#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 kappa_; /** damping constant for some models */ std::vector gamma_; /** ratio between mass of ghost types and desired mass for some models */ std::vector 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 * atomPositions_; /** FE displacement at ghost locations */ PerAtomQuantity * atomFeDisplacement_; /** atom reference positions */ PerAtomQuantity * 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 & kappa, const std::vector & gamma, const std::vector & 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 * atomVelocities_; /** FE velocity at ghost locations */ PerAtomQuantity * atomFeVelocity_; /** atom forces */ PerAtomQuantity * atomForces_; /** effective spring constant for potential */ double k0_; /** spring constant */ const std::vector & kappa_; /** damping constant */ const std::vector & gamma_; /** ratio between mass of ghost types and desired mass */ const std::vector & 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 & kappa, const std::vector & gamma, const std::vector & 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 * ghostToBoundaryDistance_; /** layer id for ghost atoms */ PerAtomQuantity * 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 & elementSet_; /** internal to element map */ PerAtomQuantity * atomElement_; /** ghost to element map */ PerAtomQuantity * atomGhostElement_; /** internal to atom map */ const Array & internalToAtom_; /** ghost to atom map */ const Array & ghostToAtom_; /** group bit for internal */ int groupbit_; /** group bit for ghost */ int groupbitGhost_; private: // DO NOT define this GhostIntegratorSwap(); }; }; #endif