Mode.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 MODE_H
#define MODE_H
 
#include "CutoffFunction.h"
#include "Element.h"
#include "ElementMap.h"
#include "ErfcBuf.h"
#include "EwaldSetup.h"
#include "Kspace.h"
#include "Log.h"
#include "ScreeningFunction.h"
#include "Settings.h"
#include "Structure.h"
#include "SymFnc.h"
#include <cstddef> // std::size_t
#include <map>     // std::map
#include <string>  // std::string
#include <vector>  // std::vector
 
namespace nnp
{

class Mode
{
public:
    enum class NNPType
    {
        HDNNP_2G = 2,
        HDNNP_4G = 4,
        HDNNP_Q = 10
    };
 
    Mode();
    void                     initialize();
    void                     loadSettingsFile(std::string const& fileName
                                                                 = "input.nn");
    void                     setupGeneric(std::string const& nnpDir = "",
                                          bool               skipNormalize = false,
                                          bool               initialHardness = false);
    void                     setupNormalization(bool standalone = true);
    virtual void             setupElementMap();
    virtual void             setupElements();
    void                     setupCutoff();
    virtual void             setupSymmetryFunctions();
    void                     setupSymmetryFunctionScalingNone();
    virtual void             setupSymmetryFunctionScaling(
                                 std::string const& fileName = "scaling.data");
    virtual void             setupSymmetryFunctionGroups();
#ifndef N2P2_NO_SF_CACHE
    virtual void             setupSymmetryFunctionCache(bool verbose = false);
#endif
    void                     setupSymmetryFunctionMemory(bool verbose = false);
    void                     setupSymmetryFunctionStatistics(
                                             bool collectStatistics,
                                             bool collectExtrapolationWarnings,
                                             bool writeExtrapolationWarnings,
                                             bool stopOnExtrapolationWarnings);
    void                     setupCutoffMatrix();
    virtual void             setupNeuralNetwork();
    virtual void             setupNeuralNetworkWeights(
                                 std::map<std::string,
                                          std::string> fileNameFormats =
                                 std::map<std::string,
                                          std::string>());
    virtual void             setupNeuralNetworkWeights(
                                 std::string           directoryPrefix,
                                 std::map<std::string,
                                          std::string> fileNameFormats =
                                 std::map<std::string,
                                          std::string>());
    virtual void             setupElectrostatics(bool initialHardness =
                                                 false,
                                                 std::string directoryPrefix =
                                                 "",
                                                 std::string fileNameFormat =
                                                 "hardness.%03zu.data");
    void                     calculateSymmetryFunctions(
                                                       Structure& structure,
                                                       bool const derivatives);
    void                     calculateSymmetryFunctionGroups(
                                                       Structure& structure,
                                                       bool const derivatives);
    // /** Calculate a single atomic neural network for a given atom and nn type.
    // *
    // * @param[in] nnId Neural network identifier, e.g. "short", "charge".
    // * @param[in] atom Input atom.
    // * @param[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.
    // */
    //void                     calculateAtomicNeuralNetwork(
    //                                           std::string const& nnId,
    //                                           Atom&              atom,
    //                                           bool const         derivatives);
    void                     calculateAtomicNeuralNetworks(
                                           Structure&  structure,
                                           bool const  derivatives,
                                           std::string id = "");
    void                     chargeEquilibration(
                                                Structure& structure,
                                                bool const derivativesElec);
    void                     calculateEnergy(Structure& structure) const;
    void                     calculateCharge(Structure& structure) const;
    void                     calculateForces(Structure& structure) const;
    void                     evaluateNNP(Structure& structure,
                                         bool useForces = true,
                                         bool useDEdG = true);
    void                     addEnergyOffset(Structure& structure,
                                             bool       ref = true);
    void                     removeEnergyOffset(Structure& structure,
                                                bool       ref = true);
    double                   getEnergyOffset(Structure const& structure) const;
    double                   getEnergyWithOffset(
                                            Structure const& structure,
                                            bool             ref = true) const;
    double                   normalized(std::string const& property,
                                        double             value) const;
    double                   normalizedEnergy(
                                            Structure const& structure,
                                            bool             ref = true) const;
    double                   physical(std::string const& property,
                                      double             value) const;
    double                   physicalEnergy(Structure const& structure,
                                            bool             ref = true) const;
    void                     convertToNormalizedUnits(
                                                   Structure& structure) const;
    void                     convertToPhysicalUnits(
                                                   Structure& structure) const;
    void                     logEwaldCutoffs();
    std::size_t              getNumExtrapolationWarnings() const;
    void                     resetExtrapolationWarnings();
    NNPType                  getNnpType() const;
    double                   getMeanEnergy() const;
    double                   getConvEnergy() const;
    double                   getConvLength() const;
    double                   getConvCharge() const;
    double                   getEwaldPrecision() const;
    double                   getEwaldMaxCharge() const;
    double                   getEwaldMaxSigma() const;
    EWALDTruncMethod         getEwaldTruncationMethod() const;
    KSPACESolver             kspaceSolver() const;
    double                   getMaxCutoffRadius() const;
    std::size_t              getNumElements() const;
    ScreeningFunction        getScreeningFunction() const;
    std::vector<std::size_t> getNumSymmetryFunctions() const;
    bool                     useNormalization() const;
    bool                     settingsKeywordExists(
                                             std::string const& keyword) const;
    std::string              settingsGetValue(
                                             std::string const& keyword) const;
    std::vector<std::size_t> pruneSymmetryFunctionsRange(double threshold);
    std::vector<std::size_t> pruneSymmetryFunctionsSensitivity(
                                            double threshold,
                                            std::vector<
                                            std::vector<double> > sensitivity);
    void                     writePrunedSettingsFile(
                                              std::vector<std::size_t> prune,
                                              std::string              fileName
                                                          = "output.nn") const;
    void                     writeSettingsFile(
                                             std::ofstream* const& file) const;

    ElementMap elementMap;
    Log        log;
 
protected:
    struct NNSetup
    {
        struct Topology
        {
            int                                numLayers;
            std::vector<int>                   numNeuronsPerLayer;
            std::vector<
            NeuralNetwork::ActivationFunction> activationFunctionsPerLayer;

            Topology() : numLayers(0) {};
        };

        std::string           id;
        std::string           name;
        std::string           weightFileFormat;
        std::string           keywordSuffix;
        std::string           keywordSuffix2;
        std::vector<Topology> topology;
    };
 
 
    NNPType                    nnpType;
    bool                       normalize;
    bool                       checkExtrapolationWarnings;
    std::size_t                numElements;
    std::vector<std::size_t>   minNeighbors;
    std::vector<double>        minCutoffRadius;
    double                     maxCutoffRadius;
    double                     cutoffAlpha;
    double                     meanEnergy;
    double                     convEnergy;
    double                     convLength;
    double                     convCharge;
    double                     fourPiEps;
    EwaldSetup                 ewaldSetup;
    KspaceGrid                 kspaceGrid;
    settings::Settings         settings;
    SymFnc::ScalingType        scalingType;
    CutoffFunction::CutoffType cutoffType;
    ScreeningFunction          screeningFunction;
    std::vector<Element>       elements;
    std::vector<std::string>   nnk;
    std::map<
    std::string, NNSetup>      nns;
    std::vector<
    std::vector<double>>       cutoffs;
    ErfcBuf                    erfcBuf;

    void readNeuralNetworkWeights(std::string const& id,
                                  std::string const& fileName);
};

// Inlined function definitions //
 
inline Mode::NNPType Mode::getNnpType() const
{
    return nnpType;
}
 
inline double Mode::getMeanEnergy() const
{
    return meanEnergy;
}
 
inline double Mode::getConvEnergy() const
{
    return convEnergy;
}
 
inline double Mode::getConvLength() const
{
    return convLength;
}
 
inline double Mode::getConvCharge() const
{
    return convCharge;
}
 
inline double Mode::getMaxCutoffRadius() const
{
    return maxCutoffRadius;
}
 
inline std::size_t Mode::getNumElements() const
{
    return numElements;
}
 
inline double Mode::getEwaldPrecision() const
{
    return ewaldSetup.getPrecision();
}
 
inline double Mode::getEwaldMaxCharge() const
{
    return ewaldSetup.getMaxCharge();
}
 
inline double Mode::getEwaldMaxSigma() const
{
    return ewaldSetup.getMaxQSigma();
}
 
inline EWALDTruncMethod Mode::getEwaldTruncationMethod() const
{
    return ewaldSetup.getTruncMethod();
}
 
inline KSPACESolver Mode::kspaceSolver() const
{
    return kspaceGrid.kspaceSolver;
}
 
inline bool Mode::useNormalization() const
{
    return normalize;
}
 
}
 
#endif