forked from lijiext/lammps
1146 lines
33 KiB
C++
1146 lines
33 KiB
C++
// 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_;
|
|
|
|
/** persistent 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_;
|
|
|
|
/** persistent 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_;
|
|
|
|
/** persistent 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_;
|
|
|
|
/** persistent 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
|