ScanEnumerator

pydantic model openff.qcsubmit.workflow_components.ScanEnumerator[source]

This module will tag any matching substructures for scanning, useful for torsiondrive datasets.

Show JSON schema

{
   "title": "ScanEnumerator",
   "description": "This module will tag any matching substructures for scanning, useful for torsiondrive datasets.",
   "type": "object",
   "properties": {
      "type": {
         "title": "Type",
         "default": "ScanEnumerator",
         "enum": [
            "ScanEnumerator"
         ],
         "type": "string"
      },
      "torsion_scans": {
         "title": "Torsion Scans",
         "description": "A list of scan objects which describes the scan range and scan incrementthat should be used with the associated smarts pattern.",
         "default": [],
         "type": "array",
         "items": {
            "$ref": "#/definitions/Scan1D"
         }
      },
      "double_torsion_scans": {
         "title": "Double Torsion Scans",
         "description": "A list of double scan objects which describes the scan ranges and scan increments,that should be used with each of the smarts patterns.",
         "default": [],
         "type": "array",
         "items": {
            "$ref": "#/definitions/Scan2D"
         }
      },
      "improper_scans": {
         "title": "Improper Scans",
         "description": "A list of improper scan objects which describes the scan range and scan incrementthat should be used with the smarts pattern.",
         "default": [],
         "type": "array",
         "items": {
            "$ref": "#/definitions/ImproperScan"
         }
      }
   },
   "definitions": {
      "Scan1D": {
         "title": "Scan1D",
         "description": "A class to hold information on 1D scans to be computed.",
         "type": "object",
         "properties": {
            "smarts1": {
               "title": "Smarts1",
               "description": "The numerically tagged SMARTs pattern used to select the torsion.",
               "type": "string"
            },
            "scan_range1": {
               "title": "Scan Range1",
               "description": "The scan range that should be given to this torsion drive.",
               "type": "array",
               "minItems": 2,
               "maxItems": 2,
               "items": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "integer"
                  }
               ]
            },
            "scan_increment": {
               "title": "Scan Increment",
               "description": "The angle in degrees between each grid point in the scan.",
               "default": 15,
               "type": "array",
               "items": {
                  "type": "integer"
               }
            }
         },
         "required": [
            "smarts1"
         ]
      },
      "Scan2D": {
         "title": "Scan2D",
         "description": "A class to hold information on 2D scans to be computed.",
         "type": "object",
         "properties": {
            "smarts1": {
               "title": "Smarts1",
               "description": "The numerically tagged SMARTs pattern used to select the torsion.",
               "type": "string"
            },
            "scan_range1": {
               "title": "Scan Range1",
               "description": "The scan range that should be given to this torsion drive.",
               "type": "array",
               "minItems": 2,
               "maxItems": 2,
               "items": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "integer"
                  }
               ]
            },
            "scan_increment": {
               "title": "Scan Increment",
               "default": [
                  15,
                  15
               ],
               "type": "array",
               "items": {
                  "type": "integer"
               }
            },
            "smarts2": {
               "title": "Smarts2",
               "description": "The second numerically tagged SMARTs pattern used to select a torsion.",
               "type": "string"
            },
            "scan_range2": {
               "title": "Scan Range2",
               "description": "The scan range which should be given to the second torsion drive.",
               "type": "array",
               "minItems": 2,
               "maxItems": 2,
               "items": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "integer"
                  }
               ]
            }
         },
         "required": [
            "smarts1",
            "smarts2"
         ]
      },
      "ImproperScan": {
         "title": "ImproperScan",
         "description": "A class to hold information on Improper scans to be computed.",
         "type": "object",
         "properties": {
            "smarts": {
               "title": "Smarts",
               "description": "The numerically tagged SMARTs pattern used to select the improper torsion.",
               "type": "string"
            },
            "central_smarts": {
               "title": "Central Smarts",
               "description": "The numerically tagged SMARTSs pattern used to select the centralof the improper torsion.",
               "type": "string"
            },
            "scan_range": {
               "title": "Scan Range",
               "description": "The scan range which should be used for the improper.",
               "type": "array",
               "minItems": 2,
               "maxItems": 2,
               "items": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "integer"
                  }
               ]
            },
            "scan_increment": {
               "title": "Scan Increment",
               "description": "The angle in degrees between each grid point in the scan.",
               "default": 15,
               "type": "array",
               "items": {
                  "type": "integer"
               }
            }
         },
         "required": [
            "smarts",
            "central_smarts"
         ]
      }
   }
}

Config

allow_mutation: bool = True
validate_assignment: bool = True

Fields

double_torsion_scans (List[openff.qcsubmit.workflow_components.utils.Scan2D])
improper_scans (List[openff.qcsubmit.workflow_components.utils.ImproperScan])
torsion_scans (List[openff.qcsubmit.workflow_components.utils.Scan1D])
type (Literal['ScanEnumerator'])

field type: Literal['ScanEnumerator'] = 'ScanEnumerator'

field torsion_scans: List[openff.qcsubmit.workflow_components.utils.Scan1D] = []: A list of scan objects which describes the scan range and scan incrementthat should be used with the associated smarts pattern.

field double_torsion_scans: List[openff.qcsubmit.workflow_components.utils.Scan2D] = []: A list of double scan objects which describes the scan ranges and scan increments,that should be used with each of the smarts patterns.

field improper_scans: List[openff.qcsubmit.workflow_components.utils.ImproperScan] = []: A list of improper scan objects which describes the scan range and scan incrementthat should be used with the smarts pattern.

classmethod description()[source]

Returns a friendly description of the workflow component.

Return type: str

classmethod fail_reason()[source]

Returns a friendly description of why a molecule would fail to pass the component.

Return type: str

classmethod properties()[source]

Returns the runtime properties of the component such as parallel safe.

Return type: openff.qcsubmit.common_structures.ComponentProperties

add_torsion_scan(smarts, scan_rage=None, scan_increment=15)[source]

Add a targeted 1D torsion scan to the scan enumerator.

Parameters

smarts (str) – The numerically tagged SMARTs pattern that should be used to identify the torsion atoms.
scan_rage (Optional[Tuple[int, int]]) – The angle in degrees the torsion should be scanned between, from low to high
scan_increment (int) – The value in degrees between each grid point in the scan.

Return type

None

add_double_torsion(smarts1, smarts2, scan_range1=None, scan_range2=None, scan_increments=(15, 15))[source]

Add a targeted 2D torsion scan to the scan enumerator.

Parameters

smarts1 (str) – The numerically tagged SMARTs pattern that should be used to identify the first torsion atoms.
smarts2 (str) – The numerically tagged SMARTs pattern that should be used to identify the second torsion atoms.
scan_range1 (Optional[Tuple[int, int]]) – The angle in degrees the first torsion should be scanned between, from low to high
scan_range2 (Optional[Tuple[int, int]]) – The angle in degrees the second torsion should be scanned between, from low to high
scan_increments (List[int]) – A list of the values in degrees between each grid point in the scans.

Return type

None

add_improper_torsion(smarts, central_smarts, scan_range=None, scan_increment=15)[source]

Add a targeted Improper torsion to the scan enumerator.

Parameters

smarts (str) – The numerically tagged SMARTs pattern which describes the entire improper.
central_smarts (str) – The numerically tagged SMARTs pattern which identifies the central atom in the improper.
scan_range (Optional[Tuple[int, int]]) – The angles in degrees the improper should be scanned between, from low to high.
scan_increment (int) – The value in degrees between each grid point in the scan.

Return type

None

apply(molecules, toolkit_registry, processors=None, verbose=True)

This is the main feature of the workflow component which should accept a molecule, perform the component action and then return any resulting molecules.

Parameters

molecules (List[openff.toolkit.topology.molecule.Molecule]) – The list of molecules to be processed by this component.
toolkit_registry (openff.toolkit.utils.toolkit_registry.ToolkitRegistry) – The openff.toolkit.utils.ToolkitRegistry which declares the available backend toolkits to be used.
processors (Optional[int]) – The number of processor the component can use to run the job in parallel across molecules, None will default to all cores.
verbose (bool) – If true a progress bar should be shown on screen.

Returns

A component result class which handles collecting together molecules that pass and fail the component

Return type

openff.qcsubmit.workflow_components.utils.ComponentResult

classmethod info()

Returns a dictionary of the friendly descriptions of the class.

Return type: Dict[str, str]

classmethod is_available()

Check if any of the requested backend toolkits can be used.

Return type: bool

provenance(toolkit_registry)

This component calls the OFFTK to perform the task and logs information on the backend toolkit used.

Parameters: toolkit_registry (openff.toolkit.utils.toolkit_registry.ToolkitRegistry) – The openff.toolkit.utils.ToolkitRegistry which declares the available toolkits for the component.
Returns: A dictionary containing the version information about the backend toolkit called to perform the task.
Return type: Dict