Update of ACORDE-QA-Raw data histograms (now they go from -0.5 to 59.5)
[u/mrichter/AliRoot.git] / MUON / AliMUONDigitizerV3.cxx
index 6192934..5c6f67e 100644 (file)
 
 // $Id$
 
+
 #include "AliMUONDigitizerV3.h"
 
-#include "AliLog.h"
 #include "AliMUON.h"
 #include "AliMUONCalibrationData.h"
 #include "AliMUONConstants.h"
-#include "AliMUONData.h"
-#include "AliMUONDataIterator.h"
 #include "AliMUONDigit.h"
-#include "AliMUONSegmentation.h"
-#include "AliMUONTriggerDecisionV1.h"
-#include "AliMUONTriggerEfficiencyCells.h"
+#include "AliMUONLogger.h"
 #include "AliMUONTriggerElectronics.h"
+#include "AliMUONTriggerStoreV1.h"
 #include "AliMUONVCalibParam.h"
+#include "AliMUONVDigitStore.h"
+#include "AliMUONGeometryTransformer.h" //ADDED for trigger noise
+
+#include "AliMpCDB.h"
+#include "AliMpSegmentation.h"
+#include "AliMpCathodType.h"
+#include "AliMpConstants.h"
 #include "AliMpDEIterator.h"
 #include "AliMpDEManager.h"
-#include "AliMpIntPair.h"
 #include "AliMpPad.h"
 #include "AliMpStationType.h"
 #include "AliMpVSegmentation.h"
+
+#include "AliCDBManager.h"
+#include "AliCodeTimer.h"
+#include "AliLog.h"
 #include "AliRun.h"
 #include "AliRunDigitizer.h"
 #include "AliRunLoader.h"
-#include "Riostream.h"
-#include "TF1.h"
-#include "TRandom.h"
-#include "TString.h"
 
-///
+#include <Riostream.h>
+#include <TF1.h>
+#include <TFile.h>
+#include <TMath.h>
+#include <TRandom.h>
+#include <TString.h>
+#include <TSystem.h>
+
+//-----------------------------------------------------------------------------
+/// \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)
 /// 
@@ -56,6 +68,8 @@
 /// (for performance reason mainly, and because anyway we know we have to do it
 /// here, at the digitization level).
 ///
+/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
 
 namespace
 {
@@ -64,338 +78,313 @@ namespace
     return static_cast<AliMUON*>(gAlice->GetModule("MUON"));
   }
 
-  AliMUONSegmentation* Segmentation()
+  //ADDED for trigger noise
+  const AliMUONGeometryTransformer* GetTransformer()
   {
-    static AliMUONSegmentation* segmentation = muon()->GetSegmentation();
-    return segmentation;
+      return muon()->GetGeometryTransformer();
   }
 }
 
 const Double_t AliMUONDigitizerV3::fgkNSigmas=3;
 
+/// \cond CLASSIMP
 ClassImp(AliMUONDigitizerV3)
+/// \endcond
 
 //_____________________________________________________________________________
 AliMUONDigitizerV3::AliMUONDigitizerV3(AliRunDigitizer* manager, 
-                                       ETriggerCodeVersion triggerCodeVersion,
-                                       Bool_t useTriggerEfficiency,
-                                       Bool_t generateNoisyDigits)
+                                       Int_t generateNoisyDigits)
 : AliDigitizer(manager),
 fIsInitialized(kFALSE),
-fOutputData(0x0),
 fCalibrationData(0x0),
 fTriggerProcessor(0x0),
-fTriggerCodeVersion(triggerCodeVersion),
-fUseTriggerEfficiency(useTriggerEfficiency),
-fTriggerEfficiency(0x0),
-fNoiseFunction(0x0),
-fGenerateNoisyDigits(generateNoisyDigits)
+fNoiseFunctionTrig(0x0),
+fGenerateNoisyDigits(generateNoisyDigits),
+fLogger(new AliMUONLogger(1000)),
+fTriggerStore(new AliMUONTriggerStoreV1),
+fDigitStore(0x0),
+fOutputDigitStore(0x0),
+fInputDigitStore(0x0)
 {
-  //
-  // Ctor.
-  //
-  AliDebug(1,Form("AliRunDigitizer=%p",fManager));
-  fGenerateNoisyDigitsTimer.Start(kTRUE); fGenerateNoisyDigitsTimer.Stop();
-  fExecTimer.Start(kTRUE); fExecTimer.Stop();
-  fFindDigitIndexTimer.Start(kTRUE); fFindDigitIndexTimer.Stop();
-}
+  /// Ctor.
 
-//______________________________________________________________________________
-AliMUONDigitizerV3::AliMUONDigitizerV3(const AliMUONDigitizerV3& right) 
-  : AliDigitizer(right) 
-{  
-/// Protected copy constructor (not implemented)
+  AliDebug(1,Form("AliRunDigitizer=%p",fManager));
 
-  AliFatal("Copy constructor not provided.");
 }
 
 //_____________________________________________________________________________
 AliMUONDigitizerV3::~AliMUONDigitizerV3()
 {
-  //
-  // Dtor. Note we're the owner of some pointers.
-  // 
+  /// Dtor. Note we're the owner of some pointers.
+
   AliDebug(1,"dtor");
 
-  delete fOutputData;
-  delete fCalibrationData;
+ // delete fCalibrationData;
   delete fTriggerProcessor;
-  delete fNoiseFunction;
+  delete fNoiseFunctionTrig;
+  delete fTriggerStore;
+  delete fDigitStore;
+  delete fOutputDigitStore;
+  delete fInputDigitStore;
   
-  AliInfo(Form("Execution time for FindDigitIndex() : R:%.2fs C:%.2fs",
-               fFindDigitIndexTimer.RealTime(),fFindDigitIndexTimer.CpuTime()));
-  if ( fGenerateNoisyDigits )
-  {
-    AliInfo(Form("Execution time for GenerateNoisyDigits() : R:%.2fs C:%.2fs",
-                 fGenerateNoisyDigitsTimer.RealTime(),
-                 fGenerateNoisyDigitsTimer.CpuTime()));
-  }
-  AliInfo(Form("Execution time for Exec() : R:%.2fs C:%.2fs",
-               fExecTimer.RealTime(),fExecTimer.CpuTime()));
+  AliInfo("Summary of messages");
+  fLogger->Print();
   
+  delete fLogger;
 }
 
-//______________________________________________________________________________
-AliMUONDigitizerV3& 
-AliMUONDigitizerV3::operator=(const AliMUONDigitizerV3& right)
-{
-/// Protected assignement operator (not implemented)
-
-  // check assignement to self
-  if (this == &right) return *this;
-
-  AliFatal("Assignement operator not provided.");
-    
-  return *this;  
-}    
-
 //_____________________________________________________________________________
 void 
-AliMUONDigitizerV3::ApplyResponseToTrackerDigit(AliMUONDigit& digit, Bool_t addNoise)
+AliMUONDigitizerV3::ApplyResponseToTrackerDigit(AliMUONVDigit& digit, Bool_t addNoise)
 {
-  // For tracking digits, starting from an ideal digit's charge, we :
-  //
-  // - add some noise (thus leading to a realistic charge), if requested to do so
-  // - divide by a gain (thus decalibrating the digit)
-  // - add a pedestal (thus decalibrating the digit)
-  // - sets the signal to zero if below 3*sigma of the noise
-  //
-
-  static const Int_t kMaxADC = (1<<12)-1; // We code the charge on a 12 bits ADC.
-
-  Float_t signal = digit.Signal();
-
-  if ( !addNoise )
-    {
-      digit.SetADC(TMath::Nint(signal));
-      return;
-    }
-  
+  /// For tracking digits, starting from an ideal digit's charge, we :
+  ///
+  /// - "divide" by a gain (thus decalibrating the digit)
+  /// - add a pedestal (thus decalibrating the digit)
+  /// - 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.Charge();
+  
+  // We set the charge to 0, as the only relevant piece of information
+  // after Digitization is the ADC value.  
+  digit.SetCharge(0);
+    
   Int_t detElemId = digit.DetElemId();
-  
   Int_t manuId = digit.ManuId();
-  Int_t manuChannel = digit.ManuChannel();
   
   AliMUONVCalibParam* pedestal = fCalibrationData->Pedestals(detElemId,manuId);
   if (!pedestal)
-    {
-      AliFatal(Form("Could not get pedestal for DE=%d manuId=%d",
-                   detElemId,manuId));    
-    }
-  Float_t pedestalMean = pedestal->ValueAsFloat(manuChannel,0);
-  Float_t pedestalSigma = pedestal->ValueAsFloat(manuChannel,1);
+  {
+    fLogger->Log(Form("%s:%d:Could not get pedestal for DE=%4d manuId=%4d. Disabling.",
+                      __FILE__,__LINE__,
+                      detElemId,manuId));
+    digit.SetADC(0);
+    return;    
+  }
   
+  Int_t manuChannel = digit.ManuChannel();
+  
+  if ( pedestal->ValueAsFloat(manuChannel,0) == AliMUONVCalibParam::InvalidFloatValue() ||
+      pedestal->ValueAsFloat(manuChannel,1) == AliMUONVCalibParam::InvalidFloatValue() )
+  {
+    // protection against invalid pedestal value
+    digit.SetADC(0);
+    return;
+  }
+      
   AliMUONVCalibParam* gain = fCalibrationData->Gains(detElemId,manuId);
   if (!gain)
-    {
-      AliFatal(Form("Could not get gain for DE=%d manuId=%d",
-                   detElemId,manuId));    
-    }    
-  Float_t gainMean = gain->ValueAsFloat(manuChannel,0);
-
-  Float_t adcNoise = gRandom->Gaus(0.0,pedestalSigma);
-     
-  Int_t adc;
+  {
+    fLogger->Log(Form("%s:%d:Could not get gain for DE=%4d manuId=%4d. Disabling.",
+                      __FILE__,__LINE__,
+                      detElemId,manuId));
+    digit.SetADC(0);
+    return;        
+  }    
 
-  if ( gainMean < 1E-6 )
-    {
-      AliError(Form("Got a too small gain %e for DE=%d manuId=%d manuChannel=%d. "
-                   "Setting signal to 0.",
-                   gainMean,detElemId,manuId,manuChannel));
-      adc = 0;
-    }
-  else
-    {
-      adc = TMath::Nint( signal / gainMean + pedestalMean + adcNoise);///
-      
-      if ( adc <= pedestalMean + fgkNSigmas*pedestalSigma ) 
-       {
-         adc = 0;
-       }
-    }
+  Int_t adc = DecalibrateTrackerDigit(*pedestal,*gain,manuChannel,charge,addNoise,
+                                      digit.IsNoiseOnly());
   
-  // be sure we stick to 12 bits.
-  if ( adc > kMaxADC )
-    {
-      adc = kMaxADC;
-    }
-  
-  digit.SetPhysicsSignal(TMath::Nint(signal));
-  digit.SetSignal(adc);
   digit.SetADC(adc);
 }
 
 //_____________________________________________________________________________
-void 
-AliMUONDigitizerV3::ApplyResponseToTriggerDigit(AliMUONDigit& digit,
-                                                AliMUONData* data)
+void
+AliMUONDigitizerV3::ApplyResponse(const AliMUONVDigitStore& store,
+                                  AliMUONVDigitStore& filteredStore)
 {
-  if ( !fTriggerEfficiency ) return;
-
-  AliMUONDigit* correspondingDigit = FindCorrespondingDigit(digit,data);
+  /// Loop over all chamber digits, and apply the response to them
+  /// Note that this method may remove digits.
 
-  if(!correspondingDigit)return;//reject bad correspondences
-
-  Int_t detElemId = digit.DetElemId();
+  filteredStore.Clear();
   
-  const AliMpVSegmentation* segment[2] = 
+  const Bool_t kAddNoise = kTRUE;
+  
+  TIter next(store.CreateIterator());
+  AliMUONVDigit* digit;
+  
+  while ( ( digit = static_cast<AliMUONVDigit*>(next()) ) )
   {
-    Segmentation()->GetMpSegmentation(detElemId,digit.Cathode()), 
-    Segmentation()->GetMpSegmentation(detElemId,correspondingDigit->Cathode())
-  };
+    AliMp::StationType stationType = AliMpDEManager::GetStationType(digit->DetElemId());
+    
+    if ( stationType != AliMp::kStationTrigger )
+    {
+      ApplyResponseToTrackerDigit(*digit,kAddNoise);
+    }
 
-  AliMpPad pad[2] = 
-  {
-    segment[0]->PadByIndices(AliMpIntPair(digit.PadX(),digit.PadY()),kTRUE), 
-    segment[1]->PadByIndices(AliMpIntPair(correspondingDigit->PadX(),correspondingDigit->PadY()),kTRUE)
-  };
+    if ( digit->ADC() > 0  || digit->Charge() > 0 )
+    {
+      filteredStore.Add(*digit,AliMUONVDigitStore::kIgnore);
+    }
+  }
+}    
 
-  Int_t ix(0);
-  Int_t iy(1);
+//_____________________________________________________________________________
+Int_t 
+AliMUONDigitizerV3::DecalibrateTrackerDigit(const AliMUONVCalibParam& pedestals,
+                                            const AliMUONVCalibParam& gains,
+                                            Int_t channel,
+                                            Float_t charge,
+                                            Bool_t addNoise,
+                                            Bool_t noiseOnly)
+{
+  /// 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...)
 
-  if (digit.Cathode()==0)
+  static const Int_t kMaxADC = (1<<12)-1; // We code the charge on a 12 bits ADC.
+  
+  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 ) 
   {
-         ix=1;
-         iy=0;
+    // linear part only
+    
+    if ( TMath::Abs(a0) > 1E-12 ) 
+    {
+      padc = charge/a0;    
+    }
   }
-  
-  Float_t x = pad[ix].Position().X();
-  Float_t y = pad[iy].Position().Y();
-  if ( x==-1 && y==-1 )
+  else 
   {
-         x=-9999.;
-         y=-9999.;
-    AliError(Form("Got an unknown position for a digit in DE %d at (ix,iy)=(%d,%d)",
-             detElemId,pad[ix].GetIndices().GetFirst(),pad[iy].GetIndices().GetSecond()));
+    // linear + parabolic part
+    Double_t qt = chargeThres - charge;
+    Double_t delta = a0*a0-4*a1*qt;
+    if ( delta < 0 ) 
+    {
+      AliErrorClass(Form("delta=%e DE %d Manu %d Channel %d "
+                    " charge %e a0 %e a1 %e thres %d ped %e pedsig %e",
+                    delta,pedestals.ID0(),pedestals.ID1(),
+                    channel, charge, a0, a1, thres, pedestalMean, 
+                    pedestalSigma));      
+    }      
+    else
+    {
+      delta = TMath::Sqrt(delta);
+      
+      padc = ( ( -a0 + delta ) > 0 ? ( -a0 + delta ) : ( -a0 - delta ) );
+      
+      padc /= 2*a1;
+    
+      if ( padc < 0 )
+      {
+        if ( TMath::Abs(padc) > 1E-3) 
+        {
+          // this is more than a precision problem : let's signal it !
+          AliErrorClass(Form("padc=%e DE %d Manu %d Channel %d "
+                             " charge %e a0 %e a1 %e thres %d ped %e pedsig %e delta %e",
+                             padc,pedestals.ID0(),pedestals.ID1(),
+                             channel, charge, a0, a1, thres, pedestalMean, 
+                             pedestalSigma,delta));
+        }
+
+        // ok. consider we're just at thres, let it be zero.
+        padc = 0;
+      }
+
+      padc += thres;
+
+    }
   }
-  Float_t x0 = segment[0]->Dimensions().X();
-  Float_t y0 = segment[1]->Dimensions().Y();
-  TVector2 newCoord = fTriggerEfficiency->ChangeReferenceFrame(x, y, x0, y0);
   
-  Bool_t isTrig[2];
-  fTriggerEfficiency->IsTriggered(detElemId, newCoord.Px(), newCoord.Py(), 
-                                  isTrig[0], isTrig[1]);
+  Int_t adc(0);
   
-  if (!isTrig[digit.Cathode()])
+  Float_t adcNoise = 0.0;
+    
+  if ( addNoise ) 
   {
-         digit.SetSignal(0);
+    if ( noiseOnly )
+    {      
+      adcNoise = NoiseFunction()->GetRandom()*pedestalSigma;
+    }
+    else
+    {
+      adcNoise = gRandom->Gaus(0.0,pedestalSigma);
+    }
   }
+    
+  adc = TMath::Nint(padc + pedestalMean + adcNoise + 0.5);
   
-  if ( &digit != correspondingDigit )
+  if ( adc < TMath::Nint(pedestalMean + fgkNSigmas*pedestalSigma + 0.5) ) 
   {
-         if (!isTrig[correspondingDigit->Cathode()])
-    {
-      correspondingDigit->SetSignal(0);
-         }
+    adc = 0;
   }
-}
-
-//_____________________________________________________________________________
-void
-AliMUONDigitizerV3::ApplyResponse()
-{
-  //
-  // Loop over all chamber digits, and apply the response to them
-  // Note that this method may remove digits.
-  //
-  const Bool_t kAddNoise = kTRUE;
   
-  for ( Int_t ich = 0; ich < AliMUONConstants::NCh(); ++ich )
+  // be sure we stick to 12 bits.
+  if ( adc > kMaxADC )
   {
-    TClonesArray* digits = fOutputData->Digits(ich);
-    Int_t n = digits->GetEntriesFast();
-    Bool_t trackingChamber = ( ich < AliMUONConstants::NTrackingCh() );
-    for ( Int_t i = 0; i < n; ++i )
-    {
-      AliMUONDigit* d = static_cast<AliMUONDigit*>(digits->UncheckedAt(i));
-      if ( trackingChamber )
-      {
-        ApplyResponseToTrackerDigit(*d,kAddNoise);
-      }
-      else
-      {
-        ApplyResponseToTriggerDigit(*d,fOutputData);
-      }
-      if ( d->Signal() <= 0 )
-      {
-        digits->RemoveAt(i);
-      }
-    }
-    digits->Compress();
-  }    
+    adc = kMaxADC;
+  }
   
-// The version below, using iterator, does not yet work (as the iterator
-// assumes it is reading digits from the tree, while in this case it's
-// writing...)
-//
-//  AliMUONDigit* digit(0x0);
-//
-//  // First loop on tracker digits
-//  AliMUONDataIterator tracker(fOutputData,"D",AliMUONDataIterator::kTrackingChambers);
-//  
-//  while ( ( digit = static_cast<AliMUONDigit*>(tracker.Next()) ) )
-//  {
-//    ApplyResponseToTrackerDigit(*digit);
-//    if ( digit->Signal() <= 0 )
-//    {
-//      tracker.Remove();
-//    }    
-//    
-//  }
-//
-//  // Then loop on trigger digits
-//  AliMUONDataIterator trigger(fOutputData,"D",AliMUONDataIterator::kTriggerChambers);
-//  
-//  while ( ( digit = static_cast<AliMUONDigit*>(trigger.Next()) ) )
-//  {
-//    ApplyResponseToTriggerDigit(*digit,fOutputData);
-//    if ( digit->Signal() <= 0 )
-//    {
-//      trigger.Remove();
-//    }    
-//  }
+  return adc;
 }
 
 //_____________________________________________________________________________
 void
-AliMUONDigitizerV3::AddOrUpdateDigit(TClonesArray& array, 
-                                     const AliMUONDigit& digit)
+AliMUONDigitizerV3::CreateInputDigitStore()
 {
-  //
-  // Add or update a digit, depending on whether there's already a digit
-  // for the corresponding channel.
-  //
-  Int_t ix = FindDigitIndex(array,digit);
+  /// Create an input digit store, and check that all input files
+  /// actually contains the same type of AliMUONVDigitStore
   
-  if (ix>=0)
-  {
-    AliMUONDigit* d = static_cast<AliMUONDigit*>(array.UncheckedAt(ix));
-    Bool_t ok = MergeDigits(digit,*d);
-    if (!ok)
+  fInputDigitStore = 0x0;
+  
+  for ( Int_t iFile = 0; iFile < fManager->GetNinputs(); ++iFile )
+  {    
+    AliLoader* inputLoader = GetLoader(fManager->GetInputFolderName(iFile));
+    
+    inputLoader->LoadSDigits("READ");
+    
+    TTree* iTreeS = inputLoader->TreeS();
+    if (!iTreeS)
     {
-      AliError("Digits are not mergeable !");
+      AliFatal(Form("Could not get access to input file #%d",iFile));
+    }
+    
+    AliMUONVDigitStore* inputStore = AliMUONVDigitStore::Create(*iTreeS);
+    
+    if (!fInputDigitStore)
+    {
+      fInputDigitStore = inputStore;
+    }
+    else
+    {
+      if ( inputStore->IsA() != fInputDigitStore->IsA() )
+      {
+        AliFatal("Got different types of AliMUONVDigitStore here. Please implement me.");
+      }
     }
   }
-  else
-  {
-    ix = array.GetLast() + 1;
-    new(array[ix]) AliMUONDigit(digit);
-  }
-  
 }
 
 //_____________________________________________________________________________
 void
 AliMUONDigitizerV3::Exec(Option_t*)
 {
-  //
-  // Main method.
-  // We first loop over input files, and merge the sdigits we found there.
-  // Second, we digitize all the resulting sdigits
-  // Then we generate noise-only digits (for tracker only)
-  // And we finally generate the trigger outputs.
-  //
+  /// Main method.
+  /// We first loop over input files, and merge the sdigits we found there.
+  /// Second, we digitize all the resulting sdigits
+  /// Then we generate noise-only digits (for tracker only)
+  /// And we finally generate the trigger outputs.
     
+  AliCodeTimerAuto("",0)
+  
   AliDebug(1, "Running digitizer.");
   
   if ( fManager->GetNinputs() == 0 )
@@ -410,37 +399,47 @@ AliMUONDigitizerV3::Exec(Option_t*)
     return;
   }
   
-  fExecTimer.Start(kFALSE);
-
   Int_t nInputFiles = fManager->GetNinputs();
   
-  if ( fOutputData->TreeD() == 0x0 )
+  AliLoader* outputLoader = GetLoader(fManager->GetOutputFolderName());
+  
+  outputLoader->MakeDigitsContainer();
+  
+  TTree* oTreeD = outputLoader->TreeD();
+  
+  if (!oTreeD) 
   {
-    AliDebug(1,"Calling MakeDigitsContainer");
-    fOutputData->GetLoader()->MakeDigitsContainer();
+    AliFatal("Cannot create output TreeD");
   }
-  fOutputData->MakeBranch("D,GLT");
-  fOutputData->SetTreeAddress("D,GLT");
-  
+
   // Loop over all the input files, and merge the sdigits found in those
   // files.
+  
   for ( Int_t iFile = 0; iFile < nInputFiles; ++iFile )
   {    
-    AliMUONData* inputData = GetDataAccess(fManager->GetInputFolderName(iFile));
-    if (!inputData)
+    AliLoader* inputLoader = GetLoader(fManager->GetInputFolderName(iFile));
+
+    inputLoader->LoadSDigits("READ");
+
+    TTree* iTreeS = inputLoader->TreeS();
+    if (!iTreeS)
     {
       AliFatal(Form("Could not get access to input file #%d",iFile));
     }
 
-    inputData->GetLoader()->LoadSDigits("READ");
-    inputData->SetTreeAddress("S");
-    inputData->GetSDigits();
+    if (!fInputDigitStore)
+    {
+      CreateInputDigitStore();
+    }
+    fInputDigitStore->Connect(*iTreeS);
+    
+    iTreeS->GetEvent(0);
+    
+    MergeWithSDigits(fDigitStore,*fInputDigitStore,fManager->GetMask(iFile));
 
-    MergeWithSDigits(*fOutputData,*inputData,fManager->GetMask(iFile));
+    inputLoader->UnloadSDigits();
     
-    inputData->ResetSDigits();
-    inputData->GetLoader()->UnloadSDigits();
-    delete inputData;
+    fInputDigitStore->Clear();
   }
   
   // At this point, we do have digit arrays (one per chamber) which contains 
@@ -448,121 +447,64 @@ AliMUONDigitizerV3::Exec(Option_t*)
   // We now massage them to apply the detector response, i.e. this
   // is here that we do the "digitization" work.
   
-  ApplyResponse();
+  if (!fOutputDigitStore)
+  {
+    fOutputDigitStore = fDigitStore->Create();
+  }
+  
+  if ( fGenerateNoisyDigits>=2 )
+  {
+    // Generate noise-only digits for trigger.
+    GenerateNoisyDigitsForTrigger(*fDigitStore);
+  }
+
+  ApplyResponse(*fDigitStore,*fOutputDigitStore);
   
   if ( fGenerateNoisyDigits )
   {
     // Generate noise-only digits for tracker.
-    GenerateNoisyDigits();
+    GenerateNoisyDigits(*fOutputDigitStore);
   }
   
   // We generate the global and local trigger decisions.
-  fTriggerProcessor->ExecuteTask();
+  fTriggerProcessor->Digits2Trigger(*fOutputDigitStore,*fTriggerStore);
+
+  // Prepare output tree
+  Bool_t okD = fOutputDigitStore->Connect(*oTreeD,kFALSE);
+  Bool_t okT = fTriggerStore->Connect(*oTreeD,kFALSE);
+  if (!okD || !okT)
+  {
+    AliError(Form("Could not make branch : Digit %d Trigger %d",okD,okT));
+    return;
+  }
   
   // Fill the output treeD
-  fOutputData->Fill("D,GLT");
+  oTreeD->Fill();
   
   // Write to the output tree(D).
   // Please note that as GlobalTrigger, LocalTrigger and Digits are in the same
   // tree (=TreeD) in different branches, this WriteDigits in fact writes all of 
   // the 3 branches.
-  fOutputData->GetLoader()->WriteDigits("OVERWRITE");
+  outputLoader->WriteDigits("OVERWRITE");  
   
-  // Finally, we clean up after ourselves.
-  fOutputData->ResetDigits();
-  fOutputData->ResetTrigger();
-  fOutputData->GetLoader()->UnloadDigits();
+  outputLoader->UnloadDigits();
   
-  fExecTimer.Stop();
-}
-
-//_____________________________________________________________________________
-AliMUONDigit* 
-AliMUONDigitizerV3::FindCorrespondingDigit(AliMUONDigit& digit,
-                                           AliMUONData* data)
-{                                                
-  AliMUONDataIterator it(data,"D",AliMUONDataIterator::kTriggerChambers);
-  AliMUONDigit* cd;
-
-  for(;;){
-      cd = static_cast<AliMUONDigit*>(it.Next());
-      if(!cd)continue;
-      if (cd->DetElemId() == digit.DetElemId() &&
-         cd->PadX() == digit.PadX() &&
-         cd->PadY() == digit.PadY() && 
-         cd->Cathode() == digit.Cathode()){
-         break;
-      }
-  }
-  //The corresponding digit is searched only forward in the AliMUONData.
-  //In this way when the first digit of the couple is given, the second digit is found and the efficiency is applied to both. 
-  //Afterwards, when the second digit of the couple is given the first one is not found and hence efficiency is not applied again
-  
-  while ( ( cd = static_cast<AliMUONDigit*>(it.Next()) ) )
-  {
-    if(!cd)continue;//avoid problems when 1 digit is removed
-    if ( cd->DetElemId() == digit.DetElemId() &&
-         cd->Hit() == digit.Hit() &&
-         cd->Cathode() != digit.Cathode() )
-    {
-      return cd;
-    }
-  }
-  return 0x0;
+  // Finally, we clean up after ourselves.
+  fTriggerStore->Clear();
+  fDigitStore->Clear();
+  fOutputDigitStore->Clear();
 }
 
 
 //_____________________________________________________________________________
-Int_t
-AliMUONDigitizerV3::FindDigitIndex(TClonesArray& array, 
-                                   const AliMUONDigit& digit) const
-{
-  // 
-  // Return the index of digit within array, if that digit is there, 
-  // otherwise returns -1
-  //
-  // FIXME: this is of course not the best implementation you can think of.
-  // Reconsider the use of hit/digit map... ? (but be sure it's needed!)
-  //
-  
-  fFindDigitIndexTimer.Start(kFALSE);
-  
-  Int_t n = array.GetEntriesFast();
-  for ( Int_t i = 0; i < n; ++i )
-  {
-    AliMUONDigit* d = static_cast<AliMUONDigit*>(array.UncheckedAt(i));
-    if ( d->DetElemId() == digit.DetElemId() &&
-         d->PadX() == digit.PadX() &&
-         d->PadY() == digit.PadY() && 
-         d->Cathode() == digit.Cathode() )
-    {
-      fFindDigitIndexTimer.Stop();
-      return i;
-    }
-  }
-  fFindDigitIndexTimer.Stop();
-  return -1;
-}
-
-//_____________________________________________________________________________
 void
-AliMUONDigitizerV3::GenerateNoisyDigits()
+AliMUONDigitizerV3::GenerateNoisyDigits(AliMUONVDigitStore& digitStore)
 {
-  //
-  // According to a given probability, generate digits that
-  // have a signal above the noise cut (ped+n*sigma_ped), i.e. digits
-  // that are "only noise".
-  //
+  /// According to a given probability, generate digits that
+  /// have a signal above the noise cut (ped+n*sigma_ped), i.e. digits
+  /// that are "only noise".
   
-  if ( !fNoiseFunction )
-  {
-    fNoiseFunction = new TF1("AliMUONDigitizerV3::fNoiseFunction","gaus",
-                             fgkNSigmas,fgkNSigmas*10);
-    
-    fNoiseFunction->SetParameters(1,0,1);
-  }
-  
-  fGenerateNoisyDigitsTimer.Start(kFALSE);
+  AliCodeTimerAuto("",0)
   
   for ( Int_t i = 0; i < AliMUONConstants::NTrackingCh(); ++i )
   {
@@ -574,27 +516,23 @@ AliMUONDigitizerV3::GenerateNoisyDigits()
     {
       for ( Int_t cathode = 0; cathode < 2; ++cathode )
       {
-        GenerateNoisyDigitsForOneCathode(it.CurrentDE(),cathode);
+        GenerateNoisyDigitsForOneCathode(digitStore,it.CurrentDEId(),cathode);
       }
       it.Next();
     }
   }
-  
-  fGenerateNoisyDigitsTimer.Stop();
 }
  
 //_____________________________________________________________________________
 void
-AliMUONDigitizerV3::GenerateNoisyDigitsForOneCathode(Int_t detElemId, Int_t cathode)
+AliMUONDigitizerV3::GenerateNoisyDigitsForOneCathode(AliMUONVDigitStore& digitStore,
+                                                     Int_t detElemId, Int_t cathode)
 {
-  //
-  // Generate noise-only digits for one cathode of one detection element.
-  // Called by GenerateNoisyDigits()
-  //
+  /// Generate noise-only digits for one cathode of one detection element.
+  /// Called by GenerateNoisyDigits()
   
-  TClonesArray* digits = fOutputData->Digits(detElemId/100-1);
-  
-  const AliMpVSegmentation* seg = Segmentation()->GetMpSegmentation(detElemId,cathode);
+  const AliMpVSegmentation* seg 
+    = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::GetCathodType(cathode));
   Int_t nofPads = seg->NofPads();
   
   Int_t maxIx = seg->MaxPadIndexX();
@@ -611,94 +549,185 @@ AliMUONDigitizerV3::GenerateNoisyDigitsForOneCathode(Int_t detElemId, Int_t cath
   
   AliDebug(3,Form("DE %d cath %d nofNoisyPads %d",detElemId,cathode,nofNoisyPads));
   
-  for ( Int_t i = 0; i < nofNoisyPads; ++i )
+  for ( Int_t i = 0; i < nofNoisyPads; ++i ) 
   {
     Int_t ix(-1);
     Int_t iy(-1);
+    AliMpPad pad;
+    
     do {
       ix = gRandom->Integer(maxIx+1);
       iy = gRandom->Integer(maxIy+1);
-    } while ( !seg->HasPad(AliMpIntPair(ix,iy)) );
-    AliMUONDigit d;
-    d.SetDetElemId(detElemId);
-    d.SetCathode(cathode);
-    d.SetPadX(ix);
-    d.SetPadY(iy);
-    if ( FindDigitIndex(*digits,d) >= 0 )
+      pad = seg->PadByIndices(ix,iy,kFALSE);
+    } while ( !pad.IsValid() );
+
+    Int_t manuId = pad.GetManuId();
+    Int_t manuChannel = pad.GetManuChannel();    
+
+    AliMUONVCalibParam* pedestals = fCalibrationData->Pedestals(detElemId,manuId);
+    
+    if (!pedestals) 
     {
-      // this digit is already there, and not noise-only, we simply skip it
+      // no pedestal available for this channel, simply give up
       continue;
     }
-    AliMpPad pad = seg->PadByIndices(AliMpIntPair(ix,iy));
-    Int_t manuId = pad.GetLocation().GetFirst();
-    Int_t manuChannel = pad.GetLocation().GetSecond();
     
-    d.SetElectronics(manuId,manuChannel);
-    
-    AliMUONVCalibParam* pedestals = fCalibrationData->Pedestals(detElemId,manuId);
+    AliMUONVDigit* d = digitStore.CreateDigit(detElemId,manuId,manuChannel,cathode);
     
-    Float_t pedestalMean = pedestals->ValueAsFloat(manuChannel,0);
-    Float_t pedestalSigma = pedestals->ValueAsFloat(manuChannel,1);
+    d->SetPadXY(ix,iy);
     
-    Double_t ped = fNoiseFunction->GetRandom()*pedestalSigma;
-
-    d.SetSignal(TMath::Nint(ped+pedestalMean+0.5));
-    d.SetPhysicsSignal(0);
-    d.NoiseOnly(kTRUE);
-    AliDebug(3,Form("Adding a pure noise digit :"));
-    StdoutToAliDebug(3,cout << "Before Response: " << endl; 
-                     d.Print(););
-    ApplyResponseToTrackerDigit(d,kFALSE);
-    if ( d.Signal() > 0 )
+    d->SetCharge(0.0); // charge is zero, the ApplyResponseToTrackerDigit will add the noise
+    d->NoiseOnly(kTRUE);
+    ApplyResponseToTrackerDigit(*d,kTRUE);
+    if ( d->ADC() > 0 )
     {
-      AddOrUpdateDigit(*digits,d);
-    }
-    else
-    {
-      AliError("Pure noise below threshold. This should not happen. Not adding "
-               "this digit.");
+      Bool_t ok = digitStore.Add(*d,AliMUONVDigitStore::kDeny);
+      // this can happen (that we randomly chose a digit that is
+      // already there). We simply ignore this, but log the occurence
+      // to cross-check that it's not too frequent.
+      if (!ok)
+      {
+        fLogger->Log("Collision while adding noiseOnly digit");
+      }
+      else
+      {
+        fLogger->Log("Added noiseOnly digit");
+      }
     }
-    StdoutToAliDebug(3,cout << "After Response: " << endl; 
-                     d.Print(););
+    delete d;
   }
 }
 
+
 //_____________________________________________________________________________
-AliMUONData* 
-AliMUONDigitizerV3::GetDataAccess(const TString& folderName)
+void
+AliMUONDigitizerV3::GenerateNoisyDigitsForTrigger(AliMUONVDigitStore& digitStore)
 {
-  //
-  // Create an AliMUONData to deal with data found in folderName.
-  //
-  AliDebug(1,Form("Getting access to folder %s",folderName.Data()));
-  AliRunLoader* runLoader = AliRunLoader::GetRunLoader(folderName);
-  if (!runLoader)
+  /// Generate noise-only digits for one cathode of one detection element.
+  /// Called by GenerateNoisyDigits()
+
+  if ( !fNoiseFunctionTrig )
   {
-    AliError(Form("Could not get RunLoader from folder %s",folderName.Data()));
-    return 0x0;
+    fNoiseFunctionTrig = new TF1("AliMUONDigitizerV3::fNoiseFunctionTrig","landau",
+                                50.,270.);
+    
+    fNoiseFunctionTrig->SetParameters(3.91070e+02, 9.85026, 9.35881e-02);
   }
-  AliLoader* loader = static_cast<AliLoader*>(runLoader->GetLoader("MUONLoader"));
+
+  AliMpPad pad[2];
+  AliMUONVDigit *d[2]={0x0};
+
+  for ( Int_t chamberId = AliMUONConstants::NTrackingCh(); chamberId < AliMUONConstants::NCh(); ++chamberId )
+  {
+  
+    Int_t nofNoisyPads = 50;
+
+    Float_t r=-1, fi = 0., gx, gy, x, y, z, xg01, yg01, zg, xg02, yg02;
+    AliMpDEIterator it;
+  
+    AliDebug(3,Form("Chamber %d nofNoisyPads %d",chamberId,nofNoisyPads));
+
+    for ( Int_t i = 0; i < nofNoisyPads; ++i )
+    {
+      //printf("Generating noise %i\n",i);
+       Int_t ix(-1);
+       Int_t iy(-1);
+       Bool_t isOk = kFALSE;
+       Int_t detElemId = -1;
+       do {
+         //r = gRandom->Landau(9.85026, 9.35881e-02);
+           r = fNoiseFunctionTrig->GetRandom();
+           fi = 2. * TMath::Pi() * gRandom->Rndm();
+           //printf("r = %f\tfi = %f\n", r, fi);
+           gx = r * TMath::Cos(fi);
+           gy = r * TMath::Sin(fi);
+
+           for ( it.First(chamberId); ! it.IsDone(); it.Next() ){
+               Int_t currDetElemId = it.CurrentDEId();
+               const AliMpVSegmentation* seg
+                   = AliMpSegmentation::Instance()->GetMpSegmentation(currDetElemId,AliMp::GetCathodType(0));
+               if (!seg) continue;
+               Float_t deltax = seg->GetDimensionX();
+               Float_t deltay = seg->GetDimensionY();
+               GetTransformer()->Local2Global(currDetElemId, -deltax, -deltay, 0, xg01, yg01, zg);
+               GetTransformer()->Local2Global(currDetElemId,  deltax,  deltay, 0, xg02, yg02, zg);
+               Float_t xg1 = xg01, xg2 = xg02, yg1 = yg01, yg2 = yg02;
+               if(xg01>xg02){
+                   xg1 = xg02;
+                   xg2 = xg01;
+               }
+               if(yg01>yg02){
+                   yg1 = yg02;
+                   yg2 = yg01;
+               }
+               if(gx>=xg1 && gx<=xg2 && gy>=yg1 && gy<=yg2){
+                   detElemId = currDetElemId;
+                   GetTransformer()->Global2Local(detElemId, gx, gy, 0, x, y, z);
+                   pad[0] = seg->PadByPosition(x,y,kFALSE);
+                   if(!pad[0].IsValid()) continue;
+                   isOk = kTRUE;
+                   break;
+               }
+           } // loop on slats
+       } while ( !isOk );
+
+       const AliMpVSegmentation* seg1
+           = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::GetCathodType(1));
+       pad[1] = seg1->PadByPosition(x,y,kFALSE);
+
+       for ( Int_t cathode = 0; cathode < 2; ++cathode ){
+         Int_t manuId = pad[cathode].GetLocalBoardId(0);
+         Int_t manuChannel = pad[cathode].GetLocalBoardChannel(0);    
+         d[cathode] = digitStore.CreateDigit(detElemId,manuId,manuChannel,cathode);
+         ix = pad[cathode].GetIx();
+         iy = pad[cathode].GetIy();
+         d[cathode]->SetPadXY(ix,iy);
+         //d[cathode].SetSignal(1);
+         //d[cathode].SetPhysicsSignal(0);
+         d[cathode]->SetCharge(1);
+         d[cathode]->NoiseOnly(kTRUE);
+         AliDebug(3,Form("Adding a pure noise digit :"));
+
+         Bool_t ok = digitStore.Add(*d[cathode],AliMUONVDigitStore::kDeny);
+         if (!ok)
+         {
+             fLogger->Log("Collision while adding TriggerNoise digit");
+         }
+         else
+         {
+             fLogger->Log("Added triggerNoise digit");
+         }
+       } //loop on cathodes
+    } // loop on noisy pads
+  } // loop on chambers
+}
+
+
+//_____________________________________________________________________________
+AliLoader*
+AliMUONDigitizerV3::GetLoader(const TString& folderName)
+{
+  /// Get a MUON loader
+
+  AliDebug(2,Form("Getting access to folder %s",folderName.Data()));
+  AliLoader* loader = AliRunLoader::GetDetectorLoader("MUON",folderName.Data());
   if (!loader)
   {
     AliError(Form("Could not get MuonLoader from folder %s",folderName.Data()));
     return 0x0;
   }
-  AliMUONData* data = new AliMUONData(loader,"MUON","MUONDataForDigitOutput");
-  AliDebug(1,Form("AliMUONData=%p loader=%p",data,loader));
-  return data;
+  return loader;
 }
 
 //_____________________________________________________________________________
 Bool_t
 AliMUONDigitizerV3::Init()
 {
-  //
-  // Initialization of the TTask :
-  // a) set the outputData pointer
-  // b) create the calibrationData, according to run number
-  // c) create the trigger processing task
-  //
-  AliDebug(1,"");
+  /// Initialization of the TTask :
+  /// a) create the calibrationData, according to run number
+  /// b) create the trigger processing task
+
+  AliDebug(2,"");
   
   if ( fIsInitialized )
   {
@@ -712,125 +741,80 @@ AliMUONDigitizerV3::Init()
     return kFALSE;
   }
   
-  fOutputData = GetDataAccess(fManager->GetOutputFolderName());
-  if (!fOutputData)
-  {
-    AliError("Can not perform digitization. I'm sorry");
-    return kFALSE;
+  // Load mapping
+  if ( ! AliMpCDB::LoadDDLStore() ) {
+    AliFatal("Could not access mapping from OCDB !");
   }
-  AliDebug(1,Form("fOutputData=%p",fOutputData));
   
-  AliRunLoader* runLoader = fOutputData->GetLoader()->GetRunLoader();
-  AliRun* galice = runLoader->GetAliRun();  
-  Int_t runnumber = galice->GetRunNumber();
-  
-  fCalibrationData = new AliMUONCalibrationData(runnumber);
-  
-  switch (fTriggerCodeVersion)
+  if (!fCalibrationData)
+      AliFatal("Calibration data object not defined");
+
+  if ( !fCalibrationData->Pedestals() )
   {
-    case kTriggerDecision:
-      fTriggerProcessor = new AliMUONTriggerDecisionV1(fOutputData);
-      break;
-    case kTriggerElectronics:
-      fTriggerProcessor = new AliMUONTriggerElectronics(fOutputData,fCalibrationData);
-      break;
-    default:
-      AliFatal("Unknown trigger processor type");
-      break;
+    AliFatal("Could not access pedestals from OCDB !");
   }
-  AliDebug(1,Form("Using the following trigger code %s - %s",
-                  fTriggerProcessor->GetName(),fTriggerProcessor->GetTitle()));
-  
-  if ( fUseTriggerEfficiency )
+  if ( !fCalibrationData->Gains() )
   {
-    fTriggerEfficiency = fCalibrationData->TriggerEfficiency();
-    if ( fTriggerEfficiency )
-    {
-      AliInfo("Will apply trigger efficiency");
-    }
-    else
-    {
-      AliError("I was requested to apply trigger efficiency, but I could "
-               "not get it !");
-    }
+    AliFatal("Could not access gains from OCDB !");
   }
   
-  if ( fGenerateNoisyDigits )
-  {
-    AliInfo("Will generate noise-only digits for tracker");
-  }
   
+   AliInfo("Using trigger configuration from CDB");
+  
+  fTriggerProcessor = new AliMUONTriggerElectronics(fCalibrationData);
+  
+  AliDebug(1, Form("Will %s generate noise-only digits for tracker",
+                     (fGenerateNoisyDigits ? "":"NOT")));
+
   fIsInitialized = kTRUE;
   return kTRUE;
 }
 
 //_____________________________________________________________________________
-Bool_t
-AliMUONDigitizerV3::MergeDigits(const AliMUONDigit& src, 
-                                AliMUONDigit& srcAndDest)
+void 
+AliMUONDigitizerV3::MergeWithSDigits(AliMUONVDigitStore*& outputStore,
+                                     const AliMUONVDigitStore& input,
+                                     Int_t mask)
 {
-  //
-  // Merge 2 digits (src and srcAndDest) into srcAndDest.
-  //
-  AliDebug(1,"Merging the following digits:");
-  StdoutToAliDebug(1,src.Print("tracks"););
-  StdoutToAliDebug(1,srcAndDest.Print("tracks"););
-  
-  Bool_t check = ( src.DetElemId() == srcAndDest.DetElemId() &&
-                   src.PadX() == srcAndDest.PadX() &&
-                   src.PadY() == srcAndDest.PadY() &&
-                   src.Cathode() == srcAndDest.Cathode() );
-  if (!check)
-  {
-    return kFALSE;
-  }
+  /// Merge the sdigits in inputData with the digits already present in outputData
+  
+  if ( !outputStore ) outputStore = input.Create();
   
-  srcAndDest.AddSignal(src.Signal());
-  srcAndDest.AddPhysicsSignal(src.Physics());
-  for ( Int_t i = 0; i < src.Ntracks(); ++i )
+  TIter next(input.CreateIterator());
+  AliMUONVDigit* sdigit;
+  
+  const float kTime1 = muon()->GetTimeMin();
+  const float kTime2 = muon()->GetTimeMax();
+
+  while ( ( sdigit = static_cast<AliMUONVDigit*>(next()) ) )
   {
-    srcAndDest.AddTrack(src.Track(i),src.TrackCharge(i));
+    float time = sdigit->Time()*1E9;
+    if (time<kTime1 || time>kTime2) continue;
+    
+    // Update the track references using the mask.
+    // FIXME: this is dirty, for backward compatibility only.
+    // Should re-design all this way of keeping track of MC information...
+    if ( mask ) sdigit->PatchTracks(mask);
+    // Then add or update the digit to the output.
+    AliMUONVDigit* added = outputStore->Add(*sdigit,AliMUONVDigitStore::kMerge);
+    if (!added)
+    {
+      AliError("Could not add digit in merge mode");
+    }
   }
-  StdoutToAliDebug(1,cout << "result:"; srcAndDest.Print("tracks"););
-  return kTRUE;
 }
 
 //_____________________________________________________________________________
-void 
-AliMUONDigitizerV3::MergeWithSDigits(AliMUONData& outputData, 
-                                     const AliMUONData& inputData, Int_t mask)
+TF1*
+AliMUONDigitizerV3::NoiseFunction()
 {
-  //
-  // Merge the sdigits in inputData with the digits already present in outputData
-  //
-  AliDebug(1,"");
-  
-       for ( Int_t ich = 0; ich < AliMUONConstants::NCh(); ++ich )
-       {
-    TClonesArray* iDigits = inputData.SDigits(ich); 
-    TClonesArray* oDigits = outputData.Digits(ich);
-    if (!iDigits)
-    {
-      AliError(Form("Could not get sdigits for ich=%d",ich));
-      return;
-    }
-    Int_t nSDigits = iDigits->GetEntriesFast();
-    for ( Int_t k = 0; k < nSDigits; ++k )
-               {
-                       AliMUONDigit* sdigit = static_cast<AliMUONDigit*>(iDigits->UncheckedAt(k));
-      if (!sdigit)
-      {
-        AliError(Form("Could not get sdigit for ich=%d and k=%d",ich,k));
-      }
-      else
-      {
-        // Update the track references using the mask.
-        // FIXME: this is dirty, for backward compatibility only.
-        // Should re-design all this way of keeping track of MC information...
-        if ( mask ) sdigit->PatchTracks(mask);
-        // Then add or update the digit to the output.
-        AddOrUpdateDigit(*oDigits,*sdigit);
-      }
-               }   
+  /// Return noise function
+  static TF1* f = 0x0;
+  if (!f)
+  {
+    f = new TF1("AliMUONDigitizerV3::NoiseFunction","gaus",fgkNSigmas,fgkNSigmas*10);
+    f->SetParameters(1,0,1);
   }
+  return f;
 }
+