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
// - Id: $Id$
//
// ----------------------------------------------------------------------------

#ifndef _FCST_FUELCELL_SYSTEM_MANAGEMENT_H_
#define _FCST_FUELCELL_SYSTEM_MANAGEMENT_H_

#include <base/parameter_handler.h>

#include "matrix_block.h"
#include "mesh_loop_info_objects.h"
#include "logging.h"

#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
};



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;

  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