Minor updates
authorauras <auras@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 16 May 2012 08:42:09 +0000 (08:42 +0000)
committerauras <auras@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 16 May 2012 08:42:09 +0000 (08:42 +0000)
MFT/AliMFT.cxx
MFT/AliMFTConstants.cxx
MFT/AliMFTGeometry.root
MFT/AliMFTPlane.cxx
MFT/AliMuonForwardTrackFinder.cxx
MFT/SetMFTGeometry.C

index 1a6ae165f24045e2a9a25812098aac14598d8077..691b7d8ed3b40feb12a7db8fcc64b0efe70ee581 100644 (file)
@@ -53,17 +53,17 @@ AliMFT::AliMFT():
   AliDetector(),
   fVersion(1),
   fNPlanes(0),
-  fNSlices(0),
+  fNSlices(1),
   fSDigitsPerPlane(0),
   fDigitsPerPlane(0),
   fRecPointsPerPlane(0),
   fSideDigits(0),
   fSegmentation(0),
   fNameGeomFile(0),
-  fChargeDispersion(0),
+  fChargeDispersion(25.e-4),
   fSingleStepForChargeDispersion(0),
-  fNStepForChargeDispersion(0),
-  fDensitySupportOverSi(0.1)
+  fNStepForChargeDispersion(4),
+  fDensitySupportOverSi(0.15)
 {
 
   // default constructor
@@ -76,17 +76,17 @@ AliMFT::AliMFT(const Char_t *name, const Char_t *title):
   AliDetector(name, title),
   fVersion(1),
   fNPlanes(0),
-  fNSlices(0),
+  fNSlices(1),
   fSDigitsPerPlane(0),
   fDigitsPerPlane(0),
   fRecPointsPerPlane(0),
   fSideDigits(0),
   fSegmentation(0),
   fNameGeomFile(0),
-  fChargeDispersion(0),
+  fChargeDispersion(25.e-4),
   fSingleStepForChargeDispersion(0),
-  fNStepForChargeDispersion(0),
-  fDensitySupportOverSi(0.1)
+  fNStepForChargeDispersion(4),
+  fDensitySupportOverSi(0.15)
 {
 
   fNameGeomFile = "AliMFTGeometry.root";
@@ -103,17 +103,17 @@ AliMFT::AliMFT(const Char_t *name, const Char_t *title, Char_t *nameGeomFile):
   AliDetector(name, title),
   fVersion(1),
   fNPlanes(0),
-  fNSlices(0),
+  fNSlices(1),
   fSDigitsPerPlane(0),
   fDigitsPerPlane(0),
   fRecPointsPerPlane(0),
   fSideDigits(0),
   fSegmentation(0),
   fNameGeomFile(0),
-  fChargeDispersion(0),
+  fChargeDispersion(25.e-4),
   fSingleStepForChargeDispersion(0),
-  fNStepForChargeDispersion(0),
-  fDensitySupportOverSi(0.1)
+  fNStepForChargeDispersion(4),
+  fDensitySupportOverSi(0.15)
 {
 
   fNameGeomFile = nameGeomFile;
@@ -416,7 +416,7 @@ void AliMFT::Hits2SDigitsLocal(TClonesArray *hits, const TObjArray *pSDig, Int_t
 
   //  Add sdigits of these hits to the list
   
-  AliDebug(1, "Start Hits2SDigitsLocal");
+  AliDebug(1, "Entering Hits2SDigitsLocal");
   
   if (!fSegmentation) CreateGeometry();
   
@@ -432,131 +432,155 @@ void AliMFT::Hits2SDigitsLocal(TClonesArray *hits, const TObjArray *pSDig, Int_t
 
     AliMFTHit *hit = (AliMFTHit*) hits->At(iHit);
 
-    AliMFTDigit sDigit;
-    sDigit.SetEloss(hit->GetEloss());
-    sDigit.SetDetElemID(hit->GetDetElemID());
-    sDigit.SetPlane(hit->GetPlane());
-    sDigit.AddMCLabel(hit->GetTrack()); 
+    // Creating "main digit"
+
+    AliMFTDigit *mainSDigit = new AliMFTDigit();
+    mainSDigit->SetEloss(hit->GetEloss());
+    mainSDigit->SetDetElemID(hit->GetDetElemID());
+    mainSDigit->SetPlane(hit->GetPlane());
+    mainSDigit->AddMCLabel(hit->GetTrack()); 
 
     Int_t xPixel = -1;
     Int_t yPixel = -1;
-    if (fSegmentation->Hit2PixelID(hit->X(), hit->Y(), sDigit.GetDetElemID(), xPixel, yPixel)) {
-      sDigit.SetPixID(xPixel, yPixel, 0);
-      sDigit.SetPixWidth(fSegmentation->GetPixelSizeX(sDigit.GetDetElemID()), 
-                        fSegmentation->GetPixelSizeY(sDigit.GetDetElemID()),
-                        fSegmentation->GetPixelSizeZ(sDigit.GetDetElemID()));  
-      sDigit.SetPixCenter(fSegmentation->GetPixelCenterX(sDigit.GetDetElemID(), xPixel), 
-                         fSegmentation->GetPixelCenterY(sDigit.GetDetElemID(), yPixel),
-                         fSegmentation->GetPixelCenterZ(sDigit.GetDetElemID(), 0));  
-      new ((*pSDigList[sDigit.GetPlane()])[pSDigList[sDigit.GetPlane()]->GetEntries()]) AliMFTDigit(sDigit);
+    if (fSegmentation->Hit2PixelID(hit->X(), hit->Y(), mainSDigit->GetDetElemID(), xPixel, yPixel)) {
+      mainSDigit->SetPixID(xPixel, yPixel, 0);
+      mainSDigit->SetPixWidth(fSegmentation->GetPixelSizeX(mainSDigit->GetDetElemID()), 
+                         fSegmentation->GetPixelSizeY(mainSDigit->GetDetElemID()),
+                         fSegmentation->GetPixelSizeZ(mainSDigit->GetDetElemID()));  
+      mainSDigit->SetPixCenter(fSegmentation->GetPixelCenterX(mainSDigit->GetDetElemID(), xPixel), 
+                          fSegmentation->GetPixelCenterY(mainSDigit->GetDetElemID(), yPixel),
+                          fSegmentation->GetPixelCenterZ(mainSDigit->GetDetElemID(), 0));
+      new ((*fSideDigits)[fSideDigits->GetEntries()]) AliMFTDigit(*mainSDigit);
       AliDebug(1, Form("Created new sdigit (%f, %f, %f) from hit (%f, %f, %f)",
-                      sDigit.GetPixelCenterX(), sDigit.GetPixelCenterY(), sDigit.GetPixelCenterZ(), hit->X(), hit->Y(), hit->Z()));
-//       AliDebug(1, Form("Created new sdigit from hit: residual is (%f, %f, %f)",
-//                    sDigit.GetPixelCenterX()-hit->X(), sDigit.GetPixelCenterY()-hit->Y(), sDigit.GetPixelCenterZ()-hit->Z()));
+                              mainSDigit->GetPixelCenterX(), mainSDigit->GetPixelCenterY(), mainSDigit->GetPixelCenterZ(), hit->X(), hit->Y(), hit->Z()));
     }
 
-    // creating "side hits" to simulate the effect of charge dispersion
+    // creating "side digits" to simulate the effect of charge dispersion
 
-    Int_t xPixelNew = -1;
-    Int_t yPixelNew = -1;
-    Double_t x0 = hit->X();
-    Double_t y0 = hit->Y();
     Double_t pi4 = TMath::Pi()/4.;
     for (Int_t iStep=0; iStep<fNStepForChargeDispersion; iStep++) {
       Double_t shift = (iStep+1) * fSingleStepForChargeDispersion;
       for (Int_t iAngle=0; iAngle<8; iAngle++) {
        Double_t shiftX = shift*TMath::Cos(iAngle*pi4);
        Double_t shiftY = shift*TMath::Sin(iAngle*pi4);
-       if (fSegmentation->Hit2PixelID(x0+shiftX, y0+shiftY, hit->GetDetElemID(), xPixelNew, yPixelNew)) {
+       if (fSegmentation->Hit2PixelID(hit->X()+shiftX, hit->Y()+shiftY, hit->GetDetElemID(), xPixel, yPixel)) {
          Bool_t digitExists = kFALSE;
-         if (xPixelNew==xPixel && yPixelNew==yPixel) digitExists = kTRUE;
-         if (!digitExists) {
-           for (Int_t iSideDigit=0; iSideDigit<fSideDigits->GetEntries(); iSideDigit++) {
-             if (xPixelNew==((AliMFTDigit*) fSideDigits->At(iSideDigit))->GetPixelX() && 
-                 yPixelNew==((AliMFTDigit*) fSideDigits->At(iSideDigit))->GetPixelY()) {
-               digitExists = kTRUE;
-               break;
-             }
+         for (Int_t iSideDigit=0; iSideDigit<fSideDigits->GetEntries(); iSideDigit++) {
+           if (xPixel==((AliMFTDigit*) fSideDigits->At(iSideDigit))->GetPixelX() && 
+               yPixel==((AliMFTDigit*) fSideDigits->At(iSideDigit))->GetPixelY()) {
+             digitExists = kTRUE;
+             break;
            }
          }
          if (!digitExists) {
-           AliMFTDigit newSDigit;
-           newSDigit.SetEloss(0.);
-           newSDigit.SetDetElemID(hit->GetDetElemID());
-           newSDigit.SetPlane(hit->GetPlane());
-           newSDigit.AddMCLabel(hit->GetTrack());
-           newSDigit.SetPixID(xPixelNew, yPixelNew, 0);
-           newSDigit.SetPixWidth(fSegmentation->GetPixelSizeX(sDigit.GetDetElemID()), 
-                                 fSegmentation->GetPixelSizeY(sDigit.GetDetElemID()),
-                                 fSegmentation->GetPixelSizeZ(sDigit.GetDetElemID()));  
-           newSDigit.SetPixCenter(fSegmentation->GetPixelCenterX(sDigit.GetDetElemID(), xPixelNew), 
-                                  fSegmentation->GetPixelCenterY(sDigit.GetDetElemID(), yPixelNew),
-                                  fSegmentation->GetPixelCenterZ(sDigit.GetDetElemID(), 0)); 
-           new ((*fSideDigits)[fSideDigits->GetEntries()]) AliMFTDigit(newSDigit);
+           AliMFTDigit *sideSDigit = new AliMFTDigit();
+           sideSDigit->SetEloss(0.);
+           sideSDigit->SetDetElemID(hit->GetDetElemID());
+           sideSDigit->SetPlane(hit->GetPlane());
+           sideSDigit->AddMCLabel(hit->GetTrack());
+           sideSDigit->SetPixID(xPixel, yPixel, 0);
+           sideSDigit->SetPixWidth(fSegmentation->GetPixelSizeX(sideSDigit->GetDetElemID()), 
+                                   fSegmentation->GetPixelSizeY(sideSDigit->GetDetElemID()),
+                                   fSegmentation->GetPixelSizeZ(sideSDigit->GetDetElemID()));  
+           sideSDigit->SetPixCenter(fSegmentation->GetPixelCenterX(sideSDigit->GetDetElemID(), xPixel), 
+                                    fSegmentation->GetPixelCenterY(sideSDigit->GetDetElemID(), yPixel),
+                                    fSegmentation->GetPixelCenterZ(sideSDigit->GetDetElemID(), 0)); 
+           new ((*fSideDigits)[fSideDigits->GetEntries()]) AliMFTDigit(*sideSDigit);
          }
        }
       }
     }
-
-    for (Int_t iSideDigit=0; iSideDigit<fSideDigits->GetEntries(); iSideDigit++) {
-      AliMFTDigit *newSDigit = (AliMFTDigit*) fSideDigits->At(iSideDigit);
-      new ((*pSDigList[sDigit.GetPlane()])[pSDigList[sDigit.GetPlane()]->GetEntries()]) AliMFTDigit(*newSDigit);
-    }
-
-    fSideDigits->Delete();  
-
-  }
-
-  // ------------ In case we should simulate a rectangular pattern of pixel...
-  
-  for (Int_t iPlane=0; iPlane<fNPlanes; iPlane++) { 
-    if (fSegmentation->GetPlane(iPlane)->HasPixelRectangularPatternAlongY()) {
-      Int_t nSDigits = pSDigList[iPlane]->GetEntries();
-      for (Int_t iSDigit=0; iSDigit<nSDigits; iSDigit++) {
-       AliMFTDigit *mySDig = (AliMFTDigit*) (pSDigList[iPlane]->At(iSDigit));
+    
+    // ------------ In case we should simulate a rectangular pattern of pixel...
+    
+    if (fSegmentation->GetPlane(mainSDigit->GetPlane())->HasPixelRectangularPatternAlongY()) {
+      for (Int_t iSDigit=0; iSDigit<fSideDigits->GetEntries(); iSDigit++) {
+       AliMFTDigit *mySDig = (AliMFTDigit*) (fSideDigits->At(iSDigit));
        if (mySDig->GetPixelX()%2 == mySDig->GetPixelY()%2) {   // both pair or both odd
-         Int_t xPixelNew = mySDig->GetPixelX();
-         Int_t yPixelNew = mySDig->GetPixelY()+1;
-         if (fSegmentation->DoesPixelExist(mySDig->GetDetElemID(), xPixelNew, yPixelNew)) {
-           AliMFTDigit newSDigit;
-           newSDigit.SetEloss(0.);
-           newSDigit.SetDetElemID(mySDig->GetDetElemID());
-           newSDigit.SetPlane(iPlane);
-           newSDigit.SetPixID(xPixelNew, yPixelNew, 0);
-           newSDigit.SetPixWidth(fSegmentation->GetPixelSizeX(newSDigit.GetDetElemID()), 
-                                 fSegmentation->GetPixelSizeY(newSDigit.GetDetElemID()),
-                                 fSegmentation->GetPixelSizeZ(newSDigit.GetDetElemID()));  
-           newSDigit.SetPixCenter(fSegmentation->GetPixelCenterX(newSDigit.GetDetElemID(), xPixelNew), 
-                                  fSegmentation->GetPixelCenterY(newSDigit.GetDetElemID(), yPixelNew),
-                                  fSegmentation->GetPixelCenterZ(newSDigit.GetDetElemID(), 0)); 
-           new ((*pSDigList[iPlane])[pSDigList[iPlane]->GetEntries()]) AliMFTDigit(newSDigit);
+         xPixel = mySDig->GetPixelX();
+         yPixel = mySDig->GetPixelY()+1;
+         if (fSegmentation->DoesPixelExist(mySDig->GetDetElemID(), xPixel, yPixel)) {
+           AliMFTDigit *newSDigit = new AliMFTDigit();
+           newSDigit->SetEloss(0.);
+           newSDigit->SetDetElemID(mySDig->GetDetElemID());
+           newSDigit->SetPlane(mySDig->GetDetElemID());
+           newSDigit->SetPixID(xPixel, yPixel, 0);
+           newSDigit->SetPixWidth(fSegmentation->GetPixelSizeX(newSDigit->GetDetElemID()), 
+                                  fSegmentation->GetPixelSizeY(newSDigit->GetDetElemID()),
+                                  fSegmentation->GetPixelSizeZ(newSDigit->GetDetElemID()));  
+           newSDigit->SetPixCenter(fSegmentation->GetPixelCenterX(newSDigit->GetDetElemID(), xPixel), 
+                                   fSegmentation->GetPixelCenterY(newSDigit->GetDetElemID(), yPixel),
+                                   fSegmentation->GetPixelCenterZ(newSDigit->GetDetElemID(), 0)); 
+           new ((*fSideDigits)[fSideDigits->GetEntries()]) AliMFTDigit(*newSDigit);
          }
        }
        else {   // pair-odd
-         Int_t xPixelNew = mySDig->GetPixelX();
-         Int_t yPixelNew = mySDig->GetPixelY()-1;
-         if (fSegmentation->DoesPixelExist(mySDig->GetDetElemID(), xPixelNew, yPixelNew)) {
-           AliMFTDigit newSDigit;
-           newSDigit.SetEloss(0.);
-           newSDigit.SetDetElemID(mySDig->GetDetElemID());
-           newSDigit.SetPlane(iPlane);
-           newSDigit.SetPixID(xPixelNew, yPixelNew, 0);
-           newSDigit.SetPixWidth(fSegmentation->GetPixelSizeX(newSDigit.GetDetElemID()), 
-                                 fSegmentation->GetPixelSizeY(newSDigit.GetDetElemID()),
-                                 fSegmentation->GetPixelSizeZ(newSDigit.GetDetElemID()));  
-           newSDigit.SetPixCenter(fSegmentation->GetPixelCenterX(newSDigit.GetDetElemID(), xPixelNew), 
-                                  fSegmentation->GetPixelCenterY(newSDigit.GetDetElemID(), yPixelNew),
-                                  fSegmentation->GetPixelCenterZ(newSDigit.GetDetElemID(), 0)); 
-           new ((*pSDigList[iPlane])[pSDigList[iPlane]->GetEntries()]) AliMFTDigit(newSDigit);
+         xPixel = mySDig->GetPixelX();
+         yPixel = mySDig->GetPixelY()-1;
+         if (fSegmentation->DoesPixelExist(mySDig->GetDetElemID(), xPixel, yPixel)) {
+           AliMFTDigit *newSDigit = new AliMFTDigit();
+           newSDigit->SetEloss(0.);
+           newSDigit->SetDetElemID(mySDig->GetDetElemID());
+           newSDigit->SetPlane(mySDig->GetPlane());
+           newSDigit->SetPixID(xPixel, yPixel, 0);
+           newSDigit->SetPixWidth(fSegmentation->GetPixelSizeX(newSDigit->GetDetElemID()), 
+                                  fSegmentation->GetPixelSizeY(newSDigit->GetDetElemID()),
+                                  fSegmentation->GetPixelSizeZ(newSDigit->GetDetElemID()));  
+           newSDigit->SetPixCenter(fSegmentation->GetPixelCenterX(newSDigit->GetDetElemID(), xPixel), 
+                                   fSegmentation->GetPixelCenterY(newSDigit->GetDetElemID(), yPixel),
+                                   fSegmentation->GetPixelCenterZ(newSDigit->GetDetElemID(), 0)); 
+           new ((*fSideDigits)[fSideDigits->GetEntries()]) AliMFTDigit(*newSDigit);
          }
        }
       }
     }
+
+    // -------- checking which pixels switched on have their diode actually within the charge dispersion radius
+
+    for (Int_t iSDigit=0; iSDigit<fSideDigits->GetEntries(); iSDigit++) {
+      AliMFTDigit *mySDig = (AliMFTDigit*) (fSideDigits->At(iSDigit));
+      Double_t distance = TMath::Sqrt(TMath::Power(mySDig->GetPixelCenterX()-hit->X(),2) + TMath::Power(mySDig->GetPixelCenterY()-hit->Y(),2));
+      if (fSegmentation->GetPlane(mySDig->GetPlane())->HasPixelRectangularPatternAlongY()) {
+       if (mySDig->GetPixelX()%2 == mySDig->GetPixelY()%2) {  // both pair or both odd
+         if (distance<fChargeDispersion) {
+           AliDebug(1, Form("Created new sdigit (%f, %f, %f) from hit (%f, %f, %f)",
+                            mySDig->GetPixelCenterX(), mySDig->GetPixelCenterY(), mySDig->GetPixelCenterZ(), hit->X(), hit->Y(), hit->Z()));
+           new ((*pSDigList[mySDig->GetPlane()])[pSDigList[mySDig->GetPlane()]->GetEntries()]) AliMFTDigit(*mySDig);
+           xPixel = mySDig->GetPixelX();
+           yPixel = mySDig->GetPixelY()+1;
+           if (fSegmentation->DoesPixelExist(mySDig->GetDetElemID(), xPixel, yPixel)) {
+             AliMFTDigit *newSDigit = new AliMFTDigit();
+             newSDigit->SetEloss(0.);
+             newSDigit->SetDetElemID(mySDig->GetDetElemID());
+             newSDigit->SetPlane(mySDig->GetPlane());
+             newSDigit->SetPixID(xPixel, yPixel, 0);
+             newSDigit->SetPixWidth(fSegmentation->GetPixelSizeX(newSDigit->GetDetElemID()), 
+                                    fSegmentation->GetPixelSizeY(newSDigit->GetDetElemID()),
+                                    fSegmentation->GetPixelSizeZ(newSDigit->GetDetElemID()));  
+             newSDigit->SetPixCenter(fSegmentation->GetPixelCenterX(newSDigit->GetDetElemID(), xPixel), 
+                                     fSegmentation->GetPixelCenterY(newSDigit->GetDetElemID(), yPixel),
+                                     fSegmentation->GetPixelCenterZ(newSDigit->GetDetElemID(), 0));
+             AliDebug(1, Form("Created new sdigit (%f, %f, %f) from hit (%f, %f, %f)",
+                              newSDigit->GetPixelCenterX(), newSDigit->GetPixelCenterY(), newSDigit->GetPixelCenterZ(), hit->X(), hit->Y(), hit->Z()));
+             new ((*pSDigList[newSDigit->GetPlane()])[pSDigList[newSDigit->GetPlane()]->GetEntries()]) AliMFTDigit(*newSDigit);
+           }
+         }
+       }
+      }
+      else {
+       if (distance<fChargeDispersion) {
+         AliDebug(1, Form("Created new sdigit (%f, %f, %f) from hit (%f, %f, %f)",
+                          mySDig->GetPixelCenterX(), mySDig->GetPixelCenterY(), mySDig->GetPixelCenterZ(), hit->X(), hit->Y(), hit->Z()));
+         new ((*pSDigList[mySDig->GetPlane()])[pSDigList[mySDig->GetPlane()]->GetEntries()]) AliMFTDigit(*mySDig);
+       }
+      }
+    }
+
+    fSideDigits->Delete(); 
+
   }
 
-  //------------------------------------------------------------------------
-  
-  AliDebug(1,"Stop Hits2SDigitsLocal");
+  AliDebug(1,"Exiting Hits2SDigitsLocal");
 
 }
 
index 95c9ba9e334db26a0c143e0b508f9cf0b4c41f85..556ec0021404da1ed72054b7abee45ddc56f8fdb 100644 (file)
@@ -31,7 +31,7 @@ const Double_t AliMFTConstants::fCutForAttachingDigits = 1.;
 
 const Double_t AliMFTConstants::fElossPerElectron = 3.62e-09;
 
-const Double_t AliMFTConstants::fRadiusMin = 2.225;
+const Double_t AliMFTConstants::fRadiusMin = 2.5;
 
 const Double_t AliMFTConstants::fActiveSuperposition = 0.05;
                                  
index 7b001dc542e60917c4ce870ec8e9b274b2c1d9e5..cf7a631246e0fd67d053175ff0113bb83bf51bc0 100644 (file)
Binary files a/MFT/AliMFTGeometry.root and b/MFT/AliMFTGeometry.root differ
index 419744775a9cd4f1030505c2fb386a482ab52a06..be9ac7a548fe30f85fddc3101def65d8978caf89 100644 (file)
@@ -200,10 +200,10 @@ Bool_t AliMFTPlane::Init(Int_t    planeNumber,
   fZCenterActiveFront = fZCenter - 0.5*fThicknessSupport - 0.5*fThicknessActive;
   fZCenterActiveBack  = fZCenter + 0.5*fThicknessSupport + 0.5*fThicknessActive;
 
-  if (fRMinSupport <= fRadiusMin) fRMinSupport = fRadiusMin;
-  else {
-    fRMinSupport = fRadiusMin + (fHeightActive-fActiveSuperposition) * Int_t((fRMinSupport-fRadiusMin)/(fHeightActive-fActiveSuperposition));
-  }
+//   if (fRMinSupport <= fRadiusMin) fRMinSupport = fRadiusMin;
+//   else {
+//     fRMinSupport = fRadiusMin + (fHeightActive-fActiveSuperposition) * Int_t((fRMinSupport-fRadiusMin)/(fHeightActive-fActiveSuperposition));
+//   }
   
   if (fRMax < fRMinSupport+fHeightActive) fRMax = fRMinSupport + fHeightActive;
   
index 8ad17d0f6d1ed39d2ceed62ac2b149e69d9cad0e..c01353ff1e7b67139ddc4a727acdd64287c0016f 100644 (file)
@@ -422,11 +422,20 @@ Bool_t AliMuonForwardTrackFinder::LoadNextEvent() {
   
   AliInfo(Form(" **** analyzing event # %d  \n", fEv));
   
-  fTrackStore    = fMuonRecoCheck->ReconstructedTracks(fEv);
-  if (fTrackStore->IsEmpty()) return kFALSE;
+  fTrackStore = fMuonRecoCheck->ReconstructedTracks(fEv);
+  if (fTrackStore->IsEmpty()) {
+    AliInfo("fTrackStore Is Empty: exiting NOW!");
+    return kFALSE;
+  }
+  AliInfo("fTrackStore contains tracks!");
+
+  AliDebug(2, Form("Getting fMuonRecoCheck->ReconstructibleTracks(%d)", fEv));
   fTrackRefStore = fMuonRecoCheck->ReconstructibleTracks(fEv);
   
+  AliDebug(2, Form("Getting fRunLoader->GetEvent(%d)", fEv));
   fRunLoader->GetEvent(fEv);
+
+  AliDebug(2, Form("fMFTLoader->TreeR() = %p",fMFTLoader->TreeR()));
   if (!fMFTLoader->TreeR()->GetEvent()) return kFALSE;
   for (Int_t iPlane=0; iPlane<fNPlanesMFT; iPlane++) {
     AliDebug(1, Form("plane %02d: nClusters = %d\n", iPlane, (fMFT->GetRecPointsList(iPlane))->GetEntries()));
index 15ff8834c880e48b627961d8c8aa053d1107854a..01902598110773bde8a06fcf9588181495d339c4 100644 (file)
@@ -12,22 +12,22 @@ void SetMFTGeometry() {
   
   const Float_t zCenter[nPlanes]          = {  -50.0,   -58.0,   -66.0,   -72.0,   -76.0 };   // expressed in cm
                                          
-  const Float_t rMin[nPlanes]             = {   2.20,    2.60,    3.00,    3.30,    3.60 };   // expressed in cm  
+  const Float_t rMin[nPlanes]             = {   2.50,    2.50,    3.00,    3.50,    3.50 };   // expressed in cm  
   const Float_t rMax[nPlanes]             = {   9.70,   11.00,   12.40,   13.40,   14.00 };   // expressed in cm
-                                         
-  const Float_t pixelSizeX[nPlanes]       = { 20.e-4,  20.e-4,  20.e-4,  20.e-4,  20.e-4 };   // expressed in cm
-  const Float_t pixelSizeY[nPlanes]       = { 20.e-4,  20.e-4,  20.e-4,  20.e-4,  20.e-4 };   // expressed in cm
+
+  const Float_t pixelSizeX[nPlanes]       = { 25.e-4,  25.e-4,  25.e-4,  25.e-4,  25.e-4 };   // expressed in cm
+  const Float_t pixelSizeY[nPlanes]       = { 25.e-4,  25.e-4,  25.e-4,  25.e-4,  25.e-4 };   // expressed in cm
 
   const Float_t thicknessActive[nPlanes]  = {  50.e-4,   50.e-4,   50.e-4,   50.e-4,   50.e-4 };   // expressed in cm
   const Float_t thicknessSupport[nPlanes] = {2000.e-4, 2000.e-4, 2000.e-4, 2000.e-4, 2000.e-4 };   // expressed in cm
   const Float_t thicknessReadout[nPlanes] = {  50.e-4,   50.e-4,   50.e-4,   50.e-4,   50.e-4 };   // expressed in cm
 
-  const Float_t equivalentSilicon[nPlanes]            = { 300.e-4, 300.e-4, 300.e-4, 300.e-4, 300.e-4};    // expressed in cm
-  const Float_t equivalentSiliconBeforeFront[nPlanes] = {   0.e-4,   0.e-4,   0.e-4,   0.e-4,   0.e-4};    // expressed in cm
-  const Float_t equivalentSiliconBeforeBack[nPlanes]  = { 250.e-4, 250.e-4, 250.e-4, 250.e-4, 250.e-4};    // expressed in cm
+  const Float_t equivalentSilicon[nPlanes]            = { 400.e-4, 400.e-4, 400.e-4, 400.e-4, 400.e-4 };    // expressed in cm
+  const Float_t equivalentSiliconBeforeFront[nPlanes] = {   0.e-4,   0.e-4,   0.e-4,   0.e-4,   0.e-4 };    // expressed in cm
+  const Float_t equivalentSiliconBeforeBack[nPlanes]  = { 350.e-4, 350.e-4, 350.e-4, 350.e-4, 350.e-4 };    // expressed in cm
 
   const Float_t hasPixelRectangularPatternAlongY[nPlanes] = {0., 0., 0., 0., 0.};
-
+                                        
   TNtuple *geomMFT = new TNtuple("AliMFTGeometry", "ALICE MFT Geometry", "zCenter:rMin:rMax:pixelSizeX:pixelSizeY:thicknessActive:thicknessSupport:thicknessReadout:equivalentSilicon:equivalentSiliconBeforeFront:equivalentSiliconBeforeBack:hasPixelRectangularPatternAlongY");
 
   for (Int_t iPlane=0; iPlane<nPlanes; iPlane++) geomMFT -> Fill(zCenter[iPlane],