chemaxon.calculations

This package contains various calculations for molecules.

GitHub examples: https://github.com/ChemAxon/python-examples/blob/main/jupyter/02_calculators.ipynb

@typecheck(Molecule)
def herg_classification( mol: chemaxon.Molecule) -> HergClassResult:

Predict hERG class inhibition.

For more information: https://docs.chemaxon.com/latest/calculators_herg.html#the-herg-classification-model

Parameters
Returns

HergClassResult - Result object containing classification

@dataclass(frozen=True)
class HergClassResult:

hERG inhibition prediction result object

HergClassResult( classification: HergClassificationType, error: list[HergClassificationType], probabilities: dict[HergClassificationType, int])
classification: HergClassificationType

Classification result.

error: list[HergClassificationType]

The value of the error component

probabilities: dict[HergClassificationType, int]

Probabilities for each classification type.

class HergClassificationType(enum.IntEnum):

Enumeration for hERG inhibition classification types used in the hERG classification predictor.

@typecheck(Molecule)
def herg_activity( mol: chemaxon.Molecule) -> HergActivityResult:

Predict hERG inhibition activity.

For more information: https://docs.chemaxon.com/latest/calculators_herg.html#the-herg-activity-model

Parameters
Returns

int - Predicted hERG inhibition activity

@dataclass(frozen=True)
class HergActivityResult:

hERG inhibition activity prediction result object

HergActivityResult(value: float, error: float)
value: float

Predicted hERG inhibition activity.

error: float

Error of the predicted hERG inhibition activity.

@typecheck(Molecule)
def bbb(mol: chemaxon.Molecule) -> BbbResult:

Predict blood-brain barrier penetration.

For more information: https://docs.chemaxon.com/latest/calculators_bbb-score.html#blood-brain-barrier-bbb-score-predictor

Parameters
Returns

BbbResult - Predicted blood-brain barrier scores by properties and the overall (multiplied) score

@dataclass(frozen=True)
class BbbResult:

Blood-brain barrier penetration prediction result object

BbbResult( score: float, properties: dict[BbbFunction, BbbProperty])
score: float

Multiplied predicted blood-brain barrier penetration score of the property scores.

properties: dict[BbbFunction, BbbProperty]

Predicted blood-brain barrier penetration scores for each property used in the prediction, as well as the predicted value for each property.

class BbbFunction(enum.IntEnum):

Enumeration for blood-brain barrier penetration properties used in the BBB predictor.

ARO_R = <BbbFunction.ARO_R: 0>

Number of aromatic rings.

HA = <BbbFunction.HA: 1>

Number of heavy atoms.

MWHBN = <BbbFunction.MWHBN: 2>

MW^(-0.5) * (HBN), where HBN = HBA + HBD.

TPSA = <BbbFunction.TPSA: 3>

Topological polar surface area.

PKA = <BbbFunction.PKA: 4>

PKa calculation for bbb score.

@dataclass(frozen=True)
class BbbProperty:

Blood-brain barrier penetration prediction property object

BbbProperty(value: float, multiplied_score: float, score: float)
value: float

Predicted value for the property.

multiplied_score: float

Predicted score for the property, calculated by multiplying the predicted value with the corresponding coefficient for the property.

score: float

Predicted score for the property.

@typecheck(Molecule)
def cns_mpo( mol: chemaxon.Molecule) -> CnsMpoResult:

Predict CNS MPO score.

For more information: https://docs.chemaxon.com/latest/calculators_cns-mpo-score.html

Parameters
Returns

CnsMpoResult - Predicted CNS MPO score and scores by properties

@dataclass(frozen=True)
class CnsMpoResult:

CNS MPO score prediction result object

CnsMpoResult( score: float, properties: dict[CnsMpoFunction, CnsMpoProperty])
score: float

Predicted CNS MPO score calculated by summing the predicted scores of the properties.

properties: dict[CnsMpoFunction, CnsMpoProperty]

Predicted CNS MPO scores for each property used in the prediction, as well as the predicted value for each property.

class CnsMpoFunction(enum.IntEnum):

Enumeration for CNS MPO score prediction properties used in the CNS MPO predictor.

HBD = <CnsMpoFunction.HBD: 0>

Number of hydrogen bond donors.

LOGD = <CnsMpoFunction.LOGD: 1>

Calculated distribution coefficient az pH 7.4.

LOGP = <CnsMpoFunction.LOGP: 2>

Lipophilicity, calculated partition coefficient.

MW = <CnsMpoFunction.MW: 3>

Molecular weight.

PKA = <CnsMpoFunction.PKA: 4>

Most basic center (pKa).

TPSA = <CnsMpoFunction.TPSA: 5>

Topological polar surface area.

@dataclass(frozen=True)
class CnsMpoProperty:

CNS MPO score prediction property

CnsMpoProperty(value: float, score: float)
value: float

Predicted value for the property.

score: float

Predicted score for the property.

@typecheck(Molecule)
def formal_charge(mol: chemaxon.Molecule) -> int:

Charge calculation.

Link: https://docs.chemaxon.com/display/docs/calculators_charge-plugin.html

Parameters
Returns

int - The formal charge

@typecheck(Molecule)
def charge_by_atoms( mol: chemaxon.Molecule) -> ChargeResult:

Charge calculation.

Link: https://docs.chemaxon.com/display/docs/calculators_charge-plugin.html

Parameters
Returns

ChargeResult

@dataclass(frozen=True)
class ChargeResult:

ChargeResult class for storing charge calculation results.

This class contains the results of charge calculations including formal charges and total charges for atoms in a molecule.

ChargeResult( formal_charge: int, charge_values: list[ChargeValue])
formal_charge: int

The calculated formal charge value for the whole molecule

charge_values: list[ChargeValue]

List of ChargeValue objects containing charge values for individual atoms

class ChargeValue(typing.NamedTuple):

ChargeValue class for storing charge values for individual atoms.

ChargeValue(atom_index: int, formal_charge: int, total_charge: float)

Create new instance of ChargeValue(atom_index, formal_charge, total_charge)

atom_index: int

Index of the atom

formal_charge: int

Formal charge value of the atom

total_charge: float

Total charge value of the atom

@typecheck(Molecule, ConformerOptions)
def conformers( mol: chemaxon.Molecule, options: ConformerOptions = <ConformerOptions object>) -> list[ConformerResult]:

Calculate conformers for a molecule. Conformational isomerism is a form of isomerism that describes the phenomenon of molecules with the same structural formula having different 3D structure. Conformations are transformed into each other by rotations along rotatable bonds. Different conformations might have different energies.

Link: https://docs.chemaxon.com/latest/calculators_conformer-plugin.html

Parameters
Returns

list[ConformerResult] - The list of conformers and their energies, sorted by energy in ascending order.

class ConformerOptions:

Class representing the options for a conformer generation calculation.

force_field: ConformerForceField = <ConformerForceField.DREIDING: 0>

Force field to use for conformer generation. Default is ConformerForceField.DREIDING.

energy_unit: ConformerEnergyUnit = <ConformerEnergyUnit.KCAL_PER_MOL: 0>

Unit for energy values. Default is ConformerEnergyUnit.KCAL_PER_MOL.

optimization_limit: ConformerOptimization = <ConformerOptimization.NORMAL: 1>

Optimization limit. Default is ConformerOptimization.NORMAL.

max_number_of_conformers: int = 100

Maximum number of conformers to generate. Default is 100.

diversity_limit: float = 0.1

Diversity limit for conformer selection. Default is 0.1.

time_limit: int = 900

Time limit for conformer generation in seconds. Default is 900.

calculate_lowest_energy_conformer: bool = False

If True, calculate the lowest energy conformer. Default is False.

prehydrogenize: bool = False

If True, pre-hydrogenize the molecule. Default is False.

hyperfine: bool = False

If True, include hyperfine structure. Default is False.

optimize_multi_fragment: bool = False

If True, optimize multi-fragment molecules with MMFF94. Default is False.

class ConformerForceField(enum.IntEnum):

The supported types of force fields for the conformer generation calculation.

DREIDING = <ConformerForceField.DREIDING: 0>

DREIDING force field, a generic force field for molecular mechanics simulations.

MMFF94 = <ConformerForceField.MMFF94: 1>

Merck Molecular force field, a widely used force field for small molecules.

class ConformerEnergyUnit(enum.IntEnum):

The supported types of energy units for the conformer generation calculation.

KCAL_PER_MOL = <ConformerEnergyUnit.KCAL_PER_MOL: 0>

kcal/mol, a common unit for energy in molecular mechanics simulations. Note that 1 kcal/mol is approximately equal to 4.184 kJ/mol.

KJ_PER_MOL = <ConformerEnergyUnit.KJ_PER_MOL: 1>

kJ/mol, a common unit for energy in molecular mechanics simulations.

class ConformerOptimization(enum.IntEnum):

The supported types of optimization limits for the conformer generation calculation.

VERY_LOOSE = <ConformerOptimization.VERY_LOOSE: 0>

Very loose optimization limit, allowing for a larger number of conformers to be generated with less strict energy minimization.

NORMAL = <ConformerOptimization.NORMAL: 1>

Normal optimization limit, providing a balance between the number of conformers generated and the quality of energy minimization.

STRICT = <ConformerOptimization.STRICT: 2>

Strict optimization limit, resulting in fewer conformers being generated but with more rigorous energy minimization.

VERY_STRICT = <ConformerOptimization.VERY_STRICT: 3>

Very strict optimization limit, producing a small number of conformers with very rigorous energy minimization.

class ConformerResult(typing.NamedTuple):

Class representing the result of a conformer generation for a single conformer.

ConformerResult(conformer: chemaxon.Molecule, energy: float)

Create new instance of ConformerResult(conformer, energy)

conformer: chemaxon.Molecule

The actual conformer.

energy: float

Energy of the conformer.

@typecheck(Molecule, str, str)
def evaluate( mol: chemaxon.Molecule, expression: str, mol_format: str = '') -> str:

Evaluate chemical terms function.

Chemaxon's Chemical Terms is a language for adding advanced chemical intelligence to cheminformatics applications.

Chemical Terms provides chemistry and mathematical functions including:

  • property predictions
  • functional group recognition
  • isomer enumeration
  • conformer selection
  • ring and distance based topological functions
  • other electronical, steric and structural functions

Link: https://docs.chemaxon.com/display/docs/chemical-terms_index.html

Parameters
  • mol: chemaxon.Molecule - Input molecule
  • expression: str - chemterms expression
  • mol_format: str - (optional) format of the result molecule if the result is a molecule or molecule array (default format is smiles)
Returns

str - result

@typecheck(Molecule, HlbMethod)
def hlb( mol: chemaxon.Molecule, method: HlbMethod = <HlbMethod.CHEMAXON: 0>) -> float:

Hydrophilic-lipophilic balance calculation.

The hydrophilic-lipophilic balance number (HLB number) measures the degree of a molecule being hydrophilic or lipophilic. This number is calculated based on identifying various hydrophil and liphophil regions in the molecule. This number is a commonly used descriptor in any workflow in which lipid based delivery can be an option (e.g. lipid-based drug delivery, cosmetics).

Link: https://docs.chemaxon.com/display/docs/calculators_hlb-predictor.html

Parameters
  • mol: chemaxon.Molecule - Input molecule
  • method: HlbMethod - This option is for selecting the applied method for the HLB calculation:
    • CHEMAXON (default)
    • DAVIES
    • GRIFFIN
    • REQUIRED
Returns

float - The calculated HLB value

class HlbMethod(enum.IntEnum):

The supported methods for the HLB calculation.

CHEMAXON = <HlbMethod.CHEMAXON: 0>

This is a consensus method based on the other two methods with optimal weights

DAVIES = <HlbMethod.DAVIES: 1>

This is an extended version of the Davies method

GRIFFIN = <HlbMethod.GRIFFIN: 2>

This is an extended version of the Griffin method

REQUIRED = <HlbMethod.REQUIRED: 3>

Experimental value, characteristic to the compound used in (O/W) emulsions

@typecheck(Molecule, PhRange, bool)
def isoelectric_point( mol: chemaxon.Molecule, ph_range: PhRange = PhRange(lower_bound=0, upper_bound=14.0, step=0.5), consider_tautomerization: bool = False) -> IsoelectricPointResult:

Calculate the isoelectric point of a molecule.

Additional details: https://docs.chemaxon.com/latest/calculators_isoelectric-point-pi-calculation.html

Parameters
  • mol: chemaxon.Molecule - The molecule for which the isoelectric point will be calculated.
  • ph_range: PhRange - pH values on which the charge distribution will be calculated.
  • consider_tautomerization: bool - Whether to consider tautomerization during the calculation.
Returns

IsoelectricPointResult - The result object containing the isoelectric point and charge distributions. If the provided pH range does not include the isoelectric point, Nan is returned as the isoelectric point.

@dataclass(frozen=True)
class IsoelectricPointResult:

Isoelectric point calculator result object

IsoelectricPointResult( isoelectric_point: float, charge_distributions: list[IsoelectricChargeResult])
isoelectric_point: float

The isoelectric point of the molecule

charge_distributions: list[IsoelectricChargeResult]

The charge distribution of the molecule at different pH values.

class IsoelectricChargeResult(typing.NamedTuple):

Charge distribution result object

IsoelectricChargeResult(charge: float, ph: float)

Create new instance of IsoelectricChargeResult(charge, ph)

charge: float

The charge of the molecule at a specific pH value.

ph: float

The pH value at which the charge is calculated.

def logd( mol: chemaxon.Molecule, ph: float = 7.4, method: LogPMethod = <LogPMethod.CONSENSUS: 0>, consider_tautomerization: bool = False) -> float:

logD calculation.

Compounds having ionizable groups exist in solution as a mixture of different ionic forms. The ionization of those groups, thus the ratio of the ionic forms depends on the pH. Since logP describes the hydrophobicity of one form only, the apparent logP value can be different. The logD represents the octanol-water coefficient of compounds at a given pH value.

Link: https://docs.chemaxon.com/display/docs/calculators_logd-plugin.html

Parameters
  • mol: chemaxon.Molecule - Input molecule
  • ph: float - Calculates logD value at this pH
  • method: LogPMethod - This option is for selecting the applied method for the logP prediction:
    • CONSENSUS
    • CHEMAXON
  • consider_tautomerization: bool - In case of tautomer structures, all dominant tautomers at the given pH are taken into account during the logD calculation
Returns

float - The calculated logD value

@typecheck(Molecule, PhRange, LogPMethod, bool)
def logd_ph_range( mol: chemaxon.Molecule, ph_range: PhRange = PhRange(lower_bound=7.4, upper_bound=7.4, step=1.0), method: LogPMethod = <LogPMethod.CONSENSUS: 0>, consider_tautomerization: bool = False) -> list[LogDResult]:

logD calculation on a range of ph values.

Parameters
  • mol: chemaxon.Molecule - Input molecule
  • ph_range: PhRange - Calculates logD value at these pH values
  • method: LogPMethod - This option is for selecting the applied method for the logP prediction:
    • CONSENSUS
    • CHEMAXON
  • consider_tautomerization: bool - In case of tautomer structures, all dominant tautomers at the given pH are taken into account during the logD calculation
Returns

list[LogDResult] - The calculated logD values for the given pH range as a list of LogDResult objects.

class LogDResult(typing.NamedTuple):

LogD calculator result object

LogDResult(ph: float, logd: float)

Create new instance of LogDResult(ph, logd)

ph: float

pH value for which logD value is specified.

logd: float

logD value for the given pH value.

@typecheck(Molecule, LogPMethod, float, float, bool, float | None)
def logp( mol: chemaxon.Molecule, method: LogPMethod = <LogPMethod.CONSENSUS: 0>, anion: float = 0.1, kation: float = 0.1, consider_tautomerization: bool = False, ph: float = None) -> float:

logP calculation.

The logp function calculates the logarithm of the octanol/water partition coefficient (logP), which is used in QSAR analysis and rational drug design as a measure of molecular lipophylicity/hydrophobicity.

Link: https://docs.chemaxon.com/display/docs/calculators_logp-plugin.html

Parameters
  • mol: chemaxon.Molecule - Input molecule
  • method: LogPMethod - This option is for selecting the applied method for the logP prediction:
    • CONSENSUS: Consensus model built on the Chemaxon and Klopman et al. models and the PhysProp database
    • CHEMAXON: Chemaxon's own logP model, which is based on the VG method
  • anion: float - Cl- concentration
  • kation: float - Na+ K+ concentration
  • consider_tautomerization: bool - In case of tautomer structures, all dominant tautomers at the given pH are taken into account during the logP calculation
  • ph: float - If set, calculates logP value at this pH
Returns

float - The calculated logP

