- AliITSRawStreamSPDErrorLog.cxx, .h
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 14 Nov 2008 11:35:28 +0000 (11:35 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 14 Nov 2008 11:35:28 +0000 (11:35 +0000)
some updates by Henrik basically for using the class in SPDmood

- AliITSRawStreamSPD.cxx, .h
same as above + my addition of the method GetOfflineChipKeyFromOnline()
(SPD chip numbering 0-1199, same definition used in the PlaneEff framework)

- AliITSClusterFinderV2SPD.cxx
it now uses GetOfflineChipKeyFromOnline() to compute the chip key
when filling the FastOr bit map

- AliITSDetTypeRec.cxx, .h
added the SPDFastOr part in GetCalibrationSPD() method

- AliITSFastOrCalibrationSPD.cxx, .h
new class to store in the OCDB the map of FastOrConfigured chips as a
TBits

D. Elia

12 files changed:
ITS/AliITSClusterFinderV2SPD.cxx
ITS/AliITSDetTypeRec.cxx
ITS/AliITSDetTypeRec.h
ITS/AliITSFastOrCalibrationSPD.cxx [new file with mode: 0644]
ITS/AliITSFastOrCalibrationSPD.h [new file with mode: 0644]
ITS/AliITSRawStreamSPD.cxx
ITS/AliITSRawStreamSPD.h
ITS/AliITSRawStreamSPDErrorLog.cxx
ITS/AliITSRawStreamSPDErrorLog.h
ITS/CMake_libITSbase.txt
ITS/ITSbaseLinkDef.h
ITS/libITSbase.pkg

index a9de7da..fc33d76 100644 (file)
@@ -297,9 +297,7 @@ void AliITSClusterFinderV2SPD::FindClustersSPD(AliITSRawStreamSPD* input,
     for(UInt_t hs=0; hs<6; hs++) {
       for(UInt_t chip=0; chip<10; chip++) {
         if(input->GetFastOrSignal(eq,hs,chip)) {
-          UInt_t module = input->GetOfflineModuleFromOnline(eq,hs,chip);
-          UInt_t chipInModule = ( chip>4 ? chip-5 : chip );
-          UInt_t chipKey = module*5 + chipInModule;
+          UInt_t chipKey = input->GetOfflineChipKeyFromOnline(eq,hs,chip);
           fDetTypeRec->SetFastOrFiredMap(chipKey);
         }
       }
index 09ab31c..7381399 100644 (file)
@@ -71,6 +71,7 @@ fSegmentation(0),
 fCalibration(0),
 fSSDCalibration(0),
 fSPDDead(0),
+fSPDFastOr(0),
 fPreProcess(0),
 fPostProcess(0),
 fDigits(0),
@@ -128,6 +129,7 @@ fSegmentation(rec.fSegmentation),
 fCalibration(rec.fCalibration),
 fSSDCalibration(rec.fSSDCalibration),
 fSPDDead(rec.fSPDDead),
+fSPDFastOr(rec.fSPDFastOr),
 fPreProcess(rec.fPreProcess),
 fPostProcess(rec.fPostProcess),
 fDigits(rec.fDigits),
@@ -454,7 +456,8 @@ Bool_t AliITSDetTypeRec::GetCalibrationSPD(Bool_t cacheStatus) {
 
   AliCDBEntry *entrySPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDNoisy");
   AliCDBEntry *deadSPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDDead");
-  if(!entrySPD || !deadSPD ){
+  AliCDBEntry *fastOrSPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDFastOr");
+  if(!entrySPD || !deadSPD || !fastOrSPD ){
     AliFatal("SPD Calibration object retrieval failed! ");
     return kFALSE;
   }    
@@ -467,11 +470,16 @@ Bool_t AliITSDetTypeRec::GetCalibrationSPD(Bool_t cacheStatus) {
   if(!cacheStatus)deadSPD->SetObject(NULL);
   deadSPD->SetOwner(kTRUE);
 
+  AliITSFastOrCalibrationSPD *calfastOrSPD = (AliITSFastOrCalibrationSPD *)fastOrSPD->GetObject();
+  if(!cacheStatus)fastOrSPD->SetObject(NULL);
+  fastOrSPD->SetOwner(kTRUE);
+
   if(!cacheStatus){
     delete entrySPD;
     delete deadSPD;
+    delete fastOrSPD;
   }
-  if ((!calSPD) || (!caldeadSPD)){ 
+  if ((!calSPD) || (!caldeadSPD) || (!calfastOrSPD)){ 
     AliWarning("Can not get SPD calibration from calibration database !");
     return kFALSE;
   }
@@ -485,6 +493,7 @@ Bool_t AliITSDetTypeRec::GetCalibrationSPD(Bool_t cacheStatus) {
     cal = (AliITSCalibration*) caldeadSPD->At(i);
     SetSPDDeadModel(i, cal);
   }
+  fSPDFastOr = calfastOrSPD;
 
   return kTRUE;
 }
index 8c40dfc..01ca3c3 100644 (file)
@@ -16,6 +16,7 @@ $Id$
 #include <TClonesArray.h>
 #include <TBits.h>
 #include "AliITSDDLModuleMapSDD.h"
+#include "AliITSFastOrCalibrationSPD.h"
 #include "AliITSresponseSDD.h"
 #include "AliITSgeom.h"
 class TTree;
@@ -56,6 +57,7 @@ class AliITSDetTypeRec : public TObject {
     virtual Bool_t GetCalibrationSPD(Bool_t cacheStatus);
     virtual Bool_t GetCalibrationSDD(Bool_t cacheStatus);
     virtual Bool_t GetCalibrationSSD(Bool_t cacheStatus);
+    virtual AliITSFastOrCalibrationSPD* GetFastOrCalibrationSPD() const { return fSPDFastOr;}
     virtual AliITSsegmentation* GetSegmentationModel(Int_t dettype);
     virtual AliITSCalibration* GetCalibrationModel(Int_t iMod);
     virtual AliITSCalibration* GetSPDDeadModel(Int_t iMod);
@@ -102,7 +104,7 @@ class AliITSDetTypeRec : public TObject {
     void DigitsToRecPoints(TTree *treeD,TTree *treeR,Int_t lastEntry,Option_t *det, Int_t optCluFind=0);
     void DigitsToRecPoints(AliRawReader* rawReader,TTree *treeR,Option_t *det="All");
 
-    void   SetFastOrFiredMap(UInt_t chip){fFastOrFiredMap.SetBitNumber(chip);}
+    void   SetFastOrFiredMap(UInt_t chipKey){fFastOrFiredMap.SetBitNumber(chipKey);} 
     TBits  GetFastOrFiredMap() const {return fFastOrFiredMap;}
     void   ResetFastOrFiredMap(){fFastOrFiredMap.ResetAllBits();}
 
@@ -133,6 +135,7 @@ class AliITSDetTypeRec : public TObject {
     TObjArray    *fCalibration;   //! [NMod]
     AliITSCalibrationSSD* fSSDCalibration;  //! SSD calibration object
     TObjArray    *fSPDDead;       //! [fgkDefaultNModulesSPD]
+    AliITSFastOrCalibrationSPD *fSPDFastOr; // Map of FastOr configured chips
     TObjArray    *fPreProcess;    //! [] e.g. Find Calibration values
     TObjArray    *fPostProcess;   //! [] e.g. find primary vertex
     TObjArray    *fDigits;        //! [NMod][NDigits]
@@ -155,7 +158,7 @@ class AliITSDetTypeRec : public TObject {
 
     TBits fFastOrFiredMap;     // Map of FastOr fired chips
 
-    ClassDef(AliITSDetTypeRec,15) // ITS Reconstruction structure
+    ClassDef(AliITSDetTypeRec,16) // ITS Reconstruction structure
 };
 
 #endif
diff --git a/ITS/AliITSFastOrCalibrationSPD.cxx b/ITS/AliITSFastOrCalibrationSPD.cxx
new file mode 100644 (file)
index 0000000..35db352
--- /dev/null
@@ -0,0 +1,58 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+#include "AliITSFastOrCalibrationSPD.h"
+///////////////////////////////////////////////////////////////////////////
+//
+//  Calibration class for the SPD FastOr configuration info
+//  
+//  C. Di Giglio Carmelo.Digiglio@ba.infn.it
+//  D. Elia      Domenico.Elia@ba.infn.it 
+//
+///////////////////////////////////////////////////////////////////////////
+
+ClassImp(AliITSFastOrCalibrationSPD)
+
+//-----------------------------------------------
+//Deafault constructor
+AliITSFastOrCalibrationSPD::AliITSFastOrCalibrationSPD():
+TObject(),
+fFastOrConfiguredChips(1200)
+{
+// constructor
+}
+
+//Default destructor
+AliITSFastOrCalibrationSPD::~AliITSFastOrCalibrationSPD() {}
+//____________________________________________________________________________________________
+Bool_t AliITSFastOrCalibrationSPD::WriteFOConfToDB(Int_t runNrStart, Int_t runNrEnd)  {
+
+  AliCDBManager* man = AliCDBManager::Instance();
+
+  if(!man->IsDefaultStorageSet()) {
+     man->SetDefaultStorage("local://$ALICE_ROOT");
+  }
+
+  AliCDBMetaData* metaData = new AliCDBMetaData();
+  metaData->SetResponsible("Domenico Elia");
+  metaData->SetComment("Created by storeFastOrConfToDB.C");
+  AliCDBId idCalSPD("ITS/Calib/SPDFastOr",runNrStart,runNrEnd);
+  AliCDBEntry* cdbEntry = new AliCDBEntry(this,idCalSPD,metaData);
+  man->Put(cdbEntry);
+  delete cdbEntry;
+  delete metaData;
+
+  return kTRUE;
+}
diff --git a/ITS/AliITSFastOrCalibrationSPD.h b/ITS/AliITSFastOrCalibrationSPD.h
new file mode 100644 (file)
index 0000000..d78b496
--- /dev/null
@@ -0,0 +1,32 @@
+#ifndef AliITSFastOrCalibrationSPD_H
+#define AliITSFastOrCalibrationSPD_H
+
+#include <TObject.h>
+#include <TBits.h>
+#include <AliCDBManager.h>
+#include <AliCDBMetaData.h>
+#include <AliCDBEntry.h>
+
+
+class AliITSFastOrCalibrationSPD : public TObject{
+ public:
+    AliITSFastOrCalibrationSPD(); //default constructor
+    virtual ~AliITSFastOrCalibrationSPD(); //destructor
+
+    //setters          
+    void   SetFastOrConfiguredChips(UInt_t chipKey) {fFastOrConfiguredChips.SetBitNumber(chipKey);}
+    void   ResetFastOrConfiguredChips() {fFastOrConfiguredChips.ResetAllBits();}
+
+    //getters
+    TBits  GetFastOrConfiguredChips() const {return fFastOrConfiguredChips;}
+    Bool_t TestFastOrConfiguredChips(UInt_t chipKey) const {return fFastOrConfiguredChips.TestBitNumber(chipKey);}
+
+    Bool_t WriteFOConfToDB(Int_t runNrStart, Int_t runNrEnd); 
+
+ private:
+    TBits  fFastOrConfiguredChips;     // Map of FastOr configured chips
+
+    ClassDef(AliITSFastOrCalibrationSPD,1) 
+};
+
+#endif
index de58c2a..e6be7e3 100644 (file)
@@ -707,6 +707,16 @@ UInt_t AliITSRawStreamSPD::GetOfflineModuleFromOnline(UInt_t eqId, UInt_t hs, UI
   else return 240;
 }
 //__________________________________________________________________________
+UInt_t AliITSRawStreamSPD::GetOfflineChipKeyFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip) {
+  // online->offline (chip key: 0-1199)
+  if (eqId<20 && hs<6 && chip<10) {
+    UInt_t module = GetOfflineModuleFromOnline(eqId,hs,chip);
+    UInt_t chipInModule = ( chip>4 ? chip-5 : chip ); 
+    if(eqId>9) chipInModule = 4 - chipInModule;  // side C only
+    return (module*5 + chipInModule);
+  } else return 1200;
+}
+//__________________________________________________________________________
 UInt_t AliITSRawStreamSPD::GetOfflineColFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col) {
   // online->offline (col)
   if (eqId>=20 || hs>=6 || chip>=10 || col>=32) return 160; // error
@@ -734,7 +744,3 @@ UInt_t AliITSRawStreamSPD::GetOfflineRowFromOnline(UInt_t eqId, UInt_t hs, UInt_
   if (eqId>=20 || hs>=6 || chip>=10 || row>=256) return 256; // error
   return 255-row;
 }
-
-
-
-
index dceff95..4e23c76 100644 (file)
@@ -51,6 +51,7 @@ class AliITSRawStreamSPD: public AliITSRawStream {
     static UInt_t GetOnlineRowFromOffline(UInt_t module, UInt_t rowM);
     // coordinate conversions - online->offline
     static UInt_t GetOfflineModuleFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip);
+    static UInt_t GetOfflineChipKeyFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip);
     static UInt_t GetOfflineColFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col);
     static UInt_t GetOfflineRowFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t row);
 
@@ -88,6 +89,8 @@ class AliITSRawStreamSPD: public AliITSRawStream {
     UInt_t GetHTPAmp(UInt_t hs) const;
     Bool_t GetHminTHchipPresent(UInt_t chip) const;
     void   ActivateAdvancedErrorLog(Bool_t activate, AliITSRawStreamSPDErrorLog* advLogger = NULL);
+    AliITSRawStreamSPDErrorLog* GetAdvancedErrorLog() {return fAdvLogger;}
+
     static const Char_t* GetErrorName(UInt_t errorCode);
 
 
index 11c903e..665db99 100644 (file)
@@ -26,6 +26,7 @@ AliITSRawStreamSPDErrorLog::AliITSRawStreamSPDErrorLog() :
     fSuppressEq[eq] = kFALSE;
     for (UInt_t err=0; err<kNrErrorCodes; err++) {
       fNErrors[err][eq] = 0;
+      fNErrorsTotal[err][eq] = 0;
     }
   }
   for (UInt_t err=0; err<kNrErrorCodes; err++) {
@@ -41,6 +42,7 @@ AliITSRawStreamSPDErrorLog::AliITSRawStreamSPDErrorLog(const AliITSRawStreamSPDE
   for (UInt_t eq=0; eq<20; eq++) {
     for (UInt_t err=0; err<kNrErrorCodes; err++) {
       fNErrors[err][eq] = logger.fNErrors[err][eq];
+      fNErrorsTotal[err][eq] = logger.fNErrorsTotal[err][eq];
       fErrEventCounter[err][eq] = logger.fErrEventCounter[err][eq];
     }
     fNEvents[eq] = logger.fNEvents[eq];
@@ -79,6 +81,7 @@ AliITSRawStreamSPDErrorLog& AliITSRawStreamSPDErrorLog::operator=(const AliITSRa
     for (UInt_t eq=0; eq<20; eq++) {
       for (UInt_t err=0; err<kNrErrorCodes; err++) {
        fNErrors[err][eq] = logger.fNErrors[err][eq];
+       fNErrorsTotal[err][eq] = logger.fNErrorsTotal[err][eq];
        fErrEventCounter[err][eq] = logger.fErrEventCounter[err][eq];
       }
       fNEvents[eq] = logger.fNEvents[eq];
@@ -160,6 +163,7 @@ void AliITSRawStreamSPDErrorLog::DeleteHistograms() const {
 void AliITSRawStreamSPDErrorLog::Reset() {
   // Reset
   fText->Clear();
+  fTextTmpGeneral->Clear();
   for (UInt_t eq=0; eq<20; eq++) {
     fTextTmp[eq]->Clear();
     fConsErrType[eq]->Reset();
@@ -167,6 +171,7 @@ void AliITSRawStreamSPDErrorLog::Reset() {
     fNEvents[eq] = 0;
     for (UInt_t err=0; err<kNrErrorCodes; err++) {
       fNErrors[err][eq] = 0;
+      fNErrorsTotal[err][eq] = 0;
       delete fConsErrEvent[err][eq];
       delete fConsErrPos[err][eq];
       delete fConsErrPosTMP[err][eq];
@@ -189,7 +194,11 @@ void AliITSRawStreamSPDErrorLog::ProcessError(UInt_t errorCode, UInt_t eq, Int_t
   // check if we want to exclude the error...
   if (!(fSuppressMess[errorCode] || fSuppressEq[eq])) {
     fNErrors[errorCode][eq]++;
-    if (errorCode!=kTotal) fNErrors[kTotal][eq]++;
+    fNErrorsTotal[errorCode][eq]++;
+    if (errorCode!=kTotal) {
+      fNErrors[kTotal][eq]++;
+      fNErrorsTotal[kTotal][eq]++;
+    }
 
     if (bytesRead>=0) {
       fConsErrPosTMP[errorCode][eq]->SetPoint(fErrPosTMPCounter[errorCode][eq],0,bytesRead+fByteOffset[eq]);
@@ -216,8 +225,27 @@ void AliITSRawStreamSPDErrorLog::AddMessage(const Char_t *errMess) {
   fTextTmpGeneral->InsLine(fTextTmpGeneral->RowCount(),errMess);
 }
 //________________________________________________________________________________________________
-void AliITSRawStreamSPDErrorLog::SummarizeEvent(UInt_t eventNum) {
-  // summarize the information for the current event
+void AliITSRawStreamSPDErrorLog::ResetEvent() {
+  // reset error counters for current event
+  for (UInt_t eq=0; eq<20; eq++) {
+    for (UInt_t err=0; err<kNrErrorCodes; err++) {
+      fNErrors[err][eq]=0;
+    }
+    fByteOffset[eq]=0;
+    fTextTmpGeneral->Clear();
+    fTextTmp[eq]->Clear();
+  }
+
+  for (UInt_t eq=0; eq<20; eq++) {
+    for (UInt_t err=0; err<kNrErrorCodes; err++) {
+      delete fConsErrPosTMP[err][eq];
+      fErrPosTMPCounter[err][eq] = 0;
+      fConsErrPosTMP[err][eq] = new TGraph();
+    }
+  }
+}
+//________________________________________________________________________________________________
+void AliITSRawStreamSPDErrorLog::AddErrorMessagesFromCurrentEvent(UInt_t eventNum) {
   TString msg;
   if (fText->RowCount()>5000) {
     fText->Clear();
@@ -228,12 +256,41 @@ void AliITSRawStreamSPDErrorLog::SummarizeEvent(UInt_t eventNum) {
     msg = Form("*** Event %d , General Errors: ***",eventNum);
     fText->InsLine(fText->RowCount(),msg.Data());
     fText->AddText(fTextTmpGeneral);
-    fTextTmpGeneral->Clear();
+    //    fTextTmpGeneral->Clear();
+  }
+
+  for (UInt_t eq=0; eq<20; eq++) {
+    if (fNErrors[kTotal][eq]>0) {
+      msg = Form("*** Event %d , Eq %d: ***",eventNum,eq);
+      fText->InsLine(fText->RowCount(),msg.Data());
+      fText->AddText(fTextTmp[eq]);
+      fText->InsLine(fText->RowCount()," ");
+    }
+    //    fTextTmp[eq]->Clear();
   }
+}
+//________________________________________________________________________________________________
+void AliITSRawStreamSPDErrorLog::ProcessEvent(UInt_t eventNum) {
+  // summarize the information for the current event
+//  TString msg;
+//  if (fText->RowCount()>5000) {
+//    fText->Clear();
+//    msg = "*** previous errors cleared ***";
+//    fText->InsLine(fText->RowCount(),msg.Data());
+//  }
+//  if (fTextTmpGeneral->RowCount()>1) {
+//    msg = Form("*** Event %d , General Errors: ***",eventNum);
+//    fText->InsLine(fText->RowCount(),msg.Data());
+//    fText->AddText(fTextTmpGeneral);
+//    fTextTmpGeneral->Clear();
+//  }
+
+  AddErrorMessagesFromCurrentEvent(eventNum);
+
   for (UInt_t eq=0; eq<20; eq++) {
     for (UInt_t err=0; err<kNrErrorCodes; err++) {
       fConsErrType[eq]->Fill(err,fNErrors[err][eq]);
-      if (fNErrors[err][eq]>0){
+      if (fNErrors[err][eq]>0) {
        fConsErrEvent[err][eq]->SetPoint(fErrEventCounter[err][eq],eventNum,fNErrors[err][eq]);
        fErrEventCounter[err][eq]++;
        fConsErrFraction[eq]->Fill(err);
@@ -247,26 +304,23 @@ void AliITSRawStreamSPDErrorLog::SummarizeEvent(UInt_t eventNum) {
     }
 
     fNEvents[eq]++;
-    if (fNErrors[kTotal][eq]>0) {
-      msg = Form("*** Event %d , Eq %d: ***",eventNum,eq);
-      fText->InsLine(fText->RowCount(),msg.Data());
-      fText->AddText(fTextTmp[eq]);
-      fText->InsLine(fText->RowCount()," ");
-    }
-    fByteOffset[eq]=0;
-    fTextTmp[eq]->Clear();
-    for (UInt_t err=0; err<kNrErrorCodes; err++) {
-      fNErrors[err][eq]=0;
-    }
+//    if (fNErrors[kTotal][eq]>0) {
+//      msg = Form("*** Event %d , Eq %d: ***",eventNum,eq);
+//      fText->InsLine(fText->RowCount(),msg.Data());
+//      fText->AddText(fTextTmp[eq]);
+//      fText->InsLine(fText->RowCount()," ");
+//    }
+//    fByteOffset[eq]=0;
+//    fTextTmp[eq]->Clear();
   }
 
-  for (UInt_t eq=0; eq<20; eq++) {
-    for (UInt_t err=0; err<kNrErrorCodes; err++) {
-      delete fConsErrPosTMP[err][eq];
-      fErrPosTMPCounter[err][eq] = 0;
-      fConsErrPosTMP[err][eq] = new TGraph();
-    }
-  }
+}
+//________________________________________________________________________________________________
+void AliITSRawStreamSPDErrorLog::SummarizeEvent(UInt_t eventNum) {
+  // summarize the information for the current event 
+  //  (could be replaced by calls to 'StartEvent' and 'EndEvent')
+  ProcessEvent(eventNum);
+  ResetEvent();
 }
 //________________________________________________________________________________________________
 void AliITSRawStreamSPDErrorLog::SetByteOffset(UInt_t eq, Int_t size) {
@@ -326,7 +380,8 @@ UInt_t AliITSRawStreamSPDErrorLog::GetNrErrorsAllEq(UInt_t errorCode) {
 UInt_t AliITSRawStreamSPDErrorLog::GetNrErrorsTotal(UInt_t errorCode, UInt_t eq) {
   // returns the total number of errors for a specific error code and equipment
   if (errorCode<kNrErrorCodes && eq<20) {
-    return (UInt_t) fConsErrType[eq]->GetBinContent(errorCode+1);
+    return fNErrorsTotal[errorCode][eq];
+    //    return (UInt_t) fConsErrType[eq]->GetBinContent(errorCode+1);
   }
   else {
     AliWarning(Form("Error code (%d) or equipment (%d) out of range, returning 0",errorCode,eq));
@@ -335,11 +390,12 @@ UInt_t AliITSRawStreamSPDErrorLog::GetNrErrorsTotal(UInt_t errorCode, UInt_t eq)
 }
 //________________________________________________________________________________________________
 UInt_t AliITSRawStreamSPDErrorLog::GetNrErrorsTotalAllEq(UInt_t errorCode) {
-  // returns the total number of errors for a specific error code and for all equipment
+  // returns the total number of errors for a specific error code and for all equipments
   if (errorCode<kNrErrorCodes) {
     UInt_t returnval=0;
     for (UInt_t eq=0; eq<20; eq++) {
-      returnval += (UInt_t) fConsErrType[eq]->GetBinContent(errorCode+1);
+      returnval += fNErrorsTotal[errorCode][eq];
+      //      returnval += (UInt_t) fConsErrType[eq]->GetBinContent(errorCode+1);
     }
     return returnval;
   }
@@ -399,3 +455,32 @@ TGraph* AliITSRawStreamSPDErrorLog::GetConsErrPos(UInt_t errorCode, UInt_t eq) {
     return NULL;
   }
 }
+//________________________________________________________________________________________________
+UInt_t AliITSRawStreamSPDErrorLog::GetEventErrPosCounter(UInt_t errorCode, UInt_t eq) {
+  // returns the number of errors with bytes information for current event
+  if (errorCode<kNrErrorCodes && eq<20) return fErrPosTMPCounter[errorCode][eq];
+  else {
+    AliError(Form("Error code (%d) or equipment (%d) out of range, returning 0",errorCode,eq));
+    return 0;
+  }
+}
+//________________________________________________________________________________________________
+UInt_t AliITSRawStreamSPDErrorLog::GetEventErrPos(UInt_t index, UInt_t errorCode, UInt_t eq) {
+  // returns the bytes read for the index'th error of current event
+  if (errorCode<kNrErrorCodes && eq<20) {
+    if (index<fErrPosTMPCounter[errorCode][eq]) {
+      Double_t x,y;
+      fConsErrPosTMP[errorCode][eq]->GetPoint(index,x,y);
+      return (UInt_t) y;
+    }
+    else {
+      AliError(Form("Index %d out of range, returning 0",index));
+    return 0;
+    }
+  }
+  else {
+    AliError(Form("Error code (%d) or equipment (%d) out of range, returning 0",errorCode,eq));
+    return 0;
+  }
+
+}
index 31a238e..5dc9387 100644 (file)
@@ -30,6 +30,10 @@ class AliITSRawStreamSPDErrorLog : public TObject {
   void    Reset();
   void    ProcessError(UInt_t errorCode, UInt_t eq, Int_t bytesRead, Int_t headersRead, const Char_t *errMess);
   void    AddMessage(const Char_t *errMess);
+
+  void    ResetEvent();
+  void    ProcessEvent(UInt_t eventNum);
+  void    AddErrorMessagesFromCurrentEvent(UInt_t eventNum);
   void    SummarizeEvent(UInt_t eventNum);
 
   UInt_t  GetNrErrors(UInt_t errorCode, UInt_t eq);
@@ -49,10 +53,15 @@ class AliITSRawStreamSPDErrorLog : public TObject {
   TH1F*   GetConsErrFraction(UInt_t eq);        // NB!!! Take care of deleting returned object later
   TH1F*   GetConsErrFractionUnScaled(UInt_t eq);
   TGText* GetText() {return fText;}
+  TGText* GetTextThisEvent(UInt_t eq) {if (eq<20) return fTextTmp[eq]; else return NULL;}
+  TGText* GetTextGeneralThisEvent() {return fTextTmpGeneral;}
 
+  UInt_t  GetEventErrPosCounter(UInt_t errorCode, UInt_t eq);
+  UInt_t  GetEventErrPos(UInt_t index, UInt_t errorCode, UInt_t eq);
 
  private:
   Int_t   fNErrors[kNrErrorCodes][20];          // number of errors for this event, for each code and eq
+  Int_t   fNErrorsTotal[kNrErrorCodes][20];     // number of errors for all events, for each code and eq
   UInt_t  fNEvents[20];                         // number of events used, for each eq
   UInt_t  fErrEventCounter[kNrErrorCodes][20];  // event counter used when filling graph
   UInt_t  fErrPosCounter[kNrErrorCodes][20];    // event counter used when filling graph
index 5801c71..82f76da 100644 (file)
@@ -30,6 +30,7 @@ set(SRCS
                AliITSresponseSPD.cxx
                AliITSresponseSDD.cxx
                AliITSCalibrationSPD.cxx
+               AliITSFastOrCalibrationSPD.cxx
                AliITSCalibrationSDD.cxx
                AliITSCalibrationSSD.cxx
                 AliITSChannelStatus.cxx
index a60f901..8cad21f 100644 (file)
@@ -50,6 +50,7 @@
 #pragma link C++ class  AliITSresponseSPD+;
 #pragma link C++ class  AliITSresponseSDD+;
 #pragma link C++ class  AliITSCalibrationSPD-;
+#pragma link C++ class  AliITSFastOrCalibrationSPD+;
 #pragma link C++ class  AliITSCalibrationSDD+;
 #pragma link C++ class  AliITSCalibrationSSD+;
 #pragma link C++ class  AliITSChannelStatus+;
index 0cfaac2..ef019e8 100644 (file)
@@ -29,6 +29,7 @@ SRCS =        AliITSgeom.cxx \
                AliITSresponseSPD.cxx \
                AliITSresponseSDD.cxx \
                AliITSCalibrationSPD.cxx \
+               AliITSFastOrCalibrationSPD.cxx \
                AliITSCalibrationSDD.cxx \
                AliITSCalibrationSSD.cxx \
                 AliITSChannelStatus.cxx \