dof_application.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// FCST: Fuel Cell Simulation Toolbox
//
// Copyright (C) 2006-2009 by Guido Kanschat
// Copyright (C) 2006-2014 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: dof_application.h
// - Description: This class implements:
//                - triangulation
//                - finite element spaces
//                - dof handler
//                - distribution of dofs over triangulation
//                - residual of nonlinear system of equations
//                - estimations of cell-wise errors for adaptive refinement
//                - and more
// - Developers: Guido Kanschat,     Texas A&M University
//               Valentin N. Zingan, University of Alberta
//               Marc Secanell,      University of Alberta
//               Peter Dobson,       University of Alberta
//
// ----------------------------------------------------------------------------

#ifndef _FUEL_CELL_APPLICATION_CORE_DOF_APPLICATION_H_
#define _FUEL_CELL_APPLICATION_CORE_DOF_APPLICATION_H_

#include <base/parameter_handler.h>
#include <base/data_out_base.h>
#include <base/quadrature_lib.h>

#include <lac/block_indices.h>
#include <lac/constraint_matrix.h>
#include <lac/block_vector.h>

#include <grid/tria.h>
#include <grid/tria_iterator.h>
#include <grid/tria_accessor.h>
#include <grid/grid_refinement.h>
#include <grid/grid_tools.h>
#include <grid/grid_out.h>

#include <multigrid/mg_tools.h>

#include <fe/fe.h>
#include <fe/mapping_q1.h>
#include <fe/mapping_q.h>
#include <fe/fe_tools.h>
#include <fe/fe_values.h>

#include <dofs/dof_handler.h>
#include <dofs/dof_renumbering.h>
#include <dofs/dof_tools.h>

#include <numerics/data_out.h>
#include <numerics/solution_transfer.h>
#include <numerics/error_estimator.h>

#include "application_wrapper.h"
#include "mesh_loop_info_objects.h"
#include "fcst_utilities.h"
#include "initial_and_boundary_data.h"
#include <grid/geometry.h>
#include <grid/geometries.h>

#include <deal.II/lac/petsc_parallel_vector.h>
#include <deal.II/lac/petsc_vector.h>

#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <typeinfo>

using namespace dealii;
using namespace FuelCell::ApplicationCore;

namespace dealii
{
    template<int, int> class Triangulation;
    template<int, int> class Mapping;
    template<int, int> class FiniteElement;
    template<int, int> class DoFHandler;
}

namespace FuelCell
{
    namespace ApplicationCore
    {

        template<int dim>
        class DoFApplication : public ApplicationBase
        {
        public:

            typedef typename FuelCell::ApplicationCore::IntegrationInfo< dim, FEValuesBase<dim> >     CellInfo;

            typedef typename FuelCell::ApplicationCore::IntegrationInfo< dim, FEFaceValuesBase<dim> > FaceInfo;


            DoFApplication(boost::shared_ptr<ApplicationData> data      = boost::shared_ptr<ApplicationData>(),
                           bool                               multigrid = false);

            DoFApplication(bool multigrid);

            DoFApplication(DoFApplication<dim>& dof_app,
                           bool                 triangulation_only,
                           bool                 multigrid = false);

            ~DoFApplication();

            virtual void declare_parameters(ParameterHandler& param);

            virtual void initialize(ParameterHandler& param);

            virtual void remesh_dofs();

            virtual void remesh();

            virtual void init_vector(FEVector& dst) const;

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



            virtual double estimate(const FEVectors& src);

            virtual double evaluate(const FEVectors& src);

            virtual double residual(FEVector&        dst,
                                    const FEVectors& src,
                                    bool             apply_boundaries = true);

            virtual void residual_constraints(FEVector& dst) const;

            #ifdef OPENFCST_WITH_PETSC
            virtual void residual_constraints(PETScWrappers::MPI::Vector& dst, const std::vector<unsigned int>&) const;
            #endif

            void store_triangulation(Triangulation<dim>& new_tr);

            void add_vector_for_transfer(FEVector* src);

            void delete_vector_for_transfer();

            void transfer_solution_to_coarse_mesh(Triangulation<dim>& tr_coarse,
                                                  FEVector&           coarse_solution,
                                                  FEVector&           refined_solution);

            unsigned int memory_consumption() const;


            std::string filename_initial_sol;

            bool output_initial_sol;
            bool read_in_initial_solution;

            bool use_predefined_solution;

            bool output_coarse_solution;



            virtual void grid_out(const std::string& basename);

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

            void print(const std::string&               basename,
                       const FEVector&                  src,
                       const std::vector<unsigned int>& src_indices = std::vector<unsigned int>()) const;


            std::vector< DataComponentInterpretation::DataComponentInterpretation > solution_interpretations;

            std::vector< DataComponentInterpretation::DataComponentInterpretation > postprocessing_interpretations;

            std::vector<DataComponentInterpretation::DataComponentInterpretation> data_interpretation;

            bool output_materials_and_levels;

            Vector<double> output_materials;

            Vector<double> output_levels;

            bool output_actual_degree;

            bool print_solution;

            bool print_postprocessing;

            std::vector<unsigned int> solution_printing_indices;

            std::vector<unsigned int> postprocessing_printing_indices;

            bool print_blocks_instead_of_indices;


            boost::shared_ptr< Boundary<dim> > curved_boundary;

            types::boundary_id curved_bdry_id;

        protected:

            void _initialize(ParameterHandler& param);

            virtual void initialize_triangulation(ParameterHandler& param);

            //virtual void initialize_grid(ParameterHandler& param){};

            void read_init_solution(FEVector& dst,
                                    bool&     good_solution) const;


            virtual void cell_residual(FEVector&       cell_vector,
                                       const CellInfo& cell);

            virtual void bdry_residual(FEVector&       face_vector,
                                       const FaceInfo& face);

            virtual void face_residual(FEVector&       face_vector1,
                                       FEVector&       face_vector2,
                                       const FaceInfo& face1,
                                       const FaceInfo& face2);

            virtual double cell_estimate(const CellInfo& src);

            virtual double bdry_estimate(const FaceInfo& src);

            virtual double face_estimate(const FaceInfo& src1,
                                         const FaceInfo& src2);


            std::vector< component_materialID_value_map > component_materialID_value_maps;

            std::vector< component_boundaryID_value_map > component_boundaryID_value_maps;


            boost::shared_ptr< FuelCellShop::Geometry::GridBase<dim> > mesh_generator;

            boost::shared_ptr<Triangulation<dim> > tr;


            GridOut g_out;

            DataOut<dim, DoFHandler<dim> > d_out;

            virtual void data_out(const std::string&                            basename,
                                  const FEVector&                               solution,
                                  const std::vector<std::string>&               solution_names,
                                  const std::vector< DataPostprocessor<dim>* >& PostProcessing);

            virtual void data_out(const std::string&              basename,

                                  const FEVector&                 solution,
                                  const std::vector<std::string>& solution_names,

                                  const FEVector&                 postprocessing       = FEVector(),
                                  const std::vector<std::string>& postprocessing_names = std::vector<std::string>());

            void constrain_boundary(FEVector& v,
                                    bool      homogeneous) const;

            FuelCell::SystemManagement system_management;

            std::map<unsigned int, double> boundary_constraints;

            ConstraintMatrix hanging_node_constraints;

            boost::shared_ptr<Mapping<dim> > mapping;

            unsigned int mapping_degree;

            boost::shared_ptr<FiniteElement<dim> > element;

            boost::shared_ptr<DoFHandler<dim> > dof;

            boost::shared_ptr<MGDoFHandler<dim> > mg_dof;

            BlockInfo block_info;

            Vector<float> cell_errors;

            Vector<float> face_errors;

            std::string refinement;

            unsigned int initial_refinement;

            double refinement_threshold;

            double coarsening_threshold;

            bool sort_cuthill;

            Point<dim> sort_direction;

            std::vector<FEVector*> transfer_vectors;

            Quadrature<dim> quadrature_residual_cell;

            Quadrature<dim-1> quadrature_residual_bdry;

            Quadrature<dim-1> quadrature_residual_face;

            Table<2, DoFTools::Coupling> cell_couplings;

            Table<2, DoFTools::Coupling> flux_couplings;

            bool boundary_fluxes;

            bool interior_fluxes;

            unsigned int verbosity;

        private:

            virtual void sort_dofs(DoFHandler<dim>* dof_handler,
                                   MGDoFHandler<dim>* mg_dof_handler = NULL ) const;

            virtual void distribute_face_to_cell_errors();

            virtual double global_from_local_errors() const;
        };

    } // ApplicationCore

} // FuelCell

#endif