util.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_UTIL_H
#define TOOLS_PP_UTIL_H
 
#include "inp/decks/fractureDeck.h" // definition of EdgeCrack
#include "util/point.h"             // definition of Point3
#include <string>
#include <vector>
 
namespace tools {
 
namespace pp {
 
struct JEnergy {
 
  double d_contourPdStrainEnergy;
 
  double d_contourPdStrainEnergyRate;
 
  double d_contourKineticEnergyRate;
 
  double d_contourElasticInternalWorkRate;
 
  double d_pdInternalWork;
 
  double d_pdInternalWorkRate;
 
  double d_lefmEnergyRate;
 
  double d_pdStrainEnergyInsideContour;
 
 
  double d_kineticEnergyInsideContour;
 
  double d_pdFractureEnergy;
 
  JEnergy()
      : d_contourPdStrainEnergy(0.), d_contourPdStrainEnergyRate(0.),
        d_contourKineticEnergyRate(0.), d_contourElasticInternalWorkRate(0.),
        d_pdInternalWork(0.), d_pdInternalWorkRate(0.), d_lefmEnergyRate(0.),
        d_pdStrainEnergyInsideContour(0.), d_kineticEnergyInsideContour(0.),
        d_pdFractureEnergy(0.) {};
};
 
struct SortZ {
 
  size_t d_i;
 
  size_t d_r;
 
  double d_Z;
 
  SortZ() : d_i(0), d_r(0), d_Z(0.){};
};
 
struct CrackTipData {
 
  int d_n;
 
  util::Point3 d_p;
 
  util::Point3 d_v;
 
  util::Point3 d_d;
 
  CrackTipData() : d_n(0), d_p(util::Point3()), d_v(util::Point3()), d_d
  (util::Point3()){};
 
  CrackTipData(size_t n, util::Point3 p, util::Point3 v, util::Point3 d =
      util::Point3())
      : d_n(n), d_p(p), d_v(v), d_d(d){};
};
 
struct TransformU {
  double d_scale;
 
  TransformU() : d_scale(1.){};
};
 
struct TransformVelocity {
  bool d_markVAsZero;
 
  bool d_markVInRectGiven;
 
  std::pair<util::Point3, util::Point3> d_markVRect;
 
  std::vector<util::Point3> d_markVPts;
 
  bool d_markVPtsAreInCurrentConfig;
 
  std::vector<size_t> d_markVNodes;
 
  bool d_symmetrizeV;
 
  bool d_combineMarkV;
 
  std::string d_symmAxis;
 
  double d_symmLine;
 
  TransformVelocity()
      : d_markVAsZero(false), d_markVInRectGiven(false),
        d_markVPtsAreInCurrentConfig(false), d_symmetrizeV(false),
        d_combineMarkV(false), d_symmLine(0.){};
};
 
struct ComputeStrain {
  bool d_computeStrain;
 
  bool d_magStrainTensor;
 
  std::string d_magStrainComp;
 
  std::vector<std::pair<size_t, double>> d_markMagStrainCells;
 
  ComputeStrain() : d_computeStrain(false), d_magStrainTensor(false){};
};
 
struct FindCrackTip {
 
  double d_timet;
 
  double d_timeb;
 
  size_t d_updateCount;
 
  std::vector<inp::EdgeCrack> d_cracks;
 
  double d_minZAllowed;
 
  double d_maxZAllowed;
 
  FILE *d_filet;
 
  FILE *d_fileb;
 
  FindCrackTip()
      : d_timet(0.), d_timeb(0.), d_updateCount(0), d_minZAllowed(1.),
        d_maxZAllowed(50.), d_filet(nullptr), d_fileb(nullptr){};
};
 
struct ComputeJIntegral {
  int d_crackOrient;
 
  int d_crackId;
 
  std::string d_crackTipFile;
 
  std::vector<tools::pp::CrackTipData> d_crackTipData;
 
  FILE *d_file;
 
  FILE *d_fileNew;
 
  bool d_setLateralCompVZero;
 
  bool d_setLateralCompUZero;
 
  double d_setLateralCompX;
 
  bool d_isCrackInclined;
 
  std::vector<double> d_contourFactor;
 
  bool d_contourGiven;
 
  std::pair<util::Point3, util::Point3> d_contour;
 
  ComputeJIntegral()
      : d_crackOrient(0), d_crackId(1), d_file(nullptr), d_fileNew(nullptr),
        d_setLateralCompVZero(false), d_setLateralCompUZero(false),
        d_setLateralCompX(0.), d_isCrackInclined(false), d_contourGiven(false),
        d_contour({util::Point3(), util::Point3()}){};
};
 
struct InstructionData {
 
  std::string d_tagFilename;
 
  std::string d_outFormat;
 
  int d_start;
 
  int d_end;
 
  int d_interval;
 
  bool d_outOnlyNodes;
 
  bool d_removeElements;
 
  std::string d_compressType;
 
  tools::pp::TransformU *d_transformU_p;
 
  tools::pp::TransformVelocity *d_transformV_p;
 
  tools::pp::ComputeStrain *d_compStrain_p;
 
  tools::pp::FindCrackTip *d_findCrackTip_p;
 
  bool d_damageAtNodes;
 
  tools::pp::ComputeJIntegral *d_computeJInt_p;
 
  bool d_calculateInRefConfig;
 
  InstructionData()
      : d_outFormat("vtu"), d_start(-1), d_end(-1), d_interval(1),
        d_outOnlyNodes(true), d_removeElements(false), d_transformU_p(nullptr),
        d_transformV_p(nullptr), d_compStrain_p(nullptr),
        d_findCrackTip_p(nullptr), d_damageAtNodes(false),
        d_computeJInt_p(nullptr), d_calculateInRefConfig(false) {};
};
 
} // namespace pp
 
} // namespace tools
 
#endif // TOOLS_PP_UTIL_H