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 ApplicationCopy used to implement adaptive refinement
//    - Developers: M. Secanell
//    - $Id: adaptive_refinement.h 1389 2013-08-27 23:29:33Z zingan $
//
//---------------------------------------------------------------------------

#ifndef _FUELCELL__ADAPTIVEREFINEMENT_H_
#define _FUELCELL__ADAPTIVEREFINEMENT_H_

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

// Appframe include files:
#include <appframe/base.h>
#include <appframe/newton.h>
//#include <appframe/fe_vectors.h>

// Fuel cell include files
#include "optimization_block_matrix_application.h"

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


namespace AppFrame
{
template <int dim>
class AdaptiveRefinement
{
public:
    AdaptiveRefinement ( AppFrame::OptimizationBlockMatrixApplication<dim>& app_lin,
                         AppFrame::ApplicationCopy& app,
                         const AppFrame::FEVector& solution = AppFrame::FEVector() );

    ~AdaptiveRefinement();

    void declare_parameters ( ParameterHandler& param ) const;

    void set_parameters ( const std::vector<std::string>& name_dvar,
                          const std::vector<double>& value_dvar,
                          ParameterHandler& param );
    void initialize ( ParameterHandler& param );

    void solve ( const std::string param_file, ParameterHandler& param );

    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;

    void run_Newton();

    void run_Newton ( std::vector<double>& resp );

    void run_Newton ( std::vector<double>& resp, //std::vector<double> (),
                      std::vector<std::vector<double> >& dresp_dl ); //std::vector<std::vector<double> > (0, std::vector<double> ()));

    const AppFrame::FEVector& get_solution() const
    {
           return solution;
    }

private:
    bool output_initial_mesh;
    bool output_initial_sol;
    std::string filename_initial_mesh;
    std::string filename_initial_sol;
    bool output_intermediate_sol;
    bool output_final_sol;
    bool output_intermediate_resp;

    bool output_coarse_solution;

    bool read_in_initial_solution;

    unsigned int n_ref;

    bool gradients;

    AppFrame::OptimizationBlockMatrixApplication<dim> *app_linear;

    AppFrame::ApplicationCopy *app;

    AppFrame::FEVector solution;
};
}

#endif