fractureDeck.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 INP_FRACTUREDECK_H
#define INP_FRACTUREDECK_H
 
#include "util/compare.h"       // compare utility
#include "util/point.h"         // definition of Point3
#include "util/transfomation.h" // rotation of point
#include <cstdlib>                    // definition of siz_t
#include <vector>
#include "util/utilIO.h"
 
namespace inp {
 
struct EdgeCrack {
 
  int d_o;
 
  double d_theta;
 
  double d_l;
 
  double d_lt;
 
  double d_lb;
 
  util::Point3 d_vt;
 
  util::Point3 d_vb;
 
  int d_it;
 
  int d_ib;
 
  util::Point3 d_pt;
 
  util::Point3 d_pb;
 
  util::Point3 d_oldPt;
 
  util::Point3 d_oldPb;
 
  util::Point3 d_initPt;
 
  util::Point3 d_initPb;
 
  bool d_trackt;
 
  bool d_trackb;
 
  double d_activationTime;
 
  bool d_crackAcrivated;
 
  EdgeCrack()
      : d_o(1), d_theta(0.), d_l(0.), d_lt(0.), d_lb(0.), d_it(-1), d_ib(-1),
        d_vt(util::Point3()), d_vb(util::Point3()),
        d_pt(util::Point3()), d_pb(util::Point3()),
        d_oldPt(util::Point3()), d_oldPb(util::Point3()),
        d_initPt(util::Point3()), d_initPb(util::Point3()),
        d_trackt(false), d_trackb(false), d_activationTime(-1.),
        d_crackAcrivated(false) {};
 
  bool ptOutside(util::Point3 p, int o, util::Point3 pb, util::Point3 pt,
                 double theta = 0.0) {
 
    if (o == -1) {
 
      // straight crack along y-axis
      return util::compare::definitelyLessThan(p.d_y, pb.d_y) or
             util::compare::definitelyGreaterThan(p.d_y, pt.d_y);
 
    } else if (o == 1) {
 
      // straight crack along x-axis ===> pb == pl, pt == pr
      return util::compare::definitelyLessThan(p.d_x, pb.d_x) or
             util::compare::definitelyGreaterThan(p.d_x, pt.d_x);
 
    } else if (o == 0) {
 
      // straight crack at theta angle with x-axis ===> pb == pl, pt == pr
 
      // 1. pb ==> (0,0), pt ==> pt - pb, p ==> p - pb
      // 2. Apply CW rotation to new pt and new p so that crack line
      // after rotation is simply along x-axis with left point at
      // origin and right point at transformed new pt
 
      util::Point3 pmap = util::transformation::rotateCW2D(p - pb, theta);
      util::Point3 ptmap = util::transformation::rotateCW2D(pt - pb, theta);
 
      return util::compare::definitelyLessThan(pmap.d_x, 0.0) or
             util::compare::definitelyGreaterThan(pmap.d_x, ptmap.d_x);
    }
 
    return true;
  }
 
  bool ptLeftside(util::Point3 p, util::Point3 pb, util::Point3 pt) {
 
    // algorithm is same for any orientation of crack
    //            pt
    //           o
    //          /
    //  p      /
    //   o    /
    //       /
    //      /
    //     /
    //    o
    //    pb
    double a = 0.5 * ((pt.d_x - pb.d_x) * (p.d_y - pb.d_y) -
                      (p.d_x - pb.d_x) * (pt.d_y - pb.d_y));
 
    // crack is closer to left nodes
    return !util::compare::definitelyLessThan(a, 0.0);
  }
 
  bool ptRightside(util::Point3 p, util::Point3 pb, util::Point3 pt) {
 
    return !this->ptLeftside(p, pb, pt);
  }
 
  std::string printStr(int nt = 0, int lvl = 0) const {
    auto tabS = util::io::getTabS(nt);
    std::ostringstream oss;
    oss << tabS << "------- EdgeCrack --------" << std::endl << std::endl;
    oss << tabS << "Orientation = " << d_o << std::endl;
    oss << tabS << "Point 1 = " << d_pb << std::endl;
    oss << tabS << "Point 2 = " << d_pt << std::endl;
    oss << tabS << "Length = " << d_l << std::endl;
    oss << tabS << "Angle = " << d_theta << std::endl;
    oss << tabS << std::endl;
 
    return oss.str();
  };
 
  void print(int nt = 0, int lvl = 0) const { std::cout << printStr(nt, lvl); };
};
 
struct FractureDeck {
 
  std::vector<inp::EdgeCrack> d_cracks;
 
  FractureDeck() {};
 
  std::string printStr(int nt = 0, int lvl = 0) const {
    auto tabS = util::io::getTabS(nt);
    std::ostringstream oss;
    oss << tabS << "------- FractureDeck --------" << std::endl << std::endl;
    oss << tabS << "Number of cracks = " << d_cracks.size() << std::endl;
    for (size_t i=0; i<d_cracks.size(); i++) {
      oss << tabS << "Crack " << i + 1 << " information" << std::endl;
      oss << d_cracks[i].printStr(nt + 1, lvl);
      oss << 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_FRACTUREDECK_H