PWG0/TPC/AliROCRawAnalysisSelector.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18
  19 #include "AliROCRawAnalysisSelector.h"
  20
  21 #include <AliLog.h>
  22
  23 #include <AliRawEvent.h>
  24 #include <AliRawReaderRoot.h>
  25 #include <AliRawEventHeaderBase.h>
  26 #include <AliTPCRawStream.h>
  27 #include <AliTPCParamSR.h>
  28
  29 #include <TFile.h>
  30 #include <TTree.h>
  31 #include <TCanvas.h>
  32 #include <TTimeStamp.h>
  33 #include <TROOT.h>
  34
  35 #include <TPC/AliTPCRawHistograms.h>
  36
  37
  38 ClassImp(AliROCRawAnalysisSelector)
  39
  40 AliROCRawAnalysisSelector::AliROCRawAnalysisSelector() :
  41   TSelector(),
  42   fRawEvent(0),
  43   fTree(0),
  44   fParam(0)
  45 {
  46   //
  47   // Constructor. Initialization of pointers
  48   //
  49
  50   for (Int_t i=0; i<kTPCSectors; i++)
  51     fHistograms[i] = 0;
  52
  53   fParam = new AliTPCParamSR;
  54 }
  55
  56 AliROCRawAnalysisSelector::~AliROCRawAnalysisSelector()
  57 {
  58   //
  59   // Destructor
  60   //
  61 }
  62
  63 void AliROCRawAnalysisSelector::SlaveBegin(TTree* tree)
  64 {
  65   //
  66
  67   if (tree != 0)
  68     Init(tree);
  69 }
  70
  71 void AliROCRawAnalysisSelector::Init(TTree* tree)
  72 {
  73   // The Init() function is called when the selector needs to initialize
  74   // a new tree or chain. Typically here the branch addresses of the tree
  75   // will be set. It is normaly not necessary to make changes to the
  76   // generated code, but the routine can be extended by the user if needed.
  77   // Init() will be called many times when running with PROOF.
  78
  79   fTree = tree;
  80
  81   // Set branch address
  82   if (tree)
  83   {
  84     AliDebug(AliLog::kInfo, "INFO: Tree found");
  85
  86     tree->SetBranchAddress("rawevent", &fRawEvent);
  87   }
  88 }
  89
  90 Bool_t AliROCRawAnalysisSelector::Process(Long64_t entry)
  91 {
  92   //
  93   //
  94   //
  95
  96   AliDebug(AliLog::kInfo, Form("Processing event %lld", entry));
  97
  98   fTree->GetTree()->GetEntry(entry);
  99
 100   if (!fRawEvent)
 101   {
 102     AliDebug(AliLog::kError, "fRawEvent empty");
 103     return kFALSE;
 104   }
 105
 106   AliRawReaderRoot* rawReader = new AliRawReaderRoot(fRawEvent);
 107
 108   const AliRawEventHeaderBase* eventHeader = dynamic_cast<const AliRawEventHeaderBase*> (rawReader->GetEventHeader());
 109   if (eventHeader)
 110   {
 111     eventHeader->Print();
 112
 113     UInt_t timeStamp = eventHeader->Get("Timestamp");
 114     UInt_t eventType = eventHeader->Get("Type");
 115
 116     AliDebug(AliLog::kInfo, Form("Time stamp: %s, event type %d", TTimeStamp(timeStamp).AsString(), eventType));
 117   }
 118
 119   AliTPCRawStream* tpcRawStream = new AliTPCRawStream(rawReader);
 120
 121   const Int_t kNIS = fParam->GetNInnerSector();
 122   const Int_t kNOS = fParam->GetNOuterSector();
 123   const Int_t kNS = kNIS + kNOS;
 124
 125   for (Int_t sector = 0; sector < kNS; sector++)
 126   {
 127     AliDebug(AliLog::kInfo, Form("*** Looking at sector %d ***", sector));
 128
 129     Int_t nRows = 0;
 130     Int_t nDDLs = 0, indexDDL = 0;
 131
 132     if (sector < kNIS)
 133     {
 134       nRows = fParam->GetNRowLow();
 135       nDDLs = 2;
 136       indexDDL = sector * 2;
 137     }
 138     else
 139     {
 140       nRows = fParam->GetNRowUp();
 141       nDDLs = 4;
 142       indexDDL = (sector-kNIS) * 4 + kNIS * 2;
 143     }
 144
 145     // Loas the raw data for corresponding DDLs
 146     rawReader->Reset();
 147     rawReader->Select("TPC",indexDDL,indexDDL+nDDLs-1);
 148
 149     AliDebug(AliLog::kDebug, Form("Selected DDLs %d ... %d", indexDDL, indexDDL+nDDLs-1));
 150
 151     Int_t count = 0;
 152
 153     while (tpcRawStream->Next())
 154     {
 155           if (tpcRawStream->GetSector() != sector)
 156       {
 157             AliDebug(AliLog::kError, Form("Sector index mismatch ! Expected (%d), but got (%d) !",sector,tpcRawStream->GetSector()));
 158             return kFALSE;
 159       }
 160
 161       if ((count++ % 100000) == 0)
 162             AliDebug(AliLog::kDebug, Form("Found %d. digit in sector %d: row %d, pad %d, time %d, signal %d", count,
 163             tpcRawStream->GetSector(), tpcRawStream->GetRow(), tpcRawStream->GetPad(), tpcRawStream->GetTime(), tpcRawStream->GetSignal()));
 164
 165       if (!fHistograms[sector])
 166       {
 167         // not sure if this is still needed, should prevent creation of the histogram in the opened root file
 168         gROOT->cd();
 169         fHistograms[sector] = new AliTPCRawHistograms(sector);
 170       }
 171
 172       fHistograms[sector]->FillDigit(tpcRawStream);
 173     }
 174   }
 175
 176   delete fRawEvent;
 177   fRawEvent = 0;
 178
 179   return kTRUE;
 180 }
 181
 182 void AliROCRawAnalysisSelector::SlaveTerminate()
 183 {
 184   //
 185   for (Int_t i=0; i<kTPCSectors; i++)
 186    if (fHistograms[i])
 187      fOutput->Add(fHistograms[i]);
 188 }
 189
 190 void AliROCRawAnalysisSelector::Terminate()
 191 {
 192   AliDebug(AliLog::kInfo, "Terminate....");
 193
 194   // TODO read from output list for PROOF
 195
 196   TFile* file = TFile::Open("rocRaw.root", "RECREATE");
 197
 198   for (Int_t i=0; i<kTPCSectors; i++)
 199     if (fHistograms[i])
 200       fHistograms[i]->SaveHistograms();
 201
 202   file->Close();
 203
 204   for (Int_t i=0; i<kTPCSectors; i++)
 205     if (fHistograms[i])
 206       fHistograms[i]->DrawHistograms();
 207 }