Line data    Source code

       1             : //--------------------------------------------------------------------------
       2             : //
       3             : // Environment:
       4             : //      This software is part of the EvtGen package developed jointly
       5             : //      for the BaBar and CLEO collaborations.  If you use all or part
       6             : //      of it, please give an appropriate acknowledgement.
       7             : //
       8             : // Copyright Information: See EvtGen/COPYRIGHT
       9             : //      Copyright (C) 2003      Caltech
      10             : //
      11             : // Module: EvtGen/EvtRadiativeBaryonicPenguins.hh
      12             : //
      13             : // Description:Implementation of the decay B- -> lambda p_bar gamma according to
      14             : // Cheng, Yang; hep-ph/0201015
      15             : //
      16             : // Modification history:
      17             : //
      18             : //    JFS     December 16th, 2003         Module created
      19             : //
      20             : //------------------------------------------------------------------------
      21             : #include "EvtGenBase/EvtPatches.hh"
      22             : 
      23             : #include "EvtGenModels/EvtLambdaP_BarGamma.hh"
      24             : #include "EvtGenBase/EvtGammaMatrix.hh"
      25             : #include "EvtGenBase/EvtDiracSpinor.hh"
      26             : #include "EvtGenBase/EvtSpinType.hh"
      27             : #include "EvtGenBase/EvtDiracParticle.hh"
      28             : #include "EvtGenBase/EvtPhotonParticle.hh"
      29             : #include <stdlib.h>
      30             : using std::cout;
      31             : using std::endl;
      32             : 
      33           0 : EvtLambdaP_BarGamma::EvtLambdaP_BarGamma() :
      34           0 :   _mLambdab   ( 5.624),            // Lambda_b mass
      35           0 :   _mLambda0    ( 1.115684),         // Lambda0 mass
      36           0 :   _c7Eff       ( -0.31),            // Wilson coefficient                                      
      37           0 :   _mb          (  4.4),             // running b mass                                          
      38           0 :   _mV          (  5.42),            // pole mass vector current                                
      39           0 :   _mA          (  5.86),            // pole mass axial current                                 
      40           0 :   _GF          (  1.166E-5),        // Fermi constant                                          
      41           0 :   _gLambdab   (  16),               // coupling constant Lambda_b -> B- p
      42           0 :   _e0          (  1),               // electromagnetic coupling (+1)                           
      43           0 :   _g1          (  0.64),            // heavy-light form factors at q_mSqare                    
      44           0 :   _g2          ( -0.10),     
      45           0 :   _f1          (  0.64),
      46           0 :   _f2          ( -0.31),
      47           0 :   _VtbVtsStar ( 0.038)            // |V_tb V_ts^*|
      48           0 : {
      49           0 : }
      50             : 
      51             : 
      52             : 
      53             : std::string EvtLambdaP_BarGamma::getName(){
      54           0 :     return "B_TO_LAMBDA_PBAR_GAMMA";
      55             : }
      56             : 
      57             : EvtDecayBase* EvtLambdaP_BarGamma::clone(){
      58           0 :     return new EvtLambdaP_BarGamma;
      59           0 : }
      60             : 
      61             : void EvtLambdaP_BarGamma::init() {
      62             :     // no arguments, daughter lambda p_bar gamma
      63           0 :     checkNArg(0);
      64           0 :     checkNDaug(3);
      65             :     
      66           0 :     checkSpinParent(EvtSpinType::SCALAR);
      67           0 :     checkSpinDaughter(0, EvtSpinType::DIRAC);
      68           0 :     checkSpinDaughter(1, EvtSpinType::DIRAC);
      69           0 :     checkSpinDaughter(2, EvtSpinType::PHOTON);    
      70           0 : }
      71             : 
      72             : 
      73             : // initialize phasespace and calculate the amplitude
      74             : void EvtLambdaP_BarGamma::decay(EvtParticle* p) {
      75           0 :     EvtComplex I(0, 1);
      76             :     
      77           0 :     p->initializePhaseSpace(getNDaug(), getDaugs());
      78             :     
      79           0 :     EvtDiracParticle* theLambda = static_cast<EvtDiracParticle*>(p->getDaug(0));
      80           0 :     EvtVector4R lambdaMomentum = theLambda->getP4Lab();
      81             :     
      82           0 :     EvtDiracParticle* theAntiP = static_cast<EvtDiracParticle*>(p->getDaug(1));
      83             :     
      84           0 :     EvtPhotonParticle* thePhoton = static_cast<EvtPhotonParticle*>(p->getDaug(2));
      85           0 :     EvtVector4R photonMomentum = thePhoton->getP4Lab();     // get momentum in the same frame
      86             :         
      87             :     // loop over all possible spin states
      88           0 :     for (int i=0; i<2; ++i) {
      89           0 :       EvtDiracSpinor lambdaPol = theLambda->spParent(i);
      90           0 :       for (int j=0; j<2; ++j)  {
      91           0 :         EvtDiracSpinor antiP_Pol = theAntiP->spParent(j);
      92           0 :         for (int k=0; k<2; ++k) {
      93           0 :           EvtVector4C photonPol = thePhoton->epsParentPhoton(k); // one of two possible polarization states
      94           0 :           EvtGammaMatrix photonGamma; // sigma[mu][nu] * epsilon[mu] * k[nu] (watch lower indices)
      95           0 :           for (int mu=0; mu<4; ++mu)
      96           0 :             for (int nu=0; nu<4; ++nu)
      97           0 :               photonGamma += EvtGammaMatrix::sigmaLower(mu, nu) * photonPol.get(mu) * photonMomentum.get(nu);
      98             :           
      99           0 :           EvtComplex amp = 
     100           0 :             -I*_gLambdab * lambdaPol.adjoint() * 
     101           0 :       ((constA()*EvtGammaMatrix::id() + constB()*EvtGammaMatrix::g5())
     102           0 :        * photonGamma * (EvtGenFunctions::slash(lambdaMomentum) + 
     103           0 :                         EvtGenFunctions::slash(photonMomentum) + 
     104           0 :                         _mLambdab*EvtGammaMatrix::id())
     105           0 :        / ((lambdaMomentum + photonMomentum)*(lambdaMomentum + photonMomentum) - _mLambdab*_mLambdab)
     106           0 :        * EvtGammaMatrix::g5() * antiP_Pol);
     107             :           // use of parentheses so I do not have to define EvtDiracSpinor*EvtGammaMatrix, which shouldn't be defined to prevent errors in indexing
     108             : 
     109           0 :           vertex(i, j, k, amp);
     110           0 :         }
     111           0 :       }
     112           0 :     }
     113           0 : }
     114             : 
     115             : void EvtLambdaP_BarGamma::initProbMax()
     116             : {
     117             :     // setProbMax(1);
     118           0 :     setProbMax(9.0000E-13); // found by trial and error
     119           0 : }
     120             : 
     121             : // form factors at 0
     122             : double EvtLambdaP_BarGamma::f0(double fqm, int n) const {
     123           0 :     return fqm * pow(1 - pow(_mLambdab - _mLambda0, 2) / (_mV * _mV), n);
     124             : }
     125             : 
     126             : double EvtLambdaP_BarGamma::g0(double gqm, int n) const {
     127           0 :     return gqm * pow(1 - pow(_mLambdab - _mLambda0, 2) / (_mA * _mA), n);
     128             : }
     129             : 
     130             : double EvtLambdaP_BarGamma::constA() const {
     131           0 :     return _GF/sqrt(2.) * _e0 / (8 * EvtConst::pi*EvtConst::pi) * 2 * _c7Eff * _mb * _VtbVtsStar
     132           0 :         * (f0(_f1) - f0(_f2));
     133             : }
     134             : 
     135             : double EvtLambdaP_BarGamma::constB() const {
     136           0 :     return _GF/sqrt(2.) * _e0 / (8 * EvtConst::pi*EvtConst::pi) * 2 * _c7Eff * _mb * _VtbVtsStar
     137           0 :         * (g0(_g1) - (_mLambdab - _mLambda0) / (_mLambdab + _mLambda0) * g0(_g2));
     138             : }