//////////////////////////////////////////////////////////////////////////////
// --- ROOT system ---
-#include "TBenchmark.h"
+#include <TBenchmark.h>
+#include <TH1.h>
+#include <TBrowser.h>
+#include <Riostream.h>
+#include <TMath.h>
+#include <TROOT.h>
// --- Standard library ---
#include "stdlib.h"
// --- AliRoot header files ---
+#include "AliLog.h"
+#include "AliRunLoader.h"
+#include "AliStack.h"
#include "AliEMCALDigit.h"
-#include "AliEMCALGetter.h"
+#include "AliEMCALLoader.h"
#include "AliEMCALHit.h"
#include "AliEMCALSDigitizer.h"
#include "AliEMCALGeometry.h"
+#include "AliEMCALHistoUtilities.h"
ClassImp(AliEMCALSDigitizer)
//____________________________________________________________________________
- AliEMCALSDigitizer::AliEMCALSDigitizer():TTask("","")
+AliEMCALSDigitizer::AliEMCALSDigitizer()
+ : TTask("",""),
+ fA(0.),fB(0.),fECPrimThreshold(0.),
+ fDefaultInit(kTRUE),
+ fEventFolderName(0),
+ fInit(0),
+ fSDigitsInRun(0),
+ fFirstEvent(0),
+ fLastEvent(0),
+ fSampling(0.),
+ fControlHists(0),
+ fHists(0)
{
// ctor
- fFirstEvent = fLastEvent = 0 ;
- fDefaultInit = kTRUE ;
+ InitParameters();
}
//____________________________________________________________________________
-AliEMCALSDigitizer::AliEMCALSDigitizer(const char * alirunFileName, const char * eventFolderName):
- TTask("EMCAL"+AliConfig::fgkSDigitizerTaskName, alirunFileName),
- fEventFolderName(eventFolderName)
+AliEMCALSDigitizer::AliEMCALSDigitizer(const char * alirunFileName,
+ const char * eventFolderName)
+ : TTask("EMCAL"+AliConfig::Instance()->GetSDigitizerTaskName(), alirunFileName),
+ fA(0.),fB(0.),fECPrimThreshold(0.),
+ fDefaultInit(kFALSE),
+ fEventFolderName(eventFolderName),
+ fInit(0),
+ fSDigitsInRun(0),
+ fFirstEvent(0),
+ fLastEvent(0),
+ fSampling(0.),
+ fControlHists(1),
+ fHists(0)
{
// ctor
- fFirstEvent = fLastEvent = 0 ; // runs one event by defaut
Init();
InitParameters() ;
- fDefaultInit = kFALSE ;
+ if(fControlHists) BookControlHists(1);
}
//____________________________________________________________________________
-AliEMCALSDigitizer::AliEMCALSDigitizer(const AliEMCALSDigitizer & sd) : TTask(sd) {
+AliEMCALSDigitizer::AliEMCALSDigitizer(const AliEMCALSDigitizer & sd)
+ : TTask(sd.GetName(),sd.GetTitle()),
+ fA(sd.fA),
+ fB(sd.fB),
+ fECPrimThreshold(sd.fECPrimThreshold),
+ fDefaultInit(sd.fDefaultInit),
+ fEventFolderName(sd.fEventFolderName),
+ fInit(sd.fInit),
+ fSDigitsInRun(sd.fSDigitsInRun),
+ fFirstEvent(sd.fFirstEvent),
+ fLastEvent(sd.fLastEvent),
+ fSampling(sd.fSampling),
+ fControlHists(sd.fControlHists),
+ fHists(sd.fHists)
+{
//cpy ctor
-
- fFirstEvent = sd.fFirstEvent ;
- fLastEvent = sd.fLastEvent ;
- fA = sd.fA ;
- fB = sd.fB ;
- fECPrimThreshold = sd.fECPrimThreshold ;
- fSDigitsInRun = sd.fSDigitsInRun ;
- SetName(sd.GetName()) ;
- SetTitle(sd.GetTitle()) ;
- fEventFolderName = sd.fEventFolderName;
}
//____________________________________________________________________________
AliEMCALSDigitizer::~AliEMCALSDigitizer() {
- // dtor
- AliEMCALGetter * gime =
- AliEMCALGetter::Instance(GetTitle(), fEventFolderName.Data());
- gime->EmcalLoader()->CleanSDigitizer();
+ //dtor
+ AliLoader *emcalLoader=0;
+ if ((emcalLoader = AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL")))
+ emcalLoader->CleanSDigitizer();
}
//____________________________________________________________________________
//============================================================= YS
// The initialisation is now done by the getter
- fInit = kTRUE ;
+ fInit = kTRUE;
- AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle(), fEventFolderName.Data());
- if ( gime == 0 ) {
- Fatal("Init", "Could not obtain the Getter objectfor file %s and event %s !", GetTitle(), fEventFolderName.Data()) ;
+ AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
+
+ if ( emcalLoader == 0 ) {
+ Fatal("Init", "Could not obtain the AliEMCALLoader");
return ;
}
- TString opt("SDigits") ;
- if(gime->VersionExists(opt) ) {
- Error( "Init", "Give a version name different from %s", fEventFolderName.Data() ) ;
- fInit = kFALSE ;
- }
-
- gime->PostSDigitizer(this);
- gime->EmcalLoader()->GetSDigitsDataLoader()->GetBaseTaskLoader()->SetDoNotReload(kTRUE);
+ emcalLoader->PostSDigitizer(this);
+ emcalLoader->GetSDigitsDataLoader()->GetBaseTaskLoader()->SetDoNotReload(kTRUE);
}
//____________________________________________________________________________
void AliEMCALSDigitizer::InitParameters()
{
- // Initializes parameters
- fA = 0;
- fB = 10000000.;
+ //initialize parameters for sdigitization
- AliEMCALGetter * gime = AliEMCALGetter::Instance() ;
- const AliEMCALGeometry * geom = gime->EMCALGeometry() ;
+ const AliEMCALGeometry * geom = AliEMCALGeometry::GetInstance();
if (geom->GetSampling() == 0.) {
Fatal("InitParameters", "Sampling factor not set !") ;
}
-// else
-// Info("InitParameters", "Sampling factor set to %f", geom->GetSampling()) ;
+ // Initializes parameters
+ fA = 0;
+ fB = 1.e+6; // Changed 24 Apr 2007. Dynamic range now 2 TeV
+ fSampling = geom->GetSampling();
+
+ // threshold for deposit energy of hit
+ fECPrimThreshold = 0.05;// GeV // 22-may-07 was 0// 24-nov-04 - was 1.e-6;
- // this threshold corresponds approximately to 100 MeV
- fECPrimThreshold = 100E-3;
+ AliDebug(2,Form("Print: \n------------------- %s -------------\n",GetName()));
+ AliDebug(2,Form(" fInit %i\n", int(fInit)));
+ AliDebug(2,Form(" fFirstEvent %i\n", fFirstEvent));
+ AliDebug(2,Form(" fLastEvent %i\n", fLastEvent));
+ AliDebug(2,Form(" Writing SDigits to branch with title %s\n", fEventFolderName.Data()));
+ AliDebug(2,Form(" with digitization parameters A = %f\n", fA));
+ AliDebug(2,Form(" B = %f\n", fB));
+ AliDebug(2,Form(" Threshold for EC Primary assignment = %f\n", fECPrimThreshold));
+ AliDebug(2,Form(" Sampling = %f\n", fSampling));
+ AliDebug(2,Form("---------------------------------------------------\n"));
+
+ // Print("");
+
}
//____________________________________________________________________________
void AliEMCALSDigitizer::Exec(Option_t *option)
{
// Collects all hit of the same tower into digits
+ TString o(option); o.ToUpper();
if (strstr(option, "print") ) {
- Print() ;
+
+ AliDebug(2,Form("Print: \n------------------- %s -------------\n",GetName()));
+ AliDebug(2,Form(" fInit %i\n", int(fInit)));
+ AliDebug(2,Form(" fFirstEvent %i\n", fFirstEvent));
+ AliDebug(2,Form(" fLastEvent %i\n", fLastEvent));
+ AliDebug(2,Form(" Writing SDigits to branch with title %s\n", fEventFolderName.Data()));
+ AliDebug(2,Form(" with digitization parameters A = %f\n", fA));
+ AliDebug(2,Form(" B = %f\n", fB));
+ AliDebug(2,Form(" Threshold for EC Primary assignment = %f\n", fECPrimThreshold));
+ AliDebug(2,Form(" Sampling = %f\n", fSampling));
+ AliDebug(2,Form("---------------------------------------------------\n"));
+
+ // Print();
return ;
}
if(strstr(option,"tim"))
gBenchmark->Start("EMCALSDigitizer");
- AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle()) ;
-
+ AliRunLoader *rl = AliRunLoader::GetRunLoader();
+ AliEMCALLoader *emcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetDetectorLoader("EMCAL"));
+
//switch off reloading of this task while getting event
if (!fInit) { // to prevent overwrite existing file
- Error( "Exec", "Give a version name different from %s", fEventFolderName.Data() ) ;
+ AliError( Form("Give a version name different from %s", fEventFolderName.Data()) ) ;
return ;
}
if (fLastEvent == -1)
- fLastEvent = gime->MaxEvent() - 1 ;
- else
- fLastEvent = TMath::Min(fFirstEvent, gime->MaxEvent()); // only ine event at the time
+ fLastEvent = rl->GetNumberOfEvents() - 1 ;
+ else {
+ fLastEvent = TMath::Min(fLastEvent, rl->GetNumberOfEvents()-1);
+ }
Int_t nEvents = fLastEvent - fFirstEvent + 1;
- Int_t ievent ;
+ Int_t ievent;
+ Float_t energy=0.; // de * fSampling - 23-nov-04
+ rl->LoadKinematics();
+ rl->LoadHits("EMCAL");
+
for (ievent = fFirstEvent; ievent <= fLastEvent; ievent++) {
- gime->Event(ievent,"H") ;
- TTree * treeS = gime->TreeS();
- TClonesArray * hits = gime->Hits() ;
- TClonesArray * sdigits = gime->SDigits() ;
+ rl->GetEvent(ievent);
+ TTree * treeS = emcalLoader->TreeS();
+ if ( !treeS ) {
+ emcalLoader->MakeSDigitsContainer();
+ treeS = emcalLoader->TreeS();
+ }
+ TClonesArray * hits = emcalLoader->Hits() ;
+ TClonesArray * sdigits = emcalLoader->SDigits() ;
sdigits->Clear();
+
Int_t nSdigits = 0 ;
- //Now make SDigits from hits, for EMCAL it is the same, so just copy
- Int_t nPrim = static_cast<Int_t>((gime->TreeH())->GetEntries()) ;
- // Attention nPrim is the number of primaries tracked by Geant
- // and this number could be different to the number of Primaries in TreeK;
- Int_t iprim ;
- for ( iprim = 0 ; iprim < nPrim ; iprim++ ) {
- //=========== Get the EMCAL branch from Hits Tree for the Primary iprim
- gime->Track(iprim) ;
- Int_t i;
- for ( i = 0 ; i < hits->GetEntries() ; i++ ) {
- AliEMCALHit * hit = dynamic_cast<AliEMCALHit*>(hits->At(i)) ;
- AliEMCALDigit * curSDigit = 0 ;
- AliEMCALDigit * sdigit = 0 ;
- Bool_t newsdigit = kTRUE;
-
- // Assign primary number only if deposited energy is significant
- AliEMCALGeometry * geom = gime->EMCALGeometry() ;
- if( geom->IsInECA(hit->GetId()) ){
- if( hit->GetEnergy() > fECPrimThreshold )
- curSDigit = new AliEMCALDigit( hit->GetPrimary(),
- hit->GetIparent(), hit->GetId(),
- Digitize(hit->GetEnergy()), hit->GetTime() ) ;
+ Int_t i;
+ AliEMCALGeometry *geom = AliEMCALGeometry::GetInstance();
+ for ( i = 0 ; i < hits->GetEntries() ; i++ ) {
+ AliEMCALHit * hit = dynamic_cast<AliEMCALHit*>(hits->At(i)) ;
+ AliEMCALDigit * curSDigit = 0 ;
+ AliEMCALDigit * sdigit = 0 ;
+ Bool_t newsdigit = kTRUE;
+
+ // hit->GetId() - Absolute Id number EMCAL segment
+ if(geom->CheckAbsCellId(hit->GetId())) { // was IsInECA(hit->GetId())
+ energy = hit->GetEnergy() * fSampling; // 23-nov-04
+ if(energy > fECPrimThreshold )
+ // Assign primary number only if deposited energy is significant
+ curSDigit = new AliEMCALDigit( hit->GetPrimary(),
+ hit->GetIparent(), hit->GetId(),
+ Digitize(energy), hit->GetTime(),
+ -1, energy ) ;
else
curSDigit = new AliEMCALDigit( -1 ,
-1 ,
hit->GetId(),
- Digitize(hit->GetEnergy()), hit->GetTime() ) ;
- }
- else{
- newsdigit = kFALSE;
- }
-
- Int_t check = 0 ;
-
- for(check= 0; check < nSdigits ; check++) {
+ Digitize(energy), hit->GetTime(),
+ -1, energy ) ;
+ } else {
+ Warning("Exec"," abs id %i is bad \n", hit->GetId());
+ newsdigit = kFALSE;
+ curSDigit = 0;
+ }
+
+ if(curSDigit != 0){
+ for(Int_t check= 0; check < nSdigits ; check++) {
sdigit = dynamic_cast<AliEMCALDigit *>(sdigits->At(check)) ;
- if(curSDigit != 0){
- if( sdigit->GetId() == curSDigit->GetId()) { // Are we in the same ECAL tower ?
+
+ if( sdigit->GetId() == curSDigit->GetId()) { // Are we in the same ECAL tower ?
*sdigit = *sdigit + *curSDigit;
newsdigit = kFALSE;
- }
}
}
- if (newsdigit) {
- new((*sdigits)[nSdigits]) AliEMCALDigit(*curSDigit);
- nSdigits++ ;
- }
- delete curSDigit ;
- } // loop over all hits (hit = deposited energy/entering particle)
- } // loop over iprim
+ }
+ if (newsdigit) {
+ new((*sdigits)[nSdigits]) AliEMCALDigit(*curSDigit);
+ nSdigits++ ;
+ }
+ delete curSDigit ;
+ } // loop over all hits (hit = deposited energy/entering particle)
sdigits->Sort() ;
nSdigits = sdigits->GetEntriesFast() ;
fSDigitsInRun += nSdigits ;
- sdigits->Expand(nSdigits) ;
-
- Int_t nPrimarymax = -1 ;
- Int_t i ;
+
+ Double_t e=0.,esum=0.;
+ AliEMCALHistoUtilities::FillH1(fHists, 0, double(sdigits->GetEntriesFast()));
for (i = 0 ; i < sdigits->GetEntriesFast() ; i++) {
AliEMCALDigit * sdigit = dynamic_cast<AliEMCALDigit *>(sdigits->At(i)) ;
sdigit->SetIndexInList(i) ;
+
+ AliEMCALHistoUtilities::FillH1(fHists, 2, double(sdigit->GetAmp()));
+ e = double(Calibrate(sdigit->GetAmp()));
+ esum += e;
+ AliEMCALHistoUtilities::FillH1(fHists, 3, e);
+ AliEMCALHistoUtilities::FillH1(fHists, 4, double(sdigit->GetId()));
}
-
- for (i = 0 ; i < sdigits->GetEntriesFast() ; i++) {
- if (((dynamic_cast<AliEMCALDigit *>(sdigits->At(i)))->GetNprimary()) > nPrimarymax)
- nPrimarymax = ((dynamic_cast<AliEMCALDigit *>(sdigits->At(i)))->GetNprimary()) ;
- }
+ if(esum>0.) AliEMCALHistoUtilities::FillH1(fHists, 1, esum);
// Now write SDigits
- //First list of sdigits
-
+
Int_t bufferSize = 32000 ;
- TBranch * sdigitsBranch = treeS->Branch("EMCAL",&sdigits,bufferSize);
-
- sdigitsBranch->Fill() ;
-
- gime->WriteSDigits("OVERWRITE");
+ TBranch * sdigitsBranch = treeS->GetBranch("EMCAL");
+ if (sdigitsBranch)
+ sdigitsBranch->SetAddress(&sdigits);
+ else
+ treeS->Branch("EMCAL",&sdigits,bufferSize);
+
+ treeS->Fill();
+
+ emcalLoader->WriteSDigits("OVERWRITE");
//NEXT - SDigitizer
-
- gime->WriteSDigitizer("OVERWRITE");
+ emcalLoader->WriteSDigitizer("OVERWRITE"); // why in event cycle ?
if(strstr(option,"deb"))
PrintSDigits(option) ;
}
-
+
Unload();
- gime->EmcalLoader()->GetSDigitsDataLoader()->GetBaseTaskLoader()->SetDoNotReload(kTRUE);
+ emcalLoader->GetSDigitsDataLoader()->GetBaseTaskLoader()->SetDoNotReload(kTRUE);
if(strstr(option,"tim")){
gBenchmark->Stop("EMCALSDigitizer");
- printf("Exec: took %f seconds for SDigitizing %f seconds per event",
- gBenchmark->GetCpuTime("EMCALSDigitizer"), gBenchmark->GetCpuTime("EMCALSDigitizer")/nEvents ) ;
+ printf("\n Exec: took %f seconds for SDigitizing %f seconds per event\n",
+ gBenchmark->GetCpuTime("EMCALSDigitizer"), gBenchmark->GetCpuTime("EMCALSDigitizer")/nEvents ) ;
}
}
+//__________________________________________________________________
+
+Int_t AliEMCALSDigitizer::Digitize(Float_t energy)const {
+ // Digitize the energy
+ Double_t aSignal = fA + energy*fB;
+ if (TMath::Abs(aSignal)>2147483647.0) {
+ //PH 2147483647 is the max. integer
+ //PH This apparently is a problem which needs investigation
+ AliWarning(Form("Too big or too small energy %f",aSignal));
+ aSignal = TMath::Sign((Double_t)2147483647,aSignal);
+ }
+ return (Int_t ) aSignal;
+ }
+
+
+//__________________________________________________________________
+
+void AliEMCALSDigitizer::Print1(Option_t * option)
+{
+ Print();
+ PrintSDigits(option);
+}
//__________________________________________________________________
-void AliEMCALSDigitizer::Print()const
+void AliEMCALSDigitizer::Print(Option_t *option) const
{
// Prints parameters of SDigitizer
- printf("Print: \n------------------- %s -------------", GetName() ) ;
+ printf("Print: \n------------------- %s ------------- option %s\n", GetName() , option) ;
+ printf(" fInit %i\n", int(fInit));
+ printf(" fFirstEvent %i\n", fFirstEvent);
+ printf(" fLastEvent %i\n", fLastEvent);
printf(" Writing SDigits to branch with title %s\n", fEventFolderName.Data()) ;
- printf(" with digitization parameters A = %f\n", fA) ;
- printf(" B = %f\n", fB) ;
- printf(" Threshold for EC Primary assignment= %f\n", fECPrimThreshold) ;
+ printf(" with digitization parameters A = %f\n", fA) ;
+ printf(" B = %f\n", fB) ;
+ printf(" Threshold for EC Primary assignment = %f\n", fECPrimThreshold) ;
+ printf(" Sampling = %f\n", fSampling);
printf("---------------------------------------------------\n") ;
-
}
//__________________________________________________________________
//Prints list of digits produced at the current pass of AliEMCALDigitizer
- AliEMCALGetter * gime = AliEMCALGetter::Instance() ;
- const TClonesArray * sdigits = gime->SDigits() ;
+ // AliEMCALGetter * gime = AliEMCALGetter::Instance() ;
+ AliEMCALLoader *rl = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
+ const TClonesArray * sdigits = rl->SDigits() ;
printf("\n") ;
- printf("event %i", gAlice->GetEvNumber()) ;
- printf("\n Number of entries in SDigits list %i", sdigits->GetEntriesFast());
+ printf("event %i", rl->GetRunLoader()->GetEventNumber());
+ printf(" Number of entries in SDigits list %i", sdigits->GetEntriesFast());
if(strstr(option,"all")||strstr(option,"EMC")){
//loop over digits
AliEMCALDigit * digit;
printf("\n Id Amplitude Time Index Nprim: Primaries list \n") ;
- Int_t index ;
+ Int_t index, isum=0;
char * tempo = new char[8192];
for (index = 0 ; index < sdigits->GetEntries() ; index++) {
digit = dynamic_cast<AliEMCALDigit *>( sdigits->At(index) ) ;
sprintf(tempo, "\n%6d %8d %6.5e %4d %2d :",
digit->GetId(), digit->GetAmp(), digit->GetTime(), digit->GetIndexInList(), digit->GetNprimary()) ;
- printf(tempo);
+ printf(tempo);
+ isum += digit->GetAmp();
Int_t iprimary;
for (iprimary=0; iprimary<digit->GetNprimary(); iprimary++) {
}
}
delete tempo ;
- }
+ printf("\n** Sum %i : %10.3f GeV/c **\n ", isum, double(isum)*1.e-6);
+ } else printf("\n");
}
//____________________________________________________________________________
void AliEMCALSDigitizer::Unload() const
{
// Unload Hits and SDigits from the folder
- AliEMCALGetter * gime = AliEMCALGetter::Instance() ;
- AliEMCALLoader * loader = gime->EmcalLoader() ;
- loader->UnloadHits() ;
- loader->UnloadSDigits() ;
+ AliEMCALLoader *rl = dynamic_cast<AliEMCALLoader*>(AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL"));
+ rl->UnloadHits() ;
+ rl->UnloadSDigits() ;
+}
+
+void AliEMCALSDigitizer::Browse(TBrowser* b)
+{
+ if(fHists) b->Add(fHists);
+ TTask::Browse(b);
+}
+
+TList *AliEMCALSDigitizer::BookControlHists(int var)
+{
+ //book histograms for monitoring sdigitization
+ // 22-nov-04
+ gROOT->cd();
+ const AliEMCALGeometry *geom = AliEMCALGeometry::GetInstance() ;
+ if(var>=1){
+ AliDebug(1, " BookControlHists() in action ");
+ new TH1F("HSDigiN", "#EMCAL sdigits ", 1001, -0.5, 1000.5);
+ new TH1F("HSDigiSumEnergy","Sum.EMCAL energy", 1000, 0.0, 100.);
+ new TH1F("HSDigiAmp", "EMCAL sdigits amplitude", 1000, 0., 2.e+9);
+ new TH1F("HSDigiEnergy","EMCAL cell energy", 1000, 0.0, 100.);
+ new TH1F("HSDigiAbsId","EMCAL absID for sdigits",
+ geom->GetNCells(), 0.5, Double_t(geom->GetNCells())+0.5);
+ }
+
+ fHists = AliEMCALHistoUtilities::MoveHistsToList("EmcalSDigiControlHists", kFALSE);
+ // fHists = 0; ??
+
+ return fHists;
+}
+
+void AliEMCALSDigitizer::SaveHists(const char* name, Bool_t kSingleKey, const char* opt)
+{
+ AliEMCALHistoUtilities::SaveListOfHists(fHists, name, kSingleKey, opt);
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff