ITS/AliITSHandleDaSSD.cxx

   1 /**************************************************************************
   2  * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   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  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 ///////////////////////////////////////////////////////////////////////////////
  19 ///
  20 /// This class provides ITS SSD data handling
  21 /// used by DA.
  22 //  Author: Oleksandr Borysov
  23 //  Date: 18/07/2008
  24 ///////////////////////////////////////////////////////////////////////////////
  25
  26 #include <string>
  27 #include <fstream>
  28 #include <new>
  29 #include <Riostream.h>
  30 #include "AliITSHandleDaSSD.h"
  31 #include <math.h>
  32 #include <limits.h>
  33 #include "event.h"
  34 #include "TFile.h"
  35 #include "TString.h"
  36 #include "AliLog.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"
  44
  45
  46 ClassImp(AliITSHandleDaSSD)
  47
  48 using namespace std;
  49
  50
  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
  59
  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
  64
  65 //______________________________________________________________________________
  66 AliITSHandleDaSSD::AliITSHandleDaSSD() :
  67   fRawDataFileName(NULL),
  68   fNumberOfModules(0),
  69   fModules(NULL),
  70   fModIndProcessed(0),
  71   fModIndRead(0),
  72   fModIndex(NULL),
  73   fEqIndex(0),
  74   fNumberOfEvents(0),
  75   fBadChannelsList(NULL),
  76   fDDLModuleMap(NULL),
  77   fALaddersOff(0),
  78   fCLaddersOff(0),
  79   fLdcId(0),
  80   fRunId(0),
  81   fPedestalThresholdFactor(fgkPedestalThresholdFactor),
  82   fCmThresholdFactor(fgkCmThresholdFactor),
  83   fZsDefault(-1),
  84   fOffsetDefault(INT_MAX),
  85   fZsMinimum(2),
  86   fMergeBCLists(1),
  87   fZsFactor(3.0)
  88 {
  89 // Default constructor
  90 }
  91
  92
  93 //______________________________________________________________________________
  94 AliITSHandleDaSSD::AliITSHandleDaSSD(Char_t *rdfname) :
  95   fRawDataFileName(NULL),
  96   fNumberOfModules(0),
  97   fModules(NULL),
  98   fModIndProcessed(0),
  99   fModIndRead(0),
 100   fModIndex(NULL),
 101   fEqIndex(0),
 102   fNumberOfEvents(0),
 103   fBadChannelsList(NULL),
 104   fDDLModuleMap(NULL),
 105   fALaddersOff(0),
 106   fCLaddersOff(0),
 107   fLdcId(0),
 108   fRunId(0),
 109   fPedestalThresholdFactor(fgkPedestalThresholdFactor) ,
 110   fCmThresholdFactor(fgkCmThresholdFactor),
 111   fZsDefault(-1),
 112   fOffsetDefault(INT_MAX),
 113   fZsMinimum(2),
 114   fMergeBCLists(1),
 115   fZsFactor(3.0)
 116 {
 117   if (!Init(rdfname)) AliError("AliITSHandleDaSSD::AliITSHandleDaSSD() initialization error!");
 118 }
 119
 120
 121 //______________________________________________________________________________
 122 AliITSHandleDaSSD::AliITSHandleDaSSD(const AliITSHandleDaSSD& ssdadldc) :
 123   TObject(ssdadldc),
 124   fRawDataFileName(ssdadldc.fRawDataFileName),
 125   fNumberOfModules(ssdadldc.fNumberOfModules),
 126   fModules(NULL),
 127   fModIndProcessed(ssdadldc.fModIndProcessed),
 128   fModIndRead(ssdadldc.fModIndRead),
 129   fModIndex(NULL),
 130   fEqIndex(0),
 131   fNumberOfEvents(ssdadldc.fNumberOfEvents),
 132   fBadChannelsList(NULL),
 133   fDDLModuleMap(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)
 145 {
 146   // copy constructor
 147   if ((ssdadldc.fNumberOfModules > 0) && (ssdadldc.fModules)) {
 148     fModules = new (nothrow) AliITSModuleDaSSD* [ssdadldc.fNumberOfModules];
 149     if (fModules) {
 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];
 156             delete [] fModules;
 157             fModules = NULL;
 158             break;
 159           }
 160         } else fModules[modind] = NULL;
 161       }
 162     } else {
 163       AliError(Form("AliITSHandleDaSSD: Error allocating memory for %i AliITSModulesDaSSD* objects!", ssdadldc.fNumberOfModules));
 164       fNumberOfModules = 0;
 165       fModules = NULL;
 166     }
 167   }
 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!");
 170 }
 171
 172
 173 //______________________________________________________________________________
 174 AliITSHandleDaSSD& AliITSHandleDaSSD::operator = (const AliITSHandleDaSSD& ssdadldc)
 175 {
 176 // assignment operator
 177   if (this == &ssdadldc)  return *this;
 178   TObject::operator=(ssdadldc);
 179   if (fModules) {
 180     for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i];
 181     delete [] fModules;
 182     fModules = NULL;
 183   }
 184   if (fModIndex) { delete [] fModIndex; fModIndex = NULL; }
 185   if ((ssdadldc.fNumberOfModules > 0) && (ssdadldc.fModules)) {
 186     fModules = new (nothrow) AliITSModuleDaSSD* [ssdadldc.fNumberOfModules];
 187     if (fModules) {
 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];
 194             delete [] fModules;
 195             fModules = NULL;
 196             break;
 197           }
 198         } else fModules[modind] = NULL;
 199       }
 200     } else {
 201       AliError(Form("AliITSHandleDaSSD: Error allocating memory for %i AliITSModulesDaSSD* objects!", ssdadldc.fNumberOfModules));
 202       fNumberOfModules = 0;
 203       fModules = NULL;
 204     }
 205   }
 206   fRawDataFileName = NULL;
 207   fModIndProcessed = 0;
 208   fModIndRead = 0;
 209   fModIndex = NULL;
 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;
 225   fModIndex = 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!");
 228   return *this;
 229 }
 230
 231
 232 //______________________________________________________________________________
 233 AliITSHandleDaSSD::~AliITSHandleDaSSD()
 234 {
 235 // Default destructor
 236   if (fModules)
 237   {
 238     for (Int_t i = 0; i < fNumberOfModules; i++)
 239     {
 240       if (fModules[i]) delete fModules[i];
 241     }
 242     delete [] fModules;
 243   }
 244   if (fModIndex) delete [] fModIndex;
 245   if (fBadChannelsList)  delete fBadChannelsList;
 246   if (fDDLModuleMap) delete [] fDDLModuleMap;
 247 }
 248
 249
 250
 251 //______________________________________________________________________________
 252 void AliITSHandleDaSSD::Reset()
 253 {
 254 // Delete array of AliITSModuleDaSSD* objects.
 255   if (fModules) {
 256     for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i];
 257     delete [] fModules;
 258     fModules = NULL;
 259   }
 260   if (fModIndex) { delete [] fModIndex; fModIndex = NULL; }
 261 /*
 262   if (fBadChannelsList) {
 263     delete fBadChannelsList;
 264     fBadChannelsList = NULL;
 265   }
 266   if (fDDLModuleMap) { delete [] fDDLModuleMap; fDDLModuleMap = NULL; }
 267 */
 268   fALaddersOff.Set(0);
 269   fCLaddersOff.Set(0);
 270   fRawDataFileName = NULL;
 271   fModIndProcessed = fModIndRead = 0;
 272   fNumberOfEvents = 0;
 273   fLdcId = fRunId = 0;
 274   fPedestalThresholdFactor = fgkPedestalThresholdFactor;
 275   fCmThresholdFactor = fgkCmThresholdFactor;
 276 }
 277
 278
 279
 280 //______________________________________________________________________________
 281 Bool_t AliITSHandleDaSSD::Init(Char_t *rdfname)
 282 {
 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;
 289
 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));
 293     MakeZombie();
 294     return kFALSE;
 295   }
 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");
 303   nofstrips = 0;
 304   while (rawreaderdate->NextEvent()) {
 305     if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
 306     nofstripsev = 0;
 307     nofeqipmentev = 0;
 308     while (rawreaderdate->ReadNextData(data)) {
 309       fLdcId = rawreaderdate->GetLDCId();
 310       nofeqipmentev += 1;
 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));
 316         MakeZombie();
 317             return kFALSE;
 318       }
 319       nofstripsev += (Int_t) (datasize / eqbelsize);
 320     }
 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");
 325     }
 326     nofstrips = nofstripsev;
 327     nofeqipment = nofeqipmentev;
 328     if (strn < nofstrips)  strn = nofstrips;
 329     if (eqn < nofeqipment) eqn = nofeqipment;
 330   }
 331   delete rawreaderdate;
 332   if ((physeventind > 0) && (strn > 0))
 333   {
 334     fNumberOfEvents = physeventind;
 335     fRawDataFileName = rdfname;
 336     fEqIndex.Set(eqn);
 337     fEqIndex.Reset(-1);
 338     fModIndex = new (nothrow) Int_t [fgkNumberOfSSDModulesPerDdl * eqn];
 339     if (fModIndex)
 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());
 346       return kTRUE;
 347     }
 348   }
 349   MakeZombie();
 350   return kFALSE;
 351 }
 352
 353
 354
 355 //______________________________________________________________________________
 356 AliITSModuleDaSSD* AliITSHandleDaSSD::GetModule (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
 357 {
 358 // Retrieve AliITSModuleDaSSD object from the array
 359    if (!fModules) return NULL;
 360    for (Int_t i = 0; i < fNumberOfModules; i++) {
 361      if (fModules[i]) {
 362        if (    (fModules[i]->GetDdlId() == ddlID)
 363             && (fModules[i]->GetAD() == ad)
 364             && (fModules[i]->GetADC() == adc))
 365             return fModules[i];
 366      }
 367    }
 368    return NULL;
 369 }
 370
 371
 372 Int_t AliITSHandleDaSSD::GetModuleIndex (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
 373 {
 374 // Retrieve the position of AliITSModuleDaSSD object in the array
 375    if (!fModules) return -1;
 376    for (Int_t i = 0; i < fNumberOfModules; i++) {
 377      if (fModules[i]) {
 378        if (    (fModules[i]->GetDdlId() == ddlID)
 379             && (fModules[i]->GetAD() == ad)
 380             && (fModules[i]->GetADC() == adc))
 381             return i;
 382      }
 383    }
 384    return -1;
 385 }
 386
 387
 388
 389 //______________________________________________________________________________
 390 AliITSChannelDaSSD* AliITSHandleDaSSD::GetStrip (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t stripID) const
 391 {
 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)  )
 397         {
 398        return fModules[modind]->GetStrip(stripID);
 399     }
 400   }
 401   AliError(Form("AliITSHandleDaSSD: Error GetStrip (%i, %i, %i, %i), strip not found, returns NULL!",
 402                 ddlID, ad, adc, stripID));
 403   return NULL;
 404 }
 405
 406
 407
 408 //______________________________________________________________________________
 409 Bool_t AliITSHandleDaSSD::SetModule(AliITSModuleDaSSD *const module, const Int_t index)
 410 {
 411 // Assign array element with AliITSModuleDaSSD object
 412    if ((index < fNumberOfModules) && (index >= 0))
 413      {
 414         if (fModules[index]) delete fModules[index];
 415         fModules[index] = module;
 416         return kTRUE;
 417       }
 418    else return kFALSE;
 419 }
 420
 421
 422
 423 //______________________________________________________________________________
 424 Bool_t AliITSHandleDaSSD::SetNumberOfModules (const Int_t numberofmodules)
 425 {
 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));
 430   if (fModules) {
 431     for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i];
 432     delete [] fModules;
 433     fModules = NULL;
 434   }
 435   fModules = new (nothrow) AliITSModuleDaSSD* [numberofmodules];
 436   if (fModules) {
 437     fNumberOfModules = numberofmodules;
 438     memset(fModules, 0, sizeof(AliITSModuleDaSSD*) * numberofmodules);
 439     return kTRUE;
 440   } else {
 441      AliError(Form("AliITSHandleDaSSD: Error allocating memory for %i AliITSModulesDaSSD* objects!", numberofmodules));
 442      fNumberOfModules = 0;
 443      fModules = NULL;
 444   }
 445   return kFALSE;
 446 }
 447
 448
 449
 450 //______________________________________________________________________________
 451 Bool_t AliITSHandleDaSSD::ReadStaticBadChannelsMap(const Char_t *filename)
 452 {
 453 // Reads Static Bad Channels Map from the file
 454   TFile *bcfile;
 455   if (!filename) {
 456     AliWarning("No file name is specified for Static Bad Channels Map!");
 457     return kFALSE;
 458   }
 459   bcfile = new TFile(filename, "READ");
 460   if (bcfile->IsZombie()) {
 461     AliWarning(Form("Error reading file %s with Static Bad Channels Map!", filename));
 462     return kFALSE;
 463   }
 464   bcfile->GetObject("AliITSBadChannelsSSDv2;1", fBadChannelsList);
 465   if (!fBadChannelsList) {
 466     AliWarning("Error fBadChannelsList == NULL!");
 467     bcfile->Close();
 468     delete bcfile;
 469     return kFALSE;
 470   }
 471   bcfile->Close();
 472   delete bcfile;
 473   return kTRUE;
 474 }
 475
 476
 477
 478 Bool_t AliITSHandleDaSSD::ReadDDLModuleMap(const Char_t *filename)
 479 {
 480 // Reads the SSD DDL Map from the file
 481   ifstream             ddlmfile;
 482   AliRawReaderDate    *rwr = NULL;
 483   AliITSRawStreamSSD  *rsm = NULL;
 484   void                *event = 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!");
 489     return kFALSE;
 490   }
 491   if (!filename) {
 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);
 499     if (rsm) delete rsm;
 500     if (rwr) delete rwr;
 501     return kTRUE;
 502   }
 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;}
 507     return kFALSE;
 508   }
 509   Int_t ind = 0;
 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));
 513   }
 514   if (ind != (fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl))
 515     AliWarning(Form("Only %i (< %i) entries were read from DDL Map!", ind, (fgkNumberOfSSDDDLs * fgkNumberOfSSDModulesPerDdl)));
 516   ddlmfile.close();
 517   return kTRUE;
 518 }
 519
 520
 521
 522 //______________________________________________________________________________
 523 Int_t AliITSHandleDaSSD::ReadCalibrationDataFile (char* fileName, const Long_t eventsnumber)
 524 {
 525 // Reads raw data from file
 526   if (!Init(fileName)){
 527     AliError("AliITSHandleDaSSD: Error ReadCalibrationDataFile");
 528     return kFALSE;
 529   }
 530   fNumberOfEvents = eventsnumber;
 531   return ReadModuleRawData (fNumberOfModules);
 532 }
 533
 534
 535
 536 //______________________________________________________________________________
 537 Int_t AliITSHandleDaSSD::ReadModuleRawData (const Int_t modulesnumber)
 538 {
 539 // Reads raw data from file
 540   AliRawReader        *rawreaderdate = NULL;
 541   AliITSRawStreamSSD  *stream = NULL;
 542   AliITSModuleDaSSD   *module;
 543   AliITSChannelDaSSD  *strip;
 544   Long_t            eventind = 0;
 545   Int_t             nofeqipment, eqind;
 546   Short_t           equipid, prequipid;
 547   Short_t           modind;
 548   if (!(rawreaderdate = new AliRawReaderDate(fRawDataFileName, 0))) return 0;
 549   if (!fModules) {
 550     AliError("AliITSHandleDaSSD: Error ReadModuleRawData: no structure was allocated for data");
 551     return 0;
 552   }
 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");
 558   modind = 0;
 559   nofeqipment = 0;
 560   while (rawreaderdate->NextEvent()) {
 561     if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
 562     prequipid = -1;
 563     eqind = -1;
 564     while (stream->Next()) {
 565       equipid = rawreaderdate->GetEquipmentId();
 566       if ((equipid != prequipid)) {
 567         if ((eqind = GetEqIndex(equipid)) < 0) { fEqIndex.AddAt(equipid, nofeqipment); eqind = nofeqipment++; }
 568         prequipid = equipid;
 569       }
 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();
 576
 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());
 583         Int_t mddli;
 584         if (fDDLModuleMap) mddli = RetrieveModuleId(ddlID, ad, adc);
 585         else  mddli = 0;
 586         if (!module->SetModuleIdData (ddlID, ad, adc, mddli)) return 0;
 587         module->SetModuleRorcId (equipid, equiptype);
 588         modpos = fModIndRead + modind;
 589         modind += 1;
 590         fModules[modpos] = module;
 591         fModIndex[indpos] = modpos;
 592       }
 593       if (stripID < AliITSModuleDaSSD::GetStripsPerModuleConst()) {
 594         if (!(strip = fModules[modpos]->GetStrip(stripID))) {
 595           strip = new AliITSChannelDaSSD(stripID, fNumberOfEvents);
 596           fModules[modpos]->SetStrip(strip, stripID);
 597         }
 598         strip->SetSignal(eventind, signal);
 599           } else  {
 600         if (!(fModules[modpos]->GetCMFerom())) {
 601           fModules[modpos]->AllocateCMFeromArray();
 602           fModules[modpos]->SetCMFeromEventsNumber(fNumberOfEvents);
 603                 }
 604             fModules[modpos]->SetCMFerom(signal, (stripID - AliITSModuleDaSSD::GetStripsPerModuleConst()), eventind);
 605           }
 606     }
 607     if (++eventind > fNumberOfEvents) break;
 608   }
 609   delete stream;
 610   delete rawreaderdate;
 611   if (modind) cout << "The memory was allocated for " <<  modind << " modules." << endl;
 612   fModIndRead += modind;
 613   if (modind < modulesnumber) RelocateModules();
 614   return modind;
 615 }
 616
 617
 618
 619 //______________________________________________________________________________
 620 Bool_t AliITSHandleDaSSD::RelocateModules()
 621 {
 622 // Relocate memory for AliITSModuleDaSSD object array
 623   Int_t         nm = 0;
 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];
 629   if (!marray) {
 630     AliError(Form("AliITSHandleDaSSD: Error relocating memory for %i AliITSModuleDaSSD* objects!", nm));
 631     return kFALSE;
 632   }
 633   nm = 0;
 634   for (Int_t modind = 0; modind < fNumberOfModules; modind++)
 635     if (fModules[modind]) marray[nm++] = fModules[modind];
 636   delete [] fModules;
 637   fModules = marray;
 638   fNumberOfModules = fModIndRead = nm;
 639   return kTRUE;
 640 }
 641
 642
 643
 644 //______________________________________________________________________________
 645 Bool_t AliITSHandleDaSSD::AddFeromCm(AliITSModuleDaSSD *const module)
 646 // Restore the original signal value adding CM calculated and subtracted in ferom
 647 {
 648   AliITSChannelDaSSD *strip;
 649   Short_t            *signal, *cmferom;
 650
 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()));
 656       continue;
 657     }
 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;
 663       Long_t ovev = 0;
 664       for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
 665         if (SignalOutOfRange(signal[ev]) || SignalOutOfRange(cmferom[ev])) ovev += 1;
 666         else {
 667           Short_t signal1 = signal[ev] + cmferom[ev];
 668           strip->SetSignal(ev, signal1);
 669             }
 670       }
 671     }
 672   }
 673   return kTRUE;
 674 }
 675
 676
 677
 678 //______________________________________________________________________________
 679 Bool_t AliITSHandleDaSSD::CalculatePedestal(AliITSModuleDaSSD *const module)
 680 {
 681 // Calculates Pedestal
 682   AliITSChannelDaSSD *strip;
 683   Double_t            pedestal, noise;
 684   Short_t            *signal;
 685   Long_t              ovev, ev, n;
 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));
 692       continue;
 693     }
 694 //************* pedestal first pass ****************
 695     pedestal = 0.0L;
 696     ovev = 0l;
 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<Double_t>(ev - ovev + 1) : signal[ev];
 700     if (ev == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
 701     strip->SetPedestal(static_cast<Float_t>(pedestal));
 702 //************* noise *******************************
 703     Double_t nsum = 0.0L;
 704     ovev = 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);
 708     }
 709     if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise =  sqrt(nsum / (Double_t)(n));
 710     else  noise = AliITSChannelDaSSD::GetUndefinedValue();
 711     strip->SetNoise(static_cast<Float_t>(noise));
 712 //************* pedestal second pass ****************
 713     pedestal = 0.0L;
 714     ovev = 0l;
 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<Double_t>(ev - ovev + 1) : signal[ev];
 719     if (ev == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
 720     strip->SetPedestal(static_cast<Float_t>(pedestal));
 721     strip->SetOverflowNumber(ovev);
 722   }
 723   return kTRUE;
 724 }
 725
 726
 727 //______________________________________________________________________________
 728 Bool_t AliITSHandleDaSSD::CalculateNoise(AliITSModuleDaSSD *const module)
 729 {
 730 // Calculates Noise
 731   AliITSChannelDaSSD *strip;
 732   Short_t    *signal;
 733   Float_t     noise;
 734   Long_t      ovev, n;
 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));
 742       continue;
 743     }
 744     Double_t nsum = 0.0L;
 745     ovev = 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);
 749     }
 750     if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise =  static_cast<Float_t>(sqrt(nsum / (Float_t)(n)));
 751     else  noise = AliITSChannelDaSSD::GetUndefinedValue();
 752     strip->SetNoise(noise);
 753   }
 754   return kTRUE;
 755 }
 756
 757
 758
 759 //______________________________________________________________________________
 760 Bool_t AliITSHandleDaSSD::CalculateNoiseCM(AliITSModuleDaSSD *const module)
 761 {
 762 // Calculates Noise with CM correction
 763   AliITSChannelDaSSD  *strip = NULL;
 764   Short_t     *signal;
 765   Float_t      noise;
 766   Long_t       ovev, n;
 767   if (!CalculateCM(module)) {
 768     AliError("Error: AliITSHandleDaSSD::CalculateCM() returned kFALSE");
 769     return kFALSE;
 770   }
 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("AliITSHandleDaSSD: Error CalculateNoiseCM(): there are no events data for module[%i] strip[%i]->GetSignal()",
 776                      module->GetModuleId(), strind));
 777       continue; //return kFALSE;
 778     }
 779     Int_t chipind = strind / AliITSModuleDaSSD::GetStripsPerChip();
 780     Double_t nsum = 0.0L;
 781     ovev = 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);
 785     }
 786     if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = static_cast<Float_t>(sqrt(nsum / (Double_t)(n)));
 787     else  noise = AliITSChannelDaSSD::GetUndefinedValue();
 788     strip->SetNoiseCM(noise);
 789   }
 790   return kTRUE;
 791 }
 792
 793
 794
 795 //______________________________________________________________________________
 796 Bool_t AliITSHandleDaSSD::CalculateCM(AliITSModuleDaSSD *const module)
 797 {
 798 // Calculates CM
 799   AliITSChannelDaSSD  *strip = NULL;
 800   Short_t             *signal;
 801   Long_t               ovstr, n;
 802   Int_t                stripind;
 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.
 810       Double_t cm0 = 0.0L;
 811       ovstr = 0l;
 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));
 817           return kFALSE;
 818         }
 819         if ((SignalOutOfRange(signal[ev])) || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())) ovstr += 1;
 820         else cm0 += (signal[ev] - strip->GetPedestal());
 821       }
 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;
 826       ovstr = 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));
 832           return kFALSE;
 833         }
 834         if ((SignalOutOfRange(signal[ev])) || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())) ovstr += 1;
 835         else cmsigma += pow((cm0 - (signal[ev] - strip->GetPedestal())), 2);
 836       }
 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;
 841       ovstr = 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());
 848       }
 849       if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cmsum /= (Float_t)(n);
 850       else cmsum = 0.0L;
 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));
 854     }
 855   }
 856   return kTRUE;
 857 }
 858
 859
 860 //______________________________________________________________________________
 861 Bool_t AliITSHandleDaSSD::ProcessRawData(const Int_t nmread, const Bool_t usewelford)
 862 {
 863 // Performs calculation of calibration parameters (pedestal, noise, ...)
 864   Int_t nm = 0;
 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",
 872                        modind));
 873         return kFALSE;
 874       }
 875       AddFeromCm(fModules[modind]);
 876       if (usewelford) {
 877         CalculatePedNoiseW(fModules[modind]);
 878         CalculateNoiseCMW(fModules[modind]);
 879       } else {
 880         CalculatePedestal(fModules[modind]);
 881         CalculateNoise(fModules[modind]);
 882         CalculateNoiseCM(fModules[modind]);
 883       }
 884     }
 885     DeleteSignal();
 886     DeleteCM();
 887     DeleteCMFerom();
 888     fModIndProcessed = fModIndRead;
 889     cout << fModIndProcessed << " - done" << endl;
 890     if (nm < nmread ) break;
 891   }
 892   return kTRUE;
 893 }
 894
 895
 896 //______________________________________________________________________________
 897 Short_t AliITSHandleDaSSD::RetrieveModuleId(const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
 898 {
 899 // Retrieve ModuleId from the DDL map which is defined in AliITSRawStreamSSD class
 900   if (!fDDLModuleMap) {
 901     AliError("Error DDLMap is not initialized, return 0!");
 902         return 0;
 903   }
 904   Int_t mddli = ((ad - 1) * fgkNumberOfSSDModulesPerSlot) + (adc < 6 ? adc : (adc - 2));
 905   if ((ddlID < fgkNumberOfSSDDDLs) && (mddli < fgkNumberOfSSDModulesPerDdl)) {
 906     mddli = fDDLModuleMap[ddlID * fgkNumberOfSSDModulesPerDdl + mddli];
 907   }
 908   else {
 909     AliWarning(Form("Module index  = %d or ddlID = %d is out of range 0 is rturned", ddlID, mddli));
 910     mddli = 0;
 911   }
 912   if (mddli > SHRT_MAX) return SHRT_MAX;
 913   else return (Short_t)mddli;
 914 }
 915
 916
 917
 918 //______________________________________________________________________________
 919 AliITSNoiseSSDv2* AliITSHandleDaSSD::GetCalibrationOCDBNoise() const
 920 {
 921 // Fill in the array for OCDB
 922   AliITSNoiseSSDv2         *ldcn = NULL;
 923   AliITSModuleDaSSD      *module = NULL;
 924   AliITSChannelDaSSD     *strip = NULL;
 925   if (!fModules) return NULL;
 926   ldcn = new AliITSNoiseSSDv2;
 927   if (!ldcn) {
 928     AliError("Error allocation mamory for AliITSBadChannelsSSDv2 object, return NULL!");
 929     return NULL;
 930   }
 931   for (Int_t i = 0; i < fNumberOfModules; i++) {
 932     if (!(module = fModules[i])) continue;
 933     if (module->GetModuleId() < fgkMinSSDModuleId) continue;
 934     for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
 935       if (!(strip = module->GetStrip(strind))) continue;
 936       Short_t modid = module->GetModuleId() - fgkMinSSDModuleId;
 937       if (strip->GetStripId() < AliITSModuleDaSSD::GetPNStripsPerModule() )
 938         ldcn->AddNoiseP(modid, strip->GetStripId(), strip->GetNoiseCM());
 939       else
 940         ldcn->AddNoiseN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()), strip->GetNoiseCM());
 941     }
 942   }
 943   return ldcn;
 944 }
 945
 946
 947 //______________________________________________________________________________
 948 AliITSBadChannelsSSDv2* AliITSHandleDaSSD::GetCalibrationBadChannels() const
 949 {
 950 // Fill in the TObjArray with the list of bad channels
 951   AliITSBadChannelsSSDv2   *ldcbc = NULL;
 952   AliITSModuleDaSSD      *module = NULL;
 953   AliITSChannelDaSSD     *strip = NULL;
 954   if (!fModules) return NULL;
 955   ldcbc = new AliITSBadChannelsSSDv2;
 956   if (!ldcbc) {
 957     AliError("Error allocation mamory for AliITSBadChannelsSSDv2 object, return NULL!");
 958     return NULL;
 959   }
 960   for (Int_t i = 0; i < fNumberOfModules; i++) {
 961     if (!(module = fModules[i])) continue;
 962     if (module->GetModuleId() < fgkMinSSDModuleId) continue;
 963     for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
 964       if (!(strip = module->GetStrip(strind))) continue;
 965       Short_t modid = module->GetModuleId() - fgkMinSSDModuleId;
 966       if (strip->GetStripId() < AliITSModuleDaSSD::GetPNStripsPerModule() )
 967         ldcbc->AddBadChannelP(modid, strip->GetStripId(), EvaluateIfChannelIsBad(module, strip->GetStripId()));
 968       else
 969         ldcbc->AddBadChannelN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()),
 970                                      EvaluateIfChannelIsBad(module, strip->GetStripId()));
 971     }
 972   }
 973   return ldcbc;
 974 }
 975
 976
 977
 978 //______________________________________________________________________________
 979 Bool_t AliITSHandleDaSSD::SaveCalibrationSSDLDC(Char_t*& dafname)
 980 {
 981 // Save Calibration data locally
 982   AliITSBadChannelsSSDv2   *ldcbc = NULL;
 983   AliITSPedestalSSDv2      *ldcp = NULL;
 984   AliITSNoiseSSDv2         *ldcn = NULL;
 985   AliITSModuleDaSSD      *module = NULL;
 986   AliITSChannelDaSSD     *strip = NULL;
 987   Char_t         *tmpfname;
 988   TString         dadatafilename("");
 989   if (!fModules) return kFALSE;
 990   ldcn = new AliITSNoiseSSDv2;
 991   ldcp = new AliITSPedestalSSDv2;
 992   ldcbc = new AliITSBadChannelsSSDv2;
 993   if ((!ldcn) || (!ldcp) || (!ldcp)) {
 994     AliError("Error allocation mamory for calibration objects, return kFALSE!");
 995     return kFALSE;
 996   }
 997   for (Int_t i = 0; i < fNumberOfModules; i++) {
 998     if (!(module = fModules[i])) continue;
 999     if (module->GetModuleId() < fgkMinSSDModuleId) continue;
1000     for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
1001       if (!(strip = module->GetStrip(strind))) continue;
1002       Short_t modid = module->GetModuleId() - fgkMinSSDModuleId;
1003       if (strip->GetStripId() < AliITSModuleDaSSD::GetPNStripsPerModule() ) {
1004         ldcn->AddNoiseP(modid, strip->GetStripId(), strip->GetNoiseCM());
1005         ldcp->AddPedestalP(modid, strip->GetStripId(), strip->GetPedestal());
1006         ldcbc->AddBadChannelP(modid, strip->GetStripId(), EvaluateIfChannelIsBad(module, strip->GetStripId()));
1007       } else {
1008         ldcn->AddNoiseN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()), strip->GetNoiseCM());
1009         ldcp->AddPedestalN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()), strip->GetPedestal());
1010         ldcbc->AddBadChannelN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strip->GetStripId()),
1011                                      EvaluateIfChannelIsBad(module, strip->GetStripId()));
1012       }
1013     }
1014   }
1015   if (dafname) dadatafilename.Form("%s/", dafname);
1016   dadatafilename += TString::Format("ITSSSDda_%i.root", fLdcId);
1017   tmpfname = new Char_t[dadatafilename.Length()+1];
1018   dafname = strcpy(tmpfname, dadatafilename.Data());
1019   TFile *fileRun = new TFile (dadatafilename.Data(),"RECREATE");
1020   if (fileRun->IsZombie()) {
1021     AliError(Form("AliITSHandleDaSSD: SaveCalibrationSSDLDC() error open file %s", dadatafilename.Data()));
1022     ldcn->Delete();
1023     delete fileRun;
1024     delete ldcn;
1025     delete ldcp;
1026     delete ldcbc;
1027     return kFALSE;
1028   }
1029   fileRun->WriteTObject(ldcn);
1030   fileRun->WriteTObject(ldcp);
1031   if (fBadChannelsList)
1032     if (fMergeBCLists) {
1033       MergeBadChannels(ldcbc);
1034       fileRun->WriteTObject(ldcbc);
1035     } else fileRun->WriteTObject(fBadChannelsList);
1036   else fileRun->WriteTObject(ldcbc);
1037   fileRun->Close();
1038   delete fileRun;
1039   delete ldcn;
1040   delete ldcp;
1041   delete ldcbc;
1042   return kTRUE;
1043 }
1044
1045
1046 //______________________________________________________________________________
1047 Int_t AliITSHandleDaSSD::MergeBadChannels(AliITSBadChannelsSSDv2*&  bcl) const
1048 {
1049 // Merges the statick bad channels list with bad channels got upon calibration
1050   AliITSModuleDaSSD     *module = 0;
1051   Int_t                  nmpch = 0, nmnch = 0, ngpch = 0, ngnch = 0;
1052   if (!fBadChannelsList || !bcl) {
1053     AliWarning("Either fBadChannelsList == NULL or bad_channels_list == NULL, there is nothing to merge!");
1054         return -1;
1055   }
1056   for (Int_t modind = 0; modind < GetNumberOfModules(); modind++) {
1057     if (!(module = fModules[modind])) continue;
1058     if (module->GetModuleId() < fgkMinSSDModuleId) continue;
1059     Short_t modid = module->GetModuleId() - fgkMinSSDModuleId;
1060     for (Int_t strind = 0; strind < AliITSModuleDaSSD::GetPNStripsPerModule(); strind++) {
1061       if ( (!(fBadChannelsList->GetBadChannelP(modid, strind) & fgkBadChannelMask))
1062           && (bcl->GetBadChannelP(modid, strind) & fgkBadChannelMask) )
1063         ngpch++;
1064       if ( (!(fBadChannelsList->GetBadChannelN(modid, strind) & fgkBadChannelMask))
1065           && (bcl->GetBadChannelN(modid, strind) & fgkBadChannelMask) )
1066         ngnch++;
1067       if ( (!(bcl->GetBadChannelP(modid, strind) & fgkBadChannelMask))
1068           && (fBadChannelsList->GetBadChannelP(modid, strind) & fgkBadChannelMask) ) {
1069         bcl->AddBadChannelP(modid, strind, fBadChannelsList->GetBadChannelP(modid, strind));
1070         nmpch++;
1071       }
1072       if ( (!(bcl->GetBadChannelN(modid, strind) & fgkBadChannelMask))
1073           && (fBadChannelsList->GetBadChannelN(modid, strind) & fgkBadChannelMask) ) {
1074         bcl->AddBadChannelN(modid, strind, fBadChannelsList->GetBadChannelN(modid, strind));
1075         nmnch++;
1076       }
1077     }
1078   }
1079   AliInfo(Form("Static bad, dynamic good: P%d,  N%d", nmpch, nmnch));
1080   AliInfo(Form("Static good, dynamic bad: P%d,  N%d", ngpch, ngnch));
1081   return (nmnch + nmpch);
1082 }
1083
1084
1085
1086 //______________________________________________________________________________
1087 Bool_t AliITSHandleDaSSD::DumpModInfo(const Float_t meannosethreshold) const
1088 {
1089 // Dump calibration parameters
1090   AliITSModuleDaSSD    *mod;
1091   AliITSChannelDaSSD   *strip;
1092   if (!fModules) {
1093     cout << "SSDDALDC::DumpModInfo():  Error, no modules are allocated!" << endl;
1094     return kFALSE;
1095   }
1096   cout << "Modules with MeanNoise > " << meannosethreshold << endl;
1097   for (Int_t i = 0; i < fNumberOfModules; i++) {
1098     if (!(mod = fModules[i])) continue;
1099     Double_t  maxnoise = 0.0L, meannoise = 0.0L, meanovf = 0.0L;
1100     Float_t   maxped = 0.0f;
1101     Int_t     maxstrind = 0, novfstr = 0, maxovf = 0;
1102     for (Int_t strind = 0; strind < mod->GetNumberOfStrips(); strind++) {
1103       if (!(strip = mod->GetStrip(strind))) {novfstr++;  continue; }
1104       if (strip->GetNoiseCM() >= AliITSChannelDaSSD::GetUndefinedValue() ) {novfstr++;  continue; }
1105       if (maxnoise < strip->GetNoiseCM()) {
1106         maxnoise = strip->GetNoiseCM();
1107         maxstrind = strind;
1108       }
1109       meannoise = (strind - novfstr) ? meannoise + (strip->GetNoiseCM() - meannoise) / static_cast<Double_t>(strind - novfstr + 1)
1110                                     : strip->GetNoiseCM();
1111       if (TMath::Abs(maxped) < TMath::Abs(strip->GetPedestal())) maxped = strip->GetPedestal();
1112       meanovf = (strind - novfstr) ? meanovf + (strip->GetOverflowNumber() - meanovf) / static_cast<Double_t>(strind - novfstr + 1)
1113                                     : strip->GetOverflowNumber();
1114       if (strip->GetOverflowNumber() > maxovf) maxovf = strip->GetOverflowNumber();
1115     }
1116     if (meannoise > meannosethreshold)
1117       cout << "Mod: " << i << ";  DDl: " << (int)mod->GetDdlId() << ";  AD: " << (int)mod->GetAD()
1118                            << ";  ADC: " << (int)mod->GetADC() << "; MaxPed = " << maxped
1119                            << ";  MeanNoise = " << meannoise
1120                            << ";  NOfStrips = " << (mod->GetNumberOfStrips() - novfstr) << endl;
1121         if (maxovf > 10) cout << "Max number of events with overflow :  " << maxovf << ";  mean : " << meanovf << endl;
1122   }
1123   return kTRUE;
1124 }
1125
1126
1127
1128 //______________________________________________________________________________
1129 Bool_t AliITSHandleDaSSD::PrintModCalibrationData(const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const Char_t *fname) const
1130 {
1131 // Print Module calibration data whether in file or in cout
1132    AliITSChannelDaSSD  *strip;
1133    ofstream             datafile;
1134    ostream             *outputfile;
1135    if (!fname) { outputfile = &cout; }
1136    else {
1137      datafile.open(fname, ios::out);
1138      if  (datafile.fail()) return kFALSE;
1139      outputfile = dynamic_cast<ostream*>(&datafile);
1140    }
1141    *outputfile  << "DDL = " << (int)ddlID << ";  AD = " << (int)ad << ";  ADC = " << (int)adc << endl;
1142    for (Int_t strind = 0; strind < AliITSModuleDaSSD::GetStripsPerModuleConst(); strind++) {
1143      if ( (strip = GetStrip(ddlID, ad, adc, strind)) ) {
1144        *outputfile << "Str = " << strind << ";  ped = " << strip->GetPedestal()
1145                    << ";  noise = " << strip->GetNoiseCM() << endl;
1146      }
1147      else continue;
1148    }
1149   if (datafile.is_open()) datafile.close();
1150   return kTRUE;
1151 }
1152
1153
1154
1155 //______________________________________________________________________________
1156 void AliITSHandleDaSSD::DumpInitData(const Char_t *str) const
1157 {
1158 // Print general information retrieved from raw data file
1159   cout << "Raw data file: " << fRawDataFileName << endl
1160        << "LDC: " << (Int_t)fLdcId << "; RunId: " << fRunId << endl
1161        << "Number of physics events: " << fNumberOfEvents << endl
1162        << str;
1163 }
1164
1165
1166 //______________________________________________________________________________
1167 Bool_t AliITSHandleDaSSD::AllocateSimulatedModules(const Int_t copymodind)
1168 {
1169 // Used to allocate simulated modules to test the performance
1170   AliITSModuleDaSSD *module;
1171   UChar_t      ad, adc, ddlID;
1172   ad = adc = ddlID = 0;
1173   if (!(fModules[copymodind])) return kFALSE;
1174   for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
1175     if (!fModules[modind]) {
1176       module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst());
1177       if ((adc < 5) || ((adc > 7) && (adc < 13)) ) adc += 1;
1178       else if (adc == 5) adc = 8;
1179       else if (adc == 13) {
1180         adc = 0;
1181         if (ad < 8) ad += 1;
1182         else {
1183           ad = 0;
1184           ddlID +=1;
1185         }
1186       }
1187       if (!module->SetModuleIdData (ddlID, ad, adc, modind)) return kFALSE;
1188       fModules[modind] = module;
1189       for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
1190         AliITSChannelDaSSD *cstrip = fModules[copymodind]->GetStrip(strind);
1191         Long_t      eventsnumber = cstrip->GetEventsNumber();
1192         AliITSChannelDaSSD *strip = new AliITSChannelDaSSD(strind, eventsnumber);
1193         for (Long_t evind = 0; evind < eventsnumber; evind++) {
1194           Short_t sign = cstrip->GetSignal(evind);
1195           if (!strip->SetSignal(evind, sign)) AliError(Form("AliITSHandleDaSSD: Copy events error! mod = %i, str = %i", modind, strind));
1196         }
1197         module->SetStrip(strip, strind);
1198       }
1199     }
1200     else {
1201       ddlID = fModules[modind]->GetDdlId();
1202       ad    = fModules[modind]->GetAD();
1203       adc   = fModules[modind]->GetADC();
1204     }
1205   }
1206   for (UShort_t modind = 0; modind < fNumberOfModules; modind++) fModules[modind]->SetModuleId(modind + 1080);
1207   return kTRUE;
1208 }
1209
1210
1211
1212 //___________________________________________________________________________________________
1213 Bool_t AliITSHandleDaSSD::AdDataPresent(const Int_t ddl, const Int_t ad) const
1214 {
1215 // Check if there are calibration data for given ddl and slot
1216   for (Int_t modind = 0; modind < fNumberOfModules; modind++)
1217     if ((GetModule(modind)->GetAD() == ad) && (GetModule(modind)->GetDdlId() == ddl)) return kTRUE;
1218   return kFALSE;
1219 }
1220
1221
1222
1223 //___________________________________________________________________________________________
1224 Bool_t AliITSHandleDaSSD::SaveEqSlotCalibrationData(const Int_t ddl, const Int_t ad, const Char_t *fname) const
1225 // Saves calibration files for selected equipment (DDL)
1226 {
1227   fstream    feefile;
1228   Int_t      zsml, offsetml;
1229   ULong_t    zsth, offset, zsoffset;
1230   if (!fname) {
1231     AliError("File name must be specified!");
1232     return kFALSE;
1233   }
1234   if (!AdDataPresent(ddl, ad)) {
1235     AliError(Form("Error SaveEqSlotCalibrationData(ddl = %i, ad = %i) no data present", ddl, ad));
1236     return kFALSE;
1237   }
1238   feefile.open(fname, ios::out);
1239   if (!feefile.is_open()) {
1240         AliError(Form("Can not open the file %s for output!", fname));
1241     return kFALSE;
1242   }
1243   for (zsml = 0; fgkZsBitMask >> zsml; zsml++) ;
1244   for (offsetml = 0; fgkOffSetBitMask >> offsetml; offsetml++) ;
1245   for (Int_t strind = 0; strind < AliITSModuleDaSSD::GetStripsPerModuleConst(); strind++) {
1246     for (Int_t adcb = 0; adcb < fgkAdcPerDBlock; adcb++) {
1247       zsoffset = 0x0;
1248       for (Int_t j = 0; j < 2; j++) {
1249         Int_t adc = adcb + j * 8;
1250         zsth = ZsThreshold(ddl, ad, adc, strind);
1251         offset = OffsetValue(ddl, ad, adc, strind);
1252         zsoffset = zsoffset | (((zsth << offsetml) | offset) << ((j == 0) ? (offsetml + zsml) : 0));
1253       }
1254       feefile << "0x" << ConvBase(static_cast<unsigned long>(zsoffset), 16) << endl;
1255     }
1256   }
1257   feefile.close();
1258   return kTRUE;
1259 }
1260
1261
1262 //______________________________________________________________________________
1263 Int_t AliITSHandleDaSSD::ChannelIsBad(const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const
1264 {
1265 // Check if the channel is bad
1266   AliITSModuleDaSSD     *module = NULL;
1267   Int_t                  modn = -1;
1268   if (fBadChannelsList && fDDLModuleMap) {
1269     modn = RetrieveModuleId(ddl, ad, adc);
1270     if (modn < 0) return -1;
1271     if (modn < fgkMinSSDModuleId) {
1272       AliWarning(Form("Module ddl/ad/adc: %i/%i/%i has number %i which is wrong for SSD module", ddl, ad, adc, strn, modn));
1273           return -1;
1274     }
1275     Short_t modid = modn - fgkMinSSDModuleId;
1276     if (strn < AliITSModuleDaSSD::GetPNStripsPerModule())
1277       return (fBadChannelsList->GetBadChannelP(modid, strn)  & fgkBadChannelMask);
1278     else return (fBadChannelsList->GetBadChannelN(modid, (AliITSChannelDaSSD::GetMaxStripIdConst() - strn)) & fgkBadChannelMask);
1279   } else {
1280     AliError("Error ether bad channels list or DDLMap is not initialized or both, EvaluateIfChannelIsBad(module, strip) is used!");
1281     if ((module = GetModule(ddl, ad, adc))) {
1282       return (EvaluateIfChannelIsBad(module, strn) & fgkBadChannelMask);
1283     } else {
1284       AliWarning(Form("There is no calibration data for ddl = %i,  ad = %i,  adc = %i, 0 is used!", ddl, ad, adc));
1285       return 0ul;
1286     }
1287         return 0;
1288   }
1289 }
1290
1291
1292
1293 //______________________________________________________________________________
1294 Int_t AliITSHandleDaSSD::LadderIsOff(const UChar_t ddl, const UChar_t ad, const UChar_t adc) const
1295 {
1296 //Checks if the module with given ddl, ad, adc is on the ladder which is in the list of ladders which are off
1297   const Int_t nm5 =  500;
1298   const Int_t nm6 =  1248;
1299   const Int_t nml5a = 12;
1300   const Int_t nml5c = 10;
1301   const Int_t nml6a = 12;
1302   const Int_t nml6c = 13;
1303   Int_t               modn, ladder, layer, side;
1304   AliITSModuleDaSSD  *module;
1305   if (!(module = GetModule(ddl, ad, adc))) return 0;
1306   if ((modn = module->GetModuleId()) <= 0)  modn = RetrieveModuleId(ddl, ad, adc);
1307   if (modn <= 0) return 0;
1308   layer = modn >= nm6 ? 1 : 0;     // 6 : 5
1309   ladder = (modn - (layer ? nm6 : nm5)) / (layer ? (nml6a + nml6c) : (nml5a + nml5c));
1310   if ( ((modn - (layer ? nm6 : nm5)) % (layer ? (nml6a + nml6c) : (nml5a + nml5c))) < (layer ? nml6a : nml5a))
1311     side = 0;      // A
1312   else side = 1;   // C
1313   ladder += (layer ? 600 : 500);
1314   layer += 5;
1315   if (side)
1316     if (fCLaddersOff.GetSize()) {
1317       for(Int_t i = 0; i < fCLaddersOff.GetSize(); i++)
1318         if (fCLaddersOff.At(i) == ladder) return fCLaddersOff.At(i);
1319       return 0;
1320     } else return 0;
1321   else
1322     if (fALaddersOff.GetSize()) {
1323       for(Int_t i = 0; i < fALaddersOff.GetSize(); i++)
1324         if (fALaddersOff.At(i) == ladder) return fALaddersOff.At(i);
1325       return 0;
1326     } else return 0;
1327   return 0;
1328 }
1329
1330
1331
1332 //______________________________________________________________________________
1333 ULong_t AliITSHandleDaSSD::OffsetValue(const AliITSChannelDaSSD *strip,
1334                                        const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const
1335 {
1336 // Calculate the offset value to be upload to FEROM
1337   Int_t  pedint;
1338   if (fOffsetDefault < INT_MAX) pedint = fOffsetDefault;
1339   else pedint = TMath::Nint(strip->GetPedestal());
1340   if (pedint > static_cast<Int_t>((fgkOffSetBitMask >> 1))) {
1341     if (!ChannelIsBad(ddl, ad, adc, strn) && !((fMergeBCLists) && (EvaluateIfChannelIsBad(GetModule(ddl, ad, adc), strn))))
1342       AliError(Form("Offset %i, channel(ddl/ad/adc/strip) %i/%i/%i/%i  can not be represented with mask 0x%s, Offset = %i",
1343                    pedint, ddl, ad, adc, strn, ConvBase(fgkOffSetBitMask, 16).c_str(), (fgkOffSetBitMask >> 1)));
1344     return (fgkOffSetBitMask >> 1);
1345   }
1346   if ((-pedint) > static_cast<Int_t>(((fgkOffSetBitMask + 1) >> 1))) {
1347     if (!ChannelIsBad(ddl, ad, adc, strn) && !((fMergeBCLists) && (EvaluateIfChannelIsBad(GetModule(ddl, ad, adc), strn))))
1348       AliError(Form("Offset %i, channel(ddl/ad/adc/strip) %i/%i/%i/%i  can not be represented with mask 0x%s, Offset = %i",
1349                pedint, ddl, ad, adc, strn, ConvBase(fgkOffSetBitMask, 16).c_str(),
1350                ((fgkOffSetBitMask & (~fgkOffSetBitMask >> 1)) - fgkOffSetBitMask - 1)));
1351     return fgkOffSetBitMask & (~fgkOffSetBitMask >> 1);
1352   }
1353   return fgkOffSetBitMask & (pedint >= 0 ? pedint : pedint + fgkOffSetBitMask + 1);
1354 }
1355
1356
1357
1358 //______________________________________________________________________________
1359 ULong_t AliITSHandleDaSSD::OffsetValue(const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const
1360 {
1361 // Calculate the offset value to be upload to FEROM
1362   AliITSChannelDaSSD    *strip = NULL;
1363   AliITSModuleDaSSD     *module = NULL;
1364   if ((module = GetModule(ddl, ad, adc))) {
1365     if ((strip = module->GetStrip(strn))) return OffsetValue(strip, ddl, ad, adc, strn);
1366     else {
1367       AliWarning(Form("There is no calibration data for ddl = %i,  ad = %i,  adc = %i,  strip = %i, 0 is used!", ddl, ad, adc, strn));
1368       return 0ul;
1369     }
1370   } else {
1371     AliWarning(Form("There is no calibration data for ddl = %i,  ad = %i,  adc = %i, 0 is used!", ddl, ad, adc));
1372     return 0ul;
1373   }
1374 }
1375
1376
1377
1378 //______________________________________________________________________________
1379 ULong_t AliITSHandleDaSSD::ZsThreshold(AliITSChannelDaSSD *strip) const
1380 {
1381 // Calculate the value of zero suppression threshold to be upload to FEROM
1382   ULong_t zs;
1383   if (fZsDefault < 0) {
1384     zs = TMath::Nint(fZsFactor * strip->GetNoiseCM());
1385     if (zs < static_cast<ULong_t>(fZsMinimum)) zs = static_cast<ULong_t>(fZsMinimum);
1386   }
1387   else zs = fZsDefault;
1388   return (zs < fgkZsBitMask) ? (zs & fgkZsBitMask) : fgkZsBitMask;
1389 }
1390
1391
1392 //______________________________________________________________________________
1393 ULong_t AliITSHandleDaSSD::ZsThreshold(const UChar_t ddl, const UChar_t ad, const UChar_t adc, const Int_t strn) const
1394 {
1395 // Calculate the value of zero suppression threshold to be upload to FEROM, account bad channels list
1396   AliITSChannelDaSSD    *strip = NULL;
1397   AliITSModuleDaSSD     *module = NULL;
1398   if (ChannelIsBad(ddl, ad, adc, strn)) return fgkZsBitMask;
1399   if (LadderIsOff(ddl, ad, adc)) return fgkZsBitMask;
1400   if (fZsDefault > 0) if (static_cast<ULong_t>(fZsDefault) >= fgkZsBitMask) return fgkZsBitMask;
1401   if ((module = GetModule(ddl, ad, adc))) {
1402         if (fMergeBCLists) if (EvaluateIfChannelIsBad(module, strn)) return fgkZsBitMask;
1403     if ((strip = module->GetStrip(strn)))  return ZsThreshold(strip);
1404     else {
1405       AliWarning(Form("There is no calibration data for ddl = %i,  ad = %i,  adc = %i,  strip = %i, 0 is used!", ddl, ad, adc, strn));
1406       return 0ul;
1407     }
1408   } else {
1409     AliWarning(Form("There is no calibration data for ddl = %i,  ad = %i,  adc = %i, 0 is used!", ddl, ad, adc));
1410     return 0ul;
1411   }
1412 }
1413
1414
1415 //______________________________________________________________________________
1416 string AliITSHandleDaSSD::ConvBase(const unsigned long value, const long base) const
1417 {
1418 // Converts the unsigned long number into that in another base
1419   string digits = "0123456789ABCDEF";
1420   string result;
1421   unsigned long v = value;
1422   if((base < 2) || (base > 16)) {
1423     result = "Error: base out of range.";
1424   }
1425   else {
1426     int i = 0;
1427     do {
1428       result = digits[v % base] + result;
1429       v /= base;
1430       i++;
1431     }
1432     while((v) || (i<8));
1433   }
1434   return result;
1435 }
1436
1437
1438
1439 //______________________________________________________________________________
1440 Int_t AliITSHandleDaSSD::CheckOffChips() const
1441 {
1442 // Check if the chip, module are off
1443   AliITSChannelDaSSD *strip;
1444   Int_t       offthreshold;
1445   Int_t       strnd, chipnd, modnd, stroff, chipoff, modoff;
1446   offthreshold = TMath::Nint(fZsMinimum/fZsFactor);
1447   modnd = modoff = 0;
1448   for (Int_t mi = 0; mi < fNumberOfModules; mi++) {
1449     if (!fModules[mi]) { modnd++; continue; }
1450     if (fModules[mi]->GetModuleId() < 0) continue;
1451     if (LadderIsOff(fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC()) ) continue;
1452     chipoff = chipnd = 0;
1453     for (Int_t chipind = 0; chipind < AliITSModuleDaSSD::GetChipsPerModuleConst(); chipind++) {
1454       strnd = stroff = 0;
1455       Int_t stripind = chipind * AliITSModuleDaSSD::GetStripsPerChip();
1456       for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
1457         if (!(strip = fModules[mi]->GetStrip(strind))) { strnd++;  continue; }
1458         if (strip->GetNoiseCM() < offthreshold ) stroff++;
1459       }
1460       if (strnd == AliITSModuleDaSSD::GetStripsPerChip()) chipnd++;
1461       else if (stroff == AliITSModuleDaSSD::GetStripsPerChip()) chipoff++;
1462       else if ((stroff + strnd) == AliITSModuleDaSSD::GetStripsPerChip()) chipoff++;
1463     }
1464     if ((!chipoff) && (!chipnd)) continue;
1465     if (chipnd == AliITSModuleDaSSD::GetChipsPerModuleConst()) {
1466       AliInfo(Form("Module: (ddl/ad/adc) %i/%i/%i seems to be off and it is not on the ladders which are off!",
1467                fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC()));
1468       modnd++;
1469     }
1470     if (chipoff == AliITSModuleDaSSD::GetChipsPerModuleConst()) {
1471       AliInfo(Form("Module (ddl/ad/adc): %i/%i/%i seems to be off and it is not on the ladders which are off!",
1472                fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC()));
1473       modoff++;
1474     }
1475     else if ((chipoff + chipnd) == AliITSModuleDaSSD::GetChipsPerModuleConst()) {
1476       AliInfo(Form("Module: (ddl/ad/adc): %i/%i/%i seems to be off and it is not on the ladders which are off!",
1477                fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC()));
1478       modoff++;
1479     }
1480     else if (chipoff) {
1481       AliInfo(Form("Module: (ddl/ad/adc): %i/%i/%i has %i chips which are off!",
1482                fModules[mi]->GetDdlId(), fModules[mi]->GetAD(), fModules[mi]->GetADC(), chipoff));
1483       modoff++;
1484     }
1485   }
1486   return (modoff + modnd);
1487 }
1488
1489
1490 //______________________________________________________________________________
1491 Bool_t AliITSHandleDaSSD::CalculatePedNoiseW(AliITSModuleDaSSD *const module)
1492 {
1493 // Calculates Pedestal and Noise using Welford algorithm
1494   AliITSChannelDaSSD *strip;
1495   Double_t            pedestal, noise, p0, s0;
1496   Short_t            *signal;
1497   Int_t               ovev, n;
1498   if (!module) return kFALSE;
1499   for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
1500     if (!(strip = module->GetStrip(strind))) continue;
1501     if (!(signal = strip->GetSignal())) {
1502       AliError(Form("AliITSHandleDaSSD: Error CalculatePedestal(): there are no events data for module[%i] strip[%i]->GetSignal()",
1503                      module->GetModuleId(), strind));
1504       continue;
1505     }
1506 //************* pedestal and noise first pass ****************
1507     pedestal = p0 = noise = 0.0L;
1508     ovev = 0;
1509     for (Int_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
1510       if (SignalOutOfRange(signal[ev])) ovev += 1;
1511       else
1512         if (!(ev - ovev)) {
1513           pedestal = p0 = signal[ev];
1514           noise = 0.0L;
1515         } else {
1516           p0 = pedestal + (signal[ev] - pedestal) / static_cast<Double_t>(ev - ovev + 1);
1517           s0 = noise + (signal[ev] - pedestal) * (signal[ev] - p0);
1518           pedestal = p0;
1519           noise = s0;
1520         }
1521     }
1522     if (strip->GetEventsNumber() == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
1523     strip->SetPedestal(static_cast<Float_t>(pedestal));
1524     if ((n = strip->GetEventsNumber() - ovev - 1) > 0)
1525       strip->SetNoise( static_cast<Float_t>(sqrt(noise / static_cast<Double_t>(n))) );
1526     else {
1527       strip->SetNoise(AliITSChannelDaSSD::GetUndefinedValue());
1528       continue;
1529     }
1530 //************* Second pass excluds event with |p - s|>f*noise *****************
1531     pedestal = p0 = noise = 0.0L;
1532     ovev = 0;
1533     for (Int_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
1534       if (   SignalOutOfRange(signal[ev])
1535           || TMath::Abs(signal[ev] - strip->GetPedestal()) > (fPedestalThresholdFactor * strip->GetNoise())) ovev += 1;
1536       else
1537         if (!(ev - ovev)) {
1538           pedestal = p0 = signal[ev];
1539           noise = 0.0L;
1540         } else {
1541           p0 = pedestal + (signal[ev] - pedestal) / static_cast<Double_t>(ev - ovev + 1);
1542           s0 = noise + (signal[ev] - pedestal) * (signal[ev] - p0);
1543           pedestal = p0;
1544           noise = s0;
1545         }
1546     }
1547     if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(noise / static_cast<Double_t>(n));
1548     else  noise = AliITSChannelDaSSD::GetUndefinedValue();
1549     strip->SetNoise(static_cast<Float_t>(noise));
1550     if (strip->GetEventsNumber() == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
1551     strip->SetPedestal(static_cast<Float_t>(pedestal));
1552     strip->SetOverflowNumber(ovev);
1553   }
1554   return kTRUE;
1555 }
1556
1557
1558 //______________________________________________________________________________
1559 Bool_t AliITSHandleDaSSD::CalculateCMW(AliITSModuleDaSSD *const module)
1560 {
1561 // Calculates CM using Welford algorithm
1562   AliITSChannelDaSSD  *strip = NULL;
1563   Short_t             *signal;
1564   Int_t                ovstr, n;
1565   Int_t                stripind;
1566   Double_t             cm0, cm1, cmsigma, cms1;
1567   module->SetNumberOfChips(AliITSModuleDaSSD::GetChipsPerModuleConst());
1568   for (Int_t chipind = 0; chipind < module->GetNumberOfChips(); chipind++) {
1569     stripind = chipind * module->GetStripsPerChip();
1570     module->GetCM()[chipind].Set(fNumberOfEvents);
1571     module->GetCM()[chipind].Reset(0.0f);
1572     for (Long_t ev = 0; ev < fNumberOfEvents; ev++) {
1573     // calculate firs approximation of CM and SigmaCM.
1574       cm0 = cm1 = cmsigma = 0.0L;
1575       ovstr = 0;
1576       for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
1577         if (!(strip = module->GetStrip(strind))) { ovstr += 1; continue; } //return kFALSE;
1578         if (!(signal = strip->GetSignal())) { ovstr += 1; continue; }  //return kFALSE;
1579         if ((SignalOutOfRange(signal[ev])) || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())) ovstr += 1;
1580         else {
1581           if (!(strind - stripind - ovstr)) {
1582           cm0 = cm1 = signal[ev] - strip->GetPedestal();
1583           cmsigma = 0.0L;
1584         } else {
1585           cm1 = cm0 + (signal[ev] - strip->GetPedestal() - cm0) / static_cast<Double_t>(strind - stripind - ovstr + 1);
1586           cms1 = cmsigma + (signal[ev] - strip->GetPedestal() - cm0) * (signal[ev] - strip->GetPedestal() - cm1);
1587           cm0 = cm1;
1588           cmsigma = cms1;
1589         } }
1590       }
1591       if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr - 1) > 0) cmsigma = sqrt(cmsigma / static_cast<Double_t>(n));
1592       else {
1593         AliWarning(Form("AliITSHandleDaSSD: Too little number of strips have a signal for module:chip:event : [%i]:[%i]:[%i]\n",
1594                    module->GetModuleId(), chipind, ev));
1595         if (!(module->SetCM(0.0f, chipind, ev)))
1596           AliError(Form("AliITSHandleDaSSD: Error, module->SetCM(...) returned kFALSE module:chip:event : [%i]:[%i]:[%i]\n",
1597                    module->GetModuleId(), chipind, ev));
1598         continue;
1599       }
1600    // calculate cm with threshold
1601       Double_t cmsum = 0.0L;
1602       ovstr = 0;
1603       for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
1604         if (!(strip = module->GetStrip(strind))) { ovstr += 1; continue; }
1605         if (!(signal = strip->GetSignal())) { ovstr += 1; continue; }
1606         if ( (SignalOutOfRange(signal[ev])) || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())
1607                || (TMath::Abs(cm0 - (signal[ev] - strip->GetPedestal())) > (fCmThresholdFactor * cmsigma)) ) ovstr += 1;
1608         else cmsum += (signal[ev] - strip->GetPedestal());
1609       }
1610       if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cmsum /= (Double_t)(n);
1611       else cmsum = 0.0L;
1612       if (!(module->SetCM(static_cast<Float_t>(cmsum), chipind, ev)))
1613         AliError(Form("AliITSHandleDaSSD: Error, module->SetCM(...) returned kFALSE module:chip:event : [%i]:[%i]:[%i]\n",
1614                  module->GetModuleId(), chipind, ev));
1615     }
1616   }
1617   return kTRUE;
1618 }
1619
1620
1621 //______________________________________________________________________________
1622 Bool_t AliITSHandleDaSSD::CalculateNoiseCMW(AliITSModuleDaSSD *const module)
1623 {
1624 // Calculates Noise with CM correction
1625   AliITSChannelDaSSD  *strip = NULL;
1626   Short_t     *signal;
1627   Int_t        ovev, n;
1628   if (!CalculateCMW(module)) {
1629     AliError("Error: AliITSHandleDaSSD::CalculateCMW() returned kFALSE");
1630     return kFALSE;
1631   }
1632   for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
1633     if (!(strip = module->GetStrip(strind))) continue; //return kFALSE;
1634     if (!(signal = strip->GetSignal())) {
1635       strip->SetNoiseCM(AliITSChannelDaSSD::GetUndefinedValue());
1636       AliError(Form("AliITSHandleDaSSD: Error CalculateNoiseCMW(): there are no events data for module[%i] strip[%i]->GetSignal()",
1637                      module->GetModuleId(), strind));
1638       continue; //return kFALSE;
1639     }
1640 //** To get exactly the same set of events as for pedestal and noise calculation **
1641     Double_t pedestal, noise, p0, s0;
1642     pedestal = p0 = noise = 0.0L;
1643     ovev = 0;
1644     for (Int_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
1645       if (SignalOutOfRange(signal[ev])) ovev += 1;
1646       else
1647         if (!(ev - ovev)) {
1648           pedestal = p0 = signal[ev];
1649           noise = 0.0L;
1650         } else {
1651           p0 = pedestal + (signal[ev] - pedestal) / static_cast<Double_t>(ev - ovev + 1);
1652           s0 = noise + (signal[ev] - pedestal) * (signal[ev] - p0);
1653           pedestal = p0;
1654           noise = s0;
1655         }
1656     }
1657     if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise = sqrt(noise / static_cast<Double_t>(n));
1658     else  {
1659           strip->SetNoiseCM(AliITSChannelDaSSD::GetUndefinedValue());
1660           continue;
1661     }
1662 //** Calculation of CM corrected noise **
1663     Int_t chipind = strind / AliITSModuleDaSSD::GetStripsPerChip();
1664     Double_t nsum = 0.0L;
1665     ovev = 0;
1666     for (Int_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
1667       if (   SignalOutOfRange(signal[ev])
1668           || TMath::Abs(signal[ev] - pedestal) > (fPedestalThresholdFactor * noise)) ovev += 1;
1669       else nsum += pow((signal[ev] - strip->GetPedestal() - module->GetCM(chipind, ev)), 2);
1670     }
1671     if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise =  sqrt(nsum / static_cast<Double_t>(n));
1672     else  noise = AliITSChannelDaSSD::GetUndefinedValue();
1673     strip->SetNoiseCM(static_cast<Float_t>(noise));
1674   }
1675   return kTRUE;
1676 }
1677
1678
1679
1680 //______________________________________________________________________________
1681 UChar_t AliITSHandleDaSSD::EvaluateIfChannelIsBad(const AliITSModuleDaSSD *const module, const Int_t stripn) const
1682 {
1683 //Applies the bad channel creteria and set the appropriate flags for returned value
1684   AliITSChannelDaSSD  *strip = 0;
1685   UInt_t               bcflags = 0;
1686   if (fZsDefault >= 0) { if (static_cast<ULong_t>(fZsDefault) >= fgkZsBitMask) bcflags |= 3; }
1687   else if (static_cast<ULong_t>(fZsMinimum) >= fgkZsBitMask) bcflags |= 3;
1688   if (LadderIsOff(module->GetDdlId(), module->GetAD(), module->GetADC()) )  bcflags |= 3;
1689
1690   if (!(strip = module->GetStrip(stripn))) bcflags |= 3;
1691   else {
1692     if (strip->GetNoiseCM() == AliITSChannelDaSSD::GetUndefinedValue()) bcflags |= 8;
1693     if (static_cast<ULong_t>(TMath::Nint(fZsFactor * strip->GetNoiseCM())) >= fgkZsBitMask) bcflags |= 8;
1694     if (strip->GetNoiseCM() < 1) bcflags |= 16;
1695     if (strip->GetPedestal() > ((fgkOffSetBitMask >> 1) - 1))  bcflags |= 4;
1696     else if ((-(strip->GetPedestal())) > (fgkOffSetBitMask >> 1))  bcflags |= 4;
1697     if (bcflags) bcflags |= 3;
1698   }
1699   return bcflags;
1700 }
1701