n2p2 - A neural network potential package
Functions
nnp-dataset.cpp File Reference
#include "Dataset.h"
#include "mpi-extra.h"
#include "utility.h"
#include <mpi.h>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <map>
#include <string>
#include <vector>
Include dependency graph for nnp-dataset.cpp:

Go to the source code of this file.

Functions

int main (int argc, char *argv[])
 

Function Documentation

◆ main()

int main ( int  argc,
char *  argv[] 
)

Definition at line 33 of file nnp-dataset.cpp.

34{
35 bool shuffle = false;
36 bool useForces = false;
37 bool normalize = false;
38 int numProcs = 0;
39 int myRank = 0;
40 size_t countEnergy = 0;
41 size_t countForces = 0;
42 map<string, double> errorEnergy;
43 map<string, double> errorForces;
44 string fileName;
45 ofstream fileEnergy;
46 ofstream fileForces;
47 ofstream fileOutputData;
48 ofstream myLog;
49
50 errorEnergy["RMSEpa"] = 0.0;
51 errorEnergy["RMSE"] = 0.0;
52 errorEnergy["MAEpa"] = 0.0;
53 errorEnergy["MAE"] = 0.0;
54 errorForces["RMSE"] = 0.0;
55 errorForces["MAE"] = 0.0;
56
57 if (argc != 2)
58 {
59 cout << "USAGE: " << argv[0] << " <shuffle>\n"
60 << " <shuffle> ... Randomly distribute structures to MPI"
61 " processes (0/1 = no/yes).\n"
62 << " Execute in directory with these NNP files present:\n"
63 << " - input.data (structure file)\n"
64 << " - input.nn (NNP settings)\n"
65 << " - scaling.data (symmetry function scaling data)\n"
66 << " - \"weights.%%03d.data\" (weights files)\n";
67 return 1;
68 }
69
70 shuffle = (bool)atoi(argv[1]);
71
72 MPI_Init(&argc, &argv);
73 MPI_Comm_size(MPI_COMM_WORLD, &numProcs);
74 MPI_Comm_rank(MPI_COMM_WORLD, &myRank);
75
76 Dataset dataset;
77 if (myRank != 0) dataset.log.writeToStdout = false;
78 myLog.open(strpr("nnp-dataset.log.%04d", myRank).c_str());
79 dataset.log.registerStreamPointer(&myLog);
80 dataset.setupMPI();
81 dataset.initialize();
82 dataset.loadSettingsFile();
83 dataset.setupGeneric();
84 normalize = dataset.useNormalization();
85 dataset.setupSymmetryFunctionScaling();
86 dataset.setupSymmetryFunctionStatistics(false, false, true, false);
87 dataset.setupNeuralNetworkWeights();
88 if (shuffle) dataset.setupRandomNumberGenerator();
89 dataset.distributeStructures(shuffle);
90 if (normalize) dataset.toNormalizedUnits();
91
92 dataset.log << "\n";
93 dataset.log << "*** DATA SET PREDICTION *****************"
94 "**************************************\n";
95 dataset.log << "\n";
96
97 useForces = dataset.settingsKeywordExists("use_short_forces");
98 if (useForces)
99 {
100 dataset.log << "Energies and forces are predicted.\n";
101 }
102 else
103 {
104 dataset.log << "Only energies are predicted.\n";
105 }
106
107 // Set up sensitivity vectors.
108 size_t numElements = dataset.getNumElements();
109 vector<size_t> numSymmetryFunctions = dataset.getNumSymmetryFunctions();
110 vector<size_t> count(numElements, 0);
111 vector<vector<double> > sensMean;
112 vector<vector<double> > sensMax;
113 sensMean.resize(numElements);
114 sensMax.resize(numElements);
115 for (size_t i = 0; i < numElements; ++i)
116 {
117 sensMean.at(i).resize(numSymmetryFunctions.at(i), 0.0);
118 sensMax.at(i).resize(numSymmetryFunctions.at(i), 0.0);
119 }
120
121 // Set up error files for energy and forces RMSEs.
122 fileName = strpr("energy.comp.%04d", myRank);
123 fileEnergy.open(fileName.c_str());
124
125 // File header.
126 if (myRank == 0)
127 {
128 vector<string> title;
129 vector<string> colName;
130 vector<string> colInfo;
131 vector<size_t> colSize;
132 title.push_back("Energy comparison.");
133 colSize.push_back(10);
134 colName.push_back("index");
135 colInfo.push_back("Structure index.");
136 colSize.push_back(10);
137 colName.push_back("N");
138 colInfo.push_back("Number of atoms in structure.");
139 colSize.push_back(16);
140 colName.push_back("Eref_phys");
141 colInfo.push_back("Reference potential energy (physical units, "
142 "atomic energy offsets added).");
143 colSize.push_back(16);
144 colName.push_back("Ennp_phys");
145 colInfo.push_back("NNP potential energy (physical units, "
146 "atomic energy offsets added).");
147 if (normalize)
148 {
149 colSize.push_back(16);
150 colName.push_back("Eref_int");
151 colInfo.push_back("Reference potential energy (internal units).");
152 colSize.push_back(16);
153 colName.push_back("Ennp_int");
154 colInfo.push_back("NNP potential energy (internal units).");
155 }
156 appendLinesToFile(fileEnergy,
157 createFileHeader(title, colSize, colName, colInfo));
158 }
159 if (useForces)
160 {
161 fileName = strpr("forces.comp.%04d", myRank);
162 fileForces.open(fileName.c_str());
163
164 // File header.
165 if (myRank == 0)
166 {
167 vector<string> title;
168 vector<string> colName;
169 vector<string> colInfo;
170 vector<size_t> colSize;
171 title.push_back("Force comparison.");
172 colSize.push_back(10);
173 colName.push_back("index_s");
174 colInfo.push_back("Structure index.");
175 colSize.push_back(10);
176 colName.push_back("index_a");
177 colInfo.push_back("Atom index (x, y, z components in consecutive "
178 "lines).");
179 colSize.push_back(16);
180 colName.push_back("Fref_phys");
181 colInfo.push_back("Reference force (physical units).");
182 colSize.push_back(16);
183 colName.push_back("Fnnp_phys");
184 colInfo.push_back("NNP force (physical units).");
185 if (normalize)
186 {
187 colSize.push_back(16);
188 colName.push_back("Fref_int");
189 colInfo.push_back("Reference force (internal units).");
190 colSize.push_back(16);
191 colName.push_back("Fnnp_int");
192 colInfo.push_back("NNP force (internal units).");
193 }
194 appendLinesToFile(fileForces,
195 createFileHeader(title,
196 colSize,
197 colName,
198 colInfo));
199 }
200 }
201
202 // Open output.data file.
203 fileName = strpr("output.data.%04d", myRank);
204 fileOutputData.open(fileName.c_str());
205
206 for (vector<Structure>::iterator it = dataset.structures.begin();
207 it != dataset.structures.end(); ++it)
208 {
209 it->calculateNeighborList(dataset.getMaxCutoffRadius());
210#ifdef N2P2_NO_SF_GROUPS
211 dataset.calculateSymmetryFunctions((*it), useForces);
212#else
213 dataset.calculateSymmetryFunctionGroups((*it), useForces);
214#endif
215 // Manually allocate dEdG vectors.
216 for (vector<Atom>::iterator it2 = it->atoms.begin();
217 it2 != it->atoms.end(); ++it2)
218 {
219 size_t const& e = it2->element;
220 it2->dEdG.resize(numSymmetryFunctions.at(e), 0.0);
221 }
222 // Set derivatives argument to true in any case to fill dEdG vectors
223 // in atom storage.
224 dataset.calculateAtomicNeuralNetworks((*it), true);
225 dataset.calculateEnergy((*it));
226 if (useForces) dataset.calculateForces((*it));
227 // Loop over atoms, collect sensitivity data and clear memory.
228 for (vector<Atom>::iterator it2 = it->atoms.begin();
229 it2 != it->atoms.end(); ++it2)
230 {
231 // Collect sensitivity data.
232 size_t const& e = it2->element;
233 count.at(e)++;
234 for (size_t i = 0; i < numSymmetryFunctions.at(e); ++i)
235 {
236 double const& s = it2->dEdG.at(i);
237 sensMean.at(e).at(i) += s * s;
238 sensMax.at(e).at(i) = max(sensMax.at(e).at(i), abs(s));
239 }
240 // Clear unneccessary memory (neighbor list and others), energies
241 // and forces are still stored. Don't use these structures after
242 // these operations unless you know what you do!
243 it2->numNeighborsUnique = 0;
244 it2->neighborsUnique.clear();
245 vector<size_t>(it2->neighborsUnique).swap(it2->neighborsUnique);
246
247 it2->numNeighborsPerElement.clear();
248 vector<size_t>(it2->numNeighborsPerElement).swap(
249 it2->numNeighborsPerElement);
250
251 it2->G.clear();
252 vector<double>(it2->G).swap(it2->G);
253
254 it2->dEdG.clear();
255 vector<double>(it2->dEdG).swap(it2->dEdG);
256
257#ifdef N2P2_FULL_SFD_MEMORY
258 it2->dGdxia.clear();
259 vector<double>(it2->dGdxia).swap(it2->dGdxia);
260#endif
261
262 it2->dGdr.clear();
263 vector<Vec3D>(it2->dGdr).swap(it2->dGdr);
264
265 it2->numNeighbors = 0;
266 it2->neighbors.clear();
267 vector<Atom::Neighbor>(it2->neighbors).swap(it2->neighbors);
268
269 it2->hasNeighborList = false;
270 it2->hasSymmetryFunctions = false;
271 it2->hasSymmetryFunctionDerivatives = false;
272 }
273 it->hasNeighborList = false;
274 it->hasSymmetryFunctions = false;
275 it->hasSymmetryFunctionDerivatives = false;
276 it->updateError("energy", errorEnergy, countEnergy);
277 fileEnergy << strpr("%10zu %10zu", it->index, it->numAtoms);
278 if (normalize)
279 {
280 fileEnergy << strpr(" %16.8E %16.8E %16.8E %16.8E\n",
281 dataset.physicalEnergy(*it, true)
282 + dataset.getEnergyOffset(*it),
283 dataset.physicalEnergy(*it, false)
284 + dataset.getEnergyOffset(*it),
285 it->energyRef,
286 it->energy);
287 }
288 else
289 {
290 fileEnergy << strpr(" %16.8E %16.8E\n",
291 dataset.getEnergyWithOffset(*it, true),
292 dataset.getEnergyWithOffset(*it, false));
293 }
294 if (useForces)
295 {
296 it->updateError("force", errorForces, countForces);
297 for (vector<Atom>::const_iterator it2 = it->atoms.begin();
298 it2 != it->atoms.end(); ++it2)
299 {
300 for (size_t i = 0; i < 3; ++i)
301 {
302 fileForces << strpr("%10zu %10zu",
303 it2->indexStructure,
304 it2->index);
305 if (normalize)
306 {
307 fileForces << strpr(
308 " %16.8E %16.8E",
309 dataset.physical("force", it2->fRef[i]),
310 dataset.physical("force", it2->f[i]));
311 }
312 fileForces << strpr(" %16.8E %16.8E\n",
313 it2->fRef[i],
314 it2->f[i]);
315 }
316 }
317 }
318 if (normalize)
319 {
320 it->toPhysicalUnits(dataset.getMeanEnergy(),
321 dataset.getConvEnergy(),
322 dataset.getConvLength());
323 }
324 dataset.addEnergyOffset(*it, false);
325 it->writeToFile(&fileOutputData, false);
326 }
327
328 fileEnergy.close();
329 if (useForces) fileForces.close();
330 fileOutputData.close();
331 MPI_Barrier(MPI_COMM_WORLD);
332
333 if (myRank == 0)
334 {
335 fileName = "energy.comp";
336 dataset.combineFiles(fileName);
337 if (useForces)
338 {
339 fileName = "forces.comp";
340 dataset.combineFiles(fileName);
341 }
342 fileName = "output.data";
343 dataset.combineFiles(fileName);
344 }
345
346 dataset.collectError("energy", errorEnergy, countEnergy);
347 if (useForces) dataset.collectError("force", errorForces, countForces);
348
349 if (myRank == 0)
350 {
351 if (useForces)
352 {
353 dataset.log << "Energy and force comparison in files:\n";
354 dataset.log << " - energy.comp\n";
355 dataset.log << " - forces.comp\n";
356 }
357 else
358 {
359 dataset.log << "Energy comparison in file:\n";
360 dataset.log << " - energy.comp\n";
361 }
362 dataset.log << "Predicted data set in \"output.data\"\n";
363 }
364 dataset.log << "Error metrics for energies and forces:\n";
365 dataset.log << "-----------------------------------------"
366 "-----------------------------------------"
367 "--------------------------------------\n";
368 dataset.log << " physical units ";
369 if (normalize)
370 {
371 dataset.log << " | internal units ";
372 }
373 dataset.log << "\n";
374 dataset.log << strpr(" %13s %13s %13s %13s",
375 "RMSEpa", "RMSE", "MAEpa", "MAE");
376 if (normalize)
377 {
378 dataset.log << strpr(" | %13s %13s %13s %13s",
379 "RMSEpa", "RMSE", "MAEpa", "MAE");
380 }
381 dataset.log << "\n";
382 dataset.log << "ENERGY";
383 if (normalize)
384 {
385 dataset.log << strpr(
386 " %13.5E %13.5E %13.5E %13.5E |",
387 dataset.physical("energy", errorEnergy.at("RMSEpa")),
388 dataset.physical("energy", errorEnergy.at("RMSE")),
389 dataset.physical("energy", errorEnergy.at("MAEpa")),
390 dataset.physical("energy", errorEnergy.at("MAE")));
391 }
392 dataset.log << strpr(" %13.5E %13.5E %13.5E %13.5E\n",
393 errorEnergy.at("RMSEpa"),
394 errorEnergy.at("RMSE"),
395 errorEnergy.at("MAEpa"),
396 errorEnergy.at("MAE"));
397 if (useForces)
398 {
399 dataset.log << "FORCES";
400 if (normalize)
401 {
402 dataset.log << strpr(
403 " %13s %13.5E %13s %13.5E |", "",
404 dataset.physical("force", errorForces.at("RMSE")), "",
405 dataset.physical("force", errorForces.at("MAE")));
406 }
407 dataset.log << strpr(" %13s %13.5E %13s %13.5E\n", "",
408 errorForces.at("RMSE"), "",
409 errorForces.at("MAE"));
410 }
411 dataset.log << "-----------------------------------------"
412 "-----------------------------------------"
413 "--------------------------------------\n";
414 dataset.log << "*****************************************"
415 "**************************************\n";
416
417 dataset.log << "\n";
418 dataset.log << "*** SENSITIVITY ANALYSIS ****************"
419 "**************************************\n";
420 dataset.log << "\n";
421
422 // Combine sensititvity data from all procs.
423 if (myRank == 0)
424 {
425 dataset.log << "Writing sensitivity analysis data to files:\n";
426 MPI_Reduce(MPI_IN_PLACE, &(count.front()), numElements, MPI_SIZE_T, MPI_SUM, 0, MPI_COMM_WORLD);
427 for (size_t i = 0; i < numElements; ++i)
428 {
429 size_t const& n = numSymmetryFunctions.at(i);
430 double sensMeanSum = 0.0;
431 double sensMaxSum = 0.0;
432 MPI_Reduce(MPI_IN_PLACE, &(sensMean.at(i).front()), n, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
433 MPI_Reduce(MPI_IN_PLACE, &(sensMax.at(i).front() ), n, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD);
434 for (size_t j = 0; j < numSymmetryFunctions.at(i); ++j)
435 {
436 sensMean.at(i).at(j) = sqrt(sensMean.at(i).at(j)
437 / count.at(i));
438 sensMeanSum += sensMean.at(i).at(j);
439 sensMaxSum += sensMax.at(i).at(j);
440 }
441 ofstream sensFile;
442 string sensFileName = strpr("sensitivity.%03d.out",
443 dataset.elementMap.atomicNumber(i));
444 dataset.log << strpr(" - %s\n", sensFileName.c_str());
445 sensFile.open(sensFileName.c_str());
446
447 // File header.
448 vector<string> title;
449 vector<string> colName;
450 vector<string> colInfo;
451 vector<size_t> colSize;
452 title.push_back(strpr("Sensitivity analysis for element %2s.",
453 dataset.elementMap[i].c_str()));
454 colSize.push_back(10);
455 colName.push_back("index");
456 colInfo.push_back("Symmetry function index.");
457 colSize.push_back(16);
458 colName.push_back("sens_msa_norm");
459 colInfo.push_back("Mean square average sensitivity (normalized, "
460 "sum = 100%).");
461 colSize.push_back(16);
462 colName.push_back("sens_max_norm");
463 colInfo.push_back("Maximum sensitivity (normalized, sum = 100%).");
464 colSize.push_back(16);
465 colName.push_back("sens_msa_phys");
466 colInfo.push_back("Mean square average sensitivity (physical "
467 "energy units).");
468 colSize.push_back(16);
469 colName.push_back("sens_max_phys");
470 colInfo.push_back("Maximum sensitivity (physical energy units).");
471 if (normalize)
472 {
473 colSize.push_back(16);
474 colName.push_back("sens_msa_int");
475 colInfo.push_back("Mean square average sensitivity (internal "
476 "units).");
477 colSize.push_back(16);
478 colName.push_back("sens_max_int");
479 colInfo.push_back("Maximum sensitivity (internal units).");
480 }
481 appendLinesToFile(sensFile,
482 createFileHeader(title,
483 colSize,
484 colName,
485 colInfo));
486
487 for (size_t j = 0; j < numSymmetryFunctions.at(i); ++j)
488 {
489 sensFile << strpr("%10d", j + 1);
490 sensFile << strpr(" %16.8E %16.8E",
491 sensMean.at(i).at(j) / sensMeanSum * 100.0,
492 sensMax.at(i).at(j) / sensMaxSum * 100.0);
493 if (normalize)
494 {
495 sensFile << strpr(" %16.8E %16.8E",
496 dataset.physical("energy",
497 sensMean.at(i).at(j)),
498 dataset.physical("energy",
499 sensMax.at(i).at(j)));
500 }
501 sensFile << strpr(" %16.8E %16.8E\n",
502 sensMean.at(i).at(j),
503 sensMax.at(i).at(j));
504 }
505 sensFile.close();
506 }
507 }
508 else
509 {
510 MPI_Reduce(&(count.front()), &(count.front()), numElements, MPI_SIZE_T, MPI_SUM, 0, MPI_COMM_WORLD);
511 for (size_t i = 0; i < numElements; ++i)
512 {
513 size_t const& n = numSymmetryFunctions.at(i);
514 MPI_Reduce(&(sensMean.at(i).front()), &(sensMean.at(i).front()), n, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
515 MPI_Reduce(&(sensMax.at(i).front() ), &(sensMax.at(i).front() ), n, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD);
516 }
517 }
518
519 dataset.log << "*****************************************"
520 "**************************************\n";
521
522 myLog.close();
523
524 MPI_Finalize();
525
526 return 0;
527}
nnp::Dataset
Collect and process large data sets.
Definition: Dataset.h:35
nnp::Dataset::distributeStructures
int distributeStructures(bool randomize, bool excludeRank0=false, std::string const &fileName="input.data")
Read data file and distribute structures among processors.
Definition: Dataset.cpp:722
nnp::Dataset::setupMPI
void setupMPI()
Initialize MPI with MPI_COMM_WORLD.
Definition: Dataset.cpp:52
nnp::Dataset::structures
std::vector< Structure > structures
All structures in this dataset.
Definition: Dataset.h:195
nnp::Dataset::setupRandomNumberGenerator
void setupRandomNumberGenerator()
Initialize random number generator.
Definition: Dataset.cpp:110
nnp::Dataset::combineFiles
void combineFiles(std::string filePrefix) const
Combine individual MPI proc files to one.
Definition: Dataset.cpp:1742
nnp::Dataset::collectError
void collectError(std::string const &property, std::map< std::string, double > &error, std::size_t &count) const
Collect error metrics of a property over all MPI procs.
Definition: Dataset.cpp:1710
nnp::Dataset::toNormalizedUnits
void toNormalizedUnits()
Switch all structures to normalized units.
Definition: Dataset.cpp:950
nnp::ElementMap::atomicNumber
std::size_t atomicNumber(std::size_t index) const
Get atomic number from element index.
Definition: ElementMap.h:145
nnp::Log::registerStreamPointer
void registerStreamPointer(std::ofstream *const &streamPointer)
Register new C++ ofstream pointer.
Definition: Log.cpp:91
nnp::Log::writeToStdout
bool writeToStdout
Turn on/off output to stdout.
Definition: Log.h:85
nnp::Mode::physicalEnergy
double physicalEnergy(Structure const &structure, bool ref=true) const
Undo normalization for a given energy of structure.
Definition: Mode.cpp:1557
nnp::Mode::elementMap
ElementMap elementMap
Global element map, populated by setupElementMap().
Definition: Mode.h:508
nnp::Mode::addEnergyOffset
void addEnergyOffset(Structure &structure, bool ref=true)
Add atomic energy offsets to reference energy.
Definition: Mode.cpp:1461
nnp::Mode::initialize
void initialize()
Write welcome message with version information.
Definition: Mode.cpp:50
nnp::Mode::getNumElements
std::size_t getNumElements() const
Getter for Mode::numElements.
Definition: Mode.h:568
nnp::Mode::getConvLength
double getConvLength() const
Getter for Mode::convLength.
Definition: Mode.h:558
nnp::Mode::physical
double physical(std::string const &property, double value) const
Undo normalization for a given property.
Definition: Mode.cpp:1549
nnp::Mode::getMaxCutoffRadius
double getMaxCutoffRadius() const
Getter for Mode::maxCutoffRadius.
Definition: Mode.h:563
nnp::Mode::calculateAtomicNeuralNetworks
void calculateAtomicNeuralNetworks(Structure &structure, bool const derivatives)
Calculate a single atomic neural network for a given atom and nn type.
Definition: Mode.cpp:1310
nnp::Mode::useNormalization
bool useNormalization() const
Check if normalization is enabled.
Definition: Mode.h:573
nnp::Mode::setupNeuralNetworkWeights
virtual void setupNeuralNetworkWeights(std::string const &fileNameFormatShort="weights.%03zu.data", std::string const &fileNameFormatCharge="weightse.%03zu.data")
Set up neural network weights from files.
Definition: Mode.cpp:1126
nnp::Mode::calculateEnergy
void calculateEnergy(Structure &structure) const
Calculate potential energy for a given structure.
Definition: Mode.cpp:1366
nnp::Mode::calculateSymmetryFunctionGroups
void calculateSymmetryFunctionGroups(Structure &structure, bool const derivatives)
Calculate all symmetry function groups for all atoms in given structure.
Definition: Mode.cpp:1230
nnp::Mode::getConvEnergy
double getConvEnergy() const
Getter for Mode::convEnergy.
Definition: Mode.h:553
nnp::Mode::setupSymmetryFunctionScaling
virtual void setupSymmetryFunctionScaling(std::string const &fileName="scaling.data")
Set up symmetry function scaling from file.
Definition: Mode.cpp:532
nnp::Mode::getNumSymmetryFunctions
std::vector< std::size_t > getNumSymmetryFunctions() const
Get number of symmetry functions per element.
Definition: Mode.cpp:1609
nnp::Mode::settingsKeywordExists
bool settingsKeywordExists(std::string const &keyword) const
Check if keyword was found in settings file.
Definition: Mode.cpp:1622
nnp::Mode::log
Log log
Global log file.
Definition: Mode.h:510
nnp::Mode::getMeanEnergy
double getMeanEnergy() const
Getter for Mode::meanEnergy.
Definition: Mode.h:548
nnp::Mode::getEnergyWithOffset
double getEnergyWithOffset(Structure const &structure, bool ref=true) const
Add atomic energy offsets and return energy.
Definition: Mode.cpp:1512
nnp::Mode::setupGeneric
void setupGeneric(bool skipNormalize=false)
Combine multiple setup routines and provide a basic NNP setup.
Definition: Mode.cpp:197
nnp::Mode::calculateSymmetryFunctions
void calculateSymmetryFunctions(Structure &structure, bool const derivatives)
Calculate all symmetry functions for all atoms in given structure.
Definition: Mode.cpp:1150
nnp::Mode::calculateForces
void calculateForces(Structure &structure) const
Calculate forces for all atoms in given structure.
Definition: Mode.cpp:1392
nnp::Mode::setupSymmetryFunctionStatistics
void setupSymmetryFunctionStatistics(bool collectStatistics, bool collectExtrapolationWarnings, bool writeExtrapolationWarnings, bool stopOnExtrapolationWarnings)
Set up symmetry function statistics collection.
Definition: Mode.cpp:923
nnp::Mode::loadSettingsFile
void loadSettingsFile(std::string const &fileName="input.nn")
Open settings file and load all keywords into memory.
Definition: Mode.cpp:156
nnp::Mode::getEnergyOffset
double getEnergyOffset(Structure const &structure) const
Get atomic energy offset for given structure.
Definition: Mode.cpp:1499
MPI_SIZE_T
#define MPI_SIZE_T
Definition: mpi-extra.h:22
nnp::strpr
string strpr(const char *format,...)
String version of printf function.
Definition: utility.cpp:90
nnp::createFileHeader
vector< string > createFileHeader(vector< string > const &title, vector< size_t > const &colSize, vector< string > const &colName, vector< string > const &colInfo, char const &commentChar)
Definition: utility.cpp:104
nnp::appendLinesToFile
void appendLinesToFile(ofstream &file, vector< string > const lines)
Append multiple lines of strings to open file stream.
Definition: utility.cpp:218

References nnp::Mode::addEnergyOffset(), nnp::appendLinesToFile(), nnp::ElementMap::atomicNumber(), nnp::Mode::calculateAtomicNeuralNetworks(), nnp::Mode::calculateEnergy(), nnp::Mode::calculateForces(), nnp::Mode::calculateSymmetryFunctionGroups(), nnp::Mode::calculateSymmetryFunctions(), nnp::Dataset::collectError(), nnp::Dataset::combineFiles(), nnp::createFileHeader(), nnp::Dataset::distributeStructures(), nnp::Mode::elementMap, nnp::Mode::getConvEnergy(), nnp::Mode::getConvLength(), nnp::Mode::getEnergyOffset(), nnp::Mode::getEnergyWithOffset(), nnp::Mode::getMaxCutoffRadius(), nnp::Mode::getMeanEnergy(), nnp::Mode::getNumElements(), nnp::Mode::getNumSymmetryFunctions(), nnp::Mode::initialize(), nnp::Mode::loadSettingsFile(), nnp::Mode::log, MPI_SIZE_T, nnp::Mode::physical(), nnp::Mode::physicalEnergy(), nnp::Log::registerStreamPointer(), nnp::Mode::settingsKeywordExists(), nnp::Mode::setupGeneric(), nnp::Dataset::setupMPI(), nnp::Mode::setupNeuralNetworkWeights(), nnp::Dataset::setupRandomNumberGenerator(), nnp::Mode::setupSymmetryFunctionScaling(), nnp::Mode::setupSymmetryFunctionStatistics(), nnp::strpr(), nnp::Dataset::structures, nnp::Dataset::toNormalizedUnits(), nnp::Mode::useNormalization(), and nnp::Log::writeToStdout.

Here is the call graph for this function: