dakota_direct_interface.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
//
//    FCST: Fuel Cell Simulation Toolbox
//
//    Copyright (C) 2006-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: dakota_direct_interface.h
//    - Description: Class used to create an interface between FCST and DAKOTA
//    - Developers: Malte Krack, Peter Dobson, Marc Secanell <secanell@ualberta.ca>
//    - $Id: dakota_direct_interface.h 2616 2014-08-15 22:57:14Z secanell $
//
//---------------------------------------------------------------------------

#ifndef dakota_direct_interface_h
#define dakota_direct_interface_h

//STL libraries:
#include<string>
#include<fstream>
#include<iostream>
#include<vector>
#include<ctime>

//deal.II:
#include<base/parameter_handler.h>
#include <base/timer.h>

// Fuel Cells:
#include "optimization_block_matrix_application.h"
#include "experimental_data.h"
#include "simulation_selector.h"
#include "adaptive_refinement.h"
#include "dakota_application.h"
#include <utils/fcst_utilities.h>

#ifdef _WITH_DAKOTA

#include <DirectApplicInterface.hpp>
#include <ApplicationInterface.hpp>

namespace SIM
{

    template <int dim>
    class DakotaDirectInterface : public Dakota::DirectApplicInterface
    {
    public:

        DakotaDirectInterface(boost::shared_ptr<const Dakota::ProblemDescDB > problem_db);

        DakotaDirectInterface(DakotaApplication &fcst_interface,
                              boost::shared_ptr<const Dakota::ProblemDescDB > problem_db,
                              ParameterHandler& param,
                              boost::shared_ptr<SimulationSelector<dim> > sim_selector,
                              std::string &param_file);

        ~DakotaDirectInterface()
        {
        };


    protected:
        int derived_map_ac(const Dakota::String& ac_name);

        void dakota_adopt_parameters(boost::shared_ptr<FuelCell::ApplicationCore::OptimizationBlockMatrixApplication<dim> > app_linear);

        void dakota_assign_results(const std::vector<double>& responses,
                                   const std::vector<std::vector<double> >& dresponses_dl);
        void dakota_assign_results(const std::vector<double>& responses);

        ParameterHandler* param;

        boost::shared_ptr<SimulationSelector<deal_II_dimension> > sim_selector;

        DakotaApplication* fcst_interface;

        boost::shared_ptr<const Dakota::ProblemDescDB> problem_db;

        std::string simulator_parameter_file_name;

        Timer eval_timer;

        unsigned int n_dvar;

        unsigned int n_resp;

        std::vector<std::string> name_design_var;

        std::vector<std::string> name_responses;

    };


    // Least-Squares Interface
    template <int dim>
    class DakotaLeastSquaresInterface : public DakotaDirectInterface<dim>
    {
    public:
        DakotaLeastSquaresInterface(DakotaApplication &fcst_interface,
                                    boost::shared_ptr<const Dakota::ProblemDescDB > problem_db,
                                    ParameterHandler& param,
                                    boost::shared_ptr<SimulationSelector<dim> > sim_selector,
                                    std::string &param_file);

        ~DakotaLeastSquaresInterface()
        {
        };

        void _initialize(ParameterHandler& param);

    protected:
        int derived_map_ac(const Dakota::String& ac_name);

    private:

        std::string NLS_data_file;
        std::vector<double> NLS_residual;
        std::string NLS_residual_option;
        std::string NLS_residual_value;
        std::vector<double> experimental_current;
        std::vector<std::string> OC_names;
        std::vector<std::vector<double> > OC_values;
        std::vector<std::string> param_names;
        std::vector<double> param_values;

        Timer nls_timer;
    };

}

#endif  //Dakota


#endif