-
-#include <iostream>
+/**************************************************************************
+ * 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 ITS SSD data handling
+/// used by DA.
+///
+///////////////////////////////////////////////////////////////////////////////
+
+#include <Riostream.h>
#include "AliITSHandleDaSSD.h"
+#include <math.h>
+#include <sstream>
+#include <string>
+#include "event.h"
+#include "TFile.h"
+#include "TObjArray.h"
+#include "AliITSNoiseSSD.h"
+#include "AliRawReaderDate.h"
+
+#include "AliITSChannelDaSSD.h"
ClassImp(AliITSHandleDaSSD)
fLdcId(0),
fRunId(0)
{
+// Default constructor
}
fLdcId(0),
fRunId(0)
{
+// Constructor allocates memory for AliITSModuleDaSSD objects
if (numberofmodules > fgkNumberOfSSDModules)
cout << "ALICE ITS SSD contains " << fgkNumberOfSSDModules << "modules!"<< endl;
- try
- {
- fModules = new AliITSModuleDaSSD* [numberofmodules];
- fNumberOfModules = numberofmodules;
- for (Int_t i = 0; i < numberofmodules; i++) fModules[i] = NULL;
- }
- catch (bad_alloc&)
- {
- Error("AliITSHandleDaSSD", "Error allocating memory for %i AliITSModulesDaSSD objects!", numberofmodules);
+ fModules = new (nothrow) AliITSModuleDaSSD* [numberofmodules];
+ if (fModules) {
+ fNumberOfModules = numberofmodules;
+ memset(fModules, 0, sizeof(AliITSModuleDaSSD*) * numberofmodules);
+ } else {
+ Error("AliITSHandleDaSSD", "Error allocating memory for %i AliITSModulesDaSSD* objects!", numberofmodules);
fNumberOfModules = 0;
fModules = NULL;
- }
+ }
}
AliITSHandleDaSSD::~AliITSHandleDaSSD()
-{
+{
+// Default destructor
if (fModules)
{
for (Int_t i = 0; i < fNumberOfModules; i++)
AliITSModuleDaSSD* AliITSHandleDaSSD::GetModule (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
{
+// Retrieve AliITSModuleDaSSD object from the array
if (!fModules) return NULL;
for (Int_t i = 0; i < fNumberOfModules; i++) {
if (fModules[i]) {
-/*************************** Used for test only ******************************/
-
AliITSChannelDaSSD* AliITSHandleDaSSD::GetStrip (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t stripID) const
{
+// Retrieve AliITSChannalDaSSD object from the array
for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
if ( (fModules[modind]->GetDdlId() == ddlID)
&& (fModules[modind]->GetAD() == ad)
Bool_t AliITSHandleDaSSD::SetModule(AliITSModuleDaSSD *const module, const Int_t index)
{
+// Assign array element with AliITSModuleDaSSD object
if ((index < fNumberOfModules) && (index >= 0))
{
if (fModules[index]) delete fModules[index];
Bool_t AliITSHandleDaSSD::SetNumberOfModules (const Int_t numberofmodules)
{
- if (numberofmodules > fgkNumberOfSSDModules)
- Warning("AliITSHandleDaSSD", "The number of modules you use exceeds the maximum %i for ALICE ITS SSD", fgkNumberOfSSDModules);
- try
- {
- fModules = new AliITSModuleDaSSD* [numberofmodules];
- fNumberOfModules = numberofmodules;
- for (Int_t i = 0; i < fNumberOfModules; i++) fModules[i] = NULL;
- return kTRUE;
- }
- catch (bad_alloc&)
- {
- Error("AliITSHandleDaSSD", "Error allocating memory for %i AliITSModuleDaSSD objects!", numberofmodules);
+// Allocates memory for AliITSModuleDaSSD objects
+ if (numberofmodules > fgkNumberOfSSDModules)
+ Warning("AliITSHandleDaSSD", "The number of modules %i you use exceeds the maximum %i for ALICE ITS SSD", numberofmodules, fgkNumberOfSSDModules);
+ if (fModules) { delete [] fModules; fModules = NULL; }
+ fModules = new (nothrow) AliITSModuleDaSSD* [numberofmodules];
+ if (fModules) {
+ fNumberOfModules = numberofmodules;
+ memset(fModules, 0, sizeof(AliITSModuleDaSSD*) * numberofmodules);
+ return kTRUE;
+ } else {
+ Error("AliITSHandleDaSSD", "Error allocating memory for %i AliITSModulesDaSSD* objects!", numberofmodules);
fNumberOfModules = 0;
fModules = NULL;
- }
+ }
return kFALSE;
}
Bool_t AliITSHandleDaSSD::ReadCalibrationDataFile (const char* fileName, const Long_t eventsnumber)
{
+// Reads raw data from file
AliRawReaderDate *rawreaderdate = new AliRawReaderDate(fileName, 0);
AliITSModuleDaSSD *module;
AliITSChannelDaSSD *strip;
Error("AliITSHandleDaSSD", "Error ReadCalibrationDataFile: no structure was allocated for data");
return kFALSE;
}
- rawreaderdate->SelectEvents(PHYSICS_EVENT);
+ rawreaderdate->SelectEvents(-1);
while (rawreaderdate->NextEvent()) {
+ if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
fLdcId = rawreaderdate->GetLDCId();
fRunId = rawreaderdate->GetRunNumber();
modind = 0;
Bool_t AliITSHandleDaSSD::RelocateModules()
-{
+{
+// Relocate memory for AliITSModuleDaSSD object array
Int_t nm = 0;
- AliITSModuleDaSSD **marray;
+ AliITSModuleDaSSD **marray = NULL;
for (Int_t modind = 0; modind < fNumberOfModules; modind++)
if (fModules[modind]) nm += 1;
if (nm == fNumberOfModules) return kTRUE;
- try {
- marray = new AliITSModuleDaSSD* [nm];
- }
- catch (bad_alloc&) {
- Error("AliITSHandleDaSSD", "Error relocating memory for %i AliITSModuleDaSSD objects!", nm);
+ marray = new (nothrow) AliITSModuleDaSSD* [nm];
+ if (!marray) {
+ Error("AliITSHandleDaSSD", "Error relocating memory for %i AliITSModuleDaSSD* objects!", nm);
return kFALSE;
}
nm = 0;
Bool_t AliITSHandleDaSSD::CalculatePedestal()
{
+// Calculates Pedestal
Float_t pedestal;
Short_t *signal;
AliITSChannelDaSSD *strip;
Bool_t AliITSHandleDaSSD::CalculateNoise()
{
+// Calculates Noise
AliITSChannelDaSSD *strip;
Short_t *signal;
Float_t noise;
Bool_t AliITSHandleDaSSD::CalculateCM(const Int_t modind, const Int_t stripind, Float_t* const cm)
{
+// Calculates CM
AliITSChannelDaSSD *strip = NULL;
Short_t *signal;
Long_t ovstr, evn, n;
Bool_t AliITSHandleDaSSD::CalculateNoiseCM()
{
+// Calculates Noise with CM correction
Short_t *signal;
AliITSChannelDaSSD *strip = NULL;
Float_t noise, *cm = NULL;
TObjArray* AliITSHandleDaSSD::GetCalibrationSSDLDC() const
-{
+{
+// Fill in the array for OCDB
TObjArray *ldcc;
if (!fModules) return NULL;
ldcc = new TObjArray(fNumberOfModules, 0);
delete ldcc;
return NULL;
}
- ldcc->AddAt(fModules[i]->GetCalibrationSSDModule(), i);
+ ldcc->AddAt(dynamic_cast<TObject*>(fModules[i]->GetCalibrationSSDModule()), i);
}
ldcc->Compress();
return ldcc;
Bool_t AliITSHandleDaSSD::SaveCalibrationSSDLDC(string& dafname) const
{
+// Save Calibration data locally
ostringstream dadatafilename;
TObjArray *ldcc;
if (!fModules) return kFALSE;
delete ldcc;
return kFALSE;
}
- ldcc->AddAt(fModules[i]->GetCalibrationSSDModule(), i);
+ ldcc->AddAt(dynamic_cast<TObject*>(fModules[i]->GetCalibrationSSDModule()), i);
}
ldcc->Compress();
dadatafilename << dafname << "/ITSSSDda_" << fLdcId << "_" << fRunId << ".root";
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff