Homec4science
Diffusion lammps (efficient_neuronet) Browse

lammps/lib/atc/GhostManager.h
7d77aea42d30efficient_neuronet

Last Change
Raw File

GhostManager.h
View Options

#ifndef GHOST_MANAGER_H
#define GHOST_MANAGER_H
// ATC headers
#include "MatrixLibrary.h"
#include "PerAtomQuantityLibrary.h"
#include "TimeIntegrator.h"
#include "ATC_TypeDefs.h"
namespace ATC {
// forward declarations
class ATC_Method;
class GhostModifier;
class LammpsInterface;
/**
* @class GhostManager
* @brief Manages methods for modifying ghost atoms
*/
class GhostManager {
public:
/** types of ghost boundary conditions in momentum */
enum BoundaryDynamicsType {
NO_BOUNDARY_DYNAMICS=0,
VERLET, // performs velocity-verlet
PRESCRIBED, // forces ghost locations to conform to interpolated finite element locations
DAMPED_HARMONIC, // turns ghost atoms into spring-mass-dashpot systems
DAMPED_LAYERS, // oer layer DAMPED_HARMONIC
COUPLED, // applies a spring-dashpot force to the ghosts
SWAP, // exchanges ghost and real atoms when they cross AtC boundaries
SWAP_VERLET // like above, but integrates the ghosts using velocity verlet
};
// constructor
GhostManager(ATC_Method * atc);
// destructor
virtual ~GhostManager();
/** parser/modifier */
virtual bool modify(int narg, char **arg);
/** create objects to implement requested numerical method */
virtual void construct_methods();
/** create and get necessary transfer operators */
virtual void construct_transfers();
/** pre time integration initialization of data */
virtual void initialize();
/** prior to lammps exchange */
virtual void pre_exchange();
/** Predictor phase, Verlet first step for velocity */
virtual void init_integrate_velocity(double dt);
/** Predictor phase, Verlet first step for position */
virtual void init_integrate_position(double dt);
/** set positions after integration */
virtual void post_init_integrate();
/** Corrector phase, Verlet second step for velocity */
virtual void final_integrate(double dt);
/** sets the boundary dynamics flag as desired */
void set_boundary_dynamics(BoundaryDynamicsType boundaryDynamics) {boundaryDynamics_ = boundaryDynamics;}
/** flag for reset */
bool need_reset() const {return needReset_;};
/** access to ATC method object */
ATC_Method * atc() {return atc_;};
protected:
/** pointer to routines that modify ghosts */
GhostModifier* ghostModifier_;
/** pointer to access ATC methods */
ATC_Method * atc_;
/** boundary dynamics method type */
BoundaryDynamicsType boundaryDynamics_;
/** flag for reset */
bool needReset_;
/** spring constant for some models */
std::vector<double> kappa_;
/** damping constant for some models */
std::vector<double> gamma_;
/** ratio between mass of ghost types and desired mass for some models */
std::vector<double> mu_;
private:
// DO NOT define this
GhostManager();
};
/**
* @class GhostModifier
* @brief Base class for objects which modify the ghost atoms, integrates ghost atoms using velocity-verlet if requested
*/
class GhostModifier {
public:
// constructor
GhostModifier(GhostManager * ghostManager);
// destructor
virtual ~GhostModifier();
/** create and get necessary transfer operators */
virtual void construct_transfers();
/** pre time integration initialization of data */
virtual void initialize(){};
/** Predictor phase, Verlet first step for velocity */
virtual void init_integrate_velocity(double dt);
/** Predictor phase, Verlet first step for position */
virtual void init_integrate_position(double dt);
/** set positions after integration */
virtual void post_init_integrate(){};
/** prior to lammps exchange */
virtual void pre_exchange(){};
/** Corrector phase, Verlet second step for velocity */
virtual void final_integrate(double dt);
/** sets the verlet integration flag as desired */
void set_integrate_atoms(bool integrateAtoms) {integrateAtoms_ = integrateAtoms;}
protected:
/** owning ghost manager */
GhostManager * ghostManager_;
/** object which integrates atoms */
AtomTimeIntegrator * atomTimeIntegrator_;
/** flag to perform velocity-verlet integration of ghosts */
bool integrateAtoms_;
private:
// DO NOT define this
GhostModifier();
};
/**
* @class GhostModifierPrescribed
* @brief sets ghost atom positions based on FE displacement
*/
class GhostModifierPrescribed : public GhostModifier {
public:
// constructor
GhostModifierPrescribed(GhostManager * ghostManager);
// destructor
virtual ~GhostModifierPrescribed(){};
/** create and get necessary transfer operators */
virtual void construct_transfers();
/** set positions after integration */
virtual void post_init_integrate();
protected:
/** positions of atoms */
PerAtomQuantity<double> * atomPositions_;
/** FE displacement at ghost locations */
PerAtomQuantity<double> * atomFeDisplacement_;
/** atom reference positions */
PerAtomQuantity<double> * atomRefPositions_;
private:
// DO NOT define this
GhostModifierPrescribed();
};
/**
* @class GhostModifierDampedHarmonic
* @brief Integrates ghost atoms using velocity-verlet with a damped harmonic force
*/
class GhostModifierDampedHarmonic : public GhostModifierPrescribed {
public:
// constructor
GhostModifierDampedHarmonic(GhostManager * ghostManager,
const std::vector<double> & kappa,
const std::vector<double> & gamma,
const std::vector<double> & mu);
// destructor
virtual ~GhostModifierDampedHarmonic(){};
/** create and get necessary transfer operators */
virtual void construct_transfers();
#if true
/** Predictor phase, Verlet first step for velocity */
virtual void init_integrate_velocity(double dt);
/** Predictor phase, Verlet first step for position */
virtual void init_integrate_position(double dt);
#endif
/** set positions after integration */
virtual void post_init_integrate(){};
/** Corrector phase, Verlet second step for velocity */
virtual void final_integrate(double dt);
protected:
/** velocities of atoms */
PerAtomQuantity<double> * atomVelocities_;
/** FE velocity at ghost locations */
PerAtomQuantity<double> * atomFeVelocity_;
/** atom forces */
PerAtomQuantity<double> * atomForces_;
/** effective spring constant for potential */
double k0_;
/** spring constant */
const std::vector<double> & kappa_;
/** damping constant */
const std::vector<double> & gamma_;
/** ratio between mass of ghost types and desired mass */
const std::vector<double> & mu_;
// workspace
DENS_MAT _forces_;
private:
// DO NOT define this
GhostModifierDampedHarmonic();
};
/**
* @class GhostModifierDampedHarmonicLayers
* @brief Integrates ghost atoms using velocity-verlet with a damped harmonic force based on which layer the atom resides in
*/
class GhostModifierDampedHarmonicLayers : public GhostModifierDampedHarmonic {
public:
// constructor
GhostModifierDampedHarmonicLayers(GhostManager * ghostManager,
const std::vector<double> & kappa,
const std::vector<double> & gamma,
const std::vector<double> & mu);
// destructor
virtual ~GhostModifierDampedHarmonicLayers(){};
/** create and get necessary transfer operators */
virtual void construct_transfers();
/** pre time integration initialization of data */
virtual void initialize();
/** Corrector phase, Verlet second step for velocity */
virtual void final_integrate(double dt);
protected:
// methods
/** compute distance of ghost atom to boundary */
void compute_distances();
/** sorting heuristics to identify layers */
int find_layers();
// data
/** distance from all ghost atoms to boundary, i.e. boundary face of containing element */
PerAtomQuantity<double> * ghostToBoundaryDistance_;
/** layer id for ghost atoms */
PerAtomQuantity<int> * layerId_;
private:
// DO NOT define this
GhostModifierDampedHarmonicLayers();
};
/**
* @class GhostIntegratorSwap
* @brief Integrates ghost atoms using velocity-verlet, and swaps atoms between ghost
* and internal depending on what element they are in
*/
class GhostIntegratorSwap : public GhostModifier {
public:
// constructor
GhostIntegratorSwap(GhostManager * ghostManager);
// destructor
virtual ~GhostIntegratorSwap(){};
/** create and get necessary transfer operators */
virtual void construct_transfers();
/** pre time integration initialization of data */
virtual void initialize();
/** prior to lammps exchange */
virtual void pre_exchange();
protected:
/** pointer to lammps interface */
LammpsInterface * lammpsInterface_;
/** internal element set */
const std::set<int> & elementSet_;
/** internal to element map */
PerAtomQuantity<int> * atomElement_;
/** ghost to element map */
PerAtomQuantity<int> * atomGhostElement_;
/** internal to atom map */
const Array<int> & internalToAtom_;
/** ghost to atom map */
const Array<int> & ghostToAtom_;
/** group bit for internal */
int groupbit_;
/** group bit for ghost */
int groupbitGhost_;
private:
// DO NOT define this
GhostIntegratorSwap();
};
};
#endif
c4science · Help