ProcessVariable.h

Go to the documentation of this file.

 
#pragma once
 
#include "MathLib/LinAlg/GlobalMatrixVectorTypes.h"
#include "ParameterLib/Parameter.h"
#include "ProcessLib/BoundaryConditionAndSourceTerm/BoundaryConditionConfig.h"
#include "ProcessLib/BoundaryConditionAndSourceTerm/SourceTermConfig.h"
 
// DeactivatedSubdomain cannot be forwardly declared because that
// std::unique_ptr<DeactivatedSubdomain> type member requires its full
// definition (see https://stackoverflow.com/a/6089065).
#include "ProcessLib/DeactivatedSubdomain.h"
 
namespace MeshLib
{
class Mesh;
template <typename T>
class PropertyVector;
}  // namespace MeshLib
namespace NumLib
{
class LocalToGlobalIndexMap;
}
 
namespace ProcessLib
{
class SourceTerm;
class BoundaryCondition;
class Process;
}  // 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&& other);
 
    std::string const& getName() const;
 
    MeshLib::Mesh const& getMesh() const;
 
    std::vector<std::unique_ptr<DeactivatedSubdomain const>> 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::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);
 
    ParameterLib::Parameter<double> const& getInitialCondition() const
    {
        return _initial_condition;
    }
 
    unsigned getShapeFunctionOrder() const { return _shapefunction_order; }
 
private:
    std::string const _name;
    MeshLib::Mesh& _mesh;
    const int _n_components;
    unsigned _shapefunction_order;
 
    std::vector<std::unique_ptr<DeactivatedSubdomain const>>
        _deactivated_subdomains;
 
    mutable std::vector<std::size_t> _ids_of_active_elements;
 
    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;
};
 
}  // namespace ProcessLib