system_management.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: system_management.h
// - Description: This class manages systems of equations
// - Developers: Valentin N. Zingan,    University of Alberta
//               Marc Secanell Gallart, University of Alberta
//
// ----------------------------------------------------------------------------

#ifndef _FCST_FUELCELL_SYSTEM_MANAGEMENT_H_
#define _FCST_FUELCELL_SYSTEM_MANAGEMENT_H_
//-- dealII 
#include <deal.II/base/parameter_handler.h>

//-- OpenFCST
#include <application_core/matrix_block.h>
#include <application_core/mesh_loop_info_objects.h>
#include <utils/logging.h>

//-- boost libraries
#include <boost/algorithm/string/join.hpp>

using namespace dealii;
using namespace FuelCell::ApplicationCore;

typedef std::map<   std::string , std::map<std::string, DoFTools::Coupling>   > couplings_map;

enum VariableNames
{
    nothing = 0,
    
    oxygen_molar_fraction,
    water_molar_fraction,
    hydrogen_molar_fraction,
    nitrogen_molar_fraction,
    protonic_electrical_potential,
    electronic_electrical_potential,
    membrane_water_content,
    temperature_of_solid_phase,
    temperature_of_fluid_phase,
    temperature_of_REV,
    liquid_water_saturation,
    capillary_pressure,
    
    current_density,
    CL_effectiveness,
    
    OH_coverage,
    O_coverage,
    
    oxygen_concentration,
    water_concentration,
    hydrogen_concentration,
    nitrogen_concentration,
    proton_concentration,
    
    total_pressure,
    
    density_species_1,
    velocity_species_1_X,
    velocity_species_1_Y,
    velocity_species_1_Z,
    
    density_species_2,
    velocity_species_2_X,
    velocity_species_2_Y,
    velocity_species_2_Z,
    
    density_species_3,
    velocity_species_3_X,
    velocity_species_3_Y,
    velocity_species_3_Z,
    
    density_species_4,
    velocity_species_4_X,
    velocity_species_4_Y,
    velocity_species_4_Z,
    
    density_species_5,
    velocity_species_5_X,
    velocity_species_5_Y,
    velocity_species_5_Z,
    
    single_fluid_pressure,
    single_fluid_velocity_X,
    single_fluid_velocity_Y,
    single_fluid_velocity_Z
};


namespace FuelCell
{
    namespace ApplicationCore
    {
        enum SolverName 
        {
            noSolver = 0,
            LINEAR, 
            NEWTON, 
            PICARD
        };
    }
}

enum ReactionNames{
    noReaction = 0,
    
    ORR,
    HOR
};


namespace FuelCell
{
    
class SystemManagement : public Subscriptor
{
public:



  SystemManagement();

  SystemManagement(FuelCell::ApplicationCore::BlockInfo& block_info,
                   Table<2, DoFTools::Coupling>&     cell_couplings,
                   Table<2, DoFTools::Coupling>&     flux_couplings);

 ~SystemManagement();

  void initialize(FuelCell::ApplicationCore::BlockInfo& rblock_info,
                  Table<2, DoFTools::Coupling>&     rcell_couplings,
                  Table<2, DoFTools::Coupling>&     rflux_couplings)
  {
    block_info     = &rblock_info;
    cell_couplings = &rcell_couplings;
    flux_couplings = &rflux_couplings;
  }

  void declare_parameters(ParameterHandler& param) const;

  void initialize(ParameterHandler& param);



// The # and ## preprocessor operators are available in C++ and ANSI/ISO C.
// The # operator causes a replacement-text token to be converted to a string surrounded by quotes.
const std::string& get_VariableNames(const VariableNames value)
{
    static std::map<VariableNames, std::string> VariableNames_strings;
    if (VariableNames_strings.size() == 0){
#define INSERT_ELEMENT(p) VariableNames_strings[p] = #p
        INSERT_ELEMENT(oxygen_molar_fraction);
        INSERT_ELEMENT(water_molar_fraction);
        INSERT_ELEMENT(hydrogen_molar_fraction);
#undef INSERT_ELEMENT
    }

    return VariableNames_strings[value];
}
  const bool solution_in_userlist(const std::string& name) const;

  const unsigned int solution_name_to_index(const std::string& name) const;

  //const unsigned int solution_name_to_index(const VariableNames) const;

  const unsigned int equation_name_to_index(const std::string& name) const;

  const unsigned int matrix_block_index(const std::string& equation_name,
                                        const std::string& solution_name) const;
  
  inline bool matrix_block_index_exists(const std::string& equation_name,
                                        const std::string& solution_name) const
  {     
      const unsigned int line   = this->equation_name_to_index(equation_name);
      const unsigned int column = this->solution_name_to_index(solution_name);
      
      bool value = false;
      if ( (*cell_couplings)(line,column) != 0 )
          value = true;
      
      return value;
   }

  void make_cell_couplings(const std::vector<couplings_map>& src);

  void make_flux_couplings(const std::vector<couplings_map>& src);




  const std::vector<std::string>& get_all_solution_names() const
  {
    return all_solution_names;
  }

  const std::vector<std::string>& get_all_equation_names() const
  {
    return all_equation_names;
  }

  const std::vector<std::string>& get_solution_names() const
  {
    return solution_names;
  }

  const std::vector<std::string>& get_equation_names() const
  {
    return equation_names;
  }

  const unsigned int& get_number_of_solution_names() const
  {
    return n_solution_names;
  }

  void print_system_info() const;




  DeclException2(VariableNotFoundInFCSTVariables,
                 std::string,
                 std::string,
                 << "A "  << arg1 << " with name \"" << arg2 << "\" is not stored in available FCST solution variables");

  DeclException2(EquationNotFoundInFCSTEquations,
                 std::string,
                 std::string,
                 << "An " << arg1 << " with name \"" << arg2 << "\" is not stored in available FCST equations");

  DeclException2(VariableNotFoundInUserVariables,
                 std::string,
                 std::string,
                 << "A "  << arg1 << " with name \"" << arg2 << "\" is not stored in user defined solution variables");

  DeclException2(EquationNotFoundInUserEquations,
                 std::string,
                 std::string,
                 << "An " << arg1 << " with name \"" << arg2 << "\" is not stored in user defined equations");

  DeclException5(SystemMatrixBlockDoesNotExist,
                 std::string,
                 unsigned int,
                 unsigned int,
                 std::string,
                 std::string,
                 << "A "  << arg1 << " (" << arg2 << "," << arg3 << ") " << "does not exist, because the variable \"" << arg4 << "\" is not coupled with the equation \"" << arg5 << "\"");


  // DATA //



  FuelCell::ApplicationCore::BlockInfo* block_info;

  Table<2, DoFTools::Coupling>* cell_couplings;

  Table<2, DoFTools::Coupling>* flux_couplings;


protected:



  void set_all_solution_names();

  void set_all_equation_names();

  void check_solution_names() const;

  void check_equation_names() const;


  // DATA //



   //std::vector<VariableNames > variable_names;
  std::vector<std::string> all_solution_names;

  std::vector<std::string> all_equation_names;

  std::vector<std::string> solution_names;

  std::vector<std::string> equation_names;

  unsigned int n_solution_names;

  std::map<VariableNames, std::string> VariableNames_strings;

};

} // FuelCell

#endif