Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F85323942
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
Sat, Sep 28, 08:14
Size
33 KB
Mime Type
text/x-c
Expires
Mon, Sep 30, 08:14 (1 d, 23 h)
Engine
blob
Format
Raw Data
Handle
21149287
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