rb_construction_base.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_CONSTRUCTION_BASE_H
#define LIBMESH_RB_CONSTRUCTION_BASE_H
 
// rbOOmit includes
#include "libmesh/id_types.h"
#include "libmesh/rb_parametrized.h"
#include "libmesh/rb_theta_expansion.h"
#include "libmesh/rb_theta.h"
 
// libMesh includes
#include "libmesh/system.h"
#include "libmesh/numeric_vector.h"
#include "libmesh/linear_solver.h"
#include "libmesh/perf_log.h"
 
// C++ includes
#include <set>
 
namespace libMesh
{
 
template<class Base>
class RBConstructionBase : public Base, public RBParametrized
{
public:
 
  RBConstructionBase (EquationSystems & es,
                      const std::string & name,
                      const unsigned int number);
 
  RBConstructionBase (RBConstructionBase &&) = default;
  RBConstructionBase & operator= (RBConstructionBase &&) = delete;
  RBConstructionBase (const RBConstructionBase &) = delete;
  RBConstructionBase & operator= (const RBConstructionBase &) = delete;
  virtual ~RBConstructionBase ();
 
  typedef RBConstructionBase<Base> sys_type;
 
  sys_type & system () { return *this; }
 
  virtual void clear ();
 
  void set_quiet_mode(bool quiet_mode_in)
  { this->quiet_mode = quiet_mode_in; }
 
  bool is_quiet() const
  { return this->quiet_mode; }
 
  void set_normalize_solution_snapshots(bool value);
 
  numeric_index_type get_n_training_samples() const;
 
  numeric_index_type get_local_n_training_samples() const;
 
  numeric_index_type get_first_local_training_index() const;
 
  numeric_index_type get_last_local_training_index() const;
 
  virtual void initialize_training_parameters(const RBParameters & mu_min,
                                              const RBParameters & mu_max,
                                              const unsigned int n_global_training_samples,
                                              const std::map<std::string, bool> & log_param_scale,
                                              const bool deterministic=true);
 
  virtual void load_training_set(const std::map<std::string, std::vector<RBParameter>> & new_training_set);
 
  void set_training_parameter_values(const std::string & param_name, const std::vector<RBParameter> & values);
 
  void broadcast_parameters(const unsigned int proc_id);
 
  void set_training_random_seed(int seed);
 
  void set_deterministic_training_parameter_name(const std::string & name);
 
  const std::string & get_deterministic_training_parameter_name() const;
 
  static std::pair<std::size_t, std::size_t>
  generate_training_parameters_random(const Parallel::Communicator & communicator,
                                      const std::map<std::string, bool> & log_param_scale,
                                      std::map<std::string, std::vector<RBParameter>> & local_training_parameters_in,
                                      const unsigned int n_global_training_samples_in,
                                      const RBParameters & min_parameters,
                                      const RBParameters & max_parameters,
                                      const int training_parameters_random_seed=-1,
                                      const bool serial_training_set=false);
 
  static std::pair<std::size_t, std::size_t>
  generate_training_parameters_deterministic(const Parallel::Communicator & communicator,
                                             const std::map<std::string, bool> & log_param_scale,
                                             std::map<std::string, std::vector<RBParameter>> & local_training_parameters_in,
                                             const unsigned int n_global_training_samples_in,
                                             const RBParameters & min_parameters,
                                             const RBParameters & max_parameters,
                                             const bool serial_training_set=false);
 
protected:
 
  virtual void init_data ();
 
  RBParameters get_params_from_training_set(unsigned int global_index);
 
  void set_params_from_training_set(unsigned int global_index);
 
  virtual void set_params_from_training_set_and_broadcast(unsigned int global_index);
 
  static void get_global_max_error_pair(const Parallel::Communicator & communicator,
                                        std::pair<numeric_index_type, Real> & error_pair);
 
 
  //----------- PROTECTED DATA MEMBERS -----------//
 
  bool quiet_mode;
 
  bool serial_training_set;
 
  bool _normalize_solution_snapshots;
 
  std::unique_ptr<NumericVector<Number>> inner_product_storage_vector;
 
 
private:
 
  bool _training_parameters_initialized;
 
  std::map<std::string, std::vector<RBParameter>> _training_parameters;
 
  numeric_index_type _first_local_index;
  numeric_index_type _n_local_training_samples;
  numeric_index_type _n_global_training_samples;
 
  int _training_parameters_random_seed;
};
 
} // namespace libMesh
 
 
#endif // LIBMESH_RB_CONSTRUCTION_BASE_H