rb_data_serialization.h

Go to the documentation of this file.

// rbOOmit: An implementation of the Certified Reduced Basis method.
// Copyright (C) 2009, 2010, 2015 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 RB_DATA_SERIALIZATION_H
#define RB_DATA_SERIALIZATION_H
 
#include "libmesh/libmesh_config.h"
#if defined(LIBMESH_HAVE_CAPNPROTO)
 
// C++ includes
#include <string>
 
// libMesh/reduced_basis includes
#include "libmesh/rb_data.capnp.h"
 
// Cap'n'Proto includes
#include "capnp/message.h"
 
namespace libMesh
{
 
// Forward declarations
class RBEvaluation;
class TransientRBEvaluation;
class RBEIMEvaluation;
class RBSCMEvaluation;
class RBParametrized;
class Point;
class Elem;
 
namespace RBDataSerialization
{
 
class RBEvaluationSerialization
{
public:
 
  RBEvaluationSerialization(RBEvaluation & rb_eval);
 
  RBEvaluationSerialization (RBEvaluationSerialization &&) = default;
  RBEvaluationSerialization (const RBEvaluationSerialization &) = default;
  RBEvaluationSerialization & operator= (const RBEvaluationSerialization &) = delete;
  RBEvaluationSerialization & operator= (RBEvaluationSerialization &&) = delete;
  virtual ~RBEvaluationSerialization();
 
  void write_to_file(const std::string & path, bool use_packing = false);
 
private:
 
  RBEvaluation & _rb_eval;
};
 
 
 
class TransientRBEvaluationSerialization
{
public:
 
  TransientRBEvaluationSerialization(TransientRBEvaluation & rb_eval);
 
  TransientRBEvaluationSerialization (TransientRBEvaluationSerialization &&) = default;
  TransientRBEvaluationSerialization (const TransientRBEvaluationSerialization &) = default;
  TransientRBEvaluationSerialization & operator= (const TransientRBEvaluationSerialization &) = delete;
  TransientRBEvaluationSerialization & operator= (TransientRBEvaluationSerialization &&) = delete;
  virtual ~TransientRBEvaluationSerialization();
 
  void write_to_file(const std::string & path, bool use_packing = false);
 
private:
 
  TransientRBEvaluation & _trans_rb_eval;
};
 
 
 
class RBEIMEvaluationSerialization
{
public:
 
  RBEIMEvaluationSerialization(RBEIMEvaluation & rb_eval);
 
  RBEIMEvaluationSerialization (RBEIMEvaluationSerialization &&) = default;
  RBEIMEvaluationSerialization (const RBEIMEvaluationSerialization &) = default;
  RBEIMEvaluationSerialization & operator= (const RBEIMEvaluationSerialization &) = delete;
  RBEIMEvaluationSerialization & operator= (RBEIMEvaluationSerialization &&) = delete;
  virtual ~RBEIMEvaluationSerialization();
 
  void write_to_file(const std::string & path, bool use_packing = false);
 
private:
 
  RBEIMEvaluation & _rb_eim_eval;
};
 
 
 
// RBSCMEvaluation should only be available
// if SLEPc and GLPK support is enabled.
#if defined(LIBMESH_HAVE_SLEPC) && (LIBMESH_HAVE_GLPK)
 
class RBSCMEvaluationSerialization
{
public:
 
  RBSCMEvaluationSerialization(RBSCMEvaluation & rb_eval);
 
  RBSCMEvaluationSerialization (RBSCMEvaluationSerialization &&) = default;
  RBSCMEvaluationSerialization (const RBSCMEvaluationSerialization &) = default;
  RBSCMEvaluationSerialization & operator= (const RBSCMEvaluationSerialization &) = delete;
  RBSCMEvaluationSerialization & operator= (RBSCMEvaluationSerialization &&) = delete;
  virtual ~RBSCMEvaluationSerialization();
 
  void write_to_file(const std::string & path, bool use_packing = false);
 
private:
 
  RBSCMEvaluation & _rb_scm_eval;
};
 
#endif // LIBMESH_HAVE_SLEPC && LIBMESH_HAVE_GLPK
 
 
 
 
void add_parameter_ranges_to_builder(const RBParametrized & rb_evaluation,
                                     RBData::ParameterRanges::Builder & parameter_ranges,
                                     RBData::DiscreteParameterList::Builder & discrete_parameters_list);
 
template <typename RBEvaluationBuilderNumber>
void add_rb_evaluation_data_to_builder(RBEvaluation & rb_eval,
                                       RBEvaluationBuilderNumber & rb_eval_builder);
 
template <typename RBEvaluationBuilderNumber, typename TransRBEvaluationBuilderNumber>
void add_transient_rb_evaluation_data_to_builder(TransientRBEvaluation & trans_rb_eval,
                                                 RBEvaluationBuilderNumber & rb_eval_builder,
                                                 TransRBEvaluationBuilderNumber & trans_rb_eval_builder);
 
template <typename RBEIMEvaluationBuilderNumber>
void add_rb_eim_evaluation_data_to_builder(RBEIMEvaluation & rb_eim_eval,
                                           RBEIMEvaluationBuilderNumber & rb_eim_eval_builder);
 
#if defined(LIBMESH_HAVE_SLEPC) && (LIBMESH_HAVE_GLPK)
void add_rb_scm_evaluation_data_to_builder(RBSCMEvaluation & rb_scm_eval,
                                           RBData::RBSCMEvaluation::Builder & rb_scm_eval_builder);
#endif // LIBMESH_HAVE_SLEPC && LIBMESH_HAVE_GLPK
 
void add_point_to_builder(const Point & point,
                          RBData::Point3D::Builder point_builder);
 
} // namespace RBDataSerialization
 
} // namespace libMesh
 
#endif // #if defined(LIBMESH_HAVE_CAPNPROTO)
 
#endif // RB_DATA_SERIALIZATION_H