// a library for the various transfer operators used in ATC #ifndef TRANSFER_LIBRARY_H #define TRANSFER_LIBRARY_H #include #include #include // 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 { 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 { public: // constructor NodalAtomVolumeElement(ATC_Method * atc, SPAR_MAN * shapeFunction, PerAtomQuantity * 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 * 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 { public: // constructor AtomTypeElement(ATC_Coupling * atc, PerAtomQuantity * 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 * 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 { public: // constructor ElementMask(ATC_Coupling * atc, MatrixDependencyManager * hasInternal = NULL, MatrixDependencyManager * 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 * hasInternal_; /** shape function matrix over the ghost atoms used to help define the geometry */ MatrixDependencyManager * 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 { public: // constructor AtomElementMask(ATC_Coupling * atc, MatrixDependencyManager * 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 * 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 { public: // constructor NodalGeometryType(ATC_Coupling * atc, MatrixDependencyManager * hasInternal = NULL, MatrixDependencyManager * 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 * hasInternal_; /** shape function matrix over the ghost atoms used to help define the geometry */ MatrixDependencyManager * 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 _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 { public: // constructor NodalGeometryTypeElementSet(ATC_Coupling * atc, MatrixDependencyManager * 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 * 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 _nodesInternal_, _nodesGhost_; private: // do not define NodalGeometryTypeElementSet(); }; /** * @class LargeToSmallMap * @brief mapping from a larger set to a smaller set */ class LargeToSmallMap : public DenseMatrixTransfer { 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 * 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 * subsetNodes_; private: // do not define NodeToSubset(); }; /** * @class SubsetToNode * @brief mapping from a subset of nodes to all nodes */ class SubsetToNode : public DenseMatrixTransfer { 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 { 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 _row_; // vector storing the row values of a matrix mutable DenseVector _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 { public: // constructor RowMappedSparseMatrixVector(ATC_Method * atc, VectorDependencyManager * source, LargeToSmallAtomMap * map); // destructor virtual ~RowMappedSparseMatrixVector(); /** apply transfer operator */ virtual void reset_quantity() const; protected: /** original quantity */ VectorDependencyManager * source_; /** mapping transfer */ LargeToSmallAtomMap * map_; // workspace mutable DenseVector _row_; // vector storing the row values of a matrix mutable DenseVector _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 { 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 { 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 { public: // constructor RegulatedNodes(ATC_Coupling * atc, FieldName fieldName = NUM_TOTAL_FIELDS, MatrixDependencyManager * 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 fieldSizes_; /** map from atom to element in which it resides */ MatrixDependencyManager * 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 * 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 * 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 * 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 * 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 * 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 * 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 { public: // constructor ElementMaskNodeSet(ATC_Coupling * atc, SetDependencyManager * nodeSet); // destructor virtual ~ElementMaskNodeSet() { nodeSet_->remove_dependence(this); }; /** apply transfer operator */ virtual void reset_quantity() const; protected: /** transfer determining used nodes */ SetDependencyManager * 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 { public: // constructor PointToElementMap(ATC_Method * atc, MatrixDependencyManager * pointPositions); // destructor virtual ~PointToElementMap(); protected: /** resets the data if necessary */ virtual void reset_quantity() const; /** point positions */ MatrixDependencyManager * 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 { public: // constructor Interpolant(ATC_Method * atc, MatrixDependencyManager* 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* 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 { public: // constructor InterpolantGradient(ATC_Method * atc, MatrixDependencyManager* 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* 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 { public: // constructor PerAtomShapeFunctionGradient(ATC_Method * atc, MatrixDependencyManager* 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* 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 * > 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* 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 { 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 { 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 { 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 { public: // constructor OnTheFlyKernelAccumulation(ATC_Method * atc, PerAtomQuantity * 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 * 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 * 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 * 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 * 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 { 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 { 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 { 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 { public: // constructor OnTheFlyMeshAccumulation(ATC_Method * atc, PerAtomQuantity * 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 * 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 * 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 * 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 * 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 { 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