Derived Cabana main NNP class. More...

#include <ModeCabana.h>

Inheritance diagram for nnp::ModeCabana< t_device >:

Collaboration diagram for nnp::ModeCabana< t_device >:

[legend]

Public Types
using	device_type = t_device

using	exe_space = typename device_type::execution_space

using	memory_space = typename device_type::memory_space

typedef exe_space::array_layout	layout

using	host_space = Kokkos::HostSpace

using	d_t_mass = Kokkos::View<T_V_FLOAT *, memory_space>

using	h_t_mass = Kokkos::View<T_V_FLOAT *, layout, host_space>

using	d_t_int = Kokkos::View<T_INT *, memory_space>

using	h_t_int = Kokkos::View<T_INT *, layout, host_space>

using	d_t_SF = Kokkos::View<T_FLOAT * * [15], memory_space>

using	t_SF = Kokkos::View<T_FLOAT * * [15], layout, host_space>

using	d_t_SFscaling = Kokkos::View<T_FLOAT * * [8], memory_space>

using	t_SFscaling = Kokkos::View<T_FLOAT * * [8], layout, host_space>

using	d_t_SFGmemberlist = Kokkos::View<T_INT ***, memory_space>

using	t_SFGmemberlist = Kokkos::View<T_INT ***, layout, host_space>

using	d_t_bias = Kokkos::View<T_FLOAT ***, memory_space>

using	t_bias = Kokkos::View<T_FLOAT ***, layout, host_space>

using	d_t_weights = Kokkos::View<T_FLOAT ****, memory_space>

using	t_weights = Kokkos::View<T_FLOAT ****, layout, host_space>

using	d_t_NN = Kokkos::View<T_FLOAT ***, memory_space>

Public Types inherited from nnp::Mode
enum class	NNPType { HDNNP_2G = 2 , HDNNP_4G = 4 , HDNNP_Q = 10 }

Public Member Functions
void	setupElementMap () override
	Set up the element map.

void	setupElements () override
	Set up all Element instances.

void	setupSymmetryFunctions () override
	Set up all symmetry functions.

void	setupSymmetryFunctionScaling (std::string const &fileName="scaling.data") override
	Set up symmetry function scaling from file.

void	setupSymmetryFunctionGroups () override
	Set up symmetry function groups.

void	setupNeuralNetwork () override
	Set up neural networks for all elements.

void	setupNeuralNetworkWeights (std::string const &fileNameFormat="weights.%03zu.data") override
	Set up neural network weights from files.

KOKKOS_INLINE_FUNCTION void	compute_cutoff (CutoffFunction::CutoffType cutoffType, double cutoffAlpha, double &fc, double &dfc, double r, double rc, bool derivative) const

KOKKOS_INLINE_FUNCTION double	scale (int attype, double value, int k, d_t_SFscaling SFscaling) const

template<class t_slice_x, class t_slice_f, class t_slice_type, class t_slice_dEdG, class t_neigh_list, class t_neigh_parallel, class t_angle_parallel>
void	calculateForces (t_slice_x x, t_slice_f f, t_slice_type type, t_slice_dEdG dEdG, t_neigh_list neigh_list, int N_local, t_neigh_parallel neigh_op, t_angle_parallel angle_op)
	Calculate forces for all atoms in given structure.

template<class t_slice_type, class t_slice_G, class t_slice_dEdG, class t_slice_E>
void	calculateAtomicNeuralNetworks (t_slice_type type, t_slice_G G, t_slice_dEdG dEdG, t_slice_E E, int N_local)
	Calculate atomic neural networks for all atoms in given structure.

template<class t_slice_x, class t_slice_type, class t_slice_G, class t_neigh_list, class t_neigh_parallel, class t_angle_parallel>
void	calculateSymmetryFunctionGroups (t_slice_x x, t_slice_type type, t_slice_G G, t_neigh_list neigh_list, int N_local, t_neigh_parallel neigh_op, t_angle_parallel angle_op)
	Calculate all symmetry function groups for all atoms in given structure.

	Mode ()

Public Member Functions inherited from nnp::Mode
	Mode ()

void	initialize ()
	Write welcome message with version information.

void	loadSettingsFile (std::string const &fileName="input.nn")
	Open settings file and load all keywords into memory.

void	setupGeneric (std::string const &nnpDir="", bool skipNormalize=false, bool initialHardness=false)
	Combine multiple setup routines and provide a basic NNP setup.

void	setupNormalization (bool standalone=true)
	Set up normalization.

void	setupCutoff ()
	Set up cutoff function for all symmetry functions.

void	setupSymmetryFunctionScalingNone ()
	Set up "empy" symmetry function scaling.

virtual void	setupSymmetryFunctionCache (bool verbose=false)
	Set up symmetry function cache.

void	setupSymmetryFunctionMemory (bool verbose=false)
	Extract required memory dimensions for symmetry function derivatives.

void	setupSymmetryFunctionStatistics (bool collectStatistics, bool collectExtrapolationWarnings, bool writeExtrapolationWarnings, bool stopOnExtrapolationWarnings)
	Set up symmetry function statistics collection.

void	setupCutoffMatrix ()
	Setup matrix storing all symmetry function cut-offs for each element.

virtual void	setupNeuralNetworkWeights (std::map< std::string, std::string > fileNameFormats=std::map< std::string, std::string >())
	Set up neural network weights from files with given name format.

virtual void	setupNeuralNetworkWeights (std::string directoryPrefix, std::map< std::string, std::string > fileNameFormats=std::map< std::string, std::string >())
	Set up neural network weights from files with given name format.

virtual void	setupElectrostatics (bool initialHardness=false, std::string directoryPrefix="", std::string fileNameFormat="hardness.%03zu.data")
	Set up electrostatics related stuff (hardness, screening, ...).

void	calculateSymmetryFunctions (Structure &structure, bool const derivatives)
	Calculate all symmetry functions for all atoms in given structure.

void	calculateSymmetryFunctionGroups (Structure &structure, bool const derivatives)
	Calculate all symmetry function groups for all atoms in given structure.

void	calculateAtomicNeuralNetworks (Structure &structure, bool const derivatives, std::string id="")
	Calculate a single atomic neural network for a given atom and nn type.

void	chargeEquilibration (Structure &structure, bool const derivativesElec)
	Perform global charge equilibration method.

void	calculateEnergy (Structure &structure) const
	Calculate potential energy for a given structure.

void	calculateCharge (Structure &structure) const
	Calculate total charge for a given structure.

void	calculateForces (Structure &structure) const
	Calculate forces for all atoms in given structure.

void	evaluateNNP (Structure &structure, bool useForces=true, bool useDEdG=true)
	Evaluate neural network potential (includes total energy, optionally forces and in some cases charges.

void	addEnergyOffset (Structure &structure, bool ref=true)
	Add atomic energy offsets to reference energy.

void	removeEnergyOffset (Structure &structure, bool ref=true)
	Remove atomic energy offsets from reference energy.

double	getEnergyOffset (Structure const &structure) const
	Get atomic energy offset for given structure.

double	getEnergyWithOffset (Structure const &structure, bool ref=true) const
	Add atomic energy offsets and return energy.

double	normalized (std::string const &property, double value) const
	Apply normalization to given property.

double	normalizedEnergy (Structure const &structure, bool ref=true) const
	Apply normalization to given energy of structure.

double	physical (std::string const &property, double value) const
	Undo normalization for a given property.

double	physicalEnergy (Structure const &structure, bool ref=true) const
	Undo normalization for a given energy of structure.

void	convertToNormalizedUnits (Structure &structure) const
	Convert one structure to normalized units.

void	convertToPhysicalUnits (Structure &structure) const
	Convert one structure to physical units.

void	logEwaldCutoffs ()
	Logs Ewald params whenever they change.

std::size_t	getNumExtrapolationWarnings () const
	Count total number of extrapolation warnings encountered for all elements and symmetry functions.

void	resetExtrapolationWarnings ()
	Erase all extrapolation warnings and reset counters.

NNPType	getNnpType () const
	Getter for Mode::nnpType.

double	getMeanEnergy () const
	Getter for Mode::meanEnergy.

double	getConvEnergy () const
	Getter for Mode::convEnergy.

double	getConvLength () const
	Getter for Mode::convLength.

double	getConvCharge () const
	Getter for Mode::convCharge.

double	getEwaldPrecision () const
	Getter for Mode::ewaldSetup.precision.

double	getEwaldMaxCharge () const
	Getter for Mode::ewaldSetup.maxCharge.

double	getEwaldMaxSigma () const
	Getter for Mode::ewaldSetup.maxQsigma.

EWALDTruncMethod	getEwaldTruncationMethod () const
	Getter for Mode::ewaldSetup.truncMethod.

KSPACESolver	kspaceSolver () const
	Getter for Mode::kspaceSolver.

double	getMaxCutoffRadius () const
	Getter for Mode::maxCutoffRadius.

std::size_t	getNumElements () const
	Getter for Mode::numElements.

ScreeningFunction	getScreeningFunction () const
	Getter for Mode::screeningFunction.

std::vector< std::size_t >	getNumSymmetryFunctions () const
	Get number of symmetry functions per element.

bool	useNormalization () const
	Check if normalization is enabled.

bool	settingsKeywordExists (std::string const &keyword) const
	Check if keyword was found in settings file.

std::string	settingsGetValue (std::string const &keyword) const
	Get value for given keyword in Settings instance.

std::vector< std::size_t >	pruneSymmetryFunctionsRange (double threshold)
	Prune symmetry functions according to their range and write settings file.

std::vector< std::size_t >	pruneSymmetryFunctionsSensitivity (double threshold, std::vector< std::vector< double > > sensitivity)
	Prune symmetry functions with sensitivity analysis data.

void	writePrunedSettingsFile (std::vector< std::size_t > prune, std::string fileName="output.nn") const
	Copy settings file but comment out lines provided.

void	writeSettingsFile (std::ofstream *const &file) const
	Write complete settings file.

Public Attributes
std::vector< std::string >	knownElements
	list of element symbols in order of periodic table

d_t_SF	d_SF

t_SF	SF

d_t_SFGmemberlist	d_SFGmemberlist

t_SFGmemberlist	SFGmemberlist

d_t_SFscaling	d_SFscaling

t_SFscaling	SFscaling

d_t_bias	bias

d_t_weights	weights

t_bias	h_bias

t_weights	h_weights

int	numLayers

int	numHiddenLayers

int	maxNeurons

d_t_int	numNeuronsPerLayer

h_t_int	h_numNeuronsPerLayer

d_t_int	AF

h_t_int	h_AF

h_t_mass	atomicEnergyOffset

h_t_int	h_numSFperElem

d_t_int	numSFperElem

h_t_int	h_numSFGperElem

d_t_int	numSFGperElem

int	maxSFperElem

double	meanEnergy

ScalingType	scalingType

std::vector< ElementCabana >	elements

std::vector< std::string >	elementStrings

Log	log
	Global log file.

std::size_t	numElements

std::vector< std::size_t >	minNeighbors

std::vector< double >	minCutoffRadius

double	maxCutoffRadius

double	cutoffAlpha

double	convEnergy

double	convLength

settings::Settings	settings

CutoffFunction::CutoffType	cutoffType

Public Attributes inherited from nnp::Mode
ElementMap	elementMap
	Global element map, populated by setupElementMap().

Log	log
	Global log file.

Additional Inherited Members
Protected Member Functions inherited from nnp::Mode
void	readNeuralNetworkWeights (std::string const &id, std::string const &fileName)
	Read in weights for a specific type of neural network.

Protected Attributes inherited from nnp::Mode
NNPType	nnpType

bool	normalize

bool	checkExtrapolationWarnings

std::size_t	numElements

std::vector< std::size_t >	minNeighbors

std::vector< double >	minCutoffRadius

double	maxCutoffRadius

double	cutoffAlpha

double	meanEnergy

double	convEnergy

double	convLength

double	convCharge

double	fourPiEps

EwaldSetup	ewaldSetup

KspaceGrid	kspaceGrid

settings::Settings	settings

SymFnc::ScalingType	scalingType

CutoffFunction::CutoffType	cutoffType

ScreeningFunction	screeningFunction

std::vector< Element >	elements

std::vector< std::string >	nnk

std::map< std::string, NNSetup >	nns

std::vector< std::vector< double > >	cutoffs
	Matrix storing all symmetry function cut-offs for all elements.

ErfcBuf	erfcBuf

Detailed Description

template<class t_device>
class nnp::ModeCabana< t_device >

Derived Cabana main NNP class.

The main n2p2 functions for computing energies and forces are replaced to use the Kokkos and Cabana libraries. Most setup functions are overridden; some are replaced as needed to work within device kernels.

Definition at line 46 of file ModeCabana.h.

Member Typedef Documentation

◆ device_type

template<class t_device>

using nnp::ModeCabana< t_device >::device_type = t_device

Definition at line 53 of file ModeCabana.h.

◆ exe_space

template<class t_device>

using nnp::ModeCabana< t_device >::exe_space = typename device_type::execution_space

Definition at line 54 of file ModeCabana.h.

◆ memory_space

template<class t_device>

using nnp::ModeCabana< t_device >::memory_space = typename device_type::memory_space

Definition at line 55 of file ModeCabana.h.

◆ layout

template<class t_device>

typedef exe_space::array_layout nnp::ModeCabana< t_device >::layout

Definition at line 56 of file ModeCabana.h.

◆ host_space

template<class t_device>

using nnp::ModeCabana< t_device >::host_space = Kokkos::HostSpace

Definition at line 57 of file ModeCabana.h.

◆ d_t_mass

template<class t_device>

using nnp::ModeCabana< t_device >::d_t_mass = Kokkos::View<T_V_FLOAT *, memory_space>

Definition at line 60 of file ModeCabana.h.

◆ h_t_mass

template<class t_device>

using nnp::ModeCabana< t_device >::h_t_mass = Kokkos::View<T_V_FLOAT *, layout, host_space>

Definition at line 61 of file ModeCabana.h.

◆ d_t_int

template<class t_device>

using nnp::ModeCabana< t_device >::d_t_int = Kokkos::View<T_INT *, memory_space>

Definition at line 62 of file ModeCabana.h.

◆ h_t_int

template<class t_device>

using nnp::ModeCabana< t_device >::h_t_int = Kokkos::View<T_INT *, layout, host_space>

Definition at line 63 of file ModeCabana.h.

◆ d_t_SF

template<class t_device>

using nnp::ModeCabana< t_device >::d_t_SF = Kokkos::View<T_FLOAT * * [15], memory_space>

Definition at line 66 of file ModeCabana.h.

◆ t_SF

template<class t_device>

using nnp::ModeCabana< t_device >::t_SF = Kokkos::View<T_FLOAT * * [15], layout, host_space>

Definition at line 67 of file ModeCabana.h.

◆ d_t_SFscaling

template<class t_device>

using nnp::ModeCabana< t_device >::d_t_SFscaling = Kokkos::View<T_FLOAT * * [8], memory_space>

Definition at line 68 of file ModeCabana.h.

◆ t_SFscaling

template<class t_device>

using nnp::ModeCabana< t_device >::t_SFscaling = Kokkos::View<T_FLOAT * * [8], layout, host_space>

Definition at line 69 of file ModeCabana.h.

◆ d_t_SFGmemberlist

template<class t_device>

using nnp::ModeCabana< t_device >::d_t_SFGmemberlist = Kokkos::View<T_INT ***, memory_space>

Definition at line 70 of file ModeCabana.h.

◆ t_SFGmemberlist

template<class t_device>

using nnp::ModeCabana< t_device >::t_SFGmemberlist = Kokkos::View<T_INT ***, layout, host_space>

Definition at line 71 of file ModeCabana.h.

◆ d_t_bias

template<class t_device>

using nnp::ModeCabana< t_device >::d_t_bias = Kokkos::View<T_FLOAT ***, memory_space>

Definition at line 74 of file ModeCabana.h.

◆ t_bias

template<class t_device>

using nnp::ModeCabana< t_device >::t_bias = Kokkos::View<T_FLOAT ***, layout, host_space>

Definition at line 75 of file ModeCabana.h.

◆ d_t_weights

template<class t_device>

using nnp::ModeCabana< t_device >::d_t_weights = Kokkos::View<T_FLOAT ****, memory_space>

Definition at line 76 of file ModeCabana.h.

◆ t_weights

template<class t_device>

using nnp::ModeCabana< t_device >::t_weights = Kokkos::View<T_FLOAT ****, layout, host_space>

Definition at line 77 of file ModeCabana.h.

◆ d_t_NN

template<class t_device>

using nnp::ModeCabana< t_device >::d_t_NN = Kokkos::View<T_FLOAT ***, memory_space>

Definition at line 78 of file ModeCabana.h.

Member Function Documentation

◆ setupElementMap()

template<class t_device>

void nnp::ModeCabana< t_device >::setupElementMap ( )

overridevirtual

Set up the element map.

Uses keyword elements. This function should follow immediately after settings are loaded via loadSettingsFile().

Reimplemented from nnp::Mode.

Definition at line 34 of file ModeCabana_impl.h.

{
    log << "\n";
    log << "*** SETUP: ELEMENT MAP ******************"
           "**************************************\n";
    log << "\n";
 
    elementStrings = split( reduce( settings["elements"] ) );
 
    log << strpr( "Number of element strings found: %d\n",
                       elementStrings.size() );
    for ( size_t i = 0; i < elementStrings.size(); ++i )
    {
        log << strpr( "Element %2zu: %2s\n", i,
                           elementStrings[i].c_str() );
    }
    // resize to match number of element types
    numElements = elementStrings.size();
 
    log << "*****************************************"
           "**************************************\n";
 
    return;
}

References elementStrings, log, numElements, nnp::reduce(), settings, nnp::split(), and nnp::strpr().

Here is the call graph for this function:

◆ setupElements()

template<class t_device>

void nnp::ModeCabana< t_device >::setupElements ( )

overridevirtual

Set up all Element instances.

Uses keywords number_of_elements and atom_energy. This function should follow immediately after setupElementMap().

Reimplemented from nnp::Mode.

Definition at line 60 of file ModeCabana_impl.h.

{
    log << "\n";
    log << "*** SETUP: ELEMENTS *********************"
           "**************************************\n";
    log << "\n";
 
    numElements = (size_t)atoi( settings["number_of_elements"].c_str() );
    atomicEnergyOffset =
        h_t_mass( "Mode::atomicEnergyOffset", numElements );
    if ( numElements != elementStrings.size() )
    {
        throw runtime_error( "ERROR: Inconsistent number of elements.\n" );
    }
    log << strpr( "Number of elements is consistent: %zu\n", numElements );
 
    for ( size_t i = 0; i < numElements; ++i )
    {
        elements.push_back( ElementCabana( i ) );
    }
 
    if ( settings.keywordExists( "atom_energy" ) )
    {
        Settings::KeyRange r = settings.getValues( "atom_energy" );
        for ( Settings::KeyMap::const_iterator it = r.first;
              it != r.second; ++it )
        {
            vector<string> args = split( reduce( it->second.first ) );
            const char *estring = args.at( 0 ).c_str();
            for ( size_t i = 0; i < elementStrings.size(); ++i )
            {
                if ( strcmp( elementStrings[i].c_str(), estring ) == 0 )
                    atomicEnergyOffset( i ) = atof( args.at( 1 ).c_str() );
            }
        }
    }
 
    log << "Atomic energy offsets per element:\n";
    for ( size_t i = 0; i < elementStrings.size(); ++i )
    {
        log << strpr( "Element %2zu: %16.8E\n", i,
                           atomicEnergyOffset( i ) );
    }
 
    log << "Energy offsets are automatically subtracted from reference "
           "energies.\n";
    log << "*****************************************"
           "**************************************\n";
 
    return;
}

References atomicEnergyOffset, elements, elementStrings, log, numElements, nnp::reduce(), settings, nnp::split(), and nnp::strpr().

Here is the call graph for this function:

◆ setupSymmetryFunctions()

template<class t_device>

void nnp::ModeCabana< t_device >::setupSymmetryFunctions ( )

overridevirtual

Set up all symmetry functions.

Uses keyword symfunction_short. Reads all symmetry functions from settings and automatically assigns them to the correct element.

Reimplemented from nnp::Mode.

Definition at line 113 of file ModeCabana_impl.h.

{
    maxSFperElem = 0;
    h_numSFperElem =
        h_t_int( "Mode::numSymmetryFunctionsPerElement", numElements );
    log << "\n";
    log << "*** SETUP: SYMMETRY FUNCTIONS ***********"
           "**************************************\n";
    log << "\n";
 
    // Only count SF per element; parse and add later
    Settings::KeyRange r = settings.getValues( "symfunction_short" );
    for ( Settings::KeyMap::const_iterator it = r.first; it != r.second;
          ++it )
    {
        vector<string> args = split( reduce( it->second.first ) );
        int type = 0;
        const char *estring = args.at( 0 ).c_str();
        for ( size_t i = 0; i < elementStrings.size(); ++i )
        {
            if ( strcmp( elementStrings[i].c_str(), estring ) == 0 )
                type = i;
        }
        h_numSFperElem( type )++;
 
        if ( h_numSFperElem( type ) > maxSFperElem )
            maxSFperElem = h_numSFperElem( type );
    }
    Kokkos::deep_copy( h_numSFperElem, 0 );
 
    // setup SF host views
    // create device mirrors if needed below
    SF = t_SF( "SymmetryFunctions", numElements, maxSFperElem );
    SFscaling = t_SFscaling( "SFscaling", numElements, maxSFperElem );
    // +1 to store size of memberlist
    SFGmemberlist = t_SFGmemberlist( "SFGmemberlist", numElements,
                                     maxSFperElem + 1, maxSFperElem + 1 );
 
    r = settings.getValues( "symfunction_short" );
    for ( Settings::KeyMap::const_iterator it = r.first; it != r.second;
          ++it )
    {
        vector<string> args = split( reduce( it->second.first ) );
        int type = 0;
        const char *estring = args.at( 0 ).c_str();
        for ( size_t i = 0; i < elementStrings.size(); ++i )
        {
            if ( strcmp( elementStrings[i].c_str(), estring ) == 0 )
                type = i;
        }
        elements.at( type ).addSymmetryFunction( it->second.first,
                                                 elementStrings, type, SF,
                                                 convLength, h_numSFperElem );
    }
 
    log << "Abbreviations:\n";
    log << "--------------\n";
    log << "ind .... Symmetry function index.\n";
    log << "ec ..... Central atom element.\n";
    log << "ty ..... Symmetry function type.\n";
    log << "e1 ..... Neighbor 1 element.\n";
    log << "e2 ..... Neighbor 2 element.\n";
    log << "eta .... Gaussian width eta.\n";
    log << "rs ..... Shift distance of Gaussian.\n";
    log << "la ..... Angle prefactor lambda.\n";
    log << "zeta ... Angle term exponent zeta.\n";
    log << "rc ..... Cutoff radius.\n";
    log << "ct ..... Cutoff type.\n";
    log << "ca ..... Cutoff alpha.\n";
    log << "ln ..... Line number in settings file.\n";
    log << "\n";
    maxCutoffRadius = 0.0;
 
    for ( vector<ElementCabana>::iterator it = elements.begin(); it != elements.end();
          ++it )
    {
        int attype = it->getIndex();
        it->sortSymmetryFunctions( SF, h_numSFperElem, attype );
        maxCutoffRadius =
            max( it->getMaxCutoffRadius( SF, attype, h_numSFperElem ),
                 maxCutoffRadius );
        it->setCutoffFunction( cutoffType, cutoffAlpha, SF, attype,
                               h_numSFperElem );
        log << strpr(
            "Short range atomic symmetry functions element %2s :\n",
            it->getSymbol().c_str() );
        log << "-----------------------------------------"
               "--------------------------------------\n";
        log << " ind ec ty e1 e2       eta        rs la "
               "zeta        rc ct   ca    ln\n";
        log << "-----------------------------------------"
               "--------------------------------------\n";
        log << it->infoSymmetryFunctionParameters( SF, attype, h_numSFperElem );
        log << "-----------------------------------------"
               "--------------------------------------\n";
    }
    minNeighbors.resize( numElements, 0 );
    minCutoffRadius.resize( numElements, maxCutoffRadius );
    for ( size_t i = 0; i < numElements; ++i )
    {
        int attype = elements.at( i ).getIndex();
        int nSF = h_numSFperElem( attype );
        minNeighbors.at( i ) =
            elements.at( i ).getMinNeighbors( attype, SF, nSF );
        minCutoffRadius.at( i ) =
            elements.at( i ).getMinCutoffRadius( SF, attype, h_numSFperElem );
        log << strpr( "Minimum cutoff radius for element %2s: %f\n",
                           elements.at( i ).getSymbol().c_str(),
                           minCutoffRadius.at( i ) / convLength );
    }
    log << strpr( "Maximum cutoff radius (global)      : %f\n",
                       maxCutoffRadius / convLength );
 
    log << "*****************************************"
           "**************************************\n";
 
    numSFperElem =
        Kokkos::create_mirror_view_and_copy( memory_space(), h_numSFperElem );
 
    return;
}

References convLength, cutoffAlpha, cutoffType, elements, elementStrings, h_numSFperElem, log, maxCutoffRadius, maxSFperElem, minCutoffRadius, minNeighbors, numElements, numSFperElem, nnp::reduce(), settings, SF, SFGmemberlist, SFscaling, nnp::split(), and nnp::strpr().

Here is the call graph for this function:

◆ setupSymmetryFunctionScaling()

template<class t_device>

void nnp::ModeCabana< t_device >::setupSymmetryFunctionScaling ( std::string const & fileName = "scaling.data" )

overridevirtual

Set up symmetry function scaling from file.

Parameters

[in] fileName Scaling file name.

Uses keywords scale_symmetry_functions, center_symmetry_functions, scale_symmetry_functions_sigma, scale_min_short and scale_max_short. Reads in scaling information and sets correct scaling behavior for all symmetry functions. Call after setupSymmetryFunctions().

Reimplemented from nnp::Mode.

Definition at line 237 of file ModeCabana_impl.h.

{
    log << "\n";
    log << "*** SETUP: SYMMETRY FUNCTION SCALING ****"
           "**************************************\n";
    log << "\n";
 
    log << "Equal scaling type for all symmetry functions:\n";
    if ( ( settings.keywordExists( "scale_symmetry_functions" ) ) &&
         ( !settings.keywordExists( "center_symmetry_functions" ) ) )
    {
        scalingType = ST_SCALE;
        log << strpr( "Scaling type::ST_SCALE (%d)\n", scalingType );
        log << "Gs = Smin + (Smax - Smin) * (G - Gmin) / (Gmax - Gmin)\n";
    }
    else if ( ( !settings.keywordExists( "scale_symmetry_functions" ) ) &&
              ( settings.keywordExists( "center_symmetry_functions" ) ) )
    {
        scalingType = ST_CENTER;
        log << strpr( "Scaling type::ST_CENTER (%d)\n", scalingType );
        log << "Gs = G - Gmean\n";
    }
    else if ( ( settings.keywordExists( "scale_symmetry_functions" ) ) &&
              ( settings.keywordExists( "center_symmetry_functions" ) ) )
    {
        scalingType = ST_SCALECENTER;
        log << strpr( "Scaling type::ST_SCALECENTER (%d)\n", scalingType );
        log << "Gs = Smin + (Smax - Smin) * (G - Gmean) / (Gmax - Gmin)\n";
    }
    else if ( settings.keywordExists( "scale_symmetry_functions_sigma" ) )
    {
        scalingType = ST_SCALESIGMA;
        log << strpr( "Scaling type::ST_SCALESIGMA (%d)\n", scalingType );
        log << "Gs = Smin + (Smax - Smin) * (G - Gmean) / Gsigma\n";
    }
    else
    {
        scalingType = ST_NONE;
        log << strpr( "Scaling type::ST_NONE (%d)\n", scalingType );
        log << "Gs = G\n";
        log << "WARNING: No symmetry function scaling!\n";
    }
 
    double Smin = 0.0;
    double Smax = 0.0;
    if ( scalingType == ST_SCALE || scalingType == ST_SCALECENTER ||
         scalingType == ST_SCALESIGMA )
    {
        if ( settings.keywordExists( "scale_min_short" ) )
        {
            Smin = atof( settings["scale_min_short"].c_str() );
        }
        else
        {
            log << "WARNING: Keyword \"scale_min_short\" not found.\n";
            log << "         Default value for Smin = 0.0.\n";
            Smin = 0.0;
        }
 
        if ( settings.keywordExists( "scale_max_short" ) )
        {
            Smax = atof( settings["scale_max_short"].c_str() );
        }
        else
        {
            log << "WARNING: Keyword \"scale_max_short\" not found.\n";
            log << "         Default value for Smax = 1.0.\n";
            Smax = 1.0;
        }
 
        log << strpr( "Smin = %f\n", Smin );
        log << strpr( "Smax = %f\n", Smax );
    }
 
    log << strpr( "Symmetry function scaling statistics from file: %s\n",
                       fileName.c_str() );
    log << "-----------------------------------------"
           "--------------------------------------\n";
    ifstream file;
    file.open( fileName.c_str() );
    if ( !file.is_open() )
    {
        throw runtime_error( "ERROR: Could not open file: \"" + fileName +
                             "\".\n" );
    }
    string line;
    vector<string> lines;
    while ( getline( file, line ) )
    {
        if ( line.at( 0 ) != '#' )
            lines.push_back( line );
    }
    file.close();
 
    log << "\n";
    log << "Abbreviations:\n";
    log << "--------------\n";
    log << "ind ..... Symmetry function index.\n";
    log << "min ..... Minimum symmetry function value.\n";
    log << "max ..... Maximum symmetry function value.\n";
    log << "mean .... Mean symmetry function value.\n";
    log << "sigma ... Standard deviation of symmetry function values.\n";
    log << "sf ...... Scaling factor for derivatives.\n";
    log << "Smin .... Desired minimum scaled symmetry function value.\n";
    log << "Smax .... Desired maximum scaled symmetry function value.\n";
    log << "t ....... Scaling type.\n";
    log << "\n";
    for ( vector<ElementCabana>::iterator it = elements.begin(); it != elements.end();
          ++it )
    {
        int attype = it->getIndex();
        it->setScaling( scalingType, lines, Smin, Smax, SF, SFscaling, attype,
                        h_numSFperElem );
        log << strpr(
            "Scaling data for symmetry functions element %2s :\n",
            it->getSymbol().c_str() );
        log << "-----------------------------------------"
               "--------------------------------------\n";
        log << " ind       min       max      mean     sigma        sf  Smin  "
               "Smax t\n";
        log << "-----------------------------------------"
               "--------------------------------------\n";
        log << it->infoSymmetryFunctionScaling( scalingType, SF, SFscaling,
                                                attype, h_numSFperElem );
        log << "-----------------------------------------"
               "--------------------------------------\n";
        lines.erase( lines.begin(),
                     lines.begin() +
                         it->numSymmetryFunctions( attype, h_numSFperElem ) );
    }
 
    log << "*****************************************"
           "**************************************\n";
 
    d_SF = Kokkos::create_mirror_view_and_copy( memory_space(), SF );
    d_SFscaling =
        Kokkos::create_mirror_view_and_copy( memory_space(), SFscaling );
    d_SFGmemberlist =
        Kokkos::create_mirror_view_and_copy( memory_space(), SFGmemberlist );
 
    return;
}

References d_SF, d_SFGmemberlist, d_SFscaling, elements, h_numSFperElem, log, scalingType, settings, SF, SFGmemberlist, SFscaling, ST_CENTER, ST_NONE, ST_SCALE, ST_SCALECENTER, ST_SCALESIGMA, and nnp::strpr().

Here is the call graph for this function:

◆ setupSymmetryFunctionGroups()

template<class t_device>

void nnp::ModeCabana< t_device >::setupSymmetryFunctionGroups ( )

overridevirtual

Set up symmetry function groups.

Does not use any keywords. Call after setupSymmetryFunctions() and ensure that correct scaling behavior has already been set.

Reimplemented from nnp::Mode.

Definition at line 381 of file ModeCabana_impl.h.

{
    log << "\n";
    log << "*** SETUP: SYMMETRY FUNCTION GROUPS *****"
           "**************************************\n";
    log << "\n";
 
    log << "Abbreviations:\n";
    log << "--------------\n";
    log << "ind .... Symmetry function group index.\n";
    log << "ec ..... Central atom element.\n";
    log << "ty ..... Symmetry function type.\n";
    log << "e1 ..... Neighbor 1 element.\n";
    log << "e2 ..... Neighbor 2 element.\n";
    log << "eta .... Gaussian width eta.\n";
    log << "rs ..... Shift distance of Gaussian.\n";
    log << "la ..... Angle prefactor lambda.\n";
    log << "zeta ... Angle term exponent zeta.\n";
    log << "rc ..... Cutoff radius.\n";
    log << "ct ..... Cutoff type.\n";
    log << "ca ..... Cutoff alpha.\n";
    log << "ln ..... Line number in settings file.\n";
    log << "mi ..... Member index.\n";
    log << "sfi .... Symmetry function index.\n";
    log << "e ...... Recalculate exponential term.\n";
    log << "\n";
 
    h_numSFGperElem =
        h_t_int( "Mode::numSymmetryFunctionGroupsPerElement", numElements );
 
    for ( vector<ElementCabana>::iterator it = elements.begin(); it != elements.end();
          ++it )
    {
        int attype = it->getIndex();
        it->setupSymmetryFunctionGroups( SF, SFGmemberlist, attype,
                                         h_numSFperElem, h_numSFGperElem,
                                         maxSFperElem );
        log << strpr( "Short range atomic symmetry function groups "
                           "element %2s :\n",
                           it->getSymbol().c_str() );
        log << "-----------------------------------------"
               "--------------------------------------\n";
        log << " ind ec ty e1 e2       eta        rs la "
               "zeta        rc ct   ca    ln   mi  sfi e\n";
        log << "-----------------------------------------"
               "--------------------------------------\n";
        log << it->infoSymmetryFunctionGroups( SF, SFGmemberlist, attype,
                                               h_numSFGperElem );
        log << "-----------------------------------------"
               "--------------------------------------\n";
    }
 
    log << "*****************************************"
           "**************************************\n";
 
    numSFGperElem =
        Kokkos::create_mirror_view_and_copy( memory_space(), h_numSFGperElem );
 
    return;
}

References elements, h_numSFGperElem, h_numSFperElem, log, maxSFperElem, numElements, numSFGperElem, SF, SFGmemberlist, and nnp::strpr().

Here is the call graph for this function:

◆ setupNeuralNetwork()

template<class t_device>

void nnp::ModeCabana< t_device >::setupNeuralNetwork ( )

overridevirtual

Set up neural networks for all elements.

Uses keywords global_hidden_layers_short, global_nodes_short, global_activation_short, normalize_nodes. Call after setupSymmetryFunctions(), only then the number of input layer neurons is known.

Reimplemented from nnp::Mode.

Definition at line 443 of file ModeCabana_impl.h.

{
    log << "\n";
    log << "*** SETUP: NEURAL NETWORKS **************"
           "**************************************\n";
    log << "\n";
 
    numLayers = 2 + atoi( settings["global_hidden_layers_short"].c_str() );
    numHiddenLayers = numLayers - 2;
 
    h_numNeuronsPerLayer = h_t_int( "Mode::numNeuronsPerLayer", numLayers );
    h_AF = h_t_int( "Mode::ActivationFunctions", numLayers );
 
    vector<string> numNeuronsPerHiddenLayer =
        split( reduce( settings["global_nodes_short"] ) );
    vector<string> activationFunctions =
        split( reduce( settings["global_activation_short"] ) );
 
    for ( int i = 0; i < numLayers; i++ )
    {
        if ( i == 0 )
            h_AF( i ) = 0;
        else if ( i == numLayers - 1 )
        {
            h_numNeuronsPerLayer( i ) = 1;
            h_AF( i ) = 0;
        }
        else
        {
            h_numNeuronsPerLayer( i ) =
                atoi( numNeuronsPerHiddenLayer.at( i - 1 ).c_str() );
            h_AF( i ) = 1; // TODO: hardcoded atoi(activationFunctions.at(i-1));
        }
    }
 
    // TODO: add normalization of neurons
    bool normalizeNeurons = settings.keywordExists( "normalize_nodes" );
    log << strpr( "Normalize neurons (all elements): %d\n",
                       (int)normalizeNeurons );
    log << "-----------------------------------------"
           "--------------------------------------\n";
 
    for ( vector<ElementCabana>::iterator it = elements.begin(); it != elements.end();
          ++it )
    {
        int attype = it->getIndex();
        h_numNeuronsPerLayer( 0 ) =
            it->numSymmetryFunctions( attype, h_numSFperElem );
        log << strpr( "Atomic short range NN for "
                           "element %2s :\n",
                           it->getSymbol().c_str() );
 
        int numWeights = 0, numBiases = 0, numConnections = 0;
        for ( int j = 1; j < numLayers; ++j )
        {
            numWeights +=
                h_numNeuronsPerLayer( j - 1 ) * h_numNeuronsPerLayer( j );
            numBiases += h_numNeuronsPerLayer( j );
        }
        numConnections = numWeights + numBiases;
        log << strpr( "Number of weights    : %6zu\n", numWeights );
        log << strpr( "Number of biases     : %6zu\n", numBiases );
        log << strpr( "Number of connections: %6zu\n", numConnections );
        log << strpr( "Architecture    " );
        for ( int j = 0; j < numLayers; ++j )
            log << strpr( " %4d", h_numNeuronsPerLayer( j ) );
 
        log << "\n-----------------------------------------"
               "--------------------------------------\n";
    }
 
    // initialize Views
    maxNeurons = 0;
    for ( int j = 0; j < numLayers; ++j )
        maxNeurons = max( maxNeurons, h_numNeuronsPerLayer( j ) );
 
    h_bias = t_bias( "Mode::biases", numElements, numLayers, maxNeurons );
    h_weights = t_weights( "Mode::weights", numElements, numLayers,
                           maxNeurons, maxNeurons );
 
    log << "*****************************************"
           "**************************************\n";
 
    return;
}

References elements, h_AF, h_bias, h_numNeuronsPerLayer, h_numSFperElem, h_weights, log, maxNeurons, numElements, numHiddenLayers, numLayers, nnp::reduce(), settings, nnp::split(), and nnp::strpr().

Here is the call graph for this function:

◆ setupNeuralNetworkWeights()

template<class t_device>

void nnp::ModeCabana< t_device >::setupNeuralNetworkWeights ( std::string const & fileNameFormat = "weights.%03zu.data" )

override

Set up neural network weights from files.

Parameters

[in] fileNameFormat Format for weights file name. The string must contain one placeholder for the atomic number.

Does not use any keywords. The weight files should contain one weight per line, see NeuralNetwork::setConnections() for the correct order.

Definition at line 530 of file ModeCabana_impl.h.

{
    log << "\n";
    log << "*** SETUP: NEURAL NETWORK WEIGHTS *******"
           "**************************************\n";
    log << "\n";
 
    log << strpr( "Weight file name format: %s\n",
                       fileNameFormat.c_str() );
    int count = 0;
    int AN = 0;
    for ( vector<ElementCabana>::iterator it = elements.begin(); it != elements.end();
          ++it )
    {
        const char *estring = elementStrings[count].c_str();
        for ( size_t i = 0; i < knownElements.size(); ++i )
        {
            if ( strcmp( knownElements[i].c_str(), estring ) == 0 )
            {
                AN = i + 1;
                break;
            }
        }
 
        string fileName = strpr( fileNameFormat.c_str(), AN );
        log << strpr( "Weight file for element %2s: %s\n",
                           elementStrings[count].c_str(), fileName.c_str() );
        ifstream file;
        file.open( fileName.c_str() );
        if ( !file.is_open() )
        {
            throw runtime_error( "ERROR: Could not open file: \"" + fileName +
                                 "\".\n" );
        }
        string line;
        int attype = it->getIndex();
        int layer, start, end;
        while ( getline( file, line ) )
        {
            if ( line.at( 0 ) != '#' )
            {
                vector<string> splitLine = split( reduce( line ) );
                if ( strcmp( splitLine.at( 1 ).c_str(), "a" ) == 0 )
                {
                    layer = atoi( splitLine.at( 3 ).c_str() );
                    start = atoi( splitLine.at( 4 ).c_str() ) - 1;
                    end = atoi( splitLine.at( 6 ).c_str() ) - 1;
                    h_weights( attype, layer, end, start ) =
                        atof( splitLine.at( 0 ).c_str() );
                }
                else if ( strcmp( splitLine.at( 1 ).c_str(), "b" ) == 0 )
                {
                    layer = atoi( splitLine.at( 3 ).c_str() ) - 1;
                    start = atoi( splitLine.at( 4 ).c_str() ) - 1;
                    h_bias( attype, layer, start ) =
                        atof( splitLine.at( 0 ).c_str() );
                }
            }
        }
        file.close();
        count += 1;
    }
    log << "*****************************************"
           "**************************************\n";
 
    bias = Kokkos::create_mirror_view_and_copy( memory_space(), h_bias );
    weights = Kokkos::create_mirror_view_and_copy( memory_space(), h_weights );
    AF = Kokkos::create_mirror_view_and_copy( memory_space(), h_AF );
    numNeuronsPerLayer = Kokkos::create_mirror_view_and_copy(
        memory_space(), h_numNeuronsPerLayer );
 
    return;
}

References AF, bias, elements, elementStrings, h_AF, h_bias, h_numNeuronsPerLayer, h_weights, knownElements, log, numNeuronsPerLayer, nnp::reduce(), nnp::split(), nnp::strpr(), and weights.

Here is the call graph for this function:

◆ compute_cutoff()

template<class t_device>

KOKKOS_INLINE_FUNCTION void nnp::ModeCabana< t_device >::compute_cutoff	(	CutoffFunction::CutoffType	cutoffType,
		double	cutoffAlpha,
		double &	fc,
		double &	dfc,
		double	r,
		double	rc,
		bool	derivative ) const

Definition at line 285 of file ModeCabana.h.

{
    double temp;
    if (cutoffType == CutoffFunction::CT_TANHU) {
        temp = tanh(1.0 - r / rc);
        fc = temp * temp * temp;
        if (derivative)
            dfc = 3.0 * temp * temp * (temp * temp - 1.0) / rc;
    }
 
    if (cutoffType == CutoffFunction::CT_COS) {
 
        double rci = rc * cutoffAlpha;
        double iw = 1.0 / (rc - rci);
        double PI = 4.0 * atan(1.0);
        if (r < rci) {
            fc = 1.0;
            dfc = 0.0;
        } else {
            temp = cos(PI * (r - rci) * iw);
            fc = 0.5 * (temp + 1.0);
            if (derivative)
                dfc = -0.5 * iw * PI * sqrt(1.0 - temp * temp);
        }
    }
}

References nnp::CutoffFunction::CT_COS, nnp::CutoffFunction::CT_TANHU, cutoffAlpha, cutoffType, and fc.

Referenced by calculateForces(), and calculateSymmetryFunctionGroups().

Here is the caller graph for this function:

◆ scale()

template<class t_device>

KOKKOS_INLINE_FUNCTION double nnp::ModeCabana< t_device >::scale	(	int	attype,
		double	value,
		int	k,
		d_t_SFscaling	SFscaling ) const

Definition at line 316 of file ModeCabana.h.

{
    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 Smin + scalingFactor * (value - Gmin);
    } else if (scalingType == 2.0) {
        return value - Gmean;
    } else if (scalingType == 3.0) {
        return Smin + scalingFactor * (value - Gmean);
    } else if (scalingType == 4.0) {
        return Smin + scalingFactor * (value - Gmean);
    } else {
        return 0.0;
    }
}

References scalingType.

Referenced by calculateSymmetryFunctionGroups().

Here is the caller graph for this function:

◆ calculateForces()

template<class t_device>

template<class t_slice_x, class t_slice_f, class t_slice_type, class t_slice_dEdG, class t_neigh_list, class t_neigh_parallel, class t_angle_parallel>

void nnp::ModeCabana< t_device >::calculateForces	(	t_slice_x	x,
		t_slice_f	f,
		t_slice_type	type,
		t_slice_dEdG	dEdG,
		t_neigh_list	neigh_list,
		int	N_local,
		t_neigh_parallel	neigh_op,
		t_angle_parallel	angle_op )

Calculate forces for all atoms in given structure.

Parameters

[in]	x	Cabana slice of atom positions.
[in]	f	Cabana slice of atom forces.
[in]	type	Cabana slice of atom types.
[in]	dEdG	Cabana slice of the derivative of energy with respect to symmetry functions per atom.
[in]	N_local	Number of atoms.
[in]	neigh_op	Cabana tag for neighbor parallelism.
[in]	angle_op	Cabana tag for angular parallelism.

Combine intermediate results from symmetry function and neural network computation to atomic forces. Results are stored in f.

Definition at line 932 of file ModeCabana_impl.h.

{
    double convForce_ = convLength / convEnergy;
 
    Kokkos::RangePolicy<exe_space> policy( 0, N_local );
 
    // Create local copies for lambda
    auto numSFGperElem_ = numSFGperElem;
    auto SFGmemberlist_ = d_SFGmemberlist;
    auto SF_ = d_SF;
    auto SFscaling_ = d_SFscaling;
    auto maxSFperElem_ = maxSFperElem;
    auto convLength_ = convLength;
    auto cutoffType_ = cutoffType;
    auto cutoffAlpha_ = cutoffAlpha;
 
    auto calc_radial_force_op = KOKKOS_LAMBDA( const int i, const int j )
    {
        double pfcij = 0.0;
        double pdfcij = 0.0;
        double rij, r2ij;
        T_F_FLOAT dxij, dyij, dzij;
        double eta, rs;
        int memberindex, globalIndex;
 
        int attype = type( i );
 
        for ( int groupIndex = 0; groupIndex < numSFGperElem_( attype );
              ++groupIndex )
        {
            if ( SF_( attype, SFGmemberlist_( attype, groupIndex, 0 ), 1 ) ==
                 2 )
            {
                size_t memberindex0 = SFGmemberlist_( attype, groupIndex, 0 );
                size_t e1 = SF_( attype, memberindex0, 2 );
                double rc = SF_( attype, memberindex0, 7 );
                size_t size =
                    SFGmemberlist_( attype, groupIndex, maxSFperElem_ );
 
                size_t nej = type( j );
                dxij = ( x( i, 0 ) - x( j, 0 ) ) * CFLENGTH * convLength_;
                dyij = ( x( i, 1 ) - x( j, 1 ) ) * CFLENGTH * convLength_;
                dzij = ( x( i, 2 ) - x( j, 2 ) ) * CFLENGTH * convLength_;
                r2ij = dxij * dxij + dyij * dyij + dzij * dzij;
                rij = sqrt( r2ij );
                if ( e1 == nej && rij < rc )
                {
                    // Energy calculation.
                    // Calculate cutoff function and derivative.
                    compute_cutoff( cutoffType_, cutoffAlpha_, pfcij, pdfcij,
                                    rij, rc, true );
                    for ( size_t k = 0; k < size; ++k )
                    {
                        globalIndex = SF_(
                            attype, SFGmemberlist_( attype, groupIndex, k ),
                            14 );
                        memberindex = SFGmemberlist_( attype, groupIndex, k );
                        eta = SF_( attype, memberindex, 4 );
                        rs = SF_( attype, memberindex, 8 );
                        double pexp = exp( -eta * ( rij - rs ) * ( rij - rs ) );
                        // Force calculation.
                        double const p1 =
                            SFscaling_( attype, memberindex, 6 ) *
                            ( pdfcij - 2.0 * eta * ( rij - rs ) * pfcij ) *
                            pexp / rij;
                        f_a( i, 0 ) -= ( dEdG( i, globalIndex ) *
                                         ( p1 * dxij ) * CFFORCE * convForce_ );
                        f_a( i, 1 ) -= ( dEdG( i, globalIndex ) *
                                         ( p1 * dyij ) * CFFORCE * convForce_ );
                        f_a( i, 2 ) -= ( dEdG( i, globalIndex ) *
                                         ( p1 * dzij ) * CFFORCE * convForce_ );
 
                        f_a( j, 0 ) += ( dEdG( i, globalIndex ) *
                                         ( p1 * dxij ) * CFFORCE * convForce_ );
                        f_a( j, 1 ) += ( dEdG( i, globalIndex ) *
                                         ( p1 * dyij ) * CFFORCE * convForce_ );
                        f_a( j, 2 ) += ( dEdG( i, globalIndex ) *
                                         ( p1 * dzij ) * CFFORCE * convForce_ );
                    }
                }
            }
        }
    };
    Cabana::neighbor_parallel_for( policy, calc_radial_force_op, neigh_list,
                                   Cabana::FirstNeighborsTag(), neigh_op_tag,
                                   "Mode::calculateRadialForces" );
    Kokkos::fence();
 
    auto calc_angular_force_op =
        KOKKOS_LAMBDA( const int i, const int j, const int k )
    {
        double pfcij = 0.0;
        double pdfcij = 0.0;
        double pfcik, pdfcik, pfcjk, pdfcjk;
        size_t nej, nek;
        double rij, r2ij, rik, r2ik, rjk, r2jk;
        T_F_FLOAT dxij, dyij, dzij, dxik, dyik, dzik, dxjk, dyjk, dzjk;
        double eta, rs, lambda, zeta;
        int memberindex, globalIndex;
 
        int attype = type( i );
        for ( int groupIndex = 0; groupIndex < numSFGperElem_( attype );
              ++groupIndex )
        {
            if ( SF_( attype, SFGmemberlist_( attype, groupIndex, 0 ), 1 ) ==
                 3 )
            {
                size_t memberindex0 = SFGmemberlist_( attype, groupIndex, 0 );
                size_t e1 = SF_( attype, memberindex0, 2 );
                size_t e2 = SF_( attype, memberindex0, 3 );
                double rc = SF_( attype, memberindex0, 7 );
                size_t size =
                    SFGmemberlist_( attype, groupIndex, maxSFperElem_ );
 
                nej = type( j );
                dxij = ( x( i, 0 ) - x( j, 0 ) ) * CFLENGTH * convLength_;
                dyij = ( x( i, 1 ) - x( j, 1 ) ) * CFLENGTH * convLength_;
                dzij = ( x( i, 2 ) - x( j, 2 ) ) * CFLENGTH * convLength_;
                r2ij = dxij * dxij + dyij * dyij + dzij * dzij;
                rij = sqrt( r2ij );
                if ( ( e1 == nej || e2 == nej ) && rij < rc )
                {
                    // Calculate cutoff function and derivative.
                    compute_cutoff( cutoffType_, cutoffAlpha_, pfcij, pdfcij,
                                    rij, rc, true );
 
                    nek = type( k );
                    if ( ( e1 == nej && e2 == nek ) ||
                         ( e2 == nej && e1 == nek ) )
                    {
                        dxik =
                            ( x( i, 0 ) - x( k, 0 ) ) * CFLENGTH * convLength_;
                        dyik =
                            ( x( i, 1 ) - x( k, 1 ) ) * CFLENGTH * convLength_;
                        dzik =
                            ( x( i, 2 ) - x( k, 2 ) ) * CFLENGTH * convLength_;
                        r2ik = dxik * dxik + dyik * dyik + dzik * dzik;
                        rik = sqrt( r2ik );
                        if ( rik < rc )
                        {
                            dxjk = dxik - dxij;
                            dyjk = dyik - dyij;
                            dzjk = dzik - dzij;
                            r2jk = dxjk * dxjk + dyjk * dyjk + dzjk * dzjk;
                            if ( r2jk < rc * rc )
                            {
                                // Energy calculation.
                                compute_cutoff( cutoffType_, cutoffAlpha_,
                                                pfcik, pdfcik, rik, rc, true );
                                rjk = sqrt( r2jk );
 
                                compute_cutoff( cutoffType_, cutoffAlpha_,
                                                pfcjk, pdfcjk, rjk, rc, true );
 
                                double const rinvijik = 1.0 / rij / rik;
                                double const costijk =
                                    ( dxij * dxik + dyij * dyik +
                                      dzij * dzik ) *
                                    rinvijik;
                                double const pfc = pfcij * pfcik * pfcjk;
                                double const r2sum = r2ij + r2ik + r2jk;
                                double const pr1 = pfcik * pfcjk * pdfcij / rij;
                                double const pr2 = pfcij * pfcjk * pdfcik / rik;
                                double const pr3 = pfcij * pfcik * pdfcjk / rjk;
                                double vexp = 0.0, rijs = 0.0, riks = 0.0,
                                       rjks = 0.0;
                                for ( size_t l = 0; l < size; ++l )
                                {
                                    globalIndex =
                                        SF_( attype,
                                              SFGmemberlist_( attype,
                                                               groupIndex, l ),
                                              14 );
                                    memberindex = SFGmemberlist_(
                                        attype, groupIndex, l );
                                    rs = SF_( attype, memberindex, 8 );
                                    eta = SF_( attype, memberindex, 4 );
                                    lambda = SF_( attype, memberindex, 5 );
                                    zeta = SF_( attype, memberindex, 6 );
                                    if ( rs > 0.0 )
                                    {
                                        rijs = rij - rs;
                                        riks = rik - rs;
                                        rjks = rjk - rs;
                                        vexp = exp( -eta * ( rijs * rijs +
                                                             riks * riks +
                                                             rjks * rjks ) );
                                    }
                                    else
                                        vexp = exp( -eta * r2sum );
 
                                    double const plambda =
                                        1.0 + lambda * costijk;
                                    double fg = vexp;
                                    if ( plambda <= 0.0 )
                                        fg = 0.0;
                                    else
                                        fg *= pow( plambda, ( zeta - 1.0 ) );
 
                                    fg *= pow( 2, ( 1 - zeta ) ) *
                                          SFscaling_( attype, memberindex, 6 );
                                    double const pfczl = pfc * zeta * lambda;
                                    double factorDeriv =
                                        2.0 * eta / zeta / lambda;
                                    double const p2etapl =
                                        plambda * factorDeriv;
                                    double p1, p2, p3;
                                    if ( rs > 0.0 )
                                    {
                                        p1 = fg *
                                             ( pfczl *
                                                   ( rinvijik - costijk / r2ij -
                                                     p2etapl * rijs / rij ) +
                                               pr1 * plambda );
                                        p2 = fg *
                                             ( pfczl *
                                                   ( rinvijik - costijk / r2ik -
                                                     p2etapl * riks / rik ) +
                                               pr2 * plambda );
                                        p3 =
                                            fg *
                                            ( pfczl * ( rinvijik +
                                                        p2etapl * rjks / rjk ) -
                                              pr3 * plambda );
                                    }
                                    else
                                    {
                                        p1 = fg * ( pfczl * ( rinvijik -
                                                              costijk / r2ij -
                                                              p2etapl ) +
                                                    pr1 * plambda );
                                        p2 = fg * ( pfczl * ( rinvijik -
                                                              costijk / r2ik -
                                                              p2etapl ) +
                                                    pr2 * plambda );
                                        p3 = fg *
                                             ( pfczl * ( rinvijik + p2etapl ) -
                                               pr3 * plambda );
                                    }
                                    f_a( i, 0 ) -= ( dEdG( i, globalIndex ) *
                                                     ( p1 * dxij + p2 * dxik ) *
                                                     CFFORCE * convForce_ );
                                    f_a( i, 1 ) -= ( dEdG( i, globalIndex ) *
                                                     ( p1 * dyij + p2 * dyik ) *
                                                     CFFORCE * convForce_ );
                                    f_a( i, 2 ) -= ( dEdG( i, globalIndex ) *
                                                     ( p1 * dzij + p2 * dzik ) *
                                                     CFFORCE * convForce_ );
 
                                    f_a( j, 0 ) += ( dEdG( i, globalIndex ) *
                                                     ( p1 * dxij + p3 * dxjk ) *
                                                     CFFORCE * convForce_ );
                                    f_a( j, 1 ) += ( dEdG( i, globalIndex ) *
                                                     ( p1 * dyij + p3 * dyjk ) *
                                                     CFFORCE * convForce_ );
                                    f_a( j, 2 ) += ( dEdG( i, globalIndex ) *
                                                     ( p1 * dzij + p3 * dzjk ) *
                                                     CFFORCE * convForce_ );
 
                                    f_a( k, 0 ) += ( dEdG( i, globalIndex ) *
                                                     ( p2 * dxik - p3 * dxjk ) *
                                                     CFFORCE * convForce_ );
                                    f_a( k, 1 ) += ( dEdG( i, globalIndex ) *
                                                     ( p2 * dyik - p3 * dyjk ) *
                                                     CFFORCE * convForce_ );
                                    f_a( k, 2 ) += ( dEdG( i, globalIndex ) *
                                                     ( p2 * dzik - p3 * dzjk ) *
                                                     CFFORCE * convForce_ );
                                } // l
                            }     // rjk <= rc
                        }         // rik <= rc
                    }             // elem
                }                 // rij <= rc
            }
        }
    };
    Cabana::neighbor_parallel_for( policy, calc_angular_force_op, neigh_list,
                                   Cabana::SecondNeighborsTag(), angle_op_tag,
                                   "Mode::calculateAngularForces" );
    Kokkos::fence();
 
    return;
}

References CFFORCE, CFLENGTH, compute_cutoff(), convEnergy, convLength, cutoffAlpha, cutoffType, d_SF, d_SFGmemberlist, d_SFscaling, maxSFperElem, and numSFGperElem.

Here is the call graph for this function:

◆ calculateAtomicNeuralNetworks()

template<class t_device>

template<class t_slice_type, class t_slice_G, class t_slice_dEdG, class t_slice_E>

void nnp::ModeCabana< t_device >::calculateAtomicNeuralNetworks	(	t_slice_type	type,
		t_slice_G	G,
		t_slice_dEdG	dEdG,
		t_slice_E	E,
		int	N_local )

Calculate atomic neural networks for all atoms in given structure.

Parameters

[in]	type	Cabana slice of atom types.
[in]	G	Cabana slice of symmetry functions per atom.
[in]	dEdG	Cabana slice of the derivative of energy with respect to symmetry functions per atom.
[in]	E	Cabana slice of energy per atom.
[in]	N_local	Number of atoms.

The atomic energy is stored in E.

Definition at line 836 of file ModeCabana_impl.h.

{
    auto NN = d_t_NN( "Mode::NN", N_local, numLayers, maxNeurons );
    auto dfdx = d_t_NN( "Mode::dfdx", N_local, numLayers, maxNeurons );
    auto inner = d_t_NN( "Mode::inner", N_local, numHiddenLayers, maxNeurons );
    auto outer = d_t_NN( "Mode::outer", N_local, numHiddenLayers, maxNeurons );
 
    Kokkos::RangePolicy<exe_space> policy( 0, N_local );
 
    // Create local copies for lambda
    auto numSFperElem_ = numSFperElem;
    auto numNeuronsPerLayer_ = numNeuronsPerLayer;
    auto numLayers_ = numLayers;
    auto numHiddenLayers_ = numHiddenLayers;
    auto AF_ = AF;
    auto weights_ = weights;
    auto bias_ = bias;
 
    auto calc_nn_op = KOKKOS_LAMBDA( const int atomindex )
    {
        int attype = type( atomindex );
        // set input layer of NN
        int layer_0, layer_lminusone;
        layer_0 = (int)numSFperElem_( attype );
 
        for ( int k = 0; k < layer_0; ++k )
            NN( atomindex, 0, k ) = G( atomindex, k );
        // forward propagation
        for ( int l = 1; l < numLayers_; l++ )
        {
            if ( l == 1 )
                layer_lminusone = layer_0;
            else
                layer_lminusone = numNeuronsPerLayer_( l - 1 );
            double dtmp;
            for ( int i = 0; i < numNeuronsPerLayer_( l ); i++ )
            {
                dtmp = 0.0;
                for ( int j = 0; j < layer_lminusone; j++ )
                    dtmp += weights_( attype, l - 1, i, j ) *
                            NN( atomindex, l - 1, j );
                dtmp += bias_( attype, l - 1, i );
                if ( AF_( l ) == 0 )
                {
                    NN( atomindex, l, i ) = dtmp;
                    dfdx( atomindex, l, i ) = 1.0;
                }
                else if ( AF_( l ) == 1 )
                {
                    dtmp = tanh( dtmp );
                    NN( atomindex, l, i ) = dtmp;
                    dfdx( atomindex, l, i ) = 1.0 - dtmp * dtmp;
                }
            }
        }
 
        E( atomindex ) = NN( atomindex, numLayers_ - 1, 0 );
 
        // derivative of network w.r.t NN inputs
        for ( int k = 0; k < numNeuronsPerLayer_( 0 ); k++ )
        {
            for ( int i = 0; i < numNeuronsPerLayer_( 1 ); i++ )
                inner( atomindex, 0, i ) =
                    weights_( attype, 0, i, k ) * dfdx( atomindex, 1, i );
 
            for ( int l = 1; l < numHiddenLayers_ + 1; l++ )
            {
                for ( int i2 = 0; i2 < numNeuronsPerLayer_( l + 1 ); i2++ )
                {
                    outer( atomindex, l - 1, i2 ) = 0.0;
 
                    for ( int i1 = 0; i1 < numNeuronsPerLayer_( l ); i1++ )
                        outer( atomindex, l - 1, i2 ) +=
                            weights_( attype, l, i2, i1 ) *
                            inner( atomindex, l - 1, i1 );
                    outer( atomindex, l - 1, i2 ) *=
                        dfdx( atomindex, l + 1, i2 );
 
                    if ( l < numHiddenLayers_ )
                        inner( atomindex, l, i2 ) =
                            outer( atomindex, l - 1, i2 );
                }
            }
            dEdG( atomindex, k ) = outer( atomindex, numHiddenLayers_ - 1, 0 );
        }
    };
    Kokkos::parallel_for( "Mode::calculateAtomicNeuralNetworks", policy,
                          calc_nn_op );
    Kokkos::fence();
}

References AF, bias, maxNeurons, numHiddenLayers, numLayers, numNeuronsPerLayer, numSFperElem, and weights.

◆ calculateSymmetryFunctionGroups()

template<class t_device>

template<class t_slice_x, class t_slice_type, class t_slice_G, class t_neigh_list, class t_neigh_parallel, class t_angle_parallel>

void nnp::ModeCabana< t_device >::calculateSymmetryFunctionGroups	(	t_slice_x	x,
		t_slice_type	type,
		t_slice_G	G,
		t_neigh_list	neigh_list,
		int	N_local,
		t_neigh_parallel	neigh_op,
		t_angle_parallel	angle_op )

Calculate all symmetry function groups for all atoms in given structure.

Parameters

[in]	x	Cabana slice of atom positions.
[in]	type	Cabana slice of atom types.
[in]	G	Cabana slice of symmetry functions per atom.
[in]	neigh_list	Cabana neighbor list.
[in]	N_local	Number of atoms.
[in]	neigh_op	Cabana tag for neighbor parallelism.
[in]	angle_op	Cabana tag for angular parallelism.

Note there is no calculateSymmetryFunctions() within this derived class. Results are stored in G.

Definition at line 607 of file ModeCabana_impl.h.

{
    Cabana::deep_copy( G, 0.0 );
 
    Kokkos::RangePolicy<exe_space> policy( 0, N_local );
 
    // Create local copies for lambda
    auto numSFGperElem_ = numSFGperElem;
    auto SFGmemberlist_ = d_SFGmemberlist;
    auto SF_ = d_SF;
    auto SFscaling_ = d_SFscaling;
    auto maxSFperElem_ = maxSFperElem;
    auto convLength_ = convLength;
    auto cutoffType_ = cutoffType;
    auto cutoffAlpha_ = cutoffAlpha;
 
    auto calc_radial_symm_op = KOKKOS_LAMBDA( const int i, const int j )
    {
        double pfcij = 0.0;
        double pdfcij = 0.0;
        double eta, rs;
        size_t nej;
        int memberindex, globalIndex;
        double rij, r2ij;
        T_F_FLOAT dxij, dyij, dzij;
 
        int attype = type( i );
        for ( int groupIndex = 0; groupIndex < numSFGperElem_( attype );
              ++groupIndex )
        {
            if ( SF_( attype, SFGmemberlist_( attype, groupIndex, 0 ), 1 ) ==
                 2 )
            {
                size_t memberindex0 = SFGmemberlist_( attype, groupIndex, 0 );
                size_t e1 = SF_( attype, memberindex0, 2 );
                double rc = SF_( attype, memberindex0, 7 );
                size_t size =
                    SFGmemberlist_( attype, groupIndex, maxSFperElem_ );
 
                nej = type( j );
                dxij = ( x( i, 0 ) - x( j, 0 ) ) * CFLENGTH * convLength_;
                dyij = ( x( i, 1 ) - x( j, 1 ) ) * CFLENGTH * convLength_;
                dzij = ( x( i, 2 ) - x( j, 2 ) ) * CFLENGTH * convLength_;
                r2ij = dxij * dxij + dyij * dyij + dzij * dzij;
                rij = sqrt( r2ij );
                if ( e1 == nej && rij < rc )
                {
                    compute_cutoff( cutoffType_, cutoffAlpha_, pfcij, pdfcij,
                                    rij, rc, false );
                    for ( size_t k = 0; k < size; ++k )
                    {
                        memberindex = SFGmemberlist_( attype, groupIndex, k );
                        globalIndex = SF_( attype, memberindex, 14 );
                        eta = SF_( attype, memberindex, 4 );
                        rs = SF_( attype, memberindex, 8 );
                        G( i, globalIndex ) +=
                            exp( -eta * ( rij - rs ) * ( rij - rs ) ) * pfcij;
                    }
                }
            }
        }
    };
    Cabana::neighbor_parallel_for(
        policy, calc_radial_symm_op, neigh_list, Cabana::FirstNeighborsTag(),
        neigh_op_tag, "Mode::calculateRadialSymmetryFunctionGroups" );
    Kokkos::fence();
 
    auto calc_angular_symm_op =
        KOKKOS_LAMBDA( const int i, const int j, const int k )
    {
        double pfcij = 0.0, pdfcij = 0.0;
        double pfcik = 0.0, pdfcik = 0.0;
        double pfcjk = 0.0, pdfcjk = 0.0;
        size_t nej, nek;
        int memberindex, globalIndex;
        double rij, r2ij, rik, r2ik, rjk, r2jk;
        T_F_FLOAT dxij, dyij, dzij, dxik, dyik, dzik, dxjk, dyjk, dzjk;
        double eta, rs, lambda, zeta;
 
        int attype = type( i );
        for ( int groupIndex = 0; groupIndex < numSFGperElem_( attype );
              ++groupIndex )
        {
            if ( SF_( attype, SFGmemberlist_( attype, groupIndex, 0 ), 1 ) ==
                 3 )
            {
                size_t memberindex0 = SFGmemberlist_( attype, groupIndex, 0 );
                size_t e1 = SF_( attype, memberindex0, 2 );
                size_t e2 = SF_( attype, memberindex0, 3 );
                double rc = SF_( attype, memberindex0, 7 );
                size_t size =
                    SFGmemberlist_( attype, groupIndex, maxSFperElem_ );
 
                nej = type( j );
                dxij = ( x( i, 0 ) - x( j, 0 ) ) * CFLENGTH * convLength_;
                dyij = ( x( i, 1 ) - x( j, 1 ) ) * CFLENGTH * convLength_;
                dzij = ( x( i, 2 ) - x( j, 2 ) ) * CFLENGTH * convLength_;
                r2ij = dxij * dxij + dyij * dyij + dzij * dzij;
                rij = sqrt( r2ij );
                if ( ( e1 == nej || e2 == nej ) && rij < rc )
                {
                    // Calculate cutoff function and derivative.
                    compute_cutoff( cutoffType_, cutoffAlpha_, pfcij, pdfcij,
                                    rij, rc, false );
 
                    nek = type( k );
 
                    if ( ( e1 == nej && e2 == nek ) ||
                         ( e2 == nej && e1 == nek ) )
                    {
                        dxik =
                            ( x( i, 0 ) - x( k, 0 ) ) * CFLENGTH * convLength_;
                        dyik =
                            ( x( i, 1 ) - x( k, 1 ) ) * CFLENGTH * convLength_;
                        dzik =
                            ( x( i, 2 ) - x( k, 2 ) ) * CFLENGTH * convLength_;
                        r2ik = dxik * dxik + dyik * dyik + dzik * dzik;
                        rik = sqrt( r2ik );
                        if ( rik < rc )
                        {
                            dxjk = dxik - dxij;
                            dyjk = dyik - dyij;
                            dzjk = dzik - dzij;
                            r2jk = dxjk * dxjk + dyjk * dyjk + dzjk * dzjk;
                            if ( r2jk < rc * rc )
                            {
                                // Energy calculation.
                                compute_cutoff( cutoffType_, cutoffAlpha_,
                                                pfcik, pdfcik, rik, rc, false );
 
                                rjk = sqrt( r2jk );
                                compute_cutoff( cutoffType_, cutoffAlpha_,
                                                pfcjk, pdfcjk, rjk, rc, false );
 
                                double const rinvijik = 1.0 / rij / rik;
                                double const costijk =
                                    ( dxij * dxik + dyij * dyik +
                                      dzij * dzik ) *
                                    rinvijik;
                                double vexp = 0.0, rijs = 0.0, riks = 0.0,
                                       rjks = 0.0;
                                for ( size_t l = 0; l < size; ++l )
                                {
                                    globalIndex =
                                        SF_( attype,
                                              SFGmemberlist_( attype,
                                                               groupIndex, l ),
                                              14 );
                                    memberindex = SFGmemberlist_(
                                        attype, groupIndex, l );
                                    eta = SF_( attype, memberindex, 4 );
                                    lambda = SF_( attype, memberindex, 5 );
                                    zeta = SF_( attype, memberindex, 6 );
                                    rs = SF_( attype, memberindex, 8 );
                                    if ( rs > 0.0 )
                                    {
                                        rijs = rij - rs;
                                        riks = rik - rs;
                                        rjks = rjk - rs;
                                        vexp = exp( -eta * ( rijs * rijs +
                                                             riks * riks +
                                                             rjks * rjks ) );
                                    }
                                    else
                                        vexp = exp( -eta *
                                                    ( r2ij + r2ik + r2jk ) );
                                    double const plambda =
                                        1.0 + lambda * costijk;
                                    double fg = vexp;
                                    if ( plambda <= 0.0 )
                                        fg = 0.0;
                                    else
                                        fg *= pow( plambda, ( zeta - 1.0 ) );
                                    G( i, globalIndex ) +=
                                        fg * plambda * pfcij * pfcik * pfcjk;
                                } // l
                            }     // rjk <= rc
                        }         // rik <= rc
                    }             // elem
                }                 // rij <= rc
            }
        }
    };
    Cabana::neighbor_parallel_for(
        policy, calc_angular_symm_op, neigh_list, Cabana::SecondNeighborsTag(),
        angle_op_tag, "Mode::calculateAngularSymmetryFunctionGroups" );
    Kokkos::fence();
 
    auto scale_symm_op = KOKKOS_LAMBDA( const int i )
    {
        int attype = type( i );
 
        int memberindex0;
        int memberindex, globalIndex;
        double raw_value = 0.0;
        for ( int groupIndex = 0; groupIndex < numSFGperElem_( attype );
              ++groupIndex )
        {
            memberindex0 = SFGmemberlist_( attype, groupIndex, 0 );
 
            size_t size = SFGmemberlist_( attype, groupIndex, maxSFperElem_ );
            for ( size_t k = 0; k < size; ++k )
            {
                globalIndex = SF_(
                    attype, SFGmemberlist_( attype, groupIndex, k ), 14 );
                memberindex = SFGmemberlist_( attype, groupIndex, k );
 
                if ( SF_( attype, memberindex0, 1 ) == 2 )
                    raw_value = G( i, globalIndex );
                else if ( SF_( attype, memberindex0, 1 ) == 3 )
                    raw_value =
                        G( i, globalIndex ) *
                        pow( 2, ( 1 - SF_( attype, memberindex, 6 ) ) );
 
                G( i, globalIndex ) =
                    scale( attype, raw_value, memberindex, SFscaling_ );
            }
        }
    };
    Kokkos::parallel_for( "Mode::scaleSymmetryFunctionGroups", policy,
                          scale_symm_op );
    Kokkos::fence();
}

References CFLENGTH, compute_cutoff(), convLength, cutoffAlpha, cutoffType, d_SF, d_SFGmemberlist, d_SFscaling, maxSFperElem, numSFGperElem, and scale().

Here is the call graph for this function:

◆ Mode()

template<class t_device>

Mode::Mode ( )

Definition at line 106 of file Mode.cpp.

           : nnpType                   (NNPType::HDNNP_2G),
               normalize                 (false            ),
               checkExtrapolationWarnings(false            ),
               numElements               (0                ),
               maxCutoffRadius           (0.0              ),
               cutoffAlpha               (0.0              ),
               meanEnergy                (0.0              ),
               convEnergy                (1.0              ),
               convLength                (1.0              ),
               convCharge                (1.0              ),
               fourPiEps                 (1.0              ),
               ewaldSetup                {},
               kspaceGrid                {}
{
}

References log.

Member Data Documentation

◆ knownElements

template<class t_device>

std::vector<std::string> nnp::ModeCabana< t_device >::knownElements

Initial value:

= {
        "H",  "He", "Li", "Be", "B",  "C",  "N",  "O",  "F",  "Ne", "Na", "Mg",
        "Al", "Si", "P",  "S",  "Cl", "Ar", "K",  "Ca", "Sc", "Ti", "V",  "Cr",
        "Mn", "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br", "Kr",
        "Rb", "Sr", "Y",  "Zr", "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag", "Cd",
        "In", "Sn", "Sb", "Te", "I",  "Xe", "Cs", "Ba", "La", "Ce", "Pr", "Nd",
        "Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb", "Lu", "Hf",
        "Ta", "W",  "Re", "Os", "Ir", "Pt", "Au", "Hg", "Tl", "Pb", "Bi", "Po",
        "At", "Rn", "Fr", "Ra", "Ac", "Th", "Pa", "U",  "Np", "Pu", "Am", "Cm",
        "Bk", "Cf", "Es", "Fm", "Md", "No"}

list of element symbols in order of periodic table

Definition at line 226 of file ModeCabana.h.

                                         {
        "H",  "He", "Li", "Be", "B",  "C",  "N",  "O",  "F",  "Ne", "Na", "Mg",
        "Al", "Si", "P",  "S",  "Cl", "Ar", "K",  "Ca", "Sc", "Ti", "V",  "Cr",
        "Mn", "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br", "Kr",
        "Rb", "Sr", "Y",  "Zr", "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag", "Cd",
        "In", "Sn", "Sb", "Te", "I",  "Xe", "Cs", "Ba", "La", "Ce", "Pr", "Nd",
        "Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb", "Lu", "Hf",
        "Ta", "W",  "Re", "Os", "Ir", "Pt", "Au", "Hg", "Tl", "Pb", "Bi", "Po",
        "At", "Rn", "Fr", "Ra", "Ac", "Th", "Pa", "U",  "Np", "Pu", "Am", "Cm",
        "Bk", "Cf", "Es", "Fm", "Md", "No"};