nnp::SymGrpExpAngnWeighted Class Reference

Weighted angular symmetry function group (type 13) More...

#include <SymGrpExpAngnWeighted.h>

Inheritance diagram for nnp::SymGrpExpAngnWeighted:

Collaboration diagram for nnp::SymGrpExpAngnWeighted:

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

Private Attributes
std::vector< SymFncExpAngnWeighted const * >	members
	Vector of all group member pointers.
std::vector< bool >	calculateExp
	Vector indicating whether exponential term needs to be calculated.
std::vector< double >	factorNorm
	Vector containing precalculated normalizing factor for each zeta.
std::vector< double >	factorDeriv
	Vector containing precalculated normalizing factor for derivatives.
std::vector< bool >	useIntegerPow
	Vector containing values of all member symmetry functions.
std::vector< int >	zetaInt
	Vector containing values of all member symmetry functions.
std::vector< double >	eta
	Vector containing values of all member symmetry functions.
std::vector< double >	rs
	Vector containing values of all member symmetry functions.
std::vector< double >	lambda
	Vector containing values of all member symmetry functions.
std::vector< double >	zeta
	Vector containing values of all member symmetry functions.
std::vector< double >	zetaLambda
	Vector containing values of all member symmetry functions.

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::SymGrpBaseCutoff
	SymGrpBaseCutoff (std::size_t type, ElementMap const &elementMap)
	Constructor, sets type.
Protected Member Functions inherited from nnp::SymGrp
	SymGrp (std::size_t type, ElementMap const &elementMap)
	Constructor, sets type.
std::string	getPrintFormatCommon () const
	Get common parameter line format string.
std::string	getPrintFormatMember () const
	Get member parameter line format string.
Static Protected Member Functions inherited from nnp::SymGrp
static PrintFormat const	initializePrintFormat ()
	Initialize static print format map for all possible parameters.
static PrintOrder const	initializePrintOrder ()
	Initialize static print order vector for all possible parameters.
Protected Attributes inherited from nnp::SymGrpBaseCutoff
double	rc
	Cutoff radius \(r_c\) (common feature).
double	cutoffAlpha
	Cutoff function parameter \(\alpha\) (common feature).
std::string	subtype
	Subtype string (specifies cutoff type) (common feature).
CutoffFunction	fc
	Cutoff function used by this symmetry function group.
CutoffFunction::CutoffType	cutoffType
	Cutoff type used by this symmetry function group (common feature).
Protected Attributes inherited from nnp::SymGrp
std::size_t	type
	Symmetry function type.
ElementMap	elementMap
	Copy of element map.
std::size_t	index
	Symmetry function group index.
std::size_t	ec
	Element index of center atom (common feature).
double	convLength
	Data set normalization length conversion factor.
std::vector< size_t >	memberIndex
	Vector containing indices of all member symmetry functions.
std::vector< double >	scalingFactors
	Scaling factors of all member symmetry functions.
std::set< std::string >	parametersCommon
	Set of common parameters IDs.
std::set< std::string >	parametersMember
	Set of common parameters IDs.
std::vector< std::vector< std::size_t > >	memberIndexPerElement
	Vector containing per-element indices of all member symmetry functions.
Static Protected Attributes inherited from nnp::SymGrp
static PrintFormat const	printFormat = initializePrintFormat()
	Map of parameter format strings and empty strings.
static PrintOrder const	printOrder = initializePrintOrder()
	Vector of parameters in order of printing.

Detailed Description

Weighted angular symmetry function group (type 13)

\[G^{13}_i = 2^{1-\zeta} \sum_{\substack{j,k\neq i \\ j < k}} Z_j Z_k \, \left( 1 + \lambda \cos \theta_{ijk} \right)^\zeta \mathrm{e}^{-\eta \left[ (r_{ij} - r_s)^2 + (r_{ik} - r_s)^2 + (r_{jk} - r_s)^2 \right] } f_c(r_{ij}) f_c(r_{ik}) f_c(r_{jk}) \]

