icolos.core.containers package

Submodules

icolos.core.containers.compound module

class icolos.core.containers.compound.Compound(name: str = '', compound_number: Optional[int] = None)

Bases: object

This class bundles all information on a molecule and serves mainly to group enumerations.

add_enumeration(enumeration: Enumeration, auto_update: bool = True)

Add a new enumeration. If “auto_update” is True, the Compound class will be set to “self” and the enumeration_id will be set to the next free index.

add_enumerations(enumerations: List[Enumeration], auto_update: bool = True)

Add new enumerations. If “auto_update” is True, the Compound class will be set to “self” and the enumeration_id will be set to the next free index.

clear_enumerations()

empty() → bool

find_enumeration(enumeration_id: int) → Enumeration

get_compound_number() → int

get_enumeration_ids() → List[int]

get_enumerations() → List[Enumeration]

get_index_string() → str

get_name() → str

reset_all_ids()

reset_enumeration_ids()

set_compound_number(compound_number: int)

set_name(name: str)

unroll_conformers() → List[Conformer]

update_all_relations()

class icolos.core.containers.compound.Conformer(conformer: Optional[Mol] = None, conformer_id: Optional[int] = None, enumeration_object=None)

Bases: object

This class is a storage class for individual conformers associated with a given Enumeration.

add_extra_data(key: str, data)

clear_extra_data()

empty() → bool

get_compound_name() → str

get_conformer_id() → int

get_enumeration_object()

get_extra_data() → dict

get_index_string() → str

get_molecule() → Mol

set_conformer_id(conformer_id: int)

set_enumeration_object(enumeration_object)

set_molecule(conformer: Mol)

update_coordinates(path: str)

write(path: str, format_='sdf')

class icolos.core.containers.compound.Enumeration(compound_object=None, smile: str = '', molecule: Optional[Mol] = None, original_smile: Optional[str] = None, enumeration_id: Optional[int] = None)

Bases: object

This class bundles all information on an enumeration, especially all conformers generated.

add_conformer(conformer: Conformer, auto_update: bool = True)

Add a new conformer. If “auto_update” is True, the Enumeration class will be set to “self” and the conformer_id will be set to the next free index.

add_conformers(conformers: List[Conformer], auto_update: bool = True)

Add new conformers. If “auto_update” is True, the Enumeration class will be set to “self” and the conformer_id will be set to the next free index.

clean_failed_conformers()

clear_conformers()

clear_molecule()

clone_conformers() → List[Conformer]

empty() → bool

find_conformer(conformer_id: int) → Conformer

get_compound_name() → str

get_compound_object()

get_conformer_ids() → List[int]

get_conformers() → List[Conformer]

get_enumeration_id() → int

get_index_string() → str

get_molecule() → Mol

get_original_smile() → str

get_smile() → str

reset_conformer_ids()

set_compound_object(compound_object)

set_enumeration_id(enumeration_id: int)

set_molecule(molecule: Mol)

set_original_smile(original_smile: str)

set_smile(smile: str)

sort_conformers(by_tag: Union[str, List[str]], reverse: bool = True, aggregation='sum')

icolos.core.containers.compound.get_compound_by_id(compounds: List[Compound], id: int) → Compound

icolos.core.containers.compound.get_compound_by_name(compounds: List[Compound], name: str) → Compound

icolos.core.containers.compound.unroll_conformers(compounds: List[Compound]) → List[Conformer]

icolos.core.containers.compound.unroll_enumerations(compounds: List[Compound]) → List[Enumeration]

icolos.core.containers.generic module

class icolos.core.containers.generic.GenericContainer

Bases: object

Container class to hold the instances of the Generic class, separated by extension

add_file(file: GenericData)

add_files(files: List[GenericData])

clear_file_dict()

get_all_files() → Dict[str, List]

get_argument_by_extension(ext, rtn_file_object=False) → Union[GenericData, str]

get_file_by_index(index)

get_file_by_name(name)

get_file_names_by_extension(ext: str)

get_file_types()

get_files_by_extension(ext: str) → List[Optional[GenericData]]

get_flattened_files() → List[GenericData]

get_next_file_id(ext)

write_out_all_files(folder)

flattens all files in the container and writes to the specified directory

class icolos.core.containers.generic.GenericData(file_name: str, file_data=None, argument=True, file_id: Optional[int] = None, extension: Optional[str] = None)

Bases: object

Container class to hold generic data of any file type

calculate_file_size()

get_data() → Any

get_extension()

get_file_name() → str

get_id()

set_data(data)

set_extension(extension)

set_file_name(file_name)

set_id(file_id)

update_data(data)

write(path: str, join: bool = True, final_writeout: bool = False)

Handles all I/O operations for generic data. Support for handling directories and symlinks

icolos.core.containers.gmx_state module

class icolos.core.containers.gmx_state.AtomType(*, number: int, a_type: str, resi: int, res: str, atom: str, cgnr: int, charge: float, mass: float)

Bases: BaseModel

a_type: str

atom: str

cgnr: int

charge: float

mass: float

number: int

res: str

resi: int

class icolos.core.containers.gmx_state.GromacsState(*, top_lines: List = [], itps: Dict = {}, posre: Dict = {}, atomtypes: List = [], chains: List = None, forcefield: str = 'amber03', water: str = 'tip3p', system: List = [], molecules: Dict = {}, structures: Dict = {}, tprs: Dict = {}, trajectories: Dict = {}, log: Dict = {}, edr: Dict = {}, cpt: Dict = {}, ndx: List = [], properties: Dict[str, List] = {})

Bases: BaseModel

class Config

Bases: object

arbitrary_types_allowed: True

add_itp(path, files: List[str], gen_posre: bool = True) → None

add_molecule(name: str, num: int = 1)

add_posre(path, files: List[str]) → None

append_structure(path: str, file: str, sanitize=False, index: int = 0) → None

atomtypes: List

chains: List

collect_atomtypes() → List

Iterate over the itp files, strip any newly defined atomtypes, append to their own atomtypes.itp file, include this just after the forcefield include

cpt: Dict

edr: Dict

forcefield: str

generate_base_topol_file()

Generates the main topology file

generate_posre(path: str, itp_file: str, force: int = 1000)

itps: Dict

log: Dict

molecules: Dict

ndx: List

parse(path: str, file: str = 'topol.top')

Populate the fields from parsing a topol file (normally from gmx pdb2gmx) If a moleculetype has been defined in a single topology, this is separated into its own itp file

posre: Dict

properties: Dict[str, List]

set_cpt(path: str, file: str = 'state.cpt', index: int = 0)

set_edr(path: str, file: str = 'ener.edr', index: int = 0)

set_log(path: str, file: str = 'md.log', index: int = 0)

set_ndx(path: str, file: str = 'index.ndx')

set_structure(path: str, file: str = 'confout.gro', sanitize=False, index: int = 0)

set_topol(path: str, file: str = 'topol.top')

When solvate or genion produce a modified topol, read this into the topology lines

set_tpr(path: str, file: str = 'topol.tpr', index: int = 0)

set_trajectory(path: str, file: str = 'traj.xtc', index: int = 0)

structures: Dict

system: List

top_lines: List

tprs: Dict

trajectories: Dict

water: str

write_cpt(path: str, file: str = 'state.cpt', index: int = 0)

write_edr(path: str, file: str = 'ener.edr', index: int = 0)

write_log(path: str, file: str = 'md.log', index: int = 0)

write_ndx(path: str, file: str = 'index.ndx')

write_props(path: str)

writes summary of properties for all trajectories to a file

write_structure(path: str, file: str = 'confout.gro', index: int = 0)

write_topol(base_dir: str, file: str = 'topol.top')

Write a gromacs topology file, including its dependent itp files, to a dir

write_tpr(path: str, file: str = 'topol.tpr', index: int = 0)

write_trajectory(path: str, file: str = 'traj.xtc', index: int = 0)

icolos.core.containers.perturbation_map module

class icolos.core.containers.perturbation_map.Edge(*, node_from: Node = Node(node_id=None, node_hash=None, conformer=None, node_connectivity=[]), node_to: Node = Node(node_id=None, node_hash=None, conformer=None, node_connectivity=[]), total: str = None, mcs: str = None, chg: str = None, softbond: str = None, min_no_atoms: str = None, snapCoreRmsd: str = None, bidirSnapCoreRmsd: str = None, status: ParallelizationEnum = ParallelizationEnum.STATUS_SUCCESS, ddG: float = 0.0, ddG_err: float = 0.0)

Bases: BaseModel

class Config

Bases: object

arbitrary_types_allowed = True

bidirSnapCoreRmsd: str

chg: str

ddG: float

ddG_err: float

get_edge_id() → str

mcs: str

min_no_atoms: str

node_from: Node

node_to: Node

snapCoreRmsd: str

softbond: str

status: ParallelizationEnum

total: str

class icolos.core.containers.perturbation_map.Node(*, node_id: str = None, node_hash: str = None, conformer: Conformer = None, node_connectivity: List = [])

Bases: BaseModel

class Config

Bases: object

arbitrary_types_allowed = True

conformer: Optional[Conformer]

get_conformer() → Conformer

get_node_color()

get_node_hash() → str

get_node_id() → str

node_connectivity: List

node_hash: str

node_id: str

set_conformer(conformer: Conformer) → None

set_node_id(node_id: str)

class icolos.core.containers.perturbation_map.PerturbationMap(*, nodes: List[Node] = [], edges: List[Edge] = [], hash_map: Dict = {}, compounds: List[Compound] = [], protein: GenericData = None, vmap_output: IFrame = None, replicas: int = 3, node_df: DataFrame = None, strict_execution: str = False, hub_conformer: Conformer = None)

Bases: BaseModel

Hold a map construction parsed from a csv (probabably from a parsed schrodinger log file or something) and provide some utility methods for doing pmx calculations on the edges

class Config

Bases: object

arbitrary_types_allowed = True

add_edge(edge: Edge) → None

add_node(node: Node) → None

compounds: List[Compound]

edges: List[Edge]

generate_from_lomap_output(file: str)

generate_star_map() → None

Generates a star topology using a single hub compound

get_edge_by_id(id: str) → Optional[Edge]

Lookup edge by identifier

Parameters:

id (str) – edge hash to retrieve

Return Optional[Edge]:

Return the edge if found, else None

get_edges(alive_only=True) → List[Edge]

get_nodes() → List[Node]

get_protein() → GenericData

hash_map: Dict

hub_conformer: Conformer

node_df: DataFrame

nodes: List[Node]

parse_map_file(file_path: str) → None

Parse map from Schrodinger’s fep_mapper log file, build internal graph representation + attach properties from fmp_stats, if provided

Parameters:

file_path (str) – path to the fep_mapper.log file to extract the perturbation map from

protein: GenericData

replicas: int

strict_execution: str

visualise_perturbation_map(write_out_path: str) → None

Generate NetworkX graph for the parsed perturbation map

Parameters:

write_out_path (str) – directory to write output file

vmap_output: IFrame

Module contents