TNloptShare.h

Go to the documentation of this file.

 
// Copyright (C) 2013-2024 CEA/DES
//
// This program 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 3 of the License, or any 
// later version.
//
// This program 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 program.  If not, see <http://www.gnu.org/licenses/>.
// $Id$
// $Author$
// $Date$
// $Revision 1.5 $
// $State$
 
#ifndef __NLOPTSHARE__
#define __NLOPTSHARE__
 
#include <vector>
#include <map>
 
//ROOT
#include "Rtypes.h"
 
//Uranie
#include "Reoptimizer.h"
#include "TOptimShare.h"
 
#include "DataServer.h"
#include "TEval.h"
#include "TOptimFit.h"
#include "TFitGetter.h"
 
struct nlopt_opt_s;
/* opaque structure, defined internally */
typedef struct nlopt_opt_s *nlopt_opt;
struct nlopt_work;
 
 
namespace URANIE
{
namespace Reoptimizer
{
 
class TNloptSolver
{
public:
    virtual ~TNloptSolver() {}
    virtual nlopt_opt build(int, int, int, double, nlopt_opt*) = 0;
 
    ClassDef(URANIE::Reoptimizer::TNloptSolver, ID_REOPTIMIZER)
};
 
class TNloptShare: public TOptimShare
{
private:
    void create();
 
protected:
    TFitGetter *_crit;
    TObjArray _equal;
    TNloptSolver *_solv;
    std::vector<double *> _guess;
    int _id, _max; //, _coef;
    std::vector<std::vector<URANIE::DataServer::UEntry *>> _codi, _codo, _codg;
 
    virtual void build();
    // abstrack methods
    virtual void buildSolver(int siz, struct nlopt_work *) = 0;
    virtual void cleanSolver(struct nlopt_work *) = 0;
    virtual void put(struct nlopt_work *, Bool_t, const double *) = 0;
    virtual int get(long &) = 0;
    //void gradFromCode(double *code, double *solv);
    // solver
    void solver(struct nlopt_work *, int, double*,
            vector<URANIE::DataServer::UEntry*>&,
            vector<URANIE::DataServer::UEntry*>&,
            vector<URANIE::DataServer::UEntry*>&
        );
    void calcul(struct nlopt_work *, Bool_t, const double *);
    void fillOptimum(struct nlopt_work *);
    void fill(struct nlopt_work *, URANIE::DataServer::TDataServer *tds, int id);
 
public:
    class NotASingleEval
    {
    };
 
    TNloptShare(URANIE::DataServer::TDataServer *tds, URANIE::Relauncher::TRun *run,
            TNloptSolver *algo);
    TNloptShare(URANIE::DataServer::TDataServer *tds, URANIE::Relauncher::TEval *fun,
            TNloptSolver *algo);
    virtual ~TNloptShare();
 
    // initialisation
    void setStartingPoint(double *pt);
    void setStartingPoint(int nb, double *pt);
    void setMaximumEval(int max)
    {
        _max = max;
    }
   
    // callback methode
    virtual int critere(struct nlopt_work*, const double *ini, double *out,
            double *grad) = 0;
    virtual int inequality(struct nlopt_work*, const double *in, double *out,
            double *grad) = 0;
    virtual int equality(struct nlopt_work*, const double *in, double *out,
            double *grad) = 0;
    void run(struct nlopt_work *);
 
    int _retOptim;
    int getReturnOptim()
        {
            return _retOptim;
        }
 
    int getNStartingPoint()
        {
            return _guess.size();
        }
    
 
    virtual void solverLoop();
 
    ClassDef(URANIE::Reoptimizer::TNloptShare, ID_REOPTIMIZER)
};
 
#ifdef HIDE
double nlopt_crit(unsigned, const double*, double*, void *);
void nlopt_inequal(unsigned, double *, unsigned, const double*, double*, void*);
void nlopt_equal(unsigned, double *, unsigned, const double*, double*, void*);
//void nlopt_run(void*);
#endif
 
}
} //namespace
#endif