Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F75354915
TransferLibrary.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, Aug 1, 19:15
Size
39 KB
Mime Type
text/x-c
Expires
Sat, Aug 3, 19:15 (1 d, 23 h)
Engine
blob
Format
Raw Data
Handle
19521077
Attached To
rLAMMPS lammps
TransferLibrary.h
View Options
// a library for the various transfer operators used in ATC
#ifndef TRANSFER_LIBRARY_H
#define TRANSFER_LIBRARY_H
#include <string>
#include <map>
#include <vector>
// ATC_Method headers
#include "TransferOperator.h"
namespace
ATC
{
// forward declarations
class
ATC_Method
;
class
ATC_Coupling
;
class
FE_Engine
;
class
FE_Mesh
;
class
PrescribedDataManager
;
class
LargeToSmallAtomMap
;
class
MoleculeSet
;
/**
* @class NodalAtomVolume
* @brief Computes the nodal volumes which coarse grain the volume per atom
*/
class
NodalAtomVolume
:
public
DenseMatrixTransfer
<
double
>
{
public:
// constructor
NodalAtomVolume
(
ATC_Method
*
atc
,
SPAR_MAN
*
shapeFunction
);
// destructor
virtual
~
NodalAtomVolume
()
{
shapeFunction_
->
remove_dependence
(
this
);};
/** apply transfer operator */
virtual
void
reset_quantity
()
const
;
/** overload function to get the number rows */
virtual
int
nRows
()
const
;
/** overload function to get the number columns */
virtual
int
nCols
()
const
;
protected:
/** applies the needed averaging operation to get the appropriate average volume */
virtual
double
averaging_operation
(
const
double
totalVolume
)
const
;
/** pointer to atc method object */
const
ATC_Method
*
atc_
;
/** shape function matrix used to base volumes on */
SPAR_MAN
*
shapeFunction_
;
/** pointer to lammps interface */
const
LammpsInterface
*
lammpsInterface_
;
/** pointer to the FE engine */
const
FE_Engine
*
feEngine_
;
/** tolerance used in the linear solver */
const
double
tol_
;
// workspace variables
mutable
DIAG_MAT
_rhsMatrix_
;
mutable
DENS_VEC
_rhs_
;
mutable
DENS_VEC
_scale_
;
private:
// do not define
NodalAtomVolume
();
};
/**
* @class NodalVolume
* @brief Computes the nodal volumes associated with the support of each nodal shape function
*/
class
NodalVolume
:
public
NodalAtomVolume
{
public:
// constructor
NodalVolume
(
ATC_Method
*
atc
,
SPAR_MAN
*
shapeFunction
)
:
NodalAtomVolume
(
atc
,
shapeFunction
)
{};
// destructor
virtual
~
NodalVolume
()
{};
protected:
/** applies the needed averaging operation to get the appropriate average volume */
virtual
double
averaging_operation
(
const
double
totalVolume
)
const
;
private:
// do not define
NodalVolume
();
};
/**
* @class NodalAtomVolumeElement
* @brief Computes the nodal volumes which coarse grain the volume per atom based on element volumes
*/
class
NodalAtomVolumeElement
:
public
DenseMatrixTransfer
<
double
>
{
public:
// constructor
NodalAtomVolumeElement
(
ATC_Method
*
atc
,
SPAR_MAN
*
shapeFunction
,
PerAtomQuantity
<
int
>
*
atomElement
=
NULL
);
// destructor
virtual
~
NodalAtomVolumeElement
()
{
shapeFunction_
->
remove_dependence
(
this
);
atomElement_
->
remove_dependence
(
this
);
};
/** apply transfer operator */
virtual
void
reset_quantity
()
const
;
/** overload function to get the number rows */
virtual
int
nRows
()
const
;
/** overload function to get the number columns */
virtual
int
nCols
()
const
;
protected:
/** pointer to atc method object */
ATC_Method
*
atc_
;
/** shape function matrix used to base volumes on */
SPAR_MAN
*
shapeFunction_
;
/** object containing the elements associated with each atom */
PerAtomQuantity
<
int
>
*
atomElement_
;
/** pointer to the FE engine */
const
FE_Engine
*
feEngine_
;
/** tolerance used in the linear solver */
const
double
tol_
;
// workspace variables
mutable
DIAG_MAT
_nodeVolumesMatrix_
;
mutable
DENS_VEC
_nodeVolumes_
;
mutable
DENS_VEC
_nodeElementVolumes_
;
mutable
DENS_MAT
_nodalCoords_
;
mutable
DENS_VEC
_scale_
;
private:
// do not define
NodalAtomVolumeElement
();
};
/**
* @class AtomTypeElement
* @brief determines if the given atom type is in each element
*/
class
AtomTypeElement
:
public
DenseMatrixTransfer
<
int
>
{
public:
// constructor
AtomTypeElement
(
ATC_Coupling
*
atc
,
PerAtomQuantity
<
int
>
*
atomElement
=
NULL
);
// destructor
virtual
~
AtomTypeElement
()
{
atomElement_
->
remove_dependence
(
this
);
};
/** apply transfer operator */
virtual
void
reset_quantity
()
const
;
protected:
/** map from atom to the element in which it resides */
PerAtomQuantity
<
int
>
*
atomElement_
;
/** number of element */
int
nElts_
;
// workspace
mutable
INT_ARRAY
_quantityLocal_
;
private:
// do not define
AtomTypeElement
();
};
/**
* @class ElementMask
* @brief determines which elements should be used for FE quadrature
*/
class
ElementMask
:
public
DenseMatrixTransfer
<
bool
>
{
public:
// constructor
ElementMask
(
ATC_Coupling
*
atc
,
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
hasInternal
=
NULL
,
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
hasGhost
=
NULL
);
// destructor
virtual
~
ElementMask
()
{
hasInternal_
->
remove_dependence
(
this
);
if
(
hasGhost_
)
hasGhost_
->
remove_dependence
(
this
);
};
/** apply transfer operator */
virtual
void
reset_quantity
()
const
;
protected:
/** shape function matrix over the internal atoms used to help define the geometry */
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
hasInternal_
;
/** shape function matrix over the ghost atoms used to help define the geometry */
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
hasGhost_
;
/** finite element engine */
const
FE_Engine
*
feEngine_
;
private:
// do not define
ElementMask
();
};
/**
* @class AtomElementMask
* @brief determines which elements should be used for FE quadrature based on presence of atoms
*/
class
AtomElementMask
:
public
DenseMatrixTransfer
<
bool
>
{
public:
// constructor
AtomElementMask
(
ATC_Coupling
*
atc
,
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
hasAtoms
=
NULL
);
// destructor
virtual
~
AtomElementMask
()
{
hasAtoms_
->
remove_dependence
(
this
);
};
/** apply transfer operator */
virtual
void
reset_quantity
()
const
;
protected:
/** shape function matrix over the atoms used to help define the geometry */
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
hasAtoms_
;
/** finite element engine */
const
FE_Engine
*
feEngine_
;
private:
// do not define
AtomElementMask
();
};
/**
* @class NodalGeometryType
* @brief Computes the computational geometry associated with each node with respect to the FE and MD regions
*/
class
NodalGeometryType
:
public
DenseMatrixTransfer
<
int
>
{
public:
// constructor
NodalGeometryType
(
ATC_Coupling
*
atc
,
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
hasInternal
=
NULL
,
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
hasGhost
=
NULL
);
// destructor
virtual
~
NodalGeometryType
()
{
hasInternal_
->
remove_dependence
(
this
);
if
(
hasGhost_
)
hasGhost_
->
remove_dependence
(
this
);
};
/** apply transfer operator */
virtual
void
reset_quantity
()
const
;
protected:
/** shape function matrix over the internal atoms used to help define the geometry */
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
hasInternal_
;
/** shape function matrix over the ghost atoms used to help define the geometry */
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
hasGhost_
;
/** finite element engine */
const
FE_Engine
*
feEngine_
;
/** number of nodes in the mesh */
int
nNodes_
;
/** number of elements in the mesh */
int
nElts_
;
// workspace
// ints so they can be shared through MPI
mutable
Array
<
int
>
_nodesInternal_
,
_nodesGhost_
;
private:
// do not define
NodalGeometryType
();
};
/**
* @class NodalGeometryTypeElementSet
* @brief Divdes nodes into MD, FE, and boundary based on if they are connected to nodes in internal and not internal
*/
class
NodalGeometryTypeElementSet
:
public
DenseMatrixTransfer
<
int
>
{
public:
// constructor
NodalGeometryTypeElementSet
(
ATC_Coupling
*
atc
,
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
hasInternal
=
NULL
);
// destructor
virtual
~
NodalGeometryTypeElementSet
()
{
hasInternal_
->
remove_dependence
(
this
);
};
/** apply transfer operator */
virtual
void
reset_quantity
()
const
;
protected:
/** shape function matrix over the internal atoms used to help define the geometry */
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
hasInternal_
;
/** finite element engine */
const
FE_Engine
*
feEngine_
;
/** number of nodes in the mesh */
int
nNodes_
;
/** number of elements in the mesh */
int
nElts_
;
// workspace
// ints so they can be shared through MPI
mutable
Array
<
int
>
_nodesInternal_
,
_nodesGhost_
;
private:
// do not define
NodalGeometryTypeElementSet
();
};
/**
* @class LargeToSmallMap
* @brief mapping from a larger set to a smaller set
*/
class
LargeToSmallMap
:
public
DenseMatrixTransfer
<
int
>
{
public:
// constructor
LargeToSmallMap
()
:
size_
(
0
)
{};
// destructor
virtual
~
LargeToSmallMap
()
{};
/** get the number of elements associated with the map */
virtual
int
size
()
const
{
this
->
quantity
();
return
size_
;};
protected:
/** number of nodes in the map */
mutable
int
size_
;
};
/**
* @class NodeToSubset
* @brief mapping from all nodes to a subset
*/
class
NodeToSubset
:
public
LargeToSmallMap
{
public:
// constructor
NodeToSubset
(
ATC_Method
*
atc
,
SetDependencyManager
<
int
>
*
subsetNodes
);
// destructor
virtual
~
NodeToSubset
()
{
subsetNodes_
->
remove_dependence
(
this
);
};
/** apply transfer operator */
virtual
void
reset_quantity
()
const
;
protected:
/** pointer to atc to get the number of nodes */
const
ATC_Method
*
atc_
;
/** map from atom to the element in which it resides */
SetDependencyManager
<
int
>
*
subsetNodes_
;
private:
// do not define
NodeToSubset
();
};
/**
* @class SubsetToNode
* @brief mapping from a subset of nodes to all nodes
*/
class
SubsetToNode
:
public
DenseMatrixTransfer
<
int
>
{
public:
// constructor
SubsetToNode
(
NodeToSubset
*
nodeToSubset
);
// destructor
virtual
~
SubsetToNode
()
{
nodeToSubset_
->
remove_dependence
(
this
);
};
/** apply transfer operator */
virtual
void
reset_quantity
()
const
;
protected:
/** map from atom to the element in which it resides */
NodeToSubset
*
nodeToSubset_
;
private:
// do not define
SubsetToNode
();
};
/**
* @class ReducedSparseMatrix
* @brief reduction of a sparse matrix to only those columns consistent with the map
*/
class
ReducedSparseMatrix
:
public
SparseMatrixTransfer
<
double
>
{
public:
// constructor
ReducedSparseMatrix
(
ATC_Method
*
atc
,
SPAR_MAN
*
source
,
LargeToSmallAtomMap
*
map
);
// destructor
virtual
~
ReducedSparseMatrix
();
/** apply transfer operator */
virtual
void
reset_quantity
()
const
;
protected:
/** original quantity */
SPAR_MAN
*
source_
;
/** mapping transfer */
LargeToSmallAtomMap
*
map_
;
// workspace
mutable
DenseVector
<
double
>
_row_
;
// vector storing the row values of a matrix
mutable
DenseVector
<
INDEX
>
_index_
;
// vector storing the column indices of the values
private:
// do not define
ReducedSparseMatrix
();
};
/**
* @class RowMappedSparseMatrix
* @brief mapping of rows from a sparse matrix to a new sparse matrix
*/
class
RowMappedSparseMatrix
:
public
ReducedSparseMatrix
{
public:
// constructor
RowMappedSparseMatrix
(
ATC_Method
*
atc
,
SPAR_MAN
*
source
,
LargeToSmallAtomMap
*
map
)
:
ReducedSparseMatrix
(
atc
,
source
,
map
)
{};
// destructor
virtual
~
RowMappedSparseMatrix
()
{};
/** apply transfer operator */
virtual
void
reset_quantity
()
const
;
protected:
private:
// do not define
RowMappedSparseMatrix
();
};
/**
* @class RowMappedSparseMatrixVector
* @brief mapping of rows from a vector sparse matrices to a new vector of sparse matrices
*/
class
RowMappedSparseMatrixVector
:
public
VectorTransfer
<
SPAR_MAT
*
>
{
public:
// constructor
RowMappedSparseMatrixVector
(
ATC_Method
*
atc
,
VectorDependencyManager
<
SPAR_MAT
*
>
*
source
,
LargeToSmallAtomMap
*
map
);
// destructor
virtual
~
RowMappedSparseMatrixVector
();
/** apply transfer operator */
virtual
void
reset_quantity
()
const
;
protected:
/** original quantity */
VectorDependencyManager
<
SPAR_MAT
*
>
*
source_
;
/** mapping transfer */
LargeToSmallAtomMap
*
map_
;
// workspace
mutable
DenseVector
<
double
>
_row_
;
// vector storing the row values of a matrix
mutable
DenseVector
<
INDEX
>
_index_
;
// vector storing the column indices of the values
private:
// do not define
RowMappedSparseMatrixVector
();
};
/**
* @class MappedDiagonalMatrix
* @brief mapping of a diagonal matrix to a new diagronal matrix
*/
class
MappedDiagonalMatrix
:
public
DiagonalMatrixTransfer
<
double
>
{
public:
// constructor
MappedDiagonalMatrix
(
ATC_Method
*
atc
,
DIAG_MAN
*
source
,
LargeToSmallAtomMap
*
map
);
// destructor
virtual
~
MappedDiagonalMatrix
();
/** apply transfer operator */
virtual
void
reset_quantity
()
const
;
protected:
/** original quantity */
DIAG_MAN
*
source_
;
/** mapping transfer */
LargeToSmallAtomMap
*
map_
;
private:
// do not define
MappedDiagonalMatrix
();
};
/**
* @class MappedQuantity
* @brief generic reduced mapping
*/
class
MappedQuantity
:
public
DenseMatrixTransfer
<
double
>
{
public:
// constructor
MappedQuantity
(
ATC_Method
*
atc
,
DENS_MAN
*
source
,
LargeToSmallMap
*
map
);
// destructor
virtual
~
MappedQuantity
()
{
source_
->
remove_dependence
(
this
);
map_
->
remove_dependence
(
this
);
};
/** apply transfer operator */
virtual
void
reset_quantity
()
const
;
protected:
/** original quantity */
DENS_MAN
*
source_
;
/** mapping transfer */
LargeToSmallMap
*
map_
;
private:
// do not define
MappedQuantity
();
};
/**
* @class RegulatedNodes
* @brief set of all nodes being controlled by an atomic regulator
*/
class
RegulatedNodes
:
public
SetTransfer
<
int
>
{
public:
// constructor
RegulatedNodes
(
ATC_Coupling
*
atc
,
FieldName
fieldName
=
NUM_TOTAL_FIELDS
,
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
nodalGeometryType
=
NULL
);
// destructor
virtual
~
RegulatedNodes
()
{
nodalGeometryType_
->
remove_dependence
(
this
);
};
protected:
/** recomputes the set of regulated nodes based on prescribed data and atom locations */
virtual
void
reset_quantity
()
const
;
/** map from fields to their sizes */
std
::
map
<
FieldName
,
int
>
fieldSizes_
;
/** map from atom to element in which it resides */
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
nodalGeometryType_
;
/** pointer to atc object */
ATC_Coupling
*
atc_
;
/** pointer to the finite element engine */
const
FE_Engine
*
feEngine_
;
/** pointer to the prescribed data manager */
const
PrescribedDataManager
*
prescribedDataManager_
;
// methods
/** adds boundary nodes */
void
insert_boundary_nodes
()
const
;
/** adds nodes associated with boundary facesets */
void
insert_boundary_faces
()
const
;
/** adds fixed nodes */
void
insert_fixed_nodes
()
const
;
/** adds nodes associated with face fluxes */
void
insert_face_fluxes
()
const
;
/** adds nodes associated with element fluxes */
void
insert_element_fluxes
()
const
;
private:
// do not define
RegulatedNodes
();
};
/**
* @class FluxNodes
* @brief set of all nodes being controlled by an atomic regulator for fluxes
*/
class
FluxNodes
:
public
RegulatedNodes
{
public:
// constructor
FluxNodes
(
ATC_Coupling
*
atc
,
FieldName
fieldName
=
NUM_TOTAL_FIELDS
,
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
nodalGeometryType
=
NULL
)
:
RegulatedNodes
(
atc
,
fieldName
,
nodalGeometryType
)
{};
// destructor
virtual
~
FluxNodes
()
{};
protected:
/** recomputes the set of regulated nodes based on prescribed data and atom locations */
virtual
void
reset_quantity
()
const
;
private:
// do not define
FluxNodes
();
};
/**
* @class BoundaryNodes
* @brief set of all nodes associated with the FE/MD boundary
*/
class
BoundaryNodes
:
public
RegulatedNodes
{
public:
// constructor
BoundaryNodes
(
ATC_Coupling
*
atc
,
FieldName
fieldName
=
NUM_TOTAL_FIELDS
,
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
nodalGeometryType
=
NULL
)
:
RegulatedNodes
(
atc
,
fieldName
,
nodalGeometryType
)
{};
// destructor
virtual
~
BoundaryNodes
()
{};
protected:
/** recomputes the set of regulated nodes based on prescribed data and atom locations */
virtual
void
reset_quantity
()
const
;
private:
// do not define
BoundaryNodes
();
};
/**
* @class FluxBoundaryNodes
* @brief set of all nodes being controlled by an atomic regulator for fluxes
*/
class
FluxBoundaryNodes
:
public
FluxNodes
{
public:
// constructor
FluxBoundaryNodes
(
ATC_Coupling
*
atc
,
FieldName
fieldName
=
NUM_TOTAL_FIELDS
,
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
nodalGeometryType
=
NULL
)
:
FluxNodes
(
atc
,
fieldName
,
nodalGeometryType
)
{};
// destructor
virtual
~
FluxBoundaryNodes
()
{};
protected:
/** recomputes the set of regulated nodes based on prescribed data and atom locations */
virtual
void
reset_quantity
()
const
;
private:
// do not define
FluxBoundaryNodes
();
};
/**
* @class AllRegulatedNodes
* @brief set of all nodes being controlled by an atomic regulator when localization is used
*/
class
AllRegulatedNodes
:
public
FluxBoundaryNodes
{
public:
// constructor
AllRegulatedNodes
(
ATC_Coupling
*
atc
,
FieldName
fieldName
=
NUM_TOTAL_FIELDS
,
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
nodalGeometryType
=
NULL
)
:
FluxBoundaryNodes
(
atc
,
fieldName
,
nodalGeometryType
)
{};
// destructor
virtual
~
AllRegulatedNodes
()
{};
protected:
/** recomputes the set of regulated nodes based on prescribed data and atom locations */
virtual
void
reset_quantity
()
const
;
private:
// do not define
AllRegulatedNodes
();
};
/**
* @class FixedNodes
* @brief set of all nodes being controlled by an atomic regulator which are fixed
*/
class
FixedNodes
:
public
RegulatedNodes
{
public:
// constructor
FixedNodes
(
ATC_Coupling
*
atc
,
FieldName
fieldName
=
NUM_TOTAL_FIELDS
,
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
nodalGeometryType
=
NULL
)
:
RegulatedNodes
(
atc
,
fieldName
,
nodalGeometryType
)
{};
// destructor
virtual
~
FixedNodes
()
{};
protected:
/** recomputes the set of regulated nodes based on prescribed data and atom locations */
virtual
void
reset_quantity
()
const
;
private:
// do not define
FixedNodes
();
};
/**
* @class FixedBoundaryNodes
* @brief set of all nodes being controlled by an atomic regulator which are fixed, including for coupling
*/
class
FixedBoundaryNodes
:
public
FixedNodes
{
public:
// constructor
FixedBoundaryNodes
(
ATC_Coupling
*
atc
,
FieldName
fieldName
=
NUM_TOTAL_FIELDS
,
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
nodalGeometryType
=
NULL
)
:
FixedNodes
(
atc
,
fieldName
,
nodalGeometryType
)
{};
// destructor
virtual
~
FixedBoundaryNodes
()
{};
protected:
/** recomputes the set of regulated nodes based on prescribed data and atom locations */
virtual
void
reset_quantity
()
const
;
private:
// do not define
FixedBoundaryNodes
();
};
/**
* @class ElementMaskNodeSet
* @brief determines which elements should be used for FE quadrature based on them possessing certain nodes
*/
class
ElementMaskNodeSet
:
public
DenseMatrixTransfer
<
bool
>
{
public:
// constructor
ElementMaskNodeSet
(
ATC_Coupling
*
atc
,
SetDependencyManager
<
int
>
*
nodeSet
);
// destructor
virtual
~
ElementMaskNodeSet
()
{
nodeSet_
->
remove_dependence
(
this
);
};
/** apply transfer operator */
virtual
void
reset_quantity
()
const
;
protected:
/** transfer determining used nodes */
SetDependencyManager
<
int
>
*
nodeSet_
;
/** finite element mesh */
const
FE_Mesh
*
feMesh_
;
private:
// do not define
ElementMaskNodeSet
();
};
/**
* @class PointToElementMap
* @brief Class for identifying the element associated with a given point
*/
class
PointToElementMap
:
public
DenseMatrixTransfer
<
int
>
{
public:
// constructor
PointToElementMap
(
ATC_Method
*
atc
,
MatrixDependencyManager
<
DenseMatrix
,
double
>
*
pointPositions
);
// destructor
virtual
~
PointToElementMap
();
protected:
/** resets the data if necessary */
virtual
void
reset_quantity
()
const
;
/** point positions */
MatrixDependencyManager
<
DenseMatrix
,
double
>
*
pointPositions_
;
/** pointer to finite element mesh */
const
FE_Mesh
*
feMesh_
;
private:
// do not define
PointToElementMap
();
};
/**
* @class Interpolant
* @brief constructs the spatial values of the shape functions
*/
class
Interpolant
:
public
SparseMatrixTransfer
<
double
>
{
public:
// constructor
Interpolant
(
ATC_Method
*
atc
,
MatrixDependencyManager
<
DenseMatrix
,
int
>*
pointToElementMap
,
DENS_MAN
*
pointPositions
);
// destructor
virtual
~
Interpolant
()
{
pointToElementMap_
->
remove_dependence
(
this
);
pointPositions_
->
remove_dependence
(
this
);
};
protected:
/** does the actual computation of the quantity */
virtual
void
reset_quantity
()
const
;
protected:
/** map from point coordinates to element */
MatrixDependencyManager
<
DenseMatrix
,
int
>*
pointToElementMap_
;
/** coordinates used to evaluate shape functions */
DENS_MAN
*
pointPositions_
;
/** pointer to the FE engine */
const
FE_Engine
*
feEngine_
;
private:
// do not define
Interpolant
();
};
/**
* @class InterpolantGradient
* @brief constructs the spatial derivatives of the shape functions
*/
class
InterpolantGradient
:
public
VectorTransfer
<
SPAR_MAT
*
>
{
public:
// constructor
InterpolantGradient
(
ATC_Method
*
atc
,
MatrixDependencyManager
<
DenseMatrix
,
int
>*
pointToElementMap
,
DENS_MAN
*
pointPositions
);
// destructor
virtual
~
InterpolantGradient
();
protected:
/** does the actual computation of the quantity */
virtual
void
reset_quantity
()
const
;
protected:
/** map from point coordinates to element */
MatrixDependencyManager
<
DenseMatrix
,
int
>*
pointToElementMap_
;
/** coordinates used to evaluate shape functions */
DENS_MAN
*
pointPositions_
;
/** pointer to the FE engine */
const
FE_Engine
*
feEngine_
;
private:
// do not define
InterpolantGradient
();
};
/**
* @class PerAtomShapeFunctionGradient
* @brief constructs the spatial derivatives of the shape functions at each atom
*/
class
PerAtomShapeFunctionGradient
:
public
VectorTransfer
<
SPAR_MAT
*
>
{
public:
// constructor
PerAtomShapeFunctionGradient
(
ATC_Method
*
atc
,
MatrixDependencyManager
<
DenseMatrix
,
int
>*
atomToElementMap
=
NULL
,
DENS_MAN
*
atomPositions
=
NULL
,
const
std
::
string
&
tag
=
"AtomicShapeFunctionGradient"
,
AtomType
atomType
=
INTERNAL
);
// destructor
virtual
~
PerAtomShapeFunctionGradient
();
protected:
/** does the actual computation of the quantity */
virtual
void
reset_quantity
()
const
;
protected:
/** map from point coordinates to element */
MatrixDependencyManager
<
DenseMatrix
,
int
>*
atomToElementMap_
;
/** coordinates used to evaluate shape functions */
DENS_MAN
*
atomPositions_
;
/** pointer to the FE engine */
const
FE_Engine
*
feEngine_
;
/** container for dependency managers */
std
::
vector
<
AtcAtomSparseMatrix
<
double
>
*
>
matrices_
;
private:
// do not define
PerAtomShapeFunctionGradient
();
};
/**
* @class InterpolantSmallMolecule
* @brief constructs the spatial values of the shape functions for small molecules
*/
class
InterpolantSmallMolecule
:
public
Interpolant
{
public:
// constructor
InterpolantSmallMolecule
(
ATC_Method
*
atc
,
MatrixDependencyManager
<
DenseMatrix
,
int
>*
moleculeToElementMap
,
DENS_MAN
*
moleculePositions
,
MoleculeSet
*
moleculeSet
);
// destructor
virtual
~
InterpolantSmallMolecule
();
protected:
/** does the actual computation of the quantity */
virtual
void
reset_quantity
()
const
;
protected:
/** pointer to atc base class */
MoleculeSet
*
moleculeSet_
;
// workspace
mutable
DENS_VEC
_fractions_
;
private:
// do not define
InterpolantSmallMolecule
();
};
/**
* @class DenseMatrixQuotient
* @brief quotient of two matrices
*/
class
DenseMatrixQuotient
:
public
DenseMatrixTransfer
<
double
>
{
public:
// constructor
DenseMatrixQuotient
(
DENS_MAN
*
matrixNumerator
,
DENS_MAN
*
matrixDenominator
);
// destructor
virtual
~
DenseMatrixQuotient
()
{
matrixNumerator_
->
remove_dependence
(
this
);
matrixDenominator_
->
remove_dependence
(
this
);
};
/** apply transfer operator */
virtual
void
reset_quantity
()
const
;
/** get number of columns */
virtual
int
nCols
()
const
{
return
matrixNumerator_
->
nCols
();};
protected:
DENS_MAN
*
matrixNumerator_
;
DENS_MAN
*
matrixDenominator_
;
private:
// do not define
DenseMatrixQuotient
();
};
/**
* @class DenseMatrixSum
* @brief sum of two matrices
*/
class
DenseMatrixSum
:
public
DenseMatrixTransfer
<
double
>
{
public:
// constructor
DenseMatrixSum
(
DENS_MAN
*
matrixOne
,
DENS_MAN
*
matrixTwo
);
// destructor
virtual
~
DenseMatrixSum
()
{
matrixOne_
->
remove_dependence
(
this
);
matrixTwo_
->
remove_dependence
(
this
);
};
/** apply transfer operator */
virtual
void
reset_quantity
()
const
;
/** get number of columns */
virtual
int
nCols
()
const
{
return
matrixOne_
->
nCols
();};
protected:
DENS_MAN
*
matrixOne_
;
DENS_MAN
*
matrixTwo_
;
private:
// do not define
DenseMatrixSum
();
};
/**
* @class DenseMatrixDelta
* @brief change relative to a reference value
*/
class
DenseMatrixDelta
:
public
DenseMatrixTransfer
<
double
>
{
public:
// constructor
DenseMatrixDelta
(
DENS_MAN
*
current
,
DENS_MAT
*
reference
);
// destructor
virtual
~
DenseMatrixDelta
()
{
matrix_
->
remove_dependence
(
this
);
};
/** apply transfer operator */
virtual
void
reset_quantity
()
const
;
protected:
DENS_MAN
*
matrix_
;
DENS_MAT
*
reference_
;
private:
// do not define
DenseMatrixDelta
();
};
/**
* @class OnTheFlyKernelAccumulation
* @brief implements the accumulant on the fly
*/
class
OnTheFlyKernelAccumulation
:
public
DenseMatrixTransfer
<
double
>
{
public:
// constructor
OnTheFlyKernelAccumulation
(
ATC_Method
*
atc
,
PerAtomQuantity
<
double
>
*
source
,
KernelFunction
*
kernelFunction
,
DENS_MAN
*
atomCoarseGrainingPositions
);
// destructor
virtual
~
OnTheFlyKernelAccumulation
()
{
source_
->
remove_dependence
(
this
);
atomCoarseGrainingPositions_
->
remove_dependence
(
this
);
};
/** do nothing */
virtual
void
reset_quantity
()
const
;
protected:
/** pointer to atc base class */
const
ATC_Method
*
atc_
;
/** pointer to source data */
PerAtomQuantity
<
double
>
*
source_
;
/** map from atom coordinates to element */
KernelFunction
*
kernelFunction_
;
/** atomic coordinates used for coarse graining operations */
DENS_MAN
*
atomCoarseGrainingPositions_
;
/** access to mesh */
const
FE_Mesh
*
feMesh_
;
// workspace
mutable
DENS_MAT
_quantityLocal_
;
private:
// do not define
OnTheFlyKernelAccumulation
();
};
/**
* @class OnTheFlyKernelAccumulationNormalized
* @brief implements a normalized accumulant on the fly
*/
class
OnTheFlyKernelAccumulationNormalized
:
public
OnTheFlyKernelAccumulation
{
public:
// constructor
OnTheFlyKernelAccumulationNormalized
(
ATC_Method
*
atc
,
PerAtomQuantity
<
double
>
*
source
,
KernelFunction
*
kernelFunction
,
DENS_MAN
*
atomCoarseGrainingPositions
,
DIAG_MAN
*
weights
);
// destructor
virtual
~
OnTheFlyKernelAccumulationNormalized
()
{
weights_
->
remove_dependence
(
this
);
};
/** do nothing */
virtual
void
reset_quantity
()
const
;
protected:
DIAG_MAN
*
weights_
;
private:
// do not define
OnTheFlyKernelAccumulationNormalized
();
};
/**
* @class OnTheFlyKernelAccumulationNormalizedReferenced
* @brief implements a normalized referenced accumulant on the fly
*/
class
OnTheFlyKernelAccumulationNormalizedReferenced
:
public
OnTheFlyKernelAccumulationNormalized
{
public:
// constructor
OnTheFlyKernelAccumulationNormalizedReferenced
(
ATC_Method
*
atc
,
PerAtomQuantity
<
double
>
*
source
,
KernelFunction
*
kernelFunction
,
DENS_MAN
*
atomCoarseGrainingPositions
,
DIAG_MAN
*
weights
,
DENS_MAN
*
reference
);
// destructor
virtual
~
OnTheFlyKernelAccumulationNormalizedReferenced
()
{
reference_
->
remove_dependence
(
this
);
};
/** do nothing */
virtual
void
reset_quantity
()
const
;
protected:
/** reference value */
DENS_MAN
*
reference_
;
private:
// do not define
OnTheFlyKernelAccumulationNormalizedReferenced
();
};
/**
* @class OnTheFlyKernelNormalizedAccumulationScaled
* @brief implements a scaled accumulant on the fly
*/
class
OnTheFlyKernelAccumulationNormalizedScaled
:
public
OnTheFlyKernelAccumulationNormalized
{
public:
// constructor
OnTheFlyKernelAccumulationNormalizedScaled
(
ATC_Method
*
atc
,
PerAtomQuantity
<
double
>
*
source
,
KernelFunction
*
kernelFunction
,
DENS_MAN
*
atomCoarseGrainingPositions
,
DIAG_MAN
*
weights
,
const
double
scale
);
// destructor
virtual
~
OnTheFlyKernelAccumulationNormalizedScaled
()
{
atomCoarseGrainingPositions_
->
remove_dependence
(
this
);
};
/** do nothing */
virtual
void
reset_quantity
()
const
;
protected:
const
double
scale_
;
private:
// do not define
OnTheFlyKernelAccumulationNormalizedScaled
();
};
/**
* @class AccumulantWeights
* @brief weights for kernel function accumulants
*/
class
AccumulantWeights
:
public
DiagonalMatrixTransfer
<
double
>
{
public:
// constructor
AccumulantWeights
(
SPAR_MAN
*
accumulant
);
// destructor
virtual
~
AccumulantWeights
()
{
accumulant_
->
remove_dependence
(
this
);
};
/** apply transfer operator */
virtual
void
reset_quantity
()
const
;
protected:
SPAR_MAN
*
accumulant_
;
// workspace
mutable
DENS_VEC
_localWeights_
;
mutable
DENS_VEC
_weights_
;
private:
// do not define
AccumulantWeights
();
};
/**
* @class OnTheFlyKernelWeights
* @brief weights for on-the-fly kernel function
*/
class
OnTheFlyKernelWeights
:
public
DiagonalMatrixTransfer
<
double
>
{
public:
// constructor
OnTheFlyKernelWeights
(
DENS_MAN
*
weights
);
// destructor
virtual
~
OnTheFlyKernelWeights
()
{
weights_
->
remove_dependence
(
this
);
};
/** apply transfer operator */
virtual
void
reset_quantity
()
const
;
protected:
DENS_MAN
*
weights_
;
private:
// do not define
OnTheFlyKernelWeights
();
};
/**
* @class KernelInverseVolumes
* @brief inverse volumes for kernel function accumulants
*/
class
KernelInverseVolumes
:
public
DiagonalMatrixTransfer
<
double
>
{
public:
// constructor
KernelInverseVolumes
(
ATC_Method
*
atc
,
KernelFunction
*
kernelFunction
);
// destructor
virtual
~
KernelInverseVolumes
()
{};
/** apply transfer operator */
virtual
void
reset_quantity
()
const
;
protected:
/** kernel function being used */
KernelFunction
*
kernelFunction_
;
/** access to mesh */
const
FE_Mesh
*
feMesh_
;
private:
// do not define
KernelInverseVolumes
();
};
/**
* @class OnTheFlyMeshAccumulation
* @brief implements the mesh-based accumulant on the fly
*/
class
OnTheFlyMeshAccumulation
:
public
DenseMatrixTransfer
<
double
>
{
public:
// constructor
OnTheFlyMeshAccumulation
(
ATC_Method
*
atc
,
PerAtomQuantity
<
double
>
*
source
,
DENS_MAN
*
atomCoarseGrainingPositions
);
// destructor
virtual
~
OnTheFlyMeshAccumulation
()
{
source_
->
remove_dependence
(
this
);
atomCoarseGrainingPositions_
->
remove_dependence
(
this
);
};
/** do nothing */
virtual
void
reset_quantity
()
const
;
/** access nCols_ */
virtual
int
nCols
()
const
{
return
source_
->
nCols
();
}
protected
:
/** pointer to atc base class */
const
ATC_Method
*
atc_
;
/** pointer to source data */
PerAtomQuantity
<
double
>
*
source_
;
/** atomic coordinates used for coarse graining operations */
DENS_MAN
*
atomCoarseGrainingPositions_
;
/** access to mesh */
const
FE_Mesh
*
feMesh_
;
// workspace
mutable
DENS_MAT
_quantityLocal_
;
private:
// do not define
OnTheFlyMeshAccumulation
();
};
/**
* @class OnTheFlyMeshAccumulationNormalized
* @brief implements a normalized mesh-based accumulant on the fly
*/
class
OnTheFlyMeshAccumulationNormalized
:
public
OnTheFlyMeshAccumulation
{
public:
// constructor
OnTheFlyMeshAccumulationNormalized
(
ATC_Method
*
atc
,
PerAtomQuantity
<
double
>
*
source
,
DENS_MAN
*
atomCoarseGrainingPositions
,
DIAG_MAN
*
weights
);
// destructor
virtual
~
OnTheFlyMeshAccumulationNormalized
()
{
weights_
->
remove_dependence
(
this
);
};
/** do nothing */
virtual
void
reset_quantity
()
const
;
protected:
DIAG_MAN
*
weights_
;
private:
// do not define
OnTheFlyMeshAccumulationNormalized
();
};
/**
* @class OnTheFlyMeshAccumulationNormalizedReferenced
* @brief implements a normalized referenced mesh-based accumulant on the fly
*/
class
OnTheFlyMeshAccumulationNormalizedReferenced
:
public
OnTheFlyMeshAccumulationNormalized
{
public:
// constructor
OnTheFlyMeshAccumulationNormalizedReferenced
(
ATC_Method
*
atc
,
PerAtomQuantity
<
double
>
*
source
,
DENS_MAN
*
atomCoarseGrainingPositions
,
DIAG_MAN
*
weights
,
DENS_MAN
*
reference
);
// destructor
virtual
~
OnTheFlyMeshAccumulationNormalizedReferenced
()
{
reference_
->
remove_dependence
(
this
);
};
/** do nothing */
virtual
void
reset_quantity
()
const
;
protected:
/** reference value */
DENS_MAN
*
reference_
;
private:
// do not define
OnTheFlyMeshAccumulationNormalizedReferenced
();
};
/**
* @class OnTheFlyMeshAccumulationNormalizedScaled
* @brief implements a scaled mesh-based accumulant on the fly
*/
class
OnTheFlyMeshAccumulationNormalizedScaled
:
public
OnTheFlyMeshAccumulationNormalized
{
public:
// constructor
OnTheFlyMeshAccumulationNormalizedScaled
(
ATC_Method
*
atc
,
PerAtomQuantity
<
double
>
*
source
,
DENS_MAN
*
atomCoarseGrainingPositions
,
DIAG_MAN
*
weights
,
const
double
scale
);
// destructor
virtual
~
OnTheFlyMeshAccumulationNormalizedScaled
()
{
atomCoarseGrainingPositions_
->
remove_dependence
(
this
);
};
/** do nothing */
virtual
void
reset_quantity
()
const
;
protected:
const
double
scale_
;
private:
// do not define
OnTheFlyMeshAccumulationNormalizedScaled
();
};
/**
* @class NativeShapeFunctionGradient
* @brief constructs the spatial derivatives of the shape functions
*/
class
NativeShapeFunctionGradient
:
public
VectorTransfer
<
SPAR_MAT
*
>
{
public:
// constructor
NativeShapeFunctionGradient
(
ATC_Method
*
atc
);
// destructor
virtual
~
NativeShapeFunctionGradient
();
protected:
/** does the actual computation of the quantity */
virtual
void
reset_quantity
()
const
;
protected:
/** pointer to the FE engine */
const
FE_Engine
*
feEngine_
;
private:
// do not define
NativeShapeFunctionGradient
();
};
/**
* @class OnTheFlyShapeFunctionProlongation
* @brief implements the interpolant on the fly
*/
class
OnTheFlyShapeFunctionProlongation
:
public
FeToAtomTransfer
{
public:
// constructor
OnTheFlyShapeFunctionProlongation
(
ATC_Method
*
atc
,
DENS_MAN
*
source
,
DENS_MAN
*
atomCoarseGrainingPositions
);
// destructor
virtual
~
OnTheFlyShapeFunctionProlongation
();
/** do nothing */
virtual
void
reset
()
const
;
protected:
/** pointer to atc base class */
//const ATC_Method * atc_;
/** pointer to source data */
//DENS_MAN * source_;
/** atomic coordinates used for coarse graining operations */
DENS_MAN
*
atomCoarseGrainingPositions_
;
/** access to mesh */
const
FE_Mesh
*
feMesh_
;
// workspace
//mutable DENS_MAT _quantityLocal_;
private:
// do not define
OnTheFlyShapeFunctionProlongation
();
};
}
#endif
Event Timeline
Log In to Comment