Common features:

• element of central atom
• cutoff type
• \(r_c\)
• \(\alpha\)

Definition at line 49 of file SymGrpExpAngnWeighted.h.

Constructor & Destructor Documentation

SymGrpExpAngnWeighted()

SymGrpExpAngnWeighted::SymGrpExpAngnWeighted

(

ElementMap const &

elementMap

)

Constructor, sets type = 13.

Definition at line 30 of file SymGrpExpAngnWeighted.cpp.

                                                                         :
    SymGrpBaseCutoff(13, elementMap)
{
    parametersMember.insert("eta");
    parametersMember.insert("rs/rl");
    parametersMember.insert("lambda");
    parametersMember.insert("zeta");
    parametersMember.insert("mindex");
    parametersMember.insert("sfindex");
    parametersMember.insert("calcexp");
}

References nnp::SymGrp::elementMap, nnp::SymGrp::parametersMember, and nnp::SymGrpBaseCutoff::SymGrpBaseCutoff().

Referenced by operator<(), and operator==().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

operator==()

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

virtual

Overload == operator.

Implements nnp::SymGrp.

Definition at line 42 of file SymGrpExpAngnWeighted.cpp.

{
    if (ec   != rhs.getEc()  ) return false;
    if (type != rhs.getType()) return false;
    SymGrpExpAngnWeighted const& c =
        dynamic_cast<SymGrpExpAngnWeighted const&>(rhs);
    if (cutoffType  != c.cutoffType ) return false;
    if (cutoffAlpha != c.cutoffAlpha) return false;
    if (rc          != c.rc         ) return false;
    return true;
}

References nnp::SymGrpBaseCutoff::cutoffAlpha, nnp::SymGrpBaseCutoff::cutoffType, nnp::SymGrp::ec, nnp::SymGrp::getEc(), nnp::SymGrp::getType(), nnp::SymGrpBaseCutoff::rc, SymGrpExpAngnWeighted(), and nnp::SymGrp::type.

Here is the call graph for this function:

operator<()

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

virtual

Overload < operator.

Implements nnp::SymGrp.

Definition at line 54 of file SymGrpExpAngnWeighted.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;
    SymGrpExpAngnWeighted const& c =
        dynamic_cast<SymGrpExpAngnWeighted const&>(rhs);
    if      (cutoffType  < c.cutoffType ) return true;
    else if (cutoffType  > c.cutoffType ) return false;
    if      (cutoffAlpha < c.cutoffAlpha) return true;
    else if (cutoffAlpha > c.cutoffAlpha) return false;
    if      (rc          < c.rc         ) return true;
    else if (rc          > c.rc         ) return false;
    return false;
}

References nnp::SymGrpBaseCutoff::cutoffAlpha, nnp::SymGrpBaseCutoff::cutoffType, nnp::SymGrp::ec, nnp::SymGrp::getEc(), nnp::SymGrp::getType(), nnp::SymGrpBaseCutoff::rc, SymGrpExpAngnWeighted(), and nnp::SymGrp::type.

Here is the call graph for this function:

addMember()

bool SymGrpExpAngnWeighted::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 71 of file SymGrpExpAngnWeighted.cpp.

{
    if (symmetryFunction->getType() != type) return false;
 
    SymFncExpAngnWeighted const* sf =
        dynamic_cast<SymFncExpAngnWeighted const*>(symmetryFunction);
 
    if (members.empty())
    {
        cutoffType  = sf->getCutoffType();
        subtype     = sf->getSubtype();
        cutoffAlpha = sf->getCutoffAlpha();
        ec          = sf->getEc();
        rc          = sf->getRc();
        convLength  = sf->getConvLength();
 
        fc.setCutoffType(cutoffType);
        fc.setCutoffRadius(rc);
        fc.setCutoffParameter(cutoffAlpha);
    }
 
    if (sf->getCutoffType()  != cutoffType ) return false;
    if (sf->getCutoffAlpha() != cutoffAlpha) return false;
    if (sf->getEc()          != ec         ) return false;
    if (sf->getRc()          != rc         ) return false;
    if (sf->getConvLength()  != convLength )
    {
        throw runtime_error("ERROR: Unable to add symmetry function members "
                            "with different conversion factors.\n");
    }
 
    members.push_back(sf);
 
    return true;
}

References nnp::SymGrp::convLength, nnp::SymGrpBaseCutoff::cutoffAlpha, nnp::SymGrpBaseCutoff::cutoffType, nnp::SymGrp::ec, nnp::SymGrpBaseCutoff::fc, nnp::SymFnc::getConvLength(), nnp::SymFncBaseCutoff::getCutoffAlpha(), nnp::SymFncBaseCutoff::getCutoffType(), nnp::SymFnc::getEc(), nnp::SymFnc::getRc(), nnp::SymFncBaseCutoff::getSubtype(), nnp::SymFnc::getType(), members, nnp::SymGrpBaseCutoff::rc, nnp::SymGrpBaseCutoff::subtype, and nnp::SymGrp::type.

Here is the call graph for this function:

sortMembers()

void SymGrpExpAngnWeighted::sortMembers ( )

virtual

Sort member symmetry functions.

Also allocate and precalculate additional stuff.

Implements nnp::SymGrp.

Definition at line 107 of file SymGrpExpAngnWeighted.cpp.

{
    sort(members.begin(),
         members.end(),
         comparePointerTargets<SymFncExpAngnWeighted const>);
 
    // Members are now sorted with eta changing the slowest.
    for (size_t i = 0; i < members.size(); i++)
    {
        factorNorm.push_back(pow(2.0, 1.0 - members[i]->getZeta()));
        factorDeriv.push_back(2.0 * members[i]->getEta() /
                              members[i]->getZeta() / members[i]->getLambda());
        if (i == 0)
        {
            calculateExp.push_back(true);
        }
        else
        {
            if ( members[i - 1]->getEta() != members[i]->getEta() ||
                 members[i - 1]->getRs()  != members[i]->getRs() )
            {
                calculateExp.push_back(true);
            }
            else
            {
                calculateExp.push_back(false);
            }
        }
        useIntegerPow.push_back(members[i]->getUseIntegerPow());
        memberIndex.push_back(members[i]->getIndex());
        zetaInt.push_back(members[i]->getZetaInt());
        eta.push_back(members[i]->getEta());
        rs.push_back(members[i]->getRs());
        lambda.push_back(members[i]->getLambda());
        zeta.push_back(members[i]->getZeta());
        zetaLambda.push_back(members[i]->getZeta() * members[i]->getLambda());
        memberIndexPerElement.push_back(members[i]->getIndexPerElement());
    }
 
    return;
}

References calculateExp, nnp::comparePointerTargets(), eta, factorDeriv, factorNorm, nnp::SymGrp::getIndex(), lambda, nnp::SymGrp::memberIndex, nnp::SymGrp::memberIndexPerElement, members, rs, useIntegerPow, zeta, zetaInt, and zetaLambda.

Here is the call graph for this function:

setScalingFactors()

void SymGrpExpAngnWeighted::setScalingFactors ( )

virtual

Fill scalingFactors with values from member symmetry functions.

Implements nnp::SymGrp.

Definition at line 149 of file SymGrpExpAngnWeighted.cpp.

{
    scalingFactors.resize(members.size(), 0.0);
    for (size_t i = 0; i < members.size(); i++)
    {
        scalingFactors.at(i) = members[i]->getScalingFactor();
        factorNorm.at(i) *= scalingFactors.at(i);
    }
 
    return;
}

References factorNorm, members, and nnp::SymGrp::scalingFactors.

calculate()

void SymGrpExpAngnWeighted::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 167 of file SymGrpExpAngnWeighted.cpp.

