#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	setLocalAtoms (int numAtomsLocal, int const *const atomType)
	(Re)set structure to contain only local LAMMPS atoms. 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	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	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...

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

double	getMaxCutoffRadius () const
	Get largest 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...

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 (bool skipNormalize=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...

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

virtual void	setupNeuralNetworkWeights (std::string const &fileNameFormatShort="weights.%03zu.data", std::string const &fileNameFormatCharge="weightse.%03zu.data")
	Set up neural network weights from files. 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)
	Calculate a single atomic neural network for a given atom and nn type. 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	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...

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

bool	useChargeNN

std::size_t	numElements

std::vector< std::size_t >	minNeighbors

std::vector< double >	minCutoffRadius

double	maxCutoffRadius

double	cutoffAlpha

double	meanEnergy

double	convEnergy

double	convLength

Settings	settings

SymFnc::ScalingType	scalingType

CutoffFunction::CutoffType	cutoffType

std::vector< Element >	elements

Additional Inherited Members
Public Types inherited from nnp::Mode
enum class	NNPType { SHORT_ONLY , SHORT_CHARGE_NN }

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 &type, 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 35 of file InterfaceLammps.cpp.

                                 : myRank      (0    ),
                                     initialized (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 47 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();
    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 + "weights.%03d.data");
 
    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::PairNNP::init_style().

Here is the call graph for this function:

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 253 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();
    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::PairNNP::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 291 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::PairNNP::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 302 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.

◆ 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 312 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[0] *= convLength;
        n.dr[1] *= convLength;
        n.dr[2] *= 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::PairNNP::transferNeighborList().

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

{
#ifdef N2P2_NO_SF_GROUPS
    calculateSymmetryFunctions(structure, true);
#else
    calculateSymmetryFunctionGroups(structure, true);
#endif
    calculateAtomicNeuralNetworks(structure, true);
    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::Structure::energy, nnp::Mode::normalize, nnp::Mode::physicalEnergy(), and structure.

Referenced by LAMMPS_NS::PairNNP::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 370 of file InterfaceLammps.cpp.

{
    return structure.energy / cfenergy;
}

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

Referenced by LAMMPS_NS::PairNNP::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 375 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::PairNNP::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 392 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 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 (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 N2P2_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 nnp::Structure::atoms, 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.

Referenced by LAMMPS_NS::PairNNP::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 194 of file InterfaceLammps.h.

{
    return initialized;
}

References initialized.

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

Here is the caller graph for this function:

◆ getMaxCutoffRadius()

double InterfaceLammps::getMaxCutoffRadius ( ) const

Get largest cutoff.

Returns: Largest cutoff of all symmetry functions.

Definition at line 364 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 LAMMPS_NS::PairNNP::init_style(), and initialize().

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 459 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::PairNNP::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 496 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::PairNNP::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 529 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::PairNNP::handleExtrapolationWarnings().

Here is the caller graph for this function:

◆ writeExtrapolationWarnings()

void InterfaceLammps::writeExtrapolationWarnings ( )

Write extrapolation warnings to log.

Definition at line 572 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::PairNNP::handleExtrapolationWarnings(), and initialize().

Here is the caller graph for this function:

◆ clearExtrapolationWarnings()

void InterfaceLammps::clearExtrapolationWarnings ( )

Clear extrapolation warnings storage.

Definition at line 588 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::PairNNP::handleExtrapolationWarnings().

Here is the caller graph for this function:

Member Data Documentation

◆ myRank

int nnp::InterfaceLammps::myRank

protected

Process rank.

Definition at line 161 of file InterfaceLammps.h.

Referenced by initialize(), and setLocalAtoms().

◆ initialized

bool nnp::InterfaceLammps::initialized

protected

Initialization state.

Definition at line 163 of file InterfaceLammps.h.

Referenced by initialize(), and isInitialized().

◆ showew

bool nnp::InterfaceLammps::showew

protected

Corresponds to LAMMPS showew keyword.

Definition at line 165 of file InterfaceLammps.h.

Referenced by initialize().

◆ resetew

bool nnp::InterfaceLammps::resetew

protected

Corresponds to LAMMPS resetew keyword.

Definition at line 167 of file InterfaceLammps.h.

Referenced by initialize().

◆ showewsum

int nnp::InterfaceLammps::showewsum

protected

Corresponds to LAMMPS showewsum keyword.

Definition at line 169 of file InterfaceLammps.h.

Referenced by initialize().

◆ maxew

int nnp::InterfaceLammps::maxew

protected

Corresponds to LAMMPS maxew keyword.

Definition at line 171 of file InterfaceLammps.h.

Referenced by initialize().

◆ cflength

double nnp::InterfaceLammps::cflength

protected

Corresponds to LAMMPS cflength keyword.

Definition at line 173 of file InterfaceLammps.h.

Referenced by addNeighbor(), getForces(), getMaxCutoffRadius(), and initialize().

◆ cfenergy

double nnp::InterfaceLammps::cfenergy

protected

Corresponds to LAMMPS cfenergy keyword.

Definition at line 175 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 177 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 179 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 181 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 183 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 185 of file InterfaceLammps.h.

Referenced by initialize().

◆ structure

Structure nnp::InterfaceLammps::structure

protected

Structure containing local atoms.

Definition at line 187 of file InterfaceLammps.h.

Referenced by addNeighbor(), getAtomicEnergy(), getEnergy(), getForces(), initialize(), process(), setLocalAtoms(), and setLocalTags().

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

◆ setLocalAtoms()

◆ setLocalTags() [1/2]

◆ setLocalTags() [2/2]

◆ addNeighbor()

◆ process()

◆ getEnergy()

◆ getAtomicEnergy()

◆ getForces()

◆ isInitialized()

◆ getMaxCutoffRadius()

◆ getEWBufferSize()

◆ fillEWBuffer()

◆ extractEWBuffer()

◆ writeExtrapolationWarnings()

◆ clearExtrapolationWarnings()

Member Data Documentation

◆ myRank

◆ initialized

◆ showew

◆ resetew

◆ showewsum

◆ maxew

◆ cflength

◆ cfenergy

◆ emap

◆ indexMap

◆ ignoreType

◆ mapTypeToElement

◆ mapElementToType

◆ structure