Adding the AliAlienBrowser class: it deals with the browser of the file catalog in...

[u/mrichter/AliRoot.git] / STEER / AliAlignmentTracks.cxx

diff --git a/STEER/AliAlignmentTracks.cxx b/STEER/AliAlignmentTracks.cxx
index 45ffc99d6dd4318466373ce036a50ec1c0dc8c21..17ec9ece104cb0a8080efea3229175aaec636a71 100644 (file)
--- a/STEER/AliAlignmentTracks.cxx
+++ b/STEER/AliAlignmentTracks.cxx
@@ -44,9 +44,11 @@ AliAlignmentTracks::AliAlignmentTracks():
   fLastIndex(0),
   fArrayIndex(0),
   fIsIndexBuilt(kFALSE),
+  fAlignObjs(0),
   fMisalignObjs(0),
   fTrackFitter(0),
-  fMinimizer(0)
+  fMinimizer(0),
+  fDoUpdate(kTRUE)
 {
   // Default constructor
   InitIndex();
@@ -62,9 +64,11 @@ AliAlignmentTracks::AliAlignmentTracks(TChain *esdchain):
   fLastIndex(0),
   fArrayIndex(0),
   fIsIndexBuilt(kFALSE),
+  fAlignObjs(0),
   fMisalignObjs(0),
   fTrackFitter(0),
-  fMinimizer(0)
+  fMinimizer(0),
+  fDoUpdate(kTRUE)
 {
   // Constructor in the case
   // the user provides an already
@@ -76,48 +80,28 @@ AliAlignmentTracks::AliAlignmentTracks(TChain *esdchain):
 
 //______________________________________________________________________________
 AliAlignmentTracks::AliAlignmentTracks(const char *esdfilename, const char *esdtreename):
+  fESDChain(new TChain(esdtreename)),
   fPointsFilename("AliTrackPoints.root"),
   fPointsFile(0),
   fPointsTree(0),
   fLastIndex(0),
   fArrayIndex(0),
   fIsIndexBuilt(kFALSE),
+  fAlignObjs(0),
   fMisalignObjs(0),
   fTrackFitter(0),
-  fMinimizer(0)
+  fMinimizer(0),
+  fDoUpdate(kTRUE)
 {
   // Constructor in the case
   // the user provides a single ESD file
   // or a directory containing ESD files
-  fESDChain = new TChain(esdtreename);
   fESDChain->Add(esdfilename);
 
   InitIndex();
   InitAlignObjs();
 }
 
-//______________________________________________________________________________
-AliAlignmentTracks::AliAlignmentTracks(const AliAlignmentTracks &alignment):
-  TObject(alignment)
-{
-  // Copy constructor
-  // not implemented
-  AliWarning("Copy constructor not implemented!");
-}
-
-//______________________________________________________________________________
-AliAlignmentTracks& AliAlignmentTracks::operator= (const AliAlignmentTracks& alignment)
-{
-  // Asignment operator
-  // not implemented
-  if(this==&alignment) return *this;
-
-  AliWarning("Asignment operator not implemented!");
-
-  ((TObject *)this)->operator=(alignment);
-
-  return *this;
-}
 
 //______________________________________________________________________________
 AliAlignmentTracks::~AliAlignmentTracks()
@@ -169,6 +153,9 @@ void AliAlignmentTracks::ProcessESD()
 
   AliESD *esd = 0;
   fESDChain->SetBranchAddress("ESD",&esd);
+  AliESDfriend *esdf = 0; 
+  fESDChain->SetBranchStatus("ESDfriend*",1);
+  fESDChain->SetBranchAddress("ESDfriend.",&esdf);
 
   // Open the output file
   if (fPointsFilename.Data() == "") {
@@ -183,12 +170,14 @@ void AliAlignmentTracks::ProcessESD()
   }
 
   TTree *pointsTree = new TTree("spTree", "Tree with track space point arrays");
-  AliTrackPointArray *array = 0;
+  const AliTrackPointArray *array = 0;
   pointsTree->Branch("SP","AliTrackPointArray", &array);
-
   Int_t ievent = 0;
   while (fESDChain->GetEntry(ievent++)) {
     if (!esd) break;
+
+    esd->SetESDfriend(esdf); //Attach the friend to the ESD
+
     Int_t ntracks = esd->GetNumberOfTracks();
     for (Int_t itrack=0; itrack < ntracks; itrack++) {
       AliESDtrack * track = esd->GetTrack(itrack);
@@ -229,6 +218,10 @@ void AliAlignmentTracks::BuildIndex()
 
   fIsIndexBuilt = kTRUE;
 
+  // Dummy object is created in order
+  // to initialize the volume paths
+  AliAlignObjAngles alobj;
+
   TFile *fPointsFile = TFile::Open(fPointsFilename);
   if (!fPointsFile || !fPointsFile->IsOpen()) {
     AliWarning(Form("Can't open %s !",fPointsFilename.Data()));
@@ -251,6 +244,12 @@ void AliAlignmentTracks::BuildIndex()
       if (!array) continue;
       for (Int_t ipoint = 0; ipoint < array->GetNPoints(); ipoint++) {
        UShort_t volId = array->GetVolumeID()[ipoint];
+       // check if the volId is valid
+       if (!AliAlignObj::SymName(volId)) {
+         AliError(Form("The volume id %d has no default volume name !",
+                       volId));
+         continue;
+       }
        Int_t modId;
        Int_t layerId = AliAlignObj::VolUIDToLayer(volId,modId)
                      - AliAlignObj::kFirstLayer;
@@ -289,9 +288,9 @@ void AliAlignmentTracks::InitIndex()
   fLastIndex = new Int_t*[nLayers];
   fArrayIndex = new TArrayI**[nLayers];
   for (Int_t iLayer = 0; iLayer < (AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer); iLayer++) {
-    fLastIndex[iLayer] = new Int_t[AliAlignObj::LayerSize(iLayer)];
-    fArrayIndex[iLayer] = new TArrayI*[AliAlignObj::LayerSize(iLayer)];
-    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++) {
+    fLastIndex[iLayer] = new Int_t[AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer)];
+    fArrayIndex[iLayer] = new TArrayI*[AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer)];
+    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer); iModule++) {
       fLastIndex[iLayer][iModule] = 0;
       fArrayIndex[iLayer][iModule] = 0;
     }
@@ -307,7 +306,7 @@ void AliAlignmentTracks::ResetIndex()
   fIsIndexBuilt = kFALSE;
   
   for (Int_t iLayer = 0; iLayer < AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer; iLayer++) {
-    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++) {
+    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer); iModule++) {
       fLastIndex[iLayer][iModule] = 0;
     }
   }
@@ -319,7 +318,7 @@ void AliAlignmentTracks::DeleteIndex()
   // Delete the index arrays
   // Called by the destructor
   for (Int_t iLayer = 0; iLayer < (AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer); iLayer++) {
-    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++) {
+    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer); iModule++) {
       if (fArrayIndex[iLayer][iModule]) {
        delete fArrayIndex[iLayer][iModule];
        fArrayIndex[iLayer][iModule] = 0;
@@ -349,10 +348,10 @@ void AliAlignmentTracks::InitAlignObjs()
   Int_t nLayers = AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer;
   fAlignObjs = new AliAlignObj**[nLayers];
   for (Int_t iLayer = 0; iLayer < (AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer); iLayer++) {
-    fAlignObjs[iLayer] = new AliAlignObj*[AliAlignObj::LayerSize(iLayer)];
-    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++) {
+    fAlignObjs[iLayer] = new AliAlignObj*[AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer)];
+    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer); iModule++) {
       UShort_t volid = AliAlignObj::LayerToVolUID(iLayer+ AliAlignObj::kFirstLayer,iModule);
-      fAlignObjs[iLayer][iModule] = new AliAlignObjAngles("",volid,0,0,0,0,0,0);
+      fAlignObjs[iLayer][iModule] = new AliAlignObjAngles("",volid,0,0,0,0,0,0,kTRUE);
     }
   }
 }
