dakota_application.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_application_h
#define dakota_application_h

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

//appframe:
#include <appframe/base.h>

#include "experimental_data.h"
#include "simulation_selector.h"

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

#ifdef _WITH_DAKOTA

//Dakota:
#include <ParallelLibrary.H>
#include <ProblemDescDB.H>
#include <DakotaStrategy.H>
#include <DakotaModel.H>
#include <DirectApplicInterface.H>


namespace SIM
{

class DakotaApplication
{
public:
     DakotaApplication(boost::shared_ptr<Dakota::ProblemDescDB> global_problem_db,
                       std::string parameter_file);

     void manage_inputs(ParameterHandler& param);

     void assign_interface(Dakota::DirectApplicInterface* optimization_interface);

     void run();

     inline bool use_NLS()
     {
          return NLS_flag;
     }

     Dakota::RealVector vars_results();

     Dakota::RealVector resp_results();

     void declare_parameters(ParameterHandler& param);
         
         void synchronize_variables(unsigned int &n_dvar, unsigned int &n_resp, 
                                                           std::vector<std::string> &name_design_var, std::vector<std::string> &name_responses);
         
private:
     void initialize(ParameterHandler& param);
     void write_hybrid_dakota_input_file();
     void write_pareto_dakota_input_file();
     void write_multi_start_dakota_input_file();
     void write_single_method_dakota_input_file();
     void write_method(std::stringstream& inputss, std::string& method_id, std::string method_name, std::string model_ptr);
     void write_responses(std::stringstream& inputss, int id, std::string method_name);
     void write_variables(std::stringstream& inputss, int id);
         void set_all_dvar_names();
         
         void check_dvar_names() const;
         DeclException2(DesignVariableNotFoundInFCSTDesignVariables,
                                        std::string,
                                        std::string,
                                        << "A "  << arg1 << " with name \"" << arg2 << "\" is not stored in available FCST design variables. Please define the variable in DakotaApplication class and in set_parameters in the appropriate class");

     bool a_gradients;
     bool n_gradients;
     std::string n_gradient_type;
     bool hessians;
 
        unsigned int n_dvar;
        unsigned int n_obj;
        unsigned int n_nl_con;
        unsigned int n_eq_con;
        unsigned int n_con;
        unsigned int n_resp;
        std::vector<std::string> name_design_var;
        std::vector<std::string> all_name_design_var;
        std::vector<std::string> name_responses;
        
     std::string input_file;
     boost::shared_ptr<Dakota::ProblemDescDB> problem_db;

     //DAKOTA variables
     std::string dakota_version;
        
     bool use_dakota_input_file;
     std::string dakota_input;
     std::string optimization_strategy;
     std::string optimization_method;
     bool NLS_flag;
     bool scaling;
     std::string NLS_data_file;
     int max_iter;
     int max_f_eval;
     double convergence_tol;
     double constraint_tol;
     int rand_pareto_weights;
     int rand_start_points;
     std::string hybrid_strategy;
     int n_hybrid_methods;
     std::vector<std::string> hybrid_opt_method;
     std::vector<std::string> method_list;
     std::vector<std::string> model_ptr;
     std::vector<double> tol;
     std::vector<double> eval_max;
     std::vector<double> iter_max;


     std::vector<int> part_design_var;
     double step_to_boundary;
     double grad_tol;
     std::string merit_function;
     double trust_rad;
     double abs_conv_tol;
     double x_conv_tol;
     double false_conv_tol;
     int m_data_points;

     double solution_target;
     double final_solutions;
     double min_boxsize_limit;
     double volume_boxsize_limit;


     Dakota::StringArray dakota_name_design_var;
     Dakota::RealVector ip_design_var;
     Dakota::RealVector lb_design_var;
     Dakota::RealVector ub_design_var;
     Dakota::RealVector scale_design_var;
     Dakota::StringArray scale_types;
     Dakota::RealVector step_design_var;
     Dakota::RealVector lb_nl_constraint;
     Dakota::RealVector ub_nl_constraint;
     Dakota::RealVector eq_constraint;
     Dakota::Strategy selected_strategy;
          
    double centering_param;
    
    double initial_delta;
    double threshold_delta;
    double contraction_factor;
//
//    /**
//      * Optimization - OPT++ Search method .
//      */
//     std::string search_method;
//      bool changing_search_method;
    

    
    

---

Generated on Fri Aug 30 2013 17:15:54 for OpenFCST: The open-source Fuel Cell Simulation Toolbox by   1.8.2