nnp::Atom Struct Reference

Storage for a single atom. More...

#include <Atom.h>

Collaboration diagram for nnp::Atom:

Classes
struct	Neighbor
	Struct to store information on neighbor atoms. More...

Public Member Functions
	Atom ()
	Atom constructor, initialize to zero. More...
void	toNormalizedUnits (double convEnergy, double convLength)
	Switch to normalized length and energy units. More...
void	toPhysicalUnits (double convEnergy, double convLength)
	Switch to physical length and energy units. More...
void	allocate (bool all)
	Allocate vectors related to symmetry functions (G, dEdG). More...
void	free (bool all)
	Free vectors related to symmetry functions, opposite of allocate(). More...
void	clearNeighborList ()
	Clear neighbor list. More...
void	clearNeighborList (std::size_t const numElements)
	Clear neighbor list and change number of elements. More...
std::size_t	getNumNeighbors (double cutoffRadius) const
	Calculate number of neighbors for a given cutoff radius. More...
void	updateError (std::string const &property, std::map< std::string, double > &error, std::size_t &count) const
	Update property error metrics with data from this atom. More...
std::vector< std::string >	getForcesLines () const
	Get reference and NN forces for this atoms. More...
std::string	getChargeLine () const
	Get reference and NN charge for this atoms. More...
std::vector< std::string >	info () const
	Get atom information as a vector of strings. More...

Public Attributes
bool	hasNeighborList
	If the neighbor list has been calculated for this atom. More...
bool	hasSymmetryFunctions
	If symmetry function values are saved for this atom. More...
bool	hasSymmetryFunctionDerivatives
	If symmetry function derivatives are saved for this atom. More...
bool	useChargeNeuron
	If an additional charge neuron in the short-range NN is present. More...
std::size_t	index
	Index number of this atom. More...
std::size_t	indexStructure
	Index number of structure this atom belongs to. More...
int64_t	tag
	Tag number of this atom. More...
std::size_t	element
	Element index of this atom. More...
std::size_t	numNeighbors
	Total number of neighbors. More...
std::size_t	numNeighborsUnique
	Number of unique neighbor indices (don't count multiple PBC images). More...
std::size_t	numSymmetryFunctions
	Number of symmetry functions used to describe the atom environment. More...
double	energy
	Atomic energy determined by neural network. More...
double	charge
	Atomic charge determined by neural network. More...
double	chargeRef
	Atomic reference charge. More...
Vec3D	r
	Cartesian coordinates. More...
Vec3D	f
	Force vector calculated by neural network. More...
Vec3D	fRef
	Reference force vector from data set. More...
std::vector< std::size_t >	neighborsUnique
	List of unique neighbor indices (don't count multiple PBC images). More...
std::vector< std::size_t >	numNeighborsPerElement
	Number of neighbors per element. More...
std::vector< std::size_t >	numSymmetryFunctionDerivatives
	Number of neighbor atom symmetry function derivatives per element. More...
std::vector< std::size_t >	cacheSizePerElement
	Cache size for each element. More...
std::vector< double >	G
	Symmetry function values. More...
std::vector< double >	dEdG
	Derivative of atomic energy with respect to symmetry functions. More...
std::vector< double >	dQdG
	Derivative of atomic charge with respect to symmetry functions. More...
std::vector< Vec3D >	dGdr
	Derivative of symmetry functions with respect to this atom's coordinates. More...
std::vector< Neighbor >	neighbors
	Neighbor array (maximum number defined in macros.h. More...

Detailed Description

Storage for a single atom.

Definition at line 31 of file Atom.h.

Constructor & Destructor Documentation

Atom()

Atom::Atom

(

)

Atom constructor, initialize to zero.

Definition at line 27 of file Atom.cpp.

           : hasNeighborList               (false),
               hasSymmetryFunctions          (false),
               hasSymmetryFunctionDerivatives(false),
               useChargeNeuron               (false),
               index                         (0    ),
               indexStructure                (0    ),
               tag                           (0    ),
               element                       (0    ),
               numNeighbors                  (0    ),
               numNeighborsUnique            (0    ),
               numSymmetryFunctions          (0    ),
               energy                        (0.0  ),
               charge                        (0.0  ),
               chargeRef                     (0.0  )
{
}

Member Function Documentation

toNormalizedUnits()

void Atom::toNormalizedUnits	(	double	convEnergy,
		double	convLength
	)

Switch to normalized length and energy units.

Parameters

[in]	convEnergy	Multiplicative energy unit conversion factor.
[in]	convLength	Multiplicative length unit conversion factor.

Definition at line 73 of file Atom.cpp.

{
    energy *= convEnergy;
    r *= convLength;
    f *= convEnergy / convLength;
    fRef *= convEnergy / convLength;
    if (hasSymmetryFunctionDerivatives)
    {
        for (size_t i = 0; i < numSymmetryFunctions; ++i)
        {
            dEdG.at(i) *= convEnergy;
            dGdr.at(i) /= convLength;
#ifdef N2P2_FULL_SFD_MEMORY
            dGdxia.at(i) /= convLength;
#endif
        }
        // Take care of extra charge neuron.
        if (useChargeNeuron) dEdG.at(numSymmetryFunctions) *= convEnergy;
    }
 
    if (hasNeighborList)
    {
        for (vector<Neighbor>::iterator it = neighbors.begin();
             it != neighbors.end(); ++it)
        {
            it->d *= convLength;
            it->dr *= convLength;
            if (hasSymmetryFunctionDerivatives)
            {
                for (size_t i = 0; i < dGdr.size(); ++i)
                {
                    dGdr.at(i) /= convLength;
                }
            }
        }
    }
 
    return;
}

References dEdG, dGdr, energy, f, fRef, hasNeighborList, hasSymmetryFunctionDerivatives, neighbors, numSymmetryFunctions, r, and useChargeNeuron.

toPhysicalUnits()

void Atom::toPhysicalUnits	(	double	convEnergy,
		double	convLength
	)

Switch to physical length and energy units.

Parameters

[in]	convEnergy	Multiplicative energy unit conversion factor.
[in]	convLength	Multiplicative length unit conversion factor.

Definition at line 113 of file Atom.cpp.

{
    energy /= convEnergy;
    r /= convLength;
    f /= convEnergy / convLength;
    fRef /= convEnergy / convLength;
    if (hasSymmetryFunctionDerivatives)
    {
        for (size_t i = 0; i < numSymmetryFunctions; ++i)
        {
            dEdG.at(i) /= convEnergy;
            dGdr.at(i) *= convLength;
#ifdef N2P2_FULL_SFD_MEMORY
            dGdxia.at(i) *= convLength;
#endif
        }
        // Take care of extra charge neuron.
        if (useChargeNeuron) dEdG.at(numSymmetryFunctions) *= convEnergy;
    }
 
    if (hasNeighborList)
    {
        for (vector<Neighbor>::iterator it = neighbors.begin();
             it != neighbors.end(); ++it)
        {
            it->d /= convLength;
            it->dr /= convLength;
            if (hasSymmetryFunctionDerivatives)
            {
                for (size_t i = 0; i < dGdr.size(); ++i)
                {
                    dGdr.at(i) *= convLength;
                }
            }
        }
    }
 
    return;
}

References dEdG, dGdr, energy, f, fRef, hasNeighborList, hasSymmetryFunctionDerivatives, neighbors, numSymmetryFunctions, r, and useChargeNeuron.

allocate()

void Atom::allocate

(

bool

all

)

Allocate vectors related to symmetry functions (G, dEdG).

Parameters

[in]

all

If true allocate also vectors corresponding to derivatives of symmetry functions (dEdG, dGdr, #dGdxia and Neighbor::dGdr, neighbors must be present). If false allocate only G.

Warning: numSymmetryFunctions and numSymmetryFunctionDerivatives need to be set first (the latter only in case of argument all == true.

Definition at line 153 of file Atom.cpp.

{
    if (numSymmetryFunctions == 0)
    {
        throw range_error("ERROR: Number of symmetry functions set to"
                          "zero, cannot allocate.\n");
    }
 
    // Clear all symmetry function related vectors (also for derivatives).
    G.clear();
    dEdG.clear();
    dQdG.clear();
#ifdef N2P2_FULL_SFD_MEMORY
    dGdxia.clear();
#endif
    dGdr.clear();
    for (vector<Neighbor>::iterator it = neighbors.begin();
         it != neighbors.end(); ++it)
    {
#ifndef N2P2_NO_SF_CACHE
        it->cache.clear();
#endif
        it->dGdr.clear();
    }
 
    // Reset status of symmetry functions and derivatives.
    hasSymmetryFunctions           = false;
    hasSymmetryFunctionDerivatives = false;
 
    // Resize vectors (derivatives only if requested).
    G.resize(numSymmetryFunctions, 0.0);
    if (all)
    {
#ifndef N2P2_FULL_SFD_MEMORY
        if (numSymmetryFunctionDerivatives.size() == 0)
        {
            throw range_error("ERROR: Number of symmetry function derivatives"
                              " unset, cannot allocate.\n");
        }
#endif
        if (useChargeNeuron) dEdG.resize(numSymmetryFunctions + 1, 0.0);
        else                 dEdG.resize(numSymmetryFunctions, 0.0);
        dQdG.resize(numSymmetryFunctions, 0.0);
#ifdef N2P2_FULL_SFD_MEMORY
        dGdxia.resize(numSymmetryFunctions, 0.0);
#endif
        dGdr.resize(numSymmetryFunctions);
    }
    for (vector<Neighbor>::iterator it = neighbors.begin();
         it != neighbors.end(); ++it)
    {
#ifndef N2P2_NO_SF_CACHE
        it->cache.resize(cacheSizePerElement.at(it->element),
                         -numeric_limits<double>::max());
#endif
        if (all)
        {
#ifndef N2P2_FULL_SFD_MEMORY
            it->dGdr.resize(numSymmetryFunctionDerivatives.at(it->element));
#else
            it->dGdr.resize(numSymmetryFunctions);
#endif
        }
    }
 
    return;
}

References cacheSizePerElement, dEdG, dGdr, dQdG, G, hasSymmetryFunctionDerivatives, hasSymmetryFunctions, neighbors, numSymmetryFunctionDerivatives, numSymmetryFunctions, and useChargeNeuron.

Referenced by nnp::Mode::calculateSymmetryFunctionGroups(), and nnp::Mode::calculateSymmetryFunctions().

Here is the caller graph for this function:

free()

void Atom::free

(

bool

all

)

Free vectors related to symmetry functions, opposite of allocate().

Parameters

[in]

all

If true free all vectors (G, dEdG, dGdr, #dGdxia and Neighbor::dGdr) otherwise free only dEdG, dGdr, #dGdxia and Neighbor::dGdr.

Definition at line 221 of file Atom.cpp.

{
    if (all)
    {
        G.clear();
        vector<double>(G).swap(G);
        hasSymmetryFunctions = false;
#ifndef N2P2_NO_SF_CACHE
        for (vector<Neighbor>::iterator it = neighbors.begin();
             it != neighbors.end(); ++it)
        {
            it->cache.clear();
            vector<double>(it->cache).swap(it->cache);
        }
#endif
    }
 
    dEdG.clear();
    vector<double>(dEdG).swap(dEdG);
    dQdG.clear();
    vector<double>(dQdG).swap(dQdG);
#ifdef N2P2_FULL_SFD_MEMORY
    dGdxia.clear();
    vector<double>(dGdxia).swap(dGdxia);
#endif
    dGdr.clear();
    vector<Vec3D>(dGdr).swap(dGdr);
    for (vector<Neighbor>::iterator it = neighbors.begin();
         it != neighbors.end(); ++it)
    {
        it->dGdr.clear();
        vector<Vec3D>(it->dGdr).swap(it->dGdr);
    }
    hasSymmetryFunctionDerivatives = false;
 
    return;
}

References dEdG, dGdr, dQdG, G, hasSymmetryFunctionDerivatives, hasSymmetryFunctions, and neighbors.

clearNeighborList() [1/2]

void Atom::clearNeighborList

(

)

Clear neighbor list.

Note

Also clears symmetry function data.

Definition at line 259 of file Atom.cpp.

{
    clearNeighborList(numNeighborsPerElement.size());
 
    return;
}

References clearNeighborList(), and numNeighborsPerElement.

Referenced by clearNeighborList(), and nnp::Structure::clearNeighborList().

Here is the call graph for this function:

Here is the caller graph for this function:

clearNeighborList() [2/2]

void nnp::Atom::clearNeighborList

(

std::size_t const

numElements

)

Clear neighbor list and change number of elements.

Parameters

[in]

numElements

Number of elements present.

Note

Also clears symmetry function data. The number of elements is necessary to allocate the numNeighborsPerElement vector. Use the overloaded version clearNeighborList() if the number of elements stays the same.

getNumNeighbors()

size_t Atom::getNumNeighbors

(

double

cutoffRadius

)

const

Calculate number of neighbors for a given cutoff radius.

Parameters

[in]

cutoffRadius

Desired cutoff radius.

This function assumes that the neighbor list has already been calculated for a large cutoff radius and now the number of neighbor atoms for a smaller cutoff is requested.

Definition at line 281 of file Atom.cpp.

{
    size_t numNeighborsLocal = 0;
 
    for (vector<Neighbor>::const_iterator it = neighbors.begin();
         it != neighbors.end(); ++it)
    {
        if (it->d <= cutoffRadius)
        {
            numNeighborsLocal++;
        }
    }
 
    return numNeighborsLocal;
}

References neighbors.

Referenced by nnp::Mode::calculateSymmetryFunctionGroups(), and nnp::Mode::calculateSymmetryFunctions().

Here is the caller graph for this function:

updateError()

void Atom::updateError	(	std::string const &	property,
		std::map< std::string, double > &	error,
		std::size_t &	count
	)		const

Update property error metrics with data from this atom.

Parameters

[in]	property	One of "force" or "charge".
[in,out]	error	Input error metric map to be updated.
[in,out]	count	Input counter to be updated.

Definition at line 297 of file Atom.cpp.

{
    if (property == "force")
    {
        count += 3;
        error.at("RMSE") += (fRef - f).norm2();
        error.at("MAE") += (fRef - f).l1norm();
    }
    else if (property == "charge")
    {
        count++;
        error.at("RMSE") += (chargeRef - charge) * (chargeRef - charge);
        error.at("MAE") += fabs(chargeRef - charge);
    }
    else
    {
        throw runtime_error("ERROR: Unknown property for error update.\n");
    }
 
    return;
}

References charge, chargeRef, f, and fRef.

getForcesLines()

vector< string > Atom::getForcesLines

(

)

const

Get reference and NN forces for this atoms.

Returns

Vector of strings with indexStructure, index, fRef, f values.

Definition at line 321 of file Atom.cpp.

{
    vector<string> v;
    for (size_t i = 0; i < 3; ++i)
    {
        v.push_back(strpr("%10zu %10zu %16.8E %16.8E\n",
                          indexStructure,
                          index,
                          fRef[i],
                          f[i]));
    }
 
    return v;
}

References f, fRef, index, indexStructure, and nnp::strpr().

Here is the call graph for this function:

getChargeLine()

string Atom::getChargeLine

(

)

const

Get reference and NN charge for this atoms.

Returns

Line with indexStructure, index, chargeRef, charge values.

Definition at line 336 of file Atom.cpp.

{
    return strpr("%10zu %10zu %16.8E %16.8E\n",
                 indexStructure,
                 index,
                 chargeRef,
                 charge);
}

References charge, chargeRef, index, indexStructure, and nnp::strpr().

Here is the call graph for this function:

info()

vector< string > Atom::info

(

)

const

Get atom information as a vector of strings.

Returns

Lines with atom information.

Definition at line 345 of file Atom.cpp.

{
    vector<string> v;
 
    v.push_back(strpr("********************************\n"));
    v.push_back(strpr("ATOM                            \n"));
    v.push_back(strpr("********************************\n"));
    v.push_back(strpr("hasNeighborList                : %d\n", hasNeighborList));
    v.push_back(strpr("hasSymmetryFunctions           : %d\n", hasSymmetryFunctions));
    v.push_back(strpr("hasSymmetryFunctionDerivatives : %d\n", hasSymmetryFunctionDerivatives));
    v.push_back(strpr("useChargeNeuron                : %d\n", useChargeNeuron));
    v.push_back(strpr("index                          : %d\n", index));
    v.push_back(strpr("indexStructure                 : %d\n", indexStructure));
    v.push_back(strpr("tag                            : %" PRId64 "\n", tag));
    v.push_back(strpr("element                        : %d\n", element));
    v.push_back(strpr("numNeighbors                   : %d\n", numNeighbors));
    v.push_back(strpr("numNeighborsUnique             : %d\n", numNeighborsUnique));
    v.push_back(strpr("numSymmetryFunctions           : %d\n", numSymmetryFunctions));
    v.push_back(strpr("energy                         : %16.8E\n", energy));
    v.push_back(strpr("charge                         : %16.8E\n", charge));
    v.push_back(strpr("chargeRef                      : %16.8E\n", chargeRef));
    v.push_back(strpr("r                              : %16.8E %16.8E %16.8E\n", r[0], r[1], r[2]));
    v.push_back(strpr("f                              : %16.8E %16.8E %16.8E\n", f[0], f[1], f[2]));
    v.push_back(strpr("fRef                           : %16.8E %16.8E %16.8E\n", fRef[0], fRef[1], fRef[2]));
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("neighborsUnique            [*] : %d\n", neighborsUnique.size()));
    v.push_back(strpr("--------------------------------\n"));
    for (size_t i = 0; i < neighborsUnique.size(); ++i)
    {
        v.push_back(strpr("%29d  : %d\n", i, neighborsUnique.at(i)));
    }
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("numNeighborsPerElement     [*] : %d\n", numNeighborsPerElement.size()));
    v.push_back(strpr("--------------------------------\n"));
    for (size_t i = 0; i < numNeighborsPerElement.size(); ++i)
    {
        v.push_back(strpr("%29d  : %d\n", i, numNeighborsPerElement.at(i)));
    }
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("numSymmetryFunctionDeriv.  [*] : %d\n", numSymmetryFunctionDerivatives.size()));
    v.push_back(strpr("--------------------------------\n"));
    for (size_t i = 0; i < numSymmetryFunctionDerivatives.size(); ++i)
    {
        v.push_back(strpr("%29d  : %d\n", i, numSymmetryFunctionDerivatives.at(i)));
    }
#ifndef N2P2_NO_SF_CACHE
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("cacheSizePerElement        [*] : %d\n", cacheSizePerElement.size()));
    v.push_back(strpr("--------------------------------\n"));
    for (size_t i = 0; i < cacheSizePerElement.size(); ++i)
    {
        v.push_back(strpr("%29d  : %d\n", i, cacheSizePerElement.at(i)));
    }
#endif
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("G                          [*] : %d\n", G.size()));
    v.push_back(strpr("--------------------------------\n"));
    for (size_t i = 0; i < G.size(); ++i)
    {
        v.push_back(strpr("%29d  : %16.8E\n", i, G.at(i)));
    }
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("dEdG                       [*] : %d\n", dEdG.size()));
    v.push_back(strpr("--------------------------------\n"));
    for (size_t i = 0; i < dEdG.size(); ++i)
    {
        v.push_back(strpr("%29d  : %16.8E\n", i, dEdG.at(i)));
    }
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("dQdG                       [*] : %d\n", dQdG.size()));
    v.push_back(strpr("--------------------------------\n"));
    for (size_t i = 0; i < dQdG.size(); ++i)
    {
        v.push_back(strpr("%29d  : %16.8E\n", i, dQdG.at(i)));
    }
    v.push_back(strpr("--------------------------------\n"));
#ifdef N2P2_FULL_SFD_MEMORY
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("dGdxia                     [*] : %d\n", dGdxia.size()));
    v.push_back(strpr("--------------------------------\n"));
    for (size_t i = 0; i < dGdxia.size(); ++i)
    {
        v.push_back(strpr("%29d  : %16.8E\n", i, dGdxia.at(i)));
    }
    v.push_back(strpr("--------------------------------\n"));
#endif
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("dGdr                       [*] : %d\n", dGdr.size()));
    v.push_back(strpr("--------------------------------\n"));
    for (size_t i = 0; i < dGdr.size(); ++i)
    {
        v.push_back(strpr("%29d  : %16.8E %16.8E %16.8E\n", i, dGdr.at(i)[0], dGdr.at(i)[1], dGdr.at(i)[2]));
    }
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("neighbors                  [*] : %d\n", neighbors.size()));
    v.push_back(strpr("--------------------------------\n"));
    for (size_t i = 0; i < neighbors.size(); ++i)
    {
        v.push_back(strpr("%29d  :\n", i));
        vector<string> vn = neighbors[i].info();
        v.insert(v.end(), vn.begin(), vn.end());
    }
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("********************************\n"));
 
    return v;
}

References cacheSizePerElement, charge, chargeRef, dEdG, dGdr, dQdG, element, energy, f, fRef, G, hasNeighborList, hasSymmetryFunctionDerivatives, hasSymmetryFunctions, index, indexStructure, neighbors, neighborsUnique, numNeighbors, numNeighborsPerElement, numNeighborsUnique, numSymmetryFunctionDerivatives, numSymmetryFunctions, r, nnp::strpr(), tag, and useChargeNeuron.

Here is the call graph for this function:

Member Data Documentation

hasNeighborList

bool nnp::Atom::hasNeighborList

If the neighbor list has been calculated for this atom.

Definition at line 90 of file Atom.h.

Referenced by info(), toNormalizedUnits(), and toPhysicalUnits().

hasSymmetryFunctions

bool nnp::Atom::hasSymmetryFunctions

If symmetry function values are saved for this atom.

Definition at line 92 of file Atom.h.

Referenced by allocate(), nnp::Mode::calculateSymmetryFunctionGroups(), nnp::Mode::calculateSymmetryFunctions(), free(), info(), and nnp::InterfaceLammps::setLocalAtoms().

hasSymmetryFunctionDerivatives

bool nnp::Atom::hasSymmetryFunctionDerivatives

If symmetry function derivatives are saved for this atom.

Definition at line 94 of file Atom.h.

Referenced by allocate(), nnp::Mode::calculateSymmetryFunctionGroups(), nnp::Mode::calculateSymmetryFunctions(), free(), info(), nnp::InterfaceLammps::setLocalAtoms(), toNormalizedUnits(), and toPhysicalUnits().

useChargeNeuron

bool nnp::Atom::useChargeNeuron

If an additional charge neuron in the short-range NN is present.

Definition at line 96 of file Atom.h.

Referenced by allocate(), nnp::Mode::calculateSymmetryFunctionGroups(), nnp::Mode::calculateSymmetryFunctions(), info(), toNormalizedUnits(), and toPhysicalUnits().

index

std::size_t nnp::Atom::index

Index number of this atom.

Definition at line 98 of file Atom.h.

Referenced by nnp::Mode::calculateForces(), nnp::Mode::calculateSymmetryFunctionGroups(), nnp::Mode::calculateSymmetryFunctions(), nnp::Training::collectDGdxia(), getChargeLine(), nnp::InterfaceLammps::getForces(), getForcesLines(), nnp::Atom::Neighbor::info(), info(), and nnp::InterfaceLammps::setLocalAtoms().

indexStructure

std::size_t nnp::Atom::indexStructure

Index number of structure this atom belongs to.

Definition at line 100 of file Atom.h.

Referenced by nnp::Mode::calculateSymmetryFunctionGroups(), nnp::Mode::calculateSymmetryFunctions(), getChargeLine(), getForcesLines(), info(), nnp::InterfaceLammps::setLocalAtoms(), and nnp::Element::updateSymmetryFunctionStatistics().

tag

int64_t nnp::Atom::tag

Tag number of this atom.

Definition at line 102 of file Atom.h.

Referenced by nnp::Atom::Neighbor::info(), info(), and nnp::Element::updateSymmetryFunctionStatistics().

element

std::size_t nnp::Atom::element

Element index of this atom.

Definition at line 104 of file Atom.h.

Referenced by nnp::Mode::calculateForces(), nnp::Mode::calculateSymmetryFunctionGroups(), nnp::Mode::calculateSymmetryFunctions(), nnp::Training::collectDGdxia(), nnp::InterfaceLammps::getAtomicEnergy(), nnp::InterfaceLammps::getForces(), nnp::Atom::Neighbor::info(), info(), nnp::Atom::Neighbor::operator<(), nnp::Atom::Neighbor::operator==(), nnp::InterfaceLammps::setLocalAtoms(), nnp::Training::update(), and nnp::Element::updateSymmetryFunctionStatistics().

numNeighbors

std::size_t nnp::Atom::numNeighbors

Total number of neighbors.

Definition at line 106 of file Atom.h.

Referenced by nnp::InterfaceLammps::addNeighbor(), nnp::SymFncCompAngn::calculate(), nnp::SymFncCompAngnWeighted::calculate(), nnp::SymFncCompAngw::calculate(), nnp::SymFncCompAngwWeighted::calculate(), nnp::SymFncCompRad::calculate(), nnp::SymFncCompRadWeighted::calculate(), nnp::SymFncExpAngn::calculate(), nnp::SymFncExpAngnWeighted::calculate(), nnp::SymFncExpAngw::calculate(), nnp::SymFncExpRad::calculate(), nnp::SymFncExpRadWeighted::calculate(), nnp::SymGrpCompAngn::calculate(), nnp::SymGrpCompAngnWeighted::calculate(), nnp::SymGrpCompAngw::calculate(), nnp::SymGrpCompAngwWeighted::calculate(), nnp::SymGrpCompRad::calculate(), nnp::SymGrpCompRadWeighted::calculate(), nnp::SymGrpExpAngn::calculate(), nnp::SymGrpExpAngnWeighted::calculate(), nnp::SymGrpExpAngw::calculate(), nnp::SymGrpExpRad::calculate(), nnp::SymGrpExpRadWeighted::calculate(), nnp::Training::collectDGdxia(), info(), nnp::InterfaceLammps::setLocalAtoms(), and nnp::Training::update().

numNeighborsUnique

std::size_t nnp::Atom::numNeighborsUnique