@typecheck(Molecule, LogPMethod, float, float, bool, (float, None))
def logp_by_atoms( mol: chemaxon.Molecule, method: LogPMethod = <LogPMethod.CONSENSUS: 0>, anion: float = 0.1, kation: float = 0.1, consider_tautomerization: bool = False, ph: float = None) -> LogPResult:

logP by atom calculation.

The logp function calculates the logarithm of the octanol/water partition coefficient (logP), which is used in QSAR analysis and rational drug design as a measure of molecular lipophylicity/hydrophobicity.

Link: https://docs.chemaxon.com/display/docs/calculators_logp-plugin.html

Parameters
  • mol: chemaxon.Molecule - Input molecule
  • method: LogPMethod - This option is for selecting the applied method for the logP prediction:
    • CONSENSUS: Consensus model built on the Chemaxon and Klopman et al. models and the PhysProp database
    • CHEMAXON: Chemaxon's own logP model, which is based on the VG method
  • anion: float - Cl- concentration
  • kation: float - Na+ K+ concentration
  • consider_tautomerization: bool - In case of tautomer structures, all dominant tautomers at the given pH are taken into account during the logP calculation
  • ph: float - If set, calculates logP value at this pH
Returns

LogPResult - The calculated logP

@dataclass(frozen=True)
class LogPResult:

LogPResult

LogPResult( logp: float, logp_values: list[AtomLogPResult])
logp: float

The calculated logp value

logp_values: list[AtomLogPResult]

logp values for every atom.

class LogPMethod(enum.IntEnum):

The supported methods for the logP calculation.

CONSENSUS = <LogPMethod.CONSENSUS: 0>

Consensus model built on the Chemaxon and Klopman et al. models and the PhysProp database

CHEMAXON = <LogPMethod.CHEMAXON: 1>

Chemaxon's own logP model, which is based on the VG method

class AtomLogPResult(typing.NamedTuple):

Result for a single atom's logP contribution.

AtomLogPResult(atom_index: int, logp: float)

Create new instance of AtomLogPResult(atom_index, logp)

atom_index: int

The atom index

logp: float

The logP contribution for this atom

@typecheck(Molecule, float, bool, bool)
def major_microspecies( mol: chemaxon.Molecule, ph: float = 7.4, take_major_tautomeric_form: bool = False, keep_explicit_hydrogens: bool = False) -> chemaxon.Molecule:

Major Microspecies calculation.

The Major Microspecies determines the major (de)protonated form of the molecule at a specified pH.

Link: https://docs.chemaxon.com/display/docs/calculators_major-microspecies-plugin.html

Parameters
  • mol: chemaxon.Molecule - Input molecule
  • ph: float - Calculates major microspecies at this pH
  • take_major_tautomeric_form: bool - If major tautomeric form should be taken
  • keep_explicit_hydrogens: bool - If explicit hydrogens should be kept on the result molecule
Returns

chemaxon.Molecule - Major microspecies molecule

@dataclass
class PhRange:

Class representing pH range. The range goes from lower_bound to upper_bound (inclusive) with the step size of step.

PhRange(lower_bound: float, upper_bound: float, step: float)
lower_bound: float

Lower bound of the pH range.

upper_bound: float

Inclusive upper bound of the pH range.

step: float

Step size for the pH range.

@typecheck(Molecule, bool, bool, bool, float, float, int, int, float, RequiredPkaType)
def pka( mol: chemaxon.Molecule, consider_tautomerization: bool = False, calculate_micro: bool = False, use_large_model: bool = False, min_basic: float = -10.0, max_acidic: float = 20.0, number_of_acidic_values: int = 2, number_of_basic_values: int = 2, temperature: float = 298, required_pka_type: RequiredPkaType = <RequiredPkaType.PKA: 2>) -> PkaResult:

pKa calculation.

Most molecules contain some specific functional groups likely to lose or gain proton(s) under specific circumstances. Each equilibrium between the protonated and deprotonated forms of the molecule can be described with a constant value called p K a. The pka function calculates the pKa values of the molecule based on its partial charge distribution.

Link: https://docs.chemaxon.com/display/docs/calculators_pka-plugin.html

