2.2. Generators

The Generator classes are not meant to be directly accessed by the user. Instead, they are used as components of the UniqueConformer classes.

There are two main generator classes, RDKitGenerator and CRESTGenerator, which have roughly the same interface, but different settings. All generators accept an instance of one of the UniqueConformers classes upon initiation. This conformer set is generally expected to be empty, but is not required to be so.

The CREST method combines three separate methods to generate conformers: 1. CREST metadynamics 2. High temperature MD 3. A genetic combinatorial method that extends an existing conformer set. Each of these methods can be used separately, via their additional expert generator classes.

2.2.1. RDKitGenerator

This generator fills the conformer set of a molecule, using RDKit to call the ETKDG conformer generation approach, followed by geometry optimization with a specified AMS engine.

class RDKitGenerator(conformers=None, engine_settings=None, nproc=1, energy_threshold=None)

Machine that generates a set of unique conformers using RDKit

DOI: 10.1021/acs.jcim.5b00654

A simple example of (parallel) use:

>>> from scm.plams import Molecule
>>> from scm.plams import init, finish
>>> from scm.conformers import UniqueConformersAMS, RDKitGenerator

>>> # Set up the molecular data
>>> mol = Molecule('mol.xyz')
>>> conformers = UniqueConformersAMS()
>>> conformers.prepare_state(mol)

>>> # Set up PLAMS settings
>>> init()

>>> # Create the generator and run
>>> generator = RDKitGenerator(conformers, nproc=4)
>>> generator.generate()

>>> finish()

>>> # Write the results to file
>>> print(conformers)
>>> conformers.write()

The default engine used is the UFF engine. A different engine can be provided upon initiation.

>>> engine_settings = Settings()
>>> engine_settings.DFTB.Model = "GFN1-xTB"
>>> generator = RDKitGenerator(conformers, engine_settings=engine, nproc=4)
__init__(conformers=None, engine_settings=None, nproc=1, energy_threshold=None)

Initiates an instance of the RDKitGenerator class

  • conformers – A UniqueConformers object

  • engine_settings – PLAMS Settings object:
    >>> engine_settings = Settings()
>>> engine_settings.DFTB.Model = 'GFN1-xTB'

  • nproc – Number of processors to use in total

  • energy_threshold – Maximum accepted energy difference from lowest energy conformer

set_number_initial_conformers(ngeoms=None)

Set the number of conformers created by RDKit, before geometry optimization and filtering

  • ngeoms – The number of initial conformers created by RDKit. If not provided, this number will be generated based on the number of rotational bonds \(n\): \(3^n*self.settings.nconfs_estimation_factor\)

generate()

Generate the conformer set

static _rdkit_call_from_thread(mol, ngeoms, kwargs, queue)

Call RDKits conformer generation in parallel, via PLAMS get_conformations

are_geometries_local_minima(molecules)

Perform a PES point characterization for the molecules and return a list of booleans indicating whether the geometry is a local minimum or not

convert_key_to_camelcase(key)

Convert the key to json format

convert_key_to_underscore_case(key)

Revert back to original value, and see if it works

convert_keys_to_camelcase(settings)

Convert all keys to CamelCase (except the last json ones like _type, _default, etc)

convert_keys_to_underscore_case(settings)

Revert all the keys to the Python settings

static create_json_entry(typename, value, unique=True, choices=None, include=None)

Create a single entry

estimate_runtime(factor=1)

Provides a reasonable estimate of the runtime, based on several geometry optimizations

  • factor – Determines the number of GO optimizations that are performerd. The higher the value, the more accurate the estimate.

    The number of GOs will be 2*factor*nproc It converges, but generally to a value that is still a bit too high

get_json_settings()

Convert the settings object in self to a json style settings object

handle_input(inp, names, handle_nested_objects)

Get the settings from the input, convert to underscore case, and insert them

  • inp - Input object

  • names - The names (self._name) of all the classes in the family of classes of self

  • handle_nested_objects - Boolean specifying if there can be encapsulated objects of the same family,

    for which settings are needed

optimize_and_filter(geometries, conformers=None, level=None, name='go')

Run the geometry optimizations for the provided geometries and add to conformer set

  • geometries – List of “math:n numpy arrays containing coordinates (n*(nats,3))

  • level – The quality level of the geometry optimization convergence

  • name – The base name of the PLAMS directories in which the geometry optimizations are performed

optimize_conformers(convergence_level, name='go')

(Re)-Optimize the conformers currently in the set

  • convergence_level – One of the convergence options (‘Normal’, ‘Good’, ‘VeryGood’, ‘Excellent’)

  • name – The base name of the PLAMS directories in which the geometry optimizations are performed

pass_settings(settings, encaps_settings=False)

Set the settings object into self

read_settings(inp, names)

Get the settings for the conformers object from the input in the required format

  • inp - Input object

  • names - The classnames of all the classes in the family of classes of obj

Note: This is complicated by the fact that a single family of classes may be spread over multiple input blocks.

set_blocknames(blocknames)

Provide the relevant blocknames for the family of classes

  • blocknames – List of strings representing the input blocks relevant for this family of classes

set_convergence_quality(level=None)

Set the three levels of convergence, based on the middle one

set_max_energy(max_energy)

Determines the highest energy a created conformer can have, relative to the most stable one

set_optimizer(optimizer)

Change the optimizer of the generator object

  • optimizer – ConformerOptimizer object

set_preoptimizer(engine_settings)

Set a lower level optimizer, to be used for preoptimization

A selection will be made based on the energies, but the preoptimized geometries will not be used, so as not to rely on the low-level engine too much

set_printing_level(verbose)

Set the printing level (verbose is True of False)

set_rngseed(seed)

Set a seed for the random number generation

static time_to_timestring(time)

Convert time in seconds to a time string

to_json()

Create a json settings object from self.settings

write_geometries(geometries, name='unoptimized', filetype='xyz')

Write a set of geometries at any point

2.2.2. CRESTGenerator

This generator fills the conformer set of a molecule using the CREST method.

class CRESTGenerator(conformers=None, engine_settings=None, nproc=1, energy_threshold=None)

Machine that generates a set of conformers using the CREST workflow

A simple example of (parallel) use:

>>> from scm.plams import Molecule
>>> from scm.plams import init, finish
>>> from scm.conformers import UniqueConformersCrest, CRESTGenerator

>>> # Set up the molecular data
>>> mol = Molecule('mol.xyz')
>>> conformers = UniqueConformersCrest()
>>> conformers.prepare_state(mol)

>>> # Set up PLAMS settings
>>> init()

>>> # Create the generator and run
>>> generator = CRESTGenerator(conformers, nproc=4)
>>> generator.generate()

>>> finish()

>>> # Write the results to file
>>> print(conformers)
>>> conformers.write()

The default CREST engine used is the UFF engine. A different engine can be provided upon initiation.

>>> engine_settings = Settings()
>>> engine_settings.DFTB = 'GFN1-xTB'
>>> generator = CRESTGenerator(conformers, engine_settings=engine, nproc=4)
__init__(conformers=None, engine_settings=None, nproc=1, energy_threshold=None)

Initiates an instance of the Optimizer class

  • conformers – A UniqueConformers object

  • engine_settings – PLAMS Settings object:
    >>> engine_settings = Settings()
>>> engine_settings.DFTB.Model = 'GFN1-xTB'

  • nproc – Number of processors to use in total

  • energy_threshold – Maximum accepted energy difference from lowest energy conformer

set_optimizer(optimizer)

Change the optimizer of the generator object

  • optimizer – ConformerOptimizer object

set_printing_level(verbose)

Set the printing level (verbose is True of False)

set_shake(shake=True)

Determine if SHAKE will be used

set_rngseed(seed)

Set a seed for the random number generation

set_convergence_quality(level=None)

Set the three levels of convergence, based on the middle one

set_max_energy(max_energy)

Determines the highest energy a created conformer can have, relative to the most stable one

generate()

Generate the conformer set

static _rdkit_call_from_thread(mol, ngeoms, kwargs, queue)

Call RDKits conformer generation in parallel, via PLAMS get_conformations

are_geometries_local_minima(molecules)

Perform a PES point characterization for the molecules and return a list of booleans indicating whether the geometry is a local minimum or not

convert_key_to_camelcase(key)

Convert the key to json format

convert_key_to_underscore_case(key)

Revert back to original value, and see if it works

convert_keys_to_camelcase(settings)

Convert all keys to CamelCase (except the last json ones like _type, _default, etc)

convert_keys_to_underscore_case(settings)

Revert all the keys to the Python settings

static create_json_entry(typename, value, unique=True, choices=None, include=None)

Create a single entry

estimate_runtime(factor=1)

Provides a reasonable estimate of the runtime, based on several geometry optimizations

  • factor – Determines the number of GO optimizations that are performerd. The higher the value, the more accurate the estimate.

    The number of GOs will be 2*factor*nproc It converges, but generally to a value that is still a bit too high

get_json_settings()

Convert the settings object in self to a json style settings object

handle_input(inp, names, handle_nested_objects)

Get the settings from the input, convert to underscore case, and insert them

  • inp - Input object

  • names - The names (self._name) of all the classes in the family of classes of self

  • handle_nested_objects - Boolean specifying if there can be encapsulated objects of the same family,

    for which settings are needed

optimize_and_filter(geometries, conformers=None, level=None, name='go')

Run the geometry optimizations for the provided geometries and add to conformer set

  • geometries – List of “math:n numpy arrays containing coordinates (n*(nats,3))

  • level – The quality level of the geometry optimization convergence

  • name – The base name of the PLAMS directories in which the geometry optimizations are performed

optimize_conformers(convergence_level, name='go')

(Re)-Optimize the conformers currently in the set

  • convergence_level – One of the convergence options (‘Normal’, ‘Good’, ‘VeryGood’, ‘Excellent’)

  • name – The base name of the PLAMS directories in which the geometry optimizations are performed

pass_settings(settings, encaps_settings=False)

Set the settings object into self

read_settings(inp, names)

Get the settings for the conformers object from the input in the required format

  • inp - Input object

  • names - The classnames of all the classes in the family of classes of obj

Note: This is complicated by the fact that a single family of classes may be spread over multiple input blocks.

set_blocknames(blocknames)

Provide the relevant blocknames for the family of classes

  • blocknames – List of strings representing the input blocks relevant for this family of classes

set_preoptimizer(engine_settings)

Set a lower level optimizer, to be used for preoptimization

A selection will be made based on the energies, but the preoptimized geometries will not be used, so as not to rely on the low-level engine too much

static time_to_timestring(time)

Convert time in seconds to a time string

to_json()

Create a json settings object from self.settings

2.2.3. MetadynamicsGenerator

This generator fills the conformer set of a molecule using only CREST metadynanics, followed by geometry optimization of the stored shapshots (step 1 of the CREST approach).

class MetadynamicsGenerator(conformers=None, engine_settings=None, nproc=1, energy_threshold=None)

Machine that produces a set of conformers from CREST metadynamics simulations

A simple example of (parallel) use:

>>> from scm.plams import Molecule
>>> from scm.plams import init, finish
>>> from scm.conformers import UniqueConformersCrest, MetadynamicsGenerator

>>> # Set up the molecular data
>>> mol = Molecule('mol.xyz')
>>> conformers = UniqueConformersCrest()
>>> conformers.prepare_state(mol)

>>> # Set up PLAMS settings
>>> init()

>>> # Create the generator and run
>>> generator = MetadynamicsGenerator(conformers, nproc=4)
>>> generator.generate()

>>> finish()

>>> # Write the results to file
>>> print(conformers)
>>> conformers.write()

The default engine used is the UFF engine. A different engine can be provided upon initiation.

>>> engine_settings = Settings()
>>> engine_settings.DFTB.Model = "GFN1-xTB"
>>> generator = MetadynamicsGenerator(conformers, engine_settings=engine, nproc=4)
__init__(conformers=None, engine_settings=None, nproc=1, energy_threshold=None)

Initiates an instance of the MetadynamicsGenerator class

  • conformers – A UniqueConformers object

  • engine_settings – PLAMS Settings object:
    >>> engine_settings = Settings()
>>> engine_settings.DFTB.Model = 'GFN1-xTB'

  • nproc – Number of processors to use in total

  • energy_threshold – Maximum accepted energy difference from lowest energy conformer

set_shake(shake=True)

Determine if SHAKE will be used

set_convergence_quality(level=None)

Set the three levels of convergence, based on the middle one

generate()

Generate the conformer set

optimize_and_filter(geometries)

Run dual-level geometry optimizations for the provided geometries and add to conformer set

  • geometries – List of “math:n numpy arrays containing coordinates (n*(nats,3))

static _rdkit_call_from_thread(mol, ngeoms, kwargs, queue)

Call RDKits conformer generation in parallel, via PLAMS get_conformations

are_geometries_local_minima(molecules)

Perform a PES point characterization for the molecules and return a list of booleans indicating whether the geometry is a local minimum or not

convert_key_to_camelcase(key)

Convert the key to json format

convert_key_to_underscore_case(key)

Revert back to original value, and see if it works

convert_keys_to_camelcase(settings)

Convert all keys to CamelCase (except the last json ones like _type, _default, etc)

convert_keys_to_underscore_case(settings)

Revert all the keys to the Python settings

static create_json_entry(typename, value, unique=True, choices=None, include=None)

Create a single entry

estimate_runtime(factor=1)

Provides a reasonable estimate of the runtime, based on several geometry optimizations

  • factor – Determines the number of GO optimizations that are performerd. The higher the value, the more accurate the estimate.

    The number of GOs will be 2*factor*nproc It converges, but generally to a value that is still a bit too high

get_json_settings()

Convert the settings object in self to a json style settings object

handle_input(inp, names, handle_nested_objects)

Get the settings from the input, convert to underscore case, and insert them

  • inp - Input object

  • names - The names (self._name) of all the classes in the family of classes of self

  • handle_nested_objects - Boolean specifying if there can be encapsulated objects of the same family,

    for which settings are needed

optimize_conformers(convergence_level, name='go')

(Re)-Optimize the conformers currently in the set

  • convergence_level – One of the convergence options (‘Normal’, ‘Good’, ‘VeryGood’, ‘Excellent’)

  • name – The base name of the PLAMS directories in which the geometry optimizations are performed

pass_settings(settings, encaps_settings=False)

Set the settings object into self

read_settings(inp, names)

Get the settings for the conformers object from the input in the required format

  • inp - Input object

  • names - The classnames of all the classes in the family of classes of obj

Note: This is complicated by the fact that a single family of classes may be spread over multiple input blocks.

set_blocknames(blocknames)

Provide the relevant blocknames for the family of classes

  • blocknames – List of strings representing the input blocks relevant for this family of classes

set_max_energy(max_energy)

Determines the highest energy a created conformer can have, relative to the most stable one

set_optimizer(optimizer)

Change the optimizer of the generator object

  • optimizer – ConformerOptimizer object

set_preoptimizer(engine_settings)

Set a lower level optimizer, to be used for preoptimization

A selection will be made based on the energies, but the preoptimized geometries will not be used, so as not to rely on the low-level engine too much

set_printing_level(verbose)

Set the printing level (verbose is True of False)

set_rngseed(seed)

Set a seed for the random number generation

static time_to_timestring(time)

Convert time in seconds to a time string

to_json()

Create a json settings object from self.settings

2.2.4. MDExpander

This generator fills the conformer set of a molecule using only regular molecular dynamics, followed by geometry optimization of the stored shapshots (step 2 of the CREST approach).

class MDExpander(conformers=None, engine_settings=None, nproc=1, energy_threshold=None)

Machine that produces a set of conformers from molecular dynamics simulations (Step 2 of CREST approach)

A simple example of (parallel) use:

>>> from scm.plams import Molecule
>>> from scm.plams import init, finish
>>> from scm.conformers import UniqueConformersCrest, MDExpander

>>> # Set up the molecular data
>>> mol = Molecule('mol.xyz')
>>> conformers = UniqueConformersCrest()
>>> conformers.prepare_state(mol)

>>> # Set up PLAMS settings
>>> init()

>>> # Create the generator and run
>>> generator = MDExpander(conformers, nproc=4)
>>> generator.generate()

>>> finish()

>>> # Write the results to file
>>> print(conformers)
>>> conformers.write()

The default engine used is the UFF engine. A different engine can be provided upon initiation.

>>> engine_settings = Settings()
>>> engine_settings.DFTB.Model = "GFN1-xTB"
>>> generator = MDExpander(conformers, engine_settings=engine, nproc=4)
__init__(conformers=None, engine_settings=None, nproc=1, energy_threshold=None)

Initiates an instance of the MDExpander class

  • engine_settings – PLAMS Settings object:
    >>> engine_settings = Settings()
>>> engine_settings.DFTB.Model = 'GFN1-xTB'

  • nproc – Number of processors to use in total for the MD simulations

  • energy_threshold – Maximum accepted energy difference from lowest energy conformer

set_shake(shake=True)

Determine if SHAKE will be used

set_number_of_identical_mdruns()

Sets the number of MD runs of each temperature (default=1)

set_number_of_starting_geometries()

Set the number of conformers used to start the MD runs from (default=4)

generate()

Generate the conformer set

static _rdkit_call_from_thread(mol, ngeoms, kwargs, queue)

Call RDKits conformer generation in parallel, via PLAMS get_conformations

are_geometries_local_minima(molecules)

Perform a PES point characterization for the molecules and return a list of booleans indicating whether the geometry is a local minimum or not

convert_key_to_camelcase(key)

Convert the key to json format

convert_key_to_underscore_case(key)

Revert back to original value, and see if it works

convert_keys_to_camelcase(settings)

Convert all keys to CamelCase (except the last json ones like _type, _default, etc)

convert_keys_to_underscore_case(settings)

Revert all the keys to the Python settings

static create_json_entry(typename, value, unique=True, choices=None, include=None)

Create a single entry

estimate_runtime(factor=1)

Provides a reasonable estimate of the runtime, based on several geometry optimizations

  • factor – Determines the number of GO optimizations that are performerd. The higher the value, the more accurate the estimate.

    The number of GOs will be 2*factor*nproc It converges, but generally to a value that is still a bit too high

get_json_settings()

Convert the settings object in self to a json style settings object

handle_input(inp, names, handle_nested_objects)

Get the settings from the input, convert to underscore case, and insert them

  • inp - Input object

  • names - The names (self._name) of all the classes in the family of classes of self

  • handle_nested_objects - Boolean specifying if there can be encapsulated objects of the same family,

    for which settings are needed

optimize_and_filter(geometries, conformers=None, level=None, name='go')

Run the geometry optimizations for the provided geometries and add to conformer set

  • geometries – List of “math:n numpy arrays containing coordinates (n*(nats,3))

  • level – The quality level of the geometry optimization convergence

  • name – The base name of the PLAMS directories in which the geometry optimizations are performed

optimize_conformers(convergence_level, name='go')

(Re)-Optimize the conformers currently in the set

  • convergence_level – One of the convergence options (‘Normal’, ‘Good’, ‘VeryGood’, ‘Excellent’)

  • name – The base name of the PLAMS directories in which the geometry optimizations are performed

pass_settings(settings, encaps_settings=False)

Set the settings object into self

read_settings(inp, names)

Get the settings for the conformers object from the input in the required format

  • inp - Input object

  • names - The classnames of all the classes in the family of classes of obj

Note: This is complicated by the fact that a single family of classes may be spread over multiple input blocks.

set_blocknames(blocknames)

Provide the relevant blocknames for the family of classes

  • blocknames – List of strings representing the input blocks relevant for this family of classes

set_convergence_quality(level=None)

Set the three levels of convergence, based on the middle one

set_max_energy(max_energy)

Determines the highest energy a created conformer can have, relative to the most stable one

set_optimizer(optimizer)

Change the optimizer of the generator object

  • optimizer – ConformerOptimizer object

set_preoptimizer(engine_settings)

Set a lower level optimizer, to be used for preoptimization

A selection will be made based on the energies, but the preoptimized geometries will not be used, so as not to rely on the low-level engine too much

set_printing_level(verbose)

Set the printing level (verbose is True of False)

set_rngseed(seed)

Set a seed for the random number generation

static time_to_timestring(time)

Convert time in seconds to a time string

to_json()

Create a json settings object from self.settings

2.2.5. GCExpander

This generator extends a conformer set of a molecule using only the CREST genetic combinatorial method (GC), followed by geometry optimization of the stored shapshots (step 3 of the CREST approach).

class GCExpander(conformers=None, engine_settings=None, nproc=1, energy_threshold=None)

Machine that extends a set of conformers using genetic structure crossing

DOI: 10.1002/anie.201708266 (Supporting Information)

A simple example of (parallel) use:

>>> from scm.plams import Molecule
>>> from scm.plams import init, finish
>>> from scm.conformers import UniqueConformersCrest, GCExpander

>>> # Set up the molecular data
>>> mol = Molecule('mol.xyz')
>>> conformers = UniqueConformersCrest()
>>> conformers.prepare_state(mol)

>>> # Set up PLAMS settings
>>> init()

>>> # Create the generator and run
>>> generator = GCExpander(conformers, nproc=1)
>>> generator.generate()

>>> finish()

>>> # Write the results to file
>>> print(conformers)
>>> conformers.write()

The default engine used is the UFF engine. A different engine can be provided upon initiation.

