application_base.h

Go to the documentation of this file.

// ------------------------------------------------------------------
//  $Id: application_base.h 1348 2013-08-16 00:45:07Z secanell $
//
//  Copyright (C) 2006, 2007, 2008, 2009 by Guido Kanschat.
//  Copyright (C) 2012 by Valentin N. Zingan, University of Alberta.
//
//  This file is subject to QPL and may not be  distributed
//  without copyright and license information. Please refer
//  to the file deal.II/doc/license.html for the  text  and
//  further information on this license.
// ------------------------------------------------------------------

#ifndef _DEALII_APPFRAME_APPLICATION_BASE_H_
#define _DEALII_APPFRAME_APPLICATION_BASE_H_

#include <base/parameter_handler.h>

#include <boost/shared_ptr.hpp>

#include <appframe/fe_vectors.h>
#include <appframe/application_data.h>
#include <appframe/event.h>

using namespace dealii;

namespace AppFrame
{

typedef BlockVector<double> FEVector;

// ------------------------------

class ApplicationBase : public Subscriptor
{
public:

  ApplicationBase(boost::shared_ptr<ApplicationData> ex_data = boost::shared_ptr<ApplicationData>());

  ApplicationBase(const ApplicationBase& other);

  virtual ~ApplicationBase() { }

  virtual void declare_parameters(ParameterHandler& param) = 0; // No implementation here

  void print_parameters_to_file(ParameterHandler& param,
                                const std::string& file_name,
                                const ParameterHandler::OutputStyle& style);

  virtual void initialize(ParameterHandler& param) = 0; // No implementation here

  virtual void remesh();

  virtual void init_vector(FEVector& dst) const;

  virtual void start_vector(FEVector& dst,
                            std::string caller) const;

  virtual double residual(FEVector& dst,
                          const FEVectors& src,
                          bool apply_boundaries = true);

  virtual void solve(FEVector& start,
                     const FEVectors& rhs);

  virtual void Tsolve(FEVector& start,
                      const FEVectors& rhs);

  virtual double estimate(const FEVectors& src);

  virtual double evaluate(const FEVectors& src);

  virtual void grid_out(const std::string& filename) const;

  virtual void data_out(const std::string& filename,
                        const FEVectors& src);
  
  virtual void data_out(const std::string& filename,
                        const FEVectors& src,
                                                                const std::vector<std::string> );
  
  boost::shared_ptr<ApplicationData> get_data()             { return data; }

  const boost::shared_ptr<ApplicationData> get_data() const { return data; }

  virtual std::string id() const           { return std::string( typeid(*this).name() ); }

  virtual void notify(const Event& reason) { notifications += reason; }

  virtual void clear()                     { notifications.all(); }

  void clear_events()                      { notifications.clear(); }

protected:

  void print_caller_name(const std::string& caller_name) const;

  boost::shared_ptr<ApplicationData> data;

  Event notifications;
};

// ------------------------------

inline
ApplicationBase::ApplicationBase(boost::shared_ptr<ApplicationData> ex_data)
:
Subscriptor(),
data(ex_data)
{
  deallog << "  Application";
  notifications.all();

  if(!data) //if(data == NULL)
    data = boost::shared_ptr<ApplicationData>(new ApplicationData);
}

inline
ApplicationBase::ApplicationBase(const ApplicationBase& other)
:
Subscriptor(),
data(other.data)
{
  deallog << "Base->";
  notifications.all();
}

inline
void
ApplicationBase::print_parameters_to_file(ParameterHandler& param,
                                          const std::string& file_name,
                                          const ParameterHandler::OutputStyle& style)
{
  std::ofstream file_out;
  file_out.open(file_name.c_str());
  deallog << "Printing parameter handler" << std::endl;
  param.print_parameters(file_out, style);
  file_out.close();
}

inline
void
ApplicationBase::remesh()
{
  print_caller_name(__FUNCTION__);
}

inline
void
ApplicationBase::init_vector(FEVector&) const
{
  print_caller_name(__FUNCTION__);
}

inline
void
ApplicationBase::start_vector(FEVector& dst,
                              std::string) const
{
  print_caller_name(__FUNCTION__);
  init_vector(dst);
}

inline
double
ApplicationBase::residual(FEVector&,
                          const FEVectors&,
                          bool)
{
  print_caller_name(__FUNCTION__);
  return 0.;
}

inline
void
ApplicationBase::solve(FEVector&,
                       const FEVectors&)
{
  print_caller_name(__FUNCTION__);
}

inline
void
ApplicationBase::Tsolve(FEVector&,
                        const FEVectors&)
{
  print_caller_name(__FUNCTION__);
}

inline
double
ApplicationBase::estimate(const FEVectors&)
{
  print_caller_name(__FUNCTION__);
  return 0.;
}

inline
double
ApplicationBase::evaluate(const FEVectors&)
{
  print_caller_name(__FUNCTION__);
  return 0.;
}

inline
void
ApplicationBase::grid_out(const std::string&) const
{
  print_caller_name(__FUNCTION__);
}

inline
void
ApplicationBase::data_out(const std::string&,
                          const FEVectors&)
{
  print_caller_name(__FUNCTION__);
}

inline
void
ApplicationBase::data_out(const std::string&,
                          const FEVectors&,
                                                                  const std::vector<std::string> )
{
  print_caller_name(__FUNCTION__);
}

inline
void
ApplicationBase::print_caller_name(const std::string& caller_name) const
{
  const std::type_info& info = typeid(*this);
  deallog << "Pure function " << caller_name << " called in Class " << info.name() << std::endl;
}

}

#endif