Material.h

Go to the documentation of this file.

#ifndef included_AMP_Material
#define included_AMP_Material
 
#include "AMP/materials/Property.h"
 
#include <map>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
 
namespace AMP::Materials {
 
 
class Material
{
public:
    Material() = default;
 
    virtual ~Material() = default;
 
public:
    bool hasProperty( const std::string &type ) const;
 
    virtual std::string materialName() const = 0;
 
    std::shared_ptr<Property> property( const std::string &type );
 
    std::shared_ptr<const Property> property( const std::string &type ) const;
 
    std::vector<std::string> list() const;
 
public:
    template<class PROPERTY>
    void addProperty( std::string_view name, std::shared_ptr<PROPERTY> property )
    {
        d_propertyMap[std::string( name )] = property;
    }
    template<class PROPERTY, typename... Args>
    void addProperty( std::string_view name, Args &&...args )
    {
        auto name2 = materialName() + "::" + std::string( name );
        d_propertyMap[std::string( name )] =
            std::make_shared<PROPERTY>( name2, std::forward<Args>( args )... );
    }
 
    void
    addStringProperty( std::string_view name, std::string value, std::string_view source = "" );
 
    void addScalarProperty( std::string_view name,
                            double value,
                            const AMP::Units &unit  = AMP::Units(),
                            std::string_view source = "" );
 
    void addScalarProperty( std::string_view name,
                            AMP::Array<double> value,
                            const AMP::Units &unit  = AMP::Units(),
                            std::string_view source = "" );
 
    void addPolynomialProperty( std::string_view name,
                                const AMP::Units &unit                    = {},
                                std::vector<double> params                = {},
                                std::vector<std::string> args             = {},
                                std::vector<std::array<double, 2>> ranges = {},
                                std::vector<AMP::Units> argUnits          = {},
                                std::string_view source                   = "" );
 
    void addEquationProperty( std::string_view name,
                              const AMP::Units &unit,
                              std::string expression,
                              std::vector<std::string> args             = {},
                              std::vector<std::array<double, 2>> ranges = {},
                              std::vector<AMP::Units> argUnits          = {},
                              std::string_view source                   = "" );
 
 
protected:
    std::map<std::string, std::shared_ptr<Property>> d_propertyMap;
};
 
 
class DatabaseMaterial : public Material
{
public:
    DatabaseMaterial( std::string_view name, std::shared_ptr<Database> db );
 
    std::string materialName() const override { return d_name; }
 
private:
    std::string d_name; 
};
 
 
void registerMaterial( const std::string &name, std::function<std::unique_ptr<Material>()> fun );
 
std::unique_ptr<Material> getMaterial( const std::string &name );
 
std::vector<std::string> getMaterialList();
 
bool isMaterial( const std::string &name );
 
 
} // namespace AMP::Materials
 
 
#endif