X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITSHandleDaSSD.cxx;h=a17b9681c5556937bb9262b231aae6a7d2f882e5;hb=76ec83068fbf25b40552c6cc2d892dc6c7722fae;hp=f1a7a1b31f6c29e164cd338adc62f2f8201a8452;hpb=a69c8ba0de95e8bceca88dff0544fa1a39013c95;p=u%2Fmrichter%2FAliRoot.git diff --git a/ITS/AliITSHandleDaSSD.cxx b/ITS/AliITSHandleDaSSD.cxx index f1a7a1b31f6..a17b9681c55 100644 --- a/ITS/AliITSHandleDaSSD.cxx +++ b/ITS/AliITSHandleDaSSD.cxx @@ -19,9 +19,13 @@ /// /// This class provides ITS SSD data handling /// used by DA. -/// +// Author: Oleksandr Borysov +// Date: 18/07/2008 /////////////////////////////////////////////////////////////////////////////// +#include +#include +#include #include #include "AliITSHandleDaSSD.h" #include @@ -29,12 +33,13 @@ #include "event.h" #include "TFile.h" #include "TString.h" -#include "TObjArray.h" #include "AliLog.h" -#include "AliITSNoiseSSD.h" +#include "AliITSNoiseSSDv2.h" +#include "AliITSPedestalSSDv2.h" +#include "AliITSBadChannelsSSDv2.h" #include "AliITSRawStreamSSD.h" #include "AliRawReaderDate.h" - +#include "AliITSRawStreamSSD.h" #include "AliITSChannelDaSSD.h" @@ -44,10 +49,19 @@ using namespace std; const Int_t AliITSHandleDaSSD::fgkNumberOfSSDModules = 1698; // Number of SSD modules in ITS -const Int_t AliITSHandleDaSSD::fgkNumberOfSSDModulesPerDdl = 108; // Number of SSD modules in ITS +const Int_t AliITSHandleDaSSD::fgkNumberOfSSDModulesPerDdl = 108; // Number of SSD modules in DDL +const Int_t AliITSHandleDaSSD::fgkNumberOfSSDModulesPerSlot = 12; // Number of SSD modules in Slot +const Short_t AliITSHandleDaSSD::fgkMinSSDModuleId = 500; // Initial SSD modules number +const Int_t AliITSHandleDaSSD::fgkNumberOfSSDSlotsPerDDL = 9; // Number of SSD slots per DDL +const Int_t AliITSHandleDaSSD::fgkNumberOfSSDDDLs = 16; // Number of SSD modules in Slot const Float_t AliITSHandleDaSSD::fgkPedestalThresholdFactor = 3.0; // Defalt value for fPedestalThresholdFactor const Float_t AliITSHandleDaSSD::fgkCmThresholdFactor = 3.0; // Defalt value for fCmThresholdFactor +const UInt_t AliITSHandleDaSSD::fgkZsBitMask = 0x0000003F; // Bit mask for FEROM ZS +const UInt_t AliITSHandleDaSSD::fgkOffSetBitMask = 0x000003FF; // Bit mask for FEROM Offset correction +const UInt_t AliITSHandleDaSSD::fgkBadChannelMask = 0x00000001; // Mask to suppress the channel from the bad channel list +const Int_t AliITSHandleDaSSD::fgkAdcPerDBlock = 6; // FEROM configuration file constant + //______________________________________________________________________________ AliITSHandleDaSSD::AliITSHandleDaSSD() : fRawDataFileName(NULL), @@ -55,11 +69,22 @@ AliITSHandleDaSSD::AliITSHandleDaSSD() : fModules(NULL), fModIndProcessed(0), fModIndRead(0), + fModIndex(NULL), + fEqIndex(0), fNumberOfEvents(0), + fBadChannelsList(NULL), + fDDLModuleMap(NULL), + fALaddersOff(0), + fCLaddersOff(0), fLdcId(0), fRunId(0), fPedestalThresholdFactor(fgkPedestalThresholdFactor), - fCmThresholdFactor(fgkCmThresholdFactor) + fCmThresholdFactor(fgkCmThresholdFactor), + fZsDefault(-1), + fOffsetDefault(INT_MAX), + fZsMinimum(2), + fMergeBCLists(1), + fZsFactor(3.0) { // Default constructor } @@ -72,11 +97,22 @@ AliITSHandleDaSSD::AliITSHandleDaSSD(Char_t *rdfname) : fModules(NULL), fModIndProcessed(0), fModIndRead(0), + fModIndex(NULL), + fEqIndex(0), fNumberOfEvents(0), + fBadChannelsList(NULL), + fDDLModuleMap(NULL), + fALaddersOff(0), + fCLaddersOff(0), fLdcId(0), fRunId(0), fPedestalThresholdFactor(fgkPedestalThresholdFactor) , - fCmThresholdFactor(fgkCmThresholdFactor) + fCmThresholdFactor(fgkCmThresholdFactor), + fZsDefault(-1), + fOffsetDefault(INT_MAX), + fZsMinimum(2), + fMergeBCLists(1), + fZsFactor(3.0) { if (!Init(rdfname)) AliError("AliITSHandleDaSSD::AliITSHandleDaSSD() initialization error!"); } @@ -90,11 +126,22 @@ AliITSHandleDaSSD::AliITSHandleDaSSD(const AliITSHandleDaSSD& ssdadldc) : fModules(NULL), fModIndProcessed(ssdadldc.fModIndProcessed), fModIndRead(ssdadldc.fModIndRead), + fModIndex(NULL), + fEqIndex(0), fNumberOfEvents(ssdadldc.fNumberOfEvents), + fBadChannelsList(NULL), + fDDLModuleMap(NULL), + fALaddersOff(ssdadldc.fALaddersOff), + fCLaddersOff(ssdadldc.fCLaddersOff), fLdcId(ssdadldc.fLdcId), fRunId(ssdadldc.fRunId), fPedestalThresholdFactor(ssdadldc.fPedestalThresholdFactor), - fCmThresholdFactor(ssdadldc.fCmThresholdFactor) + fCmThresholdFactor(ssdadldc.fCmThresholdFactor), + fZsDefault(ssdadldc.fZsDefault), + fOffsetDefault(ssdadldc.fOffsetDefault), + fZsMinimum(ssdadldc.fZsMinimum), + fMergeBCLists(ssdadldc.fMergeBCLists), + fZsFactor(ssdadldc.fZsFactor) { // copy constructor if ((ssdadldc.fNumberOfModules > 0) && (ssdadldc.fModules)) { @@ -118,6 +165,8 @@ AliITSHandleDaSSD::AliITSHandleDaSSD(const AliITSHandleDaSSD& ssdadldc) : fModules = NULL; } } + if (ssdadldc.fBadChannelsList) AliWarning("fBadChannelsList is not copied by copy constructor, use other methods to init it!"); + if (ssdadldc.fDDLModuleMap) AliWarning("fDDLModuleMap is not copied by copy constructor, use other methods to init it!"); } @@ -126,25 +175,27 @@ AliITSHandleDaSSD& AliITSHandleDaSSD::operator = (const AliITSHandleDaSSD& ssdad { // assignment operator if (this == &ssdadldc) return *this; + TObject::operator=(ssdadldc); if (fModules) { for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i]; delete [] fModules; fModules = NULL; } + if (fModIndex) { delete [] fModIndex; fModIndex = NULL; } if ((ssdadldc.fNumberOfModules > 0) && (ssdadldc.fModules)) { fModules = new (nothrow) AliITSModuleDaSSD* [ssdadldc.fNumberOfModules]; if (fModules) { for (Int_t modind = 0; modind < ssdadldc.fNumberOfModules; modind++) { if (ssdadldc.fModules[modind]) { - fModules[modind] = new AliITSModuleDaSSD(*(ssdadldc.fModules[modind])); - if (!fModules[modind]) { - AliError("AliITSHandleDaSSD: Error assignment operator"); + fModules[modind] = new AliITSModuleDaSSD(*(ssdadldc.fModules[modind])); + if (!fModules[modind]) { + AliError("AliITSHandleDaSSD: Error assignment operator"); for (Int_t i = (modind - 1); i >= 0; i--) delete fModules[modind]; - delete [] fModules; - fModules = NULL; - break; - } - } else fModules[modind] = NULL; + delete [] fModules; + fModules = NULL; + break; + } + } else fModules[modind] = NULL; } } else { AliError(Form("AliITSHandleDaSSD: Error allocating memory for %i AliITSModulesDaSSD* objects!", ssdadldc.fNumberOfModules)); @@ -152,6 +203,28 @@ AliITSHandleDaSSD& AliITSHandleDaSSD::operator = (const AliITSHandleDaSSD& ssdad fModules = NULL; } } + fRawDataFileName = NULL; + fModIndProcessed = 0; + fModIndRead = 0; + fModIndex = NULL; + fEqIndex = ssdadldc.fEqIndex; + fNumberOfEvents = ssdadldc.fNumberOfEvents; + fLdcId = ssdadldc.fLdcId; + fRunId = ssdadldc.fRunId; + fPedestalThresholdFactor = ssdadldc.fPedestalThresholdFactor; + fCmThresholdFactor = ssdadldc.fCmThresholdFactor; + fZsDefault = ssdadldc.fZsDefault; + fOffsetDefault = ssdadldc.fOffsetDefault; + fZsMinimum = ssdadldc.fZsMinimum; + fMergeBCLists = ssdadldc.fMergeBCLists; + fZsFactor = ssdadldc.fZsFactor; + fALaddersOff = ssdadldc.fALaddersOff; + fCLaddersOff = ssdadldc.fCLaddersOff; + fBadChannelsList = NULL; + fDDLModuleMap = NULL; + fModIndex = NULL; + if (ssdadldc.fBadChannelsList) AliWarning("fBadChannelsList is not copied by assignment operator, use other methods to init it!"); + if (ssdadldc.fDDLModuleMap) AliWarning("fDDLModuleMap is not copied by assignment operator, use other methods to init it!"); return *this; } @@ -168,6 +241,9 @@ AliITSHandleDaSSD::~AliITSHandleDaSSD() } delete [] fModules; } + if (fModIndex) delete [] fModIndex; + if (fBadChannelsList) delete fBadChannelsList; + if (fDDLModuleMap) delete [] fDDLModuleMap; } @@ -180,7 +256,17 @@ void AliITSHandleDaSSD::Reset() for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i]; delete [] fModules; fModules = NULL; - } + } + if (fModIndex) { delete [] fModIndex; fModIndex = NULL; } +/* + if (fBadChannelsList) { + delete fBadChannelsList; + fBadChannelsList = NULL; + } + if (fDDLModuleMap) { delete [] fDDLModuleMap; fDDLModuleMap = NULL; } +*/ + fALaddersOff.Set(0); + fCLaddersOff.Set(0); fRawDataFileName = NULL; fModIndProcessed = fModIndRead = 0; fNumberOfEvents = 0; @@ -192,7 +278,7 @@ void AliITSHandleDaSSD::Reset() //______________________________________________________________________________ -Bool_t AliITSHandleDaSSD::Init(Char_t *rdfname, const Char_t *configfname) +Bool_t AliITSHandleDaSSD::Init(Char_t *rdfname) { // Read raw data file and set initial and configuration parameters Long_t physeventind = 0, strn = 0, nofstripsev, nofstrips = 0; @@ -201,44 +287,45 @@ Bool_t AliITSHandleDaSSD::Init(Char_t *rdfname, const Char_t *configfname) UChar_t *data = NULL; Long_t datasize = 0, eqbelsize = 1; - if (configfname) ReadConfigurationFile(configfname); rawreaderdate = new AliRawReaderDate(rdfname, 0); if (!(rawreaderdate->GetAttributes() || rawreaderdate->GetEventId())) { AliError(Form("AliITSHandleDaSSD: Error reading raw data file %s by RawReaderDate", rdfname)); MakeZombie(); return kFALSE; - } + } if (rawreaderdate->NextEvent()) { - fLdcId = rawreaderdate->GetLDCId(); fRunId = rawreaderdate->GetRunNumber(); rawreaderdate->RewindEvents(); } else { MakeZombie(); return kFALSE; } if (fModules) Reset(); - rawreaderdate->SelectEvents(-1); + //rawreaderdate->SelectEvents(-1); + rawreaderdate->Select("ITSSSD"); nofstrips = 0; while (rawreaderdate->NextEvent()) { if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue; nofstripsev = 0; nofeqipmentev = 0; while (rawreaderdate->ReadNextData(data)) { + fLdcId = rawreaderdate->GetLDCId(); nofeqipmentev += 1; datasize = rawreaderdate->GetDataSize(); eqbelsize = rawreaderdate->GetEquipmentElementSize(); - if ( (datasize % eqbelsize) || (eqbelsize != sizeof(long32)) ) { - AliError(Form("AliITSHandleDaSSD: Error Init(%s): event data size %i is not an integer of equipment data size %i", + if ( datasize % eqbelsize ) { + AliError(Form("AliITSHandleDaSSD: Error Init(%s): event data size %ld is not an integer of equipment data size %ld", rdfname, datasize, eqbelsize)); MakeZombie(); - return kFALSE; + return kFALSE; } - nofstripsev += (Int_t) (datasize / eqbelsize); + nofstripsev += (Int_t) (datasize / eqbelsize); } if (physeventind++) { - if (nofstrips != nofstripsev) AliWarning("AliITSHandleDaSSD: number of strips varies from event to evnt"); - if (nofeqipment != nofeqipmentev) AliWarning("AliITSHandleDaSSD: number of DDLs varies from event to evnt"); + if (nofstrips != nofstripsev) AliWarning(Form("AliITSHandleDaSSD: number of strips varies from event to event, ev = %ld, %ld", + physeventind, nofstripsev)); + if (nofeqipment != nofeqipmentev) AliWarning("AliITSHandleDaSSD: number of DDLs varies from event to event"); } nofstrips = nofstripsev; nofeqipment = nofeqipmentev; - if (strn < nofstrips) strn = nofstrips; + if (strn < nofstrips) strn = nofstrips; if (eqn < nofeqipment) eqn = nofeqipment; } delete rawreaderdate; @@ -246,8 +333,15 @@ Bool_t AliITSHandleDaSSD::Init(Char_t *rdfname, const Char_t *configfname) { fNumberOfEvents = physeventind; fRawDataFileName = rdfname; - if (SetNumberOfModules(fgkNumberOfSSDModules)) { - TString str = TString::Format("Max number of equipment: %i, max number of channels: %i\n", eqn, strn); + fEqIndex.Set(eqn); + fEqIndex.Reset(-1); + fModIndex = new (nothrow) Int_t [fgkNumberOfSSDModulesPerDdl * eqn]; + if (fModIndex) + for (Int_t i = 0; i < fgkNumberOfSSDModulesPerDdl * eqn; i++) fModIndex[i] = -1; + else AliWarning(Form("AliITSHandleDaSSD: Error Init(%s): Index array for %i modules was not created", + rdfname, fgkNumberOfSSDModulesPerDdl * eqn)); + if (SetNumberOfModules(fgkNumberOfSSDModulesPerDdl * eqn)) { + TString str = TString::Format("Max number of equipment: %d, max number of channels: %ld\n", eqn, strn); DumpInitData(str.Data()); return kTRUE; } @@ -257,14 +351,6 @@ Bool_t AliITSHandleDaSSD::Init(Char_t *rdfname, const Char_t *configfname) } -//______________________________________________________________________________ -Bool_t AliITSHandleDaSSD::ReadConfigurationFile(const Char_t *configfname) -const { -// Dowload configuration parameters from configuration file or database - return kFALSE; -} - - //______________________________________________________________________________ AliITSModuleDaSSD* AliITSHandleDaSSD::GetModule (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const @@ -362,66 +448,87 @@ Bool_t AliITSHandleDaSSD::SetNumberOfModules (const Int_t numberofmodules) //______________________________________________________________________________ -Bool_t AliITSHandleDaSSD::ReadCalibrationDataFile (char* fileName, const Long_t eventsnumber) +Bool_t AliITSHandleDaSSD::ReadStaticBadChannelsMap(const Char_t *filename) +{ +// Reads Static Bad Channels Map from the file + TFile *bcfile; + if (!filename) { + AliWarning("No file name is specified for Static Bad Channels Map!"); + return kFALSE; + } + bcfile = new TFile(filename, "READ"); + if (bcfile->IsZombie()) { + AliWarning(Form("Error reading file %s with Static Bad Channels Map!", filename)); + return kFALSE; + } + bcfile->GetObject("AliITSBadChannelsSSDv2;1", fBadChannelsList); + if (!fBadChannelsList) { + AliWarning("Error fBadChannelsList == NULL!"); + bcfile->Close(); + delete bcfile; + return kFALSE; + } + bcfile->Close(); + delete bcfile; + return kTRUE; +} + + + +Bool_t AliITSHandleDaSSD::ReadDDLModuleMap(const Char_t *filename) +{ +// Reads the SSD DDL Map from the file + ifstream ddlmfile; + AliRawReaderDate *rwr = NULL; + AliITSRawStreamSSD *rsm = NULL; + void *event = NULL; + if (fDDLModuleMap) { delete [] fDDLModuleMap; fDDLModuleMap = NULL;} + fDDLModuleMap = new (nothrow) Int_t [fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl]; + if (!fDDLModuleMap) { + AliWarning("Error allocation memory for DDL Map!"); + return kFALSE; + } + if (!filename) { + AliWarning("No file name is specified for SSD DDL Map, using the one from AliITSRawStreamSSD!"); + rwr = new AliRawReaderDate(event); + rsm = new AliITSRawStreamSSD(rwr); + rsm->Setv11HybridDDLMapping(); + for (Int_t ddli = 0; ddli < fgkNumberOfSSDDDLs; ddli++) + for (Int_t mi = 0; mi < fgkNumberOfSSDModulesPerDdl; mi++) + fDDLModuleMap[(ddli * fgkNumberOfSSDModulesPerDdl + mi)] = rsm->GetModuleNumber(ddli, mi); + if (rsm) delete rsm; + if (rwr) delete rwr; + return kTRUE; + } + ddlmfile.open(filename, ios::in); + if (!ddlmfile.is_open()) { + AliWarning(Form("Error reading file %s with SSD DDL Map!", filename)); + if (fDDLModuleMap) { delete [] fDDLModuleMap; fDDLModuleMap = NULL;} + return kFALSE; + } + Int_t ind = 0; + while((!ddlmfile.eof()) && (ind < (fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl))) { + ddlmfile >> fDDLModuleMap[ind++]; + if (ddlmfile.fail()) AliError(Form("Error extracting number from the DDL map file %s, ind: %d ", filename, ind)); + } + if (ind != (fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl)) + AliWarning(Form("Only %i (< %i) entries were read from DDL Map!", ind, (fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl))); + ddlmfile.close(); + return kTRUE; +} + + + +//______________________________________________________________________________ +Int_t AliITSHandleDaSSD::ReadCalibrationDataFile (char* fileName, const Long_t eventsnumber) { // Reads raw data from file - AliRawReaderDate *rawreaderdate = NULL; - AliITSModuleDaSSD *module; - AliITSChannelDaSSD *strip; - Long_t datasize, eventind = 0; - Int_t nofstrips, eqbelsize; - UShort_t modind; - long32 *data; - UChar_t *databyte; if (!Init(fileName)){ AliError("AliITSHandleDaSSD: Error ReadCalibrationDataFile"); return kFALSE; } - rawreaderdate = new AliRawReaderDate(fileName, 0); - rawreaderdate->SelectEvents(-1); - while (rawreaderdate->NextEvent()) { - if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue; - fLdcId = rawreaderdate->GetLDCId(); - fRunId = rawreaderdate->GetRunNumber(); - modind = 0; - while (rawreaderdate->ReadNextData(databyte)) { - data = reinterpret_cast(databyte); - Int_t equipid = rawreaderdate->GetEquipmentId(); // EquipmentID required to access to rorc - Int_t equiptype = rawreaderdate->GetEquipmentType(); // - UChar_t ddlID = (UChar_t)rawreaderdate->GetDDLID(); // GetDDLID(); index of DDL, ITS SSD: 33-48 - datasize = rawreaderdate->GetDataSize(); - eqbelsize = rawreaderdate->GetEquipmentElementSize(); - if ( (datasize % eqbelsize) || (eqbelsize != sizeof(long32)) ) { - AliError(Form("AliITSHandleDaSSD: Error ReadCalibrationDataFile: event data size %i is not an integer of equipment data size %i", - datasize, eqbelsize)); - return kFALSE; - } - nofstrips = (Int_t) (datasize / eqbelsize); - for (Int_t strind = 0; strind < nofstrips; strind++) { - UChar_t ad = (UChar_t) (data[strind] >> 28) & 0x0000000F; // index of AD module 0-9 - UChar_t adc = (UChar_t) (data[strind] >> 24) & 0x0000000F; // index of ADC module 0-5, 8-13 - UShort_t stripID = (UShort_t)(data[strind] >> 12) & 0x000007FF; // strip number 0-1535 - Short_t signal = (Short_t)(data[strind] & 0x00000FFF); - signal = (signal > AliITSChannelDaSSD::GetUnderflowConst()) ? (signal - 2 * AliITSChannelDaSSD::GetUnderflowConst()) - : signal; - if (!(module = GetModule(ddlID, ad, adc))) { - module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst()); - if (!module->SetModuleIdData (ddlID, ad, adc, RetrieveModuleId(ddlID, ad, adc))) return kFALSE; - module->SetModuleRorcId (equipid, equiptype); - fModules[modind++] = module; - } - if (!(strip = module->GetStrip(stripID))) { - strip = new AliITSChannelDaSSD(stripID, eventsnumber); - module->SetStrip(strip, stripID); - } - strip->SetSignal(eventind, signal); - } - if (modind) cout << "The memory was allocated for " << modind << " modules." << endl; - } - if (++eventind > eventsnumber) break; - } - delete rawreaderdate; - return RelocateModules(); + fNumberOfEvents = eventsnumber; + return ReadModuleRawData (fNumberOfModules); } @@ -430,62 +537,76 @@ Bool_t AliITSHandleDaSSD::ReadCalibrationDataFile (char* fileName, const Long_t Int_t AliITSHandleDaSSD::ReadModuleRawData (const Int_t modulesnumber) { // Reads raw data from file - AliRawReaderDate *rawreaderdate = NULL; + AliRawReader *rawreaderdate = NULL; + AliITSRawStreamSSD *stream = NULL; AliITSModuleDaSSD *module; AliITSChannelDaSSD *strip; - Long_t datasize, eventind = 0; - Int_t nofstrips, eqbelsize; - UShort_t modind; - long32 *data; - UChar_t *databyte; + Long_t eventind = 0; + Int_t nofeqipment, eqind; + Short_t equipid, prequipid; + Short_t modind; if (!(rawreaderdate = new AliRawReaderDate(fRawDataFileName, 0))) return 0; if (!fModules) { AliError("AliITSHandleDaSSD: Error ReadModuleRawData: no structure was allocated for data"); return 0; } - rawreaderdate->SelectEvents(-1); + if (!fDDLModuleMap) if (!ReadDDLModuleMap()) AliWarning("DDL map is not defined, ModuleID will be set to 0!"); + stream = new AliITSRawStreamSSD(rawreaderdate); + stream->Setv11HybridDDLMapping(); + //rawreaderdate->SelectEvents(-1); + rawreaderdate->Select("ITSSSD"); modind = 0; + nofeqipment = 0; while (rawreaderdate->NextEvent()) { if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue; - while (rawreaderdate->ReadNextData(databyte)) { - data = reinterpret_cast(databyte); - Int_t equipid = rawreaderdate->GetEquipmentId(); // EquipmentID required to access to rorc - Int_t equiptype = rawreaderdate->GetEquipmentType(); // - UChar_t ddlID = (UChar_t)rawreaderdate->GetDDLID(); // GetDDLID(); index of DDL, ITS SSD: 33-48 - datasize = rawreaderdate->GetDataSize(); - eqbelsize = rawreaderdate->GetEquipmentElementSize(); - if ( (datasize % eqbelsize) || (eqbelsize != sizeof(long32)) ) { - AliError(Form("AliITSHandleDaSSD: Error ReadCalibrationDataFile: event data size %i is not an integer of equipment data size %i", - datasize, eqbelsize)); - return kFALSE; + prequipid = -1; + eqind = -1; + while (stream->Next()) { + equipid = rawreaderdate->GetEquipmentId(); + if ((equipid != prequipid)) { + if ((eqind = GetEqIndex(equipid)) < 0) { fEqIndex.AddAt(equipid, nofeqipment); eqind = nofeqipment++; } + prequipid = equipid; } - nofstrips = (Int_t) (datasize / eqbelsize); - for (Int_t strind = 0; strind < nofstrips; strind++) { - UChar_t ad = (UChar_t) (data[strind] >> 28) & 0x0000000F; // index of AD module 0-9 - UChar_t adc = (UChar_t) (data[strind] >> 24) & 0x0000000F; // index of ADC module 0-5, 8-13 - UShort_t stripID = (UShort_t)(data[strind] >> 12) & 0x000007FF; // strip number 0-1535 - Short_t signal = (Short_t)(data[strind] & 0x00000FFF); - signal = (signal > AliITSChannelDaSSD::GetUnderflowConst()) ? (signal - 2 * AliITSChannelDaSSD::GetUnderflowConst()) - : signal; - Int_t modpos = GetModuleIndex(ddlID, ad, adc); - if (((modpos > 0) && (modpos < fModIndRead)) || ((modpos < 0) && (modind == modulesnumber))) continue; - if ((modpos < 0) && (modind < modulesnumber)) { - module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst()); - if (!module->SetModuleIdData (ddlID, ad, adc, RetrieveModuleId(ddlID, ad, adc))) return 0; - module->SetModuleRorcId (equipid, equiptype); - modpos = fModIndRead + modind; - modind += 1; - fModules[modpos] = module; - } + Int_t equiptype = rawreaderdate->GetEquipmentType(); + UChar_t ddlID = (UChar_t)rawreaderdate->GetDDLID(); + UChar_t ad = stream->GetAD(); + UChar_t adc = stream->GetADC(); + UShort_t stripID = stream->GetSideFlag() ? AliITSChannelDaSSD::GetMaxStripIdConst() - stream->GetStrip() : stream->GetStrip(); + Short_t signal = stream->GetSignal(); + + Int_t indpos = (eqind * fgkNumberOfSSDModulesPerDdl) + + ((ad - 1) * fgkNumberOfSSDModulesPerSlot) + (adc < 6 ? adc : (adc - 2)); + Int_t modpos = fModIndex[indpos]; + if (((modpos > 0) && (modpos < fModIndRead)) || ((modpos < 0) && (modind == modulesnumber))) continue; + if ((modpos < 0) && (modind < modulesnumber)) { + module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst()); + Int_t mddli; + if (fDDLModuleMap) mddli = RetrieveModuleId(ddlID, ad, adc); + else mddli = 0; + if (!module->SetModuleIdData (ddlID, ad, adc, mddli)) return 0; + module->SetModuleRorcId (equipid, equiptype); + modpos = fModIndRead + modind; + modind += 1; + fModules[modpos] = module; + fModIndex[indpos] = modpos; + } + if (stripID < AliITSModuleDaSSD::GetStripsPerModuleConst()) { if (!(strip = fModules[modpos]->GetStrip(stripID))) { strip = new AliITSChannelDaSSD(stripID, fNumberOfEvents); fModules[modpos]->SetStrip(strip, stripID); } strip->SetSignal(eventind, signal); - } + } else { + if (!(fModules[modpos]->GetCMFerom())) { + fModules[modpos]->AllocateCMFeromArray(); + fModules[modpos]->SetCMFeromEventsNumber(fNumberOfEvents); + } + fModules[modpos]->SetCMFerom(signal, (stripID - AliITSModuleDaSSD::GetStripsPerModuleConst()), eventind); + } } if (++eventind > fNumberOfEvents) break; } + delete stream; delete rawreaderdate; if (modind) cout << "The memory was allocated for " << modind << " modules." << endl; fModIndRead += modind; @@ -520,12 +641,46 @@ Bool_t AliITSHandleDaSSD::RelocateModules() +//______________________________________________________________________________ +Bool_t AliITSHandleDaSSD::AddFeromCm(AliITSModuleDaSSD *const module) +// Restore the original signal value adding CM calculated and subtracted in ferom +{ + AliITSChannelDaSSD *strip; + Short_t *signal, *cmferom; + + if (!module) return kFALSE; + if (!module->GetCMFerom()) return kTRUE; + for (Int_t chipind = 0; chipind < AliITSModuleDaSSD::GetChipsPerModuleConst(); chipind++) { + if (!(cmferom = module->GetCMFerom(chipind))) { + AliWarning(Form("AliITSHandleDaSSD: There is no Ferom CM values for chip %i, module %i!", chipind, module->GetModuleId())); + continue; + } + for (Int_t strind = (chipind * AliITSModuleDaSSD::GetStripsPerChip()); + strind < ((chipind + 1) * AliITSModuleDaSSD::GetStripsPerChip()); strind++) { + if (!(strip = module->GetStrip(strind))) continue; + if (!(signal = strip->GetSignal())) continue; +// if (strip->GetEventsNumber() != module->GetEventsNumber()) return kFALSE; + Long_t ovev = 0; + for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) { + if (SignalOutOfRange(signal[ev]) || SignalOutOfRange(cmferom[ev])) ovev += 1; + else { + Short_t signal1 = signal[ev] + cmferom[ev]; + strip->SetSignal(ev, signal1); + } + } + } + } + return kTRUE; +} + + + //______________________________________________________________________________ Bool_t AliITSHandleDaSSD::CalculatePedestal(AliITSModuleDaSSD *const module) { // Calculates Pedestal AliITSChannelDaSSD *strip; - Float_t pedestal, noise; + Double_t pedestal, noise; Short_t *signal; Long_t ovev, ev, n; if (!module) return kFALSE; @@ -537,13 +692,13 @@ Bool_t AliITSHandleDaSSD::CalculatePedestal(AliITSModuleDaSSD *const module) continue; } //************* pedestal first pass **************** - pedestal = 0.0f; + pedestal = 0.0L; ovev = 0l; for (ev = 0; ev < strip->GetEventsNumber(); ev++) if (SignalOutOfRange(signal[ev])) ovev += 1; - else pedestal = ((ev - ovev)) ? pedestal + (signal[ev] - pedestal) / static_cast(ev - ovev + 1) : signal[ev]; + else pedestal = ((ev - ovev)) ? pedestal + (signal[ev] - pedestal) / static_cast(ev - ovev + 1) : signal[ev]; if (ev == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue(); - strip->SetPedestal(pedestal); + strip->SetPedestal(static_cast(pedestal)); //************* noise ******************************* Double_t nsum = 0.0L; ovev = 0l; @@ -551,18 +706,18 @@ Bool_t AliITSHandleDaSSD::CalculatePedestal(AliITSModuleDaSSD *const module) if (SignalOutOfRange(signal[ev])) ovev += 1; else nsum += pow((signal[ev] - strip->GetPedestal()), 2); } - if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(nsum / (Float_t)(n)); + if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(nsum / (Double_t)(n)); else noise = AliITSChannelDaSSD::GetUndefinedValue(); - strip->SetNoise(noise); + strip->SetNoise(static_cast(noise)); //************* pedestal second pass **************** - pedestal = 0.0f; + pedestal = 0.0L; ovev = 0l; for (ev = 0; ev < strip->GetEventsNumber(); ev++) if ( SignalOutOfRange(signal[ev]) || TMath::Abs(signal[ev] - strip->GetPedestal()) > (fPedestalThresholdFactor * strip->GetNoise())) ovev += 1; - else pedestal = ((ev - ovev)) ? pedestal + (signal[ev] - pedestal) / static_cast(ev - ovev + 1) : signal[ev]; + else pedestal = ((ev - ovev)) ? pedestal + (signal[ev] - pedestal) / static_cast(ev - ovev + 1) : signal[ev]; if (ev == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue(); - strip->SetPedestal(pedestal); + strip->SetPedestal(static_cast(pedestal)); strip->SetOverflowNumber(ovev); } return kTRUE; @@ -592,7 +747,7 @@ Bool_t AliITSHandleDaSSD::CalculateNoise(AliITSModuleDaSSD *const module) if (SignalOutOfRange(signal[ev])) ovev += 1; else nsum += pow((signal[ev] - strip->GetPedestal()), 2); } - if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(nsum / (Float_t)(n)); + if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = static_cast(sqrt(nsum / (Float_t)(n))); else noise = AliITSChannelDaSSD::GetUndefinedValue(); strip->SetNoise(noise); } @@ -617,9 +772,9 @@ Bool_t AliITSHandleDaSSD::CalculateNoiseCM(AliITSModuleDaSSD *const module) if (!(strip = module->GetStrip(strind))) continue; //return kFALSE; if (!(signal = strip->GetSignal())) { strip->SetNoiseCM(AliITSChannelDaSSD::GetUndefinedValue()); - AliError(Form("SSDDAModule: Error CalculateNoiseWithoutCM(): there are no events data for module[%i] strip[%i]->GetSignal()", + AliError(Form("AliITSHandleDaSSD: Error CalculateNoiseCM(): there are no events data for module[%i] strip[%i]->GetSignal()", module->GetModuleId(), strind)); - return kFALSE; + continue; //return kFALSE; } Int_t chipind = strind / AliITSModuleDaSSD::GetStripsPerChip(); Double_t nsum = 0.0L; @@ -628,11 +783,11 @@ Bool_t AliITSHandleDaSSD::CalculateNoiseCM(AliITSModuleDaSSD *const module) if (SignalOutOfRange(signal[ev])) ovev += 1; else nsum += pow((signal[ev] - strip->GetPedestal() - module->GetCM(chipind, ev)), 2); } - if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(nsum / (Float_t)(n)); + if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = static_cast(sqrt(nsum / (Double_t)(n))); else noise = AliITSChannelDaSSD::GetUndefinedValue(); strip->SetNoiseCM(noise); } -return kTRUE; + return kTRUE; } @@ -648,8 +803,8 @@ Bool_t AliITSHandleDaSSD::CalculateCM(AliITSModuleDaSSD *const module) module->SetNumberOfChips(AliITSModuleDaSSD::GetChipsPerModuleConst()); for (Int_t chipind = 0; chipind < module->GetNumberOfChips(); chipind++) { stripind = chipind * module->GetStripsPerChip(); - module->GetCm()[chipind].Set(fNumberOfEvents); - module->GetCm()[chipind].Reset(0.0f); + module->GetCM()[chipind].Set(fNumberOfEvents); + module->GetCM()[chipind].Reset(0.0f); for (Long_t ev = 0; ev < fNumberOfEvents; ev++) { // calculate firs approximation of CM. Double_t cm0 = 0.0L; @@ -661,8 +816,7 @@ Bool_t AliITSHandleDaSSD::CalculateCM(AliITSModuleDaSSD *const module) module->GetModuleId(), strind)); return kFALSE; } - if ((signal[ev] >= AliITSChannelDaSSD::GetOverflowConst()) || - (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())) ovstr += 1; + if ((SignalOutOfRange(signal[ev])) || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())) ovstr += 1; else cm0 += (signal[ev] - strip->GetPedestal()); } if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cm0 /= (Float_t)(n); @@ -677,8 +831,7 @@ Bool_t AliITSHandleDaSSD::CalculateCM(AliITSModuleDaSSD *const module) module->GetModuleId(), strind)); return kFALSE; } - if ((signal[ev] >= AliITSChannelDaSSD::GetOverflowConst()) || - (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())) ovstr += 1; + if ((SignalOutOfRange(signal[ev])) || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())) ovstr += 1; else cmsigma += pow((cm0 - (signal[ev] - strip->GetPedestal())), 2); } if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cmsigma = sqrt(cmsigma / (Float_t)(n)); @@ -689,14 +842,15 @@ Bool_t AliITSHandleDaSSD::CalculateCM(AliITSModuleDaSSD *const module) for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) { if (!(strip = module->GetStrip(strind))) continue; signal = strip->GetSignal(); - if ( (signal[ev] >= AliITSChannelDaSSD::GetOverflowConst()) - || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue()) - || (TMath::Abs(cm0 - (signal[ev] - strip->GetPedestal())) > (fCmThresholdFactor * cmsigma)) ) ovstr += 1; + if ( (SignalOutOfRange(signal[ev])) || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue()) + || (TMath::Abs(cm0 - (signal[ev] - strip->GetPedestal())) > (fCmThresholdFactor * cmsigma)) ) ovstr += 1; else cmsum += (signal[ev] - strip->GetPedestal()); } if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cmsum /= (Float_t)(n); else cmsum = 0.0L; - if (!module->SetCM(cmsum, chipind, ev)); + if (!(module->SetCM(cmsum, chipind, ev))) + AliError(Form("AliITSHandleDaSSD: Error, module->SetCM(...) returned kFALSE module:chip:event : [%d]:[%d]:[%ld]\n", + module->GetModuleId(), chipind, ev)); } } return kTRUE; @@ -704,7 +858,7 @@ Bool_t AliITSHandleDaSSD::CalculateCM(AliITSModuleDaSSD *const module) //______________________________________________________________________________ -Bool_t AliITSHandleDaSSD::ProcessRawData(const Int_t nmread) +Bool_t AliITSHandleDaSSD::ProcessRawData(const Int_t nmread, const Bool_t usewelford) { // Performs calculation of calibration parameters (pedestal, noise, ...) Int_t nm = 0; @@ -718,14 +872,22 @@ Bool_t AliITSHandleDaSSD::ProcessRawData(const Int_t nmread) modind)); return kFALSE; } - CalculatePedestal(fModules[modind]); - CalculateNoise(fModules[modind]); - CalculateNoiseCM(fModules[modind]); + AddFeromCm(fModules[modind]); + if (usewelford) { + CalculatePedNoiseW(fModules[modind]); + CalculateNoiseCMW(fModules[modind]); + } else { + CalculatePedestal(fModules[modind]); + CalculateNoise(fModules[modind]); + CalculateNoiseCM(fModules[modind]); + } } DeleteSignal(); -// DeleteCM(); + DeleteCM(); + DeleteCMFerom(); fModIndProcessed = fModIndRead; cout << fModIndProcessed << " - done" << endl; + if (nm < nmread ) break; } return kTRUE; } @@ -735,81 +897,192 @@ Bool_t AliITSHandleDaSSD::ProcessRawData(const Int_t nmread) Short_t AliITSHandleDaSSD::RetrieveModuleId(const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const { // Retrieve ModuleId from the DDL map which is defined in AliITSRawStreamSSD class - Int_t mddli = (ad - 1) * 12 + ((adc<6) ? adc : (adc-2)); - if ((ddlID < AliITSRawStreamSSD::kDDLsNumber) && (mddli < AliITSRawStreamSSD::kModulesPerDDL)) { - mddli = AliITSRawStreamSSD::GetModuleNumber(ddlID, mddli); - if (mddli > SHRT_MAX) return SHRT_MAX; - else return (Short_t)mddli; + if (!fDDLModuleMap) { + AliError("Error DDLMap is not initialized, return 0!"); + return 0; } + Int_t mddli = ((ad - 1) * fgkNumberOfSSDModulesPerSlot) + (adc < 6 ? adc : (adc - 2)); + if ((ddlID < fgkNumberOfSSDDDLs) && (mddli < fgkNumberOfSSDModulesPerDdl)) { + mddli = fDDLModuleMap[ddlID * fgkNumberOfSSDModulesPerDdl + mddli]; + } else { - AliWarning(Form("Module index = %d or ddlID = %d is out of range -1 is rturned", ddlID, mddli)); - return -1; + AliWarning(Form("Module index = %d or ddlID = %d is out of range 0 is rturned", ddlID, mddli)); + mddli = 0; } + if (mddli > SHRT_MAX) return SHRT_MAX; + else return (Short_t)mddli; } //______________________________________________________________________________ -TObjArray* AliITSHandleDaSSD::GetCalibrationSSDLDC() const +AliITSNoiseSSDv2* AliITSHandleDaSSD::GetCalibrationOCDBNoise() const { // Fill in the array for OCDB - TObjArray *ldcc; - TObject *modcalibobj; + AliITSNoiseSSDv2 *ldcn = NULL; + AliITSModuleDaSSD *module = NULL; + AliITSChannelDaSSD *strip = NULL; if (!fModules) return NULL; - ldcc = new TObjArray(fNumberOfModules, 0); + ldcn = new AliITSNoiseSSDv2; + if (!ldcn) { + AliError("Error allocation mamory for AliITSBadChannelsSSDv2 object, return NULL!"); + return NULL; + } for (Int_t i = 0; i < fNumberOfModules; i++) { - if (!fModules[i]) { - delete ldcc; - return NULL; + if (!(module = fModules[i])) continue; + if (module->GetModuleId() < fgkMinSSDModuleId) continue; + for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) { + if (!(strip = module->GetStrip(strind))) continue; + Short_t modid = module->GetModuleId() - fgkMinSSDModuleId; + if (strip->GetStripId() < AliITSModuleDaSSD::GetPNStripsPerModule() ) + ldcn->AddNoiseP(modid, strip->GetStripId(), strip->GetNoiseCM()); + else + ldcn->AddNoiseN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()), strip->GetNoiseCM()); } - modcalibobj = dynamic_cast(fModules[i]->GetCalibrationSSDModule()); - ldcc->AddAt(modcalibobj, i); } - ldcc->Compress(); - return ldcc; + return ldcn; } //______________________________________________________________________________ -Bool_t AliITSHandleDaSSD::SaveCalibrationSSDLDC(Char_t*& dafname) const +AliITSBadChannelsSSDv2* AliITSHandleDaSSD::GetCalibrationBadChannels() const +{ +// Fill in the TObjArray with the list of bad channels + AliITSBadChannelsSSDv2 *ldcbc = NULL; + AliITSModuleDaSSD *module = NULL; + AliITSChannelDaSSD *strip = NULL; + if (!fModules) return NULL; + ldcbc = new AliITSBadChannelsSSDv2; + if (!ldcbc) { + AliError("Error allocation mamory for AliITSBadChannelsSSDv2 object, return NULL!"); + return NULL; + } + for (Int_t i = 0; i < fNumberOfModules; i++) { + if (!(module = fModules[i])) continue; + if (module->GetModuleId() < fgkMinSSDModuleId) continue; + for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) { + if (!(strip = module->GetStrip(strind))) continue; + Short_t modid = module->GetModuleId() - fgkMinSSDModuleId; + if (strip->GetStripId() < AliITSModuleDaSSD::GetPNStripsPerModule() ) + ldcbc->AddBadChannelP(modid, strip->GetStripId(), EvaluateIfChannelIsBad(module, strip->GetStripId())); + else + ldcbc->AddBadChannelN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()), + EvaluateIfChannelIsBad(module, strip->GetStripId())); + } + } + return ldcbc; +} + + + +//______________________________________________________________________________ +Bool_t AliITSHandleDaSSD::SaveCalibrationSSDLDC(Char_t*& dafname) { // Save Calibration data locally - TObjArray *ldcc; - TObject *modcalibobj; + AliITSBadChannelsSSDv2 *ldcbc = NULL; + AliITSPedestalSSDv2 *ldcp = NULL; + AliITSNoiseSSDv2 *ldcn = NULL; + AliITSModuleDaSSD *module = NULL; + AliITSChannelDaSSD *strip = NULL; Char_t *tmpfname; TString dadatafilename(""); if (!fModules) return kFALSE; - ldcc = new TObjArray(fNumberOfModules, 0); + ldcn = new AliITSNoiseSSDv2; + ldcp = new AliITSPedestalSSDv2; + ldcbc = new AliITSBadChannelsSSDv2; + if ((!ldcn) || (!ldcp) || (!ldcp)) { + AliError("Error allocation mamory for calibration objects, return kFALSE!"); + return kFALSE; + } for (Int_t i = 0; i < fNumberOfModules; i++) { - if (!fModules[i]) { - delete ldcc; - return kFALSE; + if (!(module = fModules[i])) continue; + if (module->GetModuleId() < fgkMinSSDModuleId) continue; + for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) { + if (!(strip = module->GetStrip(strind))) continue; + Short_t modid = module->GetModuleId() - fgkMinSSDModuleId; + if (strip->GetStripId() < AliITSModuleDaSSD::GetPNStripsPerModule() ) { + ldcn->AddNoiseP(modid, strip->GetStripId(), strip->GetNoiseCM()); + ldcp->AddPedestalP(modid, strip->GetStripId(), strip->GetPedestal()); + ldcbc->AddBadChannelP(modid, strip->GetStripId(), EvaluateIfChannelIsBad(module, strip->GetStripId())); + } else { + ldcn->AddNoiseN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()), strip->GetNoiseCM()); + ldcp->AddPedestalN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()), strip->GetPedestal()); + ldcbc->AddBadChannelN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()), + EvaluateIfChannelIsBad(module, strip->GetStripId())); + } } - modcalibobj = dynamic_cast(fModules[i]->GetCalibrationSSDModule()); - ldcc->AddAt(modcalibobj, i); } - ldcc->Compress(); if (dafname) dadatafilename.Form("%s/", dafname); - dadatafilename += TString::Format("ITSSSDda_%i_%i.root", fLdcId, fRunId); + dadatafilename += TString::Format("ITSSSDda_%i.root", fLdcId); tmpfname = new Char_t[dadatafilename.Length()+1]; - dafname = strcpy(tmpfname, dadatafilename.Data()); + Int_t sz = dadatafilename.Sizeof(); + dafname = strncpy(tmpfname, dadatafilename.Data(),sz); TFile *fileRun = new TFile (dadatafilename.Data(),"RECREATE"); if (fileRun->IsZombie()) { AliError(Form("AliITSHandleDaSSD: SaveCalibrationSSDLDC() error open file %s", dadatafilename.Data())); - ldcc->Delete(); + ldcn->Delete(); delete fileRun; - delete ldcc; + delete ldcn; + delete ldcp; + delete ldcbc; return kFALSE; } - fileRun->WriteTObject(ldcc); + fileRun->WriteTObject(ldcn); + fileRun->WriteTObject(ldcp); + if (fBadChannelsList) + if (fMergeBCLists) { + MergeBadChannels(ldcbc); + fileRun->WriteTObject(ldcbc); + } else fileRun->WriteTObject(fBadChannelsList); + else fileRun->WriteTObject(ldcbc); fileRun->Close(); - ldcc->Delete(); delete fileRun; - delete ldcc; + delete ldcn; + delete ldcp; + delete ldcbc; return kTRUE; } +//______________________________________________________________________________ +Int_t AliITSHandleDaSSD::MergeBadChannels(AliITSBadChannelsSSDv2*& bcl) const +{ +// Merges the statick bad channels list with bad channels got upon calibration + AliITSModuleDaSSD *module = 0; + Int_t nmpch = 0, nmnch = 0, ngpch = 0, ngnch = 0; + if (!fBadChannelsList || !bcl) { + AliWarning("Either fBadChannelsList == NULL or bad_channels_list == NULL, there is nothing to merge!"); + return -1; + } + for (Int_t modind = 0; modind < GetNumberOfModules(); modind++) { + if (!(module = fModules[modind])) continue; + if (module->GetModuleId() < fgkMinSSDModuleId) continue; + Short_t modid = module->GetModuleId() - fgkMinSSDModuleId; + for (Int_t strind = 0; strind < AliITSModuleDaSSD::GetPNStripsPerModule(); strind++) { + if ( (!(fBadChannelsList->GetBadChannelP(modid, strind) & fgkBadChannelMask)) + && (bcl->GetBadChannelP(modid, strind) & fgkBadChannelMask) ) + ngpch++; + if ( (!(fBadChannelsList->GetBadChannelN(modid, strind) & fgkBadChannelMask)) + && (bcl->GetBadChannelN(modid, strind) & fgkBadChannelMask) ) + ngnch++; + if ( (!(bcl->GetBadChannelP(modid, strind) & fgkBadChannelMask)) + && (fBadChannelsList->GetBadChannelP(modid, strind) & fgkBadChannelMask) ) { + bcl->AddBadChannelP(modid, strind, fBadChannelsList->GetBadChannelP(modid, strind)); + nmpch++; + } + if ( (!(bcl->GetBadChannelN(modid, strind) & fgkBadChannelMask)) + && (fBadChannelsList->GetBadChannelN(modid, strind) & fgkBadChannelMask) ) { + bcl->AddBadChannelN(modid, strind, fBadChannelsList->GetBadChannelN(modid, strind)); + nmnch++; + } + } + } + AliInfo(Form("Static bad, dynamic good: P%d, N%d", nmpch, nmnch)); + AliInfo(Form("Static good, dynamic bad: P%d, N%d", ngpch, ngnch)); + return (nmnch + nmpch); +} + + //______________________________________________________________________________ Bool_t AliITSHandleDaSSD::DumpModInfo(const Float_t meannosethreshold) const @@ -824,8 +1097,9 @@ Bool_t AliITSHandleDaSSD::DumpModInfo(const Float_t meannosethreshold) const cout << "Modules with MeanNoise > " << meannosethreshold << endl; for (Int_t i = 0; i < fNumberOfModules; i++) { if (!(mod = fModules[i])) continue; - Float_t maxnoise = 0.0f, meannoise = 0.0f; - Int_t maxstrind = 0, novfstr = 0; + Double_t maxnoise = 0.0L, meannoise = 0.0L, meanovf = 0.0L; + Float_t maxped = 0.0f; + Int_t maxstrind = 0, novfstr = 0, maxovf = 0; for (Int_t strind = 0; strind < mod->GetNumberOfStrips(); strind++) { if (!(strip = mod->GetStrip(strind))) {novfstr++; continue; } if (strip->GetNoiseCM() >= AliITSChannelDaSSD::GetUndefinedValue() ) {novfstr++; continue; } @@ -833,13 +1107,19 @@ Bool_t AliITSHandleDaSSD::DumpModInfo(const Float_t meannosethreshold) const maxnoise = strip->GetNoiseCM(); maxstrind = strind; } - meannoise = (strind - novfstr) ? meannoise + (strip->GetNoiseCM() - meannoise) / static_cast(strind - novfstr + 1) + meannoise = (strind - novfstr) ? meannoise + (strip->GetNoiseCM() - meannoise) / static_cast(strind - novfstr + 1) : strip->GetNoiseCM(); + if (TMath::Abs(maxped) < TMath::Abs(strip->GetPedestal())) maxped = strip->GetPedestal(); + meanovf = (strind - novfstr) ? meanovf + (strip->GetOverflowNumber() - meanovf) / static_cast(strind - novfstr + 1) + : strip->GetOverflowNumber(); + if (strip->GetOverflowNumber() > maxovf) maxovf = strip->GetOverflowNumber(); } if (meannoise > meannosethreshold) cout << "Mod: " << i << "; DDl: " << (int)mod->GetDdlId() << "; AD: " << (int)mod->GetAD() - << "; ADC: " << (int)mod->GetADC() << "; MeanNoise = " << meannoise + << "; ADC: " << (int)mod->GetADC() << "; MaxPed = " << maxped + << "; MeanNoise = " << meannoise << "; NOfStrips = " << (mod->GetNumberOfStrips() - novfstr) << endl; + if (maxovf > 10) cout << "Max number of events with overflow : " << maxovf << "; mean : " << meanovf << endl; } return kTRUE; } @@ -849,7 +1129,7 @@ Bool_t AliITSHandleDaSSD::DumpModInfo(const Float_t meannosethreshold) const //______________________________________________________________________________ Bool_t AliITSHandleDaSSD::PrintModCalibrationData(const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const Char_t *fname) const { -// Print Module calibration data whether in file on in cout +// Print Module calibration data whether in file or in cout AliITSChannelDaSSD *strip; ofstream datafile; ostream *outputfile; @@ -861,7 +1141,7 @@ Bool_t AliITSHandleDaSSD::PrintModCalibrationData(const UChar_t ddlID, const UCh } *outputfile << "DDL = " << (int)ddlID << "; AD = " << (int)ad << "; ADC = " << (int)adc << endl; for (Int_t strind = 0; strind < AliITSModuleDaSSD::GetStripsPerModuleConst(); strind++) { - if (strip = GetStrip(ddlID, ad, adc, strind)) { + if ( (strip = GetStrip(ddlID, ad, adc, strind)) ) { *outputfile << "Str = " << strind << "; ped = " << strip->GetPedestal() << "; noise = " << strip->GetNoiseCM() << endl; } @@ -873,9 +1153,10 @@ Bool_t AliITSHandleDaSSD::PrintModCalibrationData(const UChar_t ddlID, const UCh +//______________________________________________________________________________ void AliITSHandleDaSSD::DumpInitData(const Char_t *str) const { -// Print general information retrieve from raw data file +// Print general information retrieved from raw data file cout << "Raw data file: " << fRawDataFileName << endl << "LDC: " << (Int_t)fLdcId << "; RunId: " << fRunId << endl << "Number of physics events: " << fNumberOfEvents << endl @@ -908,10 +1189,11 @@ Bool_t AliITSHandleDaSSD::AllocateSimulatedModules(const Int_t copymodind) fModules[modind] = module; for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) { AliITSChannelDaSSD *cstrip = fModules[copymodind]->GetStrip(strind); + if(!cstrip)return kFALSE; Long_t eventsnumber = cstrip->GetEventsNumber(); AliITSChannelDaSSD *strip = new AliITSChannelDaSSD(strind, eventsnumber); for (Long_t evind = 0; evind < eventsnumber; evind++) { - Short_t sign = *cstrip->GetSignal(evind); + Short_t sign = cstrip->GetSignal(evind); if (!strip->SetSignal(evind, sign)) AliError(Form("AliITSHandleDaSSD: Copy events error! mod = %i, str = %i", modind, strind)); } module->SetStrip(strip, strind); @@ -926,3 +1208,496 @@ Bool_t AliITSHandleDaSSD::AllocateSimulatedModules(const Int_t copymodind) for (UShort_t modind = 0; modind < fNumberOfModules; modind++) fModules[modind]->SetModuleId(modind + 1080); return kTRUE; } + + + +//___________________________________________________________________________________________ +Bool_t AliITSHandleDaSSD::AdDataPresent(const Int_t ddl, const Int_t ad) const +{ +// Check if there are calibration data for given ddl and slot + for (Int_t modind = 0; modind < fNumberOfModules; modind++) + if ((GetModule(modind)->GetAD() == ad) && (GetModule(modind)->GetDdlId() == ddl)) return kTRUE; + return kFALSE; +} + + + +//___________________________________________________________________________________________ +Bool_t AliITSHandleDaSSD::SaveEqSlotCalibrationData(const Int_t ddl, const Int_t ad, const Char_t *fname) const +// Saves calibration files for selected equipment (DDL) +{ + fstream feefile; + Int_t zsml, offsetml; + ULong_t zsth, offset, zsoffset; + if (!fname) { + AliError("File name must be specified!"); + return kFALSE; + } + if (!AdDataPresent(ddl, ad)) { + AliError(Form("Error SaveEqSlotCalibrationData(ddl = %i, ad = %i) no data present", ddl, ad)); + return kFALSE; + } + feefile.open(fname, ios::out); + if (!feefile.is_open()) { + AliError(Form("Can not open the file %s for output!", fname)); + return kFALSE; + } + for (zsml = 0; fgkZsBitMask >> zsml; zsml++) ; + for (offsetml = 0; fgkOffSetBitMask >> offsetml; offsetml++) ; + for (Int_t strind = 0; strind < AliITSModuleDaSSD::GetStripsPerModuleConst(); strind++) { + for (Int_t adcb = 0; adcb < fgkAdcPerDBlock; adcb++) { + zsoffset = 0x0; + for (Int_t j = 0; j < 2; j++) { + Int_t adc = adcb + j * 8; + zsth = ZsThreshold(ddl, ad, adc, strind); + offset = OffsetValue(ddl, ad, adc, strind); + zsoffset = zsoffset | (((zsth << offsetml) | offset) << ((j == 0) ? (offsetml + zsml) : 0)); + } + feefile << "0x" << ConvBase(static_cast(zsoffset), 16) << endl; + } + } + feefile.close(); + return kTRUE; +} + + +//______________________________________________________________________________ +Int_t AliITSHandleDaSSD::ChannelIsBad(const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const +{ +// Check if the channel is bad + AliITSModuleDaSSD *module = NULL; + Int_t modn = -1; + if (fBadChannelsList && fDDLModuleMap) { + modn = RetrieveModuleId(ddl, ad, adc); + if (modn < 0) return -1; + if (modn < fgkMinSSDModuleId) { + AliWarning(Form("Module ddl/ad/adc: %d/%d/%d has number %d which is wrong for SSD module %d", ddl, ad, adc, strn, modn)); + return -1; + } + Short_t modid = modn - fgkMinSSDModuleId; + if (strn < AliITSModuleDaSSD::GetPNStripsPerModule()) + return (fBadChannelsList->GetBadChannelP(modid, strn) & fgkBadChannelMask); + else return (fBadChannelsList->GetBadChannelN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strn)) & fgkBadChannelMask); + } else { + AliError("Error ether bad channels list or DDLMap is not initialized or both, EvaluateIfChannelIsBad(module, strip) is used!"); + if ((module = GetModule(ddl, ad, adc))) { + return (EvaluateIfChannelIsBad(module, strn) & fgkBadChannelMask); + } else { + AliWarning(Form("There is no calibration data for ddl = %i, ad = %i, adc = %i, 0 is used!", ddl, ad, adc)); + return 0ul; + } + return 0; + } +} + + + +//______________________________________________________________________________ +Int_t AliITSHandleDaSSD::LadderIsOff(const UChar_t ddl, const UChar_t ad, const UChar_t adc) const +{ +//Checks if the module with given ddl, ad, adc is on the ladder which is in the list of ladders which are off + const Int_t nm5 = 500; + const Int_t nm6 = 1248; + const Int_t nml5a = 12; + const Int_t nml5c = 10; + const Int_t nml6a = 12; + const Int_t nml6c = 13; + Int_t modn, ladder, layer, side; + AliITSModuleDaSSD *module; + if (!(module = GetModule(ddl, ad, adc))) return 0; + if ((modn = module->GetModuleId()) <= 0) modn = RetrieveModuleId(ddl, ad, adc); + if (modn <= 0) return 0; + layer = modn >= nm6 ? 1 : 0; // 6 : 5 + ladder = (modn - (layer ? nm6 : nm5)) / (layer ? (nml6a + nml6c) : (nml5a + nml5c)); + if ( ((modn - (layer ? nm6 : nm5)) % (layer ? (nml6a + nml6c) : (nml5a + nml5c))) < (layer ? nml6a : nml5a)) + side = 0; // A + else side = 1; // C + ladder += (layer ? 600 : 500); + layer += 5; + if (side) + if (fCLaddersOff.GetSize()) { + for(Int_t i = 0; i < fCLaddersOff.GetSize(); i++) + if (fCLaddersOff.At(i) == ladder) return fCLaddersOff.At(i); + return 0; + } else return 0; + else + if (fALaddersOff.GetSize()) { + for(Int_t i = 0; i < fALaddersOff.GetSize(); i++) + if (fALaddersOff.At(i) == ladder) return fALaddersOff.At(i); + return 0; + } else return 0; + return 0; +} + + + +//______________________________________________________________________________ +ULong_t AliITSHandleDaSSD::OffsetValue(const AliITSChannelDaSSD *strip, + const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const +{ +// Calculate the offset value to be upload to FEROM + Int_t pedint; + if (fOffsetDefault < INT_MAX) pedint = fOffsetDefault; + else pedint = TMath::Nint(strip->GetPedestal()); + if (pedint > static_cast((fgkOffSetBitMask >> 1))) { + if (!ChannelIsBad(ddl, ad, adc, strn) && !((fMergeBCLists) && (EvaluateIfChannelIsBad(GetModule(ddl, ad, adc), strn)))) + AliError(Form("Offset %i, channel(ddl/ad/adc/strip) %i/%i/%i/%i can not be represented with mask 0x%s, Offset = %i", + pedint, ddl, ad, adc, strn, ConvBase(fgkOffSetBitMask, 16).c_str(), (fgkOffSetBitMask >> 1))); + return (fgkOffSetBitMask >> 1); + } + if ((-pedint) > static_cast(((fgkOffSetBitMask + 1) >> 1))) { + if (!ChannelIsBad(ddl, ad, adc, strn) && !((fMergeBCLists) && (EvaluateIfChannelIsBad(GetModule(ddl, ad, adc), strn)))) + AliError(Form("Offset %i, channel(ddl/ad/adc/strip) %i/%i/%i/%i can not be represented with mask 0x%s, Offset = %i", + pedint, ddl, ad, adc, strn, ConvBase(fgkOffSetBitMask, 16).c_str(), + ((fgkOffSetBitMask & (~fgkOffSetBitMask >> 1)) - fgkOffSetBitMask - 1))); + return fgkOffSetBitMask & (~fgkOffSetBitMask >> 1); + } + return fgkOffSetBitMask & (pedint >= 0 ? pedint : pedint + fgkOffSetBitMask + 1); +} + + + +//______________________________________________________________________________ +ULong_t AliITSHandleDaSSD::OffsetValue(const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const +{ +// Calculate the offset value to be upload to FEROM + AliITSChannelDaSSD *strip = NULL; + AliITSModuleDaSSD *module = NULL; + if ((module = GetModule(ddl, ad, adc))) { + if ((strip = module->GetStrip(strn))) return OffsetValue(strip, ddl, ad, adc, strn); + else { + AliWarning(Form("There is no calibration data for ddl = %i, ad = %i, adc = %i, strip = %i, 0 is used!", ddl, ad, adc, strn)); + return 0ul; + } + } else { + AliWarning(Form("There is no calibration data for ddl = %i, ad = %i, adc = %i, 0 is used!", ddl, ad, adc)); + return 0ul; + } +} + + + +//______________________________________________________________________________ +ULong_t AliITSHandleDaSSD::ZsThreshold(AliITSChannelDaSSD *strip) const +{ +// Calculate the value of zero suppression threshold to be upload to FEROM + ULong_t zs; + if (fZsDefault < 0) { + zs = TMath::Nint(fZsFactor * strip->GetNoiseCM()); + if (zs < static_cast(fZsMinimum)) zs = static_cast(fZsMinimum); + } + else zs = fZsDefault; + return (zs < fgkZsBitMask) ? (zs & fgkZsBitMask) : fgkZsBitMask; +} + + +//______________________________________________________________________________ +ULong_t AliITSHandleDaSSD::ZsThreshold(const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const +{ +// Calculate the value of zero suppression threshold to be upload to FEROM, account bad channels list + AliITSChannelDaSSD *strip = NULL; + AliITSModuleDaSSD *module = NULL; + if (ChannelIsBad(ddl, ad, adc, strn)) return fgkZsBitMask; + if (LadderIsOff(ddl, ad, adc)) return fgkZsBitMask; + if (fZsDefault > 0) if (static_cast(fZsDefault) >= fgkZsBitMask) return fgkZsBitMask; + if ((module = GetModule(ddl, ad, adc))) { + if (fMergeBCLists) if (EvaluateIfChannelIsBad(module, strn)) return fgkZsBitMask; + if ((strip = module->GetStrip(strn))) return ZsThreshold(strip); + else { + AliWarning(Form("There is no calibration data for ddl = %i, ad = %i, adc = %i, strip = %i, 0 is used!", ddl, ad, adc, strn)); + return 0ul; + } + } else { + AliWarning(Form("There is no calibration data for ddl = %i, ad = %i, adc = %i, 0 is used!", ddl, ad, adc)); + return 0ul; + } +} + + +//______________________________________________________________________________ +string AliITSHandleDaSSD::ConvBase(const unsigned long value, const long base) const +{ +// Converts the unsigned long number into that in another base + string digits = "0123456789ABCDEF"; + string result; + unsigned long v = value; + if((base < 2) || (base > 16)) { + result = "Error: base out of range."; + } + else { + int i = 0; + do { + result = digits[v % base] + result; + v /= base; + i++; + } + while((v) || (i<8)); + } + return result; +} + + + +//______________________________________________________________________________ +Int_t AliITSHandleDaSSD::CheckOffChips() const +{ +// Check if the chip, module are off + AliITSChannelDaSSD *strip; + Int_t offthreshold; + Int_t strnd, chipnd, modnd, stroff, chipoff, modoff; + offthreshold = TMath::Nint(fZsMinimum/fZsFactor); + modnd = modoff = 0; + for (Int_t mi = 0; mi < fNumberOfModules; mi++) { + if (!fModules[mi]) { modnd++; continue; } + if (fModules[mi]->GetModuleId() < 0) continue; + if (LadderIsOff(fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC()) ) continue; + chipoff = chipnd = 0; + for (Int_t chipind = 0; chipind < AliITSModuleDaSSD::GetChipsPerModuleConst(); chipind++) { + strnd = stroff = 0; + Int_t stripind = chipind * AliITSModuleDaSSD::GetStripsPerChip(); + for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) { + if (!(strip = fModules[mi]->GetStrip(strind))) { strnd++; continue; } + if (strip->GetNoiseCM() < offthreshold ) stroff++; + } + if (strnd == AliITSModuleDaSSD::GetStripsPerChip()) chipnd++; + else if (stroff == AliITSModuleDaSSD::GetStripsPerChip()) chipoff++; + else if ((stroff + strnd) == AliITSModuleDaSSD::GetStripsPerChip()) chipoff++; + } + if ((!chipoff) && (!chipnd)) continue; + if (chipnd == AliITSModuleDaSSD::GetChipsPerModuleConst()) { + AliInfo(Form("Module: (ddl/ad/adc) %i/%i/%i seems to be off and it is not on the ladders which are off!", + fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC())); + modnd++; + } + if (chipoff == AliITSModuleDaSSD::GetChipsPerModuleConst()) { + AliInfo(Form("Module (ddl/ad/adc): %i/%i/%i seems to be off and it is not on the ladders which are off!", + fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC())); + modoff++; + } + else if ((chipoff + chipnd) == AliITSModuleDaSSD::GetChipsPerModuleConst()) { + AliInfo(Form("Module: (ddl/ad/adc): %i/%i/%i seems to be off and it is not on the ladders which are off!", + fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC())); + modoff++; + } + else if (chipoff) { + AliInfo(Form("Module: (ddl/ad/adc): %i/%i/%i has %i chips which are off!", + fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC(), chipoff)); + modoff++; + } + } + return (modoff + modnd); +} + + +//______________________________________________________________________________ +Bool_t AliITSHandleDaSSD::CalculatePedNoiseW(AliITSModuleDaSSD *const module) +{ +// Calculates Pedestal and Noise using Welford algorithm + AliITSChannelDaSSD *strip; + Double_t pedestal, noise, p0, s0; + Short_t *signal; + Int_t ovev, n; + if (!module) return kFALSE; + for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) { + if (!(strip = module->GetStrip(strind))) continue; + if (!(signal = strip->GetSignal())) { + AliError(Form("AliITSHandleDaSSD: Error CalculatePedestal(): there are no events data for module[%i] strip[%i]->GetSignal()", + module->GetModuleId(), strind)); + continue; + } +//************* pedestal and noise first pass **************** + pedestal = p0 = noise = 0.0L; + ovev = 0; + for (Int_t ev = 0; ev < strip->GetEventsNumber(); ev++) { + if (SignalOutOfRange(signal[ev])) ovev += 1; + else + if (!(ev - ovev)) { + pedestal = p0 = signal[ev]; + noise = 0.0L; + } else { + p0 = pedestal + (signal[ev] - pedestal) / static_cast(ev - ovev + 1); + s0 = noise + (signal[ev] - pedestal) * (signal[ev] - p0); + pedestal = p0; + noise = s0; + } + } + if (strip->GetEventsNumber() == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue(); + strip->SetPedestal(static_cast(pedestal)); + if ((n = strip->GetEventsNumber() - ovev - 1) > 0) + strip->SetNoise( static_cast(sqrt(noise / static_cast(n))) ); + else { + strip->SetNoise(AliITSChannelDaSSD::GetUndefinedValue()); + continue; + } +//************* Second pass excluds event with |p - s|>f*noise ***************** + pedestal = p0 = noise = 0.0L; + ovev = 0; + for (Int_t ev = 0; ev < strip->GetEventsNumber(); ev++) { + if ( SignalOutOfRange(signal[ev]) + || TMath::Abs(signal[ev] - strip->GetPedestal()) > (fPedestalThresholdFactor * strip->GetNoise())) ovev += 1; + else + if (!(ev - ovev)) { + pedestal = p0 = signal[ev]; + noise = 0.0L; + } else { + p0 = pedestal + (signal[ev] - pedestal) / static_cast(ev - ovev + 1); + s0 = noise + (signal[ev] - pedestal) * (signal[ev] - p0); + pedestal = p0; + noise = s0; + } + } + if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(noise / static_cast(n)); + else noise = AliITSChannelDaSSD::GetUndefinedValue(); + strip->SetNoise(static_cast(noise)); + if (strip->GetEventsNumber() == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue(); + strip->SetPedestal(static_cast(pedestal)); + strip->SetOverflowNumber(ovev); + } + return kTRUE; +} + + +//______________________________________________________________________________ +Bool_t AliITSHandleDaSSD::CalculateCMW(AliITSModuleDaSSD *const module) +{ +// Calculates CM using Welford algorithm + AliITSChannelDaSSD *strip = NULL; + Short_t *signal; + Int_t ovstr, n; + Int_t stripind; + Double_t cm0, cm1, cmsigma, cms1; + module->SetNumberOfChips(AliITSModuleDaSSD::GetChipsPerModuleConst()); + for (Int_t chipind = 0; chipind < module->GetNumberOfChips(); chipind++) { + stripind = chipind * module->GetStripsPerChip(); + module->GetCM()[chipind].Set(fNumberOfEvents); + module->GetCM()[chipind].Reset(0.0f); + for (Long_t ev = 0; ev < fNumberOfEvents; ev++) { + // calculate firs approximation of CM and SigmaCM. + cm0 = cm1 = cmsigma = 0.0L; + ovstr = 0; + for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) { + if (!(strip = module->GetStrip(strind))) { ovstr += 1; continue; } //return kFALSE; + if (!(signal = strip->GetSignal())) { ovstr += 1; continue; } //return kFALSE; + if ((SignalOutOfRange(signal[ev])) || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())) ovstr += 1; + else { + if (!(strind - stripind - ovstr)) { + cm0 = cm1 = signal[ev] - strip->GetPedestal(); + cmsigma = 0.0L; + } else { + cm1 = cm0 + (signal[ev] - strip->GetPedestal() - cm0) / static_cast(strind - stripind - ovstr + 1); + cms1 = cmsigma + (signal[ev] - strip->GetPedestal() - cm0) * (signal[ev] - strip->GetPedestal() - cm1); + cm0 = cm1; + cmsigma = cms1; + } } + } + if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr - 1) > 0) cmsigma = sqrt(cmsigma / static_cast(n)); + else { + AliWarning(Form("AliITSHandleDaSSD: Too little number of strips have a signal for module:chip:event : [%d]:[%d]:[%ld]\n", + module->GetModuleId(), chipind, ev)); + if (!(module->SetCM(0.0f, chipind, ev))) + AliError(Form("AliITSHandleDaSSD: Error, module->SetCM(...) returned kFALSE module:chip:event : [%d]:[%d]:[%ld]\n", + module->GetModuleId(), chipind, ev)); + continue; + } + // calculate cm with threshold + Double_t cmsum = 0.0L; + ovstr = 0; + for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) { + if (!(strip = module->GetStrip(strind))) { ovstr += 1; continue; } + if (!(signal = strip->GetSignal())) { ovstr += 1; continue; } + if ( (SignalOutOfRange(signal[ev])) || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue()) + || (TMath::Abs(cm0 - (signal[ev] - strip->GetPedestal())) > (fCmThresholdFactor * cmsigma)) ) ovstr += 1; + else cmsum += (signal[ev] - strip->GetPedestal()); + } + if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cmsum /= (Double_t)(n); + else cmsum = 0.0L; + if (!(module->SetCM(static_cast(cmsum), chipind, ev))) + AliError(Form("AliITSHandleDaSSD: Error, module->SetCM(...) returned kFALSE module:chip:event : [%d]:[%d]:[%ld]\n", + module->GetModuleId(), chipind, ev)); + } + } + return kTRUE; +} + + +//______________________________________________________________________________ +Bool_t AliITSHandleDaSSD::CalculateNoiseCMW(AliITSModuleDaSSD *const module) +{ +// Calculates Noise with CM correction + AliITSChannelDaSSD *strip = NULL; + Short_t *signal; + Int_t ovev, n; + if (!CalculateCMW(module)) { + AliError("Error: AliITSHandleDaSSD::CalculateCMW() returned kFALSE"); + return kFALSE; + } + for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) { + if (!(strip = module->GetStrip(strind))) continue; //return kFALSE; + if (!(signal = strip->GetSignal())) { + strip->SetNoiseCM(AliITSChannelDaSSD::GetUndefinedValue()); + AliError(Form("AliITSHandleDaSSD: Error CalculateNoiseCMW(): there are no events data for module[%i] strip[%i]->GetSignal()", + module->GetModuleId(), strind)); + continue; //return kFALSE; + } +//** To get exactly the same set of events as for pedestal and noise calculation ** + Double_t pedestal, noise, p0, s0; + pedestal = p0 = noise = 0.0L; + ovev = 0; + for (Int_t ev = 0; ev < strip->GetEventsNumber(); ev++) { + if (SignalOutOfRange(signal[ev])) ovev += 1; + else + if (!(ev - ovev)) { + pedestal = p0 = signal[ev]; + noise = 0.0L; + } else { + p0 = pedestal + (signal[ev] - pedestal) / static_cast(ev - ovev + 1); + s0 = noise + (signal[ev] - pedestal) * (signal[ev] - p0); + pedestal = p0; + noise = s0; + } + } + if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(noise / static_cast(n)); + else { + strip->SetNoiseCM(AliITSChannelDaSSD::GetUndefinedValue()); + continue; + } +//** Calculation of CM corrected noise ** + Int_t chipind = strind / AliITSModuleDaSSD::GetStripsPerChip(); + Double_t nsum = 0.0L; + ovev = 0; + for (Int_t ev = 0; ev < strip->GetEventsNumber(); ev++) { + if ( SignalOutOfRange(signal[ev]) + || TMath::Abs(signal[ev] - pedestal) > (fPedestalThresholdFactor * noise)) ovev += 1; + else nsum += pow((signal[ev] - strip->GetPedestal() - module->GetCM(chipind, ev)), 2); + } + if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(nsum / static_cast(n)); + else noise = AliITSChannelDaSSD::GetUndefinedValue(); + strip->SetNoiseCM(static_cast(noise)); + } + return kTRUE; +} + + + +//______________________________________________________________________________ +UChar_t AliITSHandleDaSSD::EvaluateIfChannelIsBad(const AliITSModuleDaSSD *const module, const Int_t stripn) const +{ +//Applies the bad channel creteria and set the appropriate flags for returned value + AliITSChannelDaSSD *strip = 0; + UInt_t bcflags = 0; + if (fZsDefault >= 0) { if (static_cast(fZsDefault) >= fgkZsBitMask) bcflags |= 3; } + else if (static_cast(fZsMinimum) >= fgkZsBitMask) bcflags |= 3; + if (LadderIsOff(module->GetDdlId(), module->GetAD(), module->GetADC()) ) bcflags |= 3; + + if (!(strip = module->GetStrip(stripn))) bcflags |= 3; + else { + if (strip->GetNoiseCM() == AliITSChannelDaSSD::GetUndefinedValue()) bcflags |= 8; + if (static_cast(TMath::Nint(fZsFactor * strip->GetNoiseCM())) >= fgkZsBitMask) bcflags |= 8; + if (strip->GetNoiseCM() < 1) bcflags |= 16; + if (strip->GetPedestal() > ((fgkOffSetBitMask >> 1) - 1)) bcflags |= 4; + else if ((-(strip->GetPedestal())) > (fgkOffSetBitMask >> 1)) bcflags |= 4; + if (bcflags) bcflags |= 3; + } + return bcflags; +} +