Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F87781023
TransferOperator.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
Mon, Oct 14, 22:18
Size
33 KB
Mime Type
text/x-c
Expires
Wed, Oct 16, 22:18 (1 d, 23 h)
Engine
blob
Format
Raw Data
Handle
21652964
Attached To
rLAMMPS lammps
TransferOperator.h
View Options
// A class for defining transfer operations
#ifndef TRANSFER_OPERATOR_H
#define TRANSFER_OPERATOR_H
#include "PerAtomQuantityLibrary.h"
#include <set>
#include <vector>
namespace ATC {
// forward declarations
class ATC_Method;
class KernelFunction;
class FE_Mesh;
/**
* @class DenseMatrixTransfer
* @brief Class for defining objects that generate dense matrix quantities from other matrix quantities
*/
template <typename T>
class DenseMatrixTransfer : public MatrixDependencyManager<DenseMatrix, T> {
public:
// constructor
DenseMatrixTransfer() :
MatrixDependencyManager<DenseMatrix, T>(),
lammpsInterface_(LammpsInterface::instance()) {};
// destructor
virtual ~DenseMatrixTransfer() {};
/** apply transfer operator */
virtual const DenseMatrix<T> & quantity() const {
if (this->need_reset()) {
this->reset_quantity();
MatrixDependencyManager<DenseMatrix, T>::needReset_ = false;
}
return MatrixDependencyManager<DenseMatrix, T>::quantity_;
};
/** sets the quantity to a given value */
virtual void operator=(const DenseMatrix<T> & target)
{throw ATC_Error("DenseMatrixTransfer::set_quantity - Cannot modify transfer-based matrices");};
/** sets the quantity to a given constant value */
virtual void operator=(const T & target)
{throw ATC_Error("DenseMatrixTransfer::operator= - Cannot modify transfer-based matrices");};
/** adds the given data to the Lammps quantity */
virtual void operator+=(const DenseMatrix<T> & addition)
{throw ATC_Error("DenseMatrixTransfer::operator+= - Cannot modify transfer-based matrices");};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(T addition)
{throw ATC_Error("DenseMatrixTransfer::operator+= - Cannot modify transfer-based matrices");};
/** subtracts the given data from the Lammps quantity */
virtual void operator-=(const DenseMatrix<T> & subtraction)
{throw ATC_Error("DenseMatrixTransfer::operator-= - Cannot modify transfer-based matrices");};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(T subtraction)
{throw ATC_Error("DenseMatrixTransfer::operator-= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(const DenseMatrix<T> & multiplier)
{throw ATC_Error("DenseMatrixTransfer::operator*= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(T multiplier)
{throw ATC_Error("DenseMatrixTransfer::operator*= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const DenseMatrix<T> & divisor)
{throw ATC_Error("DenseMatrixTransfer::operator/= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(T divisor)
{throw ATC_Error("DenseMatrixTransfer::operator/= - Cannot modify transfer-based matrices");};
protected:
/** does the actual computation of the quantity */
virtual void reset_quantity() const = 0;
/** pointer to LammpsInterface for MPI */
LammpsInterface * lammpsInterface_;
};
/**
* @class SparseMatrixTransfer
* @brief Class for defining objects that generate dense matrix quantities from other matrix quantities
*/
template <typename T>
class SparseMatrixTransfer : public MatrixDependencyManager<SparseMatrix, T> {
public:
// constructor
SparseMatrixTransfer() :
MatrixDependencyManager<SparseMatrix, T>(),
lammpsInterface_(LammpsInterface::instance()) {};
// destructor
virtual ~SparseMatrixTransfer() {};
/** apply transfer operator */
virtual const SparseMatrix<T> & quantity() const {if (this->need_reset()) {this->reset_quantity(); MatrixDependencyManager<SparseMatrix, T>::needReset_ = false;} return MatrixDependencyManager<SparseMatrix, T>::quantity_;};
/** sets the quantity to a given value */
virtual void operator=(const SparseMatrix<T> & target)
{throw ATC_Error("SparseMatrixTransfer::set_quantity - Cannot modify transfer-based matrices");};
/** sets the quantity to a given constant value */
virtual void operator=(const T & target)
{throw ATC_Error("SparseMatrixTransfer::operator= - Cannot modify transfer-based matrices");};
/** adds the given data to the Lammps quantity */
virtual void operator+=(const SparseMatrix<T> & addition)
{throw ATC_Error("SparseMatrixTransfer::operator+= - Cannot modify transfer-based matrices");};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(T addition)
{throw ATC_Error("SparseMatrixTransfer::operator+= - Cannot modify transfer-based matrices");};
/** subtracts the given data from the Lammps quantity */
virtual void operator-=(const SparseMatrix<T> & subtraction)
{throw ATC_Error("SparseMatrixTransfer::operator-= - Cannot modify transfer-based matrices");};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(T subtraction)
{throw ATC_Error("SparseMatrixTransfer::operator-= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(const SparseMatrix<T> & multiplier)
{throw ATC_Error("SparseMatrixTransfer::operator*= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(T multiplier)
{throw ATC_Error("SparseMatrixTransfer::operator*= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const SparseMatrix<T> & divisor)
{throw ATC_Error("SparseMatrixTransfer::operator/= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(T divisor)
{throw ATC_Error("SparseMatrixTransfer::operator/= - Cannot modify transfer-based matrices");};
protected:
/** does the actual computation of the quantity */
virtual void reset_quantity() const = 0;
/** pointer to LammpsInterface for MPI */
LammpsInterface * lammpsInterface_;
};
/**
* @class DiagonalMatrixTransfer
* @brief Class for defining objects that generate diagonal matrix quantities from other matrix quantities
*/
template <typename T>
class DiagonalMatrixTransfer : public MatrixDependencyManager<DiagonalMatrix, T> {
public:
// constructor
DiagonalMatrixTransfer() :
MatrixDependencyManager<DiagonalMatrix, T>(),
lammpsInterface_(LammpsInterface::instance()) {};
// destructor
virtual ~DiagonalMatrixTransfer() {};
/** apply transfer operator */
virtual const DiagonalMatrix<T> & quantity() const {if (this->need_reset()) {this->reset_quantity(); MatrixDependencyManager<DiagonalMatrix, T>::needReset_ = false;} return MatrixDependencyManager<DiagonalMatrix, T>::quantity_;};
/** sets the quantity to a given value */
virtual void operator=(const DiagonalMatrix<T> & target)
{throw ATC_Error("DiagonalMatrixTransfer::set_quantity - Cannot modify transfer-based matrices");};
/** sets the quantity to a given constant value */
virtual void operator=(const T & target)
{throw ATC_Error("DiagonalMatrixTransfer::operator= - Cannot modify transfer-based matrices");};
/** adds the given data to the Lammps quantity */
virtual void operator+=(const DiagonalMatrix<T> & addition)
{throw ATC_Error("DiagonalMatrixTransfer::operator+= - Cannot modify transfer-based matrices");};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(T addition)
{throw ATC_Error("DiagonalMatrixTransfer::operator+= - Cannot modify transfer-based matrices");};
/** subtracts the given data from the Lammps quantity */
virtual void operator-=(const DiagonalMatrix<T> & subtraction)
{throw ATC_Error("DiagonalMatrixTransfer::operator-= - Cannot modify transfer-based matrices");};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(T subtraction)
{throw ATC_Error("DiagonalMatrixTransfer::operator-= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(const DiagonalMatrix<T> & multiplier)
{throw ATC_Error("DiagonalMatrixTransfer::operator*= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(T multiplier)
{throw ATC_Error("DiagonalMatrixTransfer::operator*= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const DiagonalMatrix<T> & divisor)
{throw ATC_Error("DiagonalMatrixTransfer::operator/= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(T divisor)
{throw ATC_Error("DiagonalMatrixTransfer::operator/= - Cannot modify transfer-based matrices");};
protected:
/** does the actual computation of the quantity */
virtual void reset_quantity() const = 0;
/** pointer to LammpsInterface for MPI */
LammpsInterface * lammpsInterface_;
};
/**
* @class SetTransfer
* @brief Class for defining objects that generate sets using prescribed algorithms
*/
template <typename T>
class SetTransfer : public SetDependencyManager<T> {
public:
// constructor
SetTransfer() :
SetDependencyManager<T>() {};
// destructor
virtual ~SetTransfer() {};
/** apply transfer operator */
virtual const std::set<T> & quantity() const {if (this->need_reset()) {this->reset_quantity(); SetDependencyManager<T>::needReset_ = false;} return SetDependencyManager<T>::quantity_;};
/** returns a non-const version for manipulations and changes, resets dependent quantities */
virtual std::set<T> & set_quantity()
{throw ATC_Error("SetTransfer::set_quantity - Cannot modify protected quantities"); return this->quantity_;};
protected:
/** does the actual computation of the quantity */
virtual void reset_quantity() const = 0;
};
/**
* @class VectorTransfer
* @brief Class for defining objects that generate sets using prescribed algorithms
*/
template <typename T>
class VectorTransfer : public VectorDependencyManager<T> {
public:
// constructor
VectorTransfer() :
VectorDependencyManager<T>() {};
// destructor
virtual ~VectorTransfer() {};
/** apply transfer operator */
virtual const std::vector<T> & quantity() const {if (this->need_reset()) {this->reset_quantity(); VectorDependencyManager<T>::needReset_ = false;} return VectorDependencyManager<T>::quantity_;};
/** returns a non-const version for manipulations and changes, resets dependent quantities */
virtual std::vector<T> & set_quantity()
{throw ATC_Error("VectorTransfer::set_quantity - Cannot modify protected quantities"); return this->quantity_;};
protected:
/** does the actual computation of the quantity */
virtual void reset_quantity() const = 0;
};
/**
* @class AtomToFeTransfer
* @brief Class for defining objects to transfer atomistic quantities to FE quantities
*/
class AtomToFeTransfer : public DenseMatrixTransfer<double> {
public:
// constructor
AtomToFeTransfer(ATC_Method * atc,
PerAtomQuantity<double> * source);
// destructor
virtual ~AtomToFeTransfer();
protected:
/** pointer to atc */
ATC_Method * atc_;
/** pointer to source atomic quantity data */
PerAtomQuantity<double> * source_;
private:
// do not define
AtomToFeTransfer();
};
/**
* @class AtomDiagonalMatrixToFeTransfer
* @brief Class for defining objects to transfer atomistic quantities to FE quantities
*/
class AtomDiagonalMatrixToFeTransfer : public DenseMatrixTransfer<double> {
public:
// constructor
AtomDiagonalMatrixToFeTransfer(ATC_Method * atc,
PerAtomDiagonalMatrix<double> * source);
// destructor
virtual ~AtomDiagonalMatrixToFeTransfer();
protected:
/** pointer to atc */
ATC_Method * atc_;
/** pointer to source atomic quantity data */
PerAtomDiagonalMatrix<double> * source_;
private:
// do not define
AtomDiagonalMatrixToFeTransfer();
};
/**
* @class FeToAtomTransfer
* @brief Class for defining objects to transfer FE quantities to atomistic quantities
*/
class FeToAtomTransfer : public ProtectedAtomQuantity<double> {
public:
// constructor
FeToAtomTransfer(ATC_Method * atc,
DENS_MAN * source,
AtomType atomType = INTERNAL);
// destructor
virtual ~FeToAtomTransfer();
protected:
/** pointer to source Fe matrix data */
DENS_MAN * source_;
private:
// do not define
FeToAtomTransfer();
};
/**
* @class FeToAtomDiagonalMatrix
* @brief Class for defining objects to transfer FE quantities to atomistic diagonal matrices
*/
class FeToAtomDiagonalMatrix : public ProtectedAtomDiagonalMatrix<double> {
public:
// constructor
FeToAtomDiagonalMatrix(ATC_Method * atc,
DENS_MAN * source);
// destructor
virtual ~FeToAtomDiagonalMatrix();
protected:
/** pointer to source Fe matrix data */
DENS_MAN * source_;
private:
// do not define
FeToAtomDiagonalMatrix();
};
/**
* @class MatToMatTransfer
* @brief Class for defining objects that transfer quantities between materials
*/
template <typename T>
class MatToMatTransfer : public DenseMatrixTransfer<T> {
public:
// constructor
MatToMatTransfer(MatrixDependencyManager<DenseMatrix, T> * source) :
source_(source) {source_->register_dependence(this);};
// destructor
virtual ~MatToMatTransfer() {source_->remove_dependence(this);};
protected:
/** pointer to source matrix data */
MatrixDependencyManager<DenseMatrix, T> * source_;
private:
// do not define
MatToMatTransfer();
};
/**
* @class AtfShapeFunctionRestriction
* @brief Class for defining objects that transfer atomistic quantities to FE using shape functions
* (implements restrict_volumetric_quantity)
*/
class AtfShapeFunctionRestriction : public AtomToFeTransfer {
public:
// constructor
AtfShapeFunctionRestriction(ATC_Method * atc,
PerAtomQuantity<double> * source,
SPAR_MAN * shapeFunction);
// destructor
virtual ~AtfShapeFunctionRestriction();
/** apply transfer operator */
virtual void reset_quantity() const;
protected:
/** reference to shape function matrix */
SPAR_MAN * shapeFunction_;
/** persistant workspace */
mutable DENS_MAT _workspace_;
/** applies restriction operation across all processors */
virtual void global_restriction() const;
/** applies restriction operation on this processor */
virtual void local_restriction(const DENS_MAT & sourceMatrix,
const SPAR_MAT & shapeFunctionMatrix) const;
private:
// do not define
AtfShapeFunctionRestriction();
};
/**
* @class AdmtfShapeFunctionRestriction
* @brief Class for defining objects that transfer atomistic diagonal matrices to FE using shape functions=
*/
class AdmtfShapeFunctionRestriction : public AtomDiagonalMatrixToFeTransfer {
public:
// constructor
AdmtfShapeFunctionRestriction(ATC_Method * atc,
PerAtomDiagonalMatrix<double> * source,
SPAR_MAN * shapeFunction);
// destructor
virtual ~AdmtfShapeFunctionRestriction();
/** apply transfer operator */
virtual void reset_quantity() const;
protected:
/** reference to shape function matrix */
SPAR_MAN * shapeFunction_;
/** persistant workspace */
mutable DENS_MAT _workspace_;
/** applies restriction operation across all processors */
virtual void global_restriction() const;
/** applies restriction operation on this processor */
virtual void local_restriction(const DENS_MAT & sourceMatrix,
const SPAR_MAT & shapeFunctionMatrix) const;
private:
// do not define
AdmtfShapeFunctionRestriction();
};
/**
* @class AtfProjection
* @brief
*/
class AtfProjection : public AtomToFeTransfer {
public:
// constructor
AtfProjection(ATC_Method * atc,
PerAtomQuantity<double> * source,
SPAR_MAN * accumulant,
DIAG_MAN * weights = NULL);
// destructor
virtual ~AtfProjection();
/** apply transfer operator */
virtual void reset_quantity() const;
/** get number of columns */
virtual int nCols() const {return source_->nCols();};
protected:
/** reference to shape function matrix */
SPAR_MAN * accumulant_;
DIAG_MAN * weights_;
DENS_MAT * reference_;
/** persistant workspace */
mutable DENS_MAT _workspace_;
/** applies restriction operation across all processors */
virtual void global_restriction() const;
/** applies restriction operation on this processor */
virtual void local_restriction(const DENS_MAT & sourceMatrix,
const SPAR_MAT & shapeFunctionMatrix) const;
private:
// do not define
AtfProjection();
};
class AtfProjectionScaled : public AtfProjection {
public:
// constructor
AtfProjectionScaled(ATC_Method * atc,
PerAtomQuantity<double> * source,
SPAR_MAN * accumulant,
const double scale,
DIAG_MAN * weights = NULL);
// destructor
virtual ~AtfProjectionScaled();
/** apply transfer operator */
virtual void reset_quantity() const;
protected:
/** reference to shape function matrix */
double scale_;
private:
// do not define
AtfProjectionScaled();
};
/**
* @class AtfProjectionReferenced
* @brief
*/
class AtfProjectionReferenced : public AtfProjection {
public:
// constructor
AtfProjectionReferenced(ATC_Method * atc,
PerAtomQuantity<double> * source,
SPAR_MAN * accumulant,
DENS_MAN * reference,
DIAG_MAN * weights = NULL);
// destructor
virtual ~AtfProjectionReferenced();
/** apply transfer operator */
virtual void reset_quantity() const;
protected:
/** reference value */
DENS_MAN * reference_;
private:
// do not define
AtfProjectionReferenced();
};
/**
* @class AtfWeightedShapeFunctionRestriction
* @brief Class for defining objects that transfer atomistic quantities to FE using shape functions
* including approximate quadrature weights
* (implements restrict_unscaled)
*/
class AtfWeightedShapeFunctionRestriction : public AtfShapeFunctionRestriction {
public:
// constructor
AtfWeightedShapeFunctionRestriction(ATC_Method * atc,
PerAtomQuantity<double> * source,
SPAR_MAN * shapeFunction,
DIAG_MAN * weights);
// destructor
virtual ~AtfWeightedShapeFunctionRestriction() {weights_->remove_dependence(this);};
protected:
/** reference to diagonal weighting matrix */
DIAG_MAN * weights_;
/** applies restriction operation on this processor */
virtual void local_restriction(const DENS_MAT & sourceMatrix,
const SPAR_MAT & shapeFunctionMatrix) const;
private:
// do not define
AtfWeightedShapeFunctionRestriction();
};
/**
* @class AtfNodeWeightedShapeFunctionRestriction
* @brief Class for defining objects that transfer atomistic quantities to FE using shape functions
* including weighting at the mesh nodes
*/
class AtfNodeWeightedShapeFunctionRestriction : public AtfShapeFunctionRestriction {
public:
// constructor
AtfNodeWeightedShapeFunctionRestriction(ATC_Method * atc,
PerAtomQuantity<double> * source,
SPAR_MAN * shapeFunction,
DIAG_MAN * weights);
// destructor
virtual ~AtfNodeWeightedShapeFunctionRestriction() {weights_->remove_dependence(this);};
protected:
/** reference to diagonal weighting matrix */
DIAG_MAN * weights_;
/** applies restriction operation across all processors */
virtual void global_restriction() const;
private:
// do not define
AtfNodeWeightedShapeFunctionRestriction();
};
/**
* @class AtfShapeFunctionProjection
* @brief Class for defining objects that transfer restricted atomistic quantities to FE using shape functions
* (implements project/project_volumetric_quantity assuming restrict_unscaled/
* restrict_volumetric_quantity has been applied)
*/
class AtfShapeFunctionProjection : public MatToMatTransfer<double> {
public:
// constructor
AtfShapeFunctionProjection(ATC_Method * atc,
DENS_MAN * source,
FieldName thisField);
// destructor
virtual ~AtfShapeFunctionProjection();
/** apply transfer operator */
virtual void reset_quantity() const ;
protected:
/** pointer to atc object for mass matrix inversion */
ATC_Method * atc_;
/** field name to define mass matrix to use */
FieldName thisField_;
private:
// do not define
AtfShapeFunctionProjection();
};
/**
* @class AtfShapeFunctionMdProjection
* @brief Class for defining objects that transfer restricted atomistic quantities to FE using shape functions for the MD region
* (implements project_md/project_md_volumetric_quantity assuming
* restrict_unscaled/restrict_volumetric_quantity has been applied)
*/
class AtfShapeFunctionMdProjection : public MatToMatTransfer<double> {
public:
// constructor
AtfShapeFunctionMdProjection(ATC_Method * atc,
DENS_MAN * source,
FieldName thisField);
// destructor
virtual ~AtfShapeFunctionMdProjection();
/** apply transfer operator */
virtual void reset_quantity() const;
protected:
/** pointer to atc object for mass matrix inversion */
ATC_Method * atc_;
/** field name to define mass matrix to use */
FieldName thisField_;
private:
// do not define
AtfShapeFunctionMdProjection();
};
/**
* @class AtfShapeFunctionMdProjectionScaled
* @brief Class for defining objects that transfer restricted atomistic quantities to FE using shape functions for the MD region with a scaling factor
* (implements project_md/project_md_volumetric_quantity assuming
* restrict_unscaled/restrict_volumetric_quantity has been applied)
*/
class AtfShapeFunctionMdProjectionScaled : public AtfShapeFunctionMdProjection {
public:
// constructor
AtfShapeFunctionMdProjectionScaled(ATC_Method * atc,
DENS_MAN * source,
double scale,
FieldName thisField);
// destructor
virtual ~AtfShapeFunctionMdProjectionScaled();
/** apply transfer operator */
virtual void reset_quantity() const;
protected:
/** scale multiplier */
double scale_;
private:
// do not define
AtfShapeFunctionMdProjectionScaled();
};
/**
* @class AtfShapeFunctionMdProjectionReferenced
* @brief Class for defining objects that transfer restricted atomistic quantities to FE using shape functions for the MD region with respect to a reference
* (implements project_md/project_md_volumetric_quantity assuming
* restrict_unscaled/restrict_volumetric_quantity has been applied)
*/
class AtfShapeFunctionMdProjectionReferenced : public AtfShapeFunctionMdProjection {
public:
// constructor
AtfShapeFunctionMdProjectionReferenced(ATC_Method * atc,
DENS_MAN * source,
DENS_MAN * reference,
FieldName thisField);
// destructor
virtual ~AtfShapeFunctionMdProjectionReferenced();
/** apply transfer operator */
virtual void reset_quantity() const;
protected:
/** reference value */
DENS_MAN * reference_;
private:
// do not define
AtfShapeFunctionMdProjectionReferenced();
};
/**
* @class AtfKernelFunctionRestriction
* @brief Class for defining objects that transfer atomistic quantities to FE using kernel functions
*/
class AtfKernelFunctionRestriction : public AtomToFeTransfer {
public:
// constructor
AtfKernelFunctionRestriction(ATC_Method * atc,
PerAtomQuantity<double> * source,
PerAtomQuantity<double> * coarseGrainingPositions,
KernelFunction * kernelFunction);
// destructor
virtual ~AtfKernelFunctionRestriction();
/** apply transfer operator */
virtual void reset_quantity() const;
protected:
/** pointer to the kernel function evaluator */
KernelFunction * kernelFunction_;
/** reference positions for coarse graining operations */
PerAtomQuantity<double> * coarseGrainingPositions_;
/** pointer to the mesh being used */
const FE_Mesh * feMesh_;
/** persistant workspace */
mutable DENS_MAT _workspace_;
mutable DENS_VEC _xI_, _xa_, _xaI_;
/** applies restriction operation across all processors */
virtual void global_restriction() const;
/** applies restriction operation on this processor */
virtual void local_restriction(const DENS_MAT & sourceMatrix,
const DENS_MAT & positions,
const KernelFunction * kernelFunction) const;
private:
// do not define
AtfKernelFunctionRestriction();
};
/**
* @class AtfWeightedKernelFunctionRestriction
* @brief Class for defining objects that transfer atomistic quantities to mesh using kernel functions
* including approximate quadrature weights
*/
class AtfWeightedKernelFunctionRestriction : public AtfKernelFunctionRestriction {
public:
// constructor
AtfWeightedKernelFunctionRestriction(ATC_Method * atc,
PerAtomQuantity<double> * source,
PerAtomQuantity<double> * coarseGrainingPositions,
KernelFunction * kernelFunction,
DIAG_MAN * weights);
// destructor
virtual ~AtfWeightedKernelFunctionRestriction() {weights_->remove_dependence(this);};
protected:
/** reference to diagonal weighting matrix */
DIAG_MAN * weights_;
/** applies restriction operation on this processor */
virtual void local_restriction(const DENS_MAT & sourceMatrix,
const DENS_MAT & positions,
const KernelFunction * kernelFunction) const;
private:
// do not define
AtfWeightedKernelFunctionRestriction();
};
/**
* @class AtfNodeWeightedKernelFunctionRestriction
* @brief Class for defining objects that transfer atomistic quantities to a mesh using kernel functions
* including weighting at the mesh nodes
*/
class AtfNodeWeightedKernelFunctionRestriction : public AtfKernelFunctionRestriction {
public:
// constructor
AtfNodeWeightedKernelFunctionRestriction(ATC_Method * atc,
PerAtomQuantity<double> * source,
PerAtomQuantity<double> * coarseGrainingPositions,
KernelFunction * kernelFunction,
DIAG_MAN * weights);
// destructor
virtual ~AtfNodeWeightedKernelFunctionRestriction() {weights_->remove_dependence(this);};
protected:
/** reference to diagonal weighting matrix */
DIAG_MAN * weights_;
/** applies restriction operation across all processors */
virtual void global_restriction() const;
private:
// do not define
AtfNodeWeightedKernelFunctionRestriction();
};
/**
* @class FtaShapeFunctionProlongation
* @brief Class for defining objects that transfer FE quantities to atoms using shape functions
* (implements prolong)
*/
class FtaShapeFunctionProlongation : public FeToAtomTransfer {
public:
// constructor
FtaShapeFunctionProlongation(ATC_Method * atc,
DENS_MAN * source,
SPAR_MAN * shapeFunction,
AtomType atomType = INTERNAL);
// destructor
virtual ~FtaShapeFunctionProlongation();
protected:
/** apply transfer operator if needed */
virtual void reset() const;
/** reference to shape function matrix */
SPAR_MAN * shapeFunction_;
private:
// do not define
FtaShapeFunctionProlongation();
};
/**
* @class FtaShapeFunctionProlongationDiagonalMatrix
* @brief Class for defining objects that transfer FE quantities to atomic diagonal matrices using shape functions
* (implements prolong)
*/
class FtaShapeFunctionProlongationDiagonalMatrix : public FeToAtomDiagonalMatrix {
public:
// constructor
FtaShapeFunctionProlongationDiagonalMatrix(ATC_Method * atc,
DENS_MAN * source,
SPAR_MAN * shapeFunction);
// destructor
virtual ~FtaShapeFunctionProlongationDiagonalMatrix();
protected:
/** apply transfer operator if needed */
virtual void reset() const;
/** reference to shape function matrix */
SPAR_MAN * shapeFunction_;
// workspace
mutable DENS_MAT _temp_; // temporary storage for dense matrix
private:
// do not define
FtaShapeFunctionProlongationDiagonalMatrix();
};
/**
* transfer for a matrix to a gradient mitigated by sparse matrices
*
*/
class MatToGradBySparse : public MatToMatTransfer<double> {
public:
//constructor
MatToGradBySparse(ATC_Method * atc,
DENS_MAN * source,
VectorDependencyManager<SPAR_MAT * > * gradientMatrices);
//destructor
virtual ~MatToGradBySparse();
// apply transfer operator
virtual void reset_quantity() const;
protected:
// pointer to sparseMatrix
VectorDependencyManager<SPAR_MAT * > * gradientMatrices_;
private:
// do not define
MatToGradBySparse();
};
/**
* transfer from dense to dense by diagonal matrix multiplier for anything
**/
class DiagonalMatrixMultiply : public MatToMatTransfer<double> {
public:
//constructor
DiagonalMatrixMultiply(DENS_MAN * source,
DIAG_MAN * diagonalMatrix);
//destructor
virtual ~DiagonalMatrixMultiply();
// apply transfer operator
virtual void reset_quantity() const;
protected:
// pointer to sparseMatrix
DIAG_MAN * diagonalMatrix_;
private:
// do not define
DiagonalMatrixMultiply();
};
#ifdef ATC_WHO
/**
// class sparse matrix multiplier for anything
//delete later
**/
class SparseMatrixMultiply : public MatToMatTransfer<double> {
public:
//constructor
SparseMatrixMultiply(ATC_Method * atc,
DENS_MAN * source,
SPAR_MAN * sparseMatrix);
//destructor
virtual ~SparseMatrixMultiply();
protected:
// pointer to sparseMatrix
SPAR_MAN * sparseMatrix_;
// apply transfer operator
virtual const DENS_MAT & quantity() const;
private:
// do not define
SparseMatrixMultiply();
};
#endif
}
#endif
Event Timeline
Log In to Comment