DataManager.h

//  Copyright (c) 2019 Prashant K. Jha
//  Copyright (c) 2019 Patrick Diehl
//
//  Distributed under the Boost Software License, Version 1.0. (See accompanying
//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
#ifndef SRC_DATA_DATAMANAGER_H_
#define SRC_DATA_DATAMANAGER_H_
 
#include "util/point.h"
 
#include <vector>
 
// forward declaration of class
namespace fe {
class MassMatrix;
class Mesh;
// class Quadrature;
}// namespace fe
 
namespace geometry {
class Fracture;
class InteriorFlags;
class Neighbor;
class VolumeCorrection;
} // namespace geometry
 
namespace inp {
struct ModelDeck;
struct RestartDeck;
struct OutputDeck;
class Input;
class Policy;
} // namespace inp
 
namespace loading {
class InitialCondition;
class ULoading;
class FLoading;
} // namespace loading
 
namespace material {
namespace pd {
class BaseMaterial;
}
} // namespace material
 
namespace util {
class StateBasedHelperFunctions;
} // namespace util
 
namespace data {
 
class DataManager {
 
public:
 
    DataManager();
 
    void setModelDeckP(inp::ModelDeck *pointer);
 
    inp::ModelDeck* getModelDeckP();
 
    void setOutputDeckP(inp::OutputDeck *pointer);
 
    inp::OutputDeck* getOutputDeckP();
 
    void setBodyForceP(std::vector<util::Point3> *pointer);
 
    std::vector<util::Point3>* getBodyForceP();
 
    void setForceP(std::vector<util::Point3> *pointer);
 
    std::vector<util::Point3>* getForceP();
 
    void setReactionForceP(std::vector<util::Point3> *pointer);
 
    std::vector<util::Point3>* getReactionForceP();
 
    void setVelocityP(std::vector<util::Point3> *pointer);
 
    std::vector<util::Point3>* getVelocityP();
 
    void setDisplacementP(std::vector<util::Point3> *pointer);
 
 
    std::vector<util::Point3>* getDisplacementP();
 
    void setMeshP(fe::Mesh *d_mesh_p);
 
 
    fe::Mesh* getMeshP();
 
    void setNeighborP(geometry::Neighbor *d_neighbor_p);
 
    geometry::Neighbor* getNeighborP();
 
    void setVolumeCorrectionP(geometry::VolumeCorrection* pointer);
 
 
    geometry::VolumeCorrection* getVolumeCorrectionP();
 
  void setFractureP(geometry::Fracture *pointer);
 
 
  geometry::InteriorFlags* getInteriorFlagsP();
 
  void setInteriorFlagsP(geometry::InteriorFlags *pointer);
 
 
  geometry::Fracture* getFractureP();
 
    void setStateBasedHelperFunctionsP(util::StateBasedHelperFunctions* pointer);
 
    util::StateBasedHelperFunctions* getStateBasedHelperFunctionsP();
 
    void setDisplacementLoadingP(loading::ULoading * pointer);
 
 
    loading::ULoading* getDisplacementLoadingP();
 
    void setForceLoadingP(loading::FLoading * pointer);
 
    loading::FLoading* getForceLoadingP();
 
    void setExtensionP(std::vector<std::vector<double>>* pointer);
 
 
    std::vector<std::vector<double>>* getExtensionP();
 
    void setStressTensorP(std::vector<util::Matrix33>* pointer);
 
 
    std::vector<util::Matrix33>* getStressTensorP();
 
    void setStrainTensorP(std::vector<util::Matrix33>* pointer);
 
    std::vector<util::Matrix33>* getStrainTensorP();
 
    void setDilatationP(std::vector<double> * pointer);
 
    std::vector<double> * getDilatationP();
 
  void setWeightedVolP(std::vector<double> * pointer);
 
  std::vector<double> * getWeightedVolP();
 
    void setTotalReactionForceP(std::vector<double>* pointer);
 
 
    std::vector<double>* getTotalReactionForceP();
 
    void setStrainEnergyP(std::vector<float>* pointer);
 
    std::vector<float>* getStrainEnergyP();
 
    void setWorkDoneP(std::vector<float>* pointer);
 
    std::vector<float>* getWorkDoneP();
 
    void setPhiP(std::vector<float>* pointer);
 
 
 
    std::vector<float>* getPhiP();
 
    void setDamageFunctionP(std::vector<float>* pointer);
 
 
    std::vector<float>* getDamageFunctionP();
 
    void setBBFractureEnergyP(std::vector<float>*pointer);
 
 
    std::vector<float>* getBBFractureEnergyP();
 
    void setFractureEnergyP(std::vector<float>*pointer);
 
    std::vector<float>* getFractureEnergyP();
 
    void setKineticEnergyP(std::vector<float>* pointer);
 
    std::vector<float>* getKineticEnergyP();
 
  std::string printStr(int nt = 0, int lvl = 0) const;
 
  void print(int nt = 0, int lvl = 0) const { std::cout << printStr(nt, lvl); };
 
private:
 
    inp::ModelDeck *d_modelDeck_p = nullptr;
 
    inp::OutputDeck *d_outputDeck_p = nullptr;
 
    std::vector<util::Point3> *d_b_p = nullptr;
 
    std::vector<util::Point3> *d_u_p = nullptr;
 
    std::vector<util::Point3> *d_v_p = nullptr;
 
    std::vector<util::Point3> *d_f_p = nullptr;
 
    std::vector<util::Point3> *d_reaction_force_p = nullptr;
 
    std::vector<std::vector<double>>* d_extension_p = nullptr;
 
    std::vector<double> *d_dilatation_p = nullptr;
 
  std::vector<double> *d_weighted_vol_p = nullptr;
 
  std::vector<double> d_thetaX;
 
  std::vector<double> d_mX;
 
    std::vector<float>* d_e_p = nullptr;
 
    std::vector<double>* d_total_reaction_force_p = nullptr;
 
    std::vector<float>* d_w_p = nullptr;
 
    std::vector<float>* d_phi_p = nullptr;
 
    std::vector<float>* d_Z_p = nullptr;
 
    std::vector<float>* d_eFB_p = nullptr;
 
    std::vector<float>* d_eF_p = nullptr;
 
    std::vector<float>* d_ke_p = nullptr;
 
    std::vector<util::Matrix33>* d_strain_p = nullptr;
 
    std::vector<util::Matrix33>* d_stress_p = nullptr;
 
    fe::Mesh *d_mesh_p = nullptr;
 
    geometry::Neighbor *d_neighbor_p = nullptr;
 
    geometry::VolumeCorrection *d_volumeCorrection_p = nullptr;
 
  geometry::Fracture *d_fracture_p = nullptr;
 
  geometry::InteriorFlags *d_interiorFlags_p = nullptr;
 
    util::StateBasedHelperFunctions* d_sbhelper_p = nullptr;
 
 
    loading::ULoading *d_uLoading_p = nullptr;
 
    loading::FLoading *d_fLoading_p = nullptr;
 
};
 
}
 
#endif /* SRC_DATA_DATAMANAGER_H_ */