nnp::SymGrpCompAngnWeighted Class Reference

Weighted narrow angular symmetry function with compact support (type 24) More...

#include <SymGrpCompAngnWeighted.h>

Inheritance diagram for nnp::SymGrpCompAngnWeighted:

Collaboration diagram for nnp::SymGrpCompAngnWeighted:

Public Member Functions
	SymGrpCompAngnWeighted (ElementMap const &elementMap)
	Constructor, sets type = 24. More...
virtual bool	operator== (SymGrp const &rhs) const
	Overload == operator. More...
virtual bool	operator< (SymGrp const &rhs) const
	Overload < operator. More...
virtual bool	addMember (SymFnc const *const symmetryFunction)
	Potentially add a member to group. More...
virtual void	sortMembers ()
	Sort member symmetry functions. More...
virtual void	calculate (Atom &atom, bool const derivatives) const
	Calculate all symmetry functions of this group for one atom. More...
Public Member Functions inherited from nnp::SymGrpBaseCompAngWeighted
virtual void	setScalingFactors ()
	Fill scalingFactors with values from member symmetry functions. More...
virtual std::vector< std::string >	parameterLines () const
	Give symmetry function group parameters on multiple lines. More...
Public Member Functions inherited from nnp::SymGrpBaseComp
double	getRmin () const
	Getter for rmin. More...
double	getRmax () const
	Getter for rmax. More...
Public Member Functions inherited from nnp::SymGrp
virtual	~SymGrp ()
	Virtual destructor. More...
virtual bool	operator== (SymGrp const &rhs) const =0
	Overload == operator. More...
virtual bool	operator< (SymGrp const &rhs) const =0
	Overload < operator. More...
bool	operator!= (SymGrp const &rhs) const
	Overload != operator. More...
bool	operator> (SymGrp const &rhs) const
	Overload > operator. More...
bool	operator<= (SymGrp const &rhs) const
	Overload <= operator. More...
bool	operator>= (SymGrp const &rhs) const
	Overload >= operator. More...
virtual bool	addMember (SymFnc const *const symmetryFunction)=0
	Potentially add a member to group. More...
virtual void	sortMembers ()=0
	Sort member symmetry functions. More...
virtual void	setScalingFactors ()=0
	Fill scalingFactors with values from member symmetry functions. More...
virtual void	calculate (Atom &atom, bool const derivatives) const =0
	Calculate all symmetry functions of this group for one atom. More...
virtual std::vector< std::string >	parameterLines () const =0
	Give symmetry function group parameters on multiple lines. More...
void	setIndex (std::size_t index)
	Set private index member variable. More...
std::size_t	getIndex () const
	Get private index member variable. More...
std::size_t	getType () const
	Get private type member variable. More...
std::size_t	getEc () const
	Get private ec member variable. More...

Private Member Functions
virtual std::vector< SymFncBaseCompAngWeighted const * >	getMembers () const
	Get symmetry function members. More...

Private Attributes
std::vector< SymFncCompAngnWeighted const * >	members
	Vector of all group member pointers. More...

Additional Inherited Members
Protected Types inherited from nnp::SymGrp
typedef std::map< std::string, std::pair< std::string, std::string > >	PrintFormat
typedef std::vector< std::string >	PrintOrder
Protected Member Functions inherited from nnp::SymGrpBaseCompAngWeighted
	SymGrpBaseCompAngWeighted (std::size_t type, ElementMap const &elementMap)
	Constructor, sets type. More...
virtual std::vector< SymFncBaseCompAngWeighted const * >	getMembers () const =0
	Get symmetry function members. More...
Protected Member Functions inherited from nnp::SymGrpBaseComp
	SymGrpBaseComp (std::size_t type, ElementMap const &elementMap)
	Constructor, sets type. More...
Protected Member Functions inherited from nnp::SymGrp
	SymGrp (std::size_t type, ElementMap const &elementMap)
	Constructor, sets type. More...
std::string	getPrintFormatCommon () const
	Get common parameter line format string. More...
std::string	getPrintFormatMember () const
	Get member parameter line format string. More...
Static Protected Member Functions inherited from nnp::SymGrp
static PrintFormat const	initializePrintFormat ()
	Initialize static print format map for all possible parameters. More...
static PrintOrder const	initializePrintOrder ()
	Initialize static print order vector for all possible parameters. More...
Protected Attributes inherited from nnp::SymGrpBaseCompAngWeighted
std::vector< bool >	calculateComp
	Vector indicating whether compact function needs to be recalculated. More...
std::vector< double >	mrl
	Member rl. More...
std::vector< double >	mrc
	Member rc. More...
std::vector< double >	mal
	Member angleLeft. More...
std::vector< double >	mar
	Member angleRight. More...
std::vector< std::vector< std::vector< std::size_t > > >	mci
	Member cache indices for actual neighbor element. More...
Protected Attributes inherited from nnp::SymGrpBaseComp
double	rmin
	Minimum radius within group. More...
double	rmax
	Maximum radius within group. More...
Protected Attributes inherited from nnp::SymGrp
std::size_t	type
	Symmetry function type. More...
ElementMap	elementMap
	Copy of element map. More...
std::size_t	index
	Symmetry function group index. More...
std::size_t	ec
	Element index of center atom (common feature). More...
double	convLength
	Data set normalization length conversion factor. More...
std::vector< size_t >	memberIndex
	Vector containing indices of all member symmetry functions. More...
std::vector< double >	scalingFactors
	Scaling factors of all member symmetry functions. More...
std::set< std::string >	parametersCommon
	Set of common parameters IDs. More...
std::set< std::string >	parametersMember
	Set of common parameters IDs. More...
std::vector< std::vector< std::size_t > >	memberIndexPerElement
	Vector containing per-element indices of all member symmetry functions. More...
Static Protected Attributes inherited from nnp::SymGrp
static PrintFormat const	printFormat = initializePrintFormat()
	Map of parameter format strings and empty strings. More...
static PrintOrder const	printOrder = initializePrintOrder()
	Vector of parameters in order of printing. More...

Detailed Description

Weighted narrow angular symmetry function with compact support (type 24)

\[ G^{24}_i = \sum_{\substack{j,k\neq i \\ j < k}} Z_j Z_k C(r_{ij}, r_l, r_c) C(r_{ik}, r_l, r_c) C(r_{jk}, r_l, r_c) C(\theta_{ijk}, \theta_l, \theta_r), \]

where \(C(x, x_\text{low}, x_\text{high})\) is a function with compact support \(\left[x_\text{low}, x_\text{high}\right]\). \(Z_j\) is defined as the atomic number of the neighbor atom \(j\).

Common features:

• element of central atom

Definition at line 51 of file SymGrpCompAngnWeighted.h.

Constructor & Destructor Documentation

SymGrpCompAngnWeighted()

SymGrpCompAngnWeighted::SymGrpCompAngnWeighted

(

ElementMap const &

elementMap

)

Constructor, sets type = 24.

Definition at line 30 of file SymGrpCompAngnWeighted.cpp.

                                                     :
    SymGrpBaseCompAngWeighted(24, elementMap)
{
}

Member Function Documentation

operator==()

bool SymGrpCompAngnWeighted::operator== ( SymGrp const &  rhs ) const

virtual

Overload == operator.

Implements nnp::SymGrp.

Definition at line 36 of file SymGrpCompAngnWeighted.cpp.

{
    if (ec   != rhs.getEc()  ) return false;
    if (type != rhs.getType()) return false;
    return true;
}

References nnp::SymGrp::ec, nnp::SymGrp::getEc(), nnp::SymGrp::getType(), and nnp::SymGrp::type.

Here is the call graph for this function:

operator<()

bool SymGrpCompAngnWeighted::operator< ( SymGrp const &  rhs ) const

virtual

Overload < operator.

Implements nnp::SymGrp.

Definition at line 43 of file SymGrpCompAngnWeighted.cpp.

{
    if      (ec   < rhs.getEc()  ) return true;
    else if (ec   > rhs.getEc()  ) return false;
    if      (type < rhs.getType()) return true;
    else if (type > rhs.getType()) return false;
    return false;
}

References nnp::SymGrp::ec, nnp::SymGrp::getEc(), nnp::SymGrp::getType(), and nnp::SymGrp::type.

Here is the call graph for this function:

addMember()

bool SymGrpCompAngnWeighted::addMember ( SymFnc const *const  symmetryFunction )

virtual

Potentially add a member to group.

Parameters

[in]

symmetryFunction

Candidate symmetry function.

Returns

If addition was successful.

If symmetry function is compatible with common feature list its pointer will be added to members.

Implements nnp::SymGrp.

Definition at line 52 of file SymGrpCompAngnWeighted.cpp.

{
    if (symmetryFunction->getType() != type) return false;
 
    SymFncCompAngnWeighted const* sf =
        dynamic_cast<SymFncCompAngnWeighted const*>(symmetryFunction);
 
    if (members.empty())
    {
        ec          = sf->getEc();
        convLength  = sf->getConvLength();
    }
 
    if (sf->getEc()          != ec         ) return false;
    if (sf->getConvLength()  != convLength )
    {
        throw runtime_error("ERROR: Unable to add symmetry function members "
                            "with different conversion factors.\n");
    }
 
    if (sf->getRl() <= 0.0) rmin = 0.0;
    else rmin = min( rmin, sf->getRl() );
    rmax = max( rmax, sf->getRc() );
 
    members.push_back(sf);
 
    return true;
}

References nnp::SymGrp::convLength, nnp::SymGrp::ec, nnp::SymFnc::getConvLength(), nnp::SymFnc::getEc(), nnp::SymFnc::getRc(), nnp::SymFncBaseComp::getRl(), nnp::SymFnc::getType(), members, nnp::SymGrpBaseComp::rmax, nnp::SymGrpBaseComp::rmin, and nnp::SymGrp::type.

Here is the call graph for this function:

sortMembers()

void SymGrpCompAngnWeighted::sortMembers ( )

virtual

Sort member symmetry functions.

Also allocate and precalculate additional stuff.

Implements nnp::SymGrp.

Definition at line 81 of file SymGrpCompAngnWeighted.cpp.

{
    sort(members.begin(),
         members.end(),
         comparePointerTargets<SymFncCompAngnWeighted const>);
 
    mrl.resize(members.size(), 0.0);
    mrc.resize(members.size(), 0.0);
    mal.resize(members.size(), 0.0);
    mar.resize(members.size(), 0.0);
    for (size_t i = 0; i < members.size(); i++)
    {
        mrl.at(i) = members[i]->getRl();
        mrc.at(i) = members[i]->getRc();
        mal.at(i) = members[i]->getAngleLeft() * M_PI / 180.0;
        mar.at(i) = members[i]->getAngleRight() * M_PI / 180.0;
        memberIndex.push_back(members[i]->getIndex());
        memberIndexPerElement.push_back(members[i]->getIndexPerElement());
        if (i == 0)
        {
            calculateComp.push_back(true);
        }
        else
        {
            if ( members[i - 1]->getRc() != members[i]->getRc() ||
                 members[i - 1]->getRl() != members[i]->getRl() )
            {
                calculateComp.push_back(true);
            }
            else
            {
                calculateComp.push_back(false);
            }
        }
    }
 
#ifndef N2P2_NO_SF_CACHE
    mci.resize(members.size());
    for (size_t k = 0; k < members.size(); ++k)
    {
        mci.at(k) = members.at(k)->getCacheIndices();
    }
#endif
 
    return;
}

References nnp::SymGrpBaseCompAngWeighted::calculateComp, nnp::SymGrp::getIndex(), nnp::SymGrpBaseCompAngWeighted::mal, nnp::SymGrpBaseCompAngWeighted::mar, nnp::SymGrpBaseCompAngWeighted::mci, nnp::SymGrp::memberIndex, nnp::SymGrp::memberIndexPerElement, members, nnp::SymGrpBaseCompAngWeighted::mrc, and nnp::SymGrpBaseCompAngWeighted::mrl.

Here is the call graph for this function:

calculate()

void SymGrpCompAngnWeighted::calculate ( Atom &  atom, bool const  derivatives  ) const

virtual

Calculate all symmetry functions of this group for one atom.

Parameters

[in,out]	atom	Atom for which symmetry functions are caluclated.
[in]	derivatives	If also symmetry function derivatives will be calculated and saved.

Implements nnp::SymGrp.

Definition at line 134 of file SymGrpCompAngnWeighted.cpp.

{
    double* result = new double[members.size()];
    double* radij  = new double[members.size()];
    double* dradij = new double[members.size()];
    for (size_t l = 0; l < members.size(); ++l)
    {
        result[l] = 0.0;
        radij[l]  = 0.0;
        dradij[l] = 0.0;
    }
 
    double r2min = rmin * rmin;
    double r2max = rmax * rmax;
 
    size_t numNeighbors = atom.numNeighbors;
    // Prevent problematic condition in loop test below (j < numNeighbors - 1).
    if (numNeighbors == 0) numNeighbors = 1;
 
    for (size_t j = 0; j < numNeighbors - 1; j++)
    {
        Atom::Neighbor& nj = atom.neighbors[j];
        size_t const nej = nj.element;
        double const rij = nj.d;
 
        if (rij < rmax && rij > rmin)
        {
            // Precalculate the radial part for ij
            // Supposedly saves quite a number of operations
            for (size_t l = 0; l < members.size(); ++l)
            {
                if (rij > mrl[l] && rij < mrc[l])
                {
                    SymFncCompAngnWeighted const& sf = *(members[l]);
#ifndef N2P2_NO_SF_CACHE
                    if (mci[l][nej].size() == 0)
                    {
                        sf.getCompactRadial(rij, radij[l], dradij[l]);
                    }
                    else
                    {
                        double& crad = nj.cache[mci[l][nej][0]];
                        double& cdrad = nj.cache[mci[l][nej][1]];
                        if (crad < 0) sf.getCompactRadial(rij, crad, cdrad);
                        radij[l] = crad;
                        dradij[l] = cdrad;
                    }
#else
                    sf.getCompactRadial(rij, radij[l], dradij[l]);
#endif
                }
                else radij[l] = 0.0;
            }
 
            // SIMPLE EXPRESSIONS:
            //Vec3D drij(atom.neighbors[j].dr);
            double const* const dr1 = nj.dr.r;
 
            for (size_t k = j + 1; k < numNeighbors; k++)
            {
                Atom::Neighbor& nk = atom.neighbors[k];
                size_t const nek = nk.element;
                double const rik = nk.d;
                if (rik < rmax && rik > rmin)
                {
                    // SIMPLE EXPRESSIONS:
                    //Vec3D drik(atom.neighbors[k].dr);
                    //Vec3D drjk = drik - drij;
                    double const* const dr2 = nk.dr.r;
                    double const dr30 = dr2[0] - dr1[0];
                    double const dr31 = dr2[1] - dr1[1];
                    double const dr32 = dr2[2] - dr1[2];
 
                    double rjk = dr30 * dr30
                               + dr31 * dr31
                               + dr32 * dr32;
                    if ((rjk >= r2max) || (rjk <= r2min)) continue;
                    rjk = sqrt(rjk);
 
                    // Energy calculation.
                    double const rinvijik = 1.0 / (rij * rik);
                    double const costijk = (dr1[0] * dr2[0] +
                                            dr1[1] * dr2[1] +
                                            dr1[2] * dr2[2]) * rinvijik;
 
                    // By definition, our polynomial is zero at 0 and 180 deg.
                    // Therefore, skip the whole rest which might yield some NaN
                    if (costijk <= -1.0 || costijk >= 1.0) continue;
 
                    double const acostijk = acos(costijk);
 
                    double const rinvij   = rinvijik * rik;
                    double const rinvik   = rinvijik * rij;
                    double const rinvjk   = 1.0 / rjk;
                    double const phiijik0 = rinvij
                                          * (rinvik - rinvij * costijk);
                    double const phiikij0 = rinvik
                                          * (rinvij - rinvik * costijk);
                    double dacostijk = 0.0;
                    if (derivatives)
                    {
                        dacostijk = -1.0 / sqrt(1.0 - costijk * costijk);
                    }
 
                    bool skip = false;
                    double ang;
                    double dang;
                    double radik;
                    double dradik;
                    double radjk;
                    double dradjk;
 
                    for (size_t l = 0; l < members.size(); ++l)
                    {
                        // Break conditions.
                        if (radij[l] == 0.0 ||
                            rik <= mrl[l] || rik >= mrc[l] ||
                            rjk <= mrl[l] || rjk >= mrc[l] ||
                            acostijk <= mal[l] || acostijk >= mar[l])
                        {
                            // Record if skipped.
                            skip = true;
                            continue;
                        }
 
                        SymFncCompAngnWeighted const& sf = *(members[l]);
#ifndef N2P2_NO_SF_CACHE
                        if (mci[l][nek].size() == 0)
                        {
                            sf.getCompactRadial(rik, radik, dradik);
                        }
                        else
                        {
                            double& crad = nk.cache[mci[l][nek][0]];
                            double& cdrad = nk.cache[mci[l][nek][1]];
                            if (crad < 0) sf.getCompactRadial(rik, crad, cdrad);
                            radik = crad;
                            dradik = cdrad;
                        }
#else
                        sf.getCompactRadial(rik, radik, dradik);
#endif
                        // Calculate anyway if skipped previously.
                        if (calculateComp[l] || skip)
                        {
                            sf.getCompactRadial(rjk, radjk, dradjk);
                            skip = false;
                        }
 
                        sf.getCompactAngle(acostijk, ang, dang);
 
                        double const z = elementMap.atomicNumber(nej)
                                       * elementMap.atomicNumber(nek);
                        ang *= z;
                        double rad = radij[l] * radik * radjk;
                        result[l] += rad * ang;
            
                        // Force calculation.
                        if (!derivatives) continue;
 
                        dang *= dacostijk;
                        double const phiijik = phiijik0 * dang;
                        double const phiikij = phiikij0 * dang;
                        double const psiijik = rinvijik * dang;
 
                        double const chiij =  rinvij * dradij[l]
                                           *  radik  * radjk;
                        double const chiik =  rinvik * radij[l]
                                           *  dradik * radjk;
                        double const chijk = -rinvjk * radij[l]
                                           *  radik  * dradjk;
 
                        double p1;
                        double p2;
                        double p3;
 
                        if (dang != 0.0 && rad != 0.0)
                        {
                            rad  *= scalingFactors[l] * z;
                            ang  *= scalingFactors[l];
                            p1 = rad * phiijik +  ang * chiij;
                            p2 = rad * phiikij +  ang * chiik;
                            p3 = rad * psiijik +  ang * chijk;
                        }
                        else if (ang != 0.0)
                        {
                            ang *= scalingFactors[l];
 
                            p1 = ang * chiij;
                            p2 = ang * chiik;
                            p3 = ang * chijk;
                        }
                        else continue;
 
                        // SIMPLE EXPRESSIONS:
                        // Save force contributions in Atom storage.
                        //atom.dGdr[memberIndex[l]] += p1 * drij
                        //                           + p2 * drik;
                        //atom.neighbors[j].
                        //    dGdr[memberIndex[l]] -= p1 * drij
                        //                          + p3 * drjk;
                        //atom.neighbors[k].
                        //    dGdr[memberIndex[l]] -= p2 * drik
                        //                          - p3 * drjk;
 
                        double const p1drijx = p1 * dr1[0];
                        double const p1drijy = p1 * dr1[1];
                        double const p1drijz = p1 * dr1[2];
 
                        double const p2drikx = p2 * dr2[0];
                        double const p2driky = p2 * dr2[1];
                        double const p2drikz = p2 * dr2[2];
 
                        double const p3drjkx = p3 * dr30;
                        double const p3drjky = p3 * dr31;
                        double const p3drjkz = p3 * dr32;
 
#ifndef N2P2_FULL_SFD_MEMORY
                        size_t li = memberIndex[l];
#else
                        size_t const li = memberIndex[l];
#endif
                        double* dGdr = atom.dGdr[li].r;
                        dGdr[0] += p1drijx + p2drikx;
                        dGdr[1] += p1drijy + p2driky;
                        dGdr[2] += p1drijz + p2drikz;
 
#ifndef N2P2_FULL_SFD_MEMORY
                        li = memberIndexPerElement[l][nej];
#endif
                        dGdr = nj.dGdr[li].r;
                        dGdr[0] -= p1drijx + p3drjkx;
                        dGdr[1] -= p1drijy + p3drjky;
                        dGdr[2] -= p1drijz + p3drjkz;
 
#ifndef N2P2_FULL_SFD_MEMORY
                        li = memberIndexPerElement[l][nek];
#endif
                        dGdr = nk.dGdr[li].r;
                        dGdr[0] -= p2drikx - p3drjkx;
                        dGdr[1] -= p2driky - p3drjky;
                        dGdr[2] -= p2drikz - p3drjkz;
                    } // l
                } // rik <= rc
            } // k
        } // rij <= rc
    } // j
 
    for (size_t l = 0; l < members.size(); ++l)
    {
        atom.G[memberIndex[l]] = members[l]->scale(result[l]);
    }
 
    delete[] result;
    delete[] radij;
    delete[] dradij;
 
    return;
}

References nnp::ElementMap::atomicNumber(), nnp::Atom::Neighbor::cache, nnp::SymGrpBaseCompAngWeighted::calculateComp, nnp::Atom::Neighbor::d, nnp::Atom::Neighbor::dGdr, nnp::Atom::dGdr, nnp::Atom::Neighbor::dr, nnp::Atom::Neighbor::element, nnp::SymGrp::elementMap, nnp::Atom::G, nnp::SymFncBaseCompAngWeighted::getCompactAngle(), nnp::SymFncBaseCompAngWeighted::getCompactRadial(), nnp::SymGrpBaseCompAngWeighted::mal, nnp::SymGrpBaseCompAngWeighted::mar, nnp::SymGrpBaseCompAngWeighted::mci, nnp::SymGrp::memberIndex, nnp::SymGrp::memberIndexPerElement, members, nnp::SymGrpBaseCompAngWeighted::mrc, nnp::SymGrpBaseCompAngWeighted::mrl, nnp::Atom::neighbors, nnp::Atom::numNeighbors, nnp::Vec3D::r, nnp::SymGrpBaseComp::rmax, nnp::SymGrpBaseComp::rmin, and nnp::SymGrp::scalingFactors.

Here is the call graph for this function:

getMembers()

std::vector< SymFncBaseCompAngWeighted const * > nnp::SymGrpCompAngnWeighted::getMembers ( ) const

inlineprivatevirtual

Get symmetry function members.

Returns

Vector of pointers casted to base class.

Implements nnp::SymGrpBaseCompAngWeighted.

Definition at line 97 of file SymGrpCompAngnWeighted.h.

{
    std::vector<SymFncBaseCompAngWeighted const*> cast;
 
    for (auto p : members)
    {
        cast.push_back(dynamic_cast<SymFncBaseCompAngWeighted const*>(p));
    }
 
    return cast;
}

References members, and p.

Member Data Documentation

members

std::vector<SymFncCompAngnWeighted const*> nnp::SymGrpCompAngnWeighted::members

private

Vector of all group member pointers.

Definition at line 93 of file SymGrpCompAngnWeighted.h.

Referenced by addMember(), calculate(), getMembers(), and sortMembers().

---

The documentation for this class was generated from the following files:

• /home/runner/work/n2p2/n2p2/src/libnnp/SymGrpCompAngnWeighted.h
• /home/runner/work/n2p2/n2p2/src/libnnp/SymGrpCompAngnWeighted.cpp