Parameters
  • mol: chemaxon.Molecule - Input molecule
  • consider_tautomerization: bool - Whether to consider tautomerization and resonance during pKa calculation
  • calculate_micro: bool - Whether to calculate micro-pKa values. In case of false, macro-pKa values will be calculated.
  • use_large_model: bool - Whether to use large pKa model.
    • small: optimized for at most 8 ionizable atoms
    • large: optimized for a large number of ionizable atoms
  • min_basic: float - Minimum basic pKa value to be considered
  • max_acidic: float - Maximum acidic pKa value to be considered
  • number_of_acidic_values: int - Number of acidic pKa values to be displayed
  • number_of_basic_values: int - Number of basic pKa values to be displayed
  • temperature: float - Temperature in Kelvin
Returns

PkaResult

@dataclass(frozen=True)
class PkaResult:

PkaResult

PkaResult( pka_values: list[PkaValue], mol: chemaxon.Molecule)
pka_values: list[PkaValue]

List of atomic pka values

mol: chemaxon.Molecule

The input structure extended by pka values as atomic properties

def acidic_values(self) -> list[PkaValue]:

Returns acidic pka values sorted by their value in ascending order

def basic_values(self) -> list[PkaValue]:

Returns basic pka values sorted by their value in descending order

def min_acidic(self) -> PkaValue:

Returns the acidic pka value with the lowest value

def max_basic(self) -> PkaValue:

Returns the basic pka value with the highest value

class PkaValue(typing.NamedTuple):

PkaValue

PkaValue( atom_index: int, pka_type: PkaType, value: float)

Create new instance of PkaValue(atom_index, pka_type, value)

atom_index: int

Index of the atom

pka_type: PkaType

Pka type

value: float

Pka value

class PkaType(enum.IntEnum):

pKa types of the calculated pKa values. This is the type of the pKa function's result.

ACIDIC = <PkaType.ACIDIC: 0>

Acidic pKa value

BASIC = <PkaType.BASIC: 1>

Basic pKa value

class RequiredPkaType(enum.IntEnum):

Pka types to be calculated. This is the input option for the pka function.

ACIDIC = <RequiredPkaType.ACIDIC: 0>

Calculate only acidic pKa values

BASIC = <RequiredPkaType.BASIC: 1>

Calculate only basic pKa values

PKA = <RequiredPkaType.PKA: 2>

Calculate both acidic and basic pKa values

@typecheck(Molecule, float)
def polarizability(mol: chemaxon.Molecule, ph: float = -1) -> float:

Polarizability calculation.

Polarizability is the relative tendency of an electron cloud (a charge distribution) of a molecule to be distorted by an external electric field. The more stable an ionized (charged) site is the more polarizable its vicinity is. Atomic polarizability is altered by partial charges of atoms. The polarizability function is able to calculate the atomic and molecular polarizability values.

Link: https://docs.chemaxon.com/display/docs/calculators_polarizability-plugin.html

Parameters
  • mol: chemaxon.Molecule - Input molecule
  • ph: float - Calculates polarizability value at this pH. Optional, skip this if you want to calculate polarizability for the input molecule as it is
Returns

float - polarizability

@typecheck(Molecule, float)
def atomic_polarizability( mol: chemaxon.Molecule, ph: float = -1) -> PolarizabilityResult:

Atomic Polarizability calculation.

Polarizability is the relative tendency of an electron cloud (a charge distribution) of a molecule to be distorted by an external electric field. The more stable an ionized (charged) site is the more polarizable its vicinity is. Atomic polarizability is altered by partial charges of atoms. The polarizability function is able to calculate the atomic and molecular polarizability values.

Link: https://docs.chemaxon.com/display/docs/calculators_polarizability-plugin.html

Parameters
  • mol: chemaxon.Molecule - Input molecule
  • ph: float - Calculates polarizability value at this pH. Optional, skip this if you want to calculate polarizability for the input molecule as it is
Returns

PolarizabilityResult

@dataclass(frozen=True)
class PolarizabilityResult:

PolarizabilityResult

PolarizabilityResult( molecular_polarizability: float, polarizability_values: list[PolarizabilityValue])
molecular_polarizability: float

Calculated molecular polarizability value

polarizability_values: list[PolarizabilityValue]

Atomic polarizability values

class PolarizabilityValue(typing.NamedTuple):

Result for a single atom's polarizability.

PolarizabilityValue(atom_index: int, polarizability: float)

Create new instance of PolarizabilityValue(atom_index, polarizability)

atom_index: int

The atom index

polarizability: float

The polarizability value for this atom

@typecheck(Molecule, (float, None), SolubilityUnit)
def solubility( mol: chemaxon.Molecule, ph: float = None, unit: SolubilityUnit = <SolubilityUnit.LOG_S: 0>) -> float:

Solubility calculation.

Solubility predictor calculates the aqueous solubility of a compound based on its structure. It is able to calculate two types of solubility: intrinsic and pH-dependent solubility.

The intrinsic solubility (usually denoted as logS0) of an ionizable compound is the solubility that can be measured after an equilibrium of solvation between the dissolved and the solid state is reached at a pH where the compound is fully neutral.

The pH of a solution affects the ionization of the dissolved compound, shifting its solvation equilibrium. With increasing ionization solubility increases compared to the intrinsic solubility.

Link: https://docs.chemaxon.com/latest/calculators_solubility-predictor.html

Parameters
Returns

float - solubility in the specified unit

@typecheck(Molecule, PhRange, SolubilityUnit)
def solubility_ph_range( mol: chemaxon.Molecule, ph_range: PhRange = PhRange(lower_bound=0.0, upper_bound=14.0, step=1.0), unit: SolubilityUnit = <SolubilityUnit.LOG_S: 0>) -> list[SolubilityResult]:

Solubility calculation in pH range.

Solubility predictor calculates the aqueous solubility of a compound based on its structure. It is able to calculate two types of solubility: intrinsic and pH-dependent solubility.

The pH of a solution affects the ionization of the dissolved compound, shifting its solvation equilibrium. With increasing ionization solubility increases compared to the intrinsic solubility.

This function calculates the pH-dependent solubility in the provided pH range with the provided step size. The result is an array of solubility values in the specified unit.

Link: https://docs.chemaxon.com/latest/calculators_solubility-predictor.html

Parameters
Returns

list[SolubilityResult] - list of solubility results with pH values

class SolubilityUnit(enum.IntEnum):

The supported types of units for the solubility result.

LOG_S = <SolubilityUnit.LOG_S: 0>

Solubility is expressed in base-10 logarithm unit.

MG_PER_ML = <SolubilityUnit.MG_PER_ML: 1>

Solubility is expressed in mg/ml unit.

MOL_PER_L = <SolubilityUnit.MOL_PER_L: 2>

Solubility is expressed in mol/l unit.

class SolubilityResult(typing.NamedTuple):

Solubility calculation result object containing the solubility value with pH.

SolubilityResult(solubility: float, ph: float)

Create new instance of SolubilityResult(solubility, ph)

solubility: float

Solubility value in the specified unit.

ph: float

pH value for which the solubility is specified.

@typecheck(Molecule, bool, int, TautomerAdvancedOptions)
def all_tautomers( mol: chemaxon.Molecule, normal: bool = False, max_tautomers: int = 1000, options: TautomerAdvancedOptions = <TautomerAdvancedOptions object>) -> list[chemaxon.Molecule]:

All tautomer generation. This function generates all tautomers of the input molecule. The tautomers are generated in their original form by default, but they can also be generated in their normal form. The maximum number of tautomers to be generated can be specified.

Link: https://docs.chemaxon.com/latest/calculators_tautomer-generation-plugin.html

Parameters
  • mol: chemaxon.Molecule - Input molecule.
  • normal: bool - If True, the tautomers are generated in their normal form. If False, the tautomers are generated in their original form. Default is False.
  • max_tautomers: int - Maximum number of tautomers to be generated. Default is 1000.
  • options: TautomerAdvancedOptions - Advanced options for tautomer generation. Default is TautomerAdvancedOptions().
Returns

list[Molecule] - list of tautomers as Molecule objects.

@typecheck(Molecule, (float, None), int, TautomerAdvancedOptions)
def dominant_tautomer_distribution( mol: chemaxon.Molecule, ph: float = None, max_tautomers: int = 1000, options: TautomerAdvancedOptions = <TautomerAdvancedOptions object>) -> list[DominantTautomerResult]:

Dominant tautomer distributions. This function generates the dominant tautomer distribution of the input molecule. The pH can be specified to generate the tautomers at a specific pH, or it can be generated without considering pH. The maximum number of tautomers to be generated can be specified.

Link: https://docs.chemaxon.com/latest/calculators_tautomer-generation-plugin.html

Parameters
  • mol: chemaxon.Molecule - Input molecule.
  • ph: float - If specified, the tautomers are generated at this pH. If not specified, the tautomers are generated without considering pH. Default is None.
  • max_tautomers: int - Maximum number of tautomers to be generated. Default is 1000.
  • options: TautomerAdvancedOptions - Advanced options for tautomer generation. Default is the default TautomerAdvancedOptions instance.
Returns

list[DominantTautomerResult] - list of dominant tautomer results.

@typecheck(Molecule, bool, TautomerAdvancedOptions)
def canonical_tautomer( mol: chemaxon.Molecule, normal: bool = False, options: TautomerAdvancedOptions = <TautomerAdvancedOptions object>) -> chemaxon.Molecule:

Canonical tautomer generation. This function generates the canonical tautomer of the input molecule. The tautomers are generated in their original form by default, but they can also be generated in their normal form. The maximum number of tautomers to be generated can be specified. The canonical tautomer is the first tautomer in the list of tautomers generated by the all_tautomers function, which is the tautomer with the highest distribution. The canonical tautomer is not necessarily the most stable tautomer, but it is a representative tautomer that can be used for various purposes, such as structure searching and database indexing.

Link: https://docs.chemaxon.com/latest/calculators_tautomer-generation-plugin.html

Parameters
  • mol: chemaxon.Molecule - Input molecule.
  • normal: bool - If True, the tautomers are generated in their normal form. If False, the tautomers are generated in their original form. Default is False.
  • options: TautomerAdvancedOptions - Advanced options for tautomer generation. Default is the default TautomerAdvancedOptions instance.
Returns

chemaxon.Molecule - the canonical tautomer as Molecule object.

@typecheck(Molecule, (float, None), TautomerAdvancedOptions)
def major_tautomer( mol: chemaxon.Molecule, ph: float = None, options: TautomerAdvancedOptions = <TautomerAdvancedOptions object>) -> chemaxon.Molecule:

Major tautomer generation. This function generates the major tautomer of the input molecule at a specific pH. The major tautomer is the tautomer with the highest distribution at the specified pH. The pH can be specified to generate the tautomers at a specific pH, or it can be generated without considering pH.

Link: https://docs.chemaxon.com/latest/calculators_tautomer-generation-plugin.html

Parameters
  • mol: chemaxon.Molecule - Input molecule.
  • ph: float - If specified, the tautomers are generated at this pH. If not specified, the tautomers are generated without considering pH. Default is None.
Returns

Molecule - the major tautomer as Molecule object.

class TautomerAdvancedOptions:

TautomerAdvancedOptions class for configuring advanced tautomer generation options.

precision: Optional[int] = None

Precision for tautomer generation. If not specified, the default precision is used. Default is None.

path_length: Optional[int] = None

Maximum allowed length of the tautomerization path in chemical bonds. If not specified, the default path length is used. Default is None.

protect_aromaticity: bool = True

If True, aromaticity is protected during tautomer generation. Default is True.

protect_charge: bool = True

If True, charged atom is maintain their charge during tautomer generation. Default is True.

exclude_antiaromatic_compounds: bool = True

If True, antiaromatic ring systems are excluded from tautomer generation. Default is True.

protect_double_bond_stereo: bool = False

If True, all double bond with stereo information remain intact during tautomer generation. Default is False.

protect_all_tetrahedral_centers: bool = False

If True, tetrahedral centers are not included in tautomer generation. Default is False.

protect_labeled_tetrahedral_centers: bool = False

If True, stereo centers labeled with chiral flag or MDL Enhanced Stereo Representation flag will not be included in tautomer generation. Default is False.

protect_ester_groups: bool = True

If True, ester groups are protected during tautomer generation. Default is True.

allow_ring_chain: bool = False

If True, Ring-chain tautomers are allowed during tautomer generation. Default is False.

class DominantTautomerResult(typing.NamedTuple):

Result for a single dominant tautomer with its distribution.

DominantTautomerResult(tautomer: chemaxon.Molecule, distribution: float)

Create new instance of DominantTautomerResult(tautomer, distribution)

tautomer: chemaxon.Molecule

The tautomer molecule

distribution: float

The distribution value for this tautomer