[u/mrichter/AliRoot.git] / PWGPP / TPC / AliMCInfo.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/


///////////////////////////////////////////////////////////////////////////
/*

Origin: marian.ivanov@cern.ch
Container classes with MC infomation

The AliMCInfo contains the information about the particles properties 
during transportation throuch ALICE Detector

The base Information :
TParticle - fParticle             -  properties of the particle at creation point
AliTrackReference - fXXXRefernces -  TClonesArray of refernces in differnt detectors
fNXXXRef                          -  number of the track refernces in differnt detectors
AliTPCdigitRow    - fTPCRow       -  the map of the hitted rows - (will be repalced by TBits)
fRowsWith*                        - number of rows hitted by particle
fMCtracks         -               - number of turn over of the track inside of the TPC

++++
some additional information usable for tree draw - TO SPEED UP tree queries
IMPORTANT FOR PROOF FAST PROTOTYPING ANALYSIS 
                                      

*/

#if !defined(__CINT__) || defined(__MAKECINT__)
#include <stdio.h>
//ROOT includes
#include "Rtypes.h"
#include "TClonesArray.h"
#include "TDatabasePDG.h"
//ALIROOT includes
#include "AliTrackReference.h"
#include "AliMCInfo.h" 
#include "AliMathBase.h" 
#endif

//
// 

ClassImp(AliTPCdigitRow)
ClassImp(AliMCInfo)


////////////////////////////////////////////////////////////////////////
AliMCInfo::AliMCInfo():
  fTrackRef(),
  fTrackRefOut(),
  fTRdecay(),
  fPrimPart(0),
  fParticle(),
  fMass(0),
  fCharge(0),
  fLabel(0),
  fEventNr(),
  fMCtracks(),
  fPdg(0),
  fTPCdecay(0),
  fRowsWithDigitsInn(0),
  fRowsWithDigits(0),
  fRowsTrackLength(0),
  fTPCtrackLength(-1),
  fPrim(0),
  fTPCRow(), 
  fNTPCRef(0),                    // tpc references counter
  fNITSRef(0),                    // ITS references counter
  fNTRDRef(0),                    // TRD references counter
  fNTOFRef(0),                    // TOF references counter
  fNTPCRefOut(0),                    // tpc references counter
  fNITSRefOut(0),                    // ITS references counter
  fNTRDRefOut(0),                    // TRD references counter
  fNTOFRefOut(0),                    // TOF references counter
  fTPCReferences(0),
  fITSReferences(0),
  fTRDReferences(0),
  fTOFReferences(0)
{
  //
  // Default constructor
  //
  fTPCReferences  = new TClonesArray("AliTrackReference",10);
  fITSReferences  = new TClonesArray("AliTrackReference",10);
  fTRDReferences  = new TClonesArray("AliTrackReference",10);
  fTOFReferences  = new TClonesArray("AliTrackReference",10);
  fTRdecay.SetTrack(-1);
  for (Int_t i=0;i<4;i++) fVDist[i]=0;
  for (Int_t i=0;i<3;i++) fDecayCoord[i]=0;
  fCharge = 0;
}

AliMCInfo::AliMCInfo(const AliMCInfo& info):
  TObject(),
  fTrackRef(info.fTrackRef),
  fTrackRefOut(info.fTrackRefOut),
  fTRdecay(info.GetTRdecay()),
  fPrimPart(info.fPrimPart),
  fParticle(info.fParticle),
  fMass(info.GetMass()),
  fCharge(info.fCharge),
  fLabel(info.fLabel),
  fEventNr(info.fEventNr),
  fMCtracks(info.fMCtracks),
  fPdg(info.fPdg),
  fTPCdecay(info.fTPCdecay),
  fRowsWithDigitsInn(info.fRowsWithDigitsInn),
  fRowsWithDigits(info.fRowsWithDigits),
  fRowsTrackLength(info.fRowsTrackLength),
  fTPCtrackLength(info.fTPCtrackLength),
  fPrim(info.fPrim),
  fTPCRow(info.fTPCRow), 
  fNTPCRef(info.fNTPCRef),                    // tpc references counter
  fNITSRef(info.fNITSRef),                    // ITS references counter
  fNTRDRef(info.fNTRDRef),                    // TRD references counter
  fNTOFRef(info.fNTOFRef),                    // TOF references counter
  fNTPCRefOut(info.fNTPCRefOut),                    // tpc references counter
  fNITSRefOut(info.fNITSRefOut),                    // ITS references counter
  fNTRDRefOut(info.fNTRDRefOut),                    // TRD references counter
  fNTOFRefOut(info.fNTOFRefOut),                    // TOF references counter
  fTPCReferences(0),
  fITSReferences(0),
  fTRDReferences(0),
  fTOFReferences(0)
{
  //
  // copy constructor
  //
  fTPCReferences = (TClonesArray*)info.fTPCReferences->Clone();
  fITSReferences = (TClonesArray*)info.fITSReferences->Clone();
  fTRDReferences = (TClonesArray*)info.fTRDReferences->Clone();
  fTOFReferences = (TClonesArray*)info.fTOFReferences->Clone();
  for (Int_t i=0;i<4;i++) fVDist[i]=info.fVDist[i];
  for (Int_t i=0;i<3;i++) fDecayCoord[i]=info.fDecayCoord[i];

}


AliMCInfo& AliMCInfo::operator=(const AliMCInfo& info) { 
  //
  // Assignment operator
  //
  this->~AliMCInfo();
  new (this) AliMCInfo(info);
  return *this;
}


AliMCInfo::~AliMCInfo()
{
  //
  // Destructor of the class
  //
  if (fTPCReferences) {
    delete fTPCReferences;
  }
  if (fITSReferences){
    delete fITSReferences;
  }
  if (fTRDReferences){    
    delete fTRDReferences;  
  }
  if (fTOFReferences){    
    delete fTOFReferences;  
  }

}


void AliMCInfo::Update()
{
  //
  // Update MC info
  // Calculates some derived variables
  //
  //
  fMCtracks =1;
  //
  // decay info
  fTPCdecay=kFALSE;
  if (fTRdecay.GetTrack()>0){
    fDecayCoord[0] = fTRdecay.X();
    fDecayCoord[1] = fTRdecay.Y();
    fDecayCoord[2] = fTRdecay.Z();
    if ( (fTRdecay.R()<250)&&(fTRdecay.R()>85) && (TMath::Abs(fTRdecay.Z())<250) ){
      fTPCdecay=kTRUE;     
    }
    else{
      fDecayCoord[0] = 0;
      fDecayCoord[1] = 0;
      fDecayCoord[2] = 0;
    }
  }
  //
  //
  //digits information update
  fRowsWithDigits    = fTPCRow.RowsOn();    
  fRowsWithDigitsInn = fTPCRow.RowsOn(63); // 63 = number of inner rows
  fRowsTrackLength   = fTPCRow.Last() - fTPCRow.First();
  //
  //
  // calculate primary ionization per cm  
  if (fParticle.GetPDG()){
    fMass = fParticle.GetMass();  
    fCharge = fParticle.GetPDG()->Charge();
    if (fTPCReferences->GetEntriesFast()>0){
      fTrackRef = *((AliTrackReference*)fTPCReferences->At(0));
    }
    if (fMass>0){
      Float_t p = TMath::Sqrt(fTrackRef.Px()*fTrackRef.Px()+
			      fTrackRef.Py()*fTrackRef.Py()+
			      fTrackRef.Pz()*fTrackRef.Pz());    
      if (p>0.001){
	Float_t betagama = p /fMass;
	fPrim = AliMathBase::BetheBlochAleph(betagama);
      }else fPrim=0;
    }
  }else{
    fMass =0;
    fPrim =0;
  }  
  

}


////////////////////////////////////////////////////////////////////////
AliTPCdigitRow::AliTPCdigitRow()
{
  for (Int_t i = 0; i<32; i++) { fDig[i] = 0; }
  Reset();
}
////////////////////////////////////////////////////////////////////////
AliTPCdigitRow & AliTPCdigitRow::operator=(const AliTPCdigitRow &digOld)
{
  for (Int_t i = 0; i<32; i++) fDig[i] = digOld.fDig[i];
  return (*this);
}
////////////////////////////////////////////////////////////////////////
void AliTPCdigitRow::SetRow(Int_t row) 
{
  //
  // set bit mask for given row
  //
  if (row >= 8*32) {
    //    cerr<<"AliTPCdigitRow::SetRow: index "<<row<<" out of bounds."<<endl;
    return;
  }
  Int_t iC = row/8;
  Int_t iB = row%8;
  SETBIT(fDig[iC],iB);
}

