transient_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_TRANSIENT_RB_EVALUATION_H
#define LIBMESH_TRANSIENT_RB_EVALUATION_H
 
// rbOOmit includes
#include "libmesh/rb_evaluation.h"
#include "libmesh/rb_temporal_discretization.h"
 
// libMesh includes
 
// C++ includes
 
namespace libMesh
{
 
class TransientRBThetaExpansion;
 
class TransientRBEvaluation : public RBEvaluation, public RBTemporalDiscretization
{
public:
 
  TransientRBEvaluation (const Parallel::Communicator & comm_in);
 
  TransientRBEvaluation (TransientRBEvaluation &&) = default;
  TransientRBEvaluation (const TransientRBEvaluation &) = delete;
  TransientRBEvaluation & operator= (const TransientRBEvaluation &) = delete;
  TransientRBEvaluation & operator= (TransientRBEvaluation &&) = default;
  virtual ~TransientRBEvaluation ();
 
  typedef RBEvaluation Parent;
 
  virtual void clear() override;
 
  virtual void resize_data_structures(const unsigned int Nmax,
                                      bool resize_error_bound_data=true) override;
 
  using RBEvaluation::rb_solve;
  virtual Real rb_solve(unsigned int N) override;
 
  virtual Real rb_solve_again();
 
  virtual Real get_error_bound_normalization() override;
 
  virtual Real residual_scaling_numer(Real alpha_LB);
 
  using RBEvaluation::compute_residual_dual_norm;
  virtual Real compute_residual_dual_norm(const unsigned int N) override;
 
  virtual Real uncached_compute_residual_dual_norm(const unsigned int N);
 
  void cache_online_residual_terms(const unsigned int N);
 
  virtual void clear_riesz_representors() override;
 
  virtual void legacy_write_offline_data_to_files(const std::string & directory_name = "offline_data",
                                                  const bool write_binary_data=true) override;
 
  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) override;
 
  //----------- PUBLIC DATA MEMBERS -----------//
 
  DenseMatrix<Number> RB_L2_matrix;
 
  DenseMatrix<Number> RB_LHS_matrix;
  DenseMatrix<Number> RB_RHS_matrix;
  DenseVector<Number> RB_RHS_save;
 
  std::vector<DenseMatrix<Number>> RB_M_q_vector;
 
  std::vector<std::vector<Number>> RB_outputs_all_k;
 
  std::vector<std::vector<Real>> RB_output_error_bounds_all_k;
 
  DenseVector<Number> old_RB_solution;
 
  std::vector<DenseVector<Number>> RB_temporal_solution_data;
 
  std::vector<Real > error_bound_all_k;
 
  std::vector<Real> initial_L2_error_all_N;
 
  std::vector<DenseVector<Number>> RB_initial_condition_all_N;
 
  std::vector<std::vector<std::vector<Number>>> Fq_Mq_representor_innerprods;
  std::vector<std::vector<std::vector<Number>>> Mq_Mq_representor_innerprods;
  std::vector<std::vector<std::vector<std::vector<Number>>>> Aq_Mq_representor_innerprods;
 
 
  Number cached_Fq_term;
  DenseVector<Number> cached_Fq_Aq_vector;
  DenseMatrix<Number> cached_Aq_Aq_matrix;
  DenseVector<Number> cached_Fq_Mq_vector;
  DenseMatrix<Number> cached_Aq_Mq_matrix;
  DenseMatrix<Number> cached_Mq_Mq_matrix;
 
  std::vector<std::vector<std::unique_ptr<NumericVector<Number>>>> M_q_representor;
 
  bool _rb_solve_data_cached;
};
 
}
 
#endif // LIBMESH_TRANSIENT_RB_EVALUATION_H