From 8812811557dbb35fa7ffdbeae10c0c2273588b27 Mon Sep 17 00:00:00 2001 From: prino Date: Mon, 4 Aug 2008 03:32:40 +0000 Subject: [PATCH] Restoring backward compatibility of the SSD calibration objects + output of the SSD DA in AMORE (Panos) --- ITS/AliITSBadChannelsSSD.cxx | 43 +---- ITS/AliITSBadChannelsSSD.h | 55 +++--- ITS/AliITSBadChannelsSSDv2.cxx | 62 +++++++ ITS/AliITSBadChannelsSSDv2.h | 49 ++++++ ITS/AliITSCalibrationSSD.h | 26 +-- ITS/AliITSDetTypeRec.cxx | 122 +++++++++++-- ITS/AliITSDetTypeRec.h | 12 +- ITS/AliITSDetTypeSim.cxx | 123 ++++++++++++- ITS/AliITSDetTypeSim.h | 12 ++ ITS/AliITSGainSSD.cxx | 34 +--- ITS/AliITSGainSSD.h | 60 +++---- ITS/AliITSGainSSDv2.cxx | 64 +++++++ ITS/AliITSGainSSDv2.h | 51 ++++++ ITS/AliITSHandleDaSSD.cxx | 38 ++-- ITS/AliITSHandleDaSSD.h | 12 +- ITS/AliITSNoiseSSD.cxx | 33 ++-- ITS/AliITSNoiseSSD.h | 57 +++--- ITS/AliITSNoiseSSDv2.cxx | 64 +++++++ ITS/AliITSNoiseSSDv2.h | 50 ++++++ ITS/AliITSPedestalSSD.cxx | 44 ++--- ITS/AliITSPedestalSSD.h | 59 ++++--- ITS/AliITSPedestalSSDv2.cxx | 66 +++++++ ITS/AliITSPedestalSSDv2.h | 49 ++++++ ITS/AliITSPreprocessorSSD.cxx | 24 +-- ITS/AliITSQASSDDataMakerRec.cxx | 163 ++++++++++++++++-- ITS/AliITSQASSDDataMakerRec.h | 11 +- .../BadChannelsSSD/Run0_999999999_v0_s0.root | Bin 13737 -> 13773 bytes ITS/Calib/GainSSD/Run0_999999999_v0_s0.root | Bin 29347 -> 29391 bytes ITS/Calib/NoiseSSD/Run0_999999999_v0_s0.root | Bin 62241 -> 62282 bytes ITS/ITSbaseLinkDef.h | 4 + ITS/libITSbase.pkg | 4 + 31 files changed, 1071 insertions(+), 320 deletions(-) create mode 100644 ITS/AliITSBadChannelsSSDv2.cxx create mode 100644 ITS/AliITSBadChannelsSSDv2.h create mode 100644 ITS/AliITSGainSSDv2.cxx create mode 100644 ITS/AliITSGainSSDv2.h create mode 100644 ITS/AliITSNoiseSSDv2.cxx create mode 100644 ITS/AliITSNoiseSSDv2.h create mode 100644 ITS/AliITSPedestalSSDv2.cxx create mode 100644 ITS/AliITSPedestalSSDv2.h diff --git a/ITS/AliITSBadChannelsSSD.cxx b/ITS/AliITSBadChannelsSSD.cxx index eba5cb74904..b92ceb2cc9a 100644 --- a/ITS/AliITSBadChannelsSSD.cxx +++ b/ITS/AliITSBadChannelsSSD.cxx @@ -1,6 +1,6 @@ /************************************************************************** * 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. * * * @@ -15,48 +15,21 @@ #include "AliITSBadChannelsSSD.h" -#include - -////////////////////////////////////////////////////// -// Author: Enrico Fragiacomo -// Date: 23/08/2007 -// Modified: 08/07/2008 -// // -////////////////////////////////////////////////////// - -//const Int_t AliITSBadChannelsSSD::fgkDefaultNModulesSSD = 1698; -//const Int_t AliITSBadChannelsSSD::fgkDefaultNStripsSSD = 768; ClassImp(AliITSBadChannelsSSD) - -//______________________________________________________________________ - AliITSBadChannelsSSD::AliITSBadChannelsSSD() - // Default Constructor -{ - for(Int_t i=0; i<2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD; i++) - fBadChannels[i]=0; - } //______________________________________________________________________ -AliITSBadChannelsSSD::AliITSBadChannelsSSD(const AliITSBadChannelsSSD &source): - TObject(source) -{ - // copy Constructor - memcpy(fBadChannels,source.fBadChannels, - 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Char_t)); +AliITSBadChannelsSSD::AliITSBadChannelsSSD(): +fMod(0), +fBadNChannelsList(0), +fBadPChannelsList(0){ + // Default Constructor + } //______________________________________________________________________ AliITSBadChannelsSSD::~AliITSBadChannelsSSD(){ // destructor -} -//______________________________________________________________________ -AliITSBadChannelsSSD& AliITSBadChannelsSSD::operator=(const AliITSBadChannelsSSD &source) { - // ass. op. - if (this == &source)return *this; - memcpy(fBadChannels,source.fBadChannels, - 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Char_t)); - - return *this; } + diff --git a/ITS/AliITSBadChannelsSSD.h b/ITS/AliITSBadChannelsSSD.h index a3f72582279..0a432264776 100644 --- a/ITS/AliITSBadChannelsSSD.h +++ b/ITS/AliITSBadChannelsSSD.h @@ -1,49 +1,44 @@ #ifndef ALIITSBADCHANNELSSSD_H #define ALIITSBADCHANNELSSSD_H +#include "TObjArray.h" +#include "TArrayI.h" + ////////////////////////////////////////////// -// Author: Enrico Fragiacomo -// Date: 23/08/2007 -// Modified: 08/07/2008 +// Response class for SSD // // // ////////////////////////////////////////////// -#include "TObject.h" - class AliITSBadChannelsSSD : public TObject { public: - AliITSBadChannelsSSD(); virtual ~AliITSBadChannelsSSD(); - AliITSBadChannelsSSD(const AliITSBadChannelsSSD &source); // copy constructor - AliITSBadChannelsSSD& operator=(const AliITSBadChannelsSSD &source); // ass. op. - void AddBadChannelP(Int_t module, Int_t strip, Char_t value) { - fBadChannels[module*2*fgkDefaultNStripsSSD+strip] = value; - } - Char_t GetBadChannelP(Int_t module, Int_t strip) { - return fBadChannels[module*2*fgkDefaultNStripsSSD+strip]; - } + void SetNBadPChannelsList(Int_t n) { fBadPChannelsList.Set(n); } + void AddBadPChannel(Int_t c, Int_t n) { fBadPChannelsList.AddAt(n,c);} + TArrayI GetBadPChannelsList() const {return fBadPChannelsList; } + Int_t GetBadPChannel(Int_t n) {return fBadPChannelsList.At(n); } + void SetNBadNChannelsList(Int_t n) { fBadNChannelsList.Set(n); } + void AddBadNChannel(Int_t c, Int_t n) { fBadNChannelsList.AddAt(n,c);} + TArrayI GetBadNChannelsList() const {return fBadNChannelsList; } + Int_t GetBadNChannel(Int_t n) {return fBadNChannelsList.At(n); } + // - void AddBadChannelN(Int_t module, Int_t strip, Char_t value) { - fBadChannels[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip] = value; - } - Char_t GetBadChannelN(Int_t module, Int_t strip) { - return fBadChannels[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip]; - } + void SetMod(UShort_t mod) {fMod = mod;} + UShort_t GetMod() { return fMod;} protected: - static const Int_t fgkDefaultNModulesSSD = 1698; - static const Int_t fgkDefaultNStripsSSD = 768; - //static const Int_t fgkDefaultNModulesSSD; // Total numbers of SSD modules - // static const Int_t fgkDefaultNStripsSSD; // Total numbers of SSD modules - Char_t fBadChannels[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD]; - // Char_t *fBadChannels; - + UShort_t fMod; // module number (from 0 to 1535). Needed by the preprocessor to + // extract the information from the Detector Algorithm + + TArrayI fBadNChannelsList; // list of P side dead channels + TArrayI fBadPChannelsList; // list of N side dead channels + private: - - ClassDef(AliITSBadChannelsSSD,2) // BadChannels class for SSD - }; + AliITSBadChannelsSSD(const AliITSBadChannelsSSD &source); // copy constructor + AliITSBadChannelsSSD& operator=(const AliITSBadChannelsSSD &source); // ass. op. + ClassDef(AliITSBadChannelsSSD,1) //Response class for SSD +}; #endif diff --git a/ITS/AliITSBadChannelsSSDv2.cxx b/ITS/AliITSBadChannelsSSDv2.cxx new file mode 100644 index 00000000000..941d192b2d2 --- /dev/null +++ b/ITS/AliITSBadChannelsSSDv2.cxx @@ -0,0 +1,62 @@ +/************************************************************************** + * 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. * + **************************************************************************/ + + +#include "AliITSBadChannelsSSDv2.h" +#include + +////////////////////////////////////////////////////// +// Author: Enrico Fragiacomo +// Date: 23/08/2007 +// Modified: 08/07/2008 +// // +////////////////////////////////////////////////////// + +//const Int_t AliITSBadChannelsSSD::fgkDefaultNModulesSSD = 1698; +//const Int_t AliITSBadChannelsSSD::fgkDefaultNStripsSSD = 768; + +ClassImp(AliITSBadChannelsSSDv2) + +//______________________________________________________________________ + AliITSBadChannelsSSDv2::AliITSBadChannelsSSDv2() + // Default Constructor +{ + for(Int_t i=0; i<2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD; i++) + fBadChannels[i]=0; + } + +//______________________________________________________________________ +AliITSBadChannelsSSDv2::AliITSBadChannelsSSDv2(const AliITSBadChannelsSSDv2 &source): + TObject(source) +{ + // copy Constructor + memcpy(fBadChannels,source.fBadChannels, + 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Char_t)); +} + +//______________________________________________________________________ +AliITSBadChannelsSSDv2::~AliITSBadChannelsSSDv2(){ + // destructor +} + +//______________________________________________________________________ +AliITSBadChannelsSSDv2& AliITSBadChannelsSSDv2::operator=(const AliITSBadChannelsSSDv2 &source) { + // ass. op. + if (this == &source)return *this; + memcpy(fBadChannels,source.fBadChannels, + 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Char_t)); + + return *this; +} diff --git a/ITS/AliITSBadChannelsSSDv2.h b/ITS/AliITSBadChannelsSSDv2.h new file mode 100644 index 00000000000..ce0e5a01918 --- /dev/null +++ b/ITS/AliITSBadChannelsSSDv2.h @@ -0,0 +1,49 @@ +#ifndef ALIITSBADCHANNELSSSDV2_H +#define ALIITSBADCHANNELSSSDV2_H + +////////////////////////////////////////////// +// Author: Enrico Fragiacomo +// Date: 23/08/2007 +// Modified: 08/07/2008 +// // +////////////////////////////////////////////// +#include "TObject.h" + +class AliITSBadChannelsSSDv2 : public TObject { + + public: + + AliITSBadChannelsSSDv2(); + virtual ~AliITSBadChannelsSSDv2(); + AliITSBadChannelsSSDv2(const AliITSBadChannelsSSDv2 &source); // copy constructor + AliITSBadChannelsSSDv2& operator=(const AliITSBadChannelsSSDv2 &source); // ass. op. + + void AddBadChannelP(Int_t module, Int_t strip, Char_t value) { + fBadChannels[module*2*fgkDefaultNStripsSSD+strip] = value; + } + Char_t GetBadChannelP(Int_t module, Int_t strip) { + return fBadChannels[module*2*fgkDefaultNStripsSSD+strip]; + } + + void AddBadChannelN(Int_t module, Int_t strip, Char_t value) { + fBadChannels[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip] = value; + } + Char_t GetBadChannelN(Int_t module, Int_t strip) { + return fBadChannels[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip]; + } + + protected: + + static const Int_t fgkDefaultNModulesSSD = 1698; + static const Int_t fgkDefaultNStripsSSD = 768; + //static const Int_t fgkDefaultNModulesSSD; // Total numbers of SSD modules + // static const Int_t fgkDefaultNStripsSSD; // Total numbers of SSD modules + Char_t fBadChannels[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD]; + // Char_t *fBadChannels; + + private: + + ClassDef(AliITSBadChannelsSSDv2,1) // BadChannels class for SSD + }; + +#endif diff --git a/ITS/AliITSCalibrationSSD.h b/ITS/AliITSCalibrationSSD.h index a7387dbf305..403ec7f6471 100644 --- a/ITS/AliITSCalibrationSSD.h +++ b/ITS/AliITSCalibrationSSD.h @@ -3,10 +3,10 @@ /* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. * * See cxx source for full Copyright notice */ #include "AliITSCalibration.h" -#include "AliITSNoiseSSD.h" -#include "AliITSPedestalSSD.h" -#include "AliITSGainSSD.h" -#include "AliITSBadChannelsSSD.h" +#include "AliITSNoiseSSDv2.h" +#include "AliITSPedestalSSDv2.h" +#include "AliITSGainSSDv2.h" +#include "AliITSBadChannelsSSDv2.h" #include "AliITSresponseSSD.h" #include "TArrayF.h" #include "TArrayI.h" @@ -31,17 +31,17 @@ class AliITSCalibrationSSD : public AliITSCalibration { Float_t GetNoiseP(Int_t n) {return fNoise->GetNoiseP(fModule,n); } Float_t GetNoiseN(Int_t n) {return fNoise->GetNoiseN(fModule,n); } - void SetNoise( AliITSNoiseSSD* noise) {fNoise=noise;} + void SetNoise( AliITSNoiseSSDv2* noise) {fNoise=noise;} Float_t GetPedestalP(Int_t n) {return fPedestal->GetPedestalP(fModule,n); } Float_t GetPedestalN(Int_t n) {return fPedestal->GetPedestalN(fModule,n); } - void SetPedestal( AliITSPedestalSSD* pedestal) {fPedestal=pedestal;} + void SetPedestal( AliITSPedestalSSDv2* pedestal) {fPedestal=pedestal;} Float_t GetGainP(Int_t n) {return fGain->GetGainP(fModule,n); } Float_t GetGainN(Int_t n) {return fGain->GetGainN(fModule,n); } void SetGainP(Int_t n, Float_t value) {fGain->AddGainP(fModule,n,value);} void SetGainN(Int_t n, Float_t value) {fGain->AddGainN(fModule,n,value);} - void SetGain( AliITSGainSSD* gain) {fGain=gain;} + void SetGain( AliITSGainSSDv2* gain) {fGain=gain;} void SetBad() { fIsBad = kTRUE; @@ -58,7 +58,7 @@ class AliITSCalibrationSSD : public AliITSCalibration { Int_t ChipsPerModule() const{return fgkChipsPerModule;} // # chips/module Int_t ChannelsPerChip() const{ return fgkChannelsPerChip;}// #channels/chip - void SetBadChannels( AliITSBadChannelsSSD* badchannels) { + void SetBadChannels( AliITSBadChannelsSSDv2* badchannels) { fBadChannels=badchannels;} Char_t GetBadPChannel(Int_t n) { return fBadChannels->GetBadChannelP(fModule,n); } @@ -127,10 +127,10 @@ protected: Int_t fNPar; // Number of detector param Double_t *fDetPar; //[fNPar] Array of parameters - AliITSNoiseSSD *fNoise; - AliITSPedestalSSD *fPedestal; - AliITSGainSSD *fGain; - AliITSBadChannelsSSD *fBadChannels; + AliITSNoiseSSDv2 *fNoise; + AliITSPedestalSSDv2 *fPedestal; + AliITSGainSSDv2 *fGain; + AliITSBadChannelsSSDv2 *fBadChannels; Bool_t fIsBad; // module is dead or alive ? Bool_t fIsChipBad[fgkChipsPerModule]; // chip is dead or alive ? @@ -139,6 +139,6 @@ protected: AliITSCalibrationSSD(const AliITSCalibrationSSD &source); // copy constructor AliITSCalibrationSSD& operator=(const AliITSCalibrationSSD &source); // ass. op. - ClassDef(AliITSCalibrationSSD,3) //Response class for SSD + ClassDef(AliITSCalibrationSSD,4) //Response class for SSD }; #endif diff --git a/ITS/AliITSDetTypeRec.cxx b/ITS/AliITSDetTypeRec.cxx index 898e943ebf8..d2c61287c17 100644 --- a/ITS/AliITSDetTypeRec.cxx +++ b/ITS/AliITSDetTypeRec.cxx @@ -50,10 +50,12 @@ #include "AliITSDriftSpeedArraySDD.h" #include "AliITSDriftSpeedSDD.h" #include "AliITSCalibrationSSD.h" +#include "AliITSNoiseSSDv2.h" +#include "AliITSGainSSDv2.h" +#include "AliITSBadChannelsSSDv2.h" #include "AliITSNoiseSSD.h" #include "AliITSGainSSD.h" #include "AliITSBadChannelsSSD.h" -#include "AliITSPedestalSSD.h" #include "AliITSsegmentationSPD.h" #include "AliITSsegmentationSDD.h" #include "AliITSsegmentationSSD.h" @@ -450,7 +452,6 @@ Bool_t AliITSDetTypeRec::GetCalibration() { // AliCDBEntry *entrySSD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSSD"); AliCDBEntry *entryNoiseSSD = AliCDBManager::Instance()->Get("ITS/Calib/NoiseSSD"); - AliCDBEntry *entryPedestalSSD = AliCDBManager::Instance()->Get("ITS/Calib/PedestalSSD"); AliCDBEntry *entryGainSSD = AliCDBManager::Instance()->Get("ITS/Calib/GainSSD"); AliCDBEntry *entryBadChannelsSSD = AliCDBManager::Instance()->Get("ITS/Calib/BadChannelsSSD"); AliCDBEntry *entry2SPD = AliCDBManager::Instance()->Get("ITS/Calib/RespSPD"); @@ -462,7 +463,7 @@ Bool_t AliITSDetTypeRec::GetCalibration() { AliCDBEntry *mapTSDD = AliCDBManager::Instance()->Get("ITS/Calib/MapsTimeSDD"); if(!entrySPD || !deadSPD || !entrySDD || !entryNoiseSSD || !entryGainSSD || - !entryPedestalSSD || !entryBadChannelsSSD || + !entryBadChannelsSSD || !entry2SPD || !entry2SDD || !entry2SSD || !drSpSDD || !ddlMapSDD || !mapASDD || !mapTSDD ){ AliFatal("Calibration object retrieval failed! "); return kFALSE; @@ -504,21 +505,40 @@ Bool_t AliITSDetTypeRec::GetCalibration() { if(!cacheStatus)mapTSDD->SetObject(NULL); mapTSDD->SetOwner(kTRUE); - AliITSNoiseSSD *noiseSSD = (AliITSNoiseSSD *)entryNoiseSSD->GetObject(); + TObject *emptyssd = 0; TString ssdobjectname = 0; + AliITSNoiseSSDv2 *noiseSSD = new AliITSNoiseSSDv2(); + emptyssd = (TObject *)entryNoiseSSD->GetObject(); + ssdobjectname = emptyssd->GetName(); + if(ssdobjectname=="TObjArray") { + TObjArray *noiseSSDOld = (TObjArray *)entryNoiseSSD->GetObject(); + ReadOldSSDNoise(noiseSSDOld, noiseSSD); + } + else if(ssdobjectname=="AliITSNoiseSSDv2") + noiseSSD = (AliITSNoiseSSDv2 *)entryNoiseSSD->GetObject(); if(!cacheStatus)entryNoiseSSD->SetObject(NULL); entryNoiseSSD->SetOwner(kTRUE); - AliITSPedestalSSD *pedestalSSD = - (AliITSPedestalSSD*)entryPedestalSSD->GetObject(); - if(!cacheStatus)entryPedestalSSD->SetObject(NULL); - entryPedestalSSD->SetOwner(kTRUE); - - AliITSGainSSD *gainSSD = (AliITSGainSSD *)entryGainSSD->GetObject(); + AliITSGainSSDv2 *gainSSD = new AliITSGainSSDv2(); + emptyssd = (TObject *)entryGainSSD->GetObject(); + ssdobjectname = emptyssd->GetName(); + if(ssdobjectname=="Gain") { + TObjArray *gainSSDOld = (TObjArray *)entryGainSSD->GetObject(); + ReadOldSSDGain(gainSSDOld, gainSSD); + } + else if(ssdobjectname=="AliITSGainSSDv2") + gainSSD = (AliITSGainSSDv2 *)entryGainSSD->GetObject(); if(!cacheStatus)entryGainSSD->SetObject(NULL); entryGainSSD->SetOwner(kTRUE); - AliITSBadChannelsSSD *badchannelsSSD = - (AliITSBadChannelsSSD*)entryBadChannelsSSD->GetObject(); + AliITSBadChannelsSSDv2 *badChannelsSSD = new AliITSBadChannelsSSDv2(); + emptyssd = (TObject *)entryBadChannelsSSD->GetObject(); + ssdobjectname = emptyssd->GetName(); + if(ssdobjectname=="TObjArray") { + TObjArray *badChannelsSSDOld = (TObjArray *)entryBadChannelsSSD->GetObject(); + ReadOldSSDBadChannels(badChannelsSSDOld, badChannelsSSD); + } + else if(ssdobjectname=="AliITSBadChannelsSSDv2") + badChannelsSSD = (AliITSBadChannelsSSDv2*)entryBadChannelsSSD->GetObject(); if(!cacheStatus)entryBadChannelsSSD->SetObject(NULL); entryBadChannelsSSD->SetOwner(kTRUE); @@ -532,7 +552,6 @@ Bool_t AliITSDetTypeRec::GetCalibration() { delete deadSPD; delete entrySDD; delete entryNoiseSSD; - delete entryPedestalSSD; delete entryGainSSD; delete entryBadChannelsSSD; delete entry2SPD; @@ -545,7 +564,7 @@ Bool_t AliITSDetTypeRec::GetCalibration() { } if ((!pSPD)||(!pSDD)||(!pSSD) || (!calSPD) || (!caldeadSPD) ||(!calSDD) || (!drSp) || (!ddlsdd) - || (!mapAn) || (!mapT) || (!noiseSSD)|| (!gainSSD)|| (!badchannelsSSD)) { + || (!mapAn) || (!mapT) || (!noiseSSD)|| (!gainSSD)|| (!badChannelsSSD)) { AliWarning("Can not get calibration from calibration database !"); return kFALSE; } @@ -592,9 +611,8 @@ Bool_t AliITSDetTypeRec::GetCalibration() { fSSDCalibration->SetResponse((AliITSresponse*)pSSD); fSSDCalibration->SetNoise(noiseSSD); - fSSDCalibration->SetPedestal(pedestalSSD); fSSDCalibration->SetGain(gainSSD); - fSSDCalibration->SetBadChannels(badchannelsSSD); + fSSDCalibration->SetBadChannels(badChannelsSSD); //fSSDCalibration->FillBadChipMap(); @@ -972,4 +990,76 @@ void AliITSDetTypeRec::DigitsToRecPoints(AliRawReader* rawReader,TTree *treeR,Op } +//______________________________________________________________________ +void AliITSDetTypeRec::ReadOldSSDNoise(TObjArray *array, + AliITSNoiseSSDv2 *noiseSSD) { + //Reads the old SSD calibration object and converts it to the new format + const Int_t fgkSSDSTRIPSPERMODULE = 1536; + const Int_t fgkSSDPSIDESTRIPSPERMODULE = 768; + + Int_t fNMod = array->GetEntries(); + cout<<"Converting old calibration object for noise..."<At(iModule)); + for(Int_t iStrip = 0; iStrip < fgkSSDSTRIPSPERMODULE; iStrip++) { + noise = (iStrip < fgkSSDPSIDESTRIPSPERMODULE) ? noiseModule->GetNoiseP(iStrip) : noiseModule->GetNoiseN(1535 - iStrip); + if(iStrip < fgkSSDPSIDESTRIPSPERMODULE) + noiseSSD->AddNoiseP(iModule,iStrip,noise); + if(iStrip >= fgkSSDPSIDESTRIPSPERMODULE) + noiseSSD->AddNoiseN(iModule,1535 - iStrip,noise); + }//loop over strips + }//loop over modules +} + +//______________________________________________________________________ +void AliITSDetTypeRec::ReadOldSSDBadChannels(TObjArray *array, + AliITSBadChannelsSSDv2 *badChannelsSSD) { + //Reads the old SSD calibration object and converts it to the new format + Int_t fNMod = array->GetEntries(); + cout<<"Converting old calibration object for bad channels..."<At(iModule)); + TArrayI arrayPSide = bad->GetBadPChannelsList(); + for(Int_t iPCounter = 0; iPCounter < arrayPSide.GetSize(); iPCounter++) + badChannelsSSD->AddBadChannelP(iModule, + iPCounter, + (Char_t)arrayPSide.At(iPCounter)); + + TArrayI arrayNSide = bad->GetBadNChannelsList(); + for(Int_t iNCounter = 0; iNCounter < arrayNSide.GetSize(); iNCounter++) + badChannelsSSD->AddBadChannelN(iModule, + iNCounter, + (Char_t)arrayNSide.At(iNCounter)); + + }//loop over modules +} + +//______________________________________________________________________ +void AliITSDetTypeRec::ReadOldSSDGain(TObjArray *array, + AliITSGainSSDv2 *gainSSD) { + //Reads the old SSD calibration object and converts it to the new format + + Int_t fNMod = array->GetEntries(); + cout<<"Converting old calibration object for gain..."<At(iModule)); + TArrayF arrayPSide = gainModule->GetGainP(); + for(Int_t iPCounter = 0; iPCounter < arrayPSide.GetSize(); iPCounter++) + gainSSD->AddGainP(iModule, + iPCounter, + arrayPSide.At(iPCounter)); + TArrayF arrayNSide = gainModule->GetGainN(); + for(Int_t iNCounter = 0; iNCounter < arrayNSide.GetSize(); iNCounter++) + gainSSD->AddGainN(iModule, + iNCounter, + arrayNSide.At(iNCounter)); + }//loop over modules +} + diff --git a/ITS/AliITSDetTypeRec.h b/ITS/AliITSDetTypeRec.h index b158856ce1c..593fc613dfc 100644 --- a/ITS/AliITSDetTypeRec.h +++ b/ITS/AliITSDetTypeRec.h @@ -31,7 +31,9 @@ class AliITSClusterFinder; class AliITSRawCluster; class AliITSRecPoint; class AliRawReader; - +class AliITSGainSSDv2; +class AliITSBadChannelsSSDv2; +class AliITSNoiseSSDv2; class AliITSDetTypeRec : public TObject { public: @@ -101,6 +103,14 @@ class AliITSDetTypeRec : public TObject { AliITSDetTypeRec(const AliITSDetTypeRec& rec); AliITSDetTypeRec& operator=(const AliITSDetTypeRec &source); + //conversion of the old SSD calibration objects tothe new ones + void ReadOldSSDNoise(TObjArray *array, + AliITSNoiseSSDv2 *noiseSSD); + void ReadOldSSDBadChannels(TObjArray *array, + AliITSBadChannelsSSDv2 *badChannelsSSD); + void ReadOldSSDGain(TObjArray *array, + AliITSGainSSDv2 *gainSSD); + // virtual void SetLoader(AliITSLoader* loader) {fLoader=loader;} static const Int_t fgkNdettypes; // number of det. types static const Int_t fgkDefaultNModulesSPD; // Total numbers of SPD modules by default diff --git a/ITS/AliITSDetTypeSim.cxx b/ITS/AliITSDetTypeSim.cxx index 75186f84256..38bb6210ebf 100644 --- a/ITS/AliITSDetTypeSim.cxx +++ b/ITS/AliITSDetTypeSim.cxx @@ -47,6 +47,9 @@ #include "AliITSDriftSpeedArraySDD.h" #include "AliITSDriftSpeedSDD.h" #include "AliITSCalibrationSSD.h" +#include "AliITSNoiseSSDv2.h" +#include "AliITSGainSSDv2.h" +#include "AliITSBadChannelsSSDv2.h" #include "AliITSNoiseSSD.h" #include "AliITSGainSSD.h" #include "AliITSBadChannelsSSD.h" @@ -487,19 +490,56 @@ Bool_t AliITSDetTypeSim::GetCalibration() { entrySSD->SetOwner(kTRUE); */ - AliITSNoiseSSD *noiseSSD = (AliITSNoiseSSD *)entryNoiseSSD->GetObject(); + TObject *emptyssd = 0; TString ssdobjectname = 0; + AliITSNoiseSSDv2 *noiseSSD = new AliITSNoiseSSDv2(); + emptyssd = (TObject *)entryNoiseSSD->GetObject(); + ssdobjectname = emptyssd->GetName(); + if(ssdobjectname=="TObjArray") { + TObjArray *noiseSSDOld = (TObjArray *)entryNoiseSSD->GetObject(); + ReadOldSSDNoise(noiseSSDOld, noiseSSD); + } + else if(ssdobjectname=="AliITSNoiseSSDv2") + noiseSSD = (AliITSNoiseSSDv2 *)entryNoiseSSD->GetObject(); if(!isCacheActive)entryNoiseSSD->SetObject(NULL); entryNoiseSSD->SetOwner(kTRUE); - AliITSGainSSD *gainSSD = (AliITSGainSSD *)entryGainSSD->GetObject(); + AliITSGainSSDv2 *gainSSD = new AliITSGainSSDv2(); + emptyssd = (TObject *)entryGainSSD->GetObject(); + ssdobjectname = emptyssd->GetName(); + if(ssdobjectname=="Gain") { + TObjArray *gainSSDOld = (TObjArray *)entryGainSSD->GetObject(); + ReadOldSSDGain(gainSSDOld, gainSSD); + } + else if(ssdobjectname=="AliITSGainSSDv2") + gainSSD = (AliITSGainSSDv2 *)entryGainSSD->GetObject(); if(!isCacheActive)entryGainSSD->SetObject(NULL); entryGainSSD->SetOwner(kTRUE); - AliITSBadChannelsSSD *badchannelsSSD = - (AliITSBadChannelsSSD *)entryBadChannelsSSD->GetObject(); + AliITSBadChannelsSSDv2 *badChannelsSSD = new AliITSBadChannelsSSDv2(); + emptyssd = (TObject *)entryBadChannelsSSD->GetObject(); + ssdobjectname = emptyssd->GetName(); + if(ssdobjectname=="TObjArray") { + TObjArray *badChannelsSSDOld = (TObjArray *)entryBadChannelsSSD->GetObject(); + ReadOldSSDBadChannels(badChannelsSSDOld, badChannelsSSD); + } + else if(ssdobjectname=="AliITSBadChannelsSSDv2") + badChannelsSSD = (AliITSBadChannelsSSDv2*)entryBadChannelsSSD->GetObject(); if(!isCacheActive)entryBadChannelsSSD->SetObject(NULL); entryBadChannelsSSD->SetOwner(kTRUE); + /*AliITSNoiseSSDv2 *noiseSSD = (AliITSNoiseSSDv2 *)entryNoiseSSD->GetObject(); + if(!isCacheActive)entryNoiseSSD->SetObject(NULL); + entryNoiseSSD->SetOwner(kTRUE); + + AliITSGainSSDv2 *gainSSD = (AliITSGainSSDv2 *)entryGainSSD->GetObject(); + if(!isCacheActive)entryGainSSD->SetObject(NULL); + entryGainSSD->SetOwner(kTRUE); + + AliITSBadChannelsSSDv2 *badchannelsSSD = + (AliITSBadChannelsSSDv2 *)entryBadChannelsSSD->GetObject(); + if(!isCacheActive)entryBadChannelsSSD->SetObject(NULL); + entryBadChannelsSSD->SetOwner(kTRUE);*/ + AliITSresponseSSD *pSSD = (AliITSresponseSSD*)entry2SSD->GetObject(); if(!isCacheActive)entry2SSD->SetObject(NULL); entry2SSD->SetOwner(kTRUE); @@ -522,7 +562,7 @@ Bool_t AliITSDetTypeSim::GetCalibration() { AliCDBManager::Instance()->SetCacheFlag(origCacheStatus); if ((!pSPD)||(!pSSD) || (!calSPD) || (!calSDD) || (!drSp) || (!ddlsdd) - || (!mapAn) || (!mapT) || (!noiseSSD)|| (!gainSSD)|| (!badchannelsSSD)) { + || (!mapAn) || (!mapT) || (!noiseSSD)|| (!gainSSD)|| (!badChannelsSSD)) { AliWarning("Can not get calibration from calibration database !"); return kFALSE; } @@ -578,7 +618,7 @@ Bool_t AliITSDetTypeSim::GetCalibration() { fSSDCalibration->SetResponse((AliITSresponse*)pSSD); fSSDCalibration->SetNoise(noiseSSD); fSSDCalibration->SetGain(gainSSD); - fSSDCalibration->SetBadChannels(badchannelsSSD); + fSSDCalibration->SetBadChannels(badChannelsSSD); //fSSDCalibration->FillBadChipMap(); @@ -873,4 +913,75 @@ void AliITSDetTypeSim::StoreCalibration(Int_t firstRun, Int_t lastRun, AliCDBManager::Instance()->Put(&respSSD, idRespSSD, &md); } +//______________________________________________________________________ +void AliITSDetTypeSim::ReadOldSSDNoise(TObjArray *array, + AliITSNoiseSSDv2 *noiseSSD) { + //Reads the old SSD calibration object and converts it to the new format + const Int_t fgkSSDSTRIPSPERMODULE = 1536; + const Int_t fgkSSDPSIDESTRIPSPERMODULE = 768; + + Int_t fNMod = array->GetEntries(); + cout<<"Converting old calibration object for noise..."<At(iModule)); + for(Int_t iStrip = 0; iStrip < fgkSSDSTRIPSPERMODULE; iStrip++) { + noise = (iStrip < fgkSSDPSIDESTRIPSPERMODULE) ? noiseModule->GetNoiseP(iStrip) : noiseModule->GetNoiseN(1535 - iStrip); + if(iStrip < fgkSSDPSIDESTRIPSPERMODULE) + noiseSSD->AddNoiseP(iModule,iStrip,noise); + if(iStrip >= fgkSSDPSIDESTRIPSPERMODULE) + noiseSSD->AddNoiseN(iModule,1535 - iStrip,noise); + }//loop over strips + }//loop over modules +} + +//______________________________________________________________________ +void AliITSDetTypeSim::ReadOldSSDBadChannels(TObjArray *array, + AliITSBadChannelsSSDv2 *badChannelsSSD) { + //Reads the old SSD calibration object and converts it to the new format + Int_t fNMod = array->GetEntries(); + cout<<"Converting old calibration object for bad channels..."<At(iModule)); + TArrayI arrayPSide = bad->GetBadPChannelsList(); + for(Int_t iPCounter = 0; iPCounter < arrayPSide.GetSize(); iPCounter++) + badChannelsSSD->AddBadChannelP(iModule, + iPCounter, + (Char_t)arrayPSide.At(iPCounter)); + + TArrayI arrayNSide = bad->GetBadNChannelsList(); + for(Int_t iNCounter = 0; iNCounter < arrayNSide.GetSize(); iNCounter++) + badChannelsSSD->AddBadChannelN(iModule, + iNCounter, + (Char_t)arrayNSide.At(iNCounter)); + + }//loop over modules +} + +//______________________________________________________________________ +void AliITSDetTypeSim::ReadOldSSDGain(TObjArray *array, + AliITSGainSSDv2 *gainSSD) { + //Reads the old SSD calibration object and converts it to the new format + + Int_t fNMod = array->GetEntries(); + cout<<"Converting old calibration object for gain..."<At(iModule)); + TArrayF arrayPSide = gainModule->GetGainP(); + for(Int_t iPCounter = 0; iPCounter < arrayPSide.GetSize(); iPCounter++) + gainSSD->AddGainP(iModule, + iPCounter, + arrayPSide.At(iPCounter)); + TArrayF arrayNSide = gainModule->GetGainN(); + for(Int_t iNCounter = 0; iNCounter < arrayNSide.GetSize(); iNCounter++) + gainSSD->AddGainN(iModule, + iNCounter, + arrayNSide.At(iNCounter)); + }//loop over modules +} diff --git a/ITS/AliITSDetTypeSim.h b/ITS/AliITSDetTypeSim.h index 446e947b772..d9285f9afca 100644 --- a/ITS/AliITSDetTypeSim.h +++ b/ITS/AliITSDetTypeSim.h @@ -30,6 +30,9 @@ class AliITSsimulation; class AliITSsegmentation; class AliITSresponse; class AliITSCalibrationSSD; +class AliITSGainSSDv2; +class AliITSBadChannelsSSDv2; +class AliITSNoiseSSDv2; class AliITSDetTypeSim : public TObject { public: @@ -106,6 +109,15 @@ class AliITSDetTypeSim : public TObject { private: void SetDefaultSegmentation(Int_t idet); // creates def segm. + + //conversion of the old SSD calibration objects tothe new ones + void ReadOldSSDNoise(TObjArray *array, + AliITSNoiseSSDv2 *noiseSSD); + void ReadOldSSDBadChannels(TObjArray *array, + AliITSBadChannelsSSDv2 *badChannelsSSD); + void ReadOldSSDGain(TObjArray *array, + AliITSGainSSDv2 *gainSSD); + static const Int_t fgkNdettypes; // number of different det. types static const Int_t fgkDefaultNModulesSPD; // Total numbers of SPD modules by default static const Int_t fgkDefaultNModulesSDD; // Total numbers of SDD modules by default diff --git a/ITS/AliITSGainSSD.cxx b/ITS/AliITSGainSSD.cxx index d7dbddb85f3..aa850ade1ec 100644 --- a/ITS/AliITSGainSSD.cxx +++ b/ITS/AliITSGainSSD.cxx @@ -15,35 +15,21 @@ #include "AliITSGainSSD.h" -#include ////////////////////////////////////////////////////// // Author: Enrico Fragiacomo // Date: 23/08/2007 -// Modified: 08/07/2008 // // ////////////////////////////////////////////////////// -//const Int_t AliITSGainSSD::fgkDefaultNModulesSSD = 1698; -//const Int_t AliITSGainSSD::fgkDefaultNStripsSSD = 768; - ClassImp(AliITSGainSSD) - -//______________________________________________________________________ - AliITSGainSSD::AliITSGainSSD() -{ - // Default Constructor - for(Int_t i=0; i<2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD; i++) - fGain[i]=0; -} //______________________________________________________________________ -AliITSGainSSD::AliITSGainSSD(const AliITSGainSSD &source): - TObject(source) -{ - // copy Constructor - memcpy(fGain,source.fGain, - 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(UShort_t)); +AliITSGainSSD::AliITSGainSSD(): +fMod(0), +fGainP(0), +fGainN(0) { + // Default Constructor } //______________________________________________________________________ @@ -52,13 +38,3 @@ AliITSGainSSD::~AliITSGainSSD(){ } -//______________________________________________________________________ -AliITSGainSSD& AliITSGainSSD::operator=(const AliITSGainSSD &source) { - // ass. op. - if (this == &source)return *this; - - memcpy(fGain,source.fGain, - 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(UShort_t)); - - return *this; -} diff --git a/ITS/AliITSGainSSD.h b/ITS/AliITSGainSSD.h index ce685aa0a6b..9291347a440 100644 --- a/ITS/AliITSGainSSD.h +++ b/ITS/AliITSGainSSD.h @@ -1,51 +1,45 @@ #ifndef ALIITSGAINSSD_H #define ALIITSGAINSSD_H +#include "TObjArray.h" +#include "TArrayF.h" + ////////////////////////////////////////////// // Author: Enrico Fragiacomo // Date: 23/08/2007 -// Modified: 08/07/2008 // // ////////////////////////////////////////////// -#include "TObject.h" - class AliITSGainSSD : public TObject { public: AliITSGainSSD(); virtual ~AliITSGainSSD(); + + void SetNGainP(Int_t n) { fGainP.Set(n); } + void AddGainP(Int_t c, Float_t n) { fGainP.AddAt(n,c);} + TArrayF GetGainP() const {return fGainP; } + Float_t GetGainP(Int_t n) {return fGainP.At(n); } + void SetNGainN(Int_t n) { fGainN.Set(n); } + void AddGainN(Int_t c, Float_t n) { fGainN.AddAt(n,c);} + TArrayF GetGainN() const {return fGainN; } + Float_t GetGainN(Int_t n) {return fGainN.At(n); } + + void SetMod(UShort_t mod) {fMod = mod;} + UShort_t GetMod() { return fMod;} + +protected: + + UShort_t fMod; // module number (from 0 to 1535). Needed by the preprocessor to + // extract the information from the Detector Algorithm + + TArrayF fGainP; // Gain for P side channels + TArrayF fGainN; // Gain for N side channels + + private: AliITSGainSSD(const AliITSGainSSD &source); // copy constructor AliITSGainSSD& operator=(const AliITSGainSSD &source); // ass. op. - void AddGainP(Int_t module, Int_t strip, Float_t value) { - fGain[module*2*fgkDefaultNStripsSSD+strip] = (UShort_t) (1000.*value); - } - Float_t GetGainP(Int_t module, Int_t strip) { - return ((Float_t) ( (Float_t) fGain[module*2*fgkDefaultNStripsSSD+strip] ) /1000.); - } - - void AddGainN(Int_t module, Int_t strip, Float_t value) { - fGain[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip] = - (UShort_t) (1000.*value); - } - Float_t GetGainN(Int_t module, Int_t strip) { - return ( (Float_t) ((Float_t) fGain[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip])/1000.); - } - - protected: - - static const Int_t fgkDefaultNModulesSSD = 1698; - static const Int_t fgkDefaultNStripsSSD = 768; - - //static const Int_t fgkDefaultNModulesSSD; // Total numbers of SSD modules - //static const Int_t fgkDefaultNStripsSSD; // Total numbers of SSD modules - - UShort_t fGain[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD]; - // UShort_t *fGain; - - private: - - ClassDef(AliITSGainSSD,2) // Gain class for SSD - }; + ClassDef(AliITSGainSSD,1) //Response class for SSD +}; #endif diff --git a/ITS/AliITSGainSSDv2.cxx b/ITS/AliITSGainSSDv2.cxx new file mode 100644 index 00000000000..b24614e210b --- /dev/null +++ b/ITS/AliITSGainSSDv2.cxx @@ -0,0 +1,64 @@ +/************************************************************************** + * 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. * + **************************************************************************/ + + +#include "AliITSGainSSDv2.h" +#include + +////////////////////////////////////////////////////// +// Author: Enrico Fragiacomo +// Date: 23/08/2007 +// Modified: 08/07/2008 +// // +////////////////////////////////////////////////////// + +//const Int_t AliITSGainSSD::fgkDefaultNModulesSSD = 1698; +//const Int_t AliITSGainSSD::fgkDefaultNStripsSSD = 768; + +ClassImp(AliITSGainSSDv2) + +//______________________________________________________________________ + AliITSGainSSDv2::AliITSGainSSDv2() +{ + // Default Constructor + for(Int_t i=0; i<2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD; i++) + fGain[i]=0; +} + +//______________________________________________________________________ +AliITSGainSSDv2::AliITSGainSSDv2(const AliITSGainSSDv2 &source): + TObject(source) +{ + // copy Constructor + memcpy(fGain,source.fGain, + 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(UShort_t)); +} + +//______________________________________________________________________ +AliITSGainSSDv2::~AliITSGainSSDv2(){ + // destructor + +} + +//______________________________________________________________________ +AliITSGainSSDv2& AliITSGainSSDv2::operator=(const AliITSGainSSDv2 &source) { + // ass. op. + if (this == &source)return *this; + + memcpy(fGain,source.fGain, + 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(UShort_t)); + + return *this; +} diff --git a/ITS/AliITSGainSSDv2.h b/ITS/AliITSGainSSDv2.h new file mode 100644 index 00000000000..5711c4ca5fc --- /dev/null +++ b/ITS/AliITSGainSSDv2.h @@ -0,0 +1,51 @@ +#ifndef ALIITSGAINSSDV2_H +#define ALIITSGAINSSDV2_H + +////////////////////////////////////////////// +// Author: Enrico Fragiacomo +// Date: 23/08/2007 +// Modified: 08/07/2008 +// // +////////////////////////////////////////////// +#include "TObject.h" + +class AliITSGainSSDv2 : public TObject { + + public: + + AliITSGainSSDv2(); + virtual ~AliITSGainSSDv2(); + AliITSGainSSDv2(const AliITSGainSSDv2 &source); // copy constructor + AliITSGainSSDv2& operator=(const AliITSGainSSDv2 &source); // ass. op. + + void AddGainP(Int_t module, Int_t strip, Float_t value) { + fGain[module*2*fgkDefaultNStripsSSD+strip] = (UShort_t) (1000.*value); + } + Float_t GetGainP(Int_t module, Int_t strip) { + return ((Float_t) ( (Float_t) fGain[module*2*fgkDefaultNStripsSSD+strip] ) /1000.); + } + + void AddGainN(Int_t module, Int_t strip, Float_t value) { + fGain[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip] = + (UShort_t) (1000.*value); + } + Float_t GetGainN(Int_t module, Int_t strip) { + return ( (Float_t) ((Float_t) fGain[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip])/1000.); + } + + protected: + + static const Int_t fgkDefaultNModulesSSD = 1698; + static const Int_t fgkDefaultNStripsSSD = 768; + + //static const Int_t fgkDefaultNModulesSSD; // Total numbers of SSD modules + //static const Int_t fgkDefaultNStripsSSD; // Total numbers of SSD modules + + UShort_t fGain[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD]; + // UShort_t *fGain; + + private: + + ClassDef(AliITSGainSSDv2,1) // Gain class for SSD + }; +#endif diff --git a/ITS/AliITSHandleDaSSD.cxx b/ITS/AliITSHandleDaSSD.cxx index 07bc44c9268..215880021d5 100644 --- a/ITS/AliITSHandleDaSSD.cxx +++ b/ITS/AliITSHandleDaSSD.cxx @@ -34,9 +34,9 @@ #include "TFile.h" #include "TString.h" #include "AliLog.h" -#include "AliITSNoiseSSD.h" -#include "AliITSPedestalSSD.h" -#include "AliITSBadChannelsSSD.h" +#include "AliITSNoiseSSDv2.h" +#include "AliITSPedestalSSDv2.h" +#include "AliITSBadChannelsSSDv2.h" #include "AliITSRawStreamSSD.h" #include "AliRawReaderDate.h" #include "AliITSRawStreamSSD.h" @@ -461,7 +461,7 @@ Bool_t AliITSHandleDaSSD::ReadStaticBadChannelsMap(const Char_t *filename) AliWarning(Form("Error reading file %s with Static Bad Channels Map!", filename)); return kFALSE; } - bcfile->GetObject("AliITSBadChannelsSSD;1", fBadChannelsList); + bcfile->GetObject("AliITSBadChannelsSSDv2;1", fBadChannelsList); if (!fBadChannelsList) { AliWarning("Error fBadChannelsList == NULL!"); bcfile->Close(); @@ -902,16 +902,16 @@ Short_t AliITSHandleDaSSD::RetrieveModuleId(const UChar_t ddlID, const UChar_t a //______________________________________________________________________________ -AliITSNoiseSSD* AliITSHandleDaSSD::GetCalibrationOCDBNoise() const +AliITSNoiseSSDv2* AliITSHandleDaSSD::GetCalibrationOCDBNoise() const { // Fill in the array for OCDB - AliITSNoiseSSD *ldcn = NULL; + AliITSNoiseSSDv2 *ldcn = NULL; AliITSModuleDaSSD *module = NULL; AliITSChannelDaSSD *strip = NULL; if (!fModules) return NULL; - ldcn = new AliITSNoiseSSD; + ldcn = new AliITSNoiseSSDv2; if (!ldcn) { - AliError("Error allocation mamory for AliITSBadChannelsSSD object, return NULL!"); + AliError("Error allocation mamory for AliITSBadChannelsSSDv2 object, return NULL!"); return NULL; } for (Int_t i = 0; i < fNumberOfModules; i++) { @@ -931,16 +931,16 @@ AliITSNoiseSSD* AliITSHandleDaSSD::GetCalibrationOCDBNoise() const //______________________________________________________________________________ -AliITSBadChannelsSSD* AliITSHandleDaSSD::GetCalibrationBadChannels() const +AliITSBadChannelsSSDv2* AliITSHandleDaSSD::GetCalibrationBadChannels() const { // Fill in the TObjArray with the list of bad channels - AliITSBadChannelsSSD *ldcbc = NULL; + AliITSBadChannelsSSDv2 *ldcbc = NULL; AliITSModuleDaSSD *module = NULL; AliITSChannelDaSSD *strip = NULL; if (!fModules) return NULL; - ldcbc = new AliITSBadChannelsSSD; + ldcbc = new AliITSBadChannelsSSDv2; if (!ldcbc) { - AliError("Error allocation mamory for AliITSBadChannelsSSD object, return NULL!"); + AliError("Error allocation mamory for AliITSBadChannelsSSDv2 object, return NULL!"); return NULL; } for (Int_t i = 0; i < fNumberOfModules; i++) { @@ -965,17 +965,17 @@ AliITSBadChannelsSSD* AliITSHandleDaSSD::GetCalibrationBadChannels() const Bool_t AliITSHandleDaSSD::SaveCalibrationSSDLDC(Char_t*& dafname) { // Save Calibration data locally - AliITSBadChannelsSSD *ldcbc = NULL; - AliITSPedestalSSD *ldcp = NULL; - AliITSNoiseSSD *ldcn = NULL; + AliITSBadChannelsSSDv2 *ldcbc = NULL; + AliITSPedestalSSDv2 *ldcp = NULL; + AliITSNoiseSSDv2 *ldcn = NULL; AliITSModuleDaSSD *module = NULL; AliITSChannelDaSSD *strip = NULL; Char_t *tmpfname; TString dadatafilename(""); if (!fModules) return kFALSE; - ldcn = new AliITSNoiseSSD; - ldcp = new AliITSPedestalSSD; - ldcbc = new AliITSBadChannelsSSD; + ldcn = new AliITSNoiseSSDv2; + ldcp = new AliITSPedestalSSDv2; + ldcbc = new AliITSBadChannelsSSDv2; if ((!ldcn) || (!ldcp) || (!ldcp)) { AliError("Error allocation mamory for calibration objects, return kFALSE!"); return kFALSE; @@ -1030,7 +1030,7 @@ Bool_t AliITSHandleDaSSD::SaveCalibrationSSDLDC(Char_t*& dafname) //______________________________________________________________________________ -Int_t AliITSHandleDaSSD::MergeBadChannels(AliITSBadChannelsSSD*& bcl) const +Int_t AliITSHandleDaSSD::MergeBadChannels(AliITSBadChannelsSSDv2*& bcl) const { // Merges the statick bad channels list with bad channels got upon calibration AliITSModuleDaSSD *module = 0; diff --git a/ITS/AliITSHandleDaSSD.h b/ITS/AliITSHandleDaSSD.h index 49aac469f8f..37867571c19 100644 --- a/ITS/AliITSHandleDaSSD.h +++ b/ITS/AliITSHandleDaSSD.h @@ -10,6 +10,8 @@ #include "TObject.h" #include "TArrayS.h" #include "AliITSModuleDaSSD.h" +#include "AliITSBadChannelsSSDv2.h" +#include "AliITSNoiseSSDv2.h" /////////////////////////////////////////////////////////////////////////////// /// @@ -64,10 +66,10 @@ class AliITSHandleDaSSD : public TObject { {if ((fModules) && (index < fNumberOfModules)) return fModules[index]; else return NULL;} Int_t GetModuleIndex (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const; AliITSChannelDaSSD* GetStrip (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t stripID) const; - AliITSNoiseSSD* GetCalibrationOCDBNoise() const; - AliITSBadChannelsSSD* GetCalibrationBadChannels() const; + AliITSNoiseSSDv2* GetCalibrationOCDBNoise() const; + AliITSBadChannelsSSDv2* GetCalibrationBadChannels() const; Bool_t SaveCalibrationSSDLDC(Char_t*& dafname); - Int_t MergeBadChannels(AliITSBadChannelsSSD*& bcl) const; + Int_t MergeBadChannels(AliITSBadChannelsSSDv2*& bcl) const; void SetModIndProcessed(Int_t mi) {fModIndProcessed = mi;} void SetModIndRead (Int_t mr) {fModIndRead = mr;} @@ -137,7 +139,7 @@ class AliITSHandleDaSSD : public TObject { TArrayS fEqIndex; //! index array of equipmnts (DDLs). Long_t fNumberOfEvents; // Number of physics or calibration events in raw data file fRawDataFileName - AliITSBadChannelsSSD *fBadChannelsList; //! List of bad channels: static or created on base of calculated noise and pedestal + AliITSBadChannelsSSDv2 *fBadChannelsList; //! List of bad channels: static or created on base of calculated noise and pedestal Int_t *fDDLModuleMap; //! DDL map TArrayS fALaddersOff; //! Lisst of ladders of side A that are off and should be suppressed TArrayS fCLaddersOff; //! Lisst of ladders of side C that are off and should be suppressed @@ -158,7 +160,7 @@ class AliITSHandleDaSSD : public TObject { (signal <= AliITSChannelDaSSD::GetUnderflowConst())); } string ConvBase(const unsigned long value, const long base) const; - ClassDef(AliITSHandleDaSSD, 6) + ClassDef(AliITSHandleDaSSD, 7) }; diff --git a/ITS/AliITSNoiseSSD.cxx b/ITS/AliITSNoiseSSD.cxx index 3d77352b45a..896c4ff7c36 100644 --- a/ITS/AliITSNoiseSSD.cxx +++ b/ITS/AliITSNoiseSSD.cxx @@ -15,36 +15,30 @@ #include "AliITSNoiseSSD.h" -#include ////////////////////////////////////////////////////// // Author: Enrico Fragiacomo // Date: 23/08/2007 -// Modified: 08/07/2008 // // ////////////////////////////////////////////////////// -//const Int_t AliITSNoiseSSD::fgkDefaultNModulesSSD = 1698; -//const Int_t AliITSNoiseSSD::fgkDefaultNStripsSSD = 768; - ClassImp(AliITSNoiseSSD) - + //______________________________________________________________________ - AliITSNoiseSSD::AliITSNoiseSSD() { - // Default Constructor - for(Int_t i=0; i<2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD; i++) - fNois[i]=0; +AliITSNoiseSSD::AliITSNoiseSSD(): +fMod(0), +fNoisP(0), +fNoisN(0) { + // Default Constructor } //______________________________________________________________________ -AliITSNoiseSSD::AliITSNoiseSSD(const AliITSNoiseSSD &source): - TObject(source) -{ +AliITSNoiseSSD::AliITSNoiseSSD(const AliITSNoiseSSD &source): TObject(source), +fMod(source.fMod), +fNoisP(source.fNoisP), +fNoisN(source.fNoisN) { // copy Constructor - memcpy(fNois,source.fNois, - 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Float_t)); } - //______________________________________________________________________ AliITSNoiseSSD::~AliITSNoiseSSD(){ // destructor @@ -56,9 +50,8 @@ AliITSNoiseSSD& AliITSNoiseSSD::operator=(const AliITSNoiseSSD &source) { // ass. op. if (this == &source) return *this; - - memcpy(fNois,source.fNois, - 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Float_t)); - + fMod = source.fMod; + fNoisP = source.fMod; + fNoisN = source.fMod; return *this; } diff --git a/ITS/AliITSNoiseSSD.h b/ITS/AliITSNoiseSSD.h index a6b1c64c079..e389cf10ac8 100644 --- a/ITS/AliITSNoiseSSD.h +++ b/ITS/AliITSNoiseSSD.h @@ -1,14 +1,14 @@ #ifndef ALIITSNOISESSD_H #define ALIITSNOISESSD_H +#include "TObjArray.h" +#include "TArrayF.h" + ////////////////////////////////////////////// // Author: Enrico Fragiacomo // Date: 23/08/2007 -// Modified: 08/07/2008 // // ////////////////////////////////////////////// -#include "TObject.h" - class AliITSNoiseSSD : public TObject { public: @@ -18,33 +18,28 @@ class AliITSNoiseSSD : public TObject { AliITSNoiseSSD(const AliITSNoiseSSD &source); // copy constructor AliITSNoiseSSD& operator=(const AliITSNoiseSSD &source); // ass. op. - void AddNoiseP(Int_t module, Int_t strip, Float_t value) { - fNois[module*2*fgkDefaultNStripsSSD+strip] = value; - } - Float_t GetNoiseP(Int_t module, Int_t strip) { - return fNois[module*2*fgkDefaultNStripsSSD+strip]; - } - - void AddNoiseN(Int_t module, Int_t strip, Float_t value) { - fNois[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip] = value; - } - Float_t GetNoiseN(Int_t module, Int_t strip) { - return fNois[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip]; - } - - protected: - - static const Int_t fgkDefaultNModulesSSD = 1698; - static const Int_t fgkDefaultNStripsSSD = 768; - - // static const Int_t fgkDefaultNModulesSSD; // Total numbers of SSD modules - //static const Int_t fgkDefaultNStripsSSD; // Total numbers of SSD modules - - Float_t fNois[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD]; - //Float_t *fNois; - + void SetNNoiseP(Int_t n) { fNoisP.Set(n); } + void AddNoiseP(Int_t c, Float_t n) { fNoisP.AddAt(n,c);} + TArrayF GetNoiseP() const {return fNoisP; } + Float_t GetNoiseP(Int_t n) {return fNoisP.At(n); } + void SetNNoiseN(Int_t n) { fNoisN.Set(n); } + void AddNoiseN(Int_t c, Float_t n) { fNoisN.AddAt(n,c);} + TArrayF GetNoiseN() const {return fNoisN; } + Float_t GetNoiseN(Int_t n) {return fNoisN.At(n); } + + void SetMod(UShort_t mod) {fMod = mod;} + UShort_t GetMod() { return fMod;} + +protected: + + UShort_t fMod; // module number (from 0 to 1535). Needed by the preprocessor to + // extract the information from the Detector Algorithm + + TArrayF fNoisP; // Noise for P side channels + TArrayF fNoisN; // Noise for N side channels + private: - - ClassDef(AliITSNoiseSSD,2) // Noise class for SSD - }; + + ClassDef(AliITSNoiseSSD,1) // Noise class for SSD +}; #endif diff --git a/ITS/AliITSNoiseSSDv2.cxx b/ITS/AliITSNoiseSSDv2.cxx new file mode 100644 index 00000000000..b5d92bae96f --- /dev/null +++ b/ITS/AliITSNoiseSSDv2.cxx @@ -0,0 +1,64 @@ +/************************************************************************** + * 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. * + **************************************************************************/ + + +#include "AliITSNoiseSSDv2.h" +#include + +////////////////////////////////////////////////////// +// Author: Enrico Fragiacomo +// Date: 23/08/2007 +// Modified: 08/07/2008 +// // +////////////////////////////////////////////////////// + +//const Int_t AliITSNoiseSSD::fgkDefaultNModulesSSD = 1698; +//const Int_t AliITSNoiseSSD::fgkDefaultNStripsSSD = 768; + +ClassImp(AliITSNoiseSSDv2) + +//______________________________________________________________________ + AliITSNoiseSSDv2::AliITSNoiseSSDv2() { + // Default Constructor + for(Int_t i=0; i<2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD; i++) + fNois[i]=0; +} + +//______________________________________________________________________ +AliITSNoiseSSDv2::AliITSNoiseSSDv2(const AliITSNoiseSSDv2 &source): + TObject(source) +{ + // copy Constructor + memcpy(fNois,source.fNois, + 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Float_t)); +} + +//______________________________________________________________________ +AliITSNoiseSSDv2::~AliITSNoiseSSDv2(){ + // destructor + +} + +//______________________________________________________________________ +AliITSNoiseSSDv2& AliITSNoiseSSDv2::operator=(const AliITSNoiseSSDv2 &source) { + // ass. op. + if (this == &source) + return *this; + + memcpy(fNois,source.fNois, + 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Float_t)); + + return *this; +} diff --git a/ITS/AliITSNoiseSSDv2.h b/ITS/AliITSNoiseSSDv2.h new file mode 100644 index 00000000000..3ddd2328482 --- /dev/null +++ b/ITS/AliITSNoiseSSDv2.h @@ -0,0 +1,50 @@ +#ifndef ALIITSNOISESSDV2_H +#define ALIITSNOISESSDV2_H + +////////////////////////////////////////////// +// Author: Enrico Fragiacomo +// Date: 23/08/2007 +// Modified: 08/07/2008 +// // +////////////////////////////////////////////// +#include "TObject.h" + +class AliITSNoiseSSDv2 : public TObject { + + public: + + AliITSNoiseSSDv2(); + virtual ~AliITSNoiseSSDv2(); + AliITSNoiseSSDv2(const AliITSNoiseSSDv2 &source); // copy constructor + AliITSNoiseSSDv2& operator=(const AliITSNoiseSSDv2 &source); // ass. op. + + void AddNoiseP(Int_t module, Int_t strip, Float_t value) { + fNois[module*2*fgkDefaultNStripsSSD+strip] = value; + } + Float_t GetNoiseP(Int_t module, Int_t strip) { + return fNois[module*2*fgkDefaultNStripsSSD+strip]; + } + + void AddNoiseN(Int_t module, Int_t strip, Float_t value) { + fNois[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip] = value; + } + Float_t GetNoiseN(Int_t module, Int_t strip) { + return fNois[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip]; + } + + protected: + + static const Int_t fgkDefaultNModulesSSD = 1698; + static const Int_t fgkDefaultNStripsSSD = 768; + + // static const Int_t fgkDefaultNModulesSSD; // Total numbers of SSD modules + //static const Int_t fgkDefaultNStripsSSD; // Total numbers of SSD modules + + Float_t fNois[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD]; + //Float_t *fNois; + + private: + + ClassDef(AliITSNoiseSSDv2,1) // Noise class for SSD + }; +#endif diff --git a/ITS/AliITSPedestalSSD.cxx b/ITS/AliITSPedestalSSD.cxx index 81ddd1c74fb..1ba1ed6ae17 100644 --- a/ITS/AliITSPedestalSSD.cxx +++ b/ITS/AliITSPedestalSSD.cxx @@ -1,5 +1,5 @@ /************************************************************************** - * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * Copyright(c) 2007-9, ALICE Experiment at CERN, All rights reserved. * * * * Author: The ALICE Off-line Project. * * Contributors are mentioned in the code where appropriate. * @@ -13,41 +13,33 @@ * provided "as is" without express or implied warranty. * **************************************************************************/ +/* $Id$ */ #include "AliITSPedestalSSD.h" -#include ////////////////////////////////////////////////////// // Author: Enrico Fragiacomo -// Date: 23/08/2007 -// Modified: 08/07/2008 +// Date: 12/12/2007 // // ////////////////////////////////////////////////////// -//const Int_t AliITSPedestalSSD::fgkDefaultNModulesSSD = 1698; -//const Int_t AliITSPedestalSSD::fgkDefaultNStripsSSD = 768; - ClassImp(AliITSPedestalSSD) - + //______________________________________________________________________ - AliITSPedestalSSD::AliITSPedestalSSD() +AliITSPedestalSSD::AliITSPedestalSSD(): +fMod(0), +fPedP(0), +fPedN(0) { // Default Constructor - //: fPedestal(new Float_t[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD]) -{ - for(Int_t i=0; i<2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD; i++) - fPedestal[i]=0; - } +} //______________________________________________________________________ -AliITSPedestalSSD::AliITSPedestalSSD(const AliITSPedestalSSD &source): - TObject(source) - //, fPedestal(new Float_t[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD]) -{ +AliITSPedestalSSD::AliITSPedestalSSD(const AliITSPedestalSSD &source): TObject(source), +fMod(source.fMod), +fPedP(source.fPedP), +fPedN(source.fPedN) { // copy Constructor - memcpy(fPedestal,source.fPedestal, - 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Float_t)); } - //______________________________________________________________________ AliITSPedestalSSD::~AliITSPedestalSSD(){ // destructor @@ -57,10 +49,10 @@ AliITSPedestalSSD::~AliITSPedestalSSD(){ //______________________________________________________________________ AliITSPedestalSSD& AliITSPedestalSSD::operator=(const AliITSPedestalSSD &source) { // ass. op. - if (this == &source)return *this; - - memcpy(fPedestal,source.fPedestal, - 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Float_t)); - + if (this == &source) + return *this; + fMod = source.fMod; + fPedP = source.fMod; + fPedN = source.fMod; return *this; } diff --git a/ITS/AliITSPedestalSSD.h b/ITS/AliITSPedestalSSD.h index 9c50e39fa75..7afc2e7a7b1 100644 --- a/ITS/AliITSPedestalSSD.h +++ b/ITS/AliITSPedestalSSD.h @@ -1,13 +1,16 @@ #ifndef ALIITSPEDESTALSSD_H #define ALIITSPEDESTALSSD_H +#include "TObjArray.h" +#include "TArrayF.h" + ////////////////////////////////////////////// // Author: Enrico Fragiacomo -// Date: 23/08/2007 -// Modified: 08/07/2008 +// Date: 12/12/2007 // // ////////////////////////////////////////////// -#include "TObject.h" + +/* $Id$ */ class AliITSPedestalSSD : public TObject { @@ -18,32 +21,28 @@ class AliITSPedestalSSD : public TObject { AliITSPedestalSSD(const AliITSPedestalSSD &source); // copy constructor AliITSPedestalSSD& operator=(const AliITSPedestalSSD &source); // ass. op. - void AddPedestalP(Int_t module, Int_t strip, Float_t value) { - fPedestal[module*2*fgkDefaultNStripsSSD+strip] = value; - } - Float_t GetPedestalP(Int_t module, Int_t strip) { - return fPedestal[module*2*fgkDefaultNStripsSSD+strip]; - } - - void AddPedestalN(Int_t module, Int_t strip, Float_t value) { - fPedestal[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip] = value; - } - Float_t GetPedestalN(Int_t module, Int_t strip) { - return fPedestal[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip]; - } - - protected: - - static const Int_t fgkDefaultNModulesSSD = 1698; - static const Int_t fgkDefaultNStripsSSD = 768; - - // static const Int_t fgkDefaultNModulesSSD; // Total numbers of SSD modules - //static const Int_t fgkDefaultNStripsSSD; // Total numbers of SSD modules - -Float_t fPedestal[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD]; - + void SetNPedestalP(Int_t n) { fPedP.Set(n); } + void AddPedestalP(Int_t c, Float_t n) { fPedP.AddAt(n,c);} + TArrayF GetPedestalP() const {return fPedP; } + Float_t GetPedestalP(Int_t n) {return fPedP.At(n); } + void SetNPedestalN(Int_t n) { fPedN.Set(n); } + void AddPedestalN(Int_t c, Float_t n) { fPedN.AddAt(n,c);} + TArrayF GetPedestalN() const {return fPedN; } + Float_t GetPedestalN(Int_t n) {return fPedN.At(n); } + + void SetMod(UShort_t mod) {fMod = mod;} + UShort_t GetMod() { return fMod;} + +protected: + + UShort_t fMod; // module number (from 0 to 1535). Needed by the preprocessor to + // extract the information from the Detector Algorithm + + TArrayF fPedP; // Pedestal for P side channels + TArrayF fPedN; // Pedestal for N side channels + private: - - ClassDef(AliITSPedestalSSD,2) // Pedestal class for SSD - }; + + ClassDef(AliITSPedestalSSD,1) // Pedestal class for SSD +}; #endif diff --git a/ITS/AliITSPedestalSSDv2.cxx b/ITS/AliITSPedestalSSDv2.cxx new file mode 100644 index 00000000000..1961fc8d823 --- /dev/null +++ b/ITS/AliITSPedestalSSDv2.cxx @@ -0,0 +1,66 @@ +/************************************************************************** + * 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. * + **************************************************************************/ + + +#include "AliITSPedestalSSDv2.h" +#include + +////////////////////////////////////////////////////// +// Author: Enrico Fragiacomo +// Date: 23/08/2007 +// Modified: 08/07/2008 +// // +////////////////////////////////////////////////////// + +//const Int_t AliITSPedestalSSD::fgkDefaultNModulesSSD = 1698; +//const Int_t AliITSPedestalSSD::fgkDefaultNStripsSSD = 768; + +ClassImp(AliITSPedestalSSDv2) + +//______________________________________________________________________ + AliITSPedestalSSDv2::AliITSPedestalSSDv2() + // Default Constructor + //: fPedestal(new Float_t[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD]) +{ + for(Int_t i=0; i<2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD; i++) + fPedestal[i]=0; + } + +//______________________________________________________________________ +AliITSPedestalSSDv2::AliITSPedestalSSDv2(const AliITSPedestalSSDv2 &source): + TObject(source) + //, fPedestal(new Float_t[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD]) +{ + // copy Constructor + memcpy(fPedestal,source.fPedestal, + 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Float_t)); +} + +//______________________________________________________________________ +AliITSPedestalSSDv2::~AliITSPedestalSSDv2(){ + // destructor + +} + +//______________________________________________________________________ +AliITSPedestalSSDv2& AliITSPedestalSSDv2::operator=(const AliITSPedestalSSDv2 &source) { + // ass. op. + if (this == &source)return *this; + + memcpy(fPedestal,source.fPedestal, + 2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD*sizeof(Float_t)); + + return *this; +} diff --git a/ITS/AliITSPedestalSSDv2.h b/ITS/AliITSPedestalSSDv2.h new file mode 100644 index 00000000000..7fcf0fe6ea3 --- /dev/null +++ b/ITS/AliITSPedestalSSDv2.h @@ -0,0 +1,49 @@ +#ifndef ALIITSPEDESTALSSDV2_H +#define ALIITSPEDESTALSSDV2_H + +////////////////////////////////////////////// +// Author: Enrico Fragiacomo +// Date: 23/08/2007 +// Modified: 08/07/2008 +// // +////////////////////////////////////////////// +#include "TObject.h" + +class AliITSPedestalSSDv2 : public TObject { + + public: + + AliITSPedestalSSDv2(); + virtual ~AliITSPedestalSSDv2(); + AliITSPedestalSSDv2(const AliITSPedestalSSDv2 &source); // copy constructor + AliITSPedestalSSDv2& operator=(const AliITSPedestalSSDv2 &source); // ass. op. + + void AddPedestalP(Int_t module, Int_t strip, Float_t value) { + fPedestal[module*2*fgkDefaultNStripsSSD+strip] = value; + } + Float_t GetPedestalP(Int_t module, Int_t strip) { + return fPedestal[module*2*fgkDefaultNStripsSSD+strip]; + } + + void AddPedestalN(Int_t module, Int_t strip, Float_t value) { + fPedestal[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip] = value; + } + Float_t GetPedestalN(Int_t module, Int_t strip) { + return fPedestal[module*2*fgkDefaultNStripsSSD+fgkDefaultNStripsSSD+strip]; + } + + protected: + + static const Int_t fgkDefaultNModulesSSD = 1698; + static const Int_t fgkDefaultNStripsSSD = 768; + + // static const Int_t fgkDefaultNModulesSSD; // Total numbers of SSD modules + //static const Int_t fgkDefaultNStripsSSD; // Total numbers of SSD modules + +Float_t fPedestal[2*fgkDefaultNModulesSSD*fgkDefaultNStripsSSD]; + + private: + + ClassDef(AliITSPedestalSSDv2,1) // Pedestal class for SSD + }; +#endif diff --git a/ITS/AliITSPreprocessorSSD.cxx b/ITS/AliITSPreprocessorSSD.cxx index fd579f23cc6..57e5c43c77a 100644 --- a/ITS/AliITSPreprocessorSSD.cxx +++ b/ITS/AliITSPreprocessorSSD.cxx @@ -8,9 +8,9 @@ #include #include "AliITSRawStreamSSD.h" -#include "AliITSNoiseSSD.h" -#include "AliITSPedestalSSD.h" -#include "AliITSBadChannelsSSD.h" +#include "AliITSNoiseSSDv2.h" +#include "AliITSPedestalSSDv2.h" +#include "AliITSBadChannelsSSDv2.h" #include @@ -65,9 +65,9 @@ UInt_t AliITSPreprocessorSSD::Process(TMap* /*dcsAliasMap*/) //--------------------------------------- // initialize the calibration objects - AliITSNoiseSSD *calib = new AliITSNoiseSSD(); - AliITSBadChannelsSSD *badch = new AliITSBadChannelsSSD(); - AliITSPedestalSSD *pedel = new AliITSPedestalSSD(); + AliITSNoiseSSDv2 *calib = new AliITSNoiseSSDv2(); + AliITSBadChannelsSSDv2 *badch = new AliITSBadChannelsSSDv2(); + AliITSPedestalSSDv2 *pedel = new AliITSPedestalSSDv2(); TString runType = GetRunType(); if(runType == "ELECTRONICS_CALIBRATION_RUN") { @@ -102,22 +102,22 @@ UInt_t AliITSPreprocessorSSD::Process(TMap* /*dcsAliasMap*/) return 2; } - AliITSNoiseSSD *cal; - f->GetObject("AliITSNoiseSSD;1", cal); + AliITSNoiseSSDv2 *cal; + f->GetObject("AliITSNoiseSSDv2;1", cal); if(!cal) { Log("File does not contain expected data for the noise!"); delete list; return 3; } - AliITSPedestalSSD *ped; - f->GetObject("AliITSPedestalSSD;1", ped); + AliITSPedestalSSDv2 *ped; + f->GetObject("AliITSPedestalSSDv2;1", ped); if(!ped) { Log("File does not contain expected data for the pedestals!"); delete list; return 5; } - AliITSBadChannelsSSD *bad; - f->GetObject("AliITSBadChannelsSSD;1", bad); + AliITSBadChannelsSSDv2 *bad; + f->GetObject("AliITSBadChannelsSSDv2;1", bad); if(!bad) { Log("File does not contain expected data for bad channels !"); delete list; diff --git a/ITS/AliITSQASSDDataMakerRec.cxx b/ITS/AliITSQASSDDataMakerRec.cxx index 75f573e130f..ba909a902a6 100644 --- a/ITS/AliITSQASSDDataMakerRec.cxx +++ b/ITS/AliITSQASSDDataMakerRec.cxx @@ -42,6 +42,7 @@ #include "AliITSgeomTGeo.h" #include "AliRawEventHeaderBase.h" #include "AliITSRecPoint.h" +#include "AliITSBadChannelsSSDv2.h" #include "AliCDBManager.h" #include "AliCDBEntry.h" @@ -55,21 +56,23 @@ fSSDEvent(0), fSSDEventPerCycle(0), fkOnline(kMode), fLDC(ldc), -fSSDRawsOffset(0), +fSSDRawsOffset(0), fSSDRawsDAOffset(0), fSSDRawsCommonLevelOffset(0), fSSDhTask(0), -fGenOffset(0) { +fGenOffset(0), +fCDBManager(0) { // Default constructor //initilize the raw signal vs strip number histograms if(fkOnline) { - AliCDBManager * man = AliCDBManager::Instance(); - man->SetDefaultStorage("local://$ALICE_ROOT"); + fCDBManager = AliCDBManager::Instance(); + //fCDBManager->SetDefaultStorage("local://$ALICE_ROOT"); + fCDBManager->SetDefaultStorage(gSystem->Getenv("AMORE_CDB_URI")); Int_t runNumber = atoi(gSystem->Getenv("DATE_RUN_NUMBER")); if(!runNumber) AliInfo("DATE_RUN_NUMBER not defined!!!\n"); - man->SetRun(runNumber); - AliCDBEntry *geomGRP = man->Get("GRP/Geometry/Data"); + fCDBManager->SetRun(runNumber); + AliCDBEntry *geomGRP = fCDBManager->Get("GRP/Geometry/Data"); if(!geomGRP) AliInfo("GRP geometry not found!!!\n"); Int_t gLayer = 0,gLadder = 0, gModule = 0; @@ -92,6 +95,7 @@ fGenOffset(0) { else { for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) fHistSSDRawSignalModule[iModule]=NULL; + fCDBManager = NULL; } } @@ -103,10 +107,11 @@ fSSDEvent(qadm.fSSDEvent), fSSDEventPerCycle(qadm.fSSDEventPerCycle), fkOnline(qadm.fkOnline), fLDC(qadm.fLDC), -fSSDRawsOffset(qadm.fSSDRawsOffset), +fSSDRawsOffset(qadm.fSSDRawsOffset), fSSDRawsDAOffset(qadm.fSSDRawsDAOffset), fSSDRawsCommonLevelOffset(qadm.fSSDRawsCommonLevelOffset), fSSDhTask(qadm.fSSDhTask), -fGenOffset(qadm.fGenOffset) { +fGenOffset(qadm.fGenOffset), +fCDBManager(qadm.fCDBManager) { //copy ctor fAliITSQADataMakerRec->SetName((const char*)qadm.fAliITSQADataMakerRec->GetName()) ; fAliITSQADataMakerRec->SetTitle((const char*)qadm.fAliITSQADataMakerRec->GetTitle()); @@ -126,6 +131,7 @@ AliITSQASSDDataMakerRec::~AliITSQASSDDataMakerRec() { // destructor for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) if(fHistSSDRawSignalModule[iModule]) delete fHistSSDRawSignalModule[iModule]; + if(fCDBManager) delete fCDBManager; } //____________________________________________________________________________ @@ -143,6 +149,9 @@ void AliITSQASSDDataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjAr //online part if(fkOnline) { + //Output of the DA + MonitorOCDBObjects(); + Int_t gHistPositionOccupancyPerModule = 0; Int_t gLayer = 0, gLadder = 0, gModule = 0; //occupancy per module @@ -167,7 +176,7 @@ void AliITSQASSDDataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjAr gHistPositionOccupancyPerModule = (gLayer == 5) ? ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER5 + gModule - 1) : ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER6 + gModule + fgkSSDMODULESLAYER5 - 1); gHistPositionOccupancyPerLadder = (gLayer == 5) ? 2*(gLadder - 1) : 2*(gLadder - 1 + fgkSSDLADDERSLAYER5); - //P-SIDE OCCUPANCY + //P-SIDE OCCUPANCY occupancy = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerModule),0); fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+fgkSSDMODULES+gHistPositionOccupancyPerLadder)->Fill(gModule,occupancy); lLadderLocationY = 3*gLadder; // sideP=1 sideN=0 @@ -176,7 +185,7 @@ void AliITSQASSDDataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjAr else if(gLayer == 6) ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+1))->SetBinContent(gModule,lLadderLocationY,occupancy); - //N-SIDE OCCUPANCY + //N-SIDE OCCUPANCY occupancy = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerModule),1); fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+fgkSSDMODULES+gHistPositionOccupancyPerLadder+1)->Fill(gModule,occupancy); if(gLayer == 5) @@ -359,6 +368,71 @@ void AliITSQASSDDataMakerRec::InitRaws() { } fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLayer6, fGenOffset+fSSDRawsOffset); fSSDRawsOffset += 1; + + //Output of the DA + TH2D *fHistPSideBadChannelMapLayer5 = new TH2D("fHistPSideBadChannelMapLayer5", + "Layer 5;N_{module};N_{ladder}", + 22,1,23, + 34,500,534); + fHistPSideBadChannelMapLayer5->GetXaxis()->SetTitleColor(1); + fHistPSideBadChannelMapLayer5->SetStats(kFALSE); + fHistPSideBadChannelMapLayer5->GetYaxis()->SetTitleOffset(1.8); + fHistPSideBadChannelMapLayer5->GetXaxis()->SetNdivisions(22); + fHistPSideBadChannelMapLayer5->GetYaxis()->SetNdivisions(34); + fHistPSideBadChannelMapLayer5->GetXaxis()->SetLabelSize(0.03); + fHistPSideBadChannelMapLayer5->GetYaxis()->SetLabelSize(0.03); + fHistPSideBadChannelMapLayer5->GetZaxis()->SetTitleOffset(1.6); + fHistPSideBadChannelMapLayer5->GetZaxis()->SetTitle("Bad channels (p-side)[%]"); + fAliITSQADataMakerRec->Add2RawsList(fHistPSideBadChannelMapLayer5, fGenOffset+fSSDRawsOffset); + fSSDRawsOffset += 1; fSSDRawsDAOffset += 1; + + TH2D *fHistNSideBadChannelMapLayer5 = new TH2D("fHistNSideBadChannelMapLayer5", + "Layer 5;N_{module};N_{ladder}", + 22,1,23, + 34,500,534); + fHistNSideBadChannelMapLayer5->GetXaxis()->SetTitleColor(1); + fHistNSideBadChannelMapLayer5->SetStats(kFALSE); + fHistNSideBadChannelMapLayer5->GetYaxis()->SetTitleOffset(1.8); + fHistNSideBadChannelMapLayer5->GetXaxis()->SetNdivisions(22); + fHistNSideBadChannelMapLayer5->GetYaxis()->SetNdivisions(34); + fHistNSideBadChannelMapLayer5->GetXaxis()->SetLabelSize(0.03); + fHistNSideBadChannelMapLayer5->GetYaxis()->SetLabelSize(0.03); + fHistNSideBadChannelMapLayer5->GetZaxis()->SetTitleOffset(1.6); + fHistNSideBadChannelMapLayer5->GetZaxis()->SetTitle("Bad channels (n-side)[%]"); + fAliITSQADataMakerRec->Add2RawsList(fHistNSideBadChannelMapLayer5, fGenOffset+fSSDRawsOffset); + fSSDRawsOffset += 1; fSSDRawsDAOffset += 1; + + TH2D *fHistPSideBadChannelMapLayer6 = new TH2D("fHistPSideBadChannelMapLayer6", + "Layer 6;N_{module};N_{ladder}", + 25,1,26, + 38,600,638); + fHistPSideBadChannelMapLayer6->GetXaxis()->SetTitleColor(1); + fHistPSideBadChannelMapLayer6->SetStats(kFALSE); + fHistPSideBadChannelMapLayer6->GetYaxis()->SetTitleOffset(1.8); + fHistPSideBadChannelMapLayer6->GetXaxis()->SetNdivisions(25); + fHistPSideBadChannelMapLayer6->GetYaxis()->SetNdivisions(38); + fHistPSideBadChannelMapLayer6->GetXaxis()->SetLabelSize(0.03); + fHistPSideBadChannelMapLayer6->GetYaxis()->SetLabelSize(0.03); + fHistPSideBadChannelMapLayer6->GetZaxis()->SetTitleOffset(1.6); + fHistPSideBadChannelMapLayer6->GetZaxis()->SetTitle("Bad channels (p-side)[%]"); + fAliITSQADataMakerRec->Add2RawsList(fHistPSideBadChannelMapLayer6, fGenOffset+fSSDRawsOffset); + fSSDRawsOffset += 1; fSSDRawsDAOffset += 1; + + TH2D *fHistNSideBadChannelMapLayer6 = new TH2D("fHistNSideBadChannelMapLayer6", + "Layer 6;N_{module};N_{ladder}", + 25,1,26, + 38,600,638); + fHistNSideBadChannelMapLayer6->GetXaxis()->SetTitleColor(1); + fHistNSideBadChannelMapLayer6->SetStats(kFALSE); + fHistNSideBadChannelMapLayer6->GetYaxis()->SetTitleOffset(1.8); + fHistNSideBadChannelMapLayer6->GetXaxis()->SetNdivisions(25); + fHistNSideBadChannelMapLayer6->GetYaxis()->SetNdivisions(38); + fHistNSideBadChannelMapLayer6->GetXaxis()->SetLabelSize(0.03); + fHistNSideBadChannelMapLayer6->GetYaxis()->SetLabelSize(0.03); + fHistNSideBadChannelMapLayer6->GetZaxis()->SetTitleOffset(1.6); + fHistNSideBadChannelMapLayer6->GetZaxis()->SetTitle("Bad channels (n-side)[%]"); + fAliITSQADataMakerRec->Add2RawsList(fHistNSideBadChannelMapLayer6, fGenOffset+fSSDRawsOffset); + fSSDRawsOffset += 1; fSSDRawsDAOffset += 1; }//online flag fSSDhTask = fSSDRawsOffset; AliDebug(1,Form("%d SSD Raws histograms booked\n",fSSDhTask)); @@ -441,7 +515,7 @@ void AliITSQASSDDataMakerRec::MakeRaws(AliRawReader* rawReader) { } //____________________________________________________________________________ // -Double_t AliITSQASSDDataMakerRec::GetOccupancyStrip(TH1 *lHisto, Int_t *occupancyMatrix) { +void AliITSQASSDDataMakerRec::GetOccupancyStrip(TH1 *lHisto, Int_t *occupancyMatrix) { //Increments the entries in the occupancy matrix based //on whether the signal for each strip is larger than the cutoff //Currently the cutoff is at 0 which means that if ZS @@ -474,6 +548,73 @@ Double_t AliITSQASSDDataMakerRec::GetOccupancyModule(TH1 *lHisto, Int_t stripsid return lOccupancy; } +//____________________________________________________________________________ +void AliITSQASSDDataMakerRec::MonitorOCDBObjects() { + //Monitor in AMORE the output of the DA + //Currently only the bad channel list is monitored + //Todo: Noise - Pedestal + AliCDBEntry *entryBadChannelsSSD = fCDBManager->Get("ITS/Calib/BadChannelsSSD"); + if(!entryBadChannelsSSD) + AliError("OCDB entry for the bad channel list is not valid!"); + AliITSBadChannelsSSDv2 *badchannelsSSD = (AliITSBadChannelsSSDv2 *)entryBadChannelsSSD->GetObject(); + if(!badchannelsSSD) + AliError("Bad channel list object is not a valid AliITSBadChannelsSSD object!"); + + //_____________________________________________________________________________// + Int_t nBadPSideChannels = 0, nBadNSideChannels = 0; + Int_t layer = 0, ladder = 0, module = 0; + Int_t nPSideChannelsLayer5 = 0, nNSideChannelsLayer5 = 0; + Int_t nPSideChannelsLayer6 = 0, nNSideChannelsLayer6 = 0; + //_____________________________________________________________________________// + + for(Int_t i = 0; i < fgkSSDMODULES; i++) { + AliITSgeomTGeo::GetModuleId(i+500,layer,ladder,module); + nBadPSideChannels = 0, nBadNSideChannels = 0; + nPSideChannelsLayer5 = 0, nNSideChannelsLayer5 = 0; + nPSideChannelsLayer6 = 0, nNSideChannelsLayer6 = 0; + + Int_t badChannel = 0; + for(Int_t j = 0; j < fgkNumberOfPSideStrips; j++) { + badChannel = (Int_t)(badchannelsSSD->GetBadChannelP(i,j)); + if(badChannel != 0) { + if(layer == 5) + nPSideChannelsLayer5 += 1; + if(layer == 6) + nPSideChannelsLayer6 += 1; + nBadPSideChannels += 1; + }//badchannel flag != 0 + badChannel = (Int_t)(badchannelsSSD->GetBadChannelN(i,j)); + if(badChannel != 0) { + if(layer == 5) + nNSideChannelsLayer5 += 1; + if(layer == 6) + nNSideChannelsLayer6 += 1; + nBadNSideChannels += 1; + }//badchannel flag != 0 + }//loop over strips + if(layer == 5) { + if(nPSideChannelsLayer5 > 0) + ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset))->Fill(module,499+ladder, + 100.*nPSideChannelsLayer5/fgkNumberOfPSideStrips); + else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset))->Fill(module,499+ladder,0.0001); + if(nNSideChannelsLayer5 > 0) + ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+1))->Fill(module,499+ladder, + 100.*nNSideChannelsLayer5/fgkNumberOfPSideStrips); + else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+1))->Fill(module,499+ladder,0.0001); + }//layer 5 + if(layer == 6) { + if(nPSideChannelsLayer6 > 0) + ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+2))->Fill(module,599+ladder, + 100.*nPSideChannelsLayer6/fgkNumberOfPSideStrips); + else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+2))->Fill(module,599+ladder,0.0001); + if(nNSideChannelsLayer6 > 0) + ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+3))->Fill(module,599+ladder, + 100.*nNSideChannelsLayer6/fgkNumberOfPSideStrips); + else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+3))->Fill(module,599+ladder,0.0001); + }//layer 6 + }//module loop +} + //____________________________________________________________________________ void AliITSQASSDDataMakerRec::InitRecPoints() { diff --git a/ITS/AliITSQASSDDataMakerRec.h b/ITS/AliITSQASSDDataMakerRec.h index 45ba8bc9eff..532a8f8a5d9 100644 --- a/ITS/AliITSQASSDDataMakerRec.h +++ b/ITS/AliITSQASSDDataMakerRec.h @@ -19,8 +19,10 @@ class TObjArray; class TH1D; + class AliRawReader; class AliITSQADataMakerRec; +class AliCDBManager; class AliITSQASSDDataMakerRec: public TObject { @@ -40,9 +42,10 @@ public: private: - Double_t GetOccupancyStrip(TH1 *lHisto, Int_t *occupancyMatrix); + void GetOccupancyStrip(TH1 *lHisto, Int_t *occupancyMatrix); Double_t GetOccupancyModule(TH1 *lHisto, Int_t stripside); - + void MonitorOCDBObjects(); + static const Int_t fgkNumOfLDCs = 3; //number of SSD LDCs static const Int_t fgkNumOfDDLs = 16; //number of SSD DDLs static const Int_t fgkSSDMODULES = 1698; //total number of SSD modules @@ -60,14 +63,16 @@ public: Bool_t fkOnline; //online (1) or offline (0) use Int_t fLDC; //LDC number (0 for offline, 1 to 4 for online) Int_t fSSDRawsOffset; //SSD raw data plot offset + Int_t fSSDRawsDAOffset; //SSD DA plot offset Int_t fSSDRawsCommonLevelOffset; //Raw data QA - top level offset - histos used both online and offline Int_t fSSDhTask; //number of histo booked for each SSD task Int_t fGenOffset; //qachecking offset TH1D *fHistSSDRawSignalModule[fgkSSDMODULES]; //raw signal vs strip number - SSD Int_t fOccupancyMatrix[fgkSSDMODULES][2*fgkNumberOfPSideStrips]; //occupancy values per strip - ClassDef(AliITSQASSDDataMakerRec,3) // description + AliCDBManager *fCDBManager; //CDB manager + ClassDef(AliITSQASSDDataMakerRec,4) // description }; #endif diff --git a/ITS/Calib/BadChannelsSSD/Run0_999999999_v0_s0.root b/ITS/Calib/BadChannelsSSD/Run0_999999999_v0_s0.root index 05c3f11c9eaf20945c9272b5626d214c5b7e341b..baa442d2de9070102b77992894834fa683f54d37 100644 GIT binary patch delta 2122 zcmai#c{J4BAIHD8^yIN-&Av5LgApTGz!Hp7TEEbI$$T_x;@ax#zwrf_j4t!!Vc#0O&~p z0Kf+Tw0c3=f^i%uHc&4){}aGv0e~wFU=!J?@;W~vIG!)2XOn@aE@vZ^4Z%!y;8$MO zQ4Wq+AbfWrXa=r0Z59yhYX|qog!sZkz5T-i!Xw}&D0^$TXK;YGFFYbF5*?J=hCs;v zdybYJ*Drfe37|6>)Jssi+W-K9^m}RG?EehaM_`GNUWeThHGh@J=9inmCWnht1sr-I z(QK@Nc1wnlIQQo>CYZan(7W%I@5KlRw|*DWj{RaQTn|@YBBA{YQ#+#=W zeNY2YYg=ia;?#A&obwk~b~I>17CIJ`V;fPeCv`AI1YfPJ#jyP?HRv?5E2GqEHmkOi zQenPVK+Y%uyfV(+fMUq5rIH)U4#j!EZLg@Oo;h%cJAf4T<rBb@x{w+h=0!KO z7k!jv>qt-$G5Ew&HX-IWEPZ}rBD;pyP^RqCu&(mrLW{zcG`DW-7?H5vA9Iy(>}AF3 zcB9rw^EOgU%={Kl^My3$x-mY;ED4i(WP4(wVXW;1d8s9L^k8Jl=dF4Sy3jzaX+82B zvogQGZ!AK0XB4wD(?hLDt5Y*xld8{e>nC;o!0t&-w#(Ul2w=PU(Yw7c`gNCZ*<2yG zD$allK=T99Y%iS8VkA+*2JR3lqM1F=ac{aH*N_4%KtW!qMslp$CmYdzDVKD}G-$bs zGU!JicVjA`=MoL%5~JA?pTmUgWh*nBC!(kRGB?tb+Xf61zV?37l_)w!h6!dO#Ii2* zX)}*AX|x4I9jb#UmwxcDg(Za57iWQM6xv|CnTzjg)O$8BMtqHz>5O}qD(Q2fRL-tu^N z)G6okJbH(@`fv^9>yUjOHtb6JS7>LqZ9FwhLi2(7zQ+lQ)jg%GREF5``#Gt&4KkzM zht5~!k6r*ozd@6SoHf3X&JW-f0(BW?WKQ=Rh!Gy4TEg@lM-9z$>NHD~LJaRLj7ZJF z7u#z@-ZGPHx-~AxyIMH1-4JN?+I6Pf4q>cFk&d$1n2jbJRJhvb>iNc6tZYbsbc?hy zryEcpfc8@M;<}|MKezH|dmrAFp$rwzKRSf^sR1t;z9c0 z_dEx?y#!PY5o-LT5PHh7tg&0QIrt%O>FQavZz%r9sH3GOA7Rsir!Lg-@jo|kQpH-P zbi2S_agBu!AGhO~JwYtTQRUXWAI_vomRtKgU!Yrb)Mh9xw36eWlN$n$Jgd0r7%P6Q zwk1dU-VN4KQ=`jD$jQ8$$|4aXuIfn-gkq?J?=`K;mfyI;JdlW|g_(BDPf0yd;Z;*( zewjM%>#YaTE&wAyO9?z8r;wDd-1yaVh9y zDcVEB1)^vOmlsW2?vzuNA6+(?)yP;W?lL)drL^DlRm;PQw<%tF2nQO05=9!C zi5!$jM$cAVEJ zg48hQTwIJaxc!^YAE5+ZPSP@>2efBZn z<+*VsD~Rj5w)2_A3>LS%_0K;}MifN+*-?#5E}mW$H;>cPzxOpS+nk(mF|`v)+TavADw?kw=t<^Y=XT0fsY>%_ll)Q#s@8xTG7q_55Sd9&{-KEHE$2_aXW- zhmGkAj!ATa?qRjZrLBriGLs=ajAs4tJE=8Kk+R3Up`BC(d%AA_UPx0vc!(JDcli#i zq6eW3*Y)97%Y;7U8vXQ1TgD@48s2(Z)sJc2E?hWFtfZ{*^kw)8uTxe$7eYKPmNhT^ zR>`W9UeK^8GFl@T^!CS77yobXB|6RguuebmUF?i|O)1NLbM3-U3EJDd>-~a!yCk;XyWIXtb1N;7KzDxdpGXKq6 PEBB@rCs%Kj77_RxQ&6mr delta 2074 zcma)-do zohVWo*p4HkxN6xzk~mRxm?#6|go_UMHa$m(2{#RoNC=L^1&5jjN8`3tO-=2habDX_ zSuqL;|9_%Tp3rRxu?zsTh!h4zCYAyKBy$ zVt!kj9MU`P6K@SxHC_vD47`sT&MxeG^X~q&5rsGN1f6gmu3D${i|vwluA=EFM2p*E zyWN&=*2_?)2+#rwL@NNP5|8~@1WiZvt@|EY-D!*G6n}A)7m!t3sI-AxAv5_9R^R<* zbq+H3=E@7p(=o|BUXnKCXA8FE9-^GAew&Mn4IC3MVCHTCFqr}LLmk_-p%0c-sCbN@ z9tl~zZz#QY-iAMeynCYmvL4c1{@mW`&hZou{xusEGF4YuZ34w)bfaSRG_r^#httxo z{_#TyE$+>(4V$IS7a4^;%0+KWq*P~*{hrPrRjTAum-|o@h{;utR~~0oNSTGaU9O=& zG{8y2O~n1E?**3@>?oa@Ew{S-Lu)4Bb&xOQm>Y-vdPqv|$XQZx4oT1Gyppe3*%~w7VE=?xZ17Xhu+73NUl~f|fvHk$i%i{iOThb?u*G$}RXw&$xXxgucR;|H$#6r? zS4O^U!+GpQs3kQc4_p2|Ud1@7^&yiXEQ)qEBQ|o1N!63LG-GpgqXyn{UHbiejAss( zuix;A;fCfY*>zt)>z*;7sC(kO-6vr>uIviM$hDI!;W&f4+aDHl zQ*>2xtNEpB>!>e`s>mWPc$i{sHh#KQ&H;I`#&Le!$w9lQ%LU|+FVt*ezN9^JQ*Iui zS@p`@el#+2Aok(N2=}~AhLlXvn-TOhd*PNx=XV;+YhIP@w0k6L8^RK7$J>upacOF% zFsm~KcOqP&WbcS3#9LV5&q!JJYKW@+v#dkdRBU+gz*XV+#9ea%_%z>fAwA`4(%qlP zfrnH+wlFZ1nwrh_g~4>!ll6C>Q9Qdv!sDf0Qvttx>5PTLrW@UB z)6Mv}LU+J0UG-QROv3|cKN`Jy9O+qHzjpOK^?=0*2YRZ8uWpmY1B8>+gywR1W=|Sv zslowUZj_%8qHNR*GD45a^R@W-YS|EYkymYE*tv$|rPtGZU*k?SP>aFVb(e3gy_>so z7fvEp@*0W!(A}rZetn(vGO?~4oHdRN?AXwCVAggHWS!_gd|w0UqD>eu$9pc2n%Y}V z(jZJbyp8QMo|QbNGB&v`>@J6^$D7Ih_e91gRbpX|Md4{sFF0uW_S3DB!vrP=U)G?6 zqB=(SxZA)g>l}@Yy9!RO#bL@kpe=Al*yoo(vHaPwBh#w5&v;k18iswO`B8R-P&%16 z8Mz{{k?l^EK`-R^O?;e{zR|y~=V?+D09`LOiRZ68=U7%iWTM`Y>UFS=VHMrsIZCX^ z(gvj-1SnuNFS!S}w5klt{pMwV`QB97zE?`w#BgRR-rrzgFu;)zB?sM<;_u4HM%A@v zN_+ET4V(6#rvCAnRg%y{9Yo;~YuZTFF>7<-DA8oN0Ic@UTz$n@K))VCLsC5@w;xp= zUe3uatk=-WbHxe~I!D=ge$UJyZWFZMBo@?YV^#kv0Kuso1`R*t66?|NYKqRipPVRp zl20g-+^LCWX`Cfz)+@i5_L77x&^=r1!Fe^TZ$-_I?C9lx3mbnz7(^S{Bu0u5)FLM2 zG4UTOCZq^gB6R%|A?5y#NYq|2lK%(9_K7eoqV_h1cm5?JX8Avg{9VHWN=rdq2L1&4 CV4Vs8 diff --git a/ITS/Calib/GainSSD/Run0_999999999_v0_s0.root b/ITS/Calib/GainSSD/Run0_999999999_v0_s0.root index 42f04436147e6fc291f619f8f077750e97b90002..17f7c994201db1f225f09f6cc95fefbac6470b60 100644 GIT binary patch delta 2242 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 W(f{Dz3_ZW({}sKVuw9&S0q`fv0AD`< delta 2306 zcma)82~d+s7XCwE5Qb5Rq8tViRt{kxfGAf0gPWKgbQ0Y^t* zh#-OtQB<%{0znZ(IphWrFd&OcIKmM~2uc18%+%KGZtc`|)z|&1`n~tPuI}phb$o`G zeui7c5Q!H7pc4fEKqvsLq5)v#zQ|4z0VV=n{C8s>1OSON0A{vX@%f~`+yn_G+6C#X zJezZdr#%_FV;t+i{{?qJT5UBhH06VZw<~VVE#{Ob{U=C21xa>8W?;!Wv4bO$i47a_bT>HYNWE*$P&Ko88%2@K|cM zY}_=&e(Uw_kCaPb?FAK~X)Ve~ZhryMQ?*vnZ}U{`(U2^0+_QyIT*st`ciU8rt~gHC z+m~eiRYqK1)5BbP=S76E%MqO8n0Rn&lZn~b1-FGJ-PDh-SXE01*Q($C&cUWZNtjx+ z3;_$~=7Iw5s9;XWZ8HBdJ>8SSp+H;~G+PwFUs&CaHKu9>3O3q% zSoJBZ14O|^a8`8!1fktlf>C!XXpEJ@U8!b4Y|+Zc1Xx1MO^7QL7Uo*S{S(F|MjlN)Q&6Fz5)G^i@Hzf_iK>#s+u=%#1=CtgIIQ160)%Sf}oFW#-0`Fc~ z^_^0scxiYU&VIIhf_@Ejt@+W?_``V3vzsS=5ft~E^(lUTOF7@OxF~ks^|=WvU8t7? z5}Mn5#T?Tk&2n)8>K7 zMcZb3r4QAvyn^43c+DB^%6THEbUPl4inw+6aABrC@A8kqKJa9R)xiYw{=&KPAY5oS z;S4+5P3mU7-y(SOQrUM8$B=l_<5|~La6hM{3w!gmFO}3PUZu6ps`Q!hq-IOMoFUuq zuXC-@O^SbU_Nk#@t-YOrD~=}7-ml5?0=|;YMtY)t5L@}G$!?#_eyS2dfidIyd*3;l z|LVG?P*0X7$E4Hgc1D6)1Su#uREXm7}!`N1ZJ%ZTj9c$#*Dl+}ogKZW?Lil_>`AlEG-IRmvB! zwT#G#hmC&Gwmj=bJ3kcdgPlw8`|y`P!wIogr)^0XYRFNTvgwV&?s#(xK9$1{qv=k` zs@nA?90<3Su!zuA!g+pc!3bX-{i&z^T#fQ0RAC^pJv=7<0X@zZfV`mb9?Qk!YWv zWpT7-W^Kkqhd%f`*=fdbh28k}nD3R69&#t`S<&c54EC^(UgkM-pSh(9h3r<;QASR# zY{%c8t?a;5pRn`EO3pIhSBV^byrYEG^+;IdA3D-;4_jSx1CPfGb@7ocq?z*KRu^R*=e;*eQnuK zTFdsBhGHu$KgQiq{R-P>?L_|6ZO>Pr9+?ol5tx|CwfMYb6!P$h-9Uyr)a^Fx{YZea zc};oJO0s{YKdxltphA3Y!i=5u8j?I@cu!hEvMNqh{W7F~M{ksA`!*)_zAcYs))31Y z@{!d;;9)eImd5B_HRxDNqvDBbr$Xn!8+#Al|G{F9Rlg%j+ta!NE8jF+2_FXcoHk63 zAUl4eKcP_Pq(t{duqEW#$_E)H-WFQ5^P8T0Yg~N5rq+1pFIeJ*7K!L)JQvUlYR8Eo1hGdTqtF3^3mQWVdC2 zs4a_H^k2vTnSa*-7{zVX@jrSs5+}-*w9O&?Cyp(-@>d-HK_Mmj{8!Nlhi?G?1RA3^ AMgRZ+ diff --git a/ITS/ITSbaseLinkDef.h b/ITS/ITSbaseLinkDef.h index 0e5fb9c67c2..f462d10f128 100644 --- a/ITS/ITSbaseLinkDef.h +++ b/ITS/ITSbaseLinkDef.h @@ -59,8 +59,11 @@ #pragma link C++ class AliITSDriftSpeedArraySDD+; #pragma link C++ class AliITSDDLModuleMapSDD+; #pragma link C++ class AliITSBadChannelsSSD+; +#pragma link C++ class AliITSBadChannelsSSDv2+; #pragma link C++ class AliITSGainSSD+; +#pragma link C++ class AliITSGainSSDv2+; #pragma link C++ class AliITSNoiseSSD+; +#pragma link C++ class AliITSNoiseSSDv2+; #pragma link C++ class AliITSHandleDaSSD+; #pragma link C++ class AliITSModuleDaSSD+; #pragma link C++ class AliITSChannelDaSSD+; @@ -96,6 +99,7 @@ #pragma link C++ class AliITSIntMap+; #pragma link C++ class AliITSIntMapNode+; #pragma link C++ class AliITSPedestalSSD+; +#pragma link C++ class AliITSPedestalSSDv2+; #pragma link C++ class AliITSSurveyToAlignSSD+; #endif diff --git a/ITS/libITSbase.pkg b/ITS/libITSbase.pkg index dd1e1373bcb..222d2024ba3 100644 --- a/ITS/libITSbase.pkg +++ b/ITS/libITSbase.pkg @@ -38,8 +38,11 @@ SRCS = AliITSgeom.cxx \ AliITSDDLModuleMapSDD.cxx \ AliITSDriftSpeedArraySDD.cxx \ AliITSBadChannelsSSD.cxx \ + AliITSBadChannelsSSDv2.cxx \ AliITSGainSSD.cxx \ + AliITSGainSSDv2.cxx \ AliITSNoiseSSD.cxx \ + AliITSNoiseSSDv2.cxx \ AliITSChannelDaSSD.cxx \ AliITSModuleDaSSD.cxx \ AliITSHandleDaSSD.cxx \ @@ -64,6 +67,7 @@ SRCS = AliITSgeom.cxx \ AliITSIntMap.cxx \ AliITSIntMapNode.cxx \ AliITSPedestalSSD.cxx \ + AliITSPedestalSSDv2.cxx \ AliITSSurveyToAlignSSD.cxx HDRS:= $(SRCS:.cxx=.h) -- 2.39.3