Storage for one atomic configuration. More...

#include <Structure.h>

Collaboration diagram for nnp::Structure:

[legend]

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	calculateNeighborList (double cutoffRadius)
	Calculate neighbor list for all atoms. More...

void	calculatePbcCopies (double cutoffRadius)
	Calculate required PBC copies. More...

void	calculateInverseBox ()
	Calculate inverse box. More...

void	calculateVolume ()
	Calculate volume from box vectors. 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)
	Normalize structure, shift energy and change energy and length unit. More...

void	toPhysicalUnits (double meanEnergy, double convEnergy, double convLength)
	Switch to physical units, shift energy and change energy and length unit. More...

std::size_t	getMaxNumNeighbors () const
	Find maximum number of neighbors. More...

void	freeAtoms (bool all)
	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	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	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. More...

double	energy
	Potential energy determined by neural network. More...

double	energyRef
	Reference potential energy. More...

double	charge
	Charge determined by neural network potential. More...

double	chargeRef
	Reference charge. More...

double	volume
	Simulation box volume. 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...

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 33 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 37 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 30 of file Structure.cpp.

                     :
    isPeriodic                    (false     ),
    isTriclinic                   (false     ),
    hasNeighborList               (false     ),
    hasSymmetryFunctions          (false     ),
    hasSymmetryFunctionDerivatives(false     ),
    index                         (0         ),
    numAtoms                      (0         ),
    numElements                   (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;
        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 60 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(), and nnp::Prediction::readStructureFromFile().

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 69 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 86 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 102 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 131 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");
            }
            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:

◆ calculateNeighborList()

void Structure::calculateNeighborList ( double cutoffRadius )

Calculate neighbor list for all atoms.

Parameters

[in] cutoffRadius Atoms are neighbors if there distance is smaller than the cutoff radius.

Definition at line 253 of file Structure.cpp.

{
    if (isPeriodic)
    {
        calculatePbcCopies(cutoffRadius);
 
        // Use square of cutoffRadius (faster).
        cutoffRadius *= cutoffRadius;
 
        size_t i = 0;
#ifdef _OPENMP
        #pragma omp parallel for private(i)
#endif
        for (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;
 
        size_t i = 0;
#ifdef _OPENMP
        #pragma omp parallel for private(i)
#endif
        for (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;
 
    return;
}

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

Referenced by main(), and nnp::Prediction::predict().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calculatePbcCopies()

void Structure::calculatePbcCopies ( double cutoffRadius )

Calculate required PBC copies.

Parameters

[in] cutoffRadius Cutoff radius for neighbor list.

Called by calculateNeighborList().

Definition at line 375 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 408 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().

Here is the caller graph for this function:

◆ calculateVolume()

void Structure::calculateVolume ( )

Calculate volume from box vectors.

Definition at line 436 of file Structure.cpp.

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

References box, and volume.

Referenced by readFromLines().

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 443 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 453 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
	)

Normalize structure, shift energy and change energy and length 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.

Definition at line 479 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;
    volume *= convLength * convLength * convLength;
 
    for (vector<Atom>::iterator it = atoms.begin(); it != atoms.end(); ++it)
    {
        it->toNormalizedUnits(convEnergy, convLength);
    }
 
    return;
}

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

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

Here is the caller graph for this function:

◆ toPhysicalUnits()

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

Switch to physical units, shift energy and change energy and length 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.

Definition at line 505 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;
    volume /= convLength * convLength * convLength;
 
    for (vector<Atom>::iterator it = atoms.begin(); it != atoms.end(); ++it)
    {
        it->toPhysicalUnits(convEnergy, convLength);
    }
 
    return;
}

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

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

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

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

Parameters

[in] all See description in Atom.

Definition at line 531 of file Structure.cpp.

