BOSS_7.0.2: /home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Generator/BesEvtGen/BesEvtGen-00-03-58/src/EvtGen/EvtGenModels/EvtD0mixDalitz.cc Source File

00001 /*****************************************************************************
00002  * Project: BaBar detector at the SLAC PEP-II B-factory
00003  * Package: EvtGenModels
00004  *    File: $Id: EvtD0mixDalitz.cc,v 1.1 2009/05/08 01:59:56 pingrg Exp $
00005  *
00006  * Description:
00007  *   The D0mixDalitz model, with many resonances and mixing implemented.
00008  *
00009  * Modification history:
00010  *   Jordi Garra Ticó     2008/07/03         File created
00011  *****************************************************************************/
00012 
00013 #include "EvtGenBase/EvtPatches.hh"
00014 #include "EvtGenBase/EvtParticle.hh"
00015 #include "EvtGenBase/EvtPDL.hh"
00016 #include "EvtGenBase/EvtRandom.hh"
00017 #include "EvtGenBase/EvtResonance.hh"
00018 #include "EvtGenBase/EvtDalitzPlot.hh"
00019 #include "EvtGenBase/EvtDalitzReso.hh"
00020 #include "EvtGenModels/EvtD0mixDalitz.hh"
00021 
00022 
00023 // Initialize the static variables.
00024 const EvtSpinType::spintype& EvtD0mixDalitz::_SCALAR = EvtSpinType::SCALAR;
00025 const EvtSpinType::spintype& EvtD0mixDalitz::_VECTOR = EvtSpinType::VECTOR;
00026 const EvtSpinType::spintype& EvtD0mixDalitz::_TENSOR = EvtSpinType::TENSOR;
00027 
00028 const EvtDalitzReso::CouplingType& EvtD0mixDalitz::_EtaPic   = EvtDalitzReso::EtaPic;
00029 const EvtDalitzReso::CouplingType& EvtD0mixDalitz::_PicPicKK = EvtDalitzReso::PicPicKK;
00030 
00031 const EvtDalitzReso::NumType& EvtD0mixDalitz::_RBW   = EvtDalitzReso::RBW_CLEO_ZEMACH;
00032 const EvtDalitzReso::NumType& EvtD0mixDalitz::_GS    = EvtDalitzReso::GS_CLEO_ZEMACH;
00033 const EvtDalitzReso::NumType& EvtD0mixDalitz::_KMAT  = EvtDalitzReso::K_MATRIX;
00034 
00035 const EvtCyclic3::Pair& EvtD0mixDalitz::_AB = EvtCyclic3::AB;
00036 const EvtCyclic3::Pair& EvtD0mixDalitz::_AC = EvtCyclic3::AC;
00037 const EvtCyclic3::Pair& EvtD0mixDalitz::_BC = EvtCyclic3::BC;
00038 
00039 
00040 void EvtD0mixDalitz::init()
00041 {
00042   // check that there are 0 arguments
00043   checkNDaug( 3 );
00044 
00045   if ( getNArg() )
00046     if ( getNArg() == 2 )
00047       {
00048         _x = getArg( 0 );
00049         _y = getArg( 1 );
00050       }
00051     else if ( getNArg() == 4 )
00052       {
00053         _x = getArg( 0 );
00054         _y = getArg( 1 );
00055         _qp = EvtComplex( getArg( 2 ), getArg( 3 ) );
00056       }
00057     else if ( getNArg() == 5 )
00058       {
00059         _x = getArg( 0 );
00060         _y = getArg( 1 );
00061         _qp = EvtComplex( getArg( 2 ), getArg( 3 ) );
00062         _isRBWmodel = ! getArg( 4 ); // RBW by default. If arg4 is set, do K-matrix.
00063       }
00064     else
00065       {
00066         report( ERROR, "EvtD0mixDalitz" ) << "Number of arguments for this model must be 0, 2, 4 or 5:" << std::endl
00067                                           << "[ x y ][ qp.re qp.im ][ doK-matrix ]" << std::endl
00068                                           << "Check your dec file." << std::endl;
00069         exit( 1 );
00070       }
00071 
00072   checkSpinParent  (    _SCALAR );
00073   checkSpinDaughter( 0, _SCALAR );
00074   checkSpinDaughter( 1, _SCALAR );
00075   checkSpinDaughter( 2, _SCALAR );
00076 
00077   readPDGValues();
00078 
00079   // Get the EvtId of the D0 and its (3) daughters.
00080   EvtId parId = getParentId();
00081 
00082   EvtId dau[ 3 ];
00083   for ( int index = 0; index < 3; index++ )
00084     dau[ index ] = getDaug( index );
00085 
00086   if ( parId == _D0 ) // Look for K0bar h+ h-. The order must be K[0SL] h+ h-
00087     for ( int index = 0; index < 3; index++ )
00088       if      ( ( dau[ index ] == _K0B ) || ( dau[ index ] == _KS ) || ( dau[ index ] == _KL ) )
00089         _d1 = index;
00090       else if ( ( dau[ index ] == _PIP ) || ( dau[ index ] == _KP ) )
00091         _d2 = index;
00092       else if ( ( dau[ index ] == _PIM ) || ( dau[ index ] == _KM ) )
00093         _d3 = index;
00094       else
00095         reportInvalidAndExit();
00096   else if ( parId == _D0B ) // Look for K0 h+ h-. The order must be K[0SL] h- h+
00097     for ( int index = 0; index < 3; index++ )
00098       if      ( ( dau[ index ] == _K0  ) || ( dau[ index ] == _KS ) || ( dau[ index ] == _KL ) )
00099         _d1 = index;
00100       else if ( ( dau[ index ] == _PIM ) || ( dau[ index ] == _KM ) )
00101         _d2 = index;
00102       else if ( ( dau[ index ] == _PIP ) || ( dau[ index ] == _KP ) )
00103         _d3 = index;
00104       else
00105         reportInvalidAndExit();
00106   else
00107     reportInvalidAndExit();
00108 
00109   // Check if we're dealing with Ks pi pi or with Ks K K.
00110   _isKsPiPi = false;
00111   if ( dau[ _d2 ] == _PIP || dau[ _d2 ] == _PIM )
00112     _isKsPiPi = true;
00113 }
00114 
00115 
00116 
00117 void EvtD0mixDalitz::decay( EvtParticle* part )
00118 {
00119   // Same structure for all of these decays.
00120   part->initializePhaseSpace( getNDaug(), getDaugs() );
00121   EvtVector4R pA = part->getDaug( _d1 )->getP4();
00122   EvtVector4R pB = part->getDaug( _d2 )->getP4();
00123   EvtVector4R pC = part->getDaug( _d3 )->getP4();
00124 
00125   // Squared invariant masses.
00126   double m2AB = ( pA + pB ).mass2();
00127   double m2AC = ( pA + pC ).mass2();
00128   double m2BC = ( pB + pC ).mass2();
00129 
00130   // Dalitz amplitudes of the decay of the particle and that of the antiparticle.
00131   EvtComplex ampDalitz;
00132   EvtComplex ampAntiDalitz;
00133 
00134   if ( _isKsPiPi )
00135     { // For Ks pi pi
00136       EvtDalitzPoint point    ( _mKs, _mPi, _mPi, m2AB, m2BC, m2AC );
00137       EvtDalitzPoint antiPoint( _mKs, _mPi, _mPi, m2AC, m2BC, m2AB );
00138 
00139       ampDalitz     = dalitzKsPiPi( point     );
00140       ampAntiDalitz = dalitzKsPiPi( antiPoint );
00141     }
00142   else
00143     { // For Ks K K
00144       EvtDalitzPoint point    ( _mKs, _mK, _mK, m2AB, m2BC, m2AC );
00145       EvtDalitzPoint antiPoint( _mKs, _mK, _mK, m2AC, m2BC, m2AB );
00146 
00147       ampDalitz     = dalitzKsKK( point     );
00148       ampAntiDalitz = dalitzKsKK( antiPoint );
00149     }
00150 
00151   //_i1    += ampDalitz     * conj( ampDalitz     ) / 1.e8;
00152   //_iChi  += ampAntiDalitz * conj( ampDalitz     ) / 1.e8;
00153   //_iChi2 += ampAntiDalitz * conj( ampAntiDalitz ) / 1.e8;
00154 
00155   //std::cout << "INTEGRALS: " << _i1 << " " << _iChi << " " << _iChi2 << " " << _iChi / _i1 << " " << _iChi2 / _i1 << std::endl;
00156 
00157   // Assume there's no direct CP violation.
00158   EvtComplex barAOverA = ampAntiDalitz / ampDalitz;
00159 
00160   // CP violation in the interference. _qp implements CP violation in the mixing.
00161   EvtComplex chi = _qp * barAOverA;
00162 
00163   // Generate a negative exponential life time. p( gt ) = ( 1 - y ) * e^{ - ( 1 - y ) gt }
00164   double gt = -log( EvtRandom::Flat() ) / ( 1. - _y );
00165   part->setLifetime( gt / _gamma );
00166 
00167   // Compute time dependent amplitude.
00168   EvtComplex amp = .5 * ampDalitz * exp( - _y * gt / 2. ) * ( ( 1. + chi ) * h1( gt ) + ( 1. - chi ) * h2( gt ) );
00169 
00170   vertex( amp );
00171 
00172   return;
00173 }
00174 
00175 
00176 void EvtD0mixDalitz::readPDGValues()
00177 {
00178   // Define the EvtIds.
00179   _D0  = EvtPDL::getId( "D0"      );
00180   _D0B = EvtPDL::getId( "anti-D0" );
00181   _KM  = EvtPDL::getId( "K-"      );
00182   _KP  = EvtPDL::getId( "K+"      );
00183   _K0  = EvtPDL::getId( "K0"      );
00184   _K0B = EvtPDL::getId( "anti-K0" );
00185   _KL  = EvtPDL::getId( "K_L0"    );
00186   _KS  = EvtPDL::getId( "K_S0"    );
00187   _PIM = EvtPDL::getId( "pi-"     );
00188   _PIP = EvtPDL::getId( "pi+"     );
00189 
00190   // Read the relevant masses.
00191   _mD0 = EvtPDL::getMass( _D0  );
00192   _mKs = EvtPDL::getMass( _KS  );
00193   _mPi = EvtPDL::getMass( _PIP );
00194   _mK  = EvtPDL::getMass( _KP  );
00195 
00196   // Compute the decay rate from the parameter in the evt.pdl file.
00197   _ctau = EvtPDL::getctau( EvtPDL::getId( "D0" ) );
00198 
00199   //_iChi  = _qp * EvtComplex( 0.089723 , 0.0004776  ); // All resonances RBW, also Rho0.
00200 
00201   //_iChi  = _qp * EvtComplex( 0.0481807, 0.0003043  ); // KStarm only
00202   //_iChi  = _qp * EvtComplex( 0.0594099, 0.00023803 ); // All resonances RBW but GS Rho
00203   //_iChi  = _qp * EvtComplex( 0.0780186, 0.000417646 ); // All resonances for KsKK
00204   //_iChi2 = _qp * 1.;
00205 
00206   /*
00207   // Compute the gamma correction factor avgBeta = Gamma tau.
00208   //    Compute the norm of the unnormalized p(\beta).
00209   double factorY = ( 1. + abs( _iChi2 ) ) / 2. - _y * real( _iChi );
00210   double factorX = ( 1. - abs( _iChi2 ) ) / 2. + _x * imag( _iChi );
00211   double norm = factorY / ( 1. - pow( _y, 2 ) ) + factorX / ( 1. + pow( _x, 2 ) );
00212 
00213   //    Compute the integral of p(\beta) \beta d\beta.
00214   double termY = ( 1. + abs( _iChi2 ) ) / 2. - 2. * _y / ( 1. + pow( _y, 2 ) ) * real( _iChi );
00215   double termX = ( 1. - abs( _iChi2 ) ) / 2. + 2. * _x / ( 1. - pow( _x, 2 ) ) * imag( _iChi );
00216   double quotientY = ( 1. + pow( _y, 2 ) ) / pow( 1. - pow( _y, 2 ), 2 );
00217   double quotientX = ( 1. - pow( _x, 2 ) ) / pow( 1. + pow( _x, 2 ), 2 );
00218   double normTimesAvg = termY * quotientY + termX * quotientX;
00219 
00220   double avgBeta = normTimesAvg / norm;
00221 
00222   _gamma = avgBeta / _ctau;
00223   */
00224 
00225   _gamma = 1. / _ctau; // ALERT: Gamma is not 1 / tau.
00226 }
00227 
00228 
00229 EvtComplex EvtD0mixDalitz::dalitzKsPiPi( const EvtDalitzPoint& point )
00230 {
00231   static const EvtDalitzPlot plot( _mKs, _mPi, _mPi, _mD0 );
00232 
00233   EvtComplex amp = 0.;
00234 
00235   if ( _isRBWmodel )
00236     {
00237       // This corresponds to relativistic Breit-Wigner distributions. Not K-matrix.
00238       // Defining resonances.
00239       static EvtDalitzReso KStarm      ( plot, _BC, _AC, _VECTOR, 0.893606, 0.0463407, _RBW );
00240       static EvtDalitzReso KStarp      ( plot, _BC, _AB, _VECTOR, 0.893606, 0.0463407, _RBW );
00241       static EvtDalitzReso rho0        ( plot, _AC, _BC, _VECTOR, 0.7758  , 0.1464   , _GS  );
00242       static EvtDalitzReso omega       ( plot, _AC, _BC, _VECTOR, 0.78259 , 0.00849  , _RBW );
00243       static EvtDalitzReso f0_980      ( plot, _AC, _BC, _SCALAR, 0.975   , 0.044    , _RBW );
00244       static EvtDalitzReso f0_1370     ( plot, _AC, _BC, _SCALAR, 1.434   , 0.173    , _RBW );
00245       static EvtDalitzReso f2_1270     ( plot, _AC, _BC, _TENSOR, 1.2754  , 0.1851   , _RBW );
00246       static EvtDalitzReso K0Starm_1430( plot, _BC, _AC, _SCALAR, 1.459   , 0.175    , _RBW );
00247       static EvtDalitzReso K0Starp_1430( plot, _BC, _AB, _SCALAR, 1.459   , 0.175    , _RBW );
00248       static EvtDalitzReso K2Starm_1430( plot, _BC, _AC, _TENSOR, 1.4256  , 0.0985   , _RBW );
00249       static EvtDalitzReso K2Starp_1430( plot, _BC, _AB, _TENSOR, 1.4256  , 0.0985   , _RBW );
00250       static EvtDalitzReso sigma       ( plot, _AC, _BC, _SCALAR, 0.527699, 0.511861 , _RBW );
00251       static EvtDalitzReso sigma2      ( plot, _AC, _BC, _SCALAR, 1.03327 , 0.0987890, _RBW );
00252       static EvtDalitzReso KStarm_1680 ( plot, _BC, _AC, _VECTOR, 1.677   , 0.205    , _RBW );
00253 
00254       // Adding terms to the amplitude with their corresponding amplitude and phase terms.
00255       amp += EvtComplex(   .848984 ,   .893618  );
00256       amp += EvtComplex( -1.16356  ,  1.19933   ) * KStarm      .evaluate( point );
00257       amp += EvtComplex(   .106051 , - .118513  ) * KStarp      .evaluate( point );
00258       amp += EvtComplex(  1.0      ,  0.0       ) * rho0        .evaluate( point );
00259       amp += EvtComplex( - .0249569,   .0388072 ) * omega       .evaluate( point );
00260       amp += EvtComplex( - .423586 , - .236099  ) * f0_980      .evaluate( point );
00261       amp += EvtComplex( -2.16486  ,  3.62385   ) * f0_1370     .evaluate( point );
00262       amp += EvtComplex(   .217748 , - .133327  ) * f2_1270     .evaluate( point );
00263       amp += EvtComplex(  1.62128  ,  1.06816   ) * K0Starm_1430.evaluate( point );
00264       amp += EvtComplex(   .148802 ,   .0897144 ) * K0Starp_1430.evaluate( point );
00265       amp += EvtComplex(  1.15489  , - .773363  ) * K2Starm_1430.evaluate( point );
00266       amp += EvtComplex(   .140865 , - .165378  ) * K2Starp_1430.evaluate( point );
00267       amp += EvtComplex( -1.55556  , - .931685  ) * sigma       .evaluate( point );
00268       amp += EvtComplex( - .273791 , - .0535596 ) * sigma2      .evaluate( point );
00269       amp += EvtComplex( -1.69720  ,   .128038  ) * KStarm_1680 .evaluate( point );
00270     }
00271   else
00272     {
00273       // This corresponds to the complete model (RBW, GS, LASS and K-matrix).
00274       // Defining resonances.
00275       static EvtDalitzReso KStarm      ( plot, _BC, _AC, _VECTOR, 0.893619, 0.0466508, _RBW );
00276       static EvtDalitzReso KStarp      ( plot, _BC, _AB, _VECTOR, 0.893619, 0.0466508, _RBW );
00277       static EvtDalitzReso rho0        ( plot, _AC, _BC, _VECTOR, 0.7758  , 0.1464   , _GS  );
00278       static EvtDalitzReso omega       ( plot, _AC, _BC, _VECTOR, 0.78259 , 0.00849  , _RBW );
00279       static EvtDalitzReso f2_1270     ( plot, _AC, _BC, _TENSOR, 1.2754  , 0.1851   , _RBW );
00280       static EvtDalitzReso K0Starm_1430( plot, _AC, 1.46312, 0.232393, 1.0746, -1.83214, .803516, 2.32788, 1., -5.31306 ); // LASS
00281       static EvtDalitzReso K0Starp_1430( plot, _AB, 1.46312, 0.232393, 1.0746, -1.83214, .803516, 2.32788, 1., -5.31306 ); // LASS
00282       static EvtDalitzReso K2Starm_1430( plot, _BC, _AC, _TENSOR, 1.4256  , 0.0985   , _RBW );
00283       static EvtDalitzReso K2Starp_1430( plot, _BC, _AB, _TENSOR, 1.4256  , 0.0985   , _RBW );
00284       static EvtDalitzReso KStarm_1680 ( plot, _BC, _AC, _VECTOR, 1.677   , 0.205    , _RBW );
00285 
00286       // Defining K-matrix.
00287       static EvtComplex fr12( 1.87981, -.628378 );
00288       static EvtComplex fr13( 4.3242 , 2.75019  );
00289       static EvtComplex fr14( 3.22336,  .271048 );
00290       static EvtComplex fr15(  .0    ,  .0      );
00291       static EvtDalitzReso Pole1  ( plot, _BC, "Pole1"  , _KMAT, fr12, fr13, fr14, fr15, -.0694725 );
00292       static EvtDalitzReso Pole2  ( plot, _BC, "Pole2"  , _KMAT, fr12, fr13, fr14, fr15, -.0694725 );
00293       static EvtDalitzReso Pole3  ( plot, _BC, "Pole3"  , _KMAT, fr12, fr13, fr14, fr15, -.0694725 );
00294       static EvtDalitzReso Pole4  ( plot, _BC, "Pole4"  , _KMAT, fr12, fr13, fr14, fr15, -.0694725 );
00295       static EvtDalitzReso kmatrix( plot, _BC, "f11prod", _KMAT, fr12, fr13, fr14, fr15, -.0694725 );
00296 
00297       // Adding terms to the amplitude with their corresponding amplitude and phase terms.
00298       amp += EvtComplex( - 1.31394   ,  1.14072   ) * KStarm      .evaluate( point );
00299       amp += EvtComplex(    .116239  , - .107287  ) * KStarp      .evaluate( point );
00300       amp += EvtComplex(   1.0       ,  0.0       ) * rho0        .evaluate( point );
00301       amp += EvtComplex( -  .0313343 ,   .0424013 ) * omega       .evaluate( point );
00302       amp += EvtComplex(    .559412  , - .232336  ) * f2_1270     .evaluate( point );
00303       amp += EvtComplex(   7.35400   , -3.67637   ) * K0Starm_1430.evaluate( point );
00304       amp += EvtComplex(    .255913  , - .190459  ) * K0Starp_1430.evaluate( point );
00305       amp += EvtComplex(   1.05397   , - .936297  ) * K2Starm_1430.evaluate( point );
00306       amp += EvtComplex( -  .00760136, - .0908624 ) * K2Starp_1430.evaluate( point );
00307       amp += EvtComplex( - 1.45336   , - .164494  ) * KStarm_1680 .evaluate( point );
00308       amp += EvtComplex( - 1.81830   ,  9.10680   ) * Pole1       .evaluate( point );
00309       amp += EvtComplex(  10.1751    ,  3.87961   ) * Pole2       .evaluate( point );
00310       amp += EvtComplex(  23.6569    , -4.94551   ) * Pole3       .evaluate( point );
00311       amp += EvtComplex(    .0725431 , -9.16264   ) * Pole4       .evaluate( point );
00312       amp += EvtComplex( - 2.19449   , -7.62666   ) * kmatrix     .evaluate( point );
00313 
00314       amp *= .97; // Multiply by a constant in order to use the same maximum as RBW model.
00315     }
00316 
00317   return amp;
00318 }
00319 
00320 
00321 EvtComplex EvtD0mixDalitz::dalitzKsKK( const EvtDalitzPoint& point )
00322 {
00323   static const EvtDalitzPlot plot( _mKs, _mK, _mK, _mD0 );
00324 
00325   // Defining resonances.
00326   static EvtDalitzReso a00_980 ( plot, _AC, _BC, _SCALAR, 0.999  , _RBW, .550173, .324, _EtaPic   );
00327   static EvtDalitzReso phi     ( plot, _AC, _BC, _VECTOR, 1.01943,       .00459319    , _RBW      );
00328   static EvtDalitzReso a0p_980 ( plot, _AC, _AB, _SCALAR, 0.999  , _RBW, .550173, .324, _EtaPic   );
00329   static EvtDalitzReso f0_1370 ( plot, _AC, _BC, _SCALAR, 1.350  ,       .265         , _RBW      );
00330   static EvtDalitzReso a0m_980 ( plot, _AB, _AC, _SCALAR, 0.999  , _RBW, .550173, .324, _EtaPic   );
00331   static EvtDalitzReso f0_980  ( plot, _AC, _BC, _SCALAR, 0.965  , _RBW, .695   , .165, _PicPicKK );
00332   static EvtDalitzReso f2_1270 ( plot, _AC, _BC, _TENSOR, 1.2754 ,       .1851        , _RBW      );
00333   static EvtDalitzReso a00_1450( plot, _AC, _BC, _SCALAR, 1.474  ,       .265         , _RBW      );
00334   static EvtDalitzReso a0p_1450( plot, _AC, _AB, _SCALAR, 1.474  ,       .265         , _RBW      );
00335   static EvtDalitzReso a0m_1450( plot, _AB, _AC, _SCALAR, 1.474  ,       .265         , _RBW      );
00336 
00337   // Adding terms to the amplitude with their corresponding amplitude and phase terms.
00338   EvtComplex amp( 0., 0. ); // Phase space amplitude.
00339   amp += EvtComplex( 1.0          , 0.0        ) * a00_980 .evaluate( point );
00340   amp += EvtComplex( -.126314     ,  .188701   ) * phi     .evaluate( point );
00341   amp += EvtComplex( -.561428     ,  .0135338  ) * a0p_980 .evaluate( point );
00342   amp += EvtComplex(  .035        , -.00110488 ) * f0_1370 .evaluate( point );
00343   amp += EvtComplex( -.0872735    ,  .0791190  ) * a0m_980 .evaluate( point );
00344   amp += EvtComplex( 0.           , 0.         ) * f0_980  .evaluate( point );
00345   amp += EvtComplex(  .257341     , -.0408343  ) * f2_1270 .evaluate( point );
00346   amp += EvtComplex( -.0614342    , -.649930   ) * a00_1450.evaluate( point );
00347   amp += EvtComplex( -.104629     ,  .830120   ) * a0p_1450.evaluate( point );
00348   amp += EvtComplex( 0.           , 0.         ) * a0m_1450.evaluate( point );
00349 
00350   return 2.8 * amp; // Multiply by 2.8 in order to reuse the same probmax as Ks pi pi.
00351 }
00352 
00353 
00354 // < f | H | D^0 (t) > = 1/2 * [ ( 1 + \chi_f ) * A_f * e_1(gt) + ( 1 - \chi_f ) * A_f * e_2(gt) ]
00355 // < f | H | D^0 (t) > = 1/2 * exp( -gamma t / 2 ) * [ ( 1 + \chi_f ) * A_f * h_1(t) + ( 1 - \chi_f ) * A_f * h_2(t) ]
00356 // e{1,2}( gt ) = exp( -gt / 2 ) * h{1,2}( gt ).
00357 EvtComplex EvtD0mixDalitz::h1( const double& gt ) const
00358 {
00359   return exp( - EvtComplex( _y, _x ) * gt / 2. );
00360 }
00361 
00362 
00363 EvtComplex EvtD0mixDalitz::h2( const double& gt ) const
00364 {
00365   return exp(   EvtComplex( _y, _x ) * gt / 2. );
00366 }
00367