Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

EvtVubNLO Class Reference

#include <EvtVubNLO.hh>

Inheritance diagram for EvtVubNLO:

EvtDecayIncoherent EvtDecayBase List of all members.

Public Member Functions

void checkNArg (int a1, int a2=-1, int a3=-1, int a4=-1)
void checkNDaug (int d1, int d2=-1)
void checkQ ()
void checkSpinDaughter (int d1, EvtSpinType::spintype sp)
void checkSpinParent (EvtSpinType::spintype sp)
EvtDecayBase * clone ()
virtual void command (std::string cmd)
virtual std::string commandName ()
void decay (EvtParticle *p)
void disableCheckQ ()
 EvtVubNLO ()
double getArg (int j)
double * getArgs ()
std::string * getArgsStr ()
std::string getArgStr (int j)
double getBranchingFraction ()
EvtId getDaug (int i)
EvtId * getDaugs ()
int getDSum ()
std::string getModelName ()
void getName (std::string &name)
int getNArg ()
int getNDaug ()
EvtId getParentId ()
int getPHOTOS ()
double getProbMax (double prob)
void init ()
void initProbMax ()
int isDaughterSpinDensitySet (int daughter)
void makeDecay (EvtParticle *p)
virtual bool matchingDecay (const EvtDecayBase &other) const
void noProbMax ()
virtual int nRealDaughters ()
void printSummary ()
double resetProbMax (double prob)
void saveDecayInfo (EvtId ipar, int ndaug, EvtId *daug, int narg, std::vector< std::string > &args, std::string name, double brfr)
void setDaughterSpinDensity (int daughter)
void setPHOTOS ()
void setProbMax (double prbmx)
void setSummary ()
void setVerbose ()
int summary ()
int verbose ()
virtual ~EvtVubNLO ()

Static Public Member Functions

void findMass (EvtParticle *p)
void findMasses (EvtParticle *p, int ndaugs, EvtId daugs[10], double masses[10])
double findMaxMass (EvtParticle *p)

Protected Member Functions

bool daugsDecayedByParentModel ()

Protected Attributes

bool _daugsDecayedByParentModel

Private Member Functions

double aGamma (double mu1, double mu2, double epsi=0)
double agammap (double mu1, double mu2, double epsi=0)
double alo (double mu1, double mu2)
double anlo (double mu1, double mu2)
double dGdepsi (double mu1, double mu2)
double dgpdepsi (double mu1, double mu2)
double dSudakovdepsi (double mu1, double mu2)
double F10 (const std::vector< double > &coeffs)
double F20 (const std::vector< double > &coeffs)
double F30 (const std::vector< double > &coeffs)
double lambda (double mu=0)
double lambda1 ()
double lambda2 ()
double lambda_bar (double omega0)
double lambda_SF ()
double M0 (double mui, double omega0)
double mu_bar ()
double mu_h ()
double mu_i ()
double mu_pi2 (double omega0)
double S0 (double a, double r)
double S1 (double a, double r)
double S2 (double a, double r)
double SFNorm (const std::vector< double > &coeffs)
double subS (const std::vector< double > &coeffs)
double subT (const std::vector< double > &coeffs)
double subU (const std::vector< double > &coeffs)
double subV (const std::vector< double > &coeffs)
double Sudakov (double mu1, double mu2, double epsi=0)
double tripleDiff (double pp, double pl, double pm)
double U1 (double mu1, double mu2, double epsi=0)
double U1lo (double mu1, double mu2)
double U1nlo (double mu1, double mu2)

Static Private Member Functions

double alphas (double mu)
double beta0 (int nf=4)
double beta1 (int nf=4)
double beta2 (int nf=4)
double C_F (double mu)
double cGaus (double b)
double dgamma (double t, const std::vector< double > &c)
double expShapeFunction (double omega, const std::vector< double > &coeffs)
double F1Int (double omega, const std::vector< double > &coeffs)
double F2Int (double omega, const std::vector< double > &coeffs)
double F3Int (double omega, const std::vector< double > &coeffs)
double g1 (double y, double z)
double g2 (double y, double z)
double g3 (double y, double z)
double Gamma (double z, double tmax)
double Gamma (double z)
double gamma0 ()
double gamma1 (int nf=4)
double gamma2 (int nf=4)
double gammap0 ()
double gammap1 (int nf=4)
double gausShapeFunction (double omega, const std::vector< double > &coeffs)
double integrand (double omega, const std::vector< double > &coeffs)
double shapeFunction (double omega, const std::vector< double > &coeffs)

Private Attributes

double _b
double _dGMax
double _gmax
int _idSF
double _kpar
double _lambdaSF
double _lbar
double * _masses
double _mB
double _mb
double _mui
double _mupi2
int _nbins
int _ngood
int _ntot
double _SFNorm
double * _weights

Constructor & Destructor Documentation

EvtVubNLO::EvtVubNLO (   )  [inline]
  

00036 {}

EvtVubNLO::~EvtVubNLO (   )  [virtual]
  

00039                       {
00040   delete [] _masses;
00041   delete [] _weights;
00042   cout <<" max pdf : "<<_gmax<<endl;
00043   cout <<" efficiency : "<<(float)_ngood/(float)_ntot<<endl;
00044 
00045 }

Member Function Documentation

double EvtVubNLO::aGamma (  double  mu1,
double  mu2,
double  epsi = 0
)  [inline, private]
  

00152 {return gamma0()/2/beta0()*log(alphas(mu2)/alphas(mu1))+epsi*dGdepsi( mu1, mu2);}

double EvtVubNLO::agammap (  double  mu1,
double  mu2,
double  epsi = 0
)  [inline, private]
  

00154 {return gammap0()/2/beta0()*log(alphas(mu2)/alphas(mu1))+epsi*dgpdepsi( mu1, mu2);}

double EvtVubNLO::alo (  double  mu1,
double  mu2
)  [inline, private]
  

00158 {return -2*aGamma(mu1,mu2);}

double EvtVubNLO::alphas (  double  mu  )  [static, private]
  

00591                           {
00592   double Lambda4=0.302932;
00593   double lg=2*log(mu/Lambda4);
00594   return 4*EvtConst::pi/lg/beta0()*(1-beta1()*log(lg)/pow(beta0(),2)/lg+pow(beta1()/lg,2)/pow(beta0(),4)*(pow(log(lg)-0.5,2)-1.25+beta2()*beta0()/pow(beta1(),2)));
00595 }

double EvtVubNLO::anlo (  double  mu1,
double  mu2
)  [inline, private]
  

00159 {return -2*dGdepsi(mu1,mu2);}

double EvtVubNLO::beta0 (  int  nf = 4  )  [inline, static, private]
  

00097 {return 11.-2./3.*nf;}

double EvtVubNLO::beta1 (  int  nf = 4  )  [inline, static, private]
  

00098 {return 34.*3.-38./3.*nf;}

double EvtVubNLO::beta2 (  int  nf = 4  )  [inline, static, private]
  

00099 {return 1428.5-5033./18.*nf+325./54.*nf*nf;}

double EvtVubNLO::C_F (  double  mu  )  [inline, static, private]
  

00110 {return (4.0/3.0)*alphas(mu)/4./EvtConst::pi;}

double EvtVubNLO::cGaus (  double  b  )  [inline, static, private]
  

00121 {return pow(Gamma(1+b/2.)/Gamma((1+b)/2.),2);}

void EvtDecayBase::checkNArg (  int  a1,
int  a2 = -1,
int  a3 = -1,
int  a4 = -1
)  [inherited]
  

00483                                                            {
00484 
00485   if ( _narg != a1 && _narg != a2 && _narg != a3 && _narg != a4 ) {
00486     report(ERROR,"EvtGen") << _modelname.c_str() << " generator expected "<<endl;
00487     report(ERROR,"EvtGen") << a1<<endl;; 
00488     if ( a2>-1) {
00489       report(ERROR,"EvtGen") << " or " << a2<<endl; 
00490     }
00491     if ( a3>-1) {
00492       report(ERROR,"EvtGen") << " or " << a3<<endl; 
00493     }
00494     if ( a4>-1) {
00495       report(ERROR,"EvtGen") << " or " << a4<<endl; 
00496     }
00497     report(ERROR,"EvtGen") << " arguments but found:"<< _narg << endl;
00498     printSummary();
00499     report(ERROR,"EvtGen") << "Will terminate execution!"<<endl;
00500     ::abort();
00501 
00502   } 
00503 
00504 }

void EvtDecayBase::checkNDaug (  int  d1,
int  d2 = -1
)  [inherited]
  

00505                                            {
00506 
00507   if ( _ndaug != d1 && _ndaug != d2 ) {
00508     report(ERROR,"EvtGen") << _modelname.c_str() << " generator expected ";
00509     report(ERROR,"EvtGen") << d1; 
00510     if ( d2>-1) {
00511       report(ERROR,"EvtGen") << " or " << d2; 
00512     }
00513     report(ERROR,"EvtGen") << " daughters but found:"<< _ndaug << endl;
00514     printSummary();
00515     report(ERROR,"EvtGen") << "Will terminate execution!"<<endl;
00516     ::abort();
00517   } 
00518 
00519 }

void EvtDecayBase::checkQ (   )  [inherited]
  

00035                           {
00036   int i;
00037   int q=0;
00038   int qpar;
00039 
00040   //If there are no daughters (jetset etc) then we do not
00041   //want to do this test.  Why?  Because sometimes the parent
00042   //will have a nonzero charge.
00043 
00044   if ( _ndaug != 0) {
00045     for(i=0; i<_ndaug; i++ ) {
00046       q += EvtPDL::chg3(_daug[i]);
00047     }
00048     qpar = EvtPDL::chg3(_parent);
00049 
00050     if ( q != qpar ) {
00051       report(ERROR,"EvtGen") <<_modelname.c_str()<< " generator expected "
00052                              << " charge to be conserved, found:"<<endl;
00053       report(ERROR,"EvtGen") << "Parent charge of "<<(qpar/3)<<endl;
00054       report(ERROR,"EvtGen") << "Sum of daughter charge of "<<(q/3)<<endl;
00055       report(ERROR,"EvtGen") << "The parent is "<< EvtPDL::name(_parent).c_str()<<endl;
00056       for(i=0; i<_ndaug; i++ ) {
00057       report(ERROR,"EvtGen") << "Daughter "<< EvtPDL::name(_daug[i]).c_str()<<endl;
00058       }
00059       report(ERROR,"EvtGen") << "Will terminate execution!"<<endl;
00060       
00061       ::abort();
00062     }
00063   }
00064 }

void EvtDecayBase::checkSpinDaughter (  int  d1,
EvtSpinType::spintype  sp
)  [inherited]
  

00534                                                                    {
00535 
00536   EvtSpinType::spintype parenttype = EvtPDL::getSpinType(getDaug(d1));
00537   if ( parenttype != sp ) {
00538     report(ERROR,"EvtGen") << _modelname.c_str() 
00539                            << " did not get the correct daughter spin d=" 
00540                            << d1 << endl;
00541     printSummary();
00542     report(ERROR,"EvtGen") << "Will terminate execution!"<<endl;
00543     ::abort();
00544   } 
00545 
00546 }

void EvtDecayBase::checkSpinParent (  EvtSpinType::spintype  sp  )  [inherited]
  

00521                                                          {
00522 
00523   EvtSpinType::spintype parenttype = EvtPDL::getSpinType(getParentId());
00524   if ( parenttype != sp ) {
00525     report(ERROR,"EvtGen") << _modelname.c_str() 
00526                            << " did not get the correct parent spin\n";
00527     printSummary();
00528     report(ERROR,"EvtGen") << "Will terminate execution!"<<endl;
00529     ::abort();
00530   } 
00531 
00532 }

EvtDecayBase * EvtVubNLO::clone (   )  [virtual]
 

Implements EvtDecayBase.

00057                               {
00058 
00059   return new EvtVubNLO;
00060 
00061 }

void EvtDecayBase::command (  std::string  cmd  )  [virtual, inherited]
 

Reimplemented in EvtJetSet, EvtLunda, EvtLundCharm, EvtPythia, and EvtTauola.

00132                                        {
00133   report(ERROR,"EvtGen") << "Should never call EvtDecayBase::command"<<endl;
00134   ::abort();
00135 }

std::string EvtDecayBase::commandName (   )  [virtual, inherited]
 

Reimplemented in EvtJetSet, EvtLunda, EvtLundCharm, EvtPythia, and EvtTauola.

00129                                    {
00130   return std::string("");
00131 }

bool EvtDecayBase::daugsDecayedByParentModel (   )  [inline, protected, inherited]
  

00111 {return _daugsDecayedByParentModel;}

void EvtVubNLO::decay (  EvtParticle *  p  )  [virtual]
 

Implements EvtDecayBase.

