[u/mrichter/AliRoot.git] / RICH / AliRICH.h

#ifndef AliRICH_h
#define AliRICH_h

/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

#include <TObjArray.h>
#include <TClonesArray.h>
#include <TLorentzVector.h>
#include <AliDetector.h>
#include <AliHit.h>
#include <AliDigit.h>

#include "AliRICHConst.h"
#include "AliRICHChamber.h"

#include "AliRICHDigit.h"
#include "AliRICHSDigit.h"
#include "AliRICHRawCluster.h"

//__________________AliRICHhit______________________________________________________________________
//__________________________________________________________________________________________________
//__________________________________________________________________________________________________
class AliRICHhit : public AliHit
{
public:
  inline   AliRICHhit();
  inline   AliRICHhit(Int_t fIshunt, Int_t track, Int_t *vol, Float_t *hits);
  inline   AliRICHhit(Int_t track,Int_t iPID,Int_t iChamber,TLorentzVector x4,Float_t eloss);
  virtual ~AliRICHhit()         {;}
    
  Int_t   C()                   {return fChamber;}
  Int_t   Chamber()             {return fChamber;}
  Int_t   Pid()                 {return fPid;}    
  Int_t   Particle()            {return fPid;}
  Float_t Theta()               {return fTheta;}
  Float_t Phi()                 {return fPhi;}
  Float_t Tlength()             {return fTlength;}
  Float_t Eloss()               {return fEloss;}
  Float_t Loss()                {return fLoss;}
  Float_t PHfirst()             {return fPHfirst;}
  Float_t PHlast()              {return fPHlast;}
  Float_t MomX()                {return fMomX;}
  Float_t MomY()                {return fMomY;}
  Float_t MomZ()                {return fMomZ;}
  Float_t CerenkovAngle()       {return fCerenkovAngle;}
  Float_t MomFreoX()            {return fMomFreoX;}
  Float_t MomFreoY()            {return fMomFreoY;}
  Float_t MomFreoZ()            {return fMomFreoZ;}
  void    Print(Option_t *option="")const;      //virtual
protected:
  Int_t     fChamber;                      //chamber number
  Int_t     fPid;                          //particle code
  Float_t   fTheta,fPhi ;                  //incident theta phi angles in degrees
  Float_t   fTlength;                      //track length inside the chamber
  Float_t   fEloss;                        //ionisation energy loss in gas
  Float_t   fPHfirst;                      //first padhit
  Float_t   fPHlast;                       //last padhit
  Float_t   fLoss;                         // did it hit the freon?
  Float_t   fMomX,fMomY,fMomZ;             //momentum at photochatode entry point
  Float_t   fNPads;                        // Pads hit
  Float_t   fCerenkovAngle;                // Dummy cerenkov angle
  Float_t   fMomFreoX,fMomFreoY,fMomFreoZ; //momentum at freon entry point
  ClassDef(AliRICHhit,1)                   //RICH hit class
};//class AliRICHhit

  //__________________________________________________________________________________________________
AliRICHhit::AliRICHhit()
           :AliHit() 
{//default ctor  
  fChamber=fPid=kBad;
  fTheta=fPhi=fTlength=fEloss=fPHfirst=fPHlast=fLoss=kBad;
  fMomX=fMomY=fMomZ=fNPads=fCerenkovAngle=fMomFreoX=fMomFreoY=fMomFreoZ=kBad;
}
//__________________________________________________________________________________________________
AliRICHhit::AliRICHhit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hit):
            AliHit(shunt, track)
{//ctor
  fChamber=vol[0];
  fPid=(Int_t)hit[0];
  fX=hit[1];fY=hit[2];fZ=hit[3];
  fTheta=hit[4];fPhi=hit[5];
  fTlength=hit[6];
  fEloss=hit[7];
  fPHfirst=(Int_t)hit[8];
  fPHlast=(Int_t)hit[9];
  fLoss=hit[13];
  fMomX=hit[14];fMomY=hit[15];fMomZ=hit[16];
  fNPads=hit[17];
  fCerenkovAngle=hit[18];
  fMomFreoX=hit[19];fMomFreoY=hit[20];fMomFreoZ=hit[21];
}
//__________________________________________________________________________________________________
AliRICHhit::AliRICHhit(Int_t track,Int_t iPID,Int_t iChamber,TLorentzVector x4,Float_t eloss):
            AliHit(0, track)
{//ctor
  fChamber=iChamber;
  fPid=iPID;
  fX=x4.X();fY=x4.Y();fZ=x4.Z();
  fEloss=eloss;
}

//__________________AliRICHCerenkov_________________________________________________________________
//__________________________________________________________________________________________________
//__________________________________________________________________________________________________
class AliRICHCerenkov: public AliHit 
{
public:
  inline   AliRICHCerenkov();
  inline   AliRICHCerenkov(Int_t fIshunt, Int_t track, Int_t *vol, Float_t *Cerenkovs);
  virtual ~AliRICHCerenkov() {;}
public:
  Int_t     fChamber;          //chamber number
  Float_t   fTheta,fPhi;       //incident theta phi angles in degrees      
  Float_t   fTlength;          //track length inside the chamber
  Float_t   fEloss;            //ionisation energy loss in gas
  Int_t     fPHfirst;          //first padhit
  Int_t     fPHlast;           //last padhit
  Int_t     fCMother;          //index of mother particle
  Float_t   fLoss;             //nature of particle loss
  Float_t   fIndex;            //index of photon
  Float_t   fProduction;       //point of production
  Float_t   fMomX,fMomY,fMomZ; //local Momentum
  Float_t   fNPads;           // Pads hit
  Float_t   fCerenkovAngle;   // Cerenkov Angle
    
  ClassDef(AliRICHCerenkov,1)  //RICH cerenkov class
};//class AliRICHCerenkov

//__________________________________________________________________________________________________
AliRICHCerenkov::AliRICHCerenkov()
{//ctor
    fChamber=kBad;
    fX=fY=fZ=fTheta=fPhi=fTlength=fEloss=kBad;
    fPHfirst=fPHlast=fCMother=kBad;
    fLoss=fIndex=fProduction=fMomX=fMomY=fMomZ=fNPads=fCerenkovAngle=kBad;
}
//__________________________________________________________________________________________________
AliRICHCerenkov::AliRICHCerenkov(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits)
                :AliHit(shunt, track)
{//ctor
    fChamber=vol[0];
    fX=hits[1];fY=hits[2];fZ=hits[3];
    fTheta=hits[4];fPhi=hits[5];
    fTlength=hits[6];
    fEloss=hits[7];
    fPHfirst=(Int_t)hits[8];fPHlast=(Int_t)hits[9];
    fCMother=Int_t(hits[10]);
    fIndex = hits[11];
    fProduction = hits[12];  
    fLoss=hits[13];
    fMomX=hits[14];fMomY=hits[15];fMomZ=hits[16];
    fNPads=hits[17];
    fCerenkovAngle=hits[18];
}

//__________________AliRICHdigit____________________________________________________________________
//__________________________________________________________________________________________________
//__________________________________________________________________________________________________
class AliRICHdigit :public AliDigit
{
public:
           AliRICHdigit() {fPadX=fPadY=fChamber=fQdc=fTracks[0]=fTracks[1]=fTracks[2]=kBad;}
  inline   AliRICHdigit(Int_t iC,Int_t iX,Int_t iY,Int_t iQdc,Int_t iT1,Int_t iT2,Int_t iT3);
  virtual ~AliRICHdigit() {;}  
  inline   Int_t Compare(const TObject *pObj) const;//virtual
           Bool_t IsSortable()                                 const{return kTRUE;}//virtual
           Int_t C()                                           const{return fChamber;}
           Int_t X()                                           const{return fPadX;}
           Int_t Y()                                           const{return fPadY;}
           Int_t Id()                                          const{return fChamber*1000000+fPadX*1000+fPadY;}
           Int_t Qdc()                                         const{return fQdc;}
           Int_t T(Int_t i)                                    const{return fTracks[i];}
           void  Print(Option_t *option)const;      //virtual
protected:
  Int_t fChamber;  //module number 
  Int_t fPadX;     //pad number along X
  Int_t fPadY;     //pad number along Y
  Int_t fQdc;      //ADC value
  ClassDef(AliRICHdigit,1) //RICH digit class       
};//class AliRICHdigit
//__________________________________________________________________________________________________
AliRICHdigit::AliRICHdigit(Int_t iC,Int_t iX,Int_t iY,Int_t iQdc,Int_t iT0,Int_t iT1,Int_t iT2)
{
  fChamber=iC;fPadX=iX;fPadY=iY;fQdc=iQdc;
  fTracks[0]=iT0;fTracks[1]=iT1;fTracks[2]=iT2;
}
//__________________________________________________________________________________________________
Int_t AliRICHdigit::Compare(const TObject *pObj)const
{
  if(Id()==((AliRICHdigit*)pObj)->Id()) 
    return 0;
  else if(Id()>((AliRICHdigit*)pObj)->Id()) 
    return 1;
  else
    return -1;
} 
//__________________AliRICH_________________________________________________________________________
//__________________________________________________________________________________________________
//__________________________________________________________________________________________________
class AliRICHParam;
class AliRICHSDigit;

class AliRICH : public AliDetector 
{
public:
            AliRICH();                                            
            AliRICH(const char *name, const char *title);         
            AliRICH(const AliRICH& RICH):AliDetector(RICH) {;}   
  virtual  ~AliRICH();                                            
          
  AliRICH&  operator=(const AliRICH&)                 {return *this;}
  virtual Int_t   IsVersion()                                            const =0;            
          void    Hits2SDigits();                                                                                 //virtual
          void    SDigits2Digits();                                                                               //virtual
          void    Digits2Reco();                                                                                  //virtual
  
  inline  void    CreateHits();    
  inline  void    CreateSdigits();  
  inline  void    CreateDigits();  
  inline  void    CreateClusters();  
  inline  void    AddHit(Int_t track, Int_t *vol, Float_t *hits);                                                 //virtual
  inline  void    AddSdigit(Int_t iC,Int_t iX,Int_t iY,Int_t iAdc,Int_t iT0,Int_t iT1=kBad,Int_t iT2=kBad);
  inline  void    AddDigit (Int_t iC,Int_t iX,Int_t iY,Int_t iAdc,Int_t iT0,Int_t iT1=kBad,Int_t iT2=kBad);     
          void    AddCluster()                                                                                {;}     
          void    ResetHits()     {AliDetector::ResetHits();fNcerenkovs=0;if(fCerenkovs)fCerenkovs->Clear();fNspecials=0;if(fSpecials)fSpecials->Clear();}  //virtual
          void    ResetSdigits()  {fNsdigits=0;  if(fSdigits)  fSdigits ->Clear();}                                 
          void    ResetDigits()   {if(fDigitsNew)for(int i=0;i<kNCH;i++){fDigitsNew->At(i)->Clear();fNdigitsNew[i]=0;}}
          void    ResetClusters() {if(fClusters) for(int i=0;i<kNCH;i++){fClusters ->At(i)->Clear();fNclusters[i]=0;}}
                  //Hits provided by AliDetector
  TClonesArray*   Sdigits()             const{return fSdigits;}
  TClonesArray*   Digits(Int_t iC)      const{if(fDigitsNew) return (TClonesArray *)fDigitsNew->At(iC-1);else return 0;}
  TClonesArray*   Clusters(Int_t iC)    const{if(fClusters)  return (TClonesArray *)fClusters->At(iC-1);else return 0;}
          
  AliRICHChamber* C(Int_t iC)           const{return (AliRICHChamber*)fChambers->At(iC-1);}
  AliRICHParam*   Param()               const{return fpParam;}
  
  //  AliRICHhit*     FirstHit(Int_t iTrkN)      {return (AliRICHhit*)AliDetector::FirstHit(iTrkN);}                   //virtual
  //  AliRICHhit*     NextHit()                  {return (AliRICHhit*)AliDetector::NextHit();}                         //virtual 
  
          void    CreateChambers();         
          void    CreateMaterials(); //virtual
  virtual void    BuildGeometry();   //virtual
  virtual void    CreateGeometry();  //virtual
          Float_t AbsoCH4(Float_t x);
          Float_t Fresnel(Float_t ene,Float_t pdoti, Bool_t pola);
  
  virtual void    StepManager()=0;
          void    GenerateFeedbacks(Int_t iChamber,Float_t eloss);
          void    Print(Option_t *option)const;//virtual
          void    MakeBranch(Option_t *opt=" ");
          void    SetTreeAddress();//virtual
// OLD staff OLD staff    
  inline  void    AddCerenkov(Int_t track, Int_t *vol, Float_t *cerenkovs);
  inline  void    AddSpecialOld(Int_t *);      
  inline  void    AddDigitOld(Int_t id, Int_t *tracks, Int_t *charges, Int_t *digits);          
  inline  void    AddClusterOld(Int_t iChamber, const AliRICHRawCluster& cluster);
          
  inline  void    CreateCerenkovsOld();  
  inline  void    CreateSpecialsOld();   
  inline  void    CreateDigitsOld();    
  inline  void    CreateRawClustersOld();  
          void    ResetDigitsOld()  {if(fDchambers)  for(int i=0;i<kNCH;i++){fDchambers->At(i)->Clear();fNdch[i]=0;}}   //virtual
          void    ResetSpecialsOld(){fNspecials=0; if(fSpecials) fSpecials->Clear();}   
          void    ResetRawClusters(){if(fRawClusters)for(int i=0;i<kNCH;i++){fRawClusters->At(i)->Clear();fNrawch[i]=0;}}
  
  TClonesArray*   DigitsOld(Int_t iC)   const{if(fDchambers) return (TClonesArray *)fDchambers->At(iC-1);else return 0;}
  TClonesArray*   ClustersOld(Int_t iC) const{if(fRawClusters)return (TClonesArray *)fRawClusters->At(iC-1);else return 0;}
  TClonesArray*   Specials()            const{return fSpecials;}
  TClonesArray*   Cerenkovs()           const{return fCerenkovs;}
  
  
  AliRICHChamber& Chamber(Int_t id)      {return *((AliRICHChamber *) (*fChambers)[id]);}  
  TObjArray     *Dchambers()                const{return fDchambers;}
  Int_t         *Ndch()                          {return fNdch;}
  TClonesArray  *DigitsAddress(Int_t id)    const{return ((TClonesArray *) (*fDchambers)[id]);}
  TClonesArray  *RawClustAddress(Int_t id)  const{return ((TClonesArray *) (*fRawClusters)[id]);}    
//          Int_t DistancetoPrimitive(Int_t /*px*/, Int_t /*py*/)      {return 9999;}
    
protected:  
  AliRICHParam         *fpParam;             //main RICH parametrization     
  TObjArray            *fChambers;           //list of RICH chambers
                //fHits and fDigits belong to AliDetector
  TClonesArray         *fSdigits;            //! List of sdigits  
  Int_t                 fNsdigits;           //Current number of sdigits
  TObjArray            *fDigitsNew;          //! Each chamber holds it's one lists of digits
  Int_t                 fNdigitsNew[kNCH];   //Array of current numbers of digits
  TObjArray            *fClusters;           //! Each chamber holds it's one lists of clusters 
  Int_t                 fNclusters[kNCH];    //Array of current numbers of raw clusters

  TClonesArray         *fCerenkovs;          //! ??? List of cerenkovs
  Int_t                 fNcerenkovs;         //??? Current number of cerenkovs
  TClonesArray         *fSpecials;           //! ??? List of specials
  Int_t                 fNspecials;          //??? Current number of specials  
  TObjArray            *fDchambers;          //! Array of lists of digits  
  Int_t                 fNdch[kNCH];         //Array of current numbers of digits
  TObjArray            *fRawClusters;        //! Array of lists of raw clusters 
  Int_t                 fNrawch[kNCH];       //Array of current numbers of raw clusters
  Int_t fCkovNumber;                         // Number of Cerenkov photons
  Int_t fFreonProd;                          // Cerenkovs produced in freon
  Int_t fFeedbacks;                          // Number of feedback photons
    
  ClassDef(AliRICH,3)                        //Main RICH class 
};//class AliRICH  
//__________________________________________________________________________________________________
void AliRICH::AddHit(Int_t track, Int_t *vol, Float_t *hits)
{//Adds the current hit to the RICH hits list
  TClonesArray &tmp=*fHits;
  new(tmp[fNhits++])AliRICHhit(fIshunt,track,vol,hits);
}
//__________________________________________________________________________________________________
void AliRICH::AddSdigit(Int_t iC,Int_t iX,Int_t iY,Int_t iAdc,Int_t iT0,Int_t iT1,Int_t iT2)
{//Adds the current Sdigit to the RICH list of Sdigits   
  TClonesArray &tmp=*fSdigits;
  new(tmp[fNsdigits++])AliRICHdigit(iC,iX,iY,iAdc,iT0,iT1,iT2);
} 
//__________________________________________________________________________________________________
void AliRICH::AddDigit(Int_t iC,Int_t iX,Int_t iY,Int_t iAdc,Int_t iT0,Int_t iT1,Int_t iT2)
{//Adds the current digit to the corresponding RICH list of digits (individual list per chamber)
  TClonesArray &tmp=*((TClonesArray*)fDigitsNew->At(iC-1));
  new(tmp[fNdigitsNew[iC-1]++]) AliRICHdigit(iC,iX,iY,iAdc,iT0,iT1,iT2);
}
//__________________________________________________________________________________________________
void AliRICH::CreateHits()
{
  if(fHits) return;
  if(GetDebug())Info("CreateHits","creating hits container.");
  fHits=new TClonesArray("AliRICHhit",10000);   fNhits=0;
}
//__________________________________________________________________________________________________
void AliRICH::CreateSdigits()
{
  if(fSdigits) return;
  if(GetDebug())Info("CreateSdigits","creating sdigits container.");
  fSdigits=new TClonesArray("AliRICHdigit",10000); fNsdigits=0;
}
//__________________________________________________________________________________________________
void AliRICH::CreateDigits()
{
  if(fDigitsNew) return;
  if(GetDebug())Info("CreateDigits","creating digits containers.");
  fDigitsNew = new TObjArray(kNCH);  
  for(Int_t i=0;i<kNCH;i++) {fDigitsNew->AddAt(new TClonesArray("AliRICHdigit",10000), i); fNdigitsNew[i]=0;}
}
//__________________________________________________________________________________________________
void AliRICH::CreateClusters()
{
  if(fClusters) return;
  if(GetDebug())Info("CreateClusters","creating clusters containers.");
  fClusters = new TObjArray(kNCH);  
  for(Int_t i=0;i<kNCH;i++) {fClusters->AddAt(new TClonesArray("AliRICHcluster",10000), i); fNclusters[i]=0;}
}


//__________________________________________________________________________________________________
void AliRICH::CreateCerenkovsOld()
{
  if(fCerenkovs) return;
  if(GetDebug())Info("CreateCerenkovs","creating cerenkovs container.");
  fCerenkovs=new TClonesArray("AliRICHCerenkov",10000);   fNcerenkovs=0;
}
//__________________________________________________________________________________________________
void AliRICH::CreateSpecialsOld()
{
  if(fSpecials) return;
  if(GetDebug())Info("CreateSpecialsOld","creating SDigits special container.");
  fSpecials=new TClonesArray("AliRICHSDigit",100000); fNspecials=0;
}
//__________________________________________________________________________________________________
void AliRICH::CreateDigitsOld()
{
  if(fDchambers) return;
  if(GetDebug())Info("CreateDigitsOld","creating digits containers.");
  fDchambers = new TObjArray(kNCH);  
  for(Int_t i=0;i<kNCH;i++) fDchambers->AddAt(new TClonesArray("AliRICHDigit",10000), i); 
}
//__________________________________________________________________________________________________
void AliRICH::CreateRawClustersOld()
{
  if(fRawClusters) return;
  if(GetDebug())Info("CreateClustersOld","creating clusters containers.");
  fRawClusters = new TObjArray(kNCH);
  for(Int_t i=0; i<kNCH ;i++) fRawClusters->AddAt(new TClonesArray("AliRICHRawCluster",10000), i); 
}
//__________________________________________________________________________________________________
void AliRICH::AddCerenkov(Int_t track, Int_t *vol, Float_t *cerenkovs)
{//Adds the current RICH cerenkov hit to the Cerenkovs list   
  TClonesArray &tmp=*fCerenkovs;
  new(tmp[fNcerenkovs++]) AliRICHCerenkov(fIshunt,track,vol,cerenkovs);
}
//__________________________________________________________________________________________________
void AliRICH::AddSpecialOld(Int_t *aiSDigit)
{// Adds the current Sdigit to the RICH list of Specials
  TClonesArray &lSDigits = *fSpecials;
  new(lSDigits[fNspecials++]) AliRICHSDigit(aiSDigit);
}
//__________________________________________________________________________________________________
void AliRICH::AddDigitOld(Int_t iChamber, Int_t *tracks, Int_t *charges, Int_t *digits)
{// Adds the current digit to the RICH list of S digits
   TClonesArray &ldigits = *((TClonesArray*)fDchambers->At(iChamber-1));
   new(ldigits[fNdch[iChamber-1]++]) AliRICHDigit(tracks,charges,digits);
}
//__________________________________________________________________________________________________
void AliRICH::AddClusterOld(Int_t iChamber, const AliRICHRawCluster& c)
{// Add a RICH raw cluster to the list   
  TClonesArray &tmp= *((TClonesArray*)fRawClusters->At(iChamber-1));
  new(tmp[fNrawch[iChamber-1]++]) AliRICHRawCluster(c);
}
//__________________________________________________________________________________________________
#endif//#ifndef AliRICH_h
Commit	Line	Data
2f614988	1	#ifndef AliRICH_h
2f614988	2	#define AliRICH_h
2e5f0f7b	3
3da30618	4	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	5	* See cxx source for full Copyright notice */
	6
c11ee6f0	7	#include <TObjArray.h>
853634d3	8	#include <TClonesArray.h>
c021cb15	9	#include <TLorentzVector.h>
c11ee6f0	10	#include <AliDetector.h>
853634d3	11	#include <AliHit.h>
853634d3	12	#include <AliDigit.h>
543d5224	13
dfb4e77d	14	#include "AliRICHConst.h"
dfb4e77d	15	#include "AliRICHChamber.h"
853634d3	16
c60862bf	17	#include "AliRICHDigit.h"
c60862bf	18	#include "AliRICHSDigit.h"
543d5224	19	#include "AliRICHRawCluster.h"
853634d3	20
c021cb15	21	//__________________AliRICHhit______________________________________________________________________
	22	//__________________________________________________________________________________________________
	23	//__________________________________________________________________________________________________
853634d3	24	class AliRICHhit : public AliHit
	25	{
	26	public:
	27	inline AliRICHhit();
	28	inline AliRICHhit(Int_t fIshunt, Int_t track, Int_t vol, Float_t hits);
c021cb15	29	inline AliRICHhit(Int_t track,Int_t iPID,Int_t iChamber,TLorentzVector x4,Float_t eloss);
853634d3	30	virtual ~AliRICHhit() {;}
853634d3	31
c60862bf	32	Int_t C() {return fChamber;}
853634d3	33	Int_t Chamber() {return fChamber;}
c60862bf	34	Int_t Pid() {return fPid;}
c60862bf	35	Int_t Particle() {return fPid;}
853634d3	36	Float_t Theta() {return fTheta;}
	37	Float_t Phi() {return fPhi;}
	38	Float_t Tlength() {return fTlength;}
	39	Float_t Eloss() {return fEloss;}
	40	Float_t Loss() {return fLoss;}
c021cb15	41	Float_t PHfirst() {return fPHfirst;}
c021cb15	42	Float_t PHlast() {return fPHlast;}
853634d3	43	Float_t MomX() {return fMomX;}
	44	Float_t MomY() {return fMomY;}
	45	Float_t MomZ() {return fMomZ;}
1774a484	46	Float_t CerenkovAngle() {return fCerenkovAngle;}
	47	Float_t MomFreoX() {return fMomFreoX;}
	48	Float_t MomFreoY() {return fMomFreoY;}
	49	Float_t MomFreoZ() {return fMomFreoZ;}
543d5224	50	void Print(Option_t *option="")const; //virtual
853634d3	51	protected:
c021cb15	52	Int_t fChamber; //chamber number
c60862bf	53	Int_t fPid; //particle code
1774a484	54	Float_t fTheta,fPhi ; //incident theta phi angles in degrees
c021cb15	55	Float_t fTlength; //track length inside the chamber
1774a484	56	Float_t fEloss; //ionisation energy loss in gas
c021cb15	57	Float_t fPHfirst; //first padhit
	58	Float_t fPHlast; //last padhit
	59	Float_t fLoss; // did it hit the freon?
	60	Float_t fMomX,fMomY,fMomZ; //momentum at photochatode entry point
	61	Float_t fNPads; // Pads hit
	62	Float_t fCerenkovAngle; // Dummy cerenkov angle
	63	Float_t fMomFreoX,fMomFreoY,fMomFreoZ; //momentum at freon entry point
	64	ClassDef(AliRICHhit,1) //RICH hit class
853634d3	65	};//class AliRICHhit
c021cb15	66
c021cb15	67	//__________________________________________________________________________________________________
853634d3	68	AliRICHhit::AliRICHhit()
	69	:AliHit()
	70	{//default ctor
c60862bf	71	fChamber=fPid=kBad;
c021cb15	72	fTheta=fPhi=fTlength=fEloss=fPHfirst=fPHlast=fLoss=kBad;
c021cb15	73	fMomX=fMomY=fMomZ=fNPads=fCerenkovAngle=fMomFreoX=fMomFreoY=fMomFreoZ=kBad;
543d5224	74	}
c021cb15	75	//__________________________________________________________________________________________________
c021cb15	76	AliRICHhit::AliRICHhit(Int_t shunt, Int_t track, Int_t vol, Float_t hit):
853634d3	77	AliHit(shunt, track)
	78	{//ctor
	79	fChamber=vol[0];
c60862bf	80	fPid=(Int_t)hit[0];
c021cb15	81	fX=hit[1];fY=hit[2];fZ=hit[3];
	82	fTheta=hit[4];fPhi=hit[5];
	83	fTlength=hit[6];
	84	fEloss=hit[7];
	85	fPHfirst=(Int_t)hit[8];
	86	fPHlast=(Int_t)hit[9];
	87	fLoss=hit[13];
	88	fMomX=hit[14];fMomY=hit[15];fMomZ=hit[16];
	89	fNPads=hit[17];
	90	fCerenkovAngle=hit[18];
	91	fMomFreoX=hit[19];fMomFreoY=hit[20];fMomFreoZ=hit[21];
543d5224	92	}
c021cb15	93	//__________________________________________________________________________________________________
	94	AliRICHhit::AliRICHhit(Int_t track,Int_t iPID,Int_t iChamber,TLorentzVector x4,Float_t eloss):
	95	AliHit(0, track)
	96	{//ctor
	97	fChamber=iChamber;
c60862bf	98	fPid=iPID;
c021cb15	99	fX=x4.X();fY=x4.Y();fZ=x4.Z();
c021cb15	100	fEloss=eloss;
543d5224	101	}
c021cb15	102
	103	//__________________AliRICHCerenkov_________________________________________________________________
	104	//__________________________________________________________________________________________________
	105	//__________________________________________________________________________________________________
853634d3	106	class AliRICHCerenkov: public AliHit
	107	{
	108	public:
	109	inline AliRICHCerenkov();
	110	inline AliRICHCerenkov(Int_t fIshunt, Int_t track, Int_t vol, Float_t Cerenkovs);
	111	virtual ~AliRICHCerenkov() {;}
	112	public:
c021cb15	113	Int_t fChamber; //chamber number
	114	Float_t fTheta,fPhi; //incident theta phi angles in degrees
	115	Float_t fTlength; //track length inside the chamber
	116	Float_t fEloss; //ionisation energy loss in gas
	117	Int_t fPHfirst; //first padhit
	118	Int_t fPHlast; //last padhit
	119	Int_t fCMother; //index of mother particle
	120	Float_t fLoss; //nature of particle loss
	121	Float_t fIndex; //index of photon
	122	Float_t fProduction; //point of production
	123	Float_t fMomX,fMomY,fMomZ; //local Momentum
853634d3	124	Float_t fNPads; // Pads hit
	125	Float_t fCerenkovAngle; // Cerenkov Angle
	126
	127	ClassDef(AliRICHCerenkov,1) //RICH cerenkov class
	128	};//class AliRICHCerenkov
c021cb15	129
c021cb15	130	//__________________________________________________________________________________________________
853634d3	131	AliRICHCerenkov::AliRICHCerenkov()
853634d3	132	{//ctor
c021cb15	133	fChamber=kBad;
	134	fX=fY=fZ=fTheta=fPhi=fTlength=fEloss=kBad;
	135	fPHfirst=fPHlast=fCMother=kBad;
	136	fLoss=fIndex=fProduction=fMomX=fMomY=fMomZ=fNPads=fCerenkovAngle=kBad;
543d5224	137	}
c021cb15	138	//__________________________________________________________________________________________________
853634d3	139	AliRICHCerenkov::AliRICHCerenkov(Int_t shunt, Int_t track, Int_t vol, Float_t hits)
	140	:AliHit(shunt, track)
	141	{//ctor
	142	fChamber=vol[0];
c021cb15	143	fX=hits[1];fY=hits[2];fZ=hits[3];
c021cb15	144	fTheta=hits[4];fPhi=hits[5];
853634d3	145	fTlength=hits[6];
853634d3	146	fEloss=hits[7];
c021cb15	147	fPHfirst=(Int_t)hits[8];fPHlast=(Int_t)hits[9];
853634d3	148	fCMother=Int_t(hits[10]);
	149	fIndex = hits[11];
	150	fProduction = hits[12];
	151	fLoss=hits[13];
c021cb15	152	fMomX=hits[14];fMomY=hits[15];fMomZ=hits[16];
853634d3	153	fNPads=hits[17];
853634d3	154	fCerenkovAngle=hits[18];
543d5224	155	}
c021cb15	156
	157	//__________________AliRICHdigit____________________________________________________________________
	158	//__________________________________________________________________________________________________
	159	//__________________________________________________________________________________________________
853634d3	160	class AliRICHdigit :public AliDigit
	161	{
	162	public:
c60862bf	163	AliRICHdigit() {fPadX=fPadY=fChamber=fQdc=fTracks[0]=fTracks[1]=fTracks[2]=kBad;}
c60862bf	164	inline AliRICHdigit(Int_t iC,Int_t iX,Int_t iY,Int_t iQdc,Int_t iT1,Int_t iT2,Int_t iT3);
853634d3	165	virtual ~AliRICHdigit() {;}
c60862bf	166	inline Int_t Compare(const TObject *pObj) const;//virtual
	167	Bool_t IsSortable() const{return kTRUE;}//virtual
	168	Int_t C() const{return fChamber;}
	169	Int_t X() const{return fPadX;}
	170	Int_t Y() const{return fPadY;}
	171	Int_t Id() const{return fChamber1000000+fPadX1000+fPadY;}
	172	Int_t Qdc() const{return fQdc;}
	173	Int_t T(Int_t i) const{return fTracks[i];}
	174	void Print(Option_t *option)const; //virtual
853634d3	175	protected:
853634d3	176	Int_t fChamber; //module number
c021cb15	177	Int_t fPadX; //pad number along X
c021cb15	178	Int_t fPadY; //pad number along Y
c60862bf	179	Int_t fQdc; //ADC value
853634d3	180	ClassDef(AliRICHdigit,1) //RICH digit class
853634d3	181	};//class AliRICHdigit
c021cb15	182	//__________________________________________________________________________________________________
c60862bf	183	AliRICHdigit::AliRICHdigit(Int_t iC,Int_t iX,Int_t iY,Int_t iQdc,Int_t iT0,Int_t iT1,Int_t iT2)
853634d3	184	{
c60862bf	185	fChamber=iC;fPadX=iX;fPadY=iY;fQdc=iQdc;
853634d3	186	fTracks[0]=iT0;fTracks[1]=iT1;fTracks[2]=iT2;
543d5224	187	}
c60862bf	188	//__________________________________________________________________________________________________
	189	Int_t AliRICHdigit::Compare(const TObject *pObj)const
	190	{
	191	if(Id()==((AliRICHdigit*)pObj)->Id())
	192	return 0;
	193	else if(Id()>((AliRICHdigit*)pObj)->Id())
	194	return 1;
	195	else
	196	return -1;
543d5224	197	}
c021cb15	198	//__________________AliRICH_________________________________________________________________________
	199	//__________________________________________________________________________________________________
	200	//__________________________________________________________________________________________________
3ea9cb08	201	class AliRICHParam;
	202	class AliRICHSDigit;
	203
2f614988	204	class AliRICH : public AliDetector
2f614988	205	{
2f614988	206	public:
853634d3	207	AliRICH();
853634d3	208	AliRICH(const char name, const char title);
942194a4	209	AliRICH(const AliRICH& RICH):AliDetector(RICH) {;}
853634d3	210	virtual ~AliRICH();
dfb4e77d	211
942194a4	212	AliRICH& operator=(const AliRICH&) {return *this;}
c60862bf	213	virtual Int_t IsVersion() const =0;
	214	void Hits2SDigits(); //virtual
	215	void SDigits2Digits(); //virtual
	216	void Digits2Reco(); //virtual
c021cb15	217
c60862bf	218	inline void CreateHits();
	219	inline void CreateSdigits();
	220	inline void CreateDigits();
	221	inline void CreateClusters();
	222	inline void AddHit(Int_t track, Int_t vol, Float_t hits); //virtual
c60862bf	223	inline void AddSdigit(Int_t iC,Int_t iX,Int_t iY,Int_t iAdc,Int_t iT0,Int_t iT1=kBad,Int_t iT2=kBad);
543d5224	224	inline void AddDigit (Int_t iC,Int_t iX,Int_t iY,Int_t iAdc,Int_t iT0,Int_t iT1=kBad,Int_t iT2=kBad);
c60862bf	225	void AddCluster() {;}
543d5224	226	void ResetHits() {AliDetector::ResetHits();fNcerenkovs=0;if(fCerenkovs)fCerenkovs->Clear();fNspecials=0;if(fSpecials)fSpecials->Clear();} //virtual
	227	void ResetSdigits() {fNsdigits=0; if(fSdigits) fSdigits ->Clear();}
	228	void ResetDigits() {if(fDigitsNew)for(int i=0;i<kNCH;i++){fDigitsNew->At(i)->Clear();fNdigitsNew[i]=0;}}
	229	void ResetClusters() {if(fClusters) for(int i=0;i<kNCH;i++){fClusters ->At(i)->Clear();fNclusters[i]=0;}}
c60862bf	230	//Hits provided by AliDetector
c60862bf	231	TClonesArray* Sdigits() const{return fSdigits;}
543d5224	232	TClonesArray* Digits(Int_t iC) const{if(fDigitsNew) return (TClonesArray *)fDigitsNew->At(iC-1);else return 0;}
c60862bf	233	TClonesArray* Clusters(Int_t iC) const{if(fClusters) return (TClonesArray *)fClusters->At(iC-1);else return 0;}
	234
	235	AliRICHChamber* C(Int_t iC) const{return (AliRICHChamber*)fChambers->At(iC-1);}
	236	AliRICHParam* Param() const{return fpParam;}
c021cb15	237
5d12ce38	238	// AliRICHhit* FirstHit(Int_t iTrkN) {return (AliRICHhit*)AliDetector::FirstHit(iTrkN);} //virtual
5d12ce38	239	// AliRICHhit* NextHit() {return (AliRICHhit*)AliDetector::NextHit();} //virtual
c60862bf	240
3ea9cb08	241	void CreateChambers();
c60862bf	242	void CreateMaterials(); //virtual
	243	virtual void BuildGeometry(); //virtual
	244	virtual void CreateGeometry(); //virtual
dfb4e77d	245	Float_t AbsoCH4(Float_t x);
dfb4e77d	246	Float_t Fresnel(Float_t ene,Float_t pdoti, Bool_t pola);
3ea9cb08	247
c021cb15	248	virtual void StepManager()=0;
c60862bf	249	void GenerateFeedbacks(Int_t iChamber,Float_t eloss);
	250	void Print(Option_t *option)const;//virtual
	251	void MakeBranch(Option_t *opt=" ");
	252	void SetTreeAddress();//virtual
543d5224	253	// OLD staff OLD staff
	254	inline void AddCerenkov(Int_t track, Int_t vol, Float_t cerenkovs);
	255	inline void AddSpecialOld(Int_t *);
	256	inline void AddDigitOld(Int_t id, Int_t tracks, Int_t charges, Int_t *digits);
	257	inline void AddClusterOld(Int_t iChamber, const AliRICHRawCluster& cluster);
543d5224	258
	259	inline void CreateCerenkovsOld();
	260	inline void CreateSpecialsOld();
	261	inline void CreateDigitsOld();
	262	inline void CreateRawClustersOld();
543d5224	263	void ResetDigitsOld() {if(fDchambers) for(int i=0;i<kNCH;i++){fDchambers->At(i)->Clear();fNdch[i]=0;}} //virtual
	264	void ResetSpecialsOld(){fNspecials=0; if(fSpecials) fSpecials->Clear();}
	265	void ResetRawClusters(){if(fRawClusters)for(int i=0;i<kNCH;i++){fRawClusters->At(i)->Clear();fNrawch[i]=0;}}
543d5224	266
	267	TClonesArray* DigitsOld(Int_t iC) const{if(fDchambers) return (TClonesArray *)fDchambers->At(iC-1);else return 0;}
	268	TClonesArray* ClustersOld(Int_t iC) const{if(fRawClusters)return (TClonesArray *)fRawClusters->At(iC-1);else return 0;}
	269	TClonesArray* Specials() const{return fSpecials;}
	270	TClonesArray* Cerenkovs() const{return fCerenkovs;}
c60862bf	271
3ea9cb08	272
c60862bf	273
c60862bf	274	AliRICHChamber& Chamber(Int_t id) {return ((AliRICHChamber ) (*fChambers)[id]);}
c60862bf	275	TObjArray *Dchambers() const{return fDchambers;}
3ba5db3e	276	Int_t *Ndch() {return fNdch;}
c60862bf	277	TClonesArray DigitsAddress(Int_t id) const{return ((TClonesArray ) (*fDchambers)[id]);}
3ba5db3e	278	TClonesArray RawClustAddress(Int_t id) const{return ((TClonesArray ) (*fRawClusters)[id]);}
c60862bf	279	// Int_t DistancetoPrimitive(Int_t /px/, Int_t /py/) {return 9999;}
2f614988	280
c60862bf	281	protected:
c021cb15	282	AliRICHParam *fpParam; //main RICH parametrization
c021cb15	283	TObjArray *fChambers; //list of RICH chambers
c60862bf	284	//fHits and fDigits belong to AliDetector
c60862bf	285	TClonesArray *fSdigits; //! List of sdigits
853634d3	286	Int_t fNsdigits; //Current number of sdigits
c60862bf	287	TObjArray *fDigitsNew; //! Each chamber holds it's one lists of digits
	288	Int_t fNdigitsNew[kNCH]; //Array of current numbers of digits
	289	TObjArray *fClusters; //! Each chamber holds it's one lists of clusters
	290	Int_t fNclusters[kNCH]; //Array of current numbers of raw clusters
	291
	292	TClonesArray *fCerenkovs; //! ??? List of cerenkovs
	293	Int_t fNcerenkovs; //??? Current number of cerenkovs
	294	TClonesArray *fSpecials; //! ??? List of specials
	295	Int_t fNspecials; //??? Current number of specials
	296	TObjArray *fDchambers; //! Array of lists of digits
dfb4e77d	297	Int_t fNdch[kNCH]; //Array of current numbers of digits
c60862bf	298	TObjArray *fRawClusters; //! Array of lists of raw clusters
dfb4e77d	299	Int_t fNrawch[kNCH]; //Array of current numbers of raw clusters
dfb4e77d	300	Int_t fCkovNumber; // Number of Cerenkov photons
dfb4e77d	301	Int_t fFreonProd; // Cerenkovs produced in freon
dfb4e77d	302	Int_t fFeedbacks; // Number of feedback photons
ddae0931	303
c60862bf	304	ClassDef(AliRICH,3) //Main RICH class
c60862bf	305	};//class AliRICH
c021cb15	306	//__________________________________________________________________________________________________
853634d3	307	void AliRICH::AddHit(Int_t track, Int_t vol, Float_t hits)
	308	{//Adds the current hit to the RICH hits list
	309	TClonesArray &tmp=*fHits;
	310	new(tmp[fNhits++])AliRICHhit(fIshunt,track,vol,hits);
543d5224	311	}
c60862bf	312	//__________________________________________________________________________________________________
	313	void AliRICH::AddSdigit(Int_t iC,Int_t iX,Int_t iY,Int_t iAdc,Int_t iT0,Int_t iT1,Int_t iT2)
	314	{//Adds the current Sdigit to the RICH list of Sdigits
	315	TClonesArray &tmp=*fSdigits;
	316	new(tmp[fNsdigits++])AliRICHdigit(iC,iX,iY,iAdc,iT0,iT1,iT2);
	317	}
	318	//__________________________________________________________________________________________________
c60862bf	319	void AliRICH::AddDigit(Int_t iC,Int_t iX,Int_t iY,Int_t iAdc,Int_t iT0,Int_t iT1,Int_t iT2)
	320	{//Adds the current digit to the corresponding RICH list of digits (individual list per chamber)
	321	TClonesArray &tmp=((TClonesArray)fDigitsNew->At(iC-1));
	322	new(tmp[fNdigitsNew[iC-1]++]) AliRICHdigit(iC,iX,iY,iAdc,iT0,iT1,iT2);
543d5224	323	}
c60862bf	324	//__________________________________________________________________________________________________
	325	void AliRICH::CreateHits()
	326	{
	327	if(fHits) return;
	328	if(GetDebug())Info("CreateHits","creating hits container.");
	329	fHits=new TClonesArray("AliRICHhit",10000); fNhits=0;
543d5224	330	}
c60862bf	331	//__________________________________________________________________________________________________
	332	void AliRICH::CreateSdigits()
	333	{
	334	if(fSdigits) return;
	335	if(GetDebug())Info("CreateSdigits","creating sdigits container.");
	336	fSdigits=new TClonesArray("AliRICHdigit",10000); fNsdigits=0;
543d5224	337	}
c60862bf	338	//__________________________________________________________________________________________________
	339	void AliRICH::CreateDigits()
	340	{
	341	if(fDigitsNew) return;
	342	if(GetDebug())Info("CreateDigits","creating digits containers.");
	343	fDigitsNew = new TObjArray(kNCH);
	344	for(Int_t i=0;i<kNCH;i++) {fDigitsNew->AddAt(new TClonesArray("AliRICHdigit",10000), i); fNdigitsNew[i]=0;}
543d5224	345	}
c60862bf	346	//__________________________________________________________________________________________________
	347	void AliRICH::CreateClusters()
	348	{
	349	if(fClusters) return;
	350	if(GetDebug())Info("CreateClusters","creating clusters containers.");
	351	fClusters = new TObjArray(kNCH);
	352	for(Int_t i=0;i<kNCH;i++) {fClusters->AddAt(new TClonesArray("AliRICHcluster",10000), i); fNclusters[i]=0;}
543d5224	353	}
c60862bf	354
	355
	356
	357	//__________________________________________________________________________________________________
	358	void AliRICH::CreateCerenkovsOld()
	359	{
	360	if(fCerenkovs) return;
	361	if(GetDebug())Info("CreateCerenkovs","creating cerenkovs container.");
	362	fCerenkovs=new TClonesArray("AliRICHCerenkov",10000); fNcerenkovs=0;
543d5224	363	}
c60862bf	364	//__________________________________________________________________________________________________
	365	void AliRICH::CreateSpecialsOld()
	366	{
	367	if(fSpecials) return;
	368	if(GetDebug())Info("CreateSpecialsOld","creating SDigits special container.");
	369	fSpecials=new TClonesArray("AliRICHSDigit",100000); fNspecials=0;
543d5224	370	}
c60862bf	371	//__________________________________________________________________________________________________
	372	void AliRICH::CreateDigitsOld()
	373	{
	374	if(fDchambers) return;
	375	if(GetDebug())Info("CreateDigitsOld","creating digits containers.");
	376	fDchambers = new TObjArray(kNCH);
	377	for(Int_t i=0;i<kNCH;i++) fDchambers->AddAt(new TClonesArray("AliRICHDigit",10000), i);
543d5224	378	}
c60862bf	379	//__________________________________________________________________________________________________
	380	void AliRICH::CreateRawClustersOld()
	381	{
	382	if(fRawClusters) return;
	383	if(GetDebug())Info("CreateClustersOld","creating clusters containers.");
	384	fRawClusters = new TObjArray(kNCH);
	385	for(Int_t i=0; i<kNCH ;i++) fRawClusters->AddAt(new TClonesArray("AliRICHRawCluster",10000), i);
543d5224	386	}
c60862bf	387	//__________________________________________________________________________________________________
853634d3	388	void AliRICH::AddCerenkov(Int_t track, Int_t vol, Float_t cerenkovs)
	389	{//Adds the current RICH cerenkov hit to the Cerenkovs list
	390	TClonesArray &tmp=*fCerenkovs;
	391	new(tmp[fNcerenkovs++]) AliRICHCerenkov(fIshunt,track,vol,cerenkovs);
	392	}
c021cb15	393	//__________________________________________________________________________________________________
543d5224	394	void AliRICH::AddSpecialOld(Int_t *aiSDigit)
c60862bf	395	{// Adds the current Sdigit to the RICH list of Specials
c60862bf	396	TClonesArray &lSDigits = *fSpecials;
543d5224	397	new(lSDigits[fNspecials++]) AliRICHSDigit(aiSDigit);
543d5224	398	}
c021cb15	399	//__________________________________________________________________________________________________
543d5224	400	void AliRICH::AddDigitOld(Int_t iChamber, Int_t tracks, Int_t charges, Int_t *digits)
c60862bf	401	{// Adds the current digit to the RICH list of S digits
543d5224	402	TClonesArray &ldigits = ((TClonesArray)fDchambers->At(iChamber-1));
	403	new(ldigits[fNdch[iChamber-1]++]) AliRICHDigit(tracks,charges,digits);
	404	}
	405	//__________________________________________________________________________________________________
	406	void AliRICH::AddClusterOld(Int_t iChamber, const AliRICHRawCluster& c)
	407	{// Add a RICH raw cluster to the list
	408	TClonesArray &tmp= ((TClonesArray)fRawClusters->At(iChamber-1));
	409	new(tmp[fNrawch[iChamber-1]++]) AliRICHRawCluster(c);
	410	}
c021cb15	411	//__________________________________________________________________________________________________
c60862bf	412	#endif//#ifndef AliRICH_h