Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F82648014
PerAtomQuantityLibrary.h
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Thu, Sep 12, 15:43
Size
43 KB
Mime Type
text/x-c
Expires
Sat, Sep 14, 15:43 (2 d)
Engine
blob
Format
Raw Data
Handle
20725980
Attached To
rLAMMPS lammps
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
Log In to Comment