1 /**************************************************************************
2 * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
18 ///////////////////////////////////////////////////////////////////////////////
20 /// This class provides ITS SSD data handling
22 // Author: Oleksandr Borysov
24 ///////////////////////////////////////////////////////////////////////////////
29 #include <Riostream.h>
30 #include "AliITSHandleDaSSD.h"
37 #include "AliITSNoiseSSDv2.h"
38 #include "AliITSPedestalSSDv2.h"
39 #include "AliITSBadChannelsSSDv2.h"
40 #include "AliITSRawStreamSSD.h"
41 #include "AliRawReaderDate.h"
42 #include "AliITSRawStreamSSD.h"
43 #include "AliITSChannelDaSSD.h"
46 ClassImp(AliITSHandleDaSSD)
51 const Int_t AliITSHandleDaSSD::fgkNumberOfSSDModules = 1698; // Number of SSD modules in ITS
52 const Int_t AliITSHandleDaSSD::fgkNumberOfSSDModulesPerDdl = 108; // Number of SSD modules in DDL
53 const Int_t AliITSHandleDaSSD::fgkNumberOfSSDModulesPerSlot = 12; // Number of SSD modules in Slot
54 const Short_t AliITSHandleDaSSD::fgkMinSSDModuleId = 500; // Initial SSD modules number
55 const Int_t AliITSHandleDaSSD::fgkNumberOfSSDSlotsPerDDL = 9; // Number of SSD slots per DDL
56 const Int_t AliITSHandleDaSSD::fgkNumberOfSSDDDLs = 16; // Number of SSD modules in Slot
57 const Float_t AliITSHandleDaSSD::fgkPedestalThresholdFactor = 3.0; // Defalt value for fPedestalThresholdFactor
58 const Float_t AliITSHandleDaSSD::fgkCmThresholdFactor = 3.0; // Defalt value for fCmThresholdFactor
60 const UInt_t AliITSHandleDaSSD::fgkZsBitMask = 0x0000003F; // Bit mask for FEROM ZS
61 const UInt_t AliITSHandleDaSSD::fgkOffSetBitMask = 0x000003FF; // Bit mask for FEROM Offset correction
62 const UInt_t AliITSHandleDaSSD::fgkBadChannelMask = 0x00000001; // Mask to suppress the channel from the bad channel list
63 const Int_t AliITSHandleDaSSD::fgkAdcPerDBlock = 6; // FEROM configuration file constant
65 //______________________________________________________________________________
66 AliITSHandleDaSSD::AliITSHandleDaSSD() :
67 fRawDataFileName(NULL),
75 fBadChannelsList(NULL),
81 fPedestalThresholdFactor(fgkPedestalThresholdFactor),
82 fCmThresholdFactor(fgkCmThresholdFactor),
84 fOffsetDefault(INT_MAX),
89 // Default constructor
93 //______________________________________________________________________________
94 AliITSHandleDaSSD::AliITSHandleDaSSD(Char_t *rdfname) :
95 fRawDataFileName(NULL),
103 fBadChannelsList(NULL),
109 fPedestalThresholdFactor(fgkPedestalThresholdFactor) ,
110 fCmThresholdFactor(fgkCmThresholdFactor),
112 fOffsetDefault(INT_MAX),
117 if (!Init(rdfname)) AliError("AliITSHandleDaSSD::AliITSHandleDaSSD() initialization error!");
121 //______________________________________________________________________________
122 AliITSHandleDaSSD::AliITSHandleDaSSD(const AliITSHandleDaSSD& ssdadldc) :
124 fRawDataFileName(ssdadldc.fRawDataFileName),
125 fNumberOfModules(ssdadldc.fNumberOfModules),
127 fModIndProcessed(ssdadldc.fModIndProcessed),
128 fModIndRead(ssdadldc.fModIndRead),
131 fNumberOfEvents(ssdadldc.fNumberOfEvents),
132 fBadChannelsList(NULL),
134 fALaddersOff(ssdadldc.fALaddersOff),
135 fCLaddersOff(ssdadldc.fCLaddersOff),
136 fLdcId(ssdadldc.fLdcId),
137 fRunId(ssdadldc.fRunId),
138 fPedestalThresholdFactor(ssdadldc.fPedestalThresholdFactor),
139 fCmThresholdFactor(ssdadldc.fCmThresholdFactor),
140 fZsDefault(ssdadldc.fZsDefault),
141 fOffsetDefault(ssdadldc.fOffsetDefault),
142 fZsMinimum(ssdadldc.fZsMinimum),
143 fMergeBCLists(ssdadldc.fMergeBCLists),
144 fZsFactor(ssdadldc.fZsFactor)
147 if ((ssdadldc.fNumberOfModules > 0) && (ssdadldc.fModules)) {
148 fModules = new (nothrow) AliITSModuleDaSSD* [ssdadldc.fNumberOfModules];
150 for (Int_t modind = 0; modind < ssdadldc.fNumberOfModules; modind++) {
151 if (ssdadldc.fModules[modind]) {
152 fModules[modind] = new AliITSModuleDaSSD(*(ssdadldc.fModules[modind]));
153 if (!fModules[modind]) {
154 AliError("AliITSHandleDaSSD: Error copy constructor");
155 for (Int_t i = (modind - 1); i >= 0; i--) delete fModules[modind];
160 } else fModules[modind] = NULL;
163 AliError(Form("AliITSHandleDaSSD: Error allocating memory for %i AliITSModulesDaSSD* objects!", ssdadldc.fNumberOfModules));
164 fNumberOfModules = 0;
168 if (ssdadldc.fBadChannelsList) AliWarning("fBadChannelsList is not copied by copy constructor, use other methods to init it!");
169 if (ssdadldc.fDDLModuleMap) AliWarning("fDDLModuleMap is not copied by copy constructor, use other methods to init it!");
173 //______________________________________________________________________________
174 AliITSHandleDaSSD& AliITSHandleDaSSD::operator = (const AliITSHandleDaSSD& ssdadldc)
176 // assignment operator
177 if (this == &ssdadldc) return *this;
178 TObject::operator=(ssdadldc);
180 for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i];
184 if (fModIndex) { delete [] fModIndex; fModIndex = NULL; }
185 if ((ssdadldc.fNumberOfModules > 0) && (ssdadldc.fModules)) {
186 fModules = new (nothrow) AliITSModuleDaSSD* [ssdadldc.fNumberOfModules];
188 for (Int_t modind = 0; modind < ssdadldc.fNumberOfModules; modind++) {
189 if (ssdadldc.fModules[modind]) {
190 fModules[modind] = new AliITSModuleDaSSD(*(ssdadldc.fModules[modind]));
191 if (!fModules[modind]) {
192 AliError("AliITSHandleDaSSD: Error assignment operator");
193 for (Int_t i = (modind - 1); i >= 0; i--) delete fModules[modind];
198 } else fModules[modind] = NULL;
201 AliError(Form("AliITSHandleDaSSD: Error allocating memory for %i AliITSModulesDaSSD* objects!", ssdadldc.fNumberOfModules));
202 fNumberOfModules = 0;
206 fRawDataFileName = NULL;
207 fModIndProcessed = 0;
210 fEqIndex = ssdadldc.fEqIndex;
211 fNumberOfEvents = ssdadldc.fNumberOfEvents;
212 fLdcId = ssdadldc.fLdcId;
213 fRunId = ssdadldc.fRunId;
214 fPedestalThresholdFactor = ssdadldc.fPedestalThresholdFactor;
215 fCmThresholdFactor = ssdadldc.fCmThresholdFactor;
216 fZsDefault = ssdadldc.fZsDefault;
217 fOffsetDefault = ssdadldc.fOffsetDefault;
218 fZsMinimum = ssdadldc.fZsMinimum;
219 fMergeBCLists = ssdadldc.fMergeBCLists;
220 fZsFactor = ssdadldc.fZsFactor;
221 fALaddersOff = ssdadldc.fALaddersOff;
222 fCLaddersOff = ssdadldc.fCLaddersOff;
223 fBadChannelsList = NULL;
224 fDDLModuleMap = NULL;
226 if (ssdadldc.fBadChannelsList) AliWarning("fBadChannelsList is not copied by assignment operator, use other methods to init it!");
227 if (ssdadldc.fDDLModuleMap) AliWarning("fDDLModuleMap is not copied by assignment operator, use other methods to init it!");
232 //______________________________________________________________________________
233 AliITSHandleDaSSD::~AliITSHandleDaSSD()
235 // Default destructor
238 for (Int_t i = 0; i < fNumberOfModules; i++)
240 if (fModules[i]) delete fModules[i];
244 if (fModIndex) delete [] fModIndex;
245 if (fBadChannelsList) delete fBadChannelsList;
246 if (fDDLModuleMap) delete [] fDDLModuleMap;
251 //______________________________________________________________________________
252 void AliITSHandleDaSSD::Reset()
254 // Delete array of AliITSModuleDaSSD* objects.
256 for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i];
260 if (fModIndex) { delete [] fModIndex; fModIndex = NULL; }
262 if (fBadChannelsList) {
263 delete fBadChannelsList;
264 fBadChannelsList = NULL;
266 if (fDDLModuleMap) { delete [] fDDLModuleMap; fDDLModuleMap = NULL; }
270 fRawDataFileName = NULL;
271 fModIndProcessed = fModIndRead = 0;
274 fPedestalThresholdFactor = fgkPedestalThresholdFactor;
275 fCmThresholdFactor = fgkCmThresholdFactor;
280 //______________________________________________________________________________
281 Bool_t AliITSHandleDaSSD::Init(Char_t *rdfname)
283 // Read raw data file and set initial and configuration parameters
284 Long_t physeventind = 0, strn = 0, nofstripsev, nofstrips = 0;
285 Int_t nofeqipmentev, nofeqipment = 0, eqn = 0;
286 AliRawReaderDate *rawreaderdate = NULL;
287 UChar_t *data = NULL;
288 Long_t datasize = 0, eqbelsize = 1;
290 rawreaderdate = new AliRawReaderDate(rdfname, 0);
291 if (!(rawreaderdate->GetAttributes() || rawreaderdate->GetEventId())) {
292 AliError(Form("AliITSHandleDaSSD: Error reading raw data file %s by RawReaderDate", rdfname));
296 if (rawreaderdate->NextEvent()) {
297 fRunId = rawreaderdate->GetRunNumber();
298 rawreaderdate->RewindEvents();
299 } else { MakeZombie(); return kFALSE; }
300 if (fModules) Reset();
301 //rawreaderdate->SelectEvents(-1);
302 rawreaderdate->Select("ITSSSD");
304 while (rawreaderdate->NextEvent()) {
305 if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
308 while (rawreaderdate->ReadNextData(data)) {
309 fLdcId = rawreaderdate->GetLDCId();
311 datasize = rawreaderdate->GetDataSize();
312 eqbelsize = rawreaderdate->GetEquipmentElementSize();
313 if ( datasize % eqbelsize ) {
314 AliError(Form("AliITSHandleDaSSD: Error Init(%s): event data size %i is not an integer of equipment data size %i",
315 rdfname, datasize, eqbelsize));
319 nofstripsev += (Int_t) (datasize / eqbelsize);
321 if (physeventind++) {
322 if (nofstrips != nofstripsev) AliWarning(Form("AliITSHandleDaSSD: number of strips varies from event to event, ev = %i, %i",
323 physeventind, nofstripsev));
324 if (nofeqipment != nofeqipmentev) AliWarning("AliITSHandleDaSSD: number of DDLs varies from event to event");
326 nofstrips = nofstripsev;
327 nofeqipment = nofeqipmentev;
328 if (strn < nofstrips) strn = nofstrips;
329 if (eqn < nofeqipment) eqn = nofeqipment;
331 delete rawreaderdate;
332 if ((physeventind > 0) && (strn > 0))
334 fNumberOfEvents = physeventind;
335 fRawDataFileName = rdfname;
338 fModIndex = new (nothrow) Int_t [fgkNumberOfSSDModulesPerDdl * eqn];
340 for (Int_t i = 0; i < fgkNumberOfSSDModulesPerDdl * eqn; i++) fModIndex[i] = -1;
341 else AliWarning(Form("AliITSHandleDaSSD: Error Init(%s): Index array for %i modules was not created",
342 rdfname, fgkNumberOfSSDModulesPerDdl * eqn));
343 if (SetNumberOfModules(fgkNumberOfSSDModulesPerDdl * eqn)) {
344 TString str = TString::Format("Max number of equipment: %i, max number of channels: %i\n", eqn, strn);
345 DumpInitData(str.Data());
355 //______________________________________________________________________________
356 AliITSModuleDaSSD* AliITSHandleDaSSD::GetModule (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
358 // Retrieve AliITSModuleDaSSD object from the array
359 if (!fModules) return NULL;
360 for (Int_t i = 0; i < fNumberOfModules; i++) {
362 if ( (fModules[i]->GetDdlId() == ddlID)
363 && (fModules[i]->GetAD() == ad)
364 && (fModules[i]->GetADC() == adc))
372 Int_t AliITSHandleDaSSD::GetModuleIndex (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
374 // Retrieve the position of AliITSModuleDaSSD object in the array
375 if (!fModules) return -1;
376 for (Int_t i = 0; i < fNumberOfModules; i++) {
378 if ( (fModules[i]->GetDdlId() == ddlID)
379 && (fModules[i]->GetAD() == ad)
380 && (fModules[i]->GetADC() == adc))
389 //______________________________________________________________________________
390 AliITSChannelDaSSD* AliITSHandleDaSSD::GetStrip (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t stripID) const
392 // Retrieve AliITSChannalDaSSD object from the array
393 for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
394 if ( (fModules[modind]->GetDdlId() == ddlID)
395 && (fModules[modind]->GetAD() == ad)
396 && (fModules[modind]->GetADC() == adc) )
398 return fModules[modind]->GetStrip(stripID);
401 AliError(Form("AliITSHandleDaSSD: Error GetStrip (%i, %i, %i, %i), strip not found, returns NULL!",
402 ddlID, ad, adc, stripID));
408 //______________________________________________________________________________
409 Bool_t AliITSHandleDaSSD::SetModule(AliITSModuleDaSSD *const module, const Int_t index)
411 // Assign array element with AliITSModuleDaSSD object
412 if ((index < fNumberOfModules) && (index >= 0))
414 if (fModules[index]) delete fModules[index];
415 fModules[index] = module;
423 //______________________________________________________________________________
424 Bool_t AliITSHandleDaSSD::SetNumberOfModules (const Int_t numberofmodules)
426 // Allocates memory for AliITSModuleDaSSD objects
427 if (numberofmodules > fgkNumberOfSSDModules)
428 AliWarning(Form("AliITSHandleDaSSD: the number of modules %i you use exceeds the maximum %i for ALICE ITS SSD",
429 numberofmodules, fgkNumberOfSSDModules));
431 for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i];
435 fModules = new (nothrow) AliITSModuleDaSSD* [numberofmodules];
437 fNumberOfModules = numberofmodules;
438 memset(fModules, 0, sizeof(AliITSModuleDaSSD*) * numberofmodules);
441 AliError(Form("AliITSHandleDaSSD: Error allocating memory for %i AliITSModulesDaSSD* objects!", numberofmodules));
442 fNumberOfModules = 0;
450 //______________________________________________________________________________
451 Bool_t AliITSHandleDaSSD::ReadStaticBadChannelsMap(const Char_t *filename)
453 // Reads Static Bad Channels Map from the file
456 AliWarning("No file name is specified for Static Bad Channels Map!");
459 bcfile = new TFile(filename, "READ");
460 if (bcfile->IsZombie()) {
461 AliWarning(Form("Error reading file %s with Static Bad Channels Map!", filename));
464 bcfile->GetObject("AliITSBadChannelsSSDv2;1", fBadChannelsList);
465 if (!fBadChannelsList) {
466 AliWarning("Error fBadChannelsList == NULL!");
478 Bool_t AliITSHandleDaSSD::ReadDDLModuleMap(const Char_t *filename)
480 // Reads the SSD DDL Map from the file
482 AliRawReaderDate *rwr = NULL;
483 AliITSRawStreamSSD *rsm = NULL;
485 if (fDDLModuleMap) { delete [] fDDLModuleMap; fDDLModuleMap = NULL;}
486 fDDLModuleMap = new (nothrow) Int_t [fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl];
487 if (!fDDLModuleMap) {
488 AliWarning("Error allocation memory for DDL Map!");
492 AliWarning("No file name is specified for SSD DDL Map, using the one from AliITSRawStreamSSD!");
493 rwr = new AliRawReaderDate(event);
494 rsm = new AliITSRawStreamSSD(rwr);
495 rsm->Setv11HybridDDLMapping();
496 for (Int_t ddli = 0; ddli < fgkNumberOfSSDDDLs; ddli++)
497 for (Int_t mi = 0; mi < fgkNumberOfSSDModulesPerDdl; mi++)
498 fDDLModuleMap[(ddli * fgkNumberOfSSDModulesPerDdl + mi)] = rsm->GetModuleNumber(ddli, mi);
503 ddlmfile.open(filename, ios::in);
504 if (!ddlmfile.is_open()) {
505 AliWarning(Form("Error reading file %s with SSD DDL Map!", filename));
506 if (fDDLModuleMap) { delete [] fDDLModuleMap; fDDLModuleMap = NULL;}
510 while((!ddlmfile.eof()) && (ind < (fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl))) {
511 ddlmfile >> fDDLModuleMap[ind++];
512 if (ddlmfile.fail()) AliError(Form("Error extracting number from the DDL map file %s, ind: ", filename, ind));
514 if (ind != (fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl))
515 AliWarning(Form("Only %i (< %i) entries were read from DDL Map!", ind, (fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl)));
522 //______________________________________________________________________________
523 Int_t AliITSHandleDaSSD::ReadCalibrationDataFile (char* fileName, const Long_t eventsnumber)
525 // Reads raw data from file
526 if (!Init(fileName)){
527 AliError("AliITSHandleDaSSD: Error ReadCalibrationDataFile");
530 fNumberOfEvents = eventsnumber;
531 return ReadModuleRawData (fNumberOfModules);
536 //______________________________________________________________________________
537 Int_t AliITSHandleDaSSD::ReadModuleRawData (const Int_t modulesnumber)
539 // Reads raw data from file
540 AliRawReader *rawreaderdate = NULL;
541 AliITSRawStreamSSD *stream = NULL;
542 AliITSModuleDaSSD *module;
543 AliITSChannelDaSSD *strip;
545 Int_t nofeqipment, eqind;
546 Short_t equipid, prequipid;
548 if (!(rawreaderdate = new AliRawReaderDate(fRawDataFileName, 0))) return 0;
550 AliError("AliITSHandleDaSSD: Error ReadModuleRawData: no structure was allocated for data");
553 if (!fDDLModuleMap) if (!ReadDDLModuleMap()) AliWarning("DDL map is not defined, ModuleID will be set to 0!");
554 stream = new AliITSRawStreamSSD(rawreaderdate);
555 stream->Setv11HybridDDLMapping();
556 //rawreaderdate->SelectEvents(-1);
557 rawreaderdate->Select("ITSSSD");
560 while (rawreaderdate->NextEvent()) {
561 if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
564 while (stream->Next()) {
565 equipid = rawreaderdate->GetEquipmentId();
566 if ((equipid != prequipid)) {
567 if ((eqind = GetEqIndex(equipid)) < 0) { fEqIndex.AddAt(equipid, nofeqipment); eqind = nofeqipment++; }
570 Int_t equiptype = rawreaderdate->GetEquipmentType();
571 UChar_t ddlID = (UChar_t)rawreaderdate->GetDDLID();
572 UChar_t ad = stream->GetAD();
573 UChar_t adc = stream->GetADC();
574 UShort_t stripID = stream->GetSideFlag() ? AliITSChannelDaSSD::GetMaxStripIdConst() - stream->GetStrip() : stream->GetStrip();
575 Short_t signal = stream->GetSignal();
577 Int_t indpos = (eqind * fgkNumberOfSSDModulesPerDdl)
578 + ((ad - 1) * fgkNumberOfSSDModulesPerSlot) + (adc < 6 ? adc : (adc - 2));
579 Int_t modpos = fModIndex[indpos];
580 if (((modpos > 0) && (modpos < fModIndRead)) || ((modpos < 0) && (modind == modulesnumber))) continue;
581 if ((modpos < 0) && (modind < modulesnumber)) {
582 module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst());
584 if (fDDLModuleMap) mddli = RetrieveModuleId(ddlID, ad, adc);
586 if (!module->SetModuleIdData (ddlID, ad, adc, mddli)) return 0;
587 module->SetModuleRorcId (equipid, equiptype);
588 modpos = fModIndRead + modind;
590 fModules[modpos] = module;
591 fModIndex[indpos] = modpos;
593 if (stripID < AliITSModuleDaSSD::GetStripsPerModuleConst()) {
594 if (!(strip = fModules[modpos]->GetStrip(stripID))) {
595 strip = new AliITSChannelDaSSD(stripID, fNumberOfEvents);
596 fModules[modpos]->SetStrip(strip, stripID);
598 strip->SetSignal(eventind, signal);
600 if (!(fModules[modpos]->GetCMFerom())) {
601 fModules[modpos]->AllocateCMFeromArray();
602 fModules[modpos]->SetCMFeromEventsNumber(fNumberOfEvents);
604 fModules[modpos]->SetCMFerom(signal, (stripID - AliITSModuleDaSSD::GetStripsPerModuleConst()), eventind);
607 if (++eventind > fNumberOfEvents) break;
610 delete rawreaderdate;
611 if (modind) cout << "The memory was allocated for " << modind << " modules." << endl;
612 fModIndRead += modind;
613 if (modind < modulesnumber) RelocateModules();
619 //______________________________________________________________________________
620 Bool_t AliITSHandleDaSSD::RelocateModules()
622 // Relocate memory for AliITSModuleDaSSD object array
624 AliITSModuleDaSSD **marray = NULL;
625 for (Int_t modind = 0; modind < fNumberOfModules; modind++)
626 if (fModules[modind]) nm += 1;
627 if (nm == fNumberOfModules) return kTRUE;
628 marray = new (nothrow) AliITSModuleDaSSD* [nm];
630 AliError(Form("AliITSHandleDaSSD: Error relocating memory for %i AliITSModuleDaSSD* objects!", nm));
634 for (Int_t modind = 0; modind < fNumberOfModules; modind++)
635 if (fModules[modind]) marray[nm++] = fModules[modind];
638 fNumberOfModules = fModIndRead = nm;
644 //______________________________________________________________________________
645 Bool_t AliITSHandleDaSSD::AddFeromCm(AliITSModuleDaSSD *const module)
646 // Restore the original signal value adding CM calculated and subtracted in ferom
648 AliITSChannelDaSSD *strip;
649 Short_t *signal, *cmferom;
651 if (!module) return kFALSE;
652 if (!module->GetCMFerom()) return kTRUE;
653 for (Int_t chipind = 0; chipind < AliITSModuleDaSSD::GetChipsPerModuleConst(); chipind++) {
654 if (!(cmferom = module->GetCMFerom(chipind))) {
655 AliWarning(Form("AliITSHandleDaSSD: There is no Ferom CM values for chip %i, module %i!", chipind, module->GetModuleId()));
658 for (Int_t strind = (chipind * AliITSModuleDaSSD::GetStripsPerChip());
659 strind < ((chipind + 1) * AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
660 if (!(strip = module->GetStrip(strind))) continue;
661 if (!(signal = strip->GetSignal())) continue;
662 // if (strip->GetEventsNumber() != module->GetEventsNumber()) return kFALSE;
664 for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
665 if (SignalOutOfRange(signal[ev]) || SignalOutOfRange(cmferom[ev])) ovev += 1;
667 Short_t signal1 = signal[ev] + cmferom[ev];
668 strip->SetSignal(ev, signal1);
678 //______________________________________________________________________________
679 Bool_t AliITSHandleDaSSD::CalculatePedestal(AliITSModuleDaSSD *const module)
681 // Calculates Pedestal
682 AliITSChannelDaSSD *strip;
683 Float_t pedestal, noise;
686 if (!module) return kFALSE;
687 for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
688 if (!(strip = module->GetStrip(strind))) continue;
689 if (!(signal = strip->GetSignal())) {
690 AliError(Form("AliITSHandleDaSSD: Error CalculatePedestal(): there are no events data for module[%i] strip[%i]->GetSignal()",
691 module->GetModuleId(), strind));
694 //************* pedestal first pass ****************
697 for (ev = 0; ev < strip->GetEventsNumber(); ev++)
698 if (SignalOutOfRange(signal[ev])) ovev += 1;
699 else pedestal = ((ev - ovev)) ? pedestal + (signal[ev] - pedestal) / static_cast<Float_t>(ev - ovev + 1) : signal[ev];
700 if (ev == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
701 strip->SetPedestal(pedestal);
702 //************* noise *******************************
703 Double_t nsum = 0.0L;
705 for (ev = 0; ev < strip->GetEventsNumber(); ev++) {
706 if (SignalOutOfRange(signal[ev])) ovev += 1;
707 else nsum += pow((signal[ev] - strip->GetPedestal()), 2);
709 if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(nsum / (Float_t)(n));
710 else noise = AliITSChannelDaSSD::GetUndefinedValue();
711 strip->SetNoise(noise);
712 //************* pedestal second pass ****************
715 for (ev = 0; ev < strip->GetEventsNumber(); ev++)
716 if ( SignalOutOfRange(signal[ev])
717 || TMath::Abs(signal[ev] - strip->GetPedestal()) > (fPedestalThresholdFactor * strip->GetNoise())) ovev += 1;
718 else pedestal = ((ev - ovev)) ? pedestal + (signal[ev] - pedestal) / static_cast<Float_t>(ev - ovev + 1) : signal[ev];
719 if (ev == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
720 strip->SetPedestal(pedestal);
721 strip->SetOverflowNumber(ovev);
727 //______________________________________________________________________________
728 Bool_t AliITSHandleDaSSD::CalculateNoise(AliITSModuleDaSSD *const module)
731 AliITSChannelDaSSD *strip;
735 if (!module) return kFALSE;
736 for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
737 if (!(strip = module->GetStrip(strind))) continue;
738 if (!(signal = strip->GetSignal())) {
739 strip->SetNoise(AliITSChannelDaSSD::GetUndefinedValue());
740 AliError(Form("AliITSHandleDaSSD: Error CalculateNoise(): there are no events data for module[%i] strip[%i]->GetSignal()",
741 module->GetModuleId(), strind));
744 Double_t nsum = 0.0L;
746 for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
747 if (SignalOutOfRange(signal[ev])) ovev += 1;
748 else nsum += pow((signal[ev] - strip->GetPedestal()), 2);
750 if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(nsum / (Float_t)(n));
751 else noise = AliITSChannelDaSSD::GetUndefinedValue();
752 strip->SetNoise(noise);
759 //______________________________________________________________________________
760 Bool_t AliITSHandleDaSSD::CalculateNoiseCM(AliITSModuleDaSSD *const module)
762 // Calculates Noise with CM correction
763 AliITSChannelDaSSD *strip = NULL;
767 if (!CalculateCM(module)) {
768 AliError("Error: AliITSHandleDaSSD::CalculateCM() returned kFALSE");
771 for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
772 if (!(strip = module->GetStrip(strind))) continue; //return kFALSE;
773 if (!(signal = strip->GetSignal())) {
774 strip->SetNoiseCM(AliITSChannelDaSSD::GetUndefinedValue());
775 AliError(Form("SSDDAModule: Error CalculateNoiseWithoutCM(): there are no events data for module[%i] strip[%i]->GetSignal()",
776 module->GetModuleId(), strind));
777 continue; //return kFALSE;
779 Int_t chipind = strind / AliITSModuleDaSSD::GetStripsPerChip();
780 Double_t nsum = 0.0L;
782 for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
783 if (SignalOutOfRange(signal[ev])) ovev += 1;
784 else nsum += pow((signal[ev] - strip->GetPedestal() - module->GetCM(chipind, ev)), 2);
786 if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(nsum / (Float_t)(n));
787 else noise = AliITSChannelDaSSD::GetUndefinedValue();
788 strip->SetNoiseCM(noise);
795 //______________________________________________________________________________
796 Bool_t AliITSHandleDaSSD::CalculateCM(AliITSModuleDaSSD *const module)
799 AliITSChannelDaSSD *strip = NULL;
803 module->SetNumberOfChips(AliITSModuleDaSSD::GetChipsPerModuleConst());
804 for (Int_t chipind = 0; chipind < module->GetNumberOfChips(); chipind++) {
805 stripind = chipind * module->GetStripsPerChip();
806 module->GetCM()[chipind].Set(fNumberOfEvents);
807 module->GetCM()[chipind].Reset(0.0f);
808 for (Long_t ev = 0; ev < fNumberOfEvents; ev++) {
809 // calculate firs approximation of CM.
812 for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
813 if (!(strip = module->GetStrip(strind))) continue; //return kFALSE;
814 if (!(signal = strip->GetSignal())) {
815 AliError(Form("AliITSHandleDaSSD: Error CalculateCM: there are no events data for module[%i] strip[%i]->GetSignal()",
816 module->GetModuleId(), strind));
819 if ((SignalOutOfRange(signal[ev])) || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())) ovstr += 1;
820 else cm0 += (signal[ev] - strip->GetPedestal());
822 if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cm0 /= (Float_t)(n);
823 else { module->SetCM(0.0f, chipind, ev); continue; }
824 // calculate avarage (cm - (signal - pedestal)) over the chip
825 Double_t cmsigma = 0.0L;
827 for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
828 if (!(strip = module->GetStrip(strind))) continue;
829 if (!(signal = strip->GetSignal())) {
830 AliError(Form("AliITSHandleDaSSD: Error CalculateCM: there are no events data for module[%i] strip[%i]->GetSignal()\n",
831 module->GetModuleId(), strind));
834 if ((SignalOutOfRange(signal[ev])) || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())) ovstr += 1;
835 else cmsigma += pow((cm0 - (signal[ev] - strip->GetPedestal())), 2);
837 if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cmsigma = sqrt(cmsigma / (Float_t)(n));
838 else { module->SetCM(0.0f, chipind, ev); continue; }
839 // calculate cm with threshold
840 Double_t cmsum = 0.0L;
842 for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
843 if (!(strip = module->GetStrip(strind))) continue;
844 signal = strip->GetSignal();
845 if ( (SignalOutOfRange(signal[ev])) || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())
846 || (TMath::Abs(cm0 - (signal[ev] - strip->GetPedestal())) > (fCmThresholdFactor * cmsigma)) ) ovstr += 1;
847 else cmsum += (signal[ev] - strip->GetPedestal());
849 if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cmsum /= (Float_t)(n);
851 if (!(module->SetCM(cmsum, chipind, ev)))
852 AliError(Form("AliITSHandleDaSSD: Error, module->SetCM(...) returned kFALSE module:chip:event : [%i]:[%i]:[%i]\n",
853 module->GetModuleId(), chipind, ev));
860 //______________________________________________________________________________
861 Bool_t AliITSHandleDaSSD::ProcessRawData(const Int_t nmread)
863 // Performs calculation of calibration parameters (pedestal, noise, ...)
865 if (nmread <= 0) return kFALSE;
866 if (!fModules) return kFALSE;
867 while ((nm = ReadModuleRawData(nmread)) > 0) {
868 cout << "Processing next " << nm << " modules;" << endl;
869 for (Int_t modind = fModIndProcessed; modind < fModIndRead; modind++) {
870 if (!fModules[modind]) {
871 AliError(Form("AliITSHandleDaSSD: Error ProcessRawData(): No AliITSModuleDaSSD object with index %i is allocated in AliITSHandleDaSSD\n",
875 AddFeromCm(fModules[modind]);
876 CalculatePedestal(fModules[modind]);
877 CalculateNoise(fModules[modind]);
878 CalculateNoiseCM(fModules[modind]);
883 fModIndProcessed = fModIndRead;
884 cout << fModIndProcessed << " - done" << endl;
890 //______________________________________________________________________________
891 Short_t AliITSHandleDaSSD::RetrieveModuleId(const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
893 // Retrieve ModuleId from the DDL map which is defined in AliITSRawStreamSSD class
894 if (!fDDLModuleMap) {
895 AliError("Error DDLMap is not initialized, return 0!");
898 Int_t mddli = ((ad - 1) * fgkNumberOfSSDModulesPerSlot) + (adc < 6 ? adc : (adc - 2));
899 if ((ddlID < fgkNumberOfSSDDDLs) && (mddli < fgkNumberOfSSDModulesPerDdl)) {
900 mddli = fDDLModuleMap[ddlID * fgkNumberOfSSDModulesPerDdl + mddli];
903 AliWarning(Form("Module index = %d or ddlID = %d is out of range 0 is rturned", ddlID, mddli));
906 if (mddli > SHRT_MAX) return SHRT_MAX;
907 else return (Short_t)mddli;
912 //______________________________________________________________________________
913 AliITSNoiseSSDv2* AliITSHandleDaSSD::GetCalibrationOCDBNoise() const
915 // Fill in the array for OCDB
916 AliITSNoiseSSDv2 *ldcn = NULL;
917 AliITSModuleDaSSD *module = NULL;
918 AliITSChannelDaSSD *strip = NULL;
919 if (!fModules) return NULL;
920 ldcn = new AliITSNoiseSSDv2;
922 AliError("Error allocation mamory for AliITSBadChannelsSSDv2 object, return NULL!");
925 for (Int_t i = 0; i < fNumberOfModules; i++) {
926 if (!(module = fModules[i])) continue;
927 if (module->GetModuleId() < fgkMinSSDModuleId) continue;
928 for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
929 if (!(strip = module->GetStrip(strind))) continue;
930 Short_t modid = module->GetModuleId() - fgkMinSSDModuleId;
931 if (strip->GetStripId() < AliITSModuleDaSSD::GetPNStripsPerModule() )
932 ldcn->AddNoiseP(modid, strip->GetStripId(), strip->GetNoiseCM());
934 ldcn->AddNoiseN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()), strip->GetNoiseCM());
941 //______________________________________________________________________________
942 AliITSBadChannelsSSDv2* AliITSHandleDaSSD::GetCalibrationBadChannels() const
944 // Fill in the TObjArray with the list of bad channels
945 AliITSBadChannelsSSDv2 *ldcbc = NULL;
946 AliITSModuleDaSSD *module = NULL;
947 AliITSChannelDaSSD *strip = NULL;
948 if (!fModules) return NULL;
949 ldcbc = new AliITSBadChannelsSSDv2;
951 AliError("Error allocation mamory for AliITSBadChannelsSSDv2 object, return NULL!");
954 for (Int_t i = 0; i < fNumberOfModules; i++) {
955 if (!(module = fModules[i])) continue;
956 if (module->GetModuleId() < fgkMinSSDModuleId) continue;
957 for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
958 if (!(strip = module->GetStrip(strind))) continue;
959 Short_t modid = module->GetModuleId() - fgkMinSSDModuleId;
960 if (strip->GetStripId() < AliITSModuleDaSSD::GetPNStripsPerModule() )
961 ldcbc->AddBadChannelP(modid, strip->GetStripId(), module->CheckIfBad(strip->GetStripId()));
963 ldcbc->AddBadChannelN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()),
964 module->CheckIfBad(strip->GetStripId()));
972 //______________________________________________________________________________
973 Bool_t AliITSHandleDaSSD::SaveCalibrationSSDLDC(Char_t*& dafname)
975 // Save Calibration data locally
976 AliITSBadChannelsSSDv2 *ldcbc = NULL;
977 AliITSPedestalSSDv2 *ldcp = NULL;
978 AliITSNoiseSSDv2 *ldcn = NULL;
979 AliITSModuleDaSSD *module = NULL;
980 AliITSChannelDaSSD *strip = NULL;
982 TString dadatafilename("");
983 if (!fModules) return kFALSE;
984 ldcn = new AliITSNoiseSSDv2;
985 ldcp = new AliITSPedestalSSDv2;
986 ldcbc = new AliITSBadChannelsSSDv2;
987 if ((!ldcn) || (!ldcp) || (!ldcp)) {
988 AliError("Error allocation mamory for calibration objects, return kFALSE!");
991 for (Int_t i = 0; i < fNumberOfModules; i++) {
992 if (!(module = fModules[i])) continue;
993 if (module->GetModuleId() < fgkMinSSDModuleId) continue;
994 for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
995 if (!(strip = module->GetStrip(strind))) continue;
996 Short_t modid = module->GetModuleId() - fgkMinSSDModuleId;
997 if (strip->GetStripId() < AliITSModuleDaSSD::GetPNStripsPerModule() ) {
998 ldcn->AddNoiseP(modid, strip->GetStripId(), strip->GetNoiseCM());
999 ldcp->AddPedestalP(modid, strip->GetStripId(), strip->GetPedestal());
1000 ldcbc->AddBadChannelP(modid, strip->GetStripId(), module->CheckIfBad(strip->GetStripId()));
1002 ldcn->AddNoiseN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()), strip->GetNoiseCM());
1003 ldcp->AddPedestalN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()), strip->GetPedestal());
1004 ldcbc->AddBadChannelN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()),
1005 module->CheckIfBad(strip->GetStripId()));
1009 if (dafname) dadatafilename.Form("%s/", dafname);
1010 dadatafilename += TString::Format("ITSSSDda_%i.root", fLdcId);
1011 tmpfname = new Char_t[dadatafilename.Length()+1];
1012 dafname = strcpy(tmpfname, dadatafilename.Data());
1013 TFile *fileRun = new TFile (dadatafilename.Data(),"RECREATE");
1014 if (fileRun->IsZombie()) {
1015 AliError(Form("AliITSHandleDaSSD: SaveCalibrationSSDLDC() error open file %s", dadatafilename.Data()));
1023 fileRun->WriteTObject(ldcn);
1024 fileRun->WriteTObject(ldcp);
1025 if (fBadChannelsList)
1026 if (fMergeBCLists) {
1027 MergeBadChannels(ldcbc);
1028 fileRun->WriteTObject(ldcbc);
1029 } else fileRun->WriteTObject(fBadChannelsList);
1030 else fileRun->WriteTObject(ldcbc);
1040 //______________________________________________________________________________
1041 Int_t AliITSHandleDaSSD::MergeBadChannels(AliITSBadChannelsSSDv2*& bcl) const
1043 // Merges the statick bad channels list with bad channels got upon calibration
1044 AliITSModuleDaSSD *module = 0;
1045 Int_t nmpch = 0, nmnch = 0, ngpch = 0, ngnch = 0;
1046 if (!fBadChannelsList || !bcl) {
1047 AliWarning("Either fBadChannelsList == NULL or bad_channels_list == NULL, there is nothing to merge!");
1050 for (Int_t modind = 0; modind < GetNumberOfModules(); modind++) {
1051 if (!(module = fModules[modind])) continue;
1052 if (module->GetModuleId() < fgkMinSSDModuleId) continue;
1053 Short_t modid = module->GetModuleId() - fgkMinSSDModuleId;
1054 for (Int_t strind = 0; strind < AliITSModuleDaSSD::GetPNStripsPerModule(); strind++) {
1055 if ( (!(fBadChannelsList->GetBadChannelP(modid, strind) & fgkBadChannelMask))
1056 && (bcl->GetBadChannelP(modid, strind) & fgkBadChannelMask) )
1058 if ( (!(fBadChannelsList->GetBadChannelN(modid, strind) & fgkBadChannelMask))
1059 && (bcl->GetBadChannelN(modid, strind) & fgkBadChannelMask) )
1061 if ( (!(bcl->GetBadChannelP(modid, strind) & fgkBadChannelMask))
1062 && (fBadChannelsList->GetBadChannelP(modid, strind) & fgkBadChannelMask) ) {
1063 bcl->AddBadChannelP(modid, strind, fBadChannelsList->GetBadChannelP(modid, strind));
1066 if ( (!(bcl->GetBadChannelN(modid, strind) & fgkBadChannelMask))
1067 && (fBadChannelsList->GetBadChannelN(modid, strind) & fgkBadChannelMask) ) {
1068 bcl->AddBadChannelN(modid, strind, fBadChannelsList->GetBadChannelN(modid, strind));
1073 AliInfo(Form("Static bad, dynamic good: P%d, N%d", nmpch, nmnch));
1074 AliInfo(Form("Static good, dynamic bad: P%d, N%d", ngpch, ngnch));
1075 return (nmnch + nmpch);
1080 //______________________________________________________________________________
1081 Bool_t AliITSHandleDaSSD::DumpModInfo(const Float_t meannosethreshold) const
1083 // Dump calibration parameters
1084 AliITSModuleDaSSD *mod;
1085 AliITSChannelDaSSD *strip;
1087 cout << "SSDDALDC::DumpModInfo(): Error, no modules are allocated!" << endl;
1090 cout << "Modules with MeanNoise > " << meannosethreshold << endl;
1091 for (Int_t i = 0; i < fNumberOfModules; i++) {
1092 if (!(mod = fModules[i])) continue;
1093 Float_t maxnoise = 0.0f, meannoise = 0.0f, maxped = 0.0f;
1094 Int_t maxstrind = 0, novfstr = 0;
1095 for (Int_t strind = 0; strind < mod->GetNumberOfStrips(); strind++) {
1096 if (!(strip = mod->GetStrip(strind))) {novfstr++; continue; }
1097 if (strip->GetNoiseCM() >= AliITSChannelDaSSD::GetUndefinedValue() ) {novfstr++; continue; }
1098 if (maxnoise < strip->GetNoiseCM()) {
1099 maxnoise = strip->GetNoiseCM();
1102 meannoise = (strind - novfstr) ? meannoise + (strip->GetNoiseCM() - meannoise) / static_cast<Float_t>(strind - novfstr + 1)
1103 : strip->GetNoiseCM();
1104 if (TMath::Abs(maxped) < TMath::Abs(strip->GetPedestal())) maxped = strip->GetPedestal();
1106 if (meannoise > meannosethreshold)
1107 cout << "Mod: " << i << "; DDl: " << (int)mod->GetDdlId() << "; AD: " << (int)mod->GetAD()
1108 << "; ADC: " << (int)mod->GetADC() << "; MaxPed = " << maxped
1109 << "; MeanNoise = " << meannoise
1110 << "; NOfStrips = " << (mod->GetNumberOfStrips() - novfstr) << endl;
1117 //______________________________________________________________________________
1118 Bool_t AliITSHandleDaSSD::PrintModCalibrationData(const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const Char_t *fname) const
1120 // Print Module calibration data whether in file or in cout
1121 AliITSChannelDaSSD *strip;
1123 ostream *outputfile;
1124 if (!fname) { outputfile = &cout; }
1126 datafile.open(fname, ios::out);
1127 if (datafile.fail()) return kFALSE;
1128 outputfile = dynamic_cast<ostream*>(&datafile);
1130 *outputfile << "DDL = " << (int)ddlID << "; AD = " << (int)ad << "; ADC = " << (int)adc << endl;
1131 for (Int_t strind = 0; strind < AliITSModuleDaSSD::GetStripsPerModuleConst(); strind++) {
1132 if ( (strip = GetStrip(ddlID, ad, adc, strind)) ) {
1133 *outputfile << "Str = " << strind << "; ped = " << strip->GetPedestal()
1134 << "; noise = " << strip->GetNoiseCM() << endl;
1138 if (datafile.is_open()) datafile.close();
1144 //______________________________________________________________________________
1145 void AliITSHandleDaSSD::DumpInitData(const Char_t *str) const
1147 // Print general information retrieved from raw data file
1148 cout << "Raw data file: " << fRawDataFileName << endl
1149 << "LDC: " << (Int_t)fLdcId << "; RunId: " << fRunId << endl
1150 << "Number of physics events: " << fNumberOfEvents << endl
1155 //______________________________________________________________________________
1156 Bool_t AliITSHandleDaSSD::AllocateSimulatedModules(const Int_t copymodind)
1158 // Used to allocate simulated modules to test the performance
1159 AliITSModuleDaSSD *module;
1160 UChar_t ad, adc, ddlID;
1161 ad = adc = ddlID = 0;
1162 if (!(fModules[copymodind])) return kFALSE;
1163 for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
1164 if (!fModules[modind]) {
1165 module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst());
1166 if ((adc < 5) || ((adc > 7) && (adc < 13)) ) adc += 1;
1167 else if (adc == 5) adc = 8;
1168 else if (adc == 13) {
1170 if (ad < 8) ad += 1;
1176 if (!module->SetModuleIdData (ddlID, ad, adc, modind)) return kFALSE;
1177 fModules[modind] = module;
1178 for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
1179 AliITSChannelDaSSD *cstrip = fModules[copymodind]->GetStrip(strind);
1180 Long_t eventsnumber = cstrip->GetEventsNumber();
1181 AliITSChannelDaSSD *strip = new AliITSChannelDaSSD(strind, eventsnumber);
1182 for (Long_t evind = 0; evind < eventsnumber; evind++) {
1183 Short_t sign = cstrip->GetSignal(evind);
1184 if (!strip->SetSignal(evind, sign)) AliError(Form("AliITSHandleDaSSD: Copy events error! mod = %i, str = %i", modind, strind));
1186 module->SetStrip(strip, strind);
1190 ddlID = fModules[modind]->GetDdlId();
1191 ad = fModules[modind]->GetAD();
1192 adc = fModules[modind]->GetADC();
1195 for (UShort_t modind = 0; modind < fNumberOfModules; modind++) fModules[modind]->SetModuleId(modind + 1080);
1201 //___________________________________________________________________________________________
1202 Bool_t AliITSHandleDaSSD::AdDataPresent(const Int_t ddl, const Int_t ad) const
1204 // Check if there are calibration data for given ddl and slot
1205 for (Int_t modind = 0; modind < fNumberOfModules; modind++)
1206 if ((GetModule(modind)->GetAD() == ad) && (GetModule(modind)->GetDdlId() == ddl)) return kTRUE;
1212 //___________________________________________________________________________________________
1213 Bool_t AliITSHandleDaSSD::SaveEqSlotCalibrationData(const Int_t ddl, const Int_t ad, const Char_t *fname) const
1214 // Saves calibration files for selected equipment (DDL)
1217 Int_t zsml, offsetml;
1218 ULong_t zsth, offset, zsoffset;
1220 AliError("File name must be specified!");
1223 if (!AdDataPresent(ddl, ad)) {
1224 AliError(Form("Error SaveEqSlotCalibrationData(ddl = %i, ad = %i) no data present", ddl, ad));
1227 feefile.open(fname, ios::out);
1228 if (!feefile.is_open()) {
1229 AliError(Form("Can not open the file %s for output!", fname));
1232 for (zsml = 0; fgkZsBitMask >> zsml; zsml++) ;
1233 for (offsetml = 0; fgkOffSetBitMask >> offsetml; offsetml++) ;
1234 for (Int_t strind = 0; strind < AliITSModuleDaSSD::GetStripsPerModuleConst(); strind++) {
1235 for (Int_t adcb = 0; adcb < fgkAdcPerDBlock; adcb++) {
1237 for (Int_t j = 0; j < 2; j++) {
1238 Int_t adc = adcb + j * 8;
1239 zsth = ZsThreshold(ddl, ad, adc, strind);
1240 offset = OffsetValue(ddl, ad, adc, strind);
1241 zsoffset = zsoffset | (((zsth << offsetml) | offset) << ((j == 0) ? (offsetml + zsml) : 0));
1243 feefile << "0x" << ConvBase(static_cast<unsigned long>(zsoffset), 16) << endl;
1251 //______________________________________________________________________________
1252 Int_t AliITSHandleDaSSD::ChannelIsBad(const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const
1254 // Check if the channel is bad
1255 AliITSModuleDaSSD *module = NULL;
1257 if (fBadChannelsList && fDDLModuleMap) {
1258 modn = RetrieveModuleId(ddl, ad, adc);
1259 if (modn < 0) return -1;
1260 if (modn < fgkMinSSDModuleId) {
1261 AliWarning(Form("Module ddl/ad/adc: %i/%i/%i has number %i which is wrong for SSD module", ddl, ad, adc, strn, modn));
1264 Short_t modid = modn - fgkMinSSDModuleId;
1265 if (strn < AliITSModuleDaSSD::GetPNStripsPerModule())
1266 return (fBadChannelsList->GetBadChannelP(modid, strn) & fgkBadChannelMask);
1267 else return (fBadChannelsList->GetBadChannelN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strn)) & fgkBadChannelMask);
1269 AliError("Error ether bad channels list or DDLMap is not initialized or both, AliITSModuleDaSSD::CheckIfBad(str) is used!");
1270 if ((module = GetModule(ddl, ad, adc))) {
1271 return (module->CheckIfBad(strn) & fgkBadChannelMask);
1273 AliWarning(Form("There is no calibration data for ddl = %i, ad = %i, adc = %i, 0 is used!", ddl, ad, adc));
1282 //______________________________________________________________________________
1283 Int_t AliITSHandleDaSSD::LadderIsOff(const UChar_t ddl, const UChar_t ad, const UChar_t adc) const
1285 //Checks if the module with given ddl, ad, adc is on the ladder which is in the list of ladders which are off
1286 const Int_t nm5 = 500;
1287 const Int_t nm6 = 1248;
1288 const Int_t nml5a = 12;
1289 const Int_t nml5c = 10;
1290 const Int_t nml6a = 12;
1291 const Int_t nml6c = 13;
1292 Int_t modn, ladder, layer, side;
1293 AliITSModuleDaSSD *module;
1294 if (!(module = GetModule(ddl, ad, adc))) return 0;
1295 if ((modn = module->GetModuleId()) <= 0) modn = RetrieveModuleId(ddl, ad, adc);
1296 if (modn <= 0) return 0;
1297 layer = modn >= nm6 ? 1 : 0; // 6 : 5
1298 ladder = (modn - (layer ? nm6 : nm5)) / (layer ? (nml6a + nml6c) : (nml5a + nml5c));
1299 if ( ((modn - (layer ? nm6 : nm5)) % (layer ? (nml6a + nml6c) : (nml5a + nml5c))) < (layer ? nml6a : nml5a))
1302 ladder += (layer ? 600 : 500);
1305 if (fCLaddersOff.GetSize()) {
1306 for(Int_t i = 0; i < fCLaddersOff.GetSize(); i++)
1307 if (fCLaddersOff.At(i) == ladder) return fCLaddersOff.At(i);
1311 if (fALaddersOff.GetSize()) {
1312 for(Int_t i = 0; i < fALaddersOff.GetSize(); i++)
1313 if (fALaddersOff.At(i) == ladder) return fALaddersOff.At(i);
1321 //______________________________________________________________________________
1322 ULong_t AliITSHandleDaSSD::OffsetValue(const AliITSChannelDaSSD *strip,
1323 const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const
1325 // Calculate the offset value to be upload to FEROM
1327 if (fOffsetDefault < INT_MAX) pedint = fOffsetDefault;
1328 else pedint = TMath::Nint(strip->GetPedestal());
1329 if (pedint > static_cast<Int_t>((fgkOffSetBitMask >> 1))) {
1330 if (!ChannelIsBad(ddl, ad, adc, strn) && !((fMergeBCLists) && (GetModule(ddl, ad, adc)->CheckIfBad(strn))))
1331 AliError(Form("Offset %i, channel(ddl/ad/adc/strip) %i/%i/%i/%i can not be represented with mask 0x%s, Offset = %i",
1332 pedint, ddl, ad, adc, strn, ConvBase(fgkOffSetBitMask, 16).c_str(), (fgkOffSetBitMask >> 1)));
1333 return (fgkOffSetBitMask >> 1);
1335 if ((-pedint) > static_cast<Int_t>(((fgkOffSetBitMask + 1) >> 1))) {
1336 if (!ChannelIsBad(ddl, ad, adc, strn) && !((fMergeBCLists) && (GetModule(ddl, ad, adc)->CheckIfBad(strn))))
1337 AliError(Form("Offset %i, channel(ddl/ad/adc/strip) %i/%i/%i/%i can not be represented with mask 0x%s, Offset = %i",
1338 pedint, ddl, ad, adc, strn, ConvBase(fgkOffSetBitMask, 16).c_str(),
1339 ((fgkOffSetBitMask & (~fgkOffSetBitMask >> 1)) - fgkOffSetBitMask - 1)));
1340 return fgkOffSetBitMask & (~fgkOffSetBitMask >> 1);
1342 return fgkOffSetBitMask & (pedint >= 0 ? pedint : pedint + fgkOffSetBitMask + 1);
1347 //______________________________________________________________________________
1348 ULong_t AliITSHandleDaSSD::OffsetValue(const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const
1350 // Calculate the offset value to be upload to FEROM
1351 AliITSChannelDaSSD *strip = NULL;
1352 AliITSModuleDaSSD *module = NULL;
1353 if ((module = GetModule(ddl, ad, adc))) {
1354 if ((strip = module->GetStrip(strn))) return OffsetValue(strip, ddl, ad, adc, strn);
1356 AliWarning(Form("There is no calibration data for ddl = %i, ad = %i, adc = %i, strip = %i, 0 is used!", ddl, ad, adc, strn));
1360 AliWarning(Form("There is no calibration data for ddl = %i, ad = %i, adc = %i, 0 is used!", ddl, ad, adc));
1367 //______________________________________________________________________________
1368 ULong_t AliITSHandleDaSSD::ZsThreshold(AliITSChannelDaSSD *strip) const
1370 // Calculate the value of zero suppression threshold to be upload to FEROM
1372 if (fZsDefault < 0) {
1373 zs = TMath::Nint(fZsFactor * strip->GetNoiseCM());
1374 if (zs < static_cast<ULong_t>(fZsMinimum)) zs = static_cast<ULong_t>(fZsMinimum);
1376 else zs = fZsDefault;
1377 return (zs < fgkZsBitMask) ? (zs & fgkZsBitMask) : fgkZsBitMask;
1381 //______________________________________________________________________________
1382 ULong_t AliITSHandleDaSSD::ZsThreshold(const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const
1384 // Calculate the value of zero suppression threshold to be upload to FEROM, account bad channels list
1385 AliITSChannelDaSSD *strip = NULL;
1386 AliITSModuleDaSSD *module = NULL;
1387 if (ChannelIsBad(ddl, ad, adc, strn)) return fgkZsBitMask;
1388 if (LadderIsOff(ddl, ad, adc)) return fgkZsBitMask;
1389 if ((module = GetModule(ddl, ad, adc))) {
1390 if (fMergeBCLists) if (module->CheckIfBad(strn)) return fgkZsBitMask;
1391 if ((strip = module->GetStrip(strn))) return ZsThreshold(strip);
1393 AliWarning(Form("There is no calibration data for ddl = %i, ad = %i, adc = %i, strip = %i, 0 is used!", ddl, ad, adc, strn));
1397 AliWarning(Form("There is no calibration data for ddl = %i, ad = %i, adc = %i, 0 is used!", ddl, ad, adc));
1403 //______________________________________________________________________________
1404 string AliITSHandleDaSSD::ConvBase(const unsigned long value, const long base) const
1406 // Converts the unsigned long number into that in another base
1407 string digits = "0123456789ABCDEF";
1409 unsigned long v = value;
1410 if((base < 2) || (base > 16)) {
1411 result = "Error: base out of range.";
1416 result = digits[v % base] + result;
1420 while((v) || (i<8));
1427 //______________________________________________________________________________
1428 Int_t AliITSHandleDaSSD::CheckOffChips() const
1430 // Check if the chip, module are off
1431 AliITSChannelDaSSD *strip;
1433 Int_t strnd, chipnd, modnd, stroff, chipoff, modoff;
1434 offthreshold = TMath::Nint(fZsMinimum/fZsFactor);
1436 for (Int_t mi = 0; mi < fNumberOfModules; mi++) {
1437 if (!fModules[mi]) { modnd++; continue; }
1438 if (fModules[mi]->GetModuleId() < 0) continue;
1439 if (LadderIsOff(fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC()) ) continue;
1440 chipoff = chipnd = 0;
1441 for (Int_t chipind = 0; chipind < AliITSModuleDaSSD::GetChipsPerModuleConst(); chipind++) {
1443 Int_t stripind = chipind * AliITSModuleDaSSD::GetStripsPerChip();
1444 for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
1445 if (!(strip = fModules[mi]->GetStrip(strind))) { strnd++; continue; }
1446 if (strip->GetNoiseCM() < offthreshold ) stroff++;
1448 if (strnd == AliITSModuleDaSSD::GetStripsPerChip()) chipnd++;
1449 else if (stroff == AliITSModuleDaSSD::GetStripsPerChip()) chipoff++;
1450 else if ((stroff + strnd) == AliITSModuleDaSSD::GetStripsPerChip()) chipoff++;
1452 if ((!chipoff) && (!chipnd)) continue;
1453 if (chipnd == AliITSModuleDaSSD::GetChipsPerModuleConst()) {
1454 AliInfo(Form("Module: (ddl/ad/adc) %i/%i/%i seems to be off and it is not on the ladders which are off!",
1455 fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC()));
1458 if (chipoff == AliITSModuleDaSSD::GetChipsPerModuleConst()) {
1459 AliInfo(Form("Module (ddl/ad/adc): %i/%i/%i seems to be off and it is not on the ladders which are off!",
1460 fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC()));
1463 else if ((chipoff + chipnd) == AliITSModuleDaSSD::GetChipsPerModuleConst()) {
1464 AliInfo(Form("Module: (ddl/ad/adc): %i/%i/%i seems to be off and it is not on the ladders which are off!",
1465 fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC()));
1469 AliInfo(Form("Module: (ddl/ad/adc): %i/%i/%i has %i chips which are off!",
1470 fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC(), chipoff));
1474 return (modoff + modnd);