dakota_application.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_application.h
//    - Description: Used to read in an array of experimental data with column headers.
//                   For use with parameter estimation or generating polarization curves.
//    - Developers: Malte Krack, Peter Dobson <pdobson@ualberta.ca>, Marc Secanell <secanell@ualberta.ca>
//    - $Id: dakota_application.h 2605 2014-08-15 03:36:44Z secanell $
//
//---------------------------------------------------------------------------

#ifndef dakota_application_h
#define dakota_application_h

#ifdef _WITH_DAKOTA

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

#include <contribs/experimental_data.h>
#include <utils/simulation_selector.h>
#include <utils/fcst_utilities.h>

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

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


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);

        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;




        std::string mutation_type;
        std::string crossover_type;
        std::string fitness_type;
        std::string fitness_type_moga;
        std::string replacement_type;
        std::string replacement_type_moga;
        std::string initialization_type;
        std::string convergence_type;
        std::string convergence_type_moga;
        double num_offspring;
        double num_parents;



    };
}

#endif  //Dakota

#endif