MadEvDisplay Class Reference

#include <MadEvDisplay.h>

Inheritance diagram for MadEvDisplay:
MadBase MadHandScan

List of all members.

Public Member Functions

 MadEvDisplay (TChain *chainSR=0, TChain *chainMC=0, TChain *chainTH=0, TChain *chainem=0)
 MadEvDisplay (JobC *, string, int)
virtual ~MadEvDisplay ()
Int_t NextPass ()
Int_t PrevPass ()
Int_t SkipTo ()
Int_t JumpTo ()
Bool_t Display (Int_t entry=0, Int_t theSlice=0, Int_t theEvent=0, Int_t theMCevent=0, Bool_t automat=true)
void SetDVals (Float_t, Float_t)
void PrintDisplay ()
void SetPrintOpt (char *opt)
void SetMessages (Bool_t yesno=true)
virtual Bool_t PassCuts ()
void DrawButtons (TCanvas *)
void DrawTextBox (TCanvas *, Bool_t)
void DrawInteractionDiagram (Int_t itr=0)
void EventDump ()
Float_t RecoMKMuEnergy (Int_t &opt, Int_t itrk, bool isdata=true)
Float_t RecoMuDCosNeuND (Int_t itr=0, Float_t *vtx=0)
Float_t RecoMuDCosNeuFD (Int_t itr=0, Float_t *vtx=0)
void StartLogger ()
void Log ()
void EnableHandScan (char *)
void ChangeLogButColor ()
void PrintHSHelp ()
void SetDefaultShowerMarkerColor (Int_t col)
void SetDefaultShowerMarkerStyle (Int_t style)
bool ReadEventsFile (const char *filename)
Int_t NextInterestingEvent (bool backward=false)

Public Attributes

Int_t LeNu
Int_t LeAction
Bool_t LeLego
Bool_t LeClus
Int_t LeEvent
Int_t LeSlice
Int_t LeMCevent
Int_t LeEntry
Bool_t UseNuInfo
Bool_t LeAutoMat
Bool_t drawSAME
Bool_t handScan
Int_t ScanID
Int_t ScanTop
char logFileName [256]

Protected Member Functions

Int_t * Dec2Bin (Int_t)
void DrawKey (TVirtualPad *)
void DrawKey2 (TVirtualPad *)

Protected Attributes

char printName [100]
char printOpt [10]
Float_t Dspe_val
Float_t Dmid_val
Bool_t ptt_msg

Private Attributes

std::vector< std::vector< Int_t > > fNeatoEvents
bool fHaveNeatoEvents
Int_t fNeatoEventIdx
Int_t fDefaultShowerMarkerColor
Int_t fDefaultShowerMarkerStyle

Detailed Description

Definition at line 8 of file MadEvDisplay.h.


Constructor & Destructor Documentation

MadEvDisplay::MadEvDisplay ( TChain *  chainSR = 0,
TChain *  chainMC = 0,
TChain *  chainTH = 0,
TChain *  chainem = 0 
)

Definition at line 41 of file MadEvDisplay.cxx.

References MadBase::Clear(), Dmid_val, drawSAME, Dspe_val, MadBase::emrecord, handScan, MadBase::InitChain(), MadBase::isEM, MadBase::isMC, MadBase::isTH, LeAction, LeAutoMat, LeClus, LeEntry, LeEvent, LeLego, LeMCevent, LeNu, LeSlice, logFileName, MadBase::mcrecord, MadBase::Nentries, printOpt, ptt_msg, MadBase::record, ScanID, ScanTop, MadBase::threcord, UseNuInfo, and MadBase::whichSource.

00042                                                             : fHaveNeatoEvents(false), fNeatoEventIdx(-1), fDefaultShowerMarkerColor(6), fDefaultShowerMarkerStyle(4)
00043 {
00044 
00045   Dspe_val = 2.0;
00046   Dmid_val = 20.0;
00047   ptt_msg = false;
00048   UseNuInfo = false;
00049 
00050   LeNu = 14;
00051   LeAction = 1;
00052   LeLego = false;
00053   LeClus = false;
00054   LeEvent = 0;
00055   LeSlice = 0;
00056   LeMCevent = 0;
00057   LeEntry = 0;
00058   LeAutoMat = true;
00059   drawSAME = false;
00060 
00061   handScan = false;
00062   ScanID = 0;
00063   ScanTop = 0;
00064   sprintf(logFileName,"handScan.dat");
00065 
00066   sprintf(printOpt,"gif");
00067   //  sprintf(printOpt,"png");
00068   //  sprintf(printOpt,"eps");
00069 
00070   if(!chainSR) {
00071     record = 0;
00072     emrecord = 0;
00073     mcrecord = 0;
00074     threcord = 0;
00075     Clear();
00076     whichSource = -1;
00077     isMC = true;
00078     isTH = true;
00079     isEM = true;
00080     Nentries = -1;
00081     return;
00082   }
00083   
00084   InitChain(chainSR,chainMC,chainTH,chainEM, true);
00085   whichSource = 0;
00086 
00087 }

MadEvDisplay::MadEvDisplay ( JobC j,
string  path,
int  entries 
)

Definition at line 89 of file MadEvDisplay.cxx.

References MadBase::Clear(), Dmid_val, drawSAME, Dspe_val, MadBase::emrecord, MadBase::fChain, MadBase::fCurRun, MadBase::fJC, handScan, MadBase::isEM, MadBase::isMC, MadBase::isTH, MadBase::jcPath, LeAction, LeAutoMat, LeClus, LeEntry, LeEvent, LeLego, LeMCevent, LeNu, LeSlice, logFileName, MadBase::mcrecord, MadBase::Nentries, printOpt, ptt_msg, MadBase::record, ScanID, ScanTop, MadBase::threcord, UseNuInfo, and MadBase::whichSource.

00089                                                           : fHaveNeatoEvents(false), fNeatoEventIdx(-1), fDefaultShowerMarkerColor(6), fDefaultShowerMarkerStyle(4)
00090 {
00091  
00092   Dspe_val = 2.0;
00093   Dmid_val = 20.0;
00094   ptt_msg = false;
00095   UseNuInfo = false;
00096 
00097   LeNu = 14;
00098   LeAction = 1;
00099   LeLego = false;
00100   LeClus = false;
00101   LeEvent = 0;
00102   LeSlice = 0;
00103   LeMCevent = 0;
00104   LeEntry = 0;
00105   LeAutoMat = true;
00106   drawSAME = false;
00107 
00108   handScan = false;
00109   ScanID = 0;
00110   ScanTop = 0;
00111   sprintf(logFileName,"handScan.dat");
00112 
00113   sprintf(printOpt,"gif");
00114   //  sprintf(printOpt,"png");
00115   //  sprintf(printOpt,"eps");
00116 
00117   record = 0;
00118   emrecord = 0;
00119   mcrecord = 0;
00120   threcord = 0;
00121   Clear();
00122   isMC = true;
00123   isTH = true;
00124   isEM = true;
00125   Nentries = entries;
00126   jcPath = path;
00127   whichSource = 1;
00128   fCurRun = -1;
00129   fJC = j;
00130   fChain = NULL;
00131 
00132 }

MadEvDisplay::~MadEvDisplay (  )  [virtual]

Definition at line 134 of file MadEvDisplay.cxx.

00135 {
00136 }


Member Function Documentation

void MadEvDisplay::ChangeLogButColor (  ) 

Definition at line 3964 of file MadEvDisplay.cxx.

References ScanID, and ScanTop.

Referenced by Display().

03965 {
03966   if(gROOT->FindObject("MainCanvas")) {
03967     TCanvas *MainCanvas = (TCanvas*) gROOT->FindObject("MainCanvas");
03968     TVirtualPad *MainCanvas_2 = MainCanvas->GetPad(2);
03969     char butName[256];
03970     int butNums[10] = {1,2,3,4,5,6,8,9,10,11};
03971     for(int i=0;i<10;i++){
03972       sprintf(butName,"logBut%i",butNums[i]);
03973       TButton *but = (TButton*) MainCanvas_2->FindObject(butName);
03974       if(butNums[i]==ScanID || butNums[i]==ScanTop+7) {
03975         but->SetFillColor(3);
03976         but->Modified();
03977       }
03978       else if(but->GetFillColor()!=2) {
03979         but->SetFillColor(2);
03980         but->Modified();
03981       }
03982     }
03983   }
03984 }

Int_t * MadEvDisplay::Dec2Bin ( Int_t  dec  )  [protected]

Definition at line 3386 of file MadEvDisplay.cxx.

03386                                      {
03387 
03388   Int_t *bin = new Int_t[32];
03389   for(Int_t i=0;i<32;i++) bin[i]=0;
03390 
03391   Int_t index=1;
03392   
03393   while(true){
03394     if(dec<TMath::Power(2,index) && dec>1) {
03395       bin[index-1]=1;
03396       dec-=Int_t(TMath::Power(2,index-1));
03397       index=1;
03398     }
03399 
03400     else index+=1;
03401 
03402     if(dec==0) break;
03403     if(dec==1){
03404       bin[0]=1;
03405       dec-=1;
03406       break;
03407     }
03408   }
03409   return bin;
03410 }

Bool_t MadEvDisplay::Display ( Int_t  entry = 0,
Int_t  theSlice = 0,
Int_t  theEvent = 0,
Int_t  theMCevent = 0,
Bool_t  automat = true 
)

Delete truth,track,shower,strip objects

Delete arrows

Recover shapes

recover histo placeholders and reset

EM Showers

Definition at line 520 of file MadEvDisplay.cxx.

References ClusterType::AsString(), ChangeLogButColor(), NtpSRShower::clu, Munits::cm, count, NtpSRVertex::dcosu, NtpSRVertex::dcosv, NtpSRVertex::dcosz, det, Dmid_val, DrawButtons(), DrawInteractionDiagram(), drawSAME, DrawTextBox(), Dspe_val, MadBase::eventSummary, fDefaultShowerMarkerColor, fDefaultShowerMarkerStyle, VldContext::GetDetector(), MadBase::GetEntry(), PlaneOutline::GetNDPlanesHist(), PlaneOutline::GetOutline(), RecDataHeader::GetRun(), RecPhysicsHeader::GetSnarl(), RecHeader::GetVldContext(), handScan, NtpSRCluster::id, NtpMCStdHep::IdHEP, Munits::inch, MadBase::isEM, NtpSRShieldSummary::ishit, MadBase::isMC, MadBase::isST, MadBase::isTH, NtpMCStdHep::IstHEP, Detector::kCalDet, Detector::kFar, Detector::kNear, PlaneCoverage::kNearFull, PlaneCoverage::kNearPartial, PlaneView::kU, PlaneView::kV, LeClus, LeEvent, LeLego, LeMCevent, LeSlice, MadBase::LoadCluster(), MadBase::LoadEMShower(), MadBase::LoadEvent(), MadBase::LoadLargestShowerFromEvent(), MadBase::LoadLargestTrackFromEvent(), MadBase::LoadShower(), MadBase::LoadShowerAtTrackVertex(), MadBase::LoadSlice(), MadBase::LoadSliceForRecoTH(), MadBase::LoadTHEvent(), MadBase::LoadTrack(), MadBase::LoadTruth(), MadBase::LoadTruthForReco(), MadBase::LoadTruthForRecoTH(), NtpMCStdHep::mc, MadBase::mcrecord, NtpSRShower::ncluster, NtpSRSlice::ndigit, NtpTHEvent::neustdhep, NtpSREventSummary::nevent, NtpSREvent::nshower, NtpEMSummary::nshower, NtpSREventSummary::nslice, NtpSRCluster::nstrip, NtpSRTrack::nstrip, NtpEMShower::nstrip, NtpSRShower::nstrip, NtpSRSlice::nstrip, MadBase::ntpCluster, MadBase::ntpEMShower, MadBase::ntpEMSummary, MadBase::ntpEvent, MadBase::ntpHeader, MadBase::ntpShieldStrip, MadBase::ntpShower, MadBase::ntpSlice, MadBase::ntpStrip, MadBase::ntpTHEvent, MadBase::ntpTrack, MadBase::ntpTruth, NtpSREvent::ntrack, NtpMCStdHep::p4, NtpMCTruth::p4el1, NtpMCTruth::p4mu1, NtpMCTruth::p4neu, NtpMCTruth::p4neunoosc, NtpMCStdHep::parent, NtpSRPulseHeight::pe, NtpSREventSummary::ph, NtpSRSlice::ph, NtpSRStrip::ph0, NtpSRStrip::ph1, NtpSRStrip::plane, NtpSRStrip::planeview, NtpSRCluster::planeview, NtpMCStdHep::Print(), printName, printOpt, NtpSRCluster::probem, ptt_msg, NtpSRPulseHeight::raw, MadBase::record, ScanID, ScanTop, MadBase::shieldSummary, NtpSREvent::shw, NtpSREvent::slc, NtpStRecord::stdhep, NtpMCRecord::stdhep, NtpSRShower::stp, NtpEMShower::stp, NtpSRSlice::stp, NtpStRecord::stp, NtpSRCluster::stp, NtpSRRecord::stp, NtpSRTrack::stp, NtpSRTrack::stpt0, NtpSRTrack::stpt1, NtpSRTrack::stpx, NtpSRTrack::stpy, NtpSRTrack::stpz, MadBase::strecord, NtpSRStrip::strip, NtpSRShieldStrip::time, NtpSRStrip::time0, NtpSRStrip::time1, NtpSRStrip::tpos, NtpSREventSummary::trigtime, NtpSREvent::trk, NtpSRVertex::u, NtpSRVertex::v, NtpSRRecord::vetostp, NtpStRecord::vetostp, NtpMCStdHep::vtx, NtpSRShower::vtx, NtpMCTruth::vtxx, NtpMCTruth::vtxy, NtpMCTruth::vtxz, NtpSRShieldStrip::x, NtpSRShieldStrip::y, NtpSRStrip::z, and NtpSRVertex::z.

Referenced by JumpTo(), NextInterestingEvent(), NextPass(), PrevPass(), and SkipTo().

00522 {
00523 
00524   gStyle->SetTextFont(132);
00525   if(this->GetEntry(entry)==0) return false;
00526   
00527   Bool_t isReco = true;  //checks for reconstructed event
00528   Bool_t NoSlice = false;
00529 
00530   //no point using LoadStrip since it will called many times, just get arrays
00531   TClonesArray* pointShieldStripArray = NULL;
00532   if(isST) pointShieldStripArray = (strecord->vetostp);
00533   else pointShieldStripArray = (record->vetostp);
00534   TClonesArray& shieldstripArray = *pointShieldStripArray;
00535   TClonesArray* pointStripArray = NULL;
00536   if(isST) pointStripArray = (strecord->stp);
00537   else pointStripArray = (record->stp);
00538   TClonesArray& stripArray = *pointStripArray;
00539 
00540   //Load the event:  
00541   if(!LoadEvent(theEvent)) { //if can't load event asked for
00542     LeEvent = theEvent = 0; //try loading event 0
00543     if(!LoadEvent(theEvent)) isReco=false; //if not present then don't 
00544                                            //try to draw reco graphs
00545   }
00546   else LeEvent = theEvent;
00547 
00548   //if we have MC and TH, load slices and truth events based on reco'd event
00549   if(isMC) {
00550     if(isTH&&automat) {
00551       if(!LoadSliceForRecoTH(theEvent,theSlice)){ //load slice from reco evt
00552         LeSlice = theSlice = 0; //if not present load slice 0
00553         if(!LoadSlice(theSlice)) {
00554           std::cerr << "No slice present in Run: " << ntpHeader->GetRun() 
00555                     << " Snarl: " << ntpHeader->GetSnarl() << std::endl; 
00556           NoSlice=true; //if not there exit with a message after delete stuff
00557         }
00558       }
00559       else LeSlice = theSlice;
00560       if(!LoadTruthForRecoTH(theEvent,theMCevent)){ //load truth from reco
00561         LeMCevent = theMCevent = 0; //if not present load truth 0
00562         LoadTruth(theMCevent);
00563       }
00564       else LeMCevent = theMCevent;
00565     }
00566     else if(automat){ //if there's no TH but we are in automatic mode
00567       if(!LoadTruthForReco(theEvent,theMCevent)){ //load truth using reco vtx
00568         LeMCevent = theMCevent = 0; //if not present load truth 0
00569         LoadTruth(theMCevent);
00570         //load slice from event->slc:
00571         theSlice = ntpEvent->slc;
00572         if(!LoadSlice(theSlice)) {
00573           LeSlice = theSlice = 0;         
00574           if(!LoadSlice(theSlice)) {
00575            std::cerr << "No slice present in Run: " << ntpHeader->GetRun() 
00576                     << " Snarl: " << ntpHeader->GetSnarl() << std::endl; 
00577           NoSlice=true; //if not there exit with a message after delete stuff 
00578           }
00579         }
00580         else LeSlice = theSlice;
00581       }
00582       else LeMCevent = theMCevent;
00583     }
00584     else { //not in automatic mode
00585       if(!LoadTruth(theMCevent)) { //load truth asked for
00586         LeMCevent = theMCevent = 0; //if not present load truth 0
00587         LoadTruth(theMCevent);  
00588       }
00589       else LeMCevent = theMCevent;
00590       if(!LoadSlice(theSlice)){
00591         LeSlice = theSlice = 0; //if not present load slice 0
00592         if(!LoadSlice(theSlice)){
00593           std::cerr << "No slice present in Run: " << ntpHeader->GetRun() 
00594                     << " Snarl: " << ntpHeader->GetSnarl() << std::endl; 
00595           NoSlice=true; //if not there exit with a message after delete stuff
00596         }
00597       }
00598       else LeSlice = theSlice;
00599     }
00600     DrawInteractionDiagram(theMCevent);
00601   }
00602 
00603   else { //if no MC present
00604     if(!automat) { //if not in automatic mode, load slice asked for if possible
00605       if(!LoadSlice(theSlice)) { //if the one asked for not present
00606         theSlice = 0;
00607         LeSlice = theSlice;
00608         if(!LoadSlice(theSlice)){ //trying loading slice 0
00609           std::cerr << "No slice present in Run: " << ntpHeader->GetRun() 
00610                     << " Snarl: " << ntpHeader->GetSnarl() << std::endl; 
00611           return false; //if not there exit with a message
00612         }
00613       }
00614       else LeSlice = theSlice;
00615     }
00616     else { //in automatic mode
00617       if(isReco) { //if there is a reco'd event
00618         theSlice = ntpEvent->slc; //load slice from event
00619         if(!LoadSlice(theSlice)) {
00620           LeSlice = theSlice = 0;         
00621           if(!LoadSlice(theSlice)) {
00622             std::cerr << "No slice present in Run: " << ntpHeader->GetRun() 
00623                       << " Snarl: " << ntpHeader->GetSnarl() << std::endl; 
00624             NoSlice=true; //if not there exit with a message after delete stuff 
00625           }
00626         }
00627         else LeSlice = theSlice;
00628       }
00629       else {  //no reco'd event
00630         if(!LoadSlice(theSlice)) {  //try to load the slice asked for
00631           LeSlice = theSlice = 0;   //otherwise try to load slice 0
00632           if(!LoadSlice(theSlice)) {
00633             std::cerr << "No slice present in Run: " << ntpHeader->GetRun() 
00634                       << " Snarl: " << ntpHeader->GetSnarl() << std::endl; 
00635             NoSlice=true; //if not there exit with a message after delete stuff
00636           }
00637         }
00638         else LeSlice = theSlice;
00639       }
00640     }
00641   }
00642 
00643   sprintf(printName,"_Run%i_Snl%i_Slc%i_Evt%i.%s",ntpHeader->GetRun(),
00644           ntpHeader->GetSnarl(),theSlice,theEvent,printOpt);
00645 
00646 
00648   //Set Up Display Canvas
00649   //Delete Old Graphs
00650 
00651   TCanvas *RecoCanvas = 0;
00652   TCanvas *MainCanvas = 0;
00653   TCanvas *LegoCanvas = 0;
00654   TCanvas *ClusterCanvas = 0;
00655 
00656   static TPolyLine *line = 0;
00657   static TPolyLine *pu1_outline = 0; static TPolyLine *fu1_outline = 0; 
00658   static TPolyLine *pv1_outline = 0; static TPolyLine *fv1_outline = 0;
00659   static TPolyLine *pu2_outline = 0; static TPolyLine *fu2_outline = 0; 
00660   static TPolyLine *pv2_outline = 0; static TPolyLine *fv2_outline = 0;
00661 
00662   TEllipse *ellie = 0;
00663 
00664   TH2F *xz_place = 0;
00665   TH2F *yz_place = 0;
00666   TH2F *yx_place = 0;
00667   TH2 *tz_place_0 = 0;
00668   TH2 *tz_place_1 = 0;
00669 
00670   static std::string tz_place_dopt="";
00671 
00672 
00673   TH2F *tz_0_lego = 0;
00674   TH2F *tz_1_lego = 0;  
00675 
00676   TMultiGraph *xz_trk = 0;
00677   TMultiGraph *yz_trk = 0;
00678   TMultiGraph *yx_trk = 0;
00679   TMultiGraph *xz_shw = 0;
00680   TMultiGraph *yz_shw = 0;
00681   TMultiGraph *yx_shw = 0;
00682   TMultiGraph *yx_veto = 0;
00683 
00684   TMultiGraph *tz_stp_0 = 0;
00685   TMultiGraph *tz_stp_mid_0 = 0;
00686   TMultiGraph *tz_stp_spe_0 = 0;
00687   TMultiGraph *tz_stp_1 = 0;
00688   TMultiGraph *tz_stp_mid_1 = 0;
00689   TMultiGraph *tz_stp_spe_1 = 0;
00690 
00691   TMultiGraph *tz_trk0 = 0;
00692   TMultiGraph *tz_shw0 = 0;
00693   TMultiGraph *tz_emshw0 = 0;
00694   TMultiGraph *tz_clu0 = 0;
00695   TMultiGraph *tz_trk1 = 0;
00696   TMultiGraph *tz_shw1 = 0;
00697   TMultiGraph *tz_emshw1 = 0;
00698   TMultiGraph *tz_clu1 = 0;
00699   
00700   TLegend *cluLeg0 = 0;
00701   TLegend *cluLeg1 = 0;
00702   
00703   TMultiGraph *ytime = 0;
00704   TMultiGraph *ztime = 0;
00705   TMultiGraph *ytime_veto = 0;
00706     
00707   if(!gROOT->FindObject("RecoCanvas")){ 
00708 
00709     //set up canvases and placeholders
00710     gStyle->SetOptStat(0);
00711 
00712     RecoCanvas = new TCanvas("RecoCanvas","Reconstructed Tracks",0,0,900,700);
00713     RecoCanvas->Divide(3,2);
00714     TVirtualPad *RecoCanvas_5 = RecoCanvas->GetPad(5);
00715     RecoCanvas_5->Divide(1,2);
00716     
00717     if(LeLego) {
00718       LegoCanvas = new TCanvas("LegoCanvas","Lego View of Hit Strips",
00719                                0,0,900,700);
00720       LegoCanvas->Divide(1,2);
00721       
00722       /*
00723       int nzpos = 1000;
00724       double z_pos[1001];
00725       z_pos[0] = 0.5;
00726       z_pos[1] = 0.5+0.167;
00727       for(int i=2;i<1001;i++) z_pos[i] = z_pos[i-2]+1;
00728       */
00729       
00730       int nzpos = 500;
00731       double z_pos[501];
00732       z_pos[0] = 0.5;
00733       for(int i=1;i<501;i++) z_pos[i] = z_pos[i-1]+1;      
00734       
00735       tz_0_lego = new TH2F("tz_0_lego","TPos vs Plane view - U Planes",
00736                            nzpos,z_pos,192,-3.936,3.936);
00737       tz_0_lego->SetXTitle("Plane");
00738       tz_0_lego->SetYTitle("TPos (m)");
00739       tz_0_lego->SetZTitle("Pulse Height (PEs)");
00740       tz_1_lego = new TH2F("tz_1_lego","TPos vs Plane view - V Planes",
00741                            nzpos,z_pos,192,-3.936,3.936);
00742       tz_1_lego->SetXTitle("Plane");
00743       tz_1_lego->SetYTitle("TPos (m)");
00744       tz_1_lego->SetZTitle("Pulse Height (PEs)");
00745     }
00746 
00747     if(LeClus) {
00748       ClusterCanvas = new TCanvas("ClusterCanvas","Reconstructed Cluster View",
00749                                   910,0,400,700);
00750       ClusterCanvas->Divide(1,2);
00751     }
00752 
00753     MainCanvas = new TCanvas("MainCanvas","Main Display and Controls",
00754                              0,0,900,700);
00755     MainCanvas->Divide(2,2);
00756  
00757     xz_place = new TH2F("xz_place","X vs Z view",70,0,35,50,-5,5);
00758     xz_place->SetXTitle("z position (m)");
00759     xz_place->SetYTitle("x position (m)");
00760 
00761     yz_place = new TH2F("yz_place","Y vs Z view",70,0,35,50,-5,5);
00762     yz_place->SetXTitle("z position (m)");
00763     yz_place->SetYTitle("y position (m)");
00764 
00765     yx_place = new TH2F("yx_place","Y vs X view",50,-5,5,50,-5,5);
00766     yx_place->SetXTitle("x position (m)");
00767     yx_place->SetYTitle("y position (m)");
00768     // mike, fill us
00769     Detector::Detector_t det=ntpHeader->GetVldContext().GetDetector();
00770     if(det==Detector::kFar){
00771       tz_place_0 = new TH2F("tz_place_0","Transverse vs Z view - U Planes",
00772                             70,0,35,50,-5,5);
00773       tz_place_1 = new TH2F("tz_place_1","Transverse vs Z view - V Planes",
00774                             70,0,35,50,-5,5);      
00775     }
00776     else{
00777       PlaneOutline po;
00778       tz_place_0 = po.GetNDPlanesHist(PlaneView::kV);//strips measure U
00779       tz_place_0->SetName("tz_place_0");
00780       tz_place_0->SetTitle("Transverse vs Z view - U Planes");
00781       // attempt to defeat ROOT's behaviour whereby it unzooms z axis
00782       // when user unzooms y axis ... didn't work, causes whacky behaviour
00783       //tz_place_0->GetYaxis()->SetName("xaxis");
00784       tz_place_0->SetDirectory(gROOT);
00785       //      tz_place_0->SetDrawOption("col");
00786       tz_place_1 = po.GetNDPlanesHist(PlaneView::kU);//strips measure V
00787       tz_place_1->SetName("tz_place_1");
00788       tz_place_1->SetTitle("Transverse vs Z view - V Planes");
00789       //tz_place_1->GetYaxis()->SetName("xaxis");
00790       tz_place_1->SetDirectory(gROOT);
00791       //      tz_place_1->SetDrawOption("col");
00792       tz_place_dopt ="col";
00793     
00794     }
00795     tz_place_0->SetXTitle("z position (m)");
00796     tz_place_0->SetYTitle("transverse position (m)");
00797     tz_place_1->SetXTitle("z position (m)");
00798     tz_place_1->SetYTitle("transverse position (m)");
00799     
00800     this->DrawButtons(MainCanvas);
00801   }
00802   else {
00803     RecoCanvas = (TCanvas*) gROOT->FindObject("RecoCanvas");
00804     MainCanvas = (TCanvas*) gROOT->FindObject("MainCanvas");
00805 
00806     //Lego:
00807     if(gROOT->FindObject("LegoCanvas")) {
00808       LegoCanvas = (TCanvas*) gROOT->FindObject("LegoCanvas");
00809       LegoCanvas->cd(1);
00810       TVirtualPad *LegoCanvas_1 = LegoCanvas->GetPad(1);
00811       tz_0_lego = (TH2F*) LegoCanvas_1->FindObject("tz_0_lego");
00812       LegoCanvas->cd(2);
00813       TVirtualPad *LegoCanvas_2 = LegoCanvas->GetPad(2);
00814       tz_1_lego = (TH2F*) LegoCanvas_2->FindObject("tz_1_lego");
00815     }
00816     else if(LeLego) {
00817       LegoCanvas = new TCanvas("LegoCanvas","Lego View of Hit Strips",
00818                                0,0,900,700);
00819       LegoCanvas->Divide(1,2);
00820       
00821       /*
00822       int nzpos = 1000;
00823       double z_pos[1001];
00824       z_pos[0] = 0.5;
00825       z_pos[1] = 0.5+0.167;
00826       for(int i=2;i<1001;i++) z_pos[i] = z_pos[i-2]+1;
00827       */
00828       
00829       int nzpos = 500;
00830       double z_pos[501];
00831       z_pos[0] = 0.5;
00832       for(int i=1;i<501;i++) z_pos[i] = z_pos[i-1]+1;
00833 
00834       tz_0_lego = new TH2F("tz_0_lego","TPos vs Plane view - U Planes",
00835                            nzpos,z_pos,192,-3.936,3.936);
00836       tz_0_lego->SetXTitle("Plane");
00837       tz_0_lego->SetYTitle("TPos (m)");
00838       tz_0_lego->SetZTitle("Pulse Height (PEs)");
00839       tz_1_lego = new TH2F("tz_1_lego","TPos vs Plane view - V Planes",
00840                            nzpos,z_pos,192,-3.936,3.936);
00841       tz_1_lego->SetXTitle("Plane");
00842       tz_1_lego->SetYTitle("TPos (m)");
00843       tz_1_lego->SetZTitle("Pulse Height (PEs)");
00844 
00845       LegoCanvas->cd(1);
00846       tz_0_lego->Draw("lego");
00847       LegoCanvas->cd(2);
00848       tz_1_lego->Draw("lego");
00849     }
00850 
00851     if(!LeLego&&gROOT->FindObject("LegoCanvas")) {
00852       delete LegoCanvas;
00853       delete tz_0_lego;
00854       delete tz_1_lego;
00855     }
00856 
00858     RecoCanvas->cd(1);
00859     TVirtualPad *RecoCanvas_1 = RecoCanvas->GetPad(1);
00860     TVirtualPad *RecoCanvas_4 = RecoCanvas->GetPad(4);
00861     TVirtualPad *RecoCanvas_2 = RecoCanvas->GetPad(2);
00862     xz_trk = (TMultiGraph*) RecoCanvas_1->FindObject("xz_trk");
00863     yz_trk = (TMultiGraph*) RecoCanvas_4->FindObject("yz_trk");
00864     yx_trk = (TMultiGraph*) RecoCanvas_2->FindObject("yx_trk");
00865     xz_shw = (TMultiGraph*) RecoCanvas_1->FindObject("xz_shw");
00866     yz_shw = (TMultiGraph*) RecoCanvas_4->FindObject("yz_shw");
00867     yx_shw = (TMultiGraph*) RecoCanvas_2->FindObject("yx_shw");
00868     yx_veto = (TMultiGraph*) RecoCanvas_2->FindObject("yx_veto");
00869     
00870     if(!drawSAME) {
00871       delete xz_trk; xz_trk = 0;
00872       delete yz_trk; yz_trk = 0;
00873       delete yx_trk; yx_trk = 0;
00874       delete xz_shw; xz_shw = 0;
00875       delete yz_shw; yz_shw = 0;
00876       delete yx_shw; yx_shw = 0;
00877       delete yx_veto; yx_veto = 0;
00878     }
00879 
00880     RecoCanvas->cd(5);
00881     TVirtualPad *RecoCanvas_5 = RecoCanvas->GetPad(5);
00882     TVirtualPad *RecoCanvas_5_1 = RecoCanvas_5->GetPad(1);
00883     TVirtualPad *RecoCanvas_5_2 = RecoCanvas_5->GetPad(2);
00884     ytime = (TMultiGraph*) RecoCanvas_5_1->FindObject("ytime");
00885     ztime = (TMultiGraph*) RecoCanvas_5_2->FindObject("ztime");
00886     ytime_veto = (TMultiGraph*) RecoCanvas_5_1->FindObject("ytime_veto");
00887     
00888     if(!drawSAME) {
00889       delete ytime; ytime = 0;
00890       delete ztime; ztime = 0;
00891       delete ytime_veto; ytime_veto = 0;
00892     }
00893 
00894     MainCanvas->cd(1);
00895     TVirtualPad *MainCanvas_1 = MainCanvas->GetPad(1);
00896     TLatex *info1 = (TLatex*) MainCanvas_1->FindObject("info1");
00897     TLatex *info2 = (TLatex*) MainCanvas_1->FindObject("info2");
00898     TLatex *info3 = (TLatex*) MainCanvas_1->FindObject("info3");
00899     TLatex *info4 = (TLatex*) MainCanvas_1->FindObject("info4");
00900     TLatex *info5 = (TLatex*) MainCanvas_1->FindObject("info5");
00901     TLatex *info6 = (TLatex*) MainCanvas_1->FindObject("info6");
00902     TLatex *info7 = (TLatex*) MainCanvas_1->FindObject("info7");
00903     TLatex *info8 = (TLatex*) MainCanvas_1->FindObject("info8");
00904     TLatex *info9 = (TLatex*) MainCanvas_1->FindObject("info9");
00905     TLatex *info10 = (TLatex*) MainCanvas_1->FindObject("info10");
00906     TLatex *info11 = (TLatex*) MainCanvas_1->FindObject("info11");
00907     TLatex *info12 = (TLatex*) MainCanvas_1->FindObject("info12");
00908     TLatex *info13 = (TLatex*) MainCanvas_1->FindObject("info13");
00909     TLatex *info14 = (TLatex*) MainCanvas_1->FindObject("info14");
00910 
00911     delete info1;
00912     delete info2;
00913     delete info3;
00914     delete info4;
00915     delete info5;
00916     delete info6;
00917     delete info7;
00918     delete info8;
00919     delete info9;
00920     delete info10;
00921     delete info11;
00922     delete info12;
00923     delete info13;
00924     delete info14;
00925 
00927 
00929     MainCanvas->cd(3);
00930     TVirtualPad *MainCanvas_3 = MainCanvas->GetPad(3);
00931 
00932     tz_stp_0 = (TMultiGraph*) MainCanvas_3->FindObject("tz_stp_0");
00933     tz_stp_mid_0 = (TMultiGraph*) MainCanvas_3->FindObject("tz_stp_mid_0");
00934     tz_stp_spe_0 = (TMultiGraph*) MainCanvas_3->FindObject("tz_stp_spe_0");    
00935     if(!drawSAME){
00936       delete tz_stp_0; tz_stp_0 = 0;
00937       delete tz_stp_mid_0; tz_stp_mid_0 = 0;
00938       delete tz_stp_spe_0; tz_stp_spe_0 = 0;
00939     }
00940 
00941     tz_trk0 = (TMultiGraph*) MainCanvas_3->FindObject("tz_trk0");
00942     tz_shw0 = (TMultiGraph*) MainCanvas_3->FindObject("tz_shw0");
00943     tz_emshw0 = (TMultiGraph*) MainCanvas_3->FindObject("tz_emshw0");
00944     if(!drawSAME){
00945       delete tz_trk0; tz_trk0 = 0;
00946       delete tz_shw0; tz_shw0 = 0;
00947       delete tz_emshw0; tz_emshw0 = 0;
00948     }
00949     
00950     TArrow *ttz_arrow1 = (TArrow*) MainCanvas_3->FindObject("TArrow");
00951     delete ttz_arrow1;
00952     
00953     //delete stdhep lines:
00954     TLine *stdhepLine = 0;
00955     while((stdhepLine = (TLine*) MainCanvas_3->FindObject("TLine"))) {
00956       delete stdhepLine;
00957     }
00958   
00959     MainCanvas->cd(4);
00960     TVirtualPad *MainCanvas_4 = MainCanvas->GetPad(4);
00961     
00962     tz_stp_1 = (TMultiGraph*) MainCanvas_4->FindObject("tz_stp_1");
00963     tz_stp_mid_1 = (TMultiGraph*) MainCanvas_4->FindObject("tz_stp_mid_1");
00964     tz_stp_spe_1 = (TMultiGraph*) MainCanvas_4->FindObject("tz_stp_spe_1");
00965     if(!drawSAME){
00966       delete tz_stp_1; tz_stp_1 = 0;
00967       delete tz_stp_mid_1; tz_stp_mid_1 = 0;
00968       delete tz_stp_spe_1; tz_stp_spe_1 = 0;
00969     }
00970 
00971     tz_trk1 = (TMultiGraph*) MainCanvas_4->FindObject("tz_trk1");
00972     tz_shw1 = (TMultiGraph*) MainCanvas_4->FindObject("tz_shw1");
00973     tz_emshw1 = (TMultiGraph*) MainCanvas_4->FindObject("tz_emshw1");
00974     if(!drawSAME){
00975       delete tz_trk1; tz_trk1 = 0;
00976       delete tz_shw1; tz_shw1 = 0;
00977       delete tz_emshw1; tz_emshw1 = 0;
00978     }
00979 
00980 
00981     TArrow *ttz_arrow2 = (TArrow*) MainCanvas_4->FindObject("TArrow");
00982     delete ttz_arrow2;
00983 
00984     stdhepLine = 0;  
00985     while((stdhepLine = (TLine*) MainCanvas_4->FindObject("TLine"))) {
00986       delete stdhepLine;
00987     }
00988 
00989     //Cluster:
00990     if(gROOT->FindObject("ClusterCanvas")) {
00991       ClusterCanvas = (TCanvas*) gROOT->FindObject("ClusterCanvas");
00992       ClusterCanvas->cd(1);
00993       TVirtualPad *ClusterCanvas_1 = ClusterCanvas->GetPad(1);
00994       tz_clu0 = (TMultiGraph*) ClusterCanvas_1->FindObject("tz_clu0");
00995       cluLeg0 = (TLegend*) ClusterCanvas_1->FindObject("TPave");
00996       if(!drawSAME) {
00997         delete tz_clu0; tz_clu0 = 0;
00998         delete cluLeg0; cluLeg0 = 0;
00999       }
01000       gPad->Update();
01001       gPad->Modified();
01002       ClusterCanvas->cd(2);
01003       TVirtualPad *ClusterCanvas_2 = ClusterCanvas->GetPad(2);
01004       tz_clu1 = (TMultiGraph*) ClusterCanvas_2->FindObject("tz_clu1");
01005       cluLeg1 = (TLegend*) ClusterCanvas_2->FindObject("TPave");
01006       if(!drawSAME) {
01007         delete tz_clu1; tz_clu1 = 0;
01008         delete cluLeg1; cluLeg1 = 0;
01009       }
01010       gPad->Update();
01011       gPad->Modified();
01012     }
01013     else if(LeClus) {
01014       ClusterCanvas = new TCanvas("ClusterCanvas","Reconstructed Cluster View",
01015                                   910,0,400,700);
01016       ClusterCanvas->Divide(1,2);
01017     }
01018 
01019     if(!LeClus&&gROOT->FindObject("ClusterCanvas")) {
01020       delete ClusterCanvas;
01021     }
01022 
01024         
01026     RecoCanvas->cd(2);
01027     //    line = (TPolyLine*) RecoCanvas_2->FindObject("TPolyLine");
01028     ellie = (TEllipse*) RecoCanvas_2->FindObject("TEllipse");
01029     RecoCanvas->Clear();
01030     RecoCanvas->Divide(3,2);
01031     RecoCanvas_5 = RecoCanvas->GetPad(5);
01032     RecoCanvas_5->Divide(1,2);
01033     
01035     xz_place = (TH2F*) gROOT->FindObject("xz_place");
01036     yz_place = (TH2F*) gROOT->FindObject("yz_place");
01037     yx_place = (TH2F*) gROOT->FindObject("yx_place");
01038     tz_place_0 = (TH2*) gROOT->FindObject("tz_place_0");
01039     tz_place_1 = (TH2*) gROOT->FindObject("tz_place_1");
01040 
01041     xz_place->GetXaxis()->UnZoom();
01042     yz_place->GetXaxis()->UnZoom();
01043     tz_place_0->GetXaxis()->UnZoom();
01044     tz_place_1->GetXaxis()->UnZoom();
01045     xz_place->GetYaxis()->UnZoom();
01046     yz_place->GetYaxis()->UnZoom();
01047     tz_place_0->GetYaxis()->UnZoom();
01048     tz_place_1->GetYaxis()->UnZoom();
01049 
01050     if(ntpHeader->GetVldContext().GetDetector()==Detector::kNear){
01051       yx_place->GetXaxis()->SetRangeUser(-2.6,3.8);
01052       yx_place->GetYaxis()->SetRangeUser(-3.2,3.2);
01053 
01054     }
01055     else {
01056       yx_place->GetXaxis()->UnZoom();
01057       yx_place->GetYaxis()->UnZoom();
01058     }
01059     
01060     if(LeLego){
01061       tz_0_lego->GetXaxis()->UnZoom();
01062       tz_0_lego->GetYaxis()->UnZoom();
01063       tz_1_lego->GetXaxis()->UnZoom();
01064       tz_1_lego->GetYaxis()->UnZoom();
01065       if(!drawSAME) {
01066         tz_0_lego->Reset();
01067         tz_1_lego->Reset();
01068       }
01069     }
01070     if(handScan) {
01071       ScanID = 0;
01072       ScanTop = 0;
01073       ChangeLogButColor();
01074     }
01075   }
01076 
01077   //if no detector outlines, make them here:
01078   if(!line){
01079     float linex_caldet[5] = {-0.5,0.5,0.5,-0.5,-0.5};
01080     float liney_caldet[5] = {-0.5,-0.5,0.5,0.5,-0.5};
01081     if(ntpHeader->GetVldContext().GetDetector()==Detector::kFar) {
01082       line = new TPolyLine(33,"");
01083       line->SetPoint( 0, 421.8893*Munits::cm,-142.8867*Munits::cm);
01084       line->SetPoint( 1, 421.8893*Munits::cm,-138.3342*Munits::cm);
01085       line->SetPoint( 2, 400.1614*Munits::cm,-115.9855*Munits::cm);
01086       line->SetPoint( 3, 400.1614*Munits::cm,  87.6358*Munits::cm);
01087       line->SetPoint( 4, 406.9902*Munits::cm,  94.0507*Munits::cm);
01088       line->SetPoint( 5, 429.1319*Munits::cm, 101.5003*Munits::cm);
01089       line->SetPoint( 6, 447.1350*Munits::cm, 101.5003*Munits::cm);
01090       line->SetPoint( 7, 454.7915*Munits::cm,  94.2577*Munits::cm);
01091       line->SetPoint( 8, 457.6886*Munits::cm,  94.2577*Munits::cm);
01092       line->SetPoint( 9, 457.6886*Munits::cm, 109.3637*Munits::cm);
01093       line->SetPoint(10, 143.7724*Munits::cm, 423.2799*Munits::cm);
01094       line->SetPoint(11, 139.4268*Munits::cm, 423.2799*Munits::cm);
01095       line->SetPoint(12, 117.2850*Munits::cm, 401.1382*Munits::cm);
01096       line->SetPoint(13,-116.9622*Munits::cm, 401.1382*Munits::cm);
01097       line->SetPoint(14,-139.1040*Munits::cm, 423.2799*Munits::cm);
01098       line->SetPoint(15,-143.4496*Munits::cm, 423.2799*Munits::cm);
01099       line->SetPoint(16,-457.3658*Munits::cm, 109.3637*Munits::cm);
01100       line->SetPoint(17,-457.3658*Munits::cm,  94.2577*Munits::cm);
01101       line->SetPoint(18,-454.4687*Munits::cm,  94.2577*Munits::cm);
01102       line->SetPoint(19,-439.9834*Munits::cm, 101.9141*Munits::cm);
01103       line->SetPoint(20,-429.8438*Munits::cm, 101.9141*Munits::cm);
01104       line->SetPoint(21,-406.6674*Munits::cm,  94.2577*Munits::cm);
01105       line->SetPoint(22,-399.8386*Munits::cm,  84.7388*Munits::cm);
01106       line->SetPoint(23,-399.8386*Munits::cm,-115.9855*Munits::cm);
01107       line->SetPoint(24,-421.5665*Munits::cm,-137.7134*Munits::cm);
01108       line->SetPoint(25,-421.5665*Munits::cm,-142.8867*Munits::cm);
01109       line->SetPoint(26,-143.4496*Munits::cm,-421.0036*Munits::cm);
01110       line->SetPoint(27,-139.1040*Munits::cm,-421.0036*Munits::cm);
01111       line->SetPoint(28,-116.9622*Munits::cm,-398.8619*Munits::cm);
01112       line->SetPoint(29, 116.8712*Munits::cm,-398.8619*Munits::cm);
01113       line->SetPoint(30, 139.4268*Munits::cm,-421.0036*Munits::cm);
01114       line->SetPoint(31, 143.7724*Munits::cm,-421.0036*Munits::cm);
01115       line->SetPoint(32, 421.8893*Munits::cm,-142.8867*Munits::cm);
01116     }     
01117     else if(ntpHeader->GetVldContext().GetDetector()==Detector::kNear) {
01118       line = new TPolyLine(23,"");
01119       Double_t x0 = 55.78*Munits::cm;   
01120       line->SetPoint( 0,-121.43*Munits::inch+x0,  0.47*Munits::inch);
01121       line->SetPoint( 1,-120.25*Munits::inch+x0,  0.47*Munits::inch);
01122       line->SetPoint( 2,-115.14*Munits::inch+x0,  3.42*Munits::inch);
01123       line->SetPoint( 3,-110.24*Munits::inch+x0,  3.42*Munits::inch);
01124       line->SetPoint( 4, -95.24*Munits::inch+x0, -1.48*Munits::inch);
01125       line->SetPoint( 5, -95.24*Munits::inch+x0,-35.47*Munits::inch);
01126       line->SetPoint( 6, -69.80*Munits::inch+x0,-60.91*Munits::inch);
01127       line->SetPoint( 7, -69.80*Munits::inch+x0,-75.04*Munits::inch);
01128       line->SetPoint( 8,  69.80*Munits::inch+x0,-75.04*Munits::inch);
01129       line->SetPoint( 9,  69.80*Munits::inch+x0,-60.91*Munits::inch);
01130       line->SetPoint(10,  95.24*Munits::inch+x0,-35.47*Munits::inch);
01131       line->SetPoint(11,  95.24*Munits::inch+x0, -1.48*Munits::inch);
01132       line->SetPoint(12, 110.16*Munits::inch+x0,  3.42*Munits::inch);
01133       line->SetPoint(13, 117.30*Munits::inch+x0,  3.42*Munits::inch);
01134       line->SetPoint(14, 120.25*Munits::inch+x0,  0.47*Munits::inch);
01135       line->SetPoint(15, 121.43*Munits::inch+x0,  0.47*Munits::inch);
01136       line->SetPoint(16, 121.43*Munits::inch+x0,  9.28*Munits::inch);
01137       line->SetPoint(17,  69.80*Munits::inch+x0, 60.91*Munits::inch);
01138       line->SetPoint(18,  69.80*Munits::inch+x0, 75.04*Munits::inch);
01139       line->SetPoint(19, -69.80*Munits::inch+x0, 75.04*Munits::inch);
01140       line->SetPoint(20, -69.80*Munits::inch+x0, 60.91*Munits::inch);
01141       line->SetPoint(21,-121.43*Munits::inch+x0,  9.28*Munits::inch);
01142       line->SetPoint(22,-121.43*Munits::inch+x0,  0.47*Munits::inch);
01143       
01144       // near detector plane outlines
01145       PlaneOutline po;
01146       Color_t colu=38;
01147       Color_t colv=46;
01148       po.GetOutline(PlaneView::kV, PlaneCoverage::kNearPartial,
01149                     pv1_outline, pv2_outline);
01150       po.GetOutline(PlaneView::kV, PlaneCoverage::kNearFull,
01151                     fv1_outline, fv2_outline);
01152       po.GetOutline(PlaneView::kU, PlaneCoverage::kNearPartial,
01153                     pu1_outline, pu2_outline);
01154       po.GetOutline(PlaneView::kU, PlaneCoverage::kNearFull,
01155                     fu1_outline, fu2_outline);
01156       pv1_outline->SetLineColor(colv);
01157       pu1_outline->SetLineColor(colu);
01158 
01159       fv1_outline->SetLineColor(colv);
01160       fu1_outline->SetLineColor(colu);
01161       fv2_outline->SetFillColor(16);
01162       fu2_outline->SetFillColor(16);
01163       fv2_outline->SetFillStyle(4020);
01164       fu2_outline->SetFillStyle(4020);
01165       
01166       pv1_outline->SetLineWidth(2);
01167       pu1_outline->SetLineWidth(2);
01168       fv1_outline->SetLineWidth(2);
01169       fu1_outline->SetLineWidth(2);
01170       fv2_outline->SetLineWidth(2);
01171       fu2_outline->SetLineWidth(2);
01172       
01173     }
01174     else if(ntpHeader->GetVldContext().GetDetector()==Detector::kCalDet) 
01175       line = new TPolyLine(5,linex_caldet,liney_caldet);
01176     line->SetLineWidth(3);
01177     line->SetLineColor(4);
01178   }
01179   
01180   if(!ellie&&ntpHeader->GetVldContext().GetDetector()==Detector::kFar){ 
01181 // dp - new cc FV 
01182     ellie = new TEllipse(0,0,TMath::Sqrt(14),TMath::Sqrt(14),0,360,0);
01183     ellie->SetLineColor(5);
01184     ellie->SetLineWidth(1);   // dp  - was 3
01185     ellie->SetFillStyle(0);   // dp - transparent
01186     ellie->SetLineStyle(2);
01187   }
01188 
01189   if(NoSlice) return false;
01190 
01192   //Strips
01193   
01194   int slc_nstrip = ntpSlice->nstrip;
01195   
01196   float *stp_z_big_0 = new float[slc_nstrip];
01197   float *stp_z_mid_0 = new float[slc_nstrip];
01198   float *stp_z_spe_0 = new float[slc_nstrip];
01199 
01200   float *stp_tpos_big_0 = new float[slc_nstrip];
01201   float *stp_tpos_mid_0 = new float[slc_nstrip];
01202   float *stp_tpos_spe_0 = new float[slc_nstrip];
01203 
01204   int nstp_big_0 = 0;
01205   int nstp_mid_0 = 0;
01206   int nstp_spe_0 = 0;
01207 
01208   float *stp_z_big_1 = new float[slc_nstrip];
01209   float *stp_z_mid_1 = new float[slc_nstrip];
01210   float *stp_z_spe_1 = new float[slc_nstrip];
01211 
01212   float *stp_tpos_big_1 = new float[slc_nstrip];
01213   float *stp_tpos_mid_1 = new float[slc_nstrip];
01214   float *stp_tpos_spe_1 = new float[slc_nstrip];
01215 
01216   int nstp_big_1 = 0;
01217   int nstp_mid_1 = 0;
01218   int nstp_spe_1 = 0;
01219     
01220   float ATH_reco0[500][192] = {};
01221   float ATH_reco1[500][192] = {};
01222   float ATH_mcA[500][192] = {};
01223   float ATH_mcB[500][192] = {};
01224   
01225   for(int i=0;i<500;i++){
01226     for(int j=0;j<192;j++){
01227       ATH_reco0[i][j] = -1;
01228       ATH_reco1[i][j] = -1;
01229       ATH_mcA[i][j] = -1;
01230       ATH_mcB[i][j] = -1;
01231     }
01232   }
01233 
01234   float highest_plane = 0;
01235   float lowest_plane = 500;
01236 
01237   float highest_z = 0;
01238   float lowest_z = 30.;
01239   float highest_t0 = -4.0;
01240   float lowest_t0 = 4.0;
01241   float highest_t1 = -4.0;
01242   float lowest_t1 = 4.0;
01243   
01244   for(int i=0;i<slc_nstrip;i++){
01245     
01246     int index = ntpSlice->stp[i];
01247     ntpStrip = dynamic_cast<NtpSRStrip *>(stripArray[index]);
01248     
01249     int tempo_pln = ntpStrip->plane;
01250     int tempo_stp = ntpStrip->strip;
01251 
01252     if(tempo_pln<lowest_plane) {
01253       lowest_plane=tempo_pln;
01254       lowest_z=ntpStrip->z;
01255     }
01256     if(tempo_pln>highest_plane) {
01257       highest_plane=tempo_pln;
01258       highest_z=ntpStrip->z;
01259     }
01260     
01261     ATH_reco0[tempo_pln][tempo_stp] = ntpStrip->ph0.pe;
01262     ATH_reco1[tempo_pln][tempo_stp] = ntpStrip->ph1.pe;
01263     
01264     if(ntpStrip->planeview==2){
01265       
01266       if(LeLego) 
01267         tz_0_lego->Fill(tempo_pln-0.49,ntpStrip->tpos,
01268                         ntpStrip->ph0.pe+ntpStrip->ph1.pe);
01269       
01270       if(ntpStrip->tpos<lowest_t0) lowest_t0=ntpStrip->tpos;
01271       if(ntpStrip->tpos>highest_t0) highest_t0=ntpStrip->tpos;
01272       
01273       if(ntpStrip->ph0.pe+ntpStrip->ph1.pe<Dspe_val){
01274         stp_z_spe_0[nstp_spe_0]=ntpStrip->z;
01275         stp_tpos_spe_0[nstp_spe_0]=ntpStrip->tpos;
01276         nstp_spe_0++;
01277       }
01278       else if(ntpStrip->ph0.pe+ntpStrip->ph1.pe<Dmid_val){
01279         stp_z_mid_0[nstp_mid_0]=ntpStrip->z;
01280         stp_tpos_mid_0[nstp_mid_0]=ntpStrip->tpos;
01281         nstp_mid_0++;
01282       }
01283       else {
01284         stp_z_big_0[nstp_big_0]=ntpStrip->z;
01285         stp_tpos_big_0[nstp_big_0]=ntpStrip->tpos;
01286         nstp_big_0++;
01287       }
01288     }
01289     
01290     else {
01291       
01292       if(LeLego)
01293         tz_1_lego->Fill(tempo_pln-0.49,ntpStrip->tpos,
01294                         ntpStrip->ph0.pe+ntpStrip->ph1.pe);
01295 
01296       if(ntpStrip->tpos<lowest_t1) lowest_t1=ntpStrip->tpos;
01297       if(ntpStrip->tpos>highest_t1) highest_t1=ntpStrip->tpos;
01298       
01299       if(ntpStrip->ph0.pe+ntpStrip->ph1.pe<Dspe_val){
01300         stp_z_spe_1[nstp_spe_1]=ntpStrip->z;
01301         stp_tpos_spe_1[nstp_spe_1]=ntpStrip->tpos;
01302         nstp_spe_1++;
01303       }
01304       else if(ntpStrip->ph0.pe+ntpStrip->ph1.pe<Dmid_val){
01305         stp_z_mid_1[nstp_mid_1]=ntpStrip->z;
01306         stp_tpos_mid_1[nstp_mid_1]=ntpStrip->tpos;
01307         nstp_mid_1++;
01308       }
01309       else {
01310         stp_z_big_1[nstp_big_1]=ntpStrip->z;
01311         stp_tpos_big_1[nstp_big_1]=ntpStrip->tpos;
01312         nstp_big_1++;
01313       }
01314     }
01315   }
01316 
01317   if(!tz_stp_0 && nstp_big_0>0) {
01318     tz_stp_0 = new TMultiGraph();
01319     tz_stp_0->SetName("tz_stp_0");
01320     tz_stp_0->SetTitle("Transverse Position vs Z View");
01321   }
01322   if(nstp_big_0>0){
01323     TGraph *temp = new TGraph(nstp_big_0,stp_z_big_0,stp_tpos_big_0);
01324     temp->SetMarkerColor(1);
01325     temp->SetMarkerSize(1.1);
01326     temp->SetMarkerStyle(8);
01327     tz_stp_0->Add(temp);
01328   }
01329 
01330   if(!tz_stp_mid_0 && nstp_mid_0>0){
01331     tz_stp_mid_0 = new TMultiGraph();
01332     tz_stp_mid_0->SetName("tz_stp_mid_0");
01333     tz_stp_mid_0->SetTitle("Transverse Position vs Z View");
01334   }
01335   if(nstp_mid_0>0){
01336     TGraph *temp = new TGraph(nstp_mid_0,stp_z_mid_0,stp_tpos_mid_0);
01337     temp->SetMarkerColor(4);
01338     temp->SetMarkerSize(1.1);
01339     temp->SetMarkerStyle(8);
01340     tz_stp_mid_0->Add(temp);
01341   }
01342 
01343   if(!tz_stp_spe_0 && nstp_spe_0>0){
01344     tz_stp_spe_0 = new TMultiGraph();
01345     tz_stp_spe_0->SetName("tz_stp_spe_0");
01346   }
01347   if(nstp_spe_0>0){  
01348     TGraph *temp = new TGraph(nstp_spe_0,stp_z_spe_0,stp_tpos_spe_0);
01349     temp->SetMarkerColor(3);
01350     temp->SetMarkerSize(1.1);
01351     temp->SetMarkerStyle(8);
01352     tz_stp_spe_0->Add(temp);
01353   }
01354 
01355   if(!tz_stp_1 && nstp_big_1>0) {
01356     tz_stp_1 = new TMultiGraph();
01357     tz_stp_1->SetName("tz_stp_1");
01358     tz_stp_1->SetTitle("Transverse Position vs Z View");
01359   }
01360   if(nstp_big_1>0){
01361     TGraph *temp = new TGraph(nstp_big_1,stp_z_big_1,stp_tpos_big_1);
01362     temp->SetMarkerColor(1);
01363     temp->SetMarkerSize(1.1);
01364     temp->SetMarkerStyle(8);
01365     tz_stp_1->Add(temp);
01366   }
01367 
01368   if(!tz_stp_mid_1 && nstp_mid_1>0){
01369     tz_stp_mid_1 = new TMultiGraph();
01370     tz_stp_mid_1->SetName("tz_stp_mid_1");
01371     tz_stp_mid_1->SetTitle("Transverse Position vs Z View");
01372   }
01373   if(nstp_mid_1>0){
01374     TGraph *temp = new TGraph(nstp_mid_1,stp_z_mid_1,stp_tpos_mid_1);
01375     temp->SetMarkerColor(4);
01376     temp->SetMarkerSize(1.1);
01377     temp->SetMarkerStyle(8);
01378     tz_stp_mid_1->Add(temp);
01379   }
01380 
01381   if(!tz_stp_spe_1 && nstp_spe_1>0){
01382     tz_stp_spe_1 = new TMultiGraph();
01383     tz_stp_spe_1->SetName("tz_stp_spe_1");
01384   }
01385   if(nstp_spe_1>0){  
01386     TGraph *temp = new TGraph(nstp_spe_1,stp_z_spe_1,stp_tpos_spe_1);
01387     temp->SetMarkerColor(3);
01388     temp->SetMarkerSize(1.1);
01389     temp->SetMarkerStyle(8);
01390     tz_stp_spe_1->Add(temp);
01391   }
01392 
01393   delete [] stp_tpos_big_0;
01394   delete [] stp_tpos_mid_0;
01395   delete [] stp_tpos_spe_0;
01396   delete [] stp_z_big_0;
01397   delete [] stp_z_mid_0;
01398   delete [] stp_z_spe_0;
01399 
01400   delete [] stp_tpos_big_1;
01401   delete [] stp_tpos_mid_1;
01402   delete [] stp_tpos_spe_1;
01403   delete [] stp_z_big_1;
01404   delete [] stp_z_mid_1;
01405   delete [] stp_z_spe_1;
01406 
01407   if(lowest_plane-10>=0) {
01408     lowest_plane-=10;
01409     lowest_z-=10.*0.06;
01410   }
01411   else {
01412     lowest_plane=0;
01413     lowest_z=0.;
01414   }
01415 
01416   if(highest_plane+10<=485) {
01417     highest_plane+=10;
01418     highest_z+=10.*0.06;
01419   }
01420   else {
01421     highest_plane=485;
01422     highest_z=30.;
01423   }
01424   
01425   if(lowest_t0-5*0.041>=-4.0) lowest_t0-=5.*0.041;
01426   else lowest_t0=-4.0;
01427 
01428   if(lowest_t1-5*0.041>=-4.0) lowest_t1-=5.*0.041;
01429   else lowest_t1=-4.0;
01430 
01431   if(highest_t0+5*0.041<=4.0) highest_t0+=5.*0.041;
01432   else highest_t0=4.0;
01433 
01434   if(highest_t1+5*0.041<=4.0) highest_t1+=5.*0.041;
01435   else highest_t1=4.0;
01436 
01438   //Start making Reco plots for showers and tracks:
01439 
01440   //make sure there is a reconstructed event
01441   if(isReco&&eventSummary->nevent!=0){ //begin of reco code
01442 
01444     //Showers
01445     
01446     //make sure there is a shower
01447     if(ntpEvent->nshower>0){ //begin of shower code
01448       
01449       if(!tz_shw0) {
01450         tz_shw0 = new TMultiGraph();
01451         tz_shw0->SetName("tz_shw0");
01452       }
01453       if(!tz_shw1){
01454         tz_shw1 = new TMultiGraph();
01455         tz_shw1->SetName("tz_shw1");
01456       }
01457       if(!xz_shw){
01458         xz_shw = new TMultiGraph();
01459         xz_shw->SetName("xz_shw");
01460       }
01461       if(!yz_shw){
01462         yz_shw = new TMultiGraph();
01463         yz_shw->SetName("yz_shw");
01464       }
01465       if(!yx_shw){
01466         yx_shw = new TMultiGraph();
01467         yx_shw->SetName("yx_shw");
01468       }
01469       if(!ztime) {
01470         ztime = new TMultiGraph();
01471         ztime->SetName("ztime");
01472         ztime->SetTitle("Time vs Z view");      
01473       }
01474       if(!ytime){
01475         ytime = new TMultiGraph();
01476         ytime->SetName("ytime");
01477         ytime->SetTitle("Time vs Y view");
01478       }
01479 
01480       int *showers = ntpEvent->shw;
01481       
01482       int numshwstp=0;
01483       int numshwstp0=0;
01484       int numshwstp1=0;
01485       
01486       for(int i=0;i<ntpEvent->nshower;i++){
01487         int index = showers[i];
01488         LoadShower(index);
01489         numshwstp += ntpShower->nstrip;
01490       }
01491 
01492       float *shw_tpos = new float[numshwstp];      
01493       float *shw_tpos0 = new float[numshwstp];
01494       float *shw_z0 = new float[numshwstp];
01495       float *shw_tpos1 = new float[numshwstp];
01496       float *shw_z1 = new float[numshwstp];
01497       float *shwstpx = new float[numshwstp];
01498       float *shwstpy = new float[numshwstp];
01499       float *shwstpz = new float[numshwstp];
01500       double *shw_time = new double[numshwstp];
01501       double *shw_y = new double[numshwstp];
01502       double *shw_z = new double[numshwstp];
01503       int count = 0;
01504       int largest_shw_index=-1;
01505       int vtx_shw_index=-1;
01506       LoadLargestShowerFromEvent(theEvent,largest_shw_index);
01507       {
01508         int track_index=-1;
01509         LoadLargestTrackFromEvent(theEvent,track_index);
01510         if(track_index>-1) LoadShowerAtTrackVertex(theEvent,track_index,vtx_shw_index);
01511       }
01512       for(int i=0;i<ntpEvent->nshower;i++){
01513         int index1 = showers[i];
01514         LoadShower(index1);
01515         Int_t *shwstrips = ntpShower->stp;
01516 
01517         count=0;
01518         numshwstp0=0;
01519         numshwstp1=0;
01520       
01521         for(int j=0;j<ntpShower->nstrip;j++){
01522           Int_t index = shwstrips[j];
01523           if(index==-1) {numshwstp=0; break;} //bug in old ntuple code
01524           ntpStrip = dynamic_cast<NtpSRStrip *>(stripArray[index]);
01525           
01526           shw_tpos[count] = ntpStrip->tpos;
01527           shw_z[count] = ntpStrip->z;
01528 
01529           if(ntpStrip->time0>0 && 
01530              ntpStrip->time1>0) shw_time[count] = (ntpStrip->time0 + 
01531                                                    ntpStrip->time1)/2.;
01532           else if(ntpStrip->time0>0) shw_time[count] = ntpStrip->time0;
01533           else if(ntpStrip->time1>0) shw_time[count] = ntpStrip->time1;
01534           else shw_time[count] = 0;
01535           /*
01536             if(ntpStrip->time0>0 && 
01537             ntpStrip->time1>0) shw_time[count] = (ntpShower->stpt0[j] + 
01538             ntpShower->stpt1[j])/2.;
01539             else if(ntpStrip->time0>0) shw_time[count] = ntpShower->stpt0[j];
01540             else if(ntpStrip->time1>0) shw_time[count] = ntpShower->stpt1[j];
01541             else shw_time[count] = 0;
01542             }
01543           */
01544           shw_time[count] -= eventSummary->trigtime;
01545           shw_time[count] *= 1e9;
01546 
01547           float shwstpu = 0;
01548           float shwstpv = 0;
01549 
01550           if(ntpStrip->planeview==2){
01551             shw_tpos0[numshwstp0] = shw_tpos[count];
01552             shw_z0[numshwstp0] = shw_z[count];
01553             numshwstp0+=1;
01554             shwstpu = shw_tpos[count];
01555             float grad = 0;
01556             if(ntpShower->vtx.dcosv!=0&&false) {
01557               grad = ntpShower->vtx.dcosz/ntpShower->vtx.dcosv;
01558             }
01559             shwstpv = ntpShower->vtx.v+(shw_z[count]-ntpShower->vtx.z)*grad;
01560             //shwstpv = ntpShower->stpv[j];
01561           }
01562           else {
01563             shw_tpos1[numshwstp1] = shw_tpos[count];
01564             shw_z1[numshwstp1] = shw_z[count];
01565             numshwstp1+=1;
01566             shwstpv = shw_tpos[count];
01567             float grad = 0;
01568             if(ntpShower->vtx.dcosu!=0&&false) {
01569               grad = ntpShower->vtx.dcosz/ntpShower->vtx.dcosu;
01570             }
01571             shwstpu = ntpShower->vtx.u+(shw_z[count]-ntpShower->vtx.z)*grad;
01572             //shwstpu = ntpShower->stpu[j];
01573           }
01574           shwstpx[count] = (shwstpu-shwstpv)/sqrt(2.);
01575           shwstpy[count] = (shwstpu+shwstpv)/sqrt(2.);
01576           shwstpz[count] = shw_z[count];
01577           shw_y[count]   = shwstpy[count];
01578           count++;
01579         }
01580         // largest ph shower will have color 5 by default
01581         // users can change this default via SetDefaultShowerMarkerColor()
01582         // others, a purplish-brown
01583         int shw_marker_color=48;
01584         if(largest_shw_index==index1) shw_marker_color = fDefaultShowerMarkerColor;
01585         // vertex shower will have open circles, other open squares by default
01586         // users can change the default via SetDefaultShowerMarkerStyle()
01587         int shw_marker_style=25;
01588         if(vtx_shw_index==index1) shw_marker_style=fDefaultShowerMarkerStyle;
01589         if(numshwstp0>0){
01590           TGraph *temp = new TGraph(numshwstp0,shw_z0,shw_tpos0);
01591           temp->SetMarkerColor(shw_marker_color);
01592           temp->SetMarkerSize(0.6);
01593           temp->SetMarkerStyle(shw_marker_style);
01594           tz_shw0->Add(temp);
01595         }
01596         else {
01597           delete tz_shw0;
01598           tz_shw0 = NULL;
01599         }
01600         
01601         if(numshwstp1>0){
01602           TGraph *temp = new TGraph(numshwstp1,shw_z1,shw_tpos1);
01603           temp->SetMarkerColor(shw_marker_color);
01604           temp->SetMarkerSize(0.6);
01605           temp->SetMarkerStyle(shw_marker_style);
01606           tz_shw1->Add(temp);
01607         }
01608         else {
01609           delete tz_shw1;
01610           tz_shw1 = NULL;
01611         }
01612 
01613         if(count>0){
01614           TGraph *temp = new TGraph(count,shwstpz,shwstpx);
01615           temp->SetMarkerColor(fDefaultShowerMarkerColor);
01616           temp->SetMarkerSize(0.6);
01617           temp->SetMarkerStyle(fDefaultShowerMarkerStyle);
01618           xz_shw->Add(temp);
01619           
01620           temp = new TGraph(count,shwstpz,shwstpy);
01621           temp->SetMarkerColor(fDefaultShowerMarkerColor);
01622           temp->SetMarkerSize(0.6);
01623           temp->SetMarkerStyle(fDefaultShowerMarkerStyle);
01624           yz_shw->Add(temp);
01625           
01626           temp = new TGraph(count,shwstpx,shwstpy);
01627           temp->SetMarkerColor(fDefaultShowerMarkerColor);
01628           temp->SetMarkerSize(0.6);
01629           temp->SetMarkerStyle(fDefaultShowerMarkerStyle);
01630           yx_shw->Add(temp);
01631 
01632           temp = new TGraph(count,shw_z,shw_time);
01633           temp->SetMarkerColor(fDefaultShowerMarkerColor);
01634           temp->SetMarkerSize(0.6);
01635           temp->SetMarkerStyle(fDefaultShowerMarkerStyle);
01636           ztime->Add(temp);
01637 
01638           temp = new TGraph(count,shw_y,shw_time);
01639           temp->SetMarkerColor(fDefaultShowerMarkerColor);
01640           temp->SetMarkerSize(0.6);
01641           temp->SetMarkerStyle(fDefaultShowerMarkerStyle);    
01642           ytime->Add(temp);
01643         }
01644       }
01645     
01646       delete [] shw_tpos;
01647       delete [] shw_tpos0;
01648       delete [] shw_z0;
01649       delete [] shw_tpos1;
01650       delete [] shw_z1;
01651       delete [] shwstpx;
01652       delete [] shwstpy;
01653       delete [] shwstpz;
01654       delete [] shw_time;
01655       delete [] shw_y;
01656       delete [] shw_z; 
01657       
01658     }
01659   
01661       //Clusters
01662 
01663     //make sure there is a cluster (by checking that there's a shower)
01664     if(LeClus&&ntpEvent->nshower>0){  //begin of cluster code
01665 
01666       if(!tz_clu0){
01667         tz_clu0 = new TMultiGraph();
01668         tz_clu0->SetName("tz_clu0");
01669       }
01670       if(!tz_clu1){
01671         tz_clu1 = new TMultiGraph();
01672         tz_clu1->SetName("tz_clu1");
01673       }
01674       if(!cluLeg0)
01675         cluLeg0 = new TLegend(0.85,0.7,0.98,0.98,"  Key: ID (P_{EM})");
01676       if(!cluLeg1)
01677         cluLeg1 = new TLegend(0.85,0.7,0.98,0.98,"  Key: ID (P_{EM})");
01678     
01679       int nUclus = 0;
01680       int col0 = 1;
01681       int nVclus = 0;
01682       int col1 = 1;
01683       
01684       int *showers = ntpEvent->shw;
01685       for(int i=0;i<ntpEvent->nshower;i++){
01686         int index2 = showers[i];
01687         LoadShower(index2);
01688                 
01689         int *clusters = ntpShower->clu;
01690         int numclustp=0;
01691         int numclustp0=0;
01692         int numclustp1=0;
01693         
01694         for(int j=0;j<ntpShower->ncluster;j++){
01695           int index1 = clusters[j];
01696           if(LoadCluster(index1)) {
01697             numclustp+=ntpCluster->nstrip;
01698             if(ntpCluster->planeview==2) nUclus+=1;
01699             else if(ntpCluster->planeview==3) nVclus+=1;
01700           }
01701         }
01702       
01703         float *clu_tpos = new float[numclustp];
01704         float *clu_tpos0 = new float[numclustp];
01705         float *clu_z0 = new float[numclustp];
01706         float *clu_tpos1 = new float[numclustp];
01707         float *clu_z1 = new float[numclustp];
01708         double *clu_z = new double[numclustp];
01709         int count = 0;
01710 
01711         for(int j=0;j<ntpShower->ncluster;j++){
01712           int index1 = clusters[j];
01713           if(!LoadCluster(index1)) continue;
01714           Int_t *clustrips = ntpCluster->stp;
01715 
01716           count=0;
01717           numclustp0=0;
01718           numclustp1=0;
01719 
01720           for(int k=0;k<ntpCluster->nstrip;k++){
01721             Int_t index = clustrips[k];
01722             ntpStrip = dynamic_cast<NtpSRStrip *>(stripArray[index]);
01723 
01724             clu_tpos[count] = ntpStrip->tpos;
01725             clu_z[count]    = ntpStrip->z;
01726 
01727             if(ntpStrip->planeview==2){
01728               clu_tpos0[numclustp0] = clu_tpos[count];
01729               clu_z0[numclustp0] = clu_z[count];
01730               numclustp0+=1;
01731             }
01732             else {
01733               clu_tpos1[numclustp1] = clu_tpos[count];
01734               clu_z1[numclustp1] = clu_z[count];
01735               numclustp1+=1;
01736             }
01737             count++;
01738           }
01739               
01740           if(numclustp0>0){
01741             TGraph *temp = new TGraph(numclustp0,clu_z0,clu_tpos0);
01742             if(col0==10) col0+=1;
01743             temp->SetMarkerColor(col0);
01744             temp->SetMarkerSize(0.6);
01745             temp->SetMarkerStyle(21);
01746             if(ntpCluster->id==2 || 
01747                ntpCluster->id==4) temp->SetMarkerStyle(25);
01748             tz_clu0->Add(temp);
01749             col0+=1;
01750             char ssnom[256];
01751             if(ntpCluster->id==0||ntpCluster->id==1){
01752               sprintf(ssnom,"%s (%.2f)",
01753                       ClusterType::AsString(ClusterType::
01754                                             EClusterType(ntpCluster->id)),
01755                       ntpCluster->probem);
01756             }
01757             else {
01758               sprintf(ssnom,"%s",
01759                       ClusterType::AsString(ClusterType::
01760                                             EClusterType(ntpCluster->id)));
01761             }
01762             cluLeg0->AddEntry(temp,ssnom,"p");
01763           }
01764         
01765           if(numclustp1>0){
01766             if(col1==10) col1+=1;
01767             TGraph *temp = new TGraph(numclustp1,clu_z1,clu_tpos1);
01768             temp->SetMarkerColor(col1);
01769             temp->SetMarkerSize(0.6);
01770             temp->SetMarkerStyle(21);
01771             if(ntpCluster->id==2 || 
01772                ntpCluster->id==4) temp->SetMarkerStyle(25);
01773             tz_clu1->Add(temp);
01774             col1+=1;
01775             char ssnom[256];
01776             if(ntpCluster->id==0||ntpCluster->id==1){
01777               sprintf(ssnom,"%s (%.2f)",
01778                       ClusterType::AsString(ClusterType::
01779                                             EClusterType(ntpCluster->id)),
01780                       ntpCluster->probem);
01781             }
01782             else {
01783               sprintf(ssnom,"%s",
01784                       ClusterType::AsString(ClusterType::
01785                                             EClusterType(ntpCluster->id)));
01786             }
01787             cluLeg1->AddEntry(temp,ssnom,"p");
01788           }
01789         }
01790         
01791         delete [] clu_tpos;
01792         delete [] clu_z;
01793         delete [] clu_tpos0;
01794         delete [] clu_z0;
01795         delete [] clu_tpos1;
01796         delete [] clu_z1;
01797         
01798       }
01799       if(nUclus==0) {
01800         delete tz_clu0;
01801         tz_clu0=NULL;
01802       }
01803       if(nVclus==0) {
01804         delete tz_clu1;
01805         tz_clu1=NULL;
01806       }
01807     }
01808       
01810     if(isEM){ //make sure there is an EM chain
01811     
01812       //make sure there is a shower
01813       if(ntpEMSummary->nshower!=0){ 
01814 
01815         if(!tz_emshw0){
01816           tz_emshw0 = new TMultiGraph();
01817           tz_emshw0->SetName("tz_emshw0");
01818         }
01819         if(!tz_emshw1){
01820           tz_emshw1 = new TMultiGraph();
01821           tz_emshw1->SetName("tz_emshw1");
01822         }
01823         int numemshwstp=0;
01824         int numemshwstp0=0;
01825         int numemshwstp1=0;
01826         
01827         for(int i=0;i<ntpEMSummary->nshower;i++){
01828           LoadEMShower(i);
01829           numemshwstp += ntpEMShower->nstrip;
01830         }
01831         
01832         float *emshw_tpos = new float[numemshwstp];
01833         float *emshw_z = new float[numemshwstp];
01834         float *emshw_tpos0 = new float[numemshwstp];
01835         float *emshw_z0 = new float[numemshwstp];
01836         float *emshw_tpos1 = new float[numemshwstp];
01837         float *emshw_z1 = new float[numemshwstp];
01838         int count = 0;
01839         
01840         for(int i=0;i<ntpEMSummary->nshower;i++){
01841           LoadEMShower(i);
01842           Int_t *emshwstrips = ntpEMShower->stp;
01843           count=0;
01844           numemshwstp0=0;
01845           numemshwstp1=0;
01846           for(int j=0;j<ntpEMShower->nstrip;j++){
01847             Int_t index = emshwstrips[j];
01848             ntpStrip = dynamic_cast<NtpSRStrip *>(stripArray[index]);
01849             emshw_tpos[count] = ntpStrip->tpos;
01850             emshw_z[count] = ntpStrip->z;
01851             if(ntpStrip->planeview==2){
01852               emshw_tpos0[numemshwstp0] = emshw_tpos[count];
01853               emshw_z0[numemshwstp0] = emshw_z[count];
01854               numemshwstp0+=1;
01855             }
01856             else {
01857               emshw_tpos1[numemshwstp1] = emshw_tpos[count];
01858               emshw_z1[numemshwstp1] = emshw_z[count];
01859               numemshwstp1+=1;
01860             }
01861             count++;
01862           }
01863 
01864           if(numemshwstp0>0){
01865             TGraph *temp = new TGraph(numemshwstp0,emshw_z0,emshw_tpos0);
01866             temp->SetMarkerColor(7);
01867             temp->SetMarkerSize(0.6);
01868             temp->SetMarkerStyle(4);
01869             tz_emshw0->Add(temp);
01870           }
01871           else {
01872             delete tz_emshw0;
01873             tz_emshw0 = NULL;
01874           }
01875 
01876           if(numemshwstp1>0){
01877             TGraph *temp = new TGraph(numemshwstp1,emshw_z1,emshw_tpos1);
01878             temp->SetMarkerColor(7);
01879             temp->SetMarkerSize(0.6);
01880             temp->SetMarkerStyle(4);
01881             tz_emshw1->Add(temp);
01882           }
01883           else {
01884             delete tz_emshw1;
01885             tz_emshw1 = NULL;
01886           }
01887         }
01888         delete [] emshw_tpos;
01889         delete [] emshw_z;
01890         delete [] emshw_tpos0;
01891         delete [] emshw_z0;
01892         delete [] emshw_tpos1;
01893         delete [] emshw_z1;
01894       }
01895     }
01896   
01898     //Tracks
01899   
01900     if(ntpEvent->ntrack>0){ //begin of track code
01901       if(!tz_trk0){
01902         tz_trk0 = new TMultiGraph();
01903         tz_trk0->SetName("tz_trk0");
01904       }
01905       if(!tz_trk1){
01906         tz_trk1 = new TMultiGraph();
01907         tz_trk1->SetName("tz_trk1");
01908       }
01909       if(!xz_trk){
01910         xz_trk = new TMultiGraph();
01911         xz_trk->SetName("xz_trk");
01912       }
01913       if(!yz_trk){
01914         yz_trk = new TMultiGraph();
01915         yz_trk->SetName("yz_trk");
01916       }
01917       if(!yx_trk){
01918         yx_trk = new TMultiGraph();
01919         yx_trk->SetName("yx_trk");
01920       }
01921       if(!ztime){
01922         ztime = new TMultiGraph();
01923         ztime->SetName("ztime");
01924         ztime->SetTitle("Time vs Z view");
01925       }
01926       if(!ytime){
01927         ytime = new TMultiGraph();
01928         ytime->SetName("ytime");
01929         ytime->SetTitle("Time vs Y view");
01930       }
01931     
01932       int *tracks = ntpEvent->trk;
01933       
01934       int totnumtrkstp = 0;
01935       int numtrkstpcnt = 0;
01936       int numtrkstp0 = 0;
01937       int numtrkstp1 = 0;
01938     
01939       for(int itrk=0;itrk<ntpEvent->ntrack;itrk++) {
01940         int index = tracks[itrk];
01941         LoadTrack(index);
01942         totnumtrkstp += ntpTrack->nstrip;
01943       }
01944     
01945       //just in case there are no strips in the track
01946       if(totnumtrkstp!=0) { 
01947         
01948         float *trk_tpos = new float[totnumtrkstp];
01949         float *trk_tpos0 = new float[totnumtrkstp];
01950         float *trk_tpos1 = new float[totnumtrkstp];
01951         float *trkstpz0 = new float[totnumtrkstp];
01952         float *trkstpz1 = new float[totnumtrkstp];
01953         
01954         float *trkstpx = new float[totnumtrkstp];
01955         float *trkstpy = new float[totnumtrkstp];
01956         float *trkstpz = new float[totnumtrkstp];
01957         
01958         int alpha = 0;
01959         double *trk_time = new double[totnumtrkstp*2];
01960         double *trk_y = new double[totnumtrkstp*2];
01961         double *trk_z = new double[totnumtrkstp*2];
01962       
01963         for(int itrk=0;itrk<ntpEvent->ntrack;itrk++){
01964           
01965           int index1 = tracks[itrk];
01966           LoadTrack(index1);
01967         
01968           int numtrkstp = ntpTrack->nstrip;
01969         
01970           float *trk_stp_x = ntpTrack->stpx;
01971           float *trk_stp_y = ntpTrack->stpy;
01972           float *trk_stp_z = ntpTrack->stpz;
01973         
01974           double *trkstpt0 = ntpTrack->stpt0;
01975           double *trkstpt1 = ntpTrack->stpt1;
01976           
01977           int *trkstrips = ntpTrack->stp;
01978           numtrkstpcnt=0;
01979           numtrkstp0=0;
01980           numtrkstp1=0;
01981           alpha=0;
01982         
01983           for(int i=0;i<numtrkstp;i++){
01984             int index = trkstrips[i];
01985             ntpStrip = dynamic_cast<NtpSRStrip *>(stripArray[index]);
01986             
01987             trkstpx[numtrkstpcnt] = trk_stp_x[i];
01988             trkstpy[numtrkstpcnt] = trk_stp_y[i];
01989             trkstpz[numtrkstpcnt] = trk_stp_z[i];
01990             trk_tpos[numtrkstpcnt] = ntpStrip->tpos;
01991             numtrkstpcnt++;
01992             
01993             if(ntpStrip->planeview==2){
01994               trk_tpos0[numtrkstp0] = ntpStrip->tpos;
01995               trkstpz0[numtrkstp0] = trk_stp_z[i];
01996               numtrkstp0+=1;
01997             }
01998             else {
01999               trk_tpos1[numtrkstp1] = ntpStrip->tpos;
02000               trkstpz1[numtrkstp1] = trk_stp_z[i];
02001               numtrkstp1+=1;
02002             }
02003           }
02004           
02005           for(int i=0;i<numtrkstp;i++){
02006             if(trkstpt0[i]!=-999999){
02007               trk_time[alpha] = 1e9*(trkstpt0[i]-eventSummary->trigtime);
02008               trk_z[alpha] = trk_stp_z[i];
02009               trk_y[alpha] = trk_stp_y[i];
02010               alpha+=1;
02011             }
02012             if(trkstpt1[i]!=-999999){
02013               trk_time[alpha] = 1e9*(trkstpt1[i]-eventSummary->trigtime);
02014               trk_z[alpha] = trk_stp_z[i];
02015               trk_y[alpha] = trk_stp_y[i];
02016               alpha+=1;
02017             }
02018           }
02019 
02020           TGraph *temp = 0;
02021           if(numtrkstp0>0){
02022             temp = new TGraph(numtrkstp0,trkstpz0,trk_tpos0);
02023             temp->SetMarkerColor(2);
02024             temp->SetMarkerSize(0.6);
02025             temp->SetMarkerStyle(8);
02026             tz_trk0->Add(temp);
02027           }
02028           else {
02029             delete tz_trk0;
02030             tz_trk0 = NULL;
02031           }
02032           
02033           if(numtrkstp1>0){
02034             temp = new TGraph(numtrkstp1,trkstpz1,trk_tpos1);
02035             temp->SetMarkerColor(2);
02036             temp->SetMarkerSize(0.6);
02037             temp->SetMarkerStyle(8);
02038             tz_trk1->Add(temp);
02039           }
02040           else {
02041             delete tz_trk1;
02042             tz_trk1 = NULL;
02043           }
02044         
02045           if(numtrkstpcnt>0){
02046             temp = new TGraph(numtrkstpcnt,trkstpz,trkstpx);
02047             temp->SetMarkerColor(2);
02048             temp->SetMarkerSize(0.6);
02049             temp->SetMarkerStyle(8);
02050             xz_trk->Add(temp);
02051             
02052             temp = new TGraph(numtrkstpcnt,trkstpz,trkstpy);
02053             temp->SetMarkerColor(2);
02054             temp->SetMarkerSize(0.6);
02055             temp->SetMarkerStyle(8);
02056             yz_trk->Add(temp);
02057             
02058             temp = new TGraph(numtrkstpcnt,trkstpx,trkstpy);
02059             temp->SetMarkerColor(2);
02060             temp->SetMarkerSize(0.6);
02061             temp->SetMarkerStyle(8);
02062             yx_trk->Add(temp);
02063           }
02064 
02065           if(alpha>0){
02066             temp = new TGraph(alpha,trk_z,trk_time);
02067             temp->SetMarkerColor(2);
02068             temp->SetMarkerSize(0.6);
02069             temp->SetMarkerStyle(8);
02070             ztime->Add(temp);   
02071             
02072             temp = new TGraph(alpha,trk_y,trk_time);
02073             temp->SetMarkerColor(2);
02074             temp->SetMarkerSize(0.6);
02075             temp->SetMarkerStyle(8);    
02076             ytime->Add(temp);
02077           }
02078         }
02079       
02080         delete [] trkstpx;
02081         delete [] trkstpy;
02082         delete [] trkstpz;
02083         delete [] trk_tpos;
02084         delete [] trk_tpos0;
02085         delete [] trk_tpos1;
02086         delete [] trkstpz0;
02087         delete [] trkstpz1;
02088         delete [] trk_time;
02089         delete [] trk_y;
02090         delete [] trk_z; 
02091         
02092       }
02093     }
02094   } //end of reco code
02095   
02096   //Veto Shield
02097   if(!yx_veto) {
02098     yx_veto = new TMultiGraph();
02099     yx_veto->SetName("yx_veto");
02100   }
02101   if(!ytime_veto) {
02102     ytime_veto = new TMultiGraph();
02103     ytime_veto->SetName("ytime_veto");
02104   }
02105 
02106   if(shieldstripArray.GetEntries()!=0&&shieldSummary->ishit){
02107     int nvetostp = shieldstripArray.GetEntries();    
02108     double *vetostp_x = new double[nvetostp];
02109     double *vetostp_y = new double[nvetostp];
02110     double *veto_y = new double[nvetostp*2];
02111     double *veto_time = new double[nvetostp*2];
02112     int beta = 0;
02113     
02114     for(int i=0;i<nvetostp;i++) {
02115       ntpShieldStrip = dynamic_cast<NtpSRShieldStrip *>(shieldstripArray[i]);
02116       vetostp_x[i] = ntpShieldStrip->x;
02117       vetostp_y[i] = ntpShieldStrip->y;
02118       
02119       veto_time[beta] = ntpShieldStrip->time[0];
02120       veto_y[beta] = vetostp_y[i];
02121       beta+=1;
02122       
02123       veto_time[beta] = ntpShieldStrip->time[1];
02124       veto_y[beta] = vetostp_y[i];
02125       beta+=1;      
02126     }
02127     
02128     TGraph *temp1 = new TGraph(nvetostp,vetostp_x,vetostp_y);
02129     temp1->SetMarkerColor(7);
02130     temp1->SetMarkerSize(0.6);
02131     temp1->SetMarkerStyle(8);
02132     yx_veto->Add(temp1);
02133 
02134     TGraph *temp2 = new TGraph(beta,veto_y,veto_time);
02135     temp2->SetMarkerColor(7);
02136     temp2->SetMarkerSize(0.6);
02137     temp2->SetMarkerStyle(8);
02138     ytime_veto->Add(temp2);
02139     
02140     delete [] vetostp_x;
02141     delete [] vetostp_y;
02142     delete [] veto_time;
02143     delete [] veto_y;
02144   }
02145   else {
02146     delete yx_veto; yx_veto = NULL;
02147     delete ytime_veto; ytime_veto = NULL;
02148   }
02149 
02151   //Truth Angles
02152 
02153   TArrow *tz_arrow1 = 0;     // arrows to show direction of
02154   TArrow *tz_arrow2 = 0;     // neutrino in tz view
02155   float nu_mu_angle = 0; // angle between nu and mu P3 vectors in rad
02156   float nu_el_angle = 0; // angle between nu and el P3 vectors in rad
02157   float zen_mu_angle = 0; // angle between mu and zenith P3 vectors in rad
02158 
02159   MainCanvas->cd(1);
02160   gPad->Clear();
02161   
02162   if(isMC){
02163     
02164     TVector3 *nuvec = new TVector3(ntpTruth->p4neunoosc[0],
02165                                    ntpTruth->p4neunoosc[1],
02166                                    ntpTruth->p4neunoosc[2]);
02167     TVector3 *muvec = new TVector3(ntpTruth->p4mu1[0],
02168                                    ntpTruth->p4mu1[1],
02169                                    ntpTruth->p4mu1[2]);
02170     TVector3 *elvec = new TVector3(ntpTruth->p4el1[0],
02171                                    ntpTruth->p4el1[1],
02172                                    ntpTruth->p4el1[2]);
02173     TVector3 *zenith = new TVector3(0,-1,0);
02174 
02175     nu_mu_angle = nuvec->Angle(*muvec);
02176     nu_el_angle = nuvec->Angle(*elvec);
02177     zen_mu_angle = muvec->Angle(*zenith);
02178     
02179     nuvec->RotateZ(-TMath::Pi()/4.);
02180     muvec->RotateZ(-TMath::Pi()/4.);
02181     TVector3 unitnu;
02182     if(ntpTruth->p4neu[3]<0.00001) unitnu = muvec->Unit();
02183     else unitnu = nuvec->Unit();
02184     
02185     float mc_vtxu = ntpTruth->vtxx/(sqrt(2.)) 
02186       + ntpTruth->vtxy/(sqrt(2.));
02187     float mc_vtxv = - ntpTruth->vtxx/(sqrt(2.)) 
02188       + ntpTruth->vtxy/(sqrt(2.));
02189 
02190  
02191     tz_arrow1 = new TArrow(ntpTruth->vtxz-unitnu.Z(),
02192                            mc_vtxu-unitnu.X(),
02193                            ntpTruth->vtxz,mc_vtxu,0.02,"|>");
02194     tz_arrow1->SetFillColor(5);
02195     tz_arrow1->SetLineColor(9);
02196     tz_arrow1->SetLineWidth(2);
02197 
02198     tz_arrow2 = new TArrow(ntpTruth->vtxz-unitnu.Z(),
02199                            mc_vtxv-unitnu.Y(),
02200                            ntpTruth->vtxz,mc_vtxv,0.02,"|>");
02201     tz_arrow2->SetFillColor(5);
02202     tz_arrow2->SetLineColor(9);
02203     tz_arrow2->SetLineWidth(2);
02204 
02205     delete nuvec;
02206     delete muvec;
02207     delete elvec;
02208   }
02209 
02210   //StdHep line drawing code from Tingjun:
02211   //stdhep vectors
02212   TLine** paru = 0;
02213   TLine** parv = 0;
02214   bool usingparuv = false; // keep track to avoid using them if they aren't allocated
02215   int nstdhep = 0;
02216   int *drawline = 0;
02217   if (isMC&&isTH){
02218     TClonesArray* pointHepArray = NULL;
02219     if(isST) pointHepArray = (strecord->stdhep);
02220     else pointHepArray = (mcrecord->stdhep);
02221     TClonesArray& heparray = *pointHepArray;
02222     nstdhep = heparray.GetLast()+1;
02223     double *vtx_u = new double[nstdhep];
02224     double *vtx_v = new double[nstdhep];
02225     double *vtx_z = new double[nstdhep];
02226     double *p_u = new double[nstdhep];
02227     double *p_v = new double[nstdhep];
02228     double *p_z = new double[nstdhep];
02229     double *p_tot = new double[nstdhep];
02230     double *k_u = new double[nstdhep];
02231     double *k_v = new double[nstdhep];
02232     double *epar = new double[nstdhep];
02233     int *idhep = new int[nstdhep];
02234     drawline = new int[nstdhep];
02235 
02236     if(LoadTHEvent(theEvent)) {
02237       NtpMCStdHep* hep0 = 
02238         dynamic_cast<NtpMCStdHep*>(heparray[ntpTHEvent->neustdhep]);
02239       int currentmc = hep0->mc;
02240     
02241       for (int istd = 0; istd < nstdhep; istd++){
02242         NtpMCStdHep* hep =  dynamic_cast<NtpMCStdHep*>(heparray[istd]);
02243         drawline[istd] = 0;
02244         vtx_u[istd] = (hep->vtx[0]+hep->vtx[1])*sqrt(2.)/2;
02245         vtx_v[istd] = (hep->vtx[1]-hep->vtx[0])*sqrt(2.)/2;
02246         vtx_z[istd] = hep->vtx[2];
02247         
02248         p_u[istd] = (hep->p4[0]+hep->p4[1])*sqrt(2.)/2;
02249         p_v[istd] = (hep->p4[1]-hep->p4[0])*sqrt(2.)/2;
02250         p_z[istd] = hep->p4[2];
02251         p_tot[istd] = sqrt(p_u[istd]*p_u[istd] + p_v[istd]*p_v[istd] + 
02252                            p_z[istd]*p_z[istd]);
02253         
02254         epar[istd] = hep->p4[3];
02255         idhep[istd] = abs(hep->IdHEP);
02256         if (fabs(p_z[istd])>0.) {
02257           k_u[istd] = p_u[istd]/p_z[istd];
02258           k_v[istd] = p_v[istd]/p_z[istd];
02259         }
02260 
02261         bool drawphoton = false;
02262         if (abs(hep->IdHEP)==22){//photon
02263           NtpMCStdHep*hep_parent = 
02264             dynamic_cast<NtpMCStdHep*>(heparray[hep->parent[0]]);
02265           if (abs(hep_parent->IdHEP)!=111) drawphoton = true;
02266         }
02267         //decide what to draw
02268         /*
02269         if((hep->mc==currentmc && hep->child[0]==-1 && hep->child[1]==-1 &&
02270           abs(hep->IdHEP)<10000 && 
02271             (abs(hep->IdHEP)==22 && drawphoton || abs(hep->IdHEP)!=22)) || 
02272            (hep->mc==currentmc && abs(hep->IdHEP)==111)) drawline[istd]=1;
02273         */
02274         if(hep->mc==currentmc){
02275           hep->Print();
02276           // draw all final state particles except photons from pi0 decay
02277           if(hep->IstHEP==1 && hep->IdHEP<10000){
02278             // do not draw geantinos (probably made by intranuke)
02279             if(hep->IdHEP!=28) drawline[istd]=1;
02280             //      if(hep->IdHEP!=22) drawline[istd]=1;
02281             //      else if(drawphoton) drawline[istd]=1;
02282           }
02283         }
02284       }
02285       paru = new TLine*[nstdhep];
02286       parv = new TLine*[nstdhep];
02287       usingparuv = true;
02288       for (int istd = 0; istd < nstdhep; istd++){
02289         if (drawline[istd] == 1){
02290           if(p_tot[istd]<=0.001) {
02291             drawline[istd]=0;
02292             continue;
02293           }
02294           float pztot = p_z[istd]/p_tot[istd];
02295           float putot = p_u[istd]/p_tot[istd];
02296           float pvtot = p_v[istd]/p_tot[istd];
02297           paru[istd] = new TLine(vtx_z[istd], vtx_u[istd],
02298                                  vtx_z[istd] + pztot*epar[istd]/3,
02299                                  vtx_u[istd] + putot*epar[istd]/3);
02300           parv[istd] = new TLine(vtx_z[istd], vtx_v[istd],
02301                                  vtx_z[istd] + pztot*epar[istd]/3,
02302                                  vtx_v[istd] + pvtot*epar[istd]/3);
02303           if(idhep[istd] == 11) {     //electron
02304             paru[istd]->SetLineColor(3);
02305             parv[istd]->SetLineColor(3);
02306           }
02307           else if(idhep[istd] == 13) {//muon
02308             paru[istd]->SetLineColor(4);
02309             parv[istd]->SetLineColor(4);
02310           }
02311           else if(idhep[istd] == 15) {//tau
02312             paru[istd]->SetLineColor(1);
02313             parv[istd]->SetLineColor(1);
02314           }
02315           else if(idhep[istd] == 211){//pion
02316             paru[istd]->SetLineColor(6);
02317             parv[istd]->SetLineColor(6);
02318           }
02319           else if(idhep[istd] == 2212){//proton
02320             paru[istd]->SetLineColor(2);
02321             parv[istd]->SetLineColor(2);
02322           }
02323           else if(idhep[istd] == 111) { //pi0
02324             paru[istd]->SetLineColor(7);
02325             parv[istd]->SetLineColor(7);
02326           }
02327           else if(idhep[istd] == 22){  //photon
02328             paru[istd]->SetLineColor(9);
02329             parv[istd]->SetLineColor(9);
02330           }
02331           else if(idhep[istd] == 2112){//neutron
02332             paru[istd]->SetLineColor(28);
02333             parv[istd]->SetLineColor(28);
02334           }
02335           else if(idhep[istd] == 321 || idhep[istd] == 311 || 
02336                   idhep[istd] == 310 || idhep[istd] == 130){//kaon
02337             paru[istd]->SetLineColor(31);
02338             parv[istd]->SetLineColor(31);
02339           }//anything else will be black
02340           else if(idhep[istd] == 12 || idhep[istd] == 14 ||
02341                   idhep[istd] == 16){  //outgoing neutrino
02342             paru[istd]->SetLineStyle(2); //black, dashed line
02343             parv[istd]->SetLineStyle(2);
02344           }
02345         }
02346       }
02347     }
02348 
02349     delete[] vtx_u;
02350     delete[] vtx_v;
02351     delete[] vtx_z;
02352     delete[] p_u;
02353     delete[] p_v;
02354     delete[] p_z;
02355     delete[] p_tot;
02356     delete[] k_u;
02357     delete[] k_v;
02358     delete[] epar;
02359     delete[] idhep;
02360   }
02361 
02363   //Text Box
02364   this->DrawTextBox(MainCanvas,isReco);
02365 
02367   //Start Drawing
02368 
02369   RecoCanvas->cd(1);
02370   gPad->Clear();
02371   xz_place->Draw();
02372   if(xz_trk) xz_trk->Draw("P");
02373   if(xz_shw) xz_shw->Draw("P");
02374 
02375   RecoCanvas->cd(4);
02376   gPad->Clear();
02377   yz_place->Draw();
02378   if(yz_trk) yz_trk->Draw("P");
02379   if(yz_shw) yz_shw->Draw("P");
02380 
02381   RecoCanvas->cd(2);
02382   gPad->Clear();
02383 
02384   if(ntpHeader->GetVldContext().GetDetector()==Detector::kNear){
02385     yx_place->GetXaxis()->SetRangeUser(-2.6,3.8);
02386     yx_place->GetYaxis()->SetRangeUser(-3.2,3.2);
02387     
02388   }
02389   else {
02390     yx_place->GetXaxis()->UnZoom();
02391     yx_place->GetYaxis()->UnZoom();
02392   }
02393   yx_place->Draw();  
02394 
02395 
02396   // dp - draw fid vol outline before drawing tracks/showers
02397   if(ntpHeader->GetVldContext().GetDetector()==Detector::kFar) 
02398     ellie->Draw();
02399 
02400 
02401   if(yx_trk) yx_trk->Draw("P");
02402   if(yx_shw) yx_shw->Draw("P");
02403   if(yx_veto) yx_veto->Draw("P");
02404   // mike: draw plane outlines here
02405   line->Draw();
02406   if(ntpHeader->GetVldContext().GetDetector()==Detector::kNear){
02407     fu1_outline->Draw();
02408     fu2_outline->Draw();
02409     fv1_outline->Draw();
02410     fv2_outline->Draw();
02411     pu1_outline->Draw();
02412     //  pu2_outline->Draw();
02413     pv1_outline->Draw();
02414     //  pv2_outline->Draw();
02415   }
02416 
02417 
02418 
02419   RecoCanvas->cd(3);
02420   TVirtualPad *RecoCanvas_3 = RecoCanvas->GetPad(3);
02421   RecoCanvas_3->Clear();
02422 
02423   tz_place_0->Draw(tz_place_dopt.c_str());
02424   tz_place_0->SetAxisRange(lowest_z,highest_z,"X");
02425   tz_place_0->SetAxisRange(lowest_t0,highest_t0,"Y");
02426   
02427   if(tz_stp_0) tz_stp_0->Draw("P");
02428   if(tz_stp_mid_0) tz_stp_mid_0->Draw("P");
02429   if(tz_stp_spe_0) tz_stp_spe_0->Draw("P");
02430 
02431   if(tz_trk0) tz_trk0->Draw("P");
02432   if(tz_shw0) tz_shw0->Draw("P");
02433   if(tz_emshw0) tz_emshw0->Draw("P");
02434 
02435   RecoCanvas_3->Update();
02436   RecoCanvas_3->Modified();
02437 
02438   RecoCanvas->cd(5);
02439   TVirtualPad *RecoCanvas_5 = RecoCanvas->GetPad(5);
02440   RecoCanvas_5->cd(1);
02441   gPad->Clear();
02442   if(ytime){
02443     ytime->Draw("AP");
02444     ytime->GetXaxis()->SetTitle("y position (m)");
02445     ytime->GetYaxis()->SetTitle("time (ns)");
02446     if(ytime_veto) ytime_veto->Draw("P");
02447   }
02448   gPad->Update();
02449   gPad->Modified();
02450 
02451   RecoCanvas_5->cd(2);
02452   gPad->Clear();
02453   if(ztime) {
02454     ztime->Draw("AP");
02455     ztime->GetXaxis()->SetTitle("z position (m)");
02456     ztime->GetYaxis()->SetTitle("time (ns)");
02457   }
02458   gPad->Update();
02459   gPad->Modified();
02460 
02461   RecoCanvas->cd(6);
02462   gPad->Clear(); 
02463   tz_place_1->Draw(tz_place_dopt.c_str());
02464   tz_place_1->SetAxisRange(lowest_z,highest_z,"X");
02465   tz_place_1->SetAxisRange(lowest_t1,highest_t1,"Y");
02466   
02467   if(tz_stp_1) tz_stp_1->Draw("P");
02468   if(tz_stp_mid_1) tz_stp_mid_1->Draw("P");
02469   if(tz_stp_spe_1) tz_stp_spe_1->Draw("P");
02470   
02471   if(tz_trk1) tz_trk1->Draw("P");
02472   if(tz_shw1) tz_shw1->Draw("P");
02473   if(tz_emshw1) tz_emshw1->Draw("P");
02474 
02475   gPad->Update();
02476   gPad->Modified();
02477 
02479 
02480   MainCanvas->cd(3);
02481   gPad->Clear();
02482 
02483   tz_place_0->Draw(tz_place_dopt.c_str());
02484 
02485   if(nstp_big_0>0) tz_stp_0->Draw("P");
02486   if(nstp_mid_0>0) tz_stp_mid_0->Draw("P");
02487   if(nstp_spe_0>0) tz_stp_spe_0->Draw("P");
02488   
02489   if(tz_trk0) tz_trk0->Draw("P");
02490   if(tz_shw0) tz_shw0->Draw("P");
02491   if(tz_emshw0) tz_emshw0->Draw("P");
02492   if(isMC) {
02493     tz_arrow1->Draw();
02494     if(isTH && usingparuv){
02495       for (int istd = 0; istd < nstdhep; istd++){
02496         if (drawline[istd] == 1) paru[istd]->Draw("same");
02497       }
02498     }
02499   }
02500   gPad->Modified();
02501   gPad->Update();
02502 
02503   MainCanvas->cd(4);
02504   gPad->Clear();
02505 
02506   tz_place_1->Draw(tz_place_dopt.c_str());
02507 
02508   if(nstp_big_1>0) tz_stp_1->Draw("P");
02509   if(nstp_mid_1>0) tz_stp_mid_1->Draw("P");
02510   if(nstp_spe_1>0) tz_stp_spe_1->Draw("P");
02511 
02512   if(tz_trk1) tz_trk1->Draw("P");
02513   if(tz_shw1) tz_shw1->Draw("P");
02514   if(tz_emshw1) tz_emshw1->Draw("P");
02515   if(isMC) {
02516     tz_arrow2->Draw();
02517     if(isTH && usingparuv){
02518       for (int istd = 0; istd < nstdhep; istd++){
02519         if (drawline[istd] == 1) parv[istd]->Draw("same");
02520       }
02521     }
02522   }
02523 
02525 
02526   if(LeLego) {
02527     tz_0_lego->SetAxisRange(lowest_plane,highest_plane,"X");
02528     tz_1_lego->SetAxisRange(lowest_plane,highest_plane,"X");
02529     tz_0_lego->SetAxisRange(lowest_t0,highest_t0,"Y");
02530     tz_1_lego->SetAxisRange(lowest_t1,highest_t1,"Y");
02531 
02532     LegoCanvas->cd(1);
02533     tz_0_lego->Draw("LEGO2");
02534     gPad->Update();
02535     gPad->Modified();
02536 
02537     LegoCanvas->cd(2);
02538     tz_1_lego->Draw("LEGO2");
02539     gPad->Update();
02540     gPad->Modified();
02541   }
02542 
02544 
02545   if(LeClus){
02546     ClusterCanvas->cd(1);
02547     gPad->Clear();
02548     if(tz_clu0) {
02549       if(tz_clu0->Sizeof()>0){
02550         tz_place_0->Draw(tz_place_dopt.c_str());
02551         tz_clu0->Draw("P");
02552         if(cluLeg0) cluLeg0->Draw();
02553         if(isMC) {
02554           //tz_arrow1->Draw();
02555           if(isTH){
02556             for (int istd = 0; istd < nstdhep; istd++){
02557               if (drawline[istd] == 1) paru[istd]->Draw("same");
02558             }
02559           }
02560         }
02561       }
02562     }
02563     gPad->Update();
02564     gPad->Modified();    
02565     
02566     ClusterCanvas->cd(2);
02567     gPad->Clear();
02568     if(tz_clu1) {
02569       if(tz_clu1->Sizeof()>0){
02570         tz_place_1->Draw(tz_place_dopt.c_str());
02571         tz_clu1->Draw("P");
02572         if(cluLeg1) cluLeg1->Draw();
02573         if(isMC) {
02574           //tz_arrow2->Draw();
02575           if(isTH){
02576             for (int istd = 0; istd < nstdhep; istd++){
02577               if (drawline[istd] == 1) parv[istd]->Draw("same");
02578             }
02579           }
02580         }
02581       }
02582     }
02583     gPad->Update();
02584     gPad->Modified();
02585   }
02586 
02587   //delete stdhep 
02588   if (isMC&&isTH) delete[] drawline;
02589 
02591   //Print To Terminal
02592 
02593   if(ptt_msg) {
02594 
02595     float Sum_mcA = 0;
02596     float Sum_mcB = 0;
02597     //for(int i=0;i<500;i++){
02598     //  for(int j=0;j<192;j++){
02599     //    if(ATH_mcA[i][j]>0||ATH_mcB[i][j]>0) {
02600     //  Sum_mcA+=ATH_mcA[i][j];
02601     //  Sum_mcB+=ATH_mcB[i][j];      
02602     //   }
02603     // }
02604     //}
02605     
02606     std::cout << "Run: " << ntpHeader->GetRun() 
02607               << " Snarl: " << ntpHeader->GetSnarl() 
02608               << " (entry: " << entry << ")" << std::endl;
02609     std::cout << "-----------------------------------" << std::endl;
02610     std::cout << "Truth:" << std::endl;
02611     std::cout << "\tSummed PEs=" << Sum_mcA+Sum_mcB << "\tSummed PEs/0.6=" 
02612               << (Sum_mcA+Sum_mcB)/0.6 << std::endl;
02613     std::cout << "-----------------------------------" << std::endl;
02614     std::cout << "Reco:" << std::endl;
02615     std::cout << "\tNumber of slices\t"<< eventSummary->nslice << std::endl;
02616     std::cout << "\tSummed Raw Charge in Snarl (Current Slice) " 
02617               << eventSummary->ph.raw << " (" 
02618               << ntpSlice->ph.raw << ")" << std::endl; 
02619     std::cout << "\tSummed PEs in Snarl (Current Slice) " 
02620               << eventSummary->ph.pe << " (" 
02621               << ntpSlice->ph.pe << ")" << std::endl; 
02622     std::cout << "\tNumber of Reco Digits in Slice = " << ntpSlice->ndigit
02623               << " Strips = " 
02624               << (nstp_spe_0+nstp_spe_1+nstp_mid_0+nstp_mid_1+nstp_big_0
02625                   +nstp_big_1) << std::endl;
02626     std::cout << "===================================" << std::endl;
02627   }
02628 
02629   MainCanvas->cd(2); //change to pad with controls
02630 
02631   return true;
02632 }

void MadEvDisplay::DrawButtons ( TCanvas *  MainCanvas  ) 

Definition at line 3695 of file MadEvDisplay.cxx.

References DrawKey2(), drawSAME, handScan, LeAction, LeAutoMat, LeClus, LeLego, LeNu, StartLogger(), and UseNuInfo.

Referenced by Display().

03695                                                   {
03696   MainCanvas->cd(2);
03697   TVirtualPad *MainCanvas_2 = MainCanvas->GetPad(2);
03698   MainCanvas_2->Range(0,0,1,1);
03699   
03700   if(!gROOT->IsBatch()){ //if we are not in batch mode, draw controls.
03701     //otherwise let the Key fill up MainCanvas_2
03702     
03703     //Next/Prev event with cuts
03704     TButton *but1 = new TButton("Next Pass","if(EVD->drawSAME) {EVD->drawSAME=false; but4b->SetFillColor(2); but4b->Modified();} EVD->LeEntry = EVD->NextPass();",0.6,0.9,1,1);
03705     but1->SetTextSize(0.5);
03706     but1->SetFillColor(4);
03707     TButton *but2 = new TButton("Previous Pass","if(EVD->drawSAME) {EVD->drawSAME=false; but4b->SetFillColor(2); but4b->Modified();} EVD->LeEntry = EVD->PrevPass();",0.2,0.9,0.6,1);
03708     but2->SetTextSize(0.5);
03709     but2->SetFillColor(5);
03710     
03711     //Next/Prev event of any kind
03712     TButton *but14 = new TButton("Step Forward","if(EVD->drawSAME) {EVD->drawSAME=false; but4b->SetFillColor(2); but4b->Modified();} EVD->LeSlice=0; EVD->LeEvent=0; EVD->LeMCevent=0; EVD->LeEntry += 1; EVD->Display(EVD->LeEntry,0,0,0,EVD->LeAutoMat);",0.6,0.8,1,0.9);
03713     but14->SetTextSize(0.5);
03714     but14->SetFillColor(4);
03715     TButton *but15 = new TButton("Step Back","if(EVD->drawSAME) {EVD->drawSAME=false; but4b->SetFillColor(2); but4b->Modified();} EVD->LeSlice=0; EVD->LeEvent=0; EVD->LeMCevent=0; EVD->LeEntry -= 1; EVD->Display(EVD->LeEntry,0,0,0,EVD->LeAutoMat);",0.2,0.8,0.6,0.9);
03716     but15->SetTextSize(0.5);
03717     but15->SetFillColor(5);
03718     
03719     //+/- slice, +/- event
03720     TButton *but10 = new TButton("Next Slc","EVD->LeSlice+=1; EVD->Display(EVD->LeEntry,EVD->LeSlice,EVD->LeEvent,EVD->LeMCevent,EVD->LeAutoMat);",0.4,0.7,0.6,0.8);
03721     but10->SetName("but10");
03722     but10->SetTextSize(0.5);
03723     but10->SetFillColor(4);
03724     
03725     TButton *but11 = new TButton("Next Evt","EVD->LeEvent+=1; EVD->Display(EVD->LeEntry,EVD->LeSlice,EVD->LeEvent,EVD->LeMCevent,EVD->LeAutoMat);",0.8,0.7,1,0.8);
03726     but11->SetName("but11");
03727     but11->SetTextSize(0.5);
03728     but11->SetFillColor(4);
03729     
03730     TButton *but12 = new TButton("Prev Slc","EVD->LeSlice-=1; EVD->Display(EVD->LeEntry,EVD->LeSlice,EVD->LeEvent,EVD->LeMCevent,EVD->LeAutoMat);",0.2,0.7,0.4,0.8);
03731     but12->SetName("but12");
03732     but12->SetTextSize(0.5);
03733     but12->SetFillColor(5);
03734     TButton *but13 = new TButton("Prev Evt","EVD->LeEvent-=1; EVD->Display(EVD->LeEntry,EVD->LeSlice,EVD->LeEvent,EVD->LeMCevent,EVD->LeAutoMat);",0.6,0.7,0.8,0.8);
03735     but12->SetName("but12");
03736     but13->SetTextSize(0.5);
03737     but13->SetFillColor(5);
03738     
03739     //Skip to, +/- MC
03740     TButton *but16 = new TButton("Prev MC","EVD->LeMCevent-=1; EVD->Display(EVD->LeEntry,EVD->LeSlice,EVD->LeEvent,EVD->LeMCevent,EVD->LeAutoMat);",0.2,0.6,0.4,0.7);
03741     but16->SetName("but16");
03742     but16->SetTextSize(0.5);
03743     but16->SetFillColor(5);
03744     TButton *but17 = new TButton("Next MC","EVD->LeMCevent+=1; EVD->Display(EVD->LeEntry,EVD->LeSlice,EVD->LeEvent,EVD->LeMCevent,EVD->LeAutoMat);",0.4,0.6,0.6,0.7);
03745     but17->SetName("but17");
03746     but17->SetTextSize(0.5);
03747     but17->SetFillColor(4);
03748     
03749     TButton *but3a = new TButton("Skip to...","if(EVD->drawSAME) {EVD->drawSAME=false; but4b->SetFillColor(2); but4b->Modified();} EVD->LeSlice=0; EVD->LeEvent=0; EVD->LeMCevent=0; EVD->LeEntry = EVD->SkipTo();",0.6,0.65,0.8,0.7);
03750     but3a->SetTextSize(0.5);
03751     but3a->SetFillColor(9);
03752     
03753     TButton *but3e = new TButton("Run,Snarl...","if(EVD->drawSAME) {EVD->drawSAME=false; but4b->SetFillColor(2); but4b->Modified();} EVD->LeSlice=0; EVD->LeEvent=0; EVD->LeMCevent=0; EVD->LeEntry = EVD->JumpTo();",0.6,0.6,0.8,0.65);
03754     but3e->SetTextSize(0.5);
03755     but3e->SetFillColor(9);
03756     
03757     TButton *but3c = new TButton("AutoMatch","if(EVD->LeAutoMat) { but3c->SetFillColor(2); but10->SetFillColor(4); but12->SetFillColor(5); but16->SetFillColor(5); but17->SetFillColor(4); EVD->LeAutoMat=false; } else { but3c->SetFillColor(3); but10->SetFillColor(15); but12->SetFillColor(15); but16->SetFillColor(15); but17->SetFillColor(15); EVD->LeAutoMat = true; }; but10->Modified(); but12->Modified(); but16->Modified(); but17->Modified();",0.8,0.6,1,0.7);
03758     but3c->SetName("but3c");
03759     but3c->SetTextSize(0.5);
03760     but3c->SetFillColor(3);
03761     
03762     if(LeAutoMat) {
03763       but10->SetFillColor(15);
03764       but12->SetFillColor(15);
03765       but16->SetFillColor(15);
03766       but17->SetFillColor(15);
03767     }
03768     //Refresh/Lego/Quit/Print
03769     
03770     TButton *but4 = new TButton("Refresh","EVD->Display(EVD->LeEntry,EVD->LeSlice,EVD->LeEvent,EVD->LeMCevent,EVD->LeAutoMat);",0.2,0.55,0.4,0.6);
03771     but4->SetTextSize(0.5);
03772     but4->SetFillColor(5);
03773 
03774     TButton *but4b = new TButton("Overlay","if(EVD->drawSAME) {EVD->drawSAME=false; but4b->SetFillColor(2);} else {EVD->drawSAME=true; but4b->SetFillColor(3);}",0.2,0.5,0.4,0.55);
03775     but4b->SetName("but4b");
03776     but4b->SetTextSize(0.5);
03777     if(drawSAME) but4b->SetFillColor(3);
03778     else but4b->SetFillColor(2);
03779     
03780     TButton *but3b = new TButton("Lego?","if(EVD->LeLego) {EVD->LeLego=false; but3b->SetFillColor(2);} else {EVD->LeLego=true; but3b->SetFillColor(3);}",0.4,0.55,0.6,0.6);
03781     but3b->SetName("but3b");
03782     but3b->SetTextSize(0.5);
03783     if(LeLego) but3b->SetFillColor(3);
03784     else but3b->SetFillColor(2);    
03785     
03786     TButton *but3d = new TButton("Clusters?","if(EVD->LeClus) {EVD->LeClus=false; but3d->SetFillColor(2);} else {EVD->LeClus=true; but3d->SetFillColor(3);}",0.4,0.5,0.6,0.55);
03787     but3d->SetName("but3d");
03788     but3d->SetTextSize(0.5);
03789     if(LeClus) but3d->SetFillColor(3);
03790     else but3d->SetFillColor(2);    
03791     
03792     TButton *but18 = new TButton("Print","EVD->PrintDisplay();",
03793                                  0.6,0.5,0.8,0.6);
03794     but18->SetTextSize(0.5);
03795     but18->SetFillColor(8);
03796     
03797     TButton *but5 = new TButton("Quit",".q",0.8,0.5,1,0.6);
03798     but5->SetTextSize(0.5);
03799     but5->SetFillColor(45);
03800     
03801     but1->Draw();
03802     but2->Draw();
03803     but3a->Draw();
03804     but3b->Draw();
03805     but3c->Draw();
03806     but3d->Draw();
03807     but3e->Draw();
03808     but4->Draw();
03809     but4b->Draw();
03810     but5->Draw();
03811     but10->Draw();
03812     but11->Draw();
03813     but12->Draw();
03814     but13->Draw();
03815     but14->Draw();
03816     but15->Draw();
03817     but16->Draw();
03818     but17->Draw();
03819     but18->Draw();
03820     
03821     if(!handScan) {
03822       
03823       //Buttons to select out numu/nue/NC/CC
03824       TButton *but19 = new TButton("Ignore","EVD->UseNuInfo=false; but19->SetFillColor(3); but6->SetFillColor(15); but6->Modified(); but7->SetFillColor(15); but7->Modified(); but8->SetFillColor(15); but8->Modified(); but9->SetFillColor(15); but9->Modified();",0,0.9,0.195,1);
03825       but19->SetTextSize(0.4);
03826       but19->SetName("but19");
03827       TButton *but6 = new TButton("NuMu","EVD->LeNu=14; but6->SetFillColor(3); but7->SetFillColor(2); but7->Modified(); EVD->UseNuInfo=true; but19->SetFillColor(2); but19->Modified();",0,0.8,0.195,0.9);
03828       but6->SetTextSize(0.4);
03829       but6->SetName("but6");
03830       TButton *but7 = new TButton("NuE","EVD->LeNu=12; but6->SetFillColor(2); but7->SetFillColor(3); but6->Modified(); EVD->UseNuInfo=true; but19->SetFillColor(2); but19->Modified();",0,0.7,0.195,0.8);
03831       but7->SetTextSize(0.4);
03832       but7->SetName("but7");
03833       TButton *but8 = new TButton("NC","EVD->LeAction=0; but8->SetFillColor(3); but9->SetFillColor(2); but9->Modified(); EVD->UseNuInfo=true; but19->SetFillColor(2); but19->Modified();",0,0.6,0.195,0.7);
03834       but8->SetTextSize(0.4);
03835       but8->SetName("but8");
03836       TButton *but9 = new TButton("CC","EVD->LeAction=1; but8->SetFillColor(2); but9->SetFillColor(3); but8->Modified(); EVD->UseNuInfo=true; but19->SetFillColor(2); but19->Modified();",0,0.5,0.195,0.6);
03837       but9->SetTextSize(0.4);
03838       but9->SetName("but9");
03839         
03840       if(UseNuInfo){
03841         if(LeNu==14) {but6->SetFillColor(3); but7->SetFillColor(2);}
03842         else if(LeNu==12) {but7->SetFillColor(3); but6->SetFillColor(2);}
03843           else {but6->SetFillColor(10); but7->SetFillColor(10);}
03844         if(LeAction==0) {but8->SetFillColor(3); but9->SetFillColor(2);}
03845         else if(LeAction==1) {but9->SetFillColor(3); but8->SetFillColor(2);}
03846         else {but9->SetFillColor(10); but8->SetFillColor(10);}
03847         }
03848       else {
03849         but19->SetFillColor(3); but6->SetFillColor(15); 
03850         but7->SetFillColor(15);
03851         but8->SetFillColor(15); but9->SetFillColor(15);
03852       }
03853       
03854       but6->Draw();
03855       but7->Draw();
03856       but8->Draw();
03857       but9->Draw();
03858       but19->Draw();
03859     }
03860     else StartLogger();
03861   }
03862   //else MainCanvas_2->Range(0,0,0.5,0.5);
03863   this->DrawKey2(MainCanvas_2);
03864 }

void MadEvDisplay::DrawInteractionDiagram ( Int_t  itr = 0  ) 

Definition at line 3413 of file MadEvDisplay.cxx.

References NtpMCStdHep::IdHEP, MadBase::isST, NtpMCStdHep::IstHEP, MadBase::LoadStdHep(), MadBase::LoadTruth(), Munits::m, NtpMCStdHep::mc, MadBase::mcrecord, MadBase::ntpStdHep, NtpMCStdHep::p4, NtpMCStdHep::parent, NtpStRecord::stdhep, NtpMCRecord::stdhep, and MadBase::strecord.

Referenced by MadHandScan::Cheat(), and Display().

03413                                                   {
03414 
03415   if(!LoadTruth(itr)) return;
03416 
03417   //make sure there is a canvas for my art
03418   TCanvas *can;  
03419   if(gROOT->FindObject("StdHepDiagramCanvas")) {
03420     can = (TCanvas*) gROOT->FindObject("StdHepDiagramCanvas");
03421     can->cd();    
03422     TList *theList = can->GetListOfPrimitives();
03423     TIterator *iter = theList->MakeIterator();
03424     TObject *ob;      
03425     while((ob = iter->Next())){
03426       if(ob->InheritsFrom("TLatex")) {
03427         TLatex *tex = (TLatex*) ob;
03428         delete tex;
03429       }
03430       else if(ob->InheritsFrom("TArrow")) {
03431         TArrow *ar = (TArrow*) ob;
03432         delete ar;
03433       }
03434       else if(ob->InheritsFrom("TMarker")) {
03435         TMarker *m = (TMarker*) ob;
03436         delete m;
03437       }
03438     }
03439     can->Range(0,0,1,1.1);
03440   }
03441   else {
03442     can = new TCanvas("StdHepDiagramCanvas","StdHep Diagram Canvas",0,0,900,400);
03443     can->cd();
03444     can->Range(0,0,1,1.1);
03445     TPaveText *infoTex1 = new TPaveText(0.05,1.,0.2,1.07);
03446     infoTex1->AddText("Initial State");
03447     infoTex1->SetBorderSize(1);
03448     TPaveText *infoTex2 = new TPaveText(0.3,1.,0.45,1.07);
03449     infoTex2->AddText("Intermediate");
03450     infoTex2->SetBorderSize(1);
03451     TPaveText *infoTex3 = new TPaveText(0.55,1.,0.7,1.07);
03452     infoTex3->AddText("Final State");
03453     infoTex3->SetBorderSize(1);
03454     TPaveText *infoTex4 = new TPaveText(0.8,1.,0.95,1.07);
03455     infoTex4->AddText("Later Decays");
03456     infoTex4->SetBorderSize(1);
03457     infoTex1->SetTextSize(0.05);
03458     infoTex1->SetTextFont(12);
03459     infoTex1->SetTextColor(1);
03460     infoTex2->SetTextSize(0.05);
03461     infoTex2->SetTextFont(12);
03462     infoTex2->SetTextColor(1);
03463     infoTex3->SetTextSize(0.05);
03464     infoTex3->SetTextFont(12);
03465     infoTex3->SetTextColor(1);
03466     infoTex4->SetTextSize(0.05);
03467     infoTex4->SetTextFont(12);
03468     infoTex4->SetTextColor(1);
03469     infoTex1->SetName("infoTex1");
03470     infoTex2->SetName("infoTex2");
03471     infoTex3->SetName("infoTex3");
03472     infoTex4->SetName("infoTex4");
03473     infoTex1->Draw();
03474     infoTex2->Draw();
03475     infoTex3->Draw();
03476     infoTex4->Draw();
03477   }
03478   
03479   //First get indices to use:
03480   TClonesArray* pointStdhepArray = NULL;
03481   if(isST) pointStdhepArray = (strecord->stdhep);
03482   else pointStdhepArray = (mcrecord->stdhep);
03483   TClonesArray& stdhepArray = *pointStdhepArray;
03484   Int_t nStdHep = stdhepArray.GetEntries();
03485   Int_t *indicesToUse = new Int_t[nStdHep];
03486   Int_t *parent = new Int_t[nStdHep];
03487   Int_t incomingNeutrino = -1;
03488   Int_t cnt = 0;
03489   for(int i=0;i<nStdHep;i++){
03490     LoadStdHep(i);
03491     if(ntpStdHep->mc==itr) {
03492       indicesToUse[cnt] = i;
03493       parent[i] = ntpStdHep->parent[0];
03494       if(ntpStdHep->IstHEP==0){
03495         if(abs(ntpStdHep->IdHEP)==12||abs(ntpStdHep->IdHEP)==14
03496            ||abs(ntpStdHep->IdHEP)==16) {
03497           incomingNeutrino=i;
03498         }
03499         parent[i] = -1; //don't draw arrows to initial state particles
03500       }
03501       cnt++;
03502     }
03503     else parent[i] = -1;
03504   }
03505   
03506   //make arrows and markers
03507   //  TArrow *arrow[1000];
03508   //  TMarker *marker[1000];
03509   // it is possible to have more than 1000 stdhep particles
03510   // yikes...
03511   // I think that these objects are deleted in the block at
03512   // the start of this routine.
03513   std::vector<TArrow*> arrow(nStdHep);
03514   std::vector<TMarker*> marker(nStdHep);
03515 
03516   for(int i=0;i<nStdHep;i++) {
03517     arrow[i] = new TArrow(0,0,0,0,0.03,"|>");
03518     arrow[i]->SetLineWidth(1);
03519     arrow[i]->SetLineStyle(3);
03520     arrow[i]->SetFillColor(39);
03521     arrow[i]->SetLineColor(39);
03522     marker[i] = new TMarker(0,0,24);
03523     marker[i]->SetMarkerSize(1);
03524     marker[i]->SetMarkerColor(38);
03525   }
03526 
03527   //now loop through valid stdhep entries and fill variables  
03528   Float_t Available[4] = {0.9,0.7,0.8,0.7};
03529   std::vector<int> rootino;
03530   for(int i=0;i<cnt;i++){
03531     
03532     int toUse = indicesToUse[i];
03533     LoadStdHep(toUse);
03534     if(ntpStdHep->IstHEP==999){
03535       rootino.push_back(i);
03536       continue;
03537     }
03538     Float_t mom = sqrt(ntpStdHep->p4[0]*ntpStdHep->p4[0] + 
03539                        ntpStdHep->p4[1]*ntpStdHep->p4[1] + 
03540                        ntpStdHep->p4[2]*ntpStdHep->p4[2]);
03541     float x=0.05,y=0.05;
03542     int col=0;
03543     char text[256];
03544 
03545     //set x,y    
03546     if(ntpStdHep->IstHEP==0 ||
03547        ntpStdHep->IstHEP==11 ) {
03548       x = 0.05;
03549       y=Available[0]; Available[0] -= 0.1;
03550     }
03551     else if(ntpStdHep->IstHEP==2 ||
03552             ntpStdHep->IstHEP==3 ||
03553             ntpStdHep->IstHEP==14 ) {
03554       x = 0.3;
03555       y=Available[1]; Available[1] -= 0.1;
03556     }
03557     else if(ntpStdHep->IstHEP==1){
03558       x = 0.55;
03559       y=Available[2]; Available[2] -= 0.1;
03560     }
03561     else if(ntpStdHep->IstHEP==205 ||
03562             ntpStdHep->IstHEP==1205 ) {
03563       x = 0.8;
03564       y=Available[3]; Available[3] -= 0.1;
03565     }
03566 
03567     //set colour and label
03568     if(abs(ntpStdHep->IdHEP)==12) { //nue
03569       if(parent[toUse]==incomingNeutrino) y = 0.9;
03570       sprintf(text,"#nu_{e}"); col = 3;
03571       if(ntpStdHep->IdHEP<0) sprintf(text,"#bar{#nu}_{e}");
03572     }
03573     else if(abs(ntpStdHep->IdHEP)==14) { //numu
03574       if(parent[toUse]==incomingNeutrino) y = 0.9;
03575       sprintf(text,"#nu_{#mu}"); col = 4;
03576       if(ntpStdHep->IdHEP<0) sprintf(text,"#bar{#nu}_{#mu}");
03577     }
03578     else if(abs(ntpStdHep->IdHEP)==16) { //nutau
03579       if(parent[toUse]==incomingNeutrino) y = 0.9;
03580       sprintf(text,"#nu_{#tau}"); col = 1;
03581       if(ntpStdHep->IdHEP<0) sprintf(text,"#bar{#nu}_{#tau}"); 
03582     }    
03583     else if(abs(ntpStdHep->IdHEP)==11) { //e
03584       if(parent[toUse]==incomingNeutrino) y = 0.9;
03585       sprintf(text,"e^{-}"); col = 3;
03586       if(ntpStdHep->IdHEP<0) sprintf(text,"e^{+}");
03587     }
03588     else if(abs(ntpStdHep->IdHEP)==13) { //mu
03589       if(parent[toUse]==incomingNeutrino) y = 0.9;
03590       sprintf(text,"#mu^{-}"); col = 4;
03591       if(ntpStdHep->IdHEP<0) sprintf(text,"#mu^{+}");
03592     }
03593     else if(abs(ntpStdHep->IdHEP)==15) { //tau
03594       y = 0.9;
03595       sprintf(text,"#tau^{-}"); col = 1;
03596       if(ntpStdHep->IdHEP<0) sprintf(text,"#tau^{+}"); 
03597     }
03598     else if(ntpStdHep->IdHEP==22) { //photon
03599       sprintf(text,"#gamma"); col = 9;      
03600     }
03601     else if(ntpStdHep->IdHEP>1000000000) { //nucleus
03602       y = 0.8;
03603       sprintf(text,"nucleus(%i,%i)",int((ntpStdHep->IdHEP-1e9)/1e6),
03604               int((ntpStdHep->IdHEP-1e9 - 1e6*int((ntpStdHep->IdHEP-1e9)
03605                                                   /1e6))/1e3)); 
03606       col = 15;
03607     }
03608     else if(ntpStdHep->IdHEP==2112){ 
03609       sprintf(text,"neutron"); col = 28;
03610     }
03611     else if(ntpStdHep->IdHEP==2212){
03612       sprintf(text,"proton"); col = 2;
03613     }
03614     else if(abs(ntpStdHep->IdHEP)==211) {
03615       sprintf(text,"#pi^{+}"); col = 6;
03616       if(ntpStdHep->IdHEP<0) sprintf(text,"#pi^{-}");
03617     }
03618     else if(ntpStdHep->IdHEP==111) {
03619       sprintf(text,"#pi^{0}"); col = 7;
03620     }
03621     else if(ntpStdHep->IdHEP==130) {
03622       sprintf(text,"K^{0}_{L}"); col = 31;
03623     }
03624     else if(ntpStdHep->IdHEP==310) {
03625       sprintf(text,"K^{0}_{S}"); col = 31;
03626     }
03627     else if(ntpStdHep->IdHEP==311) {
03628       sprintf(text,"K^{0}"); col = 31;
03629     }
03630     else if(abs(ntpStdHep->IdHEP)==321) {
03631       sprintf(text,"K^{+}"); col = 31;
03632       if(ntpStdHep->IdHEP<0) sprintf(text,"K^{-}"); col = 31;
03633     }
03634     else if(ntpStdHep->IdHEP==28) {
03635       sprintf(text,"Geantino"); col = 46;
03636       if(ntpStdHep->IdHEP<0) sprintf(text,"K^{-}"); col = 31;
03637     }
03638     else {
03639       sprintf(text,"ID: %i",ntpStdHep->IdHEP); col=43;
03640     }
03641 
03642     sprintf(text,"%s [%.2f GeV/c]",text,mom);
03643     
03644     arrow[toUse]->SetX2(x-0.02);   
03645     arrow[toUse]->SetY2(y-0.02);   
03646     marker[toUse]->SetX(x-0.02);
03647     marker[toUse]->SetY(y-0.02);
03648 
03649     for(int j=0;j<nStdHep;j++){
03650       if(parent[j]==toUse){
03651         arrow[j]->SetX1(x-0.02);
03652         arrow[j]->SetY1(y-0.02);
03653       }
03654     }
03655  
03656     TLatex *tex = new TLatex(x,y,text);
03657     char texname[256];
03658     sprintf(texname,"tex%i",i);
03659     tex->SetName(texname);
03660     tex->SetTextSize(0.05);
03661     tex->SetTextColor(col);    
03662     tex->Draw();
03663   }
03664 
03665   for(int i=0;i<nStdHep;i++){
03666     if(parent[i]==-1) {
03667       delete arrow[i]; arrow[i]=0;
03668     }
03669     else arrow[i]->Draw();
03670     marker[i]->Draw();
03671   }
03672 
03673   for (unsigned int j=0;j<rootino.size();j++){
03674     if (arrow[rootino[j]]){
03675       delete arrow[rootino[j]]; arrow[rootino[j]] = 0;
03676     }
03677     delete marker[rootino[j]];
03678   }
03679 
03680   Float_t minAvail = 0;
03681   for(int i=0;i<4;i++){
03682     if(Available[i]<minAvail) minAvail = Available[i];
03683   }
03684 
03685   if(minAvail<0) can->Range(0,minAvail,1,1.1);
03686 
03687   delete [] indicesToUse;
03688   delete [] parent;
03689 
03690   can->Modified();
03691   can->Update();
03692 
03693 }

void MadEvDisplay::DrawKey ( TVirtualPad *  KeyPad  )  [protected]

Definition at line 3249 of file MadEvDisplay.cxx.

References Dmid_val, and Dspe_val.

03249                                              {
03250 
03251    KeyPad->cd(2);
03252 
03253    TPave *pave = new TPave(0.02,0.02,0.98,0.48);
03254    pave->Draw();
03255 
03256    TMarker *marker = new TMarker(0.2,0.89/2.,8);
03257    marker->SetMarkerColor(3);
03258    marker->SetMarkerStyle(8);
03259    marker->SetMarkerSize(1.3);
03260    marker->Draw();
03261    marker = new TMarker(0.2,0.80/2.,8);
03262    marker->SetMarkerColor(4);
03263    marker->SetMarkerStyle(8);
03264    marker->SetMarkerSize(1.3);
03265    marker->Draw();
03266    marker = new TMarker(0.2,0.71/2.,8);
03267    marker->SetMarkerStyle(8);
03268    marker->SetMarkerSize(1.3);
03269    marker->Draw();
03270    marker = new TMarker(0.2,0.62/2.,8);
03271    marker->SetMarkerColor(2);
03272    marker->SetMarkerStyle(8);
03273    marker->SetMarkerSize(0.9);
03274    marker->Draw();
03275    marker = new TMarker(0.2,0.53/2.,4);
03276    marker->SetMarkerColor(6);
03277    marker->SetMarkerStyle(4);
03278    marker->SetMarkerSize(0.9);
03279    marker->Draw();
03280    marker = new TMarker(0.21,0.53/2.,4);
03281    marker->SetMarkerColor(7);
03282    marker->SetMarkerStyle(4);
03283    marker->SetMarkerSize(0.9);
03284    marker->Draw();
03285    marker = new TMarker(0.2,0.44/2.,25);
03286    marker->SetMarkerColor(7);
03287    marker->SetMarkerStyle(25);
03288    marker->SetMarkerSize(1.3);
03289    marker->Draw();
03290    marker = new TMarker(0.2,0.35/2.,26);
03291    marker->SetMarkerColor(3);
03292    marker->SetMarkerStyle(26);
03293    marker->SetMarkerSize(1.3);
03294    marker->Draw();
03295    marker = new TMarker(0.2,0.26/2.,27);
03296    marker->SetMarkerColor(6);
03297    marker->SetMarkerStyle(27);
03298    marker->SetMarkerSize(1.3);
03299    marker->Draw();
03300    marker = new TMarker(0.2,0.17/2.,30);
03301    marker->SetMarkerStyle(30);
03302    marker->SetMarkerSize(1.3);
03303    marker->Draw();
03304    marker = new TMarker(0.2,0.08/2.,28);
03305    marker->SetMarkerColor(6);
03306    marker->SetMarkerStyle(28);
03307    marker->SetMarkerSize(1.3);
03308    marker->Draw();
03309    TLatex *tex = new TLatex(0.04,0.86/2.,"Reco");
03310    tex->SetTextFont(132);
03311    tex->SetTextSize(0.05);
03312    tex->SetLineWidth(2);
03313    tex->Draw();
03314    tex = new TLatex(0.04,0.41/2.,"Truth");
03315    tex->SetTextFont(132);
03316    tex->SetTextSize(0.05);
03317    tex->SetLineWidth(2);
03318    tex->Draw();
03319    char temp[256];
03320    sprintf(temp,"Summed NPEs < %.1f",Dspe_val);
03321    tex = new TLatex(0.3,0.86/2.,temp);
03322    tex->SetTextFont(132);
03323    tex->SetTextSize(0.05);
03324    tex->SetLineWidth(2);
03325    tex->Draw();
03326    sprintf(temp,"%.1f < Summed NPEs < %.1f",Dspe_val,Dmid_val);
03327    tex = new TLatex(0.3,0.77/2.,temp);
03328    tex->SetTextFont(132);
03329    tex->SetTextSize(0.05);
03330    tex->SetLineWidth(2);
03331    tex->Draw();
03332    sprintf(temp,"Summed NPEs > %.1f",Dmid_val);
03333    tex = new TLatex(0.3,0.68/2.,temp);
03334    tex->SetTextFont(132);
03335    tex->SetTextSize(0.05);
03336    tex->SetLineWidth(2);
03337    tex->Draw();
03338    tex = new TLatex(0.3,0.59/2.,"Reconstructed Track Hit");
03339    tex->SetTextFont(132);
03340    tex->SetTextSize(0.05);
03341    tex->SetLineWidth(2);
03342    tex->Draw();
03343    tex = new TLatex(0.3,0.50/2.,"Reconstructed Shower Hit (cyan=EM)");
03344    tex->SetTextFont(132);
03345    tex->SetTextSize(0.05);
03346    tex->SetLineWidth(2);
03347    tex->Draw();
03348    tex = new TLatex(0.3,0.41/2.,"Primary Muon (+ secondaries)");
03349    tex->SetTextFont(132);
03350    tex->SetTextSize(0.05);
03351    tex->SetLineWidth(2);
03352    tex->Draw();
03353    tex = new TLatex(0.3,0.32/2.,"Primary Electron (+ secondaries)");
03354    tex->SetTextFont(132);
03355    tex->SetTextSize(0.05);
03356    tex->SetLineWidth(2);
03357    tex->Draw();
03358    tex = new TLatex(0.3,0.23/2.,"Recoil Shower Products");
03359    tex->SetTextFont(132);
03360    tex->SetTextSize(0.05);
03361    tex->SetLineWidth(2);
03362    tex->Draw();
03363    tex = new TLatex(0.3,0.14/2.,"Noise");
03364    tex->SetTextFont(132);
03365    tex->SetTextSize(0.05);
03366    tex->SetLineWidth(2);
03367    tex->Draw();
03368    tex = new TLatex(0.3,0.05/2.,"Other");
03369    tex->SetTextFont(132);
03370    tex->SetTextSize(0.05);
03371    tex->SetLineWidth(2);
03372    tex->Draw();
03373    tex = new TLatex(0.65,0.05/2.,"Nu Unit P");
03374    tex->SetTextFont(132);
03375    tex->SetTextSize(0.05);
03376    tex->SetLineWidth(2);
03377    tex->Draw();
03378    TArrow *arrow = new TArrow(0.5,0.09/2.,0.6,0.09/2.,0.03,"|>");
03379    arrow->SetFillColor(5);
03380    arrow->SetLineColor(9);
03381    arrow->SetLineWidth(2);
03382    arrow->Draw();
03383 }

