/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86

Bug Summary

File:	alld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h
Warning:	line 398, column 7 Null pointer passed to 2nd parameter expecting 'nonnull'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -main-file-name hdv_mainframe.cc -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /w/halld-scifs17exp/home/sdobbs/clang/llvm-project/install/lib/clang/12.0.0 -D HAVE_CCDB -D HAVE_RCDB -D HAVE_EVIO -D HAVE_TMVA=1 -D RCDB_MYSQL=1 -D RCDB_SQLITE=1 -D SQLITE_USE_LEGACY_STRUCT=ON -I .Linux_CentOS7.7-x86_64-gcc4.8.5/programs/Analysis/hdview2 -I programs/Analysis/hdview2 -I . -I libraries -I libraries/include -I /w/halld-scifs17exp/home/sdobbs/clang/halld_recon/Linux_CentOS7.7-x86_64-gcc4.8.5/include -I external/xstream/include -I /usr/include/tirpc -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/root/root-6.08.06/include -I /w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/ccdb/ccdb_1.06.06/include -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/rcdb/rcdb_0.06.00/cpp/include -I /usr/include/mysql -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/sqlitecpp/SQLiteCpp-2.2.0^bs130/include -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/sqlite/sqlite-3.13.0^bs130/include -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/hdds/hdds-4.9.0/Linux_CentOS7.7-x86_64-gcc4.8.5/src -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/xerces-c/xerces-c-3.1.4/include -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/evio/evio-4.4.6/Linux-x86_64/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../include/c++/4.8.5 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../include/c++/4.8.5/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../include/c++/4.8.5/backward -internal-isystem /usr/local/include -internal-isystem /w/halld-scifs17exp/home/sdobbs/clang/llvm-project/install/lib/clang/12.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /home/sdobbs/work/clang/halld_recon/src -ferror-limit 19 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -o /tmp/scan-build-2021-01-21-110224-160369-1 -x c++ programs/Analysis/hdview2/hdv_mainframe.cc

programs/Analysis/hdview2/hdv_mainframe.cc

→


2#include <iostream>
3#include <iomanip>
4#include <sstream>
5#include <cmath>
6#include <fstream>
7using namespace std;

9#include <unistd.h>
10#include <pthread.h>
11#include <sys/time.h>

13#include <TRACKING/DMCThrown.h>
14#include "hdv_mainframe.h"
15#include "hdview2.h"
16#include "MyProcessor.h"
17#include "FDC/DFDCGeometry.h"
18#include "FCAL/DFCALGeometry.h"
19#include "TOF/DTOFGeometry.h"
20#include "DVector2.h"
21#include "HDGEOMETRY/DGeometry.h"
22#include <PID/DNeutralParticle.h>
23#include <DAQ/DEPICSvalue.h>

25#include <TPolyMarker.h>
26#include <TLine.h>
27#include <TMarker.h>
28#include <TBox.h>
29#include <TVector3.h>
30#include <TGeoVolume.h>
31#include <TGeoManager.h>
32#include <TGLabel.h>
33#include <TGComboBox.h>
34#include <TGButton.h>
35#include <TGButtonGroup.h>
36#include <TGTextEntry.h>
37#include <TArrow.h>
38#include <TLatex.h>
39#include <TColor.h>
40#include <TMath.h>
41#include <TArc.h>

43extern JApplication *japp;
44//TGeoVolume *MOTHER = NULL;
45//TGeoCombiTrans *MotherRotTrans = NULL;

47extern int GO;
48extern bool SKIP_EPICS_EVENTS;

50// These values are just used to draw the detectors for visualization.
51// These should be replaced by a database lookup or something similar
52// at some point.
53static float BCAL_Rmin=65.0;
54static float BCAL_Rmax = 87.46;
55static float BCAL_MIDRAD = 77.0;
56static float BCAL_Zlen = 390.0;
57static float BCAL_Zmin = 212.0 - BCAL_Zlen/2.0;
58static float BCAL_MODS  = 48;
59static float BCAL_LAYS1 =  3;
60//static float BCAL_LAYS2 =  4; 
61static float BCAL_SECS1 =  4; 
62static float BCAL_SECS2 =  4;
63static float BCAL_PHI_SHIFT = 0.0; // radians (will be overwritten in constructor!)
64static float FCAL_Zlen = 45.0;
65static float FCAL_Zmin = 622.8;
66static float FCAL_Rmin = 6.0;
67static float FCAL_Rmax = 212.0/2.0;
68static float CCAL_Zlen = 18.0;
69static float CCAL_Zmin = 876.106;
70static float CCAL_Rmin = 2.0;
71static float CCAL_Rmax = 24.0;
72static float CDC_Rmin = 9.0;
73static float CDC_Rmax = 59.0;
74static float CDC_Zlen = 150.0;
75static float CDC_Zmin = 17.0;
76static float TOF_Rmax = 125.0;
77static float TOF_Rmin = 6.0;
78static float TOF_Zlen = 2.54;
79static float TOF_Zmin = 618.8;
80static float FDC_Rmin = 3.5;
81static float FDC_Rmax = 48.5;
82static float TARGET_Zmid = 65.0;
83static float TARGET_Zlen = 30.0;

85static DFCALGeometry *fcalgeom = NULL__null;
86static DTOFGeometry *tofgeom = NULL__null;

88static vector<vector <DFDCWire *> >fdcwires;

90//-------------------
91// Constructor
92//-------------------
93hdv_mainframe::hdv_mainframe(const TGWindow *p, UInt_t w, UInt_t h):TGMainFrame(p,w,h)
94{
//Get pointer to DGeometry object
DApplication* dapp=dynamic_cast<DApplication*>(japp);
const DGeometry *dgeom  = dapp->GetDGeometry(RUNNUMBER);

tofgeom = new DTOFGeometry(dgeom);
fcalgeom= new DFCALGeometry(dgeom);

dgeom->GetFDCWires(fdcwires);

// Get Target parameters from XML
double my_TARGET_Zmid = TARGET_Zmid;
double my_TARGET_Zlen = TARGET_Zlen;
dgeom->GetTargetZ(my_TARGET_Zmid);
dgeom->GetTargetLength(my_TARGET_Zlen);
TARGET_Zmid = my_TARGET_Zmid;
TARGET_Zlen = my_TARGET_Zlen;

// Get overall phi shift of BCAL
float my_BCAL_PHI_SHIFT;
dgeom->GetBCALPhiShift(my_BCAL_PHI_SHIFT);
BCAL_PHI_SHIFT = my_BCAL_PHI_SHIFT*TMath::DegToRad();  // convert to radians

UInt_t MainWidth = w;

// First, define all of the of the graphics objects. Below that, make all
// of the connections to the methods so these things will work!

// Use the "color wheel" rather than the classic palette.
//TColor::CreateColorWheel();

// The main GUI window is divided into three sections, top, middle, and bottom.
// Create those frames here.
TGLayoutHints *hints = new TGLayoutHints(kLHintsNormal|kLHintsExpandX|kLHintsExpandY|kLHintsLeft, 5,5,5,5);
TGLayoutHints *lhints = new TGLayoutHints(kLHintsNormal, 2,2,2,2);
TGLayoutHints *rhints = new TGLayoutHints(kLHintsCenterY|kLHintsRight, 2,2,2,2);
TGLayoutHints *chints = new TGLayoutHints(kLHintsCenterY|kLHintsCenterX, 2,2,2,2);
TGLayoutHints *bhints = new TGLayoutHints(kLHintsBottom|kLHintsCenterX, 2,2,2,2);
//TGLayoutHints *tofhints = new TGLayoutHints(kLHintsBottom|kLHintsCenterX, 2,2,2,2);
TGLayoutHints *xhints = new TGLayoutHints(kLHintsNormal|kLHintsExpandX, 2,2,2,2);
TGLayoutHints *yhints = new TGLayoutHints(kLHintsNormal|kLHintsExpandY, 2,2,2,2);
TGLayoutHints *dhints = new TGLayoutHints(kLHintsLeft|kLHintsCenterY, 0,0,0,0);
TGLayoutHints *ehints = new TGLayoutHints(kLHintsNormal, 2,2,0,0);
TGLayoutHints *thints = new TGLayoutHints(kLHintsTop|kLHintsCenterX, 2,2,0,0);
TGLayoutHints *lxhints = new TGLayoutHints(kLHintsLeft|kLHintsExpandX, 2,2,0,0);
TGHorizontalFrame *sourceframe = new TGHorizontalFrame(this,w,20);
TGHorizontalFrame *topframe = new TGHorizontalFrame(this, w, 200);
//	TGHorizontalFrame *midframe = new TGHorizontalFrame(this, w, 200);
TGCompositeFrame *midframe = new TGCompositeFrame(this, w, 200, kHorizontalFrame);
TGHorizontalFrame *botframe = new TGHorizontalFrame(this, w, 200);
AddFrame(sourceframe, lxhints);
AddFrame(topframe, lhints);
AddFrame(midframe, lhints);
AddFrame(botframe, lhints);

//========== Source ===========
TGLabel *sourcelab = new TGLabel(sourceframe, "Source:");
sourceframe->AddFrame(sourcelab,ehints);
source = new TGLabel(sourceframe, "--");
sourceframe->AddFrame(source, lxhints);
source->SetTextJustify(1);

//========== TOP FRAME ============
TGGroupFrame *viewcontrols = new TGGroupFrame(topframe, "View Controls", kHorizontalFrame);
TGGroupFrame *eventcontrols = new TGGroupFrame(topframe, "Event Controls", kHorizontalFrame);
TGGroupFrame *eventinfo = new TGGroupFrame(topframe, "Info", kHorizontalFrame);
TGGroupFrame *inspectors = new TGGroupFrame(topframe, "Inspectors", kVerticalFrame);
TGHorizontalFrame *programcontrols = new TGHorizontalFrame(topframe);
topframe->AddFrame(viewcontrols, lhints);
topframe->AddFrame(eventcontrols, hints);
topframe->AddFrame(eventinfo, yhints);
topframe->AddFrame(inspectors, yhints);
topframe->AddFrame(programcontrols, yhints);

//-------------Pan buttons
TGVerticalFrame *panneg = new TGVerticalFrame(viewcontrols);
TGVerticalFrame *panpos = new TGVerticalFrame(viewcontrols);
viewcontrols->AddFrame(panneg,	hints);
viewcontrols->AddFrame(panpos,	hints);
TGTextButton *panxneg	= new TGTextButton(panneg,	"-X");
TGTextButton *panyneg	= new TGTextButton(panneg,	"-Y");
TGTextButton *panzneg	= new TGTextButton(panneg,	"-Z");
panneg->AddFrame(panxneg,	dhints);
panneg->AddFrame(panyneg,	dhints);
panneg->AddFrame(panzneg,	dhints);

TGTextButton *panxpos	= new TGTextButton(panpos,	"X+");
TGTextButton *panypos	= new TGTextButton(panpos,	"Y+");
TGTextButton *panzpos	= new TGTextButton(panpos,	"Z+");
panpos->AddFrame(panxpos,	dhints);
panpos->AddFrame(panypos,	dhints);
panpos->AddFrame(panzpos,	dhints);

panxneg->Connect("Clicked()","hdv_mainframe",this,"DoPanXneg()");
panyneg->Connect("Clicked()","hdv_mainframe",this,"DoPanYneg()");
panzneg->Connect("Clicked()","hdv_mainframe",this,"DoPanZneg()");
panxpos->Connect("Clicked()","hdv_mainframe",this,"DoPanXpos()");
panypos->Connect("Clicked()","hdv_mainframe",this,"DoPanYpos()");
panzpos->Connect("Clicked()","hdv_mainframe",this,"DoPanZpos()");
//------------- Zoom/Reset buttons
TGVerticalFrame *zoom = new TGVerticalFrame(viewcontrols);
viewcontrols->AddFrame(zoom,	lhints);
TGGroupFrame *zoomframe = new TGGroupFrame(zoom, "ZOOM", kHorizontalFrame);
zoom->AddFrame(zoomframe,	thints);
TGTextButton *zoomout = new TGTextButton(zoomframe,	" - ");
TGTextButton *zoomin	= new TGTextButton(zoomframe,	" + ");
zoomframe->AddFrame(zoomout,	thints);
zoomframe->AddFrame(zoomin,	thints);
TGTextButton *reset	= new TGTextButton(zoom,	"Reset");
zoom->AddFrame(reset, chints);

//-------------- Transverse Coordinates
TGVButtonGroup *coordinates = new TGVButtonGroup(viewcontrols,"Transverse Coordinates");
viewcontrols->AddFrame(coordinates,	lhints);
TGRadioButton *xy = new TGRadioButton(coordinates, "x/y");
new TGRadioButton(coordinates, "r/phi");

//-------------- Next, Previous
prev	= new TGTextButton(eventcontrols,	"<-- Prev");
next	= new TGTextButton(eventcontrols,	"Next -->");
TGVerticalFrame *contf = new TGVerticalFrame(eventcontrols);
eventcontrols->AddFrame(prev, chints);
eventcontrols->AddFrame(next, chints);
eventcontrols->AddFrame(contf, lhints);

// continuous, delay
checkbuttons["continuous"] = new TGCheckButton(contf, "continuous");
TGHorizontalFrame *delayf = new TGHorizontalFrame(contf);
contf->AddFrame(checkbuttons["continuous"], lhints);
contf->AddFrame(delayf, lhints);
TGLabel *delaylab = new TGLabel(delayf, "delay:");
delay = new TGComboBox(delayf, "0.25");
delay->Resize(50,20);
float delays[]={0, 0.25, 0.5, 1, 2, 3, 5, 10};
for(int i=0; i<8; i++){
  stringstream ss;
  ss<<delays[i];
  delay->AddEntry(ss.str().c_str(),i);
}
delayf->AddFrame(delaylab, lhints);
delayf->AddFrame(delay, lhints);

//----------------- Event Info
TGVerticalFrame *eventlabs = new TGVerticalFrame(eventinfo);
TGVerticalFrame *eventvals = new TGVerticalFrame(eventinfo);
eventinfo->AddFrame(eventlabs, lhints);
eventinfo->AddFrame(eventvals, lhints);

TGLabel *runlab = new TGLabel(eventlabs, "Run:");
TGLabel *eventlab = new TGLabel(eventlabs, "Event:");
TGLabel *triglab = new TGLabel(eventlabs, "GTP bits:");
run = new TGLabel(eventvals, "--------------");
event = new TGLabel(eventvals, "--------------");
trig = new TGLabel(eventvals, "--------------");
eventlabs->AddFrame(runlab, rhints);
eventlabs->AddFrame(eventlab,rhints);
eventlabs->AddFrame(triglab,rhints);
eventvals->AddFrame(run, lhints);
eventvals->AddFrame(event, lhints);
eventvals->AddFrame(trig, lhints);

//----------------- Inspectors
TGTextButton *trackinspector	= new TGTextButton(inspectors,	"Track Inspector");
//TGTextButton *tofinspector	= new TGTextButton(inspectors,	"TOF Inspector");
//TGTextButton *bcalinspector	= new TGTextButton(inspectors,	"BCAL Inspector");
//TGTextButton *fcalinspector	= new TGTextButton(inspectors,	"FCAL Inspector");
inspectors->AddFrame(trackinspector, xhints);
//inspectors->AddFrame(tofinspector, xhints);
//inspectors->AddFrame(bcalinspector, xhints);
//inspectors->AddFrame(fcalinspector, xhints);
//tofinspector->SetEnabled(kFALSE);
//bcalinspector->SetEnabled(kFALSE);
//fcalinspector->SetEnabled(kFALSE);

//-------------- Program Controls
TGTextButton *quit	= new TGTextButton(programcontrols,	"&Quit");
programcontrols->AddFrame(quit, new TGLayoutHints(kLHintsTop|kLHintsRight|kLHintsExpandX, 2,2,2,2));

//========== MID FRAME ============
TGHorizontalFrame *detectorframe = new TGHorizontalFrame(midframe);
midframe->AddFrame(detectorframe, hints);

//------ Detector Frame ------
TGVerticalFrame *sideviews = new TGVerticalFrame(detectorframe);
TGVerticalFrame *endviews = new TGVerticalFrame(detectorframe);
TGVerticalFrame *drawopts = new TGVerticalFrame(detectorframe);
TGVerticalFrame *caloColorCodes = new TGVerticalFrame(detectorframe);		
detectorframe->AddFrame(sideviews, lhints);
detectorframe->AddFrame(endviews, lhints);
detectorframe->AddFrame(caloColorCodes, lhints);
detectorframe->AddFrame(drawopts, lhints);

// Side views
int width = MainWidth/6*2;
TGHorizontalFrame *sideviewAframe = new TGHorizontalFrame(sideviews);
TGHorizontalFrame *sideviewBframe = new TGHorizontalFrame(sideviews);
sideviews->AddFrame(sideviewAframe, lhints);
sideviews->AddFrame(sideviewBframe, lhints);
sideviewA = new TRootEmbeddedCanvas("sideviewA Canvas", sideviewAframe, width, width/2, kSunkenFrame, GetWhitePixel());
sideviewB = new TRootEmbeddedCanvas("sideviewB Canvas", sideviewBframe, width, width/2, kSunkenFrame, GetWhitePixel());
sideviewAframe->AddFrame(sideviewA, lhints);
sideviewBframe->AddFrame(sideviewB, lhints);
sideviewA->SetScrolling(TGCanvas::kCanvasScrollBoth);
sideviewB->SetScrolling(TGCanvas::kCanvasScrollBoth);
sideviewA->SetBackgroundColor(0xafeeee);
sideviewB->SetBackgroundColor(0xafeeee);

// End views
endviewA = new TRootEmbeddedCanvas("endviewA Canvas", endviews, width/2, width/2, kSunkenFrame, GetWhitePixel());
endviewB = new TRootEmbeddedCanvas("endviewB Canvas", endviews, width/2, width/2, kSunkenFrame, GetWhitePixel());
endviews->AddFrame(endviewA, lhints);
endviews->AddFrame(endviewB, lhints);
endviewA->SetScrolling(TGCanvas::kCanvasScrollBoth);
endviewB->SetScrolling(TGCanvas::kCanvasScrollBoth);
endviewA->GetCanvas()->SetFillColor(kGray+1);
endviewB->GetCanvas()->SetFillColor(kGray+1);

// Draw opts
TGGroupFrame *trkdrawopts = new TGGroupFrame(drawopts, "Track Draw Options", kVerticalFrame);
TGGroupFrame *hitdrawopts = new TGGroupFrame(drawopts, "Hit Draw Options", kVerticalFrame);
drawopts->AddFrame(trkdrawopts, lhints);
drawopts->AddFrame(hitdrawopts, lhints);

// Track
TGHorizontalFrame *candidatesf = new TGHorizontalFrame(trkdrawopts);
checkbuttons["candidates"]	= new TGCheckButton(candidatesf,	"DTrackCandidate:");
candidatesfactory = new TGComboBox(candidatesf, "<default>", 0);
candidatesfactory->Resize(80,20);
candidatesf->AddFrame(checkbuttons["candidates"], lhints);
for(int i=0; i<100; i++)candidatesfactory->AddEntry("a",i); 
// For some reason, this is needed for ROOT >5.14 (??!!!) real entries are filled in later
candidatesf->AddFrame(candidatesfactory, lhints);
trkdrawopts->AddFrame(candidatesf, lhints);

TGHorizontalFrame *wiretracksf		= new TGHorizontalFrame(trkdrawopts);
checkbuttons["wiretracks"]		= new TGCheckButton(wiretracksf,	"DTrackWireBased:");
wiretracksfactory	= new TGComboBox(wiretracksf, "<default>", 0);
wiretracksfactory->Resize(80,20);
wiretracksf->AddFrame(checkbuttons["wiretracks"], lhints);
for(int i=0; i<100; i++)wiretracksfactory->AddEntry("a",i); 
// For some reason, this is needed for ROOT >5.14 (??!!!) real entries are filled in later
wiretracksf->AddFrame(wiretracksfactory, lhints);
trkdrawopts->AddFrame(wiretracksf, lhints);

TGHorizontalFrame *timetracksf		= new TGHorizontalFrame(trkdrawopts);
checkbuttons["timetracks"]		= new TGCheckButton(timetracksf,	"DTrackTimeBased:");
timetracksfactory	= new TGComboBox(timetracksf, "<default>", 0);
timetracksfactory->Resize(80,20);
timetracksf->AddFrame(checkbuttons["timetracks"], lhints);
for(int i=0; i<100; i++)timetracksfactory->AddEntry("a",i); 
// For some reason, this is needed for ROOT >5.14 (??!!!) real entries are filled in later
timetracksf->AddFrame(timetracksfactory, lhints);
trkdrawopts->AddFrame(timetracksf, lhints);
TGHorizontalFrame *chargedtracksf		= new TGHorizontalFrame(trkdrawopts);
checkbuttons["chargedtracks"]		= new TGCheckButton(chargedtracksf,	"DChargedTrack:");
chargedtracksfactory	= new TGComboBox(chargedtracksf, "<default>", 0);
chargedtracksfactory->Resize(80,20);
chargedtracksf->AddFrame(checkbuttons["chargedtracks"], lhints);
for(int i=0; i<100; i++)chargedtracksfactory->AddEntry("a",i); 
// For some reason, this is needed for ROOT >5.14 (??!!!) real entries are filled in later
chargedtracksf->AddFrame(chargedtracksfactory, lhints);
trkdrawopts->AddFrame(chargedtracksf, lhints);

checkbuttons["neutrals"]     = new TGCheckButton(trkdrawopts,"DNeutralParticle");
checkbuttons["thrown"]       = new TGCheckButton(trkdrawopts,"DMCThrown");
checkbuttons["trajectories"] = new TGCheckButton(trkdrawopts,	"DMCTrajectoryPoint");
trkdrawopts->AddFrame(checkbuttons["neutrals"], lhints);
trkdrawopts->AddFrame(checkbuttons["thrown"], lhints);
trkdrawopts->AddFrame(checkbuttons["trajectories"], lhints);

// Hit
checkbuttons["cdc"]		= new TGCheckButton(hitdrawopts,	"CDC");
checkbuttons["cdcdrift"]	= new TGCheckButton(hitdrawopts,	"CDC Drift Time");
checkbuttons["cdctruth"]	= new TGCheckButton(hitdrawopts,	"CDCTruth");
checkbuttons["fdcwire"]		= new TGCheckButton(hitdrawopts,	"FDC Wire");
checkbuttons["fdcpseudo"]	= new TGCheckButton(hitdrawopts,	"FDC Pseudo");
checkbuttons["fdctruth"]	= new TGCheckButton(hitdrawopts,	"FDCTruth");
checkbuttons["tof"]		= new TGCheckButton(hitdrawopts,	"TOF");
checkbuttons["toftruth"]	= new TGCheckButton(hitdrawopts,	"TOFTruth");
checkbuttons["fcal"]		= new TGCheckButton(hitdrawopts,	"FCAL");
checkbuttons["bcal"]		= new TGCheckButton(hitdrawopts,	"BCAL");
checkbuttons["ccal"]		= new TGCheckButton(hitdrawopts,	"CCAL");

hitdrawopts->AddFrame(checkbuttons["cdc"], lhints);
hitdrawopts->AddFrame(checkbuttons["cdcdrift"], lhints);
hitdrawopts->AddFrame(checkbuttons["cdctruth"], lhints);
hitdrawopts->AddFrame(checkbuttons["fdcwire"], lhints);
hitdrawopts->AddFrame(checkbuttons["fdcpseudo"], lhints);
hitdrawopts->AddFrame(checkbuttons["fdctruth"], lhints);
hitdrawopts->AddFrame(checkbuttons["tof"], lhints);
hitdrawopts->AddFrame(checkbuttons["toftruth"], lhints);
hitdrawopts->AddFrame(checkbuttons["fcal"], lhints);
hitdrawopts->AddFrame(checkbuttons["bcal"], lhints);
hitdrawopts->AddFrame(checkbuttons["ccal"], lhints);

TGTextButton *moreOptions	= new TGTextButton(hitdrawopts,	"More options");
hitdrawopts->AddFrame(moreOptions, lhints);

// Color codes
TGGroupFrame *bcalColorCodes = new TGGroupFrame(caloColorCodes, "BCAL colors", kVerticalFrame);
TGGroupFrame *fcalColorCodes = new TGGroupFrame(caloColorCodes, "FCAL colors", kVerticalFrame);
TGTextButton *debuger       = new TGTextButton(caloColorCodes,"Debugger");
TGTextButton *bcaldisp       = new TGTextButton(caloColorCodes,"BcalDisp");

caloColorCodes->AddFrame(bcalColorCodes, thints);
caloColorCodes->AddFrame(debuger,lhints);
caloColorCodes->AddFrame(bcaldisp,lhints);
caloColorCodes->AddFrame(fcalColorCodes, bhints);
bcalColorCodes->SetWidth(30);
fcalColorCodes->SetWidth(30);

// color lables BCAL
TGLabel* BCCLables[9]; 
unsigned int BCccodes[9] = {0x0000FF,0x7700FF,0xFF00FF,0xFF0077,0xFF0000,0xFF7700,0xFFFF00,0xFFFF77,0xFFFFFF};
for (int i=0;i<9;i++) {
  double e = pow(10,((8-(double)i)/2.0));
  char str1[128];
  if (e >= 1000) {
    sprintf(str1,"%7.2f GeV",e/1000.);
  } else {
    sprintf(str1,"%7.1f MeV",e);
  }
  BCCLables[i] =  new TGLabel(bcalColorCodes, (const char*)str1);
  //BCCLables[i]->SetTextColor(1);
  BCCLables[i]->SetBackgroundColor(BCccodes[i]);
  bcalColorCodes->AddFrame(BCCLables[i],lhints);
}
// color lables FCAL
TGLabel* FCCLables[9]; 
unsigned int FCccodes[9] = {0x0000FF,0x7700FF,0xFF00FF,0xFF0077,0xFF0000,0xFF7700,0xFFFF00,0xFFFF77,0xFFFFFF};
for (int i=0;i<9;i++) {
  double e = pow(10,((8-(double)i)/2.0));
  char str1[128];
  if (e >= 1000) {
    sprintf(str1,"%7.2f GeV",e/1000.);
  } else {
    sprintf(str1,"%7.1f MeV",e);
  }
  FCCLables[i] =  new TGLabel(fcalColorCodes, (const char*)str1);
  FCCLables[i]->SetBackgroundColor(FCccodes[i]);
  fcalColorCodes->AddFrame(FCCLables[i],lhints);
}

//========== BOT FRAME ============
TGGroupFrame *trackinfo = new TGGroupFrame(botframe, "Track Info", kHorizontalFrame);
botframe->AddFrame(trackinfo, xhints);

//------ Track Info ------
throwninfo = new TGGroupFrame(trackinfo, "Thrown", kHorizontalFrame);
reconinfo = new TGGroupFrame(trackinfo, "Reconstructed", kHorizontalFrame);
trackinfo->AddFrame(throwninfo, lhints);
trackinfo->AddFrame(reconinfo, lhints);

// Column names
vector<string> colnames;
colnames.push_back("trk");
colnames.push_back("type");
colnames.push_back("p");
colnames.push_back("theta");
colnames.push_back("phi");
colnames.push_back("z");
colnames.push_back("chisq/Ndof");
colnames.push_back("Ndof");
colnames.push_back("FOM");	
colnames.push_back("cand");

// Create a vertical frame for each column and insert the label as the first item
for(unsigned int i=0; i<colnames.size(); i++){
  // create frames
  TGVerticalFrame *tf = new TGVerticalFrame(throwninfo);
  TGVerticalFrame *rf = new TGVerticalFrame(reconinfo);
  throwninfo->AddFrame(tf, bhints);
  reconinfo->AddFrame(rf, bhints);
  
  // create column labels
  string lab = colnames[i]+":";
  TGLabel *tl = new TGLabel(tf, lab.c_str());
  TGLabel *rl = new TGLabel(rf, lab.c_str());
  if(i<6)tf->AddFrame(tl, chints);
  rf->AddFrame(rl, chints);
  vector<TGLabel*> tv;
  vector<TGLabel*> rv;
  tv.push_back(tl);
  rv.push_back(rl);
  
  // Add 8 labels to each column
  // These have to be added in reverse order so we can pack them from
  // the bottom. Otherwise, it doesn't draw correctly.
  for(int j=0; j<14; j++){
    stringstream ss;
    ss<<(5-j);
    if(i<6)tl = new TGLabel(tf, i==0 ? ss.str().c_str():"--------");
    rl = new TGLabel(rf, i==0 ? ss.str().c_str():"--------");
    if(i<6)tf->AddFrame(tl, bhints);
    rf->AddFrame(rl, bhints);
    tv.push_back(tl);
    rv.push_back(rl);
  }
  
  // Record the label object pointers for later use
  thrownlabs[colnames[i]] = tv;
  reconlabs[colnames[i]] = rv;
}

// Reconstruction factory and full list button
TGVerticalFrame *vf = new TGVerticalFrame(reconinfo);
reconinfo->AddFrame(vf, yhints);
reconfactory = new TGComboBox(vf, "DTrackCandidate:", 0);
reconfactory->Resize(160,20);
for(int i=0; i<100; i++)reconfactory->AddEntry("a",i); // For some reason, this is needed for ROOT >5.14 (??!!!) real entries are filled in later
vf->AddFrame(reconfactory, thints);

TGTextButton *listall	= new TGTextButton(vf,	"Full List");
vf->AddFrame(listall, new TGLayoutHints(kLHintsBottom|kLHintsExpandX, 2,2,2,2));

// Pointers to optional daughter windows (these must be done before ReadPreferences in
// order for the options they implement to be filled into checkbuttons)
trkmf = NULL__null;
bcaldispmf = NULL__null;
optionsmf = new hdv_optionsframe(this, NULL__null, 100, 100);
debugermf = new hdv_debugerframe(this, NULL__null, 800, 800);
fulllistmf = new hdv_fulllistframe(this, NULL__null, 100, 100);
endviewAmf = new hdv_endviewAframe(this, NULL__null, 600, 600);
endviewBmf = new hdv_endviewBframe(this, NULL__null, 600, 600);

//&&&&&&&&&&&&&&&& Defaults
ReadPreferences();
xy->SetState(kButtonDown,kTRUE);
coordinatetype = COORD_XY;
r0 = 50.0;
phi0 = M_PI3.14159265358979323846;
x0 = 0.0;
y0 = 0.0;
z0 = 350.0;
zoom_factor = 1.0;

//&&&&&&&&&&&&&&&& Connections
zoomin->Connect("Clicked()","hdv_mainframe", this, "DoZoomIn()");
zoomout->Connect("Clicked()","hdv_mainframe", this, "DoZoomOut()");
reset->Connect("Clicked()","hdv_mainframe", this, "DoReset()");

coordinates->Connect("Clicked(Int_t)","hdv_mainframe", this, "DoSetCoordinates(Int_t)");
coordinates->Connect("Clicked(Int_t)","hdv_mainframe", this, "DoMyRedraw()");

quit->Connect("Clicked()","hdv_mainframe", this, "DoQuit()");
this->Connect("CloseWindow()", "hdv_mainframe", this, "DoQuit()");
this->DontCallClose();
next->Connect("Clicked()","hdv_mainframe", this, "DoNext()");
prev->Connect("Clicked()","hdv_mainframe", this, "DoPrev()");
checkbuttons["continuous"]->Connect("Clicked()","hdv_mainframe", this, "DoCont()");
delay->Connect("Selected(Int_t)","hdv_mainframe", this, "DoSetDelay(Int_t)");

trackinspector->Connect("Clicked()","hdv_mainframe", this, "DoOpenTrackInspector()");
moreOptions->Connect("Clicked()","hdv_mainframe", this, "DoOpenOptionsWindow()");
listall->Connect("Clicked()","hdv_mainframe", this, "DoOpenFullListWindow()");
debuger->Connect("Clicked()","hdv_mainframe", this, "DoOpenDebugerWindow()");
bcaldisp->Connect("Clicked()","hdv_mainframe", this, "DoBcalDispFrame()");
//tofinspector->Connect("Clicked()","hdv_mainframe", this, "DoOpenTOFInspector()");
//fcalinspector->Connect("Clicked()","hdv_mainframe", this, "DoOpenFCALInspector()");
//bcalinspector->Connect("Clicked()","hdv_mainframe", this, "DoOpenBCALInspector()");

checkbuttons["candidates"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");
checkbuttons["wiretracks"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");
checkbuttons["timetracks"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");	
checkbuttons["chargedtracks"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");
checkbuttons["neutrals"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");
checkbuttons["thrown"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");

checkbuttons["cdc"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");
checkbuttons["cdcdrift"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");
checkbuttons["cdctruth"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");
checkbuttons["fdcwire"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");
checkbuttons["fdcpseudo"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");
checkbuttons["fdctruth"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");
checkbuttons["tof"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");
checkbuttons["toftruth"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");
checkbuttons["bcal"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");
checkbuttons["bcaltruth"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");
checkbuttons["fcal"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");
checkbuttons["fcaltruth"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");
checkbuttons["ccal"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");
checkbuttons["trajectories"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");

for (Int_t n=1;n<debugermf->GetNTrCand();n++){
  char str1[128];
  sprintf(str1,"Candidate%d",n);
  checkbuttons[str1]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");
}

for (Int_t n=1;n<debugermf->GetNTrWB();n++){
  char str1[128];
  sprintf(str1,"WireBased%d",n);
  checkbuttons[str1]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");
}

for (Int_t n=1;n<debugermf->GetNTrTB();n++){
  char str1[128];
  sprintf(str1,"TimeBased%d",n);
  checkbuttons[str1]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()");
}

candidatesfactory->Connect("Selected(Int_t)","hdv_mainframe", this, "DoMyRedraw()");
wiretracksfactory->Connect("Selected(Int_t)","hdv_mainframe", this, "DoMyRedraw()");
timetracksfactory->Connect("Selected(Int_t)","hdv_mainframe", this, "DoMyRedraw()");	
chargedtracksfactory->Connect("Selected(Int_t)","hdv_mainframe", this, "DoMyRedraw()");
reconfactory->Connect("Selected(Int_t)","hdv_mainframe", this, "DoUpdateTrackLabels()");

endviewA->GetCanvas()->Connect("Selected(TVirtualPad*, TObject*, Int_t)", "hdv_mainframe", this, "DoEndViewAEvent(TVirtualPad*, TObject*, Int_t)");
endviewB->GetCanvas()->Connect("Selected(TVirtualPad*, TObject*, Int_t)", "hdv_mainframe", this, "DoEndViewBEvent(TVirtualPad*, TObject*, Int_t)");

// Set up timer to call the DoTimer() method repeatedly
// so events can be automatically advanced.
timer = new TTimer();
timer->Connect("Timeout()", "hdv_mainframe", this, "DoTimer()");
sleep_time = 250;
timer->Start(sleep_time, kFALSE);

// Finish up and map the window
SetWindowName("Hall-D Event Viewer");
SetIconName("HDView");
MapSubwindows();
Resize(GetDefaultSize());
MapWindow();

// Call Resize method of some group frames to get them to shrink down to smallest size
viewcontrols->Resize();
eventinfo->Resize();
eventcontrols->Resize();
inspectors->Resize();
623}

625//-------------------
626// ReadPreferences
627//-------------------
628void hdv_mainframe::ReadPreferences(void)
629{
// Preferences file is "${HOME}/.hdview2"
const char *home = getenv("HOME");
if(!home)return;

// Try and open file
string fname = string(home) + "/.hdview2";
ifstream ifs(fname.c_str());
if(!ifs.is_open())return;
cout<<"Reading preferences from \""<<fname<<"\" ..."<<endl;

// Loop over lines
char line[1024];
while(!ifs.eof()){
ifs.getline(line, 1024);
if(strlen(line)==0)continue;
if(line[0] == '#')continue;
string str(line);

// Break line into tokens
vector<string> tokens;
string buf; // Have a buffer string
stringstream ss(str); // Insert the string into a stream
while (ss >> buf)tokens.push_back(buf);
if(tokens.size()<1)continue;

// Check first token to decide what to do
if(tokens[0] == "checkbutton"){
	if(tokens.size()!=4)continue; // should be of form "checkbutton name = value" with white space on either side of the "="
	map<string, TGCheckButton*>::iterator it = checkbuttons.find(tokens[1]);
	if(it != checkbuttons.end()){
		if(tokens[3] == "on")(it->second)->SetState(kButtonDown);
	}
}

if(tokens[0] == "DTrackCandidate"){
	if(tokens.size()!=3)continue; // should be of form "DTrackCandidate = tag" with white space on either side of the "="
	default_candidate = tokens[2];
}

if(tokens[0] == "DTrackWireBased"){
	if(tokens.size()!=3)continue; // should be of form "DTrackWireBased = tag" with white space on either side of the "="
	default_track = tokens[2];
}

if(tokens[0] == "DTrackTimeBased"){
	if(tokens.size()!=3)continue; // should be of form "DTrackTimeBased = tag" with white space on either side of the "="
	default_track = tokens[2];
}

if(tokens[0] == "Reconstructed"){
	if(tokens.size()!=3)continue; // should be of form "Reconstructed = Factory:tag" with white space on either side of the "="
	default_reconstructed = tokens[2];
}

}

// close file
ifs.close();
688}

690//-------------------
691// SavePreferences
692//-------------------
693void hdv_mainframe::SavePreferences(void)
694{
// Preferences file is "${HOME}/.hdview2"
const char *home = getenv("HOME");
if(!home)return;

// Try deleting old file and creating new file
string fname = string(home) + "/.hdview2";
unlink(fname.c_str());
ofstream ofs(fname.c_str());
if(!ofs.is_open()){
cout<<"Unable to create preferences file \""<<fname<<"\"!"<<endl;
return;
}

// Write header
time_t t = time(NULL__null);
ofs<<"##### hdview2 preferences file ###"<<endl;
ofs<<"##### Auto-generated on "<<ctime(&t)<<endl;
ofs<<endl;

// Write all checkbuttons that are "on"
map<string, TGCheckButton*>::iterator iter;
for(iter=checkbuttons.begin(); iter!=checkbuttons.end(); iter++){
TGCheckButton *but = iter->second;
if(but->GetState() == kButtonDown){
	ofs<<"checkbutton "<<(iter->first)<<" = on"<<endl;
}
}
ofs<<endl;

ofs<<"DTrackCandidate = "<<(candidatesfactory->GetTextEntry()->GetText())<<endl;
ofs<<"DTrackWireBased = "<<(wiretracksfactory->GetTextEntry()->GetText())<<endl;
ofs<<"DTrackTimeBased = "<<(timetracksfactory->GetTextEntry()->GetText())<<endl;
ofs<<"Reconstructed = "<<(reconfactory->GetTextEntry()->GetText())<<endl;

ofs<<endl;
ofs.close();
cout<<"Preferences written to \""<<fname<<"\""<<endl;
732}

734//-------------------
735// SetRange
736//-------------------
737void hdv_mainframe::SetRange(void)
738{
// The following is for the bug
//endviewA->GetCanvas()->Range(-1, -1, 1, 1);

// Set the ranges of all canvases based on
// the current units (x/y or r/phi) and the zoom,pan
// settings

if(coordinatetype==COORD_XY){
// define range in each direction in cm
double x_width = 350.0/zoom_factor;
double y_width = x_width;
double z_width = 2.70*x_width;
double xlo = x0 - x_width/2.0;
double xhi = x0 + x_width/2.0;
double ylo = y0 - y_width/2.0;
double yhi = y0 + y_width/2.0;
double zlo = z0 - z_width*0.40;
double zhi = z0 + z_width*0.60;

sideviewA->GetCanvas()->cd();
sideviewA->GetCanvas()->Range(zlo, xlo, zhi, xhi);
sideviewB->GetCanvas()->cd();
sideviewB->GetCanvas()->Range(zlo, ylo, zhi, yhi);

// Zoom in a little on the end views
double end_to_side_ratio=1.8;
xlo/=end_to_side_ratio;
xhi/=end_to_side_ratio;
ylo/=end_to_side_ratio;
yhi/=end_to_side_ratio;

endviewA->GetCanvas()->cd();
endviewA->GetCanvas()->Range(xlo, ylo, xhi, yhi);
endviewB->GetCanvas()->cd();
endviewB->GetCanvas()->Range(xlo*1.3, ylo*1.3, xhi*1.3, yhi*1.3);
//endviewB->GetCanvas()->Range(-158, -158, 158, 158);
endviewAmf->SetRange(xlo, ylo, xhi, yhi);
endviewBmf->SetRange(xlo*1.3, ylo*1.3, xhi*1.3, yhi*1.3);
//endviewBmf->SetRange(-158, -158, 158, 158);

}else{
// define range in each direction in cm, radians
double r_width = 400.0/zoom_factor;
//double phi_width = 2.0*M_PI/zoom_factor;
double z_width = 2.0*r_width/zoom_factor;
double rlo = r0 - r_width/2.0;
double rhi = r0 + r_width/2.0;
double zlo = z0 - z_width/2.0;
double zhi = z0 + z_width/2.0;
double philo = -0.2;
double phihi = 2.0*M_PI3.14159265358979323846+0.2;

sideviewA->GetCanvas()->cd();
sideviewA->GetCanvas()->Range(zlo, rlo, zhi, rhi);
sideviewB->GetCanvas()->cd();
sideviewB->GetCanvas()->Range(zlo, philo, zhi, phihi);

// Zoom in a little on the end views in A
endviewA->GetCanvas()->cd();
endviewA->GetCanvas()->Range(philo, rlo/2.5, phihi,  rhi/2.5);
endviewB->GetCanvas()->cd();
endviewB->GetCanvas()->Range(philo, rlo/10.0, phihi,  rhi/1.9);
endviewAmf->SetRange(philo, rlo/2.5, phihi,  rhi/2.5);
endviewBmf->SetRange(philo, rlo/10.0, phihi,  rhi/1.9);
}
804}

806//-------------------
807// DoQuit
808//-------------------
809void hdv_mainframe::DoQuit(void)
810{
SavePreferences();

japp->Quit();
japp->Fini();
delete japp;
japp = NULL__null;

// This is supposed to return from the Run() method in "main()"
// since we call SetReturnFromRun(true), but it doesn't seem to work.
gApplication->Terminate(0);	
821}

823//-------------------
824// DoNext
825//-------------------
826void hdv_mainframe::DoNext(void)
827{
if(eventloop){
3
←
Assuming 'eventloop' is non-null→
4
←
Taking true branch→
if(SKIP_EPICS_EVENTS){
5
←
Assuming 'SKIP_EPICS_EVENTS' is true→
6
←
Taking true branch→
	while(true){
7
←
Loop condition is true.  Entering loop body→
		eventloop->OneEvent();
		vector<const DEPICSvalue*> epicsvalues;
		eventloop->Get(epicsvalues);
8
←
Calling 'JEventLoop::Get'→
		if(epicsvalues.empty()) break;
		cout << "Skipping EPICS event " << eventloop->GetJEvent().GetEventNumber() << endl;
	}
}else{
	eventloop->OneEvent();
}
}
841}

843//-------------------
844// DoPrev
845//-------------------
846void hdv_mainframe::DoPrev(void)
847{
//eventloop->GotoEvent(current_eventnumber-1);
//eventloop->OneEvent();
850}

852//-------------------
853// DoStop
854//-------------------
855void hdv_mainframe::DoStop(void)
856{
GO = 0;
858}

860//-------------------
861// DoCont
862//-------------------
863void hdv_mainframe::DoCont(void)
864{
GO = 1;
866}

868//-------------------
869// DoTimer
870//-------------------
871void hdv_mainframe::DoTimer(void)
872{
/// This gets called periodically (value is set in constructor)
/// It is used to automatically call DoNext() periodically
/// so long as the global GO is set to 1.
if(GetCheckButton("continuous")){
1
Taking true branch→
DoNext();
2
←
Calling 'hdv_mainframe::DoNext'→
if(sleep_time != (long)timer->GetTime())timer->SetTime(sleep_time);
}else{
if(sleep_time == 0)timer->SetTime(10);
}
882}

884//-------------------
885// DoOpenTrackInspector
886//-------------------
887void hdv_mainframe::DoOpenTrackInspector(void)
888{
if(trkmf==NULL__null){
trkmf = new trk_mainframe(this, NULL__null, 100, 100);
if(trkmf){
	next->Connect("Clicked()","trk_mainframe", trkmf, "DoNewEvent()");
	prev->Connect("Clicked()","trk_mainframe", trkmf, "DoNewEvent()");
}
}else{
trkmf->RaiseWindow();
trkmf->RequestFocus();
}
899}

901//-------------------
902// DoOpenOptionsWindow
903//-------------------
904void hdv_mainframe::DoOpenOptionsWindow(void)
905{
if(optionsmf==NULL__null){
optionsmf = new hdv_optionsframe(this, NULL__null, 100, 100);
}else{
optionsmf->MapWindow();
optionsmf->RaiseWindow();
optionsmf->RequestFocus();
}
913}
914//-------------------
915// DoOpenDebugerWindow
916//-------------------
917void hdv_mainframe::DoOpenDebugerWindow(void)
918{
if(debugermf==NULL__null){
debugermf = new hdv_debugerframe(this, NULL__null, 100, 100);
}else{
debugermf->MapWindow();
debugermf->RaiseWindow();
debugermf->RequestFocus();
DoUpdateTrackLabels();
}
927}
928//-------------------
929// DoOpenDebugerWindow
930//-------------------
931void hdv_mainframe::DoBcalDispFrame(void)
932{
if(bcaldispmf==NULL__null){
bcaldispmf = new TCanvas("BCALHitCanvas", "BCAL Hit Distribution", 900, 900);
}

DoUpdateBcalDisp();
938}
939//-------------------
940// DoOpenDebugerWindow
941//-------------------
942void hdv_mainframe::DoUpdateBcalDisp(void)
943{
gMYPROC->UpdateBcalDisp();

946}
947///-------------------
948// DoOpenFullListWindow
949//-------------------
950void hdv_mainframe::DoOpenFullListWindow(void)
951{
if(fulllistmf==NULL__null){
fulllistmf = new hdv_fulllistframe(this, NULL__null, 100, 100);
}else{
fulllistmf->MapWindow();
fulllistmf->RaiseWindow();
fulllistmf->RequestFocus();
DoUpdateTrackLabels();
}
960}

962//-------------------
963// DoOpenTOFInspector
964//-------------------
965void hdv_mainframe::DoOpenTOFInspector(void)
966{

968}

970//-------------------
971// DoOpenFCALInspector
972//-------------------
973void hdv_mainframe::DoOpenFCALInspector(void)
974{

976}

978//-------------------
979// DoOpenBCALInspector
980//-------------------
981void hdv_mainframe::DoOpenBCALInspector(void)
982{

984}

986//-------------------
987// DoClearTrackInspectorPointer
988//-------------------
989void hdv_mainframe::DoClearTrackInspectorPointer(void)
990{
trkmf = NULL__null;
992}

994//-------------------
995// DoClearOptionsWindowPointer
996//-------------------
997void hdv_mainframe::DoClearOptionsWindowPointer(void)
998{
optionsmf = NULL__null;
1000}

1002//-------------------
1003// DoClearTOFInspectorPointer
1004//-------------------
1005void hdv_mainframe::DoClearTOFInspectorPointer(void)
1006{

1008}

1010//-------------------
1011// DoClearFCALInspectorPointer
1012//-------------------
1013void hdv_mainframe::DoClearFCALInspectorPointer(void)
1014{

1016}

1018//-------------------
1019// DoClearBCALInspectorPointer
1020//-------------------
1021void hdv_mainframe::DoClearBCALInspectorPointer(void)
1022{

1024}

1026//-------------------
1027// DoEndViewAEvent
1028//-------------------
1029void hdv_mainframe::DoEndViewAEvent(TVirtualPad* pad, TObject* obj, Int_t event)
1030{
// event is the mouse button pushed (1=left, 2=center, 3=right)
// It seems we can't detect double clicks here.
if(endviewAmf==NULL__null){
endviewAmf = new hdv_endviewAframe(this, NULL__null, 100, 100);
}else{
endviewAmf->MapWindow();
endviewAmf->RaiseWindow();
endviewAmf->RequestFocus();
DoMyRedraw();
}
1041}


1044//-------------------
1045// DoEndViewBEvent
1046//-------------------
1047void hdv_mainframe::DoEndViewBEvent(TVirtualPad* pad, TObject* obj, Int_t event)
1048{
// event is the mouse button pushed (1=left, 2=center, 3=right)
// It seems we can't detect double clicks here.
if(endviewBmf==NULL__null){
endviewBmf = new hdv_endviewBframe(this, NULL__null, 100, 100);
}else{
endviewBmf->MapWindow();
endviewBmf->RaiseWindow();
endviewBmf->RequestFocus();
DoMyRedraw();
}
1059}

1061//-------------------
1062// DoPanXpos
1063//-------------------
1064void hdv_mainframe::DoPanXpos(void)
1065{
x0 += 50/zoom_factor;
SetRange();
DoMyRedraw();
1069}

1071//-------------------
1072// DoPanXneg
1073//-------------------
1074void hdv_mainframe::DoPanXneg(void)
1075{
x0 -= 50/zoom_factor;
SetRange();
DoMyRedraw();
1079}

1081//-------------------
1082// DoPanYpos
1083//-------------------
1084void hdv_mainframe::DoPanYpos(void)
1085{
y0 += 50/zoom_factor;
SetRange();
DoMyRedraw();
1089}

1091//-------------------
1092// DoPanYneg
1093//-------------------
1094void hdv_mainframe::DoPanYneg(void)
1095{
y0 -= 50/zoom_factor;
SetRange();
DoMyRedraw();
1099}

1101//-------------------
1102// DoPanZpos
1103//-------------------
1104void hdv_mainframe::DoPanZpos(void)
1105{
z0 += 50/zoom_factor;
SetRange();
DoMyRedraw();
1109}

1111//-------------------
1112// DoPanZneg
1113//-------------------
1114void hdv_mainframe::DoPanZneg(void)
1115{
z0 -= 50/zoom_factor;
SetRange();
DoMyRedraw();
1119}

1121//-------------------
1122// DoZoomIn
1123//-------------------
1124void hdv_mainframe::DoZoomIn(void)
1125{
zoom_factor*=1.25;
SetRange();
DoMyRedraw();
//if(gMYPROC)gMYPROC->evnt(eventloop, current_eventnumber);
1130}

1132//-------------------
1133// DoZoomOut
1134//-------------------
1135void hdv_mainframe::DoZoomOut(void)
1136{
zoom_factor/=1.25;
SetRange();
DoMyRedraw();
//if(gMYPROC)gMYPROC->evnt(eventloop, current_eventnumber);
1141}

1143//-------------------
1144// DoReset
1145//-------------------
1146void hdv_mainframe::DoReset(void)
1147{
x0 = 0.0;
y0 = 0.0;
z0 = 350.0;
zoom_factor = 1.0;
DoMyRedraw();
1153}


1156//-------------------
1157// DoMyRedraw
1158//-------------------
1159void hdv_mainframe::DoMyRedraw(void)
1160{
// Make sure canvases have proper ranges
SetRange();

// Delete any existing graphics objects
for(unsigned int i=0; i<graphics_sideA.size(); i++)delete graphics_sideA[i];
for(unsigned int i=0; i<graphics_sideB.size(); i++)delete graphics_sideB[i];
for(unsigned int i=0; i<graphics_endA.size(); i++)delete graphics_endA[i];
for(unsigned int i=0; i<graphics_endB.size(); i++)delete graphics_endB[i];
graphics_sideA.clear();
graphics_sideB.clear();
graphics_endA.clear();
graphics_endB.clear();


// Draw detectors depending on coordinate system we're using
if(coordinatetype == COORD_XY){
DrawDetectorsXY();			// Draw Detectors
}else{
DrawDetectorsRPhi();			// Draw Detectors
}

// Collect all hits for display
gMYPROC->FillGraphics();

// put collected hits into appropriate views 
AddGraphicsSideA(gMYPROC->graphics_xz);
AddGraphicsSideB(gMYPROC->graphics_yz);
AddGraphicsEndB(gMYPROC->graphics_tof_hits); 

// Draw detector hits and tracks for the correct coordinates in all views
vector<MyProcessor::DGraphicSet>::iterator iter = gMYPROC->graphics.begin();
for(; iter!=gMYPROC->graphics.end(); iter++){

if(iter->type==MyProcessor::kMarker){
	// Markers
	TPolyMarker *sA = new TPolyMarker();
	TPolyMarker *sB = new TPolyMarker();
	TPolyMarker *eA = new TPolyMarker();
	sA->SetMarkerColor(iter->color);
	sB->SetMarkerColor(iter->color);
	eA->SetMarkerColor(iter->color);
	sA->SetMarkerSize(iter->size);
	sB->SetMarkerSize(iter->size);
	eA->SetMarkerSize(iter->size);
	sA->SetMarkerStyle(iter->marker_style);
	sB->SetMarkerStyle(iter->marker_style);
	eA->SetMarkerStyle(iter->marker_style);
	FillPoly(sA, sB, eA, iter->points); // in hdv_mainframe.h
}else{
	// Lines
	TPolyLine *sA = new TPolyLine();
	TPolyLine *sB = new TPolyLine();
	TPolyLine *eA = new TPolyLine();
	sA->SetLineColor(iter->color);
	sB->SetLineColor(iter->color);
	eA->SetLineColor(iter->color);
	sA->SetLineWidth((Width_t)iter->size);
	sB->SetLineWidth((Width_t)iter->size);
	eA->SetLineWidth((Width_t)iter->size);
	sA->SetFillStyle(0);
	sB->SetFillStyle(0);
	eA->SetFillStyle(0);
	FillPoly(sA, sB, eA, iter->points); // in hdv_mainframe.h
	
	// Axial CDC wires will end up as having zero length in the end view
	// so we draw an additional marker in the end view for those cases.
	if(eA->GetN()==2){
		double *x = eA->GetX();
		double *y = eA->GetY();
		if(fabs(x[0]-x[1])<0.1 && fabs(y[0]==y[1])<0.1){
			TMarker *m = new TMarker(x[0], y[0], 8);
			m->SetMarkerColor(iter->color);
			m->SetMarkerSize(0.5);
			graphics_endA.push_back(m);
		}
	}
}
}

// Add in additional view-specific objects
if(coordinatetype == COORD_XY){
for(unsigned int i=0; i<gMYPROC->graphics_xyA.size(); i++){
	graphics_endA.push_back(gMYPROC->graphics_xyA[i]);
}
for(unsigned int i=0; i<gMYPROC->graphics_xyB.size(); i++){
	graphics_endB.push_back(gMYPROC->graphics_xyB[i]);
}
}

// Draw everything
endviewA->GetCanvas()->cd(0);
for(unsigned int i=0; i<graphics_endA.size(); i++){
TPolyLine *l = dynamic_cast<TPolyLine*>(graphics_endA[i]);
if(l && l->GetFillStyle()!=0){
	graphics_endA[i]->Draw("f");
}else{
	graphics_endA[i]->Draw("");
}
}
endviewA->GetCanvas()->Update();
endviewAmf->DrawObjects(graphics_endA); // duplicate drawing of objects in big window

endviewB->GetCanvas()->cd(0);
for(unsigned int i=0; i<graphics_endB.size(); i++)graphics_endB[i]->Draw("f");
for(unsigned int i=0; i<graphics_endB.size(); i++)graphics_endB[i]->Draw();
endviewB->GetCanvas()->Update();
endviewBmf->DrawObjects(graphics_endB); // duplicate drawing of objects in big window

sideviewA->GetCanvas()->cd(0);
for(unsigned int i=0; i<graphics_sideA.size(); i++)graphics_sideA[i]->Draw();
sideviewA->GetCanvas()->Update();
sideviewB->GetCanvas()->cd(0);
for(unsigned int i=0; i<graphics_sideB.size(); i++)graphics_sideB[i]->Draw();
sideviewB->GetCanvas()->Update();

// Update track labels
DoUpdateTrackLabels();
1278}

1280//-------------------
1281// DoSetDelay
1282//-------------------
1283void hdv_mainframe::DoSetDelay(Int_t id)
1284{
stringstream ss;
ss<<delay->GetSelectedEntry()->GetTitle();
double seconds;
ss>>seconds;
sleep_time = (int)(1000.0*seconds);
timer->SetTime(sleep_time);
1291}

1293//-------------------
1294// DoSetCoordinates
1295//-------------------
1296void hdv_mainframe::DoSetCoordinates(Int_t id)
1297{
coordinatetype = (coordsys_t)id;
1299}

1301//-------------------
1302// DoUpdateTrackLabels
1303//-------------------
1304void hdv_mainframe::DoUpdateTrackLabels(void)
1305{
gMYPROC->UpdateTrackLabels();

throwninfo->Resize();
reconinfo->Resize();
1310}

1312//-------------------
1313// DrawDetectorsXY
1314//-------------------
1315void hdv_mainframe::DrawDetectorsXY(void)
1316{
//============== Side A
{
sideviewA->GetCanvas()->cd(0);
sideviewA->GetCanvas()->Clear();



// ------ Target ------	
TBox *target = new TBox(TARGET_Zmid-TARGET_Zlen/2.0, -0.5, TARGET_Zmid+TARGET_Zlen/2.0, +0.5);
target->SetFillColor(13);
graphics_sideA.push_back(target);


// ----- BCAL ------
TBox *bcal1 = new TBox(BCAL_Zmin, BCAL_Rmin, BCAL_Zmin+BCAL_Zlen, BCAL_Rmax);
TBox *bcal2 = new TBox(BCAL_Zmin, -BCAL_Rmin, BCAL_Zmin+BCAL_Zlen, -BCAL_Rmax);
bcal1->SetFillColor(28);
bcal2->SetFillColor(28);
graphics_sideA.push_back(bcal1);
graphics_sideA.push_back(bcal2);

// ----- CDC ------
TBox *cdc1 = new TBox(CDC_Zmin, CDC_Rmin, CDC_Zmin + CDC_Zlen, CDC_Rmax);
TBox *cdc2 = new TBox(CDC_Zmin, -CDC_Rmin, CDC_Zmin + CDC_Zlen, -CDC_Rmax);
cdc1->SetFillColor(17);
cdc2->SetFillColor(17);
graphics_sideA.push_back(cdc1);
graphics_sideA.push_back(cdc2);

// ----- FDC ------
for(int i=0; i<4; i++){
	// Get FDC package positions from FDC library
	float zu = fdcwires[i*6][0]->origin.z();
	float zd = fdcwires[i*6+5][0]->origin.z();			
	TBox *fdc1 = new TBox(zu, FDC_Rmin, zd, FDC_Rmax);
	TBox *fdc2 = new TBox(zu, -FDC_Rmin, zd, -FDC_Rmax);
	fdc1->SetFillColor(21);
	fdc2->SetFillColor(21);
	graphics_sideA.push_back(fdc1);
	graphics_sideA.push_back(fdc2);
}

// ----- TOF ------
TBox *tof1 = new TBox(TOF_Zmin, TOF_Rmin, TOF_Zmin+TOF_Zlen, TOF_Rmax);
TBox *tof2 = new TBox(TOF_Zmin, -TOF_Rmin, TOF_Zmin+TOF_Zlen, -TOF_Rmax);
tof1->SetFillColor(11);
tof2->SetFillColor(11);
graphics_sideA.push_back(tof1);
graphics_sideA.push_back(tof2);

// ----- FCAL ------
TBox *fcal1 = new TBox(FCAL_Zmin, FCAL_Rmin, FCAL_Zmin+FCAL_Zlen, FCAL_Rmax);
TBox *fcal2 = new TBox(FCAL_Zmin, -FCAL_Rmin, FCAL_Zmin+FCAL_Zlen, -FCAL_Rmax);
fcal1->SetFillColor(40);
fcal2->SetFillColor(40);
graphics_sideA.push_back(fcal1);
graphics_sideA.push_back(fcal2);

// ----- CCAL ------
TBox *ccal1 = new TBox(CCAL_Zmin,  CCAL_Rmin, CCAL_Zmin+CCAL_Zlen,  CCAL_Rmax);
TBox *ccal2 = new TBox(CCAL_Zmin, -CCAL_Rmin, CCAL_Zmin+CCAL_Zlen, -CCAL_Rmax);
ccal1->SetFillColor(42);
ccal2->SetFillColor(42);
graphics_sideA.push_back(ccal1);
graphics_sideA.push_back(ccal2);

// ------ scale ------
DrawScale(sideviewA->GetCanvas(), graphics_sideA);
}

//============== Side B
{
sideviewB->GetCanvas()->cd(0);
sideviewB->GetCanvas()->Clear();

// Side B is exactly the same as side A so just copy it
for(unsigned int i=0; i<graphics_sideA.size(); i++){
	graphics_sideB.push_back(graphics_sideA[i]->Clone());
}
}

//============== End A
{
endviewB->GetCanvas()->cd(0);
endviewB->GetCanvas()->Clear();

// ----- BCAL ------
TEllipse *bcal1 = new TEllipse(0.0, 0.0, BCAL_Rmax, BCAL_Rmax);
TEllipse *bcal2 = new TEllipse(0.0, 0.0, BCAL_Rmin, BCAL_Rmin);
bcal1->SetFillColor(0);
bcal2->SetFillColor(0);
graphics_endA.push_back(bcal1);
graphics_endA.push_back(bcal2);

double dlayer1 = 0.5*(BCAL_MIDRAD-BCAL_Rmin)/(double)BCAL_LAYS1;
//double dlayer2 = (BCAL_Rmax-BCAL_MIDRAD)/(double)BCAL_LAYS2;
double dmodule = (double)TMath::TwoPi()/(double)BCAL_MODS;
double dsector1 = dmodule/(double)BCAL_SECS1;
double dsector2 = dmodule/(double)BCAL_SECS2;

// Create polygon for each readout segment for use in coloring hits
if(GetCheckButton("bcal")){
  for(int imod=0; imod<BCAL_MODS; imod++){
    double mod_phi = (double)imod*dmodule -2.0*dsector1 + BCAL_PHI_SHIFT;
    double r_min=BCAL_Rmin;
    for(int ilay=0; ilay<BCAL_LAYS1; ilay++){
      r_min+=dlayer1*ilay;
      double r_max = r_min+(ilay+1)*dlayer1;
      for(int isec=0; isec<BCAL_SECS1; isec++){
	double phimin = mod_phi + (double)isec*dsector1;
	double phimax = phimin + dsector1;
	
	double x[4], y[4];
	x[0] = r_min*cos(phimin);		
	y[0] = r_min*sin(phimin);
	x[1] = r_max*cos(phimin);		
	y[1] = r_max*sin(phimin);
	x[2] = r_max*cos(phimax);		
	y[2] = r_max*sin(phimax);
	x[3] = r_min*cos(phimax);		
	y[3] = r_min*sin(phimax);
				
	TPolyLine *poly = new TPolyLine(4, x, y);
	poly->SetLineColor(12);
	poly->SetLineWidth(0);
	poly->SetFillColor(0);
	poly->SetFillStyle(0);
	int chan = (imod+1)*1000 + (ilay+1)*100 + (isec+1)*10;
	graphics_endA.push_back(poly);
	bcalblocks[chan] = poly; // record so we can set the color later
      }
    
      for(int isec=0; isec<BCAL_SECS2; isec++){
	double phimin = mod_phi + (double)isec*dsector2;
	double phimax = phimin + dsector2;
	
	double x[5], y[5];
	x[0] = BCAL_MIDRAD*cos(phimin);	
	y[0] = BCAL_MIDRAD*sin(phimin);
	x[1] = BCAL_Rmax*cos(phimin);		
	y[1] = BCAL_Rmax*sin(phimin);
	x[2] = BCAL_Rmax*cos(phimax);		
	y[2] = BCAL_Rmax*sin(phimax);
	x[3] = BCAL_MIDRAD*cos(phimax);
	y[3] = BCAL_MIDRAD*sin(phimax);
	x[4] = x[0];
	y[4] = y[0];
	TPolyLine *poly = new TPolyLine(5, x, y);
	poly->SetLineColor(12);
	poly->SetLineWidth(1);
	poly->SetFillColor(0);
	poly->SetFillStyle(0);
	int chan = (int)((imod+1)*1000 + (ilay+1+BCAL_LAYS1)*100 + (isec+1)*10);
	graphics_endA.push_back(poly);
	bcalblocks[chan] = poly; // record so we can set the color later
      }
    }
  }
}
// Draw lines to identify boundaries of readout segments
for(int imod=0; imod<BCAL_MODS; imod++){
	// Vertical(sector) boundaries
	double mod_phi = (double)imod*dmodule -2.0*dsector1 + BCAL_PHI_SHIFT;
	for(int isec=0; isec<BCAL_SECS1; isec++){
		double rmin = BCAL_Rmin;
		double rmax = BCAL_MIDRAD;
		double phi = mod_phi + (double)isec*dsector1;

		TLine *l = new TLine(rmin*cos(phi), rmin*sin(phi), rmax*cos(phi), rmax*sin(phi));
		l->SetLineColor(isec==0 ? kBlack:12);
		l->SetLineWidth((Width_t)(isec==0 ? 2.5:1.0));
		graphics_endA.push_back(l);
	}
	for(int isec=0; isec<BCAL_SECS2; isec++){
		double rmin = BCAL_MIDRAD;
		double rmax = BCAL_Rmax;
		double phi = mod_phi + (double)isec*dsector2;

		TLine *l = new TLine(rmin*cos(phi), rmin*sin(phi), rmax*cos(phi), rmax*sin(phi));
		l->SetLineColor(isec==0 ? kBlack:12);
		l->SetLineWidth((Width_t)(isec==0 ? 2.5:1.0));
		graphics_endA.push_back(l);
	}
	
	// Horizontal(layer) boundaries
	double r=BCAL_Rmin;
	for(int ilay=0; ilay<BCAL_LAYS1; ilay++){
	  r+=dlayer1*ilay;
		TLine *l = new TLine(r*cos(mod_phi), r*sin(mod_phi), r*cos(mod_phi+dmodule), r*sin(mod_phi+dmodule));
		l->SetLineColor(ilay==0 ? kBlack:12);
		l->SetLineWidth((Width_t)(ilay==0 ? 1.0:1.0));
		graphics_endA.push_back(l);
	}
	
	TLine *l = new TLine(BCAL_MIDRAD*cos(mod_phi), BCAL_MIDRAD*sin(mod_phi), BCAL_MIDRAD*cos(mod_phi+dmodule), BCAL_MIDRAD*sin(mod_phi+dmodule));
	l->SetLineColor(12);
	l->SetLineWidth((Width_t)(1.0));
	graphics_endA.push_back(l);
}

// ----- CDC ------
TEllipse *cdc1 = new TEllipse(0.0, 0.0, CDC_Rmax, CDC_Rmax);
TEllipse *cdc2 = new TEllipse(0.0, 0.0, CDC_Rmin, CDC_Rmin);
cdc1->SetFillColor(17);
cdc1->SetLineColor(17);
cdc2->SetFillColor(10);
graphics_endA.push_back(cdc1);
graphics_endA.push_back(cdc2);

// ----- FDC ------
TEllipse *fdc1 = new TEllipse(0.0, 0.0, FDC_Rmax, FDC_Rmax);
TEllipse *fdc2 = new TEllipse(0.0, 0.0, FDC_Rmin, FDC_Rmin);
fdc1->SetFillColor(21);
fdc1->SetLineColor(21);
fdc2->SetFillColor(10);
fdc2->SetLineColor(10);
graphics_endA.push_back(fdc1);
graphics_endA.push_back(fdc2);


/*			
// ------ Start counter ------
double r_start=7.7;
for (unsigned int i=0;i<30;i++){
  double phi_0=0.209*i;
  double phi_1=0.209*(i+1);
  TLine *l = new TLine(r_start*cos(phi_0), r_start*sin(phi_0), 
		       r_start*cos(phi_1), r_start*sin(phi_1));
  l->SetLineColor(10);
  l->SetLineWidth(2.);
  graphics_endA.push_back(l);
}
*/

// ----- Start Counter -----
// All units are in cm.  These dimensions represent the geometry exactly.
Double_t inner_radius = 7.7493;	// Inner radius of the Start Counter
Double_t outer_radius = 8.0493;	// Outer radius of the Start Counter
Double_t bottom_width = 1.6289; // Width of the bottom edge of scintillator
Double_t top_width = 1.692;	// Width of the top edge of scintillator
Double_t dtr = 1.745329252e-02;	// Conversion factor from degrees to radians

// 5 x and 5 y coordinates for each of the 30 paddles
Double_t x_coords[31][5];
Double_t y_coords[31][5];
 
// Initialize the x-coordinates of channel 0 (phi = [0, 12 deg] in hall coordinates)
x_coords[0][0] = -outer_radius;
x_coords[0][1] = -(outer_radius - top_width*sin(6.0*dtr));
x_coords[0][2] = -(inner_radius - bottom_width*sin(6.0*dtr));
x_coords[0][3] = -inner_radius;
x_coords[0][4] = -outer_radius;
// Initialize the x-coordinates of channel 0 (phi = [0, 12 deg] in hall coordinates)
y_coords[0][0] = 0.0;
y_coords[0][1] = top_width*cos(6.0*dtr);
y_coords[0][2] = bottom_width*cos(6.0*dtr);
y_coords[0][3] = 0.0;
y_coords[0][4] = 0.0;

// Create an array of TPolyLine objects 
TPolyLine *ch_pline[30];
 
// Define array of points which define the individual scintillators
for (int i = 1; i < 31; i++)
  { 
    // Contruct the x-coordinates of the 30 scintillator paddles 
    x_coords[i][0] = x_coords[i-1][1];
    x_coords[i][1] = x_coords[i-1][1] + top_width*sin((6.0 + 12.0*i)*dtr);
    x_coords[i][2] = x_coords[i-1][2] + bottom_width*sin((6.0 + 12.0*i)*dtr);
    x_coords[i][3] = x_coords[i-1][2];
    x_coords[i][4] = x_coords[i-1][1];
    // Construct the y-coordinates of the 30 scintillator paddles
    y_coords[i][0] = y_coords[i-1][1];
    y_coords[i][1] = y_coords[i-1][1] + top_width*cos((6.0 + 12.0*i)*dtr);
    y_coords[i][2] = y_coords[i-1][2] + bottom_width*cos((6.0 + 12.0*i)*dtr);
    y_coords[i][3] = y_coords[i-1][2];
    y_coords[i][4] = y_coords[i-1][1];
       
    // Construct the TPolyLine objects that defines the paddles
    Double_t x[5] = {x_coords[i-1][0], x_coords[i-1][1], x_coords[i-1][2], x_coords[i-1][3], x_coords[i-1][4]};
    Double_t y[5] = {y_coords[i-1][0], y_coords[i-1][1], y_coords[i-1][2], y_coords[i-1][3], y_coords[i-1][4]};
    ch_pline[i-1] = new TPolyLine(5, x, y);
    ch_pline[i-1]->SetFillColor(18);
    ch_pline[i-1]->SetLineColor(1);
    ch_pline[i-1]->SetLineWidth(2);
    graphics_endA.push_back(ch_pline[i-1]);
  }

// ----- TARGET ------
TEllipse *target = new TEllipse(0.0, 0.0, 0.5, 0.5);
target->SetFillColor(13);
graphics_endA.push_back(target);

// ------ scale ------
DrawScale(endviewA->GetCanvas(), graphics_endA);
}

//============== End B
{
endviewB->GetCanvas()->cd(0);
endviewB->GetCanvas()->Clear();

// ----- FCAL ------
// Get list of blocks. Loop over all getting x,y coordinates of corners for all active ones.

// Set up 4 2-D vectors that point from the center of a block to its
// corners. This makes it easier to represent each corner as a vector
// in lab coordinate which we can extract r, phi from.
double blocksize = fcalgeom->blockSize();
DVector2 shift[8];
shift[0].Set(-blocksize/2, -blocksize/2);  // these are ordered such that they
shift[1].Set(-blocksize/2, +blocksize/2);  // go in a clockwise manner. This
shift[2].Set(+blocksize/2, +blocksize/2);  // ensures the r/phi cooridinates also
shift[3].Set(+blocksize/2, -blocksize/2);  // define a single enclosed space
double insertSize=fcalgeom->insertSize();
if (insertSize>0){
  blocksize=fcalgeom->insertBlockSize();
  shift[4].Set(-blocksize/2, -blocksize/2);  // these are ordered such that they
  shift[5].Set(-blocksize/2, +blocksize/2);  // go in a clockwise manner. This
  shift[6].Set(+blocksize/2, +blocksize/2);  // ensures the r/phi cooridinates also
  shift[7].Set(+blocksize/2, -blocksize/2);  // define a single enclosed space	  
}

fcalblocks.clear();
if(GetCheckButton("fcal")){
  for(unsigned int chan=0; chan<fcalgeom->numChannels(); chan++){
    if (fcalgeom->isBlockActive(chan)==false) continue;
    DVector2 fcalBlockPos=fcalgeom->positionOnFace(chan);

    double x[5], y[5];
    for(int i=0; i<4; i++){
      DVector2 pos = fcalBlockPos;
      if (insertSize>0 
	  && fabs(pos.X())<insertSize
	  && fabs(pos.Y())<insertSize){
	pos+=shift[i+4];
      }
      else{
	pos+=shift[i];
      }
      x[i] = pos.X();
      y[i] = pos.Y();
    }
    x[4] = x[0];
    y[4] = y[0];
		
    TPolyLine *poly = new TPolyLine(5, x, y);
    poly->SetFillColor(0);
    poly->SetLineColor(kBlack);
    graphics_endB.push_back(poly);
    
    fcalblocks[chan] = poly; // record so we can set the color later
  }
}

// ----- CCAL ------
// Get list of blocks. Loop over all getting x,y coordinates of corners for all active ones.

// Set up 4 2-D vectors that point from the center of a block to its
// corners. This makes it easier to represent each corner as a vector
// in lab coordinate which we can extract r, phi from.
blocksize = 2.0;
shift[0].Set(-blocksize/2, -blocksize/2);  // these are ordered such that they
shift[1].Set(-blocksize/2, +blocksize/2);  // go in a clockwise manner. This
shift[2].Set(+blocksize/2, +blocksize/2);  // ensures the r/phi coordinates also
shift[3].Set(+blocksize/2, -blocksize/2);  // define a single enclosed space
ccalblocks.clear();

if(GetCheckButton("ccal")){
	for(int irow=0; irow<12; irow++){
		for(int icol=0; icol<12; icol++){
			if( (irow==5 || irow==6) && (icol==5 || icol==6) ) continue;

			double center_x = (-6.0 + (icol+0.5))*2.0;
			double center_y = (-6.0 + (irow+0.5))*2.0;
			DVector2 mypos(center_x,center_y);

			double x[5], y[5];
			for(int i=0; i<4; i++){
				DVector2 pos = shift[i] + mypos;
				x[i] = pos.X();
				y[i] = pos.Y();
			}
			x[4] = x[0];
			y[4] = y[0];

			TPolyLine *poly = new TPolyLine(5, x, y);
			poly->SetFillColor(0);
			poly->SetLineColor(kBlack);
			graphics_endB.push_back(poly);

			int channel = icol + 12*(irow);
			ccalblocks[channel] = poly; // record so we can set the color later
		}
	}

	// If also drawing FCAL, draw an extra outline of the FCAL beam hole
	if(GetCheckButton("fcal")){
		double x[5] = {-6.0, -6.0, 6.0, 6.0, -6.0};
		double y[5] = {-6.0,  6.0, 6.0,-6.0, -6.0};
		TPolyLine *poly = new TPolyLine(5, x, y);
		poly->SetFillColor(0);
		poly->SetLineColor(kBlack);
		poly->SetLineWidth(3);
		poly->SetLineStyle(2);
		graphics_endB.push_back(poly);
	}
}

// ------- TOF ---------// 
tofblocks.clear();
if(GetCheckButton("tof")){
  
  TPolyLine *pmtPline[4][44] = {{ NULL__null }, { NULL__null }};
  
  // 38 PMTs for the standard modules in each side
  Double_t pmtX[4][44][5];
  Double_t pmtY[4][44][5];
  
  Double_t x[5];
  Double_t y[5];

  // origin: 0:DOWN; 1:NORTH; 2:UP; 3:SOUTH
  Double_t position_x[4] = {-126,-126,-126,126};
  Double_t position_y[4] = {-126,-126,126,-126};

  // PMTs from regular and half lenght modules with 6 cm x 14 cm
  Double_t step_x[4][5] = {{0,0,6,6,0},{0,-14,-14,0,0},{0,0,6,6,0},{0,14,14,0,0}};
  Double_t step_y[4][5] = {{0,-14,-14,0,0},{0,0,6,6,0},{0,14,14,0,0},{0,0,6,6,0}};
  Double_t step_xl[4][5] = {{0,0,3,3,0},{0,-20,-20,0,0},{0,0,3,3,0},{0,20,20,0,0}};
  Double_t step_yl[4][5] = {{0,-20,-20,0,0},{0,0,3,3,0},{0,20,20,0,0},{0,0,3,3,0}};
  Double_t step_X[4] = {6,0,6,0};
  Double_t step_Y[4] = {0,6,0,6};
  Double_t step_XL[4] = {3,0,3,0};
  Double_t step_YL[4] = {0,3,0,3};


  for (int sd=0; sd<4; sd++)
    {
      for (int i=0; i<44; i++)
	{
	  for (int l=0; l<5; l++)
	    {
	      switch(l)
		{
		case 0:
		  if (i == 19 || i == 20 || i == 23 || i == 24){
		    pmtX[sd][i][l]=position_x[sd] + step_xl[sd][l];
		    pmtY[sd][i][l]=position_y[sd] + step_yl[sd][l];
		  }
		  else{
		    pmtX[sd][i][l]=position_x[sd] + step_x[sd][l];
		    pmtY[sd][i][l]=position_y[sd] + step_y[sd][l];
		  }
		  break;
		case 1:
		  if (i == 19 || i == 20 || i == 23 || i == 24){
		    pmtX[sd][i][l]=position_x[sd] + step_xl[sd][l];
		    pmtY[sd][i][l]=position_y[sd] + step_yl[sd][l];
		  }
		  else{
		    pmtX[sd][i][l]=position_x[sd] + step_x[sd][l];
		    pmtY[sd][i][l]=position_y[sd] + step_y[sd][l];
		  }
		  break;
		case 2:
		  if (i == 19 || i == 20 || i == 23 || i == 24){
		    pmtX[sd][i][l]=position_x[sd] + step_xl[sd][l];
		    pmtY[sd][i][l]=position_y[sd] + step_yl[sd][l];
		  }
		  else{
		    pmtX[sd][i][l]=position_x[sd] + step_x[sd][l];
		    pmtY[sd][i][l]=position_y[sd] + step_y[sd][l];
		  }
		  break;
		case 3:
		  if (i == 19 || i == 20 || i == 23 || i == 24){
		    pmtX[sd][i][l]=position_x[sd] + step_xl[sd][l];
		    pmtY[sd][i][l]=position_y[sd] + step_yl[sd][l];
		  }
		  else{
		    pmtX[sd][i][l]=position_x[sd] + step_x[sd][l];
		    pmtY[sd][i][l]=position_y[sd] + step_y[sd][l];
		  }
		  break;
		case 4:
		  if (i == 19 || i == 20 || i == 23 || i == 24){
		    pmtX[sd][i][l]=position_x[sd] + step_xl[sd][l];
		    pmtY[sd][i][l]=position_y[sd] + step_yl[sd][l];
		  }
		  else{
		    pmtX[sd][i][l]=position_x[sd] + step_x[sd][l];
		    pmtY[sd][i][l]=position_y[sd] + step_y[sd][l];
		  }
		  break;
		}
	    }
	  if ( i == 19 || i == 20 || i == 23 || i == 24){
	    position_x[sd] = position_x[sd] + step_XL[sd];
	    position_y[sd] = position_y[sd] + step_YL[sd];
	  }
	  else{
	    position_x[sd] = position_x[sd] + step_X[sd];
	    position_y[sd] = position_y[sd] + step_Y[sd];
	  }
	}
    }
  
  for (int sd=0; sd<4; sd++) // for the 4 sides
    {
      for (int j=0; j<44; j++) // PMT for the standard modules
	{
	  for (int q=0; q<5; q++)
	    {
	      x[q] = pmtX[sd][j][q];
	      y[q] = pmtY[sd][j][q];
	    }
	  pmtPline[sd][j] = new TPolyLine(5,x,y);
	}
    }
  
  int tof_count = 0;
  for (int sd=0; sd<4; sd++) // for the 4 sides
    {
      for (int j=0; j<44; j++)
	{
	  pmtPline[sd][j]->SetFillColor(1);
	  pmtPline[sd][j]->SetLineColor(41);
	  pmtPline[sd][j]->SetLineWidth(2);
	  tof_count++;
	  graphics_endB.push_back(pmtPline[sd][j]);
	  tofblocks[sd][tof_count] = pmtPline[sd][j];
	}
      tof_count = 0;
    }

} // close the if tof-check button

// ------ scale ------
DrawScale(endviewB->GetCanvas(), graphics_endB);
}

//=============== Draw axes arrows
// (this is done here since the sideB graphics are copied from sideA)
DrawAxes(sideviewA->GetCanvas(), graphics_sideA, "Z", "X");
DrawAxes(sideviewB->GetCanvas(), graphics_sideB, "Z", "Y");
DrawAxes(endviewA->GetCanvas(), graphics_endA, "X", "Y");
DrawAxes(endviewB->GetCanvas(), graphics_endB, "X", "Y");


//=============== Draw view labels
DrawLabel(sideviewA->GetCanvas(), graphics_sideA, "top view (looking down from above detector)");
DrawLabel(sideviewA->GetCanvas(), graphics_sideB, "side view from beam right (south)");
DrawLabel(endviewA->GetCanvas(), graphics_endA, "BCAL view from downstream looking upstream");
DrawLabel(endviewB->GetCanvas(), graphics_endB, "FCAL view from downstream looking upstream");
1872}

1874//-------------------
1875// DrawDetectorsRPhi
1876//-------------------
1877void hdv_mainframe::DrawDetectorsRPhi(void)
1878{
//============== Side A  R vs. z
{
sideviewA->GetCanvas()->cd(0);
sideviewA->GetCanvas()->Clear();

// ------ Target ------	
TBox *target = new TBox(TARGET_Zmid-TARGET_Zlen/2.0, 0.0, TARGET_Zmid+TARGET_Zlen/2.0, 0.5);
target->SetFillColor(13);
graphics_sideA.push_back(target);

// ----- BCAL ------
TBox *bcal1 = new TBox(BCAL_Zmin, BCAL_Rmin, BCAL_Zmin+BCAL_Zlen, BCAL_Rmax);
bcal1->SetFillColor(28);
graphics_sideA.push_back(bcal1);

// ----- CDC ------
TBox *cdc1 = new TBox(CDC_Zmin, CDC_Rmin, CDC_Zmin + CDC_Zlen, CDC_Rmax);
cdc1->SetFillColor(17);
graphics_sideA.push_back(cdc1);

// ----- FDC ------
for(int i=0; i<4; i++){
	// Get FDC package positions from FDC library
	float zu = fdcwires[i*6][0]->origin.z();
	float zd = fdcwires[i*6+5][0]->origin.z();			
	TBox *fdc1 = new TBox(zu, FDC_Rmin, zd, FDC_Rmax);
	fdc1->SetFillColor(21);
	graphics_sideA.push_back(fdc1);
}

// ----- TOF ------
TBox *tof1 = new TBox(TOF_Zmin, TOF_Rmin, TOF_Zmin+TOF_Zlen, TOF_Rmax);
tof1->SetFillColor(11);
graphics_sideA.push_back(tof1);

// ----- FCAL ------
TBox *fcal1 = new TBox(FCAL_Zmin, FCAL_Rmin, FCAL_Zmin+FCAL_Zlen, FCAL_Rmax);
fcal1->SetFillColor(40);
graphics_sideA.push_back(fcal1);

// ------ scale ------
DrawScale(endviewA->GetCanvas(), graphics_endA);
}

//============== Side B Phi vs. z
{
sideviewB->GetCanvas()->cd(0);
sideviewB->GetCanvas()->Clear();

// ------ Target ------	
TBox *target = new TBox(TARGET_Zmid-TARGET_Zlen/2.0, 0.0, TARGET_Zmid+TARGET_Zlen/2.0, 2.0*M_PI3.14159265358979323846);
target->SetFillColor(13);
graphics_sideB.push_back(target);

// ----- BCAL ------
TBox *bcal1 = new TBox(BCAL_Zmin, 0.0, BCAL_Zmin+BCAL_Zlen, 2.0*M_PI3.14159265358979323846);
bcal1->SetFillColor(28);
graphics_sideB.push_back(bcal1);

// ----- CDC ------
TBox *cdc1 = new TBox(CDC_Zmin, 0.0, CDC_Zmin + CDC_Zlen, 2.0*M_PI3.14159265358979323846);
cdc1->SetFillColor(17);
graphics_sideB.push_back(cdc1);

// ----- FDC ------
for(int i=0; i<4; i++){
	// Get FDC package positions from FDC library
	float zu = fdcwires[i*6][0]->origin.z();
	float zd = fdcwires[i*6+5][0]->origin.z();	

	TBox *fdc1 = new TBox(zu, 0.0, zd, 2.0*M_PI3.14159265358979323846);
	fdc1->SetFillColor(21);
	graphics_sideB.push_back(fdc1);
}

// ----- TOF ------
TBox *tof1 = new TBox(TOF_Zmin, 0.0, TOF_Zmin+TOF_Zlen, 2.0*M_PI3.14159265358979323846);
tof1->SetFillColor(11);
graphics_sideB.push_back(tof1);

// ----- FCAL ------
TBox *fcal1 = new TBox(FCAL_Zmin, 0.0, FCAL_Zmin+FCAL_Zlen, 2.0*M_PI3.14159265358979323846);
fcal1->SetFillColor(40);
graphics_sideB.push_back(fcal1);

// ------ scale ------
DrawScale(endviewA->GetCanvas(), graphics_endA);
}

//============== End A R vs. phi
{
endviewA->GetCanvas()->cd(0);
endviewA->GetCanvas()->Clear();

// ----- BCAL ------
TBox *bcal1 = new TBox(0.0, BCAL_Rmin, 2.0*M_PI3.14159265358979323846, BCAL_Rmax);
bcal1->SetFillColor(28);
graphics_endA.push_back(bcal1);

// ----- CDC ------
TBox *cdc1 = new TBox(0.0, CDC_Rmin, 2.0*M_PI3.14159265358979323846, CDC_Rmax);
cdc1->SetFillColor(17);
graphics_endA.push_back(cdc1);

// ----- FDC ------
TBox *fdc1 = new TBox(0.0, FDC_Rmin, 2.0*M_PI3.14159265358979323846, FDC_Rmax);
fdc1->SetFillColor(21);
graphics_endA.push_back(fdc1);

// ----- TARGET ------
TBox *target = new TBox(0.0, 0.0, 2.0*M_PI3.14159265358979323846, 0.5);
target->SetFillColor(13);
graphics_endA.push_back(target);

}

//============== End B R vs. phi
{
endviewB->GetCanvas()->cd(0);
endviewB->GetCanvas()->Clear();

// ----- FCAL ------
// Get list of blocks. Loop over all getting x,y coordinates of corners for all active ones.

// Set up 4 2-D vectors that point from the center of a block to its
// corners. This makes it easier to represent each corner as a vector
// in lab corrdinate whch we can extract r, phi from.
double blocksize = fcalgeom->blockSize();
DVector2 shift[8];
shift[0].Set(-blocksize/2, -blocksize/2);  // these are ordered such that they
shift[1].Set(-blocksize/2, +blocksize/2);  // go in a clockwise manner. This
shift[2].Set(+blocksize/2, +blocksize/2);  // ensures the r/phi cooridinates also
shift[3].Set(+blocksize/2, -blocksize/2);  // define a single enclosed space

double insertSize=fcalgeom->insertSize();
if (insertSize>0){
  blocksize=fcalgeom->insertBlockSize();
  shift[4].Set(-blocksize/2, -blocksize/2);  // these are ordered such that they
  shift[5].Set(-blocksize/2, +blocksize/2);  // go in a clockwise manner. This
  shift[6].Set(+blocksize/2, +blocksize/2);  // ensures the r/phi cooridinates also
  shift[7].Set(+blocksize/2, -blocksize/2);  // define a single enclosed space	  
}
fcalblocks.clear();
for(unsigned int chan=0; chan<fcalgeom->numChannels(); chan++){ 
  if (fcalgeom->isBlockActive(chan)==false) continue;
  DVector2 fcalBlockPos=fcalgeom->positionOnFace(chan);

  double r[4], phi[4];
  for(int i=0; i<4; i++){
    DVector2 pos = fcalBlockPos; 
    if (insertSize>0 
	  && fabs(pos.X())<insertSize
	  && fabs(pos.Y())<insertSize){
      pos+=shift[i+4];
    }
    else{
      pos+=shift[i];
    }
    r[i] = pos.Mod();
    phi[i] = pos.Phi_0_2pi(pos.Phi());
  }
  
  TPolyLine *poly = new TPolyLine(4, phi, r);
  poly->SetFillColor(18);
  poly->SetLineColor(kBlack);
  graphics_endB.push_back(poly);
  
  fcalblocks[chan] = poly; // record so we can set the color later
}
}

//=============== Draw axes arrows
DrawAxes(sideviewA->GetCanvas(), graphics_sideA, "Z", "R");
DrawAxes(sideviewB->GetCanvas(), graphics_sideB, "Z", "#phi");
DrawAxes(endviewA->GetCanvas(), graphics_endA, "#phi", "R");
DrawAxes(endviewB->GetCanvas(), graphics_endB, "#phi", "R");
2055}

2057//-------------------
2058// DrawAxes
2059//-------------------
2060void hdv_mainframe::DrawAxes(TCanvas *c, vector<TObject*> &graphics, const char *xlab, const char *ylab)
2061{
/// Create arrows indicating x and y axes with labels on the specified canvas
/// and add them to the specified container of graphics objects to be draw later.
double x1 = c->GetX1();
double x2 = c->GetX2();
double y1 = c->GetY1();
double y2 = c->GetY2();
double deltax = x2-x1;
deltax *= c->GetYsizeReal()/c->GetXsizeReal();
double deltay = y2-y1;
double xlo = x1+0.04*deltax;
double xhi = xlo + 0.075*deltax;
double ylo = y1+0.04*deltay;
double yhi = ylo + 0.075*deltay;
TArrow *yarrow = new TArrow(xlo, ylo, xlo, yhi, 0.02, ">");
yarrow->SetLineWidth((Width_t)1.5);
graphics.push_back(yarrow);

TLatex *ylabel = new TLatex(xlo, yhi+0.005*deltay, ylab);
ylabel->SetTextAlign(21);
graphics.push_back(ylabel);

TArrow *xarrow = new TArrow(xlo, ylo, xhi, ylo, 0.02, ">");
xarrow->SetLineWidth((Width_t)1.5);
graphics.push_back(xarrow);

TLatex *xlabel = new TLatex(xhi+0.005*deltax, ylo, xlab);
xlabel->SetTextAlign(12);
graphics.push_back(xlabel);
2090}

2092//-------------------
2093// DrawScale
2094//-------------------
2095void hdv_mainframe::DrawScale(TCanvas *c, vector<TObject*> &graphics)
2096{
/// Create a scale label on the specified canvas and add it 
/// to the specified container of graphics objects to be draw later.
double x1 = c->GetX1();
double x2 = c->GetX2();
double y1 = c->GetY1();
double y2 = c->GetY2();
double deltax = x2-x1;
double deltay = y2-y1;
double p = floor(log(0.1*deltax)/log(10.0));
double m = floor(0.1*deltax/pow(10.0, p) + 0.5);
double xlo = x1+0.72*deltax;
double xhi = xlo + m*pow(10.0, p);
double y = y1+0.04*deltay;
TArrow *arrow = new TArrow(xlo, y, xhi, y, 0.02, "|-|");
arrow->SetLineWidth((Width_t)1.0);
graphics.push_back(arrow);

const char *units="<out of range>";
switch((int)p){
case -5:
	units = "#mum";
	break;
case -4:
	units = "#mum";
	break;
case -3:
	m*=10.0;
	units = "#mum";
	break;
case -2:
	m*=100.0;
	units="#mum";
	break;
case -1:
	units="mm";
	break;
case 0:
	units = "cm";
	break;
case 1:
	m*=10.0;
	units = "cm";
	break;
case 2:
	units = "m";
	break;
case 3:
	m*=10.0;
	units = "m";
	break;
case 4:
	m*=100.0;
	units = "m";
	break;
case 5:
	units = "km";
	break;
case 6:
	m*=10.0;
	units = "km";
	break;
}
char str[256];
sprintf(str,"%d %s", (int)m, units);
TLatex *label = new TLatex(xhi+0.01*deltax, y, str);
label->SetTextAlign(12);
graphics.push_back(label);
2164}

2166//-------------------
2167// DrawLabel
2168//-------------------
2169void hdv_mainframe::DrawLabel(TCanvas *c, vector<TObject*> &graphics, const char *txt)
2170{
/// Create label on top of the specified canvas
/// and add it to the specified container of graphics
/// objects to be drawn later.
double x1 = c->GetX1();
double x2 = c->GetX2();
double y1 = c->GetY1();
double y2 = c->GetY2();
double deltax = x2-x1;
double deltay = y2-y1;
deltax *= c->GetYsizeReal()/c->GetXsizeReal();
double x = x1 + 0.005*deltax;
double y = y2 - 0.003*deltay;

TLatex *label = new TLatex(x, y, txt);
label->SetTextAlign(13);
label->SetTextSize(0.045);
graphics.push_back(label);
2188}


2191//-------------------
2192// SetEvent
2193//-------------------
2194void hdv_mainframe::SetEvent(ULong64_t id)
2195{
if(!event)return;

stringstream ss;
ss << id;
event->SetTitle(ss.str().c_str());
event->Draw();
2202}

2204//-------------------
2205// SetRun
2206//-------------------
2207void hdv_mainframe::SetRun(Int_t id)
2208{
if(!event)return;

stringstream ss;
ss << id;
run->SetTitle(ss.str().c_str());
run->Draw();
2215}

2217//-------------------
2218// SetTrig
2219//-------------------
2220void hdv_mainframe::SetTrig(char *trigstring)
2221{
if(!event)return;

trig->SetTitle(trigstring);
trig->Draw();
2226}


2229//-------------------
2230// SetSource
2231//-------------------
2232void hdv_mainframe::SetSource(string source)
2233{
this->source->SetTitle(source.c_str());
this->source->Draw();
2236}

2238//-------------------
2239// SetCandidateFactories
2240//-------------------
2241void hdv_mainframe::SetCandidateFactories(vector<string> &facnames)
2242{
/// Filter out the factories that provide "DTrackCandidate" objects
/// and add their tags to the tracksfactory combobox.
// Erase all current entries in the combobox and add back in
// "<default>".
candidatesfactory->RemoveAll();
candidatesfactory->AddEntry("<default>", 0);
candidatesfactory->GetTextEntry()->SetText("<default>");
candidatesfactory->Select(0, kFALSE);

for(unsigned int i=0; i< facnames.size(); i++){
string name = "DTrackCandidate:";
string::size_type pos = facnames[i].find(name);
if(pos==string::npos)continue;
string tag = facnames[i];
tag.erase(0, name.size());
candidatesfactory->AddEntry(tag.c_str(), i);
if(tag==default_candidate){
	candidatesfactory->Select(i, kTRUE);
	candidatesfactory->GetTextEntry()->SetText(tag.c_str());
}
}
2264}

2266//-------------------
2267// SetWireBasedTrackFactories
2268//-------------------
2269void hdv_mainframe::SetWireBasedTrackFactories(vector<string> &facnames)
2270{
/// Filter out the factories that provide "DTrackWireBased" objects
/// and add their tags to the tracksfactory combobox.

// Erase all current entries in the combobox and add back in
// "<default>".
wiretracksfactory->RemoveAll();
wiretracksfactory->AddEntry("<default>", 0);
wiretracksfactory->GetTextEntry()->SetText("<default>");
wiretracksfactory->Select(0, kFALSE);

for(unsigned int i=0; i< facnames.size(); i++){
string name = "DTrackWireBased:";
string::size_type pos = facnames[i].find(name);
if(pos==string::npos)continue;
string tag = facnames[i];
tag.erase(0, name.size());
wiretracksfactory->AddEntry(tag.c_str(), i+1);
if(tag==default_track){
	wiretracksfactory->Select(i, kTRUE);
	wiretracksfactory->GetTextEntry()->SetText(tag.c_str());
}
}
2293}

2295//-------------------
2296// SetTimeBasedTrackFactories
2297//-------------------
2298void hdv_mainframe::SetTimeBasedTrackFactories(vector<string> &facnames)
2299{
/// Filter out the factories that provide "DTrackTimeBased" objects
/// and add their tags to the timetracksfactory combobox.

// Erase all current entries in the combobox and add back in
// "<default>".
timetracksfactory->RemoveAll();
timetracksfactory->AddEntry("<default>", 0);
timetracksfactory->GetTextEntry()->SetText("<default>");
timetracksfactory->Select(0, kFALSE);

for(unsigned int i=0; i< facnames.size(); i++){
string name = "DTrackTimeBased:";
string::size_type pos = facnames[i].find(name);
if(pos==string::npos)continue;
string tag = facnames[i];
tag.erase(0, name.size());
timetracksfactory->AddEntry(tag.c_str(), i+1);
if(tag==default_track){
	timetracksfactory->Select(i, kTRUE);
	timetracksfactory->GetTextEntry()->SetText(tag.c_str());
}
}
2322}

2324//-------------------
2325// SetChargedTrackFactories
2326//-------------------
2327void hdv_mainframe::SetChargedTrackFactories(vector<string> &facnames)
2328{
/// Filter out the factories that provide "DChargedTrack" objects
/// and add their tags to the chargedtracksfactory combobox.

// Erase all current entries in the combobox and add back in
// "<default>".
chargedtracksfactory->RemoveAll();
chargedtracksfactory->AddEntry("<default>", 0);
chargedtracksfactory->GetTextEntry()->SetText("<default>");
chargedtracksfactory->Select(0, kFALSE);

for(unsigned int i=0; i< facnames.size(); i++){
string name = "DChargedTrack:";
string::size_type pos = facnames[i].find(name);
if(pos==string::npos)continue;
string tag = facnames[i];
tag.erase(0, name.size());
chargedtracksfactory->AddEntry(tag.c_str(), i+1);
if(tag==default_track){
	chargedtracksfactory->Select(i, kTRUE);
	chargedtracksfactory->GetTextEntry()->SetText(tag.c_str());
}
}
2351}



2355//-------------------
2356// SetReconstructedFactories
2357//-------------------
2358void hdv_mainframe::SetReconstructedFactories(vector<string> &facnames)
2359{
/// Filter out the factories that provide "DTrack" objects
/// and add them to the reconfactory combobox.

// Erase all current entries in the combobox and add back in
// "<default>".
int id =0;
reconfactory->RemoveAll();
reconfactory->AddEntry("DTrackTimeBased:", id++);
reconfactory->Select(0, kFALSE);
reconfactory->GetTextEntry()->SetText("DTrackTimeBased:");

// Add DTrackTimeBased factories
for(unsigned int i=0; i< facnames.size(); i++){
string name = "DTrackTimeBased:";
string::size_type pos = facnames[i].find(name);
if(pos==string::npos)continue;
string tag = facnames[i].substr(name.size(), facnames[i].size()-name.size());
reconfactory->AddEntry(facnames[i].c_str(), id++);
if(facnames[i]==default_reconstructed){
	reconfactory->Select(id-1, kTRUE);
	reconfactory->GetTextEntry()->SetText(facnames[i].c_str());
}
}

// Add DTrackWireBased factories
reconfactory->AddEntry("DTrackWireBased:", id++);
for(unsigned int i=0; i< facnames.size(); i++){
string name = "DTrackWireBased:";
string::size_type pos = facnames[i].find(name);
if(pos==string::npos)continue;
string tag = facnames[i].substr(name.size(), facnames[i].size()-name.size());
reconfactory->AddEntry(facnames[i].c_str(), id++);
if(facnames[i]==default_reconstructed){
	reconfactory->Select(id-1, kTRUE);
	reconfactory->GetTextEntry()->SetText(facnames[i].c_str());
}
}

// Add DTrackCandidate factories
reconfactory->AddEntry("DTrackCandidate:", id++);
for(unsigned int i=0; i< facnames.size(); i++){
string name = "DTrackCandidate:";
string::size_type pos = facnames[i].find(name);
if(pos==string::npos)continue;
string tag = facnames[i].substr(name.size(), facnames[i].size()-name.size());
reconfactory->AddEntry(facnames[i].c_str(), id++);
if(facnames[i]==default_reconstructed){
	reconfactory->Select(id-1, kTRUE);
	reconfactory->GetTextEntry()->SetText(facnames[i].c_str());
}
}


// Add DNeutralTrack factories
reconfactory->AddEntry("DNeutralParticle:", id++);
for(unsigned int i=0; i< facnames.size(); i++){
string name = "DNeutralParticle:";
string::size_type pos = facnames[i].find(name);
if(pos==string::npos)continue;
string tag = facnames[i].substr(name.size(), facnames[i].size()-name.size());
reconfactory->AddEntry(facnames[i].c_str(), id++);
if(facnames[i]==default_reconstructed){
	reconfactory->Select(id-1, kTRUE);
	reconfactory->GetTextEntry()->SetText(facnames[i].c_str());
}
}

// Add DChargedTrack factories
reconfactory->AddEntry("DChargedTrack:", id++);
for(unsigned int i=0; i< facnames.size(); i++){
string name = "DChargedTrack:";
string::size_type pos = facnames[i].find(name);
if(pos==string::npos)continue;
string tag = facnames[i].substr(name.size(), facnames[i].size()-name.size());
reconfactory->AddEntry(facnames[i].c_str(), id++);
if(facnames[i]==default_reconstructed){
	reconfactory->Select(id-1, kTRUE);
	reconfactory->GetTextEntry()->SetText(facnames[i].c_str());
}
}


2442}

2444//-------------------
2445// GetCheckButton
2446//-------------------
2447bool hdv_mainframe::GetCheckButton(string who)
2448{
map<string, TGCheckButton*>::iterator iter = checkbuttons.find(who);
if(iter==checkbuttons.end())return false;
return iter->second->GetState()==kButtonDown;
2452}
2453//-------------------
2454// AddCheckButtons
2455//-------------------
2456void hdv_mainframe::AddCheckButtons(map<string, TGCheckButton*> &checkbuttons)
2457{
this->checkbuttons.insert(checkbuttons.begin(), checkbuttons.end());
2459}

2461//-------------------
2462// GetFactoryTag
2463//-------------------
2464const char* hdv_mainframe::GetFactoryTag(string who)
2465{
const char *tag = "";

if(who=="DTrackWireBased"){
tag = wiretracksfactory->GetTextEntry()->GetTitle();
//tag = wiretracksfactory->GetSelectedEntry()->GetTitle();
}
if(who=="DTrackCandidate"){
tag = candidatesfactory->GetTextEntry()->GetTitle();
//tag = candidatesfactory->GetSelectedEntry()->GetTitle();
}
if(who=="DTrackTimeBased"){
tag = timetracksfactory->GetTextEntry()->GetTitle();
//tag = timetracksfactory->GetSelectedEntry()->GetTitle();
}
if (who=="DChargedTrack"){
 tag=chargedtracksfactory->GetTextEntry()->GetTitle();
}
if(string(tag) == "<default>")tag = "";

return tag;
2486}

2488//-------------------
2489// GetReconFactory
2490//-------------------
2491void hdv_mainframe::GetReconFactory(string &name, string &tag)
2492{
if(!reconfactory) return;
if(!reconfactory->GetSelectedEntry()) return;
if(!reconfactory->GetSelectedEntry()->GetTitle()) return;
string nametag(reconfactory->GetSelectedEntry()->GetTitle());
string::size_type pos = nametag.find(":");
name = nametag.substr(0, pos);
tag = nametag.substr(pos+1, nametag.size()-(pos+1));
2500}

2502//-------------------
2503// GetFCALPolyLine
2504//-------------------
2505TPolyLine* hdv_mainframe::GetFCALPolyLine(int channel)
2506{
map<int, TPolyLine*>::iterator iter = fcalblocks.find(channel);
if(iter==fcalblocks.end())return NULL__null;
return iter->second;
2510}

2512//-------------------
2513// GetFCALPolyLine
2514//-------------------
2515TPolyLine* hdv_mainframe::GetFCALPolyLine(int row, int column)
2516{
if(!fcalgeom)return NULL__null;
return GetFCALPolyLine(fcalgeom->channel(row, column));
2519}

2521//-------------------
2522// GetCCALPolyLine
2523//-------------------
2524TPolyLine* hdv_mainframe::GetCCALPolyLine(int row, int col)
2525{
int channel = col + 12*(row);
map<int, TPolyLine*>::iterator iter = ccalblocks.find(channel);
if(iter==ccalblocks.end())return NULL__null;
return iter->second;
2530}

2532//------------------- 
2533// GetTOFPolyLine
2534//-------------------

2536TPolyLine* hdv_mainframe::GetTOFPolyLine(int translate_side, int tof_ch)
2537{
map <int, map<int, TPolyLine*> >::iterator iter;
iter = tofblocks.find(translate_side);
map <int, TPolyLine*>::iterator iter2 = iter->second.find(tof_ch);
if(iter2==iter->second.end())return NULL__null;
return iter2->second;
2543}

2545//-------------------
2546// GetBCALPolyLine
2547//-------------------
2548TPolyLine* hdv_mainframe::GetBCALPolyLine(int module, int layer, int sector)
2549{
int chan = module*1000 + layer*100 + sector*10;
map<int, TPolyLine*>::iterator iter = bcalblocks.find(chan);
if(iter==bcalblocks.end()){
_DBG_std::cerr<<"programs/Analysis/hdview2/hdv_mainframe.cc"
<<":"<<2553<<" "<<"ERROR: No BCAL readout segment display poly for module="<<module<<" layer="<<layer<<" sector="<<sector<<endl;
return NULL__null;
}
return iter->second;
2557}

2559//-------------------
2560// AddGraphicsSideA
2561//-------------------
2562void hdv_mainframe::AddGraphicsSideA(vector<TObject*> &v)
2563{
for(unsigned int i=0; i<v.size(); i++)graphics_sideA.push_back(v[i]);
2565}

2567//-------------------
2568// AddGraphicsSideB
2569//-------------------
2570void hdv_mainframe::AddGraphicsSideB(vector<TObject*> &v)
2571{
for(unsigned int i=0; i<v.size(); i++)graphics_sideB.push_back(v[i]);
2573}

2575//-------------------
2576// AddGraphicsEndA
2577//-------------------
2578void hdv_mainframe::AddGraphicsEndA(vector<TObject*> &v)
2579{
for(unsigned int i=0; i<v.size(); i++)graphics_endA.push_back(v[i]);
2581}

2583//-------------------
2584// AddGraphicsEndB
2585//-------------------
2586void hdv_mainframe::AddGraphicsEndB(vector<TObject*> &v)
2587{
for(unsigned int i=0; i<v.size(); i++)graphics_endB.push_back(v[i]);
2589}

←

/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h

→

1// $Id: JEventLoop.h 1763 2006-05-10 14:29:25Z davidl $
2//
3//    File: JEventLoop.h
4// Created: Wed Jun  8 12:30:51 EDT 2005
5// Creator: davidl (on Darwin wire129.jlab.org 7.8.0 powerpc)
6//

8#ifndef _JEventLoop_
9#define _JEventLoop_

11#include <sys/time.h>

13#include <vector>
14#include <list>
15#include <string>
16#include <utility>
17#include <typeinfo>
18#include <string.h>
19#include <map>
20#include <utility>
21using std::vector;
22using std::list;
23using std::string;
24using std::type_info;

26#include <JANA/jerror.h>
27#include <JANA/JObject.h>
28#include <JANA/JException.h>
29#include <JANA/JEvent.h>
30#include <JANA/JThread.h>
31#include <JANA/JFactory_base.h>
32#include <JANA/JCalibration.h>
33#include <JANA/JGeometry.h>
34#include <JANA/JResourceManager.h>
35#include <JANA/JStreamLog.h>

37// The following is here just so we can use ROOT's THtml class to generate documentation.
38#include "cint.h"


41// Place everything in JANA namespace
42namespace jana{


45template<class T> class JFactory;
46class JApplication;
47class JEventProcessor;


50class JEventLoop{
public:

friend class JApplication;

enum data_source_t{
	DATA_NOT_AVAILABLE = 1,
	DATA_FROM_CACHE,
	DATA_FROM_SOURCE,
	DATA_FROM_FACTORY
};

typedef struct{
	string caller_name;
	string caller_tag;
	string callee_name;
	string callee_tag;
	double start_time;
	double end_time;
	data_source_t data_source;
}call_stack_t;

typedef struct{
	const char* factory_name;
	string tag;
	const char* filename;
	int line;
}error_call_stack_t;

                                  JEventLoop(JApplication *app); ///< Constructor
					   virtual ~JEventLoop(); ////< Destructor
		   virtual const char* className(void){return static_className();}
			static const char* static_className(void){return "JEventLoop";}

				 JApplication* GetJApplication(void) const {return app;} ///< Get pointer to the JApplication object
                                void RefreshProcessorListFromJApplication(void); ///< Re-copy the list of JEventProcessors from JApplication
                    virtual jerror_t AddFactory(JFactory_base* factory); ///< Add a factory
					  jerror_t RemoveFactory(JFactory_base* factory); ///< Remove a factory
                      JFactory_base* GetFactory(const string data_name, const char *tag="", bool allow_deftag=true); ///< Get a specific factory pointer
              vector<JFactory_base*> GetFactories(void) const {return factories;} ///< Get all factory pointers
                                void GetFactoryNames(vector<string> &factorynames); ///< Get names of all factories in name:tag format
                                void GetFactoryNames(map<string,string> &factorynames); ///< Get names of all factories in map with key=name, value=tag
                  map<string,string> GetDefaultTags(void) const {return default_tags;}
                            jerror_t ClearFactories(void); ///< Reset all factories in preparation for next event.
					  jerror_t PrintFactories(int sparsify=0); ///< Print a list of all factories.
                            jerror_t Print(const string data_name, const char *tag=""); ///< Print the data of the given type

				 JCalibration* GetJCalibration();
              template<class T> bool GetCalib(string namepath, map<string,T> &vals);
              template<class T> bool GetCalib(string namepath, vector<T> &vals);
              template<class T> bool GetCalib(string namepath, T &val);

                          JGeometry* GetJGeometry();
              template<class T> bool GetGeom(string namepath, map<string,T> &vals);
	    template<class T> bool GetGeom(string namepath, T &val);

                   JResourceManager* GetJResourceManager(void);
                              string GetResource(string namepath);
              template<class T> bool GetResource(string namepath, T vals, int event_number=0);

                                void Initialize(void); ///< Do initializations just before event processing starts
                            jerror_t Loop(void); ///< Loop over events
                            jerror_t OneEvent(uint64_t event_number); ///< Process a specific single event (if source supports it)
                            jerror_t OneEvent(void); ///< Process a single event
                         inline void Pause(void){pause = 1;} ///< Pause event processing
                         inline void Resume(void){pause = 0;} ///< Resume event processing
                         inline void Quit(void){quit = 1;} ///< Clean up and exit the event loop
                         inline bool GetQuit(void) const {return quit;}
                                void QuitProgram(void);

                               // Support for random access of events
                          bool HasRandomAccess(void);
                          void AddToEventQueue(uint64_t event_number){ next_events_to_process.push_back(event_number); }
                          void AddToEventQueue(list<uint64_t> &event_numbers) { next_events_to_process.insert(next_events_to_process.end(), event_numbers.begin(), event_numbers.end()); }
                list<uint64_t> GetEventQueue(void){ return next_events_to_process; }
                          void ClearEventQueue(void){ next_events_to_process.clear(); }

      template<class T> JFactory<T>* GetSingle(const T* &t, const char *tag="", bool exception_if_not_one=true); ///< Get pointer to first data object from (source or factory).
      template<class T> JFactory<T>* Get(vector<const T*> &t, const char *tag="", bool allow_deftag=true); ///< Get data object pointers from (source or factory)
      template<class T> JFactory<T>* GetFromFactory(vector<const T*> &t, const char *tag="", data_source_t &data_source=null_data_source, bool allow_deftag=true); ///< Get data object pointers from factory
          template<class T> jerror_t GetFromSource(vector<const T*> &t, JFactory_base *factory=NULL__null); ///< Get data object pointers from source.
                      inline JEvent& GetJEvent(void){return event;} ///< Get pointer to the current JEvent object.
                         inline void SetJEvent(JEvent *event){this->event = *event;} ///< Set the JEvent pointer.
                         inline void SetAutoFree(int auto_free){this->auto_free = auto_free;} ///< Set the Auto-Free flag on/off
                    inline pthread_t GetPThreadID(void) const {return pthread_id;} ///< Get the pthread of the thread to which this JEventLoop belongs
                              double GetInstantaneousRate(void) const {return rate_instantaneous;} ///< Get the current event processing rate
                              double GetIntegratedRate(void) const {return rate_integrated;} ///< Get the current event processing rate
                              double GetLastEventProcessingTime(void) const {return delta_time_single;}
                        unsigned int GetNevents(void) const {return Nevents;}

                         inline bool CheckEventBoundary(uint64_t event_numberA, uint64_t event_numberB);

                         inline bool GetCallStackRecordingStatus(void){ return record_call_stack; }
                         inline void DisableCallStackRecording(void){ record_call_stack = false; }
                         inline void EnableCallStackRecording(void){ record_call_stack = true; }
                     inline void CallStackStart(JEventLoop::call_stack_t &cs, const string &caller_name, const string &caller_tag, const string callee_name, const string callee_tag);
                     inline void CallStackEnd(JEventLoop::call_stack_t &cs);
         inline vector<call_stack_t> GetCallStack(void){return call_stack;} ///< Get the current factory call stack
                         inline void AddToCallStack(call_stack_t &cs){if(record_call_stack) call_stack.push_back(cs);} ///< Add specified item to call stack record but only if record_call_stack is true
                         inline void AddToErrorCallStack(error_call_stack_t &cs){error_call_stack.push_back(cs);} ///< Add layer to the factory call stack
   inline vector<error_call_stack_t> GetErrorCallStack(void){return error_call_stack;} ///< Get the current factory error call stack
                                void PrintErrorCallStack(void); ///< Print the current factory call stack

                      const JObject* FindByID(JObject::oid_t id); ///< Find a data object by its identifier.
          template<class T> const T* FindByID(JObject::oid_t id); ///< Find a data object by its type and identifier
                      JFactory_base* FindOwner(const JObject *t); ///< Find the factory that owns a data object by pointer
                      JFactory_base* FindOwner(JObject::oid_t id); ///< Find a factory that owns a data object by identifier

                                     // User defined references
              template<class T> void SetRef(T *t);    ///< Add a user reference to this JEventLoop (must be a pointer)
                template<class T> T* GetRef(void);   ///< Get a user-defined reference of a specific type
        template<class T> vector<T*> GetRefsT(void); ///< Get all user-defined refrences of a specicif type
   vector<pair<const char*, void*> > GetRefs(void){ return user_refs; }  ///< Get copy of full list of user-defined references
              template<class T> void RemoveRef(T *t); ///< Remove user reference from list

							   // Convenience methods wrapping JEvent methods of same name
                      uint64_t GetStatus(void){return event.GetStatus();}
                          bool GetStatusBit(uint32_t bit){return event.GetStatusBit(bit);}
                          bool SetStatusBit(uint32_t bit, bool val=true){return event.SetStatusBit(bit, val);}
                          bool ClearStatusBit(uint32_t bit){return event.ClearStatusBit(bit);}
                          void ClearStatus(void){event.ClearStatus();}
                          void SetStatusBitDescription(uint32_t bit, string description){event.SetStatusBitDescription(bit, description);}
                        string GetStatusBitDescription(uint32_t bit){return event.GetStatusBitDescription(bit);}
                          void GetStatusBitDescriptions(map<uint32_t, string> &status_bit_descriptions){return event.GetStatusBitDescriptions(status_bit_descriptions);}
                              string StatusWordToString(void);

private:
JEvent event;
vector<JFactory_base*> factories;
vector<JEventProcessor*> processors;
vector<error_call_stack_t> error_call_stack;
vector<call_stack_t> call_stack;
JApplication *app;
JThread *jthread;
bool initialized;
bool print_parameters_called;
int pause;
int quit;
int auto_free;
pthread_t pthread_id;
map<string, string> default_tags;
vector<pair<string,string> > auto_activated_factories;
bool record_call_stack;
string caller_name;
string caller_tag;
vector<uint64_t> event_boundaries;
int32_t event_boundaries_run; ///< Run number boundaries were retrieved from (possbily 0)
list<uint64_t> next_events_to_process;

uint64_t Nevents;			      ///< Total events processed (this thread)
uint64_t Nevents_rate;		   ///< Num. events accumulated for "instantaneous" rate
double delta_time_single;		///< Time spent processing last event
double delta_time_rate;			///< Integrated time accumulated "instantaneous" rate (partial number of events)
double delta_time;				///< Total time spent processing events (this thread)
double rate_instantaneous;		///< Latest instantaneous rate
double rate_integrated;			///< Rate integrated over all events
 
static data_source_t null_data_source;

vector<pair<const char*, void*> > user_refs;
210};


213// The following is here just so we can use ROOT's THtml class to generate documentation.
214#ifdef G__DICTIONARY
215typedef JEventLoop::call_stack_t call_stack_t;
216typedef JEventLoop::error_call_stack_t error_call_stack_t;
217#endif

219#if !defined(__CINT__) && !defined(__CLING__)

221//-------------
222// GetSingle
223//-------------
224template<class T>
225JFactory<T>* JEventLoop::GetSingle(const T* &t, const char *tag, bool exception_if_not_one)
226{
/// This is a convenience method that can be used to get a pointer to the single
/// object of type T from the specified factory. It simply calls the Get(vector<...>) method
/// and copies the first pointer into "t" (or NULL if something other than 1 object is returned).
/// 
/// This is intended to address the common situation in which there is an interest
/// in the event if and only if there is exactly 1 object of type T. If the event
/// has no objects of that type or more than 1 object of that type (for the specified
/// factory) then an exception of type "unsigned long" is thrown with the value
/// being the number of objects of type T. You can supress the exception by setting
/// exception_if_not_one to false. In that case, you will have to check if t==NULL to
/// know if the call succeeded.
vector<const T*> v;
JFactory<T> *fac = Get(v, tag);

if(v.size()!=1){
t = NULL__null;
if(exception_if_not_one) throw v.size();
}

t = v[0];

return fac;
249}

251//-------------
252// Get
253//-------------
254template<class T> 
255JFactory<T>* JEventLoop::Get(vector<const T*> &t, const char *tag, bool allow_deftag)
256{
/// Retrieve or generate the array of objects of
/// type T for the curent event being processed
/// by this thread.
///
/// By default, preference is given to reading the
/// objects from the data source(e.g. file) before generating
/// them in the factory. A flag exists in the factory
/// however to change this so that the factory is
/// given preference.
///
/// Note that regardless of the setting of this flag,
/// the data are only either read in or generated once.
/// Ownership of the objects will always be with the
/// factory so subsequent calls will always return pointers to
/// the same data.
///
/// If the factory is called on to generate the data,
/// it is done by calling the factory's Get() method
/// which, in turn, calls the evnt() method. 
/// 
/// First, we just call the GetFromFactory() method.
/// It will make the initial decision as to whether
/// it should look in the source first or not. If
/// it returns NULL, then the factory couldn't be
/// found so we automatically try the file.
///
/// Note that if no factory exists to hold the objects
/// from the file, one can be created automatically
/// providing the <i>JANA:AUTOFACTORYCREATE</i>
/// configuration parameter is set.

// Check if a tag was specified for this data type to use for the
// default.
const char *mytag = tag8.1
'tag' is not equal to NULL
1
'tag' is not equal to NULL
1
'tag' is not equal to NULL
==NULL__null ? "":tag; // protection against NULL tags
9
←
'?' condition is false→
if(strlen(mytag)==0 && allow_deftag9.1
'allow_deftag' is true
1
'allow_deftag' is true
1
'allow_deftag' is true
){
10
←
Taking true branch→
map<string, string>::const_iterator iter = default_tags.find(T::static_className());
if(iter!=default_tags.end())tag = iter->second.c_str();
11
←
Assuming the condition is true→
12
←
Taking true branch→
13
←
Value assigned to 'tag'→
}


// If we are trying to keep track of the call stack then we
// need to add a new call_stack_t object to the the list
// and initialize it with the start time and caller/callee
// info.
call_stack_t cs;

// Optionally record starting info of call stack entry
if(record_call_stack) CallStackStart(cs, caller_name, caller_tag, T::static_className(), tag);
14
←
Assuming field 'record_call_stack' is false→
15
←
Taking false branch→

// Get the data (or at least try to)
JFactory<T>* factory=NULL__null;
try{
factory = GetFromFactory(t, tag, cs.data_source, allow_deftag);
16
←
Passing value via 2nd parameter 'tag'→
17
←
Calling 'JEventLoop::GetFromFactory'→
if(!factory){
	// No factory exists for this type and tag. It's possible
	// that the source may be able to provide the objects
	// but it will need a place to put them. We can create a
	// dumb JFactory just to hold the data in case the source
	// can provide the objects. Before we do though, make sure
	// the user condones this via the presence of the
	// "JANA:AUTOFACTORYCREATE" config parameter.
	string p;
	try{
		gPARMS->GetParameter("JANA:AUTOFACTORYCREATE", p);
	}catch(...){}
	if(p.size()==0){
		jout<<std::endl;
		_DBG__std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<324<<std::endl;
		jout<<"No factory of type \""<<T::static_className()<<"\" with tag \""<<tag<<"\" exists."<<std::endl;
		jout<<"If you are reading objects from a file, I can auto-create a factory"<<std::endl;
		jout<<"of the appropriate type to hold the objects, but this feature is turned"<<std::endl;
		jout<<"off by default. To turn it on, set the \"JANA:AUTOFACTORYCREATE\""<<std::endl;
		jout<<"configuration parameter. This can usually be done by passing the"<<std::endl;
		jout<<"following argument to the program from the command line:"<<std::endl;
		jout<<std::endl;
		jout<<"   -PJANA:AUTOFACTORYCREATE=1"<<std::endl;
		jout<<std::endl;
		jout<<"Note that since the most commonly expected occurance of this situation."<<std::endl;
		jout<<"is an error, the program will now throw an exception so that the factory."<<std::endl;
		jout<<"call stack can be printed."<<std::endl;
		jout<<std::endl;
		throw exception();
	}else{
		AddFactory(new JFactory<T>(tag));
		jout<<__FILE__"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"<<":"<<__LINE__341<<" Auto-created "<<T::static_className()<<":"<<tag<<" factory"<<std::endl;
	
		// Now try once more. The GetFromFactory method will call
		// GetFromSource since it's empty.
		factory = GetFromFactory(t, tag, cs.data_source, allow_deftag);
	}
}
}catch(exception &e){
// Uh-oh, an exception was thrown. Add us to the call stack
// and re-throw the exception
error_call_stack_t ecs;
ecs.factory_name = T::static_className();
ecs.tag = tag;
ecs.filename = NULL__null;
error_call_stack.push_back(ecs);
throw e;
}

// If recording the call stack, update the end_time field and add to stack
if(record_call_stack) CallStackEnd(cs);

return factory;
363}

365//-------------
366// GetFromFactory
367//-------------
368template<class T> 
369JFactory<T>* JEventLoop::GetFromFactory(vector<const T*> &t, const char *tag, data_source_t &data_source, bool allow_deftag)
370{
// We need to find the factory providing data type T with
// tag given by "tag". 
vector<JFactory_base*>::iterator iter=factories.begin();
JFactory<T> *factory = NULL__null;
string className(T::static_className());

// Check if a tag was specified for this data type to use for the
// default.
const char *mytag = tag==NULL__null ? "":tag; // protection against NULL tags
18
←
Assuming 'tag' is equal to NULL→
19
←
'?' condition is true→
if(strlen(mytag)==0 && allow_deftag19.1
'allow_deftag' is true
1
'allow_deftag' is true
1
'allow_deftag' is true
){
20
←
Taking true branch→
map<string, string>::const_iterator iter = default_tags.find(className);
if(iter!=default_tags.end())tag = iter->second.c_str();
21
←
Assuming the condition is false→
22
←
Taking false branch→
}

for(; iter!=factories.end(); iter++){
23
←
Calling 'operator!=<jana::JFactory_base **, std::vector<jana::JFactory_base *>>'→
26
←
Returning from 'operator!=<jana::JFactory_base **, std::vector<jana::JFactory_base *>>'→
27
←
Loop condition is true.  Entering loop body→
// It turns out a long standing bug in g++ makes dynamic_cast return
// zero improperly when used on objects created on one side of
// a dynamically shared object (DSO) and the cast occurs on the 
// other side. I saw bug reports ranging from 2001 to 2004. I saw
// saw it first-hand on LinuxEL4 using g++ 3.4.5. This is too bad
// since it is much more elegant (and safe) to use dynamic_cast.
// To avoid this problem which can occur with plugins, we check
// the name of the data classes are the same. (sigh)
//factory = dynamic_cast<JFactory<T> *>(*iter);
if(className == (*iter)->GetDataClassName())factory = (JFactory<T>*)(*iter);
28
←
Taking true branch→
if(factory == NULL__null)continue;
29
←
Assuming 'factory' is not equal to NULL→
30
←
Taking false branch→
const char *factag = factory->Tag()==NULL__null ? "":factory->Tag();
31
←
Assuming the condition is true→
32
←
'?' condition is true→
if(!strcmp(factag, tag)){
33
←
Null pointer passed to 2nd parameter expecting 'nonnull'
	break;
}else{
	factory=NULL__null;
}
}

// If factory not found, just return now
if(!factory){
data_source = DATA_NOT_AVAILABLE;
return NULL__null;
}

// OK, we found the factory. If the evnt() routine has already
// been called, then just call the factory's Get() routine
// to return a copy of the existing data
if(factory->evnt_was_called()){
factory->CopyFrom(t);
data_source = DATA_FROM_CACHE;
return factory;
}

// Next option is to get the objects from the data source
if(factory->GetCheckSourceFirst()){
// If the object type/tag is found in the source, it
// will return NOERROR, even if there are zero instances
// of it. If it is not available in the source then it
// will return OBJECT_NOT_AVAILABLE.

jerror_t err = GetFromSource(t, factory);
if(err == NOERROR){
	// A return value of NOERROR means the source had the objects
	// even if there were zero of them.(If the source had no
	// information about the objects OBJECT_NOT_AVAILABLE would 
	// have been returned.)
	// The GetFromSource() call will eventually lead to a call to
	// the GetObjects() method of the concrete class derived
	// from JEventSource. That routine should copy the object
	// pointers into the factory using the factory's CopyTo()
	// method which also sets the evnt_called flag for the factory.
	// Note also that the "t" vector is then filled with a call
	// to the factory's CopyFrom() method in JEvent::GetObjects().
	// All we need to do now is just set the factory pointers in
	// the newly generated JObjects and return the factory pointer.

	factory->SetFactoryPointers();
	data_source = DATA_FROM_SOURCE;

	return factory;
}
}

// OK. It looks like we have to have the factory make this.
// Get pointers to data from the factory.
factory->Get(t);
factory->SetFactoryPointers();
data_source = DATA_FROM_FACTORY;

return factory;
457}

459//-------------
460// GetFromSource
461//-------------
462template<class T> 
463jerror_t JEventLoop::GetFromSource(vector<const T*> &t, JFactory_base *factory)
464{
/// This tries to get objects from the event source.
/// "factory" must be a valid pointer to a JFactory
/// object since that will take ownership of the objects
/// created by the source.
/// This should usually be called from JEventLoop::GetFromFactory
/// which is called from JEventLoop::Get. The latter will
/// create a dummy JFactory of the proper flavor and tag if
/// one does not already exist so if objects exist in the
/// file without a corresponding factory to create them, they
/// can still be used.
if(!factory)throw OBJECT_NOT_AVAILABLE;

return event.GetObjects(t, factory);
478}

480//-------------
481// CallStackStart
482//-------------
483inline void JEventLoop::CallStackStart(JEventLoop::call_stack_t &cs, const string &caller_name, const string &caller_tag, const string callee_name, const string callee_tag)
484{
/// This is used to fill initial info into a call_stack_t stucture
/// for recording the call stack. It should be matched with a call
/// to CallStackEnd. It is normally called from the Get() method
/// above, but may also be used by external actors to manipulate
/// the call stack (presumably for good and not evil).

struct itimerval tmr;
getitimer(ITIMER_PROFITIMER_PROF, &tmr);

cs.caller_name    = this->caller_name;
cs.caller_tag     = this->caller_tag;
this->caller_name = cs.callee_name = callee_name;
this->caller_tag  = cs.callee_tag  = callee_tag;
cs.start_time = tmr.it_value.tv_sec + tmr.it_value.tv_usec/1.0E6;
499}

501//-------------
502// CallStackEnd
503//-------------
504inline void JEventLoop::CallStackEnd(JEventLoop::call_stack_t &cs)
505{
/// Complete a call stack entry. This should be matched
/// with a previous call to CallStackStart which was
/// used to fill the cs structure.

struct itimerval tmr;
getitimer(ITIMER_PROFITIMER_PROF, &tmr);
cs.end_time = tmr.it_value.tv_sec + tmr.it_value.tv_usec/1.0E6;
caller_name = cs.caller_name;
caller_tag  = cs.caller_tag;
call_stack.push_back(cs);
516}

518//-------------
519// CheckEventBoundary
520//-------------
521inline bool JEventLoop::CheckEventBoundary(uint64_t event_numberA, uint64_t event_numberB)
522{
/// Check whether the two event numbers span one or more boundaries
/// in the calibration/conditions database for the current run number.
/// Return true if they do and false if they don't. The first parameter
/// "event_numberA" is also checked if it lands on a boundary in which
/// case true is also returned. If event_numberB lands on a boundary,
/// but event_numberA does not, then false is returned.
///
/// This method is not expected to be called by a user. It is, however called,
/// everytime a JFactory's Get() method is called.

// Make sure our copy of the boundaries is up to date
if(event.GetRunNumber()!=event_boundaries_run){
event_boundaries.clear(); // in case we can't get the JCalibration pointer
JCalibration *jcalib = GetJCalibration();
if(jcalib)jcalib->GetEventBoundaries(event_boundaries);
event_boundaries_run = event.GetRunNumber();
}

// Loop over boundaries
for(unsigned int i=0; i<event_boundaries.size(); i++){
uint64_t eb = event_boundaries[i];
if((eb - event_numberA)*(eb - event_numberB) < 0.0 || eb==event_numberA){ // think about it ....
	// events span a boundary or is on a boundary. Return true
	return true;
}
}

return false;
551}

553//-------------
554// FindByID
555//-------------
556template<class T> 
557const T* JEventLoop::FindByID(JObject::oid_t id)
558{
/// This is a templated method that can be used in place
/// of the non-templated FindByID(oid_t) method if one knows
/// the class of the object with the specified id.
/// This method is faster than calling the non-templated
/// FindByID and dynamic_cast-ing the JObject since
/// this will only search the objects of factories that
/// produce the desired data type.
/// This method will cast the JObject pointer to one
/// of the specified type. To use this method,
/// a type is specified in the call as follows:
///
/// const DMyType *t = loop->FindByID<DMyType>(id);

// Loop over factories looking for ones that provide
// specified data type.
for(unsigned int i=0; i<factories.size(); i++){
if(factories[i]->GetDataClassName() != T::static_className())continue;

// This factory provides data of type T. Search it for
// the object with the specified id.
const JObject *my_obj = factories[i]->GetByID(id);
if(my_obj)return dynamic_cast<const T*>(my_obj);
}

return NULL__null;
584}

586//-------------
587// GetCalib (map)
588//-------------
589template<class T>
590bool JEventLoop::GetCalib(string namepath, map<string,T> &vals)
591{
/// Get the JCalibration object from JApplication for the run number of
/// the current event and call its Get() method to get the constants.

// Note that we could do this by making "vals" a generic type T thus, combining
// this with the vector version below. However, doing this explicitly will make
// it easier for the user to understand how to call us.

vals.clear();

JCalibration *calib = GetJCalibration();
if(!calib){
_DBG_std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<603<<" "<<"Unable to get JCalibration object for run "<<event.GetRunNumber()<<std::endl;
return true;
}

return calib->Get(namepath, vals, event.GetEventNumber());
608}

610//-------------
611// GetCalib (vector)
612//-------------
613template<class T> bool JEventLoop::GetCalib(string namepath, vector<T> &vals)
614{
/// Get the JCalibration object from JApplication for the run number of
/// the current event and call its Get() method to get the constants.

vals.clear();

JCalibration *calib = GetJCalibration();
if(!calib){
_DBG_std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<622<<" "<<"Unable to get JCalibration object for run "<<event.GetRunNumber()<<std::endl;
return true;
}

return calib->Get(namepath, vals, event.GetEventNumber());
627}

629//-------------
630// GetCalib (single)
631//-------------
632template<class T> bool JEventLoop::GetCalib(string namepath, T &val)
633{
/// This is a convenience method for getting a single entry. It
/// simply calls the vector version and returns the first entry.
/// It returns true if the vector version returns true AND there
/// is at least one entry in the vector. No check is made for there
/// there being more than one entry in the vector.

vector<T> vals;
bool ret = GetCalib(namepath, vals);
if(vals.empty()) return true;
val = vals[0];

return ret;
646}

648//-------------
649// GetGeom (map)
650//-------------
651template<class T>
652bool JEventLoop::GetGeom(string namepath, map<string,T> &vals)
653{
/// Get the JGeometry object from JApplication for the run number of
/// the current event and call its Get() method to get the constants.

// Note that we could do this by making "vals" a generic type T thus, combining
// this with the vector version below. However, doing this explicitly will make
// it easier for the user to understand how to call us.

vals.clear();

JGeometry *geom = GetJGeometry();
if(!geom){
_DBG_std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<665<<" "<<"Unable to get JGeometry object for run "<<event.GetRunNumber()<<std::endl;
return true;
}

return geom->Get(namepath, vals);
670}

672//-------------
673// GetGeom (atomic)
674//-------------
675template<class T> bool JEventLoop::GetGeom(string namepath, T &val)
676{
/// Get the JCalibration object from JApplication for the run number of
/// the current event and call its Get() method to get the constants.

JGeometry *geom = GetJGeometry();
if(!geom){
_DBG_std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<682<<" "<<"Unable to get JGeometry object for run "<<event.GetRunNumber()<<std::endl;
return true;
}

return geom->Get(namepath, val);
687}

689//-------------
690// SetRef
691//-------------
692template<class T>
693void JEventLoop::SetRef(T *t)
694{
pair<const char*, void*> p(typeid(T).name(), (void*)t);
user_refs.push_back(p);
697}

699//-------------
700// GetResource
701//-------------
702template<class T> bool JEventLoop::GetResource(string namepath, T vals, int event_number)
703{
JResourceManager *resource_manager = GetJResourceManager();
if(!resource_manager){
string mess = string("Unable to get the JResourceManager object (namepath=\"")+namepath+"\")";
throw JException(mess);
}

return resource_manager->Get(namepath, vals, event_number);
711}

713//-------------
714// GetRef
715//-------------
716template<class T>
717T* JEventLoop::GetRef(void)
718{
/// Get a user-defined reference (a pointer)
for(unsigned int i=0; i<user_refs.size(); i++){
if(user_refs[i].first == typeid(T).name()) return (T*)user_refs[i].second;
}

return NULL__null;
725}

727//-------------
728// GetRefsT
729//-------------
730template<class T>
731vector<T*> JEventLoop::GetRefsT(void)
732{
vector<T*> refs;
for(unsigned int i=0; i<user_refs.size(); i++){
if(user_refs[i].first == typeid(T).name()){
	refs.push_back((T*)user_refs[i].second);
}
}

return refs;
741}

743//-------------
744// RemoveRef
745//-------------
746template<class T>
747void JEventLoop::RemoveRef(T *t)
748{
vector<pair<const char*, void*> >::iterator iter;
for(iter=user_refs.begin(); iter!= user_refs.end(); iter++){
if(iter->second == (void*)t){
	user_refs.erase(iter);
	return;
}
}
_DBG_std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<756<<" "<<" Attempt to remove user reference not in event loop!" << std::endl;
757}


760#endif //__CINT__  __CLING__

762} // Close JANA namespace



766#endif // _JEventLoop_


←

/usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../include/c++/4.8.5/bits/stl_iterator.h

1// Iterators -*- C++ -*-

3// Copyright (C) 2001-2013 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996-1998
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*/

51/** @file bits/stl_iterator.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{iterator}
*
*  This file implements reverse_iterator, back_insert_iterator,
*  front_insert_iterator, insert_iterator, __normal_iterator, and their
*  supporting functions and overloaded operators.
*/

60#ifndef _STL_ITERATOR_H1
61#define _STL_ITERATOR_H1 1

63#include <bits/cpp_type_traits.h>
64#include <ext/type_traits.h>
65#include <bits/move.h>

67namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
68{
69_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup iterators
 * @{
 */

// 24.4.1 Reverse iterators
/**
 *  Bidirectional and random access iterators have corresponding reverse
 *  %iterator adaptors that iterate through the data structure in the
 *  opposite direction.  They have the same signatures as the corresponding
 *  iterators.  The fundamental relation between a reverse %iterator and its
 *  corresponding %iterator @c i is established by the identity:
 *  @code
 *      &*(reverse_iterator(i)) == &*(i - 1)
 *  @endcode
 *
 *  <em>This mapping is dictated by the fact that while there is always a
 *  pointer past the end of an array, there might not be a valid pointer
 *  before the beginning of an array.</em> [24.4.1]/1,2
 *
 *  Reverse iterators can be tricky and surprising at first.  Their
 *  semantics make sense, however, and the trickiness is a side effect of
 *  the requirement that the iterators must be safe.
*/
template<typename _Iterator>
  class reverse_iterator
  : public iterator<typename iterator_traits<_Iterator>::iterator_category,
      typename iterator_traits<_Iterator>::value_type,
      typename iterator_traits<_Iterator>::difference_type,
      typename iterator_traits<_Iterator>::pointer,
                    typename iterator_traits<_Iterator>::reference>
  {
  protected:
    _Iterator current;

    typedef iterator_traits<_Iterator>		__traits_type;

  public:
    typedef _Iterator					iterator_type;
    typedef typename __traits_type::difference_type	difference_type;
    typedef typename __traits_type::pointer		pointer;
    typedef typename __traits_type::reference		reference;

    /**
     *  The default constructor value-initializes member @p current.
     *  If it is a pointer, that means it is zero-initialized.
    */
    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 235 No specification of default ctor for reverse_iterator
    reverse_iterator() : current() { }

    /**
     *  This %iterator will move in the opposite direction that @p x does.
    */
    explicit
    reverse_iterator(iterator_type __x) : current(__x) { }

    /**
     *  The copy constructor is normal.
    */
    reverse_iterator(const reverse_iterator& __x)
    : current(__x.current) { }

    /**
     *  A %reverse_iterator across other types can be copied if the
     *  underlying %iterator can be converted to the type of @c current.
    */
    template<typename _Iter>
      reverse_iterator(const reverse_iterator<_Iter>& __x)
: current(__x.base()) { }

    /**
     *  @return  @c current, the %iterator used for underlying work.
    */
    iterator_type
    base() const
    { return current; }

    /**
     *  @return  A reference to the value at @c --current
     *
     *  This requires that @c --current is dereferenceable.
     *
     *  @warning This implementation requires that for an iterator of the
     *           underlying iterator type, @c x, a reference obtained by
     *           @c *x remains valid after @c x has been modified or
     *           destroyed. This is a bug: http://gcc.gnu.org/PR51823
    */
    reference
    operator*() const
    {
_Iterator __tmp = current;
return *--__tmp;
    }

    /**
     *  @return  A pointer to the value at @c --current
     *
     *  This requires that @c --current is dereferenceable.
    */
    pointer
    operator->() const
    { return &(operator*()); }

    /**
     *  @return  @c *this
     *
     *  Decrements the underlying iterator.
    */
    reverse_iterator&
    operator++()
    {
--current;
return *this;
    }

    /**
     *  @return  The original value of @c *this
     *
     *  Decrements the underlying iterator.
    */
    reverse_iterator
    operator++(int)
    {
reverse_iterator __tmp = *this;
--current;
return __tmp;
    }

    /**
     *  @return  @c *this
     *
     *  Increments the underlying iterator.
    */
    reverse_iterator&
    operator--()
    {
++current;
return *this;
    }

    /**
     *  @return  A reverse_iterator with the previous value of @c *this
     *
     *  Increments the underlying iterator.
    */
    reverse_iterator
    operator--(int)
    {
reverse_iterator __tmp = *this;
++current;
return __tmp;
    }

    /**
     *  @return  A reverse_iterator that refers to @c current - @a __n
     *
     *  The underlying iterator must be a Random Access Iterator.
    */
    reverse_iterator
    operator+(difference_type __n) const
    { return reverse_iterator(current - __n); }

    /**
     *  @return  *this
     *
     *  Moves the underlying iterator backwards @a __n steps.
     *  The underlying iterator must be a Random Access Iterator.
    */
    reverse_iterator&
    operator+=(difference_type __n)
    {
current -= __n;
return *this;
    }

    /**
     *  @return  A reverse_iterator that refers to @c current - @a __n
     *
     *  The underlying iterator must be a Random Access Iterator.
    */
    reverse_iterator
    operator-(difference_type __n) const
    { return reverse_iterator(current + __n); }

    /**
     *  @return  *this
     *
     *  Moves the underlying iterator forwards @a __n steps.
     *  The underlying iterator must be a Random Access Iterator.
    */
    reverse_iterator&
    operator-=(difference_type __n)
    {
current += __n;
return *this;
    }

    /**
     *  @return  The value at @c current - @a __n - 1
     *
     *  The underlying iterator must be a Random Access Iterator.
    */
    reference
    operator[](difference_type __n) const
    { return *(*this + __n); }
  };

//@{
/**
 *  @param  __x  A %reverse_iterator.
 *  @param  __y  A %reverse_iterator.
 *  @return  A simple bool.
 *
 *  Reverse iterators forward many operations to their underlying base()
 *  iterators.  Others are implemented in terms of one another.
 *
*/
template<typename _Iterator>
  inline bool
  operator==(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return __x.base() == __y.base(); }

template<typename _Iterator>
  inline bool
  operator<(const reverse_iterator<_Iterator>& __x,
     const reverse_iterator<_Iterator>& __y)
  { return __y.base() < __x.base(); }

template<typename _Iterator>
  inline bool
  operator!=(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return !(__x == __y); }

template<typename _Iterator>
  inline bool
  operator>(const reverse_iterator<_Iterator>& __x,
     const reverse_iterator<_Iterator>& __y)
  { return __y < __x; }

template<typename _Iterator>
  inline bool
  operator<=(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return !(__y < __x); }

template<typename _Iterator>
  inline bool
  operator>=(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return !(__x < __y); }

template<typename _Iterator>
  inline typename reverse_iterator<_Iterator>::difference_type
  operator-(const reverse_iterator<_Iterator>& __x,
     const reverse_iterator<_Iterator>& __y)
  { return __y.base() - __x.base(); }

template<typename _Iterator>
  inline reverse_iterator<_Iterator>
  operator+(typename reverse_iterator<_Iterator>::difference_type __n,
     const reverse_iterator<_Iterator>& __x)
  { return reverse_iterator<_Iterator>(__x.base() - __n); }

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 280. Comparison of reverse_iterator to const reverse_iterator.
template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator==(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return __x.base() == __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator<(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
  { return __y.base() < __x.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator!=(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return !(__x == __y); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator>(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
  { return __y < __x; }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator<=(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return !(__y < __x); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator>=(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return !(__x < __y); }

template<typename _IteratorL, typename _IteratorR>
376#if __cplusplus201103L >= 201103L
  // DR 685.
  inline auto
  operator-(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
  -> decltype(__y.base() - __x.base())
382#else
  inline typename reverse_iterator<_IteratorL>::difference_type
  operator-(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
386#endif
  { return __y.base() - __x.base(); }
//@}

// 24.4.2.2.1 back_insert_iterator
/**
 *  @brief  Turns assignment into insertion.
 *
 *  These are output iterators, constructed from a container-of-T.
 *  Assigning a T to the iterator appends it to the container using
 *  push_back.
 *
 *  Tip:  Using the back_inserter function to create these iterators can
 *  save typing.
*/
template<typename _Container>
  class back_insert_iterator
  : public iterator<output_iterator_tag, void, void, void, void>
  {
  protected:
    _Container* container;

  public:
    /// A nested typedef for the type of whatever container you used.
    typedef _Container          container_type;

    /// The only way to create this %iterator is with a container.
    explicit
    back_insert_iterator(_Container& __x) : container(&__x) { }

    /**
     *  @param  __value  An instance of whatever type
     *                 container_type::const_reference is; presumably a
     *                 reference-to-const T for container<T>.
     *  @return  This %iterator, for chained operations.
     *
     *  This kind of %iterator doesn't really have a @a position in the
     *  container (you can think of the position as being permanently at
     *  the end, if you like).  Assigning a value to the %iterator will
     *  always append the value to the end of the container.
    */
427#if __cplusplus201103L < 201103L
    back_insert_iterator&
    operator=(typename _Container::const_reference __value)
    {
container->push_back(__value);
return *this;
    }
434#else
    back_insert_iterator&
    operator=(const typename _Container::value_type& __value)
    {
container->push_back(__value);
return *this;
    }

    back_insert_iterator&
    operator=(typename _Container::value_type&& __value)
    {
container->push_back(std::move(__value));
return *this;
    }
448#endif

    /// Simply returns *this.
    back_insert_iterator&
    operator*()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    back_insert_iterator&
    operator++()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    back_insert_iterator
    operator++(int)
    { return *this; }
  };

/**
 *  @param  __x  A container of arbitrary type.
 *  @return  An instance of back_insert_iterator working on @p __x.
 *
 *  This wrapper function helps in creating back_insert_iterator instances.
 *  Typing the name of the %iterator requires knowing the precise full
 *  type of the container, which can be tedious and impedes generic
 *  programming.  Using this function lets you take advantage of automatic
 *  template parameter deduction, making the compiler match the correct
 *  types for you.
*/
template<typename _Container>
  inline back_insert_iterator<_Container>
  back_inserter(_Container& __x)
  { return back_insert_iterator<_Container>(__x); }

/**
 *  @brief  Turns assignment into insertion.
 *
 *  These are output iterators, constructed from a container-of-T.
 *  Assigning a T to the iterator prepends it to the container using
 *  push_front.
 *
 *  Tip:  Using the front_inserter function to create these iterators can
 *  save typing.
*/
template<typename _Container>
  class front_insert_iterator
  : public iterator<output_iterator_tag, void, void, void, void>
  {
  protected:
    _Container* container;

  public:
    /// A nested typedef for the type of whatever container you used.
    typedef _Container          container_type;

    /// The only way to create this %iterator is with a container.
    explicit front_insert_iterator(_Container& __x) : container(&__x) { }

    /**
     *  @param  __value  An instance of whatever type
     *                 container_type::const_reference is; presumably a
     *                 reference-to-const T for container<T>.
     *  @return  This %iterator, for chained operations.
     *
     *  This kind of %iterator doesn't really have a @a position in the
     *  container (you can think of the position as being permanently at
     *  the front, if you like).  Assigning a value to the %iterator will
     *  always prepend the value to the front of the container.
    */
517#if __cplusplus201103L < 201103L
    front_insert_iterator&
    operator=(typename _Container::const_reference __value)
    {
container->push_front(__value);
return *this;
    }
524#else
    front_insert_iterator&
    operator=(const typename _Container::value_type& __value)
    {
container->push_front(__value);
return *this;
    }

    front_insert_iterator&
    operator=(typename _Container::value_type&& __value)
    {
container->push_front(std::move(__value));
return *this;
    }
538#endif

    /// Simply returns *this.
    front_insert_iterator&
    operator*()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    front_insert_iterator&
    operator++()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    front_insert_iterator
    operator++(int)
    { return *this; }
  };

/**
 *  @param  __x  A container of arbitrary type.
 *  @return  An instance of front_insert_iterator working on @p x.
 *
 *  This wrapper function helps in creating front_insert_iterator instances.
 *  Typing the name of the %iterator requires knowing the precise full
 *  type of the container, which can be tedious and impedes generic
 *  programming.  Using this function lets you take advantage of automatic
 *  template parameter deduction, making the compiler match the correct
 *  types for you.
*/
template<typename _Container>
  inline front_insert_iterator<_Container>
  front_inserter(_Container& __x)
  { return front_insert_iterator<_Container>(__x); }

/**
 *  @brief  Turns assignment into insertion.
 *
 *  These are output iterators, constructed from a container-of-T.
 *  Assigning a T to the iterator inserts it in the container at the
 *  %iterator's position, rather than overwriting the value at that
 *  position.
 *
 *  (Sequences will actually insert a @e copy of the value before the
 *  %iterator's position.)
 *
 *  Tip:  Using the inserter function to create these iterators can
 *  save typing.
*/
template<typename _Container>
  class insert_iterator
  : public iterator<output_iterator_tag, void, void, void, void>
  {
  protected:
    _Container* container;
    typename _Container::iterator iter;

  public:
    /// A nested typedef for the type of whatever container you used.
    typedef _Container          container_type;

    /**
     *  The only way to create this %iterator is with a container and an
     *  initial position (a normal %iterator into the container).
    */
    insert_iterator(_Container& __x, typename _Container::iterator __i)
    : container(&__x), iter(__i) {}

    /**
     *  @param  __value  An instance of whatever type
     *                 container_type::const_reference is; presumably a
     *                 reference-to-const T for container<T>.
     *  @return  This %iterator, for chained operations.
     *
     *  This kind of %iterator maintains its own position in the
     *  container.  Assigning a value to the %iterator will insert the
     *  value into the container at the place before the %iterator.
     *
     *  The position is maintained such that subsequent assignments will
     *  insert values immediately after one another.  For example,
     *  @code
     *     // vector v contains A and Z
     *
     *     insert_iterator i (v, ++v.begin());
     *     i = 1;
     *     i = 2;
     *     i = 3;
     *
     *     // vector v contains A, 1, 2, 3, and Z
     *  @endcode
    */
628#if __cplusplus201103L < 201103L
    insert_iterator&
    operator=(typename _Container::const_reference __value)
    {
iter = container->insert(iter, __value);
++iter;
return *this;
    }
636#else
    insert_iterator&
    operator=(const typename _Container::value_type& __value)
    {
iter = container->insert(iter, __value);
++iter;
return *this;
    }

    insert_iterator&
    operator=(typename _Container::value_type&& __value)
    {
iter = container->insert(iter, std::move(__value));
++iter;
return *this;
    }
652#endif

    /// Simply returns *this.
    insert_iterator&
    operator*()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    insert_iterator&
    operator++()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    insert_iterator&
    operator++(int)
    { return *this; }
  };

/**
 *  @param __x  A container of arbitrary type.
 *  @return  An instance of insert_iterator working on @p __x.
 *
 *  This wrapper function helps in creating insert_iterator instances.
 *  Typing the name of the %iterator requires knowing the precise full
 *  type of the container, which can be tedious and impedes generic
 *  programming.  Using this function lets you take advantage of automatic
 *  template parameter deduction, making the compiler match the correct
 *  types for you.
*/
template<typename _Container, typename _Iterator>
  inline insert_iterator<_Container>
  inserter(_Container& __x, _Iterator __i)
  {
    return insert_iterator<_Container>(__x,
			 typename _Container::iterator(__i));
  }

// @} group iterators

691_GLIBCXX_END_NAMESPACE_VERSION
692} // namespace

694namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
695{
696_GLIBCXX_BEGIN_NAMESPACE_VERSION

// This iterator adapter is @a normal in the sense that it does not
// change the semantics of any of the operators of its iterator
// parameter.  Its primary purpose is to convert an iterator that is
// not a class, e.g. a pointer, into an iterator that is a class.
// The _Container parameter exists solely so that different containers
// using this template can instantiate different types, even if the
// _Iterator parameter is the same.
using std::iterator_traits;
using std::iterator;
template<typename _Iterator, typename _Container>
  class __normal_iterator
  {
  protected:
    _Iterator _M_current;

    typedef iterator_traits<_Iterator>		__traits_type;

  public:
    typedef _Iterator					iterator_type;
    typedef typename __traits_type::iterator_category iterator_category;
    typedef typename __traits_type::value_type  	value_type;
    typedef typename __traits_type::difference_type 	difference_type;
    typedef typename __traits_type::reference 	reference;
    typedef typename __traits_type::pointer   	pointer;

    _GLIBCXX_CONSTEXPRconstexpr __normal_iterator() : _M_current(_Iterator()) { }

    explicit
    __normal_iterator(const _Iterator& __i) : _M_current(__i) { }

    // Allow iterator to const_iterator conversion
    template<typename _Iter>
      __normal_iterator(const __normal_iterator<_Iter,
	  typename __enable_if<
    	       (std::__are_same<_Iter, typename _Container::pointer>::__value),
      _Container>::__type>& __i)
      : _M_current(__i.base()) { }

    // Forward iterator requirements
    reference
    operator*() const
    { return *_M_current; }

    pointer
    operator->() const
    { return _M_current; }

    __normal_iterator&
    operator++()
    {
++_M_current;
return *this;
    }

    __normal_iterator
    operator++(int)
    { return __normal_iterator(_M_current++); }

    // Bidirectional iterator requirements
    __normal_iterator&
    operator--()
    {
--_M_current;
return *this;
    }

    __normal_iterator
    operator--(int)
    { return __normal_iterator(_M_current--); }

    // Random access iterator requirements
    reference
    operator[](const difference_type& __n) const
    { return _M_current[__n]; }

    __normal_iterator&
    operator+=(const difference_type& __n)
    { _M_current += __n; return *this; }

    __normal_iterator
    operator+(const difference_type& __n) const
    { return __normal_iterator(_M_current + __n); }

    __normal_iterator&
    operator-=(const difference_type& __n)
    { _M_current -= __n; return *this; }

    __normal_iterator
    operator-(const difference_type& __n) const
    { return __normal_iterator(_M_current - __n); }

    const _Iterator&
    base() const
    { return _M_current; }
  };

// Note: In what follows, the left- and right-hand-side iterators are
// allowed to vary in types (conceptually in cv-qualification) so that
// comparison between cv-qualified and non-cv-qualified iterators be
// valid.  However, the greedy and unfriendly operators in std::rel_ops
// will make overload resolution ambiguous (when in scope) if we don't
// provide overloads whose operands are of the same type.  Can someone
// remind me what generic programming is about? -- Gaby

// Forward iterator requirements
template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }
24
←
Assuming the condition is true→
25
←
Returning the value 1, which participates in a condition later→

// Random access iterator requirements
template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// According to the resolution of DR179 not only the various comparison
// operators but also operator- must accept mixed iterator/const_iterator
// parameters.
template<typename _IteratorL, typename _IteratorR, typename _Container>
881#if __cplusplus201103L >= 201103L
  // DR 685.
  inline auto
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  -> decltype(__lhs.base() - __rhs.base())
887#else
  inline typename __normal_iterator<_IteratorL, _Container>::difference_type
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
891#endif
  { return __lhs.base() - __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline typename __normal_iterator<_Iterator, _Container>::difference_type
  operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() - __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline __normal_iterator<_Iterator, _Container>
  operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
     __n, const __normal_iterator<_Iterator, _Container>& __i)
  { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }

906_GLIBCXX_END_NAMESPACE_VERSION
907} // namespace

909#if __cplusplus201103L >= 201103L

911namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
912{
913_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup iterators
 * @{
 */

// 24.4.3  Move iterators
/**
 *  Class template move_iterator is an iterator adapter with the same
 *  behavior as the underlying iterator except that its dereference
 *  operator implicitly converts the value returned by the underlying
 *  iterator's dereference operator to an rvalue reference.  Some
 *  generic algorithms can be called with move iterators to replace
 *  copying with moving.
 */
template<typename _Iterator>
  class move_iterator
  {
  protected:
    _Iterator _M_current;

    typedef iterator_traits<_Iterator>		__traits_type;

  public:
    typedef _Iterator					iterator_type;
    typedef typename __traits_type::iterator_category iterator_category;
    typedef typename __traits_type::value_type  	value_type;
    typedef typename __traits_type::difference_type	difference_type;
    // NB: DR 680.
    typedef _Iterator					pointer;
    typedef value_type&&				reference;

    move_iterator()
    : _M_current() { }

    explicit
    move_iterator(iterator_type __i)
    : _M_current(__i) { }

    template<typename _Iter>
move_iterator(const move_iterator<_Iter>& __i)
: _M_current(__i.base()) { }

    iterator_type
    base() const
    { return _M_current; }

    reference
    operator*() const
    { return std::move(*_M_current); }

    pointer
    operator->() const
    { return _M_current; }

    move_iterator&
    operator++()
    {
++_M_current;
return *this;
    }

    move_iterator
    operator++(int)
    {
move_iterator __tmp = *this;
++_M_current;
return __tmp;
    }

    move_iterator&
    operator--()
    {
--_M_current;
return *this;
    }

    move_iterator
    operator--(int)
    {
move_iterator __tmp = *this;
--_M_current;
return __tmp;
    }

    move_iterator
    operator+(difference_type __n) const
    { return move_iterator(_M_current + __n); }

    move_iterator&
    operator+=(difference_type __n)
    {
_M_current += __n;
return *this;
    }

    move_iterator
    operator-(difference_type __n) const
    { return move_iterator(_M_current - __n); }
  
    move_iterator&
    operator-=(difference_type __n)
    { 
_M_current -= __n;
return *this;
    }

    reference
    operator[](difference_type __n) const
    { return std::move(_M_current[__n]); }
  };

// Note: See __normal_iterator operators note from Gaby to understand
// why there are always 2 versions for most of the move_iterator
// operators.
template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator==(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
  { return __x.base() == __y.base(); }

template<typename _Iterator>
  inline bool
  operator==(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return __x.base() == __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator!=(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
  { return !(__x == __y); }

template<typename _Iterator>
  inline bool
  operator!=(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return !(__x == __y); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator<(const move_iterator<_IteratorL>& __x,
     const move_iterator<_IteratorR>& __y)
  { return __x.base() < __y.base(); }

template<typename _Iterator>
  inline bool
  operator<(const move_iterator<_Iterator>& __x,
     const move_iterator<_Iterator>& __y)
  { return __x.base() < __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator<=(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
  { return !(__y < __x); }

template<typename _Iterator>
  inline bool
  operator<=(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return !(__y < __x); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator>(const move_iterator<_IteratorL>& __x,
     const move_iterator<_IteratorR>& __y)
  { return __y < __x; }

template<typename _Iterator>
  inline bool
  operator>(const move_iterator<_Iterator>& __x,
     const move_iterator<_Iterator>& __y)
  { return __y < __x; }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator>=(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
  { return !(__x < __y); }

template<typename _Iterator>
  inline bool
  operator>=(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return !(__x < __y); }

// DR 685.
template<typename _IteratorL, typename _IteratorR>
  inline auto
  operator-(const move_iterator<_IteratorL>& __x,
     const move_iterator<_IteratorR>& __y)
  -> decltype(__x.base() - __y.base())
  { return __x.base() - __y.base(); }

template<typename _Iterator>
  inline auto
  operator-(const move_iterator<_Iterator>& __x,
     const move_iterator<_Iterator>& __y)
  -> decltype(__x.base() - __y.base())
  { return __x.base() - __y.base(); }

template<typename _Iterator>
  inline move_iterator<_Iterator>
  operator+(typename move_iterator<_Iterator>::difference_type __n,
     const move_iterator<_Iterator>& __x)
  { return __x + __n; }

template<typename _Iterator>
  inline move_iterator<_Iterator>
  make_move_iterator(_Iterator __i)
  { return move_iterator<_Iterator>(__i); }

template<typename _Iterator, typename _ReturnType
  = typename conditional<__move_if_noexcept_cond
    <typename iterator_traits<_Iterator>::value_type>::value,
              _Iterator, move_iterator<_Iterator>>::type>
  inline _ReturnType
  __make_move_if_noexcept_iterator(_Iterator __i)
  { return _ReturnType(__i); }

// @} group iterators

1137_GLIBCXX_END_NAMESPACE_VERSION
1138} // namespace

1140#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter)std::make_move_iterator(_Iter) std::make_move_iterator(_Iter)
1141#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter)std::__make_move_if_noexcept_iterator(_Iter) \
std::__make_move_if_noexcept_iterator(_Iter)
1143#else
1144#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter)std::make_move_iterator(_Iter) (_Iter)
1145#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter)std::__make_move_if_noexcept_iterator(_Iter) (_Iter)
1146#endif // C++11

1148#endif