#include <InterfaceLammps.h>

Inheritance diagram for nnp::InterfaceLammps:

Collaboration diagram for nnp::InterfaceLammps:

[legend]

Public Member Functions
	InterfaceLammps ()

void	initialize (char const const &directory, char const const &emap, bool showew, bool resetew, int showewsum, int maxew, double cflength, double cfenergy, double lammpsCutoff, int lammpsNtypes, int myRank)
	Initialize the LAMMPS interface.

void	setGlobalStructureStatus (bool const status)
	Specify whether n2p2 knows about global structure or only local structure.

bool	getGlobalStructureStatus ()
	Check if n2p2 knows about global structure.

void	setLocalAtoms (int numAtomsLocal, int const *const atomType)
	(Re)set structure to contain only local LAMMPS atoms.

void	setLocalAtomPositions (double const const const atomPos)
	Set absolute atom positions from LAMMPS (nnp/develop only).

void	setLocalTags (int const *const atomTag)
	Set atom tags (int version, -DLAMMPS_SMALLBIG).

void	setLocalTags (int64_t const *const atomTag)
	Set atom tags (int64_t version, -DLAMMPS_BIGBIG).

void	setBoxVectors (double const boxlo, double const boxhi, double const xy, double const xz, double const yz)
	Set box vectors of structure stored in LAMMPS (nnp/develop only).

void	allocateNeighborlists (int const *const numneigh)
	Allocate neighbor lists.

void	addNeighbor (int i, int j, int64_t tag, int type, double dx, double dy, double dz, double d2)
	Add one neighbor to atom (int64_t version, -DLAMMPS_BIGBIG).

void	finalizeNeighborList ()
	Sorts neighbor list and creates cutoff map if necessary.

void	process ()
	Calculate symmetry functions, atomic neural networks and sum of local energy contributions.

void	processDevelop ()
	Calculate symmetry functions, atomic neural networks and sum of local energy contributions (development version for "hdnnp/develop" pair style).

double	getEnergy () const
	Return sum of local energy contributions.

double	getAtomicEnergy (int index) const
	Return energy contribution of one atom.

void	addElectrostaticEnergy (double energy)
	Adds electrostatic energy contribution to the total structure energy.

void	getForces (double const const &atomF) const
	Calculate forces and add to LAMMPS atomic force arrays.

void	getForcesDevelop (double const const &atomF) const
	Calculate forces and add to LAMMPS atomic force arrays (development version for "hdnnp/develop" pair style).

void	getForcesChi (double const const &lambda, double const *const &atomF) const
	Calculate chi-term for forces and add to LAMMPS atomic force arrays.

void	getCharges (double *const &atomQ) const
	Transfer charges (in units of e) to LAMMPS atomic charge vector.

bool	isInitialized () const
	Check if this interface is correctly initialized.

double	getMaxCutoffRadius () const
	Get largest cutoff of symmetry functions.

double	getEwaldPrec () const
	Get Ewald precision parameter.

double	getMaxCutoffRadiusOverall ()
	Get largest cutoff including structure specific cutoff and screening cutoff.

long	getEWBufferSize () const
	Calculate buffer size for extrapolation warning communication.

void	fillEWBuffer (char *const &buf, int bs) const
	Fill provided buffer with extrapolation warning entries.

void	extractEWBuffer (char const *const &buf, int bs)
	Extract given buffer to symmetry function statistics class.

void	writeExtrapolationWarnings ()
	Write extrapolation warnings to log.

void	clearExtrapolationWarnings ()
	Clear extrapolation warnings storage.

void	addCharge (int index, double Q)
	Read atomic charges from LAMMPS into n2p2.

void	getQEqParams (double const &atomChi, double const &atomJ, double const &sigmaSqrtPi, double const *const &gammaSqrt2, double &qRef) const
	Write QEq arrays from n2p2 to LAMMPS.

void	getdEdQ (double *const &dEtotdQ) const
	Write the derivative of total energy with respect to atomic charges from n2p2 into LAMMPS.

void	getScreeningInfo (double *const &rScreen) const
	Read screening function information from n2p2 into LAMMPS.

void	getdChidxyz (int tag, double const &dChidx, double const &dChidy, double *const &dChidz) const
	Transfer spatial derivatives of atomic electronegativities.

void	setElecDone ()
	Set isElecDone true after running the first NN in 4G-HDNNPs.

void	writeToFile (std::string const fileName, bool const append)
	Write current structure to file in units used in training data.

void	add3DVecToArray (double *const &arr, Vec3D const &v) const
	Add a Vec3D vector to a 3D array in place.

Public Member Functions inherited from nnp::Mode
	Mode ()

void	initialize ()
	Write welcome message with version information.

void	loadSettingsFile (std::string const &fileName="input.nn")
	Open settings file and load all keywords into memory.

void	setupGeneric (std::string const &nnpDir="", bool skipNormalize=false, bool initialHardness=false)
	Combine multiple setup routines and provide a basic NNP setup.

void	setupNormalization (bool standalone=true)
	Set up normalization.

virtual void	setupElementMap ()
	Set up the element map.

virtual void	setupElements ()
	Set up all Element instances.

void	setupCutoff ()
	Set up cutoff function for all symmetry functions.

virtual void	setupSymmetryFunctions ()
	Set up all symmetry functions.

void	setupSymmetryFunctionScalingNone ()
	Set up "empy" symmetry function scaling.

virtual void	setupSymmetryFunctionScaling (std::string const &fileName="scaling.data")
	Set up symmetry function scaling from file.

virtual void	setupSymmetryFunctionGroups ()
	Set up symmetry function groups.

virtual void	setupSymmetryFunctionCache (bool verbose=false)
	Set up symmetry function cache.

void	setupSymmetryFunctionMemory (bool verbose=false)
	Extract required memory dimensions for symmetry function derivatives.

void	setupSymmetryFunctionStatistics (bool collectStatistics, bool collectExtrapolationWarnings, bool writeExtrapolationWarnings, bool stopOnExtrapolationWarnings)
	Set up symmetry function statistics collection.

void	setupCutoffMatrix ()
	Setup matrix storing all symmetry function cut-offs for each element.

virtual void	setupNeuralNetwork ()
	Set up neural networks for all elements.

virtual void	setupNeuralNetworkWeights (std::map< std::string, std::string > fileNameFormats=std::map< std::string, std::string >())
	Set up neural network weights from files with given name format.

virtual void	setupNeuralNetworkWeights (std::string directoryPrefix, std::map< std::string, std::string > fileNameFormats=std::map< std::string, std::string >())
	Set up neural network weights from files with given name format.

virtual void	setupElectrostatics (bool initialHardness=false, std::string directoryPrefix="", std::string fileNameFormat="hardness.%03zu.data")
	Set up electrostatics related stuff (hardness, screening, ...).

void	calculateSymmetryFunctions (Structure &structure, bool const derivatives)
	Calculate all symmetry functions for all atoms in given structure.

void	calculateSymmetryFunctionGroups (Structure &structure, bool const derivatives)
	Calculate all symmetry function groups for all atoms in given structure.

void	calculateAtomicNeuralNetworks (Structure &structure, bool const derivatives, std::string id="")
	Calculate a single atomic neural network for a given atom and nn type.

void	chargeEquilibration (Structure &structure, bool const derivativesElec)
	Perform global charge equilibration method.

void	calculateEnergy (Structure &structure) const
	Calculate potential energy for a given structure.

void	calculateCharge (Structure &structure) const
	Calculate total charge for a given structure.

void	calculateForces (Structure &structure) const
	Calculate forces for all atoms in given structure.

void	evaluateNNP (Structure &structure, bool useForces=true, bool useDEdG=true)
	Evaluate neural network potential (includes total energy, optionally forces and in some cases charges.

void	addEnergyOffset (Structure &structure, bool ref=true)
	Add atomic energy offsets to reference energy.

void	removeEnergyOffset (Structure &structure, bool ref=true)
	Remove atomic energy offsets from reference energy.

double	getEnergyOffset (Structure const &structure) const
	Get atomic energy offset for given structure.

double	getEnergyWithOffset (Structure const &structure, bool ref=true) const
	Add atomic energy offsets and return energy.

double	normalized (std::string const &property, double value) const
	Apply normalization to given property.

double	normalizedEnergy (Structure const &structure, bool ref=true) const
	Apply normalization to given energy of structure.

double	physical (std::string const &property, double value) const
	Undo normalization for a given property.

double	physicalEnergy (Structure const &structure, bool ref=true) const
	Undo normalization for a given energy of structure.

void	convertToNormalizedUnits (Structure &structure) const
	Convert one structure to normalized units.

void	convertToPhysicalUnits (Structure &structure) const
	Convert one structure to physical units.

void	logEwaldCutoffs ()
	Logs Ewald params whenever they change.

std::size_t	getNumExtrapolationWarnings () const
	Count total number of extrapolation warnings encountered for all elements and symmetry functions.

void	resetExtrapolationWarnings ()
	Erase all extrapolation warnings and reset counters.

NNPType	getNnpType () const
	Getter for Mode::nnpType.

double	getMeanEnergy () const
	Getter for Mode::meanEnergy.

double	getConvEnergy () const
	Getter for Mode::convEnergy.

double	getConvLength () const
	Getter for Mode::convLength.

double	getConvCharge () const
	Getter for Mode::convCharge.

double	getEwaldPrecision () const
	Getter for Mode::ewaldSetup.precision.

double	getEwaldMaxCharge () const
	Getter for Mode::ewaldSetup.maxCharge.

double	getEwaldMaxSigma () const
	Getter for Mode::ewaldSetup.maxQsigma.

EWALDTruncMethod	getEwaldTruncationMethod () const
	Getter for Mode::ewaldSetup.truncMethod.

KSPACESolver	kspaceSolver () const
	Getter for Mode::kspaceSolver.

double	getMaxCutoffRadius () const
	Getter for Mode::maxCutoffRadius.

std::size_t	getNumElements () const
	Getter for Mode::numElements.

ScreeningFunction	getScreeningFunction () const
	Getter for Mode::screeningFunction.

std::vector< std::size_t >	getNumSymmetryFunctions () const
	Get number of symmetry functions per element.

bool	useNormalization () const
	Check if normalization is enabled.

bool	settingsKeywordExists (std::string const &keyword) const
	Check if keyword was found in settings file.

std::string	settingsGetValue (std::string const &keyword) const
	Get value for given keyword in Settings instance.

std::vector< std::size_t >	pruneSymmetryFunctionsRange (double threshold)
	Prune symmetry functions according to their range and write settings file.

std::vector< std::size_t >	pruneSymmetryFunctionsSensitivity (double threshold, std::vector< std::vector< double > > sensitivity)
	Prune symmetry functions with sensitivity analysis data.

void	writePrunedSettingsFile (std::vector< std::size_t > prune, std::string fileName="output.nn") const
	Copy settings file but comment out lines provided.

void	writeSettingsFile (std::ofstream *const &file) const
	Write complete settings file.

Protected Attributes
int	myRank
	Process rank.

bool	initialized
	Initialization state.

bool	hasGlobalStructure
	Whether n2p2 knows about the global structure or only a local part.

bool	showew
	Corresponds to LAMMPS `showew` keyword.

bool	resetew
	Corresponds to LAMMPS `resetew` keyword.

int	showewsum
	Corresponds to LAMMPS `showewsum` keyword.

int	maxew
	Corresponds to LAMMPS `maxew` keyword.

double	cflength
	Corresponds to LAMMPS `cflength` keyword.

double	cfenergy
	Corresponds to LAMMPS `cfenergy` keyword.

std::string	emap
	Corresponds to LAMMPS `map` keyword.

std::vector< size_t >	indexMap
	Map from LAMMPS index to n2p2 atom index.

std::map< int, bool >	ignoreType
	True if atoms of this LAMMPS type will be ignored.

std::map< int, std::size_t >	mapTypeToElement
	Map from LAMMPS type to n2p2 element index.

std::map< std::size_t, int >	mapElementToType
	Map from n2p2 element index to LAMMPS type.

Structure	structure
	Structure containing local atoms.

bool	isElecDone
	True if first NN is calculated.

Protected Attributes inherited from nnp::Mode
NNPType	nnpType

bool	normalize

bool	checkExtrapolationWarnings

std::size_t	numElements

std::vector< std::size_t >	minNeighbors

std::vector< double >	minCutoffRadius

double	maxCutoffRadius

double	cutoffAlpha

double	meanEnergy

double	convEnergy

double	convLength

double	convCharge

double	fourPiEps

EwaldSetup	ewaldSetup

KspaceGrid	kspaceGrid

settings::Settings	settings

SymFnc::ScalingType	scalingType

CutoffFunction::CutoffType	cutoffType

ScreeningFunction	screeningFunction

std::vector< Element >	elements

std::vector< std::string >	nnk

std::map< std::string, NNSetup >	nns

std::vector< std::vector< double > >	cutoffs
	Matrix storing all symmetry function cut-offs for all elements.

ErfcBuf	erfcBuf

Additional Inherited Members
Public Types inherited from nnp::Mode
enum class	NNPType { HDNNP_2G = 2 , HDNNP_4G = 4 , HDNNP_Q = 10 }

Public Attributes inherited from nnp::Mode
ElementMap	elementMap
	Global element map, populated by setupElementMap().

Log	log
	Global log file.

Protected Member Functions inherited from nnp::Mode
void	readNeuralNetworkWeights (std::string const &id, std::string const &fileName)
	Read in weights for a specific type of neural network.

Detailed Description

Definition at line 31 of file InterfaceLammps.h.

Constructor & Destructor Documentation

◆ InterfaceLammps()

InterfaceLammps::InterfaceLammps ( )

Definition at line 38 of file InterfaceLammps.cpp.

                                 : myRank             (0    ),
                                     initialized        (false),
                                     hasGlobalStructure (false),
                                     showew             (true ),
                                     resetew            (false),
                                     showewsum          (0    ),
                                     maxew              (0    ),
                                     cflength           (1.0  ),
                                     cfenergy           (1.0  ),
                                     isElecDone         (false)
{
}

References cfenergy, cflength, hasGlobalStructure, initialized, isElecDone, maxew, myRank, resetew, showew, and showewsum.

Member Function Documentation

◆ initialize()

void InterfaceLammps::initialize	(	char const *const &	directory,
		char const *const &	emap,
		bool	showew,
		bool	resetew,
		int	showewsum,
		int	maxew,
		double	cflength,
		double	cfenergy,
		double	lammpsCutoff,
		int	lammpsNtypes,
		int	myRank )

Initialize the LAMMPS interface.

Parameters

[in]	directory	Directory containing NNP data files (weights, scaling, settings).
[in]	emap	Element mapping from LAMMPS to n2p2.
[in]	showew	If detailed extrapolation warnings for all atoms are shown.
[in]	resetew	If extrapolation warnings counter is reset every timestep.
[in]	showewsum	Show number of warnings every this many timesteps.
[in]	maxew	Abort simulation if more than this many warnings are encountered.
[in]	cflength	Length unit conversion factor.
[in]	cfenergy	Energy unit conversion factor.
[in]	lammpsCutoff	Cutoff radius from LAMMPS (via pair_coeff).
[in]	lammpsNtypes	Number of atom types in LAMMPS.
[in]	myRank	MPI process rank (passed on to structure index).

Definition at line 51 of file InterfaceLammps.cpp.

{
    this->emap = emap;
    this->showew = showew;
    this->resetew = resetew;
    this->showewsum = showewsum;
    this->maxew = maxew;
    this->cflength = cflength;
    this->cfenergy = cfenergy;
    this->myRank = myRank;
    log.writeToStdout = false;
    string dir(directory);
    char const separator = '/';
    if (dir.back() != separator) dir += separator;
    Mode::initialize();
    loadSettingsFile(dir + "input.nn");
    setupGeneric(dir);
    setupSymmetryFunctionScaling(dir + "scaling.data");
    bool collectStatistics = false;
    bool collectExtrapolationWarnings = false;
    bool writeExtrapolationWarnings = false;
    bool stopOnExtrapolationWarnings = false;
    if (showew == true || showewsum > 0 || maxew >= 0)
    {
        collectExtrapolationWarnings = true;
    }
    setupSymmetryFunctionStatistics(collectStatistics,
                                    collectExtrapolationWarnings,
                                    writeExtrapolationWarnings,
                                    stopOnExtrapolationWarnings);
    setupNeuralNetworkWeights(dir);
 
    log << "\n";
    log << "*** SETUP: LAMMPS INTERFACE *************"
           "**************************************\n";
    log << "\n";
 
    if (showew)
    {
        log << "Individual extrapolation warnings will be shown.\n";
    }
    else
    {
        log << "Individual extrapolation warnings will not be shown.\n";
    }
 
    if (showewsum != 0)
    {
        log << strpr("Extrapolation warning summary will be shown every %d"
                     " timesteps.\n", showewsum);
    }
    else
    {
        log << "Extrapolation warning summary will not be shown.\n";
    }
 
    if (maxew != 0)
    {
        log << strpr("The simulation will be stopped when %d extrapolation"
                     " warnings are exceeded.\n", maxew);
    }
    else
    {
        log << "No extrapolation warning limit set.\n";
    }
 
    if (resetew)
    {
        log << "Extrapolation warning counter is reset every time step.\n";
    }
    else
    {
        log << "Extrapolation warnings are accumulated over all time steps.\n";
    }
 
    log << "-----------------------------------------"
           "--------------------------------------\n";
    log << "CAUTION: If the LAMMPS unit system differs from the one used\n";
    log << "         during NN training, appropriate conversion factors\n";
    log << "         must be provided (see keywords cflength and cfenergy).\n";
    log << "\n";
    log << strpr("Length unit conversion factor: %24.16E\n", cflength);
    log << strpr("Energy unit conversion factor: %24.16E\n", cfenergy);
    double sfCutoff = getMaxCutoffRadius();
    log << "\n";
    log << "Checking consistency of cutoff radii (in LAMMPS units):\n";
    log << strpr("LAMMPS Cutoff (via pair_coeff)  : %11.3E\n", lammpsCutoff);
    log << strpr("Maximum symmetry function cutoff: %11.3E\n", sfCutoff);
    if (lammpsCutoff < sfCutoff)
    {
        throw runtime_error("ERROR: LAMMPS cutoff via pair_coeff keyword is"
                            " smaller than maximum symmetry function"
                            " cutoff.\n");
    }
    else if (fabs(sfCutoff - lammpsCutoff) / lammpsCutoff > TOLCUTOFF)
    {
        log << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n";
        log << "WARNING: Potential length units mismatch!\n";
        log << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n";
    }
    else
    {
        log << "Cutoff radii are consistent.\n";
    }
 
    log << "-----------------------------------------"
           "--------------------------------------\n";
    log << "Element mapping string from LAMMPS to n2p2: \""
           + this->emap + "\"\n";
    // Create default element mapping.
    if (this->emap == "")
    {
        if (elementMap.size() != (size_t)lammpsNtypes)
        {
            throw runtime_error(strpr("ERROR: No element mapping given and "
                                      "number of LAMMPS atom types (%d) and "
                                      "NNP elements (%zu) does not match.\n",
                                      lammpsNtypes, elementMap.size()));
        }
        log << "Element mapping string empty, creating default mapping.\n";
        for (int i = 0; i < lammpsNtypes; ++i)
        {
            mapTypeToElement[i + 1] = i;
            mapElementToType[i] = i + 1;
        }
    }
    // Read element mapping from pair_style argument.
    else
    {
        vector<string> emapSplit = split(reduce(trim(this->emap), " \t", ""),
                                         ',');
        if (elementMap.size() < emapSplit.size())
        {
            throw runtime_error(strpr("ERROR: Element mapping is inconsistent,"
                                      " NNP elements: %zu,"
                                      " emap elements: %zu.\n",
                                      elementMap.size(),
                                      emapSplit.size()));
        }
        for (string s : emapSplit)
        {
            vector<string> typeString = split(s, ':');
            if (typeString.size() != 2)
            {
                throw runtime_error(strpr("ERROR: Invalid element mapping "
                                          "string: \"%s\".\n", s.c_str()));
            }
            int t = stoi(typeString.at(0));
            if (t > lammpsNtypes)
            {
                throw runtime_error(strpr("ERROR: LAMMPS type \"%d\" not "
                                          "present, there are only %d types "
                                          "defined.\n", t, lammpsNtypes));
            }
            size_t e = elementMap[typeString.at(1)];
            mapTypeToElement[t] = e;
            mapElementToType[e] = t;
        }
    }
    log << "\n";
    log << "CAUTION: Please ensure that this mapping between LAMMPS\n";
    log << "         atom types and NNP elements is consistent:\n";
    log << "\n";
    log << "---------------------------\n";
    log << "LAMMPS type  |  NNP element\n";
    log << "---------------------------\n";
    for (int i = 1; i <= lammpsNtypes; ++i)
    {
        if (mapTypeToElement.find(i) != mapTypeToElement.end())
        {
            size_t e = mapTypeToElement.at(i);
            log << strpr("%11d <-> %2s (%3zu)\n",
                         i,
                         elementMap[e].c_str(),
                         elementMap.atomicNumber(e));
            ignoreType[i] = false;
        }
        else
        {
            log << strpr("%11d <-> --\n", i);
            ignoreType[i] = true;
 
        }
    }
    log << "---------------------------\n";
    log << "\n";
    log << "NNP setup for LAMMPS completed.\n";
 
    log << "*****************************************"
           "**************************************\n";
 
    structure.setElementMap(elementMap);
 
    initialized = true;
}

References cfenergy, cflength, nnp::Mode::elementMap, emap, getMaxCutoffRadius(), ignoreType, nnp::Mode::initialize(), initialized, nnp::Mode::loadSettingsFile(), nnp::Mode::log, mapElementToType, mapTypeToElement, maxew, myRank, nnp::reduce(), resetew, nnp::Mode::setupGeneric(), nnp::Mode::setupNeuralNetworkWeights(), nnp::Mode::setupSymmetryFunctionScaling(), nnp::Mode::setupSymmetryFunctionStatistics(), showew, showewsum, nnp::split(), nnp::strpr(), structure, TOLCUTOFF, nnp::trim(), and writeExtrapolationWarnings().

Here is the call graph for this function:

◆ setGlobalStructureStatus()

void InterfaceLammps::setGlobalStructureStatus ( bool const status )

Specify whether n2p2 knows about global structure or only local structure.

Parameters

[in] status true if n2p2 has global structure.

Definition at line 257 of file InterfaceLammps.cpp.

{
    hasGlobalStructure = status;
}

References hasGlobalStructure.

◆ getGlobalStructureStatus()

bool InterfaceLammps::getGlobalStructureStatus ( )

Check if n2p2 knows about global structure.

Definition at line 262 of file InterfaceLammps.cpp.

{
    return hasGlobalStructure;
}

References hasGlobalStructure.

◆ setLocalAtoms()

void InterfaceLammps::setLocalAtoms	(	int	numAtomsLocal,
		int const *const	atomType )

(Re)set structure to contain only local LAMMPS atoms.

Parameters

[in]	numAtomsLocal	Number of local atoms.
[in]	atomType	LAMMPS atom type.

Definition at line 267 of file InterfaceLammps.cpp.

{
    for (size_t i = 0; i < numElements; ++i)
    {
        structure.numAtomsPerElement[i] = 0;
    }
    structure.index                          = myRank;
    structure.numAtoms                       = 0;
    structure.hasNeighborList                = false;
    structure.hasSymmetryFunctions           = false;
    structure.hasSymmetryFunctionDerivatives = false;
    structure.energy                         = 0.0;
    structure.atoms.clear();
    indexMap.clear();
    structure.atoms.reserve(numAtomsLocal);
    indexMap.resize(numAtomsLocal, numeric_limits<size_t>::max());
    for (int i = 0; i < numAtomsLocal; i++)
    {
        if (ignoreType[atomType[i]]) continue;
        indexMap.at(i) = structure.numAtoms;
        structure.numAtoms++;
        structure.atoms.push_back(Atom());
        Atom& a = structure.atoms.back();
        a.index                          = i;
        a.indexStructure                 = myRank;
        a.element                        = mapTypeToElement[atomType[i]];
        a.numNeighbors                   = 0;
        a.hasSymmetryFunctions           = false;
        a.hasSymmetryFunctionDerivatives = false;
        a.neighbors.clear();
        a.numNeighborsPerElement.clear();
        a.numNeighborsPerElement.resize(numElements, 0);
        structure.numAtomsPerElement[a.element]++;
    }
 
    return;
}

References nnp::Atom::element, nnp::Atom::hasSymmetryFunctionDerivatives, nnp::Atom::hasSymmetryFunctions, ignoreType, nnp::Atom::index, indexMap, nnp::Atom::indexStructure, mapTypeToElement, myRank, nnp::Atom::neighbors, nnp::Mode::numElements, nnp::Atom::numNeighbors, nnp::Atom::numNeighborsPerElement, and structure.

◆ setLocalAtomPositions()

void InterfaceLammps::setLocalAtomPositions ( double const *const *const atomPos )

Set absolute atom positions from LAMMPS (nnp/develop only).

Parameters

[in] atomPos Atom coordinate array in LAMMPS units.

Definition at line 306 of file InterfaceLammps.cpp.

{
    for (size_t i = 0; i < structure.numAtoms; ++i)
    {
        Atom& a = structure.atoms.at(i);
        a.r[0] = atomPos[i][0] * cflength;
        a.r[1] = atomPos[i][1] * cflength;
        a.r[2] = atomPos[i][2] * cflength;
        if (normalize)
        {
            a.r[0] *= convLength;
            a.r[1] *= convLength;
            a.r[2] *= convLength;
        }
    }
 
    return;
}

References cflength, nnp::Mode::convLength, nnp::Mode::normalize, nnp::Atom::r, and structure.

◆ setLocalTags() [1/2]

void InterfaceLammps::setLocalTags ( int const *const atomTag )

Set atom tags (int version, -DLAMMPS_SMALLBIG).

Parameters

[in] atomTag LAMMPS atom tag.

Definition at line 325 of file InterfaceLammps.cpp.

{
    for (size_t i = 0; i < structure.atoms.size(); i++)
    {
        // Implicit conversion from int to int64_t!
        structure.atoms.at(i).tag = atomTag[i];
    }
 
    return;
}

References structure.

◆ setLocalTags() [2/2]

void InterfaceLammps::setLocalTags ( int64_t const *const atomTag )

Set atom tags (int64_t version, -DLAMMPS_BIGBIG).

Parameters

[in] atomTag LAMMPS atom tag.

Definition at line 336 of file InterfaceLammps.cpp.

{
    for (size_t i = 0; i < structure.atoms.size(); i++)
    {
        structure.atoms.at(i).tag = atomTag[i];
    }
 
    return;
}

References structure.

◆ setBoxVectors()

void InterfaceLammps::setBoxVectors	(	double const *	boxlo,
		double const *	boxhi,
		double const	xy,
		double const	xz,
		double const	yz )

Set box vectors of structure stored in LAMMPS (nnp/develop only).

Parameters

[in]	boxlo	Array containing coordinates of origin xlo, ylo, zlo.
[in]	boxhi	Array containing coordinates xhi, yhi, zhi.
[in]	xy	Tilt factor for box vector b.
[in]	xz	First tilt factor for box vector c.
[in]	yz	Second tilt factor for box vector c.

Definition at line 346 of file InterfaceLammps.cpp.

{
    structure.isPeriodic = true;
 
    // Box vector a
    structure.box[0][0] = boxhi[0] - boxlo[0];
    structure.box[0][1] = 0;
    structure.box[0][2] = 0;
 
    // Box vector b
    structure.box[1][0] = xy;
    structure.box[1][1] = boxhi[1] - boxlo[1];
    structure.box[1][2] = 0;
 
    // Box vector c
    structure.box[2][0] = xz;
    structure.box[2][1] = yz;
    structure.box[2][2] = boxhi[2] - boxlo[2];
 
    // LAMMPS may set triclinic = 1 even if the following condition is not
    // satisfied.
    if (structure.box[0][1] > numeric_limits<double>::min() ||
        structure.box[0][2] > numeric_limits<double>::min() ||
        structure.box[1][0] > numeric_limits<double>::min() ||
        structure.box[1][2] > numeric_limits<double>::min() ||
        structure.box[2][0] > numeric_limits<double>::min() ||
        structure.box[2][1] > numeric_limits<double>::min())
    {
        structure.isTriclinic = true;
    }
 
    for(size_t i = 0; i < 3; ++i)
    {
        structure.box[i] *= cflength;
        if (normalize) structure.box[i] *= convLength;
    }
 
    structure.calculateInverseBox();
    structure.calculateVolume();
    //cout << "Box vectors: \n";
    //for(size_t i = 0; i < 3; ++i)
    //{
    //    for(size_t j = 0; j < 3; ++j)
    //    {
    //        cout << structure.box[i][j] / convLength << " ";
    //    }
    //    cout << endl;
    //}
 
}

References cflength, nnp::Mode::convLength, nnp::Mode::normalize, and structure.

◆ allocateNeighborlists()

void InterfaceLammps::allocateNeighborlists ( int const *const numneigh )

Allocate neighbor lists.

Parameters

[in] numneigh Array containing number of neighbors for each local atom.

Definition at line 401 of file InterfaceLammps.cpp.

{
    for(size_t i = 0; i < structure.numAtoms; ++i)
    {
        auto& a = structure.atoms.at(i);
        a.neighbors.reserve(numneigh[i]);
    }
}

References structure.

◆ addNeighbor()

void InterfaceLammps::addNeighbor	(	int	i,
		int	j,
		int64_t	tag,
		int	type,
		double	dx,
		double	dy,
		double	dz,
		double	d2 )

Add one neighbor to atom (int64_t version, -DLAMMPS_BIGBIG).

Parameters

[in]	i	Local atom index.
[in]	j	Neighbor atom index.
[in]	tag	Neighbor atom tag.
[in]	type	Neighbor atom type.
[in]	dx	Neighbor atom distance in x direction.
[in]	dy	Neighbor atom distance in y direction.
[in]	dz	Neighbor atom distance in z direction.
[in]	d2	Square of neighbor atom distance.

If -DLAMMPS_SMALLBIG implicit conversion is applied for tag.

Definition at line 410 of file InterfaceLammps.cpp.

{
    if (ignoreType[type] ||
        indexMap.at(i) == numeric_limits<size_t>::max()) return;
    Atom& a = structure.atoms[indexMap.at(i)];
    a.numNeighbors++;
    a.neighbors.push_back(Atom::Neighbor());
    a.numNeighborsPerElement.at(mapTypeToElement[type])++;
    Atom::Neighbor& n = a.neighbors.back();
 
    n.index = j;
    n.tag = tag;
    n.element = mapTypeToElement[type];
    n.dr[0]   = dx * cflength;
    n.dr[1]   = dy * cflength;
    n.dr[2]   = dz * cflength;
    n.d       = sqrt(d2) * cflength;
    if (normalize)
    {
        n.dr *= convLength;
        n.d  *= convLength;
    }
 
    return;
}

References cflength, nnp::Mode::convLength, nnp::Atom::Neighbor::d, nnp::Atom::Neighbor::dr, nnp::Atom::Neighbor::element, ignoreType, nnp::Atom::Neighbor::index, indexMap, mapTypeToElement, nnp::Atom::neighbors, nnp::Mode::normalize, nnp::Atom::numNeighbors, nnp::Atom::numNeighborsPerElement, structure, and nnp::Atom::Neighbor::tag.

◆ finalizeNeighborList()

void InterfaceLammps::finalizeNeighborList ( )

Sorts neighbor list and creates cutoff map if necessary.

If structure is periodic, this function needs to be called after setBoxVectors!

Definition at line 443 of file InterfaceLammps.cpp.

{
    if (nnpType == NNPType::HDNNP_4G)
    {
        for (auto& a : structure.atoms)
        {
            a.hasNeighborList = true;
        }
        // Ewald summation cut-off depends on box vectors.
        structure.calculateMaxCutoffRadiusOverall(
                                            ewaldSetup,
                                            screeningFunction.getOuter(),
                                            maxCutoffRadius);
        structure.sortNeighborList();
        structure.setupNeighborCutoffMap(cutoffs);
    }
 
    return;
}

References nnp::Mode::cutoffs, nnp::Mode::ewaldSetup, nnp::Mode::HDNNP_4G, nnp::Mode::maxCutoffRadius, nnp::Mode::nnpType, nnp::Mode::screeningFunction, and structure.

◆ process()

void InterfaceLammps::process ( )

Calculate symmetry functions, atomic neural networks and sum of local energy contributions.

Definition at line 463 of file InterfaceLammps.cpp.

{
#ifdef N2P2_NO_SF_GROUPS
    calculateSymmetryFunctions(structure, true);
#else
    calculateSymmetryFunctionGroups(structure, true);
#endif
    if (nnpType == NNPType::HDNNP_2G)
    {
        calculateAtomicNeuralNetworks(structure, true);
        calculateEnergy(structure);
        if (normalize)
        {
            structure.energy = physicalEnergy(structure, false);
        }
        addEnergyOffset(structure, false);
    }
    else if (nnpType == NNPType::HDNNP_4G)
    {
        if (!isElecDone)
        {
            calculateAtomicNeuralNetworks(structure, true, "elec");
            isElecDone = true;
        } else
        {
            calculateAtomicNeuralNetworks(structure, true, "short");
            isElecDone = false;
            calculateEnergy(structure);
            if (normalize)
            {
                structure.energy = physicalEnergy(structure, false);
            }
            addEnergyOffset(structure, false);
        }
    }
 
    return;
}

References nnp::Mode::addEnergyOffset(), nnp::Mode::calculateAtomicNeuralNetworks(), nnp::Mode::calculateEnergy(), nnp::Mode::calculateSymmetryFunctionGroups(), nnp::Mode::calculateSymmetryFunctions(), nnp::Mode::HDNNP_2G, nnp::Mode::HDNNP_4G, isElecDone, nnp::Mode::nnpType, nnp::Mode::normalize, nnp::Mode::physicalEnergy(), and structure.

Here is the call graph for this function:

◆ processDevelop()

void InterfaceLammps::processDevelop ( )

Calculate symmetry functions, atomic neural networks and sum of local energy contributions (development version for "hdnnp/develop" pair style).

Definition at line 502 of file InterfaceLammps.cpp.

{
#ifdef N2P2_NO_SF_GROUPS
    calculateSymmetryFunctions(structure, true);
#else
    calculateSymmetryFunctionGroups(structure, true);
#endif
    calculateAtomicNeuralNetworks(structure, true, "");
    if (nnpType == NNPType::HDNNP_4G)
    {
        chargeEquilibration(structure, true);
        calculateAtomicNeuralNetworks(structure, true, "short");
        ewaldSetup.logEwaldCutoffs(log, convLength * cflength);
    }
    calculateEnergy(structure);
    if (nnpType == NNPType::HDNNP_4G ||
        nnpType == NNPType::HDNNP_Q) calculateCharge(structure);
    if (normalize)
    {
        structure.energy = physicalEnergy(structure, false);
    }
    addEnergyOffset(structure, false);
 
    return;
}

References nnp::Mode::addEnergyOffset(), nnp::Mode::calculateAtomicNeuralNetworks(), nnp::Mode::calculateCharge(), nnp::Mode::calculateEnergy(), nnp::Mode::calculateSymmetryFunctionGroups(), nnp::Mode::calculateSymmetryFunctions(), cflength, nnp::Mode::chargeEquilibration(), nnp::Mode::convLength, nnp::Mode::ewaldSetup, nnp::Mode::HDNNP_4G, nnp::Mode::HDNNP_Q, nnp::Mode::log, nnp::Mode::nnpType, nnp::Mode::normalize, nnp::Mode::physicalEnergy(), and structure.

Here is the call graph for this function:

◆ getEnergy()

double InterfaceLammps::getEnergy ( ) const

Return sum of local energy contributions.

Returns: Sum of local energy contributions.

Definition at line 550 of file InterfaceLammps.cpp.

{
    return structure.energy / cfenergy;
}

References cfenergy, and structure.

◆ getAtomicEnergy()

double InterfaceLammps::getAtomicEnergy ( int index ) const

Return energy contribution of one atom.

Parameters

[in] index Atom index.

Returns: energy contribution of atom with given index.

Attention: These atomic contributions are not physical!

Definition at line 555 of file InterfaceLammps.cpp.

{
    Atom const& a = structure.atoms.at(index);
    Element const& e = elements.at(a.element);
 
    if (normalize)
    {
        return (physical("energy", a.energy)
                + meanEnergy
                + e.getAtomicEnergyOffset()) / cfenergy;
    }
    else
    {
        return (a.energy + e.getAtomicEnergyOffset()) / cfenergy;
    }
}

References cfenergy, nnp::Atom::element, nnp::Mode::elements, nnp::Atom::energy, nnp::Element::getAtomicEnergyOffset(), nnp::Mode::meanEnergy, nnp::Mode::normalize, nnp::Mode::physical(), and structure.

Here is the call graph for this function:

◆ addElectrostaticEnergy()

void InterfaceLammps::addElectrostaticEnergy ( double energy )

Adds electrostatic energy contribution to the total structure energy.

Parameters

[in] electrostatic energy (calculated in LAMMPS).

Definition at line 674 of file InterfaceLammps.cpp.

{
    structure.energyElec = eElec;
}

References structure.

◆ getForces()

void InterfaceLammps::getForces ( double *const *const & atomF ) const

Calculate forces and add to LAMMPS atomic force arrays.

Parameters

[in,out] atomF LAMMPS force array for local and ghost atoms.

Definition at line 679 of file InterfaceLammps.cpp.

                                                                 {
    double const cfforce = cflength / cfenergy;
    double convForce = 1.0;
    if (normalize) {
        convForce = convLength / convEnergy;
    }
 
    // Loop over all local atoms. Neural network and Symmetry function
    // derivatives are saved in the dEdG arrays of atoms and dGdr arrays of
    // atoms and their neighbors. These are now summed up to the force
    // contributions of local and ghost atoms.
    Atom const *a = NULL;
 
    for (size_t i = 0; i < structure.atoms.size(); ++i) {
        // Set pointer to atom.
        a = &(structure.atoms.at(i));
 
#ifndef NNP_FULL_SFD_MEMORY
        vector <vector<size_t>> const &tableFull
                = elements.at(a->element).getSymmetryFunctionTable();
#endif
        // Loop over all neighbor atoms. Some are local, some are ghost atoms.
        for (vector<Atom::Neighbor>::const_iterator n = a->neighbors.begin();
             n != a->neighbors.end(); ++n) {
            // Temporarily save the neighbor index. Note: this is the index for
            // the LAMMPS force array.
            size_t const in = n->index;
            // Now loop over all symmetry functions and add force contributions
            // (local + ghost atoms).
#ifndef NNP_FULL_SFD_MEMORY
            vector <size_t> const &table = tableFull.at(n->element);
            for (size_t s = 0; s < n->dGdr.size(); ++s)
            {
                double const dEdG = a->dEdG[table.at(s)] * cfforce * convForce;
#else
            for (size_t s = 0; s < a->numSymmetryFunctions; ++s)
            {
                double const dEdG = a->dEdG[s] * cfforce * convForce;
#endif
                double const *const dGdr = n->dGdr[s].r;
                atomF[in][0] -= dEdG * dGdr[0];
                atomF[in][1] -= dEdG * dGdr[1];
                atomF[in][2] -= dEdG * dGdr[2];
            }
        }
        // Temporarily save the atom index. Note: this is the index for
        // the LAMMPS force array.
        size_t const ia = a->index;
        // Loop over all symmetry functions and add force contributions (local
        // atoms).
        for (size_t s = 0; s < a->numSymmetryFunctions; ++s)
        {
            double const dEdG = a->dEdG[s] * cfforce * convForce;
            double const *const dGdr = a->dGdr[s].r;
            atomF[ia][0] -= dEdG * dGdr[0];
            atomF[ia][1] -= dEdG * dGdr[1];
            atomF[ia][2] -= dEdG * dGdr[2];
        }
    }
 
    return;
}

References cfenergy, cflength, nnp::Mode::convEnergy, nnp::Mode::convLength, nnp::Atom::dEdG, nnp::Atom::dGdr, nnp::Atom::element, nnp::Mode::elements, nnp::Atom::index, nnp::Atom::neighbors, nnp::Mode::normalize, nnp::Atom::numSymmetryFunctions, and structure.

◆ getForcesDevelop()

void InterfaceLammps::getForcesDevelop ( double *const *const & atomF ) const

Calculate forces and add to LAMMPS atomic force arrays (development version for "hdnnp/develop" pair style).

Parameters

[in,out] atomF LAMMPS force array for local and ghost atoms.

Definition at line 742 of file InterfaceLammps.cpp.

{
    double const cfforce = cflength / cfenergy;
    double convForce = 1.0;
    if (normalize)
    {
        convForce = convLength / convEnergy;
    }
 
    // Loop over all local atoms. Neural network and Symmetry function
    // derivatives are saved in the dEdG arrays of atoms and dGdr arrays of
    // atoms and their neighbors. These are now summed up to the force
    // contributions of local and ghost atoms.
    for (auto const& a : structure.atoms)
    {
        size_t const ia = a.index;
        Vec3D selfForce = a.calculateSelfForceShort();
        selfForce *= cfforce * convForce;
        // TODO: ia is not the right index when some atom types are excluded / ignored
        //       (see use of indexmap)
        add3DVecToArray(atomF[ia], selfForce);
 
#ifndef N2P2_FULL_SFD_MEMORY
        vector<vector<size_t> > const& tableFull
            = elements.at(a.element).getSymmetryFunctionTable();
#endif
        // Loop over all neighbor atoms. Some are local, some are ghost atoms.
 
        //for (auto const& n : a.neighbors)
        size_t const numNeighbors = a.getStoredMinNumNeighbors(maxCutoffRadius);
#ifdef _OPENMP
        #pragma omp parallel for
#endif
        for (size_t k = 0; k < numNeighbors; ++k)
        {
            Atom::Neighbor const& n = a.neighbors[k];
            // Temporarily save the neighbor index. Note: this is the index for
            // the LAMMPS force array.
            size_t const in = n.index;
 
#ifndef N2P2_FULL_SFD_MEMORY
            Vec3D pairForce = a.calculatePairForceShort(n, &tableFull);
#else
            Vec3D pairForce = a.calculatePairForceShort(n);
#endif
            pairForce *= cfforce * convForce;
            add3DVecToArray(atomF[in], pairForce);
        }
    }
 
    // Comment: Will not work with multiple MPI tasks but this routine will
    //          probably be obsolete when Emir's solution is finished.
    if (nnpType == NNPType::HDNNP_4G)
    {
        Structure const& s = structure;
        VectorXd lambdaTotal = s.calculateForceLambdaTotal();
 
#ifdef _OPENMP
        #pragma omp parallel for
#endif
        // OpenMP 4.0 doesn't support range based loops
        for (size_t i = 0; i < s.numAtoms; ++i)
        {
            auto const& ai = s.atoms[i];
            add3DVecToArray(atomF[i], -ai.pEelecpr * cfforce * convForce);
 
            for (auto const& aj : s.atoms)
            {
                size_t const j = aj.index;
 
#ifndef N2P2_FULL_SFD_MEMORY
                vector<vector<size_t> > const& tableFull
                        = elements.at(aj.element).getSymmetryFunctionTable();
                Vec3D dChidr = aj.calculateDChidr(ai.index,
                                                  maxCutoffRadius,
                                                  &tableFull);
#else
                Vec3D dChidr = aj.calculateDChidr(ai.index,
                                                  maxCutoffRadius);
#endif
 
                Vec3D remainingForce = -lambdaTotal(j) * (ai.dAdrQ[j] + dChidr);
                add3DVecToArray(atomF[i], remainingForce * cfforce * convForce);
 
            }
        }
    }
    return;
}

References add3DVecToArray(), nnp::Structure::atoms, nnp::Structure::calculateForceLambdaTotal(), nnp::Atom::calculatePairForceShort(), nnp::Atom::calculateSelfForceShort(), cfenergy, cflength, nnp::Mode::convEnergy, nnp::Mode::convLength, nnp::Atom::element, nnp::Mode::elements, nnp::Atom::getStoredMinNumNeighbors(), nnp::Mode::HDNNP_4G, nnp::Atom::index, nnp::Atom::Neighbor::index, nnp::Mode::maxCutoffRadius, nnp::Atom::neighbors, nnp::Mode::nnpType, nnp::Mode::normalize, nnp::Structure::numAtoms, and structure.

Here is the call graph for this function:

◆ getForcesChi()

void InterfaceLammps::getForcesChi	(	double const *const &	lambda,
		double const const &	atomF ) const

Calculate chi-term for forces and add to LAMMPS atomic force arrays.

Parameters

[in,out] atomF LAMMPS force array for local and ghost atoms.

Definition at line 832 of file InterfaceLammps.cpp.

                                                                      {
    double const cfforce = cflength / cfenergy;
    double convForce = 1.0;
    if (normalize) {
        convForce = convLength / convEnergy;
    }
 
    // Loop over all local atoms. Neural network and Symmetry function
    // derivatives are saved in the dEdG arrays of atoms and dGdr arrays of
    // atoms and their neighbors. These are now summed up to the force
    // contributions of local and ghost atoms.
    Atom const *a = NULL;
 
    for (size_t i = 0; i < structure.atoms.size(); ++i) {
        // Set pointer to atom.
        a = &(structure.atoms.at(i));
 
        // Temporarily save the atom index. Note: this is the index for
        // the LAMMPS force array.
        size_t const ia = a->index;
        // Also save tag - 1 which is the correct position in lambda array.
        size_t const ta = a->tag - 1;
 
#ifndef NNP_FULL_SFD_MEMORY
        vector <vector<size_t>> const &tableFull
                = elements.at(a->element).getSymmetryFunctionTable();
#endif
        // Loop over all neighbor atoms. Some are local, some are ghost atoms.
        for (vector<Atom::Neighbor>::const_iterator n = a->neighbors.begin();
             n != a->neighbors.end(); ++n) {
            // Temporarily save the neighbor index. Note: this is the index for
            // the LAMMPS force array.
            size_t const in = n->index;
            // Also save tag - 1 which is the correct position in lambda array.
            size_t const tn = n->tag - 1;
            //std::cout << "Chi : " << a->chi << '\t' << "nei :" << n->index << '\n';
            // Now loop over all symmetry functions and add force contributions
            // (local + ghost atoms).
#ifndef NNP_FULL_SFD_MEMORY
            vector <size_t> const &table = tableFull.at(n->element);
            for (size_t s = 0; s < n->dGdr.size(); ++s)
            {
                double const dChidG = a->dChidG[table.at(s)]
                                    * cfforce * convForce;
#else
            for (size_t s = 0; s < a->numSymmetryFunctions; ++s)
            {
                double const dChidG = a->dChidG[s] * cfforce * convForce;
#endif
                double const *const dGdr = n->dGdr[s].r;
                atomF[in][0] -= lambda[ta] * dChidG * dGdr[0];
                atomF[in][1] -= lambda[ta] * dChidG * dGdr[1];
                atomF[in][2] -= lambda[ta] * dChidG * dGdr[2];
            }
        }
        // Loop over all symmetry functions and add force contributions (local
        // atoms).
        for (size_t s = 0; s < a->numSymmetryFunctions; ++s)
        {
            double const dChidG = a->dChidG[s] * cfforce * convForce;
            double const *const dGdr = a->dGdr[s].r;
            atomF[ia][0] -= lambda[ta] * dChidG * dGdr[0];
            atomF[ia][1] -= lambda[ta] * dChidG * dGdr[1];
            atomF[ia][2] -= lambda[ta] * dChidG * dGdr[2];
        }
    }
 
    return;
}

References cfenergy, cflength, nnp::Mode::convEnergy, nnp::Mode::convLength, nnp::Atom::dChidG, nnp::Atom::dGdr, nnp::Atom::element, nnp::Mode::elements, nnp::Atom::index, nnp::Atom::neighbors, nnp::Mode::normalize, nnp::Atom::numSymmetryFunctions, structure, and nnp::Atom::tag.

◆ getCharges()

void InterfaceLammps::getCharges ( double *const & atomQ ) const

Transfer charges (in units of e) to LAMMPS atomic charge vector.

Call after getAtomicEnergy().

Parameters

[in,out] atomQ LAMMPS charge vector.

Definition at line 903 of file InterfaceLammps.cpp.

{
    if (nnpType != NNPType::HDNNP_4G) return;
    if (!atomQ) return;
 
    Structure const& s = structure;
#ifdef _OPENMP
    #pragma omp parallel for
#endif
    for (size_t i = 0; i < s.numAtoms; ++i)
    {
        atomQ[i] = s.atoms[i].charge;
    }
 
    return;
}

References nnp::Structure::atoms, nnp::Mode::HDNNP_4G, nnp::Mode::nnpType, nnp::Structure::numAtoms, and structure.

◆ isInitialized()

bool nnp::InterfaceLammps::isInitialized ( ) const

inline

Check if this interface is correctly initialized.

Returns: True if initialized, False otherwise.

Definition at line 326 of file InterfaceLammps.h.

{
    return initialized;
}

References initialized.

◆ getMaxCutoffRadius()

double InterfaceLammps::getMaxCutoffRadius ( ) const

Get largest cutoff of symmetry functions.

Returns: Largest cutoff of all symmetry functions.

Definition at line 528 of file InterfaceLammps.cpp.

{
    if (normalize) return maxCutoffRadius / convLength / cflength;
    else return maxCutoffRadius / cflength;
}

References cflength, nnp::Mode::convLength, nnp::Mode::maxCutoffRadius, and nnp::Mode::normalize.

Referenced by getMaxCutoffRadiusOverall(), and initialize().

Here is the caller graph for this function:

◆ getEwaldPrec()

double InterfaceLammps::getEwaldPrec ( ) const

Get Ewald precision parameter.

Returns: Ewald precision parameter.

Definition at line 664 of file InterfaceLammps.cpp.

{
    return Mode::getEwaldPrecision();
}

References nnp::Mode::getEwaldPrecision().

Here is the call graph for this function:

◆ getMaxCutoffRadiusOverall()

double InterfaceLammps::getMaxCutoffRadiusOverall ( )

Get largest cutoff including structure specific cutoff and screening cutoff.

Returns: Largest cutoff of all symmetry functions and structure specific cutoff and screening cutoff.

Definition at line 534 of file InterfaceLammps.cpp.

{
    double cutoff = 0;
    if(nnpType == NNPType::HDNNP_4G)
    {
        structure.calculateMaxCutoffRadiusOverall(
                                        ewaldSetup,
                                        screeningFunction.getOuter(),
                                        maxCutoffRadius);
        cutoff = structure.maxCutoffRadiusOverall / cflength;
        if (normalize) cutoff /= convLength;
    }
    else cutoff = getMaxCutoffRadius();
    return cutoff;
}

References cflength, nnp::Mode::convLength, nnp::Mode::ewaldSetup, getMaxCutoffRadius(), nnp::Mode::HDNNP_4G, nnp::Mode::maxCutoffRadius, nnp::Mode::nnpType, nnp::Mode::normalize, nnp::Mode::screeningFunction, and structure.

Here is the call graph for this function:

◆ getEWBufferSize()

long InterfaceLammps::getEWBufferSize ( ) const

Calculate buffer size for extrapolation warning communication.

Returns: Buffer size.

Definition at line 920 of file InterfaceLammps.cpp.

{
    long bs = 0;
#ifndef N2P2_NO_MPI
    int ss = 0; // size_t size.
    int ds = 0; // double size.
    int cs = 0; // char size.
    MPI_Pack_size(1, MPI_SIZE_T, MPI_COMM_WORLD, &ss);
    MPI_Pack_size(1, MPI_DOUBLE, MPI_COMM_WORLD, &ds);
    MPI_Pack_size(1, MPI_CHAR  , MPI_COMM_WORLD, &cs);
 
    for (vector<Element>::const_iterator it = elements.begin();
         it != elements.end(); ++it)
    {
        map<size_t, SymFncStatistics::Container> const& m
            = it->statistics.data;
        bs += ss; // n.
        for (map<size_t, SymFncStatistics::Container>::const_iterator
             it2 = m.begin(); it2 != m.end(); ++it2)
        {
            bs += ss; // index   (it2->first).
            bs += ss; // countEW (it2->second.countEW).
            bs += ss; // type    (it2->second.type).
            bs += ds; // Gmin    (it2->second.Gmin).
            bs += ds; // Gmax    (it2->second.Gmax).
            bs += ss; // element.length() (it2->second.element.length()).
            bs += (it2->second.element.length() + 1) * cs; // element.
            size_t countEW = it2->second.countEW;
            bs += countEW * ss; // indexStructureEW.
            bs += countEW * ss; // indexAtomEW.
            bs += countEW * ds; // valueEW.
        }
    }
#endif
    return bs;
}

References nnp::Mode::elements, and MPI_SIZE_T.

◆ fillEWBuffer()

void InterfaceLammps::fillEWBuffer	(	char *const &	buf,
		int	bs ) const

Fill provided buffer with extrapolation warning entries.

Parameters

[in,out]	buf	Communication buffer to fill.
[in]	bs	Buffer size.

Definition at line 957 of file InterfaceLammps.cpp.

{
#ifndef N2P2_NO_MPI
    int p = 0;
    for (vector<Element>::const_iterator it = elements.begin();
         it != elements.end(); ++it)
    {
        map<size_t, SymFncStatistics::Container> const& m =
            it->statistics.data;
        size_t n = m.size();
        MPI_Pack((void *) &(n), 1, MPI_SIZE_T, buf, bs, &p, MPI_COMM_WORLD);
        for (map<size_t, SymFncStatistics::Container>::const_iterator
             it2 = m.begin(); it2 != m.end(); ++it2)
        {
            MPI_Pack((void *) &(it2->first                          ),       1, MPI_SIZE_T, buf, bs, &p, MPI_COMM_WORLD);
            size_t countEW = it2->second.countEW;
            MPI_Pack((void *) &(countEW                             ),       1, MPI_SIZE_T, buf, bs, &p, MPI_COMM_WORLD);
            MPI_Pack((void *) &(it2->second.type                    ),       1, MPI_SIZE_T, buf, bs, &p, MPI_COMM_WORLD);
            MPI_Pack((void *) &(it2->second.Gmin                    ),       1, MPI_DOUBLE, buf, bs, &p, MPI_COMM_WORLD);
            MPI_Pack((void *) &(it2->second.Gmax                    ),       1, MPI_DOUBLE, buf, bs, &p, MPI_COMM_WORLD);
            // it2->element
            size_t ts = it2->second.element.length() + 1;
            MPI_Pack((void *) &ts                                    ,       1, MPI_SIZE_T, buf, bs, &p, MPI_COMM_WORLD);
            MPI_Pack((void *) it2->second.element.c_str()            ,      ts, MPI_CHAR  , buf, bs, &p, MPI_COMM_WORLD);
            MPI_Pack((void *) &(it2->second.indexStructureEW.front()), countEW, MPI_SIZE_T, buf, bs, &p, MPI_COMM_WORLD);
            MPI_Pack((void *) &(it2->second.indexAtomEW.front()     ), countEW, MPI_SIZE_T, buf, bs, &p, MPI_COMM_WORLD);
            MPI_Pack((void *) &(it2->second.valueEW.front()         ), countEW, MPI_DOUBLE, buf, bs, &p, MPI_COMM_WORLD);
        }
    }
#endif
    return;
}

References nnp::Mode::elements, MPI_SIZE_T, and p.

◆ extractEWBuffer()

void InterfaceLammps::extractEWBuffer	(	char const *const &	buf,
		int	bs )

Extract given buffer to symmetry function statistics class.

Parameters

[in]	buf	Buffer with extrapolation warnings data.
[in]	bs	Buffer size.

Definition at line 990 of file InterfaceLammps.cpp.

{
#ifndef N2P2_NO_MPI
    int p = 0;
    for (vector<Element>::iterator it = elements.begin();
         it != elements.end(); ++it)
    {
        size_t n = 0;
        MPI_Unpack((void *) buf, bs, &p, &(n), 1, MPI_SIZE_T, MPI_COMM_WORLD);
        for (size_t i = 0; i < n; ++i)
        {
            size_t index = 0;
            MPI_Unpack((void *) buf, bs, &p, &(index), 1, MPI_SIZE_T, MPI_COMM_WORLD);
            SymFncStatistics::Container& d = it->statistics.data[index];
            size_t countEW = 0;
            MPI_Unpack((void *) buf, bs, &p, &(countEW                      ),       1, MPI_SIZE_T, MPI_COMM_WORLD);
            MPI_Unpack((void *) buf, bs, &p, &(d.type                       ),       1, MPI_SIZE_T, MPI_COMM_WORLD);
            MPI_Unpack((void *) buf, bs, &p, &(d.Gmin                       ),       1, MPI_DOUBLE, MPI_COMM_WORLD);
            MPI_Unpack((void *) buf, bs, &p, &(d.Gmax                       ),       1, MPI_DOUBLE, MPI_COMM_WORLD);
            // d.element
            size_t ts = 0;
            MPI_Unpack((void *) buf, bs, &p, &ts                             ,       1, MPI_SIZE_T, MPI_COMM_WORLD);
            char* element = new char[ts];
            MPI_Unpack((void *) buf, bs, &p, element                         ,      ts, MPI_CHAR  , MPI_COMM_WORLD);
            d.element = element;
            delete[] element;
            // indexStructureEW.
            d.indexStructureEW.resize(d.countEW + countEW);
            MPI_Unpack((void *) buf, bs, &p, &(d.indexStructureEW[d.countEW]), countEW, MPI_SIZE_T, MPI_COMM_WORLD);
            // indexAtomEW.
            d.indexAtomEW.resize(d.countEW + countEW);
            MPI_Unpack((void *) buf, bs, &p, &(d.indexAtomEW[d.countEW]     ), countEW, MPI_SIZE_T, MPI_COMM_WORLD);
            // valueEW.
            d.valueEW.resize(d.countEW + countEW);
            MPI_Unpack((void *) buf, bs, &p, &(d.valueEW[d.countEW]         ), countEW, MPI_DOUBLE, MPI_COMM_WORLD);
 
            d.countEW += countEW;
        }
    }
#endif
    return;
}

References d, nnp::Mode::elements, MPI_SIZE_T, and p.

◆ writeExtrapolationWarnings()

void InterfaceLammps::writeExtrapolationWarnings ( )

Write extrapolation warnings to log.

Definition at line 1033 of file InterfaceLammps.cpp.

{
    for (vector<Element>::const_iterator it = elements.begin();
         it != elements.end(); ++it)
    {
        vector<string> vs = it->statistics.getExtrapolationWarningLines();
        for (vector<string>::const_iterator it2 = vs.begin();
             it2 != vs.end(); ++it2)
        {
            log << (*it2);
        }
    }
 
    return;
}

References nnp::Mode::elements, and nnp::Mode::log.

Referenced by initialize().

Here is the caller graph for this function:

◆ clearExtrapolationWarnings()

void InterfaceLammps::clearExtrapolationWarnings ( )

Clear extrapolation warnings storage.

Definition at line 1049 of file InterfaceLammps.cpp.

{
    for (vector<Element>::iterator it = elements.begin();
         it != elements.end(); ++it)
    {
        it->statistics.clear();
    }
 
    return;
}

References nnp::Mode::elements.

◆ addCharge()

void InterfaceLammps::addCharge	(	int	index,
		double	Q )

Read atomic charges from LAMMPS into n2p2.

Definition at line 648 of file InterfaceLammps.cpp.

{
    Atom& a = structure.atoms.at(index);
    a.charge = Q;
    //log << strpr("Atom %5zu (%2s) q: %24.16E\n",
    //             a.tag, elementMap[a.element].c_str(), a.charge);
}

References nnp::Atom::charge, and structure.

◆ getQEqParams()

void InterfaceLammps::getQEqParams	(	double *const &	atomChi,
		double *const &	atomJ,
		double *const &	sigmaSqrtPi,
		double const const &	gammaSqrt2,
		double &	qRef ) const

Write QEq arrays from n2p2 to LAMMPS.

Parameters

[in]	atomChi	Electronegativities.
[in]	atomJ	Atomic hardness.
[in]	atomSigma	Gaussian width.
[in]	qRef	Reference charge of the structure.

Definition at line 572 of file InterfaceLammps.cpp.

{
    for (size_t i = 0; i < structure.atoms.size(); ++i) {
        Atom const& a = structure.atoms.at(i);
        size_t const ia = a.index;
        atomChi[ia] = a.chi;
    }
 
    for (size_t i = 0; i < numElements; ++i)
    {
        double const iSigma = elements.at(i).getQsigma();
        atomJ[i] = elements.at(i).getHardness();
        sigmaSqrtPi[i] = sqrt(M_PI) * iSigma;
        for (size_t j = 0; j < numElements; j++)
        {
            double const jSigma = elements.at(j).getQsigma();
            gammaSqrt2[i][j] = sqrt(2.0 * (iSigma * iSigma + jSigma * jSigma));
        }
    }
    qRef = structure.chargeRef;
}

References nnp::Atom::chi, nnp::Mode::elements, nnp::Atom::index, nnp::Mode::numElements, and structure.

◆ getdEdQ()

void InterfaceLammps::getdEdQ ( double *const & dEtotdQ ) const

Write the derivative of total energy with respect to atomic charges from n2p2 into LAMMPS.

Parameters

[in] dEtotdQ Derivative of the total energy w.r.t. atomic charge.

Definition at line 595 of file InterfaceLammps.cpp.

{
    Atom const* ai = NULL;
    for (size_t i = 0; i < structure.atoms.size(); ++i)
    {
        ai = &(structure.atoms.at(i));
        size_t const ia = ai->index;
        dEtotdQ[ia] += ai->dEdG.back();
    }
}

References nnp::Atom::dEdG, nnp::Atom::index, and structure.

◆ getScreeningInfo()

void InterfaceLammps::getScreeningInfo ( double *const & rScreen ) const

Read screening function information from n2p2 into LAMMPS.

Parameters

[in] rScreen Array that contains screening radii.

Definition at line 656 of file InterfaceLammps.cpp.

{
    screenInfo[0] = (double) screeningFunction.getCoreFunctionType(); //TODO: this does not work atm
    screenInfo[1] = screeningFunction.getInner();
    screenInfo[2] = screeningFunction.getOuter();
    screenInfo[3] = 1.0 / (screenInfo[2] - screenInfo[1]); // scale
}

References nnp::Mode::screeningFunction.

◆ getdChidxyz()

void InterfaceLammps::getdChidxyz	(	int	tag,
		double *const &	dChidx,
		double *const &	dChidy,
		double *const &	dChidz ) const

Transfer spatial derivatives of atomic electronegativities.

Parameters

[in]	tag	Atom of interest
	dChidx
	dChidy
	dChidz

Definition at line 606 of file InterfaceLammps.cpp.

{
    Atom const &ai = structure.atoms.at(ind);
 
    for (size_t j = 0; j < structure.numAtoms; ++j) {
        Atom const &aj = structure.atoms.at(j);
#ifndef NNP_FULL_SFD_MEMORY
        vector <vector<size_t>> const &tableFull
                = elements.at(aj.element).getSymmetryFunctionTable();
#endif
        Vec3D dChi;
        // need to add this case because the loop over the neighbors
        // does not include the contribution dChi_i/dr_i.
        if (ai.index == j) {
            for (size_t k = 0; k < aj.numSymmetryFunctions; ++k) {
                dChi += aj.dChidG.at(k) * aj.dGdr.at(k);
            }
        }
 
        for (auto const &n : aj.neighbors) {
            if (n.d > maxCutoffRadius) break;
            if (n.index == ai.index) {
#ifndef NNP_FULL_SFD_MEMORY
                vector <size_t> const &table = tableFull.at(n.element);
                for (size_t k = 0; k < n.dGdr.size(); ++k) {
                    dChi += aj.dChidG.at(table.at(k)) * n.dGdr.at(k);
                }
#else
                for (size_t k = 0; k < aj.numSymmetryFunctions; ++k)
                        {
                            dChi += aj.dChidG.at(k) * n.dGdr.at(k);
                        }
#endif
                }
            }
        dChidx[j] = dChi[0];
        dChidy[j] = dChi[1];
        dChidz[j] = dChi[2];
        }
}

References nnp::Atom::dChidG, nnp::Atom::dGdr, nnp::Atom::element, nnp::Mode::elements, nnp::Atom::index, nnp::Mode::maxCutoffRadius, nnp::Atom::neighbors, nnp::Atom::numSymmetryFunctions, and structure.

◆ setElecDone()

void InterfaceLammps::setElecDone ( )

Set isElecDone true after running the first NN in 4G-HDNNPs.

Definition at line 669 of file InterfaceLammps.cpp.

{
    if (isElecDone) isElecDone = false;
}

References isElecDone.

◆ writeToFile()

void InterfaceLammps::writeToFile	(	std::string const	fileName,
		bool const	append )

Write current structure to file in units used in training data.

Parameters

fileName	File name of the output structure file.
append	true if structure should be appended to existing file.

Definition at line 1060 of file InterfaceLammps.cpp.

{
    structure.toPhysicalUnits(meanEnergy, convEnergy, convLength, convCharge);
    structure.writeToFile(fileName, false, append);
    structure.toNormalizedUnits(meanEnergy, convEnergy, convLength, convCharge);
}

References nnp::Mode::convCharge, nnp::Mode::convEnergy, nnp::Mode::convLength, nnp::Mode::meanEnergy, and structure.

◆ add3DVecToArray()

void InterfaceLammps::add3DVecToArray	(	double *const &	arr,
		Vec3D const &	v ) const

Add a Vec3D vector to a 3D array in place.

Parameters

[in,out]	arr	Array which is edited in place.
[in]	v	Vector which is added to arr.

Definition at line 1068 of file InterfaceLammps.cpp.

{
    arr[0] += v[0];
    arr[1] += v[1];
    arr[2] += v[2];
}

Referenced by getForcesDevelop().

Here is the caller graph for this function:

Member Data Documentation

◆ myRank

int nnp::InterfaceLammps::myRank

protected

Process rank.

Definition at line 289 of file InterfaceLammps.h.

Referenced by initialize(), InterfaceLammps(), and setLocalAtoms().

◆ initialized

bool nnp::InterfaceLammps::initialized

protected

Initialization state.

Definition at line 291 of file InterfaceLammps.h.

Referenced by initialize(), InterfaceLammps(), and isInitialized().

◆ hasGlobalStructure

bool nnp::InterfaceLammps::hasGlobalStructure

protected

Whether n2p2 knows about the global structure or only a local part.

Definition at line 293 of file InterfaceLammps.h.

Referenced by getGlobalStructureStatus(), InterfaceLammps(), and setGlobalStructureStatus().

◆ showew

bool nnp::InterfaceLammps::showew

protected

Corresponds to LAMMPS showew keyword.

Definition at line 295 of file InterfaceLammps.h.

Referenced by initialize(), and InterfaceLammps().

◆ resetew

bool nnp::InterfaceLammps::resetew

protected

Corresponds to LAMMPS resetew keyword.

Definition at line 297 of file InterfaceLammps.h.

Referenced by initialize(), and InterfaceLammps().

◆ showewsum

int nnp::InterfaceLammps::showewsum

protected

Corresponds to LAMMPS showewsum keyword.

Definition at line 299 of file InterfaceLammps.h.

Referenced by initialize(), and InterfaceLammps().

◆ maxew

int nnp::InterfaceLammps::maxew

protected

Corresponds to LAMMPS maxew keyword.

Definition at line 301 of file InterfaceLammps.h.

Referenced by initialize(), and InterfaceLammps().

◆ cflength

double nnp::InterfaceLammps::cflength

protected

Corresponds to LAMMPS cflength keyword.

Definition at line 303 of file InterfaceLammps.h.

Referenced by addNeighbor(), getForces(), getForcesChi(), getForcesDevelop(), getMaxCutoffRadius(), getMaxCutoffRadiusOverall(), initialize(), InterfaceLammps(), processDevelop(), setBoxVectors(), and setLocalAtomPositions().

◆ cfenergy

double nnp::InterfaceLammps::cfenergy

protected

Corresponds to LAMMPS cfenergy keyword.

Definition at line 305 of file InterfaceLammps.h.

Referenced by getAtomicEnergy(), getEnergy(), getForces(), getForcesChi(), getForcesDevelop(), initialize(), and InterfaceLammps().

◆ emap

std::string nnp::InterfaceLammps::emap

protected

Corresponds to LAMMPS map keyword.

Definition at line 307 of file InterfaceLammps.h.

Referenced by initialize().

◆ indexMap

std::vector<size_t> nnp::InterfaceLammps::indexMap

protected

Map from LAMMPS index to n2p2 atom index.

Definition at line 309 of file InterfaceLammps.h.

Referenced by addNeighbor(), and setLocalAtoms().

◆ ignoreType

std::map<int, bool> nnp::InterfaceLammps::ignoreType

protected

True if atoms of this LAMMPS type will be ignored.

Definition at line 311 of file InterfaceLammps.h.

Referenced by addNeighbor(), initialize(), and setLocalAtoms().

◆ mapTypeToElement

std::map<int, std::size_t> nnp::InterfaceLammps::mapTypeToElement

protected

Map from LAMMPS type to n2p2 element index.

Definition at line 313 of file InterfaceLammps.h.

Referenced by addNeighbor(), initialize(), and setLocalAtoms().

◆ mapElementToType

std::map<std::size_t, int> nnp::InterfaceLammps::mapElementToType

protected

Map from n2p2 element index to LAMMPS type.

Definition at line 315 of file InterfaceLammps.h.

Referenced by initialize().

◆ structure

Structure nnp::InterfaceLammps::structure

protected

Structure containing local atoms.

Definition at line 317 of file InterfaceLammps.h.

Referenced by addCharge(), addElectrostaticEnergy(), addNeighbor(), allocateNeighborlists(), finalizeNeighborList(), getAtomicEnergy(), getCharges(), getdChidxyz(), getdEdQ(), getEnergy(), getForces(), getForcesChi(), getForcesDevelop(), getMaxCutoffRadiusOverall(), getQEqParams(), initialize(), process(), processDevelop(), setBoxVectors(), setLocalAtomPositions(), setLocalAtoms(), setLocalTags(), setLocalTags(), and writeToFile().

◆ isElecDone

bool nnp::InterfaceLammps::isElecDone

protected

True if first NN is calculated.

Definition at line 319 of file InterfaceLammps.h.

Referenced by InterfaceLammps(), process(), and setElecDone().

The documentation for this class was generated from the following files:

/home/runner/work/n2p2/n2p2/src/libnnpif/LAMMPS/InterfaceLammps.h
/home/runner/work/n2p2/n2p2/src/libnnpif/LAMMPS/InterfaceLammps.cpp

Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ InterfaceLammps()

Member Function Documentation

◆ initialize()

◆ setGlobalStructureStatus()

◆ getGlobalStructureStatus()

◆ setLocalAtoms()

◆ setLocalAtomPositions()

◆ setLocalTags() [1/2]

◆ setLocalTags() [2/2]

◆ setBoxVectors()

◆ allocateNeighborlists()

◆ addNeighbor()

◆ finalizeNeighborList()

◆ process()

◆ processDevelop()

◆ getEnergy()

◆ getAtomicEnergy()

◆ addElectrostaticEnergy()

◆ getForces()

◆ getForcesDevelop()

◆ getForcesChi()

◆ getCharges()

◆ isInitialized()

◆ getMaxCutoffRadius()

◆ getEwaldPrec()

◆ getMaxCutoffRadiusOverall()

◆ getEWBufferSize()

◆ fillEWBuffer()

◆ extractEWBuffer()

◆ writeExtrapolationWarnings()

◆ clearExtrapolationWarnings()

◆ addCharge()

◆ getQEqParams()

◆ getdEdQ()

◆ getScreeningInfo()

◆ getdChidxyz()

◆ setElecDone()

◆ writeToFile()

◆ add3DVecToArray()

Member Data Documentation

◆ myRank

◆ initialized

◆ hasGlobalStructure

◆ showew

◆ resetew

◆ showewsum

◆ maxew

◆ cflength

◆ cfenergy

◆ emap

◆ indexMap

◆ ignoreType

◆ mapTypeToElement

◆ mapElementToType

◆ structure

◆ isElecDone