rb_parametrized_function.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_PARAMETRIZED_FUNCTION_H
#define LIBMESH_RB_PARAMETRIZED_FUNCTION_H
 
// libMesh includes
#include "libmesh/libmesh_common.h"
#include "libmesh/enum_elem_type.h"
#include "libmesh/enum_order.h"
 
// C++ includes
#include <unordered_map>
#include <vector>
#include <map>
#include <set>
 
namespace libMesh
{
 
class RBParameters;
class Point;
class System;
 
namespace Parallel {
  class Communicator;
}
 
struct VectorizedEvalInput
{
  VectorizedEvalInput () = default;
  VectorizedEvalInput (const VectorizedEvalInput &) = default;
  VectorizedEvalInput & operator= (const VectorizedEvalInput &) = default;
  VectorizedEvalInput (VectorizedEvalInput &&) = default;
  VectorizedEvalInput & operator= (VectorizedEvalInput &&) = default;
  virtual ~VectorizedEvalInput() = default;
 
  void clear();
 
  std::vector<Point> all_xyz;
  std::vector<dof_id_type> elem_ids;
  std::vector<unsigned int> qps;
  std::vector<subdomain_id_type> sbd_ids;
  std::vector<std::vector<Point>> all_xyz_perturb;
  std::vector<std::vector<Real>> phi_i_qp;
  std::vector<unsigned int> side_indices;
  std::vector<boundary_id_type> boundary_ids;
  std::vector<dof_id_type> node_ids;
  std::vector<ElemType> elem_types;
  std::map<dof_id_type, unsigned int> elem_id_to_local_index;
  std::vector<std::vector<Real>> JxW_all_qp;
  std::vector<std::vector<std::vector<Real>>> phi_i_all_qp;
  std::vector<Point> dxyzdxi_elem_center;
  std::vector<Point> dxyzdeta_elem_center;
  std::vector<Order> qrule_orders;
 
  std::unordered_map<std::string, std::set<dof_id_type>> rb_property_map;
};
 
class RBParametrizedFunction
{
public:
 
  RBParametrizedFunction();
 
  RBParametrizedFunction (RBParametrizedFunction &&) = default;
  RBParametrizedFunction (const RBParametrizedFunction &) = default;
  RBParametrizedFunction & operator= (const RBParametrizedFunction &) = default;
  RBParametrizedFunction & operator= (RBParametrizedFunction &&) = default;
  virtual ~RBParametrizedFunction();
 
  virtual unsigned int get_n_components() const = 0;
 
  virtual Number evaluate_comp(const RBParameters & mu,
                               unsigned int comp,
                               const Point & xyz,
                               dof_id_type elem_id,
                               unsigned int qp,
                               subdomain_id_type subdomain_id,
                               const std::vector<Point> & xyz_perturb,
                               const std::vector<Real> & phi_i_qp);
 
  virtual Number side_evaluate_comp(const RBParameters & mu,
                                    unsigned int comp,
                                    const Point & xyz,
                                    dof_id_type elem_id,
                                    unsigned int side_index,
                                    unsigned int qp,
                                    subdomain_id_type subdomain_id,
                                    boundary_id_type boundary_id,
                                    const std::vector<Point> & xyz_perturb,
                                    const std::vector<Real> & phi_i_qp);
 
  virtual Number node_evaluate_comp(const RBParameters & mu,
                                    unsigned int comp,
                                    const Point & xyz,
                                    dof_id_type node_id,
                                    boundary_id_type boundary_id);
 
  virtual std::vector<Number> evaluate(const RBParameters & mu,
                                       const Point & xyz,
                                       dof_id_type elem_id,
                                       unsigned int qp,
                                       subdomain_id_type subdomain_id,
                                       const std::vector<Point> & xyz_perturb,
                                       const std::vector<Real> & phi_i_qp);
 
  virtual std::vector<Number> side_evaluate(const RBParameters & mu,
                                            const Point & xyz,
                                            dof_id_type elem_id,
                                            unsigned int side_index,
                                            unsigned int qp,
                                            subdomain_id_type subdomain_id,
                                            boundary_id_type boundary_id,
                                            const std::vector<Point> & xyz_perturb,
                                            const std::vector<Real> & phi_i_qp);
 
  virtual std::vector<Number> node_evaluate(const RBParameters & mu,
                                            const Point & xyz,
                                            dof_id_type node_id,
                                            boundary_id_type boundary_id);
 
  virtual void vectorized_evaluate(const std::vector<RBParameters> & mus,
                                   const VectorizedEvalInput & v,
                                   std::vector<std::vector<std::vector<Number>>> & output);
 
  virtual void side_vectorized_evaluate(const std::vector<RBParameters> & mus,
                                        const VectorizedEvalInput & v,
                                        std::vector<std::vector<std::vector<Number>>> & output);
 
  virtual void node_vectorized_evaluate(const std::vector<RBParameters> & mus,
                                        const VectorizedEvalInput & v,
                                        std::vector<std::vector<std::vector<Number>>> & output);
 
  virtual void preevaluate_parametrized_function_on_mesh(const RBParameters & mu,
                                                         const std::unordered_map<dof_id_type, std::vector<Point>> & all_xyz,
                                                         const std::unordered_map<dof_id_type, subdomain_id_type> & sbd_ids,
                                                         const std::unordered_map<dof_id_type, std::vector<std::vector<Point>> > & all_xyz_perturb,
                                                         const System & sys);
 
  virtual void preevaluate_parametrized_function_on_mesh_sides(const RBParameters & mu,
                                                               const std::map<std::pair<dof_id_type,unsigned int>, std::vector<Point>> & side_all_xyz,
                                                               const std::map<std::pair<dof_id_type,unsigned int>, subdomain_id_type> & sbd_ids,
                                                               const std::map<std::pair<dof_id_type,unsigned int>, boundary_id_type> & side_boundary_ids,
                                                               const std::map<std::pair<dof_id_type,unsigned int>, unsigned int> & side_types,
                                                               const std::map<std::pair<dof_id_type,unsigned int>, std::vector<std::vector<Point>> > & side_all_xyz_perturb,
                                                               const System & sys);
 
  virtual void preevaluate_parametrized_function_on_mesh_nodes(const RBParameters & mu,
                                                               const std::unordered_map<dof_id_type, Point> & all_xyz,
                                                               const std::unordered_map<dof_id_type, boundary_id_type> & node_boundary_ids,
                                                               const System & sys);
 
  virtual Number lookup_preevaluated_value_on_mesh(unsigned int comp,
                                                   dof_id_type elem_id,
                                                   unsigned int qp) const;
 
  virtual Number lookup_preevaluated_side_value_on_mesh(unsigned int comp,
                                                        dof_id_type elem_id,
                                                        unsigned int side_index,
                                                        unsigned int qp) const;
 
  virtual Number lookup_preevaluated_node_value_on_mesh(unsigned int comp,
                                                        dof_id_type node_id) const;
 
  virtual void initialize_lookup_table();
 
  Number get_parameter_independent_data(const std::string & property_name,
                                        subdomain_id_type sbd_id) const;
 
  const std::set<boundary_id_type> & get_parametrized_function_boundary_ids() const;
  void set_parametrized_function_boundary_ids(const std::set<boundary_id_type> & boundary_ids, bool is_nodal_boundary);
 
  bool on_mesh_sides() const;
 
  bool on_mesh_nodes() const;
 
  virtual void get_spatial_indices(std::vector<std::vector<unsigned int>> & spatial_indices,
                                   const VectorizedEvalInput & v);
 
  virtual void initialize_spatial_indices(const std::vector<std::vector<unsigned int>> & spatial_indices,
                                          const VectorizedEvalInput & v);
 
  virtual void preevaluate_parametrized_function_cleanup();
 
  const std::unordered_map<std::string, std::set<dof_id_type>> &  get_rb_property_map() const;
 
  void add_rb_property_map_entry(std::string & property_name, std::set<dof_id_type> & entity_ids);
 
  virtual void add_interpolation_data_to_rb_property_map(
    const Parallel::Communicator & comm,
    std::unordered_map<std::string, std::set<dof_id_type>> & rb_property_map,
    dof_id_type elem_id);
 
  std::vector<std::vector<std::vector<Number>>> preevaluated_values;
 
  std::unordered_map<dof_id_type, std::vector<unsigned int>> mesh_to_preevaluated_values_map;
 
  std::map<std::pair<dof_id_type,unsigned int>, std::vector<unsigned int>> mesh_to_preevaluated_side_values_map;
 
  std::unordered_map<dof_id_type, unsigned int> mesh_to_preevaluated_node_values_map;
 
  bool requires_xyz_perturbations;
 
  bool requires_all_elem_qp_data;
 
  bool requires_all_elem_center_data;
 
  bool is_lookup_table;
 
  std::string lookup_table_param_name;
 
  Real fd_delta;
 
protected:
 
  std::map<std::string, std::map<subdomain_id_type, Number>> _parameter_independent_data;
 
  std::set<boundary_id_type> _parametrized_function_boundary_ids;
 
  bool _is_nodal_boundary;
 
  std::unordered_map<std::string, std::set<dof_id_type>> _rb_property_map;
};
 
}
 
#endif // LIBMESH_RB_PARAMETRIZED_FUNCTION_H