640 lines
21 KiB
C++
640 lines
21 KiB
C++
/***************************************************************************
|
|
|
|
BMWIntegrator.cpp
|
|
|
|
Author: Bastian M. Wojek
|
|
|
|
***************************************************************************/
|
|
|
|
/***************************************************************************
|
|
* Copyright (C) 2009 by Bastian M. Wojek *
|
|
* bastian.wojek@psi.ch *
|
|
* *
|
|
* 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. *
|
|
***************************************************************************/
|
|
|
|
#include "BMWIntegrator.h"
|
|
|
|
#include "cuba.h"
|
|
|
|
#define USERDATA NULL
|
|
#define SPIN NULL
|
|
#define SEED 0
|
|
#define STATEFILE NULL
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
std::vector<double> TPointPWaveGapIntegralCuhre::fPar;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/**
|
|
* <p>Integrate the function using the Cuhre interface
|
|
*
|
|
* <p><b>return:</b>
|
|
* - value of the integral
|
|
*/
|
|
double TPointPWaveGapIntegralCuhre::IntegrateFunc(int tag)
|
|
{
|
|
const unsigned int NCOMP(1);
|
|
const unsigned int NVEC(1);
|
|
const double EPSREL (1e-4);
|
|
const double EPSABS (1e-6);
|
|
const unsigned int VERBOSE (0);
|
|
const unsigned int LAST (4);
|
|
const unsigned int MINEVAL (0);
|
|
const unsigned int MAXEVAL (50000);
|
|
|
|
const unsigned int KEY (13);
|
|
|
|
int nregions, neval, fail;
|
|
double integral[NCOMP], error[NCOMP], prob[NCOMP];
|
|
|
|
if (tag == 0)
|
|
Cuhre(fNDim, NCOMP, Integrand_aa, USERDATA, NVEC,
|
|
EPSREL, EPSABS, VERBOSE | LAST, MINEVAL, MAXEVAL,
|
|
KEY, STATEFILE, SPIN,
|
|
&nregions, &neval, &fail, integral, error, prob);
|
|
else
|
|
Cuhre(fNDim, NCOMP, Integrand_cc, USERDATA, NVEC,
|
|
EPSREL, EPSABS, VERBOSE | LAST, MINEVAL, MAXEVAL,
|
|
KEY, STATEFILE, SPIN,
|
|
&nregions, &neval, &fail, integral, error, prob);
|
|
|
|
return integral[0];
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/**
|
|
* <p>Calculate the function value for the use with Cuhre---actual implementation of the function
|
|
* for p-wave point, aa==bb component
|
|
*
|
|
* <p><b>return:</b>
|
|
* - 0
|
|
*
|
|
* \param ndim number of dimensions of the integral (2 here)
|
|
* \param x point where the function should be evaluated
|
|
* \param ncomp number of components of the integrand (1 here)
|
|
* \param f function value
|
|
* \param userdata additional user parameters (required by the interface, NULL here)
|
|
*/
|
|
int TPointPWaveGapIntegralCuhre::Integrand_aa(const int *ndim, const double x[],
|
|
const int *ncomp, double f[], void *userdata) // x = {E, z}, fPar = {twokBT, Delta(T), Ec, zc}
|
|
{
|
|
double z = x[1]*fPar[3];
|
|
double deltasq(pow(sqrt(1.0-z*z)*fPar[1],2.0));
|
|
f[0] = (1.0-z*z)/TMath::Power(TMath::CosH(TMath::Sqrt(x[0]*x[0]*fPar[2]*fPar[2]+deltasq)/fPar[0]),2.0);
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/**
|
|
* <p>Calculate the function value for the use with Cuhre---actual implementation of the function
|
|
* for p-wave point, cc component
|
|
*
|
|
* <p><b>return:</b>
|
|
* - 0
|
|
*
|
|
* \param ndim number of dimensions of the integral (2 here)
|
|
* \param x point where the function should be evaluated
|
|
* \param ncomp number of components of the integrand (1 here)
|
|
* \param f function value
|
|
* \param userdata additional user parameters (required by the interface, NULL here)
|
|
*/
|
|
int TPointPWaveGapIntegralCuhre::Integrand_cc(const int *ndim, const double x[],
|
|
const int *ncomp, double f[], void *userdata) // x = {E, z}, fPar = {twokBT, Delta(T), Ec, zc}
|
|
{
|
|
double z = x[1]*fPar[3];
|
|
double deltasq(pow(sqrt(1.0-z*z)*fPar[1],2.0));
|
|
f[0] = (z*z)/TMath::Power(TMath::CosH(TMath::Sqrt(x[0]*x[0]*fPar[2]*fPar[2]+deltasq)/fPar[0]),2.0);
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
std::vector<double> TLinePWaveGapIntegralCuhre::fPar;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/**
|
|
* <p>Integrate the function using the Cuhre interface
|
|
*
|
|
* <p><b>return:</b>
|
|
* - value of the integral
|
|
*/
|
|
double TLinePWaveGapIntegralCuhre::IntegrateFunc(int tag)
|
|
{
|
|
const unsigned int NCOMP(1);
|
|
const unsigned int NVEC(1);
|
|
const double EPSREL (1e-4);
|
|
const double EPSABS (1e-6);
|
|
const unsigned int VERBOSE (0);
|
|
const unsigned int LAST (4);
|
|
const unsigned int MINEVAL (0);
|
|
const unsigned int MAXEVAL (50000);
|
|
|
|
const unsigned int KEY (13);
|
|
|
|
int nregions, neval, fail;
|
|
double integral[NCOMP], error[NCOMP], prob[NCOMP];
|
|
|
|
if (tag == 0)
|
|
Cuhre(fNDim, NCOMP, Integrand_aa, USERDATA, NVEC,
|
|
EPSREL, EPSABS, VERBOSE | LAST, MINEVAL, MAXEVAL,
|
|
KEY, STATEFILE, SPIN,
|
|
&nregions, &neval, &fail, integral, error, prob);
|
|
else
|
|
Cuhre(fNDim, NCOMP, Integrand_cc, USERDATA, NVEC,
|
|
EPSREL, EPSABS, VERBOSE | LAST, MINEVAL, MAXEVAL,
|
|
KEY, STATEFILE, SPIN,
|
|
&nregions, &neval, &fail, integral, error, prob);
|
|
|
|
return integral[0];
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/**
|
|
* <p>Calculate the function value for the use with Cuhre---actual implementation of the function
|
|
* for p-wave line, aa==bb component
|
|
*
|
|
* <p><b>return:</b>
|
|
* - 0
|
|
*
|
|
* \param ndim number of dimensions of the integral (2 here)
|
|
* \param x point where the function should be evaluated
|
|
* \param ncomp number of components of the integrand (1 here)
|
|
* \param f function value
|
|
* \param userdata additional user parameters (required by the interface, NULL here)
|
|
*/
|
|
int TLinePWaveGapIntegralCuhre::Integrand_aa(const int *ndim, const double x[],
|
|
const int *ncomp, double f[], void *userdata) // x = {E, z}, fPar = {twokBT, Delta(T), Ec, zc}
|
|
{
|
|
double z = x[1]*fPar[3];
|
|
double deltasq(pow(z*fPar[1],2.0));
|
|
f[0] = (1.0-z*z)/TMath::Power(TMath::CosH(TMath::Sqrt(x[0]*x[0]*fPar[2]*fPar[2]+deltasq)/fPar[0]),2.0);
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/**
|
|
* <p>Calculate the function value for the use with Cuhre---actual implementation of the function
|
|
* for p-wave line, cc component
|
|
*
|
|
* <p><b>return:</b>
|
|
* - 0
|
|
*
|
|
* \param ndim number of dimensions of the integral (2 here)
|
|
* \param x point where the function should be evaluated
|
|
* \param ncomp number of components of the integrand (1 here)
|
|
* \param f function value
|
|
* \param userdata additional user parameters (required by the interface, NULL here)
|
|
*/
|
|
int TLinePWaveGapIntegralCuhre::Integrand_cc(const int *ndim, const double x[],
|
|
const int *ncomp, double f[], void *userdata) // x = {E, z}, fPar = {twokBT, Delta(T), Ec, zc}
|
|
{
|
|
double z = x[1]*fPar[3];
|
|
double deltasq(pow(z*fPar[1],2.0));
|
|
f[0] = (z*z)/TMath::Power(TMath::CosH(TMath::Sqrt(x[0]*x[0]*fPar[2]*fPar[2]+deltasq)/fPar[0]),2.0);
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
std::vector<double> TDWaveGapIntegralCuhre::fPar;
|
|
|
|
/**
|
|
* <p>Integrate the function using the Cuhre interface
|
|
*
|
|
* <p><b>return:</b>
|
|
* - value of the integral
|
|
*/
|
|
double TDWaveGapIntegralCuhre::IntegrateFunc()
|
|
{
|
|
const unsigned int NCOMP(1);
|
|
const unsigned int NVEC(1);
|
|
const double EPSREL (1e-4);
|
|
const double EPSABS (1e-6);
|
|
const unsigned int VERBOSE (0);
|
|
const unsigned int LAST (4);
|
|
const unsigned int MINEVAL (0);
|
|
const unsigned int MAXEVAL (50000);
|
|
|
|
const unsigned int KEY (13);
|
|
|
|
int nregions, neval, fail;
|
|
double integral[NCOMP], error[NCOMP], prob[NCOMP];
|
|
|
|
Cuhre(fNDim, NCOMP, Integrand, USERDATA, NVEC,
|
|
EPSREL, EPSABS, VERBOSE | LAST, MINEVAL, MAXEVAL,
|
|
KEY, STATEFILE, SPIN,
|
|
&nregions, &neval, &fail, integral, error, prob);
|
|
|
|
return integral[0];
|
|
}
|
|
|
|
/**
|
|
* <p>Calculate the function value for the use with Cuhre---actual implementation of the function
|
|
*
|
|
* <p><b>return:</b>
|
|
* - 0
|
|
*
|
|
* \param ndim number of dimensions of the integral (2 here)
|
|
* \param x point where the function should be evaluated
|
|
* \param ncomp number of components of the integrand (1 here)
|
|
* \param f function value
|
|
* \param userdata additional user parameters (required by the interface, NULL here)
|
|
*/
|
|
int TDWaveGapIntegralCuhre::Integrand(const int *ndim, const double x[],
|
|
const int *ncomp, double f[], void *userdata) // x = {E, phi}, fPar = {twokBT, Delta(T), Ec, phic}
|
|
{
|
|
double deltasq(TMath::Power(fPar[1]*TMath::Cos(2.0*x[1]*fPar[3]),2.0));
|
|
f[0] = 1.0/TMath::Power(TMath::CosH(TMath::Sqrt(x[0]*x[0]*fPar[2]*fPar[2]+deltasq)/fPar[0]),2.0);
|
|
return 0;
|
|
}
|
|
|
|
std::vector<double> TCosSqDWaveGapIntegralCuhre::fPar;
|
|
|
|
/**
|
|
* <p>Integrate the function using the Cuhre interface
|
|
*
|
|
* <p><b>return:</b>
|
|
* - value of the integral
|
|
*/
|
|
double TCosSqDWaveGapIntegralCuhre::IntegrateFunc()
|
|
{
|
|
const unsigned int NCOMP(1);
|
|
const unsigned int NVEC(1);
|
|
const double EPSREL (1e-8);
|
|
const double EPSABS (1e-6);
|
|
const unsigned int VERBOSE (0);
|
|
const unsigned int LAST (4);
|
|
const unsigned int MINEVAL (0);
|
|
const unsigned int MAXEVAL (500000);
|
|
|
|
const unsigned int KEY (13);
|
|
|
|
int nregions, neval, fail;
|
|
double integral[NCOMP], error[NCOMP], prob[NCOMP];
|
|
|
|
Cuhre(fNDim, NCOMP, Integrand, USERDATA, NVEC,
|
|
EPSREL, EPSABS, VERBOSE | LAST, MINEVAL, MAXEVAL,
|
|
KEY, STATEFILE, SPIN,
|
|
&nregions, &neval, &fail, integral, error, prob);
|
|
|
|
return integral[0];
|
|
}
|
|
|
|
/**
|
|
* <p>Calculate the function value for the use with Cuhre---actual implementation of the function
|
|
*
|
|
* <p><b>return:</b>
|
|
* - 0
|
|
*
|
|
* \param ndim number of dimensions of the integral (2 here)
|
|
* \param x point where the function should be evaluated
|
|
* \param ncomp number of components of the integrand (1 here)
|
|
* \param f function value
|
|
* \param userdata additional user parameters (required by the interface, NULL here)
|
|
*/
|
|
int TCosSqDWaveGapIntegralCuhre::Integrand(const int *ndim, const double x[],
|
|
const int *ncomp, double f[], void *userdata) // x = {E, phi}, fPar = {twokBT, DeltaD(T), Ec, phic, DeltaS(T)}
|
|
{
|
|
double deltasq(TMath::Power(fPar[1]*TMath::Cos(2.0*x[1]*fPar[3]) + fPar[4], 2.0));
|
|
f[0] = TMath::Power(TMath::Cos(x[1]*fPar[3])/TMath::CosH(TMath::Sqrt(x[0]*x[0]*fPar[2]*fPar[2]+deltasq)/fPar[0]),2.0);
|
|
return 0;
|
|
}
|
|
|
|
std::vector<double> TSinSqDWaveGapIntegralCuhre::fPar;
|
|
|
|
/**
|
|
* <p>Integrate the function using the Cuhre interface
|
|
*
|
|
* <p><b>return:</b>
|
|
* - value of the integral
|
|
*/
|
|
double TSinSqDWaveGapIntegralCuhre::IntegrateFunc()
|
|
{
|
|
const unsigned int NCOMP(1);
|
|
const unsigned int NVEC(1);
|
|
const double EPSREL (1e-8);
|
|
const double EPSABS (1e-10);
|
|
const unsigned int VERBOSE (0);
|
|
const unsigned int LAST (4);
|
|
const unsigned int MINEVAL (0);
|
|
const unsigned int MAXEVAL (500000);
|
|
|
|
const unsigned int KEY (13);
|
|
|
|
int nregions, neval, fail;
|
|
double integral[NCOMP], error[NCOMP], prob[NCOMP];
|
|
|
|
Cuhre(fNDim, NCOMP, Integrand, USERDATA, NVEC,
|
|
EPSREL, EPSABS, VERBOSE | LAST, MINEVAL, MAXEVAL,
|
|
KEY, STATEFILE, SPIN,
|
|
&nregions, &neval, &fail, integral, error, prob);
|
|
|
|
return integral[0];
|
|
}
|
|
|
|
/**
|
|
* <p>Calculate the function value for the use with Cuhre---actual implementation of the function
|
|
*
|
|
* <p><b>return:</b>
|
|
* - 0
|
|
*
|
|
* \param ndim number of dimensions of the integral (2 here)
|
|
* \param x point where the function should be evaluated
|
|
* \param ncomp number of components of the integrand (1 here)
|
|
* \param f function value
|
|
* \param userdata additional user parameters (required by the interface, NULL here)
|
|
*/
|
|
int TSinSqDWaveGapIntegralCuhre::Integrand(const int *ndim, const double x[],
|
|
const int *ncomp, double f[], void *userdata) // x = {E, phi}, fPar = {twokBT, DeltaD(T), Ec, phic, DeltaS(T)}
|
|
{
|
|
double deltasq(TMath::Power(fPar[1]*TMath::Cos(2.0*x[1]*fPar[3]) + fPar[4], 2.0));
|
|
f[0] = TMath::Power(TMath::Sin(x[1]*fPar[3]),2.0)/TMath::Power(TMath::CosH(TMath::Sqrt(x[0]*x[0]*fPar[2]*fPar[2]+deltasq)/fPar[0]),2.0);
|
|
return 0;
|
|
}
|
|
|
|
std::vector<double> TAnSWaveGapIntegralCuhre::fPar;
|
|
|
|
/**
|
|
* <p>Integrate the function using the Cuhre interface
|
|
*
|
|
* <p><b>return:</b>
|
|
* - value of the integral
|
|
*/
|
|
double TAnSWaveGapIntegralCuhre::IntegrateFunc()
|
|
{
|
|
const unsigned int NCOMP(1);
|
|
const unsigned int NVEC(1);
|
|
const double EPSREL (1e-4);
|
|
const double EPSABS (1e-6);
|
|
const unsigned int VERBOSE (0);
|
|
const unsigned int LAST (4);
|
|
const unsigned int MINEVAL (100);
|
|
const unsigned int MAXEVAL (1000000);
|
|
|
|
const unsigned int KEY (13);
|
|
|
|
int nregions, neval, fail;
|
|
double integral[NCOMP], error[NCOMP], prob[NCOMP];
|
|
|
|
Cuhre(fNDim, NCOMP, Integrand, USERDATA, NVEC,
|
|
EPSREL, EPSABS, VERBOSE | LAST, MINEVAL, MAXEVAL,
|
|
KEY, STATEFILE, SPIN,
|
|
&nregions, &neval, &fail, integral, error, prob);
|
|
|
|
return integral[0];
|
|
}
|
|
|
|
/**
|
|
* <p>Calculate the function value for the use with Cuhre---actual implementation of the function
|
|
*
|
|
* <p><b>return:</b>
|
|
* - 0
|
|
*
|
|
* \param ndim number of dimensions of the integral (2 here)
|
|
* \param x point where the function should be evaluated
|
|
* \param ncomp number of components of the integrand (1 here)
|
|
* \param f function value
|
|
* \param userdata additional user parameters (required by the interface, NULL here)
|
|
*/
|
|
int TAnSWaveGapIntegralCuhre::Integrand(const int *ndim, const double x[],
|
|
const int *ncomp, double f[], void *userdata) // x = {E, phi}, fPar = {twokBT, Delta(T),a, Ec, phic}
|
|
{
|
|
double deltasq(TMath::Power(fPar[1]*(1.0+fPar[2]*TMath::Cos(4.0*x[1]*fPar[4])),2.0));
|
|
f[0] = 1.0/TMath::Power(TMath::CosH(TMath::Sqrt(x[0]*x[0]*fPar[3]*fPar[3]+deltasq)/fPar[0]),2.0);
|
|
return 0;
|
|
}
|
|
|
|
std::vector<double> TAnSWaveGapIntegralDivonne::fPar;
|
|
|
|
/**
|
|
* <p>Integrate the function using the Divonne interface
|
|
*
|
|
* <p><b>return:</b>
|
|
* - value of the integral
|
|
*/
|
|
double TAnSWaveGapIntegralDivonne::IntegrateFunc()
|
|
{
|
|
const unsigned int NCOMP(1);
|
|
const unsigned int NVEC(1);
|
|
const double EPSREL (1e-4);
|
|
const double EPSABS (1e-6);
|
|
const unsigned int VERBOSE (0);
|
|
const unsigned int MINEVAL (1000);
|
|
const unsigned int MAXEVAL (1000000);
|
|
const unsigned int KEY1 (47);
|
|
const unsigned int KEY2 (1);
|
|
const unsigned int KEY3 (1);
|
|
const unsigned int MAXPASS (5);
|
|
const double BORDER (0.);
|
|
const double MAXCHISQ (10.);
|
|
const double MINDEVIATION (.25);
|
|
const unsigned int NGIVEN (0);
|
|
const unsigned int LDXGIVEN (fNDim);
|
|
const unsigned int NEXTRA (0);
|
|
|
|
int nregions, neval, fail;
|
|
double integral[NCOMP], error[NCOMP], prob[NCOMP];
|
|
|
|
Divonne(fNDim, NCOMP, Integrand, USERDATA, NVEC,
|
|
EPSREL, EPSABS, VERBOSE, SEED, MINEVAL, MAXEVAL,
|
|
KEY1, KEY2, KEY3, MAXPASS, BORDER, MAXCHISQ, MINDEVIATION,
|
|
NGIVEN, LDXGIVEN, NULL, NEXTRA, NULL, STATEFILE, SPIN,
|
|
&nregions, &neval, &fail, integral, error, prob);
|
|
|
|
return integral[0];
|
|
}
|
|
|
|
/**
|
|
* <p>Calculate the function value for the use with Divonne---actual implementation of the function
|
|
*
|
|
* <p><b>return:</b>
|
|
* - 0
|
|
*
|
|
* \param ndim number of dimensions of the integral (2 here)
|
|
* \param x point where the function should be evaluated
|
|
* \param ncomp number of components of the integrand (1 here)
|
|
* \param f function value
|
|
* \param userdata additional user parameters (required by the interface, NULL here)
|
|
*/
|
|
int TAnSWaveGapIntegralDivonne::Integrand(const int *ndim, const double x[],
|
|
const int *ncomp, double f[], void *userdata) // x = {E, phi}, fPar = {twokBT, Delta(T),a, Ec, phic}
|
|
{
|
|
double deltasq(TMath::Power(fPar[1]*(1.0+fPar[2]*TMath::Cos(4.0*x[1]*fPar[4])),2.0));
|
|
f[0] = 1.0/TMath::Power(TMath::CosH(TMath::Sqrt(x[0]*x[0]*fPar[3]*fPar[3]+deltasq)/fPar[0]),2.0);
|
|
return 0;
|
|
}
|
|
|
|
std::vector<double> TAnSWaveGapIntegralSuave::fPar;
|
|
|
|
/**
|
|
* <p>Integrate the function using the Suave interface
|
|
*
|
|
* <p><b>return:</b>
|
|
* - value of the integral
|
|
*/
|
|
double TAnSWaveGapIntegralSuave::IntegrateFunc()
|
|
{
|
|
const unsigned int NCOMP(1);
|
|
const unsigned int NVEC(1);
|
|
const double EPSREL (1e-4);
|
|
const double EPSABS (1e-6);
|
|
const unsigned int VERBOSE (0);
|
|
const unsigned int LAST (4);
|
|
const unsigned int MINEVAL (1000);
|
|
const unsigned int MAXEVAL (1000000);
|
|
|
|
const unsigned int NNEW (1000);
|
|
const unsigned int NMIN (2);
|
|
const double FLATNESS (25.);
|
|
|
|
int nregions, neval, fail;
|
|
double integral[NCOMP], error[NCOMP], prob[NCOMP];
|
|
|
|
Suave(fNDim, NCOMP, Integrand, USERDATA, NVEC,
|
|
EPSREL, EPSABS, VERBOSE | LAST, SEED, MINEVAL, MAXEVAL,
|
|
NNEW, NMIN, FLATNESS, STATEFILE, SPIN,
|
|
&nregions, &neval, &fail, integral, error, prob);
|
|
|
|
return integral[0];
|
|
}
|
|
|
|
/**
|
|
* <p>Calculate the function value for the use with Suave---actual implementation of the function
|
|
*
|
|
* <p><b>return:</b>
|
|
* - 0
|
|
*
|
|
* \param ndim number of dimensions of the integral (2 here)
|
|
* \param x point where the function should be evaluated
|
|
* \param ncomp number of components of the integrand (1 here)
|
|
* \param f function value
|
|
* \param userdata additional user parameters (required by the interface, NULL here)
|
|
*/
|
|
int TAnSWaveGapIntegralSuave::Integrand(const int *ndim, const double x[],
|
|
const int *ncomp, double f[], void *userdata) // x = {E, phi}, fPar = {twokBT, Delta(T),a, Ec, phic}
|
|
{
|
|
double deltasq(TMath::Power(fPar[1]*(1.0+fPar[2]*TMath::Cos(4.0*x[1]*fPar[4])),2.0));
|
|
f[0] = 1.0/TMath::Power(TMath::CosH(TMath::Sqrt(x[0]*x[0]*fPar[3]*fPar[3]+deltasq)/fPar[0]),2.0);
|
|
return 0;
|
|
}
|
|
|
|
std::vector<double> TNonMonDWave1GapIntegralCuhre::fPar;
|
|
|
|
/**
|
|
* <p>Integrate the function using the Cuhre interface
|
|
*
|
|
* <p><b>return:</b>
|
|
* - value of the integral
|
|
*/
|
|
double TNonMonDWave1GapIntegralCuhre::IntegrateFunc()
|
|
{
|
|
const unsigned int NCOMP(1);
|
|
const unsigned int NVEC(1);
|
|
const double EPSREL (1e-4);
|
|
const double EPSABS (1e-6);
|
|
const unsigned int VERBOSE (0);
|
|
const unsigned int LAST (4);
|
|
const unsigned int MINEVAL (100);
|
|
const unsigned int MAXEVAL (1000000);
|
|
|
|
const unsigned int KEY (13);
|
|
|
|
int nregions, neval, fail;
|
|
double integral[NCOMP], error[NCOMP], prob[NCOMP];
|
|
|
|
Cuhre(fNDim, NCOMP, Integrand, USERDATA, NVEC,
|
|
EPSREL, EPSABS, VERBOSE | LAST, MINEVAL, MAXEVAL,
|
|
KEY, STATEFILE, SPIN,
|
|
&nregions, &neval, &fail, integral, error, prob);
|
|
|
|
return integral[0];
|
|
}
|
|
|
|
/**
|
|
* <p>Calculate the function value for the use with Cuhre---actual implementation of the function
|
|
*
|
|
* <p><b>return:</b>
|
|
* - 0
|
|
*
|
|
* \param ndim number of dimensions of the integral (2 here)
|
|
* \param x point where the function should be evaluated
|
|
* \param ncomp number of components of the integrand (1 here)
|
|
* \param f function value
|
|
* \param userdata additional user parameters (required by the interface, NULL here)
|
|
*/
|
|
int TNonMonDWave1GapIntegralCuhre::Integrand(const int *ndim, const double x[],
|
|
const int *ncomp, double f[], void *userdata) // x = {E, phi}, fPar = {twokBT, Delta(T),a, Ec, phic}
|
|
{
|
|
double deltasq(TMath::Power(fPar[1]*(fPar[2]*TMath::Cos(2.0*x[1]*fPar[4])+(1.0-fPar[2])*TMath::Cos(6.0*x[1]*fPar[4])),2.0));
|
|
f[0] = 1.0/TMath::Power(TMath::CosH(TMath::Sqrt(x[0]*x[0]*fPar[3]*fPar[3]+deltasq)/fPar[0]),2.0);
|
|
return 0;
|
|
}
|
|
|
|
std::vector<double> TNonMonDWave2GapIntegralCuhre::fPar;
|
|
|
|
/**
|
|
* <p>Integrate the function using the Cuhre interface
|
|
*
|
|
* <p><b>return:</b>
|
|
* - value of the integral
|
|
*/
|
|
double TNonMonDWave2GapIntegralCuhre::IntegrateFunc()
|
|
{
|
|
const unsigned int NCOMP(1);
|
|
const unsigned int NVEC(1);
|
|
const double EPSREL (1e-4);
|
|
const double EPSABS (1e-6);
|
|
const unsigned int VERBOSE (0);
|
|
const unsigned int LAST (4);
|
|
const unsigned int MINEVAL (100);
|
|
const unsigned int MAXEVAL (1000000);
|
|
|
|
const unsigned int KEY (13);
|
|
|
|
int nregions, neval, fail;
|
|
double integral[NCOMP], error[NCOMP], prob[NCOMP];
|
|
|
|
Cuhre(fNDim, NCOMP, Integrand, USERDATA, NVEC,
|
|
EPSREL, EPSABS, VERBOSE | LAST, MINEVAL, MAXEVAL,
|
|
KEY, STATEFILE, SPIN,
|
|
&nregions, &neval, &fail, integral, error, prob);
|
|
|
|
return integral[0];
|
|
}
|
|
|
|
/**
|
|
* <p>Calculate the function value for the use with Cuhre---actual implementation of the function
|
|
*
|
|
* <p><b>return:</b>
|
|
* - 0
|
|
*
|
|
* \param ndim number of dimensions of the integral (2 here)
|
|
* \param x point where the function should be evaluated
|
|
* \param ncomp number of components of the integrand (1 here)
|
|
* \param f function value
|
|
* \param userdata additional user parameters (required by the interface, NULL here)
|
|
*/
|
|
int TNonMonDWave2GapIntegralCuhre::Integrand(const int *ndim, const double x[],
|
|
const int *ncomp, double f[], void *userdata) // x = {E, phi}, fPar = {twokBT, Delta(T),a, Ec, phic}
|
|
{
|
|
double deltasq(4.0*fPar[2]/27.0*TMath::Power(fPar[1]*TMath::Cos(2.0*x[1]*fPar[4]), 2.0) \
|
|
/ TMath::Power(1.0 + fPar[2]*TMath::Cos(2.0*x[1]*fPar[4])*TMath::Cos(2.0*x[1]*fPar[4]), 3.0));
|
|
f[0] = 1.0/TMath::Power(TMath::CosH(TMath::Sqrt(x[0]*x[0]*fPar[3]*fPar[3]+deltasq)/fPar[0]),2.0);
|
|
return 0;
|
|
}
|