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"
#include "libmesh/rb_theta_expansion.h"

// libMesh includes
#include "libmesh/dense_matrix.h"
#include "libmesh/dense_vector.h"
#include "libmesh/auto_ptr.h"
#include "libmesh/parallel_object.h"

// C++ includes

namespace libMesh
{

class System;
template <typename T> class NumericVector;

// ------------------------------------------------------------
// RBEvaluation class definition
class RBEvaluation : public RBParametrized,
                     public ParallelObject
{
public:

  RBEvaluation (const Parallel::Communicator &comm
                LIBMESH_CAN_DEFAULT_TO_COMMWORLD);

  virtual ~RBEvaluation ();

  virtual void clear();

  void set_rb_theta_expansion(RBThetaExpansion& rb_theta_expansion_in);

  RBThetaExpansion& get_rb_theta_expansion();

  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);

  virtual Real rb_solve(unsigned int N);

  virtual Real get_rb_solution_norm();

  virtual Real compute_residual_dual_norm(const unsigned int N);

  virtual Real residual_scaling_denom(Real alpha_LB);

  Real eval_output_dual_norm(unsigned int n, const RBParameters& mu);

  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) { basis_functions.resize(n_bfs); }

  virtual void clear_riesz_representors();

  virtual void write_offline_data_to_files(const std::string& directory_name = "offline_data",
                                           const bool write_binary_data=true);

  virtual void 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);

  virtual 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);

  void read_in_vectors(System& sys,
                       std::vector<NumericVector<Number>*>& vectors,
                       const std::string& directory_name,
                       const std::string& data_name,
                       const bool read_binary_vectors);

  void read_in_vectors_from_multiple_files(System& sys,
                                           std::vector< std::vector<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);

  static std::string get_io_version_string();

  //----------- PUBLIC DATA MEMBERS -----------//

  std::vector< 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< NumericVector<Number>* > > Aq_representor;

  bool evaluate_RB_error_bound;

  bool compute_RB_inner_product;

private:

  RBThetaExpansion* rb_theta_expansion;

};

}

#endif // LIBMESH_RB_EVALUATION_H