diff --git a/EvtGenBase/EvtPdf.hh b/EvtGenBase/EvtPdf.hh index b72c817..bc465e4 100644 --- a/EvtGenBase/EvtPdf.hh +++ b/EvtGenBase/EvtPdf.hh @@ -1,315 +1,313 @@ /******************************************************************************* * Project: BaBar detector at the SLAC PEP-II B-factory * Package: EvtGenBase * File: $Id: EvtPdf.hh,v 1.2 2009-03-16 16:40:15 robbep Exp $ * Author: Alexei Dvoretskii, dvoretsk@slac.stanford.edu, 2001-2002 * * Copyright (C) 2002 Caltech *******************************************************************************/ /* * All classes are templated on the point type T * * EvtPdf: * * Probability density function defined on an interval of phase-space. * Integral over the interval can be calculated by Monte Carlo integration. * Some (but not all) PDFs are analytic in the sense that they can be integrated * by numeric quadrature and distributions can be generated according to them. * * EvtPdfGen: * * Generator adaptor. Can be used to generate random points * distributed according to the PDF for analytic PDFs. * * EvtPdfPred: * * Predicate adaptor for PDFs. Can be used for generating random points distributed * according to the PDF for any PDF using rejection method. (See "Numerical Recipes"). * * EvtPdfUnary: * * Adapter for generic algorithms. Evaluates the PDF and returns the value * * EvtPdfDiv: * * PDF obtained by division of one PDF by another. Because the two PDFs are * arbitrary this PDF is not analytic. When importance sampling is used the * original PDF is divided by the analytic comparison function. EvtPdfDiv is * used to represent the modified PDF. */ #ifndef EVT_PDF_HH #define EVT_PDF_HH #include #include #include "EvtGenBase/EvtValError.hh" #include "EvtGenBase/EvtPredGen.hh" #include "EvtGenBase/EvtStreamInputIterator.hh" #include "EvtGenBase/EvtPdfMax.hh" #include "EvtGenBase/EvtMacros.hh" #include "EvtGenBase/EvtRandom.hh" template class EvtPdfPred; template class EvtPdfGen; template class EvtPdf { public: EvtPdf() {} EvtPdf(const EvtPdf& other) : _itg(other._itg) {} virtual ~EvtPdf() {} virtual EvtPdf* clone() const = 0; double evaluate(const T& p) const { if(p.isValid()) return pdf(p); else return 0.; } // Find PDF maximum. Points are sampled according to pc EvtPdfMax findMax(const EvtPdf& pc, int N); // Find generation efficiency. EvtValError findGenEff(const EvtPdf& pc, int N, int nFindMax); // Analytic integration. Calls cascade down until an overridden // method is called. void setItg(EvtValError itg) {_itg = itg; } EvtValError getItg() const { if(!_itg.valueKnown()) _itg = compute_integral(); return _itg; } EvtValError getItg(int N) const { if(!_itg.valueKnown()) _itg = compute_integral(N); return _itg; } virtual EvtValError compute_integral() const - //make sun happy - return something - { printf("Analytic integration of PDF is not defined\n"); assert(0); return compute_integral();} + { printf("Analytic integration of PDF is not defined\n"); assert(0); return EvtValError{};} virtual EvtValError compute_integral(int) const { return compute_integral(); } // Monte Carlo integration. EvtValError compute_mc_integral(const EvtPdf& pc, int N); // Generation. Create predicate accept-reject generators. // nMax iterations will be used to find the maximum of the accept-reject predicate EvtPredGen,EvtPdfPred > accRejGen(const EvtPdf& pc, int nMax, double factor = 1.); virtual T randomPoint(); protected: virtual double pdf(const T&) const = 0; mutable EvtValError _itg; }; template class EvtPdfGen { public: typedef T result_type; EvtPdfGen() : _pdf(0) {} EvtPdfGen(const EvtPdfGen& other) : _pdf(other._pdf ? other._pdf->clone() : 0) {} EvtPdfGen(const EvtPdf& pdf) : _pdf(pdf.clone()) {} ~EvtPdfGen() { delete _pdf;} result_type operator()() {return _pdf->randomPoint();} private: EvtPdf* _pdf; }; template class EvtPdfPred { public: typedef T argument_type; typedef bool result_type; EvtPdfPred() {} EvtPdfPred(const EvtPdf& thePdf) : itsPdf(thePdf.clone()) {} EvtPdfPred(const EvtPdfPred& other) : COPY_PTR(itsPdf), COPY_MEM(itsPdfMax) {} ~EvtPdfPred() { delete itsPdf; } result_type operator()(argument_type p) { assert(itsPdf); assert(itsPdfMax.valueKnown()); double random = EvtRandom::Flat(0.,itsPdfMax.value()); return (random <= itsPdf->evaluate(p)); } EvtPdfMax getMax() const { return itsPdfMax; } void setMax(const EvtPdfMax& max) { itsPdfMax = max; } template void compute_max(InputIterator it, InputIterator end, double factor = 1.) { T p = *it++; itsPdfMax = EvtPdfMax(p,itsPdf->evaluate(p)*factor); while(!(it == end)) { T p = *it++; double val = itsPdf->evaluate(p)*factor; if(val > itsPdfMax.value()) itsPdfMax = EvtPdfMax(p,val); } } private: EvtPdf* itsPdf; EvtPdfMax itsPdfMax; }; template class EvtPdfUnary { public: typedef double result_type; typedef T argument_type; EvtPdfUnary() {} EvtPdfUnary(const EvtPdf& thePdf) : itsPdf(thePdf.clone()) {} EvtPdfUnary(const EvtPdfUnary& other) : COPY_PTR(itsPdf) {} ~EvtPdfUnary() { delete itsPdf; } result_type operator()(argument_type p) { assert(itsPdf); double ret = itsPdf->evaluate(p); return ret; } private: EvtPdf* itsPdf; }; template class EvtPdfDiv : public EvtPdf { public: EvtPdfDiv() : itsNum(0), itsDen(0) {} EvtPdfDiv(const EvtPdf& theNum, const EvtPdf& theDen) : EvtPdf(), itsNum(theNum.clone()), itsDen(theDen.clone()) {} EvtPdfDiv(const EvtPdfDiv& other) : EvtPdf(other), COPY_PTR(itsNum), COPY_PTR(itsDen) {} virtual ~EvtPdfDiv() { delete itsNum; delete itsDen; } EvtPdf* clone() const override { return new EvtPdfDiv(*this); } double pdf(const T& p) const override { double num = itsNum->evaluate(p); double den = itsDen->evaluate(p); assert(den != 0); return num/den; } private: EvtPdf* itsNum; // numerator EvtPdf* itsDen; // denominator }; template EvtPdfMax EvtPdf::findMax(const EvtPdf& pc, int N) { EvtPdfPred pred(*this); EvtPdfGen gen(pc); pred.compute_max(iter(gen,N),iter(gen)); EvtPdfMax p = pred.getMax(); return p; } template EvtValError EvtPdf::findGenEff(const EvtPdf& pc, int N, int nFindMax) { assert(N > 0 || nFindMax > 0); EvtPredGen,EvtPdfPred > gen = accRejGen(pc,nFindMax); int i; for(i=0;i EvtValError EvtPdf::compute_mc_integral(const EvtPdf& pc, int N) { assert(N > 0); - EvtValError otherItg = pc.getItg(); EvtPdfDiv pdfdiv(*this,pc); EvtPdfUnary unary(pdfdiv); EvtPdfGen gen(pc); EvtStreamInputIterator begin = iter(gen,N); EvtStreamInputIterator end; double sum = 0.; double sum2 = 0.; while(!(begin == end)) { double value = pdfdiv.evaluate(*begin++); sum += value; sum2 += value*value; } EvtValError x; if(N > 0) { double av = sum/((double) N); if(N > 1) { double dev2 = (sum2 - av*av*N)/((double) (N - 1)); // Due to numerical precision dev2 may sometimes be negative if(dev2 < 0.) dev2 = 0.; double error = sqrt(dev2/((double) N)); x = EvtValError(av,error); } else x = EvtValError(av); } _itg = x * pc.getItg(); return _itg; } template T EvtPdf::randomPoint() { printf("Function defined for analytic PDFs only\n"); assert(0); T temp; return temp; } template EvtPredGen,EvtPdfPred > EvtPdf::accRejGen(const EvtPdf& pc, int nMax, double factor) { EvtPdfGen gen(pc); EvtPdfDiv pdfdiv(*this,pc); EvtPdfPred pred(pdfdiv); pred.compute_max(iter(gen,nMax),iter(gen),factor); return EvtPredGen,EvtPdfPred >(gen,pred); } #endif diff --git a/EvtGenModels/EvtBTo3hCP.hh b/EvtGenModels/EvtBTo3hCP.hh index e239b5d..b36eba6 100644 --- a/EvtGenModels/EvtBTo3hCP.hh +++ b/EvtGenModels/EvtBTo3hCP.hh @@ -1,122 +1,122 @@ //-------------------------------------------------------------------------- // // Environment: // This software is part of the EvtGen package developed jointly // for the BaBar and CLEO collaborations. If you use all or part // of it, please give an appropriate acknowledgement. // // Copyright Information: See EvtGen/COPYRIGHT // Copyright (C) 1998 Caltech, UCSB // // Module: EvtGen/EvtBTo3hCP.hh // // Description: // // Modification history: // // MK August 26, 2016 Module created // //------------------------------------------------------------------------ #ifndef EVTBTO3HCP_HH #define EVTBTO3HCP_HH #include "EvtGenBase/EvtDecayAmp.hh" #include "EvtGenBase/EvtVector4R.hh" class EvtParticle; /* struct fcomplex { double re; double im; }; */ class EvtBTo3hCP { public: EvtBTo3hCP(); ~EvtBTo3hCP() {}; void EvtKpipi(double alpha, double beta, int iset, EvtVector4R& p_K_plus, EvtVector4R& p_pi_minus, EvtVector4R& p_gamma_1, EvtVector4R& p_gamma_2, double& Real_B0, double& Imag_B0, double& Real_B0bar, double& Imag_B0bar); void Evt3pi(double alpha, int iset, EvtVector4R& p_K_plus, EvtVector4R& p_pi_minus, EvtVector4R& p_gamma_1, EvtVector4R& p_gamma_2, double& Real_B0, double& Imag_B0, double& Real_B0bar, double& Imag_B0bar); void Evt3piMPP(double alpha, int iset, EvtVector4R& p_p1, EvtVector4R& p_p2, EvtVector4R& p_p3, double& Real_B0, double& Imag_B0, double& Real_B0bar, double& Imag_B0bar); void Evt3piP00(double alpha, int iset, EvtVector4R &p_p1, EvtVector4R &p_p1_gamma1, EvtVector4R &p_p1_gamma2, EvtVector4R &p_p2_gamma1, EvtVector4R &p_p2_gamma2, double &Real_B0, double &Imag_B0, double &Real_B0bar, double &Imag_B0bar); private: void setConstants(double balpha, double bbeta); int computeKpipi(EvtVector4R &p1, EvtVector4R &p2, EvtVector4R &p3, double &real_B0, double &imag_B0, double &real_B0bar, double &imag_B0bar, int set); int compute3pi(EvtVector4R &p1, EvtVector4R &p2, EvtVector4R &p3, double &real_B0, double &imag_B0, double &real_B0bar, double &imag_B0bar, int set); int compute3piMPP(EvtVector4R &p1, EvtVector4R &p2, EvtVector4R &p3, double &real_B0, double &imag_B0, double &real_B0bar, double &imag_B0bar, int set); int compute3piP00(EvtVector4R &p1, EvtVector4R &p2, EvtVector4R &p3, double &real_B0, double &imag_B0, double &real_B0bar, double &imag_B0bar, int set); // Modes are : 0 = Kpipi, 1 = 3pi, 2 = MPP, 3 = P00 void firstStep(EvtVector4R &p1, EvtVector4R &p2, EvtVector4R &p3, int mode); void generateSqMasses_Kpipi(double &m12, double &m13, double &m23, double MB2, double m1sq, double m2sq, double m3sq); void generateSqMasses_3pi(double &m12, double &m13, double &m23, double MB2, double m1sq, double m2sq, double m3sq); void generateSqMasses_3piMPP(double &m12, double &m13, double &m23, double MB2, double m1sq, double m2sq, double m3sq); void generateSqMasses_3piP00(double &m12, double &m13, double &m23, double MB2, double m1sq, double m2sq, double m3sq); void rotation(EvtVector4R& p, int newRot); void gammaGamma(EvtVector4R &p, EvtVector4R &pgamma1, EvtVector4R &pgamma2); EvtComplex BreitWigner(EvtVector4R &p1, EvtVector4R &p2, EvtVector4R &p3, int &ierr, double Mass=0, double Width=0); EvtComplex EvtRBW(double s, double Am2, double Gam, double Am2Min); EvtComplex EvtCRhoF_W(double s); EvtComplex EvtcBW_KS(double s, double Am2, double Gam); EvtComplex EvtcBW_GS(double s, double Am2, double Gam); double d(double AmRho2); double k(double s); double Evtfs(double s, double AmRho2, double GamRho); double h(double s); double dh_ds(double s); EvtComplex Mat_S1, Mat_S2, Mat_S3, Mat_S4, Mat_S5, Nat_S1, Nat_S2, Nat_S3, Nat_S4, Nat_S5, MatKstarp, MatKstar0, MatKrho, NatKstarp, NatKstar0, NatKrho; - double alphaCP, betaCP, pi, MA2, MB2, MC2, one, eno, Mass_rho, Gam_rho, M_B, M_pip, - M_pim, M_pi0, DeltaM, Gam_B, xd, M_Upsi, BetaBabar, ptcut, coscut, M_Kp, + double alphaCP, betaCP, pi, MA2, MB2, MC2, Mass_rho, Gam_rho, M_B, M_pip, + M_pim, M_pi0, M_Kp, Mass_Kstarp, Mass_Kstar0, Gam_Kstarp, Gam_Kstar0; double rotMatrix[3][3]; double factor_max; }; #endif diff --git a/EvtGenModels/EvtD0gammaDalitz.hh b/EvtGenModels/EvtD0gammaDalitz.hh index 9add209..e7eac9d 100644 --- a/EvtGenModels/EvtD0gammaDalitz.hh +++ b/EvtGenModels/EvtD0gammaDalitz.hh @@ -1,94 +1,93 @@ //-------------------------------------------------------------------------- // // Module: EvtGen/EvtD0gammaDalitz.hh // // Modification history: // // JGT February 13, 2012 Module created // //------------------------------------------------------------------------ #ifndef __EVTD0GAMMADALITZ_HH__ #define __EVTD0GAMMADALITZ_HH__ #include #include "EvtGenBase/EvtDecayAmp.hh" #include "EvtGenBase/EvtFlatte.hh" #include "EvtGenBase/EvtSpinType.hh" #include "EvtGenBase/EvtDalitzReso.hh" #include "EvtGenBase/EvtCyclic3.hh" class EvtParticle; class EvtD0gammaDalitz : public EvtDecayAmp { private: int _d1; int _d2; int _d3; - int _flag; bool _isKsPiPi; // Useful constants. static const EvtSpinType::spintype& _SCALAR; static const EvtSpinType::spintype& _VECTOR; static const EvtSpinType::spintype& _TENSOR; static const EvtDalitzReso::CouplingType& _EtaPic; static const EvtDalitzReso::CouplingType& _PicPicKK; static const EvtDalitzReso::NumType& _RBW; static const EvtDalitzReso::NumType& _GS; static const EvtDalitzReso::NumType& _KMAT; static const EvtCyclic3::Pair& _AB; static const EvtCyclic3::Pair& _AC; static const EvtCyclic3::Pair& _BC; // Values to be read or computed based on values in the evt.pdl file. // IDs of the relevant particles. EvtId _BP; EvtId _BM; EvtId _B0; EvtId _B0B; EvtId _D0; EvtId _D0B; EvtId _KM; EvtId _KP; EvtId _K0; EvtId _K0B; EvtId _KL; EvtId _KS; EvtId _PIM; EvtId _PIP; // Flavor of the B mother. EvtId _bFlavor; // Masses of the relevant particles. double _mD0; double _mKs; double _mPi; double _mK; void readPDGValues(); void reportInvalidAndExit() const; EvtComplex dalitzKsPiPi( const EvtDalitzPoint& point ) const; EvtComplex dalitzKsKK ( const EvtDalitzPoint& point ) const; public: std::string getName() override; EvtDecayBase* clone() override; void init() override; void initProbMax() override; void decay( EvtParticle* p ) override; }; #endif diff --git a/EvtGenModels/EvtVubAC.hh b/EvtGenModels/EvtVubAC.hh index 69cfe60..4c71e89 100644 --- a/EvtGenModels/EvtVubAC.hh +++ b/EvtGenModels/EvtVubAC.hh @@ -1,70 +1,69 @@ ////////////////////////////////////////////////////////////////////// // // Module: EvtVubAC.hh // ////////////////////////////////////////////////////////////////// #ifndef EVTVUBAC_HH #define EVTVUBAC_HH #include "EvtGenBase/EvtDecayIncoherent.hh" #include class EvtParticle; class EvtVubAC:public EvtDecayIncoherent { public: std::string getName() override; EvtDecayBase* clone() override; void initProbMax() override; void init() override; void decay(EvtParticle *Bmeson) override; private: // Input parameters double mB; - double lambda2; double alphaSmZ; double alphaSmB; double c; double q; double k; double CF; double CA; double beta0; std::vector gvars; double rate(double u, double w, double xb); double wreg(double w); double alphaS(double Q); double PolyLog(double v, double z); double ureg(double u); double ularge(double u); double Coeff(double u, double w, double xb); double Coeff1(double w, double xb); double Coeff0(double w, double xb); double Sigma(double x1, double x2); double max(double ub, double lb); double d1(double u, double w, double xb); double d(double u, double w, double xb); double f(double w); double Lambda2(double x, double alphaSmZ); int Bisect(double x1, double x2,double precision,double& root,const double alphaSmZ); double FindRoot(const double alphaSmZ); }; #endif diff --git a/src/EvtGenModels/Evtbs2llGammaFFMNT.cpp b/src/EvtGenModels/Evtbs2llGammaFFMNT.cpp index eeac4ce..933e0bc 100644 --- a/src/EvtGenModels/Evtbs2llGammaFFMNT.cpp +++ b/src/EvtGenModels/Evtbs2llGammaFFMNT.cpp @@ -1,188 +1,188 @@ //-------------------------------------------------------------------------- // // Environment: // This software is part of the EvtGen package. // // Module: // Description: Form-factors for B_q -> gamma transitions, q={d,s} // according to the papers: // 1) F.Kruger, D.Melikhov, Phys. Rev. D67, 034002, 2003. // 2) D.Melikhov, N.Nikitin, Phys. Rev. D70, 114028, 2004. // 3) I.Balakireva, D.Melikhov, N.Nikitin, D.Tlisov, // Phys. Rev. D81, 054024, 2010. // // Modification history: // // A.Popov October 03, 2008 Module created // N.Nikitin October 10, 2008 Prepare the main classes // A.Popov October 30, 2008 Add the Ftv(0,q^2) and Fta(0,q^2) form-factors // N.Nikitin March 01, 2010 Add the weak annihilation contribution // N.Nikitin July 16, 2010 Has corrected the found bugs // //------------------------------------------------------------------------ #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtComplex.hh" #include "EvtGenBase/EvtVector4C.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtId.hh" #include "EvtGenModels/Evtbs2llGammaFFMNT.hh" #include #include Evtbs2llGammaFFMNT::Evtbs2llGammaFFMNT(){} /* * * decay_id = 0 for b \bar q -> l^+ l^- \gamma transitions * * 1 for q \bar b -> l^+ l^- \gamma transitions; * * fb - leptonic decay constant of the B_q - meson; * * mb - the mass of the b-quark; * * mq - the mass of the light quark (d or s); * * c7gam - Wilson coefficient C_{7\gamma}; * * a1 = c1 + c2/3.0 - linear combination of the Wils. Coeff.; * * lambda_qu = V^*_{uq}*V_{ub}/V^*_{tq}*V_{tb}, where q={d,s}; * * lambda_qc = V^*_{cq}*V_{cb}/V^*_{tq}*V_{tb}, where q={d,s}. * * */ void Evtbs2llGammaFFMNT::getPhotonFF(int decay_id, double fb, EvtId parent, double q2, double M1, double mb, double mq, EvtComplex c7gam, EvtComplex a1, EvtComplex lambda_qu, EvtComplex lambda_qc, EvtComplex& Fv, EvtComplex& Fa, EvtComplex& Ftv, EvtComplex& Fta){ EvtComplex unit1(1.0,0.0); // real unit EvtComplex uniti(0.0,1.0); // imaginary unit EvtComplex unit0(0.0,0.0); // complex zero unit // characteristics of resonances rho, omega, phi double M_res[] = {0.7758, 0.78259, 1.019456}; // particle masses, Gev double Gamma[] = {0.1503, 0.00849, 0.00426}; // particle widthes, Gev double f_lept[] = {5.04, 17.1, -13.2}; // decay constants f_i double g_plus[] = {0.27, -0.27, -0.38}; // and form-factors g+(0) g_plus[0] = g_plus[0]/sqrt(2.0); // by D.Melikhov, N.Nikitin, K.Toms, g_plus[1] = g_plus[1]/sqrt(2.0); // Phys.At.Nucl. 68, p.1842 (2005) double hatq2 = q2/pow(M1,2); // E - photon energy in the B-meson rest frame double E = 0.5*M1*(1-hatq2); // parametrs for form-factors Fv, Ftv, Fa, Fta //(by D.Melikhov, N.Nikitin, K.Toms, Yad. Fiz. 62, No 11) double beta[] = {0.28, 0.30, 0.26, 0.33}; // beta, Gev^(-1) double Delta[] = {0.04, 0.04, 0.30, 0.30}; // Delta, Gev // form-factors EvtComplex Ftvq0, Ftaq0, Ftv00, Fta00; Fv = unit1*beta[0]*fb*M1/(Delta[0]+E); // Fv(q^2) Ftvq0 = unit1*beta[1]*fb*M1/(Delta[1]+E); // Ftv(q^2,0) Fa = unit1*beta[2]*fb*M1/(Delta[2]+E); // Fa(q^2) Ftaq0 = unit1*beta[3]*fb*M1/(Delta[3]+E); // Fta(q^2,0) Ftv00 = unit1*beta[1]*fb*M1/(Delta[1] + 0.5*M1); // Ftv(0,0) Fta00 = unit1*beta[3]*fb*M1/(Delta[3] + 0.5*M1); // Fta(0,0) EvtComplex Ftv_WA(0.0,0.0); // the weak annihilation contribution // Resonant contribution to the form-factors Ftv(0,q^2) and Fta(0,q^2) EvtComplex ResSum(0.0, 0.0); if(parent == EvtPDL::getId(std::string("B_s0"))|| parent == EvtPDL::getId(std::string("anti-B_s0"))){ // only \phi-resonant contribution to the Bs-decays ResSum = 2.0*g_plus[2]*q2/(f_lept[2]*(unit1*(q2-pow(M_res[2],2))+uniti*M_res[2]*Gamma[2])); } if(parent == EvtPDL::getId(std::string("B_d0"))|| parent == EvtPDL::getId(std::string("anti-B_d0"))){ // \rho- and \omega-resonant contribution to the Bd-decays for (int i=0; i<2; i++){ ResSum = ResSum + 2.0*g_plus[i]*q2/(f_lept[i]*(unit1*(q2-pow(M_res[i],2))+uniti*M_res[i]*Gamma[i])); } } EvtComplex Ftv0q = Ftv00 - ResSum; // form-factor Ftv(0,q^2) EvtComplex Fta0q = Fta00 - ResSum; // form-factor Fta(0,q^2) // Ftv(q^2,q^2) = Ftv(q^2,0)+Ftv(0,q^2) Ftv = Ftvq0+Ftv0q; // Fta(q^2,q^2) = Fta(q^2,0)+Fta(0,q^2) Fta = Ftaq0+Fta0q; // Weak annihilation if(abs(c7gam)<0.0000001){ EvtGenReport(EVTGEN_ERROR,"EvtGen") << "\n\n The function Evtbs2llGammaFFMNT::getPhotonFF" << "\n Error: the Wilson coefficient C7gamma = 0!" << " c7gam = " << c7gam << std::endl; ::abort(); } if(mb<0.001){ EvtGenReport(EVTGEN_ERROR,"EvtGen") << "\n\n The function Evtbs2llGammaFFMNT::getPhotonFF" << " mb = " << mb << " << 5 GeV!" << std::endl; ::abort(); } switch(decay_id){ /* b \bar q -> l^+ l^- \gamma transitions */ case 0: Ftv_WA =(16.0/3.0)*(lambda_qu + lambda_qc)*(a1/c7gam)*(fb/mb); Ftv = (1.0 + mq/mb)*Ftv - Ftv_WA; Fta = (1.0 - mq/mb)*Fta; - Fv = Fv; - Fa = Fa; + //Fv = Fv; + //Fa = Fa; break; /* q \bar b -> l^+ l^- \gamma transitions */ case 1: Ftv_WA =(16.0/3.0)*conj(lambda_qu+lambda_qc)*(a1/c7gam)*(fb/mb); Ftv = (1.0 + mq/mb)*Ftv + Ftv_WA; Fta = (1.0 - mq/mb)*Fta; // The change of the sign - Fv = Fv; // is included in the - Fa = Fa; // amplitudes definition! + //Fv = Fv; // is included in the + //Fa = Fa; // amplitudes definition! break; }; } // Getting the quark mass (in GeV) using to the dispersion quark model // of D.Melikhov, B.Stech, PRD62, 014006 (2000). // // i=1 => return m_u; // i=2 => return m_d; // i=3 => return m_s; // i=4 => return m_c; // i=5 => return m_b; double Evtbs2llGammaFFMNT::getQuarkMass(int i){ double qm=0.0; switch(i) { case 1: qm=0.23; // m_u break; case 2: qm=0.23; // m_d = m_u break; case 3: qm=0.35; // m_s break; case 4: qm=1.45; // m_c break; case 5: qm=4.85; // m_b break; default: EvtGenReport(EVTGEN_ERROR,"EvtGen") << "In the function EvtbTosllMSFF::getQuarkMass \n" << "the parametr i not equal 1, 2, 3, 4 or 5! \n" << "i =" << i <