{
#ifndef N2P2_NO_SF_CACHE
    // Can use cache indices of any member because this group is defined via
    // identical symmetry function type and cutoff functions.
    auto cacheIndices = members.at(0)->getCacheIndices();
#endif
    double* result = new double[members.size()];
    for (size_t l = 0; l < members.size(); ++l)
    {
        result[l] = 0.0;
    }
 
    double const rc2 = rc * rc;
    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 < rc)
        {
            double const r2ij = rij * rij;
 
            // Calculate cutoff function and derivative.
            double pfcij;
            double pdfcij;
#ifndef N2P2_NO_SF_CACHE
            if (cacheIndices[nej].size() == 0) fc.fdf(rij, pfcij, pdfcij);
            else
            {
                double& cfc = nj.cache[cacheIndices[nej][0]];
                double& cdfc = nj.cache[cacheIndices[nej][1]];
                if (cfc < 0) fc.fdf(rij, cfc, cdfc);
                pfcij = cfc;
                pdfcij = cdfc;
            }
#else
            fc.fdf(rij, pfcij, pdfcij);
#endif
            // SIMPLE EXPRESSIONS:
            //Vec3D const drij(atom.neighbors[j].dr);
            //double const* const dr1 = drij.r;
            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 < rc)
                {
                    // SIMPLE EXPRESSIONS:
                    //Vec3D const drjk(atom.neighbors[k].dr
                    //               - atom.neighbors[j].dr);
                    //double rjk = drjk.norm2();
                    double const* const dr2 = nk.dr.r;
                    double dr3[3];
                    dr3[0] = dr2[0] - dr1[0];
                    dr3[1] = dr2[1] - dr1[1];
                    dr3[2] = dr2[2] - dr1[2];
                    double rjk = dr3[0] * dr3[0]
                               + dr3[1] * dr3[1]
                               + dr3[2] * dr3[2];
                    if (rjk < rc2)
                    {
                        // Energy calculation.
                        double pfcik;
                        double pdfcik;
#ifndef N2P2_NO_SF_CACHE
                        if (cacheIndices[nej].size() == 0)
                        {
                            fc.fdf(rik, pfcik, pdfcik);
                        }
                        else
                        {
                            double& cfc = nk.cache[cacheIndices[nek][0]];
                            double& cdfc = nk.cache[cacheIndices[nek][1]];
                            if (cfc < 0) fc.fdf(rik, cfc, cdfc);
                            pfcik = cfc;
                            pdfcik = cdfc;
                        }
#else
                        fc.fdf(rik, pfcik, pdfcik);
#endif
                        rjk = sqrt(rjk);
 
                        double pfcjk;
                        double pdfcjk;
                        fc.fdf(rjk, pfcjk, pdfcjk);
 
                        // SIMPLE EXPRESSIONS:
                        //Vec3D const drik(atom.neighbors[k].dr);
                        //double const* const dr2 = drik.r;
                        //double const* const dr3 = drjk.r;
                        double const rinvijik = 1.0 / rij / rik;
                        // SIMPLE EXPRESSIONS:
                        //double const costijk = (drij * drik) * rinvijik;
                        double const costijk = (dr1[0] * dr2[0] +
                                                dr1[1] * dr2[1] +
                                                dr1[2] * dr2[2]) * rinvijik;
                        double const z = elementMap.atomicNumber(nej)
                                       * elementMap.atomicNumber(nek);
                        double const pfc = z * pfcij * pfcik * pfcjk;
                        double const r2ik = rik * rik;
                        double const pr1 = z * pfcik * pfcjk * pdfcij / rij;
                        double const pr2 = z * pfcij * pfcjk * pdfcik / rik;
                        double const pr3 = z * pfcij * pfcik * pdfcjk / rjk;
                        double vexp = 0.0;
                        double rijs = 0.0;
                        double riks = 0.0;
                        double rjks = 0.0;
 
                        for (size_t l = 0; l < members.size(); ++l)
                        {
                            if (calculateExp[l])
                            {
                                rijs = rij - rs[l];
                                riks = rik - rs[l];
                                rjks = rjk - rs[l];
                                double const r2sum = rijs * rijs
                                                   + riks * riks
                                                   + rjks * rjks;
                                vexp = exp(-eta[l] * r2sum);
                            }
                            double const plambda = 1.0
                                                 + lambda[l] * costijk;
                            double fg = vexp;
                            if (plambda <= 0.0) fg = 0.0;
                            else
                            {
                                if (useIntegerPow[l])
                                {
                                    fg *= pow_int(plambda, zetaInt[l] - 1);
                                }
                                else
                                {
                                    fg *= pow(plambda, zeta[l] - 1.0);
                                }
                            }
                            result[l] += fg * plambda * pfc;
 
                            // Force calculation.
                            if (!derivatives) continue;
                            fg *= factorNorm[l];
                            double const pfczl = pfc * zetaLambda[l];
                            double const p2etapl = plambda * factorDeriv[l];
                            double const p1 = fg * (pfczl * (rinvijik - costijk
                                            / r2ij - p2etapl * rijs / rij)
                                            + pr1 * plambda);
                            double const p2 = fg * (pfczl * (rinvijik - costijk
                                            / r2ik - p2etapl * riks / rik)
                                            + pr2 * plambda);
                            double const p3 = fg * (pfczl * (rinvijik + p2etapl
                                            * rjks / rjk) - pr3 * plambda);
 
                            // Save force contributions in Atom storage.
                            //
                            // SIMPLE EXPRESSIONS:
                            //size_t const li = members[l]->getIndex();
                            //atom.dGdr[li] += p1 * drij + p2 * drik;
                            //atom.neighbors[j].dGdr[li] -= p1 * drij
                            //                            + p3 * drjk;
                            //atom.neighbors[k].dGdr[li] -= 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 * dr3[0];
                            double const p3drjky = p3 * dr3[1];
                            double const p3drjkz = p3 * dr3[2];
 
#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
                    } // rjk <= rc
                } // rik <= rc
            } // k
        } // rij <= rc
    } // j
 
    for (size_t l = 0; l < members.size(); ++l)
    {
        result[l] *= factorNorm[l] / scalingFactors[l];
        atom.G[memberIndex[l]] = members[l]->scale(result[l]);
    }
 
    delete[] result;
 
    return;
}

References nnp::Atom::Neighbor::cache, calculateExp, nnp::Atom::Neighbor::d, nnp::Atom::dGdr, nnp::Atom::Neighbor::dGdr, nnp::Atom::Neighbor::dr, nnp::Atom::Neighbor::element, nnp::SymGrp::elementMap, eta, factorDeriv, factorNorm, nnp::SymGrpBaseCutoff::fc, nnp::Atom::G, lambda, nnp::SymGrp::memberIndex, nnp::SymGrp::memberIndexPerElement, members, nnp::Atom::neighbors, nnp::Atom::numNeighbors, nnp::pow_int(), nnp::Vec3D::r, nnp::SymGrpBaseCutoff::rc, rs, nnp::SymGrp::scalingFactors, useIntegerPow, zeta, zetaInt, and zetaLambda.

Here is the call graph for this function:

parameterLines()

vector< string > SymGrpExpAngnWeighted::parameterLines ( ) const

virtual

Give symmetry function group parameters on multiple lines.

Returns

Vector of string containing symmetry function parameters lines.

Implements nnp::SymGrp.

Definition at line 391 of file SymGrpExpAngnWeighted.cpp.

{
    vector<string> v;
 
    v.push_back(strpr(getPrintFormatCommon().c_str(),
                      index + 1,
                      elementMap[ec].c_str(),
                      type,
                      subtype.c_str(),
                      rc / convLength,
                      cutoffAlpha));
 
    for (size_t i = 0; i < members.size(); ++i)
    {
        v.push_back(strpr(getPrintFormatMember().c_str(),
                          members[i]->getEta() * convLength * convLength,
                          members[i]->getRs() / convLength,
                          members[i]->getLambda(),
                          members[i]->getZeta(),
                          members[i]->getLineNumber() + 1,
                          i + 1,
                          members[i]->getIndex() + 1,
                          (int)calculateExp[i]));
    }
 
    return v;
}

References calculateExp, nnp::SymGrp::convLength, nnp::SymGrpBaseCutoff::cutoffAlpha, nnp::SymGrp::ec, nnp::SymGrp::elementMap, nnp::SymGrp::getIndex(), nnp::SymGrp::getPrintFormatCommon(), nnp::SymGrp::getPrintFormatMember(), nnp::SymGrp::index, members, nnp::SymGrpBaseCutoff::rc, nnp::strpr(), nnp::SymGrpBaseCutoff::subtype, and nnp::SymGrp::type.

Here is the call graph for this function:

Member Data Documentation

members

std::vector<SymFncExpAngnWeighted const*> nnp::SymGrpExpAngnWeighted::members

private

Vector of all group member pointers.

Definition at line 94 of file SymGrpExpAngnWeighted.h.

Referenced by addMember(), calculate(), parameterLines(), setScalingFactors(), and sortMembers().

calculateExp

std::vector<bool> nnp::SymGrpExpAngnWeighted::calculateExp

private

Vector indicating whether exponential term needs to be calculated.

Definition at line 96 of file SymGrpExpAngnWeighted.h.

Referenced by calculate(), parameterLines(), and sortMembers().

factorNorm

std::vector<double> nnp::SymGrpExpAngnWeighted::factorNorm

private

Vector containing precalculated normalizing factor for each zeta.

Definition at line 98 of file SymGrpExpAngnWeighted.h.

Referenced by calculate(), setScalingFactors(), and sortMembers().

factorDeriv

std::vector<double> nnp::SymGrpExpAngnWeighted::factorDeriv

private

Vector containing precalculated normalizing factor for derivatives.

Definition at line 100 of file SymGrpExpAngnWeighted.h.

Referenced by calculate(), and sortMembers().

useIntegerPow

std::vector<bool> nnp::SymGrpExpAngnWeighted::useIntegerPow

private

Vector containing values of all member symmetry functions.

Definition at line 102 of file SymGrpExpAngnWeighted.h.

Referenced by calculate(), and sortMembers().

zetaInt

std::vector<int> nnp::SymGrpExpAngnWeighted::zetaInt

private

Vector containing values of all member symmetry functions.

Definition at line 104 of file SymGrpExpAngnWeighted.h.

Referenced by calculate(), and sortMembers().

eta

std::vector<double> nnp::SymGrpExpAngnWeighted::eta

private

Vector containing values of all member symmetry functions.

Definition at line 106 of file SymGrpExpAngnWeighted.h.

Referenced by calculate(), and sortMembers().

rs

std::vector<double> nnp::SymGrpExpAngnWeighted::rs

private

Vector containing values of all member symmetry functions.

Definition at line 108 of file SymGrpExpAngnWeighted.h.

Referenced by calculate(), and sortMembers().

lambda

std::vector<double> nnp::SymGrpExpAngnWeighted::lambda

private

Vector containing values of all member symmetry functions.

Definition at line 110 of file SymGrpExpAngnWeighted.h.

Referenced by calculate(), and sortMembers().

zeta

std::vector<double> nnp::SymGrpExpAngnWeighted::zeta

private

Vector containing values of all member symmetry functions.

Definition at line 112 of file SymGrpExpAngnWeighted.h.

Referenced by calculate(), and sortMembers().

zetaLambda

std::vector<double> nnp::SymGrpExpAngnWeighted::zetaLambda

private

Vector containing values of all member symmetry functions.

Definition at line 114 of file SymGrpExpAngnWeighted.h.

Referenced by calculate(), and sortMembers().

---

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

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