From 990119d6135a6dabeff252828891563af675574e Mon Sep 17 00:00:00 2001 From: schutz Date: Mon, 12 Mar 2001 15:26:48 +0000 Subject: [PATCH] new classes for digitization derived from TTask --- PHOS/AliPHOSDigit.cxx | 9 +- PHOS/AliPHOSDigit.h | 1 + PHOS/AliPHOSDigitizer.cxx | 573 +++++++++++++++++++++++++++++++++++++ PHOS/AliPHOSDigitizer.h | 78 +++++ PHOS/AliPHOSEmcRecPoint.h | 2 +- PHOS/AliPHOSSDigitizer.cxx | 222 ++++++++++++++ PHOS/AliPHOSSDigitizer.h | 55 ++++ PHOS/Makefile | 3 +- PHOS/PHOSLinkDef.h | 2 + 9 files changed, 942 insertions(+), 3 deletions(-) create mode 100644 PHOS/AliPHOSDigitizer.cxx create mode 100644 PHOS/AliPHOSDigitizer.h create mode 100644 PHOS/AliPHOSSDigitizer.cxx create mode 100644 PHOS/AliPHOSSDigitizer.h diff --git a/PHOS/AliPHOSDigit.cxx b/PHOS/AliPHOSDigit.cxx index 18aa5c1d36f..8857742736a 100644 --- a/PHOS/AliPHOSDigit.cxx +++ b/PHOS/AliPHOSDigit.cxx @@ -129,7 +129,14 @@ Int_t AliPHOSDigit::GetPrimary(Int_t index) const return rv ; } - +//____________________________________________________________________________ +void AliPHOSDigit::ShiftPrimary(Int_t shift){ + //shifts primary nimber to BIG offset, to separate primary in different TreeK + Int_t index ; + for(index = 0; index ExecuteTask() +// Warning in : object already instantiated +// //Digitizes SDigitis in all events found in file galice.root +// //Depending on variable "CONFIG_SPLIT_FILE" reads branches stored in galice.root +// //or in PHOS.SDigits.root +// root[2] AliPHOSDigitizer * d1 = new AliPHOSDigitizer("galice1.root") ; // Will read sdigits from galice1.root +// root[3] d1->MixWith("galice2.root",1) // Reads another portion of sdigits from galice2.root +// // says, that this will be output file +// Warning in : object already instantiated +// root[3] d1->MixWith("galice3.root",1) // Reads another portion of sdigits from galice3.root +// // overwrides previous definition of output file +// root[4] d->ExecuteTask() // Reads SDigits from files galice1.root, galice2.root .... +// // mixes them and stores produced Digits in file galice3.root +// +// +// + +// --- ROOT system --- +#include "TTask.h" +#include "TTree.h" +#include "TSystem.h" +// --- Standard library --- + +// --- AliRoot header files --- + +#include "AliPHOSDigit.h" +#include "AliPHOSHit.h" +#include "AliPHOSv1.h" +#include "AliPHOSDigitizer.h" +#include "AliPHOSSDigitizer.h" +#include "TROOT.h" +#include "TFolder.h" + +ClassImp(AliPHOSDigitizer) + + +//____________________________________________________________________________ + AliPHOSDigitizer::AliPHOSDigitizer():TTask("AliPHOSDigitizer","") +{ + // ctor + + fSDigitizer = 0 ; + fNinputs = 1 ; + fPinNoise = 0.01 ; + fEMCDigitThreshold = 0.01 ; + fCPVNoise = 0.01; + fCPVDigitThreshold = 0.09 ; + fPPSDNoise = 0.0000001; + fPPSDDigitThreshold = 0.0000002 ; + fInitialized = kFALSE ; + // add Task to //root/Tasks folder + TTask * roottasks = (TTask*)gROOT->GetRootFolder()->FindObject("Tasks") ; + roottasks->Add(this) ; + +} +//____________________________________________________________________________ +void AliPHOSDigitizer::Init(Int_t isOutFile){ +// Mades all memory allocations and defiles, +// whether first (default) file will be output file (isOutFile !=0) + + if(!fInitialized){ + + fHeaderFiles = new TClonesArray("TObjString",1) ; + new((*fHeaderFiles)[0]) TObjString("galice.root") ; + TFile * file ; + + if(isOutFile) + file = new TFile(((TObjString *) fHeaderFiles->At(0))->GetString(),"update") ; + else + file = new TFile(((TObjString *) fHeaderFiles->At(0))->GetString()) ; + + file->cd() ; + + fSDigitsFiles = new TClonesArray("TObjString",1); + if(gSystem->Getenv("CONFIG_SPLIT_FILE")) + new((*fSDigitsFiles)[0]) TObjString("./PHOS.SDigits.root") ; + else + new((*fSDigitsFiles)[0]) TObjString("") ; + + fSDigits = new TClonesArray("TClonesArray",1) ; + new((*fSDigits)[0]) TClonesArray("AliPHOSDigit",1000) ; + + fDigits = new TClonesArray("AliPHOSDigit",200000) ; + + fIevent = new TArrayI(1) ; + fIevent->AddAt(-1,0 ) ; + fIeventMax = new TArrayI(1) ; + + //Store digits in this file + if(isOutFile){ + gAlice = (AliRun *) file->Get("gAlice") ; + fIeventMax->AddAt((Int_t) gAlice->TreeE()->GetEntries(), 0 ); + fOutFileNumber = 0 ; + } + else{ + TTree * te = (TTree *) file->Get("TE") ; + fIeventMax->AddAt((Int_t) te->GetEntries(), 0 ); + fOutFileNumber = -1 ; + } + + fInitialized = kTRUE ; + } + +} + + +//____________________________________________________________________________ +AliPHOSDigitizer::AliPHOSDigitizer(char *HeaderFile,char *DigitsFile = 0):TTask("AliPHOSDigitizer","") +{ + // ctor + fHeaderFiles = new TClonesArray("TFile",1) ; + new((*fHeaderFiles)[0]) TObjString(HeaderFile) ; + TFile * file = new TFile(((TObjString *) fHeaderFiles->At(0))->GetString(),"update") ; // Header file, where result will be stored + + file->cd() ; + + fSDigitsFiles = new TClonesArray("TObjString",1); // File name of the SDigits branch + if(DigitsFile) + new((*fSDigitsFiles)[0]) TObjString(DigitsFile) ; + else + if(gSystem->Getenv("CONFIG_SPLIT_FILE")) + new((*fSDigitsFiles)[0]) TObjString("./PHOS.SDigits.root") ; + else + new((*fSDigitsFiles)[0]) TObjString("") ; + + fSDigits = new TClonesArray("TClonesArray",1) ; // here list of SDigits wil be stored + new((*fSDigits)[0]) TClonesArray("AliPHOSDigit",1000) ; + + fDigits = new TClonesArray("AliPHOSDigit",200000) ; + fDigitsFile="PHOS.Digits" ; + + fIevent = new TArrayI(1) ; + fIevent->AddAt(-1,0 ) ; + fIeventMax = new TArrayI(1) ; + //Should be check whether gAlice in memory is the same as in file + //However, there is no such method (?) ==> we are forced to read it + // if(gAlice->TreeE()==0) + + gAlice = (AliRun *) file->Get("gAlice") ; //If not read yet + + // Get number of events to process + fIeventMax->AddAt((Int_t) gAlice->TreeE()->GetEntries(), 0 ); + fOutFileNumber = 0 ; + + fNinputs = 1 ; + + fPinNoise = 0.01 ; + fEMCDigitThreshold = 0.01 ; + fCPVNoise = 0.01; + fCPVDigitThreshold = 0.09 ; + fPPSDNoise = 0.0000001; + fPPSDDigitThreshold = 0.0000002 ; + + // add Task to //root/Tasks folder + TTask * roottasks = (TTask*)gROOT->GetRootFolder()->FindObject("Tasks") ; + roottasks->Add(this) ; + fInitialized = kTRUE ; + +} + +//____________________________________________________________________________ + AliPHOSDigitizer::~AliPHOSDigitizer() +{ + // dtor + delete fHeaderFiles ; + delete fSDigitsFiles ; + delete fSDigits ; + delete fDigits ; +} +//____________________________________________________________________________ +Bool_t AliPHOSDigitizer::Combinator() { + + //Makes all desirable combinations Signal+Background, + // returns kFALSE when all combinations are made + // May be useful to introduce some options like "One-to-One", "All-to-One" and "All-to-All" ? + + //realizing "One-to-One" option... + + if(!fInitialized) + Init(1) ; + + Int_t inputs ; + Bool_t endNotReached = kTRUE ; + + for(inputs = 0; (inputs < fNinputs) && endNotReached ;inputs++){ + if(fIevent->At(inputs)+1 < fIeventMax->At(inputs)) + fIevent->AddAt(fIevent->At(inputs)+1, inputs ) ; + else + endNotReached = kFALSE ; + } + return endNotReached ; + +} + +//____________________________________________________________________________ +void AliPHOSDigitizer::Digitize(Option_t *option) { + + //Makes the digitization of the collected summable digits + + if(!fInitialized) + Init(1) ; + + //Collects all hits in the same active volume into digit + //if(option == "raw") // add simulated data to row data -- to be implemented + + + fDigits->Clear() ; + + AliPHOS * PHOS = (AliPHOS *) gAlice->GetDetector("PHOS") ; + AliPHOSGeometry *geom = AliPHOSGeometry::GetInstance( PHOS->GetGeometry()->GetName(), PHOS->GetGeometry()->GetTitle() ); + + //Making digits with noise, first EMC + Int_t nEMC = geom->GetNModules()*geom->GetNPhi()*geom->GetNZ(); + + Int_t nCPV ; + Int_t nPPSD ; + Int_t absID ; + TString name = geom->GetName() ; + + if ( name == "IHEP" || name == "MIXT" ) + nCPV =nEMC + geom->GetNumberOfCPVPadsZ()*geom->GetNumberOfCPVPadsPhi()* + geom->GetNCPVModules()*geom->GetNumberOfCPVLayers() ; + else + nCPV = nEMC; + + if ( name == "GPS2" || name == "MIXT" ) + nPPSD =nCPV+2*geom->GetNPPSDModules()*geom->GetNumberOfModulesPhi()*geom->GetNumberOfModulesZ()* + geom->GetNumberOfPadsPhi()*geom->GetNumberOfPadsZ() ; + else + nPPSD = nCPV; + + for(absID = 1; absID <= nEMC; absID++){ + Float_t noise = gRandom->Gaus(0., fPinNoise) ; + new((*fDigits)[absID-1]) AliPHOSDigit( -1,absID,fSDigitizer->Digitize(noise) ) ; + } + + for(absID = nEMC+1; absID <= nCPV; absID++){ + Float_t noise = gRandom->Gaus(0., fCPVNoise) ; + new((*fDigits)[absID-1]) AliPHOSDigit( -1,absID,fSDigitizer->Digitize(noise) ) ; + } + + for(absID = nCPV+1; absID <= nPPSD; absID++){ + Float_t noise = gRandom->Gaus(0., fPPSDNoise) ; + new((*fDigits)[absID-1]) AliPHOSDigit( -1,absID,fSDigitizer->Digitize(noise) ) ; + } + + + // Now look throught (unsorted) list of SDigits and add corresponding digits + AliPHOSDigit *curSDigit ; + AliPHOSDigit *digit ; + + Int_t inputs; + for(inputs = 0; inputs< fNinputs ; inputs++){ //loop over (possible) merge sources + + TClonesArray * sdigits= (TClonesArray *)fSDigits->At(inputs) ; + Int_t isdigit ; + Int_t nSDigits = sdigits->GetEntries() ; + for(isdigit=0;isdigit< nSDigits; isdigit++){ + curSDigit = (AliPHOSDigit *)sdigits->At(isdigit) ; + if(inputs) //Shift primaries for non-background sdigits + curSDigit->ShiftPrimary(inputs) ; + digit = (AliPHOSDigit *)fDigits->At(curSDigit->GetId() - 1); + *digit = *digit + *curSDigit ; + } + } + + + + //remove digits below thresholds + for(absID = 0; absID < nEMC ; absID++) + if(fSDigitizer->Calibrate(((AliPHOSDigit*)fDigits->At(absID))->GetAmp()) < fEMCDigitThreshold) + fDigits->RemoveAt(absID) ; + for(absID = nEMC; absID < nCPV ; absID++) + if(fSDigitizer->Calibrate(((AliPHOSDigit*)fDigits->At(absID))->GetAmp()) < fCPVDigitThreshold) + fDigits->RemoveAt(absID) ; + for(absID = nCPV; absID < nPPSD ; absID++) + if(fSDigitizer->Calibrate(((AliPHOSDigit *)fDigits->At(absID))->GetAmp()) < fPPSDDigitThreshold) + fDigits->RemoveAt(absID) ; + + fDigits->Compress() ; + + Int_t ndigits = fDigits->GetEntries() ; + fDigits->Expand(ndigits) ; + + + //Set indexes in list of digits + Int_t i ; + for (i = 0 ; i < ndigits ; i++) { + AliPHOSDigit * digit = (AliPHOSDigit *) fDigits->At(i) ; + digit->SetIndexInList(i) ; + } +} +//____________________________________________________________________________ +void AliPHOSDigitizer::WriteDigits(){ + + //Made TreeD in the output file if necessary and writes digiths there. + + gAlice->GetEvent(fIevent->At(fOutFileNumber)) ; // Suitable only for One-To-One mixing + gAlice->SetEvent(fIevent->At(fOutFileNumber)) ; // for all-to-all will produce a lot of branches in TreeD + + if(gAlice->TreeD()==0) + gAlice->MakeTree("D") ; + + //Make branches in TreeD for digits and Digitizer + char branchname[20]; + sprintf(branchname,"PHOS"); + + Int_t bufferSize = 16000 ; + char * filename = 0; + if(!fDigitsFile.IsNull()) + filename = (char*) fDigitsFile.Data() ; //ievent ; + else + if(gSystem->Getenv("CONFIG_SPLIT_FILE")!=0){ //generating file name + filename = new char[30] ; + // sprintf(filename,"PHOS.Digits%d.root",ievent) ; + sprintf(filename,"PHOS.Digits.root") ; + } + else + filename = 0 ; + + //Link digits + gAlice->MakeBranchInTree(gAlice->TreeD(),branchname,&fDigits,bufferSize,filename); + //Link Digitizer + AliPHOSDigitizer * d = this ; + Int_t splitlevel = 0 ; + sprintf(branchname,"AliPHOSDigitizer"); + gAlice->MakeBranchInTree(gAlice->TreeD(),branchname,"AliPHOSDigitizer",&d, bufferSize, splitlevel,filename); + + gAlice->TreeD()->Fill() ; + + gAlice->TreeD()->Write(0,kOverwrite) ; +} + +//____________________________________________________________________________ +void AliPHOSDigitizer::Exec(Option_t *option) { + //manager + + if(!fInitialized) Init(1) ; + + while(Combinator()){ + + if(!ReadSDigits()) //read sdigits event(s) evaluated by Combinator() from file(s) + return ; + + Digitize(option) ; //Add prepared SDigits to digits and add the noise + WriteDigits() ; + } + +// //Close all opened files +// Int_t input ; +// for(input = 0; input < fNinputs ; input ++){ +// TFile * file = (TFile*) gROOT->GetFile(((TObjString *) fHeaderFiles->At(input))->GetString() ) ; +// file->Close() ; +// } + + +} + +//__________________________________________________________________ +Bool_t AliPHOSDigitizer::ReadSDigits(){ +// Reads summable digits from the opened files for the particular set of events given by fIevent + + if(!fInitialized) Init(1) ; + + Int_t inputs ; + for(inputs = fNinputs-1; inputs >= 0; inputs --){ + + Int_t event = fIevent->At(inputs) ; + + TFile * file = (TFile*) gROOT->GetFile(((TObjString *) fHeaderFiles->At(inputs))->GetString() ) ; + file->cd() ; + + // Get SDigits Tree header from file + char treeName[20]; + sprintf(treeName,"TreeS%d",event); + TTree * treeS = (TTree*)file->Get(treeName); + + if(treeS==0){ + cout << "Error at AliPHOSDigitizer: no "<GetName() << endl ; + cout << "Do nothing " << endl ; + return kFALSE ; + } + + TBranch * sdigitsBranch = 0; + TBranch * sdigitizerBranch = 0; + + TObjArray * branches = treeS->GetListOfBranches() ; + Int_t ibranch; + Bool_t phosNotFound = kTRUE ; + Bool_t sdigitizerNotFound = kTRUE ; + + for(ibranch = 0;ibranch GetEntries();ibranch++){ + + if(phosNotFound){ + sdigitsBranch=(TBranch *) branches->At(ibranch) ; + if( ((TObjString*)fSDigitsFiles->At(inputs))->GetString().CompareTo(sdigitsBranch->GetFileName())==0 ){ + if( strcmp(sdigitsBranch->GetName(),"PHOS") == 0) { + phosNotFound = kFALSE ; + } + } + } + + if(sdigitizerNotFound){ + sdigitizerBranch = (TBranch *) branches->At(ibranch) ; + if( ((TObjString*)fSDigitsFiles->At(inputs))->GetString().CompareTo(sdigitizerBranch->GetFileName()) == 0){ + if( strcmp(sdigitizerBranch->GetName(),"AliPHOSSDigitizer") == 0) { + sdigitizerNotFound = kFALSE ; + } + } + } + + } + + if(sdigitizerNotFound || phosNotFound){ + cout << "Can't find Branch with sdigits or SDigitizer in the file " ; + if( ((TObjString*)fSDigitsFiles->At(inputs))->GetString().IsNull() ) + cout << file->GetName() << endl ; + else + cout << ((TObjString*)fSDigitsFiles->At(inputs))->GetString().Data() << endl ; + cout << "Do nothing" <At(inputs) ; + sdigitsBranch->SetAddress(&sdigits) ; + + AliPHOSSDigitizer *sDigitizer = new AliPHOSSDigitizer(); + sdigitizerBranch->SetAddress(&sDigitizer) ; + treeS->GetEvent(0) ; + + if(fSDigitizer == 0) + fSDigitizer = sDigitizer ; + else + if(!((*fSDigitizer)==(*sDigitizer)) ){ + cout << "ERROR: you are using sdigits made with different SDigitizers" << endl ; + fSDigitizer->Print("") ; + sDigitizer->Print("") ; + cout << "Do Nothing " << endl ; + return kFALSE ; + } + + } + + + return kTRUE ; + +} +//__________________________________________________________________ +void AliPHOSDigitizer::MixWith(char* HeaderFile,Int_t isOutFile = 1, char* SDigitsFile =0){ +// + + if(!fInitialized) + if(isOutFile) + Init(0) ; //Do not read gAlice from Background file + else + Init(1) ; //read gAlice from background file + + if(HeaderFile == 0){ + cout << "Specify at least header file to merge"<< endl ; + return ; + } + + Int_t inputs ; + for(inputs = 0; inputs < fNinputs ; inputs++){ + if(strcmp(((TObjString *)fHeaderFiles->At(inputs))->GetString(),HeaderFile) == 0 ){ + if(SDigitsFile == 0){ + if(((TObjString*)fSDigitsFiles->At(inputs))->GetString().CompareTo("") == 0){ + cout << "Entry already exists, do not add" << endl ; + return ; + } + } + else + if(((TObjString*)fSDigitsFiles->At(inputs))->GetString().CompareTo(SDigitsFile) == 0){ + cout << "Entry already exists, do not add" << endl ; + return; + } + } + } + + fHeaderFiles->Expand(fNinputs+1) ; + new((*fHeaderFiles)[fNinputs]) TObjString(HeaderFile) ; + + + TFile * file ; + if(isOutFile) + file = new TFile(((TObjString *) fHeaderFiles->At(fNinputs))->GetString(),"update") ; + else + file = new TFile(((TObjString *) fHeaderFiles->At(fNinputs))->GetString()) ; + + file->cd() ; + + fSDigitsFiles->Expand(fNinputs+1) ; + new((*fSDigitsFiles)[fNinputs]) TObjString(SDigitsFile) ; + + fSDigits->Expand(fNinputs+1) ; + new((*fSDigits)[fNinputs]) TClonesArray("AliPHOSDigit",1000) ; + + fIevent->Set(fNinputs+1) ; + fIevent->AddAt(-1, fNinputs) ; + + fIeventMax->Set(fNinputs+1) ; + + if(isOutFile){ + gAlice = (AliRun*) file->Get("gAlice") ; + fIeventMax->AddAt((Int_t) gAlice->TreeE()->GetEntries(), fNinputs ); + fOutFileNumber = fNinputs ; + } + else{ + TTree * te = (TTree *) file->Get("TE") ; + fIeventMax->AddAt((Int_t) te->GetEntries(), fNinputs ); + } + + fNinputs++ ; + +} +//__________________________________________________________________ +void AliPHOSDigitizer::Print(Option_t* option){ + + if(!fInitialized) Init(1) ; + + cout << "------------------- "<< GetName() << " -------------" << endl ; + cout << "Digitizing sDigits from file(s): " <At(input))->GetString() << + " Branch: " << ((TObjString *) fSDigitsFiles->At(input))->GetString() << endl ; + } + cout << endl ; + cout << "Writing digits to " << ((TObjString *) fHeaderFiles->At(fOutFileNumber))->GetString() << endl ; + + cout << endl ; + cout << "With following parameters: " << endl ; + cout << " Electronics noise in EMC (fPinNoise) = " << fPinNoise << endl ; + cout << " Threshold in EMC (fEMCDigitThreshold) = " << fEMCDigitThreshold << endl ; ; + cout << " Noise in CPV (fCPVNoise) = " << fCPVNoise << endl ; + cout << " Threshold in CPV (fCPVDigitThreshold) = " << fCPVDigitThreshold << endl ; + cout << " Noise in PPSD (fPPSDNoise) = " << fPPSDNoise << endl ; + cout << " Threshold in PPSD (fPPSDDigitThreshold) = " << fPPSDDigitThreshold << endl ; + cout << "---------------------------------------------------" << endl ; + + + +} diff --git a/PHOS/AliPHOSDigitizer.h b/PHOS/AliPHOSDigitizer.h new file mode 100644 index 00000000000..89d133f4d26 --- /dev/null +++ b/PHOS/AliPHOSDigitizer.h @@ -0,0 +1,78 @@ +#ifndef ALIPHOSDigitizer_H +#define ALIPHOSDigitizer_H +/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +/* $Id$ */ + +//_________________________________________________________________________ +// Task Class for making SDigits in PHOS +// +//*-- Author: Dmitri Peressounko(SUBATECH & KI) + + +// --- ROOT system --- +#include "TTask.h" +#include "TObjString.h" +// --- Standard library --- + +// --- AliRoot header files --- + +class AliPHOSSDigitizer ; + +class AliPHOSDigitizer: public TTask { + +public: + AliPHOSDigitizer() ; // ctor + AliPHOSDigitizer(char *HeaderFile,char * SDigitsBrancheFile = 0) ; + virtual ~AliPHOSDigitizer() ; + Bool_t Combinator() ; // makes all desirable combination sig+Bg + void Exec(Option_t *option); // Does the job + void Digitize(Option_t *option); // Digitizes SDigits stored in fSDigits + Float_t GetPinNoise() const { return fPinNoise;} + Float_t GetEMCThreshold() const { return fEMCDigitThreshold;} + Float_t GetCPVNoise() const { return fCPVNoise ;} + Float_t GetCPVThreshold() const { return fCPVDigitThreshold ;} + Float_t GetPPSDNoise() const { return fPPSDNoise ;} + Float_t GetPPSDThreshold()const { return fPPSDDigitThreshold ;} + void MixWith(char* HeaderFile, Int_t isOutFile = 1, char* SDigitsFile =0) ; // Add another one file to mix + void Print(Option_t* option) ; + void SetPinNoise(Float_t PinNoise ) {fPinNoise = PinNoise;} + void SetEMCThreshold(Float_t EMCThreshold) {fEMCDigitThreshold = EMCThreshold;} + void SetCPVNoise(Float_t CPVNoise) {fCPVNoise = CPVNoise;} + void SetCPVThreshold(Float_t CPVThreshold) {fCPVDigitThreshold= CPVThreshold;} + void SetPPSDNoise(Float_t PPSDNoise) {fPPSDNoise = PPSDNoise;} + void SetPPSDThreshold(Float_t PPSDThreshold){fPPSDDigitThreshold = PPSDThreshold;} + +private: + void Init(Int_t isOutFile); + Bool_t ReadSDigits() ; // Read sdigits for particular events + void WriteDigits() ; // Writes Digits for particular event + +private: + TClonesArray * fSDigitsFiles ; // Names of sdigits branches + TClonesArray * fHeaderFiles ; // Names of files with headers to merge + TString fDigitsFile ; // Name of the Digits Branch + Int_t fOutFileNumber ; // Number of the header file into which Digits are written + TClonesArray * fSDigits ; // ! Lists of SDigits + TClonesArray * fDigits ; // ! Final list of digits + AliPHOSSDigitizer * fSDigitizer ; // ! SDigitizer to extarct some digitizing parameters + Int_t fNinputs ; // Number of input files + Bool_t fInitialized ; // if background file already read? + TArrayI * fIevent ; // events to read at the next ReadSDigits() call + TArrayI * fIeventMax ; // Maximal number of events in each input file + + Float_t fPinNoise ; // Electronics noise in EMC + Float_t fEMCDigitThreshold ; // Threshold for storing digits in EMC + Float_t fCPVNoise ; // Noise in CPV + Float_t fCPVDigitThreshold ; // Threshold for storing digits in CPV + Float_t fPPSDNoise ; // Noise in PPSD + Float_t fPPSDDigitThreshold ; // Threshold for storing digits in PPSD + + + ClassDef(AliPHOSDigitizer,1) // description + +}; + + +#endif // AliPHOSDigitizer_H diff --git a/PHOS/AliPHOSEmcRecPoint.h b/PHOS/AliPHOSEmcRecPoint.h index e7e9b83adeb..aae870eb72b 100644 --- a/PHOS/AliPHOSEmcRecPoint.h +++ b/PHOS/AliPHOSEmcRecPoint.h @@ -42,7 +42,7 @@ public: virtual void AddDigit(AliPHOSDigit & digit, Float_t Energy) ; // add a digit to the digits list Int_t Compare(const TObject * obj) const; // method for sorting - Float_t CoreEnergy() ; + Float_t CoreEnergy() ; void EvalAll() ; void EvalLocalPosition() ; // computes the position in the PHOS module Float_t GetDelta () const { return fDelta ; } diff --git a/PHOS/AliPHOSSDigitizer.cxx b/PHOS/AliPHOSSDigitizer.cxx new file mode 100644 index 00000000000..9780671a2df --- /dev/null +++ b/PHOS/AliPHOSSDigitizer.cxx @@ -0,0 +1,222 @@ +/************************************************************************** + * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * * + * Author: The ALICE Off-line Project. * + * Contributors are mentioned in the code where appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ + +/* $Id$ */ + +//_________________________________________________________________________ +// This is a TTask that constructs SDigits out of Hits +// A Summable Digits is the sum of all hits in a cell +// A threshold is applied +// +//*-- Author : Dmitri Peressounko (SUBATECH & KI) +////////////////////////////////////////////////////////////////////////////// + +// --- ROOT system --- +#include "TTask.h" +#include "TTree.h" +#include "TSystem.h" +// --- Standard library --- + +// --- AliRoot header files --- + +#include "AliPHOSDigit.h" +#include "AliPHOSHit.h" +#include "AliPHOSv1.h" +#include "AliPHOSSDigitizer.h" + +#include "TROOT.h" +#include "TFolder.h" + +ClassImp(AliPHOSSDigitizer) + + +//____________________________________________________________________________ + AliPHOSSDigitizer::AliPHOSSDigitizer():TTask("AliPHOSSDigitizer","") +{ + // ctor + fA = 0; + fB = 10000000. ; + fPrimThreshold = 0.01 ; + fNevents = 0 ; // Number of events to digitize, 0 means all evens in current file + // add Task to //root/Tasks folder + TTask * roottasks = (TTask*)gROOT->GetRootFolder()->FindObject("Tasks") ; + roottasks->Add(this) ; + +} +//____________________________________________________________________________ +AliPHOSSDigitizer::AliPHOSSDigitizer(char* HeaderFile, char *SDigitsFile):TTask("AliPHOSSDigitizer","") +{ + // ctor + fA = 0; + fB = 10000000.; + fPrimThreshold = 0.01 ; + fNevents = 0 ; // Number of events to digitize, 0 means all events in current file + fSDigitsFile = SDigitsFile ; + fHeadersFile = HeaderFile ; + //add Task to //root/Tasks folder + TTask * roottasks = (TTask*)gROOT->GetRootFolder()->FindObject("Tasks") ; + roottasks->Add(this) ; + +} + +//____________________________________________________________________________ + AliPHOSSDigitizer::~AliPHOSSDigitizer() +{ + // dtor +} + + +//____________________________________________________________________________ +void AliPHOSSDigitizer::Exec(Option_t *option) { + //Collects all hits in the same active volume into digit + + TFile * file = 0; + + // if(gAlice->TreeE()==0) //If gAlice not yet read/constructed + if(fHeadersFile.IsNull()) + file = new TFile("galice.root", "update") ; + else + file = new TFile(fHeadersFile.Data(),"update") ; + + gAlice = (AliRun *) file->Get("gAlice") ; + + + + TClonesArray * sdigits = new TClonesArray("AliPHOSDigit",1000) ; + + AliPHOS * PHOS = (AliPHOS *) gAlice->GetDetector("PHOS") ; + + + if(fNevents == 0) + fNevents = (Int_t) gAlice->TreeE()->GetEntries() ; + + Int_t ievent ; + for(ievent = 0; ievent < fNevents; ievent++){ + gAlice->GetEvent(ievent) ; + gAlice->SetEvent(ievent) ; + + if(gAlice->TreeH()==0){ + cout << "AliPHOSSDigitizer: There is no Hit Tree" << endl; + return ; + } + + if(gAlice->TreeS() == 0) + gAlice->MakeTree("S") ; + + TClonesArray * hits = PHOS->Hits() ; + + sdigits->Clear(); + Int_t nSdigits = 0 ; + + //Make branches + char branchname[20]; + sprintf(branchname,"%s",PHOS->GetName()); + + Int_t bufferSize = 16000 ; + char * file =0; + if(!fSDigitsFile.IsNull()) + file = (char*) fSDigitsFile.Data() ; //ievent ; + else + if(gSystem->Getenv("CONFIG_SPLIT_FILE")){ //generating file name + file = new char[30] ; + // sprintf(file,"PHOS.SDigits%d.root",ievent) ; + sprintf(file,"PHOS.SDigits.root") ; + } + else + file = 0 ; + + gAlice->MakeBranchInTree(gAlice->TreeS(),branchname,&sdigits,bufferSize,file); + + + Int_t splitlevel = 0 ; + sprintf(branchname,"AliPHOSSDigitizer"); + AliPHOSSDigitizer * sd = this ; + gAlice->MakeBranchInTree(gAlice->TreeS(),branchname,"AliPHOSSDigitizer",&sd, bufferSize, splitlevel,file); + + + //Now made SDigits from hits, for PHOS it is the same + + Int_t itrack ; + for (itrack=0; itrackGetNtrack(); itrack++){ + + //=========== Get the Hits Tree for the Primary track itrack + gAlice->ResetHits(); + gAlice->TreeH()->GetEvent(itrack); + + Int_t i; + for ( i = 0 ; i < hits->GetEntries() ; i++ ) { + AliPHOSHit * hit = (AliPHOSHit*)hits->At(i) ; + AliPHOSDigit * newdigit ; + + // Assign primary number only if contribution is significant + if( hit->GetEnergy() > fPrimThreshold) + newdigit = new AliPHOSDigit( hit->GetPrimary(), hit->GetId(), Digitize( hit->GetEnergy() ) ) ; + else + newdigit = new AliPHOSDigit( -1 , hit->GetId(), Digitize( hit->GetEnergy() ) ) ; + + new((*sdigits)[nSdigits]) AliPHOSDigit(* newdigit) ; + nSdigits++ ; + + delete newdigit ; + } + + } // loop over tracks + + sdigits->Sort() ; + + nSdigits = sdigits->GetEntries() ; + sdigits->Expand(nSdigits) ; + + Int_t i ; + for (i = 0 ; i < nSdigits ; i++) { + AliPHOSDigit * digit = (AliPHOSDigit *) sdigits->At(i) ; + digit->SetIndexInList(i) ; + } + + gAlice->TreeS()->Fill() ; + gAlice->TreeS()->Write(0,TObject::kOverwrite) ; + } + + delete sdigits ; + if(file) + file->Close() ; + +} +//__________________________________________________________________ +void AliPHOSSDigitizer::SetSDigitsFile(char * file ){ + if(!fSDigitsFile.IsNull()) + cout << "Changing SDigits file from " <<(char *)fSDigitsFile.Data() << " to " << file << endl ; + fSDigitsFile=file ; +} +//__________________________________________________________________ +void AliPHOSSDigitizer::Print(Option_t* option)const{ + cout << "------------------- "<< GetName() << " -------------" << endl ; + if(fSDigitsFile.IsNull()) + cout << " Writing SDigitis to file galice.root "<< endl ; + else + cout << " Writing SDigitis to file " << (char*) fSDigitsFile.Data() << endl ; + cout << " with digitization parameters A = " << fA << endl ; + cout << " B = " << fB << endl ; + cout << "Threshold for Primary assignment = " << fPrimThreshold << endl ; + cout << "---------------------------------------------------"< threshold + TString fSDigitsFile ; //output file + TString fHeadersFile ; //input file + + + ClassDef(AliPHOSSDigitizer,1) // description + +}; + +#endif // AliPHOSSDigitizer_H diff --git a/PHOS/Makefile b/PHOS/Makefile index eff8884c67e..717fefd61a9 100644 --- a/PHOS/Makefile +++ b/PHOS/Makefile @@ -19,7 +19,8 @@ SRCS = AliPHOS.cxx AliPHOSv0.cxx AliPHOSv1.cxx AliPHOSv2.cxx \ AliPHOSCPVDigit.cxx AliPHOSDigit.cxx \ AliPHOSRecPoint.cxx AliPHOSEmcRecPoint.cxx \ AliPHOSPpsdRecPoint.cxx AliPHOSCpvRecPoint.cxx \ - AliPHOSClusterizer.cxx AliPHOSClusterizerv1.cxx AliPHOSLink.cxx \ + AliPHOSClusterizer.cxx AliPHOSClusterizerv1.cxx \ + AliPHOSLink.cxx AliPHOSSDigitizer.cxx AliPHOSDigitizer.cxx\ AliPHOSReconstructioner.cxx AliPHOSTrackSegment.cxx \ AliPHOSTrackSegmentMaker.cxx AliPHOSTrackSegmentMakerv1.cxx \ AliPHOSRecParticle.cxx AliPHOSPID.cxx AliPHOSPIDv1.cxx \ diff --git a/PHOS/PHOSLinkDef.h b/PHOS/PHOSLinkDef.h index 99839d2410d..35e2563f0eb 100644 --- a/PHOS/PHOSLinkDef.h +++ b/PHOS/PHOSLinkDef.h @@ -18,6 +18,8 @@ #pragma link C++ class AliPHOSPpsdRecPoint+; #pragma link C++ class AliPHOSReconstructioner+; #pragma link C++ class AliPHOSRecPoint+; +#pragma link C++ class AliPHOSSDigitizer+; +#pragma link C++ class AliPHOSDigitizer+; #pragma link C++ class AliPHOSv0+; #pragma link C++ class AliPHOSv1+; #pragma link C++ class AliPHOSv2+; -- 2.43.5