app_laplace.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
//    $Id: app_laplace.h 1417 2013-08-30 16:27:42Z secanell $
//
//    Copyright (C) 2012 by Marc Secanell
//
//    This file is subject to QPL and may not be  distributed
//    without copyright and license information. Please refer
//    to the file deal.II/doc/license.html for the  text  and
//    further information on this license.
//
//---------------------------------------------------------------------------

#ifndef _FUELCELL__APP_LAPLACE__H
#define _FUELCELL__APP_LAPLACE__H

// Include deal.II classes
#include "base/parameter_handler.h"
#include "base/function_lib.h"
#include "base/function.h"
#include "base/quadrature_lib.h"

#include "lac/block_vector.h"
#include "lac/solver_cg.h"
#include "lac/solver_gmres.h"
#include "lac/precondition.h"
#include "lac/precondition_block.h"
#include "lac/block_matrix_array.h"
#include "lac/filtered_matrix.h"
#include "lac/sparse_ilu.h"
#include "lac/sparse_direct.h"

#include "grid/grid_generator.h"
#include "grid/tria_accessor.h"
#include "grid/tria_iterator.h"
#include "grid/tria_boundary_lib.h"
#include "linear_solvers.h"
#include "fe/fe_values.h"

#include "numerics/vector_tools.h"
#include "numerics/matrix_tools.h"
#include "numerics/error_estimator.h"

#include "boost/shared_ptr.hpp"

// Include appframe classes
#include "appframe/base.h"
#include "appframe/block_matrix_application.h"
#include "appframe/matrix_shop_cell.h"
#include "appframe/residual_shop_cell.h"

// Include FuelCell classes
#include "system_management.h"
#include "optimization_block_matrix_application.h"
#include "solver_utils.h"
#include "operating_conditions.h"
#include "dummy_GDL.h"
#include "SGL_24_BA.h"
#include "PureGas.h"
#include "BinaryDiffusion.h"
#include "geometries.h"
#include "homogeneous_CL.h"
#include "platinum.h"
#include "tafel_kinetics.h"
#include "fcst_constants.h"
#include "ideal_gas.h"
#include "ficks_transport_equation.h"
#include "new_ficks_transport_equation.h"

//Include STL
#include "fstream"
#include "iostream"
#include "sstream"

// Use namespace of deal.II
using namespace dealii;

namespace FuelCell
{
  namespace InitialSolution
  {
    template <int dim>
      //class InitialSolution
      class AppLaplaceIC
      :
    public Function<dim>
    {
    public:
      AppLaplaceIC (FuelCell::OperatingConditions* );
      ~AppLaplaceIC ();
       double value (const Point<dim> &p, unsigned int) const;
      void vector_value (const Point<dim> &p, 
                         Vector<double> &v) const;
      
    private:
      FuelCell::OperatingConditions* OC;
     
    };
  } //end namespace InitialSolution
  

namespace Application
{
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  template <int dim>
    class AppLaplace
    :
  public AppFrame::OptimizationBlockMatrixApplication<dim>
  {
  public:
    
    AppLaplace (boost::shared_ptr<AppFrame::ApplicationData> data = 
                            boost::shared_ptr<AppFrame::ApplicationData> ());
    
    ~AppLaplace();
    virtual void declare_parameters(ParameterHandler& param);

    virtual void set_parameters(const std::vector<std::string>& name_dvar,
                                const std::vector<double>& value_dvar,
                                ParameterHandler& param);    
    
    void _initialize(ParameterHandler& param);
    
    virtual void initialize(ParameterHandler& param);
    
    void init_solution(AppFrame::FEVector& src);
    virtual void cell_matrix(MatrixVector& cell_matrices,
                             const typename DoFApplication<dim>::CellInfo& cell);  
    virtual void cell_residual(AppFrame::FEVector& cell_vector,
                               const typename DoFApplication<dim>::CellInfo& cell);

    /*virtual void cell_dresidual_dlambda(std::vector<AppFrame::FEVector >& cell_vector,
                                        const typename DoFApplication<dim>::CellInfo& cell,
                                        std::vector<std::vector<double> >& src)
    {};
    */
    virtual void dirichlet_bc(std::map<unsigned int, double>& boundary_values) const;
    
    virtual void solve(AppFrame::FEVector& start,
                       const AppFrame::FEVectors& rhs);
    
    virtual double estimate(const AppFrame::FEVectors& sol);
    
    /*virtual void check_responses()
    {};
    */
      virtual void cell_responses (std::vector<double>& resp,
                                 const typename DoFApplication<dim>::CellInfo& info,
                                 const AppFrame::FEVector& sol)
    {};
    virtual void global_responses (std::vector<double>& resp,
                                   const AppFrame::FEVector& sol)
    {};
    
    /*virtual void cell_dresponses_dl(std::vector<std::vector<double> >& cell_df_dl,
                                    const typename DoFApplication<dim>::CellInfo& info,
                                    const AppFrame::FEVector& sol)
    {};
    */
    /*virtual void global_dresponses_dl(std::vector<std::vector<double> >& df_dl,
                                      const AppFrame::FEVector& sol)
    {};
    */
    /*virtual void cell_dresponses_du(std::vector<AppFrame::FEVector >& cell_df_du,
                                    const typename DoFApplication<dim>::CellInfo& info,
                                    std::vector<std::vector<double> >& src)
    {};
*/
  /*  virtual void global_dresponses_du(std::vector<AppFrame::FEVector >& df_du,
                                      const AppFrame::FEVector& src)
    {};
*/
    virtual double evaluate (const AppFrame::FEVectors& src);

    /*virtual void data_out(const std::string &basename, 
                          const AppFrame::FEVectors &src);
    */
    
  private:
    FuelCell::SystemManagement system_management;
    boost::shared_ptr< FuelCellShop::Geometry::GridBase<dim> > grid;
    FuelCell::OperatingConditions OC;
    // Create the object that you need to store material and geometry properties
    boost::shared_ptr<FuelCellShop::Layer::GasDiffusionLayer<dim> > CGDL;
    FuelCellShop::Material::Oxygen oxygen;
    FuelCellShop::Material::Nitrogen nitrogen;
    FuelCellShop::Equation::FicksTransportEquation<dim> FicksLaw;
  };
}
}

#endif //_FUELCELL__APP_TEST_H