nnp::Mode Class Reference

Base class for all NNP applications. More...

#include <Mode.h>

Inheritance diagram for nnp::Mode:

Collaboration diagram for nnp::Mode:

Public Types
enum class	NNPType { SHORT_ONLY , SHORT_CHARGE_NN }

Public Member Functions
	Mode ()
void	initialize ()
	Write welcome message with version information. More...
void	loadSettingsFile (std::string const &fileName="input.nn")
	Open settings file and load all keywords into memory. More...
void	setupGeneric (bool skipNormalize=false)
	Combine multiple setup routines and provide a basic NNP setup. More...
void	setupNormalization (bool standalone=true)
	Set up normalization. More...
virtual void	setupElementMap ()
	Set up the element map. More...
virtual void	setupElements ()
	Set up all Element instances. More...
void	setupCutoff ()
	Set up cutoff function for all symmetry functions. More...
virtual void	setupSymmetryFunctions ()
	Set up all symmetry functions. More...
void	setupSymmetryFunctionScalingNone ()
	Set up "empy" symmetry function scaling. More...
virtual void	setupSymmetryFunctionScaling (std::string const &fileName="scaling.data")
	Set up symmetry function scaling from file. More...
virtual void	setupSymmetryFunctionGroups ()
	Set up symmetry function groups. More...
virtual void	setupSymmetryFunctionCache (bool verbose=false)
	Set up symmetry function cache. More...
void	setupSymmetryFunctionMemory (bool verbose=false)
	Extract required memory dimensions for symmetry function derivatives. More...
void	setupSymmetryFunctionStatistics (bool collectStatistics, bool collectExtrapolationWarnings, bool writeExtrapolationWarnings, bool stopOnExtrapolationWarnings)
	Set up symmetry function statistics collection. More...
virtual void	setupNeuralNetwork ()
	Set up neural networks for all elements. More...
virtual void	setupNeuralNetworkWeights (std::string const &fileNameFormatShort="weights.%03zu.data", std::string const &fileNameFormatCharge="weightse.%03zu.data")
	Set up neural network weights from files. More...
void	calculateSymmetryFunctions (Structure &structure, bool const derivatives)
	Calculate all symmetry functions for all atoms in given structure. More...
void	calculateSymmetryFunctionGroups (Structure &structure, bool const derivatives)
	Calculate all symmetry function groups for all atoms in given structure. More...
void	calculateAtomicNeuralNetworks (Structure &structure, bool const derivatives)
	Calculate a single atomic neural network for a given atom and nn type. More...
void	calculateEnergy (Structure &structure) const
	Calculate potential energy for a given structure. More...
void	calculateCharge (Structure &structure) const
	Calculate total charge for a given structure. More...
void	calculateForces (Structure &structure) const
	Calculate forces for all atoms in given structure. More...
void	addEnergyOffset (Structure &structure, bool ref=true)
	Add atomic energy offsets to reference energy. More...
void	removeEnergyOffset (Structure &structure, bool ref=true)
	Remove atomic energy offsets from reference energy. More...
double	getEnergyOffset (Structure const &structure) const
	Get atomic energy offset for given structure. More...
double	getEnergyWithOffset (Structure const &structure, bool ref=true) const
	Add atomic energy offsets and return energy. More...
double	normalized (std::string const &property, double value) const
	Apply normalization to given property. More...
double	normalizedEnergy (Structure const &structure, bool ref=true) const
	Apply normalization to given energy of structure. More...
double	physical (std::string const &property, double value) const
	Undo normalization for a given property. More...
double	physicalEnergy (Structure const &structure, bool ref=true) const
	Undo normalization for a given energy of structure. More...
void	convertToNormalizedUnits (Structure &structure) const
	Convert one structure to normalized units. More...
void	convertToPhysicalUnits (Structure &structure) const
	Convert one structure to physical units. More...
std::size_t	getNumExtrapolationWarnings () const
	Count total number of extrapolation warnings encountered for all elements and symmetry functions. More...
void	resetExtrapolationWarnings ()
	Erase all extrapolation warnings and reset counters. More...
NNPType	getNnpType () const
	Getter for Mode::nnpType. More...
double	getMeanEnergy () const
	Getter for Mode::meanEnergy. More...
double	getConvEnergy () const
	Getter for Mode::convEnergy. More...
double	getConvLength () const
	Getter for Mode::convLength. More...
double	getMaxCutoffRadius () const
	Getter for Mode::maxCutoffRadius. More...
std::size_t	getNumElements () const
	Getter for Mode::numElements. More...
std::vector< std::size_t >	getNumSymmetryFunctions () const
	Get number of symmetry functions per element. More...
bool	useNormalization () const
	Check if normalization is enabled. More...
bool	settingsKeywordExists (std::string const &keyword) const
	Check if keyword was found in settings file. More...
std::string	settingsGetValue (std::string const &keyword) const
	Get value for given keyword in Settings instance. More...
std::vector< std::size_t >	pruneSymmetryFunctionsRange (double threshold)
	Prune symmetry functions according to their range and write settings file. More...
std::vector< std::size_t >	pruneSymmetryFunctionsSensitivity (double threshold, std::vector< std::vector< double > > sensitivity)
	Prune symmetry functions with sensitivity analysis data. More...
void	writePrunedSettingsFile (std::vector< std::size_t > prune, std::string fileName="output.nn") const
	Copy settings file but comment out lines provided. More...
void	writeSettingsFile (std::ofstream *const &file) const
	Write complete settings file. More...

Public Attributes
ElementMap	elementMap
	Global element map, populated by setupElementMap(). More...
Log	log
	Global log file. More...

Protected Member Functions
void	readNeuralNetworkWeights (std::string const &type, std::string const &fileName)
	Read in weights for a specific type of neural network. More...

Protected Attributes
NNPType	nnpType
bool	normalize
bool	checkExtrapolationWarnings
bool	useChargeNN
std::size_t	numElements
std::vector< std::size_t >	minNeighbors
std::vector< double >	minCutoffRadius
double	maxCutoffRadius
double	cutoffAlpha
double	meanEnergy
double	convEnergy
double	convLength
Settings	settings
SymFnc::ScalingType	scalingType
CutoffFunction::CutoffType	cutoffType
std::vector< Element >	elements

Detailed Description

Base class for all NNP applications.

This top-level class is the anchor point for existing and future applications. It contains functions to set up an existing neural network potential and calculate energies and forces for configurations given as Structure. A minimal setup requires some consecutive functions calls as this minimal example shows:

Mode mode;
mode.initialize();
mode.loadSettingsFile();
mode.setupElementMap();
mode.setupElements();
mode.setupCutoff();
mode.setupSymmetryFunctions();
mode.setupSymmetryFunctionGroups();
mode.setupSymmetryFunctionStatistics(false, false, true, false);
mode.setupNeuralNetwork();

To load weights and scaling information from files add these lines:

mode.setupSymmetryFunctionScaling();
mode.setupNeuralNetworkWeights();

The NNP is now ready! If we load a structure from a data file:

Structure structure;
ifstream file;
file.open("input.data");
structure.setupElementMap(mode.elementMap);
structure.readFromFile(file);
file.close();

we can finally predict the energy and forces from the neural network potential:

structure.calculateNeighborList(mode.getMaxCutoffRadius());
mode.calculateSymmetryFunctionGroups(structure, true);
mode.calculateAtomicNeuralNetworks(structure, true);
mode.calculateEnergy(structure);
mode.calculateForces(structure);
cout << structure.energy << '\n';

The resulting potential energy is stored in Structure::energy, the forces on individual atoms are located within the Structure::atoms vector in Atom::f.

Definition at line 82 of file Mode.h.

Member Enumeration Documentation

NNPType

enum class nnp::Mode::NNPType

strong

Enumerator
SHORT_ONLY	Short range NNP only.
SHORT_CHARGE_NN	Short range NNP with additional charge NN (M. Bircher).

Definition at line 85 of file Mode.h.

    {
        SHORT_ONLY,
        SHORT_CHARGE_NN
    };

Constructor & Destructor Documentation

Mode()

Mode::Mode

(

)

Definition at line 37 of file Mode.cpp.

           : nnpType                   (NNPType::SHORT_ONLY),
               normalize                 (false              ),
               checkExtrapolationWarnings(false              ),
               useChargeNN               (false              ),
               numElements               (0                  ),
               maxCutoffRadius           (0.0                ),
               cutoffAlpha               (0.0                ),
               meanEnergy                (0.0                ),
               convEnergy                (1.0                ),
               convLength                (1.0                )
{
}

Member Function Documentation

initialize()

void Mode::initialize

(

)

Write welcome message with version information.

Definition at line 50 of file Mode.cpp.

{
    log << "\n";
    log << "*****************************************"
           "**************************************\n";
    log << "\n";
    log << "WELCOME TO n²p², A SOFTWARE PACKAGE FOR NEURAL NETWORK "
           "POTENTIALS!\n";
    log << "-------------------------------------------------------"
           "-----------\n";
    log << "\n";
    log << "n²p² version  (from git): " N2P2_GIT_VERSION "\n";
    log << "             (version.h): " N2P2_VERSION "\n";
    log << "------------------------------------------------------------\n";
    log << "Git branch              : " N2P2_GIT_BRANCH "\n";
    log << "Git revision            : " N2P2_GIT_REV "\n";
    log << "Compile date/time       : " __DATE__ " " __TIME__ "\n";
    log << "------------------------------------------------------------\n";
    log << "\n";
    log << "Features/Flags:\n";
    log << "------------------------------------------------------------\n";
    log << "Symmetry function groups     : ";
#ifndef N2P2_NO_SF_GROUPS
    log << "enabled\n";
#else
    log << "disabled\n";
#endif
    log << "Symmetry function cache      : ";
#ifndef N2P2_NO_SF_CACHE
    log << "enabled\n";
#else
    log << "disabled\n";
#endif
    log << "Timing function available    : ";
#ifndef N2P2_NO_TIME
    log << "available\n";
#else
    log << "disabled\n";
#endif
    log << "Asymmetric polynomial SFs    : ";
#ifndef N2P2_NO_ASYM_POLY
    log << "available\n";
#else
    log << "disabled\n";
#endif
    log << "SF low neighbor number check : ";
#ifndef N2P2_NO_NEIGH_CHECK
    log << "enabled\n";
#else
    log << "disabled\n";
#endif
    log << "SF derivative memory layout  : ";
#ifndef N2P2_FULL_SFD_MEMORY
    log << "reduced\n";
#else
    log << "full\n";
#endif
    log << "MPI explicitly disabled      : ";
#ifndef N2P2_NO_MPI
    log << "no\n";
#else
    log << "yes\n";
#endif
#ifdef _OPENMP
    log << strpr("OpenMP threads               : %d\n", omp_get_max_threads());
#endif
    log << "------------------------------------------------------------\n";
    log << "\n";
 
    log << "Please cite the following papers when publishing results "
           "obtained with n²p²:\n";
    log << "-----------------------------------------"
           "--------------------------------------\n";
    log << " * General citation for n²p² and the LAMMPS interface:\n";
    log << "\n";
    log << " Singraber, A.; Behler, J.; Dellago, C.\n";
    log << " Library-Based LAMMPS Implementation of High-Dimensional\n";
    log << " Neural Network Potentials.\n";
    log << " J. Chem. Theory Comput. 2019 15 (3), 1827–1840.\n";
    log << " https://doi.org/10.1021/acs.jctc.8b00770\n";
    log << "-----------------------------------------"
           "--------------------------------------\n";
    log << " * Additionally, if you use the NNP training features of n²p²:\n";
    log << "\n";
    log << " Singraber, A.; Morawietz, T.; Behler, J.; Dellago, C.\n";
    log << " Parallel Multistream Training of High-Dimensional Neural\n";
    log << " Network Potentials.\n";
    log << " J. Chem. Theory Comput. 2019, 15 (5), 3075–3092.\n";
    log << " https://doi.org/10.1021/acs.jctc.8b01092\n";
    log << "-----------------------------------------"
           "--------------------------------------\n";
    log << " * Additionally, if polynomial symmetry functions are used:\n";
    log << "\n";
    log << " Bircher, M. P.; Singraber, A.; Dellago, C.\n";
    log << " Improved Description of Atomic Environments Using Low-Cost\n";
    log << " Polynomial Functions with Compact Support.\n";
    log << " arXiv:2010.14414 [cond-mat, physics:physics] 2020.\n";
    log << " https://arxiv.org/abs/2010.14414\n";
 
 
    log << "*****************************************"
           "**************************************\n";
 
    return;
}

References log, N2P2_GIT_BRANCH, N2P2_GIT_REV, N2P2_GIT_VERSION, and N2P2_VERSION.

Referenced by nnp::InterfaceLammps::initialize(), main(), and nnp::Prediction::setup().

Here is the caller graph for this function:

loadSettingsFile()

void Mode::loadSettingsFile

(

std::string const &

fileName = "input.nn"

)

Open settings file and load all keywords into memory.

Parameters

[in]

fileName

Settings file name.

Definition at line 156 of file Mode.cpp.

{
    log << "\n";
    log << "*** SETUP: SETTINGS FILE ****************"
           "**************************************\n";
    log << "\n";
 
    size_t numCriticalProblems = settings.loadFile(fileName);
    log << settings.info();
    if (numCriticalProblems > 0)
    {
        throw runtime_error(strpr("ERROR: %zu critical problem(s) were found "
                                  "in settings file.\n", numCriticalProblems));
    }
 
    if (settings.keywordExists("nnp_type"))
    {
        nnpType = (NNPType)atoi(settings["nnp_type"].c_str());
    }
 
    if (nnpType == NNPType::SHORT_ONLY)
    {
        log << "This settings file defines a short-range only NNP.\n";
    }
    else if (nnpType == NNPType::SHORT_CHARGE_NN)
    {
        log << "This settings file defines a short-range NNP with additional "
               "charge NN (method by M. Bircher).\n";
        useChargeNN = true;
    }
    else
    {
        throw runtime_error("ERROR: Unknown NNP type.\n");
    }
 
    log << "*****************************************"
           "**************************************\n";
 
    return;
}

References nnp::Settings::info(), nnp::Settings::keywordExists(), nnp::Settings::loadFile(), log, nnpType, settings, SHORT_CHARGE_NN, SHORT_ONLY, nnp::strpr(), and useChargeNN.

Referenced by nnp::InterfaceLammps::initialize(), main(), and nnp::Prediction::setup().

Here is the call graph for this function:

Here is the caller graph for this function:

setupGeneric()

void Mode::setupGeneric

(

bool

skipNormalize = false

)

Combine multiple setup routines and provide a basic NNP setup.

Parameters

[in]

skipNormalize

Whether to skip normalization setup.

Sets up elements, symmetry functions, symmetry function groups, neural networks. No symmetry function scaling data is read, no weights are set.

Definition at line 197 of file Mode.cpp.

{
    if (!skipNormalize) setupNormalization();
    setupElementMap();
    setupElements();
    setupCutoff();
    setupSymmetryFunctions();
#ifndef N2P2_FULL_SFD_MEMORY
    setupSymmetryFunctionMemory(false);
#endif
#ifndef N2P2_NO_SF_CACHE
    setupSymmetryFunctionCache();
#endif
#ifndef N2P2_NO_SF_GROUPS
    setupSymmetryFunctionGroups();
#endif
    setupNeuralNetwork();
 
    return;
}

References setupCutoff(), setupElementMap(), setupElements(), setupNeuralNetwork(), setupNormalization(), setupSymmetryFunctionCache(), setupSymmetryFunctionGroups(), setupSymmetryFunctionMemory(), and setupSymmetryFunctions().

Referenced by nnp::InterfaceLammps::initialize(), main(), and nnp::Prediction::setup().

Here is the call graph for this function:

Here is the caller graph for this function:

setupNormalization()

void Mode::setupNormalization

(

bool

standalone = true

)

Set up normalization.

Parameters

[in]

standalone

Whether to write section header and footer.

If the keywords mean_energy, conv_length and conv_length are present, the provided conversion factors are used to internally use a different unit system.

Definition at line 218 of file Mode.cpp.

{
    if (standalone)
    {
        log << "\n";
        log << "*** SETUP: NORMALIZATION ****************"
               "**************************************\n";
        log << "\n";
    }
 
    if (settings.keywordExists("mean_energy") &&
        settings.keywordExists("conv_energy") &&
        settings.keywordExists("conv_length"))
    {
        normalize = true;
        meanEnergy = atof(settings["mean_energy"].c_str());
        convEnergy = atof(settings["conv_energy"].c_str());
        convLength = atof(settings["conv_length"].c_str());
        log << "Data set normalization is used.\n";
        log << strpr("Mean energy per atom     : %24.16E\n", meanEnergy);
        log << strpr("Conversion factor energy : %24.16E\n", convEnergy);
        log << strpr("Conversion factor length : %24.16E\n", convLength);
        if (settings.keywordExists("atom_energy"))
        {
            log << "\n";
            log << "Atomic energy offsets are used in addition to"
                   " data set normalization.\n";
            log << "Offsets will be subtracted from reference energies BEFORE"
                   " normalization is applied.\n";
        }
    }
    else if ((!settings.keywordExists("mean_energy")) &&
             (!settings.keywordExists("conv_energy")) &&
             (!settings.keywordExists("conv_length")))
    {
        normalize = false;
        log << "Data set normalization is not used.\n";
    }
    else
    {
        throw runtime_error("ERROR: Incorrect usage of normalization"
                            " keywords.\n"
                            "       Use all or none of \"mean_energy\", "
                            "\"conv_energy\" and \"conv_length\".\n");
    }
 
    if (standalone)
    {
        log << "*****************************************"
               "**************************************\n";
    }
 
    return;
}

References convEnergy, convLength, nnp::Settings::keywordExists(), log, meanEnergy, normalize, settings, and nnp::strpr().

Referenced by nnp::Training::dataSetNormalization(), and setupGeneric().

Here is the call graph for this function:

Here is the caller graph for this function:

setupElementMap()

void Mode::setupElementMap ( )

virtual

Set up the element map.

Uses keyword elements. This function should follow immediately after settings are loaded via loadSettingsFile().

Reimplemented in nnp::ModeCabana< t_device >.

Definition at line 273 of file Mode.cpp.

{
    log << "\n";
    log << "*** SETUP: ELEMENT MAP ******************"
           "**************************************\n";
    log << "\n";
 
    elementMap.registerElements(settings["elements"]);
    log << strpr("Number of element strings found: %d\n", elementMap.size());
    for (size_t i = 0; i < elementMap.size(); ++i)
    {
        log << strpr("Element %2zu: %2s (%3zu)\n", i, elementMap[i].c_str(),
                     elementMap.atomicNumber(i));
    }
 
    log << "*****************************************"
           "**************************************\n";
 
    return;
}

References nnp::ElementMap::atomicNumber(), elementMap, log, nnp::ElementMap::registerElements(), settings, nnp::ElementMap::size(), and nnp::strpr().

Referenced by main(), and setupGeneric().

Here is the call graph for this function:

Here is the caller graph for this function:

setupElements()

void Mode::setupElements ( )

virtual

Set up all Element instances.

Uses keywords number_of_elements and atom_energy. This function should follow immediately after setupElementMap().

Reimplemented in nnp::ModeCabana< t_device >.

Definition at line 294 of file Mode.cpp.

{
    log << "\n";
    log << "*** SETUP: ELEMENTS *********************"
           "**************************************\n";
    log << "\n";
 
    numElements = (size_t)atoi(settings["number_of_elements"].c_str());
    if (numElements != elementMap.size())
    {
        throw runtime_error("ERROR: Inconsistent number of elements.\n");
    }
    log << strpr("Number of elements is consistent: %zu\n", numElements);
 
    for (size_t i = 0; i < numElements; ++i)
    {
        elements.push_back(Element(i, elementMap));
    }
 
    if (settings.keywordExists("atom_energy"))
    {
        Settings::KeyRange r = settings.getValues("atom_energy");
        for (Settings::KeyMap::const_iterator it = r.first;
             it != r.second; ++it)
        {
            vector<string> args    = split(reduce(it->second.first));
            size_t         element = elementMap[args.at(0)];
            elements.at(element).
                setAtomicEnergyOffset(atof(args.at(1).c_str()));
        }
    }
    log << "Atomic energy offsets per element:\n";
    for (size_t i = 0; i < elementMap.size(); ++i)
    {
        log << strpr("Element %2zu: %16.8E\n",
                     i, elements.at(i).getAtomicEnergyOffset());
    }
 
    log << "Energy offsets are automatically subtracted from reference "
           "energies.\n";
    log << "*****************************************"
           "**************************************\n";
 
    return;
}

References elementMap, elements, nnp::Settings::getValues(), nnp::Settings::keywordExists(), log, numElements, nnp::reduce(), settings, nnp::ElementMap::size(), nnp::split(), and nnp::strpr().

Referenced by main(), and setupGeneric().

Here is the call graph for this function:

Here is the caller graph for this function:

setupCutoff()

void Mode::setupCutoff

(

)

Set up cutoff function for all symmetry functions.

Uses keyword cutoff_type. Cutoff parameters are read from settings keywords and stored internally. As soon as setupSymmetryFunctions() is called the settings are restored and used for all symmetry functions. Thus, this function must be called before setupSymmetryFunctions().

Definition at line 340 of file Mode.cpp.

{
    log << "\n";
    log << "*** SETUP: CUTOFF FUNCTIONS *************"
           "**************************************\n";
    log << "\n";
 
    vector<string> args = split(settings["cutoff_type"]);
 
    cutoffType = (CutoffFunction::CutoffType) atoi(args.at(0).c_str());
    if (args.size() > 1)
    {
        cutoffAlpha = atof(args.at(1).c_str());
        if (0.0 < cutoffAlpha && cutoffAlpha >= 1.0)
        {
            throw invalid_argument("ERROR: 0 <= alpha < 1.0 is required.\n");
        }
    }
    log << strpr("Parameter alpha for inner cutoff: %f\n", cutoffAlpha);
    log << "Inner cutoff = Symmetry function cutoff * alpha\n";
 
    log << "Equal cutoff function type for all symmetry functions:\n";
    if (cutoffType == CutoffFunction::CT_COS)
    {
        log << strpr("CutoffFunction::CT_COS (%d)\n", cutoffType);
        log << "x := (r - rc * alpha) / (rc - rc * alpha)\n";
        log << "f(x) = 1/2 * (cos(pi*x) + 1)\n";
    }
    else if (cutoffType == CutoffFunction::CT_TANHU)
    {
        log << strpr("CutoffFunction::CT_TANHU (%d)\n", cutoffType);
        log << "f(r) = tanh^3(1 - r/rc)\n";
        if (cutoffAlpha > 0.0)
        {
            log << "WARNING: Inner cutoff parameter not used in combination"
                   " with this cutoff function.\n";
        }
    }
    else if (cutoffType == CutoffFunction::CT_TANH)
    {
        log << strpr("CutoffFunction::CT_TANH (%d)\n", cutoffType);
        log << "f(r) = c * tanh^3(1 - r/rc), f(0) = 1\n";
        if (cutoffAlpha > 0.0)
        {
            log << "WARNING: Inner cutoff parameter not used in combination"
                   " with this cutoff function.\n";
        }
    }
    else if (cutoffType == CutoffFunction::CT_POLY1)
    {
        log << strpr("CutoffFunction::CT_POLY1 (%d)\n", cutoffType);
        log << "x := (r - rc * alpha) / (rc - rc * alpha)\n";
        log << "f(x) = (2x - 3)x^2 + 1\n";
    }
    else if (cutoffType == CutoffFunction::CT_POLY2)
    {
        log << strpr("CutoffFunction::CT_POLY2 (%d)\n", cutoffType);
        log << "x := (r - rc * alpha) / (rc - rc * alpha)\n";
        log << "f(x) = ((15 - 6x)x - 10)x^3 + 1\n";
    }
    else if (cutoffType == CutoffFunction::CT_POLY3)
    {
        log << strpr("CutoffFunction::CT_POLY3 (%d)\n", cutoffType);
        log << "x := (r - rc * alpha) / (rc - rc * alpha)\n";
        log << "f(x) = (x(x(20x - 70) + 84) - 35)x^4 + 1\n";
    }
    else if (cutoffType == CutoffFunction::CT_POLY4)
    {
        log << strpr("CutoffFunction::CT_POLY4 (%d)\n", cutoffType);
        log << "x := (r - rc * alpha) / (rc - rc * alpha)\n";
        log << "f(x) = (x(x((315 - 70x)x - 540) + 420) - 126)x^5 + 1\n";
    }
    else if (cutoffType == CutoffFunction::CT_EXP)
    {
        log << strpr("CutoffFunction::CT_EXP (%d)\n", cutoffType);
        log << "x := (r - rc * alpha) / (rc - rc * alpha)\n";
        log << "f(x) = exp(-1 / 1 - x^2)\n";
    }
    else if (cutoffType == CutoffFunction::CT_HARD)
    {
        log << strpr("CutoffFunction::CT_HARD (%d)\n", cutoffType);
        log << "f(r) = 1\n";
        log << "WARNING: Hard cutoff used!\n";
    }
    else
    {
        throw invalid_argument("ERROR: Unknown cutoff type.\n");
    }
 
    log << "*****************************************"
           "**************************************\n";
 
    return;
}

References nnp::CutoffFunction::CT_COS, nnp::CutoffFunction::CT_EXP, nnp::CutoffFunction::CT_HARD, nnp::CutoffFunction::CT_POLY1, nnp::CutoffFunction::CT_POLY2, nnp::CutoffFunction::CT_POLY3, nnp::CutoffFunction::CT_POLY4, nnp::CutoffFunction::CT_TANH, nnp::CutoffFunction::CT_TANHU, cutoffAlpha, cutoffType, log, settings, nnp::split(), and nnp::strpr().

Referenced by main(), and setupGeneric().

Here is the call graph for this function:

Here is the caller graph for this function:

setupSymmetryFunctions()

void Mode::setupSymmetryFunctions ( )

virtual

Set up all symmetry functions.

Uses keyword symfunction_short. Reads all symmetry functions from settings and automatically assigns them to the correct element.

Reimplemented in nnp::ModeCabana< t_device >.

Definition at line 435 of file Mode.cpp.

{
    log << "\n";
    log << "*** SETUP: SYMMETRY FUNCTIONS ***********"
           "**************************************\n";
    log << "\n";
 
    Settings::KeyRange r = settings.getValues("symfunction_short");
    for (Settings::KeyMap::const_iterator it = r.first; it != r.second; ++it)
    {
        vector<string> args    = split(reduce(it->second.first));
        size_t         element = elementMap[args.at(0)];
 
        elements.at(element).addSymmetryFunction(it->second.first,
                                                 it->second.second);
    }
 
    log << "Abbreviations:\n";
    log << "--------------\n";
    log << "ind .... Symmetry function index.\n";
    log << "ec ..... Central atom element.\n";
    log << "tp ..... Symmetry function type.\n";
    log << "sbtp ... Symmetry function subtype (e.g. cutoff type).\n";
    log << "e1 ..... Neighbor 1 element.\n";
    log << "e2 ..... Neighbor 2 element.\n";
    log << "eta .... Gaussian width eta.\n";
    log << "rs/rl... Shift distance of Gaussian or left cutoff radius "
           "for polynomial.\n";
    log << "angl.... Left cutoff angle for polynomial.\n";
    log << "angr.... Right cutoff angle for polynomial.\n";
    log << "la ..... Angle prefactor lambda.\n";
    log << "zeta ... Angle term exponent zeta.\n";
    log << "rc ..... Cutoff radius / right cutoff radius for polynomial.\n";
    log << "a ...... Free parameter alpha (e.g. cutoff alpha).\n";
    log << "ln ..... Line number in settings file.\n";
    log << "\n";
    maxCutoffRadius = 0.0;
    for (vector<Element>::iterator it = elements.begin();
         it != elements.end(); ++it)
    {
        if (normalize) it->changeLengthUnitSymmetryFunctions(convLength);
        it->sortSymmetryFunctions();
        maxCutoffRadius = max(it->getMaxCutoffRadius(), maxCutoffRadius);
        it->setCutoffFunction(cutoffType, cutoffAlpha);
        log << strpr("Short range atomic symmetry functions element %2s :\n",
                     it->getSymbol().c_str());
        log << "--------------------------------------------------"
               "-----------------------------------------------\n";
        log << " ind ec tp sbtp e1 e2       eta      rs/rl         "
               "rc   angl   angr la zeta    a    ln\n";
        log << "--------------------------------------------------"
               "-----------------------------------------------\n";
        log << it->infoSymmetryFunctionParameters();
        log << "--------------------------------------------------"
               "-----------------------------------------------\n";
    }
    minNeighbors.clear();
    minNeighbors.resize(numElements, 0);
    minCutoffRadius.clear();
    minCutoffRadius.resize(numElements, maxCutoffRadius);
    for (size_t i = 0; i < numElements; ++i)
    {
        minNeighbors.at(i) = elements.at(i).getMinNeighbors();
        minCutoffRadius.at(i) = elements.at(i).getMinCutoffRadius();
        log << strpr("Minimum cutoff radius for element %2s: %f\n",
                     elements.at(i).getSymbol().c_str(),
                     minCutoffRadius.at(i) / convLength);
    }
    log << strpr("Maximum cutoff radius (global)      : %f\n",
                 maxCutoffRadius / convLength);
 
    log << "*****************************************"
           "**************************************\n";
 
    return;
}

References convLength, cutoffAlpha, cutoffType, elementMap, elements, nnp::Settings::getValues(), log, maxCutoffRadius, minCutoffRadius, minNeighbors, normalize, numElements, nnp::reduce(), settings, nnp::split(), and nnp::strpr().

Referenced by nnp::Training::dataSetNormalization(), main(), and setupGeneric().

Here is the call graph for this function:

Here is the caller graph for this function:

setupSymmetryFunctionScalingNone()

void Mode::setupSymmetryFunctionScalingNone

(

)

Set up "empy" symmetry function scaling.

Does not use any keywords. Sets no scaling for all symmetry functions. Call after setupSymmetryFunctions(). Alternatively set scaling via setupSymmetryFunctionScaling().

Definition at line 512 of file Mode.cpp.

{
    log << "\n";
    log << "*** SETUP: SYMMETRY FUNCTION SCALING ****"
           "**************************************\n";
    log << "\n";
 
    log << "No scaling for symmetry functions.\n";
    for (vector<Element>::iterator it = elements.begin();
         it != elements.end(); ++it)
    {
        it->setScalingNone();
    }
 
    log << "*****************************************"
           "**************************************\n";
 
    return;
}

References elements, and log.

Referenced by main().

Here is the caller graph for this function:

setupSymmetryFunctionScaling()

void Mode::setupSymmetryFunctionScaling ( std::string const &  fileName = "scaling.data" )

virtual

Set up symmetry function scaling from file.

Parameters

[in]

fileName

Scaling file name.

Uses keywords scale_symmetry_functions, center_symmetry_functions, scale_symmetry_functions_sigma, scale_min_short and scale_max_short. Reads in scaling information and sets correct scaling behavior for all symmetry functions. Call after setupSymmetryFunctions().

Reimplemented in nnp::ModeCabana< t_device >.

Definition at line 532 of file Mode.cpp.

{
    log << "\n";
    log << "*** SETUP: SYMMETRY FUNCTION SCALING ****"
           "**************************************\n";
    log << "\n";
 
    log << "Equal scaling type for all symmetry functions:\n";
    if (   ( settings.keywordExists("scale_symmetry_functions" ))
        && (!settings.keywordExists("center_symmetry_functions")))
    {
        scalingType = SymFnc::ST_SCALE;
        log << strpr("Scaling type::ST_SCALE (%d)\n", scalingType);
        log << "Gs = Smin + (Smax - Smin) * (G - Gmin) / (Gmax - Gmin)\n";
    }
    else if (   (!settings.keywordExists("scale_symmetry_functions" ))
             && ( settings.keywordExists("center_symmetry_functions")))
    {
        scalingType = SymFnc::ST_CENTER;
        log << strpr("Scaling type::ST_CENTER (%d)\n", scalingType);
        log << "Gs = G - Gmean\n";
    }
    else if (   ( settings.keywordExists("scale_symmetry_functions" ))
             && ( settings.keywordExists("center_symmetry_functions")))
    {
        scalingType = SymFnc::ST_SCALECENTER;
        log << strpr("Scaling type::ST_SCALECENTER (%d)\n", scalingType);
        log << "Gs = Smin + (Smax - Smin) * (G - Gmean) / (Gmax - Gmin)\n";
    }
    else if (settings.keywordExists("scale_symmetry_functions_sigma"))
    {
        scalingType = SymFnc::ST_SCALESIGMA;
        log << strpr("Scaling type::ST_SCALESIGMA (%d)\n", scalingType);
        log << "Gs = Smin + (Smax - Smin) * (G - Gmean) / Gsigma\n";
    }
    else
    {
        scalingType = SymFnc::ST_NONE;
        log << strpr("Scaling type::ST_NONE (%d)\n", scalingType);
        log << "Gs = G\n";
        log << "WARNING: No symmetry function scaling!\n";
    }
 
    double Smin = 0.0;
    double Smax = 0.0;
    if (scalingType == SymFnc::ST_SCALE ||
        scalingType == SymFnc::ST_SCALECENTER ||
        scalingType == SymFnc::ST_SCALESIGMA)
    {
        if (settings.keywordExists("scale_min_short"))
        {
            Smin = atof(settings["scale_min_short"].c_str());
        }
        else
        {
            log << "WARNING: Keyword \"scale_min_short\" not found.\n";
            log << "         Default value for Smin = 0.0.\n";
            Smin = 0.0;
        }
 
        if (settings.keywordExists("scale_max_short"))
        {
            Smax = atof(settings["scale_max_short"].c_str());
        }
        else
        {
            log << "WARNING: Keyword \"scale_max_short\" not found.\n";
            log << "         Default value for Smax = 1.0.\n";
            Smax = 1.0;
        }
 
        log << strpr("Smin = %f\n", Smin);
        log << strpr("Smax = %f\n", Smax);
    }
 
    log << strpr("Symmetry function scaling statistics from file: %s\n",
                 fileName.c_str());
    log << "-----------------------------------------"
           "--------------------------------------\n";
    ifstream file;
    file.open(fileName.c_str());
    if (!file.is_open())
    {
        throw runtime_error("ERROR: Could not open file: \"" + fileName
                            + "\".\n");
    }
    string line;
    vector<string> lines;
    while (getline(file, line))
    {
        if (line.at(0) != '#') lines.push_back(line);
    }
    file.close();
 
    log << "\n";
    log << "Abbreviations:\n";
    log << "--------------\n";
    log << "ind ..... Symmetry function index.\n";
    log << "min ..... Minimum symmetry function value.\n";
    log << "max ..... Maximum symmetry function value.\n";
    log << "mean .... Mean symmetry function value.\n";
    log << "sigma ... Standard deviation of symmetry function values.\n";
    log << "sf ...... Scaling factor for derivatives.\n";
    log << "Smin .... Desired minimum scaled symmetry function value.\n";
    log << "Smax .... Desired maximum scaled symmetry function value.\n";
    log << "t ....... Scaling type.\n";
    log << "\n";
    for (vector<Element>::iterator it = elements.begin();
         it != elements.end(); ++it)
    {
        it->setScaling(scalingType, lines, Smin, Smax);
        log << strpr("Scaling data for symmetry functions element %2s :\n",
                     it->getSymbol().c_str());
        log << "-----------------------------------------"
               "--------------------------------------\n";
        log << " ind       min       max      mean     sigma        sf  Smin  Smax t\n";
        log << "-----------------------------------------"
               "--------------------------------------\n";
        log << it->infoSymmetryFunctionScaling();
        log << "-----------------------------------------"
               "--------------------------------------\n";
        lines.erase(lines.begin(), lines.begin() + it->numSymmetryFunctions());
    }
 
    log << "*****************************************"
           "**************************************\n";
 
    return;
}

References elements, nnp::Settings::keywordExists(), log, scalingType, settings, nnp::SymFnc::ST_CENTER, nnp::SymFnc::ST_NONE, nnp::SymFnc::ST_SCALE, nnp::SymFnc::ST_SCALECENTER, nnp::SymFnc::ST_SCALESIGMA, and nnp::strpr().

Referenced by nnp::Training::dataSetNormalization(), nnp::InterfaceLammps::initialize(), main(), and nnp::Prediction::setup().

Here is the call graph for this function:

Here is the caller graph for this function:

setupSymmetryFunctionGroups()

void Mode::setupSymmetryFunctionGroups ( )

virtual

Set up symmetry function groups.

Does not use any keywords. Call after setupSymmetryFunctions() and ensure that correct scaling behavior has already been set.

Reimplemented in nnp::ModeCabana< t_device >.

Definition at line 662 of file Mode.cpp.

{
    log << "\n";
    log << "*** SETUP: SYMMETRY FUNCTION GROUPS *****"
           "**************************************\n";
    log << "\n";
 
    log << "Abbreviations:\n";
    log << "--------------\n";
    log << "ind .... Symmetry function index.\n";
    log << "ec ..... Central atom element.\n";
    log << "tp ..... Symmetry function type.\n";
    log << "sbtp ... Symmetry function subtype (e.g. cutoff type).\n";
    log << "e1 ..... Neighbor 1 element.\n";
    log << "e2 ..... Neighbor 2 element.\n";
    log << "eta .... Gaussian width eta.\n";
    log << "rs/rl... Shift distance of Gaussian or left cutoff radius "
           "for polynomial.\n";
    log << "angl.... Left cutoff angle for polynomial.\n";
    log << "angr.... Right cutoff angle for polynomial.\n";
    log << "la ..... Angle prefactor lambda.\n";
    log << "zeta ... Angle term exponent zeta.\n";
    log << "rc ..... Cutoff radius / right cutoff radius for polynomial.\n";
    log << "a ...... Free parameter alpha (e.g. cutoff alpha).\n";
    log << "ln ..... Line number in settings file.\n";
    log << "mi ..... Member index.\n";
    log << "sfi .... Symmetry function index.\n";
    log << "e ...... Recalculate exponential term.\n";
    log << "\n";
    for (vector<Element>::iterator it = elements.begin();
         it != elements.end(); ++it)
    {
        it->setupSymmetryFunctionGroups();
        log << strpr("Short range atomic symmetry function groups "
                     "element %2s :\n", it->getSymbol().c_str());
        log << "------------------------------------------------------"
               "----------------------------------------------------\n";
        log << " ind ec tp sbtp e1 e2       eta      rs/rl         "
               "rc   angl   angr la zeta    a    ln   mi  sfi e\n";
        log << "------------------------------------------------------"
               "----------------------------------------------------\n";
        log << it->infoSymmetryFunctionGroups();
        log << "------------------------------------------------------"
               "----------------------------------------------------\n";
    }
 
    log << "*****************************************"
           "**************************************\n";
 
    return;
}

References elements, log, and nnp::strpr().

Referenced by nnp::Training::dataSetNormalization(), and setupGeneric().

Here is the call graph for this function:

Here is the caller graph for this function:

setupSymmetryFunctionCache()

void Mode::setupSymmetryFunctionCache ( bool  verbose = false )

virtual

Set up symmetry function cache.

Parameters

[in]

verbose

If true, print more cache information.

Searches symmetry functions for identical cutoff functions or compact function (i.e. all cachable stuff) and sets up a caching index.

Definition at line 804 of file Mode.cpp.

{
    log << "\n";
    log << "*** SETUP: SYMMETRY FUNCTION CACHE ******"
           "**************************************\n";
    log << "\n";
 
    for (size_t i = 0; i < numElements; ++i)
    {
        using SFCacheList = Element::SFCacheList;
        vector<vector<SFCacheList>> cacheLists(numElements);
        Element& e = elements.at(i);
        for (size_t j = 0; j < e.numSymmetryFunctions(); ++j)
        {
            SymFnc const& s = e.getSymmetryFunction(j);
            for (auto identifier : s.getCacheIdentifiers())
            {
                size_t ne = atoi(split(identifier)[0].c_str());
                bool unknown = true;
                for (auto& c : cacheLists.at(ne))
                {
                    if (identifier == c.identifier)
                    {
                        c.indices.push_back(s.getIndex());
                        unknown = false;
                        break;
                    }
                }
                if (unknown)
                {
                    cacheLists.at(ne).push_back(SFCacheList());
                    cacheLists.at(ne).back().element = ne;
                    cacheLists.at(ne).back().identifier = identifier;
                    cacheLists.at(ne).back().indices.push_back(s.getIndex());
                }
            }
        }
        if (verbose)
        {
            log << strpr("Multiple cache identifiers for element %2s:\n\n",
                         e.getSymbol().c_str());
        }
        double cacheUsageMean = 0.0;
        size_t cacheCount = 0;
        for (size_t j = 0; j < numElements; ++j)
        {
            if (verbose)
            {
                log << strpr("Neighbor %2s:\n", elementMap[j].c_str());
            }
            vector<SFCacheList>& c = cacheLists.at(j);
            c.erase(remove_if(c.begin(),
                              c.end(),
                              [](SFCacheList l)
                              {
                                  return l.indices.size() <= 1;
                              }), c.end());
            cacheCount += c.size();
            for (size_t k = 0; k < c.size(); ++k)
            {
                cacheUsageMean += c.at(k).indices.size();
                if (verbose)
                {
                    log << strpr("Cache %zu, Identifier \"%s\", "
                                 "Symmetry functions",
                                 k, c.at(k).identifier.c_str());
                    for (auto si : c.at(k).indices)
                    {
                        log << strpr(" %zu", si);
                    }
                    log << "\n";
                }
            }
        }
        e.setCacheIndices(cacheLists);
        //for (size_t j = 0; j < e.numSymmetryFunctions(); ++j)
        //{
        //    SymFnc const& sf = e.getSymmetryFunction(j);
        //    auto indices = sf.getCacheIndices();
        //    size_t count = 0;
        //    for (size_t k = 0; k < numElements; ++k)
        //    {
        //        count += indices.at(k).size();
        //    }
        //    if (count > 0)
        //    {
        //        log << strpr("SF %4zu:\n", sf.getIndex());
        //    }
        //    for (size_t k = 0; k < numElements; ++k)
        //    {
        //        if (indices.at(k).size() > 0)
        //        {
        //            log << strpr("- Neighbor %2s:", elementMap[k].c_str());
        //            for (size_t l = 0; l < indices.at(k).size(); ++l)
        //            {
        //                log << strpr(" %zu", indices.at(k).at(l));
        //            }
        //            log << "\n";
        //        }
        //    }
        //}
        cacheUsageMean /= cacheCount;
        log << strpr("Element %2s: in total %zu caches, "
                     "used %3.2f times on average.\n",
                     e.getSymbol().c_str(), cacheCount, cacheUsageMean);
        if (verbose)
        {
            log << "-----------------------------------------"
                   "--------------------------------------\n";
        }
    }
 
    log << "*****************************************"
           "**************************************\n";
 
    return;
}

References elementMap, elements, nnp::SymFnc::getCacheIdentifiers(), nnp::SymFnc::getIndex(), nnp::Element::getSymbol(), nnp::Element::getSymmetryFunction(), log, numElements, nnp::Element::numSymmetryFunctions(), nnp::Element::setCacheIndices(), nnp::split(), and nnp::strpr().

Referenced by nnp::Training::dataSetNormalization(), and setupGeneric().

Here is the call graph for this function:

Here is the caller graph for this function:

setupSymmetryFunctionMemory()

void Mode::setupSymmetryFunctionMemory

(

bool

verbose = false

)

Extract required memory dimensions for symmetry function derivatives.

Parameters

[in]

verbose

If true, print all symmetry function lines.

Call after symmetry functions have been set up and sorted.

Definition at line 714 of file Mode.cpp.

{
    log << "\n";
    log << "*** SETUP: SYMMETRY FUNCTION MEMORY *****"
           "**************************************\n";
    log << "\n";
 
    for (auto& e : elements)
    {
        e.setupSymmetryFunctionMemory();
        vector<size_t> symmetryFunctionNumTable
            = e.getSymmetryFunctionNumTable();
        vector<vector<size_t>> symmetryFunctionTable
            = e.getSymmetryFunctionTable();
        log << strpr("Symmetry function derivatives memory table "
                     "for element %2s :\n", e.getSymbol().c_str());
        log << "-----------------------------------------"
               "--------------------------------------\n";
        log << "Relevant symmetry functions for neighbors with element:\n";
        for (size_t i = 0; i < numElements; ++i)
        {
            log << strpr("- %2s: %4zu of %4zu (%5.1f %)\n",
                         elementMap[i].c_str(),
                         symmetryFunctionNumTable.at(i),
                         e.numSymmetryFunctions(),
                         (100.0 * symmetryFunctionNumTable.at(i))
                         / e.numSymmetryFunctions());
            if (verbose)
            {
                log << "-----------------------------------------"
                       "--------------------------------------\n";
                for (auto isf : symmetryFunctionTable.at(i))
                {
                    SymFnc const& sf = e.getSymmetryFunction(isf);
                    log << sf.parameterLine();
                }
                log << "-----------------------------------------"
                       "--------------------------------------\n";
            }
        }
        log << "-----------------------------------------"
               "--------------------------------------\n";
    }
    if (verbose)
    {
        for (auto& e : elements)
        {
            log << strpr("%2s - symmetry function per-element index table:\n",
                         e.getSymbol().c_str());
            log << "-----------------------------------------"
                   "--------------------------------------\n";
            log << " ind";
            for (size_t i = 0; i < numElements; ++i)
            {
                log << strpr(" %4s", elementMap[i].c_str());
            }
            log << "\n";
            log << "-----------------------------------------"
                   "--------------------------------------\n";
            for (size_t i = 0; i < e.numSymmetryFunctions(); ++i)
            {
                SymFnc const& sf = e.getSymmetryFunction(i);
                log << strpr("%4zu", sf.getIndex() + 1);
                vector<size_t> indexPerElement = sf.getIndexPerElement();
                for (auto ipe : sf.getIndexPerElement())
                {
                    if (ipe == numeric_limits<size_t>::max())
                    {
                        log << strpr("     ");
                    }
                    else
                    {
                        log << strpr(" %4zu", ipe + 1);
                    }
                }
                log << "\n";
            }
            log << "-----------------------------------------"
                   "--------------------------------------\n";
        }
 
    }
 
    log << "*****************************************"
           "**************************************\n";
 
    return;
}

References elementMap, elements, nnp::SymFnc::getIndex(), nnp::SymFnc::getIndexPerElement(), log, numElements, nnp::SymFnc::parameterLine(), and nnp::strpr().

Referenced by nnp::Training::dataSetNormalization(), and setupGeneric().

Here is the call graph for this function:

Here is the caller graph for this function:

setupSymmetryFunctionStatistics()

void Mode::setupSymmetryFunctionStatistics	(	bool	collectStatistics,
		bool	collectExtrapolationWarnings,
		bool	writeExtrapolationWarnings,
		bool	stopOnExtrapolationWarnings
	)

Set up symmetry function statistics collection.

Parameters

[in]	collectStatistics	Whether statistics (min, max, mean, sigma) is collected.
[in]	collectExtrapolationWarnings	Whether extrapolation warnings are logged.
[in]	writeExtrapolationWarnings	Write extrapolation warnings immediately when they occur.
[in]	stopOnExtrapolationWarnings	Throw error immediately when an extrapolation warning occurs.

Does not use any keywords. Calling this setup function is not required, by default no statistics collection is enabled (all arguments false). Call after setupElements().

Definition at line 923 of file Mode.cpp.

{
    log << "\n";
    log << "*** SETUP: SYMMETRY FUNCTION STATISTICS *"
           "**************************************\n";
    log << "\n";
 
    log << "Equal symmetry function statistics for all elements.\n";
    log << strpr("Collect min/max/mean/sigma                        : %d\n",
                 (int)collectStatistics);
    log << strpr("Collect extrapolation warnings                    : %d\n",
                 (int)collectExtrapolationWarnings);
    log << strpr("Write extrapolation warnings immediately to stderr: %d\n",
                 (int)writeExtrapolationWarnings);
    log << strpr("Halt on any extrapolation warning                 : %d\n",
                 (int)stopOnExtrapolationWarnings);
    for (vector<Element>::iterator it = elements.begin();
         it != elements.end(); ++it)
    {
        it->statistics.collectStatistics = collectStatistics;
        it->statistics.collectExtrapolationWarnings =
                                                  collectExtrapolationWarnings;
        it->statistics.writeExtrapolationWarnings = writeExtrapolationWarnings;
        it->statistics.stopOnExtrapolationWarnings =
                                                   stopOnExtrapolationWarnings;
    }
 
    checkExtrapolationWarnings = collectStatistics
                              || collectExtrapolationWarnings
                              || writeExtrapolationWarnings
                              || stopOnExtrapolationWarnings;
 
    log << "*****************************************"
           "**************************************\n";
    return;
}

References checkExtrapolationWarnings, elements, log, and nnp::strpr().

Referenced by nnp::Training::dataSetNormalization(), nnp::InterfaceLammps::initialize(), main(), and nnp::Prediction::setup().

Here is the call graph for this function:

Here is the caller graph for this function:

setupNeuralNetwork()

void Mode::setupNeuralNetwork ( )

virtual

Set up neural networks for all elements.

Uses keywords global_hidden_layers_short, global_nodes_short, global_activation_short, normalize_nodes. Call after setupSymmetryFunctions(), only then the number of input layer neurons is known.

Reimplemented in nnp::ModeCabana< t_device >.

Definition at line 963 of file Mode.cpp.

