Thermal element

Collaboration diagram for Thermal element:

Files
file	ThermalElement.cpp
file	ThermalElement.hpp
	Operators and data structures for thermal analysis.
file	ThermalStressElement.hpp
	Implementation of thermal stresses element.
file	thermal_steady.cpp
	Example of steady thermal analysis.
file	thermal_unsteady.cpp
	Example of thermal unsteady analyze.

Classes
struct	ThermalElement
	structure grouping operators and data used for thermal problems More...
struct	ThermalElement::MyVolumeFE
	definition of volume element More...
struct	ThermalElement::MyTriFE
	define surface element More...
struct	ThermalElement::BlockData
	data for calculation heat conductivity and heat capacity elements More...
struct	ThermalElement::FluxData
	data for calculation heat flux More...
struct	ThermalElement::ConvectionData
	data for convection More...
struct	ThermalElement::RadiationData
	data for radiation More...
struct	ThermalElement::CommonData
	common data used by volume elements More...
struct	ThermalElement::OpGetGradAtGaussPts
	operator to calculate temperature gradient at Gauss points More...
struct	ThermalElement::OpGetFieldAtGaussPts< OP >
	operator to calculate temperature and rate of temperature at Gauss points More...
struct	ThermalElement::OpGetTetTemperatureAtGaussPts
	operator to calculate temperature at Gauss pts More...
struct	ThermalElement::OpGetTriTemperatureAtGaussPts
	operator to calculate temperature at Gauss pts More...
struct	ThermalElement::OpGetTetRateAtGaussPts
	operator to calculate temperature rate at Gauss pts More...
struct	ThermalElement::OpThermalRhs
struct	ThermalElement::OpThermalLhs
struct	ThermalElement::OpHeatCapacityRhs
	operator to calculate right hand side of heat capacity terms More...
struct	ThermalElement::OpHeatCapacityLhs
	operator to calculate left hand side of heat capacity terms More...
struct	ThermalElement::OpHeatFlux
	operator for calculate heat flux and assemble to right hand side More...
struct	ThermalElement::OpRadiationLhs
struct	ThermalElement::OpRadiationRhs
	operator to calculate radiation therms on body surface and assemble to rhs of transient equations(Residual Vector) More...
struct	ThermalElement::OpConvectionRhs
	operator to calculate convection therms on body surface and assemble to rhs of equations More...
struct	ThermalElement::OpConvectionLhs
struct	ThermalElement::UpdateAndControl
	this calass is to control time stepping More...
struct	ThermalElement::TimeSeriesMonitor
	TS monitore it records temperature at time steps. More...
struct	ThermalStressElement
	Implentation of thermal stress element. More...
struct	ThermalStressElement::MyVolumeFE
struct	ThermalStressElement::BlockData
struct	ThermalStressElement::CommonData
struct	ThermalStressElement::OpGetTemperatureAtGaussPts
struct	ThermalStressElement::OpThermalStressRhs

Functions
MoFEMErrorCode	ThermalElement::addThermalElements (const std::string field_name, const std::string mesh_nodals_positions="MESH_NODE_POSITIONS")
	add thermal element on tets
MoFEMErrorCode	ThermalElement::addThermalFluxElement (const std::string field_name, const std::string mesh_nodals_positions="MESH_NODE_POSITIONS")
	add heat flux element
MoFEMErrorCode	ThermalElement::addThermalConvectionElement (const std::string field_name, const std::string mesh_nodals_positions="MESH_NODE_POSITIONS")
	add convection element
MoFEMErrorCode	ThermalElement::addThermalRadiationElement (const std::string field_name, const std::string mesh_nodals_positions="MESH_NODE_POSITIONS")
	add Non-linear Radiation element
MoFEMErrorCode	ThermalElement::setThermalFiniteElementRhsOperators (string field_name, Vec &F)
	this function is used in case of stationary problem to set elements for rhs
MoFEMErrorCode	ThermalElement::setThermalFiniteElementLhsOperators (string field_name, Mat A)
	this function is used in case of stationary heat conductivity problem for lhs
MoFEMErrorCode	ThermalElement::setThermalFluxFiniteElementRhsOperators (string field_name, Vec &F, const std::string mesh_nodals_positions="MESH_NODE_POSITIONS")
	this function is used in case of stationary problem for heat flux terms
MoFEMErrorCode	ThermalElement::setTimeSteppingProblem (string field_name, string rate_name, const std::string mesh_nodals_positions="MESH_NODE_POSITIONS")
	set up operators for unsteady heat flux; convection; radiation problem
MoFEMErrorCode	ThermalElement::setTimeSteppingProblem (TsCtx &ts_ctx, string field_name, string rate_name, const std::string mesh_nodals_positions="MESH_NODE_POSITIONS")
	set up operators for unsteady heat flux; convection; radiation problem

Detailed Description

Function Documentation

addThermalConvectionElement()

MoFEMErrorCode ThermalElement::addThermalConvectionElement	(	const std::string	field_name,
		const std::string	mesh_nodals_positions = "MESH_NODE_POSITIONS"
	)

#include <users_modules/basic_finite_elements/src/ThermalElement.hpp>

add convection element

It get data from convection set and define element in moab. Alternatively uses block set with name including substring CONVECTION.

Parameters

field	name
name	of mesh nodal positions (if not defined nodal coordinates are used)

Definition at line 622 of file ThermalElement.cpp.

                                                                       {
  MoFEMFunctionBeginHot;
 
  CHKERR mField.add_finite_element("THERMAL_CONVECTION_FE", MF_ZERO);
  CHKERR mField.modify_finite_element_add_field_row("THERMAL_CONVECTION_FE",
                                                    field_name);
  CHKERR mField.modify_finite_element_add_field_col("THERMAL_CONVECTION_FE",
                                                    field_name);
  CHKERR mField.modify_finite_element_add_field_data("THERMAL_CONVECTION_FE",
                                                     field_name);
  if (mField.check_field(mesh_nodals_positions)) {
    CHKERR mField.modify_finite_element_add_field_data("THERMAL_CONVECTION_FE",
                                                       mesh_nodals_positions);
  }
 
  // this is alternative method for setting boundary conditions, to bypass bu
  // in cubit file reader. not elegant, but good enough
  for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(mField, BLOCKSET, it)) {
    if (std::regex_match(it->getName(), std::regex("(.*)CONVECTION(.*)"))) {
      std::vector<double> data;
      CHKERR it->getAttributes(data);
      if (data.size() != 2) {
        SETERRQ(PETSC_COMM_SELF, 1, "Data inconsistency");
      }
      setOfConvection[it->getMeshsetId()].cOnvection = data[0];
      setOfConvection[it->getMeshsetId()].tEmperature = data[1];
      CHKERR mField.get_moab().get_entities_by_type(
          it->meshset, MBTRI, setOfConvection[it->getMeshsetId()].tRis, true);
      CHKERR mField.add_ents_to_finite_element_by_type(
          setOfConvection[it->getMeshsetId()].tRis, MBTRI,
          "THERMAL_CONVECTION_FE");
    }
  }
 
  MoFEMFunctionReturnHot(0);
}

addThermalElements()

MoFEMErrorCode ThermalElement::addThermalElements	(	const std::string	field_name,
		const std::string	mesh_nodals_positions = "MESH_NODE_POSITIONS"
	)

#include <users_modules/basic_finite_elements/src/ThermalElement.hpp>

add thermal element on tets

It get data from block set and define element in moab w

Parameters

field	name
name	of mesh nodal positions (if not defined nodal coordinates are used)

Definition at line 528 of file ThermalElement.cpp.

                                                                          {
  MoFEMFunctionBegin;
 
  CHKERR mField.add_finite_element("THERMAL_FE", MF_ZERO);
  CHKERR mField.modify_finite_element_add_field_row("THERMAL_FE", field_name);
  CHKERR mField.modify_finite_element_add_field_col("THERMAL_FE", field_name);
  CHKERR mField.modify_finite_element_add_field_data("THERMAL_FE", field_name);
  if (mField.check_field(mesh_nodals_positions)) {
    CHKERR mField.modify_finite_element_add_field_data("THERMAL_FE",
                                                       mesh_nodals_positions);
  }
 
  // takes skin of block of entities
  // Skinner skin(&mField.get_moab());
  // loop over all blocksets and get data which name is FluidPressure
  for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(
           mField, BLOCKSET | MAT_THERMALSET, it)) {
 
    Mat_Thermal temp_data;
    ierr = it->getAttributeDataStructure(temp_data);
 
    setOfBlocks[it->getMeshsetId()].cOnductivity_mat.resize(
        3, 3); //(3X3) conductivity matrix
    setOfBlocks[it->getMeshsetId()].cOnductivity_mat.clear();
    setOfBlocks[it->getMeshsetId()].cOnductivity_mat(0, 0) =
        temp_data.data.Conductivity;
    setOfBlocks[it->getMeshsetId()].cOnductivity_mat(1, 1) =
        temp_data.data.Conductivity;
    setOfBlocks[it->getMeshsetId()].cOnductivity_mat(2, 2) =
        temp_data.data.Conductivity;
    // setOfBlocks[it->getMeshsetId()].cOnductivity =
    // temp_data.data.Conductivity;
    setOfBlocks[it->getMeshsetId()].cApacity = temp_data.data.HeatCapacity;
    if (temp_data.data.User2 != 0) {
      setOfBlocks[it->getMeshsetId()].initTemp = temp_data.data.User2;
    }
    CHKERR mField.get_moab().get_entities_by_type(
        it->meshset, MBTET, setOfBlocks[it->getMeshsetId()].tEts, true);
    CHKERR mField.add_ents_to_finite_element_by_type(
        setOfBlocks[it->getMeshsetId()].tEts, MBTET, "THERMAL_FE");
  }
 
  MoFEMFunctionReturn(0);
}

addThermalFluxElement()

MoFEMErrorCode ThermalElement::addThermalFluxElement	(	const std::string	field_name,
		const std::string	mesh_nodals_positions = "MESH_NODE_POSITIONS"
	)

#include <users_modules/basic_finite_elements/src/ThermalElement.hpp>

add heat flux element

It get data from heat flux set and define element in moab. Alternatively uses block set with name including substring HEAT_FLUX.

Parameters

field	name
name	of mesh nodal positions (if not defined nodal coordinates are used)

Definition at line 575 of file ThermalElement.cpp.

                                                                             {
  MoFEMFunctionBegin;
 
  CHKERR mField.add_finite_element("THERMAL_FLUX_FE", MF_ZERO);
  CHKERR mField.modify_finite_element_add_field_row("THERMAL_FLUX_FE",
                                                    field_name);
  CHKERR mField.modify_finite_element_add_field_col("THERMAL_FLUX_FE",
                                                    field_name);
  CHKERR mField.modify_finite_element_add_field_data("THERMAL_FLUX_FE",
                                                     field_name);
  if (mField.check_field(mesh_nodals_positions)) {
    CHKERR mField.modify_finite_element_add_field_data("THERMAL_FLUX_FE",
                                                       mesh_nodals_positions);
  }
 
  for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(mField, SIDESET | HEATFLUXSET,
                                                  it)) {
    CHKERR it->getBcDataStructure(setOfFluxes[it->getMeshsetId()].dAta);
    CHKERR mField.get_moab().get_entities_by_type(
        it->meshset, MBTRI, setOfFluxes[it->getMeshsetId()].tRis, true);
    CHKERR mField.add_ents_to_finite_element_by_type(
        setOfFluxes[it->getMeshsetId()].tRis, MBTRI, "THERMAL_FLUX_FE");
  }
 
  // this is alternative method for setting boundary conditions, to bypass bu
  // in cubit file reader. not elegant, but good enough
  for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(mField, BLOCKSET, it)) {
    if (std::regex_match(it->getName(), std::regex("(.*)HEAT_FLUX(.*)"))) {
      std::vector<double> data;
      CHKERR it->getAttributes(data);
      if (data.size() != 1) {
        SETERRQ(PETSC_COMM_SELF, 1, "Data inconsistency");
      }
      strcpy(setOfFluxes[it->getMeshsetId()].dAta.data.name, "HeatFlu");
      setOfFluxes[it->getMeshsetId()].dAta.data.flag1 = 1;
      setOfFluxes[it->getMeshsetId()].dAta.data.value1 = data[0];
      CHKERR mField.get_moab().get_entities_by_type(
          it->meshset, MBTRI, setOfFluxes[it->getMeshsetId()].tRis, true);
      CHKERR mField.add_ents_to_finite_element_by_type(
          setOfFluxes[it->getMeshsetId()].tRis, MBTRI, "THERMAL_FLUX_FE");
    }
  }
 
  MoFEMFunctionReturn(0);
}

addThermalRadiationElement()

MoFEMErrorCode ThermalElement::addThermalRadiationElement	(	const std::string	field_name,
		const std::string	mesh_nodals_positions = "MESH_NODE_POSITIONS"
	)

#include <users_modules/basic_finite_elements/src/ThermalElement.hpp>

add Non-linear Radiation element

It get data from Radiation set and define element in moab. Alternatively uses block set with name including substring RADIATION.

Parameters

field	name
name	of mesh nodal positions (if not defined nodal coordinates are used)

Definition at line 660 of file ThermalElement.cpp.

                                                                       {
  MoFEMFunctionBegin;
 
  CHKERR mField.add_finite_element("THERMAL_RADIATION_FE", MF_ZERO);
  CHKERR mField.modify_finite_element_add_field_row("THERMAL_RADIATION_FE",
                                                    field_name);
  CHKERR mField.modify_finite_element_add_field_col("THERMAL_RADIATION_FE",
                                                    field_name);
  CHKERR mField.modify_finite_element_add_field_data("THERMAL_RADIATION_FE",
                                                     field_name);
  if (mField.check_field(mesh_nodals_positions)) {
    CHKERR mField.modify_finite_element_add_field_data("THERMAL_RADIATION_FE",
                                                       mesh_nodals_positions);
  }
 
  // this is alternative method for setting boundary conditions, to bypass bu
  // in cubit file reader. not elegant, but good enough
  for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(mField, BLOCKSET, it)) {
    if (std::regex_match(it->getName(), std::regex("(.*)RADIATION(.*)"))) {
      std::vector<double> data;
      ierr = it->getAttributes(data);
      if (data.size() != 3) {
        SETERRQ(PETSC_COMM_SELF, 1, "Data inconsistency");
      }
      setOfRadiation[it->getMeshsetId()].sIgma = data[0];
      setOfRadiation[it->getMeshsetId()].eMissivity = data[1];
      setOfRadiation[it->getMeshsetId()].aMbienttEmp = data[2];
      CHKERR mField.get_moab().get_entities_by_type(
          it->meshset, MBTRI, setOfRadiation[it->getMeshsetId()].tRis, true);
      CHKERR mField.add_ents_to_finite_element_by_type(
          setOfRadiation[it->getMeshsetId()].tRis, MBTRI,
          "THERMAL_RADIATION_FE");
    }
  }
 
  MoFEMFunctionReturn(0);
}

setThermalFiniteElementLhsOperators()

MoFEMErrorCode ThermalElement::setThermalFiniteElementLhsOperators	(	string	field_name,
		Mat	A
	)

#include <users_modules/basic_finite_elements/src/ThermalElement.hpp>

this function is used in case of stationary heat conductivity problem for lhs

Definition at line 714 of file ThermalElement.cpp.

                                                                            {
  MoFEMFunctionBegin;
  std::map<int, BlockData>::iterator sit = setOfBlocks.begin();
  for (; sit != setOfBlocks.end(); sit++) {
    // add finite elemen
    feLhs.getOpPtrVector().push_back(
        new OpThermalLhs(field_name, A, sit->second, commonData));
  }
  MoFEMFunctionReturn(0);
}

setThermalFiniteElementRhsOperators()

MoFEMErrorCode ThermalElement::setThermalFiniteElementRhsOperators	(	string	field_name,
		Vec &	F
	)

#include <users_modules/basic_finite_elements/src/ThermalElement.hpp>

this function is used in case of stationary problem to set elements for rhs

Definition at line 700 of file ThermalElement.cpp.

                                                                             {
  MoFEMFunctionBegin;
  std::map<int, BlockData>::iterator sit = setOfBlocks.begin();
  feRhs.getOpPtrVector().push_back(
      new OpGetGradAtGaussPts(field_name, commonData));
  for (; sit != setOfBlocks.end(); sit++) {
    // add finite element
    feRhs.getOpPtrVector().push_back(
        new OpThermalRhs(field_name, F, sit->second, commonData));
  }
  MoFEMFunctionReturn(0);
}

setThermalFluxFiniteElementRhsOperators()

MoFEMErrorCode ThermalElement::setThermalFluxFiniteElementRhsOperators	(	string	field_name,
		Vec &	F,
		const std::string	mesh_nodals_positions = "MESH_NODE_POSITIONS"
	)

#include <users_modules/basic_finite_elements/src/ThermalElement.hpp>

this function is used in case of stationary problem for heat flux terms

Definition at line 725 of file ThermalElement.cpp.

                                                                      {
  MoFEMFunctionBegin;
  bool hoGeometry = false;
  if (mField.check_field(mesh_nodals_positions)) {
    hoGeometry = true;
  }
  std::map<int, FluxData>::iterator sit = setOfFluxes.begin();
  for (; sit != setOfFluxes.end(); sit++) {
    // add finite element
    feFlux.getOpPtrVector().push_back(
        new OpHeatFlux(field_name, F, sit->second, hoGeometry));
  }
  MoFEMFunctionReturn(0);
}

setTimeSteppingProblem() [1/2]

MoFEMErrorCode ThermalElement::setTimeSteppingProblem	(	string	field_name,
		string	rate_name,
		const std::string	mesh_nodals_positions = "MESH_NODE_POSITIONS"
	)

#include <users_modules/basic_finite_elements/src/ThermalElement.hpp>

set up operators for unsteady heat flux; convection; radiation problem

Definition at line 775 of file ThermalElement.cpp.

                                           {
  MoFEMFunctionBegin;
 
  bool hoGeometry = false;
  if (mField.check_field(mesh_nodals_positions)) {
    hoGeometry = true;
  }
 
  {
    std::map<int, BlockData>::iterator sit = setOfBlocks.begin();
    for (; sit != setOfBlocks.end(); sit++) {
      // add finite element
      // those methods are to calculate matrices on Lhs
      //  feLhs.getOpPtrVector().push_back(new
      //  OpGetTetTemperatureAtGaussPts(field_name,commonData));
      feLhs.getOpPtrVector().push_back(
          new OpThermalLhs(field_name, sit->second, commonData));
      feLhs.getOpPtrVector().push_back(
          new OpHeatCapacityLhs(field_name, sit->second, commonData));
      // those methods are to calculate vectors on Rhs
      feRhs.getOpPtrVector().push_back(
          new OpGetTetTemperatureAtGaussPts(field_name, commonData));
      feRhs.getOpPtrVector().push_back(
          new OpGetTetRateAtGaussPts(rate_name, commonData));
      feRhs.getOpPtrVector().push_back(
          new OpGetGradAtGaussPts(field_name, commonData));
      feRhs.getOpPtrVector().push_back(
          new OpThermalRhs(field_name, sit->second, commonData));
      feRhs.getOpPtrVector().push_back(
          new OpHeatCapacityRhs(field_name, sit->second, commonData));
    }
  }
 
  // Flux
  {
    std::map<int, FluxData>::iterator sit = setOfFluxes.begin();
    for (; sit != setOfFluxes.end(); sit++) {
      feFlux.getOpPtrVector().push_back(
          new OpHeatFlux(field_name, sit->second, hoGeometry));
    }
  }
 
  // Convection
  {
    std::map<int, ConvectionData>::iterator sit = setOfConvection.begin();
    for (; sit != setOfConvection.end(); sit++) {
      feConvectionRhs.getOpPtrVector().push_back(
          new OpGetTriTemperatureAtGaussPts(field_name, commonData));
      feConvectionRhs.getOpPtrVector().push_back(
          new OpConvectionRhs(field_name, sit->second, commonData, hoGeometry));
    }
  }
  {
    std::map<int, ConvectionData>::iterator sit = setOfConvection.begin();
    for (; sit != setOfConvection.end(); sit++) {
      feConvectionLhs.getOpPtrVector().push_back(
          new OpConvectionLhs(field_name, sit->second, hoGeometry));
    }
  }
 
  // Radiation
  {
    std::map<int, RadiationData>::iterator sit = setOfRadiation.begin();
    for (; sit != setOfRadiation.end(); sit++) {
      feRadiationRhs.getOpPtrVector().push_back(
          new OpGetTriTemperatureAtGaussPts(field_name, commonData));
      feRadiationRhs.getOpPtrVector().push_back(
          new OpRadiationRhs(field_name, sit->second, commonData, hoGeometry));
    }
  }
  {
    std::map<int, RadiationData>::iterator sit = setOfRadiation.begin();
    for (; sit != setOfRadiation.end(); sit++) {
      feRadiationLhs.getOpPtrVector().push_back(
          new OpGetTriTemperatureAtGaussPts(field_name, commonData));
      feRadiationLhs.getOpPtrVector().push_back(
          new OpRadiationLhs(field_name, sit->second, commonData, hoGeometry));
    }
  }
 
  MoFEMFunctionReturn(0);
}

setTimeSteppingProblem() [2/2]

MoFEMErrorCode ThermalElement::setTimeSteppingProblem	(	TsCtx &	ts_ctx,
		string	field_name,
		string	rate_name,
		const std::string	mesh_nodals_positions = "MESH_NODE_POSITIONS"
	)

#include <users_modules/basic_finite_elements/src/ThermalElement.hpp>

set up operators for unsteady heat flux; convection; radiation problem

Definition at line 860 of file ThermalElement.cpp.

                                           {
  MoFEMFunctionBegin;
 
  CHKERR setTimeSteppingProblem(field_name, rate_name, mesh_nodals_positions);
 
  // rhs
  TsCtx::FEMethodsSequence &loops_to_do_Rhs =
      ts_ctx.getLoopsIFunction();
  loops_to_do_Rhs.push_back(TsCtx::PairNameFEMethodPtr("THERMAL_FE", &feRhs));
  loops_to_do_Rhs.push_back(
      TsCtx::PairNameFEMethodPtr("THERMAL_FLUX_FE", &feFlux));
  if (mField.check_finite_element("THERMAL_CONVECTION_FE"))
    loops_to_do_Rhs.push_back(
        TsCtx::PairNameFEMethodPtr("THERMAL_CONVECTION_FE", &feConvectionRhs));
  if (mField.check_finite_element("THERMAL_RADIATION_FE"))
    loops_to_do_Rhs.push_back(
        TsCtx::PairNameFEMethodPtr("THERMAL_RADIATION_FE", &feRadiationRhs));
 
  // lhs
  TsCtx::FEMethodsSequence &loops_to_do_Mat =
      ts_ctx.getLoopsIJacobian();
  loops_to_do_Mat.push_back(TsCtx::PairNameFEMethodPtr("THERMAL_FE", &feLhs));
  if (mField.check_finite_element("THERMAL_CONVECTION_FE"))
    loops_to_do_Mat.push_back(
        TsCtx::PairNameFEMethodPtr("THERMAL_CONVECTION_FE", &feConvectionLhs));
  if (mField.check_finite_element("THERMAL_RADIATION_FE"))
    loops_to_do_Mat.push_back(
        TsCtx::PairNameFEMethodPtr("THERMAL_RADIATION_FE", &feRadiationLhs));
 
  MoFEMFunctionReturn(0);
}