adaptive_refinement.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
//
//    FCST: Fuel Cell Simulation Toolbox
//
//    Copyright (C) 2009-13 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: adaptive_refinement.h
//    - Description: Child of ApplicationWrapper used to implement adaptive refinement
//    - Developers: M. Secanell, Valentin N. Zingan
//    - $Id: adaptive_refinement.h 2617 2014-08-16 16:29:29Z secanell $
//
//---------------------------------------------------------------------------

#ifndef _FUELCELL__ADAPTIVEREFINEMENT_H_
#define _FUELCELL__ADAPTIVEREFINEMENT_H_

// Deal.II include files:
#include <base/parameter_handler.h>
#include <base/convergence_table.h>
#include <base/smartpointer.h>
#include <grid/tria.h>


// Fuel cell include files
#include <application_core/application_wrapper.h>
#include "newton_base.h"
#include "optimization_block_matrix_application.h"
#include <utils/fcst_utilities.h>

// STD include files
#include <string>
#include <stdio.h>
#include <stdlib.h>

namespace FuelCell
{
    namespace ApplicationCore
    {
        template <int dim>
        class AdaptiveRefinement
        :
        public ApplicationWrapper
        {
        public:
            AdaptiveRefinement ( FuelCell::ApplicationCore::ApplicationBase& application)
            :
            FuelCell::ApplicationCore::ApplicationWrapper(application)
            {
                solution = FuelCell::ApplicationCore::FEVector();
            }
            
            AdaptiveRefinement ( FuelCell::ApplicationCore::OptimizationBlockMatrixApplication<dim>& app_lin,
                                 FuelCell::ApplicationCore::ApplicationWrapper& app,
                                 const FuelCell::ApplicationCore::FEVector& solution = FuelCell::ApplicationCore::FEVector() );
            
            ~AdaptiveRefinement();
            
            void declare_parameters ( ParameterHandler& param ) const;
            
            void initialize ( ParameterHandler& param );
            

            
            void solve( const std::string param_file,
                        ParameterHandler& param,
                        bool              solution_component_changes_between_data_files = false );
            
            void run_Newton(bool solution_component_changes_between_data_files = false);
            
            void run_Newton ( std::vector<double>& resp,
                              bool solution_component_changes_between_data_files = false );
            
            void run_Newton ( std::vector<double>& resp,
                              std::vector<std::vector<double> >& dresp_dl,
                              bool solution_component_changes_between_data_files = false );
            
            
            void test_derivatives ( const std::string input_file,
                                    const std::string dvar,
                                    const double value,
                                    std::vector<double>& resp,
                                    std::vector<std::vector<double> >& dresp,
                                    const bool gradient = true );
            
            void print_parameters() const;
            
            const FuelCell::ApplicationCore::FEVector& get_solution() const
            {
                return solution;
            }
            
            const FuelCell::ApplicationCore::FEVector& get_coarse_solution() const
            {
                return coarse_solution;
            }
            
            const Triangulation<dim>& get_coarse_triangulation() const
            {
                return coarse_triangulation;
            }
            
        private:
            void print_convergence_table();
            
            std::string filename_initial_mesh;
            
            bool output_initial_mesh;
            

            
            bool output_intermediate_sol;
            
            bool output_final_sol;
            
            bool output_intermediate_resp;
                                  
            bool L1_L2_error_and_convergence_rate;
            
            bool nonlinear_solver_for_linear_problem;
            
            unsigned int n_ref;
            
            bool gradients;    
            
            Triangulation<dim> coarse_triangulation;
            
            FuelCell::ApplicationCore::OptimizationBlockMatrixApplication<dim> *app_linear;
            
            FuelCell::ApplicationCore::ApplicationWrapper *app;
            
            FuelCell::ApplicationCore::FEVector solution;
            
            FuelCell::ApplicationCore::FEVector coarse_solution;
            
            std::vector< ConvergenceTable > convergence_tables;
        };
    }
}

#endif