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 "Log.h"
#include "Settings.h"
#include "Structure.h"
#include "SymFnc.h"
#include <cstddef> // std::size_t
#include <string>  // std::string
#include <vector>  // std::vector
 
namespace nnp
{
 
class Mode
{
public:
    enum class NNPType
    {
        SHORT_ONLY,
        SHORT_CHARGE_NN
    };
 
    Mode();
    void                     initialize();
    void                     loadSettingsFile(std::string const& fileName
                                                                 = "input.nn");
    void                     setupGeneric(bool skipNormalize = 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);
    virtual void             setupNeuralNetwork();
    virtual void             setupNeuralNetworkWeights(
                                std::string const& fileNameFormatShort
                                                      = "weights.%03zu.data",
                                std::string const& fileNameFormatCharge
                                                      = "weightse.%03zu.data");
    void                     calculateSymmetryFunctions(
                                                       Structure& structure,
                                                       bool const derivatives);
    void                     calculateSymmetryFunctionGroups(
                                                       Structure& structure,
                                                       bool const derivatives);
    //void                     calculateAtomicNeuralNetwork(
    //                                           std::string const& nnId,
    //                                           Atom&              atom,
    //                                           bool const         derivatives);
    void                     calculateAtomicNeuralNetworks(
                                                       Structure& structure,
                                                       bool const derivatives);
    void                     calculateEnergy(Structure& structure) const;
    void                     calculateCharge(Structure& structure) const;
    void                     calculateForces(Structure& structure) const;
    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;
    std::size_t              getNumExtrapolationWarnings() const;
    void                     resetExtrapolationWarnings();
    NNPType                  getNnpType() const;
    double                   getMeanEnergy() const;
    double                   getConvEnergy() const;
    double                   getConvLength() const;
    double                   getMaxCutoffRadius() const;
    std::size_t              getNumElements() 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:
    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;
 
    void readNeuralNetworkWeights(std::string const& type,
                                  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::getMaxCutoffRadius() const
{
    return maxCutoffRadius;
}
 
inline std::size_t Mode::getNumElements() const
{
    return numElements;
}
 
inline bool Mode::useNormalization() const
{
    return normalize;
}
 
}
 
#endif