SSD detactor algorithm and related classes (E. Fragiacomo)
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 3 Sep 2007 16:03:07 +0000 (16:03 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 3 Sep 2007 16:03:07 +0000 (16:03 +0000)
ITS/AliITSChannelDaSSD.cxx [new file with mode: 0644]
ITS/AliITSChannelDaSSD.h [new file with mode: 0644]
ITS/AliITSHandleDaSSD.cxx [new file with mode: 0644]
ITS/AliITSHandleDaSSD.h [new file with mode: 0644]
ITS/AliITSModuleDaSSD.cxx [new file with mode: 0644]
ITS/AliITSModuleDaSSD.h [new file with mode: 0644]
ITS/ITSSSDPEDda.cxx [new file with mode: 0644]
ITS/ITSbaseLinkDef.h
ITS/libITSbase.pkg

diff --git a/ITS/AliITSChannelDaSSD.cxx b/ITS/AliITSChannelDaSSD.cxx
new file mode 100644 (file)
index 0000000..33c8278
--- /dev/null
@@ -0,0 +1,118 @@
+
+#include "AliITSChannelDaSSD.h"
+
+ClassImp(AliITSChannelDaSSD)
+
+using namespace std;
+
+const Float_t  AliITSChannelDaSSD::fgkUndefinedValue  = 32639.0f;  // = 0x7F7F
+
+AliITSChannelDaSSD::AliITSChannelDaSSD() :
+  fStripId(0),
+  fEventsNumber(0),
+  fSignal(NULL),
+  fPedestal(fgkUndefinedValue),
+  fNoise(fgkUndefinedValue),
+  fZsThresholdFactor(0.0f)
+{
+}
+
+
+AliITSChannelDaSSD::AliITSChannelDaSSD(const UShort_t stripID) :
+  fStripId(stripID),
+  fEventsNumber(0),
+  fSignal(NULL),
+  fPedestal(fgkUndefinedValue),
+  fNoise(fgkUndefinedValue),
+  fZsThresholdFactor(0.0f)
+{
+}
+
+
+AliITSChannelDaSSD::AliITSChannelDaSSD(const UShort_t stripID, const Long_t eventsnumber) :
+  fStripId(stripID),
+  fEventsNumber(0),
+  fSignal(NULL),
+  fPedestal(fgkUndefinedValue),
+  fNoise(fgkUndefinedValue),
+  fZsThresholdFactor(0.0f)
+{
+  if (stripID > fgkMaxStripId)
+    Warning("AliITSChannelDaSSD", "Wrong StripID: %i", stripID);
+  try
+  {
+     fSignal = new Short_t [eventsnumber];
+     fEventsNumber = eventsnumber;
+     memset(fSignal, fgkDefaultSignal, (eventsnumber * sizeof(Short_t)));
+  }
+  catch (bad_alloc&) 
+  {
+     cout << "Error allocating memory for " << (long) eventsnumber << " Short_t objects in AliITSChannelDaSSD constructor!" << endl;
+     fSignal = NULL;
+     fEventsNumber = 0;
+  }  
+}
+
+
+
+AliITSChannelDaSSD::AliITSChannelDaSSD(const AliITSChannelDaSSD& strip) :
+  TObject(strip),
+  fStripId(strip.fStripId),
+  fEventsNumber(strip.fEventsNumber),
+  fSignal(strip.fSignal),
+  fPedestal(strip.fPedestal),
+  fNoise(strip.fNoise),
+  fZsThresholdFactor(strip.fZsThresholdFactor)
+{
+  // copy constructor
+
+  Fatal("AliITSChannelDaSSD", "copy constructor not implemented");
+}
+
+AliITSChannelDaSSD& AliITSChannelDaSSD::operator = (const AliITSChannelDaSSD& strip)
+{
+// assignment operator
+
+  Fatal("operator =", "assignment operator not implemented");
+  return *this;
+}
+
+
+AliITSChannelDaSSD::~AliITSChannelDaSSD()
+{
+  if (fSignal) 
+  {
+     delete [] fSignal;
+  }
+}
+
+
+Bool_t AliITSChannelDaSSD::SetEvenetsNumber(const Long_t eventsnumber)
+{
+  try
+  {
+     fSignal = new Short_t[eventsnumber];
+     fEventsNumber = eventsnumber;
+     memset(fSignal, fgkDefaultSignal, (eventsnumber * sizeof(Short_t)));
+     return kTRUE;
+  }
+  catch (bad_alloc&) 
+  {
+     cout << "Error allocating memory for " << (long) eventsnumber << " Short_t objects!" << endl;
+     fSignal = NULL;
+     fEventsNumber = 0;
+     return kFALSE;
+  }  
+}
+
+
+
+Bool_t AliITSChannelDaSSD::SetSignal(const Long_t eventnumber, const Short_t signal)
+{
+  if (eventnumber < fEventsNumber && fSignal)
+  {
+     fSignal[eventnumber] = signal;
+     return kTRUE;
+  }
+  return kFALSE;
+}
diff --git a/ITS/AliITSChannelDaSSD.h b/ITS/AliITSChannelDaSSD.h
new file mode 100644 (file)
index 0000000..d40dd98
--- /dev/null
@@ -0,0 +1,69 @@
+#ifndef ALIITSCHANNELDASSD_H
+#define ALIITSCHANNELDASSD_H
+
+
+#include <iostream>
+#include "TMath.h"
+#include "TObject.h"
+
+class AliITSChannelDaSSD : public TObject {
+  public :
+    AliITSChannelDaSSD();
+    explicit AliITSChannelDaSSD(const UShort_t stripId);
+    AliITSChannelDaSSD(const UShort_t stripId, const Long_t eventsnumber);
+    AliITSChannelDaSSD(const AliITSChannelDaSSD& strip);
+    AliITSChannelDaSSD& operator = (const AliITSChannelDaSSD& strip);
+    virtual ~AliITSChannelDaSSD();
+    
+    UShort_t  GetStripId() const { return fStripId; }
+    Long_t    GetEventsNumber() const { return fEventsNumber; }
+    Short_t*  GetSignal()  const { return fSignal; }
+    Short_t*  GetSignal(const Long_t eventnumber)  const 
+                                { return (eventnumber < fEventsNumber && fSignal) ? (fSignal+eventnumber) : NULL; }
+    
+    Float_t  GetPedestal() const { return fPedestal; }
+    Float_t  GetNoise()    const { return fNoise; }
+    Bool_t   CheckNoise()  const { return (fNoise < fgkUndefinedValue) ? kTRUE : kFALSE; }
+
+    UChar_t  GetFeeOffset() const { return (fPedestal < fgkUndefinedValue) ? (static_cast<UChar_t>(TMath::Nint(fPedestal))) : 0; }
+    UChar_t  GetFeeZs()     const { return (fNoise < fgkUndefinedValue) ? 
+                                                    (static_cast<UChar_t>(fZsThresholdFactor * TMath::Nint(fNoise))) : 0;      }
+    Bool_t    SetEvenetsNumber(const Long_t eventsnumber);
+    Bool_t    SetSignal(const Long_t eventnumber, const Short_t signal);
+    void      SetStripId(const UShort_t stripId) { fStripId = stripId; }
+
+    void      SetPedestal(Float_t pedestal) { fPedestal = pedestal; }
+    void      SetNoise(Float_t noise) { fNoise = noise; }
+    void      ClearNoise() { if (fNoise < fgkUndefinedValue) fNoise = fgkUndefinedValue; }
+    void      ClearPedestal() { if (fPedestal < fgkUndefinedValue) fPedestal = fgkUndefinedValue; }
+    void      ClearSignal() { if (fSignal) for (Int_t i = 0; i < fEventsNumber; i++) 
+                                             fSignal[i] = 0x100 * fgkDefaultSignal + fgkDefaultSignal; }
+    void      DeleteSignal() { if (fSignal) { delete [] fSignal; fSignal = NULL; fEventsNumber = 0;} }
+
+    static  Short_t  GetOverflowConst()  { return fgkSignalOverflow;  }
+    static  Short_t  GetUnderflowConst() { return fgkSignalUnderflow; }
+    static  Float_t  GetUndefinedValue() { return fgkUndefinedValue;  }
+
+  protected :
+  
+    static const UShort_t fgkMinStripId = 0;
+    static const UShort_t fgkMaxStripId = 1535;
+
+    static const Short_t  fgkSignalOverflow  = 2047;
+    static const Short_t  fgkSignalUnderflow = 2048;
+    static const UShort_t fgkDefaultSignal   = 0x7F;
+    static const Float_t  fgkUndefinedValue;
+    UShort_t          fStripId;             //  channel = strip number within SSD module 0-1535
+    Long_t            fEventsNumber;        //  number of events for fSignal memory allocation
+    Short_t          *fSignal;              //! 
+    
+    Float_t           fPedestal;
+    Float_t           fNoise;
+    Float_t           fZsThresholdFactor;   //  factor for zero suppression threshold
+
+    ClassDef(AliITSChannelDaSSD, 1)
+};
+
+#endif
diff --git a/ITS/AliITSHandleDaSSD.cxx b/ITS/AliITSHandleDaSSD.cxx
new file mode 100644 (file)
index 0000000..fa3fd90
--- /dev/null
@@ -0,0 +1,424 @@
+
+#include <iostream> 
+#include "AliITSHandleDaSSD.h"
+
+
+ClassImp(AliITSHandleDaSSD)
+
+using namespace std;
+
+
+AliITSHandleDaSSD::AliITSHandleDaSSD() :
+  fNumberOfModules(0),
+  fModules(NULL),
+  fLdcId(0),
+  fRunId(0)
+{
+}
+
+
+AliITSHandleDaSSD::AliITSHandleDaSSD(const Int_t numberofmodules) :
+  fNumberOfModules(0),
+  fModules(NULL),
+  fLdcId(0),
+  fRunId(0)
+{
+  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);
+     fNumberOfModules = 0;
+     fModules = NULL;
+  }  
+}
+
+
+AliITSHandleDaSSD::AliITSHandleDaSSD(const AliITSHandleDaSSD& ssdadldc) :
+  TObject(ssdadldc),
+  fNumberOfModules(ssdadldc.fNumberOfModules),
+  fModules(ssdadldc.fModules),
+  fLdcId(ssdadldc.fLdcId),
+  fRunId(ssdadldc.fRunId)
+{
+  // copy constructor
+
+  Fatal("AliITSHandleDaSSD", "copy constructor not implemented");
+}
+
+
+AliITSHandleDaSSD& AliITSHandleDaSSD::operator = (const AliITSHandleDaSSD& ssdadldc)
+{
+// assignment operator
+
+  Fatal("operator =", "assignment operator not implemented");
+  return *this;
+}
+
+
+AliITSHandleDaSSD::~AliITSHandleDaSSD()
+{ 
+  if (fModules) 
+  {
+    for (Int_t i = 0; i < fNumberOfModules; i++)
+    { 
+      if (fModules[i]) delete fModules[i];
+    }
+    delete [] fModules;
+  }
+}
+
+
+
+AliITSModuleDaSSD* AliITSHandleDaSSD::GetModule (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
+{
+   if (!fModules) return NULL;
+   for (Int_t i = 0; i < fNumberOfModules; i++) {
+     if (fModules[i]) {
+       if (    (fModules[i]->GetDdlId() == ddlID)
+            && (fModules[i]->GetAD() == ad)
+            && (fModules[i]->GetADC() == adc))
+           return fModules[i];
+     }     
+   }
+   return NULL;
+}
+
+
+
+/*************************** Used for test only ******************************/
+
+AliITSChannelDaSSD* AliITSHandleDaSSD::GetStrip (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t stripID) const
+{
+  for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
+    if (    (fModules[modind]->GetDdlId() == ddlID)
+         && (fModules[modind]->GetAD() == ad)
+         && (fModules[modind]->GetADC() == adc)  ) 
+        {
+       return fModules[modind]->GetStrip(stripID);
+    }
+  }
+  Error("AliITSHandleDaSSD", "Error GetStrip (%i, %i, %i, %i), strip not found, returns NULL!", ddlID, ad, adc, stripID);
+  return NULL;
+}
+
+
+
+Bool_t AliITSHandleDaSSD::SetModule(AliITSModuleDaSSD *const module, const Int_t index)
+{ 
+   if ((index < fNumberOfModules) && (index >= 0)) 
+     { 
+        if (fModules[index]) delete fModules[index];
+       fModules[index] = module;
+       return kTRUE;
+      }
+   else return kFALSE;                        
+}
+
+
+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);
+     fNumberOfModules = 0;
+     fModules = NULL;
+  }  
+  return kFALSE;
+}
+
+
+Bool_t AliITSHandleDaSSD::ReadCalibrationDataFile (const char* fileName, const Long_t eventsnumber)
+{
+  AliRawReaderDate    *rawreaderdate = new AliRawReaderDate(fileName, 0);
+  AliITSModuleDaSSD   *module;
+  AliITSChannelDaSSD  *strip;
+  Long_t            datasize, eventind = 0;
+  Int_t             nofstrips, eqbelsize;
+  UShort_t          modind;
+  long32           *data;
+  if (!fModules) {
+    Error("AliITSHandleDaSSD", "Error ReadCalibrationDataFile: no structure was allocated for data");
+    return kFALSE;
+  }
+  rawreaderdate->SelectEvents(PHYSICS_EVENT);
+  while (rawreaderdate->NextEvent()) {
+    fLdcId = rawreaderdate->GetLDCId();
+    fRunId = rawreaderdate->GetRunNumber(); 
+    modind = 0;
+    while (rawreaderdate->ReadNextData((UChar_t*&)data)) {
+      Int_t     equipid    = rawreaderdate->GetEquipmentId();              //  EquipmentID required to access to rorc
+      Int_t     equiptype  = rawreaderdate->GetEquipmentType();            //
+      UChar_t   ddlID      = (UChar_t)rawreaderdate->GetDDLID();           // GetDDLID(); index of DDL, ITS SSD: 33-48
+      datasize = rawreaderdate->GetDataSize();
+      eqbelsize = rawreaderdate->GetEquipmentElementSize();
+      if ( (datasize % eqbelsize) || (eqbelsize != sizeof(long32)) ) {
+        Error("AliITSHandleDaSSD", "Error ReadCalibrationDataFile: event data size %i is not an integer of equipment data size %i", datasize,
+               eqbelsize);
+        return kFALSE;
+      }
+      nofstrips = (Int_t) (datasize / eqbelsize);               
+      for (Int_t strind = 0; strind < nofstrips; strind++) {
+        UChar_t   ad      = (UChar_t) (data[strind] >> 28) & 0x0000000F;  // index of AD module     0-9
+        UChar_t   adc     = (UChar_t) (data[strind] >> 24) & 0x0000000F;  // index of ADC module    0-5, 8-13
+        UShort_t  stripID = (UShort_t)(data[strind] >> 12) & 0x000007FF;  // strip number           0-1535
+        Short_t   signal  = (Short_t)(data[strind] & 0x00000FFF);
+                  signal  = (signal > AliITSChannelDaSSD::GetUnderflowConst()) ? (signal - 2 * AliITSChannelDaSSD::GetUnderflowConst()) 
+                                                                              : signal;
+        if (!(module = GetModule(ddlID, ad, adc))) {
+          module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst());
+         if (!module->SetModuleIdData (ddlID, ad, adc, modind)) return kFALSE;
+          module->SetModuleRorcId (equipid, equiptype);
+         fModules[modind++] = module;
+        }
+        if (!(strip = module->GetStrip(stripID))) {
+          strip = new AliITSChannelDaSSD(stripID, eventsnumber);
+          module->SetStrip(strip, stripID);
+        }
+        strip->SetSignal(eventind, signal);
+     }
+     if (modind) cout << "The memory was allocated for " <<  modind << " modules." << endl;
+   }
+   if (++eventind > eventsnumber) break;
+  }
+  delete rawreaderdate;
+  return RelocateModules();
+}
+
+
+Bool_t AliITSHandleDaSSD::RelocateModules()
+{  
+  Int_t         nm = 0;
+  AliITSModuleDaSSD **marray;
+  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);
+    return kFALSE;
+  }
+  nm = 0;
+  for (Int_t modind = 0; modind < fNumberOfModules; modind++)  
+    if (fModules[modind]) marray[nm++] = fModules[modind];
+  delete [] fModules;
+  fModules = marray;
+  fNumberOfModules = nm;
+  return kTRUE;
+}
+
+
+Bool_t AliITSHandleDaSSD::CalculatePedestal()
+{
+  Float_t     pedestal;
+  Short_t    *signal;
+  AliITSChannelDaSSD *strip;
+  Long_t      ovev, ev;
+  if (!fModules) return kFALSE;
+  for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
+    if (!fModules[modind]) {
+      Error("AliITSHandleDaSSD", "Error CalculatePedestal(): No AliITSChannelDaSSD object with index %i is allocated in AliITSModuleDaSSD\n", modind);
+      return kFALSE;
+    }
+    for (Int_t strind = 0; strind < fModules[modind]->GetNumberOfStrips(); strind++) {
+      if (!(strip = fModules[modind]->GetStrip(strind))) return kFALSE;
+      if (!(signal = strip->GetSignal())) {
+        Error("AliITSHandleDaSSD", "Error CalculatePedestal(): there are no events data for module[%i] strip[%i]->GetSignal()", modind, strind);
+        return kFALSE;
+      }
+      pedestal = 0.0f;
+      ovev = 0l;
+      for (ev = 0; ev < strip->GetEventsNumber(); ev++)
+        if (SignalOutOfRange(signal[ev])) ovev += 1;
+//     else pedestal += signal[ev];
+       else pedestal = ((ev - ovev)) ? pedestal + (signal[ev] - pedestal) / static_cast<Float_t>(ev - ovev + 1) : signal[ev];
+       if (ev == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
+//      if ((Long_t n = strip->GetEventsNumber() - ovev)) pedestal /= static_cast<Float_t>(n);
+//      else return kFALSE;
+      strip->SetPedestal(pedestal);    
+    }
+  }
+  return kTRUE;
+}
+
+
+
+Bool_t AliITSHandleDaSSD::CalculateNoise()
+{
+  AliITSChannelDaSSD *strip;
+  Short_t    *signal;
+  Float_t     noise;
+  Long_t      ovev, n;
+  if (!fModules) return kFALSE;
+  for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
+    if (!fModules[modind]) {
+      Error("AliITSHandleDaSSD", "Error CalculateNoise(): No AliITSChannelDaSSD object with index %i is allocated in AliITSModuleDaSSD\n", modind);
+      return kFALSE;
+    }
+    for (Int_t strind = 0; strind < fModules[modind]->GetNumberOfStrips(); strind++) {
+      if (!(strip = fModules[modind]->GetStrip(strind))) return kFALSE;
+      if (!(signal = strip->GetSignal())) {
+        Error("AliITSHandleDaSSD", "Error CalculateNoise(): there are no events data for module[%i] strip[%i]->GetSignal()", modind, strind);
+        return kFALSE;
+      }
+      Double_t nsum = 0.0L;
+      ovev = 0l;
+      for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
+        if (SignalOutOfRange(signal[ev])) ovev += 1;
+       else nsum += pow((signal[ev] - strip->GetPedestal()), 2);
+//     else nsum = ((ev - ovev)) ? nsum + (pow((signal[ev] - strip->GetPedestal()), 2) - nsum) / static_cast<Double_t>(ev - ovev)
+//                               : pow((signal[ev] - strip->GetPedestal()), 2);
+      } 
+//      noise =  sqrt(nsum);
+      if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise =  sqrt(nsum / (Float_t)(n));
+      else  noise = AliITSChannelDaSSD::GetUndefinedValue();
+      strip->SetNoise(noise);
+    }
+  }
+  return kTRUE;
+}
+
+
+
+Bool_t AliITSHandleDaSSD::CalculateCM(const Int_t modind, const Int_t stripind, Float_t* const cm)
+{
+  AliITSChannelDaSSD *strip = NULL;
+  Short_t    *signal;
+  Long_t      ovstr, evn, n;
+  if ((stripind + AliITSModuleDaSSD::GetStripsPerChip()) > fModules[modind]->GetNumberOfStrips()) return kFALSE;
+  if (!(strip = fModules[modind]->GetStrip(stripind))) return kFALSE;
+  evn = fModules[modind]->GetStrip(stripind)->GetEventsNumber();
+  for (Long_t ev = 0; ev < evn; ev++) {
+    Double_t cmsum = 0.0L;
+    ovstr = 0l;
+    for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
+      if (!(strip = fModules[modind]->GetStrip(strind))) return kFALSE;
+      if (!(signal = strip->GetSignal())) {
+        Error("AliITSHandleDaSSD", "Error CalculateCM: there are no events data for module[%i] strip[%i]->GetSignal()", modind, strind);
+        return kFALSE;
+      }
+      if (SignalOutOfRange(signal[ev])) ovstr += 1;
+      else cmsum += (signal[ev] - strip->GetPedestal());
+    }
+    if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cm[ev] = cmsum / (Float_t)(n);
+    else cm[ev] = 0.0;
+  } 
+  return kTRUE; 
+}
+
+
+
+Bool_t  AliITSHandleDaSSD::CalculateNoiseCM()
+{
+  Short_t     *signal;
+  AliITSChannelDaSSD  *strip = NULL;
+  Float_t      noise, *cm = NULL;
+  Long_t       ovev, n;
+  if (!fModules) return kFALSE;
+  for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
+    if (!fModules[modind]) {
+      Error("AliITSHandleDaSSD", "Error CalculateNoiseCM(): No AliITSChannelDaSSD object with index %i is allocated in AliITSModuleDaSSD", modind);
+      return kFALSE;
+    }
+    for (Int_t strind = 0; strind < fModules[modind]->GetNumberOfStrips(); strind++) {
+      if (!(strip = fModules[modind]->GetStrip(strind))) return kFALSE;
+      if (!(signal = strip->GetSignal())) {
+        Error("AliITSHandleDaSSD", "Error CalculateNoiseCM(): there are no events data for module[%i] strip[%i]->GetSignal()", modind, strind);
+        return kFALSE;
+      }
+      if (!(strind % AliITSModuleDaSSD::GetStripsPerChip())) {
+        if (!cm) {
+          try { 
+           cm = new Float_t [strip->GetEventsNumber()];  }
+          catch (bad_alloc&) {
+            Warning("AliITSHandleDaSSD", "Noise calculation with common mode correction failed becouse of memory allocation problems.");
+            return kFALSE; 
+          }  
+        }
+// calculate cm;
+        if (!CalculateCM(modind, strind, cm)) return kFALSE;
+      }
+// calculate noise;    
+      Double_t nsum = 0.0L;
+      ovev = 0l;
+      for (Long_t ev = 0; ev < strip->GetEventsNumber(); ev++) {
+        if (SignalOutOfRange(signal[ev])) ovev += 1;
+       else nsum += pow((signal[ev] - strip->GetPedestal() - cm[ev]), 2);
+//     else nsum = ((ev - ovev)) ? nsum + (pow((signal[ev] - strip->GetPedestal() - cm[ev]), 2) - nsum) / static_cast<Double_t>(ev - ovev)
+//                               : pow((signal[ev] - strip->GetPedestal() - cm[ev]), 2);
+      } 
+//      noise =  sqrt(nsum);
+      if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise =  sqrt(nsum / (Float_t)(n));
+      else  noise = AliITSChannelDaSSD::GetUndefinedValue();
+      strip->SetNoise(noise);
+      }
+    }
+  if (cm) delete [] cm;
+  return kTRUE;
+}
+
+
+
+TObjArray* AliITSHandleDaSSD::GetCalibrationSSDLDC() const
+{ 
+  TObjArray *ldcc;
+  if (!fModules) return NULL;
+  ldcc = new TObjArray(fNumberOfModules, 0);
+  for (Int_t i = 0; i < fNumberOfModules; i++) {
+    if (!fModules[i]) {
+      delete ldcc;
+      return NULL;
+    }
+    ldcc->AddAt(fModules[i]->GetCalibrationSSDModule(), i);
+  }
+  ldcc->Compress();
+  return ldcc;
+}
+
+
+Bool_t AliITSHandleDaSSD::SaveCalibrationSSDLDC(string& dafname) const
+{
+  ostringstream   dadatafilename;
+  TObjArray      *ldcc;
+  if (!fModules) return kFALSE;
+  ldcc = new TObjArray(fNumberOfModules, 0);
+  for (Int_t i = 0; i < fNumberOfModules; i++) {
+    if (!fModules[i]) {
+      delete ldcc;
+      return kFALSE;
+    }
+    ldcc->AddAt(fModules[i]->GetCalibrationSSDModule(), i);
+  }
+  ldcc->Compress();
+  dadatafilename << dafname << "/ITSSSDda_" << fLdcId << "_" << fRunId << ".root";
+  dafname = dadatafilename.str();
+  TFile *fileRun = new TFile (dadatafilename.str().data(),"RECREATE");
+  if (fileRun->IsZombie()) {
+    Error("AliITSHandleDaSSD", "SaveCalibrationSSDLDC() error open file %s", dadatafilename.str().data());
+    ldcc->Delete();
+    delete fileRun;
+    return kFALSE;
+  }
+  fileRun->WriteTObject(ldcc);
+  fileRun->Close();
+  ldcc->Delete();
+  delete fileRun;
+  return kTRUE;
+}
diff --git a/ITS/AliITSHandleDaSSD.h b/ITS/AliITSHandleDaSSD.h
new file mode 100644 (file)
index 0000000..0854086
--- /dev/null
@@ -0,0 +1,65 @@
+#ifndef ALIITSHANDLEDASSD_H
+#define ALIITSHANDLEDASSD_H
+
+#include <math.h>
+#include <sstream>
+#include <string>
+#include "TObject.h"
+#include "TFile.h"
+#include "TObjArray.h"
+#include "AliRawReaderDate.h"
+
+#include "AliITSChannelDaSSD.h"
+#include "AliITSModuleDaSSD.h"
+
+#ifndef PHYSICS_EVENT
+#define PHYSICS_EVENT 7
+#endif
+
+class AliITSHandleDaSSD : public TObject {
+  public :
+    AliITSHandleDaSSD();
+    explicit AliITSHandleDaSSD(const Int_t numberofmodules);
+    AliITSHandleDaSSD(const AliITSHandleDaSSD& ssdadldc);
+    AliITSHandleDaSSD& operator = (const AliITSHandleDaSSD& ssdadldc);
+    virtual ~AliITSHandleDaSSD();
+
+    Int_t        GetNumberOfModules() const { return fNumberOfModules; }
+
+    AliITSModuleDaSSD* GetModule (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const;
+    AliITSModuleDaSSD* GetModule (const Int_t index) const 
+                               {if ((fModules) && (index < fNumberOfModules)) return fModules[index]; else return NULL;}
+    AliITSChannelDaSSD* GetStrip (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t stripID) const;
+    TObjArray*  GetCalibrationSSDLDC()  const;
+    Bool_t      SaveCalibrationSSDLDC(std::string& dafname) const;
+    
+    Bool_t  SetNumberOfModules (const Int_t numberofmodules);
+    Bool_t  SetModule(AliITSModuleDaSSD *const module, const Int_t index); 
+    Bool_t  ReadCalibrationDataFile (const char* fileName, const Long_t eventsnumber);
+
+    virtual Bool_t  CalculatePedestal();
+    virtual Bool_t  CalculateNoise();
+    virtual Bool_t  CalculateNoiseCM();
+
+    void    DeleteSignal() { if (fModules) for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) fModules[i]->DeleteSignal();}
+
+    static Int_t GetNumberOfSSDModulesConst() { return fgkNumberOfSSDModules; }
+
+  protected :
+    static const Int_t fgkNumberOfSSDModules = 1698;
+
+    Int_t                fNumberOfModules;       // number of AliITSModuleDaSSD to allocate
+    AliITSModuleDaSSD  **fModules;               //[fNumberOfModules]  array of all SSD 1698 Modules (2608128 strips)
+    UInt_t               fLdcId;                 //  LDC number, read from header
+    UInt_t               fRunId;                 //  Run number, read from header
+
+  private :
+    Bool_t   CalculateCM(const Int_t modind, const Int_t stripind, Float_t* const cm);
+    Bool_t   RelocateModules();
+    Bool_t   SignalOutOfRange (const Short_t signal) const { return (signal >= AliITSChannelDaSSD::GetOverflowConst()); }
+
+    ClassDef(AliITSHandleDaSSD, 1)
+
+};
+
+#endif
diff --git a/ITS/AliITSModuleDaSSD.cxx b/ITS/AliITSModuleDaSSD.cxx
new file mode 100644 (file)
index 0000000..e8c10e8
--- /dev/null
@@ -0,0 +1,222 @@
+
+
+#include "AliITSModuleDaSSD.h"
+
+ClassImp(AliITSModuleDaSSD)
+
+using namespace std;
+
+AliITSModuleDaSSD::AliITSModuleDaSSD() :
+  fEquipId(0),
+  fEquipType(0),
+  fDdlId(0),
+  fAd(0),
+  fAdc(0),
+  fModuleId(0),
+  fNumberOfStrips(0),
+  fStrips(NULL),
+  fEventsNumber(0)
+{
+}
+
+
+AliITSModuleDaSSD::AliITSModuleDaSSD(const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t moduleID) :
+  fEquipId(0),
+  fEquipType(0),
+  fDdlId(ddlID),
+  fAd(ad),
+  fAdc(adc),
+  fModuleId(moduleID),
+  fNumberOfStrips(0),
+  fStrips(NULL),
+  fEventsNumber(0)
+{
+}
+
+
+
+AliITSModuleDaSSD::AliITSModuleDaSSD(const Int_t numberofstrips) :
+  fEquipId(0),
+  fEquipType(0),
+  fDdlId(0),
+  fAd(0),
+  fAdc(0),
+  fModuleId(0),
+  fNumberOfStrips(0),
+  fStrips(NULL),
+  fEventsNumber(0)
+{
+  if (numberofstrips != fgkStripsPerModule) 
+    Warning("AliITSModuleDaSSD", "ALICE ITS SSD Module contains %d strips", fgkStripsPerModule);
+  try  {
+     fStrips = new AliITSChannelDaSSD* [numberofstrips];
+     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);
+     fNumberOfStrips = 0;
+     fStrips = NULL;
+  }
+}
+
+
+AliITSModuleDaSSD::AliITSModuleDaSSD(const Int_t numberofstrips, const Long_t eventsnumber) :
+  fEquipId(0),
+  fEquipType(0),
+  fDdlId(0),
+  fAd(0),
+  fAdc(0),
+  fModuleId(0),
+  fNumberOfStrips(0),
+  fStrips(NULL),
+  fEventsNumber(0)
+{
+  if (numberofstrips != fgkStripsPerModule) 
+    Warning("AliITSModuleDaSSD", "ALICE ITS SSD Module contains %d strips", fgkStripsPerModule);
+  try  {
+     fStrips = new AliITSChannelDaSSD* [numberofstrips];
+     fNumberOfStrips = numberofstrips;
+  }
+  catch (bad_alloc&) {
+     Error("AliITSModuleDaSSD", "Error allocating memory for %d 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),
+  fEquipType(module.fEquipType),
+  fDdlId(module.fDdlId),
+  fAd(module.fAd),
+  fAdc(module.fAdc),
+  fModuleId(module.fModuleId),
+  fNumberOfStrips(module.fNumberOfStrips),
+  fStrips(module.fStrips),
+  fEventsNumber(module.fEventsNumber)
+{
+  // copy constructor
+
+  Fatal("AliITSModuleDaSSD", "copy constructor not implemented");
+}
+
+
+
+AliITSModuleDaSSD& AliITSModuleDaSSD::operator = (const AliITSModuleDaSSD& module)
+{
+// assignment operator
+
+  Fatal("AliITSModuleDaSSD: operator =", "assignment operator not implemented");
+  return *this;
+}
+    
+
+    
+AliITSModuleDaSSD::~AliITSModuleDaSSD()
+{
+  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;
+  } 
+}
+
+
+  
+Bool_t AliITSModuleDaSSD::SetModuleIdData (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t moduleID)
+{
+  if (ad > fgkMaxAdNumber) {
+    Warning("AliITSModuleDaSSD", "Wrong AD number: %i", ad);
+    return kFALSE;
+  }  
+  if (adc > fgkMaxAdcNumber || ForbiddenAdcNumber(adc)) {
+    Warning("AliITSModuleDaSSD", "Wrong ADC number: %i", adc);
+    return kFALSE;
+  }  
+  fDdlId = ddlID;
+  fAd = ad;
+  fAdc = adc;
+  fModuleId = moduleID;
+  return kTRUE;
+}
+
+
+
+void AliITSModuleDaSSD::SetModuleFEEId (const UChar_t ddlID, const UChar_t ad, const UChar_t adc)
+{
+  fDdlId = ddlID;
+  fAd = ad;
+  fAdc = adc;
+}
+
+
+void AliITSModuleDaSSD::SetModuleRorcId (const Int_t equipid, const Int_t equiptype)
+{
+  fEquipId = equipid; 
+  fEquipType = equiptype;
+}
+
+
+Bool_t AliITSModuleDaSSD::SetEventsNumber(const Long_t eventsnumber)
+{
+  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;
+  }
+  return kTRUE;
+}
+
+
+
+AliITSNoiseSSD* AliITSModuleDaSSD::GetCalibrationSSDModule() const
+{
+  AliITSNoiseSSD  *mc;
+  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 (i < fgkPNStripsPerModule)
+          mc->AddNoiseP(i, fStrips[i]->GetNoise());
+    else  mc->AddNoiseN((i - fgkPNStripsPerModule), fStrips[i]->GetNoise());                     
+  }
+  return mc;
+}
diff --git a/ITS/AliITSModuleDaSSD.h b/ITS/AliITSModuleDaSSD.h
new file mode 100644 (file)
index 0000000..7e8bda2
--- /dev/null
@@ -0,0 +1,73 @@
+#ifndef ALIITSMODULEDASSD_H
+#define ALIITSMODULEDASSD_H
+
+
+#include <iostream>
+#include "TObject.h"
+#include "AliITSNoiseSSD.h"
+
+#include "AliITSChannelDaSSD.h"
+
+class AliITSModuleDaSSD : public TObject {
+  public :
+    AliITSModuleDaSSD();
+    AliITSModuleDaSSD(const Int_t numberofstrips);
+    AliITSModuleDaSSD(const Int_t numberofstrips, const Long_t eventsnumber);
+    AliITSModuleDaSSD(const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t moduleID);
+    AliITSModuleDaSSD(const AliITSModuleDaSSD& module);
+    AliITSModuleDaSSD& operator = (const AliITSModuleDaSSD& module);
+    virtual ~AliITSModuleDaSSD();
+    
+    UChar_t      GetDdlId()    const { return fDdlId; }
+    UChar_t      GetAD()       const { return fAd; }
+    UChar_t      GetADC()      const { return fAdc; }
+    UShort_t     GetModuleId() const { return fModuleId; }
+    Int_t        GetModuleRorcEquipId()   const { return fEquipId; }
+    Int_t        GetModuleRorcEquipType() const { return fEquipType; }
+    Int_t        GetNumberOfStrips() const { return fNumberOfStrips; }
+    Long_t       GetEventsNumber()   const { return fEventsNumber; }
+//    AliITSChannelDaSSD*  GetStrip()  const { return fStrips; }
+    AliITSChannelDaSSD*  GetStrip(const Int_t stripnumber)  const 
+                                { return (fStrips) ? fStrips[stripnumber] : NULL; }
+
+    AliITSNoiseSSD* GetCalibrationSSDModule() const;
+    
+    Bool_t  SetEventsNumber(const Long_t eventsnumber);
+    Bool_t  SetModuleIdData (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const UShort_t moduleID);
+    void    SetModuleFEEId (const UChar_t ddlID, const UChar_t ad, const UChar_t adc);
+    void    SetModuleRorcId (const Int_t equipid, const Int_t equiptype);
+    void    SetModuleId (const UShort_t moduleID) { fModuleId = moduleID; }
+    void    SetStrip(AliITSChannelDaSSD* strip, const Int_t strID) { if ((fStrips) && (strID <= fNumberOfStrips)) fStrips[strID] = strip; }
+    void    DeleteSignal() {if (fStrips) for (Int_t i = 0; i < fNumberOfStrips; i++) 
+                                            if (fStrips[i]) fStrips[i]->DeleteSignal(); fEventsNumber = 0; }
+    static Int_t GetStripsPerModuleConst() { return  fgkStripsPerModule;  }
+    static Int_t GetPNStripsPerModule()    { return  fgkPNStripsPerModule;}
+    static Int_t GetStripsPerChip()        { return  fgkStripsPerChip;    }
+
+  protected :
+    static const Int_t   fgkStripsPerModule   = 1536;
+    static const Int_t   fgkPNStripsPerModule = 768;
+    static const Int_t   fgkStripsPerChip     = 128;
+    static const UChar_t fgkMaxAdNumber       = 9;
+    static const UChar_t fgkMaxAdcNumber      = 13;
+
+    Int_t          fEquipId;        // required to access to rorc
+    Int_t          fEquipType;
+    UChar_t        fDdlId;          // index of DDL, ITS SSD: 33-48
+    UChar_t        fAd;             // index of AD module     0-9
+    UChar_t        fAdc;            // index of ADC module    0-5, 8-13
+    UShort_t       fModuleId;       // Module number          0-1697
+    
+    Int_t                 fNumberOfStrips;
+    AliITSChannelDaSSD  **fStrips;         //[fNumberOfStrips]  Array of *AliITSChannelDaSSD
+
+    Long_t            fEventsNumber;       // number of events for fsignal memory allocation
+
+  private:
+    Bool_t ForbiddenAdcNumber (const UChar_t adcn) const { return ((adcn == 6) || (adcn == 7)); }
+    ClassDef(AliITSModuleDaSSD, 1) 
+};
+
+#endif
diff --git a/ITS/ITSSSDPEDda.cxx b/ITS/ITSSSDPEDda.cxx
new file mode 100644 (file)
index 0000000..35c1e70
--- /dev/null
@@ -0,0 +1,146 @@
+
+#include <iostream>
+#include <sstream>
+#include <string>
+#include "TFile.h"
+#include "daqDA.h"
+//#include "AliITSChannelDaSSD.h" 
+#include "AliITSHandleDaSSD.h" 
+
+using namespace std;
+
+Bool_t GetRunSettings (const char *datafilename, Long_t &eventsnumber, Long_t &stripsnumber);
+
+int main( int argc, char** argv )
+{
+  AliITSHandleDaSSD  *ssddaldc;
+  ostringstream       feefname;
+  Int_t               status;
+  string              dafname;
+  Char_t             *dadaqdir = NULL;
+
+  /* check that we got some arguments = list of files */
+  if (argc<2) {
+    printf("Wrong number of arguments\n");
+    return -1;
+  }
+
+  char *datafilename = argv[1];
+
+  Long_t strn, evn;
+  if (!GetRunSettings (datafilename, evn, strn))
+  {
+    cout << "Error GetRunSettings (datafilename, evn, strn)!" << endl;
+    return -1;
+  }
+  cout << "Pysics events : " << evn << ";   Total strip number : " << strn 
+       << ";   Modules number: " << strn / AliITSModuleDaSSD::GetStripsPerModuleConst() << endl;
+  
+  ssddaldc = new AliITSHandleDaSSD();
+//  if (!ssddaldc->SetNumberOfModules((Int_t)(strn / AliITSModuleDaSSD::GetStripsPerModuleConst())))
+  if (!ssddaldc->SetNumberOfModules(AliITSHandleDaSSD::GetNumberOfSSDModulesConst()))
+  {
+     cout << "Error ssddaldc->SetNumberOfModules" << endl;
+     delete ssddaldc;
+     return -1;
+  }  
+  if (!ssddaldc->ReadCalibrationDataFile(datafilename, evn))
+  {
+     cout << "Error !ssddaldc->ReadCalibrationDataFile" << endl;
+     delete ssddaldc;
+     return -1;
+  }  
+  daqDA_progressReport(30);
+//  if (daqDA_checkShutdown() == 1) {
+//    cout << "Shutdown has been requested!" << endl;
+//    delete ssddaldc;
+//    return -1;
+//  }
+
+  if (!ssddaldc->CalculatePedestal()) {
+    cout << "Error, ssddaldc->CalculatePedestal()";
+    return 1; 
+  } 
+  daqDA_progressReport(50);
+  if (!ssddaldc->CalculateNoiseCM()) {
+    cout << "Error, ssddaldc->CalculateNoiseCM()";
+    return 2; 
+  } 
+  ssddaldc->DeleteSignal();
+  daqDA_progressReport(90);
+  dadaqdir = getenv ("DAQDA_TEST_DIR");
+  if (dadaqdir) {
+    dafname = dadaqdir;
+    if (!(ssddaldc->SaveCalibrationSSDLDC(dafname))) 
+      cout << "Error saving DA data to the file! Probably $DAQDA_TEST_DIR defined incorrectly!" << endl;
+    else cout << "SSDDA data are saved in " << dafname << endl;
+      feefname << dadaqdir << "/ssddaldc.root";
+    cout << "Saving feessdda data in " << feefname.str() << endl;
+    TFile *fileRun = new TFile (feefname.str().data(),"RECREATE");
+    ssddaldc->Write();
+    fileRun->Close();
+    delete fileRun;
+    status = daqDA_FES_storeFile(dafname.data(),"DASSD_DB_results");
+    if (status) printf("Failed to export file : %d\n",status);
+  }
+  else cout << "Error: DAQDA_TEST_DIR is not defined, DA data are not saved!" << endl;
+  delete ssddaldc;
+  daqDA_progressReport(100);
+  return 0;
+}
+
+
+
+Bool_t GetRunSettings (const char *datafilename, Long_t &eventsnumber, Long_t &stripsnumber)
+{
+  Long_t physeventind = 0, strn = 0, strneq = 0;
+  AliRawReaderDate  *rawreaderdate = NULL;
+  Int_t *data = NULL;
+  Long_t datasize = 0, eqdatasize = 0, eqbelsize = 1;
+  rawreaderdate = new AliRawReaderDate(datafilename, 0);
+  if (!rawreaderdate) {
+    cout << "GetRunSettings : Error  new DARawReader(datafilename, 0);" << endl;
+    return kFALSE;
+  }  
+  rawreaderdate->SelectEvents(PHYSICS_EVENT);
+  while (rawreaderdate->NextEvent())
+  { 
+    physeventind += 1;
+    datasize = 0;
+    strn = 0;
+    while (rawreaderdate->ReadNextData((UChar_t*&)data)) {
+      eqdatasize = rawreaderdate->GetDataSize();
+      eqbelsize = rawreaderdate->GetEquipmentElementSize();
+      if ( (eqdatasize % eqbelsize) || (eqbelsize != sizeof(long32)) ) {
+        cout << "Error ReadCalibrationDataFile: equipment event data size " << eqdatasize  
+            << " is not an integer of equipment data size "      << eqbelsize << endl;
+       rawreaderdate->DumpData();
+        return kFALSE;
+      }
+      strneq = eqdatasize / eqbelsize;
+      datasize += eqdatasize;
+      strn += strneq;
+    }  
+    if ((strn * eqbelsize != datasize)) {
+      if (physeventind != 1) {
+        cout << "Something is wrong with data file, strip number changes from event to event! Ev = " << physeventind << endl;
+        rawreaderdate->DumpData();
+        return kFALSE;
+      }
+      if ((datasize % eqbelsize)) {
+        cout << "Wrong number :  (datasize % eqbelsize) != 0" << endl;
+        rawreaderdate->DumpData();
+        return kFALSE;
+      }
+      strneq = datasize / eqbelsize;
+    }
+  }
+  delete rawreaderdate;
+  if ((physeventind > 0) && (strn > 0))
+  {
+    eventsnumber = physeventind;
+    stripsnumber = strn;
+    return kTRUE;
+  }
+  return kFALSE;
+}
index 1a53c44..943ace3 100644 (file)
@@ -55,6 +55,9 @@
 #pragma link C++ class  AliITSBadChannelsSSD+;
 #pragma link C++ class  AliITSGainSSD+;
 #pragma link C++ class  AliITSNoiseSSD+;
+#pragma link C++ class  AliITSHandleDaSSD+;
+#pragma link C++ class  AliITSModuleDaSSD+;
+#pragma link C++ class  AliITSChannelDaSSD+;
 #pragma link C++ class  AliITSpList+;
 #pragma link C++ class  AliITSpListItem+;
 
index 795b58f..1aa32b7 100644 (file)
@@ -32,6 +32,9 @@ SRCS =        AliITSgeom.cxx \
                AliITSBadChannelsSSD.cxx \
                AliITSGainSSD.cxx \
                AliITSNoiseSSD.cxx \
+               AliITSChannelDaSSD.cxx \
+                AliITSModuleDaSSD.cxx \
+                AliITSHandleDaSSD.cxx \
                AliITSDDLRawData.cxx \
                AliITSRawStream.cxx \
                AliITSRawStreamSDDv2.cxx \