Property.h

Go to the documentation of this file.

#ifndef included_AMP_Property
    #define included_AMP_Property
 
    #include "AMP/utils/ArraySize.h"
    #include "AMP/utils/Database.h"
    #include "AMP/utils/Units.h"
    #include "AMP/utils/UtilityMacros.h"
 
    #include <algorithm>
    #include <array>
    #include <limits>
    #include <map>
    #include <memory>
    #include <string>
    #include <string_view>
    #include <vector>
 
 
// Foward declare classes
namespace AMP::LinearAlgebra {
class Vector;
class MultiVector;
} // namespace AMP::LinearAlgebra
 
 
namespace AMP::Materials {
 
 
class Property
{
public:
    Property( std::string_view name,
              const ArraySize &size                     = { 1 },
              const Units &unit                         = Units(),
              std::string_view source                   = "",
              std::vector<std::string> args             = {},
              std::vector<std::array<double, 2>> ranges = {},
              std::vector<Units> argUnits               = {} );
 
    virtual ~Property() {}
 
    inline const ArraySize &size() const { return d_dim; }
 
    inline const std::string &get_name() const { return d_name; }
 
    inline const std::string &get_source() const { return d_source; }
 
    inline const Units &get_units() const { return d_units; }
 
    inline const std::vector<std::string> &get_arguments() const { return d_arguments; }
 
    inline size_t get_number_arguments() const { return d_arguments.size(); }
 
    inline int get_argument_index( std::string_view name ) const
    {
        int index = -1;
        for ( size_t i = 0; i < d_arguments.size(); i++ ) {
            if ( name == d_arguments[i] )
                index = i;
        }
        return index;
    }
 
    double get_default( std::string_view name ) const;
 
    inline const std::vector<double> &get_defaults() const { return d_defaults; }
 
    inline void
    set_default( std::string_view name, double value, const AMP::Units &unit = AMP::Units() )
    {
        int i = get_argument_index( name );
        if ( i != -1 ) {
            if ( !unit.isNull() )
                value *= unit.convert( d_argUnits[i] );
            d_defaults[i] = value;
        }
    }
 
    inline void set_defaults( std::vector<double> defaults )
    {
        AMP_INSIST( defaults.size() == d_arguments.size(),
                    "incorrect number of defaults specified" );
        d_defaults = std::move( defaults );
    }
 
    bool is_argument( std::string_view argname ) const;
 
    virtual bool isString() const { return false; }
 
    bool isScalar() const { return d_dim.length() == 1; }
 
    bool isVector() const { return d_dim.ndim() == 1 && d_dim.length() > 0; }
 
    bool isTensor() const { return d_dim.ndim() == 2; }
 
    // converts AMP::MultiVector to a map of pointers to AMP::Vectors based on argument names
    std::map<std::string, std::shared_ptr<AMP::LinearAlgebra::Vector>>
    make_map( const std::shared_ptr<AMP::LinearAlgebra::MultiVector> &args,
              const std::map<std::string, std::string> &translator ) const;
 
 
public: // Functions dealing with the ranges of the arguments
    const auto &get_arg_units() const { return d_argUnits; }
 
    const auto &get_arg_ranges() const { return d_ranges; }
 
    std::array<double, 2> get_arg_range( std::string_view argname ) const;
 
    inline bool in_range( std::string_view argname,
                          double value,
                          const Units &unit = Units(),
                          bool throwError   = false ) const;
 
    template<class INPUT_VTYPE>
    inline bool in_range( std::string_view argname,
                          const INPUT_VTYPE &values,
                          const Units &unit = Units(),
                          bool throwError   = false ) const;
 
 
    inline const Database &getAuxiliaryData() const { return d_auxiliaryData; }
 
    template<class TYPE>
    TYPE getAuxiliaryData( const std::string &key ) const;
 
    template<class TYPE>
    void setAuxiliaryData( const std::string &key, const TYPE &data );
 
 
public: // Evaluators
    template<class... Args>
    double eval( const Units &unit = Units(), const Args &...args ) const;
 
    double eval( const Units &unit,
                 const std::vector<std::string> &args,
                 const std::vector<double> &vec,
                 const std::vector<Units> &units = {} ) const;
 
    template<class... Args>
    void evalv( std::vector<double> &r, const Units &unit, const Args &...args ) const;
 
    template<class... Args>
    void evalv( AMP::LinearAlgebra::Vector &r, const Args &...args ) const;
 
    template<class... Args>
    void evalv( std::vector<std::shared_ptr<std::vector<double>>> &r,
                const Units &unit,
                const Args &...args ) const;
 
    template<class... Args>
    void evalv( std::vector<std::shared_ptr<AMP::LinearAlgebra::Vector>> &r,
                const Args &...args ) const;
 
    template<class... Args>
    void evalv( AMP::Array<std::shared_ptr<std::vector<double>>> &r,
                const Units &unit,
                const Args &...args ) const;
 
    template<class... Args>
    void evalv( AMP::Array<std::shared_ptr<AMP::LinearAlgebra::Vector>> &r,
                const Args &...args ) const;
 
    template<class... Args>
    void
    evalv( AMP::Array<std::vector<double> *> &r, const Units &unit, const Args &...args ) const;
 
    template<class... Args>
    void evalv( AMP::Array<AMP::LinearAlgebra::Vector *> &r, const Args &...args ) const;
 
    virtual std::string evalString() const;
 
 
protected: // Virtual function to override to load the property
    virtual void eval( AMP::Array<double> &result, const AMP::Array<double> &args ) const = 0;
 
 
protected: // Internal eval/evalv/evalArg
    // clang-format off
    static size_t getSize( const AMP::LinearAlgebra::Vector& );
    static Units getUnits( const AMP::LinearAlgebra::Vector& );
    void evalv( const AMP::Array<double>&, AMP::Array<std::vector<double> *> &, const Units & ) const;
    void evalv( const AMP::Array<double>&, AMP::Array<AMP::LinearAlgebra::Vector *> & ) const;
    void evalArg( AMP::Array<double>&, std::string_view, const Units&, double ) const;
    void evalArg( AMP::Array<double>&, std::string_view, const Units&, const std::vector<double>& ) const;
    void evalArg( AMP::Array<double>&, std::string_view, const Units&, const AMP::LinearAlgebra::Vector& ) const;
    // clang-format on
 
 
protected: // Functions to load the arguments
    // clang-format off
    void evalArgs( AMP::Array<double>& ) const {}
    void evalArgs( AMP::Array<double>&, const std::shared_ptr<AMP::LinearAlgebra::MultiVector>&, const std::map<std::string, std::string>& = {} ) const;
    template<class VEC>
    void evalArgs( AMP::Array<double>&, const std::map<std::string, VEC>& ) const;
    template<class... Args>
    void evalArgs( AMP::Array<double>&, std::string_view, double, const Args&... ) const;
    template<class... Args>
    void evalArgs( AMP::Array<double>&, std::string_view, const Units&, double, const Args&... ) const;
    template<class... Args>
    void evalArgs( AMP::Array<double>&, std::string_view, const std::vector<double>&, const Args&... ) const;
    template<class... Args>
    void evalArgs( AMP::Array<double>&, std::string_view, const AMP::LinearAlgebra::Vector&, const Args&... ) const;
    template<class... Args>
    void evalArgs( AMP::Array<double>&, std::string_view, const Units&, const std::vector<double>&, const Args&... ) const;
    template<class... Args>
    void evalArgs( AMP::Array<double>&, std::string_view, const Units&, const AMP::LinearAlgebra::Vector&, const Args&... ) const;
    template<class VEC, class... Args>
    void evalArgs( AMP::Array<double>&, std::string_view, const std::shared_ptr<VEC>&, const Args&... ) const;
    template<class VEC, class... Args>
    void evalArgs( AMP::Array<double>&, std::string_view, const Units&, const std::shared_ptr<VEC>&, const Args&... ) const;
    void evalArgs( AMP::Array<double>&, const std::vector<double> &args, const std::vector<std::string> &names, const std::vector<Units> &argUnits = {} ) const;
    // clang-format on
 
 
protected:
    std::string d_name;                                 
    AMP::ArraySize d_dim;                               
    AMP::Units d_units;                                 
    std::string d_source;                               
    std::vector<std::string> d_arguments;               
    std::vector<Units> d_argUnits;                      
    std::vector<double> d_defaults;                     
    std::vector<std::array<double, 2>> d_ranges;        
    std::map<std::string_view, size_t> d_argToIndexMap; 
    AMP::Database d_auxiliaryData;                      
 
 
protected:
    Property() = default;
 
    AMP::Array<double> defaultArgs( size_t ) const;
 
    void checkArgs( const AMP::Array<double> &args ) const;
 
    // Get the index for the desired argument
    inline int get_arg_index( std::string_view name ) const
    {
        auto it = d_argToIndexMap.find( name );
        if ( it == d_argToIndexMap.end() )
            return -1;
        return it->second;
    }
};
 
 
std::unique_ptr<Property> createProperty( std::string_view key, const Database &db );
 
 
} // namespace AMP::Materials
 
#endif
 
 
#include "AMP/materials/Property.hpp"