{
    log << "\n";
    log << "*** SETUP: NEURAL NETWORKS **************"
           "**************************************\n";
    log << "\n";
 
    struct NeuralNetworkTopology
    {
        int                                       numLayers = 0;
        vector<int>                               numNeuronsPerLayer;
        vector<NeuralNetwork::ActivationFunction> activationFunctionsPerLayer;
    };
 
    vector<NeuralNetworkTopology> nnt(numElements);
 
    size_t globalNumHiddenLayers =
        (size_t)atoi(settings["global_hidden_layers_short"].c_str());
    vector<string> globalNumNeuronsPerHiddenLayer =
        split(reduce(settings["global_nodes_short"]));
    vector<string> globalActivationFunctions =
        split(reduce(settings["global_activation_short"]));
 
    for (size_t i = 0; i < numElements; ++i)
    {
        NeuralNetworkTopology& t = nnt.at(i);
        t.numLayers = 2 + globalNumHiddenLayers;
        t.numNeuronsPerLayer.resize(t.numLayers, 0);
        t.activationFunctionsPerLayer.resize(t.numLayers,
                                             NeuralNetwork::AF_IDENTITY);
 
        for (int i = 0; i < t.numLayers; i++)
        {
            NeuralNetwork::
            ActivationFunction& a = t.activationFunctionsPerLayer[i];
            if (i == 0)
            {
                t.numNeuronsPerLayer[i] = 0;
                a = NeuralNetwork::AF_IDENTITY;
            }
            else
            {
                if (i == t.numLayers - 1) t.numNeuronsPerLayer[i] = 1;
                else
                {
                    t.numNeuronsPerLayer[i] =
                        atoi(globalNumNeuronsPerHiddenLayer.at(i-1).c_str());
                }
                if (globalActivationFunctions.at(i-1) == "l")
                {
                    a = NeuralNetwork::AF_IDENTITY;
                }
                else if (globalActivationFunctions.at(i-1) == "t")
                {
                    a = NeuralNetwork::AF_TANH;
                }
                else if (globalActivationFunctions.at(i-1) == "s")
                {
                    a = NeuralNetwork::AF_LOGISTIC;
                }
                else if (globalActivationFunctions.at(i-1) == "p")
                {
                    a = NeuralNetwork::AF_SOFTPLUS;
                }
                else if (globalActivationFunctions.at(i-1) == "r")
                {
                    a = NeuralNetwork::AF_RELU;
                }
                else if (globalActivationFunctions.at(i-1) == "g")
                {
                    a = NeuralNetwork::AF_GAUSSIAN;
                }
                else if (globalActivationFunctions.at(i-1) == "c")
                {
                    a = NeuralNetwork::AF_COS;
                }
                else if (globalActivationFunctions.at(i-1) == "S")
                {
                    a = NeuralNetwork::AF_REVLOGISTIC;
                }
                else if (globalActivationFunctions.at(i-1) == "e")
                {
                    a = NeuralNetwork::AF_EXP;
                }
                else if (globalActivationFunctions.at(i-1) == "h")
                {
                    a = NeuralNetwork::AF_HARMONIC;
                }
                else
                {
                    throw runtime_error("ERROR: Unknown activation "
                                        "function.\n");
                }
            }
        }
    }
 
    if (settings.keywordExists("element_nodes_short"))
    {
        Settings::KeyRange r = settings.getValues("element_nodes_short");
        for (Settings::KeyMap::const_iterator it = r.first;
             it != r.second; ++it)
        {
            vector<string> args = split(reduce(it->second.first));
            size_t e = elementMap[args.at(0)];
            size_t l = atoi(args.at(1).c_str());
 
            nnt.at(e).numNeuronsPerLayer.at(l) =
                (size_t)atoi(args.at(2).c_str());
        }
    }
 
    bool normalizeNeurons = settings.keywordExists("normalize_nodes");
    log << strpr("Normalize neurons (all elements): %d\n",
                 (int)normalizeNeurons);
    log << "-----------------------------------------"
           "--------------------------------------\n";
 
    for (size_t i = 0; i < numElements; ++i)
    {
        Element& e = elements.at(i);
        NeuralNetworkTopology& t = nnt.at(i);
 
        t.numNeuronsPerLayer[0] = e.numSymmetryFunctions();
        // Need one extra neuron for atomic charge.
        if (nnpType == NNPType::SHORT_CHARGE_NN) t.numNeuronsPerLayer[0]++;
        e.neuralNetworks.emplace(piecewise_construct,
                                 forward_as_tuple("short"),
                                 forward_as_tuple(
                                     t.numLayers,
                                     t.numNeuronsPerLayer.data(),
                                     t.activationFunctionsPerLayer.data()));
        e.neuralNetworks.at("short").setNormalizeNeurons(normalizeNeurons);
        log << strpr("Atomic short range NN for "
                     "element %2s :\n", e.getSymbol().c_str());
        log << e.neuralNetworks.at("short").info();
        log << "-----------------------------------------"
               "--------------------------------------\n";
        if (useChargeNN)
        {
            e.neuralNetworks.emplace(
                                    piecewise_construct,
                                    forward_as_tuple("charge"),
                                    forward_as_tuple(
                                        t.numLayers,
                                        t.numNeuronsPerLayer.data(),
                                        t.activationFunctionsPerLayer.data()));
            e.neuralNetworks.at("charge")
                .setNormalizeNeurons(normalizeNeurons);
            log << strpr("Atomic charge NN for "
                         "element %2s :\n", e.getSymbol().c_str());
            log << e.neuralNetworks.at("charge").info();
            log << "-----------------------------------------"
                   "--------------------------------------\n";
        }
    }
 
    log << "*****************************************"
           "**************************************\n";
 
    return;
}

References nnp::NeuralNetwork::AF_COS, nnp::NeuralNetwork::AF_EXP, nnp::NeuralNetwork::AF_GAUSSIAN, nnp::NeuralNetwork::AF_HARMONIC, nnp::NeuralNetwork::AF_IDENTITY, nnp::NeuralNetwork::AF_LOGISTIC, nnp::NeuralNetwork::AF_RELU, nnp::NeuralNetwork::AF_REVLOGISTIC, nnp::NeuralNetwork::AF_SOFTPLUS, nnp::NeuralNetwork::AF_TANH, elementMap, elements, nnp::Element::getSymbol(), nnp::Settings::getValues(), nnp::Settings::keywordExists(), log, nnp::Element::neuralNetworks, nnpType, numElements, nnp::Element::numSymmetryFunctions(), nnp::reduce(), settings, SHORT_CHARGE_NN, nnp::split(), nnp::strpr(), and useChargeNN.

Referenced by setupGeneric().

Here is the call graph for this function:

Here is the caller graph for this function:

setupNeuralNetworkWeights()

void Mode::setupNeuralNetworkWeights ( std::string const &  fileNameFormatShort = "weights.%03zu.data", std::string const &  fileNameFormatCharge = "weightse.%03zu.data"  )

virtual

Set up neural network weights from files.

Parameters

[in]	fileNameFormatShort	Format for weights file name. The string must contain one placeholder for the atomic number.
[in]	fileNameFormatCharge	Format for charge NN weights file name. The string must contain one placeholder for the atomic number.

Does not use any keywords. The weight files should contain one weight per line, see NeuralNetwork::setConnections() for the correct order.

Definition at line 1126 of file Mode.cpp.

{
    log << "\n";
    log << "*** SETUP: NEURAL NETWORK WEIGHTS *******"
           "**************************************\n";
    log << "\n";
 
    log << strpr("Short  NN weight file name format: %s\n",
                 fileNameFormatShort.c_str());
    readNeuralNetworkWeights("short", fileNameFormatShort);
    if (useChargeNN)
    {
        log << strpr("Charge NN weight file name format: %s\n",
                     fileNameFormatCharge.c_str());
        readNeuralNetworkWeights("charge", fileNameFormatCharge);
    }
 
    log << "*****************************************"
           "**************************************\n";
 
    return;
}

References log, readNeuralNetworkWeights(), nnp::strpr(), and useChargeNN.

Referenced by nnp::InterfaceLammps::initialize(), main(), and nnp::Prediction::setup().

Here is the call graph for this function:

Here is the caller graph for this function:

calculateSymmetryFunctions()

void Mode::calculateSymmetryFunctions	(	Structure &	structure,
		bool const	derivatives
	)

Calculate all symmetry functions for all atoms in given structure.

Parameters

[in]	structure	Input structure.
[in]	derivatives	If true calculate also derivatives of symmetry functions.

This function should be replaced by calculateSymmetryFunctionGroups() whenever possible. Results are stored in Atom::G. If derivatives are calculated, additional results are stored in Atom::dGdr and Atom::Neighbor::dGdr.

Definition at line 1150 of file Mode.cpp.

{
    // Skip calculation for whole structure if results are already saved.
    if (structure.hasSymmetryFunctionDerivatives) return;
    if (structure.hasSymmetryFunctions && !derivatives) return;
 
    Atom* a = NULL;
    Element* e = NULL;
#ifdef _OPENMP
    #pragma omp parallel for private (a, e)
#endif
    for (size_t i = 0; i < structure.atoms.size(); ++i)
    {
        // Pointer to atom.
        a = &(structure.atoms.at(i));
 
        // Skip calculation for individual atom if results are already saved.
        if (a->hasSymmetryFunctionDerivatives) continue;
        if (a->hasSymmetryFunctions && !derivatives) continue;
 
        // Inform atom if extra charge neuron is present in short-range NN.
        if (nnpType == NNPType::SHORT_CHARGE_NN) a->useChargeNeuron = true;
 
        // Get element of atom and set number of symmetry functions.
        e = &(elements.at(a->element));
        a->numSymmetryFunctions = e->numSymmetryFunctions();
        if (derivatives)
        {
            a->numSymmetryFunctionDerivatives
                = e->getSymmetryFunctionNumTable();
        }
#ifndef N2P2_NO_SF_CACHE
        a->cacheSizePerElement = e->getCacheSizes();
#endif
 
#ifndef N2P2_NO_NEIGH_CHECK
        // Check if atom has low number of neighbors.
        size_t numNeighbors = a->getNumNeighbors(
                                            minCutoffRadius.at(e->getIndex()));
        if (numNeighbors < minNeighbors.at(e->getIndex()))
        {
            log << strpr("WARNING: Structure %6zu Atom %6zu : %zu "
                         "neighbors.\n",
                         a->indexStructure,
                         a->index,
                         numNeighbors);
        }
#endif
 
        // Allocate symmetry function data vectors in atom.
        a->allocate(derivatives);
 
        // Calculate symmetry functions (and derivatives).
        e->calculateSymmetryFunctions(*a, derivatives);
 
        // Remember that symmetry functions of this atom have been calculated.
        a->hasSymmetryFunctions = true;
        if (derivatives) a->hasSymmetryFunctionDerivatives = true;
    }
 
    // If requested, check extrapolation warnings or update statistics.
    // Needed to shift this out of the loop above to make it thread-safe.
    if (checkExtrapolationWarnings)
    {
        for (size_t i = 0; i < structure.atoms.size(); ++i)
        {
            a = &(structure.atoms.at(i));
            e = &(elements.at(a->element));
            e->updateSymmetryFunctionStatistics(*a);
        }
    }
 
    // Remember that symmetry functions of this structure have been calculated.
    structure.hasSymmetryFunctions = true;
    if (derivatives) structure.hasSymmetryFunctionDerivatives = true;
 
    return;
}

References nnp::Atom::allocate(), nnp::Structure::atoms, nnp::Atom::cacheSizePerElement, nnp::Element::calculateSymmetryFunctions(), checkExtrapolationWarnings, nnp::Atom::element, elements, nnp::Element::getCacheSizes(), nnp::Element::getIndex(), nnp::Atom::getNumNeighbors(), nnp::Element::getSymmetryFunctionNumTable(), nnp::Atom::hasSymmetryFunctionDerivatives, nnp::Structure::hasSymmetryFunctionDerivatives, nnp::Atom::hasSymmetryFunctions, nnp::Structure::hasSymmetryFunctions, nnp::Atom::index, nnp::Atom::indexStructure, log, minCutoffRadius, minNeighbors, nnpType, nnp::Atom::numSymmetryFunctionDerivatives, nnp::Atom::numSymmetryFunctions, nnp::Element::numSymmetryFunctions(), SHORT_CHARGE_NN, nnp::strpr(), nnp::Element::updateSymmetryFunctionStatistics(), and nnp::Atom::useChargeNeuron.

Referenced by nnp::Training::calculateError(), nnp::Training::calculateWeightDerivatives(), nnp::Training::dataSetNormalization(), main(), nnp::Prediction::predict(), nnp::InterfaceLammps::process(), and nnp::Training::update().

Here is the call graph for this function:

Here is the caller graph for this function:

calculateSymmetryFunctionGroups()

void Mode::calculateSymmetryFunctionGroups	(	Structure &	structure,
		bool const	derivatives
	)

Calculate all symmetry function groups for all atoms in given structure.

Parameters

[in]	structure	Input structure.
[in]	derivatives	If true calculate also derivatives of symmetry functions.

This function replaces calculateSymmetryFunctions() when symmetry function groups are enabled (faster, default behavior). Results are stored in Atom::G. If derivatives are calculated, additional results are stored in Atom::dGdr and Atom::Neighbor::dGdr.

Definition at line 1230 of file Mode.cpp.

{
    // Skip calculation for whole structure if results are already saved.
    if (structure.hasSymmetryFunctionDerivatives) return;
    if (structure.hasSymmetryFunctions && !derivatives) return;
 
    Atom* a = NULL;
    Element* e = NULL;
#ifdef _OPENMP
    #pragma omp parallel for private (a, e)
#endif
    for (size_t i = 0; i < structure.atoms.size(); ++i)
    {
        // Pointer to atom.
        a = &(structure.atoms.at(i));
 
        // Skip calculation for individual atom if results are already saved.
        if (a->hasSymmetryFunctionDerivatives) continue;
        if (a->hasSymmetryFunctions && !derivatives) continue;
 
        // Inform atom if extra charge neuron is present in short-range NN.
        if (nnpType == NNPType::SHORT_CHARGE_NN) a->useChargeNeuron = true;
 
        // Get element of atom and set number of symmetry functions.
        e = &(elements.at(a->element));
        a->numSymmetryFunctions = e->numSymmetryFunctions();
        if (derivatives)
        {
            a->numSymmetryFunctionDerivatives
                = e->getSymmetryFunctionNumTable();
        }
#ifndef N2P2_NO_SF_CACHE
        a->cacheSizePerElement = e->getCacheSizes();
#endif
 
#ifndef N2P2_NO_NEIGH_CHECK
        // Check if atom has low number of neighbors.
        size_t numNeighbors = a->getNumNeighbors(
                                            minCutoffRadius.at(e->getIndex()));
        if (numNeighbors < minNeighbors.at(e->getIndex()))
        {
            log << strpr("WARNING: Structure %6zu Atom %6zu : %zu "
                         "neighbors.\n",
                         a->indexStructure,
                         a->index,
                         numNeighbors);
        }
#endif
 
        // Allocate symmetry function data vectors in atom.
        a->allocate(derivatives);
 
        // Calculate symmetry functions (and derivatives).
        e->calculateSymmetryFunctionGroups(*a, derivatives);
 
        // Remember that symmetry functions of this atom have been calculated.
        a->hasSymmetryFunctions = true;
        if (derivatives) a->hasSymmetryFunctionDerivatives = true;
    }
 
    // If requested, check extrapolation warnings or update statistics.
    // Needed to shift this out of the loop above to make it thread-safe.
    if (checkExtrapolationWarnings)
    {
        for (size_t i = 0; i < structure.atoms.size(); ++i)
        {
            a = &(structure.atoms.at(i));
            e = &(elements.at(a->element));
            e->updateSymmetryFunctionStatistics(*a);
        }
    }
 
    // Remember that symmetry functions of this structure have been calculated.
    structure.hasSymmetryFunctions = true;
    if (derivatives) structure.hasSymmetryFunctionDerivatives = true;
 
    return;
}

