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
{

// ------------------------------------------------------------
// TransientRBConstruction class definition

class TransientRBConstruction : public TransientSystem<RBConstruction>, public RBTemporalDiscretization
{
public:

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

  virtual ~TransientRBConstruction ();

  typedef TransientRBConstruction sys_type;

  typedef TransientSystem<RBConstruction> Parent;

  virtual void clear ();

  virtual void initialize_rb_construction(bool skip_matrix_assembly=false,
                                          bool skip_vector_assembly=false);

  virtual Real truth_solve(int write_interval);

  virtual Real train_reduced_basis(const std::string& directory_name = "offline_data",
                                   const bool resize_rb_eval_data=true);

  virtual void process_parameters_file (const std::string& parameters_filename);

  virtual void print_info();

  virtual bool greedy_termination_test(Real training_greedy_error, int count);

  virtual void assemble_all_affine_operators();

  virtual void assemble_misc_matrices();

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

  virtual void truth_assembly();

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

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

  virtual void read_riesz_representors_from_files(const std::string& riesz_representors_dir,
                                                  const bool write_binary_residual_representors);


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

  UniquePtr< SparseMatrix<Number> > L2_matrix;

  UniquePtr< SparseMatrix<Number> > non_dirichlet_L2_matrix;

  std::vector< SparseMatrix<Number>* > M_q_vector;

  std::vector< 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();

  virtual void assemble_affine_expansion(bool skip_matrix_assembly,
                                         bool skip_vector_assembly);

  virtual void initialize_truth();

  virtual void assemble_matrix_for_output_dual_solves();

  void add_IC_to_RB_space();

  virtual void enrich_RB_space();

  virtual void update_system();

  virtual void update_RB_system_matrices();

  virtual void update_residual_terms(bool compute_inner_products);

  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< NumericVector<Number>* > temporal_data;

};

} // namespace libMesh

#endif // LIBMESH_TRANSIENT_RB_CONSTRUCTION_H