MinosEventDisplay Class Reference

#include <MinosEventDisplay.h>

List of all members.

Public Member Functions

 MinosEventDisplay (int mode, bool mc)
void Draw (const MinosEvent &event)
void Draw (const MinosCompactEvent *eventA, Float_t min_qpe=0.0)
void Draw (const MinosCompactEvent *eventA, const MinosCompactEvent *eventB, int, int, int)
void Draw (const MinosCompactEvent *eventA, const MinosCompactEvent *eventB, comparisonResult_h resultB, const MinosCompactEvent *eventC, comparisonResult_h resultC)
void Print ()

Private Attributes

TCanvas * fCanvas
int fPlaneMax
int fPlaneMin
int fUStripMax
int fUStripMin
int fVStripMax
int fVStripMin
TH2F * fUZAxis
TH2F * fVZAxis
TH2F * fXYAxis
TH2F * fUZAxisB
TH2F * fVZAxisB
TH2F * fXYAxisB
TH2F * fUZAxisC
TH2F * fVZAxisC
TH2F * fXYAxisC
vector< TMarker > fUZview
vector< TMarker > fVZview
vector< TMarker > fUZviewB
vector< TMarker > fVZviewB
int fMode
TApplication * theApp

Detailed Description

Definition at line 17 of file MinosEventDisplay.h.


Constructor & Destructor Documentation

MinosEventDisplay::MinosEventDisplay ( int  mode,
bool  mc 
)

Definition at line 20 of file MinosEventDisplay.cxx.

References fCanvas, fUZAxis, fUZAxisB, fUZAxisC, fVZAxis, fVZAxisB, fVZAxisC, and theApp.

00021 {
00022 
00023   int argc = 0;
00024   char* argv;
00025  
00026   theApp = new TApplication("bob",&argc,&argv);
00027   theApp->SetReturnFromRun(kTRUE);
00028   gStyle->SetCanvasColor(10);
00029   gStyle->SetPadColor(10);
00030   gStyle->SetStatColor(10);
00031   gStyle->SetTitleColor(1);
00032   gStyle->SetOptFit();
00033   gStyle->SetFillColor(10);
00034   //      gStyle->SetPadGridX(0);
00035   //      gStyle->SetPadGridY(0);
00036   gStyle->SetFrameLineWidth(2);
00037   gStyle->SetHistLineWidth(2);
00038   gStyle->SetLabelFont(12, "X");
00039   gStyle->SetLabelFont(12, "Y");
00040   gStyle->SetTitleFont(62, "X");
00041   gStyle->SetTitleFont(62, "Y");  
00042   gStyle->SetTitleFont(62, "H");
00043   gStyle->SetTitleBorderSize(0);
00044   gStyle->SetTitleFillColor(10);
00045   gStyle->SetTitleOffset(1.3,"Y");
00046   gStyle->SetPadBottomMargin(1.7);
00047   gStyle->SetPadLeftMargin(1.2);
00048   gStyle->SetPalette(1);
00049   
00050   gStyle->SetStatBorderSize(0);
00051   gStyle->SetStatFont(40);
00052   gStyle->SetStatX(0.88);
00053   gStyle->SetStatY(0.875);
00054   
00055   fCanvas = new TCanvas("EventCanvas", "event", 1300, 600);
00056 
00057   fUZAxis  = new TH2F("UZAxis ", "U Planes",903, -0.5, 300.5, 193, -0.5, 192.5);  
00058   fVZAxis  = new TH2F("VZAxis ", "V Planes",903, -0.5, 300.5, 193, -0.5, 192.5);  
00059   fUZAxis->SetStats(0);
00060   fVZAxis->SetStats(0);
00061   fUZAxis->SetXTitle("z position (plane)");
00062   fVZAxis->SetXTitle("z position (plane)");
00063   fUZAxis->SetYTitle("transverse position (strip)");
00064   fVZAxis->SetYTitle("transverse position (strip)");
00065 
00066   fUZAxisB = new TH2F("UZAxisB", "U Planes",903, -0.5, 300.5, 193, -0.5, 192.5);  
00067   fVZAxisB = new TH2F("VZAxisB", "V Planes",903, -0.5, 300.5, 193, -0.5, 192.5);  
00068   fUZAxisB->SetStats(0);
00069   fVZAxisB->SetStats(0);
00070   fUZAxisB->SetXTitle("z position (plane #)");
00071   fVZAxisB->SetXTitle("z position (plane #)");
00072   fUZAxisB->SetYTitle("transverse position (strip)");
00073   fVZAxisB->SetYTitle("transverse position (strip)");
00074 
00075   fUZAxisC = new TH2F("UZAxisC", "U Planes",903, -0.5, 300.5, 193, -0.5, 192.5);  
00076   fVZAxisC = new TH2F("VZAxisC", "V Planes",903, -0.5, 300.5, 193, -0.5, 192.5);  
00077   fUZAxisC->SetStats(0);
00078   fVZAxisC->SetStats(0);
00079   fUZAxisC->SetXTitle("z position (plane #)");
00080   fVZAxisC->SetXTitle("z position (plane #)");
00081   fUZAxisC->SetYTitle("transverse position (strip)");
00082   fVZAxisC->SetYTitle("transverse position (strip)");
00083 
00084   fCanvas->Draw();
00085 
00086 }


Member Function Documentation

void MinosEventDisplay::Draw ( const MinosCompactEvent eventA,
const MinosCompactEvent eventB,
comparisonResult_h  resultB,
const MinosCompactEvent eventC,
comparisonResult_h  resultC 
)

Definition at line 372 of file MinosEventDisplay.cxx.

References MinosCompactEvent::chargeScale, fCanvas, fPlaneMax, fPlaneMin, fUStripMax, fUStripMin, fUZAxis, fUZAxisB, fUZAxisC, fVStripMax, fVStripMin, fVZAxis, fVZAxisB, fVZAxisC, MAX_QPE, comparisonResult_h::planeOffset, comparisonResult_h::stripOffsetU, comparisonResult_h::stripOffsetV, MinosCompactEvent::UStrips, and MinosCompactEvent::VStrips.

00373 {
00374   
00375   fCanvas->Clear();
00376   fUZAxis->Reset();
00377   fVZAxis->Reset();
00378   fUZAxisB->Reset();
00379   fVZAxisB->Reset();
00380   fUZAxisC->Reset();
00381   fVZAxisC->Reset();
00382   fUZAxis->Fill(1.,1.,MAX_QPE);
00383   fVZAxis->Fill(1.,1.,MAX_QPE);
00384   fUZAxisB->Fill(1.,1.,MAX_QPE);
00385   fVZAxisB->Fill(1.,1.,MAX_QPE);
00386   fUZAxisC->Fill(1.,1.,MAX_QPE);
00387   fVZAxisC->Fill(1.,1.,MAX_QPE);
00388   fUZAxis->SetMaximum(MAX_QPE);
00389   fVZAxis->SetMaximum(MAX_QPE);
00390   fUZAxisB->SetMaximum(MAX_QPE);
00391   fVZAxisB->SetMaximum(MAX_QPE);
00392   fUZAxisC->SetMaximum(MAX_QPE);
00393   fVZAxisC->SetMaximum(MAX_QPE);
00394 
00395   fCanvas->Divide(3,2);
00396   
00397   fPlaneMin = 500;
00398   fPlaneMax = 0;
00399   fUStripMin = 192;
00400   fUStripMax = 0;
00401   fVStripMin = 192;
00402   fVStripMax = 0;
00403 
00404   float chargeScale = eventA->chargeScale;
00405   bool UOddA = true;
00406   bool UOddB = true;
00407   bool UOddC = true;
00408  
00409 
00410   // loop over the U strips
00411   int nustrips = eventA->UStrips.size();
00412   for(int istp = 0; istp< nustrips; istp++){
00413     int plane = eventA->UStrips[istp].plane;
00414     int strip = eventA->UStrips[istp].strip;
00415     if(plane%2==0)UOddA=false;
00416     float qpe = static_cast<float>(eventA->UStrips[istp].icharge)/chargeScale;
00417     if(qpe>MAX_QPE)qpe=MAX_QPE;
00418     if(plane>fPlaneMax) fPlaneMax = plane;
00419     if(plane<fPlaneMin) fPlaneMin = plane; 
00420     if(strip>fUStripMax) fUStripMax = strip;
00421     if(strip<fUStripMin) fUStripMin = strip;      
00422     fUZAxis->Fill( (float)plane,(float)strip, qpe);
00423   }
00424 
00425   // loop over the V strips
00426   int nvstrips = eventA->VStrips.size();
00427   for(int istp = 0; istp< nvstrips; istp++){
00428     int plane = eventA->VStrips[istp].plane;
00429     int strip = eventA->VStrips[istp].strip;
00430     float qpe = static_cast<float>(eventA->VStrips[istp].icharge)/chargeScale;
00431     if(qpe>MAX_QPE)qpe=MAX_QPE;
00432     if(plane>fPlaneMax) fPlaneMax = plane;
00433     if(plane<fPlaneMin) fPlaneMin = plane;      
00434     if(strip>fVStripMax) fVStripMax = strip;
00435     if(strip<fVStripMin) fVStripMin = strip;      
00436     fVZAxis->Fill( (float)plane,(float)strip, qpe);
00437   }
00438 
00439 
00440 
00441   // loop over the U strips
00442   nustrips = eventB->UStrips.size();
00443   for(int istp = 0; istp< nustrips; istp++){
00444     int plane = eventB->UStrips[istp].plane-resultB.planeOffset;
00445     int strip = eventB->UStrips[istp].strip-resultB.stripOffsetU;
00446     if(plane%2==0)UOddB=false;
00447     float qpe = static_cast<float>(eventB->UStrips[istp].icharge)/chargeScale;
00448     if(qpe>MAX_QPE)qpe=MAX_QPE;
00449     if(plane>fPlaneMax) fPlaneMax = plane;
00450     if(plane<fPlaneMin) fPlaneMin = plane; 
00451     if(UOddB==UOddA){
00452       if(strip>fUStripMax) fUStripMax = strip;
00453       if(strip<fUStripMin) fUStripMin = strip;
00454     }else{
00455       if(strip>fVStripMax) fVStripMax = strip;
00456       if(strip<fVStripMin) fVStripMin = strip;
00457     }      
00458     fUZAxisB->Fill( (float)plane,(float)strip, qpe);
00459   }
00460 
00461   // loop over the V strips
00462   nvstrips = eventB->VStrips.size();
00463   for(int istp = 0; istp< nvstrips; istp++){
00464     int plane = eventB->VStrips[istp].plane-resultB.planeOffset;
00465     int strip = eventB->VStrips[istp].strip-resultB.stripOffsetV;
00466     float qpe = static_cast<float>(eventB->VStrips[istp].icharge)/chargeScale;
00467     if(qpe>MAX_QPE)qpe=MAX_QPE;
00468     if(plane>fPlaneMax) fPlaneMax = plane;
00469     if(plane<fPlaneMin) fPlaneMin = plane;      
00470     if(UOddB==UOddA){
00471       if(strip>fVStripMax) fVStripMax = strip;
00472       if(strip<fVStripMin) fVStripMin = strip;      
00473     }else{
00474       if(strip>fUStripMax) fUStripMax = strip;
00475       if(strip<fUStripMin) fUStripMin = strip;
00476     }
00477     fVZAxisB->Fill( (float)plane,(float)strip, qpe);
00478   }
00479 
00480 
00481 
00482 
00483 
00484 
00485   // loop over the U strips
00486   nustrips = eventC->UStrips.size();
00487   for(int istp = 0; istp< nustrips; istp++){
00488     int plane = eventC->UStrips[istp].plane-resultC.planeOffset;
00489     int strip = eventC->UStrips[istp].strip-resultC.stripOffsetU;
00490     if(plane%2==0)UOddC=false;
00491     float qpe = static_cast<float>(eventC->UStrips[istp].icharge)/chargeScale;
00492     if(qpe>MAX_QPE)qpe=MAX_QPE;
00493     if(plane>fPlaneMax) fPlaneMax = plane;
00494     if(plane<fPlaneMin) fPlaneMin = plane; 
00495     if(UOddC==UOddA){
00496       if(strip>fUStripMax) fUStripMax = strip;
00497       if(strip<fUStripMin) fUStripMin = strip;
00498     }else{
00499       if(strip>fVStripMax) fVStripMax = strip;
00500       if(strip<fVStripMin) fVStripMin = strip;
00501     }      
00502     fUZAxisC->Fill( (float)plane,(float)strip, qpe);
00503   }
00504 
00505   // loop over the V strips
00506   nvstrips = eventC->VStrips.size();
00507   for(int istp = 0; istp< nvstrips; istp++){
00508     int plane = eventC->VStrips[istp].plane-resultC.planeOffset;
00509     int strip = eventC->VStrips[istp].strip-resultC.stripOffsetV;
00510     float qpe = static_cast<float>(eventC->VStrips[istp].icharge)/chargeScale;
00511     if(qpe>MAX_QPE)qpe=MAX_QPE;
00512     if(plane>fPlaneMax) fPlaneMax = plane;
00513     if(plane<fPlaneMin) fPlaneMin = plane;      
00514     if(UOddC==UOddA){
00515       if(strip>fVStripMax) fVStripMax = strip;
00516       if(strip<fVStripMin) fVStripMin = strip;      
00517     }else{
00518       if(strip>fUStripMax) fUStripMax = strip;
00519       if(strip<fUStripMin) fUStripMin = strip;
00520     }
00521     fVZAxisC->Fill( (float)plane,(float)strip, qpe);
00522   }
00523 
00524 
00525   // Draw the UZ view
00526   fCanvas->cd(1);
00527   fUZAxis->GetXaxis()->SetRangeUser(fPlaneMin-1, fPlaneMax+1);
00528   fUZAxis->GetYaxis()->SetRangeUser(fUStripMin-1, fUStripMax+1);
00529   fUZAxis->Draw("colz");
00530 
00531   // Draw the VZ view
00532   fCanvas->cd(4);
00533   fVZAxis->GetXaxis()->SetRangeUser(fPlaneMin-1, fPlaneMax+1);
00534   fVZAxis->GetYaxis()->SetRangeUser(fVStripMin-1, fVStripMax+1);
00535   fVZAxis->Draw("colz");
00536 
00537   // Draw the UZ view
00538   if(UOddA==UOddB){
00539     fCanvas->cd(2);
00540     fUZAxisB->GetYaxis()->SetRangeUser(fUStripMin-1, fUStripMax+1);
00541   }
00542   if(UOddA!=UOddB){
00543     fCanvas->cd(5);
00544     fUZAxisB->GetYaxis()->SetRangeUser(fVStripMin-1, fVStripMax+1);
00545   }
00546   fUZAxisB->GetXaxis()->SetRangeUser(fPlaneMin-1, fPlaneMax+1);
00547   fUZAxisB->Draw("colz");
00548 
00549   // Draw the VZ view
00550   if(UOddA==UOddB){
00551     fCanvas->cd(5);
00552     fVZAxisB->GetYaxis()->SetRangeUser(fVStripMin-1, fVStripMax+1);
00553   }
00554   if(UOddA!=UOddB){
00555     fCanvas->cd(2);
00556     fVZAxisB->GetYaxis()->SetRangeUser(fUStripMin-1, fUStripMax+1);
00557   }
00558   fVZAxisB->GetXaxis()->SetRangeUser(fPlaneMin-1, fPlaneMax+1);
00559   fVZAxisB->Draw("colz");
00560 
00561 
00562   // Draw the UZ view
00563   if(UOddA==UOddC){
00564     fCanvas->cd(3);
00565     fUZAxisC->GetYaxis()->SetRangeUser(fUStripMin-1, fUStripMax+1);
00566   }
00567   if(UOddA!=UOddC){
00568     fCanvas->cd(6);
00569     fUZAxisC->GetYaxis()->SetRangeUser(fVStripMin-1, fVStripMax+1);
00570   }
00571   fUZAxisC->GetXaxis()->SetRangeUser(fPlaneMin-1, fPlaneMax+1);
00572   fUZAxisC->Draw("colz");
00573 
00574   // Draw the VZ view
00575   if(UOddA==UOddC){
00576     fCanvas->cd(6);
00577     fVZAxisC->GetYaxis()->SetRangeUser(fVStripMin-1, fVStripMax+1);
00578   }
00579   if(UOddA!=UOddC){
00580     fCanvas->cd(3);
00581     fVZAxisC->GetYaxis()->SetRangeUser(fUStripMin-1, fUStripMax+1);
00582   }
00583   fVZAxisC->GetXaxis()->SetRangeUser(fPlaneMin-1, fPlaneMax+1);
00584   fVZAxisC->Draw("colz");
00585 
00586 
00587   fCanvas->cd(0);
00588   fCanvas->Update();
00589   fCanvas->Draw();
00590   fCanvas->SaveAs("Event.gif");
00591   getchar();
00592 
00593   
00594 }

void MinosEventDisplay::Draw ( const MinosCompactEvent eventA,
const MinosCompactEvent eventB,
int  isU,
int  isV,
int  ip 
)

Definition at line 220 of file MinosEventDisplay.cxx.

References MinosCompactEvent::chargeScale, fCanvas, fPlaneMax, fPlaneMin, fUStripMax, fUStripMin, fUZAxis, fUZAxisB, fVStripMax, fVStripMin, fVZAxis, fVZAxisB, MAX_QPE, MinosCompactEvent::UStrips, and MinosCompactEvent::VStrips.

00221 {
00222   fCanvas->Clear();
00223   fUZAxis->Reset();
00224   fVZAxis->Reset();
00225   fUZAxisB->Reset();
00226   fVZAxisB->Reset();
00227   fUZAxis->Fill(1.,1.,MAX_QPE);
00228   fVZAxis->Fill(1.,1.,MAX_QPE);
00229   fUZAxisB->Fill(1.,1.,MAX_QPE);
00230   fVZAxisB->Fill(1.,1.,MAX_QPE);
00231   fUZAxis->SetMaximum(MAX_QPE);
00232   fVZAxis->SetMaximum(MAX_QPE);
00233   fUZAxisB->SetMaximum(MAX_QPE);
00234   fVZAxisB->SetMaximum(MAX_QPE);
00235 
00236   fCanvas->Divide(2,2);
00237   
00238   fPlaneMin = 500;
00239   fPlaneMax = 0;
00240   fUStripMin = 192;
00241   fUStripMax = 0;
00242   fVStripMin = 192;
00243   fVStripMax = 0;
00244 
00245   float chargeScale = eventA->chargeScale;
00246   bool UOddA = true;
00247   bool UOddB = true;
00248  
00249 
00250   // loop over the U strips
00251   int nustrips = eventA->UStrips.size();
00252   for(int istp = 0; istp< nustrips; istp++){
00253     int plane = eventA->UStrips[istp].plane;
00254     int strip = eventA->UStrips[istp].strip;
00255     if(plane%2==0)UOddA=false;
00256     float qpe = static_cast<float>(eventA->UStrips[istp].icharge)/chargeScale;
00257     if(qpe>MAX_QPE)qpe=MAX_QPE;
00258     if(plane>fPlaneMax) fPlaneMax = plane;
00259     if(plane<fPlaneMin) fPlaneMin = plane; 
00260     if(strip>fUStripMax) fUStripMax = strip;
00261     if(strip<fUStripMin) fUStripMin = strip;      
00262     fUZAxis->Fill( (float)plane,(float)strip, qpe);
00263   }
00264 
00265   // loop over the V strips
00266   int nvstrips = eventA->VStrips.size();
00267   for(int istp = 0; istp< nvstrips; istp++){
00268     int plane = eventA->VStrips[istp].plane;
00269     int strip = eventA->VStrips[istp].strip;
00270     float qpe = static_cast<float>(eventA->VStrips[istp].icharge)/chargeScale;
00271     if(qpe>MAX_QPE)qpe=MAX_QPE;
00272     if(plane>fPlaneMax) fPlaneMax = plane;
00273     if(plane<fPlaneMin) fPlaneMin = plane;      
00274     if(strip>fVStripMax) fVStripMax = strip;
00275     if(strip<fVStripMin) fVStripMin = strip;      
00276     fVZAxis->Fill( (float)plane,(float)strip, qpe);
00277   }
00278 
00279 
00280 
00281   // loop over the U strips
00282   nustrips = eventB->UStrips.size();
00283   for(int istp = 0; istp< nustrips; istp++){
00284     int plane = eventB->UStrips[istp].plane-ip;
00285     int strip = eventB->UStrips[istp].strip-isU;
00286     if(plane%2==0)UOddB=false;
00287     float qpe = static_cast<float>(eventB->UStrips[istp].icharge)/chargeScale;
00288     if(qpe>MAX_QPE)qpe=MAX_QPE;
00289     if(plane>fPlaneMax) fPlaneMax = plane;
00290     if(plane<fPlaneMin) fPlaneMin = plane; 
00291     if(UOddB==UOddA){
00292       if(strip>fUStripMax) fUStripMax = strip;
00293       if(strip<fUStripMin) fUStripMin = strip;
00294     }else{
00295       if(strip>fVStripMax) fVStripMax = strip;
00296       if(strip<fVStripMin) fVStripMin = strip;
00297     }      
00298     fUZAxisB->Fill( (float)plane,(float)strip, qpe);
00299   }
00300 
00301   // loop over the V strips
00302   nvstrips = eventB->VStrips.size();
00303   for(int istp = 0; istp< nvstrips; istp++){
00304     int plane = eventB->VStrips[istp].plane-ip;
00305     int strip = eventB->VStrips[istp].strip-isV;
00306     float qpe = static_cast<float>(eventB->VStrips[istp].icharge)/chargeScale;
00307     if(qpe>MAX_QPE)qpe=MAX_QPE;
00308     if(plane>fPlaneMax) fPlaneMax = plane;
00309     if(plane<fPlaneMin) fPlaneMin = plane;      
00310     if(UOddB==UOddA){
00311       if(strip>fVStripMax) fVStripMax = strip;
00312       if(strip<fVStripMin) fVStripMin = strip;      
00313     }else{
00314       if(strip>fUStripMax) fUStripMax = strip;
00315       if(strip<fUStripMin) fUStripMin = strip;
00316     }
00317     fVZAxisB->Fill( (float)plane,(float)strip, qpe);
00318   }
00319 
00320 
00321   // Draw the UZ view
00322   fCanvas->cd(1);
00323   fUZAxis->GetXaxis()->SetRangeUser(fPlaneMin-1, fPlaneMax+1);
00324   fUZAxis->GetYaxis()->SetRangeUser(fUStripMin-1, fUStripMax+1);
00325   fUZAxis->Draw("colz");
00326 
00327   // Draw the VZ view
00328   fCanvas->cd(3);
00329   fVZAxis->GetXaxis()->SetRangeUser(fPlaneMin-1, fPlaneMax+1);
00330   fVZAxis->GetYaxis()->SetRangeUser(fVStripMin-1, fVStripMax+1);
00331   fVZAxis->Draw("colz");
00332 
00333 
00334 
00335 
00336 
00337   // Draw the UZ view
00338   if(UOddA==UOddB){
00339     fCanvas->cd(2);
00340     fUZAxisB->GetYaxis()->SetRangeUser(fUStripMin-1, fUStripMax+1);
00341   }
00342   if(UOddA!=UOddB){
00343     fCanvas->cd(4);
00344     fUZAxisB->GetYaxis()->SetRangeUser(fVStripMin-1, fVStripMax+1);
00345   }
00346   fUZAxisB->GetXaxis()->SetRangeUser(fPlaneMin-1, fPlaneMax+1);
00347   fUZAxisB->Draw("colz");
00348 
00349   // Draw the VZ view
00350   if(UOddA==UOddB){
00351     fCanvas->cd(4);
00352     fVZAxisB->GetYaxis()->SetRangeUser(fVStripMin-1, fVStripMax+1);
00353   }
00354   if(UOddA!=UOddB){
00355     fCanvas->cd(2);
00356     fVZAxisB->GetYaxis()->SetRangeUser(fUStripMin-1, fUStripMax+1);
00357   }
00358   fVZAxisB->GetXaxis()->SetRangeUser(fPlaneMin-1, fPlaneMax+1);
00359   fVZAxisB->Draw("colz");
00360 
00361   fCanvas->cd(0);
00362   fCanvas->Update();
00363   fCanvas->Draw();
00364   getchar();
00365   
00366 }

void MinosEventDisplay::Draw ( const MinosCompactEvent eventA,
Float_t  min_qpe = 0.0 
)

Definition at line 136 of file MinosEventDisplay.cxx.

References fCanvas, fPlaneMax, fPlaneMin, fUStripMax, fUStripMin, fUZAxis, fVStripMax, fVStripMin, fVZAxis, and MAX_QPE.

00137 {
00138   fCanvas->Clear();
00139   fUZAxis->Reset();
00140   fVZAxis->Reset();
00141   fUZAxis->Fill(1.,1.,MAX_QPE);
00142   fVZAxis->Fill(1.,1.,MAX_QPE);
00143   fUZAxis->SetMaximum(MAX_QPE);
00144   fVZAxis->SetMaximum(MAX_QPE);
00145 
00146   fCanvas->Divide(2,1);
00147   
00148   fPlaneMin = 500;
00149   fPlaneMax = 0;
00150   fUStripMin = 192;
00151   fUStripMax = 0;
00152   fVStripMin = 192;
00153   fVStripMax = 0;
00154 
00155   float chargeScale = event->chargeScale;
00156 
00157   // loop over the U strips
00158   const int nustrips = event->UStrips.size();
00159   for(int istp = 0; istp< nustrips; istp++){
00160     int plane = event->UStrips[istp].plane;
00161     int strip = event->UStrips[istp].strip;
00162     float qpe = static_cast<float>(event->UStrips[istp].icharge)/chargeScale;
00163     if(qpe>MAX_QPE)qpe=MAX_QPE;
00164     if(plane>fPlaneMax) fPlaneMax = plane;
00165     if(plane<fPlaneMin) fPlaneMin = plane; 
00166     if(strip>fUStripMax) fUStripMax = strip;
00167     if(strip<fUStripMin) fUStripMin = strip;   
00168     if(qpe>min_qpe){
00169       fUZAxis->Fill( (float)plane,(float)strip, qpe);
00170     }
00171 
00172   }
00173 
00174   // loop over the V strips
00175   const int nvstrips = event->VStrips.size();
00176   for(int istp = 0; istp< nvstrips; istp++){
00177     int plane = event->VStrips[istp].plane;
00178     int strip = event->VStrips[istp].strip;
00179     float qpe = static_cast<float>(event->VStrips[istp].icharge)/chargeScale;
00180     if(qpe>MAX_QPE)qpe=MAX_QPE;
00181     if(plane>fPlaneMax) fPlaneMax = plane;
00182     if(plane<fPlaneMin) fPlaneMin = plane;      
00183     if(strip>fVStripMax) fVStripMax = strip;
00184     if(strip<fVStripMin) fVStripMin = strip;   
00185     if(qpe>min_qpe){
00186       fVZAxis->Fill( (float)plane,(float)strip, qpe);
00187     }
00188   }
00189 
00190 
00191   // Draw the UZ view
00192   fCanvas->cd(1);
00193   fUZAxis->GetXaxis()->SetRangeUser(fPlaneMin-2, fPlaneMax+2);
00194   fUZAxis->GetYaxis()->SetRangeUser(fUStripMin-2, fUStripMax+2);
00195   fUZAxis->Draw("colz");
00196 
00197   // Draw the VZ view
00198   fCanvas->cd(2);
00199   fVZAxis->GetXaxis()->SetRangeUser(fPlaneMin-2, fPlaneMax+2);
00200   fVZAxis->GetYaxis()->SetRangeUser(fVStripMin-2, fVStripMax+2);
00201   fVZAxis->Draw("colz");
00202   fCanvas->Update();
00203   fCanvas->Draw();
00204   getchar();
00205 
00206   //Log scale
00207   fCanvas->cd(1)->SetLogz(0);
00208   fCanvas->cd(2)->SetLogz(0);
00209   fCanvas->Draw();
00210   
00211   fCanvas->cd();
00212 
00213 }

void MinosEventDisplay::Draw ( const MinosEvent event  ) 

Definition at line 88 of file MinosEventDisplay.cxx.

References fCanvas, fPlaneMax, fPlaneMin, fUZAxis, fUZview, fVZAxis, fVZview, MAX_QPE, MinosStrip::Plane, MinosStrip::Qadc, and MinosEvent::StripList.

00089 {
00090   fCanvas->Clear();
00091   fUZAxis->Reset();
00092   fVZAxis->Reset();
00093   fUZAxis->Fill(1.,1.,MAX_QPE);
00094   fVZAxis->Fill(1.,1.,MAX_QPE);
00095   fUZAxis->SetMaximum(MAX_QPE);
00096   fVZAxis->SetMaximum(MAX_QPE);
00097   fCanvas->Divide(2,1);
00098   
00099   fPlaneMin = 500;
00100   fPlaneMax = 0;
00101 
00102 
00103   // loop over the strips
00104   const int nstrips = (int)(event.StripList->GetEntries());
00105   for(int istp = 0; istp< nstrips; istp++){
00106     const MinosStrip* strip = dynamic_cast<const MinosStrip*>(event.StripList->At(istp));
00107     assert(strip);
00108     float qpe = strip->Qadc[0]+strip->Qadc[1];
00109     if(qpe>MAX_QPE)qpe=MAX_QPE;
00110     if(strip->Plane>fPlaneMax) fPlaneMax = strip->Plane;
00111     if(strip->Plane<fPlaneMin) fPlaneMin = strip->Plane;      
00112   }
00113 
00114   // Draw the UZ view
00115   fCanvas->cd(1);
00116   fUZAxis->GetXaxis()->SetRangeUser(fPlaneMin-2, fPlaneMax+2);
00117   fUZAxis->Draw();
00118   for(unsigned int i=0; i<fUZview.size(); ++i)fUZview[i].Draw();
00119   
00120   // Draw the VZ view
00121   fCanvas->cd(2);
00122   fVZAxis->GetXaxis()->SetRangeUser(fPlaneMin-2, fPlaneMax+2);
00123   fVZAxis->Draw();
00124   for(unsigned int i=0; i<fVZview.size(); ++i)fVZview[i].Draw();
00125   fCanvas->Update();
00126   fCanvas->Draw();
00127   getchar();
00128 
00129   fCanvas->cd();
00130 
00131 }

void MinosEventDisplay::Print (  )  [inline]

Definition at line 24 of file MinosEventDisplay.h.

References fCanvas.

00024 {fCanvas->Print("event.eps");}


Member Data Documentation

TCanvas* MinosEventDisplay::fCanvas [private]

Definition at line 26 of file MinosEventDisplay.h.

Referenced by Draw(), MinosEventDisplay(), and Print().

int MinosEventDisplay::fMode [private]

Definition at line 53 of file MinosEventDisplay.h.

Definition at line 29 of file MinosEventDisplay.h.

Referenced by Draw().

Definition at line 30 of file MinosEventDisplay.h.

Referenced by Draw().

Definition at line 31 of file MinosEventDisplay.h.

Referenced by Draw().

Definition at line 32 of file MinosEventDisplay.h.

Referenced by Draw().

TH2F* MinosEventDisplay::fUZAxis [private]

Definition at line 36 of file MinosEventDisplay.h.

Referenced by Draw(), and MinosEventDisplay().

TH2F* MinosEventDisplay::fUZAxisB [private]

Definition at line 39 of file MinosEventDisplay.h.

Referenced by Draw(), and MinosEventDisplay().

TH2F* MinosEventDisplay::fUZAxisC [private]

Definition at line 42 of file MinosEventDisplay.h.

Referenced by Draw(), and MinosEventDisplay().

vector<TMarker> MinosEventDisplay::fUZview [private]

Definition at line 46 of file MinosEventDisplay.h.

Referenced by Draw().

vector<TMarker> MinosEventDisplay::fUZviewB [private]

Definition at line 49 of file MinosEventDisplay.h.

Definition at line 33 of file MinosEventDisplay.h.

Referenced by Draw().

Definition at line 34 of file MinosEventDisplay.h.

Referenced by Draw().

TH2F* MinosEventDisplay::fVZAxis [private]

Definition at line 37 of file MinosEventDisplay.h.

Referenced by Draw(), and MinosEventDisplay().

TH2F* MinosEventDisplay::fVZAxisB [private]

Definition at line 40 of file MinosEventDisplay.h.

Referenced by Draw(), and MinosEventDisplay().

TH2F* MinosEventDisplay::fVZAxisC [private]

Definition at line 43 of file MinosEventDisplay.h.

Referenced by Draw(), and MinosEventDisplay().

vector<TMarker> MinosEventDisplay::fVZview [private]

Definition at line 47 of file MinosEventDisplay.h.

Referenced by Draw().

vector<TMarker> MinosEventDisplay::fVZviewB [private]

Definition at line 50 of file MinosEventDisplay.h.

TH2F* MinosEventDisplay::fXYAxis [private]

Definition at line 38 of file MinosEventDisplay.h.

TH2F* MinosEventDisplay::fXYAxisB [private]

Definition at line 41 of file MinosEventDisplay.h.

TH2F* MinosEventDisplay::fXYAxisC [private]

Definition at line 44 of file MinosEventDisplay.h.

TApplication* MinosEventDisplay::theApp [private]

Definition at line 54 of file MinosEventDisplay.h.

Referenced by MinosEventDisplay().


The documentation for this class was generated from the following files:

Generated on 2 Nov 2017 for loon by  doxygen 1.6.1