#include "AliITSReconstructor.h"
#include "AliITSsegmentationSPD.h"
#include "AliITSRecPoint.h"
+#include "AliITSRecPointContainer.h"
#include "AliITSgeom.h"
+#include "AliITSgeomTGeo.h"
#include "AliLog.h"
#include "TGeoGlobalMagField.h"
#include "AliMagF.h"
fNFiredChips[0] = 0;
fNFiredChips[1] = 0;
- AliITSsegmentationSPD *seg = new AliITSsegmentationSPD();
+ AliITSsegmentationSPD seg;
- TClonesArray* itsClusters = new TClonesArray("AliITSRecPoint");
- TBranch* itsClusterBranch=itsClusterTree->GetBranch("ITSRecPoints");
-
- itsClusterBranch->SetAddress(&itsClusters);
-
- Int_t nItsSubs = (Int_t)itsClusterTree->GetEntries();
+ AliITSRecPointContainer* rpcont=AliITSRecPointContainer::Instance();
+ TClonesArray* itsClusters=rpcont->FetchClusters(0,itsClusterTree);
+ if(!rpcont->IsSPDActive()){
+ AliWarning("No SPD rec points found, multiplicity not calculated");
+ return;
+ }
Float_t cluGlo[3]={0.,0.,0.};
// count clusters
- // loop over the its subdetectors
- for (Int_t iIts=0; iIts < nItsSubs; iIts++) {
- if (!itsClusterTree->GetEvent(iIts))
- continue;
-
- Int_t nClusters = itsClusters->GetEntriesFast();
- // loop over clusters
- while(nClusters--) {
- AliITSRecPoint* cluster = (AliITSRecPoint*)itsClusters->UncheckedAt(nClusters);
-
- Int_t layer = cluster->GetLayer();
- if (layer == 0)
- fNClustersLay1++;
- else if (layer == 1)
- fNClustersLay2++;
- }
+ // loop over the SPD subdetectors
+ Int_t nSPDL1 = AliITSgeomTGeo::GetModuleIndex(2,1,1);
+ for (Int_t iIts=0; iIts < nSPDL1; iIts++) {
+ itsClusters=rpcont->UncheckedGetClusters(iIts);
+ fNClustersLay1 += itsClusters->GetEntriesFast();
+ }
+ Int_t nSPDL2=AliITSgeomTGeo::GetModuleIndex(3,1,1);
+ for (Int_t iIts=nSPDL1; iIts < nSPDL2; iIts++) {
+ itsClusters=rpcont->UncheckedGetClusters(iIts);
+ fNClustersLay2 += itsClusters->GetEntriesFast();
}
// create arrays
// loop over the its subdetectors
fNClustersLay1 = 0; // reset to 0
fNClustersLay2 = 0;
- for (Int_t iIts=0; iIts < nItsSubs; iIts++) {
+ for (Int_t iIts=0; iIts < nSPDL2; iIts++) {
- if (!itsClusterTree->GetEvent(iIts))
- continue;
+ itsClusters=rpcont->UncheckedGetClusters(iIts);
Int_t nClusters = itsClusters->GetEntriesFast();
// find the chip for the current cluster
Float_t locz = cluster->GetDetLocalZ();
- Int_t iChip = seg->GetChipFromLocal(0,locz);
+ Int_t iChip = seg.GetChipFromLocal(0,locz);
nClustersInChip[iChip]++;
if (layer==0) {
}// end of cluster loop
// get number of fired chips in the current module
- if(layer<2)
+
for(Int_t ifChip=0; ifChip<5; ifChip++) {
if(nClustersInChip[ifChip] >= 1) fNFiredChips[layer]++;
}
} // end of its "subdetector" loop
- if (itsClusters) {
- itsClusters->Delete();
- delete itsClusters;
- delete seg;
- itsClusters = 0;
- }
AliDebug(1,Form("(clusters in layer 1 : %d, layer 2: %d)",fNClustersLay1,fNClustersLay2));
AliDebug(1,Form("(cluster-fired chips in layer 1 : %d, layer 2: %d)",fNFiredChips[0],fNFiredChips[1]));
}
fNFiredChips[0] = 0;
fNFiredChips[1] = 0;
- AliITSsegmentationSPD *seg = new AliITSsegmentationSPD();
-
- TClonesArray* itsClusters = new TClonesArray("AliITSRecPoint");
- TBranch* itsClusterBranch=itsClusterTree->GetBranch("ITSRecPoints");
-
- itsClusterBranch->SetAddress(&itsClusters);
+ AliITSsegmentationSPD seg;
+ AliITSRecPointContainer* rpcont=AliITSRecPointContainer::Instance();
+ TClonesArray* itsClusters=rpcont->FetchClusters(0,itsClusterTree);
+ if(!rpcont->IsSPDActive()){
+ AliWarning("No SPD rec points found, multiplicity not calculated");
+ return;
+ }
- Int_t nItsSubs = (Int_t)itsClusterTree->GetEntries();
-
// loop over the its subdetectors
- for (Int_t iIts=0; iIts < nItsSubs; iIts++) {
-
- if (!itsClusterTree->GetEvent(iIts))
- continue;
-
+ Int_t nSPDmodules=AliITSgeomTGeo::GetModuleIndex(3,1,1);
+ for (Int_t iIts=0; iIts < nSPDmodules; iIts++) {
+ itsClusters=rpcont->UncheckedGetClusters(iIts);
Int_t nClusters = itsClusters->GetEntriesFast();
// number of clusters in each chip of the current module
// find the chip for the current cluster
Float_t locz = cluster->GetDetLocalZ();
- Int_t iChip = seg->GetChipFromLocal(0,locz);
+ Int_t iChip = seg.GetChipFromLocal(0,locz);
nClustersInChip[iChip]++;
}// end of cluster loop
// get number of fired chips in the current module
- if(layer<2)
for(Int_t ifChip=0; ifChip<5; ifChip++) {
if(nClustersInChip[ifChip] >= 1) fNFiredChips[layer]++;
}
} // end of its "subdetector" loop
- if (itsClusters) {
- itsClusters->Delete();
- delete itsClusters;
- delete seg;
- itsClusters = 0;
- }
+
AliDebug(1,Form("(cluster-fired chips in layer 1 : %d, layer 2: %d)",fNFiredChips[0],fNFiredChips[1]));
}
//____________________________________________________________________
--- /dev/null
+#include <TTree.h>
+#include "AliLog.h"
+#include "AliITSRecoParam.h"
+#include "AliITSReconstructor.h"
+#include "AliITSRecPointContainer.h"
+#include "AliITSRecPoint.h"
+#include "AliRunLoader.h"
+
+ClassImp(AliITSRecPointContainer)
+
+//////////////////////////////////////////////////////////////////////
+// Class to store ITS RecPoints for the duration of //
+// one event processing //
+// The container is cleared at each event and new RP //
+// are loaded from TTree //
+// Origin masera@to.infn.it Nov. 12 2009 //
+//////////////////////////////////////////////////////////////////////
+
+/* $Id$ */
+
+AliITSRecPointContainer* AliITSRecPointContainer::fgInstance = 0x0;
+
+//______________________________________________________________________
+AliITSRecPointContainer::AliITSRecPointContainer(const AliITSRecoParam* krp):TObject(),
+fSPDNModules(0),
+fSDDNModules(0),
+fSSDNModules(0),
+fArray(),
+fCurrentEve(-1000),
+fActualSize(0),
+fDet(""){
+ // Default constructor
+
+ if(fgkNModules != AliITSgeomTGeo::GetNModules())AliError(Form("The total number of modules is not %d, but %d",fgkNModules,AliITSgeomTGeo::GetNModules()));
+
+ Int_t modperlay[6];
+ for(Int_t i=0;i<6;i++)modperlay[i]=AliITSgeomTGeo::GetNDetectors(1+i)*AliITSgeomTGeo::GetNLadders(1+i);
+ fSPDNModules=modperlay[0]+modperlay[1];
+ fSDDNModules=modperlay[2]+modperlay[3];
+ fSSDNModules=modperlay[4]+modperlay[5];
+ // AliInfo(Form("Total modules: %d \n SPD modules=%d , SDD modules=%d, SSD modules=%d ",fgkNModules,fSPDNModules,fSDDNModules,fSSDNModules));
+
+ // kLimits[0:5] --> low fluw; kLimits[6,11] --> High flux
+ const Int_t kLimits[12]={25,25,20,20,10,10,300,300,200,200,100,100};
+ Int_t offset=0;
+ if(!krp){
+ AliWarning("AliITSRecoPoint is missing. Using defaults");
+ }
+ else {
+ if(krp->GetEventSpecie() == AliRecoParam::kHighMult)offset=6;
+ }
+ Int_t maxval[6];
+ TString values="";
+ for(Int_t i=0;i<6;i++){
+ maxval[i]=kLimits[i+offset];
+ values+=maxval[i];
+ values+=" ";
+ if(i>0)modperlay[i]+=modperlay[i-1];
+ }
+ AliInfo(Form("Container created with sizes/layer: %s",values.Data()));
+ Int_t layer=0;
+ for(Int_t i=0;i<fgkNModules;i++){
+ if(i>=modperlay[layer])++layer;
+ fArray[i]=new TClonesArray("AliITSRecPoint",maxval[layer]);
+ }
+}
+
+
+//______________________________________________________________________
+AliITSRecPointContainer::~AliITSRecPointContainer(){
+ // Destructor
+ for(Int_t i=0;i<fgkNModules;i++){
+ if(fArray[i]){
+ fArray[i]->Delete();
+ delete fArray[i];
+ }
+ }
+}
+
+//______________________________________________________________________
+void AliITSRecPointContainer::CookEntries(){
+ // From the number of entries in TTree R, the number of ITS subdetectors
+ // active for the present run is inferred
+ if(fActualSize == fgkNModules)fDet="ALL SPD SDD SSD ";
+ if(fActualSize == fSPDNModules) fDet = "SPD ";
+ if(fActualSize == fSDDNModules) fDet = "SDD ";
+ if(fActualSize == fSSDNModules)fDet = "SSD ";
+ if(fActualSize == (fSPDNModules+fSDDNModules)) fDet = "SPD SDD ";
+ if(fActualSize == (fSPDNModules+fSSDNModules))fDet = "SPD SSD ";
+ if(fActualSize == (fSDDNModules+fSSDNModules))fDet = "SDD SSD ";
+ if((!fDet.Contains("SPD")) && (!fDet.Contains("SDD")) &&
+ (!fDet.Contains("SSD")))AliError(Form("The number of active modules %d does not correspond to any standard configuration of the detector",fActualSize));
+}
+//______________________________________________________________________
+TClonesArray* AliITSRecPointContainer::FetchClusters(Int_t mod, TTree* tR){
+ // retrieves Recpoints for module mod
+ Int_t cureve=AliRunLoader::Instance()->GetEventNumber();
+ if(cureve != fCurrentEve){
+ fCurrentEve = cureve;
+ Reset();
+ TBranch *branch = NULL;
+ branch = tR->GetBranch("ITSRecPoints");
+ if(!branch){
+ AliError("Branch ITSRecPoints not found on ITS recpoints TTree");
+ return NULL;
+ }
+
+ fActualSize = branch->GetEntries();
+ CookEntries();
+ if(fDet.IsNull())return NULL;
+
+ // it is assumed that the filling order of the tree is SPD, SDD, SSD
+ // even if one or two subdetector are missing
+ if(IsSPDActive()){
+ for(Int_t i=0;i<fSPDNModules;i++){
+ branch->SetAddress(&fArray[i]);
+ branch->GetEvent(i);
+ }
+ }
+ if(IsSDDActive()){
+ Int_t start=0;
+ if(IsSPDActive())start+=fSPDNModules;
+ Int_t counter = fSPDNModules;
+ for(Int_t i=start;i<start+fSDDNModules;i++){
+ branch->SetAddress(&fArray[counter]);
+ ++counter;
+ branch->GetEvent(i);
+ }
+ }
+ if(IsSSDActive()){
+ Int_t start=0;
+ if(IsSPDActive())start+=fSPDNModules;
+ if(IsSDDActive())start+=fSDDNModules;
+ Int_t counter = fSPDNModules+fSDDNModules;
+ for(Int_t i=start;i<start+fSSDNModules;i++){
+ branch->SetAddress(&fArray[counter]);
+ ++counter;
+ branch->GetEvent(i);
+ }
+ }
+ }
+
+ if(CheckBoundaries(mod)){
+ return fArray[mod];
+ }
+ else {
+ AliError(Form("Module %d is out of boundaries",mod));
+ return NULL;
+ }
+
+}
+
+//______________________________________________________________________
+AliITSRecPointContainer* AliITSRecPointContainer::Instance(const AliITSRecoParam* kptr){
+ // returns AliITSRecPointContainer instance (singleton)
+ if(!fgInstance){
+ if(!kptr){
+ fgInstance = new AliITSRecPointContainer(AliITSReconstructor::GetRecoParam());
+ }
+ else {
+ fgInstance = new AliITSRecPointContainer(kptr);
+ }
+ }
+ return fgInstance;
+}
+
+//______________________________________________________________________
+void AliITSRecPointContainer::Reset(){
+ // Resets the status of the object
+ for(Int_t i=0;i<fgkNModules;i++){
+ (fArray[i])->Clear();
+ }
+ fDet="";
+}
--- /dev/null
+#ifndef ALIITSRECPOINTCONTAINER_H
+#define ALIITSRECPOINTCONTAINER_H
+/* Copyright(c) 2009-2011, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id$ */
+
+////////////////////////////////////////////////////////////////////////
+// Container class for ITS rec points //
+////////////////////////////////////////////////////////////////////////
+
+#include <TClonesArray.h>
+#include <TString.h>
+
+class AliITSRecoParam;
+
+class AliITSRecPointContainer : public TObject {
+
+ public:
+
+ virtual ~AliITSRecPointContainer(); //Destructor
+
+ Bool_t IsSPDActive() const {return fDet.Contains("SPD");}
+ Bool_t IsSDDActive() const {return fDet.Contains("SDD");}
+ Bool_t IsSSDActive() const {return fDet.Contains("SSD");}
+ Bool_t IsITSComplete() const {return fDet.Contains("ALL");}
+
+ static AliITSRecPointContainer* Instance(const AliITSRecoParam *ptr=NULL);
+ TClonesArray* FetchClusters(Int_t mod, TTree* tR);
+ TClonesArray* UncheckedGetClusters(Int_t mod) const {return fArray[mod];}
+
+ private:
+ // methods
+ AliITSRecPointContainer(const AliITSRecoParam* krp=NULL); // Default constructor
+ AliITSRecPointContainer(const AliITSRecPointContainer& rec);
+ AliITSRecPointContainer& operator=(const AliITSRecPointContainer &source);
+ Bool_t CheckBoundaries(Int_t i)const { return (i>=0 && i<fgkNModules);}
+ void CookEntries();
+ void Reset();
+ //Data members
+ static AliITSRecPointContainer* fgInstance; //! AliITSRecPointContainer
+ // singleton
+ static const Int_t fgkNModules=2198; //! total number of ITS modules
+
+ Int_t fSPDNModules; //! number of SPD modules
+ Int_t fSDDNModules; //! number of SDD modules
+ Int_t fSSDNModules; //! number of SDD modules
+ TClonesArray* fArray[fgkNModules]; //! container - 1 TClonesArray per module
+ Int_t fCurrentEve; //!run number
+ Int_t fActualSize; //! actual number of ITS modules in TTree R
+ TString fDet; //! ITS subdetectors active for the current run
+
+ ClassDef(AliITSRecPointContainer,0)
+};
+
+#endif
param->SetExtendedEtaAcceptance(kFALSE);
// allow to skip layer if no cluster and no bad
param->SetAllowProlongationWithEmptyRoad(kFALSE);
-
+ // set event specie
+ param->SetEventSpecie(AliRecoParam::kHighMult);
param->fMaxSnp = 0.95;
param->SetExtendedEtaAcceptance(kTRUE);
// allow to skip layer if no cluster and no bad
param->SetAllowProlongationWithEmptyRoad(kTRUE);
-
+ // set event specie
+ param->SetEventSpecie(AliRecoParam::kLowMult);
param->fMaxSnp = 0.95;
param->SetAddVirtualClustersInDeadZone(kFALSE);
param->SetUseAmplitudeInfo(kFALSE);
+ // set event specie
+ param->SetEventSpecie(AliRecoParam::kCosmic);
+
// full use of bads from OCDB
param->SetUseBadZonesFromOCDB(kTRUE);
param->SetUseSingleBadChannelsFromOCDB(kTRUE);
* provided "as is" without express or implied warranty. *
**************************************************************************/
#include <TTree.h>
+#include "AliRunLoader.h"
#include "AliESDVertex.h"
#include "AliLog.h"
#include "AliStrLine.h"
#include "AliTracker.h"
#include "AliITSDetTypeRec.h"
#include "AliITSRecPoint.h"
+#include "AliITSRecPointContainer.h"
#include "AliITSgeomTGeo.h"
#include "AliVertexerTracks.h"
#include "AliITSVertexer3D.h"
// considered. Straight lines (=tracklets)are formed.
// The tracklets are processed in Prepare3DVertex
- if(!GetDetTypeRec())AliFatal("DetTypeRec pointer has not been set");
-
- TTree *tR = itsClusterTree;
- fDetTypeRec->ResetRecPoints();
- fDetTypeRec->SetTreeAddressR(tR);
TClonesArray *itsRec = 0;
if(optCuts==0) fZHisto->Reset();
// gc1 are local and global coordinates for layer 1
// gc2 are local and global coordinates for layer 2
Float_t gc2f[3]={0.,0.,0.};
Double_t gc2[3]={0.,0.,0.};
-
- itsRec = fDetTypeRec->RecPoints();
- TBranch *branch = NULL;
- branch = tR->GetBranch("ITSRecPoints");
- if(!branch){
- AliWarning("Null pointer for RecPoints branch, vertex not calculated");
+ AliITSRecPointContainer* rpcont=AliITSRecPointContainer::Instance();
+ itsRec=rpcont->FetchClusters(0,itsClusterTree);
+ if(!rpcont->IsSPDActive()){
+ AliWarning("No SPD rec points found, 3D vertex not calculated");
return -1;
}
Int_t firstL1 = AliITSgeomTGeo::GetModuleIndex(1,1,1);
Int_t lastL1 = AliITSgeomTGeo::GetModuleIndex(2,1,1)-1;
for(Int_t module= firstL1; module<=lastL1;module++){ // count number of recopints on layer 1
- branch->GetEvent(module);
+ itsRec=rpcont->UncheckedGetClusters(module);
nrpL1+= itsRec->GetEntries();
- fDetTypeRec->ResetRecPoints();
}
//By default firstL2=80 and lastL2=239
Int_t firstL2 = AliITSgeomTGeo::GetModuleIndex(2,1,1);
Int_t lastL2 = AliITSgeomTGeo::GetModuleIndex(3,1,1)-1;
for(Int_t module= firstL2; module<=lastL2;module++){ // count number of recopints on layer 2
- branch->GetEvent(module);
+ itsRec=rpcont->UncheckedGetClusters(module);
nrpL2+= itsRec->GetEntries();
- fDetTypeRec->ResetRecPoints();
}
if(nrpL1 == 0 || nrpL2 == 0){
AliDebug(1,Form("No RecPoints in at least one SPD layer (%d %d)",nrpL1,nrpL2));
for(Int_t modul1= firstL1; modul1<=lastL1;modul1++){ // Loop on modules of layer 1
if(!fUseModule[modul1]) continue;
UShort_t ladder=int(modul1/4)+1; // ladders are numbered starting from 1
- branch->GetEvent(modul1);
- Int_t nrecp1 = itsRec->GetEntries();
- static TClonesArray prpl1("AliITSRecPoint",nrecp1);
- prpl1.SetOwner();
- for(Int_t j=0;j<nrecp1;j++){
- AliITSRecPoint *recp = (AliITSRecPoint*)itsRec->At(j);
- new(prpl1[j])AliITSRecPoint(*recp);
- }
- fDetTypeRec->ResetRecPoints();
+ TClonesArray *prpl1=rpcont->UncheckedGetClusters(modul1);
+ Int_t nrecp1 = prpl1->GetEntries();
for(Int_t j=0;j<nrecp1;j++){
if(j>kMaxCluPerMod) continue;
UShort_t idClu1=modul1*kMaxCluPerMod+j;
if(fUsedCluster.TestBitNumber(idClu1)) continue;
- AliITSRecPoint *recp1 = (AliITSRecPoint*)prpl1.At(j);
+ AliITSRecPoint *recp1 = (AliITSRecPoint*)prpl1->At(j);
recp1->GetGlobalXYZ(gc1f);
for(Int_t ico=0;ico<3;ico++)gc1[ico]=gc1f[ico];
if(ladmod>AliITSgeomTGeo::GetNLadders(2)) ladmod=ladmod-AliITSgeomTGeo::GetNLadders(2);
Int_t modul2=AliITSgeomTGeo::GetModuleIndex(2,ladmod,k+1);
if(!fUseModule[modul2]) continue;
- branch->GetEvent(modul2);
+ itsRec=rpcont->UncheckedGetClusters(modul2);
Int_t nrecp2 = itsRec->GetEntries();
for(Int_t j2=0;j2<nrecp2;j2++){
if(j2>kMaxCluPerMod) continue;
new(fLines[nolines++])AliStrLine(gc1,sigmasq,wmat,gc2,kTRUE,idClu1,idClu2);
}
- fDetTypeRec->ResetRecPoints();
}
}
}
- prpl1.Clear();
}
if(nolines == 0)return -2;
return nolines;
#include<TTree.h>
#include "AliESDVertex.h"
#include "AliITSgeomTGeo.h"
-#include "AliITSDetTypeRec.h"
#include "AliITSRecPoint.h"
+#include "AliITSRecPointContainer.h"
#include "AliITSZPoint.h"
/////////////////////////////////////////////////////////////////
// Defines the AliESDVertex for the current event
fCurrentVertex = 0;
ResetVertex();
-
- if(!GetDetTypeRec())AliFatal("DetTypeRec pointer has not been set");
-
- TTree *tR = itsClusterTree;
- fDetTypeRec->SetTreeAddressR(tR);
TClonesArray *itsRec = 0;
// lc1 and gc1 are local and global coordinates for layer 1
Float_t lc1[3]; for(Int_t ii=0; ii<3; ii++) lc1[ii]=0.;
// lc2 and gc2 are local and global coordinates for layer 2
Float_t lc2[3]; for(Int_t ii=0; ii<3; ii++) lc2[ii]=0.;
Float_t gc2[3]; for(Int_t ii=0; ii<3; ii++) gc2[ii]=0.;
-
- itsRec = fDetTypeRec->RecPoints();
- TBranch *branch;
- branch = tR->GetBranch("ITSRecPoints");
- if(!branch){
+ AliITSRecPointContainer* rpcont=AliITSRecPointContainer::Instance();
+ itsRec=rpcont->FetchClusters(0,itsClusterTree);
+ if(!rpcont->IsSPDActive()){
AliWarning("Null pointer for RecPoints branch, vertex not calculated");
ResetHistograms();
fCurrentVertex = new AliESDVertex(0.,5.3,-2);
// By default fFirstL1=0 and fLastL1=79
for(Int_t module= fFirstL1; module<=fLastL1;module++){
- branch->GetEvent(module);
+ itsRec=rpcont->UncheckedGetClusters(module);
nrpL1+= itsRec->GetEntries();
- fDetTypeRec->ResetRecPoints();
}
//By default fFirstL2=80 and fLastL2=239
for(Int_t module= fFirstL2; module<=fLastL2;module++){
- branch->GetEvent(module);
+ itsRec=rpcont->UncheckedGetClusters(module);
nrpL2+= itsRec->GetEntries();
- fDetTypeRec->ResetRecPoints();
}
if(nrpL1 == 0 || nrpL2 == 0){
AliDebug(1,Form("No RecPoints in at least one SPD layer (%d %d)",nrpL1,nrpL2));
for(Int_t modul1= fFirstL1; modul1<=fLastL1;modul1++){ // Loop on modules of layer 1
if(!fUseModule[modul1]) continue;
UShort_t ladder=int(modul1/4)+1; // ladders are numbered starting from 1
- branch->GetEvent(modul1);
- Int_t nrecp1 = itsRec->GetEntries();
- static TClonesArray prpl1("AliITSRecPoint",nrecp1);
- prpl1.SetOwner();
- for(Int_t j=0;j<nrecp1;j++){
- AliITSRecPoint *recp = (AliITSRecPoint*)itsRec->At(j);
- new(prpl1[j])AliITSRecPoint(*recp);
- }
- fDetTypeRec->ResetRecPoints();
+ TClonesArray *prpl1=rpcont->UncheckedGetClusters(modul1);
+ Int_t nrecp1 = prpl1->GetEntries();
for(Int_t j1=0;j1<nrecp1;j1++){
- AliITSRecPoint *recp = (AliITSRecPoint*)prpl1.At(j1);
- /*
- lc1[0]=recp->GetDetLocalX();
- lc1[2]=recp->GetDetLocalZ();
- geom->LtoG(modul1,lc1,gc1);
- // Global coordinates of this recpoints
- */
+ AliITSRecPoint *recp = (AliITSRecPoint*)prpl1->At(j1);
recp->GetGlobalXYZ(gc1);
gc1[0]-=GetNominalPos()[0]; // Possible beam offset in the bending plane
gc1[1]-=GetNominalPos()[1]; // " "
if(ladmod>AliITSgeomTGeo::GetNLadders(2)) ladmod=ladmod-AliITSgeomTGeo::GetNLadders(2);
Int_t modul2=AliITSgeomTGeo::GetModuleIndex(2,ladmod,k+1);
if(!fUseModule[modul2]) continue;
- branch->GetEvent(modul2);
+ itsRec=rpcont->UncheckedGetClusters(modul2);
Int_t nrecp2 = itsRec->GetEntries();
for(Int_t j2=0;j2<nrecp2;j2++){
recp = (AliITSRecPoint*)itsRec->At(j2);
- /*
- lc2[0]=recp->GetDetLocalX();
- lc2[2]=recp->GetDetLocalZ();
- geom->LtoG(modul2,lc2,gc2);
- */
recp->GetGlobalXYZ(gc2);
gc2[0]-=GetNominalPos()[0];
gc2[1]-=GetNominalPos()[1];
fZCombc->Fill(zr0);
}
}
- fDetTypeRec->ResetRecPoints();
}
}
}
- prpl1.Clear();
}
points.Sort();
AliITSQASSDRefData.cxx
AliITSTrackleterSPDEff.cxx
AliITSRealignTracks.cxx
+ AliITSRecPointContainer.cxx
)
# fill list of header files from list of source files
#pragma link C++ class AliITSVertexerFixed+;
#pragma link C++ class AliITSMeanVertexer+;
#pragma link C++ class AliITSZPoint+;
+#pragma link C++ class AliITSRecPointContainer+;
// Tasks
#pragma link C++ class AliITSreconstruction+;
AliITSQASDDChecker.cxx \
AliITSQASSDChecker.cxx \
AliITSQASSDRefData.cxx \
- AliITSTrackleterSPDEff.cxx
+ AliITSTrackleterSPDEff.cxx \
+ AliITSRecPointContainer.cxx
HDRS:= $(SRCS:.cxx=.h)