Some changes to AliFMDInput and scripts
authorcholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 25 Sep 2007 08:44:03 +0000 (08:44 +0000)
committercholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 25 Sep 2007 08:44:03 +0000 (08:44 +0000)
12 files changed:
FMD/AliFMDInput.cxx
FMD/AliFMDInput.h
FMD/AliFMDPattern.cxx
FMD/AliFMDReconstructor.cxx
FMD/AliFMDReconstructor.h
FMD/Simulate.C
FMD/scripts/DrawDigits.C
FMD/scripts/DrawDigitsRecs.C
FMD/scripts/DrawESD.C
FMD/scripts/DrawHits.C
FMD/scripts/DrawHitsDigits.C
FMD/scripts/DrawHitsRecs.C

index 1a77c39..d376f8e 100644 (file)
@@ -29,7 +29,7 @@
 // Latest changes by Christian Holm Christensen
 //
 #include "AliFMDInput.h"       // ALIFMDHIT_H
-#include "AliFMDDebug.h"               // ALIFMDDEBUG_H ALILOG_H
+#include "AliFMDDebug.h"       // ALIFMDDEBUG_H ALILOG_H
 #include "AliLoader.h"          // ALILOADER_H
 #include "AliRunLoader.h"       // ALIRUNLOADER_H
 #include "AliRun.h"             // ALIRUN_H
@@ -250,7 +250,7 @@ AliFMDInput::Init()
     }
   }
 
-  
+  fEventCount = 0;
   fIsInit = kTRUE;
   return fIsInit;
 }
@@ -271,25 +271,25 @@ AliFMDInput::Begin(Int_t event)
   }
   // Get the event 
   if (fLoader->GetEvent(event)) return kFALSE;
-  AliInfo(Form("Now in event %d/%d", event, NEvents()));
+  AliInfo(Form("Now in event %8d/%8d", event, NEvents()));
 
   // Possibly load global kinematics information 
   if (TESTBIT(fTreeMask, kKinematics) || TESTBIT(fTreeMask, kTracks)) {
-    AliInfo("Getting kinematics");
+    // AliInfo("Getting kinematics");
     if (fLoader->LoadKinematics()) return kFALSE;
     fStack = fLoader->Stack();
   }
   // Possibly load FMD Hit information 
   if (TESTBIT(fTreeMask, kHits) || TESTBIT(fTreeMask, kTracks)) {
-    AliInfo("Getting FMD hits");
-    if (fFMDLoader->LoadHits()) return kFALSE;
+    // AliInfo("Getting FMD hits");
+    if (!fFMDLoader || fFMDLoader->LoadHits()) return kFALSE;
     fTreeH = fFMDLoader->TreeH();
     if (!fArrayH) fArrayH = fFMD->Hits(); 
   }
   // Possibly load FMD Digit information 
   if (TESTBIT(fTreeMask, kDigits)) {
-    AliInfo("Getting FMD digits");
-    if (fFMDLoader->LoadDigits()) return kFALSE;
+    // AliInfo("Getting FMD digits");
+    if (!fFMDLoader || fFMDLoader->LoadDigits()) return kFALSE;
     fTreeD = fFMDLoader->TreeD();
     if (fTreeD) {
       if (!fArrayD) fArrayD = fFMD->Digits();
@@ -301,21 +301,21 @@ AliFMDInput::Begin(Int_t event)
   }
   // Possibly load FMD Sdigit information 
   if (TESTBIT(fTreeMask, kSDigits)) {
-    AliInfo("Getting FMD summable digits");
-    if (fFMDLoader->LoadSDigits()) return kFALSE;
+    // AliInfo("Getting FMD summable digits");
+    if (!fFMDLoader || fFMDLoader->LoadSDigits()) return kFALSE;
     fTreeS = fFMDLoader->TreeS();
     if (!fArrayS) fArrayS = fFMD->SDigits();
   }
   // Possibly load FMD RecPoints information 
   if (TESTBIT(fTreeMask, kRecPoints)) {
-    AliInfo("Getting FMD reconstructed points");
-    if (fFMDLoader->LoadRecPoints()) return kFALSE;
+    // AliInfo("Getting FMD reconstructed points");
+    if (!fFMDLoader || fFMDLoader->LoadRecPoints()) return kFALSE;
     fTreeR = fFMDLoader->TreeR();
     if (!fArrayR) fArrayR = new TClonesArray("AliFMDRecPoint");
     fTreeR->SetBranchAddress("FMD",  &fArrayR);
   }  // Possibly load FMD ESD information 
   if (TESTBIT(fTreeMask, kESD)) {
-    AliInfo("Getting FMD event summary data");
+    // AliInfo("Getting FMD event summary data");
     Int_t read = fChainE->GetEntry(event);
     if (read <= 0) return kFALSE;
     fESD = fESDEvent->GetFMDData();
@@ -333,13 +333,13 @@ AliFMDInput::Begin(Int_t event)
   }
   // Possibly load FMD Digit information 
   if (TESTBIT(fTreeMask, kRaw)) {
-    AliInfo("Getting FMD raw data digits");
+    // AliInfo("Getting FMD raw data digits");
     if (!fReader->NextEvent()) return kFALSE;
     AliFMDRawReader r(fReader, 0);
     fArrayA->Clear();
     r.ReadAdcs(fArrayA);
   }
-  
+  fEventCount++;
   return kTRUE;
 }
 
@@ -612,6 +612,31 @@ AliFMDInput::Run()
   return retval;
 }
 
+//__________________________________________________________________
+TArrayF 
+AliFMDInput::MakeLogScale(Int_t n, Double_t min, Double_t max) 
+{
+  // Service function to define a logarithmic axis. 
+  // Parameters: 
+  //   n    Number of bins 
+  //   min  Minimum of axis 
+  //   max  Maximum of axis 
+  TArrayF bins(n+1);
+  bins[0]      = min;
+  if (n <= 20) {
+    for (Int_t i = 1; i < n+1; i++) bins[i] = bins[i-1] + (max-min)/n;
+    return bins;
+  }
+  Float_t dp   = n / TMath::Log10(max / min);
+  Float_t pmin = TMath::Log10(min);
+  for (Int_t i = 1; i < n+1; i++) {
+    Float_t p = pmin + i / dp;
+    bins[i]   = TMath::Power(10, p);
+  }
+  return bins;
+}
+
+
 
 //____________________________________________________________________
 //
index aeb4ce2..fb27fc6 100644 (file)
@@ -223,7 +223,12 @@ public:
       @return  @c false on error  */
   virtual Bool_t ProcessESD(UShort_t, Char_t, UShort_t, UShort_t, 
                            Float_t, Float_t);
-  
+  /** Service function to make a logarithmic axis. 
+      @param n    Number of bins 
+      @param min  Minimum of axis 
+      @param max  Maximum of axis. 
+      @return An array with the bin boundaries. */
+  static TArrayF MakeLogScale(Int_t n, Double_t min, Double_t max);
 protected:
   /** Copy ctor 
       @param o Object to copy from  */
@@ -284,6 +289,7 @@ protected:
   TGeoManager*  fGeoManager; // Geometry manager
   Int_t         fTreeMask;   // Which tree's to load
   Bool_t        fIsInit;     // Have we been initialized 
+  Int_t         fEventCount; // Event counter 
   ClassDef(AliFMDInput,0)  //Hits for detector FMD
 };
 
index ebdb15e..79999d7 100644 (file)
@@ -245,6 +245,7 @@ AliFMDPattern::Init()
   // Initialize.  Get transforms and such, 
   if (!AliFMDInput::Init()) return kFALSE;
   AliFMDGeometry* geom = AliFMDGeometry::Instance();
+  if (!geom) return kFALSE;
   geom->Init();
   geom->InitTransformations();
   
