#include "AliHLTEveHLT.h"
#include "AliHLTHOMERBlockDesc.h"
#include "AliHLTEveBase.h"
-#include "AliEveHOMERManager.h"
+#include "AliEveHLTEventManager.h"
+#include "AliHLTGlobalTriggerDecision.h"
#include "TEveManager.h"
#include "TEvePointSet.h"
#include "TEveTrack.h"
+#include "TEveElement.h"
#include "TCanvas.h"
#include "AliESDEvent.h"
+#include "AliESDtrack.h"
#include "TEveTrackPropagator.h"
#include "AliEveTrack.h"
#include "TEveVSDStructs.h"
#include "TPCLib/tracking-ca/AliHLTTPCCATrackParam.h"
#include "TPCLib/tracking-ca/AliHLTTPCCATrackConvertor.h"
#include "AliEveMagField.h"
+#include "TH1.h"
#include "TH1F.h"
#include "TH2F.h"
+#include "TThread.h"
ClassImp(AliHLTEveHLT)
AliHLTEveHLT::AliHLTEveHLT() :
- AliHLTEveBase(),
+ AliHLTEveBase("TPC tracks"),
fTrueField(kFALSE),
fUseIpOnFailedITS(kFALSE),
fUseRkStepper(kFALSE),
fTrackList(NULL),
+ fTrackLists(NULL),
+ fOldTrackList(NULL),
+ fPointSetVertex(NULL),
fTrCanvas(NULL),
- fHistPt(NULL),
- fHistP(NULL),
+ fVertexCanvas(NULL),
fHistEta(NULL),
- fHistTheta(NULL),
fHistPhi(NULL),
fHistnClusters(NULL),
- fHistMult(NULL)
+ fHistMult(NULL),
+ fHistDCAr(NULL),
+ fTrCount(0),
+ fVCount(0),
+ fNTrackBins(10)
{
// Constructor.
CreateHistograms();
}
-
+///___________________________________________________________________
AliHLTEveHLT::~AliHLTEveHLT()
{
//Destructor, not implemented
if(fTrackList)
delete fTrackList;
fTrackList = NULL;
+
+ if(fTrackLists)
+ delete fTrackLists;
+ fTrackLists = NULL;
+
+
}
+
+///________________________________________________________________________
void AliHLTEveHLT::CreateHistograms(){
//See header file for documentation
- fHistPt = new TH1F("fHistPt", "transverse momentum", 100, 0, 10); // KK
- fHistP = new TH1F("fHistP", "signed momentum", 100,-7, 7);
+
+ //fHistPt = new TH1F("fHistPt", "transverse momentum", 100, 0, 10); // KK
+ //fHistP = new TH1F("fHistP", "signed momentum", 100,-7, 7);
+
+ //fHistPt ->SetXTitle("p_{t} (GeV/c)"); // KK
+ //fHistP ->SetXTitle("P*charge (GeV/c)");
+
+ // fHistTheta = new TH1F("fHistTheta", "polar angle", 180, 0,180);
+ // fHistTheta->SetXTitle("#theta (degrees)");
+
fHistEta = new TH1F("fHistEta", "pseudorapidity", 100,-2, 2);
- fHistTheta = new TH1F("fHistTheta", "polar angle", 180, 0,180);
+ fHistEta ->SetXTitle("#eta");
+
fHistPhi = new TH1F("fHistPhi", "azimuthal angle", 180, 0,360);
+ fHistPhi ->SetXTitle("#phi (degrees)");
+
fHistnClusters = new TH1F("fHistnClusters","TPC clusters per track", 160, 0,160);
- fHistMult = new TH1F("fHistMult", "event track multiplicity",50, 0, 50);
+
+ fHistMult = new TH1F("fHistMult", "event track multiplicity",150, 0, 15000);
- fHistPt ->SetXTitle("p_{t} (GeV/c)"); // KK
- fHistP ->SetXTitle("P*charge (GeV/c)");
- fHistEta ->SetXTitle("#eta");
- fHistTheta->SetXTitle("#theta (degrees)");
- fHistPhi ->SetXTitle("#phi (degrees)");
+ fHistDCAr = new TH1F("fHistDCAr", "DCA r", 200, -100, 100);
}
+
+///_____________________________________________________________________
void AliHLTEveHLT::ProcessBlock(AliHLTHOMERBlockDesc * block) {
//See header file for documentation
if ( ! block->GetDataType().CompareTo("ALIESDV0") ) {
- if(!fTrackList) CreateTrackList();
- ProcessEsdBlock(block, fTrackList);
+ ProcessEsdBlock(block);
}
else if ( ! block->GetDataType().CompareTo("ROOTTOBJ") ) {
}
else if ( ! block->GetDataType().CompareTo("HLTRDLST") ) {
+ cout << "ignoring hlt rdlst"<<endl;
//processHLTRDLST( block );
}
+ else if ( ! block->GetDataType().CompareTo("GLOBTRIG") ) {
+ ProcessGlobalTrigger( block );
+ }
+
else if ( !block->GetDataType().CompareTo("ROOTHIST") ) {
if( !fCanvas ) {
- fCanvas = CreateCanvas("Primary Vertex", "Primary Vertex");
- fCanvas->Divide(3, 2);
+ fCanvas = CreateCanvas("PVtx/Tr QA", "PrimV");
+ fCanvas->Divide(3, 3);
}
ProcessHistograms( block , fCanvas);
- }
-
+ }
}
-
+///____________________________________________________________________________
void AliHLTEveHLT::UpdateElements() {
//See header file for documentation
- if(fCanvas) fCanvas->Update();
+
DrawHistograms();
- if(fTrackList) fTrackList->ElementChanged();
+
+ if(fTrackLists) {
+ for(Int_t il = 0; il < fNTrackBins; il++) {
+ TEveTrackList * trackList = dynamic_cast<TEveTrackList*>(fTrackLists->FindChild(Form("Tracks_%d", il)));
+ if(trackList) trackList->ElementChanged();
+ }
+ }
+
+ if(fPointSetVertex) fPointSetVertex->ResetBBox();
+ if(fTrCanvas) fTrCanvas->Update();
+ if(fVertexCanvas) fVertexCanvas->Update();
+ if(fCanvas) fCanvas->Update();
+
}
+///_________________________________________________________________________________
void AliHLTEveHLT::ResetElements(){
- //See header file for documentation
- if(fTrackList) fTrackList->DestroyElements();
+ //See header file for documentation
+
+ cout << "destroy"<<endl;
+
+ if(fTrackLists) {
+ for(Int_t il = 0; il < fNTrackBins; il++) {
+ TEveTrackList * trackList = dynamic_cast<TEveTrackList*>(fTrackLists->FindChild(Form("Tracks_%d", il)));
+ if(trackList) trackList->DestroyElements();
+ }
+ }
+
+
+ fTrCount = 0;
+ fVCount = 0;
+
+ if(fPointSetVertex) fPointSetVertex->Reset();
+ cout<< "reset done"<<endl;
fHistoCount = 0;
}
+///_____________________________________________________________________________________
+void * AliHLTEveHLT::DestroyGarbage(void * arg) {
+ AliHLTEveHLT * hlt = reinterpret_cast<AliHLTEveHLT*>(arg);
+ if(hlt) hlt->DestroyOldTrackList();
+ return (void*)0;
+}
+///_____________________________________________________________________________________
+void AliHLTEveHLT::DestroyOldTrackList() {
+ cout << "Destroying the old tracklist's elements"<<endl;
+ fOldTrackList->DestroyElements();
+ cout << "Destroying the old tracklist itself"<<endl;
+ fOldTrackList->Destroy();
+}
+
+///_____________________________________________________________________________________
void AliHLTEveHLT::ProcessHistograms(AliHLTHOMERBlockDesc * block, TCanvas * canvas) {
//See header file for documentation
+ if (!fTrCanvas) {
+ fTrCanvas = CreateCanvas("ESD", "ESD");
+ fTrCanvas->Divide(4, 2);
+ }
+
+ if(!fVertexCanvas) {
+ fVertexCanvas = CreateCanvas("Vtx", "Vtx");
+ fVertexCanvas->Divide(4, 2);
+ }
+
+
+
if ( ! block->GetClassName().CompareTo("TH1F")) {
TH1F* histo = reinterpret_cast<TH1F*>(block->GetTObject());
if( histo ){
TString name(histo->GetName());
+ cout << "TH1F " <<name << endl;
if( !name.CompareTo("primVertexZ") ){
canvas->cd(2);
histo->Draw();
}else if( !name.CompareTo("primVertexY") ){
canvas->cd(4);
histo->Draw();
+ } else if ( name.Contains("Track")) {
+ AddHistogramToCanvas(histo, fTrCanvas, fTrCount);
+ } else {
+ AddHistogramToCanvas(histo, fVertexCanvas, fVCount);
}
}
} else if ( ! block->GetClassName().CompareTo("TH2F")) {
TH2F *hista = reinterpret_cast<TH2F*>(block->GetTObject());
if (hista ){
TString name(hista->GetName());
+ cout << "TH2F " << name << endl;
if( !name.CompareTo("primVertexXY")) {
canvas->cd(1);
hista->Draw();
- }
+ } else if ( name.Contains("Track")) {
+ AddHistogramToCanvas(hista, fTrCanvas, fTrCount);
+ } else {
+ AddHistogramToCanvas(hista, fVertexCanvas, fVCount);
+ }
}
}
canvas->cd();
+}
+
+///_____________________________________________________________________________________
+void AliHLTEveHLT::AddHistogramToCanvas(TH1* histogram, TCanvas * canvas, Int_t &cdCount) {
+ canvas->cd(++cdCount);
+ histogram->Draw();
+}
+///________________________________________________________________________________________
+void AliHLTEveHLT::CreateTrackList() {
+ //See header file for documentation
+ fTrackList = new TEveTrackList("ESD Tracks");
+ fTrackList->SetMainColor(kOrange);
+ AddElement(fTrackList);
+}
+///________________________________________________________________________________________
+void AliHLTEveHLT::CreateTrackLists() {
+ //See header file for documentation
+ fTrackLists = new TEveElementList("ESD Track lists");
+ AddElement(fTrackLists);
+ for(Int_t i = 0; i < 10; i++) {
+ TEveTrackList * trackList = new TEveTrackList(Form("Tracks_%d", i));
+ trackList->SetMainColor(kOrange-i);
+ fTrackLists->AddElement(trackList);
+ }
+}
+
+///_________________________________________________________________________________________
+void AliHLTEveHLT::CreateVertexPointSet() {
+ //See header file for documentation
+ fPointSetVertex = new TEvePointSet("Primary Vertex");
+ fPointSetVertex->SetMainColor(6);
+ fPointSetVertex->SetMarkerStyle((Style_t)kFullStar);
+
+ AddElement(fPointSetVertex);
}
-void AliHLTEveHLT::CreateTrackList() {
+///________________________________________________________________________
+void AliHLTEveHLT::ProcessGlobalTrigger( AliHLTHOMERBlockDesc * block ) {
//See header file for documentation
- fTrackList = new TEveTrackList("ESD Tracks");
- fTrackList->SetMainColor(6);
- gEve->AddElement(fTrackList);
+ AliHLTGlobalTriggerDecision * decision = dynamic_cast<AliHLTGlobalTriggerDecision*>(block->GetTObject());
+ if(decision) decision->Print();
+
}
-void AliHLTEveHLT::ProcessEsdBlock( AliHLTHOMERBlockDesc * block, TEveTrackList * cont ) {
+///______________________________________________________________________
+void AliHLTEveHLT::ProcessEsdBlock( AliHLTHOMERBlockDesc * block) {
//See header file for documentation
AliESDEvent* esd = (AliESDEvent *) (block->GetTObject());
- esd->GetStdContent();
+ if (!esd) return;
- SetUpTrackPropagator(cont->GetPropagator(),-0.1*esd->GetMagneticField(), 520);
+ ProcessEsdEvent(esd);
+}
- for (Int_t iter = 0; iter < esd->GetNumberOfTracks(); ++iter) {
- AliEveTrack* track = dynamic_cast<AliEveTrack*>(MakeEsdTrack(esd->GetTrack(iter), cont));
- cont->AddElement(track);
+
+
+///_________________________________________________________________________________
+Color_t AliHLTEveHLT::GetColor(Float_t pt) {
+ //See header file
+ Color_t baseColor = kOrange;
+
+ Float_t binlimit = 0.1;
+ for(Int_t i = 0; i< 10; i++) {
- fHistPt->Fill(esd->GetTrack(iter)->Pt()); // KK
- fHistP->Fill(esd->GetTrack(iter)->P()*esd->GetTrack(iter)->Charge());
- fHistEta->Fill(esd->GetTrack(iter)->Eta());
- fHistTheta->Fill(esd->GetTrack(iter)->Theta()*TMath::RadToDeg());
- fHistPhi->Fill(esd->GetTrack(iter)->Phi()*TMath::RadToDeg());
- if(esd->GetTrack(iter)->GetStatus()&AliESDtrack::kTPCin || (esd->GetTrack(iter)->GetStatus()&AliESDtrack::kTPCin && esd->GetTrack(iter)->GetStatus()&AliESDtrack::kITSin)){
- fHistnClusters->Fill(esd->GetTrack(iter)->GetTPCNcls());
- }
+ if (pt < binlimit)
+ return baseColor - i;
+
+ binlimit +=0.1;
+ }
+
+ return baseColor - 9;
+
+}
+
+///_________________________________________________________________________________
+Int_t AliHLTEveHLT::GetColorBin(Float_t pt) {
+ //See header file
+
+ Float_t binlimit = 0.1;
+ for(Int_t i = 0; i< 10; i++) {
+
+ if (pt < binlimit)
+ return i;
+
+ binlimit +=0.1;
+ }
+
+ return 9;
+
+}
+
+///____________________________________________________________________
+void AliHLTEveHLT::ProcessEsdEvent( AliESDEvent * esd ) {
+ //See header file for documentation
+ if(!fPointSetVertex) CreateVertexPointSet();
+ if(!fTrackLists) CreateTrackLists();
+
+ cout << "ProcessESDEvent() :"<< esd->GetEventNumberInFile()<< " " << esd->GetNumberOfCaloClusters() << " tracks : " << esd->GetNumberOfTracks() << endl;
+
+ //fEventManager->SetRunNumber(esd->GetRunNumber());
+
+ Double_t vertex[3];
+ const AliESDVertex * esdVertex = esd->GetPrimaryVertex();
+
+ if(esdVertex) {
+ esdVertex->GetXYZ(vertex);
+ fPointSetVertex->SetNextPoint(vertex[0], vertex[1], vertex[2]);
}
+ TEveTrackList * trackList = dynamic_cast<TEveTrackList*>(fTrackLists->FirstChild());
+ if(trackList) SetUpTrackPropagator(trackList->GetPropagator(),-0.1*esd->GetMagneticField(), 520);
+ for (Int_t iter = 0; iter < esd->GetNumberOfTracks(); ++iter) {
+
+ AliESDtrack * esdTrack = dynamic_cast<AliESDtrack*>(esd->GetTrack(iter));
+ FillTrackList(esdTrack);
+ FillHistograms(esdTrack);
+
+ }
fHistMult->Fill(esd->GetNumberOfTracks()); // KK
+ //BALLE hardcoded size
+ for(Int_t il = 0; il < fNTrackBins; il++) {
+ trackList = dynamic_cast<TEveTrackList*>(fTrackLists->FindChild(Form("Tracks_%d", il)));
+ trackList->MakeTracks();
+ }
+}
+///__________________________________________________________________________
+void AliHLTEveHLT::FillTrackList(AliESDtrack * esdTrack) {
+ //See header file for documentation
+ TEveTrackList * trackList = dynamic_cast<TEveTrackList*>(fTrackLists->FirstChild());
+ if (!trackList) return;
- cont->SetTitle(Form("N=%d", esd->GetNumberOfTracks()) );
- cont->MakeTracks();
+ AliEveTrack* track = dynamic_cast<AliEveTrack*>(MakeEsdTrack(esdTrack, trackList));
+ Int_t bin = GetColorBin(esdTrack->Pt());
+ trackList = dynamic_cast<TEveTrackList*>(fTrackLists->FindChild(Form("Tracks_%d", bin)));
+ if(trackList) {
+ track->SetAttLineAttMarker(trackList);
+ trackList->AddElement(track);
+ } else cout << "BALLE"<<endl;
+
}
+///____________________________________________________________________________________
+void AliHLTEveHLT::FillHistograms(AliESDtrack * esdTrack) {
+
+ if(esdTrack->GetTPCNcls() == 0) return;
+
+ fHistEta->Fill(esdTrack->Eta());
+ // fHistTheta->Fill(esdTrack->Theta()*TMath::RadToDeg());
+ fHistPhi->Fill(esdTrack->Phi()*TMath::RadToDeg());
+
+
+ Float_t DCAr, DCAz = -99;
+ esdTrack->GetImpactParametersTPC(DCAr, DCAz);
+ fHistDCAr->Fill(DCAr);
+
+
+ if(esdTrack->GetStatus()&AliESDtrack::kTPCin || (esdTrack->GetStatus()&AliESDtrack::kTPCin && esdTrack->GetStatus()&AliESDtrack::kITSin)){
+ fHistnClusters->Fill(esdTrack->GetTPCNcls());
+ }
+}
+
void AliHLTEveHLT::DrawHistograms(){
//See header file for documentation
-
- if (!fTrCanvas) {
- fTrCanvas = CreateCanvas("TPC Tr QA", "TPC Track QA");
- fTrCanvas->Divide(4, 2);
+ if(!fCanvas) {
+ fCanvas = CreateCanvas("PVtx/Tr QA", "Primary vertex, Track QA");
+ fCanvas->Divide(3, 3);
}
- Int_t icd = 1;
- fTrCanvas->cd(icd++);
- fHistPt->Draw();
- fTrCanvas->cd(icd++);
- fHistP->Draw();
- fTrCanvas->cd(icd++);
+ fCanvas->cd(5);
fHistEta->Draw();
- fTrCanvas->cd(icd++);
- fHistTheta->Draw();
- fTrCanvas->cd(icd++);
+
+ fCanvas->cd(6);
fHistPhi->Draw();
- fTrCanvas->cd(icd++);
+
+ fCanvas->cd(7);
fHistnClusters->Draw();
- fTrCanvas->cd(icd++);
+
+ fCanvas->cd(8);
fHistMult->Draw();
- fTrCanvas->cd();
- fTrCanvas->Update();
+ fCanvas->cd(9);
+ fHistDCAr->Draw();
+
+ fCanvas->cd();
}
AliEveTrack* AliHLTEveHLT::MakeEsdTrack (AliESDtrack *at, TEveTrackList* cont) {
//See header file for documentation
+
+
+
const double kCLight = 0.000299792458;
trackParam = *at->GetConstrainedParam();
}
else if( at->GetInnerParam() ){
- trackParam = *(at->GetInnerParam());
+ float x = at->GetX();
+ float y = at->GetY();
+ if(sqrt(x*x+y*y)>.5 ) trackParam = *(at->GetInnerParam());
}
if( at->GetStatus()&AliESDtrack::kTRDin ){
// transport to TRD in
}
AliEveTrack* track = new AliEveTrack(&rt, cont->GetPropagator());
- track->SetAttLineAttMarker(cont);
track->SetName(Form("AliEveTrack %d", at->GetID()));
track->SetElementTitle(CreateTrackTitle(at));
track->SetSourceObject(at);
track->AddPathMark( startPoint );
}
+ bool ok = 1;
+ if( at->GetOuterParam() && at->GetTPCPoints(2)>80 ){
- if( at->GetTPCPoints(2)>80 ){
-
//
// use AliHLTTPCCATrackParam propagator
// since AliExternalTrackParam:PropagateTo()
// has an offset at big distances
//
-
+ double rot = at->GetOuterParam()->GetAlpha() - trackParam.GetAlpha();
+ double crot = cos(rot), srot = sin(rot);
+ double xEnd = at->GetTPCPoints(2)*crot - at->GetTPCPoints(3)*srot;
+ // take parameters constrained to vertex (if they are)
+
+
AliHLTTPCCATrackParam t;
AliHLTTPCCATrackConvertor::SetExtParam( t, trackParam );
Double_t x0 = trackParam.GetX();
- Double_t dx = at->GetTPCPoints(2) - x0;
+ Double_t dx = xEnd - x0;
+ if( dx<0 ) ok = 0;
//
// set a reference at the half of trajectory for better drawing
//
- for( double dxx=dx/2; TMath::Abs(dxx)>=1.; dxx*=.9 ){
- if( !t.TransportToX(x0+dxx, bz, .99 ) ) continue;
- AliHLTTPCCATrackConvertor::GetExtParam( t, trackParam, trackParam.GetAlpha() );
- trackParam.GetXYZ(vbuf);
- trackParam.GetPxPyPz(pbuf);
- TEvePathMark midPoint(TEvePathMark::kReference);
- midPoint.fV.Set(vbuf);
- midPoint.fP.Set(pbuf);
- track->AddPathMark( midPoint );
- break;
+ if( ok ){
+ double dxx=dx/2;
+ if( TMath::Abs(dxx)>=1. ){
+
+ if( !t.TransportToX(x0+dxx, bz, .999 ) ){
+ ok = 0;
+ } else {
+ AliExternalTrackParam tt;
+ AliHLTTPCCATrackConvertor::GetExtParam( t, tt, trackParam.GetAlpha() );
+ tt.GetXYZ(vbuf);
+ tt.GetPxPyPz(pbuf);
+ TEvePathMark midPoint(TEvePathMark::kReference);
+ midPoint.fV.Set(vbuf);
+ midPoint.fP.Set(pbuf);
+ track->AddPathMark( midPoint );
+ }
+ }
}
-
+
//
// Set a reference at the end of the trajectory
// and a "decay point", to let the event display know where the track ends
//
- for( ; TMath::Abs(dx)>=1.; dx*=.9 ){
- if( !t.TransportToX(x0+dx, bz, .99 ) ) continue;
- AliHLTTPCCATrackConvertor::GetExtParam( t, trackParam, trackParam.GetAlpha() );
- trackParam.GetXYZ(vbuf);
- trackParam.GetPxPyPz(pbuf);
+ for( ; ok; dx*=.9 ){
+
+ if( !t.TransportToX(x0+dx, bz, .999 ) ){
+ ok = 0;
+ break;
+ if( TMath::Abs(dx)<1. ) break;
+ continue;
+ }
+ break;
+ }
+
+ {
+ if( !ok ){
+ AliHLTTPCCATrackConvertor::SetExtParam( t, trackParam );
+ }
+ AliExternalTrackParam tt;
+ AliHLTTPCCATrackConvertor::GetExtParam( t, tt, trackParam.GetAlpha() );
+ tt.GetXYZ(vbuf);
+ tt.GetPxPyPz(pbuf);
TEvePathMark endPoint(TEvePathMark::kReference);
TEvePathMark decPoint(TEvePathMark::kDecay);
endPoint.fV.Set(vbuf);
decPoint.fP.Set(pbuf);
track->AddPathMark( endPoint );
track->AddPathMark( decPoint );
- break;
}
}
- if (at->IsOn(AliESDtrack::kTPCrefit))
+ if ( ok && at->IsOn(AliESDtrack::kTPCrefit))
{
if ( ! innerTaken)
{
}
AddTrackParamToTrack(track, at->GetOuterParam());
}
+
return track;
}
return s;
}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff