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

EvtDalitzPlot Class Reference

#include <EvtDalitzPlot.hh>

List of all members.

Public Member Functions

double bigM () const
const EvtDalitzPlot * clone () const
double cosTh (EvtCyclic3::Pair i1, double q1, EvtCyclic3::Pair i2, double q2) const
double e (EvtCyclic3::Index i, EvtCyclic3::Pair j, double q) const
 EvtDalitzPlot (const EvtDalitzPlot &other)
 EvtDalitzPlot (const EvtDecayMode &mode, double ldel=0., double rdel=0.)
 EvtDalitzPlot (double mA, double mB, double mC, double bigM, double ldel=0., double rdel=0.)
 EvtDalitzPlot ()
bool fuzzy () const
double getArea (int N=1000, EvtCyclic3::Pair i=EvtCyclic3::AB, EvtCyclic3::Pair j=EvtCyclic3::BC) const
double jacobian (EvtCyclic3::Pair i, double q) const
double m (EvtCyclic3::Index i) const
double mA () const
double mAbsMax (EvtCyclic3::Pair i) const
double mAbsMin (EvtCyclic3::Pair i) const
double mB () const
double mC () const
bool operator== (const EvtDalitzPlot &other) const
double p (EvtCyclic3::Index i, EvtCyclic3::Pair j, double q) const
void print () const
double q (EvtCyclic3::Pair i1, double cosTh, EvtCyclic3::Pair i2, double q2) const
double qAbsMax (EvtCyclic3::Pair i) const
double qAbsMin (EvtCyclic3::Pair i) const
double qHelAbsMax (EvtCyclic3::Pair i) const
double qHelAbsMin (EvtCyclic3::Pair i) const
double qMax (EvtCyclic3::Pair i, EvtCyclic3::Pair j, double q) const
double qMin (EvtCyclic3::Pair i, EvtCyclic3::Pair j, double q) const
double qResAbsMax (EvtCyclic3::Pair i) const
double qResAbsMin (EvtCyclic3::Pair i) const
double qSumMax () const
double qSumMin () const
void sanityCheck () const
double sum () const
EvtTwoBodyVertex vB (EvtCyclic3::Pair iRes, double m0, int L) const
EvtTwoBodyVertex vD (EvtCyclic3::Pair iRes, double m0, int L) const
 ~EvtDalitzPlot ()

Protected Attributes

double _bigM
double _ldel
double _mA
double _mB
double _mC
double _rdel

Constructor & Destructor Documentation

EvtDalitzPlot::EvtDalitzPlot (   ) 
  

00034   : _mA(0.), _mB(0.), _mC(0.), _bigM(0.),
00035     _ldel(0.), _rdel(0.)
00036 {}

EvtDalitzPlot::EvtDalitzPlot (  double  mA,
double  mB,
double  mC,
double  bigM,
double  ldel = 0.,
double  rdel = 0.
) 
  

00041   : _mA(mA), _mB(mB), _mC(mC), _bigM(bigM),
00042     _ldel(ldel), _rdel(rdel) 
00043 {
00044   sanityCheck();
00045 }

EvtDalitzPlot::EvtDalitzPlot (  const EvtDecayMode &  mode,
double  ldel = 0.,
double  rdel = 0.
) 
  

00048 {
00049   _mA = EvtPDL::getMeanMass(EvtPDL::getId(mode.dau(A)));
00050   _mB = EvtPDL::getMeanMass(EvtPDL::getId(mode.dau(B)));
00051   _mC = EvtPDL::getMeanMass(EvtPDL::getId(mode.dau(C)));
00052   _bigM = EvtPDL::getMeanMass(EvtPDL::getId(mode.mother()));
00053 
00054   _ldel = ldel;
00055   _rdel = rdel;
00056   
00057   sanityCheck();
00058 }

EvtDalitzPlot::EvtDalitzPlot (  const EvtDalitzPlot &  other  ) 
  

00062   : _mA(other._mA), _mB(other._mB), _mC(other._mC), _bigM(other._bigM),
00063     _ldel(other._ldel), _rdel(other._rdel)
00064 {}

EvtDalitzPlot::~EvtDalitzPlot (   ) 
  

00068 {}

Member Function Documentation

double EvtDalitzPlot::bigM (   )  const [inline]
  

00092 { return _bigM; }

const EvtDalitzPlot * EvtDalitzPlot::clone (   )  const
  

00084 {
00085   return new EvtDalitzPlot(*this);
00086 }

double EvtDalitzPlot::cosTh (  EvtCyclic3::Pair  i1,
double  q1,
EvtCyclic3::Pair  i2,
double  q2
)  const
  

00261 {
00262   if(i1 == i2) return 1.;
00263   
00264   double qmax = qMax(i1,i2,q2);
00265   double qmin = qMin(i1,i2,q2);
00266   
00267   double cos = (qmax + qmin - 2*q1)/(qmax - qmin);
00268   
00269   return cos;
00270 }

double EvtDalitzPlot::e (  EvtCyclic3::Index  i,
EvtCyclic3::Pair  j,
double  q
)  const
  

00274 {
00275   if(i == other(j)) {
00276  
00277     // i does not belong to pair j
00278 
00279     return (bigM()*bigM()-q-m(i)*m(i))/2/sqrt(q);
00280   }
00281   else {
00282     
00283     // i and k make pair j
00284 
00285     Index k;
00286     if(first(j) == i) k = second(j);
00287     else k = first(j); 
00288 
00289     double e = (q + m(i)*m(i) - m(k)*m(k))/2/sqrt(q);          
00290     return e;
00291   }
00292 }

bool EvtDalitzPlot::fuzzy (   )  const [inline]
  

00055 { return (_rdel - _ldel != 0.); }

double EvtDalitzPlot::getArea (  int  N = 1000,
EvtCyclic3::Pair  i = EvtCyclic3::AB,
EvtCyclic3::Pair  j = EvtCyclic3::BC
)  const
  

00241 {
00242   // Trapezoidal integral over qi. qj can be calculated.
00243   // The first and the last point are zero, so they are not counted
00244 
00245   double dh = (qAbsMax(i) - qAbsMin(i))/((double) N);
00246   double sum = 0;
00247 
00248   int ii;
00249   for(ii=1;ii<N;ii++) {
00250 
00251     double x = qAbsMin(i) + ii*dh;
00252     double dy = qMax(j,i,x) - qMin(j,i,x);
00253     sum += dy;
00254   }
00255 
00256   return sum * dh;
00257 }

double EvtDalitzPlot::jacobian (  EvtCyclic3::Pair  i,
double  q
)  const
  

00320 {
00321   return 2*p(first(i),i,q)*p(other(i),i,q);  // J(BC) = 2pA*pB = 2pA*pC
00322 }

double EvtDalitzPlot::m (  EvtCyclic3::Index  i  )  const
  

00101                                      {
00102 
00103   double m = _mA;
00104   if(i == B) m = _mB;
00105   else
00106     if(i == C) m = _mC;
00107 
00108   return m;
00109 }

double EvtDalitzPlot::mA (   )  const [inline]
  

00093 { return _mA; }

double EvtDalitzPlot::mAbsMax (  EvtCyclic3::Pair  i  )  const
  

00166 {
00167   return sqrt(qAbsMax(i));
00168 }

double EvtDalitzPlot::mAbsMin (  EvtCyclic3::Pair  i  )  const
  

00160 {
00161   return sqrt(qAbsMin(i));
00162 }

double EvtDalitzPlot::mB (   )  const [inline]
  

00094 { return _mB; }

double EvtDalitzPlot::mC (   )  const [inline]
  

00095 { return _mC; }

bool EvtDalitzPlot::operator== (  const EvtDalitzPlot &  other  )  const
  

00072 {
00073   bool ret = false;
00074   if(_mA == other._mA && 
00075      _mB == other._mB &&
00076      _mC == other._mC &&
00077      _bigM == other._bigM) ret = true;
00078 
00079   return ret;
00080 }

double EvtDalitzPlot::p (  EvtCyclic3::Index  i,
EvtCyclic3::Pair  j,
double  q
)  const
  

00296 {
00297   double en = e(i,j,q);
00298   double p2 = en*en - m(i)*m(i);
00299   
00300   if(p2 < 0) {
00301     printf("Bad value of p2 %f %d %d %f %f\n",p2,i,j,en,m(i));
00302     assert(0);
00303   }
00304 
00305   return sqrt(p2);  
00306 }

void EvtDalitzPlot::print (   )  const
  

00339 {
00340   // masses
00341   printf("Mass  M    %f\n",bigM());
00342   printf("Mass mA    %f\n",_mA);
00343   printf("Mass mB    %f\n",_mB);
00344   printf("Mass mC    %f\n",_mC);
00345   // limits
00346   printf("Limits qAB %f : %f\n",qAbsMin(AB),qAbsMax(AB));
00347   printf("Limits qBC %f : %f\n",qAbsMin(BC),qAbsMax(BC));
00348   printf("Limits qCA %f : %f\n",qAbsMin(CA),qAbsMax(CA));
00349   printf("Sum q       %f\n",sum());
00350   printf("Limit qsum  %f : %f\n",qSumMin(),qSumMax());
00351 }

double EvtDalitzPlot::q (  EvtCyclic3::Pair  i1,
double  cosTh,
EvtCyclic3::Pair  i2,
double  q2
)  const
  

00310 {
00311   if(i1 == i2) return q2;
00312 
00313   EvtCyclic3::Index f = first(i1);
00314   EvtCyclic3::Index s = second(i1);
00315   return m(f)*m(f) + m(s)*m(s) + 2*e(f,i2,q2)*e(s,i2,q2) - 2*p(f,i2,q2)*p(s,i2,q2)*cosTh;
00316 }

double EvtDalitzPlot::qAbsMax (  EvtCyclic3::Pair  i  )  const
  

00128 {
00129   Index j = other(i);
00130   return (_bigM-m(j))*(_bigM-m(j));
00131 }

double EvtDalitzPlot::qAbsMin (  EvtCyclic3::Pair  i  )  const
  

00119 {
00120   Index j = first(i);
00121   Index k = second(i);
00122 
00123   return (m(j) + m(k))*(m(j) + m(k));
00124 }

double EvtDalitzPlot::qHelAbsMax (  EvtCyclic3::Pair  i  )  const
  

00152 {
00153   Pair j = next(i);
00154   Pair k = prev(i);
00155   return  (qAbsMax(j) - qAbsMin(k))/2.;
00156 }

double EvtDalitzPlot::qHelAbsMin (  EvtCyclic3::Pair  i  )  const
  

00145 {
00146   Pair j = next(i);
00147   Pair k = prev(i);
00148   return  (qAbsMin(j) - qAbsMax(k))/2.;
00149 }

double EvtDalitzPlot::qMax (  EvtCyclic3::Pair  i,
EvtCyclic3::Pair  j,
double  q
)  const
  

00209 {
00210 
00211   if(i == j) return q;
00212   else {
00213 
00214     // Particle pair j defines the rest-frame
00215     // 0 - particle common to r.f. and angle calculations
00216     // 1 - particle belonging to r.f. but not angle
00217     // 2 - particle not belonging to r.f.
00218     
00219     Index k0 = common(i,j);
00220     Index k2 = other(j);
00221     Index k1 = other(k0,k2); 
00222 
00223     // Energy, momentum of particle common to rest-frame and angle
00224     EvtTwoBodyKine jpair(m(k0),m(k1),sqrt(q)); 
00225     double ek = jpair.e(EvtTwoBodyKine::A,EvtTwoBodyKine::AB);
00226     double pk = jpair.p();
00227 
00228     // Energy and momentum of the other particle
00229     EvtTwoBodyKine mother(sqrt(q),m(k2),bigM());
00230     double ej = mother.e(EvtTwoBodyKine::B,EvtTwoBodyKine::A);
00231     double pj = mother.p(EvtTwoBodyKine::A);
00232 
00233     
00234     // See PDG 34.4.3.1
00235     return (ek+ej)*(ek+ej) - (pk-pj)*(pk-pj);
00236   }
00237 }

double EvtDalitzPlot::qMin (  EvtCyclic3::Pair  i,
EvtCyclic3::Pair  j,
double  q
)  const
  

00174 {
00175   if(i == j) return q;
00176 
00177   else {
00178 
00179     // Particle pair j defines the rest-frame
00180     // 0 - particle common to r.f. and angle calculations
00181     // 1 - particle belonging to r.f. but not angle
00182     // 2 - particle not belonging to r.f.
00183 
00184     Index k0 = common(i,j);
00185     Index k2 = other(j);
00186     Index k1 = other(k0,k2);
00187 
00188     // Energy, momentum of particle common to rest-frame and angle
00189     EvtTwoBodyKine jpair(m(k0),m(k1),sqrt(q)); 
00190     double pk = jpair.p();
00191     double ek = jpair.e(EvtTwoBodyKine::A,EvtTwoBodyKine::AB);
00192 
00193 
00194     // Energy and momentum of the other particle
00195     EvtTwoBodyKine mother(sqrt(q),m(k2),bigM());
00196     double ej = mother.e(EvtTwoBodyKine::B,EvtTwoBodyKine::A);
00197     double pj = mother.p(EvtTwoBodyKine::A);
00198 
00199 
00200     // See PDG 34.4.3.1
00201     return (ek+ej)*(ek+ej) - (pk+pj)*(pk+pj);
00202   }
00203 }

double EvtDalitzPlot::qResAbsMax (  EvtCyclic3::Pair  i  )  const
  

00140 {
00141   return  qAbsMax(i) - sum()/3.;
00142 }

double EvtDalitzPlot::qResAbsMin (  EvtCyclic3::Pair  i  )  const
  

00135 {
00136   return qAbsMin(i) - sum()/3.;
00137 }

double EvtDalitzPlot::qSumMax (   )  const [inline]
  

00054 { return sum() + _rdel; }

double EvtDalitzPlot::qSumMin (   )  const [inline]
  

00053 { return sum() + _ldel; }

void EvtDalitzPlot::sanityCheck (   )  const
  

00090 {
00091   if(_mA < 0 || _mB < 0 || _mC < 0 || _bigM <= 0 || _bigM - _mA - _mB - _mC < 0.) {
00092     
00093     printf("Invalid Dalitz plot %f %f %f %f\n",_mA,_mB,_mC,_bigM);
00094     assert(0);
00095   }
00096   assert(_ldel <= 0.);
00097   assert(_rdel >= 0.);
00098 }

double EvtDalitzPlot::sum (   )  const
  

00113 {
00114   return _mA*_mA + _mB*_mB + _mC*_mC + _bigM*_bigM;
00115 }

EvtTwoBodyVertex EvtDalitzPlot::vB (  EvtCyclic3::Pair  iRes,
double  m0,
int  L
)  const
  

00333 {
00334   return EvtTwoBodyVertex(m0,m(other(iRes)),bigM(),L);
00335 }

EvtTwoBodyVertex EvtDalitzPlot::vD (  EvtCyclic3::Pair  iRes,
double  m0,
int  L
)  const
  

00326 {
00327   return EvtTwoBodyVertex(m(first(iRes)),
00328                           m(second(iRes)),m0,L);
00329 }

Member Data Documentation

double EvtDalitzPlot::_bigM [protected]
 

double EvtDalitzPlot::_ldel [protected]
 

double EvtDalitzPlot::_mA [protected]
 

double EvtDalitzPlot::_mB [protected]
 

double EvtDalitzPlot::_mC [protected]
 

double EvtDalitzPlot::_rdel [protected]
 

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