Changes for #87331: Combined commit MUON+HLT
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 3 Oct 2011 11:15:23 +0000 (11:15 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 3 Oct 2011 11:15:23 +0000 (11:15 +0000)
AliMUONDigitCalibrator

  Simplified the ctors interface (removed a default parameter)

AliMUONReconstructor

  Propagate AliMUONDigitCalibrator interface change
  Change order of delete calls in the destructors (to avoid access dead OCDB objects in dtor of calibrator)

AliMUONTrackerDataMaker

  Propagate AliMUONDigitCalibrator interface change

AliMUON

  Propagate changes in AliMUONDigitizerV3 (e.g. pass the recoparams when creating the digitizer)

AliMUONVDigit
AliMUONRealDigit
AliMUONDigit

All digits now have the ChargeInFC method defined

AliMUONDigitizerV3

  Now uses the RecoParams to know how to decalibrate.
  Now assumes that all digits to be decalibrated have their charge in fC, as it should be...

AliMUONSDigitizerV2
AliMUONResponseV0

  Simulated charges are now in fC.

runSimulation.C
runReconstruction.C
AlirootRun_MUONtest.sh

  One more step towards removal of specific OCDB storages for simulations : take
  MUON/Calib/Gains from raw OCDB.
  Added an option "-b anchorRunNumber" to AlirootRun_MUONtest.sh in order to test realistic simulations
  (i.e. using an anchor run). Note that this option references a couple of "private" OCDB files. This is
  only an interim solution...

Config.C

  Added a parameter to know when we're doing realistic simulations, in which case we must
  instantiante the ITS to get the correct propagation of the simulated vertex to the reconstruction.

AliMUONRecoParam.cxx

  Added eventspecie to Print()

Laurent

20 files changed:
HLT/MUON/OnlineAnalysis/AliHLTMUONClusterFinderComponent.cxx
MUON/AliMUON.cxx
MUON/AliMUON.h
MUON/AliMUONDigitCalibrator.cxx
MUON/AliMUONDigitCalibrator.h
MUON/AliMUONDigitizerV3.cxx
MUON/AliMUONDigitizerV3.h
MUON/AliMUONRealDigit.h
MUON/AliMUONRecoParam.cxx
MUON/AliMUONReconstructor.cxx
MUON/AliMUONResponseV0.cxx
MUON/AliMUONSDigitizerV2.cxx
MUON/AliMUONTrackerDataMaker.cxx
MUON/AliMUONVDigit.cxx
MUON/AliMUONVDigit.h
MUON/AlirootRun_MUONtest.sh
MUON/Config.C
MUON/MUONefficiency.C
MUON/runReconstruction.C
MUON/runSimulation.C

index d5cb807..42d23a1 100644 (file)
@@ -592,9 +592,7 @@ int AliHLTMUONClusterFinderComponent::ReadConfigFromCDB(
                AliMUONSimpleClusterServer* clusterServer = NULL;
                try
                {
-                       calibrator = new AliMUONDigitCalibrator(
-                                       *fCalibrationData, fRecoParam->GetCalibrationMode()
-                               );
+                       calibrator = new AliMUONDigitCalibrator(*fCalibrationData, fRecoParam);
                
                        clusterFinder = AliMUONReconstructor::CreateClusterFinder(
                                        fRecoParam->GetClusteringMode()
index adb3ab3..31c0bb3 100644 (file)
@@ -445,7 +445,7 @@ AliDigitizer* AliMUON::CreateDigitizer(AliRunDigitizer* manager) const
   
   AliMUONDigitizerV3* digitizer = new AliMUONDigitizerV3(manager, fDigitizerWithNoise);
   AliMUONDigitizerV3::SetNSigmas(fDigitizerNSigmas);
-  digitizer->SetCalibrationData(fCalibrationData);
+  digitizer->SetCalibrationData(fCalibrationData,GetRecoParam());
   return digitizer;
 }
 
@@ -540,34 +540,14 @@ Bool_t AliMUON::Raw2SDigits(AliRawReader* rawReader)
        
   if (!fDigitCalibrator)
   {
-    AliMUONRecoParam* recoParam = 0x0;
-    
-    AliCDBEntry* entry = AliCDBManager::Instance()->Get("MUON/Calib/RecoParam");
-    
-    if (entry) 
-    {      
-      // load recoParam according OCDB content (single or array)
-      if (!(recoParam = dynamic_cast<AliMUONRecoParam*>(entry->GetObject()))) 
-      {        
-        TObjArray* recoParamArray = static_cast<TObjArray*>(entry->GetObject());
-        
-        for(Int_t i = 0; i < recoParamArray->GetEntriesFast(); ++i)
-        {
-          recoParam = static_cast<AliMUONRecoParam*>(recoParamArray->UncheckedAt(i));
-          if (recoParam && recoParam->IsDefault()) break;
-          recoParam = 0x0;
-        }        
-      }      
-    }
+    AliMUONRecoParam* recoParam = GetRecoParam();
     
     if (!recoParam)
     {
       AliFatal("Cannot work without recoparams !");
     }
     
-    TString calibMode = recoParam->GetCalibrationMode();
-  
-    fDigitCalibrator = new AliMUONDigitCalibrator(*fCalibrationData,recoParam,calibMode.Data());
+    fDigitCalibrator = new AliMUONDigitCalibrator(*fCalibrationData,recoParam);
   }
   
        fDigitMaker->Raw2Digits(rawReader,sDigitStore,triggerStore);
@@ -667,4 +647,29 @@ Int_t  AliMUON::GetDigitizerWithNoise() const
     
 }  
 
+//____________________________________________________________________
+AliMUONRecoParam* AliMUON::GetRecoParam() const
+{
+  AliMUONRecoParam* recoParam = 0x0;
+
+  AliCDBEntry* entry = AliCDBManager::Instance()->Get("MUON/Calib/RecoParam");
+
+  if (entry) 
+  {      
+    // load recoParam according OCDB content (single or array)
+    if (!(recoParam = dynamic_cast<AliMUONRecoParam*>(entry->GetObject()))) 
+    {        
+      TObjArray* recoParamArray = static_cast<TObjArray*>(entry->GetObject());
+      
+      for(Int_t i = 0; i < recoParamArray->GetEntriesFast(); ++i)
+      {
+        recoParam = static_cast<AliMUONRecoParam*>(recoParamArray->UncheckedAt(i));
+        if (recoParam && recoParam->IsDefault()) break;
+        recoParam = 0x0;
+      }        
+    }      
+  }
+  return recoParam;
+}
+
 
index 2763d39..99a6233 100644 (file)
@@ -28,6 +28,7 @@ class AliMUONDigitMaker;
 class AliMUONVHitStore;
 class AliMUONCalibrationData;
 class AliMUONDigitCalibrator;
+class AliMUONRecoParam;
 
 class AliLoader;
 
@@ -150,6 +151,8 @@ class AliMUON : public  AliDetector
 
     const AliMUONGeometry* GetGeometry() const;
 
+  AliMUONRecoParam* GetRecoParam() const;
+  
     Int_t                 fNCh;                ///< Number of chambers   
     Int_t                 fNTrackingCh;        ///< Number of tracking chambers*
     Int_t                 fSplitLevel;         ///< Splitlevel when making branches in outfiles.
@@ -192,9 +195,9 @@ class AliMUON : public  AliDetector
     
     AliMUONCalibrationData* fCalibrationData; ///< pointer of calibration data
 
-  AliMUONDigitCalibrator* fDigitCalibrator; ///< digit calibrator (for raw2sdigits)
+  AliMUONDigitCalibrator* fDigitCalibrator; //!< digit calibrator (for raw2sdigits)
   
-    ClassDef(AliMUON,24)  // MUON Detector base class
+    ClassDef(AliMUON,25)  // MUON Detector base class
 };
 #endif
 
index aff3997..86a4d62 100644 (file)
@@ -68,7 +68,7 @@ const Int_t AliMUONDigitCalibrator::fgkGain(2);
 const Int_t AliMUONDigitCalibrator::fgkInjectionGain(3);
 
 //_____________________________________________________________________________
-AliMUONDigitCalibrator::AliMUONDigitCalibrator(Int_t runNumber, const char* calibMode)
+AliMUONDigitCalibrator::AliMUONDigitCalibrator(Int_t runNumber)
 : TObject(),
 fLogger(new AliMUONLogger(20000)),
 fStatusMaker(0x0),
@@ -93,6 +93,7 @@ fMask(0)
     if ( o->IsA() == TObjArray::Class() )
     {
       TObjArray* a = static_cast<TObjArray*>(o);
+//      a->SetOwner(kTRUE); // FIXME: this should be done but somehow makes the reco crash at the end at cleaning stage... investigate why ?
       TIter next(a);
       AliMUONRecoParam* p;
       while ( ( p = static_cast<AliMUONRecoParam*>(next()) ))
@@ -115,13 +116,12 @@ fMask(0)
   
   AliMUONCalibrationData calib(runNumber);
   
-  Ctor(calibMode,calib,recoParam,kFALSE);
+  Ctor(calib,recoParam,kFALSE);
 }
 
 //_____________________________________________________________________________
 AliMUONDigitCalibrator::AliMUONDigitCalibrator(const AliMUONCalibrationData& calib,
-                                               const AliMUONRecoParam* recoParams,
-                                               const char* calibMode)
+                                               const AliMUONRecoParam* recoParams)
 : TObject(),
 fLogger(new AliMUONLogger(20000)),
 fStatusMaker(0x0),
@@ -137,12 +137,11 @@ fMask(0)
 {
   /// ctor
   
-  Ctor(calibMode,calib,recoParams);
+  Ctor(calib,recoParams);
 }
 
 //_____________________________________________________________________________
-AliMUONDigitCalibrator::AliMUONDigitCalibrator(const AliMUONCalibrationData& calib,
-                                               const char* calibMode)
+AliMUONDigitCalibrator::AliMUONDigitCalibrator(const AliMUONCalibrationData& calib, int /*b*/)
 : TObject(),
 fLogger(new AliMUONLogger(20000)),
 fStatusMaker(0x0),
@@ -158,19 +157,19 @@ fMask(0)
 {
   /// ctor
   
-  Ctor(calibMode,calib,0x0);
+  Ctor(calib,0x0);
 }
 
 //_____________________________________________________________________________
 void
-AliMUONDigitCalibrator::Ctor(const char* calibMode,
-                             const AliMUONCalibrationData& calib,
+AliMUONDigitCalibrator::Ctor(const AliMUONCalibrationData& calib,
                              const AliMUONRecoParam* recoParams,
                              Bool_t deferredInitialization)
 {
   /// designated ctor
   
-  TString cMode(calibMode);
+  TString cMode("NOGAIN");
+  if (recoParams) cMode=recoParams->GetCalibrationMode();
   cMode.ToUpper();
   
   if ( cMode == "NOGAIN" ) 
@@ -195,7 +194,7 @@ AliMUONDigitCalibrator::Ctor(const char* calibMode,
        }  
   else
   {
-    AliError(Form("Invalid calib mode = %s. Will use NOGAIN instead",calibMode));
+    AliError(Form("Invalid calib mode = %s. Will use NOGAIN instead",cMode.Data()));
     fApplyGains = fgkNoGain;
   }
   
@@ -292,6 +291,7 @@ AliMUONDigitCalibrator::Calibrate(AliMUONVDigitStore& digitStore)
     }
     
     digit->Calibrated(kTRUE);
+    digit->ChargeInFC(kTRUE);
     
     Float_t charge(0.0);
     Int_t statusMap;
@@ -302,7 +302,7 @@ AliMUONDigitCalibrator::Calibrate(AliMUONVDigitStore& digitStore)
     Bool_t ok = IsValidDigit(digit->DetElemId(),digit->ManuId(),digit->ManuChannel(),&statusMap);
     
     digit->SetStatusMap(statusMap);
-    
+
     if (ok)
     {
       charge = CalibrateDigit(digit->DetElemId(),digit->ManuId(),digit->ManuChannel(),
@@ -315,6 +315,7 @@ AliMUONDigitCalibrator::Calibrate(AliMUONVDigitStore& digitStore)
     
     digit->SetCharge(charge);
     digit->Saturated(isSaturated);
+    
   }
 }
 
@@ -455,6 +456,9 @@ AliMUONDigitCalibrator::IsValidDigit(Int_t detElemId, Int_t manuId, Int_t manuCh
 {
   /// Check if a given pad is ok or not.
   
+  // initialize the statusmap to dead by default
+  if (statusMap) *statusMap = AliMUONPadStatusMapMaker::SelfDeadMask();
+
   // First a protection against bad input parameters
   AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
   if (!de) return kFALSE; // not existing DE
@@ -473,7 +477,7 @@ AliMUONDigitCalibrator::IsValidDigit(Int_t detElemId, Int_t manuId, Int_t manuCh
   // ok, now we have a valid channel number, so let's see if that pad
   // behaves or not ;-)
   
-  Int_t sm = fStatusMapMaker->StatusMap(detElemId,manuId,manuChannel);
+  Int_t sm = StatusMap(detElemId,manuId,manuChannel);
   
   if (statusMap) *statusMap = sm;
   
index d55b099..2ff057f 100644 (file)
@@ -30,14 +30,12 @@ class AliMUONDigitCalibrator : public TObject
 {
 public:
 
-  AliMUONDigitCalibrator(Int_t runNumber, const char* calibMode="NOGAIN");
+  AliMUONDigitCalibrator(Int_t runNumber);
   
   AliMUONDigitCalibrator(const AliMUONCalibrationData& calib, 
-                         const AliMUONRecoParam* recoParams,
-                         const char* calibMode="NOGAIN");
+                         const AliMUONRecoParam* recoParams);
   
-  AliMUONDigitCalibrator(const AliMUONCalibrationData& calib, 
-                         const char* calibMode="NOGAIN");
+  AliMUONDigitCalibrator(const AliMUONCalibrationData& calib, int b);
   
   virtual ~AliMUONDigitCalibrator();
   
@@ -61,8 +59,7 @@ private:
   /// Not implemented
   AliMUONDigitCalibrator& operator=(const AliMUONDigitCalibrator& other);
   
-  void Ctor(const char* calibMode,
-            const AliMUONCalibrationData& calib,
+  void Ctor(const AliMUONCalibrationData& calib,
             const AliMUONRecoParam* recoParams,
             Bool_t deferredInitialization=kTRUE);
   
index 172bdc9..4f4ac60 100644 (file)
@@ -28,6 +28,7 @@
 #include "AliMUONVCalibParam.h"
 #include "AliMUONVDigitStore.h"
 #include "AliMUONGeometryTransformer.h" //ADDED for trigger noise
+#include "AliMUONRecoParam.h"
 #include "AliMUONTriggerChamberEfficiency.h"
 #include "AliMUONTriggerUtilities.h"
 
@@ -61,6 +62,7 @@
 
 //-----------------------------------------------------------------------------
 /// \class AliMUONDigitizerV3
+///
 /// The digitizer is performing the transformation to go from SDigits (digits
 /// w/o any electronic noise) to Digits (w/ electronic noise, and decalibration)
 /// 
 /// (for performance reason mainly, and because anyway we know we have to do it
 /// here, at the digitization level).
 ///
+/// August 2011. In order to remove the need for specific MC OCDB storages,
+/// we're introducing a dependence of simulation on AliMUONRecoParam (stored
+/// in MUON/Calib/RecoParam in OCDB), which is normally (or conceptually, if
+/// you will) only a reconstruction object. That's not a pretty solution, but,
+/// well, we have to do it...
+/// This dependence comes from the fact that we must know how to decalibrate
+/// the digits, so that the decalibration (done here) - calibration (done during
+/// reco) process is (as much as possible) neutral.
+///
+///
 /// \author Laurent Aphecetche
+///
 //-----------------------------------------------------------------------------
 
 namespace
@@ -110,6 +123,7 @@ fTriggerStore(new AliMUONTriggerStoreV1),
 fDigitStore(0x0),
 fOutputDigitStore(0x0),
 fInputDigitStores(0x0),
+fRecoParam(0x0),
 fTriggerEfficiency(0x0),
 fTriggerUtilities(0x0),
 fEfficiencyResponse(2*AliMUONConstants::NTriggerCh()*AliMUONConstants::NTriggerCircuit())
@@ -153,7 +167,14 @@ AliMUONDigitizerV3::ApplyResponseToTrackerDigit(AliMUONVDigit& digit, Bool_t add
   /// - add some electronics noise (thus leading to a realistic adc), if requested to do so
   /// - sets the signal to zero if below 3*sigma of the noise
 
-  Float_t charge = digit.IsChargeInFC() ? digit.Charge()*AliMUONConstants::FC2ADC() : digit.Charge();
+  Float_t charge = digit.Charge();
+  
+  if (!digit.IsChargeInFC())
+  {
+    charge *= AliMUONConstants::DefaultADC2MV()*AliMUONConstants::DefaultA0()*AliMUONConstants::DefaultCapa();
+    fLogger->Log("CHECK ME ! WAS NOT SUPPOSED TO BE HERE !!! ARE YOU RECONSTRUCTING OLD SIMULATIONS ? ");
+    AliError("CHECK ME ! WAS NOT SUPPOSED TO BE HERE !!! ARE YOU RECONSTRUCTING OLD SIMULATIONS ? ");
+  }
   
   // We set the charge to 0, as the only relevant piece of information
   // after Digitization is the ADC value.  
@@ -193,7 +214,8 @@ AliMUONDigitizerV3::ApplyResponseToTrackerDigit(AliMUONVDigit& digit, Bool_t add
   }    
 
   Int_t adc = DecalibrateTrackerDigit(*pedestal,*gain,manuChannel,charge,addNoise,
-                                      digit.IsNoiseOnly());
+                                      digit.IsNoiseOnly(),
+                                      fRecoParam->GetCalibrationMode());
   
   digit.SetADC(adc);
 }
@@ -293,34 +315,51 @@ AliMUONDigitizerV3::DecalibrateTrackerDigit(const AliMUONVCalibParam& pedestals,
                                             Int_t channel,
                                             Float_t charge,
                                             Bool_t addNoise,
-                                            Bool_t noiseOnly)
+                                            Bool_t noiseOnly,
+                                            const TString& calibrationMode)
 {
   /// Decalibrate (i.e. go from charge to adc) a tracker digit, given its
   /// pedestal and gain parameters.
   /// Must insure before calling that channel is valid (i.e. between 0 and
   /// pedestals or gains->GetSize()-1, but also corresponding to a valid channel
   /// otherwise results are not predictible...)
-
+  ///
+  /// This method is completely tied to what happens in its sister method :
+  /// AliMUONDigitCalibrator::CalibrateDigit, which is doing the reverse work...
+  ///
+  
   static const Int_t kMaxADC = (1<<12)-1; // We code the charge on a 12 bits ADC.
   
+  Bool_t nogain = calibrationMode.Contains("NOGAIN");
+  
+  Float_t a1(0.0);
+  Int_t thres(4095);
+  Int_t qual(0xF);
+  Float_t capa(AliMUONConstants::DefaultCapa()); // capa = 0.2 and a0 = 1.25
+  Float_t a0(AliMUONConstants::DefaultA0());  // is equivalent to gain = 4 mV/fC
+  Float_t adc2mv(AliMUONConstants::DefaultADC2MV()); // 1 ADC channel = 0.61 mV
+               
+  if ( ! nogain )
+  {
+    a0 = gains.ValueAsFloat(channel,0);
+    a1 = gains.ValueAsFloat(channel,1);
+    thres = gains.ValueAsInt(channel,2);
+    qual = gains.ValueAsInt(channel,3);
+  }
+  
   Float_t pedestalMean = pedestals.ValueAsFloat(channel,0);
   Float_t pedestalSigma = pedestals.ValueAsFloat(channel,1);
   
   AliDebugClass(1,Form("DE %04d MANU %04d CH %02d PEDMEAN %7.2f PEDSIGMA %7.2f",
                       pedestals.ID0(),pedestals.ID1(),channel,pedestalMean,pedestalSigma));
   
-  Float_t a0 = gains.ValueAsFloat(channel,0);
-  Float_t a1 = gains.ValueAsFloat(channel,1);
-  Int_t thres = gains.ValueAsInt(channel,2);
-  Int_t qual = gains.ValueAsInt(channel,3);
-
   if ( qual <= 0 ) return 0;
   
   Float_t chargeThres = a0*thres;
   
   Float_t padc(0); // (adc - ped) value
   
-  if ( charge <= chargeThres || TMath::Abs(a1) < 1E-12 ) 
+  if ( nogain || charge <= chargeThres || TMath::Abs(a1) < 1E-12 ) 
   {
     // linear part only
     
@@ -331,6 +370,11 @@ AliMUONDigitizerV3::DecalibrateTrackerDigit(const AliMUONVCalibParam& pedestals,
   }
   else 
   {
+    // FIXME: when we'll use capacitances and real gains, revise this part
+    // to take capa properly into account...
+    
+    AliWarningClass("YOU PROBABLY NEED TO REVISE THIS PART OF CODE !!!");
+    
     // linear + parabolic part
     Double_t qt = chargeThres - charge;
     Double_t delta = a0*a0-4*a1*qt;
@@ -371,6 +415,8 @@ AliMUONDigitizerV3::DecalibrateTrackerDigit(const AliMUONVCalibParam& pedestals,
     }
   }
   
+  padc /= capa*adc2mv;
+  
   Int_t adc(0);
   
   Float_t adcNoise = 0.0;
@@ -907,3 +953,15 @@ AliMUONDigitizerV3::NoiseFunction()
   return f;
 }
 
+//_____________________________________________________________________________
+void AliMUONDigitizerV3::SetCalibrationData(AliMUONCalibrationData* calibrationData, 
+                                            AliMUONRecoParam* recoParam) 
+{
+  fCalibrationData = calibrationData;
+  fRecoParam = recoParam;
+  if (!fRecoParam)
+  {
+    AliError("Cannot work (e.g. decalibrate) without recoparams !");
+  }
+}
+
index 409608b..7f3d082 100644 (file)
@@ -29,6 +29,7 @@ class AliLoader;
 class AliMUONVTriggerStore;
 class AliMUONTriggerElectronics;
 class AliMUONVCalibParam;
+class AliMUONRecoParam;
 class AliMUONTriggerChamberEfficiency;
 class AliMUONTriggerUtilities;
 
@@ -49,11 +50,11 @@ public:
                                        Int_t channel,
                                        Float_t charge,
                                        Bool_t addNoise=kFALSE,
-                                       Bool_t noiseOnly=kFALSE);
+                                       Bool_t noiseOnly=kFALSE,
+                                       const TString& calibrationMode="NOGAIN");
   
-  /// Set calibration data
-  void SetCalibrationData(AliMUONCalibrationData* calibrationData) 
-                          {fCalibrationData = calibrationData;}
+  /// Set calibration (and recoparam) data
+  void SetCalibrationData(AliMUONCalibrationData* calibrationData, AliMUONRecoParam* recoParam);
 
   /// Set the number of sigmas for pedestal cut
   static void SetNSigmas(Double_t nsigmas=4.0) { fgNSigmas = nsigmas; }
@@ -102,11 +103,12 @@ private:
   AliMUONVDigitStore* fDigitStore; //!< temporary digits
   AliMUONVDigitStore* fOutputDigitStore; //!< digits we'll output to disk
   TObjArray* fInputDigitStores; //!< input digit stores (one per input file
+  AliMUONRecoParam* fRecoParam; //!< reco params (to know how to decalibrate) (not owner)
   AliMUONTriggerChamberEfficiency* fTriggerEfficiency; //!< trigger efficiency map
   AliMUONTriggerUtilities* fTriggerUtilities; //!< Trigger utilities for masks
   TArrayI fEfficiencyResponse; //!< Local board efficiency response
   
-  ClassDef(AliMUONDigitizerV3,10) // MUON Digitizer V3-9
+  ClassDef(AliMUONDigitizerV3,11) // MUON Digitizer V3-11
 };
 
 #endif
index d6c30fb..031eede 100644 (file)
@@ -57,6 +57,11 @@ public:
   /// Set the calibration status
   virtual void Calibrated(Bool_t value) { SetBit(kCalibrated,value); }
   
+  /// Whether this digit has its charge already in fC
+  virtual Bool_t IsChargeInFC() const { return TestBit(kChargeInFC); }
+  /// Set the charge unit value
+  virtual void ChargeInFC(Bool_t value=kTRUE) { SetBit(kChargeInFC,value); }
+
   /// Whether this digit is part of a cluster or something else
   virtual Bool_t IsUsed() const { return TestBit(kUsed); }
   /// Set the used status
@@ -89,10 +94,11 @@ private:
   {
     kSaturated = BIT(20),  ///< to indicate that manas amplifier has saturated 
     kUsed = BIT(21),       ///< whether the digit is used (e.g. in a cluster)
-    kCalibrated = BIT(22)  ///< whether the digit has been calibrated or not 
+    kCalibrated = BIT(22),  ///< whether the digit has been calibrated or not 
+    kChargeInFC = BIT(23)   ///< whether the digit has a charge in fC or not
   };
   
-  ClassDef(AliMUONRealDigit,1) // Implementation of AliMUONVDigit
+  ClassDef(AliMUONRealDigit,2) // Implementation of AliMUONVDigit
 };
 
 #endif
index 7ef3777..d30ac34 100644 (file)
@@ -355,6 +355,8 @@ void AliMUONRecoParam::Print(Option_t *option) const
   
   if (IsDefault()) cout<<"\t\t*** Parameters used by default ***"<<endl;
   
+  cout << "Event Specie=" << GetEventSpecie() << endl;
+  
   cout<<Form("Calibration mode = %s",fCalibrationMode.Data())<<endl;
   cout<<Form("Clustering mode = %s",fClusteringMode.Data())<<endl;
   cout<<Form("Tracking mode = %s",fTrackingMode.Data())<<endl;
index 50688e1..7bdd6c1 100644 (file)
@@ -175,13 +175,12 @@ AliMUONReconstructor::~AliMUONReconstructor()
 
   AliDebug(1,"");
 
+  delete fDigitCalibrator;
+
   delete fDigitMaker;
   delete fDigitStore;
   delete fTransformer;
   delete fTriggerCircuit;
-  delete fDigitCalibrator;
-  delete fCalibrationData;
-  delete fClusterServer;
   delete fTriggerStore;
   delete fTrackStore;
   delete fClusterStore;
@@ -189,7 +188,9 @@ AliMUONReconstructor::~AliMUONReconstructor()
   delete fTriggerUtilities;
 
   delete AliMpSegmentation::Instance(false);
-  delete AliMpDDLStore::Instance(false);
+  delete AliMpDDLStore::Instance(false);  
+
+  delete fCalibrationData;
 }
 
 //_____________________________________________________________________________
@@ -533,9 +534,7 @@ AliMUONReconstructor::CreateCalibrator() const
     AliWarning("NOSTATUSMAP is obsolete");
   }
 
-  TString calibMode = GetRecoParam()->GetCalibrationMode();
-
-  fDigitCalibrator = new AliMUONDigitCalibrator(*fCalibrationData,GetRecoParam(),calibMode.Data());
+  fDigitCalibrator = new AliMUONDigitCalibrator(*fCalibrationData,GetRecoParam());
 }
 
 //_____________________________________________________________________________
index 65b9ad5..1f596e2 100644 (file)
@@ -271,6 +271,9 @@ AliMUONResponseV0::DisIntegrate(const AliMUONHit& hit, TList& digits, Float_t ti
     qtot = AliMUONConstants::ReducedQTot(qtot,timeDif);
   }
   
+  // Scale the charge to it'll (roughly) be in fC
+  qtot *= AliMUONConstants::DefaultADC2MV()*AliMUONConstants::DefaultA0()*AliMUONConstants::DefaultCapa();
+  
   // Get the charge correlation between cathodes.
   Float_t currentCorrel = TMath::Exp(gRandom->Gaus(0.0,ChargeCorrel()/2.0));
 
@@ -328,16 +331,19 @@ AliMUONResponseV0::DisIntegrate(const AliMUONHit& hit, TList& digits, Float_t ti
       Float_t qp = TMath::Abs(fMathieson->IntXY(lowerLeft.X(),lowerLeft.Y(),
                                                 upperRight.X(),upperRight.Y()));
             
-      Int_t icharge = Int_t(qp*qcath);
-      
-      if ( qp > fChargeThreshold )
+      if ( qp > fChargeThreshold && 
+           qp*qcath > AliMUONConstants::DefaultADC2MV()*AliMUONConstants::DefaultA0()*AliMUONConstants::DefaultCapa() )
       {
         // If we're above threshold, then we create a digit,
         // and fill it with relevant information, including electronics.
+        
+        // note that the second condition above is to be backward compatible (when 
+        // the sdigitizer was making a cut on Int_t(qp*qcath) > 0 and qcath was in ADC, not in fC)
+        
         AliMUONDigit* d = new AliMUONDigit(detElemId,pad.GetManuId(),
                                            pad.GetManuChannel(),cath);
         d->SetPadXY(pad.GetIx(),pad.GetIy());
-        d->SetCharge(icharge);
+        d->SetCharge(qp*qcath);
         digits.Add(d);   
       }       
       it->Next();
index 0960c20..3b00f87 100644 (file)
@@ -231,17 +231,15 @@ AliMUONSDigitizerV2::Exec(Option_t*)
     
     while ( ( d = static_cast<AliMUONVDigit*>(next()) ) )
     {
-      if ( d->Charge() > 0 ) // that check would be better in the disintegrate
-        // method, but to compare with old sdigitizer, it has to be there.
+      d->ChargeInFC(kTRUE);
+      
+      AliMUONVDigit* added = sDigitStore->Add(*d,AliMUONVDigitStore::kMerge);
+      if (!added)
       {
-        AliMUONVDigit* added = sDigitStore->Add(*d,AliMUONVDigitStore::kMerge);
-        if (!added)
-        {
-          AliError("Could not add digit to digitStore");
-        }
+        AliError("Could not add digit to digitStore");
       }
     }
-
+  
     treeS->Fill();
     
     loader->WriteSDigits("OVERWRITE");
index e640c03..92193f2 100644 (file)
@@ -268,7 +268,7 @@ AliMUONTrackerDataMaker::Ctor(const AliMUONRecoParam* recoParam,
       AliCDBManager::Instance()->SetDefaultStorage(storage);
     }
     
-    fDigitCalibrator = new AliMUONDigitCalibrator(*fCalibrationData,recoParam,calibMode);
+    fDigitCalibrator = new AliMUONDigitCalibrator(*fCalibrationData,recoParam);
     //FIXME: get the reco param from GUI and/or from OCDB if not used from the QA code ?
   }
 }
index 8d8107e..511e198 100644 (file)
 /// Also, if HasGeometryInformation is true, the digit knows the position and
 /// the (half) dimensions (in cm) of the pad it corresponds to.
 ///
+/// Note 1.
+///
+/// Please note that IsCalibrated and IsChargeInFC are two 
+/// concepts closely related, but not equivalent, at least for SDigits.
+///
+/// For instance a SDigit can have its charge in fC but not being calibrated.
+///
+/// { SDigits coming from a simulation are yet to be merged (i.e. the
+///   SDigitStore can contain several SDigits objects per channel), so, while
+///   their charge is in femto-coulomb, they are not calibrated (e.g. pedestal
+///   is not subtracted yet). }
+///
+/// Conversely, a calibrated (s)digit always has its charge in fC.
+///
 /// \author Laurent Aphecetche, Subatech
 //-----------------------------------------------------------------------------
 
@@ -210,12 +224,39 @@ void
 AliMUONVDigit::Print(Option_t* opt) const
 {
   /// Dump to screen.
+  ///
   /// If opt=="tracks", info on tracks are printed too.
+  /// 
+  /// The last part of the printout indicated the status of the digit :
+  /// (S) means that digit is saturated
+  /// (C) means that digit has been calibrated
+  /// [fC] means that digit's charge is in femto-coulombs (fC)
+  /// (U) means that digit is part of (has been used in) a cluster
+  /// (+) is noise-only digit (added by the simulation)
+  /// (X) has the IsConverted flag on (e.g. has been embedded)
+  
+  TString options(opt);
+  options.ToLower();
+
+  if ( options.Contains("zs") )
+  {
+    if ( IsCalibrated() && Charge() <= 0 )
+    {
+      return;
+    }
+    
+    if ( !IsCalibrated() && ADC() <= 0 )
+    {
+      return;
+    }
+  }
   
   cout << Form("<%s>: ID %12u DE %4d Cath %d (Ix,Iy)=(%3d,%3d) (Manu,Channel)=(%4d,%2d)"
                ", Charge=%7.2f",
                ClassName(),GetUniqueID(),
                DetElemId(),Cathode(),PadX(),PadY(),ManuId(),ManuChannel(),Charge());  
+  
+  
   if ( IsSaturated() ) 
   {
     cout << "(S)";
@@ -234,6 +275,15 @@ AliMUONVDigit::Print(Option_t* opt) const
     cout << "   ";
   }
 
+  if ( IsChargeInFC() )
+  {
+    cout << "[fC]";
+  }
+  else
+  {
+    cout << "    ";
+  }
+  
   if ( IsUsed() )
   {
     cout << "(U)";
@@ -243,10 +293,33 @@ AliMUONVDigit::Print(Option_t* opt) const
     cout << "   ";
   }
   
-  cout << Form(" ADC=%4d StatusMap=%04x",ADC(),StatusMap());
+  if ( IsNoiseOnly() )
+  {
+    cout << "(+)";
+  }
+  else
+  {
+    cout << "   ";
+  }
+  
+  if ( IsConverted() )
+  {
+    cout << "(X)";
+  }
+  else
+  {
+    cout << "   ";
+  }
+    
+  cout << Form(" ADC=%4d",ADC());
+  
+  if ( IsCalibrated() )
+  {
+    // StatusMap is not set before calibration has occured (e.g.
+    // SDigits cannot have it meaningfully filled)
+    cout << Form(" StatusMap=%04x",StatusMap());    
+  }
 
-  TString options(opt);
-  options.ToLower();
   if ( options.Contains("tracks") && HasMCInformation() )
   {
     cout << " Hit " << setw(3) << Hit();
index 86fb198..f77eafb 100644 (file)
@@ -64,14 +64,16 @@ public:
   /// Set the efficiencyApplied status
   virtual void EfficiencyApplied(Bool_t /*value*/=kTRUE) {}
   
-  /// Whether this digit has been calibrated or not
+  /// Whether this digit has been calibrated or not (see note 1 in AliMUONVDigit.cxx)
   virtual Bool_t IsCalibrated() const=0;
-  /// Set the calibrated status
+  /// Set the calibrated status (see note 1 in AliMUONVDigit.cxx)
   virtual void Calibrated(Bool_t value)=0;
 
-  /// Whether this digit has charge in femto coulomb
+  /// Whether this digit has charge in femto coulomb (see note 1 in AliMUONVDigit.cxx)
   virtual Bool_t IsChargeInFC() const { return kFALSE; }
-  
+  /// Set the unit value (see note 1 in AliMUONVDigit.cxx)
+  virtual void ChargeInFC(Bool_t value=kTRUE)=0;
+
   /// Whether or not this digit was obtained from a conversion (e.g. real to simulated)
   virtual Bool_t IsConverted() const { return kFALSE; }
 
index 7d181d5..dad00e9 100755 (executable)
@@ -22,17 +22,18 @@ CURDIR=`pwd`
 #RUN=0 # run number for OCDB access
 SEED=1234567 # random number generator seed
 SIMDIR="generated" # sub-directory where to move simulated files prior to reco
-DUMPEVENT=5 # event to be dump on files
+DUMPEVENT=5 # event to be dump on files (set to negative to skip dumps)
 
 SIMCONFIG="$ALICE_ROOT/MUON/"$MC"Config.C"
 EMBEDWITH="" # no embedding by default
+REALISTIC=0 # ideal simulation by default
 
 # next try to see if there are options of this script that want to change the
 # defaults
  
 EXIT=0
 
-while getopts "SRZX:srxzn:tg:p:d:c:e:" option
+while getopts "SRZX:srxzn:tg:p:d:c:e:b:" option
 do
   case $option in
     R ) RECONSTRUCTION=1;;
@@ -53,6 +54,10 @@ do
     g ) SEED=$OPTARG;;
     p ) RECOPTIONS=$OPTARG;; 
     e ) EMBEDWITH=$OPTARG;;
+    b ) 
+    REALISTIC=$OPTARG
+    RAW=0
+    ;;
     *     ) echo "Unimplemented option chosen."
     EXIT=1
     ;;
@@ -84,6 +89,7 @@ if [ $# -gt 0 ] || [ "$EXIT" -eq 1 ]; then
   echo "       -d full path to output directory (default $OUTDIR)"
   echo "       -c full path to configuration file for simulation (default $SIMCONFIG)"
   echo "       -e full path to a galice.root file relating to SDigits to be merged (embedding)"
+  echo "       -b runnumber (int) make a realistic simulation using runnumber as anchor (default 0=ideal simulation)"
   exit 4;
 fi
 
@@ -96,6 +102,9 @@ fi
 if [ -n "$EMBEDWITH" ]; then
   echo "Will embed simulation with $EMBEDWITH"
 fi
+if [ "$REALISTIC" -gt 0 ]; then
+  echo "Will use anchor run $REALISTIC"
+fi
 if [ "$RECONSTRUCTION" -eq 1 ]; then
 echo "Reconstruction options to be used : $RECOPTIONS"
 if [ "$RAW" -eq 0 ]; then
@@ -169,14 +178,17 @@ if [ "$SIMULATION" -eq 1 ]; then
 
   echo "Running simulation  ..."
 
-  aliroot -l -b -q runSimulation.C\($SEED,$NEVENTS,\""$SIMCONFIG"\"\,\""$EMBEDWITH"\"\) > $OUTDIR/testSim.out 2>&1
+  aliroot -l -b -q runSimulation.C\($SEED,$NEVENTS,\""$SIMCONFIG"\"\,\""$EMBEDWITH"\"\,$REALISTIC\) > $OUTDIR/testSim.out 2>&1
 
   mkdir $OUTDIR/$SIMDIR
 
   if [ "$RAW" -eq 1 ]; then
-    echo "Moving generated files to $SIMDIR"
-    mv $OUTDIR/*QA*.root $OUTDIR/*.log $OUTDIR/$SIMDIR
-    mv $OUTDIR/MUON*.root $OUTDIR/Kinematics*.root $OUTDIR/galice.root $OUTDIR/TrackRefs*.root $OUTDIR/$SIMDIR
+    if [ "$REALISTIC" -eq 0 ]; then # we can not move for realistic simulations as we need e.g. kinematics to propagate the simulated vertex to the reco.
+      echo "Moving generated files to $SIMDIR"
+      mv $OUTDIR/*QA*.root $OUTDIR/*.log $OUTDIR/$SIMDIR
+      mv $OUTDIR/MUON*.root $OUTDIR/TrackRefs*.root $OUTDIR/$SIMDIR
+      mv $OUTDIR/Kinematics*.root $OUTDIR/galice.root $OUTDIR/$SIMDIR
+    fi
   else  
     echo "Copying generated files to $SIMDIR"
     cp $OUTDIR/*QA*.root $OUTDIR/*.log $OUTDIR/$SIMDIR
@@ -194,6 +206,9 @@ if [ "$SIMULATION" -eq 1 ]; then
   if [ "$MC" = "g4" ]; then
     cp $ALICE_ROOT/MUON/geometry/geometry.root $OUTDIR
   fi 
+  
+  cp $OUTDIR/geometry.root $OUTDIR/$SIMDIR/geometry.root
+  
 fi
 
 ###############################################################################
@@ -205,8 +220,14 @@ fi
 if [ "$RECONSTRUCTION" -eq 1 ]; then
 
   if [ "$RAW" -eq 1 ]; then
-    rm -f galice.root 
+    if [ "$REALISTIC" -eq 0 ]; then
+      rm -f galice.root
+    fi
   fi  
+
+  if [ "$REALISTIC" -ne 0 ]; then
+    rm -f geometry.root
+  fi
   
   rm -f AliESD*.root *QA*.root
   
@@ -214,19 +235,23 @@ if [ "$RECONSTRUCTION" -eq 1 ]; then
 
   cd $OUTDIR
   
-  BOOLEMBED=kFALSE
+  RAWOCDB=kFALSE
   
   if [ -n "$EMBEDWITH" ]; then
-    BOOLEMBED=kTRUE
+    RAWOCDB=kTRUE
+  fi
+  
+  if [ "$REALISTIC" -gt 0 ]; then
+    RAWOCDB=kTRUE
   fi
   
   if [ "$RAW" -eq 1 ]; then
   
-    aliroot -l -b -q runReconstruction\.C\($SEED,\""$OUTDIR/raw.root"\",\""$RECOPTIONS"\",$BOOLEMBED\) > $OUTDIR/testReco.out 2>&1
+    aliroot -l -b -q runReconstruction\.C\($SEED,\""$OUTDIR/raw.root"\",\""$RECOPTIONS"\",$RAWOCDB\) > $OUTDIR/testReco.out 2>&1
 
   else
 
-    aliroot -l -b -q runReconstruction\.C\($SEED,\"""\",\""$RECOPTIONS"\",$BOOLEMBED\) > $OUTDIR/testReco.out  2>&1
+    aliroot -l -b -q runReconstruction\.C\($SEED,\"""\",\""$RECOPTIONS"\",$RAWOCDB\) > $OUTDIR/testReco.out  2>&1
   
   fi
   
@@ -272,6 +297,8 @@ EOF
       fi
     fi
   fi
+  
+if [ "$DUMPEVENT" -ge 0 ]; then
 
   echo "Running dumps for selected event ($DUMPEVENT) ..."
 
@@ -306,6 +333,8 @@ EOF
   fi
 fi
 
+fi
+
 echo "Finished"  
 echo "... see results in $OUTDIR"
 
index 65e8e41..5abda7c 100644 (file)
@@ -70,7 +70,8 @@
 void Config(const char* directory="", 
             const char* option="param", 
             const char* digitstore="AliMUONDigitStoreV2S",
-            bool forEmbedding=kFALSE)
+            bool forEmbedding=kFALSE,
+            bool forRealistic=kFALSE)
 {
   //=====================================================================
   // Config file for MUON test
@@ -99,7 +100,7 @@ void Config(const char* directory="",
     { gAlice->Fatal("Config.C","Can not instatiate the Run Loader");
       return; }
   rl->SetCompressionLevel(2);
-  rl->SetNumberOfEventsPerFile(100);
+  rl->SetNumberOfEventsPerFile(10000);
   gAlice->SetRunLoader(rl);
   //=======================================================================
   // For having more debuging messages
@@ -176,7 +177,11 @@ void Config(const char* directory="",
     gener->SetCutOnChild(1);
     gener->SetChildPhiRange(0.,360.);
     gener->SetChildThetaRange(171.0,178.0);
-    gener->SetOrigin(0,0,0);          //vertex position    gener->SetSigma(0,0,0);           //Sigma in (X,Y,Z) (cm) on IP position
+    gener->SetOrigin(0,0,0);          //vertex position    gener->SetSigma(0,0,0); //Sigma in (X,Y,Z) (cm) on IP position
+    if (forRealistic)
+    {
+      gener->SetVertexSmear(kPerEvent);
+    }
     gener->SetForceDecay(kDiMuon);
     gener->SetTrackingFlag(1);
     gener->Init();
@@ -275,8 +280,11 @@ void Config(const char* directory="",
     MUON->SetDigitizerWithNoise(0);
                MUON->SetConvertTrigger(true);
     
-    new AliITSv11Hybrid("ITS","ITS v11Hybrid");
-    
+    new AliITSv11Hybrid("ITS","ITS v11Hybrid");    
+  }
+  else if (forRealistic)
+  {
+    new AliITSv11Hybrid("ITS","ITS v11Hybrid");        
   }
   
   // Use non-high performance raw data decoder 
index 565b0db..6ed1bcc 100644 (file)
@@ -67,7 +67,7 @@
 #endif
 
 Bool_t MUONefficiency(const char* filename = "generated/galice.root", const char* esdFileName = "AliESDs.root",
-                     const char* geoFilename = "geometry.root", const char* ocdbPath = "local://$ALICE_ROOT/OCDB",
+                     const char* geoFilename = "generated/geometry.root", const char* ocdbPath = "local://$ALICE_ROOT/OCDB",
                      Int_t ExtrapToVertex = -1, Int_t ResType = 553, Int_t FirstEvent = 0, Int_t LastEvent = 1000000 )
 { 
 /// \param ExtrapToVertex (default -1) 
index 891e1eb..f586faf 100644 (file)
 //#include <TObjectTable.h>
 #endif
 
-void runReconstruction(int seed, const char* input, const char* recoptions, bool embedding)
+void runReconstruction(int seed, const char* input, const char* recoptions, bool rawocdb)
 { 
   AliCDBManager* man = AliCDBManager::Instance();
   
-  if ( embedding ) 
+  if ( rawocdb ) 
   {
-    cout << "**** WILL USE RAW OCDB AS WE'RE RECONSTRUCTING EMBEDDED DATA" << endl;
-    man->SetDefaultStorage("raw://");
-  }
+    cout << "**** WILL USE RAW OCDB" << endl;
+    man->SetDefaultStorage("raw://"); //alien://folder=/alice/data/2011/OCDB?cacheFold=/Users/laurent/OCDBcache");
+    man->SetSpecificStorage("ITS/Calib/RecoParam","alien://folder=/alice/cern.ch/user/p/ppillot/OCDB_PbPbSim");
+  } 
   else
   {
     man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
 
     man->SetSpecificStorage("GRP/GRP/Data",
                             Form("local://%s",gSystem->pwd()));
+
   }
   
   gRandom->SetSeed(seed);
   
   AliReconstruction* MuonRec = new AliReconstruction("galice.root");
   MuonRec->SetInput(gSystem->ExpandPathName(input));
-  MuonRec->SetRunReconstruction("MUON");
+  MuonRec->SetRunReconstruction("MUON ITS");
   MuonRec->SetFillESD("HLT");
   MuonRec->SetOption("HLT", "libAliHLTMUON.so");
-  MuonRec->SetNumberOfEventsPerFile(1000);
+  MuonRec->SetNumberOfEventsPerFile(10000);
   MuonRec->SetOption("MUON",recoptions);
   MuonRec->SetRunQA("MUON:ALL");
   MuonRec->SetQAWriteExpert(AliQAv1::kMUON);
index c7bf1fe..829154b 100644 (file)
@@ -35,7 +35,8 @@
 void runSimulation(int seed, 
                    int nevents, 
                    const char* config,
-                   const char* embedwith)
+                   const char* embedwith,
+                   int runnumber)
 { 
 // Uncoment following lines to run simulation with local residual mis-alignment
 // (generated via MUONGenerateGeometryData.C macro)
@@ -76,10 +77,30 @@ void runSimulation(int seed,
     
     cout << "***** EMBEDDING MODE : USING RAW OCDB" << endl;
     AliCDBManager::Instance()->SetDefaultStorage("raw://");
-    AliCDBManager::Instance()->SetSpecificStorage("local://$ALICE_ROOT/OCDB","MUON/Calib/Gains");
     AliCDBManager::Instance()->SetSpecificStorage("local://$ALICE_ROOT/OCDB","MUON/Align/Data");
     
   }
+  else if ( runnumber > 0 )
+  {
+    // simulation with anchor run
+
+    cout << "***** ANCHOR RUN MODE : USING RAW OCDB AS MUCH AS POSSIBLE" << endl;
+    cout << "*****                   AND TAKING VERTEX FROM OCDB IF AVAILABLE" << endl;
+  
+    // Last parameter of Config.C indicates we're doing realistic simulations, so we NEED
+    // the ITS in the geometry
+    gAlice->SetConfigFunction("Config(\"\", \"param\", \"AliMUONDigitStoreV2S\",kFALSE,kTRUE);");
+
+    AliCDBManager::Instance()->SetDefaultStorage("raw://");
+    // use something like : "alien://folder=/alice/data/2011/OCDB?cacheFold=/Users/laurent/OCDBcache" instead of "raw://"
+    // if getting slow/problematic accesses to OCDB...
+        
+    AliCDBManager::Instance()->SetSpecificStorage("MUON/Align/Data","alien://folder=/alice/cern.ch/user/j/jcastill/LHC10hMisAlignCDB");
+    
+    MuonSim.SetRunNumber(runnumber);
+    
+    MuonSim.UseVertexFromCDB();
+  }
   else
   {
     gAlice->SetConfigFunction("Config(\"\", \"param\", \"AliMUONDigitStoreV2S\",kFALSE);");    
@@ -89,9 +110,9 @@ void runSimulation(int seed,
   MuonSim.SetTriggerConfig("MUON");
   MuonSim.SetWriteRawData("MUON HLT","raw.root",kTRUE);
 
-  MuonSim.SetMakeDigits("MUON");
   MuonSim.SetMakeSDigits("MUON");
-  MuonSim.SetMakeDigitsFromHits("");
+  MuonSim.SetMakeDigits("MUON ITS"); // ITS needed to propagate the simulated vertex
+  MuonSim.SetMakeDigitsFromHits("ITS"); // ITS needed to propagate the simulated vertex
 
   MuonSim.SetRunHLT("libAliHLTMUON.so chains=dHLT-sim");