ElementCabana.h

Go to the documentation of this file.

// n2p2 - A neural network potential package
// Copyright (C) 2018 Andreas Singraber (University of Vienna)
// Copyright (C) 2020 Saaketh Desai and Sam Reeve
//
// 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 ELEMENT_CABANA_H
#define ELEMENT_CABANA_H
 
#include "typesCabana.h"
 
#include "CutoffFunction.h"
#include "Element.h"
#include "utility.h"
 
#include <cstddef> // size_t
#include <string>  // string
#include <vector>  // vector
 
namespace nnp
{
 
class ElementCabana : public Element
{
  public:
    ElementCabana( std::size_t const index );
    ~ElementCabana();
 
    template <class t_SF, class h_t_int>
    void addSymmetryFunction( std::string const &parameters,
                              std::vector<std::string> elementStrings,
                              int attype, t_SF SF, double convLength,
                              h_t_int h_numSFperElem );
    void changeLengthUnitSymmetryFunctions( double convLength );
    template <class t_SF, class h_t_int>
    void sortSymmetryFunctions( t_SF SF, h_t_int h_numSFperElem, int attype );
    template <class t_SF>
    bool compareSF( t_SF SF, int attype, int index1, int index2 );
    template <class t_SF, class h_t_int>
    std::vector<std::string>
    infoSymmetryFunctionParameters( t_SF SF, int attype,
                                    h_t_int h_numSFperElem ) const;
    template <class t_SF, class t_SFscaling, class h_t_int>
    std::vector<std::string>
    infoSymmetryFunctionScaling( ScalingType scalingType,
                                 t_SF SF, t_SFscaling SFscaling,
                                 int attype,
                                 h_t_int h_numSFperElem ) const;
    template <class t_SF, class t_SFGmemberlist, class h_t_int>
    void setupSymmetryFunctionGroups( t_SF SF, t_SFGmemberlist SFGmemberlist,
                                      int attype, h_t_int h_numSFperElem,
                                      h_t_int h_numSFGperElem,
                                      int maxSFperElem );
    template <class t_SF, class t_SFGmemberlist, class h_t_int>
    std::vector<std::string>
    infoSymmetryFunctionGroups( t_SF SF, t_SFGmemberlist SFGmemberlist,
                                int attype, h_t_int h_numSFGperElem ) const;
    template <class t_SF, class h_t_int>
    void setCutoffFunction( CutoffFunction::CutoffType const cutoffType,
                            double const cutoffAlpha, t_SF SF, int attype,
                            h_t_int h_numSFperElem );
    template <class t_SF, class t_SFscaling, class h_t_int>
    void setScaling( ScalingType scalingType,
                     std::vector<std::string> const &statisticsLine,
                     double minS, double maxS, t_SF SF,
                     t_SFscaling SFscaling, int attype,
                     h_t_int h_numSFperElem ) const;
    template <class h_t_int>
    std::size_t numSymmetryFunctions( int attype, h_t_int h_numSFperElem ) const;
    template <class t_SF>
    std::size_t getMinNeighbors( int attype, t_SF SF, int nSF ) const;
    template <class t_SF, class h_t_int>
    double getMinCutoffRadius( t_SF SF, int attype,
                               h_t_int h_numSFperElem ) const;
    template <class t_SF, class h_t_int>
    double getMaxCutoffRadius( t_SF SF, int attype,
                               h_t_int h_numSFperElem ) const;
 
    /* Update symmetry function statistics.
     *
     */
    // void                     updateSymmetryFunctionStatistics(
 
    // SymmetryFunctionStatistics statistics;
 
    template <class t_SFscaling>
    inline void setScalingType( ScalingType scalingType,
                                std::string statisticsLine,
                                double Smin, double Smax,
                                t_SFscaling SFscaling,
                                int attype, int k ) const;
    template <class t_SFscaling>
    inline std::string scalingLine( ScalingType scalingType,
                                    t_SFscaling SFscaling,
                                    int attype, int k ) const;
    template <class t_SFscaling>
    inline double unscale( int attype, double value, int k,
                           t_SFscaling SFscaling );
 
  private:
    using Element::index;
    using Element::atomicNumber;
    using Element::atomicEnergyOffset;
    using Element::symbol;
};
 
// Inlined function definitions //
 
template <class h_t_int>
inline std::size_t
ElementCabana::numSymmetryFunctions( int attype,
                                     h_t_int h_numSFperElem ) const
{
    return h_numSFperElem( attype );
}
 
template <class t_SFscaling>
inline void
ElementCabana::setScalingType( ScalingType scalingType,
                               std::string statisticsLine, double Smin,
                               double Smax, t_SFscaling SFscaling,
                               int attype, int k ) const
{
    double Gmin, Gmax, Gmean, Gsigma = 0, scalingFactor = 0;
    std::vector<std::string> s = split( reduce( statisticsLine ) );
 
    Gmin = atof( s.at( 2 ).c_str() );
    Gmax = atof( s.at( 3 ).c_str() );
    Gmean = atof( s.at( 4 ).c_str() );
    SFscaling( attype, k, 0 ) = Gmin;
    SFscaling( attype, k, 1 ) = Gmax;
    SFscaling( attype, k, 2 ) = Gmean;
 
    // Older versions may not supply sigma.
    if ( s.size() > 5 )
        Gsigma = atof( s.at( 5 ).c_str() );
    SFscaling( attype, k, 3 ) = Gsigma;
 
    SFscaling( attype, k, 4 ) = Smin;
    SFscaling( attype, k, 5 ) = Smax;
    SFscaling( attype, k, 7 ) = scalingType;
 
    if ( scalingType == ST_NONE )
        scalingFactor = 1.0;
    else if ( scalingType == ST_SCALE )
        scalingFactor = ( Smax - Smin ) / ( Gmax - Gmin );
    else if ( scalingType == ST_CENTER )
        scalingFactor = 1.0;
    else if ( scalingType == ST_SCALECENTER )
        scalingFactor = ( Smax - Smin ) / ( Gmax - Gmin );
    else if ( scalingType == ST_SCALESIGMA )
        scalingFactor = ( Smax - Smin ) / Gsigma;
    SFscaling( attype, k, 6 ) = scalingFactor;
 
    return;
}
 
template <class t_SFscaling>
inline std::string
ElementCabana::scalingLine( ScalingType scalingType,
                            t_SFscaling SFscaling, int attype,
                            int k ) const
{
    return strpr( "%4zu %9.2E %9.2E %9.2E %9.2E %9.2E %5.2f %5.2f %d\n",
                  k + 1, SFscaling( attype, k, 0 ),
                  SFscaling( attype, k, 1 ), SFscaling( attype, k, 2 ),
                  SFscaling( attype, k, 3 ), SFscaling( attype, k, 6 ),
                  SFscaling( attype, k, 4 ), SFscaling( attype, k, 5 ),
                  scalingType );
}
 
template <class t_SFscaling>
inline double ElementCabana::unscale( int attype, double value, int k,
                                      t_SFscaling SFscaling )
{
    double scalingType = SFscaling( attype, k, 7 );
    double scalingFactor = SFscaling( attype, k, 6 );
    double Gmin = SFscaling( attype, k, 0 );
    // double Gmax = SFscaling(attype,k,1);
    double Gmean = SFscaling( attype, k, 2 );
    // double Gsigma = SFscaling(attype,k,3);
    double Smin = SFscaling( attype, k, 4 );
    // double Smax = SFscaling(attype,k,5);
 
    if ( scalingType == 0.0 )
    {
        return value;
    }
    else if ( scalingType == 1.0 )
    {
        return ( value - Smin ) / scalingFactor + Gmin;
    }
    else if ( scalingType == 2.0 )
    {
        return value + Gmean;
    }
    else if ( scalingType == 3.0 )
    {
        return ( value - Smin ) / scalingFactor + Gmean;
    }
    else if ( scalingType == 4.0 )
    {
        return ( value - Smin ) / scalingFactor + Gmean;
    }
    else
    {
        return 0.0;
    }
}
 
}
 
#include "ElementCabana_impl.h"
 
#endif