materialDeck.h

Go to the documentation of this file.

/*
 * -------------------------------------------
 * Copyright (c) 2021 - 2024 Prashant K. Jha
 * -------------------------------------------
 * PeriDEM https://github.com/prashjha/PeriDEM
 *
 * Distributed under the Boost Software License, Version 1.0. (See accompanying
 * file LICENSE)
 */
 
#ifndef INP_MATERIALDECK_H
#define INP_MATERIALDECK_H
 
#include "util/io.h"
#include <cmath>
#include <string>
#include <vector>
 
namespace inp {
 
struct MatData {
 
  double d_E;
 
  double d_G;
 
  double d_K;
 
  double d_nu;
 
  double d_lambda;
 
  double d_mu;
 
  double d_KIc;
 
  double d_Gc;
 
  MatData()
      : d_E(-1.), d_G(-1.), d_K(-1.), d_nu(-1.), d_lambda(-1.), d_mu(-1.),
        d_KIc(-1.), d_Gc(-1.){};
 
  MatData(const MatData &md)
      : d_E(md.d_E), d_G(md.d_G), d_K(md.d_K), d_nu(md.d_nu),
        d_lambda(md.d_lambda), d_mu(md.d_mu), d_KIc(md.d_KIc), d_Gc(md.d_Gc){};
 
  std::string printStr(int nt = 0, int lvl = 0) const {
 
    auto tabS = util::io::getTabS(nt);
    std::ostringstream oss;
    oss << tabS << "------- MatData --------" << std::endl << std::endl;
    oss << tabS << "Young's modulus = " << d_E << std::endl;
    oss << tabS << "Shear modulus = " << d_G << std::endl;
    oss << tabS << "Bulk modulus = " << d_K << std::endl;
    oss << tabS << "Poisson ratio = " << d_nu << std::endl;
    oss << tabS << "Lame parameter Lambda = " << d_lambda << std::endl;
    oss << tabS << "Lame parameter Mu = " << d_mu << std::endl;
    oss << tabS << "Critical stress intensity factor = " << d_KIc << std::endl;
    oss << tabS << "Critical energy release rate = " << d_Gc << std::endl;
    oss << tabS << std::endl;
 
    return oss.str();
  }
 
  void print(int nt = 0, int lvl = 0) const { std::cout << printStr(nt, lvl); }
 
  double toNu(double lambda, double mu) { return lambda * 0.5 / (lambda + mu); }
 
  double toNuEG(double E, double G) { return E * 0.5 / G - 1.; }
 
  double toE(double K, double nu) { return K * (3. * (1. - 2. * nu)); }
 
  double toK(double E, double nu) { return E / (3. * (1. - 2. * nu)); }
 
  double toLambdaE(double E, double nu) {
    return E * nu / ((1. + nu) * (1. - 2. * nu));
  }
 
  double toLambdaK(double K, double nu) { return 3. * K * nu / (1. + nu); }
 
  double toGE(double E, double nu) { return E / (2. * (1. + nu)); }
 
  double toGK(double K, double nu) {
    return 3. * K * (1. - 2. * nu) / (2. * (1. + nu));
  }
 
  double toELambda(double lambda, double nu) {
    return lambda * (1. + nu) * (1. - 2. * nu) / nu;
  }
 
  double toGc(double KIc, double nu, double E) { return KIc * KIc / E; }
 
  double toKIc(double Gc, double nu, double E) { return std::sqrt(Gc * E); }
 
};
 
struct MaterialDeck {
 
  bool d_isPlaneStrain;
 
  std::string d_materialType;
 
  size_t d_bondPotentialType;
 
  size_t d_statePotentialType;
 
  size_t d_influenceFnType;
 
  std::vector<double> d_bondPotentialParams;
 
  std::vector<double> d_statePotentialParams;
 
  std::vector<double> d_influenceFnParams;
 
  bool d_irreversibleBondBreak;
 
  bool d_stateContributionFromBrokenBond;
 
  double d_checkScFactor;
 
  bool d_computeParamsFromElastic;
 
  inp::MatData d_matData;
 
  double d_density;
 
  double d_horizon;
 
  double d_horizonMeshRatio;
 
  MaterialDeck()
      : d_isPlaneStrain(false), d_bondPotentialType(0), d_statePotentialType(0),
        d_influenceFnType(0), d_irreversibleBondBreak(true),
        d_stateContributionFromBrokenBond(true), d_checkScFactor(1.),
        d_computeParamsFromElastic(true), d_matData(inp::MatData()),
        d_density(1.), d_horizon(-1.), d_horizonMeshRatio(-1.){};
 
  MaterialDeck(const MaterialDeck &md)
      : d_isPlaneStrain(md.d_isPlaneStrain),
        d_materialType(md.d_materialType),
        d_bondPotentialType(md.d_bondPotentialType),
        d_statePotentialType(md.d_statePotentialType),
        d_influenceFnType(md.d_influenceFnType),
        d_bondPotentialParams(md.d_bondPotentialParams),
        d_statePotentialParams(md.d_statePotentialParams),
        d_influenceFnParams(md.d_influenceFnParams),
        d_irreversibleBondBreak(md.d_irreversibleBondBreak),
        d_stateContributionFromBrokenBond(md.d_stateContributionFromBrokenBond),
        d_checkScFactor(md.d_checkScFactor),
        d_computeParamsFromElastic(md.d_computeParamsFromElastic),
        d_matData(md.d_matData), d_density(md.d_density),
        d_horizon(md.d_horizon), d_horizonMeshRatio(md.d_horizonMeshRatio){};
 
  std::string printStr(int nt = 0, int lvl = 0) const {
 
    auto tabS = util::io::getTabS(nt);
    std::ostringstream oss;
    oss << tabS << "------- MaterialDeck --------" << std::endl << std::endl;
    oss << tabS << "Is plain strain = " << d_isPlaneStrain << std::endl;
    oss << tabS << "Material type = " << d_materialType << std::endl;
    oss << tabS << "Bond potential type = " << d_bondPotentialType << std::endl;
    oss << tabS << "Bond potential params = ["
        << util::io::printStr<double>(d_bondPotentialParams, 0) << "]"
        << std::endl;
    oss << tabS << "State potential type = " << d_statePotentialType
        << std::endl;
    oss << tabS << "State potential params = ["
        << util::io::printStr<double>(d_statePotentialParams, 0) << "]"
        << std::endl;
    oss << tabS << "Influence function type = " << d_influenceFnType
        << std::endl;
    oss << tabS << "Influence function params = ["
        << util::io::printStr<double>(d_influenceFnParams, 0) << "]"
        << std::endl;
    oss << tabS
        << "Irreversible bond breaking enabled = " << d_irreversibleBondBreak
        << std::endl;
    oss << tabS << "State contribution from broken bond enabled = "
        << d_stateContributionFromBrokenBond << std::endl;
    oss << tabS << "Check Sc factor = " << d_checkScFactor << std::endl;
    oss << tabS << "Compute parameters from elastic properties = "
        << d_computeParamsFromElastic << std::endl;
    oss << d_matData.printStr(nt + 1, lvl);
    oss << tabS << "Density = " << d_density << std::endl;
    oss << tabS << "Horizon = " << d_horizon << std::endl;
    oss << tabS << "Horizon to mesh ratio = " << d_horizonMeshRatio
        << std::endl;
    oss << tabS << std::endl;
 
    return oss.str();
  }
 
  void print(int nt = 0, int lvl = 0) const { std::cout << printStr(nt, lvl); }
};
 
} // namespace inp
 
#endif // INP_MATERIALDECK_H