Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

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

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  ,
int  ,
int 
) 
 

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 MinosCompactEvent::chargeScale, fCanvas, fPlaneMax, fPlaneMin, fUStripMax, fUStripMin, fUZAxis, fVStripMax, fVStripMin, fVZAxis, MAX_QPE, MinosCompactEvent::UStrips, and MinosCompactEvent::VStrips.

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.

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

Member Data Documentation

TCanvas* MinosEventDisplay::fCanvas [private]
 

Definition at line 26 of file MinosEventDisplay.h.

Referenced by Draw(), and MinosEventDisplay().

int MinosEventDisplay::fMode [private]
 

Definition at line 53 of file MinosEventDisplay.h.

int MinosEventDisplay::fPlaneMax [private]
 

Definition at line 29 of file MinosEventDisplay.h.

Referenced by Draw().

int MinosEventDisplay::fPlaneMin [private]
 

Definition at line 30 of file MinosEventDisplay.h.

Referenced by Draw().

int MinosEventDisplay::fUStripMax [private]
 

Definition at line 31 of file MinosEventDisplay.h.

Referenced by Draw().

int MinosEventDisplay::fUStripMin [private]
 

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.

int MinosEventDisplay::fVStripMax [private]
 

Definition at line 33 of file MinosEventDisplay.h.

Referenced by Draw().

int MinosEventDisplay::fVStripMin [private]
 

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 Mon Feb 15 11:09:36 2010 for loon by  doxygen 1.3.9.1