physics module

Full Documentation for hippynn.layers.physics module. Click here for a summary page.

Layers for physical operations

class AlphaScreening(alpha)

Bases: Module

class CombineEnergy

Bases: Module

Combines the energies (molecular and atom energies) from two different nodes, e.g. HEnergy, Coulomb, or ScreenedCoulomb Energy Nodes.

forward(atom_energy_1, atom_energy_2, mol_index, n_molecules)

Param:

atom_energy_1 per-atom energy from first node.

Param:

atom_energy_2 per atom energy from second node.

Param:

mol_index the molecular index for atoms in the batch

Param:

total number of molecules in the batch

Returns:

Total Energy

class CombineScreenings(screening_list)

Bases: Module

Returns products of different screenings for Screened Coulomb Interactions.

forward(pair_dist, radius)

Product of different screenings applied to pair_dist upto radius.

Parameters:

• pair_dist – torch.tensor, dtype=float64: ‘Neighborlist’ distances for coulomb energies.

• radius – Maximum radius that Screened-Coulomb is evaluated upto.

Return screening:

Weights for screening for all pair_dist.

class CoulombEnergy(energy_conversion_factor)

Bases: Module

Computes the Coulomb Energy of the molecule/configuration.

Coulomb energies is defined for pairs of atoms. Here, we adopt the convention that the Coulomby energy for a pair of atoms is evenly partitioned to both atoms as the ‘per-atom energies’. Therefore, the atom energies sum to the molecular energy; similar to the HEnergy.

forward(charges, pair_dist, pair_first, pair_second, mol_index, n_molecules)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class Dipole

Bases: Module

forward(charges: Tensor, positions: Tensor, mol_index: Tensor, n_molecules: int)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class EwaldRealSpaceScreening(alpha)

Bases: AlphaScreening

forward(pair_dist, radius)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class Gradient(sign)

Bases: Module

forward(molecular_energies, positions)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class LocalDampingCosine(alpha)

Bases: AlphaScreening

Local damping using complement of the hipnn cutoff function. (‘glue-on’ method) g = 1 if pair_dist > R_cutoff, 1 - [cos(pi/2 * dist * R_cutoff)]^2 otherwise

forward(pair_dist, radius)

Parameters:

• pair_dist – torch.tensor, dtype=float64: ‘Neighborlist’ distances for coulomb energies.

• radius – Maximum radius that Screened-Coulomb is evaluated upto.

Return screening:

Weights for screening for each pair.

class MultiGradient(signs)

Bases: Module

forward(molecular_energies: Tensor, *generalized_coordinates: Tensor)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class PerAtom(*args, **kwargs)

Bases: Module

forward(features, species)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class QScreening(p_value)

Bases: Module

forward(pair_dist, radius)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

property p_value

class Quadrupole(**kwargs)

Bases: Module

Computes quadrupoles as a flattened (n_molecules,9) array. NOTE: Uses normalization sum_a q_a (r_a,i*r_a,j - 1/3 delta_ij r_a^2)

forward(charges, positions, mol_index, n_molecules)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class ScreenedCoulombEnergy(energy_conversion_factor, screening, radius=None)

Bases: CoulombEnergy

Computes the Coulomb Energy of the molecule/configuration.

The convention for the atom energies is the same as CoulombEnergy and the HEnergy.

forward(charges, pair_dist, pair_first, pair_second, mol_index, n_molecules)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class StressForce(*args, **kwargs)

Bases: Module

forward(energy, strain, coordinates, cell)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class VecMag(*args, **kwargs)

Bases: Module

forward(vector_feature)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class WolfScreening(alpha)

Bases: AlphaScreening

forward(pair_dist, radius)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.