TransferOperator.cpp
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Wed, Jul 31, 17:25

TransferOperator.cpp
View Options

	// ATC headers
	#include "TransferOperator.h"
	#include "ATC_Method.h"
	#include "ATC_Coupling.h"
	#include "KernelFunction.h"
	#include "FE_Mesh.h"
	//#include "AtomToMoleculeTransfer.h"

	//#include <typeinfo>

	namespace ATC {

	//--------------------------------------------------------
	//--------------------------------------------------------
	// Class AtomToFeTransfer
	//--------------------------------------------------------
	//--------------------------------------------------------

	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	AtomToFeTransfer::AtomToFeTransfer(ATC_Method * atc,
	PerAtomQuantity<double> * source) :
	DenseMatrixTransfer<double>(),
	atc_(atc),
	source_(source)
	{
	source_->register_dependence(this);
	}

	//--------------------------------------------------------
	// Destructor
	//--------------------------------------------------------
	AtomToFeTransfer::~AtomToFeTransfer()
	{
	source_->remove_dependence(this);
	}

	//--------------------------------------------------------
	//--------------------------------------------------------
	// Class AtomDiagonalMatrixToFeTransfer
	//--------------------------------------------------------
	//--------------------------------------------------------

	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	AtomDiagonalMatrixToFeTransfer::AtomDiagonalMatrixToFeTransfer(ATC_Method * atc,
	PerAtomDiagonalMatrix<double> * source) :
	DenseMatrixTransfer<double>(),
	atc_(atc),
	source_(source)
	{
	source_->register_dependence(this);
	}

	//--------------------------------------------------------
	// Destructor
	//--------------------------------------------------------
	AtomDiagonalMatrixToFeTransfer::~AtomDiagonalMatrixToFeTransfer()
	{
	source_->remove_dependence(this);
	}

	//--------------------------------------------------------
	//--------------------------------------------------------
	// Class FeToAtomTransfer
	//--------------------------------------------------------
	//--------------------------------------------------------

	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	FeToAtomTransfer::FeToAtomTransfer(ATC_Method * atc,
	DENS_MAN * source,
	AtomType atomType) :
	ProtectedAtomQuantity<double>(atc,source->nCols(),atomType),
	source_(source)
	{
	source_->register_dependence(this);
	}

	//--------------------------------------------------------
	// Destructor
	//--------------------------------------------------------
	FeToAtomTransfer::~FeToAtomTransfer()
	{
	source_->remove_dependence(this);
	}

	//--------------------------------------------------------
	//--------------------------------------------------------
	// Class FeToAtomDiagonalMatrix
	//--------------------------------------------------------
	//--------------------------------------------------------

	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	FeToAtomDiagonalMatrix::FeToAtomDiagonalMatrix(ATC_Method * atc,
	DENS_MAN * source) :
	ProtectedAtomDiagonalMatrix<double>(atc),
	source_(source)
	{
	source_->register_dependence(this);
	}

	//--------------------------------------------------------
	// Destructor
	//--------------------------------------------------------
	FeToAtomDiagonalMatrix::~FeToAtomDiagonalMatrix()
	{
	source_->remove_dependence(this);
	}

	//--------------------------------------------------------
	//--------------------------------------------------------
	// Class AtfShapeFunctionRestriction
	//--------------------------------------------------------
	//--------------------------------------------------------

	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	AtfShapeFunctionRestriction::AtfShapeFunctionRestriction(ATC_Method * atc,
	PerAtomQuantity<double> * source,
	SPAR_MAN * shapeFunction) :
	AtomToFeTransfer(atc,source),
	shapeFunction_(shapeFunction)
	{
	shapeFunction_->register_dependence(this);
	}

	//--------------------------------------------------------
	// Destructor
	//--------------------------------------------------------
	AtfShapeFunctionRestriction::~AtfShapeFunctionRestriction()
	{
	shapeFunction_->remove_dependence(this);
	}

	//--------------------------------------------------------
	// reset_quantity
	//--------------------------------------------------------
	void AtfShapeFunctionRestriction::reset_quantity() const
	{
	global_restriction();
	}

	//--------------------------------------------------------
	// global_restriction
	//--------------------------------------------------------
	void AtfShapeFunctionRestriction::global_restriction() const
	{
	// computes nodeData = N*atomData where N are the shape functions
	const DENS_MAT & sourceMatrix(source_->quantity());
	// reallocate memory only if sizing has changed
	const SPAR_MAT & shapeFunctionMatrix(shapeFunction_->quantity());
	quantity_.resize(shapeFunctionMatrix.nCols(),sourceMatrix.nCols());

	local_restriction(sourceMatrix,shapeFunctionMatrix);

	// communicate for total restriction
	int count = quantity_.nRows()*quantity_.nCols();
	lammpsInterface_->allsum(_workspace_.ptr(),quantity_.ptr(),count);
	}

	//--------------------------------------------------------
	// local_restriction
	//--------------------------------------------------------
	void AtfShapeFunctionRestriction::local_restriction(const DENS_MAT & sourceMatrix,
	const SPAR_MAT & shapeFunctionMatrix) const
	{
	if (sourceMatrix.nRows() > 0)
	_workspace_ = shapeFunctionMatrix.transMat(sourceMatrix);
	else
	_workspace_.reset(quantity_.nRows(),quantity_.nCols());
	}

	//--------------------------------------------------------
	//--------------------------------------------------------
	// Class AdmtfShapeFunctionRestriction
	//--------------------------------------------------------
	//--------------------------------------------------------

	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	AdmtfShapeFunctionRestriction::AdmtfShapeFunctionRestriction(ATC_Method * atc,
	PerAtomDiagonalMatrix<double> * source,
	SPAR_MAN * shapeFunction) :
	AtomDiagonalMatrixToFeTransfer(atc,source),
	shapeFunction_(shapeFunction)
	{
	shapeFunction_->register_dependence(this);
	}

	//--------------------------------------------------------
	// Destructor
	//--------------------------------------------------------
	AdmtfShapeFunctionRestriction::~AdmtfShapeFunctionRestriction()
	{
	shapeFunction_->remove_dependence(this);
	}

	//--------------------------------------------------------
	// reset_quantity
	//--------------------------------------------------------
	void AdmtfShapeFunctionRestriction::reset_quantity() const
	{
	global_restriction();
	}

	//--------------------------------------------------------
	// global_restriction
	//--------------------------------------------------------
	void AdmtfShapeFunctionRestriction::global_restriction() const
	{
	// computes nodeData = N*atomData where N are the shape functions
	const CLON_VEC & sourceMatrix(source_->quantity());
	// reallocate memory only if sizing has changed
	const SPAR_MAT & shapeFunctionMatrix(shapeFunction_->quantity());
	quantity_.resize(shapeFunctionMatrix.nCols(),sourceMatrix.nCols());

	local_restriction(sourceMatrix,shapeFunctionMatrix);

	// communicate for total restriction
	int count = quantity_.nRows()*quantity_.nCols();
	lammpsInterface_->allsum(_workspace_.ptr(),quantity_.ptr(),count);
	}

	//--------------------------------------------------------
	// local_restriction
	//--------------------------------------------------------
	void AdmtfShapeFunctionRestriction::local_restriction(const DENS_MAT & sourceMatrix,
	const SPAR_MAT & shapeFunctionMatrix) const
	{
	if (sourceMatrix.nRows() > 0)
	_workspace_ = shapeFunctionMatrix.transMat(sourceMatrix);
	else
	_workspace_.reset(quantity_.nRows(),quantity_.nCols());
	}

	//--------------------------------------------------------
	//--------------------------------------------------------
	// Class DiagonalMatrixMultiply
	//--------------------------------------------------------
	//--------------------------------------------------------

	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	DiagonalMatrixMultiply::DiagonalMatrixMultiply(DENS_MAN * source,
	DIAG_MAN * diagonalMatrix) :
	MatToMatTransfer<double>(source),
	diagonalMatrix_(diagonalMatrix)
	{
	diagonalMatrix_->register_dependence(this);
	}

	//--------------------------------------------------------
	// Destructor
	//--------------------------------------------------------
	DiagonalMatrixMultiply::~DiagonalMatrixMultiply()
	{
	diagonalMatrix_->remove_dependence(this);
	}

	//--------------------------------------------------------
	// reset_quantity
	//--------------------------------------------------------
	void DiagonalMatrixMultiply::reset_quantity() const
	{
	quantity_ = (diagonalMatrix_->quantity())*(source_->quantity());
	}

	//--------------------------------------------------------
	//--------------------------------------------------------
	// Class AtfProjection
	//--------------------------------------------------------
	//--------------------------------------------------------

	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	AtfProjection::AtfProjection(ATC_Method * atc,
	PerAtomQuantity<double> * source,
	SPAR_MAN * accumulant,
	DIAG_MAN * weights) :
	AtomToFeTransfer(atc,source),
	accumulant_(accumulant),
	weights_(weights)
	{
	if(accumulant_) accumulant_->register_dependence(this);
	if(weights_) weights_->register_dependence(this);
	}

	//--------------------------------------------------------
	// Destructor
	//--------------------------------------------------------
	AtfProjection::~AtfProjection()
	{
	if(accumulant_) accumulant_->remove_dependence(this);
	if(weights_) weights_->remove_dependence(this);
	}

	//--------------------------------------------------------
	// reset_quantity
	//--------------------------------------------------------
	void AtfProjection::reset_quantity() const
	{
	global_restriction();
	}

	//--------------------------------------------------------
	// global_restriction
	//--------------------------------------------------------
	void AtfProjection::global_restriction() const
	{
	// computes nodeData = N*atomData where N are the shape functions
	const DENS_MAT & sourceMatrix(source_->quantity());
	// reallocate memory only if sizing has changed
	const SPAR_MAT & accumulantMatrix(accumulant_->quantity());
	quantity_.resize(accumulantMatrix.nCols(),sourceMatrix.nCols());

	local_restriction(sourceMatrix,accumulantMatrix);

	// communicate for total restriction
	int count = quantity_.nRows()*quantity_.nCols();
	lammpsInterface_->allsum(_workspace_.ptr(),quantity_.ptr(),count);
	if (weights_) {
	CLON_VEC w(weights_->quantity());
	quantity_ *= w;
	}
	}

	//--------------------------------------------------------
	// local_restriction
	//--------------------------------------------------------
	void AtfProjection::local_restriction(const DENS_MAT & sourceMatrix,
	const SPAR_MAT & accumulantMatrix) const
	{
	if (sourceMatrix.nRows() > 0)
	_workspace_ = accumulantMatrix.transMat(sourceMatrix);
	else
	_workspace_.reset(quantity_.nRows(),quantity_.nCols());
	}
	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	AtfProjectionScaled::AtfProjectionScaled(ATC_Method * atc,
	PerAtomQuantity<double> * source,
	SPAR_MAN * accumulant,
	const double scale,
	DIAG_MAN * weights) :
	AtfProjection(atc,source,accumulant,weights),
	scale_(scale)
	{
	}

	//--------------------------------------------------------
	// Destructor
	//--------------------------------------------------------
	AtfProjectionScaled::~AtfProjectionScaled()
	{
	}

	//--------------------------------------------------------
	// reset_quantity
	//--------------------------------------------------------
	void AtfProjectionScaled::reset_quantity() const
	{
	global_restriction();
	quantity_ *= scale_;
	}
	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	AtfProjectionReferenced::AtfProjectionReferenced(ATC_Method * atc,
	PerAtomQuantity<double> * source,
	SPAR_MAN * accumulant,
	DENS_MAN * reference,
	DIAG_MAN * weights) :
	AtfProjection(atc,source,accumulant,weights),
	reference_(reference)
	{
	if(reference_) reference_->register_dependence(this);
	}

	//--------------------------------------------------------
	// Destructor
	//--------------------------------------------------------
	AtfProjectionReferenced::~AtfProjectionReferenced()
	{
	if(reference_) reference_->remove_dependence(this);
	}

	//--------------------------------------------------------
	// reset_quantity
	//--------------------------------------------------------
	void AtfProjectionReferenced::reset_quantity() const
	{
	global_restriction();
	quantity_ -= (reference_->quantity());
	}

	//--------------------------------------------------------
	//--------------------------------------------------------
	// Class AtfWeightedShapeFunctionRestriction
	//--------------------------------------------------------
	//--------------------------------------------------------

	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	AtfWeightedShapeFunctionRestriction::AtfWeightedShapeFunctionRestriction(ATC_Method * atc,
	PerAtomQuantity<double> * source,
	SPAR_MAN * shapeFunction,
	DIAG_MAN * weights) :
	AtfShapeFunctionRestriction(atc,source,shapeFunction),
	weights_(weights)
	{
	weights_->register_dependence(this);
	}

	//--------------------------------------------------------
	// local_restriction
	//--------------------------------------------------------
	void AtfWeightedShapeFunctionRestriction::local_restriction(const DENS_MAT & sourceMatrix,
	const SPAR_MAT & shapeFunctionMatrix) const
	{
	if (sourceMatrix.nRows() > 0) {
	const DIAG_MAT & weightsMatrix(weights_->quantity());
	_workspace_ = shapeFunctionMatrix.transMat(weightsMatrix*sourceMatrix);
	}
	else {
	_workspace_.reset(quantity_.nRows(),quantity_.nCols());
	}
	}

	//--------------------------------------------------------
	//--------------------------------------------------------
	// Class AtfNodeWeightedShapeFunctionRestriction
	//--------------------------------------------------------
	//--------------------------------------------------------

	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	AtfNodeWeightedShapeFunctionRestriction::AtfNodeWeightedShapeFunctionRestriction(ATC_Method * atc,
	PerAtomQuantity<double> * source,
	SPAR_MAN * shapeFunction,
	DIAG_MAN * weights) :
	AtfShapeFunctionRestriction(atc,source,shapeFunction),
	weights_(weights)
	{
	weights_->register_dependence(this);
	}

	//--------------------------------------------------------
	// global_restriction
	//--------------------------------------------------------
	void AtfNodeWeightedShapeFunctionRestriction::global_restriction() const
	{
	AtfShapeFunctionRestriction::global_restriction();
	quantity_ *= weights_->quantity();
	}

	//--------------------------------------------------------
	//--------------------------------------------------------
	// Class AtfShapeFunctionProjection
	//--------------------------------------------------------
	//--------------------------------------------------------

	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	AtfShapeFunctionProjection::AtfShapeFunctionProjection(ATC_Method * atc,
	DENS_MAN * source,
	FieldName thisField) :
	MatToMatTransfer<double>(source),
	atc_(atc),
	thisField_(thisField)
	{
	DIAG_MAN & massMat(atc_->mass_mat(thisField_));
	massMat.register_dependence(this);
	}

	//--------------------------------------------------------
	// Destructor
	//--------------------------------------------------------
	AtfShapeFunctionProjection::~AtfShapeFunctionProjection()
	{
	DIAG_MAN & massMat(atc_->mass_mat(thisField_));
	massMat.remove_dependence(this);
	}

	//--------------------------------------------------------
	// reset_quantity
	//--------------------------------------------------------
	void AtfShapeFunctionProjection::reset_quantity() const
	{
	const DENS_MAT & sourceMatrix(source_->quantity());
	atc_->apply_inverse_mass_matrix(sourceMatrix,quantity_,thisField_);
	}

	//--------------------------------------------------------
	//--------------------------------------------------------
	// Class AtfKernelFunctionRestriction
	//--------------------------------------------------------
	//--------------------------------------------------------

	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	AtfKernelFunctionRestriction::AtfKernelFunctionRestriction(ATC_Method * atc,
	PerAtomQuantity<double> * source,
	PerAtomQuantity<double> * coarseGrainingPositions,
	KernelFunction * kernelFunction) :
	AtomToFeTransfer(atc,source),
	kernelFunction_(kernelFunction),
	coarseGrainingPositions_(coarseGrainingPositions),
	feMesh_(((atc->fe_engine())->fe_mesh()))
	{
	coarseGrainingPositions_->register_dependence(this);
	}

	//--------------------------------------------------------
	// Destructor
	//--------------------------------------------------------
	AtfKernelFunctionRestriction::~AtfKernelFunctionRestriction()
	{
	coarseGrainingPositions_->remove_dependence(this);
	}

	//--------------------------------------------------------
	// reset_quantity
	//--------------------------------------------------------
	void AtfKernelFunctionRestriction::reset_quantity() const
	{
	global_restriction();
	}

	//--------------------------------------------------------
	// global_restriction
	//--------------------------------------------------------
	void AtfKernelFunctionRestriction::global_restriction() const
	{
	// computes nodeData = N*atomData where N are the shape functions
	const DENS_MAT & sourceMatrix(source_->quantity());
	const DENS_MAT & positions(coarseGrainingPositions_->quantity());
	// reallocate memory only if sizing has changed
	quantity_.resize(atc_->num_nodes(),sourceMatrix.nCols());

	local_restriction(sourceMatrix,positions,
	kernelFunction_);

	// communicate for total restriction
	int count = quantity_.nRows()*quantity_.nCols();
	lammpsInterface_->allsum(_workspace_.ptr(),quantity_.ptr(),count);
	}

	//--------------------------------------------------------
	// local_restriction
	//--------------------------------------------------------
	void AtfKernelFunctionRestriction::local_restriction(const DENS_MAT & sourceMatrix,
	const DENS_MAT & positions,
	const KernelFunction * kernelFunction) const
	{
	if (sourceMatrix.nRows() > 0) {
	_xI_.resize(positions.nCols()); _xaI_.resize(positions.nCols());
	_workspace_.reset(quantity_.nRows(),quantity_.nCols());
	double val;
	for (int i = 0; i < quantity_.nRows(); i++) {
	_xI_ = feMesh_->nodal_coordinates(i);
	for (int j = 0; j < sourceMatrix.nRows(); j++) {
	for (int k = 0; k < positions.nCols(); k++)
	_xaI_(k) = _xI_(k) - positions(j,k);
	atc_->lammps_interface()->periodicity_correction(_xaI_.ptr());
	val = kernelFunction->value(_xaI_);
	if (val > 0) {
	for (int k = 0; k < sourceMatrix.nCols(); k++)
	_workspace_(i,k) += val*sourceMatrix(j,k);
	}
	}
	}
	}
	else
	_workspace_.reset(quantity_.nRows(),quantity_.nCols());
	}

	//--------------------------------------------------------
	//--------------------------------------------------------
	// Class AtfWeightedKernelFunctionRestriction
	//--------------------------------------------------------
	//--------------------------------------------------------

	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	AtfWeightedKernelFunctionRestriction::AtfWeightedKernelFunctionRestriction(ATC_Method * atc,
	PerAtomQuantity<double> * source,
	PerAtomQuantity<double> * coarseGrainingPositions,
	KernelFunction * kernelFunction,
	DIAG_MAN * weights) :
	AtfKernelFunctionRestriction(atc,source,coarseGrainingPositions,kernelFunction),
	weights_(weights)
	{
	weights_->register_dependence(this);
	}

	//--------------------------------------------------------
	// local_restriction
	//--------------------------------------------------------
	void AtfWeightedKernelFunctionRestriction::local_restriction(const DENS_MAT & sourceMatrix,
	const DENS_MAT & positions,
	const KernelFunction * kernelFunction) const
	{
	const DIAG_MAT & weights(weights_->quantity());
	if (sourceMatrix.nRows() > 0) {
	_xI_.resize(positions.nCols()); _xaI_.resize(positions.nCols());
	_workspace_.reset(quantity_.nRows(),quantity_.nCols());
	double val;
	for (int i = 0; i < quantity_.nRows(); i++) {
	_xI_ = feMesh_->nodal_coordinates(i);
	for (int j = 0; j < sourceMatrix.nRows(); j++) {
	for (int k = 0; k < positions.nCols(); k++)
	_xaI_(k) = _xI_(k) - positions(j,k);
	atc_->lammps_interface()->periodicity_correction(_xaI_.ptr());
	val = kernelFunction->value(_xaI_);
	if (val > 0) {
	val *= weights(j,j);
	for (int k = 0; k < sourceMatrix.nCols(); k++)
	_workspace_(i,k) += val*sourceMatrix(j,k);
	}
	}
	}
	}
	else {
	_workspace_.reset(quantity_.nRows(),quantity_.nCols());
	}
	}

	//--------------------------------------------------------
	//--------------------------------------------------------
	// Class AtfNodeWeightedKernelFunctionRestriction
	//--------------------------------------------------------
	//--------------------------------------------------------

	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	AtfNodeWeightedKernelFunctionRestriction::AtfNodeWeightedKernelFunctionRestriction(ATC_Method * atc,
	PerAtomQuantity<double> * source,
	PerAtomQuantity<double> * coarseGrainingPositions,
	KernelFunction * kernelFunction,
	DIAG_MAN * weights) :
	AtfKernelFunctionRestriction(atc,source,coarseGrainingPositions,kernelFunction),
	weights_(weights)
	{
	weights_->register_dependence(this);
	}

	//--------------------------------------------------------
	// global_restriction
	//--------------------------------------------------------
	void AtfNodeWeightedKernelFunctionRestriction::global_restriction() const
	{
	AtfKernelFunctionRestriction::global_restriction();
	quantity_ *= weights_->quantity();
	}

	//--------------------------------------------------------
	//--------------------------------------------------------
	// Class AtfShapeFunctionMdProjection
	//--------------------------------------------------------
	//--------------------------------------------------------

	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	AtfShapeFunctionMdProjection::AtfShapeFunctionMdProjection(ATC_Method * atc,
	DENS_MAN * source,
	FieldName thisField) :
	MatToMatTransfer<double>(source),
	atc_(atc),
	thisField_(thisField)
	{
	DIAG_MAN & massMat(atc_->set_mass_mat_md(thisField_));
	massMat.register_dependence(this);
	}

	//--------------------------------------------------------
	// Destructor
	//--------------------------------------------------------
	AtfShapeFunctionMdProjection::~AtfShapeFunctionMdProjection()
	{
	DIAG_MAN & massMat(atc_->set_mass_mat_md(thisField_));
	massMat.remove_dependence(this);
	}

	//--------------------------------------------------------
	// reset_quantity
	//--------------------------------------------------------
	void AtfShapeFunctionMdProjection::reset_quantity() const
	{
	const DENS_MAT & sourceMatrix(source_->quantity());
	atc_->apply_inverse_md_mass_matrix(sourceMatrix,quantity_,thisField_);
	}

	//--------------------------------------------------------
	//--------------------------------------------------------
	// Class AtfShapeFunctionMdProjectionScaled
	//--------------------------------------------------------
	//--------------------------------------------------------

	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	AtfShapeFunctionMdProjectionScaled::AtfShapeFunctionMdProjectionScaled(ATC_Method * atc,
	DENS_MAN * source,
	double scale,
	FieldName thisField) :
	AtfShapeFunctionMdProjection(atc,source,thisField),
	scale_(scale)
	{
	}

	//--------------------------------------------------------
	// Destructor
	//--------------------------------------------------------
	AtfShapeFunctionMdProjectionScaled::~AtfShapeFunctionMdProjectionScaled()
	{
	}

	//--------------------------------------------------------
	// reset_quantity
	//--------------------------------------------------------
	void AtfShapeFunctionMdProjectionScaled::reset_quantity() const
	{
	AtfShapeFunctionMdProjection::reset_quantity();
	quantity_ *= scale_;
	}

	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	AtfShapeFunctionMdProjectionReferenced::AtfShapeFunctionMdProjectionReferenced(ATC_Method * atc,
	DENS_MAN * source,
	DENS_MAN * reference,
	FieldName thisField) :
	AtfShapeFunctionMdProjection(atc,source,thisField),
	reference_(reference)
	{
	reference_->register_dependence(this);
	}

	//--------------------------------------------------------
	// Destructor
	//--------------------------------------------------------
	AtfShapeFunctionMdProjectionReferenced::~AtfShapeFunctionMdProjectionReferenced()
	{
	reference_->remove_dependence(this);
	}

	//--------------------------------------------------------
	// reset_quantity
	//--------------------------------------------------------
	void AtfShapeFunctionMdProjectionReferenced::reset_quantity() const
	{
	quantity_ = source_->quantity();
	quantity_ -= reference_->quantity();
	atc_->apply_inverse_md_mass_matrix(quantity_,thisField_);
	}

	//--------------------------------------------------------
	//--------------------------------------------------------
	// Class FtaShapeFunctionProlongation
	//--------------------------------------------------------
	//--------------------------------------------------------

	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	FtaShapeFunctionProlongation::FtaShapeFunctionProlongation(ATC_Method * atc,
	DENS_MAN * source,
	SPAR_MAN * shapeFunction,
	AtomType atomType) :
	FeToAtomTransfer(atc,source,atomType),
	shapeFunction_(shapeFunction)
	{
	shapeFunction_->register_dependence(this);
	}

	//--------------------------------------------------------
	// Destructor
	//--------------------------------------------------------
	FtaShapeFunctionProlongation::~FtaShapeFunctionProlongation()
	{
	shapeFunction_->remove_dependence(this);
	}

	//--------------------------------------------------------
	// reset
	//--------------------------------------------------------
	void FtaShapeFunctionProlongation::reset() const
	{
	if (need_reset()) {
	PerAtomQuantity<double>::reset();
	if (atc_.nlocal() > 0) {
	const DENS_MAT & sourceMatrix(source_->quantity());
	const SPAR_MAT & shapeFunctionMatrix(shapeFunction_->quantity());
	quantity_ = shapeFunctionMatrix*sourceMatrix;
	}
	}
	}

	//--------------------------------------------------------
	//--------------------------------------------------------
	// Class FtaShapeFunctionProlongationDiagonalMatrix
	//--------------------------------------------------------
	//--------------------------------------------------------

	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	FtaShapeFunctionProlongationDiagonalMatrix::FtaShapeFunctionProlongationDiagonalMatrix(ATC_Method * atc,
	DENS_MAN * source,
	SPAR_MAN * shapeFunction) :
	FeToAtomDiagonalMatrix(atc,source),
	shapeFunction_(shapeFunction)
	{
	shapeFunction_->register_dependence(this);
	}

	//--------------------------------------------------------
	// Destructor
	//--------------------------------------------------------
	FtaShapeFunctionProlongationDiagonalMatrix::~FtaShapeFunctionProlongationDiagonalMatrix()
	{
	shapeFunction_->remove_dependence(this);
	}

	//--------------------------------------------------------
	// reset
	//--------------------------------------------------------
	void FtaShapeFunctionProlongationDiagonalMatrix::reset() const
	{
	if (need_reset()) {
	PerAtomDiagonalMatrix<double>::reset();
	if (atc_.nlocal() > 0) {
	const DENS_MAT & sourceMatrix(source_->quantity());
	const SPAR_MAT & shapeFunctionMatrix(shapeFunction_->quantity());
	_temp_ = shapeFunctionMatrix*sourceMatrix;
	for (int i = 0; i < quantity_.size(); ++i) {
	quantity_(i,i) = _temp_(i,0);
	}
	}
	}
	}

	//--------------------------------------------------------
	//--------------------------------------------------------
	// Class MatToGradBySparse
	//--------------------------------------------------------
	//--------------------------------------------------------

	//--------------------------------------------------------
	// Constructor
	//--------------------------------------------------------
	MatToGradBySparse::MatToGradBySparse(ATC_Method * atc,
	DENS_MAN * source,
	VectorDependencyManager<SPAR_MAT * > * gradientMatrices) :
	MatToMatTransfer<double>(source),
	gradientMatrices_(gradientMatrices)
	{
	gradientMatrices_->register_dependence(this);
	}

	//--------------------------------------------------------
	// Destructor
	//--------------------------------------------------------
	MatToGradBySparse::~MatToGradBySparse()
	{
	gradientMatrices_->remove_dependence(this);
	}

	//--------------------------------------------------------
	// reset_quantity
	//--------------------------------------------------------
	void MatToGradBySparse::reset_quantity() const
	{
	const DENS_MAT & source(source_->quantity());
	const SPAR_MAT_VEC & gradientMatrices(gradientMatrices_->quantity());
	int nsd = gradientMatrices.size();
	int nNodes = source.nRows();
	int nCols = source.nCols();
	quantity_.reset(nNodes,nCols*nsd);

	int index = 0;
	for (int n = 0; n < nCols; n++) {
	for (int m = 0; m < nsd; m++) {
	CLON_VEC inData(source,CLONE_COL,n);
	CLON_VEC outData(quantity_,CLONE_COL,index);
	outData = ((gradientMatrices[m]))inData;
	++index;
	}
	}
	}

	}

TransferOperator.cppNo OneTemporaryActions

File Metadata

TransferOperator.cppView Options

Event Timeline

TransferOperator.cpp
No OneTemporary
Actions

TransferOperator.cpp
View Options