new version of SSD DA and related classes (O. Borysov)
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 27 Nov 2007 17:08:01 +0000 (17:08 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 27 Nov 2007 17:08:01 +0000 (17:08 +0000)
ITS/AliITSChannelDaSSD.cxx
ITS/AliITSChannelDaSSD.h
ITS/AliITSHandleDaSSD.cxx
ITS/AliITSHandleDaSSD.h
ITS/AliITSModuleDaSSD.cxx
ITS/AliITSModuleDaSSD.h
ITS/ITSSSDPEDda.cxx

index dbc6910..eda6039 100644 (file)
 
 #include <Riostream.h>
 #include "AliITSChannelDaSSD.h"
+#include "TString.h"
+#include "AliLog.h"
 
 ClassImp(AliITSChannelDaSSD)
 
 using namespace std;
 
+const Short_t AliITSChannelDaSSD::fgkMinStripId = 0;               // minimum strip id
+const Short_t AliITSChannelDaSSD::fgkMaxStripId = 1535;            // maximum strip id
+
+const Short_t  AliITSChannelDaSSD::fgkSignalOverflow  = 2047;      // ADC overflow value
+const Short_t  AliITSChannelDaSSD::fgkSignalUnderflow = 2048;      // ADC underflow value
+const UShort_t AliITSChannelDaSSD::fgkDefaultSignal   = 0x7F;      // initialization value for fNoise, fPedestal, fSignal[i]
 const Float_t  AliITSChannelDaSSD::fgkUndefinedValue  = 32639.0f;  // = 0x7F7F
 
+
+//______________________________________________________________________________
 AliITSChannelDaSSD::AliITSChannelDaSSD() :
   fStripId(0),
   fEventsNumber(0),
   fSignal(NULL),
   fPedestal(fgkUndefinedValue),
   fNoise(fgkUndefinedValue),
-  fZsThresholdFactor(0.0f)
+  fNoiseCM(fgkUndefinedValue),
+  fNOverflowEv(0)
 {
 // Default costructor
 }
 
 
+//______________________________________________________________________________
 AliITSChannelDaSSD::AliITSChannelDaSSD(const UShort_t stripID) :
   fStripId(stripID),
   fEventsNumber(0),
   fSignal(NULL),
   fPedestal(fgkUndefinedValue),
   fNoise(fgkUndefinedValue),
-  fZsThresholdFactor(0.0f)
+  fNoiseCM(fgkUndefinedValue),
+  fNOverflowEv(0)
 {
 // Costructor, initialize channal id
 }
 
 
+//______________________________________________________________________________
 AliITSChannelDaSSD::AliITSChannelDaSSD(const UShort_t stripID, const Long_t eventsnumber) :
   fStripId(stripID),
   fEventsNumber(0),
   fSignal(NULL),
   fPedestal(fgkUndefinedValue),
   fNoise(fgkUndefinedValue),
-  fZsThresholdFactor(0.0f)
+  fNoiseCM(fgkUndefinedValue),
+  fNOverflowEv(0)
 {
 // Costructor, initialize channal id and allocate array for events data
   if (stripID > fgkMaxStripId)
-    Warning("AliITSChannelDaSSD", "Wrong StripID: %i", stripID);
+    AliWarning(Form("AliITSChannelDaSSD: Wrong StripID: %i", stripID));
   fSignal = new (nothrow) Short_t[eventsnumber];
   if (fSignal) {
     fEventsNumber = eventsnumber;
     memset(fSignal, fgkDefaultSignal, (eventsnumber * sizeof(Short_t)));
   } else {
-    Error("AliITSChannelDaSSD", "Error allocating memory for %i Short_t objects!", eventsnumber);
+    AliError(Form("AliITSChannelDaSSD: Error allocating memory for %i Short_t objects!", eventsnumber));
     fSignal = NULL;
     fEventsNumber = 0;
   }
@@ -80,6 +95,7 @@ AliITSChannelDaSSD::AliITSChannelDaSSD(const UShort_t stripID, const Long_t even
 
 
 
+//______________________________________________________________________________
 AliITSChannelDaSSD::AliITSChannelDaSSD(const AliITSChannelDaSSD& strip) :
   TObject(strip),
   fStripId(strip.fStripId),
@@ -87,22 +103,27 @@ AliITSChannelDaSSD::AliITSChannelDaSSD(const AliITSChannelDaSSD& strip) :
   fSignal(strip.fSignal),
   fPedestal(strip.fPedestal),
   fNoise(strip.fNoise),
-  fZsThresholdFactor(strip.fZsThresholdFactor)
+  fNoiseCM(strip.fNoiseCM),
+  fNOverflowEv(strip.fNOverflowEv)
 {
   // copy constructor
 
-  Fatal("AliITSChannelDaSSD", "copy constructor not implemented");
+  AliFatal("AliITSChannelDaSSD, copy constructor not implemented");
 }
 
+
+
+//______________________________________________________________________________
 AliITSChannelDaSSD& AliITSChannelDaSSD::operator = (const AliITSChannelDaSSD& strip)
 {
 // assignment operator
 
-  Fatal("operator =", "assignment operator not implemented");
+  AliFatal("operator =, assignment operator not implemented");
   return *this;
 }
 
 
+//______________________________________________________________________________
 AliITSChannelDaSSD::~AliITSChannelDaSSD()
 {
 // Destructor
@@ -113,6 +134,7 @@ AliITSChannelDaSSD::~AliITSChannelDaSSD()
 }
 
 
+//______________________________________________________________________________
 Bool_t AliITSChannelDaSSD::SetEvenetsNumber(const Long_t eventsnumber)
 {
 // Allocate array for events data
@@ -123,7 +145,7 @@ Bool_t AliITSChannelDaSSD::SetEvenetsNumber(const Long_t eventsnumber)
     memset(fSignal, fgkDefaultSignal, (eventsnumber * sizeof(Short_t)));
     return kTRUE;
   } else {
-    Error("AliITSChannelDaSSD", "Error allocating memory for %i Short_t objects!", eventsnumber);
+    AliError(Form("AliITSChannelDaSSD: Error allocating memory for %i Short_t objects!", eventsnumber));
     fSignal = NULL;
     fEventsNumber = 0;
     return kFALSE;
@@ -131,7 +153,7 @@ Bool_t AliITSChannelDaSSD::SetEvenetsNumber(const Long_t eventsnumber)
 }
 
 
-
+//______________________________________________________________________________
 Bool_t AliITSChannelDaSSD::SetSignal(const Long_t eventnumber, const Short_t signal)
 {
 // put signal value to array 
index c6e7a5b..b2cb149 100644 (file)
@@ -33,19 +33,22 @@ class AliITSChannelDaSSD : public TObject {
                                 { 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; }
+    Float_t  GetNoise()    const { return fNoise;    }
+    Float_t  GetNoiseCM()  const { return fNoiseCM;  }
+    Long_t   GetOverflowNumber() const { return fNOverflowEv; }
+    Bool_t   CheckNoise()   const { return (fNoise < fgkUndefinedValue) ? kTRUE : kFALSE; }
+    Bool_t   CheckNoiseCM() const { return (fNoiseCM < 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      SetNoise(Float_t noise)   { fNoise = noise; }
+    void      SetNoiseCM(Float_t noise) { fNoiseCM = noise; }
+    void      SetOverflowNumber(Long_t ovn) {fNOverflowEv = ovn; }
     void      ClearNoise() { if (fNoise < fgkUndefinedValue) fNoise = fgkUndefinedValue; }
+    void      ClearNoiseCM() { if (fNoiseCM < fgkUndefinedValue) fNoiseCM = 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; }
@@ -54,26 +57,27 @@ class AliITSChannelDaSSD : public TObject {
     static  Short_t  GetOverflowConst()  { return fgkSignalOverflow;  }
     static  Short_t  GetUnderflowConst() { return fgkSignalUnderflow; }
     static  Float_t  GetUndefinedValue() { return fgkUndefinedValue;  }
+    static  Short_t  GetMaxStripIdConst(){ return fgkMaxStripId;      }
 
   protected :
-    static const UShort_t fgkMinStripId = 0;              // minimum strip id
-    static const UShort_t fgkMaxStripId = 1535;           // maximum strip id
+    static const Short_t fgkMinStripId;         // minimum strip id
+    static const Short_t fgkMaxStripId;         // maximum strip id
 
-    static const Short_t  fgkSignalOverflow  = 2047;      // ADC overflow value
-    static const Short_t  fgkSignalUnderflow = 2048;      // ADC underflow value
-    static const UShort_t fgkDefaultSignal   = 0x7F;      // initialization value for fNoise, fPedestal, fSignal[i]
-    static const Float_t  fgkUndefinedValue;              // constant value which indicates that fNoise, fPedestal is undefined
+    static const Short_t  fgkSignalOverflow;     // ADC overflow value
+    static const Short_t  fgkSignalUnderflow;    // ADC underflow value
+    static const UShort_t fgkDefaultSignal;      // initialization value for fNoise, fPedestal, fSignal[i]
+    static const Float_t  fgkUndefinedValue;     // constant value which indicates that fNoise, fPedestal is undefined
   
     UShort_t          fStripId;             //  channel = strip number within SSD module 0-1535
     Long_t            fEventsNumber;        //  number of events for fSignal memory allocation
-    Short_t          *fSignal;              //! 
+    Short_t          *fSignal;              //! array of signal data
     
     Float_t           fPedestal;            //  pedestal
     Float_t           fNoise;               //  noise
-    Float_t           fZsThresholdFactor;   //  factor for zero suppression threshold
-
-    ClassDef(AliITSChannelDaSSD, 1)
+    Float_t           fNoiseCM;             //  noise with CM correction
+    Long_t            fNOverflowEv;         //  Number of events which exceed the pedestal calculation threshold
+                     
+    ClassDef(AliITSChannelDaSSD, 2)
 };
 
 #endif
index 2f39fb0..63c82b0 100644 (file)
 #include <Riostream.h> 
 #include "AliITSHandleDaSSD.h"
 #include <math.h>
-#include <sstream>
-#include <string>
+#include <limits.h>
 #include "event.h"
 #include "TFile.h"
+#include "TString.h"
 #include "TObjArray.h"
+#include "AliLog.h"
 #include "AliITSNoiseSSD.h"
+#include "AliITSRawStreamSSD.h"
 #include "AliRawReaderDate.h"
 
 #include "AliITSChannelDaSSD.h"
@@ -41,59 +43,76 @@ ClassImp(AliITSHandleDaSSD)
 using namespace std;
 
 
+const Int_t    AliITSHandleDaSSD::fgkNumberOfSSDModules = 1698;       // Number of SSD modules in ITS
+const Int_t    AliITSHandleDaSSD::fgkNumberOfSSDModulesPerDdl = 108;  // Number of SSD modules in ITS
+const Float_t  AliITSHandleDaSSD::fgkPedestalThresholdFactor = 3.0;   // Defalt value for fPedestalThresholdFactor 
+const Float_t  AliITSHandleDaSSD::fgkCmThresholdFactor = 3.0;         // Defalt value for fCmThresholdFactor
+
+//______________________________________________________________________________
 AliITSHandleDaSSD::AliITSHandleDaSSD() :
+  fRawDataFileName(NULL),
   fNumberOfModules(0),
   fModules(NULL),
+  fModIndProcessed(0),
+  fModIndRead(0),
+  fNumberOfEvents(0),
   fLdcId(0),
-  fRunId(0)
+  fRunId(0),
+  fPedestalThresholdFactor(fgkPedestalThresholdFactor),
+  fCmThresholdFactor(fgkCmThresholdFactor) 
 {
 // Default constructor
 }
 
 
-AliITSHandleDaSSD::AliITSHandleDaSSD(const Int_t numberofmodules) :
+//______________________________________________________________________________
+AliITSHandleDaSSD::AliITSHandleDaSSD(Char_t *rdfname) :
+  fRawDataFileName(NULL),
   fNumberOfModules(0),
   fModules(NULL),
+  fModIndProcessed(0),
+  fModIndRead(0),
+  fNumberOfEvents(0),
   fLdcId(0),
-  fRunId(0)
+  fRunId(0),
+  fPedestalThresholdFactor(fgkPedestalThresholdFactor) ,
+  fCmThresholdFactor(fgkCmThresholdFactor) 
 {
-// Constructor allocates memory for AliITSModuleDaSSD objects
-  if (numberofmodules > fgkNumberOfSSDModules) 
-      cout << "ALICE ITS SSD contains " <<  fgkNumberOfSSDModules << "modules!"<< endl;
-  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;
-  }
+  if (!Init(rdfname)) AliError("AliITSHandleDaSSD::AliITSHandleDaSSD() initialization error!");
 }
 
 
+//______________________________________________________________________________
 AliITSHandleDaSSD::AliITSHandleDaSSD(const AliITSHandleDaSSD& ssdadldc) :
   TObject(ssdadldc),
+  fRawDataFileName(ssdadldc.fRawDataFileName),
   fNumberOfModules(ssdadldc.fNumberOfModules),
   fModules(ssdadldc.fModules),
+  fModIndProcessed(ssdadldc.fModIndProcessed),
+  fModIndRead(ssdadldc.fModIndRead),
+  fNumberOfEvents(ssdadldc.fNumberOfEvents),
   fLdcId(ssdadldc.fLdcId),
-  fRunId(ssdadldc.fRunId)
+  fRunId(ssdadldc.fRunId),
+  fPedestalThresholdFactor(ssdadldc.fPedestalThresholdFactor),
+  fCmThresholdFactor(ssdadldc.fCmThresholdFactor) 
 {
   // copy constructor
 
-  Fatal("AliITSHandleDaSSD", "copy constructor not implemented");
+  AliFatal("AliITSHandleDaSSD, copy constructor not implemented");
 }
 
 
+//______________________________________________________________________________
 AliITSHandleDaSSD& AliITSHandleDaSSD::operator = (const AliITSHandleDaSSD& ssdadldc)
 {
 // assignment operator
 
-  Fatal("operator =", "assignment operator not implemented");
+  AliFatal("operator =, assignment operator not implemented");
   return *this;
 }
 
 
+//______________________________________________________________________________
 AliITSHandleDaSSD::~AliITSHandleDaSSD()
 {
 // Default destructor 
@@ -109,6 +128,101 @@ AliITSHandleDaSSD::~AliITSHandleDaSSD()
 
 
 
+//______________________________________________________________________________
+void AliITSHandleDaSSD::Reset()
+{
+// Delete array of AliITSModuleDaSSD* objects. 
+  if (fModules) {
+    for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i];
+    delete [] fModules;
+    fModules = NULL;
+  }  
+  fRawDataFileName = NULL;
+  fModIndProcessed = fModIndRead = 0;
+  fNumberOfEvents = 0;
+  fLdcId = fRunId = 0;
+  fPedestalThresholdFactor = fgkPedestalThresholdFactor;
+  fCmThresholdFactor = fgkCmThresholdFactor;
+}
+
+
+
+//______________________________________________________________________________
+Bool_t AliITSHandleDaSSD::Init(Char_t *rdfname, const Char_t *configfname)
+{
+// Read raw data file and set initial and configuration parameters
+  Long_t physeventind = 0, strn = 0, nofstripsev, nofstrips = 0;
+  Int_t  nofeqipmentev, nofeqipment = 0, eqn = 0; 
+  AliRawReaderDate  *rawreaderdate = NULL;
+  UChar_t *data = NULL;
+  Long_t datasize = 0, eqbelsize = 1;
+
+  if (configfname) ReadConfigurationFile(configfname);
+  rawreaderdate = new AliRawReaderDate(rdfname, 0);
+  if (!(rawreaderdate->GetAttributes() || rawreaderdate->GetEventId())) {
+    AliError(Form("AliITSHandleDaSSD: Error reading raw data file %s by RawReaderDate", rdfname));
+    MakeZombie();
+    return kFALSE;
+  }  
+  if (rawreaderdate->NextEvent()) {
+    fLdcId = rawreaderdate->GetLDCId();
+    fRunId = rawreaderdate->GetRunNumber(); 
+    rawreaderdate->RewindEvents();
+  } else { MakeZombie(); return kFALSE; }
+  if (fModules) Reset();
+  rawreaderdate->SelectEvents(-1);
+  nofstrips = 0;
+  while (rawreaderdate->NextEvent()) {
+    if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
+    nofstripsev = 0;
+    nofeqipmentev = 0;
+    while (rawreaderdate->ReadNextData(data)) {
+      nofeqipmentev += 1;
+      datasize = rawreaderdate->GetDataSize();
+      eqbelsize = rawreaderdate->GetEquipmentElementSize();
+      if ( (datasize % eqbelsize) || (eqbelsize != sizeof(long32)) ) {
+        AliError(Form("AliITSHandleDaSSD: Error Init(%s): event data size %i is not an integer of equipment data size %i", 
+                                   rdfname, datasize, eqbelsize));
+        MakeZombie();
+       return kFALSE;
+      }
+      nofstripsev += (Int_t) (datasize / eqbelsize);            
+    }
+    if (physeventind++) {
+      if (nofstrips != nofstripsev) AliWarning("AliITSHandleDaSSD: number of strips varies from event to evnt");
+      if (nofeqipment != nofeqipmentev) AliWarning("AliITSHandleDaSSD: number of DDLs varies from event to evnt");
+    }
+    nofstrips = nofstripsev;
+    nofeqipment = nofeqipmentev;
+    if (strn < nofstrips) strn = nofstrips;
+    if (eqn < nofeqipment) eqn = nofeqipment;
+  }
+  delete rawreaderdate;
+  if ((physeventind > 0) && (strn > 0))
+  {
+    fNumberOfEvents = physeventind;
+    fRawDataFileName = rdfname;
+    if (SetNumberOfModules(fgkNumberOfSSDModules)) {
+      TString str = Form("Max number of equipment: %i, max number of channels: %i\n", eqn, strn);
+      DumpInitData(str.Data());
+      return kTRUE;
+    }  
+  }
+  MakeZombie();
+  return kFALSE;
+}
+
+
+//______________________________________________________________________________
+Bool_t AliITSHandleDaSSD::ReadConfigurationFile(const Char_t *configfname) 
+const {
+// Dowload configuration parameters from configuration file or database
+  return kFALSE;
+}
+
+
+
+//______________________________________________________________________________
 AliITSModuleDaSSD* AliITSHandleDaSSD::GetModule (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
 {
 // Retrieve AliITSModuleDaSSD object from the array
@@ -125,7 +239,24 @@ AliITSModuleDaSSD* AliITSHandleDaSSD::GetModule (const UChar_t ddlID, const UCha
 }
 
 
+Int_t AliITSHandleDaSSD::GetModuleIndex (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
+{
+// Retrieve the position of AliITSModuleDaSSD object in the array
+   if (!fModules) return -1;
+   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 i;
+     }     
+   }
+   return -1;
+}
+
+
 
+//______________________________________________________________________________
 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
@@ -137,12 +268,14 @@ AliITSChannelDaSSD* AliITSHandleDaSSD::GetStrip (const UChar_t ddlID, const UCha
        return fModules[modind]->GetStrip(stripID);
     }
   }
-  Error("AliITSHandleDaSSD", "Error GetStrip (%i, %i, %i, %i), strip not found, returns NULL!", ddlID, ad, adc, stripID);
+  AliError(Form("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)
 { 
 // Assign array element with AliITSModuleDaSSD object
@@ -156,19 +289,26 @@ Bool_t AliITSHandleDaSSD::SetModule(AliITSModuleDaSSD *const module, const Int_t
 }
 
 
+
+//______________________________________________________________________________
 Bool_t AliITSHandleDaSSD::SetNumberOfModules (const Int_t 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; }
+    AliWarning(Form("AliITSHandleDaSSD: the number of modules %i you use exceeds the maximum %i for ALICE ITS SSD", 
+                     numberofmodules, fgkNumberOfSSDModules));
+  if (fModules) {
+    for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i];
+    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);
+     AliError(Form("AliITSHandleDaSSD: Error allocating memory for %i AliITSModulesDaSSD* objects!", numberofmodules));
      fNumberOfModules = 0;
      fModules = NULL;
   }
@@ -176,35 +316,40 @@ Bool_t AliITSHandleDaSSD::SetNumberOfModules (const Int_t numberofmodules)
 }
 
 
-Bool_t AliITSHandleDaSSD::ReadCalibrationDataFile (const char* fileName, const Long_t eventsnumber)
+
+//______________________________________________________________________________
+Bool_t AliITSHandleDaSSD::ReadCalibrationDataFile (char* fileName, const Long_t eventsnumber)
 {
 // Reads raw data from file
-  AliRawReaderDate    *rawreaderdate = new AliRawReaderDate(fileName, 0);
+  AliRawReaderDate    *rawreaderdate = NULL;
   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");
+  UChar_t          *databyte;
+  if (!Init(fileName)){
+    AliError("AliITSHandleDaSSD: Error ReadCalibrationDataFile");
     return kFALSE;
   }
+  rawreaderdate = new AliRawReaderDate(fileName, 0);
   rawreaderdate->SelectEvents(-1);
   while (rawreaderdate->NextEvent()) {
     if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
     fLdcId = rawreaderdate->GetLDCId();
     fRunId = rawreaderdate->GetRunNumber(); 
     modind = 0;
-    while (rawreaderdate->ReadNextData((UChar_t*&)data)) {
+    while (rawreaderdate->ReadNextData(databyte)) {
+      data = reinterpret_cast<long32*>(databyte);
       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);
+        AliError(Form("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);               
@@ -217,7 +362,7 @@ Bool_t AliITSHandleDaSSD::ReadCalibrationDataFile (const char* fileName, const L
                                                                               : signal;
         if (!(module = GetModule(ddlID, ad, adc))) {
           module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst());
-         if (!module->SetModuleIdData (ddlID, ad, adc, modind)) return kFALSE;
+         if (!module->SetModuleIdData (ddlID, ad, adc, RetrieveModuleId(ddlID, ad, adc))) return kFALSE;
           module->SetModuleRorcId (equipid, equiptype);
          fModules[modind++] = module;
         }
@@ -236,6 +381,77 @@ Bool_t AliITSHandleDaSSD::ReadCalibrationDataFile (const char* fileName, const L
 }
 
 
+
+//______________________________________________________________________________
+Int_t AliITSHandleDaSSD::ReadModuleRawData (const Int_t modulesnumber)
+{
+// Reads raw data from file
+  AliRawReaderDate    *rawreaderdate = NULL;
+  AliITSModuleDaSSD   *module;
+  AliITSChannelDaSSD  *strip;
+  Long_t            datasize, eventind = 0;
+  Int_t             nofstrips, eqbelsize;
+  UShort_t          modind;
+  long32           *data;
+  UChar_t          *databyte;
+  if (!(rawreaderdate = new AliRawReaderDate(fRawDataFileName, 0))) return 0;
+  if (!fModules) {
+    AliError("AliITSHandleDaSSD: Error ReadModuleRawData: no structure was allocated for data");
+    return 0;
+  }
+  rawreaderdate->SelectEvents(-1);
+  modind = 0;
+  while (rawreaderdate->NextEvent()) {
+    if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
+    while (rawreaderdate->ReadNextData(databyte)) {
+      data = reinterpret_cast<long32*>(databyte);
+      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)) ) {
+        AliError(Form("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;
+        Int_t modpos = GetModuleIndex(ddlID, ad, adc);
+        if (((modpos > 0) && (modpos < fModIndRead)) || ((modpos < 0) && (modind == modulesnumber))) continue;
+       if ((modpos < 0) && (modind < modulesnumber)) {
+         module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst());
+         if (!module->SetModuleIdData (ddlID, ad, adc, RetrieveModuleId(ddlID, ad, adc))) return 0;
+          module->SetModuleRorcId (equipid, equiptype);
+         modpos = fModIndRead + modind;
+         modind += 1;
+         fModules[modpos] = module;
+       } 
+        if (!(strip = fModules[modpos]->GetStrip(stripID))) {
+          strip = new AliITSChannelDaSSD(stripID, fNumberOfEvents);
+          fModules[modpos]->SetStrip(strip, stripID);
+        }
+        strip->SetSignal(eventind, signal);
+      } 
+    }
+    if (++eventind > fNumberOfEvents) break;
+  }
+  delete rawreaderdate;
+  if (modind) cout << "The memory was allocated for " <<  modind << " modules." << endl;
+  fModIndRead += modind;
+  if (modind < modulesnumber) RelocateModules();
+  return modind;
+}
+
+
+
+//______________________________________________________________________________
 Bool_t AliITSHandleDaSSD::RelocateModules()
 {
 // Relocate memory for AliITSModuleDaSSD object array
@@ -246,7 +462,7 @@ Bool_t AliITSHandleDaSSD::RelocateModules()
   if (nm == fNumberOfModules) return kTRUE;
   marray = new (nothrow) AliITSModuleDaSSD* [nm];
   if (!marray) {
-    Error("AliITSHandleDaSSD", "Error relocating memory for %i AliITSModuleDaSSD* objects!", nm);
+    AliError(Form("AliITSHandleDaSSD: Error relocating memory for %i AliITSModuleDaSSD* objects!", nm));
     return kFALSE;
   }
   nm = 0;
@@ -254,169 +470,246 @@ Bool_t AliITSHandleDaSSD::RelocateModules()
     if (fModules[modind]) marray[nm++] = fModules[modind];
   delete [] fModules;
   fModules = marray;
-  fNumberOfModules = nm;
+  fNumberOfModules = fModIndRead = nm;
   return kTRUE;
 }
 
 
-Bool_t AliITSHandleDaSSD::CalculatePedestal()
+
+//______________________________________________________________________________
+Bool_t AliITSHandleDaSSD::CalculatePedestal(AliITSModuleDaSSD *const module)
 {
 // Calculates Pedestal
-  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);    
+  Float_t             pedestal, noise;
+  Short_t            *signal;
+  Long_t              ovev, ev, n;
+  if (!module) return kFALSE;
+  for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
+    if (!(strip = module->GetStrip(strind))) continue;
+    if (!(signal = strip->GetSignal())) {
+      AliError(Form("AliITSHandleDaSSD: Error CalculatePedestal(): there are no events data for module[%i] strip[%i]->GetSignal()",
+                     module->GetModuleId(), strind));
+      continue;        
     }
+//************* pedestal first pass ****************
+    pedestal = 0.0f;
+    ovev = 0l;
+    for (ev = 0; ev < strip->GetEventsNumber(); ev++)
+      if (SignalOutOfRange(signal[ev])) ovev += 1;
+      else pedestal = ((ev - ovev)) ? pedestal + (signal[ev] - pedestal) / static_cast<Float_t>(ev - ovev + 1) : signal[ev];
+    if (ev == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
+    strip->SetPedestal(pedestal);      
+//************* noise *******************************
+    Double_t nsum = 0.0L;
+    ovev = 0l;
+    for (ev = 0; ev < strip->GetEventsNumber(); ev++) {
+      if (SignalOutOfRange(signal[ev])) ovev += 1;
+      else nsum += pow((signal[ev] - strip->GetPedestal()), 2);
+    } 
+    if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise =  sqrt(nsum / (Float_t)(n));
+    else  noise = AliITSChannelDaSSD::GetUndefinedValue();
+    strip->SetNoise(noise);
+//************* pedestal second pass ****************
+    pedestal = 0.0f;
+    ovev = 0l;
+    for (ev = 0; ev < strip->GetEventsNumber(); ev++)
+      if (   SignalOutOfRange(signal[ev]) 
+          || TMath::Abs(signal[ev] - strip->GetPedestal()) > (fPedestalThresholdFactor * strip->GetNoise())) ovev += 1;
+      else pedestal = ((ev - ovev)) ? pedestal + (signal[ev] - pedestal) / static_cast<Float_t>(ev - ovev + 1) : signal[ev];
+    if (ev == ovev) pedestal = AliITSChannelDaSSD::GetUndefinedValue();
+    strip->SetPedestal(pedestal);      
+    strip->SetOverflowNumber(ovev);    
   }
   return kTRUE;
 }
 
 
-
-Bool_t AliITSHandleDaSSD::CalculateNoise()
+//______________________________________________________________________________
+Bool_t AliITSHandleDaSSD::CalculateNoise(AliITSModuleDaSSD *const module, const Bool_t CorrectCM)
 {
 // Calculates Noise
   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);
+  if (!module) return kFALSE;
+  for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
+    if (!(strip = module->GetStrip(strind))) continue;
+    if (!(signal = strip->GetSignal())) {
+      strip->SetNoise(AliITSChannelDaSSD::GetUndefinedValue());
+      AliError(Form("AliITSHandleDaSSD: Error CalculateNoise(): there are no events data for module[%i] strip[%i]->GetSignal()",
+                     module->GetModuleId(), strind));
+      continue;
     }
+    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);
+    } 
+    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)
+//______________________________________________________________________________
+Bool_t AliITSHandleDaSSD::CalculateNoiseCM(AliITSModuleDaSSD *const module)
 {
-// Calculates 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());
+// Calculates Noise with CM correction
+  AliITSChannelDaSSD  *strip = NULL;
+  Short_t     *signal;
+  Float_t      noise;
+  Long_t       ovev, n;
+  if (!CalculateCM(module)) { 
+    AliError("Error: AliITSHandleDaSSD::CalculateCM() returned kFALSE");
+    return kFALSE;
+  }  
+  for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
+    if (!(strip = module->GetStrip(strind))) continue; //return kFALSE;
+    if (!(signal = strip->GetSignal())) {
+      strip->SetNoiseCM(AliITSChannelDaSSD::GetUndefinedValue());
+      AliError(Form("SSDDAModule: Error CalculateNoiseWithoutCM(): there are no events data for module[%i] strip[%i]->GetSignal()", 
+                     module->GetModuleId(), strind));
+      return kFALSE;
     }
-    if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cm[ev] = cmsum / (Float_t)(n);
-    else cm[ev] = 0.0;
-  } 
-  return kTRUE; 
+    Int_t chipind = strind / AliITSModuleDaSSD::GetStripsPerChip();
+    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() - module->GetCM(chipind, ev)), 2);
+    } 
+    if ((n = strip->GetEventsNumber() - ovev - 1) > 0) noise =  sqrt(nsum / (Float_t)(n));
+    else  noise = AliITSChannelDaSSD::GetUndefinedValue();
+    strip->SetNoiseCM(noise);
+  }
+return kTRUE;
 }
 
 
 
-Bool_t  AliITSHandleDaSSD::CalculateNoiseCM()
+//______________________________________________________________________________
+Bool_t AliITSHandleDaSSD::CalculateCM(AliITSModuleDaSSD *const module)
 {
-// Calculates Noise with CM correction
-  Short_t     *signal;
+// Calculates CM
   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;
+  Short_t             *signal;
+  Long_t               ovstr, n;
+  Int_t                stripind;
+  module->SetNumberOfChips(AliITSModuleDaSSD::GetChipsPerModuleConst());
+  for (Int_t chipind = 0; chipind < module->GetNumberOfChips(); chipind++) {
+    stripind = chipind * module->GetStripsPerChip();
+    module->GetCm()[chipind].Set(fNumberOfEvents);
+    module->GetCm()[chipind].Reset(0.0f);
+    for (Long_t ev = 0; ev < fNumberOfEvents; ev++) {
+    // calculate firs approximation of CM.
+      Double_t cm0 = 0.0L;
+      ovstr = 0l;
+      for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
+        if (!(strip = module->GetStrip(strind))) continue; //return kFALSE; 
+        if (!(signal = strip->GetSignal())) {
+          AliError(Form("AliITSHandleDaSSD: Error CalculateCM: there are no events data for module[%i] strip[%i]->GetSignal()", 
+                       module->GetModuleId(), strind));
+          return kFALSE;
+        }
+        if ((signal[ev] >= AliITSChannelDaSSD::GetOverflowConst()) || 
+           (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())) ovstr += 1;
+        else cm0 += (signal[ev] - strip->GetPedestal());
       }
-      if (!(strind % AliITSModuleDaSSD::GetStripsPerChip())) {
-        if (!cm) {
-          cm = new (nothrow) Float_t [strip->GetEventsNumber()];
-          if (!cm) {
-            Warning("AliITSHandleDaSSD", "Noise calculation with common mode correction failed becouse of memory allocation problems.");
-            return kFALSE; 
-          }
+      if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cm0 /= (Float_t)(n);
+      else { module->SetCM(0.0f, chipind, ev); continue; }
+    // calculate avarage (cm - (signal - pedestal)) over the chip
+      Double_t cmsigma = 0.0L;
+      ovstr = 0l;
+      for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
+        if (!(strip = module->GetStrip(strind))) continue;
+        if (!(signal = strip->GetSignal())) {
+          AliError(Form("AliITSHandleDaSSD: Error CalculateCM: there are no events data for module[%i] strip[%i]->GetSignal()\n",
+                        module->GetModuleId(), strind));
+          return kFALSE;
         }
-// calculate cm;
-        if (!CalculateCM(modind, strind, cm)) return kFALSE;
+        if ((signal[ev] >= AliITSChannelDaSSD::GetOverflowConst()) || 
+           (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue())) ovstr += 1;
+        else cmsigma += pow((cm0 - (signal[ev] - strip->GetPedestal())), 2);
       }
-// 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 ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cmsigma = sqrt(cmsigma / (Float_t)(n));
+      else { module->SetCM(0.0f, chipind, ev); continue; }
+   // calculate cm with threshold
+      Double_t cmsum = 0.0L;
+      ovstr = 0l;
+      for (Int_t strind = stripind; strind < (stripind + AliITSModuleDaSSD::GetStripsPerChip()); strind++) {
+        if (!(strip = module->GetStrip(strind))) continue;
+        signal = strip->GetSignal();
+        if (   (signal[ev] >= AliITSChannelDaSSD::GetOverflowConst())
+           || (strip->GetPedestal() == AliITSChannelDaSSD::GetUndefinedValue()) 
+           || (TMath::Abs(cm0 - (signal[ev] - strip->GetPedestal())) > (fCmThresholdFactor * cmsigma)) ) ovstr += 1;
+        else cmsum += (signal[ev] - strip->GetPedestal());
+      }
+      if ((n = AliITSModuleDaSSD::GetStripsPerChip() - ovstr)) cmsum /= (Float_t)(n);
+      else cmsum = 0.0L;
+      if (!module->SetCM(cmsum, chipind, ev));
+    } 
+  }
+  return kTRUE; 
+}
+
+
+//______________________________________________________________________________
+Bool_t AliITSHandleDaSSD::ProcessRawData(const Int_t nmread)
+{
+// Performs calculation of calibration parameters (pedestal, noise, ...) 
+  Int_t nm = 0;
+  if (nmread <= 0) return kFALSE;
+  if (!fModules) return kFALSE;
+  while ((nm = ReadModuleRawData(nmread)) > 0) {
+    cout << "Processing next " << nm << " modules;" << endl;  
+    for (Int_t modind = fModIndProcessed; modind < fModIndRead; modind++) {
+      if (!fModules[modind]) {
+        AliError(Form("AliITSHandleDaSSD: Error ProcessRawData(): No AliITSModuleDaSSD object with index %i is allocated in AliITSHandleDaSSD\n",
+                      modind));
+        return kFALSE;
       }
+      CalculatePedestal(fModules[modind]);
+      CalculateNoise(fModules[modind]);
+      CalculateNoiseCM(fModules[modind]);
     }
-  if (cm) delete [] cm;
-  return kTRUE;
+    DeleteSignal();
+    fModIndProcessed = fModIndRead;
+    cout << fModIndProcessed << " - done" << endl;
+  }
+  return kTRUE;  
 }
 
 
+//______________________________________________________________________________
+Short_t AliITSHandleDaSSD::RetrieveModuleId(const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const
+{
+// Retrieve ModuleId from the DDL map which is defined in AliITSRawStreamSSD class
+  Int_t mddli = (ad - 1) * 12 + ((adc<6) ? adc : (adc-2));
+  if ((ddlID < AliITSRawStreamSSD::kDDLsNumber) && (mddli < AliITSRawStreamSSD::kModulesPerDDL)) {
+    mddli = AliITSRawStreamSSD::GetModuleNumber(ddlID, mddli);
+    if (mddli > SHRT_MAX) return SHRT_MAX;
+    else return (Short_t)mddli;
+  }
+  else {
+    AliWarning(Form("Module index  = %d or ddlID = %d is out of range -1 is rturned", ddlID, mddli));
+    return -1;
+  }
+}
+
 
+
+//______________________________________________________________________________
 TObjArray* AliITSHandleDaSSD::GetCalibrationSSDLDC() const
 {
 // Fill in the array for OCDB 
   TObjArray *ldcc;
+  TObject   *modcalibobj;
   if (!fModules) return NULL;
   ldcc = new TObjArray(fNumberOfModules, 0);
   for (Int_t i = 0; i < fNumberOfModules; i++) {
@@ -424,18 +717,22 @@ TObjArray* AliITSHandleDaSSD::GetCalibrationSSDLDC() const
       delete ldcc;
       return NULL;
     }
-    ldcc->AddAt(dynamic_cast<TObject*>(fModules[i]->GetCalibrationSSDModule()), i);
+    modcalibobj = dynamic_cast<TObject*>(fModules[i]->GetCalibrationSSDModule());
+    ldcc->AddAt(modcalibobj, i);
   }
   ldcc->Compress();
   return ldcc;
 }
 
 
-Bool_t AliITSHandleDaSSD::SaveCalibrationSSDLDC(string& dafname) const
+//______________________________________________________________________________
+Bool_t AliITSHandleDaSSD::SaveCalibrationSSDLDC(Char_t*& dafname) const
 {
 // Save Calibration data locally
-  ostringstream   dadatafilename;
   TObjArray      *ldcc;
+  TObject        *modcalibobj;
+  Char_t         *tmpfname;
+  TString         dadatafilename("");
   if (!fModules) return kFALSE;
   ldcc = new TObjArray(fNumberOfModules, 0);
   for (Int_t i = 0; i < fNumberOfModules; i++) {
@@ -443,21 +740,144 @@ Bool_t AliITSHandleDaSSD::SaveCalibrationSSDLDC(string& dafname) const
       delete ldcc;
       return kFALSE;
     }
-    ldcc->AddAt(dynamic_cast<TObject*>(fModules[i]->GetCalibrationSSDModule()), i);
+    modcalibobj = dynamic_cast<TObject*>(fModules[i]->GetCalibrationSSDModule());
+    ldcc->AddAt(modcalibobj, i);
   }
   ldcc->Compress();
-  dadatafilename << dafname << "/ITSSSDda_" << fLdcId << "_" << fRunId << ".root";
-  dafname = dadatafilename.str();
-  TFile *fileRun = new TFile (dadatafilename.str().data(),"RECREATE");
+  if (dafname) dadatafilename = Form("%s/", dafname); 
+  dadatafilename.Append(Form("ITSSSDda_%i_%i.root", fLdcId, fRunId));
+  tmpfname = new Char_t[dadatafilename.Length()];
+  dafname = strcpy(tmpfname, dadatafilename.Data());
+  TFile *fileRun = new TFile (dadatafilename.Data(),"RECREATE");
   if (fileRun->IsZombie()) {
-    Error("AliITSHandleDaSSD", "SaveCalibrationSSDLDC() error open file %s", dadatafilename.str().data());
+    AliError(Form("AliITSHandleDaSSD: SaveCalibrationSSDLDC() error open file %s", dadatafilename.Data()));
     ldcc->Delete();
     delete fileRun;
+    delete ldcc;
     return kFALSE;
   }
   fileRun->WriteTObject(ldcc);
   fileRun->Close();
   ldcc->Delete();
   delete fileRun;
+  delete ldcc;
+  return kTRUE;
+}
+
+
+
+//______________________________________________________________________________
+Bool_t AliITSHandleDaSSD::DumpModInfo(const Float_t meannosethreshold) const
+{
+// Dump calibration parameters
+  AliITSModuleDaSSD    *mod;
+  AliITSChannelDaSSD   *strip;
+  if (!fModules) {
+    cout << "SSDDALDC::DumpModInfo():  Error, no modules are allocated!" << endl;
+    return kFALSE;
+  }  
+  cout << "Modules with MeanNoise > " << meannosethreshold << endl;
+  for (Int_t i = 0; i < fNumberOfModules; i++) {
+    if (!(mod = fModules[i])) continue;
+    Float_t  maxnoise = 0.0f, meannoise = 0.0f;
+    Int_t    maxstrind = 0, novfstr = 0;  
+    for (Int_t strind = 0; strind < mod->GetNumberOfStrips(); strind++) {
+      if (!(strip = mod->GetStrip(strind))) {novfstr++;  continue; }
+      if (strip->GetNoiseCM() >= AliITSChannelDaSSD::GetUndefinedValue() ) {novfstr++;  continue; }
+      if (maxnoise < strip->GetNoiseCM()) { 
+        maxnoise = strip->GetNoiseCM();
+        maxstrind = strind;
+      }        
+      meannoise = (strind - novfstr) ? meannoise + (strip->GetNoiseCM() - meannoise) / static_cast<Float_t>(strind - novfstr + 1) 
+                                    : strip->GetNoiseCM();
+    } 
+    if (meannoise > meannosethreshold)
+      cout << "Mod: " << i << ";  DDl: " << (int)mod->GetDdlId() << ";  AD: " << (int)mod->GetAD()  
+                           << ";  ADC: " << (int)mod->GetADC() << ";  MeanNoise = " << meannoise 
+                          << ";  NOfStrips = " << (mod->GetNumberOfStrips() - novfstr) << endl;
+  }
+  return kTRUE;
+}
+
+
+
+//______________________________________________________________________________
+Bool_t AliITSHandleDaSSD::PrintModCalibrationData(const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const Char_t *fname) const
+{
+// Print Module calibration data whether in file on in cout
+   AliITSChannelDaSSD  *strip;
+   ofstream             datafile;
+   ostream             *outputfile;
+   if (!fname) { outputfile = &cout; }
+   else {
+     datafile.open(fname, ios::out);
+     if  (datafile.fail()) return kFALSE;
+     outputfile = dynamic_cast<ostream*>(&datafile); 
+   }
+   *outputfile  << "DDL = " << (int)ddlID << ";  AD = " << (int)ad << ";  ADC = " << (int)adc << endl;
+   for (Int_t strind = 0; strind < AliITSModuleDaSSD::GetStripsPerModuleConst(); strind++) {
+     if (strip = GetStrip(ddlID, ad, adc, strind)) {
+       *outputfile << "Str = " << strind << ";  ped = " << strip->GetPedestal() 
+                   << ";  noise = " << strip->GetNoiseCM() << endl;
+     }
+     else continue;
+   }
+  if (datafile.is_open()) datafile.close(); 
+  return kTRUE;
+}
+
+
+
+void AliITSHandleDaSSD::DumpInitData(const Char_t *str) const
+{
+// Print general information retrieve from raw data file
+  cout << "Raw data file: " << fRawDataFileName << endl
+       << "LDC: " << (Int_t)fLdcId << "; RunId: " << fRunId << endl
+       << "Number of physics events: " << fNumberOfEvents << endl
+       << str;
+}
+
+
+//______________________________________________________________________________
+Bool_t AliITSHandleDaSSD::AllocateSimulatedModules(const Int_t copymodind)
+{
+// Used to allocate simulated modules to test the performance  
+  AliITSModuleDaSSD *module;
+  UChar_t      ad, adc, ddlID;
+  ad = adc = ddlID = 0;
+  if (!(fModules[copymodind])) return kFALSE;
+  for (Int_t modind = 0; modind < fNumberOfModules; modind++) {
+    if (!fModules[modind]) {
+      module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst());
+      if ((adc < 5) || ((adc > 7) && (adc < 13)) ) adc += 1;
+      else if (adc == 5) adc = 8;
+      else if (adc == 13) {
+        adc = 0;
+        if (ad < 8) ad += 1;
+        else {
+          ad = 0;
+          ddlID +=1;
+        }
+      }
+      if (!module->SetModuleIdData (ddlID, ad, adc, modind)) return kFALSE;
+      fModules[modind] = module;
+      for (Int_t strind = 0; strind < module->GetNumberOfStrips(); strind++) {
+        AliITSChannelDaSSD *cstrip = fModules[copymodind]->GetStrip(strind);
+        Long_t      eventsnumber = cstrip->GetEventsNumber();
+        AliITSChannelDaSSD *strip = new AliITSChannelDaSSD(strind, eventsnumber);
+        for (Long_t evind = 0; evind < eventsnumber; evind++) {
+          Short_t sign = *cstrip->GetSignal(evind);
+          if (!strip->SetSignal(evind, sign)) AliError(Form("AliITSHandleDaSSD: Copy events error! mod = %i, str = %i", modind, strind));
+        }
+       module->SetStrip(strip, strind);
+      }
+    }
+    else {
+      ddlID = fModules[modind]->GetDdlId();
+      ad    = fModules[modind]->GetAD();
+      adc   = fModules[modind]->GetADC();
+    }
+  }
+  for (UShort_t modind = 0; modind < fNumberOfModules; modind++) fModules[modind]->SetModuleId(modind + 1080);  
   return kTRUE;
 }
index e6d6de1..3aa6903 100644 (file)
@@ -21,46 +21,74 @@ class TObjArray;
 class AliITSHandleDaSSD : public TObject {
   public :
     AliITSHandleDaSSD();
-    explicit AliITSHandleDaSSD(const Int_t numberofmodules);
+    explicit AliITSHandleDaSSD(Char_t *rdfname);
     AliITSHandleDaSSD(const AliITSHandleDaSSD& ssdadldc);
     AliITSHandleDaSSD& operator = (const AliITSHandleDaSSD& ssdadldc);
     virtual ~AliITSHandleDaSSD();
 
-    Int_t        GetNumberOfModules() const { return fNumberOfModules; }
+    virtual Bool_t Init(Char_t *rdfname, const Char_t *configfname = NULL);
+    virtual Bool_t ReadConfigurationFile(const Char_t *configfname = NULL) const;
+    Bool_t  SetRawFileName (Char_t *rdfname) {return Init(rdfname); }
 
+    Int_t              GetNumberOfModules() const { return fNumberOfModules; }
+    UInt_t             GetLdcId() const { return fLdcId; }
+    UInt_t             GetRunId() const { return fRunId; }
     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;}
+    Int_t GetModuleIndex (const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const;
     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      SaveCalibrationSSDLDC(Char_t*& dafname) const;
     
+    void    SetModIndProcessed(Int_t mi) {fModIndProcessed = mi;}
+    void    SetModIndRead (Int_t mr)  {fModIndRead = mr;}
     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();}
+    Bool_t  ReadCalibrationDataFile (char* fileName, const Long_t eventsnumber);
+    Int_t   ReadModuleRawData (const Int_t modulesnumber);  
+
+    virtual Bool_t  CalculatePedestal(AliITSModuleDaSSD *const module);
+    virtual Bool_t  CalculateNoise(AliITSModuleDaSSD *const module, const Bool_t CorrectCM = kFALSE);
+    virtual Bool_t  CalculateNoiseCM(AliITSModuleDaSSD *const module);
+    virtual Bool_t  CalculateCM(AliITSModuleDaSSD *const module);
+    virtual Bool_t  ProcessRawData(const Int_t nmread = fgkNumberOfSSDModulesPerDdl);
+    virtual Bool_t  RelocateModules();
+    virtual Bool_t  AllocateSimulatedModules(const Int_t copymodind = 0);
+     
+    virtual void    Reset();
+    virtual Short_t RetrieveModuleId(const UChar_t ddlID, const UChar_t ad, const UChar_t adc) const;
+    Bool_t  DumpModInfo(const Float_t meannosethreshold) const;
+    Bool_t  PrintModCalibrationData(const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const Char_t *fname = NULL) const;
+    void    DumpInitData(const Char_t *str = "") const;
+    void    DeleteSignalAll() { if (fModules) for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) fModules[i]->DeleteSignal();}
+    void    DeleteSignal() { if (fModules) for (Int_t i = fModIndProcessed; i < fModIndRead; i++) if (fModules[i]) fModules[i]->DeleteSignal();}
 
     static Int_t GetNumberOfSSDModulesConst() { return fgkNumberOfSSDModules; }
 
   protected :
-    static const Int_t fgkNumberOfSSDModules = 1698;   // Number of SSD modules in ITS
+    static const Int_t    fgkNumberOfSSDModules ;        // Number of SSD modules in ITS
+    static const Int_t    fgkNumberOfSSDModulesPerDdl;   // Number of SSD modules in ITS
+    static const Float_t  fgkPedestalThresholdFactor;    // Defalt value for fPedestalThresholdFactor 
+    static const Float_t  fgkCmThresholdFactor;          // Defalt value for fCmThresholdFactor 
 
+    Char_t              *fRawDataFileName;       // Name of the file with raw data
     Int_t                fNumberOfModules;       // number of AliITSModuleDaSSD to allocate
-    AliITSModuleDaSSD  **fModules;               //[fNumberOfModules]  array of all SSD 1698 Modules (2608128 strips)
+    AliITSModuleDaSSD  **fModules;               //[fNumberOfModules] array of pointer on AliITSModuleDaSSD objects (1698 SSD  Modules)
+    Int_t                fModIndProcessed;       //! index of the last module in fModules array with processed data
+    Int_t                fModIndRead;            //! index of the last module in fModules array with adc data present (read)
+    Long_t               fNumberOfEvents;        // Number of physics or calibration events in raw data file fRawDataFileName
+    
     UInt_t               fLdcId;                 //  LDC number, read from header
     UInt_t               fRunId;                 //  Run number, read from header
 
+    Float_t     fPedestalThresholdFactor;        // configuration parameter: ThresholdFactor for pedestal calculation 
+    Float_t     fCmThresholdFactor;              // configuration parameter: ThresholdFactor for CM calculation 
+
   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)
+    ClassDef(AliITSHandleDaSSD, 2)
 
 };
 
index 8320b58..698acdb 100644 (file)
 
 #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),
@@ -38,12 +51,15 @@ AliITSModuleDaSSD::AliITSModuleDaSSD() :
   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),
