transient_rb_construction.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_CONSTRUCTION_H
#define LIBMESH_TRANSIENT_RB_CONSTRUCTION_H
 
// rbOOmit includes
#include "libmesh/rb_construction.h"
#include "libmesh/transient_rb_evaluation.h"
#include "libmesh/rb_temporal_discretization.h"
 
// libMesh includes
#include "libmesh/transient_system.h"
 
// C++ includes
 
namespace libMesh
{
 
class TransientRBConstruction : public TransientSystem<RBConstruction>, public RBTemporalDiscretization
{
public:
 
  TransientRBConstruction (EquationSystems & es,
                           const std::string & name,
                           const unsigned int number);
 
  TransientRBConstruction (TransientRBConstruction &&) = default;
  TransientRBConstruction (const TransientRBConstruction &) = delete;
  TransientRBConstruction & operator= (const TransientRBConstruction &) = delete;
  TransientRBConstruction & operator= (TransientRBConstruction &&) = delete;
  virtual ~TransientRBConstruction ();
 
  typedef TransientRBConstruction sys_type;
 
  typedef TransientSystem<RBConstruction> Parent;
 
  virtual void clear () override;
 
  virtual void initialize_rb_construction(bool skip_matrix_assembly=false,
                                          bool skip_vector_assembly=false) override;
 
  virtual Real truth_solve(int write_interval) override;
 
  virtual Real train_reduced_basis(const bool resize_rb_eval_data=true) override;
 
  virtual void process_parameters_file (const std::string & parameters_filename) override;
 
  virtual void print_info() const override;
 
  virtual bool greedy_termination_test(Real abs_greedy_error,
                                       Real initial_greedy_error,
                                       int count) override;
 
  virtual void assemble_all_affine_operators() override;
 
  virtual void assemble_misc_matrices() override;
 
  void assemble_L2_matrix(SparseMatrix<Number> * input_matrix,
                          bool apply_dirichlet_bc=true);
 
  void assemble_mass_matrix(SparseMatrix<Number> * input_matrix);
 
  void add_scaled_mass_matrix(Number scalar,
                              SparseMatrix<Number> * input_matrix);
 
  void mass_matrix_scaled_matvec(Number scalar,
                                 NumericVector<Number> & dest,
                                 NumericVector<Number> & arg);
 
  void set_L2_assembly(ElemAssembly & L2_assembly_in);
 
  ElemAssembly & get_L2_assembly();
 
  void assemble_Mq_matrix(unsigned int q,
                          SparseMatrix<Number> * input_matrix,
                          bool apply_dirichlet_bc=true);
 
  SparseMatrix<Number> * get_M_q(unsigned int q);
 
  SparseMatrix<Number> * get_non_dirichlet_M_q(unsigned int q);
 
  virtual void get_all_matrices(std::map<std::string, SparseMatrix<Number> *> & all_matrices) override;
 
  virtual void truth_assembly() override;
 
  int get_max_truth_solves() const                   { return max_truth_solves; }
  void set_max_truth_solves(int max_truth_solves_in) { this->max_truth_solves = max_truth_solves_in; }
 
  Real get_POD_tol() const                { return POD_tol; }
  void set_POD_tol(const Real POD_tol_in) { this->POD_tol = POD_tol_in; }
 
  void set_delta_N(const unsigned int new_delta_N) { this->delta_N = new_delta_N; }
 
  virtual void load_rb_solution() override;
 
  const NumericVector<Number> & get_error_temporal_data();
 
  void update_RB_initial_condition_all_N();
 
  virtual void write_riesz_representors_to_files(const std::string & riesz_representors_dir,
                                                 const bool write_binary_residual_representors) override;
 
  virtual void read_riesz_representors_from_files(const std::string & riesz_representors_dir,
                                                  const bool write_binary_residual_representors) override;
 
 
  //----------- PUBLIC DATA MEMBERS -----------//
 
  std::unique_ptr<SparseMatrix<Number>> L2_matrix;
 
  std::unique_ptr<SparseMatrix<Number>> non_dirichlet_L2_matrix;
 
  std::vector<std::unique_ptr<SparseMatrix<Number>>> M_q_vector;
 
  std::vector<std::unique_ptr<SparseMatrix<Number>>> non_dirichlet_M_q_vector;
 
  std::vector<std::vector<Number>> truth_outputs_all_k;
 
  bool nonzero_initialization;
 
  bool compute_truth_projection_error;
 
  std::string init_filename;
 
protected:
 
  virtual void allocate_data_structures() override;
 
  virtual void assemble_affine_expansion(bool skip_matrix_assembly,
                                         bool skip_vector_assembly) override;
 
  virtual void initialize_truth();
 
  virtual SparseMatrix<Number> & get_matrix_for_output_dual_solves() override;
 
  void add_IC_to_RB_space();
 
  virtual void enrich_RB_space() override;
 
  virtual void update_system() override;
 
  virtual void update_RB_system_matrices() override;
 
  virtual void update_residual_terms(bool compute_inner_products) override;
 
  Number set_error_temporal_data();
 
  //----------- PROTECTED DATA MEMBERS -----------//
 
  Real POD_tol;
 
  int max_truth_solves;
 
  ElemAssembly * L2_assembly;
 
  DenseVector<Number> RB_ic_proj_rhs_all_N;
 
private:
 
  //----------- PRIVATE DATA MEMBERS -----------//
 
  std::vector<std::unique_ptr<NumericVector<Number>>> temporal_data;
};
 
} // namespace libMesh
 
#endif // LIBMESH_TRANSIENT_RB_CONSTRUCTION_H