update of data handling classes for SSD calibration

diff --git a/ITS/AliITSHandleDaSSD.cxx b/ITS/AliITSHandleDaSSD.cxx
index f1a7a1b31f6c29e164cd338adc62f2f8201a8452..175bbc7b17eab0006dd62b9ba6e738f3bcf4b995 100644 (file)
--- a/ITS/AliITSHandleDaSSD.cxx
+++ b/ITS/AliITSHandleDaSSD.cxx
@@ -13,13 +13,14 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
+/* $Id:$ */
 
 ///////////////////////////////////////////////////////////////////////////////
 ///
 /// This class provides ITS SSD data handling
 /// used by DA. 
-///
+//  Author: Oleksandr Borysov
+//  Date: 14/02/2008
 ///////////////////////////////////////////////////////////////////////////////
 
 #include <Riostream.h> 
@@ -32,6 +33,8 @@
 #include "TObjArray.h"
 #include "AliLog.h"
 #include "AliITSNoiseSSD.h"
+#include "AliITSPedestalSSD.h"
+#include "AliITSBadChannelsSSD.h"
 #include "AliITSRawStreamSSD.h"
 #include "AliRawReaderDate.h"
 
@@ -44,7 +47,8 @@ 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 Int_t    AliITSHandleDaSSD::fgkNumberOfSSDModulesPerDdl = 108;  // Number of SSD modules in DDL
+const Int_t    AliITSHandleDaSSD::fgkNumberOfSSDModulesPerSlot = 12;  // Number of SSD modules in Slot
 const Float_t  AliITSHandleDaSSD::fgkPedestalThresholdFactor = 3.0;   // Defalt value for fPedestalThresholdFactor 
 const Float_t  AliITSHandleDaSSD::fgkCmThresholdFactor = 3.0;         // Defalt value for fCmThresholdFactor
 
@@ -55,6 +59,7 @@ AliITSHandleDaSSD::AliITSHandleDaSSD() :
   fModules(NULL),
   fModIndProcessed(0),
   fModIndRead(0),
+  fModIndex(NULL),
   fNumberOfEvents(0),
   fLdcId(0),
   fRunId(0),
@@ -72,6 +77,7 @@ AliITSHandleDaSSD::AliITSHandleDaSSD(Char_t *rdfname) :
   fModules(NULL),
   fModIndProcessed(0),
   fModIndRead(0),
+  fModIndex(NULL),
   fNumberOfEvents(0),
   fLdcId(0),
   fRunId(0),
@@ -90,6 +96,7 @@ AliITSHandleDaSSD::AliITSHandleDaSSD(const AliITSHandleDaSSD& ssdadldc) :
   fModules(NULL),
   fModIndProcessed(ssdadldc.fModIndProcessed),
   fModIndRead(ssdadldc.fModIndRead),
+  fModIndex(NULL),
   fNumberOfEvents(ssdadldc.fNumberOfEvents),
   fLdcId(ssdadldc.fLdcId),
   fRunId(ssdadldc.fRunId),
@@ -131,6 +138,7 @@ AliITSHandleDaSSD& AliITSHandleDaSSD::operator = (const AliITSHandleDaSSD& ssdad
     delete [] fModules; 
     fModules = NULL;
   }
+  if (fModIndex) { delete [] fModIndex; fModIndex = NULL; }
   if ((ssdadldc.fNumberOfModules > 0) && (ssdadldc.fModules)) {
     fModules = new (nothrow) AliITSModuleDaSSD* [ssdadldc.fNumberOfModules];
     if (fModules) {
@@ -168,6 +176,7 @@ AliITSHandleDaSSD::~AliITSHandleDaSSD()
     }
     delete [] fModules;
   }
+  if (fModIndex) delete [] fModIndex;
 }
 
 
@@ -180,7 +189,8 @@ void AliITSHandleDaSSD::Reset()
     for (Int_t i = 0; i < fNumberOfModules; i++) if (fModules[i]) delete fModules[i];
     delete [] fModules;
     fModules = NULL;
-  }  
+  }
+  if (fModIndex) { delete [] fModIndex; fModIndex = NULL; }
   fRawDataFileName = NULL;
   fModIndProcessed = fModIndRead = 0;
   fNumberOfEvents = 0;
@@ -209,7 +219,6 @@ Bool_t AliITSHandleDaSSD::Init(Char_t *rdfname, const Char_t *configfname)
     return kFALSE;
   }  
   if (rawreaderdate->NextEvent()) {
-    fLdcId = rawreaderdate->GetLDCId();
     fRunId = rawreaderdate->GetRunNumber(); 
     rawreaderdate->RewindEvents();
   } else { MakeZombie(); return kFALSE; }
@@ -221,6 +230,7 @@ Bool_t AliITSHandleDaSSD::Init(Char_t *rdfname, const Char_t *configfname)
     nofstripsev = 0;
     nofeqipmentev = 0;
     while (rawreaderdate->ReadNextData(data)) {
+      fLdcId = rawreaderdate->GetLDCId();
       nofeqipmentev += 1;
       datasize = rawreaderdate->GetDataSize();
       eqbelsize = rawreaderdate->GetEquipmentElementSize();
@@ -246,6 +256,11 @@ Bool_t AliITSHandleDaSSD::Init(Char_t *rdfname, const Char_t *configfname)
   {
     fNumberOfEvents = physeventind;
     fRawDataFileName = rdfname;
+    fModIndex = new (nothrow) Int_t [fgkNumberOfSSDModulesPerDdl * eqn];
+    if (fModIndex) 
+      for (Int_t i = 0; i < fgkNumberOfSSDModulesPerDdl * eqn; i++) fModIndex[i] = -1; 
+    else AliWarning(Form("AliITSHandleDaSSD: Error Init(%s): Index array for %i modules was not created", 
+                                     rdfname, fgkNumberOfSSDModulesPerDdl * eqn));
     if (SetNumberOfModules(fgkNumberOfSSDModules)) {
       TString str = TString::Format("Max number of equipment: %i, max number of channels: %i\n", eqn, strn);
       DumpInitData(str.Data());
@@ -381,10 +396,10 @@ Bool_t AliITSHandleDaSSD::ReadCalibrationDataFile (char* fileName, const Long_t
   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(databyte)) {
+      fLdcId = rawreaderdate->GetLDCId();
       data = reinterpret_cast<long32*>(databyte);
       Int_t     equipid    = rawreaderdate->GetEquipmentId();              //  EquipmentID required to access to rorc
       Int_t     equiptype  = rawreaderdate->GetEquipmentType();            //
@@ -434,7 +449,7 @@ Int_t AliITSHandleDaSSD::ReadModuleRawData (const Int_t modulesnumber)
   AliITSModuleDaSSD   *module;
   AliITSChannelDaSSD  *strip;
   Long_t            datasize, eventind = 0;
-  Int_t             nofstrips, eqbelsize;
+  Int_t             nofstrips, eqbelsize, nofeqipmentev;
   UShort_t          modind;
   long32           *data;
   UChar_t          *databyte;
@@ -447,6 +462,7 @@ Int_t AliITSHandleDaSSD::ReadModuleRawData (const Int_t modulesnumber)
   modind = 0;
   while (rawreaderdate->NextEvent()) {
     if ((rawreaderdate->GetType() != PHYSICS_EVENT) && (rawreaderdate->GetType() != CALIBRATION_EVENT)) continue;
+    nofeqipmentev = 0;
     while (rawreaderdate->ReadNextData(databyte)) {
       data = reinterpret_cast<long32*>(databyte);
       Int_t     equipid    = rawreaderdate->GetEquipmentId();              //  EquipmentID required to access to rorc
@@ -467,7 +483,10 @@ Int_t AliITSHandleDaSSD::ReadModuleRawData (const Int_t modulesnumber)
         Short_t   signal  = (Short_t)(data[strind] & 0x00000FFF);
                   signal  = (signal > AliITSChannelDaSSD::GetUnderflowConst()) ? (signal - 2 * AliITSChannelDaSSD::GetUnderflowConst()) 
                                                                               : signal;
-        Int_t modpos = GetModuleIndex(ddlID, ad, adc);
+
+        Int_t indpos = (nofeqipmentev * fgkNumberOfSSDModulesPerDdl)
+                       + ((ad - 1) * fgkNumberOfSSDModulesPerSlot) + (adc < 6 ? adc : (adc - 2));
+       Int_t modpos = fModIndex[indpos];
         if (((modpos > 0) && (modpos < fModIndRead)) || ((modpos < 0) && (modind == modulesnumber))) continue;
        if ((modpos < 0) && (modind < modulesnumber)) {
          module = new AliITSModuleDaSSD(AliITSModuleDaSSD::GetStripsPerModuleConst());
@@ -476,6 +495,7 @@ Int_t AliITSHandleDaSSD::ReadModuleRawData (const Int_t modulesnumber)
          modpos = fModIndRead + modind;
          modind += 1;
          fModules[modpos] = module;
+         fModIndex[indpos] = modpos;
        } 
         if (!(strip = fModules[modpos]->GetStrip(stripID))) {
           strip = new AliITSChannelDaSSD(stripID, fNumberOfEvents);
@@ -483,6 +503,7 @@ Int_t AliITSHandleDaSSD::ReadModuleRawData (const Int_t modulesnumber)
         }
         strip->SetSignal(eventind, signal);
       } 
+      nofeqipmentev += 1;
     }
     if (++eventind > fNumberOfEvents) break;
   }
@@ -619,7 +640,7 @@ Bool_t AliITSHandleDaSSD::CalculateNoiseCM(AliITSModuleDaSSD *const module)
       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;
+      continue; //return kFALSE;
     }
     Int_t chipind = strind / AliITSModuleDaSSD::GetStripsPerChip();
     Double_t nsum = 0.0L;
@@ -632,7 +653,7 @@ Bool_t AliITSHandleDaSSD::CalculateNoiseCM(AliITSModuleDaSSD *const module)
     else  noise = AliITSChannelDaSSD::GetUndefinedValue();
     strip->SetNoiseCM(noise);
   }
-return kTRUE;
+  return kTRUE;
 }
 
 
@@ -762,7 +783,7 @@ TObjArray* AliITSHandleDaSSD::GetCalibrationSSDLDC() const
       delete ldcc;
       return NULL;
     }
-    modcalibobj = dynamic_cast<TObject*>(fModules[i]->GetCalibrationSSDModule());
+    modcalibobj = dynamic_cast<TObject*>(fModules[i]->GetCalibrationNoise());
     ldcc->AddAt(modcalibobj, i);
   }
   ldcc->Compress();
@@ -774,21 +795,32 @@ TObjArray* AliITSHandleDaSSD::GetCalibrationSSDLDC() const
 Bool_t AliITSHandleDaSSD::SaveCalibrationSSDLDC(Char_t*& dafname) const
 {
 // Save Calibration data locally
-  TObjArray      *ldcc;
-  TObject        *modcalibobj;
+  TObjArray      *ldcn, *ldcp, *ldcbc;
+  TObject        *modobjn, *modobjp, *modobjbc;
   Char_t         *tmpfname;
   TString         dadatafilename("");
   if (!fModules) return kFALSE;
-  ldcc = new TObjArray(fNumberOfModules, 0);
+  ldcn = new TObjArray(fNumberOfModules, 0);
+  ldcn->SetName("Noise");
+  ldcp = new TObjArray(fNumberOfModules, 0);
+  ldcp->SetName("Pedestal");
+  ldcbc = new TObjArray(fNumberOfModules, 0);
+  ldcbc->SetName("BadChannels");
   for (Int_t i = 0; i < fNumberOfModules; i++) {
     if (!fModules[i]) {
-      delete ldcc;
+      delete ldcn;
       return kFALSE;
     }
-    modcalibobj = dynamic_cast<TObject*>(fModules[i]->GetCalibrationSSDModule());
-    ldcc->AddAt(modcalibobj, i);
+    modobjn = dynamic_cast<TObject*>(fModules[i]->GetCalibrationNoise());
+    modobjp = dynamic_cast<TObject*>(fModules[i]->GetCalibrationPedestal());
+    modobjbc = dynamic_cast<TObject*>(fModules[i]->GetCalibrationBadChannels());
+    ldcn->AddAt(modobjn, i);
+    ldcp->AddAt(modobjp, i);
+    ldcbc->AddAt(modobjbc, i);
   }
-  ldcc->Compress();
+  ldcn->Compress();
+  ldcp->Compress();
+  ldcbc->Compress();
   if (dafname) dadatafilename.Form("%s/", dafname);
   dadatafilename += TString::Format("ITSSSDda_%i_%i.root", fLdcId, fRunId);
   tmpfname = new Char_t[dadatafilename.Length()+1];
@@ -796,16 +828,22 @@ Bool_t AliITSHandleDaSSD::SaveCalibrationSSDLDC(Char_t*& dafname) const
   TFile *fileRun = new TFile (dadatafilename.Data(),"RECREATE");
   if (fileRun->IsZombie()) {
     AliError(Form("AliITSHandleDaSSD: SaveCalibrationSSDLDC() error open file %s", dadatafilename.Data()));
-    ldcc->Delete();
+    ldcn->Delete();
     delete fileRun;
-    delete ldcc;
+    delete ldcn;
+    delete ldcp;
+    delete ldcbc;
     return kFALSE;
   }
-  fileRun->WriteTObject(ldcc);
+  fileRun->WriteTObject(ldcn);
+  fileRun->WriteTObject(ldcp);
+  fileRun->WriteTObject(ldcbc);
   fileRun->Close();
-  ldcc->Delete();
+  ldcn->Delete();
   delete fileRun;
-  delete ldcc;
+  delete ldcn;
+  delete ldcp;
+  delete ldcbc;
   return kTRUE;
 }
 

diff --git a/ITS/AliITSHandleDaSSD.h b/ITS/AliITSHandleDaSSD.h
index 2a6e201571e91b5849a31e3abc0493eeeb587dbf..8944ee8f1284e3a07506431ef674fd3495ed6d29 100644 (file)
--- a/ITS/AliITSHandleDaSSD.h
+++ b/ITS/AliITSHandleDaSSD.h
@@ -4,7 +4,7 @@
 /* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 /*                                                                        */
-/* $Id$ */
+/* $Id:$ */
 
 #include "TObject.h"
 #include "AliITSModuleDaSSD.h"
@@ -13,7 +13,8 @@
 ///
 /// This class provides ITS SSD data handling
 /// used by DA. 
-///
+//  Author: Oleksandr Borysov
+//  Date: 14/02/2008
 ///////////////////////////////////////////////////////////////////////////////
 
 class TObjArray;
@@ -70,7 +71,8 @@ class AliITSHandleDaSSD : public TObject {
 
   protected :
     static const Int_t    fgkNumberOfSSDModules ;        // Number of SSD modules in ITS
-    static const Int_t    fgkNumberOfSSDModulesPerDdl;   // Number of SSD modules in ITS
+    static const Int_t    fgkNumberOfSSDModulesPerDdl;   // Number of SSD modules in DDL
+    static const Int_t    fgkNumberOfSSDModulesPerSlot;  // Number of SSD modules in Slot
     static const Float_t  fgkPedestalThresholdFactor;    // Defalt value for fPedestalThresholdFactor 
     static const Float_t  fgkCmThresholdFactor;          // Defalt value for fCmThresholdFactor 
 
@@ -79,6 +81,7 @@ class AliITSHandleDaSSD : public TObject {
     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)
+    Int_t               *fModIndex;              //! index array for fModules
     Long_t               fNumberOfEvents;        // Number of physics or calibration events in raw data file fRawDataFileName
     
     UInt_t               fLdcId;                 //  LDC number, read from header
@@ -90,7 +93,7 @@ class AliITSHandleDaSSD : public TObject {
   private :
     Bool_t   SignalOutOfRange (const Short_t signal) const { return (signal >= AliITSChannelDaSSD::GetOverflowConst()); }
 
-    ClassDef(AliITSHandleDaSSD, 2)
+    ClassDef(AliITSHandleDaSSD, 3)
 
 };
 

diff --git a/ITS/AliITSModuleDaSSD.cxx b/ITS/AliITSModuleDaSSD.cxx
index 3be79ece2c693ed9e73af3c89f36909cb6c32c86..95773b5aba3600a8e20c6425849f242cb758653a 100644 (file)
--- a/ITS/AliITSModuleDaSSD.cxx
+++ b/ITS/AliITSModuleDaSSD.cxx
@@ -13,7 +13,7 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$  */
+/* $Id:$  */
 
 ///////////////////////////////////////////////////////////////////////////////
 ///
@@ -23,6 +23,8 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "AliITSNoiseSSD.h"
+#include "AliITSPedestalSSD.h"
+#include "AliITSBadChannelsSSD.h"
 #include "AliITSModuleDaSSD.h"
 #include "TString.h"
 #include "AliLog.h"
@@ -405,7 +407,7 @@ Float_t  AliITSModuleDaSSD::GetCM(const Int_t chipn, const Long_t evn)   const
 
 
 //______________________________________________________________________________
-AliITSNoiseSSD* AliITSModuleDaSSD::GetCalibrationSSDModule() const
+AliITSNoiseSSD* AliITSModuleDaSSD::GetCalibrationNoise() const
 {
 // Creates the AliITSNoiseSSD objects with callibration data
   AliITSNoiseSSD  *mc;
@@ -424,3 +426,53 @@ AliITSNoiseSSD* AliITSModuleDaSSD::GetCalibrationSSDModule() const
   }
   return mc;
 }
+
+
+
+//______________________________________________________________________________
+AliITSPedestalSSD* AliITSModuleDaSSD::GetCalibrationPedestal() const
+{
+// Creates the AliITSPedestalSSD objects with callibration data
+  AliITSPedestalSSD  *mc;
+  Float_t             ped;
+  if (!fStrips) return NULL;
+  mc = new AliITSPedestalSSD();
+  mc->SetMod(fModuleId);
+  mc->SetNPedestalP(fgkPNStripsPerModule);
+  mc->SetNPedestalN(fgkPNStripsPerModule);
+  for (Int_t i = 0; i < fNumberOfStrips; i++) {
+    if (!fStrips[i]) ped = AliITSChannelDaSSD::GetUndefinedValue();
+    else  ped = fStrips[i]->GetPedestal();
+    if (i < fgkPNStripsPerModule)
+          mc->AddPedestalP(i, ped);
+    else  mc->AddPedestalN((AliITSChannelDaSSD::GetMaxStripIdConst() - i), ped);                     
+  }
+  return mc;
+}
+
+
+
+//______________________________________________________________________________
+AliITSBadChannelsSSD* AliITSModuleDaSSD::GetCalibrationBadChannels() const
+{
+// Creates the AliITSBadChannelsSSD objects with callibration data
+  AliITSBadChannelsSSD  *mc;
+  Int_t                 *chlist, nch = 0, nchn = 0, nchp = 0;
+  if (!fStrips) return NULL;
+  chlist = new Int_t [GetStripsPerModuleConst()];
+  for (Int_t i = 0; i < fNumberOfStrips; i++) {
+    if (!fStrips[i]) { chlist[nch++] = i; if (i < fgkPNStripsPerModule) nchp++; else nchn++; continue;}
+    if (fStrips[i]->GetNoiseCM() == AliITSChannelDaSSD::GetUndefinedValue())
+       { chlist[nch++] = i; if (i < fgkPNStripsPerModule) nchp++; else nchn++; }
+  }
+  mc = new AliITSBadChannelsSSD();
+  mc->SetMod(fModuleId);
+  if (!nch) return mc;
+  mc->SetNBadPChannelsList(nchp);
+  mc->SetNBadNChannelsList(nchn);
+  for (Int_t i = 0; i < nch; i++) {
+    if (chlist[i] < fgkPNStripsPerModule) mc->AddBadPChannel(chlist[i], i);
+    else mc->AddBadNChannel((AliITSChannelDaSSD::GetMaxStripIdConst() - chlist[i]), (i-nchp));
+  }
+  return mc;
+}

diff --git a/ITS/AliITSModuleDaSSD.h b/ITS/AliITSModuleDaSSD.h
index ed6f5c59dcc54b3a169d34d46fbdae685928f28a..44704c16b57f9ed9c0bc24def6ecadcd17328656 100644 (file)
--- a/ITS/AliITSModuleDaSSD.h
+++ b/ITS/AliITSModuleDaSSD.h
@@ -5,10 +5,10 @@
 /* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 /*                                                                        */
-/* $Id$ */
+/* $Id:$ */
 ///////////////////////////////////////////////////////////////////////////////
 ///
-/// This class provides storage container ITS SSD module callibration data
+/// This class provides storage container ITS SSD module calibration data
 /// used by DA. 
 ///
 ///////////////////////////////////////////////////////////////////////////////
@@ -18,6 +18,8 @@
 #include "AliITSChannelDaSSD.h"
 
 class AliITSNoiseSSD;
+class AliITSPedestalSSD;
+class AliITSBadChannelsSSD;
 
 class AliITSModuleDaSSD : public TObject {
   public :
@@ -43,7 +45,9 @@ class AliITSModuleDaSSD : public TObject {
     Int_t        GetNumberOfChips() const  { return fNumberOfChips; }
     AliITSChannelDaSSD*  GetStrip(const Int_t stripnumber)  const 
                                 { return (fStrips) ? fStrips[stripnumber] : NULL; }
-    AliITSNoiseSSD* GetCalibrationSSDModule() const;
+    AliITSNoiseSSD*       GetCalibrationNoise() const;
+    AliITSPedestalSSD*    GetCalibrationPedestal() const;
+    AliITSBadChannelsSSD* GetCalibrationBadChannels() const;
     Bool_t  SetEventsNumber(const Long_t eventsnumber);
     Bool_t  SetNumberOfStrips(const Int_t numberofstrips);
     Bool_t  SetNumberOfChips(const Int_t nchips);
@@ -75,7 +79,7 @@ class AliITSModuleDaSSD : public TObject {
     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
-    Short_t        fModuleId;       // Module number          0-1697
+    Short_t        fModuleId;       // Module number          500-2197
     
     Int_t                 fNumberOfStrips;     // Number of AliITSChannelDaSSD* allocated
     AliITSChannelDaSSD  **fStrips;             //[fNumberOfStrips]  Array of *AliITSChannelDaSSD