rb_evaluation.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_EVALUATION_H
#define LIBMESH_RB_EVALUATION_H
 
// rbOOmit includes
#include "libmesh/rb_parametrized.h"
 
// libMesh includes
#include "libmesh/dense_matrix.h"
#include "libmesh/dense_vector.h"
#include "libmesh/parallel_object.h"
 
// C++ includes
#include <memory>
 
namespace libMesh
{
 
class System;
template <typename T> class NumericVector;
class RBThetaExpansion;
 
class RBEvaluation : public RBParametrized,
                     public ParallelObject
{
public:
 
  RBEvaluation (const Parallel::Communicator & comm);
 
  RBEvaluation (RBEvaluation &&) = default;
  RBEvaluation (const RBEvaluation &) = delete;
  RBEvaluation & operator= (const RBEvaluation &) = delete;
  RBEvaluation & operator= (RBEvaluation &&) = default;
  virtual ~RBEvaluation ();
 
  virtual void clear() override;
 
  void set_rb_theta_expansion(RBThetaExpansion & rb_theta_expansion_in);
 
  RBThetaExpansion & get_rb_theta_expansion();
  const RBThetaExpansion & get_rb_theta_expansion() const;
 
  bool is_rb_theta_expansion_initialized() const;
 
  virtual void resize_data_structures(const unsigned int Nmax,
                                      bool resize_error_bound_data=true);
 
  NumericVector<Number> & get_basis_function(unsigned int i);
  const NumericVector<Number> & get_basis_function(unsigned int i) const;
 
  virtual Real rb_solve(unsigned int N);
 
  virtual Real rb_solve(unsigned int N,
                        const std::vector<Number> * evaluated_thetas);
 
  virtual Real get_error_bound_normalization();
 
  virtual Real compute_residual_dual_norm(const unsigned int N);
 
  virtual Real compute_residual_dual_norm(const unsigned int N,
                                          const std::vector<Number> * evaluated_thetas);
 
  virtual Real residual_scaling_denom(Real alpha_LB);
 
  Real eval_output_dual_norm(unsigned int n, const std::vector<Number> * evaluated_thetas);
 
  virtual Real get_stability_lower_bound();
 
  virtual unsigned int get_n_basis_functions() const
  { return cast_int<unsigned int>(basis_functions.size()); }
 
  virtual void set_n_basis_functions(unsigned int n_bfs);
 
  virtual void clear_riesz_representors();
 
  virtual void legacy_write_offline_data_to_files(const std::string & directory_name = "offline_data",
                                                  const bool write_binary_data=true);
 
  virtual void legacy_read_offline_data_from_files(const std::string & directory_name = "offline_data",
                                                   bool read_error_bound_data=true,
                                                   const bool read_binary_data=true);
 
  virtual void write_out_basis_functions(System & sys,
                                         const std::string & directory_name = "offline_data",
                                         const bool write_binary_basis_functions = true);
 
  static void write_out_vectors(System & sys,
                                std::vector<NumericVector<Number>*> & vectors,
                                const std::string & directory_name = "offline_data",
                                const std::string & data_name = "bf",
                                const bool write_binary_basis_functions = true);
 
  virtual void read_in_basis_functions(System & sys,
                                       const std::string & directory_name = "offline_data",
                                       const bool read_binary_basis_functions = true);
 
  static void read_in_vectors(System & sys,
                              std::vector<std::unique_ptr<NumericVector<Number>>> & vectors,
                              const std::string & directory_name,
                              const std::string & data_name,
                              const bool read_binary_vectors);
 
  static void read_in_vectors_from_multiple_files(System & sys,
                                                  std::vector<std::vector<std::unique_ptr<NumericVector<Number>>> *> multiple_vectors,
                                                  const std::vector<std::string> & multiple_directory_names,
                                                  const std::vector<std::string> & multiple_data_names,
                                                  const bool read_binary_vectors);
 
  //----------- PUBLIC DATA MEMBERS -----------//
 
  std::vector<std::unique_ptr<NumericVector<Number>>> basis_functions;
 
  std::vector<RBParameters> greedy_param_list;
 
  DenseMatrix<Number> RB_inner_product_matrix;
 
  std::vector<DenseMatrix<Number>> RB_Aq_vector;
 
  std::vector<DenseVector<Number>> RB_Fq_vector;
 
  DenseVector<Number> RB_solution;
 
  std::vector<std::vector<DenseVector<Number>>> RB_output_vectors;
 
  std::vector<Number > RB_outputs;
  std::vector<Real > RB_output_error_bounds;
 
  std::vector<Number> Fq_representor_innerprods;
 
  std::vector<std::vector<std::vector<Number>>> Fq_Aq_representor_innerprods;
  std::vector<std::vector<std::vector<Number>>> Aq_Aq_representor_innerprods;
 
  std::vector<std::vector<Number >> output_dual_innerprods;
 
  std::vector<std::vector<std::unique_ptr<NumericVector<Number>>>> Aq_representor;
 
  bool evaluate_RB_error_bound;
 
  bool compute_RB_inner_product;
 
protected:
 
  static void assert_file_exists(const std::string & file_name);
 
private:
 
  RBThetaExpansion * rb_theta_expansion;
 
  void check_evaluated_thetas_size(const std::vector<Number> * evaluated_thetas) const;
};
 
}
 
#endif // LIBMESH_RB_EVALUATION_H