parameter.hh

#ifndef DUNE_FEM_PARAMETER_HH
#define DUNE_FEM_PARAMETER_HH
 
#include <fstream>
#include <iostream>
#include <string>
#include <unordered_map>
 
#include <dune/fem/io/io.hh>
#include <dune/fem/io/parameter/exceptions.hh>
#include <dune/fem/io/parameter/container.hh>
#include <dune/fem/io/parameter/reader.hh>
 
#include <dune/fem/storage/singleton.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    // Parameter
    // ---------
 
    class Parameter
    {
    public:
      static const int solverStatistics   = ParameterContainerData::solverStatistics;
      static const int extendedStatistics = ParameterContainerData::extendedStatistics;
      static const int parameterOutput    = ParameterContainerData::parameterOutput;
      static const int diagnosticsOutput  = ParameterContainerData::diagnosticsOutput;
      static const int debugOutput        = ParameterContainerData::debugOutput;
 
      static ParameterContainer &container ()
      {
        return Singleton< ParameterContainer > :: instance();
      }
 
      static auto &localParameterLog ()
      {
        return container().localParameterLog_;
      }
 
      static void append ( int &argc, char **argv ) { container().append( argc, argv ); }
 
      static void append ( const std::string &key, const std::string &value, const bool force = false ) { container().append( key, value, force ); }
 
      template<class NumberType>
      static void append ( const std::string &key, const NumberType &value, const bool force = false ) { container().append( key, value, force ); }
 
      static void append ( const std::string &filename ) { container().append( filename ); }
 
      static void appendDGF ( const std::string &filename ) { container().appendDGF( filename ); }
 
      static bool exists ( const std::string &key ) { return container().exists( key ); }
 
      template< class T >
      static void get ( const std::string &key, T &value )
      {
        container().get( key, value );
      }
 
      template< class T >
      static void get ( const std::string &key, const T &defaultValue, T &value )
      {
        container().get( key, defaultValue, value );
      }
 
      static void get ( const std::string &key, const char* defaultValue, std::string &value )
      {
        container().get( key, defaultValue, value );
      }
 
      template< class T, class Validator >
      static void getValid ( const std::string &key, const Validator &validator, T &value )
      {
        container().getValid( key, validator, value );
      }
 
      template< class T, class Validator >
      static void getValid ( const std::string &key, const T &defaultValue, const Validator &validator, T &value )
      {
        container().getValid( key, validator, value );
      }
 
      template< class T >
      static T getValue ( const std::string &key )
      {
        return container().getValue< T >( key );
      }
 
      template< class T >
      static T getValue ( const std::string &key, const T &defaultValue )
      {
        return container().getValue( key, defaultValue );
      }
 
      template< class T, class Validator >
      static T getValidValue ( const std::string &key, const Validator &validator )
      {
        return container().getValidValue( key, validator );
      }
 
 
      template< class T, class Validator >
      static T getValidValue ( const std::string &key, const T &defaultValue, const Validator &validator )
      {
        return container().getValidValue( key, defaultValue, validator );
      }
 
      template< int n >
      static int getEnum ( const std::string &key, const std::string (&values)[ n ] )
      {
        return container().getEnum( key, values );
      }
 
      template< int n >
      static int getEnum ( const std::string &key, const std::string (&values)[ n ], int defaultValue )
      {
        return container().getEnum( key, values, defaultValue );
      }
 
      static int getEnum ( const std::string &key, const std::vector<std::string> &values )
      {
        return container().getEnum( key, values );
      }
 
      static int getEnum ( const std::string &key, const std::vector<std::string> &values, int defaultValue )
      {
        return container().getEnum( key, values, defaultValue );
      }
 
      static std::string commonOutputPath ()
      {
        return container().commonOutputPath();
      }
 
      static std::string outputPath ();
 
      static std::string commonInputPath ()
      {
        return container().commonInputPath();
      }
 
      static bool verbose () { return container().verbose(); }
 
      static bool verbose ( const int level ) { return container().verbose(level ); }
 
      static void write ( const std::string &filename, const std::string &fileextension ="", bool writeAll = true );
 
      static void write ( std::ostream &out, bool writeAll = true ) { return container().write( out, writeAll ); }
      static auto write () { return container().write(); }
 
    protected:
      friend class PersistenceManager ;
 
      static void write ( const std::string &path, const std::string &filename, const std::string &fileextension, bool writeAll = true );
    };
 
 
 
    // Implementation of Parameter
    // ---------------------------
 
    inline std::string Parameter::outputPath ()
    {
      std::string path = commonOutputPath();
      if( path.empty() )
        path = "./";
      if( path[ path.length()-1 ] != '/' )
        path += '/';
      return path + "p" + std::to_string( MPIManager::rank() );
    }
 
 
    inline void Parameter::write ( const std::string &filename, const std::string &fileextension, bool writeAll )
    {
      // only write one parameter log file
      // to the common path
      if( MPIManager::rank() == 0 )
        write( commonOutputPath(), filename, fileextension, writeAll );
    }
 
 
    inline void Parameter::write ( const std::string &path, const std::string &filename, const std::string &fileextension, bool writeAll )
    {
      //create path if it does not exist
      if( !directoryExists( path ) )
        createDirectory( path );
 
      std::string fullname( path );
      fullname += "/";
      fullname += filename;
      fullname += fileextension;
 
      std::ofstream file( fullname );
      if( file.is_open() )
        write( file, writeAll );
      else
        std::cerr << "Warning: Unable to write parameter file '" << fullname << "'" << std::endl;
    }
 
 
 
    // LocalParameter
    // --------------
 
    // Helper class for Parameter structures for classes
    template< class ParamDefault, class ParamImpl >
    struct LocalParameter : public ParamDefault
    {
      virtual ~LocalParameter ()
      {}
 
      virtual ParamDefault *clone () const
      {
        return new ParamImpl( asImp() );
      }
 
      template <class... Args>
      LocalParameter( Args... args ) : ParamDefault( args... ) {}
 
    protected:
      const ParamImpl &asImp () const
      {
        return static_cast< const ParamImpl & >( *this );
      }
    };
 
    template< class ParamDefault >
    struct LocalParameter< ParamDefault, ParamDefault >
    {
      virtual ~LocalParameter ()
      {}
 
      virtual ParamDefault *clone () const
      {
        return new ParamDefault( static_cast< const ParamDefault & >( *this ) );
      }
    };
 
#if 0
    struct ParameterDict
    {
      std::string tmp_;
      const std::string rmPrefix_;
      std::unordered_map<std::string,std::string> dict_;
      ParameterDict(const std::string &rmPrefix,
                    const std::unordered_map<std::string,std::string> &dict )
      : rmPrefix_(rmPrefix), dict_(dict) {}
      const std::string* operator()( const std::string &key, const std::string *def )
      {
        // first determine if the `prefix` of the provided key corresponds
        // to the prefix to be removed:
        if (key.compare(0,rmPrefix_.size(),rmPrefix_) == 0)
        {
          // check the provided map - stripping prefix
          assert(key.size()>rmPrefix_.size());
          std::string reducedKey = key.substr(rmPrefix_.size(),key.size());
          auto pos = dict_.find( reducedKey );
          if (pos != dict_.end())
            return &(pos->second);
        }
        // the key either does not have the correct prefix or it was not
        // found in the provided map so check the global Parameter container
        if( !Fem::Parameter::exists( key ) )
        {
          if( *def == Dune::Fem::checkParameterExistsString() )
            return nullptr;  // this call was simply to check if key exists
          return def;        // return default
        }
        if (def)
          Fem::Parameter::get( key, *def, tmp_ );
        else
          Fem::Parameter::get( key, tmp_ );
        return &tmp_;
      }
    };
    ParameterReader parameterDict (
        const std::string &rmPrefix,
        const std::unordered_map<std::string,std::string> &dict )
    {
      return Fem::ParameterReader( ParameterDict(rmPrefix,dict) );
    }
    ParameterReader parameterDict (
        const std::unordered_map<std::string,std::string> &dict )
    {
      return parameterDict("",dict);
    }
#endif
#if 0
    namespace {
      std::pair<std::string,std::string> convertValueToString(const std::pair<const char*,const char*> &keyValue)
      { return keyValue; }
      template <class V>
      std::pair<std::string,std::string> convertValueToString(const std::pair<const char*,V> &keyValue)
      { return std::make_pair(keyValue.first,std::to_string(keyValue.second)); }
      std::pair<std::string,std::string> convertValueToString(const std::pair<std::string,const char*> &keyValue)
      { return keyValue; }
      template <class V>
      std::pair<std::string,std::string> convertValueToString(const std::pair<std::string,V> &keyValue)
      { return std::make_pair(keyValue.first,std::to_string(keyValue.second)); }
    }
