Medium.h

Go to the documentation of this file.

 
#pragma once
 
#include <memory>
#include <string>
#include <vector>
 
#include "BaseLib/Error.h"
#include "Phase.h"
 
namespace MaterialPropertyLib
{
class Property;
}
namespace MaterialPropertyLib
{
class Medium final
{
public:
    Medium(std::vector<std::unique_ptr<Phase>>&& phases,
           std::unique_ptr<PropertyArray>&& properties);
 
    Phase const& phase(std::size_t index) const;
    Phase const& phase(std::string const& phase_name) const;
 
    bool hasPhase(std::string const& phase_name) const;
 
    Property const& property(PropertyType const& p) const;
 
    Property const& operator[](PropertyType const& p) const;
 
    bool hasProperty(PropertyType const& p) const;
 
    std::size_t numberOfPhases() const;
 
    static std::string description();
 
    template <typename T>
    T value(PropertyType const p) const
    {
        return property(p).template value<T>();
    }
 
    template <typename T>
    T value(PropertyType const p, VariableArray const& variable_array) const
    {
        return property(p).template value<T>(variable_array);
    }
 
    template <typename T>
    T dValue(PropertyType const p,
             VariableArray const& variable_array,
             Variable const variable) const
    {
        return property(p).template dValue<T>(variable_array, variable);
    }
 
    template <typename T>
    T d2Value(PropertyType const p,
              VariableArray const& variable_array,
              Variable const variable1,
              Variable const variable2) const
    {
        return property(p).template d2Value<T>(variable_array, variable1,
                                               variable2);
    }
 
private:
    std::vector<std::unique_ptr<Phase>> const phases_;
    PropertyArray properties_;
};
 
template <typename Container>
void checkRequiredProperties(Medium const& medium,
                             Container const& required_properties)
{
    for (auto const& p : required_properties)
    {
        if (!medium.hasProperty(p))
        {
            OGS_FATAL(
                "The property '{:s}' is missing in the medium definition.",
                property_enum_to_string[p]);
        }
    }
}
 
Phase const& fluidPhase(Medium const& medium);
 
}  // namespace MaterialPropertyLib