TEvtGen/EvtGen/EvtGenBase/EvtParticle.hh

   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) 1998      Caltech, UCSB
  10 //
  11 // Module: EvtGen/EvtParticle.hh
  12 //
  13 // Description:Class to describe all particles
  14 //
  15 // Modification history:
  16 //
  17 //    DJL/RYD     Sept. 25, 1996         Module created
  18 //
  19 //------------------------------------------------------------------------
  20
  21 #ifndef EVTPARTICLE_HH
  22 #define EVTPARTICLE_HH
  23
  24 //#include <iostream.h>
  25 #include <assert.h>
  26 #include "EvtGenBase/EvtVector4R.hh"
  27 #include "EvtGenBase/EvtSpinDensity.hh"
  28 #include "EvtGenBase/EvtId.hh"
  29 #include "EvtGenBase/EvtSpinType.hh"
  30 #include <string>
  31 #include <vector>
  32
  33 class EvtDiracSpinor;
  34 class EvtVector4C;
  35 class EvtTensor4C;
  36 class EvtStdHep;
  37 class EvtSecondary;
  38 class EvtRaritaSchwinger;
  39
  40 const int MAX_DAUG =100;
  41 const int MAX_LEVEL=10;
  42 const int MAX_TRIES=10000;
  43
  44 class EvtParticle{
  45
  46 public:
  47
  48   /**
  49   * Default constructor.
  50   */
  51   EvtParticle();
  52
  53   /**
  54   * Destructor.
  55   */
  56   virtual ~EvtParticle();
  57
  58   /**
  59   * Returns polarization vector in the parents restframe.
  60   */
  61   virtual EvtVector4C epsParent(int i) const;
  62
  63   /**
  64   * Returns polarization vector in the particles own restframe.
  65   */
  66   virtual EvtVector4C eps(int i) const;
  67
  68
  69   /**
  70   * Returns polarization vector in the parents restframe for a photon.
  71   */
  72   virtual EvtVector4C epsParentPhoton(int i);
  73
  74   /**
  75   * Returns polarization vector in the particles own restframe for a photon.
  76   */
  77   virtual EvtVector4C epsPhoton(int i);
  78
  79
  80   /**
  81   * Returns Dirac spinor in the parents restframe for a Dirac particle.
  82   */
  83   virtual EvtDiracSpinor spParent(int) const;
  84
  85   /**
  86   * Returns Dirac spinor in the particles own restframe for a Dirac particle.
  87   */
  88   virtual EvtDiracSpinor sp(int) const;
  89
  90
  91
  92   /**
  93   * Returns Dirac spinor in the parents restframe for a Neutrino particle.
  94   */
  95   virtual EvtDiracSpinor spParentNeutrino() const;
  96
  97   /**
  98   * Returns Dirac spinor in the particles own restframe for a
  99   * Neutrino particle.
 100   */
 101   virtual EvtDiracSpinor spNeutrino() const;
 102
 103
 104   /**
 105   * Returns tensor in the parents restframe for a spin 2 particle.
 106   */
 107   virtual EvtTensor4C epsTensorParent(int i) const;
 108
 109   /**
 110   * Returns tensor in the particles own restframe for a spin 2 particle.
 111   */
 112   virtual EvtTensor4C epsTensor(int i) const;
 113
 114   /**
 115    * Returns Rarita-Schwinger spinor in the parents restframe for a
 116    * Rarita-Schwinger particle.
 117    */
 118   virtual EvtRaritaSchwinger spRSParent(int) const;
 119
 120   /**
 121    * Returns Rarita-Schwinger spinor in the particles own restframe for a
 122    * Rarita-Schwinger particle.
 123    */
 124   virtual EvtRaritaSchwinger spRS(int) const;
 125
 126
 127
 128   /**
 129   * Initialiaze particle with id and 4momentum.
 130   */
 131   virtual void init(EvtId part_n,const EvtVector4R& p4)=0;
 132
 133   /**
 134   * Add another daughter to the particle
 135   */
 136   void addDaug(EvtParticle *node);
 137
 138   /**
 139   * Decay particle
 140   */
 141   void decay();
 142
 143   /**
 144   * Delete a decay chain
 145   */
 146   void deleteTree();
 147   void deleteDaughters(bool keepChannel=false);
 148
 149   /**
 150   * Should only be used internally.
 151   */
 152   void setChannel( int i );
 153
 154   /**
 155   * Creates the daughters in the list of ids and
 156   * adds them to the parent. Note that momentum
 157   * is left uninitialized, this is _only_ creation.
 158   */
 159   void makeDaughters(unsigned int ndaug,EvtId *id);
 160
 161   /**
 162   * Creates the daughters in the list of ids and
 163   * adds them to the parent. Note that momentum
 164   * is left uninitialized, this is _only_ creation.
 165   */
 166   void makeDaughters(unsigned int ndaug, std::vector<EvtId> idVector);
 167
 168   /**
 169   * Similar to the routine above except that here
 170   * momentum is generated according to phase space
 171   * daughters are filled with this momentum.
 172   */
 173   double initializePhaseSpace(unsigned int numdaughter,EvtId *daughters,
 174                               bool forceResetMasses=false,
 175                               double poleSize=-1., int whichTwo1=0,
 176                               int whichTwo2=1);
 177
 178   /**
 179   * Get pointer the the i:th daugther.
 180   */
 181   EvtParticle *getDaug(int i);
 182
 183   /**
 184   * Iterates over the particles in a decay chain.
 185   */
 186   EvtParticle *nextIter(EvtParticle *rootOfTree=0);
 187
 188   /**
 189   * Makes stdhep list
 190   */
 191   void makeStdHep(EvtStdHep& stdhep,
 192                  EvtSecondary& secondary,EvtId *stable_parent_ihep);
 193   void makeStdHep(EvtStdHep& stdhep);
 194
 195   /**
 196   * Gets 4vector in the labframe, i.e., the frame in which the root
 197   * particles momentum is measured.
 198   */
 199   EvtVector4R getP4Lab() const;
 200
 201
 202   /**
 203   * Gets 4vector in the labframe for the 4-momentum befor FSR was
 204   * generated in the parents decay. The lab frame is where the root
 205   * particles momentum is measured.
 206   */
 207   EvtVector4R getP4LabBeforeFSR();
 208
 209   /**
 210   * Gets 4vector in the particles restframe, i.e. this functiont will
 211   * return (m,0,0,0)
 212   */
 213   EvtVector4R getP4Restframe() const;
 214
 215   /**
 216   * Returns the 4position of the particle in the lab frame.
 217   */
 218   EvtVector4R get4Pos() const;
 219
 220   /**
 221   * Returns pointer to parent particle.
 222   */
 223   EvtParticle *getParent() const;
 224
 225   /**
 226   * Makes partptr the idaug:th daugther.
 227   */
 228   void insertDaugPtr(int idaug,EvtParticle* partptr){ _daug[idaug]=partptr;
 229                                                  partptr->_parent=this; }
 230   /**
 231   * Returns mass of particle.
 232   */
 233   double mass() const;
 234
 235   /**
 236   * Used internally to decide if first time particle is decayed.
 237   */
 238   int firstornot() const;
 239   void setFirstOrNot();
 240   void resetFirstOrNot();
 241
 242   /**
 243   * Returns Id of particle.
 244   */
 245   EvtId getId() const;
 246
 247   /**
 248   * Returns the PDG id of the particle
 249   */
 250
 251   int getPDGId() const;
 252
 253   /**
 254   * Returns particle type.
 255   */
 256
 257   EvtSpinType::spintype getSpinType() const;
 258
 259   /**
 260   * Returns number of spin states of the particle.
 261   */
 262   int getSpinStates() const;
 263
 264   /**
 265   * Returns 4momentum in parents restframe.
 266   */
 267   const EvtVector4R& getP4() const;
 268
 269   /**
 270   * Sets the 4momentum in the parents restframe.
 271   */
 272   void setP4(const EvtVector4R& p4){
 273     _p=p4;
 274     _pBeforeFSR=p4;
 275   }
 276
 277   void setP4WithFSR(const EvtVector4R& p4){
 278     _p=p4;
 279   }
 280
 281   void setFSRP4toZero(){
 282     _pBeforeFSR.set(0.0,0.0,0.0,0.0);
 283   }
 284
 285   /**
 286   * Retunrs the decay channel.
 287   */
 288   int getChannel() const;
 289
 290   /**
 291   * Returns number of daugthers.
 292   */
 293   size_t getNDaug() const;
 294   void resetNDaug() {_ndaug=0; return;}
 295
 296   /**
 297   * Prints out the particle "tree" of a given particle.  The
 298   * tree consists of all daughters (and their daughters, etc)
 299   * and their properties.
 300   */
 301   void printTree() const;
 302
 303   void printTreeRec(unsigned int level) const;
 304
 305   std::string treeStr() const;
 306   std::string treeStrRec(unsigned int level) const;
 307
 308   /**
 309   * Prints information for the particle.
 310   */
 311   void printParticle() const;
 312
 313   /**
 314   * Set lifetime of the particle in parents restframe.
 315   */
 316   void setLifetime(double tau);
 317
 318   /**
 319   * Generate lifetime according to pure exponential.
 320   */
 321   void setLifetime();
 322
 323   /**
 324   * Returns the lifetime.
 325   */
 326   double getLifetime();
 327
 328   /**
 329   * Set diagonal spindensity matrix.
 330   */
 331   void setDiagonalSpinDensity();
 332
 333   /**
 334   * Set spindensity matrix for e+e- -> V
 335   */
 336   void setVectorSpinDensity();
 337
 338   /**
 339   * Set forward spin density matrix.
 340   */
 341   void setSpinDensityForward(const EvtSpinDensity& rho){_rhoForward=rho;}
 342
 343   /**
 344   * Set forward spin density matrix according to the density matrix
 345   * rho in the helicity amplitude basis.
 346   */
 347   void setSpinDensityForwardHelicityBasis(const EvtSpinDensity& rho);
 348   void setSpinDensityForwardHelicityBasis(const EvtSpinDensity& rho,
 349                                           double alpha,
 350                                           double beta,
 351                                           double gamma);
 352
 353   /**
 354   * Returns a rotation matrix need to rotate the basis state
 355   * to the helicity basis. The EvtSpinDensity matrix is just use
 356   * as a matrix here. This function is to be implemented in each
 357   * derived class.
 358   */
 359   virtual EvtSpinDensity rotateToHelicityBasis() const=0;
 360   virtual EvtSpinDensity rotateToHelicityBasis(double alpha,
 361                                                double beta,
 362                                                double gamma) const=0;
 363
 364   /**
 365   * Get forward spin density matrix.
 366   */
 367   EvtSpinDensity getSpinDensityForward(){return _rhoForward;}
 368
 369   /**
 370   * Set backward spin density matrix.
 371   */
 372   void setSpinDensityBackward(const EvtSpinDensity& rho){_rhoBackward=rho;}
 373
 374   /**
 375   * Get backward spin density matrix.
 376   */
 377   EvtSpinDensity getSpinDensityBackward(){return _rhoBackward;}
 378
 379   //Hacks will be removed when better solutions are thought of!
 380   //This is used to suppress use of random numbers when doing initialization
 381   //of some models.
 382   void noLifeTime() { _genlifetime=0; }
 383
 384   //lange - April 29, 2002
 385   void setId(EvtId id) { _id=id;}
 386   void initDecay(bool useMinMass=false);
 387   bool generateMassTree();
 388
 389   double compMassProb();
 390
 391   //setMass will blow away any existing 4vector
 392   void setMass(double m) { _p=EvtVector4R(m,0.0,0.0,0.0);}
 393
 394   //void setMixed() {_mix=true;}
 395   //void setUnMixed() {_mix=false;}
 396   //bool getMixed() {return _mix;}
 397
 398   //void takeCConj() {report(INFO,"EvtGen") << "should take conj\n";}
 399
 400   //this means that the particle has gone through initDecay
 401   // and thus has a mass
 402   bool isInitialized() {return _isInit;}
 403   bool hasValidP4() {return _validP4;}
 404   bool isDecayed() {return _isDecayed;}
 405
 406
 407   // decay prob - only relevent if already decayed
 408   // and is a scalar particle
 409   // returned is a double* that should be prob/probMax
 410   double* decayProb() {return _decayProb;}
 411   void setDecayProb( double p);
 412
 413   // Return the name of the particle (from the EvtId number)
 414   std::string getName();
 415
 416 protected:
 417
 418   void setp( double e, double px, double py, double pz) {
 419     _p.set(e,px,py,pz);
 420     _pBeforeFSR=_p;
 421   }
 422
 423   void setp( const EvtVector4R& p4 ) {
 424     _p =p4;
 425     _pBeforeFSR=_p;
 426   }
 427
 428   void setpart_num(EvtId particle_number ) {
 429     assert(_channel==-10||
 430            _id.getId()==particle_number.getId()||
 431            _id.getId()==-1);
 432     _id = particle_number;
 433   }
 434   bool           _validP4;
 435
 436 private:
 437
 438   EvtParticle*   _daug[MAX_DAUG];
 439   size_t         _ndaug;
 440   EvtParticle*   _parent;
 441   int            _channel;
 442   int            _first;
 443   EvtId          _id;
 444   EvtVector4R    _p;
 445   EvtVector4R    _pBeforeFSR;
 446   double         _t;
 447   bool            _isInit;
 448   bool           _isDecayed;
 449
 450   //bool _mix;
 451
 452   EvtSpinDensity _rhoForward;
 453   EvtSpinDensity _rhoBackward;
 454
 455   void makeStdHepRec(int firstparent,int lastparent,EvtStdHep& stdhep,
 456                  EvtSecondary& secondary,EvtId *stable_parent_ihep);
 457   void makeStdHepRec(int firstparent,int lastparent,EvtStdHep& stdhep);
 458
 459
 460   //This is a hack until things gets straightened out. (Ryd)
 461   int         _genlifetime;
 462
 463   //should never be used, therefor is private.
 464   //these does _not_ have an implementation
 465   EvtParticle& operator=(const EvtParticle& p);
 466   EvtParticle(const EvtParticle& p);
 467
 468   double *_decayProb;
 469
 470 };
 471
 472 #endif
 473