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