void MadEvDisplay::DrawKey2 ( TVirtualPad *  KeyPad  )  [protected]

Definition at line 3057 of file MadEvDisplay.cxx.

References Dmid_val, Dspe_val, fDefaultShowerMarkerColor, and fDefaultShowerMarkerStyle.

Referenced by DrawButtons().

03057                                               {
03058 
03059    KeyPad->cd(2);
03060 
03061    TPave *pave = new TPave(0.02,0.02,0.98,0.48);
03062    pave->Draw();
03063    //reco:
03064    TMarker *marker = new TMarker(0.2,0.89/2.,8);
03065    marker->SetMarkerColor(3);
03066    marker->SetMarkerStyle(8);
03067    marker->SetMarkerSize(1.3);
03068    marker->Draw();
03069    marker = new TMarker(0.2,0.80/2.,8);
03070    marker->SetMarkerColor(4);
03071    marker->SetMarkerStyle(8);
03072    marker->SetMarkerSize(1.3);
03073    marker->Draw();
03074    marker = new TMarker(0.2,0.71/2.,8);
03075    marker->SetMarkerStyle(8);
03076    marker->SetMarkerSize(1.3);
03077    marker->Draw();
03078    marker = new TMarker(0.2,0.62/2.,8);
03079    marker->SetMarkerColor(2);
03080    marker->SetMarkerStyle(8);
03081    marker->SetMarkerSize(0.9);
03082    marker->Draw();
03083    marker = new TMarker(0.2,0.53/2.,4);
03084    marker->SetMarkerColor(fDefaultShowerMarkerColor);
03085    marker->SetMarkerStyle(fDefaultShowerMarkerStyle);
03086    marker->SetMarkerSize(0.9);
03087    marker->Draw();
03088    marker = new TMarker(0.21,0.53/2.,4);
03089    marker->SetMarkerColor(7);
03090    marker->SetMarkerStyle(4);
03091    marker->SetMarkerSize(0.9);
03092    marker->Draw();
03093    //truth:
03094    //electron - 3
03095    //muon - 4
03096    //tau = 1
03097    //pion - 6
03098    //proton - 2
03099    //pi0 - 7
03100    //photon - 9
03101    //neutron - 28
03102    //kaon -31
03103    TLine *line = new TLine(0.19,0.44/2.,0.25,0.44/2.);
03104    line->SetLineColor(3);
03105    line->SetLineWidth(3);
03106    line->Draw();
03107    line = new TLine(0.49,0.44/2.,0.55,0.44/2.);
03108    line->SetLineColor(4);
03109    line->SetLineWidth(3);
03110    line->Draw();
03111    line = new TLine(0.19,0.35/2.,0.25,0.35/2.);
03112    line->SetLineColor(2);
03113    line->SetLineWidth(3);
03114    line->Draw();
03115    line = new TLine(0.49,0.35/2.,0.55,0.35/2.);
03116    line->SetLineColor(28);
03117    line->SetLineWidth(3);
03118    line->Draw();
03119    line = new TLine(0.19,0.26/2.,0.25,0.26/2.);
03120    line->SetLineColor(6);
03121    line->SetLineWidth(3);
03122    line->Draw();
03123    line = new TLine(0.49,0.26/2.,0.55,0.26/2.);
03124    line->SetLineColor(7);
03125    line->SetLineWidth(3);
03126    line->Draw();
03127    line = new TLine(0.19,0.17/2.,0.25,0.17/2.);
03128    line->SetLineColor(31);
03129    line->SetLineWidth(3);
03130    line->Draw();
03131    line = new TLine(0.49,0.17/2.,0.55,0.17/2.);
03132    line->SetLineColor(9);
03133    line->SetLineWidth(3);
03134    line->Draw();
03135    line = new TLine(0.19,0.08/2.,0.25,0.08/2.);
03136    line->SetLineColor(1);
03137    line->SetLineWidth(3);
03138    line->Draw();
03139    line = new TLine(0.49,0.08/2.,0.55,0.08/2.);
03140    line->SetLineColor(1);
03141    line->SetLineStyle(2);
03142    line->SetLineWidth(3);
03143    line->Draw();
03144    
03145    TLatex *tex = new TLatex(0.04,0.86/2.,"Reco");
03146    tex->SetTextFont(132);
03147    tex->SetTextSize(0.05);
03148    tex->SetLineWidth(2);
03149    tex->Draw();
03150    tex = new TLatex(0.04,0.41/2.,"Truth");
03151    tex->SetTextFont(132);
03152    tex->SetTextSize(0.05);
03153    tex->SetLineWidth(2);
03154    tex->Draw();
03155    char temp[256];
03156    sprintf(temp,"Summed NPEs < %.1f",Dspe_val);
03157    tex = new TLatex(0.3,0.86/2.,temp);
03158    tex->SetTextFont(132);
03159    tex->SetTextSize(0.05);
03160    tex->SetLineWidth(2);
03161    tex->Draw();
03162    sprintf(temp,"%.1f < Summed NPEs < %.1f",Dspe_val,Dmid_val);
03163    tex = new TLatex(0.3,0.77/2.,temp);
03164    tex->SetTextFont(132);
03165    tex->SetTextSize(0.05);
03166    tex->SetLineWidth(2);
03167    tex->Draw();
03168    sprintf(temp,"Summed NPEs > %.1f",Dmid_val);
03169    tex = new TLatex(0.3,0.68/2.,temp);
03170    tex->SetTextFont(132);
03171    tex->SetTextSize(0.05);
03172    tex->SetLineWidth(2);
03173    tex->Draw();
03174    tex = new TLatex(0.3,0.59/2.,"Reconstructed Track Hit");
03175    tex->SetTextFont(132);
03176    tex->SetTextSize(0.05);
03177    tex->SetLineWidth(2);
03178    tex->Draw();
03179    tex = new TLatex(0.3,0.50/2.,"Reconstructed Shower Hit (cyan=EM)");
03180    tex->SetTextFont(132);
03181    tex->SetTextSize(0.05);
03182    tex->SetLineWidth(2);
03183    tex->Draw();
03184    tex = new TLatex(0.3,0.41/2.,"e");
03185    tex->SetTextFont(132);
03186    tex->SetTextSize(0.05);
03187    tex->SetLineWidth(2);
03188    tex->Draw();
03189    tex = new TLatex(0.65,0.41/2.,"#mu");
03190    tex->SetTextFont(132);
03191    tex->SetTextSize(0.05);
03192    tex->SetLineWidth(2);
03193    tex->Draw();
03194    tex = new TLatex(0.3,0.32/2.,"p");
03195    tex->SetTextFont(132);
03196    tex->SetTextSize(0.05);
03197    tex->SetLineWidth(2);
03198    tex->Draw();
03199    tex = new TLatex(0.65,0.32/2.,"n");
03200    tex->SetTextFont(132);
03201    tex->SetTextSize(0.05);
03202    tex->SetLineWidth(2);
03203    tex->Draw();
03204    tex = new TLatex(0.3,0.23/2.,"#pi^{+/-}");
03205    tex->SetTextFont(132);
03206    tex->SetTextSize(0.05);
03207    tex->SetLineWidth(2);
03208    tex->Draw();
03209    tex = new TLatex(0.65,0.23/2.,"#pi^{0}");
03210    tex->SetTextFont(132);
03211    tex->SetTextSize(0.05);
03212    tex->SetLineWidth(2);
03213    tex->Draw();
03214    tex = new TLatex(0.3,0.14/2.,"K^{+/-/0}");
03215    tex->SetTextFont(132);
03216    tex->SetTextSize(0.05);
03217    tex->SetLineWidth(2);
03218    tex->Draw();
03219    tex = new TLatex(0.65,0.14/2.,"#gamma");
03220    tex->SetTextFont(132);
03221    tex->SetTextSize(0.05);
03222    tex->SetLineWidth(2);
03223    tex->Draw();
03224    tex = new TLatex(0.3,0.05/2.,"#tau");
03225    tex->SetTextFont(132);
03226    tex->SetTextSize(0.05);
03227    tex->SetLineWidth(2);
03228    tex->Draw();
03229    tex = new TLatex(0.65,0.05/2.,"final #nu");
03230    tex->SetTextFont(132);
03231    tex->SetTextSize(0.05);
03232    tex->SetLineWidth(2);
03233    tex->Draw();
03234 
03235    TArrow *arrow = new TArrow(0.79,0.44/2.,0.89,0.44/2.,0.025,"|>");
03236    arrow->SetFillColor(5);
03237    arrow->SetLineColor(9);
03238    arrow->SetLineWidth(2);
03239    arrow->Draw();
03240    tex = new TLatex(0.79,0.32/2.,"initial #nu");
03241    tex->SetTextFont(132);
03242    tex->SetTextSize(0.05);
03243    tex->SetLineWidth(2);
03244    tex->Draw();
03245 
03246 }

void MadEvDisplay::DrawTextBox ( TCanvas *  MainCanvas,
Bool_t  isReco 
)

Definition at line 2635 of file MadEvDisplay.cxx.

References NtpTHSlice::complete, NtpTHTrack::completeall, NtpTHShower::completeall, EnergyCorrections::CorrectShowerEnergy(), det, NtpSRTrack::end, NtpSRMomentum::eqp, MadBase::eventSummary, MadMKAnalysis::FarTrkContained(), VldContext::GetDetector(), RecDataHeader::GetRun(), VldContext::GetSimFlag(), RecPhysicsHeader::GetSnarl(), RecHeader::GetVldContext(), NtpSRStripPulseHeight::gev, NtpMCTruth::iaction, NtpMCTruth::inu, NtpMCTruth::iresonance, MadBase::isMC, MadBase::isST, MadBase::isTH, it, CandShowerHandle::kCC, Detector::kFar, SimFlag::kMC, Detector::kNear, LeEvent, LeMCevent, LeSlice, NtpSRShowerPulseHeight::linCCgev, MadBase::LoadShower(), MadBase::LoadTHShower(), MadBase::LoadTHSlice(), MadBase::LoadTHTrack(), MadBase::LoadTrack(), NtpStRecord::mc, NtpMCRecord::mc, MadBase::mcrecord, NtpSRTrack::momentum, NtpSREventSummary::nevent, NtpSREvent::nshower, NtpSREventSummary::nslice, MadBase::ntpEvent, MadBase::ntpHeader, MadBase::ntpShower, MadBase::ntpTHShower, MadBase::ntpTHSlice, MadBase::ntpTHTrack, MadBase::ntpTrack, MadBase::ntpTruth, NtpSREvent::ntrack, NtpMCTruth::p4el1, NtpMCTruth::p4mu1, NtpMCTruth::p4neu, NtpMCTruth::p4neunoosc, NtpMCTruth::p4shw, NtpSRShower::ph, MadMKAnalysis::PittTrkContained(), NtpTHSlice::purity, NtpTHTrack::purity, NtpTHShower::purity, NtpSRMomentum::qp, RecoMKMuEnergy(), RecoMuDCosNeuFD(), RecoMuDCosNeuND(), NtpSREvent::shw, NtpSRShower::shwph, MadBase::strecord, NtpSREvent::trk, NtpSRVertex::u, NtpSRVertex::v, NtpSRShower::vtx, NtpSRTrack::vtx, NtpMCTruth::vtxx, NtpMCTruth::vtxy, NtpMCTruth::vtxz, NtpSRVertex::x, NtpSRVertex::y, and NtpSRVertex::z.

Referenced by Display().

02635                                                                {
02636   
02637   //recalculate angles:
02638   float nu_mu_angle = 0;
02639   float nu_el_angle = 0;
02640   float zen_mu_angle = 0;
02641   if(isMC){
02642     TVector3 *nuvec = new TVector3(ntpTruth->p4neunoosc[0],
02643                                    ntpTruth->p4neunoosc[1],
02644                                    ntpTruth->p4neunoosc[2]);
02645     TVector3 *muvec = new TVector3(ntpTruth->p4mu1[0],
02646                                    ntpTruth->p4mu1[1],
02647                                    ntpTruth->p4mu1[2]);
02648     TVector3 *elvec = new TVector3(ntpTruth->p4el1[0],
02649                                    ntpTruth->p4el1[1],
02650                                    ntpTruth->p4el1[2]);
02651     TVector3 *zenith = new TVector3(0,-1,0); 
02652     nu_mu_angle = nuvec->Angle(*muvec);
02653     nu_el_angle = nuvec->Angle(*elvec);
02654     zen_mu_angle = muvec->Angle(*zenith);
02655   }
02656 
02657   //Summary
02658   char sometext1[100] = ".";
02659   if(isReco) sprintf(sometext1,
02660                      "Run: %i, Snarl: %i, Slice: %i(/%i), Event %i(/%i)",
02661                      ntpHeader->GetRun(),ntpHeader->GetSnarl(),LeSlice+1,
02662                      eventSummary->nslice,LeEvent+1,eventSummary->nevent);
02663   else sprintf(sometext1,
02664                "Run: %i, Snarl: %i, Slice: %i(/%i), Event %i(/%i)",
02665                ntpHeader->GetRun(),ntpHeader->GetSnarl(),LeSlice+1,
02666                eventSummary->nslice,0,eventSummary->nevent);
02667 
02668   //Truth
02669   char sometext2[100] = "Truth";
02670   char sometext3[100] = "N/A";
02671   char sometext4[100] = "N/A";
02672   char sometext5[100] = "N/A";
02673   char sometext6[100] = "N/A";
02674   char sometext7[100] = "N/A";
02675   char sometext8[100] = "N/A";
02676 
02677   //Reco
02678   char sometext9[100] = "N/A";
02679   char sometext10[100] = "N/A";
02680   char sometext14[100] = "N/A";
02681 
02682   if(isReco&&eventSummary->nevent!=0&&isTH) {
02683     //Slice summary:
02684     LoadTHSlice(LeSlice);
02685     if(ntpTHSlice) sprintf(sometext9,"Reco - Slice (%.3f, %.3f)",
02686                            ntpTHSlice->purity,ntpTHSlice->complete);
02687     else sprintf(sometext9,"Reco");
02688 
02689     //Shower summary:
02690     if(ntpEvent->nshower>0&&ntpTHShower){
02691       if(LoadTHShower(ntpEvent->shw[0])) 
02692         sprintf(sometext14,"     #Shws: %i (%.3f, %.3f)",
02693                 ntpEvent->nshower,ntpTHShower->purity,ntpTHShower->completeall);
02694       for(int i=1;i<ntpEvent->nshower;i++){
02695         LoadTHShower(ntpEvent->shw[i]);
02696         if(ntpTHShower) 
02697           sprintf(sometext14,"%s (%.3f, %.3f)",sometext14,ntpTHShower->purity,
02698                   ntpTHShower->completeall);
02699       }
02700     }
02701     else if(ntpEvent->nshower>0) sprintf(sometext14,"     #Shws: %i",
02702                                          ntpEvent->nshower);
02703     else sprintf(sometext14,"     #Shws: 0");
02704 
02705     //Track summary:
02706     if(ntpEvent->ntrack>0&&ntpTHTrack){
02707       sprintf(sometext10,"     #Trks: %i (%.3f, %.3f)",
02708               ntpEvent->ntrack,ntpTHTrack->purity,ntpTHTrack->completeall);
02709       for(int i=1;i<ntpEvent->ntrack;i++){
02710         LoadTHTrack(ntpEvent->trk[i]);
02711         if(ntpTHTrack) 
02712           sprintf(sometext10,"%s (%.3f, %.3f)",sometext10,ntpTHTrack->purity,
02713                   ntpTHTrack->completeall);
02714       }
02715     }
02716     else if(ntpEvent->ntrack>0) sprintf(sometext10,"     #Trks: %i",
02717                                         ntpEvent->ntrack);
02718     else sprintf(sometext10,"     #Trks: 0");
02719     
02720   }
02721   
02722   else if(isReco&&eventSummary->nevent!=0){
02723     sprintf(sometext9,"Reco");
02724     sprintf(sometext10,"     #Trks: %i",ntpEvent->ntrack);
02725     sprintf(sometext14,"     #Shws: %i",ntpEvent->nshower);
02726   }
02727   else {
02728     sprintf(sometext9,"Reco");
02729     sprintf(sometext10,"     No Reconstruced Event");
02730   }
02731 
02732   //Track values
02733   char sometext11[100] = "N/A";
02734   char sometext12[100] = "N/A";
02735   char sometext13[100] = "N/A";
02736   
02737   if(isMC){ //if MC
02738     TClonesArray* pointMcArray = NULL;
02739     if(isST) pointMcArray = (strecord->mc);
02740     else pointMcArray = (mcrecord->mc);
02741     TClonesArray& mcArray = *pointMcArray;
02742 
02743     sprintf(sometext2,"Truth - MC: %i(/%i)",LeMCevent+1,
02744             mcArray.GetEntries());
02745     
02746     sprintf(sometext3,"     Nu ID: %i;  NC/CC: %i;  Process: %i",ntpTruth->inu,
02747             ntpTruth->iaction,ntpTruth->iresonance);
02748     
02749     sprintf(sometext7,"     Shw Energy: %f",ntpTruth->p4shw[3]);
02750 
02751     sprintf(sometext8,"     Vtx: %.2f, %.2f, %.2f",ntpTruth->vtxx,
02752             ntpTruth->vtxy,ntpTruth->vtxz);    
02753     
02754     if(abs(ntpTruth->inu)==12){
02755       
02756       sprintf(sometext4,"     Nu E: %.3f;  Elec E*q: %.3f",ntpTruth->p4neu[3],
02757               ntpTruth->p4el1[3]);
02758       
02759       sprintf(sometext5,"     Elec p: %.3f;  Py: %.2f",
02760               sqrt(ntpTruth->p4el1[3]*ntpTruth->p4el1[3])
02761               -(0.000511*0.000511),ntpTruth->p4el1[1]);
02762       
02763       sprintf(sometext6,"     #theta: %.4f rad, %.2f deg",nu_el_angle,
02764               nu_el_angle*180./TMath::Pi());
02765       
02766     }
02767     
02768     else if(abs(ntpTruth->inu)==14){
02769       
02770       sprintf(sometext4,"     Nu E: %.3f;  Mu E*q: %.3f",ntpTruth->p4neu[3],
02771               ntpTruth->p4mu1[3]);
02772       
02773       sprintf(sometext5,"     Mu p: %.3f;  Py: %.2f",
02774               sqrt(ntpTruth->p4mu1[3]*ntpTruth->p4mu1[3])
02775               -(0.10555*0.10555),ntpTruth->p4mu1[1]);
02776       
02777       sprintf(sometext6,"     #theta: %.4f rad, %.2f deg",nu_mu_angle,
02778               nu_mu_angle*180./TMath::Pi());
02779       
02780     }
02781 
02782     else if(ntpTruth->p4neu[3]<0.00001){
02783       
02784       sprintf(sometext4,"     Nu E: %.3f;  Mu E*q: %.3f",ntpTruth->p4neu[3],
02785               ntpTruth->p4mu1[3]);
02786       
02787       sprintf(sometext5,"     Mu p: %.3f;  Py: %.2f",
02788               sqrt(ntpTruth->p4mu1[3]*ntpTruth->p4mu1[3])
02789               -(0.10555*0.10555),ntpTruth->p4mu1[1]);
02790       
02791       sprintf(sometext6,"     Zenith angle: %.4f rad, %.2f deg",zen_mu_angle,
02792               zen_mu_angle*180./TMath::Pi());
02793     }
02794 
02795   }
02796   
02797   if(isReco&&eventSummary->nevent!=0){ //reconstructed event present
02798     const Detector::Detector_t det 
02799       = ntpHeader->GetVldContext().GetDetector();
02800     Float_t cor_shw_energy =0; // corrected shower energy
02801     float best_trk_mom=0.0;// will be range or curvature
02802     int do_meth=0; // emu reco method we should use
02803     float reco_dircosneu=-1; // z cosine
02804     const bool is_mc
02805       =(ntpHeader->GetVldContext().GetSimFlag()==SimFlag::kMC);
02806     const double muM=0.10566; // muon mass
02807     if(ntpEvent->ntrack!=0){  //and at least one track
02808       
02809       float trk_mom_pq = 0;
02810       //for info, just show first track:
02811       int *tracks = ntpEvent->trk;
02812       int index = 0;
02813       float largestEn = 0;
02814       for(int it=0;it<ntpEvent->ntrack;it++){
02815         if(!LoadTrack(tracks[it])) continue;
02816         if(ntpTrack->momentum.qp==0) continue;
02817         if(fabs(1./ntpTrack->momentum.qp)>largestEn) {
02818           largestEn = fabs(1./ntpTrack->momentum.qp);
02819           index = tracks[it];
02820         }
02821       }
02822       LoadTrack(index);
02823       if(ntpTrack->momentum.qp!=0) trk_mom_pq = 1./ntpTrack->momentum.qp;
02824 
02825       // determine if event is contained, compute momentum      
02826       if(det==Detector::kNear){//if it's the near detector
02827         int pitt_evt_class = 
02828           MadMKAnalysis::PittTrkContained(ntpTrack->end.x,
02829                                           ntpTrack->end.y,
02830                                           ntpTrack->end.z,
02831                                           ntpTrack->end.u,
02832                                           ntpTrack->end.v);
02833         if(pitt_evt_class>0){ // if it was classified
02834           if( (pitt_evt_class == 1) || (pitt_evt_class == 3) ) 
02835             do_meth=2; // stoppers --> range
02836           else if( (pitt_evt_class == 2) || (pitt_evt_class == 4) ) 
02837             do_meth=1; // punch-through --> curvature
02838           if(do_meth==1 || do_meth==2){
02839             best_trk_mom = 
02840               RecoMKMuEnergy(do_meth,index,!is_mc);
02841           }
02842         }
02843       }
02844       else if(det==Detector::kFar){//if it's the far detector
02845         do_meth=MadMKAnalysis::FarTrkContained(ntpTrack->end.x,
02846                                                ntpTrack->end.y,
02847                                                ntpTrack->end.z);
02848         if(do_meth==1 || do_meth==2){
02849           best_trk_mom = 
02850             RecoMKMuEnergy(do_meth,index,!is_mc);
02851         }
02852       }                             
02853       best_trk_mom = sqrt(best_trk_mom*best_trk_mom - muM*muM);
02854       int range_meth=2;
02855       float mom_range = RecoMKMuEnergy(range_meth,index,!is_mc);
02856       mom_range = sqrt(mom_range*mom_range - muM*muM);
02857       if(det==Detector::kNear) 
02858         reco_dircosneu = RecoMuDCosNeuND(index);
02859       else reco_dircosneu = RecoMuDCosNeuFD(index);
02860 
02861       
02862       char range_used=' ';
02863       char curve_used=' ';
02864       if(do_meth==1) curve_used='*';
02865       else range_used='*';
02866       sprintf(sometext11,"     q/p: %.3f +/- %.3f,  p/q: %.3f %c",
02867               ntpTrack->momentum.qp,
02868               ntpTrack->momentum.eqp,trk_mom_pq,curve_used);
02869       
02870       sprintf(sometext12,"     TrkRangeEnergy: %.3f %c",mom_range,range_used);
02871 
02872       
02873       sprintf(sometext13,"     Vtx: %.2f, %.2f, %.2f",ntpTrack->vtx.x,
02874               ntpTrack->vtx.y,ntpTrack->vtx.z);
02875 
02876 
02877     }
02878     else {//no track
02879       sprintf(sometext11,"     q/p: %.3f +/- %.3f,  p/q: %.3f",0.,0.,0.);
02880       sprintf(sometext12,"     TrkRangeEnergy: %.3f",0.);
02881       sprintf(sometext13,"     Vtx: %.2f, %.2f, %.2f",0.,0.,0.);
02882     }
02883     if(ntpEvent->nshower!=0){  //at least one shower
02884       //for info, just show biggest shower:
02885       // and the sum of showers
02886       int *showers = ntpEvent->shw;      
02887       int index = 0;
02888       float largestEn = 0;
02889       float sumEn = 0;
02890       float thisEn = 0;
02891       for(int is=0;is<ntpEvent->nshower;is++){
02892         if(!LoadShower(showers[is])) continue;
02893         if(ntpShower->shwph.linCCgev>largestEn) {
02894           largestEn = ntpShower->shwph.linCCgev;
02895           index = showers[is];
02896         }
02897 
02898         thisEn=CorrectShowerEnergy(ntpShower->shwph.linCCgev,
02899                                    det,CandShowerHandle::kCC);
02900         sumEn+=thisEn;
02901         std::cout<<"shw (i,u,v,z,E,Ecor): ( "<<is<<" , "<<ntpShower->vtx.u
02902                  <<" , "<<ntpShower->vtx.v<<" , "<<ntpShower->vtx.z
02903                  <<" , "<<ntpShower->ph.gev<<" , "<<thisEn<<" ) "<<std::endl;
02904         
02905       }
02906       LoadShower(index);
02907       static int i_shw_message=1;
02908       if(i_shw_message<11){
02909         std::cout<<"Printing the corrected linCC energy ("<<i_shw_message<<"/10)";
02910         if(i_shw_message==10){
02911           std::cout<<" Last message...";
02912         }
02913         std::cout<<std::endl;
02914         i_shw_message++;
02915       }
02916 
02917       cor_shw_energy = CorrectShowerEnergy(ntpShower->shwph.linCCgev,
02918                               det,CandShowerHandle::kCC);
02919       sprintf(sometext12,"%s   RecoShwEnergy: %.3f [%.3f]",sometext12,
02920               cor_shw_energy, sumEn);
02921        
02922     }
02923     else {//no shower
02924       sprintf(sometext12,"%s   RecoShwEnergy: %.3f",sometext12,0.);
02925     }
02926 
02927     if(best_trk_mom>0){
02928       float reco_x=0.,reco_y=0.,reco_Q2=0.,reco_W2=0.,reco_QEQ2=0.;
02929       float reco_eshw=cor_shw_energy;
02930       float reco_emu=sqrt(best_trk_mom*best_trk_mom+muM*muM);
02931       
02932       float reco_enu=reco_emu+reco_eshw;
02933       const double M=(0.93827 + 0.93957)/2.0; // <nucleon mass>
02934       if(reco_emu>0) reco_Q2 = 
02935                        2*reco_enu*reco_emu*(1.0 - reco_dircosneu);
02936       reco_W2 = M*M - reco_Q2 + 2*M*reco_eshw;    
02937       if(reco_enu>0) reco_y = reco_eshw/reco_enu;
02938       if(reco_eshw>0 && reco_Q2>0) reco_x =  reco_Q2/(2*M*reco_eshw);
02939       
02940       float muP=(reco_emu*reco_emu -muM*muM);
02941       if(muP<0) muP=0;
02942       else muP=sqrt(muP);
02943       float reco_qe_enu = (M*reco_emu - muM*muM/2.0)
02944         /(M - reco_emu + muP*reco_dircosneu);
02945       reco_QEQ2 
02946         = abs(-2.0*reco_qe_enu*(reco_emu-muP*reco_dircosneu)+muM*muM);
02947     
02948       sprintf(sometext13,"%s,  x,y,Q2,W2  = %.2f, %.2f, %.2f, %.2f",
02949               sometext13, reco_x,reco_y,reco_Q2,reco_W2);
02950     }
02951   }
02952   else { //no event
02953     sprintf(sometext11,"     q/p: %.3f +/- %.3f,  p/q: %.3f",0.,0.,0.);
02954     sprintf(sometext12,
02955             "     TrkRangeEnergy: %.3f   RecoShwEnergy: %.3f",0.,0.);
02956     sprintf(sometext13,"     Vtx: %.2f, %.2f, %.2f",0.,0.,0.);
02957   }
02958 
02959   const double horzoff = 0.01, vertoff = 0.02;
02960 
02961   //summary
02962   TLatex *Info1 = new TLatex(horzoff,0.91+vertoff,sometext1);
02963   Info1->SetName("info1");
02964   Info1->SetTextSize(0.06);
02965   Info1->SetTextColor(2);
02966 
02967   //Reco
02968   TLatex *Info9 = new TLatex(horzoff,0.84+vertoff,sometext9);
02969   Info9->SetName("info9");
02970   Info9->SetTextSize(0.06);
02971   Info9->SetTextColor(4);
02972 
02973   TLatex *Info10 = new TLatex(horzoff,0.77+vertoff,sometext10);
02974   Info10->SetName("info10");
02975   if(Info10->Sizeof()<70) Info10->SetTextSize(0.05);
02976   else Info10->SetTextSize(0.04);
02977   Info10->SetTextColor(9);
02978 
02979   TLatex *Info14 = new TLatex(horzoff,0.70+vertoff,sometext14);
02980   Info14->SetName("info14");
02981   if(Info14->Sizeof()<70) Info14->SetTextSize(0.05);
02982   else Info14->SetTextSize(0.04);
02983   Info14->SetTextColor(9);
02984 
02985   //track
02986 
02987   TLatex *Info11 = new TLatex(horzoff,0.63+vertoff,sometext11);
02988   Info11->SetName("info11");
02989   Info11->SetTextSize(0.05);
02990   Info11->SetTextColor(9);
02991 
02992   TLatex *Info12 = new TLatex(horzoff,0.56+vertoff,sometext12);
02993   Info12->SetName("info12");
02994   Info12->SetTextSize(0.05);
02995   Info12->SetTextColor(9);
02996 
02997   TLatex *Info13 = new TLatex(horzoff,0.49+vertoff,sometext13);
02998   Info13->SetName("info13");
02999   Info13->SetTextSize(0.05);
03000   Info13->SetTextColor(9);
03001   
03002   //truth
03003   TLatex *Info2 = new TLatex(horzoff,0.42+vertoff,sometext2);
03004   Info2->SetName("info2");
03005   Info2->SetTextSize(0.06);
03006   Info2->SetTextColor(3);
03007   
03008   TLatex *Info3 = new TLatex(horzoff,0.35+vertoff,sometext3);
03009   Info3->SetName("info3");
03010   Info3->SetTextSize(0.05);
03011   Info3->SetTextColor(8);
03012 
03013   TLatex *Info4 = new TLatex(horzoff,0.28+vertoff,sometext4);
03014   Info4->SetName("info4");
03015   Info4->SetTextSize(0.05);
03016   Info4->SetTextColor(8);
03017 
03018   TLatex *Info5 = new TLatex(horzoff,0.21+vertoff,sometext5);
03019   Info5->SetName("info5");
03020   Info5->SetTextSize(0.05);
03021   Info5->SetTextColor(8);
03022 
03023   TLatex *Info6 = new TLatex(horzoff,0.14+vertoff,sometext6);
03024   Info6->SetName("info6");
03025   Info6->SetTextSize(0.05);
03026   Info6->SetTextColor(8);
03027 
03028   TLatex *Info7 = new TLatex(horzoff,0.07+vertoff,sometext7);
03029   Info7->SetName("info7");
03030   Info7->SetTextSize(0.05);
03031   Info7->SetTextColor(8);
03032 
03033   TLatex *Info8 = new TLatex(horzoff,0.00+vertoff,sometext8);
03034   Info8->SetName("info8");
03035   Info8->SetTextSize(0.05);
03036   Info8->SetTextColor(8);
03037 
03038   MainCanvas->cd(1);
03039   gPad->Range(0,0,1,1);
03040   Info1->Draw();
03041   Info2->Draw();
03042   Info3->Draw();
03043   Info4->Draw();
03044   Info5->Draw();
03045   Info6->Draw();
03046   Info7->Draw();
03047   Info8->Draw();
03048   Info9->Draw();
03049   Info10->Draw();
03050   Info11->Draw();
03051   Info12->Draw();
03052   Info13->Draw();
03053   Info14->Draw();
03054 }

void MadEvDisplay::EnableHandScan ( char *  fname  ) 

Definition at line 4001 of file MadEvDisplay.cxx.

References handScan, and logFileName.

04002 {
04003   handScan = true;
04004   if(std::strcmp(fname,"")) {
04005     sprintf(logFileName,"%s",fname);
04006   }
04007 }

void MadEvDisplay::EventDump (  ) 
Int_t MadEvDisplay::JumpTo (  ) 

Definition at line 497 of file MadEvDisplay.cxx.

References Display(), MadBase::fChain, MadChain::GetEntryNumber(), MadBase::lastEntry, LeAutoMat, MadBase::Nentries, run(), and MadBase::whichSource.

00498 {
00499   if(whichSource==0){
00500     Int_t run = 0;
00501     Int_t snarl = 0;
00502     std::cout << "Enter run number of the snarl:" << std::endl;
00503     std::cin >> run;
00504     std::cout << "Enter snarl number:" << std::endl;
00505     std::cin >> snarl;
00506     Int_t entry = fChain->GetEntryNumber(run,snarl);
00507     cout << entry << endl;
00508     if(entry>=0 && entry<Nentries) {
00509       std::cout << "Displaying Run: " << run << " Snarl: " 
00510                 << snarl << std::endl;
00511       Display(entry,0,0,0,LeAutoMat);
00512       return entry;
00513     }
00514     std::cout << "Couldn't find Run: " << run << " Snarl: " 
00515               << snarl << std::endl;
00516   }
00517   return lastEntry;
00518 }

void MadEvDisplay::Log (  ) 

Definition at line 3986 of file MadEvDisplay.cxx.

References RecDataHeader::GetRun(), RecPhysicsHeader::GetSnarl(), RecDataHeader::GetSubRun(), NtpSRSlice::index, NtpSREvent::index, logFileName, MadBase::ntpEvent, MadBase::ntpHeader, MadBase::ntpSlice, ScanID, and ScanTop.

03987 {
03988   ofstream outFile;
03989   outFile.open(logFileName, ofstream::out | ofstream::app);
03990   outFile << ntpHeader->GetRun() << " " 
03991           << ntpHeader->GetSubRun() << " " 
03992           << ntpHeader->GetSnarl() << " "
03993           << ntpSlice->index << " "
03994           << ntpEvent->index << " "
03995           << ScanID << " "
03996           << ScanTop << " "
03997           << endl;
03998   outFile.close();
03999 }

Int_t MadEvDisplay::NextInterestingEvent ( bool  backward = false  ) 

Definition at line 4091 of file MadEvDisplay.cxx.

References Display(), MadBase::fChain, fNeatoEventIdx, fNeatoEvents, MadBase::GetEntry(), MadChain::GetEntryNumber(), LeAutoMat, LeEntry, and MadBase::LoadEvent().

Referenced by NextPass(), and PrevPass().

04091                                                      {
04092   if(fNeatoEvents.size()==0) return LeEntry;
04093   //  int ncontinue;
04094   Int_t event=-1;
04095   Int_t entry=-1;
04096   int startingindex = fNeatoEventIdx;
04097   if(startingindex == -1) startingindex = 0;
04098   bool firsttry = true;
04099   while(true){
04100     if(!backward){
04101       if(fNeatoEventIdx+1 >= static_cast<Int_t>(fNeatoEvents.size())){
04102         fNeatoEventIdx=0; 
04103       }
04104       else fNeatoEventIdx++;
04105 
04106       if(fNeatoEventIdx == startingindex && !firsttry){
04107         cerr << "Looped all the way around without finding any neato events!\n";
04108         return -1;
04109       }
04110 
04111       firsttry = false;
04112     }
04113     else{
04114       if(fNeatoEventIdx-1 < 0){
04115         fNeatoEventIdx=fNeatoEvents.size()-1;
04116       }
04117       else fNeatoEventIdx--;
04118     }
04119     //  return fNeatoEventIdx;
04120     // search for event in MadChain's list
04121     std::vector<Int_t>& v = fNeatoEvents[fNeatoEventIdx]; 
04122     entry = fChain->GetEntryNumber(v[0],v[1]);
04123     if(entry != -1) {
04124       event = v[2];
04125       break;
04126     }
04127   }
04128   this->GetEntry(entry);
04129   this->LoadEvent(event);
04130   Display(entry,0,event,0,LeAutoMat);
04131 
04132   return entry;
04133 
04134 }

Int_t MadEvDisplay::NextPass (  ) 

Definition at line 358 of file MadEvDisplay.cxx.

References Display(), fHaveNeatoEvents, MadBase::GetEntry(), NtpMCTruth::iaction, NtpMCTruth::inu, MadBase::isMC, MadBase::isTH, LeAction, LeAutoMat, LeEntry, LeEvent, LeMCevent, LeNu, LeSlice, MadBase::LoadEvent(), MadBase::LoadSliceForRecoTH(), MadBase::LoadTruthForRecoTH(), MadBase::Nentries, NextInterestingEvent(), MadBase::ntpTruth, PassCuts(), and UseNuInfo.

00358                              {
00359   // override to read from list of events
00360   if(fHaveNeatoEvents) { return NextInterestingEvent(); }
00361 
00362   int entry = LeEntry;
00363   int event = LeEvent+1;
00364 
00365   if(isMC&&isTH){
00366     int mcevent = 0;
00367     while(this->GetEntry(entry)){
00368       while(LoadEvent(event)) { 
00369         if(LoadTruthForRecoTH(event,mcevent)){
00370           if(PassCuts()&&(!UseNuInfo||(abs(ntpTruth->inu)==LeNu
00371                                        &&ntpTruth->iaction==LeAction))){
00372             int slice = 0;
00373             LoadSliceForRecoTH(event,slice);
00374             LeSlice = slice;        
00375             LeEvent = event;
00376             LeMCevent = mcevent;
00377             Display(entry,slice,event,mcevent,LeAutoMat);
00378             return entry;
00379           }
00380         }
00381         event+=1;
00382       }
00383       event = 0;
00384       entry+=1;
00385       if(entry>=Nentries) break;
00386     }
00387     entry = 0;
00388     Display(0,0,0,0,LeAutoMat);
00389     return entry;
00390   }
00391 
00392   //if no MC or TH:
00393   while(this->GetEntry(entry)){
00394     while(LoadEvent(event)) {
00395       if(PassCuts()){
00396         LeSlice = 0;
00397         LeEvent = event;
00398         LeMCevent = 0;
00399         Display(entry,0,event,0,LeAutoMat);
00400         return entry;
00401       }     
00402       event+=1;
00403     }
00404     event = 0;
00405     entry+=1;
00406     if(entry>=Nentries) break;
00407   }
00408   entry = 0;
00409   Display(0,0,0,0,LeAutoMat);
00410   return entry;
00411   
00412 }

Bool_t MadEvDisplay::PassCuts (  )  [virtual]

Definition at line 188 of file MadEvDisplay.cxx.

References NtpSRCluster::avgdev, NtpSRShower::clu, NtpTHShower::completeslc, NtpTHEvent::completeslc, MadBase::eventSummary, VldContext::GetDetector(), RecHeader::GetVldContext(), NtpSRStripPulseHeight::gev, NtpMCTruth::iaction, NtpSRCluster::id, NtpSRTrack::index, NtpSREvent::index, Detector::kNear, MadBase::LoadCluster(), MadBase::LoadEvent(), MadBase::LoadLargestShowerFromEvent(), MadBase::LoadLargestTrackFromEvent(), MadBase::LoadShowerAtTrackVertex(), MadBase::LoadTHEvent(), MadBase::LoadTHShower(), NtpSRShower::ncluster, NtpSREventSummary::nevent, NtpSREventSummary::nshower, NtpSREvent::nshower, MadBase::ntpCluster, MadBase::ntpEvent, MadBase::ntpHeader, MadBase::ntpShower, MadBase::ntpTHEvent, MadBase::ntpTHShower, MadBase::ntpTrack, MadBase::ntpTruth, NtpSREvent::ntrack, NtpSREventSummary::ntrack, NtpSRPulseHeight::pe, NtpSRCluster::ph, NtpSRCluster::planeview, NtpSRCluster::probem, NtpSREvent::slc, NtpSREvent::vtx, NtpSRTrack::vtx, NtpSRVertex::x, NtpSRVertex::y, and NtpSRVertex::z.

Referenced by NextPass(), and PrevPass().

00188                              {
00189   if(!ntpEvent) return false;
00190   
00191   //ND fid cuts
00192   if(false){
00193     if(ntpHeader->GetVldContext().GetDetector()==Detector::kNear){
00194       if((ntpEvent->vtx.z<1 || ntpEvent->vtx.z>5 ||
00195           sqrt(((ntpEvent->vtx.x-1.4885)*(ntpEvent->vtx.x-1.4885)) +
00196                ((ntpEvent->vtx.y-0.1397)*(ntpEvent->vtx.y-0.1397)))>1)) {
00197         return false;
00198       }
00199       Int_t track = -1;
00200       if(LoadLargestTrackFromEvent(ntpEvent->index,track)){
00201         if((ntpTrack->vtx.z<1 || ntpTrack->vtx.z>5 ||
00202             sqrt(((ntpTrack->vtx.x-1.4885)*(ntpTrack->vtx.x-1.4885)) +
00203                  ((ntpTrack->vtx.y-0.1397)*(ntpTrack->vtx.y-0.1397)))>1)) {
00204           return false;
00205         }
00206       }
00207     }
00208   }
00209 
00210   if(false){
00211     if(LoadTHEvent(ntpEvent->index)) {
00212       if(ntpTHEvent->completeslc<0.1) {
00213         cout << "low event completeness " << ntpTHEvent->completeslc << endl;
00214         return true;    
00215       }
00216       if(ntpEvent->nshower>0) {
00217         Int_t shw_ind = -1;
00218         if( ( ntpEvent->ntrack>0 && ntpTrack &&
00219               LoadShowerAtTrackVertex(ntpEvent->index,
00220                                       ntpTrack->index,shw_ind) ) ||
00221             (ntpEvent->ntrack==0 && 
00222              LoadLargestShowerFromEvent(ntpEvent->index,shw_ind) ) ){
00223           if(LoadTHShower(shw_ind)) {
00224             if(ntpTHShower->completeslc < 0.2) {
00225               cout << "low vertex shower completeness " 
00226                    << ntpTHShower->completeslc << endl;
00227               return true;    
00228             }
00229           }
00230         }
00231       }
00232     }
00233   }
00234 
00235   if(false){
00236     if(eventSummary->nshower==1 && eventSummary->ntrack==1 &&
00237        eventSummary->nevent==1 && ntpEvent->nshower==1 && 
00238        ntpEvent->ntrack==0) return true;
00239   }
00240 
00241   //>=2 showers
00242   if(false){
00243     if(ntpEvent->nshower>1 && 
00244        ntpEvent->ntrack==0) return true;
00245   }
00246 
00247   //Two or more events/slice
00248   if(false){
00249     Int_t slice = ntpEvent->slc;
00250     Int_t ev_index = ntpEvent->index;
00251     if(LoadEvent(ev_index+1)) {      
00252       if(ntpEvent->slc==slice) {
00253         //get total charge of shower in PEs for U and V:
00254         Double_t shwChargeU = 0;
00255         Double_t shwChargeV = 0;
00256         Double_t shwChargeAsym = 0;
00257         Int_t shower = -1;
00258         if(LoadLargestShowerFromEvent(ntpEvent->index,shower)){
00259           for(int i = 0; i<ntpShower->ncluster;i++){
00260             LoadCluster(ntpShower->clu[i]);
00261             if(ntpCluster->planeview==2) shwChargeU += ntpCluster->ph.pe;
00262             else shwChargeV += ntpCluster->ph.pe;
00263           }
00264           shwChargeAsym = ( TMath::Abs(shwChargeU - shwChargeV) / 
00265                             (shwChargeU+shwChargeV) );
00266           cout << "2nd: " << shwChargeU << " " << shwChargeV << " " 
00267                << shwChargeAsym << endl;
00268         }
00269         LoadEvent(ev_index);    
00270         // first event:
00271         shwChargeU = 0;
00272         shwChargeV = 0;
00273         if(LoadLargestShowerFromEvent(ntpEvent->index,shower)){
00274           for(int i = 0; i<ntpShower->ncluster;i++){
00275             LoadCluster(ntpShower->clu[i]);
00276             if(ntpCluster->planeview==2) shwChargeU += ntpCluster->ph.pe;
00277             else shwChargeV += ntpCluster->ph.pe;
00278           }
00279           shwChargeAsym = ( TMath::Abs(shwChargeU - shwChargeV) / 
00280                             (shwChargeU+shwChargeV) );
00281           
00282           cout << "1st: " << shwChargeU << " " << shwChargeV << " " 
00283                << shwChargeAsym << endl;
00284         }
00285         cout << ">1 event in slice" << endl;
00286         return true;
00287       }
00288     }
00289     LoadEvent(ev_index);
00290   }
00291 
00292   //SubShower Cuts:
00293   if(false){
00294     Int_t shower = -1;
00295     if(eventSummary->nevent==1&&ntpEvent->nshower==1&&
00296        LoadLargestShowerFromEvent(ntpEvent->index,shower)) {
00297       int goodU = 0;
00298       int goodV = 0;
00299       double maxU = 0;
00300       double maxV = 0;
00301       double avgdevU = 1.;
00302       double avgdevV = 1.;
00303       Int_t nemclu = 0;
00304       Int_t nhadclu = 0;
00305       Int_t nphysclu = 0;
00306       
00307       Int_t *clusters = ntpShower->clu;
00308       for(int k=0; k<ntpShower->ncluster; k++){
00309         Int_t index = clusters[k];
00310         if(!LoadCluster(index)) continue;
00311         if(ntpCluster->ph.gev>0.4){
00312           if(ntpCluster->id==0) nemclu++;
00313           else if(ntpCluster->id==1) nhadclu++;
00314           else if(ntpCluster->id!=2) nphysclu++;
00315         }
00316         if(ntpCluster->planeview==2){
00317           if(ntpCluster->ph.gev>maxU){
00318             if(ntpCluster->id==0){
00319               goodU = 1;
00320               if(ntpCluster->probem>0.2) goodU=3;
00321               avgdevU = ntpCluster->avgdev;
00322               maxU = ntpCluster->ph.gev;
00323             }
00324             else {
00325               goodU = 0;
00326               avgdevU = ntpCluster->avgdev;
00327             maxU = ntpCluster->ph.gev;
00328             }
00329           }
00330         }
00331         else if(ntpCluster->planeview==3){
00332           if(ntpCluster->ph.gev>maxV){
00333             if(ntpCluster->id==0){
00334               goodV = 1;
00335               if(ntpCluster->probem>0.2) goodV=3;
00336               avgdevV = ntpCluster->avgdev;
00337               maxV = ntpCluster->ph.gev;
00338             }
00339             else {
00340               goodV = 0;
00341               avgdevV = ntpCluster->avgdev;
00342               maxV = ntpCluster->ph.gev;
00343             }
00344           }
00345         }
00346       }
00347       if((goodU==1 && goodV==1) || goodU==3 || goodV==3){
00348         cout << ntpTruth->iaction << " " 
00349              << nemclu << " " << nhadclu << " " 
00350              << nemclu+nhadclu+nphysclu << endl;
00351         return true;
00352       }
00353     }
00354   }
00355   return false;
00356 }

Int_t MadEvDisplay::PrevPass (  ) 

Definition at line 414 of file MadEvDisplay.cxx.

References Display(), NtpStRecord::evt, NtpSRRecord::evt, fHaveNeatoEvents, MadBase::GetEntry(), NtpMCTruth::iaction, NtpMCTruth::inu, MadBase::isMC, MadBase::isST, MadBase::isTH, LeAction, LeAutoMat, LeEntry, LeEvent, LeMCevent, LeNu, LeSlice, MadBase::LoadEvent(), MadBase::LoadSliceForRecoTH(), MadBase::LoadTruthForRecoTH(), NextInterestingEvent(), MadBase::ntpTruth, PassCuts(), MadBase::record, MadBase::strecord, and UseNuInfo.

00414                              {
00415   // override to read from list of events
00416   if(fHaveNeatoEvents) { return NextInterestingEvent(true); }
00417 
00418   int entry = LeEntry;
00419   int event = LeEvent-1;
00420   
00421   if(isMC&&isTH){
00422     int mcevent = 0;
00423     while(this->GetEntry(entry)){
00424       if(event==-100){ 
00425         TClonesArray* pointEventArray = NULL;
00426         if(isST) pointEventArray = (strecord->evt);
00427         else pointEventArray = (record->evt);
00428         TClonesArray& eventArray = *pointEventArray;
00429         event = eventArray.GetEntries() - 1;
00430       }
00431       while(LoadEvent(event)) {
00432         if(LoadTruthForRecoTH(event,mcevent)){
00433           if(PassCuts()&&(!UseNuInfo||(abs(ntpTruth->inu)==LeNu
00434                                        &&ntpTruth->iaction==LeAction))){
00435             int slice = 0;
00436             LoadSliceForRecoTH(event,slice);
00437             LeSlice = slice;        
00438             LeEvent = event;
00439             LeMCevent = mcevent;
00440             Display(entry,slice,event,mcevent,LeAutoMat);
00441             return entry;
00442           }
00443         }
00444         event-=1;
00445       }
00446       event = -100; //to catch when we've got to last event in snarl
00447       entry -= 1;      
00448       if(entry<0) break;
00449     }
00450     entry = 0;
00451     Display(0,0,0,0,LeAutoMat);
00452     return entry;
00453   }
00454 
00455   //if no MC or TH:
00456   while(this->GetEntry(entry)){
00457     if(event==-100){
00458       TClonesArray* pointEventArray = NULL;
00459       if(isST) pointEventArray = (strecord->evt);
00460       else pointEventArray = (record->evt);
00461       TClonesArray& eventArray = *pointEventArray;
00462       event = eventArray.GetEntries() - 1;
00463     }
00464     while(LoadEvent(event)) {
00465       if(PassCuts()){
00466         LeSlice = 0;
00467         LeEvent = event;
00468         LeMCevent = 0;
00469         Display(entry,0,event,0,LeAutoMat);
00470         return entry;
00471       }
00472       event-=1;
00473     }
00474     event = -100;
00475     entry-=1;
00476     if(entry<0) break;
00477   }
00478   entry = 0;
00479   Display(0,0,0,0,LeAutoMat);
00480   return entry;
00481 
00482 }

void MadEvDisplay::PrintDisplay (  ) 

Definition at line 144 of file MadEvDisplay.cxx.

References Nav::GetName(), MadBase::isMC, and printName.

00145 {
00146   //Print canvases
00147   TCanvas *can[6];
00148   can[0] = (TCanvas*) gROOT->FindObject("RecoCanvas");
00149   can[1] = (TCanvas*) gROOT->FindObject("MainCanvas");
00150   can[2] = (TCanvas*) gROOT->FindObject("TruthCanvas");
00151   can[3] = (TCanvas*) gROOT->FindObject("LegoCanvas");
00152   can[4] = (TCanvas*) gROOT->FindObject("ClusterCanvas");
00153   can[5] = (TCanvas*) gROOT->FindObject("StdHepDiagramCanvas");
00154   
00155   for(int i=0;i<6;i++){
00156     if(can[i]) {
00157       TString temp(can[i]->GetName());
00158       if(isMC) {
00159         temp.Append("_MC");
00160       }
00161       temp.Append(printName);
00162       can[i]->Print(temp.Data());
00163 
00164       /*
00165       // try to use TImage (TASImage actually...) to print canvases
00166       // in the hope of solving the "canvas with bit of other window" output
00167       // this didn't work... got 
00168       // <RootX11ErrorHandler>: BadMatch and canvas was covered
00169       // or
00170       // ASImage2gif():944:<MainCanvas_MC_Run10001_Snl35_Slc1_Evt1.gif>
00171       // GIF-LIB undefined error 0.
00172       // Error in <TASImage::WriteImage>: error writing file MainCanvas_MC_Run10001_Snl35_Slc1_Evt1.gif
00173 
00174       TImage* img = TImage::Create();
00175       img->FromPad(can[i]);
00176       img->WriteImage(temp.Data());
00177       delete img;
00178       */
00179     }
00180   }  
00181 }

void MadEvDisplay::PrintHSHelp (  ) 

Definition at line 4009 of file MadEvDisplay.cxx.

04010 {
04011   cout << endl;
04012   cout << endl;
04013   cout << "================= Hand Scan Info =================" << endl;
04014   cout << "Left Hand Column shows possible event ID tags:" << endl;
04015   cout << "mu    = numu CC                  -   code = 1" << endl;
04016   cout << "e     = nue CC                   -   code = 2" << endl;
04017   cout << "NC    = NC                       -   code = 3" << endl;
04018   cout << "mu/NC = numu CC / NC Ambiguity   -   code = 4" << endl;
04019   cout << "e/NC  = nue CC / NC Ambiguity    -   code = 5" << endl;
04020   cout << "???   = Complete Ambiguity       -   code = 6" << endl;
04021   cout << "N/A (all buttons red)            -   code = 0" << endl;
04022   cout << "--------------------------------------------------" << endl;
04023   cout << "Right Hand Column shows possible event topology tags:" << endl;
04024   cout << "QE                               -   code = 1" << endl;
04025   cout << "RES                              -   code = 2" << endl;
04026   cout << "DIS                              -   code = 3" << endl;
04027   cout << "???                              -   code = 4" << endl;
04028   cout << "N/A (all buttons red)            -   code = 0" << endl;
04029   cout << "--------------------------------------------------" << endl;
04030   cout << "Click 'Log Details' to write choices to text file" << endl;
04031   cout << "=================== Good Luck! ===================" << endl;
04032   cout << endl;
04033 }

bool MadEvDisplay::ReadEventsFile ( const char *  filename  ) 

Definition at line 4043 of file MadEvDisplay.cxx.

References fHaveNeatoEvents, fNeatoEvents, gSystem(), and run().

04043                                                      {
04044   // read text file listing interesting events
04045   // file format: run snarl event
04046   // blank lines and lines beginning with # are ignored
04047 
04048   //check that file exists
04049   FileStat_t buf;  
04050   if(gSystem->GetPathInfo(filename,buf) == 1) {
04051     std::cout<<"MadEvDisplay::ReadEventsFile: couldn't open "<<filename<<std::endl;
04052     return false;
04053   }
04054   else{
04055     std::cout<<"MadEvDisplay::ReadEventsFile: reading from "<<filename<<std::endl;
04056   }
04057   std::ifstream in(filename);
04058   int nread=0;
04059   std::string s;
04060   while(std::getline(in,s,'\n')){
04061 
04062     if(s=="") continue;// a blank line
04063     else if(s[0]=='#') continue; // a comment
04064     else{ 
04065       std::istringstream iss(s,std::istringstream::in);
04066       Int_t run,snarl,event;
04067       iss>>run>>snarl>>event;
04068 
04069       /*
04070       std::cout<<run<<" "<<snarl<<" "<<event;
04071       if(iss.good()) std::cout<<" good ";
04072       else std::cout<<" !good ";
04073       if(iss.eof()) std::cout<<" eof ";
04074       else std::cout<<" !eof ";
04075       std::cout<<std::endl;
04076       */
04077 
04078       // check that the read was ok
04079       if(iss.good() || iss.eof()){ 
04080         std::vector<Int_t> v(3); v[0]=run; v[1]=snarl; v[2]=event;
04081         fNeatoEvents.push_back(v);
04082         nread++;
04083       }
04084     }
04085   }
04086   std::cout<<"MadEvDisplay::ReadEventsFile read "<<nread<<" events."<<std::endl;
04087   if(nread>0) fHaveNeatoEvents=true;
04088   return true;
04089 }

Float_t MadEvDisplay::RecoMKMuEnergy ( Int_t &  opt,
Int_t  itrk,
bool  isdata = true 
)

Definition at line 4136 of file MadEvDisplay.cxx.

References EnergyCorrections::CorrectMomentumFromRange(), NtpSRFiducial::dr, NtpSRFiducial::dz, NtpSRTrack::fidall, MadBase::LoadTrack(), NtpSRTrack::momentum, MadBase::ntpTrack, NtpSRMomentum::qp, and NtpSRMomentum::range.

Referenced by DrawTextBox().

04136                                                                       {
04137   
04138   if(LoadTrack(itrk)){
04139      float mr=ntpTrack->momentum.range;
04140      mr=CorrectMomentumFromRange(mr,isdata);
04141     if(opt==0){  
04142       //return the most appropriate measure of momentum
04143       // assign opt based on our choice
04144       if(ntpTrack->fidall.dr>0.5&&ntpTrack->fidall.dz>0.5) {
04145         opt=2;
04146         return sqrt(mr*mr+ 0.10555*0.10555);
04147       }
04148       else {
04149         opt=1;
04150         // in R1.9 the tracker will apparently return (q/p)=0.0
04151         // maybe it's when a track looks perfectly rigid?
04152         // if so, we have to do something
04153         // I don't want to use the range, that could be very wrong
04154         // but wrong in a more subtle way ...
04155         // so, we'll return an obviously ridiculous value of 10 TeV
04156         if(ntpTrack->momentum.qp == 0.0) return 10000.0; 
04157         else return sqrt(1./(ntpTrack->momentum.qp*ntpTrack->momentum.qp)
04158                          + 0.10555*0.10555);
04159       }
04160     }
04161     else if(opt==1) { //return curvature measurement
04162         if(ntpTrack->momentum.qp == 0.0) return 10000.0; 
04163         else return sqrt(1./(ntpTrack->momentum.qp*ntpTrack->momentum.qp)
04164                          + 0.10555*0.10555);
04165     }
04166     else if(opt==2) //return range measurement
04167       return sqrt(mr*mr + 0.10555*0.10555);
04168     else return 0;
04169   }
04170   return 0.;
04171 }

Float_t MadEvDisplay::RecoMuDCosNeuFD ( Int_t  itr = 0,
Float_t *  vtx = 0 
)

Definition at line 4174 of file MadEvDisplay.cxx.

References NtpSRVertex::dcosy, NtpSRVertex::dcosz, MadBase::LoadTrack(), MadBase::ntpTrack, and NtpSRTrack::vtx.

Referenced by DrawTextBox().

04174                                                                   {
04175   if(!LoadTrack(itr)) return 0.;
04176 
04177   Float_t bl_z = TMath::Cos(TMath::Pi()*3./180.); //3degree beam
04178   Float_t bl_y = sqrt(1. - bl_z*bl_z);
04179   Float_t costhbl = ntpTrack->vtx.dcosz*bl_z + ntpTrack->vtx.dcosy*bl_y;
04180   
04181   return  costhbl;
04182 }

Float_t MadEvDisplay::RecoMuDCosNeuND ( Int_t  itr = 0,
Float_t *  vtx = 0 
)

Definition at line 4184 of file MadEvDisplay.cxx.

References NtpSRVertex::dcosy, NtpSRVertex::dcosz, MadBase::LoadTrack(), MadBase::ntpTrack, and NtpSRTrack::vtx.

Referenced by DrawTextBox().

04184                                                                   {
04185   if(!LoadTrack(itr)) return 0.;
04186   /*
04187    // simple correction based on the vertical position
04188   float vtxy=0;
04189   if(vtx) vtxy=vtx[1]; // in meters
04190   // cosine of the typical neutrino angle in the yz plane
04191   // calculated as py / sqrt( py^2 + pz^2)
04192   float nu_cos = -5.799E-2;
04193   if(vtxy>-2.0 && vtxy<2.0){ //prevents further nuttyness if vtxy is silly
04194     nu_cos += vtxy*1.23304E-3 
04195       + vtxy*vtxy*1.08212E-5 
04196       + vtxy*vtxy*vtxy*(-4.634E-5);
04197   }
04198   */
04199   float nu_cos = -5.799E-2;
04200   float nu_sin = sqrt(1 -nu_cos*nu_cos);
04201   float cosz = ntpTrack->vtx.dcosz*nu_sin + ntpTrack->vtx.dcosy*nu_cos;
04202 
04203   return cosz;
04204 
04205 }

void MadEvDisplay::SetDefaultShowerMarkerColor ( Int_t  col  )  [inline]

Definition at line 74 of file MadEvDisplay.h.

References fDefaultShowerMarkerColor.

void MadEvDisplay::SetDefaultShowerMarkerStyle ( Int_t  style  )  [inline]

Definition at line 75 of file MadEvDisplay.h.

References fDefaultShowerMarkerStyle.

void MadEvDisplay::SetDVals ( Float_t  spe_val,
Float_t  mid_val 
)

Definition at line 138 of file MadEvDisplay.cxx.

References Dmid_val, and Dspe_val.

00139 {
00140   Dspe_val = spe_val;
00141   Dmid_val = mid_val; 
00142 }

void MadEvDisplay::SetMessages ( Bool_t  yesno = true  )  [inline]

Definition at line 40 of file MadEvDisplay.h.

References ptt_msg.

00040 {ptt_msg=yesno;} //print extra info?

void MadEvDisplay::SetPrintOpt ( char *  opt  ) 

Definition at line 183 of file MadEvDisplay.cxx.

References printOpt.

00183                                        {
00184   sprintf(printOpt,"%s",opt);
00185   //  this->Display(LeEntry,LeSlice,LeEvent,LeMCevent,LeAutoMat);
00186 }

Int_t MadEvDisplay::SkipTo (  ) 

Definition at line 484 of file MadEvDisplay.cxx.

References Display(), LeAutoMat, and MadBase::Nentries.

00485 {
00486 
00487   Int_t sp = 0;
00488   std::cout << "Enter tree entry number to jump to" << std::endl;
00489   std::cin >> sp;
00490   if(sp<0||sp>Nentries) sp=0;
00491   std::cout << sp << std::endl;
00492   Display(sp,0,0,0,LeAutoMat);
00493   return sp;
00494 
00495 }

void MadEvDisplay::StartLogger (  ) 

Definition at line 3866 of file MadEvDisplay.cxx.

Referenced by DrawButtons().

03867 {
03868 
03869   TButton *but1 = new TButton("mu",
03870                               "EVD->ScanID=1; EVD->ChangeLogButColor();",
03871                               0.,0.8875,0.1275,0.95);
03872   but1->SetTextSize(0.6);
03873   but1->SetFillColor(2);
03874   but1->SetName("logBut1");
03875   
03876   TButton *but2 = new TButton("e",
03877                               "EVD->ScanID=2; EVD->ChangeLogButColor();",
03878                               0.,0.825,0.1275,0.8875);
03879   but2->SetTextSize(0.6);
03880   but2->SetFillColor(2);
03881   but2->SetName("logBut2");
03882   
03883   TButton *but3 = new TButton("NC",
03884                               "EVD->ScanID=3; EVD->ChangeLogButColor();",
03885                               0.,0.7625,0.1275,0.825);
03886   but3->SetTextSize(0.6);
03887   but3->SetFillColor(2);
03888   but3->SetName("logBut3");
03889   
03890   TButton *but4 = new TButton("mu/NC?",
03891                               "EVD->ScanID=4; EVD->ChangeLogButColor();",
03892                               0.,0.70,0.1275,0.7625);
03893   but4->SetTextSize(0.6);
03894   but4->SetFillColor(2);
03895   but4->SetName("logBut4");
03896   
03897   TButton *but5 = new TButton("e/NC?",
03898                               "EVD->ScanID=5; EVD->ChangeLogButColor();",
03899                               0.,0.6375,0.1275,0.7);
03900   but5->SetTextSize(0.6);
03901   but5->SetFillColor(2);
03902   but5->SetName("logBut5");
03903   
03904   TButton *but6 = new TButton("???",
03905                               "EVD->ScanID=6; EVD->ChangeLogButColor();",
03906                               0.,0.575,0.1275,0.6375);
03907   but6->SetTextSize(0.6);
03908   but6->SetFillColor(2);
03909   but6->SetName("logBut6");
03910 
03911   TButton *but8 = new TButton("QE",
03912                               "EVD->ScanTop=1; EVD->ChangeLogButColor();",
03913                               0.1275,0.85625,0.195,0.95);
03914   but8->SetTextSize(0.4);
03915   but8->SetFillColor(2);
03916   but8->SetName("logBut8");
03917   
03918   TButton *but9 = new TButton("RES",
03919                               "EVD->ScanTop=2; EVD->ChangeLogButColor();",
03920                               0.1275,0.7625,0.195,0.85625);
03921   but9->SetTextSize(0.4);
03922   but9->SetFillColor(2);
03923   but9->SetName("logBut9");
03924   
03925   TButton *but10 = new TButton("DIS",
03926                                "EVD->ScanTop=3; EVD->ChangeLogButColor();",
03927                                0.1275,0.66875,0.195,0.7625);
03928   but10->SetTextSize(0.4);
03929   but10->SetFillColor(2);
03930   but10->SetName("logBut10");
03931 
03932   TButton *but11 = new TButton("???",
03933                               "EVD->ScanTop=4; EVD->ChangeLogButColor();",
03934                               0.1275,0.575,0.195,0.66875);
03935   but11->SetTextSize(0.4);
03936   but11->SetFillColor(2);
03937   but11->SetName("logBut11");
03938     
03939   TButton *but12 = new TButton("Log Details","EVD->Log();",
03940                                0.,0.5,0.195,0.575);
03941   but12->SetTextSize(0.6);
03942   but12->SetFillColor(4);
03943 
03944   TButton *but7 = new TButton("Click for Info",
03945                                "EVD->PrintHSHelp();",
03946                                0.,0.95,0.195,1.0);
03947   but7->SetTextSize(0.6);
03948   but7->SetFillColor(45);
03949     
03950   but1->Draw();
03951   but2->Draw();
03952   but3->Draw();
03953   but4->Draw();
03954   but5->Draw();
03955   but6->Draw();
03956   but7->Draw();
03957   but8->Draw();
03958   but9->Draw();
03959   but10->Draw();
03960   but11->Draw();
03961   but12->Draw();
03962 }


Member Data Documentation

Float_t MadEvDisplay::Dmid_val [protected]

Definition at line 17 of file MadEvDisplay.h.

Referenced by Display(), DrawKey(), DrawKey2(), MadEvDisplay(), and SetDVals().

Definition at line 61 of file MadEvDisplay.h.

Referenced by Display(), DrawButtons(), and MadEvDisplay().

Float_t MadEvDisplay::Dspe_val [protected]

Definition at line 16 of file MadEvDisplay.h.

Referenced by Display(), DrawKey(), DrawKey2(), MadEvDisplay(), and SetDVals().

Definition at line 85 of file MadEvDisplay.h.

Referenced by Display(), DrawKey2(), and SetDefaultShowerMarkerColor().

Definition at line 86 of file MadEvDisplay.h.

Referenced by Display(), DrawKey2(), and SetDefaultShowerMarkerStyle().

Definition at line 83 of file MadEvDisplay.h.

Referenced by NextPass(), PrevPass(), and ReadEventsFile().

Definition at line 84 of file MadEvDisplay.h.

Referenced by NextInterestingEvent().

std::vector< std::vector<Int_t> > MadEvDisplay::fNeatoEvents [private]

Definition at line 82 of file MadEvDisplay.h.

Referenced by NextInterestingEvent(), and ReadEventsFile().

Definition at line 64 of file MadEvDisplay.h.

Referenced by Display(), DrawButtons(), EnableHandScan(), and MadEvDisplay().

Definition at line 52 of file MadEvDisplay.h.

Referenced by DrawButtons(), MadEvDisplay(), NextPass(), and PrevPass().

Definition at line 54 of file MadEvDisplay.h.

Referenced by Display(), DrawButtons(), and MadEvDisplay().

Definition at line 58 of file MadEvDisplay.h.

Referenced by MadEvDisplay(), NextInterestingEvent(), NextPass(), and PrevPass().

Definition at line 55 of file MadEvDisplay.h.

Referenced by Display(), DrawTextBox(), MadEvDisplay(), NextPass(), and PrevPass().

Definition at line 53 of file MadEvDisplay.h.

Referenced by Display(), DrawButtons(), and MadEvDisplay().

Definition at line 57 of file MadEvDisplay.h.

Referenced by Display(), DrawTextBox(), MadEvDisplay(), NextPass(), and PrevPass().

Definition at line 51 of file MadEvDisplay.h.

Referenced by DrawButtons(), MadEvDisplay(), NextPass(), and PrevPass().

Definition at line 56 of file MadEvDisplay.h.

Referenced by Display(), DrawTextBox(), MadEvDisplay(), NextPass(), and PrevPass().

Definition at line 67 of file MadEvDisplay.h.

Referenced by EnableHandScan(), Log(), and MadEvDisplay().

char MadEvDisplay::printName[100] [protected]

Definition at line 13 of file MadEvDisplay.h.

Referenced by Display(), and PrintDisplay().

char MadEvDisplay::printOpt[10] [protected]

Definition at line 14 of file MadEvDisplay.h.

Referenced by Display(), MadEvDisplay(), and SetPrintOpt().

Bool_t MadEvDisplay::ptt_msg [protected]

Definition at line 19 of file MadEvDisplay.h.

Referenced by Display(), MadEvDisplay(), and SetMessages().

Definition at line 65 of file MadEvDisplay.h.

Referenced by ChangeLogButColor(), Display(), Log(), and MadEvDisplay().

Definition at line 66 of file MadEvDisplay.h.

Referenced by ChangeLogButColor(), Display(), Log(), and MadEvDisplay().

Definition at line 59 of file MadEvDisplay.h.

Referenced by DrawButtons(), MadEvDisplay(), NextPass(), and PrevPass().


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

Generated on 2 Nov 2017 for loon by  doxygen 1.6.1