#endif
#if 0
    // this solution needs the user to call the function using `make_pair`
    // becuase {"key",value} will not be deduced correctly
    template<class... Values>
    ParameterReader parameterDict (const std::string &rmPrefix, std::pair< const char*, Values > const &... keyValues)
    {
      std::unordered_map<std::string,std::string> dict;
      dict.insert({convertValueToString(keyValues)...});
      return parameterDict( rmPrefix, dict);
    }
#endif
#if 0
    namespace {
      template<class V>
      void insertIntoMap(std::unordered_map<std::string,std::string> &dict,
          const std::string &key, const V &v)
      { dict.insert(convertValueToString( std::make_pair(key,v) )); }
      template<class V, class... Values>
      void insertIntoMap(std::unordered_map<std::string,std::string> &dict,
          const std::string &key, const V &v, Values... keyValues)
      {
        dict.insert(convertValueToString( std::make_pair(key,v) ));
        insertIntoMap(dict,keyValues...);
      }
    }
    template<class... Values>
    ParameterReader parameterDict (const std::string &rmPrefix, Values... keyValues)
    {
      std::unordered_map<std::string,std::string> dict;
      insertIntoMap(dict,keyValues...);
      return parameterDict( rmPrefix, dict);
    }
#endif
    struct ParameterDict
    {
      typedef std::function<std::string()> LambdaType;
      typedef std::unordered_map<std::string,LambdaType> DictType;
      template <class... KeyValues>
      ParameterDict(const std::string &rmPrefix, KeyValues... keyValues)
      : rmPrefix_(rmPrefix), dict_()
      {
        insertIntoMap(keyValues...);
      }
      const std::string* operator()( const std::string &key, const std::string *def )
      {
        // first determine if the `prefix` of the provided key corresponds
        // to the prefix to be removed:
        if (key.compare(0,rmPrefix_.size(),rmPrefix_) == 0)
        {
          // check the provided map - stripping prefix
          assert(key.size()>rmPrefix_.size());
          std::string reducedKey = key.substr(rmPrefix_.size(),key.size());
          auto pos = dict_.find( reducedKey );
          if (pos != dict_.end())
          {
            tmp_ = pos->second();
            return &tmp_;
          }
          // need to check global parameter set
        }
        // the key either does not have the correct prefix or it was not
        // found in the provided map so check the global Parameter container
        if( !Fem::Parameter::exists( key ) )
        {
          if (def == nullptr)
            return nullptr;
          else if( *def == Dune::Fem::checkParameterExistsString() )
            return nullptr;  // this call was simply to check if key exists
          return def;        // return default
        }
        if (def)
          Fem::Parameter::get( key, *def, tmp_ );
        else
          Fem::Parameter::get( key, tmp_ );
        return &tmp_;
      }
 
      private:
      static std::string convertValueToString(const std::string &value)
      { return value; }
      static std::string convertValueToString(const char* value)
      { return value; }
      template <class V>
      static std::string convertValueToString(const V &value)
      { return ParameterParser<double>::toString(value); }
 
      template<class V, std::enable_if_t<std::is_convertible<V,const LambdaType&>::value,int> i=0>
      void insertIntoMap_(const std::string &key, const V &v, Dune::PriorityTag<2>)
      { dict_.insert( std::make_pair(key, v )); }
      template<class V>
      auto insertIntoMap_(const std::string &key, const V &v, Dune::PriorityTag<1>)
        -> void_t< decltype(std::declval<const V&>()()) >
      { dict_.insert( std::make_pair(key, [v]() { return convertValueToString(v()); } )); }
      template<class V>
      void insertIntoMap_(const std::string &key, const V &v, Dune::PriorityTag<0>)
      { dict_.insert( std::make_pair(key, [v]() { return convertValueToString(v); } )); }
 
      template<class V>
      void insertIntoMap(const std::string &key, const V &v)
      { insertIntoMap_(key,v,PriorityTag<42>()); }
      template<class V, class... Values>
      void insertIntoMap(const std::string &key, const V &v, Values... keyValues)
      {
        insertIntoMap_(key,v,PriorityTag<42>());
        insertIntoMap(keyValues...);
      }
 
      std::string tmp_;
      const std::string rmPrefix_;
      DictType dict_;
    };
 
    template<class... KeyValues>
    ParameterReader parameterDict (const std::string &rmPrefix, KeyValues... keyValues)
    {
      return Fem::ParameterReader( ParameterDict(rmPrefix,keyValues...) );
    }
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_PARAMETER_HH