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: 14/02/2008
  24 ///////////////////////////////////////////////////////////////////////////////
  25
  26 #include <Riostream.h>
  27 #include "AliITSHandleDaSSD.h"
  28 #include <math.h>
  29 #include <limits.h>
  30 #include "event.h"
  31 #include "TFile.h"
  32 #include "TString.h"
  33 #include "TObjArray.h"
  34 #include "AliLog.h"
  35 #include "AliITSNoiseSSD.h"
  36 #include "AliITSPedestalSSD.h"
  37 #include "AliITSBadChannelsSSD.h"
  38 #include "AliITSRawStreamSSD.h"
  39 #include "AliRawReaderDate.h"
  40
  41 #include "AliITSChannelDaSSD.h"
  42
  43
  44 ClassImp(AliITSHandleDaSSD)
  45
  46 using namespace std;
  47
  48
  49 const Int_t    AliITSHandleDaSSD::fgkNumberOfSSDModules = 1698;       // Number of SSD modules in ITS
  50 const Int_t    AliITSHandleDaSSD::fgkNumberOfSSDModulesPerDdl = 108;  // Number of SSD modules in DDL
  51 const Int_t    AliITSHandleDaSSD::fgkNumberOfSSDModulesPerSlot = 12;  // Number of SSD modules in Slot
  52 const Float_t  AliITSHandleDaSSD::fgkPedestalThresholdFactor = 3.0;   // Defalt value for fPedestalThresholdFactor
  53 const Float_t  AliITSHandleDaSSD::fgkCmThresholdFactor = 3.0;         // Defalt value for fCmThresholdFactor
  54
  55 //______________________________________________________________________________
  56 AliITSHandleDaSSD::AliITSHandleDaSSD() :
  57   fRawDataFileName(NULL),
  58   fNumberOfModules(0),
  59   fModules(NULL),
  60   fModIndProcessed(0),
  61   fModIndRead(0),
  62   fModIndex(NULL),
  63   fNumberOfEvents(0),
  64   fLdcId(0),
  65   fRunId(0),
  66   fPedestalThresholdFactor(fgkPedestalThresholdFactor),
  67   fCmThresholdFactor(fgkCmThresholdFactor)
  68 {
  69 // Default constructor
  70 }
  71
  72
  73 //______________________________________________________________________________
  74 AliITSHandleDaSSD::AliITSHandleDaSSD(Char_t *rdfname) :
  75   fRawDataFileName(NULL),
  76   fNumberOfModules(0),
  77   fModules(NULL),
  78   fModIndProcessed(0),
  79   fModIndRead(0),
  80   fModIndex(NULL),
  81   fNumberOfEvents(0),
  82   fLdcId(0),
  83   fRunId(0),
  84   fPedestalThresholdFactor(fgkPedestalThresholdFactor) ,
  85   fCmThresholdFactor(fgkCmThresholdFactor)
  86 {
  87   if (!Init(rdfname)) AliError("AliITSHandleDaSSD::AliITSHandleDaSSD() initialization error!");
  88 }
  89
  90
  91 //______________________________________________________________________________
  92 AliITSHandleDaSSD::AliITSHandleDaSSD(const AliITSHandleDaSSD& ssdadldc) :
  93   TObject(ssdadldc),
  94   fRawDataFileName(ssdadldc.fRawDataFileName),
  95   fNumberOfModules(ssdadldc.fNumberOfModules),
  96   fModules(NULL),
  97   fModIndProcessed(ssdadldc.fModIndProcessed),
  98   fModIndRead(ssdadldc.fModIndRead),
  99   fModIndex(NULL),
 100   fNumberOfEvents(ssdadldc.fNumberOfEvents),
 101   fLdcId(ssdadldc.fLdcId),
 102   fRunId(ssdadldc.fRunId),
 103   fPedestalThresholdFactor(ssdadldc.fPedestalThresholdFactor),
 104   fCmThresholdFactor(ssdadldc.fCmThresholdFactor)
 105 {
 106   // copy constructor
 107   if ((ssdadldc.fNumberOfModules > 0) && (ssdadldc.fModules)) {
 108     fModules = new (nothrow) AliITSModuleDaSSD* [ssdadldc.fNumberOfModules];
 109     if (fModules) {
 110       for (Int_t modind = 0; modind < ssdadldc.fNumberOfModules; modind++) {
 111         if (ssdadldc.fModules[modind]) {
 112           fModules[modind] = new AliITSModuleDaSSD(*(ssdadldc.fModules[modind]));
 113           if (!fModules[modind]) {
 114             AliError("AliITSHandleDaSSD: Error copy constructor");
 115             for (Int_t i = (modind - 1); i >= 0; i--) delete fModules[modind];
 116             delete [] fModules;
 117             fModules = NULL;
 118             break;
 119           }
 120         } else fModules[modind] = NULL;
 121       }
 122     } else {
 123       AliError(Form("AliITSHandleDaSSD: Error allocating memory for %i AliITSModulesDaSSD* objects!", ssdadldc.fNumberOfModules));
 124       fNumberOfModules = 0;
 125       fModules = NULL;
 126     }
 127   }
 128 }
 129
 130
 131 //______________________________________________________________________________
 132 AliITSHandleDaSSD& AliITSHandleDaSSD::operator = (const AliITSHandleDaSSD& ssdadldc)
 133 {
 134 // assignment operator
 135   if (this == &ssdadldc)  return *this;
 136   if (fModules) {
 137     for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i];
 138     delete [] fModules;
 139     fModules = NULL;
 140   }
 141   if (fModIndex) { delete [] fModIndex; fModIndex = NULL; }
 142   if ((ssdadldc.fNumberOfModules > 0) && (ssdadldc.fModules)) {
 143     fModules = new (nothrow) AliITSModuleDaSSD* [ssdadldc.fNumberOfModules];
 144     if (fModules) {
 145       for (Int_t modind = 0; modind < ssdadldc.fNumberOfModules; modind++) {
 146         if (ssdadldc.fModules[modind]) {
 147           fModules[modind] = new AliITSModuleDaSSD(*(ssdadldc.fModules[modind]));
 148           if (!fModules[modind]) {
 149             AliError("AliITSHandleDaSSD: Error assignment operator");
 150             for (Int_t i = (modind - 1); i >= 0; i--) delete fModules[modind];
 151             delete [] fModules;
 152             fModules = NULL;
 153             break;
 154           }
 155         } else fModules[modind] = NULL;
 156       }
 157     } else {
 158       AliError(Form("AliITSHandleDaSSD: Error allocating memory for %i AliITSModulesDaSSD* objects!", ssdadldc.fNumberOfModules));
 159       fNumberOfModules = 0;
 160       fModules = NULL;
 161     }
 162   }
 163   return *this;
 164 }
 165
 166
 167 //______________________________________________________________________________
 168 AliITSHandleDaSSD::~AliITSHandleDaSSD()
 169 {
 170 // Default destructor
 171   if (fModules)
 172   {
 173     for (Int_t i = 0; i < fNumberOfModules; i++)
 174     {
 175       if (fModules[i]) delete fModules[i];
 176     }
 177     delete [] fModules;
 178   }
 179   if (fModIndex) delete [] fModIndex;
 180 }
 181
 182
 183
 184 //______________________________________________________________________________
 185 void AliITSHandleDaSSD::Reset()
 186 {
 187 // Delete array of AliITSModuleDaSSD* objects.
 188   if (fModules) {
 189     for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i];
 190     delete [] fModules;
 191     fModules = NULL;
 192   }
 193   if (fModIndex) { delete [] fModIndex; fModIndex = NULL; }
 194   fRawDataFileName = NULL;
 195   fModIndProcessed = fModIndRead = 0;
 196   fNumberOfEvents = 0;
 197   fLdcId = fRunId = 0;
 198   fPedestalThresholdFactor = fgkPedestalThresholdFactor;
 199   fCmThresholdFactor = fgkCmThresholdFactor;
 200 }
 201
 202
 203
 204 //______________________________________________________________________________
 205 Bool_t AliITSHandleDaSSD::Init(Char_t *rdfname, const Char_t *configfname)
 206 {
 207 // Read raw data file and set initial and configuration parameters
 208   Long_t physeventind = 0, strn = 0, nofstripsev, nofstrips = 0;
 209   Int_t  nofeqipmentev, nofeqipment = 0, eqn = 0;
 210   AliRawReaderDate  *rawreaderdate = NULL;
 211   UChar_t *data = NULL;
 212   Long_t datasize = 0, eqbelsize = 1;
 213
 214   if (configfname) ReadConfigurationFile(configfname);
 215   rawreaderdate = new AliRawReaderDate(rdfname, 0);
 216   if (!(rawreaderdate->GetAttributes() || rawreaderdate->GetEventId())) {
 217     AliError(Form("AliITSHandleDaSSD: Error reading raw data file %s by RawReaderDate", rdfname));
 218     MakeZombie();
 219     return kFALSE;
 220   }
 221   if (rawreaderdate->NextEvent()) {
 222     fRunId = rawreaderdate->GetRunNumber();
 223     rawreaderdate->RewindEvents();
 224   } else { MakeZombie(); return kFALSE; }
 225   if (fModules) Reset();
 226   rawreaderdate->SelectEvents(-1);
 227   nofstrips = 0;
 228   while (rawreaderdate->NextEvent()) {
 229     if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
 230     nofstripsev = 0;
 231     nofeqipmentev = 0;
 232     while (rawreaderdate->ReadNextData(data)) {
 233       fLdcId = rawreaderdate->GetLDCId();
 234       nofeqipmentev += 1;
 235       datasize = rawreaderdate->GetDataSize();
 236       eqbelsize = rawreaderdate->GetEquipmentElementSize();
 237       if ( (datasize % eqbelsize) || (eqbelsize != sizeof(long32)) ) {
 238         AliError(Form("AliITSHandleDaSSD: Error Init(%s): event data size %i is not an integer of equipment data size %i",
 239                                     rdfname, datasize, eqbelsize));
 240         MakeZombie();
 241         return kFALSE;
 242       }
 243       nofstripsev += (Int_t) (datasize / eqbelsize);
 244     }
 245     if (physeventind++) {
 246       if (nofstrips != nofstripsev) AliWarning("AliITSHandleDaSSD: number of strips varies from event to evnt");
 247       if (nofeqipment != nofeqipmentev) AliWarning("AliITSHandleDaSSD: number of DDLs varies from event to evnt");
 248     }
 249     nofstrips = nofstripsev;
 250     nofeqipment = nofeqipmentev;
 251     if (strn < nofstrips) strn = nofstrips;
 252     if (eqn < nofeqipment) eqn = nofeqipment;
 253   }
 254   delete rawreaderdate;
 255   if ((physeventind > 0) && (strn > 0))
 256   {
 257     fNumberOfEvents = physeventind;
 258     fRawDataFileName = rdfname;
 259     fModIndex = new (nothrow) Int_t [fgkNumberOfSSDModulesPerDdl * eqn];
 260     if (fModIndex)
 261       for (Int_t i = 0; i < fgkNumberOfSSDModulesPerDdl * eqn; i++) fModIndex[i] = -1;
 262     else AliWarning(Form("AliITSHandleDaSSD: Error Init(%s): Index array for %i modules was not created",
 263                                      rdfname, fgkNumberOfSSDModulesPerDdl * eqn));
 264     if (SetNumberOfModules(fgkNumberOfSSDModules)) {
 265       TString str = TString::Format("Max number of equipment: %i, max number of channels: %i\n", eqn, strn);
 266       DumpInitData(str.Data());
 267       return kTRUE;
 268     }
 269   }
 270   MakeZombie();
 271   return kFALSE;
 272 }
 273
 274
 275 //______________________________________________________________________________
 276 Bool_t AliITSHandleDaSSD::ReadConfigurationFile(const Char_t * /* configfname */)
 277 const {
 278 // Dowload configuration parameters from configuration file or database
 279   return kFALSE;
 280 }
 281
 282
 283
 284 //______________________________________________________________________________
 285 AliITSModuleDaSSD* AliITSHandleDaSSD::GetModule (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
 286 {
 287 // Retrieve AliITSModuleDaSSD object from the array
 288    if (!fModules) return NULL;
 289    for (Int_t i = 0; i < fNumberOfModules; i++) {
 290      if (fModules[i]) {
 291        if (    (fModules[i]->GetDdlId() == ddlID)
 292             && (fModules[i]->GetAD() == ad)
 293             && (fModules[i]->GetADC() == adc))
 294             return fModules[i];
 295      }
 296    }
 297    return NULL;
 298 }
 299
 300
 301 Int_t AliITSHandleDaSSD::GetModuleIndex (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
 302 {
 303 // Retrieve the position of AliITSModuleDaSSD object in the array
 304    if (!fModules) return -1;
 305    for (Int_t i = 0; i < fNumberOfModules; i++) {
 306      if (fModules[i]) {
 307        if (    (fModules[i]->GetDdlId() == ddlID)
 308             && (fModules[i]->GetAD() == ad)
 309             && (fModules[i]->GetADC() == adc))
 310             return i;
 311      }
 312    }
 313    return -1;
 314 }
 315
 316
 317
 318 //______________________________________________________________________________
 319 AliITSChannelDaSSD* AliITSHandleDaSSD::GetStrip (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t stripID) const
 320 {
 321 // Retrieve AliITSChannalDaSSD object from the array
 322   for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
 323     if (    (fModules[modind]->GetDdlId() == ddlID)
 324          && (fModules[modind]->GetAD() == ad)
 325          && (fModules[modind]->GetADC() == adc)  )
 326         {
 327        return fModules[modind]->GetStrip(stripID);
 328     }
 329   }
 330   AliError(Form("AliITSHandleDaSSD: Error GetStrip (%i, %i, %i, %i), strip not found, returns NULL!",
 331                 ddlID, ad, adc, stripID));
 332   return NULL;
 333 }
 334
 335
 336
 337 //______________________________________________________________________________
 338 Bool_t AliITSHandleDaSSD::SetModule(AliITSModuleDaSSD *const module, const Int_t index)
 339 {
 340 // Assign array element with AliITSModuleDaSSD object
 341    if ((index < fNumberOfModules) && (index >= 0))
 342      {
 343         if (fModules[index]) delete fModules[index];
 344         fModules[index] = module;
 345         return kTRUE;
 346       }
 347    else return kFALSE;
 348 }
 349
 350
 351
 352 //______________________________________________________________________________
 353 Bool_t AliITSHandleDaSSD::SetNumberOfModules (const Int_t numberofmodules)
 354 {
 355 // Allocates memory for AliITSModuleDaSSD objects
 356   if (numberofmodules > fgkNumberOfSSDModules)
 357     AliWarning(Form("AliITSHandleDaSSD: the number of modules %i you use exceeds the maximum %i for ALICE ITS SSD",
 358                      numberofmodules, fgkNumberOfSSDModules));
 359   if (fModules) {
 360     for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i];
 361     delete [] fModules;
 362     fModules = NULL;
 363   }
 364   fModules = new (nothrow) AliITSModuleDaSSD* [numberofmodules];
 365   if (fModules) {
 366     fNumberOfModules = numberofmodules;
 367     memset(fModules, 0, sizeof(AliITSModuleDaSSD*) * numberofmodules);
 368     return kTRUE;
 369   } else {
 370      AliError(Form("AliITSHandleDaSSD: Error allocating memory for %i AliITSModulesDaSSD* objects!", numberofmodules));
 371      fNumberOfModules = 0;
 372      fModules = NULL;
 373   }
 374   return kFALSE;
 375 }
 376
 377
 378
 379 //______________________________________________________________________________
 380 Bool_t AliITSHandleDaSSD::ReadCalibrationDataFile (char* fileName, const Long_t eventsnumber)
 381 {
 382 // Reads raw data from file
 383   AliRawReaderDate    *rawreaderdate = NULL;
 384   AliITSModuleDaSSD   *module;
 385   AliITSChannelDaSSD  *strip;
 386   Long_t            datasize, eventind = 0;
 387   Int_t             nofstrips, eqbelsize;
 388   UShort_t          modind;
 389   long32           *data;
 390   UChar_t          *databyte;
 391   if (!Init(fileName)){
 392     AliError("AliITSHandleDaSSD: Error ReadCalibrationDataFile");
 393     return kFALSE;
 394   }
 395   rawreaderdate = new AliRawReaderDate(fileName, 0);
 396   rawreaderdate->SelectEvents(-1);
 397   while (rawreaderdate->NextEvent()) {
 398     if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
 399     fRunId = rawreaderdate->GetRunNumber();
 400     modind = 0;
 401     while (rawreaderdate->ReadNextData(databyte)) {
 402       fLdcId = rawreaderdate->GetLDCId();
 403       data = reinterpret_cast<long32*>(databyte);
 404       Int_t     equipid    = rawreaderdate->GetEquipmentId();              //  EquipmentID required to access to rorc
 405       Int_t     equiptype  = rawreaderdate->GetEquipmentType();            //
 406       UChar_t   ddlID      = (UChar_t)rawreaderdate->GetDDLID();           // GetDDLID(); index of DDL, ITS SSD: 33-48
 407       datasize = rawreaderdate->GetDataSize();
 408       eqbelsize = rawreaderdate->GetEquipmentElementSize();
 409       if ( (datasize % eqbelsize) || (eqbelsize != sizeof(long32)) ) {
 410         AliError(Form("AliITSHandleDaSSD: Error ReadCalibrationDataFile: event data size %i is not an integer of equipment data size %i",
 411                       datasize, eqbelsize));
 412         return kFALSE;
 413       }
 414       nofstrips = (Int_t) (datasize / eqbelsize);
 415       for (Int_t strind = 0; strind < nofstrips; strind++) {
 416         UChar_t   ad      = (UChar_t) (data[strind] >> 28) & 0x0000000F;  // index of AD module     0-9
 417         UChar_t   adc     = (UChar_t) (data[strind] >> 24) & 0x0000000F;  // index of ADC module    0-5, 8-13
 418         UShort_t  stripID = (UShort_t)(data[strind] >> 12) & 0x000007FF;  // strip number           0-1535
 419         Short_t   signal  = (Short_t)(data[strind] & 0x00000FFF);
 420                   signal  = (signal > AliITSChannelDaSSD::GetUnderflowConst()) ? (signal - 2 * AliITSChannelDaSSD::GetUnderflowConst())
 421                                                                                : signal;
 422         if (!(module = GetModule(ddlID, ad, adc))) {
 423           module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst());
 424           if (!module->SetModuleIdData (ddlID, ad, adc, RetrieveModuleId(ddlID, ad, adc))) return kFALSE;
 425           module->SetModuleRorcId (equipid, equiptype);
 426           fModules[modind++] = module;
 427         }
 428         if (!(strip = module->GetStrip(stripID))) {
 429           strip = new AliITSChannelDaSSD(stripID, eventsnumber);
 430           module->SetStrip(strip, stripID);
 431         }
 432         strip->SetSignal(eventind, signal);
 433      }
 434      if (modind) cout << "The memory was allocated for " <<  modind << " modules." << endl;
 435    }
 436    if (++eventind > eventsnumber) break;
 437   }
 438   delete rawreaderdate;
 439   return RelocateModules();
 440 }
 441
 442
 443
 444 //______________________________________________________________________________
 445 Int_t AliITSHandleDaSSD::ReadModuleRawData (const Int_t modulesnumber)
 446 {
 447 // Reads raw data from file
 448   AliRawReaderDate    *rawreaderdate = NULL;
 449   AliITSModuleDaSSD   *module;
 450   AliITSChannelDaSSD  *strip;
 451   Long_t            datasize, eventind = 0;
 452   Int_t             nofstrips, eqbelsize, nofeqipmentev;
 453   UShort_t          modind;
 454   long32           *data;
 455   UChar_t          *databyte;
 456   if (!(rawreaderdate = new AliRawReaderDate(fRawDataFileName, 0))) return 0;
 457   if (!fModules) {
 458     AliError("AliITSHandleDaSSD: Error ReadModuleRawData: no structure was allocated for data");
 459     return 0;
 460   }
 461   rawreaderdate->SelectEvents(-1);
 462   modind = 0;
 463   while (rawreaderdate->NextEvent()) {
 464     if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
 465     nofeqipmentev = 0;
 466     while (rawreaderdate->ReadNextData(databyte)) {
 467       data = reinterpret_cast<long32*>(databyte);
 468       Int_t     equipid    = rawreaderdate->GetEquipmentId();              //  EquipmentID required to access to rorc
 469       Int_t     equiptype  = rawreaderdate->GetEquipmentType();            //
 470       UChar_t   ddlID      = (UChar_t)rawreaderdate->GetDDLID();           // GetDDLID(); index of DDL, ITS SSD: 33-48
 471       datasize = rawreaderdate->GetDataSize();
 472       eqbelsize = rawreaderdate->GetEquipmentElementSize();
 473       if ( (datasize % eqbelsize) || (eqbelsize != sizeof(long32)) ) {
 474         AliError(Form("AliITSHandleDaSSD: Error ReadCalibrationDataFile: event data size %i is not an integer of equipment data size %i",
 475                        datasize, eqbelsize));
 476         return kFALSE;
 477       }
 478       nofstrips = (Int_t) (datasize / eqbelsize);
 479       for (Int_t strind = 0; strind < nofstrips; strind++) {
 480         UChar_t   ad      = (UChar_t) (data[strind] >> 28) & 0x0000000F;  // index of AD module     0-9
 481         UChar_t   adc     = (UChar_t) (data[strind] >> 24) & 0x0000000F;  // index of ADC module    0-5, 8-13
 482         UShort_t  stripID = (UShort_t)(data[strind] >> 12) & 0x000007FF;  // strip number           0-1535
 483         Short_t   signal  = (Short_t)(data[strind] & 0x00000FFF);
 484                   signal  = (signal > AliITSChannelDaSSD::GetUnderflowConst()) ? (signal - 2 * AliITSChannelDaSSD::GetUnderflowConst())
 485                                                                                : signal;
 486
 487         Int_t indpos = (nofeqipmentev * fgkNumberOfSSDModulesPerDdl)
 488                         + ((ad - 1) * fgkNumberOfSSDModulesPerSlot) + (adc < 6 ? adc : (adc - 2));
 489         Int_t modpos = fModIndex[indpos];
 490         if (((modpos > 0) && (modpos < fModIndRead)) || ((modpos < 0) && (modind == modulesnumber))) continue;
 491         if ((modpos < 0) && (modind < modulesnumber)) {
 492           module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst());
 493           if (!module->SetModuleIdData (ddlID, ad, adc, RetrieveModuleId(ddlID, ad, adc))) return 0;
 494           module->SetModuleRorcId (equipid, equiptype);
 495           modpos = fModIndRead + modind;
 496           modind += 1;
 497           fModules[modpos] = module;
 498           fModIndex[indpos] = modpos;
 499         }
 500         if (!(strip = fModules[modpos]->GetStrip(stripID))) {
 501           strip = new AliITSChannelDaSSD(stripID, fNumberOfEvents);
 502           fModules[modpos]->SetStrip(strip, stripID);
 503         }
 504         strip->SetSignal(eventind, signal);
 505       }
 506       nofeqipmentev += 1;
 507     }
 508     if (++eventind > fNumberOfEvents) break;
 509   }
 510   delete rawreaderdate;
 511   if (modind) cout << "The memory was allocated for " <<  modind << " modules." << endl;
 512   fModIndRead += modind;
 513   if (modind < modulesnumber) RelocateModules();
 514   return modind;
 515 }
 516
 517
 518
 519 //______________________________________________________________________________
 520 Bool_t AliITSHandleDaSSD::RelocateModules()
 521 {
 522 // Relocate memory for AliITSModuleDaSSD object array
 523   Int_t         nm = 0;
 524   AliITSModuleDaSSD **marray = NULL;
 525   for (Int_t modind = 0; modind < fNumberOfModules; modind++)
 526     if (fModules[modind]) nm += 1;
 527   if (nm == fNumberOfModules) return kTRUE;
 528   marray = new (nothrow) AliITSModuleDaSSD* [nm];
 529   if (!marray) {
 530     AliError(Form("AliITSHandleDaSSD: Error relocating memory for %i AliITSModuleDaSSD* objects!", nm));
 531     return kFALSE;
 532   }
 533   nm = 0;
 534   for (Int_t modind = 0; modind < fNumberOfModules; modind++)
 535     if (fModules[modind]) marray[nm++] = fModules[modind];
 536   delete [] fModules;
 537   fModules = marray;
 538   fNumberOfModules = fModIndRead = nm;
 539   return kTRUE;
 540 }
 541
 542
 543
 544 //______________________________________________________________________________
 545 Bool_t AliITSHandleDaSSD::CalculatePedestal(AliITSModuleDaSSD *const module)
 546 {
 547 // Calculates Pedestal
 548   AliITSChannelDaSSD *strip;
 549   Float_t             pedestal, noise;
 550   Short_t            *signal;
 551   Long_t              ovev, ev, n;
 552   if (!module) return kFALSE;
 553   for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
 554     if (!(strip = module->GetStrip(strind))) continue;
 555     if (!(signal = strip->GetSignal())) {
 556       AliError(Form("AliITSHandleDaSSD: Error CalculatePedestal(): there are no events data for module[%i] strip[%i]->GetSignal()",
 557                      module->GetModuleId(), strind));
 558       continue;
 559     }
 560 //************* pedestal first pass ****************
 561     pedestal = 0.0f;
 562     ovev = 0l;
 563     for (ev = 0; ev < strip->GetEventsNumber(); ev++)
 564       if (SignalOutOfRange(signal[ev])) ovev += 1;
 565       else pedestal = ((ev - ovev)) ? pedestal + (signal[ev] - pedestal) / static_cast<Float_t>(ev - ovev + 1) : signal[ev];
 566     if (ev == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
 567     strip->SetPedestal(pedestal);
 568 //************* noise *******************************
 569     Double_t nsum = 0.0L;
 570     ovev = 0l;
 571     for (ev = 0; ev < strip->GetEventsNumber(); ev++) {
 572       if (SignalOutOfRange(signal[ev])) ovev += 1;
 573       else nsum += pow((signal[ev] - strip->GetPedestal()), 2);
 574     }
 575     if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise =  sqrt(nsum / (Float_t)(n));
 576     else  noise = AliITSChannelDaSSD::GetUndefinedValue();
 577     strip->SetNoise(noise);
 578 //************* pedestal second pass ****************
 579     pedestal = 0.0f;
 580     ovev = 0l;
 581     for (ev = 0; ev < strip->GetEventsNumber(); ev++)
 582       if (   SignalOutOfRange(signal[ev])
 583           || TMath::Abs(signal[ev] - strip->GetPedestal()) > (fPedestalThresholdFactor * strip->GetNoise())) ovev += 1;
 584       else pedestal = ((ev - ovev)) ? pedestal + (signal[ev] - pedestal) / static_cast<Float_t>(ev - ovev + 1) : signal[ev];
 585     if (ev == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
 586     strip->SetPedestal(pedestal);
 587     strip->SetOverflowNumber(ovev);
 588   }
 589   return kTRUE;
 590 }
 591
 592
 593 //______________________________________________________________________________
 594 Bool_t AliITSHandleDaSSD::CalculateNoise(AliITSModuleDaSSD *const module)
 595 {
 596 // Calculates Noise
 597   AliITSChannelDaSSD *strip;
 598   Short_t    *signal;
 599   Float_t     noise;
 600   Long_t      ovev, n;
 601   if (!module) return kFALSE;
 602   for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
 603     if (!(strip = module->GetStrip(strind))) continue;
 604     if (!(signal = strip->GetSignal())) {
 605       strip->SetNoise(AliITSChannelDaSSD::GetUndefinedValue());
 606       AliError(Form("AliITSHandleDaSSD: Error CalculateNoise(): there are no events data for module[%i] strip[%i]->GetSignal()",
 607                      module->GetModuleId(), strind));
 608       continue;
 609     }
 610     Double_t nsum = 0.0L;
 611     ovev = 0l;
 612     for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
 613       if (SignalOutOfRange(signal[ev])) ovev += 1;
 614       else nsum += pow((signal[ev] - strip->GetPedestal()), 2);
 615     }
 616     if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise =  sqrt(nsum / (Float_t)(n));
 617     else  noise = AliITSChannelDaSSD::GetUndefinedValue();
 618     strip->SetNoise(noise);
 619   }
 620   return kTRUE;
 621 }
 622
 623
 624
 625 //______________________________________________________________________________
 626 Bool_t AliITSHandleDaSSD::CalculateNoiseCM(AliITSModuleDaSSD *const module)
 627 {
 628 // Calculates Noise with CM correction
 629   AliITSChannelDaSSD  *strip = NULL;
 630   Short_t     *signal;
 631   Float_t      noise;
 632   Long_t       ovev, n;
 633   if (!CalculateCM(module)) {
 634     AliError("Error: AliITSHandleDaSSD::CalculateCM() returned kFALSE");
 635     return kFALSE;
 636   }
 637   for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
 638     if (!(strip = module->GetStrip(strind))) continue; //return kFALSE;
 639     if (!(signal = strip->GetSignal())) {
 640       strip->SetNoiseCM(AliITSChannelDaSSD::GetUndefinedValue());
 641       AliError(Form("SSDDAModule: Error CalculateNoiseWithoutCM(): there are no events data for module[%i] strip[%i]->GetSignal()",
 642                      module->GetModuleId(), strind));
 643       continue; //return kFALSE;
 644     }
 645     Int_t chipind = strind / AliITSModuleDaSSD::GetStripsPerChip();
 646     Double_t nsum = 0.0L;
 647     ovev = 0l;
 648     for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
 649       if (SignalOutOfRange(signal[ev])) ovev += 1;
 650       else nsum += pow((signal[ev] - strip->GetPedestal() - module->GetCM(chipind, ev)), 2);
 651     }
 652     if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise =  sqrt(nsum / (Float_t)(n));
 653     else  noise = AliITSChannelDaSSD::GetUndefinedValue();
 654     strip->SetNoiseCM(noise);
 655   }
 656   return kTRUE;
 657 }
 658
 659
 660
 661 //______________________________________________________________________________
 662 Bool_t AliITSHandleDaSSD::CalculateCM(AliITSModuleDaSSD *const module)
 663 {
 664 // Calculates CM
 665   AliITSChannelDaSSD  *strip = NULL;
 666   Short_t             *signal;
 667   Long_t               ovstr, n;
 668   Int_t                stripind;
 669   module->SetNumberOfChips(AliITSModuleDaSSD::GetChipsPerModuleConst());
 670   for (Int_t chipind = 0; chipind < module->GetNumberOfChips(); chipind++) {
 671     stripind = chipind * module->GetStripsPerChip();
 672     module->GetCm()[chipind].Set(fNumberOfEvents);
 673     module->GetCm()[chipind].Reset(0.0f);
 674     for (Long_t ev = 0; ev < fNumberOfEvents; ev++) {
 675     // calculate firs approximation of CM.
 676       Double_t cm0 = 0.0L;
 677       ovstr = 0l;
 678       for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
 679         if (!(strip = module->GetStrip(strind))) continue; //return kFALSE;
 680         if (!(signal = strip->GetSignal())) {
 681           AliError(Form("AliITSHandleDaSSD: Error CalculateCM: there are no events data for module[%i] strip[%i]->GetSignal()",
 682                         module->GetModuleId(), strind));
 683           return kFALSE;
 684         }
 685         if ((signal[ev] >= AliITSChannelDaSSD::GetOverflowConst()) ||
 686             (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())) ovstr += 1;
 687         else cm0 += (signal[ev] - strip->GetPedestal());
 688       }
 689       if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cm0 /= (Float_t)(n);
 690       else { module->SetCM(0.0f, chipind, ev); continue; }
 691     // calculate avarage (cm - (signal - pedestal)) over the chip
 692       Double_t cmsigma = 0.0L;
 693       ovstr = 0l;
 694       for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
 695         if (!(strip = module->GetStrip(strind))) continue;
 696         if (!(signal = strip->GetSignal())) {
 697           AliError(Form("AliITSHandleDaSSD: Error CalculateCM: there are no events data for module[%i] strip[%i]->GetSignal()\n",
 698                          module->GetModuleId(), strind));
 699           return kFALSE;
 700         }
 701         if ((signal[ev] >= AliITSChannelDaSSD::GetOverflowConst()) ||
 702             (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())) ovstr += 1;
 703         else cmsigma += pow((cm0 - (signal[ev] - strip->GetPedestal())), 2);
 704       }
 705       if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cmsigma = sqrt(cmsigma / (Float_t)(n));
 706       else { module->SetCM(0.0f, chipind, ev); continue; }
 707    // calculate cm with threshold
 708       Double_t cmsum = 0.0L;
 709       ovstr = 0l;
 710       for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
 711         if (!(strip = module->GetStrip(strind))) continue;
 712         signal = strip->GetSignal();
 713         if (   (signal[ev] >= AliITSChannelDaSSD::GetOverflowConst())
 714             || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())
 715             || (TMath::Abs(cm0 - (signal[ev] - strip->GetPedestal())) > (fCmThresholdFactor * cmsigma)) ) ovstr += 1;
 716         else cmsum += (signal[ev] - strip->GetPedestal());
 717       }
 718       if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cmsum /= (Float_t)(n);
 719       else cmsum = 0.0L;
 720       if (!module->SetCM(cmsum, chipind, ev));
 721     }
 722   }
 723   return kTRUE;
 724 }
 725
 726
 727 //______________________________________________________________________________
 728 Bool_t AliITSHandleDaSSD::ProcessRawData(const Int_t nmread)
 729 {
 730 // Performs calculation of calibration parameters (pedestal, noise, ...)
 731   Int_t nm = 0;
 732   if (nmread <= 0) return kFALSE;
 733   if (!fModules) return kFALSE;
 734   while ((nm = ReadModuleRawData(nmread)) > 0) {
 735     cout << "Processing next " << nm << " modules;" << endl;
 736     for (Int_t modind = fModIndProcessed; modind < fModIndRead; modind++) {
 737       if (!fModules[modind]) {
 738         AliError(Form("AliITSHandleDaSSD: Error ProcessRawData(): No AliITSModuleDaSSD object with index %i is allocated in AliITSHandleDaSSD\n",
 739                        modind));
 740         return kFALSE;
 741       }
 742       CalculatePedestal(fModules[modind]);
 743       CalculateNoise(fModules[modind]);
 744       CalculateNoiseCM(fModules[modind]);
 745     }
 746     DeleteSignal();
 747 //    DeleteCM();
 748     fModIndProcessed = fModIndRead;
 749     cout << fModIndProcessed << " - done" << endl;
 750   }
 751   return kTRUE;
 752 }
 753
 754
 755 //______________________________________________________________________________
 756 Short_t AliITSHandleDaSSD::RetrieveModuleId(const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
 757 {
 758 // Retrieve ModuleId from the DDL map which is defined in AliITSRawStreamSSD class
 759   Int_t mddli = (ad - 1) * 12 + ((adc<6) ? adc : (adc-2));
 760   if ((ddlID < AliITSRawStreamSSD::kDDLsNumber) && (mddli < AliITSRawStreamSSD::kModulesPerDDL)) {
 761     mddli = AliITSRawStreamSSD::GetModuleNumber(ddlID, mddli);
 762     if (mddli > SHRT_MAX) return SHRT_MAX;
 763     else return (Short_t)mddli;
 764   }
 765   else {
 766     AliWarning(Form("Module index  = %d or ddlID = %d is out of range -1 is rturned", ddlID, mddli));
 767     return -1;
 768   }
 769 }
 770
 771
 772
 773 //______________________________________________________________________________
 774 TObjArray* AliITSHandleDaSSD::GetCalibrationSSDLDC() const
 775 {
 776 // Fill in the array for OCDB
 777   TObjArray *ldcc;
 778   TObject   *modcalibobj;
 779   if (!fModules) return NULL;
 780   ldcc = new TObjArray(fNumberOfModules, 0);
 781   for (Int_t i = 0; i < fNumberOfModules; i++) {
 782     if (!fModules[i]) {
 783       delete ldcc;
 784       return NULL;
 785     }
 786     modcalibobj = dynamic_cast<TObject*>(fModules[i]->GetCalibrationNoise());
 787     ldcc->AddAt(modcalibobj, i);
 788   }
 789   ldcc->Compress();
 790   return ldcc;
 791 }
 792
 793
 794 //______________________________________________________________________________
 795 Bool_t AliITSHandleDaSSD::SaveCalibrationSSDLDC(Char_t*& dafname) const
 796 {
 797 // Save Calibration data locally
 798   TObjArray      *ldcn, *ldcp, *ldcbc;
 799   TObject        *modobjn, *modobjp, *modobjbc;
 800   Char_t         *tmpfname;
 801   TString         dadatafilename("");
 802   if (!fModules) return kFALSE;
 803   ldcn = new TObjArray(fNumberOfModules, 0);
 804   ldcn->SetName("Noise");
 805   ldcp = new TObjArray(fNumberOfModules, 0);
 806   ldcp->SetName("Pedestal");
 807   ldcbc = new TObjArray(fNumberOfModules, 0);
 808   ldcbc->SetName("BadChannels");
 809   for (Int_t i = 0; i < fNumberOfModules; i++) {
 810     if (!fModules[i]) {
 811       delete ldcn;
 812       return kFALSE;
 813     }
 814     modobjn = dynamic_cast<TObject*>(fModules[i]->GetCalibrationNoise());
 815     modobjp = dynamic_cast<TObject*>(fModules[i]->GetCalibrationPedestal());
 816     modobjbc = dynamic_cast<TObject*>(fModules[i]->GetCalibrationBadChannels());
 817     ldcn->AddAt(modobjn, i);
 818     ldcp->AddAt(modobjp, i);
 819     ldcbc->AddAt(modobjbc, i);
 820   }
 821   ldcn->Compress();
 822   ldcp->Compress();
 823   ldcbc->Compress();
 824   if (dafname) dadatafilename.Form("%s/", dafname);
 825   dadatafilename += TString::Format("ITSSSDda_%i_%i.root", fLdcId, fRunId);
 826   tmpfname = new Char_t[dadatafilename.Length()+1];
 827   dafname = strcpy(tmpfname, dadatafilename.Data());
 828   TFile *fileRun = new TFile (dadatafilename.Data(),"RECREATE");
 829   if (fileRun->IsZombie()) {
 830     AliError(Form("AliITSHandleDaSSD: SaveCalibrationSSDLDC() error open file %s", dadatafilename.Data()));
 831     ldcn->Delete();
 832     delete fileRun;
 833     delete ldcn;
 834     delete ldcp;
 835     delete ldcbc;
 836     return kFALSE;
 837   }
 838   fileRun->WriteTObject(ldcn);
 839   fileRun->WriteTObject(ldcp);
 840   fileRun->WriteTObject(ldcbc);
 841   fileRun->Close();
 842   ldcn->Delete();
 843   delete fileRun;
 844   delete ldcn;
 845   delete ldcp;
 846   delete ldcbc;
 847   return kTRUE;
 848 }
 849
 850
 851
 852 //______________________________________________________________________________
 853 Bool_t AliITSHandleDaSSD::DumpModInfo(const Float_t meannosethreshold) const
 854 {
 855 // Dump calibration parameters
 856   AliITSModuleDaSSD    *mod;
 857   AliITSChannelDaSSD   *strip;
 858   if (!fModules) {
 859     cout << "SSDDALDC::DumpModInfo():  Error, no modules are allocated!" << endl;
 860     return kFALSE;
 861   }
 862   cout << "Modules with MeanNoise > " << meannosethreshold << endl;
 863   for (Int_t i = 0; i < fNumberOfModules; i++) {
 864     if (!(mod = fModules[i])) continue;
 865     Float_t  maxnoise = 0.0f, meannoise = 0.0f;
 866     Int_t    maxstrind = 0, novfstr = 0;
 867     for (Int_t strind = 0; strind < mod->GetNumberOfStrips(); strind++) {
 868       if (!(strip = mod->GetStrip(strind))) {novfstr++;  continue; }
 869       if (strip->GetNoiseCM() >= AliITSChannelDaSSD::GetUndefinedValue() ) {novfstr++;  continue; }
 870       if (maxnoise < strip->GetNoiseCM()) {
 871         maxnoise = strip->GetNoiseCM();
 872         maxstrind = strind;
 873       }
 874       meannoise = (strind - novfstr) ? meannoise + (strip->GetNoiseCM() - meannoise) / static_cast<Float_t>(strind - novfstr + 1)
 875                                     : strip->GetNoiseCM();
 876     }
 877     if (meannoise > meannosethreshold)
 878       cout << "Mod: " << i << ";  DDl: " << (int)mod->GetDdlId() << ";  AD: " << (int)mod->GetAD()
 879                            << ";  ADC: " << (int)mod->GetADC() << ";  MeanNoise = " << meannoise
 880                            << ";  NOfStrips = " << (mod->GetNumberOfStrips() - novfstr) << endl;
 881   }
 882   return kTRUE;
 883 }
 884
 885
 886
 887 //______________________________________________________________________________
 888 Bool_t AliITSHandleDaSSD::PrintModCalibrationData(const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const Char_t *fname) const
 889 {
 890 // Print Module calibration data whether in file on in cout
 891    AliITSChannelDaSSD  *strip;
 892    ofstream             datafile;
 893    ostream             *outputfile;
 894    if (!fname) { outputfile = &cout; }
 895    else {
 896      datafile.open(fname, ios::out);
 897      if  (datafile.fail()) return kFALSE;
 898      outputfile = dynamic_cast<ostream*>(&datafile);
 899    }
 900    *outputfile  << "DDL = " << (int)ddlID << ";  AD = " << (int)ad << ";  ADC = " << (int)adc << endl;
 901    for (Int_t strind = 0; strind < AliITSModuleDaSSD::GetStripsPerModuleConst(); strind++) {
 902      if ( (strip = GetStrip(ddlID, ad, adc, strind)) ) {
 903        *outputfile << "Str = " << strind << ";  ped = " << strip->GetPedestal()
 904                    << ";  noise = " << strip->GetNoiseCM() << endl;
 905      }
 906      else continue;
 907    }
 908   if (datafile.is_open()) datafile.close();
 909   return kTRUE;
 910 }
 911
 912
 913
 914 void AliITSHandleDaSSD::DumpInitData(const Char_t *str) const
 915 {
 916 // Print general information retrieve from raw data file
 917   cout << "Raw data file: " << fRawDataFileName << endl
 918        << "LDC: " << (Int_t)fLdcId << "; RunId: " << fRunId << endl
 919        << "Number of physics events: " << fNumberOfEvents << endl
 920        << str;
 921 }
 922
 923
 924 //______________________________________________________________________________
 925 Bool_t AliITSHandleDaSSD::AllocateSimulatedModules(const Int_t copymodind)
 926 {
 927 // Used to allocate simulated modules to test the performance
 928   AliITSModuleDaSSD *module;
 929   UChar_t      ad, adc, ddlID;
 930   ad = adc = ddlID = 0;
 931   if (!(fModules[copymodind])) return kFALSE;
 932   for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
 933     if (!fModules[modind]) {
 934       module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst());
 935       if ((adc < 5) || ((adc > 7) && (adc < 13)) ) adc += 1;
 936       else if (adc == 5) adc = 8;
 937       else if (adc == 13) {
 938         adc = 0;
 939         if (ad < 8) ad += 1;
 940         else {
 941           ad = 0;
 942           ddlID +=1;
 943         }
 944       }
 945       if (!module->SetModuleIdData (ddlID, ad, adc, modind)) return kFALSE;
 946       fModules[modind] = module;
 947       for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
 948         AliITSChannelDaSSD *cstrip = fModules[copymodind]->GetStrip(strind);
 949         Long_t      eventsnumber = cstrip->GetEventsNumber();
 950         AliITSChannelDaSSD *strip = new AliITSChannelDaSSD(strind, eventsnumber);
 951         for (Long_t evind = 0; evind < eventsnumber; evind++) {
 952           Short_t sign = *cstrip->GetSignal(evind);
 953           if (!strip->SetSignal(evind, sign)) AliError(Form("AliITSHandleDaSSD: Copy events error! mod = %i, str = %i", modind, strind));
 954         }
 955         module->SetStrip(strip, strind);
 956       }
 957     }
 958     else {
 959       ddlID = fModules[modind]->GetDdlId();
 960       ad    = fModules[modind]->GetAD();
 961       adc   = fModules[modind]->GetADC();
 962     }
 963   }
 964   for (UShort_t modind = 0; modind < fNumberOfModules; modind++) fModules[modind]->SetModuleId(modind + 1080);
 965   return kTRUE;
 966 }