app_read_mesh.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
//
//    FCST: Fuel Cell Simulation Toolbox
//
//    Copyright (C) 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: app_read_mesh.cc
//    - Description:
//    - Developers: ?????????
//    - $Id: app_read_mesh.h 2605 2014-08-15 03:36:44Z secanell $
//
//---------------------------------------------------------------------------

#ifndef _FUELCELL__APP_READ_MESH__H
#define _FUELCELL__APP_READ_MESH__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/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 "fe/fe_values.h"

#include "numerics/vector_tools.h"
#include "numerics/matrix_tools.h"
#include "numerics/error_estimator.h"
#include "base/data_out_base.h"
#include "numerics/data_out.h"
#include "boost/shared_ptr.hpp"

// Include appframe classes
#include "block_matrix_application.h"

// Include FuelCell classes
#include "optimization_block_matrix_application.h"
#include "geometries.h"

//Include STL
#include "fstream"
#include "iostream"
#include "sstream"
#include <algorithm>

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

namespace FuelCell
{
namespace InitialSolution
{
template <int dim>
//class InitialSolution
class AppReadMeshIC
            :
            public Function<dim>
{
public:
    AppReadMeshIC (std::vector<std::string> );
    ~AppReadMeshIC ();
    void vector_value ( const Point<dim> &p,
                        Vector<double> &v ) const;

    double value (const Point<dim> &/*p*/, const unsigned int) const;

    void set_solution_names ( std::vector<std::string> names )
    {
        component_names = names;
    }

private:

    std::vector<std::string> component_names;
};
} //end namespace InitialSolution


namespace Application
{
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
template <int dim>
class AppReadMesh
            :
            public FuelCell::ApplicationCore::OptimizationBlockMatrixApplication<dim>
{
public:

    AppReadMesh ( boost::shared_ptr<FuelCell::ApplicationCore::ApplicationData> data =
                     boost::shared_ptr<FuelCell::ApplicationCore::ApplicationData> () );

    ~AppReadMesh();
    virtual void declare_parameters ( ParameterHandler& param );

    void _initialize ( ParameterHandler& param );

    virtual void initialize ( ParameterHandler& param );
    
    virtual void initialize_solution (FuelCell::ApplicationCore::FEVector& initial_guess,
                                      std::shared_ptr<Function<dim> > initial_function = std::shared_ptr<Function<dim> >());

    void cell_residual ( FuelCell::ApplicationCore::FEVector&,
                                 const typename DoFApplication<dim>::CellInfo& )
         {}

    void cell_responses ( std::vector<double>& ,
                                  const typename DoFApplication<dim>::CellInfo&,
                                  const FuelCell::ApplicationCore::FEVector& )
         {}

    void global_responses ( std::vector<double>&,
                                    const FuelCell::ApplicationCore::FEVector& )
         {}


    virtual void data_out ( const std::string &basename,
                            const FuelCell::ApplicationCore::FEVectors &src );

    virtual void solve(FEVector& dst, const FEVectors& src){
        //Do nothing
    }

protected:
    std::vector<std::string> equation_names;
    std::vector<std::string> component_names;

        std::vector<std::string> design_var;

        std::vector<double> design_var_value;

};

}
}

#endif