Number of unique neighbor indices (don't count multiple PBC images).

Definition at line 108 of file Atom.h.

Referenced by info().

numSymmetryFunctions

std::size_t nnp::Atom::numSymmetryFunctions

Number of symmetry functions used to describe the atom environment.

Definition at line 110 of file Atom.h.

Referenced by allocate(), nnp::Mode::calculateForces(), nnp::Mode::calculateSymmetryFunctionGroups(), nnp::Mode::calculateSymmetryFunctions(), nnp::Training::collectDGdxia(), nnp::InterfaceLammps::getForces(), info(), toNormalizedUnits(), toPhysicalUnits(), and nnp::Element::updateSymmetryFunctionStatistics().

energy

double nnp::Atom::energy

Atomic energy determined by neural network.

Definition at line 112 of file Atom.h.

Referenced by nnp::InterfaceLammps::getAtomicEnergy(), info(), toNormalizedUnits(), and toPhysicalUnits().

charge

double nnp::Atom::charge

Atomic charge determined by neural network.

Definition at line 114 of file Atom.h.

Referenced by getChargeLine(), info(), nnp::Training::sortUpdateCandidates(), nnp::Training::update(), and updateError().

chargeRef

double nnp::Atom::chargeRef

Atomic reference charge.

Definition at line 116 of file Atom.h.

Referenced by getChargeLine(), info(), nnp::Training::sortUpdateCandidates(), nnp::Training::update(), and updateError().

r

Vec3D nnp::Atom::r

Cartesian coordinates.

Definition at line 118 of file Atom.h.

Referenced by info(), nnp::Structure::remap(), toNormalizedUnits(), and toPhysicalUnits().

f

Vec3D nnp::Atom::f

Force vector calculated by neural network.

Definition at line 120 of file Atom.h.

Referenced by nnp::Mode::calculateForces(), getForcesLines(), info(), main(), nnp::Training::sortUpdateCandidates(), toNormalizedUnits(), toPhysicalUnits(), nnp::Training::update(), and updateError().

fRef

Vec3D nnp::Atom::fRef

Reference force vector from data set.

Definition at line 122 of file Atom.h.

Referenced by getForcesLines(), info(), main(), nnp::Training::sortUpdateCandidates(), toNormalizedUnits(), toPhysicalUnits(), nnp::Training::update(), and updateError().

neighborsUnique

std::vector<std::size_t> nnp::Atom::neighborsUnique

List of unique neighbor indices (don't count multiple PBC images).

Definition at line 124 of file Atom.h.

Referenced by nnp::Mode::calculateForces(), and info().

numNeighborsPerElement

std::vector<std::size_t> nnp::Atom::numNeighborsPerElement

Number of neighbors per element.

Definition at line 126 of file Atom.h.

Referenced by nnp::InterfaceLammps::addNeighbor(), clearNeighborList(), nnp::Structure::clearNeighborList(), info(), nnp::InterfaceLammps::setLocalAtoms(), and nnp::Training::update().

numSymmetryFunctionDerivatives

std::vector<std::size_t> nnp::Atom::numSymmetryFunctionDerivatives

Number of neighbor atom symmetry function derivatives per element.

Definition at line 128 of file Atom.h.

Referenced by allocate(), nnp::Mode::calculateSymmetryFunctionGroups(), nnp::Mode::calculateSymmetryFunctions(), and info().

cacheSizePerElement

std::vector<std::size_t> nnp::Atom::cacheSizePerElement

Cache size for each element.

Definition at line 131 of file Atom.h.

Referenced by allocate(), nnp::Mode::calculateSymmetryFunctionGroups(), nnp::Mode::calculateSymmetryFunctions(), and info().

G

std::vector<double> nnp::Atom::G

Symmetry function values.

Definition at line 134 of file Atom.h.

Referenced by allocate(), nnp::SymFncCompAngn::calculate(), nnp::SymFncCompAngnWeighted::calculate(), nnp::SymFncCompAngw::calculate(), nnp::SymFncCompAngwWeighted::calculate(), nnp::SymFncCompRad::calculate(), nnp::SymFncCompRadWeighted::calculate(), nnp::SymFncExpAngn::calculate(), nnp::SymFncExpAngnWeighted::calculate(), nnp::SymFncExpAngw::calculate(), nnp::SymFncExpRad::calculate(), nnp::SymFncExpRadWeighted::calculate(), nnp::SymGrpCompAngn::calculate(), nnp::SymGrpCompAngnWeighted::calculate(), nnp::SymGrpCompAngw::calculate(), nnp::SymGrpCompAngwWeighted::calculate(), nnp::SymGrpCompRad::calculate(), nnp::SymGrpCompRadWeighted::calculate(), nnp::SymGrpExpAngn::calculate(), nnp::SymGrpExpAngnWeighted::calculate(), nnp::SymGrpExpAngw::calculate(), nnp::SymGrpExpRad::calculate(), nnp::SymGrpExpRadWeighted::calculate(), free(), info(), nnp::Training::update(), nnp::Element::updateSymmetryFunctionStatistics(), and nnp::Dataset::writeAtomicEnvironmentFile().

dEdG

std::vector<double> nnp::Atom::dEdG

Derivative of atomic energy with respect to symmetry functions.

Definition at line 136 of file Atom.h.

Referenced by allocate(), nnp::Mode::calculateForces(), free(), nnp::InterfaceLammps::getForces(), info(), toNormalizedUnits(), and toPhysicalUnits().

dQdG

std::vector<double> nnp::Atom::dQdG

Derivative of atomic charge with respect to symmetry functions.

Definition at line 138 of file Atom.h.

Referenced by allocate(), free(), and info().

dGdr

std::vector<Vec3D> nnp::Atom::dGdr

Derivative of symmetry functions with respect to this atom's coordinates.

Definition at line 146 of file Atom.h.

Referenced by allocate(), nnp::SymFncCompAngn::calculate(), nnp::SymFncCompAngnWeighted::calculate(), nnp::SymFncCompAngw::calculate(), nnp::SymFncCompAngwWeighted::calculate(), nnp::SymFncCompRad::calculate(), nnp::SymFncCompRadWeighted::calculate(), nnp::SymFncExpAngn::calculate(), nnp::SymFncExpAngnWeighted::calculate(), nnp::SymFncExpAngw::calculate(), nnp::SymFncExpRad::calculate(), nnp::SymFncExpRadWeighted::calculate(), nnp::SymGrpCompAngn::calculate(), nnp::SymGrpCompAngnWeighted::calculate(), nnp::SymGrpCompAngw::calculate(), nnp::SymGrpCompAngwWeighted::calculate(), nnp::SymGrpCompRad::calculate(), nnp::SymGrpCompRadWeighted::calculate(), nnp::SymGrpExpAngn::calculate(), nnp::SymGrpExpAngnWeighted::calculate(), nnp::SymGrpExpAngw::calculate(), nnp::SymGrpExpRad::calculate(), nnp::SymGrpExpRadWeighted::calculate(), nnp::Mode::calculateForces(), nnp::Training::collectDGdxia(), free(), nnp::InterfaceLammps::getForces(), nnp::Atom::Neighbor::info(), info(), toNormalizedUnits(), and toPhysicalUnits().

neighbors

std::vector<Neighbor> nnp::Atom::neighbors

Neighbor array (maximum number defined in macros.h.

Definition at line 148 of file Atom.h.

Referenced by nnp::InterfaceLammps::addNeighbor(), allocate(), nnp::SymFncCompAngn::calculate(), nnp::SymFncCompAngnWeighted::calculate(), nnp::SymFncCompAngw::calculate(), nnp::SymFncCompAngwWeighted::calculate(), nnp::SymFncCompRad::calculate(), nnp::SymFncCompRadWeighted::calculate(), nnp::SymFncExpAngn::calculate(), nnp::SymFncExpAngnWeighted::calculate(), nnp::SymFncExpAngw::calculate(), nnp::SymFncExpRad::calculate(), nnp::SymFncExpRadWeighted::calculate(), nnp::SymGrpCompAngn::calculate(), nnp::SymGrpCompAngnWeighted::calculate(), nnp::SymGrpCompAngw::calculate(), nnp::SymGrpCompAngwWeighted::calculate(), nnp::SymGrpCompRad::calculate(), nnp::SymGrpCompRadWeighted::calculate(), nnp::SymGrpExpAngn::calculate(), nnp::SymGrpExpAngnWeighted::calculate(), nnp::SymGrpExpAngw::calculate(), nnp::SymGrpExpRad::calculate(), nnp::SymGrpExpRadWeighted::calculate(), nnp::Mode::calculateForces(), nnp::Training::collectDGdxia(), free(), nnp::InterfaceLammps::getForces(), getNumNeighbors(), info(), nnp::InterfaceLammps::setLocalAtoms(), toNormalizedUnits(), toPhysicalUnits(), and nnp::Dataset::writeAtomicEnvironmentFile().

---

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

• /home/runner/work/n2p2/n2p2/src/libnnp/Atom.h
• /home/runner/work/n2p2/n2p2/src/libnnp/Atom.cpp