optimization_block_matrix_application.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// FCST: Fuel Cell Simulation Toolbox
//
// Copyright (C) 2006-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: optimization_block_matrix_application.h
// - Description: This is a base class for all applications that provide optimization information
// - Developers: Marc Secanell, University of Alberta
// - $Id: optimization_block_matrix_application.h 2605 2014-08-15 03:36:44Z secanell $
//
// ----------------------------------------------------------------------------

#ifndef _FUEL_CELL_APPLICATION_CORE_OPTIMIZATION_BLOCK_MATRIX_APPLICATION_H_
#define _FUEL_CELL_APPLICATION_CORE_OPTIMIZATION_BLOCK_MATRIX_APPLICATION_H_

#include <base/parameter_handler.h>
#include <base/convergence_table.h>
#include <lac/vector.h>
#include <lac/block_vector.h>
#include <grid/grid_refinement.h>
#include <grid/grid_tools.h>
#include <grid/persistent_tria.h>
#include <dofs/dof_handler.h>
#include <dofs/dof_renumbering.h>
#include <fe/fe.h>
#include <fe/fe_values.h>
#include <numerics/solution_transfer.h>
#include <boost/shared_ptr.hpp>

#include "dof_application.h"
#include "matrix_block.h"
#include "block_matrix_application.h"

#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>

namespace FuelCell
{
namespace ApplicationCore
{
        template <int dim>
        class OptimizationBlockMatrixApplication :
        public FuelCell::ApplicationCore::BlockMatrixApplication<dim>
        {
        public:
            static const FuelCell::ApplicationCore::Event sensitivity_analysis;

            OptimizationBlockMatrixApplication(FuelCell::ApplicationCore::DoFApplication<dim>&,
                                               bool triangulation_only);

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


            ~OptimizationBlockMatrixApplication(){};

            virtual void declare_parameters(ParameterHandler& param);

            virtual void initialize(ParameterHandler& param);

            virtual void responses (std::vector<double>& f,
                                    const FuelCell::ApplicationCore::FEVectors& vectors);
            virtual void check_responses();

            virtual void cell_responses (std::vector<double>& resp,
                                         const typename DoFApplication<dim>::CellInfo& info,
                                         const FuelCell::ApplicationCore::FEVector& sol);

            virtual void bdry_responses (std::vector<double>& resp,
                                         const typename DoFApplication<dim>::FaceInfo& info,
                                         const FuelCell::ApplicationCore::FEVector& sol);

            virtual void global_responses (std::vector<double>& resp,
                                           const FuelCell::ApplicationCore::FEVector& sol);

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


            virtual void dresponses_dl (std::vector<std::vector<double> >& df_dl,
                                        const FuelCell::ApplicationCore::FEVectors& src);
            virtual void cell_dresponses_dl(std::vector<std::vector<double> >& cell_df_dl,
                                            const typename DoFApplication<dim>::CellInfo& info,
                                            const FuelCell::ApplicationCore::FEVector& src);
            virtual void global_dresponses_dl(std::vector<std::vector<double> >& df_dl,
                                              const FuelCell::ApplicationCore::FEVector& src);
            virtual void dresponses_du(std::vector<FuelCell::ApplicationCore::FEVector>& dst,
                                       const FuelCell::ApplicationCore::FEVectors& src);

            virtual void cell_dresponses_du(std::vector<FuelCell::ApplicationCore::FEVector>& df_du,
                                            const typename DoFApplication<dim>::CellInfo& info,
                                            std::vector<std::vector<double> >& src);

            virtual void global_dresponses_du(std::vector<FuelCell::ApplicationCore::FEVector>& df_du,
                                              const FuelCell::ApplicationCore::FEVector& src);

            virtual void dresidual_dlambda(std::vector<FuelCell::ApplicationCore::FEVector>& dst,
                                           const FuelCell::ApplicationCore::FEVectors& src);
            virtual void cell_dresidual_dlambda(std::vector<FuelCell::ApplicationCore::FEVector>& cell_vector,
                                                const typename DoFApplication<dim>::CellInfo& cell,
                                                std::vector<std::vector<double> >& src);

            void solve_direct (std::vector<std::vector<double> >& df_dl,
                               const FuelCell::ApplicationCore::FEVectors& sol);

            void solve_adjoint (std::vector<std::vector<double> >& df_dl,
                                const FuelCell::ApplicationCore::FEVector& sol);
            unsigned int get_n_resp() const;
            unsigned int get_n_dvar() const;
            inline std::vector<std::string> get_name_dvar() const
            {
                return name_design_var;

            }

            inline std::vector<std::string> get_name_responses() const
            {
                return name_responses;

            }

            const std::vector<std::string> get_all_responses_names() const
            {
                return all_response_names;
            }
            /*void enter_data_scalar(std::string name,
             * const double& scalar)
             { *
                 this->get_data()->enter(name, scalar);
             }*/

            void print_default_parameter_file()
            {
                ParameterHandler prm;
                this->declare_parameters(prm);
                std::ofstream file;
                file.open("Default_parameter_file.prm");
                prm.print_parameters (file, ParameterHandler::Text);
                file.close();
            }

            bool get_bool_transfer_solution()
            {return output_coarse_solution;}

            void set_optimization_parameters(unsigned int &n_dvar, unsigned int &n_resp,
                                             std::vector<std::string> &name_design_var, std::vector<std::string> &name_responses);

            void set_output_variables(std::vector<std::string> &dakota_name_responses)
            {
                name_responses = dakota_name_responses;
            };

            virtual void compute_L1_L2_error_and_convergence_rate(const FuelCell::ApplicationCore::FEVector&        solution,
                                                                  const unsigned int&              refinement_cycle,
                                                                  std::vector< ConvergenceTable >& convergence_tables) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__ << " called in Class " << info.name() << std::endl;

            }

        protected:
            void print_dresponses_dl(std::vector<std::vector<double> > pdf_pdl)
            {
                for (unsigned int i=0; i<n_resp; ++i)
                    for (unsigned int j=0; j<n_dvar; ++j)
                        FcstUtilities::log<<"Df"<<i<<"/Dl"<<j<<" is equal to "<<pdf_pdl[i][j]<<std::endl;
            }

            void print_dresponses_du(std::vector<FuelCell::ApplicationCore::FEVector> df_du)
            {
                // Write partial df_du:

                for (unsigned int r=0; r<n_resp; ++r)
                {
                    // Output Du block by block
                    unsigned int n_blocks = df_du[r].n_blocks();
                    unsigned int size = df_du[r].size();
                    unsigned int comp_per_block = size/n_blocks;
                    for (unsigned int i=0; i<n_blocks; ++i)
                        for (unsigned int j=0; j<comp_per_block; ++j)
                        {
                            FcstUtilities::log<<"Element "<<j<<" in block "<<i<<" in STEP (Du) is "<<df_du[r].block(i)(j)<<std::endl;
                        }
                        FcstUtilities::log<<"NORM OF Df"<<r<<"/Du = "<<df_du[r].l2_norm()<<std::endl;
                }
            }

            const std::string extend_filename(const std::string& , const int precision = 3) const;
            
            typedef void (*CELL_Dvalues) (std::vector<FuelCell::ApplicationCore::FEVector>& ,
                                          const typename DoFApplication<dim>::CellInfo& ,
                                          std::vector<std::vector<double> >& );

            void dfunction (std::vector<FuelCell::ApplicationCore::FEVector>& dst,
                            const FuelCell::ApplicationCore::FEVectors& src,
                            bool dfunctional_du,
                            bool dresidual_dlambda);

            void set_all_response_names();

            unsigned int n_dvar;
            unsigned int n_obj;
            unsigned int n_resp;
            std::vector<std::string> name_design_var;
            std::vector<std::string> name_responses;

            std::vector<std::string> name_output_var;

            bool output_coarse_solution;

            bool optimization;

            bool boundary_responses;
            
            std::vector <std::string> all_response_names;
        };

}
}

#endif