equation_base.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// FCST: Fuel Cell Simulation Toolbox
//
// Copyright (C) 2006-2013 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: equation_base.h
// - Description: This is a base class for all available FCST equations
// - Developers: Valentin N. Zingan,    University of Alberta
//               Marc Secanell Gallart, University of Alberta
// - Id: $Id: equation_base.h 1384 2013-08-22 21:40:07Z zingan $
//
// ----------------------------------------------------------------------------

#ifndef _FCST_FUELCELLSHOP_EQUATION_EQUATION_BASE_H_
#define _FCST_FUELCELLSHOP_EQUATION_EQUATION_BASE_H_

#include "system_management.h"
#include "initial_and_boundary_data.h"
#include "base_layer.h"
#include "fem_extras.h"
#include "fcst_utilities.h"
#include "fcst_constants.h"

using namespace dealii;
using namespace AppFrame;

namespace FuelCellShop
{
namespace Equation
{



  struct BoundaryType
  {
    std::string  boundary_name;

    unsigned int boundary_id;

    std::string  boundary_condition;
  };

  struct OutputType
  {
    std::string variable_name;

    std::string variable_interpretation;
  };

  // ############################################################################################## Bhaiya #######

  struct VariableInfo
  {
    unsigned int solution_index;

    unsigned int block_index;

    unsigned int fetype_index;

    bool indices_exist;
  };

  // ############################################################################################## Bhaiya #######




  // ############################################################################################## Bhaiya #######

  DeclException2(VariableShouldExistForEquation,
                 std::string,
                 std::string,
                 << "The user-defined variable with name \"" << arg1 << "\" should be one of the solution variables for equation with name \"" << arg2 << "\"");

  DeclException2(IndexDoNotMatch,
                 std::string,
                 std::string,
                 << "The index of variable \"" << arg1 << "\" do not match with the index of equation \"" << arg2 << "\"");

  // ############################################################################################## Bhaiya #######


template<int dim>
class EquationBase : public Subscriptor
{
public:



  virtual void assemble_cell_matrix(AppFrame::MatrixVector&                                 cell_matrices,
                                    const typename AppFrame::DoFApplication<dim>::CellInfo& cell_info,
                                    FuelCellShop::Layer::BaseLayer<dim>* const              layer)
  {
    print_caller_name(__FUNCTION__);
  }

  virtual void assemble_cell_residual(AppFrame::FEVector&                                     cell_residual,
                                      const typename AppFrame::DoFApplication<dim>::CellInfo& cell_info,
                                      FuelCellShop::Layer::BaseLayer<dim>* const              layer)
  {
    print_caller_name(__FUNCTION__);
  }

  virtual void assemble_bdry_matrix(AppFrame::MatrixVector&                                 bdry_matrices,
                                    const typename AppFrame::DoFApplication<dim>::FaceInfo& bdry_info,
                                    FuelCellShop::Layer::BaseLayer<dim>* const              layer)
  {
    print_caller_name(__FUNCTION__);
  }

  virtual void assemble_bdry_residual(AppFrame::FEVector&                                     bdry_residual,
                                      const typename AppFrame::DoFApplication<dim>::FaceInfo& bdry_info,
                                      FuelCellShop::Layer::BaseLayer<dim>* const              layer)
  {
    print_caller_name(__FUNCTION__);
  }




  const couplings_map& get_internal_cell_couplings() const
  {
    AssertThrow( !internal_cell_couplings.empty() , ExcInternalError() );
    return internal_cell_couplings;
  }

  const couplings_map& get_internal_flux_couplings() const
  {
    AssertThrow( !internal_flux_couplings.empty() , ExcInternalError() );
    return internal_flux_couplings;
  }

  const component_materialID_value_map& get_component_materialID_value() const
  {
    AssertThrow( !component_materialID_value.empty() , ExcInternalError() );
    return component_materialID_value;
  }

  const component_boundaryID_value_map& get_component_boundaryID_value() const
  {
    AssertThrow( !component_boundaryID_value.empty() , ExcInternalError() );
    return component_boundaryID_value;
  }

  const std::vector< BoundaryType >& get_boundary_types() const
  {
    return boundary_types;
  }

  const std::vector< std::vector< BoundaryType > >& get_multi_boundary_types() const
  {
    return multi_boundary_types;
  }

  const std::vector< OutputType >& get_output_types() const
  {
    return output_types;
  }

  const std::vector< std::vector< OutputType > >& get_multi_output_types() const
  {
    return multi_output_types;
  }

  const std::string& get_equation_name() const
  {
    return equation_name;
  }

  const std::vector<unsigned int>& get_matrix_block_indices() const
  {
    return matrix_block_indices;
  }

  const std::vector<unsigned int>& get_residual_indices() const
  {
    return residual_indices;
  }

  virtual void print_equation_info() const
  {
    print_caller_name(__FUNCTION__);
  }


protected:



  EquationBase(FuelCell::SystemManagement& system_management);

  virtual ~EquationBase();

  virtual void declare_parameters(ParameterHandler& param) const
  {
    print_caller_name(__FUNCTION__);
  }

  virtual void initialize(ParameterHandler& param)
  {
    print_caller_name(__FUNCTION__);
  }




  virtual void make_assemblers_generic_constant_data()
  {
    print_caller_name(__FUNCTION__);
  }

  virtual void make_assemblers_cell_constant_data(const typename AppFrame::DoFApplication<dim>::CellInfo& cell_info)
  {
    print_caller_name(__FUNCTION__);
  }

  virtual void make_assemblers_bdry_constant_data(const typename AppFrame::DoFApplication<dim>::FaceInfo& bdry_info)
  {
    print_caller_name(__FUNCTION__);
  }

  virtual void make_assemblers_cell_variable_data(const typename AppFrame::DoFApplication<dim>::CellInfo& cell_info,
                                                  FuelCellShop::Layer::BaseLayer<dim>* const              layer)
  {
    print_caller_name(__FUNCTION__);
  }

  virtual void make_assemblers_bdry_variable_data(const typename AppFrame::DoFApplication<dim>::FaceInfo& bdry_info,
                                                  FuelCellShop::Layer::BaseLayer<dim>* const              layer)
  {
    print_caller_name(__FUNCTION__);
  }




  virtual void make_internal_cell_couplings()
  {
    print_caller_name(__FUNCTION__);
  }

  virtual void make_internal_flux_couplings()
  {
    print_caller_name(__FUNCTION__);
  }

  virtual void make_component_materialID_value()
  {
    print_caller_name(__FUNCTION__);
  }

  virtual void make_component_boundaryID_value()
  {
    print_caller_name(__FUNCTION__);
  }

  virtual void make_boundary_types()
  {
    print_caller_name(__FUNCTION__);
  }

  virtual void make_multi_boundary_types()
  {
    print_caller_name(__FUNCTION__);
  }

  virtual void make_output_types()
  {
    print_caller_name(__FUNCTION__);
  }

  virtual void make_multi_output_types()
  {
    print_caller_name(__FUNCTION__);
  }

  virtual void make_matrix_block_indices()
  {
    print_caller_name(__FUNCTION__);
  }

  virtual void make_residual_indices()
  {
    print_caller_name(__FUNCTION__);
  }




  void standard_to_block_wise(FullMatrix<double>& target) const;

  void standard_to_block_wise(Vector<double>& target) const;

  void dealII_to_appframe(AppFrame::MatrixVector&          dst,
                          const FullMatrix<double>&        src,
                          const std::vector<unsigned int>& matrix_block_indices) const;

  void dealII_to_appframe(AppFrame::FEVector&              dst,
                          const Vector<double>&            src,
                          const std::vector<unsigned int>& residual_indices) const;




  bool belongs_to_boundary(const unsigned int& tria_boundary_id,
                           const unsigned int& param_boundary_id) const
  {
    return tria_boundary_id == param_boundary_id;
  }




  void print_caller_name(const std::string& caller_name) const;


  // DATA //



  unsigned int dofs_per_cell;




  unsigned int n_q_points_cell;




  unsigned int n_q_points_bdry;




  typename DoFHandler<dim>::active_cell_iterator cell;

  typename DoFHandler<dim>::active_face_iterator bdry;










  std::vector<double> JxW_cell;










  std::vector<double> JxW_bdry;

  std::vector< Point<dim> > normal_vectors;

  std::vector< std::vector< Point<dim> > > tangential_vectors;




  FuelCell::SystemManagement* system_management;

  couplings_map internal_cell_couplings;

  couplings_map internal_flux_couplings;

  component_materialID_value_map component_materialID_value;

  component_boundaryID_value_map component_boundaryID_value;

  std::vector< BoundaryType > boundary_types;

  std::vector< std::vector< BoundaryType > > multi_boundary_types;

  std::vector< OutputType > output_types;

  std::vector< std::vector< OutputType > > multi_output_types;

  std::string equation_name;

  std::vector<unsigned int> matrix_block_indices;

  std::vector<unsigned int> residual_indices;

  std::vector<bool> counter;


};

} // Equation

} // FuelCellShop

#endif