ProcessVariable.h

Go to the documentation of this file.

 
#pragma once
 
#include <map>
#include <memory>
#include <string>
#include <vector>
 
#include "BaseLib/ConfigTree-fwd.h"
#include "MaterialLib/MPL/Medium.h"
 
namespace MathLib
{
class PiecewiseLinearInterpolation;
}  // namespace MathLib
 
namespace MeshLib
{
class Mesh;
 
template <typename PROP_VAL_TYPE>
class PropertyVector;
}  // namespace MeshLib
 
namespace NumLib
{
class LocalToGlobalIndexMap;
}  // namespace NumLib
 
namespace ParameterLib
{
struct ParameterBase;
 
template <typename T>
struct Parameter;
}  // namespace ParameterLib
 
namespace ProcessLib
{
class SourceTerm;
class BoundaryCondition;
class Process;
struct DeactivatedSubdomain;
struct BoundaryConditionConfig;
struct SourceTermConfig;
}  // namespace ProcessLib
 
namespace ProcessLib
{
class ProcessVariable
{
public:
    ProcessVariable(
        BaseLib::ConfigTree const& config, MeshLib::Mesh& mesh,
        std::vector<std::unique_ptr<MeshLib::Mesh>> const& meshes,
        std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const&
            parameters,
        std::map<std::string,
                 std::unique_ptr<MathLib::PiecewiseLinearInterpolation>> const&
            curves);
 
    ProcessVariable(ProcessVariable&&);
 
    std::string const& getName() const;
 
    MeshLib::Mesh const& getMesh() const;
 
    std::vector<DeactivatedSubdomain> const& getDeactivatedSubdomains() const
    {
        return _deactivated_subdomains;
    }
 
    void updateDeactivatedSubdomains(double const time);
 
    std::vector<std::size_t> const& getActiveElementIDs() const
    {
        return _ids_of_active_elements;
    }
 
    int getNumberOfGlobalComponents() const { return _n_components; }
 
    std::vector<std::unique_ptr<BoundaryCondition>> createBoundaryConditions(
        const NumLib::LocalToGlobalIndexMap& dof_table, const int variable_id,
        unsigned const integration_order,
        std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const&
            parameters,
        Process const& process,
        std::vector<std::reference_wrapper<ProcessVariable>> const&
            all_process_variables_for_this_process,
        std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const&
            media);
 
    std::vector<std::unique_ptr<SourceTerm>> createSourceTerms(
        const NumLib::LocalToGlobalIndexMap& dof_table, const int variable_id,
        unsigned const integration_order,
        std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const&
            parameters,
        std::vector<std::reference_wrapper<ProcessVariable>> const&
            all_process_variables_for_this_process);
 
    ParameterLib::Parameter<double> const& getInitialCondition() const
    {
        return _initial_condition;
    }
 
    unsigned getShapeFunctionOrder() const { return _shapefunction_order; }
 
    bool compensateNonEquilibriumInitialResiduum() const
    {
        return _compensate_non_equilibrium_initial_residuum;
    }
 
    ~ProcessVariable();
 
private:
    std::string const _name;
    MeshLib::Mesh& _mesh;
    const int _n_components;
    unsigned _shapefunction_order;
 
    std::vector<DeactivatedSubdomain> _deactivated_subdomains;
 
    mutable std::vector<std::size_t> _ids_of_active_elements;
    MeshLib::PropertyVector<unsigned char>* _is_active = nullptr;
 
    void createBoundaryConditionsForDeactivatedSubDomains(
        const NumLib::LocalToGlobalIndexMap& dof_table, const int variable_id,
        std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const&
            parameters,
        std::vector<std::unique_ptr<BoundaryCondition>>& bcs);
 
    ParameterLib::Parameter<double> const& _initial_condition;
 
    std::vector<BoundaryConditionConfig> _bc_configs;
    std::vector<SourceTermConfig> _source_term_configs;
 
    const bool _compensate_non_equilibrium_initial_residuum;
};
 
}  // namespace ProcessLib