ITS/AliITSModuleDaSSD.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 storage container ITS SSD module callibration data
  21 /// used by DA.
  22 ///
  23 /// Date: 09/07/2009
  24 ///////////////////////////////////////////////////////////////////////////////
  25
  26 #include "AliITSNoiseSSD.h"
  27 #include "AliITSPedestalSSD.h"
  28 #include "AliITSBadChannelsSSD.h"
  29 #include "AliITSModuleDaSSD.h"
  30 #include "TString.h"
  31 #include "AliLog.h"
  32
  33 ClassImp(AliITSModuleDaSSD)
  34
  35
  36 const Int_t   AliITSModuleDaSSD::fgkStripsPerModule   = 1536;   // Number of strips per SSD module
  37 const Int_t   AliITSModuleDaSSD::fgkPNStripsPerModule = 768;    // Number of N/P strips per SSD module
  38 const Int_t   AliITSModuleDaSSD::fgkStripsPerChip     = 128;    // Number of strips per chip HAL25
  39 const UChar_t AliITSModuleDaSSD::fgkMaxAdNumber       = 9;      // MAx SSD FEROM AD number
  40 const UChar_t AliITSModuleDaSSD::fgkMaxAdcNumber      = 13;     // MAx SSD FEROM ADC number
  41 const Int_t   AliITSModuleDaSSD::fgkChipsPerModule    = 12;     // Number of HAL25 chips per SSD module
  42
  43
  44
  45 using namespace std;
  46
  47 //______________________________________________________________________________
  48 AliITSModuleDaSSD::AliITSModuleDaSSD() :
  49   fEquipId(0),
  50   fEquipType(0),
  51   fDdlId(0),
  52   fAd(0),
  53   fAdc(0),
  54   fModuleId(0),
  55   fNumberOfStrips(0),
  56   fStrips(NULL),
  57   fNumberOfChips(0),
  58   fCm(NULL),
  59   fCmFerom(NULL),
  60   fEventsNumber(0)
  61 {
  62 // Default constructor
  63 }
  64
  65
  66 //______________________________________________________________________________
  67 AliITSModuleDaSSD::AliITSModuleDaSSD(const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t moduleID) :
  68   fEquipId(0),
  69   fEquipType(0),
  70   fDdlId(ddlID),
  71   fAd(ad),
  72   fAdc(adc),
  73   fModuleId(moduleID),
  74   fNumberOfStrips(0),
  75   fStrips(NULL),
  76   fNumberOfChips(0),
  77   fCm(NULL),
  78   fCmFerom(NULL),
  79   fEventsNumber(0)
  80 {
  81 // Constructor, set module id data
  82 }
  83
  84
  85
  86 //______________________________________________________________________________
  87 AliITSModuleDaSSD::AliITSModuleDaSSD(const Int_t numberofstrips) :
  88   fEquipId(0),
  89   fEquipType(0),
  90   fDdlId(0),
  91   fAd(0),
  92   fAdc(0),
  93   fModuleId(0),
  94   fNumberOfStrips(0),
  95   fStrips(NULL),
  96   fNumberOfChips(0),
  97   fCm(NULL),
  98   fCmFerom(NULL),
  99   fEventsNumber(0)
 100 {
 101 // Constructor, allocates memory for AliITSChannelDaSSD* and TArrayS* array for CM calculated in FEROM
 102   if (numberofstrips != fgkStripsPerModule)
 103     AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i strips", fgkStripsPerModule));
 104   fStrips = new (nothrow) AliITSChannelDaSSD* [numberofstrips];
 105   if (fStrips) {
 106      fNumberOfStrips = numberofstrips;
 107      for (Int_t i = 0; i < numberofstrips; i++) fStrips[i]= NULL;
 108   } else {
 109      AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips));
 110      fNumberOfStrips = 0;
 111      fStrips = NULL;
 112   }
 113 }
 114
 115
 116 //______________________________________________________________________________
 117 AliITSModuleDaSSD::AliITSModuleDaSSD(const Int_t numberofstrips, const Long_t eventsnumber) :
 118   fEquipId(0),
 119   fEquipType(0),
 120   fDdlId(0),
 121   fAd(0),
 122   fAdc(0),
 123   fModuleId(0),
 124   fNumberOfStrips(0),
 125   fStrips(NULL),
 126   fNumberOfChips(0),
 127   fCm(NULL),
 128   fCmFerom(NULL),
 129   fEventsNumber(0)
 130 {
 131 // Constructor, allocates memory for AliITSChannelDaSSD* and events data
 132   if (numberofstrips != fgkStripsPerModule)
 133     AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i strips", fgkStripsPerModule));
 134   fStrips = new (nothrow) AliITSChannelDaSSD* [numberofstrips];
 135   if (fStrips) {
 136      fNumberOfStrips = numberofstrips;
 137      memset(fStrips, 0, numberofstrips * sizeof(AliITSChannelDaSSD*));
 138      for (Int_t i = 0; i < fNumberOfStrips; i++) {
 139        fStrips[i] = new AliITSChannelDaSSD(i, eventsnumber);
 140        if (!fStrips[i]) AliError(Form("AliITSModuleDaSSD: Error allocating memory for AliITSChannelDaSSD %i-th object", i));
 141      }
 142   } else {
 143      AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips));
 144      fNumberOfStrips = 0;
 145      fStrips = NULL;
 146   }
 147 }
 148
 149
 150
 151 //______________________________________________________________________________
 152 AliITSModuleDaSSD::AliITSModuleDaSSD(const AliITSModuleDaSSD& module) :
 153   TObject(module),
 154   fEquipId(module.fEquipId),
 155   fEquipType(module.fEquipType),
 156   fDdlId(module.fDdlId),
 157   fAd(module.fAd),
 158   fAdc(module.fAdc),
 159   fModuleId(module.fModuleId),
 160   fNumberOfStrips(module.fNumberOfStrips),
 161   fStrips(NULL),
 162   fNumberOfChips(module.fNumberOfChips),
 163   fCm(NULL),
 164   fCmFerom(NULL),
 165   fEventsNumber(module.fEventsNumber)
 166 {
 167 // copy constructor
 168   if ((module.fNumberOfStrips > 0) && (module.fStrips)) {
 169     fStrips = new (nothrow) AliITSChannelDaSSD* [module.fNumberOfStrips];
 170     if (fStrips) {
 171       for (Int_t strind = 0; strind < module.fNumberOfStrips; strind++) {
 172         if (module.fStrips[strind]) {
 173           fStrips[strind] = new AliITSChannelDaSSD(*(module.fStrips[strind]));
 174           if (!fStrips[strind]) {
 175             AliError("AliITSModuleDaSSD: Error copy constructor");
 176             for (Int_t i = (strind - 1); i >= 0; i--) delete fStrips[strind];
 177             delete [] fStrips;
 178             fStrips = NULL;
 179             break;
 180           }
 181         } else fStrips[strind] = NULL;
 182       }
 183     } else {
 184        AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", module.fNumberOfStrips));
 185        fNumberOfStrips = 0;
 186        fStrips = NULL;
 187     }
 188   }
 189   if (module.fCm) {
 190     fCm = new (nothrow) TArrayF [module.fNumberOfChips];
 191     if (fCm) {
 192       for (Int_t chind = 0; chind < module.fNumberOfChips; chind++) fCm[chind] = module.fCm[chind];
 193     } else {
 194        AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayF objects!", module.fNumberOfChips));
 195        fNumberOfChips = 0;
 196        fCm = NULL;
 197     }
 198   }
 199
 200   if (module.fCmFerom) {
 201     fCmFerom = new (nothrow) TArrayS [fgkChipsPerModule];
 202     if (fCmFerom) {
 203       for (Int_t chind = 0; chind < fgkChipsPerModule; chind++) fCmFerom[chind] = module.fCmFerom[chind];
 204     } else {
 205        AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayS objects!", fgkChipsPerModule));
 206        fCmFerom = NULL;
 207     }
 208   }
 209 }
 210
 211
 212
 213 //______________________________________________________________________________
 214 AliITSModuleDaSSD& AliITSModuleDaSSD::operator = (const AliITSModuleDaSSD& module)
 215 {
 216 // assignment operator
 217   if (this == &module)  return *this;
 218   TObject::operator=(module);
 219   if (fStrips) {
 220     for (Long_t i = 0; i < fNumberOfStrips; i++) if (fStrips[i]) delete fStrips[i];
 221     delete [] fStrips;
 222     fStrips = NULL;
 223   }
 224   fEquipId = module.fEquipId;
 225   fEquipType = module.fEquipType;
 226   fDdlId = module.fDdlId;
 227   fAd = module.fAd;
 228   fAdc = module.fAdc;
 229   fModuleId = module.fModuleId;
 230   fStrips = NULL;
 231   fNumberOfChips = module.fNumberOfChips;
 232   fCm = NULL;
 233   fEventsNumber = module.fEventsNumber;
 234   if ((module.fNumberOfStrips > 0) && (module.fStrips)) {
 235     fStrips = new (nothrow) AliITSChannelDaSSD* [module.fNumberOfStrips];
 236     if (fStrips) {
 237       memset(fStrips, 0, (sizeof(AliITSChannelDaSSD*) * module.fNumberOfStrips));
 238       for (Int_t strind = 0; strind < module.fNumberOfStrips; strind++) {
 239         if (module.fStrips[strind]) {
 240           fStrips[strind] = new AliITSChannelDaSSD(*(module.fStrips[strind]));
 241           if (!fStrips[strind]) {
 242             AliError("AliITSModuleDaSSD: Error copy constructor");
 243             for (Int_t i = (strind - 1); i >= 0; i--) delete fStrips[strind];
 244             delete [] fStrips;
 245             fStrips = NULL;
 246             fNumberOfStrips = 0;
 247             break;
 248           }
 249         } else fStrips[strind] = NULL;
 250       }
 251       fNumberOfStrips = module.fNumberOfStrips;
 252     } else {
 253        AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", module.fNumberOfStrips));
 254        fNumberOfStrips = 0;
 255        fStrips = NULL;
 256     }
 257   }
 258   if (fCm) delete [] fCm;
 259   if (module.fCm) {
 260     fCm = new (nothrow) TArrayF [module.fNumberOfChips];
 261     if (fCm) {
 262       for (Int_t chind = 0; chind < module.fNumberOfChips; chind++) fCm[chind] = module.fCm[chind];
 263     } else {
 264        AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayF objects!", module.fNumberOfChips));
 265        fNumberOfChips = 0;
 266        fCm = NULL;
 267     }
 268   }
 269   if (fCmFerom) { delete [] fCmFerom; fCmFerom = NULL; }
 270   if (module.fCmFerom) {
 271     fCmFerom = new (nothrow) TArrayS [module.fNumberOfChips];
 272     if (fCmFerom) {
 273       for (Int_t chind = 0; chind < fgkChipsPerModule; chind++) fCmFerom[chind] = module.fCmFerom[chind];
 274     } else {
 275        AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayS objects!", fgkChipsPerModule));
 276        fCmFerom = NULL;
 277     }
 278   }
 279   return *this;
 280 }
 281
 282
 283
 284 //______________________________________________________________________________
 285 AliITSModuleDaSSD::~AliITSModuleDaSSD()
 286 {
 287 // Destructor
 288   if (fStrips)
 289   {
 290     for (Long_t i = 0; i < fNumberOfStrips; i++)
 291     {
 292       if (fStrips[i]) delete fStrips[i];
 293     }
 294     delete [] fStrips;
 295   }
 296   if (fCm) delete [] fCm;
 297   if (fCmFerom) delete [] fCmFerom;
 298 }
 299
 300
 301
 302 //______________________________________________________________________________
 303 Bool_t AliITSModuleDaSSD::SetNumberOfStrips(const Int_t numberofstrips)
 304 {
 305 // Allocates memory for AliITSChannelDaSSD*
 306   if (fStrips) {
 307     for (Int_t i = 0; i < fNumberOfStrips; i++) if (fStrips[i]) delete fStrips[i];
 308     delete [] fStrips;
 309     fStrips = NULL;
 310   }
 311   if (numberofstrips <= 0) {fNumberOfStrips = 0; return kTRUE; }
 312   if (numberofstrips != fgkStripsPerModule)
 313     AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i strips", fgkStripsPerModule));
 314   fStrips = new (nothrow) AliITSChannelDaSSD* [numberofstrips];
 315   if (fStrips) {
 316      fNumberOfStrips = numberofstrips;
 317      memset(fStrips, 0, sizeof(AliITSChannelDaSSD*) * numberofstrips);
 318      return kTRUE;
 319   } else {
 320      AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips));
 321      fNumberOfStrips = 0;
 322      fStrips = NULL;
 323      return kFALSE;
 324   }
 325 }
 326
 327
 328 //______________________________________________________________________________
 329 Bool_t AliITSModuleDaSSD::SetNumberOfChips(const Int_t nchips)
 330 {
 331 // Allocate nchips TArrayF objects to save Common Mode
 332   DeleteCM();
 333   if (nchips <= 0) {fNumberOfChips = 0; return kTRUE; }
 334   if (nchips != fgkChipsPerModule)
 335     AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i HAL25 chips", fgkChipsPerModule));
 336   fCm = new (nothrow) TArrayF [nchips];
 337   if (fCm) {
 338      fNumberOfChips = nchips;
 339      return kTRUE;
 340   } else {
 341      AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayF objects!", nchips));
 342      fNumberOfChips = 0;
 343      fCm = NULL;
 344      return kFALSE;
 345   }
 346 }
 347
 348
 349 //______________________________________________________________________________
 350 Bool_t AliITSModuleDaSSD::SetModuleIdData (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const Short_t moduleID)
 351 {
 352 // SetModuleIdData
 353   if (ad > fgkMaxAdNumber) {
 354     AliWarning(Form("AliITSModuleDaSSD: Wrong AD number: %i", ad));
 355     return kFALSE;
 356   }
 357   if (adc > fgkMaxAdcNumber || ForbiddenAdcNumber(adc)) {
 358     AliWarning(Form("AliITSModuleDaSSD: Wrong ADC number: %i", adc));
 359     return kFALSE;
 360   }
 361   fDdlId = ddlID;
 362   fAd = ad;
 363   fAdc = adc;
 364   fModuleId = moduleID;
 365   return kTRUE;
 366 }
 367
 368
 369 //______________________________________________________________________________
 370 void AliITSModuleDaSSD::SetModuleFEEId (const UChar_t ddlID, const UChar_t ad, const UChar_t adc)
 371 {
 372 // Set id data of FEE connected to the Module
 373   fDdlId = ddlID;
 374   fAd = ad;
 375   fAdc = adc;
 376 }
 377
 378
 379 //______________________________________________________________________________
 380 void AliITSModuleDaSSD::SetModuleRorcId (const Int_t equipid, const Int_t equiptype)
 381 {
 382 // Set data to access FEROM registres via DDL
 383   fEquipId = equipid;
 384   fEquipType = equiptype;
 385 }
 386
 387
 388 //______________________________________________________________________________
 389 Bool_t AliITSModuleDaSSD::SetEventsNumber(const Long_t eventsnumber)
 390 {
 391 // Allocate the memory for the events data
 392   Int_t i;
 393   if (!fStrips) return kFALSE;
 394   for (i = 0; i < fNumberOfStrips; i++) {
 395     if (fStrips[i]) {
 396       if (!fStrips[i]->SetEvenetsNumber(eventsnumber)) {
 397         for (Int_t j = 0; j < i; j++) fStrips[j]->DeleteSignal();
 398         AliError(Form("AliITSModuleDaSSD: Error allocating memory for %ld event for module %d, strip %d",eventsnumber, (Int_t)fModuleId, i));
 399         return kFALSE;
 400       }
 401     }
 402     else {
 403       if (!(fStrips[i] = new AliITSChannelDaSSD(i, eventsnumber))) {
 404         for (Int_t j = 0; j < i; j++) delete fStrips[j];
 405         delete [] fStrips;
 406         fNumberOfStrips = 0;
 407         fStrips = NULL;
 408         AliError(Form("AliITSModuleDaSSD: Error allocating memory for strip %i of module %i!", (Int_t)fModuleId, i));
 409         return kFALSE;
 410       }
 411     }
 412   }
 413   fEventsNumber = eventsnumber;
 414   return kTRUE;
 415 }
 416
 417
 418
 419 //______________________________________________________________________________
 420 Bool_t AliITSModuleDaSSD::SetCM (const Float_t cm, const Int_t chipn, const Int_t evn)
 421 {
 422 // Set value of CM for a given chip and event
 423   if ((!fCm) || (chipn >= fNumberOfChips)) return kFALSE;
 424   if (evn >= fCm[chipn].GetSize()) return kFALSE;
 425   else fCm[chipn][evn] = cm;
 426   return kTRUE;
 427 }
 428
 429
 430
 431 //______________________________________________________________________________
 432 Float_t  AliITSModuleDaSSD::GetCM(const Int_t chipn, const Long_t evn)   const
 433 {
 434 // Get value of CM for a given chip and event
 435   if ((!fCm) || (chipn >= fNumberOfChips)) return 0.0f;
 436   if (evn >= fCm[chipn].GetSize()) return 0.0f;
 437   else return fCm[chipn][evn];
 438 }
 439
 440
 441 //______________________________________________________________________________
 442 Bool_t  AliITSModuleDaSSD::AllocateCMFeromArray(void)
 443 {
 444 // Allocates memory for the channels which contains CM calculated in Ferom
 445  if (!fCmFerom) {
 446     fCmFerom = new (nothrow) TArrayS [fgkChipsPerModule];
 447     if (!fCmFerom) {
 448        AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayS objects!", fgkChipsPerModule));
 449        fCmFerom = NULL;
 450        return kFALSE;
 451     }
 452   }
 453   return kTRUE;
 454 }
 455
 456
 457 //______________________________________________________________________________
 458 Bool_t  AliITSModuleDaSSD::SetCMFeromEventsNumber(const Long_t eventsnumber)
 459 {
 460 // Allocates memory for the values of CM calculated in Ferom
 461   if (!fCmFerom) return kFALSE;
 462   for (Int_t chipind = 0; chipind < fgkChipsPerModule; chipind++) {
 463       fCmFerom[chipind].Set(eventsnumber);
 464       fCmFerom[chipind].Reset(0);
 465   }
 466   return kTRUE;
 467 }
 468
 469 //______________________________________________________________________________
 470 Bool_t AliITSModuleDaSSD::SetCMFerom (const Short_t cm, const Int_t chipn, const Int_t evn)
 471 {
 472 // Set value of FeromCM for a given chip and event
 473   if ((!fCmFerom) || (chipn >= fgkChipsPerModule)) return kFALSE;
 474   if (evn >= fCmFerom[chipn].GetSize()) return kFALSE;
 475   else fCmFerom[chipn][evn] = cm;
 476   return kTRUE;
 477 }
 478
 479
 480 void  AliITSModuleDaSSD::SetCMFerom (Short_t* cm, const Int_t chipn)
 481 // Set value of FeromCM for a given chip
 482 {
 483   if (!fCmFerom)
 484     if (!AllocateCMFeromArray()) return;
 485   if (chipn < fgkChipsPerModule) fCmFerom[chipn].Set(fCmFerom[chipn].GetSize(), cm);
 486 }
 487
 488
 489 //______________________________________________________________________________
 490 Short_t  AliITSModuleDaSSD::GetCMFerom(const Int_t chipn, const Long_t evn)   const
 491 {
 492 // Get value of FeromCM for a given chip and event
 493   if ((!fCmFerom) || (chipn >= fgkChipsPerModule)) return 0;
 494   if (evn >= fCmFerom[chipn].GetSize()) return 0;
 495   else return fCmFerom[chipn][evn];
 496 }
 497