00173                                      {
00174   
00175   int j;
00176   // B+ -> u-bar specflav l+ nu
00177   
00178   EvtParticle *xuhad, *lepton, *neutrino;
00179   EvtVector4R p4;
00180   
00181   double pp,pm,pl,ml,El(0.0),Eh(0.0),sh(0.0);
00182   
00183   
00184   
00185   p->initializePhaseSpace(getNDaug(),getDaugs());
00186   
00187   xuhad=p->getDaug(0);
00188   lepton=p->getDaug(1);
00189   neutrino=p->getDaug(2);
00190   
00191   _mB = p->mass();
00192   ml = lepton->mass();
00193   
00194   bool tryit = true;
00195   
00196   while (tryit) {
00197     // pm=(E_H+P_H)
00198     pm= EvtRandom::Flat(0.,1);
00199     pm= pow(pm,1./3.)*_mB;
00200     // pl=mB-2*El
00201     pl = EvtRandom::Flat(0.,1);
00202     pl=sqrt(pl)*pm;
00203     // pp=(E_H-P_H)    
00204     pp = EvtRandom::Flat(0.,pl);
00205 
00206     _ntot++;
00207     
00208     El = (_mB-pl)/2.;      
00209     Eh = (pp+pm)/2;
00210     sh = pp*pm;
00211      
00212     double pdf(0.);
00213     if (pp<pl && El>ml&& sh > _masses[0]*_masses[0]&& _mB*_mB + sh - 2*_mB*Eh > ml*ml) {
00214       double xran = EvtRandom::Flat(0,_dGMax);
00215       pdf = tripleDiff(pp,pl,pm); // triple differential distribution
00216       //      cout <<" P+,P-,Pl,Pdf= "<<pp <<" "<<pm<<" "<<pl<<" "<<pdf<<endl;
00217       if(pdf>_dGMax){
00218         report(ERROR,"EvtGen") << "EvtVubNLO pdf above maximum: " <<pdf
00219                                <<" P+,P-,Pl,Pdf= "<<pp <<" "<<pm<<" "<<pl<<" "<<pdf<<endl;
00220         //::abort();
00221         
00222       }
00223       if ( pdf >= xran ) tryit = false;
00224         
00225       if(pdf>_gmax)_gmax=pdf;
00226     } else {
00227       //      cout <<" EvtVubNLO incorrect kinematics  sh= "<<sh<<"EH "<<Eh<<endl;
00228     }   
00229       
00230     
00231     // reweight the Mx distribution
00232     if(!tryit && _nbins>0){
00233       _ngood++;
00234       double xran1 = EvtRandom::Flat();
00235       double m = sqrt(sh);j=0;
00236       while ( j < _nbins && m > _masses[j] ) j++; 
00237       double w = _weights[j-1]; 
00238       if ( w < xran1 ) tryit = true;// through away this candidate
00239     }
00240   }
00241 
00242   //  cout <<" max prob "<<gmax<<" " << pp<<" "<<y<<" "<<x<<endl;
00243   
00244   // o.k. we have the three kineamtic variables 
00245   // now calculate a flat cos Theta_H [-1,1] distribution of the 
00246   // hadron flight direction w.r.t the B flight direction 
00247   // because the B is a scalar and should decay isotropic.
00248   // Then chose a flat Phi_H [0,2Pi] w.r.t the B flight direction 
00249   // and and a flat Phi_L [0,2Pi] in the W restframe w.r.t the 
00250   // W flight direction.
00251   
00252   double ctH = EvtRandom::Flat(-1,1);
00253   double phH = EvtRandom::Flat(0,2*M_PI);
00254   double phL = EvtRandom::Flat(0,2*M_PI);
00255 
00256   // now compute the four vectors in the B Meson restframe
00257     
00258   double ptmp,sttmp;
00259   // calculate the hadron 4 vector in the B Meson restframe
00260   
00261   sttmp = sqrt(1-ctH*ctH);
00262   ptmp = sqrt(Eh*Eh-sh);
00263   double pHB[4] = {Eh,ptmp*sttmp*cos(phH),ptmp*sttmp*sin(phH),ptmp*ctH};
00264   p4.set(pHB[0],pHB[1],pHB[2],pHB[3]);
00265   xuhad->init( getDaug(0), p4);
00266 
00267 
00268   // calculate the W 4 vector in the B Meson restrframe
00269 
00270   double apWB = ptmp;
00271   double pWB[4] = {_mB-Eh,-pHB[1],-pHB[2],-pHB[3]};
00272 
00273   // first go in the W restframe and calculate the lepton and
00274   // the neutrino in the W frame
00275 
00276   double mW2   = _mB*_mB + sh - 2*_mB*Eh;
00277   //  if(mW2<0.1){
00278   //  cout <<" low Q2! "<<pp<<" "<<epp<<" "<<x<<" "<<y<<endl;
00279   //}
00280   double beta  = ptmp/pWB[0];
00281   double gamma = pWB[0]/sqrt(mW2);
00282 
00283   double pLW[4];
00284     
00285   ptmp = (mW2-ml*ml)/2/sqrt(mW2);
00286   pLW[0] = sqrt(ml*ml + ptmp*ptmp);
00287 
00288   double ctL = (El - gamma*pLW[0])/beta/gamma/ptmp;
00289   if ( ctL < -1 ) ctL = -1;
00290   if ( ctL >  1 ) ctL =  1;
00291   sttmp = sqrt(1-ctL*ctL);
00292 
00293   // eX' = eZ x eW
00294   double xW[3] = {-pWB[2],pWB[1],0};
00295   // eZ' = eW
00296   double zW[3] = {pWB[1]/apWB,pWB[2]/apWB,pWB[3]/apWB};
00297   
00298   double lx = sqrt(xW[0]*xW[0]+xW[1]*xW[1]);
00299   for (j=0;j<2;j++) 
00300     xW[j] /= lx;
00301 
00302   // eY' = eZ' x eX'
00303   double yW[3] = {-pWB[1]*pWB[3],-pWB[2]*pWB[3],pWB[1]*pWB[1]+pWB[2]*pWB[2]};
00304   double ly = sqrt(yW[0]*yW[0]+yW[1]*yW[1]+yW[2]*yW[2]);
00305   for (j=0;j<3;j++) 
00306     yW[j] /= ly;
00307 
00308   // p_lep = |p_lep| * (  sin(Theta) * cos(Phi) * eX'
00309   //                    + sin(Theta) * sin(Phi) * eY'
00310   //                    + cos(Theta) *            eZ')
00311   for (j=0;j<3;j++)
00312     pLW[j+1] = sttmp*cos(phL)*ptmp*xW[j] 
00313       +        sttmp*sin(phL)*ptmp*yW[j]
00314       +          ctL         *ptmp*zW[j];
00315 
00316   double apLW = ptmp;
00317     
00318   // boost them back in the B Meson restframe
00319   
00320   double appLB = beta*gamma*pLW[0] + gamma*ctL*apLW;
00321  
00322   ptmp = sqrt(El*El-ml*ml);
00323   double ctLL = appLB/ptmp;
00324 
00325   if ( ctLL >  1 ) ctLL =  1;
00326   if ( ctLL < -1 ) ctLL = -1;
00327     
00328   double pLB[4] = {El,0,0,0};
00329   double pNB[8] = {pWB[0]-El,0,0,0};
00330 
00331   for (j=1;j<4;j++) {
00332     pLB[j] = pLW[j] + (ctLL*ptmp - ctL*apLW)/apWB*pWB[j];
00333     pNB[j] = pWB[j] - pLB[j];
00334   }
00335 
00336   p4.set(pLB[0],pLB[1],pLB[2],pLB[3]);
00337   lepton->init( getDaug(1), p4);
00338 
00339   p4.set(pNB[0],pNB[1],pNB[2],pNB[3]);
00340   neutrino->init( getDaug(2), p4);
00341 
00342   return ;
00343 }

double EvtVubNLO::dgamma (  double  t,
const std::vector< double > &  c
)  [inline, static, private]
  

00087 {  return pow(t,c[0]-1)*exp(-t);}

double EvtVubNLO::dGdepsi (  double  mu1,
double  mu2
)  [inline, private]
  

00151 {return 1./8./EvtConst::pi*(alphas(mu2)-alphas(mu1))*(gamma1()/beta0()-beta1()*gamma0()/pow(beta0(),2));}

double EvtVubNLO::dgpdepsi (  double  mu1,
double  mu2
)  [inline, private]
  

00153 {return 1./8./EvtConst::pi*(alphas(mu2)-alphas(mu1))*(gammap1()/beta0()-beta1()*gammap0()/pow(beta0(),2));}

void EvtDecayBase::disableCheckQ (   )  [inline, inherited]
  

00062 {_chkCharge=0;};

double EvtVubNLO::dSudakovdepsi (  double  mu1,
double  mu2
)  [inline, private]
  

00147 {return S2(alphas(mu1)/(4*EvtConst::pi),alphas(mu2)/alphas(mu1));}

double EvtVubNLO::expShapeFunction (  double  omega,
const std::vector< double > &  coeffs
)  [static, private]
  

00607                                                                            {
00608   double b=sCoeffs[3];
00609   double l=sCoeffs[7];
00610   double wL=omega/l;
00611 
00612   return pow(wL,b-1)*exp(-b*wL);
00613 }

double EvtVubNLO::F10 (  const std::vector< double > &  coeffs  )  [private]
  

00395                                              {
00396   double pp=coeffs[0];
00397   double y=(coeffs[2]-coeffs[0])/(coeffs[5]-coeffs[0]);
00398   double mui=coeffs[9];
00399   double muh=coeffs[8];
00400   double z=1-y;
00401   double result= U1nlo(muh,mui)/ U1lo(muh,mui);
00402 
00403   result += anlo(muh,mui)*log(y);
00404 
00405   result += C_F(muh)*(-4*pow(log(y*coeffs[4]/muh),2)+10*log(y*coeffs[4]/muh)-4*log(y)-2*log(y)/(1-y)-4.0*ddilog_(&z)-pow(EvtConst::pi,2)/6.-12  );
00406 
00407   result += C_F(mui)*(2*pow(log(y*coeffs[4]*pp/pow(mui,2)),2)-3*log(y*coeffs[4]*pp/pow(mui,2))+7-pow(EvtConst::pi,2) );
00408   result *=shapeFunction(pp,coeffs);
00409   // changes due to SSF 
00410   result +=  (-subS(coeffs)+2*subT(coeffs)+(subU(coeffs)-subV(coeffs))*(1/y-1.))/(coeffs[5]-pp);
00411   result += shapeFunction(pp,coeffs)/pow((coeffs[5]-coeffs[0]),2)*(-5*(lambda1()+3*lambda2())/6+2*(2*lambda1()/3-lambda2())/pow(y,2));
00412   //  result +=  (subS(coeffs)+subT(coeffs)+(subU(coeffs)-subV(coeffs))/y)/(coeffs[5]-pp);
00413   // this part has been added after Feb '05
00414   
00415   //result += shapeFunction(pp,coeffs)/pow((coeffs[5]-coeffs[0]),2)*((lambda1()+3*lambda2())/6+2*(2*lambda1()/3-lambda2())/pow(y,2));
00416   return result;
00417 }

double EvtVubNLO::F1Int (  double  omega,
const std::vector< double > &  coeffs
)  [static, private]
  

00420                                                             {
00421   double pp=coeffs[0];
00422   double y=(coeffs[2]-coeffs[0])/(coeffs[5]-coeffs[0]);
00423   // mubar == mui
00424   return C_F(coeffs[9])*(
00425                          (shapeFunction(omega,coeffs)-shapeFunction(pp,coeffs))*(4*log(y*coeffs[4]*(pp-omega)/pow(coeffs[9],2))-3)/(pp-omega)+
00426                          (g1(y,(pp-omega)/(coeffs[5]-coeffs[0]))/(coeffs[5]-pp)*shapeFunction(omega,coeffs))
00427                          );  
00428 }

double EvtVubNLO::F20 (  const std::vector< double > &  coeffs  )  [private]
  

00431                                              {
00432   double pp=coeffs[0];
00433   double y=(coeffs[2]-coeffs[0])/(coeffs[5]-coeffs[0]);
00434   double result= C_F(coeffs[8])*log(y)/(1-y)*shapeFunction(pp,coeffs)-
00435     1/y*(subS(coeffs)+2*subT(coeffs)-(subT(coeffs)+subV(coeffs))/y)/(coeffs[5]-pp);
00436   // added after Feb '05
00437   result += shapeFunction(pp,coeffs)/pow((coeffs[5]-coeffs[0])*y,2)*(2*lambda1()/3+4*lambda2()-y*(7/6*lambda1()+3*lambda2()));
00438   return result;
00439 }

double EvtVubNLO::F2Int (  double  omega,
const std::vector< double > &  coeffs
)  [static, private]
  

00442                                                             {
00443   double pp=coeffs[0];
00444   double y=(coeffs[2]-coeffs[0])/(coeffs[5]-coeffs[0]);
00445   return C_F(coeffs[9])*g3(y,(pp-omega)/(coeffs[5]-coeffs[0]))*shapeFunction(omega,coeffs)/(coeffs[5]-pp);
00446 }

double EvtVubNLO::F30 (  const std::vector< double > &  coeffs  )  [private]
  

00449                                              {
00450   double y=(coeffs[2]-coeffs[0])/(coeffs[5]-coeffs[0]);
00451   return shapeFunction(coeffs[0],coeffs)/pow((coeffs[5]-coeffs[0])*y,2)*(-2*lambda1()/3+lambda2());
00452 }

double EvtVubNLO::F3Int (  double  omega,
const std::vector< double > &  coeffs
)  [static, private]
  

00455                                                             {
00456   double pp=coeffs[0];
00457   double y=(coeffs[2]-coeffs[0])/(coeffs[5]-coeffs[0]);
00458   return C_F(coeffs[9])*g3(y,(pp-omega)/(coeffs[5]-coeffs[0]))/2*shapeFunction(omega,coeffs)/(coeffs[2]-coeffs[0]);
00459 }

void EvtDecayBase::findMass (  EvtParticle *  p  )  [static, inherited]
  

00347                                           {
00348 
00349   //Need to also check that this mass does not screw
00350   //up the parent
00351   //This code assumes that for the ith daughter, 0..i-1
00352   //already have a mass
00353   double maxOkMass=findMaxMass(p);
00354 
00355   int count=0;
00356   double mass;
00357   bool massOk=false;
00358   int i;
00359   while (!massOk) { 
00360     count++;
00361     if ( count > 10000 ) {
00362       report(INFO,"EvtGen") << "Can not find a valid mass for: " << EvtPDL::name(p->getId()).c_str() <<endl;
00363       report(INFO,"EvtGen") << "Now printing parent and/or grandparent tree\n";
00364       if ( p->getParent() ) {
00365         if ( p->getParent()->getParent() ) {
00366           p->getParent()->getParent()->printTree();
00367           report(INFO,"EvtGen") << p->getParent()->getParent()->mass() <<endl;
00368           report(INFO,"EvtGen") << p->getParent()->mass() <<endl;
00369         }
00370         else{
00371           p->getParent()->printTree();
00372           report(INFO,"EvtGen") << p->getParent()->mass() <<endl;
00373         }
00374       }
00375       else  p->printTree();
00376       report(INFO,"EvtGen") << "maxokmass=" << maxOkMass << " " << EvtPDL::getMinMass(p->getId()) << " " << EvtPDL::getMaxMass(p->getId())<<endl;
00377       if ( p->getNDaug() ) { 
00378         for (i=0; i<p->getNDaug(); i++) {
00379           report(INFO,"EvtGen") << p->getDaug(i)->mass()<<" ";
00380         }
00381         report(INFO,"EvtGen") << endl;
00382       }
00383       if ( maxOkMass >= EvtPDL::getMinMass(p->getId()) ) {
00384         report(INFO,"EvtGen") << "taking a default value\n";
00385         p->setMass(maxOkMass);
00386         return;
00387       } 
00388       assert(0);
00389     }
00390     mass = EvtPDL::getMass(p->getId());
00391     //Just need to check that this mass is > than
00392     //the mass of all daughters
00393     double massSum=0.;
00394     if ( p->getNDaug() ) { 
00395       for (i=0; i<p->getNDaug(); i++) {
00396         massSum+= p->getDaug(i)->mass();
00397       }
00398     }
00399     //some special cases are handled with 0 (stable) or 1 (k0->ks/kl) daughters
00400     if (p->getNDaug()<2)  massOk=true;
00401     if ( p->getParent() ) {
00402       if ( p->getParent()->getNDaug()==1 ) massOk=true;
00403     }
00404     if ( !massOk ) { 
00405       if (massSum < mass) massOk=true;
00406       if ( mass> maxOkMass) massOk=false;
00407     }
00408   }
00409 
00410   p->setMass(mass);
00411   
00412 }

void EvtDecayBase::findMasses (  EvtParticle *  p,
int  ndaugs,
EvtId  daugs[10],
double  masses[10]
)  [static, inherited]
  

00416                                                                      {
00417 
00418   int i;
00419   double mass_sum;
00420 
00421   int count=0;
00422 
00423   if (!( p->firstornot() )) {
00424     for (i = 0; i < ndaugs; i++ ) {
00425       masses[i] = p->getDaug(i)->mass();
00426     } //for
00427   } //if
00428   else {
00429     p->setFirstOrNot();
00430     // if only one daughter do it
00431 
00432     if (ndaugs==1) {
00433       masses[0]=p->mass();
00434       return;
00435     }
00436     
00437     //until we get a combo whose masses are less than _parent mass.
00438     do {
00439       mass_sum = 0.0;
00440 
00441       for (i = 0; i < ndaugs; i++ ) {
00442         masses[i] = EvtPDL::getMass(daugs[i]);
00443         mass_sum = mass_sum + masses[i];
00444       } 
00445 
00446       count++;
00447 
00448      
00449       if(count==10000) {
00450         report(ERROR,"EvtGen") <<"Decaying particle:"<<
00451           EvtPDL::name(p->getId()).c_str()<<" (m="<<p->mass()<<")"<<endl;
00452         report(ERROR,"EvtGen") <<"To the following daugthers"<<endl;
00453         for (i = 0; i < ndaugs; i++ ) {
00454           report(ERROR,"EvtGen") <<  
00455             EvtPDL::name(daugs[i]).c_str() << endl;
00456         } 
00457         report(ERROR,"EvtGen") << "Has been rejected "<<count
00458                                << " times, will now take minimal masses "
00459                                << " of daugthers"<<endl;
00460         
00461         mass_sum=0.;
00462         for (i = 0; i < ndaugs; i++ ) {
00463           masses[i] = EvtPDL::getMinMass(daugs[i]);
00464           mass_sum = mass_sum + masses[i];
00465         } 
00466         if (mass_sum > p->mass()){
00467           report(ERROR,"EvtGen") << "Parent mass="<<p->mass()
00468                                  << "to light for daugthers."<<endl
00469                                  << "Will throw the event away."<<endl;
00470           //dont terminate - start over on the event.
00471           EvtStatus::setRejectFlag();
00472           mass_sum=0.;
00473           //      ::abort();
00474         }
00475 
00476       }
00477     } while ( mass_sum > p->mass());
00478   } //else
00479   
00480   return;
00481 }

double EvtDecayBase::findMaxMass (  EvtParticle *  p  )  [static, inherited]
  

00312                                                {
00313 
00314   
00315   double maxOkMass=EvtPDL::getMaxMass(p->getId());
00316 
00317   //protect against vphotons
00318   if ( maxOkMass < 0.0000000001 ) return 10000000.;
00319   //and against already determined masses
00320   if ( p->hasValidP4() ) maxOkMass=p->mass();
00321 
00322   EvtParticle *par=p->getParent();
00323   if ( par ) {
00324     double maxParMass=findMaxMass(par);
00325     int i;
00326     double minDaugMass=0.;
00327     for(i=0;i<par->getNDaug();i++){
00328       EvtParticle *dau=par->getDaug(i);
00329       if ( dau!=p) {
00330         // it might already have a mass
00331         if ( dau->isInitialized() || dau->hasValidP4() )
00332           minDaugMass+=dau->mass();
00333         else
00334         //give it a bit of phase space 
00335           minDaugMass+=1.000001*EvtPDL::getMinMass(dau->getId());
00336       }
00337     }
00338     if ( maxOkMass>(maxParMass-minDaugMass)) maxOkMass=maxParMass-minDaugMass;
00339   }
00340   return maxOkMass;
00341 }

double EvtVubNLO::g1 (  double  y,
double  z
)  [static, private]
  

00462                                {
00463   double result=(y*(-9+10*y)+x*x*(-12+13*y)+2*x*(-8+6*y+3*y*y))/y/pow(1+x,2)/(x+y);
00464   result -= 4*log((1+1/x)*y)/x;
00465   result -=2*log(1+y/x)*(3*pow(x,4)*(-2+y)-2*pow(y,3)-4*pow(x,3)*(2+y)-2*x*y*y*(4+y)-x*x*y*(12+4*y+y*y))/x/pow((1+x)*y,2)/(x+y);
00466   return result;
00467 }

double EvtVubNLO::g2 (  double  y,
double  z
)  [static, private]
  

00470                                {
00471   double result=y*(10*pow(x,4)+y*y+3*x*x*y*(10+y)+pow(x,3)*(12+19*y)+x*y*(8+4*y+y*y));
00472   result -= 2*x*log(1+y/x)*(5*pow(x,4)+2*y*y+6*pow(x,3)*(1+2*y)+4*y*x*(1+2*y)+x*x*y*(18+5*y));
00473   result *= 2/(pow(y*(1+x),2)*y*(x+y));
00474   return result;
00475 }

double EvtVubNLO::g3 (  double  y,
double  z
)  [static, private]
  

00478                                {
00479   double result=(2*pow(y,3)*(-11+2*y)-10*pow(x,4)*(6-6*y+y*y)+x*y*y*(-94+29*y+2*y*y)+2*x*x*y*(-72+18*y+13*y*y)-pow(x,3)*(72+42*y-70*y*y+3*pow(y,3)))/(pow(y*(1+x),2)*y*(x+y));
00480   result += 2*log(1+y/x)*(-6*x*pow(y,3)*(-5+y)+4*pow(y,4)+5*pow(x,5)*(6-6*y+y*y)-4*pow(x*y,2)*(-20+6*y+y*y)+pow(x,3)*y*(90-10*y-28*y*y+pow(y,3))+pow(x,4)*(36+36*y-50*y*y+4*pow(y,3)))/(pow((1+x)*y*y,2)*(x+y));
00481   return result;
00482 }

double EvtVubNLO::Gamma (  double  z,
double  tmax
)  [static, private]
  

00649                                       {
00650   std::vector<double> c(1);
00651   c[0]=z;
00652   EvtItgPtrFunction *func = new EvtItgPtrFunction(&dgamma, tmin, 100., c);
00653   EvtItgAbsIntegrator *jetSF = new EvtItgSimpsonIntegrator(*func,0.001);
00654   return jetSF->evaluate(tmin,100.);
00655 }

double EvtVubNLO::Gamma (  double  z  )  [static, private]
  

00616                          {
00617 
00618   std::vector<double> gammaCoeffs(6);
00619   gammaCoeffs[0]=76.18009172947146;
00620   gammaCoeffs[1]=-86.50532032941677;
00621   gammaCoeffs[2]=24.01409824083091;
00622   gammaCoeffs[3]=-1.231739572450155;
00623   gammaCoeffs[4]=0.1208650973866179e-2;
00624   gammaCoeffs[5]=-0.5395239384953e-5;
00625   
00626   //Lifted from Numerical Recipies in C
00627   double x, y, tmp, ser;
00628  
00629   int j;
00630   y = z;
00631   x = z;
00632   
00633   tmp = x + 5.5;
00634   tmp = tmp - (x+0.5)*log(tmp);
00635   ser=1.000000000190015;
00636 
00637   for (j=0;j<6;j++) {
00638     y = y +1.0;
00639     ser = ser + gammaCoeffs[j]/y;
00640   }
00641 
00642   return exp(-tmp+log(2.5066282746310005*ser/x));
00643 
00644 }

double EvtVubNLO::gamma0 (   )  [inline, static, private]
  

00100 {return 16./3.;}

double EvtVubNLO::gamma1 (  int  nf = 4  )  [inline, static, private]
  

00101 {return 4./3.*(49.85498-40./9.*nf);}

double EvtVubNLO::gamma2 (  int  nf = 4  )  [inline, static, private]
  

00102 {return 64./3.*(55.07242-8.58691*nf-nf*nf/27.);} /*  zeta3=1.20206 */

double EvtVubNLO::gammap0 (   )  [inline, static, private]
  

00103 {return -20./3.;}

double EvtVubNLO::gammap1 (  int  nf = 4  )  [inline, static, private]
  

00104 {return -32./3.*(6.92653-0.9899*nf);} /* ??  zeta3=1.202 */

double EvtVubNLO::gausShapeFunction (  double  omega,
const std::vector< double > &  coeffs
)  [static, private]
  

00598                                                                             {
00599   double b=sCoeffs[3];
00600   double l=sCoeffs[7];
00601   double wL=omega/l;
00602 
00603   return pow(wL,b)*exp(-cGaus(b)*wL*wL);
00604 }

double EvtDecayBase::getArg (  int  j  )  [inherited]
  

00565                                  {
00566 
00567   // Verify string
00568 
00569   const char* str = _args[j].c_str();
00570   int i = 0;
00571   while(str[i]!=0){
00572     if (isalpha(str[i]) && str[i]!='e') {
00573 
00574       report(INFO,"EvtGen") << "String " << str << " is not a number" << endl;
00575       assert(0);
00576     }
00577     i++;
00578   }
00579   
00580   char** tc=0; 
00581   return strtod(_args[j].c_str(),tc);
00582 }

double * EvtDecayBase::getArgs (   )  [inherited]
  

00548                               {
00549 
00550   if ( _argsD ) return _argsD;
00551   //The user has asked for a list of doubles - the arguments 
00552   //better all be doubles...
00553   if ( _narg==0 ) return _argsD;
00554 
00555   _argsD = new double[_narg];
00556 
00557   int i;
00558   char * tc;
00559   for(i=0;i<_narg;i++) { 
00560     _argsD[i] =  strtod(_args[i].c_str(),&tc);
00561   }
00562   return _argsD;
00563 }

std::string* EvtDecayBase::getArgsStr (   )  [inline, inherited]
  

00073 {return _args;}

std::string EvtDecayBase::getArgStr (  int  j  )  [inline, inherited]
  

00075 {return _args[j];}

double EvtDecayBase::getBranchingFraction (   )  [inline, inherited]
  

00061 {return _brfr;}

EvtId EvtDecayBase::getDaug (  int  i  )  [inline, inherited]
  

00066 {return _daug[i];}

EvtId* EvtDecayBase::getDaugs (   )  [inline, inherited]
  

00065 {return _daug;}

int EvtDecayBase::getDSum (   )  [inline, inherited]
  

00077 {return _dsum; }

std::string EvtDecayBase::getModelName (   )  [inline, inherited]
  

00076 {return _modelname; }

void EvtVubNLO::getName (  std::string &  name  )  [virtual]
 

Implements EvtDecayBase.

00051                                             {
00052 
00053   model_name="VUB_NLO";     
00054 
00055 }

int EvtDecayBase::getNArg (   )  [inline, inherited]
  

00067 {return _narg;}

int EvtDecayBase::getNDaug (   )  [inline, inherited]
  

00064 {return _ndaug;}

EvtId EvtDecayBase::getParentId (   )  [inline, inherited]
  

00060 {return _parent;}

int EvtDecayBase::getPHOTOS (   )  [inline, inherited]
  

00068 {return _photos;}

double EvtDecayBase::getProbMax (  double  prob  )  [inherited]
  

00067                                              {
00068 
00069   int i;
00070 
00071   //diagnostics
00072   sum_prob+=prob;
00073   if (prob>max_prob) max_prob=prob;
00074 
00075 
00076   if ( defaultprobmax && ntimes_prob<=500 ) { 
00077     //We are building up probmax with this iteration
00078      ntimes_prob += 1;
00079      if ( prob > probmax ) { probmax = prob;}
00080      if (ntimes_prob==500) { 
00081        probmax*=1.2;
00082      }
00083      return 1000000.0*prob;
00084   }
00085 
00086   if ( prob> probmax*1.0001) {
00087 
00088     report(INFO,"EvtGen") << "prob > probmax:("<<prob<<">"<<probmax<<")";
00089     report(INFO,"") << "("<<_modelname.c_str()<<") ";
00090     report(INFO,"") << EvtPDL::name(_parent).c_str()<<" -> ";
00091     for(i=0;i<_ndaug;i++){
00092        report(INFO,"") << EvtPDL::name(_daug[i]).c_str() << " ";
00093     }
00094     report(INFO,"") << endl;
00095 
00096     if (defaultprobmax) probmax = prob;
00097 
00098   }
00099 
00100   ntimes_prob += 1;
00101 
00102 
00103   return probmax;
00104 
00105 } //getProbMax

void EvtVubNLO::init (   )  [virtual]
 

Reimplemented from EvtDecayBase.

00064                     {
00065 
00066   // max pdf
00067   _gmax=0;
00068   _ntot=0;
00069   _ngood=0;
00070   _lbar=-1000;
00071   _mupi2=-1000;
00072 
00073   // check that there are at least 6 arguments
00074   int npar = 8;
00075   if (getNArg()<npar) {
00076 
00077     report(ERROR,"EvtGen") << "EvtVubNLO generator expected "
00078                            << " at least npar arguments  but found: "
00079                            <<getNArg()<<endl;
00080     report(ERROR,"EvtGen") << "Will terminate execution!"<<endl;
00081     ::abort();
00082 
00083   }
00084   // this is the shape function parameter
00085   _mb           = getArg(0);
00086   _b            = getArg(1);
00087   _lambdaSF     = getArg(2);// shape function lambda is different from lambda
00088   _mui          = 1.5;// GeV (scale)
00089   _kpar         = getArg(3);// 0
00090   _idSF         = abs((int)getArg(4));// type of shape function 1: exponential (from Neubert)
00091   _nbins        = abs((int)getArg(5));
00092   _masses       = new double[_nbins];
00093   _weights      = new double[_nbins];
00094 
00095   // Shape function normalization
00096   _mB=5.28;// temporary B meson mass for normalization
00097 
00098   std::vector<double> sCoeffs(11);
00099   sCoeffs[3] = _b;
00100   sCoeffs[4] = _mb;
00101   sCoeffs[5] = _mB;
00102   sCoeffs[6] = _idSF;
00103   sCoeffs[7] =  lambda_SF();
00104   sCoeffs[8] =  mu_h();
00105   sCoeffs[9] =  mu_i();
00106   sCoeffs[10] = 1.;
00107   _SFNorm = SFNorm(sCoeffs) ; // SF normalization;
00108 
00109 
00110   cout << " pdf 0.66, 1.32 , 4.32 "<<tripleDiff(0.66, 1.32 , 4.32)<<endl;
00111   cout << " pdf 0.23,0.37,3.76 "<<tripleDiff(0.23,0.37,3.76)<<endl;
00112   cout << " pdf 0.97,4.32,4.42 "<<tripleDiff(0.97,4.32,4.42)<<endl;
00113   cout << " pdf 0.52,1.02,2.01 "<<tripleDiff(0.52,1.02,2.01)<<endl;
00114   cout << " pdf 1.35,1.39,2.73 "<<tripleDiff(1.35,1.39,2.73)<<endl;
00115 
00116   
00117   if (getNArg()-npar+2 != 2*_nbins) {
00118     report(ERROR,"EvtGen") << "EvtVubNLO generator expected " 
00119                            << _nbins << " masses and weights but found: "
00120                            <<(getNArg()-npar)/2 <<endl;
00121     report(ERROR,"EvtGen") << "Will terminate execution!"<<endl;
00122     ::abort();
00123   }
00124   int i,j = npar-2;
00125   double maxw = 0.;
00126   for (i=0;i<_nbins;i++) {
00127     _masses[i] = getArg(j++);
00128     if (i>0 && _masses[i] <= _masses[i-1]) {
00129       report(ERROR,"EvtGen") << "EvtVubNLO generator expected " 
00130                              << " mass bins in ascending order!"
00131                              << "Will terminate execution!"<<endl;
00132       ::abort();
00133     }
00134     _weights[i] = getArg(j++);
00135     if (_weights[i] < 0) {
00136       report(ERROR,"EvtGen") << "EvtVubNLO generator expected " 
00137                              << " weights >= 0, but found: " 
00138                              <<_weights[i] <<endl;
00139       report(ERROR,"EvtGen") << "Will terminate execution!"<<endl;
00140       ::abort();
00141     }
00142     if ( _weights[i] > maxw ) maxw = _weights[i];
00143   }
00144   if (maxw == 0) {
00145     report(ERROR,"EvtGen") << "EvtVubNLO generator expected at least one " 
00146                            << " weight > 0, but found none! " 
00147                            << "Will terminate execution!"<<endl;
00148     ::abort();
00149   }
00150   for (i=0;i<_nbins;i++) _weights[i]/=maxw;
00151 
00152   // the maximum dGamma*p2 value depends on alpha_s only:
00153 
00154 
00155   //  _dGMax = 0.05;
00156    _dGMax = 150.;
00157 
00158   // for the Fermi Motion we need a B-Meso\n mass - but it's not critical
00159   // to get an exact value; in order to stay in the phase space for
00160   // B+- and B0 use the smaller mass
00161 
00162   
00163   // check that there are 3 daughters
00164   checkNDaug(3);
00165 }

void EvtVubNLO::initProbMax (   )  [virtual]
 

Reimplemented from EvtDecayBase.

00167                            {
00168   
00169   noProbMax();
00170   
00171 }

double EvtVubNLO::integrand (  double  omega,
const std::vector< double > &  coeffs
)  [static, private]
  

00385                                                                  {
00386   //double pp=coeffs[0];
00387   double c1=(coeffs[5]+coeffs[1]-coeffs[0]-coeffs[2])*(coeffs[2]-coeffs[1]);
00388   double c2=2*(coeffs[1]-coeffs[0])*(coeffs[2]-coeffs[1]);
00389   double c3=(coeffs[5]-coeffs[2])*(coeffs[2]-coeffs[0]);
00390 
00391   return  c1*F1Int(omega,coeffs)+c2*F2Int(omega,coeffs)+c3*F3Int(omega,coeffs);  
00392 }

int EvtDecayIncoherent::isDaughterSpinDensitySet (  int  daughter  )  [inline, inherited]
  

00041   {return spinDensitySet[daughter];}

double EvtVubNLO::lambda (  double  mu = 0  )  [inline, private]
  

00118 { return _mB-_mb;}

double EvtVubNLO::lambda1 (   )  [inline, private]
  

00094 {return -_mupi2;}

double EvtVubNLO::lambda2 (   )  [inline, private]
  

00116 {return 0.12;}

double EvtVubNLO::lambda_bar (  double  omega0  )  [private]
  

00553                                   {
00554   if(_lbar<0){
00555     if(_idSF==1){ // exponential SF
00556       double rat=omega0*_b/lambda_SF();
00557       _lbar=lambda_SF()/_b*(Gamma(1+_b)-Gamma(1+_b,rat))/(Gamma(_b)-Gamma(_b,rat));
00558     } else if(_idSF==2){ // Gaussian SF
00559       double c=cGaus(_b);
00560       _lbar=lambda_SF()*(Gamma(1+_b/2)-Gamma(1+_b/2,pow(omega0/lambda_SF(),2)*c))/(Gamma((1+_b)/2)-Gamma((1+_b)/2,pow(omega0/lambda_SF(),2)*c))/sqrt(c);
00561     }
00562   }
00563   return _lbar;
00564 }

double EvtVubNLO::lambda_SF (   )  [inline, private]
  

00114 { return _lambdaSF;}

double EvtVubNLO::M0 (  double  mui,
double  omega0
)  [private]
  

00585                                      {
00586   double mf=omega0-lambda_bar(omega0);
00587   return 1+4*C_F(mui)*(-pow(log(mf/mui),2)-log(mf/mui)-pow(EvtConst::pi/2,2)/6.+mu_pi2(omega0)/3/pow(mf,2)*(log(mf/mui)-0.5));
00588 }

void EvtDecayIncoherent::makeDecay (  EvtParticle *  p  )  [virtual, inherited]
 

Implements EvtDecayBase.

00030                                                 {
00031 
00032   int i;
00033   //initialize this the hard way..
00034   //Lange June 26, 2000
00035   for (i=0; i<MAX_DAUG; i++ ) { spinDensitySet[i]=0;}
00036   _daugsDecayedByParentModel=false;
00037 
00038   decay(p);
00039   p->setDecayProb(1.);
00040 
00041   EvtSpinDensity rho;
00042 
00043   rho.SetDiag(p->getSpinStates());
00044 
00045   p->setSpinDensityBackward(rho);
00046 
00047   if (getPHOTOS() || EvtRadCorr::alwaysRadCorr()) {
00048     EvtRadCorr::doRadCorr(p);
00049   }
00050 
00051   //Now decay the daughters.
00052 
00053   if ( !daugsDecayedByParentModel()) {
00054     
00055     for(i=0;i<p->getNDaug();i++){
00056       //Need to set the spin density of the daughters to be
00057       //diagonal.
00058       rho.SetDiag(p->getDaug(i)->getSpinStates());
00059       //if (p->getDaug(i)->getNDaug()==0){
00060       //only do this if the user has not already set the 
00061       //spin density matrix herself.
00062       //Lange June 26, 2000
00063       if ( isDaughterSpinDensitySet(i)==0 ) { 
00064         p->getDaug(i)->setSpinDensityForward(rho);
00065       }
00066       else{
00067         //report(INFO,"EvtGen") << "spinDensitymatrix already set!!!\n";
00068         EvtSpinDensity temp=p->getDaug(i)->getSpinDensityForward();
00069         //      report(INFO,"EvtGen") <<temp<<endl;
00070       }
00071       //Now decay the daughter.  Really!
00072       p->getDaug(i)->decay();
00073       //}
00074     } 
00075   }
00076                             
00077 }

bool EvtDecayBase::matchingDecay (  const EvtDecayBase &  other  )  const [virtual, inherited]
  

00588                                                                 {
00589 
00590   if ( _ndaug != other._ndaug) return false;
00591   if ( _parent != other._parent) return false;
00592   
00593   std::vector<int> useDs;
00594   for ( unsigned int i=0; i<_ndaug; i++) useDs.push_back(0);
00595 
00596   for ( unsigned int i=0; i<_ndaug; i++) {
00597     bool foundIt=false;
00598     for ( unsigned int j=0; j<_ndaug; j++) {
00599       if ( useDs[j] == 1 ) continue;
00600       if ( _daug[i] == other._daug[j] && _daug[i].getAlias() == other._daug[j].getAlias()) {
00601         foundIt=true;
00602         useDs[j]=1;
00603         break;
00604       }
00605     }
00606     if ( foundIt==false) return false;
00607   }
00608   for ( unsigned int i=0; i<_ndaug; i++) if ( useDs[i]==0) return false;
00609 
00610   return true;
00611 
00612 }

double EvtVubNLO::mu_bar (   )  [inline, private]
  

00092 {return _mui;}

double EvtVubNLO::mu_h (   )  [inline, private]
  

00093 {return _mb/sqrt(2.0);} // high scale

double EvtVubNLO::mu_i (   )  [inline, private]
  

00091 {return _mui;} // intermediate scale

double EvtVubNLO::mu_pi2 (  double  omega0  )  [private]
  

00568                               {
00569   if(_mupi2<0){
00570     if(_idSF==1){ // exponential SF
00571       double rat=omega0*_b/lambda_SF();
00572       _mupi2= 3*(pow(lambda_SF()/_b,2)*(Gamma(2+_b)-Gamma(2+_b,rat))/(Gamma(_b)-Gamma(_b,rat))-pow(lambda_bar(omega0),2));
00573     } else if(_idSF==2){ // Gaussian SF
00574       double c=cGaus(_b);
00575       double m1=Gamma((3+_b)/2)-Gamma((3+_b)/2,pow(omega0/lambda_SF(),2)*c);
00576       double m2=Gamma(1+_b/2)-Gamma(1+_b/2,pow(omega0/lambda_SF(),2)*c);
00577       double m3=Gamma((1+_b)/2)-Gamma((1+_b)/2,pow(omega0/lambda_SF(),2)*c);
00578       _mupi2= 3*pow(lambda_SF(),2)*(m1/m3-pow(m2/m3,2))/c;
00579     }
00580   }
00581   return _mupi2;
00582 }

void EvtDecayBase::noProbMax (   )  [inherited]
  

00305                             {
00306 
00307   defaultprobmax=0;
00308 
00309 }

virtual int EvtDecayBase::nRealDaughters (   )  [inline, virtual, inherited]
 

Reimplemented in EvtBtoKD3P, and EvtVSSBMixCPT.

00105 { return _ndaug;}

void EvtDecayBase::printSummary (   )  [inherited]
  

00259                                 {
00260 
00261   int i;
00262 
00263   if (ntimes_prob>0) {
00264 
00265     report(INFO,"EvtGen") << "Calls="<<ntimes_prob<<" eff:"<<
00266       sum_prob/(probmax*ntimes_prob)<<" frac. max:"<<max_prob/probmax;
00267     report(INFO,"") <<" probmax:"<<probmax<<" max:"<<max_prob<<" : ";
00268   }
00269 
00270   report(INFO,"") << EvtPDL::name(_parent).c_str()<<" -> ";
00271   for(i=0;i<_ndaug;i++){
00272     report(INFO,"") << EvtPDL::name(_daug[i]).c_str() << " ";
00273   }
00274   report(INFO,"") << " ("<<_modelname.c_str()<<"):"<< endl;
00275   
00276   
00277   
00278 }

double EvtDecayBase::resetProbMax (  double  prob  )  [inherited]
  

00108                                              {
00109   
00110   report(INFO,"EvtGen") << "Reseting prob max\n"; 
00111   report(INFO,"EvtGen") << "prob > probmax:("<<prob<<">"<<probmax<<")";
00112   report(INFO,"") << "("<<_modelname.c_str()<<")";
00113   report(INFO,"") << EvtPDL::getStdHep(_parent)<<"->";
00114   
00115   for( int i=0;i<_ndaug;i++){
00116     report(INFO,"") << EvtPDL::getStdHep(_daug[i]) << " ";
00117   }
00118   report(INFO,"") << endl;
00119   
00120   probmax = 0.0;
00121   defaultprobmax = 0;
00122   ntimes_prob = 0;
00123   
00124   return prob;
00125 
00126 }

double EvtVubNLO::S0 (  double  a,
double  r
)  [inline, private]
  

00136 {return -gamma0()/4/a/pow(beta0(),2)*(1/r-1+log(r));}

double EvtVubNLO::S1 (  double  a,
double  r
)  [inline, private]
  

00137                                       {return gamma0()/4./pow(beta0(),2)*(
00138                                                                   pow(log(r),2)*beta1()/2./beta0()+(gamma1()/gamma0()-beta1()/beta0())*(1.-r+log(r))
00139                                                                   );}

double EvtVubNLO::S2 (  double  a,
double  r
)  [inline, private]
  

00140                                       {return gamma0()*a/4./pow(beta0(),2)*(
00141                                                                            -0.5*pow((1-r),2)*(
00142                                                                                          pow(beta1()/beta0(),2)-beta2()/beta0()-beta1()/beta0()*gamma1()/gamma0()+gamma2()/gamma0()
00143                                                                                          )
00144                                                                            +(pow(beta1()/beta0(),2)-beta2()/beta0())*(1-r)*log(r)
00145                                                                            +(beta1()/beta0()*gamma1()/gamma0()-beta2()/beta0())*(1-r+r*log(r))
00146                                                                            );}

void EvtDecayBase::saveDecayInfo (  EvtId  ipar,
int  ndaug,
EvtId *  daug,
int  narg,
std::vector< std::string > &  args,
std::string  name,
double  brfr
)  [inherited]
  

00170                                               {
00171 
00172   int i;
00173 
00174   _brfr=brfr;
00175   _ndaug=ndaug;
00176   _narg=narg;
00177   _parent=ipar; 
00178 
00179   _dsum=0;
00180 
00181   if (_ndaug>0) {
00182     _daug=new EvtId [_ndaug];
00183     for(i=0;i<_ndaug;i++){
00184       _daug[i]=daug[i];
00185       _dsum+=daug[i].getAlias();
00186     }
00187   }
00188   else{
00189     _daug=0;
00190   }
00191 
00192   if (_narg>0) {
00193     _args=new std::string[_narg+1];
00194     for(i=0;i<_narg;i++){
00195       _args[i]=args[i];
00196     }
00197   }
00198   else{
00199      _args = 0;
00200   }
00201 
00202   _modelname=name;
00203 
00204   this->init();
00205   this->initProbMax();
00206 
00207   if (_chkCharge){
00208     this->checkQ();
00209   }
00210 
00211 
00212   if (defaultprobmax){
00213     report(INFO,"EvtGen") << "No default probmax for ";
00214     report(INFO,"") << "("<<_modelname.c_str()<<") ";
00215     report(INFO,"") << EvtPDL::name(_parent).c_str()<<" -> ";
00216     for(i=0;i<_ndaug;i++){
00217       report(INFO,"") << EvtPDL::name(_daug[i]).c_str() << " ";
00218     }
00219     report(INFO,"") << endl;
00220     report(INFO,"") << "This is fine for development, but must be provided for production."<<endl;
00221     report(INFO,"EvtGen") << "Never fear though - the decay will use the \n";
00222     report(INFO,"EvtGen") << "500 iterations to build up a good probmax \n";
00223     report(INFO,"EvtGen") << "before accepting a decay. "<<endl;
00224   }
00225 
00226 }

void EvtDecayIncoherent::setDaughterSpinDensity (  int  daughter  )  [inline, inherited]
  

00038   { spinDensitySet[daughter]=1; return;}

void EvtDecayBase::setPHOTOS (   )  [inline, inherited]
  

00069 {_photos=1;}

void EvtDecayBase::setProbMax (  double  prbmx  )  [inherited]
  

00298                                          {
00299 
00300   defaultprobmax=0;
00301   probmax=prbmx;
00302 
00303 }

void EvtDecayBase::setSummary (   )  [inline, inherited]
  

00071 {_summary=1;}

void EvtDecayBase::setVerbose (   )  [inline, inherited]
  

00070 {_verbose=1;}

double EvtVubNLO::SFNorm (  const std::vector< double > &  coeffs  )  [private]
  

00511                                                          {
00512   
00513   double omega0=1.68;//normalization scale (mB-2*1.8)
00514   if(_idSF==1){ // exponential SF
00515     double omega0=1.68;//normalization scale (mB-2*1.8)
00516     return M0(mu_i(),omega0)*pow(_b,_b)/lambda_SF()/ (Gamma(_b)-Gamma(_b,_b*omega0/lambda_SF()));
00517   } else if(_idSF==2){ // Gaussian SF
00518     double c=cGaus(_b);
00519     return M0(mu_i(),omega0)*2/lambda_SF()/pow(c,-(1+_b)/2.)/
00520       (Gamma((1+_b)/2)-Gamma((1+_b)/2,pow(omega0/lambda_SF(),2)*c));
00521   } else {
00522     report(ERROR,"EvtGen")  << "unknown SF "<<_idSF<<endl;
00523     return -1;
00524   }
00525 }

double EvtVubNLO::shapeFunction (  double  omega,
const std::vector< double > &  coeffs
)  [static, private]
  

00528                                                                         {
00529   if( sCoeffs[6]==1){
00530     return sCoeffs[10]*expShapeFunction(omega, sCoeffs);
00531   } else if( sCoeffs[6]==2) {
00532     return sCoeffs[10]*gausShapeFunction(omega, sCoeffs);
00533   } else {
00534  report(ERROR,"EvtGen") << "EvtVubNLO : unknown shape function # "
00535                            <<sCoeffs[6]<<endl;
00536   }
00537   return -1.;
00538 }

double EvtVubNLO::subS (  const std::vector< double > &  coeffs  )  [private]
  

00543 { return (lambda_bar(1.68)-c[0])*shapeFunction(c[0],c);}

double EvtVubNLO::subT (  const std::vector< double > &  coeffs  )  [private]
  

00545 {  return -3*lambda2()*subS(c)/mu_pi2(1.68);}

double EvtVubNLO::subU (  const std::vector< double > &  coeffs  )  [private]
  

00547 { return -2*subS(c);}

double EvtVubNLO::subV (  const std::vector< double > &  coeffs  )  [private]
  

00549 { return -subT(c);}

double EvtVubNLO::Sudakov (  double  mu1,
double  mu2,
double  epsi = 0
)  [inline, private]
  

00148 {double fp(4*EvtConst::pi);return S0(alphas(mu1)/fp,alphas(mu2)/alphas(mu1))+S1(alphas(mu1)/fp,alphas(mu2)/alphas(mu1))+epsi*dSudakovdepsi(mu1,mu2);}

int EvtDecayBase::summary (   )  [inline, inherited]
  

00078 {return _summary; }

double EvtVubNLO::tripleDiff (  double  pp,
double  pl,
double  pm
)  [private]
  

00346                                                        {
00347 
00348   std::vector<double> sCoeffs(11);
00349   sCoeffs[0] = pp;
00350   sCoeffs[1] = pl;
00351   sCoeffs[2] = pm;
00352   sCoeffs[3] = _b;
00353   sCoeffs[4] =  _mb;
00354   sCoeffs[5] = _mB;
00355   sCoeffs[6] = _idSF;
00356   sCoeffs[7] =  lambda_SF();
00357   sCoeffs[8] =  mu_h();
00358   sCoeffs[9] =  mu_i();
00359   sCoeffs[10] =  _SFNorm; // SF normalization;
00360   
00361 
00362   double c1=(_mB+pl-pp-pm)*(pm-pl);
00363   double c2=2*(pl-pp)*(pm-pl);
00364   double c3=(_mB-pm)*(pm-pp);
00365   double aF1=F10(sCoeffs);
00366   double aF2=F20(sCoeffs);
00367   double aF3=F30(sCoeffs);
00368   double td0=c1*aF1+c2*aF2+c3*aF3;
00369 
00370 
00371   EvtItgPtrFunction *func = new EvtItgPtrFunction(&integrand, 0., _mB, sCoeffs);
00372   EvtItgAbsIntegrator *jetSF = new EvtItgSimpsonIntegrator(*func,0.01,25);
00373   double smallfrac=0.000001;// stop a bit before the end to avoid problems with numerical integration
00374   double tdInt = jetSF->evaluate(0,pp*(1-smallfrac));
00375   delete jetSF;
00376   
00377   double SU=U1lo(mu_h(),mu_i())*pow((pm-pp)/(_mB-pp),alo(mu_h(),mu_i()));
00378   double TD=(_mB-pp)*SU*(td0+tdInt);
00379 
00380   return TD;
00381 
00382 }

double EvtVubNLO::U1 (  double  mu1,
double  mu2,
double  epsi = 0
)  [inline, private]
  

00155 {return exp(2*(Sudakov(mu1,mu2,epsi)-agammap(mu1,mu2,epsi)-aGamma(mu1,mu2,epsi)*log(_mb/mu1)));}

double EvtVubNLO::U1lo (  double  mu1,
double  mu2
)  [inline, private]
  

00156 {return U1(mu1,mu2);}

double EvtVubNLO::U1nlo (  double  mu1,
double  mu2
)  [inline, private]
  

00157 {return U1(mu1,mu2)*(1+2*(dSudakovdepsi(mu1,mu2)-dgpdepsi( mu1, mu2)-log(_mb/mu1)*dGdepsi( mu1, mu2)));}

int EvtDecayBase::verbose (   )  [inline, inherited]
  

00079 {return _verbose; }

Member Data Documentation

double EvtVubNLO::_b [private]
 

bool EvtDecayBase::_daugsDecayedByParentModel [protected, inherited]
 

double EvtVubNLO::_dGMax [private]
 

double EvtVubNLO::_gmax [private]
 

int EvtVubNLO::_idSF [private]
 

double EvtVubNLO::_kpar [private]
 

double EvtVubNLO::_lambdaSF [private]
 

double EvtVubNLO::_lbar [private]
 

double* EvtVubNLO::_masses [private]
 

double EvtVubNLO::_mB [private]
 

double EvtVubNLO::_mb [private]
 

double EvtVubNLO::_mui [private]
 

double EvtVubNLO::_mupi2 [private]
 

int EvtVubNLO::_nbins [private]
 

int EvtVubNLO::_ngood [private]
 

int EvtVubNLO::_ntot [private]
 

double EvtVubNLO::_SFNorm [private]
 

double* EvtVubNLO::_weights [private]
 

The documentation for this class was generated from the following files:
Generated on Wed Feb 2 16:13:28 2011 for BOSS6.5.5 by  doxygen 1.3.9.1