////////////////////////////////////////////////////////////////////////
Bool_t AliTPCdigitRow::TestRow(Int_t row) const
{
//
// return kTRUE if row is on
//
  Int_t iC = row/8;
  Int_t iB = row%8;
  return TESTBIT(fDig[iC],iB);
}
////////////////////////////////////////////////////////////////////////
Int_t AliTPCdigitRow::RowsOn(Int_t upto) const
{
//
// returns number of rows with a digit  
// count only rows less equal row number upto
//
  Int_t total = 0;
  for (Int_t i = 0; i<32; i++) {
    for (Int_t j = 0; j < 8; j++) {
      if (i*8+j > upto) return total;
      if (TESTBIT(fDig[i],j))  total++;
    }
  }
  return total;
}
////////////////////////////////////////////////////////////////////////
void AliTPCdigitRow::Reset()
{
//
// resets all rows to zero
//
  for (Int_t i = 0; i<32; i++) {
    //fDig[i] <<= 8;
    fDig[i] = 0;
  }
}
////////////////////////////////////////////////////////////////////////
Int_t AliTPCdigitRow::Last() const
{
//
// returns the last row number with a digit
// returns -1 if now digits 
//
  for (Int_t i = 32-1; i>=0; i--) {
    for (Int_t j = 7; j >= 0; j--) {
      if TESTBIT(fDig[i],j) return i*8+j;
    }
  }
  return -1;
}
////////////////////////////////////////////////////////////////////////
Int_t AliTPCdigitRow::First() const
{
//
// returns the first row number with a digit
// returns -1 if now digits 
//
  for (Int_t i = 0; i<32; i++) {
    for (Int_t j = 0; j < 8; j++) {
      if (TESTBIT(fDig[i],j)) return i*8+j;
    }
  }
  return -1;
}


void AliMCInfo::Clear(Option_t* ){
  //
  // clear the content
  //
  if (fTPCReferences) fTPCReferences->Clear();
  if (fITSReferences) fITSReferences->Clear();
  if (fTRDReferences) fTRDReferences->Clear();
  if (fTOFReferences) fTOFReferences->Clear();
  for (Int_t i=0;i<4;i++) fVDist[i]=0;
  for (Int_t i=0;i<3;i++) fDecayCoord[i]=0;
  fTRdecay.SetTrack(-1);
  fCharge = 0;
  fEventNr=-1;
  fPrimPart=-1;               // index of primary particle in TreeH
  fMass=0;                   // mass of the particle
  fCharge=0;                 // charge of the particle
  fLabel=0;                  // track label
  fEventNr=0;                // event number
  fMCtracks=0;               // indication of how many times the track is retuturned back
  fPdg=0;                        //pdg code
  fTPCdecay=0;                  //indicates decay in TPC
  fRowsWithDigitsInn=0;          // number of rows with digits in the inner sectors
  fRowsWithDigits=0;             // number of rows with digits in the outer sectors
  fRowsTrackLength=0;            // last - first row with digit
  fTPCtrackLength=0;           // distance between first and last track reference
  fPrim=0;                     // theoretical dedx in tpc according particle momenta and mass
  fNTPCRef=0;                    // tpc references counter
  fNITSRef=0;                    // ITS references counter
  fNTRDRef=0;                    // TRD references counter
  fNTOFRef=0;                    // TOF references counter
  //
  fNTPCRefOut=0;                    // tpc references counter - out
  fNITSRefOut=0;                    // ITS references counter - out
  fNTRDRefOut=0;                    // TRD references counter - out
  fNTOFRefOut=0;                    // TOF references counter - out
}


void AliMCInfo::CalcTPCrows(TClonesArray * runArrayTR){
  //
  // Calculates the numebr of the track references for detectors
  // In case of changing direction - curling tracks - the counter is not increasing
  //
  // Rough calculation 
  // of the first and last point in the TPC  
  //
  fNTPCRef = 0;
  fNITSRef = 0;
  fNTRDRef = 0;
  fNTOFRef = 0;  
  fNTPCRefOut = 0;
  fNITSRefOut = 0;
  fNTRDRefOut = 0;
  fNTOFRefOut = 0;  
  //
  //
  Float_t tpcminRadius=TMath::Max(90., fParticle.R());
  Float_t tpcmaxRadius=TMath::Min(250.,fParticle.R());  
  Int_t nover=-1;

  if (runArrayTR->GetEntriesFast()>0){  
    nover=0;
    AliTrackReference *ref0 = (AliTrackReference*)runArrayTR->At(0);    
    Float_t dir = ((ref0->X()*ref0->Px()+ref0->Y()*ref0->Py())>0)? 1.:-1.; //inside or outside
    //
    //    
    for (Int_t iTrackRef = 0; iTrackRef < runArrayTR->GetEntriesFast(); iTrackRef++) {
      //
      AliTrackReference *ref = (AliTrackReference*)runArrayTR->At(iTrackRef);  
      Float_t newdirection = ((ref->X()*ref->Px()+ref->Y()*ref->Py())>0)? 1.:-1.; //inside or outside
      //
      //
      if (dir*newdirection<0.0) {
	nover++;
	dir = newdirection;
      }
      //
      if (ref->DetectorId()== AliTrackReference::kTRD){
	if (nover==0) {
	  tpcmaxRadius =250;
	  fNTRDRefOut++;
	}
	fNTRDRef++;
      }
      if (ref->DetectorId()== AliTrackReference::kITS){ 
	if (nover==0) {
	  fNITSRefOut++;
	  tpcminRadius =90;
	}
	fNITSRef++;
      }
      if (ref->DetectorId()== AliTrackReference::kTOF){
	fNTOFRef++;
	if (nover==0) {
	  fNTOFRefOut++;
	  tpcmaxRadius =250;
	}
      }
      //
      if (ref->DetectorId()== AliTrackReference::kTPC){
	fNTPCRef++;
	if (nover==0) {
	  fNTPCRefOut++;
	  fTrackRefOut = (*ref);
	  if (ref->R()>tpcmaxRadius) tpcmaxRadius = ref->R();
	  if (ref->R()<tpcminRadius) tpcminRadius = ref->R();
	}
      }
      if (ref->DetectorId()== AliTrackReference::kDisappeared){
	if (nover==0 &&TMath::Abs(ref->Z())<250){
	  tpcmaxRadius = TMath::Min(Float_t(250.),ref->R());
	}
      }
    }
  }  // if we have track refs
  fTPCtrackLength = tpcmaxRadius-tpcminRadius;
  fMCtracks=nover+1;
}

//
//
//


void AliMCInfo::Update(TParticle * part, TClonesArray * runArrayTR, Double_t pvertex[4], Int_t label){
  //
  //
  //
  Clear();
  fLabel=label;
  fParticle=(*part);
  AliMCInfo *info = this;
  fVDist[0]=part->Vx()-pvertex[0];
  fVDist[1]=part->Vy()-pvertex[1];
  fVDist[2]=part->Vz()-pvertex[2];
  fVDist[3]=part->R()-pvertex[3];
  //
  //
  //
  for (Int_t iTrackRef = 0; iTrackRef < runArrayTR->GetEntriesFast(); iTrackRef++) {
    AliTrackReference *trackRef = (AliTrackReference*)runArrayTR->At(iTrackRef);         
    if (trackRef->DetectorId()== AliTrackReference::kTPC){     
      TClonesArray & arr = *(info->fTPCReferences);
      new (arr[arr.GetEntriesFast()]) AliTrackReference(*trackRef);     
    }
    if (trackRef->DetectorId()== AliTrackReference::kITS){
      TClonesArray & arr = *(info->fITSReferences);
      new (arr[arr.GetEntriesFast()]) AliTrackReference(*trackRef);     
    }
    if (trackRef->DetectorId()== AliTrackReference::kTRD){
      TClonesArray & arr = *(info->fTRDReferences);
      new (arr[arr.GetEntriesFast()]) AliTrackReference(*trackRef);     
    }
    if (trackRef->DetectorId()== AliTrackReference::kTOF){
      TClonesArray & arr = *(info->fTOFReferences);
      new (arr[arr.GetEntriesFast()]) AliTrackReference(*trackRef);     
    }
    //
    // decay case
    //
    if (trackRef->DetectorId()== AliTrackReference::kDisappeared){
      info->fTRdecay = *trackRef;      	
    }
  }
  //
  Update();
  CalcTPCrows(runArrayTR);
}
Commit	Line	Data
7cc34f08	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16
	17	///////////////////////////////////////////////////////////////////////////
	18	/*
	19
	20	Origin: marian.ivanov@cern.ch
	21	Container classes with MC infomation
	22
	23	The AliMCInfo contains the information about the particles properties
	24	during transportation throuch ALICE Detector
	25
	26	The base Information :
	27	TParticle - fParticle - properties of the particle at creation point
	28	AliTrackReference - fXXXRefernces - TClonesArray of refernces in differnt detectors
	29	fNXXXRef - number of the track refernces in differnt detectors
	30	AliTPCdigitRow - fTPCRow - the map of the hitted rows - (will be repalced by TBits)
	31	fRowsWith* - number of rows hitted by particle
	32	fMCtracks - - number of turn over of the track inside of the TPC
	33
	34	++++
	35	some additional information usable for tree draw - TO SPEED UP tree queries
	36	IMPORTANT FOR PROOF FAST PROTOTYPING ANALYSIS
	37
	38
	39
	40
	41	*/
	42
	43	#if !defined(__CINT__) \|\| defined(__MAKECINT__)
	44	#include <stdio.h>
	45	//ROOT includes
	46	#include "Rtypes.h"
	47	#include "TClonesArray.h"
	48	#include "TDatabasePDG.h"
	49	//ALIROOT includes
	50	#include "AliTrackReference.h"
	51	#include "AliMCInfo.h"
	52	#include "AliMathBase.h"
	53	#endif
	54
	55	//
	56	//
	57
	58	ClassImp(AliTPCdigitRow)
	59	ClassImp(AliMCInfo)
	60
	61
	62
	63	////////////////////////////////////////////////////////////////////////
	64	AliMCInfo::AliMCInfo():
65	fTrackRef(),
66	fTrackRefOut(),
67	fTRdecay(),
68	fPrimPart(0),
69	fParticle(),
70	fMass(0),
71	fCharge(0),
72	fLabel(0),
73	fEventNr(),
74	fMCtracks(),
75	fPdg(0),
76	fTPCdecay(0),
77	fRowsWithDigitsInn(0),
78	fRowsWithDigits(0),
79	fRowsTrackLength(0),
80	fTPCtrackLength(-1),
81	fPrim(0),
82	fTPCRow(),
83	fNTPCRef(0), // tpc references counter
84	fNITSRef(0), // ITS references counter
85	fNTRDRef(0), // TRD references counter
86	fNTOFRef(0), // TOF references counter
87	fNTPCRefOut(0), // tpc references counter
88	fNITSRefOut(0), // ITS references counter
89	fNTRDRefOut(0), // TRD references counter
90	fNTOFRefOut(0), // TOF references counter
91	fTPCReferences(0),
92	fITSReferences(0),
93	fTRDReferences(0),
94	fTOFReferences(0)
95	{
96	//
97	// Default constructor
98	//
99	fTPCReferences = new TClonesArray("AliTrackReference",10);
100	fITSReferences = new TClonesArray("AliTrackReference",10);
101	fTRDReferences = new TClonesArray("AliTrackReference",10);
102	fTOFReferences = new TClonesArray("AliTrackReference",10);
103	fTRdecay.SetTrack(-1);
104	for (Int_t i=0;i<4;i++) fVDist[i]=0;
105	for (Int_t i=0;i<3;i++) fDecayCoord[i]=0;
106	fCharge = 0;
107	}
108
109	AliMCInfo::AliMCInfo(const AliMCInfo& info):
110	TObject(),
111	fTrackRef(info.fTrackRef),
112	fTrackRefOut(info.fTrackRefOut),
113	fTRdecay(info.GetTRdecay()),
114	fPrimPart(info.fPrimPart),
115	fParticle(info.fParticle),
116	fMass(info.GetMass()),
117	fCharge(info.fCharge),
118	fLabel(info.fLabel),
119	fEventNr(info.fEventNr),
120	fMCtracks(info.fMCtracks),
121	fPdg(info.fPdg),
122	fTPCdecay(info.fTPCdecay),
123	fRowsWithDigitsInn(info.fRowsWithDigitsInn),
124	fRowsWithDigits(info.fRowsWithDigits),
125	fRowsTrackLength(info.fRowsTrackLength),
126	fTPCtrackLength(info.fTPCtrackLength),
127	fPrim(info.fPrim),
128	fTPCRow(info.fTPCRow),
129	fNTPCRef(info.fNTPCRef), // tpc references counter
130	fNITSRef(info.fNITSRef), // ITS references counter
131	fNTRDRef(info.fNTRDRef), // TRD references counter
132	fNTOFRef(info.fNTOFRef), // TOF references counter
133	fNTPCRefOut(info.fNTPCRefOut), // tpc references counter
134	fNITSRefOut(info.fNITSRefOut), // ITS references counter
135	fNTRDRefOut(info.fNTRDRefOut), // TRD references counter
136	fNTOFRefOut(info.fNTOFRefOut), // TOF references counter
137	fTPCReferences(0),
138	fITSReferences(0),
139	fTRDReferences(0),
140	fTOFReferences(0)
141	{
142	//
143	// copy constructor
144	//
145	fTPCReferences = (TClonesArray*)info.fTPCReferences->Clone();
146	fITSReferences = (TClonesArray*)info.fITSReferences->Clone();
147	fTRDReferences = (TClonesArray*)info.fTRDReferences->Clone();
148	fTOFReferences = (TClonesArray*)info.fTOFReferences->Clone();
149	for (Int_t i=0;i<4;i++) fVDist[i]=info.fVDist[i];
150	for (Int_t i=0;i<3;i++) fDecayCoord[i]=info.fDecayCoord[i];
151
152	}
153
154
155	AliMCInfo& AliMCInfo::operator=(const AliMCInfo& info) {
156	//
157	// Assignment operator
158	//
159	this->~AliMCInfo();
160	new (this) AliMCInfo(info);
161	return *this;
162	}
163
164
165	AliMCInfo::~AliMCInfo()
166	{
167	//
168	// Destructor of the class
169	//
170	if (fTPCReferences) {
171	delete fTPCReferences;
172	}
173	if (fITSReferences){
174	delete fITSReferences;
175	}
176	if (fTRDReferences){
177	delete fTRDReferences;
178	}
179	if (fTOFReferences){
180	delete fTOFReferences;
181	}
182
183	}
184
185
186
187
188	void AliMCInfo::Update()
189	{
190	//
191	// Update MC info
192	// Calculates some derived variables
193	//
194	//
195	fMCtracks =1;
196	//
197	// decay info
198	fTPCdecay=kFALSE;
199	if (fTRdecay.GetTrack()>0){
200	fDecayCoord[0] = fTRdecay.X();
201	fDecayCoord[1] = fTRdecay.Y();
202	fDecayCoord[2] = fTRdecay.Z();
203	if ( (fTRdecay.R()<250)&&(fTRdecay.R()>85) && (TMath::Abs(fTRdecay.Z())<250) ){
204	fTPCdecay=kTRUE;
205	}
206	else{
207	fDecayCoord[0] = 0;
208	fDecayCoord[1] = 0;
209	fDecayCoord[2] = 0;
210	}
211	}
212	//
213	//
214	//digits information update
215	fRowsWithDigits = fTPCRow.RowsOn();
216	fRowsWithDigitsInn = fTPCRow.RowsOn(63); // 63 = number of inner rows
217	fRowsTrackLength = fTPCRow.Last() - fTPCRow.First();
218	//
219	//
220	// calculate primary ionization per cm
221	if (fParticle.GetPDG()){
222	fMass = fParticle.GetMass();
223	fCharge = fParticle.GetPDG()->Charge();
224	if (fTPCReferences->GetEntriesFast()>0){
225	fTrackRef = ((AliTrackReference)fTPCReferences->At(0));
226	}
227	if (fMass>0){
228	Float_t p = TMath::Sqrt(fTrackRef.Px()*fTrackRef.Px()+
229	fTrackRef.Py()*fTrackRef.Py()+
230	fTrackRef.Pz()*fTrackRef.Pz());
231	if (p>0.001){
232	Float_t betagama = p /fMass;
233	fPrim = AliMathBase::BetheBlochAleph(betagama);
234	}else fPrim=0;
235	}
236	}else{
237	fMass =0;
238	fPrim =0;
239	}
240
241
242
243	}
244
245
246
247
248	////////////////////////////////////////////////////////////////////////
249	AliTPCdigitRow::AliTPCdigitRow()
250	{
18e588e9	251	for (Int_t i = 0; i<32; i++) { fDig[i] = 0; }
7cc34f08	252	Reset();
	253	}
	254	////////////////////////////////////////////////////////////////////////
	255	AliTPCdigitRow & AliTPCdigitRow::operator=(const AliTPCdigitRow &digOld)
	256	{
	257	for (Int_t i = 0; i<32; i++) fDig[i] = digOld.fDig[i];
	258	return (*this);
	259	}
	260	////////////////////////////////////////////////////////////////////////
	261	void AliTPCdigitRow::SetRow(Int_t row)
	262	{
	263	//
	264	// set bit mask for given row
	265	//
	266	if (row >= 8*32) {
	267	// cerr<<"AliTPCdigitRow::SetRow: index "<<row<<" out of bounds."<<endl;
	268	return;
	269	}
	270	Int_t iC = row/8;
	271	Int_t iB = row%8;
	272	SETBIT(fDig[iC],iB);
	273	}
	274
	275	////////////////////////////////////////////////////////////////////////
	276	Bool_t AliTPCdigitRow::TestRow(Int_t row) const
	277	{
	278	//
	279	// return kTRUE if row is on
	280	//
	281	Int_t iC = row/8;
	282	Int_t iB = row%8;
	283	return TESTBIT(fDig[iC],iB);
	284	}
	285	////////////////////////////////////////////////////////////////////////
	286	Int_t AliTPCdigitRow::RowsOn(Int_t upto) const
	287	{
	288	//
	289	// returns number of rows with a digit
	290	// count only rows less equal row number upto
	291	//
	292	Int_t total = 0;
	293	for (Int_t i = 0; i<32; i++) {
	294	for (Int_t j = 0; j < 8; j++) {
	295	if (i*8+j > upto) return total;
	296	if (TESTBIT(fDig[i],j)) total++;
	297	}
	298	}
	299	return total;
	300	}
	301	////////////////////////////////////////////////////////////////////////
	302	void AliTPCdigitRow::Reset()
	303	{
	304	//
	305	// resets all rows to zero
	306	//
	307	for (Int_t i = 0; i<32; i++) {
18e588e9	308	//fDig[i] <<= 8;
18e588e9	309	fDig[i] = 0;
7cc34f08	310	}
	311	}
	312	////////////////////////////////////////////////////////////////////////
	313	Int_t AliTPCdigitRow::Last() const
	314	{
	315	//
	316	// returns the last row number with a digit
	317	// returns -1 if now digits
	318	//
	319	for (Int_t i = 32-1; i>=0; i--) {
	320	for (Int_t j = 7; j >= 0; j--) {
	321	if TESTBIT(fDig[i],j) return i*8+j;
	322	}
	323	}
	324	return -1;
	325	}
	326	////////////////////////////////////////////////////////////////////////
	327	Int_t AliTPCdigitRow::First() const
	328	{
	329	//
	330	// returns the first row number with a digit
	331	// returns -1 if now digits
	332	//
	333	for (Int_t i = 0; i<32; i++) {
	334	for (Int_t j = 0; j < 8; j++) {
	335	if (TESTBIT(fDig[i],j)) return i*8+j;
	336	}
	337	}
	338	return -1;
	339	}
	340
	341
	342	void AliMCInfo::Clear(Option_t* ){
	343	//
	344	// clear the content
	345	//
	346	if (fTPCReferences) fTPCReferences->Clear();
	347	if (fITSReferences) fITSReferences->Clear();
	348	if (fTRDReferences) fTRDReferences->Clear();
	349	if (fTOFReferences) fTOFReferences->Clear();
	350	for (Int_t i=0;i<4;i++) fVDist[i]=0;
	351	for (Int_t i=0;i<3;i++) fDecayCoord[i]=0;
	352	fTRdecay.SetTrack(-1);
	353	fCharge = 0;
	354	fEventNr=-1;
	355	fPrimPart=-1; // index of primary particle in TreeH
	356	fMass=0; // mass of the particle
	357	fCharge=0; // charge of the particle
	358	fLabel=0; // track label
	359	fEventNr=0; // event number
	360	fMCtracks=0; // indication of how many times the track is retuturned back
	361	fPdg=0; //pdg code
	362	fTPCdecay=0; //indicates decay in TPC
	363	fRowsWithDigitsInn=0; // number of rows with digits in the inner sectors
	364	fRowsWithDigits=0; // number of rows with digits in the outer sectors
	365	fRowsTrackLength=0; // last - first row with digit
	366	fTPCtrackLength=0; // distance between first and last track reference
	367	fPrim=0; // theoretical dedx in tpc according particle momenta and mass
	368	fNTPCRef=0; // tpc references counter
	369	fNITSRef=0; // ITS references counter
	370	fNTRDRef=0; // TRD references counter
	371	fNTOFRef=0; // TOF references counter
	372	//
	373	fNTPCRefOut=0; // tpc references counter - out
374	fNITSRefOut=0; // ITS references counter - out
375	fNTRDRefOut=0; // TRD references counter - out
376	fNTOFRefOut=0; // TOF references counter - out
377	}
378
379
380
381	void AliMCInfo::CalcTPCrows(TClonesArray * runArrayTR){
382	//
383	// Calculates the numebr of the track references for detectors
384	// In case of changing direction - curling tracks - the counter is not increasing
385	//
386	// Rough calculation
387	// of the first and last point in the TPC
388	//
389	fNTPCRef = 0;
390	fNITSRef = 0;
391	fNTRDRef = 0;
392	fNTOFRef = 0;
393	fNTPCRefOut = 0;
394	fNITSRefOut = 0;
395	fNTRDRefOut = 0;
396	fNTOFRefOut = 0;
397	//
398	//
399	Float_t tpcminRadius=TMath::Max(90., fParticle.R());
400	Float_t tpcmaxRadius=TMath::Min(250.,fParticle.R());
401	Int_t nover=-1;
402
403	if (runArrayTR->GetEntriesFast()>0){
404	nover=0;
405	AliTrackReference ref0 = (AliTrackReference)runArrayTR->At(0);
406	Float_t dir = ((ref0->X()ref0->Px()+ref0->Y()ref0->Py())>0)? 1.:-1.; //inside or outside
407	//
408	//
409	for (Int_t iTrackRef = 0; iTrackRef < runArrayTR->GetEntriesFast(); iTrackRef++) {
410	//
411	AliTrackReference ref = (AliTrackReference)runArrayTR->At(iTrackRef);
412	Float_t newdirection = ((ref->X()ref->Px()+ref->Y()ref->Py())>0)? 1.:-1.; //inside or outside
413	//
414	//
415	if (dir*newdirection<0.0) {
416	nover++;
417	dir = newdirection;
418	}
419	//
420	if (ref->DetectorId()== AliTrackReference::kTRD){
421	if (nover==0) {
422	tpcmaxRadius =250;
423	fNTRDRefOut++;
424	}
425	fNTRDRef++;
426	}
427	if (ref->DetectorId()== AliTrackReference::kITS){
428	if (nover==0) {
429	fNITSRefOut++;
430	tpcminRadius =90;
431	}
432	fNITSRef++;
433	}
434	if (ref->DetectorId()== AliTrackReference::kTOF){
435	fNTOFRef++;
436	if (nover==0) {
437	fNTOFRefOut++;
438	tpcmaxRadius =250;
439	}
440	}
441	//
442	if (ref->DetectorId()== AliTrackReference::kTPC){
443	fNTPCRef++;
444	if (nover==0) {
445	fNTPCRefOut++;
446	fTrackRefOut = (*ref);
447	if (ref->R()>tpcmaxRadius) tpcmaxRadius = ref->R();
448	if (ref->R()<tpcminRadius) tpcminRadius = ref->R();
449	}
450	}
451	if (ref->DetectorId()== AliTrackReference::kDisappeared){
452	if (nover==0 &&TMath::Abs(ref->Z())<250){
453	tpcmaxRadius = TMath::Min(Float_t(250.),ref->R());
454	}
455	}
456	}
457	} // if we have track refs
458	fTPCtrackLength = tpcmaxRadius-tpcminRadius;
459	fMCtracks=nover+1;
460	}
461
462	//
463	//
464	//
465
466
467
468	void AliMCInfo::Update(TParticle * part, TClonesArray * runArrayTR, Double_t pvertex[4], Int_t label){
469	//
470	//
471	//
472	Clear();
473	fLabel=label;
474	fParticle=(*part);
475	AliMCInfo *info = this;
476	fVDist[0]=part->Vx()-pvertex[0];
477	fVDist[1]=part->Vy()-pvertex[1];
478	fVDist[2]=part->Vz()-pvertex[2];
479	fVDist[3]=part->R()-pvertex[3];
480	//
481	//
482	//
483	for (Int_t iTrackRef = 0; iTrackRef < runArrayTR->GetEntriesFast(); iTrackRef++) {
484	AliTrackReference trackRef = (AliTrackReference)runArrayTR->At(iTrackRef);
485	if (trackRef->DetectorId()== AliTrackReference::kTPC){
486	TClonesArray & arr = *(info->fTPCReferences);
487	new (arr[arr.GetEntriesFast()]) AliTrackReference(*trackRef);
488	}
489	if (trackRef->DetectorId()== AliTrackReference::kITS){
490	TClonesArray & arr = *(info->fITSReferences);
491	new (arr[arr.GetEntriesFast()]) AliTrackReference(*trackRef);
492	}
493	if (trackRef->DetectorId()== AliTrackReference::kTRD){
494	TClonesArray & arr = *(info->fTRDReferences);
495	new (arr[arr.GetEntriesFast()]) AliTrackReference(*trackRef);
496	}
497	if (trackRef->DetectorId()== AliTrackReference::kTOF){
498	TClonesArray & arr = *(info->fTOFReferences);
499	new (arr[arr.GetEntriesFast()]) AliTrackReference(*trackRef);
500	}
501	//
502	// decay case
503	//
504	if (trackRef->DetectorId()== AliTrackReference::kDisappeared){
505	info->fTRdecay = *trackRef;
506	}
507	}
508	//
509	Update();
510	CalcTPCrows(runArrayTR);
511	}
512