application_base.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// FCST: Fuel Cell Simulation Toolbox
//
// Copyright (C) 2006-2009 by Guido Kanschat
// Copyright (C) 2006-2014 by Energy Systems Design Laboratory, University of Alberta
//
// This software is distributed under the MIT License
// For more information, see the README file in /doc/LICENSE
//
// - Class: application_base.h
// - Description: This class implements the interface of applications
// - Developers: Guido Kanschat,     Texas A&M University
//               Valentin N. Zingan, University of Alberta
//               Marc Secanell,      University of Alberta
//
// ----------------------------------------------------------------------------

#ifndef _FUEL_CELL_APPLICATION_CORE_APPLICATION_BASE_H_
#define _FUEL_CELL_APPLICATION_CORE_APPLICATION_BASE_H_

// openFCST objects:
#include <application_core/application_data.h>
#include <application_core/fe_vectors.h>
#include <application_core/event.h>
#include <utils/logging.h>

// deal.II objects:
#include <deal.II/base/parameter_handler.h>

// C++ objects:
#include <boost/shared_ptr.hpp>

using namespace dealii;

namespace FuelCell
{
    namespace ApplicationCore
    {
        class ApplicationBase : public Subscriptor
        {
        public:
            
            ApplicationBase(boost::shared_ptr<ApplicationData> data = boost::shared_ptr<ApplicationData>());
            
            ApplicationBase(const ApplicationBase& other);
            
            virtual ~ApplicationBase();
            
            virtual void declare_parameters(ParameterHandler& )
            {
                print_caller_name(__FUNCTION__);
            }
            
            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()
            {
                print_caller_name(__FUNCTION__);
            }
            
            virtual void init_vector(FEVector& ) const
            {
                print_caller_name(__FUNCTION__);
            }
            
            virtual void start_vector(FEVector& dst, std::string ) const
            {
                print_caller_name(__FUNCTION__);
                init_vector(dst);
                
            };
            
            virtual double residual(FEVector&               /*dst*/,
                                    const FEVectors&        /*src*/,
                                    bool apply_boundaries = true)
            {
                print_caller_name(__FUNCTION__);
                
                return -1;
            }
            
            virtual void solve(FEVector&        dst,
                               const FEVectors& src) = 0;
            
            virtual void Tsolve(FEVector&        /*dst*/,
                                const FEVectors& /*src*/)
            {
                print_caller_name(__FUNCTION__);
            }
            
            virtual double estimate(const FEVectors& )
            {
                print_caller_name(__FUNCTION__);                
                return -1;
            }
            
            virtual double evaluate(const FEVectors& )
            {
                print_caller_name(__FUNCTION__);
                return -1;
            }
            
            virtual void grid_out(const std::string& )
            {
                print_caller_name(__FUNCTION__);
            }
            
            virtual void data_out(const std::string& filename,
                                  const FEVectors&   src)
            {
                print_caller_name(__FUNCTION__);
            }
            
            boost::shared_ptr<ApplicationData> get_data();
            
            const boost::shared_ptr<ApplicationData> get_data() const;
            
            virtual std::string id() const;
            
            virtual void notify(const Event& reason);
            
            virtual void clear();
            
            virtual void clear_events(); 
            
            virtual unsigned int get_solution_index();
            
        protected:        
            
            void print_caller_name(const std::string& caller_name) const;
            
            boost::shared_ptr<ApplicationData> data;
            
            Event notifications;
            //std::map<std::string, bool> notifications;

            #ifdef OPENFCST_WITH_PETSC

            const unsigned int n_mpi_processes;
            const unsigned int this_mpi_process;
            MPI_Comm mpi_communicator;

            #endif
        };
    
    }// ApplicationCore

} // FuelCell

#endif