ElasticState.h

// Copyright (c) 2019    Patrick Diehl
//
// Distributed under the GNU GENERAL PUBLIC LICENSE, Version 3.0.
// (See accompanying file LICENSE.txt)
 
#ifndef MATERIAL_PD_ELASTIC_STATEMATERIAL_H
#define MATERIAL_PD_ELASTIC_STATEMATERIAL_H
 
#include "baseMaterial.h"
#include "util/point.h"
#include "util/matrixBlaze.h"
#include "geometry/neighbor.h"
#include "fe/mesh.h"
#include "geometry/volumeCorrection.h"
 
#include <vector>
 
#include <hpx/include/parallel_algorithm.hpp>
 
// forward declaration
namespace inp {
struct MaterialDeck;
struct OutputDeck;
}
 
// forward declaration
namespace data {
class DataManager;
}
 
// forward declaration of class
namespace fe {
class Mesh;
} // namespace fe
 
namespace geometry {
class VolumeCorrection;
} // namespace geometry
 
namespace util {
class StateBasedHelperFunctions;
} // namespace material
 
namespace material {
 
namespace pd {
 
class ElasticState : public BaseMaterial {
 
 public:
  ElasticState(inp::MaterialDeck *deck, data::DataManager *dataManager);
 
  std::pair<util::Point3, double> getBondEF(size_t i, size_t j);
 
  double getSc(size_t i, size_t j);
 
  util::Matrix33 getStress(size_t i);
 
  util::Matrix33 getStrain(size_t i);
 
  double getFactor2D();
 
  void update();
 
  util::Point3
  getBondForceDirection(const util::Point3 &dx,
                        const util::Point3 &du) const override {
    return dx / dx.length();
  }
 
  double getInfFn(const double &r) const {return 1.; };
 
 private:
  void computeParameters(inp::MaterialDeck *deck, size_t dim);
 
  util::Matrix33 deformation_gradient(size_t i);
 
  util::Point3 X_vector_state(size_t i, size_t j);
 
  util::Point3 Y_vector_state(size_t i, size_t j);
 
  util::Matrix33 K_shape_tensor(size_t i);
 
  util::Matrix33 K_modulus_tensor(size_t i, size_t j, size_t k, size_t m);
 
  double dirac_delta(util::Point3 x, size_t i, size_t j, size_t m);
 
  double d_factor2D;
 
  size_t dim;
 
  double horizon;
 
  bool strainEnergy;
 
 
  const inp::MaterialDeck *d_deck;
 
  //const std::vector<util::Point3> *d_nodes;
 
  //const std::vector<double> *d_weightedVolume;
 
  //const std::vector<std::vector<double>> *d_volumeCorrection;
 
  //const std::vector<double> * d_volumes;
 
  //geometry::Neighbor *d_neighbors;
 
  data::DataManager *d_dataManager_p;
 
};
 
} // namespace pd
 
} // namespace material
 
#endif // MATERIAL_PD_ELASTIC_STATEMATERIAL_H