rb_parameters.h

Go to the documentation of this file.

// rbOOmit: An implementation of the Certified Reduced Basis method.
// Copyright (C) 2009, 2010 David J. Knezevic
 
// This file is part of rbOOmit.
 
// rbOOmit is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
 
// rbOOmit is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
 
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
#ifndef LIBMESH_RB_PARAMETERS_H
#define LIBMESH_RB_PARAMETERS_H
 
// libMesh includes
#include "libmesh/libmesh_common.h"
 
// C++ includes
#include <string>
#include <map>
#include <set>
#include <vector>
 
namespace libMesh
{
 
using RBParameter = std::vector<Real>;
 
class RBParameters
{
public:
 
  RBParameters();
 
  RBParameters (RBParameters &&) = default;
  RBParameters (const RBParameters &) = default;
  RBParameters & operator= (const RBParameters &) = default;
  RBParameters & operator= (RBParameters &&) = default;
  ~RBParameters() = default;
 
  RBParameters(const std::map<std::string, Real> & parameter_map);
 
  std::map<std::string,std::vector<RBParameter>>::const_iterator begin() const;
  std::map<std::string,std::vector<RBParameter>>::const_iterator end() const;
  std::map<std::string,std::vector<RBParameter>>::const_iterator extra_begin() const;
  std::map<std::string,std::vector<RBParameter>>::const_iterator extra_end() const;
 
  class const_iterator
  {
  public:
    // Typedefs needed for interoperating with other STL algorithms and containers.
    typedef std::forward_iterator_tag iterator_category;
    typedef std::pair<std::string, Real> value_type;
    typedef std::ptrdiff_t difference_type;
    typedef value_type* pointer;
    typedef value_type& reference;
 
    // Underlying iterator type, must match the container type of _parameters.
    typedef std::map<std::string, std::vector<RBParameter>>::const_iterator MapIter;
 
    // Constructor
    const_iterator(const MapIter & it,
                   const std::size_t sample_vec_index,
                   const std::size_t value_vec_index)
      : _it(it),
        _sample_vec_index(sample_vec_index),
        _value_vec_index(value_vec_index)
    {}
 
    // Copy ctor
    const_iterator(const const_iterator & i) = default;
 
    // Prefix increment operator "++it"
    const_iterator & operator++()
    {
      // First increment the value-vector index.
      // If _value_vec_index goes beyond the current value-vector, reset to the next one.
      ++_value_vec_index;
      if (_value_vec_index >= _it->second[_sample_vec_index].size())
        {
          _value_vec_index = 0;
          // Now increment the sample-vector index, and do the same check.
          // If we go beyond the current sample-vector, reset to the next one.
          ++_sample_vec_index;
          if (_sample_vec_index >= _it->second.size())
            {
              _sample_vec_index = 0;
              ++_it;
            }
        }
 
      return *this;
    }
 
    // Postfix increment operator "it++". This is actually less
    // efficient than doing the prefix increment, so if nothing
    // requires it, let's skip defining it.
    // const_iterator operator++(int)
    // {
    //   const_iterator i = *this;
    //   ++(*this);
    //   return i;
    // }
 
    // Dereference operator - returns a const reference to the value
    // indexed by it and _vec_index. Note: this is needed for backwards
    // compatibility but it is not the most efficient thing since we
    // need to construct a std::pair every time we dereference a
    // const_iterator.
    const value_type & operator*() const
    {
      _emulator = std::make_pair(_it->first, _it->second[_sample_vec_index][_value_vec_index]);
      return _emulator;
    }
 
    // Equivalence comparison operator.
    bool operator==(const const_iterator & other) const
    {
      return (_it == other._it && _sample_vec_index == other._sample_vec_index);
    }
 
    // Non-equvialence comparison operator
    bool operator!=(const const_iterator & other) const
    {
      return !(other == *this);
    }
 
  private:
    // Give RBParameters access to our private members. At the moment
    // this is not needed since the RBParameters class does not really
    // need to know anything about the const_iterator once it has been
    // created.
    // friend class RBParameters;
 
    // Iterator into real container
    MapIter _it;
 
    // Accompanying current sample-vector index into it->second
    std::size_t _sample_vec_index;
 
    // Accompanying current value-vector index into it->second[_sample_vec_index]
    std::size_t _value_vec_index;
 
    // Returned by the operator* function. Emulates dereferencing a
    // map<string, Real> iterator.
    mutable value_type _emulator;
  };  // end const_iterator
 
  const_iterator begin_serialized() const;
  const_iterator end_serialized() const;
 
  const_iterator begin_serialized_extra() const;
  const_iterator end_serialized_extra() const;
 
  void clear();
 
  bool has_value(const std::string & param_name) const;
 
  bool has_extra_value(const std::string & param_name) const;
 
  Real get_value(const std::string & param_name) const;
  const RBParameter & get_vector_value(const std::string & param_name) const;
 
  Real get_value(const std::string & param_name, const Real & default_val) const;
  const RBParameter & get_vector_value(const std::string & param_name, const RBParameter & default_val) const;
 
  Real get_sample_value(const std::string & param_name, std::size_t sample_idx) const;
  const RBParameter & get_sample_vector_value(const std::string & param_name, std::size_t sample_idx) const;
 
  Real get_sample_value(const std::string & param_name, std::size_t sample_idx, const Real & default_val) const;
  const RBParameter & get_sample_vector_value(const std::string & param_name, std::size_t sample_idx, const RBParameter & default_val) const;
 
  void set_value(const std::string & param_name, Real value);
  void set_value(const std::string & param_name, const RBParameter & value);
 
  void set_value(const std::string & param_name, std::size_t index, Real value);
  void set_value(const std::string & param_name, std::size_t index, const RBParameter & value);
 
  void push_back_value(const std::string & param_name, Real value);
  void push_back_value(const std::string & param_name, const RBParameter & value);
 
  void push_back_extra_value(const std::string & param_name, Real value);
  void push_back_extra_value(const std::string & param_name, const RBParameter & value);
 
  Real get_extra_value(const std::string & param_name) const;
  const RBParameter & get_extra_vector_value(const std::string & param_name) const;
 
  Real get_extra_value(const std::string & param_name, const Real & default_val) const;
  const RBParameter & get_extra_vector_value(const std::string & param_name, const RBParameter & default_val) const;
 
  Real get_extra_sample_value(const std::string & param_name, std::size_t sample_idx) const;
  const RBParameter & get_extra_sample_vector_value(const std::string & param_name, std::size_t sample_idx) const;
 
  Real get_extra_sample_value(const std::string & param_name, std::size_t sample_idx, const Real & default_val) const;
  const RBParameter & get_extra_sample_vector_value(const std::string & param_name, std::size_t sample_idx, const RBParameter & default_val) const;
 
  void set_extra_value(const std::string & param_name, Real value);
  void set_extra_value(const std::string & param_name, const RBParameter & value);
 
  void set_extra_value(const std::string & param_name, std::size_t index, Real value);
  void set_extra_value(const std::string & param_name, std::size_t index, const RBParameter & value);
 
  unsigned int n_parameters() const;
 
  void set_n_samples(unsigned int n_samples);
 
  unsigned int n_samples() const;
 
  std::set<std::string> get_parameter_names() const;
 
  std::set<std::string> get_extra_parameter_names() const;
 
  void erase_parameter(const std::string & param_name);
 
  void erase_extra_parameter(const std::string & param_name);
 
  bool operator== (const RBParameters & rhs) const;
 
  bool operator!= (const RBParameters & rhs) const;
 
  RBParameters & operator+= (const RBParameters & rhs);
 
  std::string get_string(unsigned precision=6, int max_values=5) const;
 
  void print(unsigned precision=6, int max_values=5) const;
 
private:
 
  void set_value_helper(std::map<std::string, std::vector<RBParameter>> & map,
                        const std::string & param_name,
                        const std::size_t index,
                        RBParameter value);
 
  unsigned int _n_samples;
 
  std::map<std::string, std::vector<RBParameter>> _parameters;
 
  std::map<std::string, std::vector<RBParameter>> _extra_parameters;
};
 
} // namespace libMesh
 
 
#endif // LIBMESH_RB_PARAMETERS_H