Detailed Description

template<typename ShapeFunction>
class ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerSoil< ShapeFunction >

Definition at line 23 of file HeatTransportBHELocalAssemblerSoil.h.

#include <HeatTransportBHELocalAssemblerSoil.h>

Inheritance diagram for ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerSoil< ShapeFunction >:

[legend]

Collaboration diagram for ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerSoil< ShapeFunction >:

[legend]

Public Types
using	ShapeMatricesType
using	NodalMatrixType = typename ShapeMatricesType::NodalMatrixType
using	NodalVectorType = typename ShapeMatricesType::NodalVectorType
using	NodalRowVectorType = typename ShapeMatricesType::NodalRowVectorType
using	ShapeMatrices = typename ShapeMatricesType::ShapeMatrices
using	GlobalDimNodalMatrixType

Public Member Functions
	HeatTransportBHELocalAssemblerSoil (HeatTransportBHELocalAssemblerSoil const &)=delete
	HeatTransportBHELocalAssemblerSoil (HeatTransportBHELocalAssemblerSoil &&)=delete
	HeatTransportBHELocalAssemblerSoil (MeshLib::Element const &e, NumLib::GenericIntegrationMethod const &integration_method, bool const is_axially_symmetric, HeatTransportBHEProcessData &process_data)
void	assemble (double const, double const, std::vector< double > const &, std::vector< double > const &, std::vector< double > &, std::vector< double > &, std::vector< double > &) override
void	assembleWithJacobian (double const t, double const dt, std::vector< double > const &local_x, std::vector< double > const &local_x_prev, std::vector< double > &local_rhs_data, std::vector< double > &local_Jac_data) override
Eigen::Map< const Eigen::RowVectorXd >	getShapeMatrix (const unsigned integration_point) const override
	Provides the shape matrix at the given integration point.
Public Member Functions inherited from ProcessLib::LocalAssemblerInterface
virtual	~LocalAssemblerInterface ()=default
virtual void	setInitialConditions (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< GlobalVector * > const &x, double const t, int const process_id)
virtual void	initialize (std::size_t const mesh_item_id, NumLib::LocalToGlobalIndexMap const &dof_table)
virtual void	preAssemble (double const, double const, std::vector< double > const &)
virtual void	assembleForStaggeredScheme (double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, int const process_id, std::vector< double > &local_M_data, std::vector< double > &local_K_data, std::vector< double > &local_b_data)
virtual void	assembleWithJacobianForStaggeredScheme (double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, int const process_id, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data)
virtual void	computeSecondaryVariable (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, double const t, double const dt, std::vector< GlobalVector * > const &x, GlobalVector const &x_prev, int const process_id)
virtual void	preTimestep (std::size_t const mesh_item_id, NumLib::LocalToGlobalIndexMap const &dof_table, GlobalVector const &x, double const t, double const delta_t)
virtual void	postTimestep (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, double const t, double const dt, int const process_id)
void	postNonLinearSolver (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, double const t, double const dt, int const process_id)
virtual Eigen::Vector3d	getFlux (MathLib::Point3d const &, double const, std::vector< double > const &) const
virtual Eigen::Vector3d	getFlux (MathLib::Point3d const &, double const, std::vector< std::vector< double > > const &) const
	Fits to staggered scheme.
virtual int	getNumberOfVectorElementsForDeformation () const
Public Member Functions inherited from NumLib::ExtrapolatableElement
virtual	~ExtrapolatableElement ()=default

Private Attributes
HeatTransportBHEProcessData &	_process_data
std::vector< IntegrationPointDataSoil< NodalRowVectorType, GlobalDimNodalMatrixType >, Eigen::aligned_allocator< IntegrationPointDataSoil< NodalRowVectorType, GlobalDimNodalMatrixType > > >	_ip_data
NumLib::GenericIntegrationMethod const &	_integration_method
std::vector< ShapeMatrices, Eigen::aligned_allocator< ShapeMatrices > >	_shape_matrices
MeshLib::Element const &	_element
SecondaryData< typename ShapeMatrices::ShapeType >	_secondary_data

Member Typedef Documentation

◆ GlobalDimNodalMatrixType

template<typename ShapeFunction>

using ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerSoil< ShapeFunction >::GlobalDimNodalMatrixType

Initial value:

typename ShapeMatricesType::GlobalDimNodalMatrixType

EigenFixedShapeMatrixPolicy::GlobalDimNodalMatrixType

MatrixType< GlobalDim, ShapeFunction::NPOINTS > GlobalDimNodalMatrixType

Definition ShapeMatrixPolicy.h:75

Definition at line 34 of file HeatTransportBHELocalAssemblerSoil.h.

◆ NodalMatrixType

template<typename ShapeFunction>

using ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerSoil< ShapeFunction >::NodalMatrixType = typename ShapeMatricesType::NodalMatrixType

Definition at line 29 of file HeatTransportBHELocalAssemblerSoil.h.

◆ NodalRowVectorType

template<typename ShapeFunction>

using ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerSoil< ShapeFunction >::NodalRowVectorType = typename ShapeMatricesType::NodalRowVectorType

Definition at line 31 of file HeatTransportBHELocalAssemblerSoil.h.

◆ NodalVectorType

template<typename ShapeFunction>

using ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerSoil< ShapeFunction >::NodalVectorType = typename ShapeMatricesType::NodalVectorType

Definition at line 30 of file HeatTransportBHELocalAssemblerSoil.h.

◆ ShapeMatrices

template<typename ShapeFunction>

using ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerSoil< ShapeFunction >::ShapeMatrices = typename ShapeMatricesType::ShapeMatrices

Definition at line 33 of file HeatTransportBHELocalAssemblerSoil.h.

◆ ShapeMatricesType

template<typename ShapeFunction>

using ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerSoil< ShapeFunction >::ShapeMatricesType

Initial value:

ShapeMatrixPolicyType<ShapeFunction, 3 >

ShapeMatrixPolicyType

EigenFixedShapeMatrixPolicy< ShapeFunction, GlobalDim > ShapeMatrixPolicyType

Definition ShapeMatrixPolicy.h:134

Definition at line 27 of file HeatTransportBHELocalAssemblerSoil.h.

Constructor & Destructor Documentation

◆ HeatTransportBHELocalAssemblerSoil() [1/3]

template<typename ShapeFunction>

ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerSoil< ShapeFunction >::HeatTransportBHELocalAssemblerSoil ( HeatTransportBHELocalAssemblerSoil< ShapeFunction > const & )

delete

References HeatTransportBHELocalAssemblerSoil().

Referenced by HeatTransportBHELocalAssemblerSoil(), and HeatTransportBHELocalAssemblerSoil().

◆ HeatTransportBHELocalAssemblerSoil() [2/3]

template<typename ShapeFunction>

ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerSoil< ShapeFunction >::HeatTransportBHELocalAssemblerSoil ( HeatTransportBHELocalAssemblerSoil< ShapeFunction > && )

delete

References HeatTransportBHELocalAssemblerSoil().

◆ HeatTransportBHELocalAssemblerSoil() [3/3]

template<typename ShapeFunction>

ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerSoil< ShapeFunction >::HeatTransportBHELocalAssemblerSoil	(	MeshLib::Element const &	e,
		NumLib::GenericIntegrationMethod const &	integration_method,
		bool const	is_axially_symmetric,
		HeatTransportBHEProcessData &	process_data )

Definition at line 25 of file HeatTransportBHELocalAssemblerSoil-impl.h.

    : _process_data(process_data),
      _integration_method(integration_method),
      _element(e)
{
    unsigned const n_integration_points =
        _integration_method.getNumberOfPoints();
 
    _ip_data.reserve(n_integration_points);
    _secondary_data.N.resize(n_integration_points);
 
    _shape_matrices =
        NumLib::initShapeMatrices<ShapeFunction, ShapeMatricesType,
                                  3 /* GlobalDim */>(e, is_axially_symmetric,
                                                     _integration_method);
 
    // ip data initialization
    for (unsigned ip = 0; ip < n_integration_points; ip++)
    {
        // create the class IntegrationPointDataBHE in place
        auto const& sm = _shape_matrices[ip];
        double const w = _integration_method.getWeightedPoint(ip).getWeight() *
                         sm.integralMeasure * sm.detJ;
        _ip_data.push_back({sm.N, sm.dNdx, w});
 
        _secondary_data.N[ip] = sm.N;
    }
}

References _element, _integration_method, _ip_data, _process_data, _secondary_data, _shape_matrices, and NumLib::initShapeMatrices().

Member Function Documentation

◆ assemble()

template<typename ShapeFunction>

void ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerSoil< ShapeFunction >::assemble	(	double const	t,
		double const	dt,
		std::vector< double > const &	local_x,
		std::vector< double > const &	,
		std::vector< double > &	local_M_data,
		std::vector< double > &	local_K_data,
		std::vector< double > &	)

overridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 60 of file HeatTransportBHELocalAssemblerSoil-impl.h.

{
    assert(local_x.size() == ShapeFunction::NPOINTS);
    (void)local_x;  // Avoid unused arg warning.
 
    auto local_M = MathLib::createZeroedMatrix<NodalMatrixType>(
        local_M_data, ShapeFunction::NPOINTS, ShapeFunction::NPOINTS);
    auto local_K = MathLib::createZeroedMatrix<NodalMatrixType>(
        local_K_data, ShapeFunction::NPOINTS, ShapeFunction::NPOINTS);
 
    auto const& medium = *_process_data.media_map.getMedium(_element.getID());
    auto const& solid_phase =
        medium.phase(MaterialPropertyLib::PhaseName::Solid);
    auto const& liquid_phase =
        medium.phase(MaterialPropertyLib::PhaseName::AqueousLiquid);
 
    MaterialPropertyLib::VariableArray vars;
 
    unsigned const n_integration_points =
        _integration_method.getNumberOfPoints();
 
    for (unsigned ip = 0; ip < n_integration_points; ip++)
    {
        auto& ip_data = _ip_data[ip];
        auto const& N = ip_data.N;
        auto const& dNdx = ip_data.dNdx;
        auto const& w = ip_data.integration_weight;
 
        ParameterLib::SpatialPosition const pos{
            std::nullopt, _element.getID(),
            MathLib::Point3d(NumLib::interpolateCoordinates<ShapeFunction,
                                                            ShapeMatricesType>(
                _element, N))};
 
        double T_int_pt = 0.0;
        NumLib::shapeFunctionInterpolate(local_x, N, T_int_pt);
 
        vars.temperature = T_int_pt;
 
        // for now only using the solid and liquid phase parameters
        auto const density_s =
            solid_phase.property(MaterialPropertyLib::PropertyType::density)
                .template value<double>(vars, pos, t, dt);
 
        auto const heat_capacity_s =
            solid_phase
                .property(
                    MaterialPropertyLib::PropertyType::specific_heat_capacity)
                .template value<double>(vars, pos, t, dt);
 
        auto const density_f =
            liquid_phase.property(MaterialPropertyLib::PropertyType::density)
                .template value<double>(vars, pos, t, dt);
 
        auto const heat_capacity_f =
            liquid_phase
                .property(
                    MaterialPropertyLib::PropertyType::specific_heat_capacity)
                .template value<double>(vars, pos, t, dt);
 
        auto const porosity =
            medium.property(MaterialPropertyLib::PropertyType::porosity)
                .template value<double>(vars, pos, t, dt);
 
        auto const velocity =
            liquid_phase
                .property(MaterialPropertyLib::PropertyType::phase_velocity)
                .template value<Eigen::Vector3d>(vars, pos, t, dt);
 
        // calculate the hydrodynamic thermodispersion tensor
        auto const thermal_conductivity =
            MaterialPropertyLib::formEigenTensor<3>(
                medium
                    .property(
                        MaterialPropertyLib::PropertyType::thermal_conductivity)
                    .value(vars, pos, t, dt));
 
        auto thermal_conductivity_dispersivity = thermal_conductivity;
 
        double const velocity_magnitude = velocity.norm();
 
        if (velocity_magnitude >= std::numeric_limits<double>::epsilon())
        {
            auto const thermal_dispersivity_longitudinal =
                medium
                    .property(MaterialPropertyLib::PropertyType::
                                  thermal_longitudinal_dispersivity)
                    .template value<double>();
            auto const thermal_dispersivity_transversal =
                medium
                    .property(MaterialPropertyLib::PropertyType::
                                  thermal_transversal_dispersivity)
                    .template value<double>();
 
            auto const thermal_dispersivity =
                density_f * heat_capacity_f *
                (thermal_dispersivity_transversal * velocity_magnitude *
                     Eigen::Matrix3d::Identity() +
                 (thermal_dispersivity_longitudinal -
                  thermal_dispersivity_transversal) /
                     velocity_magnitude * velocity * velocity.transpose());
            thermal_conductivity_dispersivity += thermal_dispersivity;
        }
 
        // assemble Conductance matrix
        local_K.noalias() +=
            (dNdx.transpose() * thermal_conductivity_dispersivity * dNdx +
             N.transpose() * velocity.transpose() * dNdx * density_f *
                 heat_capacity_f) *
            w;
 
        // assemble Mass matrix
        local_M.noalias() += N.transpose() * N * w *
                             (density_s * heat_capacity_s * (1 - porosity) +
                              density_f * heat_capacity_f * porosity);
    }
 
    if (_process_data._mass_lumping)
    {
        // only mass lumping at the BHE connected soil elements
        if (_process_data.mass_lumping_soil_elements[_element.getID()])
        {
            local_M = local_M.colwise().sum().eval().asDiagonal();
        }
    }
 
    //  debugging
    //  std::string sep = "\n----------------------------------------\n";
    //  Eigen::IOFormat CleanFmt(4, 0, ", ", "\n", "[", "]");
    //  std::cout << local_K.format(CleanFmt) << sep;
    //  std::cout << local_M.format(CleanFmt) << sep;
}

Referenced by assembleWithJacobian().

◆ assembleWithJacobian()

template<typename ShapeFunction>

void ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerSoil< ShapeFunction >::assembleWithJacobian	(	double const	t,
		double const	dt,
		std::vector< double > const &	local_x,
		std::vector< double > const &	local_x_prev,
		std::vector< double > &	local_rhs_data,
		std::vector< double > &	local_Jac_data )

overridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 198 of file HeatTransportBHELocalAssemblerSoil-impl.h.

{
    assert(local_x.size() == ShapeFunction::NPOINTS);
    auto const local_matrix_size = local_x.size();
    // initialize x and x_prev
    auto x =
        Eigen::Map<NodalVectorType const>(local_x.data(), local_matrix_size);
    auto x_prev = Eigen::Map<NodalVectorType const>(local_x_prev.data(),
                                                    local_matrix_size);
    // initialize local_Jac and local_rhs
    auto local_Jac = MathLib::createZeroedMatrix<NodalMatrixType>(
        local_Jac_data, local_matrix_size, local_matrix_size);
    auto local_rhs = MathLib::createZeroedVector<NodalVectorType>(
        local_rhs_data, local_matrix_size);
 
    std::vector<double> local_M_data;
    std::vector<double> local_K_data;
    assemble(t, dt, local_x, local_x_prev, local_M_data, local_K_data,
             local_rhs_data /*not going to be used*/);
 
    // convert to matrix
    auto local_M = MathLib::toMatrix<NodalMatrixType>(
        local_M_data, local_matrix_size, local_matrix_size);
    auto local_K = MathLib::toMatrix<NodalMatrixType>(
        local_K_data, local_matrix_size, local_matrix_size);
 
    // Jac matrix and rhs vector operation
    local_Jac.noalias() += local_K + local_M / dt;
    local_rhs.noalias() -= local_K * x + local_M * (x - x_prev) / dt;
 
    local_M.setZero();
    local_K.setZero();
}

References assemble(), MathLib::createZeroedMatrix(), MathLib::createZeroedVector(), and MathLib::toMatrix().

◆ getShapeMatrix()

template<typename ShapeFunction>

Eigen::Map< const Eigen::RowVectorXd > ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerSoil< ShapeFunction >::getShapeMatrix ( const unsigned integration_point ) const

inlineoverridevirtual

Provides the shape matrix at the given integration point.

Implements NumLib::ExtrapolatableElement.

Definition at line 61 of file HeatTransportBHELocalAssemblerSoil.h.

    {
        auto const& N = _secondary_data.N[integration_point];
 
        // assumes N is stored contiguously in memory
        return Eigen::Map<const Eigen::RowVectorXd>(N.data(), N.size());
    }