equation_base.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: equation_base.h
// - Description: This is a base class for all available openFCST equations
// - Developers: Valentin N. Zingan,    University of Alberta
//               Marc Secanell Gallart, University of Alberta
//               Mayank Sabharwal,      University of Alberta
//               Aslan Kosakian,        University of Alberta
//
// ----------------------------------------------------------------------------

#ifndef _FCST_FUELCELLSHOP_EQUATION_EQUATION_BASE_H_
#define _FCST_FUELCELLSHOP_EQUATION_EQUATION_BASE_H_
#include <boost/shared_ptr.hpp>

#include <application_core/system_management.h>
#include <application_core/dof_application.h>
#include <application_core/initial_and_boundary_data.h>
#include <layers/base_layer.h>
#include <utils/fem_extras.h>
#include <utils/fcst_utilities.h>
#include <utils/fcst_constants.h>
#include <equation_auxiliaries.h>
#include <application_core/application_data.h>

using namespace dealii;
using namespace FuelCell::ApplicationCore;

namespace FuelCellShop
{
    namespace Equation
    {
        


        struct EquationFlags 
        {
            bool assemble_generic_data;
            bool assemble_cell_constant_data;
            bool assemble_cell_variable_data_matrix;
        };
        
        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 #######
        
        


        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 << "\"");
        
        template<int dim>
        class EquationBase : public Subscriptor
        {
        public:
            


            virtual void assemble_cell_matrix(FuelCell::ApplicationCore::MatrixVector&                                 cell_matrices,
                                              const typename FuelCell::ApplicationCore::DoFApplication<dim>::CellInfo& cell_info,
                                              FuelCellShop::Layer::BaseLayer<dim>* const              layer);
            
            virtual void assemble_cell_residual(FuelCell::ApplicationCore::FEVector&                                     cell_residual,
                                                const typename FuelCell::ApplicationCore::DoFApplication<dim>::CellInfo& cell_info,
                                                FuelCellShop::Layer::BaseLayer<dim>* const              layer);
            
            virtual void assemble_bdry_matrix(FuelCell::ApplicationCore::MatrixVector&                                 bdry_matrices,
                                              const typename FuelCell::ApplicationCore::DoFApplication<dim>::FaceInfo& bdry_info,
                                              FuelCellShop::Layer::BaseLayer<dim>* const              layer)
            {
                print_caller_name(__FUNCTION__);
            }
            
            
            virtual void assemble_bdry_residual(FuelCell::ApplicationCore::FEVector&                                     bdry_residual,
                                                const typename FuelCell::ApplicationCore::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__);
            }
            
            bool variable_initial_data;
            
            bool variable_boundary_data;
            
        protected:
            

            
            EquationBase(FuelCell::SystemManagement& sys_management,boost::shared_ptr< FuelCell::ApplicationCore::ApplicationData > data = 
            boost::shared_ptr< FuelCell::ApplicationCore::ApplicationData >());
            
            virtual ~EquationBase();
            
            virtual void declare_parameters(ParameterHandler& param) const;
            
            virtual void initialize(ParameterHandler& param);
            
            virtual void set_parameters(const std::vector<std::string>& name_dvar,
                                        const std::vector<double>&      value_dvar,
                                        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 FuelCell::ApplicationCore::DoFApplication<dim>::CellInfo& cell_info)  {
                print_caller_name(__FUNCTION__);
            }
            
            virtual void make_assemblers_bdry_constant_data(const typename FuelCell::ApplicationCore::DoFApplication<dim>::FaceInfo& bdry_info)  {
                print_caller_name(__FUNCTION__);
            }
            
            virtual void make_assemblers_cell_variable_data(const typename FuelCell::ApplicationCore::DoFApplication<dim>::CellInfo& cell_info,
                                                            FuelCellShop::Layer::BaseLayer<dim>* const              layer)
            {
                print_caller_name(__FUNCTION__);
            }
            
            virtual void make_assemblers_bdry_variable_data(const typename FuelCell::ApplicationCore::DoFApplication<dim>::FaceInfo& bdry_info,
                                                            FuelCellShop::Layer::BaseLayer<dim>* const              layer)
            {
                print_caller_name(__FUNCTION__);
            }
            
            inline void select_cell_assemblers(const typename FuelCell::ApplicationCore::DoFApplication<dim>::CellInfo& cell_info,
                                               FuelCellShop::Layer::BaseLayer<dim>* const              layer)
            {
                if ( assemble_flags.assemble_generic_data )
                {
                    make_assemblers_generic_constant_data();
                    assemble_flags.assemble_generic_data = false;
                }
                
                if ( assemble_flags.assemble_cell_constant_data )
                {
                    make_assemblers_cell_constant_data(cell_info);
                    assemble_flags.assemble_cell_constant_data = false;
                }
                
                make_assemblers_cell_variable_data(cell_info, layer);
            }
            


            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__);
            }
            


            virtual void assemble_cell_Jacobian_matrix(FuelCell::ApplicationCore::MatrixVector& cell_matrices,
                                                       const typename FuelCell::ApplicationCore::DoFApplication<dim>::CellInfo& cell_info,
                                                       FuelCellShop::Layer::BaseLayer<dim>* const              layer)   {
                print_caller_name(__FUNCTION__);
            }
            
            virtual void assemble_bdry_Jacobian_matrix(FuelCell::ApplicationCore::MatrixVector&                                 bdry_matrices,
                                                       const typename FuelCell::ApplicationCore::DoFApplication<dim>::FaceInfo& bdry_info,
                                                       FuelCellShop::Layer::BaseLayer<dim>* const              layer)   {
                print_caller_name(__FUNCTION__);
            }
            
            
            virtual void assemble_cell_linear_matrix(FuelCell::ApplicationCore::MatrixVector& cell_matrices,
                                                     const typename FuelCell::ApplicationCore::DoFApplication<dim>::CellInfo& cell_info,
                                                     FuelCellShop::Layer::BaseLayer<dim>* const              layer)   {
                print_caller_name(__FUNCTION__);
            }          
            
            virtual void assemble_cell_residual_rhs(FuelCell::ApplicationCore::FEVector&                                     cell_residual,
                                                    const typename FuelCell::ApplicationCore::DoFApplication<dim>::CellInfo& cell_info,
                                                    FuelCellShop::Layer::BaseLayer<dim>* const              layer)  {
                print_caller_name(__FUNCTION__);
            }
            
            virtual void assemble_cell_linear_rhs(FuelCell::ApplicationCore::FEVector&                                     cell_residual,
                                                  const typename FuelCell::ApplicationCore::DoFApplication<dim>::CellInfo& cell_info,
                                                  FuelCellShop::Layer::BaseLayer<dim>* const              layer)  {
                print_caller_name(__FUNCTION__);
            }
            
            virtual void assemble_bdry_linear_matrix(FuelCell::ApplicationCore::MatrixVector&                                 bdry_matrices,
                                                     const typename FuelCell::ApplicationCore::DoFApplication<dim>::FaceInfo& bdry_info,
                                                     FuelCellShop::Layer::BaseLayer<dim>* const              layer)  {
                print_caller_name(__FUNCTION__);
            }
            
            virtual void assemble_bdry_linear_rhs(FuelCell::ApplicationCore::FEVector&                                     bdry_residual,
                                                  const typename FuelCell::ApplicationCore::DoFApplication<dim>::FaceInfo& bdry_info,
                                                  FuelCellShop::Layer::BaseLayer<dim>* const              layer)   {
                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(FuelCell::ApplicationCore::MatrixVector& dst,
                                    const FullMatrix<double>& src,                                    
                                    const std::vector<unsigned int>& matrix_block_indices) const;

            void dealII_to_appframe(FuelCell::ApplicationCore::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::string name_base_variable;
            
            std::vector<unsigned int> matrix_block_indices;
            
            std::vector<unsigned int> residual_indices;
            
            std::vector<bool> counter;
            EquationFlags assemble_flags;
           
            boost::shared_ptr< FuelCell::ApplicationCore::ApplicationData > data;
            
            std::string solution_vector_name;
            
            std::string residual_vector_name;
            
        };
        
    } // Equation
    
} // FuelCellShop

#endif