[u/mrichter/AliRoot.git] / MONITOR / AliMonitorHLTHough.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.                  *
 **************************************************************************/


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// This class creates and fills monitor histograms for HLT Hough transform   //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////


#include "AliMonitorHLTHough.h"
#include "AliMonitorHisto.h"
#include "AliMonitorTrend.h"
#include "AliTPCParam.h"
#include "AliLog.h"
#include <TFolder.h>
#include <stdlib.h>
#include <AliL3MemHandler.h>
#include <AliL3TrackArray.h>
#include <AliL3SpacePointData.h>
#include <AliL3HoughTrack.h>
#include <AliL3Transform.h>

//_____________________________________________________________________________
AliMonitorHLTHough::AliMonitorHLTHough(AliTPCParam* param):
  AliMonitor(),
  fParam(param),
  fClustersCharge(NULL),
  fNClustersVsRow(NULL),
  fNClustersVsSector(NULL),
  fNTracks(NULL),
  fTrackPt(NULL),
  fTrackEta(NULL),
  fTrackPhi(NULL),
  fTrackNHits(NULL),
  fTrackDEdxVsP(NULL),
  fTrackDEdx(NULL),
  fTrackEtaVsPhi(NULL),
  fPtEtaVsPhi(NULL)
{
// create a HLT monitor object with the given parameters

}

//_____________________________________________________________________________
void AliMonitorHLTHough::CreateHistos(TFolder* folder)
{
// create the HLT Hough transform monitor histograms

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

  fClustersCharge = CreateHisto1("ClustersCharge", 
				 "charge distribution of clusters", 
				 100, 0, 1000, "charge", "#Delta N/N",
				 AliMonitorHisto::kNormEvents);

  Int_t nRows = fParam->GetNRowLow() + fParam->GetNRowUp();
  fNClustersVsRow = CreateHisto1("NClustersVsRow", 
				 "mean number of clusters per pad row", 
				 nRows, -0.5, nRows-0.5,
				 "pad row", "<N_{clusters}>",
				 AliMonitorHisto::kNormEvents);

  Int_t nSector = fParam->GetNInnerSector();
  fNClustersVsSector = CreateHisto1("NClustersVsSector", 
				    "mean number of clusters per sector", 
				    nSector, -0.5, nSector-0.5, 
				    "sector", "<N_{clusters}>",
				    AliMonitorHisto::kNormEvents);

  fNTracks = CreateTrend("NTracks", "number of tracks per event", 
			 "N_{tracks}");

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

  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);

  fTrackNHits = CreateHisto1("TrackNHits", "Number of hits per track", 
			   200, 0, 200, "N_{hits}", "#Delta N/N",
			   AliMonitorHisto::kNormNone);

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

  fTrackDEdx = CreateHisto1("TrackDEdx", "dE/dx for tracks with 0.4<p<1.0 GeV/c", 
			       50, 0, 300, 
			       "dE/dx", "#Delta N/N",
			       AliMonitorHisto::kNormEntries);

  fTrackEtaVsPhi = CreateHisto2("TrackEtaVsPhi", "#phi vs #eta", 
			       20, -1, 1, 25, 0, 360, 
			       "#eta", "#phi", "#Delta N/N",
			       AliMonitorHisto::kNormNone);

  fPtEtaVsPhi = CreateHisto2("PtEtaVsPhi", "#phi vs #eta", 
			       20, -1, 1, 25, 0, 360, 
			       "#eta", "#phi", "#Delta N/N",
			       AliMonitorHisto::kNormNone);

}


//_____________________________________________________________________________
void AliMonitorHLTHough::FillHistos(AliRunLoader* /*runLoader*/, 
				    AliRawReader* /*rawReader*/, 
				    AliESD* /*esd*/)
{
// fill the HLT Hough transform monitor histograms

  AliL3MemHandler clusterHandler[36][6];
  AliL3SpacePointData *clusters[36][6];
  for (Int_t iSector = 0; iSector < fParam->GetNInnerSector(); iSector++) {
    for (Int_t iPatch = 0; iPatch < 6; iPatch++) {
      char fileName[256];
      sprintf(fileName, "hlt/fitter/points_%d_%d.raw", iSector,iPatch);
      if (!clusterHandler[iSector][iPatch].SetBinaryInput(fileName)) {
	AliWarning(Form("could not open file %s", fileName));
	continue;
      }
      clusters[iSector][iPatch] = (AliL3SpacePointData*) clusterHandler[iSector][iPatch].Allocate();
      UInt_t nClusters = 0;
      clusterHandler[iSector][iPatch].Binary2Memory(nClusters, clusters[iSector][iPatch]);

      for (UInt_t iCluster = 0; iCluster < nClusters; iCluster++) {
	AliL3SpacePointData& cluster = clusters[iSector][iPatch][iCluster];
	fClustersCharge->Fill(cluster.fCharge);
	fNClustersVsRow->Fill(cluster.fPadRow);
	fNClustersVsSector->Fill(iSector);
      }

      clusterHandler[iSector][iPatch].CloseBinaryInput();
    }
  }

  fNClustersVsSector->ScaleErrorBy(10.);


  AliL3MemHandler memHandler;
  Int_t nHoughTracks = 0;

  char fileName[256];
  sprintf(fileName, "hlt/fitter/tracks.raw");
  if (!memHandler.SetBinaryInput(fileName)) {
    AliWarning("could not open file hlt/fitter/tracks.raw");
    return;
  }
  AliL3TrackArray* tracks = new AliL3TrackArray;
  memHandler.Binary2TrackArray(tracks);

  nHoughTracks += tracks->GetNTracks();
  for (Int_t iTrack = 0; iTrack < tracks->GetNTracks(); iTrack++) {
    AliL3HoughTrack *track = (AliL3HoughTrack*)tracks->GetCheckedTrack(iTrack);
    if(!track) continue;

    track->CalculateHelix();
    //  track->Rotate(iSector);

    fTrackPt->Fill(track->GetPt());
    fTrackEta->Fill(track->GetPseudoRapidity());
    fTrackPhi->Fill(track->GetPsi() * TMath::RadToDeg());
    if(track->GetPt()>3.) {
      fTrackEtaVsPhi->Fill(track->GetPseudoRapidity(),track->GetPsi() * TMath::RadToDeg());
      fPtEtaVsPhi->Fill(track->GetPseudoRapidity(),track->GetPsi() * TMath::RadToDeg(),track->GetPt());
    }
    fTrackNHits->Fill(track->GetNHits());

    // Track dEdx
    Int_t nc=track->GetNHits();
    UInt_t *hits = track->GetHitNumbers();
    Float_t sampleDEdx[159];
    for (Int_t iHit = 0; iHit < nc; iHit++) {
      UInt_t hitID = hits[iHit];
      Int_t iSector = (hitID>>25) & 0x7f;
      Int_t iPatch = (hitID>>22) & 0x7;
      UInt_t position = hitID&0x3fffff;
      UChar_t padrow = clusters[iSector][iPatch][position].fPadRow;
      Float_t pWidth = AliL3Transform::GetPadPitchWidthLow();
      if (padrow>63)
	pWidth = AliL3Transform::GetPadPitchWidthUp(); 
      Float_t corr=1.; if (padrow>63) corr=0.67;
      sampleDEdx[iHit] = clusters[iSector][iPatch][position].fCharge/pWidth*corr;
      Double_t crossingangle = track->GetCrossingAngle(padrow,iSector);
      Double_t s = sin(crossingangle);
      Double_t t = track->GetTgl();
      sampleDEdx[iHit] *= TMath::Sqrt((1-s*s)/(1+t*t));
    }

    /* Cook dEdx */
    Int_t i;
    Int_t swap;//stupid sorting
    do {
      swap=0;
      for (i=0; i<nc-1; i++) {
	if (sampleDEdx[i]<=sampleDEdx[i+1]) continue;
	Float_t tmp=sampleDEdx[i];
	sampleDEdx[i]=sampleDEdx[i+1]; sampleDEdx[i+1]=tmp;
	swap++;
      }
    } while (swap);

    Double_t low=0.05; Double_t up=0.7;
    Int_t nl=Int_t(low*nc), nu=Int_t(up*nc);
    Float_t trackDEdx=0;
    for (i=nl; i<=nu; i++) trackDEdx += sampleDEdx[i];
    trackDEdx /= (nu-nl+1);

    fTrackDEdxVsP->Fill(track->GetP(),trackDEdx);
    if(track->GetP()>0.4 && track->GetP()<1.0)
      fTrackDEdx->Fill(trackDEdx);
  }
  fNTracks->Fill(nHoughTracks);

  delete tracks;
  memHandler.CloseBinaryInput();
}
Commit	Line	Data
c6ba6205	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
	17	///////////////////////////////////////////////////////////////////////////////
	18	// //
	19	// This class creates and fills monitor histograms for HLT Hough transform //
	20	// //
	21	///////////////////////////////////////////////////////////////////////////////
	22
	23
	24	#include "AliMonitorHLTHough.h"
	25	#include "AliMonitorHisto.h"
	26	#include "AliMonitorTrend.h"
	27	#include "AliTPCParam.h"
7ba8900c	28	#include "AliLog.h"
c6ba6205	29	#include <TFolder.h>
c6ba6205	30	#include <stdlib.h>
	31	#include <AliL3MemHandler.h>
	32	#include <AliL3TrackArray.h>
4a69f9c7	33	#include <AliL3SpacePointData.h>
c6ba6205	34	#include <AliL3HoughTrack.h>
4a69f9c7	35	#include <AliL3Transform.h>
c6ba6205	36
c6ba6205	37	//_____________________________________________________________________________
17c3cc9e	38	AliMonitorHLTHough::AliMonitorHLTHough(AliTPCParam* param):
	39	AliMonitor(),
	40	fParam(param),
	41	fClustersCharge(NULL),
	42	fNClustersVsRow(NULL),
	43	fNClustersVsSector(NULL),
	44	fNTracks(NULL),
	45	fTrackPt(NULL),
	46	fTrackEta(NULL),
	47	fTrackPhi(NULL),
	48	fTrackNHits(NULL),
	49	fTrackDEdxVsP(NULL),
	50	fTrackDEdx(NULL),
	51	fTrackEtaVsPhi(NULL),
	52	fPtEtaVsPhi(NULL)
c6ba6205	53	{
	54	// create a HLT monitor object with the given parameters
	55
c6ba6205	56	}
c6ba6205	57
c6ba6205	58	//_____________________________________________________________________________
	59	void AliMonitorHLTHough::CreateHistos(TFolder* folder)
	60	{
	61	// create the HLT Hough transform monitor histograms
	62
	63	fFolder = folder->AddFolder("HLTHOUGH", "HLTHOUGH");
	64
4a69f9c7	65	fClustersCharge = CreateHisto1("ClustersCharge",
	66	"charge distribution of clusters",
	67	100, 0, 1000, "charge", "#Delta N/N",
	68	AliMonitorHisto::kNormEvents);
	69
	70	Int_t nRows = fParam->GetNRowLow() + fParam->GetNRowUp();
	71	fNClustersVsRow = CreateHisto1("NClustersVsRow",
	72	"mean number of clusters per pad row",
	73	nRows, -0.5, nRows-0.5,
	74	"pad row", "<N_{clusters}>",
	75	AliMonitorHisto::kNormEvents);
	76
	77	Int_t nSector = fParam->GetNInnerSector();
	78	fNClustersVsSector = CreateHisto1("NClustersVsSector",
	79	"mean number of clusters per sector",
	80	nSector, -0.5, nSector-0.5,
	81	"sector", "<N_{clusters}>",
	82	AliMonitorHisto::kNormEvents);
	83
c6ba6205	84	fNTracks = CreateTrend("NTracks", "number of tracks per event",
	85	"N_{tracks}");
	86
	87	fTrackPt = CreateHisto1("TrackPt", "pt distribution of tracks",
	88	90, 0, 3, "p_{t} [GeV/c]", "#Delta N/N",
	89	AliMonitorHisto::kNormNone);
	90
	91	fTrackEta = CreateHisto1("TrackEta", "eta distribution of tracks",
	92	100, -2, 2, "#eta", "#Delta N/N",
	93	AliMonitorHisto::kNormEntries);
	94
	95	fTrackPhi = CreateHisto1("TrackPhi", "phi distribution of tracks",
	96	120, 0, 360, "#phi [#circ]", "#Delta N/N",
	97	AliMonitorHisto::kNormEntries);
	98
4a69f9c7	99	fTrackNHits = CreateHisto1("TrackNHits", "Number of hits per track",
	100	200, 0, 200, "N_{hits}", "#Delta N/N",
	101	AliMonitorHisto::kNormNone);
	102
	103	fTrackDEdxVsP = CreateHisto2("TrackDEdxVsP", "dE/dx of tracks",
	104	100, 0, 3, 100, 0, 1000,
	105	"p [GeV/c]", "dE/dx", "#Delta N/N",
	106	AliMonitorHisto::kNormEntries);
	107
	108	fTrackDEdx = CreateHisto1("TrackDEdx", "dE/dx for tracks with 0.4<p<1.0 GeV/c",
	109	50, 0, 300,
	110	"dE/dx", "#Delta N/N",
	111	AliMonitorHisto::kNormEntries);
	112
c6ba6205	113	fTrackEtaVsPhi = CreateHisto2("TrackEtaVsPhi", "#phi vs #eta",
	114	20, -1, 1, 25, 0, 360,
	115	"#eta", "#phi", "#Delta N/N",
	116	AliMonitorHisto::kNormNone);
	117
	118	fPtEtaVsPhi = CreateHisto2("PtEtaVsPhi", "#phi vs #eta",
	119	20, -1, 1, 25, 0, 360,
	120	"#eta", "#phi", "#Delta N/N",
	121	AliMonitorHisto::kNormNone);
	122
	123	}
	124
	125
	126	//_____________________________________________________________________________
	127	void AliMonitorHLTHough::FillHistos(AliRunLoader* /runLoader/,
b6a3610d	128	AliRawReader* /rawReader/,
b6a3610d	129	AliESD* /esd/)
c6ba6205	130	{
	131	// fill the HLT Hough transform monitor histograms
	132
4a69f9c7	133	AliL3MemHandler clusterHandler[36][6];
4a69f9c7	134	AliL3SpacePointData *clusters[36][6];
c6ba6205	135	for (Int_t iSector = 0; iSector < fParam->GetNInnerSector(); iSector++) {
4a69f9c7	136	for (Int_t iPatch = 0; iPatch < 6; iPatch++) {
	137	char fileName[256];
	138	sprintf(fileName, "hlt/fitter/points_%d_%d.raw", iSector,iPatch);
	139	if (!clusterHandler[iSector][iPatch].SetBinaryInput(fileName)) {
7ba8900c	140	AliWarning(Form("could not open file %s", fileName));
4a69f9c7	141	continue;
c6ba6205	142	}
4a69f9c7	143	clusters[iSector][iPatch] = (AliL3SpacePointData*) clusterHandler[iSector][iPatch].Allocate();
	144	UInt_t nClusters = 0;
	145	clusterHandler[iSector][iPatch].Binary2Memory(nClusters, clusters[iSector][iPatch]);
	146
	147	for (UInt_t iCluster = 0; iCluster < nClusters; iCluster++) {
	148	AliL3SpacePointData& cluster = clusters[iSector][iPatch][iCluster];
	149	fClustersCharge->Fill(cluster.fCharge);
	150	fNClustersVsRow->Fill(cluster.fPadRow);
	151	fNClustersVsSector->Fill(iSector);
	152	}
	153
	154	clusterHandler[iSector][iPatch].CloseBinaryInput();
	155	}
	156	}
	157
	158	fNClustersVsSector->ScaleErrorBy(10.);
	159
	160
	161	AliL3MemHandler memHandler;
	162	Int_t nHoughTracks = 0;
	163
	164	char fileName[256];
	165	sprintf(fileName, "hlt/fitter/tracks.raw");
	166	if (!memHandler.SetBinaryInput(fileName)) {
7ba8900c	167	AliWarning("could not open file hlt/fitter/tracks.raw");
4a69f9c7	168	return;
	169	}
	170	AliL3TrackArray* tracks = new AliL3TrackArray;
	171	memHandler.Binary2TrackArray(tracks);
	172
	173	nHoughTracks += tracks->GetNTracks();
	174	for (Int_t iTrack = 0; iTrack < tracks->GetNTracks(); iTrack++) {
	175	AliL3HoughTrack track = (AliL3HoughTrack)tracks->GetCheckedTrack(iTrack);
	176	if(!track) continue;
	177
	178	track->CalculateHelix();
	179	// track->Rotate(iSector);
	180
	181	fTrackPt->Fill(track->GetPt());
	182	fTrackEta->Fill(track->GetPseudoRapidity());
	183	fTrackPhi->Fill(track->GetPsi() * TMath::RadToDeg());
	184	if(track->GetPt()>3.) {
	185	fTrackEtaVsPhi->Fill(track->GetPseudoRapidity(),track->GetPsi() * TMath::RadToDeg());
	186	fPtEtaVsPhi->Fill(track->GetPseudoRapidity(),track->GetPsi() * TMath::RadToDeg(),track->GetPt());
	187	}
	188	fTrackNHits->Fill(track->GetNHits());
	189
	190	// Track dEdx
	191	Int_t nc=track->GetNHits();
	192	UInt_t *hits = track->GetHitNumbers();
	193	Float_t sampleDEdx[159];
	194	for (Int_t iHit = 0; iHit < nc; iHit++) {
	195	UInt_t hitID = hits[iHit];
	196	Int_t iSector = (hitID>>25) & 0x7f;
	197	Int_t iPatch = (hitID>>22) & 0x7;
	198	UInt_t position = hitID&0x3fffff;
	199	UChar_t padrow = clusters[iSector][iPatch][position].fPadRow;
	200	Float_t pWidth = AliL3Transform::GetPadPitchWidthLow();
	201	if (padrow>63)
	202	pWidth = AliL3Transform::GetPadPitchWidthUp();
	203	Float_t corr=1.; if (padrow>63) corr=0.67;
	204	sampleDEdx[iHit] = clusters[iSector][iPatch][position].fCharge/pWidth*corr;
	205	Double_t crossingangle = track->GetCrossingAngle(padrow,iSector);
	206	Double_t s = sin(crossingangle);
	207	Double_t t = track->GetTgl();
	208	sampleDEdx[iHit] = TMath::Sqrt((1-ss)/(1+t*t));
c6ba6205	209	}
c6ba6205	210
4a69f9c7	211	/* Cook dEdx */
	212	Int_t i;
	213	Int_t swap;//stupid sorting
	214	do {
	215	swap=0;
	216	for (i=0; i<nc-1; i++) {
	217	if (sampleDEdx[i]<=sampleDEdx[i+1]) continue;
	218	Float_t tmp=sampleDEdx[i];
	219	sampleDEdx[i]=sampleDEdx[i+1]; sampleDEdx[i+1]=tmp;
	220	swap++;
	221	}
	222	} while (swap);
	223
	224	Double_t low=0.05; Double_t up=0.7;
	225	Int_t nl=Int_t(lownc), nu=Int_t(upnc);
	226	Float_t trackDEdx=0;
	227	for (i=nl; i<=nu; i++) trackDEdx += sampleDEdx[i];
	228	trackDEdx /= (nu-nl+1);
	229
	230	fTrackDEdxVsP->Fill(track->GetP(),trackDEdx);
	231	if(track->GetP()>0.4 && track->GetP()<1.0)
	232	fTrackDEdx->Fill(trackDEdx);
c6ba6205	233	}
4a69f9c7	234	fNTracks->Fill(nHoughTracks);
	235
	236	delete tracks;
	237	memHandler.CloseBinaryInput();
c6ba6205	238	}