app_incompressible_flows.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: app_incompressible_flows.h
// - Description: This class deals with steady-state incompressible and isothermal Navier-Stokes
//                fluid transport applications for a single-phase single-component case
//
//              - Poiseuille             - Poiseuille flow                                   (channel)                - test
//              - Couette                - Couette flow                                      (channel)                - test
//              - lid_driven_cavity_flow - lid driven cavity flow                            (channel)                - test
//              - backward_step          - flow over backward facing step                    (channel)                - test
//              - serpentine_incomp      - serpentine flow                                   (channel + porous layer) - experiment
//              - square                 - flow over square                                  (channel)                - test
//              - sphere                 - flow over sphere                                  (channel)                - test
//              - DarcyCTest_incomp      - Darcy equation convergence test                   (          porous layer) - test
//              - ThInPlane_incomp       - through-plane & in-plane permeability experiments (channel + porous layer) - experiment
//              - pore_network_incomp    - pore network flow                                 (channel)                - study
//
// - Developers: Valentin N. Zingan, University of Alberta
// - Id: $Id$
//
// ------------------------------------------------------------------------------------------------------------------------------

#ifndef _FCST_APPLICATION_APP_INCOMPRESSIBLE_FLOWS_H_
#define _FCST_APPLICATION_APP_INCOMPRESSIBLE_FLOWS_H_
//-- dealII
#include <deal.II/base/function_parser.h>
//-- OpenFCST
#include <application_core/optimization_block_matrix_application.h>
#include <equations/incompressible_single_component_NS_equations.h>

using namespace dealii;
using namespace FuelCell::ApplicationCore;

namespace FuelCell
{
    namespace InitialAndBoundaryData
    {
        template<int dim>
        class InitialDataAppIncompressibleFlows : public InitialOrBoundaryDataBase<dim>
        {
            public:



                InitialDataAppIncompressibleFlows(boost::shared_ptr<ApplicationData> data,
                                                    const unsigned int                 n_components = 1);

                ~InitialDataAppIncompressibleFlows();


            protected:



                virtual double math_expression(const Point<dim>&  point,
                                                const unsigned int no_component = 0) const;


        };

        template<int dim>
        class ExactSolutionAppIncompressibleFlows : public InitialOrBoundaryDataBase<dim>
        {
            public:



                ExactSolutionAppIncompressibleFlows(boost::shared_ptr<ApplicationData> data,
                                                    const unsigned int                 n_components = 1);

                ~ExactSolutionAppIncompressibleFlows();


            protected:



                virtual double math_expression(const Point<dim>&  point,
                                                const unsigned int no_component = 0) const;


        };

    } // InitialAndBoundaryData

} // FuelCell

namespace FuelCell
{
    namespace Application
    {

        template<int dim>
        class AppIncompressibleFlows : public OptimizationBlockMatrixApplication<dim>
        {
            public:



                AppIncompressibleFlows( boost::shared_ptr<ApplicationData> data = boost::shared_ptr<ApplicationData>() );

                ~AppIncompressibleFlows();

                virtual void declare_parameters(ParameterHandler& param);

                virtual void initialize(ParameterHandler& param);

                virtual void initialize_solution(FEVector&                        initial_guess,
                                                std::shared_ptr< Function<dim> > function = std::shared_ptr< Function<dim> >());




                virtual void cell_matrix(MatrixVector&                                 cell_matrices,
                                        const typename DoFApplication<dim>::CellInfo& cell_info);

                virtual void cell_residual(FEVector&                                     cell_res,
                                            const typename DoFApplication<dim>::CellInfo& cell_info);

                virtual void bdry_matrix(MatrixVector&                                 bdry_matrices,
                                        const typename DoFApplication<dim>::FaceInfo& bdry_info);

                virtual void bdry_residual(FEVector&                                     bdry_res,
                                            const typename DoFApplication<dim>::FaceInfo& bdry_info);




                virtual void dirichlet_bc(std::map<unsigned int, double>& boundary_values) const;




                virtual void data_out(const std::string& filename,
                                        const FEVectors&   src);

                virtual void compute_L1_L2_error_and_convergence_rate(const FEVector&                  solution,
                                                                        const unsigned int&              refinement_cycle,
                                                                        std::vector< ConvergenceTable >& convergence_tables) const;


            protected:



                void make_variable_initial_data(FEVector& initial_guess);

                void make_variable_boundary_data(FEVector& initial_guess);




                FuelCellShop::Equation::IncompressibleSingleComponentNSEquations<dim> fluid_transport_equations;

                FuelCellShop::Material::ExperimentalFluid fluid;

                FuelCellShop::Material::ExperimentalSolid solid;

                FuelCellShop::Layer::Channel<dim> channel;

                FuelCellShop::Layer::ExperimentalPorousLayer<dim> porous_layer;

                std::string app_specification;


        };

    } // Application

} // FuelCell

#endif