/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 MyProcessor.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/MyProcessor.cc

programs/Analysis/hdview2/MyProcessor.cc

→

1// Author: David Lawrence  June 25, 2004
2//
3//
4// MyProcessor.cc
5//

7#include <iostream>
8#include <vector>
9#include <string>
10using namespace std;

12#include <TLorentzVector.h>
13#include <TLorentzRotation.h>
14#include <TEllipse.h>
15#include <TArc.h>
16#include <TBox.h>
17#include <TLine.h>
18#include <TText.h>
19#include <TVector3.h>
20#include <TColor.h>
21#include <TLegend.h>

23#include <particleType.h>
24#include "hdview2.h"
25#include "hdv_mainframe.h"
26#include "hdv_debugerframe.h"
27#include "MyProcessor.h"
28#include "TRACKING/DTrackHit.h"
29#include "TRACKING/DQuickFit.h"
30#include "TRACKING/DMagneticFieldStepper.h"
31#include "TRACKING/DTrackCandidate_factory.h"
32#include "TRACKING/DMCTrackHit.h"
33#include "TRACKING/DMCThrown.h"
34#include "TRACKING/DTrackWireBased.h"
35#include "TRACKING/DTrackTimeBased.h"
36#include "PID/DChargedTrack.h"
37#include "TRACKING/DReferenceTrajectory.h"
38#include "JANA/JGeometry.h"
39#include "TRACKING/DMCTrajectoryPoint.h"
40#include "FCAL/DFCALHit.h"
41#include "CCAL/DCCALHit.h"
42#include "CCAL/DCCALShower.h"
43#include "TOF/DTOFGeometry.h"
44#include "TOF/DTOFHit.h"
45#include "TOF/DTOFTDCDigiHit.h" 
46#include "TOF/DTOFDigiHit.h"
47#include "TOF/DTOFPaddleHit.h"
48#include "TOF/DTOFPoint.h"
49#include "FDC/DFDCGeometry.h"
50#include "CDC/DCDCTrackHit.h"
51#include "FDC/DFDCPseudo.h"
52#include "FDC/DFDCIntersection.h"
53#include "HDGEOMETRY/DGeometry.h"
54#include "FCAL/DFCALGeometry.h"
55#include "FCAL/DFCALHit.h"
56#include "PID/DNeutralParticle.h"
57#include "PID/DNeutralShower.h"
58#include "BCAL/DBCALHit.h"
59#include "BCAL/DBCALIncidentParticle.h"
60#include "TOF/DTOFPoint.h"
61#include "START_COUNTER/DSCHit.h"
62#include "DVector2.h"
63#include "TRIGGER/DL1Trigger.h"

65extern hdv_mainframe *hdvmf;

67// These are declared in hdv_mainframe.cc, but as static so we need to do it here as well (yechh!)
68static float FCAL_Zmin = 622.8;
69static float FCAL_Rmin = 6.0;
70static float FCAL_Rmax = 212.0/2.0;
71static float BCAL_Rmin = 65.0;
72static float BCAL_Zlen = 390.0;
73static float BCAL_Zmin = 212.0 - BCAL_Zlen/2.0;


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


79bool DMCTrajectoryPoint_track_cmp(const DMCTrajectoryPoint *a,const DMCTrajectoryPoint *b){
// sort by track number and then by particle type, then by z-coordinate
// (yes, I saw the same track number have different particle types!)
if(a->track != b->track)return a->track < b->track;
if(a->part  != b->part )return a->part < b->part;
return a->z < b->z;
85}


88MyProcessor *gMYPROC=NULL__null;

90//------------------------------------------------------------------
91// MyProcessor 
92//------------------------------------------------------------------
93MyProcessor::MyProcessor()
94{
Bfield = NULL__null;
loop = NULL__null;

// Tell factory to keep around a few density histos
//gPARMS->SetParameter("TRKFIND:MAX_DEBUG_BUFFERS",	16);

RMAX_INTERIOR = 65.0;
RMAX_EXTERIOR = 88.0;
gPARMS->SetDefaultParameter("RT:RMAX_INTERIOR",	RMAX_INTERIOR, "cm track drawing Rmax inside solenoid region");
gPARMS->SetDefaultParameter("RT:RMAX_EXTERIOR",	RMAX_EXTERIOR, "cm track drawing Rmax outside solenoid region");

BCALVERBOSE = 0;
gPARMS->SetDefaultParameter("BCALVERBOSE", BCALVERBOSE, "Verbosity level for BCAL objects and display");

gMYPROC = this;
110}

112//------------------------------------------------------------------
113// ~MyProcessor 
114//------------------------------------------------------------------
115MyProcessor::~MyProcessor()
116{

118}

120//------------------------------------------------------------------
121// init 
122//------------------------------------------------------------------
123jerror_t MyProcessor::init(void)
124{
// Make sure detectors have been drawn
//if(!drew_detectors)DrawDetectors();



vector<JEventLoop*> loops = app->GetJEventLoops();
if(loops.size()>0){

vector<string> facnames;
loops[0]->GetFactoryNames(facnames);

hdvmf = new hdv_mainframe(gClient(TGClient::Instance())->GetRoot(), 1400, 700);
hdvmf->SetCandidateFactories(facnames);
hdvmf->SetWireBasedTrackFactories(facnames);
hdvmf->SetTimeBasedTrackFactories(facnames);
hdvmf->SetReconstructedFactories(facnames);
hdvmf->SetChargedTrackFactories(facnames);
fulllistmf = hdvmf->GetFullListFrame();
debugermf = hdvmf->GetDebugerFrame();
BCALHitCanvas = hdvmf->GetBcalDispFrame();

if (BCALHitCanvas){
  BCALHitMatrixU = new TH2F("BCALHitMatrixU","BCAL Hits Upstream",  48*4+2, -1.5, 192.5, 10, 0., 10.);
  BCALHitMatrixD = new TH2F("BCALHitMatrixD","BCAL Hits Downstream",48*4+2, -1.5, 192.5, 10, 0., 10.);
  BCALParticles = new TH2F("BCALParticles","BCAL Hits Downstream",(48*4+2)*4, -1.87, 361.87, 1, 0., 1.);
  BCALHitMatrixU->SetStats(0);
  BCALHitMatrixD->SetStats(0);
  BCALParticles->SetStats(0);
  BCALHitMatrixU->GetXaxis()->SetTitle("Sector number");
  BCALHitMatrixD->GetXaxis()->SetTitle("Sector number");
  BCALParticles->GetXaxis()->SetTitle("Phi angle [deg]");
}
}

return NOERROR;
160}

162//------------------------------------------------------------------
163// brun 
164//------------------------------------------------------------------
165jerror_t MyProcessor::brun(JEventLoop *eventloop, int32_t runnumber)
166{

// Read in Magnetic field map
DApplication* dapp = dynamic_cast<DApplication*>(eventloop->GetJApplication());
Bfield = dapp->GetBfield(runnumber);
const DGeometry *dgeom  = dapp->GetDGeometry(runnumber);
dgeom->GetFDCWires(fdcwires);

RootGeom = dapp->GetRootGeom(runnumber);
geom = dapp->GetDGeometry(runnumber);

MATERIAL_MAP_MODEL="DGeometry";
gPARMS->SetDefaultParameter("TRKFIT:MATERIAL_MAP_MODEL",			MATERIAL_MAP_MODEL);

eventloop->GetCalib("PID/photon_track_matching", photon_track_matching);
DELTA_R_FCAL = photon_track_matching["DELTA_R_FCAL"];

return NOERROR;
184}

186//------------------------------------------------------------------
187// evnt 
188//------------------------------------------------------------------
189jerror_t MyProcessor::evnt(JEventLoop *eventLoop, uint64_t eventnumber)
190{
if(!eventLoop)return NOERROR;
loop = eventLoop;
last_jevent.FreeEvent();
last_jevent = loop->GetJEvent();

// get the trigger bits
char trigstring[10];
const DL1Trigger *trig = NULL__null;
try {
loop->GetSingle(trig);
} catch (...) {}
if (trig) {
sprintf(trigstring,"0x%04x",trig->trig_mask); 
} else {
sprintf(trigstring,"no bits");
}
hdvmf->SetTrig(trigstring);

string source = "<no source>";
if(last_jevent.GetJEventSource())source = last_jevent.GetJEventSource()->GetSourceName();

cout<<"----------- New Event "<<eventnumber<<"  (run " << last_jevent.GetRunNumber()<<") -------------"<<endl;
hdvmf->SetEvent(eventnumber);
hdvmf->SetRun(last_jevent.GetRunNumber());
hdvmf->SetSource(source.c_str());
hdvmf->DoMyRedraw();	

japp->SetSequentialEventComplete();

return NOERROR;
221}

223//------------------------------------------------------------------
224// FillGraphics 
225//------------------------------------------------------------------
226void MyProcessor::FillGraphics(void)
227{
/// Create "graphics" objects for this event given the current GUI settings.
///
/// This method will create DGraphicSet objects that represent tracks, hits,
/// and showers for the event. It creates objects for both hits and
/// reconstructed entities. The "graphics" objects created here are
/// really just collections of 3D space points with flags indicating
/// whether they should be drawn as markers or lines and with what
/// color and size. The actual graphics objects are created for the
/// various views of the detector in hdv_mainframe.

graphics.clear();
graphics_xyA.clear(); // The objects placed in these will be deleted by hdv_mainframe
graphics_xyB.clear(); // The objects placed in these will be deleted by hdv_mainframe
graphics_xz.clear();  // The objects placed in these will be deleted by hdv_mainframe
graphics_yz.clear();  // The objects placed in these will be deleted by hdv_mainframe
graphics_tof_hits.clear();  // The objects placed in these will be deleted by hdv_mainframe

if(!loop)return;

vector<const DSCHit *>schits;
loop->Get(schits);
vector<const DTrackCandidate*> trCand;
loop->Get(trCand);
vector<const DTrackTimeBased*> trTB;
loop->Get(trTB);
vector<const DTrackWireBased*> trWB;
loop->Get(trWB);
hdv_debugerframe *p = hdvmf->GetDebugerFrame();
p->SetNTrCand(trCand.size());
p->SetNTrWireBased(trWB.size());
p->SetNTrTimeBased(trTB.size());

if (BCALHitCanvas) {
 vector<const DBCALHit*> locBcalHits;
 loop->Get(locBcalHits);
 BCALHitMatrixU->Reset();
 BCALHitMatrixD->Reset();
 for (unsigned int k=0;k<locBcalHits.size();k++){
   
   const DBCALHit* hit = locBcalHits[k];
   float idxY = (float)hit->layer-1;
   float idxX = (float) (hit->sector-1 + (hit->module-1)*4);
   if (hit->end == DBCALGeometry::kUpstream){
     if (hit->layer==1){
BCALHitMatrixU->Fill(idxX,idxY,hit->E);
     } else if (hit->layer==2){
BCALHitMatrixU->Fill(idxX,idxY,hit->E);	      
BCALHitMatrixU->Fill(idxX,idxY+1.,hit->E);	      
     } else if (hit->layer==3){
BCALHitMatrixU->Fill(idxX,idxY+1,hit->E);	      
BCALHitMatrixU->Fill(idxX,idxY+2.,hit->E);	      
BCALHitMatrixU->Fill(idxX,idxY+3.,hit->E);	      
     } else if (hit->layer==4){
BCALHitMatrixU->Fill(idxX,idxY+3,hit->E);	      
BCALHitMatrixU->Fill(idxX,idxY+4.,hit->E);	      
BCALHitMatrixU->Fill(idxX,idxY+5.,hit->E);	      
BCALHitMatrixU->Fill(idxX,idxY+6.,hit->E);	      
     }
   } else {
     if (hit->layer==1){
BCALHitMatrixD->Fill(idxX,idxY,hit->E);
     } else if (hit->layer==2){
BCALHitMatrixD->Fill(idxX,idxY,hit->E);	      
BCALHitMatrixD->Fill(idxX,idxY+1.,hit->E);	      
     } else if (hit->layer==3){
BCALHitMatrixD->Fill(idxX,idxY+1,hit->E);	      
BCALHitMatrixD->Fill(idxX,idxY+2.,hit->E);	      
BCALHitMatrixD->Fill(idxX,idxY+3.,hit->E);	      
     } else if (hit->layer==4){
BCALHitMatrixD->Fill(idxX,idxY+3,hit->E);	      
BCALHitMatrixD->Fill(idxX,idxY+4.,hit->E);	      
BCALHitMatrixD->Fill(idxX,idxY+5.,hit->E);	      
BCALHitMatrixD->Fill(idxX,idxY+6.,hit->E);	      
     }
   }
 }

 // Fill BCAL points into layer histograms
 vector<const DBCALPoint*> locBcalPoint;
 loop->Get(locBcalPoint);
 for (int layer=0; layer<4; layer++) {
  BCALPointZphiLayer[layer]->Reset();
  BCALPointPhiTLayer[layer]->Reset();
 }

 vector<double> BCALpoints_z;
        vector<double> BCALpoints_phi;
        vector<double>::const_iterator points_min_phi;
        vector<double>::const_iterator points_max_phi;
        vector<double>::const_iterator points_min_z;
        vector<double>::const_iterator points_max_z;	

 for(unsigned int k=0;k<locBcalPoint.size();k++){
  BCALpoints_z.push_back(locBcalPoint[k]->z());
  BCALpoints_phi.push_back(locBcalPoint[k]->phi()*TMath::RadToDeg());
 }

 if(BCALpoints_phi.size() > 0){
 	  points_min_phi = min_element(BCALpoints_phi.begin(),BCALpoints_phi.end());
 	  points_max_phi = max_element(BCALpoints_phi.begin(),BCALpoints_phi.end());
 }

 if(BCALpoints_z.size() > 0){
  points_min_z = min_element(BCALpoints_z.begin(),BCALpoints_z.end());
  points_max_z = max_element(BCALpoints_z.begin(),BCALpoints_z.end());
 }

 BCALpoints_z.clear();
 BCALpoints_phi.clear();

 for (unsigned int k=0;k<locBcalPoint.size();k++){
  const DBCALPoint* point = locBcalPoint[k];
  float pointphi = point->phi()*TMath::RadToDeg();
  if (pointphi>360) pointphi-=360;
  if (pointphi<0) pointphi+=360;
  if (BCALVERBOSE>0) printf(" %3i (m,l,s) = (%2i,%i,%i)  (z,phi) = (%6.1f,%4.0f) t=%7.2f  E=%6.1f MeV\n",
						   k, point->module(), point->layer(), point->sector(),point->z(),
						   pointphi,point->t(),point->E()*1000);
  float weight = log(point->E()*1000);
	  BCALPointZphiLayer[point->layer()-1]->Fill(pointphi,point->z(),weight);
	  BCALPointZphiLayer[point->layer()-1]->GetXaxis()->SetRangeUser((*points_min_phi-2),(*points_max_phi+2));
        	          BCALPointZphiLayer[point->layer()-1]->GetYaxis()->SetRangeUser((*points_min_z-5),(*points_max_z+5));
  float time = point->t();
  if (point->t()>100) time=99;    // put overflow in last bin
  if (point->t()<-100) time=-99;
  BCALPointPhiTLayer[point->layer()-1]->Fill(pointphi,time,weight);
 }

 // Fill BCAL Clusters into histograms
 vector<const DBCALCluster*> locBcalCluster;
 loop->Get(locBcalCluster);

 unsigned int oldsize = BCALClusterZphiHistos.size();
 for (unsigned int k=0;k<oldsize;k++){
  delete BCALClusterZphiHistos[k];
 }
 BCALClusterZphiHistos.clear();

 delete ClusterLegend;
 ClusterLegend = new TLegend(0.91,0.01,0.99,0.99);
 
 for(unsigned int k = 0 ; k < locBcalCluster.size() ; k++){
 	  const DBCALCluster* cluster_range = locBcalCluster[k];

        	  vector<const DBCALPoint*> clusterpoints_range;
        	  cluster_range->Get(clusterpoints_range);

 	  for(unsigned int l=0;l<clusterpoints_range.size();l++){
  	  BCALpoints_z.push_back(clusterpoints_range[l]->z());
  	  BCALpoints_phi.push_back(clusterpoints_range[l]->phi()*TMath::RadToDeg());
	   }

 	  if(BCALpoints_phi.size() > 0){
  	  points_min_phi = min_element(BCALpoints_phi.begin(),BCALpoints_phi.end());
                	  points_max_phi = max_element(BCALpoints_phi.begin(),BCALpoints_phi.end()); 
 	  }

 	  if(BCALpoints_z.size() > 0){
  	  points_min_z = min_element(BCALpoints_z.begin(),BCALpoints_z.end());
                	  points_max_z = max_element(BCALpoints_z.begin(),BCALpoints_z.end());
 	  }

 }

 BCALpoints_z.clear();
 BCALpoints_phi.clear();

 for (unsigned int k=0;k<locBcalCluster.size();k++){
  char name[255];
  sprintf(name,"ClusterZphi%i",k);
  BCALClusterZphiHistos.push_back(new TH2F(name,"BCAL Clusters;Phi angle [deg];Z position (cm)",48*4,0,360,48,-80,400));
  int color=k+1;
  if (k>3) color=k+2; // remove yellow
  if (k>7) color=k+3; // remove white
  FormatHistogram(BCALClusterZphiHistos[k],color);
  BCALClusterZphiHistos[k]->SetLineWidth(2);
  sprintf(name,"Cluster %i",k+1);
  ClusterLegend->AddEntry(BCALClusterZphiHistos[k], name);

  const DBCALCluster* cluster = locBcalCluster[k];
                if (BCALVERBOSE>0) printf("cluster %2i, (phi,theta,rho) = (%6.2f,%6.2f,%7.2f) t=%8.3f  E=%8.2f MeV\n", k+1,cluster->phi(), cluster->theta(), cluster->rho(), cluster->t(), cluster->E()*1000);
        	  vector<const DBCALPoint*> clusterpoints;
        	  cluster->Get(clusterpoints);	  

  for (unsigned int l=0;l<clusterpoints.size();l++){
	  const DBCALPoint* clusterpoint = clusterpoints[l];
	  float weight = log(clusterpoint->E()*1000);
	  float pointphi = clusterpoint->phi()*TMath::RadToDeg();
	  if (pointphi>360) pointphi-=360;
	  if (pointphi<0) pointphi+=360;
	  if (BCALVERBOSE>1) printf("     (m,l,s) = (%2i,%i,%i)  (z,phi) = (%6.1f,%4.0f) t=%7.2f  E=%6.1f MeV\n",
								clusterpoint->module(), clusterpoint->layer(), clusterpoint->sector(),clusterpoint->z(),
								pointphi,clusterpoint->t(),clusterpoint->E()*1000);
	  BCALClusterZphiHistos[k]->Fill(pointphi,clusterpoint->z(),weight);
	  BCALClusterZphiHistos[k]->GetXaxis()->SetRangeUser((*points_min_phi - 2),(*points_max_phi + 2));
	  BCALClusterZphiHistos[k]->GetYaxis()->SetRangeUser((*points_min_z-10),(*points_max_z+10));
  }
 }

 vector<const DBCALIncidentParticle*> locBcalParticles;
 loop->Get(locBcalParticles);
 BCALParticles->Reset();
 BCALPLables.clear();
 for (unsigned int k=0;k<locBcalParticles.size();k++){	    
   const DBCALIncidentParticle* part = locBcalParticles[k];
   
   float p = TMath::Sqrt(part->px*part->px +  part->py*part->py +  part->pz*part->pz);
   float phi=999;
   if (part->x!=0){
     phi = TMath::ATan(TMath::Abs(part->y/part->x));
     //cout<<phi<<"   "<<part->y<<" / "<< part->x<<endl;
     if (part->y>0){
 	if (part->x<0.){
 	  phi = 3.1415926 - phi;
 	}
     } else {
 	if (part->x<0){
 	  phi += 3.1415926;
 	} else {
 	  phi = 3.1415926*2. - phi;
 	}
     }
     
     phi = phi*180./3.1415926;
   }
   //cout<<phi<<"  "<<p<<endl;
   BCALParticles->Fill(phi,0.5,p);
   char l[20];
   sprintf(l,"%d",part->ptype);
   TText *t = new TText(phi,1.01,l);
   t->SetTextSize(0.08);
   t->SetTextFont(72);
   t->SetTextAlign(21);
   BCALPLables.push_back(t);
 }

 // Get Maximum bin from cluster histograms
 float clustermax=0;
 if (BCALClusterZphiHistos.size()>0) {
  float max = BCALClusterZphiHistos[0]->GetMaximum();
  if (max>clustermax) clustermax=max;
 }

 BCALHitCanvas->Clear();
 BCALHitCanvas->Divide(1,3,0.001,0.001);
 float leftmargin = 0.07;
 BCALHitCanvas->cd(1);
 gPad(TVirtualPad::Pad())->SetGridx();
 gPad(TVirtualPad::Pad())->SetGridy();
 gPad(TVirtualPad::Pad())->SetLeftMargin(leftmargin);
 // if (BCALHitMatrixU->GetMaximum() < 1) {
 // 	  BCALHitMatrixU->Scale(1000);  // Scale histogram to MeV
 // 	  BCALHitMatrixU->GetZaxis()->SetTitle("Energy  (MeV)");
 // } else {
 // 	  BCALHitMatrixU->GetZaxis()->SetTitle("Energy  (GeV)");
 // }
 // BCALHitMatrixU->Draw("colz");

 bool firstup=1;

 for (int layer=0; layer<4; layer++) {
  if (BCALPointPhiTLayer[layer]->GetEntries()>0) {
	  BCALPointPhiTLayer[layer]->SetMaximum(clustermax);
	  if (firstup==1) {
		  BCALPointPhiTLayer[layer]->Draw("box");
		  firstup=0;
	  } else {
		  BCALPointPhiTLayer[layer]->Draw("box,same");
	  }
  }
 }
 LayerLegend->Draw();

 BCALHitCanvas->cd(2);
 gPad(TVirtualPad::Pad())->SetGridx();
 gPad(TVirtualPad::Pad())->SetGridy();
 gPad(TVirtualPad::Pad())->SetLeftMargin(leftmargin);
 // if (BCALHitMatrixD->GetMaximum() < 1) {
 //   BCALHitMatrixD->Scale(1000);  // Scale histogram to MeV
 //   BCALHitMatrixD->GetZaxis()->SetTitle("Energy  (MeV)");
 // } else {
 //   BCALHitMatrixU->GetZaxis()->SetTitle("Energy  (GeV)");
 // }
 // BCALHitMatrixD->Draw("colz");
 for (int layer=0; layer<4; layer++) {
  if (BCALPointZphiLayer[layer]->GetEntries()>0) {
	  BCALPointZphiLayer[layer]->SetMaximum(clustermax);
	  if (firstup==1) {
		  BCALPointZphiLayer[layer]->Draw("box");
		  firstup=0;
	  } else {
		  BCALPointZphiLayer[layer]->Draw("box,same");
	  }
  }
 }
 LayerLegend->Draw();

 BCALHitCanvas->cd(3);
 gPad(TVirtualPad::Pad())->SetGridx();
 gPad(TVirtualPad::Pad())->SetGridy();
 gPad(TVirtualPad::Pad())->SetLeftMargin(leftmargin);
 if (BCALClusterZphiHistos.size()>0) {
  BCALClusterZphiHistos[0]->SetMaximum(clustermax);
  BCALClusterZphiHistos[0]->Draw("box");
  for (unsigned int k=1; k<BCALClusterZphiHistos.size(); k++) {
	  BCALClusterZphiHistos[k]->SetMaximum(clustermax);
	  BCALClusterZphiHistos[k]->Draw("box,same");
  }
 }
 ClusterLegend->Draw();
 // BCALParticles->Draw("colz");
 // for (unsigned int n=0;n<BCALPLables.size();n++){
 //   BCALPLables[n]->Draw("same");
 // }
 BCALHitCanvas->Update();
}


// BCAL hits
if(hdvmf->GetCheckButton("bcal")){
 vector<const DBCALHit*> bcalhits;
 loop->Get(bcalhits);
 
 for(unsigned int i=0; i<bcalhits.size(); i++){
   const DBCALHit *hit = bcalhits[i];
   TPolyLine *poly = hdvmf->GetBCALPolyLine(hit->module, hit->layer, hit->sector);

   if(!poly)continue;
  
   // The aim is to have a log scale in energy
   double E = 1000.0*hit->E;      // Energy in MeV
   double logE = log10(E);      
   // 3 = 1 GeV, 0 = 1 MeV, use range 0 through 4
   // 0-1 White-Yellow
   // 1-2 Yellow-Red
   // 2-3 Red-Cyan
   // 3-4 Cyan-Blue

   float r,g,b;
   if (E<1){
     r = 1.;
     g = 1.;
     b = 1.;
   } else {
     if (logE<1){
r = 1.;
g = 1.;
b = 1.-logE;
     } else {
if (logE<2){
  r = 1.;
  g = 1.-(logE-1);
  b = 0.;
} else {
  if (logE<3){
    r = 1.;
    g = 0.;
    b = 1.-(logE-2);
  } else {
    if (logE<4){
      r = 1.-(logE-3);
      g = 0.;
      b = 1.;
    } else {
      r = 0;
      g = 1.;
      b = 0.;
      //printf("High BCAL cell reconstructed energy: E=%.1f MeV\n",E);
    }
  }
}
     }
   }
   if (r<0||g<0||b<0||r>1||g>1||b>1) printf("color error (r,g,b)=(%f,%f,%f)\n",r,g,b);

   poly->SetFillColor(TColor::GetColor(r,g,b));
   poly->SetLineColor(TColor::GetColor(r,g,b));
   poly->SetLineWidth(1);
   poly->SetFillStyle(1001);
 }
}	

// FCAL hits
if(hdvmf->GetCheckButton("fcal")){
 vector<const DFCALHit*> fcalhits;
 loop->Get(fcalhits);
 
 for(unsigned int i=0; i<fcalhits.size(); i++){
   const DFCALHit *hit = fcalhits[i];
   TPolyLine *poly = hdvmf->GetFCALPolyLine(hit->row, hit->column);
   if(!poly)continue;
   
620#if 0			
   double a = hit->E/0.005;
   double f = sqrt(a>1.0 ? 1.0:a<0.0 ? 0.0:a);
   double grey = 0.8;
   double s = 1.0 - f;
   
   float r = s*grey;
   float g = s*grey;
   float b = f*(1.0-grey) + grey;
629#endif

   // The aim is to have a log scale in energy (see BCAL)
   double E = 1000*hit->E;      // Change Energy to MeV
   if(E<0.0) continue;
   double logE = log10(E);      

   float r,g,b;
   if (logE<0){
     r = 1.;
     g = 1.;
     b = 1.;
   } else {
     if (logE<1){
r = 1.;
g = 1.;
b = 1.-logE;
     } else {
if (logE<2){
  r = 1.;
  g = 1.-(logE-1);
  b = 0.;
} else {
  if (logE<3){
    r = 1.;
    g = 0.;
    b = 1.-(logE-2);
  } else {
    if (logE<4){
      r = 1.-(logE-3);
      g = 0.;
      b = 1.;
    } else {
      r = 0;
      g = 0;
      b = 0;
    }
  }
}
     }
   }
   poly->SetFillColor(TColor::GetColor(r,g,b));
 }
}

// CCAL hits
if(hdvmf->GetCheckButton("ccal")){
 vector<const DCCALHit*> ccalhits;
 loop->Get(ccalhits);

 for(unsigned int i=0; i<ccalhits.size(); i++){
   const DCCALHit *hit = ccalhits[i];
   TPolyLine *poly = hdvmf->GetCCALPolyLine(hit->row, hit->column);
   if(!poly)continue;

   // The aim is to have a log scale in energy (see BCAL)
   double E = 1000*hit->E;      // Change Energy to MeV
   E /= 1000.0; // CCAL is currently not calibrated and appears to be at least 1E3 too large  2018-12-10 DL
   if(E<0.0) continue;
   double logE = log10(E);

   float r,g,b;
   if (logE<0){
   	r = 1.;
   	g = 1.;
   	b = 1.;
   } else {
   	if (logE<1){
   		r = 1.;
   		g = 1.;
   		b = 1.-logE;
   	} else {
   		if (logE<2){
   			r = 1.;
   			g = 1.-(logE-1);
   			b = 0.;
   		} else {
   			if (logE<3){
   				r = 1.;
   				g = 0.;
   				b = 1.-(logE-2);
   			} else {
   				if (logE<4){
   					r = 1.-(logE-3);
   					g = 0.;
   					b = 1.;
   				} else {
   					r = 0;
   					g = 0;
   					b = 0;
   				}
   			}
   		}
   	}
   }
   poly->SetFillColor(TColor::GetColor(r,g,b));
 }
}

// TOF hits
if(hdvmf->GetCheckButton("tof")){

 double hit_north[45];
 double hit_south[45];
 double hit_up[45];
 double hit_down[45];

 memset(hit_north,0,sizeof(hit_north));
 memset(hit_south,0,sizeof(hit_south));
 memset(hit_up,0,sizeof(hit_up));
 memset(hit_down,0,sizeof(hit_down));

        vector<const DTOFHit*> tofhits;
        loop->Get(tofhits);

        for(unsigned int i=0; i<tofhits.size(); i++){
          const DTOFHit *tof_hit = tofhits[i];

   int plane = tof_hit->plane;
          int bar = tof_hit->bar;
          int end = tof_hit->end;
          float t = tof_hit->t;
   
   int translate_side;
   TPolyLine *pmtPline;


   // Flash the PMTs that do have fADC hits

   /*
   double dE_padd = 0.2/5.2E5 * 40000;
   double thold = 0.2/5.2E5 * 115;
   if (tof_hit->has_fADC && (tof_hit->dE - dE_padd > thold)){
   */

   if (tof_hit->has_fADC){
     switch(plane)
{
case 0:
  if(end == 1){
    //cout << "Down : " << bar << endl;
    translate_side = 0;
    pmtPline = hdvmf->GetTOFPolyLine(translate_side, bar);
    pmtPline->SetFillColor(2);
  }
  else if(end == 0){
    //cout << "Up : " << bar << endl;
    translate_side = 2;
    pmtPline = hdvmf->GetTOFPolyLine(translate_side, bar);
    pmtPline->SetFillColor(2);
}
  else{
  cerr << "Out of range TOF end" << endl;
  }
  break;
case 1:
  if(end == 0){
    //cout << "North : " << bar << endl;
    translate_side = 3;
    pmtPline = hdvmf->GetTOFPolyLine(translate_side, bar);
    pmtPline->SetFillColor(2);
  }
  else if(end == 1){
    //cout << "South : " << bar << endl;
    translate_side = 1;
    pmtPline = hdvmf->GetTOFPolyLine(translate_side, bar);
    pmtPline->SetFillColor(2);
  }
  else{
    cerr << "Out of range TOF end" << endl;
  }
  break;
default:
  cerr << "Out of range TOF plane" << endl;
  exit(0);
} // close the switch plane loop
   } // if for the fADC

   // Draw the position from the events that do have tdc hits 
   // with the current status of the TOFHit object those hits appear with no match from the fADC
   //Float_t hit_dist;

   if (tof_hit->has_TDC){
     switch(plane)
{
case 0:
  if(end == 1){
    if (hit_down[bar]<=0 || (t < hit_down[bar]) ){
      hit_down[bar] = t;
    }
  }
  else if(end == 0){
    if (hit_up[bar]<=0 || (t < hit_up[bar]) ){
      hit_up[bar] = t;
    }
  }
  else{
  cerr << "Out of range TOF end" << endl;
  }
  break;
case 1:
  if(end == 0){
    if (hit_north[bar]<=0 || (t < hit_north[bar]) ){
      hit_north[bar] = t;
    }
  }
  else if(end == 1){
    if (hit_south[bar]<=0 || (t < hit_south[bar]) ){
      hit_south[bar] = t;
    }
  }
  else{
    cerr << "Out of range TOF end" << endl;
  }
  break;
default:
  cerr << "Out of range TOF plane" << endl;
  exit(0);
}
     
   } // close the switch if there is a TDC Hit
   
 } // close the for TOFHit object

 // Draw the TDC Points here

 Float_t hit_dist;
 Float_t distY_Horz = -126; // Horizontal plane start counting from the Bottom to Top
 Float_t distX_Vert =  -126; // Vertical plane start counting from the South to North
 int tdc_hits = 0;
 
 for(Int_t i_tdc = 1; i_tdc <= 44; i_tdc++){
   if ( i_tdc == 20 || i_tdc == 21 || i_tdc == 24 || i_tdc == 25 ){
     distY_Horz = distY_Horz + 1.5;
     distX_Vert = distX_Vert + 1.5;
   }
   else{
     distY_Horz = distY_Horz + 3.0;
     distX_Vert = distX_Vert + 3.0;
   }
   if(hit_north[i_tdc] > 0 && hit_south[i_tdc] > 0){
     hit_dist =  (15.2*(Float_t(hit_south[i_tdc] - hit_north[i_tdc])/2));
     TArc *tdc_cir = new TArc(hit_dist,distY_Horz,2);
     tdc_cir->SetFillColor(kGreen);

     graphics_tof_hits.push_back(tdc_cir);
     tdc_hits++;
   }
   if(hit_up[i_tdc] > 0 && hit_down[i_tdc] > 0){
     hit_dist =  (15.2*(Float_t(hit_down[i_tdc] - hit_up[i_tdc])/2) );
     TArc *tdc_cir = new TArc(distX_Vert,hit_dist,2);
     tdc_cir->SetFillColor(kBlue);

     graphics_tof_hits.push_back(tdc_cir);
     tdc_hits++;
   }
   if ( i_tdc == 20 || i_tdc == 21 || i_tdc == 24 || i_tdc == 25 ){
     distY_Horz = distY_Horz + 1.5;
     distX_Vert = distX_Vert + 1.5;
   }
   else{
     distY_Horz = distY_Horz + 3.0;
     distX_Vert = distX_Vert + 3.0;
   }
 }

      } // close the if check button for the TOF

// Start counter hits 
for (unsigned int i=0;i<schits.size();i++){
 DGraphicSet gset(6,kLine,2.0);
 double r_start=7.7493;
 double phi0=0.2094395*(schits[i]->sector-1);  // span 12 deg in phi
 double phi1=0.2094395*(schits[i]->sector);
 TVector3 point1(r_start*cos(phi0),r_start*sin(phi0),38.75); 
 gset.points.push_back(point1); // upstream end of sctraight section of scint
 TVector3 point2(r_start*cos(phi1),r_start*sin(phi1),38.75);
 gset.points.push_back(point2); 
 TVector3 point3(r_start*cos(phi1),r_start*sin(phi1),78.215);
 gset.points.push_back(point3); // downstream end of sctraight section of scint
 TVector3 point4(r_start*cos(phi0),r_start*sin(phi0),78.215);
 gset.points.push_back(point4); 
 TVector3 point5(r_start*cos(phi0),r_start*sin(phi0),38.75);
 gset.points.push_back(point5);

 /*
 // ST dimensions
 Double_t dtr = 1.74532925e-02;		// Conversion factor from degrees to radians
 Double_t st_straight = 39.465;		// Distance of the straight section along scintillator path
 Double_t st_arc_angle = 18.5;		// Angle of the bend arc
 Double_t st_arc_radius = 12.0;		// Radius of the bend arc
 Double_t st_to_beam = 7.74926;		// Distance from beam to bottom side of scintillator paddle
 Double_t st_len_cone = 16.056;		// Length of the cone section along scintillator path
 Double_t st_thickness = 0.3;		// Thickness of the scintillator paddles
 Double_t st_beam_to_arc_radius = 4.25;	// Distance from the beam line to the arc radius

 // Nose Arrays
 Double_t tp_nose_z[5];
 Double_t tp_nose_y[5];
 Double_t bm_nose_z[5];
 Double_t bm_nose_y[5];

 // Offsets for Hall coordinates
 Double_t z_center = 65.0;	// Target Center (0,0,65)
 Double_t us_end_pt = -26.25;    // Distance of upstream end relative to target
 Double_t ds_end_pt = 97.4;	// Distance of downstream end relative

 // Top start counter paddle straight section
 TPolyLine *top_paddle_straight;
 Double_t tp_straight_z[5] = {us_end_pt + z_center, us_end_pt + z_center, us_end_pt + st_straight + z_center, us_end_pt + st_straight + z_center, us_end_pt + z_center};
 Double_t tp_straight_y[5] = {st_to_beam, st_to_beam + st_thickness, st_to_beam + st_thickness, st_to_beam, st_to_beam};
 */
 graphics.push_back(gset);
}
 
// CDC hits
if(hdvmf->GetCheckButton("cdc")){
vector<const DCDCTrackHit*> cdctrackhits;
loop->Get(cdctrackhits);

for(unsigned int i=0; i<cdctrackhits.size(); i++){
	const DCDCWire *wire = cdctrackhits[i]->wire;
	
	int color = (cdctrackhits[i]->tdrift>-20 && cdctrackhits[i]->tdrift<800) ? kCyan:kYellow;
	DGraphicSet gset(color, kLine, 1.0);
	DVector3 dpoint=wire->origin-(wire->L/2.0)*wire->udir;
	TVector3 tpoint(dpoint.X(),dpoint.Y(),dpoint.Z());
	gset.points.push_back(tpoint);
	dpoint=wire->origin+(wire->L/2.0)*wire->udir;
	tpoint.SetXYZ(dpoint.X(),dpoint.Y(),dpoint.Z());
	gset.points.push_back(tpoint);
	graphics.push_back(gset);
	
	// Rings for drift times.
	// NOTE: These are not perfect since they still have TOF in them
	if(hdvmf->GetCheckButton("cdcdrift") && fabs(wire->stereo)<0.05){
		double x = wire->origin.X();
		double y = wire->origin.Y();
		double dist1 = cdctrackhits[i]->dist;
		TEllipse *e = new TEllipse(x, y, dist1, dist1);
		e->SetLineColor(38);
		e->SetFillStyle(0);
		graphics_xyA.push_back(e);

		double dist2 = dist1 - 4.0*55.0E-4; // what if our TOF was 4ns?
		e = new TEllipse(x, y, dist2, dist2);
		e->SetLineColor(38);
		e->SetFillStyle(0);
		graphics_xyA.push_back(e);
	}
}
}	

// FDC wire
if(hdvmf->GetCheckButton("fdcwire")){
vector<const DFDCHit*> fdchits;
loop->Get(fdchits);

for(unsigned int i=0; i<fdchits.size(); i++){
	const DFDCHit *fdchit = fdchits[i];
	if(fdchit->type!=0)continue;
	const DFDCWire *wire =fdcwires[fdchit->gLayer-1][fdchit->element-1];
	if(!wire){
		_DBG_std::cerr<<"programs/Analysis/hdview2/MyProcessor.cc"<<
":"<<992<<" "<<"Couldn't find wire for gLayer="<<fdchit->gLayer<<" and element="<<fdchit->element<<endl;
		continue;
	}
	
	// Wire
	int color = (fdchit->t>-50 && fdchit->t<2000) ? kCyan:kYellow;
	DGraphicSet gset(color, kLine, 1.0);
	DVector3 dpoint=wire->origin-(wire->L/2.0)*wire->udir;
	TVector3 tpoint(dpoint.X(),dpoint.Y(),dpoint.Z());
	gset.points.push_back(tpoint);
	dpoint=wire->origin+(wire->L/2.0)*wire->udir;
	tpoint.SetXYZ(dpoint.X(),dpoint.Y(),dpoint.Z());
	gset.points.push_back(tpoint);
	graphics.push_back(gset);
}		
}

// FDC intersection hits
if(hdvmf->GetCheckButton("fdcintersection")){
vector<const DFDCIntersection*> fdcints;
loop->Get(fdcints);
DGraphicSet gsetp(46, kMarker, 0.5);

for(unsigned int i=0; i<fdcints.size(); i++){
  TVector3 tpos(fdcints[i]->pos.X(),fdcints[i]->pos.Y(),
		fdcints[i]->pos.Z());
  gsetp.points.push_back(tpos);
}
graphics.push_back(gsetp);
}

// FDC psuedo hits
if(hdvmf->GetCheckButton("fdcpseudo")){
vector<const DFDCPseudo*> fdcpseudos;
loop->Get(fdcpseudos);
DGraphicSet gsetp(38, kMarker, 0.5);

for(unsigned int i=0; i<fdcpseudos.size(); i++){
	const DFDCWire *wire = fdcpseudos[i]->wire;
	
	// Pseudo point
	TVector3 pos(fdcpseudos[i]->xy.X(), 
		     fdcpseudos[i]->xy.Y(), wire->origin.Z());
	gsetp.points.push_back(pos);
}
graphics.push_back(gsetp);
}

// DMCThrown
if(hdvmf->GetCheckButton("thrown")){
vector<const DMCThrown*> mcthrown;
loop->Get(mcthrown);
for(unsigned int i=0; i<mcthrown.size(); i++){
	int color=14;
	double size=1.5;
	if(mcthrown[i]->charge()==0.0) color = kGreen;
	if(mcthrown[i]->charge() >0.0) color = kBlue;
	if(mcthrown[i]->charge() <0.0) color = kRed;
	switch(mcthrown[i]->type){
		case Gamma:
		case Positron:
		case Electron:
			size = 1.0;
			break;
		case Pi0:
		case PiPlus:
		case PiMinus:
			size = 2.0;
			break;
		case Neutron:
		case Proton:
		case AntiProton:
			size = 3.0;
			break;
	}
	AddKinematicDataTrack(mcthrown[i], color, size);
}
}

// CDC Truth points
if(hdvmf->GetCheckButton("cdctruth")){	
vector<const DMCTrackHit*> mctrackhits;
loop->Get(mctrackhits);
DGraphicSet gset(12, kMarker, 0.5);
for(unsigned int i=0; i<mctrackhits.size(); i++){
	const DMCTrackHit *hit = mctrackhits[i];
	if(hit->system != SYS_CDC)continue;

	TVector3 pos(hit->r*cos(hit->phi), hit->r*sin(hit->phi), hit->z);
	gset.points.push_back(pos);
}
graphics.push_back(gset);
}

// FDC Truth points
if(hdvmf->GetCheckButton("fdctruth")){	
vector<const DMCTrackHit*> mctrackhits;
loop->Get(mctrackhits);
DGraphicSet gset(12, kMarker, 0.5);
for(unsigned int i=0; i<mctrackhits.size(); i++){
	const DMCTrackHit *hit = mctrackhits[i];
	if(hit->system != SYS_FDC)continue;

	TVector3 pos(hit->r*cos(hit->phi), hit->r*sin(hit->phi), hit->z);
	gset.points.push_back(pos);
}
graphics.push_back(gset);
}

// Track Hits for Track Candidates and Candidate trajectory in Debuger Window
for(unsigned int n=0; n<trCand.size(); n++){
 if (n>9)
   break;
 char str1[128];
 sprintf(str1,"Candidate%d",n+1);
 
 if(hdvmf->GetCheckButton(str1)){	

   int color = n+1;
   if (color > 4)
     color++;
   if (color > 6)
     color++;	      
   
   AddKinematicDataTrack(trCand[n], color, 1.5);

   vector<const DCDCTrackHit*> cdctrackhits;
   trCand[n]->Get(cdctrackhits,"",1);
   for(unsigned int i=0; i<cdctrackhits.size(); i++){
     const DCDCWire *wire = cdctrackhits[i]->wire;
     DGraphicSet gset(color, kLine, 1.0);
     DVector3 dpoint=wire->origin-(wire->L/2.0)*wire->udir;
     TVector3 tpoint(dpoint.X(),dpoint.Y(),dpoint.Z());
     gset.points.push_back(tpoint);
     dpoint=wire->origin+(wire->L/2.0)*wire->udir;
     tpoint.SetXYZ(dpoint.X(),dpoint.Y(),dpoint.Z());
     gset.points.push_back(tpoint);
     graphics.push_back(gset);
     
   } // end loop of cdc hits of track candidate
   vector<const DFDCPseudo*> fdcpseudos;
   trCand[n]->Get(fdcpseudos,"",1);
   DGraphicSet gsetp(color, kMarker, 0.5);
   
   for(unsigned int i=0; i<fdcpseudos.size(); i++){
     const DFDCWire *wire = fdcpseudos[i]->wire;
     
     // Pseudo point
     TVector3 pos(fdcpseudos[i]->xy.X(), 
	   fdcpseudos[i]->xy.Y(), wire->origin.Z());
     gsetp.points.push_back(pos);
   }	
   graphics.push_back(gsetp);
   
 }
}

// Wire Based Track Hits and trajectory for Debuger Window
for(unsigned int n=0; n<trWB.size(); n++){
 if (n>=MaxWireTracks21)
   break;
 char str1[128];
 sprintf(str1,"WireBased%d",n+1);
 
 if(hdvmf->GetCheckButton(str1)){	

   int color = trWB[n]->candidateid;
   if (color > 4)
     color++;
   if (color > 6)
     color++;	      

   AddKinematicDataTrack(trWB[n], color, 1.5);

   vector<const DCDCTrackHit*> cdctrackhits;
   trWB[n]->Get(cdctrackhits,"",1);
   for(unsigned int i=0; i<cdctrackhits.size(); i++){
     const DCDCWire *wire = cdctrackhits[i]->wire;
     DGraphicSet gset(color, kLine, 1.0);
     DVector3 dpoint=wire->origin-(wire->L/2.0)*wire->udir;
     TVector3 tpoint(dpoint.X(),dpoint.Y(),dpoint.Z());
     gset.points.push_back(tpoint);
     dpoint=wire->origin+(wire->L/2.0)*wire->udir;
     tpoint.SetXYZ(dpoint.X(),dpoint.Y(),dpoint.Z());
     gset.points.push_back(tpoint);
     graphics.push_back(gset);
     
   } // end loop of cdc hits of track candidate
   vector<const DFDCPseudo*> fdcpseudos;
   trWB[n]->Get(fdcpseudos,"",1);
   DGraphicSet gsetp(color, kMarker, 0.5);
   
   for(unsigned int i=0; i<fdcpseudos.size(); i++){
     const DFDCWire *wire = fdcpseudos[i]->wire;
     
     // Pseudo point
     TVector3 pos(fdcpseudos[i]->xy.X(), 
	   fdcpseudos[i]->xy.Y(), wire->origin.Z());
     gsetp.points.push_back(pos);
   }
   graphics.push_back(gsetp);
   
 }
}

// Time Based Track Hits and trajectory for Debuger Window
for(unsigned int n=0; n<trTB.size(); n++){
 if (n>=MaxTimeTracks21)
   break;
 char str1[128];
 sprintf(str1,"TimeBased%d",n+1);
 
 if(hdvmf->GetCheckButton(str1)){	

   int color = trTB[n]->candidateid;
   if (color > 4)
     color++;
   if (color > 6)
     color++;	      

   AddKinematicDataTrack(trTB[n], color, 1.5);

   vector<const DCDCTrackHit*> cdctrackhits;
   trTB[n]->Get(cdctrackhits,"",1);
   for(unsigned int i=0; i<cdctrackhits.size(); i++){
     const DCDCWire *wire = cdctrackhits[i]->wire;
     DGraphicSet gset(color, kLine, 1.0);
     DVector3 dpoint=wire->origin-(wire->L/2.0)*wire->udir;
     TVector3 tpoint(dpoint.X(),dpoint.Y(),dpoint.Z());
     gset.points.push_back(tpoint);
     dpoint=wire->origin+(wire->L/2.0)*wire->udir;
     tpoint.SetXYZ(dpoint.X(),dpoint.Y(),dpoint.Z());
     gset.points.push_back(tpoint);
     graphics.push_back(gset);
     
   } // end loop of cdc hits of track candidate
   vector<const DFDCPseudo*> fdcpseudos;
   trTB[n]->Get(fdcpseudos,"",1);
   DGraphicSet gsetp(color, kMarker, 0.5);
   
   for(unsigned int i=0; i<fdcpseudos.size(); i++){
     const DFDCWire *wire = fdcpseudos[i]->wire;
     
     // Pseudo point
     TVector3 pos(fdcpseudos[i]->xy.X(), 
	   fdcpseudos[i]->xy.Y(), wire->origin.Z());
     gsetp.points.push_back(pos);
   }
   graphics.push_back(gsetp);
   
 }
}

// TOF reconstructed points 
if (hdvmf->GetCheckButton("tof")){
 vector<const DTOFPoint *>tofpoints;
 loop->Get(tofpoints);
 DGraphicSet gset(kRed, kMarker, 0.5);
 for(unsigned int i=0; i<tofpoints.size(); i++){
   const DTOFPoint *hit = tofpoints[i];
   TVector3 pos(hit->pos.x(),hit->pos.y(),hit->pos.z());
   gset.points.push_back(pos);
 }
 graphics.push_back(gset);
}

// TOF Truth points
if(hdvmf->GetCheckButton("toftruth")){	
vector<const DMCTrackHit*> mctrackhits;
loop->Get(mctrackhits);
DGraphicSet gset(kBlack, kMarker, 0.5);
for(unsigned int i=0; i<mctrackhits.size(); i++){
	const DMCTrackHit *hit = mctrackhits[i];
	if(hit->system != SYS_TOF)continue;

	TVector3 pos(hit->r*cos(hit->phi), hit->r*sin(hit->phi), hit->z);
	gset.points.push_back(pos);
}
graphics.push_back(gset);
}

// BCAL Truth points
if(hdvmf->GetCheckButton("bcaltruth")){	
vector<const DMCTrackHit*> mctrackhits;
loop->Get(mctrackhits);
DGraphicSet gset(kBlack, kMarker, 1.0);
for(unsigned int i=0; i<mctrackhits.size(); i++){
	const DMCTrackHit *hit = mctrackhits[i];
	if(hit->system != SYS_BCAL)continue;

	TVector3 pos(hit->r*cos(hit->phi), hit->r*sin(hit->phi), hit->z);
	gset.points.push_back(pos);

	TMarker *m = new TMarker(pos.X(), pos.Y(), 2);	
	graphics_xyA.push_back(m);
}
//graphics.push_back(gset);
}

// FCAL Truth points
if(hdvmf->GetCheckButton("fcaltruth")){
vector<const DFCALGeometry*> fcalgeometries;
vector<const DFCALHit*> mcfcalhits;
loop->Get(fcalgeometries);
loop->Get(mcfcalhits, "TRUTH");
if(fcalgeometries.size()>0){
	const DFCALGeometry *fgeom = fcalgeometries[0];

	DGraphicSet gset(kBlack, kMarker, 0.25);
	for(unsigned int i=0; i<mcfcalhits.size(); i++){
		const DFCALHit *hit = mcfcalhits[i];

		DVector2 pos_face = fgeom->positionOnFace(hit->row, hit->column);
		TVector3 pos(pos_face.X(), pos_face.Y(), FCAL_Zmin);
		gset.points.push_back(pos);
		
		TMarker *m = new TMarker(pos.X(), pos.Y(), 2);	
		//m->SetColor(kGreen);
		//m->SetLineWidth(1);
		graphics_xyB.push_back(m);

		TMarker *m1 = new TMarker(pos.Z(), pos.X(), 2);	
		graphics_xz.push_back(m1);
		TMarker *m2 = new TMarker(pos.Z(), pos.Y(), 2);	
		graphics_yz.push_back(m2);
	}
	//graphics.push_back(gset);
}
}

// BCAL reconstructed photons
if(hdvmf->GetCheckButton("recon_photons_bcal")){
vector<const DNeutralParticle*> neutrals;
loop->Get(neutrals);

DGraphicSet gset(kYellow+2, kMarker, 1.25);
gset.marker_style=21;
for(unsigned int i=0; i<neutrals.size(); i++){
  auto locNeutralShower = neutrals[i]->dNeutralShower;
  DetectorSystem_t locDetectorSystem = locNeutralShower->dDetectorSystem;
  if(locDetectorSystem == SYS_BCAL){
    TVector3 pos( locNeutralShower->dSpacetimeVertex.X(), 
		  locNeutralShower->dSpacetimeVertex.Y(), 
		  locNeutralShower->dSpacetimeVertex.Z());
    gset.points.push_back(pos);
    
    double dist2 = 2.0 + 5.0*locNeutralShower->dEnergy;
    TEllipse *e = new TEllipse(pos.X(), pos.Y(), dist2, dist2);
    e->SetLineColor(kGreen);
    e->SetFillStyle(0);
    e->SetLineWidth(2);
    graphics_xyA.push_back(e);
  }
}
//graphics.push_back(gset);
}

// FCAL reconstructed photons
if(hdvmf->GetCheckButton("recon_photons_fcal")){
vector<const DNeutralParticle*> neutrals;
loop->Get(neutrals);
DGraphicSet gset(kOrange, kMarker, 1.25);
gset.marker_style=2;
for(unsigned int i=0; i<neutrals.size(); i++){
  auto locNeutralShower = neutrals[i]->dNeutralShower;
  DetectorSystem_t locDetectorSystem = locNeutralShower->dDetectorSystem;
  if(locDetectorSystem == SYS_FCAL){
	
	TVector3 pos( locNeutralShower->dSpacetimeVertex.X(), 
		      locNeutralShower->dSpacetimeVertex.Y(), 
		      locNeutralShower->dSpacetimeVertex.Z());
	gset.points.push_back(pos);
	
	double dist2 = 2.0 + 10.0*locNeutralShower->dEnergy;
	TEllipse *e = new TEllipse(pos.X(), pos.Y(), dist2, dist2);
	e->SetLineColor(kGreen);
	e->SetFillStyle(0);
	e->SetLineWidth(2);
	graphics_xyB.push_back(e);

	TEllipse *e1 = new TEllipse(pos.Z(), pos.X(), dist2, dist2);
	e1->SetLineColor(kGreen);
	e1->SetFillStyle(0);
	e1->SetLineWidth(2);
	graphics_xz.push_back(e1);
	TEllipse *e2 = new TEllipse(pos.Z(), pos.Y(), dist2, dist2);
	e2->SetLineColor(kGreen);
	e2->SetFillStyle(0);
	e2->SetLineWidth(2);
	graphics_yz.push_back(e2);

  }
}
//graphics.push_back(gset);
}

// Reconstructed photons matched with tracks
if(hdvmf->GetCheckButton("recon_photons_track_match")){
vector<const DChargedTrack*> ctracks;
loop->Get(ctracks);
for(unsigned int i=0; i<ctracks.size(); i++){
  const DChargedTrack *locCTrack = ctracks[i];
  vector<const DNeutralShower*> locNeutralShowers;
  locCTrack->GetT(locNeutralShowers);

  if (!locNeutralShowers.size()) continue;
  const DNeutralShower *locNeutralShower = locNeutralShowers[0];
  
  
  // Decide if this hit BCAL of FCAL based on z of position on calorimeter
  bool is_bcal = (locNeutralShower->dDetectorSystem == SYS_BCAL );
  
  // Draw on all frames except FCAL frame
  DGraphicSet gset(kRed, kMarker, 1.25);
  gset.marker_style = is_bcal ? 22:3;
  TVector3 tpos( locNeutralShower->dSpacetimeVertex.X(), 
		 locNeutralShower->dSpacetimeVertex.Y(), 
		 locNeutralShower->dSpacetimeVertex.Z());
  gset.points.push_back(tpos);
  graphics.push_back(gset);
  
  // For BCAL hits, don't draw them on FCAL pane
  if(is_bcal)continue;
  
  // Draw on FCAL pane
  double dist2 = 2.0 + 2.0*locNeutralShower->dEnergy;
  TEllipse *e = new TEllipse(tpos.X(), tpos.Y(), dist2, dist2);
  e->SetLineColor(gset.color);
  e->SetFillStyle(0);
  e->SetLineWidth(1);
  TMarker *m = new TMarker(tpos.X(), tpos.Y(), gset.marker_style);
  m->SetMarkerColor(gset.color);
  m->SetMarkerSize(1.75);
  graphics_xyB.push_back(e);
  graphics_xyB.push_back(m);
}
}

// FCAL and BCAL thrown photon projections
if(hdvmf->GetCheckButton("thrown_photons_fcal") || hdvmf->GetCheckButton("thrown_photons_bcal")){
vector<const DMCThrown*> throwns;
loop->Get(throwns);
DGraphicSet gset(kSpring, kMarker, 1.25);
for(unsigned int i=0; i<throwns.size(); i++){
	const DMCThrown *thrown = throwns[i];
	if(thrown->charge()!=0.0)continue;
	
	// This may seem a little funny, but it saves swimming the reference trajectory
	// multiple times. The GetIntersectionWithCalorimeter() method will find the
	// intersection point of the photon with whichever calorimeter it actually hits
	// or if it doesn't hit either of them. Then, we decide to draw the marker based
	// on whether the flag is set to draw the calorimeter it hit or not.
	DVector3 pos;
	DetectorSystem_t who;
	GetIntersectionWithCalorimeter(thrown, pos, who);
	
	if(who!=SYS_FCAL && who!=SYS_BCAL)continue;
	if(who==SYS_FCAL && !hdvmf->GetCheckButton("thrown_photons_fcal"))continue;
	if(who==SYS_BCAL && !hdvmf->GetCheckButton("thrown_photons_bcal"))continue;
	TVector3 tpos(pos.X(),pos.Y(),pos.Z());
	gset.points.push_back(tpos);
	
	// Only draw on FCAL pane if photon hits FCAL
	if(who==SYS_BCAL)continue;
	
	double dist2 = 2.0 + 2.0*thrown->energy();
	TEllipse *e = new TEllipse(pos.X(), pos.Y(), dist2, dist2);
	e->SetLineColor(kSpring);
	e->SetFillStyle(0);
	e->SetLineWidth(4);
	graphics_xyB.push_back(e);
}
graphics.push_back(gset);
}

// FCAL and BCAL thrown charged particle projections
if(hdvmf->GetCheckButton("thrown_charged_fcal") || hdvmf->GetCheckButton("thrown_charged_bcal")){
vector<const DMCThrown*> throwns;
loop->Get(throwns);

for(unsigned int i=0; i<throwns.size(); i++){
	const DMCThrown *thrown = throwns[i];
	if(thrown->charge()==0.0)continue;
	
	// This may seem a little funny, but it saves swimming the reference trajectory
	// multiple times. The GetIntersectionWithCalorimeter() method will find the
	// intersection point of the photon with whichever calorimeter it actually hits
	// or if it doesn't hit either of them. Then, we decide to draw the marker based
	// on whether the flag is set to draw the calorimeter it hit or not.
	DVector3 pos;
	DetectorSystem_t who;
	GetIntersectionWithCalorimeter(thrown, pos, who);
	
	if(who!=SYS_FCAL && who!=SYS_BCAL)continue;
	if(who==SYS_FCAL && !hdvmf->GetCheckButton("thrown_charged_fcal"))continue;
	if(who==SYS_BCAL && !hdvmf->GetCheckButton("thrown_charged_bcal"))continue;
	
	DGraphicSet gset(thrown->charge()>0.0 ? kBlue:kRed, kMarker, 1.25);
	TVector3 tpos(pos.X(),pos.Y(),pos.Z());
	gset.points.push_back(tpos);
	graphics.push_back(gset);
	
	//double dist2 = 6.0 + 2.0*thrown->momentum().Mag();
	double dist2 = DELTA_R_FCAL;
	TEllipse *e = new TEllipse(pos.X(), pos.Y(), dist2, dist2);
	e->SetLineColor(thrown->charge()>0.0 ? kBlue:kRed);
	e->SetFillStyle(0);
	e->SetLineWidth(4);
	graphics_xyB.push_back(e);
}
}

// FCAL and BCAL reconstructed charged particle projections
if(hdvmf->GetCheckButton("recon_charged_bcal") || hdvmf->GetCheckButton("recon_charged_fcal")){

// Here we used the full time-based track list, even though it includes multiple
// hypotheses for each candidate. This is because currently, the photon/track
// matching code in PID/DPhoton_factory.cc uses the DTrackTimeBased objects and
// the current purpose of drawing these is to see matching of reconstructed
// charged tracks with calorimeter clusters.
vector<const DTrackTimeBased*> tracks;
loop->Get(tracks, hdvmf->GetFactoryTag("DTrackTimeBased"));

for(unsigned int i=0; i<tracks.size(); i++){
	const DTrackTimeBased *track = tracks[i];
	
	// See notes for above sections
	DVector3 pos;
	DetectorSystem_t who;
	GetIntersectionWithCalorimeter(track, pos, who);
	
	if(who!=SYS_FCAL && who!=SYS_BCAL)continue;
	if(who==SYS_FCAL && !hdvmf->GetCheckButton("recon_charged_fcal"))continue;
	if(who==SYS_BCAL && !hdvmf->GetCheckButton("recon_charged_bcal"))continue;
	
	DGraphicSet gset(track->charge()>0.0 ? kBlue:kRed, kMarker, 1.25);
	TVector3 tpos(pos.X(),pos.Y(),pos.Z());
	gset.points.push_back(tpos);
	graphics.push_back(gset);
	
	if(who==SYS_BCAL)continue; // Don't draw tracks hitting BCAL on FCAL pane
	
	//double dist2 = 6.0 + 2.0*track->momentum().Mag();
	double dist2 = DELTA_R_FCAL;
	TEllipse *e = new TEllipse(pos.X(), pos.Y(), dist2, dist2);
	e->SetLineColor(track->charge()>0.0 ? kBlue:kRed);
	e->SetFillStyle(0);
	e->SetLineWidth(4);
	graphics_xyB.push_back(e);
}
}

// CCAL reconstructed clusters
if(hdvmf->GetCheckButton("recon_photons_ccal")){
vector<const DCCALShower*> clusters;
loop->Get(clusters);
for(auto cluster : clusters){

	double E = cluster->E/1000.0; // divide by 1000 since energy does not seem to be calibrated to GeV at the moment.  2018-12-10 DL
	double dist2 = 1.0 + 0.5*E;
	DVector3 pos(cluster->x,cluster->y,cluster->z);

	TEllipse *e = new TEllipse(pos.X(), pos.Y(), dist2, dist2);
	e->SetLineColor(kGreen);
	e->SetFillStyle(0);
	e->SetLineWidth(2);
	graphics_xyB.push_back(e);

	TEllipse *e1 = new TEllipse(pos.Z(), pos.X(), dist2, dist2);
	e1->SetLineColor(kGreen);
	e1->SetFillStyle(0);
	e1->SetLineWidth(2);

	graphics_xz.push_back(e1);
	TEllipse *e2 = new TEllipse(pos.Z(), pos.Y(), dist2, dist2);
	e2->SetLineColor(kGreen);
	e2->SetFillStyle(0);
	e2->SetLineWidth(2);
	graphics_yz.push_back(e2);

}
//graphics.push_back(gset);
}

// DMCTrajectoryPoints
if(hdvmf->GetCheckButton("trajectories")){
vector<const DMCTrajectoryPoint*> mctrajectorypoints;
loop->Get(mctrajectorypoints);
//sort(mctrajectorypoints.begin(), mctrajectorypoints.end(), DMCTrajectoryPoint_track_cmp);

poly_type drawtype = hdvmf->GetCheckButton("trajectories_lines") ? kLine:kMarker;
double drawsize  = hdvmf->GetCheckButton("trajectories_lines") ? 1.0:0.3;
DGraphicSet gset(kBlack, drawtype, drawsize);
//gset.marker_style = 7;
TVector3 last_point;
int last_track=-1;
int last_part=-1;
for(unsigned int i=0; i<mctrajectorypoints.size(); i++){
	const DMCTrajectoryPoint *pt = mctrajectorypoints[i];
	
	switch(pt->part){
		case	Gamma:
			if(!hdvmf->GetCheckButton("trajectories_photon"))continue;
			break;
		case	Electron:
			if(!hdvmf->GetCheckButton("trajectories_electron"))continue;
			break;
		case	Positron:
			if(!hdvmf->GetCheckButton("trajectories_positron"))continue;
			break;
		case	Proton:
			if(!hdvmf->GetCheckButton("trajectories_proton"))continue;
			break;
		case	Neutron:
			if(!hdvmf->GetCheckButton("trajectories_neutron"))continue;
			break;
		case	PiPlus:
			if(!hdvmf->GetCheckButton("trajectories_piplus"))continue;
			break;
		case	PiMinus:
			if(!hdvmf->GetCheckButton("trajectories_piminus"))continue;
			break;
		default:
			if(!hdvmf->GetCheckButton("trajectories_other"))continue;
			break;
	}
				
	TVector3 v(pt->x, pt->y, pt->z);

	if(i>0){
		//if((v-last_point).Mag() > 10.0){
		if(pt->track!=last_track || pt->part!=last_part){
			if(hdvmf->GetCheckButton("trajectories_colors")){
	 			switch(last_part){
					case	Gamma:
		 				gset.color = kOrange;
			 			break;
		 			case	Electron:
		 			case	PiMinus:
		 				gset.color = kRed+2;
			 			break;
		 			case	Positron:
		 			case	Proton:
		 			case	PiPlus:
		 				gset.color = kBlue+1;
			 			break;
		 			case	Neutron:
		 				gset.color = kGreen+2;
			 			break;
					default:
		 				gset.color = kBlack;
			 			break;
	 			}
			}else{
				gset.color = kBlack;
			}
			graphics.push_back(gset);
			gset.points.clear();
		}
	}
	
	gset.points.push_back(v);
	last_point = v;
	last_track = pt->track;
	last_part = pt->part;
}

if(hdvmf->GetCheckButton("trajectories_colors")){
	switch(last_part){
		case	Gamma:
			gset.color = kOrange;
			 break;
		case	Electron:
		case	PiMinus:
			gset.color = kRed+2;
			break;
		case	Positron:
		case	Proton:
		case	PiPlus:
		 	gset.color = kBlue+1;
			break;
		case	Neutron:
		 	gset.color = kGreen+2;
			break;
		default:
		 	gset.color = kBlack;
			break;
	 }
}else{
	gset.color = kBlack;
}
graphics.push_back(gset);
}

// DTrackCandidate
if(hdvmf->GetCheckButton("candidates")){
vector<const DTrackCandidate*> trackcandidates;
loop->Get(trackcandidates, hdvmf->GetFactoryTag("DTrackCandidate"));
for(unsigned int i=0; i<trackcandidates.size(); i++){
	int color=i+1;
	double size=2.0;
	//if(trackcandidates[i]->charge() >0.0) color += 100; // lighter shade
	//if(trackcandidates[i]->charge() <0.0) color += 150; // darker shade
	AddKinematicDataTrack(trackcandidates[i], color, size);
}
}

// DTrackWireBased
if(hdvmf->GetCheckButton("wiretracks")){
vector<const DTrackWireBased*> wiretracks;
loop->Get(wiretracks, hdvmf->GetFactoryTag("DTrackWireBased"));
for(unsigned int i=0; i<wiretracks.size(); i++){
	AddKinematicDataTrack(wiretracks[i], (wiretracks[i]->charge()>0.0 ? kBlue:kRed)+2, 1.25);
}
}

// DTrackTimeBased
if(hdvmf->GetCheckButton("timetracks")){
vector<const DTrackTimeBased*> timetracks;
loop->Get(timetracks, hdvmf->GetFactoryTag("DTrackTimeBased"));
for(unsigned int i=0; i<timetracks.size(); i++){
	AddKinematicDataTrack(timetracks[i], (timetracks[i]->charge()>0.0 ? kBlue:kRed)+0, 1.00);
}
}

// DChargedTrack
if(hdvmf->GetCheckButton("chargedtracks")){
 vector<const DChargedTrack*> chargedtracks;
loop->Get(chargedtracks, hdvmf->GetFactoryTag("DChargedTrack"));
for(unsigned int i=0; i<chargedtracks.size(); i++){
  int color=kViolet-3;
  double size=1.25;
  if (chargedtracks[i]->Get_Charge() > 0) color=kMagenta;

  if (chargedtracks[i]->Get_BestFOM()->mass() > 0.9) size=2.5;
  AddKinematicDataTrack(chargedtracks[i]->Get_BestFOM(),color,size);
}
}

// DNeutralParticles
if(hdvmf->GetCheckButton("neutrals")){
vector<const DNeutralParticle*> photons;
loop->Get(photons, hdvmf->GetFactoryTag("DNeutralParticle"));
  
for(unsigned int i=0; i<photons.size(); i++){
  int color = kBlack;
  auto locNeutralShower = photons[i]->dNeutralShower;
  DetectorSystem_t locDetSys = locNeutralShower->dDetectorSystem;
  if(locDetSys==SYS_FCAL)color = kOrange;
  if(locDetSys==SYS_BCAL)color = kYellow+2;
  //if(locDetSys==DPhoton::kCharge)color = kRed;
  AddKinematicDataTrack(photons[i]->Get_BestFOM(), color, 1.00);
}
}
1746}

1748void MyProcessor::UpdateBcalDisp(void)
1749{
// This routine is run only once when the canvas is created.
BCALHitCanvas = hdvmf->GetBcalDispFrame();
BCALHitMatrixU = new TH2F("BCALHitMatrixU","BCAL Hits Upstream Energy;Sector number;Layer;Energy  (MeV)",  48*4+2, -1.5, 192.5, 10, 0., 10.);
BCALHitMatrixD = new TH2F("BCALHitMatrixD","BCAL Hits Downstream Energy;Sector number;Layer;Energy  (MeV)",48*4+2, -1.5, 192.5, 10, 0., 10.);
BCALParticles = new TH2F("BCALParticles","BCAL Particle Hits Type;Phi angle [deg];;Particle Momentum",(48*4+2)*4, -1.87, 361.87, 1, 0., 1.);
BCALHitMatrixU->SetStats(0);
BCALHitMatrixD->SetStats(0);
BCALParticles->SetStats(0);
Float_t size = 0.06;
BCALHitMatrixU->GetXaxis()->SetTitleSize(size);
BCALHitMatrixU->GetXaxis()->SetTitleOffset(0.8);
BCALHitMatrixU->GetXaxis()->SetLabelSize(size);
BCALHitMatrixU->GetYaxis()->SetTitleSize(size);
BCALHitMatrixU->GetYaxis()->SetTitleOffset(0.4);
BCALHitMatrixU->GetYaxis()->SetLabelSize(size);
BCALHitMatrixU->GetZaxis()->SetTitleSize(size);
BCALHitMatrixU->GetZaxis()->SetTitleOffset(0.4);
BCALHitMatrixU->GetZaxis()->SetLabelSize(size);
BCALHitMatrixD->GetXaxis()->SetTitleSize(size);
BCALHitMatrixD->GetXaxis()->SetTitleOffset(0.8);
BCALHitMatrixD->GetXaxis()->SetLabelSize(size);
BCALHitMatrixD->GetYaxis()->SetTitleSize(size);
BCALHitMatrixD->GetYaxis()->SetTitleOffset(0.4);
BCALHitMatrixD->GetYaxis()->SetLabelSize(size);
BCALHitMatrixD->GetZaxis()->SetTitleSize(size);
BCALHitMatrixD->GetZaxis()->SetTitleOffset(0.4);
BCALHitMatrixD->GetZaxis()->SetLabelSize(size);
BCALParticles->GetXaxis()->SetTitleSize(size);
BCALParticles->GetXaxis()->SetTitleOffset(0.8);
BCALParticles->GetXaxis()->SetLabelSize(size);
BCALParticles->GetYaxis()->SetTitleSize(size);
BCALParticles->GetYaxis()->SetTitleOffset(0.4);
BCALParticles->GetYaxis()->SetLabelSize(size);
BCALParticles->GetZaxis()->SetTitleSize(size);
BCALParticles->GetZaxis()->SetTitleOffset(0.4);
BCALParticles->GetZaxis()->SetLabelSize(size);

if (BCALHitCanvas) {
  vector<const DBCALHit*> locBcalHits;
  loop->Get(locBcalHits);
  BCALHitMatrixU->Reset();
  BCALHitMatrixD->Reset();
  for (unsigned int k=0;k<locBcalHits.size();k++){
    
    const DBCALHit* hit = locBcalHits[k];
    float idxY = (float)hit->layer-1;
    float idxX = (float) (hit->sector-1 + (hit->module-1)*4);
    if (hit->end == DBCALGeometry::kUpstream){
if (hit->layer==1){
 BCALHitMatrixU->Fill(idxX,idxY,hit->E);
} else if (hit->layer==2){
 BCALHitMatrixU->Fill(idxX,idxY,hit->E);	      
 BCALHitMatrixU->Fill(idxX,idxY+1.,hit->E);	      
} else if (hit->layer==3){
 BCALHitMatrixU->Fill(idxX,idxY+1,hit->E);	      
 BCALHitMatrixU->Fill(idxX,idxY+2.,hit->E);	      
 BCALHitMatrixU->Fill(idxX,idxY+3.,hit->E);	      
} else if (hit->layer==4){
 BCALHitMatrixU->Fill(idxX,idxY+3,hit->E);	      
 BCALHitMatrixU->Fill(idxX,idxY+4.,hit->E);	      
 BCALHitMatrixU->Fill(idxX,idxY+5.,hit->E);	      
 BCALHitMatrixU->Fill(idxX,idxY+6.,hit->E);	      
}
    } else {
if (hit->layer==1){
 BCALHitMatrixD->Fill(idxX,idxY,hit->E);
} else if (hit->layer==2){
 BCALHitMatrixD->Fill(idxX,idxY,hit->E);	      
 BCALHitMatrixD->Fill(idxX,idxY+1.,hit->E);	      
} else if (hit->layer==3){
 BCALHitMatrixD->Fill(idxX,idxY+1,hit->E);	      
 BCALHitMatrixD->Fill(idxX,idxY+2.,hit->E);	      
 BCALHitMatrixD->Fill(idxX,idxY+3.,hit->E);	      
} else if (hit->layer==4){
 BCALHitMatrixD->Fill(idxX,idxY+3,hit->E);	      
 BCALHitMatrixD->Fill(idxX,idxY+4.,hit->E);	      
 BCALHitMatrixD->Fill(idxX,idxY+5.,hit->E);	      
 BCALHitMatrixD->Fill(idxX,idxY+6.,hit->E);	      
}
    }
  }

LayerLegend = new TLegend(0.91,0.7,0.99,0.99);
for (int layer=0; layer<4; layer++) {
char name[255];
sprintf(name,"PhiZLayer%i",layer+1);
BCALPointZphiLayer[layer] = new TH2F(name,"BCAL Points vs Z position;Phi angle [deg];Z position (cm);Energy",48*4,0,360,48,-80,400);
FormatHistogram(BCALPointZphiLayer[layer],layer+1);
BCALPointZphiLayer[layer]->SetLineWidth(2);
sprintf(name,"PhiTLayer%i",layer+1);
BCALPointPhiTLayer[layer] = new TH2F(name,"BCAL Points vs time;Phi angle [deg];time  (ns);Energy",48*4,0,360,50,-100,100);
FormatHistogram(BCALPointPhiTLayer[layer],layer+1);
BCALPointPhiTLayer[layer]->SetLineWidth(2);

sprintf(name,"layer %i",layer+1);
LayerLegend->AddEntry(BCALPointZphiLayer[layer],name);
}

  vector<const DBCALIncidentParticle*> locBcalParticles;
  loop->Get(locBcalParticles);
  BCALParticles->Reset();
  BCALPLables.clear();
  for (unsigned int k=0;k<locBcalParticles.size();k++){
    
    const DBCALIncidentParticle* part = locBcalParticles[k];

    float p = TMath::Sqrt(part->px*part->px +  part->py*part->py +  part->pz*part->pz);

   float phi=999;
   if (part->x!=0){
     phi = TMath::ATan(TMath::Abs(part->y/part->x));
     //cout<<phi<<"   "<<part->y<<" / "<< part->x<<endl;
     if (part->y>0){
if (part->x<0.){
  phi = 3.1415926 - phi;
}
     } else {
if (part->x<0){
  phi += 3.1415926;
} else {
  phi = 3.1415926*2. - phi;
}
     }
     
     phi = phi*180./3.1415926;
   }
    BCALParticles->Fill(phi,0.5,p);
    char l[20];
    sprintf(l,"%d",part->ptype);
    TText *t = new TText(phi,1.01,l);
    t->SetTextSize(0.08);
    t->SetTextFont(72);
    t->SetTextAlign(21);
    BCALPLables.push_back(t);
  }
  
  
  BCALHitCanvas->Clear();
  BCALHitCanvas->Divide(1,3,0.001,0.001);
  BCALHitCanvas->cd(1);
gPad(TVirtualPad::Pad())->SetRightMargin(0.2);
  BCALHitMatrixU->Draw("colz");
  BCALHitCanvas->cd(2);
gPad(TVirtualPad::Pad())->SetRightMargin(0.2);
  BCALHitMatrixD->Draw("colz");
  BCALHitCanvas->cd(3);
gPad(TVirtualPad::Pad())->SetRightMargin(0.2);
  // BCALParticles->Draw("colz");
  // for (unsigned int n=0;n<BCALPLables.size();n++){
  //   BCALPLables[n]->Draw("same");
  // }
  BCALHitCanvas->Update();
}

1904}
1905//------------------------------------------------------------------
1906// UpdateTrackLabels 
1907//------------------------------------------------------------------
1908void MyProcessor::UpdateTrackLabels(void)
1909{
// Get the label pointers
string name, tag;
map<string, vector<TGLabel*> > &thrownlabs = hdvmf->GetThrownLabels();
map<string, vector<TGLabel*> > &reconlabs = hdvmf->GetReconstructedLabels();
hdvmf->GetReconFactory(name, tag);

// Get Thrown particles
vector<const DMCThrown*> throwns;
if(loop)loop->Get(throwns);

// Get the track info as DKinematicData objects
vector<const DKinematicData*> trks;
vector<const DKinematicData*> TrksCand;
vector<const DTrackWireBased*> TrksWireBased;
vector<const DTrackTimeBased*> TrksTimeBased;
vector<const DTrackCandidate*> cand;
if(loop)loop->Get(cand);
for(unsigned int i=0; i<cand.size(); i++)TrksCand.push_back(cand[i]);

if(loop)loop->Get(TrksWireBased);
if(loop)loop->Get(TrksTimeBased);

if(name=="DChargedTrack"){
vector<const DChargedTrack*> chargedtracks;
if(loop)loop->Get(chargedtracks, tag.c_str());
for(unsigned int i=0; i<chargedtracks.size(); i++){
  trks.push_back(chargedtracks[i]->Get_BestFOM());
}
}	
if(name=="DTrackTimeBased"){
vector<const DTrackTimeBased*> timetracks;
if(loop)loop->Get(timetracks, tag.c_str());
for(unsigned int i=0; i<timetracks.size(); i++)trks.push_back(timetracks[i]);
}
if(name=="DTrackWireBased"){
vector<const DTrackWireBased*> wiretracks;
if(loop)loop->Get(wiretracks, tag.c_str());
for(unsigned int i=0; i<wiretracks.size(); i++)trks.push_back(wiretracks[i]);
}
if(name=="DTrackCandidate"){
vector<const DTrackCandidate*> candidates;
if(loop)loop->Get(candidates, tag.c_str());
for(unsigned int i=0; i<candidates.size(); i++)trks.push_back(candidates[i]);
}
if(name=="DNeutralParticle"){
vector<const DNeutralParticle*> photons;
if(loop)loop->Get(photons, tag.c_str());
for(unsigned int i=0; i<photons.size(); i++) {
  trks.push_back(photons[i]->Get_BestFOM());
}
}

// Clear all labels (i.e. draw ---- in them)
map<string, vector<TGLabel*> >::iterator iter;
for(iter=reconlabs.begin(); iter!=reconlabs.end(); iter++){
vector<TGLabel*> &labs = iter->second;
for(unsigned int i=1; i<labs.size(); i++){
	labs[i]->SetText("--------");
}
}
for(iter=thrownlabs.begin(); iter!=thrownlabs.end(); iter++){
vector<TGLabel*> &labs = iter->second;
for(unsigned int i=1; i<labs.size(); i++){
	labs[i]->SetText("--------");
}
}

// Loop over thrown particles and fill in labels
int ii=0;
for(unsigned int i=0; i<throwns.size(); i++){
const DMCThrown *trk = throwns[i];
if(trk->type==0)continue;
int row = thrownlabs["trk"].size()-(ii++)-1;
if(row<1)break;

stringstream trkno, type, p, theta, phi, z;
trkno<<setprecision(4)<<i+1;
thrownlabs["trk"][row]->SetText(trkno.str().c_str());

thrownlabs["type"][row]->SetText(ParticleType((Particle_t)trk->type));

p<<setprecision(4)<<trk->momentum().Mag();
thrownlabs["p"][row]->SetText(p.str().c_str());

theta<<setprecision(4)<<trk->momentum().Theta()*TMath::RadToDeg();
thrownlabs["theta"][row]->SetText(theta.str().c_str());

double myphi = trk->momentum().Phi();
if(myphi<0.0)myphi+=2.0*M_PI3.14159265358979323846;
phi<<setprecision(4)<<myphi;
thrownlabs["phi"][row]->SetText(phi.str().c_str());

z<<setprecision(4)<<trk->position().Z();
thrownlabs["z"][row]->SetText(z.str().c_str());
}

// Loop over tracks and fill in labels
for(unsigned int i=0; i<trks.size(); i++){
const DKinematicData *trk = trks[i];
int row = reconlabs["trk"].size()-i-1;
if(row<1)break;

stringstream trkno, type, p, theta, phi, z, chisq_per_dof, Ndof,cand;
stringstream fom;
trkno<<setprecision(4)<<i+1;
reconlabs["trk"][row]->SetText(trkno.str().c_str());

double mass = trk->mass();
if(fabs(mass-0.13957)<1.0E-4)type<<"pi";
else if(fabs(mass-0.93827)<1.0E-4)type<<"proton";
else if(fabs(mass-0.493677)<1.0E-4)type<<"K";
else if(fabs(mass-0.000511)<1.0E-4)type<<"e";
else if (fabs(mass)<1.e-4 && fabs(trk->charge())<1.e-4) type << "gamma";
else type<<"q=";
if (fabs(trk->charge())>1.e-4){
  type<<(trk->charge()>0 ? "+":"-");
}
reconlabs["type"][row]->SetText(type.str().c_str());

p<<setprecision(4)<<trk->momentum().Mag();
reconlabs["p"][row]->SetText(p.str().c_str());

theta<<setprecision(4)<<trk->momentum().Theta()*TMath::RadToDeg();
reconlabs["theta"][row]->SetText(theta.str().c_str());

phi<<setprecision(4)<<trk->momentum().Phi()*TMath::RadToDeg();
reconlabs["phi"][row]->SetText(phi.str().c_str());

z<<setprecision(4)<<trk->position().Z();
reconlabs["z"][row]->SetText(z.str().c_str());

// Get chisq and Ndof for DTrackTimeBased or DTrackWireBased objects
const DTrackTimeBased *timetrack=dynamic_cast<const DTrackTimeBased*>(trk);
const DTrackWireBased *track=dynamic_cast<const DTrackWireBased*>(trk);	

const DTrackCandidate *candidate=dynamic_cast<const DTrackCandidate*>(trk);
const DChargedTrackHypothesis *chargedtrack=dynamic_cast<const DChargedTrackHypothesis *>(trk);

if(timetrack){
	chisq_per_dof<<setprecision(4)<<timetrack->chisq/timetrack->Ndof;
	Ndof<<timetrack->Ndof;
	fom << timetrack->FOM;
}else if(track){
	chisq_per_dof<<setprecision(4)<<track->chisq/track->Ndof;
	Ndof<<track->Ndof;
	fom << "N/A";
}else if (candidate){
	chisq_per_dof<<setprecision(4)<<candidate->chisq/candidate->Ndof;
	Ndof<<candidate->Ndof;
	fom << "N/A";
}
else if (chargedtrack){
	auto locTrackTimeBased = chargedtrack->Get_TrackTimeBased();
  chisq_per_dof<<setprecision(4)<<locTrackTimeBased->chisq/locTrackTimeBased->Ndof;
	Ndof<<locTrackTimeBased->Ndof;
	fom << locTrackTimeBased->FOM;
}
else{
  chisq_per_dof << "--------";
  Ndof << "--------";
  fom << "--------";
}

reconlabs["chisq/Ndof"][row]->SetText(chisq_per_dof.str().c_str());
reconlabs["Ndof"][row]->SetText(Ndof.str().c_str());
reconlabs["FOM"][row]->SetText(fom.str().c_str());

if (timetrack){
  cand << timetrack->candidateid;
}
else if (track){
  cand << track->candidateid;
}
else {
  cand << "--------";
}
reconlabs["cand"][row]->SetText(cand.str().c_str());
}

// Have the pop-up window with the full particle list update it's labels
if( fulllistmf ) fulllistmf->UpdateTrackLabels(throwns, trks);
if( debugermf  ) {
debugermf->SetTrackCandidates(TrksCand);
debugermf->SetTrackWireBased(TrksWireBased);
debugermf->SetTrackTimeBased(TrksTimeBased);
debugermf->UpdateTrackLabels();
}
2097}                 

2099//------------------------------------------------------------------
2100// AddKinematicDataTrack 
2101//------------------------------------------------------------------
2102void MyProcessor::AddKinematicDataTrack(const DKinematicData* kd, int color, double size)
2103{
// Create a reference trajectory with the given kinematic data and swim
// it through the detector.
DReferenceTrajectory rt(Bfield);
rt.Rsqmax_interior = RMAX_INTERIOR*RMAX_INTERIOR;
rt.Rsqmax_exterior = RMAX_EXTERIOR*RMAX_EXTERIOR;

if(MATERIAL_MAP_MODEL=="DRootGeom"){
rt.SetDRootGeom(RootGeom);
rt.SetDGeometry(NULL__null);
}else if(MATERIAL_MAP_MODEL=="DGeometry"){
rt.SetDRootGeom(NULL__null);
rt.SetDGeometry(geom);
}else if(MATERIAL_MAP_MODEL!="NONE"){
_DBG_std::cerr<<"programs/Analysis/hdview2/MyProcessor.cc"<<
":"<<2117<<" "<<"WARNING: Invalid value for TRKFIT:MATERIAL_MAP_MODEL (=\""<<MATERIAL_MAP_MODEL<<"\")"<<endl;
}

rt.SetMass(kd->mass());
rt.Swim(kd->position(), kd->momentum(), kd->charge());

// Create a new graphics set and fill it with all of the trajectory points
DGraphicSet gset(color, kLine, size);
DReferenceTrajectory::swim_step_t *step = rt.swim_steps;
for(int i=0; i<rt.Nswim_steps; i++, step++){
 TVector3 tpoint(step->origin.X(),step->origin.Y(),step->origin.Z());
gset.points.push_back(tpoint);
}

// Push the graphics set onto the stack
graphics.push_back(gset);
2133}

2135//------------------------------------------------------------------
2136// GetIntersectionWithCalorimeter 
2137//------------------------------------------------------------------
2138void MyProcessor::GetIntersectionWithCalorimeter(const DKinematicData* kd, DVector3 &pos, DetectorSystem_t &who)
2139{
// Create a reference trajectory with the given kinematic data and swim
// it through the detector.
DReferenceTrajectory rt(Bfield);
rt.Rsqmax_interior = RMAX_INTERIOR*RMAX_INTERIOR;
rt.Rsqmax_exterior = RMAX_EXTERIOR*RMAX_EXTERIOR;

if(MATERIAL_MAP_MODEL=="DRootGeom"){
rt.SetDRootGeom(RootGeom);
rt.SetDGeometry(NULL__null);
}else if(MATERIAL_MAP_MODEL=="DGeometry"){
rt.SetDRootGeom(NULL__null);
rt.SetDGeometry(geom);
}else if(MATERIAL_MAP_MODEL!="NONE"){
_DBG_std::cerr<<"programs/Analysis/hdview2/MyProcessor.cc"<<
":"<<2153<<" "<<"WARNING: Invalid value for TRKFIT:MATERIAL_MAP_MODEL (=\""<<MATERIAL_MAP_MODEL<<"\")"<<endl;
}

rt.SetMass(kd->mass());
rt.Swim(kd->position(), kd->momentum(), kd->charge());

// Find intersection with FCAL
DVector3 pos_fcal;
double s_fcal = 1.0E6;
DVector3 origin(0.0, 0.0, FCAL_Zmin);
DVector3 norm(0.0, 0.0, -1.0);
//rt.GetIntersectionWithPlane(origin, norm, pos_fcal, &s_fcal); // This gives different answer than below!
DVector3 p_at_intersection;
rt.GetIntersectionWithPlane(origin, norm, pos_fcal, p_at_intersection, &s_fcal, NULL__null, NULL__null, SYS_FCAL);
if(pos_fcal.Perp()<FCAL_Rmin || pos_fcal.Perp()>FCAL_Rmax || !isfinite(pos_fcal.Z()))s_fcal = 1.0E6;

// Find intersection with BCAL
DVector3 pos_bcal;
double s_bcal = 1.0E6;
rt.GetIntersectionWithRadius(BCAL_Rmin, pos_bcal, &s_bcal);
if(pos_bcal.Z()<BCAL_Zmin || pos_bcal.Z()>(BCAL_Zmin+BCAL_Zlen) || !isfinite(pos_bcal.Z()))s_bcal = 1.0E6;

if(s_fcal>10000.0 && s_bcal>10000.0){
// neither calorimeter hit
who = SYS_NULL;
pos.SetXYZ(0.0,0.0,0.0);
}else if(s_fcal<s_bcal){
// FCAL hit
who = SYS_FCAL;
pos = pos_fcal;
}else{
// BCAL hit
who = SYS_BCAL;
pos = pos_bcal;
}
2188}

2190//------------------------------------------------------------------
2191// GetFactoryNames 
2192//------------------------------------------------------------------
2193void MyProcessor::GetFactoryNames(vector<string> &facnames)
2194{
vector<JEventLoop*> loops = app->GetJEventLoops();
if(loops.size()>0){
vector<string> facnames;
loops[0]->GetFactoryNames(facnames);
}
2200}

2202//------------------------------------------------------------------
2203// GetFactories 
2204//------------------------------------------------------------------
2205void MyProcessor::GetFactories(vector<JFactory_base*> &factories)
2206{
vector<JEventLoop*> loops = app->GetJEventLoops();
if(loops.size()>0){
factories = loops[0]->GetFactories();
}
2211}

2213//------------------------------------------------------------------
2214// GetNrows 
2215//------------------------------------------------------------------
2216unsigned int MyProcessor::GetNrows(const string &factory, string tag)
2217{
vector<JEventLoop*> loops = app->GetJEventLoops();
if(loops.size()>0){
// Here is something a little tricky. The GetFactory() method of JEventLoop
// gets the factory of the specified data name and tag, but without trying
// to substitute a user-specified tag (a'la -PDEFTAG:XXX=YYY) as is done
// on normal Get() method calls. Therefore, we have to check for the default
// tags ourselves and substitute it "by hand".
if(tag==""){
	map<string,string> default_tags = loops[0]->GetDefaultTags();
	map<string, string>::const_iterator iter = default_tags.find(factory);
	if(iter!=default_tags.end())tag = iter->second.c_str();
}
JFactory_base *fac = loops[0]->GetFactory(factory, tag.c_str());

// Since calling GetNrows will cause the program to quit if there is
// not a valid event, then first check that there is one before calling it
if(loops[0]->GetJEvent().GetJEventSource() == NULL__null)return 0;

return fac==NULL__null ? 0:(unsigned int)fac->GetNrows();
}

return 0;
2240}

2242//------------------------------------------------------------------
2243// GetDReferenceTrajectory 
2244//------------------------------------------------------------------
2245void MyProcessor::GetDReferenceTrajectory(string dataname, string tag, unsigned int index, DReferenceTrajectory* &rt, vector<const DCDCTrackHit*> &cdchits)
2246{
2247_DBG__std::cerr<<"programs/Analysis/hdview2/MyProcessor.cc"<<
":"<<2247<<std::endl;
// initialize rt to NULL in case we don't find the one requested
rt = NULL__null;
cdchits.clear();

// Get pointer to the JEventLoop so we can get at the data
vector<JEventLoop*> loops = app->GetJEventLoops();
if(loops.size()==0)return;
JEventLoop* &loop = loops[0];

// Variables to hold track parameters
DVector3 pos, mom(0,0,0);
double q=0.0;
double mass = 0.13957018;

// Find the specified track	
if(dataname=="DChargedTrack"){
vector<const DChargedTrack*> chargedtracks;
vector<const DTrackTimeBased*> timebasedtracks;
loop->Get(chargedtracks, tag.c_str());
if(index>=chargedtracks.size())return;
q = chargedtracks[index]->Get_Charge();
pos = chargedtracks[index]->Get_BestFOM()->position();
mom = chargedtracks[index]->Get_BestFOM()->momentum();
chargedtracks[index]->Get_BestFOM()->GetT(timebasedtracks);
if(!timebasedtracks.empty()){
	timebasedtracks[0]->Get(cdchits);
	mass = chargedtracks[index]->Get_BestFOM()->mass();
}
}

if(dataname=="DTrackTimeBased"){
vector<const DTrackTimeBased*> timetracks;
loop->Get(timetracks, tag.c_str());
if(index>=timetracks.size())return;
q = timetracks[index]->charge();
pos = timetracks[index]->position();
mom = timetracks[index]->momentum();
timetracks[index]->Get(cdchits);
mass = timetracks[index]->mass();
}

if(dataname=="DTrackWireBased"){
vector<const DTrackWireBased*> wiretracks;
loop->Get(wiretracks, tag.c_str());
if(index>=wiretracks.size())return;
q = wiretracks[index]->charge();
pos = wiretracks[index]->position();
mom = wiretracks[index]->momentum();
wiretracks[index]->Get(cdchits);
mass = wiretracks[index]->mass();
}

if(dataname=="DTrackCandidate"){
vector<const DTrackCandidate*> tracks;
loop->Get(tracks, tag.c_str());
if(index>=tracks.size())return;
q = tracks[index]->charge();
pos = tracks[index]->position();
mom = tracks[index]->momentum();
tracks[index]->Get(cdchits);
mass = tracks[index]->mass();
}

if(dataname=="DMCThrown"){
vector<const DMCThrown*> tracks;
loop->Get(tracks, tag.c_str());
if(index>=tracks.size())return;
const DMCThrown *t = tracks[index];
q = t->charge();
pos = t->position();
mom = t->momentum();
tracks[index]->Get(cdchits);
mass = tracks[index]->mass();
2321_DBG_std::cerr<<"programs/Analysis/hdview2/MyProcessor.cc"<<
":"<<2321<<" "<<"mass="<<mass<<endl;
}

// Make sure we found a charged particle we can track
if(q==0.0 || mom.Mag()<0.01)return;

// Create a new DReference trajectory object. The caller takes
// ownership of this and so they are responsible for deleting it.
rt = new DReferenceTrajectory(Bfield);
rt->Rsqmax_interior = RMAX_INTERIOR*RMAX_INTERIOR;
rt->Rsqmax_exterior = RMAX_EXTERIOR*RMAX_EXTERIOR;
rt->SetMass(mass);
if(MATERIAL_MAP_MODEL=="DRootGeom"){
rt->SetDRootGeom(RootGeom);
rt->SetDGeometry(NULL__null);
}else if(MATERIAL_MAP_MODEL=="DGeometry"){
rt->SetDRootGeom(NULL__null);
rt->SetDGeometry(geom);
}else if(MATERIAL_MAP_MODEL!="NONE"){
_DBG_std::cerr<<"programs/Analysis/hdview2/MyProcessor.cc"<<
":"<<2340<<" "<<"WARNING: Invalid value for TRKFIT:MATERIAL_MAP_MODEL (=\""<<MATERIAL_MAP_MODEL<<"\")"<<endl;
}
rt->Swim(pos, mom, q);
2343}

2345//------------------------------------------------------------------
2346// GetAllWireHits
2347//------------------------------------------------------------------
2348void MyProcessor::GetAllWireHits(vector<pair<const DCoordinateSystem*,double> > &allhits)
2349{
/// Argument is vector of pairs that contain a pointer to the
/// DCoordinateSystem representing a wire and a double that
/// represents the drift distance. To get info on the specific
/// wire, one needs to attempt a dynamic_cast to both a DCDCWire
/// and a DFDCWire and access the parameters of whichever one succeeds.

// Get pointer to the JEventLoop so we can get at the data
vector<JEventLoop*> loops = app->GetJEventLoops();
if(loops.size()==0)return;
1
Assuming the condition is false→
2
←
Taking false branch→
JEventLoop* &loop = loops[0];

// Get CDC wire hits
vector<const DCDCTrackHit*> cdchits;
loop->Get(cdchits);
3
←
Calling 'JEventLoop::Get'→
for(unsigned int i=0; i<cdchits.size(); i++){
pair<const DCoordinateSystem*,double> hit;
hit.first = cdchits[i]->wire;
hit.second = cdchits[i]->dist;
allhits.push_back(hit);
}

// Get FDC wire hits
vector<const DFDCPseudo*> fdchits;
loop->Get(fdchits);
for(unsigned int i=0; i<fdchits.size(); i++){
pair<const DCoordinateSystem*,double> hit;
hit.first = fdchits[i]->wire;
hit.second = 0.0055*fdchits[i]->time;
allhits.push_back(hit);
}
2380}



2384//------------------------------------------------------------------
2385// FormatHistogram
2386//------------------------------------------------------------------
2387void MyProcessor::FormatHistogram(TH2* histo, int color=1)
2388{
histo->SetStats(0);
histo->SetLineColor(color);
histo->SetMarkerColor(color);
Float_t size = 0.06;
histo->SetTitleSize(size);
histo->GetXaxis()->SetTitleSize(size);
histo->GetXaxis()->SetTitleOffset(0.8);
histo->GetXaxis()->SetLabelSize(size);
histo->GetYaxis()->SetTitleSize(size);
histo->GetYaxis()->SetTitleOffset(0.5);
histo->GetYaxis()->SetLabelSize(size);
histo->GetZaxis()->SetTitleSize(size);
histo->GetZaxis()->SetTitleOffset(0.4);
histo->GetZaxis()->SetLabelSize(size);
2403}

←

/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 = tag3.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
4
←
'?' condition is false→
if(strlen(mytag)==0 && allow_deftag4.1
'allow_deftag' is true
1
'allow_deftag' is true
1
'allow_deftag' is true
){
5
←
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();
6
←
Assuming the condition is true→
7
←
Taking true branch→
8
←
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);
9
←
Assuming field 'record_call_stack' is false→
10
←
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);
11
←
Passing value via 2nd parameter 'tag'→
12
←
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
13
←
Assuming 'tag' is equal to NULL→
14
←
'?' condition is true→
if(strlen(mytag)==0 && allow_deftag14.1
'allow_deftag' is true
1
'allow_deftag' is true
1
'allow_deftag' is true
){
15
←
Taking true branch→
map<string, string>::const_iterator iter = default_tags.find(className);
if(iter!=default_tags.end())tag = iter->second.c_str();
16
←
Assuming the condition is false→
17
←
Taking false branch→
}

for(; iter!=factories.end(); iter++){
18
←
Calling 'operator!=<jana::JFactory_base **, std::vector<jana::JFactory_base *>>'→
21
←
Returning from 'operator!=<jana::JFactory_base **, std::vector<jana::JFactory_base *>>'→
22
←
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);
23
←
Taking true branch→
if(factory == NULL__null)continue;
24
←
Assuming 'factory' is not equal to NULL→
25
←
Taking false branch→
const char *factag = factory->Tag()==NULL__null ? "":factory->Tag();
26
←
Assuming the condition is true→
27
←
'?' condition is true→
if(!strcmp(factag, tag)){
28
←
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(); }
19
←
Assuming the condition is true→
20
←
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