#include "TBenchmark.h"
#include "TH1.h"
#include "TBrowser.h"
+#include "Riostream.h"
//#include "TObjectTable.h"
// --- Standard library ---
// --- 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 "AliEMCALJetMicroDst.h"
-//#include "AliMemoryWatcher.h"
+#include "AliEMCALHistoUtilities.h"
ClassImp(AliEMCALSDigitizer)
AliEMCALSDigitizer::AliEMCALSDigitizer():TTask("","")
{
// ctor
- Info("AliEMCALSDigitizer()", " CTOR # 1 #");
fFirstEvent = fLastEvent = fControlHists = 0;
fDefaultInit = kTRUE ;
fHists = 0;
fEventFolderName(eventFolderName)
{
// ctor
- Info("AliEMCALSDigitizer()", " CTOR # 2 #");
fFirstEvent = fLastEvent = fControlHists = 0 ; // runs one event by defaut
Init();
InitParameters() ;
fDefaultInit = kFALSE ;
fHists = 0;
+ fControlHists = 1;
+ if(fControlHists) BookControlHists(1);
}
//____________________________________________________________________________
AliEMCALSDigitizer::AliEMCALSDigitizer(const AliEMCALSDigitizer & sd) : TTask(sd) {
//cpy ctor
- Info("AliEMCALSDigitizer()", " CPY CTOR # 3 #");
fFirstEvent = sd.fFirstEvent ;
fLastEvent = sd.fLastEvent ;
//____________________________________________________________________________
AliEMCALSDigitizer::~AliEMCALSDigitizer() {
- // dtor
- AliEMCALGetter * gime =
- // AliEMCALGetter::Instance(GetTitle(), fEventFolderName.Data());
- AliEMCALGetter::Instance();
- gime->EmcalLoader()->CleanSDigitizer();
+ AliLoader *emcalLoader=0;
+ if ((emcalLoader = AliRunLoader::GetRunLoader()->GetDetectorLoader("EMCAL")))
+ emcalLoader->CleanSDigitizer();
}
//____________________________________________________________________________
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()
{
- AliEMCALGetter * gime = AliEMCALGetter::Instance() ;
- const AliEMCALGeometry * geom = gime->EMCALGeometry() ;
+ const AliEMCALGeometry * geom = AliEMCALGeometry::GetInstance();
if (geom->GetSampling() == 0.) {
Fatal("InitParameters", "Sampling factor not set !") ;
}
// threshold for deposit energy of hit
fECPrimThreshold = 0.; // 24-nov-04 - was 1.e-6;
+ Print("");
}
//____________________________________________________________________________
if(strstr(option,"tim"))
gBenchmark->Start("EMCALSDigitizer");
- //AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle()) ;
- AliEMCALGetter * gime = AliEMCALGetter::Instance() ;
+ 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
}
if (fLastEvent == -1)
- fLastEvent = gime->MaxEvent() - 1 ;
+ fLastEvent = rl->GetNumberOfEvents() - 1 ;
else {
- if(o != "EXACT") fLastEvent = TMath::Min(fFirstEvent, gime->MaxEvent());
- fLastEvent = TMath::Min(fLastEvent, gime->MaxEvent());
- printf("AliEMCALSDigitizer::Exec : option: %s | %i -> %i events : Max events %i \n \n",
- option, fFirstEvent, fLastEvent, gime->MaxEvent());
+ fLastEvent = TMath::Min(fLastEvent, rl->GetNumberOfEvents()-1);
}
Int_t nEvents = fLastEvent - fFirstEvent + 1;
Int_t ievent;
Float_t energy=0.; // de * fSampling - 23-nov-04
- for (ievent = fFirstEvent; ievent < fLastEvent; ievent++) {
- if(ievent%100==0 || ievent==fLastEvent-1) printf(" processed event %i \n", ievent);
- gime->Event(ievent,"XH"); // read primaries and hits onl
- TTree * treeS = gime->TreeS();
- TClonesArray * hits = gime->Hits() ;
- TClonesArray * sdigits = gime->SDigits() ;
+ rl->LoadKinematics();
+ rl->LoadHits("EMCAL");
+
+ for (ievent = fFirstEvent; ievent <= fLastEvent; ievent++) {
+ 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()) ;
+ Int_t nPrim = static_cast<Int_t>((emcalLoader->TreeH())->GetEntries()) ;
+ // This is not true: there is only one list of hits (MvL jan 2006)
// Attention nPrim is the number of primaries tracked by Geant
- // and this number could be different to the number of Primaries in TreeK;
+ // 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) ;
+ rl->Stack()->Particle(iprim) ;
Int_t i;
- AliEMCALGeometry *geom = gime->EMCALGeometry();
+ AliEMCALGeometry *geom = AliEMCALGeometry::GetInstance();
for ( i = 0 ; i < hits->GetEntries() ; i++ ) {
AliEMCALHit * hit = dynamic_cast<AliEMCALHit*>(hits->At(i)) ;
AliEMCALDigit * curSDigit = 0 ;
} else {
Warning("Exec"," abs id %i is bad \n", hit->GetId());
newsdigit = kFALSE;
+ curSDigit = 0;
}
- Int_t check = 0 ;
-
- for(check= 0; check < nSdigits ; check++) {
- sdigit = dynamic_cast<AliEMCALDigit *>(sdigits->At(check)) ;
- if(curSDigit != 0){
+ if(curSDigit != 0){
+ for(Int_t check= 0; check < nSdigits ; check++) {
+ sdigit = dynamic_cast<AliEMCALDigit *>(sdigits->At(check)) ;
+
if( sdigit->GetId() == curSDigit->GetId()) { // Are we in the same ECAL tower ?
- *sdigit = *sdigit + *curSDigit;
- newsdigit = kFALSE;
+ *sdigit = *sdigit + *curSDigit;
+ newsdigit = kFALSE;
}
}
}
nSdigits = sdigits->GetEntriesFast() ;
fSDigitsInRun += nSdigits ;
- sdigits->Expand(nSdigits) ;
Int_t nPrimarymax = -1 ;
Int_t i ;
Double_t e=0.,esum=0.;
- sv::FillH1(fHists, 0, double(sdigits->GetEntriesFast()));
+ 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) ;
- sv::FillH1(fHists, 2, double(sdigit->GetAmp()));
+ AliEMCALHistoUtilities::FillH1(fHists, 2, double(sdigit->GetAmp()));
e = double(Calibrate(sdigit->GetAmp()));
esum += e;
- sv::FillH1(fHists, 3, e);
- sv::FillH1(fHists, 4, double(sdigit->GetId()));
+ AliEMCALHistoUtilities::FillH1(fHists, 3, e);
+ AliEMCALHistoUtilities::FillH1(fHists, 4, double(sdigit->GetId()));
}
- if(esum>0.) sv::FillH1(fHists, 1, esum);
+ if(esum>0.) AliEMCALHistoUtilities::FillH1(fHists, 1, esum);
for (i = 0 ; i < sdigits->GetEntriesFast() ; i++) { // for what
if (((dynamic_cast<AliEMCALDigit *>(sdigits->At(i)))->GetNprimary()) > nPrimarymax)
nPrimarymax = ((dynamic_cast<AliEMCALDigit *>(sdigits->At(i)))->GetNprimary()) ;
}
-
+
// Now write SDigits
- //First list of sdigits
Int_t bufferSize = 32000 ;
- TBranch * sdigitsBranch = treeS->Branch("EMCAL",&sdigits,bufferSize);
+ TBranch * sdigitsBranch = treeS->GetBranch("EMCAL");
+ if (sdigitsBranch)
+ sdigitsBranch->SetAddress(&sdigits);
+ else
+ treeS->Branch("EMCAL",&sdigits,bufferSize);
- sdigitsBranch->Fill() ;
-
- gime->WriteSDigits("OVERWRITE");
+ treeS->Fill();
+
+ emcalLoader->WriteSDigits("OVERWRITE");
//NEXT - SDigitizer
- if(ievent == fFirstEvent) gime->WriteSDigitizer("OVERWRITE"); // why in event cycle ?
+ emcalLoader->WriteSDigitizer("OVERWRITE"); // why in event cycle ?
if(strstr(option,"deb"))
PrintSDigits(option) ;
}
- // gime->WriteSDigitizer("OVERWRITE"); // 12-jan-04
Unload();
- gime->EmcalLoader()->GetSDigitsDataLoader()->GetBaseTaskLoader()->SetDoNotReload(kTRUE);
+ emcalLoader->GetSDigitsDataLoader()->GetBaseTaskLoader()->SetDoNotReload(kTRUE);
if(strstr(option,"tim")){
gBenchmark->Stop("EMCALSDigitizer");
printf("\n Exec: took %f seconds for SDigitizing %f seconds per event\n",
gBenchmark->GetCpuTime("EMCALSDigitizer"), gBenchmark->GetCpuTime("EMCALSDigitizer")/nEvents ) ;
}
-
- //TFile f("out.root","RECREATE");
- //memwatcher.WriteToFile();
- //f.Close();
}
}
//__________________________________________________________________
-void AliEMCALSDigitizer::Print() const
+void AliEMCALSDigitizer::Print(Option_t *option) const
{
// Prints parameters of SDigitizer
- printf("Print: \n------------------- %s -------------\n", 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);
//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("event %i", rl->GetRunLoader()->GetEventNumber());
printf(" Number of entries in SDigits list %i", sdigits->GetEntriesFast());
if(strstr(option,"all")||strstr(option,"EMC")){
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)
TTask::Browse(b);
}
-TList *AliEMCALSDigitizer::BookControlHists(const int var)
+TList *AliEMCALSDigitizer::BookControlHists(int var)
{ // 22-nov-04
gROOT->cd();
- AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle(), fEventFolderName);
- const AliEMCALGeometry *geom = gime->EMCALGeometry() ;
+ const AliEMCALGeometry *geom = AliEMCALGeometry::GetInstance() ;
if(var>=1){
+ printf(" AliEMCALSDigitizer::BookControlHists() in action \n");
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("HSDigiAbsId","EMCAL absID for sdigits",
geom->GetNCells(), 0.5, Double_t(geom->GetNCells())+0.5);
}
- fHists = sv::MoveHistsToList("EmcalSDigiControlHists", kFALSE);
+
+ fHists = AliEMCALHistoUtilities::MoveHistsToList("EmcalSDigiControlHists", kFALSE);
+ fHists = 0;
+
return fHists;
}
void AliEMCALSDigitizer::SaveHists(const char* name, Bool_t kSingleKey, const char* opt)
{
- sv::SaveListOfHists(fHists, name, kSingleKey, opt);
+ AliEMCALHistoUtilities::SaveListOfHists(fHists, name, kSingleKey, opt);
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff