CUBAwrapper.h

Go to the documentation of this file.

/*******************************************************************
 *  Copyright (C) 2010 by Federico Marulli                         *
 *  federico.marulli3@unibo.it                                     *
 *                                                                 *
 *  This program is free software; you can redistribute it and/or  *
 *  modify it under the terms of the GNU General Public License as *
 *  published by the Free Software Foundation; either version 2 of *
 *  the License, or (at your option) 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 General Public License for more details.                   *
 *                                                                 *
 *  You should have received a copy of the GNU General Public      *
 *  License along with this program; if not, write to the Free     *
 *  Software Foundation, Inc.,                                     *
 *  59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.      *
 *******************************************************************/
 
#ifndef __CUBAwrap__
#define __CUBAwrap__
 
#include "cuba.h"
#include "Kernel.h"
 
namespace cbl {
 
  namespace wrapper {
 
    namespace cuba {
 
      struct STR_CUBA_inputs {
 
    int NDIM = 1;
 
    int NCOMP = 1;
 
    std::shared_ptr<void> USERDATA = NULL;
 
    int NVEC = 1;
 
    double EPSREL = 1e-4;
 
    double EPSABS = 1e-12;
 
    int VERBOSE = 0;
 
    int LAST = 4;
 
    int SEED = 0;
 
    int MINEVAL = 0;
 
    int MAXEVAL = 50000;
 
    int NSTART = 1000;
 
    int NINCREASE = 500;
 
    int NBATCH = 1000;
 
    int GRIDNO = 0;
 
    char *STATEFILE = NULL;
 
    std::shared_ptr<void> SPIN = NULL;
 
    int NNEW = 1000;
 
    int NMIN = 2;
 
    double FLATNESS = 25.;
 
    int KEY1 = 47;
 
    int KEY2 = 1;
 
    int KEY3 = 1;
 
    int MAXPASS = 5;
 
    double BORDER = 0.;
 
    double MAXCHISQ = 10.;
 
    double MINDEVIATION = 0.25;
 
    int NGIVEN = 0;
 
    int LDXGIVEN = NDIM;
 
    int NEXTRA = 0;
 
    int KEY = 0;
      };
 
    
      struct STR_CUBA_integrand
      {
    FunctionDoubleVector func;
 
    std::vector<std::vector<double>> integration_limits;
      };
 
      int CUBAIntegrand (const int *ndim, const cubareal xx[], const int *ncomp, cubareal ff[], void *userdata);
 
      class CUBAwrapper {
 
      protected:
 
    FunctionDoubleVector m_integrand;
 
    int m_ndim;
 
    STR_CUBA_inputs m_inputs;
 
      public:
 
    CUBAwrapper () = default;
 
    CUBAwrapper (FunctionDoubleVectorPtrVectorRef func, const std::shared_ptr<void> function_parameters, std::vector<double> &parameters, const int ndim);
 
    CUBAwrapper (FunctionDoubleVector func, const int ndim);
 
    ~CUBAwrapper () = default;
 
    void set_integrand (FunctionDoubleVectorPtrVectorRef func, const std::shared_ptr<void> function_parameters, std::vector<double> &parameters, const int ndim);
 
    void set_integrand (FunctionDoubleVector func, const int ndim);
    
    void set_limits (std::vector<std::vector<double>> integration_limits)
    { (void)integration_limits; ErrorCBL("", "set_limits", "CUBAwrapper.h", glob::ExitCode::_workInProgress_); };
 
    
    STR_CUBA_inputs& inputs () {return m_inputs;}
 
    double IntegrateVegas (std::vector<std::vector<double>> integration_limits, const bool parallelize=true);
 
    double IntegrateSuave (std::vector<std::vector<double>> integration_limits, const bool parallelize=true);
 
    double IntegrateDivonne (std::vector<std::vector<double>> integration_limits, const bool parallelize=true);
 
    double IntegrateCuhre (std::vector<std::vector<double>> integration_limits, const bool parallelize=true);
 
      };
    }
  }
}
 
#endif