nnp::Structure Struct Reference

Storage for one atomic configuration. More...

#include <Structure.h>

Collaboration diagram for nnp::Structure:

Public Types
enum	SampleType { ST_UNKNOWN , ST_TRAINING , ST_VALIDATION , ST_TEST }
	Enumerates different sample types (e.g. More...

Public Member Functions
	Structure ()
	Constructor, initializes to zero. More...
void	setElementMap (ElementMap const &elementMap)
	Set element map of structure. More...
void	addAtom (Atom const &atom, std::string const &element)
	Add a single atom to structure. More...
void	readFromFile (std::string const fileName="input.data")
	Read configuration from file. More...
void	readFromFile (std::ifstream &file)
	Read configuration from file. More...
void	readFromLines (std::vector< std::string > const &lines)
	Read configuration from lines. More...
void	calculateMaxCutoffRadiusOverall (EwaldSetup &ewaldSetup, double rcutScreen, double maxCutoffRadius)
	Calculate maximal cut-off if cut-off of screening and real part Ewald summation are also considered. More...
void	calculateNeighborList (double cutoffRadius, bool sortByDistance=false)
	Calculate neighbor list for all atoms. More...
void	calculateNeighborList (double cutoffRadius, std::vector< std::vector< double > > &cutoffs)
	Calculate neighbor list for all atoms and setup neighbor cut-off map. More...
void	sortNeighborList ()
	Sort all neighbor lists of this structure with respect to the distance. More...
void	setupNeighborCutoffMap (std::vector< std::vector< double > > cutoffs)
	Set up a neighbor cut-off map which gives the index (value) of the last needed neighbor corresponding to a specific cut-off (key). More...
void	calculatePbcCopies (double cutoffRadius, int(&pbc)[3])
	Calculate required PBC copies. More...
void	calculateInverseBox ()
	Calculate inverse box. More...
bool	canMinimumImageConventionBeApplied (double cutoffRadius)
	Check if cut-off radius is small enough to apply minimum image convention. More...
Vec3D	applyMinimumImageConvention (Vec3D const &dr)
	Calculate distance between two atoms in the minimum image convention. More...
void	calculateVolume ()
	Calculate volume from box vectors. More...
double	calculateElectrostaticEnergy (EwaldSetup &ewaldSetup, Eigen::VectorXd hardness, Eigen::MatrixXd gammaSqrt2, Eigen::VectorXd sigmaSqrtPi, ScreeningFunction const &fs, double const fourPiEps, ErfcBuf &erfcBuf)
	Compute electrostatic energy with global charge equilibration. More...
double	calculateScreeningEnergy (Eigen::MatrixXd gammaSqrt2, Eigen::VectorXd sigmaSqrtPi, ScreeningFunction const &fs, double const fourPiEps)
	Calculate screening energy which needs to be added (!) to the electrostatic energy in order to remove contributions in the short range domain. More...
void	calculateDAdrQ (EwaldSetup &ewaldSetup, Eigen::MatrixXd gammaSqrt2, double const fourPiEps, ErfcBuf &erfcBuf)
	Calculates derivative of A-matrix with respect to the atoms positions and contract it with Q. More...
void	calculateDQdChi (std::vector< Eigen::VectorXd > &dQdChi)
	Calculates derivative of the charges with respect to electronegativities. More...
void	calculateDQdJ (std::vector< Eigen::VectorXd > &dQdJ)
	Calculates derivative of the charges with respect to atomic hardness. More...
void	calculateDQdr (std::vector< size_t > const &atomsIndices, std::vector< size_t > const &compIndices, double const maxCutoffRadius, std::vector< Element > const &elements)
	Calculates derivative of the charges with respect to the atom's position. More...
void	calculateElectrostaticEnergyDerivatives (Eigen::VectorXd hardness, Eigen::MatrixXd gammaSqrt2, Eigen::VectorXd sigmaSqrtPi, ScreeningFunction const &fs, double const fourPiEps)
	Calculates partial derivatives of electrostatic Energy with respect to atom's coordinates and charges. More...
Eigen::VectorXd const	calculateForceLambdaTotal () const
	Calculate lambda_total vector which is needed for the total force calculation in 4G NN. More...
Eigen::VectorXd const	calculateForceLambdaElec () const
	Calculate lambda_elec vector which is needed for the electrostatic force calculation in 4G NN. More...
void	remap ()
	Translate all atoms back into box if outside. More...
void	remap (Atom &atom)
	Translate atom back into box if outside. More...
void	toNormalizedUnits (double meanEnergy, double convEnergy, double convLength, double convCharge)
	Normalize structure, shift energy and change energy, length and charge unit. More...
void	toPhysicalUnits (double meanEnergy, double convEnergy, double convLength, double convCharge)
	Switch to physical units, shift energy and change energy, length and charge unit. More...
std::size_t	getMaxNumNeighbors () const
	Find maximum number of neighbors. More...
void	freeAtoms (bool all, double const maxCutoffRadius=0.0)
	Free symmetry function memory for all atoms, see free() in Atom class. More...
void	reset ()
	Reset everything but elementMap. More...
void	clearNeighborList ()
	Clear neighbor list of all atoms. More...
void	clearElectrostatics (bool clearDQdr=false)
	Clear A-matrix, dAdrQ and optionally dQdr. More...
void	updateError (std::string const &property, std::map< std::string, double > &error, std::size_t &count) const
	Update property error metrics with this structure. More...
std::string	getEnergyLine () const
	Get reference and NN energy. More...
std::vector< std::string >	getForcesLines () const
	Get reference and NN forces for all atoms. More...
std::vector< std::string >	getChargesLines () const
	Get reference and NN charges for all atoms. More...
void	writeToFile (std::string const fileName="output.data", bool const ref=true, bool const append=false) const
	Write configuration to file. More...
void	writeToFile (std::ofstream *const &file, bool const ref=true) const
	Write configuration to file. More...
void	writeToFileXyz (std::ofstream *const &file) const
	Write configuration to xyz file. More...
void	writeToFilePoscar (std::ofstream *const &file) const
	Write configuration to POSCAR file. More...
void	writeToFilePoscar (std::ofstream *const &file, std::string const elements) const
	Write configuration to POSCAR file. More...
std::vector< std::string >	info () const
	Get structure information as a vector of strings. More...

Public Attributes
ElementMap	elementMap
	Copy of element map provided as constructor argument. More...
bool	isPeriodic
	If periodic boundary conditions apply. More...
bool	isTriclinic
	If the simulation box is triclinic. More...
bool	hasNeighborList
	If the neighbor list has been calculated. More...
bool	NeighborListIsSorted
	If the neighbor list has been sorted by distance. More...
bool	hasSymmetryFunctions
	If symmetry function values are saved for each atom. More...
bool	hasSymmetryFunctionDerivatives
	If symmetry function derivatives are saved for each atom. More...
std::size_t	index
	Index number of this structure. More...
std::size_t	numAtoms
	Total number of atoms present in this structure. More...
std::size_t	numElements
	Global number of elements (all structures). More...
std::size_t	numElementsPresent
	Number of elements present in this structure. More...
int	pbc [3]
	Number of PBC images necessary in each direction for max cut-off. More...
double	energy
	Potential energy determined by neural network. More...
double	energyRef
	Reference potential energy. More...
double	energyShort
	Short-range part of the potential energy predicted by NNP. More...
double	energyElec
	Electrostatics part of the potential energy predicted by NNP. More...
bool	hasCharges
	If all charges of this structure have been calculated (and stay the same, e.g. More...
double	charge
	Charge determined by neural network potential. More...
double	chargeRef
	Reference charge. More...
double	volume
	Simulation box volume. More...
double	maxCutoffRadiusOverall
	Maximum cut-off radius with respect to symmetry functions, screening function and Ewald summation. More...
double	lambda
	Lagrange multiplier used for charge equilibration. More...
SampleType	sampleType
	Sample type (training or test set). More...
std::string	comment
	Structure comment. More...
Vec3D	box [3]
	Simulation box vectors. More...
Vec3D	invbox [3]
	Inverse simulation box vectors. More...
Eigen::MatrixXd	A
	Global charge equilibration matrix A'. More...
bool	hasAMatrix
	If A matrix of this structure is currently stored. More...
std::vector< std::size_t >	numAtomsPerElement
	Number of atoms of each element in this structure. More...
std::vector< Atom >	atoms
	Vector of all atoms in this structure. More...

Detailed Description

Storage for one atomic configuration.

Definition at line 38 of file Structure.h.

Member Enumeration Documentation

SampleType

enum nnp::Structure::SampleType

Enumerates different sample types (e.g.

training or test set).

Enumerator
ST_UNKNOWN	Sample type not assigned yet.
ST_TRAINING	Structure is part of the training set.
ST_VALIDATION	Structure is part of validation set (currently unused).
ST_TEST	Structure is part of the test set.

Definition at line 42 of file Structure.h.

    {
        ST_UNKNOWN,
        ST_TRAINING,
        ST_VALIDATION,
        ST_TEST
    };

Constructor & Destructor Documentation

Structure()

Structure::Structure

(

)

Constructor, initializes to zero.

Definition at line 35 of file Structure.cpp.

                     :
    isPeriodic                    (false     ),
    isTriclinic                   (false     ),
    hasNeighborList               (false     ),
    NeighborListIsSorted          (false     ),
    hasSymmetryFunctions          (false     ),
    hasSymmetryFunctionDerivatives(false     ),
    index                         (0         ),
    numAtoms                      (0         ),
    numElements                   (0         ),
    numElementsPresent            (0         ),
    energy                        (0.0       ),
    energyRef                     (0.0       ),
    energyShort                   (0.0       ),
    energyElec                    (0.0       ),
    hasCharges                    (false     ),
    charge                        (0.0       ),
    chargeRef                     (0.0       ),
    volume                        (0.0       ),
    maxCutoffRadiusOverall        (0.0       ),
    sampleType                    (ST_UNKNOWN),
    comment                       (""        ),
    hasAMatrix                    (false     )
{
    for (size_t i = 0; i < 3; i++)
    {
        pbc[i] = 0;
        box[i][0] = 0.0;
        box[i][1] = 0.0;
        box[i][2] = 0.0;
        invbox[i][0] = 0.0;
        invbox[i][1] = 0.0;
        invbox[i][2] = 0.0;
    }
}

References box, invbox, and pbc.

Member Function Documentation

setElementMap()

void Structure::setElementMap

(

ElementMap const &

elementMap

)

Set element map of structure.

Parameters

[in]

elementMap

Reference to a map containing all possible (symbol, index)-pairs (see ElementMap).

Definition at line 71 of file Structure.cpp.

{
    this->elementMap = elementMap;
    numElements = elementMap.size();
    numAtomsPerElement.resize(numElements, 0);
 
    return;
}

References elementMap, numAtomsPerElement, numElements, and nnp::ElementMap::size().

Referenced by nnp::Dataset::distributeStructures(), nnp::InterfaceLammps::initialize(), main(), nnp::Dataset::prepareNumericForces(), nnp::Prediction::readStructureFromFile(), and LAMMPS_NS::PairHDNNPExternal::settings().

Here is the call graph for this function:

Here is the caller graph for this function:

addAtom()

void Structure::addAtom	(	Atom const &	atom,
		std::string const &	element
	)

Add a single atom to structure.

Parameters

[in]	atom	Atom to insert.
[in]	element	Element string of new atom.

Note

Be sure to set the element map properly before adding atoms. This function will only keep the atom's coordinates, energy, charge, tag and forces, all other members will be cleared or reset (in particular, the neighbor list and symmetry function data will be deleted).

Definition at line 80 of file Structure.cpp.

{
    atoms.push_back(Atom());
    atoms.back() = atom;
    // The number of elements may have changed.
    atoms.back().numNeighborsPerElement.resize(elementMap.size(), 0);
    atoms.back().clearNeighborList();
    atoms.back().index                = numAtoms;
    atoms.back().indexStructure       = index;
    atoms.back().element              = elementMap[element];
    atoms.back().numSymmetryFunctions = 0;
    numAtoms++;
    numAtomsPerElement[elementMap[element]]++;
 
    return;
}

References atoms, elementMap, index, numAtoms, numAtomsPerElement, and nnp::ElementMap::size().

Here is the call graph for this function:

readFromFile() [1/2]

void Structure::readFromFile

(

std::string const

fileName = "input.data"

)

Read configuration from file.

Parameters

[in]

fileName

Input file name.

Reads the first configuration found in the input file.

Definition at line 97 of file Structure.cpp.

{
    ifstream file;
 
    file.open(fileName.c_str());
    if (!file.is_open())
    {
        throw runtime_error("ERROR: Could not open file: \"" + fileName
                            + "\".\n");
    }
    readFromFile(file);
    file.close();
 
    return;
}

References readFromFile().

Referenced by nnp::Dataset::distributeStructures(), main(), readFromFile(), and nnp::Prediction::readStructureFromFile().

Here is the call graph for this function:

Here is the caller graph for this function:

readFromFile() [2/2]

void Structure::readFromFile

(

std::ifstream &

file

)

Read configuration from file.

Parameters

[in]

file

Input file stream (already opened).

Expects that a file with configurations is open, first keyword on first line should be begin. Reads until keyword is end.

Definition at line 113 of file Structure.cpp.

{
    string         line;
    vector<string> lines;
    vector<string> splitLine;
 
    // read first line, should be keyword "begin".
    getline(file, line);
    lines.push_back(line);
    splitLine = split(reduce(line));
    if (splitLine.at(0) != "begin")
    {
        throw runtime_error("ERROR: Unexpected file content, expected"
                            " \"begin\" keyword.\n");
    }
 
    while (getline(file, line))
    {
        lines.push_back(line);
        splitLine = split(reduce(line));
        if (splitLine.at(0) == "end") break;
    }
 
    readFromLines(lines);
 
    return;
}

References readFromLines(), nnp::reduce(), and nnp::split().

Here is the call graph for this function:

readFromLines()

void Structure::readFromLines

(

std::vector< std::string > const &

lines

)

Read configuration from lines.

Parameters

[in]

lines

One configuration in form of a vector of strings.

Read the configuration from a vector of strings.

Definition at line 142 of file Structure.cpp.

{
    size_t         iBoxVector = 0;
    vector<string> splitLine;
 
    // read first line, should be keyword "begin".
    splitLine = split(reduce(lines.at(0)));
    if (splitLine.at(0) != "begin")
    {
        throw runtime_error("ERROR: Unexpected line content, expected"
                            " \"begin\" keyword.\n");
    }
 
    for (vector<string>::const_iterator line = lines.begin();
         line != lines.end(); ++line)
    {
        splitLine = split(reduce(*line));
        if (splitLine.at(0) == "begin")
        {
            if (splitLine.size() > 1)
            {
                for (vector<string>::const_iterator word =
                     splitLine.begin() + 1; word != splitLine.end(); ++word)
                {
                    if      (*word == "set=train") sampleType = ST_TRAINING;
                    else if (*word == "set=test") sampleType = ST_TEST;
                    else
                    {
                        throw runtime_error("ERROR: Unknown keyword in "
                                            "structure specification, check "
                                            "\"begin\" arguments.\n");
                    }
                }
            }
        }
        else if (splitLine.at(0) == "comment")
        {
            size_t position = line->find("comment");
            string tmpLine = *line;
            comment = tmpLine.erase(position, splitLine.at(0).length() + 1);
        }
        else if (splitLine.at(0) == "lattice")
        {
            if (iBoxVector > 2)
            {
                throw runtime_error("ERROR: Too many box vectors.\n");
            }
            box[iBoxVector][0] = atof(splitLine.at(1).c_str());
            box[iBoxVector][1] = atof(splitLine.at(2).c_str());
            box[iBoxVector][2] = atof(splitLine.at(3).c_str());
            iBoxVector++;
            if (iBoxVector == 3)
            {
                isPeriodic = true;
                if (box[0][1] > numeric_limits<double>::min() ||
                    box[0][2] > numeric_limits<double>::min() ||
                    box[1][0] > numeric_limits<double>::min() ||
                    box[1][2] > numeric_limits<double>::min() ||
                    box[2][0] > numeric_limits<double>::min() ||
                    box[2][1] > numeric_limits<double>::min())
                {
                    isTriclinic = true;
                }
                calculateInverseBox();
                calculateVolume();
            }
        }
        else if (splitLine.at(0) == "atom")
        {
            atoms.push_back(Atom());
            atoms.back().index          = numAtoms;
            atoms.back().indexStructure = index;
            atoms.back().tag            = numAtoms; // Implicit conversion!
            atoms.back().r[0]           = atof(splitLine.at(1).c_str());
            atoms.back().r[1]           = atof(splitLine.at(2).c_str());
            atoms.back().r[2]           = atof(splitLine.at(3).c_str());
            atoms.back().element        = elementMap[splitLine.at(4)];
            atoms.back().chargeRef      = atof(splitLine.at(5).c_str());
            atoms.back().fRef[0]        = atof(splitLine.at(7).c_str());
            atoms.back().fRef[1]        = atof(splitLine.at(8).c_str());
            atoms.back().fRef[2]        = atof(splitLine.at(9).c_str());
            atoms.back().numNeighborsPerElement.resize(numElements, 0);
            numAtoms++;
            numAtomsPerElement[elementMap[splitLine.at(4)]]++;
        }
        else if (splitLine.at(0) == "energy")
        {
            energyRef = atof(splitLine[1].c_str());
        }
        else if (splitLine.at(0) == "charge")
        {
            chargeRef = atof(splitLine[1].c_str());
        }
        else if (splitLine.at(0) == "end")
        {
            if (!(iBoxVector == 0 || iBoxVector == 3))
            {
                throw runtime_error("ERROR: Strange number of box vectors.\n");
            }
            if (isPeriodic &&
                abs(chargeRef) > 10*std::numeric_limits<double>::epsilon())
            {
                throw runtime_error("ERROR: In structure with index "
                                    + to_string(index)
                                    + "; if PBCs are applied, the\n"
                                    "simulation cell has to be neutrally "
                                    "charged.\n");
            }
            break;
        }
        else
        {
            throw runtime_error("ERROR: Unexpected file content, "
                                "unknown keyword \"" + splitLine.at(0) +
                                "\".\n");
        }
    }
 
    for (size_t i = 0; i < numElements; i++)
    {
        if (numAtomsPerElement[i] > 0)
        {
            numElementsPresent++;
        }
    }
 
    if (isPeriodic) remap();
 
    return;
}

References atoms, box, calculateInverseBox(), calculateVolume(), chargeRef, comment, elementMap, energyRef, index, isPeriodic, isTriclinic, numAtoms, numAtomsPerElement, numElements, numElementsPresent, nnp::reduce(), remap(), sampleType, nnp::split(), ST_TEST, and ST_TRAINING.

Referenced by readFromFile().

Here is the call graph for this function:

Here is the caller graph for this function:

calculateMaxCutoffRadiusOverall()

void Structure::calculateMaxCutoffRadiusOverall	(	EwaldSetup &	ewaldSetup,
		double	rcutScreen,
		double	maxCutoffRadius
	)

Calculate maximal cut-off if cut-off of screening and real part Ewald summation are also considered.

Parameters

[in]	ewaldSetup	Settings of Ewald summation.
[in]	rcutScreen	Cut-off for Screening of the electrostatic interaction.
[in]	maxCutoffRadius	maximal cut-off of symmetry functions.

Definition at line 273 of file Structure.cpp.

{
    maxCutoffRadiusOverall = max(rcutScreen, maxCutoffRadius);
    if (isPeriodic)
    {
        ewaldSetup.calculateParameters(volume, numAtoms);
        maxCutoffRadiusOverall = max(maxCutoffRadiusOverall,
                                     ewaldSetup.params.rCut);
    }
}

References nnp::EwaldSetup::calculateParameters(), isPeriodic, maxCutoffRadiusOverall, numAtoms, nnp::EwaldSetup::params, nnp::EwaldParameters::rCut, and volume.

Referenced by nnp::Mode::evaluateNNP(), nnp::InterfaceLammps::finalizeNeighborList(), and nnp::InterfaceLammps::getMaxCutoffRadiusOverall().

Here is the call graph for this function:

Here is the caller graph for this function:

calculateNeighborList() [1/2]

void Structure::calculateNeighborList	(	double	cutoffRadius,
		bool	sortByDistance = false
	)

Calculate neighbor list for all atoms.

Parameters

[in]	cutoffRadius	Atoms are neighbors if there distance is smaller than the cutoff radius.
[in]	sortByDistance	Sort neighborlist from nearest to farthest neighbor.

Definition at line 287 of file Structure.cpp.

{
    cutoffRadius = max( cutoffRadius, maxCutoffRadiusOverall );
    //cout << "CUTOFF: " << cutoffRadius << "\n";
 
    if (isPeriodic)
    {
        calculatePbcCopies(cutoffRadius, pbc);
 
        // Use square of cutoffRadius (faster).
        cutoffRadius *= cutoffRadius;
 
#ifdef _OPENMP
        #pragma omp parallel for
#endif
        for (size_t i = 0; i < numAtoms; i++)
        {
            // Count atom i as unique neighbor.
            atoms[i].neighborsUnique.push_back(i);
            atoms[i].numNeighborsUnique++;
            for (size_t j = 0; j < numAtoms; j++)
            {
                for (int bc0 = -pbc[0]; bc0 <= pbc[0]; bc0++)
                {
                    for (int bc1 = -pbc[1]; bc1 <= pbc[1]; bc1++)
                    {
                        for (int bc2 = -pbc[2]; bc2 <= pbc[2]; bc2++)
                        {
                            if (!(i == j && bc0 == 0 && bc1 == 0 && bc2 == 0))
                            {
                                Vec3D dr = atoms[i].r - atoms[j].r
                                         + bc0 * box[0]
                                         + bc1 * box[1]
                                         + bc2 * box[2];
                                if (dr.norm2() <= cutoffRadius)
                                {
                                    atoms[i].neighbors.
                                        push_back(Atom::Neighbor());
                                    atoms[i].neighbors.
                                        back().index = j;
                                    atoms[i].neighbors.
                                        back().tag = j; // Implicit conversion!
                                    atoms[i].neighbors.
                                        back().element = atoms[j].element;
                                    atoms[i].neighbors.
                                        back().d = dr.norm();
                                    atoms[i].neighbors.
                                        back().dr = dr;
                                    atoms[i].numNeighborsPerElement[
                                        atoms[j].element]++;
                                    atoms[i].numNeighbors++;
                                    // Count atom j only once as unique
                                    // neighbor.
                                    if (atoms[i].neighborsUnique.back() != j &&
                                        i != j)
                                    {
                                        atoms[i].neighborsUnique.push_back(j);
                                        atoms[i].numNeighborsUnique++;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            atoms[i].hasNeighborList = true;
        }
    }
    else
    {
        // Use square of cutoffRadius (faster).
        cutoffRadius *= cutoffRadius;
 
#ifdef _OPENMP
        #pragma omp parallel for
#endif
        for (size_t i = 0; i < numAtoms; i++)
        {
            // Count atom i as unique neighbor.
            atoms[i].neighborsUnique.push_back(i);
            atoms[i].numNeighborsUnique++;
            for (size_t j = 0; j < numAtoms; j++)
            {
                if (i != j)
                {
                    Vec3D dr = atoms[i].r - atoms[j].r;
                    if (dr.norm2() <= cutoffRadius)
                    {
                        atoms[i].neighbors.push_back(Atom::Neighbor());
                        atoms[i].neighbors.back().index   = j;
                        atoms[i].neighbors.back().tag     = j; // Impl. conv.!
                        atoms[i].neighbors.back().element = atoms[j].element;
                        atoms[i].neighbors.back().d       = dr.norm();
                        atoms[i].neighbors.back().dr      = dr;
                        atoms[i].numNeighborsPerElement[atoms[j].element]++;
                        atoms[i].numNeighbors++;
                        atoms[i].neighborsUnique.push_back(j);
                        atoms[i].numNeighborsUnique++;
                    }
                }
            }
            atoms[i].hasNeighborList = true;
        }
    }
 
    hasNeighborList = true;
 
    if (sortByDistance) sortNeighborList();
 
    return;
}

References atoms, box, calculatePbcCopies(), hasNeighborList, isPeriodic, maxCutoffRadiusOverall, nnp::Vec3D::norm(), nnp::Vec3D::norm2(), numAtoms, pbc, and sortNeighborList().

Referenced by calculateNeighborList(), nnp::Mode::evaluateNNP(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

calculateNeighborList() [2/2]

void Structure::calculateNeighborList	(	double	cutoffRadius,
		std::vector< std::vector< double > > &	cutoffs
	)

Calculate neighbor list for all atoms and setup neighbor cut-off map.

Parameters

[in]	cutoffRadius	Atoms are neighbors if there distance is smaller than the cutoff radius.
[in]	cutoffs	Vector of all needed cutoffs (needed for cut-off map construction).

Returns

Maximum of {maxCutoffRadius, rcutScreen, rCut}.

Definition at line 401 of file Structure.cpp.

{
    calculateNeighborList(cutoffRadius, true);
    setupNeighborCutoffMap(cutoffs);
}

References calculateNeighborList(), and setupNeighborCutoffMap().

Here is the call graph for this function:

sortNeighborList()

void Structure::sortNeighborList

(

)

Sort all neighbor lists of this structure with respect to the distance.

Definition at line 409 of file Structure.cpp.

{
#ifdef _OPENMP
        #pragma omp parallel for
#endif
    for (size_t i = 0; i < numAtoms; ++i)
    {
        sort(atoms[i].neighbors.begin(), atoms[i].neighbors.end());
        //TODO: maybe sort neighborsUnique too?
        atoms[i].NeighborListIsSorted = true;
    }
    NeighborListIsSorted = true;
}

References atoms, NeighborListIsSorted, and numAtoms.

Referenced by calculateNeighborList(), and nnp::InterfaceLammps::finalizeNeighborList().

Here is the caller graph for this function:

setupNeighborCutoffMap()

void Structure::setupNeighborCutoffMap

(

std::vector< std::vector< double > >

cutoffs

)

Set up a neighbor cut-off map which gives the index (value) of the last needed neighbor corresponding to a specific cut-off (key).

Parameters

[in]

cutoffs

Vector of all needed symmetry function cutoffs. Note that a local copy gets extended with maxCutoffRadiusOverall.

Definition at line 423 of file Structure.cpp.

{
    if ( !NeighborListIsSorted )
        throw runtime_error("NeighborCutoffs map needs a sorted neighbor list");
 
    for ( auto& elementCutoffs : cutoffs )
    {
        if ( maxCutoffRadiusOverall > 0 &&
             !vectorContains(elementCutoffs, maxCutoffRadiusOverall))
        {
            elementCutoffs.push_back(maxCutoffRadiusOverall);
        }
 
        if ( !is_sorted(elementCutoffs.begin(), elementCutoffs.end()) )
        {
            sort(elementCutoffs.begin(), elementCutoffs.end());
        }
    }
 
    // Loop over all atoms in this structure and create its neighborCutoffs map
    for( auto& a : atoms )
    {
        size_t const eIndex = a.element;
        vector<double> const& elementCutoffs = cutoffs.at(eIndex);
        size_t in = 0;
        size_t ic = 0;
 
        while( in < a.numNeighbors && ic < elementCutoffs.size() )
        {
            Atom::Neighbor const& n = a.neighbors[in];
            // If neighbor distance is higher than current "desired cutoff"
            // then add neighbor cutoff.
            // Attention: a step in the neighbor list could jump over multiple
            // params -> don't increment neighbor index
            if( n.d > elementCutoffs[ic] )
            {
                a.neighborCutoffs.emplace( elementCutoffs.at(ic), in );
                ++ic;
            }
            else if ( in == a.numNeighbors - 1 )
            {
                a.neighborCutoffs.emplace( elementCutoffs.at(ic), a.numNeighbors );
                ++ic;
            }
            else ++in;
        }
    }
}

References atoms, nnp::Atom::Neighbor::d, maxCutoffRadiusOverall, NeighborListIsSorted, and nnp::vectorContains().

Referenced by calculateNeighborList(), and nnp::InterfaceLammps::finalizeNeighborList().

Here is the call graph for this function:

Here is the caller graph for this function:

calculatePbcCopies()

void Structure::calculatePbcCopies	(	double	cutoffRadius,
		int(&)	pbc[3]
	)

Calculate required PBC copies.

Parameters

[in]	cutoffRadius	Cutoff radius for neighbor list.
[in]	pbc	Array for storing the result.

Called by calculateNeighborList().

Definition at line 486 of file Structure.cpp.

{
    Vec3D axb;
    Vec3D axc;
    Vec3D bxc;
 
    axb = box[0].cross(box[1]).normalize();
    axc = box[0].cross(box[2]).normalize();
    bxc = box[1].cross(box[2]).normalize();
 
    double proja = fabs(box[0] * bxc);
    double projb = fabs(box[1] * axc);
    double projc = fabs(box[2] * axb);
 
    pbc[0] = 0;
    pbc[1] = 0;
    pbc[2] = 0;
    while (pbc[0] * proja <= cutoffRadius)
    {
        pbc[0]++;
    }
    while (pbc[1] * projb <= cutoffRadius)
    {
        pbc[1]++;
    }
    while (pbc[2] * projc <= cutoffRadius)
    {
        pbc[2]++;
    }
 
    return;
}

References box, nnp::Vec3D::cross(), nnp::Vec3D::normalize(), and pbc.

Referenced by calculateNeighborList().

Here is the call graph for this function:

Here is the caller graph for this function:

calculateInverseBox()

void Structure::calculateInverseBox

(

)

Calculate inverse box.

Simulation box looks like this:

\[ h = \begin{pmatrix} \phantom{a_x} & \phantom{b_x} & \phantom{c_x} \\ \vec{\mathbf{a}} & \vec{\mathbf{b}} & \vec{\mathbf{c}} \\ \phantom{a_z} & \phantom{b_z} & \phantom{c_z} \\ \end{pmatrix} = \begin{pmatrix} a_x & b_x & c_x \\ a_y & b_y & c_y \\ a_z & b_z & c_z \\ \end{pmatrix}, \]

where \(\vec{\mathbf{a}} = \) box[0], \(\vec{\mathbf{b}} = \) box[1] and \(\vec{\mathbf{c}} = \) box[2]. Thus, indices are column first, row second:

\[ h = \begin{pmatrix} \texttt{box[0][0]} & \texttt{box[1][0]} & \texttt{box[2][0]} \\ \texttt{box[0][1]} & \texttt{box[1][1]} & \texttt{box[2][1]} \\ \texttt{box[0][2]} & \texttt{box[1][2]} & \texttt{box[2][2]} \\ \end{pmatrix}. \]

The inverse box matrix (same scheme as above but with invbox) can be used to calculate fractional coordinates:

\[ \begin{pmatrix} f_0 \\ f_1 \\ f_2 \end{pmatrix} = h^{-1} \; \vec{\mathbf{r}}. \]

Definition at line 519 of file Structure.cpp.

{
    double invdet = box[0][0] * box[1][1] * box[2][2]
                  + box[1][0] * box[2][1] * box[0][2]
                  + box[2][0] * box[0][1] * box[1][2]
                  - box[2][0] * box[1][1] * box[0][2]
                  - box[0][0] * box[2][1] * box[1][2]
                  - box[1][0] * box[0][1] * box[2][2];
    invdet = 1.0 / invdet;
 
    invbox[0][0] = box[1][1] * box[2][2] - box[2][1] * box[1][2];
    invbox[0][1] = box[2][1] * box[0][2] - box[0][1] * box[2][2];
    invbox[0][2] = box[0][1] * box[1][2] - box[1][1] * box[0][2];
    invbox[0] *= invdet;
 
    invbox[1][0] = box[2][0] * box[1][2] - box[1][0] * box[2][2];
    invbox[1][1] = box[0][0] * box[2][2] - box[2][0] * box[0][2];
    invbox[1][2] = box[1][0] * box[0][2] - box[0][0] * box[1][2];
    invbox[1] *= invdet;
 
    invbox[2][0] = box[1][0] * box[2][1] - box[2][0] * box[1][1];
    invbox[2][1] = box[2][0] * box[0][1] - box[0][0] * box[2][1];
    invbox[2][2] = box[0][0] * box[1][1] - box[1][0] * box[0][1];
    invbox[2] *= invdet;
 
    return;
}

References box, and invbox.

Referenced by readFromLines(), and nnp::InterfaceLammps::setBoxVectors().

Here is the caller graph for this function:

canMinimumImageConventionBeApplied()

bool Structure::canMinimumImageConventionBeApplied

(

double

cutoffRadius

)

Check if cut-off radius is small enough to apply minimum image convention.

Parameters

[in]

cutoffRadius

cut-off radius for which condition should be checked.

Definition at line 548 of file Structure.cpp.

{
    Vec3D axb;
    Vec3D axc;
    Vec3D bxc;
 
    axb = box[0].cross(box[1]).normalize();
    axc = box[0].cross(box[2]).normalize();
    bxc = box[1].cross(box[2]).normalize();
 
    double proj[3];
    proj[0] = fabs(box[0] * bxc);
    proj[1] = fabs(box[1] * axc);
    proj[2] = fabs(box[2] * axb);
 
    double minProj = *min_element(proj, proj+3);
    return (cutoffRadius < minProj / 2.0);
}

References box, nnp::Vec3D::cross(), and nnp::Vec3D::normalize().

Here is the call graph for this function:

applyMinimumImageConvention()

Vec3D Structure::applyMinimumImageConvention

(

Vec3D const &

dr

)

Calculate distance between two atoms in the minimum image convention.

Parameters

[in]

dr

Distance vector between two atoms of the same box.

Definition at line 567 of file Structure.cpp.

{
    Vec3D ds = invbox * dr;
    Vec3D dsNINT;
 
    for (size_t i=0; i<3; ++i)
    {
        dsNINT[i] = round(ds[i]);
    }
    Vec3D drMin = box * (ds - dsNINT);
 
    return drMin;
}

References box, and invbox.

calculateVolume()

void Structure::calculateVolume

(

)

Calculate volume from box vectors.

Definition at line 581 of file Structure.cpp.

{
    volume = fabs(box[0] * (box[1].cross(box[2])));
 
    return;
}

References box, and volume.

Referenced by readFromLines(), and nnp::InterfaceLammps::setBoxVectors().

Here is the caller graph for this function:

calculateElectrostaticEnergy()

double Structure::calculateElectrostaticEnergy	(	EwaldSetup &	ewaldSetup,
		Eigen::VectorXd	hardness,
		Eigen::MatrixXd	gammaSqrt2,
		Eigen::VectorXd	sigmaSqrtPi,
		ScreeningFunction const &	fs,
		double const	fourPiEps,
		ErfcBuf &	erfcBuf
	)

Compute electrostatic energy with global charge equilibration.

Parameters

[in]	ewaldSetup	Settings of Ewald summation.
[in]	hardness	Vector containing the hardness of all elements.
[in]	gammaSqrt2	Matrix combining gamma with prefactor. \( \text{gammaSqrt2}_{ij} = \sqrt{2} \gamma_{ij} = \sqrt{2} \sqrt{(\sigma_i^2 + \sigma_j^2)} \)
[in]	sigmaSqrtPi	Vector combining sigma with prefactor, \( \text{sigmaSqrtPi}_i = \sqrt{\pi} \sigma_i \)
[in]	fs	Screening function.
[in]	fourPiEps	\( \text{fourPiEps} = 4 \pi \varepsilon_0 \). Value depends on unit system (e.g. normalization).
[in]	erfcBuf	helper object to avoid repeated calculation of erfc().

Definition at line 588 of file Structure.cpp.

{
    A.resize(numAtoms + 1, numAtoms + 1);
    A.setZero();
    VectorXd b(numAtoms + 1);
    VectorXd hardnessJ(numAtoms);
    VectorXd Q;
    erfcBuf.reset(atoms, 2);
 
#ifdef _OPENMP
#pragma omp parallel
    {
#endif
    if (isPeriodic)
    {
#ifdef _OPENMP
#pragma omp single
        {
#endif
        if (!NeighborListIsSorted)
        {
            throw runtime_error("ERROR: Neighbor list needs to "
                                "be sorted for Ewald summation!\n");
        }
 
        // Should always happen already before neighborlist construction.
        //ewaldSetup.calculateParameters(volume, numAtoms);
#ifdef _OPENMP
        }
#endif
        KspaceGrid grid;
        grid.setup(box, ewaldSetup);
        double const rcutReal = ewaldSetup.params.rCut;
        double const sqrt2eta = sqrt(2.0) * ewaldSetup.params.eta;
 
#ifdef _OPENMP
        #pragma omp for schedule(dynamic)
#endif
        for (size_t i = 0; i < numAtoms; ++i)
        {
            Atom const &ai = atoms.at(i);
            size_t const ei = ai.element;
 
            // diagonal including self interaction
            A(i, i) += hardness(ei)
                       + (1.0 / sigmaSqrtPi(ei) - 2 / (sqrt2eta * sqrt(M_PI)))
                         / fourPiEps;
 
            hardnessJ(i) = hardness(ei);
            b(i) = -ai.chi;
 
            // real part
            size_t const numNeighbors = ai.getStoredMinNumNeighbors(rcutReal);
            for (size_t k = 0; k < numNeighbors; ++k)
            {
                auto const &n = ai.neighbors[k];
                size_t j = n.tag;
                if (j < i) continue;
 
                double const rij = n.d;
                size_t const ej = n.element;
 
                double erfcSqrt2Eta = erfcBuf.getf(i, k, 0, rij / sqrt2eta);
                double erfcGammaSqrt2 =
                            erfcBuf.getf(i, k, 1, rij / gammaSqrt2(ei, ej));
 
                A(i, j) += (erfcSqrt2Eta - erfcGammaSqrt2) / (rij * fourPiEps);
            }
 
            // reciprocal part
            //for (size_t j = i + 1; j < numAtoms; ++j)
            for (size_t j = i; j < numAtoms; ++j)
            {
                Atom const &aj = atoms.at(j);
                for (auto const &gv: grid.kvectors)
                {
                    // Multiply by 2 because our grid is only a half-sphere
                    // Vec3D const dr = applyMinimumImageConvention(ai.r - aj.r);
                    Vec3D const dr = ai.r - aj.r;
                    A(i, j) += 2 * gv.coeff * cos(gv.k * dr) / fourPiEps;
                    //A(i, j) += 2 * gv.coeff * cos(gv.k * (ai.r - aj.r));
                }
                A(j, i) = A(i, j);
            }
        }
    }
    else
    {
#ifdef _OPENMP
#pragma omp for schedule(dynamic)
#endif
        for (size_t i = 0; i < numAtoms; ++i)
        {
            Atom const &ai = atoms.at(i);
            size_t const ei = ai.element;
 
            A(i, i) = hardness(ei)
                      + 1.0 / (sigmaSqrtPi(ei) * fourPiEps);
            hardnessJ(i) = hardness(ei);
            b(i) = -ai.chi;
            for (size_t j = i + 1; j < numAtoms; ++j)
            {
                Atom const &aj = atoms.at(j);
                size_t const ej = aj.element;
                double const rij = (ai.r - aj.r).norm();
 
                A(i, j) = erf(rij / gammaSqrt2(ei, ej)) / (rij * fourPiEps);
                A(j, i) = A(i, j);
 
            }
        }
    }
#ifdef _OPENMP
#pragma omp single
    {
#endif
    A.col(numAtoms).setOnes();
    A.row(numAtoms).setOnes();
    A(numAtoms, numAtoms) = 0.0;
    hasAMatrix = true;
    b(numAtoms) = chargeRef;
#ifdef _OPENMP
    }
#endif
    //TODO: sometimes only recalculation of A matrix is needed, because
    //      Qs are stored.
    Q = A.colPivHouseholderQr().solve(b);
#ifdef _OPENMP
    #pragma omp for nowait
#endif
    for (size_t i = 0; i < numAtoms; ++i)
    {
        atoms.at(i).charge = Q(i);
    }
#ifdef _OPENMP
    } // end of parallel region
#endif
 
    lambda = Q(numAtoms);
    hasCharges = true;
    double error = (A * Q - b).norm() / b.norm();
 
    // We need matrix E not A, which only differ by the hardness terms along the diagonal
    energyElec = 0.5 * Q.head(numAtoms).transpose()
               * (A.topLeftCorner(numAtoms, numAtoms) -
                MatrixXd(hardnessJ.asDiagonal())) * Q.head(numAtoms);
    energyElec += calculateScreeningEnergy(gammaSqrt2, sigmaSqrtPi, fs, fourPiEps);
 
    return error;
}

References A, atoms, box, calculateScreeningEnergy(), chargeRef, nnp::Atom::chi, nnp::Atom::element, energyElec, nnp::EwaldParameters::eta, nnp::ErfcBuf::getf(), nnp::Atom::getStoredMinNumNeighbors(), hasAMatrix, hasCharges, isPeriodic, nnp::KspaceGrid::kvectors, lambda, NeighborListIsSorted, nnp::Atom::neighbors, numAtoms, nnp::EwaldSetup::params, nnp::Atom::r, nnp::EwaldParameters::rCut, nnp::ErfcBuf::reset(), and nnp::KspaceGrid::setup().

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

Here is the call graph for this function:

Here is the caller graph for this function:

calculateScreeningEnergy()

double Structure::calculateScreeningEnergy	(	Eigen::MatrixXd	gammaSqrt2,
		Eigen::VectorXd	sigmaSqrtPi,
		ScreeningFunction const &	fs,
		double const	fourPiEps
	)

Calculate screening energy which needs to be added (!) to the electrostatic energy in order to remove contributions in the short range domain.

Parameters

[in]	gammaSqrt2	Matrix combining gamma with prefactor. \( \text{gammaSqrt2}_{ij} = \sqrt{2} \gamma_{ij} = \sqrt{2} \sqrt{(\sigma_i^2 + \sigma_j^2)} \)
[in]	sigmaSqrtPi	Vector combining sigma with prefactor, \( \text{sigmaSqrtPi}_i = \sqrt{\pi} \sigma_i \)
[in]	fs	Screening function.
[in]	fourPiEps	\( \text{fourPiEps} = 4 \pi \varepsilon_0 \). Value depends on unit system (e.g. normalization).

Definition at line 746 of file Structure.cpp.

{
    double energyScreen = 0;
    double const rcutScreen = fs.getOuter();
 
#ifdef _OPENMP
    #pragma omp parallel
    {
        double localEnergyScreen = 0;
#endif
        if (isPeriodic)
        {
#ifdef _OPENMP
            #pragma omp for schedule(dynamic)
#endif
            for (size_t i = 0; i < numAtoms; ++i)
            {
                Atom const& ai = atoms.at(i);
                size_t const ei = ai.element;
                double const Qi = ai.charge;
#ifdef _OPENMP
                localEnergyScreen +=  -Qi * Qi
                                   / (2 * sigmaSqrtPi(ei) * fourPiEps);
#else
                energyScreen +=  -Qi * Qi
                              / (2 * sigmaSqrtPi(ei) * fourPiEps);
#endif
 
                size_t const numNeighbors = ai.getStoredMinNumNeighbors(rcutScreen);
                for (size_t k = 0; k < numNeighbors; ++k)
                {
                    auto const& n = ai.neighbors[k];
                    size_t const j = n.tag;
                    if (j < i) continue;
                    double const rij = n.d;
                    size_t const ej = n.element;
                    //TODO: Maybe add charge to neighbor class?
                    double const Qj = atoms.at(j).charge;
#ifdef _OPENMP
                    localEnergyScreen += Qi * Qj * erf(rij / gammaSqrt2(ei, ej))
                                    * (fs.f(rij) - 1) / (rij * fourPiEps);
#else
                    energyScreen += Qi * Qj * erf(rij / gammaSqrt2(ei, ej))
                                    * (fs.f(rij) - 1) / (rij * fourPiEps);
#endif
 
               }
            }
        }
        else
        {
#ifdef _OPENMP
            #pragma omp for schedule(dynamic)
#endif
            for (size_t i = 0; i < numAtoms; ++i)
            {
                Atom const& ai = atoms.at(i);
                size_t const ei = ai.element;
                double const Qi = ai.charge;
#ifdef _OPENMP
                localEnergyScreen +=  -Qi * Qi
                                   / (2 * sigmaSqrtPi(ei) * fourPiEps);
#else
                energyScreen +=  -Qi * Qi
                              / (2 * sigmaSqrtPi(ei) * fourPiEps);
#endif
 
                for (size_t j = i + 1; j < numAtoms; ++j)
                {
                    Atom const& aj = atoms.at(j);
                    double const Qj = aj.charge;
                    double const rij = (ai.r - aj.r).norm();
                    if ( rij < rcutScreen )
                    {
#ifdef _OPENMP
                        localEnergyScreen += Qi * Qj * A(i, j) * (fs.f(rij) - 1);
#else
                        energyScreen += Qi * Qj * A(i, j) * (fs.f(rij) - 1);
#endif
                    }
                }
            }
        }
#ifdef _OPENMP
        #pragma omp atomic
        energyScreen += localEnergyScreen;
    }
#endif
    //cout << "energyScreen = " << energyScreen << endl;
    return energyScreen;
}

References A, atoms, nnp::Atom::charge, nnp::Atom::element, nnp::ScreeningFunction::f(), nnp::ScreeningFunction::getOuter(), nnp::Atom::getStoredMinNumNeighbors(), isPeriodic, nnp::Atom::neighbors, numAtoms, and nnp::Atom::r.

Referenced by calculateElectrostaticEnergy().

Here is the call graph for this function:

Here is the caller graph for this function:

calculateDAdrQ()

void Structure::calculateDAdrQ	(	EwaldSetup &	ewaldSetup,
		Eigen::MatrixXd	gammaSqrt2,
		double const	fourPiEps,
		ErfcBuf &	erfcBuf
	)

Calculates derivative of A-matrix with respect to the atoms positions and contract it with Q.

Parameters

[in]	ewaldSetup	Settings of Ewald summation.
[in]	gammaSqrt2	Matrix combining gamma with prefactor. \( \text{gammaSqrt2}_{ij} = \sqrt{2} \gamma_{ij} = \sqrt{2} \sqrt{(\sigma_i^2 + \sigma_j^2)} \)
[in]	fourPiEps	\( \text{fourPiEps} = 4 \pi \varepsilon_0 \). Value depends on unit system (e.g. normalization).
[in]	erfcBuf	helper object to avoid repeated calculation of erfc().

Definition at line 844 of file Structure.cpp.

{
 
#ifdef _OPENMP
    vector<Vec3D> dAdrQDiag(numAtoms);
    #pragma omp parallel
    {
 
    #pragma omp declare reduction(vec_Vec3D_plus : std::vector<Vec3D> : \
                  std::transform(omp_out.begin(), omp_out.end(), omp_in.begin(), omp_out.begin(), std::plus<Vec3D>())) \
                  initializer(omp_priv = decltype(omp_orig)(omp_orig.size()))
    #pragma omp for
#endif
    // TODO: This initialization loop could probably be avoid, maybe use
    // default constructor?
    for (size_t i = 0; i < numAtoms; ++i)
    {
        Atom &ai = atoms.at(i);
        // dAdrQ(numAtoms+1,:) entries are zero
        ai.dAdrQ.resize(numAtoms + 1);
    }
 
    if (isPeriodic)
    {
        // TODO: We need same Kspace grid as in calculateScreeningEnergy, should
        // we cache it for reuse? Note that we can't calculate dAdrQ already in
        // the loops of calculateElectrostaticEnergy because at this point we don't
        // have the charges.
 
        KspaceGrid grid;
        grid.setup(box, ewaldSetup);
        double rcutReal = ewaldSetup.params.rCut;
        double const sqrt2eta = sqrt(2.0) * ewaldSetup.params.eta;
 
#ifdef _OPENMP
        // This way of parallelization slightly changes the result because of
        // numerical errors.
        #pragma omp for reduction(vec_Vec3D_plus : dAdrQDiag) schedule(dynamic)
#endif
        for (size_t i = 0; i < numAtoms; ++i)
        {
            Atom &ai = atoms.at(i);
            size_t const ei = ai.element;
            double const Qi = ai.charge;
 
            // real part
            size_t const numNeighbors = ai.getStoredMinNumNeighbors(rcutReal);
            for (size_t k = 0; k < numNeighbors; ++k)
            {
                auto const &n = ai.neighbors[k];
                size_t j = n.tag;
                //if (j < i) continue;
                if (j <= i) continue;
 
                double const rij = n.d;
                Atom &aj = atoms.at(j);
                size_t const ej = aj.element;
                double const Qj = aj.charge;
 
                double erfcSqrt2Eta = erfcBuf.getf(i, k, 0, rij / sqrt2eta);
                double erfcGammaSqrt2 =
                        erfcBuf.getf(i, k, 1, rij / gammaSqrt2(ei, ej));
 
                Vec3D dAijdri;
                dAijdri = n.dr / pow(rij, 2)
                          * (2 / sqrt(M_PI) * (-exp(-pow(rij / sqrt2eta, 2))
                          / sqrt2eta + exp(-pow(rij / gammaSqrt2(ei, ej), 2))
                          / gammaSqrt2(ei, ej)) - 1 / rij
                          * (erfcSqrt2Eta - erfcGammaSqrt2));
                dAijdri /= fourPiEps;
                // Make use of symmetry: dA_{ij}/dr_i = dA_{ji}/dr_i
                // = -dA_{ji}/dr_j = -dA_{ij}/dr_j
                ai.dAdrQ[i] += dAijdri * Qj;
                ai.dAdrQ[j] += dAijdri * Qi;
                aj.dAdrQ[i] -= dAijdri * Qj;
#ifdef _OPENMP
                dAdrQDiag[j] -= dAijdri * Qi;
#else
                aj.dAdrQ[j] -= dAijdri * Qi;
#endif
            }
 
            // reciprocal part
            for (size_t j = i + 1; j < numAtoms; ++j)
            {
                Atom &aj = atoms.at(j);
                double const Qj = aj.charge;
                Vec3D dAijdri;
                for (auto const &gv: grid.kvectors)
                {
                    // Multiply by 2 because our grid is only a half-sphere
                    //Vec3D const dr = applyMinimumImageConvention(ai.r - aj.r);
                    Vec3D const dr = ai.r - aj.r;
                    dAijdri -= 2 * gv.coeff * sin(gv.k * dr) * gv.k;
                }
                dAijdri /= fourPiEps;
 
                ai.dAdrQ[i] += dAijdri * Qj;
                ai.dAdrQ[j] += dAijdri * Qi;
                aj.dAdrQ[i] -= dAijdri * Qj;
#ifdef _OPENMP
                dAdrQDiag[j] -= dAijdri * Qi;
#else
                aj.dAdrQ[j] -= dAijdri * Qi;
#endif
            }
        }
 
    } else
    {
#ifdef _OPENMP
        #pragma omp for reduction(vec_Vec3D_plus : dAdrQDiag) schedule(dynamic)
#endif
        for (size_t i = 0; i < numAtoms; ++i)
        {
            Atom &ai = atoms.at(i);
            size_t const ei = ai.element;
            double const Qi = ai.charge;
 
            for (size_t j = i + 1; j < numAtoms; ++j)
            {
                Atom &aj = atoms.at(j);
                size_t const ej = aj.element;
                double const Qj = aj.charge;
 
                double rij = (ai.r - aj.r).norm();
                Vec3D dAijdri;
                dAijdri = (ai.r - aj.r) / pow(rij, 2)
                          * (2 / (sqrt(M_PI) * gammaSqrt2(ei, ej))
                             * exp(-pow(rij / gammaSqrt2(ei, ej), 2))
                             - erf(rij / gammaSqrt2(ei, ej)) / rij);
                dAijdri /= fourPiEps;
                // Make use of symmetry: dA_{ij}/dr_i = dA_{ji}/dr_i
                // = -dA_{ji}/dr_j = -dA_{ij}/dr_j
                ai.dAdrQ[i] += dAijdri * Qj;
                ai.dAdrQ[j] = dAijdri * Qi;
                aj.dAdrQ[i] = -dAijdri * Qj;
#ifdef _OPENMP
                dAdrQDiag[j] -= dAijdri * Qi;
#else
                aj.dAdrQ[j] -= dAijdri * Qi;
#endif
            }
        }
    }
#ifdef _OPENMP
    #pragma omp for
    for (size_t i = 0; i < numAtoms; ++i)
    {
        Atom& ai = atoms[i];
        ai.dAdrQ[i] += dAdrQDiag[i];
    }
    }
#endif
    return;
}

References atoms, box, nnp::Atom::charge, nnp::Atom::dAdrQ, nnp::Atom::element, nnp::EwaldParameters::eta, nnp::ErfcBuf::getf(), nnp::Atom::getStoredMinNumNeighbors(), isPeriodic, nnp::KspaceGrid::kvectors, nnp::Atom::neighbors, numAtoms, nnp::EwaldSetup::params, nnp::Atom::r, nnp::EwaldParameters::rCut, and nnp::KspaceGrid::setup().

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

Here is the call graph for this function:

Here is the caller graph for this function:

calculateDQdChi()

void Structure::calculateDQdChi

(

std::vector< Eigen::VectorXd > &

dQdChi

)

Calculates derivative of the charges with respect to electronegativities.

Parameters

[in]

dQdChi

vector to store the result. dQdChi[i](j) represents the derivative for the i-th electronegativity and the j-th charge.

Definition at line 1005 of file Structure.cpp.

{
    dQdChi.clear();
    dQdChi.reserve(numAtoms);
    for (size_t i = 0; i < numAtoms; ++i)
    {
        // Including Lagrange multiplier equation.
        VectorXd b(numAtoms+1);
        b.setZero();
        b(i) = -1.;
        dQdChi.push_back(A.colPivHouseholderQr().solve(b).head(numAtoms));
    }
    return;
}

References A, and numAtoms.

Referenced by nnp::Training::update().

Here is the caller graph for this function:

calculateDQdJ()

void Structure::calculateDQdJ

(

std::vector< Eigen::VectorXd > &

dQdJ

)

Calculates derivative of the charges with respect to atomic hardness.

Parameters

[in]

dQdJ

vector to store the result. dQdJ[i](j) represents the derivative for the i-th hardness and the j-th charge.

Definition at line 1020 of file Structure.cpp.

{
    dQdJ.clear();
    dQdJ.reserve(numElements);
    for (size_t i = 0; i < numElements; ++i)
    {
        // Including Lagrange multiplier equation.
        VectorXd b(numAtoms+1);
        b.setZero();
        for (size_t j = 0; j < numAtoms; ++j)
        {
            Atom const &aj = atoms.at(j);
            if (i == aj.element) b(j) = -aj.charge;
        }
        dQdJ.push_back(A.colPivHouseholderQr().solve(b).head(numAtoms));
    }
    return;
}

References A, atoms, nnp::Atom::charge, nnp::Atom::element, numAtoms, and numElements.

Referenced by nnp::Training::update().

Here is the caller graph for this function:

calculateDQdr()

void Structure::calculateDQdr	(	std::vector< size_t > const &	atomsIndices,
		std::vector< size_t > const &	compIndices,
		double const	maxCutoffRadius,
		std::vector< Element > const &	elements
	)

Calculates derivative of the charges with respect to the atom's position.

Parameters

[in]	atomIndices	Vector containing indices of atoms for which the derivative should be calculated.
[in]	compIndices	Vector containing indices of vector components for which the derivative should be calculated.
[in]	maxCutoffRadius	Max. cutoff radius of symmetry functions.
[in]	elements	Vector containing all elements (needed for symmetry function table).

Definition at line 1039 of file Structure.cpp.

{
    if (atomIndices.size() != compIndices.size())
        throw runtime_error("ERROR: In calculation of dQ/dr both atom index and"
                            " component index must be specified.");
    for (size_t i = 0; i < atomIndices.size(); ++i)
    {
        Atom& a = atoms.at(atomIndices[i]);
        if ( a.dAdrQ.size() == 0 )
            throw runtime_error("ERROR: dAdrQ needs to be calculated before "
                                "calculating dQdr");
        a.dQdr.resize(numAtoms);
 
        // b stores (-dChidr - dAdrQ), last element for charge conservation.
        VectorXd b(numAtoms + 1);
        b.setZero();
        for (size_t j = 0; j < numAtoms; ++j)
        {
            Atom const& aj = atoms.at(j);
 
#ifndef N2P2_FULL_SFD_MEMORY
            vector<vector<size_t> > const *const tableFull
                    = &(elements.at(aj.element).getSymmetryFunctionTable());
#else
            vector<vector<size_t> > const *const tableFull = nullptr;
#endif
            b(j) -= aj.calculateDChidr(atomIndices[i],
                                       maxCutoffRadius,
                                       tableFull)[compIndices[i]];
            b(j) -= a.dAdrQ.at(j)[compIndices[i]];
        }
        VectorXd dQdr = A.colPivHouseholderQr().solve(b).head(numAtoms);
        for (size_t j = 0; j < numAtoms; ++j)
        {
            a.dQdr.at(j)[compIndices[i]] = dQdr(j);
        }
    }
    return;
}

References A, atoms, nnp::Atom::calculateDChidr(), nnp::Atom::dAdrQ, nnp::Atom::dQdr, nnp::Atom::element, and numAtoms.

Referenced by nnp::Training::update().

Here is the call graph for this function:

Here is the caller graph for this function:

calculateElectrostaticEnergyDerivatives()

void Structure::calculateElectrostaticEnergyDerivatives	(	Eigen::VectorXd	hardness,
		Eigen::MatrixXd	gammaSqrt2,
		Eigen::VectorXd	sigmaSqrtPi,
		ScreeningFunction const &	fs,
		double const	fourPiEps
	)

Calculates partial derivatives of electrostatic Energy with respect to atom's coordinates and charges.

Parameters

[in]	hardness	Vector containing the hardness of all elements.
[in]	gammaSqrt2	Matrix combining gamma with prefactor. \( \text{gammaSqrt2}_{ij} = \sqrt{2} \gamma_{ij} = \sqrt{2} \sqrt{(\sigma_i^2 + \sigma_j^2)} \)
[in]	sigmaSqrtPi	Vector combining sigma with prefactor, \( \text{sigmaSqrtPi}_i = \sqrt{\pi} \sigma_i \)
[in]	fs	Screening function.
[in]	fourPiEps	\( \text{fourPiEps} = 4 \pi \varepsilon_0 \). Value depends on unit system (e.g. normalization).

Definition at line 1083 of file Structure.cpp.

{
    // Reset in case structure is used again (e.g. during training)
    for (Atom &ai : atoms)
    {
        ai.pEelecpr = Vec3D{};
        ai.dEelecdQ = 0.0;
    }
 
    double rcutScreen = fs.getOuter();
    for (size_t i = 0; i < numAtoms; ++i)
    {
        Atom& ai = atoms.at(i);
        size_t const ei = ai.element;
        double const Qi = ai.charge;
 
        // TODO: This loop could be reduced by making use of symmetry, j>=i or
        // so
        for (size_t j = 0; j < numAtoms; ++j)
        {
            Atom& aj = atoms.at(j);
            double const Qj = aj.charge;
 
            ai.pEelecpr += 0.5 * Qj * ai.dAdrQ[j];
 
            // Diagonal terms contain self-interaction --> screened
            if (i != j) ai.dEelecdQ += Qj * A(i,j);
            else if (isPeriodic)
            {
                ai.dEelecdQ += Qi * (A(i,i) - hardness(ei)
                                - 1 / (sigmaSqrtPi(ei) * fourPiEps));
            }
        }
 
        if (isPeriodic)
        {
            for (auto const& ajN : ai.neighbors)
            {
                size_t j = ajN.tag;
                Atom& aj = atoms.at(j);
                if (j < i) continue;
                double const rij = ajN.d;
                if (rij >= rcutScreen) break;
 
                size_t const ej = aj.element;
                double const Qj = atoms.at(j).charge;
 
                double erfRij = erf(rij / gammaSqrt2(ei,ej));
                double fsRij = fs.f(rij);
 
                // corrections due to screening
                Vec3D Tij = Qi * Qj * ajN.dr / pow(rij,2)
                                * (2 / (sqrt(M_PI) * gammaSqrt2(ei,ej))
                                * exp(- pow(rij / gammaSqrt2(ei,ej),2))
                                * (fsRij - 1) + erfRij * fs.df(rij) - erfRij
                                * (fsRij - 1) / rij);
                Tij /= fourPiEps;
                ai.pEelecpr += Tij;
                aj.pEelecpr -= Tij;
 
                double Sij = erfRij * (fsRij - 1) / rij;
                Sij /= fourPiEps;
                ai.dEelecdQ += Qj * Sij;
                aj.dEelecdQ += Qi * Sij;
            }
        }
        else
        {
            for (size_t j = i + 1; j < numAtoms; ++j)
            {
                Atom& aj = atoms.at(j);
                double const rij = (ai.r - aj.r).norm();
                if (rij >= rcutScreen) continue;
 
                size_t const ej = aj.element;
                double const Qj = atoms.at(j).charge;
 
                double erfRij = erf(rij / gammaSqrt2(ei,ej));
                double fsRij = fs.f(rij);
 
                // corrections due to screening
                Vec3D Tij = Qi * Qj * (ai.r - aj.r) / pow(rij,2)
                                * (2 / (sqrt(M_PI) * gammaSqrt2(ei,ej))
                                * exp(- pow(rij / gammaSqrt2(ei,ej),2))
                                * (fsRij - 1) + erfRij * fs.df(rij) - erfRij
                                * (fsRij - 1) / rij);
                Tij /= fourPiEps;
                ai.pEelecpr += Tij;
                aj.pEelecpr -= Tij;
 
                double Sij = erfRij * (fsRij - 1) / rij;
                Sij /= fourPiEps;
                ai.dEelecdQ += Qj * Sij;
                aj.dEelecdQ += Qi * Sij;
            }
        }
    }
   return;
}

References A, atoms, nnp::Atom::charge, nnp::Atom::dAdrQ, nnp::Atom::dEelecdQ, nnp::ScreeningFunction::df(), nnp::Atom::element, nnp::ScreeningFunction::f(), nnp::ScreeningFunction::getOuter(), isPeriodic, nnp::Atom::neighbors, numAtoms, nnp::Atom::pEelecpr, and nnp::Atom::r.

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

Here is the call graph for this function:

Here is the caller graph for this function:

calculateForceLambdaTotal()

VectorXd const Structure::calculateForceLambdaTotal

(

)

const

Calculate lambda_total vector which is needed for the total force calculation in 4G NN.

Definition at line 1188 of file Structure.cpp.

{
    VectorXd dEdQ(numAtoms+1);
    for (size_t i = 0; i < numAtoms; ++i)
    {
        Atom const& ai = atoms.at(i);
        dEdQ(i) = ai.dEelecdQ + ai.dEdG.back();
    }
    dEdQ(numAtoms) = 0;
    VectorXd const lambdaTotal = A.colPivHouseholderQr().solve(-dEdQ);
    return lambdaTotal;
}

References A, atoms, nnp::Atom::dEdG, nnp::Atom::dEelecdQ, and numAtoms.

Referenced by nnp::Mode::calculateForces(), and nnp::InterfaceLammps::getForces().

Here is the caller graph for this function:

calculateForceLambdaElec()

VectorXd const Structure::calculateForceLambdaElec

(

)

const

Calculate lambda_elec vector which is needed for the electrostatic force calculation in 4G NN.

Definition at line 1201 of file Structure.cpp.

{
    VectorXd dEelecdQ(numAtoms+1);
    for (size_t i = 0; i < numAtoms; ++i)
    {
        Atom const& ai = atoms.at(i);
        dEelecdQ(i) = ai.dEelecdQ;
    }
    dEelecdQ(numAtoms) = 0;
    VectorXd const lambdaElec = A.colPivHouseholderQr().solve(-dEelecdQ);
    return lambdaElec;
}

References A, atoms, nnp::Atom::dEelecdQ, and numAtoms.

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

Here is the caller graph for this function:

remap() [1/2]

void Structure::remap

(

)

Translate all atoms back into box if outside.

Definition at line 1214 of file Structure.cpp.

{
    for (vector<Atom>::iterator it = atoms.begin(); it != atoms.end(); ++it)
    {
        remap((*it));
    }
    return;
}

References atoms, and remap().

Referenced by nnp::Dataset::prepareNumericForces(), readFromLines(), and remap().

Here is the call graph for this function:

Here is the caller graph for this function:

remap() [2/2]

void Structure::remap

(

Atom &

atom

)

Translate atom back into box if outside.

Parameters

[in,out]

atom

Atom to be remapped.

Definition at line 1223 of file Structure.cpp.

{
    Vec3D f = atom.r[0] * invbox[0]
            + atom.r[1] * invbox[1]
            + atom.r[2] * invbox[2];
 
    // Quick and dirty... there may be a more elegant way!
    if (f[0] > 1.0) f[0] -= (int)f[0];
    if (f[1] > 1.0) f[1] -= (int)f[1];
    if (f[2] > 1.0) f[2] -= (int)f[2];
 
    if (f[0] < 0.0) f[0] += 1.0 - (int)f[0];
    if (f[1] < 0.0) f[1] += 1.0 - (int)f[1];
    if (f[2] < 0.0) f[2] += 1.0 - (int)f[2];
 
    if (f[0] == 1.0) f[0] = 0.0;
    if (f[1] == 1.0) f[1] = 0.0;
    if (f[2] == 1.0) f[2] = 0.0;
 
    atom.r = f[0] * box[0]
           + f[1] * box[1]
           + f[2] * box[2];
 
    return;
}

References box, invbox, and nnp::Atom::r.

toNormalizedUnits()

void Structure::toNormalizedUnits	(	double	meanEnergy,
		double	convEnergy,
		double	convLength,
		double	convCharge
	)

Normalize structure, shift energy and change energy, length and charge unit.

Parameters

[in]	meanEnergy	Mean energy per atom (in old units).
[in]	convEnergy	Multiplicative energy unit conversion factor.
[in]	convLength	Multiplicative length unit conversion factor.
[in]	convCharge	Multiplicative charge unit conversion factor.

Definition at line 1249 of file Structure.cpp.

{
    if (isPeriodic)
    {
        box[0] *= convLength;
        box[1] *= convLength;
        box[2] *= convLength;
        invbox[0] /= convLength;
        invbox[1] /= convLength;
        invbox[2] /= convLength;
    }
 
    energyRef = (energyRef - numAtoms * meanEnergy) * convEnergy;
    energy = (energy - numAtoms * meanEnergy) * convEnergy;
    chargeRef *= convCharge;
    charge *= convCharge;
    volume *= convLength * convLength * convLength;
 
    for (vector<Atom>::iterator it = atoms.begin(); it != atoms.end(); ++it)
    {
        it->toNormalizedUnits(convEnergy, convLength, convCharge);
    }
 
    return;
}

References atoms, box, charge, chargeRef, energy, energyRef, invbox, isPeriodic, numAtoms, and volume.

Referenced by nnp::Mode::convertToNormalizedUnits(), nnp::Prediction::readStructureFromFile(), and nnp::InterfaceLammps::writeToFile().

Here is the caller graph for this function:

toPhysicalUnits()

void Structure::toPhysicalUnits	(	double	meanEnergy,
		double	convEnergy,
		double	convLength,
		double	convCharge
	)

Switch to physical units, shift energy and change energy, length and charge unit.

Parameters

[in]	meanEnergy	Mean energy per atom (in old units).
[in]	convEnergy	Multiplicative energy unit conversion factor.
[in]	convLength	Multiplicative length unit conversion factor.
[in]	convCharge	Multiplicative charge unit conversion factor.

Definition at line 1278 of file Structure.cpp.

{
    if (isPeriodic)
    {
        box[0] /= convLength;
        box[1] /= convLength;
        box[2] /= convLength;
        invbox[0] *= convLength;
        invbox[1] *= convLength;
        invbox[2] *= convLength;
    }
 
    energyRef = energyRef / convEnergy + numAtoms * meanEnergy;
    energy = energy / convEnergy + numAtoms * meanEnergy;
    chargeRef /= convCharge;
    charge /= convCharge;
    volume /= convLength * convLength * convLength;
 
    for (vector<Atom>::iterator it = atoms.begin(); it != atoms.end(); ++it)
    {
        it->toPhysicalUnits(convEnergy, convLength, convCharge);
    }
 
    return;
}

References atoms, box, charge, chargeRef, energy, energyRef, invbox, isPeriodic, numAtoms, and volume.

Referenced by nnp::Mode::convertToPhysicalUnits(), nnp::Prediction::predict(), and nnp::InterfaceLammps::writeToFile().

Here is the caller graph for this function:

getMaxNumNeighbors()

size_t Structure::getMaxNumNeighbors

(

)

const

Find maximum number of neighbors.

Returns

Maximum numbor of neighbors of all atoms in this structure.

Definition at line 473 of file Structure.cpp.

{
    size_t maxNumNeighbors = 0;
 
    for(vector<Atom>::const_iterator it = atoms.begin();
        it != atoms.end(); ++it)
    {
        maxNumNeighbors = max(maxNumNeighbors, it->numNeighbors);
    }
 
    return maxNumNeighbors;
}

References atoms.

freeAtoms()

void Structure::freeAtoms	(	bool	all,
		double const	maxCutoffRadius = 0.0
	)

Free symmetry function memory for all atoms, see free() in Atom class.

Parameters

[in]	all	See description in Atom.
[in]	maxCutoffRadius	Maximum cutoff radius of symmetry functions.

Definition at line 1307 of file Structure.cpp.

{
    for (vector<Atom>::iterator it = atoms.begin(); it != atoms.end(); ++it)
    {
        it->free(all, maxCutoffRadius);
    }
    if (all) hasSymmetryFunctions = false;
    hasSymmetryFunctionDerivatives = false;
 
    return;
}

References atoms, hasSymmetryFunctionDerivatives, and hasSymmetryFunctions.

Referenced by nnp::Training::update().

Here is the caller graph for this function:

reset()

void Structure::reset

(

)

Reset everything but elementMap.

Definition at line 1319 of file Structure.cpp.

{
    isPeriodic                     = false     ;
    isTriclinic                    = false     ;
    hasNeighborList                = false     ;
    hasSymmetryFunctions           = false     ;
    hasSymmetryFunctionDerivatives = false     ;
    index                          = 0         ;
    numAtoms                       = 0         ;
    numElementsPresent             = 0         ;
    energy                         = 0.0       ;
    energyRef                      = 0.0       ;
    charge                         = 0.0       ;
    chargeRef                      = 0.0       ;
    volume                         = 0.0       ;
    sampleType                     = ST_UNKNOWN;
    comment                        = ""        ;
 
    for (size_t i = 0; i < 3; ++i)
    {
        pbc[i] = 0;
        for (size_t j = 0; j < 3; ++j)
        {
            box[i][j] = 0.0;
            invbox[i][j] = 0.0;
        }
    }
 
    numElements = elementMap.size();
    numAtomsPerElement.clear();
    numAtomsPerElement.resize(numElements, 0);
    atoms.clear();
    vector<Atom>(atoms).swap(atoms);
 
    return;
}

References atoms, box, charge, chargeRef, comment, elementMap, energy, energyRef, hasNeighborList, hasSymmetryFunctionDerivatives, hasSymmetryFunctions, index, invbox, isPeriodic, isTriclinic, numAtoms, numAtomsPerElement, numElements, numElementsPresent, pbc, sampleType, nnp::ElementMap::size(), ST_UNKNOWN, and volume.

Referenced by LAMMPS_NS::PairHDNNPExternal::compute(), main(), and nnp::Prediction::readStructureFromFile().

Here is the call graph for this function:

Here is the caller graph for this function:

clearNeighborList()

void Structure::clearNeighborList

(

)

Clear neighbor list of all atoms.

Definition at line 1356 of file Structure.cpp.

{
    for (size_t i = 0; i < numAtoms; i++)
    {
        Atom& a = atoms.at(i);
        // This may have changed if atoms are added via addAtoms().
        a.numNeighborsPerElement.resize(numElements, 0);
        a.clearNeighborList();
    }
    hasNeighborList = false;
    hasSymmetryFunctions = false;
    hasSymmetryFunctionDerivatives = false;
 
    return;
}

References atoms, nnp::Atom::clearNeighborList(), hasNeighborList, hasSymmetryFunctionDerivatives, hasSymmetryFunctions, numAtoms, numElements, and nnp::Atom::numNeighborsPerElement.

Here is the call graph for this function:

clearElectrostatics()

void Structure::clearElectrostatics

(

bool

clearDQdr = false

)

Clear A-matrix, dAdrQ and optionally dQdr.

Parameters

[in]

clearDqdr

Specify if dQdr should also be cleared.

Definition at line 1372 of file Structure.cpp.

{
    A.resize(0,0);
    hasAMatrix = false;
    for (auto& a : atoms)
    {
        vector<Vec3D>().swap(a.dAdrQ);
        if (clearDQdr)
        {
            vector<Vec3D>().swap(a.dQdr);
        }
    }
}

References A, atoms, and hasAMatrix.

Referenced by nnp::Training::update().

Here is the caller graph for this function:

updateError()

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

Update property error metrics with this structure.

Parameters

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

The "energy" error metric map stores temporary sums for the following metrics:

key "RMSEpa": RMSE of energy per atom key "RMSE" : RMSE of energy key "MAEpa" : MAE of energy per atom key "MAE" : MAE of energy

The "force" error metric map stores temporary sums for the following metrics:

key "RMSE" : RMSE of forces key "MAE" : MAE of forces

The "charge" error metric map stores temporary sums for the following metrics:

key "RMSE" : RMSE of charges key "MAE" : MAE of charges

Definition at line 1386 of file Structure.cpp.

{
    if (property == "energy")
    {
        count++;
        double diff = energyRef - energy;
        error.at("RMSEpa") += diff * diff / (numAtoms * numAtoms);
        error.at("RMSE") += diff * diff;
        diff = fabs(diff);
        error.at("MAEpa") += diff / numAtoms;
        error.at("MAE") += diff;
    }
    else if (property == "force" || property == "charge")
    {
        for (vector<Atom>::const_iterator it = atoms.begin();
             it != atoms.end(); ++it)
        {
            it->updateError(property, error, count);
        }
    }
    else
    {
        throw runtime_error("ERROR: Unknown property for error update.\n");
    }
 
    return;
}

References atoms, energy, energyRef, and numAtoms.

getEnergyLine()

string Structure::getEnergyLine

(

)

const

Get reference and NN energy.

Returns

String with index, energyRef and energy values.

Definition at line 1416 of file Structure.cpp.

{
    return strpr("%10zu %16.8E %16.8E\n",
                 index,
                 energyRef / numAtoms,
                 energy / numAtoms);
}

References energy, energyRef, index, numAtoms, and nnp::strpr().

Here is the call graph for this function:

getForcesLines()

vector< string > Structure::getForcesLines

(

)

const

Get reference and NN forces for all atoms.

Returns

Vector of strings with force comparison.

Definition at line 1424 of file Structure.cpp.

{
    vector<string> v;
    for (vector<Atom>::const_iterator it = atoms.begin();
         it != atoms.end(); ++it)
    {
        vector<string> va = it->getForcesLines();
        v.insert(v.end(), va.begin(), va.end());
    }
 
    return v;
}

References atoms.

getChargesLines()

vector< string > Structure::getChargesLines

(

)

const

Get reference and NN charges for all atoms.

Returns

Vector of strings with charge comparison.

Definition at line 1437 of file Structure.cpp.

{
    vector<string> v;
    for (vector<Atom>::const_iterator it = atoms.begin();
         it != atoms.end(); ++it)
    {
        v.push_back(it->getChargeLine());
    }
 
    return v;
}

References atoms.

writeToFile() [1/2]

void Structure::writeToFile	(	std::string const	fileName = "output.data",
		bool const	ref = true,
		bool const	append = false
	)		const

Write configuration to file.

Parameters

[in,out]	fileName	Ouptut file name.
[in]	ref	If true, write reference energy and forces, if false, write NNP results instead.
[in]	append	If true, append to existing file.

Definition at line 1449 of file Structure.cpp.

{
    ofstream file;
 
    if (append)
    {
        file.open(fileName.c_str(), ofstream::app);
    }
    else
    {
        file.open(fileName.c_str());
    }
    if (!file.is_open())
    {
        throw runtime_error("ERROR: Could not open file: \"" + fileName
                            + "\".\n");
    }
    writeToFile(&file, ref );
    file.close();
 
    return;
}

References writeToFile().

Referenced by LAMMPS_NS::PairHDNNPExternal::compute(), main(), nnp::InterfaceLammps::writeToFile(), and writeToFile().

Here is the call graph for this function:

Here is the caller graph for this function:

writeToFile() [2/2]

void Structure::writeToFile	(	std::ofstream *const &	file,
		bool const	ref = true
	)		const

Write configuration to file.

Parameters

[in,out]	file	Ouptut file.
[in]	ref	If true, write reference energy and forces, if false, write NNP results instead.

Definition at line 1474 of file Structure.cpp.

{
    if (!file->is_open())
    {
        runtime_error("ERROR: Cannot write to file, file is not open.\n");
    }
 
    (*file) << "begin\n";
    (*file) << strpr("comment %s\n", comment.c_str());
    if (isPeriodic)
    {
        for (size_t i = 0; i < 3; ++i)
        {
            (*file) << strpr("lattice %24.16E %24.16E %24.16E\n",
                             box[i][0], box[i][1], box[i][2]);
        }
    }
    for (vector<Atom>::const_iterator it = atoms.begin();
         it != atoms.end(); ++it)
    {
        if (ref)
        {
            (*file) << strpr("atom %24.16E %24.16E %24.16E %2s %24.16E %24.16E"
                             " %24.16E %24.16E %24.16E\n",
                             it->r[0],
                             it->r[1],
                             it->r[2],
                             elementMap[it->element].c_str(),
                             it->chargeRef,
                             0.0,
                             it->fRef[0],
                             it->fRef[1],
                             it->fRef[2]);
        }
        else
        {
            (*file) << strpr("atom %24.16E %24.16E %24.16E %2s %24.16E %24.16E"
                             " %24.16E %24.16E %24.16E\n",
                             it->r[0],
                             it->r[1],
                             it->r[2],
                             elementMap[it->element].c_str(),
                             it->charge,
                             0.0,
                             it->f[0],
                             it->f[1],
                             it->f[2]);
 
        }
    }
    if (ref) (*file) << strpr("energy %24.16E\n", energyRef);
    else     (*file) << strpr("energy %24.16E\n", energy);
    if (ref) (*file) << strpr("charge %24.16E\n", chargeRef);
    else     (*file) << strpr("charge %24.16E\n", charge);
    (*file) << strpr("end\n");
 
    return;
}

References atoms, box, charge, chargeRef, comment, elementMap, energy, energyRef, isPeriodic, and nnp::strpr().

Here is the call graph for this function:

writeToFileXyz()

void Structure::writeToFileXyz

(

std::ofstream *const &

file

)

const

Write configuration to xyz file.

Parameters

[in,out]

file

xyz output file.

Definition at line 1533 of file Structure.cpp.

{
    if (!file->is_open())
    {
        runtime_error("ERROR: Could not write to file.\n");
    }
 
    (*file) << strpr("%d\n", numAtoms);
    if (isPeriodic)
    {
        (*file) << "Lattice=\"";
        (*file) << strpr("%24.16E %24.16E %24.16E "   ,
                         box[0][0], box[0][1], box[0][2]);
        (*file) << strpr("%24.16E %24.16E %24.16E "   ,
                         box[1][0], box[1][1], box[1][2]);
        (*file) << strpr("%24.16E %24.16E %24.16E\"\n",
                         box[2][0], box[2][1], box[2][2]);
    }
    else
    {
        (*file) << "\n";
    }
    for (vector<Atom>::const_iterator it = atoms.begin();
         it != atoms.end(); ++it)
    {
        (*file) << strpr("%-2s %24.16E %24.16E %24.16E\n",
                         elementMap[it->element].c_str(),
                         it->r[0],
                         it->r[1],
                         it->r[2]);
    }
 
    return;
}

References atoms, box, elementMap, isPeriodic, numAtoms, and nnp::strpr().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

writeToFilePoscar() [1/2]

void Structure::writeToFilePoscar

(

std::ofstream *const &

file

)

const

Write configuration to POSCAR file.

Parameters

[in,out]

file

POSCAR output file.

Warning

Elements in POTCAR file must be ordered according to periodic table.

Definition at line 1568 of file Structure.cpp.

{
    writeToFilePoscar(file, elementMap.getElementsString());
 
    return;
}

References elementMap, nnp::ElementMap::getElementsString(), and writeToFilePoscar().

Referenced by main(), and writeToFilePoscar().

Here is the call graph for this function:

Here is the caller graph for this function:

writeToFilePoscar() [2/2]

void Structure::writeToFilePoscar	(	std::ofstream *const &	file,
		std::string const	elements
	)		const

Write configuration to POSCAR file.

Parameters

[in,out]	file	POSCAR output file.
[in,out]	elements	User-defined order of elements, e.g. "Zn O Cu".

Definition at line 1575 of file Structure.cpp.

{
    if (!file->is_open())
    {
        runtime_error("ERROR: Could not write to file.\n");
    }
 
    vector<string> ve = split(elements);
    vector<size_t> elementOrder;
    for (size_t i = 0; i < ve.size(); ++i)
    {
        elementOrder.push_back(elementMap[ve.at(i)]);
    }
    if (elementOrder.size() != elementMap.size())
    {
        runtime_error("ERROR: Inconsistent element declaration.\n");
    }
 
    (*file) << strpr("%s, ", comment.c_str());
    (*file) << strpr("ATOM=%s", elementMap[elementOrder.at(0)].c_str());
    for (size_t i = 1; i < elementOrder.size(); ++i)
    {
        (*file) << strpr(" %s", elementMap[elementOrder.at(i)].c_str());
    }
    (*file) << "\n";
    (*file) << "1.0\n";
    if (isPeriodic)
    {
        (*file) << strpr("%24.16E %24.16E %24.16E\n",
                         box[0][0], box[0][1], box[0][2]);
        (*file) << strpr("%24.16E %24.16E %24.16E\n",
                         box[1][0], box[1][1], box[1][2]);
        (*file) << strpr("%24.16E %24.16E %24.16E\n",
                         box[2][0], box[2][1], box[2][2]);
    }
    else
    {
        runtime_error("ERROR: Writing non-periodic structure to POSCAR file "
                      "is not implemented.\n");
    }
    (*file) << strpr("%d", numAtomsPerElement.at(elementOrder.at(0)));
    for (size_t i = 1; i < numAtomsPerElement.size(); ++i)
    {
        (*file) << strpr(" %d", numAtomsPerElement.at(elementOrder.at(i)));
    }
    (*file) << "\n";
    (*file) << "Cartesian\n";
    for (size_t i = 0; i < elementOrder.size(); ++i)
    {
        for (vector<Atom>::const_iterator it = atoms.begin();
             it != atoms.end(); ++it)
        {
            if (it->element == elementOrder.at(i))
            {
                (*file) << strpr("%24.16E %24.16E %24.16E\n",
                                 it->r[0],
                                 it->r[1],
                                 it->r[2]);
            }
        }
    }
 
    return;
}

References atoms, box, comment, elementMap, isPeriodic, numAtomsPerElement, nnp::ElementMap::size(), nnp::split(), and nnp::strpr().

Here is the call graph for this function:

info()

vector< string > Structure::info

(

)

const

Get structure information as a vector of strings.

Returns

Lines with structure information.

Definition at line 1641 of file Structure.cpp.

{
    vector<string> v;
 
    v.push_back(strpr("********************************\n"));
    v.push_back(strpr("STRUCTURE                       \n"));
    v.push_back(strpr("********************************\n"));
    vector<string> vm = elementMap.info();
    v.insert(v.end(), vm.begin(), vm.end());
    v.push_back(strpr("index                          : %d\n", index));
    v.push_back(strpr("isPeriodic                     : %d\n", isPeriodic        ));
    v.push_back(strpr("isTriclinic                    : %d\n", isTriclinic       ));
    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("numAtoms                       : %d\n", numAtoms          ));
    v.push_back(strpr("numElements                    : %d\n", numElements       ));
    v.push_back(strpr("numElementsPresent             : %d\n", numElementsPresent));
    v.push_back(strpr("pbc                            : %d %d %d\n", pbc[0], pbc[1], pbc[2]));
    v.push_back(strpr("energy                         : %16.8E\n", energy        ));
    v.push_back(strpr("energyRef                      : %16.8E\n", energyRef     ));
    v.push_back(strpr("charge                         : %16.8E\n", charge        ));
    v.push_back(strpr("chargeRef                      : %16.8E\n", chargeRef     ));
    v.push_back(strpr("volume                         : %16.8E\n", volume        ));
    v.push_back(strpr("sampleType                     : %d\n", (int)sampleType));
    v.push_back(strpr("comment                        : %s\n", comment.c_str()   ));
    v.push_back(strpr("box[0]                         : %16.8E %16.8E %16.8E\n", box[0][0], box[0][1], box[0][2]));
    v.push_back(strpr("box[1]                         : %16.8E %16.8E %16.8E\n", box[1][0], box[1][1], box[1][2]));
    v.push_back(strpr("box[2]                         : %16.8E %16.8E %16.8E\n", box[2][0], box[2][1], box[2][2]));
    v.push_back(strpr("invbox[0]                      : %16.8E %16.8E %16.8E\n", invbox[0][0], invbox[0][1], invbox[0][2]));
    v.push_back(strpr("invbox[1]                      : %16.8E %16.8E %16.8E\n", invbox[1][0], invbox[1][1], invbox[1][2]));
    v.push_back(strpr("invbox[2]                      : %16.8E %16.8E %16.8E\n", invbox[2][0], invbox[2][1], invbox[2][2]));
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("numAtomsPerElement         [*] : %d\n", numAtomsPerElement.size()));
    v.push_back(strpr("--------------------------------\n"));
    for (size_t i = 0; i < numAtomsPerElement.size(); ++i)
    {
        v.push_back(strpr("%29d  : %d\n", i, numAtomsPerElement.at(i)));
    }
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("atoms                      [*] : %d\n", atoms.size()));
    v.push_back(strpr("--------------------------------\n"));
    for (size_t i = 0; i < atoms.size(); ++i)
    {
        v.push_back(strpr("%29d  :\n", i));
        vector<string> va = atoms[i].info();
        v.insert(v.end(), va.begin(), va.end());
    }
    v.push_back(strpr("--------------------------------\n"));
    v.push_back(strpr("********************************\n"));
 
    return v;
}

References atoms, box, charge, chargeRef, comment, elementMap, energy, energyRef, hasNeighborList, hasSymmetryFunctionDerivatives, hasSymmetryFunctions, index, nnp::ElementMap::info(), invbox, isPeriodic, isTriclinic, numAtoms, numAtomsPerElement, numElements, numElementsPresent, pbc, sampleType, nnp::strpr(), and volume.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

elementMap

ElementMap nnp::Structure::elementMap

Copy of element map provided as constructor argument.

Definition at line 59 of file Structure.h.

Referenced by addAtom(), info(), readFromLines(), reset(), setElementMap(), writeToFile(), writeToFilePoscar(), and writeToFileXyz().

isPeriodic

bool nnp::Structure::isPeriodic

If periodic boundary conditions apply.

Definition at line 61 of file Structure.h.

Referenced by calculateDAdrQ(), calculateElectrostaticEnergy(), calculateElectrostaticEnergyDerivatives(), calculateMaxCutoffRadiusOverall(), calculateNeighborList(), calculateScreeningEnergy(), LAMMPS_NS::PairHDNNPExternal::compute(), info(), main(), nnp::Dataset::prepareNumericForces(), readFromLines(), nnp::Dataset::recvStructure(), reset(), nnp::Dataset::sendStructure(), nnp::InterfaceLammps::setBoxVectors(), toNormalizedUnits(), toPhysicalUnits(), writeToFile(), writeToFilePoscar(), and writeToFileXyz().

isTriclinic

bool nnp::Structure::isTriclinic

If the simulation box is triclinic.

Definition at line 63 of file Structure.h.

Referenced by LAMMPS_NS::PairHDNNPExternal::compute(), info(), readFromLines(), nnp::Dataset::recvStructure(), reset(), nnp::Dataset::sendStructure(), and nnp::InterfaceLammps::setBoxVectors().

hasNeighborList

bool nnp::Structure::hasNeighborList

If the neighbor list has been calculated.

Definition at line 65 of file Structure.h.

Referenced by calculateNeighborList(), clearNeighborList(), info(), nnp::Dataset::recvStructure(), reset(), nnp::Dataset::sendStructure(), and nnp::InterfaceLammps::setLocalAtoms().

NeighborListIsSorted

bool nnp::Structure::NeighborListIsSorted

If the neighbor list has been sorted by distance.

Definition at line 67 of file Structure.h.

Referenced by calculateElectrostaticEnergy(), setupNeighborCutoffMap(), and sortNeighborList().

hasSymmetryFunctions

bool nnp::Structure::hasSymmetryFunctions

If symmetry function values are saved for each atom.

Definition at line 69 of file Structure.h.

Referenced by nnp::Mode::calculateSymmetryFunctionGroups(), nnp::Mode::calculateSymmetryFunctions(), clearNeighborList(), freeAtoms(), info(), nnp::Dataset::recvStructure(), reset(), nnp::Dataset::sendStructure(), and nnp::InterfaceLammps::setLocalAtoms().

hasSymmetryFunctionDerivatives

bool nnp::Structure::hasSymmetryFunctionDerivatives

If symmetry function derivatives are saved for each atom.

Definition at line 71 of file Structure.h.

Referenced by nnp::Mode::calculateSymmetryFunctionGroups(), nnp::Mode::calculateSymmetryFunctions(), clearNeighborList(), freeAtoms(), info(), nnp::Dataset::recvStructure(), reset(), nnp::Dataset::sendStructure(), and nnp::InterfaceLammps::setLocalAtoms().

index

std::size_t nnp::Structure::index

Index number of this structure.

Definition at line 73 of file Structure.h.

Referenced by addAtom(), nnp::Dataset::distributeStructures(), getEnergyLine(), info(), main(), readFromLines(), nnp::Dataset::recvStructure(), reset(), nnp::Training::selectSets(), nnp::Dataset::sendStructure(), and nnp::InterfaceLammps::setLocalAtoms().

numAtoms

std::size_t nnp::Structure::numAtoms

Total number of atoms present in this structure.

Definition at line 75 of file Structure.h.

Referenced by addAtom(), nnp::InterfaceLammps::allocateNeighborlists(), nnp::Training::calculateChargeErrorVec(), calculateDAdrQ(), calculateDQdChi(), calculateDQdJ(), calculateDQdr(), calculateElectrostaticEnergy(), calculateElectrostaticEnergyDerivatives(), calculateForceLambdaElec(), calculateForceLambdaTotal(), nnp::Mode::calculateForces(), calculateMaxCutoffRadiusOverall(), calculateNeighborList(), calculateScreeningEnergy(), clearNeighborList(), LAMMPS_NS::PairHDNNPExternal::compute(), nnp::Training::dPdc(), nnp::Training::dPdcN(), nnp::InterfaceLammps::getCharges(), getEnergyLine(), nnp::InterfaceLammps::getForces(), info(), main(), nnp::Mode::normalizedEnergy(), nnp::Mode::physicalEnergy(), nnp::Dataset::prepareNumericForces(), readFromLines(), nnp::Dataset::recvStructure(), reset(), nnp::Training::selectSets(), nnp::Dataset::sendStructure(), nnp::InterfaceLammps::setLocalAtomPositions(), nnp::InterfaceLammps::setLocalAtoms(), sortNeighborList(), nnp::Training::sortUpdateCandidates(), toNormalizedUnits(), toPhysicalUnits(), nnp::Training::update(), updateError(), and writeToFileXyz().

numElements

std::size_t nnp::Structure::numElements

Global number of elements (all structures).

Definition at line 77 of file Structure.h.

Referenced by calculateDQdJ(), clearNeighborList(), info(), main(), readFromLines(), nnp::Dataset::recvStructure(), reset(), nnp::Dataset::sendStructure(), and setElementMap().

numElementsPresent

std::size_t nnp::Structure::numElementsPresent

Number of elements present in this structure.

Definition at line 79 of file Structure.h.

Referenced by info(), readFromLines(), nnp::Dataset::recvStructure(), reset(), and nnp::Dataset::sendStructure().

pbc

int nnp::Structure::pbc[3]

Number of PBC images necessary in each direction for max cut-off.

Definition at line 81 of file Structure.h.

Referenced by calculateNeighborList(), calculatePbcCopies(), info(), nnp::Dataset::recvStructure(), reset(), nnp::Dataset::sendStructure(), and Structure().

energy

double nnp::Structure::energy

Potential energy determined by neural network.

Definition at line 83 of file Structure.h.

Referenced by nnp::Mode::addEnergyOffset(), nnp::Mode::calculateEnergy(), nnp::Training::dPdcN(), nnp::InterfaceLammps::getEnergy(), getEnergyLine(), nnp::Mode::getEnergyWithOffset(), info(), main(), nnp::Mode::normalizedEnergy(), nnp::Mode::physicalEnergy(), nnp::InterfaceLammps::process(), nnp::Dataset::recvStructure(), nnp::Mode::removeEnergyOffset(), reset(), nnp::Dataset::sendStructure(), nnp::InterfaceLammps::setLocalAtoms(), nnp::Training::sortUpdateCandidates(), toNormalizedUnits(), toPhysicalUnits(), nnp::Training::update(), updateError(), and writeToFile().

energyRef

double nnp::Structure::energyRef

Reference potential energy.

Definition at line 85 of file Structure.h.

Referenced by nnp::Mode::addEnergyOffset(), getEnergyLine(), nnp::Mode::getEnergyWithOffset(), info(), main(), nnp::Mode::normalizedEnergy(), nnp::Mode::physicalEnergy(), readFromLines(), nnp::Dataset::recvStructure(), nnp::Mode::removeEnergyOffset(), reset(), nnp::Dataset::sendStructure(), nnp::Training::sortUpdateCandidates(), toNormalizedUnits(), toPhysicalUnits(), nnp::Training::update(), updateError(), and writeToFile().

energyShort

double nnp::Structure::energyShort

Short-range part of the potential energy predicted by NNP.

Definition at line 88 of file Structure.h.

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

energyElec

double nnp::Structure::energyElec

Electrostatics part of the potential energy predicted by NNP.

Definition at line 91 of file Structure.h.

Referenced by calculateElectrostaticEnergy(), nnp::Mode::calculateEnergy(), and main().

hasCharges

bool nnp::Structure::hasCharges

If all charges of this structure have been calculated (and stay the same, e.g.

for stage 2).

Definition at line 94 of file Structure.h.

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

charge

double nnp::Structure::charge

Charge determined by neural network potential.

Definition at line 96 of file Structure.h.

Referenced by nnp::Mode::calculateCharge(), info(), main(), nnp::Dataset::recvStructure(), reset(), nnp::Dataset::sendStructure(), toNormalizedUnits(), toPhysicalUnits(), and writeToFile().

chargeRef

double nnp::Structure::chargeRef

Reference charge.

Definition at line 98 of file Structure.h.

Referenced by calculateElectrostaticEnergy(), info(), main(), readFromLines(), nnp::Dataset::recvStructure(), reset(), nnp::Dataset::sendStructure(), toNormalizedUnits(), toPhysicalUnits(), and writeToFile().

volume

double nnp::Structure::volume

Simulation box volume.

Definition at line 100 of file Structure.h.

Referenced by calculateMaxCutoffRadiusOverall(), calculateVolume(), info(), main(), nnp::Dataset::recvStructure(), reset(), nnp::Dataset::sendStructure(), toNormalizedUnits(), and toPhysicalUnits().

maxCutoffRadiusOverall

double nnp::Structure::maxCutoffRadiusOverall

Maximum cut-off radius with respect to symmetry functions, screening function and Ewald summation.

Definition at line 103 of file Structure.h.

Referenced by calculateMaxCutoffRadiusOverall(), calculateNeighborList(), nnp::InterfaceLammps::getMaxCutoffRadiusOverall(), and setupNeighborCutoffMap().

lambda

double nnp::Structure::lambda

Lagrange multiplier used for charge equilibration.

Definition at line 106 of file Structure.h.

Referenced by calculateElectrostaticEnergy().

sampleType

SampleType nnp::Structure::sampleType

Sample type (training or test set).

Definition at line 108 of file Structure.h.

Referenced by info(), readFromLines(), nnp::Dataset::recvStructure(), reset(), nnp::Training::selectSets(), and nnp::Dataset::sendStructure().

comment

std::string nnp::Structure::comment

Structure comment.

Definition at line 110 of file Structure.h.

Referenced by nnp::Dataset::calculateBufferSize(), info(), main(), nnp::Dataset::prepareNumericForces(), readFromLines(), nnp::Dataset::recvStructure(), reset(), nnp::Dataset::sendStructure(), writeToFile(), and writeToFilePoscar().

box

Vec3D nnp::Structure::box[3]

Simulation box vectors.

Definition at line 112 of file Structure.h.

Referenced by applyMinimumImageConvention(), calculateDAdrQ(), calculateElectrostaticEnergy(), calculateInverseBox(), calculateNeighborList(), calculatePbcCopies(), calculateVolume(), canMinimumImageConventionBeApplied(), LAMMPS_NS::PairHDNNPExternal::compute(), info(), main(), readFromLines(), nnp::Dataset::recvStructure(), remap(), reset(), nnp::Dataset::sendStructure(), nnp::InterfaceLammps::setBoxVectors(), Structure(), toNormalizedUnits(), toPhysicalUnits(), writeToFile(), writeToFilePoscar(), and writeToFileXyz().

invbox

Vec3D nnp::Structure::invbox[3]

Inverse simulation box vectors.

Definition at line 114 of file Structure.h.

Referenced by applyMinimumImageConvention(), calculateInverseBox(), info(), nnp::Dataset::recvStructure(), remap(), reset(), nnp::Dataset::sendStructure(), Structure(), toNormalizedUnits(), and toPhysicalUnits().

A

Eigen::MatrixXd nnp::Structure::A

Global charge equilibration matrix A'.

Definition at line 116 of file Structure.h.

Referenced by calculateDQdChi(), calculateDQdJ(), calculateDQdr(), calculateElectrostaticEnergy(), calculateElectrostaticEnergyDerivatives(), calculateForceLambdaElec(), calculateForceLambdaTotal(), calculateScreeningEnergy(), and clearElectrostatics().

hasAMatrix

bool nnp::Structure::hasAMatrix

If A matrix of this structure is currently stored.

Definition at line 118 of file Structure.h.

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

numAtomsPerElement

std::vector<std::size_t> nnp::Structure::numAtomsPerElement

Number of atoms of each element in this structure.

Definition at line 120 of file Structure.h.

Referenced by addAtom(), nnp::Mode::addEnergyOffset(), nnp::Dataset::calculateBufferSize(), nnp::Mode::getEnergyOffset(), nnp::Mode::getEnergyWithOffset(), info(), main(), readFromLines(), nnp::Dataset::recvStructure(), nnp::Mode::removeEnergyOffset(), reset(), nnp::Training::selectSets(), nnp::Dataset::sendStructure(), setElementMap(), nnp::InterfaceLammps::setLocalAtoms(), nnp::Training::update(), and writeToFilePoscar().

atoms

std::vector<Atom> nnp::Structure::atoms

Vector of all atoms in this structure.

Definition at line 122 of file Structure.h.

Referenced by addAtom(), nnp::InterfaceLammps::addNeighbor(), nnp::InterfaceLammps::allocateNeighborlists(), nnp::Mode::calculateAtomicNeuralNetworks(), nnp::Dataset::calculateBufferSize(), nnp::Mode::calculateCharge(), nnp::Training::calculateChargeErrorVec(), calculateDAdrQ(), calculateDQdJ(), calculateDQdr(), calculateElectrostaticEnergy(), calculateElectrostaticEnergyDerivatives(), nnp::Mode::calculateEnergy(), calculateForceLambdaElec(), calculateForceLambdaTotal(), nnp::Mode::calculateForces(), calculateNeighborList(), calculateScreeningEnergy(), nnp::Mode::calculateSymmetryFunctionGroups(), nnp::Mode::calculateSymmetryFunctions(), nnp::Training::calculateWeightDerivatives(), clearElectrostatics(), clearNeighborList(), LAMMPS_NS::PairHDNNPExternal::compute(), nnp::Training::dPdc(), nnp::Training::dPdcN(), nnp::Mode::evaluateNNP(), nnp::InterfaceLammps::finalizeNeighborList(), freeAtoms(), nnp::InterfaceLammps::getAtomicEnergy(), nnp::InterfaceLammps::getCharges(), getChargesLines(), nnp::InterfaceLammps::getForces(), getForcesLines(), getMaxNumNeighbors(), info(), main(), nnp::Dataset::prepareNumericForces(), readFromLines(), nnp::Dataset::recvStructure(), remap(), reset(), nnp::Training::selectSets(), nnp::Dataset::sendStructure(), nnp::InterfaceLammps::setLocalAtomPositions(), nnp::InterfaceLammps::setLocalAtoms(), nnp::InterfaceLammps::setLocalTags(), setupNeighborCutoffMap(), sortNeighborList(), nnp::Training::sortUpdateCandidates(), toNormalizedUnits(), toPhysicalUnits(), nnp::Training::update(), updateError(), writeToFile(), writeToFilePoscar(), and writeToFileXyz().

---

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

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