lammps_interface package

Submodules

lammps_interface.BTW module

Parameters for BTW-FF.

lammps_interface.CIFIO module

CIF format file I/O operations.

class lammps_interface.CIFIO.CIF(name='structure', file=None)

Bases: object

__dict__ = mappingproxy({'cell_length_b': <staticmethod object>, '__module__': 'lammps_interface.CIFIO', 'cell_length_a': <staticmethod object>, '__doc__': None, 'atom_site_description': <staticmethod object>, 'cell_angle_alpha': <staticmethod object>, 'atom_site_fract_z': <staticmethod object>, 'cell_length_c': <staticmethod object>, '__weakref__': <attribute '__weakref__' of 'CIF' objects>, 'read': <function CIF.read>, 'atom_site_fract_x': <staticmethod object>, 'atom_type_partial_charge': <staticmethod object>, 'get_non_loop_block': <function CIF.get_non_loop_block>, 'get_time': <function CIF.get_time>, 'atom_site_label': <staticmethod object>, 'atom_site_type_symbol': <staticmethod object>, 'general_label': <staticmethod object>, '__dict__': <attribute '__dict__' of 'CIF' objects>, '__init__': <function CIF.__init__>, 'geom_bond_site_symmetry_2': <staticmethod object>, 'geom_bond_distance': <staticmethod object>, 'cell_angle_gamma': <staticmethod object>, 'get_element_label': <function CIF.get_element_label>, 'insert_block_order': <function CIF.insert_block_order>, 'geom_bond_atom_site_label_2': <staticmethod object>, 'cell_angle_beta': <staticmethod object>, 'ccdc_geom_bond_type': <staticmethod object>, 'geom_bond_atom_site_label_1': <staticmethod object>, 'atom_site_fract_y': <staticmethod object>, 'atom_site_constraints': <staticmethod object>, 'label': <staticmethod object>, 'atom_site_fragment': <staticmethod object>, 'add_data': <function CIF.add_data>, '__str__': <function CIF.__str__>})

__init__(name='structure', file=None)

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.CIFIO'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

add_data(block, **kwargs)

static atom_site_constraints(x)

static atom_site_description(x)

static atom_site_fract_x(x)

static atom_site_fract_y(x)

static atom_site_fract_z(x)

static atom_site_fragment(x)

static atom_site_label(x)

static atom_site_type_symbol(x)

static atom_type_partial_charge(x)

static ccdc_geom_bond_type(x)

static cell_angle_alpha(x)

static cell_angle_beta(x)

static cell_angle_gamma(x)

static cell_length_a(x)

static cell_length_b(x)

static cell_length_c(x)

static general_label(x)

static geom_bond_atom_site_label_1(x)

static geom_bond_atom_site_label_2(x)

static geom_bond_distance(x)

static geom_bond_site_symmetry_2(x)

get_element_label(el)

get_non_loop_block(line)

get_time()

insert_block_order(name, index=None, _REPLACE=False)

Adds a block to the cif file in a specified order, unless index is specified, will not override existing order

static label(x)

special cases

read(filename)

lammps_interface.CIFIO.get_time()

lammps_interface.Dubbeldam module

Parameers for Dubbeldam force field.

lammps_interface.ForceFields module

Force field methods.

class lammps_interface.ForceFields.BTW_FF(**kwargs)

Bases: lammps_interface.ForceFields.ForceField

__init__(**kwargs)

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.ForceFields'

angle_term(angle)

class2 angle

NOTE: We ignored the 5and6 order terms of polynomial since the functional is not implemented in LAMMPS!!

bond_term(edge)

class2 bond: 4-order polynomial

detect_ff_terms()

Assigning force field type of atoms

dihedral_term(dihedral)

fourier diherdral

improper_term(improper)

class2 improper

pair_terms(node, data, cutoff, **kwargs)

Buckingham equation in MM3 type is used!

special_commands()

class lammps_interface.ForceFields.Dreiding(graph=None, h_bonding=False, **kwargs)

Bases: lammps_interface.ForceFields.ForceField

__init__(graph=None, h_bonding=False, **kwargs)

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.ForceFields'

angle_term(angle)

Harmonic cosine angle

E = 0.5*C*[cos(theta) - cos(theta0)]^2

This is available in LAMMPS as the cosine/squared angle style (NB. the prefactor includes the usual 1/2 term.)

if theta0 == 180, use

E = K*(1 + cos(theta))

This is available in LAMMPS as the cosine angle style

bond_term(edge)

The DREIDING Force Field contains two possible bond terms, harmonic and Morse. The authors recommend using harmonic as a default, and Morse potentials for more ‘refined’ calculations. Here we will assume a harmonic term by default, then the user can chose to switch to Morse if they so choose. (change type argument to ‘morse’)

E = 0.5 * K * (R - Req)^2

E = D * [exp{-(alpha*R - Req)} - 1]^2

detect_ff_terms()

dihedral_term(dihedral)

The DREIDING dihedral is of the form

E = 0.5*V*[1 - cos(n*(phi - phi0))]

LAMMPS has a similar potential ‘charmm’ which is described as

E = K*[1 + cos(n*phi - d)]

In this case the ‘d’ term must be multiplied by ‘n’ before inputting to lammps. In addition a +180 degrees out-of-phase shift must be added to ‘d’ to ensure that the potential behaves the same as the DREIDING article intended.

hbond_pot(node, nbpot, hnode)

DREIDING can describe hbonded donor and acceptors using a lj function or a morse potential

the morse potential is apparently better, so it will be default here

DREIDING III h-bonding terms specified in 10.1021/ja8100227.

Table S3 of the SI of 10.1021/ja8100227 is poorly documented, I have parameterized, to the best of my ability, what was intended in that paper. This message posted on the lammps-users message board http://lammps.sandia.gov/threads/msg36158.html was helpful N_3H == tertiary amine N_3P == primary amine N_3HP == protonated primary amine

nb. need connectivity information - this is accessed by self.graph

improper_term(improper)

Dreiding improper term.

        b                        J
       /                        /
      /                        /
c----a     , DREIDING =  K----I
      \                        \ 
       \                        \ 
        d                        L

For all non-planar configurations, DREIDING uses:

E = 0.5*C*(cos(phi) - cos(phi0))^2

For systems with planar equilibrium geometries, phi0 = 0

E = K*[1 - cos(phi)].

This is available in LAMMPS as the ‘umbrella’ improper potential.

pair_terms(node, data, cutoff, nbpot='LJ', hbpot='morse', charges=True)

DREIDING can adopt the exponential-6 or Ex6 = A*exp{-C*R} - B*R^{-6}

the Lennard-Jones type interactions. Elj = A*R^{-12} - B*R^{-6}

This will eventually be user-defined

special_commands()

class lammps_interface.ForceFields.Dubbeldam(graph=None, **kwargs)

Bases: lammps_interface.ForceFields.ForceField

__init__(graph=None, **kwargs)

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.ForceFields'

angle_term(angle)

bond_term(edge)

Harmonic term

E = 0.5 * K * (R - Req)^2

detect_ff_terms()

Instead of the painful experience of coding a huge set of ‘if’ statements over extended bonding neighbours to identify IRMOF-1, 10 and 16, all of the force field types will be detected from maximum cliques.

This means that failing to find the SBUs will result in a bad parameterization.

dihedral_term(dihedral)

The Dihedral potential has the form

U(torsion) = k * (1 + cos(m*theta - theta0))

in LAMMPS this potential can be accessed by the dihedral_style charmm

E = K * [ 1 + d*cos(n*theta - d) ]

improper_term(improper)

The Improper potential has the form

U(torsion) = k * (1 + cos(m*theta - theta0))

in LAMMPS this potential can be accessed by the improper_style cvff

E = K * [ 1 + d*cos(n*theta) ]

# NO out of phase shift! to get a minima at 180 set d to -1. # all of Dubbeldam’s terms are for 180 degrees out-of-plane movement so # this is fine.

pair_terms(node, data, cutoff, **kwargs)

special_commands()

class lammps_interface.ForceFields.EPM2_CO2(graph=None, **kwargs)

Bases: lammps_interface.ForceFields.ForceField

__init__(graph=None, **kwargs)

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.ForceFields'

angle_term(angle)

Harmonic angle term.

E = 0.5 * K * (theta - theta0)^2

Can be rigid or not with EPM2

bond_term(edge)

Harmonic term

E = 0.5 * K * (R - Req)^2

just a placeholder in LAMMPS. The bond is rigid therefore an unambiguous extra flag must be added here to ensure the potential is not grouped with identical (however unlikely) potentials which are not rigid.

detect_ff_terms()

CO2 consists of C and O, not too difficult.

dihedral_term(dihedral)

No dihedral potential in EPM2 CO2 model.

improper_term(improper)

No improper potential in EPM2 CO2 model.

pair_terms(node, data, cutoff, **kwargs)

Lennard - Jones potential for Cx and Ox.

special_commands()

class lammps_interface.ForceFields.FMOFCu(**kwargs)

Bases: lammps_interface.ForceFields.ForceField

__init__(**kwargs)

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.ForceFields'

angle_term(angle)

class2 angle

bond_term(edge)

class2 bond

detect_ff_terms()

dihedral_term(dihedral)

fourier diherdral

improper_term(improper)

class2 diherdral

insert_graph(graph)

pair_terms(node, data, cutoff, **kwargs)

Buckingham equation in MM3 type is used!

special_commands()

class lammps_interface.ForceFields.ForceField

Bases: object

__dict__ = mappingproxy({'bond_term': <function ForceField.bond_term>, '__weakref__': <attribute '__weakref__' of 'ForceField' objects>, 'compute_atomic_pair_terms': <function ForceField.compute_atomic_pair_terms>, '__module__': 'lammps_interface.ForceFields', '__dict__': <attribute '__dict__' of 'ForceField' objects>, '__metaclass__': <class 'abc.ABCMeta'>, '__doc__': None, 'compute_improper_terms': <function ForceField.compute_improper_terms>, 'compute_force_field_terms': <function ForceField.compute_force_field_terms>, 'dihedral_term': <function ForceField.dihedral_term>, 'angle_term': <function ForceField.angle_term>, 'compute_angle_terms': <function ForceField.compute_angle_terms>, 'compute_dihedral_terms': <function ForceField.compute_dihedral_terms>, 'improper_term': <function ForceField.improper_term>, 'compute_bond_terms': <function ForceField.compute_bond_terms>})

__metaclass__

alias of abc.ABCMeta

__module__ = 'lammps_interface.ForceFields'

__weakref__

list of weak references to the object (if defined)

abstract angle_term()

Computes the angle parameters

abstract bond_term()

Computes the bond parameters

compute_angle_terms()

compute_atomic_pair_terms()

compute_bond_terms()

compute_dihedral_terms()

compute_force_field_terms()

compute_improper_terms()

abstract dihedral_term()

Computes the dihedral parameters

abstract improper_term()

Computes the improper dihedral parameters

class lammps_interface.ForceFields.MOF_FF(**kwargs)

Bases: lammps_interface.ForceFields.ForceField

__init__(**kwargs)

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.ForceFields'

angle_term(angle)

class2 angle

Be careful that the 5and6 order terms are vanished here since they are not implemented in LAMMPS!! Etheta = 0.021914*Ktheta*(theta-theta0)^2[1-0.014(theta-theta0)+5.6(10^-5)*(theta-theta0)^2-7.0*(10^-7)*(theta-theta0)^3+9.0*(10^-10)*(theta-theta0)^4] (Allinger et. al. J.Am.Chem.Soc., Vol. 111, No. 23, 1989)

bond_term(edge)

class2 bond Es=71.94*Ks*(l-l0)^2[1-2.55(l-l0)+(7/12)*2.55*(l-l0)^2] (Allinger et. al. J.Am.Chem.Soc., Vol. 111, No. 23, 1989)

detect_ff_terms()

MOF-FF contains force field descriptions for three different inorganic SBUs: Cu-paddle-wheel Zn cluster –> IRMOF series Zr cluster –> UiO series

dihedral_term(dihedral)

fourier diherdral

Ew = (V1/2)(1 + cos w) + (V2/2)(1 - cos 2*w)+(V3/2)(1 + cos 3*w)+(V4/2)(1 + cos 4*w) (Allinger et. al. J.Am.Chem.Soc., Vol. 111, No. 23, 1989)

improper_term(improper)

Harmonic improper

pair_coul_term(node1, node2, data)

MOF-FF uses a damped gaussian for close-range interactions. This is added in a tabulated form.

k = 332.063711 kcal*angstroms/e^2

E_ij = k*qi*qj*erf(r_ij/sig_ij)/r_ij

— From Wolfram Alpha — F_ij = - (K*qi*qj) * (2/(pi^(.5) * sig_ij)) * [ e^(-r_ij^2/sig_ij^2) / r_ij - erf(r_ij/sig_ij)/r_ij^2 ] —

N is set to 1000 by default

pair_terms(node, data, cutoff, **kwargs)

Buckingham equation in MM3 type is used!

Also, Table for short range coulombic interactions

special_commands()

class lammps_interface.ForceFields.OverwriteFF(struct, base_FF)

Bases: lammps_interface.ForceFields.ForceField

Prepare a nanoprous material FF from a given structure for a known FF type.

Then overwrite any parameters that are supplied by user_input.txt

Methods are duplicated from UserFF, can reduce redundancy of code later if desired

__init__(struct, base_FF)

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.ForceFields'

map_pair_unique_bond(pair, descriptor)

map_quadruplet_unique_dihedral(quadruplet, descriptor)

map_quadruplet_unique_improper(quadruplet, descriptor)

map_triplet_unique_angle(triplet, descriptor)

map_user_to_unique_atom(descriptor)

parse_user_input(filename)

write_missing_uniques(description)

class lammps_interface.ForceFields.SPC_E(graph=None, **kwargs)

Bases: lammps_interface.ForceFields.ForceField

__init__(graph=None, **kwargs)

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.ForceFields'

angle_term(angle)

Harmonic angle term.

E = 0.5 * K * (theta - theta0)^2

just a placeholder in LAMMPS. The angle is rigid and fixed by SHAKE in LAMMPS therefore an unambiguous extra flag must be added here to ensure the potential is not grouped with identical (however unlikely) potentials which are not rigid.

bond_term(edge)

Harmonic term

E = 0.5 * K * (R - Req)^2

just a placeholder in LAMMPS. The bond is rigid and fixed by SHAKE in LAMMPS therefore an unambiguous extra flag must be added here to ensure the potential is not grouped with identical (however unlikely) potentials which are not rigid.

detect_ff_terms()

Water consists of O and H, not too difficult.

dihedral_term(dihedral)

No dihedral potential in SPC/E water model.

improper_term(improper)

No improper potential in SPC/E water model.

pair_terms(node, data, cutoff, **kwargs)

Lennard - Jones potential for OW and HW.

cutoff should be set to 9 angstroms, but this may be unrealistic. Also, no long range treatment of coulombic term! Otherwise this isn’t technically the SPC/E model but Ewald should be used for periodic materials.

special_commands()

class lammps_interface.ForceFields.TIP3P(graph=None, **kwargs)

Bases: lammps_interface.ForceFields.ForceField

__init__(graph=None, **kwargs)

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.ForceFields'

angle_term(angle)

Harmonic angle term.

E = 0.5 * K * (theta - theta0)^2

just a placeholder in LAMMPS. The angle is rigid and fixed by SHAKE in LAMMPS therefore an unambiguous extra flag must be added here to ensure the potential is not grouped with identical (however unlikely) potentials which are not rigid.

bond_term(edge)

Harmonic term

E = 0.5 * K * (R - Req)^2

just a placeholder in LAMMPS. The bond is rigid and fixed by SHAKE in LAMMPS therefore an unambiguous extra flag must be added here to ensure the potential is not grouped with identical (however unlikely) potentials which are not rigid.

detect_ff_terms()

Water consists of O and H, not too difficult.

dihedral_term(dihedral)

No dihedral potential in TIP3P water model.

improper_term(improper)

No improper potential in TIP3P water model.

pair_terms(node, data, cutoff, **kwargs)

Lennard - Jones potential for OW and HW.

special_commands()

class lammps_interface.ForceFields.TIP4P(graph=None, **kwargs)

Bases: lammps_interface.ForceFields.ForceField, lammps_interface.Molecules.TIP4P_Water

__init__(graph=None, **kwargs)

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.ForceFields'

angle_term(angle)

Harmonic angle term.

E = 0.5 * K * (theta - theta0)^2

just a placeholder in LAMMPS. The angle is rigid and fixed by SHAKE in LAMMPS therefore an unambiguous extra flag must be added here to ensure the potential is not grouped with identical (however unlikely) potentials which are not rigid.

bond_term(edge)

Harmonic term

E = 0.5 * K * (R - Req)^2

just a placeholder in LAMMPS. The bond is rigid and fixed by SHAKE in LAMMPS therefore an unambiguous extra flag must be added here to ensure the potential is not grouped with identical (however unlikely) potentials which are not rigid.

detect_ff_terms()

Water consists of O and H, not too difficult.

dihedral_term(dihedral)

No dihedral potential in TIP4P water model.

improper_term(improper)

No improper potential in TIP4P water model.

pair_terms(node, data, cutoff, **kwargs)

Lennard - Jones potential for OW and HW.

special_commands()

class lammps_interface.ForceFields.TIP5P(graph=None, **kwargs)

Bases: lammps_interface.ForceFields.ForceField

__init__(graph=None, **kwargs)

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.ForceFields'

angle_term(angle)

Harmonic angle term.

E = 0.5 * K * (theta - theta0)^2

just a placeholder in LAMMPS. The angle is rigid and fixed by SHAKE in LAMMPS therefore an unambiguous extra flag must be added here to ensure the potential is not grouped with identical (however unlikely) potentials which are not rigid.

bond_term(edge)

Harmonic term

E = 0.5 * K * (R - Req)^2

just a placeholder in LAMMPS. The bond is rigid and fixed by SHAKE in LAMMPS therefore an unambiguous extra flag must be added here to ensure the potential is not grouped with identical (however unlikely) potentials which are not rigid.

detect_ff_terms()

Water consists of O and H, not too difficult.

dihedral_term(dihedral)

No dihedral potential in TIP5P water model.

improper_term(improper)

No improper potential in TIP5P water model.

pair_terms(node, data, cutoff, **kwargs)

Lennard - Jones potential for OW and HW.

special_commands()

class lammps_interface.ForceFields.UFF(**kwargs)

Bases: lammps_interface.ForceFields.ForceField

Parameterize the periodic material with the UFF parameters. NB: I have come across important information regarding the implementation of UFF from the author of MCCCS TOWHEE. It can be found here: (as of 05/11/2015) http://towhee.sourceforge.net/forcefields/uff.html

The ammendments mentioned that document are included here

__init__(**kwargs)

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.ForceFields'

angle_term(angle)

several cases exist where the type of atom in a particular environment is considered in both the parameters and the functional form of the term.

A small cosine fourier expansion in (theta) E_0 = K_{IJK} * {sum^{m}_{n=0}}C_{n} * cos(n*theta)

Linear, trigonal-planar, square-planar, and octahedral: two-term expansion of the above equation, n=0 as well as n=1, n=3, n=4, and n=4 for the above geometries. E_0 = K_{IJK}/n^2 * [1 - cos(n*theta)]

in Lammps, the angle syle called ‘fourier/simple’ can be used to describe this functional form.

general non-linear case: three-term Fourier expansion E_0 = K_{IJK} * [C_0 + C_1*cos(theta) + C_2*cos(2*theta)]

in Lammps, the angle style called ‘fourier’ can be used to describe this functional form.

Both ‘fourier/simple’ and ‘fourier’ are available from the USER_MISC package in Lammps, so be sure to compile Lammps with this package.

bond_term(edge)

Harmonic assumed

detect_ff_terms()

dihedral_term(dihedral)

Use a small cosine Fourier expansion

E_phi = 1/2*V_phi * [1 - cos(n*phi0)*cos(n*phi)]

this is available in Lammps in the form of a harmonic potential E = K * [1 + d*cos(n*phi)]

NB: the d term must be negated to recover the UFF potential.

improper_term(improper)

The improper function can be described with a fourier function

E = K*[C_0 + C_1*cos(w) + C_2*cos(2*w)]

NB: not sure if keep metal geometry is important here.

pair_terms(node, data, cutoff, charges=True)

Add L-J term to atom

special_commands()

uff_angle_type(b)

class lammps_interface.ForceFields.UFF4MOF(**kwargs)

Bases: lammps_interface.ForceFields.ForceField

Parameterize the periodic material with the UFF4MOF parameters.

__init__(**kwargs)

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.ForceFields'

angle_term(angle)

several cases exist where the type of atom in a particular environment is considered in both the parameters and the functional form of the term.

A small cosine fourier expansion in (theta) E_0 = K_{IJK} * {sum^{m}_{n=0}}C_{n} * cos(n*theta)

Linear, trigonal-planar, square-planar, and octahedral: two-term expansion of the above equation, n=0 as well as n=1, n=3, n=4, and n=4 for the above geometries. E_0 = K_{IJK}/n^2 * [1 - cos(n*theta)]

in Lammps, the angle syle called ‘fourier/simple’ can be used to describe this functional form.

general non-linear case: three-term Fourier expansion E_0 = K_{IJK} * [C_0 + C_1*cos(theta) + C_2*cos(2*theta)]

in Lammps, the angle style called ‘fourier’ can be used to describe this functional form.

Both ‘fourier/simple’ and ‘fourier’ are available from the USER_MISC package in Lammps, so be sure to compile Lammps with this package.

bond_term(edge)

Harmonic assumed

detect_ff_terms()

All new terms are associated with inorganic clusters, and the number of cases are extensive. Implementation of all of the metal types would require a bit of effort, but should be done in the near future.

dihedral_term(dihedral)

Use a small cosine Fourier expansion

E_phi = 1/2*V_phi * [1 - cos(n*phi0)*cos(n*phi)]

this is available in Lammps in the form of a harmonic potential E = K * [1 + d*cos(n*phi)]

NB: the d term must be negated to recover the UFF potential.

improper_term(improper)

Improper term described by a Fourier function

E = K*[C_0 + C_1*cos(w) + C_2*cos(2*w)]

pair_terms(node, data, cutoff, charges=True)

Add L-J term to atom

special_commands()

uff_angle_type(b)

class lammps_interface.ForceFields.UserFF(graph)

Bases: lammps_interface.ForceFields.ForceField

__init__(graph)

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.ForceFields'

angle_term(angle)

Computes the angle parameters

bond_term(bond)

Computes the bond parameters

compute_force_field_terms()

dihedral_term(dihedral)

Computes the dihedral parameters

improper_term(improper)

Computes the improper dihedral parameters

map_pair_unique_bond(pair, descriptor)

map_quadruplet_unique_dihedral(quadruplet, descriptor)

map_quadruplet_unique_improper(quadruplet, descriptor)

map_triplet_unique_angle(triplet, descriptor)

map_user_to_unique_atom(descriptor)

overwrite_force_field_terms()

parse_user_input(filename)

unique_angles()

unique_atoms()

unique_bonds()

unique_dihedrals()

unique_impropers()

How many times to list the same set of atoms ???

van_der_waals_pairs()

write_missing_uniques(description)

lammps_interface.InputHandler module

Argument parser for command line interface.

class lammps_interface.InputHandler.Options

Bases: object

__dict__ = mappingproxy({'run_command_line_options': <function Options.run_command_line_options>, '__doc__': None, '__weakref__': <attribute '__weakref__' of 'Options' objects>, '_set_attr': <function Options._set_attr>, '__module__': 'lammps_interface.InputHandler', '__dict__': <attribute '__dict__' of 'Options' objects>, '__init__': <function Options.__init__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.InputHandler'

__weakref__

list of weak references to the object (if defined)

_set_attr(args)

run_command_line_options()

lammps_interface.InputHandler.git_revision_hash()

lammps_interface.MOFFF module

MOF-FF parameters.

lammps_interface.Molecules module

Molecule class.

class lammps_interface.Molecules.CO2(**kwargs)

Bases: lammps_interface.Molecules.Molecule

Carbon dioxide parent class, containing functions applicable to all CO2 models.

property O_coord

Define the oxygen coordinates assuming carbon is centered at ‘0’. angle gives the two oxygen atoms an orientation that deviates randomly from the default (lying along the x-axis).

__module__ = 'lammps_interface.Molecules'

approximate_positions(C_pos=None, O_pos1=None, O_pos2=None)

Input a set of approximate positions for the carbon and oxygens of CO2, and determine the lowest RMSD that would give the idealized model.

class lammps_interface.Molecules.EPM2_CO2(**kwargs)

Bases: lammps_interface.Molecules.CO2

RCO = 1.149

__init__(**kwargs)

Elementary Physical Model 2 (EPM2) of Harris & Yung (JPC 1995 99 12021) dx.doi.org/10.1021/j100031a034

__module__ = 'lammps_interface.Molecules'

class lammps_interface.Molecules.Molecule(**kwargs)

Bases: lammps_interface.structure_data.MolecularGraph

__module__ = 'lammps_interface.Molecules'

property _type_

compute_all_angles()

rotation_from_vectors(v1, v2)

Obtain rotation matrix from sets of vectors. the original set is v1 and the vectors to rotate to are v2.

rotation_matrix(axis, angle)

returns a 3x3 rotation matrix based on the provided axis and angle

str(atom_types={}, bond_types={}, angle_types={}, dihedral_types={}, improper_types={})

Create a molecule template string for writing to a file. Ideal for using fix gcmc or fix deposit in LAMMPS.

class lammps_interface.Molecules.TIP4P_Water(**kwargs)

Bases: lammps_interface.Molecules.Water

HOH = 104.52

ROH = 0.9572

Rdum = 0.125

__init__(**kwargs)

Class that provides a template molecule for TIP4P Water.

LAMMPS has some builtin features for this molecule which are not taken advantage of here.

I haven’t bothered constructing a robust way to implement this special case, where there is no need to explicilty describe the dummy atom. This is handeled internally by LAMMPS.

__module__ = 'lammps_interface.Molecules'

property dummy

class lammps_interface.Molecules.TIP5P_Water(**kwargs)

Bases: lammps_interface.Molecules.Water

DOD = 109.47

HOH = 104.52

ROH = 0.9572

Rdum = 0.7

__init__(**kwargs)

Class that provides a template molecule for TIP5P Water.

No built in features for TIP5P so the dummy atoms must be explicitly described. Geometric features are evaluated to ensure the proper configuration to support TIP5P.

Initially set up a default TIP5P water configuration, then update if needed if superposing a TIP5P particle on an existing water.

__module__ = 'lammps_interface.Molecules'

property dummy

Given that the H_coords are determined from an angle with the x-axis in the xy plane, here we will also use the x-axis, only project the dummy atoms in the xz plane. This will produce, if all angles are 109.5 and distances the same, a perfect tetrahedron, however if the angles and distances are different, will produce a geometry with the highest possible symmetry.

class lammps_interface.Molecules.Water(**kwargs)

Bases: lammps_interface.Molecules.Molecule

Water parent class, containing functions applicable to all water models.

property H_coord

Define the hydrogen coords based on HOH angle for the specific force field. Default axis for distributing the hydrogen atoms is the x-axis.

__module__ = 'lammps_interface.Molecules'

approximate_positions(O_pos=None, H_pos1=None, H_pos2=None)

Input a set of approximate positions for the oxygen and hydrogens of water, and determine the lowest RMSD that would give the idealized water model.

compute_midpoint_vector(centre_vec, side1_vec, side2_vec)

Define a vector oriented away from the centre_vec which is half-way between side1_vec and side2_vec. Ideal for TIP4P to define the dummy atom.

compute_orthogonal_vector(centre_vec, side1_vec, side2_vec)

Define a vector oriented orthogonal to two others, centred by the ‘centre_vec’.

Useful for other water models with dummy atoms, as this can be used as a ‘4th’ vector for the ‘rotation_from_vectors’ calculation (since 3 vectors defined by O, H, and H is not enough to orient properly). The real dummy atoms can then be applied once the proper rotation has been found.

lammps_interface.atomic module

Elemental information.

lammps_interface.ccdc module

Bond order information.

lammps_interface.create_cluster module

lammps_interface.create_cluster_v2 module

main.py

the program starts here.

class lammps_interface.create_cluster_v2.Cluster(mgraph, xyz, offset, rcut)

Bases: object

__dict__ = mappingproxy({'cap_by_material': <function Cluster.cap_by_material>, '__module__': 'lammps_interface.create_cluster_v2', 'identify_mat_type': <function Cluster.identify_mat_type>, 'cap_zeolite': <function Cluster.cap_zeolite>, 'cart_dist': <function Cluster.cart_dist>, 'cap_zeolite_v2': <function Cluster.cap_zeolite_v2>, 'cxtd_comp_from_undirected': <function Cluster.cxtd_comp_from_undirected>, '__doc__': None, 'cap_primary_cluster': <function Cluster.cap_primary_cluster>, 'parse_sym_flag_for_directionality': <function Cluster.parse_sym_flag_for_directionality>, 'identify_1D_building_blocks': <function Cluster.identify_1D_building_blocks>, 'get_nth_heirarcy_BFS_tree': <function Cluster.get_nth_heirarcy_BFS_tree>, 'truncation_criteria': <function Cluster.truncation_criteria>, 'disconnect_external_building_blocks': <function Cluster.disconnect_external_building_blocks>, 'write_map_from_MOLECULE_to_unique_types': <function Cluster.write_map_from_MOLECULE_to_unique_types>, '__weakref__': <attribute '__weakref__' of 'Cluster' objects>, 'create_cluster_around_point': <function Cluster.create_cluster_around_point>, 'write_cutoff': <function Cluster.write_cutoff>, 'cxtd_comp_continuous': <function Cluster.cxtd_comp_continuous>, 'preliminary_truncate_BFS_tree': <function Cluster.preliminary_truncate_BFS_tree>, 'cap_1D_organic': <function Cluster.cap_1D_organic>, 'write_map_from_cluster_xyz_to_unique_types': <function Cluster.write_map_from_cluster_xyz_to_unique_types>, 'cut_cappable_bonds': <function Cluster.cut_cappable_bonds>, 'cxtd_comp_convert_to_orig': <function Cluster.cxtd_comp_convert_to_orig>, 'visualize_n_levels_of_tree': <function Cluster.visualize_n_levels_of_tree>, 'write_cluster_to_xyz_host_guest_v2': <function Cluster.write_cluster_to_xyz_host_guest_v2>, 'identify_all_truncations': <function Cluster.identify_all_truncations>, 'disconnect_1D_building_blocks': <function Cluster.disconnect_1D_building_blocks>, 'compute_cluster_in_disgraph': <function Cluster.compute_cluster_in_disgraph>, 'truncate_all': <function Cluster.truncate_all>, 'iterative_BFS_tree_structure': <function Cluster.iterative_BFS_tree_structure>, 'modify_structure_w_hydrogens': <function Cluster.modify_structure_w_hydrogens>, '__init__': <function Cluster.__init__>, 'create_cluster_around_point_v2': <function Cluster.create_cluster_around_point_v2>, 'write_cluster_to_host_xyz_v2': <function Cluster.write_cluster_to_host_xyz_v2>, 'compute_cluster_in_tree': <function Cluster.compute_cluster_in_tree>, 'compute_primary_cluster': <function Cluster.compute_primary_cluster>, 'create_cluster_around_point_v3': <function Cluster.create_cluster_around_point_v3>, 'cxtd_comp_num_keep': <function Cluster.cxtd_comp_num_keep>, 'cxtd_comp_cap': <function Cluster.cxtd_comp_cap>, 'nodes_w_2plus_parents': <function Cluster.nodes_w_2plus_parents>, 'cxtd_comp_secondary_graph': <function Cluster.cxtd_comp_secondary_graph>, 'compute_required_caps': <function Cluster.compute_required_caps>, 'cap_3D_organic': <function Cluster.cap_3D_organic>, 'nodes_that_DNE_in_origraph': <function Cluster.nodes_that_DNE_in_origraph>, 'get_BFS_tree': <function Cluster.get_BFS_tree>, 'get_start_and_kept_nodes': <function Cluster.get_start_and_kept_nodes>, 'write_LSDALTON': <function Cluster.write_LSDALTON>, '__dict__': <attribute '__dict__' of 'Cluster' objects>, 'write_cluster_to_xyz': <function Cluster.write_cluster_to_xyz>, 'debug_edges_to_cut': <function Cluster.debug_edges_to_cut>, 'update_num_keep': <function Cluster.update_num_keep>, 'cxtd_comp_to_keep': <function Cluster.cxtd_comp_to_keep>})

__init__(mgraph, xyz, offset, rcut)

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.create_cluster_v2'

__weakref__

list of weak references to the object (if defined)

cap_1D_organic()

cap_3D_organic()

Cap a MOF (or COF, COP, whatever), that is a 3-D network (i.e. doens’t have 1D rods)

cap_by_material()

cap_primary_cluster()

cap_zeolite()

Cap a zeolite, not an extremeley difficult case

cap_zeolite_v2()

Cap a zeolite, not an extremeley difficult case

cart_dist(pts1, pts2)

Cartesian distance between 2 points

compute_cluster_in_disgraph()

compute_cluster_in_tree()

compute_primary_cluster()

compute_required_caps()

create_cluster_around_point()

create_cluster_around_point_v2()

A BFS search approach to creating clusters

create_cluster_around_point_v3()

Basic strategy here is to disconnect the graph at valid truncations

All the connected components are then condensed into a single node to form a secondary graph

This is the best way to make sure that in the end we perform the capping properly

cut_cappable_bonds()

cxtd_comp_cap()

cxtd_comp_continuous()

This part is critical, make sure that the final list of connected components forms a continuous network in secondary graph

In other words, the final cluster MUST not be a disconnected graph

cxtd_comp_convert_to_orig()

Temporary convert so that the files can be written

cxtd_comp_from_undirected()

Find connected components of the disconnect graph

cxtd_comp_num_keep()

cxtd_comp_secondary_graph()

Create a secondary graph with all the connected components

cxtd_comp_to_keep()

Identify which connected components have an atom within the cutoff radius

debug_edges_to_cut()

disconnect_1D_building_blocks()

Disconnect 1D rods so they can actually be capped

Best thing to do is still apply the same disconnection algorithm, only this time we are allowed to break a bond between a type in self.metals and [6,7,8]

disconnect_external_building_blocks()

Break a super simulation box into every possible component where each disconnected bond represents a cappable bond BUT we only break bonds that straddle or are external to the cluster cutoff radius

get_BFS_tree()

get_nth_heirarcy_BFS_tree(n)

get_start_and_kept_nodes()

Analyze a super box of a nanoporous material

Determine which nodes are inside the cutoff and which nodes are outside

Return the index of the starting node we will use to build the cluster

identify_1D_building_blocks()

By going through each component determined from all_external_building_blocks() we can determine if the MOF is 1D rod. If a component has two edges that eg have ‘symflag’ attribute of (4,x,x) and (6,x,x) respectively, then we found a component that spans across one crystallographic direction and reconnects with itself. This is the definition of a 1D rod MOF

identify_all_truncations()

Identify all truncations to make in the graph

identify_mat_type()

For now just a basic check to classify a zeolite vs an organic (MOF, COF, etc)

iterative_BFS_tree_structure(v)

Construct a dict with key that indexes depth of BFS tree, and the value is a set of all nodes at that depth

modify_structure_w_hydrogens()

nodes_that_DNE_in_origraph()

nodes_w_2plus_parents()

parse_sym_flag_for_directionality(string)

symm flag looks ‘like 1_455’ where 4 denotes a periodic bond in the x direction where 5 denotes a non periodic bond in the y, z direction

preliminary_truncate_BFS_tree()

truncate_all()

truncation_criteria(up_node, down_node)

update_num_keep()

visualize_n_levels_of_tree(n)

write_LSDALTON(location)

Write the LSDALTON file for DEC-MP2

write_cluster_to_host_xyz_v2()

Write the computed and capped cluster to an xyz file

write_cluster_to_xyz()

Write the computed and capped cluster to an xyz file

write_cluster_to_xyz_host_guest_v2(include_guest)

Write the computed and capped cluster to an xyz file

write_cutoff()

Write the cutoff that was used to make this cluster

write_map_from_MOLECULE_to_unique_types()

write_map_from_cluster_xyz_to_unique_types()

class lammps_interface.create_cluster_v2.LammpsSimulation(options)

Bases: object

__dict__ = mappingproxy({'unique_angles': <function LammpsSimulation.unique_angles>, '__doc__': None, 'increment_graph_sizes': <function LammpsSimulation.increment_graph_sizes>, '__module__': 'lammps_interface.create_cluster_v2', 'unique_impropers': <function LammpsSimulation.unique_impropers>, 'count_angles': <function LammpsSimulation.count_angles>, 'construct_input_file': <function LammpsSimulation.construct_input_file>, 'set_MDMC_config': <function LammpsSimulation.set_MDMC_config>, 'unique_atoms': <function LammpsSimulation.unique_atoms>, 'set_graph': <function LammpsSimulation.set_graph>, '__weakref__': <attribute '__weakref__' of 'LammpsSimulation' objects>, 'set_cell': <function LammpsSimulation.set_cell>, 'count_dihedrals': <function LammpsSimulation.count_dihedrals>, 'merge_graphs': <function LammpsSimulation.merge_graphs>, 'unique_dihedrals': <function LammpsSimulation.unique_dihedrals>, 'unique_pair_terms': <function LammpsSimulation.unique_pair_terms>, 'assign_force_fields': <function LammpsSimulation.assign_force_fields>, 'compute_molecules': <function LammpsSimulation.compute_molecules>, 'compute_cluster_box_size': <function LammpsSimulation.compute_cluster_box_size>, 'count_impropers': <function LammpsSimulation.count_impropers>, 'construct_data_file': <function LammpsSimulation.construct_data_file>, '__init__': <function LammpsSimulation.__init__>, 'compute_simulation_size': <function LammpsSimulation.compute_simulation_size>, 'groups': <function LammpsSimulation.groups>, 'molecule_template': <function LammpsSimulation.molecule_template>, 'fixcount': <function LammpsSimulation.fixcount>, 'unique_bonds': <function LammpsSimulation.unique_bonds>, 'write_lammps_files': <function LammpsSimulation.write_lammps_files>, 'cut_molecule': <function LammpsSimulation.cut_molecule>, 'split_graph': <function LammpsSimulation.split_graph>, 'define_styles': <function LammpsSimulation.define_styles>, 'assign_molecule_ids': <function LammpsSimulation.assign_molecule_ids>, '__dict__': <attribute '__dict__' of 'LammpsSimulation' objects>, 'add_water_model': <function LammpsSimulation.add_water_model>})

__init__(options)

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.create_cluster_v2'

__weakref__

list of weak references to the object (if defined)

add_water_model(ngraph, ff)

assign_force_fields()

assign_molecule_ids(graph)

compute_cluster_box_size()

Added by MW b/c simbox size can need to be even bigger than a normal simbox when we are making a cluster from one unit cell

compute_molecules(size_cutoff=0.5)

Ascertain if there are molecules within the porous structure

compute_simulation_size()

construct_data_file()

construct_input_file()

Input file will depend on what the user wants to do

count_angles()

count_dihedrals()

count_impropers()

cut_molecule(nodes)

define_styles()

fixcount(count=[])

groups(ints)

increment_graph_sizes(inc=1)

merge_graphs()

molecule_template(mol)

Construct a molecule template for reading and insertions in a LAMMPS simulation.

Not sure how the bonding, angle, dihedral, improper, and pair terms will be dealt with yet..

set_MDMC_config(MDMC_config)

set_cell(cell)

set_graph(graph)

split_graph()

unique_angles()

unique_atoms()

Computes the number of unique atoms in the structure

unique_bonds()

Computes the number of unique bonds in the structure

unique_dihedrals()

unique_impropers()

unique_pair_terms()

write_lammps_files()

lammps_interface.create_cluster_v2.main()

lammps_interface.create_cluster_v2.read_xyz_center(filename)

lammps_interface.dreiding module

Parameters for DREIDING force field.

lammps_interface.gas_models module

Gas models.

lammps_interface.generic_raspa module

RASPA file format and default parameters.

lammps_interface.lammps_main module

Lammps interface main program. Lammps simulations are setup here.

class lammps_interface.lammps_main.LammpsSimulation(options)

Bases: object

__dict__ = mappingproxy({'compute_molecules': <function LammpsSimulation.compute_molecules>, 'unique_angles': <function LammpsSimulation.unique_angles>, '__doc__': None, 'increment_graph_sizes': <function LammpsSimulation.increment_graph_sizes>, 'unique_pair_terms': <function LammpsSimulation.unique_pair_terms>, '__module__': 'lammps_interface.lammps_main', 'unique_impropers': <function LammpsSimulation.unique_impropers>, '__init__': <function LammpsSimulation.__init__>, 'unique_atoms': <function LammpsSimulation.unique_atoms>, 'construct_input_file': <function LammpsSimulation.construct_input_file>, 'compute_simulation_size': <function LammpsSimulation.compute_simulation_size>, 'unique_dihedrals': <function LammpsSimulation.unique_dihedrals>, 'set_MDMC_config': <function LammpsSimulation.set_MDMC_config>, '__dict__': <attribute '__dict__' of 'LammpsSimulation' objects>, 'groups': <function LammpsSimulation.groups>, 'molecule_template': <function LammpsSimulation.molecule_template>, 'fixcount': <function LammpsSimulation.fixcount>, 'unique_bonds': <function LammpsSimulation.unique_bonds>, 'set_graph': <function LammpsSimulation.set_graph>, '__weakref__': <attribute '__weakref__' of 'LammpsSimulation' objects>, 'cut_molecule': <function LammpsSimulation.cut_molecule>, 'set_cell': <function LammpsSimulation.set_cell>, 'merge_graphs': <function LammpsSimulation.merge_graphs>, 'split_graph': <function LammpsSimulation.split_graph>, 'define_styles': <function LammpsSimulation.define_styles>, 'assign_molecule_ids': <function LammpsSimulation.assign_molecule_ids>, 'add_co2_model': <function LammpsSimulation.add_co2_model>, 'assign_force_fields': <function LammpsSimulation.assign_force_fields>, 'write_lammps_files': <function LammpsSimulation.write_lammps_files>, 'construct_data_file': <function LammpsSimulation.construct_data_file>, 'add_water_model': <function LammpsSimulation.add_water_model>})

__init__(options)

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_main'

__weakref__

list of weak references to the object (if defined)

add_co2_model(ngraph, ff)

add_water_model(ngraph, ff)

assign_force_fields()

assign_molecule_ids(graph)

compute_molecules(size_cutoff=0.5)

Ascertain if there are molecules within the porous structure

compute_simulation_size()

construct_data_file()

construct_input_file()

Input file construction based on user-defined inputs.

NB: This function is getting huge. We should probably break it up into logical sub-sections.

cut_molecule(nodes)

define_styles()

fixcount(count=[])

groups(ints)

increment_graph_sizes(inc=1)

merge_graphs()

molecule_template(mol)

Construct a molecule template for reading and insertions in a LAMMPS simulation.

This combines two classes which have been separated conceptually - ForceField and Molecules. For some molecules, the force field is implicit within the structure (e.g. TIP5P_Water molecule must be used with the TIP5P ForceField). But one can imagine cases where this is not true (alkanes? CO2?).

set_MDMC_config(MDMC_config)

set_cell(cell)

set_graph(graph)

split_graph()

unique_angles(g)

unique_atoms(g)

Computes the number of unique atoms in the structure

unique_bonds(g)

Computes the number of unique bonds in the structure

unique_dihedrals(g)

unique_impropers(g)

unique_pair_terms()

write_lammps_files(wd=None)

lammps_interface.lammps_main.main()

lammps_interface.lammps_potentials module

Lammps potentital types.

class lammps_interface.lammps_potentials.AnglePotential

Bases: object

Class to hold angle styles that are implemented in lammps

class Charmm

Bases: object

Potential defined as

E = K*(theta - theta0)^2 + Kub*(r - Rub)^2

Input parameters: K, theta0, Kub, Rub

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Charmm' objects>, '__doc__': 'Potential defined as\n\n E = K*(theta - theta0)^2 + Kub*(r - Rub)^2\n\n Input parameters: K, theta0, Kub, Rub\n ', '__dict__': <attribute '__dict__' of 'Charmm' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function AnglePotential.Charmm.__init__>, '__str__': <function AnglePotential.Charmm.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Class2

Bases: object

Potential defined as

E = Ea + Ebb + Eba Ea = K2*(theta - theta0)^2 + K3*(theta - theta0)^3 + K4*(theta - theta0)^4 Ebb = M*(r_ij - r1)*(r_jk - r2) Eba = N1*(r_ij - r1)*(theta - theta0) + N2*(rjk - r2)*(theta - theta0)

Input parameters for each potential: Angle: theta0 (degrees), K2(energy/rad^2), K3(energy/rad^3),K4(energy/rad^4) BondBond: bb, M(energy/distance^2), r1(distance), r2(distance) BondAngle: ba, N1(energy/distance^2), N2(energy/distance^2),r1(distance), r2(distance)

class BondAngle

Bases: object

Potential defined as —-> Eba = N1*(r_ij - r1)*(theta - theta0) + N2*(r_jk - r2)*(theta - theta0) <—-

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'BondAngle' objects>, '__doc__': 'Potential defined as\n ----> Eba = N1*(r_ij - r1)*(theta - theta0) + N2*(r_jk - r2)*(theta - theta0) <----\n ', '__dict__': <attribute '__dict__' of 'BondAngle' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function AnglePotential.Class2.BondAngle.__init__>, '__str__': <function AnglePotential.Class2.BondAngle.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class BondBond

Bases: object

Potential defined as —-> Ebb = M*(r_ij - r1)*(r_jk - r2) <—-

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'BondBond' objects>, '__doc__': 'Potential defined as\n ----> Ebb = M*(r_ij - r1)*(r_jk - r2) <----\n ', '__dict__': <attribute '__dict__' of 'BondBond' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function AnglePotential.Class2.BondBond.__init__>, '__str__': <function AnglePotential.Class2.BondBond.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

__dict__ = mappingproxy({'__init__': <function AnglePotential.Class2.__init__>, 'BondBond': <class 'lammps_interface.lammps_potentials.AnglePotential.Class2.BondBond'>, '__weakref__': <attribute '__weakref__' of 'Class2' objects>, '__doc__': 'Potential defined as\n\n E = Ea + Ebb + Eba\n Ea = K2*(theta - theta0)^2 + K3*(theta - theta0)^3 + K4*(theta - theta0)^4\n Ebb = M*(r_ij - r1)*(r_jk - r2)\n Eba = N1*(r_ij - r1)*(theta - theta0) + N2*(rjk - r2)*(theta - theta0)\n\n Input parameters for each potential:\n Angle: theta0 (degrees), K2(energy/rad^2), K3(energy/rad^3),K4(energy/rad^4)\n BondBond: bb, M(energy/distance^2), r1(distance), r2(distance)\n BondAngle: ba, N1(energy/distance^2), N2(energy/distance^2),r1(distance), r2(distance)\n ', '__dict__': <attribute '__dict__' of 'Class2' objects>, 'BondAngle': <class 'lammps_interface.lammps_potentials.AnglePotential.Class2.BondAngle'>, '__module__': 'lammps_interface.lammps_potentials', '__str__': <function AnglePotential.Class2.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Cosine

Bases: object

Potential defined as

E = K*[1 - cos(theta)]

Input parameters: K

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Cosine' objects>, '__doc__': 'Potential defined as\n\n E = K*[1 - cos(theta)]\n\n Input parameters: K\n ', '__dict__': <attribute '__dict__' of 'Cosine' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function AnglePotential.Cosine.__init__>, '__str__': <function AnglePotential.Cosine.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class CosineDelta

Bases: object

Potential defined as

E = K*[1 - cos(theta-theta0)]

Input parameters: K, theta0

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'CosineDelta' objects>, '__doc__': 'Potential defined as\n\n E = K*[1 - cos(theta-theta0)]\n\n Input parameters: K, theta0\n ', '__dict__': <attribute '__dict__' of 'CosineDelta' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function AnglePotential.CosineDelta.__init__>, '__str__': <function AnglePotential.CosineDelta.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class CosinePeriodic

Bases: object

Potential defined as

E = C*[1 - B*(-1)^n*cos(n*theta)]

Input parameters: C, B, n

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'CosinePeriodic' objects>, '__doc__': 'Potential defined as\n\n E = C*[1 - B*(-1)^n*cos(n*theta)]\n\n Input parameters: C, B, n\n ', '__dict__': <attribute '__dict__' of 'CosinePeriodic' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function AnglePotential.CosinePeriodic.__init__>, '__str__': <function AnglePotential.CosinePeriodic.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class CosineShift

Bases: object

Potential defined as

E = -Umin/2 * [1 + cos(theta - theta0)]

Input parameters: Umin, theta0

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'CosineShift' objects>, '__doc__': 'Potential defined as\n\n E = -Umin/2 * [1 + cos(theta - theta0)]\n\n Input parameters: Umin, theta0\n ', '__dict__': <attribute '__dict__' of 'CosineShift' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function AnglePotential.CosineShift.__init__>, '__str__': <function AnglePotential.CosineShift.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class CosineShiftExp

Bases: object

Potential defined as

E = -Umin * [e^{-a*U(theta,theta0)} - 1] / [e^a - 1]

where U(theta,theta0) = -0.5*(1 + cos(theta - theta0))

Input parameters: Umin, theta0, a

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'CosineShiftExp' objects>, '__doc__': 'Potential defined as\n\n E = -Umin * [e^{-a*U(theta,theta0)} - 1] / [e^a - 1]\n\n where U(theta,theta0) = -0.5*(1 + cos(theta - theta0))\n\n Input parameters: Umin, theta0, a\n ', '__dict__': <attribute '__dict__' of 'CosineShiftExp' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function AnglePotential.CosineShiftExp.__init__>, '__str__': <function AnglePotential.CosineShiftExp.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class CosineSquared

Bases: object

Potential defined as

E = K*[cos(theta) - cos(theta0)]^2

Input parameters: K, theta0

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'CosineSquared' objects>, '__doc__': 'Potential defined as\n\n E = K*[cos(theta) - cos(theta0)]^2\n\n Input parameters: K, theta0\n ', '__dict__': <attribute '__dict__' of 'CosineSquared' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function AnglePotential.CosineSquared.__init__>, '__str__': <function AnglePotential.CosineSquared.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Dipole

Bases: object

Potential defined as

E = K*(cos(gamma) - cos(gamma0))^2

Input parameters: K, gamma0

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Dipole' objects>, '__doc__': 'Potential defined as\n\n E = K*(cos(gamma) - cos(gamma0))^2\n\n Input parameters: K, gamma0\n ', '__dict__': <attribute '__dict__' of 'Dipole' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function AnglePotential.Dipole.__init__>, '__str__': <function AnglePotential.Dipole.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Fourier

Bases: object

Potential defined as

E = K*[C0 + C1*cos(theta) + C2*cos(2*theta)]

Input parameters: K, C0, C1, C2

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Fourier' objects>, '__doc__': 'Potential defined as\n\n E = K*[C0 + C1*cos(theta) + C2*cos(2*theta)]\n\n Input parameters: K, C0, C1, C2\n ', '__dict__': <attribute '__dict__' of 'Fourier' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function AnglePotential.Fourier.__init__>, '__str__': <function AnglePotential.Fourier.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class FourierSimple

Bases: object

Potential defined as

E = K*[1 + c*cos(n*theta)]

Input parameters: K, c, n

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'FourierSimple' objects>, '__doc__': 'Potential defined as\n\n E = K*[1 + c*cos(n*theta)]\n\n Input parameters: K, c, n\n ', '__dict__': <attribute '__dict__' of 'FourierSimple' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function AnglePotential.FourierSimple.__init__>, '__str__': <function AnglePotential.FourierSimple.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Harmonic

Bases: object

Potential defined as

E = K*(theta - theta0)^2

Input parameters: K, theta0

special_flag is used to distinguish any extra inputs required for LAMMPS to run properly.

eg. special_flag=”shake” will flag this angle potential as a shake angle.

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Harmonic' objects>, '__doc__': 'Potential defined as\n\n E = K*(theta - theta0)^2\n\n Input parameters: K, theta0\n\n special_flag is used to distinguish\n any extra inputs required for LAMMPS\n to run properly.\n\n eg. special_flag="shake"\n will flag this angle potential as\n a shake angle.\n ', '__dict__': <attribute '__dict__' of 'Harmonic' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function AnglePotential.Harmonic.__init__>, '__str__': <function AnglePotential.Harmonic.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Quartic

Bases: object

Potential defined as

E = K2*(theta - theta0)^2 + K3*(theta - theta0)^3 + K4(theta - theta0)^4

Input parameters: theta0, K2, K3, K4

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Quartic' objects>, '__doc__': 'Potential defined as\n\n E = K2*(theta - theta0)^2 + K3*(theta - theta0)^3 + K4(theta - theta0)^4\n\n Input parameters: theta0, K2, K3, K4\n ', '__dict__': <attribute '__dict__' of 'Quartic' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function AnglePotential.Quartic.__init__>, '__str__': <function AnglePotential.Quartic.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Sdk

Bases: object

Potential defined as

E = K*(theta - theta0)^2

Input parameters: K, theta0

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Sdk' objects>, '__doc__': 'Potential defined as\n\n E = K*(theta - theta0)^2\n\n Input parameters: K, theta0\n ', '__dict__': <attribute '__dict__' of 'Sdk' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function AnglePotential.Sdk.__init__>, '__str__': <function AnglePotential.Sdk.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Table

Bases: object

__dict__ = mappingproxy({'__module__': 'lammps_interface.lammps_potentials', '__dict__': <attribute '__dict__' of 'Table' objects>, '__doc__': None, '__weakref__': <attribute '__weakref__' of 'Table' objects>, '__init__': <function AnglePotential.Table.__init__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__weakref__

list of weak references to the object (if defined)

__dict__ = mappingproxy({'CosineShiftExp': <class 'lammps_interface.lammps_potentials.AnglePotential.CosineShiftExp'>, 'Charmm': <class 'lammps_interface.lammps_potentials.AnglePotential.Charmm'>, '__doc__': '\n Class to hold angle styles that are implemented in lammps\n ', 'Class2': <class 'lammps_interface.lammps_potentials.AnglePotential.Class2'>, '__module__': 'lammps_interface.lammps_potentials', 'Sdk': <class 'lammps_interface.lammps_potentials.AnglePotential.Sdk'>, 'Fourier': <class 'lammps_interface.lammps_potentials.AnglePotential.Fourier'>, 'CosineShift': <class 'lammps_interface.lammps_potentials.AnglePotential.CosineShift'>, 'Quartic': <class 'lammps_interface.lammps_potentials.AnglePotential.Quartic'>, 'Cosine': <class 'lammps_interface.lammps_potentials.AnglePotential.Cosine'>, 'Harmonic': <class 'lammps_interface.lammps_potentials.AnglePotential.Harmonic'>, 'Table': <class 'lammps_interface.lammps_potentials.AnglePotential.Table'>, '__weakref__': <attribute '__weakref__' of 'AnglePotential' objects>, 'CosinePeriodic': <class 'lammps_interface.lammps_potentials.AnglePotential.CosinePeriodic'>, 'CosineDelta': <class 'lammps_interface.lammps_potentials.AnglePotential.CosineDelta'>, 'CosineSquared': <class 'lammps_interface.lammps_potentials.AnglePotential.CosineSquared'>, '__dict__': <attribute '__dict__' of 'AnglePotential' objects>, 'Dipole': <class 'lammps_interface.lammps_potentials.AnglePotential.Dipole'>, 'FourierSimple': <class 'lammps_interface.lammps_potentials.AnglePotential.FourierSimple'>})

__module__ = 'lammps_interface.lammps_potentials'

__weakref__

list of weak references to the object (if defined)

class lammps_interface.lammps_potentials.BondPotential

Bases: object

Class to hold bond styles that are implemented in lammps Purpose is to store info that the user wants to use to overwrite standard UFF output of lammps_interface

class Class2

Bases: object

Potential defined as

E = K2*(r-R0)^2 + K3*(r-R0)^3 + K4*(r-R0)^4

Input parameters: R0, K2, K3, K4.

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Class2' objects>, '__doc__': 'Potential defined as\n \n E = K2*(r-R0)^2 + K3*(r-R0)^3 + K4*(r-R0)^4\n \n Input parameters: R0, K2, K3, K4.\n ', '__dict__': <attribute '__dict__' of 'Class2' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function BondPotential.Class2.__init__>, '__str__': <function BondPotential.Class2.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Fene

Bases: object

Potential defined as

E = -0.5*K*R0^2 * ln[1-(r/R0)^2] + 4*eps*[(sig/r)^12 - (sig/r)^6] + eps

Input parameters: K, R0, eps, sig

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Fene' objects>, '__doc__': 'Potential defined as\n\n E = -0.5*K*R0^2 * ln[1-(r/R0)^2] + 4*eps*[(sig/r)^12 - (sig/r)^6] + eps\n\n Input parameters: K, R0, eps, sig\n ', '__dict__': <attribute '__dict__' of 'Fene' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function BondPotential.Fene.__init__>, '__str__': <function BondPotential.Fene.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class FeneExpand

Bases: object

Potential defined as

E = -0.5*K*R0^2 * ln[1-(r-delta/R0)^2] +

4*eps*[(sig/r-delta)^12 - (sig/r-delta)^6] + eps

Input parameters: K, R0, eps, sig, delta

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'FeneExpand' objects>, '__doc__': 'Potential defined as\n\n E = -0.5*K*R0^2 * ln[1-(r-delta/R0)^2] +\n 4*eps*[(sig/r-delta)^12 - (sig/r-delta)^6] + eps\n\n Input parameters: K, R0, eps, sig, delta\n ', '__dict__': <attribute '__dict__' of 'FeneExpand' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function BondPotential.FeneExpand.__init__>, '__str__': <function BondPotential.FeneExpand.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Harmonic

Bases: object

Potential defined as

E = K*(r - R0)^2

Input parameters: K, R0

special_flag is used to distinguish any extra inputs required for LAMMPS to run properly.

eg. special_flag=”shake” will flag this bond potential as a shake bond.

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Harmonic' objects>, '__doc__': 'Potential defined as\n\n E = K*(r - R0)^2\n\n Input parameters: K, R0\n\n special_flag is used to distinguish\n any extra inputs required for LAMMPS\n to run properly.\n\n eg. special_flag="shake"\n will flag this bond potential as\n a shake bond.\n ', '__dict__': <attribute '__dict__' of 'Harmonic' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function BondPotential.Harmonic.__init__>, '__str__': <function BondPotential.Harmonic.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class HarmonicShift

Bases: object

Potential defined as

E = Umin/(R0 - Rc)^2 * [(r-R0)^2 - (Rc - R0)^2]

Input parameters: Umin, R0, Rc

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'HarmonicShift' objects>, '__doc__': 'Potential defined as\n\n E = Umin/(R0 - Rc)^2 * [(r-R0)^2 - (Rc - R0)^2]\n\n Input parameters: Umin, R0, Rc\n ', '__dict__': <attribute '__dict__' of 'HarmonicShift' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function BondPotential.HarmonicShift.__init__>, '__str__': <function BondPotential.HarmonicShift.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class HarmonicShiftCut

Bases: object

Potential defined as

E = Umin/(R0 - Rc)^2 * [(r-R0)^2 - (Rc - R0)^2]

Input parameters: Umin, R0, Rc

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'HarmonicShiftCut' objects>, '__doc__': 'Potential defined as\n\n E = Umin/(R0 - Rc)^2 * [(r-R0)^2 - (Rc - R0)^2]\n\n Input parameters: Umin, R0, Rc\n ', '__dict__': <attribute '__dict__' of 'HarmonicShiftCut' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function BondPotential.HarmonicShiftCut.__init__>, '__str__': <function BondPotential.HarmonicShiftCut.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Morse

Bases: object

Potential defined as

E = D*[1 - e^(-alpha*(r-R0))]^2

Input parameters: D, alpha, R0

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Morse' objects>, '__doc__': 'Potential defined as\n\n E = D*[1 - e^(-alpha*(r-R0))]^2\n\n Input parameters: D, alpha, R0\n ', '__dict__': <attribute '__dict__' of 'Morse' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function BondPotential.Morse.__init__>, '__str__': <function BondPotential.Morse.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class NonLinear

Bases: object

Potential defined as

E = eps*(r-R0)^2 / [lamb^2 - (r-R0)^2]

Input parameters: eps, R0, lamb

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'NonLinear' objects>, '__doc__': 'Potential defined as\n\n E = eps*(r-R0)^2 / [lamb^2 - (r-R0)^2]\n\n Input parameters: eps, R0, lamb\n ', '__dict__': <attribute '__dict__' of 'NonLinear' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function BondPotential.NonLinear.__init__>, '__str__': <function BondPotential.NonLinear.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Quartic

Bases: object

Potential defined as

E = K*(r-Rc)^2 * (r - Rc - B1) * (r - Rc - B2) + U0 +

4*eps*[(sig/r)^12 - (sig/r)^6] + eps

Input parameters: K, B1, B2, Rc, U0

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Quartic' objects>, '__doc__': 'Potential defined as\n\n E = K*(r-Rc)^2 * (r - Rc - B1) * (r - Rc - B2) + U0 +\n 4*eps*[(sig/r)^12 - (sig/r)^6] + eps\n\n Input parameters: K, B1, B2, Rc, U0\n ', '__dict__': <attribute '__dict__' of 'Quartic' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function BondPotential.Quartic.__init__>, '__str__': <function BondPotential.Quartic.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Table

Bases: object

Potential read from file.

__dict__ = mappingproxy({'__module__': 'lammps_interface.lammps_potentials', '__dict__': <attribute '__dict__' of 'Table' objects>, '__weakref__': <attribute '__weakref__' of 'Table' objects>, '__doc__': 'Potential read from file.', '__init__': <function BondPotential.Table.__init__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__weakref__

list of weak references to the object (if defined)

__dict__ = mappingproxy({'HarmonicShiftCut': <class 'lammps_interface.lammps_potentials.BondPotential.HarmonicShiftCut'>, 'Harmonic': <class 'lammps_interface.lammps_potentials.BondPotential.Harmonic'>, 'NonLinear': <class 'lammps_interface.lammps_potentials.BondPotential.NonLinear'>, '__weakref__': <attribute '__weakref__' of 'BondPotential' objects>, 'Class2': <class 'lammps_interface.lammps_potentials.BondPotential.Class2'>, '__module__': 'lammps_interface.lammps_potentials', '__dict__': <attribute '__dict__' of 'BondPotential' objects>, 'HarmonicShift': <class 'lammps_interface.lammps_potentials.BondPotential.HarmonicShift'>, 'Table': <class 'lammps_interface.lammps_potentials.BondPotential.Table'>, '__doc__': '\n Class to hold bond styles that are implemented in lammps\n Purpose is to store info that the user wants to use to overwrite standard UFF output of lammps_interface\n ', 'FeneExpand': <class 'lammps_interface.lammps_potentials.BondPotential.FeneExpand'>, 'Quartic': <class 'lammps_interface.lammps_potentials.BondPotential.Quartic'>, 'Morse': <class 'lammps_interface.lammps_potentials.BondPotential.Morse'>, 'Fene': <class 'lammps_interface.lammps_potentials.BondPotential.Fene'>})

__module__ = 'lammps_interface.lammps_potentials'

__weakref__

list of weak references to the object (if defined)

class lammps_interface.lammps_potentials.DihedralPotential

Bases: object

Class to hold dihedral styles that are implemented in lammps

class Charmm

Bases: object

Potential defined as

E = K*[1 + cos(n*phi - d)]

Input parameters: K, n, d, w (weighting for 1 - 4 non-bonded interactions)

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Charmm' objects>, '__doc__': 'Potential defined as\n\n E = K*[1 + cos(n*phi - d)]\n\n Input parameters: K, n, d, w (weighting for 1 - 4 non-bonded interactions)\n ', '__dict__': <attribute '__dict__' of 'Charmm' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function DihedralPotential.Charmm.__init__>, '__str__': <function DihedralPotential.Charmm.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Class2

Bases: object

Potential deined as E = Ed + Embt + Eebt + Eat + Eaat + Ebb13 Ed = K1*[1 - cos(phi - phi1)] + K2*[1 - cos(2*phi - phi2)] + K3*[1 - cos(3*phi - phi3)] Embt = (r_jk - r2)*[A1*cos(phi) + A2*cos(2phi) + A3*cos(3phi)] Eebt = (r_ij - r1)*[B1*cos(phi) + B2*cos(2phi) + B3*cos(3phi)] + (r_kl - r3)*[C1*cos(phi) + C2*cos(2phi) + C3*cos(3phi)] Eat = (theta_ijk - theta1)*[D1*cos(phi) + D2*cos(2*phi) + D3*cos(3*phi)] + (theta_jkl - theta2)*[E1*cos(phi) + E2*cos(2*phi) + E3*cos(3phi)] Eaa = M*(theta_ijk - theta1)*(theta_jkl - theta2)*cos(phi) Ebb13 = N*(r_ij-r1)*(r_kl-r3)

class AngleAngleTorsion

Bases: object

Eaa = M*(theta_ijk - theta1)*(theta_jkl - theta2)*cos(phi)

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'AngleAngleTorsion' objects>, '__doc__': '\n Eaa = M*(theta_ijk - theta1)*(theta_jkl - theta2)*cos(phi)\n ', '__dict__': <attribute '__dict__' of 'AngleAngleTorsion' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function DihedralPotential.Class2.AngleAngleTorsion.__init__>, '__str__': <function DihedralPotential.Class2.AngleAngleTorsion.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class AngleTorsion

Bases: object

Eat = (theta_ijk - theta1)*[D1*cos(phi) + D2*cos(2*phi) + D3*cos(3*phi)] + (theta_jkl - theta2)*[E1*cos(phi) + E2*cos(2*phi) + E3*cos(3phi)]

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'AngleTorsion' objects>, '__doc__': '\n Eat = (theta_ijk - theta1)*[D1*cos(phi) + D2*cos(2*phi) + D3*cos(3*phi)] + (theta_jkl - theta2)*[E1*cos(phi) + E2*cos(2*phi) + E3*cos(3phi)]\n ', '__dict__': <attribute '__dict__' of 'AngleTorsion' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function DihedralPotential.Class2.AngleTorsion.__init__>, '__str__': <function DihedralPotential.Class2.AngleTorsion.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class BondBond13

Bases: object

Ebb13 = N*(r_ij-r1)*(r_kl-r3)

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'BondBond13' objects>, '__doc__': '\n Ebb13 = N*(r_ij-r1)*(r_kl-r3)\n ', '__dict__': <attribute '__dict__' of 'BondBond13' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function DihedralPotential.Class2.BondBond13.__init__>, '__str__': <function DihedralPotential.Class2.BondBond13.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class EndBondTorsion

Bases: object

Eebt = (r_ij - r1)*[B1*cos(phi) + B2*cos(2phi) + B3*cos(3phi)] + (r_kl - r3)*[C1*cos(phi) + C2*cos(2phi) + C3*cos(3phi)]

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'EndBondTorsion' objects>, '__doc__': '\n Eebt = (r_ij - r1)*[B1*cos(phi) + B2*cos(2phi) + B3*cos(3phi)] + (r_kl - r3)*[C1*cos(phi) + C2*cos(2phi) + C3*cos(3phi)]\n ', '__dict__': <attribute '__dict__' of 'EndBondTorsion' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function DihedralPotential.Class2.EndBondTorsion.__init__>, '__str__': <function DihedralPotential.Class2.EndBondTorsion.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class MiddleBondTorsion

Bases: object

Embt = (r_jk - r2)*[A1*cos(phi) + A2*cos(2phi) + A3*cos(3phi)]

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'MiddleBondTorsion' objects>, '__doc__': '\n Embt = (r_jk - r2)*[A1*cos(phi) + A2*cos(2phi) + A3*cos(3phi)]\n ', '__dict__': <attribute '__dict__' of 'MiddleBondTorsion' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function DihedralPotential.Class2.MiddleBondTorsion.__init__>, '__str__': <function DihedralPotential.Class2.MiddleBondTorsion.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

__dict__ = mappingproxy({'EndBondTorsion': <class 'lammps_interface.lammps_potentials.DihedralPotential.Class2.EndBondTorsion'>, '__weakref__': <attribute '__weakref__' of 'Class2' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function DihedralPotential.Class2.__init__>, 'AngleAngleTorsion': <class 'lammps_interface.lammps_potentials.DihedralPotential.Class2.AngleAngleTorsion'>, '__doc__': '\n Potential deined as\n E = Ed + Embt + Eebt + Eat + Eaat + Ebb13\n Ed = K1*[1 - cos(phi - phi1)] + K2*[1 - cos(2*phi - phi2)] + K3*[1 - cos(3*phi - phi3)]\n Embt = (r_jk - r2)*[A1*cos(phi) + A2*cos(2phi) + A3*cos(3phi)]\n Eebt = (r_ij - r1)*[B1*cos(phi) + B2*cos(2phi) + B3*cos(3phi)] + (r_kl - r3)*[C1*cos(phi) + C2*cos(2phi) + C3*cos(3phi)]\n Eat = (theta_ijk - theta1)*[D1*cos(phi) + D2*cos(2*phi) + D3*cos(3*phi)] + (theta_jkl - theta2)*[E1*cos(phi) + E2*cos(2*phi) + E3*cos(3phi)]\n Eaa = M*(theta_ijk - theta1)*(theta_jkl - theta2)*cos(phi)\n Ebb13 = N*(r_ij-r1)*(r_kl-r3)\n ', '__dict__': <attribute '__dict__' of 'Class2' objects>, 'MiddleBondTorsion': <class 'lammps_interface.lammps_potentials.DihedralPotential.Class2.MiddleBondTorsion'>, 'AngleTorsion': <class 'lammps_interface.lammps_potentials.DihedralPotential.Class2.AngleTorsion'>, 'BondBond13': <class 'lammps_interface.lammps_potentials.DihedralPotential.Class2.BondBond13'>, '__str__': <function DihedralPotential.Class2.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class CosineShiftExp

Bases: object

Potential defined as

E = -Umin*[e^{-a*U(theta,theta0)} - 1] / (e^a -1)

where U(theta, theta0) = -0.5*(1 + cos(theta-theta0))

Input parameters: Umin, theta0, a

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'CosineShiftExp' objects>, '__doc__': 'Potential defined as\n\n E = -Umin*[e^{-a*U(theta,theta0)} - 1] / (e^a -1)\n\n where U(theta, theta0) = -0.5*(1 + cos(theta-theta0))\n\n Input parameters: Umin, theta0, a\n ', '__dict__': <attribute '__dict__' of 'CosineShiftExp' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function DihedralPotential.CosineShiftExp.__init__>, '__str__': <function DihedralPotential.CosineShiftExp.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Fourier

Bases: object

Potential defined as

E = sum_i=1,m { Ki*[1.0 + cos(ni*theta - di)] }

Input parameters: m, Ki, ni, di

NB m is an integer dictating how many terms to sum, there should be 3*m + 1 total parameters.

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Fourier' objects>, '__doc__': 'Potential defined as\n\n E = sum_i=1,m { Ki*[1.0 + cos(ni*theta - di)] }\n\n Input parameters: m, Ki, ni, di\n\n NB m is an integer dictating how many terms to sum, there should be 3*m + 1\n total parameters.\n\n ', '__dict__': <attribute '__dict__' of 'Fourier' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function DihedralPotential.Fourier.__init__>, '__str__': <function DihedralPotential.Fourier.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Harmonic

Bases: object

Potential defined as

E = K*[1 + d*cos(n*phi)]

Input parameters: K, d, n

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Harmonic' objects>, '__doc__': 'Potential defined as\n\n E = K*[1 + d*cos(n*phi)]\n\n Input parameters: K, d, n\n ', '__dict__': <attribute '__dict__' of 'Harmonic' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function DihedralPotential.Harmonic.__init__>, '__str__': <function DihedralPotential.Harmonic.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Helix

Bases: object

Potential defined as

E = A*[1 - cos(theta)] + B*[1 + cos(3*theta)] + C*[1 + cos(theta + pi/4)]

Input parameters: A, B, C

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Helix' objects>, '__doc__': 'Potential defined as\n\n E = A*[1 - cos(theta)] + B*[1 + cos(3*theta)] + C*[1 + cos(theta + pi/4)]\n\n Input parameters: A, B, C\n ', '__dict__': <attribute '__dict__' of 'Helix' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function DihedralPotential.Helix.__init__>, '__str__': <function DihedralPotential.Helix.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class MultiHarmonic

Bases: object

Potential defined as

E = sum_n=1,5{ An*cos^(n-1)(theta)}

Input parameters: A1, A2, A3, A4, A5

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'MultiHarmonic' objects>, '__doc__': 'Potential defined as\n\n E = sum_n=1,5{ An*cos^(n-1)(theta)}\n\n Input parameters: A1, A2, A3, A4, A5\n ', '__dict__': <attribute '__dict__' of 'MultiHarmonic' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function DihedralPotential.MultiHarmonic.__init__>, '__str__': <function DihedralPotential.MultiHarmonic.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Opls

Bases: object

Potential defined as

E = 0.5*K1*[1 + cos(theta)] + 0.5*K2*[1 - cos(2*theta)] +

0.5*K3*[1 + cos(3*theta)] + 0.5*K4*[1 - cos(4*theta)]

Input parameters: K1, K2, K3, K4

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Opls' objects>, '__doc__': 'Potential defined as\n\n E = 0.5*K1*[1 + cos(theta)] + 0.5*K2*[1 - cos(2*theta)] +\n 0.5*K3*[1 + cos(3*theta)] + 0.5*K4*[1 - cos(4*theta)]\n\n Input parameters: K1, K2, K3, K4\n ', '__dict__': <attribute '__dict__' of 'Opls' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function DihedralPotential.Opls.__init__>, '__str__': <function DihedralPotential.Opls.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Quadratic

Bases: object

Potential defined as

E = K*(theta - theta0)^2

Input parameters: K, phi0

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Quadratic' objects>, '__doc__': 'Potential defined as\n\n E = K*(theta - theta0)^2\n\n Input parameters: K, phi0\n\n ', '__dict__': <attribute '__dict__' of 'Quadratic' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function DihedralPotential.Quadratic.__init__>, '__str__': <function DihedralPotential.Quadratic.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Table

Bases: object

Potential read from file.

__dict__ = mappingproxy({'__module__': 'lammps_interface.lammps_potentials', '__dict__': <attribute '__dict__' of 'Table' objects>, '__weakref__': <attribute '__weakref__' of 'Table' objects>, '__doc__': 'Potential read from file.', '__init__': <function DihedralPotential.Table.__init__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__weakref__

list of weak references to the object (if defined)

__dict__ = mappingproxy({'CosineShiftExp': <class 'lammps_interface.lammps_potentials.DihedralPotential.CosineShiftExp'>, 'Harmonic': <class 'lammps_interface.lammps_potentials.DihedralPotential.Harmonic'>, 'Table': <class 'lammps_interface.lammps_potentials.DihedralPotential.Table'>, 'Charmm': <class 'lammps_interface.lammps_potentials.DihedralPotential.Charmm'>, '__weakref__': <attribute '__weakref__' of 'DihedralPotential' objects>, 'nHarmonic': <class 'lammps_interface.lammps_potentials.DihedralPotential.nHarmonic'>, 'Class2': <class 'lammps_interface.lammps_potentials.DihedralPotential.Class2'>, '__module__': 'lammps_interface.lammps_potentials', 'Fourier': <class 'lammps_interface.lammps_potentials.DihedralPotential.Fourier'>, 'Helix': <class 'lammps_interface.lammps_potentials.DihedralPotential.Helix'>, '__doc__': '\n Class to hold dihedral styles that are implemented in lammps\n ', '__dict__': <attribute '__dict__' of 'DihedralPotential' objects>, 'MultiHarmonic': <class 'lammps_interface.lammps_potentials.DihedralPotential.MultiHarmonic'>, 'Quadratic': <class 'lammps_interface.lammps_potentials.DihedralPotential.Quadratic'>, 'Opls': <class 'lammps_interface.lammps_potentials.DihedralPotential.Opls'>})

__module__ = 'lammps_interface.lammps_potentials'

__weakref__

list of weak references to the object (if defined)

class nHarmonic

Bases: object

Potential defined as

E = sum_i=1,n { Ai*cos^{i-1}(theta)

Input parameters: n, Ai

NB n is an integer dictating how many terms to sum, there should be n + 1 total parameters.

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'nHarmonic' objects>, '__doc__': 'Potential defined as\n\n E = sum_i=1,n { Ai*cos^{i-1}(theta)\n\n Input parameters: n, Ai\n\n NB n is an integer dictating how many terms to sum, there should be n + 1\n total parameters.\n\n ', '__dict__': <attribute '__dict__' of 'nHarmonic' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function DihedralPotential.nHarmonic.__init__>, '__str__': <function DihedralPotential.nHarmonic.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class lammps_interface.lammps_potentials.ImproperPotential

Bases: object

Class to hold improper styles that are implemented in lammps

class Class2

Bases: object

Potential defined as

E = Ei + Eaa

Ei = K*[(chi_ijkl + chi_kjli + chi_ljik)/3 - chi0]^2 Eaa = M1*(theta_ijk - theta1)*(theta_kjl - theta3) +

M2*(theta_ijk - theta1)*(theta_ijl - theta2) + M3*(theta_ijl - theta2)*(theta_kjl - theta3)

Input parameters: K, chi0

class AngleAngle

Bases: object

Potential defined as Eaa = M1*(theta_ijk - theta1)*(theta_kjl - theta3) +

M2*(theta_ijk - theta1)*(theta_ijl - theta2) + M3*(theta_ijl - theta2)*(theta_kjl - theta3)

Input parameters: M1 M2 M3 theta1 theta2 theta3

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'AngleAngle' objects>, '__doc__': 'Potential defined as\n Eaa = M1*(theta_ijk - theta1)*(theta_kjl - theta3) +\n M2*(theta_ijk - theta1)*(theta_ijl - theta2) +\n M3*(theta_ijl - theta2)*(theta_kjl - theta3)\n\n Input parameters: M1 M2 M3 theta1 theta2 theta3\n ', '__dict__': <attribute '__dict__' of 'AngleAngle' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function ImproperPotential.Class2.AngleAngle.__init__>, '__str__': <function ImproperPotential.Class2.AngleAngle.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Class2' objects>, '__doc__': 'Potential defined as\n\n E = Ei + Eaa\n\n Ei = K*[(chi_ijkl + chi_kjli + chi_ljik)/3 - chi0]^2\n Eaa = M1*(theta_ijk - theta1)*(theta_kjl - theta3) +\n M2*(theta_ijk - theta1)*(theta_ijl - theta2) +\n M3*(theta_ijl - theta2)*(theta_kjl - theta3)\n\n Input parameters: K, chi0\n\n ', '__dict__': <attribute '__dict__' of 'Class2' objects>, '__module__': 'lammps_interface.lammps_potentials', 'AngleAngle': <class 'lammps_interface.lammps_potentials.ImproperPotential.Class2.AngleAngle'>, '__init__': <function ImproperPotential.Class2.__init__>, '__str__': <function ImproperPotential.Class2.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Cossq

Bases: object

Potential defined as

E = 0.5*K*cos^2(chi - chi0)

Input parameters: K, chi0

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Cossq' objects>, '__doc__': 'Potential defined as\n\n E = 0.5*K*cos^2(chi - chi0)\n\n Input parameters: K, chi0\n\n ', '__dict__': <attribute '__dict__' of 'Cossq' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function ImproperPotential.Cossq.__init__>, '__str__': <function ImproperPotential.Cossq.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Cvff

Bases: object

Potential defined as

E = K*[1 + d*cos(n*theta)]

Input parameters: K, d, n

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Cvff' objects>, '__doc__': 'Potential defined as\n\n E = K*[1 + d*cos(n*theta)]\n\n Input parameters: K, d, n\n\n ', '__dict__': <attribute '__dict__' of 'Cvff' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function ImproperPotential.Cvff.__init__>, '__str__': <function ImproperPotential.Cvff.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Fourier

Bases: object

Potential defined as

E = K*[C0 + C1*cos(omega) + C2*cos(2*omega)]

Input parameters: K, C0, C1, C2, a

the parameter a allows all three angles to be taken into account in an improper dihedral. It is not clear in the lammps manual what to set this to to turn it off/on, but the usual assumptions are 0/1.

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Fourier' objects>, '__doc__': 'Potential defined as\n\n E = K*[C0 + C1*cos(omega) + C2*cos(2*omega)]\n\n Input parameters: K, C0, C1, C2, a\n\n the parameter a allows all three angles to be taken into account in an\n improper dihedral. It is not clear in the lammps manual what to set this\n to to turn it off/on, but the usual assumptions are 0/1.\n ', '__dict__': <attribute '__dict__' of 'Fourier' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function ImproperPotential.Fourier.__init__>, '__str__': <function ImproperPotential.Fourier.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Harmonic

Bases: object

Potential defined as

E = K*(chi - chi0)^2

Input parameters: K, chi0

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Harmonic' objects>, '__doc__': 'Potential defined as\n\n E = K*(chi - chi0)^2\n\n Input parameters: K, chi0\n\n ', '__dict__': <attribute '__dict__' of 'Harmonic' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function ImproperPotential.Harmonic.__init__>, '__str__': <function ImproperPotential.Harmonic.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Ring

Bases: object

Potential defined as

E = 1/6*K*(delta_ijl + delta_ijk + delta_kjl)^6

where delta_ijl = cos(theta_ijl) - cos(theta0)

Input parameters: K, theta0

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Ring' objects>, '__doc__': 'Potential defined as\n\n E = 1/6*K*(delta_ijl + delta_ijk + delta_kjl)^6\n\n where delta_ijl = cos(theta_ijl) - cos(theta0)\n\n Input parameters: K, theta0\n\n ', '__dict__': <attribute '__dict__' of 'Ring' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function ImproperPotential.Ring.__init__>, '__str__': <function ImproperPotential.Ring.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Umbrella

Bases: object

Potential defined as

E = 0.5*K*[1 + cos(omega0)/sin(omega0)]^2 * [cos(omega) - cos(omega0)] if omega0 .ne. 0 (deg) E = K*[1 - cos(omega)] if omega0 = 0 (deg)

Input parameters: K, omega0

__dict__ = mappingproxy({'__weakref__': <attribute '__weakref__' of 'Umbrella' objects>, '__doc__': 'Potential defined as\n\n E = 0.5*K*[1 + cos(omega0)/sin(omega0)]^2 * [cos(omega) - cos(omega0)] if omega0 .ne. 0 (deg)\n E = K*[1 - cos(omega)] if omega0 = 0 (deg)\n\n Input parameters: K, omega0\n\n ', '__dict__': <attribute '__dict__' of 'Umbrella' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function ImproperPotential.Umbrella.__init__>, '__str__': <function ImproperPotential.Umbrella.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

__dict__ = mappingproxy({'Harmonic': <class 'lammps_interface.lammps_potentials.ImproperPotential.Harmonic'>, '__weakref__': <attribute '__weakref__' of 'ImproperPotential' objects>, 'Class2': <class 'lammps_interface.lammps_potentials.ImproperPotential.Class2'>, '__module__': 'lammps_interface.lammps_potentials', 'Ring': <class 'lammps_interface.lammps_potentials.ImproperPotential.Ring'>, 'Cossq': <class 'lammps_interface.lammps_potentials.ImproperPotential.Cossq'>, 'Cvff': <class 'lammps_interface.lammps_potentials.ImproperPotential.Cvff'>, '__doc__': '\n Class to hold improper styles that are implemented in lammps\n ', 'Umbrella': <class 'lammps_interface.lammps_potentials.ImproperPotential.Umbrella'>, '__dict__': <attribute '__dict__' of 'ImproperPotential' objects>, 'Fourier': <class 'lammps_interface.lammps_potentials.ImproperPotential.Fourier'>})

__module__ = 'lammps_interface.lammps_potentials'

__weakref__

list of weak references to the object (if defined)

class lammps_interface.lammps_potentials.PairPotential

Bases: object

Class to hold Pair styles that are implemented in lammps NB: list here is HUGE, update as needed..

class Buck

Bases: object

Potential defined as

E = A*exp{-r/rho} - C/r^{6}

__dict__ = mappingproxy({'__repr__': <function PairPotential.Buck.__repr__>, '__weakref__': <attribute '__weakref__' of 'Buck' objects>, '__doc__': 'Potential defined as\n\n E = A*exp{-r/rho} - C/r^{6}\n\n\n ', '__dict__': <attribute '__dict__' of 'Buck' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function PairPotential.Buck.__init__>, '__str__': <function PairPotential.Buck.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__repr__()

Return repr(self).

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class BuckCoulLong

Bases: object

Potential defined as

E = A*exp{-r/rho} - C/r^{6}

__dict__ = mappingproxy({'__repr__': <function PairPotential.BuckCoulLong.__repr__>, '__weakref__': <attribute '__weakref__' of 'BuckCoulLong' objects>, '__doc__': 'Potential defined as\n\n E = A*exp{-r/rho} - C/r^{6}\n\n\n ', '__dict__': <attribute '__dict__' of 'BuckCoulLong' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function PairPotential.BuckCoulLong.__init__>, '__str__': <function PairPotential.BuckCoulLong.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__repr__()

Return repr(self).

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class HbondDreidingMorse

Bases: object

Potential defined as

E = D0*[exp{-2*alpha*(r-R0)} - 2*exp{-alpha*(r-R0)}]*cos^n(theta)

__dict__ = mappingproxy({'__repr__': <function PairPotential.HbondDreidingMorse.__repr__>, '__weakref__': <attribute '__weakref__' of 'HbondDreidingMorse' objects>, '__doc__': 'Potential defined as\n\n E = D0*[exp{-2*alpha*(r-R0)} - 2*exp{-alpha*(r-R0)}]*cos^n(theta)\n\n ', '__dict__': <attribute '__dict__' of 'HbondDreidingMorse' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function PairPotential.HbondDreidingMorse.__init__>, '__str__': <function PairPotential.HbondDreidingMorse.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__repr__()

Return repr(self).

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class LjCharmmCoulLong

Bases: object

Potential defined as

E = 4*eps*[(sig/r)^12 - (sig/r)^6] r < rc

and coulombic terms dealt with a kspace solver

__dict__ = mappingproxy({'__repr__': <function PairPotential.LjCharmmCoulLong.__repr__>, '__weakref__': <attribute '__weakref__' of 'LjCharmmCoulLong' objects>, '__doc__': 'Potential defined as\n\n E = 4*eps*[(sig/r)^12 - (sig/r)^6] r < rc\n\n and coulombic terms dealt with a kspace solver\n ', '__dict__': <attribute '__dict__' of 'LjCharmmCoulLong' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function PairPotential.LjCharmmCoulLong.__init__>, '__str__': <function PairPotential.LjCharmmCoulLong.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__repr__()

Return repr(self).

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class LjCut

Bases: object

Potential defined as

E = 4*eps*[(sig/r)^12 - (sig/r)^6] r < rc

__dict__ = mappingproxy({'__repr__': <function PairPotential.LjCut.__repr__>, '__weakref__': <attribute '__weakref__' of 'LjCut' objects>, '__doc__': 'Potential defined as\n\n E = 4*eps*[(sig/r)^12 - (sig/r)^6] r < rc\n\n ', '__dict__': <attribute '__dict__' of 'LjCut' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function PairPotential.LjCut.__init__>, '__str__': <function PairPotential.LjCut.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__repr__()

Return repr(self).

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class LjCutCoulLong

Bases: object

Potential defined as

E = 4*eps*[(sig/r)^12 - (sig/r)^6] r < rc

and coulombic terms dealt with a kspace solver

__dict__ = mappingproxy({'__repr__': <function PairPotential.LjCutCoulLong.__repr__>, '__weakref__': <attribute '__weakref__' of 'LjCutCoulLong' objects>, '__doc__': 'Potential defined as\n\n E = 4*eps*[(sig/r)^12 - (sig/r)^6] r < rc\n\n and coulombic terms dealt with a kspace solver\n ', '__dict__': <attribute '__dict__' of 'LjCutCoulLong' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function PairPotential.LjCutCoulLong.__init__>, '__str__': <function PairPotential.LjCutCoulLong.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__repr__()

Return repr(self).

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class LjCutTip4pLong

Bases: object

Potential defined as

E = 4*eps*[(sig/r)^12 - (sig/r)^6] r < rc

and coulombic terms dealt with a kspace solver TIP4P water implicit charge points are included in ewald sum.

__dict__ = mappingproxy({'__repr__': <function PairPotential.LjCutTip4pLong.__repr__>, '__weakref__': <attribute '__weakref__' of 'LjCutTip4pLong' objects>, '__doc__': 'Potential defined as\n\n E = 4*eps*[(sig/r)^12 - (sig/r)^6] r < rc\n\n and coulombic terms dealt with a kspace solver\n TIP4P water implicit charge points are included in\n ewald sum.\n ', '__dict__': <attribute '__dict__' of 'LjCutTip4pLong' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function PairPotential.LjCutTip4pLong.__init__>, '__str__': <function PairPotential.LjCutTip4pLong.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__repr__()

Return repr(self).

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

class Table

Bases: object

A tabulated potential is used

LAMMPS keyword arguments are passes as kwargs

__dict__ = mappingproxy({'__repr__': <function PairPotential.Table.__repr__>, '__weakref__': <attribute '__weakref__' of 'Table' objects>, '__doc__': 'A tabulated potential is used\n\n LAMMPS keyword arguments are passes as kwargs\n ', '__dict__': <attribute '__dict__' of 'Table' objects>, '__module__': 'lammps_interface.lammps_potentials', '__init__': <function PairPotential.Table.__init__>, '__str__': <function PairPotential.Table.__str__>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.lammps_potentials'

__repr__()

Return repr(self).

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

__dict__ = mappingproxy({'HbondDreidingMorse': <class 'lammps_interface.lammps_potentials.PairPotential.HbondDreidingMorse'>, 'Table': <class 'lammps_interface.lammps_potentials.PairPotential.Table'>, '__weakref__': <attribute '__weakref__' of 'PairPotential' objects>, 'Buck': <class 'lammps_interface.lammps_potentials.PairPotential.Buck'>, 'LjCutTip4pLong': <class 'lammps_interface.lammps_potentials.PairPotential.LjCutTip4pLong'>, 'LjCharmmCoulLong': <class 'lammps_interface.lammps_potentials.PairPotential.LjCharmmCoulLong'>, '__doc__': '\n Class to hold Pair styles that are implemented in lammps\n NB: list here is HUGE, update as needed..\n\n ', '__dict__': <attribute '__dict__' of 'PairPotential' objects>, 'LjCutCoulLong': <class 'lammps_interface.lammps_potentials.PairPotential.LjCutCoulLong'>, 'LjCut': <class 'lammps_interface.lammps_potentials.PairPotential.LjCut'>, '__module__': 'lammps_interface.lammps_potentials', 'BuckCoulLong': <class 'lammps_interface.lammps_potentials.PairPotential.BuckCoulLong'>})

__module__ = 'lammps_interface.lammps_potentials'

__weakref__

list of weak references to the object (if defined)

lammps_interface.mof_sbus module

MOF sbus.

lammps_interface.mof_sbus.add_distance_matrix(graph)

lammps_interface.structure_data module

Molecular graph and structure io methods.

class lammps_interface.structure_data.Cell

Bases: object

_Cell__mkcell()

Update the cell representation to match the parameters.

_Cell__mklammps()

_Cell__mkparam()

Update the parameters to match the cell.

__dict__ = mappingproxy({'update_supercell': <function Cell.update_supercell>, '__module__': 'lammps_interface.structure_data', 'orthogonal_transformation': <function Cell.orthogonal_transformation>, 'get_cell_inverse': <function Cell.get_cell_inverse>, '_Cell__mkparam': <function Cell.__mkparam>, 'set_params': <function Cell.set_params>, '__doc__': None, 'get_cell': <function Cell.get_cell>, 'volume': <property object>, '__weakref__': <attribute '__weakref__' of 'Cell' objects>, 'set_cell': <function Cell.set_cell>, 'xy': <property object>, 'lz': <property object>, 'gamma': <property object>, 'mod_to_UC': <function Cell.mod_to_UC>, 'minimum_supercell': <function Cell.minimum_supercell>, '_Cell__mkcell': <function Cell.__mkcell>, 'cell': <property object>, 'a': <property object>, '__dict__': <attribute '__dict__' of 'Cell' objects>, '__init__': <function Cell.__init__>, 'params': <property object>, '_Cell__mklammps': <function Cell.__mklammps>, 'crystal_system': <property object>, 'alpha': <property object>, 'get_params': <function Cell.get_params>, 'inverse': <property object>, 'lx': <property object>, 'beta': <property object>, 'minimum_width': <property object>, 'ly': <property object>, 'xz': <property object>, 'b': <property object>, 'c': <property object>, 'yz': <property object>})

__init__()

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.structure_data'

__weakref__

list of weak references to the object (if defined)

property a

Magnitude of cell a vector.

property alpha

Cell angle alpha.

property b

Magnitude of cell b vector.

property beta

Cell angle beta.

property c

Magnitude of cell c vector.

property cell

Get the 3x3 vector cell representation.

property crystal_system

Return the IUCr designation for the crystal system.

property gamma

Cell angle gamma.

get_cell()

Get the 3x3 vector cell representation.

get_cell_inverse()

Get the 3x3 vector cell representation.

get_params()

Get the six parameter cell representation as a tuple.

property inverse

Inverted cell matrix for converting to fractional coordinates.

property lx

property ly

property lz

minimum_supercell(cutoff)

Calculate the smallest supercell with a half-cell width cutoff.

Increment from smallest cell vector to largest. So the supercell is not considering the ‘unit cell’ for each cell dimension.

property minimum_width

The shortest perpendicular distance within the cell.

mod_to_UC(num)

Retrun any fractional coordinate back into the unit cell

orthogonal_transformation()

Compute the transformation from the original unit cell to a supercell which has 90 degree angles between it’s basis vectors. This is somewhat approximate, and the angles will not be EXACTLY 90 deg.

property params

Get the six parameter cell representation as a tuple.

set_cell(value)

Set cell and params from the cell representation.

set_params(value)

Set cell and params from the cell parameters.

update_supercell(tuple)

property volume

Calculate cell volume a.bxc.

property xy

property xz

property yz

class lammps_interface.structure_data.MDMC_config(lammps_sim)

Bases: object

Very sloppy for now but just doing the bare minimum to get this up and running for methane in flexible materials

__dict__ = mappingproxy({'__module__': 'lammps_interface.structure_data', '__dict__': <attribute '__dict__' of 'MDMC_config' objects>, '__weakref__': <attribute '__weakref__' of 'MDMC_config' objects>, '__doc__': '\n Very sloppy for now but just doing the bare minimum to get this up and running\n for methane in flexible materials\n ', '__init__': <function MDMC_config.__init__>})

__init__(lammps_sim)

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'lammps_interface.structure_data'

__weakref__

list of weak references to the object (if defined)

class lammps_interface.structure_data.MolecularGraph(**kwargs)

Bases: networkx.classes.graph.Graph

Contains all information relating a structure file to a fully described classical system.

Important specific arguments for atomic nodes:

• mass

• force_field_type

• charge

• cartesian_coordinates

• description {contains all information about electronic environment to make a decision on the final force_field_type}

• hybridization [sp3, sp2, sp, aromatic]

Important arguments for bond edges:

• weight = 1

• length

• image_flag

• force_field_type

__iadd__(newgraph)

__init__(**kwargs)

MolecularGraph constructor.

__module__ = 'lammps_interface.structure_data'

__or__(graph)

add_atomic_node(**kwargs)

Insert nodes into the graph from the cif file

add_bond_edge(**kwargs)

Add bond edges (weight factor = 1)

atomic_node_sanity_check()

Check for specific keyword/value pairs. Exit if non-existent

build_supercell(sc, lattice, track_molecule=False, molecule_len=0, redefine=None)

Construct a graph with nodes supporting the size of the supercell (sc) Oh man.. so ugly. NB: this replaces and overwrites the original unit cell data

with a supercell. There may be a better way to do this if one needs to keep both the super- and unit cells.

compute_angle_between(l, m, r)

compute_angles()

angles are attached to specific nodes, this way if a node is cut out of a graph, the angle comes with it.

b—–a

/

/

c

Must be updated with different adjacent nodes if a supercell is requested, and the angle crosses a periodic image.

compute_bond_image_flag(n1, n2, cell)

Update bonds to contain bond type, distances, and min img shift.

compute_bond_typing()

Compute bond types and atom types based on the local edge environment. Messy, loads of ‘ifs’ is there a better way to catch chemical features?

compute_bonding(cell, scale_factor=0.9)

Computes bonds between atoms based on covalent radii.

compute_cartesian_coordinates(cell)

Compute the cartesian coordinates for each atom node

compute_dihedral_between(a, b, c, d)

compute_dihedrals()

Dihedrals are attached to specific edges in the graph.

a

b – c

d

the edge between b and c will contain all possible dihedral angles between the neighbours of b and c (this includes a and d and other possible bonded atoms)

compute_improper_dihedrals()

Improper Dihedrals are attached to specific nodes in the graph.

a

b – c

d

the node b will contain all possible improper dihedral angles between the neighbours of b

compute_init_typing()

Find possible rings in the structure and initialize the hybridization for each atom. More refined determinations of atom and bond types is computed below in compute_bond_typing

compute_min_img_distances(cell)

compute_topology_information(cell, tol, num_neighbours)

coplanar(node)

Determine if this node, and it’s neighbors are all co-planar.

correspondence_graph(graph, tol, general_metal=False, node_subset=None)

Generate a correspondence graph between the nodes and the SBU. tolerance is the distance tolerance for the edge generation in the correspondence graph.

count_angles()

count_dihedrals()

count_impropers()

detect_clusters(num_neighbors, tol, type='Inorganic', general_metal=False)

Detect clusters such as the copper paddlewheel using maximum clique detection. This will assign specific atoms with a special flag for use when building their force field.

setting general_metal to True will allow for cluster recognition of inorganic SBUs while ignoring the specific element type of the metal, so long as it is a metal, it will be paired with other metals. This may increase the time for SBU recognition.

edges_iter2(data=True)

fractional(coord)

img_offset(cells, cell, maxcell, flag, redefine, n1=0)

in_cell(coord)

min_img(coord)

min_img_distance(coords1, coords2, cell)

node_dict_factory

alias of collections.OrderedDict

nodes_iter2(data=True)

Oh man, fixing to networkx 2.0

This probably breaks a lot of stuff in the code. THANKS NETWORKX!!!!!!!1 Extensive testing under way…

recurse_bonds_to_end(node, pool=[], visited=[])

recurse_linear_chains(node, visited=[], excluded=[])

Messy recursion function to return all unique chains from a set of atoms between two metals (or terminal atoms in the case of molecules)

redefine_lattice(redefinition, lattice)

Redefines the lattice based on the old lattice vectors. This was designed to convert non-orthogonal cells to orthogonal boxes, but it could in principle be used to convert any cell to any other cell. (As long as the redefined lattice are integer multiples of the old vectors)

reorder_labels(reorder_dic)

Re-order the labels of the nodes so that LAMMPS doesn’t complain. This issue only arises when a supercell is built, but isolated molecules are not replicated in the supercell (by user request). This creates a discontinuity in the indices of the atoms, which breaks some features in LAMMPS.

show()

sorted_edge_list()

sorted_node_list()

store_original_size()

subgraph(nodelist)

Have to override subgraph from networkx. No idea why, but when Graph.subgraph is called in nx v >= 2.0, it returns a Graph object, not a MolecularGraph.

unwrap_node_coordinates(cell)

Must be done before supercell generation. This is a recursive method iterating over all edges. The design is totally unpythonic and written in about 5 mins.. so be nice (PB)

update_symflag(cell, symflag, mincell, maxcell)

lammps_interface.structure_data.clean(name)

lammps_interface.structure_data.del_parenth(string)

lammps_interface.structure_data.from_CIF(cifname)

Reads the structure data from the CIF - currently does not read the symmetry of the cell - does not unpack the assymetric unit (assumes P1) - assumes that the appropriate keys are in the cifobj (no error checking)

lammps_interface.structure_data.write_CIF(graph, cell)

Currently used for debugging purposes

lammps_interface.structure_data.write_PDB(graph, cell)

Program to write pdb file from structure graph. Doing this because MS v. 6 doesn’t do the CONECT lines correctly.

lammps_interface.structure_data.write_RASPA_CIF(graph, cell, classifier=0)

Same as debugging cif write routine

except _atom_site_label is now equal to _atom_site_description b/c RASPA uses _atom_site_label as the type for assigning FF params

lammps_interface.structure_data.write_RASPA_sim_files(lammps_sim, classifier=0)

Write the RASPA pseudo_atoms.def file for this MOF All generic adsorbates info automatically included Additional framework atoms taken from lammps_interface anaylsis

classifier = 0 -> UFF atom label is used for pseudo atoms classifier = 1 -> cif label is used for pseudo atoms (useful for

interface/defect systems where symmetry of charge density is very reduced)

lammps_interface.uff module

Parameters for Universal Force Field.

lammps_interface.uff4mof module

Parameters for UFF4MOF.

lammps_interface.uff_nonbonded module

Nonbonded parameters for Universal Force Field.

lammps_interface.water_models module

Water models.

Module contents

Lammps interface.