Page MenuHomec4science
Files F76361428

TransferOperator.h
No OneTemporary
Actions

File Metadata

Created
Wed, Aug 7, 13:38

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

c4science · Help