{
    for (vector<Atom>::iterator it = atoms.begin(); it != atoms.end(); ++it)
    {
        it->free(all);
    }
    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 543 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 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 580 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:

◆ 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 596 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 626 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 634 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 647 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 659 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 main(), 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 684 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 743 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 778 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 785 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 851 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 54 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 56 of file Structure.h.

Referenced by calculateNeighborList(), info(), main(), nnp::Dataset::prepareNumericForces(), readFromLines(), nnp::Dataset::recvStructure(), reset(), nnp::Dataset::sendStructure(), toNormalizedUnits(), toPhysicalUnits(), writeToFile(), writeToFilePoscar(), and writeToFileXyz().

◆ isTriclinic

bool nnp::Structure::isTriclinic

If the simulation box is triclinic.

Definition at line 58 of file Structure.h.

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

◆ hasNeighborList

bool nnp::Structure::hasNeighborList

If the neighbor list has been calculated.

Definition at line 60 of file Structure.h.

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

◆ hasSymmetryFunctions

bool nnp::Structure::hasSymmetryFunctions

If symmetry function values are saved for each atom.

Definition at line 62 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 64 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 66 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 68 of file Structure.h.

Referenced by addAtom(), calculateNeighborList(), clearNeighborList(), nnp::Training::dPdc(), nnp::Training::dPdcN(), getEnergyLine(), info(), main(), nnp::Mode::normalizedEnergy(), nnp::Mode::physicalEnergy(), nnp::Dataset::prepareNumericForces(), readFromLines(), nnp::Dataset::recvStructure(), reset(), nnp::Training::selectSets(), nnp::Dataset::sendStructure(), nnp::InterfaceLammps::setLocalAtoms(), 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 70 of file Structure.h.

Referenced by 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 72 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.

Definition at line 74 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 76 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 78 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().

◆ charge

double nnp::Structure::charge

Charge determined by neural network potential.

Definition at line 80 of file Structure.h.

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

◆ chargeRef

double nnp::Structure::chargeRef

Reference charge.

Definition at line 82 of file Structure.h.

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

◆ volume

double nnp::Structure::volume

Simulation box volume.

Definition at line 84 of file Structure.h.

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

◆ sampleType

SampleType nnp::Structure::sampleType

Sample type (training or test set).

Definition at line 86 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 88 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 90 of file Structure.h.

Referenced by calculateInverseBox(), calculateNeighborList(), calculatePbcCopies(), calculateVolume(), info(), main(), readFromLines(), nnp::Dataset::recvStructure(), remap(), reset(), nnp::Dataset::sendStructure(), Structure(), toNormalizedUnits(), toPhysicalUnits(), writeToFile(), writeToFilePoscar(), and writeToFileXyz().

◆ invbox

Vec3D nnp::Structure::invbox[3]

Inverse simulation box vectors.

Definition at line 92 of file Structure.h.

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

◆ numAtomsPerElement

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

Number of atoms of each element in this structure.

Definition at line 94 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 96 of file Structure.h.

Referenced by addAtom(), nnp::InterfaceLammps::addNeighbor(), nnp::Mode::calculateAtomicNeuralNetworks(), nnp::Dataset::calculateBufferSize(), nnp::Mode::calculateCharge(), nnp::Mode::calculateEnergy(), nnp::Mode::calculateForces(), calculateNeighborList(), nnp::Mode::calculateSymmetryFunctionGroups(), nnp::Mode::calculateSymmetryFunctions(), nnp::Training::calculateWeightDerivatives(), clearNeighborList(), nnp::Training::dPdc(), nnp::Training::dPdcN(), freeAtoms(), nnp::InterfaceLammps::getAtomicEnergy(), 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::setLocalAtoms(), nnp::InterfaceLammps::setLocalTags(), 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

Public Types

Public Member Functions

Public Attributes

Detailed Description

Member Enumeration Documentation

◆ SampleType

Constructor & Destructor Documentation

◆ Structure()

Member Function Documentation

◆ setElementMap()

◆ addAtom()

◆ readFromFile() [1/2]

◆ readFromFile() [2/2]

◆ readFromLines()

◆ calculateNeighborList()

◆ calculatePbcCopies()

◆ calculateInverseBox()

◆ calculateVolume()

◆ remap() [1/2]

◆ remap() [2/2]

◆ toNormalizedUnits()

◆ toPhysicalUnits()

◆ getMaxNumNeighbors()

◆ freeAtoms()

◆ reset()

◆ clearNeighborList()

◆ updateError()

◆ getEnergyLine()

◆ getForcesLines()

◆ getChargesLines()

◆ writeToFile() [1/2]

◆ writeToFile() [2/2]

◆ writeToFileXyz()

◆ writeToFilePoscar() [1/2]

◆ writeToFilePoscar() [2/2]

◆ info()

Member Data Documentation

◆ elementMap

◆ isPeriodic

◆ isTriclinic

◆ hasNeighborList

◆ hasSymmetryFunctions

◆ hasSymmetryFunctionDerivatives

◆ index

◆ numAtoms

◆ numElements

◆ numElementsPresent

◆ pbc

◆ energy

◆ energyRef

◆ charge

◆ chargeRef

◆ volume

◆ sampleType

◆ comment

◆ box

◆ invbox

◆ numAtomsPerElement

◆ atoms