modelData.h

Go to the documentation of this file.

/*
 * -------------------------------------------
 * Copyright (c) 2021 - 2026 Prashant K. Jha
 * -------------------------------------------
 * PeriDEM https://github.com/prashjha/PeriDEM
 *
 * Distributed under the Boost Software License, Version 1.0. (See accompanying
 * file LICENSE)
 */
 
#ifndef DATA_MODELDATA_H
#define DATA_MODELDATA_H
 
#include "util/point.h"
#include "util/matrix.h"
#include "util/vecMethods.h"
#include "material/mparticle/material.h"
#include "inp/input.h"
#include "loading/particleFLoading.h"
#include "loading/particleULoading.h"
#include "loading/particleIC.h"
#include "nsearch/nsearch.h"
#include "fracture/fracture.h"
#include <cstdint> // uint8_t type
#include <cstring> // string and size_t type
#include <vector>
#include <map>
#include <fstream>
#include <iostream>
#include <string>
#include <utility>
 
typedef nsearch::NFlannSearchKd<3> NSearch;
 
// forward declare particle and wall
namespace particle {
class BaseParticle;
class RefParticle;
class Particle;
}
 
namespace data {
 
class ModelData {
 
public:
  ModelData(std::shared_ptr<inp::Input> & deck)
      : d_n(0),
        d_time(0.),
        d_currentDt(0.),
        d_infoN(1),
        d_name("Model"),
        d_input_p(deck),
        d_modelDeck_p(deck->d_modelDeck_p),
        d_outputDeck_p(deck->d_outputDeck_p),
        d_restartDeck_p(deck->d_restartDeck_p),
        d_testDeck_p(deck->d_testDeck_p),
        d_bcDeck_p(deck->d_bcDeck_p),
        d_particleDeck_p(deck->d_particleDeck_p),
        d_stop(false), d_hMax(0.), d_hMin(0.), d_maxContactR(0.),
        d_contNeighUpdateInterval(0),
        d_contNeighTimestepCounter(0),
        d_contNeighSearchRadius(0.),
        d_mpiGhostPlanValid(false),
        d_mpiGhostStepsSinceRebuild(0),
        d_pdDofMpi(false),
        d_pdGrainAligned(false),
        d_uLoading_p(nullptr), d_fLoading_p(nullptr),
        d_fracture_p(nullptr), d_nsearch_p(nullptr)  {}
 
  const particle::BaseParticle* getParticleFromAllList(size_t i) const { return
            d_particlesListTypeAll[i]; };
 
  particle::BaseParticle* &getParticleFromAllList(size_t i) { return
                                                     d_particlesListTypeAll[i]; };
 
  const particle::BaseParticle* getParticleFromParticleList(size_t i) const { return
            d_particlesListTypeParticle[i]; };
 
  particle::BaseParticle* &getParticleFromParticleList(size_t i) { return
            d_particlesListTypeParticle[i]; };
 
  const particle::BaseParticle* getParticleFromWallList(size_t i) const { return
              d_particlesListTypeWall[i]; };
 
  particle::BaseParticle* &getParticleFromWallList(size_t i) { return
            d_particlesListTypeWall[i]; };
 
  double getDensity(size_t i);
 
  double getHorizon(size_t i);
 
  int dimension() const { return d_modelDeck_p->d_dim; }
 
  double timeStep() const { return d_modelDeck_p->d_dt; }
 
  double currentDt() const { return d_currentDt; }
 
  void setCurrentDt(double dt) { d_currentDt = dt; }
 
  void advanceTime() {
    ++d_n;
    d_time += d_currentDt;
  }
 
  size_t numPdForceNodes() const { return d_fPdCompNodes.size(); }
 
  size_t pdForceNode(size_t k) const { return d_fPdCompNodes[k]; }
 
  bool isDofFree(size_t i, unsigned int dof) const {
    return util::methods::isFree(d_fix[i], dof);
  }
 
  double getVMag(size_t i) const { return d_vMag[i]; }
 
  void setVMag(size_t i, double mag) { d_vMag[i] = mag; }
 
  size_t currentStep() const { return d_n; }
 
  size_t numTimeSteps() const { return d_modelDeck_p->d_Nt; }
 
  const std::string &timeDiscretization() const {
    return d_modelDeck_p->d_timeDiscretization;
  }
 
  bool performOutput() const { return d_outputDeck_p->d_performOut; }
 
  bool shouldOutput() const {
    return d_outputDeck_p->d_performOut &&
           (d_n % d_outputDeck_p->d_dtOut == 0) &&
           (d_n >= d_outputDeck_p->d_dtOut);
  }
 
  size_t &getPtId(size_t i) { return d_ptId[i]; };
 
  const size_t &getPtId(size_t i) const { return d_ptId[i]; };
 
  void setPtId(size_t i, const size_t &id) { d_ptId[i] = id; };
 
 
  double getKeyData(std::string key, bool issue_err = false) {
    return util::methods::getKeyData<double>(key, d_dbgData, issue_err);
  };
 
  void appendKeyData(std::string key, double data, bool issue_err = false) {
    util::methods::appendKeyData<double>(key, data, d_dbgData, issue_err);
  };
 
  void setKeyData(std::string key, double data, bool issue_err = false) {
    util::methods::setKeyData<double>(key, data, d_dbgData, issue_err);
  };
 
  util::Point &getXRef(size_t i) { return d_xRef[i]; };
 
  const util::Point &getXRef(size_t i) const { return d_xRef[i]; };
 
  void setXRef(size_t i, const util::Point &x) { d_xRef[i] = x; };
 
  void addXRef(size_t i, const util::Point &x) { d_xRef[i] += x; };
 
  void setXRef(size_t i, int dof, double x) { d_xRef[i][dof] = x; };
 
  void addXRef(size_t i, int dof, double x) { d_xRef[i][dof] += x; };
 
  util::Point &getX(size_t i) { return d_x[i]; };
 
  const util::Point &getX(size_t i) const { return d_x[i]; };
 
  void setX(size_t i, const util::Point &x) { d_x[i] = x; };
 
  void addX(size_t i, const util::Point &x) { d_x[i] += x; };
 
  void setX(size_t i, int dof, double x) { d_x[i][dof] = x; };
 
  void addX(size_t i, int dof, double x) { d_x[i][dof] += x; };
 
  util::Point &getU(size_t i) { return d_u[i]; };
 
  const util::Point &getU(size_t i) const { return d_u[i]; };
 
  void setU(size_t i, const util::Point &u) { d_u[i] = u; };
 
  void addU(size_t i, const util::Point &u) { d_u[i] += u; };
 
  void setU(size_t i, int dof, double u) { d_u[i][dof] = u; };
 
  void addU(size_t i, int dof, double u) { d_u[i][dof] += u; };
 
  util::Point &getV(size_t i) { return d_v[i]; };
 
  const util::Point &getV(size_t i) const { return d_v[i]; };
 
  void setV(size_t i, const util::Point &v) { d_v[i] = v; };
 
  void addV(size_t i, const util::Point &v) { d_v[i] += v; };
 
  void setV(size_t i, int dof, double v) { d_v[i][dof] = v; };
 
  void addV(size_t i, int dof, double v) { d_v[i][dof] += v; };
 
  util::Point &getF(size_t i) { return d_f[i]; };
 
  const util::Point &getF(size_t i) const { return d_f[i]; };
 
  void setF(size_t i, const util::Point &f) { d_f[i] = f; };
 
  void addF(size_t i, const util::Point &f) { d_f[i] += f; };
 
  void setF(size_t i, int dof, double f) { d_f[i][dof] = f; };
 
  void addF(size_t i, int dof, double f) { d_f[i][dof] += f; };
 
  double &getVol(size_t i) { return d_vol[i]; };
 
  const double &getVol(size_t i) const { return d_vol[i]; };
 
  void setVol(size_t i, const double &vol) { d_vol[i] = vol; };
 
  void addVol(size_t i, const double &vol) { d_vol[i] += vol; };
 
  uint8_t &getFix(size_t i) { return d_fix[i]; };
 
  const uint8_t &getFix(size_t i) const { return d_fix[i]; };
 
  void setFix(size_t i, const unsigned int &dof,
              const bool &flag) {
    // to set i^th bit as true of integer a,
    // a |= 1UL << (i % 8)
 
    // to set i^th bit as false of integer a,
    // a &= ~(1UL << (i % 8))
 
    flag ? (d_fix[i] |= 1UL << dof) : (d_fix[i] &= ~(1UL << dof));
  };
 
  double &getMx(size_t i) { return d_mX[i]; };
 
  const double &getMx(size_t i) const { return d_mX[i]; };
 
  void setMx(size_t i, const double &mx) { d_mX[i] = mx; };
 
  void addMx(size_t i, const double &mx) { d_mX[i] += mx; };
 
  double &getThetax(size_t i) { return d_thetaX[i]; };
 
  const double &getThetax(size_t i) const { return d_thetaX[i]; };
 
  void setThetax(size_t i, const double &thetax) { d_thetaX[i] = thetax; };
 
  void addThetax(size_t i, const double &thetax) { d_thetaX[i] += thetax; };
 
public:
  size_t d_n;
 
  double d_time;
 
  double d_currentDt;
 
  size_t d_infoN;
 
  std::string d_name;
 
  std::vector<std::pair<double, std::string>> d_pvdParticleEntries;
 
  std::vector<std::pair<double, std::string>> d_pvdStrainEntries;
 
  std::map<std::string, double> d_dbgData;
 
  std::ofstream d_ppFile;
 
  std::shared_ptr<inp::Input> d_input_p;
 
  std::shared_ptr<inp::ModelDeck> d_modelDeck_p;
 
  std::shared_ptr<inp::OutputDeck> d_outputDeck_p;
 
  std::shared_ptr<inp::RestartDeck> d_restartDeck_p;
 
  std::shared_ptr<inp::TestDeck> d_testDeck_p;
 
  std::shared_ptr<inp::BCDeck> d_bcDeck_p;
 
  std::shared_ptr<inp::ParticleDeck> d_particleDeck_p;
 
  bool d_stop;
 
  double d_hMax;
 
  double d_hMin;
 
  double d_maxContactR;
 
  size_t d_contNeighUpdateInterval;
 
  size_t d_contNeighTimestepCounter;
 
  double d_contNeighSearchRadius;
 
  std::vector<char> d_mpiIncludeInContactCloud;
 
  std::vector<std::vector<int>> d_mpiGhostNeedFrom;
 
  std::vector<std::vector<int>> d_mpiGhostServeTo;
 
  bool d_mpiGhostPlanValid;
 
  size_t d_mpiGhostStepsSinceRebuild;
 
  bool d_pdDofMpi;
 
  bool d_pdGrainAligned;
 
  std::vector<size_t> d_pdNodePartition;
 
  std::vector<std::vector<int>> d_pdGhostNeedFrom;
 
  std::vector<std::vector<int>> d_pdGhostServeTo;
 
  std::vector<std::shared_ptr<particle::RefParticle>> d_referenceParticles;
 
  std::vector<particle::BaseParticle*> d_particlesListTypeAll;
 
  std::vector<particle::BaseParticle*> d_particlesListTypeParticle;
 
  std::vector<particle::BaseParticle*> d_particlesListTypeWall;
 
  std::vector<inp::MatData> d_particlesMatDataList;
 
  std::vector<double> d_maxVelocityParticlesListTypeAll;
 
  double d_maxVelocity;
 
  std::vector<std::vector<size_t>> d_zInfo;
 
  std::unique_ptr<loading::ParticleULoading> d_uLoading_p;
 
  std::unique_ptr<loading::ParticleFLoading> d_fLoading_p;
 
  std::unique_ptr<geometry::Fracture> d_fracture_p;
 
  std::unique_ptr<NSearch> d_nsearch_p;
 
  std::vector<util::Point> d_xRef;
 
  std::vector<util::Point> d_x;
 
  std::vector<util::Point> d_u;
 
  std::vector<util::Point> d_v;
 
  std::vector<double> d_vMag;
 
  std::vector<util::Point> d_f;
 
  std::vector<double> d_vol;
 
  std::vector<size_t> d_ptId;
 
  std::vector<std::vector<size_t>> d_neighC;
 
  std::vector<std::vector<size_t>> d_neighPd;
 
  std::vector<std::vector<float>> d_neighPdSqdDist;
 
  std::vector<std::vector<std::vector<size_t>>> d_neighWallNodes;
 
  std::vector<std::vector<std::vector<double>>> d_neighWallNodesDistance;
 
  std::vector<std::vector<size_t>> d_neighWallNodesCondensed;
 
  std::vector<uint8_t> d_fix;
 
  std::vector<uint8_t> d_forceFixity;
 
  std::vector<double> d_thetaX;
 
  std::vector<double> d_mX;
 
  std::vector<size_t> d_fPdCompNodes;
 
  std::vector<size_t> d_fContCompNodes;
 
  std::vector<float> d_Z;
 
  std::vector<float> d_e;
 
  std::vector<float> d_w;
 
  std::vector<float> d_phi;
 
  std::vector<float> d_phiBond;
 
  std::vector<float> d_eF;
 
  std::vector<float> d_eFB;
 
  std::vector<util::Point> d_xQuadCur;
 
  std::vector<util::SymMatrix3> d_strain;
 
  std::vector<util::SymMatrix3> d_stress;
 
  float d_te;
 
  float d_tw;
 
  float d_tk;
 
  float d_teF;
 
  float d_teFB;
 
};
 
void setupQuadratureData(ModelData &data);
 
} // namespace data
 
#endif // DATA_MODELDATA_H