/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Generator/BesEvtGen/BesEvtGen-00-03-58/src/EvtGen/EvtGenBase/EvtParticle.hh

Go to the documentation of this file.

//--------------------------------------------------------------------------
//
// 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/EvtParticle.hh
//
// Description:Class to describe all particles
//
// Modification history:
//
//    DJL/RYD     Sept. 25, 1996         Module created
//
//------------------------------------------------------------------------

#ifndef EVTPARTICLE_HH
#define EVTPARTICLE_HH

//#include <iostream.h>
#include <assert.h>
#include "EvtGenBase/EvtVector4R.hh"
#include "EvtGenBase/EvtSpinDensity.hh"
#include "EvtGenBase/EvtId.hh"
#include "EvtGenBase/EvtSpinType.hh"
#include <string>
#include "EvtGenModels/EvtGlobalSet.hh"
class EvtDiracSpinor;
class EvtVector4C;
class EvtTensor4C;
class EvtStdHep;
class EvtSecondary;

const int MAX_DAUG =100;
const int MAX_LEVEL=10;
const int MAX_TRIES=10000;

class EvtParticle{

public:

  EvtParticle();

  virtual ~EvtParticle();

  virtual EvtVector4C epsParent(int i) const; 

  virtual EvtVector4C eps(int i) const; 


  virtual EvtVector4C epsParentPhoton(int i); 

  virtual EvtVector4C epsPhoton(int i); 


  virtual EvtDiracSpinor spParent(int) const;

  virtual EvtDiracSpinor sp(int) const;



  virtual EvtDiracSpinor spParentNeutrino() const;

  virtual EvtDiracSpinor spNeutrino() const;
  

  virtual EvtTensor4C epsTensorParent(int i) const; 

  virtual EvtTensor4C epsTensor(int i) const; 

  virtual void init(EvtId part_n,const EvtVector4R& p4)=0;
  
  void addDaug(EvtParticle *node); 
  
  void decay();

  void deleteTree();
  void deleteDaughters(bool keepChannel=false);

  void setChannel( int i );

  void setGeneratorFlag(int flag){_generatorFlag = flag;}

  int getGeneratorFlag(){ return _generatorFlag ;}
  
  void setIntFlag(std::vector<int> vi){
    _intFlag=vi;
  }

  std::vector<int>  getIntFlag(){
    return _intFlag;
  }

  void makeDaughters(int ndaug,EvtId *id);

  double initializePhaseSpace(int numdaughter,EvtId *daughters, 
                            double poleSize=-1., int whichTwo1=0, 
                            int whichTwo2=1); 

  EvtParticle *getDaug(int i);

  EvtParticle *nextIter(EvtParticle *rootOfTree=0);

  void makeStdHep(EvtStdHep& stdhep,
                 EvtSecondary& secondary,EvtId *stable_parent_ihep);
  void makeStdHep(EvtStdHep& stdhep);

  EvtVector4R getP4Lab();

  EvtVector4R getP4Restframe();

  EvtVector4R get4Pos();

  EvtParticle *getParent();
  
  void insertDaugPtr(int idaug,EvtParticle* partptr){ _daug[idaug]=partptr;
                                                 partptr->_parent=this; }
  double mass() const;

  int firstornot() const;
  void setFirstOrNot();
  void resetFirstOrNot();

  EvtId getId() const;

  EvtSpinType::spintype getSpinType() const;

  int getSpinStates() const;

  const EvtVector4R& getP4() const;

  void setP4(const EvtVector4R& p4){_p=p4;}
  
  int getChannel() const;
  
  int getNDaug() const;
  void resetNDaug() {_ndaug=0; return;}

  void printTree() const;

  void printTreeRec(int level) const;
  std::string writeTreeRec(std::string ) const;

  void dumpTree( ) const;
  void dumpTreeRec(int level,int dj) const;

  std::string treeStr() const;
  std::string treeStrRec(int level) const;

  void printParticle() const;

  void setLifetime(double tau);
  
  void setLifetime();

  double getLifetime();

  void setDiagonalSpinDensity();
  
  void setVectorSpinDensity(); 
  
  void setPolarizedSpinDensity(double r00,double r11,double r22); //pingrg for polarized charmonium production 
  void setSpinDensityForward(const EvtSpinDensity& rho){_rhoForward=rho;}

  void setSpinDensityForwardHelicityBasis(const EvtSpinDensity& rho);
  void setSpinDensityForwardHelicityBasis(const EvtSpinDensity& rho,
                                          double alpha,
                                          double beta,
                                          double gamma);
  
  virtual EvtSpinDensity rotateToHelicityBasis() const=0;
  virtual EvtSpinDensity rotateToHelicityBasis(double alpha,
                                               double beta,
                                               double gamma) const=0;

  EvtSpinDensity getSpinDensityForward(){return _rhoForward;}

  void setSpinDensityBackward(const EvtSpinDensity& rho){_rhoBackward=rho;}

  EvtSpinDensity getSpinDensityBackward(){return _rhoBackward;}

  //Hacks will be removed when better solutions are thought of!
  //This is used to suppress use of random numbers when doing initialization
  //of some models.
  void noLifeTime() { _genlifetime=0; }

  //lange - April 29, 2002
  void setId(EvtId id) { _id=id;}
  void initDecay(bool useMinMass=false);
  void generateMassTree();

  double compMassProb();

  //setMass will blow away any existing 4vector
  void setMass(double m) { _p=EvtVector4R(m,0.0,0.0,0.0);}

  //void setMixed() {_mix=true;}
  //void setUnMixed() {_mix=false;}
  //bool getMixed() {return _mix;}

  //void takeCConj() {report(INFO,"EvtGen") << "should take conj\n";}

  //this means that the particle has gone through initDecay
  // and thus has a mass
  bool isInitialized() {return _isInit;}
  bool hasValidP4() {return _validP4;}
  bool isDecayed() {return _isDecayed;}


  // decay prob - only relevent if already decayed
  // and is a scalar particle
  // returned is a double* that should be prob/probMax
  double* decayProb() {return _decayProb;}
  void setDecayProb( double p);

  void setInclusiveMode(int im){_inclusiveMode=im ;}
  int  getInclusiveMode(){return _inclusiveMode;}
  
protected:

  void setp( double e, double px, double py, double pz) { _p.set(e,px,py,pz); }
  void setp( const EvtVector4R& p4 ) { _p =p4; }
  void setpart_num(EvtId particle_number ) 
  { 
    assert(_channel==-10||
           _id.getId()==particle_number.getId()||
           _id.getId()==-1);
    _id = particle_number; 
  }
  bool           _validP4;

private:

  EvtParticle*   _daug[MAX_DAUG];
  int            _ndaug; 
  EvtParticle*   _parent;
  int            _channel; 
  int            _first;
  EvtId          _id;
  EvtVector4R    _p;
  double         _t;
  bool            _isInit;
  bool           _isDecayed;
  int            _generatorFlag;
  //bool _mix;

  EvtSpinDensity _rhoForward;
  EvtSpinDensity _rhoBackward;

  void makeStdHepRec(int firstparent,int lastparent,EvtStdHep& stdhep,
                 EvtSecondary& secondary,EvtId *stable_parent_ihep);
  void makeStdHepRec(int firstparent,int lastparent,EvtStdHep& stdhep);


  //This is a hack until things gets straightened out. (Ryd)
  int         _genlifetime;
  
  //should never be used, therefor is private.
  //these does _not_ have an implementation
  EvtParticle& operator=(const EvtParticle& p);
  EvtParticle(const EvtParticle& p);

  double *_decayProb;

  //Access the inclusive mode for OPENCHARM
  int _inclusiveMode;
  //Set mode index for ConExc
  std::vector<int> _intFlag;


};

std::string IntToStr( int  a); //pingrg, 2008-03-24
#endif

---