EvtParticle.hh

//--------------------------------------------------------------------------
//
// 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 <vector>
#include <map>

class EvtDiracSpinor;
class EvtVector4C;
class EvtTensor4C;
class EvtStdHep;
class EvtSecondary;
class EvtRaritaSchwinger;

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 EvtRaritaSchwinger spRSParent(int) const;
  
  virtual EvtRaritaSchwinger spRS(int) 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 makeDaughters(unsigned int ndaug,EvtId *id);

  void makeDaughters(unsigned int ndaug, std::vector<EvtId> idVector);

  double initializePhaseSpace(unsigned int numdaughter,EvtId *daughters,
                              bool forceResetMasses=false,
                              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() const;


  EvtVector4R getP4LabBeforeFSR();
 
  EvtVector4R getP4Restframe() const;

  EvtVector4R get4Pos() const;

  EvtParticle *getParent() const;
  
  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;

  int getPDGId() const;

  EvtSpinType::spintype getSpinType() const;

  int getSpinStates() const;

  const EvtVector4R& getP4() const;

  void setP4(const EvtVector4R& p4){
    _p=p4;
    _pBeforeFSR=p4;
  }

  void setP4WithFSR(const EvtVector4R& p4){
    _p=p4;
  }

  void setFSRP4toZero(){
    _pBeforeFSR.set(0.0,0.0,0.0,0.0);
  }

  int getChannel() const;
  
  size_t getNDaug() const;
  void resetNDaug() {_ndaug=0; return;}

  void printTree() const;

  void printTreeRec(unsigned int level) const;

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

  void printParticle() const;

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

  double getLifetime();

  void setDiagonalSpinDensity();
  
  void setVectorSpinDensity(); 
  
  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);
  bool 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() {EvtGenReport(EVTGEN_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);

  // Return the name of the particle (from the EvtId number)
  std::string getName();
   
  // Specify whether the particle has a special named attribute with 
  // a set value. By default, nothing is set, but derived classes
  // can set this to mean something specific, e.g. if a photon is FSR
  void setAttribute(std::string attName, int attValue) {
      _attributes[attName] = attValue;
  }

  // Retrieve the integer value for the given attribute name
  int getAttribute(std::string attName);

protected:

  void setp( double e, double px, double py, double pz) { 
    _p.set(e,px,py,pz); 
    _pBeforeFSR=_p;
  }

  void setp( const EvtVector4R& p4 ) { 
    _p =p4; 
    _pBeforeFSR=_p;
  }

  void setpart_num(EvtId particle_number ) { 
    assert(_channel==-10||
           _id.getId()==particle_number.getId()||
           _id.getId()==-1);
    _id = particle_number; 
  }
  bool           _validP4;

  // A typedef to define the attribute (name, integer) map
  typedef std::map<std::string, int> EvtAttributeMap;

  EvtAttributeMap _attributes;

private:

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

  //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;

};

#endif