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.

Functions
MoFEMErrorCode	ThermalElement::addThermalElements (const std::string field_name, const std::string mesh_nodals_positions="MESH_NODE_POSITIONS")
	add thermal element on tets More...
MoFEMErrorCode	ThermalElement::addThermalFluxElement (const std::string field_name, const std::string mesh_nodals_positions="MESH_NODE_POSITIONS")
	add heat flux element More...
MoFEMErrorCode	ThermalElement::addThermalConvectionElement (const std::string field_name, const std::string mesh_nodals_positions="MESH_NODE_POSITIONS")
	add convection element More...
MoFEMErrorCode	ThermalElement::addThermalRadiationElement (const std::string field_name, const std::string mesh_nodals_positions="MESH_NODE_POSITIONS")
	add Non-linear Radiation element More...
MoFEMErrorCode	ThermalElement::setThermalFiniteElementRhsOperators (string field_name, Vec &F)
	this function is used in case of stationary problem to set elements for rhs More...
MoFEMErrorCode	ThermalElement::setThermalFiniteElementLhsOperators (string field_name, Mat A)
	this function is used in case of stationary heat conductivity problem for lhs More...
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 More...
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 More...
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 More...

Detailed Description

Function Documentation

addThermalConvectionElement()

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

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 621 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"
	)

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 527 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"
	)

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 574 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"
	)

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 659 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
	)

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

Definition at line 713 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
	)

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

Definition at line 699 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"
	)

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

Definition at line 724 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"
	)

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

Definition at line 774 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"
	)

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