index cd2d474..85c6dfe 100644 (file)
@@ -306,16 +306,18 @@ AliFMDReconstructor::ProcessDigits(TClonesArray* digits) const
                      digit->Strip(), digit->Counts(), counts, edep, mult));
     
     // Create a `RecPoint' on the output branch. 
-    AliFMDRecPoint* m = 
-      new ((*fMult)[fNMult]) AliFMDRecPoint(digit->Detector(), 
-                                           digit->Ring(), 
-                                           digit->Sector(),
-                                           digit->Strip(),
-                                           eta, phi, 
-                                           edep, mult);
-    (void)m; // Suppress warnings about unused variables. 
-    fNMult++;
-
+    if (fMult) {
+      AliFMDRecPoint* m = 
+       new ((*fMult)[fNMult]) AliFMDRecPoint(digit->Detector(), 
+                                             digit->Ring(), 
+                                             digit->Sector(),
+                                             digit->Strip(),
+                                             eta, phi, 
+                                             edep, mult);
+      (void)m; // Suppress warnings about unused variables. 
+      fNMult++;
+    }
+    
     fESDObj->SetMultiplicity(digit->Detector(), digit->Ring(), 
                             digit->Sector(),  digit->Strip(), mult);
     fESDObj->SetEta(digit->Detector(), digit->Ring(), 
@@ -474,9 +476,12 @@ AliFMDReconstructor::FillESD(TTree*  /* digitsTree */,
 
   if (!fDiagnostics || !esd) return;
   static bool first = true;
-  Int_t evno = esd->GetEventNumberInFile(); // This is most likely NOT the event number you'd like to use. It has nothing to do with the 'real' event number.
-  AliFMDDebug(1, ("Writing diagnostics histograms to FMD.Diag.root/%03d",
-                  evno));
+  // This is most likely NOT the event number you'd like to use. It
+  // has nothing to do with the 'real' event number. 
+  // - That's OK.  We just use it for the name of the directory -
+  // nothing else.  Christian
+  Int_t evno = esd->GetEventNumberInFile(); 
+  AliFMDDebug(1, ("Writing diagnostics histograms to FMD.Diag.root/%03d",evno));
   TFile f("FMD.Diag.root", (first ? "RECREATE" : "UPDATE"));
   first = false;
   f.cd(); 
@@ -502,12 +507,26 @@ AliFMDReconstructor::FillESD(TTree*  /* digitsTree */,
 
 //____________________________________________________________________
 void 
-AliFMDReconstructor::Reconstruct(AliRawReader*,TTree*) const 
+AliFMDReconstructor::Reconstruct(AliRawReader* reader,
+                                TTree* /* ctree */) const 
 {
   // Cannot be used.  See member function with same name but with 2
   // TTree arguments.   Make sure you do local reconstrucion 
   AliFMDDebug(2, ("Calling FillESD with loader and tree"));
+#if 1
+  TClonesArray* array = new TClonesArray("AliFMDDigit");
+  // if (ctree) ctree->Branch("FMD", &array);
+  AliFMDRawReader rawRead(reader, 0);
+  rawRead.ReadAdcs(array);
+  // ctree->Fill();
+  // Question - how to get the digits in this case? 
+  ProcessDigits(array);
+  // Reconstruct(array, ctree);
+  array->Delete();
+  delete array;
+#else
   AliError("MayNotUse");
+#endif
 }
 //____________________________________________________________________
 void 
@@ -529,12 +548,16 @@ AliFMDReconstructor::Reconstruct(AliRunLoader*, AliRawReader*) const
 }
 //____________________________________________________________________
 void 
-AliFMDReconstructor::FillESD(AliRawReader*,TTree*,AliESDEvent*) const 
+AliFMDReconstructor::FillESD(AliRawReader*,TTree*,AliESDEvent* esd) const 
 {
   // Cannot be used.  See member function with same name but with 2
   // TTree arguments.   Make sure you do local reconstrucion 
   AliFMDDebug(2, ("Calling FillESD with raw reader, tree, and ESD"));
+#if 1
+  FillESD((TTree*)0, (TTree*)0, esd);
+#else
   AliError("MayNotUse");
+#endif
 }
 //____________________________________________________________________
 void 
index 53a5838..6c5ca95 100644 (file)
@@ -82,6 +82,14 @@ public:
       @param digitsTree  Tree holding the digits of this event
       @param clusterTree Tree to store AliFMDRecPoint objects in. */
   virtual void   Reconstruct(TTree* digitsTree, TTree* clusterTree) const;
+  /** Reconstruct one event from the raw data, via a digits read using
+      @a reader. The member function @e does @e not create
+      AliFMDRecPoint objects, and the read AliFMDDigit objects are not
+      stored. An FMD ESD object is created in parallel. 
+      @todo Make sure we get a vertex. 
+      @param reader      Raw data reader
+      @param clusterTree Tree to store AliFMDRecPoint objects in (not used). */
+  void Reconstruct(AliRawReader* reader, TTree* clusterTree) const;
   /** Put in the ESD data, the FMD ESD data.  The object created by
       the Reconstruct member function is copied to the ESD object. 
       @param digitsTree   Tree of digits for this event - not used
@@ -91,6 +99,14 @@ public:
   */
   virtual void   FillESD(TTree* digitsTree, TTree* clusterTree, 
                         AliESDEvent* esd) const;
+  /** Put in the ESD data, the FMD ESD data.  The object created by
+      the Reconstruct member function is copied to the ESD object. 
+      @param reader       Raw data reader - not used.
+      @param clusterTree  Tree of reconstructed points for this event
+                          - not used. 
+      @param esd          ESD object to store data in. */
+  void FillESD(AliRawReader* reader, TTree* clusterTree, 
+              AliESDEvent* esd) const;
   /** Not used */
   virtual void   SetESD(AliESDEvent* esd) { fESD = esd; }
   /** Set the noise factor 
@@ -192,13 +208,11 @@ protected:
   TH1*                  fDiagAll;      // Diagnostics histogram
 private:
   /** Hide base classes unused function */
-  void Reconstruct(AliRawReader*, TTree*) const;
-  /** Hide base classes unused function */
   void Reconstruct(AliRunLoader*) const;
   /** Hide base classes unused function */
   void Reconstruct(AliRunLoader*, AliRawReader*) const;
-  /** Hide base classes unused function */
-  void FillESD(AliRawReader*, TTree*, AliESDEvent*) const;
+  // /** Hide base classes unused function */
+  // void FillESD(AliRawReader*, TTree*, AliESDEvent*) const;
   /** Hide base classes unused function */
   void FillESD(AliRunLoader*, AliESDEvent*) const;
   /** Hide base classes unused function */
index 9d38d89..f9cab91 100644 (file)
@@ -21,7 +21,7 @@
 /** Script to do test the FMD digitization class.  
  */
 void
-Simulate()
+Simulate(Int_t n=10)
 {
   AliSimulation sim;
   // AliLog::SetModuleDebugLevel("FMD", 1);
@@ -32,7 +32,7 @@ Simulate()
   // sim.SetMakeDigitsFromHits("FMD"); 
   TStopwatch w; 
   w.Start(); 
-  sim.Run(10);  
+  sim.Run(n);  
   w.Stop(); 
   w.Print(); 
 }
index 572b492..107ba89 100644 (file)
@@ -37,11 +37,12 @@ private:
   TH1D* fAdc; // Histogram 
 public:
   //__________________________________________________________________
-  DrawDigits(Int_t m=1100, Double_t amin=-0.5, Double_t amax=1099.5) 
+  DrawDigits(Int_t m=1100, Double_t amin=-0.5, Double_t amax=1023.5) 
   { 
     AddLoad(kDigits);
     fAdc = new TH1D("adc", "ADC", m, amin, amax);
     fAdc->SetXTitle("ADC value");
+    fAdc->Sumw2();
   }
   //__________________________________________________________________
   Bool_t ProcessDigit(AliFMDDigit* digit)
@@ -60,6 +61,7 @@ public:
     gStyle->SetPadColor(0);
     gStyle->SetPadBorderSize(0);
     fAdc->SetStats(kFALSE);
+    fAdc->Scale(1. / fAdc->GetEntries());
     fAdc->Draw();
     return kTRUE;
   }
index a2b6d9f..faff781 100644 (file)
@@ -42,19 +42,6 @@ private:
   AliFMDUShortMap fMap;
 public:
   //__________________________________________________________________
-  TArrayF MakeLogScale(Int_t n, Double_t min, Double_t max) 
-  {
-    TArrayF bins(n+1);
-    Float_t dp   = n / TMath::Log10(max / min);
-    Float_t pmin = TMath::Log10(min);
-    bins[0]      = min;
-    for (Int_t i = 1; i < n+1; i++) {
-      Float_t p = pmin + i / dp;
-      bins[i]   = TMath::Power(10, p);
-    }
-    return bins;
-  }
-  //__________________________________________________________________
   DrawDigitsRecs(Int_t m=1100, Double_t amin=-0.5, Double_t amax=1099.5,
                 Int_t n=105, Double_t mmin=-0.5, Double_t mmax=20.5) 
   { 
@@ -62,6 +49,7 @@ public:
     AddLoad(kRecPoints);
     fAdcVsSingle = new TH2D("adcVsSingle", "ADC vs. Multiplicity (strip)", 
                            m, amin, amax, n, mmin, mmax);
+    fAdcVsSingle->Sumw2();
     fAdcVsSingle->SetXTitle("ADC value");
     fAdcVsSingle->SetYTitle("Strip Multiplicity");
   }
@@ -114,8 +102,8 @@ public:
     gStyle->SetCanvasBorderSize(0);
     gStyle->SetPadColor(0);
     gStyle->SetPadBorderSize(0);
-
-    fAdcVsSingle->SetStats(kFALSE);
+    gStyle->SetOptLogz(kTRUE);
+    fAdcVsSingle->SetStats(0);
     fAdcVsSingle->Draw("COLZ");
     return kTRUE;
   }
index 1e24aa0..e6cf2da 100644 (file)
@@ -47,24 +47,12 @@ private:
   const Double_t fCorr;
 public:
   //__________________________________________________________________
-  TArrayF MakeLogScale(Int_t n, Double_t min, Double_t max) 
-  {
-    TArrayF bins(n+1);
-    Float_t dp   = n / TMath::Log10(max / min);
-    Float_t pmin = TMath::Log10(min);
-    bins[0]      = min;
-    for (Int_t i = 1; i < n+1; i++) {
-      Float_t p = pmin + i / dp;
-      bins[i]   = TMath::Power(10, p);
-    }
-    return bins;
-  }
-  //__________________________________________________________________
   DrawESD(Int_t n=420, Double_t mmin=-0.5, Double_t mmax=20.5) 
     : fCorr(1) // 0.68377 / 1.1)
   { 
     AddLoad(kESD);
     fMult = new TH1D("mult", " Multiplicity (strip)", n, mmin, mmax);
+    fMult->Sumw2();
     fMult->SetXTitle("Strip Multiplicity");
   }
   //__________________________________________________________________
@@ -104,6 +92,7 @@ public:
     // fMult->GetXaxis()->SetRangeUser(0.2,4);
     // fMult->Sumw2();
     // fMult->Scale(1. / fMult->GetMaximum());
+    fMult->Scale(1. / fMult->GetEntries());
     fMult->SetStats(kFALSE);
     fMult->SetFillColor(2);
     fMult->SetFillStyle(3001);
index 6845cf4..cff327a 100644 (file)
@@ -47,23 +47,6 @@ private:
   const Double_t fBetaGammaMip;
 public:
   //__________________________________________________________________
-  TArrayF MakeLogScale(Int_t n, Double_t min, Double_t max) 
-  {
-    TArrayF bins(n+1);
-    bins[0]      = min;
-    if (n <= 20) {
-      for (Int_t i = 1; i < n+1; i++) bins[i] = bins[i-1] + (max-min)/n;
-      return bins;
-    }
-    Float_t dp   = n / TMath::Log10(max / min);
-    Float_t pmin = TMath::Log10(min);
-    for (Int_t i = 1; i < n+1; i++) {
-      Float_t p = pmin + i / dp;
-      bins[i]   = TMath::Power(10, p);
-    }
-    return bins;
-  }
-  //__________________________________________________________________
   DrawHits(const char* pdgName="pi+",
           Int_t m=1000, Double_t emin=1, Double_t emax=1000, 
           Int_t n=900, Double_t tmin=1e-2, Double_t tmax=1e3) 
@@ -87,11 +70,13 @@ public:
                           eloss.fN-1, eloss.fArray);
     fElossVsPMQ->SetXTitle("p/(mq^{2})=#beta#gamma/q^{2}");
     fElossVsPMQ->SetYTitle("#Delta E/#Delta x / q^{2} [MeV/cm]");
+    fElossVsPMQ->SumW2();
     fEloss = new TH1D("eloss", "#Delta E/#Delta x / q^{2}", 
                      eloss.fN-1, eloss.fArray);
     fEloss->SetFillColor(2);
     fEloss->SetFillStyle(3001);
     fEloss->SetXTitle("#Delta E/#Delta x / q^{2} [MeV/cm]");
+    fEloss->SumW2();
   }
   //__________________________________________________________________
   Bool_t ProcessHit(AliFMDHit* hit, TParticle* p) 
@@ -137,8 +122,7 @@ public:
     c->SetLogy();
     c->SetLogx();
 
-    TString title(fElossVsPMQ->GetTitle());
-    title.Append(Form(", %d events", fEventCount));
+    TString title(Form("%s, %d events", fElossVsPMQ->GetTitle(), fEventCount));
     fElossVsPMQ->SetTitle(title.Data());
     fElossVsPMQ->SetStats(kFALSE);
     fElossVsPMQ->Draw("AXIS");
@@ -172,6 +156,7 @@ public:
     c = new TCanvas("eloss", "Energy loss per unit material");
     // c->SetLogx();
     c->SetLogy();
+    fEloss->Scale(1. / fEloss->GetEntries());
     fEloss->GetXaxis()->SetRangeUser(1, 10);
     fEloss->Fit("landau", "", "", 1, 10);
     TF1* land = fEloss->GetFunction("landau");
@@ -191,7 +176,7 @@ public:
     l = new TLegend(.6, .6, .89, .89);
     l->AddEntry(fEloss, fEloss->GetTitle(), "lf");
     l->AddEntry(land,   "Landau fit", "l");
-    l->AddEntry(resp,   "f(#Delta_{p}/x) [RPP fig 27.8]");
+    l->AddEntry(resp,   "f(#Delta_{p}/x) [RPP fig 27.8]", "l");
     l->Draw("same");
 
     return kTRUE;
@@ -343,7 +328,8 @@ public:
     if (!graph) { 
       graph = new TGraph(12);
       graph->SetName("mean_eloss");
-      graph->SetTitle("Mean #Delta E/#Delta x - electronic only  [RPP fig. 27.6]");
+      graph->SetTitle("Mean #Delta E/#Delta x - "
+                     "electronic only  [RPP fig. 27.6]");
       graph->GetHistogram()->SetYTitle("(MeVcm^{2}/g)");
       graph->GetHistogram()->SetXTitle("#mu E_{kin} (GeV)");
       graph->SetFillColor(1);
index 8f5e227..94c8df2 100644 (file)
@@ -39,19 +39,6 @@ private:
   AliFMDEdepMap fMap;
 public:
   //__________________________________________________________________
-  TArrayF MakeLogScale(Int_t n, Double_t min, Double_t max) 
-  {
-    TArrayF bins(n+1);
-    Float_t dp   = n / TMath::Log10(max / min);
-    Float_t pmin = TMath::Log10(min);
-    bins[0]      = min;
-    for (Int_t i = 1; i < n+1; i++) {
-      Float_t p = pmin + i / dp;
-      bins[i]   = TMath::Power(10, p);
-    }
-    return bins;
-  }
-  //__________________________________________________________________
   DrawHitsDigits(Int_t n=900, Double_t emin=1e-3, Double_t emax=10, 
                 Int_t m=1100, Double_t amin=-0.5, Double_t amax=1099.5) 
   { 
index 5cbd4e1..8dea007 100644 (file)
@@ -58,19 +58,6 @@ private:
   Bool_t fPrimary;
 public:
   //__________________________________________________________________
-  TArrayF MakeLogScale(Int_t n, Double_t min, Double_t max) 
-  {
-    TArrayF bins(n+1);
-    Float_t dp   = n / TMath::Log10(max / min);
-    Float_t pmin = TMath::Log10(min);
-    bins[0]      = min;
-    for (Int_t i = 1; i < n+1; i++) {
-      Float_t p = pmin + i / dp;
-      bins[i]   = TMath::Power(10, p);
-    }
-    return bins;
-  }
-  //__________________________________________________________________
   DrawHitsRecs(Bool_t primary=kFALSE,
               Int_t n=900, Double_t emin=1e-3, Double_t emax=10, 
               Int_t m=21, Double_t mmin=-0.5, Double_t mmax=20.5) 
@@ -106,9 +93,9 @@ public:
                      1100, -1, 1.1);
     fDiffE->SetXTitle("#frac{#Delta E_{sim}-#Delta E_{rec}}{#Delta E_{sim}}");
     
-    Double_t omin = -.5;
-    Double_t omax = 7.5;
-    Int_t    o    = 8;
+    Double_t omin = mmin; // -.5;
+    Double_t omax = mmax; // 7.5;
+    Int_t    o    = m;    // 8;
     fHitsVsRecM = new TH2D("hitsVsStrip", "# of Hits vs. M_{rec}",
                           o, omin, omax, m, mmin, mmax);
     fHitsVsRecM->SetXTitle("# of Hits");
@@ -121,12 +108,12 @@ public:
     fDiffM->SetYTitle("|#eta|");
     // fDiffM->SetYTitle("Detector");
 
-    fHitEloss = new TH1D("hitEloss", "#frac{#Delta E_{sim}}{#Delta x} (MeV/cm)", 
+    fHitEloss = new TH1D("hitEloss","#frac{#Delta E_{sim}}{#Delta x} (MeV/cm)", 
                         100, 0, 10);
     fHitEloss->SetFillColor(2);
     fHitEloss->SetFillStyle(3001);
     
-    fRecEloss = new TH1D("recEloss", "#frac{#Delta E_{rec}}{#Delta x} (MeV/cm)", 
+    fRecEloss = new TH1D("recEloss","#frac{#Delta E_{rec}}{#Delta x} (MeV/cm)", 
                         100, 0, 10);
     fRecEloss->SetFillColor(4);
     fRecEloss->SetFillStyle(3001);
@@ -159,7 +146,8 @@ public:
       if (!kine->IsPrimary()) return kTRUE;
     }
     
-    if (hit->Edep()/hit->Length() > 0.1) fHitEloss->Fill(hit->Edep() / hit->Length());
+    if (hit->Edep()/hit->Length() > 0.1) 
+      fHitEloss->Fill(hit->Edep() / hit->Length());
     fMap(det, rng, sec, str).fEdep += hit->Edep();
     fMap(det, rng, sec, str).fN++;
     return kTRUE;