forked from lijiext/lammps
634 lines
20 KiB
C++
634 lines
20 KiB
C++
/** Atomic Regulator : a base class class for atom-continuum control */
|
|
|
|
#ifndef ATOMICREGULATOR_H
|
|
#define ATOMICREGULATOR_H
|
|
|
|
#include "ATC_TypeDefs.h"
|
|
#include <map>
|
|
#include <set>
|
|
#include <vector>
|
|
#include <utility>
|
|
#include <string>
|
|
|
|
namespace ATC {
|
|
|
|
static const int myMaxIterations = 0;
|
|
static const double myTolerance = 1.e-10;
|
|
|
|
// forward declarations
|
|
class TimeFilter;
|
|
class RegulatorMethod;
|
|
class LambdaMatrixSolver;
|
|
class ATC_Coupling;
|
|
class NodeToSubset;
|
|
class SubsetToNode;
|
|
class RegulatedNodes;
|
|
class ElementMaskNodeSet;
|
|
class LargeToSmallAtomMap;
|
|
template <typename T>
|
|
class PerAtomQuantity;
|
|
template <typename T>
|
|
class ProtectedAtomQuantity;
|
|
template <typename T>
|
|
class PerAtomSparseMatrix;
|
|
|
|
/**
|
|
* @class AtomicRegulator
|
|
* @brief Base class for atom-continuum control
|
|
*/
|
|
|
|
//--------------------------------------------------------
|
|
//--------------------------------------------------------
|
|
// Class AtomicRegulator
|
|
//--------------------------------------------------------
|
|
//--------------------------------------------------------
|
|
|
|
class AtomicRegulator {
|
|
|
|
public:
|
|
|
|
/** linear solver types */
|
|
enum LinearSolverType {
|
|
NO_SOLVE=0,
|
|
CG_SOLVE, // conjugate gradient
|
|
RSL_SOLVE // row-sum lumping solution
|
|
};
|
|
|
|
/** regulator target variable */
|
|
enum RegulatorTargetType {
|
|
NONE=0,
|
|
FIELD,
|
|
DERIVATIVE,
|
|
DYNAMICS
|
|
};
|
|
|
|
enum RegulatorCouplingType {
|
|
UNCOUPLED=0,
|
|
FLUX,
|
|
GHOST_FLUX,
|
|
FIXED
|
|
};
|
|
|
|
// constructor
|
|
AtomicRegulator(ATC_Coupling * atc,
|
|
const std::string & regulatorPrefix = "");
|
|
|
|
// destructor
|
|
virtual ~AtomicRegulator();
|
|
|
|
/** parser/modifier */
|
|
virtual bool modify(int narg, char **arg);
|
|
|
|
/** instantiate up the desired method(s) */
|
|
virtual void construct_methods() = 0;
|
|
|
|
/** method(s) create all necessary transfer operators */
|
|
virtual void construct_transfers();
|
|
|
|
/** initialization of method data */
|
|
virtual void initialize();
|
|
|
|
/** add output information */
|
|
virtual void output(OUTPUT_LIST & outputData) const;
|
|
virtual double compute_vector(int /* n */) const {return 0;}
|
|
|
|
/** final work at the end of a run */
|
|
virtual void finish();
|
|
|
|
/** reset number of local atoms, as well as atomic data */
|
|
virtual void reset_nlocal();
|
|
|
|
/** set up atom to material identification */
|
|
virtual void reset_atom_materials(const Array<int> & elementToMaterialMap,
|
|
const MatrixDependencyManager<DenseMatrix, int> * atomElement);
|
|
|
|
// application steps
|
|
/** apply the regulator in the pre-predictor phase */
|
|
virtual void apply_pre_predictor(double dt, int timeStep);
|
|
/** apply the regulator in the mid-predictor phase */
|
|
virtual void apply_mid_predictor(double dt, int timeStep);
|
|
/** apply the regulator in the post-predictor phase */
|
|
virtual void apply_post_predictor(double dt, int timeStep);
|
|
/** apply the regulator in the pre-correction phase */
|
|
virtual void apply_pre_corrector(double dt, int timeStep);
|
|
/** apply the regulator in the post-correction phase */
|
|
virtual void apply_post_corrector(double dt, int timeStep);
|
|
|
|
/** prior to exchanges */
|
|
virtual void pre_force();
|
|
/** prior to exchanges */
|
|
virtual void pre_exchange();
|
|
|
|
/** pack fields for restart */
|
|
virtual void pack_fields(RESTART_LIST & data);
|
|
|
|
/** thermo output */
|
|
virtual int size_vector(int /* s */) const {return 0;};
|
|
|
|
// coupling to FE state
|
|
/** FE state variable regulator is applied to */
|
|
virtual RegulatorTargetType regulator_target() const {return regulatorTarget_;};
|
|
/** type of boundary coupling */
|
|
//TEMP_JAT field variable should be removed
|
|
virtual RegulatorCouplingType coupling_mode(const FieldName /* field */) const {return couplingMode_;};
|
|
virtual RegulatorCouplingType coupling_mode() const {return couplingMode_;};
|
|
/** compute the thermal boundary flux, must be consistent with regulator */
|
|
virtual void compute_boundary_flux(FIELDS & fields);
|
|
/** add contributions (if any) to the finite element right-hand side */
|
|
virtual void add_to_rhs(FIELDS & rhs);
|
|
|
|
// data access, intended for method objects
|
|
/** returns a pointer to the DENS_MAN associated with the tag, creates a new data member if necessary */
|
|
DENS_MAN * regulator_data(const std::string tag, int nCols);
|
|
/** can externally set regulator dynamic contributions */
|
|
virtual void reset_lambda_contribution(const DENS_MAT & /* target */, const FieldName /* field */) {};
|
|
virtual void reset_lambda_contribution(const DENS_MAT & target) { reset_lambda_contribution(target,NUM_TOTAL_FIELDS); }
|
|
/** returns a const pointer to the DENS_MAN associated with the tag, or NULL */
|
|
const DENS_MAN * regulator_data(const std::string tag) const;
|
|
/** return the maximum number of iterations */
|
|
int max_iterations() {return maxIterations_;};
|
|
/** return the solver tolerance */
|
|
double tolerance() {return tolerance_;};
|
|
/** access for ATC transfer */
|
|
ATC_Coupling * atc_transfer() {return atc_;};
|
|
/** access for time filter */
|
|
TimeFilter * time_filter() {return timeFilter_;};
|
|
/** access for number of nodes */
|
|
int num_nodes() {return nNodes_;};
|
|
/** access for number of spatial dimensions */
|
|
int nsd() {return nsd_;};
|
|
/** access for number of local atoms */
|
|
int nlocal() {return nLocal_;};
|
|
/** access for boundary integration methods */
|
|
BoundaryIntegrationType boundary_integration_type()
|
|
{return boundaryIntegrationType_;};
|
|
/** access for boundary face sets */
|
|
const std::set< std::pair<int,int> > * face_sets()
|
|
{ return boundaryFaceSet_;};
|
|
/** access for needing a reset */
|
|
bool need_reset() const {return needReset_;};
|
|
/** force a reset to occur */
|
|
void force_reset() {needReset_ = true;};
|
|
/** check if lambda is localized */
|
|
bool use_localized_lambda() const {return useLocalizedLambda_;};
|
|
/** check if matrix should be lumpted for lambda solve */
|
|
bool use_lumped_lambda_solve() const {return useLumpedLambda_;};
|
|
/** check to see if this direction is being used */
|
|
bool apply_in_direction(int i) const {return applyInDirection_[i];};
|
|
|
|
|
|
/** checks if there are any fixed nodes in the MD region */
|
|
bool md_fixed_nodes(FieldName fieldName = NUM_TOTAL_FIELDS) const;
|
|
|
|
/** checks if there are any flux nodes in the MD region */
|
|
bool md_flux_nodes(FieldName fieldName = NUM_TOTAL_FIELDS) const;
|
|
|
|
/** returns prefix tag for regulator */
|
|
const std::string & regulator_prefix() const {return regulatorPrefix_;};
|
|
|
|
protected:
|
|
|
|
// methods
|
|
/** deletes the current regulator method */
|
|
void delete_method();
|
|
|
|
/** deletes all unused data */
|
|
void delete_unused_data();
|
|
|
|
/** sets all data to be unused */
|
|
void set_all_data_to_unused();
|
|
|
|
/** sets all data to be used */
|
|
void set_all_data_to_used();
|
|
|
|
// data
|
|
/** point to atc_transfer object */
|
|
ATC_Coupling * atc_;
|
|
|
|
/** how often in number of time steps regulator is applied */
|
|
int howOften_;
|
|
|
|
// reset/reinitialize flags
|
|
/** flag to reset data */
|
|
bool needReset_;
|
|
/** reinitialize method */
|
|
void reset_method();
|
|
|
|
// regulator data
|
|
/** container for all data, string is tag, bool is false if currently in use */
|
|
std::map<std::string, std::pair<bool,DENS_MAN * > > regulatorData_;
|
|
|
|
/** maximum number of iterations used in solving for lambda */
|
|
int maxIterations_;
|
|
/** tolerance used in solving for lambda */
|
|
double tolerance_;
|
|
|
|
/** regulator target flag */
|
|
RegulatorTargetType regulatorTarget_;
|
|
/** regulator fe coupling type flag */
|
|
RegulatorCouplingType couplingMode_;
|
|
|
|
/** number of nodes */
|
|
int nNodes_;
|
|
/** number of spatial dimensions */
|
|
int nsd_;
|
|
/** number of local atoms */
|
|
int nLocal_;
|
|
|
|
/** use of localization techniques */
|
|
bool useLocalizedLambda_;
|
|
bool useLumpedLambda_;
|
|
|
|
/** restrict application in certain directions */
|
|
std::vector<bool> applyInDirection_;
|
|
|
|
// method pointers
|
|
/** time filtering object */
|
|
TimeFilter * timeFilter_;
|
|
/** sets up and solves the regulator equations */
|
|
RegulatorMethod * regulatorMethod_;
|
|
|
|
// boundary flux information
|
|
BoundaryIntegrationType boundaryIntegrationType_;
|
|
const std::set< std::pair<int,int> > * boundaryFaceSet_;
|
|
|
|
/** prefix string for registering data */
|
|
const std::string regulatorPrefix_;
|
|
|
|
private:
|
|
|
|
// DO NOT define this
|
|
AtomicRegulator();
|
|
|
|
};
|
|
|
|
/**
|
|
* @class RegulatorMethod
|
|
* @brief Base class for implementation of control algorithms
|
|
*/
|
|
|
|
//--------------------------------------------------------
|
|
//--------------------------------------------------------
|
|
// Class RegulatorMethod
|
|
//--------------------------------------------------------
|
|
//--------------------------------------------------------
|
|
|
|
class RegulatorMethod {
|
|
|
|
public:
|
|
|
|
RegulatorMethod(AtomicRegulator * atomicRegulator,
|
|
const std::string & regulatorPrefix = "");
|
|
|
|
virtual ~RegulatorMethod(){};
|
|
|
|
/** instantiate all needed data */
|
|
virtual void construct_transfers(){};
|
|
|
|
/** pre-"run" initialization */
|
|
virtual void initialize(){};
|
|
|
|
/** reset number of local atoms, as well as atomic data */
|
|
virtual void reset_nlocal(){};
|
|
|
|
/** set up atom to material identification */
|
|
virtual void reset_atom_materials(const Array<int> & /* elementToMaterialMap */,
|
|
const MatrixDependencyManager<DenseMatrix, int> * /* atomElement */){};
|
|
|
|
/** applies regulator to atoms in the pre-predictor phase */
|
|
virtual void apply_pre_predictor(double /* dt */){};
|
|
|
|
/** applies regulator to atoms in the mid-predictor phase */
|
|
virtual void apply_mid_predictor(double /* dt */){};
|
|
|
|
/** applies regulator to atoms in the post-predictor phase */
|
|
virtual void apply_post_predictor(double /* dt */){};
|
|
|
|
/** applies regulator to atoms in the pre-corrector phase */
|
|
virtual void apply_pre_corrector(double /* dt */){};
|
|
|
|
/** applies regulator to atoms in the post-corrector phase */
|
|
virtual void apply_post_corrector(double /* dt */){};
|
|
|
|
/** applies regulator to atoms in the pre-corrector phase */
|
|
virtual void apply_pre_force(double /* dt */){};
|
|
|
|
/** applies regulator to atoms in the post-corrector phase */
|
|
virtual void apply_post_force(double /* dt */){};
|
|
|
|
/** applies regulator in pre-force phase */
|
|
virtual void pre_force(){};
|
|
|
|
/** applies regulator in pre-exchange phase */
|
|
virtual void pre_exchange(){};
|
|
|
|
/** applies regulator in post-exchange phase */
|
|
virtual void post_exchange(){};
|
|
|
|
/** compute boundary flux, requires regulator input since it is part of the coupling scheme */
|
|
virtual void compute_boundary_flux(FIELDS & fields);
|
|
|
|
/** add contributions (if any) to the finite element right-hand side */
|
|
virtual void add_to_rhs(FIELDS & /* rhs */){};
|
|
|
|
/** get data for output */
|
|
virtual void output(OUTPUT_LIST & /* outputData */){};
|
|
virtual double compute_vector(int /* n */) const {return 0;}
|
|
|
|
/** final work at the end of a run */
|
|
virtual void finish(){};
|
|
|
|
/** pack fields for restart */
|
|
virtual void pack_fields(RESTART_LIST & /* data */){};
|
|
|
|
protected:
|
|
|
|
//data
|
|
/** pointer to atomic regulator object for data */
|
|
AtomicRegulator * atomicRegulator_;
|
|
|
|
/** pointer to ATC_transfer object */
|
|
ATC_Coupling * atc_;
|
|
|
|
/** boundary flux */
|
|
FIELDS & boundaryFlux_;
|
|
|
|
/** field mask for specifying boundary flux */
|
|
Array2D<bool> fieldMask_;
|
|
|
|
/** number of nodes */
|
|
int nNodes_;
|
|
|
|
/** prefix string for registering data */
|
|
const std::string regulatorPrefix_;
|
|
|
|
/** mapping for atom materials for atomic FE quadrature */
|
|
Array<std::set<int> > atomMaterialGroups_;
|
|
|
|
/** shape function derivative matrices for boundary atoms */
|
|
VectorDependencyManager<SPAR_MAT * > * shpFcnDerivs_;
|
|
|
|
private:
|
|
|
|
// DO NOT define this
|
|
RegulatorMethod();
|
|
|
|
};
|
|
|
|
/**
|
|
* @class RegulatorShapeFunction
|
|
* @brief Base class for implementation of regulation algorithms using the shape function matrices
|
|
*/
|
|
// DESIGN each regulator handles only one lambda, but solvers and data are added later
|
|
// add a new function to set the linear solver based on enum CG_SOLVE or RSL_SOLVE and shape function matrix
|
|
// followed by call to compute sparsity pattern
|
|
//--------------------------------------------------------
|
|
//--------------------------------------------------------
|
|
// Class RegulatorShapeFunction
|
|
// base class for all regulators of general form
|
|
// of N^T w N lambda = rhs
|
|
//--------------------------------------------------------
|
|
//--------------------------------------------------------
|
|
|
|
class RegulatorShapeFunction : public RegulatorMethod {
|
|
|
|
public:
|
|
|
|
RegulatorShapeFunction(AtomicRegulator * atomicRegulator,
|
|
const std::string & regulatorPrefix = "");
|
|
|
|
virtual ~RegulatorShapeFunction();
|
|
|
|
/** instantiate all needed data */
|
|
virtual void construct_transfers();
|
|
|
|
/** pre-"run" initialization */
|
|
virtual void initialize();
|
|
|
|
/** sets lambda to an initial value */
|
|
virtual void set_lambda_to_value(double value) {*lambda_ = value;}
|
|
|
|
/** reset number of local atoms, as well as atomic data */
|
|
virtual void reset_nlocal();
|
|
|
|
/** set up atom to material identification */
|
|
virtual void reset_atom_materials(const Array<int> & elementToMaterialMap,
|
|
const MatrixDependencyManager<DenseMatrix, int> * atomElement);
|
|
|
|
/** compute boundary flux, requires regulator input since it is part of the coupling scheme */
|
|
virtual void compute_boundary_flux(FIELDS & fields);
|
|
|
|
/** access to nodes the thermostat is applied to */
|
|
const SetDependencyManager<int> * application_nodes() const {return applicationNodes_;};
|
|
|
|
/** determine if local shape function matrices are needed */
|
|
virtual bool use_local_shape_functions() const {return false;};
|
|
|
|
protected:
|
|
|
|
// methods
|
|
/** compute sparsity for matrix */
|
|
void compute_sparsity(void);
|
|
|
|
/** solve matrix equation */
|
|
void solve_for_lambda(const DENS_MAT & rhs,
|
|
DENS_MAT & lambda);
|
|
|
|
/** set weighting factor for in matrix Nhat^T * weights * Nhat */
|
|
virtual void set_weights() = 0;
|
|
|
|
/** Mapping between unique nodes and nodes overlapping MD region */
|
|
void map_unique_to_overlap(const MATRIX & uniqueData,
|
|
MATRIX & overlapData);
|
|
|
|
/** Mapping between nodes overlapping MD region to unique nodes */
|
|
void map_overlap_to_unique(const MATRIX & overlapData,
|
|
MATRIX & uniqueData);
|
|
|
|
/** sets up the transfer which is the set of nodes being regulated */
|
|
virtual void construct_regulated_nodes();
|
|
|
|
/** creates data structure needed for all to regulated node maps */
|
|
virtual void create_node_maps();
|
|
|
|
// member data
|
|
/** lambda coupling parameter */
|
|
DENS_MAN * lambda_;
|
|
|
|
/** lambda at atomic locations */
|
|
PerAtomQuantity<double> * atomLambdas_;
|
|
|
|
/** shape function matrix for use in GLC solve */
|
|
PerAtomSparseMatrix<double> * shapeFunctionMatrix_;
|
|
|
|
/** algorithm being used for the linear solver */
|
|
AtomicRegulator::LinearSolverType linearSolverType_;
|
|
|
|
/** pre-templated sparsity pattern for N^T * T * N */
|
|
SPAR_MAN matrixTemplate_;
|
|
|
|
/** maximum number of iterations used in solving for lambda */
|
|
int maxIterations_;
|
|
|
|
/** tolerance used in solving for lambda */
|
|
double tolerance_;
|
|
|
|
/** matrix solver object */
|
|
LambdaMatrixSolver * matrixSolver_;
|
|
|
|
/** set of nodes used to construct matrix */
|
|
SetDependencyManager<int> * regulatedNodes_;
|
|
|
|
/** set of nodes on which lambda is non-zero */
|
|
SetDependencyManager<int> * applicationNodes_;
|
|
|
|
/** set of nodes needed for localized boundary quadrature */
|
|
SetDependencyManager<int> * boundaryNodes_;
|
|
|
|
/** mapping from all nodes to overlap nodes: -1 is no overlap, otherwise entry is overlap index */
|
|
NodeToSubset * nodeToOverlapMap_;
|
|
|
|
/** mapping from overlap nodes to unique nodes */
|
|
SubsetToNode * overlapToNodeMap_;
|
|
|
|
/** shape function matrix for boundary atoms */
|
|
SPAR_MAN * shpFcn_;
|
|
|
|
/** atomic weights for boundary atoms */
|
|
DIAG_MAN * atomicWeights_;
|
|
|
|
/** element mask for boundary elements corresponding to nodeToOverlapMap_ */
|
|
MatrixDependencyManager<ATC_matrix::DenseMatrix, bool> * elementMask_;
|
|
|
|
/** maps atoms from atc indexing to regulator indexing */
|
|
LargeToSmallAtomMap * lambdaAtomMap_;
|
|
|
|
/** weight per-atom transfer */
|
|
PerAtomQuantity<double> * weights_;
|
|
|
|
/** number of spatial dimensions */
|
|
int nsd_;
|
|
|
|
/** number of ATC internal atoms on this processor */
|
|
int nLocal_;
|
|
|
|
private:
|
|
|
|
// DO NOT define this
|
|
RegulatorShapeFunction();
|
|
|
|
};
|
|
|
|
//--------------------------------------------------------
|
|
//--------------------------------------------------------
|
|
// Class LambdaMatrixSolver
|
|
//--------------------------------------------------------
|
|
//--------------------------------------------------------
|
|
|
|
class LambdaMatrixSolver {
|
|
|
|
public:
|
|
|
|
LambdaMatrixSolver(SPAR_MAN & matrixTemplate, SPAR_MAN * shapeFunctionMatrix, int maxIterations, double tolerance);
|
|
|
|
virtual ~LambdaMatrixSolver(){};
|
|
|
|
/** assemble the matrix */
|
|
virtual void assemble_matrix(DIAG_MAT & weights);
|
|
|
|
/** execute the solver */
|
|
virtual void execute(VECTOR & rhs, VECTOR & lambda)=0;
|
|
|
|
protected:
|
|
|
|
/** sparse template for the matrix */
|
|
SPAR_MAN & matrixTemplate_;
|
|
|
|
/** non-symmetric part of the matrix */
|
|
SPAR_MAN * shapeFunctionMatrix_;
|
|
|
|
/** matrix used to solve for lambda */
|
|
SPAR_MAT lambdaMatrix_;
|
|
|
|
/** maximum number of iterations */
|
|
int maxIterations_;
|
|
|
|
/** relative tolerance to solve to */
|
|
double tolerance_;
|
|
|
|
private:
|
|
|
|
// DO NOT define this
|
|
LambdaMatrixSolver();
|
|
|
|
};
|
|
|
|
//--------------------------------------------------------
|
|
//--------------------------------------------------------
|
|
// Class LambdaMatrixSolverLumped
|
|
//--------------------------------------------------------
|
|
//--------------------------------------------------------
|
|
|
|
class LambdaMatrixSolverLumped : public LambdaMatrixSolver {
|
|
|
|
public:
|
|
|
|
LambdaMatrixSolverLumped(SPAR_MAN & matrixTemplate, SPAR_MAN * shapeFunctionMatrix, int maxIterations, double tolerance, const SetDependencyManager<int> * applicationNodes, const NodeToSubset * nodeToOverlapMap);
|
|
|
|
virtual ~LambdaMatrixSolverLumped(){};
|
|
|
|
/** assemble the matrix */
|
|
virtual void assemble_matrix(DIAG_MAT & weights);
|
|
|
|
/** execute the solver */
|
|
virtual void execute(VECTOR & rhs, VECTOR & lambda);
|
|
|
|
protected:
|
|
|
|
/** lumped version of the matrix governing lambda */
|
|
DIAG_MAT lumpedMatrix_;
|
|
|
|
/** set of regulated nodes */
|
|
const SetDependencyManager<int> * applicationNodes_;
|
|
|
|
/** mapping from all nodes to overlap nodes: -1 is no overlap, otherwise entry is overlap index */
|
|
const NodeToSubset * nodeToOverlapMap_;
|
|
|
|
private:
|
|
|
|
// DO NOT define this
|
|
LambdaMatrixSolverLumped();
|
|
|
|
};
|
|
|
|
//--------------------------------------------------------
|
|
//--------------------------------------------------------
|
|
// Class LambdaMatrixSolverCg
|
|
//--------------------------------------------------------
|
|
//--------------------------------------------------------
|
|
|
|
class LambdaMatrixSolverCg : public LambdaMatrixSolver {
|
|
|
|
public:
|
|
|
|
LambdaMatrixSolverCg(SPAR_MAN & matrixTemplate, SPAR_MAN * shapeFunctionMatrix, int maxIterations, double tolerance);
|
|
|
|
virtual ~LambdaMatrixSolverCg(){};
|
|
|
|
/** execute the solver */
|
|
virtual void execute(VECTOR & rhs, VECTOR & lambda);
|
|
|
|
protected:
|
|
|
|
|
|
private:
|
|
|
|
// DO NOT define this
|
|
LambdaMatrixSolverCg();
|
|
|
|
};
|
|
|
|
};
|
|
|
|
#endif
|