References nnp::Atom::allocate(), nnp::Structure::atoms, nnp::Atom::cacheSizePerElement, nnp::Element::calculateSymmetryFunctionGroups(), checkExtrapolationWarnings, nnp::Atom::element, elements, nnp::Element::getCacheSizes(), nnp::Element::getIndex(), nnp::Atom::getNumNeighbors(), nnp::Element::getSymmetryFunctionNumTable(), nnp::Atom::hasSymmetryFunctionDerivatives, nnp::Structure::hasSymmetryFunctionDerivatives, nnp::Atom::hasSymmetryFunctions, nnp::Structure::hasSymmetryFunctions, nnp::Atom::index, nnp::Atom::indexStructure, log, minCutoffRadius, minNeighbors, nnpType, nnp::Atom::numSymmetryFunctionDerivatives, nnp::Atom::numSymmetryFunctions, nnp::Element::numSymmetryFunctions(), SHORT_CHARGE_NN, nnp::strpr(), nnp::Element::updateSymmetryFunctionStatistics(), and nnp::Atom::useChargeNeuron.

Referenced by nnp::Training::calculateError(), nnp::Training::calculateWeightDerivatives(), nnp::Training::dataSetNormalization(), main(), nnp::Prediction::predict(), nnp::InterfaceLammps::process(), and nnp::Training::update().

Here is the call graph for this function:

Here is the caller graph for this function:

calculateAtomicNeuralNetworks()

void Mode::calculateAtomicNeuralNetworks	(	Structure &	structure,
		bool const	derivatives
	)

Calculate a single atomic neural network for a given atom and nn type.

Parameters

[in]	nnId	Neural network identifier, e.g. "short", "charge".
[in]	atom	Input atom.
[in]	derivatives	If true calculate also derivatives of neural networks with respect to input layer neurons (required for force calculation).

The atomic energy and charge is stored in Atom::energy and Atom::charge, respectively. If derivatives are calculated the results are stored in Atom::dEdG or Atom::dQdG. Calculate atomic neural networks for all atoms in given structure.

Parameters

[in]	structure	Input structure.
[in]	derivatives	If true calculate also derivatives of neural networks with respect to input layer neurons (required for force calculation).

This internally calls calculateAtomicNeuralNetwork with appropriate neural network identifiers depending on the NNP type.

Definition at line 1310 of file Mode.cpp.

{
    if (nnpType == NNPType::SHORT_ONLY)
    {
        for (vector<Atom>::iterator it = structure.atoms.begin();
             it != structure.atoms.end(); ++it)
        {
            NeuralNetwork& nn = elements.at(it->element)
                                .neuralNetworks.at("short");
            nn.setInput(&((it->G).front()));
            nn.propagate();
            if (derivatives)
            {
                nn.calculateDEdG(&((it->dEdG).front()));
            }
            nn.getOutput(&(it->energy));
        }
    }
    else if (nnpType == NNPType::SHORT_CHARGE_NN)
    {
        for (vector<Atom>::iterator it = structure.atoms.begin();
             it != structure.atoms.end(); ++it)
        {
            // First the charge NN.
            NeuralNetwork& nnCharge = elements.at(it->element)
                                      .neuralNetworks.at("charge");
            nnCharge.setInput(&((it->G).front()));
            nnCharge.propagate();
            if (derivatives)
            {
                nnCharge.calculateDEdG(&((it->dQdG).front()));
            }
            nnCharge.getOutput(&(it->charge));
 
            // Now the short-range NN (have to set input neurons individually).
            NeuralNetwork& nnShort = elements.at(it->element)
                                     .neuralNetworks.at("short");
            for (size_t i = 0; i < it->G.size(); ++i)
            {
                nnShort.setInput(i, it->G.at(i));
            }
            // Set additional charge neuron.
            nnShort.setInput(it->G.size(), it->charge);
            nnShort.propagate();
            if (derivatives)
            {
                nnShort.calculateDEdG(&((it->dEdG).front()));
            }
            nnShort.getOutput(&(it->energy));
        }
    }
 
    return;
}

References nnp::Structure::atoms, nnp::NeuralNetwork::calculateDEdG(), elements, nnp::NeuralNetwork::getOutput(), nnpType, nnp::NeuralNetwork::propagate(), nnp::NeuralNetwork::setInput(), SHORT_CHARGE_NN, and SHORT_ONLY.

Referenced by nnp::Training::calculateError(), nnp::Training::dataSetNormalization(), nnp::Training::dPdcN(), main(), nnp::Prediction::predict(), nnp::InterfaceLammps::process(), and nnp::Training::update().

Here is the call graph for this function:

Here is the caller graph for this function:

calculateEnergy()

void Mode::calculateEnergy

(

Structure &

structure

)

const

Calculate potential energy for a given structure.

Parameters

[in]

structure

Input structure.

Sum up potential energy from atomic energy contributions. Result is stored in Structure::energy.

Definition at line 1366 of file Mode.cpp.

{
    // Loop over all atoms and add atomic contributions to total energy.
    structure.energy = 0.0;
    for (vector<Atom>::iterator it = structure.atoms.begin();
         it != structure.atoms.end(); ++it)
    {
        structure.energy += it->energy;
    }
 
    return;
}

References nnp::Structure::atoms, and nnp::Structure::energy.

Referenced by nnp::Training::calculateError(), nnp::Training::dataSetNormalization(), nnp::Training::dPdcN(), main(), nnp::Prediction::predict(), nnp::InterfaceLammps::process(), and nnp::Training::update().

Here is the caller graph for this function:

calculateCharge()

void Mode::calculateCharge

(

Structure &

structure

)

const

Calculate total charge for a given structure.

Parameters

[in]

structure

Input structure.

Sum up charge from atomic charge contributions. Result is stored in Structure::charge.

Definition at line 1379 of file Mode.cpp.

{
    // Loop over all atoms and add atomic charge contributions to total charge.
    structure.charge = 0.0;
    for (vector<Atom>::iterator it = structure.atoms.begin();
         it != structure.atoms.end(); ++it)
    {
        structure.charge += it->charge;
    }
 
    return;
}

References nnp::Structure::atoms, and nnp::Structure::charge.

Referenced by nnp::Prediction::predict().

Here is the caller graph for this function:

calculateForces()

void Mode::calculateForces

(

Structure &

structure

)

const

Calculate forces for all atoms in given structure.

Parameters

[in]

structure

Input structure.

Combine intermediate results from symmetry function and neural network computation to atomic forces. Results are stored in Atom::f.

Definition at line 1392 of file Mode.cpp.

{
    Atom* ai = NULL;
    // Loop over all atoms, center atom i (ai).
#ifdef _OPENMP
    #pragma omp parallel for private(ai)
#endif
    for (size_t i = 0; i < structure.atoms.size(); ++i)
    {
        // Set pointer to atom.
        ai = &(structure.atoms.at(i));
 
        // Reset forces.
        ai->f[0] = 0.0;
        ai->f[1] = 0.0;
        ai->f[2] = 0.0;
 
        // First add force contributions from atom i itself (gradient of
        // atomic energy E_i).
        for (size_t j = 0; j < ai->numSymmetryFunctions; ++j)
        {
            ai->f -= ai->dEdG.at(j) * ai->dGdr.at(j);
        }
 
        // Now loop over all neighbor atoms j of atom i. These may hold
        // non-zero derivatives of their symmetry functions with respect to
        // atom i's coordinates. Some atoms may appear multiple times in the
        // neighbor list because of periodic boundary conditions. To avoid
        // that the same contributions are added multiple times use the
        // "unique neighbor" list. This list contains also the central atom
        // index as first entry and hence also adds contributions of periodic
        // images of the central atom (happens when cutoff radii larger than
        // cell vector lengths are used).
        for (vector<size_t>::const_iterator it = ai->neighborsUnique.begin();
             it != ai->neighborsUnique.end(); ++it)
        {
            // Define shortcut for atom j (aj).
            Atom& aj = structure.atoms.at(*it);
#ifndef N2P2_FULL_SFD_MEMORY
            vector<vector<size_t> > const& tableFull
                = elements.at(aj.element).getSymmetryFunctionTable();
#endif
            // Loop over atom j's neighbors (n), atom i should be one of them.
            for (vector<Atom::Neighbor>::const_iterator n =
                 aj.neighbors.begin(); n != aj.neighbors.end(); ++n)
            {
                // If atom j's neighbor is atom i add force contributions.
                if (n->index == ai->index)
                {
#ifndef N2P2_FULL_SFD_MEMORY
                    vector<size_t> const& table = tableFull.at(n->element);
                    for (size_t j = 0; j < n->dGdr.size(); ++j)
                    {
                        ai->f -= aj.dEdG.at(table.at(j)) * n->dGdr.at(j);
                    }
#else
                    for (size_t j = 0; j < aj.numSymmetryFunctions; ++j)
                    {
                        ai->f -= aj.dEdG.at(j) * n->dGdr.at(j);
                    }
#endif
                }
            }
        }
    }
 
    return;
}

References nnp::Structure::atoms, nnp::Atom::dEdG, nnp::Atom::dGdr, nnp::Atom::element, elements, nnp::Atom::f, nnp::Atom::index, nnp::Atom::neighbors, nnp::Atom::neighborsUnique, and nnp::Atom::numSymmetryFunctions.

Referenced by nnp::Training::calculateError(), nnp::Training::dataSetNormalization(), nnp::Training::dPdcN(), main(), nnp::Prediction::predict(), and nnp::Training::update().

Here is the caller graph for this function:

addEnergyOffset()

void Mode::addEnergyOffset	(	Structure &	structure,
		bool	ref = true
	)

Add atomic energy offsets to reference energy.

Parameters

[in]	structure	Input structure.
[in]	ref	If true, use reference energy, otherwise use NN energy.

Definition at line 1461 of file Mode.cpp.

{
    for (size_t i = 0; i < numElements; ++i)
    {
        if (ref)
        {
            structure.energyRef += structure.numAtomsPerElement.at(i)
                                 * elements.at(i).getAtomicEnergyOffset();
        }
        else
        {
            structure.energy += structure.numAtomsPerElement.at(i)
                              * elements.at(i).getAtomicEnergyOffset();
        }
    }
 
    return;
}

References elements, nnp::Structure::energy, nnp::Structure::energyRef, nnp::Structure::numAtomsPerElement, and numElements.

Referenced by main(), nnp::Prediction::predict(), nnp::InterfaceLammps::process(), and nnp::Training::writeSetsToFiles().

Here is the caller graph for this function:

removeEnergyOffset()

void Mode::removeEnergyOffset	(	Structure &	structure,
		bool	ref = true
	)

Remove atomic energy offsets from reference energy.

Parameters

[in]	structure	Input structure.
[in]	ref	If true, use reference energy, otherwise use NN energy.

This function should be called immediately after structures are read in.

Definition at line 1480 of file Mode.cpp.

{
    for (size_t i = 0; i < numElements; ++i)
    {
        if (ref)
        {
            structure.energyRef -= structure.numAtomsPerElement.at(i)
                                 * elements.at(i).getAtomicEnergyOffset();
        }
        else
        {
            structure.energy -= structure.numAtomsPerElement.at(i)
                              * elements.at(i).getAtomicEnergyOffset();
        }
    }
 
    return;
}

References elements, nnp::Structure::energy, nnp::Structure::energyRef, nnp::Structure::numAtomsPerElement, and numElements.

Referenced by nnp::Dataset::distributeStructures(), nnp::Prediction::readStructureFromFile(), and nnp::Training::writeSetsToFiles().

Here is the caller graph for this function:

getEnergyOffset()

double Mode::getEnergyOffset

(

Structure const &

structure

)

const

Get atomic energy offset for given structure.

Parameters

[in]

structure

Input structure.

Returns

Summed atomic energy offsets for structure.

Definition at line 1499 of file Mode.cpp.

{
    double result = 0.0;
 
    for (size_t i = 0; i < numElements; ++i)
    {
        result += structure.numAtomsPerElement.at(i)
                * elements.at(i).getAtomicEnergyOffset();
    }
 
    return result;
}

References elements, nnp::Structure::numAtomsPerElement, and numElements.

Referenced by main(), and nnp::Dataset::writeSymmetryFunctionFile().

Here is the caller graph for this function:

getEnergyWithOffset()

double Mode::getEnergyWithOffset	(	Structure const &	structure,
		bool	ref = true
	)		const

Add atomic energy offsets and return energy.

Parameters

[in]	structure	Input structure.
[in]	ref	If true, use reference energy, otherwise use NN energy.

Returns

Reference or NNP energy with energy offsets added.

Note

If normalization is used, ensure that structure energy is already in physical units.

Definition at line 1512 of file Mode.cpp.

{
    double result;
    if (ref) result = structure.energyRef;
    else     result = structure.energy;
 
    for (size_t i = 0; i < numElements; ++i)
    {
        result += structure.numAtomsPerElement.at(i)
                * elements.at(i).getAtomicEnergyOffset();
    }
 
    return result;
}

References elements, nnp::Structure::energy, nnp::Structure::energyRef, nnp::Structure::numAtomsPerElement, and numElements.

Referenced by nnp::Training::dataSetNormalization(), and main().

Here is the caller graph for this function:

normalized()

double Mode::normalized	(	std::string const &	property,
		double	value
	)		const

Apply normalization to given property.

Parameters

[in]	property	One of "energy", "force".
[in]	value	Input property value in physical units.

Returns

Property in normalized units.

Definition at line 1527 of file Mode.cpp.

{
    if      (property == "energy") return value * convEnergy;
    else if (property == "force") return value * convEnergy / convLength;
    else throw runtime_error("ERROR: Unknown property to convert to "
                             "normalized units.\n");
}

References convEnergy, and convLength.

normalizedEnergy()

double Mode::normalizedEnergy	(	Structure const &	structure,
		bool	ref = true
	)		const

Apply normalization to given energy of structure.

Parameters

[in]	structure	Input structure with energy in physical units.
[in]	ref	If true, use reference energy, otherwise use NN energy.

Returns

Energy in normalized units.

Definition at line 1535 of file Mode.cpp.

{
    if (ref)
    {
        return (structure.energyRef - structure.numAtoms * meanEnergy)
               * convEnergy;
    }
    else
    {
        return (structure.energy - structure.numAtoms * meanEnergy)
               * convEnergy;
    }
}

References convEnergy, nnp::Structure::energy, nnp::Structure::energyRef, meanEnergy, and nnp::Structure::numAtoms.

physical()

double Mode::physical	(	std::string const &	property,
		double	value
	)		const

Undo normalization for a given property.

Parameters

[in]	property	One of "energy", "force".
[in]	value	Input property value in normalized units.

Returns

Property in physical units.

Definition at line 1549 of file Mode.cpp.

{
    if      (property == "energy") return value / convEnergy;
    else if (property == "force") return value * convLength / convEnergy;
    else throw runtime_error("ERROR: Unknown property to convert to physical "
                             "units.\n");
}

References convEnergy, and convLength.

Referenced by nnp::InterfaceLammps::getAtomicEnergy(), main(), nnp::Training::printEpoch(), and nnp::Training::writeLearningCurve().

Here is the caller graph for this function:

physicalEnergy()

double Mode::physicalEnergy	(	Structure const &	structure,
		bool	ref = true
	)		const

Undo normalization for a given energy of structure.

Parameters

[in]	structure	Input structure with energy in normalized units.
[in]	ref	If true, use reference energy, otherwise use NN energy.

Returns

Energy in physical units.

Definition at line 1557 of file Mode.cpp.

{
    if (ref)
    {
        return structure.energyRef / convEnergy + structure.numAtoms
               * meanEnergy;
    }
    else
    {
        return structure.energy / convEnergy + structure.numAtoms * meanEnergy;
    }
}

References convEnergy, nnp::Structure::energy, nnp::Structure::energyRef, meanEnergy, and nnp::Structure::numAtoms.

Referenced by main(), nnp::InterfaceLammps::process(), and nnp::Dataset::writeSymmetryFunctionFile().

Here is the caller graph for this function:

convertToNormalizedUnits()

void Mode::convertToNormalizedUnits

(

Structure &

structure

)

const

Convert one structure to normalized units.

Parameters

[in,out]

structure

Input structure.

Definition at line 1570 of file Mode.cpp.

{
    structure.toNormalizedUnits(meanEnergy, convEnergy, convLength);
 
    return;
}

References convEnergy, convLength, meanEnergy, and nnp::Structure::toNormalizedUnits().

Here is the call graph for this function:

convertToPhysicalUnits()

void Mode::convertToPhysicalUnits

(

Structure &

structure

)

const

Convert one structure to physical units.

Parameters

[in,out]

structure

Input structure.

Definition at line 1577 of file Mode.cpp.

{
    structure.toPhysicalUnits(meanEnergy, convEnergy, convLength);
 
    return;
}

References convEnergy, convLength, meanEnergy, and nnp::Structure::toPhysicalUnits().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

getNumExtrapolationWarnings()

size_t Mode::getNumExtrapolationWarnings

(

)

const

Count total number of extrapolation warnings encountered for all elements and symmetry functions.

Returns

Number of extrapolation warnings.

Definition at line 1595 of file Mode.cpp.

{
    size_t numExtrapolationWarnings = 0;
 
    for (vector<Element>::const_iterator it = elements.begin();
         it != elements.end(); ++it)
    {
        numExtrapolationWarnings +=
            it->statistics.countExtrapolationWarnings();
    }
 
    return numExtrapolationWarnings;
}

References elements.

Referenced by LAMMPS_NS::PairNNP::handleExtrapolationWarnings(), and main().

Here is the caller graph for this function:

resetExtrapolationWarnings()

void Mode::resetExtrapolationWarnings

(

)

Erase all extrapolation warnings and reset counters.

Definition at line 1584 of file Mode.cpp.

{
    for (vector<Element>::iterator it = elements.begin();
         it != elements.end(); ++it)
    {
        it->statistics.resetExtrapolationWarnings();
    }
 
    return;
}

References elements.

Referenced by main().

Here is the caller graph for this function:

getNnpType()

Mode::NNPType nnp::Mode::getNnpType ( ) const

inline

Getter for Mode::nnpType.

Returns

Type of NNP that was set up.

Definition at line 543 of file Mode.h.

{
    return nnpType;
}

References nnpType.

Referenced by main().

Here is the caller graph for this function:

getMeanEnergy()

double nnp::Mode::getMeanEnergy ( ) const

inline

Getter for Mode::meanEnergy.

Returns

Mean energy per atom.

Definition at line 548 of file Mode.h.

{
    return meanEnergy;
}

References meanEnergy.

Referenced by main().

Here is the caller graph for this function:

getConvEnergy()

double nnp::Mode::getConvEnergy ( ) const

inline

Getter for Mode::convEnergy.

Returns

Energy unit conversion factor.

Definition at line 553 of file Mode.h.

{
    return convEnergy;
}

References convEnergy.

Referenced by main().

Here is the caller graph for this function:

getConvLength()

double nnp::Mode::getConvLength ( ) const

inline

Getter for Mode::convLength.

Returns

Length unit conversion factor.

Definition at line 558 of file Mode.h.

{
    return convLength;
}

References convLength.

Referenced by main().

Here is the caller graph for this function:

getMaxCutoffRadius()

double nnp::Mode::getMaxCutoffRadius ( ) const

inline

Getter for Mode::maxCutoffRadius.

Returns

Maximum cutoff radius of all symmetry functions.

The maximum cutoff radius is determined by setupSymmetryFunctions().

Definition at line 563 of file Mode.h.

{
    return maxCutoffRadius;
}

References maxCutoffRadius.

Referenced by main(), and nnp::SetupAnalysis::writeSymmetryFunctionShape().

Here is the caller graph for this function:

getNumElements()

std::size_t nnp::Mode::getNumElements ( ) const

inline

Getter for Mode::numElements.

Returns

Number of elements defined.

The number of elements is determined by setupElements().

Definition at line 568 of file Mode.h.

{
    return numElements;
}

References numElements.

Referenced by main().

Here is the caller graph for this function:

getNumSymmetryFunctions()

vector< size_t > Mode::getNumSymmetryFunctions

(

)

const

Get number of symmetry functions per element.

Returns

Vector with number of symmetry functions for each element.

Definition at line 1609 of file Mode.cpp.

{
    vector<size_t> v;
 
    for (vector<Element>::const_iterator it = elements.begin();
         it != elements.end(); ++it)
    {
        v.push_back(it->numSymmetryFunctions());
    }
 
    return v;
}

References elements.

Referenced by main().

Here is the caller graph for this function:

useNormalization()

bool nnp::Mode::useNormalization ( ) const

inline

Check if normalization is enabled.

Returns

Value of normalize.

Definition at line 573 of file Mode.h.

{
    return normalize;
}

References normalize.

Referenced by main().

Here is the caller graph for this function:

settingsKeywordExists()

bool Mode::settingsKeywordExists

(

std::string const &

keyword

)

const

Check if keyword was found in settings file.

Parameters

[in]

keyword

Keyword for which value is requested.

Returns

true if keyword exists, false otherwise.

Definition at line 1622 of file Mode.cpp.

{
    return settings.keywordExists(keyword);
}

References nnp::Settings::keywordExists(), and settings.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

settingsGetValue()

string Mode::settingsGetValue

(

std::string const &

keyword

)

const

Get value for given keyword in Settings instance.

Parameters

[in]

keyword

Keyword for which value is requested.

Returns

Value string corresponding to keyword.

Definition at line 1627 of file Mode.cpp.

{
    return settings.getValue(keyword);
}

References nnp::Settings::getValue(), and settings.

Here is the call graph for this function:

pruneSymmetryFunctionsRange()

vector< size_t > Mode::pruneSymmetryFunctionsRange

(

double

threshold

)

Prune symmetry functions according to their range and write settings file.

Parameters

[in]

threshold

Symmetry functions with range (max - min) smaller than this threshold will be pruned.

Returns

List of line numbers with symmetry function to be removed.

Definition at line 1657 of file Mode.cpp.

{
    vector<size_t> prune;
 
    // Check if symmetry functions have low range.
    for (vector<Element>::const_iterator it = elements.begin();
         it != elements.end(); ++it)
    {
        for (size_t i = 0; i < it->numSymmetryFunctions(); ++i)
        {
            SymFnc const& s = it->getSymmetryFunction(i);
            if (fabs(s.getGmax() - s.getGmin()) < threshold)
            {
                prune.push_back(it->getSymmetryFunction(i).getLineNumber());
            }
        }
    }
 
    return prune;
}

References elements, nnp::SymFnc::getGmax(), and nnp::SymFnc::getGmin().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

pruneSymmetryFunctionsSensitivity()

vector< size_t > Mode::pruneSymmetryFunctionsSensitivity	(	double	threshold,
		std::vector< std::vector< double > >	sensitivity
	)

Prune symmetry functions with sensitivity analysis data.

Parameters

[in]	threshold	Symmetry functions with sensitivity lower than this threshold will be pruned.
[in]	sensitivity	Sensitivity data for each element and symmetry function.

Returns

List of line numbers with symmetry function to be removed.

Definition at line 1678 of file Mode.cpp.

{
    vector<size_t> prune;
 
    for (size_t i = 0; i < numElements; ++i)
    {
        for (size_t j = 0; j < elements.at(i).numSymmetryFunctions(); ++j)
        {
            if (sensitivity.at(i).at(j) < threshold)
            {
                prune.push_back(
                        elements.at(i).getSymmetryFunction(j).getLineNumber());
            }
        }
    }
 
    return prune;
}

References elements, and numElements.

Referenced by main().

Here is the caller graph for this function:

writePrunedSettingsFile()

void Mode::writePrunedSettingsFile	(	std::vector< std::size_t >	prune,
		std::string	fileName = "output.nn"
	)		const

Copy settings file but comment out lines provided.

Parameters

[in]	prune	List of line numbers to comment out.
[in]	fileName	Output file name.

Definition at line 1633 of file Mode.cpp.

{
    ofstream file(fileName.c_str());
    vector<string> settingsLines = settings.getSettingsLines();
    for (size_t i = 0; i < settingsLines.size(); ++i)
    {
        if (find(prune.begin(), prune.end(), i) != prune.end())
        {
            file << "# ";
        }
        file << settingsLines.at(i) << '\n';
    }
    file.close();
 
    return;
}

References nnp::Settings::getSettingsLines(), and settings.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

writeSettingsFile()

void Mode::writeSettingsFile

(

std::ofstream *const &

file

)

const

Write complete settings file.

Parameters

[in,out]

file

Settings file.

Definition at line 1650 of file Mode.cpp.

{
    settings.writeSettingsFile(file);
 
    return;
}

References settings, and nnp::Settings::writeSettingsFile().

Referenced by nnp::Training::dataSetNormalization(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

readNeuralNetworkWeights()

void Mode::readNeuralNetworkWeights ( std::string const &  type, std::string const &  fileName  )

protected

Read in weights for a specific type of neural network.

Parameters

[in]	type	Actual network type to initialize ("short" or "charge").
[in]	fileNameFormat	Weights file name format.

Definition at line 1699 of file Mode.cpp.

{
    string s = "";
    if      (type == "short" ) s = "short  NN";
    else if (type == "charge") s = "charge NN";
    else
    {
        throw runtime_error("ERROR: Unknown neural network type.\n");
    }
 
    for (vector<Element>::iterator it = elements.begin();
         it != elements.end(); ++it)
    {
        string fileName = strpr(fileNameFormat.c_str(),
                                it->getAtomicNumber());
        log << strpr("Setting %s weights for element %2s from file: %s\n",
                     s.c_str(),
                     it->getSymbol().c_str(),
                     fileName.c_str());
        vector<double> weights = readColumnsFromFile(fileName,
                                                     vector<size_t>(1, 0)
                                                    ).at(0);
        NeuralNetwork& nn = it->neuralNetworks.at(type);
        nn.setConnections(&(weights.front()));
    }
 
    return;
}

References elements, log, nnp::readColumnsFromFile(), nnp::NeuralNetwork::setConnections(), and nnp::strpr().

Referenced by nnp::Training::initializeWeights(), setupNeuralNetworkWeights(), and nnp::Training::setupNumericDerivCheck().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

elementMap

ElementMap nnp::Mode::elementMap

Global element map, populated by setupElementMap().

Definition at line 508 of file Mode.h.

Referenced by nnp::Dataset::distributeStructures(), nnp::InterfaceLammps::initialize(), main(), nnp::Dataset::prepareNumericForces(), nnp::Prediction::readStructureFromFile(), nnp::Training::selectSets(), setupElementMap(), setupElements(), setupNeuralNetwork(), setupSymmetryFunctionCache(), setupSymmetryFunctionMemory(), setupSymmetryFunctions(), nnp::Dataset::writeAtomicEnvironmentFile(), nnp::Dataset::writeNeighborLists(), nnp::Dataset::writeSymmetryFunctionFile(), nnp::Dataset::writeSymmetryFunctionHistograms(), and nnp::Training::writeUpdaterStatus().

log

Log nnp::Mode::log

Global log file.

Definition at line 510 of file Mode.h.

Referenced by nnp::Training::allocateArrays(), nnp::Training::calculateNeighborLists(), calculateSymmetryFunctionGroups(), calculateSymmetryFunctions(), nnp::Training::checkSelectionMode(), nnp::Dataset::collectSymmetryFunctionStatistics(), nnp::Training::dataSetNormalization(), nnp::Dataset::distributeStructures(), LAMMPS_NS::PairNNP::init_style(), initialize(), nnp::InterfaceLammps::initialize(), nnp::Training::initializeWeights(), nnp::Training::initializeWeightsMemory(), loadSettingsFile(), nnp::Training::loop(), main(), nnp::Training::printEpoch(), nnp::Training::printHeader(), nnp::Training::randomizeNeuralNetworkWeights(), readNeuralNetworkWeights(), nnp::Training::selectSets(), setupCutoff(), setupElementMap(), setupElements(), nnp::Training::setupFileOutput(), nnp::Dataset::setupMPI(), setupNeuralNetwork(), setupNeuralNetworkWeights(), setupNormalization(), nnp::Training::setupNumericDerivCheck(), nnp::Dataset::setupRandomNumberGenerator(), nnp::Training::setupSelectionMode(), setupSymmetryFunctionCache(), setupSymmetryFunctionGroups(), setupSymmetryFunctionMemory(), setupSymmetryFunctions(), setupSymmetryFunctionScaling(), setupSymmetryFunctionScalingNone(), setupSymmetryFunctionStatistics(), nnp::Training::setupTraining(), nnp::Training::setupUpdatePlan(), nnp::Dataset::sortNeighborLists(), nnp::Dataset::writeAtomicEnvironmentFile(), nnp::InterfaceLammps::writeExtrapolationWarnings(), nnp::Dataset::writeNeighborHistogram(), nnp::Dataset::writeNeighborLists(), nnp::Training::writeSetsToFiles(), nnp::Dataset::writeSymmetryFunctionFile(), nnp::Dataset::writeSymmetryFunctionHistograms(), nnp::Dataset::writeSymmetryFunctionScaling(), and nnp::SetupAnalysis::writeSymmetryFunctionShape().

nnpType

NNPType nnp::Mode::nnpType

protected

Definition at line 513 of file Mode.h.

Referenced by calculateAtomicNeuralNetworks(), calculateSymmetryFunctionGroups(), calculateSymmetryFunctions(), nnp::Training::dataSetNormalization(), getNnpType(), nnp::Training::initializeWeights(), loadSettingsFile(), nnp::Prediction::predict(), nnp::Training::setStage(), setupNeuralNetwork(), nnp::Training::setupNumericDerivCheck(), nnp::Training::setupTraining(), nnp::Training::update(), nnp::Training::writeLearningCurve(), nnp::Training::writeNeuronStatisticsEpoch(), nnp::Training::writeTimingData(), nnp::Training::writeUpdaterStatus(), and nnp::Training::writeWeightsEpoch().

normalize

bool nnp::Mode::normalize

protected

Definition at line 514 of file Mode.h.

Referenced by nnp::InterfaceLammps::addNeighbor(), nnp::Training::calculateNeighborLists(), nnp::Training::dataSetNormalization(), nnp::InterfaceLammps::getAtomicEnergy(), nnp::InterfaceLammps::getForces(), nnp::InterfaceLammps::getMaxCutoffRadius(), nnp::Prediction::predict(), nnp::Training::printEpoch(), nnp::InterfaceLammps::process(), nnp::Prediction::readStructureFromFile(), setupNormalization(), setupSymmetryFunctions(), useNormalization(), nnp::Training::writeLearningCurve(), and nnp::Dataset::writeSymmetryFunctionFile().

checkExtrapolationWarnings

bool nnp::Mode::checkExtrapolationWarnings

protected

Definition at line 515 of file Mode.h.

Referenced by calculateSymmetryFunctionGroups(), calculateSymmetryFunctions(), and setupSymmetryFunctionStatistics().

useChargeNN

bool nnp::Mode::useChargeNN

protected

Definition at line 516 of file Mode.h.

Referenced by loadSettingsFile(), setupNeuralNetwork(), and setupNeuralNetworkWeights().

numElements

std::size_t nnp::Mode::numElements

protected

Definition at line 517 of file Mode.h.

Referenced by addEnergyOffset(), nnp::Training::calculateWeightDerivatives(), nnp::Training::dPdcN(), getEnergyOffset(), getEnergyWithOffset(), getNumElements(), nnp::Training::getWeights(), nnp::Training::initializeWeightsMemory(), pruneSymmetryFunctionsSensitivity(), nnp::Training::randomizeNeuralNetworkWeights(), removeEnergyOffset(), nnp::Training::selectSets(), nnp::InterfaceLammps::setLocalAtoms(), setupElements(), setupNeuralNetwork(), setupSymmetryFunctionCache(), setupSymmetryFunctionMemory(), setupSymmetryFunctions(), nnp::Training::setWeights(), nnp::Training::update(), nnp::Dataset::writeAtomicEnvironmentFile(), nnp::Dataset::writeNeighborLists(), nnp::Training::writeNeuronStatistics(), nnp::SetupAnalysis::writeSymmetryFunctionShape(), and nnp::Training::writeWeights().

minNeighbors

std::vector<std::size_t> nnp::Mode::minNeighbors

protected

Definition at line 518 of file Mode.h.

Referenced by calculateSymmetryFunctionGroups(), calculateSymmetryFunctions(), setupSymmetryFunctions(), and nnp::Dataset::writeNeighborHistogram().

minCutoffRadius

std::vector<double> nnp::Mode::minCutoffRadius

protected

Definition at line 519 of file Mode.h.

Referenced by calculateSymmetryFunctionGroups(), calculateSymmetryFunctions(), and setupSymmetryFunctions().

maxCutoffRadius

double nnp::Mode::maxCutoffRadius

protected

Definition at line 520 of file Mode.h.

Referenced by nnp::Training::calculateNeighborLists(), nnp::Training::dataSetNormalization(), getMaxCutoffRadius(), nnp::InterfaceLammps::getMaxCutoffRadius(), nnp::Prediction::predict(), and setupSymmetryFunctions().

cutoffAlpha

double nnp::Mode::cutoffAlpha

protected

Definition at line 521 of file Mode.h.

Referenced by setupCutoff(), and setupSymmetryFunctions().

meanEnergy

double nnp::Mode::meanEnergy

protected

Definition at line 522 of file Mode.h.

Referenced by convertToNormalizedUnits(), convertToPhysicalUnits(), nnp::Training::dataSetNormalization(), nnp::InterfaceLammps::getAtomicEnergy(), getMeanEnergy(), normalizedEnergy(), physicalEnergy(), nnp::Prediction::predict(), nnp::Prediction::readStructureFromFile(), setupNormalization(), nnp::Dataset::toNormalizedUnits(), and nnp::Dataset::toPhysicalUnits().

convEnergy

double nnp::Mode::convEnergy

protected

Definition at line 523 of file Mode.h.

Referenced by convertToNormalizedUnits(), convertToPhysicalUnits(), nnp::Training::dataSetNormalization(), getConvEnergy(), nnp::InterfaceLammps::getForces(), normalized(), normalizedEnergy(), physical(), physicalEnergy(), nnp::Prediction::predict(), nnp::Prediction::readStructureFromFile(), setupNormalization(), nnp::Dataset::toNormalizedUnits(), and nnp::Dataset::toPhysicalUnits().

convLength

double nnp::Mode::convLength

protected

Definition at line 524 of file Mode.h.

Referenced by nnp::InterfaceLammps::addNeighbor(), nnp::Training::calculateNeighborLists(), convertToNormalizedUnits(), convertToPhysicalUnits(), nnp::Training::dataSetNormalization(), getConvLength(), nnp::InterfaceLammps::getForces(), nnp::InterfaceLammps::getMaxCutoffRadius(), normalized(), physical(), nnp::Prediction::predict(), nnp::Prediction::readStructureFromFile(), setupNormalization(), setupSymmetryFunctions(), nnp::Dataset::toNormalizedUnits(), and nnp::Dataset::toPhysicalUnits().

settings

Settings nnp::Mode::settings

protected

Definition at line 525 of file Mode.h.

Referenced by nnp::Training::dataSetNormalization(), nnp::Training::initializeWeights(), loadSettingsFile(), nnp::Training::randomizeNeuralNetworkWeights(), nnp::Training::selectSets(), nnp::Training::setStage(), settingsGetValue(), settingsKeywordExists(), setupCutoff(), setupElementMap(), setupElements(), nnp::Training::setupFileOutput(), setupNeuralNetwork(), setupNormalization(), nnp::Dataset::setupRandomNumberGenerator(), nnp::Training::setupSelectionMode(), setupSymmetryFunctions(), setupSymmetryFunctionScaling(), nnp::Training::setupTraining(), nnp::Training::setupUpdatePlan(), writePrunedSettingsFile(), and writeSettingsFile().

scalingType

SymFnc::ScalingType nnp::Mode::scalingType

protected

Definition at line 526 of file Mode.h.

Referenced by setupSymmetryFunctionScaling().

cutoffType

CutoffFunction::CutoffType nnp::Mode::cutoffType

protected

Definition at line 527 of file Mode.h.

Referenced by setupCutoff(), and setupSymmetryFunctions().

elements

std::vector<Element> nnp::Mode::elements

protected

Definition at line 528 of file Mode.h.

Referenced by addEnergyOffset(), calculateAtomicNeuralNetworks(), calculateForces(), calculateSymmetryFunctionGroups(), calculateSymmetryFunctions(), nnp::Training::calculateWeightDerivatives(), nnp::InterfaceLammps::clearExtrapolationWarnings(), nnp::Training::collectDGdxia(), nnp::Dataset::collectSymmetryFunctionStatistics(), nnp::Training::dataSetNormalization(), nnp::Training::dPdc(), nnp::InterfaceLammps::extractEWBuffer(), nnp::InterfaceLammps::fillEWBuffer(), nnp::InterfaceLammps::getAtomicEnergy(), nnp::Training::getConnectionOffsets(), getEnergyOffset(), getEnergyWithOffset(), nnp::InterfaceLammps::getEWBufferSize(), nnp::InterfaceLammps::getForces(), nnp::Training::getNumConnections(), nnp::Training::getNumConnectionsPerElement(), getNumExtrapolationWarnings(), getNumSymmetryFunctions(), nnp::Training::getWeights(), nnp::Training::initializeWeightsMemory(), pruneSymmetryFunctionsRange(), pruneSymmetryFunctionsSensitivity(), nnp::Training::randomizeNeuralNetworkWeights(), readNeuralNetworkWeights(), removeEnergyOffset(), resetExtrapolationWarnings(), nnp::Training::resetNeuronStatistics(), setupElements(), setupNeuralNetwork(), setupSymmetryFunctionCache(), setupSymmetryFunctionGroups(), setupSymmetryFunctionMemory(), setupSymmetryFunctions(), setupSymmetryFunctionScaling(), setupSymmetryFunctionScalingNone(), setupSymmetryFunctionStatistics(), nnp::Training::setupTraining(), nnp::Training::setWeights(), nnp::Training::update(), nnp::InterfaceLammps::writeExtrapolationWarnings(), nnp::Training::writeNeuronStatistics(), nnp::Dataset::writeSymmetryFunctionHistograms(), nnp::Dataset::writeSymmetryFunctionScaling(), nnp::SetupAnalysis::writeSymmetryFunctionShape(), and nnp::Training::writeWeights().

---

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

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