+2006-08-17 Jochen's TPCLib source code from Jan 2006 (not a joke) merged
+ - bugfix in AliHLTTPCConfMapper (caused low tracking efficiency)
+ - Online Display development
+ - Note: the AliHLTTPCDisplay Interface has been changed -> AliHLTGUI
+ has to be re-linked
+ - no changes in BASE
+
\ No newline at end of file
while(1){ //Loop over current
charge = fDigitReader->GetSignal();
+
+ // CHARGE DEBUG
+ if (fDigitReader->GetRow() == 90){
+///// LOG(AliHLTTPCLog::kFatal,"AliHLTTPCClusterFinder::Row","row90") << "PAD=" << fDigitReader->GetPad() << " TIME=" << fDigitReader->GetTime()
+ // << " SIGNAL=" << fDigitReader->GetSignal() << ENDLOG;
+
+ }
+
+
if(time >= AliHLTTPCTransform::GetNTimeBins()){
LOG(AliHLTTPCLog::kFatal,"AliHLTTPCClusterFinder::ProcessRow","Digits")
<<"Timebin out of range "<<(Int_t)time<<ENDLOG;
Float_t ftime =(Float_t)list[j].fTime / list[j].fTotalCharge;
Float_t ftime2=fZErr*fZErr; //fixed given error
+
+
+
+
+
if(fCalcerr) { //calc the errors, otherwice take the fixed error
Int_t patch = AliHLTTPCTransform::GetPatch(fCurrentRow);
UInt_t q2=list[j].fTotalCharge*list[j].fTotalCharge;
fSpacePointData[counter].fSigmaZ2 = ftime2;
fSpacePointData[counter].fUsed = kFALSE; // only used / set in AliHLTTPCDisplay
+ fSpacePointData[counter].fTrackN = -1; // only used / set in AliHLTTPCDisplay
Int_t patch=fCurrentPatch;
if(patch==-1) patch=0; //never store negative patch number
-// XEmacs -*-C++-*-
// @(#) $Id$
#ifndef ALIHLTTPCCLUSTERFINDERCOMPONENT_H
//read hits
Int_t nhit=(Int_t)count;
for (Int_t i=0;i<nhit;i++)
- {
- fHit[i].Reset();
- fHit[i].ReadHits(&(hits[i]));
+ {
+ fHit[i+fClustersUnused].Reset();
+ fHit[i+fClustersUnused].ReadHits(&(hits[i]));
}
fClustersUnused += nhit;
+
LOG(AliHLTTPCLog::kInformational,"AliHLTTPCConfMapper::ReadHits","#hits")
<<AliHLTTPCLog::kDec<<"hit_counter: "<<nhit<<" count: "<<count<<ENDLOG;
Double_t initCpuTime,cpuTime;
initCpuTime = CpuTime();
-
- SetPointers();
+// END ################################################# MODIFIY JMT
+#if 0
+ SetPointers(); // moved to Component
+#endif
+// END ################################################# MODIFIY JMT
SetVertexConstraint(true);
ClusterLoop();
if(track)//track search - look for nearest neighbor to extrapolated track
{
+// BEGINN ############################################## MODIFIY JMT
+#if 1
+ if (fVertexConstraint) {
+ if(!VerifyRange(starthit,hit))
+ continue;
+ }
+#else
if(!VerifyRange(starthit,hit))
continue;
-
+#endif
+// END ################################################# MODIFIY JMT
testhit = EvaluateHit(starthit,hit,track);
if(testhit == 0)//chi2 not good enough, keep looking
if((dist=CalcDistance(starthit,hit)) < closestdist)
{
- if(!VerifyRange(starthit,hit))
- continue;
+// BEGINN ############################################## MODIFIY JMT
+#if 1
+ if (fVertexConstraint) {
+ if(!VerifyRange(starthit,hit))
+ continue;
+ }
+#else
+ if(!VerifyRange(starthit,hit))
+ continue;
+#endif
+// END ################################################# MODIFIY JMT
closestdist = dist;
closesthit = hit;
// Anders Vestbo <mailto:vestbo@fi.uib.no>
//*-- Copyright © ALICE HLT Group
-
-// Recent Changes:
-// ==============
-// - Rename and Merge of functions / Complete new arrangement in order to use the AliHLTGUI
-// - 3D Geometry
-// - display padrows, cluster, tracks
-// - select single Tracks
-// - select used / unused cluster
-// - Histogram
-// - display padrows
-// - display pads in padrows
+#define TRACKHELIX 0
+#define TRACKPOLYMARKER 0
+#define BACKWARD 0
#include "AliHLTTPCStandardIncludes.h"
#include <TView.h>
#include <THelix.h>
#include <TStyle.h>
#include <TGraph.h>
+#include <TMultiGraph.h>
#include <TAttText.h>
#include <TAxis.h>
+#if TRACKHELIX
+#include <THelix.h>
+#endif
#ifdef use_aliroot
#include <TClonesArray.h>
ClassImp(AliHLTTPCDisplay)
// #############################################################################
-AliHLTTPCDisplay::AliHLTTPCDisplay(Char_t *gfile) {
+void AliHLTTPCDisplay::InitDisplay(Char_t *gfile) {
//constructor
memset(fClusters,0,36*6*sizeof(AliHLTTPCSpacePointData*));
memset(fNcl, 0, 36*6*sizeof(UInt_t));
fHistpad1 = NULL;
fHistpad2 = NULL;
fHistpad3 = NULL;
- fHistallresiduals = NULL;
+ fHistallresidualsY = NULL;
+ fHistallresidualsZ = NULL;
fHistcharge = NULL;
- fGraphresiduals = NULL;
+ fGraphresidualsY = NULL;
+ fGraphresidualsZ = NULL;
+ fGraphresidualsYLength = NULL;
+ fGraphresidualsZLength = NULL;
- fGeom = NULL;
+ fGeom = NULL;
+// ---------------------------------------------------
+// In order to be backward compatible
+// ---------------------------------------------------
+#if BACKWARD
+ //fc1 = NULL;
+#endif
+// ---------------------------------------------------
fNPads = 0;
fNTimes = 0;
fMinHits = 0;
fBackColor = 1;
fLineColor = 0;
+ fKeepView = kFALSE;
fSwitch3DCluster = kFALSE;
fSwitch3DTracks = kFALSE;
fSwitch3DPadRow = kFALSE;
fSwitch3DGeometry = kFALSE;
- //ctor. Specify which slices you want to look at.
+ AliHLTTPCTransform::SetBField(0.4);
LoadGeometrie(gfile);
}
continue;
}
points[pos].fUsed = kTRUE;
+ points[pos].fTrackN = j;
}
}
}
Int_t maxpads = 150;
fNTimes = AliHLTTPCTransform::GetNTimeBins();
- Float_t xyz[3];
- AliHLTTPCTransform::RawHLT2Global(xyz, 0, 0, 0, 0);
- LOG(AliHLTTPCLog::kError,"AliHLTTPCDisplay::ccc","") << "t="<< fNTimes <<"maxZ="<<xyz[2] << "|" << xyz[0]<< "|"<< xyz[1]<< ENDLOG;
if ( fHistraw ){
delete fHistraw;
fHistpad3 = NULL;
}
- if ( fHistallresiduals){
- delete fHistallresiduals;
- fHistallresiduals = NULL;
+ if ( fHistallresidualsY){
+ delete fHistallresidualsY;
+ fHistallresidualsY = NULL;
}
+ if ( fHistallresidualsZ){
+ delete fHistallresidualsZ;
+ fHistallresidualsZ = NULL;
+ }
if ( fHistcharge){
delete fHistcharge;
fHistcharge = NULL;
fHistpad1 = new TH1F ("fHistpad1","Selected Pad -1;Timebin #",fNTimes,0,fNTimes-1);
fHistpad2 = new TH1F ("fHistpad2","Selected Pad;Timebin #",fNTimes,0,fNTimes-1);
fHistpad3 = new TH1F ("fHistpad3","Selected Pad +1;Timebin #",fNTimes,0,fNTimes-1);
- fHistallresiduals = new TH1F ("fHistallresiduals","Residuals of all Tracks in selected slices;residuals",5000,0,100);
- fHistcharge = new TH1F ("fHistcharge","Cluster distribution per charge;charge;#cluster",500,0,6000);
+ fHistallresidualsY = new TH1F ("fHistallresiduals","Y Residuals of all Tracks in selected slices;residuals",5000,0,100);
+ fHistallresidualsZ = new TH1F ("fHistallresiduals","Z Residuals of all Tracks in selected slices;residuals",5000,0,100);
+ fHistcharge = new TH1F ("fHistcharge","Cluster distribution per charge;charge;#cluster",5000,0,30000);
fHistraw->SetOption("COLZ");
-
+ fHistallresidualsY->SetTitleSize(0.03);
+ fHistallresidualsY->GetXaxis()->SetLabelSize(0.03);
+ fHistallresidualsY->GetXaxis()->SetTitleSize(0.03);
+ fHistallresidualsY->GetYaxis()->SetLabelSize(0.03);
+ fHistallresidualsY->GetYaxis()->SetTitleSize(0.03);
- fHistallresiduals->SetTitleSize(0.03);
- fHistallresiduals->GetXaxis()->SetLabelSize(0.03);
- fHistallresiduals->GetXaxis()->SetTitleSize(0.03);
- fHistallresiduals->GetYaxis()->SetLabelSize(0.03);
- fHistallresiduals->GetYaxis()->SetTitleSize(0.03);
+ fHistallresidualsZ->SetTitleSize(0.03);
+ fHistallresidualsZ->GetXaxis()->SetLabelSize(0.03);
+ fHistallresidualsZ->GetXaxis()->SetTitleSize(0.03);
+ fHistallresidualsZ->GetYaxis()->SetLabelSize(0.03);
+ fHistallresidualsZ->GetYaxis()->SetTitleSize(0.03);
fHistcharge->SetTitleSize(0.03);
fHistcharge->GetXaxis()->SetLabelSize(0.03);
gStyle->SetPalette(1);
SetHistPadRowAxis();
-
}
// ####################################################################################################
UInt_t charge = fDigitReader->GetSignal();
for (UInt_t ii=0;ii < 19;ii++){
- if ( charge > (ii*21) && charge <= ((ii*21) + 21) ) fcolorbin[ii]++;
+ if ( charge > (ii*15) && charge <= ((ii*15) + 15) ) fcolorbin[ii]++;
}
- // larger than 19 * 21
- if (charge > 399 ) fcolorbin[19]++;
+ // larger than 19 * 15
+ if (charge > 285 ) fcolorbin[19]++;
}
// read next value
AliHLTTPCTransform::RawHLT2Global(xyz, fSlicePadRow, fPadRow, pad, time);
for (UInt_t ii=0;ii < 19;ii++){
- if ( charge > (ii*21) && charge <= ((ii*21) + 21) ){
+ if ( charge > (ii*15) && charge <= ((ii*15) + 15) ){
fpmarr[ii][fbinct[ii]] = xyz[0];
fpmarr[ii][fbinct[ii]+1] = xyz[1];
fpmarr[ii][fbinct[ii]+2] = xyz[2];
fbinct[ii] += 3;
}
}
- // larger than 19 * 21
- if (charge > 399 ) {
+ // larger than 19 * 15
+ if (charge > 285 ) {
fpmarr[19][fbinct[19]] = xyz[0];
fpmarr[19][fbinct[19]+1] = xyz[1];
fpmarr[19][fbinct[19]+2] = xyz[2];
}
}
-
// #############################################################################
void AliHLTTPCDisplay::ResetHistPadRow(){
fHistraw->Reset();
// #############################################################################
void AliHLTTPCDisplay::ResetHistResiduals(){
- fHistallresiduals->Reset();
+ fHistallresidualsY->Reset();
+ fHistallresidualsZ->Reset();
}
// #############################################################################
}
// #############################################################################
-void AliHLTTPCDisplay::DrawHistResiduals(){
+void AliHLTTPCDisplay::DrawHistResiduals(Bool_t ySwitch){
if (fSwitch3DTracks){
-
- // Residual histogram for 1 track
- if (fSelectTrackSwitch){
- Char_t title[256];
- sprintf(title,"Residuals of Track %d in Slice %d",fSelectTrack, fSelectTrackSlice );
-
-// fHistresiduals->SetMarkerStyle(2);
-// fHistresiduals->SetStats(kFALSE);
-// fHistresiduals->SetTitle(title);
-// fHistresiduals->Draw("p");
- fGraphresiduals->SetTitle(title);
- fGraphresiduals->GetXaxis()->SetTitle("z");
- fGraphresiduals->GetYaxis()->SetTitle("residuals");
- fGraphresiduals->Draw("A*");
-
+ if (ySwitch){
+ // Y Residual histogram for 1 track
+
+ if (fSelectTrackSwitch){
+ Char_t title[256];
+ sprintf(title,"Y Residuals of Track %d in Slice %d",fSelectTrack, fSelectTrackSlice );
+
+ TMultiGraph *mgY = new TMultiGraph();
+
+
+// fGraphresidualsY->SetTitle(title);
+ fGraphresidualsY->GetXaxis()->SetTitle("padrow");
+ fGraphresidualsY->GetYaxis()->SetTitle("residuals");
+// fGraphresidualsY->Draw("A*");
+ fGraphresidualsY->GetXaxis()->SetLabelSize(0.02);
+ fGraphresidualsY->GetXaxis()->SetTitleSize(0.02);
+ fGraphresidualsY->GetYaxis()->SetLabelSize(0.02);
+ fGraphresidualsY->GetYaxis()->SetTitleSize(0.02);
+ fGraphresidualsYLength->SetMarkerColor(2);
+ fGraphresidualsYLength->SetMarkerStyle(5);
+ fGraphresidualsY->SetMarkerColor(1);
+ fGraphresidualsY->SetMarkerStyle(3);
+
+// fGraphresidualsY->Draw("A*");
+// fGraphresidualsYLength->Draw("*");
+
+ mgY->Add(fGraphresidualsY);
+ mgY->Add(fGraphresidualsYLength);
+ mgY->SetTitle(title);
+// mgY->GetXaxis()->SetTitle("padrow");
+// mgY->GetYaxis()->SetTitle("residuals");
+ mgY->Draw("AP");
+ }
+ // Global residuals histogram
+ else{
+ fHistallresidualsY->SetStats(kFALSE);
+ fHistallresidualsY->Draw();
+ }
}
- // Global residuals histogram
- else{
- fHistallresiduals->SetStats(kFALSE);
- fHistallresiduals->Draw();
+ else {
+ // Z Residual histogram for 1 track
+ if (fSelectTrackSwitch){
+ Char_t title[256];
+ sprintf(title,"Z Residuals of Track %d in Slice %d",fSelectTrack, fSelectTrackSlice );
+
+ TMultiGraph *mgZ = new TMultiGraph();
+
+ fGraphresidualsZ->SetTitle(title);
+ fGraphresidualsZ->GetXaxis()->SetTitle("padrow");
+ fGraphresidualsZ->GetYaxis()->SetTitle("residuals");
+ fGraphresidualsZ->GetXaxis()->SetLabelSize(0.02);
+ fGraphresidualsZ->GetXaxis()->SetTitleSize(0.02);
+ fGraphresidualsZ->GetYaxis()->SetLabelSize(0.02);
+ fGraphresidualsZ->GetYaxis()->SetTitleSize(0.02);
+// fGraphresidualsZLength->Draw("F*");
+// fGraphresidualsZ->Draw("A*");
+
+ mgZ->Add(fGraphresidualsZ);
+// mgZ->Add(fGraphresidualsZLength);
+ mgZ->SetTitle(title);
+ mgZ->Draw("A*");
+ }
+ // Global residuals histogram
+ else{
+ fHistallresidualsZ->SetStats(kFALSE);
+ fHistallresidualsZ->Draw();
+ }
}
}
}
// DRAW 3D CLUSTER
//--------------------------------------------------------------------------------------------
if (fSwitch3DCluster){
+ Int_t maxCharge = 0;
+
for (Int_t slice=0; slice <= 35; slice++){
- UInt_t maxCharge = 0;
- Float_t maxXYZ[3];
- UChar_t padrow;
+ Int_t currenttrack = -1;
+
+ if (fSelectCluster == 1 && fSelectTrackSwitch && slice == fSelectTrackSlice ){
+
+ Int_t trackcounter = 0;
+ Int_t ntracks = fTracks->GetNTracks();
+
+ for(Int_t j=0; j<ntracks; j++) {
+
+ AliHLTTPCTrack *gtrack = fTracks->GetCheckedTrack(j);
+ if(!gtrack) continue;
+
+ Int_t nHits = gtrack->GetNHits(); // Number of associated hits to track
+ Int_t tmpslice = gtrack->GetSector();
+
+ // --- CHECK if track is should be drawn
+ // select Single Track
+ if(tmpslice != fSelectTrackSlice) continue;
+
+ if (trackcounter != fSelectTrack){
+ trackcounter++;
+ continue;
+ }
+ trackcounter++;
+ if((fPtThreshold > 0) && (gtrack->GetPt()< fPtThreshold)) continue;
+ if(nHits < fMinHits) continue;
+
+ currenttrack = j;
+ break;
+ }
+ }
+
if (!fSliceArray[slice]) continue;
for(Int_t p=0;p<6;p++){
AliHLTTPCSpacePointData *points = fClusters[slice][p];
if(!points) continue;
Int_t npoints = fNcl[slice][p];
- TPolyMarker3D *pm = new TPolyMarker3D(npoints);
-
+ TPolyMarker3D *pmUsed = new TPolyMarker3D(1,6);
+ TPolyMarker3D *pmUnused = new TPolyMarker3D(1,6);
+ Int_t nUsedCluster = 0;
+ Int_t nUnusedCluster = 0;
+
Float_t xyz[3];
for(Int_t i=0; i<npoints; i++){
// Used cluster only
if (fSelectCluster == 1 && points[i].fUsed == kFALSE) continue;
// Unused cluster only
if (fSelectCluster == 2 && points[i].fUsed == kTRUE) continue;
+
+ // if single track is selcted draw only cluster for this track
+ if (fSelectCluster == 1 && fSelectTrackSwitch && points[i].fTrackN != currenttrack) continue;
xyz[0] = points[i].fX;
xyz[1] = points[i].fY;
if ( pointEta<etaRange[0] || pointEta>etaRange[1] )
continue;
}
+
AliHLTTPCTransform::Local2Global(xyz,slice);
-
- pm->SetPoint(i,xyz[0],xyz[1],xyz[2]);
-
+
+ if (points[i].fUsed == kTRUE){
+ pmUsed->SetPoint(nUsedCluster,xyz[0],xyz[1],xyz[2]);
+ nUsedCluster++;
+ }
+ else {
+ pmUnused->SetPoint(nUnusedCluster,xyz[0],xyz[1],xyz[2]);
+ nUnusedCluster++;
+ }
+
// Fill Charge Histogram
fHistcharge->Fill(points[i].fCharge);
- if (points[i].fCharge > maxCharge ){
- maxCharge = points[i].fCharge;
- maxXYZ[0] = points[i].fX;
- maxXYZ[1] = points[i].fY;
- maxXYZ[2] = points[i].fZ;
- padrow = points[i].fPadRow;
- }
-
+ if ((Int_t)points[i].fCharge > maxCharge ) maxCharge = (Int_t) points[i].fCharge;
}
- pm->SetMarkerSize(4);
- pm->SetMarkerColor(2);
- pm->Draw("");
- }
-
- LOG(AliHLTTPCLog::kError,"AliHLTTPCDisplay::CHARGE","")<< "MAX CHARGE =" << maxCharge << " slice=" << slice
- << " z=" << maxXYZ[0]<< " y=" << maxXYZ[1]<< " z=" << maxXYZ[2]
-
- << ENDLOG;
-
-
- }
+ pmUsed->SetMarkerSize(1);
+ pmUsed->SetMarkerColor(3);
+ pmUsed->Draw("");
+
+ pmUnused->SetMarkerSize(1);
+ pmUnused->SetMarkerColor(2);
+ pmUnused->Draw("");
+ } // END - PATCH LOOP
+ } // END - SLICE LOOP
+ fHistcharge->SetAxisRange(0,maxCharge);
} // END - DRAW 3D CLUSTER
//--------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
if (fSwitch3DTracks){
+ Int_t trackcounter = 0;
Int_t ntracks = fTracks->GetNTracks();
+ Double_t drawStep = 0.2;
- TPolyLine3D *line = new TPolyLine3D[ntracks];
- TPolyLine3D *lineT = new TPolyLine3D[ntracks];
- Float_t xCl[176];
- Float_t yCl[176];
- Float_t zCl[176];
-
- Float_t xT[176];
- Float_t yT[176];
- Float_t zT[176];
-
- Float_t res[176];
-
- Int_t trackcounter = 0;
+ Double_t maxResidualY = 0.;
+ Double_t maxResidualZ = 0.;
+ TPolyLine3D *line = new TPolyLine3D[ntracks];
+#if TRACKHELIX
+ THelix *helix = new THelix[ntracks];
+#endif
for(Int_t j=0; j<ntracks; j++) {
AliHLTTPCTrack *gtrack = fTracks->GetCheckedTrack(j);
if(!gtrack) continue;
- Int_t nHits = gtrack->GetNHits();
- UInt_t *hitnum = gtrack->GetHitNumbers();
- Int_t hitcount=0;
-
- Bool_t nexttrack = kFALSE;
-
- TPolyMarker3D *pm = new TPolyMarker3D(nHits,7);
- TPolyMarker3D *pmT = new TPolyMarker3D(nHits,7);
+ Int_t nHits = gtrack->GetNHits(); // Number of associated hits to track
+ Int_t slice = gtrack->GetSector();
+ // --- CHECK if track is should be drawn
+ // select if slice should be displayed or not
+ if (!fSliceArray[slice]) continue;
+
+ // select Single Track
+ if (fSelectTrackSwitch){
+ if(slice != fSelectTrackSlice) continue;
+
+ if (trackcounter != fSelectTrack){
+ trackcounter++;
+ continue;
+ }
+ trackcounter++;
+ }
+
+ if((fPtThreshold > 0) && (gtrack->GetPt()< fPtThreshold)) continue;
+ if(nHits < fMinHits) continue;
+
TPolyMarker3D *pmL = new TPolyMarker3D(1,2);
TPolyMarker3D *pmF = new TPolyMarker3D(1,2);
- Double_t lambda = 0.; // dipAngle lambda
- Double_t r = 0.; // radius
- Double_t kappa = 0.; // curvature = 1/R , signed
- Double_t xyz0[3]; // startingpoint of track
- Double_t xyzT[3]; // point on track
- Double_t xyzC[3]; // cluster
- Double_t s = 0.; // length of track
- Double_t phi0 = 0.; // azimuthal angle of startingpoint, with respect to helix axis
- Double_t bfield = 0; // BField
+ Double_t radius = gtrack->GetRadius(); // radius
+ Double_t kappa = gtrack->GetKappa(); // curvature = 1/R , signed
+ Double_t lambda = atan( gtrack->GetTgl() ); // dipAngle lambda
+ Double_t phi0 = gtrack->GetPsi() + (gtrack->GetCharge() * AliHLTTPCTransform::PiHalf() ); // azimuthal angle of startingpoint, with respect to helix axis
Double_t xyzL[3]; // lastpoint of track
Double_t xyzF[3]; // firstpoint of track
- Double_t maxZ = 0; // range of the histogram
- Double_t minZ =99999.; // range of the histogram
+ xyzF[0] = gtrack->GetFirstPointX();
+ xyzF[1] = gtrack->GetFirstPointY();
+ xyzF[2] = gtrack->GetFirstPointZ();
+ pmF->SetPoint(0,xyzF[0],xyzF[1],xyzF[2]);
- for(Int_t h=0; h<nHits; h++){
+ xyzL[0] = gtrack->GetLastPointX();
+ xyzL[1] = gtrack->GetLastPointY();
+ xyzL[2] = gtrack->GetLastPointZ();
+ pmL->SetPoint(0,xyzL[0],xyzL[1],xyzL[2]);
- UInt_t id=hitnum[h];
- Int_t slice = (id>>25) & 0x7f;
- Int_t patch = (id>>22) & 0x7;
- UInt_t pos = id&0x3fffff;
+ Double_t s = 0.; // length of the track
- // select if slice should be displayed or not
- if (!fSliceArray[slice]) {
- nexttrack = kTRUE;
- break;
- }
-
- // select Single Track
- if (fSelectTrackSwitch){
- if(slice != fSelectTrackSlice) {
- nexttrack = kTRUE;
- break;
- }
+ // Calculate the length of the track. If it is to flat in in s,z plane use sxy, otherwise use sz
+ if (fabs(lambda) > 0.05){
+ // length of track calculated out of z
+ s = fabs( (xyzL[2] - xyzF[2]) / sin(lambda) ); // length of track calculated out of z
+ }
+ else {
+ Double_t d = (xyzL[0] - xyzF[0])*(xyzL[0] - xyzF[0]) + (xyzL[1] - xyzF[1])*(xyzL[1] - xyzF[1]);
+ // length of track calculated out of xy
+ s = fabs ( acos( 0.5 * (2 - (d / (radius*radius)))) / ( kappa * cos(lambda) ) );
+ }
+
+ Int_t nTrackPoints = 2 + (Int_t) floor(s / drawStep);
- if (trackcounter != fSelectTrack && h==0){
- trackcounter++;
- nexttrack = kTRUE;
- break;
- }
+#if TRACKPOLYMARKER
+ TPolyMarker3D *pmT = new TPolyMarker3D(nTrackPoints,6);
+#endif
- trackcounter++;
- }
+ Double_t *xT = new Double_t[nTrackPoints];
+ Double_t *yT = new Double_t[nTrackPoints];
+ Double_t *zT = new Double_t[nTrackPoints];
+
+ //Write Track Parameters for single track
+ if (fSelectTrackSwitch){
+ fTrackParam.id = trackcounter - 1;
+ fTrackParam.nHits = nHits;
+ fTrackParam.charge = gtrack->GetCharge();
+ fTrackParam.lambda = lambda;
+ fTrackParam.kappa = kappa;
+ fTrackParam.radius = radius;
+ fTrackParam.slice = slice;
+ fTrackParam.phi0 = phi0;
+ fTrackParam.pt = gtrack->GetPt();
+ fTrackParam.bfield = AliHLTTPCTransform::GetBFieldValue();
+ fTrackParam.xyzF[0] = gtrack->GetFirstPointX();
+ fTrackParam.xyzF[1] = gtrack->GetFirstPointY();
+ fTrackParam.xyzF[2] = gtrack->GetFirstPointZ();
+ fTrackParam.xyzL[0] = gtrack->GetLastPointX();
+ fTrackParam.xyzL[1] = gtrack->GetLastPointY();
+ fTrackParam.xyzL[2] = gtrack->GetLastPointZ();
+ fTrackParam.psi = gtrack->GetPsi();
+ fTrackParam.s = s;
+ }
- // --> in the hit loop because of 'trackcounter++', otherwise wrong single track in slice will be selected
- if((fPtThreshold > 0) && (gtrack->GetPt()< fPtThreshold)) {
- nexttrack = kTRUE;
- break;
- }
-
- // --> in the hit loop because of 'trackcounter++', otherwise wrong single track in slice will be selected
- if(nHits < fMinHits) {
- nexttrack = kTRUE;
- break;
- }
+ Int_t trackPointCounter = 0;
- AliHLTTPCSpacePointData *points = fClusters[slice][patch];
-
- if(!points) {
- LOG(AliHLTTPCLog::kError,"AliHLTTPCDisplay::Draw3D","Clusterarray") <<"No points at slice "<<slice<<" patch "<<patch
- <<" pos "<<pos<<ENDLOG;
- continue;
- }
-
- if(pos>=fNcl[slice][patch]) {
- LOG(AliHLTTPCLog::kError,"AliHLTTPCDisplay::Draw3D","Clusterarray") <<"Pos is too large: pos "<<pos <<" ncl "
- <<fNcl[slice][patch]<<ENDLOG;
- continue;
- }
+ for (Double_t ds = 0.; ds < s; ds = ds + drawStep){
+ // FILL ARRAYS IN ORDER TO DRAW THE TRACKPOINTS, OUT OF THE PARAMETER
+ xT[trackPointCounter] = xyzF[0] + radius * ( cos( phi0 + (ds*kappa*cos(lambda)) ) - cos(phi0) );
+ yT[trackPointCounter] = xyzF[1] + radius * ( sin( phi0 + (ds*kappa*cos(lambda)) ) - sin(phi0) );
+ zT[trackPointCounter] = xyzF[2] + ds * sin(lambda);
+#if TRACKPOLYMARKER
+ pmT->SetPoint(trackPointCounter,xT[trackPointCounter],yT[trackPointCounter],zT[trackPointCounter]);
+#endif
+ trackPointCounter++;
+ }
- // set the data for the residuals
- if (h == 0){
- // -> Curvature / Radius / Phi0
- //kappa = gtrack->GetKappa();
- //r = gtrack->GetRadius();
- //phi0 = gtrack->GetPhi0();
- //bfield = AliHLTTPCTransform::GetBFieldValue();
-
- lambda = atan( gtrack->GetTgl() );
-
- bfield = 0.0029980 * 0.4; // KORRIGIERE B für =0.4 T Feld
-
- xyz0[0] = gtrack->GetFirstPointX();
- xyz0[1] = gtrack->GetFirstPointY();
- xyz0[2] = gtrack->GetFirstPointZ();
-
- xyzF[0] = gtrack->GetFirstPointX();
- xyzF[1] = gtrack->GetFirstPointY();
- xyzF[2] = gtrack->GetFirstPointZ();
+ xT[trackPointCounter] = xyzF[0] + radius * ( cos( phi0 + (s*kappa*cos(lambda)) ) - cos(phi0) );
+ yT[trackPointCounter] = xyzF[1] + radius * ( sin( phi0 + (s*kappa*cos(lambda)) ) - sin(phi0) );
+ zT[trackPointCounter] = xyzF[2] + s * sin(lambda);
+#if TRACKPOLYMARKER
+ pmT->SetPoint(trackPointCounter,xT[trackPointCounter],yT[trackPointCounter],zT[trackPointCounter]);
+#endif
+ // --- RESIDUALS ---
+ gtrack->Rotate(slice,kTRUE);
+ Int_t nRes = 0; // number of resiudals
+
+ UInt_t *hitnum = gtrack->GetHitNumbers();
- xyzL[0] = gtrack->GetLastPointX();
- xyzL[1] = gtrack->GetLastPointY();
- xyzL[2] = gtrack->GetLastPointZ();
+ Double_t *resY= new Double_t[nHits];
+ Double_t *resZ= new Double_t[nHits];
- pmL->SetPoint(0,xyzL[0],xyzL[1],xyzL[2]);
- pmF->SetPoint(0,xyzF[0],xyzF[1],xyzF[2]);
+ Double_t *resYLength= new Double_t[2*nHits];
+ Double_t *resZLength= new Double_t[2*nHits];
- phi0 = gtrack->GetPsi() + (gtrack->GetCharge() * AliHLTTPCTransform::PiHalf() );
-
- if (bfield != 0.){
- r = gtrack->GetPt() / bfield;
- kappa = - gtrack->GetCharge() * 1. / r;
- }
- else {
- r = 999999; // just infinity
- kappa = 0;
- }
+ Double_t *padrows = new Double_t[nHits];
+ Double_t *padrowsLength = new Double_t[2*nHits];
- //Write Track Parameters for single track
- if (fSelectTrackSwitch){
- fTrackParam.id = trackcounter - 1;
- fTrackParam.nHits = nHits;
- fTrackParam.charge = gtrack->GetCharge();
- fTrackParam.lambda = lambda;
- fTrackParam.kappa = kappa;
- fTrackParam.radius = r;
- fTrackParam.slice = slice;
- fTrackParam.phi0 = phi0;
- fTrackParam.pt = gtrack->GetPt();
- fTrackParam.bfield = bfield;
- fTrackParam.xyzF[0] = gtrack->GetFirstPointX();
- fTrackParam.xyzF[1] = gtrack->GetFirstPointY();
- fTrackParam.xyzF[2] = gtrack->GetFirstPointZ();
- fTrackParam.xyzL[0] = gtrack->GetLastPointX();
- fTrackParam.xyzL[1] = gtrack->GetLastPointY();
- fTrackParam.xyzL[2] = gtrack->GetLastPointZ();
- fTrackParam.psi = gtrack->GetPsi();
- }
- }
+ for(Int_t h=0; h<nHits; h++){
+ UInt_t id=hitnum[h];
+ Int_t patch = (id>>22) & 0x7;
+ UInt_t pos = id&0x3fffff;
+ AliHLTTPCSpacePointData *points = fClusters[slice][patch];
Float_t xyzCtmp[3]; // cluster tmp
+ Float_t xyzTtmp[3]; // track tmp
xyzCtmp[0] = points[pos].fX;
xyzCtmp[1] = points[pos].fY;
xyzCtmp[2] = points[pos].fZ;
- AliHLTTPCTransform::Local2Global(xyzCtmp,slice);
-
- xCl[h] = xyzCtmp[0];
- yCl[h] = xyzCtmp[1];
- zCl[h] = xyzCtmp[2];
+ Int_t padrow = AliHLTTPCTransform::GetPadRow(points[pos].fX);
+ xyzTtmp[0] = gtrack->GetFirstPointX();
+ if(gtrack->GetCrossingPoint(padrow,xyzTtmp)) {
- // FILL POLYMARKER FOR THE ORIGINAL TRACKS
- pm->SetPoint(h,xCl[h],yCl[h],zCl[h]);
-
- xyzC[0] = (Double_t) xyzCtmp[0];
- xyzC[1] = (Double_t) xyzCtmp[1];
- xyzC[2] = (Double_t) xyzCtmp[2];
-
- xyzT[2] = xyzC[2];
+ Float_t deltaY = ( xyzCtmp[1] - xyzTtmp[1] );
+ Float_t deltaZ = ( xyzCtmp[2] - xyzTtmp[2] );
+// Float_t residual = sqrt( deltaY*deltaY + deltaZ*deltaZ );
+
+ padrows[nRes] = (Double_t) padrow;
+ resY[nRes] = (Double_t) deltaY;
+ resZ[nRes] = (Double_t) deltaZ;
+
+ resYLength[(2*nRes)] = 0.5 * AliHLTTPCTransform::GetPadLength(padrow);
+ resYLength[(2*nRes)+1] = -0.5 * AliHLTTPCTransform::GetPadLength(padrow);
+ resZLength[nRes] = AliHLTTPCTransform::GetZLength();
+ padrowsLength[(2*nRes)] = (Double_t) padrow;
+ padrowsLength[(2*nRes)+1] = (Double_t) padrow;
+
+ // FILL RESIDUALS HISTOGRAM
+ fHistallresidualsY->Fill(resY[nRes]);
+ fHistallresidualsZ->Fill(resZ[nRes]);
+ if (resY[nRes] > maxResidualY ) maxResidualY = resY[nRes];
+ if (resZ[nRes] > maxResidualZ ) maxResidualZ = resZ[nRes];
+ nRes++;
+ }
+ }
- //calculate length
- s = ( xyzT[2] - xyz0[2] ) / sin(lambda);
+ gtrack->Rotate(slice,kFALSE);
+ // --- RESIDUALS ---
- // calculate the corresponding coordinates on the track
- xyzT[0] = xyz0[0] + r * ( cos( phi0 + (s*kappa*cos(lambda)) ) - cos( phi0 ) );
- xyzT[1] = xyz0[1] + r * ( sin( phi0 + (s*kappa*cos(lambda)) ) - sin( phi0 ) );
+ // Draw last point of Track
+ pmL->SetMarkerSize(3);
+ pmL->SetMarkerColor(4);
+ pmL->Draw();
- Double_t deltaX = ( xyzC[0] - xyzT[0] );
- Double_t deltaY = ( xyzC[1] - xyzT[1] );
-
- Double_t residual = sqrt( deltaX*deltaX + deltaY*deltaY );
- res[h] = (Float_t) residual;
+ // Draw first point of Track
+ pmF->SetMarkerSize(3);
+ pmF->SetMarkerColor(5);
+ pmF->Draw();
- if (maxZ < fabs(xyzT[2])) maxZ = fabs(xyzT[2]);
- if (minZ > fabs(xyzT[2])) minZ = fabs(xyzT[2]);
+#if TRACKPOLYMARKER
+ // Draw Track -- as polymarker
+ pmT->SetMarkerSize(3);
+ pmT->SetMarkerColor(3);
+ pmT->Draw();
+#endif
+ // Draw Track -- as line
+ TPolyLine3D *currentline = &(line[j]);
+ currentline = new TPolyLine3D(nTrackPoints,xT,yT,zT,"");
+ currentline->SetLineColor(4);
+ currentline->SetLineWidth(2);
+ currentline->Draw("same");
+
+#if TRACKHELIX
+ // Draw Track -- as helix
+ // works ok, execpt for very small dipangles -> track almost horizontal
+ Double_t hrange[2];
+ Double_t v0[3];
+ Double_t omega;
+ hrange[0] = xyzF[2];
+ hrange[1] = xyzL[2];
+ v0[0] = gtrack->GetPx();
+ v0[1] = gtrack->GetPy();
+ v0[2] = gtrack->GetPz();
+ omega = AliHLTTPCTransform::GetBFieldValue() * gtrack->GetCharge();
+
+ THelix *currenthelix = &(helix[j]);
+ currenthelix = new THelix(xyzF,v0,omega,hrange,kHelixZ,0);
+ currenthelix->SetLineColor(6);
+ currenthelix->SetLineWidth(1);
+ currenthelix->Draw("same");
+#endif
- // FILL RESIDUALS HISTOGRAM
- fHistallresiduals->Fill(residual);
-
- // FILL ARRAYS IN ORDER TO DRAW THE TRACKPOINTS, OUT OF THE PARAMETER
- xT[h] = xyzT[0];
- yT[h] = xyzT[1];
- zT[h] = xyzT[2];
-
- // FILL POLYMARKER FOR THE NEW TRACKS
- pmT->SetPoint(h,xT[h],yT[h],zT[h]);
-
- hitcount++;
+ //Residuals
+ if ( fGraphresidualsY){
+ delete fGraphresidualsY;
+ fGraphresidualsY = NULL;
}
- if(nexttrack) continue;
- if(hitcount==0) continue;
-
+ if ( fGraphresidualsZ){
+ delete fGraphresidualsZ;
+ fGraphresidualsZ = NULL;
+ }
+ //Residuals
+ if ( fGraphresidualsYLength){
+ delete fGraphresidualsYLength;
+ fGraphresidualsYLength = NULL;
+ }
- if ( fGraphresiduals){
- delete fGraphresiduals;
- fGraphresiduals = NULL;
+ if ( fGraphresidualsZLength){
+ delete fGraphresidualsZLength;
+ fGraphresidualsZLength = NULL;
}
- // FILL RESIDUALS GRAPH
- fGraphresiduals = new TGraph(nHits,zT,res);
- fGraphresiduals->GetXaxis()->SetLabelSize(0.02);
- fGraphresiduals->GetXaxis()->SetTitleSize(0.02);
- fGraphresiduals->GetYaxis()->SetLabelSize(0.02);
- fGraphresiduals->GetYaxis()->SetTitleSize(0.02);
-
- TPolyLine3D *currentline = &(line[j]);
- currentline = new TPolyLine3D(nHits,xCl,yCl,zCl,"");
- currentline->SetLineColor(4);
- currentline->SetLineWidth(2);
-// currentline->Draw("same");
- TPolyLine3D *currentlineT = &(lineT[j]);
- currentlineT = new TPolyLine3D(nHits,xT,yT,zT,"");
- currentlineT->SetLineColor(7);
- currentlineT->SetLineWidth(1);
-// currentlineT->Draw("same");
-
- //Last Point of Track
- pmL->SetMarkerSize(3);
- pmL->SetMarkerColor(4);
- pmL->Draw();
+ // FILL Y RESIDUALS GRAPH
+ fGraphresidualsY = new TGraph(nRes-1,padrows,resY);
+ fGraphresidualsYLength = new TGraph((2*nRes)-2,padrowsLength,resYLength);
+ // FILL Z RESIDUALS GRAPH
+ fGraphresidualsZ = new TGraph(nRes-1,padrows,resZ);
+ fGraphresidualsZLength = new TGraph(nRes-1,padrows,resZLength);
- //First Point of Track
- pmF->SetMarkerSize(3);
- pmF->SetMarkerColor(5);
- pmF->Draw();
-
- //Original Track
- pm->SetMarkerSize(4);
- pm->SetMarkerColor(6);
- pm->Draw();
-
- //New Track
- pmT->SetMarkerSize(4);
- pmT->SetMarkerColor(3);
- pmT->Draw();
+ if (xT) delete xT;
+ if (yT) delete yT;
+ if (zT) delete zT;
} // END for tracks
+ fHistallresidualsY->SetAxisRange(0,maxResidualY);
+ fHistallresidualsZ->SetAxisRange(0,maxResidualZ);
+
} // END - DRAW 3D Tracks
//--------------------------------------------------------------------------------------------
v->Draw();
}
+// ---------------------------------------------------
+// In order to be backward compatible
+// ---------------------------------------------------
+#if BACKWARD
+void AliHLTTPCDisplay::DisplayClusters(Bool_t x3don,Float_t* etaRange) {
+ if (!fc1){
+ fc1 = new TCanvas("c1","",900,900);
+ fc1->cd();
+ }
+ fSwitch3DTracks = kFALSE;
+ fSwitch3DCluster = kTRUE;
+ fSwitch3DPadRow = kFALSE;
+ fSwitch3DGeometry = kFALSE;
-
+ Draw3D();
+}
+// ---------------------------------------------------
+void AliHLTTPCDisplay::DisplayTracks(Int_t minhits,Bool_t x3don,Float_t thr) {
+ if (!fc1){
+ fc1 = new TCanvas("c1","",900,900);
+ fc1->cd();
+ }
+
+ fMinHits = minhits;
+ fPtThreshold = thr;
+ fSwitch3DTracks = kTRUE;
+ fSwitch3DCluster = kFALSE;
+ fSwitch3DPadRow = kFALSE;
+ fSwitch3DGeometry = kFALSE;
+
+ Draw3D();
+}
+// ---------------------------------------------------
+void AliHLTTPCDisplay::DisplayAll(Int_t minhits,Bool_t clusterswitch,Bool_t trackswitch,Bool_t x3don, Float_t thr, Float_t* etaRange){
+ if (!fc1){
+ fc1 = new TCanvas("c1","",900,900);
+ fc1->cd();
+ }
+
+ fMinHits = minhits;
+ fPtThreshold = thr;
+ fSwitch3DTracks = trackswitch;
+ fSwitch3DCluster = clusterswitch;
+ fSwitch3DPadRow = kFALSE;
+ fSwitch3DGeometry = kFALSE;
+
+ Draw3D();
+}
+#endif
+// ---------------------------------------------------
class AliHLTTPCDisplay : public TObject {
public:
- AliHLTTPCDisplay(Char_t *gfile="$(ALIHLT_BASEDIR)/geo/alice.geom");
- virtual ~AliHLTTPCDisplay();
-
- // SETUP
- void SetupHist();
- void SetupCluster(Int_t slice, Int_t patch, UInt_t nofClusters, AliHLTTPCSpacePointData* data);
- void SetupTracks(AliHLTTPCTrackArray *tracks);
-
- // HISTOGRAM FILL/RESET FUNCTIONS
-
- void FillPadRow(Int_t patch, ULong_t dataBlock, ULong_t dataLen);
- void ResetHistPadRow();
- void ResetHistResiduals();
- void ResetHistCharge();
-
- // DRAWER
- void Draw3D();
- void DrawHistPadRow();
- void DrawGeomSector(Int_t sector);
- void DrawHistPad1();
- void DrawHistPad2();
- void DrawHistPad3();
- void DrawHistResiduals();
- void DrawHistCharge();
-
- // SETTER
- void SetSliceArray();
- void SetSlices(){fMinSlice = 0; fMaxSlice = 35; fSlicePair = kFALSE; SetSliceArray();}
- void SetSlices(Int_t s){fMinSlice = s; fMaxSlice = s; fSlicePair = kFALSE; SetSliceArray();}
- void SetSlices(Int_t mins, Int_t maxs){fMinSlice = mins; fMaxSlice = maxs; fSlicePair = kFALSE; SetSliceArray();}
- void SetSlicesPair(Int_t s){fMinSlice = s; fMaxSlice = s; fSlicePair = kTRUE; SetSliceArray();}
- void SetSlicesPair(Int_t mins, Int_t maxs){fMinSlice = mins; fMaxSlice = maxs; fSlicePair = kTRUE; SetSliceArray();}
- void SetPad(Int_t f){fPad = f;}
- void SetPadRow(Int_t f){fPadRow = f;}
- void SetSlicePadRow(Int_t f){fSlicePadRow = f;}
- void SetMinHits(Int_t f){fMinHits = f;}
- void SetPtThreshold(Float_t f){fPtThreshold = f;}
- void SetSwitches(Bool_t f1, Bool_t f2, Bool_t f3, Bool_t f4) {fSwitch3DTracks = f1; fSwitch3DCluster = f2; fSwitch3DPadRow = f3; fSwitch3DGeometry = f4;}
- void SetHistPadRowAxis();
- void SetSelectTrack(Int_t f) {fSelectTrack = f;}
- void SetSelectTrackSlice(Int_t f) {fSelectTrackSlice = f;}
- void SetSelectTrackSwitch(Bool_t f) {fSelectTrackSwitch = f;}
- void SetSelectCluster(Int_t f) {fSelectCluster = f;}
- void SetInvert() {Int_t tmp = fBackColor; fBackColor = fLineColor; fLineColor = tmp; }
- void SetKeepView(Bool_t f){fKeepView = f;}
-
- // GETTER
- Int_t GetPadRow(){return fPadRow;}
- Int_t GetSlicePadRow(){return fSlicePadRow;}
- Int_t GetNPads(){return fNPads;}
- Int_t GetBackColor() {return fBackColor;}
-
- struct AliHLTTPCTrackParameter{
- Int_t nHits;
- Int_t charge;
- Double_t kappa;
- Double_t radius;
- Double_t xyzF[3];
- Double_t xyzL[3];
- Int_t slice;
- Double_t phi0;
- Double_t psi;
- Double_t lambda;
- Double_t pt;
- Int_t id;
- Double_t bfield;
- };
-
- AliHLTTPCTrackParameter fTrackParam;
-
- private:
-
- Bool_t LoadGeometrie(Char_t *gfile);
-
- AliHLTTPCDisplay(const AliHLTTPCDisplay &/*d*/):TObject(){;}
- AliHLTTPCDisplay& operator=(const AliHLTTPCDisplay &/*d*/){return *this;}
-
- AliHLTTPCSpacePointData *fClusters[36][6];
- AliHLTTPCTrackArray *fTracks;
-
- UInt_t fNcl[36][6];//number of cluster
-
- TH1F *fHistrawcl; // histogram for cluster in padrow
- TH2F *fHistraw; // histogram for signals in padrow
- TH1F *fHistpad1; // histogram for pad in padrow
- TH1F *fHistpad2; // histogram for pad in padrow
- TH1F *fHistpad3; // histogram for pad in padrow
- TH1F *fHistallresiduals;//histogram for all residuals
- TH1F *fHistcharge; // histogram for clustercharge
-
- TGraph *fGraphresiduals; // graph of the residuals for one track
-
- TGeometry *fGeom; // geometry
- Int_t fBackColor; // Background color
- Int_t fLineColor; // Line color
- Bool_t fKeepView; // Keep View when redisplaying
-
- Int_t fPad; // pad
- Int_t fPadRow; // padrow
- Int_t fSlicePadRow;// slice where padrow is in
- Int_t fNPads; // number of pads in padrow
- Int_t fNTimes; // number of timebins
- Int_t fMinHits; // minimum cluster per track
- Float_t fPtThreshold;// pt threshold for tracks
-
- Bool_t fSelectTrackSwitch;// switch ti single track mode
- Int_t fSelectTrack;// select single track
- Int_t fSelectTrackSlice; // select slice for single track
-
- Int_t fSelectCluster; // select all=0, used=1, unused=2 cluster
-
- Int_t fMinSlice; //min slice
- Int_t fMaxSlice; //max slice
- Bool_t fSlicePair; //draw pair of slices;
- Bool_t fSliceArray[36];//Array if slice should be drawn or not
-
- Bool_t fDrawGeo;
- Int_t fcolorbin[20]; // number of entries per colorbin
- Int_t fbinct[20]; // index of colorbin
- Float_t *fpmarr[20]; // contains point data
-
- Bool_t fSwitch3DCluster;
- Bool_t fSwitch3DTracks;
- Bool_t fSwitch3DPadRow;
- Bool_t fSwitch3DGeometry;
-
- ClassDef(AliHLTTPCDisplay,1) //Display class
+ AliHLTTPCDisplay(Char_t *gfile="$(ALIHLT_BASEDIR)/geo/alice.geom") {InitDisplay(gfile);}
+ virtual ~AliHLTTPCDisplay();
+
+ void InitDisplay(Char_t *gfile);
+
+ // SETUP
+ void SetupHist();
+ void SetupCluster(Int_t slice, Int_t patch, UInt_t nofClusters, AliHLTTPCSpacePointData* data);
+ void SetupTracks(AliHLTTPCTrackArray *tracks);
+
+ // HISTOGRAM FILL/RESET FUNCTIONS
+ void FillPadRow(Int_t patch, ULong_t dataBlock, ULong_t dataLen);
+ void ResetHistPadRow();
+ void ResetHistResiduals();
+ void ResetHistCharge();
+
+ // DRAWER
+ void Draw3D();
+ void DrawHistPadRow();
+ void DrawGeomSector(Int_t sector);
+ void DrawHistPad1();
+ void DrawHistPad2();
+ void DrawHistPad3();
+ void DrawHistResiduals(Bool_t ySwitch);
+ void DrawHistCharge();
+
+ // SETTER
+ void SetSlices(){fMinSlice = 0; fMaxSlice = 35; fSlicePair = kFALSE; SetSliceArray();}
+ void SetSlices(Int_t s){fMinSlice = s; fMaxSlice = s; fSlicePair = kFALSE; SetSliceArray();}
+ void SetSlices(Int_t mins, Int_t maxs){fMinSlice = mins; fMaxSlice = maxs; fSlicePair = kFALSE; SetSliceArray();}
+ void SetSlicesPair(Int_t s){fMinSlice = s; fMaxSlice = s; fSlicePair = kTRUE; SetSliceArray();}
+ void SetSlicesPair(Int_t mins, Int_t maxs){fMinSlice = mins; fMaxSlice = maxs; fSlicePair = kTRUE; SetSliceArray();}
+
+ void SetPad(Int_t f){fPad = f;}
+ void SetPadRow(Int_t f){fPadRow = f;}
+ void SetSlicePadRow(Int_t f){fSlicePadRow = f;}
+
+ void SetMinHits(Int_t f){fMinHits = f;}
+ void SetPtThreshold(Float_t f){fPtThreshold = f;}
+
+ void SetSwitches(Bool_t f1, Bool_t f2, Bool_t f3, Bool_t f4) {fSwitch3DTracks = f1; fSwitch3DCluster = f2; fSwitch3DPadRow = f3; fSwitch3DGeometry = f4;}
+ void Set3DSwitchTracks(Bool_t f1) {fSwitch3DTracks = f1;}
+ void Set3DSwitchCluster(Bool_t f1) {fSwitch3DCluster = f1;}
+ void Set3DSwitchPadRow(Bool_t f1) {fSwitch3DPadRow = f1;}
+ void Set3DSwitchGeometry(Bool_t f1) {fSwitch3DGeometry = f1;}
+
+ void SetSelectTrack(Int_t f) {fSelectTrack = f;}
+ void SetSelectTrackSlice(Int_t f) {fSelectTrackSlice = f;}
+ void SetSelectTrackSwitch(Bool_t f) {fSelectTrackSwitch = f;}
+ void SetSelectCluster(Int_t f) {fSelectCluster = f;}
+
+ void SetHistPadRowAxis();
+
+ void SetInvert() {Int_t tmp = fBackColor; fBackColor = fLineColor; fLineColor = tmp; }
+ void SetKeepView(Bool_t f){fKeepView = f;}
+
+ // GETTER
+ Int_t GetPadRow(){return fPadRow;}
+ Int_t GetSlicePadRow(){return fSlicePadRow;}
+ Int_t GetNPads(){return fNPads;}
+ Int_t GetBackColor(){return fBackColor;}
+ Bool_t GetKeepView(){return fKeepView;}
+
+ Bool_t Get3DSwitchTracks() {return fSwitch3DTracks;}
+ Bool_t Get3DSwitchCluster() {return fSwitch3DCluster;}
+ Bool_t Get3DSwitchPadRow() {return fSwitch3DPadRow;}
+
+ Bool_t GetSelectTrackSwitch() {return fSelectTrackSwitch;}
+
+ struct AliHLTTPCTrackParameter{
+ Int_t nHits;
+ Int_t charge;
+ Double_t kappa;
+ Double_t radius;
+ Double_t xyzF[3];
+ Double_t xyzL[3];
+ Int_t slice;
+ Double_t phi0;
+ Double_t psi;
+ Double_t lambda;
+ Double_t pt;
+ Int_t id;
+ Double_t bfield;
+ Double_t s;
+ };
+
+ AliHLTTPCTrackParameter fTrackParam;
+
+// ---------------------------------------------------
+// In order to be backward compatible
+// ---------------------------------------------------
+/*
+ AliHLTTPCDisplay(Int_t *slice, Char_t *gfile ) { InitDisplay(gfile);}
+
+ // SETUP
+ void SetupClusterDataForPatch(Int_t slice, Int_t patch, UInt_t nofClusters, AliHLTTPCSpacePointData* data) {SetupCluster(slice, patch, nofClusters, data);}
+ void SetTracks(AliHLTTPCTrackArray *tracks) { SetupTracks(tracks);}
+ void DisplayClusters(Bool_t x3don=kTRUE,Float_t* etaRange=NULL);
+ void DisplayTracks(Int_t minhits=10,Bool_t x3don=kTRUE,Float_t thr=0.);
+ void DisplayAll(Int_t minhits=10,Bool_t clusterswitch=kTRUE,Bool_t trackswitch=kTRUE,Bool_t x3don=kTRUE, Float_t thr=0., Float_t* etaRange=NULL);
+*/
+// ---------------------------------------------------
+ private:
+// ---------------------------------------------------
+// In order to be backward compatible
+// ---------------------------------------------------
+/* TCanvas *fc1; */
+// ---------------------------------------------------
+ Bool_t LoadGeometrie(Char_t *gfile);
+ void SetSliceArray();
+
+ AliHLTTPCDisplay(const AliHLTTPCDisplay &/*d*/):TObject(){;}
+ AliHLTTPCDisplay& operator=(const AliHLTTPCDisplay &/*d*/){return *this;}
+
+ AliHLTTPCSpacePointData *fClusters[36][6];
+ AliHLTTPCTrackArray *fTracks;
+
+ UInt_t fNcl[36][6];//number of cluster
+
+ TH1F *fHistrawcl; // histogram for cluster in padrow
+ TH2F *fHistraw; // histogram for signals in padrow
+ TH1F *fHistpad1; // histogram for pad in padrow
+ TH1F *fHistpad2; // histogram for pad in padrow
+ TH1F *fHistpad3; // histogram for pad in padrow
+ TH1F *fHistallresidualsY;//histogram for all Y residuals
+ TH1F *fHistallresidualsZ;//histogram for all Z residuals
+ TH1F *fHistcharge; // histogram for clustercharge
+
+ TGraph *fGraphresidualsY; // graph of the Y residuals for one track
+ TGraph *fGraphresidualsZ; // graph of the Z residuals for one track
+ TGraph *fGraphresidualsYLength; // graph of the Y residuals for one track
+ TGraph *fGraphresidualsZLength; // graph of the Z residuals for one track
+
+
+ TGeometry *fGeom; // geometry
+ Int_t fBackColor; // Background color
+ Int_t fLineColor; // Line color
+ Bool_t fKeepView; // Keep View when redisplaying
+
+ Int_t fPad; // pad
+ Int_t fPadRow; // padrow
+ Int_t fSlicePadRow;// slice where padrow is in
+ Int_t fNPads; // number of pads in padrow
+ Int_t fNTimes; // number of timebins
+ Int_t fMinHits; // minimum cluster per track
+ Float_t fPtThreshold;// pt threshold for tracks
+
+ Bool_t fSelectTrackSwitch;// switch ti single track mode
+ Int_t fSelectTrack;// select single track
+ Int_t fSelectTrackSlice; // select slice for single track
+
+ Int_t fSelectCluster; // select all=0, used=1, unused=2 cluster
+
+ Int_t fMinSlice; //min slice
+ Int_t fMaxSlice; //max slice
+ Bool_t fSlicePair; //draw pair of slices;
+ Bool_t fSliceArray[36];//Array if slice should be drawn or not
+
+ Bool_t fDrawGeo;
+ Int_t fcolorbin[20]; // number of entries per colorbin
+ Int_t fbinct[20]; // index of colorbin
+ Float_t *fpmarr[20]; // contains point data
+
+ Bool_t fSwitch3DCluster;
+ Bool_t fSwitch3DTracks;
+ Bool_t fSwitch3DPadRow;
+ Bool_t fSwitch3DGeometry;
+
+ ClassDef(AliHLTTPCDisplay,1) //Display class
};
#endif
fMultiplicity = 4000;
fBField = 0.4;
fDoPP = false;
+// BEGINN ############################################## MODIFIY JMT
+ fnonvertextracking = kFALSE; // enable NONVERTEX Tracking
+ fmainvertextracking = kTRUE; // enable MAINVERTEX Tracking
+// END ################################################# MODIFIY JMT
}
AliHLTTPCSliceTrackerComponent::~AliHLTTPCSliceTrackerComponent()
fTracker->SetNSegments(phi_segments,eta_segments);
fTracker->SetMaxDca(min_pt_fit);
// fTracker->MainVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack);
+
+// BEGINN ############################################## MODIFIY JMT
+#if 1
+ Logging( kHLTLogError, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "==============================" );
+
+ if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){
+ fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kTRUE);
+ fTracker->SetTrackletCuts(maxangle,goodDist,kTRUE);
+
+ fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);
+ Logging( kHLTLogError, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING" );
+ }
+ else if ( fmainvertextracking == kTRUE && fnonvertextracking == kTRUE){
+ fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kTRUE);
+ fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kFALSE);
+ fTracker->SetTrackletCuts(maxangle,goodDist,kTRUE);
+ fTracker->SetTrackletCuts(maxangle,goodDist,kFALSE);
+
+ fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);
+ fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
+ Logging( kHLTLogError, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING - NONVERTEXTRACKING" );
+ }
+ else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){
+ fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kFALSE);
+ fTracker->SetTrackletCuts(maxangle,goodDist,kFALSE);
+
+ fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
+ Logging( kHLTLogError, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "NONVERTEXTRACKING" );
+ }
+#else
fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,vertexConstraints);
fTracker->SetTrackletCuts(maxangle,goodDist,vertexConstraints);
fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);
else
fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
- //fTracker->SetParamDone(true);
+#endif
+// END ################################################# MODIFIY JMT
+ //fTracker->SetParamDone(true);
//AliHLTTPC::SetVertexFit( kFALSE );
fTracker->InitVolumes();
void AliHLTTPCSliceTrackerComponent::SetTrackerParam( bool doPP, int multiplicity, double bField )
{
+ AliHLTTPCTransform::SetBField( bField );
+ Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f\n", bField );
+ Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "B field is %f\n",AliHLTTPCTransform::GetBFieldValue());
+
if ( doPP )
{
//tracker->SetClusterFinderParam(xyerror,zerror,kTRUE); // ??
}
break;
}
- Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f\n", bfs[closestBf] );
- AliHLTTPCTransform::SetBField( bfs[closestBf] );
-
+// Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f\n", bfs[closestBf] );
+// AliHLTTPCTransform::SetBField( bfs[closestBf] );
+// AliHLTTPCTransform::SetBField( bField );
+// Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f\n", bField );
}
}
i += 2;
continue;
}
+
+// BEGINN ############################################## MODIFIY JMT
+ if ( !strcmp( argv[i], "nonvertextracking" ) ){
+ fnonvertextracking = kTRUE;
+ i++;
+ continue;
+ }
+
+ if ( !strcmp( argv[i], "mainvertextrackingoff" ) ){
+ fmainvertextracking = kFALSE;
+ i++;
+ continue;
+ }
+
+ if ( !strcmp( argv[i], "etarange" ) ){
+ if ( argc <= i+1 ){
+ Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing Eta range", "Missing Eta-range specifiers." );
+ return ENOTSUP;
+ }
+ fEta[1] = strtod( argv[i+1], &cpErr );
+ if ( *cpErr ){
+ Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing Eta range", "Cannot convert Eta-range specifier '%s'.", argv[i+1] );
+ return EINVAL;
+ }
+
+ i += 2;
+ continue;
+ }
+// END ################################################# MODIFIY JMT
Logging(kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
return EINVAL;
}
}
outPtr = (AliHLTTPCTrackletData*)(outBPtr);
+// BEGINN ############################################## MODIFIY JMT
+#if 1
+ fTracker->SetPointers();
+ if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){
+ Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---");
+ fTracker->MainVertexTracking_a();
+ fTracker->MainVertexTracking_b();
+ fTracker->FillTracks();
+ }
+ else if ( fmainvertextracking == kTRUE && fnonvertextracking == kTRUE){
+ Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---");
+ fTracker->MainVertexTracking_a();
+ fTracker->MainVertexTracking_b();
+ fTracker->FillTracks();
+ Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---");
+ fTracker->NonVertexTracking();
+ }
+ else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){
+ Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---");
+ fTracker->NonVertexTracking();
+ fTracker->FillTracks();
+ }
+#else
fTracker->MainVertexTracking_a();
fTracker->MainVertexTracking_b();
fTracker->FillTracks();
if ( fDoNonVertex )
fTracker->NonVertexTracking();//Do a second pass for nonvertex tracks
-
+#endif
+// END ################################################# MODIFIY JMT
// XXX Do track merging??
UInt_t ntracks0=0;
int fMultiplicity;
double fBField;
+// BEGINN ############################################## MODIFIY JMT
+ Bool_t fnonvertextracking; // enable NONVERTEX Tracking
+ Bool_t fmainvertextracking; // enable MAINVERTEX Tracking
+// END ################################################# MODIFIY JMT
+
ClassDef(AliHLTTPCSliceTrackerComponent, 0)
};
Float_t fSigmaZ2; //error (former width) of the clusters
UInt_t fCharge;
Bool_t fUsed; // only used in AliHLTTPCDisplay
+ Int_t fTrackN; // only used in AliHLTTPCDisplay
};
typedef struct AliHLTTPCSpacePointData AliHLTTPCSpacePointData;
Bool_t AliHLTTPCTrack::GetCrossingPoint(Int_t padrow,Float_t *xyz)
{
//Assumes the track is given in local coordinates
-
if(!IsLocal())
{
cerr<<"GetCrossingPoint: Track is given on global coordinates"<<endl;
Double_t xHit = AliHLTTPCTransform::Row2X(padrow);
+// BEGINN ############################################## MODIFIY JMT
+ if (xHit < xyz[0]){
+ LOG(AliHLTTPCLog::kError,"AliHLTTPCTRACK::GetCrossingPoint","")<< "Track doesn't cross padrow " << padrow <<"(x=" << xHit << "). Smallest x=" << xyz[0] << ENDLOG;
+ return false;
+ }
+// END ################################################# MODIFIY JMT
+
xyz[0] = xHit;
Double_t aa = (xHit - GetCenterX())*(xHit - GetCenterX());
Double_t r2 = GetRadius()*GetRadius();
if(angle1 < 0) angle1 += 2.*AliHLTTPCTransform::Pi();
Double_t angle2 = atan2((GetFirstPointY() - GetCenterY()),(GetFirstPointX() - GetCenterX()));
if(angle2 < 0) angle2 += AliHLTTPCTransform::TwoPi();
+
Double_t diffangle = angle1 - angle2;
diffangle = fmod(diffangle,AliHLTTPCTransform::TwoPi());
if((GetCharge()*diffangle) > 0) diffangle = diffangle - GetCharge()*AliHLTTPCTransform::TwoPi();
+
Double_t stot = fabs(diffangle)*GetRadius();
+
Double_t zHit = GetFirstPointZ() + stot*GetTgl();
+
xyz[2] = zHit;
return true;
//However, if you later on want to do more precise local calculations, such
//as impact parameter, residuals etc, you need to give the track parameters
//according to the actual fit.
-
+// BEGINN ############################################## MODIFIY JMT
+ LOG(AliHLTTPCLog::kError,"AliHLTTPCTrack::UpdateToFirstPoint","ENTER") <<ENDLOG;
+// END ################################################# MODIFIY JMT
Double_t xc = GetCenterX() - GetFirstPointX();
Double_t yc = GetCenterY() - GetFirstPointY();
SetPhi0(atan2(point[1],point[0]));
SetFirstPoint(point[0],point[1],GetZ0());
SetPsi(pointpsi);
-
+ // BEGINN ############################################## MODIFIY JMT
+ LOG(AliHLTTPCLog::kError,"AliHLTTPCTrack::UpdateToFirstPoint","LEAVE") <<ENDLOG;
+// END ################################################# MODIFIY JMT
}
void AliHLTTPCTrack::GetClosestPoint(AliHLTTPCVertex *vertex,Double_t &closestx,Double_t &closesty,Double_t &closestz)
void AliHLTTPCTrack::Print() const
{ //print out parameters of track
+// BEGINN ############################################## MODIFIY JMT
+
+#if 1
+ LOG(AliHLTTPCLog::kInformational,"AliHLTTPCTrack::Print","Print values")
+ <<"NH="<<fNHits<<" "<<fMCid<<" K="<<fKappa<<" R="<<fRadius<<" Cx="<<fCenterX<<" Cy="<<fCenterY<<" MVT="
+ <<fFromMainVertex<<" Row0="<<fRowRange[0]<<" Row1="<<fRowRange[1]<<" Sector="<<fSector<<" Q="<<fQ<<" TgLam="
+ <<fTanl<<" psi="<<fPsi<<" pt="<<fPt<<" L="<<fLength<<" "<<fPterr<<" "<<fPsierr<<" "<<fZ0err<<" "
+ <<fTanlerr<<" phi0="<<fPhi0<<" R0="<<fR0<<" Z0"<<fZ0<<" X0"<<fFirstPoint[0]<<" Y0"<<fFirstPoint[1]<<" Z0"
+ <<fFirstPoint[2]<<" XL"<<fLastPoint[0]<<" YL"<<fLastPoint[1]<<" ZL"<<fLastPoint[2]<<" "
+ <<fPoint[0]<<" "<<fPoint[1]<<" "<<fPoint[2]<<" "<<fPointPsi<<" "<<fIsPoint<<" local="
+ <<fIsLocal<<" "<<fPID<<ENDLOG;
+
+
+
+#else
LOG(AliHLTTPCLog::kInformational,"AliHLTTPCTrack::Print","Print values")
<<fNHits<<" "<<fMCid<<" "<<fKappa<<" "<<fRadius<<" "<<fCenterX<<" "<<fCenterY<<" "
<<fFromMainVertex<<" "<<fRowRange[0]<<" "<<fRowRange[1]<<" "<<fSector<<" "<<fQ<<" "
<<fFirstPoint[2]<<" "<<fLastPoint[0]<<" "<<fLastPoint[1]<<" "<<fLastPoint[2]<<" "
<<fPoint[0]<<" "<<fPoint[1]<<" "<<fPoint[2]<<" "<<fPointPsi<<" "<<fIsPoint<<" "
<<fIsLocal<<" "<<fPID<<ENDLOG;
+#endif
+
+// END ################################################# MODIFIY JMT
}
AliHLTTPCTransform::Local2Global(last,slice);
track->SetLastPoint(last[0],last[1],last[2]);
track->SetHits( trs->fNPoints, trs->fPointIDs );
+// BEGINN ############################################## MODIFIY JMT
+ track->SetSector(slice);
+ track->CalculateHelix();
+// END ################################################# MODIFIY JMT
#ifdef INCLUDE_TPC_HOUGH
#ifdef ROWHOUGHPARAMS
if(GetTrackType()=='h') {
tmpP += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
size += sizeof(AliHLTTPCTrackSegmentData)+tP->fNPoints*sizeof(UInt_t);
tP = (AliHLTTPCTrackSegmentData*)tmpP;
+
+// BEGINN ############################################## MODIFIY JMT
+ LOG(AliHLTTPCLog::kError,"AliHLTTPCTrackArray::WriteTracks","TRACKPARAMETER") <<ENDLOG;
+ track->Rotate(0,kFALSE);
+ track->Print();
+// END ################################################# MODIFIY JMT
+
}
return size;
}
static void Global2Local(Float_t *xyz, Int_t sector);
static void Global2LocHLT(Float_t *xyz, Int_t slice);
static void Raw2Global(Float_t *xyz, Int_t sector, Int_t row, Float_t pad, Float_t time);
- static void RawHLT2Global(Float_t *xyz, Int_t slice,
- Int_t slicerow, Float_t pad, Float_t time);
+ static void RawHLT2Global(Float_t *xyz, Int_t slice, Int_t slicerow, Float_t pad, Float_t time);
static void Raw2Global(Float_t *xyz, Int_t sector, Int_t row, Int_t pad, Int_t time);
static void RawHLT2Global(Float_t *xyz, Int_t slice,
Int_t slicerow, Int_t pad, Int_t time);
endif
USENEWIO=1
-#EXTRACXXFLAGS=-ggdb3 -O0
-#EXTRALDFLAGS=-ggdb3 -O0
+EXTRACXXFLAGS=-ggdb3 -O0
+EXTRALDFLAGS=-ggdb3 -O0
include $(ALIHLT_TOPDIR)/Makefile.conf
* next event : <Display PadRow>, <Display PadRow with Clusters>, <Display PadRow with Tracks> or <Display PadRow with Clusters and Tracks>
*/
-
-// gROOT->GetInterpreter()->AddIncludePath( "$ALIHLT_TOPDIR/BASE" );
-// gROOT->GetInterpreter()->AddIncludePath( "$ALIHLT_TOPDIR/TPCLib" );
-
#include "AliHLTDataTypes.h"
#include "AliHLTTPCSpacePointData.h"
#include "AliHLTTPCClusterDataFormat.h"
#include "AliHLTTPCTrackletDataFormat.h"
#include "AliHLTTPCDefinitions.h"
#include "AliHLTTPCDigitReader.h"
+//#include "AliHLTTPCTrackArray.h"
// include because of connecttofile()
#include <stdio.h>
#include "AliHLT_C_Component_WrapperInterface.h"
+void* fODHReader; /* really HOMERReader* */
+void* fODHDisplay; /* really AliHLTTPCDisplay* */
-//#include "AliHLTTPCTrackArray.h"
+Int_t fTracksPerSlice[36]; // TrackCount per slice
- void* gODH_Reader; /* really HOMERReader* */
- void* gODH_Display; /* really AliHLTTPCDisplay* */
+Float_t fTheta;
+Float_t fPhi;
+//vector<QString> fHostnames;
+//vector<QString> fPorts;
+
+class AliHLTTPCTrackArray;
+AliHLTTPCTrackArray* fTrackArray;
+
+TCanvas *fCanvasPad;
+TCanvas *fCanvasPadRow;
+TCanvas *fCanvas3D;
+TCanvas *fCanvasCharge;
+TCanvas *fCanvasResiduals;
/* Dummy function to work around the problem that the interpreter does not load the first function properly... */
int ODH_Dummy() {
// ########################################################################################################################################
int HLT_OnlineDisplay_HOMER() {
- gODH_Display = NULL;
+ fODHDisplay = NULL;
+ fODHReader = NULL;
+ fTrackArray = NULL;
+ fTheta = 90.;
+ fPhi = 0.;
+
+ fCanvasPad = NULL;
+ fCanvasPadRow = NULL;
+ fCanvas3D = NULL;
+ fCanvasCharge = NULL;
+ fCanvasResiduals = NULL;
return 0;
}
// ########################################################################################################################################
-int ODH_Init( char* path_to_geom_file, char* path_to_homer_lib = NULL ) {
+int ODH_Init() {
// --- Load LIBS
- TString lib;
cout << "Loading ROOT libraries (ROOTSYS has to be set)" << endl;
-
gSystem->Load("libPhysics");
gSystem->Load("libEG");
-// if(gSystem->Load("libMC")==-1) {
gSystem->Load("libGeom");
gSystem->Load("libVMC");
-// }
+ gSystem->Load("libGpad");
cout << "Loading ALICE TPC libraries (ALICE_ROOT & ALICE_TARGET have to be set)" << endl;
gSystem->Load("libESD");
gSystem->Load("libSTEER");
+ // AliRoot versions v4-04-Release or higher have a changed RAW library layout
+ // TODO: check this at configure time
+#ifndef ALIRAW_4_04
+ gSystem->Load("libRAWData");
+#else //ALIRAW_4_04
gSystem->Load("libRAWDatabase");
gSystem->Load("libRAWDatarec");
+#endif //ALIRAW_4_04
// gSystem->Load("libCONTAINERS");
// if(gSystem->Load("libTPC")!=0) {
gSystem->Load("libTPCbase");
gSystem->Load("libTPCrec");
gSystem->Load("libTPCsim");
gSystem->Load("libTPCfast");
-// }
cout << "Loading HLT libraries (ALIHLT_LIBDIR has to be set)" << endl;
gSystem->Load("$(ALIHLT_LIBDIR)/libHLTbase.so");
gSystem->Load("$(ALIHLT_LIBDIR)/libAliHLTTPC.so");
- cout << "Loading HOMER library" << endl;
-
- if ( path_to_homer_lib ) {
- lib = path_to_homer_lib;
- lib += "/";
- }
- else {
- lib = "";
- }
-
- lib += "libHOMERReader_ROOT.so";
- gSystem->Load( lib );
+ cout << "Loading HOMER library" << endl;
+ gSystem->Load("${ALIHLT_DC_DIR}/lib/Linux-i686/libHOMERReader_ROOT.so" );
// --- Create DISPLAY
cout << "Creating display" << endl;
+ fCanvasPad = new TCanvas("fCanvasPad","HLT Online Display - Pad Display",900,900);
+ fCanvasPad->Divide(1,3);
+ fCanvasPadRow = new TCanvas("fCanvasPadRow","HLT Online Display - PadRow Display",900,900);
+ fCanvas3D = new TCanvas("fCanvas3D","HLT Online Display - 3D Display",900,900);
+ fCanvasCharge = new TCanvas("fCanvasCharge","HLT Online Display - Charge Display",900,900);
+ fCanvasResiduals = new TCanvas("fCanvasResiduals","HLT Online Display - Residuals Display",900,900);
- Char_t *gfile="alice.geom"; // geometrie file
- TString geoPath;
- if ( path_to_geom_file ){
- geoPath = path_to_geom_file;
- geoPath += "/";
- }
- else {
- geoPath = "";
- }
- geoPath += gfile;
-
- Int_t slices[] = { 0, 35 };
- AliHLTTPCDisplay* display = new AliHLTTPCDisplay( slices, geoPath.Data() );
-
- display->SetSlices();
- display->DisplayAll(0,kFALSE,kFALSE,kFALSE,kFALSE);
-
- gODH_Display = (void*)display;
- return 0;
-}
-
-int ODH_SetSliceRange(int minslice,int maxslice){
- // sets a range of Slices
- if (!gODH_Display ) return -1;
- AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)gODH_Display;
-
- display->SetSlices(minslice,maxslice);
- display->DisplayAll(0,kFALSE,kFALSE,kFALSE,kFALSE);
-}
-
-int ODH_SetSliceRange(int slice){
- // sets one slice
- if (!gODH_Display ) return -1;
- AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)gODH_Display;
+ fTheta = 90.;
+ fPhi = 0.;
- display->SetSlices(slice);
- display->DisplayAll(0,kFALSE,kFALSE,kFALSE,kFALSE);
-}
-
-int ODH_SetSliceRange(){
- // sets all Slices
- if (!gODH_Display ) return -1;
- AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)gODH_Display;
-
- display->SetSlices();
- display->DisplayAll(0,kFALSE,kFALSE,kFALSE,kFALSE);
-}
-
-int ODH_SetSlicePair(int slice){
- // sets a pair of slices
- if (!gODH_Display ) return -1;
- AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)gODH_Display;
-
- display->SetSlicesPair(slice);
- display->DisplayAll(0,kFALSE,kFALSE,kFALSE,kFALSE);
-}
+ // --- Load Geometry
+ TString geoPath;
-int ODH_SetSlicePair(int minslice, int maxslice){
- // sets a pair of slices
- if (!gODH_Display ) return -1;
- AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)gODH_Display;
+ Char_t * geometryPath = getenv("ALIHLT_DC_DIR");
+ Char_t * geometryFile = "alice.geom";
- display->SetSlicesPair(minslice,maxslice);
- display->DisplayAll(0,kFALSE,kFALSE,kFALSE,kFALSE);
-}
+ if (geometryPath) {
+ geoPath = geometryPath;
+ geoPath += "/share/TPC-OnlineDisplayHOMER";
+ }
+ else geoPath = ".";
+
+ geoPath += "/";
+ geoPath += geometryFile;
-int ODH_SetInvert(){
- // sets a pair of slices
- if (!gODH_Display ) return -1;
- AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)gODH_Display;
+ AliHLTTPCDisplay* display = new AliHLTTPCDisplay( (Char_t*)geoPath.Data() );
- display->SetInvert();
- display->DisplayAll(0,kFALSE,kFALSE,kFALSE,kFALSE);
-}
+ fODHDisplay = (void*)display;
-int ODH_SetDrawGeo(){
- // sets a pair of slices
- if (!gODH_Display ) return -1;
- AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)gODH_Display;
+ display->SetupHist();
- display->SetDrawGeo();
- display->DisplayAll(0,kFALSE,kFALSE,kFALSE,kFALSE);
+ return 0;
}
// ########################################################################################################################################
delete reader;
reader = NULL;
}
- gODH_Reader = (void*)reader;
+ fODHReader = (void*)reader;
+
+ printf( "CONNECTED\n");
return ret;
}
// ########################################################################################################################################
-int ODH_Disconnect() {
- if ( !gODH_Reader )
+Int_t ODH_Disconnect() {
+ if ( !fODHReader )
return 0;
- HOMERReader* reader = (HOMERReader*)gODH_Reader;
+ HOMERReader* reader = (HOMERReader*)fODHReader;
delete reader;
- gODH_Reader = NULL;
- return 0;
-}
-
-// ########################################################################################################################################
-Int_t ODH_SetupPadRow(Int_t histswitch, Int_t slice, Int_t padrow){
- // PADROW 0 - 158
- if (!gODH_Display ) return -1;
- AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)gODH_Display;
+ fODHReader = NULL;
+
+ if ( fTrackArray ) delete fTrackArray;
+ fTrackArray = NULL;
- // Setup Geometry: histswitch = 0;
- // Setup Histogram: histswitch = 1|2|3;
- display->SetupPadRow(histswitch,slice,padrow);
+ return 0;
+}
- return 0;
-}
// ########################################################################################################################################
-int ODH_DisplayNextEvent( Bool_t clusterswitch, Bool_t trackswitch, Bool_t padrowswitch, Float_t* clustersEtaRange = NULL ) {
-
- if ( !gODH_Reader || !gODH_Display ) return -1;
+Int_t ODH_DisplayEvent(Bool_t nextSwitch=kTRUE, Bool_t threeDSwitch=kTRUE, Bool_t PadRowSwitch= kTRUE){
+
+ if ( !fODHReader || !fODHDisplay ) {
+ printf( "ERROR no READER or DISPLAY" );
+ return -1;
+ }
+ HOMERReader* reader = (HOMERReader*)fODHReader;
+ AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)fODHDisplay;
+
// -- input datatypes , reverse
char* spptID="SRETSULC";
- //char* spptID="STPECAPS";
char* trkID = "SGESKART";
- //char* trkID = "SGESCART";
char* padrowID = "KPWR_LDD";
+ Int_t ret;
- Int_t minHits = 0;
- Bool_t x3don = kFALSE;
-
- HOMERReader* reader = (HOMERReader*)gODH_Reader;
- AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)gODH_Display;
- int ret = reader->ReadNextEvent();
-
- if ( ret ) {
- int ndx = reader->GetErrorConnectionNdx();
- printf( "------------ TRY AGAIN --------------->Error reading event from source %d: %s (%d)\n", ndx, strerror(ret), ret );
- ODH_DisplayNextEvent( clusterswitch, trackswitch, padrowswitch, clustersEtaRange);
- return ret;
- }
-
- unsigned long blockCnt = reader->GetBlockCnt();
- printf( "Event 0x%016LX (%Lu) with %lu blocks\n", (ULong64_t)reader->GetEventID(), (ULong64_t)reader->GetEventID(), blockCnt );
-
- for ( unsigned long i = 0; i < blockCnt; i++ ) {
- char tmp1[9], tmp2[5];
- memset( tmp1, 0, 9 );
- memset( tmp2, 0, 5 );
- void *tmp11 = tmp1;
- ULong64_t* tmp12 = (ULong64_t*)tmp11;
- *tmp12 = reader->GetBlockDataType( i );
- void *tmp21 = tmp2;
- ULong_t* tmp22 = (ULong_t*)tmp21;
- *tmp22 = reader->GetBlockDataOrigin( i );
- printf( "Block %lu length: %lu - type: %s - origin: %s\n",
- i, reader->GetBlockDataLength( i ), tmp1, tmp2 );
+ if (nextSwitch) {
+ ret = reader->ReadNextEvent();
+
+ if ( ret ) {
+ int ndx = reader->GetErrorConnectionNdx();
+ printf( "------------ TRY AGAIN --------------->Error reading event from source %d: %s (%d)\n", ndx, strerror(ret), ret );
+ return ret;
+ }
+
+ unsigned long blockCnt = reader->GetBlockCnt();
+ printf( "Event 0x%016LX (%Lu) with %lu blocks\n", (ULong64_t)reader->GetEventID(), (ULong64_t)reader->GetEventID(), blockCnt );
+
+ for ( unsigned long i = 0; i < blockCnt; i++ ) {
+ char tmp1[9], tmp2[5];
+ memset( tmp1, 0, 9 );
+ memset( tmp2, 0, 5 );
+ void *tmp11 = tmp1;
+ ULong64_t* tmp12 = (ULong64_t*)tmp11;
+ *tmp12 = reader->GetBlockDataType( i );
+ void *tmp21 = tmp2;
+ ULong_t* tmp22 = (ULong_t*)tmp21;
+ *tmp22 = reader->GetBlockDataOrigin( i );
+ printf( "Block %lu length: %lu - type: %s - origin: %s\n",i, reader->GetBlockDataLength( i ), tmp1, tmp2 );
+ }
+
+ for(Int_t ii=0;ii<36;ii++) fTracksPerSlice[ii] = 0;
}
- display->ResetDisplay();
-
- // -------------- CLUSTER
- if ( clusterswitch ) {
+ //--------------------------------------------------------------------------------------------
+ // READ CLUSTER DATA
+ //--------------------------------------------------------------------------------------------
+ if (nextSwitch) {
unsigned long blk = reader->FindBlockNdx( spptID, " CPT",0xFFFFFFFF );
- printf( "blk: %lu\n", blk );
+
while ( blk != ~(unsigned long)0 ) {
printf( "Found clusters block %lu\n", blk );
const AliHLTTPCClusterData* clusterData = (const AliHLTTPCClusterData*)reader->GetBlockData( blk );
- unsigned long dataLen = reader->GetBlockDataLength( blk );
+ if ( !clusterData ) {
+ printf( "No track data for block %lu\n", blk );
+ continue;
+ }
ULong_t spec = reader->GetBlockDataSpec( blk );
Int_t patch = AliHLTTPCDefinitions::GetMinPatchNr( spec );
Int_t slice = AliHLTTPCDefinitions::GetMinSliceNr( spec );
printf( "%lu Clusters found for slice %u - patch %u\n", clusterData->fSpacePointCnt, slice, patch );
-
- void* tmp30 = clusterData;
- Byte_t* tmp31 = (Byte_t*)tmp30;
- unsigned long offset;
- offset = sizeof(clusterData->fSpacePointCnt);
- if ( offset <= reader->GetBlockTypeAlignment( blk, 1 ) )
- offset = reader->GetBlockTypeAlignment( blk, 1 );
- tmp31 += offset;
- tmp30 = tmp31;
- AliHLTTPCSpacePointData* tmp32 = (AliHLTTPCSpacePointData*)tmp30;
-
- display->SetupClusterDataForPatch( slice, patch, clusterData->fSpacePointCnt, tmp32 );
-
- blk = reader->FindBlockNdx( spptID, " CPT", 0xFFFFFFFF, blk+1 );
- printf( "blk: %lu\n", blk );
- }
- }
-
- // -------------- PADROW
- if ( padrowswitch ) {
- Int_t padrow = display->GetPadrow();
- Int_t patch = AliHLTTPCTransform::GetPatch(padrow);
- Int_t maxpatch = patch;
- AliHLTUInt8_t padslice = (AliHLTUInt8_t) display->GetSlice();
-
- if (padrow == 30 || padrow == 90 || padrow == 139) maxpatch++;
-
- for (Int_t tpatch=patch;tpatch <= maxpatch;tpatch++){
-
-
- AliHLTUInt32_t padrowSpec = AliHLTTPCDefinitions::EncodeDataSpecification( padslice, padslice,(AliHLTUInt8_t) tpatch,(AliHLTUInt8_t) tpatch );
-
- unsigned long blk;
-
- // READ RAW DATA BLOCK
- blk = reader->FindBlockNdx( padrowID, " CPT", padrowSpec );
- printf( "Raw Data found for slice %u/patch %u\n", padslice, tpatch );
-
- unsigned long rawDataBlock = reader->GetBlockData( blk );
- unsigned long rawDataLen = reader->GetBlockDataLength( blk );
-
- // READ CLUSTERS BLOCK
- blk = reader->FindBlockNdx( spptID, " CPT", padrowSpec );
-
- const AliHLTTPCClusterData* clusterData = (const AliHLTTPCClusterData*)reader->GetBlockData( blk );
-
- printf( "%lu Clusters found for slice %u - patch %u\n", clusterData->fSpacePointCnt, padslice, tpatch );
- void* tmp30 = clusterData;
+ void* tmp30 = (void*)clusterData;
Byte_t* tmp31 = (Byte_t*)tmp30;
unsigned long offset;
offset = sizeof(clusterData->fSpacePointCnt);
- if ( offset <= reader->GetBlockTypeAlignment( blk, 1 ) )
- offset = reader->GetBlockTypeAlignment( blk, 1 );
+ if ( offset <= reader->GetBlockTypeAlignment( blk, 1 ) ) offset = reader->GetBlockTypeAlignment( blk, 1 );
tmp31 += offset;
tmp30 = tmp31;
AliHLTTPCSpacePointData* tmp32 = (AliHLTTPCSpacePointData*)tmp30;
- // DISPLAY RAW DATA AND CLUSTERS
- display->FillPadRow( tpatch, rawDataBlock, rawDataLen, clusterData->fSpacePointCnt, tmp32);
+ display->SetupCluster( slice, patch, clusterData->fSpacePointCnt, tmp32 );
+
+ blk = reader->FindBlockNdx( spptID, " CPT", 0xFFFFFFFF, blk+1 );
}
-
-
- }
-
- AliHLTTPCTrackArray* trackArray = NULL;
- trackArray = new AliHLTTPCTrackArray;
- if ( !trackArray ) {
- printf( "No track array\n" );
- return -1;
}
-
- // -------------- TRACKS
- if ( trackswitch ) {
+ //--------------------------------------------------------------------------------------------
+ // READ TRACKS
+ //--------------------------------------------------------------------------------------------
+ if (nextSwitch) {
+ if ( fTrackArray ) delete fTrackArray;
+ fTrackArray = new AliHLTTPCTrackArray;
+
unsigned long blk = reader->FindBlockNdx( trkID, " CPT", 0xFFFFFFFF );
-
+
while ( blk != ~(unsigned long)0 ) {
printf( "Found tracks in block %lu\n", blk );
const AliHLTTPCTrackletData* trackData = (const AliHLTTPCTrackletData*)reader->GetBlockData( blk );
ULong_t spec = reader->GetBlockDataSpec( blk );
Int_t patchmin = AliHLTTPCDefinitions::GetMinPatchNr( spec );
Int_t patchmax = AliHLTTPCDefinitions::GetMaxPatchNr( spec );
- Int_t slice = AliHLTTPCDefinitions::GetMinSliceNr( spec );
-
+ Int_t slice = AliHLTTPCDefinitions::GetMinSliceNr( spec );
printf( "%lu tracks found for slice %u - patch %u-%u\n", trackData->fTrackletCnt, slice, patchmin, patchmax );
-
- void* tmp40 = trackData;
+
+ fTracksPerSlice[slice] = trackData->fTrackletCnt;
+
+ void* tmp40 = (void*)trackData;
Byte_t* tmp41 = (Byte_t*)tmp40;
unsigned long offset;
-
offset = sizeof(trackData->fTrackletCnt);
-
if ( offset <= reader->GetBlockTypeAlignment( blk, 1 ) ) offset = reader->GetBlockTypeAlignment( blk, 1 );
-
tmp41 += offset;
tmp40 = tmp41;
AliHLTTPCTrackSegmentData* tmp42 = (AliHLTTPCTrackSegmentData*)tmp40;
-
- trackArray->FillTracks( trackData->fTrackletCnt, tmp42, slice );
-
- blk = reader->FindBlockNdx( trkID, " CPT", 0xFFFFFFFF, blk+1 );
+
+ fTrackArray->FillTracks( trackData->fTrackletCnt, tmp42, slice );
+
+ blk = reader->FindBlockNdx( trkID, " CPT", 0xFFFFFFFF, blk+1 );
}
-
-
+
+ display->SetupTracks( fTrackArray );
}
- display->SetTracks( trackArray );
-
- // DISPLAY
- display->DisplayAll( minHits, clusterswitch, trackswitch, x3don, 0. /*, clustersEtaRange */ );
- if ( padrowswitch) display->DrawPadRow(x3don);
-
- if ( trackArray ) delete trackArray;
-
- return 0;
-}
-
-// ########################################################################################################################################
-// ########################################################################################################################################
-// ########################################################################################################################################
-int ODH_SimpleDisplay(char * infiles[7],unsigned int slice){
- if ( !gODH_Display ) return -1;
-
- FILE * inFH = 1;
- AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)gODH_Display;
- int i = 1;
- char* error = NULL;
- int errorArg = -1;
- int errorParam = -1;
-
- AliHLTComponent_DataType dataType;
- AliHLTUInt32_t dataSpec = ~(AliHLTUInt32_t)0;
- dataType.fStructSize = sizeof(dataType);
- memset( dataType.fID, '*', 8 );
- memset( dataType.fOrigin, '*', 4 );
- AliHLTComponent_BlockData blocks[7];
- unsigned long totalRead = 0;
-
- // --- get INFILE
- for (int ii = 0;ii<7;ii++){
-
- inFH = fopen( infiles[ii], "r");
- if ( inFH == -1 ) {
- error = "Unable to open input file for reading";
- errorArg = i;
- errorParam = i+1;
- break;
- }
-
- AliHLTComponent_BlockData newBlock;
- newBlock.fStructSize = sizeof(AliHLTComponent_BlockData);
-
- newBlock.fShmKey.fStructSize = sizeof(AliHLTComponent_ShmData);
- newBlock.fShmKey.fShmType = gkAliHLTComponent_InvalidShmType;
- newBlock.fShmKey.fShmID = gkAliHLTComponent_InvalidShmID;
+ //--------------------------------------------------------------------------------------------
+ // READ RAW DATA for PADROW HISTOGRAM
+ //--------------------------------------------------------------------------------------------
+ if (PadRowSwitch) {
+ AliHLTUInt8_t padslice = (AliHLTUInt8_t) display->GetSlicePadRow();
+ Int_t padrow = display->GetPadRow();
+ Int_t patch = AliHLTTPCTransform::GetPatch(padrow);
+ Int_t maxpatch = patch;
- fseek( inFH, 0, SEEK_END );
- long sz = ftell(inFH);
+ display->ResetHistPadRow();
- fseek( inFH, 0, SEEK_SET);
- newBlock.fPtr = new uint8[ sz ];
+ if (padrow == 30 || padrow == 90 || padrow == 139) maxpatch++;
- if ( !newBlock.fPtr ) {
- fprintf( stderr, "Out of memory trying to allocate memory for input file '%s' of %lu bytes.\n",
- infile, sz );
- return -1;
- }
+ for (Int_t tpatch=patch;tpatch <= maxpatch;tpatch++) {
+ unsigned long blk;
+ AliHLTUInt32_t padrowSpec = AliHLTTPCDefinitions::EncodeDataSpecification( padslice, padslice,(AliHLTUInt8_t) tpatch,(AliHLTUInt8_t) tpatch );
+
+ // READ RAW DATA BLOCK - READ CLUSTERS BLOCK
+ blk = reader->FindBlockNdx( padrowID, " CPT", padrowSpec );
- unsigned long curSize = 0;
- int ret=1;
- void * tmp50 = newBlock.fPtr;
- uint8* tmp51 = (uint8*)tmp50;
- while ( ret>0 ) {
- ret = fread(tmp51+curSize,1, sz-curSize,inFH);
-
- if ( ret >= 0 ) {
- curSize += (unsigned long)ret;
- if ( curSize >= (unsigned long)sz ) {
- newBlock.fSize = sz;
- blocks[ii] = newBlock;
- break;
- }
- }
- else {
- fprintf( stderr, "%s error reading data from input file after %lu bytes.\n", infile, curSize );
- return -1;
+ if ( ~(unsigned long)0 != blk ){
+ printf( "Raw Data found for slice %u/patch %u\n", padslice, tpatch );
+ unsigned long rawDataBlock = (unsigned long) reader->GetBlockData( blk );
+ unsigned long rawDataLen = reader->GetBlockDataLength( blk );
+
+ display->FillPadRow( tpatch, rawDataBlock, rawDataLen);
}
}
- }
-
- // --- Setup CLUSTERS
- for (int ii = 1;ii<7;ii++){
- unsigned int patch = ii - 1;
- const AliHLTTPCClusterData* clusterData = (const AliHLTTPCClusterData*) blocks[ii].fPtr;
-
- if ( !clusterData ) {
- printf( "No ClusterData\n" );
- return -1;
+
+ if (fCanvasPadRow){
+ fCanvasPadRow->cd();
+ display->DrawHistPadRow();
+ fCanvasPadRow->Update();
}
- void* tmp30 = clusterData;
- Byte_t* tmp31 = (Byte_t*)tmp30;
- unsigned long offset;
+ if (fCanvasPad){
+ fCanvasPad->cd(1);
+ display->DrawHistPad1();
+ fCanvasPad->GetCanvas()->Update();
+
+ fCanvasPad->cd(2);
+ display->DrawHistPad2();
+ fCanvasPad->GetCanvas()->Update();
+
+ fCanvasPad->cd(3);
+ display->DrawHistPad3();
+ fCanvasPad->GetCanvas()->Update();
+ }
+ }
+
+ //--------------------------------------------------------------------------------------------
+ // RESET HISTOGRAMS
+ //--------------------------------------------------------------------------------------------
+ if ( display->Get3DSwitchCluster() ) display->ResetHistCharge();
+ if ( display->Get3DSwitchTracks() ) display->ResetHistResiduals();
+
+ //--------------------------------------------------------------------------------------------
+ // DRAW 3D
+ //--------------------------------------------------------------------------------------------
+ if ( (threeDSwitch || (PadRowSwitch && display->Get3DSwitchPadRow())) && fCanvas3D ){
+
+ fCanvas3D->cd();
+ fCanvas3D->Clear();
+ fCanvas3D->SetFillColor(display->GetBackColor());
- offset = sizeof(clusterData->fSpacePointCnt);
+ if ( !display->GetKeepView() ){
+ fCanvas3D->SetTheta(fTheta);
+ fCanvas3D->SetPhi(fPhi);
+ }
- tmp31 += offset;
- tmp30 = tmp31;
- AliHLTTPCSpacePointData* tmp32 = (AliHLTTPCSpacePointData*)tmp30;
+ display->Draw3D();
- display->SetupClusterDataForPatch( slice, patch, clusterData->fSpacePointCnt, tmp32 );
+ fCanvas3D->Modified();
+ fCanvas3D->Update();
}
-
- // --- Setup TRACKS
- AliHLTTPCTrackArray* trackArray = NULL;
- trackArray = new AliHLTTPCTrackArray;
- if ( !trackArray ) {
- printf( "No track array\n" );
- return -1;
+ //--------------------------------------------------------------------------------------------
+ // DRAW RESIDUALS
+ //--------------------------------------------------------------------------------------------
+ if ( display->Get3DSwitchTracks() && fCanvasResiduals) {
+ fCanvasResiduals->cd();
+ fCanvasResiduals->Clear();
+ fCanvasResiduals->Divide(1,2);
+ fCanvasResiduals->cd(1);
+ display->DrawHistResiduals(kTRUE);
+ fCanvasResiduals->cd(2);
+ display->DrawHistResiduals(kFALSE);
+ fCanvasResiduals->Update();
}
+ //--------------------------------------------------------------------------------------------
+ // DRAW CHARGE
+ //--------------------------------------------------------------------------------------------
+ if ( display->Get3DSwitchCluster() && fCanvasCharge != NULL) {
+ fCanvasCharge->cd();
+ fCanvasCharge->Clear();
+
+ display->DrawHistCharge();
- const AliHLTTPCTrackletData* trackData = (const AliHLTTPCTrackletData*) blocks[0].fPtr;
- if ( !trackData )
- {
- printf( "No track data for block %lu\n", blk );
- continue;
+ fCanvasCharge->Update();
}
-
- void* tmp40 = trackData;
- Byte_t* tmp41 = (Byte_t*)tmp40;
- unsigned long offset;
+
+ return 0;
+}
+
+// ####################################################################################################
+// SETTER - minor functions
+// ####################################################################################################
+Int_t ODH_SetSliceRange(){
+ // -- sets all Slices
+ if (!fODHDisplay ) return -1;
+ AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)fODHDisplay;
+
+ display->SetSlices();
+ fTheta = 90.;
+
+ ODH_DisplayEvent(kFALSE,kTRUE,kFALSE);
+ return 0;
+}
+// °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
+Int_t ODH_SetSliceRange(Int_t slice){
+ // -- sets one slice
+ if (!fODHDisplay ) return -1;
+ AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)fODHDisplay;
+
+ display->SetSlices(slice);
+ fTheta = 0.;
+
+ ODH_DisplayEvent(kFALSE,kTRUE,kFALSE);
+ return 0;
+}
+// °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
+Int_t ODH_SetSliceRange(Int_t minslice,Int_t maxslice){
+ // -- sets a range of Slices
+ if (!fODHDisplay ) return -1;
+ AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)fODHDisplay;
+
+ display->SetSlices(minslice,maxslice);
+ fTheta = 90.;
+
+ ODH_DisplayEvent(kFALSE,kTRUE,kFALSE);
+ return 0;
+}
+// °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
+Int_t ODH_SetSlicePair(Int_t slice){
+ // -- sets a pair of slices
+ if (!fODHDisplay ) return -1;
+ AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)fODHDisplay;
+
+ display->SetSlicesPair(slice);
+ fTheta = 90.;
+
+ ODH_DisplayEvent(kFALSE,kTRUE,kFALSE);
+ return 0;
+}
+// °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
+Int_t ODH_SetSlicePair(Int_t minslice, Int_t maxslice){
+ // -- sets a pair of slices
+ if (!fODHDisplay ) return -1;
+ AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)fODHDisplay;
- offset = sizeof(trackData->fTrackletCnt);
+ display->SetSlicesPair(minslice,maxslice);
+ fTheta = 90.;
+
+ ODH_DisplayEvent(kFALSE,kTRUE,kFALSE);
+ return 0;
+}
+// °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
+Int_t ODH_SetCluster(Bool_t used=kTRUE, Bool_t unused=kTRUE){
+ // -- set used/unuse/all cluster
+ if ( !fODHDisplay ) return -1;
+ AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)fODHDisplay;
- tmp41 += offset;
- tmp40 = tmp41;
- AliHLTTPCTrackSegmentData* tmp42 = (AliHLTTPCTrackSegmentData*)tmp40;
+ // ALL Cluster = 0 | USED Cluster = 1 | UNUSED Cluster = 2
+ if (used && unused) display->SetSelectCluster(0);
+ else if (used) display->SetSelectCluster(1);
+ else if (unused) display->SetSelectCluster(2);
+
+ ODH_DisplayEvent(kFALSE,kTRUE,kFALSE);
+ return 0;
+}
+// °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
+Int_t ODH_SetInvert(){
+ // -- set invert 3D display
+ if ( !fODHDisplay ) return -1;
+ AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)fODHDisplay;
+
+ display->SetInvert();
+
+ ODH_DisplayEvent(kFALSE,kTRUE,kFALSE);
+ return 0;
+}
+// °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
+Int_t ODH_SetKeepView(Bool_t keepview){
+ // -- keep angle view
+ if ( !fODHDisplay ) return -1;
+ AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)fODHDisplay;
+
+ if (keepview) display->SetKeepView(kTRUE);
+ else display->SetKeepView(kFALSE);
+
+ return 0;
+}
+// °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
+Int_t ODH_SetPadRow(Int_t slice, Int_t padrow, Int_t pad = 0) {
+ // -- set padrow and pad histograms
+ if (!fODHDisplay ) return -1;
+ AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)fODHDisplay;
- trackArray->FillTracks( trackData->fTrackletCnt, tmp42, slice );
+ if( padrow < 0 || padrow > 158){
+ printf("Padrow %d out of range, has to be in [0,158].",padrow);
+ return -2;
+ }
+
+ display->SetSlicePadRow(slice);
+ display->SetPadRow(padrow);
+ display->SetHistPadRowAxis();
+ display->SetPad(pad);
+
+ ODH_DisplayEvent(kFALSE,kTRUE,kTRUE);
+ return 0;
+}
+// °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
+Int_t ODH_SetSelectTrack(Bool_t trackswitch=kFALSE, Int_t slice=0, Int_t track=0){
+ // -- trackswitch : turn on /off of single track
+ // -- slice : select slice for single track
+ // -- track :select single track in slice
- display->SetTracks( trackArray );
+ if (!fODHDisplay ) return -1;
+ AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)fODHDisplay;
- // --- Display
- Int_t minHits = 0;
+ display->SetSelectTrackSwitch(trackswitch);
+ if(!trackswitch) display->SetSelectTrack(0);
+ else {
+ if ( track < 0 || track > fTracksPerSlice[slice]) {
+ printf ("No Track %d, Maximum of Tracks in Slice %d is %d ! ",track,slice,fTracksPerSlice[slice] );
+ return -2;
+ }
+
+ display->SetSelectTrackSlice(slice);
+ display->SetSelectTrack(track);
+ }
- display->SetSlices(0,4);
- display->DisplayAll( minHits, clusterswitch, trackswitch, kFALSE, 0. /*, clustersEtaRange */ );
- if ( trackArray ) delete trackArray;
+ ODH_DisplayEvent(kFALSE,kTRUE,kFALSE);
+ return 0;
+}
+// °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
+Int_t ODH_SetTrack(Int_t minhits = 0, Float_t ptthreshold = 0.){
+ // -- set track properties
+ if (!fODHDisplay ) return -1;
+ AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)fODHDisplay;
+
+ display->SetMinHits(minhits);
+ display->SetPtThreshold(ptthreshold );
+ return 0;
+}
+// °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
+Int_t ODH_Set3D(Bool_t tracks=kFALSE, Bool_t cluster=kFALSE, Bool_t padrow=kFALSE, Bool_t geometry=kFALSE){
+ // -- set 3D Display
+ if (!fODHDisplay ) return -1;
+ AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)fODHDisplay;
+
+ if (padrowCheckBox->isChecked()) setPadRow();
+ display->SetSwitches(tracks, cluster, padrow, geometry);
+
+ if (display->Get3DSwitchPadRow()) ODH_DisplayEvent(kFALSE,kTRUE,kTRUE);
+ else ODH_DisplayEvent(kFALSE,kTRUE,kFALSE);
+ return 0;
+}
+// °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
+Int_t ODH_Set3DTracks(Bool_t on=kFALSE){
+ // -- Set 3D tracks
+ if (!fODHDisplay ) return -1;
+ AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)fODHDisplay;
+
+ display->Set3DSwitchTracks(on);
+
+ ODH_DisplayEvent(kFALSE,kTRUE,kFALSE);
+ return 0;
+}
+// °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
+Int_t ODH_Set3DCluster(Bool_t on=kFALSE){
+ // -- Set 3D cluster
+ if (!fODHDisplay ) return -1;
+ AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)fODHDisplay;
+
+ display->Set3DSwitchCluster(on);
+
+ ODH_DisplayEvent(kFALSE,kTRUE,kFALSE);
return 0;
+}
+// °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
+Int_t ODH_Set3DPadRow(Bool_t on=kFALSE){
+ // -- Set 3D padrow
+ if (!fODHDisplay ) return -1;
+ AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)fODHDisplay;
+
+ display->Set3DSwitchPadRow(on);
+
+ ODH_DisplayEvent(kFALSE,kTRUE,kFALSE);
+ return 0;
+}
+// °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
+Int_t ODH_Set3DGeometry(Bool_t on=kFALSE){
+ // -- Set 3D geometry
+ if (!fODHDisplay ) return -1;
+ AliHLTTPCDisplay* display = (AliHLTTPCDisplay*)fODHDisplay;
+
+ display->Set3DSwitchGeometry(on);
+
+ ODH_DisplayEvent(kFALSE,kTRUE,kFALSE);
+ return 0;
+}
+
-} // END ODH_SimpleDisplay
+/************************************************************************
+**
+** This file is property of and copyright by the Computer Science/Computer
+** Engineering Group, Kirchhoff Institute for Physics, Ruprecht-Karls-
+** University, Heidelberg, Germany, 2005
+** This file has been written by Jochen Thaeder,
+** thaeder@kip.uni-heidelberg.de
+**
+**
+** See the file license.txt for details regarding usage, modification,
+** distribution and warranty.
+** Important: This file is provided without any warranty, including
+** fitness for any particular purpose.
+**
+**
+** Newer versions of this file's package will be made available from
+** http://www.kip.uni-heidelberg.de/ti/HLT/
+** or the corresponding page of the Heidelberg Alice HLT group.
+**
+*************************************************************************/
+
+// *****************************************************************
+// * USEAGE in ROOT
+// *****************************************************************
+// * -->LOAD the macro first:
+// * .L ("HLT-OnlineDisplay-HOMER.C");
+// *
+// * --> use with ".p FUNCTION;" OR here as macro function
+// * ODH_Init();
+// * ODH_Connect(Char_t *hostname1,Int_t port1,Char_t *hostname2,Int_t port2,Char_t *hostname3,Int_t port3);
+// * ODH_DisplayEvent(); // Display NextEvent
+// *
+// * ODH_SetSliceRange(); // Sets Slice: ALL
+// * ODH_SetSliceRange(Int_t slice); // Sets Slice: "slice"
+// * ODH_SetSliceRange(Int_t minslice, Int_t maxslice); // Sets Slice: "minslice" to "maxslice"
+// * ODH_SetSlicePair(Int_t slice); // Sets Slice: "slice" and "slice"+9
+// * ODH_SetSlicePair(Int_t minslice, Int_t maxslice); // Sets Slice: ["minslice" to "maxslice"] and ["minslice"+9 to "maxslice"+9]
+// *
+// * ODH_SetCluster(Bool_t used, Bool_t unused); // Sets Cluster: used, unused, all(= used && unused)
+// *
+// * ODH_SetInvert(); // Invert 3D Display
+// * ODH_SetKeepView(Bool_t keepview); // Keep 3D View
+// *
+// * ODH_SetPadRow(Int_t slice, Int_t padrow, Int_t pad); // Set PadRow "padrow" within Slice "slice" and Pad "pad"(=0 per default)
+// *
+// * ODH_SetSelectTrack(Bool_t switch, Int_t slice, Int_t track); // with switch=true :Select Single Track "track" in Slice "slice"
+// * // turn off: ODH_SetSelectTrack();
+// *
+// * ODH_SetTrack(Int_t minhits, Float_t ptthreshold); // Sets Cuts in order to display tracks, both default is 0
+// *
+// * ODH_Set3D(Bool_t tracks, Bool_t cluster, Bool_t padrow, Bool_t geometry); // Switches for the 3D Display
+// * ODH_Set3DTracks(Bool_t on); // Set 3D tracks, default is off
+// * ODH_Set3DCluster(Bool_t on); // Set 3D cluster, default is off
+// * ODH_Set3DPadRow(Bool_t on); // Set 3D padrow, default is off
+// * ODH_Set3DGeometry(Bool_t on); // Set 3D geometry, default is off
+// *
+// *****************************************************************
{
-//gROOT->Reset();
-
-gROOT->LoadMacro("HLT-OnlineDisplay-HOMER.C");
-
-HLT_OnlineDisplay_HOMER();
-//ODH_Init("./GEO","/home/HLT/src/versions/devel/Util/HOMER/reader/lib/Linux-i686/");
-
-ODH_Init("./GEO","/home/jthaeder/HLT/AnalysisChain/lib/Linux-i686/");
-//ODH_Init("./GEO","/home/jthaeder/HLT/src/lib_jthaeder/");
-
-//ODH_Connect("e107",42002,NULL,NULL,"e107",42003); // pprun_1_nB
-//ODH_Connect(NULL,NULL,NULL,NULL,"e107",42003);
-
-
-ODH_Connect(NULL,NULL,"eh000",42002,NULL,NULL); // -- HUGE_TEST with RAW
-//ODH_DisplayNextEvent(false,false,true,NULL);
-
-bar = new TControlBar("vertical", "HLT DISPLAY");
-
-bar->AddButton("Next clusters",".p ODH_DisplayNextEvent(true,false,false,NULL)", "Show Next Event");
-bar->AddButton("Next tracks",".p ODH_DisplayNextEvent(false,true,false,NULL)", "Show Next Event");
-bar->AddButton("Next clusters and tracks",".p ODH_DisplayNextEvent(true,true,false,NULL)", "Show Next Event");
-
-bar->AddSeparator();
-
-bar->AddButton("Show all",".p ODH_SetSliceRange()", "Show Next Event");
-
-bar->AddButton("Show Sector 0",".p ODH_SetSliceRange(0)", "Show Next Event");
-bar->AddButton("Show Sector 1",".p ODH_SetSliceRange(1)", "Show Next Event");
-bar->AddButton("Show Sector 2",".p ODH_SetSliceRange(2)", "Show Next Event");
-bar->AddButton("Show Sector 9",".p ODH_SetSliceRange(9)", "Show Next Event");
-bar->AddButton("Show Sector 10",".p ODH_SetSliceRange(10)", "Show Next Event");
-bar->AddButton("Show Sector 11",".p ODH_SetSliceRange(11)", "Show Next Event");
-
-bar->AddButton("Show Sector 0 - 2",".p ODH_SetSliceRange(0,2)", "Show Next Event");
-bar->AddButton("Show Sector 9 - 11",".p ODH_SetSliceRange(9,11)", "Show Next Event");
-bar->AddButton("Show Sector 0 - 11",".p ODH_SetSliceRange(0,11)", "Show Next Event");
-
-bar->AddButton("Show pair 0",".p ODH_SetSlicePair(0)", "Show Next Event");
-bar->AddButton("Show pair 1",".p ODH_SetSlicePair(1)", "Show Next Event");
-bar->AddButton("Show pair 2",".p ODH_SetSlicePair(2)", "Show Next Event");
-
-bar->AddButton("Show Geometry",".p ODH_SetDrawGeo()", "Show Next Event");
-
-bar->AddButton("Invert",".p ODH_SetInvert()","ccc");
-
-bar->AddSeparator();
-// PADROW 0 - 158
-
-bar->AddButton("Setup PadRow 20 with Histogram",".p ODH_SetupPadRow(1,2,20)","Setup PadRow");
-bar->AddButton("Setup PadRow 20 with Geometry",".p ODH_SetupPadRow(0,2,20)","Setup PadRow");
-
-bar->AddButton("Display PadRow",".p ODH_DisplayNextEvent(false,false,true,NULL)","Display PadRow");
-
-bar->AddButton("Display PadRow with Clusters",".p ODH_DisplayNextEvent(true,false,true,NULL)","Display PadRow");
-bar->AddButton("Display PadRow with Tracks",".p ODH_DisplayNextEvent(false,true,true,NULL)","Display PadRow");
-bar->AddButton("Display PadRow with Clusters and Tracks",".p ODH_DisplayNextEvent(true,true,true,NULL)","Display PadRow");
-
+ gROOT->LoadMacro("HLT-OnlineDisplay-HOMER.C");
+
+ // --- LOAD DISPLAY FUNCTIONS
+ HLT_OnlineDisplay_HOMER();
+
+ // --- INITIALIZE DISPLAY, LOAD GEOMETRY FILE, LOAD LIBRARIES (HOMER,HLT,..)
+ ODH_Init();
+
+ // --- CONNECT TO TCP DUMP SUBSCRIBERS
+ ODH_Connect("e300",42002,NULL,NULL,"e300",42001);
+
+ // --- Next Event
+ ODH_DisplayEvent();
+
+ barCl = new TControlBar("vertical", "HLT DISPLAY - Cluster");
+ barCl->AddButton("All Cluster",".p ODH_SetCluster(true,true)", "All Cluster");
+ barCl->AddButton("Used Cluster",".p ODH_SetCluster(true,false)", "Used Cluster");
+ barCl->AddButton("Unused Cluster",".p ODH_SetCluster(false,true)", "Unused Cluster");
+ barCl->Show();
+
+ bar = new TControlBar("vertical", "HLT DISPLAY");
+ bar->AddButton("Next Event",".p ODH_DisplayEvent()", "Next Event");
+ bar->AddSeparator();
+ bar->AddButton("Show all slices",".p ODH_SetSliceRange()", "Show all slices");
+ bar->AddSeparator();
+ bar->AddButton("Keep 3D View",".p ODH_SetKeepView(true)", "Keep 3D View");
+ bar->AddButton("!Keep 3D View",".p ODH_SetKeepView(false)", "Keep 3D View");
+ bar->AddButton("Invert 3D View",".p ODH_SetInvert()","Invert 3D View");
+ bar->AddSeparator();
+ bar->AddButton("Show 3D Tracks",".p ODH_Set3DTracks(true)","Show 3D Tracks");
+ bar->AddButton("!Show 3D Tracks",".p ODH_Set3DTracks()","!Show 3D Tracks");
+ bar->AddButton("Show 3D Cluster",".p ODH_Set3DCluster(true)","Show 3D Cluster");
+ bar->AddButton("!Show 3D Cluster",".p ODH_Set3DCluster()","!Show 3D Cluster");
+ bar->AddButton("Show 3D PadRow",".p ODH_Set3DPadRow(true)","Show 3D PadRow");
+ bar->AddButton("!Show 3D PadRow",".p ODH_Set3DPadRow()","!Show 3D PadRow");
+ bar->AddButton("Show 3D Geometry",".p ODH_Set3DGeometry(true)","Show 3D Geometry");
+ bar->AddButton("!Show 3D Geometry",".p ODH_Set3DGeometry()","!Show 3D Geometry");
+ bar->AddSeparator();
+ bar->AddButton("Show Sector 0",".p ODH_SetSliceRange(0)", "Show Next Event");
+ bar->AddButton("Show Sector 9",".p ODH_SetSliceRange(9)", "Show Next Event");
+ bar->AddButton("Show Sector 18",".p ODH_SetSliceRange(18)", "Show Next Event");
+ bar->AddButton("Show Sector 27",".p ODH_SetSliceRange(27)", "Show Next Event");
+ bar->AddButton("Show Sector 0 - 2",".p ODH_SetSliceRange(0,2)", "Show Next Event");
+ bar->AddButton("Show Sector 0 - 9",".p ODH_SetSliceRange(0,9)", "Show Next Event");
+ bar->AddButton("Show pair 0",".p ODH_SetSlicePair(0)", "Show Next Event");
+ bar->AddButton("Show pair 0 - 2",".p ODH_SetSlicePair(0,2)", "Show Next Event");
+
+ bar->AddSeparator();
+
+bar->AddButton("Close","gROOT.Reset(\"a\")", "Close");
bar->Show();
gROOT->SaveContext();
}
gROOT->GetInterpreter()->AddIncludePath( "$ALIHLT_TOPDIR/src" );
gROOT->Macro("StartDisplayMacro.C");
-//gROOT->Macro("./StartSimpleDisplayMacro.C");
-
}
void AliHLTTPCConfMapTrack::Fill(AliHLTTPCVertex *vertex,Double_t max_Dca)
{
//Fill track variables with or without fit.
-
+ LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapTrack::Fill","TEST")<< "=========="<< ENDLOG;
//fRadius = sqrt(a2Xy*a2Xy+1)/(2*fabs(a1Xy));
Double_t radius = sqrt(a2Xy*a2Xy+1)/(2*fabs(a1Xy));
+ LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapTrack::Fill","TEST")<< "====A====== r=" << GetRadius() << ENDLOG;
SetRadius(radius);
+ LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapTrack::Fill","TEST")<< "====B====== r=" << GetRadius() << ENDLOG;
//fPt = (Double_t)(BFACT * AliHLTTPCTransform::GetBField() * fRadius);
Double_t pt = (Double_t)(BFACT * AliHLTTPCTransform::GetBField() * GetRadius());
}
//Set the angles to sector 2:
+#if 0
+ fPhiMin = -1.*90/todeg;//fParam->GetAngle(sector) - 10/todeg;
+ fPhiMax = 90./todeg;//fParam->GetAngle(sector) + 10/todeg;
+#else
fPhiMin = -1.*10/todeg;//fParam->GetAngle(sector) - 10/todeg;
- fPhiMax = 10/todeg;//fParam->GetAngle(sector) + 10/todeg;
+ fPhiMax = 10./todeg;//fParam->GetAngle(sector) + 10/todeg;
+#endif
nTracks=0;
fMainVertexTracks = 0;
{
//Check if there are not enough clusters to make a track in this sector
//Can happen in pp events.
-
+// LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper:SetPointers","Tracking")<< "==================== UNUSED CLUSTERS="<< fClustersUnused <<ENDLOG;
if(fClustersUnused < fMinPoints[fVertexConstraint])
return;
-
+
+// LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::SetPointers","Tracking")<< "--------> fMaxPhi=" << fMaxPhi << " fMaxEta="<< fMaxEta << ENDLOG;
+
//Reset detector volumes
memset(fVolume,0,fBounds*sizeof(AliHLTTPCConfMapContainer));
memset(fRow,0,fNumRowSegmentPlusOne*sizeof(AliHLTTPCConfMapContainer));
Float_t phiSlice = (fPhiMax-fPhiMin)/fNumPhiSegment;
Float_t etaSlice = (fEtaMax-fEtaMin)/fNumEtaSegment;
+// LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::SetPointers","Parameters") << "min=" << fEtaMin <<" max=" << fEtaMax <<" fNumEtaSegment=" <<fNumEtaSegment << ENDLOG;
+ //LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::SetPointers","Parameters") << "min=" << fPhiMin <<" max=" << fPhiMax <<" fNumEtaSegment=" <<fNumPhiSegment << ENDLOG;
Int_t volumeIndex;
Int_t local_counter=0;
for(Int_t j=0; j<fClustersUnused; j++)
if(thisHit->phiIndex<1 || thisHit->phiIndex>fNumPhiSegment)
{
- //cout << "Phiindex: " << thisHit->phiIndex << " " << thisHit->GetPhi() << endl;
+ //cout << j<< "||Phiindex: " << thisHit->phiIndex << " | " << thisHit->GetPhi() << " PHIMIN=" << fPhiMin << endl;
fPhiHitsOutOfRange++;
continue;
}
-
+
thisHit->etaIndex=(Int_t)((thisHit->GetEta()-fEtaMin)/etaSlice + 1);
if(thisHit->etaIndex<1 || thisHit->etaIndex>fNumEtaSegment)
{
- //cout << "Etaindex: " << thisHit->etaIndex << " " << thisHit->GetEta() << endl;
+ if (thisHit->etaIndex<1) LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::SetPointers","Parameters") << " ----1-----" << ENDLOG;
+ if (thisHit->etaIndex>fNumEtaSegment) {
+// LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::SetPointers","Parameters") << "INDEX=" << thisHit->etaIndex << " fNumEtaSegment=" <<fNumEtaSegment << ENDLOG;
+ // cout << j<< "||Etaindex: " << thisHit->etaIndex << " | " << thisHit->GetEta() << " ETAMIN=" << fEtaMin << endl;
+ }
fEtaHitsOutOfRange++;
continue;
}
((AliHLTTPCConfMapPoint *)fVolume[volumeIndex].last)->nextVolumeHit=thisHit;
fVolume[volumeIndex].last = (void *)thisHit;
-
//set row pointers
if(fRow[(localrow-fRowMin)].first == NULL)
fRow[(localrow-fRowMin)].first = (void *)thisHit;
return;
}
+// LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::MainVertexTracking","Tracking")<< "USE MAINVERTEX TRACKING - ENTER A"<<ENDLOG;
Double_t initCpuTime,cpuTime;
initCpuTime = CpuTime();
- SetPointers();
+// SetPointers();
SetVertexConstraint(true);
cpuTime = CpuTime() - initCpuTime;
if(fBench)
LOG(AliHLTTPCLog::kInformational,"AliHLTTPCConfMapper::MainVertexTracking_a","Timing")
<<AliHLTTPCLog::kDec<<"Setup finished in "<<cpuTime*1000<<" ms"<<ENDLOG;
-
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::MainVertexTracking","Tracking")<< "USE MAINVERTEX TRACKING - LEAVE A"<<ENDLOG;
}
void AliHLTTPCConfMapper::MainVertexTracking_b()
{
//Tracking with vertex constraint.
-
+//LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::MainVertexTracking","Tracking")<< "USE MAINVERTEX TRACKING - ENTER B"<<ENDLOG;
if(!fParamSet[(Int_t)kTRUE])
{
LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::MainVertexTracking","Parameters")<<AliHLTTPCLog::kDec<<
if(fBench)
LOG(AliHLTTPCLog::kInformational,"AliHLTTPCConfMapper::MainVertexTracking_b","Timing")
<<AliHLTTPCLog::kDec<<"Main Tracking finished in "<<cpuTime*1000<<" ms"<<ENDLOG;
+// LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::MainVertexTracking","Tracking")<< "USE MAINVERTEX TRACKING - LEAVE B"<<ENDLOG;
}
void AliHLTTPCConfMapper::MainVertexTracking()
{
//Tracking with vertex constraint.
-
+//LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::MainVertexTracking","Tracking")<< "USE MAINVERTEX TRACKING - ENTER"<<ENDLOG;
if(!fParamSet[(Int_t)kTRUE])
{
LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::MainVertexTracking","Parameters")<<AliHLTTPCLog::kDec<<
Double_t initCpuTime,cpuTime;
initCpuTime = CpuTime();
- SetPointers();
+// SetPointers();
SetVertexConstraint(true);
ClusterLoop();
if(fBench)
LOG(AliHLTTPCLog::kInformational,"AliHLTTPCConfMapper::MainVertexTracking","Timing")<<AliHLTTPCLog::kDec<<
"Tracking finished in "<<cpuTime*1000<<" ms"<<ENDLOG;
-
+// LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::MainVertexTracking","Tracking")<< "USE MAINVERTEX TRACKING - LEAVE"<<ENDLOG;
return;
}
//in order to do tracking on the remaining clusters.
//The conformal mapping is now done with respect to the first cluster
//assosciated with this track.
-
+// LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::NonVertexTracking","Tracking")<< "USE NONVERTEX TRACKING - ENTER"<<ENDLOG;
if(!fParamSet[(Int_t)kFALSE])
{
LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::NonVertexTracking","Parameters")<<AliHLTTPCLog::kDec<<
ClusterLoop();
LOG(AliHLTTPCLog::kInformational,"AliHLTTPCConfMapper::NonVertexTracking","ntracks")<<AliHLTTPCLog::kDec<<
"Number of nonvertex tracks found: "<<(nTracks-fMainVertexTracks)<<ENDLOG;
+
+// LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::NonVertexTracking","Tracking")<< "USE NONVERTEX TRACKING - LEAVE"<<ENDLOG;
return;
}
SetTrackletLength(trackletlength,(Bool_t)false);
SetRowScopeTracklet(rowscopetracklet, (Bool_t)false);
SetRowScopeTrack(rowscopetrack, (Bool_t)false);
- SetMinPoints(tracklength,(Bool_t)false);
+ SetMinPoints(tracklength,(Bool_t)false);
SetParamDone(kFALSE);
}
}
void AliHLTTPCConfMapper::ClusterLoop()
-{
+{
+// LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::Clusterloop","Tracking")<< "USE CLUSTERLOOP NVT - ENTER"<<ENDLOG;
//Loop over hits, starting at outermost padrow, and trying to build segments.
//Check if there are not enough clusters to make a track in this sector
//Can happen in pp events.
if(fClustersUnused < fMinPoints[fVertexConstraint])
return;
-
+// LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::Clusterloop","Tracking")<< "USE CLUSTERLOOP NVT - 0"<<ENDLOG;
Int_t row_segm,lastrow = fRowMin + fMinPoints[fVertexConstraint];
AliHLTTPCConfMapPoint *hit;
//Loop over rows, and try to create tracks from the hits.
//Starts at the outermost row, and loops as long as a track can be build, due to length.
-
+// LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::Clusterloop","Tracking")<< "USE CLUSTERLOOP: row_sgm="<< row_segm << " fRowMax="<< fRowMax << "lastrow="
+// << lastrow << ENDLOG;
for(row_segm = fRowMax; row_segm >= lastrow; row_segm--)
{
- if(fRow[(row_segm-fRowMin)].first && ((AliHLTTPCConfMapPoint*)fRow[(row_segm-fRowMin)].first)->GetPadRow() < fRowMin + 1)
- break;
-
- for(hit = (AliHLTTPCConfMapPoint*)fRow[(row_segm-fRowMin)].first; hit!=0; hit=hit->nextRowHit)
- {
- if(hit->GetUsage() == true)
+ if(fRow[(row_segm-fRowMin)].first && ((AliHLTTPCConfMapPoint*)fRow[(row_segm-fRowMin)].first)->GetPadRow() < fRowMin + 1){
+ break;
+ }
+// LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::Clusterloop","Tracking")<< "USE CLUSTERLOOP NVT - xxx= "<< fRow[(row_segm-fRowMin)].first << ENDLOG;
+
+ for(hit = (AliHLTTPCConfMapPoint*)fRow[(row_segm-fRowMin)].first; hit!=0; hit=hit->nextRowHit)
+ {
+// LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::Clusterloop","Tracking")<< "USE CLUSTERLOOP NVT - www" << ENDLOG;
+ if(hit->GetUsage() == true){
+// LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::Clusterloop","Tracking")<< "USE CLUSTERLOOP NVT - 2"<<ENDLOG;
continue;
- else
- CreateTrack(hit);
+ }
+ else {
+ //LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::Clusterloop","Tracking")<< "=================== CALL CREATE TRACK : HITNUMMER:"<< hit->GetHitNumber() << ENDLOG;
+ CreateTrack(hit);
+ }
}
}
-
+// LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::Clusterloop","Tracking")<< "USE CLUSTERLOOP NVT - LEAVE"<<ENDLOG;
return;
}
//set conformal coordinates if we are looking for non vertex tracks
if(!fVertexConstraint)
{
+ //LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::Create Track","Tracking")<< "====== 1 =====" << ENDLOG;
hit->SetAllCoord(hit);
}
-
+
//fill fit parameters of initial track:
track->UpdateParam(hit); //here the number of hits is incremented.
trackhitnumber[track->GetNumberOfPoints()-1] = hit->GetHitNumber();
Double_t dx,dy;
//create tracklets:
-
+ //LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::CreateTrack","Tracking")<< "=========== OK 0 === " << ENDLOG;
for(point=1; point<fTrackletLength[fVertexConstraint]; point++)
{
if((closest_hit = GetNextNeighbor(hit)))
{//closest hit exist
-
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::CreateTrack","Tracking")<< "=========== OK 0 01 === " << ENDLOG;
// Calculate track length in sz plane
dx = ((AliHLTTPCConfMapPoint*)closest_hit)->GetX() - ((AliHLTTPCConfMapPoint*)hit)->GetX();
dy = ((AliHLTTPCConfMapPoint*)closest_hit)->GetY() - ((AliHLTTPCConfMapPoint*)hit)->GetY();
}
else
{
+ //LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::CreateTrack","Tracking")<< "=========== OK 0 02 === " << ENDLOG;
//closest hit does not exist:
track->DeleteCandidate();
fTrack->RemoveLast();
point = fTrackletLength[fVertexConstraint];
}
}
-
+ //LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::CreateTrack","Tracking")<< "=========== OK 1 === " << ENDLOG;
//tracklet is long enough to be extended to a track
if(track->GetNumberOfPoints() == fTrackletLength[fVertexConstraint])
{
-
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::CreateTrack","Tracking")<< "=========== OK 100 === " << ENDLOG;
track->SetProperties(true);
if(TrackletAngle(track) > fMaxAngleTracklet[fVertexConstraint])
track->fChiSq[0] = xyChi2;
track->fChiSq[1] = szChi2;
Double_t normalized_chi2 = (track->fChiSq[0]+track->fChiSq[1])/track->GetNumberOfPoints();
-
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::CreateTrack","Tracking")<< "=========== OK 2 === " << ENDLOG;
//remove tracks with not enough points already now
if(track->GetNumberOfPoints() < fMinPoints[fVertexConstraint] || normalized_chi2 > fTrackChi2Cut[fVertexConstraint])
- {
+ {
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::CreateTrack","Tracking")<< "=#=#=#=#=#=#=#=#=#=#= BAD =#=#= " << ENDLOG;
track->SetProperties(false);
nTracks--;
track->DeleteCandidate();
}
else
- {
+ {
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::CreateTrack","Tracking")<< "=========== OK === " << ENDLOG;
fClustersUnused -= track->GetNumberOfPoints();
track->ComesFromMainVertex(fVertexConstraint);
//mark track as main vertex track or not
}//good tracklet
}
-
+ // if (nTracks > 0) LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::CreateTrack","Tracking")<< "########### number of tracks:"<< nTracks << ENDLOG;
return;
}
{
//When forming segments: Finds closest hit to input hit
//When forming tracks: Find closest hit to track fit.
-
+ //LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 0 #####" << ENDLOG;
Double_t dist,closest_dist = fMaxDist[fVertexConstraint];
AliHLTTPCConfMapPoint *hit = NULL;
min_row = fRowMin;
if(max_row < fRowMin)
return 0; //reached the last padrow under consideration
-
+
else
- {
+ {// LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 00xxxxxxxxxxxxx1 #####" << ENDLOG;
//loop over sub rows
for(sub_row_segm=max_row; sub_row_segm>=min_row; sub_row_segm--)
{
+//LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 00xxxxxxxxxxxxx2 #####" << ENDLOG;
//loop over subsegments, in the order defined above.
for(Int_t i=0; i<9; i++)
{
+//LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 00xxxxxxxxxxxxx3 #####" << ENDLOG;
sub_phi_segm = start_hit->phiIndex + loop_phi[i];
-
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 00xxxxxxxxxxxxx4 #####" << ENDLOG;
if(sub_phi_segm < 0 || sub_phi_segm >= fNumPhiSegment)
continue;
/*
//loop over sub eta segments
sub_eta_segm = start_hit->etaIndex + loop_eta[i];
-
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 00xxxxxxxxxxxxx5 #####" << ENDLOG;
if(sub_eta_segm < 0 || sub_eta_segm >=fNumEtaSegment)
continue;//segment exceeds bounds->skip it
//loop over hits in this sub segment:
volumeIndex= (sub_row_segm-fRowMin)*fNumPhiEtaSegmentPlusOne +
sub_phi_segm*fNumEtaSegmentPlusOne + sub_eta_segm;
-
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 00xxxxxxxxxxxxx6 #####" << ENDLOG;
if(volumeIndex<0)
{//debugging
LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNextNeighbor","Memory")<<AliHLTTPCLog::kDec<<
"VolumeIndex error "<<volumeIndex<<ENDLOG;
}
-
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 00xxxxxxxxxxxxx6a #####" << ENDLOG;
for(hit = (AliHLTTPCConfMapPoint*)fVolume[volumeIndex].first;
hit!=0; hit = hit->nextVolumeHit)
{
-
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 00xxxxxxxxxxxxx7 #####" << ENDLOG;
if(!hit->GetUsage())
{//hit was not used before
-
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 00xxxxxxxxxxxxx8 #####" << ENDLOG;
//set conformal mapping if looking for nonvertex tracks:
if(!fVertexConstraint)
{
hit->SetAllCoord(start_hit);
}
-
+// LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 00xxxxxxxxxxxxx9 #####" << ENDLOG;
if(track)//track search - look for nearest neighbor to extrapolated track
{
- if(!VerifyRange(start_hit,hit))
- continue;
-
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 00xxxxxxxxxxxxx10 #####" << ENDLOG;
+// --JMT---------------------- MODIFY --------------------------------------------------------------------------
+ if (fVertexConstraint) {
+ if(!VerifyRange(start_hit,hit))
+ continue;
+ }
+
+#if 0
+ if(!VerifyRange(start_hit,hit))
+ continue;
+#endif
+// --JMT---------------------- MODIFY --------------------------------------------------------------------------
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 00xxxxxxxxxxxxx11 #####" << ENDLOG;
test_hit = EvaluateHit(start_hit,hit,track);
-
- if(test_hit == 0)//chi2 not good enough, keep looking
- continue;
- else if(test_hit==2)//chi2 good enough, return it
- return hit;
- else
+ //LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 00xxxxxxxxxxxxx12 #####" << ENDLOG;
+ if(test_hit == 0){//chi2 not good enough, keep looking
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 0x1x0 #####" << ENDLOG;
+ continue;
+ }
+ else if(test_hit==2){//chi2 good enough, return it
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 0x2x0 #####" << ENDLOG;
+ return hit;}
+ else{
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 0x3x0 #####" << ENDLOG;
closest_hit = hit;//chi2 acceptable, but keep looking
+ }
}//track search
else //tracklet search, look for nearest neighbor
{
-
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 00xxxxxxxxxxxxx-100 #####" << ENDLOG;
if((dist=CalcDistance(start_hit,hit)) < closest_dist)
- {
- if(!VerifyRange(start_hit,hit))
- continue;
+ {
+// --JMT---------------------- MODIFY --------------------------------------------------------------------------
+ if (fVertexConstraint) {
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 00xxxxxxxxxxxxx-101 #####" << ENDLOG;
+ if(!VerifyRange(start_hit,hit)){
+ //LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 00xxxxxxxxxxxxx-102 #####" << ENDLOG;
+ continue;
+ }
+ }
+#if 0
+ if(!VerifyRange(start_hit,hit))
+ continue;
+#endif
+// --JMT---------------------- MODIFY --------------------------------------------------------------------------
closest_dist = dist;
closest_hit = hit;
-
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 00xxxxxxxxxxxxx-103 #####" << ENDLOG;
//if this hit is good enough, return it:
- if(closest_dist < fGoodDist)
- return closest_hit;
+ if(closest_dist < fGoodDist){
+ //LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 00xxxxxxxxxxxxx-104 #####" << ENDLOG;
+ return closest_hit;
+ }
}
- else
- continue;//sub hit was farther away than a hit before
+ else {
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 00xxxxxxxxxxxxx-105 #####" << ENDLOG;
+ continue;//sub hit was farther away than a hit before
+ }
}//tracklet search
else continue; //sub hit was used before
- }//loop over hits in sub segment
+ }//loop over hits in sub segment ------------END 6A
}//loop over sub segments
}//else
//closest hit found:
+
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::GetNExtNeighbor","Tracking")<< "###### 0000 #####" << ENDLOG;
if(closest_hit)// && closest_dist < mMaxDist)
return closest_hit;
else
}
Bool_t AliHLTTPCConfMapper::VerifyRange(const AliHLTTPCConfMapPoint *hit1,const AliHLTTPCConfMapPoint *hit2) const
-{
+{
//Check if the hit are within reasonable range in phi and eta
Double_t dphi,deta;//maxphi=0.1,maxeta=0.1;
dphi = fabs(hit1->GetPhi() - hit2->GetPhi());
+// LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::VerifyRange","Tracking")<< "|||||||||||||||||||||||||< phi1=" << hit1->GetPhi() << " phi2="<< hit2->GetPhi()
+ // << " dphi=" << dphi << " maxphi=" << fMaxPhi << "twopi=" << twopi << ENDLOG;
+
if(dphi > pi) dphi = fabs(twopi - dphi);
+
+
if(dphi > fMaxPhi) return false;
deta = fabs(hit1->GetEta() - hit2->GetEta());
+
+ // LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::VerifyRange","Tracking")<< "|||||||||||||||||||||||||< eta1=" << hit1->GetEta() << " eta2="<< hit2->GetEta()
+ // << " deta=" << deta << " maxeta=" << fMaxEta << ENDLOG;
+
if(deta > fMaxEta) return false;
return true;
//which should be done in order to get nice tracks.
Int_t num_of_tracks = nTracks;
- LOG(AliHLTTPCLog::kInformational,"AliHLTTPCConfMapper::FillTracks","nTracks")<<AliHLTTPCLog::kDec<<
- "Number of found tracks: "<<nTracks<<ENDLOG;
+ LOG(AliHLTTPCLog::kInformational,"AliHLTTPCConfMapper::FillTracks","nTracks")<<AliHLTTPCLog::kDec<< " Number of found tracks: "<<nTracks<<ENDLOG;
if(nTracks == 0)
{
- LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::FillTracks","nTracks")<<AliHLTTPCLog::kDec<<
- "No tracks found!!"<<ENDLOG;
+ LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::FillTracks","nTracks")<<AliHLTTPCLog::kDec<<" No tracks found!!"<<ENDLOG;
return 0;
}
{
AliHLTTPCConfMapTrack *track = (AliHLTTPCConfMapTrack*)fTrack->GetTrack(i);
track->Fill(fVertex,fMaxDca);
-
+ LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapper::Filltracks","TEST")<< "====C====== r=" << track->GetRadius() << ENDLOG;
}
return 1;
void SetRowScopeTracklet(Int_t f, Bool_t vertex_constraint) { fRowScopeTracklet[(Int_t)vertex_constraint] = f; } // sets one row scope for tracklets
void SetMaxAngleTracklet(Double_t f, Bool_t vertex_constraint) { fMaxAngleTracklet[(Int_t)vertex_constraint] = f; } // sets one angle cut
- void SetPointers();
+
Double_t CpuTime();
void SetParamDone(Bool_t vertex_constraint) {fParamSet[(Int_t)vertex_constraint] = kTRUE;}
AliHLTTPCConfMapper();
// AliHLTTPCConfMapper(AliTPCParam *param,AliHLTTPCVertex *vertex,Bool_t bench=(Bool_t)false);
virtual ~AliHLTTPCConfMapper();
-
+ void SetPointers(); /////////// JMT -----------------
void InitVolumes();
void InitSector(Int_t sector,Int_t *rowrange=0,Float_t *etarange=0);
void SetVertex(AliHLTTPCVertex *vertex){fVertex = vertex;}
Int_t rowscopetracklet, Int_t rowscopetrack,Double_t maxphi=0.1,Double_t maxeta=0.1);
void NonVertexSettings(Int_t trackletlength, Int_t tracklength,
Int_t rowscopetracklet, Int_t rowscopetrack);
+
Bool_t ReadHits(UInt_t count, AliHLTTPCSpacePointData* hits );
void ClusterLoop();
void CreateTrack(AliHLTTPCConfMapPoint *hit);
fMultiplicity = 4000;
fBField = 0.4;
fDoPP = false;
+// --JMT---------------------- NEW ----------------------------
+ fnonvertextracking = kFALSE;
+ fmainvertextracking = kTRUE;
+// --JMT---------------------- NEW ----------------------------
}
AliHLTTPCSliceTrackerComponent::~AliHLTTPCSliceTrackerComponent()
fTracker->SetNSegments(phi_segments,eta_segments);
fTracker->SetMaxDca(min_pt_fit);
// fTracker->MainVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack);
+
+// --JMT---------------------- NEW ----------------------------
+#if 0
fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,vertexConstraints);
fTracker->SetTrackletCuts(maxangle,goodDist,vertexConstraints);
-
- if( vertexConstraints )
+#endif
+ Logging( kHLTLogError, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "==============================" );
+
+ if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){
+ fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kTRUE);
+ fTracker->SetTrackletCuts(maxangle,goodDist,kTRUE);
+
+ fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);
+ Logging( kHLTLogError, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING" );
+ }
+ else if ( fmainvertextracking == kTRUE && fnonvertextracking == kTRUE){
+ fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kTRUE);
+ fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kFALSE);
+ fTracker->SetTrackletCuts(maxangle,goodDist,kTRUE);
+ fTracker->SetTrackletCuts(maxangle,goodDist,kFALSE);
+
fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);
- else
+ fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
+ Logging( kHLTLogError, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING - NONVERTEXTRACKING" );
+ }
+ else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){
+ fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kFALSE);
+ fTracker->SetTrackletCuts(maxangle,goodDist,kFALSE);
+
fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
+ Logging( kHLTLogError, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "NONVERTEXTRACKING" );
+ }
+
+
+#if 0
+ if( vertexConstraints ) fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta);
+ else fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack);
+#endif
+// --JMT---------------------- NEW ----------------------------
//fTracker->SetParamDone(true);
//AliHLTTPC::SetVertexFit( kFALSE );
void AliHLTTPCSliceTrackerComponent::SetTrackerParam( bool doPP, int multiplicity, double bField )
{
+ AliHLTTPCTransform::SetBField( bField );
+ Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f\n", bField );
+ Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "B field is %f\n",AliHLTTPCTransform::GetBFieldValue());
+
if ( doPP )
{
//tracker->SetClusterFinderParam(xyerror,zerror,kTRUE); // ??
}
break;
}
- Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f\n", bfs[closestBf] );
- AliHLTTPCTransform::SetBField( bfs[closestBf] );
+// Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f\n", bfs[closestBf] );
+// AliHLTTPCTransform::SetBField( bfs[closestBf] );
}
}
fTracker = new AliHLTTPCConfMapper();
fVertex = new AliHLTTPCVertex();
fEta[0] = 0.;
- fEta[1] = 1.1;
+
+#if 0
+ fEta[1] = 10.1;
+#else
+ fEta[1] = 1.1;
+#endif
fDoNonVertex = false;
fMultiplicity = 4000;
fBField = 0.4;
fBField = strtod( argv[i+1], &cpErr );
if ( *cpErr )
{
- Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing multiplicity", "Cannot convert B-field specifier '%s'.", argv[i+1] );
+// --JMT---------------------- MODIFY ----------------------------
+ Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing B-field", "Cannot convert B-field specifier '%s'.", argv[i+1] );
+// --JMT---------------------- MODIFY ----------------------------
return EINVAL;
}
i += 2;
continue;
}
+// --JMT---------------------- NEW ----------------------------
+ if ( !strcmp( argv[i], "-nonvertextracking" ) ){
+ fnonvertextracking = kTRUE;
+ i++;
+ continue;
+ }
+
+ if ( !strcmp( argv[i], "-mainvertextrackingoff" ) ){
+ fmainvertextracking = kFALSE;
+ i++;
+ continue;
+ }
+// --JMT---------------------- NEW ----------------------------
+
Logging(kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
return EINVAL;
}
+
SetTrackerParam( fDoPP, fMultiplicity, fBField );
return 0;
}
}
outPtr = (AliHLTTPCTrackletData*)(outBPtr);
+
+// --JMT---------------------- NEW ----------------------------
+
+ fTracker->SetPointers();
+ if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){
+ Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---");
+ fTracker->MainVertexTracking_a();
+ fTracker->MainVertexTracking_b();
+ fTracker->FillTracks();
+ }
+ else if ( fmainvertextracking == kTRUE && fnonvertextracking == kTRUE){
+ Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---");
+ fTracker->MainVertexTracking_a();
+ fTracker->MainVertexTracking_b();
+ fTracker->FillTracks();
+ Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---");
+ fTracker->NonVertexTracking();
+ }
+ else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){
+ Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---");
+ fTracker->NonVertexTracking();
+ fTracker->FillTracks();
+ }
+
+#if 0
fTracker->MainVertexTracking_a();
fTracker->MainVertexTracking_b();
fTracker->FillTracks();
-
- if ( fDoNonVertex )
- fTracker->NonVertexTracking();//Do a second pass for nonvertex tracks
+ if (fDoNonVertex) fTracker->NonVertexTracking();//Do a second pass for nonvertex tracks
+#endif
+// --JMT---------------------- NEW ----------------------------
+
+
// XXX Do track merging??
int fMultiplicity;
double fBField;
+// --JMT---------------------- NEW ----------------------------
+ Bool_t fnonvertextracking; // enable NON vertex tracking
+ Bool_t fmainvertextracking; // enable MAIN vertex tracking
+// --JMT---------------------- NEW ----------------------------
+
ClassDef(AliHLTTPCSliceTrackerComponent, 0)
};
UChar_t fPadRow;
Float_t fSigmaY2; //error (former width) of the clusters
Float_t fSigmaZ2; //error (former width) of the clusters
- UInt_t fCharge;
- Bool_t fUsed;
+ UInt_t fCharge;
+ Bool_t fUsed; // only used in AliHLTTPCDisplay
+ Int_t fTrackN; // only used in AliHLTTPCDisplay
};
typedef struct AliHLTTPCSpacePointData AliHLTTPCSpacePointData;
}
void AliHLTTPCTrack::Set(AliHLTTPCTrack *tpt){
-
+ LOG(AliHLTTPCLog::kError,"AliHLTTPCTrack::Set","TEST")<< "=========== ENTER ======= " << ENDLOG;
SetRowRange(tpt->GetFirstRow(),tpt->GetLastRow());
SetPhi0(tpt->GetPhi0());
SetKappa(tpt->GetKappa());
}
Int_t AliHLTTPCTrack::Compare(const AliHLTTPCTrack *track) const
-{
+{
+ LOG(AliHLTTPCLog::kError,"AliHLTTPCTrack::Compare","TEST")<< "=========== ENTER ======= " << ENDLOG;
if(track->GetNHits() < GetNHits()) return 1;
if(track->GetNHits() > GetNHits()) return -1;
return 0;
//If flag tolocal is set, the track is rotated
//to local coordinates.
-
+ LOG(AliHLTTPCLog::kError,"AliHLTTPCTrack::Rotate","TEST")<< "=========== ENTER ======= " << ENDLOG;
Float_t psi[1] = {GetPsi()};
if(!tolocal)
AliHLTTPCTransform::Local2GlobalAngle(psi,slice);
}
void AliHLTTPCTrack::CalculateHelix(){
+ LOG(AliHLTTPCLog::kError,"AliHLTTPCTrack::claculateHelix","TEST")<< "=========== ENTER ======= " << ENDLOG;
+
//Calculate Radius, CenterX and CenterY from Psi, X0, Y0
//
//point. This is done by rotating the radius vector by 90 degrees;
//rotation matrix: ( 0 1 )
// ( -1 0 )
-
+ LOG(AliHLTTPCLog::kError,"AliHLTTPCTrack::getcrossingangle","TEST")<< "=========== ENTER ======= " << ENDLOG;
Float_t angle=0;//Angle perpendicular to the padrow in local coordinates
if(slice>=0)//Global coordinates
{
Bool_t AliHLTTPCTrack::GetCrossingPoint(Int_t padrow,Float_t *xyz)
{
//Assumes the track is given in local coordinates
-
+ LOG(AliHLTTPCLog::kError,"AliHLTTPCTrack::getcrossingpoint","TEST")<< "=========== ENTER ======= " << ENDLOG;
if(!IsLocal())
{
cerr<<"GetCrossingPoint: Track is given on global coordinates"<<endl;
Bool_t AliHLTTPCTrack::CalculateReferencePoint(Double_t angle,Double_t radius){
// Global coordinate: crossing point with y = ax+ b; a=tan(angle-AliHLTTPCTransform::Pi()/2);
- //
+ //
+LOG(AliHLTTPCLog::kError,"AliHLTTPCTrack::calculatereferencepoint","TEST")<< "=========== ENTER ======= " << ENDLOG;
const Double_t rr=radius;//132; //position of reference plane
const Double_t xr = cos(angle) * rr;
const Double_t yr = sin(angle) * rr;
Bool_t AliHLTTPCTrack::CalculateEdgePoint(Double_t angle){
// Global coordinate: crossing point with y = ax; a=tan(angle);
- //
+ //
+
+LOG(AliHLTTPCLog::kError,"AliHLTTPCTrack::calculateedgepoint","TEST")<< "=========== ENTER ======= " << ENDLOG;
Double_t rmin=AliHLTTPCTransform::Row2X(AliHLTTPCTransform::GetFirstRow(-1)); //min Radius of TPC
Double_t rmax=AliHLTTPCTransform::Row2X(AliHLTTPCTransform::GetLastRow(-1)); //max Radius of TPC
Bool_t AliHLTTPCTrack::CalculatePoint(Double_t xplane){
// Local coordinate: crossing point with x plane
//
+LOG(AliHLTTPCLog::kError,"AliHLTTPCTrack::calculatepoint","TEST")<< "=========== ENTER ======= " << ENDLOG;
Double_t racine = pow(fRadius,2)-pow(xplane-fCenterX,2);
if(racine<0) return IsPoint(kFALSE);
Double_t rootRacine = sqrt(racine);
void AliHLTTPCTrack::UpdateToFirstPoint()
{
+LOG(AliHLTTPCLog::kError,"AliHLTTPCTrack::updatetofirstpoint","TEST")<< "=========== ENTER ======= " << ENDLOG;
+
//Update track parameters to the innermost point on the track.
//Basically it justs calculates the intersection of the track, and a cylinder
//with radius = r(innermost point). Then the parameters are updated to this point.
Double_t tPsi = tPhi - GetCharge() * 0.5 * pi / abs(GetCharge()) ;
if ( tPsi > 2. * pi ) tPsi -= 2. * pi ;
if ( tPsi < 0. ) tPsi += 2. * pi ;
-
+
+ LOG(AliHLTTPCLog::kError,"AliHLTTPCTrack::updatetofirstpoint","TEST")<< "===1===" << "radius=" << radius << " fR0=" << fR0 << ENDLOG;
+
//And finally, update the track parameters
SetCenterX(xc);
SetCenterY(yc);
SetPhi0(phi);
SetFirstPoint(radius*cos(phi),radius*sin(phi),z);
SetPsi(tPsi);
+ LOG(AliHLTTPCLog::kError,"AliHLTTPCTrack::updatetofirstpoint","TEST")<< "===2===" << "radius=" << radius << " fR0=" << fR0 << ENDLOG;
}
void AliHLTTPCTrack::GetClosestPoint(AliHLTTPCVertex *vertex,Double_t &closest_x,Double_t &closest_y,Double_t &closest_z)
{
//Calculate the point of closest approach to the vertex
-
+ LOG(AliHLTTPCLog::kError,"AliHLTTPCTrack::getclosestpoint","TEST")<< "=========== ENTER ======= " << ENDLOG;
+
Double_t xc = GetCenterX() - vertex->GetX();//Shift the center of curvature with respect to the vertex
Double_t yc = GetCenterY() - vertex->GetY();
if(!track) continue; //use only present tracks
AliHLTTPCConfMapPoint *hit = (AliHLTTPCConfMapPoint*)track->lastHit;
AliHLTTPCConfMapPoint *lastHit = (AliHLTTPCConfMapPoint*)track->firstHit;
+/*
tP->fX = hit->GetX();
tP->fY = hit->GetY();
tP->fZ = hit->GetZ();
tP->fLastX = lastHit->GetX();
tP->fLastY = lastHit->GetY();
tP->fLastZ = lastHit->GetZ();
-
-// tP->fX = track->GetFirstPointX();
-// tP->fY = track->GetFirstPointY();
-// tP->fZ = track->GetFirstPointZ();
+*/
+ tP->fX = track->GetFirstPointX();
+ tP->fY = track->GetFirstPointY();
+ tP->fZ = track->GetFirstPointZ();
+
tP->fPt = track->GetPt();
-// tP->fLastX = track->GetLastPointX();
-// tP->fLastY = track->GetLastPointY();
-// tP->fLastZ = track->GetLastPointZ();
+
+ tP->fLastX = track->GetLastPointX();
+ tP->fLastY = track->GetLastPointY();
+ tP->fLastZ = track->GetLastPointZ();
+
tP->fPsi = track->GetPsi();
tP->fTgl = track->GetTgl();
tP->fCharge = track->GetCharge();
dnl framework and components
dnl
dnl ------------------------------------------------------------------
-AC_INIT([Alice High Level Trigger] , [0.1], [Matthias.Richter@ift.uib.no], alice-hlt)
+AC_INIT([Alice High Level Trigger] , [0.2], [Matthias.Richter@ift.uib.no], alice-hlt)
dnl ------------------------------------------------------------------
dnl the package from CVS contains the old Makefiles as well. In order to
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff