-
-
+/**************************************************************************
+ * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+/* $Id$ */
+
+///////////////////////////////////////////////////////////////////////////////
+///
+/// This class provides storage container ITS SSD module callibration data
+/// used by DA.
+///
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AliITSNoiseSSD.h"
#include "AliITSModuleDaSSD.h"
+#include "TString.h"
+#include "AliLog.h"
ClassImp(AliITSModuleDaSSD)
+
+const Int_t AliITSModuleDaSSD::fgkStripsPerModule = 1536; // Number of strips per SSD module
+const Int_t AliITSModuleDaSSD::fgkPNStripsPerModule = 768; // Number of N/P strips per SSD module
+const Int_t AliITSModuleDaSSD::fgkStripsPerChip = 128; // Number of strips per chip HAL25
+const UChar_t AliITSModuleDaSSD::fgkMaxAdNumber = 9; // MAx SSD FEROM AD number
+const UChar_t AliITSModuleDaSSD::fgkMaxAdcNumber = 13; // MAx SSD FEROM ADC number
+const Int_t AliITSModuleDaSSD::fgkChipsPerModule = 12; // Number of HAL25 chips per SSD module
+
+
+
using namespace std;
+//______________________________________________________________________________
AliITSModuleDaSSD::AliITSModuleDaSSD() :
fEquipId(0),
fEquipType(0),
fModuleId(0),
fNumberOfStrips(0),
fStrips(NULL),
+ fNumberOfChips(0),
+ fCm(NULL),
fEventsNumber(0)
{
+// Default constructor
}
+//______________________________________________________________________________
AliITSModuleDaSSD::AliITSModuleDaSSD(const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t moduleID) :
fEquipId(0),
fEquipType(0),
fModuleId(moduleID),
fNumberOfStrips(0),
fStrips(NULL),
+ fNumberOfChips(0),
+ fCm(NULL),
fEventsNumber(0)
{
+// Constructor, set module id data
}
+//______________________________________________________________________________
AliITSModuleDaSSD::AliITSModuleDaSSD(const Int_t numberofstrips) :
fEquipId(0),
fEquipType(0),
fModuleId(0),
fNumberOfStrips(0),
fStrips(NULL),
+ fNumberOfChips(0),
+ fCm(NULL),
fEventsNumber(0)
{
+// Constructor, allocates memory for AliITSChannelDaSSD*
if (numberofstrips != fgkStripsPerModule)
- Warning("AliITSModuleDaSSD", "ALICE ITS SSD Module contains %d strips", fgkStripsPerModule);
- try {
- fStrips = new AliITSChannelDaSSD* [numberofstrips];
+ AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i strips", fgkStripsPerModule));
+ fStrips = new (nothrow) AliITSChannelDaSSD* [numberofstrips];
+ if (fStrips) {
fNumberOfStrips = numberofstrips;
for (Int_t i = 0; i < numberofstrips; i++) fStrips[i]= NULL;
- }
- catch (bad_alloc&) {
- Error("AliITSModuleDaSSD", "Error allocating memory for %d AliITSChannelDaSSD objects!", numberofstrips);
+ } else {
+ AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips));
fNumberOfStrips = 0;
fStrips = NULL;
- }
+ }
}
+//______________________________________________________________________________
AliITSModuleDaSSD::AliITSModuleDaSSD(const Int_t numberofstrips, const Long_t eventsnumber) :
fEquipId(0),
fEquipType(0),
fModuleId(0),
fNumberOfStrips(0),
fStrips(NULL),
+ fNumberOfChips(0),
+ fCm(NULL),
fEventsNumber(0)
{
+// Constructor, allocates memory for AliITSChannelDaSSD* and events data
if (numberofstrips != fgkStripsPerModule)
- Warning("AliITSModuleDaSSD", "ALICE ITS SSD Module contains %d strips", fgkStripsPerModule);
- try {
- fStrips = new AliITSChannelDaSSD* [numberofstrips];
+ AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i strips", fgkStripsPerModule));
+ fStrips = new (nothrow) AliITSChannelDaSSD* [numberofstrips];
+ if (fStrips) {
fNumberOfStrips = numberofstrips;
- }
- catch (bad_alloc&) {
- Error("AliITSModuleDaSSD", "Error allocating memory for %d AliITSChannelDaSSD objects!", numberofstrips);
+ memset(fStrips, 0, numberofstrips * sizeof(AliITSChannelDaSSD*));
+ for (Int_t i = 0; i < fNumberOfStrips; i++) {
+ fStrips[i] = new AliITSChannelDaSSD(i, eventsnumber);
+ if (!fStrips[i]) AliError(Form("AliITSModuleDaSSD: Error allocating memory for AliITSChannelDaSSD %i-th object", i));
+ }
+ } else {
+ AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips));
fNumberOfStrips = 0;
fStrips = NULL;
- }
- if (fStrips) {
- Int_t i;
- try {
- for (i = 0; i < fNumberOfStrips; i++) fStrips[i] = new AliITSChannelDaSSD(i, eventsnumber);
- }
- catch (bad_alloc&) {
- Error("AliITSModuleDaSSD", "Error allocating memory for %d-th AliITSChannelDaSSD objects!", i);
- for (Int_t j = 0; j < i; j++) delete fStrips[j];
- delete [] fStrips;
- fNumberOfStrips = 0;
- fStrips = NULL;
- }
}
}
+//______________________________________________________________________________
AliITSModuleDaSSD::AliITSModuleDaSSD(const AliITSModuleDaSSD& module) :
TObject(module),
fEquipId(module.fEquipId),
fAdc(module.fAdc),
fModuleId(module.fModuleId),
fNumberOfStrips(module.fNumberOfStrips),
- fStrips(module.fStrips),
+ fStrips(NULL),
+ fNumberOfChips(module.fNumberOfChips),
+ fCm(NULL),
fEventsNumber(module.fEventsNumber)
{
- // copy constructor
-
- Fatal("AliITSModuleDaSSD", "copy constructor not implemented");
+// copy constructor
+ if ((module.fNumberOfStrips > 0) && (module.fStrips)) {
+ fStrips = new (nothrow) AliITSChannelDaSSD* [module.fNumberOfStrips];
+ if (fStrips) {
+ for (Int_t strind = 0; strind < module.fNumberOfStrips; strind++) {
+ if (module.fStrips[strind]) {
+ fStrips[strind] = new AliITSChannelDaSSD(*(module.fStrips[strind]));
+ if (!fStrips[strind]) {
+ AliError("AliITSModuleDaSSD: Error copy constructor");
+ for (Int_t i = (strind - 1); i >= 0; i--) delete fStrips[strind];
+ delete [] fStrips;
+ fStrips = NULL;
+ break;
+ }
+ } else fStrips[strind] = NULL;
+ }
+ } else {
+ AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", module.fNumberOfStrips));
+ fNumberOfStrips = 0;
+ fStrips = NULL;
+ }
+ }
+ if (module.fCm) {
+ fCm = new (nothrow) TArrayF [module.fNumberOfChips];
+ if (fCm) {
+ for (Int_t chind = 0; chind < module.fNumberOfChips; chind++) fCm[chind] = module.fCm[chind];
+ } else {
+ AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayF objects!", module.fNumberOfChips));
+ fNumberOfChips = 0;
+ fCm = NULL;
+ }
+ }
}
+//______________________________________________________________________________
AliITSModuleDaSSD& AliITSModuleDaSSD::operator = (const AliITSModuleDaSSD& module)
{
// assignment operator
-
- Fatal("AliITSModuleDaSSD: operator =", "assignment operator not implemented");
+ if (this == &module) return *this;
+ if (fStrips) {
+ for (Long_t i = 0; i < fNumberOfStrips; i++) if (fStrips[i]) delete fStrips[i];
+ delete [] fStrips;
+ }
+ fEquipId = module.fEquipId;
+ fEquipType = module.fEquipType;
+ fDdlId = module.fDdlId;
+ fAd = module.fAd;
+ fAdc = module.fAdc;
+ fModuleId = module.fModuleId;
+ fNumberOfStrips = module.fNumberOfStrips;
+ fStrips = NULL;
+ fNumberOfChips = module.fNumberOfChips;
+ fCm = NULL;
+ fEventsNumber = module.fEventsNumber;
+ if ((module.fNumberOfStrips > 0) && (module.fStrips)) {
+ fStrips = new (nothrow) AliITSChannelDaSSD* [module.fNumberOfStrips];
+ if (fStrips) {
+ for (Int_t strind = 0; strind < module.fNumberOfStrips; strind++) {
+ if (module.fStrips[strind]) {
+ fStrips[strind] = new AliITSChannelDaSSD(*(module.fStrips[strind]));
+ if (!fStrips[strind]) {
+ AliError("AliITSModuleDaSSD: Error copy constructor");
+ for (Int_t i = (strind - 1); i >= 0; i--) delete fStrips[strind];
+ delete [] fStrips;
+ fStrips = NULL;
+ break;
+ }
+ } else fStrips[strind] = NULL;
+ }
+ } else {
+ AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", module.fNumberOfStrips));
+ fNumberOfStrips = 0;
+ fStrips = NULL;
+ }
+ }
+ if (fCm) delete [] fCm;
+ if (module.fCm) {
+ fCm = new (nothrow) TArrayF [module.fNumberOfChips];
+ if (fCm) {
+ for (Int_t chind = 0; chind < module.fNumberOfChips; chind++) fCm[chind] = module.fCm[chind];
+ } else {
+ AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayF objects!", module.fNumberOfChips));
+ fNumberOfChips = 0;
+ fCm = NULL;
+ }
+ }
return *this;
}
+//______________________________________________________________________________
AliITSModuleDaSSD::~AliITSModuleDaSSD()
{
+// Destructor
if (fStrips)
{
for (Long_t i = 0; i < fNumberOfStrips; i++)
{
if (fStrips[i]) delete fStrips[i];
-// if (!(i % 100)) cout << "Deleted fStrips[i], i = " << i << endl;
}
delete [] fStrips;
}
+ if (fCm) delete [] fCm;
}
+
+//______________________________________________________________________________
+Bool_t AliITSModuleDaSSD::SetNumberOfStrips(const Int_t numberofstrips)
+{
+// Allocates memory for AliITSChannelDaSSD*
+ if (fStrips) {
+ for (Int_t i = 0; i < fNumberOfStrips; i++) if (fStrips[i]) delete fStrips[i];
+ delete [] fStrips;
+ fStrips = NULL;
+ }
+ if (numberofstrips <= 0) {fNumberOfStrips = 0; return kTRUE; }
+ if (numberofstrips != fgkStripsPerModule)
+ AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i strips", fgkStripsPerModule));
+ fStrips = new (nothrow) AliITSChannelDaSSD* [numberofstrips];
+ if (fStrips) {
+ fNumberOfStrips = numberofstrips;
+ memset(fStrips, 0, sizeof(AliITSChannelDaSSD*) * numberofstrips);
+ return kTRUE;
+ } else {
+ AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips));
+ fNumberOfStrips = 0;
+ fStrips = NULL;
+ return kFALSE;
+ }
+}
+
+
+//______________________________________________________________________________
+Bool_t AliITSModuleDaSSD::SetNumberOfChips(const Int_t nchips)
+{
+// Allocate nchips TArrayF objects to save Common Mode
+ DeleteCM();
+ if (nchips <= 0) {fNumberOfChips = 0; return kTRUE; }
+ if (nchips != fgkChipsPerModule)
+ AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i HAL25 chips", fgkChipsPerModule));
+ fCm = new (nothrow) TArrayF [nchips];
+ if (fCm) {
+ fNumberOfChips = nchips;
+ return kTRUE;
+ } else {
+ AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i TArrayF objects!", nchips));
+ fNumberOfChips = 0;
+ fCm = NULL;
+ return kFALSE;
+ }
+}
+
-Bool_t AliITSModuleDaSSD::SetModuleIdData (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t moduleID)
+//______________________________________________________________________________
+Bool_t AliITSModuleDaSSD::SetModuleIdData (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const Short_t moduleID)
{
+// SetModuleIdData
if (ad > fgkMaxAdNumber) {
- Warning("AliITSModuleDaSSD", "Wrong AD number: %i", ad);
+ AliWarning(Form("AliITSModuleDaSSD: Wrong AD number: %i", ad));
return kFALSE;
}
if (adc > fgkMaxAdcNumber || ForbiddenAdcNumber(adc)) {
- Warning("AliITSModuleDaSSD", "Wrong ADC number: %i", adc);
+ AliWarning(Form("AliITSModuleDaSSD: Wrong ADC number: %i", adc));
return kFALSE;
}
fDdlId = ddlID;
}
-
+//______________________________________________________________________________
void AliITSModuleDaSSD::SetModuleFEEId (const UChar_t ddlID, const UChar_t ad, const UChar_t adc)
{
+// Set id data of FEE connected to the Module
fDdlId = ddlID;
fAd = ad;
fAdc = adc;
}
+//______________________________________________________________________________
void AliITSModuleDaSSD::SetModuleRorcId (const Int_t equipid, const Int_t equiptype)
{
+// Set data to access FEROM registres via DDL
fEquipId = equipid;
fEquipType = equiptype;
}
+//______________________________________________________________________________
Bool_t AliITSModuleDaSSD::SetEventsNumber(const Long_t eventsnumber)
{
+// Allocate the memory for the events data
Int_t i;
if (!fStrips) return kFALSE;
- try {
- for (i = 0; i < fNumberOfStrips; i++) {
- if (fStrips[i]) fStrips[i]->SetEvenetsNumber(eventsnumber);
- else fStrips[i] = new AliITSChannelDaSSD(i, eventsnumber);
- }
- }
- catch (bad_alloc&) {
- Error("AliITSModuleDaSSD", "Error allocating memory for %d-th AliITSChannelDaSSD objects!", i);
- for (Int_t j = 0; j < i; j++) delete fStrips[j];
- delete [] fStrips;
- fNumberOfStrips = 0;
- fStrips = NULL;
- return kFALSE;
- }
+ for (i = 0; i < fNumberOfStrips; i++) {
+ if (fStrips[i])
+ if (!fStrips[i]->SetEvenetsNumber(eventsnumber)) {
+ for (Int_t j = 0; j < i; j++) fStrips[j]->DeleteSignal();
+ AliError(Form("AliITSModuleDaSSD: Error allocating memory for i% events for module %i, strip %i",
+ eventsnumber, (Int_t)fModuleId, i));
+ return kFALSE;
+ }
+ else
+ if (!(fStrips[i] = new AliITSChannelDaSSD(i, eventsnumber))) {
+ for (Int_t j = 0; j < i; j++) delete fStrips[j];
+ delete [] fStrips;
+ fNumberOfStrips = 0;
+ fStrips = NULL;
+ AliError(Form("AliITSModuleDaSSD: Error allocating memory for strip %i of module %i!", (Int_t)fModuleId, i));
+ return kFALSE;
+ }
+ }
+ return kTRUE;
+}
+
+
+
+//______________________________________________________________________________
+Bool_t AliITSModuleDaSSD::SetCM (const Float_t cm, const Int_t chipn, const Int_t evn)
+{
+// Set value of CM for a given chip and event
+ if ((!fCm) || (chipn >= fNumberOfChips)) return kFALSE;
+ if (evn >= fCm[chipn].GetSize()) return kFALSE;
+ else fCm[chipn][evn] = cm;
return kTRUE;
}
+//______________________________________________________________________________
+Float_t AliITSModuleDaSSD::GetCM(const Int_t chipn, const Long_t evn) const
+{
+// Get value of CM for a given chip and event
+ if ((!fCm) || (chipn >= fNumberOfChips)) return 0.0f;
+ if (evn >= fCm[chipn].GetSize()) return 0.0f;
+ else return fCm[chipn][evn];
+}
+
+
+
+//______________________________________________________________________________
AliITSNoiseSSD* AliITSModuleDaSSD::GetCalibrationSSDModule() const
{
+// Creates the AliITSNoiseSSD objects with callibration data
AliITSNoiseSSD *mc;
+ Float_t noise;
if (!fStrips) return NULL;
mc = new AliITSNoiseSSD();
mc->SetMod(fModuleId);
mc->SetNNoiseP(fgkPNStripsPerModule);
mc->SetNNoiseN(fgkPNStripsPerModule);
for (Int_t i = 0; i < fNumberOfStrips; i++) {
- if (!fStrips[i]) {
- delete mc;
- return NULL;
- }
+ if (!fStrips[i]) noise = AliITSChannelDaSSD::GetUndefinedValue();
+ else noise = fStrips[i]->GetNoiseCM();
if (i < fgkPNStripsPerModule)
- mc->AddNoiseP(i, fStrips[i]->GetNoise());
- else mc->AddNoiseN((i - fgkPNStripsPerModule), fStrips[i]->GetNoise());
+ mc->AddNoiseP(i, noise);
+ else mc->AddNoiseN((AliITSChannelDaSSD::GetMaxStripIdConst() - i), noise);
}
return mc;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff