compute.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 TOOLS_PP_COMPUTE_H
#define TOOLS_PP_COMPUTE_H
 
#include "util.h"
#include "util/matrix.h" // definition of SymMatrix3
 
// forward declarations of decks
namespace inp {
class Input;
struct MaterialDeck;
struct FractureDeck;
struct ModelDeck;
struct OutputDeck;
} // namespace inp
 
namespace fe {
class Mesh;
}
 
namespace geometry {
class Fracture;
class Neighbor;
}
 
namespace material {
namespace pd {
class BaseMaterial;
}
}
 
namespace rw {
namespace writer {
class Writer;
}
}
 
namespace data {
class DataManager;
}
 
namespace tools {
 
namespace pp {
 
class Compute {
 
public:
  explicit Compute(const std::string &filename);
 
  void init();
 
  void finalize();
 
  void readComputeInstruction(const std::string &set,
                              tools::pp::InstructionData *data);
 
  void readCrackTipData(const std::string &filename, int crack_id,
                        std::vector<tools::pp::CrackTipData> *data, bool
                        is_inclined = false);
 
  void initWriter(rw::writer::Writer *writer,
                  std::vector<util::Point3> *u);
 
  void transformU(rw::writer::Writer *writer);
 
  void transformV(rw::writer::Writer *writer);
 
  void computeStrain(rw::writer::Writer *writer);
 
  void computeDamage(rw::writer::Writer *writer,
      std::vector<double> *Z, bool perf_out = false);
 
  void findCrackTip(std::vector<double> *Z, rw::writer::Writer
  *writer);
 
  void computeJIntegral();
 
  void computeJIntegralAngledCrack();
 
private:
  void addUniqueToList(size_t i, std::vector<size_t> *list);
 
  size_t findNode(const util::Point3 &x, const std::vector<util::Point3> *nodes,
                  const std::vector<util::Point3> *u = nullptr);
 
  void
  listElemsAndNodesInDomain(const std::pair<util::Point3, util::Point3> &cd,
                            const double &tol, const double &tol_elem,
                            std::vector<size_t> *nodes,
                            std::vector<size_t> *elements,
                            bool calc_in_ref);
 
  void decomposeSearchNodes(const std::pair<util::Point3, util::Point3> &cd,
                            std::vector<size_t> *nodes,
                            std::vector<size_t> *nodes_new);
 
  bool triCheckAndInterpolateUV(const util::Point3 &p, util::Point3 &up,
                                util::Point3 &vp,
                                const std::vector<size_t> &ids,
                                bool calc_in_ref,
                                bool check_only = false);
 
  void interpolateUV(const util::Point3 &p, util::Point3 &up, util::Point3 &vp,
                     const std::vector<size_t> *nodes,
                     const std::vector<size_t> *elements, bool calc_in_ref);
 
  size_t interpolateUVNodes(const util::Point3 &p, util::Point3 &up,
                           util::Point3 &vp,
                     const std::vector<size_t> *nodes, bool calc_in_ref);
 
  void getContourContribJInt(const util::Point3 &p,
                     const std::vector<size_t> *nodes,
                     const std::vector<size_t> *elements,
                             const util::Point3 &normal,
                     double &pd_energy,
                     double &kinetic_energy,
                     double &elastic_energy,
                     util::Point3 &dot_u,
                             bool calc_in_ref,
                             const tools::pp::CrackTipData &ctip);
 
  void updateCrack(const double &time, const std::vector<double> *Z);
 
  void crackOutput();
 
  void getRectsAndNodesForCrackTip(
      inp::EdgeCrack &crack,
      std::vector<std::pair<util::Point3, util::Point3>> &rects_t,
      std::vector<std::pair<util::Point3, util::Point3>> &rects_b,
      std::vector<std::vector<size_t>> &nodes_t,
      std::vector<std::vector<size_t>> &nodes_b,
      std::vector<std::vector<double>> &Z_t,
      std::vector<std::vector<double>> &Z_b, const std::vector<double> *Z);
 
  void addNewCrackTip(inp::EdgeCrack &crack, util::Point3 pnew, double time,
      bool is_top);
 
  util::Point3 findTipInRects(
      inp::EdgeCrack &crack, const double &max_Z,
      const std::vector<std::pair<util::Point3, util::Point3>> &rects,
      const std::vector<std::vector<size_t>> &nodes,
      const std::vector<std::vector<double>> &Zs, const std::vector<double> *Z,
      bool is_top);
 
  void safeExit(const std::string &err_message, rw::writer::Writer *writer = nullptr);
 
  std::string d_inpFilename;
 
  std::vector<tools::pp::InstructionData> d_computeData;
 
  std::string d_fileZ;
 
  std::string d_tagZ;
 
  int d_nOut;
 
  size_t d_nC;
 
  double d_time;
 
  tools::pp::InstructionData *d_currentData;
 
  std::string d_outFilename;
 
  std::string d_outPath;
 
  std::string d_outPreTag;
 
  std::string d_simInpFilename;
 
  std::string d_simOutFilename;
 
  size_t d_dtOutChange;
 
  bool d_writerReady;
 
  bool d_uPlus;
 
  size_t d_dtN;
 
  size_t d_dtStart;
 
  size_t d_dtEnd;
 
  bool d_fnSuccess;
  std::string d_fnErrMsg;
 
  bool d_needDamageZ;
 
  bool d_needNeighborList;
 
  std::vector<util::Point3> d_u;
 
  std::vector<util::Point3> d_v;
 
  std::vector<double> d_Z;
 
  std::vector<double> d_thetaX;
 
  std::vector<double> d_mX;
 
  //inp::ModelDeck *d_modelDeck_p;
 
  inp::OutputDeck *d_outputDeck_p;
 
  inp::FractureDeck *d_fractureDeck_p;
 
  inp::MaterialDeck *d_matDeck_p;
 
  //geometry::Fracture *d_fracture_p;
 
  inp::Input *d_input_p;
 
  material::pd::BaseMaterial *d_material_p;
 
  data::DataManager *d_dataManager_p;
 
};
 
} // namespace pp
 
} // namespace tools
 
#endif // TOOLS_PP_COMPUTE_H