Structure.h

Go to the documentation of this file.

// n2p2 - A neural network potential package
// Copyright (C) 2018 Andreas Singraber (University of Vienna)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
#ifndef STRUCTURE_H
#define STRUCTURE_H
 
#include "Atom.h"
#include "Element.h"
#include "ElementMap.h"
#include "ErfcBuf.h"
#include "EwaldSetup.h"
#include "ScreeningFunction.h"
#include "Vec3D.h"
#include <Eigen/Core> // MatrixXd, VectorXd
#include <cstddef>    // std::size_t
#include <fstream>    // std::ofstream
#include <map>        // std::map
#include <string>     // std::string
#include <vector>     // std::vector
 
namespace nnp
{
 
struct Structure
{
    enum SampleType
    {
        ST_UNKNOWN,
        ST_TRAINING,
        ST_VALIDATION,
        ST_TEST
    };
 
    ElementMap               elementMap;
    bool                     isPeriodic;
    bool                     isTriclinic;
    bool                     hasNeighborList;
    bool                     NeighborListIsSorted;
    bool                     hasSymmetryFunctions;
    bool                     hasSymmetryFunctionDerivatives;
    std::size_t              index;
    std::size_t              numAtoms;
    std::size_t              numElements;
    std::size_t              numElementsPresent;
    int                      pbc[3];
    double                   energy;
    double                   energyRef;
    // TODO: MPI_Pack
    double                   energyShort;
    // TODO: MPI_Pack
    double                   energyElec;
    bool                     hasCharges;
    double                   charge;
    double                   chargeRef;
    double                   volume;
    double                   maxCutoffRadiusOverall;
    // TODO: MPI_Pack
    double                   lambda;
    SampleType               sampleType;
    std::string              comment;
    Vec3D                    box[3];
    Vec3D                    invbox[3];
    Eigen::MatrixXd          A;
    bool                     hasAMatrix;
    std::vector<std::size_t> numAtomsPerElement;
    std::vector<Atom>        atoms;
 
    Structure();
    void                     setElementMap(ElementMap const& elementMap);
    void                     addAtom(Atom const&        atom,
                                     std::string const& element);
    void                     readFromFile(std::string const fileName
                                                            = "input.data");
    void                     readFromFile(std::ifstream& file);
    void                     readFromLines(std::vector<
                                           std::string> const& lines);
    void                   calculateMaxCutoffRadiusOverall(
                                            EwaldSetup& ewaldSetup,
                                            double      rcutScreen,
                                            double      maxCutoffRadius);
    void                     calculateNeighborList(
                                                    double  cutoffRadius,
                                                    bool    sortByDistance = false);
    void                     calculateNeighborList(
                                                   double  cutoffRadius,
                                                   std::vector<
                                                   std::vector<double>>& cutoffs);
    void                     sortNeighborList();
    void                     setupNeighborCutoffMap(std::vector<
                                                    std::vector<double>> cutoffs);
    void                     calculatePbcCopies(double cutoffRadius, int (&pbc)[3]);
    void                     calculateInverseBox();
    bool                     canMinimumImageConventionBeApplied(double cutoffRadius);
    Vec3D                    applyMinimumImageConvention(Vec3D const& dr);
    void                     calculateVolume();
    double                   calculateElectrostaticEnergy(
                                            EwaldSetup&              ewaldSetup,
                                            Eigen::VectorXd          hardness,
                                            Eigen::MatrixXd          gammaSqrt2,
                                            Eigen::VectorXd          sigmaSqrtPi,
                                            ScreeningFunction const& fs,
                                            double const             fourPiEps,
                                            ErfcBuf&                 erfcBuf);
    double                   calculateScreeningEnergy(  
                                            Eigen::MatrixXd          gammaSqrt2,
                                            Eigen::VectorXd          sigmaSqrtPi,
                                            ScreeningFunction const& fs,
                                            double const             fourPiEps);
    void                     calculateDAdrQ(
                                        EwaldSetup&     ewaldSetup,
                                        Eigen::MatrixXd gammaSqrt2,
                                        double const    fourPiEps,
                                        ErfcBuf&        erfcBuf);
    void                     calculateDQdChi(std::vector<Eigen::VectorXd> &dQdChi);
    void                     calculateDQdJ(std::vector<Eigen::VectorXd> &dQdJ);
    void                    calculateDQdr(
                                std::vector<size_t> const&  atomsIndices,
                                std::vector<size_t> const&  compIndices,
                                double const                maxCutoffRadius,
                                std::vector<Element> const& elements);
    void                     calculateElectrostaticEnergyDerivatives(
                                        Eigen::VectorXd          hardness,
                                        Eigen::MatrixXd          gammaSqrt2,
                                        Eigen::VectorXd          sigmaSqrtPi,
                                        ScreeningFunction const& fs,
                                        double const             fourPiEps);
    Eigen::VectorXd const calculateForceLambdaTotal() const;
    Eigen::VectorXd const calculateForceLambdaElec() const;
    void                     remap();
    void                     remap(Atom& atom);
    void                     toNormalizedUnits(double meanEnergy,
                                               double convEnergy,
                                               double convLength,
                                               double convCharge);
    void                     toPhysicalUnits(double meanEnergy,
                                             double convEnergy,
                                             double convLength,
                                             double convCharge);
    std::size_t              getMaxNumNeighbors() const;
    void                     freeAtoms(bool         all,
                                       double const maxCutoffRadius = 0.0);
    void                     reset();
    void                     clearNeighborList();
    void                     clearElectrostatics(bool clearDQdr = false);
    void                     updateError(
                                   std::string const&             property,
                                   std::map<std::string, double>& error,
                                   std::size_t&                   count) const;
    std::string              getEnergyLine() const;
    std::vector<std::string> getForcesLines() const;
    std::vector<std::string> getChargesLines() const;
    void                     writeToFile(
                                     std::string const fileName ="output.data",
                                     bool const        ref = true,
                                     bool const        append = false) const;
    void                     writeToFile(
                                       std::ofstream* const& file,
                                       bool const            ref = true) const;
    void                     writeToFileXyz(std::ofstream* const& file) const;
    void                     writeToFilePoscar(
                                             std::ofstream* const& file) const;
    void                     writeToFilePoscar(
                                         std::ofstream* const& file,
                                         std::string const     elements) const;
    std::vector<std::string> info() const;
};
 
}
 
#endif