/*
$Log$
+ Revision 1.18 2002/10/29 14:24:19 morsch
+ Minor corrections on the display (adc counts readable, ...).
+ (J. Barbosa)
+
+ Revision 1.17 2001/10/23 13:03:35 hristov
+ The access to several data members was changed from public to protected. The digitisation was adapted to the multi-event case (J.Chudoba)
+
+ Revision 1.16 2001/10/21 18:31:24 hristov
+ Several pointers were set to zero in the default constructors to avoid memory management problems
+
+ Revision 1.15 2001/10/09 07:34:09 hristov
+ Modifications needed by Root.03.01.06 (J.Chudoba)
+
+ Revision 1.14 2001/05/16 14:57:20 alibrary
+ New files for folders and Stack
+
+ Revision 1.13 2001/05/10 12:35:16 jbarbosa
+ Removed hit display, added rec. ring properties.
+
+ Revision 1.12 2001/03/14 18:15:03 jbarbosa
+ Changes to adapt to new IO.
+ Removed verbose output.
+
+ Revision 1.11 2001/02/27 15:21:34 jbarbosa
+ Transition to SDigits.
+
+ Revision 1.10 2001/02/13 20:18:48 jbarbosa
+ Corrected some more positioning of points. Changes in LoadDigits to accomodate the new IO.
+
+ Revision 1.9 2000/11/01 15:33:11 jbarbosa
+ Updated to handle both reconstruction algorithms.
+
+ Revision 1.8 2000/10/03 21:44:09 morsch
+ Use AliSegmentation and AliHit abstract base classes.
+
+ Revision 1.7 2000/10/02 21:28:12 fca
+ Removal of useless dependecies via forward declarations
+
+ Revision 1.6 2000/10/02 15:46:38 jbarbosa
+ Fixed forward declarations.
+
+ Revision 1.5 2000/06/30 16:49:34 dibari
+ Different call for ring drawing.
+
+ Revision 1.4 2000/06/12 15:21:08 jbarbosa
+ Cleaned up version.
+
+ Revision 1.3 2000/06/09 14:52:08 jbarbosa
+ New tentative ellipse drawing routine
+
Revision 1.1 2000/04/19 13:07:45 morsch
Digits, clusters and reconstruction results added.
#include <TView.h>
#include <TText.h>
#include <TPolyMarker3D.h>
+#include <TAtt3D.h>
+#include <TAttLine.h>
#include <TPolyMarker.h>
#include <TPaveLabel.h>
#include <TPaveText.h>
#include <TArc.h>
#include <TTUBE.h>
#include <TSlider.h>
+#include <TGeometry.h>
#include <TSliderBox.h>
#include <TGaxis.h>
#include <TVirtualX.h>
#include <TMath.h>
#include <TRandom.h>
#include <X3DBuffer.h>
+#include <TParticle.h>
#include "AliRun.h"
#include "AliPDG.h"
#include "AliRICHConst.h"
#include "AliRICHDisplay.h"
#include "AliRICHPoints.h"
-#include "TParticle.h"
+#include "AliHeader.h"
+#include "AliRICHHit.h"
+#include "AliRICHCerenkov.h"
+#include "AliRICHSDigit.h"
+#include "AliRICHDigit.h"
+#include "AliRICHRawCluster.h"
+#include "AliRICHRecHit1D.h"
+#include "AliRICHRecHit3D.h"
+#include "AliRICHEllipse.h"
ClassImp(AliRICHDisplay)
//____________________________________________________________________________
AliRICHDisplay::AliRICHDisplay()
{
+
+// default constructor
+ fColPad = 0;
fPoints = 0;
fPhits = 0;
fPCerenkovs = 0;
SetRange();
// Set front view by default
- fTheta = 90;
- fPhi = 90;
+ fTheta = 90; //inclined HMPID
+ fPhi = 30; //inclined HMPID
+ //fTheta = 90; //normal HMPID
+ //fPhi = 90; //normal HMPID
fPsi = 0;
fChamber = 1;
fCathode = 1;
Float_t dxtr = 0.15;
Float_t dytr = 0.45;
fTrigPad = new TPad("trigger", "range and mode pad",0,0,dxtr,dytr);
- fTrigPad->SetEditable(kFALSE);
fTrigPad->Draw();
fTrigPad->cd();
fTrigPad->SetFillColor(22);
button->Draw();
AppendPad(); // append display object as last object to force selection
+ fTrigPad->SetEditable(kFALSE);
+ fButtons->SetEditable(kFALSE);
fCanvas->cd();
fCanvas->Update();
}
fButtons = new TPad("buttons", "newpad",0,0.45,0.15,1);
- fButtons->SetEditable(kFALSE);
fButtons->Draw();
fButtons->SetFillColor(38);
fButtons->SetBorderSize(2);
//_____________________________________________________________________________
void AliRICHDisplay::DisplayColorScale()
{
+
+// Draw the color scale in the RICH display canvas
Int_t i;
Int_t color;
gPad->Range(x1,y1,x2,y2);
TText *text = new TText(0,0,"");
text->SetTextFont(61);
- text->SetTextSize(0.03);
+ text->SetTextSize(0.2);
text->SetTextAlign(22);
TBox *box;
if (gPad == fTrigPad) return 9999;
- const Int_t big = 9999;
- Int_t dist = big;
+ const Int_t kBig = 9999;
+ Int_t dist = kBig;
Float_t xmin = gPad->GetX1();
Float_t xmax = gPad->GetX2();
Float_t dx = 0.02*(xmax - xmin);
if (!fDrawCoG) return;
ResetRpoints();
- for (Int_t chamber=0;chamber<7;chamber++) {
+ for (Int_t chamber=0;chamber<kNCH;chamber++) {
LoadCoG(chamber,1);
}
if (!fDrawRecHits) return;
//ResetRecpoints();
- for (Int_t chamber=0;chamber<7;chamber++) {
+ for (Int_t chamber=0;chamber<kNCH;chamber++) {
LoadRecHits(chamber,1);
}
points = fRecpoints;
if (!points) return;
nrec = points->GetEntriesFast();
- printf("Nrec %d\n",nrec);
+ //printf("Nrec %d\n",nrec);
for (irec=0; irec < nrec; irec++) {
pm = (AliRICHPoints*)points->UncheckedAt(irec);
if (!pm) continue;
//add clusters to the pad
DrawClusters();
- DrawHits();
-// DrawCerenkovs();
- printf("Calling DrawCoG\n");
- DrawCoG();
- printf("Calling DrawRecHits\n");
- DrawRecHits();
+ //DrawHits();
+ //DrawCerenkovs();
+ if (gAlice->TreeR())
+ {
+ //printf("Calling DrawCoG\n");
+ DrawCoG();
+ //printf("Calling DrawRecHits\n");
+ DrawRecHits();
+ }
/*for (Int_t i=0;i<7;i++)
LoadRecHits(i,1);*/
if (px == 0 && py == 0) { //when called by sliders
if (event == kButton1Up) {
- Draw();
+ printf("Drawing event %d\n",event);
+ Draw();
}
return;
}
if (chamber > 6) return;
- printf("Entering LoadCoG\n");
+ //printf("Entering LoadCoG\n");
- AliRICH *RICH = (AliRICH*)gAlice->GetModule("RICH");
+ AliRICH *pRICH = (AliRICH*)gAlice->GetModule("RICH");
AliRICHChamber* iChamber;
- TClonesArray *RICHrawclust = RICH->RawClustAddress(chamber);
- printf ("Chamber:%d has adress:%p\n", chamber, RICHrawclust );
- if (RICHrawclust == 0) return;
+ TClonesArray *pRICHrawclust = pRICH->RawClustAddress(chamber);
+ //printf ("Chamber:%d has adress:%p\n", chamber, pRICHrawclust );
+ if (pRICHrawclust == 0) return;
- RICH->ResetRawClusters();
+ pRICH->ResetRawClusters();
Int_t nent=(Int_t)gAlice->TreeR()->GetEntries();
gAlice->TreeR()->GetEvent(nent-1+cathode-1);
- Int_t nrawcl = RICHrawclust->GetEntriesFast();
- printf ("nrawcl:%d\n",nrawcl);
+ Int_t nrawcl = pRICHrawclust->GetEntriesFast();
+ //printf ("nrawcl:%d\n",nrawcl);
if (nrawcl == 0) return;
if (fRpoints == 0) fRpoints = new TObjArray(nrawcl);
- iChamber = &(RICH->Chamber(chamber));
+ iChamber = &(pRICH->Chamber(chamber));
AliRICHRawCluster *mRaw;
AliRICHPoints *points = 0;
//
//loop over all raw clusters and store their position
points = new AliRICHPoints(nrawcl);
for (Int_t iraw=0;iraw<nrawcl;iraw++) {
- mRaw = (AliRICHRawCluster*)RICHrawclust->UncheckedAt(iraw);
+ mRaw = (AliRICHRawCluster*)pRICHrawclust->UncheckedAt(iraw);
fRpoints->AddAt(points,iraw);
points->SetMarkerColor(3);
points->SetMarkerStyle(3);
points->SetHitIndex(-1);
points->SetTrackIndex(-1);
points->SetDigitIndex(-1);
- Float_t VecLoc[3]={mRaw->fX,6.276,mRaw->fY};
- Float_t VecGlob[3];
- iChamber->LocaltoGlobal(VecLoc,VecGlob);
- points->SetPoint(iraw,VecGlob[0],VecGlob[1],VecGlob[2]);
+ Float_t vectorLoc[3]={mRaw->fX,5,mRaw->fY};
+ Float_t vectorGlob[3];
+ iChamber->LocaltoGlobal(vectorLoc,vectorGlob);
+ points->SetPoint(iraw,vectorGlob[0],vectorGlob[1],vectorGlob[2]);
}
}
//___________________________________________
if (chamber > 6) return;
- printf("Entering LoadRecHits\n");
+ ///printf("Entering LoadRecHits\n");
- AliRICH *RICH = (AliRICH*)gAlice->GetModule("RICH");
+ AliRICH *pRICH = (AliRICH*)gAlice->GetModule("RICH");
AliRICHChamber* iChamber;
- TClonesArray *RICHrechits = RICH->RecHitsAddress(chamber);
- printf ("Chamber:%d has adress:%p\n", chamber, RICHrechits );
- if (RICHrechits == 0) return;
+ TClonesArray *pRICHrechits1D = pRICH->RecHitsAddress1D(chamber);
+ //printf ("Chamber:%d\n", chamber);
+ if (pRICHrechits1D != 0)
+ {
- //RICH->ResetRecHits();
+ //RICH->ResetRecHits();
- Int_t nent=(Int_t)gAlice->TreeR()->GetEntries();
- gAlice->TreeR()->GetEvent(nent-1+cathode-1);
- Int_t nrechits = RICHrechits->GetEntriesFast();
- printf ("nrechits:%d\n",nrechits);
- if (nrechits == 0) return;
- if (fRecpoints == 0) fRecpoints = new TObjArray(50);
-
- iChamber = &(RICH->Chamber(chamber));
- AliRICHRecHit *mRec;
- AliRICHPoints *points = 0;
- //AliRICHEllipse *ellipse = 0;
- //
- //loop over all rechits and store their position
-
- points = new AliRICHPoints(nrechits);
- for (Int_t irec=0;irec<nrechits;irec++) {
- mRec = (AliRICHRecHit*)RICHrechits->UncheckedAt(irec);
- fRecpoints->AddAt(points,irec);
- points->SetMarkerColor(38);
- points->SetMarkerStyle(8);
- points->SetMarkerSize(1.);
- points->SetParticle(-1);
- points->SetHitIndex(-1);
- points->SetTrackIndex(-1);
- points->SetDigitIndex(-1);
- Float_t VecLoc[3]={mRec->fX,6.276,mRec->fY};
- Float_t VecGlob[3];
- iChamber->LocaltoGlobal(VecLoc,VecGlob);
- points->SetPoint(irec,VecGlob[0],VecGlob[1],VecGlob[2]);
- //Float_t theta = iChamber->GetRotMatrix()->GetTheta();
- //Float_t phi = iChamber->GetRotMatrix()->GetPhi();
- //ellipse=new TEllipse(VecGlob[0],VecGlob[2],10,10,0,360,phi);
- printf("Generating ellipse %d\n",irec);
- AliRICHEllipse *ellipse=new AliRICHEllipse(mRec->fX,mRec->fY,mRec->Omega,mRec->Theta,mRec->Phi);
- ellipse->CreatePoints(chamber);
- //ellipse->SetFillStyle(1001);
- ellipse->SetMarkerColor(38);
- ellipse->Draw();
- //marker->SetRefObject((TObject*)points);
- //points->Set3DMarker(0, marker);
- }
+ Int_t nent1D=(Int_t)gAlice->TreeR()->GetEntries();
+ gAlice->TreeR()->GetEvent(nent1D-1+cathode-1);
+ Int_t nrechits1D = pRICHrechits1D->GetEntriesFast();
+ //printf ("nrechits1D:%d\n",nrechits1D);
+ if (nrechits1D != 0)
+ {
+ if (fRecpoints == 0) fRecpoints = new TObjArray(50);
+
+ iChamber = &(pRICH->Chamber(chamber));
+ AliRICHRecHit1D *mRec1D;
+ AliRICHPoints *points1D = 0;
+ //AliRICHEllipse *ellipse = 0;
+ //
+ //loop over all rechits and store their position
+
+ points1D = new AliRICHPoints(nrechits1D);
+ for (Int_t irec=0;irec<nrechits1D;irec++) {
+ mRec1D = (AliRICHRecHit1D*)pRICHrechits1D->UncheckedAt(irec);
+ fRecpoints->AddAt(points1D,irec);
+ points1D->SetMarkerColor(38);
+ points1D->SetMarkerStyle(8);
+ points1D->SetMarkerSize(.5);
+ points1D->SetParticle(-1);
+ points1D->SetHitIndex(-1);
+ points1D->SetTrackIndex(-1);
+ points1D->SetDigitIndex(-1);
+ Float_t vectorLoc[3]={mRec1D->fX,5,mRec1D->fY};
+ Float_t vectorGlob[3];
+ iChamber->LocaltoGlobal(vectorLoc,vectorGlob);
+ points1D->SetPoint(irec,vectorGlob[0],vectorGlob[1],vectorGlob[2]);
+ //Float_t theta = iChamber->GetRotMatrix()->GetTheta();
+ //Float_t phi = iChamber->GetRotMatrix()->GetPhi();
+ //ellipse=new TEllipse(vectorGlob[0],vectorGlob[2],10,10,0,360,phi);
+ //printf("Generating ellipse %d\n",irec);
+ AliRICHEllipse *ellipse=new AliRICHEllipse(mRec1D->fX,mRec1D->fY,mRec1D->fOmega,mRec1D->fTheta,mRec1D->fPhi,mRec1D->fEmissPoint);
+ printf("Ring at x:%f, y:%f - Omega:%f rad, theta:%3.1f deg, phi:%3.1f deg\n",mRec1D->fX,mRec1D->fY,mRec1D->fOmega,mRec1D->fTheta*180/TMath::Pi(),mRec1D->fPhi*180/TMath::Pi());
+ printf("fEmissPoint:%f\n",mRec1D->fEmissPoint);
+ ellipse->CerenkovRingDrawing(chamber,irec);
+ //ellipse->SetFillStyle(1001);
+ ellipse->SetMarkerColor(38);
+ ellipse->Draw();
+ //marker->SetRefObject((TObject*)points1D);
+ //points1D->Set3DMarker(0, marker);
+ }
+ }
+ }
+
+ TClonesArray *pRICHrechits3D = pRICH->RecHitsAddress3D(chamber);
+ //printf ("Chamber:%d\n", chamber);
+ if (pRICHrechits3D != 0)
+ {
+
+ //RICH->ResetRecHits();
+
+
+ Int_t nent3D=(Int_t)gAlice->TreeR()->GetEntries();
+ gAlice->TreeR()->GetEvent(nent3D-1+cathode-1);
+ Int_t nrechits3D = pRICHrechits3D->GetEntriesFast();
+ //printf ("nrechits3D:%d\n",nrechits3D);
+ if (nrechits3D != 0)
+ {
+ if (fRecpoints == 0) fRecpoints = new TObjArray(50);
+
+ iChamber = &(pRICH->Chamber(chamber));
+ AliRICHRecHit3D *mRec3D;
+ AliRICHPoints *points3D = 0;
+ //AliRICHEllipse *ellipse = 0;
+ //
+ //loop over all rechits and store their position
+
+ points3D = new AliRICHPoints(nrechits3D);
+ for (Int_t irec=0;irec<nrechits3D;irec++) {
+ mRec3D = (AliRICHRecHit3D*)pRICHrechits3D->UncheckedAt(irec);
+ fRecpoints->AddAt(points3D,irec);
+ points3D->SetMarkerColor(42);
+ points3D->SetMarkerStyle(8);
+ points3D->SetMarkerSize(1.);
+ points3D->SetParticle(-1);
+ points3D->SetHitIndex(-1);
+ points3D->SetTrackIndex(-1);
+ points3D->SetDigitIndex(-1);
+ Float_t vectorLoc[3]={mRec3D->fX,5,mRec3D->fY};
+ Float_t vectorGlob[3];
+ iChamber->LocaltoGlobal(vectorLoc,vectorGlob);
+ points3D->SetPoint(irec,vectorGlob[0],vectorGlob[1],vectorGlob[2]);
+ //Float_t theta = iChamber->GetRotMatrix()->GetTheta();
+ //Float_t phi = iChamber->GetRotMatrix()->GetPhi();
+ //ellipse=new TEllipse(vectorGlob[0],vectorGlob[2],10,10,0,360,phi);
+ //printf("Generating ellipse %d\n",irec);
+ AliRICHEllipse *ellipse=new AliRICHEllipse(mRec3D->fX,mRec3D->fY,mRec3D->fOmega,mRec3D->fTheta,mRec3D->fPhi,0.75);
+ printf("Ring at x:%f, y:%f - Omega:%f rad, theta:%3.1f deg, phi:%3.1f deg\n",mRec3D->fX,mRec3D->fY,mRec3D->fOmega,mRec3D->fTheta*180/TMath::Pi(),mRec3D->fPhi*180/TMath::Pi());
+ //ellipse->CerenkovRingDrawing(chamber,irec);
+ //ellipse->SetFillStyle(1001);
+ ellipse->CreatePoints(chamber);
+ ellipse->SetMarkerStyle(7);
+ ellipse->SetMarkerColor(42);
+ ellipse->SetMarkerSize(1);
+ ellipse->Draw();
+ //marker->SetRefObject((TObject*)points3D);
+ //points3D->Set3DMarker(0, marker);
+ }
+ }
+ }
}
//___________________________________________
void AliRICHDisplay::LoadDigits()
// Loop on all detectors
ResetPoints();
- AliRICH *RICH = (AliRICH*)gAlice->GetDetector("RICH");
+ AliRICH *pRICH = (AliRICH*)gAlice->GetDetector("RICH");
AliRICHChamber* iChamber;
- AliRICHSegmentation* segmentation;
- Int_t NallDigits=0;
+ AliSegmentation* segmentation;
+ Int_t nAllDigits=0;
Int_t ich;
+
+ //printf("Entering LoadDigits\n");
+
+ if (gAlice->TreeD())
+ {
- for (ich=0; ich<7; ich++) {
- TClonesArray *RICHdigits = RICH->DigitsAddress(ich);
- if (RICHdigits == 0) continue;
- gAlice->ResetDigits();
- gAlice->TreeD()->GetEvent(1);
- Int_t ndigits = RICHdigits->GetEntriesFast();
- NallDigits+=ndigits;
- }
- if (fPoints == 0) fPoints = new TObjArray(NallDigits);
- Int_t counter=0;
- for (ich=0; ich<7; ich++) {
- TClonesArray *RICHdigits = RICH->DigitsAddress(ich);
- if (RICHdigits == 0) continue;
- gAlice->ResetDigits();
- gAlice->TreeD()->GetEvent(1);
- Int_t ndigits = RICHdigits->GetEntriesFast();
- if (ndigits == 0) continue;
- iChamber = &(RICH->Chamber(ich));
- segmentation=iChamber->GetSegmentationModel();
- Float_t dpx = segmentation->Dpx();
- Float_t dpy = segmentation->Dpy();
-
- //printf("Dpx:%d, Dpy:%d\n",dpx,dpy);
-
- AliRICHDigit *mdig;
- AliRICHPoints *points = 0;
- TMarker3DBox *marker = 0;
- //
- //loop over all digits and store their position
- Int_t npoints=1;
+ for (ich=0; ich<kNCH; ich++) {
+ TClonesArray *pRICHdigits = pRICH->DigitsAddress(ich);
+ //printf ("Chamber:%d has adress:%p\n", ich, pRICHdigits );
+ if (pRICHdigits == 0) continue;
+ gAlice->ResetDigits();
+ gAlice->TreeD()->GetEvent(0);
+ Int_t ndigits = pRICHdigits->GetEntriesFast();
+ //printf("ndigits:%d\n",ndigits);
+ nAllDigits+=ndigits;
+ }
- for (Int_t digit=0;digit<ndigits;digit++) {
- mdig = (AliRICHDigit*)RICHdigits->UncheckedAt(digit);
+ if (fPoints == 0) fPoints = new TObjArray(nAllDigits);
+ Int_t counter=0;
+ for (ich=0; ich<kNCH; ich++) {
+ TClonesArray *pRICHdigits = pRICH->DigitsAddress(ich);
+ if (pRICHdigits == 0) continue;
+ gAlice->ResetDigits();
+ gAlice->TreeD()->GetEvent(0);
+ Int_t ndigits = pRICHdigits->GetEntriesFast();
+ if (ndigits == 0) continue;
+ iChamber = &(pRICH->Chamber(ich));
+ segmentation=iChamber->GetSegmentationModel();
+ Float_t dpx = segmentation->Dpx();
+ Float_t dpy = segmentation->Dpy();
+
+ //printf("Dpx:%d, Dpy:%d\n",dpx,dpy);
+
+ AliRICHDigit *mdig;
+ AliRICHPoints *points = 0;
+ TMarker3DBox *marker = 0;
+ //
+ //loop over all digits and store their position
+ Int_t npoints=1;
+
+ for (Int_t digit=0;digit<ndigits;digit++) {
+ mdig = (AliRICHDigit*)pRICHdigits->UncheckedAt(digit);
points = new AliRICHPoints(npoints);
fPoints->AddAt(points,counter);
counter++;
- Int_t charge=mdig->fSignal;
+ Int_t charge=mdig->Signal();
Int_t index=Int_t(TMath::Log(charge)/(TMath::Log(adc_satm)/22));
Int_t color=701+index;
if (color>722) color=722;
points->SetMarkerColor(color);
points->SetMarkerStyle(21);
points->SetMarkerSize(0.5);
- Float_t xpad, ypad;
- segmentation->GetPadCxy(mdig->fPadX, mdig->fPadY,xpad, ypad);
- Float_t VecLoc[3]={xpad,6.276,ypad};
- Float_t VecGlob[3];
- iChamber->LocaltoGlobal(VecLoc,VecGlob);
+ Float_t xpad, ypad, zpad;
+ segmentation->GetPadC(mdig->PadX(), mdig->PadY(),xpad, ypad, zpad);
+ Float_t vectorLoc[3]={xpad,5,ypad};
+ Float_t vectorGlob[3];
+ iChamber->LocaltoGlobal(vectorLoc,vectorGlob);
points->SetParticle(-1);
points->SetHitIndex(-1);
points->SetTrackIndex(-1);
points->SetDigitIndex(digit);
- points->SetPoint(0,VecGlob[0],VecGlob[1],VecGlob[2]);
+ points->SetPoint(0,vectorGlob[0],vectorGlob[1],vectorGlob[2]);
+ //printf("Y position (digit): %f\n", vectorGlob[1]);
- segmentation->GetPadCxy(mdig->fPadX, mdig->fPadY, xpad, ypad);
+ segmentation->GetPadC(mdig->PadX(), mdig->PadY(), xpad, ypad, zpad);
Float_t theta = iChamber->GetRotMatrix()->GetTheta();
Float_t phi = iChamber->GetRotMatrix()->GetPhi();
- marker=new TMarker3DBox(VecGlob[0],VecGlob[1],VecGlob[2],
+ marker=new TMarker3DBox(vectorGlob[0],vectorGlob[1],vectorGlob[2],
dpy/2,0,dpx/2,theta,phi);
marker->SetLineColor(2);
marker->SetFillStyle(1001);
marker->SetFillColor(color);
marker->SetRefObject((TObject*)points);
points->Set3DMarker(0, marker);
- } // loop over digits
- } // loop over chambers
+ } // loop over digits
+ } // loop over chambers
+ } //if TreeD
}
fChamber=chamber;
ResetPhits();
- AliRICH *RICH = (AliRICH*)gAlice->GetDetector("RICH");
+ AliRICH *pRICH = (AliRICH*)gAlice->GetDetector("RICH");
AliRICHChamber* iChamber;
- iChamber = &(RICH->Chamber(chamber-1));
+ iChamber = &(pRICH->Chamber(chamber-1));
Int_t ntracks = (Int_t)gAlice->TreeH()->GetEntries();
Int_t track;
//TVector *zp = new TVector(1000);
//TVector *ptrk = new TVector(1000);
//TVector *phit = new TVector(1000);
- Int_t NallHits=0;
+ Int_t nAllHits=0;
for (track=0; track<ntracks;track++) {
gAlice->ResetHits();
gAlice->TreeH()->GetEvent(track);
- TClonesArray *RICHhits = RICH->Hits();
- if (RICHhits == 0) return;
- Int_t nhits = RICHhits->GetEntriesFast();
- NallHits+=nhits;
+ TClonesArray *pRICHhits = pRICH->Hits();
+ if (pRICHhits == 0) return;
+ Int_t nhits = pRICHhits->GetEntriesFast();
+ nAllHits+=nhits;
}
- fPhits = new TObjArray(NallHits);
+ fPhits = new TObjArray(nAllHits);
Int_t npoints=0;
for (track=0; track<ntracks;track++) {
gAlice->ResetHits();
gAlice->TreeH()->GetEvent(track);
- TClonesArray *RICHhits = RICH->Hits();
- if (RICHhits == 0) return;
- Int_t nhits = RICHhits->GetEntriesFast();
+ TClonesArray *pRICHhits = pRICH->Hits();
+ if (pRICHhits == 0) return;
+ Int_t nhits = pRICHhits->GetEntriesFast();
if (nhits == 0) continue;
AliRICHHit *mHit;
AliRICHPoints *points = 0;
for (Int_t hit=0;hit<nhits;hit++) {
points = new AliRICHPoints(1);
fPhits->AddAt(points,npoints);
- mHit = (AliRICHHit*)RICHhits->UncheckedAt(hit);
- TParticle *current =
- (TParticle*)(*gAlice->Particles())[mHit->fTrack];
+ mHit = (AliRICHHit*)pRICHhits->UncheckedAt(hit);
+ TParticle *current = (TParticle*)gAlice->Particle(mHit->Track());
if (current->GetPdgCode() == 50000050) {
points->SetMarkerColor(kBlue);
} else if (current->GetPdgCode() == 50000051) {
}
points->SetMarkerStyle(5);
points->SetMarkerSize(1.);
- points->SetParticle(mHit->fTrack);
+ points->SetParticle(mHit->Track());
points->SetHitIndex(hit);
points->SetTrackIndex(track);
points->SetDigitIndex(-1);
- points->SetPoint(hit,mHit->fX, mHit->fY, mHit->fZ);
+ points->SetPoint(hit,mHit->X(), mHit->Y(), mHit->Z());
+ //printf("Y position: %f\n", mHit->Y());
npoints++;
}
}
fChamber=chamber;
ResetPCerenkovs();
- AliRICH *RICH = (AliRICH*)gAlice->GetDetector("RICH");
+ AliRICH *pRICH = (AliRICH*)gAlice->GetDetector("RICH");
AliRICHChamber* iChamber;
- iChamber = &(RICH->Chamber(chamber-1));
+ iChamber = &(pRICH->Chamber(chamber-1));
- RICH->SetTreeAddress();
+ pRICH->SetTreeAddress();
Int_t ntracks = (Int_t)gAlice->TreeH()->GetEntries();
if (fPCerenkovs == 0) fPCerenkovs = new TObjArray(ntracks);
for (Int_t track=0; track<ntracks;track++) {
gAlice->ResetHits();
gAlice->TreeH()->GetEvent(track);
- TClonesArray *RICHCerenkovs = RICH->Cerenkovs();
- if (RICHCerenkovs == 0) return;
- Int_t nhits = RICHCerenkovs->GetEntriesFast();
+ TClonesArray *pRICHCerenkovs = pRICH->Cerenkovs();
+ if (pRICHCerenkovs == 0) return;
+ Int_t nhits = pRICHCerenkovs->GetEntriesFast();
if (nhits == 0) continue;
AliRICHCerenkov *mCerenkov;
AliRICHPoints *cpoints = 0;
//Display Cerenkov hits in blue
for (Int_t hit=0;hit<nhits;hit++) {
- mCerenkov = (AliRICHCerenkov*)RICHCerenkovs->UncheckedAt(hit);
- (*xp)(npoints)=mCerenkov->fX;
- (*yp)(npoints)=mCerenkov->fY;
- (*zp)(npoints)=mCerenkov->fZ;
+ mCerenkov = (AliRICHCerenkov*)pRICHCerenkovs->UncheckedAt(hit);
+ (*xp)(npoints)=mCerenkov->X();
+ (*yp)(npoints)=mCerenkov->Y();
+ (*zp)(npoints)=mCerenkov->Z();
(*ptrk)(npoints)=Float_t(mCerenkov->GetTrack());
(*phit)(npoints)=Float_t(hit);
npoints++;
//_____________________________________________________________________________
void AliRICHDisplay::SetPickMode()
{
+
+// Toggle pick mode
+
fZoomMode = 0;
fArcButton->SetY1(fPickButton->GetYlowNDC()+0.5*fPickButton->GetHNDC());
//_____________________________________________________________________________
void AliRICHDisplay::SetZoomMode()
{
+
+// Toggle Zoom mode
+
fZoomMode = 1;
fArcButton->SetY1(fZoomButton->GetYlowNDC()+0.5*fZoomButton->GetHNDC());
fChamber = chamber;
fCathode = cathode;
- printf("SetChamberAndCathode - fChamber fCathode %d %d\n",fChamber,fCathode);
+ //printf("SetChamberAndCathode - fChamber fCathode %d %d\n",fChamber,fCathode);
if (!fPad) return;
fPad->Clear();
LoadDigits();
if (delta) {
gAlice->Clear();
- Int_t current_event = gAlice->GetHeader()->GetEvent();
- Int_t new_event = current_event + delta;
- gAlice->GetEvent(new_event);
+ Int_t currentEvent = gAlice->GetHeader()->GetEvent();
+ Int_t newEvent = currentEvent + delta;
+ gAlice->GetEvent(newEvent);
if (!gAlice->TreeD()) return;
}
LoadDigits();
//______________________________________________________________________________
void AliRICHDisplay::UnZoom()
{
+
+// Return to previous zoom factor
+
if (fZooms <= 0) return;
fZooms--;
TPad *pad = (TPad*)gPad->GetPadSave();
if (!view) return;
pad->x3d();
}
-
-
-
-
-ClassImp(AliRICHEllipse)
-
-//________________________________________________________________________________
-AliRICHEllipse::AliRICHEllipse()
-{
- fCx = 0;
- fCy = 0;
- fOmega = 0;
- fTheta = 0;
- fPhi = 0;
- h= 0;
-}
-
-//________________________________________________________________________________
-AliRICHEllipse::~AliRICHEllipse()
-{
- fCx = 0;
- fCy = 0;
- fOmega = 0;
- fTheta = 0;
- fPhi = 0;
- h= 0;
-}
-
-
-//________________________________________________________________________________
-AliRICHEllipse::AliRICHEllipse(Float_t cx, Float_t cy, Float_t omega, Float_t theta, Float_t phi)
-{
- fCx = cx;
- fCy = cy;
- fOmega = omega;
- fTheta = theta;
- fPhi = phi;
- h=11.25;
-}
-
-//________________________________________________________________________________
-void AliRICHEllipse::CreatePoints(Int_t chamber)
-{
- Int_t s1,s2;
- Float_t fiducial=h*TMath::Tan(fOmega+fTheta), l=h/TMath::Cos(fTheta), xtrial, y, c0, c1, c2;
- //TRandom *random=new TRandom();
-
- AliRICH *RICH = (AliRICH*)gAlice->GetModule("RICH");
- AliRICHChamber* iChamber;
-
- iChamber = &(RICH->Chamber(chamber));
- //cout<<"fiducial="<<fiducial<<endl;
-
- for(Float_t i=0;i<1000;i++)
- {
-
- Float_t counter=0;
-
- c0=0;c1=0;c2=0;
- while((c1*c1-4*c2*c0)<=0 && counter<1000)
- {
- //Choose which side to go...
- if(i>250 && i<750) s1=1;
- //if (gRandom->Rndm(1)>.5) s1=1;
- else s1=-1;
- //printf("s1:%d\n",s1);
- //Trial a y
- y=s1*i*gRandom->Rndm(Int_t(fiducial/50));
- //printf("Fiducial %f for omega:%f theta:%f phi:%f\n",fiducial,fOmega,fTheta,fPhi);
- Float_t alfa1=fTheta;
- Float_t theta1=fPhi;
- Float_t OMEGA1=fOmega;
-
- //Solve the eq for a trial x
- c0=-TMath::Power(y*TMath::Cos(alfa1)*TMath::Cos(theta1),2)-TMath::Power(y*TMath::Sin(alfa1),2)+TMath::Power(l*TMath::Tan(OMEGA1),2)+2*l*y*TMath::Cos(alfa1)*TMath::Sin(theta1)*TMath::Power(TMath::Tan(OMEGA1),2)+TMath::Power(y*TMath::Cos(alfa1)*TMath::Sin(theta1)*TMath::Tan(OMEGA1),2);
- c1=2*y*TMath::Cos(alfa1)*TMath::Sin(alfa1)-2*y*TMath::Cos(alfa1)*TMath::Power(TMath::Cos(theta1),2)*TMath::Sin(alfa1)+2*l*TMath::Sin(alfa1)*TMath::Sin(theta1)*TMath::Power(TMath::Tan(OMEGA1),2)+2*y*TMath::Cos(alfa1)*TMath::Sin(alfa1)*TMath::Power(TMath::Sin(theta1),2)*TMath::Power(TMath::Tan(OMEGA1),2);
- c2=-TMath::Power(TMath::Cos(alfa1),2)-TMath::Power(TMath::Cos(theta1)*TMath::Sin(alfa1),2)+TMath::Power(TMath::Sin(alfa1)*TMath::Sin(theta1)*TMath::Tan(OMEGA1),2);
- //cout<<"Trial: y="<<y<<"c0="<<c0<<" c1="<<c1<<" c2="<<c2<<endl;
- //printf("Result:%f\n\n",c1*c1-4*c2*c0);
- //i+=.01;
- counter +=1;
- }
-
- if (counter>=1000)
- y=0;
-
- //Choose which side to go...
- //if(gRandom->Rndm(1)>.5) s=1;
- //else s=-1;
- if(i>500) s2=1;
- //if (gRandom->Rndm(1)>.5) s2=1;
- else s2=-1;
- xtrial=fCx+(-c1+s2*TMath::Sqrt(c1*c1-4*c2*c0))/(2*c2);
- //cout<<"x="<<xtrial<<" y="<<cy+y<<endl;
- //printf("Coordinates: %f %f\n",xtrial,fCy+y);
-
- Float_t VecLoc[3]={xtrial,6.276,(fCy+y)};
- Float_t VecGlob[3];
- iChamber->LocaltoGlobal(VecLoc,VecGlob);
- SetPoint(i,VecGlob[0],VecGlob[1],VecGlob[2]);
- //printf("Coordinates: %f %f %f\n",VecGlob[0],VecGlob[1],VecGlob[2]);
- }
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff