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, double convCharge)
	Switch to normalized length, energy and charge units. More...
void	toPhysicalUnits (double convEnergy, double convLength, double convCharge)
	Switch to physical length, energy and charge units. More...
void	allocate (bool all, double const maxCutoffRadius=0.0)
	Allocate vectors related to symmetry functions (G, dEdG). More...
void	free (bool all, double const maxCutoffRadius=0.0)
	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	calculateNumNeighbors (double const cutoffRadius) const
	Calculate number of neighbors for a given cutoff radius. More...
std::size_t	getStoredMinNumNeighbors (double const cutoffRadius) const
	Return needed number of neighbors for a given cutoff radius from neighborCutoffs map. More...
bool	isNeighbor (std::size_t index) const
	Return whether atom is a neighbor. 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...
Vec3D	calculateSelfForceShort () const
	Calculate force resulting from gradient of this atom's (short-ranged) energy contribution with respect to this atom's coordinate. More...
Vec3D	calculatePairForceShort (Neighbor const &neighbor, std::vector< std::vector< std::size_t > > const *const tableFull=nullptr) const
	Calculate force resulting from gradient of this atom's (short-ranged) energy contribution with respect to neighbor's coordinate. More...
Vec3D	calculateDChidr (size_t const atomIndexOfR, double const maxCutoffRadius, std::vector< std::vector< size_t > > const *const tableFull=nullptr) const
	Calculate dChi/dr of this atom's Chi with respect to the coordinates of the given 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	NeighborListIsSorted
	If the neighbor list is sorted by distance. 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	dEelecdQ
	Derivative of electrostatic energy with respect to this atom's charge. More...
double	chi
	Atomic electronegativity 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	fElec
	Force vector resulting from electrostatics. More...
Vec3D	fRef
	Reference force vector from data set. More...
Vec3D	pEelecpr
	Partial derivative of electrostatic energy with respect to this atom's coordinates. 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< double >	dChidG
	Derivative of electronegativity with respect to symmetry functions. More...
std::vector< Vec3D >	dGdr
	Derivative of symmetry functions with respect to this atom's coordinates. More...
std::vector< Vec3D >	dQdr
	Derivative of charges with respect to this atom's coordinates. More...
std::vector< Vec3D >	dAdrQ
	If dQdr has been calculated for respective components. More...
std::vector< Neighbor >	neighbors
	Neighbor array (maximum number defined in macros.h. More...
std::unordered_map< double, size_t >	neighborCutoffs
	Map stores number of neighbors needed for the corresponding cut-off. More...

Detailed Description

Storage for a single atom.

Definition at line 32 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),
               NeighborListIsSorted          (false),
               hasSymmetryFunctions          (false),
               hasSymmetryFunctionDerivatives(false),
               useChargeNeuron               (false),
               index                         (0    ),
               indexStructure                (0    ),
               tag                           (0    ),
               element                       (0    ),
               numNeighbors                  (0    ),
               numNeighborsUnique            (0    ),
               numSymmetryFunctions          (0    ),
               energy                        (0.0  ),
               dEelecdQ                      (0.0  ),
               chi                           (0.0  ),
               charge                        (0.0  ),
               chargeRef                     (0.0  )
{
}

Member Function Documentation

toNormalizedUnits()

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

Switch to normalized length, energy and charge units.

Parameters

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

Definition at line 78 of file Atom.cpp.

{
    energy *= convEnergy;
    r *= convLength;
    f *= convEnergy / convLength;
    fRef *= convEnergy / convLength;
    charge *= convCharge;
    chargeRef *= convCharge;
    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 / convCharge;
    }
 
    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 charge, chargeRef, dEdG, dGdr, energy, f, fRef, hasNeighborList, hasSymmetryFunctionDerivatives, neighbors, numSymmetryFunctions, r, and useChargeNeuron.

toPhysicalUnits()

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

Switch to physical length, energy and charge units.

Parameters

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

Definition at line 123 of file Atom.cpp.

{
    energy /= convEnergy;
    r /= convLength;
    f /= convEnergy / convLength;
    fRef /= convEnergy / convLength;
    charge /= convCharge;
    chargeRef /= convCharge;
    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 / convCharge;
    }
 
    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 charge, chargeRef, dEdG, dGdr, energy, f, fRef, hasNeighborList, hasSymmetryFunctionDerivatives, neighbors, numSymmetryFunctions, r, and useChargeNeuron.

allocate()

void Atom::allocate	(	bool	all,
		double const	maxCutoffRadius = 0.0
	)

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.
[in]	maxCutoffRadius	Maximum cutoff radius of symmetry functions.

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

Definition at line 168 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();
    dChidG.clear();
#ifdef N2P2_FULL_SFD_MEMORY
    dGdxia.clear();
#endif
    dGdr.clear();
 
    // Don't need any allocation of neighbors outside the symmetry function
    // cutoff.
    size_t const numSymFuncNeighbors = getStoredMinNumNeighbors(maxCutoffRadius);
    for (size_t i = 0; i < numSymFuncNeighbors; ++i)
    {
        Neighbor& n = neighbors.at(i);
#ifndef N2P2_NO_SF_CACHE
        n.cache.clear();
#endif
        n.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);
        dChidG.resize(numSymmetryFunctions,0.0);
#ifdef N2P2_FULL_SFD_MEMORY
        dGdxia.resize(numSymmetryFunctions, 0.0);
#endif
        dGdr.resize(numSymmetryFunctions);
    }
    for (size_t i = 0; i < numSymFuncNeighbors; ++i)
    {
        Neighbor& n = neighbors.at(i);
#ifndef N2P2_NO_SF_CACHE
        n.cache.resize(cacheSizePerElement.at(n.element),
                         -numeric_limits<double>::max());
#endif
        if (all)
        {
#ifndef N2P2_FULL_SFD_MEMORY
            n.dGdr.resize(numSymmetryFunctionDerivatives.at(n.element));
#else
            n.dGdr.resize(numSymmetryFunctions);
#endif
        }
    }
 
    return;
}

References nnp::Atom::Neighbor::cache, cacheSizePerElement, dChidG, dEdG, nnp::Atom::Neighbor::dGdr, dGdr, dQdG, nnp::Atom::Neighbor::element, G, getStoredMinNumNeighbors(), hasSymmetryFunctionDerivatives, hasSymmetryFunctions, neighbors, numSymmetryFunctionDerivatives, numSymmetryFunctions, and useChargeNeuron.

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

Here is the call graph for this function:

Here is the caller graph for this function:

free()

void Atom::free	(	bool	all,
		double const	maxCutoffRadius = 0.0
	)

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.
[in]	maxCutoffRadius	Maximum cutoff radius of symmetry functions.

Definition at line 242 of file Atom.cpp.

{
    size_t const numSymFuncNeighbors = getStoredMinNumNeighbors(maxCutoffRadius);
    if (all)
    {
        G.clear();
        vector<double>(G).swap(G);
        hasSymmetryFunctions = false;
 
#ifndef N2P2_NO_SF_CACHE
        for (size_t i = 0; i < numSymFuncNeighbors; ++i)
        {
            Neighbor& n = neighbors.at(i);
            n.cache.clear();
            vector<double>(n.cache).swap(n.cache);
        }
#endif
    }
 
    dEdG.clear();
    vector<double>(dEdG).swap(dEdG);
    dQdG.clear();
    vector<double>(dQdG).swap(dQdG);
    dChidG.clear();
    vector<double>(dChidG).swap(dChidG);
#ifdef N2P2_FULL_SFD_MEMORY
    dGdxia.clear();
    vector<double>(dGdxia).swap(dGdxia);
#endif
    dGdr.clear();
    vector<Vec3D>(dGdr).swap(dGdr);
 
    for (size_t i = 0; i < numSymFuncNeighbors; ++i)
    {
        Neighbor& n = neighbors.at(i);
        n.dGdr.clear();
        vector<Vec3D>(n.dGdr).swap(n.dGdr);
    }
    hasSymmetryFunctionDerivatives = false;
 
    return;
}

