Update of ACORDE-QA-Raw data histograms (now they go from -0.5 to 59.5)
[u/mrichter/AliRoot.git] / MUON / AliMUONDigitizerV3.cxx
index 29edc6a..5c6f67e 100644 (file)
@@ -18,9 +18,6 @@
 
 #include "AliMUONDigitizerV3.h"
 
-#include "AliCDBManager.h"
-#include "AliCodeTimer.h"
-#include "AliLog.h"
 #include "AliMUON.h"
 #include "AliMUONCalibrationData.h"
 #include "AliMUONConstants.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 "AliMpSegmentation.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 <TFile.h>
@@ -51,8 +54,6 @@
 #include <TString.h>
 #include <TSystem.h>
 
-#include "AliMUONGeometryTransformer.h" //ADDED for trigger noise
-
 //-----------------------------------------------------------------------------
 /// \class AliMUONDigitizerV3
 /// The digitizer is performing the transformation to go from SDigits (digits
@@ -97,17 +98,18 @@ AliMUONDigitizerV3::AliMUONDigitizerV3(AliRunDigitizer* manager,
 fIsInitialized(kFALSE),
 fCalibrationData(0x0),
 fTriggerProcessor(0x0),
-fNoiseFunction(0x0),
 fNoiseFunctionTrig(0x0),
-  fGenerateNoisyDigits(generateNoisyDigits),
-  fLogger(new AliMUONLogger(1000)),
+fGenerateNoisyDigits(generateNoisyDigits),
+fLogger(new AliMUONLogger(1000)),
 fTriggerStore(new AliMUONTriggerStoreV1),
 fDigitStore(0x0),
-fOutputDigitStore(0x0)
+fOutputDigitStore(0x0),
+fInputDigitStore(0x0)
 {
   /// Ctor.
 
   AliDebug(1,Form("AliRunDigitizer=%p",fManager));
+
 }
 
 //_____________________________________________________________________________
@@ -117,14 +119,14 @@ AliMUONDigitizerV3::~AliMUONDigitizerV3()
 
   AliDebug(1,"dtor");
 
-  delete fCalibrationData;
+ // delete fCalibrationData;
   delete fTriggerProcessor;
-  delete fNoiseFunction;
   delete fNoiseFunctionTrig;
   delete fTriggerStore;
   delete fDigitStore;
   delete fOutputDigitStore;
-   
+  delete fInputDigitStore;
+  
   AliInfo("Summary of messages");
   fLogger->Print();
   
@@ -161,6 +163,16 @@ AliMUONDigitizerV3::ApplyResponseToTrackerDigit(AliMUONVDigit& digit, Bool_t add
     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)
   {
@@ -171,11 +183,8 @@ AliMUONDigitizerV3::ApplyResponseToTrackerDigit(AliMUONVDigit& digit, Bool_t add
     return;        
   }    
 
-  Int_t manuChannel = digit.ManuChannel();
-  
-
-  
-  Int_t adc = DecalibrateTrackerDigit(*pedestal,*gain,manuChannel,charge,addNoise);
+  Int_t adc = DecalibrateTrackerDigit(*pedestal,*gain,manuChannel,charge,addNoise,
+                                      digit.IsNoiseOnly());
   
   digit.SetADC(adc);
 }
@@ -217,7 +226,8 @@ AliMUONDigitizerV3::DecalibrateTrackerDigit(const AliMUONVCalibParam& pedestals,
                                             const AliMUONVCalibParam& gains,
                                             Int_t channel,
                                             Float_t charge,
-                                            Bool_t addNoise)
+                                            Bool_t addNoise,
+                                            Bool_t noiseOnly)
 {
   /// Decalibrate (i.e. go from charge to adc) a tracker digit, given its
   /// pedestal and gain parameters.
@@ -230,6 +240,9 @@ AliMUONDigitizerV3::DecalibrateTrackerDigit(const AliMUONVCalibParam& pedestals,
   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);
@@ -293,13 +306,25 @@ AliMUONDigitizerV3::DecalibrateTrackerDigit(const AliMUONVCalibParam& pedestals,
   
   Int_t adc(0);
   
-  if ( padc > 0 ) 
-  {
-    Float_t adcNoise = 0.0;
+  Float_t adcNoise = 0.0;
     
-    if ( addNoise ) adcNoise = gRandom->Gaus(0.0,pedestalSigma);
+  if ( addNoise ) 
+  {
+    if ( noiseOnly )
+    {      
+      adcNoise = NoiseFunction()->GetRandom()*pedestalSigma;
+    }
+    else
+    {
+      adcNoise = gRandom->Gaus(0.0,pedestalSigma);
+    }
+  }
     
-    adc = TMath::Nint(padc + pedestalMean + adcNoise);
+  adc = TMath::Nint(padc + pedestalMean + adcNoise + 0.5);
+  
+  if ( adc < TMath::Nint(pedestalMean + fgkNSigmas*pedestalSigma + 0.5) ) 
+  {
+    adc = 0;
   }
   
   // be sure we stick to 12 bits.
@@ -313,6 +338,43 @@ AliMUONDigitizerV3::DecalibrateTrackerDigit(const AliMUONVCalibParam& pedestals,
 
 //_____________________________________________________________________________
 void
+AliMUONDigitizerV3::CreateInputDigitStore()
+{
+  /// Create an input digit store, and check that all input files
+  /// actually contains the same type of AliMUONVDigitStore
+  
+  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)
+    {
+      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.");
+      }
+    }
+  }
+}
+
+//_____________________________________________________________________________
+void
 AliMUONDigitizerV3::Exec(Option_t*)
 {
   /// Main method.
@@ -321,7 +383,7 @@ AliMUONDigitizerV3::Exec(Option_t*)
   /// Then we generate noise-only digits (for tracker only)
   /// And we finally generate the trigger outputs.
     
-  AliCodeTimerAuto("")
+  AliCodeTimerAuto("",0)
   
   AliDebug(1, "Running digitizer.");
   
@@ -364,17 +426,20 @@ AliMUONDigitizerV3::Exec(Option_t*)
     {
       AliFatal(Form("Could not get access to input file #%d",iFile));
     }
-    
-    AliMUONVDigitStore* inputStore = AliMUONVDigitStore::Create(*iTreeS);
-    inputStore->Connect(*iTreeS);
+
+    if (!fInputDigitStore)
+    {
+      CreateInputDigitStore();
+    }
+    fInputDigitStore->Connect(*iTreeS);
     
     iTreeS->GetEvent(0);
     
-    MergeWithSDigits(fDigitStore,*inputStore,fManager->GetMask(iFile));
+    MergeWithSDigits(fDigitStore,*fInputDigitStore,fManager->GetMask(iFile));
 
     inputLoader->UnloadSDigits();
     
-    delete inputStore;
+    fInputDigitStore->Clear();
   }
   
   // At this point, we do have digit arrays (one per chamber) which contains 
@@ -439,15 +504,7 @@ AliMUONDigitizerV3::GenerateNoisyDigits(AliMUONVDigitStore& digitStore)
   /// have a signal above the noise cut (ped+n*sigma_ped), i.e. digits
   /// that are "only noise".
   
-  AliCodeTimerAuto("")
-  
-  if ( !fNoiseFunction )
-  {
-    fNoiseFunction = new TF1("AliMUONDigitizerV3::fNoiseFunction","gaus",
-                             fgkNSigmas,fgkNSigmas*10);
-    
-    fNoiseFunction->SetParameters(1,0,1);
-  }
+  AliCodeTimerAuto("",0)
   
   for ( Int_t i = 0; i < AliMUONConstants::NTrackingCh(); ++i )
   {
@@ -501,11 +558,11 @@ AliMUONDigitizerV3::GenerateNoisyDigitsForOneCathode(AliMUONVDigitStore& digitSt
     do {
       ix = gRandom->Integer(maxIx+1);
       iy = gRandom->Integer(maxIy+1);
-      pad = seg->PadByIndices(AliMpIntPair(ix,iy),kFALSE);
+      pad = seg->PadByIndices(ix,iy,kFALSE);
     } while ( !pad.IsValid() );
 
-    Int_t manuId = pad.GetLocation().GetFirst();
-    Int_t manuChannel = pad.GetLocation().GetSecond();    
+    Int_t manuId = pad.GetManuId();
+    Int_t manuChannel = pad.GetManuChannel();    
 
     AliMUONVCalibParam* pedestals = fCalibrationData->Pedestals(detElemId,manuId);
     
@@ -519,14 +576,9 @@ AliMUONDigitizerV3::GenerateNoisyDigitsForOneCathode(AliMUONVDigitStore& digitSt
     
     d->SetPadXY(ix,iy);
     
-    Float_t pedestalMean = pedestals->ValueAsFloat(manuChannel,0);
-    Float_t pedestalSigma = pedestals->ValueAsFloat(manuChannel,1);
-    
-    Double_t ped = fNoiseFunction->GetRandom()*pedestalSigma;
-
-    d->SetCharge(TMath::Nint(ped+pedestalMean+0.5));
+    d->SetCharge(0.0); // charge is zero, the ApplyResponseToTrackerDigit will add the noise
     d->NoiseOnly(kTRUE);
-    ApplyResponseToTrackerDigit(*d,kFALSE);
+    ApplyResponseToTrackerDigit(*d,kTRUE);
     if ( d->ADC() > 0 )
     {
       Bool_t ok = digitStore.Add(*d,AliMUONVDigitStore::kDeny);
@@ -542,11 +594,6 @@ AliMUONDigitizerV3::GenerateNoisyDigitsForOneCathode(AliMUONVDigitStore& digitSt
         fLogger->Log("Added noiseOnly digit");
       }
     }
-    else
-    {
-      AliError("Pure noise below threshold. This should not happen. Not adding "
-               "this digit.");
-    }
     delete d;
   }
 }
@@ -600,8 +647,8 @@ AliMUONDigitizerV3::GenerateNoisyDigitsForTrigger(AliMUONVDigitStore& digitStore
                const AliMpVSegmentation* seg
                    = AliMpSegmentation::Instance()->GetMpSegmentation(currDetElemId,AliMp::GetCathodType(0));
                if (!seg) continue;
-               Float_t deltax = seg->Dimensions().X();
-               Float_t deltay = seg->Dimensions().Y();
+               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;
@@ -616,7 +663,7 @@ AliMUONDigitizerV3::GenerateNoisyDigitsForTrigger(AliMUONVDigitStore& digitStore
                if(gx>=xg1 && gx<=xg2 && gy>=yg1 && gy<=yg2){
                    detElemId = currDetElemId;
                    GetTransformer()->Global2Local(detElemId, gx, gy, 0, x, y, z);
-                   pad[0] = seg->PadByPosition(TVector2(x,y),kFALSE);
+                   pad[0] = seg->PadByPosition(x,y,kFALSE);
                    if(!pad[0].IsValid()) continue;
                    isOk = kTRUE;
                    break;
@@ -626,14 +673,14 @@ AliMUONDigitizerV3::GenerateNoisyDigitsForTrigger(AliMUONVDigitStore& digitStore
 
        const AliMpVSegmentation* seg1
            = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::GetCathodType(1));
-       pad[1] = seg1->PadByPosition(TVector2(x,y),kFALSE);
+       pad[1] = seg1->PadByPosition(x,y,kFALSE);
 
        for ( Int_t cathode = 0; cathode < 2; ++cathode ){
-         Int_t manuId = pad[cathode].GetLocation(0).GetFirst();
-         Int_t manuChannel = pad[cathode].GetLocation(0).GetSecond();    
+         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].GetIndices().GetFirst();
-         iy = pad[cathode].GetIndices().GetSecond();
+         ix = pad[cathode].GetIx();
+         iy = pad[cathode].GetIy();
          d[cathode]->SetPadXY(ix,iy);
          //d[cathode].SetSignal(1);
          //d[cathode].SetPhysicsSignal(0);
@@ -694,19 +741,14 @@ AliMUONDigitizerV3::Init()
     return kFALSE;
   }
   
-  Int_t runnumber = AliCDBManager::Instance()->GetRun();
-  
-  if ( ! AliMpCDB::LoadMpSegmentation()  ) 
-  {
+  // Load mapping
+  if ( ! AliMpCDB::LoadDDLStore() ) {
     AliFatal("Could not access mapping from OCDB !");
   }
   
-  if ( ! AliMpCDB::LoadDDLStore() ) 
-  {
-    AliFatal("Could not access DDL Store from OCDB !");
-  }
-  
-  fCalibrationData = new AliMUONCalibrationData(runnumber);
+  if (!fCalibrationData)
+      AliFatal("Calibration data object not defined");
+
   if ( !fCalibrationData->Pedestals() )
   {
     AliFatal("Could not access pedestals from OCDB !");
@@ -715,6 +757,10 @@ AliMUONDigitizerV3::Init()
   {
     AliFatal("Could not access gains from OCDB !");
   }
+  
+  
+   AliInfo("Using trigger configuration from CDB");
+  
   fTriggerProcessor = new AliMUONTriggerElectronics(fCalibrationData);
   
   AliDebug(1, Form("Will %s generate noise-only digits for tracker",
@@ -737,8 +783,14 @@ AliMUONDigitizerV3::MergeWithSDigits(AliMUONVDigitStore*& outputStore,
   TIter next(input.CreateIterator());
   AliMUONVDigit* sdigit;
   
+  const float kTime1 = muon()->GetTimeMin();
+  const float kTime2 = muon()->GetTimeMax();
+
   while ( ( sdigit = static_cast<AliMUONVDigit*>(next()) ) )
   {
+    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...
@@ -751,3 +803,18 @@ AliMUONDigitizerV3::MergeWithSDigits(AliMUONVDigitStore*& outputStore,
     }
   }
 }
+
+//_____________________________________________________________________________
+TF1*
+AliMUONDigitizerV3::NoiseFunction()
+{
+  /// 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;
+}
+