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/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
{

// ------------------------------------------------------------
// RBConstructionBase class definition
template<class Base>
class RBConstructionBase : public Base, public RBParametrized
{
public:

  RBConstructionBase (EquationSystems& es,
                      const std::string& name,
                      const unsigned int number);

  virtual ~RBConstructionBase ();

  typedef RBConstructionBase<Base> sys_type;

  sys_type & system () { return *this; }

  virtual void clear ();

  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,
                                              unsigned int n_training_parameters,
                                              std::map<std::string, bool> log_param_scale,
                                              bool deterministic=true);

  virtual void load_training_set(std::map< std::string, std::vector<Number> >& new_training_set);

  std::pair<std::string,std::string> set_alternative_solver(UniquePtr<LinearSolver<Number> >& ls);

  void reset_alternative_solver(UniquePtr<LinearSolver<Number> >& ls,
                                const std::pair<std::string,std::string>& orig);

  void broadcast_parameters(unsigned int proc_id);

  void set_training_random_seed(unsigned int seed);

  void set_deterministic_training_parameter_name(const std::string& name);

  const std::string& get_deterministic_training_parameter_name() const;

  void set_deterministic_training_parameter_repeats(unsigned int repeats);

  unsigned int get_deterministic_training_parameter_repeats() const;

protected:

  virtual void init_data ();

  RBParameters get_params_from_training_set(unsigned int index);

  void set_params_from_training_set(unsigned int index);

  virtual void set_params_from_training_set_and_broadcast(unsigned int index);

  static void get_global_max_error_pair(const Parallel::Communicator &communicator,
                                        std::pair<unsigned int, Real>& error_pair);

  static void generate_training_parameters_random(const Parallel::Communicator &communicator,
                                                  std::map<std::string, bool> log_param_scale,
                                                  std::map< std::string, NumericVector<Number>* >& training_parameters_in,
                                                  unsigned int n_training_samples_in,
                                                  const RBParameters& min_parameters,
                                                  const RBParameters& max_parameters,
                                                  int training_parameters_random_seed=-1,
                                                  bool serial_training_set=false);

  static void generate_training_parameters_deterministic(const Parallel::Communicator &communicator,
                                                         std::map<std::string, bool> log_param_scale,
                                                         std::map< std::string, NumericVector<Number>* >& training_parameters_in,
                                                         unsigned int n_training_samples_in,
                                                         const RBParameters& min_parameters,
                                                         const RBParameters& max_parameters,
                                                         bool serial_training_set=false);


  //----------- PROTECTED DATA MEMBERS -----------//

  bool serial_training_set;

  UniquePtr< NumericVector<Number> > inner_product_storage_vector;

  std::string alternative_solver;


private:

  bool training_parameters_initialized;

  std::map< std::string, NumericVector<Number>* > training_parameters;

  int training_parameters_random_seed;

};

} // namespace libMesh


#endif // LIBMESH_RB_CONSTRUCTION_BASE_H