Atom.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 ATOM_H
#define ATOM_H
 
#include "Vec3D.h"
#include <cstddef>          // std::size_t
#include <cstdint>          // int64_t
#include <map>              // std::map
#include <unordered_map>    // std::unordered_map
#include <string>           // std::string
#include <vector>           // std::vector
 
namespace nnp
{
 
struct Atom
{
    struct Neighbor
    {
        std::size_t                index;
        int64_t                    tag;
        std::size_t                element;
        double                     d;
        Vec3D                      dr;
#ifndef N2P2_NO_SF_CACHE
        std::vector<double>        cache;
#endif
        std::vector<Vec3D>         dGdr;
 
        Neighbor();
        bool                     operator==(Neighbor const& rhs) const;
        bool                     operator!=(Neighbor const& rhs) const;
        bool                     operator<(Neighbor const& rhs) const;
        bool                     operator>(Neighbor const& rhs) const;
        bool                     operator<=(Neighbor const& rhs) const;
        bool                     operator>=(Neighbor const& rhs) const;
        std::vector<std::string> info() const;
    };
 
    bool                     hasNeighborList;
    bool                     NeighborListIsSorted;
    bool                     hasSymmetryFunctions;
    bool                     hasSymmetryFunctionDerivatives;
    bool                     useChargeNeuron;
    std::size_t              index;
    std::size_t              indexStructure;
    int64_t                  tag;
    std::size_t              element;
    std::size_t              numNeighbors;
    std::size_t              numNeighborsUnique;
    std::size_t              numSymmetryFunctions;
    double                   energy;
    double                   dEelecdQ;
    double                   chi;
    double                   charge;
    double                   chargeRef;
    Vec3D                    r;
    Vec3D                    f;
    Vec3D                    fElec;
    Vec3D                    fRef;
    Vec3D                    pEelecpr;
    std::vector<std::size_t> neighborsUnique;
    std::vector<std::size_t> numNeighborsPerElement;
    std::vector<std::size_t> numSymmetryFunctionDerivatives;
#ifndef N2P2_NO_SF_CACHE
    std::vector<std::size_t> cacheSizePerElement;
#endif
    std::vector<double>      G;
    std::vector<double>      dEdG;
    std::vector<double>      dQdG;
    std::vector<double>      dChidG;
#ifdef N2P2_FULL_SFD_MEMORY
    std::vector<double>      dGdxia;
#endif
    std::vector<Vec3D>       dGdr;
    std::vector<Vec3D>       dQdr;
    //bool                    hasdQdr[3];
    std::vector<Vec3D>       dAdrQ;
    std::vector<Neighbor>    neighbors;
    std::unordered_map<double, size_t> neighborCutoffs;
 
    Atom();
#ifdef N2P2_FULL_SFD_MEMORY
    void                     collectDGdxia(std::size_t indexAtom,
                                           std::size_t indexComponent,
                                           double maxCutoffRadius);
#endif
    void                     toNormalizedUnits(double convEnergy,
                                               double convLength,
                                               double convCharge);
    void                     toPhysicalUnits(double convEnergy,
                                             double convLength,
                                             double convCharge);
    void                     allocate(bool         all,
                                      double const maxCutoffRadius = 0.0);
    void                     free(bool all, double const maxCutoffRadius = 0.0);
    void                     clearNeighborList();
    void                     clearNeighborList(std::size_t const numElements);
    std::size_t              calculateNumNeighbors(double const cutoffRadius) const;
    std::size_t              getStoredMinNumNeighbors(
                                             double const cutoffRadius) const;
    bool                     isNeighbor(std::size_t index) const;
    void                     updateError(
                                   std::string const&             property,
                                   std::map<std::string, double>& error,
                                   std::size_t&                   count) const;
    Vec3D                    calculateSelfForceShort() const;
    Vec3D                    calculatePairForceShort(
                                    Neighbor const&  neighbor,
                                    std::vector<std::vector <std::size_t> >
                                    const *const     tableFull = nullptr) const;
    Vec3D                    calculateDChidr(
                                    size_t const     atomIndexOfR,
                                    double const     maxCutoffRadius,
                                    std::vector<std::vector<size_t> >
                                    const *const     tableFull = nullptr) const;
    std::vector<std::string> getForcesLines() const;
    std::string              getChargeLine() const;
    std::vector<std::string> info() const;
};
 
inline bool Atom::Neighbor::operator!=(Atom::Neighbor const& rhs) const
{
    return !((*this) == rhs);
}
 
inline bool Atom::Neighbor::operator>(Atom::Neighbor const& rhs) const
{
    return rhs < (*this);
}
 
inline bool Atom::Neighbor::operator<=(Atom::Neighbor const& rhs) const
{
    return !((*this) > rhs);
}
 
inline bool Atom::Neighbor::operator>=(Atom::Neighbor const& rhs) const
{
    return !((*this) < rhs);
}
 
}
 
#endif