clusterizer,reconstructor + many fixes (Magnus,Stefan)
authorshahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 25 Oct 2012 21:28:17 +0000 (21:28 +0000)
committershahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 25 Oct 2012 21:28:17 +0000 (21:28 +0000)
18 files changed:
EVE/CMakebinalieve.pkg
EVE/CMakebinalihlteve.pkg
EVE/CMakelibEveDet.pkg
EVE/EveDet/EveDetLinkDef.h
EVE/alice-macros/itsU_clusters.C [new file with mode: 0644]
ITS/UPGRADE/AliITSUClusterizer.cxx [new file with mode: 0644]
ITS/UPGRADE/AliITSUClusterizer.h [new file with mode: 0644]
ITS/UPGRADE/AliITSUReconstructor.cxx [new file with mode: 0644]
ITS/UPGRADE/AliITSUReconstructor.h [new file with mode: 0644]
ITS/UPGRADE/AliITSUv11Layer.cxx
ITS/UPGRADE/CMakelibITSUpgradeRec.pkg
ITS/UPGRADE/CMakelibITSUpgradeSim.pkg
ITS/UPGRADE/ITSUpgradeRecLinkDef.h
ITS/UPGRADE/ITSUpgradeSimLinkDef.h
ITS/UPGRADE/readClusters.C [new file with mode: 0644]
ITS/UPGRADE/readHit.C
ITS/UPGRADE/rec.C
ITS/UPGRADE/testITSU/sim.C

index c49083d..a01b1ca 100644 (file)
@@ -32,7 +32,7 @@ set ( CSRCS )
 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)
index 17e175f..adc8599 100644 (file)
@@ -31,7 +31,7 @@ set ( CSRCS )
 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})
 
index 73ae6ad..7c5c309 100644 (file)
@@ -32,7 +32,7 @@ string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
 
 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 )
 
@@ -44,6 +44,7 @@ set ( EXPORT
   EveDet/AliEveFMDLoader.h
   EveDet/AliEveITSDigitsInfo.h
   EveDet/AliEveITSModule.h
+  EveDet/AliEveITSUModule.h
   EveDet/AliEveITSModuleStepper.h
   EveDet/AliEveITSScaledModule.h
   EveDet/AliEveListAnalyser.h
index 97b0ac1..7188b8c 100644 (file)
@@ -28,6 +28,7 @@
 #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+;
diff --git a/EVE/alice-macros/itsU_clusters.C b/EVE/alice-macros/itsU_clusters.C
new file mode 100644 (file)
index 0000000..d2503a0
--- /dev/null
@@ -0,0 +1,117 @@
+// $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();
+
+}
diff --git a/ITS/UPGRADE/AliITSUClusterizer.cxx b/ITS/UPGRADE/AliITSUClusterizer.cxx
new file mode 100644 (file)
index 0000000..0ac1ea3
--- /dev/null
@@ -0,0 +1,268 @@
+#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;
+}
diff --git a/ITS/UPGRADE/AliITSUClusterizer.h b/ITS/UPGRADE/AliITSUClusterizer.h
new file mode 100644 (file)
index 0000000..ce4e7e3
--- /dev/null
@@ -0,0 +1,185 @@
+#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
diff --git a/ITS/UPGRADE/AliITSUReconstructor.cxx b/ITS/UPGRADE/AliITSUReconstructor.cxx
new file mode 100644 (file)
index 0000000..e8b1be1
--- /dev/null
@@ -0,0 +1,243 @@
+/**************************************************************************
+ * 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;
+
+}
+
diff --git a/ITS/UPGRADE/AliITSUReconstructor.h b/ITS/UPGRADE/AliITSUReconstructor.h
new file mode 100644 (file)
index 0000000..cc57f79
--- /dev/null
@@ -0,0 +1,48 @@
+#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
index 5ac76fd..cc2753c 100644 (file)
@@ -469,11 +469,12 @@ TGeoVolume* AliITSUv11Layer::CreateModule(const Double_t xlad,
 
 
   // 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);
 
index f3a5bb9..93b4e6d 100644 (file)
 # 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}" )
index a7390ed..7e6d18c 100644 (file)
@@ -26,8 +26,8 @@
 #--------------------------------------------------------------------------------#
 
 set ( SRCS     
-v0/AliITSupgrade.cxx 
-v0/AliITSupgradeDigitizer.cxx 
+#v0/AliITSupgrade.cxx 
+#v0/AliITSupgradeDigitizer.cxx 
 #
 AliITSU.cxx 
 AliITSUv11.cxx 
@@ -45,4 +45,5 @@ string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
 
 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 )
index 1b8b1ea..048ebf2 100644 (file)
 // 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+;
@@ -25,5 +29,6 @@
 #pragma link C++ class AliITSUpgradeClusterListNode+;
 #pragma link C++ class AliITSUPixelModule+;
 #pragma link C++ class AliITSUpgradeClusterFinder+;
+*/
 
 #endif
index b1aecdd..3a890c7 100644 (file)
@@ -13,8 +13,8 @@
 
 // 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+;
diff --git a/ITS/UPGRADE/readClusters.C b/ITS/UPGRADE/readClusters.C
new file mode 100644 (file)
index 0000000..e26e656
--- /dev/null
@@ -0,0 +1,84 @@
+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();
+
+}
index 68b239d..7b43122 100644 (file)
@@ -62,14 +62,14 @@ void readHit(){
        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
        
index 3ee5679..c75db19 100644 (file)
@@ -1,5 +1,7 @@
 void rec() {
-  //AliLog::SetClassDebugLevel("AliITStrackerUpgrade",5);
+  
+  //  AliLog::SetClassDebugLevel("AliReconstruction",1);
+  AliLog::SetClassDebugLevel("AliITSUReconstructor",1);
 
   TDatime t;
 
@@ -7,22 +9,27 @@ void rec() {
   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();
index daa387d..63f94c4 100644 (file)
@@ -1,4 +1,4 @@
-void sim(Int_t nev=2) {
+void sim(Int_t nev=3) {
 
   gSystem->Exec(" rm *.root ");
   AliSimulation simulator;