nnp-atomenv.cpp File Reference

#include "Dataset.h"
#include "mpi-extra.h"
#include "utility.h"
#include <mpi.h>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <string>
#include <vector>

Include dependency graph for nnp-atomenv.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 30 of file nnp-atomenv.cpp.

{
    bool   useForces = false;
    int    numProcs  = 0;
    int    myRank    = 0;
    ofstream myLog;
 
    if (argc < 3)
    {
        cout << "USAGE: " << argv[0] << " <nbins> <ncutij> \n"
             << "       <nbins> ... Number of symmetry function"
                " histogram bins.\n"
             << "       <ncutij> ... Maximum number of neighbor symmetry "
                "functions written (for each element combination).\n"
             << "       Execute in directory with these NNP files present:\n"
             << "       - input.data (structure file)\n"
             << "       - input.nn (NNP settings)\n"
             << "       - scaling.data (symmetry function scaling data)\n";
        return 1;
    }
 
    size_t numBins = (size_t)atoi(argv[1]);
 
    MPI_Init(&argc, &argv);
    MPI_Comm_size(MPI_COMM_WORLD, &numProcs);
    MPI_Comm_rank(MPI_COMM_WORLD, &myRank);
 
    Dataset dataset;
    myLog.open(strpr("nnp-atomenv.log.%04d", myRank).c_str());
    if (myRank != 0) dataset.log.writeToStdout = false;
    dataset.log.registerStreamPointer(&myLog);
    dataset.setupMPI();
    dataset.initialize();
    dataset.loadSettingsFile();
    dataset.setupGeneric();
    dataset.setupSymmetryFunctionScaling();
    dataset.setupSymmetryFunctionStatistics(true, false, true, false);
    dataset.setupRandomNumberGenerator();
    dataset.distributeStructures(false);
    if (dataset.useNormalization()) dataset.toNormalizedUnits();
 
    size_t n = dataset.getNumElements();
    if ((size_t)argc - 2 != n * n)
    {
        throw runtime_error("ERROR: Wrong number of neighbor cutoffs.\n");
    }
    vector<vector<size_t> > neighCutoff(n);
    size_t count = 0;
    for (size_t i = 0; i < n; ++i)
    {
        neighCutoff.at(i).resize(n, 0);
        for (size_t j = 0; j < n; ++j)
        {
            neighCutoff.at(i).at(j) = atof(argv[count+2]);
            count++;
        }
    }
    useForces = dataset.settingsKeywordExists("use_short_forces");
 
    dataset.log << "\n";
    dataset.log << "*** CALCULATING SYMMETRY FUNCTIONS ******"
                   "**************************************\n";
    dataset.log << "\n";
 
    for (vector<Structure>::iterator it = dataset.structures.begin();
         it != dataset.structures.end(); ++it)
    {
        it->calculateNeighborList(dataset.getMaxCutoffRadius());
#ifdef N2P2_NO_SF_GROUPS
        dataset.calculateSymmetryFunctions((*it), useForces);
#else
        dataset.calculateSymmetryFunctionGroups((*it), useForces);
#endif
        // Clear unneccessary memory, don't use these structures after these
        // operations unless you know what you do!
        for (vector<Atom>::iterator it2 = it->atoms.begin();
             it2 != it->atoms.end(); ++it2)
        {
            it2->numNeighborsUnique = 0;
            it2->neighborsUnique.clear();
            vector<size_t>(it2->neighborsUnique).swap(it2->neighborsUnique);
 
            it2->dEdG.clear();
            vector<double>(it2->dEdG).swap(it2->dEdG);
 
#ifdef N2P2_FULL_SFD_MEMORY
            it2->dGdxia.clear();
            vector<double>(it2->dGdxia).swap(it2->dGdxia);
#endif
 
            if (!useForces)
            {
                it2->dGdr.clear();
                vector<Vec3D>(it2->dGdr).swap(it2->dGdr);
            }
        }
    }
    dataset.log << "*****************************************"
                   "**************************************\n";
 
    dataset.collectSymmetryFunctionStatistics();
    dataset.writeSymmetryFunctionHistograms(numBins,
                                            "sf-scaled.%03zu.%04zu.histo");
    dataset.writeNeighborHistogram();
    dataset.sortNeighborLists();
    dataset.writeNeighborLists();
    dataset.writeAtomicEnvironmentFile(neighCutoff, useForces);
 
    myLog.close();
 
    MPI_Finalize();
 
    return 0;
}

References nnp::Mode::calculateSymmetryFunctionGroups(), nnp::Mode::calculateSymmetryFunctions(), nnp::Dataset::collectSymmetryFunctionStatistics(), nnp::Dataset::distributeStructures(), nnp::Mode::getMaxCutoffRadius(), nnp::Mode::getNumElements(), nnp::Mode::initialize(), nnp::Mode::loadSettingsFile(), nnp::Mode::log, nnp::Log::registerStreamPointer(), nnp::Mode::settingsKeywordExists(), nnp::Mode::setupGeneric(), nnp::Dataset::setupMPI(), nnp::Dataset::setupRandomNumberGenerator(), nnp::Mode::setupSymmetryFunctionScaling(), nnp::Mode::setupSymmetryFunctionStatistics(), nnp::Dataset::sortNeighborLists(), nnp::strpr(), nnp::Dataset::structures, nnp::Dataset::toNormalizedUnits(), nnp::Mode::useNormalization(), nnp::Dataset::writeAtomicEnvironmentFile(), nnp::Dataset::writeNeighborHistogram(), nnp::Dataset::writeNeighborLists(), nnp::Dataset::writeSymmetryFunctionHistograms(), and nnp::Log::writeToStdout.

Here is the call graph for this function: