simulation_selector.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// FCST: Fuel Cell Simulation Toolbox
//
// Copyright (C) 2006-2015 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: simulation_selector.h
// - Description: This class selects an openFCST application which will run
// - Developers: P. Dobson,
//               M. Secanell,
//               A. Koupaei,
//               V. Zingan,
//               M. Bhaiya
// - Id: $Id$
//
// ----------------------------------------------------------------------------

#ifndef _SIMULATION_SELECTOR_H_
#define _SIMULATION_SELECTOR_H_

#include <string>
#include <iostream>

#include <boost/shared_ptr.hpp>

#include "optimization_block_matrix_application.h"
#include "adaptive_refinement.h"

#include "newton_basic.h"
#include "newton_w_line_search.h"
#include "newton_w_3pp.h"

// FUEL CELL APPLICATIONS WITH DIFFUSION-FICKS-BASED TRANSPORT //

#include "app_cathode.h"
#include "app_pemfc.h"
#include "app_pemfc_nonisothermal.h"
#include "app_thermal_test.h"
#include "app_test.h"
#include "app_diffusion.h"
#include "app_ohmic.h"

// OTHER APPLICATIONS //

#include "app_read_mesh.h"

using namespace boost;

template<int dim>
class SimulationSelector
{
public:

       SimulationSelector();

      ~SimulationSelector();

       void declare_parameters(ParameterHandler& param) const;

       void initialize(ParameterHandler& param);

       boost::shared_ptr< FuelCell::ApplicationCore::OptimizationBlockMatrixApplication<dim> > select_application();

       boost::shared_ptr< FuelCell::ApplicationCore::ApplicationWrapper > select_solver(FuelCell::ApplicationCore::OptimizationBlockMatrixApplication<dim>* app_lin);

       boost::shared_ptr< FuelCell::ApplicationCore::AdaptiveRefinement<dim> > select_solver_method(FuelCell::ApplicationCore::OptimizationBlockMatrixApplication<dim>* app_lin,
                                                                                                    FuelCell::ApplicationCore::ApplicationWrapper*                      newton_solver,
                                                                                                    const FuelCell::ApplicationCore::FEVector&                          solution = FuelCell::ApplicationCore::FEVector());

protected:

       const std::string get_simulator_names() const
       {
              std::stringstream result;

              result << "cathode"
                     << " | "
                     << "cathode_MPL"
                     << " | "
                     << "cathodeNIT"
                     << " | "
                     << "MEA"
                     << " | "
                     << "meaNIT"
                     << " | "
                     << "test"
                     << " | "
                     << "thermalTest"
                     << " | "
                     << "test_mesh"
                     << " | "
                     << "diffusion"
                     << " | "
                     << "ohmic";

              return result.str();
       }

       const std::string get_simulator_specifications() const
       {
              std::stringstream result;

              result << "Poiseuille"
                     << " | "
                     << "Couette"
                     << " | "
                     << "lid_driven_cavity_flow"
                     << " | "
                     << "backward_step"
                     << " | "
                     << "serpentine_incomp"
                     << " | "
                     << "square"
                     << " | "
                     << "sphere"
                     << " | "
                     << "DarcyCTest_incomp"
                     << " | "
                     << "ThInPlane_incomp"
                     << " | "
                     << "pore_network_incomp"
                     << " | "
                     << "serpentine_comp"
                     << " | "
                     << "DarcyCTest_comp"
                     << " | "
                     << "ThInPlane_comp"
                     << " | "
                     << "pore_network_comp"
                     << " | "
                     << "StefanTube"
                     << " | "
                     << "KerkhofGeboersTest_1"
                     << " | "
                     << "KerkhofGeboersTest_2"
                     << " | "
                     << "cathode_KG_2G"
                     << " | "
                     << "cathode_KG_3G"
                     << " | "
                     << "cathode_ch_KG_2G"
                     << " | "
                     << "cathode_ch_KG_3G";

              return result.str();
       }

       const std::string get_solver_names() const
       {
              std::stringstream result;

              result << "Linear"
                     << " | "
                     << "NewtonBasic"
                     << " | "
                     << "NewtonLineSearch"
                     << " | "
                     << "Newton3pp";

              return result.str();
       }

       const std::string get_solver_methods() const
       {
              std::stringstream result;

              result << "AdaptiveRefinement";

              return result.str();
       }

       // DATA //

       std::string name_application;

       std::string app_specification;

       std::string name_solver;

       std::string name_solve_method;
};

#endif