dakota_direct_interface.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
//
// C++ Implementation: dakota_application
//
// Description: Used to read in an array of experimental data with column headers.
//              For use with parameter estimation or generating polarization curves.
//
// Author: Malte Krack, Peter Dobson <pdobson@ualberta.ca>, Marc Secanell <secanell@ualberta.ca>, (C) 2009,2010
//
// Copyright: See COPYING file that comes with this distribution
//
// Created by: Malte Krack, Peter Dobson (August 2009)
// Last updated: January, 2010
//
//---------------------------------------------------------------------------
#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"

#ifdef _WITH_DAKOTA

//DAKOTA libraries:
#include "DirectApplicInterface.H"
#include "ApplicationInterface.H"




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<AppFrame::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