Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F87038171
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, Oct 10, 04:17
Size
39 KB
Mime Type
text/x-c
Expires
Sat, Oct 12, 04:17 (1 d, 23 h)
Engine
blob
Format
Raw Data
Handle
21525197
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