//#include "UPGRADE/AliITSUDigitPix.h"
#include <AliITSUGeomTGeo.h>
-#include <AliITSUSegmentationPix.h>
+#include <AliITSsegmentation.h>
#include <AliITSUDigitPix.h>
//______________________________________________________________________________
//
TEveRGBAPalette* AliEveITSUModule::fgITSUPalette = 0;
AliITSUGeomTGeo* fGM = 0;
-AliITSUSegmentationPix * fSegm = 0;
+const AliITSsegmentation* fSegm = 0;
/******************************************************************************/
//
// constructor
//
-
fGM = gm; // ITSU Geometry Manager
-
fgStaticInitDone = kFALSE;
-
- TObjArray segmArr;
- AliITSUSegmentationPix::LoadSegmentations(&segmArr, AliITSUGeomTGeo::GetITSsegmentationFileName());
-
- int detType = fGM->GetModuleDetTypeID(id);
- fSegm = (AliITSUSegmentationPix*)segmArr.At(detType);
-
- fDpx = fSegm->Dpx(); // pixel pitch in x
- fDpz = fSegm->Dpz(0); // pixel pitch in z
-
+ fSegm = fGM->GetSegmentation(layer);
+ fDpx = fSegm->Dpx(0); // pixel pitch in x
+ fDpz = fSegm->Dpz(0); // pixel pitch in z
SetID(id);
-
-
+ //
}
AliEveITSUModule::~AliEveITSUModule()
if (fgStaticInitDone) return;
fgStaticInitDone = kTRUE;
- Float_t dx = fSegm->Dpx() * fSegm->GetNRow(); // dimension in x in cm
- Float_t dz = fSegm->Dpz(0)* fSegm->GetNCol(); // dimension in y in cm
+ Float_t dx = fSegm->Dx(); // dimension in x in cm
+ Float_t dz = fSegm->Dz(); // dimension in y in cm
Float_t dy = 0;// ? eventuelly a few 100 micron, right?
{
rl->LoadRecPoints("ITS");
gGeoManager = gEve->GetGeometry("geometry.root");
- AliITSUGeomTGeo* gm = new AliITSUGeomTGeo(kTRUE);
- TObjArray segmArr;
- AliITSUSegmentationPix::LoadSegmentations(&segmArr, AliITSUGeomTGeo::GetITSsegmentationFileName());
+ AliITSUGeomTGeo* gm = new AliITSUGeomTGeo(kTRUE,kTRUE);
TTree *cTree = rl->GetTreeR("ITS", false);
if (cTree == 0)
for (int ilr=0;ilr<nlr;ilr++) {
TClonesArray* clr = (TClonesArray*)layerClus.At(ilr);
int ncl = clr->GetEntries();
-
+ // AliITSUSegmentationPix* segm = (AliITSUSegmentationPix*)fGM->GetSegmentation(ilr);
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);
#include <TGeoPhysicalNode.h>
#include <TDatime.h>
#include <TMath.h>
+#include <TSystem.h>
#include "AliITSUGeomTGeo.h"
#include "AliLog.h"
#include "AliAlignObj.h"
+#include "AliITSsegmentation.h"
+#include "AliITSUSegmentationPix.h"
using namespace TMath;
ClassImp(AliITSUGeomTGeo)
TString AliITSUGeomTGeo::fgITSsegmFileName = "itsSegmentations.root";
//______________________________________________________________________
-AliITSUGeomTGeo::AliITSUGeomTGeo(Bool_t build)
+AliITSUGeomTGeo::AliITSUGeomTGeo(Bool_t build, Bool_t loadSegm)
:fVersion(kITSVNA)
,fNLayers(0)
,fNModules(0)
,fLastModIndex(0)
,fMatSens(0)
,fMatT2L(0)
+ ,fSegm(0)
{
// default c-tor
- if (build) BuildITS();
+ if (build) BuildITS(loadSegm);
}
//______________________________________________________________________
,fLastModIndex(0)
,fMatSens(0)
,fMatT2L(0)
+ ,fSegm(0)
{
// copy c-tor
if (fNLayers) {
fMatT2L->SetOwner(kTRUE);
for (int i=0;i<fNModules;i++) {
const TGeoHMatrix* mat =(TGeoHMatrix*) src.fMatT2L->At(i);
- fMatSens->AddAt(new TGeoHMatrix(*mat),i);
+ fMatT2L->AddAt(new TGeoHMatrix(*mat),i);
+ }
+ }
+ if (src.fSegm) {
+ int sz = src.fSegm->GetEntriesFast();
+ fSegm = new TObjArray(sz);
+ fSegm->SetOwner(kTRUE);
+ for (int i=0;i<sz;i++) {
+ AliITSsegmentation* sg = (AliITSsegmentation*)src.fSegm->UncheckedAt(i);
+ if (!sg) continue;
+ fSegm->AddAt(sg->Clone(),i);
}
}
}
delete[] fLastModIndex;
delete fMatT2L;
delete fMatSens;
+ delete fSegm;
}
fMatT2L->AddAt(new TGeoHMatrix(*mat),i);
}
}
+ if (src.fSegm) {
+ int sz = src.fSegm->GetEntriesFast();
+ fSegm = new TObjArray(sz);
+ fSegm->SetOwner(kTRUE);
+ for (int i=0;i<sz;i++) {
+ AliITSsegmentation* sg = (AliITSsegmentation*)src.fSegm->UncheckedAt(i);
+ if (!sg) continue;
+ fSegm->AddAt(sg->Clone(),i);
+ }
+ }
//
if (fNLayers) {
fNLadders = new Int_t[fNLayers];
}
//______________________________________________________________________
-void AliITSUGeomTGeo::BuildITS()
+void AliITSUGeomTGeo::BuildITS(Bool_t loadSegm)
{
// exract upg ITS parameters from TGeo
if (fVersion!=kITSVNA) {AliWarning("Already built"); return; // already initialized}
FetchMatrices();
fVersion = kITSVUpg;
//
+ if (loadSegm) { // fetch segmentations
+ fSegm = new TObjArray();
+ AliITSUSegmentationPix::LoadSegmentations(fSegm,GetITSsegmentationFileName());
+ }
+ //
}
//______________________________________________________________________
class TGeoPNEntry;
class TDatime;
+class AliITSsegmentation;
class AliITSUGeomTGeo : public TObject {
enum {kITSVNA, kITSVUpg}; // ITS version
enum {kDetTypePix=0, kNDetTypes, kMaxSegmPerDetType=10}; // defined detector types (each one can have different segmentations)
//
- AliITSUGeomTGeo(Bool_t build = kFALSE);
+ AliITSUGeomTGeo(Bool_t build = kFALSE, Bool_t loadSegmentations = kTRUE);
virtual ~AliITSUGeomTGeo();
AliITSUGeomTGeo(const AliITSUGeomTGeo &src);
AliITSUGeomTGeo& operator=(const AliITSUGeomTGeo &geom);
Int_t GetLayerDetTypeID(Int_t lr) const;
Int_t GetModuleDetTypeID(Int_t id) const;
//
+ const AliITSsegmentation* GetSegmentationByID(Int_t id) const;
+ const AliITSsegmentation* GetSegmentation(Int_t lr) const;
+ TObjArray* GetSegmentations() const {return (TObjArray*)fSegm;}
virtual void Print(Option_t *opt="") const;
static const char* GetITSVolPattern() {return fgkITSVolName;}
Int_t ExtractNumberOfLadders(Int_t lay) const;
Int_t ExtractLayerDetType(Int_t lay) const;
Int_t ExtractNumberOfLayers() const;
- void BuildITS();
+ void BuildITS(Bool_t loadSegm);
//
- private:
+ protected:
//
//
Int_t fVersion; // ITS Version
//
TObjArray* fMatSens; // Sensor's matrices pointers in the geometry
TObjArray* fMatT2L; // Tracking to Local matrices pointers in the geometry
+ TObjArray* fSegm; // segmentations
//
static const char* fgkITSVolName; // ITS mother volume name
static const char* fgkITSLrName; // ITS Layer name
return fgkITSDetTypeName[i];
}
+//_____________________________________________________________________________________________
+inline const AliITSsegmentation* AliITSUGeomTGeo::GetSegmentationByID(Int_t id) const
+{
+ // get segmentation by ID
+ return fSegm ? (AliITSsegmentation*)fSegm->At(id) : 0;
+}
+
+//_____________________________________________________________________________________________
+inline const AliITSsegmentation* AliITSUGeomTGeo::GetSegmentation(Int_t lr) const
+{
+ // get segmentation of layer
+ return fSegm ? (AliITSsegmentation*)fSegm->At( GetLayerDetTypeID(lr) ) : 0;
+}
+
#endif
,fRMin(-1)
,fLayers(0)
,fLayersActive(0)
- ,fSegmentations(0)
,fITSGeom(0)
{
// def. c-tor
SetNameTitle(name,name);
fLayers.SetOwner(kTRUE); // layers belong to this array
fLayersActive.SetOwner(kFALSE); // this one just points on active layers in fLayers
- fSegmentations.SetOwner(kTRUE); // segmentations are owned by the detector
}
//______________________________________________________
// def. d-tor
fLayersActive.Clear();
fLayers.Clear(); // owned!
- fSegmentations.Clear(); // owned!
delete fITSGeom;
}
{
// build detector from TGeo
//
- fITSGeom = new AliITSUGeomTGeo(kTRUE);
+ fITSGeom = new AliITSUGeomTGeo(kTRUE,kTRUE);
int nlr = fITSGeom->GetNLayers();
if (!nlr) AliFatal("No geometry loaded");
- AliITSUSegmentationPix::LoadSegmentations(&fSegmentations, fITSGeom->GetITSsegmentationFileName());
- if (!fSegmentations.GetEntriesFast()) AliFatal(Form("Segmentations from %s are not loaded",fITSGeom->GetITSsegmentationFileName()));
//
// build active ITS layers
for (int ilr=0;ilr<nlr;ilr++) {
int nLad = fITSGeom->GetNLadders(ilr);
int nDet = fITSGeom->GetNDetectors(ilr);
// name layer according its active id, detector type and segmentation tyoe
- AliITSUSegmentationPix* segm = (AliITSUSegmentationPix*)fSegmentations.At(lrTyp);
- if (!segm) { AliFatal(Form("Did not find segmentation type %d",lrTyp)); continue; }
AliITSURecoLayer* lra = new AliITSURecoLayer( Form("Lr%d%s%d",ilr,fITSGeom->GetDetTypeName(lrTyp),
lrTyp%AliITSUGeomTGeo::kMaxSegmPerDetType),
- ilr,nLad*nDet,fITSGeom,segm);
+ ilr,nLad*nDet,fITSGeom);
lra->Build();
AddLayer(lra);
}
#include <TObjArray.h>
#include "AliITSURecoLayer.h"
class AliITSUGeomTGeo;
-class AliITSsegmentation;
///////////////////////////////////////////////////////////////////////
// //
AliITSURecoLayer* GetLayer(Int_t i) const;
AliITSURecoLayer* GetLayerActive(Int_t i) const;
AliITSUGeomTGeo* GetGeom() const {return fITSGeom;}
- TObjArray* GetSegmentations() const {return (TObjArray*)&fSegmentations;}
//
void SetRMin(Double_t r) {fRMin = r;}
void SetRMax(Double_t r) {fRMax = r;}
Double_t fRMin; // min R
TObjArray fLayers; // layers
TObjArray fLayersActive; // active layers
- //
- TObjArray fSegmentations;
AliITSUGeomTGeo* fITSGeom; // ITS geometry
//
private:
,fDPhiLadInv(0)
,fSensors(0)
,fITSGeom(0)
- ,fkSegm(0)
{
// def. c-tor
SetNameTitle(name,name);
}
//______________________________________________________
-AliITSURecoLayer::AliITSURecoLayer(const char* name,Int_t activeID,Int_t nsens, AliITSUGeomTGeo* gm,const AliITSsegmentation* segm)
+AliITSURecoLayer::AliITSURecoLayer(const char* name,Int_t activeID,Int_t nsens, AliITSUGeomTGeo* gm)
:fActiveID(activeID)
,fNSensors(0)
,fNSensInLadder(0)
,fDPhiLadInv(0)
,fSensors(nsens)
,fITSGeom(gm)
- ,fkSegm(segm)
{
// def. c-tor
SetNameTitle(name,name);
// build internal structures
fNLadders = fITSGeom->GetNLadders(fActiveID);
fNSensInLadder = fITSGeom->GetNDetectors(fActiveID);
+ const AliITSsegmentation* kSegm = fITSGeom->GetSegmentation(fActiveID);
//
// name layer according its active id, detector type and segmentation tyoe
TGeoHMatrix mmod;
double phiMin=1e9,phiMax=-1e9,zMin=1e9,zMax=-1e9;
mmod = *fITSGeom->GetMatrix(fActiveID,ild,idt);
for (int ix=0;ix<2;ix++) {
- loc[0] = (ix-0.5)*fkSegm->Dx(); // +-DX/2
+ loc[0] = (ix-0.5)*kSegm->Dx(); // +-DX/2
for (int iy=0;iy<2;iy++) {
- loc[1] = (iy-0.5)*fkSegm->Dy(); // +-DY/2
+ loc[1] = (iy-0.5)*kSegm->Dy(); // +-DY/2
for (int iz=0;iz<2;iz++) {
- loc[2] = (iz-0.5)*fkSegm->Dz(); // +-DZ/2
+ loc[2] = (iz-0.5)*kSegm->Dz(); // +-DZ/2
//
mmod.LocalToMaster(loc,glo);
double phi = ATan2(glo[1],glo[0]);
//
enum {kPassive=BIT(14)};
AliITSURecoLayer(const char* name);
- AliITSURecoLayer(const char* name, Int_t activeID,Int_t nsens,AliITSUGeomTGeo* gm,const AliITSsegmentation* segm);
+ AliITSURecoLayer(const char* name, Int_t activeID,Int_t nsens,AliITSUGeomTGeo* gm);
virtual ~AliITSURecoLayer();
//
Bool_t Build();
Double_t fDPhiLadInv;// inverse mean ladder dphi
TObjArray fSensors; // sensors
AliITSUGeomTGeo* fITSGeom; // geometry interface
- const AliITSsegmentation* fkSegm; // layer segmentation
//
private:
AliITSURecoLayer(const AliITSURecoLayer &source);
AliITSUReconstructor::AliITSUReconstructor()
: AliReconstructor()
,fGM(0)
- ,fSegmArr(0)
,fClusterFinders(0)
,fRecPoints(0)
{
}
//
delete fGM;
- fSegmArr.Delete();
}
//______________________________________________________________________
// Initalize this constructor
if (fGM) AliFatal("was already done, something is wrong...");
//
- fGM = new AliITSUGeomTGeo(kTRUE);
- AliITSUSegmentationPix::LoadSegmentations(&fSegmArr, AliITSUGeomTGeo::GetITSsegmentationFileName());
+ fGM = new AliITSUGeomTGeo(kTRUE,kTRUE);
//
AliITSUClusterizer* clusPIX = 0;
TClonesArray* rpArrayPix = 0;
//
for (int ilr=fGM->GetNLayers();ilr--;) {
- int tp = fGM->GetLayerDetTypeID(ilr);
- int tpDet = tp/AliITSUGeomTGeo::kMaxSegmPerDetType;
+ int tpDet = fGM->GetLayerDetTypeID(ilr)/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
+ // to expand the buffers to max.size
+ clusPIX->SetSegmentation((AliITSUSegmentationPix*)fGM->GetSegmentation(ilr));
continue;
}
else {
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->SetSegmentation((AliITSUSegmentationPix*)fGM->GetSegmentation(ilr));
clFinder->SetClusters(rpClones[ilr]);
//
int modF=fGM->GetFirstModIndex(ilr);
AliITSUReconstructor(const AliITSUReconstructor &); //Not implemented
AliITSUReconstructor& operator=(const AliITSUReconstructor &); //Not implemented
- AliITSUGeomTGeo* fGM; // geometry wrapper
- TObjArray fSegmArr; // Array of different pixel segmentations
+ AliITSUGeomTGeo* fGM; // geometry wrapper
TObjArray fClusterFinders; // array of clusterfinders per layer
TObjArray fRecPoints; // container for recpoints TClonesArrays
//
runLoader->LoadDigits();
AliGeomManager::LoadGeometry("geometry.root");
- AliITSUGeomTGeo* gm = new AliITSUGeomTGeo(kTRUE);
- TObjArray segmArr;
- AliITSUSegmentationPix::LoadSegmentations(&segmArr, AliITSUGeomTGeo::GetITSsegmentationFileName());
+ AliITSUGeomTGeo* gm = new AliITSUGeomTGeo(kTRUE,kTRUE);
//
Int_t nLayers = gm->GetNLayers();
Int_t nModules = gm->GetNModules();
sDigTree->GetEntry(imod);
digTree->GetEntry(imod);
int detType = gm->GetModuleDetTypeID(imod);
- AliITSUSegmentationPix* segm = (AliITSUSegmentationPix*)segmArr.At(detType);
+ AliITSUSegmentationPix* segm = (AliITSUSegmentationPix*)gm->GetSegmentationByID(detType);
int lay,lad,det;
int nsdig = sDigArr->GetEntries();
int ndig = digArr->GetEntries();
AliGeomManager::ApplyAlignObjsToGeom(*array);
gGeoManager->LockGeometry();
- AliITSUGeomTGeo* gm = new AliITSUGeomTGeo(kTRUE);
- TObjArray segmArr;
- AliITSUSegmentationPix::LoadSegmentations(&segmArr, AliITSUGeomTGeo::GetITSsegmentationFileName());
-
+ AliITSUGeomTGeo* gm = new AliITSUGeomTGeo(kTRUE,kTRUE);
+ TObjArray* segmArr = gm->GetSegmentations();
//
int nlr = gm->GetNLayers();
if (layMin<0) layMin = 0;
for (Int_t lay=layMin;lay<=layMax;lay++) {
//
- AliITSUSegmentationPix* segm = (AliITSUSegmentationPix*)segmArr.At(gm->GetLayerDetTypeID(lay));
+ AliITSUSegmentationPix* segm = (AliITSUSegmentationPix*)segmArr->At(gm->GetLayerDetTypeID(lay));
for (int ild=0;ild<gm->GetNLadders(lay);ild++) {
// Sensor Matrices