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 ///////////////////////////////////////////////////////////////////////////////
  24
  25 #include "AliITSNoiseSSD.h"
  26 #include "AliITSModuleDaSSD.h"
  27
  28 ClassImp(AliITSModuleDaSSD)
  29
  30 using namespace std;
  31
  32 AliITSModuleDaSSD::AliITSModuleDaSSD() :
  33   fEquipId(0),
  34   fEquipType(0),
  35   fDdlId(0),
  36   fAd(0),
  37   fAdc(0),
  38   fModuleId(0),
  39   fNumberOfStrips(0),
  40   fStrips(NULL),
  41   fEventsNumber(0)
  42 {
  43 // Default constructor
  44 }
  45
  46
  47 AliITSModuleDaSSD::AliITSModuleDaSSD(const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t moduleID) :
  48   fEquipId(0),
  49   fEquipType(0),
  50   fDdlId(ddlID),
  51   fAd(ad),
  52   fAdc(adc),
  53   fModuleId(moduleID),
  54   fNumberOfStrips(0),
  55   fStrips(NULL),
  56   fEventsNumber(0)
  57 {
  58 // Constructor, set module id data
  59 }
  60
  61
  62
  63 AliITSModuleDaSSD::AliITSModuleDaSSD(const Int_t numberofstrips) :
  64   fEquipId(0),
  65   fEquipType(0),
  66   fDdlId(0),
  67   fAd(0),
  68   fAdc(0),
  69   fModuleId(0),
  70   fNumberOfStrips(0),
  71   fStrips(NULL),
  72   fEventsNumber(0)
  73 {
  74 // Constructor, allocates memory for AliITSChannelDaSSD*
  75   if (numberofstrips != fgkStripsPerModule)
  76     Warning("AliITSModuleDaSSD", "ALICE ITS SSD Module contains %i strips", fgkStripsPerModule);
  77   fStrips = new (nothrow) AliITSChannelDaSSD* [numberofstrips];
  78   if (fStrips) {
  79      fNumberOfStrips = numberofstrips;
  80      for (Int_t i = 0; i < numberofstrips; i++) fStrips[i]= NULL;
  81   } else {
  82      Error("AliITSModuleDaSSD", "Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips);
  83      fNumberOfStrips = 0;
  84      fStrips = NULL;
  85   }
  86 }
  87
  88
  89 AliITSModuleDaSSD::AliITSModuleDaSSD(const Int_t numberofstrips, const Long_t eventsnumber) :
  90   fEquipId(0),
  91   fEquipType(0),
  92   fDdlId(0),
  93   fAd(0),
  94   fAdc(0),
  95   fModuleId(0),
  96   fNumberOfStrips(0),
  97   fStrips(NULL),
  98   fEventsNumber(0)
  99 {
 100 // Constructor, allocates memory for AliITSChannelDaSSD* and events data
 101   if (numberofstrips != fgkStripsPerModule)
 102     Warning("AliITSModuleDaSSD", "ALICE ITS SSD Module contains %i strips", fgkStripsPerModule);
 103   fStrips = new (nothrow) AliITSChannelDaSSD* [numberofstrips];
 104   if (fStrips) {
 105      fNumberOfStrips = numberofstrips;
 106      memset(fStrips, 0, numberofstrips * sizeof(AliITSChannelDaSSD*));
 107      for (Int_t i = 0; i < fNumberOfStrips; i++) {
 108        fStrips[i] = new AliITSChannelDaSSD(i, eventsnumber);
 109        if (!fStrips[i]) Error("AliITSModuleDaSSD", "Error allocating memory for AliITSChannelDaSSD %i-th object", i);
 110      }
 111   } else {
 112      Error("AliITSModuleDaSSD", "Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips);
 113      fNumberOfStrips = 0;
 114      fStrips = NULL;
 115   }
 116 }
 117
 118
 119
 120 AliITSModuleDaSSD::AliITSModuleDaSSD(const AliITSModuleDaSSD& module) :
 121   TObject(module),
 122   fEquipId(module.fEquipId),
 123   fEquipType(module.fEquipType),
 124   fDdlId(module.fDdlId),
 125   fAd(module.fAd),
 126   fAdc(module.fAdc),
 127   fModuleId(module.fModuleId),
 128   fNumberOfStrips(module.fNumberOfStrips),
 129   fStrips(module.fStrips),
 130   fEventsNumber(module.fEventsNumber)
 131 {
 132 // copy constructor
 133
 134   Fatal("AliITSModuleDaSSD", "copy constructor not implemented");
 135 }
 136
 137
 138
 139 AliITSModuleDaSSD& AliITSModuleDaSSD::operator = (const AliITSModuleDaSSD& module)
 140 {
 141 // assignment operator
 142
 143   Fatal("AliITSModuleDaSSD: operator =", "assignment operator not implemented");
 144   return *this;
 145 }
 146
 147
 148
 149 AliITSModuleDaSSD::~AliITSModuleDaSSD()
 150 {
 151 // Destructor
 152   if (fStrips)
 153   {
 154     for (Long_t i = 0; i < fNumberOfStrips; i++)
 155     {
 156       if (fStrips[i]) delete fStrips[i];
 157     }
 158     delete [] fStrips;
 159   }
 160 }
 161
 162
 163
 164 Bool_t AliITSModuleDaSSD::SetModuleIdData (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t moduleID)
 165 {
 166 // SetModuleIdData
 167   if (ad > fgkMaxAdNumber) {
 168     Warning("AliITSModuleDaSSD", "Wrong AD number: %i", ad);
 169     return kFALSE;
 170   }
 171   if (adc > fgkMaxAdcNumber || ForbiddenAdcNumber(adc)) {
 172     Warning("AliITSModuleDaSSD", "Wrong ADC number: %i", adc);
 173     return kFALSE;
 174   }
 175   fDdlId = ddlID;
 176   fAd = ad;
 177   fAdc = adc;
 178   fModuleId = moduleID;
 179   return kTRUE;
 180 }
 181
 182
 183
 184 void AliITSModuleDaSSD::SetModuleFEEId (const UChar_t ddlID, const UChar_t ad, const UChar_t adc)
 185 {
 186 // Set id data of FEE connected to the Module
 187   fDdlId = ddlID;
 188   fAd = ad;
 189   fAdc = adc;
 190 }
 191
 192
 193 void AliITSModuleDaSSD::SetModuleRorcId (const Int_t equipid, const Int_t equiptype)
 194 {
 195 // Set data to access FEROM registres via DDL
 196   fEquipId = equipid;
 197   fEquipType = equiptype;
 198 }
 199
 200
 201 Bool_t AliITSModuleDaSSD::SetEventsNumber(const Long_t eventsnumber)
 202 {
 203 // Allocate the memory for the enents data
 204   Int_t i;
 205   if (!fStrips) return kFALSE;
 206   try {
 207      for (i = 0; i < fNumberOfStrips; i++) {
 208        if (fStrips[i]) fStrips[i]->SetEvenetsNumber(eventsnumber);
 209        else fStrips[i] = new AliITSChannelDaSSD(i, eventsnumber);
 210      }
 211   }
 212   catch (bad_alloc&) {
 213      Error("AliITSModuleDaSSD", "Error allocating memory for %i-th AliITSChannelDaSSD objects!", i);
 214      for (Int_t j = 0; j < i; j++) delete fStrips[j];
 215      delete [] fStrips;
 216      fNumberOfStrips = 0;
 217      fStrips = NULL;
 218      return kFALSE;
 219   }
 220   return kTRUE;
 221 }
 222
 223
 224
 225 AliITSNoiseSSD* AliITSModuleDaSSD::GetCalibrationSSDModule() const
 226 {
 227 // Creates the AliITSNoiseSSD objects with callibration data
 228   AliITSNoiseSSD  *mc;
 229   if (!fStrips) return NULL;
 230   mc = new AliITSNoiseSSD();
 231   mc->SetMod(fModuleId);
 232   mc->SetNNoiseP(fgkPNStripsPerModule);
 233   mc->SetNNoiseN(fgkPNStripsPerModule);
 234   for (Int_t i = 0; i < fNumberOfStrips; i++) {
 235     if (!fStrips[i]) {
 236       delete mc;
 237       return NULL;
 238     }
 239     if (i < fgkPNStripsPerModule)
 240           mc->AddNoiseP(i, fStrips[i]->GetNoise());
 241     else  mc->AddNoiseN((i - fgkPNStripsPerModule), fStrips[i]->GetNoise());
 242   }
 243   return mc;
 244 }