Several fixes (the Make-Federico-Happy-Commit):
authorcholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 25 Aug 2008 09:27:41 +0000 (09:27 +0000)
committercholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 25 Aug 2008 09:27:41 +0000 (09:27 +0000)
- Calibration:  Redid calibration - sample rates where wrong.
- Alignment: Fixed bug in AliFMDAlignFaker and made new alignment
          objects.
- Digitisation:
* Implemented digitisation from SDigits->Digits
* Reimplemented Hit->Digit conversion using loaders
  only.
* Reimplemented Hit->SDigit conversion using loaders
  only.
- Display:  Fixed few problems here and there.

Note, this was completed a little a head of time of when I thought it would.
Basically, I managed to fix an urgent Hardware task quicker than I originally
thought.   I guess patience is a virtue.

30 files changed:
FMD/AliFMD.cxx
FMD/AliFMD.h
FMD/AliFMDAlignFaker.cxx
FMD/AliFMDBaseDigitizer.cxx
FMD/AliFMDBaseDigitizer.h
FMD/AliFMDCalibSampleRate.cxx
FMD/AliFMDDigitizer.cxx
FMD/AliFMDDigitizer.h
FMD/AliFMDDisplay.cxx
FMD/AliFMDDisplay.h
FMD/AliFMDHitDigitizer.cxx [new file with mode: 0644]
FMD/AliFMDHitDigitizer.h [new file with mode: 0644]
FMD/AliFMDParameters.cxx
FMD/AliFMDPattern.cxx
FMD/AliFMDRawWriter.cxx
FMD/AliFMDSDigitizer.cxx [deleted file]
FMD/AliFMDSDigitizer.h [deleted file]
FMD/AliFMDSSDigitizer.cxx [deleted file]
FMD/AliFMDSSDigitizer.h [deleted file]
FMD/Align/Data/Run0_999999999_v0_s0.root
FMD/Calib/AltroMap/Run0_999999_v0_s0.root
FMD/Calib/Dead/Run0_999999_v0_s0.root
FMD/Calib/Pedestal/Run0_999999_v0_s0.root
FMD/Calib/PulseGain/Run0_999999_v0_s0.root
FMD/Calib/SampleRate/Run0_999999_v0_s0.root
FMD/Calib/StripRange/Run0_999999_v0_s0.root
FMD/Calib/ZeroSuppression/Run0_999999_v0_s0.root
FMD/FMDsimLinkDef.h
FMD/libFMDsim.pkg
FMD/scripts/PatternSDigits.C [new file with mode: 0644]

index 9ee54f2..7ec9355 100644 (file)
 #include "AliFMDDetector.h"    // ALIFMDDETECTOR_H
 #include "AliFMDRing.h"                // ALIFMDRING_H
 #include "AliFMDDigitizer.h"   // ALIFMDDIGITIZER_H
-#include "AliFMDSDigitizer.h"  // ALIFMDSDIGITIZER_H
+#include "AliFMDHitDigitizer.h"        // ALIFMDSDIGITIZER_H
 // #define USE_SSDIGITIZER 
-#ifdef USE_SSDIGITIZER
-# include "AliFMDSSDigitizer.h"        // ALIFMDSDIGITIZER_H
-#endif
+//#ifdef USE_SSDIGITIZER
+//# include "AliFMDSSDigitizer.h"      // ALIFMDSDIGITIZER_H
+//#endif
 // #include "AliFMDGeometryBuilder.h"
 #include "AliFMDRawWriter.h"   // ALIFMDRAWWRITER_H
 #include "AliFMDPoints.h"       // ALIFMDPOINTS_H
@@ -1058,16 +1058,9 @@ AliFMD::Hits2Digits()
   // Create AliFMDDigit's from AliFMDHit's.  This is done by making a
   // AliFMDDigitizer, and executing that code.
   // 
-#if 0
-  Warning("Hits2Digits", "Try not to use this method.\n"
-         "Instead, use AliSimulator");
-#endif
-  AliRunDigitizer* manager = new AliRunDigitizer(1, 1);
-  manager->SetInputStream(0, "galice.root");
-  manager->SetOutputFile("H2Dfile.root");
-  new AliFMDDigitizer(manager);
-  manager->Exec("");
-  delete manager;
+  AliFMDHitDigitizer digitizer(this, AliFMDHitDigitizer::kDigits);
+  digitizer.Init();
+  digitizer.Exec("");
 }
 
 //____________________________________________________________________
@@ -1077,25 +1070,9 @@ AliFMD::Hits2SDigits()
   // Create AliFMDSDigit's from AliFMDHit's.  This is done by creating
   // an AliFMDSDigitizer object, and executing it. 
   // 
-
-#if 0
-  Warning("Hits2SDigits", "Try not to use this method.\n"
-         "Instead, use AliSimulator");
-  // Create AliFMDSDigit's from AliFMDHit's.  This is done by creating
-  // an AliFMDSDigitizer object, and executing it. 
-  // 
-  AliFMDSDigitizer* digitizer = new AliFMDSDigitizer("galice.root");
-  digitizer->Exec("");
-  delete digitizer;
-#endif
-  AliRunDigitizer* manager = new AliRunDigitizer(1, 1);
-  manager->SetInputStream(0, "galice.root");
-  // manager->SetOutputFile("H2Sfile.root");
-  
-  new AliFMDSDigitizer(manager);
-  manager->Exec("");
-  // Hmm!
-  delete manager;
+  AliFMDHitDigitizer digitizer(this, AliFMDHitDigitizer::kSDigits);
+  digitizer.Init();
+  digitizer.Exec("");
 }
 
   
@@ -1112,20 +1089,14 @@ AliFMD::CreateDigitizer(AliRunDigitizer* manager) const
   digitizer = new AliFMDSSDigitizer(manager);
 #else 
   /* This is what we actually do, and will work */
+#if 0
   AliInfo("SDigit->Digit conversion not really supported, "
          "doing Hit->Digit conversion instead");
+#endif
   digitizer = new AliFMDDigitizer(manager);
 #endif
   return digitizer;
 }
-//____________________________________________________________________
-AliDigitizer* 
-AliFMD::CreateSDigitizer(AliRunDigitizer* manager) const
-{
-  // Create a digitizer object 
-  AliFMDSDigitizer* digitizer = new AliFMDSDigitizer(manager);
-  return digitizer;
-}
 
 //====================================================================
 //
index 87fff78..d127efa 100644 (file)
@@ -486,10 +486,6 @@ public:
       @param manager Digitization manager
       @return a newly allocated AliFMDDigitizer */
   virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
-  /** Create a digitizer object
-      @param manager Digitization manager
-      @return a newly allocated AliFMDSDigitizer */
-  virtual AliDigitizer* CreateSDigitizer(AliRunDigitizer* manager) const;
   /** Create AliFMDDigit's from AliFMDHit's.  This is done by creating
       an AliFMDDigitizer object, and executing it.  */
   virtual        void   Hits2Digits();
index 8e40c79..d15cc8b 100644 (file)
@@ -224,9 +224,11 @@ AliFMDAlignFaker::Exec(Option_t*)
       alignName     = Form("FMD/FMD%c_%c", currentDet, currentHalf);
     }
     if (IS_NODE_SENSOR(name)) {
-      Char_t ring  = name[1];
-      Int_t  copy  = node->GetNumber();
-      alignName    = Form("FMD/FMD%c_%c/FMD%c_%02d", 
+      Char_t ring      = name[1];
+      Int_t  lvl       = next.GetLevel();
+      TGeoNode* parent = next.GetNode(lvl-1);
+      Int_t     copy   = parent->GetNumber();
+      alignName        = Form("FMD/FMD%c_%c/FMD%c_%02d", 
                          currentDet, currentHalf, ring, copy);
     }
     if (alignName.IsNull()) continue;
index bda9c77..06fec44 100644 (file)
 #include <AliLoader.h>         // ALILOADER_H
 #include <AliRun.h>            // ALILOADER_H
 #include <AliRunLoader.h>      // ALIRUNLOADER_H
+#include <TRandom.h>
     
 //====================================================================
 ClassImp(AliFMDBaseDigitizer)
@@ -223,7 +224,8 @@ ClassImp(AliFMDBaseDigitizer)
 
 //____________________________________________________________________
 AliFMDBaseDigitizer::AliFMDBaseDigitizer()  
-  : fRunLoader(0),
+  : fFMD(0),
+    fRunLoader(0),
     fEdep(AliFMDMap::kMaxDetectors, 
          AliFMDMap::kMaxRings, 
          AliFMDMap::kMaxSectors, 
@@ -237,6 +239,7 @@ AliFMDBaseDigitizer::AliFMDBaseDigitizer()
 //____________________________________________________________________
 AliFMDBaseDigitizer::AliFMDBaseDigitizer(AliRunDigitizer* manager) 
   : AliDigitizer(manager, "AliFMDBaseDigitizer", "FMD Digitizer base class"), 
+    fFMD(0),
     fRunLoader(0),
     fEdep(AliFMDMap::kMaxDetectors, 
          AliFMDMap::kMaxRings, 
@@ -253,6 +256,7 @@ AliFMDBaseDigitizer::AliFMDBaseDigitizer(AliRunDigitizer* manager)
 AliFMDBaseDigitizer::AliFMDBaseDigitizer(const Char_t* name, 
                                         const Char_t* title) 
   : AliDigitizer(name, title),
+    fFMD(0),
     fRunLoader(0),
     fEdep(AliFMDMap::kMaxDetectors, 
          AliFMDMap::kMaxRings, 
@@ -275,217 +279,67 @@ AliFMDBaseDigitizer::~AliFMDBaseDigitizer()
 Bool_t 
 AliFMDBaseDigitizer::Init()
 {
-  // Initialization
+  // Initialization.   Get a pointer to the parameter manager, and
+  // initialize it.  
   AliFMDParameters::Instance()->Init();
-  if (AliLog::GetDebugLevel("FMD","") >= 10) 
-    AliFMDParameters::Instance()->Print("ALL");
-  return kTRUE;
-}
-
-//____________________________________________________________________
-void
-AliFMDBaseDigitizer::Exec(Option_t* /*option*/)
-{
-  AliFMDDebug(1, ("Executing digitizer"));
-  AliFMD*    fmd = 0;
-  AliLoader* outFMD = 0;
-  if (!SetupLoaders(fmd, outFMD)) return;
-  if (!LoopOverInput(fmd)) return;
-
-  // Digitize the event 
-  DigitizeHits(fmd);
-  
-  // Make the output 
-  AliFMDDebug(5, ("Calling output tree"));
-  OutputTree(outFMD, fmd);  
-}
-
-  
-//____________________________________________________________________
-Bool_t 
-AliFMDBaseDigitizer::SetupLoaders(AliFMD*& fmd, AliLoader*& outFMD)
-{
-  // Set-up input/output loaders. 
-  AliFMDDebug(5, ("Setting up run-loaders"));
-
-  // Get the output manager and the FMD output manager 
-  TString       outFolder(fManager->GetOutputFolderName());
-  AliRunLoader* out = AliRunLoader::GetRunLoader(outFolder.Data());
-  outFMD = out->GetLoader("FMDLoader");
-  if (!outFMD) { 
-    AliError("Cannot get the FMDLoader output folder");
-    return kFALSE;
-  }
-  
-  // Get the input loader 
-  TString inFolder(fManager->GetInputFolderName(0));
-  fRunLoader = AliRunLoader::GetRunLoader(inFolder.Data());
-  if (!fRunLoader) {
-    AliError("Can not find Run Loader for input stream 0");
-    return kFALSE;
-  }
-
-  // Get the AliRun object 
-  if (!fRunLoader->GetAliRun()) { 
-    AliWarning("Loading gAlice");
-    fRunLoader->LoadgAlice();
-  }
-  
-  // Get the AliRun object 
-  AliRun* run = fRunLoader->GetAliRun();
-  if (!run) { 
-    AliError("Can not get Run from Run Loader");
-    return kFALSE;
-  }
-
-  // Get the AliFMD object 
-  fmd = static_cast<AliFMD*>(run->GetDetector("FMD"));
-  if (!fmd) {
-    AliError("Can not get FMD from gAlice");
-    return kFALSE;
-  }
-  return kTRUE;
-}
-
-//____________________________________________________________________
-Bool_t
-AliFMDBaseDigitizer::LoopOverInput(AliFMD* fmd)
-{
-  if (!fManager) { 
-    AliError("No digitisation manager defined");
-    return kFALSE;
-  }
-    
-  Int_t nFiles= fManager->GetNinputs();
-  AliFMDDebug(1, (" Digitizing event number %d, got %d inputs",
-                 fManager->GetOutputEventNr(), nFiles));
-  for (Int_t inputFile = 0; inputFile < nFiles; inputFile++) {
-    AliFMDDebug(5, ("Now reading input # %d", inputFile));
-    // Get the current loader 
-    fRunLoader = 
-      AliRunLoader::GetRunLoader(fManager->GetInputFolderName(inputFile));
-    if (!fRunLoader) { 
-      Error("Exec", Form("no run loader for input file # %d", inputFile));
-      return kFALSE;
-    }
-    // Cache contriutions 
-    AliFMDDebug(5, ("Now summing the contributions from input # %d",inputFile));
-    SumContributions(fmd);
-  }  
+  if (AliLog::GetDebugLevel("FMD","") >= 15) 
+    AliFMDParameters::Instance()->Print("");
   return kTRUE;
 }
 
-
 //____________________________________________________________________
 UShort_t
-AliFMDBaseDigitizer::MakePedestal(UShort_t, 
-                                 Char_t, 
-                                 UShort_t, 
-                                 UShort_t) const 
+AliFMDBaseDigitizer::MakePedestal(UShort_t detector, 
+                                 Char_t   ring, 
+                                 UShort_t sector, 
+                                 UShort_t strip) const 
 { 
-  // Make a pedestal
-  return 0; 
+  // Make a pedestal.  The pedestal value is drawn from a Gaussian
+  // distribution.  The mean of the distribution is the measured
+  // pedestal, and the width is the measured noise. 
+  AliFMDParameters* param =AliFMDParameters::Instance();
+  Float_t           mean  =param->GetPedestal(detector,ring,sector,strip);
+  Float_t           width =param->GetPedestalWidth(detector,ring,sector,strip);
+  return UShort_t(TMath::Max(gRandom->Gaus(mean, width), 0.));
 }
 
 //____________________________________________________________________
 void
-AliFMDBaseDigitizer::SumContributions(AliFMD* fmd) 
+AliFMDBaseDigitizer::AddContribution(UShort_t detector, 
+                                    Char_t   ring, 
+                                    UShort_t sector, 
+                                    UShort_t strip, 
+                                    Float_t  edep)
 {
-  // Sum energy deposited contributions from each hit in a cache
-  // (fEdep).  
-  if (!fRunLoader) 
-    Fatal("SumContributions", "no run loader");
-  
-  // Clear array of deposited energies 
-  fEdep.Reset();
-  
-  // Get the FMD loader 
-  AliLoader* inFMD = fRunLoader->GetLoader("FMDLoader");
-  // And load the hits 
-  AliFMDDebug(5, ("Will read hits"));
-  inFMD->LoadHits("READ");
-  
-  // Get the tree of hits 
-  AliFMDDebug(5, ("Will get hit tree"));
-  TTree* hitsTree = inFMD->TreeH();
-  if (!hitsTree)  {
-    // Try again 
-    AliFMDDebug(5, ("First attempt failed, try again"));
-    inFMD->LoadHits("READ");
-    hitsTree = inFMD->TreeH();
+  // Add edep contribution from (detector,ring,sector,strip) to cache
+  AliFMDParameters* param = AliFMDParameters::Instance();
+
+  // Check if strip is `dead' 
+  if (param->IsDead(detector, ring, sector, strip)) { 
+    AliFMDDebug(5, ("FMD%d%c[%2d,%3d] is marked as dead", 
+                   detector, ring, sector, strip));
+    return;
   }
+  // Check if strip is out-side read-out range 
+  // if (strip < minstrip || strip > maxstrip) {
+  //   AliFMDDebug(5, ("FMD%d%c[%2d,%3d] is outside range [%3d,%3d]", 
+  //               detector,ring,sector,strip,minstrip,maxstrip));
+  //   continue;
+  // }
   
-  // Get the FMD branch 
-  AliFMDDebug(5, ("Will now get the branch"));
-  TBranch* hitsBranch = hitsTree->GetBranch("FMD");
-  if (hitsBranch) fmd->SetHitsAddressBranch(hitsBranch);
-  else            AliFatal("Branch FMD hit not found");
-  
-  // Get a list of hits from the FMD manager 
-  AliFMDDebug(5, ("Get array of FMD hits"));
-  TClonesArray *fmdHits = fmd->Hits();
-  
-  // Get number of entries in the tree 
-  AliFMDDebug(5, ("Get # of tracks"));
-  Int_t ntracks  = Int_t(hitsTree->GetEntries());
-  AliFMDDebug(5, ("We got %d tracks", ntracks));
-  
-  AliFMDParameters* param = AliFMDParameters::Instance();
-  Int_t read = 0;
-  // Loop over the tracks in the 
-  for (Int_t track = 0; track < ntracks; track++)  {
-    // Read in entry number `track' 
-    read += hitsBranch->GetEntry(track);
-    
-    // Get the number of hits 
-    Int_t nhits = fmdHits->GetEntries ();
-    for (Int_t hit = 0; hit < nhits; hit++) {
-      // Get the hit number `hit'
-      AliFMDHit* fmdHit = 
-       static_cast<AliFMDHit*>(fmdHits->UncheckedAt(hit));
-      
-      // Extract parameters 
-      UShort_t detector = fmdHit->Detector();
-      Char_t   ring     = fmdHit->Ring();
-      UShort_t sector   = fmdHit->Sector();
-      UShort_t strip    = fmdHit->Strip();
-      Float_t  edep     = fmdHit->Edep();
-      AliFMDDebug(10, ("Hit in FMD%d%c[%2d,%3d]=%f",
-                     detector, ring, sector, strip, edep));
-      // Check if strip is `dead' 
-      if (param->IsDead(detector, ring, sector, strip)) { 
-       AliFMDDebug(1, ("FMD%d%c[%2d,%3d] is marked as dead", 
-                        detector, ring, sector, strip));
-       continue;
-      }
-      // UShort_t minstrip = param->GetMinStrip(detector, ring, sector, strip);
-      // UShort_t maxstrip = param->GetMaxStrip(detector, ring, sector, strip);
-      // Check if strip is out-side read-out range 
-      // if (strip < minstrip || strip > maxstrip) {
-      //   AliFMDDebug(5, ("FMD%d%c[%2d,%3d] is outside range [%3d,%3d]", 
-      //                   detector,ring,sector,strip,minstrip,maxstrip));
-      //   continue;
-      // }
-       
-      // Give warning in case of double hit 
-      if (fEdep(detector, ring, sector, strip).fEdep != 0)
-       AliFMDDebug(5, ("Double hit in %d%c(%d,%d)", 
-                        detector, ring, sector, strip));
+  // Give warning in case of double sdigit 
+  if (fEdep(detector, ring, sector, strip).fEdep != 0)
+    AliFMDDebug(5, ("Double digit in %d%c(%d,%d)", 
+                   detector, ring, sector, strip));
       
-      // Sum energy deposition
-      fEdep(detector, ring, sector, strip).fEdep  += edep;
-      fEdep(detector, ring, sector, strip).fN     += 1;
-      // Add this to the energy deposited for this strip
-    }  // hit loop
-  } // track loop
-  AliFMDDebug(5, ("Size of cache: %d bytes, read %d bytes", 
-                  sizeof(fEdep), read));
-  inFMD->UnloadHits();
+  // Sum energy deposition
+  fEdep(detector, ring, sector, strip).fEdep  += edep;
+  fEdep(detector, ring, sector, strip).fN     += 1;
 }
 
 //____________________________________________________________________
 void
-AliFMDBaseDigitizer::DigitizeHits(AliFMD* fmd) const
+AliFMDBaseDigitizer::DigitizeHits() const
 {
   // For the stored energy contributions in the cache (fEdep), convert
   // the energy signal to ADC counts, and store the created digit in
@@ -496,13 +350,13 @@ AliFMDBaseDigitizer::DigitizeHits(AliFMD* fmd) const
   
   TArrayI counts(4);
   for (UShort_t detector=1; detector <= 3; detector++) {
-    AliFMDDebug(5, ("Processing hits in FMD%d", detector));
+    AliFMDDebug(10, ("Processing hits in FMD%d", detector));
     // Get pointer to subdetector 
     AliFMDDetector* det = geometry->GetDetector(detector);
     if (!det) continue;
     for (UShort_t ringi = 0; ringi <= 1; ringi++) {
       Char_t ring = ringi == 0 ? 'I' : 'O';
-      AliFMDDebug(5, (" Processing hits in FMD%d%c", detector,ring));
+      AliFMDDebug(10, (" Processing hits in FMD%d%c", detector,ring));
       // Get pointer to Ring
       AliFMDRing* r = det->GetRing(ring);
       if (!r) continue;
@@ -511,7 +365,7 @@ AliFMDBaseDigitizer::DigitizeHits(AliFMD* fmd) const
       UShort_t nSectors = UShort_t(360. / r->GetTheta());
       // Loop over the number of sectors 
       for (UShort_t sector = 0; sector < nSectors; sector++) {
-       AliFMDDebug(5, ("  Processing hits in FMD%d%c[%2d]", 
+       AliFMDDebug(10, ("  Processing hits in FMD%d%c[%2d]", 
                        detector,ring,sector));
        // Get number of strips 
        UShort_t nStrips = r->GetNStrips();
@@ -545,10 +399,10 @@ AliFMDBaseDigitizer::DigitizeHits(AliFMD* fmd) const
          // here. 
          // 
          //   if (edep<=0) continue;
-         AddDigit(fmd, detector, ring, sector, strip, edep, 
+         AddDigit(detector, ring, sector, strip, edep, 
                   UShort_t(counts[0]), Short_t(counts[1]), 
                   Short_t(counts[2]), Short_t(counts[3]));
-         AliFMDDebug(10, ("   Adding digit in FMD%d%c[%2d,%3d]=%d", 
+         AliFMDDebug(15, ("   Adding digit in FMD%d%c[%2d,%3d]=%d", 
                          detector,ring,sector,strip,counts[0]));
 #if 0
          // This checks if the digit created will give the `right'
@@ -620,14 +474,20 @@ AliFMDBaseDigitizer::ConvertToCount(Float_t   edep,
     maxAdc = 1023;
   }
   UShort_t rate           = param->GetSampleRate(detector,ring,sector,strip);
-  if (rate < 1 || rate > 4) rate = 1;
-  
+  AliFMDDebug(15, ("Sample rate for FMD%d%c[%2d,%3d] = %d", 
+                 detector, ring, sector, strip, rate));
+  if (rate < 1 || rate > 4) {
+    AliWarning(Form("Invalid sample rate for for FMD%d%c[%2d,%3d] = %d", 
+                   detector, ring, sector, strip, rate));
+    rate = 1;
+  }
+
   // In case we don't oversample, just return the end value. 
   if (rate == 1) {
     Float_t    a = edep * convF + ped;
     if (a < 0) a = 0;
     counts[0]    = UShort_t(TMath::Min(a, Float_t(maxAdc)));
-    AliFMDDebug(10, ("FMD%d%c[%2d,%3d]: converting ELoss %f to "
+    AliFMDDebug(15, ("FMD%d%c[%2d,%3d]: converting ELoss %f to "
                     "ADC %4d (%f,%d)",
                     detector,ring,sector,strip,edep,counts[0],convF,ped));
     return;
@@ -644,7 +504,57 @@ AliFMDBaseDigitizer::ConvertToCount(Float_t   edep,
   }
 }
 
+//____________________________________________________________________
+void
+AliFMDBaseDigitizer::AddDigit(UShort_t  detector, 
+                             Char_t    ring,
+                             UShort_t  sector, 
+                             UShort_t  strip, 
+                             Float_t   /* edep */, 
+                             UShort_t  count1, 
+                             Short_t   count2, 
+                             Short_t   count3,
+                             Short_t   count4) const
+{
+  // Add a digit or summable digit
+  
+  fFMD->AddDigitByFields(detector, ring, sector, strip, 
+                        count1, count2, count3, count4);
+}
 
+//____________________________________________________________________
+TTree*
+AliFMDBaseDigitizer::MakeOutputTree(AliLoader* loader)
+{
+  // Create output tree using loader.   If the passed loader differs
+  // from the currently set loader in the FMD object, reset the FMD
+  // loader to be the passed loader.   This is for the cases wher the
+  // output is different from the output. 
+  AliFMDDebug(5, ("Making digits tree"));
+  loader->LoadDigits("UPDATE"); // "RECREATE");
+  TTree* out = loader->TreeD();
+  if (!out) loader->MakeTree("D");
+  out = loader->TreeD(); 
+  if (out) { 
+    out->Reset();
+    if (loader != fFMD->GetLoader()) 
+      fFMD->SetLoader(loader);
+    fFMD->MakeBranch("D");
+  }
+  return out;
+}
+
+//____________________________________________________________________
+void
+AliFMDBaseDigitizer::StoreDigits(AliLoader* loader)
+{
+  // Write the digits to disk 
+  AliFMDDebug(5, ("Storing %d digits",   fFMD->Digits()->GetEntries()));
+  loader->WriteDigits("OVERWRITE");
+  loader->UnloadDigits();
+  // Reset the digits in the AliFMD object 
+  fFMD->ResetDigits();
+}
 
 //____________________________________________________________________
 //
index 695cdf5..473fbe7 100644 (file)
@@ -170,8 +170,6 @@ public:
    
   /** Initialize */
   virtual Bool_t Init();
-  /** Run this task */
-  virtual void Exec(Option_t* option="");
   
   /** The response shape of the VA1 shaping circuit is approximently
       given by 
@@ -187,27 +185,11 @@ public:
   /** @return Get the shaping time */
   Float_t  GetShapingTime()      const { return fShapingTime; }
 protected:
-  /** Set-up loaders, etc. 
-      @param fmd  On return, contains pointer to loaded AliFMD object.
-      @param outFMD On return, contains pointer to loaded loader. 
-      @return kTRUE on success, kFALSE otherwise */
-  virtual Bool_t  SetupLoaders(AliFMD*& fmd, AliLoader*& outFMD);
-  /** Set-up loaders, etc. 
-      @param fmd Pointer to loaded AliFMD object 
-      @return kFALSE on failures. */
-  virtual Bool_t  LoopOverInput(AliFMD* fmd);
-  /** Output to disk 
-      @param outFMD Loader
-      @param fmd    AliFMD object */
-  virtual void OutputTree(AliLoader* outFMD, AliFMD* fmd) = 0;
-  /** Sum energy deposited contributions from each hit in a cache
-      @param fmd Pointer to detector */
-  virtual void     SumContributions(AliFMD* fmd);
   /** For the stored energy contributions in the cache, convert the
       energy signal to ADC counts, and store the created digit in  
       the digits array
       @param fmd Pointer to detector */
-  virtual void     DigitizeHits(AliFMD* fmd) const;
+  virtual void     DigitizeHits() const;
   /** Convert the total energy deposited to a (set of) ADC count(s).
       See also the class description for more details. 
       @param edep     Total energy deposited in detector
@@ -236,18 +218,32 @@ protected:
                                UShort_t  strip) const;
   /** Add noise to each sample */
   virtual void     AddNoise(TArrayI&) const {}
+
+  /** Add edep contribution from (detector,ring,sector,strip) to cache */ 
+  virtual void AddContribution(UShort_t detector, 
+                              Char_t   ring, 
+                              UShort_t sector, 
+                              UShort_t strip, 
+                              Float_t  edep);
   /** Add a digit to output */
-  virtual void     AddDigit(AliFMD*  /* fmd      */,
-                           UShort_t /* detector */, 
-                           Char_t   /* ring     */,
-                           UShort_t /* sector   */, 
-                           UShort_t /* strip    */, 
-                           Float_t  /* edep     */, 
-                           UShort_t /* count1   */, 
-                           Short_t  /* count2   */, 
-                           Short_t  /* count3   */,
-                           Short_t  /* count4   */) const {}
+  virtual void     AddDigit(UShort_t detector, 
+                           Char_t   ring,
+                           UShort_t sector, 
+                           UShort_t strip, 
+                           Float_t  edep, 
+                           UShort_t count1, 
+                           Short_t  count2, 
+                           Short_t  count3,
+                           Short_t  count4) const;
+  /** Make the output tree using the passed loader 
+      @param loader 
+      @return The generated tree. */
+  virtual TTree* MakeOutputTree(AliLoader* loader);
+  /** Store the data using the loader 
+      @param loader The loader */
+  virtual void StoreDigits(AliLoader* loader);
 
+  AliFMD*       fFMD;
   AliRunLoader* fRunLoader;       //! Run loader
   AliFMDEdepMap fEdep;             // Cache of Energy from hits 
   Float_t       fShapingTime;      // Shaping profile parameter
@@ -256,16 +252,21 @@ protected:
       @param o object to copy from  */
   AliFMDBaseDigitizer(const AliFMDBaseDigitizer& o) 
     : AliDigitizer(o),
+      fFMD(o.fFMD),
       fRunLoader(0),
-      fEdep(AliFMDMap::kMaxDetectors, 
-           AliFMDMap::kMaxRings, 
-           AliFMDMap::kMaxSectors, 
-           AliFMDMap::kMaxStrips),
-      fShapingTime(0)
+      fEdep(o.fEdep),
+      fShapingTime(o.fShapingTime)
   {}
   /** Assignment operator
       @return Reference to this object */
-  AliFMDBaseDigitizer& operator=(const AliFMDBaseDigitizer&) { return *this; }
+  AliFMDBaseDigitizer& operator=(const AliFMDBaseDigitizer& o) 
+  { 
+    AliDigitizer::operator=(o);
+    fRunLoader   = o.fRunLoader;
+    fEdep        = o.fEdep;
+    fShapingTime = o.fShapingTime;
+    return *this; 
+  }
   ClassDef(AliFMDBaseDigitizer,2) // Base class for FMD digitizers
 };
 
index d5832a0..c0b4279 100644 (file)
@@ -85,7 +85,7 @@ AliFMDCalibSampleRate::Rate(UShort_t det, Char_t ring,
   UInt_t   nSec  = (ring == 'I' ? 10 : 20);
   UInt_t   board = sec / nSec;
   UShort_t ret   = fRates(det, ring, board, 0);
-  AliFMDDebug(10, ("Getting sample rate for FMD%d%c[%2d,0] (board %d): %d", 
+  AliFMDDebug(15, ("Getting sample rate for FMD%d%c[%2d,0] (board %d): %d", 
                   det, ring, sec, board, ret));
   return ret;
 }
index 1d0dd11..2be3631 100644 (file)
@@ -22,7 +22,7 @@
 //////////////////////////////////////////////////////////////////////////////
 //
 //  This class contains the procedures simulation ADC  signal for the
-//  Forward Multiplicity detector  : Hits->Digits
+//  Forward Multiplicity detector  : SDigits->Digits
 // 
 //  Digits consists of
 //   - Detector #
 //   - Strip #
 //   - ADC count in this channel                                  
 //
+//  Digits consists of
+//   - Detector #
+//   - Ring ID                                             
+//   - Sector #     
+//   - Strip #
+//   - Total energy deposited in the strip
+//   - ADC count in this channel                                  
+//
 // As the Digits and SDigits have so much in common, the classes
 // AliFMDDigitizer and AliFMDSDigitizer are implemented via a base
 // class AliFMDBaseDigitizer.
 //      +-----------------+     +------------------+
 //      | AliFMDDigitizer |    | AliFMDSDigitizer |
 //      +-----------------+    +------------------+
+//                |
+//     +-------------------+
+//     | AliFMDSSDigitizer |
+//     +-------------------+
 //
 // These classes has several paramters: 
 //
@@ -72,7 +84,6 @@
 //         we'd like have the option, and so it should be reflected in
 //         the code.
 //
-// These parameters are fetched from OCDB via the mananger AliFMDParameters.
 //
 // The shaping function of the VA1_ALICE is generally given by 
 //
 //
 
 #include <TTree.h>             // ROOT_TTree
-#include <TRandom.h>           // ROOT_TRandom
-#include "AliFMDDebug.h"        // Better debug macros
-#include "AliFMDDigitizer.h"   // ALIFMDDIGITIZER_H
+#include <TFile.h>
+#include "AliFMDDebug.h"       // Better debug macros
+#include "AliFMDDigitizer.h"   // ALIFMDSSDIGITIZER_H
 #include "AliFMD.h"            // ALIFMD_H
+#include "AliFMDSDigit.h"      // ALIFMDDIGIT_H
 #include "AliFMDDigit.h"       // ALIFMDDIGIT_H
 #include "AliFMDParameters.h"   // ALIFMDPARAMETERS_H
 #include <AliRunDigitizer.h>   // ALIRUNDIGITIZER_H
     
 //====================================================================
 ClassImp(AliFMDDigitizer)
+#if 0
+;
+#endif
 
 //____________________________________________________________________
-void 
-AliFMDDigitizer::OutputTree(AliLoader* outFMD, AliFMD* fmd)
+Bool_t
+AliFMDDigitizer::Init()
 {
-  // Load digits from the tree 
-  outFMD->LoadDigits("update");
-
-  // Get the tree of digits 
-  TTree* digitTree = outFMD->TreeD();
-  if (!digitTree) {
-    outFMD->MakeTree("D");
-    digitTree = outFMD->TreeD();
-  }
-  digitTree->Reset();
+  // Initialisation
+  if (!AliFMDBaseDigitizer::Init()) return kFALSE;
   
-  // Get the digits 
-  TClonesArray* digits =  fmd->Digits();
-  if (!digits) { 
-    AliError("Failed to get digits");
-    return;
+#if 0
+  // Get the AliRun object 
+  AliRun* run = fRunLoader->GetAliRun();
+  if (!run) { 
+    AliWarning("Loading gAlice");
+    fRunLoader->LoadgAlice();
+    if (!run) { 
+      AliError("Can not get Run from Run Loader");
+      return kFALSE;
+    }
   }
-  AliFMDDebug(1, ("Got a total of %5d digits", digits->GetEntries()));
-
-  // Make a branch in the tree 
-  fmd->MakeBranchInTree(digitTree, fmd->GetName(), &(digits), 4000, 0);
-  // TBranch* digitBranch = digitTree->GetBranch(fmd->GetName());
-  // Fill the tree 
-  Int_t write = 0;
-  write = digitTree->Fill();
-  AliFMDDebug(1, ("Wrote %d bytes to digit tree", write));
   
-  // Write the digits to disk 
-  outFMD->WriteDigits("OVERWRITE");
-  outFMD->UnloadHits();
-  outFMD->UnloadDigits();
-
-  // Reset the digits in the AliFMD object 
-  fmd->ResetDigits();
+  // Get the AliFMD object 
+  fFMD = static_cast<AliFMD*>(run->GetDetector("FMD"));
+  if (!fFMD) {
+    AliError("Can not get FMD from gAlice");
+    return kFALSE;
+  }  
+#endif
+  return kTRUE;
 }
 
-//____________________________________________________________________
-UShort_t
-AliFMDDigitizer::MakePedestal(UShort_t  detector, 
-                             Char_t    ring, 
-                             UShort_t  sector, 
-                             UShort_t  strip) const 
-{
-  // Make a pedestal 
-  AliFMDParameters* param =AliFMDParameters::Instance();
-  Float_t           mean  =param->GetPedestal(detector,ring,sector,strip);
-  Float_t           width =param->GetPedestalWidth(detector,ring,sector,strip);
-  return UShort_t(TMath::Max(gRandom->Gaus(mean, width), 0.));
-}
 
 //____________________________________________________________________
 void
-AliFMDDigitizer::AddDigit(AliFMD*  fmd,
-                         UShort_t detector, 
-                         Char_t   ring,
-                         UShort_t sector, 
-                         UShort_t strip, 
-                         Float_t  /* edep */, 
-                         UShort_t count1, 
-                         Short_t  count2, 
-                         Short_t  count3,
-                         Short_t  count4) const
+AliFMDDigitizer::Exec(Option_t*)
 {
-  // Add a digit
-  fmd->AddDigitByFields(detector, ring, sector, strip, 
-                       count1, count2, count3, count4);
+  if (!fManager) { 
+    AliError("No digitisation manager defined");
+    return;
+  }
+
+  // Clear array of deposited energies 
+  fEdep.Reset();
+
+  AliRunLoader* runLoader = 0;
+  if (!gAlice) { 
+    TString folderName(fManager->GetInputFolderName(0));
+    runLoader = AliRunLoader::GetRunLoader(folderName.Data());
+    if (!runLoader) { 
+      AliError(Form("Failed at getting run loader from %s",
+                   folderName.Data()));
+      return;
+    }
+    runLoader->LoadgAlice();
+    runLoader->GetAliRun();
+  }
+  if (!gAlice) { 
+    AliError("Can not get Run from Run Loader");
+    return;
+  }
+  
+  // Get the AliFMD object 
+  fFMD = static_cast<AliFMD*>(gAlice->GetDetector("FMD"));
+  if (!fFMD) {
+    AliError("Can not get FMD from gAlice");
+    return;
+  }  
+
+
+  // Loop over input files
+  Int_t nFiles= fManager->GetNinputs();
+  AliFMDDebug(1, (" Digitizing event number %d, got %d inputs",
+                 fManager->GetOutputEventNr(), nFiles));
+  for (Int_t inputFile = 0; inputFile < nFiles; inputFile++) {
+    AliFMDDebug(5, ("Now reading input # %d", inputFile));
+    // Get the current loader 
+    AliRunLoader* currentLoader = 
+      AliRunLoader::GetRunLoader(fManager->GetInputFolderName(inputFile));
+    if (!currentLoader) { 
+      Error("Exec", Form("no run loader for input file # %d", inputFile));
+      continue;
+    }
+
+    // Cache contriutions 
+    AliFMDDebug(5, ("Now summing the contributions from input # %d",inputFile));
+
+    // Get the FMD loader 
+    AliLoader* inFMD = currentLoader->GetLoader("FMDLoader");
+    // And load the summable digits
+    inFMD->LoadSDigits("READ");
+  
+    // Get the tree of summable digits
+    TTree* sdigitsTree = inFMD->TreeS();
+    if (!sdigitsTree)  {
+      AliError("No sdigit tree from manager");
+      continue;
+    }
+    if (AliLog::GetDebugLevel("FMD","") >= 10) {
+      TFile* file = sdigitsTree->GetCurrentFile();
+      if (!file) {
+       AliWarning("Input tree has no file!");
+      }
+      else { 
+       AliFMDDebug(10, ("Input tree file %s content:", file->GetName()));
+       file->ls();
+      }
+      // AliFMDDebug(5, ("Input tree %s file structure:", 
+      //                 sdigitsTree->GetName()));
+      // sdigitsTree->Print();
+    }
+
+    // Get the FMD branch 
+    TBranch* sdigitsBranch = sdigitsTree->GetBranch("FMD");
+    if (!sdigitsBranch) {
+      AliError("Failed to get sdigit branch");
+      return;
+    }
+
+    // Set the branch addresses 
+    fFMD->SetTreeAddress();
+
+    // Sum contributions from the sdigits
+    SumContributions(sdigitsBranch);
+
+    // Unload the sdigits
+    inFMD->UnloadSDigits();
+  }  
+
+  TString       outFolder(fManager->GetOutputFolderName());
+  AliRunLoader* out    = AliRunLoader::GetRunLoader(outFolder.Data());
+  AliLoader*    outFMD = out->GetLoader("FMDLoader");
+  if (!outFMD) { 
+    AliError("Cannot get the FMDLoader output folder");
+    return;
+  }
+  TTree* outTree = MakeOutputTree(outFMD);
+  if (!outTree) { 
+    AliError("Failed to get output tree");
+    return;
+  }
+  // Set the branch address 
+  fFMD->SetTreeAddress();
+  
+  // And digitize the cached data 
+  DigitizeHits();
+  
+  // Fill the tree
+  Int_t write = outTree->Fill();
+  AliFMDDebug(1, ("Wrote %d bytes to digit tree", write));
+  
+  // Store the digits
+  StoreDigits(outFMD);
 }
 
 //____________________________________________________________________
 void
-AliFMDDigitizer::CheckDigit(AliFMDDigit*    digit,
-                           UShort_t        nhits,
-                           const TArrayI&  counts) 
+AliFMDDigitizer::SumContributions(TBranch* sdigitsBranch) 
 {
-  // Check that digit is consistent
-  AliFMDParameters* param = AliFMDParameters::Instance();
-  UShort_t          det   = digit->Detector();
-  Char_t            ring  = digit->Ring();
-  UShort_t          sec   = digit->Sector();
-  UShort_t          str   = digit->Strip();
-  Float_t           mean  = param->GetPedestal(det,ring,sec,str);
-  Float_t           width = param->GetPedestalWidth(det,ring,sec,str);
-  UShort_t          range = param->GetVA1MipRange();
-  UShort_t          size  = param->GetAltroChannelSize();
-  Int_t             integral = counts[0];
-  if (counts[1] >= 0) integral += counts[1];
-  if (counts[2] >= 0) integral += counts[2];
-  if (counts[3] >= 0) integral += counts[3];
-  integral -= Int_t(mean + 2 * width);
-  if (integral < 0) integral = 0;
+  // Sum energy deposited contributions from each sdigits in a cache
+  // (fEdep).  
+  AliFMDDebug(1, ("Runnin our version of SumContributions"));
+
+  // Get a list of hits from the FMD manager 
+  TClonesArray *fmdSDigits = fFMD->SDigits();
+  
+  // Get number of entries in the tree 
+  Int_t nevents  = Int_t(sdigitsBranch->GetEntries());
   
-  Float_t convF = Float_t(range) / size;
-  Float_t mips  = integral * convF;
-  if (mips > Float_t(nhits) + .5 || mips < Float_t(nhits) - .5) 
-    Warning("CheckDigit", "Digit -> %4.2f MIPS != %d +/- .5 hits", 
-           mips, nhits);
+  Int_t read = 0;
+  // Loop over the events in the 
+  for (Int_t event = 0; event < nevents; event++)  {
+    // Read in entry number `event' 
+    read += sdigitsBranch->GetEntry(event);
+    
+    // Get the number of sdigits 
+    Int_t nsdigits = fmdSDigits->GetEntries ();
+    AliFMDDebug(1, ("Got %5d SDigits", nsdigits));
+    for (Int_t sdigit = 0; sdigit < nsdigits; sdigit++) {
+      // Get the sdigit number `sdigit'
+      AliFMDSDigit* fmdSDigit = 
+       static_cast<AliFMDSDigit*>(fmdSDigits->UncheckedAt(sdigit));
+      
+      // Extract parameters 
+      AddContribution(fmdSDigit->Detector(),
+                     fmdSDigit->Ring(),
+                     fmdSDigit->Sector(),
+                     fmdSDigit->Strip(),
+                     fmdSDigit->Edep());
+    }  // sdigit loop
+  } // event loop
+
+
+  AliFMDDebug(3, ("Size of cache: %d bytes, read %d bytes", 
+                  sizeof(fEdep), read));
 }
 
 //____________________________________________________________________
index c2e8f64..1d9530d 100644 (file)
@@ -5,7 +5,7 @@
  *
  * See cxx source for full Copyright notice                               
  */
-// Classses to make Hits into digits and summable digits. 
+// Classses to make SDigits into Digits 
 //    
 //    Digits consists of
 //    - Detector #
@@ -58,49 +58,18 @@ public:
     : AliFMDBaseDigitizer(manager) {}
   /** DTOR */
   virtual ~AliFMDDigitizer() {}
+  /** Initialise */
+  virtual Bool_t Init();
+  /** Execute this digitizer.  
+      This member function will be called once per event by the passed
+      AliRunDigitizer manager object. 
+      @param options Not used */
+  virtual void Exec(Option_t* option="");
 protected:
-  /** Output to disk 
-      @param outFMD Loader
-      @param fmd    AliFMD object */
-  virtual void OutputTree(AliLoader* outFMD, AliFMD* fmd);
-  /** Add a digit to output.
-      @param fmd      Pointer to detector object
-      @param detector Detector #
-      @param ring     Ring ID
-      @param sector   Sector number
-      @param strip    Strip number
-      @param edep     Energy deposited (not used)
-      @param count1   ADC count 1
-      @param count2   ADC count 2 (-1 if not used)
-      @param count3   ADC count 3 (-1 if not used) 
-      @param count4   ADC count 4 (-1 if not used) */
-  virtual void     AddDigit(AliFMD*  fmd,
-                           UShort_t detector, 
-                           Char_t   ring,
-                           UShort_t sector, 
-                           UShort_t strip, 
-                           Float_t  edep, 
-                           UShort_t count1, 
-                           Short_t  count2, 
-                           Short_t  count3,
-                           Short_t  count4) const;
-  /** MAke a pedestal
-      @param detector Detector #
-      @param ring     Ring ID
-      @param sector   Sector number
-      @param strip    Strip number
-      @return Random noise */
-  virtual UShort_t MakePedestal(UShort_t  detector, 
-                               Char_t    ring, 
-                               UShort_t  sector, 
-                               UShort_t  strip) const;
-  /** Check that digit data is consistent
-      @param digit   Digit
-      @param nhits   Number of hits
-      @param counts  ADC counts */
-  virtual void     CheckDigit(AliFMDDigit*    digit,
-                             UShort_t        nhits,
-                             const TArrayI&  counts);
+  /** Sum contributions from SDigits 
+      @param sdigitsBranch Branch of SDigit data */
+  void SumContributions(TBranch* sdigitsBranch);
+  
   ClassDef(AliFMDDigitizer,1) // Make Digits from Hits
 };
 
index 09cbafd..18dd07a 100644 (file)
@@ -68,6 +68,12 @@ ClassImp(AliFMDDisplay)
 AliFMDDisplay* AliFMDDisplay::fgInstance = 0;
 
 //____________________________________________________________________
+const AliFMDDisplay::Range_t AliFMDDisplay::fgkEdepRange = {  100, 0.,    2. };
+const AliFMDDisplay::Range_t AliFMDDisplay::fgkAdcRange  = { 1024, 0., 1023. };
+const AliFMDDisplay::Range_t AliFMDDisplay::fgkMultRange = {  500, 0.,   20. };
+
+  
+//____________________________________________________________________
 AliFMDDisplay* 
 AliFMDDisplay::Instance()
 {
@@ -387,27 +393,30 @@ AliFMDDisplay::MakeAux()
   // MAke the aux canvas 
   // This is used to display spectra
   // etc, 
-  if ((TESTBIT(fTreeMask, kESD) || 
-       TESTBIT(fTreeMask, kDigits) || 
-       TESTBIT(fTreeMask, kRaw))) {
-    if (!fAux) {
-      fAux = new TCanvas("aux", "Aux");
-      fAux->SetLogy();
-      if (TESTBIT(fTreeMask, kESD)) 
-       fSpec = new TH1D("spec", "Mult spectra", 500, 0, 10);
-      else 
-       fSpec = new TH1D("spec", "Adc spectra", 1024, -.5, 1023.5);
-      fSpecCut = static_cast<TH1*>(fSpec->Clone("specCut"));
-      fSpec->SetFillColor(2);
-      fSpec->SetFillStyle(3001);
-      fSpecCut->SetFillColor(4);
-      fSpecCut->SetFillStyle(3001);
-    }
-    else {
-      fSpec->Reset();
-      fSpecCut->Reset();
-    }
+  const Range_t* range = 0;
+  if      (TESTBIT(fTreeMask, kESD))      range = &fgkMultRange;
+  else if (TESTBIT(fTreeMask, kDigits))   range = &fgkAdcRange;
+  else if (TESTBIT(fTreeMask, kSDigits))  range = &fgkAdcRange;
+  else if (TESTBIT(fTreeMask, kRaw))      range = &fgkAdcRange;
+  else if (TESTBIT(fTreeMask, kHits))     range = &fgkEdepRange;
+  if (!range) return;
+  
+  if (!fAux) {
+    fAux = new TCanvas("aux", "Aux");
+    fAux->SetLogy();
+    Float_t dBin = (range->fHigh - range->fLow) / range->fNbins;
+    fSpec = new TH1D("spec", "Spectra", range->fNbins, 
+                    range->fLow-dBin/2, range->fHigh-dBin/2);
+    fSpecCut = static_cast<TH1*>(fSpec->Clone("specCut"));
+    fSpec->SetFillColor(2);
+    fSpec->SetFillStyle(3001);
+    fSpecCut->SetFillColor(4);
+    fSpecCut->SetFillStyle(3001);
   }
+  else {
+    fSpec->Reset();
+    fSpecCut->Reset();
+  }  
 }
 
 //____________________________________________________________________
@@ -533,13 +542,33 @@ AliFMDDisplay::LookupColor(Float_t x, Float_t min, Float_t max) const
 
 //____________________________________________________________________
 void
+AliFMDDisplay::SetCut(Float_t l, Float_t h) 
+{
+  // Change the cut on the slider. 
+  fSlider->SetMinimum(l);
+  fSlider->SetMaximum(h);
+  ChangeCut();
+}
+
+//____________________________________________________________________
+void
 AliFMDDisplay::ChangeCut() 
 {
   // Change the cut on the slider. 
   // The factor depends on what is 
   // drawn in the AUX canvas
-  AliInfo(Form("Range is now %3.1f - %3.1f", fSlider->GetMinimum(), 
+  AliInfo(Form("Range is now %7.5f - %7.5f", fSlider->GetMinimum(), 
               fSlider->GetMaximum()));
+  if ((TESTBIT(fTreeMask, kESD) || 
+       TESTBIT(fTreeMask, kDigits) || 
+       TESTBIT(fTreeMask, kSDigits) || 
+       TESTBIT(fTreeMask, kRaw))) {
+    Float_t l = fSlider->GetMinimum();
+    Float_t h = fSlider->GetMaximum();
+    l         = 1024 * l + 0;
+    h         = 1024 * h + 0;
+    AliInfo(Form("ADC range is now %4d - %4d", int(l), int(h)));
+  }
   Redisplay();
 }
 //____________________________________________________________________
@@ -659,17 +688,17 @@ AliFMDDisplay::ProcessHit(AliFMDHit* hit, TParticle* /* p */)
   // Process a hit. 
   // Parameters: 
   //   hit   Hit data
-
-  static const Float_t rMin  = 0;
-  static const Float_t rMax  = .1;
+  static const Float_t rMin  = fgkEdepRange.fLow;
+  static const Float_t rMax  = fgkEdepRange.fHigh;
 
   if (!hit) { AliError("No hit");   return kFALSE; }
   // if (!p)   { AliError("No track"); return kFALSE; }
-
-  if (fHits) fHits->Add(hit);
   Float_t  edep  = hit->Edep();
 
+  if (fHits)                        fHits->Add(hit);
+  if (fSpec)                        fSpec->Fill(edep);
   if (!InsideCut(edep, rMin, rMax)) return kTRUE;
+  if (fSpecCut)                     fSpecCut->Fill(edep);
   
   AddMarker(hit->X(), hit->Y(), hit->Z(), hit, edep, rMin, rMax);
   return kTRUE;
@@ -682,9 +711,9 @@ AliFMDDisplay::ProcessDigit(AliFMDDigit* digit)
   // Process a digit 
   // Parameters: 
   //   digit Digit information 
+  static const Float_t rMin  = fgkAdcRange.fLow;
+  static const Float_t rMax  = fgkAdcRange.fHigh;
 
-  static const Float_t rMin  = 0;
-  static const Float_t rMax  = 1023;
   if (!digit) { AliError("No digit");   return kFALSE; }
 
   AliFMDParameters* parm = AliFMDParameters::Instance();
@@ -715,9 +744,9 @@ AliFMDDisplay::ProcessSDigit(AliFMDSDigit* sdigit)
   // Process a sdigit 
   // Parameters: 
   //   sdigit Digit information 
+  static const Float_t rMin  = fgkAdcRange.fLow;
+  static const Float_t rMax  = fgkAdcRange.fHigh;
 
-  static const Float_t rMin  = 0;
-  static const Float_t rMax  = 1023;
   if (!sdigit) { AliError("No sdigit");   return kFALSE; }
   
   UShort_t det           =  sdigit->Detector();
@@ -731,7 +760,6 @@ AliFMDDisplay::ProcessSDigit(AliFMDSDigit* sdigit)
   if (!InsideCut(counts, rMin, rMax)) return kTRUE;
   if (fSpecCut)                       fSpecCut->Fill(counts);
   
-
   AddMarker(det, ring, sec, str, sdigit, counts, rMin, rMax);
   return kTRUE;
 }
@@ -753,8 +781,9 @@ AliFMDDisplay::ProcessRecPoint(AliFMDRecPoint* recpoint)
   // Process reconstructed point 
   // Parameters: 
   //  recpoint  Reconstructed multiplicity/energy
-  static const Float_t rMin  = 0;
-  static const Float_t rMax  = 20;
+  static const Float_t rMin  = fgkMultRange.fLow;
+  static const Float_t rMax  = fgkMultRange.fHigh;
+
 
   if (!recpoint) { AliError("No recpoint");   return kFALSE; }
 
@@ -775,8 +804,8 @@ AliFMDDisplay::ProcessESD(UShort_t det, Char_t rng, UShort_t sec, UShort_t str,
   // Parameters 
   //   det,rng,sec,str   Detector coordinates. 
   //   mult              Multiplicity. 
-  static const Float_t rMin = 0;
-  static const Float_t rMax = 20;
+  static const Float_t rMin  = fgkMultRange.fLow;
+  static const Float_t rMax  = fgkMultRange.fHigh;
   
   Double_t cmult = mult;
   if (fSpec) fSpec->Fill(cmult);
index 937db3f..61d310e 100644 (file)
@@ -123,6 +123,9 @@ public:
       @param max Maximum (for example 1023 for digits)
       @return @c false on error  */
   virtual Int_t  LookupColor(Float_t x, Float_t min, Float_t max)  const;
+
+  /** Set range of displayed values */
+  virtual void SetCut(Float_t l=0., Float_t h=1.); //*MENU*
 protected:
   /** Copy constructor 
       @param o Object to copy from  */
@@ -210,6 +213,17 @@ protected:
   TH1*                  fSpecCut;   // Cut spectra
   TCanvas*              fAux;       // Aux canvas.
   Bool_t                fReturn;    // Stop 
+
+
+  struct Range_t { 
+    UInt_t  fNbins;
+    Float_t fLow;
+    Float_t fHigh;
+  };
+  static const Range_t fgkEdepRange;
+  static const Range_t fgkAdcRange;
+  static const Range_t fgkMultRange;
+
   ClassDef(AliFMDDisplay,0)  // FMD specialised event display
 };
 
diff --git a/FMD/AliFMDHitDigitizer.cxx b/FMD/AliFMDHitDigitizer.cxx
new file mode 100644 (file)
index 0000000..659e6b2
--- /dev/null
@@ -0,0 +1,479 @@
+/**************************************************************************
+ * Copyright(c) 2004, 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: AliFMDHitDigitizer.cxx 28055 2008-08-18 00:33:20Z cholm $ */
+/** @file    AliFMDHitDigitizer.cxx
+    @author  Christian Holm Christensen <cholm@nbi.dk>
+    @date    Mon Mar 27 12:38:26 2006
+    @brief   FMD Digitizers implementation
+    @ingroup FMD_sim
+*/
+//////////////////////////////////////////////////////////////////////////////
+//
+//  This class contains the procedures simulation ADC  signal for the
+//  Forward Multiplicity detector  : Hits->Digits
+// 
+//  Digits consists of
+//   - Detector #
+//   - Ring ID                                             
+//   - Sector #     
+//   - Strip #
+//   - ADC count in this channel                                  
+//
+// As the Digits and SDigits have so much in common, the classes
+// AliFMDHitDigitizer and AliFMDSDigitizer are implemented via a base
+// class AliFMDBaseDigitizer.
+//
+//                 +---------------------+
+//                 | AliFMDBaseDigitizer |
+//                 +---------------------+
+//                           ^
+//                           |
+//                +----------+---------+
+//                |                    |
+//      +-----------------+     +------------------+
+//      | AliFMDHitDigitizer | | AliFMDSDigitizer |
+//      +-----------------+    +------------------+
+//
+// These classes has several paramters: 
+//
+//     fPedestal
+//     fPedestalWidth
+//         (Only AliFMDHitDigitizer)
+//         Mean and width of the pedestal.  The pedestal is simulated
+//         by a Guassian, but derived classes my override MakePedestal
+//         to simulate it differently (or pick it up from a database).
+//
+//     fVA1MipRange
+//         The dymamic MIP range of the VA1_ALICE pre-amplifier chip 
+//
+//     fAltroChannelSize
+//         The largest number plus one that can be stored in one
+//         channel in one time step in the ALTRO ADC chip. 
+//
+//     fSampleRate
+//         How many times the ALTRO ADC chip samples the VA1_ALICE
+//         pre-amplifier signal.   The VA1_ALICE chip is read-out at
+//         10MHz, while it's possible to drive the ALTRO chip at
+//         25MHz.  That means, that the ALTRO chip can have time to
+//         sample each VA1_ALICE signal up to 2 times.  Although it's
+//         not certain this feature will be used in the production,
+//         we'd like have the option, and so it should be reflected in
+//         the code.
+//
+// These parameters are fetched from OCDB via the mananger AliFMDParameters.
+//
+// The shaping function of the VA1_ALICE is generally given by 
+//
+//      f(x) = A(1 - exp(-Bx))
+//
+// where A is the total charge collected in the pre-amp., and B is a
+// paramter that depends on the shaping time of the VA1_ALICE circut.
+// 
+// When simulating the shaping function of the VA1_ALICe
+// pre-amp. chip, we have to take into account, that the shaping
+// function depends on the previous value of read from the pre-amp. 
+//
+// That results in the following algorithm:
+//
+//    last = 0;
+//    FOR charge IN pre-amp. charge train DO 
+//      IF last < charge THEN 
+//        f(t) = (charge - last) * (1 - exp(-B * t)) + last
+//      ELSE
+//        f(t) = (last - charge) * exp(-B * t) + charge)
+//      ENDIF
+//      FOR i IN # samples DO 
+//        adc_i = f(i / (# samples))
+//      DONE
+//      last = charge
+//   DONE
+//
+// Here, 
+//
+//   pre-amp. charge train 
+//       is a series of 128 charges read from the VA1_ALICE chip
+//
+//   # samples
+//       is the number of times the ALTRO ADC samples each of the 128
+//       charges from the pre-amp. 
+//
+// Where Q is the total charge collected by the VA1_ALICE
+// pre-amplifier.   Q is then given by 
+//
+//           E S 
+//      Q =  - -
+//           e R
+//
+// where E is the total energy deposited in a silicon strip, R is the
+// dynamic range of the VA1_ALICE pre-amp (fVA1MipRange), e is the
+// energy deposited by a single MIP, and S ALTRO channel size in each
+// time step (fAltroChannelSize).  
+//
+// The energy deposited per MIP is given by 
+//
+//      e = M * rho * w 
+//
+// where M is the universal number 1.664, rho is the density of
+// silicon, and w is the depth of the silicon sensor. 
+//
+// The final ADC count is given by 
+//
+//      C' = C + P
+//
+// where P is the (randomized) pedestal (see MakePedestal)
+//
+// This class uses the class template AliFMDMap<Type> to make an
+// internal cache of the energy deposted of the hits.  The class
+// template is instantasized as 
+//
+//  typedef AliFMDMap<std::pair<Float_t, UShort_t> > AliFMDEdepMap;
+//
+// The first member of the values is the summed energy deposition in a
+// given strip, while the second member of the values is the number of
+// hits in a given strip.  Using the second member, it's possible to
+// do some checks on just how many times a strip got hit, and what
+// kind of error we get in our reconstructed hits.  Note, that this
+// information is currently not written to the digits tree.  I think a
+// QA (Quality Assurance) digit tree is better suited for that task.
+// However, the information is there to be used in the future. 
+//
+//
+// Latest changes by Christian Holm Christensen
+//
+//////////////////////////////////////////////////////////////////////////////
+
+//      /1
+//      |           A(-1 + B + exp(-B))
+//      | f(x) dx = ------------------- = 1
+//      |                    B
+//      / 0
+//
+// and B is the a parameter defined by the shaping time (fShapingTime).  
+//
+// Solving the above equation, for A gives
+//
+//                 B
+//      A = ----------------
+//          -1 + B + exp(-B)
+//
+// So, if we define the function g: [0,1] -> [0:1] by 
+//
+//               / v
+//               |              Bu + exp(-Bu) - Bv - exp(-Bv) 
+//      g(u,v) = | f(x) dx = -A -----------------------------
+//               |                            B
+//               / u
+//
+// we can evaluate the ALTRO sample of the VA1_ALICE pre-amp between
+// any two times (u, v), by 
+//       
+//
+//                                B        Bu + exp(-Bu) - Bv - exp(-Bv)
+//      C = Q g(u,v) = - Q ---------------- -----------------------------
+//                        -1 + B + exp(-B)              B                  
+//
+//               Bu + exp(-Bu) - Bv - exp(-Bv) 
+//        = -  Q -----------------------------
+//                    -1 + B + exp(-B)
+//
+
+#include <TTree.h>             // ROOT_TTree
+#include "AliFMDDebug.h"        // Better debug macros
+#include "AliFMDHitDigitizer.h"        // ALIFMDDIGITIZER_H
+#include "AliFMD.h"            // ALIFMD_H
+#include "AliFMDDigit.h"       // ALIFMDDIGIT_H
+#include "AliFMDParameters.h"   // ALIFMDPARAMETERS_H
+#include <AliRun.h>            // ALIRUN_H
+#include <AliLoader.h>         // ALILOADER_H
+#include <AliRunLoader.h>      // ALIRUNLOADER_H
+#include <AliFMDHit.h>
+#include <TFile.h>
+
+//====================================================================
+ClassImp(AliFMDHitDigitizer)    
+#if 0
+;
+#endif
+
+//____________________________________________________________________
+AliFMDHitDigitizer::AliFMDHitDigitizer(AliFMD* fmd, Output_t  output)
+  : AliFMDBaseDigitizer("FMD", (fOutput == kDigits ? 
+                               "FMD Hit->Digit digitizer" :
+                               "FMD Hit->SDigit digitizer")),
+    fOutput(output)
+{
+  fFMD = fmd;
+}
+
+//____________________________________________________________________
+void
+AliFMDHitDigitizer::Exec(Option_t* /*option*/)
+{
+  // Run this digitizer 
+  // Get an inititialize parameter manager
+  AliFMDParameters::Instance()->Init();
+  if (AliLog::GetDebugLevel("FMD","") >= 10) 
+    AliFMDParameters::Instance()->Print("ALL");
+
+  // Get loader, and ask it to read in the hits 
+  AliLoader* loader = fFMD->GetLoader();
+  if (!loader) { 
+    AliError("Failed to get loader from detector object");
+    return;
+  }
+  loader->LoadHits("READ");
+  
+  // Get the run loader 
+  AliRunLoader* runLoader = loader->GetRunLoader();
+  if (!runLoader) {
+    AliError("Failed to get run loader from loader");
+    return;
+  }
+  
+  // Now loop over events
+  Int_t nEvents = runLoader->GetNumberOfEvents();
+  for (Int_t event = 0; event < nEvents; event++) { 
+    // Get the current event folder. 
+    TFolder* folder = loader->GetEventFolder();
+    if (!folder) { 
+      AliError("Failed to get event folder from loader");
+      return;
+    }
+
+    // Get the run-loader of this event. 
+    const char* loaderName = AliRunLoader::GetRunLoaderName();
+    AliRunLoader* thisLoader = 
+      static_cast<AliRunLoader*>(folder->FindObject(loaderName));
+    if (!thisLoader) { 
+      AliError(Form("Failed to get loader '%s' from event folder", loaderName));
+      return;
+    }
+    
+    // Read in the event
+    AliFMDDebug(5, ("Now digitizing (Hits->%s) event # %d", 
+                   (fOutput == kDigits ? "digits" : "sdigits"), event));
+    thisLoader->GetEvent(event);
+    
+    // Check that we have the hits 
+    if (!loader->TreeH() && loader->LoadHits()) {
+      AliError("Failed to load hits");
+      return;
+    }
+    TTree*   hitsTree = loader->TreeH();
+    TBranch* hitsBranch = hitsTree->GetBranch(fFMD->GetName());
+    if (!hitsBranch) { 
+      AliError("Failed to get hits branch in tree");
+      return;
+    }
+    // Check that we can make the output digits - This must come
+    // before AliFMD::SetBranchAddress
+    TTree* outTree = MakeOutputTree(loader);
+    if (!outTree) { 
+      AliError("Failed to get output tree");
+      return;
+    }
+    AliFMDDebug(5, ("Output tree name for %s is '%s'", 
+                   (fOutput == kDigits ? "digits" : "sdigits"),
+                   outTree->GetName()));
+    if (AliLog::GetDebugLevel("FMD","") >= 5) {
+      TFile* file = outTree->GetCurrentFile();
+      if (!file) {
+       AliWarning("Output tree has no file!");
+      }
+      else { 
+       AliFMDDebug(5, ("Output tree file %s content:", file->GetName()));
+       file->ls();
+      }
+    }
+
+    // Set-up the branch addresses 
+    fFMD->SetTreeAddress();
+    
+    // Now sum all contributions in cache 
+    SumContributions(hitsBranch);
+    loader->UnloadHits();
+
+    // And now digitize the hits 
+    DigitizeHits();
+    
+    // Write digits to tree
+    Int_t write = outTree->Fill();
+    AliFMDDebug(1, ("Wrote %d bytes to digit tree", write));
+
+    // Store the digits
+    StoreDigits(loader);
+
+  }  
+}
+
+//____________________________________________________________________
+TTree*
+AliFMDHitDigitizer::MakeOutputTree(AliLoader* loader)
+{
+  if (fOutput == kDigits) 
+    return AliFMDBaseDigitizer::MakeOutputTree(loader);
+  
+  AliFMDDebug(5, ("Making sdigits tree"));
+  loader->LoadSDigits("UPDATE"); // RECREATE");
+  TTree* out = loader->TreeS();
+  if (!out) loader->MakeTree("S");
+  out = loader->TreeS(); 
+  if (out) { 
+    out->Reset();
+    fFMD->MakeBranch("S");
+  }
+  return out;
+}
+
+
+//____________________________________________________________________
+void
+AliFMDHitDigitizer::SumContributions(TBranch* hitsBranch) 
+{
+  // Sum energy deposited contributions from each hit in a cache
+  // (fEdep).  
+  
+  // Clear array of deposited energies 
+  fEdep.Reset();
+  
+  // Get a list of hits from the FMD manager 
+  AliFMDDebug(5, ("Get array of FMD hits"));
+  TClonesArray *fmdHits = fFMD->Hits();
+  
+
+  // Get number of entries in the tree 
+  AliFMDDebug(5, ("Get # of tracks"));
+  Int_t ntracks  = Int_t(hitsBranch->GetEntries());
+  AliFMDDebug(5, ("We got %d tracks", ntracks));
+
+  Int_t read = 0;
+  // Loop over the tracks in the 
+  for (Int_t track = 0; track < ntracks; track++)  {
+    // Read in entry number `track' 
+    read += hitsBranch->GetEntry(track);
+    
+    // Get the number of hits 
+    Int_t nhits = fmdHits->GetEntries ();
+    for (Int_t hit = 0; hit < nhits; hit++) {
+      // Get the hit number `hit'
+      AliFMDHit* fmdHit = 
+       static_cast<AliFMDHit*>(fmdHits->UncheckedAt(hit));
+      
+      // Extract parameters 
+      AddContribution(fmdHit->Detector(),
+                     fmdHit->Ring(),
+                     fmdHit->Sector(),
+                     fmdHit->Strip(),
+                     fmdHit->Edep());
+    }  // hit loop
+  } // track loop
+  AliFMDDebug(5, ("Size of cache: %d bytes, read %d bytes", 
+                  sizeof(fEdep), read));
+}
+
+
+//____________________________________________________________________
+UShort_t
+AliFMDHitDigitizer::MakePedestal(UShort_t  detector, 
+                                Char_t    ring, 
+                                UShort_t  sector, 
+                                UShort_t  strip) const 
+{
+  // Make a pedestal 
+  if (fOutput == kSDigits) return 0;
+  return AliFMDBaseDigitizer::MakePedestal(detector, ring, sector, strip);
+}
+
+
+
+//____________________________________________________________________
+void
+AliFMDHitDigitizer::AddDigit(UShort_t  detector, 
+                            Char_t    ring,
+                            UShort_t  sector, 
+                            UShort_t  strip, 
+                            Float_t   edep, 
+                            UShort_t  count1, 
+                            Short_t   count2, 
+                            Short_t   count3,
+                            Short_t   count4) const
+{
+  // Add a digit or summable digit
+  if (fOutput == kDigits) { 
+    AliFMDBaseDigitizer::AddDigit(detector, ring, sector, strip, 0,
+                                 count1, count2, count3, count4);
+    return;
+  }
+  if (edep <= 0) return;
+  if (count1 == 0 && count2 <= 0 && count3 <= 0 && count4 <= 0) return;
+  fFMD->AddSDigitByFields(detector, ring, sector, strip, edep,
+                         count1, count2, count3, count4);
+}
+
+//____________________________________________________________________
+void
+AliFMDHitDigitizer::CheckDigit(AliFMDDigit*    digit,
+                              UShort_t        nhits,
+                              const TArrayI&  counts) 
+{
+  // Check that digit is consistent
+  AliFMDParameters* param = AliFMDParameters::Instance();
+  UShort_t          det   = digit->Detector();
+  Char_t            ring  = digit->Ring();
+  UShort_t          sec   = digit->Sector();
+  UShort_t          str   = digit->Strip();
+  Float_t           mean  = param->GetPedestal(det,ring,sec,str);
+  Float_t           width = param->GetPedestalWidth(det,ring,sec,str);
+  UShort_t          range = param->GetVA1MipRange();
+  UShort_t          size  = param->GetAltroChannelSize();
+  Int_t             integral = counts[0];
+  if (counts[1] >= 0) integral += counts[1];
+  if (counts[2] >= 0) integral += counts[2];
+  if (counts[3] >= 0) integral += counts[3];
+  integral -= Int_t(mean + 2 * width);
+  if (integral < 0) integral = 0;
+  
+  Float_t convF = Float_t(range) / size;
+  Float_t mips  = integral * convF;
+  if (mips > Float_t(nhits) + .5 || mips < Float_t(nhits) - .5) 
+    Warning("CheckDigit", "Digit -> %4.2f MIPS != %d +/- .5 hits", 
+           mips, nhits);
+}
+
+//____________________________________________________________________
+void
+AliFMDHitDigitizer::StoreDigits(AliLoader* loader)
+{
+  if (fOutput == kDigits) { 
+    AliFMDBaseDigitizer::StoreDigits(loader);
+    return;
+  }
+  AliFMDDebug(5, ("Storing %d sdigits",   fFMD->SDigits()->GetEntries()));
+  // Write the digits to disk 
+  loader->WriteSDigits("OVERWRITE");
+  loader->UnloadSDigits();
+  // Reset the digits in the AliFMD object 
+  fFMD->ResetSDigits();
+}
+
+
+//____________________________________________________________________
+//
+// EOF
+// 
+
+
+
+
diff --git a/FMD/AliFMDHitDigitizer.h b/FMD/AliFMDHitDigitizer.h
new file mode 100644 (file)
index 0000000..614c36d
--- /dev/null
@@ -0,0 +1,143 @@
+#ifndef ALIFMDHITDIGITIZER_H
+#define ALIFMDHITDIGITIZER_H
+/* Copyright(c) 1998-2000, ALICE Experiment at CERN, All rights
+ * reserved. 
+ *
+ * See cxx source for full Copyright notice                               
+ */
+// Classses to make Hits into digits and summable digits
+//    
+//    Digits consists of
+//    - Detector #
+//    - Ring ID                                             
+//    - Sector #     
+//    - Strip #
+//    - ADC count in this channel
+//
+/** @file    AliFMDHitDigitizer.h
+    @author  Christian Holm Christensen <cholm@nbi.dk>
+    @date    Mon Mar 27 12:38:26 2006
+    @brief   FMD Digitizers declaration
+    @ingroup FMD_sim
+*/
+#ifndef ALIFMDBASEDIGITIZER_H
+# include <AliFMDBaseDigitizer.h>
+#endif
+
+//====================================================================
+class TClonesArray;
+class AliFMD;
+class AliLoader;
+class AliRunLoader;
+class AliFMDDigit;
+
+
+
+//====================================================================
+/** @class AliFMDHitDigitizer
+    @brief Concrete digitizer to make digits from hits.  See also
+    AliFMDBaseDigitizer documentation.  
+    @ingroup FMD_sim
+ */
+class AliFMDHitDigitizer : public AliFMDBaseDigitizer
+{
+public:
+  enum Output_t { 
+    kDigits, 
+    kSDigits
+  };
+    
+  /** CTOR */
+  AliFMDHitDigitizer() 
+    : AliFMDBaseDigitizer(), 
+      fOutput(kDigits) 
+  {}
+  /** CTOR 
+      @param name Name */
+  AliFMDHitDigitizer(AliFMD* fmd, Output_t  output);
+  /** DTOR */
+  virtual ~AliFMDHitDigitizer() {}
+  /** Run over the input events (retrieved via run loader) */
+  void Exec(Option_t* option="");
+protected:
+  /** Copy constructor 
+      @param o Object to copy from */
+  AliFMDHitDigitizer(const AliFMDHitDigitizer& o) 
+    : AliFMDBaseDigitizer(o),
+      fOutput(o.fOutput)
+  {}
+  /** Assignment operator
+      @param o Object to assign from 
+      @return Reference to this */
+  AliFMDHitDigitizer& operator=(const AliFMDHitDigitizer& o) 
+  {
+    AliFMDBaseDigitizer::operator=(o);
+    fOutput      = o.fOutput;
+    return *this;
+  }
+  /** Make the output tree using the passed loader 
+      @param loader 
+      @return The generated tree. */
+  TTree* MakeOutputTree(AliLoader* loader);
+  /** Sum energy deposited contributions from each hit in a cache
+      @param hitsBranch Branch in input tree */
+  void SumContributions(TBranch* hitsBranch);
+  /** Make a pedestal 
+      @param detector Detector #
+      @param ring     Ring ID
+      @param sector   Sector #
+      @param strip    Strip #
+      @return Pedestal value */
+  UShort_t MakePedestal(UShort_t  detector, 
+                       Char_t    ring, 
+                       UShort_t  sector, 
+                       UShort_t  strip) const;
+  /** Add a digit to output.
+      @param fmd      Pointer to detector object
+      @param detector Detector #
+      @param ring     Ring ID
+      @param sector   Sector number
+      @param strip    Strip number
+      @param edep     Energy deposited (not used)
+      @param count1   ADC count 1
+      @param count2   ADC count 2 (-1 if not used)
+      @param count3   ADC count 3 (-1 if not used) 
+      @param count4   ADC count 4 (-1 if not used) */
+  void AddDigit(UShort_t  detector, 
+               Char_t    ring,
+               UShort_t  sector, 
+               UShort_t  strip, 
+               Float_t   edep, 
+               UShort_t  count1, 
+               Short_t   count2, 
+               Short_t   count3,
+               Short_t   count4) const;
+  /** Check that digit data is consistent
+      @param digit   Digit
+      @param nhits   Number of hits
+      @param counts  ADC counts */
+  void CheckDigit(AliFMDDigit*    digit,
+                 UShort_t        nhits,
+                 const TArrayI&  counts);
+  /** Store the data using the loader 
+      @param loader The loader */
+  void StoreDigits(AliLoader* loader);
+  
+
+  Output_t      fOutput;           // Output mode
+
+  ClassDef(AliFMDHitDigitizer,1) // Make Digits from Hits
+};
+
+
+#endif
+//____________________________________________________________________
+//
+// Local Variables:
+//   mode: C++
+// End:
+//
+//
+// EOF
+//
+
index f6e8598..81ce338 100644 (file)
@@ -406,17 +406,20 @@ AliFMDParameters::Print(Option_t* option) const
       if (det == 1 && ring == 'O') continue;
       UShort_t min  = GetMinStrip(det, ring, 0, 0);
       UShort_t max  = GetMaxStrip(det, ring, 0, 0);
-      UShort_t rate = GetSampleRate(det, ring, 0, 0);
       std::cout << "FMD" << det << ring 
                << "  Strip range: " 
                << std::setw(3) << min << "," 
-               << std::setw(3) << max << "  Rate: " 
-               << std::setw(2) << rate << std::endl;
+               << std::setw(3) << max << std::endl;
 
-      if (!showStrips) continue;
       UShort_t nSec = ( ring == 'I' ? 20  :  40 );
       UShort_t nStr = ( ring == 'I' ? 512 : 256 );
       for (UShort_t sec = minSector; sec < maxSector && sec < nSec; sec++) {
+
+       UShort_t rate = GetSampleRate(det, ring, sec, 0);
+       std::cout << "FMD" << det << ring << "[" << std::setw(2) << sec 
+                 << "] sample rate: " << rate << std::endl;
+
+       if (!showStrips) continue;
        std::cout 
          << "  Strip |     Pedestal      |    Gain    | ZS thr. | Address\n" 
          << "--------+-------------------+------------+---------+---------" 
index 847ad7e..d575a5e 100644 (file)
@@ -411,10 +411,21 @@ AliFMDPattern::ProcessHit(AliFMDHit* hit, TParticle*)
   //   HIT             The hit to process. 
   // 
   // The TParticle argument is never used. 
+  static const Float_t rMin  = fgkEdepRange.fLow;
+  static const Float_t rMax  = fgkEdepRange.fHigh;
+
+  if (!hit) { AliError("No hit");   return kFALSE; }
+  // if (!p)   { AliError("No track"); return kFALSE; }
+  Float_t  edep  = hit->Edep();
+
+  if (fHits)                        fHits->Add(hit);
+  if (fSpec)                        fSpec->Fill(edep);
+  if (InsideCut(edep, rMin, rMax) && fSpecCut) fSpecCut->Fill(edep);
+
   switch (hit->Detector()) {
-  case 1: fFMD1.AddMarker(hit->X(), hit->Y(), hit->Edep(), 1); break;
-  case 2: fFMD2.AddMarker(hit->X(), hit->Y(), hit->Edep(), 1); break;
-  case 3: fFMD3.AddMarker(hit->X(), hit->Y(), hit->Edep(), 1); break;
+  case 1: fFMD1.AddMarker(hit->X(), hit->Y(), hit->Edep(), rMax); break;
+  case 2: fFMD2.AddMarker(hit->X(), hit->Y(), hit->Edep(), rMax); break;
+  case 3: fFMD3.AddMarker(hit->X(), hit->Y(), hit->Edep(), rMax); break;
   }
   return kTRUE;
 }
index a368d5f..e91daab 100644 (file)
@@ -66,6 +66,7 @@ AliFMDRawWriter::AliFMDRawWriter(AliFMD* fmd)
     fThreshold(0)
 {
   // CTOR 
+  AliFMDDebug(5, ("Created AliFMDRawWriter object"));
 }
 
 
@@ -130,10 +131,10 @@ AliFMDRawWriter::Exec(Option_t*)
   // Note, that this method assumes that the digits are ordered. 
   // 
   AliLoader* loader = fFMD->GetLoader();
-  loader->LoadDigits();
+  loader->LoadDigits("READ");
   TTree* digitTree = loader->TreeD();
   if (!digitTree) {
-    Error("Digits2Raw", "no digit tree");
+    AliError("no digit tree");
     return;
   }
   
@@ -141,7 +142,7 @@ AliFMDRawWriter::Exec(Option_t*)
   fFMD->SetTreeAddress();
   TBranch* digitBranch = digitTree->GetBranch(fFMD->GetName());
   if (!digitBranch) {
-    Error("Digits2Raw", "no branch for %s", fFMD->GetName());
+    AliError(Form("no branch for %s", fFMD->GetName()));
     return;
   }
   digitBranch->SetAddress(&digits);
diff --git a/FMD/AliFMDSDigitizer.cxx b/FMD/AliFMDSDigitizer.cxx
deleted file mode 100644 (file)
index ffd3c2a..0000000
+++ /dev/null
@@ -1,351 +0,0 @@
-/**************************************************************************
- * Copyright(c) 2004, 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$ */
-/** @file    AliFMDSDigitizer.cxx
-    @author  Christian Holm Christensen <cholm@nbi.dk>
-    @date    Mon Mar 27 12:38:26 2006
-    @brief   FMD Digitizers implementation
-    @ingroup FMD_sim
-*/
-//////////////////////////////////////////////////////////////////////////////
-//
-//  This class contains the procedures simulation ADC  signal for the
-//  Forward Multiplicity detector  : Hits->SDigits
-// 
-//  SDigits consists of
-//   - Detector #
-//   - Ring ID                                             
-//   - Sector #     
-//   - Strip #
-//   - Total energy deposited in the strip
-//   - ADC count in this channel                                  
-//
-// As the Digits and SDigits have so much in common, the classes
-// AliFMDDigitizer and AliFMDSDigitizer are implemented via a base
-// class AliFMDBaseDigitizer.
-//
-//                 +---------------------+
-//                 | AliFMDBaseDigitizer |
-//                 +---------------------+
-//                           ^
-//                           |
-//                +----------+---------+
-//                |                    |
-//      +-----------------+     +------------------+
-//      | AliFMDDigitizer |    | AliFMDSDigitizer |
-//      +-----------------+    +------------------+
-//
-// These classes has several paramters: 
-//
-//     fPedestal
-//     fPedestalWidth
-//         (Only AliFMDDigitizer)
-//         Mean and width of the pedestal.  The pedestal is simulated
-//         by a Guassian, but derived classes my override MakePedestal
-//         to simulate it differently (or pick it up from a database).
-//
-//     fVA1MipRange
-//         The dymamic MIP range of the VA1_ALICE pre-amplifier chip 
-//
-//     fAltroChannelSize
-//         The largest number plus one that can be stored in one
-//         channel in one time step in the ALTRO ADC chip. 
-//
-//     fSampleRate
-//         How many times the ALTRO ADC chip samples the VA1_ALICE
-//         pre-amplifier signal.   The VA1_ALICE chip is read-out at
-//         10MHz, while it's possible to drive the ALTRO chip at
-//         25MHz.  That means, that the ALTRO chip can have time to
-//         sample each VA1_ALICE signal up to 2 times.  Although it's
-//         not certain this feature will be used in the production,
-//         we'd like have the option, and so it should be reflected in
-//         the code.
-//
-// These parameters are fetched from OCDB via the mananger AliFMDParameters.
-//
-// The shaping function of the VA1_ALICE is generally given by 
-//
-//      f(x) = A(1 - exp(-Bx))
-//
-// where A is the total charge collected in the pre-amp., and B is a
-// paramter that depends on the shaping time of the VA1_ALICE circut.
-// 
-// When simulating the shaping function of the VA1_ALICe
-// pre-amp. chip, we have to take into account, that the shaping
-// function depends on the previous value of read from the pre-amp. 
-//
-// That results in the following algorithm:
-//
-//    last = 0;
-//    FOR charge IN pre-amp. charge train DO 
-//      IF last < charge THEN 
-//        f(t) = (charge - last) * (1 - exp(-B * t)) + last
-//      ELSE
-//        f(t) = (last - charge) * exp(-B * t) + charge)
-//      ENDIF
-//      FOR i IN # samples DO 
-//        adc_i = f(i / (# samples))
-//      DONE
-//      last = charge
-//   DONE
-//
-// Here, 
-//
-//   pre-amp. charge train 
-//       is a series of 128 charges read from the VA1_ALICE chip
-//
-//   # samples
-//       is the number of times the ALTRO ADC samples each of the 128
-//       charges from the pre-amp. 
-//
-// Where Q is the total charge collected by the VA1_ALICE
-// pre-amplifier.   Q is then given by 
-//
-//           E S 
-//      Q =  - -
-//           e R
-//
-// where E is the total energy deposited in a silicon strip, R is the
-// dynamic range of the VA1_ALICE pre-amp (fVA1MipRange), e is the
-// energy deposited by a single MIP, and S ALTRO channel size in each
-// time step (fAltroChannelSize).  
-//
-// The energy deposited per MIP is given by 
-//
-//      e = M * rho * w 
-//
-// where M is the universal number 1.664, rho is the density of
-// silicon, and w is the depth of the silicon sensor. 
-//
-// The final ADC count is given by 
-//
-//      C' = C + P
-//
-// where P is the (randomized) pedestal (see MakePedestal)
-//
-// This class uses the class template AliFMDMap<Type> to make an
-// internal cache of the energy deposted of the hits.  The class
-// template is instantasized as 
-//
-//  typedef AliFMDMap<std::pair<Float_t, UShort_t> > AliFMDEdepMap;
-//
-// The first member of the values is the summed energy deposition in a
-// given strip, while the second member of the values is the number of
-// hits in a given strip.  Using the second member, it's possible to
-// do some checks on just how many times a strip got hit, and what
-// kind of error we get in our reconstructed hits.  Note, that this
-// information is currently not written to the digits tree.  I think a
-// QA (Quality Assurance) digit tree is better suited for that task.
-// However, the information is there to be used in the future. 
-//
-//
-// Latest changes by Christian Holm Christensen
-//
-//////////////////////////////////////////////////////////////////////////////
-
-//      /1
-//      |           A(-1 + B + exp(-B))
-//      | f(x) dx = ------------------- = 1
-//      |                    B
-//      / 0
-//
-// and B is the a parameter defined by the shaping time (fShapingTime).  
-//
-// Solving the above equation, for A gives
-//
-//                 B
-//      A = ----------------
-//          -1 + B + exp(-B)
-//
-// So, if we define the function g: [0,1] -> [0:1] by 
-//
-//               / v
-//               |              Bu + exp(-Bu) - Bv - exp(-Bv) 
-//      g(u,v) = | f(x) dx = -A -----------------------------
-//               |                            B
-//               / u
-//
-// we can evaluate the ALTRO sample of the VA1_ALICE pre-amp between
-// any two times (u, v), by 
-//       
-//
-//                                B        Bu + exp(-Bu) - Bv - exp(-Bv)
-//      C = Q g(u,v) = - Q ---------------- -----------------------------
-//                        -1 + B + exp(-B)              B                  
-//
-//               Bu + exp(-Bu) - Bv - exp(-Bv) 
-//        = -  Q -----------------------------
-//                    -1 + B + exp(-B)
-//
-
-#include "AliFMDDebug.h" // Better debug macros
-#include "AliFMDSDigitizer.h"  // ALIFMDDIGITIZER_H
-#include "AliFMD.h"            // ALIFMD_H
-#include "AliFMDHit.h"         // ALIFMDHIT_H
-#include <AliRun.h>            // ALIRUN_H
-#include <AliLoader.h>         // ALILOADER_H
-#include <AliRunLoader.h>      // ALIRUNLOADER_H
-    
-//====================================================================
-ClassImp(AliFMDSDigitizer)
-
-#if 0
-//____________________________________________________________________
-AliFMDSDigitizer::AliFMDSDigitizer(const Char_t* headerFile, 
-                                  const Char_t* /* sdigfile */)
-  : AliFMDBaseDigitizer("FMDSDigitizer", "FMD SDigitizer")
-{
-  // Normal CTOR
-  AliFMDDebug(1, ("Constructed"));
-
-  fRunLoader = AliRunLoader::GetRunLoader(); // Open(headerFile);
-  if (!fRunLoader) 
-    Fatal("AliFMDSDigitizer", "cannot open session, header file '%s'",
-         headerFile);
-  AliLoader* loader = fRunLoader->GetLoader("FMDLoader");
-  if (!loader) 
-    Fatal("AliFMDSDigitizer", "cannot find FMD loader in specified event");
-
-  // Add task to tasks folder 
-  loader->PostSDigitizer(this);
-}
-//____________________________________________________________________
-AliFMDSDigitizer::~AliFMDSDigitizer() 
-{
-  // Destructor
-  AliLoader* loader = fRunLoader->GetLoader("FMDLoader");
-  loader->CleanSDigitizer();
-  AliFMDDebug(1, ("Destructed"));
-}
-//____________________________________________________________________
-void
-AliFMDSDigitizer::Exec(Option_t*) 
-{
-  // Get the output manager 
-  if (!fRunLoader) {
-    Error("Exec", "Run loader is not set");
-    return;
-  }
-  if (!fRunLoader->GetAliRun()) fRunLoader->LoadgAlice();
-  if (!fRunLoader->TreeE())     fRunLoader->LoadHeader();
-  
-  AliLoader* fmdLoader = fRunLoader->GetLoader("FMDLoader");
-  if (!fmdLoader) Fatal("Exec", "no FMD loader");
-  
-  // Get the AliFMD object 
-  AliFMD* fmd = 
-    static_cast<AliFMD*>(fRunLoader->GetAliRun()->GetDetector("FMD"));
-  if (!fmd) {
-    AliError("Can not get FMD from gAlice");
-    return;
-  }
-
-  Int_t nEvents = Int_t(fRunLoader->TreeE()->GetEntries());
-  for (Int_t event = 0; event < nEvents; event++) {
-    AliFMDDebug(1, (" Digitizing event number %d", event));
-    // Get the current loader 
-    fRunLoader->GetEvent(event);
-
-    if (!fmdLoader->TreeS()) fmdLoader->MakeTree("S");
-    // Make a branch
-    fmd->MakeBranch("S");
-    
-    // Cache contriutions 
-    SumContributions(fmd);
-
-    // Digitize the event 
-    DigitizeHits(fmd);
-
-    fmdLoader->TreeS()->Reset();
-    fmdLoader->TreeS()->Fill();
-    fmdLoader->WriteSDigits("OVERWRITE");
-  }
-}
-
-#endif
-
-//____________________________________________________________________
-void 
-AliFMDSDigitizer::OutputTree(AliLoader* outFMD, AliFMD* fmd)
-{
-  // Load sdigits from the tree 
-  outFMD->LoadSDigits("update");
-
-  // Get the tree of sdigits 
-  TTree* sdigitTree = outFMD->TreeS();
-  if (!sdigitTree) {
-    outFMD->MakeTree("S");
-    sdigitTree = outFMD->TreeS();
-  }
-  sdigitTree->Reset();
-  
-  // Get the sdigits 
-  TClonesArray* sdigits =  fmd->SDigits();
-  if (!sdigits) { 
-    AliError("Failed to get sdigits");
-    return;
-  }
-  AliFMDDebug(5, ("Got a total of %5d sdigits", sdigits->GetEntries()));
-
-  // Make a branch in the tree 
-  fmd->MakeBranchInTree(sdigitTree, fmd->GetName(), &(sdigits), 4000, 0);
-  // TBranch* sdigitBranch = sdigitTree->GetBranch(fmd->GetName());
-  // Fill the tree 
-  Int_t write = 0;
-  write = sdigitTree->Fill();
-  AliFMDDebug(1, ("Wrote %d bytes to sdigit tree", write));
-  
-  // Write the sdigits to disk 
-  outFMD->WriteSDigits("OVERWRITE");
-  outFMD->UnloadHits();
-  outFMD->UnloadSDigits();
-
-  // Reset the sdigits in the AliFMD object 
-  fmd->ResetSDigits();
-}
-
-//____________________________________________________________________
-void
-AliFMDSDigitizer::AddDigit(AliFMD*  fmd,
-                          UShort_t detector, 
-                          Char_t   ring,
-                          UShort_t sector, 
-                          UShort_t strip, 
-                          Float_t  edep, 
-                          UShort_t count1, 
-                          Short_t  count2, 
-                          Short_t  count3,
-                          Short_t  count4) const
-{
-  // Add a summable digit
-  if (count1 == 0 && 
-      count2 <= 0 && 
-      count3 <= 0 && 
-      count4 <= 0)
-    return;
-  fmd->AddSDigitByFields(detector, ring, sector, strip, edep, 
-                        count1, count2, count3, count4); 
-}
-
-
-
-//____________________________________________________________________
-//
-// EOF
-// 
-
-
-
-
diff --git a/FMD/AliFMDSDigitizer.h b/FMD/AliFMDSDigitizer.h
deleted file mode 100644 (file)
index 52ebbf7..0000000
+++ /dev/null
@@ -1,93 +0,0 @@
-#ifndef ALIFMDSDIGITIZER_H
-#define ALIFMDSDIGITIZER_H
-/* Copyright(c) 1998-2000, ALICE Experiment at CERN, All rights
- * reserved. 
- *
- * See cxx source for full Copyright notice                               
- */
-// Classses to make Hits into digits and summable digits. 
-//    
-//    Digits consists of
-//    - Detector #
-//    - Ring ID                                             
-//    - Sector #     
-//    - Strip #
-//    - ADC count in this channel                                  
-//
-//    Summable digits consists of      
-//    - Detector #
-//    - Ring ID                                             
-//    - Sector #     
-//    - Strip #
-//    - Total energy deposited in the strip
-//    - ADC count in this channel                                  
-//
-/** @file    AliFMDSDigitizer.h
-    @author  Christian Holm Christensen <cholm@nbi.dk>
-    @date    Mon Mar 27 12:38:26 2006
-    @brief   FMD Digitizers declaration
-    @ingroup FMD_sim
-*/
-#ifndef ALIFMDBASEDIGITIZER_H
-# include <AliFMDBaseDigitizer.h>
-#endif
-
-//====================================================================
-/** @class AliFMDSDigitizer AliFMDDigitizer.h <FMD/AliFMDDigitizer.h>
-    @brief Concrete implementation to make summable digits. 
-    See also class documentation of AliFMDBaseDigitizer 
-    @ingroup FMD_sim
- */
-class AliFMDSDigitizer : public AliFMDBaseDigitizer 
-{
-public:
-  /** CTOR */
-  AliFMDSDigitizer() : AliFMDBaseDigitizer() {}
-  /** CTOR 
-      @param manager Manager of digitization */
-  AliFMDSDigitizer(AliRunDigitizer * manager)
-    : AliFMDBaseDigitizer(manager) 
-  {}
-  /** DTOR */
-  virtual ~AliFMDSDigitizer() {}
-protected:
-  /** Output to disk 
-      @param outFMD Loader
-      @param fmd    AliFMD object */
-  virtual void OutputTree(AliLoader* outFMD, AliFMD* fmd);
-  /** Add a digit to output.
-      @param fmd      Pointer to detector object
-      @param detector Detector #
-      @param ring     Ring ID
-      @param sector   Sector number
-      @param strip    Strip number
-      @param edep     Energy deposited (not used)
-      @param count1   ADC count 1
-      @param count2   ADC count 2 (-1 if not used)
-      @param count3   ADC count 3 (-1 if not used) */
-  virtual void     AddDigit(AliFMD*  fmd,
-                           UShort_t detector, 
-                           Char_t   ring,
-                           UShort_t sector, 
-                           UShort_t strip, 
-                           Float_t  edep, 
-                           UShort_t count1, 
-                           Short_t  count2, 
-                           Short_t  count3,
-                           Short_t  count4) const;
-  ClassDef(AliFMDSDigitizer,0) // Make Summable Digits from Hits
-};
-
-
-
-#endif
-//____________________________________________________________________
-//
-// Local Variables:
-//   mode: C++
-// End:
-//
-//
-// EOF
-//
-
diff --git a/FMD/AliFMDSSDigitizer.cxx b/FMD/AliFMDSSDigitizer.cxx
deleted file mode 100644 (file)
index e609e84..0000000
+++ /dev/null
@@ -1,317 +0,0 @@
-/**************************************************************************
- * Copyright(c) 2004, 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: AliFMDDigitizer.cxx 22496 2007-11-26 13:50:44Z cholm $ */
-/** @file    AliFMDDigitizer.cxx
-    @author  Christian Holm Christensen <cholm@nbi.dk>
-    @date    Mon Mar 27 12:38:26 2006
-    @brief   FMD Digitizers implementation
-    @ingroup FMD_sim
-*/
-//////////////////////////////////////////////////////////////////////////////
-//
-//  This class contains the procedures simulation ADC  signal for the
-//  Forward Multiplicity detector  : SDigits->Digits
-// 
-//  Digits consists of
-//   - Detector #
-//   - Ring ID                                             
-//   - Sector #     
-//   - Strip #
-//   - ADC count in this channel                                  
-//
-//  Digits consists of
-//   - Detector #
-//   - Ring ID                                             
-//   - Sector #     
-//   - Strip #
-//   - Total energy deposited in the strip
-//   - ADC count in this channel                                  
-//
-// As the Digits and SDigits have so much in common, the classes
-// AliFMDDigitizer and AliFMDSDigitizer are implemented via a base
-// class AliFMDBaseDigitizer.
-//
-//                 +---------------------+
-//                 | AliFMDBaseDigitizer |
-//                 +---------------------+
-//                           ^
-//                           |
-//                +----------+---------+
-//                |                    |
-//      +-----------------+     +------------------+
-//      | AliFMDDigitizer |    | AliFMDSDigitizer |
-//      +-----------------+    +------------------+
-//                |
-//     +-------------------+
-//     | AliFMDSSDigitizer |
-//     +-------------------+
-//
-// These classes has several paramters: 
-//
-//     fPedestal
-//     fPedestalWidth
-//         (Only AliFMDDigitizer)
-//         Mean and width of the pedestal.  The pedestal is simulated
-//         by a Guassian, but derived classes my override MakePedestal
-//         to simulate it differently (or pick it up from a database).
-//
-//     fVA1MipRange
-//         The dymamic MIP range of the VA1_ALICE pre-amplifier chip 
-//
-//     fAltroChannelSize
-//         The largest number plus one that can be stored in one
-//         channel in one time step in the ALTRO ADC chip. 
-//
-//     fSampleRate
-//         How many times the ALTRO ADC chip samples the VA1_ALICE
-//         pre-amplifier signal.   The VA1_ALICE chip is read-out at
-//         10MHz, while it's possible to drive the ALTRO chip at
-//         25MHz.  That means, that the ALTRO chip can have time to
-//         sample each VA1_ALICE signal up to 2 times.  Although it's
-//         not certain this feature will be used in the production,
-//         we'd like have the option, and so it should be reflected in
-//         the code.
-//
-//
-// The shaping function of the VA1_ALICE is generally given by 
-//
-//      f(x) = A(1 - exp(-Bx))
-//
-// where A is the total charge collected in the pre-amp., and B is a
-// paramter that depends on the shaping time of the VA1_ALICE circut.
-// 
-// When simulating the shaping function of the VA1_ALICe
-// pre-amp. chip, we have to take into account, that the shaping
-// function depends on the previous value of read from the pre-amp. 
-//
-// That results in the following algorithm:
-//
-//    last = 0;
-//    FOR charge IN pre-amp. charge train DO 
-//      IF last < charge THEN 
-//        f(t) = (charge - last) * (1 - exp(-B * t)) + last
-//      ELSE
-//        f(t) = (last - charge) * exp(-B * t) + charge)
-//      ENDIF
-//      FOR i IN # samples DO 
-//        adc_i = f(i / (# samples))
-//      DONE
-//      last = charge
-//   DONE
-//
-// Here, 
-//
-//   pre-amp. charge train 
-//       is a series of 128 charges read from the VA1_ALICE chip
-//
-//   # samples
-//       is the number of times the ALTRO ADC samples each of the 128
-//       charges from the pre-amp. 
-//
-// Where Q is the total charge collected by the VA1_ALICE
-// pre-amplifier.   Q is then given by 
-//
-//           E S 
-//      Q =  - -
-//           e R
-//
-// where E is the total energy deposited in a silicon strip, R is the
-// dynamic range of the VA1_ALICE pre-amp (fVA1MipRange), e is the
-// energy deposited by a single MIP, and S ALTRO channel size in each
-// time step (fAltroChannelSize).  
-//
-// The energy deposited per MIP is given by 
-//
-//      e = M * rho * w 
-//
-// where M is the universal number 1.664, rho is the density of
-// silicon, and w is the depth of the silicon sensor. 
-//
-// The final ADC count is given by 
-//
-//      C' = C + P
-//
-// where P is the (randomized) pedestal (see MakePedestal)
-//
-// This class uses the class template AliFMDMap<Type> to make an
-// internal cache of the energy deposted of the hits.  The class
-// template is instantasized as 
-//
-//  typedef AliFMDMap<std::pair<Float_t, UShort_t> > AliFMDEdepMap;
-//
-// The first member of the values is the summed energy deposition in a
-// given strip, while the second member of the values is the number of
-// hits in a given strip.  Using the second member, it's possible to
-// do some checks on just how many times a strip got hit, and what
-// kind of error we get in our reconstructed hits.  Note, that this
-// information is currently not written to the digits tree.  I think a
-// QA (Quality Assurance) digit tree is better suited for that task.
-// However, the information is there to be used in the future. 
-//
-//
-// Latest changes by Christian Holm Christensen
-//
-//////////////////////////////////////////////////////////////////////////////
-
-//      /1
-//      |           A(-1 + B + exp(-B))
-//      | f(x) dx = ------------------- = 1
-//      |                    B
-//      / 0
-//
-// and B is the a parameter defined by the shaping time (fShapingTime).  
-//
-// Solving the above equation, for A gives
-//
-//                 B
-//      A = ----------------
-//          -1 + B + exp(-B)
-//
-// So, if we define the function g: [0,1] -> [0:1] by 
-//
-//               / v
-//               |              Bu + exp(-Bu) - Bv - exp(-Bv) 
-//      g(u,v) = | f(x) dx = -A -----------------------------
-//               |                            B
-//               / u
-//
-// we can evaluate the ALTRO sample of the VA1_ALICE pre-amp between
-// any two times (u, v), by 
-//       
-//
-//                                B        Bu + exp(-Bu) - Bv - exp(-Bv)
-//      C = Q g(u,v) = - Q ---------------- -----------------------------
-//                        -1 + B + exp(-B)              B                  
-//
-//               Bu + exp(-Bu) - Bv - exp(-Bv) 
-//        = -  Q -----------------------------
-//                    -1 + B + exp(-B)
-//
-
-#include <TTree.h>             // ROOT_TTree
-#include "AliFMDDebug.h"       // Better debug macros
-#include "AliFMDSSDigitizer.h" // ALIFMDSSDIGITIZER_H
-#include "AliFMD.h"            // ALIFMD_H
-#include "AliFMDSDigit.h"      // ALIFMDDIGIT_H
-#include "AliFMDDigit.h"       // ALIFMDDIGIT_H
-#include "AliFMDParameters.h"   // ALIFMDPARAMETERS_H
-#include <AliRunDigitizer.h>   // ALIRUNDIGITIZER_H
-#include <AliRun.h>            // ALIRUN_H
-#include <AliLoader.h>         // ALILOADER_H
-#include <AliRunLoader.h>      // ALIRUNLOADER_H
-    
-//====================================================================
-ClassImp(AliFMDSSDigitizer)
-
-//____________________________________________________________________
-void
-AliFMDSSDigitizer::SumContributions(AliFMD* fmd) 
-{
-  AliFMDDebug(1, ("Runnin our version of SumContributions"));
-
-  // Sum energy deposited contributions from each hit in a cache
-  // (fEdep).  
-  if (!fRunLoader) 
-    Fatal("SumContributions", "no run loader");
-  
-  // Clear array of deposited energies 
-  fEdep.Reset();
-  
-  // Get the FMD loader 
-  AliLoader* inFMD = fRunLoader->GetLoader("FMDLoader");
-  // And load the hits 
-  inFMD->LoadSDigits("READ");
-  
-  // Get the tree of hits 
-  TTree* sdigitsTree = inFMD->TreeS();
-  if (!sdigitsTree)  {
-    // Try again 
-    // inFMD->LoadSDigits("READ");
-    // sdigitsTree = inFMD->TreeH();
-    AliError("No sdigit tree from manager");
-  }
-  
-  // Get the FMD branch 
-  TBranch* sdigitsBranch = sdigitsTree->GetBranch("FMD");
-  if (sdigitsBranch) fmd->SetSDigitsAddressBranch(sdigitsBranch);
-  else            AliFatal("Branch FMD hit not found");
-  
-  // Get a list of hits from the FMD manager 
-  TClonesArray *fmdSDigits = fmd->SDigits();
-  
-  // Get number of entries in the tree 
-  Int_t nevents  = Int_t(sdigitsTree->GetEntries());
-  
-  AliFMDParameters* param = AliFMDParameters::Instance();
-  Int_t read = 0;
-  // Loop over the events in the 
-  for (Int_t event = 0; event < nevents; event++)  {
-    // Read in entry number `event' 
-    read += sdigitsBranch->GetEntry(event);
-    
-    // Get the number of sdigits 
-    Int_t nsdigits = fmdSDigits->GetEntries ();
-    AliFMDDebug(1, ("Got %5d SDigits", nsdigits));
-    for (Int_t sdigit = 0; sdigit < nsdigits; sdigit++) {
-      // Get the sdigit number `sdigit'
-      AliFMDSDigit* fmdSDigit = 
-       static_cast<AliFMDSDigit*>(fmdSDigits->UncheckedAt(sdigit));
-      
-      // Extract parameters 
-      UShort_t detector = fmdSDigit->Detector();
-      Char_t   ring     = fmdSDigit->Ring();
-      UShort_t sector   = fmdSDigit->Sector();
-      UShort_t strip    = fmdSDigit->Strip();
-      Float_t  edep     = fmdSDigit->Edep();
-      // UShort_t minstrip = param->GetMinStrip(detector, ring, sector, strip);
-      // UShort_t maxstrip = param->GetMaxStrip(detector, ring, sector, strip);
-      // Check if strip is `dead' 
-      AliFMDDebug(10, ("SDigit in FMD%d%c[%2d,%3d]=%f",
-                     detector, ring, sector, strip, edep));
-      if (param->IsDead(detector, ring, sector, strip)) { 
-       AliFMDDebug(5, ("FMD%d%c[%2d,%3d] is marked as dead", 
-                        detector, ring, sector, strip));
-       continue;
-      }
-      // Check if strip is out-side read-out range 
-      // if (strip < minstrip || strip > maxstrip) {
-      //   AliFMDDebug(5, ("FMD%d%c[%2d,%3d] is outside range [%3d,%3d]", 
-      //                   detector,ring,sector,strip,minstrip,maxstrip));
-      //   continue;
-      // }
-       
-      // Give warning in case of double sdigit 
-      if (fEdep(detector, ring, sector, strip).fEdep != 0)
-       AliFMDDebug(5, ("Double sdigit in %d%c(%d,%d)", 
-                        detector, ring, sector, strip));
-      
-      // Sum energy deposition
-      fEdep(detector, ring, sector, strip).fEdep  += edep;
-      fEdep(detector, ring, sector, strip).fN     += 1;
-      // Add this to the energy deposited for this strip
-    }  // sdigit loop
-  } // event loop
-  AliFMDDebug(3, ("Size of cache: %d bytes, read %d bytes", 
-                  sizeof(fEdep), read));
-}
-
-//____________________________________________________________________
-//
-// EOF
-// 
-
-
-
-
diff --git a/FMD/AliFMDSSDigitizer.h b/FMD/AliFMDSSDigitizer.h
deleted file mode 100644 (file)
index 7d7c443..0000000
+++ /dev/null
@@ -1,80 +0,0 @@
-#ifndef ALIFMDSSDIGITIZER_H
-#define ALIFMDSSDIGITIZER_H
-/* Copyright(c) 1998-2000, ALICE Experiment at CERN, All rights
- * reserved. 
- *
- * See cxx source for full Copyright notice                               
- */
-// Classses to make SDigits into Digits 
-//    
-//    Digits consists of
-//    - Detector #
-//    - Ring ID                                             
-//    - Sector #     
-//    - Strip #
-//    - ADC count in this channel                                  
-//
-//    Summable digits consists of      
-//    - Detector #
-//    - Ring ID                                             
-//    - Sector #     
-//    - Strip #
-//    - Total energy deposited in the strip
-//    - ADC count in this channel                                  
-//
-/** @file    AliFMDSSDigitizer.h
-    @author  Christian Holm Christensen <cholm@nbi.dk>
-    @date    Mon Mar 27 12:38:26 2006
-    @brief   FMD Digitizers declaration
-    @ingroup FMD_sim
-*/
-#ifndef ALIFMDDIGITIZER_H
-# include <AliFMDDigitizer.h>
-#endif
-
-//====================================================================
-class TClonesArray;
-class AliFMD;
-class AliLoader;
-class AliRunLoader;
-class AliFMDDigit;
-
-
-
-//====================================================================
-/** @class AliFMDSSDigitizer
-    @brief Concrete digitizer to make digits from hits.  See also
-    AliFMDBaseDigitizer documentation.  
-    @ingroup FMD_sim
- */
-class AliFMDSSDigitizer : public AliFMDDigitizer 
-{
-public:
-  /** CTOR */
-  AliFMDSSDigitizer() : AliFMDDigitizer() {}
-  /** CTOR 
-      @param manager Manager of digitization */
-  AliFMDSSDigitizer(AliRunDigitizer * manager)
-    : AliFMDDigitizer(manager) {}
-  /** DTOR */
-  virtual ~AliFMDSSDigitizer() {}
-protected:
-  /** Sum contributions from SDigits 
-      @param fmd Pointr to loaded AliFMD  */
-  void SumContributions(AliFMD* fmd);
-  
-  ClassDef(AliFMDSSDigitizer,1) // Make Digits from Hits
-};
-
-
-#endif
-//____________________________________________________________________
-//
-// Local Variables:
-//   mode: C++
-// End:
-//
-//
-// EOF
-//
-
index a181085..03aa1ff 100644 (file)
Binary files a/FMD/Align/Data/Run0_999999999_v0_s0.root and b/FMD/Align/Data/Run0_999999999_v0_s0.root differ
index 596cd94..7e28957 100644 (file)
Binary files a/FMD/Calib/AltroMap/Run0_999999_v0_s0.root and b/FMD/Calib/AltroMap/Run0_999999_v0_s0.root differ
index c651b9b..665e222 100644 (file)
Binary files a/FMD/Calib/Dead/Run0_999999_v0_s0.root and b/FMD/Calib/Dead/Run0_999999_v0_s0.root differ
index bbe5cbf..e551660 100644 (file)
Binary files a/FMD/Calib/Pedestal/Run0_999999_v0_s0.root and b/FMD/Calib/Pedestal/Run0_999999_v0_s0.root differ
index e3ea3b2..f02337a 100644 (file)
Binary files a/FMD/Calib/PulseGain/Run0_999999_v0_s0.root and b/FMD/Calib/PulseGain/Run0_999999_v0_s0.root differ
index b5e5242..43f10a9 100644 (file)
Binary files a/FMD/Calib/SampleRate/Run0_999999_v0_s0.root and b/FMD/Calib/SampleRate/Run0_999999_v0_s0.root differ
index ba92eb4..8b68d63 100644 (file)
Binary files a/FMD/Calib/StripRange/Run0_999999_v0_s0.root and b/FMD/Calib/StripRange/Run0_999999_v0_s0.root differ
index e4fad74..5d81a20 100644 (file)
Binary files a/FMD/Calib/ZeroSuppression/Run0_999999_v0_s0.root and b/FMD/Calib/ZeroSuppression/Run0_999999_v0_s0.root differ
index a6ed4ce..d11933c 100644 (file)
@@ -27,8 +27,9 @@
 #pragma link C++ class  AliFMDv1+;
 #pragma link C++ class  AliFMDBaseDigitizer+;
 #pragma link C++ class  AliFMDDigitizer+;
-#pragma link C++ class  AliFMDSDigitizer+;
-#pragma link C++ class  AliFMDSSDigitizer+;
+// #pragma link C++ class  AliFMDSDigitizer+;
+// #pragma link C++ class  AliFMDSSDigitizer+;
+#pragma link C++ class  AliFMDHitDigitizer+;
 #pragma link C++ class  AliFMDRawWriter+;
 #pragma link C++ class  AliFMDQADataMakerSim+;
 
index e802cbc..60c51fd 100644 (file)
@@ -9,12 +9,14 @@ SRCS          =  AliFMD.cxx                           \
                   AliFMDHit.cxx                        \
                   AliFMDBaseDigitizer.cxx              \
                   AliFMDDigitizer.cxx                  \
-                  AliFMDSDigitizer.cxx                 \
-                  AliFMDSSDigitizer.cxx                \
+                  AliFMDHitDigitizer.cxx               \
                   AliFMDEdepMap.cxx                    \
                   AliFMDRawWriter.cxx                  \
                   AliFMDQADataMakerSim.cxx             
 
+#                 AliFMDSDigitizer.cxx                 \
+#                 AliFMDSSDigitizer.cxx                
+
 HDRS           =  $(SRCS:.cxx=.h) AliFMDEdepHitPair.h
 DHDR           := FMDsimLinkDef.h
 EINCLUDE       := RAW
diff --git a/FMD/scripts/PatternSDigits.C b/FMD/scripts/PatternSDigits.C
new file mode 100644 (file)
index 0000000..6980bcc
--- /dev/null
@@ -0,0 +1,29 @@
+//____________________________________________________________________
+//
+// $Id: PatternDigits.C 16307 2006-12-27 13:37:57Z cholm $
+//
+// Draw hits in the specialised FMD event display 
+//
+/** Display hits 
+    @ingroup FMD_script
+ */
+void
+PatternSDigits()
+{
+  AliLog::SetModuleDebugLevel("FMD", 1);
+  AliCDBManager* cdb = AliCDBManager::Instance();
+  cdb->SetDefaultStorage("local://$ALICE_ROOT");
+  cdb->SetRun(0);
+  AliFMDParameters::Instance()->Init();
+  gSystem->Load("libFMDutil.so");
+  AliFMDPattern* d = new AliFMDPattern;
+  d->SetName("sdigit");
+  d->SetTitle("Summable digits");
+  d->AddLoad(AliFMDInput::kSDigits);
+  d->Run();
+}
+
+//____________________________________________________________________
+//
+// EOF
+//