ChemicalSystem Complete API
***************************

Tip:

  For copy-pasteable "ChemicalSystem" scripts, start with Python
  Examples.

class ChemicalSystem

   A class representing a chemical system in the Amsterdam Modeling
   Suite

   __init__(*args, **kwargs)

      Overloaded function.

      1. __init__(self: scm.base._internal.ChemicalSystem) -> None

      Creates a new, empty ChemicalSystem.

      2. __init__(self: scm.base._internal.ChemicalSystem,
         system_block: str) -> None

      Creates a new ChemicalSystem from a System block string.

      3. __init__(self: scm.base._internal.ChemicalSystem, symbols:
         list[str], coords: numpy.ndarray[numpy.float64[m, 3]],
         eol_strings: Optional[list[str]] = None, charge: float = 0.0,
         lattice: scm.base._internal.Lattice =
         <scm.base._internal.Lattice object at 0x7bf5181219b0>, bonds:
         Optional[scm.base._internal.Bonds] = None,
         electrostatic_embedding:
         Optional[scm.base._internal.ElectrostaticEmbedding] = None)
         -> None

      Creates a new ChemicalSystem from atom symbols, coordinates and
      (optionally) other data.

      4. __init__(self: scm.base._internal.ChemicalSystem,
         atomic_numbers: list[int], coords:
         numpy.ndarray[numpy.float64[m, 3]], eol_strings:
         Optional[list[str]] = None, charge: float = 0.0, lattice:
         scm.base._internal.Lattice = <scm.base._internal.Lattice
         object at 0x7bf518124a70>, bonds:
         Optional[scm.base._internal.Bonds] = None,
         electrostatic_embedding:
         Optional[scm.base._internal.ElectrostaticEmbedding] = None)
         -> None

      Creates a new ChemicalSystem from atomic numbers, coordinates
      and (optionally) other data.

   __len__(self: ChemicalSystem) -> int

   __str__(self: ChemicalSystem) -> str

      Formats a ChemicalSystem into an AMS System block.

   add_all_atoms_to_region(self: ChemicalSystem, region: str) -> None

      Adds all of the system's atoms to a region.

   add_atom(*args, **kwargs)

      Overloaded function.

      1. add_atom(self: scm.base._internal.ChemicalSystem, atom:
         scm.base._internal.Atom) -> None

      Adds a copy of an Atom to a ChemicalSystem.

      2. add_atom(self: scm.base._internal.ChemicalSystem, atom:
         scm.base._internal.Atom, coords:
         numpy.ndarray[numpy.float64[3, 1]], unit: str = 'angstrom')
         -> None

      Adds a copy of an Atom to a ChemicalSystem.

      3. add_atom(self: scm.base._internal.ChemicalSystem, Z: int,
         coords: numpy.ndarray[numpy.float64[3, 1]], unit: str =
         'angstrom') -> None

      Adds a new Atom of a given atomic number to the ChemicalSystem.

      4. add_atom(self: scm.base._internal.ChemicalSystem, element:
         scm.base._internal.Element, coords:
         numpy.ndarray[numpy.float64[3, 1]], unit: str = 'angstrom')
         -> None

      Adds a new Atom of a given Element to the ChemicalSystem.

      5. add_atom(self: scm.base._internal.ChemicalSystem, symbol:
         str, coords: numpy.ndarray[numpy.float64[3, 1]], unit: str =
         'angstrom') -> None

      Adds a new Atom to the ChemicalSystem given its symbol.

   add_atom_to_region(*args, **kwargs)

      Overloaded function.

      1. add_atom_to_region(self: scm.base._internal.ChemicalSystem,
         atom: int, region: str) -> None

      Adds an atom to a region.

      2. add_atom_to_region(self: scm.base._internal.ChemicalSystem,
         atom: scm.base._internal.Atom, region: str) -> None

      Adds an atom to a region.

   add_atoms_to_region(self: ChemicalSystem, atom_indices: numpy.ndarray[numpy.int32[m, 1]], region: str) -> None

      Adds multiple atoms to a region, given their atom indices.

   add_hydrogen_atoms(*args, **kwargs)

      Overloaded function.

      1. add_hydrogen_atoms(self: scm.base._internal.ChemicalSystem,
         atom_indices: list[int]) -> None

      Add missing hydrogen atoms to organic compounds.

      2. add_hydrogen_atoms(self: scm.base._internal.ChemicalSystem)
         -> None

      Add missing hydrogen atoms to organic compounds.

   add_other(self: ChemicalSystem, other: ChemicalSystem) -> None

      Merges another ChemicalSystem into this one.

   align_to(self: ChemicalSystem, other: ChemicalSystem) -> None

      Translate and rotate the system to maximally align it with
      'other'.

   static all_from_input(input_file: scm.base._internal.InputFile) -> dict[str, ChemicalSystem]

      Constructs and returns ChemicalSystems for all System (and
      LoadSystem) blocks in an InputFile.

   apply_strain(self: ChemicalSystem, strain_matrix: numpy.ndarray[numpy.float64[m, n]]) -> None

      Apply a strain deformation to a periodic system.

   apply_strain_voigt(self: ChemicalSystem, strain_voigt: list[float]) -> None

      Apply a strain deformation to a periodic system.

   atom_EOL_string(self: ChemicalSystem, atidx: int, skip: list[str] = []) -> str

      Returns the end-of-line string of an atom in the System%Atoms
      block given its index.

   atom_attributes_enabled(self: ChemicalSystem, group_prefix: str) -> bool

      Checks if a group of atomic properties is enabled or not.

   atom_index(self: ChemicalSystem, atom: Atom) -> int

      Given an Atom instance, returns its index in
      ChemicalSystem.atoms.

   atom_is_in_ring(*args, **kwargs)

      Overloaded function.

      1. atom_is_in_ring(self: scm.base._internal.ChemicalSystem,
         atom: int) -> bool

      Checks if an atom is part of any ring.

      2. atom_is_in_ring(self: scm.base._internal.ChemicalSystem,
         atom: scm.base._internal.Atom) -> bool

      Checks if an atom is part of any ring.

   bond_cuts_molecule(*args, **kwargs)

      Overloaded function.

      1. bond_cuts_molecule(self: scm.base._internal.ChemicalSystem,
         from_atom: int, to_atom: int) -> bool

      Checks if removing the bonds between two atoms would cut the
      graph into two disjoint subgraphs.

      2. bond_cuts_molecule(self: scm.base._internal.ChemicalSystem,
         from_atom: scm.base._internal.Atom, to_atom:
         scm.base._internal.Atom) -> bool

      Checks if removing the bonds between two atoms would cut the
      graph into two disjoint subgraphs.

   bounding_box_volume(self: ChemicalSystem, unit: str = 'angstrom3') -> float

      Volume of the bounding box.

   center_of_mass(self: ChemicalSystem, unit: str = 'angstrom') -> numpy.ndarray[numpy.float64[3, 1]]

      Position of the center of mass.

   check_molecule_symmetry(self: ChemicalSystem, label: str, tolerance: float = 1e-06) -> bool

      Checks if a molecule has a particular symmetry given by a
      Schoenflies symbol.

   clear_bonds(self: ChemicalSystem) -> None

      Removes all bonds from the system.

   contains_atom(self: ChemicalSystem, atom: Atom) -> bool

      Checks if an Atom instance is part of a ChemicalSystem.

   copy(self: ChemicalSystem) -> ChemicalSystem

      Creates a deep copy of the ChemicalSystem.

   density(self: ChemicalSystem, unit: str = 'dalton/angstrom3') -> float

      Returns the density of the system in the specified unit. Only
      valid for 3D periodic systems.

   deselect_all(self: ChemicalSystem) -> None

      Deselects all atoms, or in other words: clears the current
      selection.

   deselect_atom(*args, **kwargs)

      Overloaded function.

      1. deselect_atom(self: scm.base._internal.ChemicalSystem, arg0:
         int) -> None

      Selects an atom given its index.

      2. deselect_atom(self: scm.base._internal.ChemicalSystem, arg0:
         scm.base._internal.Atom) -> None

      Selects an instance of an atom.

   deselect_atoms(self: ChemicalSystem, atom_indices: numpy.ndarray[numpy.int32[m, 1]]) -> None

      Deselects multiple atoms at once, given their atom indices.

   deselect_atoms_if(self: ChemicalSystem, pred: Callable[[Atom], bool]) -> None

      Deselects atoms based on a predicate function.

   determine_species(self: ChemicalSystem, comp: Callable[[Atom, Atom], bool]) -> tuple[int, list[int], list[int]]

      Determines the present atomic species, based on a user defined
      comparator function.

   disable_atom_attributes(self: ChemicalSystem, group_prefix: str) -> None

      Disables the use of a group of atomic properties. Any set
      properties within the group will be discarded.

   distance_matrix(*args, **kwargs)

      Overloaded function.

      1. distance_matrix(self: scm.base._internal.ChemicalSystem,
         unit: str = 'angstrom') -> numpy.ndarray[numpy.float64[m, n]]

      Returns the distance matrix between all atoms in the system.

      2. distance_matrix(self: scm.base._internal.ChemicalSystem,
         atom_indices: numpy.ndarray[numpy.int32[m, 1]], unit: str =
         'angstrom') -> numpy.ndarray[numpy.float64[m, n]]

      Returns the distance matrix between a subset of atoms in the
      system.

      3. distance_matrix(self: scm.base._internal.ChemicalSystem,
         from_indices: numpy.ndarray[numpy.int32[m, 1]], to_indices:
         numpy.ndarray[numpy.int32[m, 1]], unit: str = 'angstrom') ->
         numpy.ndarray[numpy.float64[m, n]]

      Returns the distance matrix between two subsets of atoms in the
      system.

   do_regions_intersect(self: ChemicalSystem, regionA: str, regionB: str) -> bool

      Checks if two regions or region expressions intersect, i.e. have
      at least one atom in common.

   enable_atom_attributes(self: ChemicalSystem, group_prefix: str) -> None

      Enables the use of a group of atomic properties.

   extract_atoms(self: ChemicalSystem, atom_indices: list[int]) -> ChemicalSystem

      Returns a new system build from a subset of atoms.

   formula(self: ChemicalSystem) -> str

      Chemical formula in Hill notation, e.g. H2O or CH4.

   static from_in(filename: str, name: str = '') -> ChemicalSystem

      Constructs and returns a new ChemicalSystem from a (possibly
      named) System block in an AMS input file.

   static from_input(input_file: scm.base._internal.InputFile, prefix: str) -> ChemicalSystem

      Constructs and returns a new ChemicalSystem from an InputFile
      instance, given a prefix, e.g. 'System[1]%'.

   static from_kf(*args, **kwargs)

      Overloaded function.

      1. from_kf(filename: str, section: str = 'Molecule') ->
         scm.base._internal.ChemicalSystem

      Constructs and returns a new ChemicalSystem from a section on a
      KF file.

      2. from_kf(kf: scm.base._internal.KFFile, section: str =
         'Molecule') -> scm.base._internal.ChemicalSystem

      Constructs and returns a new ChemicalSystem from a section on a
      KF file.

   static from_xyz(filename: str) -> ChemicalSystem

      Constructs and returns a new ChemicalSystem from an extended XYZ
      file.

   geometric_center(self: ChemicalSystem, unit: str = 'angstrom') -> numpy.ndarray[numpy.float64[3, 1]]

      Position of the geometric center.

   get_angle(*args, **kwargs)

      Overloaded function.

      1. get_angle(self: scm.base._internal.ChemicalSystem, a: int, b:
         int, c: int, unit: str = 'radians') -> float

      Measures the angle A-B-C between three atoms, given their
      indices.

      2. get_angle(self: scm.base._internal.ChemicalSystem, a:
         scm.base._internal.Atom, b: scm.base._internal.Atom, c:
         scm.base._internal.Atom, unit: str = 'radians') -> float

      Measures the angle A-B-C between three Atom instances.

   get_atoms_in_region(self: ChemicalSystem, region: str) -> numpy.ndarray[numpy.int32[m, 1]]

      Returns a sorted array of atom indices of all atoms in a region
      or region expression.

   get_atoms_outside_region(self: ChemicalSystem, region: str) -> numpy.ndarray[numpy.int32[m, 1]]

      Returns a sorted array of atom indices of all atoms outside of a
      region or region expression.

   get_dihedral(*args, **kwargs)

      Overloaded function.

      1. get_dihedral(self: scm.base._internal.ChemicalSystem, a: int,
         b: int, c: int, d: int, unit: str = 'radians') -> float

      Measures the dihedral angle A-B-C-D between four atoms, given
      their indices.

      2. get_dihedral(self: scm.base._internal.ChemicalSystem, a:
         scm.base._internal.Atom, b: scm.base._internal.Atom, c:
         scm.base._internal.Atom, d: scm.base._internal.Atom, unit:
         str = 'radians') -> float

      Measures the dihedral angle A-B-C-D between four Atom instances.

   get_distance(*args, **kwargs)

      Overloaded function.

      1. get_distance(self: scm.base._internal.ChemicalSystem, a: int,
         b: int, unit: str = 'angstrom') -> float

      Measures the distance between two atoms, given their indices.

      2. get_distance(self: scm.base._internal.ChemicalSystem, a:
         scm.base._internal.Atom, b: scm.base._internal.Atom, unit:
         str = 'angstrom') -> float

      Measures the distance between two Atom instances.

   get_distances_to_point(self: ChemicalSystem, point: numpy.ndarray[numpy.float64[3, 1]], unit: str = 'angstrom') -> numpy.ndarray[numpy.float64[m, 1]]

      Returns the distance of each atom from a given point.

   get_fractional_coordinate(self: ChemicalSystem, atom: Atom, unit: str = 'angstrom') -> numpy.ndarray[numpy.float64[3, 1]]

      Returns the fractional coordinate of a single atom with respect
      to the cell. In non-periodic directions the plain coordinates
      are returned in the specified unit.

   get_fractional_coordinates(self: ChemicalSystem, unit: str = 'angstrom') -> numpy.ndarray[numpy.float64[m, 3]]

      Returns the fractional coordinates of all atoms with respect to
      the cell. In non-periodic directions the plain coordinates are
      returned in the specified unit.

   static get_operands_in_region_expression(region_expression: str) -> list[str]

      Returns a sorted list of all unique operands used in a region
      expression.

   get_regions_of_atom(*args, **kwargs)

      Overloaded function.

      1. get_regions_of_atom(self: scm.base._internal.ChemicalSystem,
         atom: int) -> list[str]

      Returns an alphabetically sorted list of the names of all
      regions an atom is part of.

      2. get_regions_of_atom(self: scm.base._internal.ChemicalSystem,
         atom: scm.base._internal.Atom) -> list[str]

      Returns an alphabetically sorted list of the names of all
      regions an atom is part of.

   get_selected_atoms(self: ChemicalSystem) -> numpy.ndarray[numpy.int32[m, 1]]

      Returns an array of indices of all selected atoms.

   get_species(self: ChemicalSystem, comp: Callable[[Atom, Atom], bool]) -> list[list[int]]

      Determines the present atomic species, based on a user defined
      comparator function.

   guess_bonds(self: ChemicalSystem) -> None

      Guesses bonds based on the atomic elements and the geometry.
      Keeps existing bonds.

   has_bonds(self: ChemicalSystem) -> bool

      Checks if the system has any bonding information.

   has_ghost_atoms(self: ChemicalSystem) -> bool

      Checks whether the ChemicalSystem contains any Ghost atoms.

   has_lattice(self: ChemicalSystem) -> bool

      Checks if the system has a lattice.

   has_region(self: ChemicalSystem, region: str) -> bool

      Checks if a region exists in the system, given its region name.

   has_same_atoms(*args, **kwargs)

      Overloaded function.

      1. has_same_atoms(self: scm.base._internal.ChemicalSystem,
         other: scm.base._internal.ChemicalSystem, properties:
         list[str] = []) -> bool

      Checks if two systems have identical atoms in the same order.

      2. has_same_atoms(self: scm.base._internal.ChemicalSystem,
         other: scm.base._internal.ChemicalSystem, comp:
         Callable[[scm.base._internal.Atom, scm.base._internal.Atom],
         bool]) -> bool

      Checks if two systems have identical atoms in the same order
      given a user defined comparator.

   has_same_coords(self: ChemicalSystem, other: ChemicalSystem, tol: float = 0.001, unit: str = 'angstrom') -> bool

      Checks if the atomic coordinates of two systems are within a
      threshold of each other.

   has_same_geometry(self: ChemicalSystem, other: ChemicalSystem, tol: float = 0.001, unit: str = 'angstrom') -> bool

      Checks if the atomic coordinates and lattice vectors of two
      systems are within a threshold of each other.

   has_same_regions(self: ChemicalSystem, other: ChemicalSystem) -> bool

      Checks if two systems have identical regions, meaning region
      names and included atom indices.

   has_same_selection(self: ChemicalSystem, other: ChemicalSystem, consider_selection_order: bool = False) -> bool

      Checks if two systems have the same atom selection.

   inertia_tensor(self: ChemicalSystem) -> numpy.ndarray[numpy.float64[3, 3]]

      Returns the system's inertia tensor as a 3x3 matrix (units
      amu*angstrom^2).

   invert_selection(self: ChemicalSystem) -> None

      Inverts the set of selected atoms.

   is_atom_in_region(*args, **kwargs)

      Overloaded function.

      1. is_atom_in_region(self: scm.base._internal.ChemicalSystem,
         atom: int, region: str) -> bool

      Checks if an atom is in a region or region expression.

      2. is_atom_in_region(self: scm.base._internal.ChemicalSystem,
         atom: scm.base._internal.Atom, region: str) -> bool

      Checks if an atom is in a region or region expression.

   is_atom_outside_region(*args, **kwargs)

      Overloaded function.

      1. is_atom_outside_region(self:
         scm.base._internal.ChemicalSystem, atom: int, region: str) ->
         bool

      Checks if an atom is outside of a region or region expression.

      2. is_atom_outside_region(self:
         scm.base._internal.ChemicalSystem, atom:
         scm.base._internal.Atom, region: str) -> bool

      Checks if an atom is outside of a region or region expression.

   is_atom_selected(*args, **kwargs)

      Overloaded function.

      1. is_atom_selected(self: scm.base._internal.ChemicalSystem,
         arg0: int) -> bool

      Checks if an atom is currently selected, given its index.

      2. is_atom_selected(self: scm.base._internal.ChemicalSystem,
         arg0: scm.base._internal.Atom) -> None

      Checks if an instance of an atom is currently selected.

   is_linear(self: ChemicalSystem) -> bool

      Checks is a ChemicalSystem is linear.

   static is_valid_region_name(name: str) -> bool

      Checks if a string is a valid region name.

   make_conventional_cell(self: ChemicalSystem, precision: float = 0.1) -> ChemicalSystem

      Create a new system by converting a 2D or 3D cell to its
      conventional representation.

   make_primitive_cell(self: ChemicalSystem, precision: float = 0.1) -> ChemicalSystem

      Create a new system by converting a 2D or 3D cell to its
      primitive representation.

   make_selection_cappable(self: ChemicalSystem) -> None

      Extends the current selection but does not cross single bonds,
      unless they are to hydrogen atoms.

   make_slab_layers(self: ChemicalSystem, miller: numpy.ndarray[numpy.int32[m, 1]], num_layers: int, translate: float = 0.0, unit: str = 'angstrom', ref_atom: int | None = None) -> ChemicalSystem

      Create a new system which is a 2D slab, by slicing a 3D system,
      specifying the number of layers in the resulting slab.

   make_slab_thickness(self: ChemicalSystem, miller: numpy.ndarray[numpy.int32[m, 1]], top: float, bottom: float, translate: float = 0.0, unit: str = 'angstrom', ref_atom: int | None = None) -> ChemicalSystem

      Create a new system which is a 2D slab, by slicing a 3D system,
      specifying the upper and lower bound of the resulting slab.

   make_supercell(self: ChemicalSystem, supercell: numpy.ndarray[numpy.int32[m, 1]]) -> ChemicalSystem

      Create a supercell by scaling the lattice vectors.

   make_supercell_trafo(self: ChemicalSystem, supercell: numpy.ndarray[numpy.int32[m, n]]) -> ChemicalSystem

      Create a supercell by creating the matrix product of the lattice
      vectors and the supercell matrix.

   map_atoms(*args, **kwargs)

      Overloaded function.

      1. map_atoms(self: scm.base._internal.ChemicalSystem,
         start_range: float) -> tuple[bool,
         numpy.ndarray[numpy.int32[m, 3]]]

      Maps all atoms into a unit cell from [start_range:start_range+1]
      in fractional coordinates.

      2. map_atoms(self: scm.base._internal.ChemicalSystem,
         start_range: numpy.ndarray[numpy.float64[m, 1]]) ->
         tuple[bool, numpy.ndarray[numpy.int32[m, 3]]]

      Maps all atoms into a unit cell from [start_range:start_range+1]
      in fractional coordinates.

   map_atoms_around_atom(*args, **kwargs)

      Overloaded function.

      1. map_atoms_around_atom(self:
         scm.base._internal.ChemicalSystem, atom:
         scm.base._internal.Atom) -> tuple[bool,
         numpy.ndarray[numpy.int32[m, 3]]]

      Map all atoms around the chosen atom that will be in the center
      of the new unit cell.

      2. map_atoms_around_atom(self:
         scm.base._internal.ChemicalSystem, atom: int) -> tuple[bool,
         numpy.ndarray[numpy.int32[m, 3]]]

      Map all atoms around the chosen atom that will be in the center
      of the new unit cell.

   map_atoms_continuous(self: ChemicalSystem) -> bool

      Map all atoms that are bonded across the periodic boundary back.

   molecule_indices(self: ChemicalSystem) -> numpy.ndarray[numpy.int32[m, 1]]

      Returns a "num_atoms" sized array mapping the atoms to connected
      molecules of the system.

   molgraph_dijkstra(self: ChemicalSystem, from_atidx: int, dist_func: Callable[[int, int, Bond], float], to_atidx: int = -1) -> tuple[list[float], list[int], list[bool]]

      General method implementing the Dijkstra algorithm on the
      molecular graph.

   moments_of_inertia(self: ChemicalSystem) -> tuple[numpy.ndarray[numpy.float64[3, 1]], numpy.ndarray[numpy.float64[3, 3]]]

      Calculates the system's moments of inertia and the corresponding
      principal axes (units amu*angstrom^2).

   moving_atoms_for_angle_change(self: scm.base._internal.ChemicalSystem, a: int, b: int, c: int, policy: scm.base._internal.ChemicalSystem.InternalCoordinateManipulationPolicy = <InternalCoordinateManipulationPolicy.SecondPartMoves: 1>) -> numpy.ndarray[numpy.int32[m, 1]]

      Determines which atoms will move when changing the angle between
      three atoms.

   moving_atoms_for_dihedral_change(self: scm.base._internal.ChemicalSystem, a: int, b: int, c: int, d: int, policy: scm.base._internal.ChemicalSystem.InternalCoordinateManipulationPolicy = <InternalCoordinateManipulationPolicy.SecondPartMoves: 1>) -> numpy.ndarray[numpy.int32[m, 1]]

      Determines which atoms will move when changing the dihedral
      between four atoms.

   moving_atoms_for_distance_change(self: scm.base._internal.ChemicalSystem, a: int, b: int, policy: scm.base._internal.ChemicalSystem.InternalCoordinateManipulationPolicy = <InternalCoordinateManipulationPolicy.SecondPartMoves: 1>) -> numpy.ndarray[numpy.int32[m, 1]]

      Determines which atoms will move when changing the distance
      between two atoms.

   num_atoms_in_region(self: ChemicalSystem, region: str) -> int

      Returns the number of atoms in a region or region expression.

   num_atoms_outside_region(self: ChemicalSystem, region: str) -> int

      Returns the number of atoms outside of a region or region
      expression.

   num_molecules(self: ChemicalSystem) -> int

      Counts the number of connected molecules that are part of this
      system.

   num_selected_atoms(self: ChemicalSystem) -> int

      The number of currently selected atoms.

   perturb_coordinates(self: ChemicalSystem, noise_level: float, unit: str = 'angstrom') -> None

      Perturb the atomic coordinates by adding random numbers between
      to each Cartesian component.

   perturb_lattice(self: ChemicalSystem, noise_level: float) -> None

      Perturb the lattice vectors by applying a random strain.

   remove_all_regions(self: ChemicalSystem) -> None

      Removes all regions. All atoms will keep existing, but will not
      longer be part of any region.

   remove_atom(self: ChemicalSystem, atom_index: int) -> None

      Removes a single atom from the system, given its index.

   remove_atom_from_all_regions(*args, **kwargs)

      Overloaded function.

      1. remove_atom_from_all_regions(self:
         scm.base._internal.ChemicalSystem, atom: int) -> None

      Removes an atom from all regions.

      2. remove_atom_from_all_regions(self:
         scm.base._internal.ChemicalSystem, atom:
         scm.base._internal.Atom) -> None

      Removes an atom from all regions.

   remove_atom_from_region(*args, **kwargs)

      Overloaded function.

      1. remove_atom_from_region(self:
         scm.base._internal.ChemicalSystem, atom: int, region: str) ->
         None

      Removes an atom from a region.

      2. remove_atom_from_region(self:
         scm.base._internal.ChemicalSystem, atom:
         scm.base._internal.Atom, region: str) -> None

      Removes an atom from a region.

   remove_atoms(self: ChemicalSystem, atom_indices: numpy.ndarray[numpy.int32[m, 1]]) -> None

      Removes multiple atoms from the system, given their atom
      indices.

   remove_atoms_from_region(self: ChemicalSystem, atom_indices: numpy.ndarray[numpy.int32[m, 1]], region: str) -> None

      Adds multiple atoms to a region, given their atom indices.

   remove_region(self: ChemicalSystem, region: str) -> None

      Removes a region. Atoms in that region will keep existing, but
      will not longer be part of that region.

   reorder_atoms(self: ChemicalSystem, atom_order: list[int]) -> None

      Reorders the system's atoms given a list of atom indices in the
      desired order.

   static rmsd(a: ChemicalSystem, b: ChemicalSystem, align: bool, unit: str = 'angstrom') -> float

      Computes the RMSD between two systems. 'align': whether or not
      the systems should be roto-translated as to maximize the RMSD.

   rotate(self: ChemicalSystem, rot_mat: numpy.ndarray[numpy.float64[3, 3]]) -> None

      Rotate the system according to the rotation matrix.

   rotation_axis_for_angle_change(self: ChemicalSystem, arg0: int, arg1: int, arg2: int) -> numpy.ndarray[numpy.float64[3, 1]]

      Determines the rotation axis for changing the angle between
      three atoms.

   static rotation_matrix_minimizing_rmsd(a: ChemicalSystem, b: ChemicalSystem) -> numpy.ndarray[numpy.float64[3, 3]]

      Given two chemical systems, returns the rotation matrix that
      minimizes the RMSD.

   select_all(self: ChemicalSystem) -> None

      Selects all atoms.

   select_atom(*args, **kwargs)

      Overloaded function.

      1. select_atom(self: scm.base._internal.ChemicalSystem, arg0:
         int) -> None

      Selects an atom given its index.

      2. select_atom(self: scm.base._internal.ChemicalSystem, arg0:
         scm.base._internal.Atom) -> None

      Selects an instance of an atom.

   select_atom_close_to_origin(self: ChemicalSystem) -> None

      Selects the atom that is closest to the origin of the coordinate
      system.

   select_atoms(self: ChemicalSystem, atom_indices: numpy.ndarray[numpy.int32[m, 1]]) -> None

      Selects multiple atoms at once, given their atom indices.

   select_atoms_if(self: ChemicalSystem, pred: Callable[[Atom], bool]) -> None

      Selects atoms based on a predicate function.

   select_atoms_of_same_type(self: ChemicalSystem) -> None

      Selects all atoms whose element is the same as of a currently
      selected atom.

   select_connected(self: ChemicalSystem) -> None

      Selects all atoms bonded to the currently selected atoms.

   select_connected_if(self: ChemicalSystem, pred: Callable[[Atom, Atom, Bond], bool]) -> None

      Selects atoms bonded to the currently selected atoms based on a
      predicate function.

   select_molecule(self: ChemicalSystem) -> None

      Using the bonds, selects entire molecules that include any
      currently selected atom.

   select_molecule_if(self: ChemicalSystem, pred: Callable[[Atom, Atom, Bond], bool]) -> None

      Using the bonds and a predicate function, selects all molecules
      that include a currently selected atom.

   select_region(self: ChemicalSystem, region: str) -> None

      Selects atoms in a region or region expression.

   select_within_radius(self: ChemicalSystem, radius: float, unit: str = 'angstrom') -> None

      Selects all atoms within a given radius of any of the currently
      selected atoms.

   set_angle(*args, **kwargs)

      Overloaded function.

      1. set_angle(self: scm.base._internal.ChemicalSystem, a: int, b:
         int, c: int, angle: float, policy: scm.base._internal.Chemic
         alSystem.InternalCoordinateManipulationPolicy =
         <InternalCoordinateManipulationPolicy.SecondPartMoves: 1>) ->
         None

      Sets the angle between three atoms by moving atoms according to
      a policy.

      2. set_angle(self: scm.base._internal.ChemicalSystem, a: int, b:
         int, c: int, angle: float, unit: str, policy: scm.base._inte
         rnal.ChemicalSystem.InternalCoordinateManipulationPolicy =
         <InternalCoordinateManipulationPolicy.SecondPartMoves: 1>) ->
         None

      Sets the angle between three atoms by moving atoms according to
      a policy.

      3. set_angle(self: scm.base._internal.ChemicalSystem, a: int, b:
         int, c: int, angle: float, rotation_axis:
         numpy.ndarray[numpy.float64[3, 1]], moving_atoms:
         numpy.ndarray[numpy.int32[m, 1]]) -> None

      Sets the angle between three atoms by moving a specified set of
      atoms.

      4. set_angle(self: scm.base._internal.ChemicalSystem, a: int, b:
         int, c: int, angle: float, unit: str, rotation_axis:
         numpy.ndarray[numpy.float64[3, 1]], moving_atoms:
         numpy.ndarray[numpy.int32[m, 1]]) -> None

      Sets the angle between three atoms by moving a specified set of
      atoms.

   set_atom(self: ChemicalSystem, atom_index: int, atom: Atom) -> None

      Safe assignment of an Atom instance to atoms[atom_index].

   set_atoms_in_region(self: ChemicalSystem, atom_indices: numpy.ndarray[numpy.int32[m, 1]], region: str) -> None

      Creates or sets an entire region given the indices of the atoms
      to be part of the region.

   set_density(self: ChemicalSystem, target_density: float, unit: str = 'dalton/angstrom3') -> None

      Applies a uniform strain to match the specified target density.
      Only valid for 3D periodic systems.

   set_dihedral(*args, **kwargs)

      Overloaded function.

      1. set_dihedral(self: scm.base._internal.ChemicalSystem, a: int,
         b: int, c: int, d: int, angle: float, policy: scm.base._inte
         rnal.ChemicalSystem.InternalCoordinateManipulationPolicy =
         <InternalCoordinateManipulationPolicy.SecondPartMoves: 1>) ->
         None

      Sets the dihedral between four atoms by moving atoms according
      to a policy.

      2. set_dihedral(self: scm.base._internal.ChemicalSystem, a: int,
         b: int, c: int, d: int, angle: float, unit: str, policy: scm
         .base._internal.ChemicalSystem.InternalCoordinateManipulatio
         nPolicy =
         <InternalCoordinateManipulationPolicy.SecondPartMoves: 1>) ->
         None

      Sets the dihedral between four atoms by moving atoms according
      to a policy.

      3. set_dihedral(self: scm.base._internal.ChemicalSystem, a: int,
         b: int, c: int, d: int, angle: float, moving_atoms:
         numpy.ndarray[numpy.int32[m, 1]]) -> None

      Sets the dihedral between four atoms by moving a specified set
      of atoms.

      4. set_dihedral(self: scm.base._internal.ChemicalSystem, a: int,
         b: int, c: int, d: int, angle: float, unit: str,
         moving_atoms: numpy.ndarray[numpy.int32[m, 1]]) -> None

      Sets the dihedral between four atoms by moving a specified set
      of atoms.

   set_distance(*args, **kwargs)

      Overloaded function.

      1. set_distance(self: scm.base._internal.ChemicalSystem, a: int,
         b: int, dist: float, policy: scm.base._internal.ChemicalSyst
         em.InternalCoordinateManipulationPolicy =
         <InternalCoordinateManipulationPolicy.SecondPartMoves: 1>) ->
         None

      Sets the distance between two atoms by moving atoms according to
      a policy.

      2. set_distance(self: scm.base._internal.ChemicalSystem, a: int,
         b: int, dist: float, unit: str, policy: scm.base._internal.C
         hemicalSystem.InternalCoordinateManipulationPolicy =
         <InternalCoordinateManipulationPolicy.SecondPartMoves: 1>) ->
         None

      Sets the distance between two atoms by moving atoms according to
      a policy.

      3. set_distance(self: scm.base._internal.ChemicalSystem, a: int,
         b: int, dist: float, moving_atoms:
         numpy.ndarray[numpy.int32[m, 1]]) -> None

      Sets the distance between two atoms by moving a specified set of
      atoms.

      4. set_distance(self: scm.base._internal.ChemicalSystem, a: int,
         b: int, dist: float, unit: str, moving_atoms:
         numpy.ndarray[numpy.int32[m, 1]]) -> None

      Sets the distance between two atoms by moving a specified set of
      atoms.

   set_fractional_coordinates(self: ChemicalSystem, frac_coords: numpy.ndarray[numpy.float64[m, 3]], unit: str = 'angstrom') -> None

      Sets the fractional coordinates of all atoms. In non-periodic
      directions the plain coordinates should be passed in the
      specified unit.

   set_lattice_displacements_from_minimum_image_convention(self: ChemicalSystem) -> None

      Applies the minimum image convention which sets the
      lattice_displacements for all bonds to be the shortest possible.

   set_num_lattice_vectors(self: ChemicalSystem, nvec: int) -> None

      Sets the number of lattice vectors.

   set_selected_atoms(self: ChemicalSystem, atom_indices: numpy.ndarray[numpy.int32[m, 1]]) -> None

      Sets the selection to the given atom indices. Any previous
      selection is cleared.

   shortest_path_between(*args, **kwargs)

      Overloaded function.

      1. shortest_path_between(self:
         scm.base._internal.ChemicalSystem, from_atom: int, to_atom:
         int, dist_func: Callable[[int, int, scm.base._internal.Bond],
         float]) -> Optional[list[int]]

      Returns the shortest path between two atoms (using a custom
      distance function).

      2. shortest_path_between(self:
         scm.base._internal.ChemicalSystem, from_atom: int, to_atom:
         int) -> Optional[list[int]]

      Returns the shortest path between two atoms (measured in number
      of hops).

      3. shortest_path_between(self:
         scm.base._internal.ChemicalSystem, from_atom:
         scm.base._internal.Atom, to_atom: scm.base._internal.Atom,
         dist_func: Callable[[int, int, scm.base._internal.Bond],
         float]) -> Optional[list[int]]

      Returns the shortest path between two atoms (using a custom
      distance function).

      4. shortest_path_between(self:
         scm.base._internal.ChemicalSystem, from_atom:
         scm.base._internal.Atom, to_atom: scm.base._internal.Atom) ->
         Optional[list[int]]

      Returns the shortest path between two atoms (measured in number
      of hops).

   shortest_path_length_between(*args, **kwargs)

      Overloaded function.

      1. shortest_path_length_between(self:
         scm.base._internal.ChemicalSystem, from_atom: int, to_atom:
         int, dist_func: Callable[[int, int, scm.base._internal.Bond],
         float]) -> float

      Returns the lengths of the shortest path between two atoms
      (measured using a custom distance function).

      2. shortest_path_length_between(self:
         scm.base._internal.ChemicalSystem, from_atom: int, to_atom:
         int) -> float

      Returns the length of the shortest path between two atoms
      (measured in number of hops).

      3. shortest_path_length_between(self:
         scm.base._internal.ChemicalSystem, from_atom:
         scm.base._internal.Atom, to_atom: scm.base._internal.Atom,
         dist_func: Callable[[int, int, scm.base._internal.Bond],
         float]) -> float

      Returns the lengths of the shortest path between two atoms
      (measured using a custom distance function).

      4. shortest_path_length_between(self:
         scm.base._internal.ChemicalSystem, from_atom:
         scm.base._internal.Atom, to_atom: scm.base._internal.Atom) ->
         float

      Returns the length of the shortest path between two atoms
      (measured in number of hops).

   shortest_path_lengths_from(*args, **kwargs)

      Overloaded function.

      1. shortest_path_lengths_from(self:
         scm.base._internal.ChemicalSystem, from_atom: int, dist_func:
         Callable[[int, int, scm.base._internal.Bond], float]) ->
         list[float]

      Returns the lengths of all shortest paths from a source atom
      using a custom distance function.

      2. shortest_path_lengths_from(self:
         scm.base._internal.ChemicalSystem, from_atom: int) ->
         list[float]

      Returns the lengths (in number of hops) of all shortest paths
      from a source atom.

      3. shortest_path_lengths_from(self:
         scm.base._internal.ChemicalSystem, from_atom:
         scm.base._internal.Atom, dist_func: Callable[[int, int,
         scm.base._internal.Bond], float]) -> list[float]

      Returns the lengths of all shortest paths from a source atom
      using a custom distance function.

      4. shortest_path_lengths_from(self:
         scm.base._internal.ChemicalSystem, from_atom:
         scm.base._internal.Atom) -> list[float]

      Returns the lengths (in number of hops) of all shortest paths
      from a source atom.

   sort_atoms(self: ChemicalSystem, comp: Callable[[Atom, Atom], bool]) -> None

      Sorts the system's atoms according to a user defined comparator
      function.

   sorted_atom_order(self: ChemicalSystem, comp: Callable[[Atom, Atom], bool]) -> list[int]

      Returns the atom order based on a user defined comparator
      function as a list of atom indices.

   split(self: ChemicalSystem, part_indices: numpy.ndarray[numpy.int32[m, 1]]) -> list[ChemicalSystem]

      Splits the system into parts and returns a list of these parts
      as separate systems.

   split_into_molecules(self: ChemicalSystem) -> list[ChemicalSystem]

      Splits the system into individual molecules based on the
      connectivity between atoms.

   squared_distance_matrix(*args, **kwargs)

      Overloaded function.

      1. squared_distance_matrix(self:
         scm.base._internal.ChemicalSystem, unit: str = 'angstrom2')
         -> numpy.ndarray[numpy.float64[m, n]]

      Returns the matrix of squared distances between all atoms in the
      system.

      2. squared_distance_matrix(self:
         scm.base._internal.ChemicalSystem, atom_indices:
         numpy.ndarray[numpy.int32[m, 1]], unit: str = 'angstrom2') ->
         numpy.ndarray[numpy.float64[m, n]]

      Returns the matrix of squared distances between a subset of
      atoms in the system.

      3. squared_distance_matrix(self:
         scm.base._internal.ChemicalSystem, from_indices:
         numpy.ndarray[numpy.int32[m, 1]], to_indices:
         numpy.ndarray[numpy.int32[m, 1]], unit: str = 'angstrom2') ->
         numpy.ndarray[numpy.float64[m, n]]

      Returns the matrix of squared distances between two subsets of
      atoms in the system.

   symmetrize(self: ChemicalSystem) -> str

      Symmetrizes a system, using either "symmetrize_molecule" or
      "symmetrize_cell", depending on periodicity.

   symmetrize_cell(self: ChemicalSystem, precision: float = 0.1) -> tuple[int, str, str]

      Symmetrize a 3D cell and return the symmetry symbols (number,
      international symbol, schoenflies symbol).

   symmetrize_molecule(self: ChemicalSystem, tolerance: float = 0.05) -> str

      Symmetrizes and reorients a molecule.

   symmetrize_molecule_to(self: ChemicalSystem, label: str, tolerance: float = 0.05) -> None

      Symmetrizes a molecule to a particular symmetry given by a
      Schoenflies symbol.

   total_mass(self: ChemicalSystem) -> float

      Total mass in atomic mass units (dalton).

   translate(self: ChemicalSystem, shift: numpy.ndarray[numpy.float64[3, 1]], unit: str = 'angstrom') -> None

      Translates all atoms in the ChemicalSystem by a vector.

   write_in(self: ChemicalSystem, filename: str) -> None

      Writes a ChemicalSystem to file as an AMS System block.

   write_kf(*args, **kwargs)

      Overloaded function.

      1. write_kf(self: scm.base._internal.ChemicalSystem, filename:
         str, section: str = 'Molecule', omode:
         scm.base._internal.KFFile.OpenMode = <OpenMode.Any: 0>) ->
         None

      Writes a ChemicalSystem to a section on a KF file.

      2. write_kf(self: scm.base._internal.ChemicalSystem, kf:
         scm.base._internal.KFFile, section: str = 'Molecule') -> None

      Writes a ChemicalSystem to a section on a KF file.

   write_xyz(self: ChemicalSystem, filename: str, extended_xyz_format: bool = True) -> None

      Writes a ChemicalSystem to an extended XYZ file.

   property adf_attribs

      An optional list of all AtomAttributesADF for all atoms.

   property atoms

      A list of all Atom instances that are part of this
      ChemicalSystem.

   property band_attribs

      An optional list of all AtomAttributesBAND for all atoms.

   property bonds

      The bonds of the system.

   property charge

      The total charge of the system in in atomic units.

   property coords: AngstromCoordsArray

      The coordinates of the atoms in Angstrom

   property dftb_attribs

      An optional list of all AtomAttributesDFTB for all atoms.

   property electrostatic_embedding

      The electrostatic embedding of the system.

   property forcefield_attribs

      An optional list of all AtomAttributesForcefield for all atoms.

   property gui_attribs

      An optional list of all AtomAttributesGUI for all atoms.

   property lattice

      The lattice of the system.

   property num_atoms

      The number of Atoms in the ChemicalSystem.

   property num_regions

      Returns the number of regions used in the system.

   property qe_attribs

      An optional list of all AtomAttributesQE for all atoms.

   property reaxff_attribs

      An optional list of all AtomAttributesReaxFF for all atoms.

   property region_names

      Returns a list of the names of all regions in the system.

   property vasp_attribs

      An optional list of all AtomAttributesVASP for all atoms.

class InternalCoordinateManipulationPolicy

   Members:

   FirstPartMoves

   SecondPartMoves

   LighterPartMoves

   HeavierPartMoves

   __init__(self: InternalCoordinateManipulationPolicy, value: int) -> None

   property name

class Element

   property Z

      The atomic number of the element.

   property bond_guess_connectors

      Number of connectors of an atom as used by the AMS bond guessing
      algorithm.

   property bond_guess_electro_negative

      Whether or not an element is considered electronegative by the
      AMS bond guessing algorithm.

   property bond_guess_metallic

      Whether or not an element is considered metallic by the AMS bond
      guessing algorithm.

   property color

      The color of the element used in the AMS graphical user
      interface.

   property lone_pairs

      The element's number of lone pairs as used by the AMS bond
      guessing algorithm.

   property mass

      The atomic mass (in Dalton) of the most abundant naturally
      occurring isotope of the element.

   property radius

      The covalent radius of the element in angstrom.

   property symbol

      The symbol of the element, e.g "C" for carbon.

class Elements

   static from_atomic_number(Z: int) -> Element

      Returns an Element given its atomic number.

   static from_symbol(symbol: str) -> Element

      Returns an Element given the element symbol as a string.

class Atom

   copy(self: Atom) -> Atom

      Creates a deep copy of the Atom.

   has_identical_attributes(self: Atom, other: Atom, properties: list[str] = []) -> bool

      Checks if two atoms have identical atomic properties.

   in_chemicalsystem(self: Atom) -> bool

      Check if this Atom instance is part of a ChemicalSystem.

   transmute(*args, **kwargs)

      Overloaded function.

      1. transmute(self: scm.base._internal.Atom, Z: int) -> None

      Change the element of an atom given an atomic number.

      2. transmute(self: scm.base._internal.Atom, element:
         scm.base._internal.Element) -> None

      Change the element of an Atom of given an Element instance.

      3. transmute(self: scm.base._internal.Atom, symbol: str) -> None

      Change the element of an Atom given an element symbol.

   property Z

      The atomic number of the atom.

   property adf

      Atomic properties used by the ADF engine.

   property band

      Atomic properties used by the BAND engine.

   property coords: AngstromCoordsArray

      The coordinates of the atoms in Angstrom

   property dftb

      Atomic properties used by the AMS DFTB engine.

   property element

      Returns the atom's element.

   property forcefield

      Atomic properties used by the AMS Forcefield engine.

   property gui

      Atomic properties used for visualization in the GUI.

   property is_ghost

      Whether the atom is a Ghost atom.

   property mass

      The mass of the atom in dalton.

   property qe

      Atomic properties used by the AMS QuantumESPRESSO engine.

   property reaxff

      Atomic properties used by the AMS ReaxFF engine.

   property symbol

      The atom's symbol (e.g. 'C' or 'Au'). May be 'Gh.C' for ghost
      atoms.

   property vasp

      Atomic properties used by the AMS VASP engine.

class Lattice

   cartesian_to_fractional(*args, **kwargs)

      Overloaded function.

      1. cartesian_to_fractional(self: scm.base._internal.Lattice,
         cartesian_coords: numpy.ndarray[numpy.float64[m, 1]], unit:
         str = 'angstrom') -> numpy.ndarray[numpy.float64[m, 1]]

      Convert Cartesian coordinates to fractional coordinates for a
      single point. No conversion will take place in non-periodic
      directions.

      2. cartesian_to_fractional(self: scm.base._internal.Lattice,
         cartesian_coords: numpy.ndarray[numpy.float64[m, n]], unit:
         str = 'angstrom') -> numpy.ndarray[numpy.float64[m, n]]

      Convert Cartesian coordinates to fractional coordinates for a
      set of points. No conversion will take place in non-periodic
      directions.

   copy(self: Lattice) -> Lattice

      Creates a deep copy of the Lattice.

   fractional_to_cartesian(*args, **kwargs)

      Overloaded function.

      1. fractional_to_cartesian(self: scm.base._internal.Lattice,
         cartesian_coords: numpy.ndarray[numpy.float64[m, 1]], unit:
         str = 'angstrom') -> numpy.ndarray[numpy.float64[m, 1]]

      Convert fractional coordinates to Cartesian coordinates for a
      single point. No conversion will take place in non-periodic
      directions.

      2. fractional_to_cartesian(self: scm.base._internal.Lattice,
         fractional_coords: numpy.ndarray[numpy.float64[m, n]], unit:
         str = 'angstrom') -> numpy.ndarray[numpy.float64[m, n]]

      Convert fractional coordinates to Cartesian coordinates for a
      set of points. No conversion will take place in non-periodic
      directions.

   static from_kf(kf: scm.base._internal.KFFile, section: str) -> Lattice

      Constructs and returns a new Lattice from a section on a KF
      file.

   get_3x3_lattice_vectors(self: Lattice, unit: str = 'angstrom') -> numpy.ndarray[numpy.float64[m, 3]]

      Get the lattice vectors as a 3x3 matrix padded out with zeros.

   get_angles(self: Lattice, unit: str = 'rad') -> numpy.ndarray[numpy.float64[3, 1]]

      Get the angles between the lattice vectors (note: always returns
      3 numbers).

   get_cell_depth(self: Lattice, unit: str = 'angstrom') -> numpy.ndarray[numpy.float64[3, 1]]

      Return unit cell depth, or thickness, in each dimension.

   get_lattice_translation(self: Lattice, d: numpy.ndarray[numpy.int32[m, 1]], unit: str = 'angstrom') -> numpy.ndarray[numpy.float64[3, 1]]

      Returns the overall translation given a multiple of the lattice
      vectors.

   get_lengths(self: Lattice, unit: str = 'angstrom') -> numpy.ndarray[numpy.float64[3, 1]]

      Get the length of the lattice vectors (note: always returns 3
      numbers).

   get_reciprocal_lattice_vectors(self: Lattice, unit: str = 'angstrom-1') -> numpy.ndarray[numpy.float64[m, 3]]

      Get the reciprocal lattice vectors as a numpy array.

   get_volume(self: Lattice, unit: str = 'angstrom') -> float

      Get the volume of the unit cell (for 2D: area, for 1D length)

   is_close(*args, **kwargs)

      Overloaded function.

      1. is_close(self: scm.base._internal.Lattice, other:
         scm.base._internal.Lattice, tol: float = 0.001, unit: str =
         'angstrom') -> bool

      Checks if two sets of lattice vectors are close to each other.
      (Threshold on norm of vector difference.)

      2. is_close(self: scm.base._internal.Lattice, other:
         scm.base._internal.Lattice, length_tol: float, angle_tol:
         float, length_unit: str = 'angstrom', angle_unit: str =
         'rad') -> bool

      Checks if two sets of lattice vectors are close to each other.
      (Thresholds on lengths and angles.)

   is_orthogonal(self: Lattice) -> bool

      Is the lattice orthogonal?

   map_vector_to_central_cell(self: Lattice, vec: numpy.ndarray[numpy.float64[3, 1]], unit: str = 'angstrom') -> numpy.ndarray[numpy.float64[3, 1]]

      Maps a vector into the central cell, such that its fractional
      coordinates are in range [-0.5,+0.5). No mapping will take place
      in non-periodic directions.

   map_vectors_to_central_cell(self: Lattice, vecs: numpy.ndarray[numpy.float64[m, 3]], unit: str = 'angstrom') -> numpy.ndarray[numpy.float64[m, 3]]

      Maps a set of vectors into the central cell, such that their
      fractional coordinates are in range [-0.5,+0.5). No mapping will
      take place in non-periodic directions.

   write_kf(self: Lattice, kf: scm.base._internal.KFFile, section: str) -> None

      Writes a Lattice to a section on a KF file.

   property num_vectors

      Returns the number of lattice vectors (i.e. the number of PBC).

   property vectors: AngstromCoordsArray

      The lattice vectors in Angstrom

class Bond

   copy(self: Bond) -> Bond

      Creates a deep copy of the Bond.

   get_inverted(self: Bond) -> Bond

      Returns a copy of the bond with inverted lattice displacements.

   property lattice_displacements

      Lattice displacements for the second atom that is part of the
      bond.

   property order

      The order of the bond: 1 = single bond, 1.5 = aromatic bond, 2 =
      double bond, 3 = triple bond.

class Bonds

   add_bond(self: Bonds, from_atom: int, to_atom: int, bond: Bond) -> None

      Adds a bond between two atoms, given their indices.

   add_bonds(*args, **kwargs)

      Overloaded function.

      1. add_bonds(self: scm.base._internal.Bonds, from_atom:
         numpy.ndarray[numpy.int32[m, 1]], to_atom:
         numpy.ndarray[numpy.int32[m, 1]], bonds:
         scm.base._internal.BondList) -> None

      Adds bonds between multiple atom pairs at the same time. All
      arguments should have the same length.

      2. add_bonds(self: scm.base._internal.Bonds, from_atom:
         numpy.ndarray[numpy.int32[m, 1]], to_atom:
         numpy.ndarray[numpy.int32[m, 1]], orders:
         numpy.ndarray[numpy.float64[m, 1]]) -> None

      Adds bonds between multiple atom pairs at the same time. All
      arguments should have the same length.

   any_bond_between(self: Bonds, from_atoms: list[int], to_atoms: list[int]) -> bool

      Checks if there is any direct bond between two groups of atoms.

   atoms_are_bonded(self: Bonds, from_atom: int, to_atom: int) -> bool

      Checks whether two atoms are bonded or not.

   clear_bonds(self: Bonds) -> None

      Removes all bonds.

   copy(self: Bonds) -> Bonds

      Creates a deep copy of the Bonds.

   static from_kf(kf: scm.base._internal.KFFile, section: str) -> Bonds

      Constructs and returns new Bonds from a section on a KF file.

   static from_list(num_atoms: int, num_lattice_vectors: int, from_atoms: numpy.ndarray[numpy.int32[m, 1]], to_atoms: numpy.ndarray[numpy.int32[m, 1]], bond_orders: numpy.ndarray[numpy.float64[m, 1]], lattice_displacements: numpy.ndarray[numpy.int32[m, n]] = array([], shape=(0, 0), dtype=int32), indexing: int = 0) -> Bonds

      Creates a set of bonds from lists of atom indices, bond orders
      and optional lattice displacements.

   static from_sparse(num_lattice_vectors: int, row_offset: numpy.ndarray[numpy.int32[m, 1]], column_index: numpy.ndarray[numpy.int32[m, 1]], bond_orders: numpy.ndarray[numpy.float64[m, 1]], lattice_displacements: numpy.ndarray[numpy.int32[m, n]] = array([], shape=(0, 0), dtype=int32), indexing: int = 0) -> Bonds

      Low level construction of a set of bonds directly from the
      (modified) CRS storage.

   get_atomic_valencies(self: Bonds) -> numpy.ndarray[numpy.float64[m, 1]]

      Returns the atomic valencies, i.e. the sum of all bond orders,
      for each atom.

   get_bond_index(self: Bonds, bond: Bond) -> int

      Returns the index of a bond in the .bonds attribute.

   get_bonded_atoms(self: Bonds, atom: int) -> list[int]

      Returns a list of atom indices that are bonded to the given atom
      index.

   get_bonds_between_atoms(self: Bonds, from_atom: int, to_atom: int) -> Iterator[tuple[int, int, Bond]]

      Returns an iterator over the bonds between the given atoms.

   get_bonds_for_atom(self: Bonds, from_atom: int) -> Iterator[tuple[int, int, Bond]]

      Returns an iterator over all bonds from a particular atom given
      by its index.

   num_bonds(*args, **kwargs)

      Overloaded function.

      1. num_bonds(self: scm.base._internal.Bonds) -> int

      Returns the total number of bonds between all atoms.

      2. num_bonds(self: scm.base._internal.Bonds, atom: int) -> int

      Returns the total number of bonds of an atom, given its index.

      3. num_bonds(self: scm.base._internal.Bonds, from_atom: int,
         to_atom: int) -> int

      Returns the total number of bonds between two atoms, given their
      indices.

   remove_bond(*args, **kwargs)

      Overloaded function.

      1. remove_bond(self: scm.base._internal.Bonds, bond: int) ->
         None

      Removes a bond, given its index in the .bonds attribute.

      2. remove_bond(self: scm.base._internal.Bonds, bond:
         scm.base._internal.Bond) -> None

      Removes a bond from the set.

   remove_bonds(self: Bonds, bidx: list[int]) -> None

      Removes multiple bonds at once, given their indices in the
      .bonds attribute.

   remove_bonds_between_atoms(self: Bonds, from_atom: int, to_atom: int) -> None

      Removes the bonds between two atoms, gived their indices.

   remove_bonds_to_atom(self: Bonds, atom: int) -> None

      Removes all bonds to a particular atom, given its index.

   remove_bonds_to_atoms(self: Bonds, remove_atoms: numpy.ndarray[numpy.int32[m, 1]]) -> None

      Removes all bonds for a list of atoms given by their indices.

   write_kf(self: Bonds, kf: scm.base._internal.KFFile, section: str, write_list_format: bool = True) -> None

      Writes Bonds to a section on a KF file.

   property bond_index

      Bonds are stored as sparse matrix in a modified Compressed
      Sparse Row format: The index in row_offset represents from_atom,
      and the value is an offset in column_index and bonds. The values
      in column_index represent to_atom. Because there can be
      duplicate indices (periodic bonds), it is not strictly a CSR
      matrix.

   property bonds

      Bonds are stored as sparse matrix in a modified Compressed
      Sparse Row format: The index in row_offset represents from_atom,
      and the value is an offset in column_index and bonds. The values
      in column_index represent to_atom. Because there can be
      duplicate indices (periodic bonds), it is not strictly a CSR
      matrix.

   property column_index

      Bonds are stored as sparse matrix in a modified Compressed
      Sparse Row format: The index in row_offset represents from_atom,
      and the value is an offset in column_index and bonds. The values
      in column_index represent to_atom. Because there can be
      duplicate indices (periodic bonds), it is not strictly a CSR
      matrix.

   property num_atoms

      The total number of atoms in the system.

   property num_lattice_vectors

      The number of lattice vectors of the system.

   property row_offset

      Bonds are stored as sparse matrix in a modified Compressed
      Sparse Row format: The index in row_offset represents from_atom,
      and the value is an offset in column_index and bonds. The values
      in column_index represent to_atom. Because there can be
      duplicate indices (periodic bonds), it is not strictly a CSR
      matrix.