References nnp::Atom::Neighbor::cache, dChidG, dEdG, nnp::Atom::Neighbor::dGdr, dGdr, dQdG, G, getStoredMinNumNeighbors(), hasSymmetryFunctionDerivatives, hasSymmetryFunctions, and neighbors.

Here is the call graph for this function:

clearNeighborList() [1/2]

void Atom::clearNeighborList

(

)

Clear neighbor list.

Note

Also clears symmetry function data.

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

calculateNumNeighbors()

size_t Atom::calculateNumNeighbors

(

double const

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 307 of file Atom.cpp.

{
    // neighborCutoffs map is only constructed when the neighbor list is sorted.
    if (unorderedMapContainsKey(neighborCutoffs, cutoffRadius))
        return neighborCutoffs.at(cutoffRadius);
    else
    {
        size_t numNeighborsLocal = 0;
 
        for (vector<Neighbor>::const_iterator it = neighbors.begin();
             it != neighbors.end(); ++it)
        {
            if (it->d <= cutoffRadius)
            {
                numNeighborsLocal++;
            }
        }
 
        return numNeighborsLocal;
    }
}

References neighborCutoffs, neighbors, and nnp::unorderedMapContainsKey().

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

Here is the call graph for this function:

Here is the caller graph for this function:

getStoredMinNumNeighbors()

size_t Atom::getStoredMinNumNeighbors

(

double const

cutoffRadius

)

const

Return needed number of neighbors for a given cutoff radius from neighborCutoffs map.

If it isn't setup, return number of all neighbors in list.

Parameters

[in]

cutoffRadius

Desired cutoff radius.

Returns

Integer with the number of neighbors corresponding to the cutoff radius.

Definition at line 329 of file Atom.cpp.

{
     // neighborCutoffs map is only constructed when the neighbor list is sorted.
    if (unorderedMapContainsKey(neighborCutoffs, cutoffRadius))
        return neighborCutoffs.at(cutoffRadius);
    else
    {
        return numNeighbors;
    }
}

References neighborCutoffs, numNeighbors, and nnp::unorderedMapContainsKey().

Referenced by allocate(), nnp::SymFncExpAngn::calculate(), nnp::SymFncExpRad::calculate(), nnp::SymGrpExpAngn::calculate(), nnp::SymGrpExpRad::calculate(), nnp::Structure::calculateDAdrQ(), calculateDChidr(), nnp::Structure::calculateElectrostaticEnergy(), nnp::Mode::calculateForces(), nnp::Structure::calculateScreeningEnergy(), and free().

Here is the call graph for this function:

Here is the caller graph for this function:

isNeighbor()

bool Atom::isNeighbor

(

std::size_t

index

)

const

Return whether atom is a neighbor.

Parameters

[in]

index

Index of atom in question.

Returns

True if atom is neighbor of this atom.

Definition at line 340 of file Atom.cpp.

{
    for (auto const& n : neighbors) if (n.index == index) return true;
 
    return false;
}

References index, and neighbors.

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

calculateSelfForceShort()

Vec3D Atom::calculateSelfForceShort

(

)

const

Calculate force resulting from gradient of this atom's (short-ranged) energy contribution with respect to this atom's coordinate.

Returns

calculated force vector.

Definition at line 371 of file Atom.cpp.

{
    Vec3D selfForce{};
    for (size_t i = 0; i < numSymmetryFunctions; ++i)
    {
        selfForce -= dEdG.at(i) * dGdr.at(i);
    }
    return selfForce;
}

References dEdG, dGdr, and numSymmetryFunctions.

Referenced by nnp::Mode::calculateForces().

Here is the caller graph for this function:

calculatePairForceShort()

Vec3D Atom::calculatePairForceShort	(	Neighbor const &	neighbor,
		std::vector< std::vector< std::size_t > > const *const	tableFull = nullptr
	)		const

Calculate force resulting from gradient of this atom's (short-ranged) energy contribution with respect to neighbor's coordinate.

Parameters

[in]	neighbor	Neighbor of which the gradient is considered.
[in]	tableFull	Pointer to ymmetry function table if it is used.

Returns

calculated force vector.

Definition at line 381 of file Atom.cpp.

{
    Vec3D pairForce{};
#ifndef NNP_FULL_SFD_MEMORY
    if (!tableFull) throw runtime_error(
                "ERROR: tableFull must not be null pointer");
    vector<size_t> const& table = tableFull->at(neighbor.element);
    for (size_t i = 0; i < neighbor.dGdr.size(); ++i)
    {
        pairForce -= dEdG.at(table.at(i)) * neighbor.dGdr.at(i);
    }
#else
    for (size_t i = 0; i < numSymmetryFunctions; ++i)
    {
        pairForce -= dEdG.at(i) * neighbor.dGdr.at(i);
    }
#endif
    return pairForce;
}

References dEdG, nnp::Atom::Neighbor::dGdr, nnp::Atom::Neighbor::element, and numSymmetryFunctions.

Referenced by nnp::Mode::calculateForces().

Here is the caller graph for this function:

calculateDChidr()

Vec3D Atom::calculateDChidr	(	size_t const	atomIndexOfR,
		double const	maxCutoffRadius,
		std::vector< std::vector< size_t > > const *const	tableFull = nullptr
	)		const

Calculate dChi/dr of this atom's Chi with respect to the coordinates of the given atom.

Parameters

[in]	atomIndexOfR	Index of the atom corresponding to the coordinates r.
[in]	maxCutoffRadius	Largest cut-off of the symmetry functions.
[in]	tableFull	Pointer to symmetry function table if it is used.

Returns

3D Vector containing the derivative dChi/dr.

Definition at line 403 of file Atom.cpp.

{
#ifndef NNP_FULL_SFD_MEMORY
    if (!tableFull) throw runtime_error(
                "ERROR: tableFull must not be null pointer");
#endif
    Vec3D dChidr{};
    // need to add this case because the loop over the neighbors
    // does not include the contribution dChi_i/dr_i.
    if (atomIndexOfR == index)
    {
        for (size_t k = 0; k < numSymmetryFunctions; ++k)
        {
            dChidr += dChidG.at(k) * dGdr.at(k);
        }
    }
 
    size_t numNeighbors = getStoredMinNumNeighbors(maxCutoffRadius);
    for (size_t m = 0; m < numNeighbors; ++m)
    {
        Atom::Neighbor const& n = neighbors.at(m);
    // atomIndexOfR must not be larger than ~max(int64_t)/2.
        if (n.tag == (int64_t)atomIndexOfR)
        {
#ifndef NNP_FULL_SFD_MEMORY
            vector<size_t> const& table = tableFull->at(n.element);
            for (size_t k = 0; k < n.dGdr.size(); ++k)
            {
                dChidr += dChidG.at(table.at(k)) * n.dGdr.at(k);
            }
#else
            for (size_t k = 0; k < numSymmetryFunctions; ++k)
            {
                dChidr += dChidG.at(k) * n.dGdr.at(k);
            }
#endif
        }
    }
    return dChidr;
}

References dChidG, nnp::Atom::Neighbor::dGdr, dGdr, nnp::Atom::Neighbor::element, getStoredMinNumNeighbors(), index, neighbors, numNeighbors, numSymmetryFunctions, and nnp::Atom::Neighbor::tag.

Referenced by nnp::Structure::calculateDQdr(), and nnp::Mode::calculateForces().

Here is the call graph for this function:

Here is the caller graph for this function:

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 446 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 461 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 470 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("chi                            : %16.8E\n", chi));
    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, chi, 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 91 of file Atom.h.

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

NeighborListIsSorted

bool nnp::Atom::NeighborListIsSorted

If the neighbor list is sorted by distance.

Definition at line 93 of file Atom.h.

hasSymmetryFunctions

bool nnp::Atom::hasSymmetryFunctions

If symmetry function values are saved for this atom.

Definition at line 95 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 97 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 99 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 101 of file Atom.h.

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

indexStructure

std::size_t nnp::Atom::indexStructure

Index number of structure this atom belongs to.

Definition at line 103 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 105 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 107 of file Atom.h.

Referenced by nnp::Structure::calculateDAdrQ(), nnp::Structure::calculateDQdJ(), nnp::Structure::calculateDQdr(), nnp::Structure::calculateElectrostaticEnergy(), nnp::Structure::calculateElectrostaticEnergyDerivatives(), nnp::Mode::calculateForces(), nnp::Structure::calculateScreeningEnergy(), nnp::Mode::calculateSymmetryFunctionGroups(), nnp::Mode::calculateSymmetryFunctions(), nnp::Training::collectDGdxia(), LAMMPS_NS::PairHDNNPExternal::compute(), nnp::InterfaceLammps::getAtomicEnergy(), nnp::Atom::Neighbor::info(), info(), 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 109 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::SymFncExpAngnWeighted::calculate(), nnp::SymFncExpAngw::calculate(), nnp::SymFncExpRadWeighted::calculate(), nnp::SymGrpCompAngn::calculate(), nnp::SymGrpCompAngnWeighted::calculate(), nnp::SymGrpCompAngw::calculate(), nnp::SymGrpCompAngwWeighted::calculate(), nnp::SymGrpCompRad::calculate(), nnp::SymGrpCompRadWeighted::calculate(), nnp::SymGrpExpAngnWeighted::calculate(), nnp::SymGrpExpAngw::calculate(), nnp::SymGrpExpRadWeighted::calculate(), calculateDChidr(), nnp::Training::collectDGdxia(), getStoredMinNumNeighbors(), 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 111 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 113 of file Atom.h.

Referenced by allocate(), calculateDChidr(), calculatePairForceShort(), calculateSelfForceShort(), nnp::Mode::calculateSymmetryFunctionGroups(), nnp::Mode::calculateSymmetryFunctions(), nnp::Training::collectDGdxia(), info(), toNormalizedUnits(), toPhysicalUnits(), and nnp::Element::updateSymmetryFunctionStatistics().

energy

double nnp::Atom::energy

Atomic energy determined by neural network.

Definition at line 115 of file Atom.h.

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

dEelecdQ

double nnp::Atom::dEelecdQ

Derivative of electrostatic energy with respect to this atom's charge.

Definition at line 117 of file Atom.h.

Referenced by nnp::Structure::calculateElectrostaticEnergyDerivatives(), nnp::Structure::calculateForceLambdaElec(), and nnp::Structure::calculateForceLambdaTotal().

chi

double nnp::Atom::chi

Atomic electronegativity determined by neural network.

Definition at line 119 of file Atom.h.

Referenced by nnp::Structure::calculateElectrostaticEnergy(), info(), and nnp::Training::update().

charge

double nnp::Atom::charge

Atomic charge determined by neural network.

Definition at line 121 of file Atom.h.

Referenced by nnp::Structure::calculateDAdrQ(), nnp::Structure::calculateDQdJ(), nnp::Structure::calculateElectrostaticEnergyDerivatives(), nnp::Structure::calculateScreeningEnergy(), getChargeLine(), info(), toNormalizedUnits(), toPhysicalUnits(), nnp::Training::update(), and updateError().

chargeRef

double nnp::Atom::chargeRef

Atomic reference charge.

Definition at line 123 of file Atom.h.

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

r

Vec3D nnp::Atom::r

Cartesian coordinates.

Definition at line 125 of file Atom.h.

Referenced by nnp::Structure::calculateDAdrQ(), nnp::Structure::calculateElectrostaticEnergy(), nnp::Structure::calculateElectrostaticEnergyDerivatives(), nnp::Structure::calculateScreeningEnergy(), LAMMPS_NS::PairHDNNPExternal::compute(), info(), nnp::Structure::remap(), nnp::InterfaceLammps::setLocalAtomPositions(), toNormalizedUnits(), and toPhysicalUnits().

f

Vec3D nnp::Atom::f

Force vector calculated by neural network.

Definition at line 127 of file Atom.h.

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

fElec

Vec3D nnp::Atom::fElec

Force vector resulting from electrostatics.

Definition at line 129 of file Atom.h.

fRef

Vec3D nnp::Atom::fRef

Reference force vector from data set.

Definition at line 131 of file Atom.h.

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

pEelecpr

Vec3D nnp::Atom::pEelecpr

Partial derivative of electrostatic energy with respect to this atom's coordinates.

Definition at line 134 of file Atom.h.

Referenced by nnp::Structure::calculateElectrostaticEnergyDerivatives().

neighborsUnique

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

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

Definition at line 136 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 138 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 140 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 143 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 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(), 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.

Also contains dEdQ in the last element if HDNNP-4G is used.

Definition at line 149 of file Atom.h.

Referenced by allocate(), nnp::Structure::calculateForceLambdaTotal(), calculatePairForceShort(), calculateSelfForceShort(), free(), info(), toNormalizedUnits(), and toPhysicalUnits().

dQdG

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

Derivative of atomic charge with respect to symmetry functions.

Definition at line 151 of file Atom.h.

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

dChidG

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

Derivative of electronegativity with respect to symmetry functions.

Definition at line 153 of file Atom.h.

Referenced by allocate(), calculateDChidr(), free(), and nnp::Training::update().

dGdr

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

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

Definition at line 161 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(), calculateDChidr(), calculateSelfForceShort(), nnp::Training::collectDGdxia(), free(), nnp::Atom::Neighbor::info(), info(), toNormalizedUnits(), and toPhysicalUnits().

dQdr

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

Derivative of charges with respect to this atom's coordinates.

Definition at line 163 of file Atom.h.

Referenced by nnp::Structure::calculateDQdr().

dAdrQ

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

If dQdr has been calculated for respective components.

Derivative of A-matrix with respect to this atom's coordinates contracted with the charges.

Definition at line 168 of file Atom.h.

Referenced by nnp::Structure::calculateDAdrQ(), nnp::Structure::calculateDQdr(), and nnp::Structure::calculateElectrostaticEnergyDerivatives().

neighbors

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

Neighbor array (maximum number defined in macros.h.

Definition at line 170 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::Structure::calculateDAdrQ(), calculateDChidr(), nnp::Structure::calculateElectrostaticEnergy(), nnp::Structure::calculateElectrostaticEnergyDerivatives(), nnp::Mode::calculateForces(), calculateNumNeighbors(), nnp::Structure::calculateScreeningEnergy(), nnp::Training::collectDGdxia(), free(), info(), isNeighbor(), nnp::InterfaceLammps::setLocalAtoms(), toNormalizedUnits(), toPhysicalUnits(), and nnp::Dataset::writeAtomicEnvironmentFile().

neighborCutoffs

std::unordered_map<double, size_t> nnp::Atom::neighborCutoffs

Map stores number of neighbors needed for the corresponding cut-off.

Definition at line 172 of file Atom.h.

Referenced by calculateNumNeighbors(), and getStoredMinNumNeighbors().

---

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