From 73bc3a3ff802a9cf3ab68d3d26815a7b48e840d2 Mon Sep 17 00:00:00 2001 From: coppedis Date: Tue, 16 Jun 2009 11:33:14 +0000 Subject: [PATCH] Updated reco alghorithm, changes in OCDB object and in RecoParam objects, new classes added --- ZDC/AliZDC.cxx | 30 +- ZDC/AliZDC.h | 12 +- ZDC/AliZDCDigitizer.cxx | 33 +- ZDC/AliZDCDigitizer.h | 17 +- ZDC/AliZDCEnCalib.cxx | 108 ++++ ZDC/AliZDCEnCalib.h | 40 ++ ZDC/AliZDCPreprocessor.cxx | 614 +++++++++++------- ZDC/AliZDCReco.cxx | 124 ++-- ZDC/AliZDCReco.h | 63 +- ZDC/AliZDCRecoParam.cxx | 12 +- ZDC/AliZDCRecoParam.h | 37 +- ZDC/AliZDCRecoParamPbPb.cxx | 182 +++--- ZDC/AliZDCRecoParamPbPb.h | 127 +--- ZDC/AliZDCRecoParampp.cxx | 28 +- ZDC/AliZDCRecoParampp.h | 39 +- ZDC/AliZDCReconstructor.cxx | 1219 +++++++++++++++++++++++++---------- ZDC/AliZDCReconstructor.h | 50 +- ZDC/AliZDCTowerCalib.cxx | 149 +++++ ZDC/AliZDCTowerCalib.h | 55 ++ ZDC/CMake_libZDCbase.txt | 3 +- ZDC/CMake_libZDCsim.txt | 6 +- ZDC/MakeZDCRecoParam.C | 97 ++- ZDC/TestZDCPreprocessor.C | 33 +- ZDC/ZDCbaseLinkDef.h | 3 +- ZDC/ZDCsimLinkDef.h | 2 + ZDC/libZDCbase.pkg | 4 +- ZDC/libZDCsim.pkg | 6 +- 27 files changed, 2053 insertions(+), 1040 deletions(-) create mode 100644 ZDC/AliZDCEnCalib.cxx create mode 100644 ZDC/AliZDCEnCalib.h create mode 100644 ZDC/AliZDCTowerCalib.cxx create mode 100644 ZDC/AliZDCTowerCalib.h diff --git a/ZDC/AliZDC.cxx b/ZDC/AliZDC.cxx index 11005a6a3f8..4fdfab3cad4 100644 --- a/ZDC/AliZDC.cxx +++ b/ZDC/AliZDC.cxx @@ -47,7 +47,8 @@ #include "AliZDCDigitizer.h" #include "AliZDCRawStream.h" #include "AliZDCPedestals.h" -#include "AliZDCCalib.h" +#include "AliZDCEnCalib.h" +#include "AliZDCTowerCalib.h" #include "AliFstream.h" @@ -58,7 +59,8 @@ AliZDC::AliZDC() : AliDetector(), fNoShower(0), fPedCalib(0), - fCalibData(0), + fEnCalibData(0), + fTowCalibData(0), fZDCCalibFName(""), fSpectatorTracked(1) { @@ -79,7 +81,8 @@ AliZDC::AliZDC(const char *name, const char *title) : AliDetector(name,title), fNoShower (0), fPedCalib(0), - fCalibData(0), + fEnCalibData(0), + fTowCalibData(0), fZDCCalibFName(""), fSpectatorTracked(1) { @@ -110,8 +113,9 @@ AliZDC::~AliZDC() // fIshunt = 0; - delete fPedCalib; - delete fCalibData; + if(fPedCalib) delete fPedCalib; + if(fEnCalibData) delete fEnCalibData; + if(fEnCalibData) delete fEnCalibData; } @@ -120,7 +124,8 @@ AliZDC::AliZDC(const AliZDC& ZDC) : AliDetector("ZDC","ZDC"), fNoShower(ZDC.fNoShower), fPedCalib(ZDC.fPedCalib), -fCalibData(ZDC.fCalibData), +fEnCalibData(ZDC.fEnCalibData), +fTowCalibData(ZDC.fTowCalibData), fZDCCalibFName(ZDC.fZDCCalibFName), fSpectatorTracked(ZDC.fSpectatorTracked) { @@ -134,7 +139,8 @@ AliZDC& AliZDC::operator=(const AliZDC& ZDC) if(this!=&ZDC){ fNoShower = ZDC.fNoShower; fPedCalib = ZDC.fPedCalib; - fCalibData = ZDC.fCalibData; + fEnCalibData = ZDC.fEnCalibData; + fTowCalibData = ZDC.fTowCalibData; fZDCCalibFName = ZDC.fZDCCalibFName; } return *this; } @@ -601,9 +607,7 @@ void AliZDC::Digits2Raw() Error("Digits2Raw", "sector[0] = %d, sector[1] = %d", digit.GetSector(0), digit.GetSector(1)); continue; - } - - + } } // /* @@ -615,12 +619,14 @@ void AliZDC::Digits2Raw() // End of Block UInt_t lADCEndBlockGEO = lADCHeaderGEO; - UInt_t lADCEndBlockEvCount = gAlice->GetEventNrInRun(); + // Event counter in ADC EOB -> getting no. of events in run from AliRunLoader + // get run loader + AliRunLoader* runLoader = fLoader->GetRunLoader(); + UInt_t lADCEndBlockEvCount = runLoader->GetEventNumber(); // lADCEndBlock = lADCEndBlockGEO << 27 | 0x1 << 26 | lADCEndBlockEvCount; //printf("\t AliZDC::Digits2Raw -> ADCEndBlock = %d\n",lADCEndBlock); - // open the output file char fileName[30]; strcpy(fileName,AliDAQ::DdlFileName("ZDC",0)); diff --git a/ZDC/AliZDC.h b/ZDC/AliZDC.h index 06c35b7b71c..25edd9a4df3 100644 --- a/ZDC/AliZDC.h +++ b/ZDC/AliZDC.h @@ -15,7 +15,8 @@ #include "AliZDCTrigger.h" class AliZDCPedestals; -class AliZDCCalib; +class AliZDCEnCalib; +class AliZDCTowCalib; class AliZDC : public AliDetector { @@ -50,7 +51,7 @@ public: void SetZDCCalibFName(const char *name); char* GetZDCCalibFName() const {return (char*)fZDCCalibFName.Data();} AliZDCPedestals* GetPedCalib() const {return fPedCalib;} - AliZDCCalib* GetECalibData() const {return fCalibData;} + AliZDCEnCalib* GetECalibData() const {return fEnCalibData;} // Trigger virtual AliTriggerDetector* CreateTriggerDetector() const @@ -69,14 +70,15 @@ protected: Int_t fNoShower; // Flag to switch off the shower //Calibration data member - AliZDCPedestals* fPedCalib; // Pedestal data for ZDC - AliZDCCalib* fCalibData; // Energy and equalization data for ZDC + AliZDCPedestals* fPedCalib; //! Pedestal data for ZDC + AliZDCEnCalib* fEnCalibData; //! Energy data for ZDC + AliZDCTowCalib* fTowCalibData; //! Equalization data for ZDC TString fZDCCalibFName; // Name of the ZDC calibration data Int_t fSpectatorTracked; // Are spectator tracked by generator? - ClassDef(AliZDC,8) // Zero Degree Calorimeter base class + ClassDef(AliZDC,9) // Zero Degree Calorimeter base class }; // Calibration diff --git a/ZDC/AliZDCDigitizer.cxx b/ZDC/AliZDCDigitizer.cxx index 05422b78059..e927afa8897 100644 --- a/ZDC/AliZDCDigitizer.cxx +++ b/ZDC/AliZDCDigitizer.cxx @@ -46,7 +46,8 @@ class AliCDBStorage; class AliZDCPedestals; -class AliZDCCalib; +class AliZDCEnCalib; +class AliZDCTowerCalib; ClassImp(AliZDCDigitizer) @@ -57,7 +58,8 @@ AliZDCDigitizer::AliZDCDigitizer() : fIsSignalInADCGate(kFALSE), fFracLostSignal(0.), fPedData(0), - fCalibData(0), + fEnCalibData(0), + fTowCalibData(0), fSpectators2Track(kFALSE) { // Default constructor @@ -71,7 +73,8 @@ AliZDCDigitizer::AliZDCDigitizer(AliRunDigitizer* manager): fIsSignalInADCGate(kFALSE), fFracLostSignal(0.), fPedData(GetPedData()), - fCalibData(GetCalibData()), + fEnCalibData(GetEnCalibData()), + fTowCalibData(GetTowCalibData()), fSpectators2Track(kFALSE) { // Get calibration data @@ -94,7 +97,8 @@ AliZDCDigitizer::AliZDCDigitizer(const AliZDCDigitizer &digitizer): fIsSignalInADCGate(digitizer.fIsSignalInADCGate), fFracLostSignal(digitizer.fFracLostSignal), fPedData(digitizer.fPedData), - fCalibData(digitizer.fCalibData), + fEnCalibData(digitizer.fEnCalibData), + fTowCalibData(digitizer.fTowCalibData), fSpectators2Track(digitizer.fSpectators2Track) { // Copy constructor @@ -547,15 +551,30 @@ AliZDCPedestals* AliZDCDigitizer::GetPedData() const } //_____________________________________________________________________________ -AliZDCCalib* AliZDCDigitizer::GetCalibData() const +AliZDCEnCalib* AliZDCDigitizer::GetEnCalibData() const { // Getting calibration object for ZDC set - AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/EMDCalib"); + AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/EnCalib"); if(!entry) AliFatal("No calibration data loaded!"); - AliZDCCalib *calibdata = dynamic_cast (entry->GetObject()); + AliZDCEnCalib *calibdata = dynamic_cast (entry->GetObject()); + if(!calibdata) AliFatal("Wrong calibration object in calibration file!"); + + return calibdata; +} + +//_____________________________________________________________________________ +AliZDCTowerCalib* AliZDCDigitizer::GetTowCalibData() const +{ + + // Getting calibration object for ZDC set + + AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/TowCalib"); + if(!entry) AliFatal("No calibration data loaded!"); + + AliZDCTowerCalib *calibdata = dynamic_cast (entry->GetObject()); if(!calibdata) AliFatal("Wrong calibration object in calibration file!"); return calibdata; diff --git a/ZDC/AliZDCDigitizer.h b/ZDC/AliZDCDigitizer.h index d21a920e597..27d1a8f7610 100644 --- a/ZDC/AliZDCDigitizer.h +++ b/ZDC/AliZDCDigitizer.h @@ -13,7 +13,8 @@ #include "AliCDBManager.h" #include "AliCDBStorage.h" #include "AliZDCPedestals.h" -#include "AliZDCCalib.h" +#include "AliZDCEnCalib.h" +#include "AliZDCTowerCalib.h" class AliRunDigitizer; @@ -43,9 +44,10 @@ public: Float_t GetADCRes(Int_t i) const {return fADCRes[i];} void SetCalibrationOn() {fIsCalibration=1;} - AliCDBStorage *SetStorage(const char* uri); - AliZDCPedestals *GetPedData() const; - AliZDCCalib *GetCalibData() const; + AliCDBStorage *SetStorage(const char* uri); + AliZDCPedestals *GetPedData() const; + AliZDCEnCalib *GetEnCalibData() const; + AliZDCTowerCalib *GetTowCalibData() const; void SetSpectators2Track() {fSpectators2Track=kTRUE;} @@ -69,11 +71,12 @@ private: Bool_t fIsSignalInADCGate; // true if signal in ADC gate Float_t fFracLostSignal; // fraction of lost signal - AliZDCPedestals *fPedData; //! pedestal calibration data - AliZDCCalib *fCalibData; //! energy and equalization calibration data + AliZDCPedestals *fPedData; //! pedestal calibration data + AliZDCEnCalib *fEnCalibData; //! energy and equalization calibration data + AliZDCTowerCalib *fTowCalibData; //! energy and equalization calibration data Bool_t fSpectators2Track; // should digitizer track spectators - ClassDef(AliZDCDigitizer, 9) // digitizer for ZDC + ClassDef(AliZDCDigitizer, 10) // digitizer for ZDC }; #endif diff --git a/ZDC/AliZDCEnCalib.cxx b/ZDC/AliZDCEnCalib.cxx new file mode 100644 index 00000000000..eebeeb4936f --- /dev/null +++ b/ZDC/AliZDCEnCalib.cxx @@ -0,0 +1,108 @@ +/************************************************************************** + * 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. * + **************************************************************************/ + +/////////////////////////////////////////////////////////////////////////////// +// // +// class for ZDC ENERGY calibration // +// -> values for energy calibration // +// // +/////////////////////////////////////////////////////////////////////////////// + +#include "AliZDCEnCalib.h" + +ClassImp(AliZDCEnCalib) + +//________________________________________________________________ +AliZDCEnCalib::AliZDCEnCalib(): +TNamed() +{ + Reset(); +} + +//________________________________________________________________ +AliZDCEnCalib::AliZDCEnCalib(const char* name): +TNamed() +{ + // Constructor + TString namst = "Calib_"; + namst += name; + SetName(namst.Data()); + SetTitle(namst.Data()); + Reset(); + for(Int_t i=0; i<6; i++){ + fEnCalibration[i] = 0.; + } +} + +//________________________________________________________________ +AliZDCEnCalib::AliZDCEnCalib(const AliZDCEnCalib& calibda) : + TNamed(calibda) +{ + // Copy constructor + SetName(calibda.GetName()); + SetTitle(calibda.GetName()); + Reset(); + for(int i=0; i<6; i++){ + fEnCalibration[i] = calibda.GetEnCalib(i); + } +} + +//________________________________________________________________ +AliZDCEnCalib &AliZDCEnCalib::operator =(const AliZDCEnCalib& calibda) +{ +// assignment operator + SetName(calibda.GetName()); + SetTitle(calibda.GetName()); + Reset(); + for(int i=0; i<6; i++){ + fEnCalibration[i] = calibda.GetEnCalib(i); + } + + return *this; +} + +//________________________________________________________________ +AliZDCEnCalib::~AliZDCEnCalib() +{ +} + +//________________________________________________________________ +void AliZDCEnCalib::Reset() +{ + // Reset +} + + +//________________________________________________________________ +void AliZDCEnCalib::Print(Option_t *) const +{ + // Printing of calibration object + printf("\n\n ####### Energy calibration coefficients ####### \n"); + printf(" ZN1 = %.4f (E[TeV]/ADCch.) \n",fEnCalibration[0]); + printf(" ZP1 = %.4f (E[TeV]/ADCch.) \n",fEnCalibration[1]); + printf(" ZN2 = %.4f (E[TeV]/ADCch.) \n",fEnCalibration[2]); + printf(" ZP2 = %.4f (E[TeV]/ADCch.) \n",fEnCalibration[3]); + printf(" ZEM1 = %.2f (E[TeV]/ADCch.) \n",fEnCalibration[4]); + printf(" ZEM2 = %.2f (E[TeV]/ADCch.) \n",fEnCalibration[5]); + +} + +//________________________________________________________________ +void AliZDCEnCalib::SetEnCalib(Float_t* EnCalib) +{ + // Set energy calibration coefficients + if(EnCalib) for(int t=0; t<6; t++) fEnCalibration[t] = EnCalib[t]; + else for(int t=0; t<6; t++) fEnCalibration[t] = 0.; +} diff --git a/ZDC/AliZDCEnCalib.h b/ZDC/AliZDCEnCalib.h new file mode 100644 index 00000000000..f10363355e0 --- /dev/null +++ b/ZDC/AliZDCEnCalib.h @@ -0,0 +1,40 @@ +#ifndef ALIZDCENCALIB_H +#define ALIZDCENCALIB_H + +/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +//////////////////////////////////////////////// +// class for ZDC calibration -> CALIBCOEFF // +//////////////////////////////////////////////// + +#include "TNamed.h" +#include "AliCDBEntry.h" + +class AliZDC; + +class AliZDCEnCalib: public TNamed { + + public: + AliZDCEnCalib(); + AliZDCEnCalib(const char* name); + AliZDCEnCalib(const AliZDCEnCalib &calibda); + AliZDCEnCalib& operator= (const AliZDCEnCalib &calibda); + virtual ~AliZDCEnCalib(); + void Reset(); + virtual void Print(Option_t *) const; + // + Float_t GetEnCalib(Int_t channel) const {return fEnCalibration[channel];} + Float_t* GetEnCalib() const {return (float*)fEnCalibration;} + + void SetEnCalib(Int_t channel, Float_t val) {fEnCalibration[channel]=val;} + void SetEnCalib(Float_t* EnCalib); + + protected: + // --- E calibration + Float_t fEnCalibration[6]; // Coeff. for energy calibration + // + ClassDef(AliZDCEnCalib,2) // ZDC calibration calibration data +}; + +#endif diff --git a/ZDC/AliZDCPreprocessor.cxx b/ZDC/AliZDCPreprocessor.cxx index 403fc730647..ab77359dea1 100644 --- a/ZDC/AliZDCPreprocessor.cxx +++ b/ZDC/AliZDCPreprocessor.cxx @@ -17,13 +17,14 @@ #include "AliZDCChMap.h" #include "AliZDCPedestals.h" #include "AliZDCLaserCalib.h" -#include "AliZDCCalib.h" +#include "AliZDCEnCalib.h" +#include "AliZDCTowerCalib.h" ///////////////////////////////////////////////////////////////////// // // -// Class implementing ZDC pre-processor. // -// It takes data from DCS and passes it to the class AliZDCDataDCS // -// The class is then written to the CDB. // +// Class implementing Shuttle ZDC pre-processor. // +// It takes data from DCS and DAQ and writes calibration objects // +// in the OCDB and reference values/histos in the ReferenceData. // // // ///////////////////////////////////////////////////////////////////// @@ -64,15 +65,15 @@ void AliZDCPreprocessor::Initialize(Int_t run, UInt_t startTime, AliPreprocessor::Initialize(run, startTime, endTime); - Log(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s", run, - TTimeStamp(startTime).AsString(), - TTimeStamp(endTime).AsString())); + Log(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s", run, + TTimeStamp(startTime).AsString(), + TTimeStamp(endTime).AsString())); - fRun = run; - fStartTime = startTime; - fEndTime = endTime; + fRun = run; + fStartTime = startTime; + fEndTime = endTime; - fData = new AliZDCDataDCS(fRun, fStartTime, fEndTime); + fData = new AliZDCDataDCS(fRun, fStartTime, fEndTime); } //______________________________________________________________________________________________ @@ -84,7 +85,7 @@ UInt_t AliZDCPreprocessor::ProcessChMap(TString runType) AliError(Form("No sources run %d for run type %s!", fRun, runType.Data())); return 1; } - Log("\t List of sources "); daqSource->Print(); + Log("\t List of DAQ sources for mapping "); daqSource->Print(); // TIter iter(daqSource); TObjString* source = 0; @@ -112,7 +113,10 @@ UInt_t AliZDCPreprocessor::ProcessChMap(TString runType) // for(Int_t j=0; j<48; j++){ for(Int_t k=0; k<6; k++){ - fscanf(file,"%d",&readMap[j][k]); + int read = fscanf(file,"%d",&readMap[j][k]); + if(read == 0){ + printf("\t WARNING! Failing in reading datum [%d][%d]\n",j,k); + } } } fclose(file); @@ -130,7 +134,7 @@ UInt_t AliZDCPreprocessor::ProcessChMap(TString runType) AliCDBEntry *cdbEntry = GetFromOCDB("Calib","ChMap"); if(!cdbEntry){ - Log("\t AliZDCPreprocessor -> WARNING! No CDB entry for ch. mapping\n"); + Log(" No existing CDB entry for ADC mapping"); updateOCDB = kTRUE; } else{ @@ -147,7 +151,7 @@ UInt_t AliZDCPreprocessor::ProcessChMap(TString runType) } // if(updateOCDB==kTRUE){ - Log("\t AliZDCPreprocessor -> A new entry ZDC/Calib/ChMap will be created"); + Log(" A new entry ZDC/Calib/ChMap will be created"); // // --- Initializing mapping calibration object AliZDCChMap *mapCalib = new AliZDCChMap("ZDC"); @@ -168,7 +172,7 @@ UInt_t AliZDCPreprocessor::ProcessChMap(TString runType) res = Store("Calib","ChMap",mapCalib, &metaData, 0, 1); } else{ - Log("\t AliZDCPreprocessor -> ZDC/Calib/ChMap entry in OCDB is valid and won't be updated\n"); + Log(" ZDC/Calib/ChMap entry in OCDB is valid and won't be updated"); res = kTRUE; } @@ -180,58 +184,59 @@ UInt_t AliZDCPreprocessor::ProcessChMap(TString runType) //______________________________________________________________________________________________ UInt_t AliZDCPreprocessor::Process(TMap* dcsAliasMap) { - // *************** From DCS ****************** - // Fills data into a AliZDCDataDCS object - if(!dcsAliasMap) return 1; - printf("Processing data from DCS\n"); - - // The processing of the DCS input data is forwarded to AliZDCDataDCS - Float_t dcsValues[28]; // DCSAliases=28 - fData->SetCalibData(dcsValues); - fData->ProcessData(*dcsAliasMap); - // Store DCS data for reference - AliCDBMetaData metadata; - metadata.SetResponsible("Chiara Oppedisano"); - metadata.SetComment("DCS data for ZDC"); - Bool_t resDCSRef = kTRUE; - resDCSRef = StoreReferenceData("DCS","Data",fData,&metadata); - dcsAliasMap->Print(""); + // ********************************* From DCS ************************************ + // Fills data into a AliZDCDataDCS object + if(!dcsAliasMap) return 1; + Log(Form("Processing data from DCS")); + + // The processing of the DCS input data is forwarded to AliZDCDataDCS + Float_t dcsValues[28]; // DCSAliases=28 + fData->SetCalibData(dcsValues); + fData->ProcessData(*dcsAliasMap); + // Store DCS data for reference + AliCDBMetaData metadata; + metadata.SetResponsible("Chiara Oppedisano"); + metadata.SetComment("DCS data for ZDC"); + Bool_t resDCSRef = kTRUE; + resDCSRef = StoreReferenceData("DCS","Data",fData,&metadata); + //dcsAliasMap->Print(""); - // --- Writing ZDC table positions into alignment object - TClonesArray *array = new TClonesArray("AliAlignObjParams",10); - TClonesArray &alobj = *array; - AliAlignObjParams a; - Double_t dx=0., dz=0., dpsi=0., dtheta=0., dphi=0.; - // Vertical table position in mm from DCS - Double_t dyZN1 = (Double_t) (dcsValues[0]/10.); - Double_t dyZP1 = (Double_t) (dcsValues[1]/10.); - Double_t dyZN2 = (Double_t) (dcsValues[2]/10.); - Double_t dyZP2 = (Double_t) (dcsValues[3]/10.); - // - - const char *n1ZDC="ZDC/NeutronZDC_C"; - const char *p1ZDC="ZDC/ProtonZDC_C"; - const char *n2ZDC="ZDC/NeutronZDC_A"; - const char *p2ZDC="ZDC/ProtonZDC_A"; - // - UShort_t iIndex=0; - AliGeomManager::ELayerID iLayer = AliGeomManager::kInvalidLayer; - UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,iIndex); - // - new(alobj[0]) AliAlignObjParams(n1ZDC, volid, dx, dyZN1, dz, dpsi, dtheta, dphi, kTRUE); - new(alobj[1]) AliAlignObjParams(p1ZDC, volid, dx, dyZP1, dz, dpsi, dtheta, dphi, kTRUE); - new(alobj[2]) AliAlignObjParams(n2ZDC, volid, dx, dyZN2, dz, dpsi, dtheta, dphi, kTRUE); - new(alobj[3]) AliAlignObjParams(p2ZDC, volid, dx, dyZP2, dz, dpsi, dtheta, dphi, kTRUE); - - // save in CDB storage - AliCDBMetaData md; - md.SetResponsible("Chiara Oppedisano"); - md.SetComment("Alignment object for ZDC"); - Bool_t resultAl = kTRUE; - resultAl = Store("Align","Data", array, &md, 0, 0); + // --- Writing ZDC table positions into alignment object + TClonesArray *array = new TClonesArray("AliAlignObjParams",10); + TClonesArray &alobj = *array; + AliAlignObjParams a; + Double_t dx=0., dz=0., dpsi=0., dtheta=0., dphi=0.; + // Vertical table position in mm from DCS + Double_t dyZN1 = (Double_t) (dcsValues[0]/10.); + Double_t dyZP1 = (Double_t) (dcsValues[1]/10.); + Double_t dyZN2 = (Double_t) (dcsValues[2]/10.); + Double_t dyZP2 = (Double_t) (dcsValues[3]/10.); + // + const char *n1ZDC="ZDC/NeutronZDC_C"; + const char *p1ZDC="ZDC/ProtonZDC_C"; + const char *n2ZDC="ZDC/NeutronZDC_A"; + const char *p2ZDC="ZDC/ProtonZDC_A"; + // + UShort_t iIndex=0; + AliGeomManager::ELayerID iLayer = AliGeomManager::kInvalidLayer; + UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,iIndex); + // + new(alobj[0]) AliAlignObjParams(n1ZDC, volid, dx, dyZN1, dz, dpsi, dtheta, dphi, kTRUE); + new(alobj[1]) AliAlignObjParams(p1ZDC, volid, dx, dyZP1, dz, dpsi, dtheta, dphi, kTRUE); + new(alobj[2]) AliAlignObjParams(n2ZDC, volid, dx, dyZN2, dz, dpsi, dtheta, dphi, kTRUE); + new(alobj[3]) AliAlignObjParams(p2ZDC, volid, dx, dyZP2, dz, dpsi, dtheta, dphi, kTRUE); + + // save in CDB storage + AliCDBMetaData md; + md.SetResponsible("Chiara Oppedisano"); + md.SetComment("Alignment object for ZDC"); + Bool_t resultAl = kTRUE; + resultAl = Store("Align","Data", array, &md, 0, 0); - // *************** From DAQ ****************** - Bool_t resChMap=kTRUE, resPedCal=kTRUE, resLaserCal=kTRUE, resECal=kTRUE; + // ********************************* From DAQ ************************************ + Bool_t resChMap=kTRUE, resPedCal=kTRUE, resPedHist=kTRUE; + Bool_t resLaserCal=kTRUE, resLaserHist=kTRUE; + Bool_t resEnCal=kTRUE, resTowCal=kTRUE; // const char* beamType = GetRunParameter("beamType"); TString runType = GetRunType(); @@ -239,34 +244,86 @@ UInt_t AliZDCPreprocessor::Process(TMap* dcsAliasMap) printf("\t AliZDCPreprocessor -> runType %s\n\n",runType.Data()); // -------------- p-p data ------------- + // NO ENERGY CALIBRATION -> coefficients set to 1. + // Temp -> also inter-calibration coefficients are set to 1. if(strcmp(beamType,"p-p")==0){ - + + // *********** Energy calibration // --- Cheking if there is already the entry in the OCDB - AliCDBEntry *cdbEntry = GetFromOCDB("Calib", "EMDCalib"); - if(!cdbEntry){ - printf("\t AliZDCPreprocessor -> ZDC/Calib/EMDCalib entry will be created\n"); + AliCDBEntry *cdbEnEntry = GetFromOCDB("Calib", "EnCalib"); + if(!cdbEnEntry){ + Log(Form(" ZDC/Calib/EnCalib entry will be created")); // --- Initializing calibration object - AliZDCCalib *eCalib = new AliZDCCalib("ZDC"); + // + AliCDBMetaData metaData; + metaData.SetBeamPeriod(0); + metaData.SetResponsible("Chiara Oppedisano"); // + AliZDCEnCalib *eCalib = new AliZDCEnCalib("ZDC"); for(Int_t j=0; j<6; j++) eCalib->SetEnCalib(j,1.); + metaData.SetComment("AliZDCEnCalib object"); + //eCalib->Print(""); + resEnCal = Store("Calib", "EnCalib", eCalib, &metaData, 0, 1); + } + else{ + // if entry exists it is still valid (=1 for all runs!) + Log(Form(" Valid ZDC/Calib/EnCalib object already existing in OCDB!!!")); + resEnCal = kTRUE; + } + // + // *********** Tower inter-calibration + // --- Cheking if there is already the entry in the OCDB + AliCDBEntry *cdbTowEntry = GetFromOCDB("Calib", "TowCalib"); + if(!cdbTowEntry){ + AliZDCTowerCalib *towCalib = new AliZDCTowerCalib("ZDC"); for(Int_t j=0; j<5; j++){ - eCalib->SetZN1EqualCoeff(j, 1.); - eCalib->SetZP1EqualCoeff(j, 1.); - eCalib->SetZN2EqualCoeff(j, 1.); - eCalib->SetZP2EqualCoeff(j, 1.); + towCalib->SetZN1EqualCoeff(j, 1.); + towCalib->SetZP1EqualCoeff(j, 1.); + towCalib->SetZN2EqualCoeff(j, 1.); + towCalib->SetZP2EqualCoeff(j, 1.); } - //eCalib->Print(""); + //towCalib->Print(""); + // + AliCDBMetaData metaData; + metaData.SetBeamPeriod(0); + metaData.SetResponsible("Chiara Oppedisano"); + metaData.SetComment("AliZDCTowerCalib object"); + // + resTowCal = Store("Calib", "TowCalib", towCalib, &metaData, 0, 1); + } + else{ + // if entry exists it is still valid (=1 for all runs!) + Log(Form(" Valid ZDC/Calib/TowCalib object already existing in OCDB!!!")); + resTowCal = kTRUE; + } + + // *********** Tower relative calibration + // --- Cheking if there is already the entry in the OCDB + AliCDBEntry *cdbSEntry = GetFromOCDB("Calib", "TowCalib"); + if(!cdbSEntry){ + Log(Form(" ZDC/Calib/TOwCalib entry will be created")); + // --- Initializing calibration object + AliZDCTowerCalib *towCalib = new AliZDCTowerCalib("ZDC"); + // + for(Int_t j=0; j<5; j++){ + towCalib->SetZN1EqualCoeff(j, 1.); + towCalib->SetZP1EqualCoeff(j, 1.); + towCalib->SetZN2EqualCoeff(j, 1.); + towCalib->SetZP2EqualCoeff(j, 1.); + } + //towCalib->Print(""); // AliCDBMetaData metaData; metaData.SetBeamPeriod(0); metaData.SetResponsible("Chiara Oppedisano"); - metaData.SetComment("AliZDCCalib object"); + metaData.SetComment("AliZDCTowerCalib object"); // - resECal = Store("Calib","EMDCalib",eCalib, &metaData, 0, 1); + resTowCal = Store("Calib", "TowCalib", towCalib, &metaData, 0, 1); } - else{ - printf("\t AliZDCPreprocessor -> ZDC/Calib/EMDCalib object already existing in OCDB!!!\n"); - resECal = kTRUE; + else{ + // if entry exists it is still valid (=1 for all runs!) + Log(Form(" Valid ZDC/Calib/TowCalib object already existing in OCDB!!!")); + resEnCal = kTRUE; } } @@ -280,206 +337,301 @@ UInt_t AliZDCPreprocessor::Process(TMap* dcsAliasMap) // ***************************************************** // if(runType=="STANDALONE_PEDESTAL"){ - TList* daqSources = GetFileSources(kDAQ, "PEDESTALS"); + TList* daqSources = GetFileSources(kDAQ, "PEDESTALDATA"); if(!daqSources){ Log(Form("No source for STANDALONE_PEDESTAL run %d !", fRun)); return 1; } - Log("\t List of sources for STANDALONE_PEDESTAL"); + Log("\t List of DAQ sources for STANDALONE_PEDESTAL run"); daqSources->Print(); // TIter iter(daqSources); TObjString* source = 0; Int_t i=0; while((source = dynamic_cast (iter.Next()))){ - Log(Form("\n\t Getting file #%d\n",++i)); - TString stringPedFileName = GetFile(kDAQ, "PEDESTALS", source->GetName()); - if(stringPedFileName.Length() <= 0){ - Log(Form("No PEDESTAL file from source %s!", source->GetName())); - return 1; - } + Log(Form("\n\t Getting file #%d\n",++i)); + TString stringPedFileName = GetFile(kDAQ, "PEDESTALDATA", source->GetName()); + if(stringPedFileName.Length() <= 0){ + Log(Form("No PEDESTAL file from source %s!", source->GetName())); + return 1; + } + // calibration data // --- Initializing pedestal calibration object AliZDCPedestals *pedCalib = new AliZDCPedestals("ZDC"); // --- Reading file with pedestal calibration data const char* pedFileName = stringPedFileName.Data(); // no. ADCch = (22 signal ch. + 2 reference PMs) * 2 gain chain = 48 const Int_t knZDCch = 48; - if(pedFileName){ - FILE *file; - if((file = fopen(pedFileName,"r")) == NULL){ - printf("Cannot open file %s \n",pedFileName); - return 1; - } - Log(Form("File %s connected to process pedestal data", pedFileName)); - Float_t pedVal[(2*knZDCch)][2]; - for(Int_t k=0; k<(2*knZDCch); k++){ - for(Int_t j=0; j<2; j++){ - fscanf(file,"%f",&pedVal[k][j]); - //if(j==1) printf("pedVal[%d] -> %f, %f \n",k,pedVal[k][0],pedVal[k][1]); - } - if(kSetMeanPed(k,pedVal[k][0]); - pedCalib->SetMeanPedWidth(i,pedVal[k][1]); - } - else if(k>=knZDCch && k<(2*knZDCch)){ - pedCalib->SetOOTPed(k-knZDCch,pedVal[k][0]); - pedCalib->SetOOTPedWidth(k-knZDCch,pedVal[k][1]); - } - else if(k>=(2*knZDCch) && k<(3*knZDCch)){ - pedCalib->SetPedCorrCoeff(k-(2*knZDCch),pedVal[k][0],pedVal[k][1]); - } - } - fclose(file); + + FILE *file; + if((file = fopen(pedFileName,"r")) == NULL){ + printf("Cannot open file %s \n",pedFileName); + return 1; } - else{ - Log(Form("File %s not found", pedFileName)); - return 1; + Log(Form("File %s connected to process pedestal data", pedFileName)); + Float_t pedVal[(2*knZDCch)][2]; + for(Int_t k=0; k<(2*knZDCch); k++){ + for(Int_t j=0; j<2; j++){ + fscanf(file,"%f",&pedVal[k][j]); + //if(j==1) printf("pedVal[%d] -> %f, %f \n",k,pedVal[k][0],pedVal[k][1]); + } + if(kSetMeanPed(k,pedVal[k][0]); + pedCalib->SetMeanPedWidth(i,pedVal[k][1]); + } + else if(k>=knZDCch && k<(2*knZDCch)){ + pedCalib->SetOOTPed(k-knZDCch,pedVal[k][0]); + pedCalib->SetOOTPedWidth(k-knZDCch,pedVal[k][1]); + } + else if(k>=(2*knZDCch) && k<(3*knZDCch)){ + pedCalib->SetPedCorrCoeff(k-(2*knZDCch),pedVal[k][0],pedVal[k][1]); + } } + fclose(file); + //pedCalib->Print(""); + // + AliCDBMetaData metaData; + metaData.SetBeamPeriod(0); + metaData.SetResponsible("Chiara Oppedisano"); + metaData.SetComment("Filling AliZDCPedestals object"); // - //pedCalib->Print(""); - // - AliCDBMetaData metaData; - metaData.SetBeamPeriod(0); - metaData.SetResponsible("Chiara Oppedisano"); - metaData.SetComment("Filling AliZDCPedestals object"); - // - resPedCal = Store("Calib","Pedestals",pedCalib, &metaData, 0, 1); + resPedCal = Store("Calib","Pedestals",pedCalib, &metaData, 0, 1); } delete daqSources; daqSources = 0; + // + TList* daqSourceH = GetFileSources(kDAQ, "PEDHISTOS"); + if(!daqSourceH){ + Log(Form("No source for STANDALONE_PEDESTAL run %d !", fRun)); + return 1; + } + Log("\t List of DAQ sources for STANDALONE_PEDESTAL run"); + daqSourceH->Print(); + // + TIter iterH(daqSourceH); + TObjString* sourceH = 0; + Int_t iH=0; + while((sourceH = dynamic_cast (iterH.Next()))){ + Log(Form("\n\t Getting file #%d\n",++iH)); + TString stringPedFileName = GetFile(kDAQ, "PEDHISTOS", sourceH->GetName()); + if(stringPedFileName.Length() <= 0){ + Log(Form("No PEDESTAL file from source %s!", sourceH->GetName())); + return 1; + } + TFile *histoFile = TFile::Open(stringPedFileName.Data()); + // + AliCDBMetaData metadata; + metadata.SetResponsible("Chiara Oppedisano"); + metadata.SetComment("Pedestal histos"); + resPedHist = StoreReferenceData("Histos","Pedestal", histoFile, &metadata); + } + delete daqSourceH; daqSourceH = 0; } // ***************************************************** // [b] STANDALONE_LASER EVENTS -> Signal stability // ***************************************************** else if(runType=="STANDALONE_LASER"){ - TList* daqSources = GetFileSources(kDAQ, "LASER"); + TList* daqSources = GetFileSources(kDAQ, "LASERDATA"); if(!daqSources){ AliError(Form("No sources for STANDALONE_LASER run %d !", fRun)); return 1; } - Log("\t List of sources for STANDALONE_LASER"); + Log("\t List of DAQ sources for STANDALONE_LASER run"); daqSources->Print(); // TIter iter2(daqSources); TObjString* source = 0; Int_t i=0; while((source = dynamic_cast (iter2.Next()))){ - Log(Form("\n\t Getting file #%d\n",++i)); - TString stringLASERFileName = GetFile(kDAQ, "LASER", source->GetName()); - if(stringLASERFileName.Length() <= 0){ - Log(Form("No LASER file from source %s!", source->GetName())); - return 1; - } - // --- Initializing pedestal calibration object - AliZDCLaserCalib *lCalib = new AliZDCLaserCalib("ZDC"); - // --- Reading file with pedestal calibration data - const char* laserFileName = stringLASERFileName.Data(); - if(laserFileName){ - FILE *file; - if((file = fopen(laserFileName,"r")) == NULL){ - printf("Cannot open file %s \n",laserFileName); - return 1; - } - Log(Form("File %s connected to process data from LASER events", laserFileName)); - // - Float_t ivalRead[22][4]; - for(Int_t j=0; j<22; j++){ - for(Int_t k=0; k<4; k++){ - fscanf(file,"%f",&ivalRead[j][k]); - //printf(" %d %1.0f ",k, ivalRead[j][k]); - } - lCalib->SetDetector(j, (Int_t) ivalRead[j][0]); - lCalib->SetSector(j, (Int_t) ivalRead[j][1]); - lCalib->SetfPMValue(j, ivalRead[j][2]); - lCalib->SetfPMWidth(j, ivalRead[j][3]); - } - fclose(file); - } - else{ - Log(Form("File %s not found", laserFileName)); + Log(Form("\n\t Getting file #%d\n",++i)); + TString stringLASERFileName = GetFile(kDAQ, "LASERDATA", source->GetName()); + if(stringLASERFileName.Length() <= 0){ + Log(Form("No LASER file from source %s!", source->GetName())); + return 1; + } + // --- Initializing pedestal calibration object + AliZDCLaserCalib *lCalib = new AliZDCLaserCalib("ZDC"); + // --- Reading file with pedestal calibration data + const char* laserFileName = stringLASERFileName.Data(); + if(laserFileName){ + FILE *file; + if((file = fopen(laserFileName,"r")) == NULL){ + printf("Cannot open file %s \n",laserFileName); return 1; } - //lCalib->Print(""); - // - AliCDBMetaData metaData; - metaData.SetBeamPeriod(0); - metaData.SetResponsible("Chiara Oppedisano"); - metaData.SetComment("Filling AliZDCLaserCalib object"); + Log(Form("File %s connected to process data from LASER events", laserFileName)); // - resLaserCal = Store("Calib","LaserCalib",lCalib, &metaData, 0, 1); + Float_t ivalRead[22][4]; + for(Int_t j=0; j<22; j++){ + for(Int_t k=0; k<4; k++){ + fscanf(file,"%f",&ivalRead[j][k]); + //printf(" %d %1.0f ",k, ivalRead[j][k]); + } + lCalib->SetDetector(j, (Int_t) ivalRead[j][0]); + lCalib->SetSector(j, (Int_t) ivalRead[j][1]); + lCalib->SetfPMValue(j, ivalRead[j][2]); + lCalib->SetfPMWidth(j, ivalRead[j][3]); + } + fclose(file); + } + else{ + Log(Form("File %s not found", laserFileName)); + return 1; + } + //lCalib->Print(""); + // + AliCDBMetaData metaData; + metaData.SetBeamPeriod(0); + metaData.SetResponsible("Chiara Oppedisano"); + metaData.SetComment("Filling AliZDCLaserCalib object"); + // + resLaserCal = Store("Calib","LaserCalib",lCalib, &metaData, 0, 1); } - + delete daqSources; daqSources = 0; + // + TList* daqSourceH = GetFileSources(kDAQ, "LASERHISTOS"); + if(!daqSourceH){ + AliError(Form("No sources for STANDALONE_LASER run %d !", fRun)); + return 1; + } + Log("\t List of DAQ sources for STANDALONE_LASER run"); + daqSourceH->Print(); + // + TIter iter2H(daqSourceH); + TObjString* sourceH = 0; + Int_t iH=0; + while((sourceH = dynamic_cast (iter2H.Next()))){ + Log(Form("\n\t Getting file #%d\n",++iH)); + TString stringLASERFileName = GetFile(kDAQ, "LASERHISTOS", sourceH->GetName()); + if(stringLASERFileName.Length() <= 0){ + Log(Form("No LASER file from source %s!", sourceH->GetName())); + return 1; + } + TFile *histoFile = TFile::Open(stringLASERFileName.Data()); + // + AliCDBMetaData metadata; + metadata.SetResponsible("Chiara Oppedisano"); + metadata.SetComment("Laser run histos"); + resPedHist = StoreReferenceData("Histos", "Laser", histoFile, &metadata); + } + delete daqSourceH; daqSourceH = 0; } // ***************************************************** // [c] EMD EVENTS -> Energy calibration and equalization // ***************************************************** else if(runType=="CALIBRATION_EMD" && strcmp(beamType,"Pb-Pb")==0){ - TList* daqSources = GetFileSources(kDAQ, "EMDCALIB"); + TList* daqSources = GetFileSources(kDAQ, "ENERGYCALIB"); if(!daqSources){ AliError(Form("No sources for CALIBRATION_EMD run %d !", fRun)); return 1; } - Log("\t List of sources for CALIBRATION_EMD"); + Log("\t List of DAQ sources for CALIBRATION_EMD run"); daqSources->Print(); // TIter iter2(daqSources); TObjString* source = 0; Int_t i=0; while((source = dynamic_cast (iter2.Next()))){ - Log(Form("\n\t Getting file #%d\n",++i)); - TString stringEMDFileName = GetFile(kDAQ, "EMDCALIB", source->GetName()); - if(stringEMDFileName.Length() <= 0){ - Log(Form("No EMDCALIB file from source %s!", source->GetName())); - return 1; + Log(Form("\n\t Getting file #%d\n",++i)); + TString stringEMDFileName = GetFile(kDAQ, "ENERGYCALIB", source->GetName()); + if(stringEMDFileName.Length() <= 0){ + Log(Form("No file from source %s!", source->GetName())); + return 1; + } + // --- Initializing energy calibration object + AliZDCEnCalib *eCalib = new AliZDCEnCalib("ZDC"); + // --- Reading file with pedestal calibration data + const char* emdFileName = stringEMDFileName.Data(); + if(emdFileName){ + FILE *file; + if((file = fopen(emdFileName,"r")) == NULL){ + printf("Cannot open file %s \n",emdFileName); + return 1; } - // --- Initializing pedestal calibration object - AliZDCCalib *eCalib = new AliZDCCalib("ZDC"); - // --- Reading file with pedestal calibration data - const char* emdFileName = stringEMDFileName.Data(); - if(emdFileName){ - FILE *file; - if((file = fopen(emdFileName,"r")) == NULL){ - printf("Cannot open file %s \n",emdFileName); - return 1; - } - Log(Form("File %s connected to process data from EM dissociation events", emdFileName)); - // - Float_t fitValEMD[6]; Float_t equalCoeff[4][5]; - Float_t calibVal[4]; - for(Int_t j=0; j<10; j++){ - if(j<6){ - fscanf(file,"%f",&fitValEMD[j]); - if(j<4){ - calibVal[j] = 2760./fitValEMD[j]; - eCalib->SetEnCalib(j,calibVal[j]); - } - else eCalib->SetEnCalib(j,fitValEMD[j]); - } - else{ - for(Int_t k=0; k<5; k++){ - fscanf(file,"%f",&equalCoeff[j][k]); - if(j==6) eCalib->SetZN1EqualCoeff(k, equalCoeff[j][k]); - else if(j==7) eCalib->SetZP1EqualCoeff(k, equalCoeff[j][k]); - else if(j==8) eCalib->SetZN2EqualCoeff(k, equalCoeff[j][k]); - else if(j==9) eCalib->SetZP2EqualCoeff(k, equalCoeff[j][k]); - } - } - } - fclose(file); + Log(Form("File %s connected to process data from EM dissociation events", emdFileName)); + // + Float_t fitValEMD[6]; + for(Int_t j=0; j<6; j++){ + if(j<6){ + fscanf(file,"%f",&fitValEMD[j]); + eCalib->SetEnCalib(j,fitValEMD[j]); + } } - else{ - Log(Form("File %s not found", emdFileName)); - return 1; + // + fclose(file); + } + else{ + Log(Form("File %s not found", emdFileName)); + return 1; + } + //eCalib->Print(""); + // + AliCDBMetaData metaData; + metaData.SetBeamPeriod(0); + metaData.SetResponsible("Chiara Oppedisano"); + metaData.SetComment("Filling AliZDCEnCalib object"); + // + resEnCal = Store("Calib","EnCalib",eCalib, &metaData, 0, 1); + } + delete daqSources; daqSources = 0; + // + TList* daqSourcesH = GetFileSources(kDAQ, "TOWERCALIB"); + if(!daqSourcesH){ + AliError(Form("No sources for CALIBRATION_EMD run %d !", fRun)); + return 1; + } + Log("\t List of DAQ sources for CALIBRATION_EMD run"); + daqSourcesH->Print(); + // + TIter iter2H(daqSourcesH); + TObjString* sourceH = 0; + Int_t iH=0; + while((sourceH = dynamic_cast (iter2H.Next()))){ + Log(Form("\n\t Getting file #%d\n",++iH)); + TString stringEMDFileName = GetFile(kDAQ, "TOWERCALIB", sourceH->GetName()); + if(stringEMDFileName.Length() <= 0){ + Log(Form("No file from source %s!", sourceH->GetName())); + return 1; + } + // --- Initializing energy calibration object + AliZDCTowerCalib *towCalib = new AliZDCTowerCalib("ZDC"); + // --- Reading file with pedestal calibration data + const char* emdFileName = stringEMDFileName.Data(); + if(emdFileName){ + FILE *file; + if((file = fopen(emdFileName,"r")) == NULL){ + printf("Cannot open file %s \n",emdFileName); + return 1; + } + Log(Form("File %s connected to process data from EM dissociation events", emdFileName)); + // + Float_t equalCoeff[4][5]; + for(Int_t j=0; j<4; j++){ + for(Int_t k=0; k<5; k++){ + fscanf(file,"%f",&equalCoeff[j][k]); + if(j==0) towCalib->SetZN1EqualCoeff(k, equalCoeff[j][k]); + else if(j==1) towCalib->SetZP1EqualCoeff(k, equalCoeff[j][k]); + else if(j==2) towCalib->SetZN2EqualCoeff(k, equalCoeff[j][k]); + else if(j==3) towCalib->SetZP2EqualCoeff(k, equalCoeff[j][k]); + } } - //eCalib->Print(""); - // - AliCDBMetaData metaData; - metaData.SetBeamPeriod(0); - metaData.SetResponsible("Chiara Oppedisano"); - metaData.SetComment("Filling AliZDCCalib object"); // - resECal = Store("Calib","EMDCalib",eCalib, &metaData, 0, 1); + fclose(file); + } + else{ + Log(Form("File %s not found", emdFileName)); + return 1; + } + //towCalib->Print(""); + // + AliCDBMetaData metaData; + metaData.SetBeamPeriod(0); + metaData.SetResponsible("Chiara Oppedisano"); + metaData.SetComment("Filling AliZDCTowerCalib object"); + // + resTowCal = Store("Calib","TowCalib",towCalib, &metaData, 0, 1); } - } + delete daqSources; daqSources = 0; + }//Pb-Pb if // note that the parameters are returned as character strings! @@ -488,14 +640,18 @@ UInt_t AliZDCPreprocessor::Process(TMap* dcsAliasMap) else Log(Form("Number of events not put in logbook!")); UInt_t result = 0; - if(resDCSRef==kFALSE || resultAl==kFALSE || resPedCal==kFALSE || - resLaserCal==kFALSE || resECal==kFALSE || resChMap==kFALSE){ - if(resDCSRef == kFALSE) result = 1; - else if(resultAl == kFALSE) result = 2; - else if(resChMap == kFALSE) result = 3; - else if(resPedCal == kFALSE) result = 4; - else if(resLaserCal == kFALSE) result = 5; - else if(resECal == kFALSE) result = 6; + if(resDCSRef==kFALSE || resultAl==kFALSE || resPedCal==kFALSE || resPedHist==kFALSE || + resLaserCal==kFALSE || resLaserHist==kFALSE || resEnCal==kFALSE || resTowCal || + resChMap==kFALSE){ + if(resDCSRef == kFALSE) result = 1; + else if(resultAl == kFALSE) result = 2; + else if(resChMap == kFALSE) result = 3; + else if(resPedCal == kFALSE) result = 4; + else if(resPedHist == kFALSE) result = 5; + else if(resLaserCal == kFALSE) result = 6; + else if(resLaserHist == kFALSE) result = 7; + else if(resEnCal == kFALSE) result = 8; + else if(resTowCal == kFALSE) result = 9; } return result; diff --git a/ZDC/AliZDCReco.cxx b/ZDC/AliZDCReco.cxx index 939cf59b4b5..cc0c9fb4dbc 100644 --- a/ZDC/AliZDCReco.cxx +++ b/ZDC/AliZDCReco.cxx @@ -33,19 +33,19 @@ AliZDCReco::AliZDCReco() : TObject(), // - fNDetSpecNLeft(0), - fNDetSpecPLeft(0), - fNDetSpecNRight(0), - fNDetSpecPRight(0), - fNTrueSpecNLeft(0), - fNTrueSpecPLeft(0), - fNTrueSpecLeft(0), - fNTrueSpecNRight(0), - fNTrueSpecPRight(0), - fNTrueSpecRight(0), - fNPartLeft(0), - fNPartRight(0), - fImpPar(0) + fNDetSpecNSideA(0), + fNDetSpecPSideA(0), + fNDetSpecNSideC(0), + fNDetSpecPSideC(0), + fNTrueSpectators(0), + fNTrueSpecSideA(0), + fNTrueSpecSideC(0), + fNParticipants(0), + fNPartSideA(0), + fNPartSideC(0), + fImpParameter(0), + fImpParSideA(0), + fImpParSideC(0) { // @@ -63,32 +63,31 @@ AliZDCReco::AliZDCReco() : //_____________________________________________________________________________ -AliZDCReco::AliZDCReco(Float_t* ezn1, Float_t* ezp1, Float_t* ezn2, Float_t* ezp2, - Float_t* ezn1tow, Float_t* ezp1tow, - Float_t* ezn2tow, Float_t* ezp2tow, - Float_t* ezem1, Float_t* ezem2, - Float_t* ref1, Float_t* ref2, - // - Int_t detspnLeft, Int_t detsppLeft, Int_t detspnRight, Int_t detsppRight, - Int_t trspnLeft, Int_t trsppLeft, Int_t trspLeft, - Int_t trspnRight, Int_t trsppRight, Int_t trspRight, - Int_t partLeft, Int_t partRight, Float_t b) : +AliZDCReco::AliZDCReco( + Float_t* ezn1, Float_t* ezp1, Float_t* ezn2, Float_t* ezp2, + Float_t* ezn1tow, Float_t* ezp1tow, Float_t* ezn2tow, Float_t* ezp2tow, + Float_t* ezem1, Float_t* ezem2, Float_t* ref1, Float_t* ref2, + // + Int_t detspnSideA, Int_t detsppSideA, Int_t detspnSideC, Int_t detsppSideC, + Int_t trsp, Int_t trspSideA,Int_t trspSideC, + Int_t npart, Int_t npartSideA, Int_t npartSideC, + Float_t b, Float_t bSideA, Float_t bSideC) : TObject(), // - fNDetSpecNLeft(detspnLeft), - fNDetSpecPLeft(detsppLeft), - fNDetSpecNRight(detspnRight), - fNDetSpecPRight(detsppRight), - fNTrueSpecNLeft(trspnLeft), - fNTrueSpecPLeft(trsppLeft), - fNTrueSpecLeft(trspLeft), - fNTrueSpecNRight(trspnRight), - fNTrueSpecPRight(trsppRight), - fNTrueSpecRight(trspRight), - fNPartLeft(partLeft), - fNPartRight(partRight), - fImpPar(b) + fNDetSpecNSideA(detspnSideA), + fNDetSpecPSideA(detsppSideA), + fNDetSpecNSideC(detspnSideC), + fNDetSpecPSideC(detsppSideC), + fNTrueSpectators(trsp), + fNTrueSpecSideA(trspSideA), + fNTrueSpecSideC(trspSideC), + fNParticipants(npart), + fNPartSideA(npartSideA), + fNPartSideC(npartSideC), + fImpParameter(b), + fImpParSideA(bSideA), + fImpParSideC(bSideC) { // @@ -116,19 +115,19 @@ AliZDCReco::AliZDCReco(Float_t* ezn1, Float_t* ezp1, Float_t* ezn2, Float_t* ezp //______________________________________________________________________________ AliZDCReco::AliZDCReco(const AliZDCReco &oldreco) : TObject(), -fNDetSpecNLeft(oldreco.GetNDetSpecNLeft()), -fNDetSpecPLeft(oldreco.GetNDetSpecPLeft()), -fNDetSpecNRight(oldreco.GetNDetSpecNRight()), -fNDetSpecPRight(oldreco.GetNDetSpecPRight()), -fNTrueSpecNLeft(oldreco.GetNTrueSpecNLeft()), -fNTrueSpecPLeft(oldreco.GetNTrueSpecPLeft()), -fNTrueSpecLeft(oldreco.GetNTrueSpecLeft()), -fNTrueSpecNRight(oldreco.GetNTrueSpecNRight()), -fNTrueSpecPRight(oldreco.GetNTrueSpecPRight()), -fNTrueSpecRight(oldreco.GetNTrueSpecRight()), -fNPartLeft(oldreco.GetNPartLeft()), -fNPartRight(oldreco.GetNPartRight()), -fImpPar(oldreco.GetImpPar()) +fNDetSpecNSideA(oldreco.GetNDetSpecNSideA()), +fNDetSpecPSideA(oldreco.GetNDetSpecPSideA()), +fNDetSpecNSideC(oldreco.GetNDetSpecNSideC()), +fNDetSpecPSideC(oldreco.GetNDetSpecPSideC()), +fNTrueSpectators(oldreco.GetNTrueSpectators()), +fNTrueSpecSideA(oldreco.GetNTrueSpecSideA()), +fNTrueSpecSideC(oldreco.GetNTrueSpecSideC()), +fNParticipants(oldreco.GetNParticipants()), +fNPartSideA(oldreco.GetNPartSideA()), +fNPartSideC(oldreco.GetNPartSideC()), +fImpParameter(oldreco.GetImpParameter()), +fImpParSideA(oldreco.GetImpParSideA()), +fImpParSideC(oldreco.GetImpParSideC()) { // Copy constructor @@ -167,16 +166,21 @@ void AliZDCReco::Print(Option_t *) const { // // Printing Reconstruction Parameters // - printf(" \t --- Reconstruction -> EZN1 = %f TeV, EZP1 = %f TeV, EZEM1 = %f GeV , EZEM2 = %f GeV \n " - "EZN2 = %f TeV, EZP2 = %f TeV \n" - " \t NDetSpecNLeft = %d, NDetSpecPLeft = %d, NspecnLeft = %d," - " NspecpLeft = %d, NpartLeft = %d" - " \t NDetSpecNRight = %d, NDetSpecPRight = %d, NspecnRight = %d," - " NspecpRight = %d, NpartRight = %d" - " \t b = %f fm\n ", - fZN1Energy[0]/1000.,fZP1Energy[0]/1000.,fZEM1signal[0]/1000.,fZEM2signal[0]/1000., + printf(" ****************** AliZDCReco object ******************\n" + " --------------- side A ---------------\n" + " E_{ZN} = %f TeV, E_{ZP} = %f TeV, " + " E_{ZEM1} = %f TeV, E_{ZEM2} = %f TeV\n " + " N_{spec n}^{DET} = %d, N_{spec p}^{DET} = %d," + " N_{part} = %d, b = %1.4f fm\n" + " --------------- side C ---------------\n" + " E_{ZN} = %f TeV, E_{ZP} = %f TeV\n " + " N_{spec n}^{DET} = %d, N_{spec p}^{DET} = %d," + " N_{part} = %d, b = %1.4f fm\n" + " *******************************************************\n", fZN2Energy[0]/1000., fZP2Energy[0]/1000., - fNDetSpecNLeft,fNDetSpecPLeft,fNTrueSpecNLeft,fNTrueSpecPLeft,fNPartLeft, - fNDetSpecNRight,fNDetSpecPRight,fNTrueSpecNRight,fNTrueSpecPRight,fNPartRight, - fImpPar); + fZEM1signal[0]/1000.,fZEM2signal[0]/1000., + fNDetSpecNSideA,fNDetSpecPSideA, fNPartSideA,fImpParSideA, + fZN1Energy[0]/1000.,fZP1Energy[0]/1000., + fNDetSpecNSideC,fNDetSpecPSideC,fNPartSideC,fImpParSideC); + } diff --git a/ZDC/AliZDCReco.h b/ZDC/AliZDCReco.h index f911823dd8c..bb4242e2ca6 100644 --- a/ZDC/AliZDCReco.h +++ b/ZDC/AliZDCReco.h @@ -17,10 +17,11 @@ public: Float_t* ezn1tow, Float_t* ezp1tow, Float_t* ezn2tow, Float_t* ezp2tow, Float_t* ezem1, Float_t* ezem2, Float_t* ref1, Float_t* ref2, // - Int_t detspnLeft, Int_t detsppLeft, Int_t detspnRight, Int_t detsppRight, - Int_t trspnLeft, Int_t trsppLeft, Int_t trspLeft, - Int_t trspnRight, Int_t trsppRight, Int_t trspRight, - Int_t partLeft, Int_t partRight, Float_t b); + Int_t detspnSideA, Int_t detsppSideA, + Int_t detspnSideC, Int_t detsppSideC, + Int_t trsp, Int_t trspSideA, Int_t trspSideC, + Int_t npart, Int_t npartSideA, Int_t npartSideC, + Float_t b, Float_t bSideA, Float_t bSideC); AliZDCReco(const AliZDCReco &oldreco); virtual ~AliZDCReco() {} @@ -56,19 +57,19 @@ public: virtual Float_t GetPMRef2HRsignal() const {return fZEM2signal[0];} virtual Float_t GetPMRef2LRsignal() const {return fZEM2signal[1];} // - virtual Int_t GetNDetSpecNLeft() const {return fNDetSpecNLeft;} - virtual Int_t GetNDetSpecPLeft() const {return fNDetSpecPLeft;} - virtual Int_t GetNDetSpecNRight() const {return fNDetSpecNRight;} - virtual Int_t GetNDetSpecPRight() const {return fNDetSpecPRight;} - virtual Int_t GetNTrueSpecNLeft() const {return fNTrueSpecNLeft;} - virtual Int_t GetNTrueSpecPLeft() const {return fNTrueSpecPLeft;} - virtual Int_t GetNTrueSpecLeft() const {return fNTrueSpecLeft;} - virtual Int_t GetNTrueSpecNRight() const {return fNTrueSpecNRight;} - virtual Int_t GetNTrueSpecPRight() const {return fNTrueSpecPRight;} - virtual Int_t GetNTrueSpecRight() const {return fNTrueSpecRight;} - virtual Int_t GetNPartLeft() const {return fNPartLeft;} - virtual Int_t GetNPartRight() const {return fNPartRight;} - virtual Float_t GetImpPar() const {return fImpPar;} + virtual Int_t GetNDetSpecNSideA() const {return fNDetSpecNSideA;} + virtual Int_t GetNDetSpecPSideA() const {return fNDetSpecPSideA;} + virtual Int_t GetNDetSpecNSideC() const {return fNDetSpecNSideC;} + virtual Int_t GetNDetSpecPSideC() const {return fNDetSpecPSideC;} + virtual Int_t GetNTrueSpectators() const {return fNTrueSpectators;} + virtual Int_t GetNTrueSpecSideA() const {return fNTrueSpecSideA;} + virtual Int_t GetNTrueSpecSideC() const {return fNTrueSpecSideC;} + virtual Int_t GetNParticipants() const {return fNParticipants;} + virtual Int_t GetNPartSideA() const {return fNPartSideA;} + virtual Int_t GetNPartSideC() const {return fNPartSideC;} + virtual Float_t GetImpParameter() const {return fImpParameter;} + virtual Float_t GetImpParSideA() const {return fImpParSideA;} + virtual Float_t GetImpParSideC() const {return fImpParSideC;} // Print method virtual void Print(Option_t *) const; @@ -91,22 +92,22 @@ private: Float_t fPMRef1[2]; // Reference PM side C Float_t fPMRef2[2]; // Reference PM side A // - Int_t fNDetSpecNLeft; // Number of spectator neutrons detected - Int_t fNDetSpecPLeft; // Number of spectator protons detected - Int_t fNDetSpecNRight; // Number of spectator neutrons detected - Int_t fNDetSpecPRight; // Number of spectator protons detected - Int_t fNTrueSpecNLeft; // Estimate of the number of spectator neutrons generated - Int_t fNTrueSpecPLeft; // Estimate of the number of spectator protons generated - Int_t fNTrueSpecLeft; // Estimate of the total number of spectators - Int_t fNTrueSpecNRight;// Estimate of the number of spectator neutrons generated - Int_t fNTrueSpecPRight;// Estimate of the number of spectator protons generated - Int_t fNTrueSpecRight; // Estimate of the total number of spectators - Int_t fNPartLeft; // Estimate of the number of participants for 1 nucleus - Int_t fNPartRight; // Estimate of the number of participants for 1 nucleus - Float_t fImpPar; // Estimate of the impact parameter + Int_t fNDetSpecNSideA; // Number of spectator neutrons detected + Int_t fNDetSpecPSideA; // Number of spectator protons detected + Int_t fNDetSpecNSideC; // Number of spectator neutrons detected + Int_t fNDetSpecPSideC; // Number of spectator protons detected + Int_t fNTrueSpectators;// Estimate of the total number of spectators + Int_t fNTrueSpecSideA; // Estimate of the number of spectators side A + Int_t fNTrueSpecSideC; // Estimate of the number of spectators side C + Int_t fNParticipants; // Estimate of the total number of participants + Int_t fNPartSideA; // Estimate of the number of participants side A + Int_t fNPartSideC; // Estimate of the number of participants side C + Float_t fImpParameter; // Estimate of the impact parameter + Float_t fImpParSideA; // Estimate of the impact parameter side A + Float_t fImpParSideC; // Estimate of the impact parameter side B - ClassDef(AliZDCReco,5) // RecPoints for the Zero Degree Calorimeters + ClassDef(AliZDCReco,6) // RecPoints for the Zero Degree Calorimeters }; #endif diff --git a/ZDC/AliZDCRecoParam.cxx b/ZDC/AliZDCRecoParam.cxx index fc1979104f2..b8f07619fe5 100644 --- a/ZDC/AliZDCRecoParam.cxx +++ b/ZDC/AliZDCRecoParam.cxx @@ -13,12 +13,12 @@ * provided "as is" without express or implied warranty. * **************************************************************************/ -/////////////////////////////////////////////////////////////////////////////// -// // -// Class with ZDC reconstruction parameters // -// Origin: Chiara.Oppedisano@to.infn.it // -// // -/////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////// +// // +// Class with ZDC reconstruction parameters // +// Origin: Chiara.Oppedisano@to.infn.it // +// // +///////////////////////////////////////////////////////////////////// //#include diff --git a/ZDC/AliZDCRecoParam.h b/ZDC/AliZDCRecoParam.h index a2d4951ec17..5053fc7c8f5 100644 --- a/ZDC/AliZDCRecoParam.h +++ b/ZDC/AliZDCRecoParam.h @@ -10,6 +10,8 @@ // // ////////////////////////////////////////////////////////// +#include +#include #include #include "AliDetectorRecoParam.h" @@ -20,32 +22,19 @@ class AliZDCRecoParam : public AliDetectorRecoParam { AliZDCRecoParam(); virtual ~AliZDCRecoParam(); - virtual TF1* GetfZNCen() const =0; - virtual TF1* GetfZNPer() const =0; - virtual TF1* GetfZPCen() const =0; - virtual TF1* GetfZPPer() const =0; - virtual TF1* GetfZDCCen() const =0; - virtual TF1* GetfZDCPer() const =0; - virtual TF1* GetfbCen() const =0; - virtual TF1* GetfbPer() const =0; - virtual TF1* GetfZEMn() const =0; - virtual TF1* GetfZEMp() const =0; - virtual TF1* GetfZEMsp() const =0; - virtual TF1* GetfZEMb() const =0; - // - virtual Float_t GetZEMEndValue() const =0; - virtual Float_t GetZEMCutFraction() const =0; - virtual Float_t GetDZEMSup() const =0; - virtual Float_t GetDZEMInf() const =0; - virtual Float_t GetEZN1MaxValue() const =0; - virtual Float_t GetEZP1MaxValue() const =0; - virtual Float_t GetEZDC1MaxValue() const =0; - virtual Float_t GetEZN2MaxValue() const =0; - virtual Float_t GetEZP2MaxValue() const =0; - virtual Float_t GetEZDC2MaxValue() const =0; + virtual TH2F* GethZDCvsZEM() const = 0; + virtual TH2F* GethZDCCvsZEM() const = 0; + virtual TH2F* GethZDCAvsZEM() const = 0; + virtual TH1D* GethNpartDist() const = 0; + virtual TH1D* GethbDist() const = 0; + virtual Float_t GetClkCenter() const = 0; + virtual void SetZDCvsZEM(TH2F* /*hCorr*/) {printf(" AliZDCRecoParam::SetZDCvsZEM doesn't set anything!!!");} + virtual void SetZDCCvsZEM(TH2F* /*hCorr*/) {printf(" AliZDCRecoParam::SetZDCCvsZEM doesn't set anything!!!");} + virtual void SetZDCAvsZEM(TH2F* /*hCorr*/) {printf(" AliZDCRecoParam::SetZDCAvsZEM doesn't set anything!!!");} + - virtual void PrintParameters() const {} + virtual void PrintParameters() const {;} protected: diff --git a/ZDC/AliZDCRecoParamPbPb.cxx b/ZDC/AliZDCRecoParamPbPb.cxx index 51587ac56fd..d844e24f44c 100644 --- a/ZDC/AliZDCRecoParamPbPb.cxx +++ b/ZDC/AliZDCRecoParamPbPb.cxx @@ -20,8 +20,11 @@ // // /////////////////////////////////////////////////////////////////////////////// +#include +#include +#include +#include -//#include #include "AliZDCRecoParam.h" #include "AliZDCRecoParamPbPb.h" @@ -30,117 +33,112 @@ ClassImp(AliZDCRecoParamPbPb) //_____________________________________________________________________________ AliZDCRecoParamPbPb::AliZDCRecoParamPbPb() : AliZDCRecoParam(), - fZNCen(0), - fZNPer(0), - fZPCen(0), - fZPPer(0), - fZDCCen(0), - fZDCPer(0), - fbCen(0), - fbPer(0), - fZEMn(0), - fZEMp(0), - fZEMsp(0), - fZEMb(0), - fZEMEndValue(0), - fZEMCutFraction(0), - fDZEMSup(0), - fDZEMInf(0), - fEZN1MaxValue(0), - fEZP1MaxValue(0), - fEZDC1MaxValue(0), - fEZN2MaxValue(0), - fEZP2MaxValue(0), - fEZDC2MaxValue(0) + fhZDCvsZEM(0x0), + fhZDCCvsZEM(0x0), + fhZDCAvsZEM(0x0), + fhNpartDist(0x0), + fhbDist(0x0), + fClkCenter(0) { // //Default constructor } //_____________________________________________________________________________ -AliZDCRecoParamPbPb::~AliZDCRecoParamPbPb() +AliZDCRecoParamPbPb::AliZDCRecoParamPbPb(TH2F *hZDCvsZEM, TH2F *hZDCCvsZEM, TH2F *hZDCAvsZEM) : + AliZDCRecoParam(), + fhZDCvsZEM(hZDCvsZEM), + fhZDCCvsZEM(hZDCCvsZEM), + fhZDCAvsZEM(hZDCAvsZEM), + fhNpartDist(0x0), + fhbDist(0x0), + fClkCenter(0.1) { -// destructor + // + //Standard constructor + SetGlauberMCDist(); +} +//_____________________________________________________________________________ +AliZDCRecoParamPbPb::AliZDCRecoParamPbPb(TH2F *hZDCvsZEM, TH2F *hZDCCvsZEM, TH2F *hZDCAvsZEM, + TH1D *hNpart, TH1D *hb, Float_t clkCent) : + AliZDCRecoParam(), + fhZDCvsZEM(hZDCvsZEM), + fhZDCCvsZEM(hZDCCvsZEM), + fhZDCAvsZEM(hZDCAvsZEM), + fhNpartDist(hNpart), + fhbDist(hb), + fClkCenter(clkCent) +{ + // + //Standard constructor +} - delete fZNCen; - delete fZNPer; - delete fZPCen; - delete fZPPer; - delete fZDCCen; - delete fZDCPer; - delete fbCen; - delete fbPer; - delete fZEMn; - delete fZEMp; - delete fZEMsp; - delete fZEMb; +//______________________________________________________________________________ +AliZDCRecoParamPbPb::AliZDCRecoParamPbPb(const AliZDCRecoParamPbPb &oldrecopar) : + AliZDCRecoParam(), + fhZDCvsZEM(0x0), + fhZDCCvsZEM(0x0), + fhZDCAvsZEM(0x0), + fhNpartDist(0x0), + fhbDist(0x0), + fClkCenter(oldrecopar.fClkCenter) +{ + //Copy constructor + if(oldrecopar.fhZDCvsZEM){ + fhZDCvsZEM = new TH2F(*oldrecopar.fhZDCvsZEM); + fhZDCvsZEM->SetDirectory(0); + } + if(oldrecopar.fhZDCCvsZEM){ + fhZDCCvsZEM = new TH2F(*oldrecopar.fhZDCCvsZEM); + fhZDCCvsZEM->SetDirectory(0); + } + if(oldrecopar.fhZDCAvsZEM){ + fhZDCAvsZEM = new TH2F(*oldrecopar.fhZDCAvsZEM); + fhZDCAvsZEM->SetDirectory(0); + } + if(oldrecopar.fhNpartDist){ + fhNpartDist = new TH1D(*oldrecopar.fhNpartDist); + fhNpartDist->SetDirectory(0); + } + if(oldrecopar.fhbDist){ + fhbDist = new TH1D(*oldrecopar.fhbDist); + fhbDist->SetDirectory(0); + } +} + +//_____________________________________________________________________________ +AliZDCRecoParamPbPb::~AliZDCRecoParamPbPb() +{ + // destructor + if(fhZDCvsZEM) delete fhZDCvsZEM; + if(fhZDCCvsZEM) delete fhZDCCvsZEM; + if(fhZDCAvsZEM) delete fhZDCAvsZEM; + if(fhNpartDist) delete fhNpartDist; + if(fhbDist) delete fhbDist; } //_____________________________________________________________________________ -AliZDCRecoParamPbPb *AliZDCRecoParamPbPb::GetPbPbRecoParam() +AliZDCRecoParamPbPb *AliZDCRecoParamPbPb::GetPbPbRecoParam() const { // - // Makes default reconstruction parameters for low flux environment + // Makes default reconstruction parameters for Pb-Pb collisions // - AliZDCRecoParamPbPb *param = new AliZDCRecoParamPbPb(); - - param->SetfZNCen("(-2.287920+sqrt(2.287920*2.287920-4*(-0.007629)*(11.921710-x)))/(2*(-0.007629))",0.,164.); - param->SetfZNPer("(-37.812280-sqrt(37.812280*37.812280-4*(-0.190932)*(-1709.249672-x)))/(2*(-0.190932))",0.,164.); - param->SetfZPCen("(-1.321353+sqrt(1.321353*1.321353-4*(-0.007283)*(3.550697-x)))/(2*(-0.007283))",0.,60.); - param->SetfZPPer("(-42.643308-sqrt(42.643308*42.643308-4*(-0.310786)*(-1402.945615-x)))/(2*(-0.310786))",0.,60.); - param->SetfZDCCen("(-1.934991+sqrt(1.934991*1.934991-4*(-0.004080)*(15.111124-x)))/(2*(-0.004080))",0.,225.); - param->SetfZDCPer("(-34.380639-sqrt(34.380639*34.380639-4*(-0.104251)*(-2612.189017-x)))/(2*(-0.104251))",0.,225.); - param->SetfbCen("-0.056923+0.079703*x-0.0004301*x*x+0.000001366*x*x*x",0.,220.); - param->SetfbPer("17.943998-0.046846*x+0.000074*x*x",0.,220.); - param->SetfZEMn("121.7-0.1934*x+0.00007565*x*x",0.,1200.); - param->SetfZEMp("80.05-0.1315*x+0.00005327*x*x",0.,1200.); - param->SetfZEMsp("201.7-0.325*x+0.0001292*x*x",0.,1200.); - param->SetfZEMb("13.83-0.02851*x+5.101e-5*x*x-7.305e-8*x*x*x+5.101e-11*x*x*x*x-1.25e-14*x*x*x*x*x",0.,1200.); - - param->SetZEMEndValue(1200.); - param->SetZEMCutFraction(0.1); - param->SetDZEMSup(0.04); - param->SetDZEMInf(0.05); - param->SetEZN1MaxValue(161.); - param->SetEZP1MaxValue(59.); - param->SetEZDC1MaxValue(220.); - param->SetEZN2MaxValue(161.); - param->SetEZP2MaxValue(59.); - param->SetEZDC2MaxValue(161.); - + AliZDCRecoParamPbPb *param = new AliZDCRecoParamPbPb(); return param; } //_____________________________________________________________________________ -void AliZDCRecoParamPbPb::PrintParameters() const +void AliZDCRecoParamPbPb::SetGlauberMCDist() { + // Setting Glauber MC distributions + // from histos file stored in $ALICE_ROOT/ZDC + TFile * fileHistos = TFile::Open("$ALICE_ROOT/ZDC/GlauberMCHistos.root"); // - // print reconstruction parameters - // - printf("\n\n\t AliZDCRecoParamPbPb -> parameters set for reconstruction\n"); - printf("\t Functions for reconstruction of centrality varibles (Pb-Pb):\n"); - - fZNCen->Print(""); - fZNPer->Print(""); - fZPCen->Print(""); - fZPPer->Print(""); - fZDCCen->Print(""); - fZDCPer->Print(""); - fbCen->Print(""); - fbPer->Print(""); - fZEMn->Print(""); - fZEMp->Print(""); - fZEMsp->Print(""); - fZEMb->Print(""); + fhNpartDist = (TH1D*) fileHistos->Get("hDist"); + fhNpartDist->SetDirectory(0); + fhbDist = (TH1D*) fileHistos->Get("hbDist"); + fhbDist->SetDirectory(0); - printf("\n ####### Parameters from EZDC vs. ZEM correlation ####### \n"); - printf("\tZEMEndPoint = %1.2f, ZEMCutFraction = %1.2f \n" - " DZEMInf = %1.2f, DZEMSup = %1.2f\n", - fZEMEndValue, fZEMCutFraction, fDZEMInf, fDZEMSup); - printf("\n ####### Parameters from EZDC vs. Nspec correlation ####### \n"); - printf("\tEZN1MaxValue = %1.2f, EZP1MaxValue = %1.2f, EZDC1MaxValue = %1.2f \n" - "\tEZN2MaxValue = %1.2f, EZP2MaxValue = %1.2f, EZDC2MaxValue = %1.2f \n\n", - fEZN1MaxValue, fEZP1MaxValue, fEZDC1MaxValue, - fEZN2MaxValue, fEZP2MaxValue, fEZDC2MaxValue); + fileHistos->Close(); } diff --git a/ZDC/AliZDCRecoParamPbPb.h b/ZDC/AliZDCRecoParamPbPb.h index 933bff25ffd..9047d197c38 100644 --- a/ZDC/AliZDCRecoParamPbPb.h +++ b/ZDC/AliZDCRecoParamPbPb.h @@ -11,117 +11,52 @@ // // ////////////////////////////////////////////////////////// -#include +#include "AliLog.h" +#include "AliCDBEntry.h" +#include "AliCDBManager.h" #include "AliZDCRecoParam.h" #include "AliZDCRecoParamPbPb.h" -//class TF1; - class AliZDCRecoParamPbPb : public AliZDCRecoParam { public: AliZDCRecoParamPbPb(); + AliZDCRecoParamPbPb(TH2F * hZDCvsZEM, TH2F * hZDCCvsZEM, TH2F * hZDCAvsZEM); + AliZDCRecoParamPbPb(TH2F * hZDCvsZEM, TH2F * hZDCCvsZEM, TH2F * hZDCAvsZEM, + TH1D * hNpart, TH1D * hb, Float_t clkCent); + AliZDCRecoParamPbPb(const AliZDCRecoParamPbPb &oldrecopar); virtual ~AliZDCRecoParamPbPb(); - // make reco parameters for Pb-Pb collisions - static AliZDCRecoParamPbPb *GetPbPbRecoParam(); - - TF1* GetfZNCen() const {return fZNCen;} - TF1* GetfZNPer() const {return fZNPer;} - TF1* GetfZPCen() const {return fZPCen;} - TF1* GetfZPPer() const {return fZPPer;} - TF1* GetfZDCCen() const {return fZDCCen;} - TF1* GetfZDCPer() const {return fZDCPer;} - TF1* GetfbCen() const {return fbCen;} - TF1* GetfbPer() const {return fbPer;} - TF1* GetfZEMn() const {return fZEMn;} - TF1* GetfZEMp() const {return fZEMp;} - TF1* GetfZEMsp() const {return fZEMsp;} - TF1* GetfZEMb() const {return fZEMb;} - - void SetfZNCen(const char* formula, Double_t xmin, Double_t xmax) - {fZNCen = new TF1("fZNCen", formula, xmin, xmax);} - void SetfZNPer(const char* formula, Double_t xmin, Double_t xmax) - {fZNPer = new TF1("fZNPer", formula, xmin, xmax);} - void SetfZPCen(const char* formula, Double_t xmin, Double_t xmax) - {fZPCen = new TF1("fZPCen", formula, xmin, xmax);} - void SetfZPPer(const char* formula, Double_t xmin, Double_t xmax) - {fZPPer = new TF1("fZPPer", formula, xmin, xmax);} - void SetfZDCCen(const char* formula, Double_t xmin, Double_t xmax) - {fZDCCen = new TF1("fZDCCen", formula, xmin, xmax);} - void SetfZDCPer(const char* formula, Double_t xmin, Double_t xmax) - {fZDCPer = new TF1("fZDCPer", formula, xmin, xmax);} - void SetfbCen(const char* formula, Double_t xmin, Double_t xmax) - {fbCen = new TF1("fbCen", formula, xmin, xmax);} - void SetfbPer(const char* formula, Double_t xmin, Double_t xmax) - {fbPer = new TF1("fbPer", formula, xmin, xmax);} - void SetfZEMn(const char* formula, Double_t xmin, Double_t xmax) - {fZEMn = new TF1("fZEMn", formula, xmin, xmax);} - void SetfZEMp(const char* formula, Double_t xmin, Double_t xmax) - {fZEMp = new TF1("fZEMp", formula, xmin, xmax);} - void SetfZEMsp(const char* formula, Double_t xmin, Double_t xmax) - {fZEMsp = new TF1("fZEMsp", formula, xmin, xmax);} - void SetfZEMb(const char* formula, Double_t xmin, Double_t xmax) - {fZEMb = new TF1("fZEMb", formula, xmin, xmax);} + AliZDCRecoParamPbPb *GetPbPbRecoParam() const; - Float_t GetZEMEndValue() const {return fZEMEndValue;} - Float_t GetZEMCutFraction() const {return fZEMCutFraction;} - Float_t GetDZEMSup() const {return fDZEMSup;} - Float_t GetDZEMInf() const {return fDZEMInf;} - // - Float_t GetEZN1MaxValue() const {return fEZN1MaxValue;} - Float_t GetEZP1MaxValue() const {return fEZP1MaxValue;} - Float_t GetEZDC1MaxValue() const {return fEZDC1MaxValue;} - Float_t GetEZN2MaxValue() const {return fEZN2MaxValue;} - Float_t GetEZP2MaxValue() const {return fEZP2MaxValue;} - Float_t GetEZDC2MaxValue() const {return fEZDC2MaxValue;} + TH2F* GethZDCvsZEM() const {return fhZDCvsZEM;} + TH2F* GethZDCCvsZEM() const {return fhZDCCvsZEM;} + TH2F* GethZDCAvsZEM() const {return fhZDCAvsZEM;} + TH1D* GethNpartDist() const {return fhNpartDist;} + TH1D* GethbDist() const {return fhbDist;} + Float_t GetClkCenter() const {return fClkCenter;} + + void SetZDCvsZEM(TH2F *hCorr) {fhZDCvsZEM = hCorr;} + void SetZDCCvsZEM(TH2F *hCorr) {fhZDCCvsZEM = hCorr;} + void SetZDCAvsZEM(TH2F *hCorr) {fhZDCAvsZEM = hCorr;} + void SetNpartDist(TH1D *hDist) {fhNpartDist = hDist;} + void SetbDist(TH1D *hbDist) {fhbDist = hbDist;} + void SetClkCenter(Float_t xValue) {fClkCenter = xValue;} + void SetGlauberMCDist(); - void SetZEMEndValue(Float_t ZEMEndValue) {fZEMEndValue = ZEMEndValue;} - void SetZEMCutFraction(Float_t ZEMCutFraction) {fZEMCutFraction = ZEMCutFraction;} - void SetDZEMSup(Float_t DZEMSup) {fDZEMSup = DZEMSup;} - void SetDZEMInf(Float_t DZEMInf) {fDZEMInf = DZEMInf;} - // - void SetEZN1MaxValue(Float_t value) {fEZN1MaxValue = value;} - void SetEZP1MaxValue(Float_t value) {fEZP1MaxValue = value;} - void SetEZDC1MaxValue(Float_t value) {fEZDC1MaxValue = value;} - void SetEZN2MaxValue(Float_t value) {fEZN2MaxValue = value;} - void SetEZP2MaxValue(Float_t value) {fEZP2MaxValue = value;} - void SetEZDC2MaxValue(Float_t value) {fEZDC2MaxValue = value;} - - void PrintParameters() const; + //void Print(Option_t *) const; protected: - AliZDCRecoParamPbPb(const AliZDCRecoParamPbPb&); - AliZDCRecoParamPbPb& operator =(const AliZDCRecoParamPbPb&); - // *** PARAMETERS FOR Pb-Pb COLLISIONS - // --- Functions to evaluate centrality variables from defined functions - TF1* fZNCen; //! Nspectator n true vs. EZN - TF1* fZNPer; //! Nspectator n true vs. EZN - TF1* fZPCen; //! Nspectator p true vs. EZP - TF1* fZPPer; //! Nspectator p true vs. EZP - TF1* fZDCCen; //! Nspectators true vs. EZDC - TF1* fZDCPer; //! Nspectators true vs. EZDC - TF1* fbCen; //! b vs. EZDC - TF1* fbPer; //! b vs. EZDC - TF1* fZEMn; //! Nspectators n from ZEM energy - TF1* fZEMp; //! Nspectators p from ZEM energy - TF1* fZEMsp; //! Nspectators from ZEM energy - TF1* fZEMb; //! b from ZEM energy - // --- Coefficients for centrality selection from ZEM signal - Float_t fZEMEndValue; // End point value of ZEM energy spectrum - Float_t fZEMCutFraction; // Fraction of ZEM energy spectrum used to cut - Float_t fDZEMSup;// Upper value of EZDCvs.ZEM correlation where ZEM signal is used - Float_t fDZEMInf;// Lower value of EZDCvs.ZEM correlation where ZEM signal is used - // --- Parameters from EZDC vs. Nspec correlation - Float_t fEZN1MaxValue; // Max value of ZN1 vs. Nspec n correlation - Float_t fEZP1MaxValue; // Max value of ZP1 vs. Nspec p correlation - Float_t fEZDC1MaxValue; // Max value of ZDC1 vs. Nspec n+p correlation - Float_t fEZN2MaxValue; // Max value of ZN2 vs. Nspec n correlation - Float_t fEZP2MaxValue; // Max value of ZP2 vs. Nspec p correlation - Float_t fEZDC2MaxValue; // Max value of ZDC2 vs. Nspec n+p correlation + // --- Correlation E_ZDC vs. E_ZEM + TH2F * fhZDCvsZEM; // E_ZDC (total) vs. E_ZEM + TH2F * fhZDCCvsZEM; // E_ZDC vs. E_ZEM sideC + TH2F * fhZDCAvsZEM; // E_ZDC vs. E_ZEM sideA + TH1D * fhNpartDist; // Npart distribution from Glauber MC + TH1D * fhbDist; // b distribution from Glauber MC + Float_t fClkCenter; // clock center: value of x-axis - ClassDef(AliZDCRecoParamPbPb, 1) + ClassDef(AliZDCRecoParamPbPb, 2) }; diff --git a/ZDC/AliZDCRecoParampp.cxx b/ZDC/AliZDCRecoParampp.cxx index c370bf58b4e..767f38b4c18 100644 --- a/ZDC/AliZDCRecoParampp.cxx +++ b/ZDC/AliZDCRecoParampp.cxx @@ -16,12 +16,11 @@ /////////////////////////////////////////////////////////////////////////////// // // // Class with ZDC reconstruction parameters // -// Origin: Chiara.Oppedisano@to.infn.it // +// Origin: Chiara.Oppedisano@to.infn.it // // // /////////////////////////////////////////////////////////////////////////////// -//#include #include "AliZDCRecoParampp.h" ClassImp(AliZDCRecoParampp) @@ -30,32 +29,17 @@ ClassImp(AliZDCRecoParampp) AliZDCRecoParampp::AliZDCRecoParampp() : AliZDCRecoParam() { - // + //Default constructor } -//_____________________________________________________________________________ -AliZDCRecoParampp::~AliZDCRecoParampp() -{ -// destructor -} //_____________________________________________________________________________ -AliZDCRecoParampp *AliZDCRecoParampp::GetppRecoParam() +AliZDCRecoParampp *AliZDCRecoParampp::GetppRecoParam() const { - // - // Makes default reconstruction parameters - // - AliZDCRecoParampp *param = new AliZDCRecoParampp(); + // Getting default reconstruction parameters + + AliZDCRecoParampp *param = new AliZDCRecoParampp(); return param; } - -//_____________________________________________________________________________ -void AliZDCRecoParampp::PrintParameters() const -{ - // - // print reconstruction parameters - // - printf("\n\n\t AliZDCRecoParampp -> parameters set for reconstruction\n"); -} diff --git a/ZDC/AliZDCRecoParampp.h b/ZDC/AliZDCRecoParampp.h index 6faf5e54521..91c34357731 100644 --- a/ZDC/AliZDCRecoParampp.h +++ b/ZDC/AliZDCRecoParampp.h @@ -11,45 +11,22 @@ // // ////////////////////////////////////////////////////////// -#include #include "AliLog.h" #include "AliZDCRecoParam.h" -//class TF1; - class AliZDCRecoParampp : public AliZDCRecoParam { public: AliZDCRecoParampp(); - virtual ~AliZDCRecoParampp(); + virtual ~AliZDCRecoParampp() {;} - // make reco parameters for p-p collisions - static AliZDCRecoParampp *GetppRecoParam(); - - void PrintParameters() const; + AliZDCRecoParampp *GetppRecoParam() const; - virtual TF1* GetfZNCen() const {AliError("NO function can be defined in pp!"); return 0;} - virtual TF1* GetfZNPer() const {AliError("NO function can be defined in pp!"); return 0;} - virtual TF1* GetfZPCen() const {AliError("NO function can be defined in pp!"); return 0;} - virtual TF1* GetfZPPer() const {AliError("NO function can be defined in pp!"); return 0;} - virtual TF1* GetfZDCCen() const {AliError("NO function can be defined in pp!"); return 0;} - virtual TF1* GetfZDCPer() const {AliError("NO function can be defined in pp!"); return 0;} - virtual TF1* GetfbCen() const {AliError("NO function can be defined in pp!"); return 0;} - virtual TF1* GetfbPer() const {AliError("NO function can be defined in pp!"); return 0;} - virtual TF1* GetfZEMn() const {AliError("NO function can be defined in pp!"); return 0;} - virtual TF1* GetfZEMp() const {AliError("NO function can be defined in pp!"); return 0;} - virtual TF1* GetfZEMsp() const {AliError("NO function can be defined in pp!"); return 0;} - virtual TF1* GetfZEMb() const {AliError("NO function can be defined in pp!"); return 0;} - // - virtual Float_t GetZEMEndValue() const {AliError("NO function can be defined in pp!"); return 0;} - virtual Float_t GetZEMCutFraction() const {AliError("NO function can be defined in pp!"); return 0;} - virtual Float_t GetDZEMSup() const {AliError("NO function can be defined in pp!"); return 0;} - virtual Float_t GetDZEMInf() const {AliError("NO function can be defined in pp!"); return 0;} - virtual Float_t GetEZN1MaxValue() const {AliError("NO function can be defined in pp!"); return 0;} - virtual Float_t GetEZP1MaxValue() const {AliError("NO function can be defined in pp!"); return 0;} - virtual Float_t GetEZDC1MaxValue() const {AliError("NO function can be defined in pp!"); return 0;} - virtual Float_t GetEZN2MaxValue() const {AliError("NO function can be defined in pp!"); return 0;} - virtual Float_t GetEZP2MaxValue() const {AliError("NO function can be defined in pp!"); return 0;} - virtual Float_t GetEZDC2MaxValue() const {AliError("NO function can be defined in pp!"); return 0;} + virtual TH2F* GethZDCvsZEM() const {AliError("NO centrality determination in p-p!"); return 0;} + virtual TH2F* GethZDCCvsZEM() const {AliError("NO centrality determination in p-p!"); return 0;} + virtual TH2F* GethZDCAvsZEM() const {AliError("NO centrality determination in p-p!"); return 0;} + virtual TH1D* GethNpartDist() const {AliError("NO centrality determination in p-p!"); return 0;} + virtual TH1D* GethbDist() const {AliError("NO centrality determination in p-p!"); return 0;} + virtual Float_t GetClkCenter() const {AliError("NO centrality determination in p-p!");return 0;} protected: diff --git a/ZDC/AliZDCReconstructor.cxx b/ZDC/AliZDCReconstructor.cxx index cf355630cec..c01aa710b0a 100644 --- a/ZDC/AliZDCReconstructor.cxx +++ b/ZDC/AliZDCReconstructor.cxx @@ -17,15 +17,21 @@ /////////////////////////////////////////////////////////////////////////////// // // -// class for ZDC reconstruction // +// ************** Class for ZDC reconstruction ************** // +// Author: Chiara.Oppedisano@to.infn.it // +// // +// NOTATIONS ADOPTED TO IDENTIFY DETECTORS (used in different ages!): // +// (ZN1,ZP1) or (ZNC, ZPC) or RIGHT refers to side C (RB26) // +// (ZN2,ZP2) or (ZNA, ZPA) or LEFT refers to side A (RB24) // // // /////////////////////////////////////////////////////////////////////////////// -#include +#include +#include +#include #include -#include "AliRunLoader.h" #include "AliRawReader.h" #include "AliGRPObject.h" #include "AliESDEvent.h" @@ -35,7 +41,8 @@ #include "AliZDCReco.h" #include "AliZDCReconstructor.h" #include "AliZDCPedestals.h" -#include "AliZDCCalib.h" +#include "AliZDCEnCalib.h" +#include "AliZDCTowerCalib.h" #include "AliZDCRecoParam.h" #include "AliZDCRecoParampp.h" #include "AliZDCRecoParamPbPb.h" @@ -47,13 +54,16 @@ AliZDCRecoParam *AliZDCReconstructor::fRecoParam=0; //reconstruction parameters //_____________________________________________________________________________ AliZDCReconstructor:: AliZDCReconstructor() : fPedData(GetPedData()), - fECalibData(GetECalibData()), + fEnCalibData(GetEnCalibData()), + fTowCalibData(GetTowCalibData()), fRecoMode(0), fBeamEnergy(0.), - fPedSubMode(0) + fNRun(0), + fIsCalibrationMB(kFALSE), + fPedSubMode(0), + fRecoFlag(0x0) { // **** Default constructor - SetRecoMode(); } @@ -62,57 +72,93 @@ AliZDCReconstructor:: AliZDCReconstructor() : AliZDCReconstructor::~AliZDCReconstructor() { // destructor - if(fRecoParam) delete fRecoParam; - if(fPedData) delete fPedData; - if(fECalibData) delete fECalibData; + if(fRecoParam) delete fRecoParam; + if(fPedData) delete fPedData; + if(fEnCalibData) delete fEnCalibData; + if(fTowCalibData) delete fTowCalibData; } //____________________________________________________________________________ -void AliZDCReconstructor::SetRecoMode() +void AliZDCReconstructor::Init() { // Setting reconstruction mode - - // Initialization of the GRP entry - AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data"); - AliGRPObject* grpData = 0x0; - if(entry){ - TMap* m = dynamic_cast(entry->GetObject()); // old GRP entry - if(m){ - m->Print(); - grpData = new AliGRPObject(); - grpData->ReadValuesFromMap(m); + // Getting beam type and beam energy from GRP calibration object + + if(fRecoMode==0 && fBeamEnergy==0.){ + // Initialization of the GRP entry + AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data"); + AliGRPObject* grpData = 0x0; + if(entry){ + TMap* m = dynamic_cast(entry->GetObject()); // old GRP entry + if(m){ + m->Print(); + grpData = new AliGRPObject(); + grpData->ReadValuesFromMap(m); + } + else{ + grpData = dynamic_cast(entry->GetObject()); // new GRP entry + } + entry->SetOwner(0); + AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data"); } - else{ - grpData = dynamic_cast(entry->GetObject()); // new GRP entry - entry->SetOwner(0); + if(!grpData) AliError("No GRP entry found in OCDB!"); + + TString runType = grpData->GetRunType(); + if(runType==AliGRPObject::GetInvalidString()){ + AliError("GRP/GRP/Data entry: missing value for the run type ! Using UNKNOWN"); + runType = "UNKNOWN"; + } + if((runType.CompareTo("CALIBRATION_MB")) == 0){ + fIsCalibrationMB = kTRUE; + // + fRecoParam = new AliZDCRecoParamPbPb(); + // + TH2F* hZDCvsZEM = new TH2F("hZDCvsZEM","hZDCvsZEM",100,0.,10.,100,0.,1000.); + hZDCvsZEM->SetXTitle("E_{ZEM} (TeV)"); hZDCvsZEM->SetYTitle("E_{ZDC} (TeV)"); + fRecoParam->SetZDCvsZEM(hZDCvsZEM); + // + TH2F* hZDCCvsZEM = new TH2F("hZDCCvsZEM","hZDCCvsZEM",100,0.,10.,100,0.,500.); + hZDCCvsZEM->SetXTitle("E_{ZEM} (TeV)"); hZDCCvsZEM->SetYTitle("E_{ZDCC} (TeV)"); + fRecoParam->SetZDCCvsZEM(hZDCCvsZEM); + // + TH2F* hZDCAvsZEM = new TH2F("hZDCAvsZEM","hZDCAvsZEM",100,0.,10.,100,0.,500.); + hZDCAvsZEM->SetXTitle("E_{ZEM} (TeV)"); hZDCAvsZEM->SetYTitle("E_{ZDCA} (TeV)"); + fRecoParam->SetZDCAvsZEM(hZDCAvsZEM); + } + + TString beamType = grpData->GetBeamType(); + if(beamType==AliGRPObject::GetInvalidString()){ + AliError("GRP/GRP/Data entry: missing value for the beam energy !"); + AliError("\t ZDC does not reconstruct event 4 UNKNOWN beam type\n"); + return; + } + if((beamType.CompareTo("p-p")) == 0){ + fRecoMode=1; + fRecoParam = (AliZDCRecoParampp*) GetppRecoParamFromOCDB(); + } + else if((beamType.CompareTo("A-A")) == 0){ + fRecoMode=2; + if(fIsCalibrationMB == kFALSE) + fRecoParam = (AliZDCRecoParamPbPb*) GetPbPbRecoParamFromOCDB(); + } + + fBeamEnergy = grpData->GetBeamEnergy(); + if(fBeamEnergy==AliGRPObject::GetInvalidFloat()){ + AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0."); + fBeamEnergy = 0.; + } + + if(fIsCalibrationMB==kTRUE){ + AliInfo("\n ***** CALIBRATION_MB data -> building AliZDCRecoParamPbPb object *****"); + } + else{ + AliInfo(Form("\n\n ***** ZDC reconstruction initialized for %s @ %1.3f GeV *****\n",beamType.Data(), fBeamEnergy)); } - AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data"); - } - if(!grpData) AliError("No GRP entry found in OCDB!"); - - TString beamType = grpData->GetBeamType(); - if(beamType==AliGRPObject::GetInvalidString()){ - AliError("GRP/GRP/Data entry: missing value for the beam energy !"); - AliError("\t ZDC does not reconstruct event 4 UNKNOWN beam type\n"); - return; - } - // - if((beamType.CompareTo("p-p")) == 0){ - fRecoMode=0; - fRecoParam = (AliZDCRecoParampp*) AliZDCRecoParampp::GetppRecoParam(); - } - else if((beamType.CompareTo("A-A")) == 0){ - fRecoMode=1; - fRecoParam = (AliZDCRecoParamPbPb*) AliZDCRecoParamPbPb::GetPbPbRecoParam(); } - - fBeamEnergy = grpData->GetBeamEnergy(); - if(fBeamEnergy==AliGRPObject::GetInvalidFloat()) { - AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0"); - fBeamEnergy = 0.; + else{ + AliError(" ATTENTION!!!!!! No beam type nor beam energy has been set!!!!!!\n"); } - printf("\n ***** ZDC reconstruction initialized for %s @ %1.3f GeV\n\n",beamType.Data(), fBeamEnergy); } //_____________________________________________________________________________ @@ -123,11 +169,12 @@ void AliZDCReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) co // Retrieving calibration data // Parameters for mean value pedestal subtraction - Float_t meanPed[48]; - for(Int_t jj=0; jj<48; jj++) meanPed[jj] = fPedData->GetMeanPed(jj); + int const kNch = 24; + Float_t meanPed[2*kNch]; + for(Int_t jj=0; jj<2*kNch; jj++) meanPed[jj] = fPedData->GetMeanPed(jj); // Parameters pedestal subtraction through correlation with out-of-time signals - Float_t corrCoeff0[48], corrCoeff1[48]; - for(Int_t jj=0; jj<48; jj++){ + Float_t corrCoeff0[2*kNch], corrCoeff1[2*kNch]; + for(Int_t jj=0; jj<2*kNch; jj++){ corrCoeff0[jj] = fPedData->GetPedCorrCoeff0(jj); corrCoeff1[jj] = fPedData->GetPedCorrCoeff1(jj); } @@ -140,14 +187,13 @@ void AliZDCReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) co // loop over digits Float_t tZN1Corr[10], tZP1Corr[10], tZN2Corr[10], tZP2Corr[10]; - Float_t dZEM1Corr[2], dZEM2Corr[2], PMRef1[2], PMRef2[2]; + Float_t dZEM1Corr[2], dZEM2Corr[2], sPMRef1[2], sPMRef2[2]; for(Int_t i=0; i<10; i++){ tZN1Corr[i] = tZP1Corr[i] = tZN2Corr[i] = tZP2Corr[i] = 0.; - if(i<2) dZEM1Corr[i] = dZEM2Corr[i] = PMRef1[i] = PMRef2[i] = 0.; + if(i<2) dZEM1Corr[i] = dZEM2Corr[i] = sPMRef1[i] = sPMRef2[i] = 0.; } Int_t digNentries = digitsTree->GetEntries(); - int const kNch = 24; Float_t ootDigi[kNch]; // -- Reading out-of-time signals (last kNch entries) for current event if(fPedSubMode==1){ @@ -181,8 +227,6 @@ void AliZDCReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) co ped2SubHg = corrCoeff1[pedindex]*ootDigi[pedindex]+corrCoeff0[pedindex]; ped2SubLg = corrCoeff1[pedindex+kNch]*ootDigi[pedindex+kNch]+corrCoeff0[pedindex+kNch]; } - - //printf("\n\t Digit #%d det %d quad %d", iDigit, det, quad); if(quad != 5){ // ZDC (not reference PTMs!) if(det == 1){ // *** ZNC @@ -190,263 +234,467 @@ void AliZDCReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) co tZN1Corr[quad+5] = (Float_t) (digit.GetADCValue(1)-ped2SubLg); if(tZN1Corr[quad]<0.) tZN1Corr[quad] = 0.; if(tZN1Corr[quad+5]<0.) tZN1Corr[quad+5] = 0.; + // Ch. debug //printf("\t pedindex %d tZN1Corr[%d] = %1.0f tZN1Corr[%d] = %1.0f", // pedindex, quad, tZN1Corr[quad], quad+5, tZN1Corr[quad+5]); } else if(det == 2){ // *** ZP1 tZP1Corr[quad] = (Float_t) (digit.GetADCValue(0)-ped2SubHg); - if(tZP1Corr[quad]<0.) tZP1Corr[quad] = 0.; tZP1Corr[quad+5] = (Float_t) (digit.GetADCValue(1)-ped2SubLg); + if(tZP1Corr[quad]<0.) tZP1Corr[quad] = 0.; if(tZP1Corr[quad+5]<0.) tZP1Corr[quad+5] = 0.; + // Ch. debug //printf("\t pedindex %d tZP1Corr[%d] = %1.0f tZP1Corr[%d] = %1.0f", // pedindex, quad, tZP1Corr[quad], quad+5, tZP1Corr[quad+5]); } else if(det == 3){ if(quad == 1){ // *** ZEM1 dZEM1Corr[0] += (Float_t) (digit.GetADCValue(0)-ped2SubHg); - if(dZEM1Corr[0]<0.) dZEM1Corr[0] = 0.; dZEM1Corr[1] += (Float_t) (digit.GetADCValue(1)-ped2SubLg); + if(dZEM1Corr[0]<0.) dZEM1Corr[0] = 0.; if(dZEM1Corr[1]<0.) dZEM1Corr[1] = 0.; + // Ch. debug //printf("\t pedindex %d tZEM1Corr[%d] = %1.0f tZEM1Corr[%d] = %1.0f", // pedindex, quad, tZEM1Corr[quad], quad+1, tZEM1Corr[quad+1]); } else if(quad == 2){ // *** ZEM2 dZEM2Corr[0] += (Float_t) (digit.GetADCValue(0)-ped2SubHg); - if(dZEM2Corr[0]<0.) dZEM2Corr[0] = 0.; dZEM2Corr[1] += (Float_t) (digit.GetADCValue(1)-ped2SubLg); + if(dZEM2Corr[0]<0.) dZEM2Corr[0] = 0.; if(dZEM2Corr[1]<0.) dZEM2Corr[1] = 0.; + // Ch. debug //printf("\t pedindex %d tZEM2Corr[%d] = %1.0f tZEM2Corr[%d] = %1.0f", // pedindex, quad, tZEM2Corr[quad], quad+1, tZEM2Corr[quad+1]); } } else if(det == 4){ // *** ZN2 tZN2Corr[quad] = (Float_t) (digit.GetADCValue(0)-ped2SubHg); - if(tZN2Corr[quad]<0.) tZN2Corr[quad] = 0.; tZN2Corr[quad+5] = (Float_t) (digit.GetADCValue(1)-ped2SubLg); + if(tZN2Corr[quad]<0.) tZN2Corr[quad] = 0.; if(tZN2Corr[quad+5]<0.) tZN2Corr[quad+5] = 0.; + // Ch. debug //printf("\t pedindex %d tZN2Corr[%d] = %1.0f tZN2Corr[%d] = %1.0f\n", // pedindex, quad, tZN2Corr[quad], quad+5, tZN2Corr[quad+5]); } else if(det == 5){ // *** ZP2 tZP2Corr[quad] = (Float_t) (digit.GetADCValue(0)-ped2SubHg); - if(tZP2Corr[quad]<0.) tZP2Corr[quad] = 0.; tZP2Corr[quad+5] = (Float_t) (digit.GetADCValue(1)-ped2SubLg); + if(tZP2Corr[quad]<0.) tZP2Corr[quad] = 0.; if(tZP2Corr[quad+5]<0.) tZP2Corr[quad+5] = 0.; + // Ch. debug //printf("\t pedindex %d tZP2Corr[%d] = %1.0f tZP2Corr[%d] = %1.0f\n", // pedindex, quad, tZP2Corr[quad], quad+5, tZP2Corr[quad+5]); } } else{ // Reference PMs if(det == 1){ - PMRef1[0] = (Float_t) (digit.GetADCValue(0)-ped2SubHg); - if(PMRef1[0]<0.) PMRef1[0] = 0.; - PMRef1[1] = (Float_t) (digit.GetADCValue(1)-ped2SubLg); - if(PMRef2[1]<0.) PMRef1[1] = 0.; + sPMRef1[0] = (Float_t) (digit.GetADCValue(0)-ped2SubHg); + sPMRef1[1] = (Float_t) (digit.GetADCValue(1)-ped2SubLg); + // Ch. debug + if(sPMRef1[0]<0.) sPMRef1[0] = 0.; + if(sPMRef2[1]<0.) sPMRef1[1] = 0.; } else if(det == 4){ - PMRef2[0] = (Float_t) (digit.GetADCValue(0)-ped2SubHg); - if(PMRef2[0]<0.) PMRef2[0] = 0.; - PMRef2[1] = (Float_t) (digit.GetADCValue(1)-ped2SubLg); - if(PMRef2[1]<0.) PMRef2[1] = 0.; + sPMRef2[0] = (Float_t) (digit.GetADCValue(0)-ped2SubHg); + sPMRef2[1] = (Float_t) (digit.GetADCValue(1)-ped2SubLg); + // Ch. debug + if(sPMRef2[0]<0.) sPMRef2[0] = 0.; + if(sPMRef2[1]<0.) sPMRef2[1] = 0.; } } - } + // Ch. debug + /*printf(" - AliZDCReconstructor -> digit #%d det %d quad %d pedHG %1.0f pedLG %1.0f\n", + iDigit, det, quad, ped2SubHg, ped2SubLg); + printf(" HGChain -> RawDig %d DigCorr %1.2f\n", digit.GetADCValue(0), digit.GetADCValue(0)-ped2SubHg); + printf(" LGChain -> RawDig %d DigCorr %1.2f\n", digit.GetADCValue(1), digit.GetADCValue(1)-ped2SubLg); + */ + }//digits loop + + // If CALIBRATION_MB run build the RecoParam object + if(fIsCalibrationMB){ + Float_t ZDCC=0., ZDCA=0., ZEM=0; + ZEM += dZEM1Corr[0] + dZEM2Corr[0]; + for(Int_t jkl=0; jkl<5; jkl++){ + ZDCC += tZN1Corr[jkl] + tZP1Corr[jkl]; + ZDCA += tZN2Corr[jkl] + tZP2Corr[jkl]; + } + // Using energies in TeV in fRecoParam object + BuildRecoParam(fRecoParam->GethZDCvsZEM(), fRecoParam->GethZDCCvsZEM(), + fRecoParam->GethZDCAvsZEM(), ZDCC/1000., ZDCA/1000., ZEM/1000.); + } // reconstruct the event - if(fRecoMode==0) + if(fRecoMode==1) ReconstructEventpp(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr, - dZEM1Corr, dZEM2Corr, PMRef1, PMRef2); - else if(fRecoMode==1) + dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2); + else if(fRecoMode==2) ReconstructEventPbPb(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr, - dZEM1Corr, dZEM2Corr, PMRef1, PMRef2); - + dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2); } //_____________________________________________________________________________ -void AliZDCReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const +void AliZDCReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTree) { // *** ZDC raw data reconstruction // Works on the current event // Retrieving calibration data - // Parameters for mean value pedestal subtraction - Float_t meanPed[48]; - for(Int_t jj=0; jj<48; jj++) meanPed[jj] = fPedData->GetMeanPed(jj); + // Parameters for pedestal subtraction + int const kNch = 24; + Float_t meanPed[2*kNch]; + for(Int_t jj=0; jj<2*kNch; jj++) meanPed[jj] = fPedData->GetMeanPed(jj); // Parameters pedestal subtraction through correlation with out-of-time signals - Float_t corrCoeff0[48], corrCoeff1[48]; - for(Int_t jj=0; jj<48; jj++){ + Float_t corrCoeff0[2*kNch], corrCoeff1[2*kNch]; + for(Int_t jj=0; jj<2*kNch; jj++){ corrCoeff0[jj] = fPedData->GetPedCorrCoeff0(jj); corrCoeff1[jj] = fPedData->GetPedCorrCoeff1(jj); } - rawReader->Reset(); + Int_t adcZN1[5], adcZN1oot[5], adcZN1lg[5], adcZN1ootlg[5]; + Int_t adcZP1[5], adcZP1oot[5], adcZP1lg[5], adcZP1ootlg[5]; + Int_t adcZN2[5], adcZN2oot[5], adcZN2lg[5], adcZN2ootlg[5]; + Int_t adcZP2[5], adcZP2oot[5], adcZP2lg[5], adcZP2ootlg[5]; + Int_t adcZEM[2], adcZEMoot[2], adcZEMlg[2], adcZEMootlg[2]; + Int_t pmRef[2], pmRefoot[2], pmReflg[2], pmRefootlg[2]; + for(Int_t ich=0; ich<5; ich++){ + adcZN1[ich] = adcZN1oot[ich] = adcZN1lg[ich] = adcZN1ootlg[ich] = 0; + adcZP1[ich] = adcZP1oot[ich] = adcZP1lg[ich] = adcZP1ootlg[ich] = 0; + adcZN2[ich] = adcZN2oot[ich] = adcZN2lg[ich] = adcZN2ootlg[ich] = 0; + adcZP2[ich] = adcZP2oot[ich] = adcZP2lg[ich] = adcZP2ootlg[ich] = 0; + if(ich<2){ + adcZEM[ich] = adcZEMoot[ich] = adcZEMlg[ich] = adcZEMootlg[ich] = 0; + pmRef[ich] = pmRefoot[ich] = pmReflg[ich] = pmRefootlg[ich] = 0; + } + } // loop over raw data Float_t tZN1Corr[10], tZP1Corr[10], tZN2Corr[10], tZP2Corr[10]; - Float_t dZEM1Corr[2], dZEM2Corr[2], PMRef1[2], PMRef2[2]; + Float_t dZEM1Corr[2], dZEM2Corr[2], sPMRef1[2], sPMRef2[2]; for(Int_t i=0; i<10; i++){ tZN1Corr[i] = tZP1Corr[i] = tZN2Corr[i] = tZP2Corr[i] = 0.; - if(i<2) dZEM1Corr[i] = dZEM2Corr[i] = PMRef1[i] = PMRef2[i] = 0.; + if(i<2) dZEM1Corr[i] = dZEM2Corr[i] = sPMRef1[i] = sPMRef2[i] = 0.; } // + rawReader->Reset(); + fNRun = (Int_t) rawReader->GetRunNumber(); AliZDCRawStream rawData(rawReader); - Int_t const kNch = 24; - while(rawData.Next()) { - if(rawData.IsADCDataWord()){ + while(rawData.Next()){ + // Do + Bool_t ch2process = kTRUE; + // + if((rawData.IsADCDataWord()) && (rawData.IsUnderflow() == kTRUE)){ + fRecoFlag = 0x1<< 9; + ch2process = kFALSE; + } + if((rawData.IsADCDataWord()) && (rawData.IsOverflow() == kTRUE)){ + fRecoFlag = 0x1 << 8; + ch2process = kFALSE; + } + if(rawData.GetNChannelsOn() < 48 ) fRecoFlag = 0x1 << 2; + + if((rawData.IsADCDataWord()) && (ch2process == kTRUE)){ + + Int_t adcMod = rawData.GetADCModule(); Int_t det = rawData.GetSector(0); Int_t quad = rawData.GetSector(1); Int_t gain = rawData.GetADCGain(); Int_t pedindex=0; // - if(quad !=5){ // ZDCs (not reference PTMs) - if(det == 1){ - pedindex = quad; - if(gain == 0) tZN1Corr[quad] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); - else tZN1Corr[quad+5] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]); - } - else if(det == 2){ - pedindex = quad+5; - if(gain == 0) tZP1Corr[quad] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); - else tZP1Corr[quad+5] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]); - } - else if(det == 3){ - pedindex = quad+9; - if(quad==1){ - if(gain == 0) dZEM1Corr[0] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); - else dZEM1Corr[1] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]); + // Mean pedestal value subtraction ------------------------------------------------------- + if(fPedSubMode == 0){ + // Not interested in o.o.t. signals (ADC modules 2, 3) + if(adcMod == 2 || adcMod == 3) return; + // + if(quad != 5){ // ZDCs (not reference PTMs) + if(det == 1){ + pedindex = quad; + if(gain == 0) tZN1Corr[quad] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); + else tZN1Corr[quad+5] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]); } - else if(quad==2){ - if(gain == 0) dZEM2Corr[0] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); - else dZEM2Corr[1] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]); + else if(det == 2){ + pedindex = quad+5; + if(gain == 0) tZP1Corr[quad] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); + else tZP1Corr[quad+5] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]); + } + else if(det == 3){ + pedindex = quad+9; + if(quad==1){ + if(gain == 0) dZEM1Corr[0] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); + else dZEM1Corr[1] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]); + } + else if(quad==2){ + if(gain == 0) dZEM2Corr[0] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); + else dZEM2Corr[1] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]); + } + } + else if(det == 4){ + pedindex = quad+12; + if(gain == 0) tZN2Corr[quad] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); + else tZN2Corr[quad+5] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]); + } + else if(det == 5){ + pedindex = quad+17; + if(gain == 0) tZP2Corr[quad] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); + else tZP2Corr[quad+5] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]); } - } - else if(det == 4){ - pedindex = quad+12; - if(gain == 0) tZN2Corr[quad] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); - else tZN2Corr[quad+5] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]); - } - else if(det == 5){ - pedindex = quad+17; - if(gain == 0) tZP2Corr[quad] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); - else tZP2Corr[quad+5] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]); - } - //printf("\t AliZDCReconstructor - det %d quad %d res %d -> Ped[%d] = %1.0f\n", - // det,quad,gain, pedindex, meanPed[pedindex]); - } - else{ // reference PM - pedindex = (det-1)/3 + 22; - if(det == 1){ - if(gain==0) PMRef1[0] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); - else PMRef1[1] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); } - else if(det ==4){ - if(gain==0) PMRef2[0] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); - else PMRef2[1] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); + else{ // reference PM + pedindex = (det-1)/3 + 22; + if(det == 1){ + if(gain==0) sPMRef1[0] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); + else sPMRef1[1] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); + } + else if(det == 4){ + if(gain==0) sPMRef2[0] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); + else sPMRef2[1] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); + } } - } - }//IsADCDataWord + // Ch. debug + /*printf(" -> AliZDCReconstructor: det %d quad %d res %d -> Pedestal[%d] %1.0f\n", + det,quad,gain, pedindex, meanPed[pedindex]); + printf(" -> AliZDCReconstructor: RawADC %1.0f ADCCorr %1.0f\n", + rawData.GetADCValue(), rawData.GetADCValue()-meanPed[pedindex]);*/ + + }// mean pedestal subtraction + // Pedestal subtraction from correlation ------------------------------------------------ + else if(fPedSubMode == 1){ + // In time signals + if(adcMod==0 || adcMod==1){ + if(quad != 5){ // signals from ZDCs + if(det == 1){ + if(gain==0) adcZN1[quad] = rawData.GetADCValue(); + else adcZN1lg[quad] = rawData.GetADCValue(); + } + else if(det == 2){ + if(gain==0) adcZP1[quad] = rawData.GetADCValue(); + else adcZP1lg[quad] = rawData.GetADCValue(); + } + else if(det == 3){ + if(gain==0) adcZEM[quad-1] = rawData.GetADCValue(); + else adcZEMlg[quad-1] = rawData.GetADCValue(); + } + else if(det == 4){ + if(gain==0) adcZN2[quad] = rawData.GetADCValue(); + else adcZN2lg[quad] = rawData.GetADCValue(); + } + else if(det == 5){ + if(gain==0) adcZP2[quad] = rawData.GetADCValue(); + else adcZP2lg[quad] = rawData.GetADCValue(); + } + } + else{ // signals from reference PM + if(gain==0) pmRef[quad-1] = rawData.GetADCValue(); + else pmReflg[quad-1] = rawData.GetADCValue(); + } + } + // Out-of-time pedestals + else if(adcMod==2 || adcMod==3){ + if(quad != 5){ // signals from ZDCs + if(det == 1){ + if(gain==0) adcZN1oot[quad] = rawData.GetADCValue(); + else adcZN1ootlg[quad] = rawData.GetADCValue(); + } + else if(det == 2){ + if(gain==0) adcZP1oot[quad] = rawData.GetADCValue(); + else adcZP1ootlg[quad] = rawData.GetADCValue(); + } + else if(det == 3){ + if(gain==0) adcZEMoot[quad-1] = rawData.GetADCValue(); + else adcZEMootlg[quad-1] = rawData.GetADCValue(); + } + else if(det == 4){ + if(gain==0) adcZN2oot[quad] = rawData.GetADCValue(); + else adcZN2ootlg[quad] = rawData.GetADCValue(); + } + else if(det == 5){ + if(gain==0) adcZP2oot[quad] = rawData.GetADCValue(); + else adcZP2ootlg[quad] = rawData.GetADCValue(); + } + } + else{ // signals from reference PM + if(gain==0) pmRefoot[quad-1] = rawData.GetADCValue(); + else pmRefootlg[quad-1] = rawData.GetADCValue(); + } + } + } // pedestal subtraction from correlation + // Ch. debug + //printf("\t AliZDCReconstructor - det %d quad %d res %d -> Ped[%d] = %1.0f\n", + // det,quad,gain, pedindex, meanPed[pedindex]); + }//IsADCDataWord + }//loop on raw data + + if(fPedSubMode==1){ + for(Int_t t=0; t<5; t++){ + tZN1Corr[t] = adcZN1[t] - (corrCoeff1[t]*adcZN1oot[t]+corrCoeff0[t]); + tZN1Corr[t+5] = adcZN1lg[t] - (corrCoeff1[t+kNch]*adcZN1ootlg[t]+corrCoeff0[t+kNch]); + // + tZP1Corr[t] = adcZP1[t] - (corrCoeff1[t+5]*adcZP1oot[t]+corrCoeff0[t+5]); + tZP1Corr[t+5] = adcZP1lg[t] - (corrCoeff1[t+5+kNch]*adcZP1ootlg[t]+corrCoeff0[t+5+kNch]); + // + tZN2Corr[t] = adcZN2[t] - (corrCoeff1[t+12]*adcZN2oot[t]+corrCoeff0[t+12]); + tZN2Corr[t+5] = adcZN2lg[t] - (corrCoeff1[t+12+kNch]*adcZN2ootlg[t]+corrCoeff0[t+12+kNch]); + // + tZP2Corr[t] = adcZP2[t] - (corrCoeff1[t+17]*adcZP2oot[t]+corrCoeff0[t+17]); + tZP2Corr[t+5] = adcZP2lg[t] - (corrCoeff1[t+17+kNch]*adcZP2ootlg[t]+corrCoeff0[t+17+kNch]); + // 0---------0 Ch. debug 0---------0 +/* printf("\n\n ---------- Debug of pedestal subtraction from correlation ----------\n"); + printf("\tCorrCoeff0\tCorrCoeff1\n"); + printf(" ZN1 %d\t%1.0f\t%1.0f\n",t,corrCoeff0[t],corrCoeff1[t]); + printf(" ZN1lg %d\t%1.0f\t%1.0f\n",t+kNch,corrCoeff0[t+kNch],corrCoeff1[t+kNch]); + printf(" ZP1 %d\t%1.0f\t%1.0f\n",t+5,corrCoeff0[t+5],corrCoeff1[t+5]); + printf(" ZP1lg %d\t%1.0f\t%1.0f\n",t+5+kNch,corrCoeff0[t+5+kNch],corrCoeff1[t+5+kNch]); + printf(" ZN2 %d\t%1.0f\t%1.0f\n",t+12,corrCoeff0[t+12],corrCoeff1[t+12]); + printf(" ZN2lg %d\t%1.0f\t%1.0f\n",t+12+kNch,corrCoeff0[t+12+kNch],corrCoeff1[t+12+kNch]); + printf(" ZP2 %d\t%1.0f\t%1.0f\n",t+17,corrCoeff0[t+17],corrCoeff1[t+17]); + printf(" ZP2lg %d\t%1.0f\t%1.0f\n",t+17+kNch,corrCoeff0[t+17+kNch],corrCoeff1[t+17+kNch]); + + printf("ZN1 -> rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n", + adcZN1[t],(corrCoeff1[t]*adcZN1oot[t]+corrCoeff0[t]),tZN1Corr[t]); + printf(" lg -> rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n", + adcZN1lg[t],(corrCoeff1[t+kNch]*adcZN1ootlg[t]+corrCoeff0[t+kNch]),tZN1Corr[t+5]); + // + printf("ZP1 -> rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n", + adcZP1[t],(corrCoeff1[t+5]*adcZP1oot[t]+corrCoeff0[t+5]),tZP1Corr[t]); + printf(" lg -> rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n", + adcZP1lg[t],(corrCoeff1[t+5+kNch]*adcZP1ootlg[t]+corrCoeff0[t+5+kNch]),tZP1Corr[t+5]); + // + printf("ZN2 -> rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n", + adcZN2[t],(corrCoeff1[t+12]*adcZN2oot[t]+corrCoeff0[t+12]),tZN2Corr[t]); + printf(" lg -> rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n", + adcZN2lg[t],(corrCoeff1[t+12+kNch]*adcZN2ootlg[t]+corrCoeff0[t+12+kNch]),tZN2Corr[t+5]); + // + printf("ZP2 -> rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n", + adcZP2[t],(corrCoeff1[t+17]*adcZP2oot[t]+corrCoeff0[t+17]),tZP2Corr[t]); + printf(" lg -> rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n", + adcZP2lg[t],(corrCoeff1[t+17+kNch]*adcZP2ootlg[t]+corrCoeff0[t+17+kNch]),tZP2Corr[t+5]); +*/ + } + dZEM1Corr[0] = adcZEM[0] - (corrCoeff1[9]*adcZEMoot[0]+corrCoeff0[9]); + dZEM1Corr[1] = adcZEMlg[0] - (corrCoeff1[9+kNch]*adcZEMootlg[0]+corrCoeff0[9+kNch]); + dZEM2Corr[0] = adcZEM[1] - (corrCoeff1[10]*adcZEMoot[1]+corrCoeff0[10]); + dZEM2Corr[1] = adcZEMlg[1] - (corrCoeff1[10+kNch]*adcZEMootlg[1]+corrCoeff0[10+kNch]); + // + sPMRef1[0] = pmRef[0] - (corrCoeff1[22]*pmRefoot[0]+corrCoeff0[22]); + sPMRef1[1] = pmReflg[0] - (corrCoeff1[22+kNch]*pmRefootlg[0]+corrCoeff0[22+kNch]); + sPMRef2[0] = pmRef[0] - (corrCoeff1[23]*pmRefoot[1]+corrCoeff0[23]); + sPMRef2[1] = pmReflg[0] - (corrCoeff1[23+kNch]*pmRefootlg[1]+corrCoeff0[23+kNch]); } + // If CALIBRATION_MB run build the RecoParam object + if(fIsCalibrationMB){ + Float_t ZDCC=0., ZDCA=0., ZEM=0; + ZEM += dZEM1Corr[0] + dZEM2Corr[0]; + for(Int_t jkl=0; jkl<5; jkl++){ + ZDCC += tZN1Corr[jkl] + tZP1Corr[jkl]; + ZDCA += tZN2Corr[jkl] + tZP2Corr[jkl]; + } + BuildRecoParam(fRecoParam->GethZDCvsZEM(), fRecoParam->GethZDCCvsZEM(), + fRecoParam->GethZDCAvsZEM(), ZDCC/100., ZDCA/100., ZEM/100.); + } // reconstruct the event - if(fRecoMode==0) - ReconstructEventpp(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr, - dZEM1Corr, dZEM2Corr, PMRef1, PMRef2); - else if(fRecoMode==1) - ReconstructEventPbPb(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr, - dZEM1Corr, dZEM2Corr, PMRef1, PMRef2); - + else{ + if(fRecoMode==1) // p-p data + ReconstructEventpp(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr, + dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2); + else if(fRecoMode==2) // Pb-Pb data + ReconstructEventPbPb(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr, + dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2); + } } //_____________________________________________________________________________ -void AliZDCReconstructor::ReconstructEventpp(TTree *clustersTree, Float_t* ZN1ADCCorr, - Float_t* ZP1ADCCorr, Float_t* ZN2ADCCorr, Float_t* ZP2ADCCorr, - Float_t* ZEM1ADCCorr, Float_t* ZEM2ADCCorr, Float_t* PMRef1, Float_t* PMRef2) const +void AliZDCReconstructor::ReconstructEventpp(TTree *clustersTree, Float_t* corrADCZN1, + Float_t* corrADCZP1, Float_t* corrADCZN2, Float_t* corrADCZP2, + Float_t* corrADCZEM1, Float_t* corrADCZEM2, Float_t* sPMRef1, Float_t* sPMRef2) const { - // ***** Reconstruct one event - - // *** RECONSTRUCTION FROM "REAL" DATA - // - // Retrieving calibration data + // ****************** Reconstruct one event ****************** + + // ****** Retrieving calibration data // --- Equalization coefficients --------------------------------------------- Float_t equalCoeffZN1[5], equalCoeffZP1[5], equalCoeffZN2[5], equalCoeffZP2[5]; for(Int_t ji=0; ji<5; ji++){ - equalCoeffZN1[ji] = fECalibData->GetZN1EqualCoeff(ji); - equalCoeffZP1[ji] = fECalibData->GetZP1EqualCoeff(ji); - equalCoeffZN2[ji] = fECalibData->GetZN2EqualCoeff(ji); - equalCoeffZP2[ji] = fECalibData->GetZP2EqualCoeff(ji); + equalCoeffZN1[ji] = fTowCalibData->GetZN1EqualCoeff(ji); + equalCoeffZP1[ji] = fTowCalibData->GetZP1EqualCoeff(ji); + equalCoeffZN2[ji] = fTowCalibData->GetZN2EqualCoeff(ji); + equalCoeffZP2[ji] = fTowCalibData->GetZP2EqualCoeff(ji); } // --- Energy calibration factors ------------------------------------ Float_t calibEne[4]; // **** Energy calibration coefficient set to 1 // **** (no trivial way to calibrate in p-p runs) - //for(Int_t ij=0; ij<4; ij++) calibEne[ij] = fECalibData->GetEnCalib(ij); - for(Int_t ij=0; ij<4; ij++) calibEne[ij] = 1.; + for(Int_t ij=0; ij<4; ij++) calibEne[ij] = fEnCalibData->GetEnCalib(ij); - // Equalization of detector responses + // ****** Equalization of detector responses Float_t equalTowZN1[10], equalTowZN2[10], equalTowZP1[10], equalTowZP2[10]; + for(Int_t gi=0; gi<10; gi++){ + equalTowZN1[gi] = corrADCZN1[gi]*equalCoeffZN1[gi]; + equalTowZP1[gi] = corrADCZP1[gi]*equalCoeffZP1[gi]; + equalTowZN2[gi] = corrADCZN2[gi]*equalCoeffZN2[gi]; + equalTowZP2[gi] = corrADCZP2[gi]*equalCoeffZP2[gi]; + } + + // ****** Summed response for hadronic calorimeter (SUMMED and then CALIBRATED!) + Float_t calibSumZN1[]={0,0}, calibSumZN2[]={0,0}, calibSumZP1[]={0,0}, calibSumZP2[]={0,0}; for(Int_t gi=0; gi<5; gi++){ - equalTowZN1[gi] = ZN1ADCCorr[gi]*equalCoeffZN1[gi]; - equalTowZN1[gi+5] = ZN1ADCCorr[gi+5]*equalCoeffZN1[gi]; - equalTowZP1[gi] = ZP1ADCCorr[gi]*equalCoeffZP1[gi]; - equalTowZP1[gi+5] = ZP1ADCCorr[gi+5]*equalCoeffZP1[gi]; - equalTowZN2[gi] = ZN2ADCCorr[gi]*equalCoeffZN2[gi]; - equalTowZN2[gi+5] = ZN2ADCCorr[gi+5]*equalCoeffZN2[gi]; - equalTowZP2[gi] = ZP2ADCCorr[gi]*equalCoeffZP2[gi]; - equalTowZP2[gi+5] = ZP2ADCCorr[gi+5]*equalCoeffZP2[gi]; + calibSumZN1[0] += equalTowZN1[gi]; + calibSumZP1[0] += equalTowZP1[gi]; + calibSumZN2[0] += equalTowZN2[gi]; + calibSumZP2[0] += equalTowZP2[gi]; + // + calibSumZN1[1] += equalTowZN1[gi+5]; + calibSumZP1[1] += equalTowZP1[gi+5]; + calibSumZN2[1] += equalTowZN2[gi+5]; + calibSumZP2[1] += equalTowZP2[gi+5]; } + // High gain chain + calibSumZN1[0] = calibSumZN1[0]*calibEne[0]/8.; + calibSumZP1[0] = calibSumZP1[0]*calibEne[1]/8.; + calibSumZN2[0] = calibSumZN2[0]*calibEne[2]/8.; + calibSumZP2[0] = calibSumZP2[0]*calibEne[3]/8.; + // Low gain chain + calibSumZN1[1] = calibSumZN1[1]*calibEne[0]; + calibSumZP1[1] = calibSumZP1[1]*calibEne[1]; + calibSumZN2[1] = calibSumZN2[1]*calibEne[2]; + calibSumZP2[1] = calibSumZP2[1]*calibEne[3]; - // Energy calibration of detector responses + // ****** Energy calibration of detector responses Float_t calibTowZN1[10], calibTowZN2[10], calibTowZP1[10], calibTowZP2[10]; - Float_t calibSumZN1[]={0,0}, calibSumZN2[]={0,0}, calibSumZP1[]={0,0}, calibSumZP2[]={0,0}; - for(Int_t gi=0; gi<10; gi++){ - calibTowZN1[gi] = equalTowZN1[gi]*calibEne[0]; - calibTowZP1[gi] = equalTowZP1[gi]*calibEne[1]; - calibTowZN2[gi] = equalTowZN2[gi]*calibEne[2]; - calibTowZP2[gi] = equalTowZP2[gi]*calibEne[3]; - // - if(gi<5){ - calibSumZN1[0] += calibTowZN1[gi]; - calibSumZP1[0] += calibTowZP1[gi]; - calibSumZN2[0] += calibTowZN2[gi]; - calibSumZP2[0] += calibTowZP2[gi]; - } - // - else{ - calibSumZN1[1] += calibTowZN1[gi]; - calibSumZP1[1] += calibTowZP1[gi]; - calibSumZN2[1] += calibTowZN2[gi]; - calibSumZP2[1] += calibTowZP2[gi]; - } + for(Int_t gi=0; gi<5; gi++){ + // High gain chain + calibTowZN1[gi] = equalTowZN1[gi]*calibEne[0]/8.; + calibTowZP1[gi] = equalTowZP1[gi]*calibEne[1]/8.; + calibTowZN2[gi] = equalTowZN2[gi]*calibEne[2]/8.; + calibTowZP2[gi] = equalTowZP2[gi]*calibEne[3]/8.; + // Low gain chain + calibTowZN1[gi+5] = equalTowZN1[gi+5]*calibEne[0]; + calibTowZP1[gi+5] = equalTowZP1[gi+5]*calibEne[1]; + calibTowZN2[gi+5] = equalTowZN2[gi+5]*calibEne[2]; + calibTowZP2[gi+5] = equalTowZP2[gi+5]*calibEne[3]; } + // + Float_t sumZEM[]={0,0}, calibZEM1[]={0,0}, calibZEM2[]={0,0}; + calibZEM1[0] = corrADCZEM1[0]*calibEne[5]/8.; + calibZEM1[1] = corrADCZEM1[1]*calibEne[5]; + calibZEM2[0] = corrADCZEM2[0]*calibEne[5]/8.; + calibZEM2[1] = corrADCZEM2[1]*calibEne[5]; + for(Int_t k=0; k<2; k++) sumZEM[k] = calibZEM1[k] + calibZEM2[k]; - // --- Number of detected spectator nucleons - // *** N.B. -> It works only in Pb-Pb!!!!!!!!!!!! + // ****** No. of spectator and participants nucleons // Variables calculated to comply with ESD structure + // *** N.B. -> They have a meaning only in Pb-Pb!!!!!!!!!!!! Int_t nDetSpecNLeft=0, nDetSpecPLeft=0, nDetSpecNRight=0, nDetSpecPRight=0; - if(fBeamEnergy!=0){ - nDetSpecNLeft = (Int_t) (calibSumZN1[0]/fBeamEnergy); - nDetSpecPLeft = (Int_t) (calibSumZP1[0]/fBeamEnergy); - nDetSpecNRight = (Int_t) (calibSumZN2[0]/fBeamEnergy); - nDetSpecPRight = (Int_t) (calibSumZP2[0]/fBeamEnergy); - } - else AliWarning(" ATTENTION -> fBeamEnergy = 0\n"); - /*printf("\n\t AliZDCReconstructor -> nDetSpecNLeft %d, nDetSpecPLeft %d," - " nDetSpecNRight %d, nDetSpecPRight %d\n",nDetSpecNLeft, nDetSpecPLeft, - nDetSpecNRight, nDetSpecPRight);*/ - - // --- Number of generated spectator nucleons (from HIJING parameterization) - Int_t nGenSpecNLeft=0, nGenSpecPLeft=0, nGenSpecLeft=0; - Int_t nGenSpecNRight=0, nGenSpecPRight=0, nGenSpecRight=0; - Int_t nPartTotLeft=0, nPartTotRight=0; - Double_t impPar=0.; + Int_t nGenSpec=0, nGenSpecLeft=0, nGenSpecRight=0; + Int_t nPart=0, nPartTotLeft=0, nPartTotRight=0; + Double_t impPar=0., impPar1=0., impPar2=0.; // create the output tree AliZDCReco reco(calibSumZN1, calibSumZP1, calibSumZN2, calibSumZP2, calibTowZN1, calibTowZP1, calibTowZN2, calibTowZP2, - ZEM1ADCCorr, ZEM2ADCCorr, PMRef1, PMRef2, + calibZEM1, calibZEM2, sPMRef1, sPMRef2, nDetSpecNLeft, nDetSpecPLeft, nDetSpecNRight, nDetSpecPRight, - nGenSpecNLeft, nGenSpecPLeft, nGenSpecLeft, nGenSpecNRight, - nGenSpecPRight, nGenSpecRight, nPartTotLeft, nPartTotRight, impPar); + nGenSpec, nGenSpecLeft, nGenSpecRight, + nPart, nPartTotLeft, nPartTotRight, + impPar, impPar1, impPar2); AliZDCReco* preco = &reco; const Int_t kBufferSize = 4000; @@ -457,89 +705,88 @@ void AliZDCReconstructor::ReconstructEventpp(TTree *clustersTree, Float_t* ZN1AD } //_____________________________________________________________________________ -void AliZDCReconstructor::ReconstructEventPbPb(TTree *clustersTree, Float_t* ZN1ADCCorr, - Float_t* ZP1ADCCorr, Float_t* ZN2ADCCorr, Float_t* ZP2ADCCorr, - Float_t* ZEM1ADCCorr, Float_t* ZEM2ADCCorr, Float_t* PMRef1, Float_t* PMRef2) const +void AliZDCReconstructor::ReconstructEventPbPb(TTree *clustersTree, + Float_t* corrADCZN1, Float_t* corrADCZP1, Float_t* corrADCZN2, Float_t* corrADCZP2, + Float_t* corrADCZEM1, Float_t* corrADCZEM2, Float_t* sPMRef1, Float_t* sPMRef2) const { - // ***** Reconstruct one event - - // *** RECONSTRUCTION FROM "REAL" DATA - // - // Retrieving calibration data + // ****************** Reconstruct one event ****************** + + // ****** Retrieving calibration data // --- Equalization coefficients --------------------------------------------- Float_t equalCoeffZN1[5], equalCoeffZP1[5], equalCoeffZN2[5], equalCoeffZP2[5]; for(Int_t ji=0; ji<5; ji++){ - equalCoeffZN1[ji] = fECalibData->GetZN1EqualCoeff(ji); - equalCoeffZP1[ji] = fECalibData->GetZP1EqualCoeff(ji); - equalCoeffZN2[ji] = fECalibData->GetZN2EqualCoeff(ji); - equalCoeffZP2[ji] = fECalibData->GetZP2EqualCoeff(ji); + equalCoeffZN1[ji] = fTowCalibData->GetZN1EqualCoeff(ji); + equalCoeffZP1[ji] = fTowCalibData->GetZP1EqualCoeff(ji); + equalCoeffZN2[ji] = fTowCalibData->GetZN2EqualCoeff(ji); + equalCoeffZP2[ji] = fTowCalibData->GetZP2EqualCoeff(ji); } // --- Energy calibration factors ------------------------------------ - Float_t calibEne[4]; - for(Int_t ij=0; ij<4; ij++) calibEne[ij] = fECalibData->GetEnCalib(ij); + Float_t valFromOCDB[6], calibEne[6]; + for(Int_t ij=0; ij<6; ij++){ + valFromOCDB[ij] = fEnCalibData->GetEnCalib(ij); + if(ij<4){ + if(valFromOCDB[ij]!=0) calibEne[ij] = fBeamEnergy/valFromOCDB[ij]; + else AliWarning(" Value from OCDB for E calibration = 0 !!!\n"); + } + else calibEne[ij] = valFromOCDB[ij]; + } - // Equalization of detector responses + // ****** Equalization of detector responses Float_t equalTowZN1[10], equalTowZN2[10], equalTowZP1[10], equalTowZP2[10]; - for(Int_t gi=0; gi<5; gi++){ - equalTowZN1[gi] = ZN1ADCCorr[gi]*equalCoeffZN1[gi]; - equalTowZN1[gi+5] = ZN1ADCCorr[gi+5]*equalCoeffZN1[gi]; - equalTowZP1[gi] = ZP1ADCCorr[gi]*equalCoeffZP1[gi]; - equalTowZP1[gi+5] = ZP1ADCCorr[gi+5]*equalCoeffZP1[gi]; - equalTowZN2[gi] = ZN2ADCCorr[gi]*equalCoeffZN2[gi]; - equalTowZN2[gi+5] = ZN2ADCCorr[gi+5]*equalCoeffZN2[gi]; - equalTowZP2[gi] = ZP2ADCCorr[gi]*equalCoeffZP2[gi]; - equalTowZP2[gi+5] = ZP2ADCCorr[gi+5]*equalCoeffZP2[gi]; + for(Int_t gi=0; gi<10; gi++){ + equalTowZN1[gi] = corrADCZN1[gi]*equalCoeffZN1[gi]; + equalTowZP1[gi] = corrADCZP1[gi]*equalCoeffZP1[gi]; + equalTowZN2[gi] = corrADCZN2[gi]*equalCoeffZN2[gi]; + equalTowZP2[gi] = corrADCZP2[gi]*equalCoeffZP2[gi]; } - // Energy calibration of detector responses - Float_t calibTowZN1[10], calibTowZN2[10], calibTowZP1[10], calibTowZP2[10]; + // ****** Summed response for hadronic calorimeter (SUMMED and then CALIBRATED!) Float_t calibSumZN1[]={0,0}, calibSumZN2[]={0,0}, calibSumZP1[]={0,0}, calibSumZP2[]={0,0}; - for(Int_t gi=0; gi<10; gi++){ - calibTowZN1[gi] = equalTowZN1[gi]*calibEne[0]; - calibTowZP1[gi] = equalTowZP1[gi]*calibEne[1]; - calibTowZN2[gi] = equalTowZN2[gi]*calibEne[2]; - calibTowZP2[gi] = equalTowZP2[gi]*calibEne[3]; - // - if(gi<5){ - calibSumZN1[0] += calibTowZN1[gi]; - calibSumZP1[0] += calibTowZP1[gi]; - calibSumZN2[0] += calibTowZN2[gi]; - calibSumZP2[0] += calibTowZP2[gi]; - } - // - else{ - calibSumZN1[1] += calibTowZN1[gi]; - calibSumZP1[1] += calibTowZP1[gi]; - calibSumZN2[1] += calibTowZN2[gi]; - calibSumZP2[1] += calibTowZP2[gi]; - } + for(Int_t gi=0; gi<5; gi++){ + calibSumZN1[0] += equalTowZN1[gi]; + calibSumZP1[0] += equalTowZP1[gi]; + calibSumZN2[0] += equalTowZN2[gi]; + calibSumZP2[0] += equalTowZP2[gi]; + // + calibSumZN1[1] += equalTowZN1[gi+5]; + calibSumZP1[1] += equalTowZP1[gi+5]; + calibSumZN2[1] += equalTowZN2[gi+5]; + calibSumZP2[1] += equalTowZP2[gi+5]; } - - // - // --- Reconstruction parameters ------------------ - if(!fRecoParam) fRecoParam = (AliZDCRecoParamPbPb*) AliZDCRecoParamPbPb::GetPbPbRecoParam(); + // High gain chain + calibSumZN1[0] = calibSumZN1[0]*calibEne[0]/8.; + calibSumZP1[0] = calibSumZP1[0]*calibEne[1]/8.; + calibSumZN2[0] = calibSumZN2[0]*calibEne[2]/8.; + calibSumZP2[0] = calibSumZP2[0]*calibEne[3]/8.; + // Low gain chain + calibSumZN1[1] = calibSumZN1[1]*calibEne[0]; + calibSumZP1[1] = calibSumZP1[1]*calibEne[1]; + calibSumZN2[1] = calibSumZN2[1]*calibEne[2]; + calibSumZP2[1] = calibSumZP2[1]*calibEne[3]; // - Float_t endPointZEM = fRecoParam->GetZEMEndValue(); - Float_t cutFractionZEM = fRecoParam->GetZEMCutFraction(); - Float_t dZEMSup = fRecoParam->GetDZEMSup(); - Float_t dZEMInf = fRecoParam->GetDZEMInf(); - // - Float_t cutValueZEM = endPointZEM*cutFractionZEM; - Float_t supValueZEM = cutValueZEM+(endPointZEM*dZEMSup); - Float_t infValueZEM = cutValueZEM-(endPointZEM*dZEMInf); - // - Float_t maxValEZN1 = fRecoParam->GetEZN1MaxValue(); - Float_t maxValEZP1 = fRecoParam->GetEZP1MaxValue(); - Float_t maxValEZDC1 = fRecoParam->GetEZDC1MaxValue(); - Float_t maxValEZN2 = fRecoParam->GetEZN2MaxValue(); - Float_t maxValEZP2 = fRecoParam->GetEZP2MaxValue(); - Float_t maxValEZDC2 = fRecoParam->GetEZDC2MaxValue(); - // - //printf("\n\t AliZDCReconstructor -> ZEMEndPoint %1.0f, ZEMCutValue %1.0f," - // " ZEMSupValue %1.0f, ZEMInfValue %1.0f\n",endPointZEM,cutValueZEM,supValueZEM,infValueZEM); + Float_t sumZEM[]={0,0}, calibZEM1[]={0,0}, calibZEM2[]={0,0}; + calibZEM1[0] = corrADCZEM1[0]*calibEne[5]/8.; + calibZEM1[1] = corrADCZEM1[1]*calibEne[5]; + calibZEM2[0] = corrADCZEM2[0]*calibEne[5]/8.; + calibZEM2[1] = corrADCZEM2[1]*calibEne[5]; + for(Int_t k=0; k<2; k++) sumZEM[k] = calibZEM1[k] + calibZEM2[k]; + + // ****** Energy calibration of detector responses + Float_t calibTowZN1[10], calibTowZN2[10], calibTowZP1[10], calibTowZP2[10]; + for(Int_t gi=0; gi<5; gi++){ + // High gain chain + calibTowZN1[gi] = equalTowZN1[gi]*calibEne[0]/8.; + calibTowZP1[gi] = equalTowZP1[gi]*calibEne[1]/8.; + calibTowZN2[gi] = equalTowZN2[gi]*calibEne[2]/8.; + calibTowZP2[gi] = equalTowZP2[gi]*calibEne[3]/8.; + // Low gain chain + calibTowZN1[gi+5] = equalTowZN1[gi+5]*calibEne[0]; + calibTowZP1[gi+5] = equalTowZP1[gi+5]*calibEne[1]; + calibTowZN2[gi+5] = equalTowZN2[gi+5]*calibEne[2]; + calibTowZP2[gi+5] = equalTowZP2[gi+5]*calibEne[3]; + } - // --- Number of detected spectator nucleons - // *** N.B. -> It works only in Pb-Pb + // ****** Number of detected spectator nucleons Int_t nDetSpecNLeft=0, nDetSpecPLeft=0, nDetSpecNRight=0, nDetSpecPRight=0; if(fBeamEnergy!=0){ nDetSpecNLeft = (Int_t) (calibSumZN1[0]/fBeamEnergy); @@ -547,91 +794,282 @@ void AliZDCReconstructor::ReconstructEventPbPb(TTree *clustersTree, Float_t* ZN1 nDetSpecNRight = (Int_t) (calibSumZN2[0]/fBeamEnergy); nDetSpecPRight = (Int_t) (calibSumZP2[0]/fBeamEnergy); } - else AliWarning(" ATTENTION -> fBeamEnergy = 0\n"); + else AliWarning(" ATTENTION!!! fBeamEnergy=0 -> N_spec will be ZERO!!! \n"); /*printf("\n\t AliZDCReconstructor -> nDetSpecNLeft %d, nDetSpecPLeft %d," " nDetSpecNRight %d, nDetSpecPRight %d\n",nDetSpecNLeft, nDetSpecPLeft, nDetSpecNRight, nDetSpecPRight);*/ + + if(fIsCalibrationMB == kFALSE){ + // ****** Reconstruction parameters ------------------ + // Ch. debug + //fRecoParam->Print(""); + // + TH2F *hZDCvsZEM = fRecoParam->GethZDCvsZEM(); + TH2F *hZDCCvsZEM = fRecoParam->GethZDCCvsZEM(); + TH2F *hZDCAvsZEM = fRecoParam->GethZDCAvsZEM(); + TH1D *hNpartDist = fRecoParam->GethNpartDist(); + TH1D *hbDist = fRecoParam->GethbDist(); + Float_t ClkCenter = fRecoParam->GetClkCenter(); + // + Double_t xHighEdge = hZDCvsZEM->GetXaxis()->GetXmax(); + Double_t origin = xHighEdge*ClkCenter; + // Ch. debug + printf("\n\n xHighEdge %1.2f, origin %1.4f \n", xHighEdge, origin); + // + // ====> Summed ZDC info (sideA+side C) + TF1 *line = new TF1("line","[0]*x+[1]",0.,xHighEdge); + Float_t y = (calibSumZN1[0]+calibSumZP1[0]+calibSumZN2[0]+calibSumZP2[0])/1000.; + Float_t x = (calibZEM1[0]+calibZEM2[0])/1000.; + line->SetParameter(0, y/(x-origin)); + line->SetParameter(1, -origin*y/(x-origin)); + // Ch. debug + printf(" ***************** Summed ZDC info (sideA+side C) \n"); + printf(" E_{ZEM} %1.4f, E_{ZDC} %1.2f, TF1: %1.2f*x + %1.2f ", x, y,y/(x-origin),-origin*y/(x-origin)); + // + Double_t countPerc=0; + Double_t xBinCenter=0, yBinCenter=0; + for(Int_t nbinx=1; nbinx<=hZDCvsZEM->GetNbinsX(); nbinx++){ + for(Int_t nbiny=1; nbiny<=hZDCvsZEM->GetNbinsY(); nbiny++){ + xBinCenter = hZDCvsZEM->GetXaxis()->GetBinCenter(nbinx); + yBinCenter = hZDCvsZEM->GetYaxis()->GetBinCenter(nbiny); + // + if(line->GetParameter(0)>0){ + if(yBinCenter < (line->GetParameter(0)*xBinCenter + line->GetParameter(1))){ + countPerc += hZDCvsZEM->GetBinContent(nbinx,nbiny); + // Ch. debug + /*printf(" xBinCenter %1.3f, yBinCenter %1.0f, countPerc %1.0f\n", + xBinCenter, yBinCenter, countPerc);*/ + } + } + else{ + if(yBinCenter > (line->GetParameter(0)*xBinCenter + line->GetParameter(1))){ + countPerc += hZDCvsZEM->GetBinContent(nbinx,nbiny); + // Ch. debug + /*printf(" xBinCenter %1.3f, yBinCenter %1.0f, countPerc %1.0f\n", + xBinCenter, yBinCenter, countPerc);*/ + } + } + } + } + // + Double_t xSecPerc = 0.; + if(hZDCvsZEM->GetEntries()!=0){ + xSecPerc = countPerc/hZDCvsZEM->GetEntries(); + } + else{ + AliWarning(" Histogram hZDCvsZEM from OCDB has no entries!!!"); + } + // Ch. debug + //printf(" xSecPerc %1.4f \n", xSecPerc); - // --- Number of generated spectator nucleons (from HIJING parameterization) - Int_t nGenSpecNLeft=0, nGenSpecPLeft=0, nGenSpecLeft=0; - Int_t nGenSpecNRight=0, nGenSpecPRight=0, nGenSpecRight=0; - Double_t impPar=0.; - // - Float_t corrADCZEMHG = ZEM1ADCCorr[0] + ZEM2ADCCorr[0]; - // - if(corrADCZEMHG > supValueZEM){ - nGenSpecNLeft = (Int_t) ((fRecoParam->GetfZNCen())->Eval(calibSumZN1[0])); - nGenSpecPLeft = (Int_t) ((fRecoParam->GetfZPCen())->Eval(calibSumZP1[0])); - nGenSpecLeft = (Int_t) ((fRecoParam->GetfZDCCen())->Eval(calibSumZN1[0]+calibSumZP1[0])); - nGenSpecNRight = (Int_t) ((fRecoParam->GetfZNCen())->Eval(calibSumZN2[0])); - nGenSpecPRight = (Int_t) ((fRecoParam->GetfZNCen())->Eval(calibSumZP2[0])); - nGenSpecRight = (Int_t) ((fRecoParam->GetfZNCen())->Eval(calibSumZN2[0]+calibSumZP2[0])); - impPar = (fRecoParam->GetfbCen())->Eval(calibSumZN1[0]+calibSumZP1[0]); - } - else if(corrADCZEMHG < infValueZEM){ - nGenSpecNLeft = (Int_t) ((fRecoParam->GetfZNPer())->Eval(calibSumZN1[0])); - nGenSpecPLeft = (Int_t) ((fRecoParam->GetfZPPer())->Eval(calibSumZP1[0])); - nGenSpecLeft = (Int_t) ((fRecoParam->GetfZDCPer())->Eval(calibSumZN1[0]+calibSumZP1[0])); - impPar = (fRecoParam->GetfbPer())->Eval(calibSumZN1[0]+calibSumZP1[0]); - } - else if(corrADCZEMHG >= infValueZEM && corrADCZEMHG <= supValueZEM){ - nGenSpecNLeft = (Int_t) ((fRecoParam->GetfZEMn())->Eval(corrADCZEMHG)); - nGenSpecPLeft = (Int_t) ((fRecoParam->GetfZEMp())->Eval(corrADCZEMHG)); - nGenSpecLeft = (Int_t)((fRecoParam->GetfZEMsp())->Eval(corrADCZEMHG)); - impPar = (fRecoParam->GetfZEMb())->Eval(corrADCZEMHG); - } - // - if(calibSumZN1[0]/maxValEZN1>1.) nGenSpecNLeft = (Int_t) ((fRecoParam->GetfZEMn())->Eval(corrADCZEMHG)); - if(calibSumZP1[0]/maxValEZP1>1.) nGenSpecPLeft = (Int_t) ((fRecoParam->GetfZEMp())->Eval(corrADCZEMHG)); - if((calibSumZN1[0]+calibSumZP1[0]/maxValEZDC1)>1.){ - nGenSpecLeft = (Int_t)((fRecoParam->GetfZEMsp())->Eval(corrADCZEMHG)); - impPar = (fRecoParam->GetfZEMb())->Eval(corrADCZEMHG); - } - if(calibSumZN2[0]/maxValEZN2>1.) nGenSpecNRight = (Int_t) ((fRecoParam->GetfZEMn())->Eval(corrADCZEMHG)); - if(calibSumZP2[0]/maxValEZP2>1.) nGenSpecPRight = (Int_t) ((fRecoParam->GetfZEMp())->Eval(corrADCZEMHG)); - if((calibSumZN2[0]+calibSumZP2[0]/maxValEZDC2)>1.) nGenSpecRight = (Int_t)((fRecoParam->GetfZEMsp())->Eval(corrADCZEMHG)); - // - if(nGenSpecNLeft>125) nGenSpecNLeft=125; - else if(nGenSpecNLeft<0) nGenSpecNLeft=0; - if(nGenSpecPLeft>82) nGenSpecPLeft=82; - else if(nGenSpecPLeft<0) nGenSpecPLeft=0; - if(nGenSpecLeft>207) nGenSpecLeft=207; - else if(nGenSpecLeft<0) nGenSpecLeft=0; + // ====> side C + TF1 *lineC = new TF1("lineC","[0]*x+[1]",0.,xHighEdge); + Float_t yC = (calibSumZN1[0]+calibSumZP1[0])/1000.; + lineC->SetParameter(0, yC/(x-origin)); + lineC->SetParameter(1, -origin*yC/(x-origin)); + // Ch. debug + //printf(" ***************** Side C \n"); + //printf(" E_{ZEM} %1.4f, E_{ZDCC} %1.2f, TF1: %1.2f*x + %1.2f ", x, yC,yC/(x-origin),-origin*yC/(x-origin)); + // + Double_t countPercC=0; + Double_t xBinCenterC=0, yBinCenterC=0; + for(Int_t nbinx=1; nbinx<=hZDCCvsZEM->GetNbinsX(); nbinx++){ + for(Int_t nbiny=1; nbiny<=hZDCCvsZEM->GetNbinsY(); nbiny++){ + xBinCenterC = hZDCCvsZEM->GetXaxis()->GetBinCenter(nbinx); + yBinCenterC = hZDCCvsZEM->GetYaxis()->GetBinCenter(nbiny); + if(lineC->GetParameter(0)>0){ + if(yBinCenterC < (lineC->GetParameter(0)*xBinCenterC + lineC->GetParameter(1))){ + countPercC += hZDCCvsZEM->GetBinContent(nbinx,nbiny); + } + } + else{ + if(yBinCenterC > (lineC->GetParameter(0)*xBinCenterC + lineC->GetParameter(1))){ + countPercC += hZDCCvsZEM->GetBinContent(nbinx,nbiny); + } + } + } + } + // + Double_t xSecPercC = 0.; + if(hZDCCvsZEM->GetEntries()!=0){ + xSecPercC = countPercC/hZDCCvsZEM->GetEntries(); + } + else{ + AliWarning(" Histogram hZDCCvsZEM from OCDB has no entries!!!"); + } + // Ch. debug + //printf(" xSecPercC %1.4f \n", xSecPercC); + + // ====> side A + TF1 *lineA = new TF1("lineA","[0]*x+[1]",0.,xHighEdge); + Float_t yA = (calibSumZN2[0]+calibSumZP2[0])/1000.; + lineA->SetParameter(0, yA/(x-origin)); + lineA->SetParameter(1, -origin*yA/(x-origin)); + // + // Ch. debug + //printf(" ***************** Side A \n"); + //printf(" E_{ZEM} %1.4f, E_{ZDCA} %1.2f, TF1: %1.2f*x + %1.2f ", x, yA,yA/(x-origin),-origin*yA/(x-origin)); + // + Double_t countPercA=0; + Double_t xBinCenterA=0, yBinCenterA=0; + for(Int_t nbinx=1; nbinx<=hZDCAvsZEM->GetNbinsX(); nbinx++){ + for(Int_t nbiny=1; nbiny<=hZDCAvsZEM->GetNbinsY(); nbiny++){ + xBinCenterA = hZDCAvsZEM->GetXaxis()->GetBinCenter(nbinx); + yBinCenterA = hZDCAvsZEM->GetYaxis()->GetBinCenter(nbiny); + if(lineA->GetParameter(0)>0){ + if(yBinCenterA < (lineA->GetParameter(0)*xBinCenterA + lineA->GetParameter(1))){ + countPercA += hZDCAvsZEM->GetBinContent(nbinx,nbiny); + } + } + else{ + if(yBinCenterA > (lineA->GetParameter(0)*xBinCenterA + lineA->GetParameter(1))){ + countPercA += hZDCAvsZEM->GetBinContent(nbinx,nbiny); + } + } + } + } + // + Double_t xSecPercA = 0.; + if(hZDCAvsZEM->GetEntries()!=0){ + xSecPercA = countPercA/hZDCAvsZEM->GetEntries(); + } + else{ + AliWarning(" Histogram hZDCAvsZEM from OCDB has no entries!!!"); + } + // Ch. debug + //printf(" xSecPercA %1.4f \n", xSecPercA); + + // ****** Number of participants (from E_ZDC vs. E_ZEM correlation) + Int_t nPart=0, nPartC=0, nPartA=0; + Double_t nPartFrac=0., nPartFracC=0., nPartFracA=0.; + for(Int_t npbin=1; npbinGetNbinsX(); npbin++){ + nPartFrac += (hNpartDist->GetBinContent(npbin))/(hNpartDist->GetEntries()); + if((1.-nPartFrac) < xSecPerc){ + nPart = (Int_t) hNpartDist->GetBinLowEdge(npbin); + // Ch. debug + //printf(" ***************** Summed ZDC info (sideA+side C) \n"); + //printf(" nPartFrac %1.4f, nPart %d\n", nPartFrac, nPart); + break; + } + } + if(nPart<0) nPart=0; + // + for(Int_t npbin=1; npbinGetNbinsX(); npbin++){ + nPartFracC += (hNpartDist->GetBinContent(npbin))/(hNpartDist->GetEntries()); + if((1.-nPartFracC) < xSecPercC){ + nPartC = (Int_t) hNpartDist->GetBinLowEdge(npbin); + // Ch. debug + //printf(" ***************** Side C \n"); + //printf(" nPartFracC %1.4f, nPartC %d\n", nPartFracC, nPartC); + break; + } + } + if(nPartC<0) nPartC=0; + // + for(Int_t npbin=1; npbinGetNbinsX(); npbin++){ + nPartFracA += (hNpartDist->GetBinContent(npbin))/(hNpartDist->GetEntries()); + if((1.-nPartFracA) < xSecPercA){ + nPartA = (Int_t) hNpartDist->GetBinLowEdge(npbin); + // Ch. debug + //printf(" ***************** Side A \n"); + //printf(" nPartFracA %1.4f, nPartA %d\n\n", nPartFracA, nPartA); + break; + } + } + if(nPartA<0) nPartA=0; + + // ****** Impact parameter (from E_ZDC vs. E_ZEM correlation) + Float_t b=0, bC=0, bA=0; + Double_t bFrac=0., bFracC=0., bFracA=0.; + for(Int_t ibbin=1; ibbinGetNbinsX(); ibbin++){ + bFrac += (hbDist->GetBinContent(ibbin))/(hbDist->GetEntries()); + if((1.-bFrac) < xSecPerc){ + b = hbDist->GetBinLowEdge(ibbin); + break; + } + } + // + for(Int_t ibbin=1; ibbinGetNbinsX(); ibbin++){ + bFracC += (hbDist->GetBinContent(ibbin))/(hbDist->GetEntries()); + if((1.-bFracC) < xSecPercC){ + bC = hbDist->GetBinLowEdge(ibbin); + break; + } + } + // + for(Int_t ibbin=1; ibbinGetNbinsX(); ibbin++){ + bFracA += (hbDist->GetBinContent(ibbin))/(hNpartDist->GetEntries()); + if((1.-bFracA) < xSecPercA){ + bA = hbDist->GetBinLowEdge(ibbin); + break; + } + } + + // ****** Number of spectator nucleons + Int_t nGenSpec=0, nGenSpecC=0, nGenSpecA=0; + // + nGenSpec = 416 - nPart; + nGenSpecC = 416 - nPartC; + nGenSpecA = 416 - nPartA; + if(nGenSpec>416) nGenSpec=416; if(nGenSpec<0) nGenSpec=0; + if(nGenSpecC>416) nGenSpecC=416; if(nGenSpecC<0) nGenSpecC=0; + if(nGenSpecA>416) nGenSpecA=416; if(nGenSpecA<0) nGenSpecA=0; - // --- Number of generated participants (from HIJING parameterization) - Int_t nPart, nPartTotLeft, nPartTotRight; - nPart = 207-nGenSpecNLeft-nGenSpecPLeft; - nPartTotLeft = 207-nGenSpecLeft; - nPartTotRight = 207-nGenSpecRight; - if(nPart<0) nPart=0; - if(nPartTotLeft<0) nPartTotLeft=0; - if(nPartTotRight<0) nPartTotRight=0; - // - // *** DEBUG *** - /*printf("\n\t AliZDCReconstructor -> calibSumZN1[0] %1.0f, calibSumZP1[0] %1.0f," - " calibSumZN2[0] %1.0f, calibSumZP2[0] %1.0f, corrADCZEMHG %1.0f\n", - calibSumZN1[0],calibSumZP1[0],calibSumZN2[0],calibSumZP2[0],corrADCZEMHG); - printf("\t AliZDCReconstructor -> nGenSpecNLeft %d, nGenSpecPLeft %d, nGenSpecLeft %d\n" - "\t\t nGenSpecNRight %d, nGenSpecPRight %d, nGenSpecRight %d\n", - nGenSpecNLeft, nGenSpecPLeft, nGenSpecLeft, - nGenSpecNRight, nGenSpecPRight, nGenSpecRight); - printf("\t AliZDCReconstructor -> NpartL %d, NpartR %d, b %1.2f fm\n\n",nPartTotLeft, nPartTotRight, impPar); - */ + // Ch. debug + /*printf("\n\t AliZDCReconstructor -> calibSumZN1[0] %1.0f, calibSumZP1[0] %1.0f," + " calibSumZN2[0] %1.0f, calibSumZP2[0] %1.0f, corrADCZEMHG %1.0f\n", + calibSumZN1[0],calibSumZP1[0],calibSumZN2[0],calibSumZP2[0],corrADCZEMHG); + printf("\t AliZDCReconstructor -> nGenSpecLeft %d nGenSpecRight %d\n", + nGenSpecLeft, nGenSpecRight); + printf("\t AliZDCReconstructor -> NpartL %d, NpartR %d, b %1.2f fm\n\n",nPartTotLeft, nPartTotRight, impPar); + */ - // create the output tree - AliZDCReco reco(calibSumZN1, calibSumZP1, calibSumZN2, calibSumZP2, - calibTowZN1, calibTowZP1, calibTowZN2, calibTowZP2, - ZEM1ADCCorr, ZEM2ADCCorr, PMRef1, PMRef2, - nDetSpecNLeft, nDetSpecPLeft, nDetSpecNRight, nDetSpecPRight, - nGenSpecNLeft, nGenSpecPLeft, nGenSpecLeft, nGenSpecNRight, - nGenSpecPRight, nGenSpecRight, nPartTotLeft, nPartTotRight, impPar); + // create the output tree + AliZDCReco reco(calibSumZN1, calibSumZP1, calibSumZN2, calibSumZP2, + calibTowZN1, calibTowZP1, calibTowZN2, calibTowZP2, + calibZEM1, calibZEM2, sPMRef1, sPMRef2, + nDetSpecNLeft, nDetSpecPLeft, nDetSpecNRight, nDetSpecPRight, + nGenSpec, nGenSpecA, nGenSpecC, + nPart, nPartA, nPartC, b, bA, bC); - AliZDCReco* preco = &reco; - const Int_t kBufferSize = 4000; - clustersTree->Branch("ZDC", "AliZDCReco", &preco, kBufferSize); + AliZDCReco* preco = &reco; + const Int_t kBufferSize = 4000; + clustersTree->Branch("ZDC", "AliZDCReco", &preco, kBufferSize); + // write the output tree + clustersTree->Fill(); + + delete lineC; delete lineA; + } // ONLY IF fIsCalibrationMB==kFALSE + else{ + // create the output tree + AliZDCReco reco(calibSumZN1, calibSumZP1, calibSumZN2, calibSumZP2, + calibTowZN1, calibTowZP1, calibTowZN2, calibTowZP2, + calibZEM1, calibZEM2, sPMRef1, sPMRef2, + nDetSpecNLeft, nDetSpecPLeft, nDetSpecNRight, nDetSpecPRight, + 0, 0, 0, + 0, 0, 0, 0., 0., 0.); + + AliZDCReco* preco = &reco; + const Int_t kBufferSize = 4000; + clustersTree->Branch("ZDC", "AliZDCReco", &preco, kBufferSize); + // write the output tree + clustersTree->Fill(); + } +} - // write the output tree - clustersTree->Fill(); +//_____________________________________________________________________________ +void AliZDCReconstructor::BuildRecoParam(TH2F* hCorr, TH2F* hCorrC, TH2F* hCorrA, + Float_t ZDCC, Float_t ZDCA, Float_t ZEM) const +{ + // Calculate RecoParam object for Pb-Pb data + hCorr->Fill(ZDCC+ZDCA, ZEM); + hCorrC->Fill(ZDCC, ZEM); + hCorrA->Fill(ZDCA, ZEM); + // + /*TH1D* hNpartDist; + TH1D* hbDist; + Float_t clkCenter;*/ + } //_____________________________________________________________________________ @@ -639,6 +1077,8 @@ void AliZDCReconstructor::FillZDCintoESD(TTree *clustersTree, AliESDEvent* esd) { // fill energies and number of participants to the ESD + if(fIsCalibrationMB==kTRUE) WritePbPbRecoParamInOCDB(); + AliZDCReco reco; AliZDCReco* preco = &reco; clustersTree->SetBranchAddress("ZDC", &preco); @@ -659,19 +1099,27 @@ void AliZDCReconstructor::FillZDCintoESD(TTree *clustersTree, AliESDEvent* esd) tZP1EneLR[i] = reco.GetZP1LREnTow(i); tZP2EneLR[i] = reco.GetZP2LREnTow(i); } + // esdzdc->SetZN1TowerEnergy(tZN1Ene); esdzdc->SetZN2TowerEnergy(tZN2Ene); esdzdc->SetZP1TowerEnergy(tZP1Ene); esdzdc->SetZP2TowerEnergy(tZP2Ene); + // esdzdc->SetZN1TowerEnergyLR(tZN1EneLR); esdzdc->SetZN2TowerEnergyLR(tZN2EneLR); esdzdc->SetZP1TowerEnergyLR(tZP1EneLR); esdzdc->SetZP2TowerEnergyLR(tZP2EneLR); // + Int_t nPart = reco.GetNParticipants(); + Int_t nPartA = reco.GetNPartSideA(); + Int_t nPartC = reco.GetNPartSideC(); + Double_t b = reco.GetImpParameter(); + Double_t bA = reco.GetImpParSideA(); + Double_t bC = reco.GetImpParSideC(); + // esd->SetZDC(reco.GetZN1HREnergy(), reco.GetZP1HREnergy(), reco.GetZEM1HRsignal(), reco.GetZEM2HRsignal(), reco.GetZN2HREnergy(), reco.GetZP2HREnergy(), - reco.GetNPartLeft(), reco.GetNPartRight()); - // + nPart, nPartA, nPartC, b, bA, bC, fRecoFlag); } @@ -717,17 +1165,80 @@ AliZDCPedestals* AliZDCReconstructor::GetPedData() const } //_____________________________________________________________________________ -AliZDCCalib* AliZDCReconstructor::GetECalibData() const +AliZDCEnCalib* AliZDCReconstructor::GetEnCalibData() const { // Getting energy and equalization calibration object for ZDC set - AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/EMDCalib"); + AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/EnCalib"); if(!entry) AliFatal("No calibration data loaded!"); - AliZDCCalib *calibdata = dynamic_cast (entry->GetObject()); + AliZDCEnCalib *calibdata = dynamic_cast (entry->GetObject()); if(!calibdata) AliFatal("Wrong calibration object in calibration file!"); return calibdata; } +//_____________________________________________________________________________ +AliZDCTowerCalib* AliZDCReconstructor::GetTowCalibData() const +{ + + // Getting energy and equalization calibration object for ZDC set + + AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/TowCalib"); + if(!entry) AliFatal("No calibration data loaded!"); + + AliZDCTowerCalib *calibdata = dynamic_cast (entry->GetObject()); + if(!calibdata) AliFatal("Wrong calibration object in calibration file!"); + + return calibdata; +} + +//_____________________________________________________________________________ +AliZDCRecoParampp* AliZDCReconstructor::GetppRecoParamFromOCDB() const +{ + + // Getting reconstruction parameters from OCDB + + AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/RecoParampp"); + if(!entry) AliFatal("No RecoParam data found in OCDB!"); + + AliZDCRecoParampp *param = dynamic_cast (entry->GetObject()); + if(!param) AliFatal("No RecoParam object in OCDB entry!"); + + return param; + +} + +//_____________________________________________________________________________ +AliZDCRecoParamPbPb* AliZDCReconstructor::GetPbPbRecoParamFromOCDB() const +{ + + // Getting reconstruction parameters from OCDB + + AliCDBEntry *entry = AliCDBManager::Instance()->Get("ZDC/Calib/RecoParamPbPb"); + if(!entry) AliFatal("No RecoParam data found in OCDB!"); + + AliZDCRecoParamPbPb *param = dynamic_cast (entry->GetObject()); + if(!param) AliFatal("No RecoParam object in OCDB entry!"); + + return param; + +} + +//_____________________________________________________________________________ +void AliZDCReconstructor::WritePbPbRecoParamInOCDB() const +{ + + // Writing Pb-Pb reconstruction parameters from OCDB + + AliCDBManager *man = AliCDBManager::Instance(); + AliCDBMetaData *md= new AliCDBMetaData(); + md->SetResponsible("Chiara Oppedisano"); + md->SetComment("ZDC Pb-Pb reconstruction parameters"); + md->SetObjectClassName("AliZDCRecoParamPbPb"); + AliCDBId id("ZDC/Calib/RecoParamPbPb",fNRun,AliCDBRunRange::Infinity()); + man->Put(fRecoParam, id, md); + +} + diff --git a/ZDC/AliZDCReconstructor.h b/ZDC/AliZDCReconstructor.h index e1e56f3107d..804e419b3c4 100644 --- a/ZDC/AliZDCReconstructor.h +++ b/ZDC/AliZDCReconstructor.h @@ -15,7 +15,8 @@ #include "AliCDBManager.h" #include "AliCDBStorage.h" #include "AliZDCPedestals.h" -#include "AliZDCCalib.h" +#include "AliZDCEnCalib.h" +#include "AliZDCTowerCalib.h" #include "AliZDCRecoParam.h" #include "AliZDCRecoParampp.h" #include "AliZDCRecoParamPbPb.h" @@ -28,26 +29,26 @@ public: AliZDCReconstructor(); virtual ~AliZDCReconstructor(); + virtual void Init(); virtual Bool_t HasDigitConversion() const {return kFALSE;}; - + virtual void Reconstruct(TTree* digitsTree, TTree* clustersTree) const; - virtual void Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const; + virtual void Reconstruct(AliRawReader* rawReader, TTree* clustersTree); virtual void FillESD(TTree* /*digitsTree*/, TTree* clustersTree, AliESDEvent* esd) const - {FillZDCintoESD(clustersTree,esd);} + {FillZDCintoESD(clustersTree, esd);} virtual void FillESD(AliRawReader* /*rawReader*/, TTree* clustersTree, AliESDEvent* esd) const - {FillZDCintoESD(clustersTree,esd);} - + {FillZDCintoESD(clustersTree, esd);} + // parameter settings for reconstruction - void SetRecoMode(); void SetRecoMode(Int_t recoMode, Float_t beamEnergy) - {fRecoMode=recoMode; fBeamEnergy=beamEnergy;} + {fRecoMode=recoMode; fBeamEnergy=beamEnergy;} static void SetRecoParam(AliZDCRecoParam * param){fRecoParam = param;} Int_t GetRecoMode() {return fRecoMode;} Float_t GetBeamEnergy() {return fBeamEnergy;} - static const AliZDCRecoParam* GetRecoParam(){return fRecoParam;} + static const AliZDCRecoParam* GetRecoParam() {return fRecoParam;} void SetPedSubMode(Int_t pedsubMode) {fPedSubMode=pedsubMode;} Int_t GetPedSubMode() {return fPedSubMode;} @@ -55,8 +56,13 @@ public: // OCDB objects for reconstruction AliCDBStorage *SetStorage(const char* uri); AliZDCPedestals *GetPedData() const; - AliZDCCalib *GetECalibData() const; + AliZDCEnCalib *GetEnCalibData() const; + AliZDCTowerCalib *GetTowCalibData() const; + AliZDCRecoParampp *GetppRecoParamFromOCDB() const; + AliZDCRecoParamPbPb *GetPbPbRecoParamFromOCDB() const; + void WritePbPbRecoParamInOCDB() const; + private: AliZDCReconstructor(const AliZDCReconstructor&); AliZDCReconstructor& operator =(const AliZDCReconstructor&); @@ -67,18 +73,26 @@ private: void ReconstructEventPbPb(TTree *clustersTree, Float_t* ZN1ADCCorr, Float_t* ZP1ADCCorr, Float_t* ZN2ADCCorr, Float_t* ZP2ADCCorr, Float_t* ZEM1ADCCorr, Float_t* ZEM2ADCCorr, Float_t* PMRef1, Float_t* PMRef2) const; - void FillZDCintoESD(TTree *clustersTree, AliESDEvent*esd) const; + void BuildRecoParam(TH2F* hCorr, TH2F* hCorrC, TH2F* hCorrA, + Float_t ZDCC, Float_t ZDCA, Float_t ZEM) const; - static AliZDCRecoParam *fRecoParam; // reconstruction parameters + void FillZDCintoESD(TTree *clustersTree, AliESDEvent*esd) const; - AliZDCPedestals *fPedData; //! pedestal calibration data - AliZDCCalib *fECalibData; //! energy and equalization calibration data - Int_t fRecoMode; // =0->p-p, =1->A-A - Float_t fBeamEnergy; // beam energy - Int_t fPedSubMode; // =0->mean values, =1->from correlations + static AliZDCRecoParam *fRecoParam; // reconstruction parameters - ClassDef(AliZDCReconstructor, 6) // class for the ZDC reconstruction + AliZDCPedestals *fPedData; //! pedestal calibration data + AliZDCEnCalib *fEnCalibData; //! energy calibration data + AliZDCTowerCalib *fTowCalibData; //! equalization calibration data + + Int_t fRecoMode; // =1->p-p, =2->A-A + Float_t fBeamEnergy; // beam energy + Int_t fNRun; // Run Number (from raw data) + Bool_t fIsCalibrationMB; // true if run type = "CALIBRATION_MB" + Int_t fPedSubMode; // =0->mean values, =1->from correlations + UInt_t fRecoFlag; // flag indicating problems in reco + + ClassDef(AliZDCReconstructor, 7) // class for the ZDC reconstruction }; #endif diff --git a/ZDC/AliZDCTowerCalib.cxx b/ZDC/AliZDCTowerCalib.cxx new file mode 100644 index 00000000000..da31551876f --- /dev/null +++ b/ZDC/AliZDCTowerCalib.cxx @@ -0,0 +1,149 @@ +/************************************************************************** + * 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: AliZDCTowerCalib.cxx 22045 2007-11-08 13:31:24Z coppedis $ */ + +/////////////////////////////////////////////////////////////////////////////// +// // +// class for ZDC calibration // +// -> values for energy calibration and relative sector calibration // +// // +/////////////////////////////////////////////////////////////////////////////// + +#include "AliZDCTowerCalib.h" + +ClassImp(AliZDCTowerCalib) + +//________________________________________________________________ +AliZDCTowerCalib::AliZDCTowerCalib(): +TNamed() +{ + Reset(); +} + +//________________________________________________________________ +AliZDCTowerCalib::AliZDCTowerCalib(const char* name): +TNamed() +{ + // Constructor + TString namst = "Calib_"; + namst += name; + SetName(namst.Data()); + SetTitle(namst.Data()); + Reset(); + for(Int_t i=0; i<5; i++){ + fZN1EqualCoeff[i] = 0.; + fZP1EqualCoeff[i] = 0.; + fZN2EqualCoeff[i] = 0.; + fZP2EqualCoeff[i] = 0.; + } +} + +//________________________________________________________________ +AliZDCTowerCalib::AliZDCTowerCalib(const AliZDCTowerCalib& calibda) : + TNamed(calibda) +{ + // Copy constructor + SetName(calibda.GetName()); + SetTitle(calibda.GetName()); + Reset(); + for(int i=0; i<5; i++){ + fZN1EqualCoeff[i] = calibda.GetZN1EqualCoeff(i); + fZP1EqualCoeff[i] = calibda.GetZP1EqualCoeff(i); + fZN2EqualCoeff[i] = calibda.GetZN2EqualCoeff(i); + fZP2EqualCoeff[i] = calibda.GetZP2EqualCoeff(i); + } +} + +//________________________________________________________________ +AliZDCTowerCalib &AliZDCTowerCalib::operator =(const AliZDCTowerCalib& calibda) +{ +// assignment operator + SetName(calibda.GetName()); + SetTitle(calibda.GetName()); + Reset(); + for(int i=0; i<5; i++){ + fZN1EqualCoeff[i] = calibda.GetZN1EqualCoeff(i); + fZP1EqualCoeff[i] = calibda.GetZP1EqualCoeff(i); + fZN2EqualCoeff[i] = calibda.GetZN2EqualCoeff(i); + fZP2EqualCoeff[i] = calibda.GetZP2EqualCoeff(i); + } + + return *this; +} + +//________________________________________________________________ +AliZDCTowerCalib::~AliZDCTowerCalib() +{ +} + +//________________________________________________________________ +void AliZDCTowerCalib::Reset() +{ + // Reset + memset(fZN1EqualCoeff,0,5*sizeof(Float_t)); + memset(fZP1EqualCoeff,0,5*sizeof(Float_t)); + memset(fZN2EqualCoeff,0,5*sizeof(Float_t)); + memset(fZP2EqualCoeff,0,5*sizeof(Float_t)); +} + + +//________________________________________________________________ +void AliZDCTowerCalib::Print(Option_t *) const +{ + // Printing of calibration object + printf("\n\n ####### Equalization coefficients ####### \n"); + printf(" ZN1 -> %1.2f %1.2f %1.2f %1.2f %1.2f \n", + fZN1EqualCoeff[0],fZN1EqualCoeff[1],fZN1EqualCoeff[2],fZN1EqualCoeff[3],fZN1EqualCoeff[4]); + printf(" ZP1 -> %1.2f %1.2f %1.2f %1.2f %1.2f \n", + fZP1EqualCoeff[0],fZP1EqualCoeff[1],fZP1EqualCoeff[2],fZP1EqualCoeff[3],fZP1EqualCoeff[4]); + printf(" ZN2 -> %1.2f %1.2f %1.2f %1.2f %1.2f \n", + fZN2EqualCoeff[0],fZN2EqualCoeff[1],fZN2EqualCoeff[2],fZN2EqualCoeff[3],fZN2EqualCoeff[4]); + printf(" ZP2 -> %1.2f %1.2f %1.2f %1.2f %1.2f \n", + fZP2EqualCoeff[0],fZP2EqualCoeff[1],fZP2EqualCoeff[2],fZP2EqualCoeff[3],fZP2EqualCoeff[4]); + +} + +//________________________________________________________________ +void AliZDCTowerCalib::SetZN1EqualCoeff(Float_t* EqualCoeff) +{ + // Set ZN1 equalization coefficients + if(EqualCoeff) for(int t=0; t<5; t++) fZN1EqualCoeff[t] = EqualCoeff[t]; + else for(int t=0; t<5; t++) fZN1EqualCoeff[t] = 1.; +} + +//________________________________________________________________ +void AliZDCTowerCalib::SetZP1EqualCoeff(Float_t* EqualCoeff) +{ + // Set ZP1 equalization coefficients + if(EqualCoeff) for(int t=0; t<5; t++) fZP1EqualCoeff[t] = EqualCoeff[t]; + else for(int t=0; t<5; t++) fZP1EqualCoeff[t] = 1.; +} +//________________________________________________________________ +void AliZDCTowerCalib::SetZN2EqualCoeff(Float_t* EqualCoeff) +{ + // Set ZN2 equalization coefficients + if(EqualCoeff) for(int t=0; t<5; t++) fZN2EqualCoeff[t] = EqualCoeff[t]; + else for(int t=0; t<5; t++) fZN2EqualCoeff[t] = 1.; +} + +//________________________________________________________________ +void AliZDCTowerCalib::SetZP2EqualCoeff(Float_t* EqualCoeff) +{ + // Set ZN1 equalization coefficients + if(EqualCoeff) for(int t=0; t<5; t++) fZP2EqualCoeff[t] = EqualCoeff[t]; + else for(int t=0; t<5; t++) fZP2EqualCoeff[t] = 1.; +} + diff --git a/ZDC/AliZDCTowerCalib.h b/ZDC/AliZDCTowerCalib.h new file mode 100644 index 00000000000..782e7fc7155 --- /dev/null +++ b/ZDC/AliZDCTowerCalib.h @@ -0,0 +1,55 @@ +#ifndef ALIZDCTOWERCALIB_H +#define ALIZDCTOWERCALIB_H + +/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +//////////////////////////////////////////////// +// class for ZDC calibration -> CALIBCOEFF // +//////////////////////////////////////////////// + +#include "TNamed.h" +#include "AliCDBEntry.h" + +class AliZDC; + +class AliZDCTowerCalib: public TNamed { + + public: + AliZDCTowerCalib(); + AliZDCTowerCalib(const char* name); + AliZDCTowerCalib(const AliZDCTowerCalib &calibda); + AliZDCTowerCalib& operator= (const AliZDCTowerCalib &calibda); + virtual ~AliZDCTowerCalib(); + void Reset(); + virtual void Print(Option_t *) const; + // + Float_t GetZN1EqualCoeff(Int_t channel) const {return fZN1EqualCoeff[channel];} + Float_t* GetZN1EqualCoeffs() const {return (float*)fZN1EqualCoeff;} + Float_t GetZP1EqualCoeff(Int_t channel) const {return fZP1EqualCoeff[channel];} + Float_t* GetZP1EqualCoeffs() const {return (float*)fZP1EqualCoeff;} + Float_t GetZN2EqualCoeff(Int_t channel) const {return fZN2EqualCoeff[channel];} + Float_t* GetZN2EqualCoeffs() const {return (float*)fZN2EqualCoeff;} + Float_t GetZP2EqualCoeff(Int_t channel) const {return fZP2EqualCoeff[channel];} + Float_t* GetZP2EqualCoeffs() const {return (float*)fZP2EqualCoeff;} + + void SetZN1EqualCoeff(Int_t channel, Float_t val) {fZN1EqualCoeff[channel]=val;} + void SetZN1EqualCoeff(Float_t* EqualCoeff); + void SetZP1EqualCoeff(Int_t channel, Float_t val) {fZP1EqualCoeff[channel]=val;} + void SetZP1EqualCoeff(Float_t* EqualCoeff); + void SetZN2EqualCoeff(Int_t channel, Float_t val) {fZN2EqualCoeff[channel]=val;} + void SetZN2EqualCoeff(Float_t* EqualCoeff); + void SetZP2EqualCoeff(Int_t channel, Float_t val) {fZP2EqualCoeff[channel]=val;} + void SetZP2EqualCoeff(Float_t* EqualCoeff); + + protected: + // --- Coefficients for tower calibration + Float_t fZN1EqualCoeff[5]; // Equalization coefficients for ZN1 PTMs + Float_t fZP1EqualCoeff[5]; // Equalization coefficients for ZN1 PTMs + Float_t fZN2EqualCoeff[5]; // Equalization coefficients for ZN1 PTMs + Float_t fZP2EqualCoeff[5]; // Equalization coefficients for ZN1 PTMs + // + ClassDef(AliZDCTowerCalib,2) // ZDC calibration calibration data +}; + +#endif diff --git a/ZDC/CMake_libZDCbase.txt b/ZDC/CMake_libZDCbase.txt index a46c441ffee..9507d0913b1 100644 --- a/ZDC/CMake_libZDCbase.txt +++ b/ZDC/CMake_libZDCbase.txt @@ -6,7 +6,8 @@ AliZDCDigit.cxx AliZDCRawStream.cxx AliZDCPedestals.cxx AliZDCLaserCalib.cxx -AliZDCCalib.cxx +AliZDCEnCalib.cxx +AliZDCTowerCalib.cxx AliZDCChMap.cxx AliZDCMisAligner.cxx AliZDCDataDCS.cxx diff --git a/ZDC/CMake_libZDCsim.txt b/ZDC/CMake_libZDCsim.txt index 845beb97d6f..a7cba9ad08e 100644 --- a/ZDC/CMake_libZDCsim.txt +++ b/ZDC/CMake_libZDCsim.txt @@ -5,11 +5,13 @@ AliZDC.cxx AliZDCv3.cxx AliZDCHit.cxx AliZDCSDigit.cxx +AliGenZDC.cxx AliZDCFragment.cxx AliZDCDigitizer.cxx -AliGenZDC.cxx -AliZDCTrigger.cxx AliZDCQADataMakerSim.cxx +AliZDCTrigger.cxx +AliZDCTriggerParameters.cxx +AliZDCTriggerProcessor.cxx ) # fill list of header files from list of source files diff --git a/ZDC/MakeZDCRecoParam.C b/ZDC/MakeZDCRecoParam.C index 00f2cbfd571..0f6734b08d2 100644 --- a/ZDC/MakeZDCRecoParam.C +++ b/ZDC/MakeZDCRecoParam.C @@ -1,3 +1,27 @@ +#if !defined(__CINT__) || defined(__MAKECINT__) + +#include +#include +#include +#include +#include +#include "STEER/AliCDBEntry.h" +#include "STEER/AliCDBGrid.h" +#include "STEER/AliCDBId.h" +#include "STEER/AliCDBLocal.h" +#include "STEER/AliCDBManager.h" +#include "STEER/AliCDBMetaData.h" +#include "STEER/AliCDBPath.h" +#include "STEER/AliCDBRunRange.h" +#include "STEER/AliCDBStorage.h" +#include "ZDC/AliZDC.h" +#include "ZDC/AliZDCv3.h" +#include "ZDC/AliZDCRecoParam.h" +#include "ZDC/AliZDCRecoParampp.h" +#include "ZDC/AliZDCRecoParamPbPb.h" + +#endif + void MakeZDCRecoParam(Int_t type=0){ //======================================================================== // @@ -12,30 +36,59 @@ void MakeZDCRecoParam(Int_t type=0){ //if(!cdb->IsDefaultStorageSet()) cdb->SetDefaultStorage("local://OCDB"); cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); - AliZDCRecoParam *zdcRecoParam = 0; - // - switch(type) { - case 0: - zdcRecoParam = (AliZDCRecoParampp*) AliZDCRecoParampp::GetppRecoParam(); - zdcRecoParam->SetBeamEnergy(5000.); - break; - case 1: - zdcRecoParam = (AliZDCRecoParamPbPb*) AliZDCRecoParamPbPb::GetPbPbRecoParam(); - break; - case default: + if(type==0){ + AliZDCRecoParampp* zdcRecoParam = new AliZDCRecoParampp(); + // save in CDB storage + AliCDBMetaData *md= new AliCDBMetaData(); + md->SetResponsible("Chiara Oppedisano"); + md->SetComment("p-p reconstruction parameters for ZDC"); + md->SetAliRootVersion(gSystem->Getenv("ARVERSION")); + md->SetObjectClassName("AliZDCRecoParampp"); + AliCDBId id("ZDC/Calib/RecoParampp",0,AliCDBRunRange::Infinity()); + cdb->GetDefaultStorage()->Put(zdcRecoParam,id, md); + } + else if(type==1){ + // + TH1::AddDirectory(0); + TH2::AddDirectory(0); + // + TFile * fileHistos = TFile::Open("$ALICE_ROOT/ZDC/GlauberMCHistos.root"); + fileHistos->cd(); + // + TH2F *hZDCvsZEM = (TH2F*) fileHistos->Get("hZDCvsZEM"); + hZDCvsZEM->SetDirectory(0); + // + TH2F *hZDCCvsZEM = (TH2F*) fileHistos->Get("hZDCCvsZEM"); + hZDCCvsZEM->SetDirectory(0); + // + TH2F *hZDCAvsZEM = (TH2F*) fileHistos->Get("hZDCAvsZEM"); + hZDCAvsZEM->SetDirectory(0); + // + TH1D* hDist = (TH1D*) fileHistos->Get("hDist"); + hDist->SetDirectory(0); + // + TH1D* hbDist = (TH1D*) fileHistos->Get("hbDist"); + hbDist->SetDirectory(0); + + AliZDCRecoParamPbPb* zdcRecoParam = + new AliZDCRecoParamPbPb(hZDCvsZEM, hZDCCvsZEM, + hZDCAvsZEM, hDist, hbDist, 0.1); + //zdcRecoParam->Print(""); + + // save in CDB storage + AliCDBMetaData *md= new AliCDBMetaData(); + md->SetResponsible("Chiara Oppedisano"); + md->SetComment("A-A reconstruction parameters for ZDC"); + md->SetAliRootVersion(gSystem->Getenv("ARVERSION")); + md->SetObjectClassName("AliZDCRecoParamPbPb"); + AliCDBId id("ZDC/Calib/RecoParamPbPb", 0, AliCDBRunRange::Infinity()); + cdb->GetDefaultStorage()->Put(zdcRecoParam, id, md); + // + fileHistos->Close(); + } + else{ printf("Event type not implemented\n"); return; - break; } - // - // save in CDB storage - AliCDBMetaData *md= new AliCDBMetaData(); - md->SetResponsible("Chiara Oppedisano"); - md->SetComment("Reconstruction parameters for ZDC"); - md->SetAliRootVersion(gSystem->Getenv("ARVERSION")); - md->SetBeamPeriod(0); - md->SetObjectClassName("AliZDCRecoParam"); - AliCDBId id("ZDC/Calib/RecoParam",0,AliCDBRunRange::Infinity()); - AliCDBManager::Instance()->GetDefaultStorage()->Put(zdcRecoParam,id, md); } diff --git a/ZDC/TestZDCPreprocessor.C b/ZDC/TestZDCPreprocessor.C index 280de423d52..61625eec6aa 100644 --- a/ZDC/TestZDCPreprocessor.C +++ b/ZDC/TestZDCPreprocessor.C @@ -41,7 +41,7 @@ void TestZDCPreprocessor(Int_t obj=0) // To use it uncomment the following line: // TMap* dcsAliasMap = CreateDCSAliasMap(); - //WriteDCSAliasMap(); + WriteDCSAliasMap(); // now give the alias map to the shuttle shuttle->SetDCSInput(dcsAliasMap); @@ -61,11 +61,14 @@ void TestZDCPreprocessor(Int_t obj=0) // Note that the test preprocessor name is TPC. The name of the detector's preprocessor must follow // the "online" naming convention ALICE-INT-2003-039. // - shuttle->AddInputFile(AliTestShuttle::kDAQ, "ZDC", "PEDESTALS", "LDC0", "ZDCPedestal.dat"); + shuttle->AddInputFile(AliTestShuttle::kDAQ, "ZDC", "PEDESTALDATA", "LDC0", "ZDCPedestal.dat"); + shuttle->AddInputFile(AliTestShuttle::kDAQ, "ZDC", "PEDHISTOS", "LDC0", "ZDCPedHisto.root"); // - shuttle->AddInputFile(AliTestShuttle::kDAQ, "ZDC", "LASER", "LDC0", "ZDCLaserCalib.dat"); + shuttle->AddInputFile(AliTestShuttle::kDAQ, "ZDC", "LASERDATA", "LDC0", "ZDCLaserCalib.dat"); + shuttle->AddInputFile(AliTestShuttle::kDAQ, "ZDC", "LASERHISTOS", "LDC0", "ZDCLasHisto.root"); // - shuttle->AddInputFile(AliTestShuttle::kDAQ, "ZDC", "EMDCALIB", "LDC0", "ZDCEMDCalib.dat"); + shuttle->AddInputFile(AliTestShuttle::kDAQ, "ZDC", "ENERGYCALIB", "LDC0", "ZDCEnCalib.dat"); + shuttle->AddInputFile(AliTestShuttle::kDAQ, "ZDC", "TOWERCALIB", "LDC0", "ZDCTowerCalib.dat"); // shuttle->AddInputFile(AliTestShuttle::kDAQ, "ZDC", "PHYSICS", "LDC0", "ZDCChMapping.dat"); // @@ -78,9 +81,9 @@ void TestZDCPreprocessor(Int_t obj=0) // using GetRunType function. if(obj==1) shuttle->SetInputRunType("STANDALONE_PEDESTAL"); else if(obj==2) shuttle->SetInputRunType("STANDALONE_LASER"); - else if(obj==3) shuttle->SetInputRunType("STANDALONE_EMD"); + else if(obj==3) shuttle->SetInputRunType("CALIBRATION_EMD"); else if(obj==4) shuttle->SetInputRunType("STANDALONE_COSMIC"); - else if(obj==5) shuttle->SetInputRunType("STANDALONE_BC"); + else if(obj==5) shuttle->SetInputRunType("CALIBRATION_BC"); else if(obj==6) shuttle->SetInputRunType("PHYSICS"); // TODO(4) @@ -139,17 +142,17 @@ void TestZDCPreprocessor(Int_t obj=0) else if(obj==2) chkEntry1 = AliCDBManager::Instance()->GetStorage(AliShuttleInterface::GetMainCDB()) ->Get("ZDC/Calib/LaserCalib", 0); else if(obj==3) chkEntry1 = AliCDBManager::Instance()->GetStorage(AliShuttleInterface::GetMainCDB()) - ->Get("ZDC/Calib/EMDCalib", 0); + ->Get("ZDC/Calib/EnCalib", 0); if(!chkEntry0){ - printf("No file in \n ZDC/Calib/ChMap\n"); + printf("No file in ZDC/Calib/ChMap\n"); return; } if(!chkEntry1){ - if(obj==1) printf("No file in \n ZDC/Calib/Pedestal\n"); - else if(obj==2) printf("No file in \n ZDC/Calib/LaserCalib\n"); - else if(obj==3) printf("No file in \n ZDC/Calib/EMDCalib\n"); + if(obj==1) printf("No file in ZDC/Calib/Pedestal\n"); + else if(obj==2) printf("No file in ZDC/Calib/LaserCalib\n"); + else if(obj==3) printf("No file in ZDC/Calib/EnCalib\n"); return; } @@ -191,14 +194,14 @@ TMap* CreateDCSAliasMap() valueSet->SetOwner(1); TString aliasName = aliasNames[nAlias]; - printf("\n\n alias: %s\n\n",aliasName.Data()); + //printf("\n\n alias: %s\n\n",aliasName.Data()); Float_t simVal = (Float_t) (random.Rndm()*0.025+random.Rndm()*0.1); for(int i=0;i<3;i++) { int timeStamp1[3] = {0,500,1000}; AliDCSValue* dcsVal = new AliDCSValue(simVal, timeStamp1[i]); - printf("%s\n",dcsVal->ToString()); + //printf("%s\n",dcsVal->ToString()); valueSet->Add(dcsVal); } aliasMap->Add(new TObjString(aliasName), valueSet); @@ -240,13 +243,13 @@ TMap* CreateDCSAliasMap() valueSet->SetOwner(1); TString aliasName = aliasNames[nAlias]; - printf("\n\n alias: %s\n\n",aliasName.Data()); + //printf("\n\n alias: %s\n\n",aliasName.Data()); for(int timeStamp=0;timeStamp<=1000;timeStamp+=500) { Float_t simVal = (Float_t) (random.Gaus()*600.+1800.); AliDCSValue* dcsVal = new AliDCSValue(simVal, timeStamp); - printf("%s\n",dcsVal->ToString()); + //printf("%s\n",dcsVal->ToString()); valueSet->Add(dcsVal); } aliasMap->Add(new TObjString(aliasName), valueSet); diff --git a/ZDC/ZDCbaseLinkDef.h b/ZDC/ZDCbaseLinkDef.h index 1ffc1f3df70..8981181d30f 100644 --- a/ZDC/ZDCbaseLinkDef.h +++ b/ZDC/ZDCbaseLinkDef.h @@ -12,7 +12,8 @@ #pragma link C++ class AliZDCRawStream+; #pragma link C++ class AliZDCPedestals+; #pragma link C++ class AliZDCLaserCalib+; -#pragma link C++ class AliZDCCalib+; +#pragma link C++ class AliZDCEnCalib+; +#pragma link C++ class AliZDCTowerCalib+; #pragma link C++ class AliZDCMisAligner+; #pragma link C++ class AliZDCChMap+; #pragma link C++ class AliZDCDataDCS+; diff --git a/ZDC/ZDCsimLinkDef.h b/ZDC/ZDCsimLinkDef.h index 8d57cf9c257..b44afabd76f 100644 --- a/ZDC/ZDCsimLinkDef.h +++ b/ZDC/ZDCsimLinkDef.h @@ -21,5 +21,7 @@ #pragma link C++ class AliZDCQADataMakerSim+; #pragma link C++ class AliZDCTrigger+; +#pragma link C++ class AliZDCTriggerParameters+; +#pragma link C++ class AliZDCTriggerProcessor+; #endif diff --git a/ZDC/libZDCbase.pkg b/ZDC/libZDCbase.pkg index 49e7fd0ad86..8da766c3222 100644 --- a/ZDC/libZDCbase.pkg +++ b/ZDC/libZDCbase.pkg @@ -2,8 +2,8 @@ # $Id$ SRCS= AliZDCDigit.cxx AliZDCRawStream.cxx AliZDCPedestals.cxx\ - AliZDCLaserCalib.cxx AliZDCCalib.cxx AliZDCChMap.cxx\ - AliZDCMisAligner.cxx\ + AliZDCLaserCalib.cxx AliZDCEnCalib.cxx AliZDCTowerCalib.cxx \ + AliZDCChMap.cxx AliZDCMisAligner.cxx \ AliZDCDataDCS.cxx AliZDCPreprocessor.cxx AliZDCQAChecker.cxx HDRS= $(SRCS:.cxx=.h) diff --git a/ZDC/libZDCsim.pkg b/ZDC/libZDCsim.pkg index 8b30079864a..78fa8e816a2 100644 --- a/ZDC/libZDCsim.pkg +++ b/ZDC/libZDCsim.pkg @@ -1,9 +1,9 @@ #-*- Mode: Makefile -*- # $Id$ -SRCS= AliZDC.cxx AliZDCv3.cxx \ - AliZDCHit.cxx AliZDCSDigit.cxx AliZDCFragment.cxx AliZDCDigitizer.cxx \ - AliGenZDC.cxx AliZDCTrigger.cxx AliZDCQADataMakerSim.cxx +SRCS= AliZDC.cxx AliZDCv3.cxx AliGenZDC.cxx AliZDCFragment.cxx \ + AliZDCHit.cxx AliZDCSDigit.cxx AliZDCDigitizer.cxx AliZDCQADataMakerSim.cxx \ + AliZDCTrigger.cxx AliZDCTriggerParameters.cxx AliZDCTriggerProcessor.cxx HDRS= $(SRCS:.cxx=.h) -- 2.39.3