@@ -53,6 +69,8 @@ AliITSModuleDaSSD::AliITSModuleDaSSD(const UChar_t ddlID, const UChar_t ad, cons
   fModuleId(moduleID),
   fNumberOfStrips(0),
   fStrips(NULL),
+  fNumberOfChips(0),
+  fCm(NULL),
   fEventsNumber(0)
 {
 // Constructor, set module id data
@@ -60,6 +78,7 @@ AliITSModuleDaSSD::AliITSModuleDaSSD(const UChar_t ddlID, const UChar_t ad, cons
 
 
 
+//______________________________________________________________________________
 AliITSModuleDaSSD::AliITSModuleDaSSD(const Int_t numberofstrips) :
   fEquipId(0),
   fEquipType(0),
@@ -69,23 +88,26 @@ AliITSModuleDaSSD::AliITSModuleDaSSD(const Int_t numberofstrips) :
   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 %i strips", fgkStripsPerModule);
+    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;
   } else {
-     Error("AliITSModuleDaSSD", "Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips);
+     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),
@@ -95,21 +117,23 @@ AliITSModuleDaSSD::AliITSModuleDaSSD(const Int_t numberofstrips, const Long_t ev
   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 %i strips", fgkStripsPerModule);
+    AliWarning(Form("AliITSModuleDaSSD: ALICE ITS SSD Module contains %i strips", fgkStripsPerModule));
   fStrips = new (nothrow) AliITSChannelDaSSD* [numberofstrips];
   if (fStrips) {
      fNumberOfStrips = numberofstrips;
      memset(fStrips, 0, numberofstrips * sizeof(AliITSChannelDaSSD*));
      for (Int_t i = 0; i < fNumberOfStrips; i++) {
        fStrips[i] = new AliITSChannelDaSSD(i, eventsnumber);
-       if (!fStrips[i]) Error("AliITSModuleDaSSD", "Error allocating memory for AliITSChannelDaSSD %i-th object", i);
+       if (!fStrips[i]) AliError(Form("AliITSModuleDaSSD: Error allocating memory for AliITSChannelDaSSD %i-th object", i));
      }
   } else {
-     Error("AliITSModuleDaSSD", "Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips);
+     AliError(Form("AliITSModuleDaSSD: Error allocating memory for %i AliITSChannelDaSSD* objects!", numberofstrips));
      fNumberOfStrips = 0;
      fStrips = NULL;
   }  
@@ -117,6 +141,7 @@ AliITSModuleDaSSD::AliITSModuleDaSSD(const Int_t numberofstrips, const Long_t ev
 
 
 
+//______________________________________________________________________________
 AliITSModuleDaSSD::AliITSModuleDaSSD(const AliITSModuleDaSSD& module) :
   TObject(module),
   fEquipId(module.fEquipId),
@@ -127,25 +152,29 @@ AliITSModuleDaSSD::AliITSModuleDaSSD(const AliITSModuleDaSSD& module) :
   fModuleId(module.fModuleId),
   fNumberOfStrips(module.fNumberOfStrips),
   fStrips(module.fStrips),
+  fNumberOfChips(module.fNumberOfChips),
+  fCm(module.fCm),
   fEventsNumber(module.fEventsNumber)
 {
 // copy constructor
 
-  Fatal("AliITSModuleDaSSD", "copy constructor not implemented");
+  AliFatal("AliITSModuleDaSSD, copy constructor not implemented");
 }
 
 
 
+//______________________________________________________________________________
 AliITSModuleDaSSD& AliITSModuleDaSSD::operator = (const AliITSModuleDaSSD& module)
 {
 // assignment operator
 
-  Fatal("AliITSModuleDaSSD: operator =", "assignment operator not implemented");
+  AliFatal("AliITSModuleDaSSD: operator =, assignment operator not implemented");
   return *this;
 }
     
 
     
+//______________________________________________________________________________
 AliITSModuleDaSSD::~AliITSModuleDaSSD()
 {
 // Destructor
@@ -157,19 +186,68 @@ AliITSModuleDaSSD::~AliITSModuleDaSSD()
     }
     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;
@@ -180,7 +258,7 @@ Bool_t AliITSModuleDaSSD::SetModuleIdData (const UChar_t ddlID, const UChar_t ad
 }
 
 
-
+//______________________________________________________________________________
 void AliITSModuleDaSSD::SetModuleFEEId (const UChar_t ddlID, const UChar_t ad, const UChar_t adc)
 {
 // Set id data of FEE connected to the Module
@@ -190,6 +268,7 @@ void AliITSModuleDaSSD::SetModuleFEEId (const UChar_t ddlID, const UChar_t ad, c
 }
 
 
+//______________________________________________________________________________
 void AliITSModuleDaSSD::SetModuleRorcId (const Int_t equipid, const Int_t equiptype)
 {
 // Set data to access FEROM registres via DDL
@@ -198,6 +277,7 @@ void AliITSModuleDaSSD::SetModuleRorcId (const Int_t equipid, const Int_t equipt
 }
 
 
+//______________________________________________________________________________
 Bool_t AliITSModuleDaSSD::SetEventsNumber(const Long_t eventsnumber)
 {
 // Allocate the memory for the events data
@@ -207,8 +287,8 @@ Bool_t AliITSModuleDaSSD::SetEventsNumber(const Long_t eventsnumber)
     if (fStrips[i])  
       if (!fStrips[i]->SetEvenetsNumber(eventsnumber)) {
         for (Int_t j = 0; j < i; j++) fStrips[j]->DeleteSignal();
-        Error("AliITSModuleDaSSD", "Error allocating memory for i% events for module %i, strip %i", 
-                                   eventsnumber, (Int_t)fModuleId, i);
+        AliError(Form("AliITSModuleDaSSD: Error allocating memory for i% events for module %i, strip %i", 
+                                   eventsnumber, (Int_t)fModuleId, i));
         return kFALSE;
       }
     else 
@@ -217,7 +297,7 @@ Bool_t AliITSModuleDaSSD::SetEventsNumber(const Long_t eventsnumber)
         delete [] fStrips;
         fNumberOfStrips = 0;
         fStrips = NULL;
-        Error("AliITSModuleDaSSD", "Error allocating memory for strip %i of module %i!", (Int_t)fModuleId, i);
+        AliError(Form("AliITSModuleDaSSD: Error allocating memory for strip %i of module %i!", (Int_t)fModuleId, i));
         return kFALSE;
       }
   } 
@@ -226,23 +306,46 @@ Bool_t AliITSModuleDaSSD::SetEventsNumber(const Long_t eventsnumber)
 
 
 
+//______________________________________________________________________________
+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;
 }
index 85b65ef..a86e9dd 100644 (file)
@@ -14,6 +14,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "TObject.h"
+#include "TArrayF.h"
 #include "AliITSChannelDaSSD.h"
 
 class AliITSNoiseSSD;
@@ -31,51 +32,63 @@ class AliITSModuleDaSSD : public TObject {
     UChar_t      GetDdlId()    const { return fDdlId; }
     UChar_t      GetAD()       const { return fAd; }
     UChar_t      GetADC()      const { return fAdc; }
-    UShort_t     GetModuleId() const { return fModuleId; }
+    Short_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; }
+    Float_t*     GetCM(const Int_t chipn)   const { return chipn < fNumberOfChips ? fCm[chipn].GetArray() : NULL; }
+    Float_t      GetCM(const Int_t chipn, const Long_t evn)   const;
+    TArrayF*     GetCm() const { return fCm; }
+    Int_t        GetNumberOfChips() const  { return fNumberOfChips; }
     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);
+    Bool_t  SetNumberOfStrips(const Int_t numberofstrips);
+    Bool_t  SetNumberOfChips(const Int_t nchips);
+    Bool_t  SetModuleIdData (const UChar_t ddlID, const UChar_t ad, const UChar_t adc, const Short_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    SetModuleId (const Short_t moduleID) { fModuleId = moduleID; }
     void    SetStrip(AliITSChannelDaSSD* strip, const Int_t strID) { if ((fStrips) && (strID <= fNumberOfStrips)) fStrips[strID] = strip; }
+    void    SetCM (Float_t* cm, const Int_t chipn)  { if (chipn < fNumberOfChips) fCm[chipn].Set(fCm[chipn].GetSize(), cm); }
+    Bool_t  SetCM (const Float_t cm, const Int_t chipn, const Int_t evn);
+    void    DeleteCM () {if (fCm) delete [] fCm; fCm = NULL; }
     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;    }
+    static Int_t GetChipsPerModuleConst()  { return  fgkChipsPerModule;   }
 
   protected :
-    static const Int_t   fgkStripsPerModule   = 1536;   // Number of strips per SSD module
-    static const Int_t   fgkPNStripsPerModule = 768;    // Number of N/P strips per SSD module
-    static const Int_t   fgkStripsPerChip     = 128;    // Number of strips per chip HAL25
-    static const UChar_t fgkMaxAdNumber       = 9;      // MAx SSD FEROM AD number
-    static const UChar_t fgkMaxAdcNumber      = 13;     // MAx SSD FEROM ADC number
+    static const Int_t   fgkStripsPerModule;    // Number of strips per SSD module
+    static const Int_t   fgkPNStripsPerModule;  // Number of N/P strips per SSD module
+    static const Int_t   fgkStripsPerChip;      // Number of strips per chip HAL25
+    static const UChar_t fgkMaxAdNumber;        // MAx SSD FEROM AD number
+    static const UChar_t fgkMaxAdcNumber;       // MAx SSD FEROM ADC number
+    static const Int_t   fgkChipsPerModule;     // Number of HAL25 chips per SSD module
 
     Int_t          fEquipId;        // required to access to rorc
     Int_t          fEquipType;      // fEquipType, required to access to rorc
     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
+    Short_t        fModuleId;       // Module number          0-1697
+    
+    Int_t                 fNumberOfStrips;     // Number of AliITSChannelDaSSD* allocated
+    AliITSChannelDaSSD  **fStrips;             //[fNumberOfStrips]  Array of *AliITSChannelDaSSD
     
-    Int_t                 fNumberOfStrips; // Number of AliITSChannelDaSSD* allocated
-    AliITSChannelDaSSD  **fStrips;         //[fNumberOfStrips]  Array of *AliITSChannelDaSSD
+    Int_t                 fNumberOfChips;      // Number of TArrayF objects allocated for CM   
+    TArrayF              *fCm;                 //[fNumberOfChips]    CM
 
-    Long_t            fEventsNumber;       // number of events for fsignal memory allocation
+    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) 
+    ClassDef(AliITSModuleDaSSD, 2) 
  
 };
 
index bab87ad..7a712b9 100644 (file)
@@ -1,24 +1,36 @@
+/**************************************************************************
+- "Contact": - Oleksandr Borysov, aborysov@ts.infnf.it
+- "Link:" - link to test files: /afs/infn.it/ts/user/aborysov/public/C23_run387.000.raw
+- "Run Type:" - run type (exactly as defined in the ECS)
+- "DA Type:" -  LDC
+- "Number of events needed:"   at least 500
 
-#include <Riostream.h>
-#include <sstream>
-#include <string>
+- "Input Files:" - config file:    ssdpeddaconfig 
+                   previous result files:  
+                  data source:   raw data file on LDC
+                   
+- "Output Files:" -  local names $DA_TEST_DIR/ssddaldc_<LDCID>_<RunID>.root 
+                     FXS name: ITSSSDda_<LDCID>_<RunID>.root, 
+                     local files are persistent over runs: data source
+- "Trigger types used:"
+ **************************************************************************/
+
+
+#include <iostream>
+#include "TString.h"
 #include "TFile.h"
 #include "daqDA.h"
-#include "event.h"
-#include "AliRawReaderDate.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;
+  TString             feefname, cmddbsave;
   Int_t               status;
-  string              dafname;
-  Char_t             *dadaqdir = NULL;
+  Char_t             *dafname = NULL, *dadaqdir = NULL;
 
   /* check that we got some arguments = list of files */
   if (argc<2) {
@@ -28,120 +40,43 @@ int main( int argc, char** argv )
 
   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()))
+  ssddaldc = new AliITSHandleDaSSD(datafilename);
+  if (ssddaldc->IsZombie()) return -1;
+  if (!ssddaldc->ProcessRawData())
   {
-     cout << "Error ssddaldc->SetNumberOfModules" << endl;
+     cout << "Error !ssddaldc->ProcessRawData()" << 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 (!system(NULL)) {
+    cout << "Error: the call system(NULL) in main() returned NULL!" << endl;
+    return -1;
+  }
+  dadaqdir = getenv ("DA_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;
+      cout << "Error saving DA data to the file! Probably $DA_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");
+    feefname = Form("%s/ssddaldc_%i_%i.root", dadaqdir, ssddaldc->GetLdcId(), ssddaldc->GetRunId());
+    cout << "Saving feessdda data in " << feefname << endl;
+    TFile *fileRun = new TFile (feefname.Data(),"RECREATE");
     ssddaldc->Write();
     fileRun->Close();
     delete fileRun;
-    status = daqDA_FES_storeFile(dafname.data(),"DASSD_DB_results");
+    status = daqDA_FES_storeFile(dafname, "DASSD_DB_results");
     if (status) printf("Failed to export file : %d\n",status);
+
+    if (getenv("DATE_DB_DIR")) {
+      cmddbsave = Form("$DATE_DB_DIR/daqDetDB_store ssddaldc.root %s", feefname.Data());
+      status = system(cmddbsave.Data());
+      if (status) printf("Failed to export file to the detector db: %d\n",status);
+    } else cout << "Error main(): $DATE_DB_DIR is not defined!" << endl;
   }
-  else cout << "Error: DAQDA_TEST_DIR is not defined, DA data are not saved!" << endl;
+  else cout << "Error: DA_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(-1);
-  while (rawreaderdate->NextEvent()) {
-    if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
-    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;
-}
+}
\ No newline at end of file