#include "AliMpConstants.h"
#include "AliMpDEIterator.h"
#include "AliMpDEManager.h"
-#include "AliMpIntPair.h"
#include "AliMpPad.h"
#include "AliMpStationType.h"
#include "AliMpVSegmentation.h"
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));
+
}
//_____________________________________________________________________________
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();
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)
{
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);
}
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.
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 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.
return adc;
}
+//_____________________________________________________________________________
+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*)
{
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
AliCodeTimerAuto("")
- if ( !fNoiseFunction )
- {
- fNoiseFunction = new TF1("AliMUONDigitizerV3::fNoiseFunction","gaus",
- fgkNSigmas,fgkNSigmas*10);
-
- fNoiseFunction->SetParameters(1,0,1);
- }
-
for ( Int_t i = 0; i < AliMUONConstants::NTrackingCh(); ++i )
{
AliMpDEIterator it;
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);
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);
fLogger->Log("Added noiseOnly digit");
}
}
- else
- {
- AliError("Pure noise below threshold. This should not happen. Not adding "
- "this digit.");
- }
delete d;
}
}
pad[1] = seg1->PadByPosition(TVector2(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);
return kFALSE;
}
- Int_t runnumber = AliCDBManager::Instance()->GetRun();
-
// Load mapping
if ( ! AliMpCDB::LoadDDLStore() ) {
AliFatal("Could not access mapping from OCDB !");
}
- fCalibrationData = new AliMUONCalibrationData(runnumber);
+ if (!fCalibrationData)
+ AliFatal("Calibration data object not defined");
+
if ( !fCalibrationData->Pedestals() )
{
AliFatal("Could not access pedestals from OCDB !");
{
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",
}
}
}
+
+//_____________________________________________________________________________
+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;
+}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff