diff --git a/demos/StationaryHeatTransfer.py b/demos/StationaryHeatTransfer.py new file mode 100644 index 0000000000000000000000000000000000000000..5e12b94000466de16292d325d83b5829cd341663 --- /dev/null +++ b/demos/StationaryHeatTransfer.py @@ -0,0 +1,121 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Fri Feb 1 08:49:11 2019 + +@author: bleyerj +""" +from dolfin import * +import mfront_wrapper as mf +import numpy as np + +length = 30e-3 +width = 5.4e-3 +mesh = RectangleMesh(Point(0., 0.), Point(length, width), 100, 10) + +V = FunctionSpace(mesh, "CG", 2) +T = Function(V, name="Temperature") + +def left(x, on_boundary): + return near(x[1], 0) and on_boundary +def right(x, on_boundary): + return near(x[0], length) and on_boundary + +Tl = 300 +Tr = 800 + +bc = [DirichletBC(V, Constant(Tl), left), + DirichletBC(V, Constant(Tr), right)] + +facets = MeshFunction("size_t", mesh, dim-1) +ds = Measure("ds", subdomain_data=facets) + + + +material = mf.MFrontNonlinearMaterial("../materials/src/libBehaviour.so", + "StationaryHeatTransfer", + hypothesis="plane_strain") +problem = mf.MFrontNonlinearProblem(T, material) +problem.bc = bc + +j = Function(Wjs, name="Current heat flux") +gT = Function(WgTs, name="Current temperature gradient") +dj_ddgT = Function(W_dj_ddgT_s, name="Derivative of the Heat Flux with respect to the temperature gradient") +dj_ddT = Function(W_dj_ddT_s, name="Derivative of the Heat Flux with respect to the temperature") + +T0 = Function(V, name="Temperature at the beginning of the time step") +T1 = Function(V, name="Temperature estimate at the end of the end step") +dT = Function(V, name="Iteration correction") +v = TrialFunction(V) +T_ = TestFunction(V) + +# definition of the stiffness matrix and residual using standard FEniCS operations +a_Newton = (inner(grad(v), dot(as_tensor(dj_ddgT), grad(T_)))+ + 0*inner(grad(v), as_vector(dj_ddT))*T_)*dxm +# a_Newton = inner(grad(v), dot(as_tensor(dj_ddgT), grad(T_)))*dxm +res = -inner(grad(T_), j)*dxm + +problem.a = inner(self.strain_variation(self.du), dot(self.Ct, self.strain_variation(self.u_)))*measure*self.dx +problam.L = inner(self.strain_variation(self.u_), self.stress)*measure*self.dxl value of the deformation gradient +# using `MFront` conventions +T0.assign(Constant(Tl)) +local_project(grad(T0), WgTs, gT) +# copy the strain values to `MGIS` +m.s0.gradients[:, :] = gT.vector().get_local().reshape((m.n, sj)) +m.s1.gradients[:, :] = gT.vector().get_local().reshape((m.n, sj)) + +it = mgis_bv.IntegrationType.IntegrationWithConsistentTangentOperator +mgis_bv.integrate(m, it, 0, 0, m.n); +bs = sj*sj+sj*1 + +dj_ddgT.vector().set_local(np.lib.stride_tricks.as_strided(m.K,shape = (m.K.size // bs, sj, sj), + strides = (m.K.strides[1] * bs, + m.K.strides[1] * sj, + m.K.strides[1])).flatten()) +dj_ddgT.vector().apply("insert") +dj_ddT.vector().set_local(np.lib.stride_tricks.as_strided(m.K[sj*sj:], + shape = (m.K.size // bs, sj), + strides = (m.K.strides[1] * bs, + m.K.strides[1])).flatten()) +dj_ddT.vector().apply("insert") +print(dj_ddT.vector().norm("l2")) + + +T.assign(T0) +problem.solve(T.vector()) + +niter = 0 +tol = 1.e-8 +Nitermax = 200 +while nRes/nRes0 > tol and niter < Nitermax: + solve(A, dT.vector(), Res, "mumps") + # update the current estimate of the displacement at the end of the time step + T1.assign(T1+dT) + # compute the current estimate of the strain at the end of the + # time step using `MFront` conventions + local_project(grad(T1), WgTs, gT) + # copy the strain values to `MGIS` + m.s1.gradients[:, :] = gT.vector().get_local().reshape((m.n, sj)) + # integrate the behaviour + it = mgis_bv.IntegrationType.IntegrationWithConsistentTangentOperator + # no time step here + mgis_bv.integrate(m, it, 0, 0, m.n); + # getting the stress and consistent tangent operator back to + # the FEniCS world. + j.vector().set_local(m.s1.thermodynamic_forces.flatten()) + j.vector().apply("insert") + dj_ddgT.vector().set_local(np.lib.stride_tricks.as_strided(m.K,shape = (m.K.size // bs, sj, sj), + strides = (m.K.strides[1] * bs, + m.K.strides[1] * sj, + m.K.strides[1])).flatten()) + dj_ddgT.vector().apply("insert") + dj_ddT.vector().set_local(np.lib.stride_tricks.as_strided(m.K[sj*sj:], + shape = (m.K.size // bs, sj), + strides = (m.K.strides[1] * bs, + m.K.strides[1])).flatten()) + dj_ddT.vector().apply("insert") + # solve Newton system + A, Res = assemble_system(a_Newton, res, bc0) + nRes = Res.norm("l2") + print(" Residual:", nRes) + niter += 1 diff --git a/materials/StationaryHeatTransfer.mfront b/materials/StationaryHeatTransfer.mfront new file mode 100644 index 0000000000000000000000000000000000000000..4f06db4083b2f3b88c26193c5f0e027371c9e0ae --- /dev/null +++ b/materials/StationaryHeatTransfer.mfront @@ -0,0 +1,28 @@ +@DSL DefaultGenericBehaviour; +@Behaviour StationaryHeatTransfer; +@Author Thomas Helfer; +@Date 15/02/2019; + +@Gradient TemperatureGradient gT; +gT.setGlossaryName("TemperatureGradient"); + +@Flux HeatFlux j; +j.setGlossaryName("HeatFlux"); + +@AdditionalTangentOperatorBlock dj_ddT; + +@Parameter A = 0.0375; +@Parameter B = 2.165e-4; + +@LocalVariable thermalconductivity k; + +@Integrator{ + const auto T_ = T + dT; + k = 1 / (A + B * T_); + j = k * (gT + dgT); +} // end of @Integrator + +@TangentOperator { + dj_ddgT = k * tmatrix::Id(); + dj_ddT = -B * k * k * (gT + dgT); +} // end of @TangentOperator diff --git a/materials/include/MFront/GenericBehaviour/StationaryHeatTransfer-generic.hxx b/materials/include/MFront/GenericBehaviour/StationaryHeatTransfer-generic.hxx new file mode 100644 index 0000000000000000000000000000000000000000..c158d80b044f392051a294d1c15bc599e6a17e02 --- /dev/null +++ b/materials/include/MFront/GenericBehaviour/StationaryHeatTransfer-generic.hxx @@ -0,0 +1,67 @@ +/*! +* \file StationaryHeatTransfer-generic.hxx +* \brief This file declares the umat interface for the StationaryHeatTransfer behaviour law +* \author Thomas Helfer +* \date 15 / 02 / 2019 +*/ + +#ifndef LIB_GENERIC_STATIONARYHEATTRANSFER_HXX +#define LIB_GENERIC_STATIONARYHEATTRANSFER_HXX + +#include"TFEL/Config/TFELConfig.hxx" +#include"MFront/GenericBehaviour/BehaviourData.h" + +#ifdef _WIN32 +#ifndef NOMINMAX +#define NOMINMAX +#endif /* NOMINMAX */ +#include +#ifdef small +#undef small +#endif /* small */ +#endif /* _WIN32 */ + +#ifndef MFRONT_SHAREDOBJ +#define MFRONT_SHAREDOBJ TFEL_VISIBILITY_EXPORT +#endif /* MFRONT_SHAREDOBJ */ + +#ifdef __cplusplus +extern "C"{ +#endif /* __cplusplus */ + +MFRONT_SHAREDOBJ void +StationaryHeatTransfer_setOutOfBoundsPolicy(const int); + +MFRONT_SHAREDOBJ int +StationaryHeatTransfer_setParameter(const char *const,const double); + +/*! + * \param[in,out] d: material data + */ +MFRONT_SHAREDOBJ int StationaryHeatTransfer_AxisymmetricalGeneralisedPlaneStrain(MFront_GB_BehaviourData* const); + +/*! + * \param[in,out] d: material data + */ +MFRONT_SHAREDOBJ int StationaryHeatTransfer_Axisymmetrical(MFront_GB_BehaviourData* const); + +/*! + * \param[in,out] d: material data + */ +MFRONT_SHAREDOBJ int StationaryHeatTransfer_PlaneStrain(MFront_GB_BehaviourData* const); + +/*! + * \param[in,out] d: material data + */ +MFRONT_SHAREDOBJ int StationaryHeatTransfer_GeneralisedPlaneStrain(MFront_GB_BehaviourData* const); + +/*! + * \param[in,out] d: material data + */ +MFRONT_SHAREDOBJ int StationaryHeatTransfer_Tridimensional(MFront_GB_BehaviourData* const); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* LIB_GENERIC_STATIONARYHEATTRANSFER_HXX */ diff --git a/materials/include/TFEL/Material/StationaryHeatTransfer.hxx b/materials/include/TFEL/Material/StationaryHeatTransfer.hxx new file mode 100644 index 0000000000000000000000000000000000000000..8b2855e766bd957908b84c5ad3ad9008fceb31f1 --- /dev/null +++ b/materials/include/TFEL/Material/StationaryHeatTransfer.hxx @@ -0,0 +1,525 @@ +/*! +* \file TFEL/Material/StationaryHeatTransfer.hxx +* \brief this file implements the StationaryHeatTransfer Behaviour. +* File generated by tfel version 3.3.0 +* \author Thomas Helfer +* \date 15 / 02 / 2019 + */ + +#ifndef LIB_TFELMATERIAL_STATIONARYHEATTRANSFER_HXX +#define LIB_TFELMATERIAL_STATIONARYHEATTRANSFER_HXX + +#include +#include +#include +#include +#include + +#include"TFEL/Raise.hxx" +#include"TFEL/PhysicalConstants.hxx" +#include"TFEL/Config/TFELConfig.hxx" +#include"TFEL/Config/TFELTypes.hxx" +#include"TFEL/Metaprogramming/StaticAssert.hxx" +#include"TFEL/TypeTraits/IsFundamentalNumericType.hxx" +#include"TFEL/TypeTraits/IsReal.hxx" +#include"TFEL/Math/General/IEEE754.hxx" +#include"TFEL/Math/Vector/TVectorView.hxx" +#include"TFEL/Math/Matrix/TMatrixView.hxx" +#include"TFEL/Material/MaterialException.hxx" +#include"TFEL/Material/MechanicalBehaviour.hxx" +#include"TFEL/Material/MechanicalBehaviourTraits.hxx" +#include"TFEL/Material/OutOfBoundsPolicy.hxx" +#include"TFEL/Material/BoundsCheck.hxx" +#include"TFEL/Material/IsotropicPlasticity.hxx" +#include"TFEL/Material/Lame.hxx" +#include"TFEL/Material/Hosford1972YieldCriterion.hxx" +#include"TFEL/Material/StationaryHeatTransferBehaviourData.hxx" +#include"TFEL/Material/StationaryHeatTransferIntegrationData.hxx" + +#include "MFront/GenericBehaviour/State.hxx" +#include "MFront/GenericBehaviour/BehaviourData.hxx" +namespace tfel{ + +namespace material{ + +struct StationaryHeatTransferParametersInitializer +{ +static StationaryHeatTransferParametersInitializer& +get(); + +double A; +double B; +double minimal_time_step_scaling_factor; +double maximal_time_step_scaling_factor; + +void set(const char* const,const double); + +/*! + * \brief convert a string to double + * \param[in] p : parameter + * \param[in] v : value + */ +static double getDouble(const std::string&,const std::string&); +private : + +StationaryHeatTransferParametersInitializer(); + +StationaryHeatTransferParametersInitializer(const StationaryHeatTransferParametersInitializer&); + +StationaryHeatTransferParametersInitializer& +operator=(const StationaryHeatTransferParametersInitializer&); +/*! + * \brief read the parameters from the given file + * \param[out] pi : parameters initializer + * \param[in] fn : file name + */ +static void readParameters(StationaryHeatTransferParametersInitializer&,const char* const); +}; + +//! \brief forward declaration +template +class StationaryHeatTransfer; + +//! \brief forward declaration +template +std::ostream& + operator <<(std::ostream&,const StationaryHeatTransfer&); + +/*! +* \class StationaryHeatTransfer +* \brief This class implements the StationaryHeatTransfer behaviour. +* \param hypothesis, modelling hypothesis. +* \param Type, numerical type. +* \author Thomas Helfer +* \date 15 / 02 / 2019 +*/ +template +class StationaryHeatTransfer final +: public MechanicalBehaviour, +public StationaryHeatTransferBehaviourData, +public StationaryHeatTransferIntegrationData +{ + +static constexpr unsigned short N = ModellingHypothesisToSpaceDimension::value; + +TFEL_STATIC_ASSERT(N==1||N==2||N==3); +TFEL_STATIC_ASSERT(tfel::typetraits::IsFundamentalNumericType::cond); +TFEL_STATIC_ASSERT(tfel::typetraits::IsReal::cond); + +friend std::ostream& operator<< <>(std::ostream&,const StationaryHeatTransfer&); + +static constexpr unsigned short TVectorSize = N; +typedef tfel::math::StensorDimeToSize StensorDimeToSize; +static constexpr unsigned short StensorSize = StensorDimeToSize::value; +typedef tfel::math::TensorDimeToSize TensorDimeToSize; +static constexpr unsigned short TensorSize = TensorDimeToSize::value; + +using ushort = unsigned short; +using Types = tfel::config::Types; +using real = typename Types::real; +using time = typename Types::time; +using length = typename Types::length; +using frequency = typename Types::frequency; +using stress = typename Types::stress; +using strain = typename Types::strain; +using strainrate = typename Types::strainrate; +using stressrate = typename Types::stressrate; +using temperature = typename Types::temperature; +using thermalexpansion = typename Types::thermalexpansion; +using thermalconductivity = typename Types::thermalconductivity; +using massdensity = typename Types::massdensity; +using energydensity = typename Types::energydensity; +using TVector = typename Types::TVector; +using Stensor = typename Types::Stensor; +using Stensor4 = typename Types::Stensor4; +using FrequencyStensor = typename Types::FrequencyStensor; +using ForceTVector = typename Types::ForceTVector; +using StressStensor = typename Types::StressStensor; +using StressRateStensor = typename Types::StressRateStensor; +using DisplacementTVector = typename Types::DisplacementTVector; +using StrainStensor = typename Types::StrainStensor; +using StrainRateStensor = typename Types::StrainRateStensor; +using StiffnessTensor = typename Types::StiffnessTensor; +using Tensor = typename Types::Tensor; +using FrequencyTensor = typename Types::FrequencyTensor; +using StressTensor = typename Types::StressTensor; +using ThermalExpansionCoefficientTensor = typename Types::ThermalExpansionCoefficientTensor; +using DeformationGradientTensor = typename Types::DeformationGradientTensor; +using DeformationGradientRateTensor = typename Types::DeformationGradientRateTensor; +using TemperatureGradient = typename Types::TemperatureGradient; +using HeatFlux = typename Types::HeatFlux; +using TangentOperator = tfel::math::tvector<(TVectorSize)*(TVectorSize)+(TVectorSize)*(1),real>; +using PhysicalConstants = tfel::PhysicalConstants; + +public : + +typedef StationaryHeatTransferBehaviourData BehaviourData; +typedef StationaryHeatTransferIntegrationData IntegrationData; +typedef typename MechanicalBehaviour::SMFlag SMFlag; +typedef typename MechanicalBehaviour::SMType SMType; +using MechanicalBehaviour::ELASTIC; +using MechanicalBehaviour::SECANTOPERATOR; +using MechanicalBehaviour::TANGENTOPERATOR; +using MechanicalBehaviour::CONSISTENTTANGENTOPERATOR; +using MechanicalBehaviour::NOSTIFFNESSREQUESTED; +using IntegrationResult = typename MechanicalBehaviour::IntegrationResult; + +using MechanicalBehaviour::SUCCESS; +using MechanicalBehaviour::FAILURE; +using MechanicalBehaviour::UNRELIABLE_RESULTS; + +private : + + + + +#line 17 "StationaryHeatTransfer.mfront" +thermalconductivity k; + +#line 14 "StationaryHeatTransfer.mfront" +real A; +#line 15 "StationaryHeatTransfer.mfront" +real B; +real minimal_time_step_scaling_factor; +real maximal_time_step_scaling_factor; + +//! Tangent operator; +TangentOperator Dt; +tfel::math::TMatrixView dj_ddgT; +tfel::math::TVectorView dj_ddT; +/*! +* \brief Update internal variables at end of integration +*/ +void updateIntegrationVariables() +{} + +/*! +* \brief Update internal variables at end of integration +*/ +void updateStateVariables() +{} + +/*! +* \brief Update auxiliary state variables at end of integration +*/ +void updateAuxiliaryStateVariables() +{} + +//! \brief Default constructor (disabled) +StationaryHeatTransfer() =delete ; +//! \brief Copy constructor (disabled) +StationaryHeatTransfer(const StationaryHeatTransfer&) = delete; +//! \brief Assignement operator (disabled) +StationaryHeatTransfer& operator = (const StationaryHeatTransfer&) = delete; + +public: + +/*! +* \brief Constructor +*/ +StationaryHeatTransfer(const StationaryHeatTransferBehaviourData& src1, +const StationaryHeatTransferIntegrationData& src2) +: StationaryHeatTransferBehaviourData(src1), +StationaryHeatTransferIntegrationData(src2), +dj_ddgT(Dt.begin()), +dj_ddT(Dt.begin()+TVectorSize*TVectorSize) +{ +using namespace std; +using namespace tfel::math; +using std::vector; +this->A = StationaryHeatTransferParametersInitializer::get().A; +this->B = StationaryHeatTransferParametersInitializer::get().B; +this->minimal_time_step_scaling_factor = StationaryHeatTransferParametersInitializer::get().minimal_time_step_scaling_factor; +this->maximal_time_step_scaling_factor = StationaryHeatTransferParametersInitializer::get().maximal_time_step_scaling_factor; +} + +/* + * \brief constructor for the Generic interface + * \param[in] mgb_d: behaviour data + */ +StationaryHeatTransfer(const mfront::gb::BehaviourData& mgb_d) +: StationaryHeatTransferBehaviourData(mgb_d), +StationaryHeatTransferIntegrationData(mgb_d), +dj_ddgT(Dt.begin()), +dj_ddT(Dt.begin()+TVectorSize*TVectorSize) +{ +using namespace std; +using namespace tfel::math; +using std::vector; +this->A = StationaryHeatTransferParametersInitializer::get().A; +this->B = StationaryHeatTransferParametersInitializer::get().B; +this->minimal_time_step_scaling_factor = StationaryHeatTransferParametersInitializer::get().minimal_time_step_scaling_factor; +this->maximal_time_step_scaling_factor = StationaryHeatTransferParametersInitializer::get().maximal_time_step_scaling_factor; +tfel::fsalgo::copy::exe(mgb_d.s0.gradients,this->gT.begin()); +tfel::fsalgo::transform::exe(mgb_d.s1.gradients,mgb_d.s0.gradients,this->dgT.begin(),std::minus()); +tfel::fsalgo::copy::exe(mgb_d.s0.thermodynamic_forces,this->j.begin()); +} + +/*! + * \ brief initialize the behaviour with user code + */ +void initialize(){ +using namespace std; +using namespace tfel::math; +using std::vector; +} + +/*! +* \brief set the policy for "out of bounds" conditions +*/ +void +setOutOfBoundsPolicy(const OutOfBoundsPolicy policy_value){ +this->policy = policy_value; +} // end of setOutOfBoundsPolicy + +/*! +* \return the modelling hypothesis +*/ +constexpr ModellingHypothesis::Hypothesis +getModellingHypothesis() const{ +return hypothesis; +} // end of getModellingHypothesis + +/*! +* \brief check bounds +*/ +void checkBounds() const{ +} // end of checkBounds + +IntegrationResult computePredictionOperator(const SMFlag,const SMType) override{ +tfel::raise("StationaryHeatTransfer::computePredictionOperator: " +"unsupported prediction operator flag"); +} + +real getMinimalTimeStepScalingFactor() const override{ + return this->minimal_time_step_scaling_factor; +} + +std::pair +computeAPrioriTimeStepScalingFactor(const real current_time_step_scaling_factor) const override{ +const auto time_scaling_factor = this->computeAPrioriTimeStepScalingFactorII(); +return {time_scaling_factor.first, + std::min(std::min(std::max(time_scaling_factor.second, + this->minimal_time_step_scaling_factor), + this->maximal_time_step_scaling_factor), + current_time_step_scaling_factor)}; +} + +/*! +* \brief Integrate behaviour over the time step +*/ +IntegrationResult +integrate(const SMFlag smflag, const SMType smt) override{ +using namespace std; +using namespace tfel::math; +raise_if(smflag!=MechanicalBehaviour::STANDARDTANGENTOPERATOR, +"invalid tangent operator flag"); +bool computeTangentOperator_ = smt!=NOSTIFFNESSREQUESTED; +#line 20 "StationaryHeatTransfer.mfront" +const auto T_ = this->T + this->dT; +#line 21 "StationaryHeatTransfer.mfront" +this->k = 1 / (this->A + this->B * T_); +#line 22 "StationaryHeatTransfer.mfront" +this->j = this->k * (this->gT + this->dgT); +this->updateIntegrationVariables(); +this->updateStateVariables(); +this->updateAuxiliaryStateVariables(); +if(computeTangentOperator_){ +if(!this->computeConsistentTangentOperator(smt)){ +return MechanicalBehaviour::FAILURE; +} +} +return MechanicalBehaviour::SUCCESS; +} + +std::pair +computeAPosterioriTimeStepScalingFactor(const real current_time_step_scaling_factor) const override{ +const auto time_scaling_factor = this->computeAPosterioriTimeStepScalingFactorII(); +return {time_scaling_factor.first, + std::min(std::min(std::max(time_scaling_factor.second, + this->minimal_time_step_scaling_factor), + this->maximal_time_step_scaling_factor), + current_time_step_scaling_factor)}; +} + +/*! +* \brief Update the internal energy at end of the time step +* \param[in] Psi_s: internal energy at end of the time step +*/ +void computeInternalEnergy(real& Psi_s) const +{ +Psi_s=0; +} + +/*! +* \brief Update the dissipated energy at end of the time step +* \param[in] Psi_d: dissipated energy at end of the time step +*/ +void computeDissipatedEnergy(real& Psi_d) const +{ +Psi_d=0; +} + +bool computeConsistentTangentOperator(const SMType smt){ +using namespace std; +using namespace tfel::math; +using std::vector; +#line 26 "StationaryHeatTransfer.mfront" +this->dj_ddgT = this->k * tmatrix::Id(); +#line 27 "StationaryHeatTransfer.mfront" +dj_ddT = -this->B * this->k * this->k * (this->gT + this->dgT); +return true; +} + +const TangentOperator& getTangentOperator() const{ +return this->Dt; +} + +void updateExternalStateVariables(){ +this->gT += this->dgT; +this->T += this->dT; +} + +//! +~StationaryHeatTransfer() + override = default; + +private: + +std::pair computeAPrioriTimeStepScalingFactorII() const{ +return {true,this->maximal_time_step_scaling_factor}; +} + +std::pair computeAPosterioriTimeStepScalingFactorII() const{ +return {true,this->maximal_time_step_scaling_factor}; +} + +//! policy for treating out of bounds conditions +OutOfBoundsPolicy policy = None; +}; // end of StationaryHeatTransfer class + +template +std::ostream& +operator <<(std::ostream& os,const StationaryHeatTransfer& b) +{ +os << "gT : " << b.gT << '\n'; +os << "ΔgT : " << b.dgT << '\n'; +os << "j : " << b.j << '\n'; +os << "Δt : " << b.dt << '\n'; +os << "T : " << b.T << '\n'; +os << "ΔT : " << b.dT << '\n'; +os << "k : " << b.k << '\n'; +os << "A : " << b.A << '\n'; +os << "B : " << b.B << '\n'; +os << "minimal_time_step_scaling_factor : " << b.minimal_time_step_scaling_factor << '\n'; +os << "maximal_time_step_scaling_factor : " << b.maximal_time_step_scaling_factor << '\n'; +return os; +} + +/*! +* Partial specialisation for StationaryHeatTransfer. +*/ +template +class MechanicalBehaviourTraits > +{ +static constexpr unsigned short N = ModellingHypothesisToSpaceDimension::value; +static constexpr unsigned short TVectorSize = N; +typedef tfel::math::StensorDimeToSize StensorDimeToSize; +static constexpr unsigned short StensorSize = StensorDimeToSize::value; +typedef tfel::math::TensorDimeToSize TensorDimeToSize; +static constexpr unsigned short TensorSize = TensorDimeToSize::value; +public: +static constexpr bool is_defined = true; +static constexpr bool use_quantities = false; +static constexpr bool hasStressFreeExpansion = false; +static constexpr bool handlesThermalExpansion = false; +static constexpr unsigned short dimension = N; +typedef Type NumType; +static constexpr unsigned short material_properties_nb = 0; +static constexpr unsigned short internal_variables_nb = 0; +static constexpr unsigned short external_variables_nb = 1; +static constexpr unsigned short external_variables_nb2 = 0; +static constexpr bool hasConsistentTangentOperator = true; +static constexpr bool isConsistentTangentOperatorSymmetric = false; +static constexpr bool hasPredictionOperator = false; +static constexpr bool hasAPrioriTimeStepScalingFactor = false; +static constexpr bool hasComputeInternalEnergy = false; +static constexpr bool hasComputeDissipatedEnergy = false; +/*! +* \return the name of the class. +*/ +static const char* getName(){ +return "StationaryHeatTransfer"; +} + +}; + +/*! +* Partial specialisation for StationaryHeatTransfer. +*/ +template +class MechanicalBehaviourTraits > +{ +public: +static constexpr bool is_defined = false; +static constexpr bool use_quantities = false; +static constexpr bool hasStressFreeExpansion = false; +static constexpr bool handlesThermalExpansion = false; +static constexpr unsigned short dimension = 0u; +typedef Type NumType; +static constexpr unsigned short material_properties_nb = 0; +static constexpr unsigned short internal_variables_nb = 0; +static constexpr unsigned short external_variables_nb = 0; +static constexpr unsigned short external_variables_nb2 = 0; +static constexpr bool hasConsistentTangentOperator = false; +static constexpr bool isConsistentTangentOperatorSymmetric = false; +static constexpr bool hasPredictionOperator = false; +static constexpr bool hasAPrioriTimeStepScalingFactor = false; +static constexpr bool hasComputeInternalEnergy = false; +static constexpr bool hasComputeDissipatedEnergy = false; +/*! +* \return the name of the class. +*/ +static const char* getName(){ +return "StationaryHeatTransfer"; +} + +}; + +/*! +* Partial specialisation for StationaryHeatTransfer. +*/ +template +class MechanicalBehaviourTraits > +{ +public: +static constexpr bool is_defined = false; +static constexpr bool use_quantities = false; +static constexpr bool hasStressFreeExpansion = false; +static constexpr bool handlesThermalExpansion = false; +static constexpr unsigned short dimension = 0u; +typedef Type NumType; +static constexpr unsigned short material_properties_nb = 0; +static constexpr unsigned short internal_variables_nb = 0; +static constexpr unsigned short external_variables_nb = 0; +static constexpr unsigned short external_variables_nb2 = 0; +static constexpr bool hasConsistentTangentOperator = false; +static constexpr bool isConsistentTangentOperatorSymmetric = false; +static constexpr bool hasPredictionOperator = false; +static constexpr bool hasAPrioriTimeStepScalingFactor = false; +static constexpr bool hasComputeInternalEnergy = false; +static constexpr bool hasComputeDissipatedEnergy = false; +/*! +* \return the name of the class. +*/ +static const char* getName(){ +return "StationaryHeatTransfer"; +} + +}; + +} // end of namespace material + +} // end of namespace tfel + +#endif /* LIB_TFELMATERIAL_STATIONARYHEATTRANSFER_HXX */ diff --git a/materials/include/TFEL/Material/StationaryHeatTransferBehaviourData.hxx b/materials/include/TFEL/Material/StationaryHeatTransferBehaviourData.hxx new file mode 100644 index 0000000000000000000000000000000000000000..41134dac0ba220da8bd892c773657cb0479b351e --- /dev/null +++ b/materials/include/TFEL/Material/StationaryHeatTransferBehaviourData.hxx @@ -0,0 +1,181 @@ +/*! +* \file TFEL/Material/StationaryHeatTransferBehaviourData.hxx +* \brief this file implements the StationaryHeatTransferBehaviourData class. +* File generated by tfel version 3.3.0 +* \author Thomas Helfer +* \date 15 / 02 / 2019 + */ + +#ifndef LIB_TFELMATERIAL_STATIONARYHEATTRANSFER_BEHAVIOUR_DATA_HXX +#define LIB_TFELMATERIAL_STATIONARYHEATTRANSFER_BEHAVIOUR_DATA_HXX + +#include +#include +#include +#include +#include +#include + +#include"TFEL/Raise.hxx" +#include"TFEL/PhysicalConstants.hxx" +#include"TFEL/Config/TFELConfig.hxx" +#include"TFEL/Config/TFELTypes.hxx" +#include"TFEL/Metaprogramming/StaticAssert.hxx" +#include"TFEL/TypeTraits/IsFundamentalNumericType.hxx" +#include"TFEL/TypeTraits/IsReal.hxx" +#include"TFEL/Math/General/IEEE754.hxx" +#include"TFEL/Math/stensor.hxx" +#include"TFEL/Math/Stensor/StensorConceptIO.hxx" +#include"TFEL/Math/tmatrix.hxx" +#include"TFEL/Math/Matrix/tmatrixIO.hxx" +#include"TFEL/Math/st2tost2.hxx" +#include"TFEL/Math/ST2toST2/ST2toST2ConceptIO.hxx" +#include"TFEL/Material/ModellingHypothesis.hxx" + +#include "MFront/GenericBehaviour/State.hxx" +#include "MFront/GenericBehaviour/BehaviourData.hxx" +namespace tfel{ + +namespace material{ + +//! \brief forward declaration +template +class StationaryHeatTransferBehaviourData; + +//! \brief forward declaration +template +class StationaryHeatTransferIntegrationData; + +//! \brief forward declaration +template +std::ostream& + operator <<(std::ostream&,const StationaryHeatTransferBehaviourData&); + +template +class StationaryHeatTransferBehaviourData +{ + +static constexpr unsigned short N = ModellingHypothesisToSpaceDimension::value; +TFEL_STATIC_ASSERT(N==1||N==2||N==3); +TFEL_STATIC_ASSERT(tfel::typetraits::IsFundamentalNumericType::cond); +TFEL_STATIC_ASSERT(tfel::typetraits::IsReal::cond); + +friend std::ostream& operator<< <>(std::ostream&,const StationaryHeatTransferBehaviourData&); + +/* integration data is declared friend to access driving variables at the beginning of the time step */ +friend class StationaryHeatTransferIntegrationData; + +static constexpr unsigned short TVectorSize = N; +typedef tfel::math::StensorDimeToSize StensorDimeToSize; +static constexpr unsigned short StensorSize = StensorDimeToSize::value; +typedef tfel::math::TensorDimeToSize TensorDimeToSize; +static constexpr unsigned short TensorSize = TensorDimeToSize::value; + +using ushort = unsigned short; +using Types = tfel::config::Types; +using real = typename Types::real; +using time = typename Types::time; +using length = typename Types::length; +using frequency = typename Types::frequency; +using stress = typename Types::stress; +using strain = typename Types::strain; +using strainrate = typename Types::strainrate; +using stressrate = typename Types::stressrate; +using temperature = typename Types::temperature; +using thermalexpansion = typename Types::thermalexpansion; +using thermalconductivity = typename Types::thermalconductivity; +using massdensity = typename Types::massdensity; +using energydensity = typename Types::energydensity; +using TVector = typename Types::TVector; +using Stensor = typename Types::Stensor; +using Stensor4 = typename Types::Stensor4; +using FrequencyStensor = typename Types::FrequencyStensor; +using ForceTVector = typename Types::ForceTVector; +using StressStensor = typename Types::StressStensor; +using StressRateStensor = typename Types::StressRateStensor; +using DisplacementTVector = typename Types::DisplacementTVector; +using StrainStensor = typename Types::StrainStensor; +using StrainRateStensor = typename Types::StrainRateStensor; +using StiffnessTensor = typename Types::StiffnessTensor; +using Tensor = typename Types::Tensor; +using FrequencyTensor = typename Types::FrequencyTensor; +using StressTensor = typename Types::StressTensor; +using ThermalExpansionCoefficientTensor = typename Types::ThermalExpansionCoefficientTensor; +using DeformationGradientTensor = typename Types::DeformationGradientTensor; +using DeformationGradientRateTensor = typename Types::DeformationGradientRateTensor; +using TemperatureGradient = typename Types::TemperatureGradient; +using HeatFlux = typename Types::HeatFlux; +using TangentOperator = tfel::math::tvector<(TVectorSize)*(TVectorSize)+(TVectorSize)*(1),real>; +using PhysicalConstants = tfel::PhysicalConstants; + +protected: + +TemperatureGradient gT; + +HeatFlux j; + + +temperature T; + +public: + +/*! +* \brief Default constructor +*/ +StationaryHeatTransferBehaviourData() +{} + +/*! +* \brief Copy constructor +*/ +StationaryHeatTransferBehaviourData(const StationaryHeatTransferBehaviourData& src) +: gT(src.gT), +j(src.j) +, +T(src.T) +{} + +/* + * \brief constructor for the Generic interface + * \param[in] mgb_d: behaviour data + */ +StationaryHeatTransferBehaviourData(const mfront::gb::BehaviourData& mgb_d) +: T(mgb_d.s0.external_state_variables[0]) +{ +} + + +/* +* \brief Assignement operator +*/ +StationaryHeatTransferBehaviourData& +operator=(const StationaryHeatTransferBehaviourData& src){ +this->gT = src.gT; +this->j = src.j; +this->T = src.T; +return *this; +} + +void exportStateData(mfront::gb::State& mbg_s1) const +{ +using namespace tfel::math; +tfel::fsalgo::copy::exe(this->j.begin(), mbg_s1.thermodynamic_forces); +} // end of exportStateData + +}; // end of StationaryHeatTransferBehaviourDataclass + +template +std::ostream& +operator <<(std::ostream& os,const StationaryHeatTransferBehaviourData& b) +{ +os << "gT : " << b.gT << '\n'; +os << "j : " << b.j << '\n'; +os << "T : " << b.T << '\n'; +return os; +} + +} // end of namespace material + +} // end of namespace tfel + +#endif /* LIB_TFELMATERIAL_STATIONARYHEATTRANSFER_BEHAVIOUR_DATA_HXX */ diff --git a/materials/include/TFEL/Material/StationaryHeatTransferIntegrationData.hxx b/materials/include/TFEL/Material/StationaryHeatTransferIntegrationData.hxx new file mode 100644 index 0000000000000000000000000000000000000000..936ed938b0981d8b28948f96c2c64915d0a838c6 --- /dev/null +++ b/materials/include/TFEL/Material/StationaryHeatTransferIntegrationData.hxx @@ -0,0 +1,183 @@ +/*! +* \file TFEL/Material/StationaryHeatTransferIntegrationData.hxx +* \brief this file implements the StationaryHeatTransferIntegrationData class. +* File generated by tfel version 3.3.0 +* \author Thomas Helfer +* \date 15 / 02 / 2019 + */ + +#ifndef LIB_TFELMATERIAL_STATIONARYHEATTRANSFER_INTEGRATION_DATA_HXX +#define LIB_TFELMATERIAL_STATIONARYHEATTRANSFER_INTEGRATION_DATA_HXX + +#include +#include +#include +#include +#include + +#include"TFEL/Raise.hxx" +#include"TFEL/PhysicalConstants.hxx" +#include"TFEL/Config/TFELConfig.hxx" +#include"TFEL/Config/TFELTypes.hxx" +#include"TFEL/Metaprogramming/StaticAssert.hxx" +#include"TFEL/TypeTraits/IsFundamentalNumericType.hxx" +#include"TFEL/TypeTraits/IsScalar.hxx" +#include"TFEL/TypeTraits/IsReal.hxx" +#include"TFEL/TypeTraits/Promote.hxx" +#include"TFEL/Math/General/IEEE754.hxx" +#include"TFEL/Math/stensor.hxx" +#include"TFEL/Math/st2tost2.hxx" +#include "MFront/GenericBehaviour/State.hxx" +#include "MFront/GenericBehaviour/BehaviourData.hxx" +namespace tfel{ + +namespace material{ + +//! \brief forward declaration +template +class StationaryHeatTransferIntegrationData; + +//! \brief forward declaration +template +std::ostream& + operator <<(std::ostream&,const StationaryHeatTransferIntegrationData&); + +template +class StationaryHeatTransferIntegrationData +{ + +static constexpr unsigned short N = ModellingHypothesisToSpaceDimension::value; +TFEL_STATIC_ASSERT(N==1||N==2||N==3); +TFEL_STATIC_ASSERT(tfel::typetraits::IsFundamentalNumericType::cond); +TFEL_STATIC_ASSERT(tfel::typetraits::IsReal::cond); + +friend std::ostream& operator<< <>(std::ostream&,const StationaryHeatTransferIntegrationData&); + +static constexpr unsigned short TVectorSize = N; +typedef tfel::math::StensorDimeToSize StensorDimeToSize; +static constexpr unsigned short StensorSize = StensorDimeToSize::value; +typedef tfel::math::TensorDimeToSize TensorDimeToSize; +static constexpr unsigned short TensorSize = TensorDimeToSize::value; + +using ushort = unsigned short; +using Types = tfel::config::Types; +using real = typename Types::real; +using time = typename Types::time; +using length = typename Types::length; +using frequency = typename Types::frequency; +using stress = typename Types::stress; +using strain = typename Types::strain; +using strainrate = typename Types::strainrate; +using stressrate = typename Types::stressrate; +using temperature = typename Types::temperature; +using thermalexpansion = typename Types::thermalexpansion; +using thermalconductivity = typename Types::thermalconductivity; +using massdensity = typename Types::massdensity; +using energydensity = typename Types::energydensity; +using TVector = typename Types::TVector; +using Stensor = typename Types::Stensor; +using Stensor4 = typename Types::Stensor4; +using FrequencyStensor = typename Types::FrequencyStensor; +using ForceTVector = typename Types::ForceTVector; +using StressStensor = typename Types::StressStensor; +using StressRateStensor = typename Types::StressRateStensor; +using DisplacementTVector = typename Types::DisplacementTVector; +using StrainStensor = typename Types::StrainStensor; +using StrainRateStensor = typename Types::StrainRateStensor; +using StiffnessTensor = typename Types::StiffnessTensor; +using Tensor = typename Types::Tensor; +using FrequencyTensor = typename Types::FrequencyTensor; +using StressTensor = typename Types::StressTensor; +using ThermalExpansionCoefficientTensor = typename Types::ThermalExpansionCoefficientTensor; +using DeformationGradientTensor = typename Types::DeformationGradientTensor; +using DeformationGradientRateTensor = typename Types::DeformationGradientRateTensor; +using TemperatureGradient = typename Types::TemperatureGradient; +using HeatFlux = typename Types::HeatFlux; +using TangentOperator = tfel::math::tvector<(TVectorSize)*(TVectorSize)+(TVectorSize)*(1),real>; +using PhysicalConstants = tfel::PhysicalConstants; + +protected: + +/*! + * \brief gT increment + */ +TemperatureGradient dgT; + +/*! + * \brief time increment + */ +time dt; + +temperature dT; +public: + +/*! +* \brief Default constructor +*/ +StationaryHeatTransferIntegrationData() +{} + +/*! +* \brief Copy constructor +*/ +StationaryHeatTransferIntegrationData(const StationaryHeatTransferIntegrationData& src) +: dgT(src.dgT), +dt(src.dt), +dT(src.dT) +{} + +/* + * \brief constructor for the Generic interface + * \param[in] mgb_d: behaviour data + */ +StationaryHeatTransferIntegrationData(const mfront::gb::BehaviourData& mgb_d) +: dt(mgb_d.dt), +dT(mgb_d.s1.external_state_variables[0]-mgb_d.s0.external_state_variables[0]) +{ +} + + +/* +* \brief scale the integration data by a scalar. +*/ +template +typename std::enable_if< +tfel::typetraits::IsFundamentalNumericType::cond&& +tfel::typetraits::IsScalar::cond&& +tfel::typetraits::IsReal::cond&& +std::is_same::type>::value, +StationaryHeatTransferIntegrationData& +>::type +scale(const StationaryHeatTransferBehaviourData&, const Scal time_scaling_factor){ +this->dt *= time_scaling_factor; +this->dgT *= time_scaling_factor; +this->dT *= time_scaling_factor; +return *this; +} + +/*! +* \brief update the driving variable in case of substepping. +*/ +StationaryHeatTransferIntegrationData& +updateDrivingVariables(const StationaryHeatTransferBehaviourData&){ +return *this; +} + +}; // end of StationaryHeatTransferIntegrationDataclass + +template +std::ostream& +operator <<(std::ostream& os,const StationaryHeatTransferIntegrationData& b) +{ +os << "ΔgT : " << b.dgT << '\n'; +os << "j : " << b.j << '\n'; +os << "Δt : " << b.dt << '\n'; +os << "ΔT : " << b.dT << '\n'; +return os; +} + +} // end of namespace material + +} // end of namespace tfel + +#endif /* LIB_TFELMATERIAL_STATIONARYHEATTRANSFER_INTEGRATION_DATA_HXX */ diff --git a/materials/src/StationaryHeatTransfer-generic.cxx b/materials/src/StationaryHeatTransfer-generic.cxx new file mode 100644 index 0000000000000000000000000000000000000000..f6b6207fa16699ca6dcbd53cbf21dff0efc11757 --- /dev/null +++ b/materials/src/StationaryHeatTransfer-generic.cxx @@ -0,0 +1,192 @@ +/*! +* \file StationaryHeatTransfer-generic.cxx +* \brief This file implements the umat interface for the StationaryHeatTransfer behaviour law +* \author Thomas Helfer +* \date 15 / 02 / 2019 +*/ + +#ifdef _WIN32 +#ifndef NOMINMAX +#define NOMINMAX +#endif /* NOMINMAX */ +#include +#ifdef small +#undef small +#endif /* small */ +#endif /* _WIN32 */ + +#ifndef MFRONT_SHAREDOBJ +#define MFRONT_SHAREDOBJ TFEL_VISIBILITY_EXPORT +#endif /* MFRONT_SHAREDOBJ */ + +#include +#include +#include"TFEL/Material/OutOfBoundsPolicy.hxx" +#include"TFEL/Material/StationaryHeatTransfer.hxx" +#include"MFront/GenericBehaviour/Integrate.hxx" + +#include"MFront/GenericBehaviour/StationaryHeatTransfer-generic.hxx" + +static tfel::material::OutOfBoundsPolicy& +StationaryHeatTransfer_getOutOfBoundsPolicy(){ +using namespace tfel::material; +static OutOfBoundsPolicy policy = None; +return policy; +} + +#ifdef __cplusplus +extern "C"{ +#endif /* __cplusplus */ + +MFRONT_SHAREDOBJ const char* +StationaryHeatTransfer_build_id = ""; + +MFRONT_SHAREDOBJ const char* +StationaryHeatTransfer_mfront_ept = "StationaryHeatTransfer"; + +MFRONT_SHAREDOBJ const char* +StationaryHeatTransfer_tfel_version = "3.3.0"; + +MFRONT_SHAREDOBJ unsigned short StationaryHeatTransfer_mfront_mkt = 1u; + +MFRONT_SHAREDOBJ const char * +StationaryHeatTransfer_mfront_interface = "Generic"; + +MFRONT_SHAREDOBJ const char * +StationaryHeatTransfer_src = "StationaryHeatTransfer.mfront"; + +MFRONT_SHAREDOBJ unsigned short StationaryHeatTransfer_nModellingHypotheses = 5u; + +MFRONT_SHAREDOBJ const char * +StationaryHeatTransfer_ModellingHypotheses[5u] = {"AxisymmetricalGeneralisedPlaneStrain", +"Axisymmetrical", +"PlaneStrain", +"GeneralisedPlaneStrain", +"Tridimensional"}; + +MFRONT_SHAREDOBJ unsigned short StationaryHeatTransfer_nMainVariables = 1; +MFRONT_SHAREDOBJ unsigned short StationaryHeatTransfer_nGradients = 1; + +MFRONT_SHAREDOBJ int StationaryHeatTransfer_GradientsTypes[1] = {2}; +MFRONT_SHAREDOBJ const char * StationaryHeatTransfer_Gradients[1] = {"TemperatureGradient"}; +MFRONT_SHAREDOBJ unsigned short StationaryHeatTransfer_nThermodynamicForces = 1; + +MFRONT_SHAREDOBJ int StationaryHeatTransfer_ThermodynamicForcesTypes[1] = {2}; +MFRONT_SHAREDOBJ const char * StationaryHeatTransfer_ThermodynamicForces[1] = {"HeatFlux"}; +MFRONT_SHAREDOBJ unsigned short StationaryHeatTransfer_nTangentOperatorBlocks = 4; + +MFRONT_SHAREDOBJ const char * StationaryHeatTransfer_TangentOperatorBlocks[4] = {"HeatFlux", +"TemperatureGradient","HeatFlux","Temperature"}; +MFRONT_SHAREDOBJ unsigned short StationaryHeatTransfer_BehaviourType = 0u; + +MFRONT_SHAREDOBJ unsigned short StationaryHeatTransfer_BehaviourKinematic = 0u; + +MFRONT_SHAREDOBJ unsigned short StationaryHeatTransfer_SymmetryType = 0u; + +MFRONT_SHAREDOBJ unsigned short StationaryHeatTransfer_ElasticSymmetryType = 0u; + +MFRONT_SHAREDOBJ unsigned short StationaryHeatTransfer_UsableInPurelyImplicitResolution = 0; + +MFRONT_SHAREDOBJ unsigned short StationaryHeatTransfer_nMaterialProperties = 0u; + +MFRONT_SHAREDOBJ const char * const *StationaryHeatTransfer_MaterialProperties = nullptr; + +MFRONT_SHAREDOBJ unsigned short StationaryHeatTransfer_nInternalStateVariables = 0; +MFRONT_SHAREDOBJ const char * const * StationaryHeatTransfer_InternalStateVariables = nullptr; + +MFRONT_SHAREDOBJ const int * StationaryHeatTransfer_InternalStateVariablesTypes = nullptr; + +MFRONT_SHAREDOBJ unsigned short StationaryHeatTransfer_nExternalStateVariables = 0; +MFRONT_SHAREDOBJ const char * const * StationaryHeatTransfer_ExternalStateVariables = nullptr; + +MFRONT_SHAREDOBJ unsigned short StationaryHeatTransfer_nParameters = 4; +MFRONT_SHAREDOBJ const char * StationaryHeatTransfer_Parameters[4] = {"A", +"B","minimal_time_step_scaling_factor","maximal_time_step_scaling_factor"}; +MFRONT_SHAREDOBJ int StationaryHeatTransfer_ParametersTypes [] = {0,0,0,0}; + +MFRONT_SHAREDOBJ double StationaryHeatTransfer_A_ParameterDefaultValue = 0.0375; + +MFRONT_SHAREDOBJ double StationaryHeatTransfer_B_ParameterDefaultValue = 0.0002165; + +MFRONT_SHAREDOBJ double StationaryHeatTransfer_minimal_time_step_scaling_factor_ParameterDefaultValue = 0.1; + +MFRONT_SHAREDOBJ double StationaryHeatTransfer_maximal_time_step_scaling_factor_ParameterDefaultValue = 1.7976931348623e+308; + +MFRONT_SHAREDOBJ unsigned short StationaryHeatTransfer_requiresStiffnessTensor = 0; +MFRONT_SHAREDOBJ unsigned short StationaryHeatTransfer_requiresThermalExpansionCoefficientTensor = 0; + +MFRONT_SHAREDOBJ void +StationaryHeatTransfer_setOutOfBoundsPolicy(const int p){ +if(p==0){ +StationaryHeatTransfer_getOutOfBoundsPolicy() = tfel::material::None; +} else if(p==1){ +StationaryHeatTransfer_getOutOfBoundsPolicy() = tfel::material::Warning; +} else if(p==2){ +StationaryHeatTransfer_getOutOfBoundsPolicy() = tfel::material::Strict; +} else { +std::cerr << "StationaryHeatTransfer_setOutOfBoundsPolicy: invalid argument\n"; +} +} + +MFRONT_SHAREDOBJ int +StationaryHeatTransfer_setParameter(const char *const key,const double value){ +using tfel::material::StationaryHeatTransferParametersInitializer; +auto& i = StationaryHeatTransferParametersInitializer::get(); +try{ +i.set(key,value); +} catch(std::runtime_error& e){ +std::cerr << e.what() << std::endl; +return 0; +} +return 1; +} + +MFRONT_SHAREDOBJ int StationaryHeatTransfer_AxisymmetricalGeneralisedPlaneStrain(MFront_GB_BehaviourData* const d){ +using namespace tfel::material; +using real = mfront::gb::real; +constexpr const auto h = ModellingHypothesis::AXISYMMETRICALGENERALISEDPLANESTRAIN; +using Behaviour = StationaryHeatTransfer; +const auto r = mfront::gb::integrate(*d,Behaviour::STANDARDTANGENTOPERATOR, StationaryHeatTransfer_getOutOfBoundsPolicy()); +return r; +} // end of StationaryHeatTransfer_AxisymmetricalGeneralisedPlaneStrain + +MFRONT_SHAREDOBJ int StationaryHeatTransfer_Axisymmetrical(MFront_GB_BehaviourData* const d){ +using namespace tfel::material; +using real = mfront::gb::real; +constexpr const auto h = ModellingHypothesis::AXISYMMETRICAL; +using Behaviour = StationaryHeatTransfer; +const auto r = mfront::gb::integrate(*d,Behaviour::STANDARDTANGENTOPERATOR, StationaryHeatTransfer_getOutOfBoundsPolicy()); +return r; +} // end of StationaryHeatTransfer_Axisymmetrical + +MFRONT_SHAREDOBJ int StationaryHeatTransfer_PlaneStrain(MFront_GB_BehaviourData* const d){ +using namespace tfel::material; +using real = mfront::gb::real; +constexpr const auto h = ModellingHypothesis::PLANESTRAIN; +using Behaviour = StationaryHeatTransfer; +const auto r = mfront::gb::integrate(*d,Behaviour::STANDARDTANGENTOPERATOR, StationaryHeatTransfer_getOutOfBoundsPolicy()); +return r; +} // end of StationaryHeatTransfer_PlaneStrain + +MFRONT_SHAREDOBJ int StationaryHeatTransfer_GeneralisedPlaneStrain(MFront_GB_BehaviourData* const d){ +using namespace tfel::material; +using real = mfront::gb::real; +constexpr const auto h = ModellingHypothesis::GENERALISEDPLANESTRAIN; +using Behaviour = StationaryHeatTransfer; +const auto r = mfront::gb::integrate(*d,Behaviour::STANDARDTANGENTOPERATOR, StationaryHeatTransfer_getOutOfBoundsPolicy()); +return r; +} // end of StationaryHeatTransfer_GeneralisedPlaneStrain + +MFRONT_SHAREDOBJ int StationaryHeatTransfer_Tridimensional(MFront_GB_BehaviourData* const d){ +using namespace tfel::material; +using real = mfront::gb::real; +constexpr const auto h = ModellingHypothesis::TRIDIMENSIONAL; +using Behaviour = StationaryHeatTransfer; +const auto r = mfront::gb::integrate(*d,Behaviour::STANDARDTANGENTOPERATOR, StationaryHeatTransfer_getOutOfBoundsPolicy()); +return r; +} // end of StationaryHeatTransfer_Tridimensional + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + diff --git a/materials/src/StationaryHeatTransfer-generic.d b/materials/src/StationaryHeatTransfer-generic.d new file mode 100644 index 0000000000000000000000000000000000000000..6fe2c26641ec4f77889cf377cc5bd8650fb2871f --- /dev/null +++ b/materials/src/StationaryHeatTransfer-generic.d @@ -0,0 +1,461 @@ +StationaryHeatTransfer-generic.o StationaryHeatTransfer-generic.d : StationaryHeatTransfer-generic.cxx \ + /usr/include/stdc-predef.h /usr/include/c++/8/iostream \ + /usr/include/x86_64-linux-gnu/c++/8/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/8/bits/os_defines.h \ + /usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/c++/8/bits/cpu_defines.h \ + /usr/include/c++/8/ostream /usr/include/c++/8/ios \ + /usr/include/c++/8/iosfwd /usr/include/c++/8/bits/stringfwd.h \ + /usr/include/c++/8/bits/memoryfwd.h /usr/include/c++/8/bits/postypes.h \ + /usr/include/c++/8/cwchar /usr/include/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/lib/gcc/x86_64-linux-gnu/8/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/8/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/wchar2.h /usr/include/c++/8/exception \ + /usr/include/c++/8/bits/exception.h \ + /usr/include/c++/8/bits/exception_ptr.h \ + /usr/include/c++/8/bits/exception_defines.h \ + /usr/include/c++/8/bits/cxxabi_init_exception.h \ + /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \ + /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \ + /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \ + /usr/include/c++/8/type_traits /usr/include/c++/8/bits/char_traits.h \ + /usr/include/c++/8/bits/stl_algobase.h \ + /usr/include/c++/8/bits/functexcept.h \ + /usr/include/c++/8/bits/cpp_type_traits.h \ + /usr/include/c++/8/ext/type_traits.h \ + /usr/include/c++/8/ext/numeric_traits.h \ + /usr/include/c++/8/bits/stl_pair.h \ + /usr/include/c++/8/bits/stl_iterator_base_types.h \ + /usr/include/c++/8/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/8/debug/assertions.h \ + /usr/include/c++/8/bits/stl_iterator.h \ + /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \ + /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/cstdint \ + /usr/lib/gcc/x86_64-linux-gnu/8/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/c++/8/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/8/bits/c++locale.h \ + /usr/include/c++/8/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/8/cctype \ + /usr/include/ctype.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/8/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/8/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/c++/8/bits/atomic_word.h \ + /usr/include/c++/8/bits/locale_classes.h /usr/include/c++/8/string \ + /usr/include/c++/8/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/8/bits/c++allocator.h \ + /usr/include/c++/8/ext/new_allocator.h \ + /usr/include/c++/8/bits/ostream_insert.h \ + /usr/include/c++/8/bits/cxxabi_forced.h \ + /usr/include/c++/8/bits/stl_function.h \ + /usr/include/c++/8/backward/binders.h \ + /usr/include/c++/8/bits/range_access.h \ + /usr/include/c++/8/initializer_list \ + /usr/include/c++/8/bits/basic_string.h \ + /usr/include/c++/8/ext/alloc_traits.h \ + /usr/include/c++/8/bits/alloc_traits.h \ + /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \ + /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/select2.h /usr/include/alloca.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib.h \ + /usr/include/c++/8/bits/std_abs.h /usr/include/c++/8/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/sys_errlist.h \ + /usr/include/x86_64-linux-gnu/bits/stdio.h \ + /usr/include/x86_64-linux-gnu/bits/stdio2.h /usr/include/c++/8/cerrno \ + /usr/include/errno.h /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/linux/errno.h /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/8/bits/functional_hash.h \ + /usr/include/c++/8/bits/basic_string.tcc \ + /usr/include/c++/8/bits/locale_classes.tcc \ + /usr/include/c++/8/system_error \ + /usr/include/x86_64-linux-gnu/c++/8/bits/error_constants.h \ + /usr/include/c++/8/stdexcept /usr/include/c++/8/streambuf \ + /usr/include/c++/8/bits/streambuf.tcc \ + /usr/include/c++/8/bits/basic_ios.h \ + /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \ + /usr/include/wctype.h /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/c++/8/bits/ctype_base.h \ + /usr/include/c++/8/bits/streambuf_iterator.h \ + /usr/include/x86_64-linux-gnu/c++/8/bits/ctype_inline.h \ + /usr/include/c++/8/bits/locale_facets.tcc \ + /usr/include/c++/8/bits/basic_ios.tcc \ + /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \ + /usr/include/c++/8/bits/istream.tcc \ + /usr/local/include/TFEL/Material/OutOfBoundsPolicy.hxx \ + ../include/TFEL/Material/StationaryHeatTransfer.hxx \ + /usr/include/c++/8/limits /usr/include/c++/8/algorithm \ + /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \ + /usr/include/c++/8/bits/stl_algo.h \ + /usr/include/c++/8/bits/algorithmfwd.h \ + /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \ + /usr/include/c++/8/bits/stl_construct.h \ + /usr/include/c++/8/bits/uniform_int_dist.h \ + /usr/local/include/TFEL/Raise.hxx \ + /usr/local/include/TFEL/Config/TFELConfig.hxx \ + /usr/local/include/TFEL/Config/TFEL_MATH_Config.hxx \ + /usr/local/include/TFEL/Raise.ixx \ + /usr/local/include/TFEL/PhysicalConstants.hxx \ + /usr/local/include/TFEL/Config/TFELTypes.hxx \ + /usr/local/include/TFEL/Math/Forward/qt.hxx \ + /usr/local/include/TFEL/Math/Forward/tvector.hxx \ + /usr/local/include/TFEL/Math/Forward/tmatrix.hxx \ + /usr/local/include/TFEL/TypeTraits/BaseType.hxx \ + /usr/local/include/TFEL/Math/Forward/Complex.hxx \ + /usr/include/c++/8/ciso646 \ + /usr/local/include/TFEL/Math/Forward/tensor.hxx \ + /usr/local/include/TFEL/Math/Forward/stensor.hxx \ + /usr/local/include/TFEL/Math/Forward/t2tost2.hxx \ + /usr/local/include/TFEL/Math/Forward/st2tost2.hxx \ + /usr/local/include/TFEL/Math/Stensor/StensorSizeToDime.hxx \ + /usr/local/include/TFEL/Math/Tensor/TensorSizeToDime.hxx \ + /usr/local/include/TFEL/Config/Internals/TFELTypesInternals.hxx \ + /usr/local/include/TFEL/Config/Internals/PositionType.hxx \ + /usr/local/include/TFEL/Math/tvector.hxx /usr/include/c++/8/cstddef \ + /usr/include/c++/8/iterator /usr/include/c++/8/bits/stream_iterator.h \ + /usr/local/include/TFEL/Metaprogramming/StaticAssert.hxx \ + /usr/local/include/TFEL/Macros.hxx \ + /usr/local/include/TFEL/TypeTraits/IsAssignableTo.hxx \ + /usr/local/include/TFEL/TypeTraits/Promote.hxx \ + /usr/local/include/TFEL/TypeTraits/Promote/Promote.ixx \ + /usr/local/include/TFEL/TypeTraits/RealPartType.hxx \ + /usr/local/include/TFEL/Metaprogramming/InvalidType.hxx \ + /usr/local/include/TFEL/TypeTraits/IsSafelyReinterpretCastableTo.hxx \ + /usr/local/include/TFEL/FSAlgorithm/copy.hxx \ + /usr/local/include/TFEL/TypeTraits/IsRandomAccessIterator.hxx \ + /usr/local/include/TFEL/Math/fsarray.hxx \ + /usr/local/include/TFEL/Math/General/fsarray.ixx \ + /usr/local/include/TFEL/Math/General/Abs.hxx /usr/include/c++/8/cmath \ + /usr/include/math.h /usr/include/x86_64-linux-gnu/bits/math-vector.h \ + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \ + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \ + /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ + /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h \ + /usr/include/x86_64-linux-gnu/bits/iscanonical.h \ + /usr/include/x86_64-linux-gnu/bits/mathinline.h \ + /usr/include/c++/8/functional /usr/include/c++/8/tuple \ + /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \ + /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \ + /usr/include/c++/8/bits/std_function.h \ + /usr/local/include/TFEL/TypeTraits/AbsType.hxx \ + /usr/local/include/TFEL/TypeTraits/IsFundamentalNumericType.hxx \ + /usr/local/include/TFEL/Math/General/Abs.ixx \ + /usr/local/include/TFEL/Math/General/BasicOperations.hxx \ + /usr/local/include/TFEL/TypeTraits/IsScalar.hxx \ + /usr/local/include/TFEL/TypeTraits/IsComplex.hxx \ + /usr/local/include/TFEL/TypeTraits/IsUnaryOperator.hxx \ + /usr/local/include/TFEL/Math/General/ComputeBinaryResult.hxx \ + /usr/local/include/TFEL/Math/General/ResultType.hxx \ + /usr/local/include/TFEL/TypeTraits/IsInvalid.hxx \ + /usr/local/include/TFEL/Math/General/ComputeObjectTag.hxx \ + /usr/local/include/TFEL/Math/General/ComputeObjectTag.ixx \ + /usr/local/include/TFEL/Math/General/ComputeUnaryResult.hxx \ + /usr/local/include/TFEL/Math/General/UnaryResultType.hxx \ + /usr/local/include/TFEL/Math/General/EmptyRunTimeProperties.hxx \ + /usr/local/include/TFEL/Math/Vector/VectorConcept.hxx \ + /usr/local/include/TFEL/Math/General/ConceptRebind.hxx \ + /usr/local/include/TFEL/Math/Forward/VectorConcept.hxx \ + /usr/local/include/TFEL/Math/Vector/VectorConcept.ixx \ + /usr/local/include/TFEL/Math/Vector/VectorConceptOperations.hxx \ + /usr/local/include/TFEL/Metaprogramming/Implements.hxx \ + /usr/local/include/TFEL/Math/ExpressionTemplates/Expr.hxx \ + /usr/local/include/TFEL/Metaprogramming/ResultOf.hxx \ + /usr/local/include/TFEL/Metaprogramming/IsConstCallable.hxx \ + /usr/local/include/TFEL/Math/ExpressionTemplates/StandardOperations.hxx \ + /usr/local/include/TFEL/Math/Vector/VectorVectorDotProduct.hxx \ + /usr/local/include/TFEL/Math/General/RunTimeCheck.hxx \ + /usr/local/include/TFEL/Math/MathException.hxx \ + /usr/local/include/TFEL/Exception/TFELException.hxx \ + /usr/local/include/TFEL/Math/Vector/VectorConceptOperations.ixx \ + /usr/local/include/TFEL/Math/Vector/TinyVectorFromTinyVectorView.hxx \ + /usr/local/include/TFEL/Math/Vector/VectorUtilities.hxx \ + /usr/local/include/TFEL/Math/Vector/tvector.ixx \ + /usr/local/include/TFEL/FSAlgorithm/FSAlgorithm.hxx \ + /usr/local/include/TFEL/FSAlgorithm/loop.hxx \ + /usr/local/include/TFEL/FSAlgorithm/fill.hxx \ + /usr/local/include/TFEL/FSAlgorithm/equal.hxx \ + /usr/local/include/TFEL/FSAlgorithm/transform.hxx \ + /usr/local/include/TFEL/FSAlgorithm/for_each.hxx \ + /usr/local/include/TFEL/FSAlgorithm/swap_ranges.hxx \ + /usr/local/include/TFEL/FSAlgorithm/generate.hxx \ + /usr/local/include/TFEL/FSAlgorithm/min_element.hxx \ + /usr/local/include/TFEL/FSAlgorithm/max_element.hxx \ + /usr/local/include/TFEL/FSAlgorithm/accumulate.hxx \ + /usr/local/include/TFEL/FSAlgorithm/inner_product.hxx \ + /usr/local/include/TFEL/FSAlgorithm/iota.hxx \ + /usr/local/include/TFEL/Math/General/DotProduct.hxx \ + /usr/local/include/TFEL/Math/Vector/tvectorResultType.hxx \ + /usr/local/include/TFEL/Math/Quantity/Unit.hxx /usr/include/c++/8/ratio \ + /usr/local/include/TFEL/Math/Quantity/Unit.ixx \ + /usr/local/include/TFEL/Config/Internals/SpatialGradType.hxx \ + /usr/local/include/TFEL/Config/Internals/InvJacobianType.hxx \ + /usr/local/include/TFEL/Math/tmatrix.hxx \ + /usr/local/include/TFEL/Math/Matrix/MatrixConcept.hxx \ + /usr/local/include/TFEL/Math/Forward/MatrixConcept.hxx \ + /usr/local/include/TFEL/Math/Matrix/MatrixConcept.ixx \ + /usr/local/include/TFEL/Math/Matrix/MatrixConceptOperations.hxx \ + /usr/local/include/TFEL/Math/power.hxx \ + /usr/local/include/TFEL/Math/power.ixx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_row_view.hxx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_row_view.ixx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_const_row_view.hxx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_const_row_view.ixx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_column_view.hxx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_column_view.ixx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_const_column_view.hxx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_const_column_view.ixx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_submatrix_view.hxx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_submatrix_view.ixx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_const_submatrix_view.hxx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_const_submatrix_view.ixx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix.ixx \ + /usr/local/include/TFEL/Math/General/AbsCompare.hxx \ + /usr/local/include/TFEL/Math/Matrix/MatrixUtilities.hxx \ + /usr/local/include/TFEL/Math/Matrix/MatrixUtilities.ixx \ + /usr/local/include/TFEL/Math/Matrix/tmatrixResultType.hxx \ + /usr/local/include/TFEL/Math/Matrix/TVectorTMatrixExpr.hxx \ + /usr/local/include/TFEL/Math/General/ObjectObjectRandomAccessConstIterator.hxx \ + /usr/local/include/TFEL/Math/Matrix/TMatrixTVectorExpr.hxx \ + /usr/local/include/TFEL/Config/Internals/JacobianType.hxx \ + /usr/local/include/TFEL/Config/Internals/TemperatureGradientType.hxx \ + /usr/local/include/TFEL/Config/Internals/HeatFluxVectorType.hxx \ + /usr/local/include/TFEL/Config/Internals/ThermalConductivityMatrixType.hxx \ + /usr/local/include/TFEL/TypeTraits/IsReal.hxx \ + /usr/local/include/TFEL/Math/General/IEEE754.hxx \ + /usr/local/include/TFEL/Math/General/IEEE754.ixx \ + /usr/include/c++/8/cfloat \ + /usr/lib/gcc/x86_64-linux-gnu/8/include/float.h \ + /usr/local/include/TFEL/Math/Vector/TVectorView.hxx \ + /usr/local/include/TFEL/Math/Matrix/TMatrixView.hxx \ + /usr/local/include/TFEL/Material/MaterialException.hxx \ + /usr/local/include/TFEL/Material/MechanicalBehaviour.hxx \ + /usr/local/include/TFEL/Material/ModellingHypothesis.hxx \ + /usr/include/c++/8/vector /usr/include/c++/8/bits/stl_uninitialized.h \ + /usr/include/c++/8/bits/stl_vector.h \ + /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \ + /usr/local/include/TFEL/Material/FiniteStrainBehaviourTangentOperatorBase.hxx \ + /usr/local/include/TFEL/Material/MechanicalBehaviourTraits.hxx \ + /usr/local/include/TFEL/Material/BoundsCheck.hxx \ + /usr/local/include/TFEL/Math/qt.hxx \ + /usr/local/include/TFEL/Metaprogramming/TypeList.hxx \ + /usr/local/include/TFEL/Metaprogramming/TypeList.ixx \ + /usr/local/include/TFEL/Metaprogramming/Forward/TypeList.hxx \ + /usr/local/include/TFEL/Metaprogramming/IsSubClassOf.hxx \ + /usr/local/include/TFEL/Metaprogramming/GenerateTypeList.hxx \ + /usr/local/include/TFEL/Math/Quantity/qtLimits.hxx \ + /usr/local/include/TFEL/Math/Quantity/qtSpecific.hxx \ + /usr/local/include/TFEL/Math/Quantity/qtSamples.hxx \ + /usr/local/include/TFEL/Math/Quantity/qt.ixx \ + /usr/local/include/TFEL/Math/Quantity/qtOperations.hxx \ + /usr/local/include/TFEL/Math/Quantity/qtOperations.ixx \ + /usr/local/include/TFEL/Math/stensor.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/ST2toST2Concept.hxx \ + /usr/local/include/TFEL/Math/Forward/TensorConcept.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/ST2toST2Concept.ixx \ + /usr/local/include/TFEL/Math/LU/LUDecomp.hxx \ + /usr/local/include/TFEL/Math/LU/LUException.hxx \ + /usr/local/include/TFEL/Math/LU/LUDecomp.ixx \ + /usr/local/include/TFEL/Math/LU/TinyPermutation.hxx \ + /usr/local/include/TFEL/Math/LU/TinyPermutation.ixx \ + /usr/local/include/TFEL/Math/ST2toST2/ST2toST2TransposeExpr.hxx \ + /usr/local/include/TFEL/Math/Forward/ST2toST2Concept.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/ST2toST2ConceptPushForward.ixx \ + /usr/local/include/TFEL/Math/General/MathConstants.hxx \ + /usr/local/include/TFEL/Metaprogramming/EmptyClass.hxx \ + /usr/local/include/TFEL/Math/General/ConstExprMathFunctions.hxx \ + /usr/local/include/TFEL/Math/Stensor/StensorConcept.hxx \ + /usr/local/include/TFEL/Math/Stensor/StensorConcept.ixx \ + /usr/local/include/TFEL/Math/Stensor/StensorConceptOperations.hxx \ + /usr/local/include/TFEL/Math/Stensor/StensorProduct.hxx \ + /usr/local/include/TFEL/Math/Tensor/TensorConcept.hxx \ + /usr/local/include/TFEL/Math/Tensor/TensorTransposeExpr.hxx \ + /usr/local/include/TFEL/Math/Tensor/TensorConcept.ixx \ + /usr/local/include/TFEL/Math/Tensor/MatrixViewFromTensor.hxx \ + /usr/local/include/TFEL/Math/Stensor/StensorConceptOperations.ixx \ + /usr/local/include/TFEL/Math/Stensor/stensor.ixx \ + /usr/local/include/TFEL/Math/Stensor/SymmetricStensorProduct.hxx \ + /usr/local/include/TFEL/Math/Stensor/SymmetricStensorProduct.ixx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorImport.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorExport.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorExport.ixx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorChangeBasis.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorInvert.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorDeterminant.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/BuildStensorFromMatrix.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/BuildStensorFromVectorDiadicProduct.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/BuildStensorFromVectorsSymmetricDiadicProduct.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/BuildStensorFromEigenValuesAndVectors.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorEigenSolver.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/FSESSymmetricEigenSolver.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/FSESSymmetricEigenSolver.ixx \ + /usr/local/include/FSES/syevc3.hxx /usr/local/include/FSES/syevc3.ixx \ + /usr/local/include/FSES/Utilities.hxx \ + /usr/local/include/FSES/Utilities.ixx /usr/local/include/FSES/syevv3.hxx \ + /usr/local/include/FSES/syevv3.ixx \ + /usr/local/include/TFEL/Math/Stensor/Internals/GteSymmetricEigenSolver.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/GteSymmetricEigenSolver.ixx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorComputeEigenValues.hxx \ + /usr/local/include/TFEL/Math/General/CubicRoots.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorComputeEigenVectors.hxx \ + /usr/include/c++/8/cassert /usr/include/assert.h \ + /usr/local/include/FSES/syevj3.hxx /usr/local/include/FSES/syevj3.ixx \ + /usr/local/include/FSES/syevq3.hxx /usr/local/include/FSES/syevq3.ixx \ + /usr/local/include/FSES/sytrd3.hxx /usr/local/include/FSES/sytrd3.ixx \ + /usr/local/include/FSES/syevd3.hxx /usr/local/include/FSES/syevd3.ixx \ + /usr/local/include/FSES/syev2.hxx /usr/local/include/FSES/syev2.ixx \ + /usr/local/include/FSES/slvsec3.hxx /usr/local/include/FSES/slvsec3.ixx \ + /usr/local/include/FSES/syevh3.hxx /usr/local/include/FSES/syevh3.ixx \ + /usr/local/include/TFEL/Math/Stensor/Internals/SortEigenValues.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/SortEigenVectors.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorComputeEigenValuesDerivatives.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorComputeEigenVectorsDerivatives.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorComputeIsotropicFunctionDerivative.hxx \ + /usr/local/include/TFEL/Math/Stensor/stensorResultType.hxx \ + /usr/local/include/TFEL/Math/Stensor/DecompositionInPositiveAndNegativeParts.hxx \ + /usr/local/include/TFEL/Math/Stensor/DecompositionInPositiveAndNegativeParts.ixx \ + /usr/local/include/TFEL/Material/IsotropicPlasticity.hxx \ + /usr/local/include/TFEL/Math/st2tost2.hxx \ + /usr/local/include/TFEL/Math/T2toST2/T2toST2Concept.hxx \ + /usr/local/include/TFEL/Math/Forward/T2toST2Concept.hxx \ + /usr/local/include/TFEL/Math/T2toST2/T2toST2Concept.ixx \ + /usr/local/include/TFEL/Math/ST2toST2/ST2toST2ConceptOperations.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/ST2toST2StensorProductExpr.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/StensorST2toST2ProductExpr.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/ST2toST2ST2toST2ProductExpr.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/StensorSquareDerivative.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/st2tost2.ixx \ + /usr/local/include/TFEL/Math/General/BaseCast.hxx \ + /usr/local/include/TFEL/Math/TinyMatrixInvert.hxx \ + /usr/local/include/TFEL/Math/TinyMatrixSolve.hxx \ + /usr/local/include/TFEL/Math/LU/TinyMatrixSolve.ixx \ + /usr/local/include/TFEL/Math/Matrix/TinyMatrixInvert.ixx \ + /usr/local/include/TFEL/Math/ST2toST2/ConvertT2toST2ToST2toST2Expr.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/BuildFromRotationMatrix.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/StensorSymmetricProductDerivative.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/SymmetricStensorProductDerivative.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/SymmetricStensorProductDerivative.ixx \ + /usr/local/include/TFEL/Math/ST2toST2/ChangeBasis.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/st2tost2ResultType.hxx \ + /usr/local/include/TFEL/Material/IsotropicPlasticity.ixx \ + /usr/local/include/TFEL/Material/Lame.hxx \ + /usr/local/include/TFEL/Material/Hosford1972YieldCriterion.hxx \ + /usr/local/include/TFEL/Material/Hosford1972YieldCriterion.ixx \ + ../include/TFEL/Material/StationaryHeatTransferBehaviourData.hxx \ + /usr/include/c++/8/sstream /usr/include/c++/8/bits/sstream.tcc \ + /usr/local/include/TFEL/Math/Stensor/StensorConceptIO.hxx \ + /usr/local/include/TFEL/Math/Matrix/tmatrixIO.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/ST2toST2ConceptIO.hxx \ + /usr/local/include/MFront/GenericBehaviour/State.hxx \ + /usr/local/include/MFront/GenericBehaviour/Types.hxx \ + /usr/local/include/MFront/GenericBehaviour/Types.h \ + /usr/local/include/MFront/GenericBehaviour/State.h \ + /usr/local/include/MFront/GenericBehaviour/BehaviourData.hxx \ + /usr/local/include/MFront/GenericBehaviour/BehaviourData.h \ + ../include/TFEL/Material/StationaryHeatTransferIntegrationData.hxx \ + /usr/local/include/MFront/GenericBehaviour/Integrate.hxx \ + /usr/local/include/TFEL/Math/t2tot2.hxx \ + /usr/local/include/TFEL/Math/tensor.hxx \ + /usr/local/include/TFEL/Math/Tensor/TensorConceptOperations.hxx \ + /usr/local/include/TFEL/Math/Tensor/TensorProduct.hxx \ + /usr/local/include/TFEL/Math/Tensor/TensorViewFromStensor.hxx \ + /usr/local/include/TFEL/Math/Tensor/TensorConceptOperations.ixx \ + /usr/local/include/TFEL/Math/Tensor/tensor.ixx \ + /usr/local/include/TFEL/Math/Tensor/TensorChangeBasis.hxx \ + /usr/local/include/TFEL/Math/Tensor/tensorResultType.hxx \ + /usr/local/include/TFEL/Math/Forward/t2tot2.hxx \ + /usr/local/include/TFEL/Math/T2toT2/T2toT2Concept.hxx \ + /usr/local/include/TFEL/Math/Forward/T2toT2Concept.hxx \ + /usr/local/include/TFEL/Math/T2toT2/T2toT2Concept.ixx \ + /usr/local/include/TFEL/Math/T2toT2/T2toT2ConceptOperations.hxx \ + /usr/local/include/TFEL/Math/T2toT2/T2toT2TensorProductExpr.hxx \ + /usr/local/include/TFEL/Math/T2toT2/TensorT2toT2ProductExpr.hxx \ + /usr/local/include/TFEL/Math/T2toT2/T2toT2T2toT2ProductExpr.hxx \ + /usr/local/include/TFEL/Math/T2toT2/t2tot2.ixx \ + /usr/local/include/TFEL/Math/T2toT2/TensorProductLeftDerivativeExpr.hxx \ + /usr/local/include/TFEL/Math/T2toT2/TensorProductRightDerivativeExpr.hxx \ + /usr/local/include/TFEL/Math/T2toT2/BuildFromRotationMatrix.hxx \ + /usr/local/include/TFEL/Math/T2toT2/ChangeBasis.hxx \ + /usr/local/include/TFEL/Math/T2toT2/t2tot2ResultType.hxx \ + /usr/local/include/TFEL/Math/t2tost2.hxx \ + /usr/local/include/TFEL/Math/T2toST2/T2toST2ConceptOperations.hxx \ + /usr/local/include/TFEL/Metaprogramming/HasRandomAccessConstIterator.hxx \ + /usr/local/include/TFEL/Math/T2toST2/StensorT2toST2ProductExpr.hxx \ + /usr/local/include/TFEL/Math/T2toST2/T2toST2TensorProductExpr.hxx \ + /usr/local/include/TFEL/Math/T2toST2/ST2toST2T2toST2ProductExpr.hxx \ + /usr/local/include/TFEL/Math/T2toST2/T2toST2T2toT2ProductExpr.hxx \ + /usr/local/include/TFEL/Math/T2toST2/t2tost2.ixx \ + /usr/local/include/TFEL/Math/T2toST2/LeftCauchyGreenTensorDerivativeExpr.hxx \ + /usr/local/include/TFEL/Math/T2toST2/RightCauchyGreenTensorDerivativeExpr.hxx \ + /usr/local/include/TFEL/Math/T2toST2/t2tost2ResultType.hxx \ + /usr/local/include/TFEL/Material/FiniteStrainBehaviourTangentOperator.hxx \ + /usr/local/include/TFEL/Utilities/GenTypeBase.hxx \ + /usr/local/include/TFEL/Utilities/GenTypeCastError.hxx \ + /usr/local/include/TFEL/Utilities/GenTypeBase.ixx \ + /usr/local/include/TFEL/Utilities/GenTypeSpecialisation.ixx \ + /usr/local/include/TFEL/Material/FiniteStrainBehaviourTangentOperator.ixx \ + /usr/local/include/TFEL/Math/ST2toST2/ConvertSpatialModuliToKirchhoffJaumanRateModuli.hxx \ + /usr/local/include/TFEL/Math/T2toT2/ConvertToPK1Derivative.hxx \ + /usr/local/include/TFEL/Math/T2toT2/ConvertToPK1Derivative.ixx \ + /usr/local/include/TFEL/Math/T2toT2/ConvertFromPK1Derivative.hxx \ + /usr/local/include/TFEL/Math/T2toT2/ConvertFromPK1Derivative.ixx \ + /usr/local/include/TFEL/Material/LogarithmicStrainHandler.hxx \ + /usr/local/include/TFEL/Material/LogarithmicStrainHandler.ixx \ + /usr/local/include/TFEL/Math/ST2toST2/ST2toST2View.hxx \ + ../include/MFront/GenericBehaviour/StationaryHeatTransfer-generic.hxx diff --git a/materials/src/StationaryHeatTransfer.cxx b/materials/src/StationaryHeatTransfer.cxx new file mode 100644 index 0000000000000000000000000000000000000000..1eee9b0e68d06d4413046b0a07b56240384c458f --- /dev/null +++ b/materials/src/StationaryHeatTransfer.cxx @@ -0,0 +1,121 @@ +/*! +* \file StationaryHeatTransfer.cxx +* \brief this file implements the StationaryHeatTransfer Behaviour. +* File generated by tfel version 3.3.0 +* \author Thomas Helfer +* \date 15 / 02 / 2019 + */ + +#include +#include +#include +#include +#include + +#include"TFEL/Raise.hxx" +#include"TFEL/Material/StationaryHeatTransferBehaviourData.hxx" +#include"TFEL/Material/StationaryHeatTransferIntegrationData.hxx" +#include"TFEL/Material/StationaryHeatTransfer.hxx" + +namespace tfel{ + +namespace material{ + +StationaryHeatTransferParametersInitializer& +StationaryHeatTransferParametersInitializer::get() +{ +static StationaryHeatTransferParametersInitializer i; +return i; +} + +StationaryHeatTransferParametersInitializer::StationaryHeatTransferParametersInitializer() +{ +this->A = 0.0375; +this->B = 0.0002165; +this->minimal_time_step_scaling_factor = 0.1; +this->maximal_time_step_scaling_factor = 1.79769e+308; +// Reading parameters from a file +StationaryHeatTransferParametersInitializer::readParameters(*this,"StationaryHeatTransfer-parameters.txt"); +} + +void +StationaryHeatTransferParametersInitializer::set(const char* const key, +const double v){ +using namespace std; +if(::strcmp("A",key)==0){ +this->A = v; +} else if(::strcmp("B",key)==0){ +this->B = v; +} else if(::strcmp("minimal_time_step_scaling_factor",key)==0){ +this->minimal_time_step_scaling_factor = v; +} else if(::strcmp("maximal_time_step_scaling_factor",key)==0){ +this->maximal_time_step_scaling_factor = v; +} else { +tfel::raise("StationaryHeatTransferParametersInitializer::set: " +" no parameter named '"+std::string(key)+"'"); +} +} + +double +StationaryHeatTransferParametersInitializer::getDouble(const std::string& n, +const std::string& v) +{ +double value; +std::istringstream converter(v); +converter >> value; +tfel::raise_if(!converter||(!converter.eof()), +"StationaryHeatTransferParametersInitializer::getDouble: " +"can't convert '"+v+"' to double for parameter '"+ n+"'"); +return value; +} + +void +StationaryHeatTransferParametersInitializer::readParameters(StationaryHeatTransferParametersInitializer& pi,const char* const fn){ +auto tokenize = [](const std::string& line){ +std::istringstream tokenizer(line); +std::vector tokens; +std::copy(std::istream_iterator(tokenizer), +std::istream_iterator(), +std::back_inserter(tokens)); +return tokens; +}; +std::ifstream f(fn); +if(!f){ +return; +} +size_t ln = 1u; +while(!f.eof()){ +auto line = std::string{}; +std::getline(f,line); +auto tokens = tokenize(line); +auto throw_if = [ln,line,fn](const bool c,const std::string& m){ +tfel::raise_if(c,"StationaryHeatTransferParametersInitializer::readParameters: " +"error at line '"+std::to_string(ln)+"' " +"while reading parameter file '"+std::string(fn)+"'" +"("+m+")"); +}; +if(tokens.empty()){ +continue; +} +if(tokens[0][0]=='#'){ +continue; +} +throw_if(tokens.size()!=2u,"invalid number of tokens"); +if("A"==tokens[0]){ +pi.A = StationaryHeatTransferParametersInitializer::getDouble(tokens[0],tokens[1]); +} else if("B"==tokens[0]){ +pi.B = StationaryHeatTransferParametersInitializer::getDouble(tokens[0],tokens[1]); +} else if("minimal_time_step_scaling_factor"==tokens[0]){ +pi.minimal_time_step_scaling_factor = StationaryHeatTransferParametersInitializer::getDouble(tokens[0],tokens[1]); +} else if("maximal_time_step_scaling_factor"==tokens[0]){ +pi.maximal_time_step_scaling_factor = StationaryHeatTransferParametersInitializer::getDouble(tokens[0],tokens[1]); +} else { +throw_if(true,"invalid parameter '"+tokens[0]+"'"); +} +} +} + +} // end of namespace material + +} // end of namespace tfel + diff --git a/materials/src/StationaryHeatTransfer.d b/materials/src/StationaryHeatTransfer.d new file mode 100644 index 0000000000000000000000000000000000000000..44f5f7e88a945c2b47ff3cbaf49063e5964fdcf5 --- /dev/null +++ b/materials/src/StationaryHeatTransfer.d @@ -0,0 +1,417 @@ +StationaryHeatTransfer.o StationaryHeatTransfer.d : StationaryHeatTransfer.cxx \ + /usr/include/stdc-predef.h /usr/include/c++/8/string \ + /usr/include/x86_64-linux-gnu/c++/8/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/8/bits/os_defines.h \ + /usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/c++/8/bits/cpu_defines.h \ + /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/memoryfwd.h \ + /usr/include/c++/8/bits/char_traits.h \ + /usr/include/c++/8/bits/stl_algobase.h \ + /usr/include/c++/8/bits/functexcept.h \ + /usr/include/c++/8/bits/exception_defines.h \ + /usr/include/c++/8/bits/cpp_type_traits.h \ + /usr/include/c++/8/ext/type_traits.h \ + /usr/include/c++/8/ext/numeric_traits.h \ + /usr/include/c++/8/bits/stl_pair.h /usr/include/c++/8/bits/move.h \ + /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/type_traits \ + /usr/include/c++/8/bits/stl_iterator_base_types.h \ + /usr/include/c++/8/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/8/debug/assertions.h \ + /usr/include/c++/8/bits/stl_iterator.h \ + /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \ + /usr/include/c++/8/bits/predefined_ops.h \ + /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \ + /usr/include/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/lib/gcc/x86_64-linux-gnu/8/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/8/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/wchar2.h /usr/include/c++/8/cstdint \ + /usr/lib/gcc/x86_64-linux-gnu/8/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/c++/8/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/8/bits/c++allocator.h \ + /usr/include/c++/8/ext/new_allocator.h /usr/include/c++/8/new \ + /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \ + /usr/include/c++/8/bits/exception_ptr.h \ + /usr/include/c++/8/bits/cxxabi_init_exception.h \ + /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \ + /usr/include/c++/8/bits/nested_exception.h \ + /usr/include/c++/8/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/8/bits/c++locale.h \ + /usr/include/c++/8/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/8/iosfwd \ + /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/c++/8/bits/ostream_insert.h \ + /usr/include/c++/8/bits/cxxabi_forced.h \ + /usr/include/c++/8/bits/stl_function.h \ + /usr/include/c++/8/backward/binders.h \ + /usr/include/c++/8/bits/range_access.h \ + /usr/include/c++/8/initializer_list \ + /usr/include/c++/8/bits/basic_string.h \ + /usr/include/c++/8/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/8/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/8/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/c++/8/bits/atomic_word.h \ + /usr/include/c++/8/ext/alloc_traits.h \ + /usr/include/c++/8/bits/alloc_traits.h \ + /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \ + /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/select2.h /usr/include/alloca.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib.h \ + /usr/include/c++/8/bits/std_abs.h /usr/include/c++/8/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/sys_errlist.h \ + /usr/include/x86_64-linux-gnu/bits/stdio.h \ + /usr/include/x86_64-linux-gnu/bits/stdio2.h /usr/include/c++/8/cerrno \ + /usr/include/errno.h /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/linux/errno.h /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/8/bits/functional_hash.h \ + /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/cstring \ + /usr/include/string.h /usr/include/strings.h \ + /usr/include/x86_64-linux-gnu/bits/strings_fortified.h \ + /usr/include/x86_64-linux-gnu/bits/string_fortified.h \ + /usr/include/c++/8/sstream /usr/include/c++/8/istream \ + /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \ + /usr/include/c++/8/bits/locale_classes.h \ + /usr/include/c++/8/bits/locale_classes.tcc \ + /usr/include/c++/8/system_error \ + /usr/include/x86_64-linux-gnu/c++/8/bits/error_constants.h \ + /usr/include/c++/8/stdexcept /usr/include/c++/8/streambuf \ + /usr/include/c++/8/bits/streambuf.tcc \ + /usr/include/c++/8/bits/basic_ios.h \ + /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \ + /usr/include/wctype.h /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/c++/8/bits/ctype_base.h \ + /usr/include/c++/8/bits/streambuf_iterator.h \ + /usr/include/x86_64-linux-gnu/c++/8/bits/ctype_inline.h \ + /usr/include/c++/8/bits/locale_facets.tcc \ + /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \ + /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \ + /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/fstream \ + /usr/include/c++/8/bits/codecvt.h \ + /usr/include/x86_64-linux-gnu/c++/8/bits/basic_file.h \ + /usr/include/x86_64-linux-gnu/c++/8/bits/c++io.h \ + /usr/include/c++/8/bits/fstream.tcc /usr/local/include/TFEL/Raise.hxx \ + /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \ + /usr/local/include/TFEL/Config/TFELConfig.hxx \ + /usr/local/include/TFEL/Config/TFEL_MATH_Config.hxx \ + /usr/local/include/TFEL/Raise.ixx \ + ../include/TFEL/Material/StationaryHeatTransferBehaviourData.hxx \ + /usr/include/c++/8/limits /usr/include/c++/8/iostream \ + /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \ + /usr/include/c++/8/bits/algorithmfwd.h \ + /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \ + /usr/include/c++/8/bits/stl_construct.h \ + /usr/include/c++/8/bits/uniform_int_dist.h \ + /usr/local/include/TFEL/PhysicalConstants.hxx \ + /usr/local/include/TFEL/Config/TFELTypes.hxx \ + /usr/local/include/TFEL/Math/Forward/qt.hxx \ + /usr/local/include/TFEL/Math/Forward/tvector.hxx \ + /usr/local/include/TFEL/Math/Forward/tmatrix.hxx \ + /usr/local/include/TFEL/TypeTraits/BaseType.hxx \ + /usr/local/include/TFEL/Math/Forward/Complex.hxx \ + /usr/include/c++/8/ciso646 \ + /usr/local/include/TFEL/Math/Forward/tensor.hxx \ + /usr/local/include/TFEL/Math/Forward/stensor.hxx \ + /usr/local/include/TFEL/Math/Forward/t2tost2.hxx \ + /usr/local/include/TFEL/Math/Forward/st2tost2.hxx \ + /usr/local/include/TFEL/Math/Stensor/StensorSizeToDime.hxx \ + /usr/local/include/TFEL/Math/Tensor/TensorSizeToDime.hxx \ + /usr/local/include/TFEL/Config/Internals/TFELTypesInternals.hxx \ + /usr/local/include/TFEL/Config/Internals/PositionType.hxx \ + /usr/local/include/TFEL/Math/tvector.hxx /usr/include/c++/8/cstddef \ + /usr/include/c++/8/iterator /usr/include/c++/8/bits/stream_iterator.h \ + /usr/local/include/TFEL/Metaprogramming/StaticAssert.hxx \ + /usr/local/include/TFEL/Macros.hxx \ + /usr/local/include/TFEL/TypeTraits/IsAssignableTo.hxx \ + /usr/local/include/TFEL/TypeTraits/Promote.hxx \ + /usr/local/include/TFEL/TypeTraits/Promote/Promote.ixx \ + /usr/local/include/TFEL/TypeTraits/RealPartType.hxx \ + /usr/local/include/TFEL/Metaprogramming/InvalidType.hxx \ + /usr/local/include/TFEL/TypeTraits/IsSafelyReinterpretCastableTo.hxx \ + /usr/local/include/TFEL/FSAlgorithm/copy.hxx \ + /usr/local/include/TFEL/TypeTraits/IsRandomAccessIterator.hxx \ + /usr/local/include/TFEL/Math/fsarray.hxx \ + /usr/local/include/TFEL/Math/General/fsarray.ixx \ + /usr/local/include/TFEL/Math/General/Abs.hxx /usr/include/c++/8/cmath \ + /usr/include/math.h /usr/include/x86_64-linux-gnu/bits/math-vector.h \ + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \ + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \ + /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ + /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h \ + /usr/include/x86_64-linux-gnu/bits/iscanonical.h \ + /usr/include/x86_64-linux-gnu/bits/mathinline.h \ + /usr/include/c++/8/functional /usr/include/c++/8/tuple \ + /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \ + /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \ + /usr/include/c++/8/bits/std_function.h \ + /usr/local/include/TFEL/TypeTraits/AbsType.hxx \ + /usr/local/include/TFEL/TypeTraits/IsFundamentalNumericType.hxx \ + /usr/local/include/TFEL/Math/General/Abs.ixx \ + /usr/local/include/TFEL/Math/General/BasicOperations.hxx \ + /usr/local/include/TFEL/TypeTraits/IsScalar.hxx \ + /usr/local/include/TFEL/TypeTraits/IsComplex.hxx \ + /usr/local/include/TFEL/TypeTraits/IsUnaryOperator.hxx \ + /usr/local/include/TFEL/Math/General/ComputeBinaryResult.hxx \ + /usr/local/include/TFEL/Math/General/ResultType.hxx \ + /usr/local/include/TFEL/TypeTraits/IsInvalid.hxx \ + /usr/local/include/TFEL/Math/General/ComputeObjectTag.hxx \ + /usr/local/include/TFEL/Math/General/ComputeObjectTag.ixx \ + /usr/local/include/TFEL/Math/General/ComputeUnaryResult.hxx \ + /usr/local/include/TFEL/Math/General/UnaryResultType.hxx \ + /usr/local/include/TFEL/Math/General/EmptyRunTimeProperties.hxx \ + /usr/local/include/TFEL/Math/Vector/VectorConcept.hxx \ + /usr/local/include/TFEL/Math/General/ConceptRebind.hxx \ + /usr/local/include/TFEL/Math/Forward/VectorConcept.hxx \ + /usr/local/include/TFEL/Math/Vector/VectorConcept.ixx \ + /usr/local/include/TFEL/Math/Vector/VectorConceptOperations.hxx \ + /usr/local/include/TFEL/Metaprogramming/Implements.hxx \ + /usr/local/include/TFEL/Math/ExpressionTemplates/Expr.hxx \ + /usr/local/include/TFEL/Metaprogramming/ResultOf.hxx \ + /usr/local/include/TFEL/Metaprogramming/IsConstCallable.hxx \ + /usr/local/include/TFEL/Math/ExpressionTemplates/StandardOperations.hxx \ + /usr/local/include/TFEL/Math/Vector/VectorVectorDotProduct.hxx \ + /usr/local/include/TFEL/Math/General/RunTimeCheck.hxx \ + /usr/local/include/TFEL/Math/MathException.hxx \ + /usr/local/include/TFEL/Exception/TFELException.hxx \ + /usr/local/include/TFEL/Math/Vector/VectorConceptOperations.ixx \ + /usr/local/include/TFEL/Math/Vector/TinyVectorFromTinyVectorView.hxx \ + /usr/local/include/TFEL/Math/Vector/VectorUtilities.hxx \ + /usr/local/include/TFEL/Math/Vector/tvector.ixx \ + /usr/local/include/TFEL/FSAlgorithm/FSAlgorithm.hxx \ + /usr/local/include/TFEL/FSAlgorithm/loop.hxx \ + /usr/local/include/TFEL/FSAlgorithm/fill.hxx \ + /usr/local/include/TFEL/FSAlgorithm/equal.hxx \ + /usr/local/include/TFEL/FSAlgorithm/transform.hxx \ + /usr/local/include/TFEL/FSAlgorithm/for_each.hxx \ + /usr/local/include/TFEL/FSAlgorithm/swap_ranges.hxx \ + /usr/local/include/TFEL/FSAlgorithm/generate.hxx \ + /usr/local/include/TFEL/FSAlgorithm/min_element.hxx \ + /usr/local/include/TFEL/FSAlgorithm/max_element.hxx \ + /usr/local/include/TFEL/FSAlgorithm/accumulate.hxx \ + /usr/local/include/TFEL/FSAlgorithm/inner_product.hxx \ + /usr/local/include/TFEL/FSAlgorithm/iota.hxx \ + /usr/local/include/TFEL/Math/General/DotProduct.hxx \ + /usr/local/include/TFEL/Math/Vector/tvectorResultType.hxx \ + /usr/local/include/TFEL/Math/Quantity/Unit.hxx /usr/include/c++/8/ratio \ + /usr/local/include/TFEL/Math/Quantity/Unit.ixx \ + /usr/local/include/TFEL/Config/Internals/SpatialGradType.hxx \ + /usr/local/include/TFEL/Config/Internals/InvJacobianType.hxx \ + /usr/local/include/TFEL/Math/tmatrix.hxx \ + /usr/local/include/TFEL/Math/Matrix/MatrixConcept.hxx \ + /usr/local/include/TFEL/Math/Forward/MatrixConcept.hxx \ + /usr/local/include/TFEL/Math/Matrix/MatrixConcept.ixx \ + /usr/local/include/TFEL/Math/Matrix/MatrixConceptOperations.hxx \ + /usr/local/include/TFEL/Math/power.hxx \ + /usr/local/include/TFEL/Math/power.ixx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_row_view.hxx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_row_view.ixx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_const_row_view.hxx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_const_row_view.ixx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_column_view.hxx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_column_view.ixx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_const_column_view.hxx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_const_column_view.ixx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_submatrix_view.hxx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_submatrix_view.ixx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_const_submatrix_view.hxx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix_const_submatrix_view.ixx \ + /usr/local/include/TFEL/Math/Matrix/tmatrix.ixx \ + /usr/local/include/TFEL/Math/General/AbsCompare.hxx \ + /usr/local/include/TFEL/Math/Matrix/MatrixUtilities.hxx \ + /usr/local/include/TFEL/Math/Matrix/MatrixUtilities.ixx \ + /usr/local/include/TFEL/Math/Matrix/tmatrixResultType.hxx \ + /usr/local/include/TFEL/Math/Matrix/TVectorTMatrixExpr.hxx \ + /usr/local/include/TFEL/Math/General/ObjectObjectRandomAccessConstIterator.hxx \ + /usr/local/include/TFEL/Math/Matrix/TMatrixTVectorExpr.hxx \ + /usr/local/include/TFEL/Config/Internals/JacobianType.hxx \ + /usr/local/include/TFEL/Config/Internals/TemperatureGradientType.hxx \ + /usr/local/include/TFEL/Config/Internals/HeatFluxVectorType.hxx \ + /usr/local/include/TFEL/Config/Internals/ThermalConductivityMatrixType.hxx \ + /usr/local/include/TFEL/TypeTraits/IsReal.hxx \ + /usr/local/include/TFEL/Math/General/IEEE754.hxx \ + /usr/local/include/TFEL/Math/General/IEEE754.ixx \ + /usr/include/c++/8/cfloat \ + /usr/lib/gcc/x86_64-linux-gnu/8/include/float.h \ + /usr/local/include/TFEL/Math/stensor.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/ST2toST2Concept.hxx \ + /usr/local/include/TFEL/Math/Forward/TensorConcept.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/ST2toST2Concept.ixx \ + /usr/local/include/TFEL/Math/LU/LUDecomp.hxx \ + /usr/local/include/TFEL/Math/LU/LUException.hxx \ + /usr/local/include/TFEL/Math/LU/LUDecomp.ixx \ + /usr/local/include/TFEL/Math/LU/TinyPermutation.hxx \ + /usr/local/include/TFEL/Math/LU/TinyPermutation.ixx \ + /usr/local/include/TFEL/Math/ST2toST2/ST2toST2TransposeExpr.hxx \ + /usr/local/include/TFEL/Math/Forward/ST2toST2Concept.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/ST2toST2ConceptPushForward.ixx \ + /usr/local/include/TFEL/Math/General/MathConstants.hxx \ + /usr/local/include/TFEL/Metaprogramming/EmptyClass.hxx \ + /usr/local/include/TFEL/Math/General/ConstExprMathFunctions.hxx \ + /usr/local/include/TFEL/Math/Stensor/StensorConcept.hxx \ + /usr/local/include/TFEL/Math/Stensor/StensorConcept.ixx \ + /usr/local/include/TFEL/Math/Stensor/StensorConceptOperations.hxx \ + /usr/local/include/TFEL/Math/Stensor/StensorProduct.hxx \ + /usr/local/include/TFEL/Math/Tensor/TensorConcept.hxx \ + /usr/local/include/TFEL/Math/Tensor/TensorTransposeExpr.hxx \ + /usr/local/include/TFEL/Math/Tensor/TensorConcept.ixx \ + /usr/local/include/TFEL/Math/Tensor/MatrixViewFromTensor.hxx \ + /usr/local/include/TFEL/Math/Stensor/StensorConceptOperations.ixx \ + /usr/local/include/TFEL/Math/Stensor/stensor.ixx \ + /usr/local/include/TFEL/Math/Stensor/SymmetricStensorProduct.hxx \ + /usr/local/include/TFEL/Math/Stensor/SymmetricStensorProduct.ixx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorImport.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorExport.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorExport.ixx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorChangeBasis.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorInvert.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorDeterminant.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/BuildStensorFromMatrix.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/BuildStensorFromVectorDiadicProduct.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/BuildStensorFromVectorsSymmetricDiadicProduct.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/BuildStensorFromEigenValuesAndVectors.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorEigenSolver.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/FSESSymmetricEigenSolver.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/FSESSymmetricEigenSolver.ixx \ + /usr/local/include/FSES/syevc3.hxx /usr/local/include/FSES/syevc3.ixx \ + /usr/local/include/FSES/Utilities.hxx \ + /usr/local/include/FSES/Utilities.ixx /usr/local/include/FSES/syevv3.hxx \ + /usr/local/include/FSES/syevv3.ixx \ + /usr/local/include/TFEL/Math/Stensor/Internals/GteSymmetricEigenSolver.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/GteSymmetricEigenSolver.ixx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorComputeEigenValues.hxx \ + /usr/local/include/TFEL/Math/General/CubicRoots.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorComputeEigenVectors.hxx \ + /usr/include/c++/8/cassert /usr/include/assert.h \ + /usr/local/include/FSES/syevj3.hxx /usr/local/include/FSES/syevj3.ixx \ + /usr/local/include/FSES/syevq3.hxx /usr/local/include/FSES/syevq3.ixx \ + /usr/local/include/FSES/sytrd3.hxx /usr/local/include/FSES/sytrd3.ixx \ + /usr/local/include/FSES/syevd3.hxx /usr/local/include/FSES/syevd3.ixx \ + /usr/local/include/FSES/syev2.hxx /usr/local/include/FSES/syev2.ixx \ + /usr/local/include/FSES/slvsec3.hxx /usr/local/include/FSES/slvsec3.ixx \ + /usr/local/include/FSES/syevh3.hxx /usr/local/include/FSES/syevh3.ixx \ + /usr/local/include/TFEL/Math/Stensor/Internals/SortEigenValues.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/SortEigenVectors.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorComputeEigenValuesDerivatives.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorComputeEigenVectorsDerivatives.hxx \ + /usr/local/include/TFEL/Math/Stensor/Internals/StensorComputeIsotropicFunctionDerivative.hxx \ + /usr/local/include/TFEL/Math/Stensor/stensorResultType.hxx \ + /usr/local/include/TFEL/Math/Stensor/DecompositionInPositiveAndNegativeParts.hxx \ + /usr/local/include/TFEL/Math/Stensor/DecompositionInPositiveAndNegativeParts.ixx \ + /usr/local/include/TFEL/Math/Stensor/StensorConceptIO.hxx \ + /usr/local/include/TFEL/Math/Matrix/tmatrixIO.hxx \ + /usr/local/include/TFEL/Math/st2tost2.hxx \ + /usr/local/include/TFEL/Math/T2toST2/T2toST2Concept.hxx \ + /usr/local/include/TFEL/Math/Forward/T2toST2Concept.hxx \ + /usr/local/include/TFEL/Math/T2toST2/T2toST2Concept.ixx \ + /usr/local/include/TFEL/Math/ST2toST2/ST2toST2ConceptOperations.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/ST2toST2StensorProductExpr.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/StensorST2toST2ProductExpr.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/ST2toST2ST2toST2ProductExpr.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/StensorSquareDerivative.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/st2tost2.ixx \ + /usr/local/include/TFEL/Math/General/BaseCast.hxx \ + /usr/local/include/TFEL/Math/TinyMatrixInvert.hxx \ + /usr/local/include/TFEL/Math/TinyMatrixSolve.hxx \ + /usr/local/include/TFEL/Math/LU/TinyMatrixSolve.ixx \ + /usr/local/include/TFEL/Math/Matrix/TinyMatrixInvert.ixx \ + /usr/local/include/TFEL/Math/ST2toST2/ConvertT2toST2ToST2toST2Expr.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/BuildFromRotationMatrix.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/StensorSymmetricProductDerivative.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/SymmetricStensorProductDerivative.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/SymmetricStensorProductDerivative.ixx \ + /usr/local/include/TFEL/Math/ST2toST2/ChangeBasis.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/st2tost2ResultType.hxx \ + /usr/local/include/TFEL/Math/ST2toST2/ST2toST2ConceptIO.hxx \ + /usr/local/include/TFEL/Material/ModellingHypothesis.hxx \ + /usr/include/c++/8/vector /usr/include/c++/8/bits/stl_uninitialized.h \ + /usr/include/c++/8/bits/stl_vector.h \ + /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \ + /usr/local/include/MFront/GenericBehaviour/State.hxx \ + /usr/local/include/MFront/GenericBehaviour/Types.hxx \ + /usr/local/include/MFront/GenericBehaviour/Types.h \ + /usr/local/include/MFront/GenericBehaviour/State.h \ + /usr/local/include/MFront/GenericBehaviour/BehaviourData.hxx \ + /usr/local/include/MFront/GenericBehaviour/BehaviourData.h \ + ../include/TFEL/Material/StationaryHeatTransferIntegrationData.hxx \ + ../include/TFEL/Material/StationaryHeatTransfer.hxx \ + /usr/local/include/TFEL/Math/Vector/TVectorView.hxx \ + /usr/local/include/TFEL/Math/Matrix/TMatrixView.hxx \ + /usr/local/include/TFEL/Material/MaterialException.hxx \ + /usr/local/include/TFEL/Material/MechanicalBehaviour.hxx \ + /usr/local/include/TFEL/Material/FiniteStrainBehaviourTangentOperatorBase.hxx \ + /usr/local/include/TFEL/Material/MechanicalBehaviourTraits.hxx \ + /usr/local/include/TFEL/Material/OutOfBoundsPolicy.hxx \ + /usr/local/include/TFEL/Material/BoundsCheck.hxx \ + /usr/local/include/TFEL/Math/qt.hxx \ + /usr/local/include/TFEL/Metaprogramming/TypeList.hxx \ + /usr/local/include/TFEL/Metaprogramming/TypeList.ixx \ + /usr/local/include/TFEL/Metaprogramming/Forward/TypeList.hxx \ + /usr/local/include/TFEL/Metaprogramming/IsSubClassOf.hxx \ + /usr/local/include/TFEL/Metaprogramming/GenerateTypeList.hxx \ + /usr/local/include/TFEL/Math/Quantity/qtLimits.hxx \ + /usr/local/include/TFEL/Math/Quantity/qtSpecific.hxx \ + /usr/local/include/TFEL/Math/Quantity/qtSamples.hxx \ + /usr/local/include/TFEL/Math/Quantity/qt.ixx \ + /usr/local/include/TFEL/Math/Quantity/qtOperations.hxx \ + /usr/local/include/TFEL/Math/Quantity/qtOperations.ixx \ + /usr/local/include/TFEL/Material/IsotropicPlasticity.hxx \ + /usr/local/include/TFEL/Material/IsotropicPlasticity.ixx \ + /usr/local/include/TFEL/Material/Lame.hxx \ + /usr/local/include/TFEL/Material/Hosford1972YieldCriterion.hxx \ + /usr/local/include/TFEL/Material/Hosford1972YieldCriterion.ixx