// //
//////////////////////////////////////////////////////////////////////////
-#include <TROOT.h>
-#include <TTree.h>
#include <TButton.h>
#include <TColor.h>
#include <TCanvas.h>
#include <TView.h>
#include <TText.h>
-#include <TPolyMarker3D.h>
#include <TPaveLabel.h>
#include <TPaveText.h>
-#include <TList.h>
#include <TDiamond.h>
#include <TNode.h>
#include <TArc.h>
-#include <TTUBE.h>
#include <TSlider.h>
-#include <TSliderBox.h>
-#include <TGaxis.h>
#include <TVirtualX.h>
#include <TMath.h>
-#include <TMatrix.h>
#include <TGeometry.h>
-#include <X3DBuffer.h>
#include <TMarker3DBox.h>
+#include <TParticle.h>
+#include <TPolyLine3D.h>
+#include "AliMUONDisplay.h"
#include "AliRun.h"
-#include "AliDetector.h"
#include "AliMUON.h"
-#include "AliMUONDisplay.h"
#include "AliMUONPoints.h"
-#include "TParticle.h"
#include "AliMUONGlobalTrigger.h"
#include "AliHeader.h"
#include "AliMUONHit.h"
-#include "AliMUONPadHit.h"
#include "AliMUONDigit.h"
#include "AliMUONRawCluster.h"
+#include "AliMUONTrack.h"
+#include "AliMUONTrackParam.h"
-#include "AliSegmentation.h"
-#include "AliMUONResponse.h"
+#include "AliMUONGeometrySegmentation.h"
#include "AliMUONChamber.h"
#include "AliMUONConstants.h"
#include "AliMC.h"
+#include "AliLog.h"
// to manage the same zoom on both cathodes
//_____________________________________________________________________________
AliMUONDisplay::AliMUONDisplay()
+ : AliDisplay()
{
// Constructor
fPoints = 0;
//_____________________________________________________________________________
AliMUONDisplay::AliMUONDisplay(Int_t size, AliLoader * loader)
+ : AliDisplay()
{
// Create an event display object.
// A canvas named "edisplay" is created with a vertical size in pixels
// fRzone = 1.e10;
fDrawClusters = kTRUE;
fDrawCoG = kTRUE;
+ fDrawTracks = kFALSE;
fZoomMode = 1;
fZooms = 0;
fClustersCuts = 0;
Int_t ysize = size;
if (ysize < 100) ysize = 750;
Int_t xsize = Int_t(size*830./ysize);
- fCanvas = new TCanvas("Canvas", "MUON Clusters Display",14,47,xsize,ysize);
+ fCanvas = new TCanvas("Canvas", "MUON Display",14,47,xsize,ysize);
fCanvas->ToggleEventStatus();
// Create main display pad
fMUONData =0x0;
}
-AliMUONDisplay::AliMUONDisplay(const AliMUONDisplay & display):AliDisplay(display)
+AliMUONDisplay::AliMUONDisplay(const AliMUONDisplay & display)
+ : AliDisplay(display)
{
-// Dummy copy constructor
- ;
+// Protected copy constructor
+
+ AliFatal("Not implemented.");
}
button->SetFillColor(38);
button->Draw();
+ y -= dbutton + dy;
+ char but8[] = "((AliMUONDisplay*)(gAlice->Display()))->DrawReco()";
+ button = new TButton("Tracking", but8, x0, y - dbutton, x1, y);
+ button->SetFillColor(38);
+ button->Draw();
+
// display logo
TDiamond *diamond = new TDiamond(0.05,0.015,0.95,0.22);
diamond->SetFillColor(50);
}
//_____________________________________________________________________________
-void AliMUONDisplay::CreateColors()
+void AliMUONDisplay::CreateColors() const
{
// Create the colors palette used to display clusters
text->SetTextSize(0.2);
text->SetTextAlign(22);
- AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
- AliMUONChamber *iChamber = &(pMUON->Chamber(fChamber-1));
- AliMUONResponse * response=iChamber->ResponseModel();
- Int_t adcmax=1024;
- if (response) adcmax = (Int_t) response->MaxAdc();
+
+ Int_t adcmax=4096; // default 12 bits ADC
+
TBox *box;
{
// Display current event
- fPad->cd();
+ if (!fDrawTracks)
+ DrawChamber();
+ else
+ DrawReco();
+
+}
+//_____________________________________________________________________________
+void AliMUONDisplay::DrawChamber()
+{
- DrawView(fTheta, fPhi, fPsi);
+ fDrawTracks = kFALSE;
+ fPad->cd();
+ DrawView(fTheta, fPhi, fPsi);
+ // Display the event number and title
+ fPad->cd();
+ DrawTitle();
+
+}
+//_____________________________________________________________________________
+void AliMUONDisplay::DrawReco(Option_t *)
+{
+// Display current event
+
+ fDrawTracks = kTRUE;
+ // print kinematics of generated particles
+ PrintKinematics();
+ // Draw global view of muon system
+ fPad->cd();
+ DrawGlobalView(135, -50, -140);
+
// Display the event number and title
fPad->cd();
DrawTitle();
}
+//_____________________________________________________________________________
+void AliMUONDisplay::PrintKinematics()
+{
+ AliRunLoader * runLoader;
+ TParticle *particle = new TParticle();
+ Int_t nPart;
+ Float_t vertex[3], momentum[3];
+
+ if (fLoader)
+ runLoader = fLoader->GetRunLoader();
+ else
+ runLoader = 0x0;
+
+ printf("****** Event # %d ******\n",runLoader->GetEventNumber());
+ runLoader->TreeK()->GetBranch("Particles")->SetAddress(&particle);
+ nPart = (Int_t)runLoader->TreeK()->GetEntries();
+ for(Int_t iPart = 0; iPart < nPart; iPart++) {
+ runLoader->TreeK()->GetEvent(iPart);
+ vertex[0] = particle->Vx();
+ vertex[1] = particle->Vy();
+ vertex[2] = particle->Vz();
+ momentum[0] = particle->Px();
+ momentum[1] = particle->Py();
+ momentum[2] = particle->Pz();
+
+ printf("===================================================\n");
+ printf(" Generated particle # %d \n",iPart);
+ printf(" name: %s \n",particle->GetName());
+ printf(" vertex x,y,z (cm): %f %f %f \n",vertex[0],vertex[1],vertex[2]);
+ printf(" momentum Px,Py,Pz (GeV/c): %f %f %f \n",momentum[0],momentum[1],momentum[2]);
+ }
+ delete particle;
+}
+
void AliMUONDisplay::DrawSegmentation()
{
+ // to be re-written for new seg
// Draw graphical representation of segmenatation
// Attention: still experimental code
- Int_t icat=1;
+// Int_t icat=1;
- AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
- AliMUONChamber* iChamber;
- AliSegmentation* seg;
- iChamber = &(pMUON->Chamber(fChamber));
- seg=iChamber->SegmentationModel(icat);
- Float_t zpos=iChamber->Z();
- Float_t r=iChamber->ROuter();
+// AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
+// AliMUONChamber* iChamber;
+
+// AliSegmentation* seg;
+// iChamber = &(pMUON->Chamber(fChamber));
+// seg=iChamber->SegmentationModel(icat);
+
+// Float_t zpos=iChamber->Z();
+// Float_t r=iChamber->ROuter();
- TMarker3DBox *marker;
- if (icat == 1) {
- for (Int_t j=0; j<seg->Npy(); j++) {
- Float_t y0;
- y0=j*seg->Dpy()-seg->Dpy()/2.;
- for (seg->FirstPad(0.,y0,0,300,0.);
- seg->MorePads();
- seg->NextPad())
- {
- if (seg->ISector()==0) continue;
- Float_t x,y,z;
- seg->GetPadC(seg->Ix(), seg->Iy(), x, y, z);
- Float_t dpx=seg->Dpx(seg->ISector())/2;
- Float_t dpy=seg->Dpy(seg->ISector())/2;
- marker=new TMarker3DBox(x,y,zpos,dpx,dpy,0,0,0);
- marker->SetLineColor(seg->ISector()+1);
- marker->SetFillStyle(1001);
- marker->SetFillColor(0);
- marker->Draw();
- }
- }
- } else {
- for (Int_t j=0; j<250; j++) {
- Float_t x0=j*seg->Dpx();
- Float_t y0=TMath::Sqrt(r*r-x0*x0);
+// TMarker3DBox *marker;
+// if (icat == 1) {
+// for (Int_t j=0; j<seg->Npy(); j++) {
+// Float_t y0;
+// y0=j*seg->Dpy()-seg->Dpy()/2.;
+// for (seg->FirstPad(0.,y0,0,300,0.);
+// seg->MorePads();
+// seg->NextPad())
+// {
+// if (seg->ISector()==0) continue;
+// Float_t x,y,z;
+// seg->GetPadC(seg->Ix(), seg->Iy(), x, y, z);
+// Float_t dpx=seg->Dpx(seg->ISector())/2;
+// Float_t dpy=seg->Dpy(seg->ISector())/2;
+// marker=new TMarker3DBox(x,y,zpos,dpx,dpy,0,0,0);
+// marker->SetLineColor(seg->ISector()+1);
+// marker->SetFillStyle(1001);
+// marker->SetFillColor(0);
+// marker->Draw();
+// }
+// }
+// } else {
+// for (Int_t j=0; j<250; j++) {
+// Float_t x0=j*seg->Dpx();
+// Float_t y0=TMath::Sqrt(r*r-x0*x0);
- for (seg->FirstPad(x0,0,0,0,y0);
- seg->MorePads();
- seg->NextPad())
- {
- if (seg->ISector()==0) continue;
+// for (seg->FirstPad(x0,0,0,0,y0);
+// seg->MorePads();
+// seg->NextPad())
+// {
+// if (seg->ISector()==0) continue;
- Float_t x,y,z;
- seg->GetPadC(seg->Ix(), seg->Iy(), x, y, z);
- Float_t dpx=seg->Dpx(seg->ISector())/2;
- Float_t dpy=seg->Dpy(seg->ISector())/2;
- marker=new TMarker3DBox(x,y,zpos,dpx,dpy,0,0,0);
- marker->SetLineColor(seg->ISector()+1);
- marker->SetFillStyle(1001);
- marker->SetFillColor(0);
- marker->Draw();
- }
- }
- }
-}
+// Float_t x,y,z;
+// seg->GetPadC(seg->Ix(), seg->Iy(), x, y, z);
+// Float_t dpx=seg->Dpx(seg->ISector())/2;
+// Float_t dpy=seg->Dpy(seg->ISector())/2;
+// marker=new TMarker3DBox(x,y,zpos,dpx,dpy,0,0,0);
+// marker->SetLineColor(seg->ISector()+1);
+// marker->SetFillStyle(1001);
+// marker->SetFillColor(0);
+// marker->Draw();
+// }
+// }
+// }
+ }
//_____________________________________________________________________________
void AliMUONDisplay::DrawClusters()
}
}
//_____________________________________________________________________________
+void AliMUONDisplay::DrawTracks()
+{
+// Draw tracks
+ if (!fDrawTracks) return;
+ LoadTracks();
+
+ Int_t nTrack, iTrack;
+ TObjArray *points;
+ TPolyLine3D *pm;
+
+ points = Rpoints();
+ if (!points) return;
+ nTrack = points->GetEntriesFast();
+ for ( iTrack = 0; iTrack < nTrack; iTrack++) {
+ pm = (TPolyLine3D*)points->UncheckedAt(iTrack);
+ if (!pm) continue;
+ pm->Draw();
+ }
+}
+//_____________________________________________________________________________
void AliMUONDisplay::DrawTitle(Option_t *option)
{
Float_t dx = xmax-xmin;
Float_t dy = ymax-ymin;
- AliRunLoader * RunLoader;
+ AliRunLoader * runLoader;
if (fLoader)
- RunLoader = fLoader->GetRunLoader();
+ runLoader = fLoader->GetRunLoader();
else
- RunLoader = 0x0;
+ runLoader = 0x0;
if (strlen(option) == 0) {
title->Draw();
char ptitle[100];
sprintf(ptitle, "Alice event:%d Run:%d Chamber:%d Cathode:%d",
- RunLoader->GetEventNumber(),
+ runLoader->GetEventNumber(),
gAlice->GetHeader()->GetRun(),
fChamber,
fCathode);
void AliMUONDisplay::DrawView(Float_t theta, Float_t phi, Float_t psi)
{
// Draw a view of MUON clusters
- printf("\n Draw View\n");
+ AliInfo(" Draw View");
gPad->SetCursor(kWatch);
// gPad->SetFillColor(39);
view->SetView(phi, theta, psi, iret);
}
+//_____________________________________________________________________________
+void AliMUONDisplay::DrawGlobalView(Float_t theta, Float_t phi, Float_t psi)
+{
+// Draw a view of muons chambers with tracks
+
+ gPad->SetCursor(kWatch);
+ // gPad->SetFillColor(39);
+ gPad->SetFillColor(1);
+ gPad->Clear();
+ // gPad->SetFillColor(39);
+ gPad->SetFillColor(1);
+
+
+ Int_t iret=0;
+ TView *view = new TView(1);
+
+ Float_t range = fRrange*fRangeSlider->GetMaximum()*3.;
+ view->SetRange(-range,-range,-range,range,range,range);
+
+// Display all MUON Chambers segmentation
+ char nodeName[7];
+ TNode *node1;
+ sprintf(nodeName,"alice");
+
+ node1=gAlice->GetGeometry()->GetNode(nodeName);
+ if (node1) node1->Draw("same");
+
+
+// Draw clusters for all chambers
+ Int_t chamberSave = fChamber;
+ for (fChamber = 1; fChamber <= 10; fChamber++){
+ DrawCoG();
+ }
+ fChamber = chamberSave;
+// Draw reconstructed tracks
+ DrawTracks();
+
+ AppendPad();
+
+ Float_t zoom = 2.;
+ Float_t shift = 0.9;
+ Float_t x0 = (-1+shift)/zoom;
+ Float_t y0 = (-1+shift)/zoom;
+ Float_t x1 = (1+shift)/zoom;
+ Float_t y1 = (1+shift)/zoom;
+ gPad->Range(x0,y0,x1,y1);
+ view->SetView(phi, theta, psi, iret);
+
+}
//______________________________________________________________________________
void AliMUONDisplay::ExecuteEvent(Int_t event, Int_t px, Int_t py)
// Loop on all detectors
if (chamber > 14) return;
- printf(" chamber %d \n",chamber);
fChamber = chamber;
fCathode = cathode;
AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
AliMUONChamber* iChamber;
- AliSegmentation* segmentation;
- AliMUONResponse* response;
-
+ AliMUONGeometrySegmentation* segmentation2 = 0x0;
+
GetMUONData()->SetTreeAddress("D");
TClonesArray *muonDigits = GetMUONData()->Digits(chamber-1);
if (GetLoader()->TreeD()) {
nent = (Int_t) GetLoader()->TreeD()->GetEntries();
- printf(" entries %d \n", nent);
// gAlice->TreeD()->GetEvent(nent-2+cathode-1);
GetMUONData()->GetCathode(cathode-1);
}
iChamber = &(pMUON->Chamber(chamber-1));
- segmentation = iChamber->SegmentationModel(cathode);
- response = iChamber->ResponseModel();
+ segmentation2 = iChamber->SegmentationModel2(cathode);
+
Float_t zpos = iChamber->Z();
AliMUONDigit *mdig;
//loop over all digits and store their position
Int_t npoints = 1;
- Float_t adcmax = 1024;
- if (response&&chamber<11) adcmax = response->MaxAdc();
+ Float_t adcmax = 1024; // default
+ if (chamber<11) adcmax = 4096;
for (Int_t digit = 0; digit < ndigits; digit++) {
mdig = (AliMUONDigit*)muonDigits->UncheckedAt(digit);
// get the center of the pad - add on x and y half of pad size
Float_t xpad, ypad, zpad;
- segmentation->GetPadC(mdig->PadX(), mdig->PadY(), xpad, ypad, zpad);
+ Int_t isec;
+ Float_t dpx, dpy;
+
+ Int_t detElemId = mdig->DetElemId();
+ segmentation2->GetPadC(detElemId, mdig->PadX(), mdig->PadY(), xpad, ypad, zpad);
+ isec = segmentation2->Sector(detElemId, mdig->PadX(), mdig->PadY());
+ dpx = segmentation2->Dpx(detElemId, isec)/2;
+ dpy = segmentation2->Dpy(detElemId, isec)/2;
- Int_t isec = segmentation->Sector(mdig->PadX(), mdig->PadY());
- Float_t dpx = segmentation->Dpx(isec)/2;
- Float_t dpy = segmentation->Dpy(isec)/2;
//
// segmentation->Dump();
points->SetHitIndex(-1);
points->SetTrackIndex(-1);
points->SetDigitIndex(-1);
- points->SetPoint(iraw,mRaw->fX[0],mRaw->fY[0],zpos);
+ points->SetPoint(iraw,mRaw->GetX(0),mRaw->GetY(0),zpos);
fRpoints->AddAt(points,iraw);
- // printf("%f and %f and %f\n",mRaw->fX[0],mRaw->fY[0],mRaw->fZ[0]);
+ // printf("%f and %f and %f\n",mRaw->GetX(0),mRaw->GetY(0),mRaw->GetZ(0));
}
}
+
+//___________________________________________
+void AliMUONDisplay::LoadTracks()
+{
+// Load tracks
+ AliMUONTrack* recTrack = 0;
+ AliMUONTrackParam* trackParam = 0;
+ TClonesArray * trackParamAtHit = 0;
+
+ ResetRpoints();
+
+ GetMUONData()->SetTreeAddress("RT");
+ TClonesArray* recTracksArray = GetMUONData()->RecTracks();
+ if (recTracksArray == NULL) return;
+ GetMUONData()->GetRecTracks();
+
+ Int_t nRecTracks = 0;
+ if (recTracksArray)
+ nRecTracks = (Int_t) recTracksArray->GetEntriesFast();
+
+
+ if (fRpoints == 0) fRpoints = new TObjArray(nRecTracks);
+
+ for (Int_t iRecTracks = 0; iRecTracks < nRecTracks; iRecTracks++) {
+ // reading info from tracks
+ recTrack = (AliMUONTrack*) recTracksArray->At(iRecTracks);
+
+ Int_t nTrackHits = recTrack->GetNTrackHits();
+
+ if (nTrackHits == 0) continue;
+
+ Int_t iPoint = 0;
+ TPolyLine3D *points = new TPolyLine3D(nTrackHits+1);
+ points->SetLineColor(6);
+ points->SetLineWidth(1);
+ fRpoints->AddAt(points,iRecTracks);
+
+ Float_t xRec=0;
+ Float_t yRec=0;
+ Float_t zRec=0;
+
+ trackParam = recTrack->GetTrackParamAtVertex();
+ xRec = trackParam->GetNonBendingCoor();
+ yRec = trackParam->GetBendingCoor();
+ zRec = trackParam->GetZ();
+ points->SetPoint(iPoint,xRec,yRec,zRec);
+ iPoint++;
+
+ for (Int_t iHit = 0; iHit < nTrackHits; iHit++){
+ trackParamAtHit = recTrack->GetTrackParamAtHit();
+ trackParam = (AliMUONTrackParam*) trackParamAtHit->At(iHit);
+ xRec = trackParam->GetNonBendingCoor();
+ yRec = trackParam->GetBendingCoor();
+ zRec = trackParam->GetZ();
+ points->SetPoint(iPoint,xRec,yRec,zRec);
+ iPoint++;
+ } // end loop rec. hits
+ PrintTrack(iRecTracks,recTrack);
+ } // end loop tracks
+
+
+}
+
+void AliMUONDisplay::PrintTrack(Int_t iRecTracks, AliMUONTrack *recTrack)
+{
+ AliMUONTrackParam *trackParam;
+ Float_t vertex[3], momentum[3];
+ Float_t pYZ, bendingSlope, nonBendingSlope, chi2dof;
+ Int_t charge;
+
+ trackParam = recTrack->GetTrackParamAtVertex();
+ vertex[0] = trackParam->GetNonBendingCoor();
+ vertex[1] = trackParam->GetBendingCoor();
+ vertex[2] = trackParam->GetZ();
+ pYZ = 1./TMath::Abs(trackParam->GetInverseBendingMomentum());
+ bendingSlope = trackParam->GetBendingSlope();
+ nonBendingSlope = trackParam->GetNonBendingSlope();
+ momentum[2] = -pYZ / TMath::Sqrt(1.0 + bendingSlope*bendingSlope);
+ momentum[0] = momentum[2] * nonBendingSlope;
+ momentum[1] = momentum[2] * bendingSlope;
+ charge = Int_t(TMath::Sign(1.,trackParam->GetInverseBendingMomentum()));
+ chi2dof = recTrack->GetFitFMin()/(2.0 * recTrack->GetNTrackHits() - 5.);
+
+ printf("===================================================\n");
+ printf(" Reconstructed track # %d \n",iRecTracks);
+ printf(" charge: %d \n",charge);
+ printf(" vertex x,y,z (cm): %f %f %f \n",vertex[0],vertex[1],vertex[2]);
+ printf(" momentum Px,Py,Pz (GeV/c): %f %f %f \n",momentum[0],momentum[1],momentum[2]);
+ printf(" track chi2/dof: %f \n",chi2dof);
+
+}
+
//___________________________________________
void AliMUONDisplay::LoadHits(Int_t chamber)
{
if (!fPad) return;
fPad->Clear();
LoadDigits(fChamber, fCathode);
- Draw();
+ DrawChamber();
}
//_____________________________________________________________________________
LoadDigits(fChamber, 1);
}
fNextCathode = kTRUE; // to keep the same zoom
- Draw();
+ DrawChamber();
fNextCathode = kFALSE;
TPad *pad = (TPad*)gPad->GetPadSave();
pad->Range(fZoomX0[fZooms], fZoomY0[fZooms],
AliMUONGlobalTrigger* globalTrig;
GetMUONData()->SetTreeAddress("GLT");
- GetMUONData()->GetTrigger();
+ GetMUONData()->GetTriggerD();
globalTrig = (AliMUONGlobalTrigger*)GetMUONData()->GlobalTrigger()->UncheckedAt(0);
if (globalTrig == 0) return;
if (!fPad) return;
fPad->Clear();
LoadDigits(chamber,cathode);
- Draw();
+ DrawChamber();
}
void AliMUONDisplay::SetEvent(Int_t newevent)
//_____________________________________________________________________________
void AliMUONDisplay::ShowNextEvent(Int_t delta)
{
- AliRunLoader * RunLoader;
+ AliRunLoader * runLoader;
if (fLoader)
- RunLoader = fLoader->GetRunLoader();
+ runLoader = fLoader->GetRunLoader();
else
- RunLoader = 0x0;
+ runLoader = 0x0;
// Display (current event_number + delta)
// delta = 1 shown next event
// delta = -1 show previous event
if (delta) {
- //RunLoader->CleanDetectors();
- //RunLoader->CleanKinematics();
- Int_t currentEvent = RunLoader->GetEventNumber();
+ //runLoader->CleanDetectors();
+ //runLoader->CleanKinematics();
+ Int_t currentEvent = runLoader->GetEventNumber();
Int_t newEvent = currentEvent + delta;
- RunLoader->GetEvent(newEvent);
+ runLoader->GetEvent(newEvent);
fEvent=newEvent;
}
LoadDigits(fChamber, fCathode);
}
}
-AliMUONDisplay & AliMUONDisplay::operator = (const AliMUONDisplay &)
+AliMUONDisplay & AliMUONDisplay::operator = (const AliMUONDisplay & rhs)
{
-// Dummy assignment operator
- return *this;
+// Protected assignement operator
+
+ if (this == &rhs) return *this;
+
+ AliFatal("Not implemented.");
+
+ return *this;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff