function_evaluation.h

Go to the documentation of this file.

/*
 * MAST: Multidisciplinary-design Adaptation and Sensitivity Toolkit
 * Copyright (C) 2013-2020  Manav Bhatia and MAST authors
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */


#ifndef __mast__function_evaluation_h__
#define __mast__function_evaluation_h__

// C++ includes
#include <vector>
#include <iostream>
#include <iomanip>
#include <fstream>


// MAST includes
#include "base/mast_data_types.h"
#include "base/mast_config.h"


// libMesh includes
#include "libmesh/parallel_object.h"


namespace MAST {

    // Forward declerations
    class OptimizationInterface;
    
    class FunctionEvaluation:
    public libMesh::ParallelObject {
        
    public:
        
        FunctionEvaluation(const libMesh::Parallel::Communicator& comm_in):
        libMesh::ParallelObject (comm_in),
        _iter                   (0),
        _n_vars                 (0),
        _n_eq                   (0),
        _n_ineq                 (0),
        _max_iters              (0),
        _n_rel_change_iters     (5),
        _tol                    (1.0e-6),
        _output                 (nullptr),
        _optimization_interface (nullptr)
        { }
        
        virtual ~FunctionEvaluation() { }
        
        
        void attach_optimization_interface(MAST::OptimizationInterface& opt);
        
        
        unsigned int n_vars() const {
            return _n_vars;
        }
        
        
        unsigned int n_eq() const {
            return _n_eq;
        }
        
        
        unsigned int n_ineq() const{
            return _n_ineq;
        }
        
        
        unsigned int max_iters() const{
            return _max_iters;
        }
        
        
        unsigned int n_iters_relative_change() const {
            return _n_rel_change_iters;
        }
        
        
        Real tolerance() const{
            return _tol;
        }
        
        
        virtual void init_dvar(std::vector<Real>& x,
                               std::vector<Real>& xmin,
                               std::vector<Real>& xmax) = 0;
        
        virtual void evaluate(const std::vector<Real>& dvars,
                              Real& obj,
                              bool eval_obj_grad,
                              std::vector<Real>& obj_grad,
                              std::vector<Real>& fvals,
                              std::vector<bool>& eval_grads,
                              std::vector<Real>& grads) = 0;
        
        
        void set_output_file(const std::string& nm) {
            
            if (!_output)
                _output = new std::ofstream;
            
            _output->close();
            _output->open(nm.c_str(), std::ofstream::out);
        }

        
        virtual void output(unsigned int iter,
                            const std::vector<Real>& x,
                            Real obj,
                            const std::vector<Real>& fval,
                            bool if_write_to_optim_file);
        
        
        void initialize_dv_from_output_file(const std::string& nm,
                                            const unsigned int iter,
                                            std::vector<Real> &x);
        
        virtual bool verify_gradients(const std::vector<Real>& dvars);

        virtual void
        parametric_line_study(const std::string& nm,
                              const unsigned int iter1,
                              const unsigned int iter2,
                              unsigned int divs);
        
        
#if MAST_ENABLE_SNOPT == 1
        typedef void (*funobj) (int*    mode,
                                int*    n,
                                double* x,
                                double* f,
                                double* g,
                                int*    nstate);
        
        
        typedef void (*funcon) (int*    mode,
                                int*    ncnln,
                                int*    n,
                                int*    ldJ,
                                int*    needc,
                                double* x,
                                double* c,
                                double* cJac,
                                int*    nstate);

        virtual funobj
        get_objective_evaluation_function() {
            
            // should not get here, if the derived method implements its
            // specialized method
            libmesh_assert(false);
            return nullptr;
        }

        
        virtual funcon
        get_constraint_evaluation_function() {
            
            // should not get here, if the derived method implements its
            // specialized method
            libmesh_assert(false);
            return nullptr;
        }
#endif
      
        void sanitize_parallel();
        
        virtual void _init_dvar_wrapper(std::vector<Real>& x,
                                        std::vector<Real>& xmin,
                                        std::vector<Real>& xmax);
        

        virtual void _evaluate_wrapper(const std::vector<Real>& dvars,
                                       Real& obj,
                                       bool eval_obj_grad,
                                       std::vector<Real>& obj_grad,
                                       std::vector<Real>& fvals,
                                       std::vector<bool>& eval_grads,
                                       std::vector<Real>& grads);

        virtual void _output_wrapper(unsigned int iter,
                                     const std::vector<Real>& x,
                                     Real obj,
                                     const std::vector<Real>& fval,
                                     bool if_write_to_optim_file);

    protected:
        
        unsigned int _iter;
        
        unsigned int _n_vars;
        
        unsigned int _n_eq;
        
        unsigned int _n_ineq;
        
        unsigned int _max_iters;
        
        unsigned int _n_rel_change_iters;
        
        Real _tol;
        
        std::ofstream* _output;
        
        MAST::OptimizationInterface        *_optimization_interface;
    };


}

#endif // __mast__function_evaluation_h__