[u/mrichter/AliRoot.git] / MONITOR / AliMonitorITS.cxx

/**************************************************************************
 * 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.                  *
 **************************************************************************/

/* $Id$ */

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  This class creates and fills the monitor histograms for the ITS          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////


#include "AliMonitorITS.h"
#include "AliMonitorHisto.h"
#include "AliITSgeom.h"
#include "AliITSRawStreamSDD.h"
#include "AliITSRawStreamSSD.h"
#include "AliITSclusterV2.h"
#include "AliITStrackV2.h"
#include "AliRunLoader.h"
#include "AliRawReader.h"
#include <TFolder.h>
#include <TTree.h>


ClassImp(AliMonitorITS) 


//_____________________________________________________________________________
AliMonitorITS::AliMonitorITS(AliITSgeom* geom)
{
// create a ITS monitor object with the given geometry

  fGeom = geom;
}


//_____________________________________________________________________________
AliMonitorITS::AliMonitorITS(const AliMonitorITS& monitor) :
  AliMonitor(monitor)
{
  Fatal("AliMonitorITS", "copy constructor not implemented");
}

//_____________________________________________________________________________
AliMonitorITS& AliMonitorITS::operator = (const AliMonitorITS& /*monitor*/)
{
  Fatal("operator =", "assignment operator not implemented");
  return *this;
}

//_____________________________________________________________________________
void AliMonitorITS::CreateHistos(TFolder* folder)
{
// create the ITS monitor histograms

  fFolder = folder->AddFolder("ITS", "ITS");

  fSDDDigitsCharge = CreateHisto1("SDDDigitsCharge", 
				  "charge distribution of SDD digits", 
				  128, 0, 256, "charge", "#Delta N/N",
				  AliMonitorHisto::kNormEvents);

  fSSDDigitsCharge = CreateHisto1("SSDDigitsCharge", 
				  "charge distribution of SSD digits", 
				  100, 0, 200, "charge", "#Delta N/N",
				  AliMonitorHisto::kNormEvents);

  fSDDClustersCharge = CreateHisto1("SDDClustersCharge", 
				    "charge distribution of SDD clusters", 
				    100, 0, 200, "charge", "#Delta N/N",
				    AliMonitorHisto::kNormEvents);

  fSSDClustersCharge = CreateHisto1("SSDClustersCharge", 
				    "charge distribution of SSD clusters", 
				    100, 0, 400, "charge", "#Delta N/N",
				    AliMonitorHisto::kNormEvents);

  Int_t nModulesSPD = fGeom->GetLastSPD() - fGeom->GetStartSPD() + 1;
  fSPDNClustersVsModule = CreateHisto1("SPDNClustersVsModule", 
				       "mean number of clusters per SPD module", 
				       nModulesSPD, -0.5, nModulesSPD-0.5,
				       "module", "<N_{clusters}>",
				       AliMonitorHisto::kNormEvents);

  Int_t nModulesSDD = fGeom->GetLastSDD() - fGeom->GetStartSDD() + 1;
  fSDDNClustersVsModule = CreateHisto1("SDDNClustersVsModule", 
				       "mean number of clusters per SDD module", 
				       nModulesSDD, -0.5, nModulesSDD-0.5,
				       "module", "<N_{clusters}>",
				       AliMonitorHisto::kNormEvents);

  Int_t nModulesSSD = fGeom->GetLastSSD() - fGeom->GetStartSSD() + 1;
  fSSDNClustersVsModule = CreateHisto1("SSDNClustersVsModule", 
				       "mean number of clusters per SSD module", 
				       nModulesSSD, -0.5, nModulesSSD-0.5,
				       "module", "<N_{clusters}>",
				       AliMonitorHisto::kNormEvents);

  Int_t nLayer = fGeom->GetNlayers();
  fNClustersVsLayer = CreateHisto1("NClustersVsLayer", 
				   "mean number of clusters per layer", 
				   nLayer, 0.5, nLayer+0.5, 
				   "layer", "<N_{clusters}>",
				   AliMonitorHisto::kNormEvents);

  fNTracks = CreateHisto1("NTracks", "number of tracks per event", 
			  300, 0, 30000, "N_{tracks}", "#Delta N/N",
			  AliMonitorHisto::kNormEvents);

  fNTracksITSTPC = CreateHisto2("NTracksTPCITS", 
				"correlation of number of ITS and TPC tracks per event", 
				30, 0, 30000, 30, 0, 30000, 
				"N_{tracks}(ITS)", "N_{tracks}(TPC)", 
				"#Delta N/N", AliMonitorHisto::kNormEvents);

  fTrackPt = CreateHisto1("TrackPt", "pt distribution of tracks", 
			  90, 0, 3, "p_{t} [GeV/c]", "#Delta N/N",
			  AliMonitorHisto::kNormEntries);

  fTrackEta = CreateHisto1("TrackEta", "eta distribution of tracks", 
			   100, -2, 2, "#eta", "#Delta N/N",
			   AliMonitorHisto::kNormEntries);

  fTrackPhi = CreateHisto1("TrackPhi", "phi distribution of tracks", 
			   120, 0, 360, "#phi [#circ]", "#Delta N/N",
			   AliMonitorHisto::kNormEntries);

  fTrackDEdxVsP = CreateHisto2("TrackDEdxVsP", "dE/dx of tracks", 
			       100, 0, 3, 100, 0, 150, 
			       "p [GeV/c]", "dE/dx", "#Delta N/N",
			       AliMonitorHisto::kNormEntries);
}


//_____________________________________________________________________________
void AliMonitorITS::FillHistos(AliRunLoader* runLoader, 
			       AliRawReader* rawReader)
{
// fill the ITS monitor histogrms

  rawReader->Reset();
  AliITSRawStreamSDD inputSDD(rawReader);
  while (inputSDD.Next()) {
    fSDDDigitsCharge->Fill(inputSDD.GetSignal());
  }

  rawReader->Reset();
  AliITSRawStreamSSD inputSSD(rawReader);
  while (inputSSD.Next()) {
    fSSDDigitsCharge->Fill(inputSSD.GetSignal());
  }

  AliLoader* itsLoader = runLoader->GetLoader("ITSLoader");
  if (!itsLoader) return;


  itsLoader->LoadRecPoints();
  TTree* clustersTree = itsLoader->TreeR();
  if (!clustersTree) return;
  TClonesArray* clusters = new TClonesArray("AliITSclusterV2");
  clustersTree->SetBranchAddress("Clusters", &clusters);

  for (Int_t iModule = 0; iModule < clustersTree->GetEntries(); iModule++) {
    clustersTree->GetEntry(iModule);
    Int_t iLayer, iLadder, iDetector;
    fGeom->GetModuleId(iModule, iLayer, iLadder, iDetector);

    for (Int_t j = 0; j < clusters->GetEntriesFast(); j++) {
      AliITSclusterV2* cluster = (AliITSclusterV2*) clusters->At(j);
      switch (iLayer) {
      case 1: case 2: {
	fSPDNClustersVsModule->Fill(iModule - fGeom->GetStartSPD());
	break;
      }
      case 3: case 4: {
	fSDDClustersCharge->Fill(cluster->GetQ());
	fSDDNClustersVsModule->Fill(iModule - fGeom->GetStartSDD());
	break;
      }
      case 5: case 6: {
	fSSDClustersCharge->Fill(cluster->GetQ());
	fSSDNClustersVsModule->Fill(iModule - fGeom->GetStartSSD());
	break;
      }
      }
      fNClustersVsLayer->Fill(iLayer);
    }
  }

  delete clusters;
  itsLoader->UnloadRecPoints();


  itsLoader->LoadTracks();
  TTree* tracks = itsLoader->TreeT();
  if (!tracks) return;
  AliITStrackV2* track = new AliITStrackV2;
  tracks->SetBranchAddress("tracks", &track);

  fNTracks->Fill(tracks->GetEntries());
  for (Int_t i = 0; i < tracks->GetEntries(); i++) {
    tracks->GetEntry(i);
    fTrackPt->Fill(track->Pt());
    fTrackEta->Fill(track->Eta());
    fTrackPhi->Fill(track->Phi() * TMath::RadToDeg());
    fTrackDEdxVsP->Fill(track->P(), track->GetdEdx());
  }

  AliLoader* tpcLoader = runLoader->GetLoader("TPCLoader");
  if (tpcLoader) {
    tpcLoader->LoadTracks();
    TTree* tracksTPC = tpcLoader->TreeT();
    if (tracksTPC) {
      fNTracksITSTPC->Fill(tracks->GetEntries(), tracksTPC->GetEntries());
    }
    tpcLoader->UnloadTracks();
  }

  delete track;
  itsLoader->UnloadTracks();
}
Commit	Line	Data
04fa961a	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 ITS //
	21	// //
	22	///////////////////////////////////////////////////////////////////////////////
	23
	24
	25	#include "AliMonitorITS.h"
	26	#include "AliMonitorHisto.h"
c4bd737c	27	#include "AliITSgeom.h"
04fa961a	28	#include "AliITSRawStreamSDD.h"
	29	#include "AliITSRawStreamSSD.h"
	30	#include "AliITSclusterV2.h"
	31	#include "AliITStrackV2.h"
c4bd737c	32	#include "AliRunLoader.h"
c6ba6205	33	#include "AliRawReader.h"
c4bd737c	34	#include <TFolder.h>
c4bd737c	35	#include <TTree.h>
04fa961a	36
	37
	38	ClassImp(AliMonitorITS)
	39
	40
	41	//_____________________________________________________________________________
	42	AliMonitorITS::AliMonitorITS(AliITSgeom* geom)
	43	{
	44	// create a ITS monitor object with the given geometry
	45
	46	fGeom = geom;
	47	}
	48
	49
c4bd737c	50	//_____________________________________________________________________________
	51	AliMonitorITS::AliMonitorITS(const AliMonitorITS& monitor) :
	52	AliMonitor(monitor)
	53	{
	54	Fatal("AliMonitorITS", "copy constructor not implemented");
	55	}
	56
	57	//_____________________________________________________________________________
	58	AliMonitorITS& AliMonitorITS::operator = (const AliMonitorITS& /monitor/)
	59	{
	60	Fatal("operator =", "assignment operator not implemented");
	61	return *this;
	62	}
	63
04fa961a	64	//_____________________________________________________________________________
	65	void AliMonitorITS::CreateHistos(TFolder* folder)
	66	{
	67	// create the ITS monitor histograms
	68
	69	fFolder = folder->AddFolder("ITS", "ITS");
	70
	71	fSDDDigitsCharge = CreateHisto1("SDDDigitsCharge",
	72	"charge distribution of SDD digits",
	73	128, 0, 256, "charge", "#Delta N/N",
	74	AliMonitorHisto::kNormEvents);
	75
	76	fSSDDigitsCharge = CreateHisto1("SSDDigitsCharge",
	77	"charge distribution of SSD digits",
	78	100, 0, 200, "charge", "#Delta N/N",
	79	AliMonitorHisto::kNormEvents);
	80
	81	fSDDClustersCharge = CreateHisto1("SDDClustersCharge",
	82	"charge distribution of SDD clusters",
	83	100, 0, 200, "charge", "#Delta N/N",
	84	AliMonitorHisto::kNormEvents);
	85
	86	fSSDClustersCharge = CreateHisto1("SSDClustersCharge",
	87	"charge distribution of SSD clusters",
	88	100, 0, 400, "charge", "#Delta N/N",
	89	AliMonitorHisto::kNormEvents);
	90
	91	Int_t nModulesSPD = fGeom->GetLastSPD() - fGeom->GetStartSPD() + 1;
	92	fSPDNClustersVsModule = CreateHisto1("SPDNClustersVsModule",
	93	"mean number of clusters per SPD module",
	94	nModulesSPD, -0.5, nModulesSPD-0.5,
	95	"module", "<N_{clusters}>",
	96	AliMonitorHisto::kNormEvents);
	97
	98	Int_t nModulesSDD = fGeom->GetLastSDD() - fGeom->GetStartSDD() + 1;
	99	fSDDNClustersVsModule = CreateHisto1("SDDNClustersVsModule",
	100	"mean number of clusters per SDD module",
	101	nModulesSDD, -0.5, nModulesSDD-0.5,
	102	"module", "<N_{clusters}>",
	103	AliMonitorHisto::kNormEvents);
	104
	105	Int_t nModulesSSD = fGeom->GetLastSSD() - fGeom->GetStartSSD() + 1;
	106	fSSDNClustersVsModule = CreateHisto1("SSDNClustersVsModule",
	107	"mean number of clusters per SSD module",
	108	nModulesSSD, -0.5, nModulesSSD-0.5,
	109	"module", "<N_{clusters}>",
	110	AliMonitorHisto::kNormEvents);
	111
	112	Int_t nLayer = fGeom->GetNlayers();
	113	fNClustersVsLayer = CreateHisto1("NClustersVsLayer",
	114	"mean number of clusters per layer",
	115	nLayer, 0.5, nLayer+0.5,
	116	"layer", "<N_{clusters}>",
	117	AliMonitorHisto::kNormEvents);
	118
	119	fNTracks = CreateHisto1("NTracks", "number of tracks per event",
	120	300, 0, 30000, "N_{tracks}", "#Delta N/N",
	121	AliMonitorHisto::kNormEvents);
	122
	123	fNTracksITSTPC = CreateHisto2("NTracksTPCITS",
	124	"correlation of number of ITS and TPC tracks per event",
	125	30, 0, 30000, 30, 0, 30000,
	126	"N_{tracks}(ITS)", "N_{tracks}(TPC)",
	127	"#Delta N/N", AliMonitorHisto::kNormEvents);
128
129	fTrackPt = CreateHisto1("TrackPt", "pt distribution of tracks",
130	90, 0, 3, "p_{t} [GeV/c]", "#Delta N/N",
131	AliMonitorHisto::kNormEntries);
132
133	fTrackEta = CreateHisto1("TrackEta", "eta distribution of tracks",
134	100, -2, 2, "#eta", "#Delta N/N",
135	AliMonitorHisto::kNormEntries);
136
137	fTrackPhi = CreateHisto1("TrackPhi", "phi distribution of tracks",
138	120, 0, 360, "#phi [#circ]", "#Delta N/N",
139	AliMonitorHisto::kNormEntries);
140
141	fTrackDEdxVsP = CreateHisto2("TrackDEdxVsP", "dE/dx of tracks",
142	100, 0, 3, 100, 0, 150,
143	"p [GeV/c]", "dE/dx", "#Delta N/N",
144	AliMonitorHisto::kNormEntries);
145	}
146
147
148	//_____________________________________________________________________________
149	void AliMonitorITS::FillHistos(AliRunLoader* runLoader,
150	AliRawReader* rawReader)
151	{
152	// fill the ITS monitor histogrms
153
154	rawReader->Reset();
155	AliITSRawStreamSDD inputSDD(rawReader);
156	while (inputSDD.Next()) {
157	fSDDDigitsCharge->Fill(inputSDD.GetSignal());
158	}
159
160	rawReader->Reset();
161	AliITSRawStreamSSD inputSSD(rawReader);
162	while (inputSSD.Next()) {
163	fSSDDigitsCharge->Fill(inputSSD.GetSignal());
164	}
165
166	AliLoader* itsLoader = runLoader->GetLoader("ITSLoader");
167	if (!itsLoader) return;
168
169
170	itsLoader->LoadRecPoints();
171	TTree* clustersTree = itsLoader->TreeR();
172	if (!clustersTree) return;
173	TClonesArray* clusters = new TClonesArray("AliITSclusterV2");
174	clustersTree->SetBranchAddress("Clusters", &clusters);
175
176	for (Int_t iModule = 0; iModule < clustersTree->GetEntries(); iModule++) {
177	clustersTree->GetEntry(iModule);
178	Int_t iLayer, iLadder, iDetector;
179	fGeom->GetModuleId(iModule, iLayer, iLadder, iDetector);
180
181	for (Int_t j = 0; j < clusters->GetEntriesFast(); j++) {
182	AliITSclusterV2* cluster = (AliITSclusterV2*) clusters->At(j);
183	switch (iLayer) {
184	case 1: case 2: {
185	fSPDNClustersVsModule->Fill(iModule - fGeom->GetStartSPD());
186	break;
187	}
188	case 3: case 4: {
189	fSDDClustersCharge->Fill(cluster->GetQ());
190	fSDDNClustersVsModule->Fill(iModule - fGeom->GetStartSDD());
191	break;
192	}
193	case 5: case 6: {
194	fSSDClustersCharge->Fill(cluster->GetQ());
195	fSSDNClustersVsModule->Fill(iModule - fGeom->GetStartSSD());
196	break;
197	}
198	}
199	fNClustersVsLayer->Fill(iLayer);
200	}
201	}
202
203	delete clusters;
204	itsLoader->UnloadRecPoints();
205
206
207	itsLoader->LoadTracks();
208	TTree* tracks = itsLoader->TreeT();
209	if (!tracks) return;
210	AliITStrackV2* track = new AliITStrackV2;
211	tracks->SetBranchAddress("tracks", &track);
212
213	fNTracks->Fill(tracks->GetEntries());
214	for (Int_t i = 0; i < tracks->GetEntries(); i++) {
215	tracks->GetEntry(i);
216	fTrackPt->Fill(track->Pt());
217	fTrackEta->Fill(track->Eta());
218	fTrackPhi->Fill(track->Phi() * TMath::RadToDeg());
219	fTrackDEdxVsP->Fill(track->P(), track->GetdEdx());
220	}
221
222	AliLoader* tpcLoader = runLoader->GetLoader("TPCLoader");
223	if (tpcLoader) {
224	tpcLoader->LoadTracks();
225	TTree* tracksTPC = tpcLoader->TreeT();
226	if (tracksTPC) {
227	fNTracksITSTPC->Fill(tracks->GetEntries(), tracksTPC->GetEntries());
228	}
229	tpcLoader->UnloadTracks();
230	}
231
232	delete track;
233	itsLoader->UnloadTracks();
234	}