#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. More...

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

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

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

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

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

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

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). More...

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

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). More...

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

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

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

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

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

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

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

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

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

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

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

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

void	writeExtrapolationWarnings ()
	Write extrapolation warnings to log. More...

void	clearExtrapolationWarnings ()
	Clear extrapolation warnings storage. More...

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

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

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

void	initialize ()
	Write welcome message with version information. More...

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

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

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

virtual void	setupElementMap ()
	Set up the element map. More...

virtual void	setupElements ()
	Set up all Element instances. More...

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

virtual void	setupSymmetryFunctions ()
	Set up all symmetry functions. More...

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

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

virtual void	setupSymmetryFunctionGroups ()
	Set up symmetry function groups. More...

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

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

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

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

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

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. More...

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. More...

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

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

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

void	calculateAtomicNeuralNetworks (Structure &structure, bool const derivatives, std::string id="")
	Calculate atomic neural networks for all atoms in given structure. More...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	logEwaldCutoffs ()
	Logs Ewald params whenever they change. More...

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

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

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

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

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

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

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

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

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

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

bool	useNormalization () const
	Check if normalization is enabled. More...

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

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

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

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

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

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

Protected Attributes
int	myRank
	Process rank. More...

bool	initialized
	Initialization state. More...

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

bool	showew
	Corresponds to LAMMPS `showew` keyword. More...

bool	resetew
	Corresponds to LAMMPS `resetew` keyword. More...

int	showewsum
	Corresponds to LAMMPS `showewsum` keyword. More...

int	maxew
	Corresponds to LAMMPS `maxew` keyword. More...

double	cflength
	Corresponds to LAMMPS `cflength` keyword. More...

double	cfenergy
	Corresponds to LAMMPS `cfenergy` keyword. More...

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

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

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

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

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

Structure	structure
	Structure containing local atoms. More...

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

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. More...

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(). More...

Log	log
	Global log file. More...

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. More...

Detailed Description

Definition at line 30 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  )
 
{
}

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 nnp::ElementMap::atomicNumber(), 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::Structure::setElementMap(), nnp::Mode::setupGeneric(), nnp::Mode::setupNeuralNetworkWeights(), nnp::Mode::setupSymmetryFunctionScaling(), nnp::Mode::setupSymmetryFunctionStatistics(), showew, showewsum, nnp::ElementMap::size(), nnp::split(), nnp::strpr(), structure, TOLCUTOFF, nnp::trim(), writeExtrapolationWarnings(), and nnp::Log::writeToStdout.

Referenced by LAMMPS_NS::PairHDNNP::init_style().

Here is the call graph for this function:

Here is the caller 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.

Referenced by LAMMPS_NS::PairHDNNPDevelop::init_style().

Here is the caller graph for this function:

◆ getGlobalStructureStatus()

bool InterfaceLammps::getGlobalStructureStatus ( )

Check if n2p2 knows about global structure.

Definition at line 262 of file InterfaceLammps.cpp.

{
    return hasGlobalStructure;
}

References hasGlobalStructure.

Referenced by LAMMPS_NS::PairHDNNPDevelop::transferNeighborList().

Here is the caller graph for this function:

◆ 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::Structure::atoms, nnp::Atom::element, nnp::Structure::energy, nnp::Structure::hasNeighborList, nnp::Atom::hasSymmetryFunctionDerivatives, nnp::Structure::hasSymmetryFunctionDerivatives, nnp::Atom::hasSymmetryFunctions, nnp::Structure::hasSymmetryFunctions, ignoreType, nnp::Atom::index, nnp::Structure::index, indexMap, nnp::Atom::indexStructure, mapTypeToElement, myRank, nnp::Atom::neighbors, nnp::Structure::numAtoms, nnp::Structure::numAtomsPerElement, nnp::Mode::numElements, nnp::Atom::numNeighbors, nnp::Atom::numNeighborsPerElement, and structure.

Referenced by LAMMPS_NS::PairHDNNP::compute(), and LAMMPS_NS::PairHDNNPDevelop::compute().

Here is the caller graph for this function:

◆ 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 nnp::Structure::atoms, cflength, nnp::Mode::convLength, nnp::Mode::normalize, nnp::Structure::numAtoms, nnp::Atom::r, and structure.

Referenced by LAMMPS_NS::PairHDNNPDevelop::compute().

Here is the caller graph for this function:

◆ 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 nnp::Structure::atoms, and structure.

Referenced by LAMMPS_NS::PairHDNNP::compute(), and LAMMPS_NS::PairHDNNPDevelop::compute().

Here is the caller graph for this function:

◆ 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 nnp::Structure::atoms, and 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 nnp::Structure::box, nnp::Structure::calculateInverseBox(), nnp::Structure::calculateVolume(), cflength, nnp::Mode::convLength, nnp::Structure::isPeriodic, nnp::Structure::isTriclinic, nnp::Mode::normalize, and structure.

Referenced by LAMMPS_NS::PairHDNNPDevelop::compute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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 nnp::Structure::atoms, nnp::Structure::numAtoms, and structure.

Referenced by LAMMPS_NS::PairHDNNPDevelop::transferNeighborList().

Here is the caller graph for this function:

◆ 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 nnp::Structure::atoms, 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.

Referenced by LAMMPS_NS::PairHDNNP::transferNeighborList(), and LAMMPS_NS::PairHDNNPDevelop::transferNeighborList().

Here is the caller graph for this function:

◆ 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 444 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);
    }
 
}

References nnp::Structure::atoms, nnp::Structure::calculateMaxCutoffRadiusOverall(), nnp::Mode::cutoffs, nnp::Mode::ewaldSetup, nnp::ScreeningFunction::getOuter(), nnp::Mode::HDNNP_4G, nnp::Mode::maxCutoffRadius, nnp::Mode::nnpType, nnp::Mode::screeningFunction, nnp::Structure::setupNeighborCutoffMap(), nnp::Structure::sortNeighborList(), and structure.

Referenced by LAMMPS_NS::PairHDNNPDevelop::transferNeighborList().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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
    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::Structure::energy, nnp::Mode::ewaldSetup, nnp::Mode::HDNNP_4G, nnp::Mode::HDNNP_Q, nnp::Mode::log, nnp::EwaldSetup::logEwaldCutoffs(), nnp::Mode::nnpType, nnp::Mode::normalize, nnp::Mode::physicalEnergy(), and structure.

Referenced by LAMMPS_NS::PairHDNNP::compute(), and LAMMPS_NS::PairHDNNPDevelop::compute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getEnergy()

double InterfaceLammps::getEnergy ( ) const

Return sum of local energy contributions.

Returns: Sum of local energy contributions.

Definition at line 511 of file InterfaceLammps.cpp.

{
    return structure.energy / cfenergy;
}

References cfenergy, nnp::Structure::energy, and structure.

Referenced by LAMMPS_NS::PairHDNNP::compute(), and LAMMPS_NS::PairHDNNPDevelop::compute().

Here is the caller graph for this function:

◆ 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 516 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 nnp::Structure::atoms, cfenergy, nnp::Atom::element, nnp::Mode::elements, nnp::Atom::energy, nnp::Element::getAtomicEnergyOffset(), nnp::Mode::meanEnergy, nnp::Mode::normalize, nnp::Mode::physical(), and structure.

Referenced by LAMMPS_NS::PairHDNNP::compute(), and LAMMPS_NS::PairHDNNPDevelop::compute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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 533 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(), cfenergy, cflength, nnp::Mode::convEnergy, nnp::Mode::convLength, nnp::Mode::elements, nnp::Mode::HDNNP_4G, nnp::Atom::Neighbor::index, nnp::Mode::maxCutoffRadius, nnp::Mode::nnpType, nnp::Mode::normalize, nnp::Structure::numAtoms, and structure.

Referenced by LAMMPS_NS::PairHDNNP::compute(), and LAMMPS_NS::PairHDNNPDevelop::compute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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 623 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;
    }
}

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

Referenced by LAMMPS_NS::PairHDNNPDevelop::compute().

Here is the caller graph for this function:

◆ isInitialized()

bool nnp::InterfaceLammps::isInitialized ( ) const

inline

Check if this interface is correctly initialized.

Returns: True if initialized, False otherwise.

Definition at line 256 of file InterfaceLammps.h.

{
    return initialized;
}

References initialized.

Referenced by LAMMPS_NS::PairHDNNP::init_style().

Here is the caller graph for this function:

◆ getMaxCutoffRadius()

double InterfaceLammps::getMaxCutoffRadius ( ) const

Get largest cutoff of symmetry functions.

Returns: Largest cutoff of all symmetry functions.

Definition at line 489 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:

◆ 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 495 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 nnp::Structure::calculateMaxCutoffRadiusOverall(), cflength, nnp::Mode::convLength, nnp::Mode::ewaldSetup, getMaxCutoffRadius(), nnp::ScreeningFunction::getOuter(), nnp::Mode::HDNNP_4G, nnp::Mode::maxCutoffRadius, nnp::Structure::maxCutoffRadiusOverall, nnp::Mode::nnpType, nnp::Mode::normalize, nnp::Mode::screeningFunction, and structure.

Referenced by LAMMPS_NS::PairHDNNPDevelop::updateNeighborlistCutoff().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getEWBufferSize()

long InterfaceLammps::getEWBufferSize ( ) const

Calculate buffer size for extrapolation warning communication.

Returns: Buffer size.

Definition at line 638 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.

Referenced by LAMMPS_NS::PairHDNNP::handleExtrapolationWarnings().

Here is the caller graph for this function:

◆ 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 675 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.

Referenced by LAMMPS_NS::PairHDNNP::handleExtrapolationWarnings().

Here is the caller graph for this function:

◆ 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 708 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.

Referenced by LAMMPS_NS::PairHDNNP::handleExtrapolationWarnings().

Here is the caller graph for this function:

◆ writeExtrapolationWarnings()

void InterfaceLammps::writeExtrapolationWarnings ( )

Write extrapolation warnings to log.

Definition at line 751 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 LAMMPS_NS::PairHDNNP::handleExtrapolationWarnings(), and initialize().

Here is the caller graph for this function:

◆ clearExtrapolationWarnings()

void InterfaceLammps::clearExtrapolationWarnings ( )

Clear extrapolation warnings storage.

Definition at line 767 of file InterfaceLammps.cpp.

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

References nnp::Mode::elements.

Referenced by LAMMPS_NS::PairHDNNP::handleExtrapolationWarnings().

Here is the caller graph for this function:

◆ 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 778 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, structure, nnp::Structure::toNormalizedUnits(), nnp::Structure::toPhysicalUnits(), and nnp::Structure::writeToFile().

Here is the call graph for this function:

◆ 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 786 of file InterfaceLammps.cpp.

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

Referenced by getForces().

Here is the caller graph for this function:

Member Data Documentation

◆ myRank

int nnp::InterfaceLammps::myRank

protected

Process rank.

Definition at line 221 of file InterfaceLammps.h.

Referenced by initialize(), and setLocalAtoms().

◆ initialized

bool nnp::InterfaceLammps::initialized

protected

Initialization state.

Definition at line 223 of file InterfaceLammps.h.

Referenced by initialize(), and isInitialized().

◆ hasGlobalStructure

bool nnp::InterfaceLammps::hasGlobalStructure

protected

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

Definition at line 225 of file InterfaceLammps.h.

Referenced by getGlobalStructureStatus(), and setGlobalStructureStatus().

◆ showew

bool nnp::InterfaceLammps::showew

protected

Corresponds to LAMMPS showew keyword.

Definition at line 227 of file InterfaceLammps.h.

Referenced by initialize().

◆ resetew

bool nnp::InterfaceLammps::resetew

protected

Corresponds to LAMMPS resetew keyword.

Definition at line 229 of file InterfaceLammps.h.

Referenced by initialize().

◆ showewsum

int nnp::InterfaceLammps::showewsum

protected

Corresponds to LAMMPS showewsum keyword.

Definition at line 231 of file InterfaceLammps.h.

Referenced by initialize().

◆ maxew

int nnp::InterfaceLammps::maxew

protected

Corresponds to LAMMPS maxew keyword.

Definition at line 233 of file InterfaceLammps.h.

Referenced by initialize().

◆ cflength

double nnp::InterfaceLammps::cflength

protected

Corresponds to LAMMPS cflength keyword.

Definition at line 235 of file InterfaceLammps.h.

Referenced by addNeighbor(), getForces(), getMaxCutoffRadius(), getMaxCutoffRadiusOverall(), initialize(), process(), setBoxVectors(), and setLocalAtomPositions().

◆ cfenergy

double nnp::InterfaceLammps::cfenergy

protected

Corresponds to LAMMPS cfenergy keyword.

Definition at line 237 of file InterfaceLammps.h.

Referenced by getAtomicEnergy(), getEnergy(), getForces(), and initialize().

◆ emap

std::string nnp::InterfaceLammps::emap

protected

Corresponds to LAMMPS map keyword.

Definition at line 239 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 241 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 243 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 245 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 247 of file InterfaceLammps.h.

Referenced by initialize().

◆ structure

Structure nnp::InterfaceLammps::structure

protected

Structure containing local atoms.

Definition at line 249 of file InterfaceLammps.h.

Referenced by addNeighbor(), allocateNeighborlists(), finalizeNeighborList(), getAtomicEnergy(), getCharges(), getEnergy(), getForces(), getMaxCutoffRadiusOverall(), initialize(), process(), setBoxVectors(), setLocalAtomPositions(), setLocalAtoms(), setLocalTags(), and writeToFile().

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()

◆ getEnergy()

◆ getAtomicEnergy()

◆ getForces()

◆ getCharges()

◆ isInitialized()

◆ getMaxCutoffRadius()

◆ getMaxCutoffRadiusOverall()

◆ getEWBufferSize()

◆ fillEWBuffer()

◆ extractEWBuffer()

◆ writeExtrapolationWarnings()

◆ clearExtrapolationWarnings()

◆ writeToFile()

◆ add3DVecToArray()

Member Data Documentation

◆ myRank

◆ initialized

◆ hasGlobalStructure

◆ showew

◆ resetew

◆ showewsum

◆ maxew

◆ cflength

◆ cfenergy

◆ emap

◆ indexMap

◆ ignoreType

◆ mapTypeToElement

◆ mapElementToType

◆ structure