MadScanDisplay Class Reference

#include <MadScanDisplay.h>

Inheritance diagram for MadScanDisplay:

List of all members.

Public Member Functions
	MadScanDisplay (TChain *chainSR=0, TChain *chainMC=0, TChain *chainTH=0, TChain *chainem=0, const char *scan_sheet_name=0)
	MadScanDisplay (JobC *, string, int, const char *scan_sheet_name=0)
virtual	~MadScanDisplay ()
Int_t	NextEvt ()
Int_t	PrevEvt ()
Int_t	NextPass ()
Int_t	PrevPass ()
Int_t	NextFidNoTrk ()
Int_t	PrevFidNoTrk ()
Bool_t	InFidNoTrk (int e)
Int_t	NextFidTrk ()
Int_t	PrevFidTrk ()
Bool_t	InFidTrk (int e)
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	ROICalc ()
void	ShwROICalc ()
void	HandleZoomEvent ()
void	MakeGraphNonEditable (TObject *)
void	MakeGraphListNonEditable (TList *)
void	StartLogger ()
void	Log ()
void	EnableHandScan (char *)
void	ChangeLogButColor ()
void	PrintHSHelp ()
void	SetDefaultShowerMarkerColor (Int_t col)
void	SetDefaultShowerMarkerStyle (Int_t style)
void	FindUnSliced ()
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
ScanFrame *	SFrame
Bool_t	handScan
Int_t	ScanID
Int_t	ScanTop
char	logFileName [256]
bool	fAltDisplay
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
bool	fSetFidSet

---

Constructor & Destructor Documentation

MadScanDisplay::MadScanDisplay (  TChain *  chainSR = 0, TChain *  chainMC = 0, TChain *  chainTH = 0, TChain *  chainem = 0, const char *  scan_sheet_name = 0 )

Definition at line 44 of file MadScanDisplay.cxx. References MadBase::Clear(), ScanFrame::CreateScanSheet(), Dmid_val, drawSAME, Dspe_val, fAltDisplay, fSetFidSet, handScan, MadBase::InitChain(), LeAction, LeAutoMat, LeClus, LeEntry, LeEvent, LeLego, LeMCevent, LeNu, LeSlice, logFileName, printOpt, ptt_msg, ScanID, ScanTop, SFrame, and UseNuInfo. : fHaveNeatoEvents(false), fNeatoEventIdx(-1), fDefaultShowerMarkerColor(5), fDefaultShowerMarkerStyle(4) { fSetFidSet=false; Dspe_val = 2.0; Dmid_val = 20.0; ptt_msg = false; UseNuInfo = false; fAltDisplay= false; LeNu = 14; LeAction = 1; LeLego = false; LeClus = false; LeEvent = 0; LeSlice = 0; LeMCevent = 0; LeEntry = 0; LeAutoMat = true; drawSAME = false; handScan = false; ScanID = 0; ScanTop = 0; sprintf(logFileName,"handScan.dat"); sprintf(printOpt,"gif"); // sprintf(printOpt,"png"); // sprintf(printOpt,"eps"); if(!chainSR) { record = 0; emrecord = 0; mcrecord = 0; threcord = 0; Clear(); whichSource = -1; isMC = true; isTH = true; isEM = true; Nentries = -1; return; } InitChain(chainSR,chainMC,chainTH,chainEM, true); whichSource = 0; SFrame = ScanFrame::CreateScanSheet(gClient->GetRoot(),scan_sheet_name); // JM add }

MadScanDisplay::MadScanDisplay (  JobC *  , string  , int  , const char *  scan_sheet_name = 0 )

Definition at line 97 of file MadScanDisplay.cxx. References MadBase::Clear(), ScanFrame::CreateScanSheet(), Dmid_val, drawSAME, Dspe_val, fSetFidSet, handScan, LeAction, LeAutoMat, LeClus, LeEntry, LeEvent, LeLego, LeMCevent, LeNu, LeSlice, logFileName, printOpt, ptt_msg, ScanID, ScanTop, SFrame, and UseNuInfo. : fHaveNeatoEvents(false), fNeatoEventIdx(-1), fDefaultShowerMarkerColor(5), fDefaultShowerMarkerStyle(4) { fSetFidSet=false; Dspe_val = 2.0; Dmid_val = 20.0; ptt_msg = false; UseNuInfo = false; LeNu = 14; LeAction = 1; LeLego = false; LeClus = false; LeEvent = 0; LeSlice = 0; LeMCevent = 0; LeEntry = 0; LeAutoMat = true; drawSAME = false; handScan = false; ScanID = 0; ScanTop = 0; sprintf(logFileName,"handScan.dat"); sprintf(printOpt,"gif"); // sprintf(printOpt,"png"); // sprintf(printOpt,"eps"); record = 0; emrecord = 0; mcrecord = 0; threcord = 0; Clear(); isMC = true; isTH = true; isEM = true; Nentries = entries; jcPath = path; whichSource = 1; fCurRun = -1; fJC = j; fChain = NULL; SFrame = ScanFrame::CreateScanSheet(gClient->GetRoot(),scan_sheet_name); // JM add }

MadScanDisplay::~MadScanDisplay (   )  [virtual]

Definition at line 146 of file MadScanDisplay.cxx. { }

---

Member Function Documentation

void MadScanDisplay::ChangeLogButColor (   )

Definition at line 4586 of file MadScanDisplay.cxx. References ScanID, and ScanTop. Referenced by Display(). { if(gROOT->FindObject("MainCanvas")) { TCanvas *MainCanvas = (TCanvas*) gROOT->FindObject("MainCanvas"); TVirtualPad *MainCanvas_2 = MainCanvas->GetPad(2); char butName[256]; int butNums[10] = {1,2,3,4,5,6,8,9,10,11}; for(int i=0;i<10;i++){ sprintf(butName,"logBut%i",butNums[i]); TButton *but = (TButton*) MainCanvas_2->FindObject(butName); if(butNums[i]==ScanID || butNums[i]==ScanTop+7) { but->SetFillColor(3); but->Modified(); } else if(but->GetFillColor()!=2) { but->SetFillColor(2); but->Modified(); } } } }

Int_t * MadScanDisplay::Dec2Bin (  Int_t   )  [protected]

Definition at line 4018 of file MadScanDisplay.cxx. { Int_t *bin = new Int_t[32]; for(Int_t i=0;i<32;i++) bin[i]=0; Int_t index=1; while(true){ if(dec<TMath::Power(2,index) && dec>1) { bin[index-1]=1; dec-=Int_t(TMath::Power(2,index-1)); index=1; } else index+=1; if(dec==0) break; if(dec==1){ bin[0]=1; dec-=1; break; } } return bin; }

Bool_t MadScanDisplay::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 774 of file MadScanDisplay.cxx. References abs(), ChangeLogButColor(), NtpSRShower::clu, NtpSRTrack::contained, CorrectShowerEnergy(), count, NtpSRVertex::dcosu, NtpSRVertex::dcosv, NtpSRVertex::dcosz, det, DrawButtons(), DrawTextBox(), ClusterType::EClusterType, fDefaultShowerMarkerColor, fDefaultShowerMarkerStyle, VldContext::GetDetector(), MadBase::GetEntry(), PlaneOutline::GetNDPlanesHist(), PlaneOutline::GetOutline(), MadAbID::GetPass(), RecDataHeader::GetRun(), RecPhysicsHeader::GetSnarl(), RecHeader::GetVldContext(), NtpSRCluster::id, NtpMCStdHep::IdHEP, NtpSRShieldSummary::ishit, NtpMCStdHep::IstHEP, LeClus, LeEvent, LeLego, LeMCevent, LeSlice, NtpSRShowerPulseHeight::linCCgev, MadBase::LoadCluster(), MadBase::LoadEMShower(), MadBase::LoadEvent(), MadBase::LoadLargestShowerFromEvent(), MadBase::LoadLargestTrackFromEvent(), MadBase::LoadShower(), MadBase::LoadShower_Jim(), MadBase::LoadSlice(), MadBase::LoadSliceForRecoTH(), MadBase::LoadStrip(), MadBase::LoadTHEvent(), MadBase::LoadTrack(), MadBase::LoadTruth(), MadBase::LoadTruthForReco(), MadBase::LoadTruthForRecoTH(), MakeGraphListNonEditable(), NtpMCStdHep::mc, NtpSRTrack::momentum, NtpSRShower::ncluster, NtpSRSlice::ndigit, NtpTHEvent::neustdhep, NtpSREventSummary::nevent, NtpEMSummary::nshower, NtpSREvent::nshower, NtpSREventSummary::nslice, NtpSRTrack::nstrip, NtpEMShower::nstrip, NtpSRCluster::nstrip, NtpSRShower::nstrip, NtpSRSlice::nstrip, NtpSREventSummary::nstrip, NtpSREvent::ntrack, OK, NtpMCStdHep::p4, NtpMCTruth::p4el1, NtpMCTruth::p4mu1, NtpMCTruth::p4neu, NtpMCTruth::p4neunoosc, NtpMCStdHep::parent, ScanFrame::PassFloat(), ScanFrame::PassInt(), NtpSRPulseHeight::pe, NtpSRSlice::ph, NtpSREventSummary::ph, NtpSRStrip::ph0, NtpSRStrip::ph1, NtpSRStrip::plane, NtpSRCluster::planeview, NtpSRStrip::planeview, NtpMCStdHep::Print(), printName, NtpSRCluster::probem, NtpSRMomentum::qp, NtpSRMomentum::range, NtpSRPulseHeight::raw, ScanFrame::ResetDisplay(), ScanID, ScanTop, ScanFrame::SetEvent(), ScanFrame::SetRun(), ScanFrame::SetSlice(), ScanFrame::SetSnarl(), SFrame, NtpSREvent::shw, NtpSRShower::shwph, NtpSREvent::slc, NtpMCRecord::stdhep, NtpStRecord::stdhep, NtpSRTrack::stp, NtpEMShower::stp, NtpSRCluster::stp, NtpSRShower::stp, NtpSRSlice::stp, NtpSRRecord::stp, NtpStRecord::stp, NtpSRTrack::stpt0, NtpSRTrack::stpt1, NtpSRTrack::stpx, NtpSRTrack::stpy, NtpSRTrack::stpz, NtpSRStrip::strip, NtpSRShieldStrip::time, NtpSRStrip::time0, NtpSRStrip::time1, NtpSRStrip::tpos, NtpSREventSummary::trigtime, NtpSREvent::trk, NtpSRVertex::u, NtpSRVertex::v, NtpSRRecord::vetostp, NtpStRecord::vetostp, NtpMCStdHep::vtx, NtpSRTrack::vtx, NtpSRShower::vtx, NtpMCTruth::vtxx, NtpMCTruth::vtxy, NtpMCTruth::vtxz, NtpSRShieldStrip::x, NtpSRShieldStrip::y, NtpSRVertex::z, and NtpSRStrip::z. Referenced by JumpTo(), NextEvt(), NextFidNoTrk(), NextFidTrk(), NextInterestingEvent(), NextPass(), PrevEvt(), PrevFidNoTrk(), PrevFidTrk(), PrevPass(), and SkipTo(). { gStyle->SetTextFont(132); if(this->GetEntry(entry)==0) return false; Bool_t isReco = true; //checks for reconstructed event Bool_t NoSlice = false; //no point using LoadStrip since it will called many times, just get arrays TClonesArray* pointShieldStripArray = NULL; if(isST) pointShieldStripArray = (strecord->vetostp); else pointShieldStripArray = (record->vetostp); TClonesArray& shieldstripArray = *pointShieldStripArray; TClonesArray* pointStripArray = NULL; if(isST) pointStripArray = (strecord->stp); else pointStripArray = (record->stp); TClonesArray& stripArray = *pointStripArray; // find all strips not in a slice int nmissU=0; int nmissV=0; int nmissUOneEnd=0; int nmissVOneEnd=0; int nmissULowPE=0; int nmissVLowPE=0; float *missstripz_0 = new float[eventSummary->nstrip]; float *missstripz_1 = new float[eventSummary->nstrip]; float *missstript_0 = new float[eventSummary->nstrip]; float *missstript_1 = new float[eventSummary->nstrip]; float *missstripzOneEnd_0 = new float[eventSummary->nstrip]; float *missstripzOneEnd_1 = new float[eventSummary->nstrip]; float *missstriptOneEnd_0 = new float[eventSummary->nstrip]; float *missstriptOneEnd_1 = new float[eventSummary->nstrip]; float *missstripzLowPE_0 = new float[eventSummary->nstrip]; float *missstripzLowPE_1 = new float[eventSummary->nstrip]; float *missstriptLowPE_0 = new float[eventSummary->nstrip]; float *missstriptLowPE_1 = new float[eventSummary->nstrip]; float lowest_missz=100; float highest_missz=0; float lowest_misst0=100; float highest_misst0=-100; for(unsigned int i=0;i<eventSummary->nstrip;i++){ bool found=false; for(int j=0;j<eventSummary->nslice;j++){ LoadSlice(j); for(int k=0;k<ntpSlice->nstrip;k++){ unsigned int index = ntpSlice->stp[k]; if(index==i){found=true; continue;} } if(found)continue; } if(!found){ LoadStrip(i); if(ntpHeader->GetVldContext().GetDetector()==Detector::kFar || ntpStrip->plane<121){ if(ntpStrip->z<lowest_missz)lowest_missz=ntpStrip->z-0.2; if(ntpStrip->z>highest_missz)highest_missz=ntpStrip->z+0.2; if(ntpStrip->tpos<lowest_misst0)lowest_misst0=ntpStrip->tpos-0.2; if(ntpStrip->tpos>highest_misst0)highest_misst0=ntpStrip->tpos+0.2; if(ntpStrip->ph0.pe>0 && ntpStrip->ph1.pe>0 && ntpStrip->ph0.pe+ntpStrip->ph1.pe>2){ if(ntpStrip->planeview==PlaneView::kU){ missstript_0[nmissU]=ntpStrip->tpos; missstripz_0[nmissU]=ntpStrip->z; nmissU++; } else{ missstript_1[nmissV]=ntpStrip->tpos; missstripz_1[nmissV]=ntpStrip->z; nmissV++; } } else if(ntpStrip->ph0.pe==0 || ntpStrip->ph1.pe==0){ if(ntpStrip->planeview==PlaneView::kU){ missstriptOneEnd_0[nmissUOneEnd]=ntpStrip->tpos; missstripzOneEnd_0[nmissUOneEnd]=ntpStrip->z; nmissUOneEnd++; } else{ missstriptOneEnd_1[nmissVOneEnd]=ntpStrip->tpos; missstripzOneEnd_1[nmissVOneEnd]=ntpStrip->z; nmissVOneEnd++; } } else if((ntpStrip->ph0.pe>0 && ntpStrip->ph1.pe>0) && ntpStrip->ph0.pe+ntpStrip->ph1.pe<2){ if(ntpStrip->planeview==PlaneView::kU){ missstriptLowPE_0[nmissULowPE]=ntpStrip->tpos; missstripzLowPE_0[nmissULowPE]=ntpStrip->z; nmissULowPE++; } else{ missstriptLowPE_1[nmissVLowPE]=ntpStrip->tpos; missstripzLowPE_1[nmissVLowPE]=ntpStrip->z; nmissVLowPE++; } } } } } //Load the event: if(!LoadEvent(theEvent)) { //if can't load event asked for LeEvent = theEvent = 0; //try loading event 0 if(!LoadEvent(theEvent)) isReco=false; //if not present then don't //try to draw reco graphs } else LeEvent = theEvent; //if we have MC and TH, load slices and truth events based on reco'd event if(isMC) { if(isTH&&automat) { if(!LoadSliceForRecoTH(theEvent,theSlice)){ //load slice from reco evt LeSlice = theSlice = 0; //if not present load slice 0 if(!LoadSlice(theSlice)) { std::cerr << "No slice present in Run: " << ntpHeader->GetRun() << " Snarl: " << ntpHeader->GetSnarl() << std::endl; NoSlice=true; //if not there exit with a message after delete stuff } } else LeSlice = theSlice; if(!LoadTruthForRecoTH(theEvent,theMCevent)){ //load truth from reco LeMCevent = theMCevent = 0; //if not present load truth 0 LoadTruth(theMCevent); } else LeMCevent = theMCevent; } else if(automat){ //if there's no TH but we are in automatic mode if(!LoadTruthForReco(theEvent,theMCevent)){ //load truth using reco vtx LeMCevent = theMCevent = 0; //if not present load truth 0 LoadTruth(theMCevent); //load slice from event->slc: theSlice = ntpEvent->slc; if(!LoadSlice(theSlice)) { LeSlice = theSlice = 0; if(!LoadSlice(theSlice)) { std::cerr << "No slice present in Run: " << ntpHeader->GetRun() << " Snarl: " << ntpHeader->GetSnarl() << std::endl; NoSlice=true; //if not there exit with a message after delete stuff } } else LeSlice = theSlice; } else LeMCevent = theMCevent; } else { //not in automatic mode if(!LoadTruth(theMCevent)) { //load truth asked for LeMCevent = theMCevent = 0; //if not present load truth 0 LoadTruth(theMCevent); } else LeMCevent = theMCevent; if(!LoadSlice(theSlice)){ LeSlice = theSlice = 0; //if not present load slice 0 if(!LoadSlice(theSlice)){ std::cerr << "No slice present in Run: " << ntpHeader->GetRun() << " Snarl: " << ntpHeader->GetSnarl() << std::endl; NoSlice=true; //if not there exit with a message after delete stuff } } else LeSlice = theSlice; } // DrawInteractionDiagram(theMCevent); } else { //if no MC present if(!automat) { //if not in automatic mode, load slice asked for if possible if(!LoadSlice(theSlice)) { //if the one asked for not present theSlice = 0; LeSlice = theSlice; if(!LoadSlice(theSlice)){ //trying loading slice 0 std::cerr << "No slice present in Run: " << ntpHeader->GetRun() << " Snarl: " << ntpHeader->GetSnarl() << std::endl; return false; //if not there exit with a message } } else LeSlice = theSlice; } else { //in automatic mode if(isReco) { //if there is a reco'd event theSlice = ntpEvent->slc; //load slice from event if(!LoadSlice(theSlice)) { LeSlice = theSlice = 0; if(!LoadSlice(theSlice)) { std::cerr << "No slice present in Run: " << ntpHeader->GetRun() << " Snarl: " << ntpHeader->GetSnarl() << std::endl; NoSlice=true; //if not there exit with a message after delete stuff } } else LeSlice = theSlice; } else { //no reco'd event if(!LoadSlice(theSlice)) { //try to load the slice asked for LeSlice = theSlice = 0; //otherwise try to load slice 0 if(!LoadSlice(theSlice)) { std::cerr << "No slice present in Run: " << ntpHeader->GetRun() << " Snarl: " << ntpHeader->GetSnarl() << std::endl; NoSlice=true; //if not there exit with a message after delete stuff } } else LeSlice = theSlice; } } } sprintf(printName,"_Run%i_Snl%i_Slc%i_Evt%i.%s",ntpHeader->GetRun(), ntpHeader->GetSnarl(),theSlice,theEvent,printOpt); //Set Up Display Canvas //Delete Old Graphs TCanvas *RecoCanvas = 0; TCanvas *MainCanvas = 0; TCanvas *LegoCanvas = 0; TCanvas *ClusterCanvas = 0; static TPolyLine *line = 0; static TPolyLine *pu1_outline = 0; static TPolyLine *fu1_outline = 0; static TPolyLine *pv1_outline = 0; static TPolyLine *fv1_outline = 0; static TPolyLine *pu2_outline = 0; static TPolyLine *fu2_outline = 0; static TPolyLine *pv2_outline = 0; static TPolyLine *fv2_outline = 0; static TEllipse *nd_xy_fid = 0; static TPolyLine *nd_uz_fid = 0; static TPolyLine *nd_vz_fid = 0; static TEllipse *fd_xy_fid = 0; static TPolyLine *fd_uz_fid1 = 0; static TPolyLine *fd_vz_fid1 = 0; static TPolyLine *fd_uz_fid2 = 0; static TPolyLine *fd_vz_fid2 = 0; TEllipse *ellie = 0; TH2F *xz_place = 0; TH2F *yz_place = 0; TH2F *yx_place = 0; TH2 *tz_place_0 = 0; TH2 *tz_place_1 = 0; TH2 *tz_missplace_0 = 0; TH2 *tz_missplace_1 = 0; static std::string tz_place_dopt=""; TH2F *tz_0_lego = 0; TH2F *tz_1_lego = 0; TMultiGraph *xz_trk = 0; TMultiGraph *yz_trk = 0; TMultiGraph *yx_trk = 0; TMultiGraph *xz_shw = 0; TMultiGraph *yz_shw = 0; TMultiGraph *yx_shw = 0; TMultiGraph *yx_veto = 0; TMultiGraph * tz_missstp_0 = 0; TMultiGraph * tz_missstp_1 = 0; TMultiGraph *tz_stp_0 = 0; TMultiGraph *tz_stp_mid_0 = 0; TMultiGraph *tz_stp_spe_0 = 0; TMultiGraph *tz_stp_1 = 0; TMultiGraph *tz_stp_mid_1 = 0; TMultiGraph *tz_stp_spe_1 = 0; TMultiGraph *tz_trk0 = 0; TMultiGraph *tz_shw0 = 0; TMultiGraph *tz_emshw0 = 0; TMultiGraph *tz_clu0 = 0; TMultiGraph *tz_trk1 = 0; TMultiGraph *tz_shw1 = 0; TMultiGraph *tz_emshw1 = 0; TMultiGraph *tz_clu1 = 0; TLegend *cluLeg0 = 0; TLegend *cluLeg1 = 0; TMultiGraph *ytime = 0; TMultiGraph *ztime = 0; TMultiGraph *ytime_veto = 0; if(!gROOT->FindObject("RecoCanvas")){ //set up canvases and placeholders gStyle->SetOptStat(0); RecoCanvas = new TCanvas("RecoCanvas","Reconstructed Tracks",0,0,900,700); RecoCanvas->Divide(3,2); TVirtualPad *RecoCanvas_5 = RecoCanvas->GetPad(5); RecoCanvas_5->Divide(1,2); if(LeLego) { LegoCanvas = new TCanvas("LegoCanvas","Lego View of Hit Strips", 0,0,900,700); LegoCanvas->Divide(1,2); /* int nzpos = 1000; double z_pos[1001]; z_pos[0] = 0.5; z_pos[1] = 0.5+0.167; for(int i=2;i<1001;i++) z_pos[i] = z_pos[i-2]+1; */ int nzpos = 500; double z_pos[501]; z_pos[0] = 0.5; for(int i=1;i<501;i++) z_pos[i] = z_pos[i-1]+1; tz_0_lego = new TH2F("tz_0_lego","TPos vs Plane view - U Planes", nzpos,z_pos,192,-3.936,3.936); tz_0_lego->SetXTitle("Plane"); tz_0_lego->SetYTitle("TPos (m)"); tz_0_lego->SetZTitle("Pulse Height (PEs)"); tz_1_lego = new TH2F("tz_1_lego","TPos vs Plane view - V Planes", nzpos,z_pos,192,-3.936,3.936); tz_1_lego->SetXTitle("Plane"); tz_1_lego->SetYTitle("TPos (m)"); tz_1_lego->SetZTitle("Pulse Height (PEs)"); } if(LeClus) { ClusterCanvas = new TCanvas("ClusterCanvas","Reconstructed Cluster View", 910,0,400,700); ClusterCanvas->Divide(1,2); } MainCanvas = new TCanvas("MainCanvas","Main Display and Controls", 0,0,900,700); MainCanvas->Divide(2,2); // add zoom execs to these two pads: MainCanvas->GetPad(3)->AddExec("zoom","EVD->HandleZoomEvent()"); MainCanvas->GetPad(4)->AddExec("zoom","EVD->HandleZoomEvent()"); xz_place = new TH2F("xz_place","X vs Z view",70,0,35,50,-5,5); xz_place->SetXTitle("z position (m)"); xz_place->SetYTitle("x position (m)"); yz_place = new TH2F("yz_place","Y vs Z view",70,0,35,50,-5,5); yz_place->SetXTitle("z position (m)"); yz_place->SetYTitle("y position (m)"); yx_place = new TH2F("yx_place","Y vs X view",50,-5,5,50,-5,5); yx_place->SetXTitle("x position (m)"); yx_place->SetYTitle("y position (m)"); // mike, fill us Detector::Detector_t det=ntpHeader->GetVldContext().GetDetector(); if(det==Detector::kFar){ tz_place_0 = new TH2F("tz_place_0","Transverse vs Z view - U Planes", 70,0,35,50,-5,5); tz_place_1 = new TH2F("tz_place_1","Transverse vs Z view - V Planes", 70,0,35,50,-5,5); tz_missplace_0 = new TH2F("tz_missplace_0","Transverse vs Z view - U Planes", 70,0,35,50,-5,5); tz_missplace_1 = new TH2F("tz_missplace_1","Transverse vs Z view - V Planes", 70,0,35,50,-5,5); } else{ PlaneOutline po; tz_place_0 = po.GetNDPlanesHist(PlaneView::kV);//strips measure U tz_place_0->SetName("tz_place_0"); tz_place_0->SetTitle("Transverse vs Z view - U Planes"); // attempt to defeat ROOT's behaviour whereby it unzooms z axis // when user unzooms y axis ... didn't work, causes whacky behaviour //tz_place_0->GetYaxis()->SetName("xaxis"); tz_place_0->SetDirectory(gROOT); tz_missplace_0 = po.GetNDPlanesHist(PlaneView::kV);//strips measure U tz_missplace_0->SetName("tz_missplace_0"); tz_missplace_0->SetTitle("Transverse vs Z view - U Planes"); // attempt to defeat ROOT's behaviour whereby it unzooms z axis // when user unzooms y axis ... didn't work, causes whacky behaviour //tz_place_0->GetYaxis()->SetName("xaxis"); tz_missplace_0->SetDirectory(gROOT); // tz_place_0->SetDrawOption("col"); tz_place_1 = po.GetNDPlanesHist(PlaneView::kU);//strips measure V tz_place_1->SetName("tz_place_1"); tz_place_1->SetTitle("Transverse vs Z view - V Planes"); //tz_place_1->GetYaxis()->SetName("xaxis"); tz_place_1->SetDirectory(gROOT); tz_missplace_1 = po.GetNDPlanesHist(PlaneView::kU);//strips measure V tz_missplace_1->SetName("tz_missplace_1"); tz_missplace_1->SetTitle("Transverse vs Z view - V Planes"); //tz_place_1->GetYaxis()->SetName("xaxis"); tz_missplace_1->SetDirectory(gROOT); // tz_place_1->SetDrawOption("col"); tz_place_dopt ="col"; } tz_place_0->SetXTitle("z position (m)"); tz_place_0->SetYTitle("transverse position (m)"); tz_place_1->SetXTitle("z position (m)"); tz_place_1->SetYTitle("transverse position (m)"); tz_missplace_0->SetXTitle("z position (m)"); tz_missplace_0->SetYTitle("transverse position (m)"); tz_missplace_1->SetXTitle("z position (m)"); tz_missplace_1->SetYTitle("transverse position (m)"); this->DrawButtons(MainCanvas); } else { RecoCanvas = (TCanvas*) gROOT->FindObject("RecoCanvas"); MainCanvas = (TCanvas*) gROOT->FindObject("MainCanvas"); //Lego: if(gROOT->FindObject("LegoCanvas")) { LegoCanvas = (TCanvas*) gROOT->FindObject("LegoCanvas"); LegoCanvas->cd(1); TVirtualPad *LegoCanvas_1 = LegoCanvas->GetPad(1); tz_0_lego = (TH2F*) LegoCanvas_1->FindObject("tz_0_lego"); LegoCanvas->cd(2); TVirtualPad *LegoCanvas_2 = LegoCanvas->GetPad(2); tz_1_lego = (TH2F*) LegoCanvas_2->FindObject("tz_1_lego"); } else if(LeLego) { LegoCanvas = new TCanvas("LegoCanvas","Lego View of Hit Strips", 0,0,900,700); LegoCanvas->Divide(1,2); /* int nzpos = 1000; double z_pos[1001]; z_pos[0] = 0.5; z_pos[1] = 0.5+0.167; for(int i=2;i<1001;i++) z_pos[i] = z_pos[i-2]+1; */ int nzpos = 500; double z_pos[501]; z_pos[0] = 0.5; for(int i=1;i<501;i++) z_pos[i] = z_pos[i-1]+1; tz_0_lego = new TH2F("tz_0_lego","TPos vs Plane view - U Planes", nzpos,z_pos,192,-3.936,3.936); tz_0_lego->SetXTitle("Plane"); tz_0_lego->SetYTitle("TPos (m)"); tz_0_lego->SetZTitle("Pulse Height (PEs)"); tz_1_lego = new TH2F("tz_1_lego","TPos vs Plane view - V Planes", nzpos,z_pos,192,-3.936,3.936); tz_1_lego->SetXTitle("Plane"); tz_1_lego->SetYTitle("TPos (m)"); tz_1_lego->SetZTitle("Pulse Height (PEs)"); LegoCanvas->cd(1); tz_0_lego->Draw("lego"); LegoCanvas->cd(2); tz_1_lego->Draw("lego"); } if(!LeLego&&gROOT->FindObject("LegoCanvas")) { delete LegoCanvas; delete tz_0_lego; delete tz_1_lego; } RecoCanvas->cd(1); TVirtualPad *RecoCanvas_1 = RecoCanvas->GetPad(1); TVirtualPad *RecoCanvas_4 = RecoCanvas->GetPad(4); TVirtualPad *RecoCanvas_2 = RecoCanvas->GetPad(2); xz_trk = (TMultiGraph*) RecoCanvas_1->FindObject("xz_trk"); yz_trk = (TMultiGraph*) RecoCanvas_4->FindObject("yz_trk"); yx_trk = (TMultiGraph*) RecoCanvas_2->FindObject("yx_trk"); xz_shw = (TMultiGraph*) RecoCanvas_1->FindObject("xz_shw"); yz_shw = (TMultiGraph*) RecoCanvas_4->FindObject("yz_shw"); yx_shw = (TMultiGraph*) RecoCanvas_2->FindObject("yx_shw"); yx_veto = (TMultiGraph*) RecoCanvas_2->FindObject("yx_veto"); if(!drawSAME) { delete xz_trk; xz_trk = 0; delete yz_trk; yz_trk = 0; delete yx_trk; yx_trk = 0; delete xz_shw; xz_shw = 0; delete yz_shw; yz_shw = 0; delete yx_shw; yx_shw = 0; delete yx_veto; yx_veto = 0; } RecoCanvas->cd(5); TVirtualPad *RecoCanvas_5 = RecoCanvas->GetPad(5); TVirtualPad *RecoCanvas_5_1 = RecoCanvas_5->GetPad(1); TVirtualPad *RecoCanvas_5_2 = RecoCanvas_5->GetPad(2); ytime = (TMultiGraph*) RecoCanvas_5_1->FindObject("ytime"); ztime = (TMultiGraph*) RecoCanvas_5_2->FindObject("ztime"); ytime_veto = (TMultiGraph*) RecoCanvas_5_1->FindObject("ytime_veto"); if(!drawSAME) { delete ytime; ytime = 0; delete ztime; ztime = 0; delete ytime_veto; ytime_veto = 0; } MainCanvas->cd(1); TVirtualPad *MainCanvas_1 = MainCanvas->GetPad(1); TLatex *info1 = (TLatex*) MainCanvas_1->FindObject("info1"); TLatex *info2 = (TLatex*) MainCanvas_1->FindObject("info2"); TLatex *info3 = (TLatex*) MainCanvas_1->FindObject("info3"); TLatex *info4 = (TLatex*) MainCanvas_1->FindObject("info4"); TLatex *info5 = (TLatex*) MainCanvas_1->FindObject("info5"); TLatex *info6 = (TLatex*) MainCanvas_1->FindObject("info6"); TLatex *info7 = (TLatex*) MainCanvas_1->FindObject("info7"); TLatex *info8 = (TLatex*) MainCanvas_1->FindObject("info8"); TLatex *info9 = (TLatex*) MainCanvas_1->FindObject("info9"); TLatex *info10 = (TLatex*) MainCanvas_1->FindObject("info10"); TLatex *info11 = (TLatex*) MainCanvas_1->FindObject("info11"); TLatex *info12 = (TLatex*) MainCanvas_1->FindObject("info12"); TLatex *info13 = (TLatex*) MainCanvas_1->FindObject("info13"); TLatex *info14 = (TLatex*) MainCanvas_1->FindObject("info14"); delete info1; delete info2; delete info3; delete info4; delete info5; delete info6; delete info7; delete info8; delete info9; delete info10; delete info11; delete info12; delete info13; delete info14; MainCanvas->cd(3); TPad *MainCanvas_3 = (TPad*)MainCanvas->GetPad(3); tz_stp_0 = (TMultiGraph*) MainCanvas_3->FindObject("tz_stp_0"); tz_stp_mid_0 = (TMultiGraph*) MainCanvas_3->FindObject("tz_stp_mid_0"); tz_stp_spe_0 = (TMultiGraph*) MainCanvas_3->FindObject("tz_stp_spe_0"); if(!drawSAME){ delete tz_stp_0; tz_stp_0 = 0; delete tz_stp_mid_0; tz_stp_mid_0 = 0; delete tz_stp_spe_0; tz_stp_spe_0 = 0; } tz_trk0 = (TMultiGraph*) MainCanvas_3->FindObject("tz_trk0"); tz_shw0 = (TMultiGraph*) MainCanvas_3->FindObject("tz_shw0"); tz_emshw0 = (TMultiGraph*) MainCanvas_3->FindObject("tz_emshw0"); if(!drawSAME){ delete tz_trk0; tz_trk0 = 0; delete tz_shw0; tz_shw0 = 0; delete tz_emshw0; tz_emshw0 = 0; } TArrow *ttz_arrow1 = (TArrow*) MainCanvas_3->FindObject("TArrow"); delete ttz_arrow1; //delete stdhep lines: TLine *stdhepLine = 0; while((stdhepLine = (TLine*) MainCanvas_3->FindObject("TLine"))) { delete stdhepLine; } MainCanvas->cd(4); TPad *MainCanvas_4 = (TPad*)MainCanvas->GetPad(4); tz_stp_1 = (TMultiGraph*) MainCanvas_4->FindObject("tz_stp_1"); tz_stp_mid_1 = (TMultiGraph*) MainCanvas_4->FindObject("tz_stp_mid_1"); tz_stp_spe_1 = (TMultiGraph*) MainCanvas_4->FindObject("tz_stp_spe_1"); if(!drawSAME){ delete tz_stp_1; tz_stp_1 = 0; delete tz_stp_mid_1; tz_stp_mid_1 = 0; delete tz_stp_spe_1; tz_stp_spe_1 = 0; } tz_trk1 = (TMultiGraph*) MainCanvas_4->FindObject("tz_trk1"); tz_shw1 = (TMultiGraph*) MainCanvas_4->FindObject("tz_shw1"); tz_emshw1 = (TMultiGraph*) MainCanvas_4->FindObject("tz_emshw1"); if(!drawSAME){ delete tz_trk1; tz_trk1 = 0; delete tz_shw1; tz_shw1 = 0; delete tz_emshw1; tz_emshw1 = 0; } TArrow *ttz_arrow2 = (TArrow*) MainCanvas_4->FindObject("TArrow"); delete ttz_arrow2; stdhepLine = 0; while((stdhepLine = (TLine*) MainCanvas_4->FindObject("TLine"))) { delete stdhepLine; } //Cluster: if(gROOT->FindObject("ClusterCanvas")) { ClusterCanvas = (TCanvas*) gROOT->FindObject("ClusterCanvas"); ClusterCanvas->cd(1); TVirtualPad *ClusterCanvas_1 = ClusterCanvas->GetPad(1); tz_clu0 = (TMultiGraph*) ClusterCanvas_1->FindObject("tz_clu0"); cluLeg0 = (TLegend*) ClusterCanvas_1->FindObject("TPave"); if(!drawSAME) { delete tz_clu0; tz_clu0 = 0; delete cluLeg0; cluLeg0 = 0; } gPad->Update(); gPad->Modified(); ClusterCanvas->cd(2); TVirtualPad *ClusterCanvas_2 = ClusterCanvas->GetPad(2); tz_clu1 = (TMultiGraph*) ClusterCanvas_2->FindObject("tz_clu1"); cluLeg1 = (TLegend*) ClusterCanvas_2->FindObject("TPave"); if(!drawSAME) { delete tz_clu1; tz_clu1 = 0; delete cluLeg1; cluLeg1 = 0; } gPad->Update(); gPad->Modified(); } else if(LeClus) { ClusterCanvas = new TCanvas("ClusterCanvas","Reconstructed Cluster View", 910,0,400,700); ClusterCanvas->Divide(1,2); } if(!LeClus&&gROOT->FindObject("ClusterCanvas")) { delete ClusterCanvas; } RecoCanvas->cd(2); // line = (TPolyLine*) RecoCanvas_2->FindObject("TPolyLine"); ellie = (TEllipse*) RecoCanvas_2->FindObject("TEllipse"); RecoCanvas->Clear(); RecoCanvas->Divide(3,2); RecoCanvas_5 = RecoCanvas->GetPad(5); RecoCanvas_5->Divide(1,2); xz_place = (TH2F*) gROOT->FindObject("xz_place"); yz_place = (TH2F*) gROOT->FindObject("yz_place"); yx_place = (TH2F*) gROOT->FindObject("yx_place"); tz_place_0 = (TH2*) gROOT->FindObject("tz_place_0"); tz_place_1 = (TH2*) gROOT->FindObject("tz_place_1"); tz_missplace_0 = (TH2*) gROOT->FindObject("tz_missplace_0"); tz_missplace_1 = (TH2*) gROOT->FindObject("tz_missplace_1"); xz_place->GetXaxis()->UnZoom(); yz_place->GetXaxis()->UnZoom(); tz_place_0->GetXaxis()->UnZoom(); tz_place_1->GetXaxis()->UnZoom(); tz_missplace_0->GetXaxis()->UnZoom(); tz_missplace_1->GetXaxis()->UnZoom(); xz_place->GetYaxis()->UnZoom(); yz_place->GetYaxis()->UnZoom(); tz_place_0->GetYaxis()->UnZoom(); tz_place_1->GetYaxis()->UnZoom(); tz_missplace_0->GetYaxis()->UnZoom(); tz_missplace_1->GetYaxis()->UnZoom(); if(ntpHeader->GetVldContext().GetDetector()==Detector::kNear){ yx_place->GetXaxis()->SetRangeUser(-2.6,3.8); yx_place->GetYaxis()->SetRangeUser(-3.2,3.2); } else { yx_place->GetXaxis()->UnZoom(); yx_place->GetYaxis()->UnZoom(); } if(LeLego){ tz_0_lego->GetXaxis()->UnZoom(); tz_0_lego->GetYaxis()->UnZoom(); tz_1_lego->GetXaxis()->UnZoom(); tz_1_lego->GetYaxis()->UnZoom(); if(!drawSAME) { tz_0_lego->Reset(); tz_1_lego->Reset(); } } if(handScan) { ScanID = 0; ScanTop = 0; ChangeLogButColor(); } } //if no detector outlines, make them here: if(!line){ float linex_caldet[5] = {-0.5,0.5,0.5,-0.5,-0.5}; float liney_caldet[5] = {-0.5,-0.5,0.5,0.5,-0.5}; if(ntpHeader->GetVldContext().GetDetector()==Detector::kFar) { line = new TPolyLine(33,""); line->SetPoint( 0, 421.8893*Munits::cm,-142.8867*Munits::cm); line->SetPoint( 1, 421.8893*Munits::cm,-138.3342*Munits::cm); line->SetPoint( 2, 400.1614*Munits::cm,-115.9855*Munits::cm); line->SetPoint( 3, 400.1614*Munits::cm, 87.6358*Munits::cm); line->SetPoint( 4, 406.9902*Munits::cm, 94.0507*Munits::cm); line->SetPoint( 5, 429.1319*Munits::cm, 101.5003*Munits::cm); line->SetPoint( 6, 447.1350*Munits::cm, 101.5003*Munits::cm); line->SetPoint( 7, 454.7915*Munits::cm, 94.2577*Munits::cm); line->SetPoint( 8, 457.6886*Munits::cm, 94.2577*Munits::cm); line->SetPoint( 9, 457.6886*Munits::cm, 109.3637*Munits::cm); line->SetPoint(10, 143.7724*Munits::cm, 423.2799*Munits::cm); line->SetPoint(11, 139.4268*Munits::cm, 423.2799*Munits::cm); line->SetPoint(12, 117.2850*Munits::cm, 401.1382*Munits::cm); line->SetPoint(13,-116.9622*Munits::cm, 401.1382*Munits::cm); line->SetPoint(14,-139.1040*Munits::cm, 423.2799*Munits::cm); line->SetPoint(15,-143.4496*Munits::cm, 423.2799*Munits::cm); line->SetPoint(16,-457.3658*Munits::cm, 109.3637*Munits::cm); line->SetPoint(17,-457.3658*Munits::cm, 94.2577*Munits::cm); line->SetPoint(18,-454.4687*Munits::cm, 94.2577*Munits::cm); line->SetPoint(19,-439.9834*Munits::cm, 101.9141*Munits::cm); line->SetPoint(20,-429.8438*Munits::cm, 101.9141*Munits::cm); line->SetPoint(21,-406.6674*Munits::cm, 94.2577*Munits::cm); line->SetPoint(22,-399.8386*Munits::cm, 84.7388*Munits::cm); line->SetPoint(23,-399.8386*Munits::cm,-115.9855*Munits::cm); line->SetPoint(24,-421.5665*Munits::cm,-137.7134*Munits::cm); line->SetPoint(25,-421.5665*Munits::cm,-142.8867*Munits::cm); line->SetPoint(26,-143.4496*Munits::cm,-421.0036*Munits::cm); line->SetPoint(27,-139.1040*Munits::cm,-421.0036*Munits::cm); line->SetPoint(28,-116.9622*Munits::cm,-398.8619*Munits::cm); line->SetPoint(29, 116.8712*Munits::cm,-398.8619*Munits::cm); line->SetPoint(30, 139.4268*Munits::cm,-421.0036*Munits::cm); line->SetPoint(31, 143.7724*Munits::cm,-421.0036*Munits::cm); line->SetPoint(32, 421.8893*Munits::cm,-142.8867*Munits::cm); fd_xy_fid = new TEllipse(0., 0., 3.74, 3.74); // 0.8 m radius fd_xy_fid->SetLineWidth(2); fd_xy_fid->SetLineColor(kBlack); fd_xy_fid->SetLineStyle(kDashed); fd_xy_fid->SetBit(kCannotPick); // hey, don't move! fd_uz_fid1 = new TPolyLine(5); fd_vz_fid1 = new TPolyLine(5); fd_uz_fid2 = new TPolyLine(5); fd_vz_fid2 = new TPolyLine(5); const double u_cen=0; const double v_cen=0; fd_uz_fid1->SetPoint(0,0.49,u_cen+3.74); fd_uz_fid1->SetPoint(1,14.9,u_cen+3.74); fd_uz_fid1->SetPoint(2,14.9,u_cen-3.74); fd_uz_fid1->SetPoint(3,0.49,u_cen-3.74); fd_uz_fid1->SetPoint(4,0.49,u_cen+3.74); fd_uz_fid1->SetLineColor(kBlack); fd_uz_fid1->SetLineStyle(kDashed); fd_uz_fid1->SetLineWidth(2); fd_uz_fid1->SetBit(kCannotPick); fd_uz_fid2->SetPoint(0,16.27,u_cen+3.74); fd_uz_fid2->SetPoint(1,27.98,u_cen+3.74); fd_uz_fid2->SetPoint(2,27.98,u_cen-3.74); fd_uz_fid2->SetPoint(3,16.27,u_cen-3.74); fd_uz_fid2->SetPoint(4,16.27,u_cen+3.74); fd_uz_fid2->SetLineColor(kBlack); fd_uz_fid2->SetLineStyle(kDashed); fd_uz_fid2->SetLineWidth(2); fd_uz_fid2->SetBit(kCannotPick); fd_vz_fid1->SetPoint(0,0.49,v_cen+3.74); fd_vz_fid1->SetPoint(1,14.9,v_cen+3.74); fd_vz_fid1->SetPoint(2,14.9,v_cen-3.74); fd_vz_fid1->SetPoint(3,0.49,v_cen-3.74); fd_vz_fid1->SetPoint(4,0.49,v_cen+3.74); fd_vz_fid1->SetLineColor(kBlack); fd_vz_fid1->SetLineStyle(kDashed); fd_vz_fid1->SetLineWidth(2); fd_vz_fid1->SetBit(kCannotPick); fd_vz_fid2->SetPoint(0,16.27,u_cen+3.74); fd_vz_fid2->SetPoint(1,27.98,u_cen+3.74); fd_vz_fid2->SetPoint(2,27.98,u_cen-3.74); fd_vz_fid2->SetPoint(3,16.27,u_cen-3.74); fd_vz_fid2->SetPoint(4,16.27,u_cen+3.74); fd_vz_fid2->SetLineColor(kBlack); fd_vz_fid2->SetLineStyle(kDashed); fd_vz_fid2->SetLineWidth(2); fd_vz_fid2->SetBit(kCannotPick); } else if(ntpHeader->GetVldContext().GetDetector()==Detector::kNear) { line = new TPolyLine(23,""); Double_t x0 = 55.78*Munits::cm; line->SetPoint( 0,-121.43*Munits::inch+x0, 0.47*Munits::inch); line->SetPoint( 1,-120.25*Munits::inch+x0, 0.47*Munits::inch); line->SetPoint( 2,-115.14*Munits::inch+x0, 3.42*Munits::inch); line->SetPoint( 3,-110.24*Munits::inch+x0, 3.42*Munits::inch); line->SetPoint( 4, -95.24*Munits::inch+x0, -1.48*Munits::inch); line->SetPoint( 5, -95.24*Munits::inch+x0,-35.47*Munits::inch); line->SetPoint( 6, -69.80*Munits::inch+x0,-60.91*Munits::inch); line->SetPoint( 7, -69.80*Munits::inch+x0,-75.04*Munits::inch); line->SetPoint( 8, 69.80*Munits::inch+x0,-75.04*Munits::inch); line->SetPoint( 9, 69.80*Munits::inch+x0,-60.91*Munits::inch); line->SetPoint(10, 95.24*Munits::inch+x0,-35.47*Munits::inch); line->SetPoint(11, 95.24*Munits::inch+x0, -1.48*Munits::inch); line->SetPoint(12, 110.16*Munits::inch+x0, 3.42*Munits::inch); line->SetPoint(13, 117.30*Munits::inch+x0, 3.42*Munits::inch); line->SetPoint(14, 120.25*Munits::inch+x0, 0.47*Munits::inch); line->SetPoint(15, 121.43*Munits::inch+x0, 0.47*Munits::inch); line->SetPoint(16, 121.43*Munits::inch+x0, 9.28*Munits::inch); line->SetPoint(17, 69.80*Munits::inch+x0, 60.91*Munits::inch); line->SetPoint(18, 69.80*Munits::inch+x0, 75.04*Munits::inch); line->SetPoint(19, -69.80*Munits::inch+x0, 75.04*Munits::inch); line->SetPoint(20, -69.80*Munits::inch+x0, 60.91*Munits::inch); line->SetPoint(21,-121.43*Munits::inch+x0, 9.28*Munits::inch); line->SetPoint(22,-121.43*Munits::inch+x0, 0.47*Munits::inch); line->SetBit(kCannotPick); // near detector plane outlines PlaneOutline po; Color_t colu=38; Color_t colv=46; po.GetOutline(PlaneView::kV, PlaneCoverage::kNearPartial, pv1_outline, pv2_outline); po.GetOutline(PlaneView::kV, PlaneCoverage::kNearFull, fv1_outline, fv2_outline); po.GetOutline(PlaneView::kU, PlaneCoverage::kNearPartial, pu1_outline, pu2_outline); po.GetOutline(PlaneView::kU, PlaneCoverage::kNearFull, fu1_outline, fu2_outline); pv1_outline->SetLineColor(colv); pu1_outline->SetLineColor(colu); fv1_outline->SetLineColor(colv); fu1_outline->SetLineColor(colu); fv2_outline->SetFillColor(16); fu2_outline->SetFillColor(16); fv2_outline->SetFillStyle(4020); fu2_outline->SetFillStyle(4020); pv1_outline->SetLineWidth(2); pu1_outline->SetLineWidth(2); fv1_outline->SetLineWidth(2); fu1_outline->SetLineWidth(2); fv2_outline->SetLineWidth(2); fu2_outline->SetLineWidth(2); pv1_outline->SetBit(kCannotPick); pu1_outline->SetBit(kCannotPick); fv1_outline->SetBit(kCannotPick); fu1_outline->SetBit(kCannotPick); fv2_outline->SetBit(kCannotPick); fu2_outline->SetBit(kCannotPick); nd_xy_fid = new TEllipse(1.4885, 0.1397, 0.8, 0.8); // 0.8 m radius nd_xy_fid->SetLineWidth(2); nd_xy_fid->SetLineColor(kBlack); nd_xy_fid->SetLineStyle(kDashed); nd_xy_fid->SetBit(kCannotPick); // hey, don't move! nd_uz_fid = new TPolyLine(5); nd_vz_fid = new TPolyLine(5); const double u_cen=(1.0/sqrt(2.0))*(1.4885+0.1397); const double v_cen=(1.0/sqrt(2.0))*(0.1397-1.4885); nd_uz_fid->SetPoint(0,0.8,u_cen+0.8); nd_uz_fid->SetPoint(1,4.0,u_cen+0.8); nd_uz_fid->SetPoint(2,4.0,u_cen-0.8); nd_uz_fid->SetPoint(3,0.8,u_cen-0.8); nd_uz_fid->SetPoint(4,0.8,u_cen+0.8); nd_uz_fid->SetLineColor(kBlack); nd_uz_fid->SetLineStyle(kDashed); nd_uz_fid->SetLineWidth(2); nd_uz_fid->SetBit(kCannotPick); nd_vz_fid->SetPoint(0,0.8,v_cen+0.8); nd_vz_fid->SetPoint(1,4.0,v_cen+0.8); nd_vz_fid->SetPoint(2,4.0,v_cen-0.8); nd_vz_fid->SetPoint(3,0.8,v_cen-0.8); nd_vz_fid->SetPoint(4,0.8,v_cen+0.8); nd_vz_fid->SetLineColor(kBlack); nd_vz_fid->SetLineStyle(kDashed); nd_vz_fid->SetLineWidth(2); nd_vz_fid->SetBit(kCannotPick); } else if(ntpHeader->GetVldContext().GetDetector()==Detector::kCalDet) line = new TPolyLine(5,linex_caldet,liney_caldet); line->SetLineWidth(3); line->SetLineColor(4); } if(!ellie&&ntpHeader->GetVldContext().GetDetector()==Detector::kFar){ ellie = new TEllipse(0,0,3.5,3.5,0,360,0); ellie->SetLineColor(6); ellie->SetLineWidth(3); ellie->SetLineStyle(2); } // if(NoSlice) return false; // Missing Strips if(tz_missstp_0 && nmissU>0) { tz_missstp_0 = new TMultiGraph(); tz_missstp_0->SetName("tz_missstp_0"); tz_missstp_0->SetTitle("Transverse Position vs Z View"); } if(tz_missstp_0 && nmissU>0){ TGraph *temp = new TGraph(nmissU,missstripz_0,missstript_0); temp->SetMarkerColor(2); temp->SetMarkerSize(1); temp->SetMarkerStyle(8); tz_missstp_0->Add(temp); } if(tz_missstp_0 && nmissU>0){ TGraph *temp = new TGraph(nmissU,missstripz_0,missstript_0); temp->SetMarkerColor(2); temp->SetMarkerSize(1); temp->SetMarkerStyle(8); tz_missstp_0->Add(temp); } if(tz_missstp_0 && nmissUOneEnd>0){ TGraph *temp = new TGraph(nmissUOneEnd,missstripzOneEnd_0,missstriptOneEnd_0); temp->SetMarkerColor(3); temp->SetMarkerSize(1); temp->SetMarkerStyle(8); tz_missstp_0->Add(temp); } if(tz_missstp_0 && nmissULowPE>0){ TGraph *temp = new TGraph(nmissULowPE,missstripzLowPE_0,missstriptLowPE_0); temp->SetMarkerColor(4); temp->SetMarkerSize(1); temp->SetMarkerStyle(8); tz_missstp_0->Add(temp); } if(tz_missstp_1 && nmissV>0) { tz_missstp_1 = new TMultiGraph(); tz_missstp_1->SetName("tz_missstp_1"); tz_missstp_1->SetTitle("Transverse Position vs Z View"); } if(tz_missstp_1 && nmissV>0){ TGraph *temp = new TGraph(nmissV,missstripz_1,missstript_1); temp->SetMarkerColor(2); temp->SetMarkerSize(1); temp->SetMarkerStyle(8); tz_missstp_1->Add(temp); } if(tz_missstp_1 && nmissVOneEnd>0){ TGraph *temp = new TGraph(nmissVOneEnd,missstripzOneEnd_1,missstriptOneEnd_1); temp->SetMarkerColor(3); temp->SetMarkerSize(1); temp->SetMarkerStyle(8); tz_missstp_1->Add(temp); } if(tz_missstp_1 && nmissVLowPE>0){ TGraph *temp = new TGraph(nmissVLowPE,missstripzLowPE_1,missstriptLowPE_1); temp->SetMarkerColor(4); temp->SetMarkerSize(1); temp->SetMarkerStyle(8); tz_missstp_1->Add(temp); } delete [] missstript_0; delete [] missstripz_0; delete [] missstript_1; delete [] missstripz_1; delete [] missstriptOneEnd_0; delete [] missstripzOneEnd_0; delete [] missstriptOneEnd_1; delete [] missstripzOneEnd_1; delete [] missstriptLowPE_0; delete [] missstripzLowPE_0; delete [] missstriptLowPE_1; delete [] missstripzLowPE_1; //Strips int slc_nstrip=0; if(ntpSlice){ slc_nstrip = ntpSlice->nstrip; } float *stp_z_big_0 = new float[slc_nstrip]; float *stp_z_mid_0 = new float[slc_nstrip]; float *stp_z_spe_0 = new float[slc_nstrip]; float *stp_tpos_big_0 = new float[slc_nstrip]; float *stp_tpos_mid_0 = new float[slc_nstrip]; float *stp_tpos_spe_0 = new float[slc_nstrip]; int nstp_big_0 = 0; int nstp_mid_0 = 0; int nstp_spe_0 = 0; float *stp_z_big_1 = new float[slc_nstrip]; float *stp_z_mid_1 = new float[slc_nstrip]; float *stp_z_spe_1 = new float[slc_nstrip]; float *stp_tpos_big_1 = new float[slc_nstrip]; float *stp_tpos_mid_1 = new float[slc_nstrip]; float *stp_tpos_spe_1 = new float[slc_nstrip]; int nstp_big_1 = 0; int nstp_mid_1 = 0; int nstp_spe_1 = 0; float ATH_reco0[500][192] = {}; float ATH_reco1[500][192] = {}; float ATH_mcA[500][192] = {}; float ATH_mcB[500][192] = {}; for(int i=0;i<500;i++){ for(int j=0;j<192;j++){ ATH_reco0[i][j] = -1; ATH_reco1[i][j] = -1; ATH_mcA[i][j] = -1; ATH_mcB[i][j] = -1; } } float highest_plane = 0; float lowest_plane = 500; float highest_z = 0; float lowest_z = 30.; float highest_t0 = -4.0; float lowest_t0 = 4.0; float highest_t1 = -4.0; float lowest_t1 = 4.0; for(int i=0;i<slc_nstrip;i++){ int index = ntpSlice->stp[i]; ntpStrip = dynamic_cast<NtpSRStrip *>(stripArray[index]); int tempo_pln = ntpStrip->plane; int tempo_stp = ntpStrip->strip; if(tempo_pln<lowest_plane) { lowest_plane=tempo_pln; lowest_z=ntpStrip->z; } if(tempo_pln>highest_plane) { highest_plane=tempo_pln; highest_z=ntpStrip->z; } ATH_reco0[tempo_pln][tempo_stp] = ntpStrip->ph0.pe; ATH_reco1[tempo_pln][tempo_stp] = ntpStrip->ph1.pe; if(ntpStrip->planeview==2){ if(LeLego) tz_0_lego->Fill(tempo_pln-0.49,ntpStrip->tpos, ntpStrip->ph0.pe+ntpStrip->ph1.pe); if(ntpStrip->tpos<lowest_t0) lowest_t0=ntpStrip->tpos; if(ntpStrip->tpos>highest_t0) highest_t0=ntpStrip->tpos; if(ntpStrip->ph0.pe+ntpStrip->ph1.pe<Dspe_val){ stp_z_spe_0[nstp_spe_0]=ntpStrip->z; stp_tpos_spe_0[nstp_spe_0]=ntpStrip->tpos; nstp_spe_0++; } else if(ntpStrip->ph0.pe+ntpStrip->ph1.pe<Dmid_val){ stp_z_mid_0[nstp_mid_0]=ntpStrip->z; stp_tpos_mid_0[nstp_mid_0]=ntpStrip->tpos; nstp_mid_0++; } else { stp_z_big_0[nstp_big_0]=ntpStrip->z; stp_tpos_big_0[nstp_big_0]=ntpStrip->tpos; nstp_big_0++; } } else { if(LeLego) tz_1_lego->Fill(tempo_pln-0.49,ntpStrip->tpos, ntpStrip->ph0.pe+ntpStrip->ph1.pe); if(ntpStrip->tpos<lowest_t1) lowest_t1=ntpStrip->tpos; if(ntpStrip->tpos>highest_t1) highest_t1=ntpStrip->tpos; if(ntpStrip->ph0.pe+ntpStrip->ph1.pe<Dspe_val){ stp_z_spe_1[nstp_spe_1]=ntpStrip->z; stp_tpos_spe_1[nstp_spe_1]=ntpStrip->tpos; nstp_spe_1++; } else if(ntpStrip->ph0.pe+ntpStrip->ph1.pe<Dmid_val){ stp_z_mid_1[nstp_mid_1]=ntpStrip->z; stp_tpos_mid_1[nstp_mid_1]=ntpStrip->tpos; nstp_mid_1++; } else { stp_z_big_1[nstp_big_1]=ntpStrip->z; stp_tpos_big_1[nstp_big_1]=ntpStrip->tpos; nstp_big_1++; } } } if(!tz_stp_0 && nstp_big_0>0) { tz_stp_0 = new TMultiGraph(); tz_stp_0->SetName("tz_stp_0"); tz_stp_0->SetTitle("Transverse Position vs Z View"); } if(nstp_big_0>0){ TGraph *temp = new TGraph(nstp_big_0,stp_z_big_0,stp_tpos_big_0); temp->SetMarkerColor(1); temp->SetMarkerSize(1.1); temp->SetMarkerStyle(8); tz_stp_0->Add(temp); } if(!tz_stp_mid_0 && nstp_mid_0>0){ tz_stp_mid_0 = new TMultiGraph(); tz_stp_mid_0->SetName("tz_stp_mid_0"); tz_stp_mid_0->SetTitle("Transverse Position vs Z View"); } if(nstp_mid_0>0){ TGraph *temp = new TGraph(nstp_mid_0,stp_z_mid_0,stp_tpos_mid_0); temp->SetMarkerColor(4); temp->SetMarkerSize(1.1); temp->SetMarkerStyle(8); tz_stp_mid_0->Add(temp); } if(!tz_stp_spe_0 && nstp_spe_0>0){ tz_stp_spe_0 = new TMultiGraph(); tz_stp_spe_0->SetName("tz_stp_spe_0"); } if(nstp_spe_0>0){ TGraph *temp = new TGraph(nstp_spe_0,stp_z_spe_0,stp_tpos_spe_0); temp->SetMarkerColor(3); temp->SetMarkerSize(1.1); temp->SetMarkerStyle(8); tz_stp_spe_0->Add(temp); } if(!tz_stp_1 && nstp_big_1>0) { tz_stp_1 = new TMultiGraph(); tz_stp_1->SetName("tz_stp_1"); tz_stp_1->SetTitle("Transverse Position vs Z View"); } if(nstp_big_1>0){ TGraph *temp = new TGraph(nstp_big_1,stp_z_big_1,stp_tpos_big_1); temp->SetMarkerColor(1); temp->SetMarkerSize(1.1); temp->SetMarkerStyle(8); tz_stp_1->Add(temp); } if(!tz_stp_mid_1 && nstp_mid_1>0){ tz_stp_mid_1 = new TMultiGraph(); tz_stp_mid_1->SetName("tz_stp_mid_1"); tz_stp_mid_1->SetTitle("Transverse Position vs Z View"); } if(nstp_mid_1>0){ TGraph *temp = new TGraph(nstp_mid_1,stp_z_mid_1,stp_tpos_mid_1); temp->SetMarkerColor(4); temp->SetMarkerSize(1.1); temp->SetMarkerStyle(8); tz_stp_mid_1->Add(temp); } if(!tz_stp_spe_1 && nstp_spe_1>0){ tz_stp_spe_1 = new TMultiGraph(); tz_stp_spe_1->SetName("tz_stp_spe_1"); } if(nstp_spe_1>0){ TGraph *temp = new TGraph(nstp_spe_1,stp_z_spe_1,stp_tpos_spe_1); temp->SetMarkerColor(3); temp->SetMarkerSize(1.1); temp->SetMarkerStyle(8); tz_stp_spe_1->Add(temp); } delete [] stp_tpos_big_0; delete [] stp_tpos_mid_0; delete [] stp_tpos_spe_0; delete [] stp_z_big_0; delete [] stp_z_mid_0; delete [] stp_z_spe_0; delete [] stp_tpos_big_1; delete [] stp_tpos_mid_1; delete [] stp_tpos_spe_1; delete [] stp_z_big_1; delete [] stp_z_mid_1; delete [] stp_z_spe_1; if(lowest_plane-10>=0) { lowest_plane-=10; lowest_z-=10.*0.06; } else { lowest_plane=0; lowest_z=0.; } if(highest_plane+10<=485) { highest_plane+=10; highest_z+=10.*0.06; } else { highest_plane=485; highest_z=30.; } if(lowest_t0-5*0.041>=-4.0) lowest_t0-=5.*0.041; else lowest_t0=-4.0; if(lowest_t1-5*0.041>=-4.0) lowest_t1-=5.*0.041; else lowest_t1=-4.0; if(highest_t0+5*0.041<=4.0) highest_t0+=5.*0.041; else highest_t0=4.0; if(highest_t1+5*0.041<=4.0) highest_t1+=5.*0.041; else highest_t1=4.0; //Start making Reco plots for showers and tracks: //make sure there is a reconstructed event if(isReco&&eventSummary->nevent!=0){ //begin of reco code //Showers //make sure there is a shower if(ntpEvent->nshower>0){ //begin of shower code if(!tz_shw0) { tz_shw0 = new TMultiGraph(); tz_shw0->SetName("tz_shw0"); } if(!tz_shw1){ tz_shw1 = new TMultiGraph(); tz_shw1->SetName("tz_shw1"); } if(!xz_shw){ xz_shw = new TMultiGraph(); xz_shw->SetName("xz_shw"); } if(!yz_shw){ yz_shw = new TMultiGraph(); yz_shw->SetName("yz_shw"); } if(!yx_shw){ yx_shw = new TMultiGraph(); yx_shw->SetName("yx_shw"); } if(!ztime) { ztime = new TMultiGraph(); ztime->SetName("ztime"); ztime->SetTitle("Time vs Z view"); } if(!ytime){ ytime = new TMultiGraph(); ytime->SetName("ytime"); ytime->SetTitle("Time vs Y view"); } int *showers = ntpEvent->shw; int numshwstp=0; int numshwstp0=0; int numshwstp1=0; for(int i=0;i<ntpEvent->nshower;i++){ int index = showers[i]; LoadShower(index); numshwstp += ntpShower->nstrip; } float *shw_tpos = new float[numshwstp]; float *shw_tpos0 = new float[numshwstp]; float *shw_z0 = new float[numshwstp]; float *shw_tpos1 = new float[numshwstp]; float *shw_z1 = new float[numshwstp]; float *shwstpx = new float[numshwstp]; float *shwstpy = new float[numshwstp]; float *shwstpz = new float[numshwstp]; double *shw_time = new double[numshwstp]; double *shw_y = new double[numshwstp]; double *shw_z = new double[numshwstp]; int count = 0; int largest_shw_index=-1; int vtx_shw_index=-1; LoadShower_Jim(theEvent,vtx_shw_index,ntpHeader->GetVldContext().GetDetector()); LoadLargestShowerFromEvent(theEvent,largest_shw_index); /* { int track_index=-1; LoadLargestTrackFromEvent(theEvent,track_index); if(track_index>-1) LoadShowerAtTrackVertex(theEvent,track_index,vtx_shw_index); } */ for(int i=0;i<ntpEvent->nshower;i++){ int index1 = showers[i]; LoadShower(index1); Int_t *shwstrips = ntpShower->stp; count=0; numshwstp0=0; numshwstp1=0; for(int j=0;j<ntpShower->nstrip;j++){ Int_t index = shwstrips[j]; if(index==-1) {numshwstp=0; break;} //bug in old ntuple code ntpStrip = dynamic_cast<NtpSRStrip *>(stripArray[index]); shw_tpos[count] = ntpStrip->tpos; shw_z[count] = ntpStrip->z; if(ntpStrip->time0>0 && ntpStrip->time1>0) shw_time[count] = (ntpStrip->time0 + ntpStrip->time1)/2.; else if(ntpStrip->time0>0) shw_time[count] = ntpStrip->time0; else if(ntpStrip->time1>0) shw_time[count] = ntpStrip->time1; else shw_time[count] = 0; /* if(ntpStrip->time0>0 && ntpStrip->time1>0) shw_time[count] = (ntpShower->stpt0[j] + ntpShower->stpt1[j])/2.; else if(ntpStrip->time0>0) shw_time[count] = ntpShower->stpt0[j]; else if(ntpStrip->time1>0) shw_time[count] = ntpShower->stpt1[j]; else shw_time[count] = 0; } */ shw_time[count] -= eventSummary->trigtime; shw_time[count] *= 1e9; float shwstpu = 0; float shwstpv = 0; if(ntpStrip->planeview==2){ shw_tpos0[numshwstp0] = shw_tpos[count]; shw_z0[numshwstp0] = shw_z[count]; numshwstp0+=1; shwstpu = shw_tpos[count]; float grad = 0; if(ntpShower->vtx.dcosv!=0&&false) { grad = ntpShower->vtx.dcosz/ntpShower->vtx.dcosv; } shwstpv = ntpShower->vtx.v+(shw_z[count]-ntpShower->vtx.z)*grad; //shwstpv = ntpShower->stpv[j]; } else { shw_tpos1[numshwstp1] = shw_tpos[count]; shw_z1[numshwstp1] = shw_z[count]; numshwstp1+=1; shwstpv = shw_tpos[count]; float grad = 0; if(ntpShower->vtx.dcosu!=0&&false) { grad = ntpShower->vtx.dcosz/ntpShower->vtx.dcosu; } shwstpu = ntpShower->vtx.u+(shw_z[count]-ntpShower->vtx.z)*grad; //shwstpu = ntpShower->stpu[j]; } shwstpx[count] = (shwstpu-shwstpv)/sqrt(2.); shwstpy[count] = (shwstpu+shwstpv)/sqrt(2.); shwstpz[count] = shw_z[count]; shw_y[count] = shwstpy[count]; count++; } // largest ph shower will have color 5 by default // users can change this default via SetDefaultShowerMarkerColor() // others, a purplish-brown fDefaultShowerMarkerStyle=28; fDefaultShowerMarkerColor=6; int shw_marker_color=1; // vertex shower will have open circles, other open squares by default // users can change the default via SetDefaultShowerMarkerStyle() int shw_marker_style=25; if(largest_shw_index==index1) shw_marker_color = fDefaultShowerMarkerColor; if(vtx_shw_index==index1) shw_marker_style=fDefaultShowerMarkerStyle; if(numshwstp0>0){ TGraph *temp = new TGraph(numshwstp0,shw_z0,shw_tpos0); temp->SetMarkerColor(shw_marker_color); temp->SetMarkerSize(1.15); temp->SetMarkerStyle(shw_marker_style); tz_shw0->Add(temp); temp = new TGraph(1,&ntpShower->vtx.z,&ntpShower->vtx.u); temp->SetMarkerColor(shw_marker_color); temp->SetMarkerSize(1); temp->SetMarkerStyle(3); tz_shw0->Add(temp); } else { delete tz_shw0; tz_shw0 = NULL; } if(numshwstp1>0){ TGraph *temp = new TGraph(numshwstp1,shw_z1,shw_tpos1); temp->SetMarkerColor(shw_marker_color); temp->SetMarkerSize(1.15); temp->SetMarkerStyle(shw_marker_style); tz_shw1->Add(temp); temp = new TGraph(1,&ntpShower->vtx.z,&ntpShower->vtx.v); temp->SetMarkerColor(shw_marker_color); temp->SetMarkerSize(1); temp->SetMarkerStyle(3); tz_shw1->Add(temp); } else { delete tz_shw1; tz_shw1 = NULL; } if(count>0){ TGraph *temp = new TGraph(count,shwstpz,shwstpx); temp->SetMarkerColor(fDefaultShowerMarkerColor); temp->SetMarkerSize(0.6); temp->SetMarkerStyle(fDefaultShowerMarkerStyle); xz_shw->Add(temp); temp = new TGraph(count,shwstpz,shwstpy); temp->SetMarkerColor(fDefaultShowerMarkerColor); temp->SetMarkerSize(0.6); temp->SetMarkerStyle(fDefaultShowerMarkerStyle); yz_shw->Add(temp); temp = new TGraph(count,shwstpx,shwstpy); temp->SetMarkerColor(fDefaultShowerMarkerColor); temp->SetMarkerSize(0.6); temp->SetMarkerStyle(fDefaultShowerMarkerStyle); yx_shw->Add(temp); temp = new TGraph(count,shw_z,shw_time); temp->SetMarkerColor(fDefaultShowerMarkerColor); temp->SetMarkerSize(0.6); temp->SetMarkerStyle(fDefaultShowerMarkerStyle); ztime->Add(temp); temp = new TGraph(count,shw_y,shw_time); temp->SetMarkerColor(fDefaultShowerMarkerColor); temp->SetMarkerSize(0.6); temp->SetMarkerStyle(fDefaultShowerMarkerStyle); ytime->Add(temp); } } delete [] shw_tpos; delete [] shw_tpos0; delete [] shw_z0; delete [] shw_tpos1; delete [] shw_z1; delete [] shwstpx; delete [] shwstpy; delete [] shwstpz; delete [] shw_time; delete [] shw_y; delete [] shw_z; } //Clusters //make sure there is a cluster (by checking that there's a shower) if(LeClus&&ntpEvent->nshower>0){ //begin of cluster code if(!tz_clu0){ tz_clu0 = new TMultiGraph(); tz_clu0->SetName("tz_clu0"); } if(!tz_clu1){ tz_clu1 = new TMultiGraph(); tz_clu1->SetName("tz_clu1"); } if(!cluLeg0) cluLeg0 = new TLegend(0.85,0.7,0.98,0.98," Key: ID (P_{EM})"); if(!cluLeg1) cluLeg1 = new TLegend(0.85,0.7,0.98,0.98," Key: ID (P_{EM})"); int nUclus = 0; int col0 = 1; int nVclus = 0; int col1 = 1; int *showers = ntpEvent->shw; for(int i=0;i<ntpEvent->nshower;i++){ int index2 = showers[i]; LoadShower(index2); int *clusters = ntpShower->clu; int numclustp=0; int numclustp0=0; int numclustp1=0; for(int j=0;j<ntpShower->ncluster;j++){ int index1 = clusters[j]; if(LoadCluster(index1)) { numclustp+=ntpCluster->nstrip; if(ntpCluster->planeview==2) nUclus+=1; else if(ntpCluster->planeview==3) nVclus+=1; } } float *clu_tpos = new float[numclustp]; float *clu_tpos0 = new float[numclustp]; float *clu_z0 = new float[numclustp]; float *clu_tpos1 = new float[numclustp]; float *clu_z1 = new float[numclustp]; double *clu_z = new double[numclustp]; int count = 0; for(int j=0;j<ntpShower->ncluster;j++){ int index1 = clusters[j]; if(!LoadCluster(index1)) continue; Int_t *clustrips = ntpCluster->stp; count=0; numclustp0=0; numclustp1=0; for(int k=0;k<ntpCluster->nstrip;k++){ Int_t index = clustrips[k]; ntpStrip = dynamic_cast<NtpSRStrip *>(stripArray[index]); clu_tpos[count] = ntpStrip->tpos; clu_z[count] = ntpStrip->z; if(ntpStrip->planeview==2){ clu_tpos0[numclustp0] = clu_tpos[count]; clu_z0[numclustp0] = clu_z[count]; numclustp0+=1; } else { clu_tpos1[numclustp1] = clu_tpos[count]; clu_z1[numclustp1] = clu_z[count]; numclustp1+=1; } count++; } if(numclustp0>0){ TGraph *temp = new TGraph(numclustp0,clu_z0,clu_tpos0); if(col0==10) col0+=1; temp->SetMarkerColor(col0); temp->SetMarkerSize(0.6); temp->SetMarkerStyle(21); if(ntpCluster->id==2 || ntpCluster->id==4) temp->SetMarkerStyle(25); tz_clu0->Add(temp); col0+=1; char ssnom[256]; if(ntpCluster->id==0||ntpCluster->id==1){ sprintf(ssnom,"%s (%.2f)", ClusterType::AsString(ClusterType:: EClusterType(ntpCluster->id)), ntpCluster->probem); } else { sprintf(ssnom,"%s", ClusterType::AsString(ClusterType:: EClusterType(ntpCluster->id))); } cluLeg0->AddEntry(temp,ssnom,"p"); } if(numclustp1>0){ if(col1==10) col1+=1; TGraph *temp = new TGraph(numclustp1,clu_z1,clu_tpos1); temp->SetMarkerColor(col1); temp->SetMarkerSize(0.6); temp->SetMarkerStyle(21); if(ntpCluster->id==2 || ntpCluster->id==4) temp->SetMarkerStyle(25); tz_clu1->Add(temp); col1+=1; char ssnom[256]; if(ntpCluster->id==0||ntpCluster->id==1){ sprintf(ssnom,"%s (%.2f)", ClusterType::AsString(ClusterType:: EClusterType(ntpCluster->id)), ntpCluster->probem); } else { sprintf(ssnom,"%s", ClusterType::AsString(ClusterType:: EClusterType(ntpCluster->id))); } cluLeg1->AddEntry(temp,ssnom,"p"); } } delete [] clu_tpos; delete [] clu_z; delete [] clu_tpos0; delete [] clu_z0; delete [] clu_tpos1; delete [] clu_z1; } if(nUclus==0) { delete tz_clu0; tz_clu0=NULL; } if(nVclus==0) { delete tz_clu1; tz_clu1=NULL; } } if(isEM){ //make sure there is an EM chain //make sure there is a shower if(ntpEMSummary->nshower!=0){ if(!tz_emshw0){ tz_emshw0 = new TMultiGraph(); tz_emshw0->SetName("tz_emshw0"); } if(!tz_emshw1){ tz_emshw1 = new TMultiGraph(); tz_emshw1->SetName("tz_emshw1"); } int numemshwstp=0; int numemshwstp0=0; int numemshwstp1=0; for(int i=0;i<ntpEMSummary->nshower;i++){ LoadEMShower(i); numemshwstp += ntpEMShower->nstrip; } float *emshw_tpos = new float[numemshwstp]; float *emshw_z = new float[numemshwstp]; float *emshw_tpos0 = new float[numemshwstp]; float *emshw_z0 = new float[numemshwstp]; float *emshw_tpos1 = new float[numemshwstp]; float *emshw_z1 = new float[numemshwstp]; int count = 0; for(int i=0;i<ntpEMSummary->nshower;i++){ LoadEMShower(i); Int_t *emshwstrips = ntpEMShower->stp; count=0; numemshwstp0=0; numemshwstp1=0; for(int j=0;j<ntpEMShower->nstrip;j++){ Int_t index = emshwstrips[j]; ntpStrip = dynamic_cast<NtpSRStrip *>(stripArray[index]); emshw_tpos[count] = ntpStrip->tpos; emshw_z[count] = ntpStrip->z; if(ntpStrip->planeview==2){ emshw_tpos0[numemshwstp0] = emshw_tpos[count]; emshw_z0[numemshwstp0] = emshw_z[count]; numemshwstp0+=1; } else { emshw_tpos1[numemshwstp1] = emshw_tpos[count]; emshw_z1[numemshwstp1] = emshw_z[count]; numemshwstp1+=1; } count++; } if(numemshwstp0>0){ TGraph *temp = new TGraph(numemshwstp0,emshw_z0,emshw_tpos0); temp->SetMarkerColor(6); temp->SetMarkerSize(0.6); temp->SetMarkerStyle(28); tz_emshw0->Add(temp); } else { delete tz_emshw0; tz_emshw0 = NULL; } if(numemshwstp1>0){ TGraph *temp = new TGraph(numemshwstp1,emshw_z1,emshw_tpos1); temp->SetMarkerColor(6); temp->SetMarkerSize(0.6); temp->SetMarkerStyle(28); tz_emshw1->Add(temp); } else { delete tz_emshw1; tz_emshw1 = NULL; } } delete [] emshw_tpos; delete [] emshw_z; delete [] emshw_tpos0; delete [] emshw_z0; delete [] emshw_tpos1; delete [] emshw_z1; } } //Tracks if(ntpEvent->ntrack>0){ //begin of track code if(!tz_trk0){ tz_trk0 = new TMultiGraph(); tz_trk0->SetName("tz_trk0"); } if(!tz_trk1){ tz_trk1 = new TMultiGraph(); tz_trk1->SetName("tz_trk1"); } if(!xz_trk){ xz_trk = new TMultiGraph(); xz_trk->SetName("xz_trk"); } if(!yz_trk){ yz_trk = new TMultiGraph(); yz_trk->SetName("yz_trk"); } if(!yx_trk){ yx_trk = new TMultiGraph(); yx_trk->SetName("yx_trk"); } if(!ztime){ ztime = new TMultiGraph(); ztime->SetName("ztime"); ztime->SetTitle("Time vs Z view"); } if(!ytime){ ytime = new TMultiGraph(); ytime->SetName("ytime"); ytime->SetTitle("Time vs Y view"); } int *tracks = ntpEvent->trk; int totnumtrkstp = 0; int numtrkstpcnt = 0; int numtrkstp0 = 0; int numtrkstp1 = 0; for(int itrk=0;itrk<ntpEvent->ntrack;itrk++) { int index = tracks[itrk]; LoadTrack(index); totnumtrkstp += ntpTrack->nstrip; } //just in case there are no strips in the track if(totnumtrkstp!=0) { float *trk_tpos = new float[totnumtrkstp]; float *trk_tpos0 = new float[totnumtrkstp]; float *trk_tpos1 = new float[totnumtrkstp]; float *trkstpz0 = new float[totnumtrkstp]; float *trkstpz1 = new float[totnumtrkstp]; float *trkstpx = new float[totnumtrkstp]; float *trkstpy = new float[totnumtrkstp]; float *trkstpz = new float[totnumtrkstp]; int alpha = 0; double *trk_time = new double[totnumtrkstp*2]; double *trk_y = new double[totnumtrkstp*2]; double *trk_z = new double[totnumtrkstp*2]; for(int itrk=0;itrk<ntpEvent->ntrack;itrk++){ int index1 = tracks[itrk]; LoadTrack(index1); int numtrkstp = ntpTrack->nstrip; float *trk_stp_x = ntpTrack->stpx; float *trk_stp_y = ntpTrack->stpy; float *trk_stp_z = ntpTrack->stpz; double *trkstpt0 = ntpTrack->stpt0; double *trkstpt1 = ntpTrack->stpt1; int *trkstrips = ntpTrack->stp; numtrkstpcnt=0; numtrkstp0=0; numtrkstp1=0; alpha=0; for(int i=0;i<numtrkstp;i++){ int index = trkstrips[i]; ntpStrip = dynamic_cast<NtpSRStrip *>(stripArray[index]); trkstpx[numtrkstpcnt] = trk_stp_x[i]; trkstpy[numtrkstpcnt] = trk_stp_y[i]; trkstpz[numtrkstpcnt] = trk_stp_z[i]; trk_tpos[numtrkstpcnt] = ntpStrip->tpos; numtrkstpcnt++; if(ntpStrip->planeview==2){ trk_tpos0[numtrkstp0] = ntpStrip->tpos; trkstpz0[numtrkstp0] = trk_stp_z[i]; numtrkstp0+=1; } else { trk_tpos1[numtrkstp1] = ntpStrip->tpos; trkstpz1[numtrkstp1] = trk_stp_z[i]; numtrkstp1+=1; } } for(int i=0;i<numtrkstp;i++){ if(trkstpt0[i]!=-999999){ trk_time[alpha] = 1e9*(trkstpt0[i]-eventSummary->trigtime); trk_z[alpha] = trk_stp_z[i]; trk_y[alpha] = trk_stp_y[i]; alpha+=1; } if(trkstpt1[i]!=-999999){ trk_time[alpha] = 1e9*(trkstpt1[i]-eventSummary->trigtime); trk_z[alpha] = trk_stp_z[i]; trk_y[alpha] = trk_stp_y[i]; alpha+=1; } } TGraph *temp = 0; if(numtrkstp0>0){ temp = new TGraph(numtrkstp0,trkstpz0,trk_tpos0); temp->SetMarkerColor(2); temp->SetMarkerSize(0.6); temp->SetMarkerStyle(8); tz_trk0->Add(temp); temp = new TGraph(1,&ntpTrack->vtx.z,&ntpTrack->vtx.u); temp->SetMarkerColor(2); temp->SetMarkerSize(1); temp->SetMarkerStyle(29); tz_trk0->Add(temp); } else { delete tz_trk0; tz_trk0 = NULL; } if(numtrkstp1>0){ temp = new TGraph(numtrkstp1,trkstpz1,trk_tpos1); temp->SetMarkerColor(2); temp->SetMarkerSize(0.6); temp->SetMarkerStyle(8); tz_trk1->Add(temp); temp = new TGraph(1,&ntpTrack->vtx.z,&ntpTrack->vtx.v); temp->SetMarkerColor(2); temp->SetMarkerSize(1); temp->SetMarkerStyle(29); tz_trk1->Add(temp); } else { delete tz_trk1; tz_trk1 = NULL; } if(numtrkstpcnt>0){ temp = new TGraph(numtrkstpcnt,trkstpz,trkstpx); temp->SetMarkerColor(2); temp->SetMarkerSize(0.6); temp->SetMarkerStyle(8); xz_trk->Add(temp); temp = new TGraph(numtrkstpcnt,trkstpz,trkstpy); temp->SetMarkerColor(2); temp->SetMarkerSize(0.6); temp->SetMarkerStyle(8); yz_trk->Add(temp); temp = new TGraph(numtrkstpcnt,trkstpx,trkstpy); temp->SetMarkerColor(2); temp->SetMarkerSize(0.6); temp->SetMarkerStyle(8); yx_trk->Add(temp); } if(alpha>0){ temp = new TGraph(alpha,trk_z,trk_time); temp->SetMarkerColor(2); temp->SetMarkerSize(0.6); temp->SetMarkerStyle(8); ztime->Add(temp); temp = new TGraph(alpha,trk_y,trk_time); temp->SetMarkerColor(2); temp->SetMarkerSize(0.6); temp->SetMarkerStyle(8); ytime->Add(temp); } } delete [] trkstpx; delete [] trkstpy; delete [] trkstpz; delete [] trk_tpos; delete [] trk_tpos0; delete [] trk_tpos1; delete [] trkstpz0; delete [] trkstpz1; delete [] trk_time; delete [] trk_y; delete [] trk_z; } } } //end of reco code //Veto Shield if(!yx_veto) { yx_veto = new TMultiGraph(); yx_veto->SetName("yx_veto"); } if(!ytime_veto) { ytime_veto = new TMultiGraph(); ytime_veto->SetName("ytime_veto"); } if(shieldstripArray.GetEntries()!=0&&shieldSummary->ishit){ int nvetostp = shieldstripArray.GetEntries(); double *vetostp_x = new double[nvetostp]; double *vetostp_y = new double[nvetostp]; double *veto_y = new double[nvetostp*2]; double *veto_time = new double[nvetostp*2]; int beta = 0; for(int i=0;i<nvetostp;i++) { ntpShieldStrip = dynamic_cast<NtpSRShieldStrip *>(shieldstripArray[i]); vetostp_x[i] = ntpShieldStrip->x; vetostp_y[i] = ntpShieldStrip->y; veto_time[beta] = ntpShieldStrip->time[0]; veto_y[beta] = vetostp_y[i]; beta+=1; veto_time[beta] = ntpShieldStrip->time[1]; veto_y[beta] = vetostp_y[i]; beta+=1; } TGraph *temp1 = new TGraph(nvetostp,vetostp_x,vetostp_y); temp1->SetMarkerColor(7); temp1->SetMarkerSize(0.6); temp1->SetMarkerStyle(8); yx_veto->Add(temp1); TGraph *temp2 = new TGraph(beta,veto_y,veto_time); temp2->SetMarkerColor(7); temp2->SetMarkerSize(0.6); temp2->SetMarkerStyle(8); ytime_veto->Add(temp2); delete [] vetostp_x; delete [] vetostp_y; delete [] veto_time; delete [] veto_y; } else { delete yx_veto; yx_veto = NULL; delete ytime_veto; ytime_veto = NULL; } //Truth Angles if(false){ TArrow *tz_arrow1 = 0; // arrows to show direction of TArrow *tz_arrow2 = 0; // neutrino in tz view float nu_mu_angle = 0; // angle between nu and mu P3 vectors in rad float nu_el_angle = 0; // angle between nu and el P3 vectors in rad float zen_mu_angle = 0; // angle between mu and zenith P3 vectors in rad MainCanvas->cd(1); gPad->Clear(); if(isMC){ TVector3 *nuvec = new TVector3(ntpTruth->p4neunoosc[0], ntpTruth->p4neunoosc[1], ntpTruth->p4neunoosc[2]); TVector3 *muvec = new TVector3(ntpTruth->p4mu1[0], ntpTruth->p4mu1[1], ntpTruth->p4mu1[2]); TVector3 *elvec = new TVector3(ntpTruth->p4el1[0], ntpTruth->p4el1[1], ntpTruth->p4el1[2]); TVector3 *zenith = new TVector3(0,-1,0); nu_mu_angle = nuvec->Angle(*muvec); nu_el_angle = nuvec->Angle(*elvec); zen_mu_angle = muvec->Angle(*zenith); nuvec->RotateZ(-TMath::Pi()/4.); muvec->RotateZ(-TMath::Pi()/4.); TVector3 unitnu; if(ntpTruth->p4neu[3]<0.00001) unitnu = muvec->Unit(); else unitnu = nuvec->Unit(); float mc_vtxu = ntpTruth->vtxx/(sqrt(2.)) + ntpTruth->vtxy/(sqrt(2.)); float mc_vtxv = - ntpTruth->vtxx/(sqrt(2.)) + ntpTruth->vtxy/(sqrt(2.)); tz_arrow1 = new TArrow(ntpTruth->vtxz-unitnu.Z(), mc_vtxu-unitnu.X(), ntpTruth->vtxz,mc_vtxu,0.02,"|>"); tz_arrow1->SetFillColor(5); tz_arrow1->SetLineColor(9); tz_arrow1->SetLineWidth(2); tz_arrow2 = new TArrow(ntpTruth->vtxz-unitnu.Z(), mc_vtxv-unitnu.Y(), ntpTruth->vtxz,mc_vtxv,0.02,"|>"); tz_arrow2->SetFillColor(5); tz_arrow2->SetLineColor(9); tz_arrow2->SetLineWidth(2); delete nuvec; delete muvec; delete elvec; } //StdHep line drawing code from Tingjun: //stdhep vectors TLine** paru = 0; TLine** parv = 0; int nstdhep = 0; int *drawline = 0; if (isMC&&isTH){ TClonesArray* pointHepArray = NULL; if(isST) pointHepArray = (strecord->stdhep); else pointHepArray = (mcrecord->stdhep); TClonesArray& heparray = *pointHepArray; nstdhep = heparray.GetLast()+1; double *vtx_u = new double[nstdhep]; double *vtx_v = new double[nstdhep]; double *vtx_z = new double[nstdhep]; double *p_u = new double[nstdhep]; double *p_v = new double[nstdhep]; double *p_z = new double[nstdhep]; double *p_tot = new double[nstdhep]; double *k_u = new double[nstdhep]; double *k_v = new double[nstdhep]; double *epar = new double[nstdhep]; int *idhep = new int[nstdhep]; drawline = new int[nstdhep]; if(LoadTHEvent(theEvent)) { NtpMCStdHep* hep0 = dynamic_cast<NtpMCStdHep*>(heparray[ntpTHEvent->neustdhep]); int currentmc = hep0->mc; for (int istd = 0; istd < nstdhep; istd++){ NtpMCStdHep* hep = dynamic_cast<NtpMCStdHep*>(heparray[istd]); drawline[istd] = 0; vtx_u[istd] = (hep->vtx[0]+hep->vtx[1])*sqrt(2.)/2; vtx_v[istd] = (hep->vtx[1]-hep->vtx[0])*sqrt(2.)/2; vtx_z[istd] = hep->vtx[2]; p_u[istd] = (hep->p4[0]+hep->p4[1])*sqrt(2.)/2; p_v[istd] = (hep->p4[1]-hep->p4[0])*sqrt(2.)/2; p_z[istd] = hep->p4[2]; p_tot[istd] = sqrt(p_u[istd]*p_u[istd] + p_v[istd]*p_v[istd] + p_z[istd]*p_z[istd]); epar[istd] = hep->p4[3]; idhep[istd] = abs(hep->IdHEP); if (fabs(p_z[istd])>0.) { k_u[istd] = p_u[istd]/p_z[istd]; k_v[istd] = p_v[istd]/p_z[istd]; } bool drawphoton = false; if (abs(hep->IdHEP)==22){//photon NtpMCStdHep*hep_parent = dynamic_cast<NtpMCStdHep*>(heparray[hep->parent[0]]); if (abs(hep_parent->IdHEP)!=111) drawphoton = true; } //decide what to draw /* if((hep->mc==currentmc && hep->child[0]==-1 && hep->child[1]==-1 && abs(hep->IdHEP)<10000 && (abs(hep->IdHEP)==22 && drawphoton || abs(hep->IdHEP)!=22)) || (hep->mc==currentmc && abs(hep->IdHEP)==111)) drawline[istd]=1; if(p_tot[istd]<=0) drawline[istd]=0; */ if(hep->mc==currentmc){ hep->Print(); // draw all final state particles except photons from pi0 decay if(hep->IstHEP==1 && hep->IdHEP<10000){ // do not draw geantinos (probably made by intranuke) if(hep->IdHEP!=28) drawline[istd]=1; // if(hep->IdHEP!=22) drawline[istd]=1; // else if(drawphoton) drawline[istd]=1; } } } paru = new TLine*[nstdhep]; parv = new TLine*[nstdhep]; for (int istd = 0; istd < nstdhep; istd++){ if(p_tot[istd]==0)p_tot[istd]=0.001; if (drawline[istd] == 1){ paru[istd] = new TLine(vtx_z[istd],vtx_u[istd], vtx_z[istd] + (p_z[istd]/p_tot[istd])*epar[istd]/3, vtx_u[istd] + p_u[istd]/p_tot[istd]*epar[istd]/3); parv[istd] = new TLine(vtx_z[istd],vtx_v[istd], vtx_z[istd] + (p_z[istd]/p_tot[istd])*epar[istd]/3, vtx_v[istd] + p_v[istd]/p_tot[istd]*epar[istd]/3); if(idhep[istd] == 11) { //electron paru[istd]->SetLineColor(3); parv[istd]->SetLineColor(3); } else if(idhep[istd] == 13) {//muon paru[istd]->SetLineColor(4); parv[istd]->SetLineColor(4); } else if(idhep[istd] == 15) {//tau paru[istd]->SetLineColor(5); parv[istd]->SetLineColor(5); } else if(idhep[istd] == 211){//pion paru[istd]->SetLineColor(6); parv[istd]->SetLineColor(6); } else if(idhep[istd] == 2212){//proton paru[istd]->SetLineColor(2); parv[istd]->SetLineColor(2); } else if(idhep[istd] == 111) { //pi0 paru[istd]->SetLineColor(7); parv[istd]->SetLineColor(7); } else if(idhep[istd] == 22){ //photon paru[istd]->SetLineColor(9); parv[istd]->SetLineColor(9); } else if(idhep[istd] == 2112){//neutron paru[istd]->SetLineColor(28); parv[istd]->SetLineColor(28); } else if(idhep[istd] == 321 || idhep[istd] == 311 || idhep[istd] == 310 || idhep[istd] == 130){//kaon paru[istd]->SetLineColor(31); parv[istd]->SetLineColor(31); }//anything else will be black else if(idhep[istd] == 12 || idhep[istd] == 14 || idhep[istd] == 16){ //outgoing neutrino paru[istd]->SetLineStyle(2); //black, dashed line parv[istd]->SetLineStyle(2); } } } } delete[] vtx_u; delete[] vtx_v; delete[] vtx_z; delete[] p_u; delete[] p_v; delete[] p_z; delete[] p_tot; delete[] k_u; delete[] k_v; delete[] epar; delete[] idhep; } } //Text Box this->DrawTextBox(MainCanvas,isReco); //Start Drawing RecoCanvas->cd(1); gPad->Clear(); xz_place->Draw(); if(xz_trk) xz_trk->Draw("P"); if(xz_shw) xz_shw->Draw("P"); RecoCanvas->cd(4); gPad->Clear(); yz_place->Draw(); if(yz_trk) yz_trk->Draw("P"); if(yz_shw) yz_shw->Draw("P"); RecoCanvas->cd(2); gPad->Clear(); if(ntpHeader->GetVldContext().GetDetector()==Detector::kNear){ yx_place->GetXaxis()->SetRangeUser(-2.6,3.8); yx_place->GetYaxis()->SetRangeUser(-3.2,3.2); } else { yx_place->GetXaxis()->UnZoom(); yx_place->GetYaxis()->UnZoom(); } yx_place->Draw(); if(yx_trk) yx_trk->Draw("P"); if(yx_shw) yx_shw->Draw("P"); if(yx_veto) yx_veto->Draw("P"); // mike: draw plane outlines here line->Draw(); if(ntpHeader->GetVldContext().GetDetector()==Detector::kNear){ fu1_outline->Draw(); fu2_outline->Draw(); fv1_outline->Draw(); fv2_outline->Draw(); pu1_outline->Draw(); // pu2_outline->Draw(); pv1_outline->Draw(); // pv2_outline->Draw(); if(ntpHeader->GetVldContext().GetDetector()==Detector::kNear){ nd_xy_fid->Draw(); } if (ntpHeader->GetVldContext().GetDetector()==Detector::kFar){ fd_xy_fid->Draw(); } } if(ntpHeader->GetVldContext().GetDetector()==Detector::kFar) ellie->Draw(); RecoCanvas->cd(3); TVirtualPad *RecoCanvas_3 = RecoCanvas->GetPad(3); RecoCanvas_3->Clear(); tz_place_0->SetAxisRange(lowest_z,highest_z,"X"); tz_place_0->SetAxisRange(lowest_t0,highest_t0,"Y"); if(fAltDisplay){ tz_place_0->Draw(tz_place_dopt.c_str()); if(tz_stp_0) tz_stp_0->Draw("P"); if(tz_stp_mid_0) tz_stp_mid_0->Draw("P"); if(tz_stp_spe_0) tz_stp_spe_0->Draw("P"); if(tz_trk0) tz_trk0->Draw("P"); if(tz_shw0) tz_shw0->Draw("P"); if(tz_emshw0) tz_emshw0->Draw("P"); } else{ tz_missplace_0->SetAxisRange(lowest_missz,highest_missz,"X"); tz_missplace_0->SetAxisRange(lowest_misst0,highest_misst0,"Y"); tz_missplace_0->Draw(tz_place_dopt.c_str()); if(tz_missstp_0) tz_missstp_0->Draw("P"); } RecoCanvas_3->Update(); RecoCanvas_3->Modified(); RecoCanvas->cd(5); TVirtualPad *RecoCanvas_5 = RecoCanvas->GetPad(5); RecoCanvas_5->cd(1); gPad->Clear(); if(ytime){ ytime->Draw("AP"); ytime->GetXaxis()->SetTitle("y position (m)"); ytime->GetYaxis()->SetTitle("time (ns)"); if(ytime_veto) ytime_veto->Draw("P"); } gPad->Update(); gPad->Modified(); RecoCanvas_5->cd(2); gPad->Clear(); if(ztime) { ztime->Draw("AP"); ztime->GetXaxis()->SetTitle("z position (m)"); ztime->GetYaxis()->SetTitle("time (ns)"); } gPad->Update(); gPad->Modified(); RecoCanvas->cd(6); gPad->Clear(); tz_place_1->SetAxisRange(lowest_z,highest_z,"X"); tz_place_1->SetAxisRange(lowest_t1,highest_t1,"Y"); if(fAltDisplay){ tz_place_1->Draw(tz_place_dopt.c_str()); if(tz_stp_1) tz_stp_1->Draw("P"); if(tz_stp_mid_1) tz_stp_mid_1->Draw("P"); if(tz_stp_spe_1) tz_stp_spe_1->Draw("P"); if(tz_trk1) tz_trk1->Draw("P"); if(tz_shw1) tz_shw1->Draw("P"); if(tz_emshw1) tz_emshw1->Draw("P"); } else{ tz_missplace_1->SetAxisRange(lowest_missz,highest_missz,"X"); tz_missplace_1->SetAxisRange(lowest_misst0,highest_misst0,"Y"); tz_missplace_1->Draw(tz_place_dopt.c_str()); if(tz_missstp_1) tz_missstp_1->Draw("P"); } gPad->Update(); gPad->Modified(); MainCanvas->cd(3); gPad->Clear(); if(fAltDisplay){ tz_missplace_0->SetAxisRange(lowest_missz,highest_missz,"X"); tz_missplace_0->SetAxisRange(lowest_misst0,highest_misst0,"Y"); tz_missplace_0->Draw(tz_place_dopt.c_str()); if(tz_missstp_0) tz_missstp_0->Draw("P"); } else{ tz_place_0->Draw(tz_place_dopt.c_str()); if(ntpHeader->GetVldContext().GetDetector()==Detector::kNear){ nd_uz_fid->Draw(); } if (ntpHeader->GetVldContext().GetDetector()==Detector::kFar){ fd_uz_fid1->Draw(); fd_uz_fid2->Draw(); } if(nstp_big_0>0) tz_stp_0->Draw("P"); if(nstp_mid_0>0) tz_stp_mid_0->Draw("P"); if(nstp_spe_0>0) tz_stp_spe_0->Draw("P"); if(tz_trk0) tz_trk0->Draw("P"); if(tz_shw0) tz_shw0->Draw("P"); if(tz_emshw0) tz_emshw0->Draw("P"); } /* if(isMC) { tz_arrow1->Draw(); if(isTH){ for (int istd = 0; istd < nstdhep; istd++){ if (drawline[istd] == 1 && paru[istd]!=0 ) paru[istd]->Draw("same"); } } } */ gPad->Modified(); gPad->Update(); MainCanvas->cd(4); gPad->Clear(); if(fAltDisplay){ tz_missplace_1->SetAxisRange(lowest_missz,highest_missz,"X"); tz_missplace_1->SetAxisRange(lowest_misst0,highest_misst0,"Y"); tz_missplace_1->Draw(tz_place_dopt.c_str()); if(tz_missstp_1) tz_missstp_1->Draw("P"); } else{ tz_place_1->Draw(tz_place_dopt.c_str()); if(ntpHeader->GetVldContext().GetDetector()==Detector::kNear){ nd_vz_fid->Draw(); } if (ntpHeader->GetVldContext().GetDetector()==Detector::kFar){ fd_vz_fid1->Draw(); fd_vz_fid2->Draw(); } if(nstp_big_1>0) tz_stp_1->Draw("P"); if(nstp_mid_1>0) tz_stp_mid_1->Draw("P"); if(nstp_spe_1>0) tz_stp_spe_1->Draw("P"); if(tz_trk1) tz_trk1->Draw("P"); if(tz_shw1) tz_shw1->Draw("P"); if(tz_emshw1) tz_emshw1->Draw("P"); } /* if(isMC) { tz_arrow2->Draw(); if(isTH){ for (int istd = 0; istd < nstdhep; istd++){ if (drawline[istd] == 1 && parv[istd] ) parv[istd]->Draw("same"); } } } */ if(LeLego) { tz_0_lego->SetAxisRange(lowest_plane,highest_plane,"X"); tz_1_lego->SetAxisRange(lowest_plane,highest_plane,"X"); tz_0_lego->SetAxisRange(lowest_t0,highest_t0,"Y"); tz_1_lego->SetAxisRange(lowest_t1,highest_t1,"Y"); LegoCanvas->cd(1); tz_0_lego->Draw("LEGO2"); gPad->Update(); gPad->Modified(); LegoCanvas->cd(2); tz_1_lego->Draw("LEGO2"); gPad->Update(); gPad->Modified(); } if(LeClus){ ClusterCanvas->cd(1); gPad->Clear(); if(tz_clu0) { if(tz_clu0->Sizeof()>0){ tz_place_0->Draw(tz_place_dopt.c_str()); tz_clu0->Draw("P"); if(cluLeg0) cluLeg0->Draw(); if(isMC) { //tz_arrow1->Draw(); if(isTH){ // for (int istd = 0; istd < nstdhep; istd++){ // if (drawline[istd] == 1 && paru[istd]) paru[istd]->Draw("same"); // } } } } } gPad->Update(); gPad->Modified(); ClusterCanvas->cd(2); gPad->Clear(); if(tz_clu1) { if(tz_clu1->Sizeof()>0){ tz_place_1->Draw(tz_place_dopt.c_str()); tz_clu1->Draw("P"); if(cluLeg1) cluLeg1->Draw(); if(isMC) { //tz_arrow2->Draw(); if(isTH){ // for (int istd = 0; istd < nstdhep; istd++){ // if (drawline[istd] == 1 && parv[istd]) parv[istd]->Draw("same"); // } } } } } gPad->Update(); gPad->Modified(); } //delete stdhep // if (isMC&&isTH) delete[] drawline; //Print To Terminal if(ptt_msg) { // float Sum_mcA = 0; // float Sum_mcB = 0; //for(int i=0;i<500;i++){ // for(int j=0;j<192;j++){ // if(ATH_mcA[i][j]>0||ATH_mcB[i][j]>0) { // Sum_mcA+=ATH_mcA[i][j]; // Sum_mcB+=ATH_mcB[i][j]; // } // } //} std::cout << "Run: " << ntpHeader->GetRun() << " Snarl: " << ntpHeader->GetSnarl() << " (entry: " << entry << ")" << std::endl; std::cout << "-----------------------------------" << std::endl; // std::cout << "Truth:" << std::endl; // std::cout << "\tSummed PEs=" << Sum_mcA+Sum_mcB << "\tSummed PEs/0.6=" // << (Sum_mcA+Sum_mcB)/0.6 << std::endl; std::cout << "-----------------------------------" << std::endl; std::cout << "Reco:" << std::endl; std::cout << "\tNumber of slices\t"<< eventSummary->nslice << std::endl; std::cout << "\tSummed Raw Charge in Snarl (Current Slice) " << eventSummary->ph.raw << " (" << ntpSlice->ph.raw << ")" << std::endl; std::cout << "\tSummed PEs in Snarl (Current Slice) " << eventSummary->ph.pe << " (" << ntpSlice->ph.pe << ")" << std::endl; std::cout << "\tNumber of Reco Digits in Slice = " << ntpSlice->ndigit << " Strips = " << (nstp_spe_0+nstp_spe_1+nstp_mid_0+nstp_mid_1+nstp_big_0 +nstp_big_1) << std::endl; std::cout << "===================================" << std::endl; } MainCanvas->cd(2); //change to pad with controls // JM add update scan page SFrame->SetRun(ntpHeader->GetRun()); SFrame->SetSnarl(ntpHeader->GetSnarl()); SFrame->SetSlice(theSlice); SFrame->SetEvent(theEvent); int shower_index ; int track_index; if(ntpEvent){ if(ntpEvent->ntrack>0){ LoadLargestTrackFromEvent(theEvent,track_index); if(ntpTrack->momentum.qp!=0) SFrame->PassFloat("Curv",1./ntpTrack->momentum.qp); SFrame->PassFloat("Range",ntpTrack->momentum.range); SFrame->PassInt("TrackContained",ntpTrack->contained); } else{ SFrame->PassFloat("Range",0); SFrame->PassFloat("Curv",0); SFrame->PassInt("TrackContained",0); } if(ntpEvent->nshower>0){ const Detector::Detector_t det = ntpHeader->GetVldContext().GetDetector(); bool OK =LoadShower_Jim(theEvent,shower_index,det); float cor_shw_energy = 0; if(OK) cor_shw_energy = CorrectShowerEnergy(ntpShower->shwph.linCCgev, det,CandShowerHandle::kCC); SFrame->PassFloat("ShwE",cor_shw_energy); } else{ SFrame->PassFloat("ShwE",0); } SFrame->ResetDisplay("noPH"); // ROICalc(); MadAbID pid; bool pass = pid.GetPass(ntpEvent,strecord); SFrame->PassInt("Passed",pass); } // // RBP -- for zooming capabilites, we will want the TGraphs and TMultiGraphs // to be non-editable. (No need to edit them anyway, I'd think.) MakeGraphListNonEditable(MainCanvas->GetPad(3)->GetListOfPrimitives()); MakeGraphListNonEditable(MainCanvas->GetPad(4)->GetListOfPrimitives()); return true; }

void MadScanDisplay::DrawButtons (  TCanvas *   )

Definition at line 4316 of file MadScanDisplay.cxx. References DrawKey2(), LeAction, LeNu, and StartLogger(). Referenced by Display(). { MainCanvas->cd(2); TVirtualPad *MainCanvas_2 = MainCanvas->GetPad(2); MainCanvas_2->Range(0,0,1,1); if(!gROOT->IsBatch()){ //if we are not in batch mode, draw controls. //otherwise let the Key fill up MainCanvas_2 //Next/Prev event with cuts TButton *but1 = new TButton("Next Fid Trk","if(EVD->drawSAME) {EVD->drawSAME=false; but4b->SetFillColor(2); but4b->Modified();} ; EVD->fAltDisplay=false; EVD->LeEntry = EVD->NextFidTrk();",0.6,0.9,1,1); but1->SetTextSize(0.5); but1->SetFillColor(4); TButton *but2 = new TButton("Nxt Fid No Trk","if(EVD->drawSAME) {EVD->drawSAME=false; but4b->SetFillColor(2); but4b->Modified();}; EVD->fAltDisplay=false; EVD->LeEntry = EVD->NextFidNoTrk();",0.2,0.9,0.6,1); but2->SetTextSize(0.5); but2->SetFillColor(5); //Next/Prev event of any kind 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->FindUnSliced(); EVD->fAltDisplay=true; EVD->Display(EVD->LeEntry,0,0,0,EVD->LeAutoMat);",0.6,0.8,1,0.9); but14->SetTextSize(0.5); but14->SetFillColor(4); 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->FindUnSliced(); EVD->fAltDisplay=true; EVD->Display(EVD->LeEntry,0,0,0,EVD->LeAutoMat);",0.2,0.8,0.6,0.9); but15->SetTextSize(0.5); but15->SetFillColor(5); TButton *but10 = new TButton("Next Slc","if(EVD->drawSAME) {EVD->drawSAME=false; } EVD->LeEntry = EVD->NextPass();",0.4,0.7,0.6,0.8); but10->SetName("but10"); but10->SetTextSize(0.5); but10->SetFillColor(4); TButton *but12 = new TButton("Prev Slc","if(EVD->drawSAME) {EVD->drawSAME=false; } EVD->LeEntry = EVD->PrevPass();",0.2,0.7,0.4,0.8); but12->SetName("but12"); but12->SetTextSize(0.5); but12->SetFillColor(5); TButton *but11 = new TButton("Next Evt","if (EVD->drawSAME) {EVD->drawSAME=false; } EVD->LeEntry = EVD->NextEvt();",0.8,0.7,1,0.8); but11->SetName("but11"); but11->SetTextSize(0.5); but11->SetFillColor(4); TButton *but13 = new TButton("Prev Evt","if (EVD->drawSAME) {EVD->drawSAME=false; } EVD->LeEntry = EVD->PrevEvt();",0.6,0.7,0.8,0.8); but13->SetName("but13"); but13->SetTextSize(0.5); but13->SetFillColor(5); //Skip to, +/- MC TButton *but16 = new TButton("Prev MC","EVD->LeMCevent-=1; fAltDisplay-false; EVD->Display(EVD->LeEntry,EVD->LeSlice,EVD->LeEvent,EVD->LeMCevent,EVD->LeAutoMat);",0.2,0.6,0.4,0.7); but16->SetName("but16"); but16->SetTextSize(0.5); but16->SetFillColor(5); TButton *but17 = new TButton("Next MC","EVD->LeMCevent+=1; fAltDisplay=false; EVD->Display(EVD->LeEntry,EVD->LeSlice,EVD->LeEvent,EVD->LeMCevent,EVD->LeAutoMat);",0.4,0.6,0.6,0.7); but17->SetName("but17"); but17->SetTextSize(0.5); but17->SetFillColor(4); TButton *but3a = new TButton("Skip to...","if(EVD->drawSAME) {EVD->drawSAME=false; but4b->SetFillColor(2); but4b->Modified();} EVD->LeSlice=0; EVD->LeEvent=0; fAltDisplay=false; EVD->LeMCevent=0; EVD->LeEntry = EVD->SkipTo();",0.6,0.65,0.8,0.7); but3a->SetTextSize(0.5); but3a->SetFillColor(9); TButton *but3e = new TButton("Run,Snarl...","if(EVD->drawSAME) {EVD->drawSAME=false; but4b->SetFillColor(2); but4b->Modified();} EVD->LeSlice=0; EVD->LeEvent=0; fAltDisplay=false; EVD->LeMCevent=0; EVD->LeEntry = EVD->JumpTo();",0.6,0.6,0.8,0.65); but3e->SetTextSize(0.5); but3e->SetFillColor(9); 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); but3c->SetName("but3c"); but3c->SetTextSize(0.5); but3c->SetFillColor(3); if(LeAutoMat) { but10->SetFillColor(15); but12->SetFillColor(15); but16->SetFillColor(15); but17->SetFillColor(15); } //Refresh/Lego/Quit/Print 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); but4->SetTextSize(0.5); but4->SetFillColor(6); 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); but4b->SetName("but4b"); but4b->SetTextSize(0.5); if(drawSAME) but4b->SetFillColor(3); else but4b->SetFillColor(2); 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); but3b->SetName("but3b"); but3b->SetTextSize(0.5); if(LeLego) but3b->SetFillColor(3); else but3b->SetFillColor(2); 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); but3d->SetName("but3d"); but3d->SetTextSize(0.5); if(LeClus) but3d->SetFillColor(3); else but3d->SetFillColor(2); TButton *but18 = new TButton("Print","EVD->PrintDisplay();", 0.6,0.5,0.8,0.6); but18->SetTextSize(0.5); but18->SetFillColor(8); TButton *but5 = new TButton("Quit",".q",0.8,0.5,1,0.6); but5->SetTextSize(0.5); but5->SetFillColor(45); but1->Draw(); but2->Draw(); but3a->Draw(); but3b->Draw(); but3c->Draw(); but3d->Draw(); but3e->Draw(); but4->Draw(); but4b->Draw(); but5->Draw(); but10->Draw(); but11->Draw(); but12->Draw(); but13->Draw(); but14->Draw(); but15->Draw(); but16->Draw(); but17->Draw(); but18->Draw(); if(!handScan) { //Buttons to select out numu/nue/NC/CC TButton *but19 = new TButton(" Missed PH","EVD->ROICalc();",0,0.9,0.195,1); but19->SetTextSize(0.4); but19->SetName("but19"); TButton *but6 = new TButton("Extra PH","EVD->ShwROICalc()",0,0.8,0.195,0.9); but6->SetTextSize(0.4); but6->SetName("but6"); 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); but7->SetTextSize(0.4); but7->SetName("but7"); 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); but8->SetTextSize(0.4); but8->SetName("but8"); 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); but9->SetTextSize(0.4); but9->SetName("but9"); if(UseNuInfo){ if(LeNu==14) {but6->SetFillColor(3); but7->SetFillColor(2);} else if(LeNu==12) {but7->SetFillColor(3); but6->SetFillColor(2);} else {but6->SetFillColor(10); but7->SetFillColor(10);} if(LeAction==0) {but8->SetFillColor(3); but9->SetFillColor(2);} else if(LeAction==1) {but9->SetFillColor(3); but8->SetFillColor(2);} else {but9->SetFillColor(10); but8->SetFillColor(10);} } else { but19->SetFillColor(3); but6->SetFillColor(15); but7->SetFillColor(15); but8->SetFillColor(15); but9->SetFillColor(15); } but6->Draw(); but7->Draw(); but8->Draw(); but9->Draw(); but19->Draw(); } else StartLogger(); } //else MainCanvas_2->Range(0,0,0.5,0.5); this->DrawKey2(MainCanvas_2); }

void MadScanDisplay::DrawInteractionDiagram (  Int_t  itr = 0  )

Definition at line 4045 of file MadScanDisplay.cxx. References abs(), NtpMCStdHep::IdHEP, NtpMCStdHep::IstHEP, MadBase::LoadStdHep(), MadBase::LoadTruth(), NtpMCStdHep::mc, NtpMCStdHep::p4, NtpMCStdHep::parent, NtpMCRecord::stdhep, and NtpStRecord::stdhep. { if(!LoadTruth(itr)) return; //make sure there is a canvas for my art TCanvas *can; if(gROOT->FindObject("StdHepDiagramCanvas")) { can = (TCanvas*) gROOT->FindObject("StdHepDiagramCanvas"); can->cd(); TList *theList = can->GetListOfPrimitives(); TIterator *iter = theList->MakeIterator(); TObject *ob; while((ob = iter->Next())){ if(ob->InheritsFrom("TLatex")) { TLatex *tex = (TLatex*) ob; delete tex; } else if(ob->InheritsFrom("TArrow")) { TArrow *ar = (TArrow*) ob; delete ar; } else if(ob->InheritsFrom("TMarker")) { TMarker *m = (TMarker*) ob; delete m; } } can->Range(0,0,1,1.1); } else { can = new TCanvas("StdHepDiagramCanvas","StdHep Diagram Canvas",0,0,900,400); can->cd(); can->Range(0,0,1,1.1); TPaveText *infoTex1 = new TPaveText(0.05,1.,0.2,1.07); infoTex1->AddText("Initial State"); infoTex1->SetBorderSize(1); TPaveText *infoTex2 = new TPaveText(0.3,1.,0.45,1.07); infoTex2->AddText("Intermediate"); infoTex2->SetBorderSize(1); TPaveText *infoTex3 = new TPaveText(0.55,1.,0.7,1.07); infoTex3->AddText("Final State"); infoTex3->SetBorderSize(1); TPaveText *infoTex4 = new TPaveText(0.8,1.,0.95,1.07); infoTex4->AddText("Later Decays"); infoTex4->SetBorderSize(1); infoTex1->SetTextSize(0.05); infoTex1->SetTextFont(12); infoTex1->SetTextColor(1); infoTex2->SetTextSize(0.05); infoTex2->SetTextFont(12); infoTex2->SetTextColor(1); infoTex3->SetTextSize(0.05); infoTex3->SetTextFont(12); infoTex3->SetTextColor(1); infoTex4->SetTextSize(0.05); infoTex4->SetTextFont(12); infoTex4->SetTextColor(1); infoTex1->SetName("infoTex1"); infoTex2->SetName("infoTex2"); infoTex3->SetName("infoTex3"); infoTex4->SetName("infoTex4"); infoTex1->Draw(); infoTex2->Draw(); infoTex3->Draw(); infoTex4->Draw(); } //First get indices to use: TClonesArray* pointStdhepArray = NULL; if(isST) pointStdhepArray = (strecord->stdhep); else pointStdhepArray = (mcrecord->stdhep); TClonesArray& stdhepArray = *pointStdhepArray; Int_t nStdHep = stdhepArray.GetEntries(); Int_t *indicesToUse = new Int_t[nStdHep]; Int_t *parent = new Int_t[nStdHep]; Int_t incomingNeutrino = -1; Int_t cnt = 0; for(int i=0;i<nStdHep;i++){ LoadStdHep(i); if(ntpStdHep->mc==itr) { indicesToUse[cnt] = i; parent[i] = ntpStdHep->parent[0]; if(ntpStdHep->IstHEP==0){ if(abs(ntpStdHep->IdHEP)==12||abs(ntpStdHep->IdHEP)==14 ||abs(ntpStdHep->IdHEP)==16) { incomingNeutrino=i; } parent[i] = -1; //don't draw arrows to initial state particles } cnt++; } else parent[i] = -1; } //make arrows and markers // TArrow *arrow[1000]; // TMarker *marker[1000]; // it is possible to have more than 1000 stdhep particles // yikes... // I think that these objects are deleted in the block at // the start of this routine. std::vector<TArrow*> arrow(nStdHep); std::vector<TMarker*> marker(nStdHep); for(int i=0;i<nStdHep;i++) { arrow[i] = new TArrow(0,0,0,0,0.03,"|>"); arrow[i]->SetLineWidth(1); arrow[i]->SetLineStyle(3); arrow[i]->SetFillColor(39); arrow[i]->SetLineColor(39); marker[i] = new TMarker(0,0,24); marker[i]->SetMarkerSize(1); marker[i]->SetMarkerColor(38); } //now loop through valid stdhep entries and fill variables Float_t Available[4] = {0.9,0.7,0.9,0.7}; for(int i=0;i<cnt;i++){ int toUse = indicesToUse[i]; LoadStdHep(toUse); if(ntpStdHep->IstHEP==999) continue; Float_t mom = sqrt(ntpStdHep->p4[0]*ntpStdHep->p4[0] + ntpStdHep->p4[1]*ntpStdHep->p4[1] + ntpStdHep->p4[2]*ntpStdHep->p4[2]); float x=0.,y=0.; int col=0; char text[256]; //set x,y if(ntpStdHep->IstHEP==0) { x = 0.05; y=Available[0]; Available[0] -= 0.1; } else if(ntpStdHep->IstHEP==11) { x = 0.05; y=Available[0]; Available[0] -= 0.1; } else if(ntpStdHep->IstHEP==3 || ntpStdHep->IstHEP==14) { x = 0.3; y=Available[1]; Available[1] -= 0.1; } else if(ntpStdHep->IstHEP==1){ x = 0.55; y=Available[2]; Available[2] -= 0.1; } else if(ntpStdHep->IstHEP==205){ x = 0.8; y=Available[3]; Available[3] -= 0.1; } //set colour and label (and override y in special cases) if(abs(ntpStdHep->IdHEP)==12) { //nue y = 0.9; sprintf(text,"#nu_{e}"); col = 3; if(ntpStdHep->IdHEP<0) sprintf(text,"#bar{#nu}_{e}"); } else if(abs(ntpStdHep->IdHEP)==14) { //numu y = 0.9; sprintf(text,"#nu_{#mu}"); col = 4; if(ntpStdHep->IdHEP<0) sprintf(text,"#bar{#nu}_{#mu}"); } else if(abs(ntpStdHep->IdHEP)==16) { //nutau y = 0.9; sprintf(text,"#nu_{#tau}"); col = 5; if(ntpStdHep->IdHEP<0) sprintf(text,"#bar{#nu}_{#tau}"); } else if(abs(ntpStdHep->IdHEP)==11) { //e if(parent[toUse]==incomingNeutrino) y = 0.9; sprintf(text,"e^{-}"); col = 3; if(ntpStdHep->IdHEP<0) sprintf(text,"e^{+}"); } else if(abs(ntpStdHep->IdHEP)==13) { //mu if(parent[toUse]==incomingNeutrino) y = 0.9; sprintf(text,"#mu^{-}"); col = 4; if(ntpStdHep->IdHEP<0) sprintf(text,"#mu^{+}"); } else if(abs(ntpStdHep->IdHEP)==15) { //tau if(parent[toUse]==incomingNeutrino) y = 0.9; sprintf(text,"#tau^{-}"); col = 5; if(ntpStdHep->IdHEP<0) sprintf(text,"#tau^{+}"); } else if(ntpStdHep->IdHEP==22) { //photon sprintf(text,"#gamma"); col = 9; } else if(ntpStdHep->IdHEP>1000000000) { //nucleus y = 0.8; sprintf(text,"nucleus(%i,%i)",int((ntpStdHep->IdHEP-1e9)/1e6), int((ntpStdHep->IdHEP-1e9 - 1e6*int((ntpStdHep->IdHEP-1e9) /1e6))/1e3)); col = 15; } else if(ntpStdHep->IdHEP==2112){ sprintf(text,"neutron"); col = 28; } else if(ntpStdHep->IdHEP==2212){ sprintf(text,"proton"); col = 2; } else if(abs(ntpStdHep->IdHEP)==211) { sprintf(text,"#pi^{+}"); col = 6; if(ntpStdHep->IdHEP<0) sprintf(text,"#pi^{-}"); } else if(ntpStdHep->IdHEP==111) { sprintf(text,"#pi^{0}"); col = 7; } else if(ntpStdHep->IdHEP==130) { sprintf(text,"K^{0}_{L}"); col = 31; } else if(ntpStdHep->IdHEP==310) { sprintf(text,"K^{0}_{S}"); col = 31; } else if(ntpStdHep->IdHEP==311) { sprintf(text,"K^{0}"); col = 31; } else if(abs(ntpStdHep->IdHEP)==321) { sprintf(text,"K^{+}"); col = 31; if(ntpStdHep->IdHEP<0) sprintf(text,"K^{-}"); col = 31; } else if(ntpStdHep->IdHEP==28) { sprintf(text,"Geantino"); col = 46; if(ntpStdHep->IdHEP<0) sprintf(text,"K^{-}"); col = 31; } else { sprintf(text,"ID: %i",ntpStdHep->IdHEP); col=43; } sprintf(text,"%s [%.1f GeV/c]",text,mom); arrow[toUse]->SetX2(x-0.02); arrow[toUse]->SetY2(y-0.02); marker[toUse]->SetX(x-0.02); marker[toUse]->SetY(y-0.02); for(int j=0;j<nStdHep;j++){ if(parent[j]==toUse){ arrow[j]->SetX1(x-0.02); arrow[j]->SetY1(y-0.02); } } TLatex *tex = new TLatex(x,y,text); char texname[256]; sprintf(texname,"tex%i",i); tex->SetName(texname); tex->SetTextSize(0.05); tex->SetTextColor(col); tex->Draw(); } for(int i=0;i<nStdHep;i++){ if(parent[i]==-1) { delete arrow[i]; delete marker[i]; } else { arrow[i]->Draw(); marker[i]->Draw(); } } Float_t minAvail = 0; for(int i=0;i<4;i++){ if(Available[i]<minAvail) minAvail = Available[i]; } if(minAvail<0) can->Range(0,minAvail,1,1.1); delete [] indicesToUse; delete [] parent; can->Modified(); can->Update(); }

void MadScanDisplay::DrawKey (  TVirtualPad *   )  [protected]

Definition at line 3876 of file MadScanDisplay.cxx. References Dmid_val, and Dspe_val. { KeyPad->cd(2); TPave *pave = new TPave(0.02,0.02,0.98,0.48); pave->Draw(); TMarker *marker = new TMarker(0.2,0.89/2.,8); marker->SetMarkerColor(3); marker->SetMarkerStyle(8); marker->SetMarkerSize(1.3); marker->Draw(); marker = new TMarker(0.2,0.80/2.,8); marker->SetMarkerColor(4); marker->SetMarkerStyle(8); marker->SetMarkerSize(1.3); marker->Draw(); marker = new TMarker(0.2,0.71/2.,8); marker->SetMarkerStyle(8); marker->SetMarkerSize(1.3); marker->Draw(); marker = new TMarker(0.2,0.62/2.,8); marker->SetMarkerColor(2); marker->SetMarkerStyle(8); marker->SetMarkerSize(0.9); marker->Draw(); marker = new TMarker(0.2,0.53/2.,4); marker->SetMarkerColor(5); marker->SetMarkerStyle(4); marker->SetMarkerSize(0.9); marker->Draw(); marker = new TMarker(0.21,0.53/2.,4); marker->SetMarkerColor(7); marker->SetMarkerStyle(4); marker->SetMarkerSize(0.9); marker->Draw(); marker = new TMarker(0.2,0.44/2.,25); marker->SetMarkerColor(7); marker->SetMarkerStyle(25); marker->SetMarkerSize(1.3); marker->Draw(); marker = new TMarker(0.2,0.35/2.,26); marker->SetMarkerColor(3); marker->SetMarkerStyle(26); marker->SetMarkerSize(1.3); marker->Draw(); marker = new TMarker(0.2,0.26/2.,27); marker->SetMarkerColor(6); marker->SetMarkerStyle(27); marker->SetMarkerSize(1.3); marker->Draw(); marker = new TMarker(0.2,0.17/2.,30); marker->SetMarkerStyle(30); marker->SetMarkerSize(1.3); marker->Draw(); marker = new TMarker(0.2,0.08/2.,28); marker->SetMarkerColor(5); marker->SetMarkerStyle(28); marker->SetMarkerSize(1.3); marker->Draw(); TLatex *tex = new TLatex(0.04,0.86/2.,"Reco"); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); tex = new TLatex(0.04,0.41/2.,"Truth"); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); char temp[256]; sprintf(temp,"Summed NPEs < %.1f",Dspe_val); tex = new TLatex(0.3,0.86/2.,temp); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); sprintf(temp,"%.1f < Summed NPEs < %.1f",Dspe_val,Dmid_val); tex = new TLatex(0.3,0.77/2.,temp); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); sprintf(temp,"Summed NPEs > %.1f",Dmid_val); tex = new TLatex(0.3,0.68/2.,temp); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); tex = new TLatex(0.3,0.59/2.,"Reconstructed Track Hit"); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); tex = new TLatex(0.3,0.50/2.,"Reconstructed Primary Shower Hit (cyan=EM)"); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); tex = new TLatex(0.3,0.50/2.,"Reconstructed Sec. Shower Hit (cyan=EM)"); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); tex = new TLatex(0.3,0.41/2.,"Primary Muon (+ secondaries)"); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); tex = new TLatex(0.3,0.32/2.,"Primary Electron (+ secondaries)"); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); tex = new TLatex(0.3,0.23/2.,"Recoil Shower Products"); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); tex = new TLatex(0.3,0.14/2.,"Noise"); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); tex = new TLatex(0.3,0.05/2.,"Other"); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); tex = new TLatex(0.65,0.05/2.,"Nu Unit P"); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); TArrow *arrow = new TArrow(0.5,0.09/2.,0.6,0.09/2.,0.03,"|>"); arrow->SetFillColor(5); arrow->SetLineColor(9); arrow->SetLineWidth(2); arrow->Draw(); }

void MadScanDisplay::DrawKey2 (  TVirtualPad *   )  [protected]

Definition at line 3776 of file MadScanDisplay.cxx. References Dmid_val, and Dspe_val. Referenced by DrawButtons(). { KeyPad->cd(2); TPave *pave = new TPave(0.02,0.02,0.98,0.48); pave->Draw(); //reco: TMarker *marker = new TMarker(0.2,0.89/2.,8); marker->SetMarkerColor(3); marker->SetMarkerStyle(8); marker->SetMarkerSize(1.3); marker->Draw(); marker = new TMarker(0.2,0.80/2.,8); marker->SetMarkerColor(4); marker->SetMarkerStyle(8); marker->SetMarkerSize(1.3); marker->Draw(); marker = new TMarker(0.2,0.71/2.,8); marker->SetMarkerStyle(8); marker->SetMarkerSize(1.3); marker->Draw(); marker = new TMarker(0.2,0.62/2.,8); marker->SetMarkerColor(2); marker->SetMarkerStyle(8); marker->SetMarkerSize(0.9); marker->Draw(); marker = new TMarker(0.2,0.53/2.,4); marker->SetMarkerColor(6); marker->SetMarkerStyle(28); marker->SetMarkerSize(0.9); marker->Draw(); marker = new TMarker(0.2,0.44/2.,4); marker->SetMarkerColor(6); marker->SetMarkerStyle(25); marker->SetMarkerSize(0.9); marker->Draw(); marker = new TMarker(0.2,0.35/2.,4); marker->SetMarkerColor(2); marker->SetMarkerStyle(29); marker->SetMarkerSize(1); marker->Draw(); marker = new TMarker(0.2,0.26/2.,4); marker->SetMarkerColor(6); marker->SetMarkerStyle(3); marker->SetMarkerSize(1); marker->Draw(); TLatex *tex = new TLatex(0.04,0.86/2.,"Reco"); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); char temp[256]; sprintf(temp,"Summed NPEs < %.1f",Dspe_val); tex = new TLatex(0.3,0.86/2.,temp); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); sprintf(temp,"%.1f < Summed NPEs < %.1f",Dspe_val,Dmid_val); tex = new TLatex(0.3,0.77/2.,temp); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); sprintf(temp,"Summed NPEs > %.1f",Dmid_val); tex = new TLatex(0.3,0.68/2.,temp); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); tex = new TLatex(0.3,0.59/2.,"Reconstructed Track Hit"); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); tex = new TLatex(0.3,0.50/2.,"Reconstructed Primary Shower Hit"); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); tex = new TLatex(0.3,0.41/2.,"Reconstructed Sec. Shower Hit"); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); tex = new TLatex(0.3,0.32/2.,"Track Vertex"); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); tex = new TLatex(0.3,0.23/2.,"Shower Vertex"); tex->SetTextFont(132); tex->SetTextSize(0.05); tex->SetLineWidth(2); tex->Draw(); }

void MadScanDisplay::DrawTextBox (  TCanvas *  , Bool_t  )

Definition at line 3320 of file MadScanDisplay.cxx. References abs(), choose_infid_set(), NtpTHSlice::complete, NtpTHTrack::completeall, NtpTHShower::completeall, CorrectShowerEnergy(), det, NtpSRTrack::end, NtpSRMomentum::eqp, MadMKAnalysis::FarTrkContained(), VldContext::GetDetector(), RecDataHeader::GetRun(), VldContext::GetSimFlag(), RecPhysicsHeader::GetSnarl(), RecHeader::GetVldContext(), NtpSRStripPulseHeight::gev, NtpMCTruth::iaction, infid(), NtpMCTruth::inu, NtpMCTruth::iresonance, LeEvent, LeMCevent, LeSlice, NtpSRShowerPulseHeight::linCCgev, MadBase::LoadShower(), MadBase::LoadTHShower(), MadBase::LoadTHSlice(), MadBase::LoadTHTrack(), MadBase::LoadTrack(), NtpMCRecord::mc, NtpStRecord::mc, NtpSRTrack::momentum, NtpSREventSummary::nevent, NtpSREvent::nshower, NtpSREventSummary::nslice, NtpSREvent::ntrack, NtpMCTruth::p4el1, NtpMCTruth::p4mu1, NtpMCTruth::p4neu, NtpMCTruth::p4neunoosc, NtpMCTruth::p4shw, ScanFrame::PassChar(), ScanFrame::PassFloat(), ScanFrame::PassInt(), NtpSRShower::ph, MadMKAnalysis::PittTrkContained(), NtpTHTrack::purity, NtpTHShower::purity, NtpTHSlice::purity, NtpSRMomentum::qp, RecoMKMuEnergy(), RecoMuDCosNeuFD(), RecoMuDCosNeuND(), SFrame, NtpSREvent::shw, NtpSRShower::shwph, 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(). { //recalculate angles: float nu_mu_angle = 0; float nu_el_angle = 0; float zen_mu_angle = 0; if(isMC){ TVector3 *nuvec = new TVector3(ntpTruth->p4neunoosc[0], ntpTruth->p4neunoosc[1], ntpTruth->p4neunoosc[2]); TVector3 *muvec = new TVector3(ntpTruth->p4mu1[0], ntpTruth->p4mu1[1], ntpTruth->p4mu1[2]); TVector3 *elvec = new TVector3(ntpTruth->p4el1[0], ntpTruth->p4el1[1], ntpTruth->p4el1[2]); TVector3 *zenith = new TVector3(0,-1,0); nu_mu_angle = nuvec->Angle(*muvec); nu_el_angle = nuvec->Angle(*elvec); zen_mu_angle = muvec->Angle(*zenith); } //Summary char sometext1[100] = "."; if(isReco) sprintf(sometext1, "Run: %i, Snarl: %i, Slice: %i(/%i), Event %i(/%i)", ntpHeader->GetRun(),ntpHeader->GetSnarl(),LeSlice+1, eventSummary->nslice,LeEvent+1,eventSummary->nevent); else sprintf(sometext1, "Run: %i, Snarl: %i, Slice: %i(/%i), Event %i(/%i)", ntpHeader->GetRun(),ntpHeader->GetSnarl(),LeSlice+1, eventSummary->nslice,0,eventSummary->nevent); //Truth char sometext2[100] = "Truth"; char sometext3[100] = "N/A"; char sometext4[100] = "N/A"; char sometext5[100] = "N/A"; char sometext6[100] = "N/A"; char sometext7[100] = "N/A"; char sometext8[100] = "N/A"; //Reco char sometext9[100] = "N/A"; char sometext10[100] = "N/A"; char sometext14[100] = "N/A"; if(isReco&&eventSummary->nevent!=0&&isTH) { //Slice summary: LoadTHSlice(LeSlice); if(ntpTHSlice) sprintf(sometext9,"Reco - Slice (%.3f, %.3f)", ntpTHSlice->purity,ntpTHSlice->complete); else sprintf(sometext9,"Reco"); //Shower summary: if(ntpEvent->nshower>0&&ntpTHShower){ if(LoadTHShower(ntpEvent->shw[0])) { sprintf(sometext14," #Shws: %i (%.3f, %.3f)", ntpEvent->nshower,ntpTHShower->purity,ntpTHShower->completeall); SFrame->PassInt("NumShw",ntpEvent->nshower); } for(int i=1;i<ntpEvent->nshower;i++){ LoadTHShower(ntpEvent->shw[i]); if(ntpTHShower) sprintf(sometext14,"%s (%.3f, %.3f)",sometext14,ntpTHShower->purity, ntpTHShower->completeall); } } else if(ntpEvent->nshower>0) { sprintf(sometext14," #Shws: %i", ntpEvent->nshower); SFrame->PassInt("NumShw",ntpEvent->nshower); } else { sprintf(sometext14," #Shws: 0"); SFrame->PassInt("NumShw",0); } //Track summary: if(ntpEvent->ntrack>0&&ntpTHTrack){ sprintf(sometext10," #Trks: %i (%.3f, %.3f)", ntpEvent->ntrack,ntpTHTrack->purity,ntpTHTrack->completeall); SFrame->PassInt("NumTrk",ntpEvent->ntrack); for(int i=1;i<ntpEvent->ntrack;i++){ LoadTHTrack(ntpEvent->trk[i]); if(ntpTHTrack) sprintf(sometext10,"%s (%.3f, %.3f)",sometext10,ntpTHTrack->purity, ntpTHTrack->completeall); } } else if (ntpEvent->ntrack>0) { sprintf(sometext10," #Trks: %i",ntpEvent->ntrack); SFrame->PassInt("NumTrk",ntpEvent->ntrack); } else { sprintf(sometext10," #Trks: 0"); SFrame->PassInt("NumTrk",0); } } else if(isReco&&eventSummary->nevent!=0){ sprintf(sometext9,"Reco"); sprintf(sometext10," #Trks: %i",ntpEvent->ntrack); SFrame->PassInt("NumTrk",ntpEvent->ntrack); sprintf(sometext14," #Shws: %i",ntpEvent->nshower); SFrame->PassInt("NumShw",ntpEvent->nshower); } else { sprintf(sometext9,"Reco"); sprintf(sometext10," No Reconstruced Event"); } //Track values char sometext11[100] = "N/A"; char sometext12[100] = "N/A"; char sometext13[100] = "N/A"; if(false){ //if MC TClonesArray* pointMcArray = NULL; if(isST) pointMcArray = (strecord->mc); else pointMcArray = (mcrecord->mc); TClonesArray& mcArray = *pointMcArray; sprintf(sometext2,"Truth - MC: %i(/%i)",LeMCevent+1, mcArray.GetEntries()); sprintf(sometext3," Nu ID: %i; NC/CC: %i; Process: %i",ntpTruth->inu, ntpTruth->iaction,ntpTruth->iresonance); sprintf(sometext7," Shw Energy: %f",ntpTruth->p4shw[3]); sprintf(sometext8," Vtx: %.2f, %.2f, %.2f",ntpTruth->vtxx, ntpTruth->vtxy,ntpTruth->vtxz); if(abs(ntpTruth->inu)==12){ sprintf(sometext4," Nu E: %.3f; Elec E*q: %.3f",ntpTruth->p4neu[3], ntpTruth->p4el1[3]); sprintf(sometext5," Elec p: %.3f; Py: %.2f", sqrt(ntpTruth->p4el1[3]*ntpTruth->p4el1[3]) -(0.000511*0.000511),ntpTruth->p4el1[1]); sprintf(sometext6," #theta: %.4f rad, %.2f deg",nu_el_angle, nu_el_angle*180./TMath::Pi()); } else if(abs(ntpTruth->inu)==14){ sprintf(sometext4," Nu E: %.3f; Mu E*q: %.3f",ntpTruth->p4neu[3], ntpTruth->p4mu1[3]); sprintf(sometext5," Mu p: %.3f; Py: %.2f", sqrt(ntpTruth->p4mu1[3]*ntpTruth->p4mu1[3]) -(0.10555*0.10555),ntpTruth->p4mu1[1]); sprintf(sometext6," #theta: %.4f rad, %.2f deg",nu_mu_angle, nu_mu_angle*180./TMath::Pi()); } else if(ntpTruth->p4neu[3]<0.00001){ sprintf(sometext4," Nu E: %.3f; Mu E*q: %.3f",ntpTruth->p4neu[3], ntpTruth->p4mu1[3]); sprintf(sometext5," Mu p: %.3f; Py: %.2f", sqrt(ntpTruth->p4mu1[3]*ntpTruth->p4mu1[3]) -(0.10555*0.10555),ntpTruth->p4mu1[1]); sprintf(sometext6," Zenith angle: %.4f rad, %.2f deg",zen_mu_angle, zen_mu_angle*180./TMath::Pi()); } } if(isReco&&eventSummary->nevent!=0){ //reconstructed event present const Detector::Detector_t det = ntpHeader->GetVldContext().GetDetector(); Float_t cor_shw_energy =0; // corrected shower energy float best_trk_mom=0.0;// will be range or curvature int do_meth=0; // emu reco method we should use float reco_dircosneu=-1; // z cosine const bool is_mc =(ntpHeader->GetVldContext().GetSimFlag()==SimFlag::kMC); const double muM=0.10566; // muon mass if(ntpEvent->ntrack!=0){ //and at least one track float trk_mom_pq = 0; //for info, just show first track: int *tracks = ntpEvent->trk; int index = 0; float largestEn = 0; for(int it=0;it<ntpEvent->ntrack;it++){ if(!LoadTrack(tracks[it])) continue; if(ntpTrack->momentum.qp==0) continue; if(fabs(1./ntpTrack->momentum.qp)>largestEn) { largestEn = fabs(1./ntpTrack->momentum.qp); index = tracks[it]; } } LoadTrack(index); if(ntpTrack->momentum.qp!=0) trk_mom_pq = 1./ntpTrack->momentum.qp; // determine if event is contained, compute momentum if(det==Detector::kNear){//if it's the near detector int pitt_evt_class = MadMKAnalysis::PittTrkContained(ntpTrack->end.x, ntpTrack->end.y, ntpTrack->end.z, ntpTrack->end.u, ntpTrack->end.v); if(pitt_evt_class>0){ // if it was classified if( (pitt_evt_class == 1) || (pitt_evt_class == 3) ) do_meth=2; // stoppers --> range else if( (pitt_evt_class == 2) || (pitt_evt_class == 4) ) do_meth=1; // punch-through --> curvature if(do_meth==1 || do_meth==2){ best_trk_mom = RecoMKMuEnergy(do_meth,index,!is_mc); } } } else if(det==Detector::kFar){//if it's the far detector do_meth=MadMKAnalysis::FarTrkContained(ntpTrack->end.x, ntpTrack->end.y, ntpTrack->end.z); if(do_meth==1 || do_meth==2){ best_trk_mom = RecoMKMuEnergy(do_meth,index,!is_mc); } } best_trk_mom = sqrt(best_trk_mom*best_trk_mom - muM*muM); int range_meth=2; float mom_range = RecoMKMuEnergy(range_meth,index,!is_mc); mom_range = sqrt(mom_range*mom_range - muM*muM); if(det==Detector::kNear) reco_dircosneu = RecoMuDCosNeuND(index); else reco_dircosneu = RecoMuDCosNeuFD(index); char range_used=' '; char curve_used='R'; if(do_meth==1) curve_used='C'; else range_used='*'; choose_infid_set("cc2008"); Bool_t fid = infid(*strecord,*ntpTrack); char track_fid = 'N'; if(fid) track_fid = 'Y'; sprintf(sometext11," q/p: %.3f +/- %.3f, p/q: %.3f Best: %c Fiducial: %c ", ntpTrack->momentum.qp, ntpTrack->momentum.eqp,trk_mom_pq,curve_used, track_fid); SFrame->PassChar("BestRange",curve_used); SFrame->PassFloat("QoverP",ntpTrack->momentum.qp); sprintf(sometext12," TrkRangeEnergy: %.3f %c",mom_range,range_used); SFrame->PassFloat("TrkEne",mom_range); sprintf(sometext13," Vtx: x: %.2f, y: %.2f, u: %.2f, v: %.2f, z: %.2f",ntpTrack->vtx.x, ntpTrack->vtx.y,ntpTrack->vtx.u, ntpTrack->vtx.v,ntpTrack->vtx.z); } else {//no track sprintf(sometext11," q/p: %.3f +/- %.3f, p/q: %.3f",0.,0.,0.); SFrame->PassChar("BestRange",'?'); SFrame->PassFloat("QoverP",0.); sprintf(sometext12," TrkRangeEnergy: %.3f",0.); SFrame->PassFloat("TrkEne",0.); sprintf(sometext13," Vtx: %.2f, %.2f, %.2f",0.,0.,0.); } if(ntpEvent->nshower!=0){ //at least one shower //for info, just show biggest shower: // and the sum of showers int *showers = ntpEvent->shw; int index = 0; float largestEn = 0; float sumEn = 0; float thisEn = 0; for(int is=0;is<ntpEvent->nshower;is++){ if(!LoadShower(showers[is])) continue; if(ntpShower->shwph.linCCgev>largestEn) { largestEn = ntpShower->shwph.linCCgev; index = showers[is]; } thisEn=CorrectShowerEnergy(ntpShower->shwph.linCCgev, det,CandShowerHandle::kCC); sumEn+=thisEn; std::cout<<"shw (i,u,v,z,E,Ecor): ( "<<is<<" , "<<ntpShower->vtx.u <<" , "<<ntpShower->vtx.v<<" , "<<ntpShower->vtx.z <<" , "<<ntpShower->ph.gev<<" , "<<thisEn<<" ) "<<std::endl; } LoadShower(index); static int i_shw_message=1; if(i_shw_message<11){ std::cout<<"Printing the corrected linCC energy ("<<i_shw_message<<"/10)"; if(i_shw_message==10){ std::cout<<" Last message..."; } std::cout<<std::endl; i_shw_message++; } cor_shw_energy = CorrectShowerEnergy(ntpShower->shwph.linCCgev, det,CandShowerHandle::kCC); sprintf(sometext12,"%s RecoShwEnergy: %.3f [%.3f]",sometext12, cor_shw_energy, sumEn); SFrame->PassFloat("ShwEne",cor_shw_energy); } else {//no shower sprintf(sometext12,"%s RecoShwEnergy: %.3f",sometext12,0.); SFrame->PassFloat("ShwEne",0.); } if(best_trk_mom>0){ float reco_x=0.,reco_y=0.,reco_Q2=0.,reco_W2=0.,reco_QEQ2=0.; float reco_eshw=cor_shw_energy; float reco_emu=sqrt(best_trk_mom*best_trk_mom+muM*muM); float reco_enu=reco_emu+reco_eshw; const double M=(0.93827 + 0.93957)/2.0; // <nucleon mass> if(reco_emu>0) reco_Q2 = 2*reco_enu*reco_emu*(1.0 - reco_dircosneu); reco_W2 = M*M - reco_Q2 + 2*M*reco_eshw; if(reco_enu>0) reco_y = reco_eshw/reco_enu; if(reco_eshw>0 && reco_Q2>0) reco_x = reco_Q2/(2*M*reco_eshw); float muP=(reco_emu*reco_emu -muM*muM); if(muP<0) muP=0; else muP=sqrt(muP); float reco_qe_enu = (M*reco_emu - muM*muM/2.0) /(M - reco_emu + muP*reco_dircosneu); reco_QEQ2 = abs(-2.0*reco_qe_enu*(reco_emu-muP*reco_dircosneu)+muM*muM); // sprintf(sometext13,"%s, x,y,Q2,W2 = %.2f, %.2f, %.2f, %.2f", // sometext13, reco_x,reco_y,reco_Q2,reco_W2); } } else { //no event sprintf(sometext11," q/p: %.3f +/- %.3f, p/q: %.3f",0.,0.,0.); sprintf(sometext12, " TrkRangeEnergy: %.3f RecoShwEnergy: %.3f",0.,0.); sprintf(sometext13," Vtx: %.2f, %.2f, %.2f",0.,0.,0.); SFrame->PassChar("BestRange",'?'); SFrame->PassFloat("QoverP",0.); SFrame->PassFloat("TrkEne",0.); SFrame->PassFloat("ShwEne",0.); } //summary TLatex *Info1 = new TLatex(0.05,0.91,sometext1); Info1->SetName("info1"); Info1->SetTextSize(0.06); Info1->SetTextColor(2); //Reco TLatex *Info9 = new TLatex(0.05,0.84,sometext9); Info9->SetName("info9"); Info9->SetTextSize(0.06); Info9->SetTextColor(4); TLatex *Info10 = new TLatex(0.05,0.77,sometext10); Info10->SetName("info10"); if(Info10->Sizeof()<70) Info10->SetTextSize(0.05); else Info10->SetTextSize(0.04); Info10->SetTextColor(9); TLatex *Info14 = new TLatex(0.05,0.70,sometext14); Info14->SetName("info14"); if(Info14->Sizeof()<70) Info14->SetTextSize(0.05); else Info14->SetTextSize(0.04); Info14->SetTextColor(9); //track TLatex *Info11 = new TLatex(0.05,0.63,sometext11); Info11->SetName("info11"); Info11->SetTextSize(0.05); Info11->SetTextColor(9); TLatex *Info12 = new TLatex(0.05,0.56,sometext12); Info12->SetName("info12"); Info12->SetTextSize(0.05); Info12->SetTextColor(9); TLatex *Info13 = new TLatex(0.05,0.49,sometext13); Info13->SetName("info13"); Info13->SetTextSize(0.05); Info13->SetTextColor(9); //truth /* TLatex *Info2 = new TLatex(0.05,0.42,sometext2); Info2->SetName("info2"); Info2->SetTextSize(0.06); Info2->SetTextColor(3); TLatex *Info3 = new TLatex(0.05,0.35,sometext3); Info3->SetName("info3"); Info3->SetTextSize(0.05); Info3->SetTextColor(8); TLatex *Info4 = new TLatex(0.05,0.28,sometext4); Info4->SetName("info4"); Info4->SetTextSize(0.05); Info4->SetTextColor(8); TLatex *Info5 = new TLatex(0.05,0.21,sometext5); Info5->SetName("info5"); Info5->SetTextSize(0.05); Info5->SetTextColor(8); TLatex *Info6 = new TLatex(0.05,0.14,sometext6); Info6->SetName("info6"); Info6->SetTextSize(0.05); Info6->SetTextColor(8); TLatex *Info7 = new TLatex(0.05,0.07,sometext7); Info7->SetName("info7"); Info7->SetTextSize(0.05); Info7->SetTextColor(8); TLatex *Info8 = new TLatex(0.05,0.00,sometext8); Info8->SetName("info8"); Info8->SetTextSize(0.05); Info8->SetTextColor(8); */ MainCanvas->cd(1); gPad->Range(0,0,1,1); Info1->Draw(); // Info2->Draw(); // Info3->Draw(); // Info4->Draw(); // Info5->Draw(); // Info6->Draw(); // Info7->Draw(); // Info8->Draw(); Info9->Draw(); Info10->Draw(); Info11->Draw(); Info12->Draw(); Info13->Draw(); Info14->Draw(); }

void MadScanDisplay::EnableHandScan (  char *   )

Definition at line 4623 of file MadScanDisplay.cxx. References handScan, and logFileName. { handScan = true; if(std::strcmp(fname,"")) { sprintf(logFileName,"%s",fname); } }

void MadScanDisplay::EventDump (   )

Definition at line 4657 of file MadScanDisplay.cxx. References MadBase::LoadShower(), MadBase::LoadTrack(), NtpMCTruth::Print(), NtpSRShower::Print(), NtpSRTrack::Print(), NtpSREvent::Print(), NtpSREvent::shw, and NtpSREvent::trk. { if(ntpEvent) ntpEvent->Print(); if(LoadTrack(ntpEvent->trk[0])) ntpTrack->Print(); if(LoadShower(ntpEvent->shw[0])) ntpShower->Print(); if(ntpTruth) ntpTruth->Print(); }

void MadScanDisplay::FindUnSliced (   )

Definition at line 766 of file MadScanDisplay.cxx. References ScanFrame::EntryProc(), ScanFrame::SetEvent(), ScanFrame::SetSlice(), and SFrame. { SFrame->SetEvent(-1); SFrame->SetSlice(-1); SFrame->EntryProc(); }

void MadScanDisplay::HandleZoomEvent (   )

Definition at line 4977 of file MadScanDisplay.cxx. { // RBP: 2008-03-13 // Added this routine to allow users to drag-draw a box for zooming. // Much less wrist strain for the hand scanning studies! static Int_t firstX, firstY, lastX , lastY , lastEvent; static Double_t holdX0, holdX1, holdY0, holdY1; static Bool_t inside; Int_t event = gPad->GetEvent(); Int_t x = gPad->GetEventX(); Int_t y = gPad->GetEventY(); // get the drawn histogram... expecting it to be At(1): TH2 *h = (TH2*)gPad->GetListOfPrimitives()->At(1); if (!h->InheritsFrom(TH1::Class())) return; if (h) { TFrame* fr = 0; switch (event) { case kButton1Down: // hold start of zoom region if inside frame fr = (TFrame*)gPad->GetListOfPrimitives()->At(0); if (x > gPad->XtoAbsPixel(fr->GetX1())&& x < gPad->XtoAbsPixel(fr->GetX2())&& y > gPad->YtoAbsPixel(fr->GetY2())&& y < gPad->YtoAbsPixel(fr->GetY1())) { inside = kTRUE; firstX = x; firstY = y; gPad->SetCursor(kCross); gPad->GetRange(holdX0,holdY0,holdX1,holdY1); gVirtualX->DrawBox(x,y,x,y,TVirtualX::kHollow); gVirtualX->SetLineColor(-1); } else { inside = kFALSE; } break; case kButton1Motion: if (inside) { // draw zooming box gVirtualX->DrawBox(firstX,firstY,lastX,lastY,TVirtualX::kHollow); gVirtualX->DrawBox(firstX,firstY, x, y,TVirtualX::kHollow); } break; case kButton1Up: if (gROOT->IsEscaped()) { gROOT->SetEscape(kFALSE); } else if (inside) { // zoom the axes gPad->Range(holdX0,holdY0,holdX1,holdY1); Double_t newx0 = gPad->AbsPixeltoX((firstX<x)?firstX:x); Double_t newx1 = gPad->AbsPixeltoX((firstX<x)?x:firstX); Double_t newy0 = gPad->AbsPixeltoY((firstY>y)?firstY:y); Double_t newy1 = gPad->AbsPixeltoY((firstY>y)?y:firstY); Double_t oldx0 = gPad->GetUxmin(); Double_t oldx1 = gPad->GetUxmax(); Double_t oldy0 = gPad->GetUymin(); Double_t oldy1 = gPad->GetUymax(); if ((newx1-newx0)/(oldx1-oldx0)>0.05|| (newy1-newy0)/(oldy1-oldy0)>0.05) { h->GetXaxis()->SetRangeUser(newx0,newx1); h->GetYaxis()->SetRangeUser(newy0,newy1); gPad->Modified(kTRUE); } } inside = kFALSE; gVirtualX->SetLineColor(-1); break; default: break; } } lastEvent = event; lastX = x; lastY = y; }

Bool_t MadScanDisplay::InFidNoTrk (  int  e  )

Definition at line 507 of file MadScanDisplay.cxx. References choose_infid_set(), VldContext::GetDetector(), RecHeader::GetVldContext(), infid(), MadBase::LoadEvent(), MadBase::LoadLargestTrackFromEvent(), MadBase::LoadShower_Jim(), MadBase::LoadSlice(), NtpSREventSummary::nevent, ScanFrame::Pass(), SFrame, and NtpSREvent::slc. Referenced by NextFidNoTrk(), and PrevFidNoTrk(). { int shower_index; int ind; bool slice2=false; int slice = ntpEvent->slc; if(!LoadSlice(slice))return false; for(int i=0;i<eventSummary->nevent;i++){ if(i!=event){ LoadEvent(i); if(ntpEvent->slc==slice) slice2=true;; } } LoadLargestTrackFromEvent(event ,ind); if(ntpTrack)return false; LoadShower_Jim(event,shower_index,ntpHeader->GetVldContext().GetDetector()); if(!ntpShower)return false; choose_infid_set("cc2008Exp"); Bool_t fid = infid(*strecord,*ntpShower); if(fid && slice2) SFrame->Pass("Slice2Evt"); return fid; }

Bool_t MadScanDisplay::InFidTrk (  int  e  )

Definition at line 485 of file MadScanDisplay.cxx. References choose_infid_set(), infid(), MadBase::LoadEvent(), MadBase::LoadLargestTrackFromEvent(), MadBase::LoadSlice(), NtpSREventSummary::nevent, ScanFrame::Pass(), SFrame, and NtpSREvent::slc. Referenced by NextFidTrk(), and PrevFidTrk(). { int ind; int slice = ntpEvent->slc; if(!LoadSlice(slice))return false; bool slice2=false; for(int i=0;i<eventSummary->nevent;i++){ if(i!=event){ LoadEvent(i); if(ntpEvent->slc==slice) slice2=true; } } LoadEvent(event); LoadLargestTrackFromEvent(event,ind); if(!ntpTrack)return false; choose_infid_set("cc2008Exp"); Bool_t fid = infid(*strecord,*ntpTrack); if(fid && slice2) SFrame->Pass("Slice2Evt"); return fid; }

Int_t MadScanDisplay::JumpTo (   )

Definition at line 742 of file MadScanDisplay.cxx. References Display(), MadChain::GetEntryNumber(), LeAutoMat, and run(). { if(whichSource==0){ Int_t run = 0; Int_t snarl = 0; std::cout << "Enter run number of the snarl:" << std::endl; std::cin >> run; std::cout << "Enter snarl number:" << std::endl; std::cin >> snarl; Int_t entry = fChain->GetEntryNumber(run,snarl); cout << entry << endl; if(entry>=0 && entry<Nentries) { std::cout << "Displaying Run: " << run << " Snarl: " << snarl << std::endl; Display(entry,0,0,0,LeAutoMat); return entry; } std::cout << "Couldn't find Run: " << run << " Snarl: " << snarl << std::endl; } return lastEntry; }

void MadScanDisplay::Log (   )

Definition at line 4608 of file MadScanDisplay.cxx. References RecDataHeader::GetRun(), RecPhysicsHeader::GetSnarl(), RecDataHeader::GetSubRun(), NtpSREvent::index, NtpSRSlice::index, logFileName, ScanID, and ScanTop. { ofstream outFile; outFile.open(logFileName, ofstream::out | ofstream::app); outFile << ntpHeader->GetRun() << " " << ntpHeader->GetSubRun() << " " << ntpHeader->GetSnarl() << " " << ntpSlice->index << " " << ntpEvent->index << " " << ScanID << " " << ScanTop << " " << endl; outFile.close(); }

void MadScanDisplay::MakeGraphListNonEditable (  TList *   )

Definition at line 5072 of file MadScanDisplay.cxx. References MakeGraphNonEditable(). Referenced by Display(), and MakeGraphNonEditable(). { TIter next(list); while (TObject *obj = next()) { MakeGraphNonEditable(obj); } }

void MadScanDisplay::MakeGraphNonEditable (  TObject *   )

Definition at line 5062 of file MadScanDisplay.cxx. References MakeGraphListNonEditable(). Referenced by MakeGraphListNonEditable(). { if (obj->InheritsFrom(TGraph::Class())) { ((TGraph*)obj)->SetEditable(0); } else if (obj->InheritsFrom(TMultiGraph::Class())) { MakeGraphListNonEditable(((TMultiGraph*)obj)->GetListOfGraphs()); } }

Int_t MadScanDisplay::NextEvt (   )

Definition at line 372 of file MadScanDisplay.cxx. References Display(), ScanFrame::EntryProc(), MadBase::GetEntry(), LeAutoMat, LeEvent, LeMCevent, LeSlice, MadBase::LoadEvent(), NextInterestingEvent(), and SFrame. { if (fHaveNeatoEvents) { return NextInterestingEvent(); } SFrame->EntryProc(); int entry = LeEntry; int event = LeEvent+1; while(this->GetEntry(entry)){ while(LoadEvent(event++)) { LeSlice = 0; LeEvent = event; LeMCevent = 0; Display(entry,0,event,0,LeAutoMat); return entry; } event = 0; entry+=1; if(entry>=Nentries) break; } entry = 0; Display(0,0,0,0,LeAutoMat); return entry; }

Int_t MadScanDisplay::NextFidNoTrk (   )

Definition at line 559 of file MadScanDisplay.cxx. References Display(), ScanFrame::EntryProc(), MadBase::GetEntry(), InFidNoTrk(), LeAutoMat, LeEvent, LeMCevent, LeSlice, MadBase::LoadEvent(), and SFrame. { // override to read from list of events SFrame->EntryProc(); int entry = LeEntry; int event = LeEvent+1; while(this->GetEntry(entry)){ while(LoadEvent(event)) { if(InFidNoTrk(event)){ LeSlice = 0; LeEvent = event; LeMCevent = 0; Display(entry,0,event,0,LeAutoMat); return entry; } event+=1; } event = 0; entry+=1; if(entry>=Nentries) break; } entry = 0; Display(0,0,0,0,LeAutoMat); return entry; }

Int_t MadScanDisplay::NextFidTrk (   )

Definition at line 533 of file MadScanDisplay.cxx. References Display(), ScanFrame::EntryProc(), MadBase::GetEntry(), InFidTrk(), LeAutoMat, LeEvent, LeMCevent, LeSlice, MadBase::LoadEvent(), and SFrame. { // override to read from list of events SFrame->EntryProc(); int entry = LeEntry; int event = LeEvent+1; while(this->GetEntry(entry)){ while(LoadEvent(event)) { if(InFidTrk(event)){ LeSlice = 0; LeEvent = event; LeMCevent = 0; Display(entry,0,event,0,LeAutoMat); return entry; } event+=1; } event = 0; entry+=1; if(entry>=Nentries) break; } entry = 0; Display(0,0,0,0,LeAutoMat); return entry; }

Int_t MadScanDisplay::NextInterestingEvent (  bool  backward = false  )

Definition at line 4713 of file MadScanDisplay.cxx. References Display(), ScanFrame::EntryProc(), fNeatoEventIdx, fNeatoEvents, MadBase::GetEntry(), MadChain::GetEntryNumber(), LeAutoMat, MadBase::LoadEvent(), and SFrame. Referenced by NextEvt(), NextPass(), PrevEvt(), and PrevPass(). { if(fNeatoEvents.size()==0) return LeEntry; // int ncontinue; Int_t event=-1; Int_t entry=-1; while(true){ if(!backward){ if(fNeatoEventIdx+1 >= static_cast<Int_t>(fNeatoEvents.size())){ fNeatoEventIdx=0; } else fNeatoEventIdx++; } else{ if(fNeatoEventIdx-1 < 0){ fNeatoEventIdx=fNeatoEvents.size()-1; } else fNeatoEventIdx--; } // return fNeatoEventIdx; // search for event in MadChain's list std::vector<Int_t>& v = fNeatoEvents[fNeatoEventIdx]; entry=fChain->GetEntryNumber(v[0],v[1]); if(entry != -1) { event = v[2]; break; } } this->GetEntry(entry); this->LoadEvent(event); SFrame->EntryProc(); Display(entry,0,event,0,LeAutoMat); return entry; }

Int_t MadScanDisplay::NextPass (   )

Definition at line 428 of file MadScanDisplay.cxx. References abs(), Display(), MadBase::GetEntry(), NtpMCTruth::iaction, NtpMCTruth::inu, LeAutoMat, LeEvent, LeMCevent, LeNu, LeSlice, MadBase::LoadEvent(), MadBase::LoadSliceForRecoTH(), MadBase::LoadTruthForRecoTH(), NextInterestingEvent(), PassCuts(), and UseNuInfo. { // override to read from list of events if(fHaveNeatoEvents) { return NextInterestingEvent(); } int entry = LeEntry; int event = LeEvent+1; if(isMC&&isTH){ int mcevent = 0; while(this->GetEntry(entry)){ while(LoadEvent(event)) { if(LoadTruthForRecoTH(event,mcevent)){ if(PassCuts()&&(!UseNuInfo||(abs(ntpTruth->inu)==LeNu &&ntpTruth->iaction==LeAction))){ int slice = 0; LoadSliceForRecoTH(event,slice); LeSlice = slice; LeEvent = event; LeMCevent = mcevent; Display(entry,slice,event,mcevent,LeAutoMat); return entry; } } event+=1; } event = 0; entry+=1; if(entry>=Nentries) break; } entry = 0; Display(0,0,0,0,LeAutoMat); return entry; } //if no MC or TH: while(this->GetEntry(entry)){ while(LoadEvent(event)) { if(PassCuts()){ LeSlice = 0; LeEvent = event; LeMCevent = 0; Display(entry,0,event,0,LeAutoMat); return entry; } event+=1; } event = 0; entry+=1; if(entry>=Nentries) break; } entry = 0; Display(0,0,0,0,LeAutoMat); return entry; }

Bool_t MadScanDisplay::PassCuts (   )  [virtual]

Definition at line 200 of file MadScanDisplay.cxx. References VldContext::GetDetector(), RecHeader::GetVldContext(), NtpSREvent::index, MadBase::LoadLargestTrackFromEvent(), NtpSRTrack::vtx, NtpSREvent::vtx, NtpSRVertex::x, NtpSRVertex::y, and NtpSRVertex::z. Referenced by NextPass(), and PrevPass(). { if(!ntpEvent) return false; //ND fid cuts if(false){ if(ntpHeader->GetVldContext().GetDetector()==Detector::kNear){ if((ntpEvent->vtx.z<1 || ntpEvent->vtx.z>5 || sqrt(((ntpEvent->vtx.x-1.4885)*(ntpEvent->vtx.x-1.4885)) + ((ntpEvent->vtx.y-0.1397)*(ntpEvent->vtx.y-0.1397)))>1)) { return false; } Int_t track = -1; if(LoadLargestTrackFromEvent(ntpEvent->index,track)){ if((ntpTrack->vtx.z<1 || ntpTrack->vtx.z>5 || sqrt(((ntpTrack->vtx.x-1.4885)*(ntpTrack->vtx.x-1.4885)) + ((ntpTrack->vtx.y-0.1397)*(ntpTrack->vtx.y-0.1397)))>1)) { return false; } } } } if(false){ if(LoadTHEvent(ntpEvent->index)) { if(ntpTHEvent->completeslc<0.1) { cout << "low event completeness " << ntpTHEvent->completeslc << endl; return true; } if(ntpEvent->nshower>0) { Int_t shw_ind = -1; if( ( ntpEvent->ntrack>0 && ntpTrack && LoadShowerAtTrackVertex(ntpEvent->index, ntpTrack->index,shw_ind) ) || (ntpEvent->ntrack==0 && LoadLargestShowerFromEvent(ntpEvent->index,shw_ind) ) ){ if(LoadTHShower(shw_ind)) { if(ntpTHShower->completeslc < 0.2) { cout << "low vertex shower completeness " << ntpTHShower->completeslc << endl; return true; } } } } } } if(false){ if(eventSummary->nshower==1 && eventSummary->ntrack==1 && eventSummary->nevent==1 && ntpEvent->nshower==1 && ntpEvent->ntrack==0) return true; } //>=2 showers if(false){ if(ntpEvent->nshower>1 && ntpEvent->ntrack==0) return true; } //Two or more events/slice if(false){ Int_t slice = ntpEvent->slc; Int_t ev_index = ntpEvent->index; if(LoadEvent(ev_index+1)) { if(ntpEvent->slc==slice) { //get total charge of shower in PEs for U and V: Double_t shwChargeU = 0; Double_t shwChargeV = 0; Double_t shwChargeAsym = 0; Int_t shower = -1; if(LoadLargestShowerFromEvent(ntpEvent->index,shower)){ for(int i = 0; i<ntpShower->ncluster;i++){ LoadCluster(ntpShower->clu[i]); if(ntpCluster->planeview==2) shwChargeU += ntpCluster->ph.pe; else shwChargeV += ntpCluster->ph.pe; } shwChargeAsym = ( TMath::Abs(shwChargeU - shwChargeV) / (shwChargeU+shwChargeV) ); cout << "2nd: " << shwChargeU << " " << shwChargeV << " " << shwChargeAsym << endl; } LoadEvent(ev_index); // first event: shwChargeU = 0; shwChargeV = 0; if(LoadLargestShowerFromEvent(ntpEvent->index,shower)){ for(int i = 0; i<ntpShower->ncluster;i++){ LoadCluster(ntpShower->clu[i]); if(ntpCluster->planeview==2) shwChargeU += ntpCluster->ph.pe; else shwChargeV += ntpCluster->ph.pe; } shwChargeAsym = ( TMath::Abs(shwChargeU - shwChargeV) / (shwChargeU+shwChargeV) ); cout << "1st: " << shwChargeU << " " << shwChargeV << " " << shwChargeAsym << endl; } cout << ">1 event in slice" << endl; return true; } } LoadEvent(ev_index); } //SubShower Cuts: if(false){ Int_t shower = -1; if(eventSummary->nevent==1&&ntpEvent->nshower==1&& LoadLargestShowerFromEvent(ntpEvent->index,shower)) { int goodU = 0; int goodV = 0; double maxU = 0; double maxV = 0; double avgdevU = 1.; double avgdevV = 1.; Int_t nemclu = 0; Int_t nhadclu = 0; Int_t nphysclu = 0; Int_t *clusters = ntpShower->clu; for(int k=0; k<ntpShower->ncluster; k++){ Int_t index = clusters[k]; if(!LoadCluster(index)) continue; if(ntpCluster->ph.gev>0.4){ if(ntpCluster->id==0) nemclu++; else if(ntpCluster->id==1) nhadclu++; else if(ntpCluster->id!=2) nphysclu++; } if(ntpCluster->planeview==2){ if(ntpCluster->ph.gev>maxU){ if(ntpCluster->id==0){ goodU = 1; if(ntpCluster->probem>0.2) goodU=3; avgdevU = ntpCluster->avgdev; maxU = ntpCluster->ph.gev; } else { goodU = 0; avgdevU = ntpCluster->avgdev; maxU = ntpCluster->ph.gev; } } } else if(ntpCluster->planeview==3){ if(ntpCluster->ph.gev>maxV){ if(ntpCluster->id==0){ goodV = 1; if(ntpCluster->probem>0.2) goodV=3; avgdevV = ntpCluster->avgdev; maxV = ntpCluster->ph.gev; } else { goodV = 0; avgdevV = ntpCluster->avgdev; maxV = ntpCluster->ph.gev; } } } } if((goodU==1 && goodV==1) || goodU==3 || goodV==3){ cout << ntpTruth->iaction << " " << nemclu << " " << nhadclu << " " << nemclu+nhadclu+nphysclu << endl; return true; } } } return false; }

Int_t MadScanDisplay::PrevEvt (   )

Definition at line 400 of file MadScanDisplay.cxx. References Display(), ScanFrame::EntryProc(), MadBase::GetEntry(), LeAutoMat, LeEvent, LeMCevent, LeSlice, MadBase::LoadEvent(), NextInterestingEvent(), and SFrame. { if (fHaveNeatoEvents) { return NextInterestingEvent(true); } SFrame->EntryProc(); int entry = LeEntry; int event = LeEvent-1; while(this->GetEntry(entry)){ while(LoadEvent(event--)) { LeSlice = 0; LeEvent = event; LeMCevent = 0; Display(entry,0,event,0,LeAutoMat); return entry; } event = 0; entry-=1; if(entry<0) break; } entry = 0; Display(0,0,0,0,LeAutoMat); return entry; }

Int_t MadScanDisplay::PrevFidNoTrk (   )

Definition at line 695 of file MadScanDisplay.cxx. References Display(), NtpSRRecord::evt, NtpStRecord::evt, MadBase::GetEntry(), InFidNoTrk(), LeAutoMat, LeEvent, LeMCevent, LeSlice, and MadBase::LoadEvent(). { // override to read from list of events int entry = LeEntry; int event = LeEvent-1; while(this->GetEntry(entry)){ if(event==-100){ TClonesArray* pointEventArray = NULL; if(isST) pointEventArray = (strecord->evt); else pointEventArray = (record->evt); TClonesArray& eventArray = *pointEventArray; event = eventArray.GetEntries() - 1; } while(LoadEvent(event)) { if(InFidNoTrk(event)){ LeSlice = 0; LeEvent = event; LeMCevent = 0; Display(entry,0,event,0,LeAutoMat); return entry; } event-=1; } event = -100; entry-=1; if(entry<0) break; } entry = 0; Display(0,0,0,0,LeAutoMat); return entry; }

Int_t MadScanDisplay::PrevFidTrk (   )

Definition at line 660 of file MadScanDisplay.cxx. References Display(), NtpSRRecord::evt, NtpStRecord::evt, MadBase::GetEntry(), InFidTrk(), LeAutoMat, LeEvent, LeMCevent, LeSlice, and MadBase::LoadEvent(). { // override to read from list of events int entry = LeEntry; int event = LeEvent-1; while(this->GetEntry(entry)){ if(event==-100){ TClonesArray* pointEventArray = NULL; if(isST) pointEventArray = (strecord->evt); else pointEventArray = (record->evt); TClonesArray& eventArray = *pointEventArray; event = eventArray.GetEntries() - 1; } while(LoadEvent(event)) { if(InFidTrk(event)){ LeSlice = 0; LeEvent = event; LeMCevent = 0; Display(entry,0,event,0,LeAutoMat); return entry; } event-=1; } event = -100; entry-=1; if(entry<0) break; } entry = 0; Display(0,0,0,0,LeAutoMat); return entry; }

Int_t MadScanDisplay::PrevPass (   )

Definition at line 586 of file MadScanDisplay.cxx. References abs(), Display(), ScanFrame::EntryProc(), NtpSRRecord::evt, NtpStRecord::evt, MadBase::GetEntry(), NtpMCTruth::iaction, NtpMCTruth::inu, LeAutoMat, LeEvent, LeMCevent, LeNu, LeSlice, MadBase::LoadEvent(), MadBase::LoadSliceForRecoTH(), MadBase::LoadTruthForRecoTH(), NextInterestingEvent(), PassCuts(), SFrame, and UseNuInfo. { // override to read from list of events if(fHaveNeatoEvents) { return NextInterestingEvent(true); } int entry = LeEntry; int event = LeEvent-1; if(isMC&&isTH){ int mcevent = 0; while(this->GetEntry(entry)){ if(event==-100){ TClonesArray* pointEventArray = NULL; if(isST) pointEventArray = (strecord->evt); else pointEventArray = (record->evt); TClonesArray& eventArray = *pointEventArray; event = eventArray.GetEntries() - 1; } while(LoadEvent(event)) { if(LoadTruthForRecoTH(event,mcevent)){ if(PassCuts()&&(!UseNuInfo||(abs(ntpTruth->inu)==LeNu &&ntpTruth->iaction==LeAction))){ int slice = 0; LoadSliceForRecoTH(event,slice); LeSlice = slice; LeEvent = event; LeMCevent = mcevent; Display(entry,slice,event,mcevent,LeAutoMat); SFrame->EntryProc(); return entry; } } event-=1; } event = -100; //to catch when we've got to last event in snarl entry -= 1; if(entry<0) break; } entry = 0; Display(0,0,0,0,LeAutoMat); SFrame->EntryProc(); return entry; } //if no MC or TH: while(this->GetEntry(entry)){ if(event==-100){ TClonesArray* pointEventArray = NULL; if(isST) pointEventArray = (strecord->evt); else pointEventArray = (record->evt); TClonesArray& eventArray = *pointEventArray; event = eventArray.GetEntries() - 1; } while(LoadEvent(event)) { if(PassCuts()){ LeSlice = 0; LeEvent = event; LeMCevent = 0; Display(entry,0,event,0,LeAutoMat); SFrame->EntryProc(); return entry; } event-=1; } event = -100; entry-=1; if(entry<0) break; } entry = 0; Display(0,0,0,0,LeAutoMat); SFrame->EntryProc(); return entry; }

void MadScanDisplay::PrintDisplay (   )

Definition at line 156 of file MadScanDisplay.cxx. References Nav::GetName(), and printName. { //Print canvases TCanvas *can[6]; can[0] = (TCanvas*) gROOT->FindObject("RecoCanvas"); can[1] = (TCanvas*) gROOT->FindObject("MainCanvas"); can[2] = (TCanvas*) gROOT->FindObject("TruthCanvas"); can[3] = (TCanvas*) gROOT->FindObject("LegoCanvas"); can[4] = (TCanvas*) gROOT->FindObject("ClusterCanvas"); can[5] = (TCanvas*) gROOT->FindObject("StdHepDiagramCanvas"); for(int i=0;i<5;i++){ if(can[i]) { TString temp(can[i]->GetName()); if(isMC) { temp.Append("_MC"); } temp.Append(printName); can[i]->Print(temp.Data()); /* // try to use TImage (TASImage actually...) to print canvases // in the hope of solving the "canvas with bit of other window" output // this didn't work... got // <RootX11ErrorHandler>: BadMatch and canvas was covered // or // ASImage2gif():944:<MainCanvas_MC_Run10001_Snl35_Slc1_Evt1.gif> // GIF-LIB undefined error 0. // Error in <TASImage::WriteImage>: error writing file MainCanvas_MC_Run10001_Snl35_Slc1_Evt1.gif TImage* img = TImage::Create(); img->FromPad(can[i]); img->WriteImage(temp.Data()); delete img; */ } } }

void MadScanDisplay::PrintHSHelp (   )

Definition at line 4631 of file MadScanDisplay.cxx. { cout << endl; cout << endl; cout << "================= Hand Scan Info =================" << endl; cout << "Left Hand Column shows possible event ID tags:" << endl; cout << "mu = numu CC - code = 1" << endl; cout << "e = nue CC - code = 2" << endl; cout << "NC = NC - code = 3" << endl; cout << "mu/NC = numu CC / NC Ambiguity - code = 4" << endl; cout << "e/NC = nue CC / NC Ambiguity - code = 5" << endl; cout << "??? = Complete Ambiguity - code = 6" << endl; cout << "N/A (all buttons red) - code = 0" << endl; cout << "--------------------------------------------------" << endl; cout << "Right Hand Column shows possible event topology tags:" << endl; cout << "QE - code = 1" << endl; cout << "RES - code = 2" << endl; cout << "DIS - code = 3" << endl; cout << "??? - code = 4" << endl; cout << "N/A (all buttons red) - code = 0" << endl; cout << "--------------------------------------------------" << endl; cout << "Click 'Log Details' to write choices to text file" << endl; cout << "=================== Good Luck! ===================" << endl; cout << endl; }

bool MadScanDisplay::ReadEventsFile (  const char *  filename  )

Definition at line 4665 of file MadScanDisplay.cxx. References fHaveNeatoEvents, fNeatoEvents, gSystem(), run(), and s(). { // read text file listing interesting events // file format: run snarl event // blank lines and lines beginning with # are ignored //check that file exists FileStat_t buf; if(gSystem->GetPathInfo(filename,buf) == 1) { std::cout<<"MadScanDisplay::ReadEventsFile: couldn't open "<<filename<<std::endl; return false; } else{ std::cout<<"MadScanDisplay::ReadEventsFile: reading from "<<filename<<std::endl; } std::ifstream in(filename); int nread=0; std::string s; while(std::getline(in,s,'\n')){ if(s=="") continue;// a blank line else if(s[0]=='#') continue; // a comment else{ std::istringstream iss(s,std::istringstream::in); Int_t run,snarl,event; iss>>run>>snarl>>event; /* std::cout<<run<<" "<<snarl<<" "<<event; if(iss.good()) std::cout<<" good "; else std::cout<<" !good "; if(iss.eof()) std::cout<<" eof "; else std::cout<<" !eof "; std::cout<<std::endl; */ // check that the read was ok if(iss.good() || iss.eof()){ std::vector<Int_t> v(3); v[0]=run; v[1]=snarl; v[2]=event; fNeatoEvents.push_back(v); nread++; } } } std::cout<<"MadScanDisplay::ReadEventsFile read "<<nread<<" events."<<std::endl; if(nread>0) fHaveNeatoEvents=true; return true; }

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

Definition at line 4749 of file MadScanDisplay.cxx. References CorrectMomentumFromRange(), NtpSRFiducial::dr, NtpSRFiducial::dz, NtpSRTrack::fidall, MadBase::LoadTrack(), NtpSRTrack::momentum, NtpSRMomentum::qp, and NtpSRMomentum::range. Referenced by DrawTextBox(). { if(LoadTrack(itrk)){ float mr=ntpTrack->momentum.range; mr=CorrectMomentumFromRange(mr,isdata); if(opt==0){ //return the most appropriate measure of momentum // assign opt based on our choice if(ntpTrack->fidall.dr>0.5&&ntpTrack->fidall.dz>0.5) { opt=2; return sqrt(mr*mr+ 0.10555*0.10555); } else { opt=1; // in R1.9 the tracker will apparently return (q/p)=0.0 // maybe it's when a track looks perfectly rigid? // if so, we have to do something // I don't want to use the range, that could be very wrong // but wrong in a more subtle way ... // so, we'll return an obviously ridiculous value of 10 TeV if(ntpTrack->momentum.qp == 0.0) return 10000.0; else return sqrt(1./(ntpTrack->momentum.qp*ntpTrack->momentum.qp) + 0.10555*0.10555); } } else if(opt==1) { //return curvature measurement if(ntpTrack->momentum.qp == 0.0) return 10000.0; else return sqrt(1./(ntpTrack->momentum.qp*ntpTrack->momentum.qp) + 0.10555*0.10555); } else if(opt==2) //return range measurement return sqrt(mr*mr + 0.10555*0.10555); else return 0; } return 0.; }

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

Definition at line 4787 of file MadScanDisplay.cxx. References NtpSRVertex::dcosy, NtpSRVertex::dcosz, MadBase::LoadTrack(), and NtpSRTrack::vtx. Referenced by DrawTextBox(). { if(!LoadTrack(itr)) return 0.; Float_t bl_z = TMath::Cos(TMath::Pi()*3./180.); //3degree beam Float_t bl_y = sqrt(1. - bl_z*bl_z); Float_t costhbl = ntpTrack->vtx.dcosz*bl_z + ntpTrack->vtx.dcosy*bl_y; return costhbl; }

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

Definition at line 4797 of file MadScanDisplay.cxx. References NtpSRVertex::dcosy, NtpSRVertex::dcosz, MadBase::LoadTrack(), and NtpSRTrack::vtx. Referenced by DrawTextBox(). { if(!LoadTrack(itr)) return 0.; /* // simple correction based on the vertical position float vtxy=0; if(vtx) vtxy=vtx[1]; // in meters // cosine of the typical neutrino angle in the yz plane // calculated as py / sqrt( py^2 + pz^2) float nu_cos = -5.799E-2; if(vtxy>-2.0 && vtxy<2.0){ //prevents further nuttyness if vtxy is silly nu_cos += vtxy*1.23304E-3 + vtxy*vtxy*1.08212E-5 + vtxy*vtxy*vtxy*(-4.634E-5); } */ float nu_cos = -5.799E-2; float nu_sin = sqrt(1 -nu_cos*nu_cos); float cosz = ntpTrack->vtx.dcosz*nu_sin + ntpTrack->vtx.dcosy*nu_cos; return cosz; }

void MadScanDisplay::ROICalc (   )

Definition at line 4820 of file MadScanDisplay.cxx. References MadBase::LoadSlice(), MadBase::LoadStrip(), NtpSREvent::nstrip, NtpSRSlice::nstrip, ScanFrame::PassFloat(), NtpSRPulseHeight::pe, NtpSRStrip::ph0, NtpSRStrip::ph1, NtpSRStrip::plane, NtpSRStrip::planeview, SFrame, NtpSREvent::slc, NtpSREvent::stp, NtpSRSlice::stp, NtpSRStrip::strip, NtpSRStrip::tpos, and NtpSRStrip::z. { TH2 * utz_place = (TH2*) gROOT->FindObject("tz_place_0"); TH2 * vtz_place = (TH2*) gROOT->FindObject("tz_place_1"); Double_t tmin_U=0; Double_t tmax_U=0; Double_t zmin_U=0; Double_t zmax_U=0; Double_t tmin_V=0; Double_t tmax_V=0; Double_t zmin_V=0; Double_t zmax_V=0; if(utz_place && vtz_place){ int firstbin = utz_place->GetXaxis()->GetFirst(); int lastbin = utz_place->GetXaxis()->GetLast(); zmin_U = utz_place->GetXaxis()->GetXmin()+utz_place->GetXaxis()->GetBinWidth(0)*(firstbin-1); zmax_U = utz_place->GetXaxis()->GetXmin()+utz_place->GetXaxis()->GetBinWidth(0)*(lastbin-1); firstbin = utz_place->GetYaxis()->GetFirst(); lastbin = utz_place->GetYaxis()->GetLast(); tmin_U = utz_place->GetYaxis()->GetXmin()+utz_place->GetYaxis()->GetBinWidth(0)*(firstbin-1); tmax_U = utz_place->GetYaxis()->GetXmin()+utz_place->GetYaxis()->GetBinWidth(0)*(lastbin-1); firstbin = vtz_place->GetXaxis()->GetFirst(); lastbin = vtz_place->GetXaxis()->GetLast(); zmin_V = vtz_place->GetXaxis()->GetXmin()+vtz_place->GetXaxis()->GetBinWidth(0)*(firstbin-1); zmax_V = vtz_place->GetXaxis()->GetXmin()+vtz_place->GetXaxis()->GetBinWidth(0)*(lastbin-1); firstbin = vtz_place->GetYaxis()->GetFirst(); lastbin = vtz_place->GetYaxis()->GetLast(); tmin_V = vtz_place->GetYaxis()->GetXmin()+vtz_place->GetYaxis()->GetBinWidth(0)*(firstbin-1); tmax_V = vtz_place->GetYaxis()->GetXmin()+vtz_place->GetYaxis()->GetBinWidth(0)*(lastbin-1); } double slcPH=0; if(ntpEvent){ LoadSlice(ntpEvent->slc); if(ntpSlice){ for(int i=0;i<ntpSlice->nstrip;i++){ if(!LoadStrip(ntpSlice->stp[i])) continue; Double_t zstp = ntpStrip->z; Double_t tstp = ntpStrip->tpos; Double_t ph = ntpStrip->ph1.pe + ntpStrip->ph0.pe; if(ntpStrip->planeview==PlaneView::kU){ if(zstp>=zmin_U && zstp<=zmax_U && tstp>=tmin_U && tstp<=tmax_U){ slcPH+=ph; } } else{ if(zstp>=zmin_V && zstp<=zmax_V && tstp>=tmin_V && tstp<=tmax_V) { slcPH+=ph; } } } } double evtPH=0; int stripbuf[10000] ; int planebuf[10000]; int nbuf=0; for(int i=0;i<ntpEvent->nstrip;i++){ if(!LoadStrip(ntpEvent->stp[i])) continue; bool used=false; for(int j=0;j<nbuf;j++){ if(stripbuf[j]==ntpStrip->strip && planebuf[j]==ntpStrip->plane) used=true; } stripbuf[nbuf]=ntpStrip->strip; planebuf[nbuf]=ntpStrip->plane; nbuf++; if(!used){ Double_t ztrk = ntpStrip->z; Double_t ttrk = ntpStrip->tpos; Double_t ph = ntpStrip->ph1.pe + ntpStrip->ph0.pe; if(ntpStrip->planeview==PlaneView::kU){ if(ztrk>=zmin_U && ztrk<=zmax_U && ttrk>=tmin_U && ttrk<=tmax_U) { evtPH+=ph; } } else{ if(ztrk>=zmin_V && ztrk<=zmax_V && ttrk>=tmin_V && ttrk<=tmax_V) { evtPH+=ph; } } } } double phlost = 0; if(slcPH-evtPH>0) phlost=slcPH-evtPH; SFrame->PassFloat("ShwLostPH",phlost); } }

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

Definition at line 92 of file MadScanDisplay.h. References fDefaultShowerMarkerColor. {fDefaultShowerMarkerColor=col;}

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

Definition at line 93 of file MadScanDisplay.h. References fDefaultShowerMarkerStyle. {fDefaultShowerMarkerStyle=style;}

void MadScanDisplay::SetDVals (  Float_t  , Float_t  )

Definition at line 150 of file MadScanDisplay.cxx. References Dmid_val, and Dspe_val. { Dspe_val = spe_val; Dmid_val = mid_val; }

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

Definition at line 51 of file MadScanDisplay.h. References ptt_msg. {ptt_msg=yesno;} //print extra info?

void MadScanDisplay::SetPrintOpt (  char *  opt  )

Definition at line 195 of file MadScanDisplay.cxx. References printOpt. { sprintf(printOpt,"%s",opt); // this->Display(LeEntry,LeSlice,LeEvent,LeMCevent,LeAutoMat); }

void MadScanDisplay::ShwROICalc (   )

Definition at line 4911 of file MadScanDisplay.cxx. References MadBase::LoadShower(), MadBase::LoadStrip(), NtpSREvent::nshower, NtpSRShower::nstrip, ScanFrame::PassFloat(), NtpSRPulseHeight::pe, NtpSRStrip::ph0, NtpSRStrip::ph1, NtpSRStrip::planeview, SFrame, NtpSREvent::shw, NtpSRShower::stp, NtpSRStrip::tpos, and NtpSRStrip::z. { TH2 * utz_place = (TH2*) gROOT->FindObject("tz_place_0"); TH2 * vtz_place = (TH2*) gROOT->FindObject("tz_place_1"); Double_t tmin_U=0; Double_t tmax_U=0; Double_t zmin_U=0; Double_t zmax_U=0; Double_t tmin_V=0; Double_t tmax_V=0; Double_t zmin_V=0; Double_t zmax_V=0; if(utz_place && vtz_place){ int firstbin = utz_place->GetXaxis()->GetFirst(); int lastbin = utz_place->GetXaxis()->GetLast(); zmin_U = utz_place->GetXaxis()->GetXmin()+utz_place->GetXaxis()->GetBinWidth(0)*(firstbin-1); zmax_U = utz_place->GetXaxis()->GetXmin()+utz_place->GetXaxis()->GetBinWidth(0)*(lastbin-1); firstbin = utz_place->GetYaxis()->GetFirst(); lastbin = utz_place->GetYaxis()->GetLast(); tmin_U = utz_place->GetYaxis()->GetXmin()+utz_place->GetYaxis()->GetBinWidth(0)*(firstbin-1); tmax_U = utz_place->GetYaxis()->GetXmin()+utz_place->GetYaxis()->GetBinWidth(0)*(lastbin-1); firstbin = vtz_place->GetXaxis()->GetFirst(); lastbin = vtz_place->GetXaxis()->GetLast(); zmin_V = vtz_place->GetXaxis()->GetXmin()+vtz_place->GetXaxis()->GetBinWidth(0)*(firstbin-1); zmax_V = vtz_place->GetXaxis()->GetXmin()+vtz_place->GetXaxis()->GetBinWidth(0)*(lastbin-1); firstbin = vtz_place->GetYaxis()->GetFirst(); lastbin = vtz_place->GetYaxis()->GetLast(); tmin_V = vtz_place->GetYaxis()->GetXmin()+vtz_place->GetYaxis()->GetBinWidth(0)*(firstbin-1); tmax_V = vtz_place->GetYaxis()->GetXmin()+vtz_place->GetYaxis()->GetBinWidth(0)*(lastbin-1); } double shwPH=0; if(ntpEvent){ int *showers = ntpEvent->shw; for(int i=0;i<ntpEvent->nshower;i++){ int index = showers[i]; LoadShower(index); } for(int i=0;i<ntpShower->nstrip;i++){ if(!LoadStrip(ntpShower->stp[i])) continue; Double_t zshw = ntpStrip->z; Double_t tshw = ntpStrip->tpos; Double_t ph = ntpStrip->ph1.pe + ntpStrip->ph0.pe; if(ntpStrip->planeview==PlaneView::kU){ if(zshw>=zmin_U && zshw<=zmax_U && tshw>=tmin_U && tshw<=tmax_U) { shwPH+=ph; } } else{ if(zshw>=zmin_V && zshw<=zmax_V && tshw>=tmin_V && tshw<=tmax_V) { shwPH+=ph; } } } } SFrame->PassFloat("ShwExtraPH",shwPH); }

Int_t MadScanDisplay::SkipTo (   )

Definition at line 729 of file MadScanDisplay.cxx. References Display(), and LeAutoMat. { Int_t sp = 0; std::cout << "Enter tree entry number to jump to" << std::endl; std::cin >> sp; if(sp<0||sp>Nentries) sp=0; std::cout << sp << std::endl; Display(sp,0,0,0,LeAutoMat); return sp; }

void MadScanDisplay::StartLogger (   )

Definition at line 4488 of file MadScanDisplay.cxx. Referenced by DrawButtons(). { TButton *but1 = new TButton("mu", "EVD->ScanID=1; EVD->ChangeLogButColor();", 0.,0.8875,0.1275,0.95); but1->SetTextSize(0.6); but1->SetFillColor(2); but1->SetName("logBut1"); TButton *but2 = new TButton("e", "EVD->ScanID=2; EVD->ChangeLogButColor();", 0.,0.825,0.1275,0.8875); but2->SetTextSize(0.6); but2->SetFillColor(2); but2->SetName("logBut2"); TButton *but3 = new TButton("NC", "EVD->ScanID=3; EVD->ChangeLogButColor();", 0.,0.7625,0.1275,0.825); but3->SetTextSize(0.6); but3->SetFillColor(2); but3->SetName("logBut3"); TButton *but4 = new TButton("mu/NC?", "EVD->ScanID=4; EVD->ChangeLogButColor();", 0.,0.70,0.1275,0.7625); but4->SetTextSize(0.6); but4->SetFillColor(2); but4->SetName("logBut4"); TButton *but5 = new TButton("e/NC?", "EVD->ScanID=5; EVD->ChangeLogButColor();", 0.,0.6375,0.1275,0.7); but5->SetTextSize(0.6); but5->SetFillColor(2); but5->SetName("logBut5"); TButton *but6 = new TButton("???", "EVD->ScanID=6; EVD->ChangeLogButColor();", 0.,0.575,0.1275,0.6375); but6->SetTextSize(0.6); but6->SetFillColor(2); but6->SetName("logBut6"); TButton *but8 = new TButton("QE", "EVD->ScanTop=1; EVD->ChangeLogButColor();", 0.1275,0.85625,0.195,0.95); but8->SetTextSize(0.4); but8->SetFillColor(2); but8->SetName("logBut8"); TButton *but9 = new TButton("RES", "EVD->ScanTop=2; EVD->ChangeLogButColor();", 0.1275,0.7625,0.195,0.85625); but9->SetTextSize(0.4); but9->SetFillColor(2); but9->SetName("logBut9"); TButton *but10 = new TButton("DIS", "EVD->ScanTop=3; EVD->ChangeLogButColor();", 0.1275,0.66875,0.195,0.7625); but10->SetTextSize(0.4); but10->SetFillColor(2); but10->SetName("logBut10"); TButton *but11 = new TButton("???", "EVD->ScanTop=4; EVD->ChangeLogButColor();", 0.1275,0.575,0.195,0.66875); but11->SetTextSize(0.4); but11->SetFillColor(2); but11->SetName("logBut11"); TButton *but12 = new TButton("Log Details","EVD->Log();", 0.,0.5,0.195,0.575); but12->SetTextSize(0.6); but12->SetFillColor(4); TButton *but7 = new TButton("Click for Info", "EVD->PrintHSHelp();", 0.,0.95,0.195,1.0); but7->SetTextSize(0.6); but7->SetFillColor(45); but1->Draw(); but2->Draw(); but3->Draw(); but4->Draw(); but5->Draw(); but6->Draw(); but7->Draw(); but8->Draw(); but9->Draw(); but10->Draw(); but11->Draw(); but12->Draw(); }

---

Member Data Documentation

Float_t MadScanDisplay::Dmid_val [protected]

Definition at line 19 of file MadScanDisplay.h. Referenced by DrawKey(), DrawKey2(), MadScanDisplay(), and SetDVals().

Bool_t MadScanDisplay::drawSAME

Definition at line 74 of file MadScanDisplay.h. Referenced by MadScanDisplay().

Float_t MadScanDisplay::Dspe_val [protected]

Definition at line 18 of file MadScanDisplay.h. Referenced by DrawKey(), DrawKey2(), MadScanDisplay(), and SetDVals().

bool MadScanDisplay::fAltDisplay

Definition at line 81 of file MadScanDisplay.h. Referenced by MadScanDisplay().

Int_t MadScanDisplay::fDefaultShowerMarkerColor [private]

Definition at line 103 of file MadScanDisplay.h. Referenced by Display(), and SetDefaultShowerMarkerColor().

Int_t MadScanDisplay::fDefaultShowerMarkerStyle [private]

Definition at line 104 of file MadScanDisplay.h. Referenced by Display(), and SetDefaultShowerMarkerStyle().

bool MadScanDisplay::fHaveNeatoEvents [private]

Definition at line 101 of file MadScanDisplay.h. Referenced by ReadEventsFile().

Int_t MadScanDisplay::fNeatoEventIdx [private]

Definition at line 102 of file MadScanDisplay.h. Referenced by NextInterestingEvent().

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

Definition at line 100 of file MadScanDisplay.h. Referenced by NextInterestingEvent(), and ReadEventsFile().

bool MadScanDisplay::fSetFidSet [private]

Definition at line 105 of file MadScanDisplay.h. Referenced by MadScanDisplay().

Bool_t MadScanDisplay::handScan

Definition at line 77 of file MadScanDisplay.h. Referenced by EnableHandScan(), and MadScanDisplay().

Int_t MadScanDisplay::LeAction

Definition at line 65 of file MadScanDisplay.h. Referenced by DrawButtons(), and MadScanDisplay().

Bool_t MadScanDisplay::LeAutoMat

Definition at line 73 of file MadScanDisplay.h. Referenced by JumpTo(), MadScanDisplay(), NextEvt(), NextFidNoTrk(), NextFidTrk(), NextInterestingEvent(), NextPass(), PrevEvt(), PrevFidNoTrk(), PrevFidTrk(), PrevPass(), and SkipTo().

Bool_t MadScanDisplay::LeClus

Definition at line 67 of file MadScanDisplay.h. Referenced by Display(), and MadScanDisplay().

Int_t MadScanDisplay::LeEntry

Definition at line 71 of file MadScanDisplay.h. Referenced by MadScanDisplay().

Int_t MadScanDisplay::LeEvent

Definition at line 68 of file MadScanDisplay.h. Referenced by Display(), DrawTextBox(), MadScanDisplay(), NextEvt(), NextFidNoTrk(), NextFidTrk(), NextPass(), PrevEvt(), PrevFidNoTrk(), PrevFidTrk(), and PrevPass().

Bool_t MadScanDisplay::LeLego

Definition at line 66 of file MadScanDisplay.h. Referenced by Display(), and MadScanDisplay().

Int_t MadScanDisplay::LeMCevent

Definition at line 70 of file MadScanDisplay.h. Referenced by Display(), DrawTextBox(), MadScanDisplay(), NextEvt(), NextFidNoTrk(), NextFidTrk(), NextPass(), PrevEvt(), PrevFidNoTrk(), PrevFidTrk(), and PrevPass().

Int_t MadScanDisplay::LeNu

Definition at line 64 of file MadScanDisplay.h. Referenced by DrawButtons(), MadScanDisplay(), NextPass(), and PrevPass().

Int_t MadScanDisplay::LeSlice

Definition at line 69 of file MadScanDisplay.h. Referenced by Display(), DrawTextBox(), MadScanDisplay(), NextEvt(), NextFidNoTrk(), NextFidTrk(), NextPass(), PrevEvt(), PrevFidNoTrk(), PrevFidTrk(), and PrevPass().

char MadScanDisplay::logFileName[256]

Definition at line 80 of file MadScanDisplay.h. Referenced by EnableHandScan(), Log(), and MadScanDisplay().

char MadScanDisplay::printName[100] [protected]

Definition at line 15 of file MadScanDisplay.h. Referenced by Display(), and PrintDisplay().

char MadScanDisplay::printOpt[10] [protected]

Definition at line 16 of file MadScanDisplay.h. Referenced by MadScanDisplay(), and SetPrintOpt().

Bool_t MadScanDisplay::ptt_msg [protected]

Definition at line 21 of file MadScanDisplay.h. Referenced by MadScanDisplay(), and SetMessages().

Int_t MadScanDisplay::ScanID

Definition at line 78 of file MadScanDisplay.h. Referenced by ChangeLogButColor(), Display(), Log(), and MadScanDisplay().

Int_t MadScanDisplay::ScanTop

Definition at line 79 of file MadScanDisplay.h. Referenced by ChangeLogButColor(), Display(), Log(), and MadScanDisplay().

ScanFrame* MadScanDisplay::SFrame

Definition at line 75 of file MadScanDisplay.h. Referenced by Display(), DrawTextBox(), FindUnSliced(), InFidNoTrk(), InFidTrk(), MadScanDisplay(), NextEvt(), NextFidNoTrk(), NextFidTrk(), NextInterestingEvent(), PrevEvt(), PrevPass(), ROICalc(), and ShwROICalc().

Bool_t MadScanDisplay::UseNuInfo

Definition at line 72 of file MadScanDisplay.h. Referenced by MadScanDisplay(), NextPass(), and PrevPass().

---

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

• MadScanDisplay.h
• MadScanDisplay.cxx

---