9#ifndef __FINITE_THERMAL_OPS_HPP__ 
   10#define __FINITE_THERMAL_OPS_HPP__ 
   14struct CommonData : 
public boost::enable_shared_from_this<CommonData> {
 
 
   21template <
int DIM, IntegrationType I, 
typename DomainEleOp>
 
   26template <
int DIM, 
typename DomainEleOp>
 
   30                      boost::shared_ptr<MatrixDouble> vec,
 
   31                      ScalarFun resistance_function,
 
   32                      boost::shared_ptr<MatrixDouble> mat_Grad_Ptr,
 
   33                      boost::shared_ptr<Range> ents_ptr = 
nullptr)
 
   35        resistanceFunction(resistance_function), matGradPtr(mat_Grad_Ptr) {}
 
 
   41  MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &data);
 
 
   44template <
int DIM, 
typename DomainEleOp>
 
   46    EntitiesFieldData::EntData &data) {
 
   54  const auto nb_integration_pts = DomainEleOp::getGaussPts().size2();
 
   61  auto t_grad = getFTensor2FromMat<DIM, DIM>(*(matGradPtr));
 
   64  const double vol = DomainEleOp::getMeasure();
 
   66  auto t_w = DomainEleOp::getFTensor0IntegrationWeight();
 
   68  auto t_row_base = data.getFTensor1N<3>();
 
   70  auto t_flux = getFTensor1FromMat<DIM>(*fluxVec);
 
   72  auto t_coords = AssemblyDomainEleOp::getFTensor1CoordsAtGaussPts();
 
   75  for (
size_t gg = 0; gg != nb_integration_pts; ++gg) {
 
   77    const double alpha = t_w * vol;
 
   80    auto t_J = determinantTensor(t_F);     
 
   83        resistanceFunction(t_coords(0), t_coords(1), t_coords(2)) * t_F(
m, 
J) *
 
   84        t_F(
m, 
N) * t_flux(
N) / t_J; 
 
   88    for (; rr != DomainEleOp::nbRows; ++rr) {
 
   89      DomainEleOp::locF[rr] += t_K_inv_Q_over_J(
J) * alpha * (t_row_base(
J));
 
   92    for (; rr < DomainEleOp::nbRowBaseFunctions; ++rr)
 
 
  102template <
int DIM, IntegrationType I, 
typename AssemblyDomainEleOp>
 
  106template <
int DIM, 
typename AssemblyDomainEleOp>
 
  111                         const std::string col_field_name,
 
  112                         ScalarFun resistance_function,
 
  113                         boost::shared_ptr<MatrixDouble> mat_Grad_Ptr,
 
  114                         boost::shared_ptr<Range> ents_ptr = 
nullptr)
 
  117        resistanceFunction(resistance_function), matGradPtr(mat_Grad_Ptr) {}
 
 
  122  MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data,
 
  123                           EntitiesFieldData::EntData &col_data);
 
 
  126template <
int DIM, 
typename AssemblyDomainEleOp>
 
  129    EntitiesFieldData::EntData &row_data,
 
  130    EntitiesFieldData::EntData &col_data) {
 
  138  auto t_w = this->getFTensor0IntegrationWeight();
 
  140  auto t_row_base = row_data.getFTensor1N<3>();
 
  149  auto t_grad = getFTensor2FromMat<DIM, DIM>(*(matGradPtr));
 
  152  auto t_coords = AssemblyDomainEleOp::getFTensor1CoordsAtGaussPts();
 
  154  for (
size_t gg = 0; gg != AssemblyDomainEleOp::nbIntegrationPts; ++gg) {
 
  157    auto t_J = determinantTensor(t_F);     
 
  159    t_right_Cauchy_Green(M, L) =
 
  163    const double alpha = this->getMeasure() * t_w;
 
  165    t_Kinv_over_J(M, L) =
 
  166        (alpha * resistanceFunction(t_coords(0), t_coords(1), t_coords(2)) /
 
  168        t_right_Cauchy_Green(M, L);
 
  171    for (; rr != AssemblyDomainEleOp::nbRows; ++rr) {
 
  172      t_Kinv_over_J_row_base(L) = t_Kinv_over_J(M, L) * t_row_base(M);
 
  173      auto t_col_base = col_data.getFTensor1N<3>(gg, 0);
 
  174      for (
size_t cc = 0; cc != AssemblyDomainEleOp::nbCols; ++cc) {
 
  175        this->locMat(rr, cc) += t_Kinv_over_J_row_base(L) * t_col_base(L);
 
  180    for (; rr < AssemblyDomainEleOp::nbRowBaseFunctions; ++rr)
 
 
  196template <
int DIM, 
typename AssemblyDomainEleOp>
 
  201                         const std::string col_field_name,
 
  202                         boost::shared_ptr<MatrixDouble> vec,
 
  203                         ScalarFun resistance_function,
 
  204                         boost::shared_ptr<MatrixDouble> mat_Grad_Ptr,
 
  205                         boost::shared_ptr<Range> ents_ptr = 
nullptr)
 
  208        fluxVec(vec), resistanceFunction(resistance_function),
 
  209        matGradPtr(mat_Grad_Ptr) {
 
  210    AssemblyDomainEleOp::sYmm = 
false;
 
 
  217  MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data,
 
  218                           EntitiesFieldData::EntData &col_data);
 
 
  221template <
int DIM, 
typename AssemblyDomainEleOp>
 
  224    EntitiesFieldData::EntData &row_data,
 
  225    EntitiesFieldData::EntData &col_data) {
 
  235  auto t_w = this->getFTensor0IntegrationWeight();
 
  238  auto t_row_base = row_data.getFTensor1N<3>();
 
  251  auto t_grad = getFTensor2FromMat<DIM, DIM>(*(matGradPtr));
 
  254  auto t_flux = getFTensor1FromMat<DIM>(*fluxVec);
 
  257  for (
size_t gg = 0; gg != AssemblyDomainEleOp::nbIntegrationPts; ++gg) {
 
  260    auto t_J = determinantTensor(t_F);     
 
  261    CHKERR invertTensor(t_F, t_J, t_F_inv);
 
  263    t_right_Cauchy_Green(M, L) =
 
  267    const double alpha = this->getMeasure() * t_w;
 
  271    auto t_vec = getFTensor1FromPtr<DIM>(&this->locMat(0, 0));
 
  274    auto t_coords = AssemblyDomainEleOp::getFTensor1CoordsAtGaussPts();
 
  276    auto alpha_resistance_Jinv =
 
  277        alpha * resistanceFunction(t_coords(0), t_coords(1), t_coords(2)) / t_J;
 
  278    t_F_flux(
l) = t_F(
l, L) * t_flux(L);
 
  280    t_FtF_Q(M) = t_right_Cauchy_Green(M, L) * t_flux(L);
 
  284    for (; rr != AssemblyDomainEleOp::nbRows; ++rr) {
 
  285      auto t_col_grad_base = col_data.getFTensor1DiffN<DIM>(gg, 0);
 
  287      t_FtF_Finv_Q_row_base(
J, 
l) = t_FtF_Q(M) * t_row_base(M) * t_F_inv(
J, 
l);
 
  288      t_F_row_base(
l) = t_F(
l, M) * t_row_base(M);
 
  289      t_F_Q_row_base(
l, M) = t_F_flux(
l) * t_row_base(M);
 
  293      for (
size_t cc = 0; cc != AssemblyDomainEleOp::nbCols / DIM; ++cc) {
 
  294        t_vec(
l) += alpha_resistance_Jinv *
 
  295                    (-t_FtF_Finv_Q_row_base(
J, 
l) * t_col_grad_base(
J) +
 
  296                     t_F_Q_row_base(
l, M) * t_col_grad_base(M) +
 
  297                     t_F_row_base(
l) * t_col_grad_base(L) * t_flux(L));
 
  303    for (; rr < AssemblyDomainEleOp::nbRowBaseFunctions; ++rr)
 
 
  315template <
int DIM, 
typename AssemblyDomainEleOp>
 
  320                         const std::string col_field_name,
 
  321                         boost::shared_ptr<MatrixDouble> vec,
 
  322                         ScalarFun resistance_function,
 
  323                         boost::shared_ptr<MatrixDouble> mat_Grad_Ptr,
 
  324                         boost::shared_ptr<Range> ents_ptr = 
nullptr)
 
  327        fluxVec(vec), resistanceFunction(resistance_function),
 
  328        matGradPtr(mat_Grad_Ptr) {
 
  329    AssemblyDomainEleOp::sYmm = 
false;
 
 
  336  MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data,
 
  337                           EntitiesFieldData::EntData &col_data);
 
 
  340template <
int DIM, 
typename AssemblyDomainEleOp>
 
  343    EntitiesFieldData::EntData &row_data,
 
  344    EntitiesFieldData::EntData &col_data) {
 
 
 
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define CHKERR
Inline error check.
FTensor::Index< 'i', SPACE_DIM > i
FTensor::Index< 'J', DIM1 > J
FTensor::Index< 'l', 3 > l
constexpr IntegrationType I
constexpr auto field_name
FTensor::Index< 'm', 3 > m
boost::shared_ptr< double > heatCapacityPtr
boost::shared_ptr< VectorDouble > coeffExpansionPtr
boost::shared_ptr< double > refTempPtr
boost::shared_ptr< double > thermalConductivityPtr
OpCalculateQdotQLhs_dQ(const std::string row_field_name, const std::string col_field_name, ScalarFun resistance_function, boost::shared_ptr< MatrixDouble > mat_Grad_Ptr, boost::shared_ptr< Range > ents_ptr=nullptr)
ScalarFun resistanceFunction
boost::shared_ptr< MatrixDouble > matGradPtr
OpCalculateQdotQLhs_dU(const std::string row_field_name, const std::string col_field_name, boost::shared_ptr< MatrixDouble > vec, ScalarFun resistance_function, boost::shared_ptr< MatrixDouble > mat_Grad_Ptr, boost::shared_ptr< Range > ents_ptr=nullptr)
ScalarFun resistanceFunction
boost::shared_ptr< MatrixDouble > fluxVec
boost::shared_ptr< MatrixDouble > matGradPtr
ScalarFun resistanceFunction
OpCalculateQdotQLhs_dU(const std::string row_field_name, const std::string col_field_name, boost::shared_ptr< MatrixDouble > vec, ScalarFun resistance_function, boost::shared_ptr< MatrixDouble > mat_Grad_Ptr, boost::shared_ptr< Range > ents_ptr=nullptr)
boost::shared_ptr< MatrixDouble > matGradPtr
boost::shared_ptr< MatrixDouble > fluxVec
boost::shared_ptr< MatrixDouble > fluxVec
boost::shared_ptr< MatrixDouble > matGradPtr
ScalarFun resistanceFunction
OpCalculateQdotQRhs(const std::string field_name, boost::shared_ptr< MatrixDouble > vec, ScalarFun resistance_function, boost::shared_ptr< MatrixDouble > mat_Grad_Ptr, boost::shared_ptr< Range > ents_ptr=nullptr)
FormsIntegrators< DomainEleOp >::Assembly< A >::OpBase AssemblyDomainEleOp
constexpr bool IS_LARGE_STRAINS