set ( EINCLUDE )
set ( ELIBSDIR )
-set ( ELIBS EveBase EveDet MUONmapping MUONevaluation MUONsim MUONrec MUONgeometry MUONcalib MUONbase MUONraw MUONtrigger MUONcore TPCfast TPCsim TPCrec TPCbase ITSbase ITSsim ITSrec PMDbase PMDsim PMDrec TRDbase TRDsim TRDrec FMDbase FMDsim FMDrec TOFbase TOFrec TOFsim PHOSUtils PHOSbase PHOSsim PHOSrec ACORDEbase ACORDEsim ACORDErec HMPIDbase HMPIDrec HMPIDsim ZDCbase ZDCsim ZDCrec VZERObase VZEROsim VZEROrec EMCALUtils EMCALbase EMCALsim EMCALrec EMCALraw BCM STRUCT T0base T0sim T0rec STEER CDB AOD ESD STEERBase ANALYSISalice ANALYSIS THijing hijing THbtp TEPEMGEN FASTSIM microcern RAWDatasim RAWDatarec RAWDatabase HLTbase XMLParser STAT OADB MONITOR)
+set ( ELIBS EveBase EveDet MUONmapping MUONevaluation MUONsim MUONrec MUONgeometry MUONcalib MUONbase MUONraw MUONtrigger MUONcore TPCfast TPCsim TPCrec TPCbase ITSbase ITSsim ITSrec ITSUpgradeBase ITSUpgradeSim PMDbase PMDsim PMDrec TRDbase TRDsim TRDrec FMDbase FMDsim FMDrec TOFbase TOFrec TOFsim PHOSUtils PHOSbase PHOSsim PHOSrec ACORDEbase ACORDEsim ACORDErec HMPIDbase HMPIDrec HMPIDsim ZDCbase ZDCsim ZDCrec VZERObase VZEROsim VZEROrec EMCALUtils EMCALbase EMCALsim EMCALrec EMCALraw BCM STRUCT T0base T0sim T0rec STEER CDB AOD ESD STEERBase ANALYSISalice ANALYSIS THijing hijing THbtp TEPEMGEN FASTSIM microcern RAWDatasim RAWDatarec RAWDatabase HLTbase XMLParser STAT OADB MONITOR)
if(PYTHIA6)
list (APPEND ELIBS EVGEN)
set ( EINCLUDE )
set ( ELIBSDIR )
-set ( ELIBS EveBase EveHLT EveDet MONITOR HLTbase HLTrec AliHLTUtil AliHLTEve AliHLTTPC TPCcalib AliHLTRCU AliHLTMUON TPCsim TPCrec TPCbase ITSbase ITSrec TRDbase TRDrec AliHLTTRD PHOSbase PHOSUtils EMCALbase EMCALraw EMCALUtils EMCALrec EMCALsim TRIGGERbase VZERObase VZEROrec VZEROsim TRIGGERbase MUONmapping MUONevaluation MUONsim MUONrec MUONgeometry MUONcalib MUONbase MUONraw MUONtrigger MUONcore STEER CDB AOD ESD STEERBase ANALYSISalice ANALYSIS FASTSIM microcern RAWDatasim RAWDatarec RAWDatabase XMLParser STAT TOFbase TOFsim FMDbase FMDsim FMDrec PMDbase T0base OADB)
+set ( ELIBS EveBase EveHLT EveDet MONITOR HLTbase HLTrec AliHLTUtil AliHLTEve AliHLTTPC TPCcalib AliHLTRCU AliHLTMUON TPCsim TPCrec TPCbase ITSbase ITSsim ITSrec ITSUpgradeBase ITSUpgradeSim TRDbase TRDrec AliHLTTRD PHOSbase PHOSUtils EMCALbase EMCALraw EMCALUtils EMCALrec EMCALsim TRIGGERbase VZERObase VZEROrec VZEROsim TRIGGERbase MUONmapping MUONevaluation MUONsim MUONrec MUONgeometry MUONcalib MUONbase MUONraw MUONtrigger MUONcore STEER CDB AOD ESD STEERBase ANALYSISalice ANALYSIS FASTSIM microcern RAWDatasim RAWDatarec RAWDatabase XMLParser STAT TOFbase TOFsim FMDbase FMDsim FMDrec PMDbase T0base OADB)
set ( PACKBLIBS ${ROOTCLIBS} ${ROOTPLIBS} -lTreePlayer -lGeomPainter -lGed -lRGL -lEve ${SYSLIBS})
set ( DHDR EveDet/EveDetLinkDef.h)
-set ( EINCLUDE RAW EMCAL ITS TPC TRD TOF T0 MUON MUON/mapping PMD HLT/BASE HLT/BASE/HOMER VZERO EVE/EveDet ANALYSIS STEER/STEER STEER/ESD STEER/STEERBase)
+set ( EINCLUDE RAW EMCAL ITS ITS/UPGRADE TPC TRD TOF T0 MUON MUON/mapping PMD HLT/BASE HLT/BASE/HOMER VZERO EVE/EveDet ANALYSIS STEER/STEER STEER/ESD STEER/STEERBase)
set ( ELIBS -L/usr/X11/lib -lGL -lGLU )
EveDet/AliEveFMDLoader.h
EveDet/AliEveITSDigitsInfo.h
EveDet/AliEveITSModule.h
+ EveDet/AliEveITSUModule.h
EveDet/AliEveITSModuleStepper.h
EveDet/AliEveITSScaledModule.h
EveDet/AliEveListAnalyser.h
#pragma link C++ class AliEveITSModuleSelection+;
#pragma link C++ class AliEveITSDigitsInfo+;
#pragma link C++ class AliEveITSModule+;
+#pragma link C++ class AliEveITSUModule+;
#pragma link C++ class AliEveDigitScaleInfo+;
#pragma link C++ class AliEveITSScaledModule+;
#pragma link C++ class AliEveITSScaledModuleEditor+;
--- /dev/null
+// $Id: its_clusters.C 55060 2012-03-09 18:13:17Z quark $
+// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
+
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
+ * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
+ * full copyright notice. *
+ **************************************************************************/
+
+#if !defined(__CINT__) || defined(__MAKECINT__)
+#include <TClonesArray.h>
+#include <TBranch.h>
+#include <TTree.h>
+#include <TEveManager.h>
+#include <TEveElement.h>
+#include <TEvePointSet.h>
+
+#include <AliRunLoader.h>
+#include <AliCluster.h>
+#include <AliEveEventManager.h>
+#include <AliGeomManager.h>
+#include <AliITSUGeomTGeo.h>
+#include <AliITSUSegmentationPix.h>
+#include <TGeoManager.h>
+
+#else
+class TEveElement;
+class TEvePointSet;
+class TTree;
+class TBranch;
+#endif
+
+void itsU_clusters(TEveElement* cont=0, Float_t maxR=50)
+{
+ AliEveEventManager::AssertGeometry();
+
+ AliRunLoader* rl = AliEveEventManager::AssertRunLoader();
+ rl->LoadRecPoints("ITS");
+
+ gGeoManager = gEve->GetGeometry("geometry.root");
+ AliITSUGeomTGeo* gm = new AliITSUGeomTGeo(kTRUE);
+ TObjArray segmArr;
+ AliITSUSegmentationPix::LoadSegmentations(&segmArr, AliITSUGeomTGeo::GetITSsegmentationFileName());
+
+ TTree *cTree = rl->GetTreeR("ITS", false);
+ if (cTree == 0)
+ return ;
+
+ TObjArray layerClus;
+ int nlr=0;
+ while(1) {
+ TBranch* br = cTree->GetBranch(Form("ITSRecPoints%d",nlr));
+ if (!br) break;
+ TClonesArray* clr = 0;
+ br->SetAddress(&clr);
+ layerClus.AddLast(clr);
+ nlr++;
+ }
+
+ TEveElementList* evClusters = new TEveElementList("ITS clusters");
+ TEvePointSet* layClusters = 0;
+ // layClusters->SetOwnIds(kTRUE);
+
+ Int_t layOld =-1;
+ Int_t nentr = (Int_t) cTree->GetEntries();
+ cTree->GetEntry(0);
+ for (int ilr=0;ilr<nlr;ilr++) {
+ TClonesArray* clr = (TClonesArray*)layerClus.At(ilr);
+ int ncl = clr->GetEntries();
+
+ Float_t maxRsqr = maxR*maxR;
+ for (Int_t icl = 0; icl < ncl; ++icl) {
+ AliCluster *c = (AliCluster*) clr->UncheckedAt(icl);
+ Int_t mod = c->GetVolumeId();
+ // int detType = gm->GetModuleDetTypeID(mod);
+ // AliITSUSegmentationPix* segm = (AliITSUSegmentationPix*)segmArr.At(detType);
+ int lay,lad,det;
+ gm->GetModuleId(mod, lay,lad,det);
+
+ if (lay!=layOld) { // assumes order in the digits !
+ layOld=lay;
+ layClusters = new TEvePointSet(Form("ITS clusters - Layer %d",lay),10000);
+ // layClusters->ApplyVizTag(viz_tag, "Clusters");
+ layClusters->SetMarkerColor(kBlue);
+ layClusters->SetMarkerStyle(21);//kFullDotMedium);
+ layClusters->SetRnrSelf(kTRUE);
+ layClusters->SetOwnIds(kTRUE);
+
+ evClusters->AddElement(layClusters);
+ }
+
+ Double_t l[3]={c->GetX(),c->GetY(),c->GetZ()};
+ Double_t g[3];
+ gm->LocalToGlobal(mod,l,g);
+ if (g[0]*g[0] + g[1]*g[1] < maxRsqr) {
+ layClusters->SetNextPoint(g[0], g[1], g[2]);
+ AliCluster *atp = new AliCluster(*c);
+ layClusters->SetPointId(atp);
+ // printf("%d: mod %d: loc(%.4lf,%.4lf,%.4lf); glob(%.4lf,%.4lf,%.4lf); \n",
+ // icl,atp->GetVolumeId(), l[0],l[1],l[2], g[0],g[1],g[2]);
+ }
+ }
+ }
+
+ rl->UnloadRecPoints("ITS");
+
+ // clusters->SetTitle(Form("N=%d", clusters->Size()));
+
+ const TString viz_tag("REC Clusters ITS");
+
+ evClusters->ApplyVizTag(viz_tag, "Clusters");
+
+ gEve->AddElement(evClusters, cont);
+
+ gEve->Redraw3D();
+
+}
--- /dev/null
+#include "AliITSUClusterizer.h"
+
+
+ClassImp(AliITSUClusterizer)
+
+//______________________________________________________________________________
+AliITSUClusterizer::AliITSUClusterizer(Int_t initNRow)
+: fVolID(-1)
+ ,fSegm(0)
+ ,fInputDigits(0)
+ ,fInputDigitsReadIndex(0)
+ ,fOutputClusters(0)
+ ,fDigitFreelist(0)
+ ,fPartFreelist(0)
+ ,fCandFreelist(0)
+ ,fDigitFreelistBptrFirst(0)
+ ,fDigitFreelistBptrLast(0)
+ ,fPartFreelistBptr(0)
+ ,fCandFreelistBptr(0)
+{
+ SetUniqueID(0);
+ // c-tor
+ SetNRow(initNRow);
+}
+
+//______________________________________________________________________________
+void AliITSUClusterizer::SetSegmentation(const AliITSUSegmentationPix *segm)
+{
+ // attach segmentation, if needed, reinitialize array
+ fSegm = segm;
+ SetNRow(fSegm->GetNRow()); // reinitialize if needed
+
+}
+
+//______________________________________________________________________________
+void AliITSUClusterizer::SetNRow(Int_t nr)
+{
+ // update buffers
+ int nrOld = GetUniqueID();
+ if (nrOld>=nr) return;
+ SetUniqueID(nr);
+ while (fDigitFreelistBptrFirst) {
+ AliITSUClusterizerClusterDigit *next = fDigitFreelistBptrFirst[kDigitChunkSize-1].fNext;
+ delete[] fDigitFreelistBptrFirst;
+ fDigitFreelistBptrFirst=next;
+ }
+ delete[] fPartFreelistBptr;
+ delete[] fCandFreelistBptr;
+ //
+ fPartFreelist=fPartFreelistBptr = new AliITSUClusterizerClusterPart[nr+1];
+ fCandFreelist=fCandFreelistBptr = new AliITSUClusterizerClusterCand[nr+1];
+ for (int i=0;i<nr;++i) {
+ fPartFreelistBptr[i].fNextInRow = &fPartFreelistBptr[i+1];
+ fCandFreelistBptr[i].fNext = &fCandFreelistBptr[i+1];
+ }
+}
+
+//______________________________________________________________________________
+AliITSUClusterizer::~AliITSUClusterizer()
+{
+ // d-tor
+ while (fDigitFreelistBptrFirst) {
+ AliITSUClusterizerClusterDigit *next = fDigitFreelistBptrFirst[kDigitChunkSize-1].fNext;
+ delete[] fDigitFreelistBptrFirst;
+ fDigitFreelistBptrFirst=next;
+ }
+ delete[] fPartFreelistBptr;
+ delete[] fCandFreelistBptr;
+}
+
+//______________________________________________________________________________
+AliITSUClusterizer::AliITSUClusterizerClusterDigit* AliITSUClusterizer::AllocDigitFreelist()
+{
+ // allocate aux space
+ AliITSUClusterizerClusterDigit *tmp = new AliITSUClusterizerClusterDigit[kDigitChunkSize];
+ for (int i=0;i<kDigitChunkSize-2;++i) tmp[i].fNext=&tmp[i+1];
+ tmp[kDigitChunkSize-2].fNext=0;
+ tmp[kDigitChunkSize-1].fNext=0;
+ if (!fDigitFreelistBptrFirst) fDigitFreelistBptrFirst=tmp;
+ else fDigitFreelistBptrLast[kDigitChunkSize-1].fNext=tmp;
+ fDigitFreelistBptrLast=tmp;
+ return tmp;
+}
+
+//______________________________________________________________________________
+AliITSUClusterizer::AliITSUClusterizerClusterDigit* AliITSUClusterizer::NextDigit()
+{
+ // get next digit
+ if (fInputDigitsReadIndex<fInputDigits->GetEntriesFast()) {
+ AliITSdigit *tmp=static_cast<AliITSdigit*>(fInputDigits->UncheckedAt(fInputDigitsReadIndex++));
+ AliITSUClusterizerClusterDigit *digit=AllocDigit();
+ digit->fDigit=tmp;
+ // IMPORTANT: A lexiographical order (fV,fU) is assumed
+ digit->fU=tmp->GetCoord1();
+ digit->fV=tmp->GetCoord2();
+ return digit;
+ }
+ else
+ return 0;
+}
+
+//______________________________________________________________________________
+void AliITSUClusterizer::AttachPartToCand(AliITSUClusterizerClusterCand *cand,AliITSUClusterizerClusterPart *part)
+{
+ // attach part
+ part->fParent = cand;
+ part->fPrevInCluster = 0;
+ part->fNextInCluster = cand->fFirstPart;
+ if (cand->fFirstPart) cand->fFirstPart->fPrevInCluster = part;
+ cand->fFirstPart=part;
+}
+
+//______________________________________________________________________________
+void AliITSUClusterizer::MergeCands(AliITSUClusterizerClusterCand *a,AliITSUClusterizerClusterCand *b)
+{
+ // merge cluster parts
+ AliITSUClusterizerClusterPart *ipart=b->fFirstPart;
+ AliITSUClusterizerClusterPart *jpart;
+ do {
+ jpart=ipart;
+ jpart->fParent=a;
+ } while ((ipart=ipart->fNextInCluster));
+ jpart->fNextInCluster=a->fFirstPart;
+ jpart->fNextInCluster->fPrevInCluster=jpart;
+ a->fFirstPart=b->fFirstPart;
+ // merge digits
+ b->fLastDigit->fNext=a->fFirstDigit;
+ a->fFirstDigit=b->fFirstDigit;
+ // DeallocCand(b);
+}
+
+//______________________________________________________________________________
+void AliITSUClusterizer::Transform(AliCluster *cluster,AliITSUClusterizerClusterCand *cand)
+{
+ // convert set of digits to clusted data
+ Double_t su=0.,sv=0.;
+ Int_t n=0;
+ cand->fLastDigit->fNext=0;
+ for (AliITSUClusterizerClusterDigit *idigit=cand->fFirstDigit;idigit;idigit=idigit->fNext) {
+ su+=idigit->fU;
+ sv+=idigit->fV;
+ ++n;
+ }
+ Double_t fac=1./n; // Todo: weighting by signal
+ Double_t detX = fac*sv, detZ = fac*su;
+
+ // Set local coordinates
+ Float_t x = detX, z = detZ;
+ if (fSegm) { // local coordinates in cm
+ x = (-0.5*fSegm->Dx() + detX*fSegm->Dpx() + 0.5*fSegm->Dpx());
+ z = (-0.5*fSegm->Dz() + detZ*fSegm->Dpz(0)+ 0.5*fSegm->Dpz(0));
+ }
+ cluster->SetX(x);
+ cluster->SetZ(z);
+ // Set Volume id
+ cluster->SetVolumeId(fVolID);
+ // printf("mod %d: (%.4lf,%.4lf)cm\n",fVolID,x,z);
+}
+
+//______________________________________________________________________________
+void AliITSUClusterizer::CloseCand(AliITSUClusterizerClusterCand *cand)
+{
+ // finish cluster
+ AliCluster *cluster=NextCluster();
+ Transform(cluster,cand);
+ DeallocDigits(cand->fFirstDigit,cand->fLastDigit);
+ DeallocCand(cand);
+}
+
+//______________________________________________________________________________
+void AliITSUClusterizer::ClosePart(AliITSUClusterizerClusterPart *part)
+{
+ // finish cluster part
+ AliITSUClusterizerClusterCand *cand=part->fParent;
+ DetachPartFromCand(cand,part);
+ DeallocPart(part);
+ if (!cand->fFirstPart) CloseCand(cand);
+}
+
+//______________________________________________________________________________
+void AliITSUClusterizer::CloseRemainingParts(AliITSUClusterizerClusterPart *part)
+{
+ // finish what is left
+ while (part) {
+ AliITSUClusterizerClusterPart *next=part->fNextInRow;
+ ClosePart(part);
+ part=next;
+ }
+}
+
+//______________________________________________________________________________
+void AliITSUClusterizer::Clusterize()
+{
+ // main algo
+ AliITSUClusterizerClusterDigit *iDigit=NextDigit();
+ AliITSUClusterizerClusterPart *iPrevRowBegin=0;
+ AliITSUClusterizerClusterPart *iNextRowBegin=0;
+ AliITSUClusterizerClusterPart *iPrevRow=0;
+ AliITSUClusterizerClusterPart *iNextRow=0;
+ Int_t lastV=0;
+ while (iDigit) {
+ if (iDigit->fV!=lastV) {
+ // NEW ROW
+ if (iNextRow) iNextRow->fNextInRow=0;
+ if (iPrevRowBegin) CloseRemainingParts(iPrevRowBegin);
+ if (iDigit->fV==lastV+1) {
+ iPrevRowBegin=iNextRowBegin;
+ iPrevRow =iNextRowBegin;
+ }
+ else {
+ // there was an empty row
+ CloseRemainingParts(iNextRowBegin);
+ iPrevRowBegin=0;
+ iPrevRow =0;
+ }
+ iNextRowBegin=0;
+ iNextRow =0;
+ lastV=iDigit->fV;
+ }
+ // skip cluster parts before this digit
+ while (iPrevRow && iPrevRow->fUEnd<iDigit->fU) {
+ iPrevRow=iPrevRow->fNextInRow;
+ }
+ // find the longest continous line of digits [iDigit,pDigit]=[iDigit,jDigit)
+ AliITSUClusterizerClusterCand *cand=AllocCand();
+ AliITSUClusterizerClusterDigit *pDigit=iDigit;
+ AliITSUClusterizerClusterDigit *jDigit=NextDigit();
+ cand->fFirstPart=0;
+ cand->fFirstDigit=cand->fLastDigit=iDigit; // NB: first diggit is attached differently
+ iDigit->fNext=0;
+ Int_t lastU =iDigit->fU;
+ Int_t lastU1=lastU+1;
+ while (jDigit && jDigit->fU==lastU1 && jDigit->fV==lastV) {
+ pDigit=jDigit;
+ jDigit=NextDigit();
+ AttachDigitToCand(cand,pDigit);
+ ++lastU1;
+ }
+ --lastU1;
+ AliITSUClusterizerClusterPart *part=AllocPart();
+ part->fUBegin=lastU ;
+ part->fUEnd =lastU1;
+ AttachPartToCand(cand,part);
+ // merge all cluster candidates of the previous line touching this one,
+ // advance to the last one, but keep that one the next active one
+ AliITSUClusterizerClusterPart *jPrevRow=iPrevRow;
+ while (jPrevRow && jPrevRow->fUBegin<=lastU1) {
+ if (jPrevRow->fParent!=cand) {
+ MergeCands(jPrevRow->fParent,cand);
+ DeallocCand(cand);
+ cand=jPrevRow->fParent;
+ }
+ iPrevRow=jPrevRow;
+ jPrevRow=jPrevRow->fNextInRow;
+ }
+ if (iNextRow)
+ iNextRow->fNextInRow=part;
+ else
+ iNextRowBegin=part;
+ iNextRow=part;
+ iDigit=jDigit;
+ }
+ // remove remaining cluster parts
+ CloseRemainingParts(iPrevRowBegin);
+ if (iNextRow) iNextRow->fNextInRow=0;
+ CloseRemainingParts(iNextRowBegin);
+ return;
+}
--- /dev/null
+#ifndef ALIITSUCLUSTERIZER_H\r
+#define ALIITSUCLUSTERIZER_H\r
+\r
+#include <AliCluster.h>\r
+#include <AliITSdigit.h>\r
+#include <TTree.h>\r
+#include <TObjArray.h>\r
+#include <TClonesArray.h>\r
+#include <AliITSUSegmentationPix.h>\r
+\r
+class AliITSUClusterizer : public TObject \r
+{\r
+ //\r
+ public:\r
+ enum {kDigitChunkSize=1024};\r
+ //\r
+ AliITSUClusterizer(Int_t nrowInit=0);\r
+ virtual ~AliITSUClusterizer();\r
+ void Clusterize();\r
+ void SetSegmentation(const AliITSUSegmentationPix *segm);\r
+ void SetVolID(Int_t id) {fVolID = id;}\r
+ void SetNRow(Int_t nrow);\r
+ // interface methods\r
+ void MakeRecPointBranch(TTree */*treeR*/) {};\r
+ void SetRecPointTreeAddress(TTree */*treeR*/) {};\r
+ void DigitsToRecPoints(const TObjArray */*digList*/) {};\r
+ \r
+ void SetDigits(TClonesArray *digits) {fInputDigits=digits;fInputDigitsReadIndex=0;}\r
+ void SetClusters(TClonesArray *clusters) {fOutputClusters=clusters;}\r
+\r
+ protected: // transient data types\r
+ struct AliITSUClusterizerClusterDigit {\r
+ AliITSUClusterizerClusterDigit *fNext;\r
+ AliITSdigit *fDigit;\r
+ Int_t fU;\r
+ Int_t fV;\r
+ };\r
+ \r
+ struct AliITSUClusterizerClusterCand;\r
+ struct AliITSUClusterizerClusterPart {\r
+ AliITSUClusterizerClusterPart *fNextInRow;\r
+ AliITSUClusterizerClusterPart *fPrevInCluster;\r
+ AliITSUClusterizerClusterPart *fNextInCluster;\r
+ AliITSUClusterizerClusterCand *fParent;\r
+ Int_t fUBegin;\r
+ Int_t fUEnd;\r
+ };\r
+ \r
+ struct AliITSUClusterizerClusterCand {\r
+ AliITSUClusterizerClusterCand *fNext; // only used for memory management\r
+ AliITSUClusterizerClusterPart *fFirstPart;\r
+ AliITSUClusterizerClusterDigit *fFirstDigit;\r
+ AliITSUClusterizerClusterDigit *fLastDigit ;\r
+ };\r
+\r
+ protected:\r
+ //\r
+ // allocation and deallocation\r
+ AliITSUClusterizerClusterDigit* AllocDigitFreelist();\r
+ AliITSUClusterizerClusterCand* AllocCand();\r
+ void DeallocCand(AliITSUClusterizerClusterCand *cand);\r
+ AliITSUClusterizerClusterPart* AllocPart();\r
+ void DeallocPart(AliITSUClusterizerClusterPart *part) {DeallocParts(part,part); }\r
+ void DeallocParts(AliITSUClusterizerClusterPart *first,AliITSUClusterizerClusterPart *last);\r
+ AliITSUClusterizerClusterDigit* AllocDigit();\r
+ void DeallocDigit(AliITSUClusterizerClusterDigit *digit) {DeallocDigits(digit,digit);}\r
+ void DeallocDigits(AliITSUClusterizerClusterDigit *first,AliITSUClusterizerClusterDigit *last);\r
+\r
+ // input "iterator"\r
+ AliITSUClusterizerClusterDigit* NextDigit();\r
+ // output "iterator"\r
+ AliCluster* NextCluster() {return new( (*fOutputClusters)[fOutputClusters->GetEntries()] ) AliCluster();}\r
+ \r
+ // modifiers\r
+ void AttachDigitToCand(AliITSUClusterizerClusterCand *cand,AliITSUClusterizerClusterDigit *digit);\r
+ void AttachPartToCand(AliITSUClusterizerClusterCand *cand,AliITSUClusterizerClusterPart *part);\r
+ void DetachPartFromCand(AliITSUClusterizerClusterCand *cand,AliITSUClusterizerClusterPart *part);\r
+ void MergeCands(AliITSUClusterizerClusterCand *a,AliITSUClusterizerClusterCand *b);\r
+\r
+ void Transform(AliCluster *cluster,AliITSUClusterizerClusterCand *cand);\r
+ void CloseCand(AliITSUClusterizerClusterCand *cand);\r
+ void ClosePart(AliITSUClusterizerClusterPart *part);\r
+\r
+ void CloseRemainingParts(AliITSUClusterizerClusterPart *part);\r
+ //\r
+ protected:\r
+ //\r
+ Int_t fVolID; // Volume id (module index)\r
+ const AliITSUSegmentationPix* fSegm; // Segmentation or local coord calc.\r
+ //\r
+ // Digit Input\r
+ TClonesArray *fInputDigits;\r
+ Int_t fInputDigitsReadIndex;\r
+ // Cluster Output\r
+ TClonesArray *fOutputClusters;\r
+ \r
+ // temporary variables\r
+ AliITSUClusterizerClusterDigit *fDigitFreelist ; //! \r
+ AliITSUClusterizerClusterPart *fPartFreelist ; //!\r
+ AliITSUClusterizerClusterCand *fCandFreelist ; //!\r
+ AliITSUClusterizerClusterDigit *fDigitFreelistBptrFirst; //!\r
+ AliITSUClusterizerClusterDigit *fDigitFreelistBptrLast ; //!\r
+ AliITSUClusterizerClusterPart *fPartFreelistBptr ; //!\r
+ AliITSUClusterizerClusterCand *fCandFreelistBptr ; //!\r
+ //\r
+ private:\r
+ AliITSUClusterizer(const AliITSUClusterizer&); //Not implemented\r
+ AliITSUClusterizer& operator=(const AliITSUClusterizer&); //Not implemented\r
+ //\r
+ ClassDef(AliITSUClusterizer,0)\r
+};\r
+\r
+\r
+//_______________________________________________________________________________\r
+inline void AliITSUClusterizer::DeallocCand(AliITSUClusterizerClusterCand *cand)\r
+{\r
+ // free candidate\r
+ cand->fNext=fCandFreelist;\r
+ fCandFreelist=cand;\r
+}\r
+\r
+//_______________________________________________________________________________\r
+inline void AliITSUClusterizer::DeallocParts(AliITSUClusterizerClusterPart *first,AliITSUClusterizerClusterPart *last)\r
+{\r
+ // free cluster part\r
+ last->fNextInRow=fPartFreelist;\r
+ fPartFreelist=first;\r
+}\r
+\r
+//_______________________________________________________________________________\r
+inline AliITSUClusterizer::AliITSUClusterizerClusterDigit* AliITSUClusterizer::AllocDigit()\r
+{\r
+ // allocate digits\r
+ if (!fDigitFreelist) fDigitFreelist = AllocDigitFreelist();\r
+ AliITSUClusterizerClusterDigit *digit = fDigitFreelist;\r
+ fDigitFreelist = fDigitFreelist->fNext;\r
+ return digit;\r
+}\r
+\r
+//_______________________________________________________________________________\r
+inline AliITSUClusterizer::AliITSUClusterizerClusterPart* AliITSUClusterizer::AllocPart()\r
+{\r
+ // allocate cluster part\r
+ AliITSUClusterizerClusterPart *part=fPartFreelist;\r
+ fPartFreelist=fPartFreelist->fNextInRow;\r
+ return part;\r
+}\r
+\r
+//_______________________________________________________________________________\r
+inline AliITSUClusterizer::AliITSUClusterizerClusterCand* AliITSUClusterizer::AllocCand()\r
+{\r
+ // allocate cluster \r
+ AliITSUClusterizerClusterCand *cand=fCandFreelist;\r
+ fCandFreelist=fCandFreelist->fNext;\r
+ return cand;\r
+}\r
+\r
+//_______________________________________________________________________________\r
+inline void AliITSUClusterizer::DeallocDigits(AliITSUClusterizerClusterDigit *first, AliITSUClusterizerClusterDigit *last) \r
+{\r
+ // free digit\r
+ last->fNext = fDigitFreelist;\r
+ fDigitFreelist = first;\r
+}\r
+\r
+//_______________________________________________________________________________\r
+inline void AliITSUClusterizer::AttachDigitToCand(AliITSUClusterizerClusterCand *cand,AliITSUClusterizerClusterDigit *digit) \r
+{\r
+ // attach digit\r
+ digit->fNext = cand->fFirstDigit;\r
+ cand->fFirstDigit = digit;\r
+}\r
+\r
+//_______________________________________________________________________________\r
+inline void AliITSUClusterizer::DetachPartFromCand(AliITSUClusterizerClusterCand *cand,AliITSUClusterizerClusterPart *part) \r
+{\r
+ // remove cluster part \r
+ if (part->fPrevInCluster) part->fPrevInCluster->fNextInCluster=part->fNextInCluster;\r
+ else cand->fFirstPart=part->fNextInCluster;\r
+ if (part->fNextInCluster) part->fNextInCluster->fPrevInCluster=part->fPrevInCluster;\r
+}\r
+\r
+\r
+#endif\r
+\r
--- /dev/null
+/**************************************************************************
+ * 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. *
+ **************************************************************************/
+
+/* $Id: AliITSUReconstructor.cxx 58442 2012-09-04 17:17:06Z masera $ */
+
+///////////////////////////////////////////////////////////////////////////////
+// //
+// class for ITS reconstruction //
+// //
+///////////////////////////////////////////////////////////////////////////////
+
+#include "Riostream.h"
+#include "AliITSUReconstructor.h"
+#include "AliRun.h"
+#include "AliRawReader.h"
+#include "AliESDEvent.h"
+
+#include "AliTracker.h"
+#include "AliITStrackerMI.h"
+
+#include "AliITSUGeomTGeo.h"
+#include "AliITSUSegmentationPix.h"
+#include "AliITSUDigitPix.h"
+#include "AliITSUClusterizer.h"
+
+ClassImp(AliITSUReconstructor)
+
+//___________________________________________________________________________
+AliITSUReconstructor::AliITSUReconstructor()
+: AliReconstructor()
+ ,fGM(0)
+ ,fSegmArr(0)
+ ,fClusterFinders(0)
+ ,fRecPoints(0)
+{
+ // Default constructor
+
+}
+
+//___________________________________________________________________________
+AliITSUReconstructor::~AliITSUReconstructor()
+{
+ // destructor
+ //
+ if (!fGM) return; // was not initialized
+ //
+ // same cluster finders and recpoint arrays might be attached to different layers
+ for (int i=fGM->GetNLayers();i--;) {
+ TObject* clFinder = fClusterFinders.At(i);
+ if (clFinder) {
+ while (fClusterFinders.Remove(clFinder)) {}
+ delete clFinder;
+ }
+ //
+ TObject* arrRP = fRecPoints.At(i);
+ if (arrRP) {
+ while (fRecPoints.Remove(arrRP)) {}
+ delete arrRP;
+ }
+ }
+ //
+ delete fGM;
+ fSegmArr.Delete();
+}
+
+//______________________________________________________________________
+void AliITSUReconstructor::Init()
+{
+ //
+ // Initalize this constructor
+ if (fGM) AliFatal("was already done, something is wrong...");
+ //
+ fGM = new AliITSUGeomTGeo(kTRUE);
+ AliITSUSegmentationPix::LoadSegmentations(&fSegmArr, AliITSUGeomTGeo::GetITSsegmentationFileName());
+ //
+ AliITSUClusterizer* clusPIX = 0;
+ TClonesArray* rpArrayPix = 0;
+ //
+ for (int ilr=fGM->GetNLayers();ilr--;) {
+ int tp = fGM->GetLayerDetTypeID(ilr);
+ int tpDet = tp/AliITSUGeomTGeo::kMaxSegmPerDetType;
+ if (tpDet == AliITSUGeomTGeo::kDetTypePix) {
+ if (!clusPIX) clusPIX = new AliITSUClusterizer();
+ if (!rpArrayPix) rpArrayPix = new TClonesArray(AliCluster::Class());
+ //
+ fClusterFinders.AddAtAndExpand(clusPIX, ilr);
+ fRecPoints.AddAtAndExpand(rpArrayPix, ilr);
+ //
+ AliITSUSegmentationPix* sg = (AliITSUSegmentationPix*)fSegmArr.At(tp);
+ clusPIX->SetSegmentation(sg); // to expand the buffers to max.size
+ continue;
+ }
+ else {
+ AliFatal(Form("ClusterFinder for detector type %d is not defined",tpDet));
+ }
+ }
+ //
+ return;
+
+}
+
+//_____________________________________________________________________________
+void AliITSUReconstructor::Reconstruct(TTree *digitsTree, TTree *clustersTree) const
+{
+ // reconstruct clusters
+ if (!digitsTree || !clustersTree) return;
+ AliDebug(1,"ITSU Cluster finder (from digits tree) is initiated here \n");
+ //
+ // At the moment only pixel digits
+ TClonesArray *digArrPix = 0;
+ digitsTree->SetBranchAddress("ITSDigitsPix",&digArrPix);
+ //
+ // a new tree is created for each event: add each layer as separate branch
+ TBranch *lrBranch[fGM->GetNLayers()];
+ TClonesArray *rpClones[fGM->GetNLayers()];
+ //
+ for (int ilr=0;ilr<fGM->GetNLayers();ilr++) {
+ rpClones[ilr] = (TClonesArray*)fRecPoints.At(ilr);
+ int tp = fGM->GetLayerDetTypeID(ilr)/AliITSUGeomTGeo::kMaxSegmPerDetType;
+ if (tp==AliITSUGeomTGeo::kDetTypePix) {
+ lrBranch[ilr] = clustersTree->Bronch(Form("ITSRecPoints%d",ilr),"TClonesArray",&rpClones[ilr]);
+ }
+ else {
+ AliFatal(Form("Detector type %d is not defined",tp));
+ }
+ }
+ //
+ AliITSUClusterizer* clFinder = 0;
+ //
+ for (int ilr=0;ilr<fGM->GetNLayers();ilr++) {
+ //
+ int tp = fGM->GetLayerDetTypeID(ilr)/AliITSUGeomTGeo::kMaxSegmPerDetType;
+ AliITSUSegmentationPix* segm = (AliITSUSegmentationPix*)fSegmArr.At(tp);
+ //
+ clFinder = (AliITSUClusterizer*)fClusterFinders[ilr];
+ clFinder->SetSegmentation(segm);
+ clFinder->SetClusters(rpClones[ilr]);
+ //
+ int modF=fGM->GetFirstModIndex(ilr);
+ int modL=fGM->GetLastModIndex(ilr)+1;
+ for (int imod=modF;imod<modL;imod++) {
+ digitsTree->GetEntry(imod);
+ int ndig = digArrPix->GetEntries();
+ if (!ndig) continue;
+ clFinder->SetVolID(imod);
+ clFinder->SetDigits(digArrPix);
+ clFinder->Clusterize();
+ }
+ //
+ AliDebug(1,Form(" -> Lr%d : %d Cluster",ilr,rpClones[ilr]->GetEntries()));
+ lrBranch[ilr]->Fill();
+ rpClones[ilr]->Clear();
+ }
+ clustersTree->SetEntries();
+ //
+}
+
+//_____________________________________________________________________________
+AliTracker* AliITSUReconstructor::CreateTracker() const
+{
+ // create a ITS tracker
+
+ AliDebug(1,"ITSU tracking initialization will be done here\n");
+
+ return 0;
+
+ /* // from Current ITS
+ Int_t trackerOpt = GetRecoParam()->GetTracker();
+ AliTracker* tracker;
+ if (trackerOpt==1) {
+ tracker = new AliITStrackerMI(0);
+ AliITStrackerMI *mit=(AliITStrackerMI*)tracker;
+ mit->SetDetTypeRec(fDetTypeRec);
+ }
+ else if (trackerOpt==2) {
+ tracker = new AliITStrackerV2(0);
+ }
+ else {
+ tracker = new AliITStrackerSA(0); // inherits from AliITStrackerMI
+ AliITStrackerSA *sat=(AliITStrackerSA*)tracker;
+ sat->SetDetTypeRec(fDetTypeRec);
+ if(GetRecoParam()->GetTrackerSAOnly()) sat->SetSAFlag(kTRUE);
+ if(sat->GetSAFlag())AliDebug(1,"Tracking Performed in ITS only\n");
+ if(GetRecoParam()->GetInwardFindingSA()){
+ sat->SetInwardFinding();
+ sat->SetInnerStartLayer(GetRecoParam()->GetInnerStartLayerSA());
+ }else{
+ sat->SetOutwardFinding();
+ sat->SetOuterStartLayer(GetRecoParam()->GetOuterStartLayerSA());
+ }
+ sat->SetMinNPoints(GetRecoParam()->GetMinNPointsSA());
+ }
+
+ return tracker;
+ */
+
+}
+
+//_____________________________________________________________________________
+AliVertexer* AliITSUReconstructor::CreateVertexer() const
+{
+ // create a ITS vertexer
+ // to be implemented for the upgrade
+
+ AliDebug(1,"ITSU vertexer should be initiated here\n");
+ return 0;
+
+}
+
+//_____________________________________________________________________________
+AliTrackleter* AliITSUReconstructor::CreateMultFinder() const
+{
+ // create the SPD trackeleter for mult. reconstruction
+ // to be implemented for the upgrade
+
+ AliDebug(1,"ITSU MultFinder should be initiated here\n");
+ return 0;
+
+}
+
+//_____________________________________________________________________________
+AliTracker* AliITSUReconstructor::CreateTrackleter() const
+{
+ // create the SPD trackeleter (for SPD PlaneEfficiency evaluation)
+ // to be implemented for the upgrade
+
+ AliDebug(1,"ITSU Trackleter should be initiated here\n");
+ return 0;
+
+}
+
--- /dev/null
+#ifndef ALIITSURECONSTRUCTOR_H
+#define ALIITSURECONSTRUCTOR_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id: AliITSUReconstructor.h 54053 2012-01-22 22:12:15Z masera $ */
+///////////////////////////////////////////////////////////////////////////////
+// //
+// class for ITS reconstruction //
+// //
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AliReconstructor.h"
+#include "AliITSURecoParam.h"
+
+class AliTracker;
+class AliTrackleter;
+class AliITSUGeomTGeo;
+
+class AliITSUReconstructor: public AliReconstructor {
+public:
+ AliITSUReconstructor();
+ virtual ~AliITSUReconstructor();
+ virtual void Init();
+ virtual void Reconstruct(TTree *digitsTree, TTree *clustersTree) const;
+ virtual void Reconstruct(AliRawReader*, TTree*) const {};
+
+ virtual AliTracker* CreateTracker() const;
+ virtual AliVertexer* CreateVertexer() const;
+ virtual AliTrackleter* CreateMultFinder() const;
+ virtual AliTracker* CreateTrackleter() const;
+
+ static const AliITSURecoParam* GetRecoParam() {
+ return dynamic_cast<const AliITSURecoParam*>(AliReconstructor::GetRecoParam(0)); }
+
+private:
+ AliITSUReconstructor(const AliITSUReconstructor &); //Not implemented
+ AliITSUReconstructor& operator=(const AliITSUReconstructor &); //Not implemented
+
+ AliITSUGeomTGeo* fGM; // geometry wrapper
+ TObjArray fSegmArr; // Array of different pixel segmentations
+ TObjArray fClusterFinders; // array of clusterfinders per layer
+ TObjArray fRecPoints; // container for recpoints TClonesArrays
+ //
+ ClassDef(AliITSUReconstructor, 0) // class for the ITSU reconstruction
+};
+
+#endif
// We have all shapes: now create the real volumes
- TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
+ // TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
TGeoMedium *medSi = mgr->GetMedium("ITS_SI$");
snprintf(volname, 30, "%s%d", AliITSUGeomTGeo::GetITSModulePattern() ,fLayerNumber);
- TGeoVolume *modVol = new TGeoVolume(volname, module, medAir);
+ // TGeoVolume *modVol = new TGeoVolume(volname, module, medAir);
+ TGeoVolume *modVol = new TGeoVolume(volname, module, medSi);
modVol->SetVisibility(kFALSE);
modVol->SetLineColor(1);
# SHLIBS - Shared Libraries and objects for linking (Executables only) #
#--------------------------------------------------------------------------------#
-set ( SRCS
+set ( SRCS
AliITSURecoParam.cxx
+ AliITSUReconstructor.cxx
+ AliITSUClusterizer.cxx
#
- v0/AliITSlayerUpgrade.cxx
- v0/AliITStrackerUpgrade.cxx
- v0/AliITStrackU.cxx
- v0/AliITStrackerU.cxx
- v0/AliITSUpgradeReconstructor.cxx
- v0/AliITSUpgradeClusterList.cxx
- v0/AliITSUpgradeClusterListNode.cxx
- v0/AliITSUPixelModule.cxx
- v0/AliITSUpgradeClusterFinder.cxx
+# v0/AliITSlayerUpgrade.cxx
+# v0/AliITStrackerUpgrade.cxx
+# v0/AliITStrackU.cxx
+# v0/AliITStrackerU.cxx
+# v0/AliITSUpgradeReconstructor.cxx
+# v0/AliITSUpgradeClusterList.cxx
+# v0/AliITSUpgradeClusterListNode.cxx
+# v0/AliITSUPixelModule.cxx
+# v0/AliITSUpgradeClusterFinder.cxx
)
string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
#--------------------------------------------------------------------------------#
set ( SRCS
-v0/AliITSupgrade.cxx
-v0/AliITSupgradeDigitizer.cxx
+#v0/AliITSupgrade.cxx
+#v0/AliITSupgradeDigitizer.cxx
#
AliITSU.cxx
AliITSUv11.cxx
set ( DHDR ITSUpgradeSimLinkDef.h)
-set ( EINCLUDE TPC RAW ITS ITS/UPGRADE ITS/UPGRADE/v0 STEER/STEER STEER/ESD STEER/STEERBase )
+#set ( EINCLUDE TPC RAW ITS ITS/UPGRADE ITS/UPGRADE/v0 STEER/STEER STEER/ESD STEER/STEERBase )
+set ( EINCLUDE TPC RAW ITS ITS/UPGRADE STEER/STEER STEER/ESD STEER/STEERBase )
// ITS upgrade classes
#pragma link C++ class AliITSURecoParam+;
+#pragma link C++ class AliITSUReconstructor+;
+#pragma link C++ class AliITSUClusterizer+;
+
//
-//
-#pragma link C++ class AliITSlayerUpgrade+;
+
+// old v0
+/*#pragma link C++ class AliITSlayerUpgrade+;
#pragma link C++ class AliITStrackerUpgrade+;
#pragma link C++ class AliITStrackU+;
#pragma link C++ class AliITStrackerU+;
#pragma link C++ class AliITSUpgradeClusterListNode+;
#pragma link C++ class AliITSUPixelModule+;
#pragma link C++ class AliITSUpgradeClusterFinder+;
+*/
#endif
// ITS upgrade classes
//v0 part >>>. obsolete?
-#pragma link C++ class AliITSupgrade+;
-#pragma link C++ class AliITSupgradeDigitizer+;
+//#pragma link C++ class AliITSupgrade+;
+//#pragma link C++ class AliITSupgradeDigitizer+;
//v0 part <<<
//
#pragma link C++ class AliITSU+;
--- /dev/null
+void readClusters(){
+
+ gSystem->Load("libITSUpgradeBase");
+ gSystem->Load("libITSUpgradeRec");
+ gROOT->SetStyle("Plain");
+
+ gAlice=NULL;
+ AliRunLoader* runLoader = AliRunLoader::Open("galice.root");
+ runLoader->LoadgAlice();
+
+ gAlice = runLoader->GetAliRun();
+
+ runLoader->LoadHeader();
+ runLoader->LoadKinematics();
+ runLoader->LoadRecPoints();
+
+ AliLoader *dl = runLoader->GetDetectorLoader("ITS");
+
+ AliGeomManager::LoadGeometry("geometry.root");
+ AliITSUGeomTGeo* gm = new AliITSUGeomTGeo(kTRUE);
+ Int_t nLayers = gm->GetNLayers();
+
+ TH2F *xyGlob = new TH2F("xyGlob"," X - Y Global coordinates ",500,-50,50,500,-50,50);
+ xyGlob->SetXTitle("cm");
+ xyGlob->SetMarkerStyle(7);
+ TH1F *zGlob = new TH1F("zGlob", " Z Global coordinates ",200, -50,50 );
+ zGlob->SetXTitle("cm");
+
+
+ TTree * cluTree = 0x0;
+ TObjArray layerClus;
+
+ printf("N Events : %i \n",(Int_t)runLoader->GetNumberOfEvents());
+
+ for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
+ printf("\n Event %i \n",iEvent);
+ runLoader->GetEvent(iEvent);
+ // AliStack *stack = runLoader->Stack();
+ cluTree=dl->TreeR();
+ int nlr=0;
+ while(1) {
+ TBranch* br = cluTree->GetBranch(Form("ITSRecPoints%d",nlr));
+ if (!br) break;
+ TClonesArray* clr = 0;
+ br->SetAddress(&clr);
+ layerClus.AddLast(clr);
+ nlr++;
+ }
+
+ printf(" tree entries: %d\n",cluTree->GetEntries());
+ cluTree->GetEntry(0);
+ //
+ for (int ilr=0;ilr<nlr;ilr++) {
+ TClonesArray* clr = (TClonesArray*)layerClus.At(ilr);
+ int nClu = clr->GetEntries();
+ printf("Layer %d : %d clusters\n",ilr,nClu);
+ //
+ for (int icl=0;icl<nClu;icl++) {
+ AliCluster *cl = (AliCluster*)clr->At(icl);
+ Double_t loc[3]={cl->GetX(),cl->GetY(),cl->GetZ()};
+ Double_t glob[3];
+ gm->LocalToGlobal(cl->GetVolumeId(),loc,glob);
+ printf("%d: mod %d: loc(%.4lf,%.4lf,%.4lf); glob(%.4lf,%.4lf,%.4lf); \n",icl,cl->GetVolumeId(),
+ loc[0],loc[1],loc[2],glob[0],glob[1],glob[2]);
+
+ xyGlob->Fill(glob[0],glob[1]);
+ zGlob->Fill(glob[2]);
+
+ }
+ }
+ layerClus.Clear();
+ }//event loop
+
+ Int_t size = 400;
+
+ TCanvas *xyCanv = new TCanvas("xvCanvClus","RecPoint X-Y Positions",10,10,size,size);
+ xyCanv->cd();
+ xyGlob->Draw("P");
+
+ TCanvas *zCanv = new TCanvas("zCanvClus","RecPoint Z Positions",size+20,10,size,size);
+ zCanv->cd();
+ zGlob->Draw();
+
+}
int lr = gm->GetLayer(id);
int ld = gm->GetLadder(id);
//
- if(pHit->GetParticle()->IsPrimary()){
- Double_t xg,yg,zg=0.;
- pHit->GetPositionG(xg,yg,zg);
- xyGlob->Fill(xg,yg);
- zGlob->Fill(zg);
- printf("Module %d | Lr:%d Ladder: %d\n",id,lr,ld);
- hDeLoss[lr]->Fill(pHit->GetIonization());
- } // is primary
+ // if(pHit->GetParticle()->IsPrimary()){
+ Double_t xg,yg,zg=0.;
+ pHit->GetPositionG(xg,yg,zg);
+ xyGlob->Fill(xg,yg);
+ zGlob->Fill(zg);
+ printf("Module %d | Lr:%d Ladder: %d, X:%+.3e Y:%+.3e Z:%+.3e TrackID: %d\n",id,lr,ld,xg,yg,zg,pHit->GetTrack());
+ hDeLoss[lr]->Fill(pHit->GetIonization());
+ // } // is primary
}//loop hit
}//entryloopHitList
void rec() {
- //AliLog::SetClassDebugLevel("AliITStrackerUpgrade",5);
+
+ // AliLog::SetClassDebugLevel("AliReconstruction",1);
+ AliLog::SetClassDebugLevel("AliITSUReconstructor",1);
TDatime t;
gSystem->Load("libITSUpgradeRec.so");
gSystem->Exec("rm -rf *RecPoints* AliESD*");
- AliITSRecoParam *p = AliITSRecoParam::GetLowFluxParam();
- p->SetTrackerSAOnly();
- p->SetInwardFindingSA();
+ // Set ITS upgrade reconstructor
+ gPluginMgr->AddHandler("AliReconstructor", "*",
+ "AliITSUReconstructor","ITS", "AliITSUReconstructor()");
+
AliReconstruction rec;
- rec.SetRecoParam("ITS",p);
- rec.SetRunReconstruction("ITS");
- rec.SetUpgradeModule("ITS");
- rec.SetRunVertexFinder(kFALSE);
- rec.SetRunTracking("ITS");
- rec.SetFillESD("ITS");
- rec.SetDefaultStorage("local://$ALICE_ROOT/OCDB");
- rec.SetRunMultFinder(kFALSE);
+
+ rec.SetRunReconstruction("ITS"); // run cluster finder
+ rec.SetRunTracking(""); // Turn on with ITS when tracker is implemented
+
+ rec.SetRunVertexFinder(kFALSE); // to be implemented - CreateVertexer
+ rec.SetRunMultFinder(kFALSE); // to be implemented - CreateMultFinder
+ rec.SetRunPlaneEff(kFALSE); // to be implemented - CreateTrackleter
+
+ // rec.SetDefaultStorage("local://$ALICE_ROOT/OCDB");
rec.SetSpecificStorage("GRP/GRP/Data",
Form("local://%s",gSystem->pwd()));
- rec.SetRunPlaneEff(kFALSE);
+ rec.SetSpecificStorage("ITS/Align/Data",
+ Form("local://%s",gSystem->pwd()));
+
+
rec.SetRunQA(":");
rec.SetRunGlobalQA(0);
AliLog::Flush();
-void sim(Int_t nev=2) {
+void sim(Int_t nev=3) {
gSystem->Exec(" rm *.root ");
AliSimulation simulator;
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff