MONITOR/AliMonitorTPC.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 //                                                                           //
  20 //  This class creates and fills the monitor histograms for the TPC          //
  21 //                                                                           //
  22 ///////////////////////////////////////////////////////////////////////////////
  23
  24
  25 #include "AliMonitorTPC.h"
  26 #include "AliMonitorDataTPC.h"
  27 #include "AliMonitorHisto.h"
  28 #include "AliMonitorTrend.h"
  29 #include "AliTPCParam.h"
  30 #include "AliTPCRawStream.h"
  31 #include "AliTPCClustersRow.h"
  32 #include "AliTPCclusterMI.h"
  33 #include "AliTPCtrack.h"
  34 #include "AliRunLoader.h"
  35 #include "AliRawReader.h"
  36 #include <TFolder.h>
  37 #include <TTree.h>
  38
  39
  40 ClassImp(AliMonitorTPC)
  41
  42
  43 //_____________________________________________________________________________
  44 AliMonitorTPC::AliMonitorTPC(AliTPCParam* param)
  45 {
  46 // create a TPC monitor object with the given parameters
  47
  48   fParam = param;
  49   fData = new AliMonitorDataTPC(10000);
  50 }
  51
  52 //_____________________________________________________________________________
  53 AliMonitorTPC::AliMonitorTPC(const AliMonitorTPC& monitor) :
  54   AliMonitor(monitor)
  55 {
  56   Fatal("AliMonitorTPC", "copy constructor not implemented");
  57 }
  58
  59 //_____________________________________________________________________________
  60 AliMonitorTPC& AliMonitorTPC::operator = (const AliMonitorTPC& /*monitor*/)
  61 {
  62   Fatal("operator =", "assignment operator not implemented");
  63   return *this;
  64 }
  65
  66 //_____________________________________________________________________________
  67 AliMonitorTPC::~AliMonitorTPC()
  68 {
  69   delete fData;
  70 }
  71
  72
  73 //_____________________________________________________________________________
  74 void AliMonitorTPC::CreateHistos(TFolder* folder)
  75 {
  76 // create the TPC monitor histograms
  77
  78   fFolder = folder->AddFolder("TPC", "TPC");
  79
  80   fPadsCharge = CreateHisto1("PadsCharge", "charge distribution of pads",
  81                              100, 0, 200, "charge", "#Delta N/N",
  82                              AliMonitorHisto::kNormEvents);
  83
  84   fClustersCharge = CreateHisto1("ClustersCharge",
  85                                  "charge distribution of clusters",
  86                                  100, 0, 1000, "charge", "#Delta N/N",
  87                                  AliMonitorHisto::kNormEvents);
  88
  89   Int_t nRows = fParam->GetNRowLow() + fParam->GetNRowUp();
  90   fNClustersVsRow = CreateHisto1("NClustersVsRow",
  91                                  "mean number of clusters per pad row",
  92                                  nRows, -0.5, nRows-0.5,
  93                                  "pad row", "<N_{clusters}>",
  94                                  AliMonitorHisto::kNormEvents);
  95
  96   Int_t nSector = fParam->GetNInnerSector();
  97   fNClustersVsSector = CreateHisto1("NClustersVsSector",
  98                                     "mean number of clusters per sector",
  99                                     nSector, -0.5, nSector-0.5,
 100                                     "sector", "<N_{clusters}>",
 101                                     AliMonitorHisto::kNormEvents);
 102
 103   fNTracks = CreateTrend("NTracks", "number of tracks per event",
 104                          "N_{tracks}");
 105
 106   fTrackPt = CreateHisto1("TrackPt", "pt distribution of tracks",
 107                           90, 0, 3, "p_{t} [GeV/c]", "#Delta N/N",
 108                           AliMonitorHisto::kNormNone);
 109
 110   fTrackEta = CreateHisto1("TrackEta", "eta distribution of tracks",
 111                            100, -2, 2, "#eta", "#Delta N/N",
 112                            AliMonitorHisto::kNormEntries);
 113
 114   fTrackPhi = CreateHisto1("TrackPhi", "phi distribution of tracks",
 115                            120, 0, 360, "#phi [#circ]", "#Delta N/N",
 116                            AliMonitorHisto::kNormEntries);
 117   fTrackPhi->SetDescription("The phi distribution should be flat on average.\nIf it is not flat check for dead TPC sectors.");
 118
 119   fTrackNCl = CreateHisto1("TrackNCl", "Number of clusters per track",
 120                            200, 0, 200, "N_{clusters}", "#Delta N/N",
 121                            AliMonitorHisto::kNormNone);
 122
 123   fTrackDEdxVsP = CreateHisto2("TrackDEdxVsP", "dE/dx of tracks",
 124                                100, 0, 3, 100, 0, 200,
 125                                "p [GeV/c]", "dE/dx", "#Delta N/N",
 126                                AliMonitorHisto::kNormEntries);
 127
 128   fTrackDEdx = CreateHisto1("TrackDEdx", "dE/dx of tracks with 0.4<p<1.0 GeV/c",
 129                                50, 0, 100,
 130                                "dE/dx", "#Delta N/N",
 131                                AliMonitorHisto::kNormEntries);
 132
 133   fTrackEtaVsPhi = CreateHisto2("TrackEtaVsPhi", "#phi vs #eta",
 134                                20, -1, 1, 25, 0, 360,
 135                                "#eta", "#phi", "#Delta N/N",
 136                                AliMonitorHisto::kNormNone);
 137
 138   fPtEtaVsPhi = CreateHisto2("PtEtaVsPhi", "#phi vs #eta",
 139                                20, -1, 1, 25, 0, 360,
 140                                "#eta", "#phi", "#Delta N/N",
 141                                AliMonitorHisto::kNormNone);
 142
 143 }
 144
 145
 146 //_____________________________________________________________________________
 147 void AliMonitorTPC::CreateBranches(TTree* tree)
 148 {
 149 // create a branch with TPC variables
 150
 151   tree->Branch("TPC", "AliMonitorDataTPC", &fData);
 152 }
 153
 154
 155 //_____________________________________________________________________________
 156 void AliMonitorTPC::FillHistos(AliRunLoader* runLoader,
 157                                AliRawReader* rawReader)
 158 {
 159 // fill the TPC monitor histogrms
 160
 161   rawReader->Reset();
 162   AliTPCRawStream input(rawReader);
 163   while (input.Next()) {
 164     fPadsCharge->Fill(input.GetSignal());
 165   }
 166
 167   AliLoader* tpcLoader = runLoader->GetLoader("TPCLoader");
 168   if (!tpcLoader) return;
 169
 170
 171   tpcLoader->LoadRecPoints();
 172   TTree* clusters = tpcLoader->TreeR();
 173   if (!clusters) return;
 174   AliTPCClustersRow* clustersRow = new AliTPCClustersRow;
 175   clustersRow->SetClass("AliTPCclusterMI");
 176   clusters->SetBranchAddress("Segment", &clustersRow);
 177
 178   for (Int_t i = 0; i < clusters->GetEntries(); i++) {
 179     clusters->GetEntry(i);
 180     Int_t iSector, iRow;
 181     fParam->AdjustSectorRow(clustersRow->GetID(), iSector, iRow);
 182     if (iSector >= fParam->GetNInnerSector()) {
 183       iRow += fParam->GetNRowLow();
 184       iSector -= fParam->GetNInnerSector();
 185     }
 186
 187     TObjArray* array = clustersRow->GetArray();
 188     for (Int_t j = 0; j < array->GetEntriesFast(); j++) {
 189       AliTPCclusterMI* cluster = (AliTPCclusterMI*) array->At(j);
 190       fClustersCharge->Fill(cluster->GetQ());
 191       fNClustersVsRow->Fill(iRow);
 192       fNClustersVsSector->Fill(iSector);
 193     }
 194   }
 195   fNClustersVsSector->ScaleErrorBy(10.);
 196
 197   delete clustersRow;
 198   tpcLoader->UnloadRecPoints();
 199
 200
 201   tpcLoader->LoadTracks();
 202   TTree* tracks = tpcLoader->TreeT();
 203   if (!tracks) return;
 204   AliTPCtrack* track = new AliTPCtrack;
 205   tracks->SetBranchAddress("tracks", &track);
 206
 207   Int_t nTracks = (Int_t) tracks->GetEntries();
 208   fNTracks->Fill(nTracks);
 209   fData->SetNTracks(nTracks);
 210   for (Int_t i = 0; i < nTracks; i++) {
 211     tracks->GetEntry(i);
 212     fTrackPt->Fill(track->Pt());
 213     fTrackEta->Fill(track->Eta());
 214     fTrackPhi->Fill(track->Phi() * TMath::RadToDeg());
 215     if(track->Pt()>3.) {
 216       fTrackEtaVsPhi->Fill(track->Eta(),track->Phi() * TMath::RadToDeg());
 217       fPtEtaVsPhi->Fill(track->Eta(),track->Phi() * TMath::RadToDeg(),track->Pt());
 218     }
 219     fTrackNCl->Fill(track->GetNumberOfClusters());
 220     fTrackDEdxVsP->Fill(track->P(), track->GetdEdx());
 221     if(track->P()>0.4 && track->P()<1.0)
 222       fTrackDEdx->Fill(track->GetdEdx());
 223
 224     fData->SetData(i, track->Pt(), track->Eta(),
 225                    track->Phi() * TMath::RadToDeg());
 226   }
 227
 228   delete track;
 229   tpcLoader->UnloadTracks();
 230 }