From ffa6d63bef8d3ba10bb8d254a05d7db3cea6f9a1 Mon Sep 17 00:00:00 2001 From: schutz Date: Mon, 17 Dec 2001 16:05:55 +0000 Subject: [PATCH] This update is a step in the continuous development of EMCAL. --- EMCAL/AliEMCAL.cxx | 15 +- EMCAL/AliEMCAL.h | 2 +- EMCAL/AliEMCALDigit.cxx | 17 +- EMCAL/AliEMCALDigit.h | 16 +- EMCAL/AliEMCALDigitizer.cxx | 53 +- EMCAL/AliEMCALDigitizer.h | 12 +- EMCAL/AliEMCALGeometry.cxx | 8 +- EMCAL/AliEMCALGeometry.h | 10 +- EMCAL/AliEMCALGetter.cxx | 967 +++++++++++++++++++++++++++++++++++ EMCAL/AliEMCALGetter.h | 155 ++++++ EMCAL/AliEMCALHit.cxx | 8 +- EMCAL/AliEMCALHit.h | 6 +- EMCAL/AliEMCALSDigitizer.cxx | 73 +-- EMCAL/AliEMCALSDigitizer.h | 8 +- EMCAL/AliEMCALv0.cxx | 76 +-- EMCAL/AliEMCALv0.h | 4 +- EMCAL/AliEMCALv1.cxx | 20 +- EMCAL/AliEMCALv1.h | 7 +- EMCAL/EMCALLinkDef.h | 1 + EMCAL/Makefile | 2 +- 20 files changed, 1314 insertions(+), 146 deletions(-) create mode 100644 EMCAL/AliEMCALGetter.cxx create mode 100644 EMCAL/AliEMCALGetter.h diff --git a/EMCAL/AliEMCAL.cxx b/EMCAL/AliEMCAL.cxx index cda534cd451..bc3a9238b7c 100644 --- a/EMCAL/AliEMCAL.cxx +++ b/EMCAL/AliEMCAL.cxx @@ -17,8 +17,8 @@ //_________________________________________________________________________ // Base Class for EMCAL description: -// -// +// This class contains material definitions +// for the EMCAL - It does not place the detector in Alice //*-- Author: Yves Schutz (SUBATECH) // //*-- Additional Contributions: Sahal Yacoob (LBNL/UCT) @@ -123,23 +123,20 @@ void AliEMCAL::CreateMaterials(){ // --- Set decent energy thresholds for gamma and electron tracking // Tracking threshold for photons and electrons in Lead - // gMC->Gstpar(idtmed[1600], "CUTGAM",0.5E-4) ; - // gMC->Gstpar(idtmed[1600], "CUTELE",1.0E-4) ; + gMC->Gstpar(idtmed[1600],"CUTGAM",0.00008) ; + gMC->Gstpar(idtmed[1600],"CUTELE",0.001) ; + gMC->Gstpar(idtmed[1600],"BCUTE",0.0001) ; // --- Generate explicitly delta rays in Lead --- gMC->Gstpar(idtmed[1600], "LOSS",3.) ; gMC->Gstpar(idtmed[1600], "DRAY",1.) ; - gMC->Gstpar(idtmed[1600],"CUTGAM",0.00008) ; - gMC->Gstpar(idtmed[1600],"CUTELE",0.001) ; - gMC->Gstpar(idtmed[1600],"BCUTE",0.0001) ; - // --- and in aluminium parts --- gMC->Gstpar(idtmed[1602], "LOSS",3.) ; gMC->Gstpar(idtmed[1602], "DRAY",1.) ; -// --- and finally in the scintillator --- +// --- and finally thresholds for photons and electrons in the scintillator --- gMC->Gstpar(idtmed[1601],"CUTGAM",0.00008) ; gMC->Gstpar(idtmed[1601],"CUTELE",0.001) ; gMC->Gstpar(idtmed[1601],"BCUTE",0.0001) ; diff --git a/EMCAL/AliEMCAL.h b/EMCAL/AliEMCAL.h index 1be224da384..467938d7345 100644 --- a/EMCAL/AliEMCAL.h +++ b/EMCAL/AliEMCAL.h @@ -43,7 +43,7 @@ class AliEMCAL : public AliDetector { virtual void CreateMaterials() ; - virtual AliEMCALGeometry * GetGeometry() = 0 ; + //virtual AliEMCALGeometry * GetGeometry() = 0 ; Int_t IsVersion(void) const { return -1 ; } virtual void SetTreeAddress() ; virtual TString Version() {return TString(" ") ; } diff --git a/EMCAL/AliEMCALDigit.cxx b/EMCAL/AliEMCALDigit.cxx index 49ecc78f3cb..54e3819bef1 100644 --- a/EMCAL/AliEMCALDigit.cxx +++ b/EMCAL/AliEMCALDigit.cxx @@ -13,17 +13,18 @@ * provided "as is" without express or implied warranty. * **************************************************************************/ -/* $Id$ */ +/* $Id: */ //_________________________________________________________________________ -// EMCAL digit: Id -// energy -// 3 identifiers for the primary particle(s) at the origine of the digit -// The digits are made in FinishEvent() by summing all the hits in a single EMCAL crystal or PPSD gas cell -// It would be nice to replace the 3 identifiers by an array, but, because digits are kept in a TClonesQArray, -// it is not possible to stream such an array... (beyond my understqnding!) +// EMCAL digit: +// A Digit is the sum of the energy lost in an EMCAL Tower +// It also stores information on Primary, and enterring particle +// tracknumbers Digits are created using AliEMCALSDigitizer, followed +// by AliEMCALDigitizer // -//*-- Author: Laurent Aphecetche & Yves Schutz (SUBATECH) +//*-- Author: Sahal Yacoob (LBL) +// based on : AliPHOSDigit +//__________________________________________________________________________ // --- ROOT system --- diff --git a/EMCAL/AliEMCALDigit.h b/EMCAL/AliEMCALDigit.h index 439f8e32c5a..f7c58b98761 100644 --- a/EMCAL/AliEMCALDigit.h +++ b/EMCAL/AliEMCALDigit.h @@ -6,14 +6,14 @@ /* $Id$ */ //_________________________________________________________________________ -// EMCAL digit: Id -// energy -// 3 identifiers for the primary particle(s) at the origine of the digit -// The digits are made in FinishEvent() by summing all the hits in a single EMCAL crystal or PPSD gas cell -// It would be nice to replace the 3 identifiers by an array, but, because digits are kept in a TClonesQArray, -// it is not possible to stream such an array... (beyond my understqnding!) +// EMCAL digit: +// +// A Digit is the sum of energy in a Tower (Hit sum) and stores information, about primaries +// and enterring particle contributing to a Digit // -//*-- Author: Laurent Aphecetche & Yves Schutz (SUBATECH) +//*-- Author: Sahal Yacoob (LBL) +// based on : AliPHOSDigit +//___________________________________________________________________________ // --- ROOT system --- @@ -51,7 +51,7 @@ class AliEMCALDigit : public AliDigitNew { return kTRUE ; } void SetAmp(Int_t Amp) { // sets the amplitude data member - fAmp=Amp ; } + fAmp= Amp ; } void ShiftPrimary(Int_t shift); // shift to semarate different TreeK in merging private: diff --git a/EMCAL/AliEMCALDigitizer.cxx b/EMCAL/AliEMCALDigitizer.cxx index 4a3c71cb815..21dd58d9d8e 100644 --- a/EMCAL/AliEMCALDigitizer.cxx +++ b/EMCAL/AliEMCALDigitizer.cxx @@ -16,10 +16,10 @@ /* $Id$ */ //_________________________________________________________________________ -//*-- Author : Dmitri Peressounko (SUBATECH & Kurchatov Institute) +// ////////////////////////////////////////////////////////////////////////////// -// Class performs digitization of Summable digits (in the EMCAL case this is just -// sum of contributions of all primary particles into given cell). +// Class performs digitization of Summable digits +// // In addition it performs mixing of summable digits from different events. // // For each event two branches are created in TreeD: @@ -48,7 +48,11 @@ // // deb - prints number of produced digits // // deb all - prints list of produced digits // // timing - prints time used for digitization +//////////////////////////////////////////////////////////////////////////////////// // +//*-- Author: Sahal Yacoob (LBL) +// based on : AliPHOSDigitizer +//_________________________________________________________________________________ // --- ROOT system --- #include "TFile.h" @@ -81,8 +85,8 @@ ClassImp(AliEMCALDigitizer) fSDigitizer = 0 ; fNinputs = 1 ; - fPinNoise = 0.01 ; - fEMCDigitThreshold = 0.01 ; + fPinNoise = 0.00 ; + fEMCDigitThreshold = 0.00 ; fInitialized = kFALSE ; fHeaderFiles = 0; @@ -114,14 +118,14 @@ void AliEMCALDigitizer::Init(){ file->cd() ; fSDigitsTitles = new TClonesArray("TObjString",1); - new((*fSDigitsTitles)[0]) TObjString("") ; + new((*fSDigitsTitles)[0]) TObjString("Default") ; fSDigits = new TClonesArray("TClonesArray",1) ; new((*fSDigits)[0]) TClonesArray("AliEMCALDigit",1000) ; fSDigitizer = 0 ; - fDigitsTitle = "" ; + fDigitsTitle = "Default" ; fDigits = new TClonesArray("AliEMCALDigit",200000) ; @@ -168,7 +172,7 @@ AliEMCALDigitizer::AliEMCALDigitizer(const char *headerFile,const char *sDigitsT fDigits = new TClonesArray("AliEMCALDigit",200000) ; - fDigitsTitle = "" ; + fDigitsTitle = "Default" ; fSDigitizer = 0 ; @@ -182,8 +186,8 @@ AliEMCALDigitizer::AliEMCALDigitizer(const char *headerFile,const char *sDigitsT fNinputs = 1 ; - fPinNoise = 0.01 ; - fEMCDigitThreshold = 0.01 ; + fPinNoise = 0.0001 ; + fEMCDigitThreshold = 0.001 ; // add Task to //root/Tasks folder TTask * roottasks = (TTask*)gROOT->GetRootFolder()->FindObject("Tasks") ; @@ -258,11 +262,11 @@ void AliEMCALDigitizer::Digitize(Option_t *option) { fDigits->Clear() ; - AliEMCAL * EMCAL = (AliEMCAL *) gAlice->GetDetector("EMCAL") ; + AliEMCALv0 * EMCAL = (AliEMCALv0 *) gAlice->GetDetector("EMCAL") ; AliEMCALGeometry *geom = AliEMCALGeometry::GetInstance( EMCAL->GetGeometry()->GetName(), EMCAL->GetGeometry()->GetTitle() ); //Making digits with noise, first EMC - Int_t nEMC = geom->GetNPhi()*geom->GetNZ(); + Int_t nEMC = 2*geom->GetNPhi()*geom->GetNZ(); Int_t absID ; TString name = geom->GetName() ; @@ -285,9 +289,10 @@ void AliEMCALDigitizer::Digitize(Option_t *option) { Int_t nSDigits = sdigits->GetEntries() ; for(isdigit=0;isdigit< nSDigits; isdigit++){ curSDigit = (AliEMCALDigit *)sdigits->At(isdigit) ; - if(inputs) //Shift primaries for non-background sdigits + if(inputs) //Shift primaries for non-background sdigits curSDigit->ShiftPrimary(inputs) ; digit = (AliEMCALDigit *)fDigits->At(curSDigit->GetId() - 1); + cout << curSDigit->GetAmp() << " and " << digit->GetAmp() << endl ; *digit = *digit + *curSDigit ; } } @@ -295,7 +300,7 @@ void AliEMCALDigitizer::Digitize(Option_t *option) { //remove digits below thresholds for(absID = 0; absID < nEMC ; absID++) - if(fSDigitizer->Calibrate(((AliEMCALDigit*)fDigits->At(absID))->GetAmp()) < fEMCDigitThreshold) + if(fSDigitizer->Calibrate(((AliEMCALDigit*)fDigits->At(absID))->GetAmp()) < fEMCDigitThreshold) fDigits->RemoveAt(absID) ; fDigits->Compress() ; @@ -310,9 +315,29 @@ void AliEMCALDigitizer::Digitize(Option_t *option) { for (i = 0 ; i < ndigits ; i++) { AliEMCALDigit * digit = (AliEMCALDigit *) fDigits->At(i) ; digit->SetIndexInList(i) ; + cout << digit->GetAmp() << "is amp" << endl; + Float_t energy = fSDigitizer->Calibrate(digit->GetAmp()) ; + cout << energy << " = energy " << endl; + energy = energy*1000 ; + cout << energy << " = energy " << endl; + digit->SetAmp(DigitizeEnergy(energy,digit->GetId()) ) ; + cout << digit->GetAmp() << "is amp" << endl; + cout << 100*energy/12.9 << endl ; } } //____________________________________________________________________________ + +Int_t AliEMCALDigitizer::DigitizeEnergy(Float_t energy, Int_t absId) + { Int_t chanel ; + //if(absId <= fEmcCrystals){ //digitize as EMC + chanel = (Int_t) TMath::Ceil(energy) ; + //if(chanel > fNADCemc ) chanel = fNADCemc ; + // } + return chanel ; +} +//____________________________________________________________________________ + + void AliEMCALDigitizer::WriteDigits(){ // Made TreeD in the output file. Check if branch already exists: if yes, exits diff --git a/EMCAL/AliEMCALDigitizer.h b/EMCAL/AliEMCALDigitizer.h index cb6978c1f7f..3acd700932e 100644 --- a/EMCAL/AliEMCALDigitizer.h +++ b/EMCAL/AliEMCALDigitizer.h @@ -6,9 +6,11 @@ /* $Id$ */ //_________________________________________________________________________ -// Task Class for making SDigits in EMCAL +// Task Class for making Digits in EMCAL // -//*-- Author: Dmitri Peressounko(SUBATECH & KI) +//*-- Author: Sahal Yacoob (LBL) +// based on : AliPHOSDigit +//_________________________________________________________________________ // --- ROOT system --- @@ -25,7 +27,7 @@ class AliEMCALDigitizer: public TTask { public: AliEMCALDigitizer() ; // ctor - AliEMCALDigitizer(const char *headerFile,const char * sDigitsBranchTitle = 0) ; + AliEMCALDigitizer(const char *headerFile,const char * sDigitsBranchTitle = "Default") ; virtual ~AliEMCALDigitizer() ; void Digitize(Option_t *option); // Make Digits from SDigits stored in fSDigits @@ -38,7 +40,7 @@ public: char * GetDigitsBranch ()const { return (char*)fDigitsTitle.Data() ;} TClonesArray * GetHeadersFiles(){ return fHeaderFiles ;} TArrayI* GetCurrentEvents() { return fIevent ;} - + Int_t DigitizeEnergy(Float_t energy, Int_t absId) ; void MixWith(char* HeaderFile, char* SDigitsTitle =0) ; // Add another one file to mix virtual void Print(Option_t* option)const ; void Reset() ; //restarts starts event processing from 0 event(s) @@ -62,7 +64,7 @@ private: TString fDigitsTitle ; // Title of the Digits Branch TClonesArray * fSDigits ; // ! Lists of SDigits TClonesArray * fDigits ; // ! Final list of digits - AliEMCALSDigitizer * fSDigitizer ; // ! SDigitizer to extarct some sdigitizing parameters + AliEMCALSDigitizer * fSDigitizer ; // ! SDigitizer to extract some sdigitizing parameters Int_t fNinputs ; // Number of input files Bool_t fInitialized ; // TArrayI * fIevent ; // events to read at the next ReadSDigits() call diff --git a/EMCAL/AliEMCALGeometry.cxx b/EMCAL/AliEMCALGeometry.cxx index 6e51537ddbe..35b048e6905 100644 --- a/EMCAL/AliEMCALGeometry.cxx +++ b/EMCAL/AliEMCALGeometry.cxx @@ -18,7 +18,13 @@ //_________________________________________________________________________ // Geometry class for EMCAL : singleton // EMCAL consists of layers of scintillator and lead -// +// Places the the Barrel Geometry of The EMCAL at Midrapidity +// between 0 and 120 degrees of Phi and +// -0.7 to 0.7 in eta +// Number of Modules and Layers may be controlled by +// the name of the instance defined +// EMCALArch2x has more modules along both phi and eta +// EMCALArchxa has less Layers in the Radial Direction //*-- Author: Sahal Yacoob (LBL / UCT) // and : Yves Schutz (SUBATECH) // and : Jennifer Klay (LBL) diff --git a/EMCAL/AliEMCALGeometry.h b/EMCAL/AliEMCALGeometry.h index 5da870e5fc9..06a1b693a0e 100644 --- a/EMCAL/AliEMCALGeometry.h +++ b/EMCAL/AliEMCALGeometry.h @@ -63,7 +63,6 @@ public: const Float_t GetAirGap() const { return fAirGap ; } const Float_t GetArm1PhiMin() const { return fArm1PhiMin ; } const Float_t GetArm1PhiMax() const { return fArm1PhiMax ; } - const Float_t GetArm1ZOffset() const {return fArm1ZOffset ;} const Float_t GetIPDistance() const { return fIPDistance ; } const Float_t GetEnvelop(Int_t index) const { return fEnvelop[index] ; } const Float_t GetShellThickness() const { return fShellThickness ; } @@ -88,12 +87,11 @@ private: // geometry Float_t fAirGap ; // Distance between envelop and active material - Float_t fArm1PhiMin ; // Minimum phi angle covered by Arm 1 - Float_t fArm1PhiMax ; // Maximum phi angle covered by Arm 1 - Float_t fArm1ZOffset ; // Distance from z = 0 of Arm 1 + Float_t fArm1PhiMin ; // Minimum angular position of EMCAL in Phi (degrees) + Float_t fArm1PhiMax ; // Maximum angular position of EMCAL in Phi (degrees) // It is assumed that Arm1 and Arm2 have the same following parameters - Float_t fEnvelop[3] ; // the GEANT TUB that contains the 2 arms + Float_t fEnvelop[3] ; // the GEANT TUB for the detector Float_t fIPDistance ; // Distance of the inner surface to the interaction point Float_t fShellThickness ; // Total thickness in (x,y) direction Float_t fZLength ; // Total length in z direction @@ -102,7 +100,7 @@ private: Int_t fNZ ; // Number of Towers in the Z direction Int_t fNPhi ; //Number of Towers in the Phi Direction - ClassDef(AliEMCALGeometry,1) // EMCAL geometry class + ClassDef(AliEMCALGeometry,2) // EMCAL geometry class } ; diff --git a/EMCAL/AliEMCALGetter.cxx b/EMCAL/AliEMCALGetter.cxx new file mode 100644 index 00000000000..bb995e00ae8 --- /dev/null +++ b/EMCAL/AliEMCALGetter.cxx @@ -0,0 +1,967 @@ +/************************************************************************** + * 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: */ + +/* $Log: +*/ + +//_________________________________________________________________________ +// A singleton. This class should be used in the analysis stage to get +// reconstructed objects: Digits, RecPoints, TrackSegments and RecParticles, +// instead of directly reading them from galice.root file. This container +// ensures, that one reads Digits, made of these particular digits, RecPoints, +// made of these particular RecPoints, TrackSegments and RecParticles. +// This becomes non trivial if there are several identical branches, produced with +// different set of parameters. Currently This class only Retrieves Hits, Digits, and SDigits. +// +// An example of how to use (see also class AliEMCALAnalyser): +// AliEMCALGetter * gime = AliEMCALGetter::GetInstance("galice.root","test") ; +// ................ +// please->GetEvent(event) ; // reads new event from galice.root +// +//*-- Author: Sahal Yacoob (LBL) +// based on : AliPHOSGetter +////////////////////////////////////////////////////////////////////////////// + + +// --- ROOT system --- + +#include "TFile.h" +#include "TTree.h" +#include "TROOT.h" +#include "TObjString.h" +#include "TFolder.h" + +// --- Standard library --- +#include + +// --- AliRoot header files --- + +#include "AliRun.h" +#include "AliConfig.h" +#include "AliEMCALGetter.h" +#include "AliEMCALv1.h" +#include "AliEMCALDigitizer.h" +#include "AliEMCALSDigitizer.h" +#include "AliEMCALGeometry.h" + +ClassImp(AliEMCALGetter) + + AliEMCALGetter * AliEMCALGetter::fgObjGetter = 0 ; + +//____________________________________________________________________________ +AliEMCALGetter::AliEMCALGetter(const char* headerFile, const char* branchTitle ) +{ + //Initialize all lists + + fHeaderFile = headerFile ; + fBranchTitle = branchTitle ; + fSDigitsTitle = branchTitle ; + fDigitsTitle = branchTitle ; + + fPrimaries = new TObjArray(1) ; + fModuleFolder = dynamic_cast(gROOT->FindObjectAny("Folders/Run/Configuration/Modules")); + fHitsFolder = dynamic_cast(gROOT->FindObjectAny("Folders/RunMC/Event/Data/Hits")); + fSDigitsFolder = dynamic_cast(gROOT->FindObjectAny("Folders/RunMC/Event/Data/SDigits")); + fDigitsFolder = dynamic_cast(gROOT->FindObjectAny("Folders/Run/Event/Data")); + fTasksFolder = dynamic_cast(gROOT->FindObjectAny("Folders/Tasks")) ; + + if ( fHeaderFile != "aliroot" ) { // to call the getter without a file + + //open headers file + TFile * file = static_cast(gROOT->GetFile(fHeaderFile.Data() ) ) ; + + if(file == 0){ //if file was not opened yet, read gAlice + if(fHeaderFile.Contains("rfio")) // if we read file using HPSS + file = TFile::Open(fHeaderFile.Data(),"update") ; + else + file = new TFile(fHeaderFile.Data(),"update") ; + + if (!file->IsOpen()) { + cerr << "ERROR : AliEMCALGetter::AliEMCALGetter -> Cannot open " << fHeaderFile.Data() << endl ; + abort() ; + } + + gAlice = static_cast(file->Get("gAlice")) ; + + if (!gAlice) { + cerr << "ERROR : AliEMCALGetter::AliEMCALGetter -> Cannot find gAlice in " << fHeaderFile.Data() << endl ; + abort() ; + } + if (!EMCAL()) { + cout << "INFO: AliEMCALGetter -> Posting EMCAL to Folders" << endl ; + AliConfig * conf = AliConfig::Instance() ; + conf->Add(static_cast(gAlice->GetDetector("EMCAL"))) ; + conf->Add(static_cast(gAlice->GetDetector("EMCAL"))) ; + } + } + + } +} +//____________________________________________________________________________ +AliEMCALGetter::~AliEMCALGetter(){ + +} + +//____________________________________________________________________________ +void AliEMCALGetter::CreateWhiteBoard() const +{ + +} + +//____________________________________________________________________________ +AliEMCALGetter * AliEMCALGetter::GetInstance() +{ + // Returns the pointer of the unique instance already defined + + AliEMCALGetter * rv = 0 ; + if ( fgObjGetter ) + rv = fgObjGetter ; + else + cout << "AliEMCALGetter::GetInstance ERROR: not yet initialized" << endl ; + + return rv ; +} + +//____________________________________________________________________________ +AliEMCALGetter * AliEMCALGetter::GetInstance(const char* headerFile, + const char* branchTitle) +{ + // Creates and returns the pointer of the unique instance + // Must be called only when the environment has changed + + if ( fgObjGetter ) + if((fgObjGetter->fBranchTitle.CompareTo(branchTitle) == 0) && + (fgObjGetter->fHeaderFile.CompareTo(headerFile)==0)) + return fgObjGetter ; + else + fgObjGetter->~AliEMCALGetter() ; // delete it if already exists another version + + fgObjGetter = new AliEMCALGetter(headerFile,branchTitle) ; + + // Posts a few item to the white board (folders) + // fgObjGetter->CreateWhiteBoard() ; + + return fgObjGetter ; + +} + +//____________________________________________________________________________ +const AliEMCALv0 * AliEMCALGetter::EMCAL() +{ + // returns the EMCAL object + //AliEMCALv0 * emcal = dynamic_cast(gAlice->GetDetector("EMCAL")) ; + AliEMCALv0 * emcal = dynamic_cast(fModuleFolder->FindObject("EMCAL")) ; + if (!emcal) + cout << "WARNING: AliEMCALGetter::EMCAL -> EMCAL module not found in Folders" << endl ; + return emcal ; +} + +//____________________________________________________________________________ +const AliEMCALGeometry * AliEMCALGetter::EMCALGeometry() +{ + AliEMCALGeometry * rv = 0 ; + if (EMCAL() ) + rv = EMCAL()->GetGeometry() ; + return rv ; +} + +//____________________________________________________________________________ +Bool_t AliEMCALGetter::PostHits(void) const +{ //------- Hits ---------------------- + + // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/Hits + + TFolder * emcalFolder = dynamic_cast(fHitsFolder->FindObject("EMCAL")) ; + if ( !emcalFolder ) { + cout << "WARNING: AliEMCALGetter::Post H -> Folder //" << fHitsFolder << "/EMCAL/ not found!" << endl; + cout << "INFO: AliEMCALGetter::Post H -> Adding Folder //" << fHitsFolder << "/EMCAL/" << endl; + emcalFolder = fHitsFolder->AddFolder("EMCAL", "Hits from EMCAL") ; + } + TClonesArray *hits= new TClonesArray("AliEMCALHit",1000) ; + hits->SetName("Hits") ; + emcalFolder->Add(hits) ; + + return kTRUE; +} + +//____________________________________________________________________________ +void * AliEMCALGetter::HitsRef(void) const +{ //------- Hits ---------------------- + + + // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/Hits + if ( !fHitsFolder ) { + cerr << "ERROR: AliEMCALGetter::Post H -> Folder //" << fHitsFolder << " not found!" << endl; + return 0; + } + + TFolder * emcalFolder = dynamic_cast(fHitsFolder->FindObject("EMCAL")) ; + if ( !emcalFolder ) { + cerr << "ERROR: AliEMCALGetter::Post HRef -> Folder //" << fHitsFolder << "/EMCAL/ not found!" << endl; + return 0; + } + + TObject * h = emcalFolder->FindObject("Hits") ; + if(!h) { + cerr << "ERROR: AliEMCALGetter::HRef -> " << emcalFolder->GetName() << "/Hits not found !" << endl ; + return 0 ; + } + else + return static_cast(emcalFolder->GetListOfFolders()->GetObjectRef(h)) ; +} + +//____________________________________________________________________________ +Bool_t AliEMCALGetter::PostSDigits(const char * name, const char * headerFile) const +{ //---------- SDigits ------------------------- + + + // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/SDigits/headerFile/sdigitsname + // because you can have sdigits from several hit files for mixing + + TFolder * emcalFolder = dynamic_cast(fSDigitsFolder->FindObject("EMCAL")) ; + if ( !emcalFolder ) { + cout << "WARNING: AliEMCALGetter::Post S -> Folder //" << fSDigitsFolder << "/EMCAL/ not found!" << endl; + cout << "INFO: AliEMCALGetter::Post S -> Adding Folder //" << fHitsFolder << "/EMCAL/" << endl; + emcalFolder = fSDigitsFolder->AddFolder("EMCAL", "SDigits from EMCAL") ; + } + TString subdir(headerFile) ; + TFolder * emcalSubFolder = dynamic_cast(emcalFolder->FindObject(subdir)) ; + if ( !emcalSubFolder ) + emcalSubFolder = emcalFolder->AddFolder(subdir, ""); + + TObject * sd = emcalSubFolder->FindObject(name); + if ( sd ) { + cerr <<"INFO: AliEMCALGetter::Post S -> Folder " << subdir + << " already exists!" << endl ; + }else{ + TClonesArray * sdigits = new TClonesArray("AliEMCALDigit",1000) ; + sdigits->SetName(name) ; + emcalSubFolder->Add(sdigits) ; + } + + return kTRUE; +} +//____________________________________________________________________________ +void * AliEMCALGetter::SDigitsRef(const char * name, const char * file) const +{ //------- SDigits ---------------------- + + // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/SDigits/filename/SDigits + + if ( !fSDigitsFolder ) { + cerr << "ERROR: AliEMCALGetter::Post SRef -> Folder //" << fSDigitsFolder << " not found!" << endl; + return 0; + } + + TFolder * emcalFolder = dynamic_cast(fSDigitsFolder->FindObject("EMCAL")) ; + if ( !emcalFolder ) { + cerr << "ERROR: AliEMCALGetter::Post SRef -> Folder //" << fSDigitsFolder << "/EMCAL/ not found!" << endl; + return 0; + } + + TFolder * emcalSubFolder = 0 ; + if(file) + emcalSubFolder = dynamic_cast(emcalFolder->FindObject(file)) ; + else + emcalSubFolder = dynamic_cast(emcalFolder->FindObject(fHeaderFile)) ; + + if(!emcalSubFolder) { + cerr << "ERROR: AliEMCALGetter::Post SRef -> Folder //Folders/RunMC/Event/Data/EMCAL/" << file << "not found!" << endl; + return 0; + } + + TObject * dis = emcalSubFolder->FindObject(name) ; + if(!dis) + return 0 ; + else + return static_cast(emcalSubFolder->GetListOfFolders()->GetObjectRef(dis)) ; + +} + +//____________________________________________________________________________ +Bool_t AliEMCALGetter::PostSDigitizer(AliEMCALSDigitizer * sdigitizer) const +{ //---------- SDigitizer ------------------------- + + // the hierarchy is //Folders/Tasks/SDigitizer/EMCAL/sdigitsname + + + TTask * sd = dynamic_cast(fTasksFolder->FindObject("SDigitizer")) ; + + if ( !sd ) { + cerr << "ERROR: AliEMCALGetter::Post Ser -> Task //" << fTasksFolder << "/SDigitizer not found!" << endl; + return kFALSE ; + } + TTask * emcal = dynamic_cast(sd->GetListOfTasks()->FindObject("EMCAL")) ; + if ( !emcal ) { + cout <<"WARNING: AliEMCALGetter::Post Ser ->//" << fTasksFolder << "/SDigitizer/EMCAL/ not found!" << endl; + cout <<"INFO: AliEMCALGetter::Post Ser -> Adding //" << fTasksFolder << "/SDigitizer/EMCAL/" << endl; + emcal = new TTask("EMCAL", "") ; + sd->Add(emcal) ; + } + AliEMCALSDigitizer * emcalsd = dynamic_cast(emcal->GetListOfTasks()->FindObject( sdigitizer->GetName() )); + if (emcalsd) { + cout << "INFO: AliEMCALGetter::Post Ser -> Task " << sdigitizer->GetName() << " already exists" << endl ; + emcal->GetListOfTasks()->Remove(emcalsd) ; + } + emcal->Add(sdigitizer) ; + return kTRUE; + +} + +//____________________________________________________________________________ +void * AliEMCALGetter::SDigitizerRef(const char * name) const +{ + + TTask * sd = dynamic_cast(fTasksFolder->FindObject("SDigitizer")) ; + if ( !sd ) { + cerr << "ERROR: AliEMCALGetter::Post SerRef -> Task //" << fTasksFolder << "/SDigitizer not found!" << endl; + abort(); + } + + TTask * emcal = dynamic_cast(sd->GetListOfTasks()->FindObject("EMCAL")) ; + if ( !emcal ) { + cerr <<"ERROR: AliEMCALGetter::Post SerRef -> //" << fTasksFolder << "/SDigitizer/EMCAL not found!" << endl; + abort(); + } + + TTask * task = dynamic_cast(emcal->GetListOfTasks()->FindObject(name)) ; + + return static_cast(emcal->GetListOfTasks()->GetObjectRef(task)) ; + +} + +//____________________________________________________________________________ +Bool_t AliEMCALGetter::PostSDigitizer(const char * name, const char * file) const +{ //---------- SDigitizer ------------------------- + + // the hierarchy is //Folders/Tasks/SDigitizer/EMCAL/sdigitsname + + + TTask * sd = dynamic_cast(fTasksFolder->FindObject("SDigitizer")) ; + if ( !sd ) { + cerr << "ERROR: AliEMCALGetter::Post Ser -> Task //" << fTasksFolder << "/SDigitizer not found!" << endl; + return kFALSE ; + } + + TTask * emcal = dynamic_cast(sd->GetListOfTasks()->FindObject("EMCAL")) ; + if ( !emcal ) { + cout <<"WARNING: AliEMCALGetter::Post Ser -> //" << fTasksFolder << "/SDigitizer/EMCAL/ not found!" << endl; + cout <<"INFO: AliEMCALGetter::Post Ser -> Adding //" << fTasksFolder << "/SDigitizer/EMCAL" << endl; + emcal = new TTask("EMCAL", "") ; + sd->Add(emcal) ; + } + + TString sdname(name) ; + sdname.Append(":") ; + sdname.Append(file); + AliEMCALSDigitizer * emcalsd = dynamic_cast(emcal->GetListOfTasks()->FindObject( sdname )); + if (!emcalsd) { + emcalsd = new AliEMCALSDigitizer() ; + //Note, we can not call constructor with parameters: it will call Getter and scrud up everething + emcalsd->SetName(sdname) ; + emcalsd->SetTitle(file) ; + emcal->Add(emcalsd) ; + } + return kTRUE; + +} + +//____________________________________________________________________________ +Bool_t AliEMCALGetter::PostDigits(const char * name) const +{ //---------- Digits ------------------------- + + // the hierarchy is //Folders/Run/Event/Data/EMCAL/SDigits/name + + TFolder * emcalFolder = dynamic_cast(fDigitsFolder->FindObject("EMCAL")) ; + + if ( !emcalFolder ) { + cout << "WARNING: AliEMCALGetter::Post D -> Folder //" << fDigitsFolder << "/EMCAL/ not found!" << endl; + cout << "INFO: AliEMCALGetter::Post D -> Adding Folder //" << fDigitsFolder << "/EMCAL/" << endl; + emcalFolder = fDigitsFolder->AddFolder("EMCAL", "Digits from EMCAL") ; + } + + TObject* dig = emcalFolder->FindObject( name ) ; + if ( !dig ) { + TClonesArray * digits = new TClonesArray("AliEMCALDigit",1000) ; + digits->SetName(name) ; + emcalFolder->Add(digits) ; + } + return kTRUE; +} + +//____________________________________________________________________________ +void * AliEMCALGetter::DigitsRef(const char * name) const +{ //------- Digits ---------------------- + + // the hierarchy is //Folders/Run/Event/Data/EMCAL/Digits/name + + if ( !fDigitsFolder ) { + cerr << "ERROR: AliEMCALGetter::Post DRef -> Folder //" << fDigitsFolder << " not found!" << endl; + return 0; + } + + TFolder * emcalFolder = dynamic_cast(fDigitsFolder->FindObject("EMCAL")) ; + if ( !emcalFolder ) { + cerr << "ERROR: AliEMCALGetter::DRef -> Folder //" << fDigitsFolder << "/EMCAL/ not found!" << endl; + return 0; + } + + TObject * d = emcalFolder->FindObject(name) ; + if(!d) + return 0 ; + else + return static_cast(emcalFolder->GetListOfFolders()->GetObjectRef(d)) ; + +} + +//____________________________________________________________________________ +Bool_t AliEMCALGetter::PostDigitizer(AliEMCALDigitizer * digitizer) const +{ //---------- Digitizer ------------------------- + + TTask * sd = dynamic_cast(fTasksFolder->FindObject("Digitizer")) ; + + if ( !sd ) { + cerr << "ERROR: AliEMCALGetter::Post Der -> Task //" << fTasksFolder << "/Digitizer not found!" << endl; + return kFALSE ; + } + TTask * emcal = dynamic_cast(sd->GetListOfTasks()->FindObject("EMCAL")) ; + if ( !emcal ) { + cout <<"WARNING: AliEMCALGetter::Post Der -> //" << fTasksFolder << "/Digitizer/EMCAL not found!" << endl; + cout <<"INFO: AliEMCALGetter::Post Der -> Adding //" << fTasksFolder << "/Digitizer/EMCAL" << endl; + emcal = new TTask("EMCAL", "") ; + sd->Add(emcal) ; + } + + AliEMCALDigitizer * emcald = dynamic_cast(emcal->GetListOfTasks()->FindObject(digitizer->GetName())) ; + if (emcald) { + emcald->Delete() ; + emcal->GetListOfTasks()->Remove(emcald) ; + } + emcal->Add(digitizer) ; + return kTRUE; +} + +//____________________________________________________________________________ +Bool_t AliEMCALGetter::PostDigitizer(const char * name) const +{ //---------- Digitizer ------------------------- + + // the hierarchy is //Folders/Tasks/SDigitizer/EMCAL/sdigitsname + + TTask * d = dynamic_cast(fTasksFolder->FindObject("Digitizer")) ; + if ( !d ) { + cerr << "ERROR: AliEMCALGetter::Post Der -> Task //" << fTasksFolder << "/Digitizer not found!" << endl; + return kFALSE ; + } + + TTask * emcal = dynamic_cast(d->GetListOfTasks()->FindObject("EMCAL")) ; + if ( !emcal ) { + cout <<"WARNING: AliEMCALGetter::Post Der -> //" << fTasksFolder << "/Digitizer/EMCAL not found!" << endl; + cout <<"INFO: AliEMCALGetter::Post Der -> Adding //" << fTasksFolder << "/Digitizer/EMCAL" << endl; + emcal = new TTask("EMCAL", "") ; + d->Add(emcal) ; +} + + AliEMCALDigitizer * emcald = dynamic_cast(emcal->GetListOfTasks()->FindObject(name)) ; + if (!emcald) { + emcald = new AliEMCALDigitizer() ; + emcald->SetName(fDigitsTitle) ; + emcald->SetTitle(fHeaderFile) ; + emcal->Add(emcald) ; + } + return kTRUE; +} + +//____________________________________________________________________________ +void * AliEMCALGetter::DigitizerRef(const char * name) const +{ + TTask * sd = dynamic_cast(fTasksFolder->FindObject("Digitizer")) ; + if ( !sd ) { + cerr << "ERROR: AliEMCALGetter::Post DerRef -> Task //" << fTasksFolder << "/Digitizer not found!" << endl; + abort(); + } + + TTask * emcal = dynamic_cast(sd->GetListOfTasks()->FindObject("EMCAL")) ; + if ( !emcal ) { + cerr <<"ERROR: AliEMCALGetter::Post DerRef -> //" << fTasksFolder << "/Digitizer/EMCAL" << endl; + abort(); + } + + TTask * task = dynamic_cast(emcal->GetListOfTasks()->FindObject(name)) ; + + return static_cast(emcal->GetListOfTasks()->GetObjectRef(task)) ; + +} + +//____________________________________________________________________________ +const TParticle * AliEMCALGetter::Primary(Int_t index) const +{ + // Return primary particle numbered by + + if(index < 0) + return 0 ; + + Int_t primaryIndex = index % 10000000 ; + Int_t primaryList = (Int_t ) ((index-primaryIndex)/10000000.) ; + + if ( primaryList > 0 ) { + cout << " Getter does not support currently Mixing of primary " << endl ; + cout << " can not return primary: " << index<< " (list "<< primaryList<< " primary # " << primaryIndex << " )"<Particle(primaryIndex) ; + +} + +//____________________________________________________________________________ +void AliEMCALGetter::ReadTreeD() +{ + // Read the digit tree gAlice->TreeD() + if(gAlice->TreeD()== 0){ + cerr << "ERROR: AliEMCALGetter::ReadTreeD: can not read TreeD " << endl ; + return ; + } + cout << "hello" << endl; + TObjArray * lob = static_cast(gAlice->TreeD()->GetListOfBranches()) ; + TIter next(lob) ; + TBranch * branch = 0 ; + TBranch * digitsbranch = 0 ; + TBranch * digitizerbranch = 0 ; + Bool_t emcalfound = kFALSE, digitizerfound = kFALSE ; + + while ( (branch = static_cast(next())) && (!emcalfound || !digitizerfound) ) { + if ( (strcmp(branch->GetName(), "EMCAL")==0) && (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) { + digitsbranch = branch ; + emcalfound = kTRUE ; + } + else if ( (strcmp(branch->GetName(), "AliEMCALDigitizer")==0) && (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) { + digitizerbranch = branch ; + digitizerfound = kTRUE ; + } + } + + if ( !emcalfound || !digitizerfound ) { + cout << "WARNING: AliEMCALGetter::ReadTreeD -> Cannot find Digits and/or Digitizer with name " + << fDigitsTitle << endl ; + return ; + } + + //read digits + if(!Digits(fDigitsTitle) ) + PostDigits(fDigitsTitle); + digitsbranch->SetAddress(DigitsRef(fDigitsTitle)) ; + digitsbranch->GetEntry(0) ; + + + // read the Digitizer + if(!Digitizer(fDigitsTitle)) + PostDigitizer(fDigitsTitle) ; + digitizerbranch->SetAddress(DigitizerRef(fDigitsTitle)) ; + digitizerbranch->GetEntry(0) ; + + +} + +//____________________________________________________________________________ +void AliEMCALGetter::ReadTreeH() +{ + // Read the first entry of EMCAL branch in hit tree gAlice->TreeH() + + if(gAlice->TreeH()== 0){ + cerr << "ERROR: AliEMCALGetter::ReadTreeH: -> Cannot read TreeH " << endl ; + return ; + } + + TBranch * hitsbranch = static_cast(gAlice->TreeH()->GetBranch("EMCAL")) ; + if ( !hitsbranch ) { + cout << "WARNING: AliEMCALGetter::ReadTreeH -> Cannot find branch EMCAL" << endl ; + return ; + } + if(!Hits()) + PostHits() ; + + hitsbranch->SetAddress(HitsRef()) ; + + hitsbranch->GetEntry(0) ; + +} + +//____________________________________________________________________________ +void AliEMCALGetter::Track(Int_t itrack) +{ + // Read the first entry of EMCAL branch in hit tree gAlice->TreeH() + + if(gAlice->TreeH()== 0){ + cerr << "ERROR: AliEMCALGetter::ReadTreeH: -> Cannot read TreeH " << endl ; + return ; + } + + TBranch * hitsbranch = dynamic_cast(gAlice->TreeH()->GetListOfBranches()->FindObject("EMCAL")) ; + if ( !hitsbranch ) { + cout << "WARNING: AliEMCALGetter::ReadTreeH -> Cannot find branch EMCAL" << endl ; + return ; + } + if(!Hits()) + PostHits() ; + hitsbranch->SetAddress(HitsRef()) ; + hitsbranch->GetEntry(itrack) ; + + +} +//____________________________________________________________________________ +void AliEMCALGetter::ReadTreeS(Int_t event) +{ + // Read the summable digits tree gAlice->TreeS() + + // loop over all opened files and read their SDigits to the White Board + TFolder * emcalF = dynamic_cast(fSDigitsFolder->FindObject("EMCAL")) ; + if (!emcalF) + emcalF = fSDigitsFolder->AddFolder("EMCAL", "SDigits from EMCAL") ; + TCollection * folderslist = emcalF->GetListOfFolders() ; + + //Add current file to list if it is not there yet + if ( (fHeaderFile != "aliroot") && ( !folderslist->Contains(fHeaderFile) ) ){ + emcalF->AddFolder(fHeaderFile, ""); + } + + TIter next(folderslist) ; + TFolder * folder = 0 ; + TFile * file; + TTree * treeS = 0; + while ( (folder = static_cast(next())) ) { + if(fHeaderFile.CompareTo(folder->GetName()) == 0 ) + {treeS=gAlice->TreeS() ; + cout << "ReadTreeS "<< gAlice->TreeS() <GetName() << endl ; + file = static_cast(gROOT->GetFile(folder->GetName())); + file->cd() ; + + // Get SDigits Tree header from file + TString treeName("TreeS") ; + treeName += event ; + treeS = dynamic_cast(gDirectory->Get(treeName.Data())); + } + if(treeS==0){ + cerr << "ERROR: AliEMCALGetter::ReadTreeS There is no SDigit Tree" << endl; + return ; + } + + //set address of the SDigits and SDigitizer + TBranch * sdigitsBranch = 0; + TBranch * sdigitizerBranch = 0; + TBranch * branch = 0 ; + TObjArray * lob = static_cast(treeS->GetListOfBranches()) ; + TIter next(lob) ; + Bool_t emcalfound = kFALSE, sdigitizerfound = kFALSE ; + + while ( (branch = static_cast(next())) && (!emcalfound || !sdigitizerfound) ) { + + if ( (strcmp(branch->GetName(), "EMCAL")==0) && (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) { + emcalfound = kTRUE ; + sdigitsBranch = branch ; + cout << "sdigitsbranch found = " << branch << endl ; + } + + else if ( (strcmp(branch->GetName(), "AliEMCALSDigitizer")==0) && (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) { + sdigitizerfound = kTRUE ; + sdigitizerBranch = branch ; + cout << "sdigitizerbranch found = " << branch << endl ; + } + } + if ( !emcalfound || !sdigitizerfound ) { + cout << "WARNING: AliEMCALDigitizer::ReadSDigits -> Digits and/or Digitizer branch with name " << GetName() + << " not found" << endl ; + return ; + } + + if ( !folder->FindObject(fSDigitsTitle) ) + { PostSDigits(fSDigitsTitle,folder->GetName()) ; + cout << "Posting SDigits " << endl << endl ;} + sdigitsBranch->SetAddress(SDigitsRef(fSDigitsTitle,folder->GetName())) ; + + sdigitsBranch->GetEntry(0) ; + + TString sdname(fSDigitsTitle) ; + cout << sdname << endl ; + sdname+=":" ; + sdname+=folder->GetName() ; + if(!SDigitizer(sdname) ) + PostSDigitizer(fSDigitsTitle,folder->GetName()) ; + sdigitizerBranch->SetAddress(SDigitizerRef(sdname)) ; + sdigitizerBranch->GetEntry(0) ; + + } + + // After SDigits have been read from all files, return to the first one + + next.Reset(); + folder = static_cast(next()); + if(folder){ + file = static_cast(gROOT->GetFile(folder->GetName())); + file ->cd() ; + } + +} +//____________________________________________________________________________ +void AliEMCALGetter::ReadTreeS(TTree * treeS, Int_t input) +{ // Read the summable digits fron treeS() + + + TString filename("mergefile") ; + filename+= input ; + + TFolder * emcalFolder = dynamic_cast(fSDigitsFolder->FindObject("EMCAL")) ; + if ( !emcalFolder ) { + emcalFolder = fSDigitsFolder->AddFolder("EMCAL", "SDigits from EMCAL") ; + } + TFolder * folder=(TFolder*)emcalFolder->FindObject(filename) ; + //set address of the SDigits and SDigitizer + TBranch * sdigitsBranch = 0; + TBranch * sdigitizerBranch = 0; + TBranch * branch = 0 ; + TObjArray * lob = (TObjArray*)treeS->GetListOfBranches() ; + TIter next(lob) ; + Bool_t emcalfound = kFALSE, sdigitizerfound = kFALSE ; + + while ( (branch = (TBranch*)next()) && (!emcalfound || !sdigitizerfound) ) { + if ( strcmp(branch->GetName(), "EMCAL")==0) { + emcalfound = kTRUE ; + sdigitsBranch = branch ; + } + + else if ( strcmp(branch->GetName(), "AliEMCALSDigitizer")==0) { + sdigitizerfound = kTRUE ; + sdigitizerBranch = branch ; + } + } + if ( !emcalfound || !sdigitizerfound ) { + cout << "WARNING: AliEMCALGetter::ReadTreeS -> Digits and/or Digitizer branch not found" << endl ; + return ; + } + + if (!folder || !(folder->FindObject(sdigitsBranch->GetTitle()) ) ) + PostSDigits(sdigitsBranch->GetTitle(),filename) ; + + sdigitsBranch->SetAddress(SDigitsRef(sdigitsBranch->GetTitle(),filename)) ; + + TString sdname(sdigitsBranch->GetTitle()) ; + sdname+=":" ; + sdname+=filename ; + if(!SDigitizer(sdigitsBranch->GetTitle()) ) + PostSDigitizer(sdigitsBranch->GetTitle(),filename) ; + sdigitizerBranch->SetAddress(SDigitizerRef(sdname)) ; + + sdigitsBranch->GetEntry(0) ; + sdigitizerBranch->GetEntry(0) ; + +} + + +//____________________________________________________________________________ +void AliEMCALGetter::ReadPrimaries() +{ + // Reads specific branches of primaries + + fNPrimaries = gAlice->GetNtrack(); + + // //Check, is it necessary to open new files + // TArrayI* events = fDigitizer->GetCurrentEvents() ; + // TClonesArray * filenames = fDigitizer->GetHeadersFiles() ; +// Int_t input ; +// for(input = 0; input < filenames->GetEntriesFast(); input++){ + +// TObjString * filename = (TObjString *) filenames->At(input) ; + +// //Test, if this file already open +// TFile *file = (TFile*) gROOT->GetFile( filename->GetString() ) ; +// if(file == 0) +// file = new TFile( filename->GetString()) ; +// file->cd() ; + +// // Get Kine Tree from file +// // char treeName[20]; +// // sprintf(treeName,"TreeK%d",events->At(input)); +// // TTree * treeK = (TTree*)gDirectory->Get(treeName); +// // if (treeK) +// // treeK->SetBranchAddress("Particles", &fParticleBuffer); +// // else +// // cout << "AliEMCALGetter: cannot find Kine Tree for event:" << events->At(input) << endl; + +// // // Create the particle stack +// // if(!fParticles) fParticles = new TClonesArray("TParticle",1000); +// // // Build the pointer list +// // if(fParticleMap) { <---- +// // fParticleMap->Clear(); +// // fParticleMap->Expand(treeK->GetEntries()); +// // } else +// // fParticleMap = new TObjArray(treeK->GetEntries()); + +// // From gAlice->Particle(i) + + +// // if(!(*fParticleMap)[i]) { +// // Int_t nentries = fParticles->GetEntries(); + +// // // algorithmic way of getting entry index +// // // (primary particles are filled after secondaries) +// // Int_t entry; +// // if (iGetEntry(fParticleFileMap[i]); +// // new ((*fParticles)[nentries]) TParticle(*fParticleBuffer); +// // fParticleMap->AddAt((*fParticles)[nentries],i); +// // } +// // return (TParticle *) (*fParticleMap)[i]; + + + +// } + + +// //scan over opened files and read corresponding TreeK## + + return ; +} +//____________________________________________________________________________ +void AliEMCALGetter::Event(const Int_t event, const char* opt) +{ + // Reads the content of all Tree's S, D and R + + if (event >= gAlice->TreeE()->GetEntries() ) { + cerr << "ERROR: AliEMCALGetter::Event -> " << event << " not found in TreeE!" << endl ; + return ; + } + gAlice->GetEvent(event) ; + + if(strstr(opt,"H") ) + {cout<<"Reading TreeH" << endl ; + ReadTreeH() ;} + + if(strstr(opt,"S") ) + { cout << "Reading TreeS" << endl ; + ReadTreeS(event) ;} + + if( strstr(opt,"D") ) + ReadTreeD() ; + + if( strstr(opt,"R") ) +// ReadTreeR() ; + + if( strstr(opt,"Q") ) +// ReadTreeQA() ; + + if( strstr(opt,"P") ) + ReadPrimaries() ; + +} + +//____________________________________________________________________________ +const TObject * AliEMCALGetter::ReturnO(TString what, TString name, TString file) const +{ + // get the object named "what" from the folder + // folders are named like //Folders + + if ( file.IsNull() ) + file = fHeaderFile ; + + TFolder * folder = 0 ; + TObject * emcalO = 0 ; + + // if ( name.IsNull() ) { + if ( what.CompareTo("Hits") == 0 ) { + folder = dynamic_cast(fHitsFolder->FindObject("EMCAL")) ; + if (folder) + emcalO = dynamic_cast(folder->FindObject("Hits")) ; + } + else if ( what.CompareTo("SDigits") == 0 ) { + TString path = "EMCAL/" + file ; + folder = dynamic_cast(fSDigitsFolder->FindObject(path.Data())) ; + if (folder) { + cout << "folder found" << endl ; + if (name.IsNull()) + name = fSDigitsTitle ; + emcalO = dynamic_cast(folder->FindObject(name)) ; + } + } + else if ( what.CompareTo("Digits") == 0 ){ + folder = dynamic_cast(fDigitsFolder->FindObject("EMCAL")) ; + if (folder) { + if (name.IsNull()) + name = fDigitsTitle ; + emcalO = dynamic_cast(folder->FindObject(name)) ; + } + } + if (!emcalO) { + cerr << "ERROR : AliEMCALGetter::ReturnO -> Object " << what << " not found in " << folder->GetName() << endl ; + return 0 ; + } + return emcalO ; +} + +//____________________________________________________________________________ +const TTask * AliEMCALGetter::ReturnT(TString what, TString name) const +{ + // get the TTask named "what" from the folder + // folders are named like //Folders/Tasks/what/EMCAL/name + + TString search(what) ; + + TTask * tasks = dynamic_cast(fTasksFolder->FindObject(search)) ; + + if (!tasks) { + cerr << "ERROR: AliEMCALGetter::ReturnT -> Task " << what << " not found!" << endl ; + return 0 ; + } + + TTask * emcalT = dynamic_cast(tasks->GetListOfTasks()->FindObject("EMCAL")) ; + if (!emcalT) { + cerr << "ERROR: AliEMCALGetter::ReturnT -> Task " << what << "/EMCAL not found!" << endl ; + return 0 ; + } + + TList * list = emcalT->GetListOfTasks() ; + + if (what.CompareTo("SDigitizer") == 0) { + if ( name.IsNull() ) + name = fSDigitsTitle ; + } else if (what.CompareTo("Digitizer") == 0){ + if ( name.IsNull() ) + name = fDigitsTitle ; + } + + TIter it(list) ; + TTask * task = 0 ; + while((task = static_cast(it.Next()) )){ + TString taskname(task->GetName()) ; + if(taskname.BeginsWith(name)) + return task ; + } + + cout << "WARNING: AliEMCALGetter::ReturnT -> Task " << search << "/" << name << " not found!" << endl ; + return 0 ; +} diff --git a/EMCAL/AliEMCALGetter.h b/EMCAL/AliEMCALGetter.h new file mode 100644 index 00000000000..5e8e8b2d4ea --- /dev/null +++ b/EMCAL/AliEMCALGetter.h @@ -0,0 +1,155 @@ +#ifndef ALIEMCALGETTER_H +#define ALIEMCALGETTER_H +/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +/* $Id$ */ + +//_________________________________________________________________________ +// A singleton that returns various objects +// Should be used on the analysis stage to avoid confusing between different +// branches of reconstruction tree: e.g. reading RecPoints and TS made from +// another set of RecPoints. +// At this stage the Getter class handles only Hits, Digits, and SDigits. +// The objects are retrived from folders. +//*-- Author: Sahal Yacoob (LBL) +// based on : AliPHOSGetter + + +// --- ROOT system --- +#include "TClonesArray.h" +#include "TFolder.h" +#include "TTree.h" +class TString ; +class TParticle ; +class TTask ; + +// --- Standard library --- +#include +#include + +// --- AliRoot header files --- + +#include "AliRun.h" +#include "AliEMCALv1.h" +class AliEMCALGeometry ; +class AliEMCALHit ; +class AliEMCALDigit ; +class AliEMCALDigitizer ; +class AliEMCALSDigitizer ; + +class AliEMCALGetter : public TObject { + + public: + + AliEMCALGetter(){ + // ctor: this is a singleton, the ctor should never be called but cint needs it as public + cerr << "ERROR: AliPHOGetter is a singleton default ctor not callable" << endl ; + abort() ; + } + AliEMCALGetter(const AliEMCALGetter & obj) { + // cpy ctor requested by Coding Convention + // but not yet needed + abort() ; + } + + virtual ~AliEMCALGetter() ; + + Bool_t PostHits(void ) const ; + Bool_t PostSDigits( const char * name, const char * file = 0) const ; + Bool_t PostDigits( const char * name ) const ; + + Bool_t PostSDigitizer (AliEMCALSDigitizer * sdigitizer) const ; + Bool_t PostSDigitizer ( const char * name, const char * file ) const ; + Bool_t PostDigitizer (AliEMCALDigitizer * digitizer) const ; + Bool_t PostDigitizer ( const char * name) const ; + + + void Event(const Int_t event, const char * opt = "HSD") ; + void Track(Int_t itrack) ; + + //Method to be used when digitizing under AliRunDigitizer, who opens all files etc. + void ReadTreeS(TTree * treeS,Int_t input) ; + + Int_t EventNumber() { return (Int_t) gAlice->GetEvNumber() ; } + Int_t MaxEvent() { return (Int_t) gAlice->TreeE()->GetEntries() ; } + static AliEMCALGetter * GetInstance(const char* headerFile, + const char* branchTitle = "Default" ) ; + static AliEMCALGetter * GetInstance() ; + + const AliEMCALv0 * EMCAL() ; + const AliEMCALGeometry * EMCALGeometry() ; + + // Hits + TClonesArray * Hits(void) const { return (TClonesArray*)(ReturnO("Hits")) ; } + + // SDigits + TClonesArray * SDigits(const char * name = 0, const char * file=0) const + { return (TClonesArray*)(ReturnO("SDigits", name, file)) ; } + + AliEMCALSDigitizer * SDigitizer(const char * name =0) const + { return ((AliEMCALSDigitizer*)(ReturnT("SDigitizer", name))) ; } + + // Digits + TClonesArray * Digits(const char * name = 0) const + { return (TClonesArray*)(ReturnO("Digits", name)) ; } + AliEMCALDigitizer * Digitizer(const char * name =0) const + { return (AliEMCALDigitizer*)(ReturnT("Digitizer", name)) ; } + + // Primaries + const TParticle * Primary(Int_t index) const ; + const Int_t NPrimaries()const { return fNPrimaries; } + + + AliEMCALGetter & operator = (const AliEMCALGetter & ) { + // assignement operator requested by coding convention, but not needed + abort() ; + return *this ; + } + + TFolder * SDigitsFolder() { return dynamic_cast(fSDigitsFolder->FindObject("EMCAL")) ; } + + private: + + AliEMCALGetter(const char* headerFile, const char* branchTitle ="Default") ; + void CreateWhiteBoard() const ; + const TObject * ReturnO(TString what, TString name=0, TString file=0) const ; + const TTask * ReturnT(TString what,TString name=0) const ; + void DefineBranchTitles(char* branch, char* branchTitle) ; + void ReadTreeD() ; + void ReadTreeH() ; + void ReadTreeS(Int_t event) ; + void ReadPrimaries() ; + + void * HitsRef(void) const ; + void * SDigitsRef(const char * name, const char * file = 0 ) const; + void * DigitsRef (const char * name) const ; + + void * SDigitizerRef (const char * name) const ; + void * DigitizerRef (const char * name) const ; + + private: + + TString fHeaderFile ; //! File in which gAlice lives + TString fBranchTitle ; //! + TString fDigitsTitle ; //! + TString fSDigitsTitle ; //! + + Int_t fDebug ; // Debug level + + Int_t fNPrimaries ; //! # of primaries + + TObjArray * fPrimaries ; //! list of lists of primaries-for the case of mixing + + TFolder * fHitsFolder ; //!Folder that contains the Hits + TFolder * fSDigitsFolder ; //!Folder that contains the SDigits + TFolder * fDigitsFolder ; //!Folder that contains the Digits + TFolder * fTasksFolder ; //!Folder that contains the Tasks (sdigitizer, digitizer, reconstructioner) + TFolder * fModuleFolder ; //! + static AliEMCALGetter * fgObjGetter; // pointer to the unique instance of the singleton + + ClassDef(AliEMCALGetter,1) // Algorithm class that provides methods to retrieve objects from a list knowing the index + +}; + +#endif // AliEMCALGETTER_H diff --git a/EMCAL/AliEMCALHit.cxx b/EMCAL/AliEMCALHit.cxx index f0f522c2fef..1003cd72dc7 100644 --- a/EMCAL/AliEMCALHit.cxx +++ b/EMCAL/AliEMCALHit.cxx @@ -17,8 +17,8 @@ //_________________________________________________________________________ // Hits class for EMCAL -// A hit in EMCAL is the sum of all hits in a single crystal -// +// A hit in EMCAL is the sum of all hits in a single segment +// from a single enterring particle //*-- Author: Sahal Yacoob (LBL / UCT) // Based on AliPHOSHit @@ -80,7 +80,7 @@ AliEMCALHit::AliEMCALHit(const AliEMCALHit & hit){ AliEMCALHit::AliEMCALHit(Int_t shunt, Int_t primary, Int_t track,Int_t iparent, Float_t ienergy, Int_t id, Float_t *hits,Float_t *p):AliHit(shunt, track){ // - // Create a CPV hit object + // Create an EMCAL hit object // fX = hits[0]; fY = hits[1]; @@ -98,7 +98,7 @@ AliEMCALHit::AliEMCALHit(Int_t shunt, Int_t primary, Int_t track,Int_t iparent, //______________________________________________________________________ Bool_t AliEMCALHit::operator==(AliEMCALHit const &rValue) const{ // Two hits are identical if they have the same Id and originat - // from the same primary + // from the same enterring Particle Bool_t rv = kFALSE; if ( (fId == rValue.GetId()) && ( fPrimary == rValue.GetIparent()) ) diff --git a/EMCAL/AliEMCALHit.h b/EMCAL/AliEMCALHit.h index 974bd0bdd8f..985c2d37a5f 100644 --- a/EMCAL/AliEMCALHit.h +++ b/EMCAL/AliEMCALHit.h @@ -7,7 +7,7 @@ //_________________________________________________________________________ // Hits class for EMCAL -// A hit in EMCAL is the sum of all hits from the same primary +// A hit in EMCAL is the sum of all hits from the same Entering particle // in the same segment of scintillator. // //*-- Author: Sahal Yacoob (LBL /UCT) @@ -46,12 +46,12 @@ class AliEMCALHit : public AliHit { private: Int_t fId; // Absolute Id number EMCAL segment Float_t fELOS; // Energy deposited - Int_t fPrimary; // Primary particles at the origine of the hit + Int_t fPrimary; // Primary particles at the origin of the hit Float_t fPx; // Primary partical enetrence momentum/energy Float_t fPy; // Primary partical enetrence momentum/energy Float_t fPz; // Primary partical enetrence momentum/energy Float_t fPe; // Primary partical enetrence momentum/energy - Int_t fIparent; // Parent particle that enterred emcal + Int_t fIparent; // Parent particle that entered emcal Float_t fIenergy; // Initial energy of parent particle that enterred the emcal ClassDef(AliEMCALHit,2) // Hit for EMCAL diff --git a/EMCAL/AliEMCALSDigitizer.cxx b/EMCAL/AliEMCALSDigitizer.cxx index 0961a29c87f..2bf60b37c75 100644 --- a/EMCAL/AliEMCALSDigitizer.cxx +++ b/EMCAL/AliEMCALSDigitizer.cxx @@ -1,4 +1,4 @@ -/************************************************************************** +/************************************************************************* * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * * * * Author: The ALICE Off-line Project. * @@ -18,7 +18,7 @@ //_________________________________________________________________________ // This is a TTask that makes SDigits out of Hits // A Summable Digits is the sum of all hits originating -// from one primary in one active cell +// from one in one tower of the EMCAL // A threshold for assignment of the primary to SDigit is applied // SDigits are written to TreeS, branch "EMCAL" // AliEMCALSDigitizer with all current parameters is written @@ -41,7 +41,8 @@ // deb all - print # and list of produced SDigits // tim - print benchmarking information // -//*-- Author : Dmitri Peressounko (SUBATECH & KI) +//*-- Author : Sahal Yacoob (LBL) +// based on : AliPHOSSDigitzer ////////////////////////////////////////////////////////////////////////////// @@ -73,7 +74,7 @@ ClassImp(AliEMCALSDigitizer) // ctor fA = 0; fB = 10000000. ; - fPrimThreshold = 0.001 ; + fPrimThreshold = 0.01 ; fNevents = 0 ; fSDigits = 0 ; fHits = 0 ; @@ -87,7 +88,7 @@ AliEMCALSDigitizer::AliEMCALSDigitizer(const char* headerFile, const char *sDigi // ctor fA = 0; fB = 10000000.; - fPrimThreshold = 0.001 ; + fPrimThreshold = 0.01 ; fNevents = 0 ; fSDigitsTitle = sDigitsTitle ; fHeadersFile = headerFile ; @@ -191,51 +192,59 @@ void AliEMCALSDigitizer::Exec(Option_t *option) { //=========== Get the EMCAL branch from Hits Tree for the Primary track itrack branch->GetEntry(itrack,0); - AliEMCAL * EMCAL = (AliEMCAL *) gAlice->GetDetector("EMCAL") ; + AliEMCALv0 * EMCAL = (AliEMCALv0 *) gAlice->GetDetector("EMCAL") ; AliEMCALGeometry *geom = AliEMCALGeometry::GetInstance( EMCAL->GetGeometry()->GetName(), EMCAL->GetGeometry()->GetTitle() ); Int_t i; for ( i = 0 ; i < fHits->GetEntries() ; i++ ) { AliEMCALHit * hit = (AliEMCALHit*)fHits->At(i) ; - AliEMCALDigit curSDigit = AliEMCALDigit(1,1,1,1); - AliEMCALDigit *sdigit ; - - // Assign primary number only if contribution is significant - + AliEMCALDigit * curSDigit = 0 ; + AliEMCALDigit * sdigit ; + Bool_t newsdigit = kTRUE; +// Assign primary number only if contribution is significant if( hit->GetEnergy() > fPrimThreshold) - curSDigit = AliEMCALDigit( hit->GetPrimary(), hit->GetIparent(), (((hit->GetId()/geom->GetNPhi())%geom->GetNZ()+1) * (hit->GetId()%(geom->GetNPhi()+1))), Digitize( hit->GetEnergy() ) ) ; + curSDigit = new AliEMCALDigit( hit->GetPrimary(), hit->GetIparent(), (((hit->GetId()/geom->GetNPhi())%geom->GetNZ()+1 ) * (hit->GetId()%(geom->GetNPhi()+1))), Digitize( hit->GetEnergy() ) ) ; else - curSDigit = AliEMCALDigit( -1 , -1 ,(((hit->GetId()/geom->GetNPhi())%geom->GetNZ()+1) * (hit->GetId()%(geom->GetNPhi()+1))), Digitize( hit->GetEnergy() ) ) ; - - for(Int_t check= 0; check < nSdigits; check++) { + curSDigit = new AliEMCALDigit( -1 , -1 ,(((hit->GetId()/geom->GetNPhi())%geom->GetNZ() + 1 ) * (hit->GetId()%(geom->GetNPhi()+1))), Digitize( hit->GetEnergy() ) ) ; + cout << "Hit ID = " <GetId() << endl ; + cout << "ID for detector = " << curSDigit->GetId() << endl ; + cout << hit->GetEnergy() << " - hit energy - Digit Energy - " << curSDigit->GetAmp() << endl; + for(Int_t check= 0; check < nSdigits ; check++) { sdigit = (AliEMCALDigit *)fSDigits->At(check); - if( (((hit->GetId()/geom->GetNPhi())%geom->GetNZ()) == ((sdigit->GetId()/geom->GetNPhi())%geom->GetNZ())) && ((hit->GetId()%geom->GetNPhi()) == (sdigit->GetId()%geom->GetNPhi()))) - { - *sdigit = *sdigit + curSDigit ; + if( sdigit->GetId() == curSDigit->GetId()) + { cout << "SDigit - Get Amp " << sdigit->GetAmp() << endl ; + *sdigit = *sdigit + *curSDigit ; + newsdigit = kFALSE; + cout << " and after addition " << sdigit->GetAmp() << endl ; } - else - { new((*fSDigits)[nSdigits]) AliEMCALDigit(curSDigit); - nSdigits++ ; } - } - + } + if (newsdigit) + { new((*fSDigits)[nSdigits]) AliEMCALDigit(*curSDigit); + nSdigits++ ; + cout << "Detector nsdigits = " << nSdigits << endl ; } + newsdigit = kTRUE; + if( hit->GetEnergy() > fPrimThreshold) - curSDigit = AliEMCALDigit( hit->GetPrimary(), hit->GetIparent(), ((geom->GetNZ() * geom->GetNPhi()) + ((hit->GetId()/geom->GetNPhi())%geom->GetNZ()+1) * (hit->GetId()%(geom->GetNPhi()+1))), Digitize( hit->GetEnergy() ) ) ; + curSDigit = new AliEMCALDigit( hit->GetPrimary(), hit->GetIparent(), ((geom->GetNZ() * geom->GetNPhi()) + ((hit->GetId()/geom->GetNPhi())%geom->GetNZ() + 1) * (hit->GetId()%(geom->GetNPhi()+1))), Digitize( hit->GetEnergy() ) ) ; else - curSDigit = AliEMCALDigit( -1 , -1 ,((geom->GetNZ() * geom->GetNPhi()) + ((hit->GetId()/geom->GetNPhi())%geom->GetNZ()+1) * (hit->GetId()%(geom->GetNPhi()+1))), Digitize( hit->GetEnergy() ) ) ; + curSDigit = new AliEMCALDigit( -1 , -1 ,((geom->GetNZ() * geom->GetNPhi()) + ((hit->GetId()/geom->GetNPhi())%geom->GetNZ()+1) * (hit->GetId()%(geom->GetNPhi()+1))), Digitize( hit->GetEnergy() ) ) ; if((hit->GetId()/geom->GetNPhi()) < (2*geom->GetNZ())) - { + { cout << "ID for Preshower = " << curSDigit->GetId() << endl ; for(Int_t check= 0; check < nSdigits; check++) { sdigit = (AliEMCALDigit *)fSDigits->At(check); - if( (((hit->GetId()/geom->GetNPhi())%geom->GetNZ()) == ((sdigit->GetId()/geom->GetNPhi())%geom->GetNZ())) && ((hit->GetId()%geom->GetNPhi()) == (sdigit->GetId()%geom->GetNPhi()))) + if( sdigit->GetId() == curSDigit->GetId()) { - *sdigit = *sdigit + curSDigit ; + *sdigit = *sdigit + *curSDigit ; + newsdigit = kFALSE ; + } } - else - { new((*fSDigits)[nSdigits]) AliEMCALDigit(curSDigit); - nSdigits++ ; } - } + if (newsdigit) + { new((*fSDigits)[nSdigits]) AliEMCALDigit(*curSDigit); + nSdigits++ ; + cout << "Preshower nsdigits = " << nSdigits << endl ;} + newsdigit=kTRUE; } } } // loop over tracks diff --git a/EMCAL/AliEMCALSDigitizer.h b/EMCAL/AliEMCALSDigitizer.h index 543b9e45c81..51f7936df26 100644 --- a/EMCAL/AliEMCALSDigitizer.h +++ b/EMCAL/AliEMCALSDigitizer.h @@ -8,7 +8,9 @@ //_________________________________________________________________________ // Task Class for making SDigits in EMCAL // -//*-- Author: Dmitri Peressounko(SUBATECH & KI) +//*-- Author: Sahal Yacoob (LBL) +// based on : AliPHOSSDigitizer +//_________________________________________________________________________ // --- ROOT system --- @@ -22,7 +24,7 @@ class AliEMCALSDigitizer: public TTask { public: AliEMCALSDigitizer() ; // ctor - AliEMCALSDigitizer(const char* HeaderFile,const char *SdigitsTitle = 0) ; + AliEMCALSDigitizer(const char* HeaderFile,const char *SdigitsTitle = "Default") ; virtual ~AliEMCALSDigitizer() ; // dtor Float_t Calibrate(Int_t amp)const {return (amp - fA)/fB ; } @@ -55,7 +57,7 @@ private: TString fHeadersFile ; //input file Bool_t fIsInitialized ; TClonesArray * fSDigits ; //! list of SDigits - TClonesArray * fHits ; //! + TClonesArray * fHits ; //! ClassDef(AliEMCALSDigitizer,1) // description diff --git a/EMCAL/AliEMCALv0.cxx b/EMCAL/AliEMCALv0.cxx index 112577e883f..40cecba5bdb 100644 --- a/EMCAL/AliEMCALv0.cxx +++ b/EMCAL/AliEMCALv0.cxx @@ -19,7 +19,7 @@ // Implementation version v0 of EMCAL Manager class // An object of this class does not produce hits nor digits // It is the one to use if you do not want to produce outputs in TREEH or TREED -// +// This class places a Geometry of the EMCAL in the ALICE Detector as defined in AliEMCALGeometry.cxx //*-- Author: Yves Schutz (SUBATECH) //*-- and : Sahal Yacoob (LBL / UCT) @@ -64,7 +64,7 @@ void AliEMCALv0::BuildGeometry(){ const Int_t kColorArm1 = kBlue ; - // make the container of Arm1 + // Difine the shape of the Calorimeter new TTUBS("Envelop1", "Tubs that contains arm 1", "void", fGeom->GetEnvelop(0), // rmin @@ -73,7 +73,7 @@ void AliEMCALv0::BuildGeometry(){ fGeom->GetArm1PhiMin(), // minimun phi angle fGeom->GetArm1PhiMax() // maximun phi angle ); - // Arm 1 inside alice + // Place the Node TNode * envelop1node = new TNode("Envelop1", "Arm1 Envelop", "Envelop1") ; envelop1node->SetLineColor(kColorArm1) ; fNodes->Add(envelop1node) ; @@ -91,7 +91,7 @@ void AliEMCALv0::CreateGeometry(){ // Get pointer to the array containing media indices Int_t *idtmed = fIdtmed->GetArray() - 1599 ; - // Create tube sectors that contains Arm 1 & 2 + // Create an Envelope within which to place the Detector Float_t envelopA[5] ; envelopA[0] = fGeom->GetEnvelop(0) ; // rmin @@ -102,55 +102,55 @@ void AliEMCALv0::CreateGeometry(){ gMC->Gsvolu("XEN1", "TUBS ", idtmed[1599], envelopA, 5) ; //filled with air - // Create a tube sector that contains active material Arm 1 & 2 + // Create the shapes of active material (LEAD/Aluminium/Scintillator) to be placed - Float_t envelopB[10]; - Float_t envelopC[10]; - Float_t envelopD[10]; - envelopC[0] = envelopD[0] = envelopB[0] = fGeom->GetArm1PhiMin(); - envelopC[1] = envelopD[1] = envelopB[1] = fGeom->GetArm1PhiMax() - + Float_t envelopB[10]; // First Layer of Aluminium + Float_t envelopC[10]; // Scintillator Layers + Float_t envelopD[10]; // Lead Layers + + envelopC[0] = envelopD[0] = envelopB[0] = fGeom->GetArm1PhiMin(); //starting position in Phi + envelopC[1] = envelopD[1] = envelopB[1] = fGeom->GetArm1PhiMax() - // Angular size of the Detector in Phi fGeom->GetArm1PhiMin(); - envelopC[2] = envelopD[2] = envelopB[2] = fGeom->GetNPhi() ; - envelopD[3] = 2; - envelopC[3] = 2; - envelopB[3] = 2; + envelopC[2] = envelopD[2] = envelopB[2] = fGeom->GetNPhi() ; // Number of Section in Phi + envelopD[3] = envelopC[3] = envelopB[3] = 2; // each section will be passed 2 z coordinates envelopB[4] = (fGeom->GetEnvelop(0) + fGeom->GetGap2Active()) / - (tan(2*atan(exp(0.7)))) ; - envelopB[5] = fGeom->GetEnvelop(0) + fGeom->GetGap2Active(); //rmin - envelopD[6] = envelopB[6] = envelopB[5] + 3.18; //rmax + (tan(2*atan(exp(0.7)))) ; // z co-ordinate 1 + envelopB[5] = fGeom->GetEnvelop(0) + fGeom->GetGap2Active(); //rmin at z1 + envelopD[6] = envelopB[6] = envelopB[5] + 3.18; //rmax at z1 envelopB[7] = (fGeom->GetEnvelop(0) + fGeom->GetGap2Active()) / - (tan(2*atan(exp(-0.7)))) ; - envelopB[8] = envelopB[5] ; - envelopB[9] = envelopB[6] ; - - // filled with active material (average) - gMC->Gsvolu("XALU", "PGON", idtmed[1602], envelopB, 10); - // filled with active material (Polystyrene) - gMC->Gsvolu("XPST", "PGON", idtmed[1601], 0, 0) ; - gMC->Gsvolu("XPBX", "PGON", idtmed[1600], 0, 0) ; // filled with Lead - gMC->Gsdvn("XPHI", "XPST", fGeom->GetNPhi(), 2) ; // Naming Phi divisions + (tan(2*atan(exp(-0.7)))) ; // z co-ordinate 2 + envelopB[8] = envelopB[5] ; // + envelopB[9] = envelopB[6] ; // radii are the same. + + // filled shapes wit hactive material + gMC->Gsvolu("XALU", "PGON", idtmed[1602], envelopB, 10); // Define Aluminium volume completely + gMC->Gsvolu("XPST", "PGON", idtmed[1601], 0, 0) ; // The polystyrene layers will be defined when placed + gMC->Gsvolu("XPBX", "PGON", idtmed[1600], 0, 0) ; // as will the lead layers + gMC->Gsdvn("XPHI", "XPST", fGeom->GetNPhi(), 2) ; // Dividind eta polystyrene divisions into phi segments. Int_t idrotm = 1; AliMatrix(idrotm, 90.0, 0., 90.0, 90.0, 0.0, 0.0) ; - // Position ENV1 container in ALIC + // Position the Envelope in Alice gMC->Gspos("XEN1", 1, "ALIC", 0.0, 0.0, 0.0, idrotm, "MANY") ; - // Position ARM1 into ENV1 + // Position Aluminium Layer in the Envelope gMC->Gspos("XALU", 1, "XEN1", 0.0, 0.0, 0.0 , idrotm, "ONLY") ; +// The loop below places the scintillator in Lead Layers alternately. + for (int i = 0; i < (fGeom->GetNLayers()); i++ ){ envelopC[5] = envelopD[6] ; //rmin - envelopC[6] = envelopD[6] + ((i > +2) ? 0.5 : 0.6) ; //rmax + envelopC[6] = envelopD[6] + ((i > +2) ? 0.5 : 0.6) ; //rmax larger for first two layers (preshower) envelopC[8] = envelopD[6] ; //rmin - envelopC[9] = envelopD[6] + ((i > 2 ) ? 0.5 : 0.6) ; //rmax + envelopC[9] = envelopD[6] + ((i > 2 ) ? 0.5 : 0.6) ; //rmax larger for first two layers (preshower) for (int j =0; j < (fGeom->GetNZ()) ; j++){ envelopC[4] = envelopD[6]/tan(2*atan(exp(0.7-(j*1.4/ - (fGeom->GetNZ()))))); + (fGeom->GetNZ()))))); //z begin envelopC[7] = envelopD[6]/tan(2*atan(exp(0.7-((j+1)*1.4/ - (fGeom->GetNZ()))))); - gMC->Gsposp("XPST",1+j+i*(fGeom->GetNZ()), "XEN1", - 0.0, 0.0, 0.0 , idrotm, "ONLY", envelopC, 10); + (fGeom->GetNZ()))))); // z end + gMC->Gsposp("XPST",1+j+i*(fGeom->GetNZ()), "XEN1", + 0.0, 0.0, 0.0 , idrotm, "ONLY", envelopC, 10); // Position and define layer } // end for j if (i < (fGeom->GetNLayers()-1)){ envelopD[5] = envelopC[6] ; //rmin @@ -159,11 +159,11 @@ void AliEMCALv0::CreateGeometry(){ envelopD[9] = envelopC[6] + 0.5; //rmax for (int j =0; j < (fGeom->GetNZ()) ; j++){ envelopD[4] = envelopC[6]/tan(2*atan(exp(0.7-(j*1.4/ - (fGeom->GetNZ()))))); + (fGeom->GetNZ()))))); // z begin envelopD[7] = envelopC[6]/tan(2*atan(exp(0.7-((j+1)*1.4/ - (fGeom->GetNZ()))))); + (fGeom->GetNZ()))))); // z end gMC->Gsposp("XPBX",1+ j+i*(fGeom->GetNZ()), "XEN1", - 0.0, 0.0, 0.0 , idrotm, "MANY", envelopD, 10) ; + 0.0, 0.0, 0.0 , idrotm, "MANY", envelopD, 10) ; // Position and Define Layer } // end for j } // end if i } // for i diff --git a/EMCAL/AliEMCALv0.h b/EMCAL/AliEMCALv0.h index e1297b3741a..ee3c7f40f26 100644 --- a/EMCAL/AliEMCALv0.h +++ b/EMCAL/AliEMCALv0.h @@ -42,7 +42,7 @@ class AliEMCALv0 : public AliEMCAL { virtual void BuildGeometry();// creates the geometry for the ROOT display virtual void CreateGeometry() ;// creates the geometry for GEANT - virtual AliEMCALGeometry * GetGeometry() { + virtual AliEMCALGeometry * GetGeometry() const { // gets the pointer to the AliEMCALGeometry unique instance return fGeom ; } @@ -67,7 +67,7 @@ class AliEMCALv0 : public AliEMCAL { protected: - ClassDef(AliEMCALv0,1) // Implementation of EMCAL manager class for layout EMC+PPSD + ClassDef(AliEMCALv0,1) // Implementation of EMCAL manager class for midrapidity barrel layout between 0 and 120 degrees }; diff --git a/EMCAL/AliEMCALv1.cxx b/EMCAL/AliEMCALv1.cxx index c401e430042..64169c4f81b 100644 --- a/EMCAL/AliEMCALv1.cxx +++ b/EMCAL/AliEMCALv1.cxx @@ -66,7 +66,7 @@ AliEMCALv1::AliEMCALv1(const char *name, const char *title): gAlice->AddHitList(fHits); fNhits = 0; - + fSamplingFraction = 12.9 ; fIshunt = 1; // All hits are associated with primary particles } //______________________________________________________________________ @@ -83,8 +83,8 @@ AliEMCALv1::~AliEMCALv1(){ void AliEMCALv1::AddHit(Int_t shunt, Int_t primary, Int_t tracknumber, Int_t iparent, Float_t ienergy, Int_t id, Float_t * hits,Float_t * p){ // Add a hit to the hit list. - // A PHOS hit is the sum of all hits in a single crystal - // or in a single PPSD gas cell + // An EMCAL hit is the sum of all hits in a single segment + // originating from the same enterring particle Int_t hitCounter; AliEMCALHit *newHit; @@ -122,19 +122,19 @@ void AliEMCALv1::StepManager(void){ TLorentzVector pos; // Lorentz vector of the track current position. TLorentzVector mom; // Lorentz vector of the track current momentum. Int_t tracknumber = gAlice->CurrentTrack(); - Int_t primary; + Int_t primary = 0; static Int_t iparent = 0; static Float_t ienergy = 0; - Int_t copy; + Int_t copy = 0; - if(gMC->IsTrackEntering() && (strcmp(gMC->CurrentVolName(),"XALU") == 0)) + if(gMC->IsTrackEntering() && (strcmp(gMC->CurrentVolName(),"XALU") == 0)) // This Particle in enterring the Calorimeter { iparent = tracknumber; gMC->TrackMomentum(mom); ienergy = mom[3]; } - if(gMC->CurrentVolID(copy) == gMC->VolId("XPHI") ) { // We are inside a PBWO crysta + if(gMC->CurrentVolID(copy) == gMC->VolId("XPHI") ) { // We are in a Scintillator Layer gMC->CurrentVolOffID(1, id[0]); // get the POLY copy number; gMC->CurrentVolID(id[1]); // get the phi number inside the layer @@ -144,7 +144,7 @@ void AliEMCALv1::StepManager(void){ xyze[0] = pos[0]; xyze[1] = pos[1]; xyze[2] = pos[2]; - xyze[3] = gMC->Edep(); + xyze[3] = fSamplingFraction*(gMC->Edep()); // Correct for sampling calorimeter pmom[0] = mom[0]; pmom[1] = mom[1]; pmom[2] = mom[2]; @@ -152,7 +152,9 @@ void AliEMCALv1::StepManager(void){ if(xyze[3] > 0.){// Track is inside the crystal and deposits some energy absid = (id[0]-1)*(fGeom->GetNPhi()) + id[1]; - AddHit(fIshunt, primary,tracknumber, iparent, ienergy, absid, xyze, pmom); + if((absid/fGeom->GetNPhi()) < (2*fGeom->GetNZ())) + {xyze[3] = 5*xyze[3]/6 ;} // Preshower readout must be scaled + AddHit(fIshunt, primary,tracknumber, iparent, ienergy, absid, xyze, pmom); } // there is deposited energy } } diff --git a/EMCAL/AliEMCALv1.h b/EMCAL/AliEMCALv1.h index 186c0b3fe5e..c3f145bf88e 100644 --- a/EMCAL/AliEMCALv1.h +++ b/EMCAL/AliEMCALv1.h @@ -9,7 +9,7 @@ // Implementation version v1 of EMCAL Manager class //*-- //*-- Author: Sahal Yacoob (LBL / UCT) -//*-- and : Jennifer Klay +//*-- and : Jennifer Klay (LBL) //#include // --- ROOT system --- @@ -38,7 +38,10 @@ class AliEMCALv1 : public AliEMCALv0 { AliEMCALv1 & operator = (const AliEMCALv0 & rvalue){abort();return *this;} protected: - ClassDef(AliEMCALv1,1)//Implementation of EMCAL manager class for layout EMC+PPSD + ClassDef(AliEMCALv1,2)//Implementation of EMCAL manager class to produce hits in a Central Calorimeter + + private: + Double_t fSamplingFraction ; // Sampling Fraction of Calorimeter E = f*Elos }; #endif // AliEMCALV1_H diff --git a/EMCAL/EMCALLinkDef.h b/EMCAL/EMCALLinkDef.h index 2655c88e4a1..2819f1f131d 100644 --- a/EMCAL/EMCALLinkDef.h +++ b/EMCAL/EMCALLinkDef.h @@ -12,4 +12,5 @@ #pragma link C++ class AliEMCALDigit+; #pragma link C++ class AliEMCALSDigitizer+; #pragma link C++ class AliEMCALDigitizer+; +#pragma link C++ class AliEMCALGetter+; #endif diff --git a/EMCAL/Makefile b/EMCAL/Makefile index c423be621f7..19e29b88d12 100644 --- a/EMCAL/Makefile +++ b/EMCAL/Makefile @@ -11,7 +11,7 @@ PACKAGE = EMCAL SRCS = AliEMCAL.cxx AliEMCALGeometry.cxx AliEMCALv0.cxx \ AliEMCALv1.cxx AliEMCALHit.cxx AliEMCALDigit.cxx \ - AliEMCALSDigitizer.cxx AliEMCALDigitizer.cxx + AliEMCALSDigitizer.cxx AliEMCALDigitizer.cxx AliEMCALGetter.cxx # C++ Headers -- 2.39.3