>>> engine_settings = Settings()
>>> engine_settings.DFTB.Model = "GFN1-xTB"
>>> generator = GCExpander(conformers, engine_settings=engine, nproc=1)
__init__(conformers=None, engine_settings=None, nproc=1, energy_threshold=None)

Initiates an instance of the GCExpander class

  • conformers – A UniqueConformers object

  • engine_settings – PLAMS Settings object:
    >>> engine_settings = Settings()
>>> engine_settings.DFTB.Model = 'GFN1-xTB'

  • nproc – Number of processors to use in total

  • energy_threshold – Maximum accepted energy difference from lowest energy conformer

generate()

Generate a conformer set, based on the CREST method

set_maxgeoms(mtd_generator=None)

Set the maximum number of geometries that can be produced, based on the molecules flexibility

determine_maxgeoms(mtd_generator=None)

Determine the maximum number of geometries that can be produced, based on the molecules flexibility

get_rmsd_time()

Get the time it takes to compute a single rmsd

estimate_gctime(rmsd_time=None, nconformers=None, mtd_generator=None)

Provides a reasonable estimate of the runtime, based on the number of RMSDs to be computed

  • nconformers – A likely estimate for the number of conformers provided to the GCExpander.

    A new large set will be created from all pairs of these conformers, and that set will be capped at maxgeoms. For the new large set, pairwise RMSD values are then computed. We assume the latter is always the bottleneck.

are_geometries_local_minima(molecules)

Perform a PES point characterization for the molecules and return a list of booleans indicating whether the geometry is a local minimum or not

convert_key_to_camelcase(key)

Convert the key to json format

convert_key_to_underscore_case(key)

Revert back to original value, and see if it works

convert_keys_to_camelcase(settings)

Convert all keys to CamelCase (except the last json ones like _type, _default, etc)

convert_keys_to_underscore_case(settings)

Revert all the keys to the Python settings

static create_json_entry(typename, value, unique=True, choices=None, include=None)

Create a single entry

estimate_runtime(factor=1)

Provides a reasonable estimate of the runtime, based on several geometry optimizations

  • factor – Determines the number of GO optimizations that are performerd. The higher the value, the more accurate the estimate.

    The number of GOs will be 2*factor*nproc It converges, but generally to a value that is still a bit too high

get_json_settings()

Convert the settings object in self to a json style settings object

handle_input(inp, names, handle_nested_objects)

Get the settings from the input, convert to underscore case, and insert them

  • inp - Input object

  • names - The names (self._name) of all the classes in the family of classes of self

  • handle_nested_objects - Boolean specifying if there can be encapsulated objects of the same family,

    for which settings are needed

optimize_and_filter(geometries, conformers=None, level=None, name='go')

Run the geometry optimizations for the provided geometries and add to conformer set

  • geometries – List of “math:n numpy arrays containing coordinates (n*(nats,3))

  • level – The quality level of the geometry optimization convergence

  • name – The base name of the PLAMS directories in which the geometry optimizations are performed

optimize_conformers(convergence_level, name='go')

(Re)-Optimize the conformers currently in the set

  • convergence_level – One of the convergence options (‘Normal’, ‘Good’, ‘VeryGood’, ‘Excellent’)

  • name – The base name of the PLAMS directories in which the geometry optimizations are performed

pass_settings(settings, encaps_settings=False)

Set the settings object into self

read_settings(inp, names)

Get the settings for the conformers object from the input in the required format

  • inp - Input object

  • names - The classnames of all the classes in the family of classes of obj

Note: This is complicated by the fact that a single family of classes may be spread over multiple input blocks.

set_blocknames(blocknames)

Provide the relevant blocknames for the family of classes

  • blocknames – List of strings representing the input blocks relevant for this family of classes

set_convergence_quality(level=None)

Set the three levels of convergence, based on the middle one

set_max_energy(max_energy)

Determines the highest energy a created conformer can have, relative to the most stable one

set_optimizer(optimizer)

Change the optimizer of the generator object

  • optimizer – ConformerOptimizer object

set_preoptimizer(engine_settings)

Set a lower level optimizer, to be used for preoptimization

A selection will be made based on the energies, but the preoptimized geometries will not be used, so as not to rely on the low-level engine too much

set_printing_level(verbose)

Set the printing level (verbose is True of False)

set_rngseed(seed)

Set a seed for the random number generation

static time_to_timestring(time)

Convert time in seconds to a time string

to_json()

Create a json settings object from self.settings