@@ -362,7 +361,7 @@ void AliAlignmentTracks::ResetAlignObjs()
 {
   // Reset the alignment objects array
   for (Int_t iLayer = 0; iLayer < (AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer); iLayer++) {
-    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++)
+    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer); iModule++)
       fAlignObjs[iLayer][iModule]->SetPars(0,0,0,0,0,0);
   }
 }
@@ -372,7 +371,7 @@ void AliAlignmentTracks::DeleteAlignObjs()
 {
   // Delete the alignment objects array
   for (Int_t iLayer = 0; iLayer < (AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer); iLayer++) {
-    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++)
+    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer); iModule++)
       if (fAlignObjs[iLayer][iModule])
        delete fAlignObjs[iLayer][iModule];
     delete [] fAlignObjs[iLayer];
@@ -394,12 +393,12 @@ void AliAlignmentTracks::AlignDetector(AliAlignObj::ELayerID firstLayer,
   // the range defined by the user.
   Int_t nModules = 0;
   for (Int_t iLayer = firstLayer; iLayer < lastLayer; iLayer++)
-    nModules += AliAlignObj::LayerSize(iLayer - AliAlignObj::kFirstLayer);
+    nModules += AliAlignObj::LayerSize(iLayer);
   TArrayI volIds(nModules);
 
   Int_t modnum = 0;
   for (Int_t iLayer = firstLayer; iLayer < lastLayer; iLayer++) {
-    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer - AliAlignObj::kFirstLayer); iModule++) {
+    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++) {
       UShort_t volId = AliAlignObj::LayerToVolUID(iLayer,iModule);
       volIds.AddAt(volId,modnum);
       modnum++;
@@ -422,7 +421,7 @@ void AliAlignmentTracks::AlignLayer(AliAlignObj::ELayerID layer,
   // a given layer.
   // Tracks are fitted only within
   // the range defined by the user.
-  Int_t nModules = AliAlignObj::LayerSize(layer - AliAlignObj::kFirstLayer);
+  Int_t nModules = AliAlignObj::LayerSize(layer);
   TArrayI volIds(nModules);
   for (Int_t iModule = 0; iModule < nModules; iModule++) {
     UShort_t volId = AliAlignObj::LayerToVolUID(layer,iModule);
@@ -487,8 +486,9 @@ void AliAlignmentTracks::AlignVolumes(const TArrayI *volids, const TArrayI *voli
     minimizer->InitAlignObj();
     AliTrackFitter *fitter = CreateFitter();
     for (Int_t iArray = 0; iArray < nArrays; iArray++) {
+      if (!points[iArray]) continue;
       fitter->SetTrackPointArray(points[iArray], kFALSE);
-      fitter->Fit(volids,volidsfit,layerRangeMin,layerRangeMax);
+      if (fitter->Fit(volids,volidsfit,layerRangeMin,layerRangeMax) == kFALSE) continue;
       AliTrackPointArray *pVolId,*pTrack;
       fitter->GetTrackResiduals(pVolId,pTrack);
       minimizer->AddTrackPointArrays(pVolId,pTrack);
@@ -496,11 +496,11 @@ void AliAlignmentTracks::AlignVolumes(const TArrayI *volids, const TArrayI *voli
     minimizer->Minimize();
 
     // Update the alignment object(s)
-    for (Int_t iVolId = 0; iVolId < nVolIds; iVolId++) {
+    if (fDoUpdate) for (Int_t iVolId = 0; iVolId < nVolIds; iVolId++) {
       UShort_t volid = (*volids)[iVolId];
       Int_t iModule;
       AliAlignObj::ELayerID iLayer = AliAlignObj::VolUIDToLayer(volid,iModule);
-      AliAlignObj *alignObj = fAlignObjs[iLayer-AliAlignObj::kFirstLayer][iModule];
+      AliAlignObj *alignObj = fAlignObjs[iLayer-AliAlignObj::kFirstLayer][iModule];      
       *alignObj *= *minimizer->GetAlignObj();
       alignObj->Print("");
     }
@@ -558,6 +558,7 @@ Int_t AliAlignmentTracks::LoadPoints(const TArrayI *volids, AliTrackPointArray**
 
   // Allocate the pointer to the space-point arrays
   points = new AliTrackPointArray*[nArrays];
+  for (Int_t i = 0; i < nArrays; i++) points[i] = 0x0;
 
   // Init the array used to flag already loaded tree entries
   Bool_t *indexUsed = new Bool_t[fPointsTree->GetEntries()];
@@ -594,6 +595,19 @@ Int_t AliAlignmentTracks::LoadPoints(const TArrayI *volids, AliTrackPointArray**
        array->GetPoint(p,iPoint);
        Int_t modnum;
        AliAlignObj::ELayerID layer = AliAlignObj::VolUIDToLayer(p.GetVolumeID(),modnum);
+       // check if the layer id is valid
+       if ((layer < AliAlignObj::kFirstLayer) ||
+           (layer >= AliAlignObj::kLastLayer)) {
+         AliError(Form("Layer index is invalid: %d (%d -> %d) !",
+                       layer,AliAlignObj::kFirstLayer,AliAlignObj::kLastLayer-1));
+         continue;
+       }
+       if ((modnum >= AliAlignObj::LayerSize(layer)) ||
+           (modnum < 0)) {
+         AliError(Form("Module number inside layer %d is invalid: %d (0 -> %d)",
+                       layer,modnum,AliAlignObj::LayerSize(layer)));
+         continue;
+       }
 
        // Misalignment is introduced here
        // Switch it off in case of real
@@ -667,8 +681,8 @@ Bool_t AliAlignmentTracks::Misalign(const char *misalignObjFileName, const char*
   Int_t nLayers = AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer;
   fMisalignObjs = new AliAlignObj**[nLayers];
   for (Int_t iLayer = 0; iLayer < (AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer); iLayer++) {
-    fMisalignObjs[iLayer] = new AliAlignObj*[AliAlignObj::LayerSize(iLayer)];
-    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++)
+    fMisalignObjs[iLayer] = new AliAlignObj*[AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer)];
+    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer); iModule++)
       fMisalignObjs[iLayer][iModule] = 0x0;
   }