Page MenuHomec4science
Files F92292030

PerAtomQuantityLibrary.h
No OneTemporary
Actions

File Metadata

Created
Tue, Nov 19, 03:35

PerAtomQuantityLibrary.h
View Options

// A library for defining various atomic quantities
#ifndef PER_ATOM_QUANTITY_LIBRARY_H
#define PER_ATOM_QUANTITY_LIBRARY_H
#include "PerAtomQuantity.h"
#include "FundamentalAtomicQuantity.h"
#include <set>
#include <map>
#include <vector>
#include <string>
namespace ATC {
// forward declarations
class LammpsInterface;
class FE_Mesh;
class FE_Engine;
template <class T> class DenseMatrixTransfer;
// need to add capability to take in group bit (JAT, 04/02/11)
/**
* @class AtomNumber
* @brief Class for identifying atoms based on a specified group
*/
class AtomNumber : public ProtectedAtomQuantity<double> {
public:
// constructor
AtomNumber(ATC_Method * atc, AtomType atomType = INTERNAL);
// destructor
virtual ~AtomNumber() {};
/** reset the quantity */
virtual void reset() const;
protected:
// int groupBit_;
ATC_Method * atc_;
private:
// do not define
AtomNumber();
};
/**
* @class AtomTypeVector
* @brief Class for identifying atoms based on a specified group
*/
class AtomTypeVector : public ProtectedAtomQuantity<double> {
public:
// constructor
AtomTypeVector(ATC_Method * atc, std::vector<int> typeList,
AtomType atomType = INTERNAL);
AtomTypeVector(ATC_Method * atc, std::vector<int> typeList, std::vector<int> grpList,
AtomType atomType = INTERNAL);
// destructor
virtual ~AtomTypeVector() {};
/** reset the quantity */
virtual void reset() const;
protected:
ATC_Method * atc_;
int ntypes_;
std::vector<int> typeList_,index_; // lammps->atc & atc->lammps
std::vector<int> groupList_;
private:
AtomTypeVector(); // do not define
};
// inherited classes are used for this task because
// lammps changes pointer location so it can only be
// accessed by functions
/**
* @class XrefWrapper
* @brief Class for wrapping the xref_ array
*/
class XrefWrapper : public ProtectedClonedAtomQuantity<double> {
public:
// constructor
XrefWrapper(ATC_Method * atc, AtomType atomType=INTERNAL);
// destructor
virtual ~XrefWrapper() {};
protected:
/** pointer to atc to access raw pointer */
ATC_Method * atc_;
/** gets appropriate pointer for lammps data */
double ** lammps_vector() const;
private:
// do not define
XrefWrapper();
};
/**
* @class AtomToElementMap
* @brief Class for identifying the element associated with an atom
*/
class AtomToElementMap : public ProtectedAtomQuantity<int> {
public:
// constructor
AtomToElementMap(ATC_Method * atc,
PerAtomQuantity<double> * atomPositions = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~AtomToElementMap();
protected:
/** resets the data if necessary */
virtual void reset() const;
/** atomic positions */
PerAtomQuantity<double> * atomPositions_;
private:
// do not define
AtomToElementMap();
};
/**
* @class AtomToElementMap
* @brief Class list of atoms in an element set
*/
class AtomInElementSet : public DependencyManager {
public:
// constructor
AtomInElementSet(ATC_Method * atc,
PerAtomQuantity<int> * map,
ESET eset, int type);
// destructor
virtual ~AtomInElementSet();
// accessors
virtual const ID_LIST & quantity();
virtual ID_LIST & set_quantity() {return list_;}
int size() {if (needReset_) reset(); return list_.size(); }
ID_PAIR item(int i) {if (needReset_) reset(); return list_[i]; }
protected:
/** resets the data if necessary */
virtual void reset();
PaqAtcUtility atc_;
/** atom to element map */
PerAtomQuantity<int> * map_;
ESET eset_;
int type_;
const Array<int> & quantityToLammps_;
ID_LIST list_;
private:
// do not define
AtomInElementSet();
};
/**
* @class AtomVolumeUser
* @brief Class for defining the volume per atom based on a user specification
*/
class AtomVolumeUser : public ProtectedAtomDiagonalMatrix<double> {
public:
// constructor
AtomVolumeUser(ATC_Method * atc,
std::map<int,double> & atomGroupVolume,
AtomType atomType = INTERNAL);
// destructor
virtual ~AtomVolumeUser() {};
protected:
/** resets the data if necessary */
virtual void reset() const;
/** reference to the map of atom group ids to atom volumes */
std::map<int,double> & atomGroupVolume_;
/** pointer to lammps interface */
const LammpsInterface * lammpsInterface_;
/** map from atc indices to lammps indices */
const Array<int> & atcToLammps_;
private:
// do not define
AtomVolumeUser();
};
/**
* @class AtomVolumeGroup
* @brief Class for defining the volume per atom based on the atom count in a group and its volume
*/
class AtomVolumeGroup : public AtomVolumeUser {
public:
// constructor
AtomVolumeGroup(ATC_Method * atc,
std::map<int,double> & atomGroupVolume,
AtomType atomType = INTERNAL);
// destructor
virtual ~AtomVolumeGroup() {};
protected:
/** map from group to group atom volume */
std::map<int,double> atomGroupVolume_;
/** pointer to lammps interface */
const LammpsInterface * lammpsInterface_;
/** reference to array mapping atc indices to lammps indices */
const Array<int> & atcToLammps_;
private:
// do not define
AtomVolumeGroup();
};
/**
* @class AtomVolumeLattice
* @brief Class for defining the volume per atom based on the lattice type and size
*/
class AtomVolumeLattice : public ProtectedAtomDiagonalMatrix<double> {
public:
// constructor
AtomVolumeLattice(ATC_Method * atc,
AtomType atomType = INTERNAL);
// destructor
virtual ~AtomVolumeLattice() {};
protected:
/** resets the data if necessary */
virtual void reset() const;
/** pointer to lammps interface */
const LammpsInterface * lammpsInterface_;
private:
// do not define
AtomVolumeLattice();
};
/**
* @class AtomVolumeElement
* @brief Class for defining the volume per atom based on the atom count per element and elemental volume
*/
class AtomVolumeElement : public ProtectedAtomDiagonalMatrix<double> {
public:
// constructor
AtomVolumeElement(ATC_Method * atc,
PerAtomQuantity<int> * atomElement = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~AtomVolumeElement();
protected:
/** resets the data if necessary */
virtual void reset() const;
/** pointer to the atom to element map */
PerAtomQuantity<int> * atomElement_;
/** pointer to lammps interface */
const LammpsInterface * lammpsInterface_;
/** pointer to mesh object */
const FE_Mesh * feMesh_;
// workspace variables
mutable INT_VECTOR _elementAtomCountLocal_;
mutable INT_VECTOR _elementAtomCount_;
mutable DENS_VEC _elementAtomVolume_;
mutable DENS_MAT _nodalCoordinates_;
private:
// do not define
AtomVolumeElement();
};
/**
* @class AtomVolumeRegion
* @brief Class for defining the volume per atom based on the atom count in the MD regions and their volumes.
* It will only be meaningful if atoms completely fill all the regions.
*/
class AtomVolumeRegion : public ProtectedAtomDiagonalMatrix<double> {
public:
// constructor
AtomVolumeRegion(ATC_Method * atc,
DENS_MAN * atomCoarseGrainingPositions = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~AtomVolumeRegion();
protected:
/** resets the data if necessary */
virtual void reset() const;
/** pointer to atomic coordinates data */
DENS_MAN * atomCoarseGrainingPositions_;
/** pointer to lammps interface */
const LammpsInterface * lammpsInterface_;
/** vector from region index to volume */
DENS_VEC regionalAtomVolume_;
private:
// do not define
AtomVolumeRegion();
};
/**
* @class AtomVolumeFile
* @brief Class for defining the volume per atom based on data read in from a file
*/
class AtomVolumeFile : public ProtectedAtomDiagonalMatrix<double> {
public:
// constructor
AtomVolumeFile(ATC_Method * atc,
const std::string & atomVolumeFile,
AtomType atomType = INTERNAL);
// destructor
virtual ~AtomVolumeFile() {};
protected:
/** resets the data if necessary */
virtual void reset() const;
/** file name containing the atomic information */
const std::string & atomVolumeFile_;
/** pointer to lammps interface */
const LammpsInterface * lammpsInterface_;
private:
// do not define
AtomVolumeFile();
};
/**
* @class AtomicMassWeightedDisplacement
* @brief Class for computing the precursor atomic quantity m*(x - x_ref)
*/
class AtomicMassWeightedDisplacement : public ProtectedAtomQuantity<double> {
public:
// constructor
AtomicMassWeightedDisplacement(ATC_Method * atc,
PerAtomQuantity<double> * atomPositions = NULL,
PerAtomQuantity<double> * atomMasses = NULL,
PerAtomQuantity<double> * atomReferencePositions = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~AtomicMassWeightedDisplacement();
protected:
/** handles resetting of data */
virtual void reset() const;
/** atomic positions */
PerAtomQuantity<double> * atomPositions_;
/** atomic masses */
PerAtomQuantity<double> * atomMasses_;
/** atomic reference positions */
PerAtomQuantity<double> * atomReferencePositions_;
private:
// do not define
AtomicMassWeightedDisplacement();
};
/**
* @class FluctuatingVelocity
* @brief Class for computing the atomic quantity v - bar{v}
*/
class FluctuatingVelocity : public ProtectedAtomQuantity<double> {
public:
// constructor
FluctuatingVelocity(ATC_Method * atc,
PerAtomQuantity<double> * atomVelocities = NULL,
PerAtomQuantity<double> * atomMeanVelocities = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~FluctuatingVelocity();
protected:
/** handles resetting of data */
virtual void reset() const;
/** atomic velocities */
PerAtomQuantity<double> * atomVelocities_;
/** atomic mean velocities */
PerAtomQuantity<double> * atomMeanVelocities_;
private:
// do not define
FluctuatingVelocity();
};
/**
* @class ChargeVelcity
* @brief Class for computing the atomic quantity q v'
*/
class ChargeVelocity : public ProtectedAtomQuantity<double> {
public:
// constructor
ChargeVelocity(ATC_Method * atc,
PerAtomQuantity<double> * fluctuatingVelocities = NULL,
FundamentalAtomQuantity * atomCharges = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~ChargeVelocity();
protected:
/** handles resetting of data */
virtual void reset() const;
/** atomic velocities */
PerAtomQuantity<double> * fluctuatingVelocities_;
/** atomic mean velocities */
FundamentalAtomQuantity * atomCharge_;
private:
// do not define
ChargeVelocity();
};
/**
* @class SpeciesVelcity
* @brief Class for computing the atomic quantity m^(a) v'
*/
class SpeciesVelocity : public ProtectedAtomQuantity<double> {
public:
// constructor
SpeciesVelocity(ATC_Method * atc,
PerAtomQuantity<double> * fluctuatingVelocities = NULL,
PerAtomQuantity<double> * atomTypeVector = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~SpeciesVelocity();
protected:
/** handles resetting of data */
virtual void reset() const;
/** atomic velocities */
PerAtomQuantity<double> * fluctuatingVelocities_;
/** atomic mean velocities */
PerAtomQuantity<double> * atomTypeVector_;
private:
// do not define
SpeciesVelocity();
};
/**
* @class AtomicMomentum
* @brief Class for computing the precursor atomic quantity m*v
*/
class AtomicMomentum : public ProtectedAtomQuantity<double> {
public:
// constructor
AtomicMomentum(ATC_Method * atc,
PerAtomQuantity<double> * atomVelocities = NULL,
PerAtomQuantity<double> * atomMasses = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~AtomicMomentum();
protected:
/** handles resetting of data */
virtual void reset() const;
/** atomic velocities */
PerAtomQuantity<double> * atomVelocities_;
/** atomic masses */
PerAtomQuantity<double> * atomMasses_;
private:
// do not define
AtomicMomentum();
};
/**
* @class AtomicEnergyForTemperature
* @brief Base class for accessing quantities needed for computing temperature
*/
class AtomicEnergyForTemperature : public ProtectedAtomQuantity<double> {
public:
// constructor
AtomicEnergyForTemperature(ATC_Method * atc,
AtomType atomType = INTERNAL)
: ProtectedAtomQuantity<double>(atc, 1, atomType) {};
// destructor
virtual ~AtomicEnergyForTemperature() {};
// returns coefficient which multiplies kinetic energy in temperature definition
virtual double kinetic_energy_multiplier() const = 0;
private:
// do not define
AtomicEnergyForTemperature();
};
/**
* @class TwiceKineticEnergy
* @brief Class for computing the precursor atomic quantity m*v*v
* (used when the kinetic definition of temperature is required)
*/
class TwiceKineticEnergy : public AtomicEnergyForTemperature {
public:
// constructor
TwiceKineticEnergy(ATC_Method * atc,
PerAtomQuantity<double> * atomVelocities = NULL,
PerAtomQuantity<double> * atomMasses = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~TwiceKineticEnergy();
// returns coefficient which multiplies kinetic energy in temperature definition
virtual double kinetic_energy_multiplier() const {return 2.;};
protected:
/** handles resetting of data */
virtual void reset() const;
/** atomic velocities */
PerAtomQuantity<double> * atomVelocities_;
/** atomic masses */
PerAtomQuantity<double> * atomMasses_;
private:
// do not define
TwiceKineticEnergy();
};
/**
* @class KineticTensor
* @brief Class for computing the atomic quantity m v (x) v
*/
class KineticTensor : public ProtectedAtomQuantity<double> {
public:
// constructor
KineticTensor(ATC_Method * atc,
PerAtomQuantity<double> * atomVelocities = NULL,
PerAtomQuantity<double> * atomMasses = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~KineticTensor();
protected:
/** handles resetting of data */
virtual void reset() const;
/** atomic velocities */
PerAtomQuantity<double> * atomVelocities_;
/** atomic masses */
PerAtomQuantity<double> * atomMasses_;
private:
// do not define
KineticTensor();
};
/**
* @class FluctuatingKineticTensor
* @brief Class for computing the atomic quantity m v (x) v
*/
class FluctuatingKineticTensor : public ProtectedAtomQuantity<double> {
public:
// constructor
FluctuatingKineticTensor(ATC_Method * atc,
PerAtomQuantity<double> * atomVelocities = NULL,
PerAtomQuantity<double> * atomMasses = NULL,
PerAtomQuantity<double> * atomMeanVelocities = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~FluctuatingKineticTensor();
protected:
/** handles resetting of data */
virtual void reset() const;
/** atomic velocities */
PerAtomQuantity<double> * atomVelocities_;
/** atomic masses */
PerAtomQuantity<double> * atomMasses_;
/** atomic mean velocities */
PerAtomQuantity<double> * atomMeanVelocities_;
private:
// do not define
FluctuatingKineticTensor();
};
/**
* @class TwiceFluctuatingKineticEnergy
* @brief Class for computing the precursor atomic quantity m*(v-vr)*(v-vr)
* (used when the kinetic definition of temperature is required)
*/
class TwiceFluctuatingKineticEnergy : public AtomicEnergyForTemperature {
public:
// constructor
TwiceFluctuatingKineticEnergy(ATC_Method * atc,
PerAtomQuantity<double> * atomVelocities = NULL,
PerAtomQuantity<double> * atomMasses = NULL,
PerAtomQuantity<double> * atomMeanVelocities = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~TwiceFluctuatingKineticEnergy();
// returns coefficient which multiplies kinetic energy in temperature definition
virtual double kinetic_energy_multiplier() const {return 2.;};
protected:
/** handles resetting of data */
virtual void reset() const;
/** atomic velocities */
PerAtomQuantity<double> * atomVelocities_;
/** atomic masses */
PerAtomQuantity<double> * atomMasses_;
/** atomic mean velocities */
PerAtomQuantity<double> * atomMeanVelocities_;
private:
// do not define
TwiceFluctuatingKineticEnergy();
};
/**
* @class MixedKePeEnergy
* @brief Class for computing the precursor atomic quantity for
* a mixed temperature definition involving both KE and PE
*/
class MixedKePeEnergy : public AtomicEnergyForTemperature {
public:
// constructor
MixedKePeEnergy(ATC_Method * atc,
double keMultiplier,
double peMultiplier,
PerAtomQuantity<double> * twiceKineticEnergy = NULL,
PerAtomQuantity<double> * potentialEnergy = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~MixedKePeEnergy();
// returns coefficient which multiplies kinetic energy in temperature definition
virtual double kinetic_energy_multiplier() const {return keMultiplier_;};
protected:
/** handles resetting of data */
virtual void reset() const;
/** factor multiplying kinetic energy */
double keMultiplier_;
/** factor multiplying potential energy */
double peMultiplier_;
/** twice the kinetic energy of each atom */
PerAtomQuantity<double> * twiceKineticEnergy_;
/** potential energy of each atom */
PerAtomQuantity<double> * potentialEnergy_;
private:
// do not define
MixedKePeEnergy();
};
/**
* @class TotalEnergy
* @brief Class for the atomic total energy
*/
class TotalEnergy : public ProtectedAtomQuantity<double> {
public:
// constructor
TotalEnergy(ATC_Method * atc,
PerAtomQuantity<double> * twiceKineticEnergy = NULL,
PerAtomQuantity<double> * potentialEnergy = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~TotalEnergy();
protected:
/** handles resetting of data */
virtual void reset() const;
/** twice the kinetic energy of each atom */
PerAtomQuantity<double> * twiceKineticEnergy_;
/** potential energy of each atom */
PerAtomQuantity<double> * potentialEnergy_;
private:
TotalEnergy(); // do not define
};
/**
* @class FluctuatingPotentialEnergy
* @brief Class for computing the precursor atomic quantity for
* a configurational (PE-based) temperature
*/
class FluctuatingPotentialEnergy : public AtomicEnergyForTemperature {
public:
// constructor
FluctuatingPotentialEnergy(ATC_Method * atc,
PerAtomQuantity<double> * potentialEnergy = NULL,
PerAtomQuantity<double> * referencePotential = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~FluctuatingPotentialEnergy();
// returns coefficient which multiplies kinetic energy in temperature definition
virtual double kinetic_energy_multiplier() const {return 0.;;};
protected:
/** handles resetting of data */
virtual void reset() const;
/** potential energy of each atom */
PerAtomQuantity<double> * potentialEnergy_;
/** twice the kinetic energy of each atom */
PerAtomQuantity<double> * referencePotential_;
private:
// do not define
FluctuatingPotentialEnergy();
};
/**
* @class DotTwiceKineticEnergy
* @brief Class for computing the precursor atomic power 2*v*f
* (used when the kinetic definition of temperature is required)
*/
class DotTwiceKineticEnergy : public ProtectedAtomQuantity<double> {
public:
// constructor
DotTwiceKineticEnergy(ATC_Method * atc,
PerAtomQuantity<double> * atomForces = NULL,
PerAtomQuantity<double> * atomVelocities = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~DotTwiceKineticEnergy();
protected:
/** handles resetting of data */
virtual void reset() const;
/** atomic forces */
PerAtomQuantity<double> * atomForces_;
/** atomic velocities */
PerAtomQuantity<double> * atomVelocities_;
private:
// do not define
DotTwiceKineticEnergy();
};
/**
* @class VelocitySquared
* @brief Class for computing the quantity |v|^2
* (used for weights in the thermostat)
*/
class VelocitySquared : public ProtectedAtomQuantity<double> {
public:
// constructor
VelocitySquared(ATC_Method *atc,
PerAtomQuantity<double> * atomVelocities = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~VelocitySquared();
protected:
/** handles resetting of data */
virtual void reset() const;
/** atomic velocities */
PerAtomQuantity<double> * atomVelocities_;
private:
// do not define
VelocitySquared();
};
/**
* @class LambdaSquared
* @brief Class for computing the 2nd order RHS fractional step
* contribution to the equation for lambda, with appropriate weights
*/
class LambdaSquared : public ProtectedAtomQuantity<double> {
public:
// constructor
LambdaSquared(ATC_Method *atc,
PerAtomQuantity<double> * atomMasses = NULL,
PerAtomQuantity<double> * atomVelocitiesSquared = NULL,
PerAtomQuantity<double> * atomLambdas = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~LambdaSquared();
protected:
/** handles resetting of data */
virtual void reset() const;
/** atomic masses */
PerAtomQuantity<double> * atomMasses_;
/** atomic velocities squared */
PerAtomQuantity<double> * atomVelocitiesSquared_;
/** atomic lambdas */
PerAtomQuantity<double> * atomLambdas_;
private:
// do not define
LambdaSquared();
};
/**
* @class LargeToSmallAtomMap
* @brief mapping from a larger set of atoms to a smaller set
* this implementation maximizes storage but reduces execution times,
* including taking advantage of MPI communcation
*/
class LargeToSmallAtomMap : public ProtectedAtomQuantity<int> {
public:
// constructor
LargeToSmallAtomMap(ATC_Method * atc,
AtomType atomType = INTERNAL)
: ProtectedAtomQuantity<int>(atc,1,atomType), size_(0) {};
// destructor
virtual ~LargeToSmallAtomMap() {};
/** change map when atoms change */
virtual void reset_nlocal() {this->set_reset();};
/** get the number of elements associated with the map */
virtual int size() const {this->quantity(); return size_;};
/** sets quantity to lammps data, if needed, should be called in pre_exchange */
virtual void prepare_exchange() {};
/** sets quantity to lammps data, if needed */
virtual void post_exchange() {this->set_reset();};
/** returns how much lammps memory is used in this function */
virtual int memory_usage() const {return 0;};
/** packs up data for parallel transfer when atoms change processors */
virtual int pack_exchange(int i, double *buffer) {return 0;};
/** unpacks data after parallel transfer when atoms change processors */
virtual int unpack_exchange(int i, double *buffer) {return 0;};
/** packs up data for parallel transfer to ghost atoms on other processors */
virtual int pack_comm(int index, double *buf,
int pbc_flag, int *pbc) {return 0;};
/** unpacks data after parallel transfer to ghost atoms on other processors */
virtual int unpack_comm(int index, double *buf) {return 0;};
/** returns size of per-atom communication */
virtual int size_comm() const {return 0;};
/** changes size of temperary lammps storage data if transfer is being used */
virtual void grow_lammps_array(int nmax, const std::string & tag) {};
/** rearrange memory of temporary lammps storage data, called from copy_array */
virtual void copy_lammps_array(int i, int j) {};
protected:
/** number of nodes in the map */
mutable int size_;
};
/**
* @class AtomToType
* @brief mapping from all atoms to the subset of atoms of a specified type
*/
class AtomToType : public LargeToSmallAtomMap {
public:
// constructor
AtomToType(ATC_Method * atc,
int type,
AtomType atomType = INTERNAL);
// destructor
virtual ~AtomToType() {};
protected:
/** handles resetting of data */
virtual void reset() const;
/** tag for type */
int type_;
private:
// do not define
AtomToType();
};
/**
* @class AtomToGroup
* @brief mapping from all atoms to the subset of atoms of a specified group
*/
class AtomToGroup : public LargeToSmallAtomMap {
public:
// constructor
AtomToGroup(ATC_Method * atc,
int group,
AtomType atomType = INTERNAL);
// destructor
virtual ~AtomToGroup() {};
protected:
/** handles resetting of data */
virtual void reset() const;
/** tag for group */
int group_;
private:
// do not define
AtomToGroup();
};
/**
* @class AtomToNodeset
* @brief mapping from all atoms to a subset of nodes
*/
class AtomToNodeset : public LargeToSmallAtomMap {
public:
// constructor
AtomToNodeset(ATC_Method * atc,
SetDependencyManager<int> * subsetNodes,
PerAtomQuantity<int> * atomElement = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~AtomToNodeset() {
atomElement_->remove_dependence(this);
subsetNodes_->remove_dependence(this);
};
protected:
/** handles resetting of data */
virtual void reset() const;
/** set of nodes which are being regulated */
SetDependencyManager<int> * subsetNodes_;
/** map from atom to element in which it resides */
PerAtomQuantity<int> * atomElement_;
/** pointer to the finite element engine */
const FE_Mesh * feMesh_;
// workspace
mutable Array<int> _nodes_; // nodes associated with an element
private:
// do not define
AtomToNodeset();
};
/**
* @class AtomToElementset
* @brief mapping from all atoms to a subset of elements
*/
class AtomToElementset : public LargeToSmallAtomMap {
public:
// constructor
AtomToElementset(ATC_Method * atc,
MatrixDependencyManager<DenseMatrix, bool> * elementMask,
PerAtomQuantity<int> * atomElement = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~AtomToElementset();
protected:
/** handles resetting of data */
virtual void reset() const;
/** set of nodes which are being regulated */
MatrixDependencyManager<DenseMatrix, bool> * elementMask_;
/** map from atom to element in which it resides */
PerAtomQuantity<int> * atomElement_;
/** pointer to the finite element engine */
const FE_Mesh * feMesh_;
private:
// do not define
AtomToElementset();
};
/**
* @class MappedAtomQuantity
* @brief generic reduced mapping
*/
class MappedAtomQuantity : public ProtectedMappedAtomQuantity<double> {
public:
// constructor
MappedAtomQuantity(ATC_Method * atc,
PerAtomQuantity<double> * source,
LargeToSmallAtomMap * map,
AtomType atomType = INTERNAL);
// destructor
virtual ~MappedAtomQuantity() {
source_->remove_dependence(this);
map_->remove_dependence(this);
};
protected:
/** handles resetting of data */
virtual void reset() const;
/** original quantity */
PerAtomQuantity<double> * source_;
/** mapping transfer */
LargeToSmallAtomMap * map_;
private:
// do not define
MappedAtomQuantity();
};
/**
* @class VelocitySquaredMapped
* @brief Class for computing the quantity |v|^2 on a subset of atoms
* (used for weights in the thermostat)
*/
class VelocitySquaredMapped : public ProtectedMappedAtomQuantity<double> {
public:
// constructor
VelocitySquaredMapped(ATC_Method *atc,
MatrixDependencyManager<DenseMatrix, int> * atomMap,
PerAtomQuantity<double> * atomVelocities = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~VelocitySquaredMapped();
protected:
/** handles resetting of data */
virtual void reset() const;
/** atomic velocities */
PerAtomQuantity<double> * atomVelocities_;
private:
// do not define
VelocitySquaredMapped();
};
/**
* @class LambdaSquaredMapped
* @brief Class for computing the 2nd order RHS fractional step
* contribution to the equation for lambda, with appropriate weights
*/
class LambdaSquaredMapped : public ProtectedMappedAtomQuantity<double> {
public:
// constructor
LambdaSquaredMapped(ATC_Method *atc,
MatrixDependencyManager<DenseMatrix, int> * atomMap,
PerAtomQuantity<double> * atomMasses = NULL,
PerAtomQuantity<double> * atomVelocitiesSquared = NULL,
PerAtomQuantity<double> * atomLambdas = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~LambdaSquaredMapped();
protected:
/** handles resetting of data */
virtual void reset() const;
/** atomic masses */
PerAtomQuantity<double> * atomMasses_;
/** atomic velocities squared */
PerAtomQuantity<double> * atomVelocitiesSquared_;
/** atomic lambdas */
PerAtomQuantity<double> * atomLambdas_;
private:
// do not define
LambdaSquaredMapped();
};
/**
* @class HeatCapacity
* @brief Class for the classical atomic heat capacity
*/
class HeatCapacity : public ConstantQuantity<double> {
public:
// constructor
HeatCapacity(ATC_Method * atc, AtomType atomType = INTERNAL);
// destructor
virtual ~HeatCapacity() {};
protected:
private:
// do not define
HeatCapacity();
};
/**
* @class AtomicVelocityRescaleFactor
* @brief Class for computing the atomic rescaling induced by the rescaling thermostat
*/
class AtomicVelocityRescaleFactor : public ProtectedAtomQuantity<double> {
public:
// constructor
AtomicVelocityRescaleFactor(ATC_Method * atc,
PerAtomQuantity<double> * atomLambdas = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~AtomicVelocityRescaleFactor();
protected:
/** handles resetting of data */
virtual void reset() const;
/** atomic lambdas */
PerAtomQuantity<double> * atomLambdas_;
private:
// do not define
AtomicVelocityRescaleFactor();
};
/**
* @class AtomicFluctuatingVelocityRescaled
* @brief Class for computing the atomic rescaling of the velocity fluctuations by the rescaling thermostat
*/
class AtomicFluctuatingVelocityRescaled : public ProtectedAtomQuantity<double> {
public:
// constructor
AtomicFluctuatingVelocityRescaled(ATC_Method * atc,
PerAtomQuantity<double> * atomRescaleFactor = NULL,
PerAtomQuantity<double> * atomFluctuatingVelocity = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~AtomicFluctuatingVelocityRescaled();
protected:
/** handles resetting of data */
virtual void reset() const;
/** atomic rescaling factor */
PerAtomQuantity<double> * atomRescaleFactor_;
/** atomic fluctuating velocity */
PerAtomQuantity<double> * atomFluctuatingVelocity_;
private:
// do not define
AtomicFluctuatingVelocityRescaled();
};
/**
* @class AtomicCombinedRescaleThermostatError
* @brief Class for computing the atomic error in the rescaling thermostat when used in combination with a specified streaming velocity
*/
class AtomicCombinedRescaleThermostatError : public ProtectedAtomQuantity<double> {
public:
// constructor
AtomicCombinedRescaleThermostatError(ATC_Method * atc,
PerAtomQuantity<double> * atomFluctuatingMomentumRescaled = NULL,
PerAtomQuantity<double> * atomMeanVelocity = NULL,
PerAtomQuantity<double> * atomStreamingVelocity = NULL,
PerAtomQuantity<double> * atomMass = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~AtomicCombinedRescaleThermostatError();
protected:
/** handles resetting of data */
virtual void reset() const;
/** atomic rescaled fluctuating momentum */
PerAtomQuantity<double> * atomFluctuatingMomentumRescaled_;
/** atomic mean (prolonged FE) velocity */
PerAtomQuantity<double> * atomMeanVelocity_;
/** atomic streaming velocity, as computed by rescaling kinetothermostat */
PerAtomQuantity<double> * atomStreamingVelocity_;
/** atomic masses */
PerAtomQuantity<double> * atomMass_;
private:
// do not define
AtomicCombinedRescaleThermostatError();
};
/**
* @class AtomicThermostatForce
* @brief Class for computing the atomic force induced by the GLC-based thermostats
*/
class AtomicThermostatForce : public ProtectedAtomQuantity<double> {
public:
// constructor
AtomicThermostatForce(ATC_Method * atc,
PerAtomQuantity<double> * atomLambdas = NULL,
PerAtomQuantity<double> * atomVelocities = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~AtomicThermostatForce();
protected:
/** handles resetting of data */
virtual void reset() const;
/** atomic lambdas */
PerAtomQuantity<double> * atomLambdas_;
/** atomic velocities */
PerAtomQuantity<double> * atomVelocities_;
private:
// do not define
AtomicThermostatForce();
};
/**
* @class AtomicKinetostatForceDisplacement
* @brief Class for computing the atomic force induced by the GLC-based kinetostats
*/
class AtomicKinetostatForceDisplacement : public ProtectedAtomQuantity<double> {
public:
// constructor
AtomicKinetostatForceDisplacement(ATC_Method * atc,
PerAtomQuantity<double> * atomLambda = NULL,
PerAtomQuantity<double> * atomMass = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~AtomicKinetostatForceDisplacement();
protected:
/** handles resetting of data */
virtual void reset() const;
/** computes the multiplication factor assocaited with the controlled quantity being an integral of the degrees of freedom */
virtual double time_step_factor(double dt) const {return 1./dt/dt;};
/** atomic lambdas */
PerAtomQuantity<double> * atomLambda_;
/** atomic velocities */
PerAtomQuantity<double> * atomMass_;
private:
// do not define
AtomicKinetostatForceDisplacement();
};
/**
* @class AtomicKinetostatForceVelocity
* @brief Class for computing the atomic force induced by the GLC-based kinetostats
*/
class AtomicKinetostatForceVelocity : public AtomicKinetostatForceDisplacement {
public:
// constructor
AtomicKinetostatForceVelocity(ATC_Method * atc,
PerAtomQuantity<double> * atomLambda = NULL,
PerAtomQuantity<double> * atomMass = NULL,
AtomType atomType = INTERNAL) :
AtomicKinetostatForceDisplacement(atc,atomLambda,atomMass,atomType) {};
// destructor
virtual ~AtomicKinetostatForceVelocity() {};
protected:
/** computes the multiplication factor assocaited with the controlled quantity being an integral of the degrees of freedom */
virtual double time_step_factor(double dt) const {return 1./dt;};
private:
// do not define
AtomicKinetostatForceVelocity();
};
/**
* @class AtomicKinetostatForceStress
* @brief Class for computing the atomic force induced by the stress-based kinetostats
*/
class AtomicKinetostatForceStress : public ProtectedAtomQuantity<double> {
public:
// constructor
AtomicKinetostatForceStress(ATC_Method * atc,
PerAtomQuantity<double> * atomLambda = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~AtomicKinetostatForceStress();
protected:
/** handles resetting of data */
virtual void reset() const;
/** atomic lambdas */
PerAtomQuantity<double> * atomLambda_;
private:
// do not define
AtomicKinetostatForceStress();
};
/**
* @class PerAtomKernelFunction
* @brief Class for computing the kernel function at each atom location
*/
class PerAtomKernelFunction : public ProtectedAtomSparseMatrix<double> {
public:
// constructor
PerAtomKernelFunction(ATC_Method * atc,
PerAtomQuantity<double> * atomPositions = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~PerAtomKernelFunction();
protected:
/** handles resetting of data */
virtual void reset() const;
/** atomic coarse-graining positions */
PerAtomQuantity<double> * atomPositions_;
/** finite element engine */
const FE_Engine * feEngine_;
private:
// do not define
PerAtomKernelFunction();
};
/**
* @class PerAtomShapeFunction
* @brief Class for computing the shape function at each atom location
*/
class PerAtomShapeFunction : public ProtectedAtomSparseMatrix<double> {
public:
// constructor
PerAtomShapeFunction(ATC_Method * atc,
PerAtomQuantity<double> * atomPositions = NULL,
PerAtomQuantity<int> * atomElements = NULL,
AtomType atomType = INTERNAL);
// destructor
virtual ~PerAtomShapeFunction();
protected:
/** handles resetting of data */
virtual void reset() const;
/** atomic coarse-graining positions */
PerAtomQuantity<double> * atomPositions_;
/** atom to element map */
PerAtomQuantity<int> * atomElements_;
/** finite element engine */
const FE_Engine * feEngine_;
private:
// do not define
PerAtomShapeFunction();
};
/**
* @class LambdaCouplingMatrix
* @brief constructs the coupling matrix needed to solve for lambda, i.e. N in N^T w N L = b
*/
class LambdaCouplingMatrix : public ProtectedMappedAtomSparseMatrix<double> {
public:
// constructor
LambdaCouplingMatrix(ATC_Method * atc,
MatrixDependencyManager<DenseMatrix, int> * nodeToOverlapMap = NULL,
SPAR_MAN * shapeFunction = NULL);
// destructor
virtual ~LambdaCouplingMatrix() {
shapeFunction_->remove_dependence(this);
nodeToOverlapMap_->remove_dependence(this);
};
protected:
/** does the actual computation of the quantity */
virtual void reset() const;
/** base shape function */
SPAR_MAN * shapeFunction_;
/** map from all nodes to regulated ones */
MatrixDependencyManager<DenseMatrix, int> * nodeToOverlapMap_;
private:
// do not define
LambdaCouplingMatrix();
};
/**
* @class LocalLambdaCouplingMatrix
* @brief constructs the coupling matrix needed to solve for lambda, i.e. N in N^T w N L = b
* when localization is being used for the constraint
*/
class LocalLambdaCouplingMatrix : public LambdaCouplingMatrix {
public:
// constructor
LocalLambdaCouplingMatrix(ATC_Method * atc,
MatrixDependencyManager<DenseMatrix, int> * lambdaAtomMap = NULL,
MatrixDependencyManager<DenseMatrix, int> * nodeToOverlapMap = NULL,
SPAR_MAN * shapeFunction = NULL);
// destructor
virtual ~LocalLambdaCouplingMatrix() {
lambdaAtomMap_->remove_dependence(this);
};
protected:
/** does the actual computation of the quantity */
virtual void reset() const;
/** map from all atoms to regulated ones */
MatrixDependencyManager<DenseMatrix, int> * lambdaAtomMap_;
private:
// do not define
LocalLambdaCouplingMatrix();
};
/**
* @class GhostCouplingMatrix
* @brief constructs the modified shape functions used to compute the total forces between ghost and internal atoms
*/
class GhostCouplingMatrix : public LambdaCouplingMatrix {
public:
// constructor
GhostCouplingMatrix(ATC_Method * atc,
SPAR_MAN * shapeFunction,
SetDependencyManager<int> * subsetNodes,
MatrixDependencyManager<DenseMatrix, int> * nodeToOverlapMap = NULL);
// destructor
virtual ~GhostCouplingMatrix() {
subsetNodes_->remove_dependence(this);
};
protected:
/** does the actual computation of the quantity */
virtual void reset() const;
/** set of nodes which are being regulated */
SetDependencyManager<int> * subsetNodes_;
// workspace
mutable DENS_VEC _activeNodes_; // nodes which are being regulated are 1, otherwise 0
mutable DENS_VEC _weights_; // required weighting for each shape function row to enforce partition of unity
mutable DIAG_MAT _weightMatrix_; // diagonal with necessary scaling for partition of unity
private:
// do not define
GhostCouplingMatrix();
};
}
#endif

Event Timeline

c4science · Help