application_data.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// FCST: Fuel Cell Simulation Toolbox
//
// Copyright (C) 2006-2009 by Guido Kanschat
// 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: application_data.h
// - Description: This class implements general data of applications
// - Developers: Guido Kanschat,     Texas A&M University
//               Valentin N. Zingan, University of Alberta
//               Marc Secanell,      University of Alberta
//               Mayank Sabharwal,   University of Alberta
//               Aslan Kosakian,     University of Alberta
//
// ----------------------------------------------------------------------------

#ifndef _FUEL_CELL_APPLICATION_CORE_APPLICATION_DATA_H_
#define _FUEL_CELL_APPLICATION_CORE_APPLICATION_DATA_H_
//-- dealII
#include <deal.II/lac/vector_memory.h>
#include <deal.II/lac/block_vector.h>
#include <deal.II/base/parameter_handler.h>

//-- OpenFCST
#include <utils/logging.h>

//-- C++ Standard libraries
#include <algorithm>
#include <fstream>


using namespace dealii;

namespace FuelCell
{
namespace ApplicationCore
{

typedef BlockVector<double> FEVector;

enum class LinearSolver {UMFPACK,CG,ILU_GMRES,MUMPS,BICGSTAB};

enum class NonLinearSolver {NONE,NEWTONBASIC,NEWTON3PP,NEWTONLINESEARCH,PICARD};

enum class RefinementSolver {ADAPTIVE};

class ApplicationData
{
    
public:
    ApplicationData();
    
    ~ApplicationData();
    
    void declare_parameters(ParameterHandler& param) const;
    
    void initialize(ParameterHandler& param);
    
    
    void enter_flag(std::string name,
                    const bool& s);
    
    void enter(std::string   name,
               const double& s);
    
    void enter(std::string     name,
               const FEVector& v);
    
    void enter(std::string                name,
               const std::vector<double>& v);
    
    void enter(std::string                name,
               const std::vector< std::vector<double> >& v);    
    
    void erase_flag(std::string name);
    
    void erase_scalar(std::string name);
    
    void erase_vector(std::string name);
    
    void erase_std_vector(std::string name);
    
    void erase_std_vector_of_std_vectors(std::string name);
    
    bool flag_exists(const std::string& name) const;
    
    bool flag(std::string name) const;
    
    const double* scalar(std::string name) const;
    
    const FEVector* vector(std::string name) const;
    
    const std::vector<double>* std_vector(std::string name) const;

    const std::vector< std::vector<double> >* std_vector_std_vector(std::string name) const;
    
    void log() const;
    
    GrowingVectorMemory< Vector<double> > vector_pool;
    
    GrowingVectorMemory<FEVector> block_vector_pool;
    
    FuelCell::ApplicationCore::LinearSolver get_linear_solver()
    {
        return this->lin_solver;
    }
    
    FuelCell::ApplicationCore::NonLinearSolver get_nonlinear_solver()
    {
        return this->nonlin_solver;
    }   
    
    FuelCell::ApplicationCore::RefinementSolver get_refinement_solver()
    {
        return this->refinement_solver;
    }
    
    void set_linear_solver(const std::string name)
    {
        if (name.compare("UMFPACK") == 0)
            this->lin_solver = FuelCell::ApplicationCore::LinearSolver::UMFPACK;
        else if ( name.compare("CG") == 0 )
            this->lin_solver = FuelCell::ApplicationCore::LinearSolver::CG;
        else if ( name.compare("ILU-GMRES") == 0 )
            this->lin_solver = FuelCell::ApplicationCore::LinearSolver::ILU_GMRES;
        else if ( name.compare("MUMPS") == 0 )
            this->lin_solver = FuelCell::ApplicationCore::LinearSolver::MUMPS;
        else if ( name.compare("Bicgstab") == 0)
            this->lin_solver = FuelCell::ApplicationCore::LinearSolver::BICGSTAB;
        else
            throw(ExcNotFound("linear_solver", name));
    }
    
    void set_nonlinear_solver(const std::string name)
    {
        if (name.compare("None") == 0)
            this->nonlin_solver = FuelCell::ApplicationCore::NonLinearSolver::NONE;
        else if ( name.compare("NewtonBasic") == 0 )
            this->nonlin_solver = FuelCell::ApplicationCore::NonLinearSolver::NEWTONBASIC;
        else if ( name.compare("Newton3pp") == 0 )
            this->nonlin_solver = FuelCell::ApplicationCore::NonLinearSolver::NEWTON3PP;
        else if( name.compare("NewtonLineSearch") == 0)
            this->nonlin_solver = FuelCell::ApplicationCore::NonLinearSolver::NEWTONLINESEARCH;
        else if ( name.compare("Picard") == 0 )
            this->nonlin_solver = FuelCell::ApplicationCore::NonLinearSolver::PICARD;
        else
            throw(ExcNotFound("nonlinear_solver", name));
    }
    
    void set_refinement_solver(const std::string name)
    {
        if (name.compare("AdaptiveRefinement") == 0)
            this->refinement_solver = FuelCell::ApplicationCore::RefinementSolver::ADAPTIVE;
        else
            throw(ExcNotFound("refinement_solver", name));
    }
    
    std::string get_solution_vector_name(FuelCell::ApplicationCore::NonLinearSolver in)
    {
        if ((in == FuelCell::ApplicationCore::NonLinearSolver::NEWTONBASIC) || (in == FuelCell::ApplicationCore::NonLinearSolver::NEWTON3PP) || (in == FuelCell::ApplicationCore::NonLinearSolver::NEWTONLINESEARCH))
            return "Newton iterate";
        else if ((in == FuelCell::ApplicationCore::NonLinearSolver::PICARD) || (in == FuelCell::ApplicationCore::NonLinearSolver::NONE))
            return "Solution";         
    }
    
    std::string get_residual_vector_name(FuelCell::ApplicationCore::NonLinearSolver in)
    {
        if ((in == FuelCell::ApplicationCore::NonLinearSolver::NEWTONBASIC) || (in == FuelCell::ApplicationCore::NonLinearSolver::NEWTON3PP) || (in == FuelCell::ApplicationCore::NonLinearSolver::NEWTONLINESEARCH))
            return "Newton residual";
        else if ((in == FuelCell::ApplicationCore::NonLinearSolver::PICARD) || (in == FuelCell::ApplicationCore::NonLinearSolver::NONE))
            return "residual";         
    }
    
    typedef std::map< std::string, bool > flag_map;
    
    typedef std::map< std::string, const double* > scalar_map;
    
    typedef std::map< std::string, const FEVector* > vector_map;
    
    typedef std::map< std::string, const std::vector<double>* > std_vector_map;
    
    typedef std::map< std::string, const std::vector< std::vector<double> >* > std_vector_std_vector_map;
    
    std::map<std::string,std::map<int,double>> field_data;
    
    DeclException2(ExcNotFound,
                   char*,
                   std::string,
                   << "A " << arg1 << " with name " << arg2 << " was not stored in this data object");
    
private:
    
    flag_map named_flags;
    
    scalar_map named_scalars;
    
    vector_map named_vectors;
    
    std_vector_map named_std_vectors;
    
    std_vector_std_vector_map named_std_vectors_of_std_vectors;    
    
    
    
protected:
    
    FuelCell::ApplicationCore::LinearSolver lin_solver;
    
    FuelCell::ApplicationCore::NonLinearSolver nonlin_solver;
    
    FuelCell::ApplicationCore::RefinementSolver refinement_solver;
    
};

} // ApplicationCore

} // FuelCell

#endif