/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 DHistogramActions_Independent.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/libraries/ANALYSIS -I libraries/ANALYSIS -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++ libraries/ANALYSIS/DHistogramActions_Independent.cc

libraries/ANALYSIS/DHistogramActions_Independent.cc

→


2#include <unistd.h>

4#include "ANALYSIS/DHistogramActions.h"
5#include "TOF/DTOFGeometry.h"

7void DHistogramAction_ObjectMemory::Initialize(JEventLoop* locEventLoop)
8{
//setup binning
vector<string> locBinLabels = {"TMatrixFSym", "DKinematicInfo", "Charged DTimingInfo", "DTrackingInfo", "Neutral DTimingInfo", "KinematicDatas", "Charged Hypos", "Neutral Hypos", "Beam Photons",
	"Combo RF Bunches", "Source Combos", "Source Combo Vectors", "Particle Combos", "Particle Combo Steps",
	"DKinFitParticle", "DKinFitChainStep", "DKinFitChain", "DKinFitResults", "DKinFitConstraint_Mass", "DKinFitConstraint_P4", "DKinFitConstraint_Vertex", "DKinFitConstraint_Spacetime"};
for(size_t loc_i = 0; loc_i < locBinLabels.size(); ++loc_i)
dBinMap[locBinLabels[loc_i]] = loc_i + 1;

//CREATE THE HISTOGRAMS
//Since we are creating histograms, the contents of gDirectory will be modified: must use JANA-wide ROOT lock
japp->RootWriteLock(); //ACQUIRE ROOT LOCK!!
{
CreateAndChangeTo_ActionDirectory();

dVirtualMemoryVsEventNumber = new TH1F("VirtualMemoryVsEventNumber", ";Event Counter;Virtual Memory (MB)", dMaxNumEvents, 0.5, (double)dMaxNumEvents + 0.5);
dResidentMemoryVsEventNumber = new TH1F("ResidentMemoryVsEventNumber", ";Event Counter;Resident Memory (MB)", dMaxNumEvents, 0.5, (double)dMaxNumEvents + 0.5);

// Total Memory
string locHistName = "TotalMemory";
string locHistTitle = ";Event Counter;Total Memory (MB)";
dHist_TotalMemory = GetOrCreate_Histogram<TH1F>(locHistName, locHistTitle, dMaxNumEvents, 0.5, float(dMaxNumEvents) + 0.5);

// # Objects
locHistName = "NumObjects2D";
locHistTitle = "# Objects;Event Counter";
dHist_NumObjects = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dMaxNumEvents, 0.5, float(dMaxNumEvents) + 0.5, locBinLabels.size(), 0.5, float(locBinLabels.size()) + 0.5);
for(size_t loc_i = 0; loc_i < locBinLabels.size(); ++loc_i)
	dHist_NumObjects->GetYaxis()->SetBinLabel(1 + loc_i, locBinLabels[loc_i].c_str());

// Object Memory
locHistName = "Memory2D";
locHistTitle = "Memory (MB);Event Counter";
dHist_Memory = GetOrCreate_Histogram<TH2F>(locHistName, locHistTitle, dMaxNumEvents, 0.5, float(dMaxNumEvents) + 0.5, locBinLabels.size(), 0.5, float(locBinLabels.size()) + 0.5);
for(size_t loc_i = 0; loc_i < locBinLabels.size(); ++loc_i)
	dHist_Memory->GetYaxis()->SetBinLabel(1 + loc_i, locBinLabels[loc_i].c_str());

//Return to the base directory
ChangeTo_BaseDirectory();
}
japp->RootUnLock(); //RELEASE ROOT LOCK!!
48}

50bool DHistogramAction_ObjectMemory::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
51{
if(Get_CalledPriorWithComboFlag())
return true; //else double-counting!

if(dEventCounter > dMaxNumEvents)
return true;

if(locParticleCombo != nullptr)
return true; // Protect against infinite recursion (see below)

//THIS IS EXTREMELY DANGEROUS, AND SHOULD BE AVOIDED UNLESS YOU KNOW !!!!EXACTLY!!!! WHAT YOU ARE DOING
//And if you're doing this, you probably don't
//This will result in a infinite-recursion crash if it is called by DAnalysisResults_factory. 
//This action should only be used directly in an event processsor
//This casuses the analysis to run, generating the objects needed for histogramming below. 
vector<const DAnalysisResults*> locAnalysisResults;
locEventLoop->Get(locAnalysisResults);

map<int, size_t> locNumObjectsMap; //int is bin
map<int, double> locMemoryMap; //int is bin
double locTotalMemory = 0.0;

/******************************************************* COMPONENT OBJECTS *******************************************************/

//TMatrixFSym
auto locBin = dBinMap["TMatrixFSym"];
locNumObjectsMap[locBin] = dResourcePool_TMatrixFSym.Get_NumObjectsAllThreads();
auto locMemory = (sizeof(TMatrixDSym) + 7*7*4)*locNumObjectsMap[locBin]; //assume 7x7 matrix of floats (4)
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

//DKinematicData::DKinematicInfo
locBin = dBinMap["DKinematicInfo"];
locNumObjectsMap[locBin] = dResourcePool_KinematicInfo.Get_NumObjectsAllThreads();
locMemory = sizeof(DKinematicData::DKinematicInfo)*locNumObjectsMap[locBin];
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

//DChargedTrackHypothesis::DTimingInfo
locBin = dBinMap["Charged DTimingInfo"];
locNumObjectsMap[locBin] = dResourcePool_ChargedHypoTimingInfo.Get_NumObjectsAllThreads();
locMemory = sizeof(DChargedTrackHypothesis::DTimingInfo)*locNumObjectsMap[locBin];
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

//DChargedTrackHypothesis::DTrackingInfo
locBin = dBinMap["DTrackingInfo"];
locNumObjectsMap[locBin] = dResourcePool_ChargedHypoTrackingInfo.Get_NumObjectsAllThreads();
locMemory = sizeof(DChargedTrackHypothesis::DTrackingInfo)*locNumObjectsMap[locBin];
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

//DNeutralParticleHypothesis::DTimingInfo
locBin = dBinMap["Neutral DTimingInfo"];
locNumObjectsMap[locBin] = dResourcePool_NeutralHypoTimingInfo.Get_NumObjectsAllThreads();
locMemory = sizeof(DNeutralParticleHypothesis::DTimingInfo)*locNumObjectsMap[locBin];
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

/******************************************************* KINEMATIC DATA OBJECTS *******************************************************/

//DKinematicData
locBin = dBinMap["KinematicDatas"];
locNumObjectsMap[locBin] = dResourcePool_KinematicData.Get_NumObjectsAllThreads();
locMemory = sizeof(DKinematicData)*locNumObjectsMap[locBin];
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

//DChargedTrackHypothesis
locBin = dBinMap["Charged Hypos"];
locNumObjectsMap[locBin] = dResourcePool_ChargedTrackHypothesis.Get_NumObjectsAllThreads();
locMemory = sizeof(DChargedTrackHypothesis)*locNumObjectsMap[locBin];
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

//DNeutralParticleHypothesis
locBin = dBinMap["Neutral Hypos"];
locNumObjectsMap[locBin] = dResourcePool_NeutralParticleHypothesis.Get_NumObjectsAllThreads();
locMemory = sizeof(DNeutralParticleHypothesis)*locNumObjectsMap[locBin];
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

//DBeamPhoton
locBin = dBinMap["Beam Photons"];
locNumObjectsMap[locBin] = dResourcePool_BeamPhotons.Get_NumObjectsAllThreads();
locMemory = sizeof(DBeamPhoton)*locNumObjectsMap[locBin];
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

/******************************************************* COMBO OBJECTS *******************************************************/

//DEventRFBunch
locBin = dBinMap["Combo RF Bunches"];
locNumObjectsMap[locBin] = dResourcePool_EventRFBunch.Get_NumObjectsAllThreads();
locMemory = sizeof(DEventRFBunch)*locNumObjectsMap[locBin];
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

//DSourceCombo
locBin = dBinMap["Source Combos"];
locNumObjectsMap[locBin] = dResourcePool_SourceCombo.Get_NumObjectsAllThreads();
locMemory = sizeof(DSourceCombo)*locNumObjectsMap[locBin];
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

//DSourceCombo Vectors
locBin = dBinMap["Source Combo Vectors"];
locNumObjectsMap[locBin] = dResourcePool_SourceComboVector.Get_NumObjectsAllThreads();
locMemory = sizeof(vector<const DSourceCombo*>)*locNumObjectsMap[locBin];
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

//DParticleCombo
locBin = dBinMap["Particle Combos"];
locNumObjectsMap[locBin] = dResourcePool_ParticleCombo.Get_NumObjectsAllThreads();
locMemory = sizeof(DParticleCombo)*locNumObjectsMap[locBin];
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

//DParticleComboStep
locBin = dBinMap["Particle Combo Steps"];
locNumObjectsMap[locBin] = dResourcePool_ParticleComboStep.Get_NumObjectsAllThreads();
locMemory = sizeof(DParticleComboStep)*locNumObjectsMap[locBin];
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

/******************************************************* KINFIT OBJECTS *******************************************************/

//DKinFitParticle
locBin = dBinMap["DKinFitParticle"];
locNumObjectsMap[locBin] = dResourcePool_KinFitParticle.Get_NumObjectsAllThreads();
locMemory = sizeof(DKinFitParticle)*locNumObjectsMap[locBin];
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

//DKinFitChainStep
locBin = dBinMap["DKinFitChainStep"];
locNumObjectsMap[locBin] = dResourcePool_KinFitChainStep.Get_NumObjectsAllThreads();
locMemory = sizeof(DKinFitChainStep)*locNumObjectsMap[locBin];
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

//DKinFitChain
locBin = dBinMap["DKinFitChain"];
locNumObjectsMap[locBin] = dResourcePool_KinFitChain.Get_NumObjectsAllThreads();
locMemory = sizeof(DKinFitChain)*locNumObjectsMap[locBin];
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

//DKinFitResults
locBin = dBinMap["DKinFitResults"];
locNumObjectsMap[locBin] = dResourcePool_KinFitResults.Get_NumObjectsAllThreads();
locMemory = sizeof(DKinFitResults)*locNumObjectsMap[locBin];
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

/******************************************************* KINFIT CONSTRAINTS *******************************************************/

//DKinFitConstraint_Mass
locBin = dBinMap["DKinFitConstraint_Mass"];
locNumObjectsMap[locBin] = dResourcePool_MassConstraint.Get_NumObjectsAllThreads();
locMemory = sizeof(DKinFitConstraint_Mass)*locNumObjectsMap[locBin];
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

//DKinFitConstraint_P4
locBin = dBinMap["DKinFitConstraint_P4"];
locNumObjectsMap[locBin] = dResourcePool_P4Constraint.Get_NumObjectsAllThreads();
locMemory = sizeof(DKinFitConstraint_P4)*locNumObjectsMap[locBin];
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

//DKinFitConstraint_Vertex
locBin = dBinMap["DKinFitConstraint_Vertex"];
locNumObjectsMap[locBin] = dResourcePool_VertexConstraint.Get_NumObjectsAllThreads();
locMemory = sizeof(DKinFitConstraint_Vertex)*locNumObjectsMap[locBin];
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

//DKinFitConstraint_Spacetime
locBin = dBinMap["DKinFitConstraint_Spacetime"];
locNumObjectsMap[locBin] = dResourcePool_SpacetimeConstraint.Get_NumObjectsAllThreads();
locMemory = sizeof(DKinFitConstraint_Spacetime)*locNumObjectsMap[locBin];
locMemoryMap[locBin] = locMemory;
locTotalMemory += locMemory;

//Convert to MB
for(auto& locMemoryPair : locMemoryMap)
locMemoryPair.second /= (1024.0*1024.0);
locTotalMemory /= (1024.0*1024.0); //convert to MB

//FILL HISTOGRAMS
//Since we are filling histograms local to this action, it will not interfere with other ROOT operations: can use action-wide ROOT lock
//Note, the mutex is unique to this DReaction + action_string combo: actions of same class with different hists will have a different mutex
Lock_Action(); //ACQUIRE ROOT LOCK!!
{
++dEventCounter;
if(dEventCounter <= dMaxNumEvents)
{
	for(auto& locNumObjectsPair : locNumObjectsMap)
	{
		int locObjectBin = locNumObjectsPair.first;
		dHist_NumObjects->SetBinContent(dEventCounter, locObjectBin, locNumObjectsMap[locObjectBin]);
		dHist_Memory->SetBinContent(dEventCounter, locObjectBin, locMemoryMap[locObjectBin]);
	}
	dHist_TotalMemory->SetBinContent(dEventCounter, locTotalMemory);

	double vm, rss;
	Read_MemoryUsage(vm, rss);
	dVirtualMemoryVsEventNumber->SetBinContent(dEventCounter, vm / 1024.0);
	dResidentMemoryVsEventNumber->SetBinContent(dEventCounter, rss / 1024.0);
}
}
Unlock_Action(); //RELEASE ROOT LOCK!!

return true;
267}

269void DHistogramAction_ObjectMemory::Read_MemoryUsage(double& vm_usage, double& resident_set)
270{
vm_usage     = 0.0;
resident_set = 0.0;

// 'file' stat seems to give the most reliable results
ifstream stat_stream("/proc/self/stat",ios_base::in);

// dummy vars for leading entries in stat that we don't care about
string pid, comm, state, ppid, pgrp, session, tty_nr;
string tpgid, flags, minflt, cminflt, majflt, cmajflt;
string utime, stime, cutime, cstime, priority, nice;
string O, itrealvalue, starttime;

// the two fields we want
unsigned long vsize;
long rss;

stat_stream >> pid >> comm >> state >> ppid >> pgrp >> session >> tty_nr
>> tpgid >> flags >> minflt >> cminflt >> majflt >> cmajflt
>> utime >> stime >> cutime >> cstime >> priority >> nice
>> O >> itrealvalue >> starttime >> vsize >> rss; // don't care about the rest

stat_stream.close();

long page_size_kb = sysconf(_SC_PAGE_SIZE_SC_PAGESIZE) / 1024; // in case x86-64 is configured to use 2MB pages
vm_usage     = vsize / 1024.0;
resident_set = rss * page_size_kb;
297}

299void DHistogramAction_Reconstruction::Initialize(JEventLoop* locEventLoop)
300{
//Create any histograms/trees/etc. within a ROOT lock.
//This is so that when running multithreaded, only one thread is writing to the ROOT file at a time.

//When creating a reaction-independent action, only modify member variables within a ROOT lock.
//Objects created within a plugin (such as reaction-independent actions) can be accessed by many threads simultaneously.

string locHistName, locHistTitle;

//Check if is REST event (high-level objects only)
bool locIsRESTEvent = locEventLoop->GetJEvent().GetStatusBit(kSTATUS_REST);

Run_Update(locEventLoop);

vector<const DMCThrown*> locMCThrowns;
locEventLoop->Get(locMCThrowns);

//CREATE THE HISTOGRAMS
//Since we are creating histograms, the contents of gDirectory will be modified: must use JANA-wide ROOT lock
japp->RootWriteLock(); //ACQUIRE ROOT LOCK!!
{
//Required: Create a folder in the ROOT output file that will contain all of the output ROOT objects (if any) for this action.
	//If another thread has already created the folder, it just changes to it.
CreateAndChangeTo_ActionDirectory();

//FCAL
locHistName = "FCALShowerYVsX";
dHist_FCALShowerYVsX = GetOrCreate_Histogram<TH2I>(locHistName, ";FCAL Shower X (cm);FCAL Shower Y (cm)", dNumFCALTOFXYBins, -130.0, 130.0, dNumFCALTOFXYBins, -130.0, 130.0);
locHistName = "FCALShowerEnergy";
dHist_FCALShowerEnergy = GetOrCreate_Histogram<TH1I>(locHistName, ";FCAL Shower Energy (GeV)", dNumShowerEnergyBins, dMinShowerEnergy, dMaxShowerEnergy);

//CCAL
locHistName = "CCALShowerYVsX";
dHist_CCALShowerYVsX = GetOrCreate_Histogram<TH2I>(locHistName, ";CCAL Shower X (cm);CCAL Shower Y (cm)", dNumFCALTOFXYBins, -130.0, 130.0, dNumFCALTOFXYBins, -130.0, 130.0);
locHistName = "CCALShowerEnergy";
dHist_CCALShowerEnergy = GetOrCreate_Histogram<TH1I>(locHistName, ";CCAL Shower Energy (GeV)", dNumShowerEnergyBins, dMinShowerEnergy, dMaxShowerEnergy);

//BCAL
locHistName = "BCALShowerEnergy";
dHist_BCALShowerEnergy = GetOrCreate_Histogram<TH1I>(locHistName, ";BCAL Shower Energy (GeV)", dNumShowerEnergyBins, dMinShowerEnergy, dMaxShowerEnergy);
locHistName = "BCALShowerPhi";
dHist_BCALShowerPhi = GetOrCreate_Histogram<TH1I>(locHistName, ";BCAL Shower #phi#circ", dNumPhiBins, dMinPhi, dMaxPhi);
locHistName = "BCALShowerPhiVsZ";
dHist_BCALShowerPhiVsZ = GetOrCreate_Histogram<TH2I>(locHistName, ";BCAL Shower Z (cm);BCAL Shower #phi#circ", dNum2DBCALZBins, 0.0, 450.0, dNum2DPhiBins, dMinPhi, dMaxPhi);

//TOF
locHistName = "TOFPointEnergy";
dHist_TOFPointEnergy = GetOrCreate_Histogram<TH1I>(locHistName, ";TOF Point Energy (MeV)", dNumHitEnergyBins, dMinHitEnergy, dMaxHitEnergy);
locHistName = "TOFPointEnergyP1";
dHist_TOFPointEnergyP1 = GetOrCreate_Histogram<TH1I>(locHistName, ";TOF Point Energy Plane 1 (MeV)", dNumHitEnergyBins, dMinHitEnergy, dMaxHitEnergy);
locHistName = "TOFPointEnergyP2";
dHist_TOFPointEnergyP2 = GetOrCreate_Histogram<TH1I>(locHistName, ";TOF Point Energy Plane 2 (MeV)", dNumHitEnergyBins, dMinHitEnergy, dMaxHitEnergy);
locHistName = "TOFPointYVsX";
dHist_TOFPointYVsX = GetOrCreate_Histogram<TH2I>(locHistName, ";TOF Point X (cm);TOF Point Y (cm)", dNumFCALTOFXYBins, -130.0, 130.0, dNumFCALTOFXYBins, -130.0, 130.0);

//SC
locHistName = "SCHitSector";
dHist_SCHitSector = GetOrCreate_Histogram<TH1I>(locHistName, ";SC Hit Sector", 30, 0.5, 30.5);
locHistName = "SCHitEnergy";
dHist_SCHitEnergy = GetOrCreate_Histogram<TH1I>(locHistName, ";SC Hit Energy (MeV)", dNumHitEnergyBins, dMinHitEnergy, dMaxHitEnergy);
locHistName = "SCHitEnergyVsSector";
dHist_SCHitEnergyVsSector = GetOrCreate_Histogram<TH2I>(locHistName, ";SC Hit Sector;SC Hit Energy (MeV)", 30, 0.5, 30.5, dNum2DHitEnergyBins, dMinHitEnergy, dMaxHitEnergy);
locHistName = "SCRFDeltaTVsSector";
dHist_SCRFDeltaTVsSector = GetOrCreate_Histogram<TH2I>(locHistName, ";SC Hit Sector;SC - RF #Deltat (ns)", 30, 0.5, 30.5, dNum2DDeltaTBins, dMinDeltaT, dMaxDeltaT);

//TAGH, TAGM
locHistName = "TAGMRFDeltaTVsColumn";
dHist_TAGMRFDeltaTVsColumn = GetOrCreate_Histogram<TH2I>(locHistName, ";TAGM Column;TAGM - RF #Deltat (ns)", 102, 0.5, 102.5, dNum2DDeltaTBins, dMinDeltaT, dMaxDeltaT);
locHistName = "TAGHRFDeltaTVsCounter";
dHist_TAGHRFDeltaTVsCounter = GetOrCreate_Histogram<TH2I>(locHistName, ";TAGH Counter;TAGH - RF #Deltat (ns)", 274, 0.5, 274.5, dNum2DDeltaTBins, dMinDeltaT, dMaxDeltaT);

//TRACKING
CreateAndChangeTo_Directory("Tracking", "Tracking");
locHistName = "NumDCHitsPerTrack";
dHist_NumDCHitsPerTrack = GetOrCreate_Histogram<TH1I>(locHistName, ";# Track Hits", 50, 0.5, 50.5);
locHistName = "NumPossDCHitsPerTrack";
dHist_NumPossDCHitsPerTrack = GetOrCreate_Histogram<TH1I>(locHistName, ";# Possible Track Hits", 50, 0.5, 50.5);
locHistName = "TrackHitFraction";
dHist_TrackHitFraction = GetOrCreate_Histogram<TH1I>(locHistName, ";# Track Hits/# Possible Track Hits", 50, 0.0, 1.0);
locHistName = "NumDCHitsPerTrackVsTheta";
dHist_NumDCHitsPerTrackVsTheta = GetOrCreate_Histogram<TH2I>(locHistName, ";#theta#circ;# Track Hits", dNum2DThetaBins, dMinTheta, dMaxTheta, 46, 4.5, 50.5);
locHistName = "NumPossDCHitsPerTrackVsTheta";
dHist_NumPossDCHitsPerTrackVsTheta = GetOrCreate_Histogram<TH2I>(locHistName, ";#theta#circ;# Possible Track Hits", dNum2DThetaBins, dMinTheta, dMaxTheta, 46, 4.5, 50.5);
locHistName = "TrackHitFractionVsTheta";
dHist_TrackHitFractionVsTheta = GetOrCreate_Histogram<TH2I>(locHistName, ";#theta#circ;# Track Hits/# Possible Track Hits", dNum2DThetaBins, dMinTheta, dMaxTheta, 50, 0.0, 1.0);
locHistName = "TrackingFOM_WireBased";
dHist_TrackingFOM_WireBased = GetOrCreate_Histogram<TH1I>(locHistName, ";Confidence Level", dNumFOMBins, 0.0, 1.0);
locHistName = "TrackingFOM";
dHist_TrackingFOM = GetOrCreate_Histogram<TH1I>(locHistName, ";Confidence Level", dNumFOMBins, 0.0, 1.0);
locHistName = "TrackingFOMVsP";
dHist_TrackingFOMVsP = GetOrCreate_Histogram<TH2I>(locHistName, ";p (GeV/c);Confidence Level", dNum2DPBins, dMinP, dMaxP, dNum2DFOMBins, 0.0, 1.0);
locHistName = "TrackingFOMVsTheta";
dHist_TrackingFOMVsTheta = GetOrCreate_Histogram<TH2I>(locHistName, ";#theta#circ;Confidence Level", dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DFOMBins, 0.0, 1.0);
locHistName = "TrackingFOMVsNumHits";
dHist_TrackingFOMVsNumHits = GetOrCreate_Histogram<TH2I>(locHistName, ";# Track Hits;Confidence Level", 46, 4.5, 50.5, dNum2DFOMBins, 0.0, 1.0);

if(!locIsRESTEvent)
{
	locHistName = "CDCRingVsTheta_Candidates";
	dHist_CDCRingVsTheta_Candidates = GetOrCreate_Histogram<TH2I>(locHistName, "Hits on Track Candidates;#theta#circ;CDC Ring", dNum2DThetaBins, dMinTheta, dMaxTheta, 28, 0.5, 28.5);
	locHistName = "CDCRingVsTheta_WireBased";
	dHist_CDCRingVsTheta_WireBased = GetOrCreate_Histogram<TH2I>(locHistName, "Hits on Wire-Based Tracks;#theta#circ;CDC Ring", dNum2DThetaBins, dMinTheta, dMaxTheta, 28, 0.5, 28.5);
}

locHistName = "CDCRingVsTheta_TimeBased";
dHist_CDCRingVsTheta_TimeBased = GetOrCreate_Histogram<TH2I>(locHistName, "Hits on Time-Based Tracks;#theta#circ;CDC Ring", dNum2DThetaBins, dMinTheta, dMaxTheta, 28, 0.5, 28.5);
locHistName = "CDCRingVsTheta_TimeBased_GoodTrackFOM";
dHist_CDCRingVsTheta_TimeBased_GoodTrackFOM = GetOrCreate_Histogram<TH2I>(locHistName, "Hits on Good FOM Time-Based Tracks;#theta#circ;CDC Ring", dNum2DThetaBins, dMinTheta, dMaxTheta, 28, 0.5, 28.5);

if(!locIsRESTEvent)
{
	locHistName = "FDCPlaneVsTheta_Candidates";
	dHist_FDCPlaneVsTheta_Candidates = GetOrCreate_Histogram<TH2I>(locHistName, "Hits on Track Candidates;p (GeV/c);FDC Plane", dNum2DThetaBins, dMinTheta, dMaxTheta, 24, 0.5, 24.5);
	locHistName = "FDCPlaneVsTheta_WireBased";
	dHist_FDCPlaneVsTheta_WireBased = GetOrCreate_Histogram<TH2I>(locHistName, "Hits on Wire-Based Tracks;p (GeV/c);FDC Plane", dNum2DThetaBins, dMinTheta, dMaxTheta, 24, 0.5, 24.5);
}

locHistName = "FDCPlaneVsTheta_TimeBased";
dHist_FDCPlaneVsTheta_TimeBased = GetOrCreate_Histogram<TH2I>(locHistName, "Hits on Time-Based Tracks;p (GeV/c);FDC Plane", dNum2DThetaBins, dMinTheta, dMaxTheta, 24, 0.5, 24.5);
locHistName = "FDCPlaneVsTheta_TimeBased_GoodTrackFOM";
dHist_FDCPlaneVsTheta_TimeBased_GoodTrackFOM = GetOrCreate_Histogram<TH2I>(locHistName, "Hits on Good FOM Time-Based Tracks;p (GeV/c);FDC Plane", dNum2DThetaBins, dMinTheta, dMaxTheta, 24, 0.5, 24.5);

if(!locMCThrowns.empty())
{
	locHistName = "MCMatchedHitsVsTheta";
	dHist_MCMatchedHitsVsTheta = GetOrCreate_Histogram<TH2I>(locHistName, "Fraction of Track Hits Matched to MC;#theta#circ;", dNum2DThetaBins, dMinTheta, dMaxTheta, 100, 0.0, 1.0);
	locHistName = "MCMatchedHitsVsP";
	dHist_MCMatchedHitsVsP = GetOrCreate_Histogram<TH2I>(locHistName, "Fraction of Track Hits Matched to MC;p (GeV/c);", dNum2DPBins, dMinP, dMaxP, 100, 0.0, 1.0);
}

for(int locCharge = -1; locCharge <= 1; locCharge += 2)
{
	string locParticleROOTName = (locCharge == -1) ? "#it{q}^{-}" : "#it{q}^{+}";
	string locParticleName = (locCharge == -1) ? "q-" : "q+";
	CreateAndChangeTo_Directory(locParticleName, locParticleName);

	if(!locIsRESTEvent)
	{
		// PVsTheta Track Candidates
		locHistName = string("PVsTheta_Candidates_") + locParticleName;
		locHistTitle = locParticleROOTName + string(" Track Candidates;#theta#circ;p (GeV/c)");
		dHistMap_PVsTheta_Candidates[locCharge] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DPBins, dMinP, dMaxP);

		// PVsTheta Wire-Based Tracks
		locHistName = string("PVsTheta_WireBased_") + locParticleName;
		locHistTitle = locParticleROOTName + string(" Wire-Based Tracks;#theta#circ;p (GeV/c)");
		dHistMap_PVsTheta_WireBased[locCharge] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DPBins, dMinP, dMaxP);
	}

	// PVsTheta Time-Based Tracks
	locHistName = string("PVsTheta_TimeBased_") + locParticleName;
	locHistTitle = locParticleROOTName + string(" Time-Based Tracks;#theta#circ;p (GeV/c)");
	dHistMap_PVsTheta_TimeBased[locCharge] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DPBins, dMinP, dMaxP);

	// PVsTheta Time-Based Tracks Good Track FOM
	locHistName = string("PVsTheta_TimeBased_GoodTrackFOM_") + locParticleName;
	locHistTitle = locParticleROOTName + string(" Time-Based Tracks, Good Tracking FOM;#theta#circ;p (GeV/c)");
	dHistMap_PVsTheta_TimeBased_GoodTrackFOM[locCharge] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DPBins, dMinP, dMaxP);

	// PVsTheta Time-Based Tracks Low Track FOM
	locHistName = string("PVsTheta_TimeBased_LowTrackFOM_") + locParticleName;
	locHistTitle = locParticleROOTName + string(" Time-Based Tracks, Low Tracking FOM;#theta#circ;p (GeV/c)");
	dHistMap_PVsTheta_TimeBased_LowTrackFOM[locCharge] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DPBins, dMinP, dMaxP);

	// PVsTheta Time-Based Tracks High Track FOM
	locHistName = string("PVsTheta_TimeBased_HighTrackFOM_") + locParticleName;
	locHistTitle = locParticleROOTName + string(" Time-Based Tracks, High Tracking FOM;#theta#circ;p (GeV/c)");
	dHistMap_PVsTheta_TimeBased_HighTrackFOM[locCharge] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DPBins, dMinP, dMaxP);

	if(!locIsRESTEvent)
	{
		// PVsTheta: Good Wire-Based, Good Time-Based
		locHistName = string("PVsTheta_GoodWireBased_GoodTimeBased_") + locParticleName;
		locHistTitle = locParticleROOTName + string(" Good Wire-Based, Good Time-Based;#theta#circ;p (GeV/c)");
		dHistMap_PVsTheta_GoodWireBased_GoodTimeBased[locCharge] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DPBins, dMinP, dMaxP);

		// PVsTheta: Good Wire-Based, Bad Time-Based
		locHistName = string("PVsTheta_GoodWireBased_BadTimeBased_") + locParticleName;
		locHistTitle = locParticleROOTName + string(" Good Wire-Based, Bad Time-Based;#theta#circ;p (GeV/c)");
		dHistMap_PVsTheta_GoodWireBased_BadTimeBased[locCharge] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DPBins, dMinP, dMaxP);
	}

	gDirectory(TDirectory::CurrentDirectory())->cd(".."); //end of charge
}
gDirectory(TDirectory::CurrentDirectory())->cd(".."); //End of "Tracking"

//Return to the base directory
ChangeTo_BaseDirectory();
}
japp->RootUnLock(); //RELEASE ROOT LOCK!!
490}

492void DHistogramAction_Reconstruction::Run_Update(JEventLoop* locEventLoop)
493{
DApplication* locApplication = dynamic_cast<DApplication*>(locEventLoop->GetJApplication());
DGeometry* locGeometry = locApplication->GetDGeometry(locEventLoop->GetJEvent().GetRunNumber());
double locTargetZCenter = 0.0;
locGeometry->GetTargetZ(locTargetZCenter);

if(dTargetCenter.Z() < -9.8E9)
dTargetCenter.SetXYZ(0.0, 0.0, locTargetZCenter);
501}

503bool DHistogramAction_Reconstruction::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
504{
//Expect locParticleCombo to be NULL since this is a reaction-independent action.

if(Get_CalledPriorWithComboFlag())
return true; //else double-counting!

bool locIsRESTEvent = locEventLoop->GetJEvent().GetStatusBit(kSTATUS_REST);

vector<const DBCALShower*> locBCALShowers;
locEventLoop->Get(locBCALShowers);

vector<const DFCALShower*> locFCALShowers;
locEventLoop->Get(locFCALShowers);

vector<const DCCALShower*> locCCALShowers;
locEventLoop->Get(locCCALShowers);

vector<const DTOFPoint*> locTOFPoints;
locEventLoop->Get(locTOFPoints);

vector<const DSCHit*> locSCHits;
locEventLoop->Get(locSCHits);

vector<const DBeamPhoton*> locBeamPhotons;
locEventLoop->Get(locBeamPhotons);

const DDetectorMatches* locDetectorMatches = NULL__null;
locEventLoop->GetSingle(locDetectorMatches);

vector<const DTrackTimeBased*> locTrackTimeBasedVector;
locEventLoop->Get(locTrackTimeBasedVector);

vector<const DMCThrownMatching*> locMCThrownMatchingVector;
locEventLoop->Get(locMCThrownMatchingVector);

vector<const DMCThrown*> locMCThrowns;
locEventLoop->Get(locMCThrowns, "FinalState");

const DParticleID* locParticleID = NULL__null;
locEventLoop->GetSingle(locParticleID);

const DEventRFBunch* locEventRFBunch = NULL__null;
locEventLoop->GetSingle(locEventRFBunch);

const DDetectorMatches* locDetectorMatches_WireBased = NULL__null;
vector<const DTrackCandidate*> locTrackCandidates;
vector<const DTrackWireBased*> locTrackWireBasedVector;
if(!locIsRESTEvent)
{
vector<const DDetectorMatches*> locDetectorMatchesVector_WireBased;
locEventLoop->Get(locDetectorMatchesVector_WireBased, "WireBased");
if(!locDetectorMatchesVector_WireBased.empty())
	locDetectorMatches_WireBased = locDetectorMatchesVector_WireBased[0];
locEventLoop->Get(locTrackCandidates);
locEventLoop->Get(locTrackWireBasedVector);
}

//select the best DTrackWireBased for each track: use best tracking FOM
map<JObject::oid_t, const DTrackWireBased*> locBestTrackWireBasedMap; //lowest tracking FOM for each candidate id
for(size_t loc_i = 0; loc_i < locTrackWireBasedVector.size(); ++loc_i)
{
JObject::oid_t locCandidateID = locTrackWireBasedVector[loc_i]->candidateid;
if(locBestTrackWireBasedMap.find(locCandidateID) == locBestTrackWireBasedMap.end())
	locBestTrackWireBasedMap[locCandidateID] = locTrackWireBasedVector[loc_i];
else if(locTrackWireBasedVector[loc_i]->FOM > locBestTrackWireBasedMap[locCandidateID]->FOM)
	locBestTrackWireBasedMap[locCandidateID] = locTrackWireBasedVector[loc_i];
}

//select the best DTrackTimeBased for each track: use best tracking FOM
//also, make map from WBT -> TBT (if not rest)
//also, select best sc matches for each track
map<JObject::oid_t, const DTrackTimeBased*> locBestTrackTimeBasedMap; //lowest tracking FOM for each candidate id
map<const DTrackWireBased*, const DTrackTimeBased*> locWireToTimeBasedTrackMap;
map<const DTrackTimeBased*, shared_ptr<const DSCHitMatchParams>> locTimeBasedToBestSCMatchMap;
for(size_t loc_i = 0; loc_i < locTrackTimeBasedVector.size(); ++loc_i)
{
//Best SC Match Params
shared_ptr<const DSCHitMatchParams> locSCHitMatchParams;
if(locParticleID->Get_BestSCMatchParams(locTrackTimeBasedVector[loc_i], locDetectorMatches, locSCHitMatchParams))
	locTimeBasedToBestSCMatchMap[locTrackTimeBasedVector[loc_i]] = locSCHitMatchParams;

JObject::oid_t locCandidateID = locTrackTimeBasedVector[loc_i]->candidateid;
if(locBestTrackTimeBasedMap.find(locCandidateID) == locBestTrackTimeBasedMap.end())
	locBestTrackTimeBasedMap[locCandidateID] = locTrackTimeBasedVector[loc_i];
else if(locTrackTimeBasedVector[loc_i]->FOM > locBestTrackTimeBasedMap[locCandidateID]->FOM)
	locBestTrackTimeBasedMap[locCandidateID] = locTrackTimeBasedVector[loc_i];
if(locIsRESTEvent)
	continue;
const DTrackWireBased* locTrackWireBased = NULL__null;
locTrackTimeBasedVector[loc_i]->GetSingle(locTrackWireBased);
locWireToTimeBasedTrackMap[locTrackWireBased] = locTrackTimeBasedVector[loc_i];
}

//FILL HISTOGRAMS
//Since we are filling histograms local to this action, it will not interfere with other ROOT operations: can use action-wide ROOT lock
//Note, the mutex is unique to this DReaction + action_string combo: actions of same class with different hists will have a different mutex
Lock_Action(); //ACQUIRE ROOT LOCK!!
{
       //FCAL
for(size_t loc_i = 0; loc_i < locFCALShowers.size(); ++loc_i)
{
	dHist_FCALShowerEnergy->Fill(locFCALShowers[loc_i]->getEnergy());
	dHist_FCALShowerYVsX->Fill(locFCALShowers[loc_i]->getPosition().X(), locFCALShowers[loc_i]->getPosition().Y());
}

//CCAL
for(size_t loc_i = 0; loc_i < locCCALShowers.size(); ++loc_i)
{
        dHist_CCALShowerEnergy->Fill(locCCALShowers[loc_i]->E);
	dHist_CCALShowerYVsX->Fill(locCCALShowers[loc_i]->x, locCCALShowers[loc_i]->y);
}

//BCAL
for(size_t loc_i = 0; loc_i < locBCALShowers.size(); ++loc_i)
{
	dHist_BCALShowerEnergy->Fill(locBCALShowers[loc_i]->E);

	DVector3 locBCALPosition(locBCALShowers[loc_i]->x, locBCALShowers[loc_i]->y, locBCALShowers[loc_i]->z);
	double locBCALPhi = locBCALPosition.Phi()*180.0/TMath::Pi();
	dHist_BCALShowerPhi->Fill(locBCALPhi);
	dHist_BCALShowerPhiVsZ->Fill(locBCALPosition.Z(), locBCALPhi);
}

//TOF
for(size_t loc_i = 0; loc_i < locTOFPoints.size(); ++loc_i)
{
	dHist_TOFPointEnergy->Fill(locTOFPoints[loc_i]->dE*1.0E3);
	dHist_TOFPointEnergyP1->Fill(locTOFPoints[loc_i]->dE1*1.0E3);
	dHist_TOFPointEnergyP2->Fill(locTOFPoints[loc_i]->dE2*1.0E3);
	dHist_TOFPointYVsX->Fill(locTOFPoints[loc_i]->pos.X(), locTOFPoints[loc_i]->pos.Y());
}

//SC
for(size_t loc_i = 0; loc_i < locSCHits.size(); ++loc_i)
{
	dHist_SCHitSector->Fill(locSCHits[loc_i]->sector);
	dHist_SCHitEnergy->Fill(locSCHits[loc_i]->dE*1.0E3);
	dHist_SCHitEnergyVsSector->Fill(locSCHits[loc_i]->sector, locSCHits[loc_i]->dE*1.0E3);
}

//TAGM, TAGH
for(size_t loc_i = 0; loc_i < locBeamPhotons.size(); ++loc_i)
{
	double locDeltaT = locBeamPhotons[loc_i]->time() - locEventRFBunch->dTime;
	if(locBeamPhotons[loc_i]->dSystem == SYS_TAGM)
		dHist_TAGMRFDeltaTVsColumn->Fill(locBeamPhotons[loc_i]->dCounter, locDeltaT);
	else
		dHist_TAGHRFDeltaTVsCounter->Fill(locBeamPhotons[loc_i]->dCounter, locDeltaT);
}

//TRACK CANDIDATES
for(size_t loc_i = 0; loc_i < locTrackCandidates.size(); ++loc_i)
{
	int locCharge = (locTrackCandidates[loc_i]->charge() > 0.0) ? 1 : -1;
	double locTheta = locTrackCandidates[loc_i]->momentum().Theta()*180.0/TMath::Pi();
	double locP = locTrackCandidates[loc_i]->momentum().Mag();
	dHistMap_PVsTheta_Candidates[locCharge]->Fill(locTheta, locP);

	set<int> locCDCRings;
	locParticleID->Get_CDCRings(locTrackCandidates[loc_i]->dCDCRings, locCDCRings);
	for(set<int>::iterator locIterator = locCDCRings.begin(); locIterator != locCDCRings.end(); ++locIterator)
		dHist_CDCRingVsTheta_Candidates->Fill(locTheta, *locIterator);

	set<int> locFDCPlanes;
	locParticleID->Get_FDCPlanes(locTrackCandidates[loc_i]->dFDCPlanes, locFDCPlanes);
	for(set<int>::iterator locIterator = locFDCPlanes.begin(); locIterator != locFDCPlanes.end(); ++locIterator)
		dHist_FDCPlaneVsTheta_Candidates->Fill(locTheta, *locIterator);
}

//WIRE-BASED TRACKS
map<JObject::oid_t, const DTrackWireBased*>::iterator locWireBasedIterator = locBestTrackWireBasedMap.begin();
for(; locWireBasedIterator != locBestTrackWireBasedMap.end(); ++locWireBasedIterator)
{
	const DTrackWireBased* locTrackWireBased = locWireBasedIterator->second;
	int locCharge = (locTrackWireBased->charge() > 0.0) ? 1 : -1;
	double locTheta = locTrackWireBased->momentum().Theta()*180.0/TMath::Pi();
	double locP = locTrackWireBased->momentum().Mag();
	dHistMap_PVsTheta_WireBased[locCharge]->Fill(locTheta, locP);

	set<int> locCDCRings;
	locParticleID->Get_CDCRings(locTrackWireBased->dCDCRings, locCDCRings);
	for(set<int>::iterator locIterator = locCDCRings.begin(); locIterator != locCDCRings.end(); ++locIterator)
		dHist_CDCRingVsTheta_WireBased->Fill(locTheta, *locIterator);

	set<int> locFDCPlanes;
	locParticleID->Get_FDCPlanes(locTrackWireBased->dFDCPlanes, locFDCPlanes);
	for(set<int>::iterator locIterator = locFDCPlanes.begin(); locIterator != locFDCPlanes.end(); ++locIterator)
		dHist_FDCPlaneVsTheta_WireBased->Fill(locTheta, *locIterator);

	dHist_TrackingFOM_WireBased->Fill(locTrackWireBased->FOM);
}

//TIME-BASED TRACKS
map<JObject::oid_t, const DTrackTimeBased*>::iterator locTimeBasedIterator = locBestTrackTimeBasedMap.begin();
for(; locTimeBasedIterator != locBestTrackTimeBasedMap.end(); ++locTimeBasedIterator)
{
	const DTrackTimeBased* locTrackTimeBased = locTimeBasedIterator->second;
	int locCharge = (locTrackTimeBased->charge() > 0.0) ? 1 : -1;
	double locTheta = locTrackTimeBased->momentum().Theta()*180.0/TMath::Pi();
	double locP = locTrackTimeBased->momentum().Mag();
	int locPossibleHits = locTrackTimeBased->potential_cdc_hits_on_track + locTrackTimeBased->potential_fdc_hits_on_track;
	double locTrackHitFraction = (locTrackTimeBased->Ndof + 5)/(double)locPossibleHits;

	dHistMap_PVsTheta_TimeBased[locCharge]->Fill(locTheta, locP);
	dHist_NumDCHitsPerTrack->Fill(locTrackTimeBased->Ndof + 5);
	dHist_NumPossDCHitsPerTrack->Fill(locPossibleHits);
	dHist_TrackHitFraction->Fill(locTrackHitFraction);
	dHist_NumDCHitsPerTrackVsTheta->Fill(locTheta, locTrackTimeBased->Ndof + 5);
	dHist_NumPossDCHitsPerTrackVsTheta->Fill(locTheta, locPossibleHits);
	dHist_TrackHitFractionVsTheta->Fill(locTheta, locTrackHitFraction);
	
	dHist_TrackingFOM->Fill(locTrackTimeBased->FOM);
	dHist_TrackingFOMVsTheta->Fill(locTheta, locTrackTimeBased->FOM);
	dHist_TrackingFOMVsP->Fill(locP, locTrackTimeBased->FOM);
	dHist_TrackingFOMVsNumHits->Fill(locTrackTimeBased->Ndof + 5, locTrackTimeBased->FOM);

	//CDC
	set<int> locCDCRings;
	locParticleID->Get_CDCRings(locTrackTimeBased->dCDCRings, locCDCRings);
	for(set<int>::iterator locIterator = locCDCRings.begin(); locIterator != locCDCRings.end(); ++locIterator)
	{
		dHist_CDCRingVsTheta_TimeBased->Fill(locTheta, *locIterator);
		if(locTrackTimeBased->FOM > dGoodTrackFOM)
			dHist_CDCRingVsTheta_TimeBased_GoodTrackFOM->Fill(locTheta, *locIterator);
	}
	
	//FDC
	set<int> locFDCPlanes;
	locParticleID->Get_FDCPlanes(locTrackTimeBased->dFDCPlanes, locFDCPlanes);
	for(set<int>::iterator locIterator = locFDCPlanes.begin(); locIterator != locFDCPlanes.end(); ++locIterator)
	{
		dHist_FDCPlaneVsTheta_TimeBased->Fill(locTheta, *locIterator);
		if(locTrackTimeBased->FOM > dGoodTrackFOM)
			dHist_FDCPlaneVsTheta_TimeBased_GoodTrackFOM->Fill(locTheta, *locIterator);
	}

	//FOM
	if(locTrackTimeBased->FOM > dGoodTrackFOM)
		dHistMap_PVsTheta_TimeBased_GoodTrackFOM[locCharge]->Fill(locTheta, locP);
	else
		dHistMap_PVsTheta_TimeBased_LowTrackFOM[locCharge]->Fill(locTheta, locP);
	if(locTrackTimeBased->FOM > dHighTrackFOM)
		dHistMap_PVsTheta_TimeBased_HighTrackFOM[locCharge]->Fill(locTheta, locP);

	//SC/RF DELTA-T
	auto locSCIterator = locTimeBasedToBestSCMatchMap.find(locTrackTimeBased);
	if(locSCIterator != locTimeBasedToBestSCMatchMap.end())
	{
		auto& locSCHitMatchParams = locSCIterator->second;
		double locPropagatedSCTime = locSCHitMatchParams->dHitTime - locSCHitMatchParams->dFlightTime + (dTargetCenter.Z() - locTrackTimeBased->z())/29.9792458;
		double locDeltaT = locPropagatedSCTime - locEventRFBunch->dTime;
		dHist_SCRFDeltaTVsSector->Fill(locSCHitMatchParams->dSCHit->sector, locDeltaT);
	}
}

// If "Good" WBT, see if TBT is good
locWireBasedIterator = locBestTrackWireBasedMap.begin();
for(; locWireBasedIterator != locBestTrackWireBasedMap.end(); ++locWireBasedIterator)
{
	if(locDetectorMatches_WireBased == NULL__null)
		continue;
	const DTrackWireBased* locTrackWireBased = locWireBasedIterator->second;
	if(locTrackWireBased->FOM < dGoodTrackFOM)
		continue; //no good
	if(!locDetectorMatches_WireBased->Get_IsMatchedToHit(locTrackWireBased))
		continue; //no good

	int locCharge = (locTrackWireBased->charge() > 0.0) ? 1 : -1;
	double locTheta = locTrackWireBased->momentum().Theta()*180.0/TMath::Pi();
	double locP = locTrackWireBased->momentum().Mag();

	map<const DTrackWireBased*, const DTrackTimeBased*>::iterator locReconIterator = locWireToTimeBasedTrackMap.find(locTrackWireBased);
	if(locReconIterator == locWireToTimeBasedTrackMap.end())
	{
		dHistMap_PVsTheta_GoodWireBased_BadTimeBased[locCharge]->Fill(locTheta, locP);
		continue; //no time-based
	}

	const DTrackTimeBased* locTrackTimeBased = locReconIterator->second;
	if((locTrackTimeBased->FOM < dGoodTrackFOM) || (!locDetectorMatches->Get_IsMatchedToHit(locTrackTimeBased)))
		dHistMap_PVsTheta_GoodWireBased_BadTimeBased[locCharge]->Fill(locTheta, locP);
	else
		dHistMap_PVsTheta_GoodWireBased_GoodTimeBased[locCharge]->Fill(locTheta, locP);
}

//THROWN
for(size_t loc_i = 0; loc_i < locMCThrowns.size(); ++loc_i)
{
	if(fabs(locMCThrowns[loc_i]->charge()) < 0.9)
		continue;

	double locMatchFOM;
	const DChargedTrackHypothesis* locChargedTrackHypothesis = locMCThrownMatchingVector[0]->Get_MatchingChargedHypothesis(locMCThrowns[loc_i], locMatchFOM);
	if(locChargedTrackHypothesis == NULL__null)
		continue;

	auto locTrackTimeBased = locChargedTrackHypothesis->Get_TrackTimeBased();
	double locHitFraction = 1.0*locTrackTimeBased->dNumHitsMatchedToThrown/(locTrackTimeBased->Ndof + 5);
	dHist_MCMatchedHitsVsTheta->Fill(locTrackTimeBased->momentum().Theta()*180.0/TMath::Pi(), locHitFraction);
	dHist_MCMatchedHitsVsP->Fill(locTrackTimeBased->momentum().Mag(), locHitFraction);
}
}
Unlock_Action(); //RELEASE ROOT LOCK!!

return true; //return false if you want to use this action to apply a cut (and it fails the cut!)
809}

811void DHistogramAction_DetectorMatching::Initialize(JEventLoop* locEventLoop)
812{
//Create any histograms/trees/etc. within a ROOT lock. 
//This is so that when running multithreaded, only one thread is writing to the ROOT file at a time. 

//When creating a reaction-independent action, only modify member variables within a ROOT lock. 
//Objects created within a plugin (such as reaction-independent actions) can be accessed by many threads simultaneously. 
string locHistName, locHistTitle;

bool locIsRESTEvent = locEventLoop->GetJEvent().GetStatusBit(kSTATUS_REST);

Run_Update(locEventLoop);

//CREATE THE HISTOGRAMS
//Since we are creating histograms, the contents of gDirectory will be modified: must use JANA-wide ROOT lock
japp->RootWriteLock(); //ACQUIRE ROOT LOCK!!
{

//Required: Create a folder in the ROOT output file that will contain all of the output ROOT objects (if any) for this action.
	//If another thread has already created the folder, it just changes to it. 
CreateAndChangeTo_ActionDirectory();

//Loop over filling for time-based and wire-based tracks
for(unsigned int locDummy = 0; locDummy < 2; ++locDummy)
{
	bool locIsTimeBased = (locDummy == 0);
	if(locIsRESTEvent && (!locIsTimeBased))
		continue;

	string locDirectoryName = locIsTimeBased ? "TimeBased" : "WireBased";
	CreateAndChangeTo_Directory(locDirectoryName.c_str(), locDirectoryName.c_str());
	string locTrackString = locIsTimeBased ? "Time-Based Tracks" : "Wire-Based Tracks";

	//Kinematics of has (no) hit
	vector<DetectorSystem_t> locDetectorSystems;
	locDetectorSystems.push_back(SYS_START);  locDetectorSystems.push_back(SYS_BCAL);
	locDetectorSystems.push_back(SYS_TOF);  locDetectorSystems.push_back(SYS_FCAL);
	//locDetectorSystems.push_back(SYS_CCAL);
	for(size_t loc_i = 0; loc_i < locDetectorSystems.size(); ++loc_i)
	{
		DetectorSystem_t locSystem = locDetectorSystems[loc_i];

		double locMaxTheta = ((locSystem == SYS_FCAL) || (locSystem == SYS_TOF) /*|| (locSystem == SYS_CCAL)*/) ? 12.0 : dMaxTheta;
		double locMaxP = (locSystem == SYS_BCAL) ? 3.0 : dMaxP;

		string locSystemName = SystemName(locSystem);
		if(locSystemName == "ST")
			locSystemName = "SC";
		string locDirName = locSystemName;
		if(locSystemName == "TOF")
			locDirName = "TOFPoint";

		CreateAndChangeTo_Directory(locDirName, locDirName);

		// PVsTheta Has Hit
		locHistName = "PVsTheta_HasHit";
		locHistTitle = locTrackString + string(", Has Other Match, ") + locSystemName + string(" Has Hit;#theta#circ;p (GeV/c)");
		dHistMap_PVsTheta_HasHit[locSystem][locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, locMaxTheta, dNum2DPBins, dMinP, locMaxP);

		// PVsTheta Has No Hit
		locHistName = "PVsTheta_NoHit";
		locHistTitle = locTrackString + string(", Has Other Match, ") + locSystemName + string(" No Hit;#theta#circ;p (GeV/c)");
		dHistMap_PVsTheta_NoHit[locSystem][locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, locMaxTheta, dNum2DPBins, dMinP, locMaxP);

		// PhiVsTheta Has Hit
		locHistName = "PhiVsTheta_HasHit";
		locHistTitle = locTrackString + string(", Has Other Match, ") + locSystemName + string(" Has Hit;#theta#circ;#phi#circ");
		dHistMap_PhiVsTheta_HasHit[locSystem][locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, locMaxTheta, dNum2DPhiBins, dMinPhi, dMaxPhi);

		// PhiVsTheta Has No Hit
		locHistName = "PhiVsTheta_NoHit";
		locHistTitle = locTrackString + string(", Has Other Match, ") + locSystemName + string(" No Hit;#theta#circ;#phi#circ");
		dHistMap_PhiVsTheta_NoHit[locSystem][locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, locMaxTheta, dNum2DPhiBins, dMinPhi, dMaxPhi);

		gDirectory(TDirectory::CurrentDirectory())->cd("..");
	}

	//SC
	CreateAndChangeTo_Directory("SC", "SC");
	locHistName = "SCPaddleVsTheta_HasHit";
	locHistTitle = locTrackString + string(", Has Other Match, SC Has Hit;#theta#circ;Projected SC Paddle");
	dHistMap_SCPaddleVsTheta_HasHit[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, 30, 0.5, 30.5);

	locHistName = "SCPaddleVsTheta_NoHit";
	locHistTitle = locTrackString + string(", Has Other Match, SC No Hit;#theta#circ;Projected SC Paddle");
	dHistMap_SCPaddleVsTheta_NoHit[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, 30, 0.5, 30.5);

	locHistName = "SCPaddleVsZ_HasHit";
	locHistTitle = locTrackString + string(", Has Other Match, SC Has Hit;Projected SC Hit-Z (cm);Projected SC Paddle");
	dHistMap_SCPaddleVsZ_HasHit[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DSCZBins, 0.0, 120.0, 30, 0.5, 30.5);

	locHistName = "SCPaddleVsZ_NoHit";
	locHistTitle = locTrackString + string(", Has Other Match, SC No Hit;Projected SC Hit-Z (cm);Projected SC Paddle");
	dHistMap_SCPaddleVsZ_NoHit[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DSCZBins, 0.0, 120.0, 30, 0.5, 30.5);

	locHistName = "SCPaddle_BarrelRegion_HasHit";
	locHistTitle = locTrackString + string(", Has Other Match, SC Barrel Region Has Hit;Projected SC Paddle");
	dHistMap_SCPaddle_BarrelRegion_HasHit[locIsTimeBased] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, 30, 0.5, 30.5);

	locHistName = "SCPaddle_BarrelRegion_NoHit";
	locHistTitle = locTrackString + string(", Has Other Match, SC Barrel Region No Hit;Projected SC Paddle");
	dHistMap_SCPaddle_BarrelRegion_NoHit[locIsTimeBased] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, 30, 0.5, 30.5);

	locHistName = "SCPaddle_NoseRegion_HasHit";
	locHistTitle = locTrackString + string(", Has Other Match, SC Front Region Has Hit;Projected SC Paddle");
	dHistMap_SCPaddle_NoseRegion_HasHit[locIsTimeBased] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, 30, 0.5, 30.5);

	locHistName = "SCPaddle_NoseRegion_NoHit";
	locHistTitle = locTrackString + string(", Has Other Match, SC Front Region No Hit;Projected SC Paddle");
	dHistMap_SCPaddle_NoseRegion_NoHit[locIsTimeBased] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, 30, 0.5, 30.5);

	locHistName = "SCTrackDeltaPhiVsP";
	locHistTitle = locTrackString + string(";p (GeV/c);SC / Track #Delta#phi#circ");
	dHistMap_SCTrackDeltaPhiVsP[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DDeltaPhiBins, dSCMatchMinDeltaPhi, dSCMatchMaxDeltaPhi);

	locHistName = "SCTrackDeltaPhiVsTheta";
	locHistTitle = locTrackString + string(";#theta#circ;SC / Track #Delta#phi#circ");
	dHistMap_SCTrackDeltaPhiVsTheta[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DDeltaPhiBins, dSCMatchMinDeltaPhi, dSCMatchMaxDeltaPhi);

	locHistName = "SCTrackDeltaPhiVsZ";
	locHistTitle = locTrackString + string(";Projected SC Hit-Z (cm);SC / Track #Delta#phi#circ");
	dHistMap_SCTrackDeltaPhiVsZ[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DSCZBins, 0.0, 120.0, dNum2DDeltaPhiBins, dSCMatchMinDeltaPhi, dSCMatchMaxDeltaPhi);
	gDirectory(TDirectory::CurrentDirectory())->cd("..");

	//TOFPaddle
	CreateAndChangeTo_Directory("TOFPaddle", "TOFPaddle");
	locHistName = "VerticalPaddleTrackDeltaX";
	locHistTitle = locTrackString + string(";Vertical TOF Paddle / Track |#DeltaX| (cm)");
	dHistMap_TOFPaddleTrackDeltaX[locIsTimeBased] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumTrackDOCABins/2, 0.0, dMaxTrackMatchDOCA);

	locHistName = "HorizontalPaddleTrackDeltaY";
	locHistTitle = locTrackString + string(";Horizontal TOF Paddle / Track |#DeltaY| (cm)");
	dHistMap_TOFPaddleTrackDeltaY[locIsTimeBased] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumTrackDOCABins/2, 0.0, dMaxTrackMatchDOCA);

	locHistName = "TrackYVsVerticalPaddle_HasHit";
	locHistTitle = locTrackString + string(", Has Other Match, TOF Paddle Has Hit;Projected Vertical Paddle;Projected TOF Hit Y (cm)");
	dHistMap_TOFPaddleTrackYVsVerticalPaddle_HasHit[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, 46, 0.5, 46.5, dNumFCALTOFXYBins, -130.0, 130.0);

	locHistName = "TrackYVsVerticalPaddle_NoHit";
	locHistTitle = locTrackString + string(", Has Other Match, TOF Paddle No Hit;Projected Vertical Paddle;Projected TOF Hit Y (cm)");
	dHistMap_TOFPaddleTrackYVsVerticalPaddle_NoHit[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, 46, 0.5, 46.5, dNumFCALTOFXYBins, -130.0, 130.0);

	locHistName = "HorizontalPaddleVsTrackX_HasHit";
	locHistTitle = locTrackString + string(", Has Other Match, TOF Paddle Has Hit;Projected TOF Hit X (cm);Projected Horizontal Paddle");
	dHistMap_TOFPaddleHorizontalPaddleVsTrackX_HasHit[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNumFCALTOFXYBins, -130.0, 130.0, 46, 0.5, 46.5);

	locHistName = "HorizontalPaddleVsTrackX_NoHit";
	locHistTitle = locTrackString + string(", Has Other Match, TOF Paddle No Hit;Projected TOF Hit X (cm);Projected Horizontal Paddle");
	dHistMap_TOFPaddleHorizontalPaddleVsTrackX_NoHit[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNumFCALTOFXYBins, -130.0, 130.0, 46, 0.5, 46.5);
	gDirectory(TDirectory::CurrentDirectory())->cd("..");

	//TOFPoint
	CreateAndChangeTo_Directory("TOFPoint", "TOFPoint");
	locHistName = "TrackTOFYVsX_HasHit";
	locHistTitle = locTrackString + string(", Has Other Match, TOF Has Hit;Projected TOF Hit X (cm);Projected TOF Hit Y (cm)");
	dHistMap_TrackTOFYVsX_HasHit[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNumFCALTOFXYBins, -130.0, 130.0, dNumFCALTOFXYBins, -130.0, 130.0);

	locHistName = "TrackTOFYVsX_NoHit";
	locHistTitle = locTrackString + string(", Has Other Match, TOF No Hit;Projected TOF Hit X (cm);Projected TOF Hit Y (cm)");
	dHistMap_TrackTOFYVsX_NoHit[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNumFCALTOFXYBins, -130.0, 130.0, dNumFCALTOFXYBins, -130.0, 130.0);

	locHistName = "TrackTOF2DPaddles_HasHit";
	locHistTitle = locTrackString + string(", Has Other Match, TOF Has Hit;Projected Vertical TOF Paddle;Projected Horizontal TOF Paddle");
	dHistMap_TrackTOF2DPaddles_HasHit[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, 46, 0.5, 46.5, 46, 0.5, 46.5);

	locHistName = "TrackTOF2DPaddles_NoHit";
	locHistTitle = locTrackString + string(", Has Other Match, TOF No Hit;Projected Vertical TOF Paddle;Projected Horizontal TOF Paddle");
	dHistMap_TrackTOF2DPaddles_NoHit[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, 46, 0.5, 46.5, 46, 0.5, 46.5);

	locHistName = "TrackTOFP_HasHit";
	locHistTitle = locTrackString + string(", Has Other Match, TOF Has Hit;p (GeV/c)");
	dHistMap_TrackTOFP_HasHit[locIsTimeBased] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumPBins, dMinP, dMaxP);

	locHistName = "TrackTOFP_NoHit";
	locHistTitle = locTrackString + string(", Has Other Match, TOF No Hit;p (GeV/c)");
	dHistMap_TrackTOFP_NoHit[locIsTimeBased] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumPBins, dMinP, dMaxP);

	locHistName = "TrackTOFR_HasHit";
	locHistTitle = locTrackString + string(", Has Other Match, TOF Has Hit;Projected TOF Hit R (cm)");
	dHistMap_TrackTOFR_HasHit[locIsTimeBased] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumTOFRBins, 0.0, 180);

	locHistName = "TrackTOFR_NoHit";
	locHistTitle = locTrackString + string(", Has Other Match, TOF No Hit;Projected TOF Hit R (cm)");
	dHistMap_TrackTOFR_NoHit[locIsTimeBased] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumTOFRBins, 0.0, 180);

	locHistName = "TOFTrackDistanceVsP";
	locHistTitle = locTrackString + string(";p (GeV/c);TOF / Track Distance (cm)");
	dHistMap_TOFPointTrackDistanceVsP[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DTrackDOCABins, dMinTrackDOCA, dMaxTrackMatchDOCA);

	locHistName = "TOFTrackDistanceVsTheta";
	locHistTitle = locTrackString + string(";#theta#circ;TOF / Track Distance (cm)");
	dHistMap_TOFPointTrackDistanceVsTheta[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, 20.0, dNum2DTrackDOCABins, dMinTrackDOCA, dMaxTrackMatchDOCA);

	locHistName = "TOFTrackDeltaXVsHorizontalPaddle";
	locHistTitle = locTrackString + string(";TOF Horizontal Paddle;TOF / Track #DeltaX (cm)");
	dHistMap_TOFPointTrackDeltaXVsHorizontalPaddle[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, 46, 0.5, 46.5, dNum2DTrackDOCABins, -1.0*dMaxTrackMatchDOCA, dMaxTrackMatchDOCA);

	locHistName = "TOFTrackDeltaXVsVerticalPaddle";
	locHistTitle = locTrackString + string(";TOF Vertical Paddle;TOF / Track #DeltaX (cm)");
	dHistMap_TOFPointTrackDeltaXVsVerticalPaddle[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, 46, 0.5, 46.5, dNum2DTrackDOCABins, -1.0*dMaxTrackMatchDOCA, dMaxTrackMatchDOCA);

	locHistName = "TOFTrackDeltaYVsHorizontalPaddle";
	locHistTitle = locTrackString + string(";TOF Horizontal Paddle;TOF / Track #DeltaY (cm)");
	dHistMap_TOFPointTrackDeltaYVsHorizontalPaddle[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, 46, 0.5, 46.5, dNum2DTrackDOCABins, -1.0*dMaxTrackMatchDOCA, dMaxTrackMatchDOCA);

	locHistName = "TOFTrackDeltaYVsVerticalPaddle";
	locHistTitle = locTrackString + string(";TOF Vertical Paddle;TOF / Track #DeltaY (cm)");
	dHistMap_TOFPointTrackDeltaYVsVerticalPaddle[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, 46, 0.5, 46.5, dNum2DTrackDOCABins, -1.0*dMaxTrackMatchDOCA, dMaxTrackMatchDOCA);

	locHistName = "TOFTrackDistance_BothPlanes";
	locHistTitle = locTrackString + string("TOF Hit in Both Planes;TOF / Track Distance (cm)");
	dHistMap_TOFPointTrackDistance_BothPlanes[locIsTimeBased] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumTrackDOCABins, dMinTrackDOCA, dMaxTrackMatchDOCA);

	locHistName = "TOFTrackDistance_OnePlane";
	locHistTitle = locTrackString + string("TOF Hit in One Plane;TOF / Track Distance (cm)");
	dHistMap_TOFPointTrackDistance_OnePlane[locIsTimeBased] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumTrackDOCABins, dMinTrackDOCA, dMaxTrackMatchDOCA);
	gDirectory(TDirectory::CurrentDirectory())->cd("..");

	//FCAL
	CreateAndChangeTo_Directory("FCAL", "FCAL");
	locHistName = "TrackFCALYVsX_HasHit";
	locHistTitle = locTrackString + string(", Has Other Match, FCAL Has Hit;Projected FCAL Hit X (cm);Projected FCAL Hit Y (cm)");
	dHistMap_TrackFCALYVsX_HasHit[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNumFCALTOFXYBins, -130.0, 130.0, dNumFCALTOFXYBins, -130.0, 130.0);

	locHistName = "TrackFCALYVsX_NoHit";
	locHistTitle = locTrackString + string(", Has Other Match, FCAL No Hit;Projected FCAL Hit X (cm);Projected FCAL Hit Y (cm)");
	dHistMap_TrackFCALYVsX_NoHit[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNumFCALTOFXYBins, -130.0, 130.0, dNumFCALTOFXYBins, -130.0, 130.0);

	locHistName = "TrackFCALP_HasHit";
	locHistTitle = locTrackString + string(", Has Other Match, FCAL Has Hit;p (GeV/c)");
	dHistMap_TrackFCALP_HasHit[locIsTimeBased] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumPBins, dMinP, dMaxP);

	locHistName = "TrackFCALP_NoHit";
	locHistTitle = locTrackString + string(", Has Other Match, FCAL No Hit;p (GeV/c)");
	dHistMap_TrackFCALP_NoHit[locIsTimeBased] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumPBins, dMinP, dMaxP);

	locHistName = "TrackFCALR_HasHit";
	locHistTitle = locTrackString + string(", Has Other Match, FCAL Has Hit;Projected FCAL Hit R (cm)");
	dHistMap_TrackFCALR_HasHit[locIsTimeBased] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumFCALTOFXYBins, 0.0, 130);

	locHistName = "TrackFCALR_NoHit";
	locHistTitle = locTrackString + string(", Has Other Match, FCAL No Hit;Projected FCAL Hit R (cm)");
	dHistMap_TrackFCALR_NoHit[locIsTimeBased] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumFCALTOFXYBins, 0.0, 130);

	locHistName = "TrackFCALRowVsColumn_HasHit";
	locHistTitle = locTrackString + string(", Has Other Match, FCAL Has Hit;Projected FCAL Hit Column;Projected FCAL Hit Row");
	dHistMap_TrackFCALRowVsColumn_HasHit[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, 59, -0.5, 58.5, 59, -0.5, 58.5);

	locHistName = "TrackFCALRowVsColumn_NoHit";
	locHistTitle = locTrackString + string(", Has Other Match, FCAL No Hit;Projected FCAL Hit Column;Projected FCAL Hit Row");
	dHistMap_TrackFCALRowVsColumn_NoHit[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, 59, -0.5, 58.5, 59, -0.5, 58.5);

	locHistName = "FCALTrackDistanceVsP";
	locHistTitle = locTrackString + string(";p (GeV/c);FCAL / Track Distance (cm)");
	dHistMap_FCALTrackDistanceVsP[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DTrackDOCABins, dMinTrackDOCA, dMaxTrackMatchDOCA);

	locHistName = "FCALTrackDistanceVsTheta";
	locHistTitle = locTrackString + string(";#theta#circ;FCAL / Track Distance (cm)");
	dHistMap_FCALTrackDistanceVsTheta[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, 20.0, dNum2DTrackDOCABins, dMinTrackDOCA, dMaxTrackMatchDOCA);
	gDirectory(TDirectory::CurrentDirectory())->cd("..");
	
	
	//BCAL
	CreateAndChangeTo_Directory("BCAL", "BCAL");
	locHistName = "TrackBCALModuleVsZ_HasHit";
	locHistTitle = locTrackString + string(", Has Other Match, BCAL Has Hit;Projected BCAL Hit Z (cm);Projected BCAL Hit Module");
	dHistMap_TrackBCALModuleVsZ_HasHit[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DBCALZBins, 0.0, 450.0, 48, 0.5, 48.5);

	locHistName = "TrackBCALModuleVsZ_NoHit";
	locHistTitle = locTrackString + string(", Has Other Match, BCAL No Hit;Projected BCAL Hit Z (cm);Projected BCAL Hit Module");
	dHistMap_TrackBCALModuleVsZ_NoHit[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DBCALZBins, 0.0, 450.0, 48, 0.5, 48.5);

	locHistName = "TrackBCALPhiVsZ_HasHit";
	locHistTitle = locTrackString + string(", Has Other Match, BCAL Has Hit;Projected BCAL Hit Z (cm);Projected BCAL Hit #phi#circ");
	dHistMap_TrackBCALPhiVsZ_HasHit[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DBCALZBins, 0.0, 450.0, dNum2DPhiBins, dMinPhi, dMaxPhi);

	locHistName = "TrackBCALPhiVsZ_NoHit";
	locHistTitle = locTrackString + string(", Has Other Match, BCAL No Hit;Projected BCAL Hit Z (cm);Projected BCAL Hit #phi#circ");
	dHistMap_TrackBCALPhiVsZ_NoHit[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DBCALZBins, 0.0, 450.0, dNum2DPhiBins, dMinPhi, dMaxPhi);

	locHistName = "BCALDeltaPhiVsP";
	locHistTitle = locTrackString + string(";p (GeV/c);BCAL / Track #Delta#phi#circ");
	dHistMap_BCALDeltaPhiVsP[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, 4.0, dNum2DDeltaPhiBins, dMinDeltaPhi, dMaxDeltaPhi);

	locHistName = "BCALDeltaPhiVsZ";
	locHistTitle = locTrackString + string(";Projected BCAL Hit-Z (cm);BCAL / Track #Delta#phi#circ");
	dHistMap_BCALDeltaPhiVsZ[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DBCALZBins, 0.0, 450.0, dNum2DDeltaPhiBins, dMinDeltaPhi, dMaxDeltaPhi);

	locHistName = "BCALDeltaZVsTheta";
	locHistTitle = locTrackString + string(";#theta#circ;BCAL / Track #Deltaz (cm)");
	dHistMap_BCALDeltaZVsTheta[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DDeltaZBins, dMinDeltaZ, dMaxDeltaZ);

	locHistName = "BCALDeltaZVsZ";
	locHistTitle = locTrackString + string(";Projected BCAL Hit-Z (cm);BCAL / Track #Deltaz (cm)");
	dHistMap_BCALDeltaZVsZ[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DBCALZBins, 0.0, 450.0, dNum2DDeltaZBins, dMinDeltaZ, dMaxDeltaZ);
	gDirectory(TDirectory::CurrentDirectory())->cd("..");

	//TRACKING
	locHistName = "PVsTheta_NoHitMatch";
	locHistTitle = locTrackString + string(", No Hit Match;#theta#circ;p (GeV/c)");
	dHistMap_TrackPVsTheta_NoHitMatch[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DPBins, dMinP, dMaxP);

	locHistName = "PVsTheta_HitMatch";
	locHistTitle = locTrackString + string(", Hit Match;#theta#circ;p (GeV/c)");
	dHistMap_TrackPVsTheta_HitMatch[locIsTimeBased] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DPBins, dMinP, dMaxP);

	gDirectory(TDirectory::CurrentDirectory())->cd("..");
}

//Return to the base directory
ChangeTo_BaseDirectory();
}
japp->RootUnLock(); //RELEASE ROOT LOCK!!
1124}

1126void DHistogramAction_DetectorMatching::Run_Update(JEventLoop* locEventLoop)
1127{
map<string, double> tofparms;
const DTOFGeometry *locTOFGeometry = nullptr;
locEventLoop->GetSingle(locTOFGeometry);
string locTOFParmsTable = locTOFGeometry->Get_CCDB_DirectoryName() + "/tof_parms";
locEventLoop->GetCalib(locTOFParmsTable.c_str(), tofparms);
TOF_E_THRESHOLD = tofparms["TOF_E_THRESHOLD"];
1134}

1136bool DHistogramAction_DetectorMatching::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
1137{
//Expect locParticleCombo to be NULL since this is a reaction-independent action.

if(Get_CalledPriorWithComboFlag())
return true; //else double-counting!

bool locIsRESTEvent = locEventLoop->GetJEvent().GetStatusBit(kSTATUS_REST);

Fill_MatchingHists(locEventLoop, true); //Time-based tracks
if(!locIsRESTEvent)
Fill_MatchingHists(locEventLoop, false); //Wire-based tracks

return true; //return false if you want to use this action to apply a cut (and it fails the cut!)
1150}

1152void DHistogramAction_DetectorMatching::Fill_MatchingHists(JEventLoop* locEventLoop, bool locIsTimeBased)
1153{
const DParticleID* locParticleID = NULL__null;
locEventLoop->GetSingle(locParticleID);
1
Calling 'JEventLoop::GetSingle'→

//can't make this a class member: may cause race condition
DCutAction_TrackHitPattern locCutAction_TrackHitPattern(NULL__null, dMinHitRingsPerCDCSuperlayer, dMinHitPlanesPerFDCPackage);
locCutAction_TrackHitPattern.Initialize(locEventLoop);

//get the best tracks for each candidate id, based on good hit pattern & tracking FOM
map<JObject::oid_t, const DTrackingData*> locBestTrackMap; //lowest tracking FOM for each candidate id
if(locIsTimeBased)
{
vector<const DTrackTimeBased*> locTrackTimeBasedVector;
locEventLoop->Get(locTrackTimeBasedVector);

//select the best DTrackTimeBased for each track: of tracks with good hit pattern, use best tracking FOM
for(size_t loc_i = 0; loc_i < locTrackTimeBasedVector.size(); ++loc_i)
{
	if(locTrackTimeBasedVector[loc_i]->FOM < dMinTrackingFOM)
		continue;
	if(!locCutAction_TrackHitPattern.Cut_TrackHitPattern(locParticleID, locTrackTimeBasedVector[loc_i]))
		continue;
	JObject::oid_t locCandidateID = locTrackTimeBasedVector[loc_i]->candidateid;
	if(locBestTrackMap.find(locCandidateID) == locBestTrackMap.end())
		locBestTrackMap[locCandidateID] = locTrackTimeBasedVector[loc_i];
	else if(locTrackTimeBasedVector[loc_i]->FOM > (dynamic_cast<const DTrackTimeBased*>(locBestTrackMap[locCandidateID]))->FOM)
		locBestTrackMap[locCandidateID] = locTrackTimeBasedVector[loc_i];
}
}
else
{
vector<const DTrackWireBased*> locTrackWireBasedVector;
locEventLoop->Get(locTrackWireBasedVector);

//select the best DTrackWireBased for each track: of tracks with good hit pattern, use best tracking FOM
for(size_t loc_i = 0; loc_i < locTrackWireBasedVector.size(); ++loc_i)
{
	if(locTrackWireBasedVector[loc_i]->FOM < dMinTrackingFOM)
		continue;
	if(!locCutAction_TrackHitPattern.Cut_TrackHitPattern(locParticleID, locTrackWireBasedVector[loc_i]))
		continue;
	JObject::oid_t locCandidateID = locTrackWireBasedVector[loc_i]->candidateid;
	if(locBestTrackMap.find(locCandidateID) == locBestTrackMap.end())
		locBestTrackMap[locCandidateID] = locTrackWireBasedVector[loc_i];
	else if(locTrackWireBasedVector[loc_i]->FOM > (dynamic_cast<const DTrackWireBased*>(locBestTrackMap[locCandidateID]))->FOM)
		locBestTrackMap[locCandidateID] = locTrackWireBasedVector[loc_i];
}
}

vector<const DBCALShower*> locBCALShowers;
locEventLoop->Get(locBCALShowers);

vector<const DFCALShower*> locFCALShowers;
locEventLoop->Get(locFCALShowers);

vector<const DCCALShower*> locCCALShowers;
locEventLoop->Get(locCCALShowers);

vector<const DTOFPoint*> locTOFPoints;
locEventLoop->Get(locTOFPoints);

vector<const DTOFPaddleHit*> locTOFPaddleHits;
locEventLoop->Get(locTOFPaddleHits);

vector<const DSCHit*> locSCHits;
locEventLoop->Get(locSCHits);

const DEventRFBunch* locEventRFBunch = nullptr;
locEventLoop->GetSingle(locEventRFBunch);

string locDetectorMatchesTag = locIsTimeBased ? "" : "WireBased";
const DDetectorMatches* locDetectorMatches = NULL__null;
locEventLoop->GetSingle(locDetectorMatches, locDetectorMatchesTag.c_str());

//TRACK / BCAL CLOSEST MATCHES
map<const DTrackingData*, pair<shared_ptr<const DBCALShowerMatchParams>, double> > locBCALTrackDistanceMap; //double = z
for(auto locTrackIterator = locBestTrackMap.begin(); locTrackIterator != locBestTrackMap.end(); ++locTrackIterator)
{
 map<DetectorSystem_t,vector<DTrackFitter::Extrapolation_t> >extrapolations;
 Get_Extrapolations(locTrackIterator->second,extrapolations);

 if(extrapolations.size()<2)
   break; //e.g. REST data: no trajectory

 double locStartTime = locTrackIterator->second->t0();
 double locStartTimeVariance = 0.0;
 DVector3 locProjPos, locProjMom;

 shared_ptr<const DBCALShowerMatchParams> locBestMatchParams;
 if(locParticleID->Get_ClosestToTrack(extrapolations.at(SYS_BCAL), locBCALShowers, false, locStartTime, locBestMatchParams, &locStartTimeVariance, &locProjPos, &locProjMom))
   locBCALTrackDistanceMap[locTrackIterator->second] = std::make_pair(locBestMatchParams, locProjPos.Z());
}

//TRACK / FCAL CLOSEST MATCHES
map<const DTrackingData*, shared_ptr<const DFCALShowerMatchParams>> locFCALTrackDistanceMap;
for(auto locTrackIterator = locBestTrackMap.begin(); locTrackIterator != locBestTrackMap.end(); ++locTrackIterator)
{
 map<DetectorSystem_t,vector<DTrackFitter::Extrapolation_t> >extrapolations;
 Get_Extrapolations(locTrackIterator->second,extrapolations);

 if(extrapolations.size()<2)
   break; //e.g. REST data: no trajectory

 double locStartTime = locTrackIterator->second->t0();
 shared_ptr<const DFCALShowerMatchParams> locBestMatchParams;
 if(locParticleID->Get_ClosestToTrack(extrapolations.at(SYS_FCAL), locFCALShowers, false, locStartTime, locBestMatchParams))
   locFCALTrackDistanceMap.emplace(locTrackIterator->second, locBestMatchParams);
}

//TRACK / SC CLOSEST MATCHES
map<const DTrackingData*, pair<shared_ptr<const DSCHitMatchParams>, double> > locSCTrackDistanceMap; //double = z
for(auto locTrackIterator = locBestTrackMap.begin(); locTrackIterator != locBestTrackMap.end(); ++locTrackIterator)
{
 map<DetectorSystem_t,vector<DTrackFitter::Extrapolation_t> >extrapolations;
 Get_Extrapolations(locTrackIterator->second,extrapolations);
 
 if(extrapolations.size()<2)
   break; //e.g. REST data: no trajectory

 double locStartTime = locTrackIterator->second->t0();
 double locStartTimeVariance = 0.0;
 DVector3 locProjPos, locProjMom;
 
 shared_ptr<const DSCHitMatchParams> locBestMatchParams;
 if(locParticleID->Get_ClosestToTrack(extrapolations.at(SYS_START), locSCHits, locIsTimeBased, false, locStartTime, locBestMatchParams, &locStartTimeVariance, &locProjPos, &locProjMom))
   locSCTrackDistanceMap[locTrackIterator->second] = std::make_pair(locBestMatchParams, locProjPos.Z());
}

//TRACK / TOF POINT CLOSEST MATCHES
map<const DTrackingData*, shared_ptr<const DTOFHitMatchParams>> locTOFPointTrackDistanceMap;
for(auto locTrackIterator = locBestTrackMap.begin(); locTrackIterator != locBestTrackMap.end(); ++locTrackIterator)
{
 map<DetectorSystem_t,vector<DTrackFitter::Extrapolation_t> >extrapolations;
 Get_Extrapolations(locTrackIterator->second,extrapolations);
 
 if(extrapolations.size()<2)
   break; //e.g. REST data: no trajectory

 double locStartTime = locTrackIterator->second->t0();
 shared_ptr<const DTOFHitMatchParams> locBestMatchParams;
 if(locParticleID->Get_ClosestToTrack(extrapolations.at(SYS_TOF), locTOFPoints, false, locStartTime, locBestMatchParams))
   locTOFPointTrackDistanceMap.emplace(locTrackIterator->second, locBestMatchParams);
}

//TRACK / TOF PADDLE CLOSEST MATCHES
map<const DTrackingData*, pair<const DTOFPaddleHit*, pair<double, double> > > locHorizontalTOFPaddleTrackDistanceMap; //doubles: delta-y, distance
map<const DTrackingData*, pair<const DTOFPaddleHit*, pair<double, double> > > locVerticalTOFPaddleTrackDistanceMap; //doubles: delta-x, distance
for(auto locTrackIterator = locBestTrackMap.begin(); locTrackIterator != locBestTrackMap.end(); ++locTrackIterator)
{
 const DKinematicData* locKinematicData = locTrackIterator->second;
 map<DetectorSystem_t,vector<DTrackFitter::Extrapolation_t> >extrapolations;
 Get_Extrapolations(locTrackIterator->second,extrapolations);
 
 if(extrapolations.size()<2)
   break; //e.g. REST data: no trajectory

 double locBestDeltaX = 999.9, locBestDeltaY = 999.9, locBestDistance_Vertical = 999.9, locBestDistance_Horizontal = 999.9;
 double locStartTime = locParticleID->Calc_PropagatedRFTime(locKinematicData, locEventRFBunch);
 
 const DTOFPaddleHit* locClosestTOFPaddleHit_Vertical = locParticleID->Get_ClosestTOFPaddleHit_Vertical(extrapolations.at(SYS_TOF), locTOFPaddleHits, locStartTime, locBestDeltaX, locBestDistance_Vertical);
 pair<double, double> locDistancePair_Vertical(locBestDeltaX, locBestDistance_Vertical);
 if(locClosestTOFPaddleHit_Vertical != NULL__null)
   locVerticalTOFPaddleTrackDistanceMap[locTrackIterator->second] = pair<const DTOFPaddleHit*, pair<double, double> >(locClosestTOFPaddleHit_Vertical, locDistancePair_Vertical);
 
 const DTOFPaddleHit* locClosestTOFPaddleHit_Horizontal = locParticleID->Get_ClosestTOFPaddleHit_Horizontal(extrapolations.at(SYS_TOF), locTOFPaddleHits, locStartTime, locBestDeltaY, locBestDistance_Horizontal);
 pair<double, double> locDistancePair_Horizontal(locBestDeltaY, locBestDistance_Horizontal);
 if(locClosestTOFPaddleHit_Horizontal != NULL__null)
   locHorizontalTOFPaddleTrackDistanceMap[locTrackIterator->second] = pair<const DTOFPaddleHit*, pair<double, double> >(locClosestTOFPaddleHit_Horizontal, locDistancePair_Horizontal);
}

//PROJECTED HIT POSITIONS
map<const DTrackingData*, pair<int, bool> > locProjectedSCPaddleMap; //pair: paddle, hit-barrel-flag (false if bend/nose)
map<const DTrackingData*, pair<int, int> > locProjectedTOF2DPaddlesMap; //pair: vertical, horizontal
map<const DTrackingData*, pair<float, float> > locProjectedTOFXYMap; //pair: x, y
map<const DTrackingData*, pair<int, int> > locProjectedFCALRowColumnMap; //pair: column, row
map<const DTrackingData*, pair<float, float> > locProjectedFCALXYMap; //pair: x, y
map<const DTrackingData*, pair<float, int> > locProjectedBCALModuleSectorMap; //pair: z, module
map<const DTrackingData*, pair<float, float> > locProjectedBCALPhiZMap; //pair: z, phi
for(auto locTrackIterator = locBestTrackMap.begin(); locTrackIterator != locBestTrackMap.end(); ++locTrackIterator)
{
 const DTrackingData* locTrack = locTrackIterator->second;
 map<DetectorSystem_t,vector<DTrackFitter::Extrapolation_t> >extrapolations;
 Get_Extrapolations(locTrackIterator->second,extrapolations);
 
 if(extrapolations.size()<2)
   break; //e.g. REST data: no trajectory

 //SC
 DVector3 locSCIntersection;
 bool locProjBarrelFlag = false;
 unsigned int locProjectedSCPaddle = locParticleID->PredictSCSector(extrapolations.at(SYS_START), &locSCIntersection, &locProjBarrelFlag);
 if(locProjectedSCPaddle != 0)
   locProjectedSCPaddleMap[locTrack] = pair<int, bool>(locProjectedSCPaddle, locProjBarrelFlag);

 //TOF
 DVector3 locTOFIntersection;
 unsigned int locHorizontalBar = 0, locVerticalBar = 0;
 if(locParticleID->PredictTOFPaddles(extrapolations.at(SYS_TOF), locHorizontalBar, locVerticalBar, &locTOFIntersection))
   {
     locProjectedTOF2DPaddlesMap[locTrack] = pair<int, int>(locVerticalBar, locHorizontalBar);
     locProjectedTOFXYMap[locTrack] = pair<float, float>(locTOFIntersection.X(), locTOFIntersection.Y());
   }
 
 //FCAL
 DVector3 locFCALIntersection;
 unsigned int locRow = 0, locColumn = 0;
 if(locParticleID->PredictFCALHit(extrapolations.at(SYS_FCAL), locRow, locColumn, &locFCALIntersection))
   {
     locProjectedFCALRowColumnMap[locTrack] = pair<int, int>(locColumn, locRow);
     locProjectedFCALXYMap[locTrack] = pair<float, float>(locFCALIntersection.X(), locFCALIntersection.Y());
   }
 
 //BCAL
 DVector3 locBCALIntersection;
 unsigned int locModule = 0, locSector = 0;
 if(locParticleID->PredictBCALWedge(extrapolations.at(SYS_BCAL), locModule, locSector, &locBCALIntersection))
   {
     locProjectedBCALModuleSectorMap[locTrack] = pair<float, int>(locBCALIntersection.Z(), locModule);
     locProjectedBCALPhiZMap[locTrack] = pair<float, float>(locBCALIntersection.Z(), locBCALIntersection.Phi()*180.0/TMath::Pi());
   }
}

//FILL HISTOGRAMS
//Since we are filling histograms local to this action, it will not interfere with other ROOT operations: can use action-wide ROOT lock
//Note, the mutex is unique to this DReaction + action_string combo: actions of same class with different hists will have a different mutex
Lock_Action(); //ACQUIRE ROOT LOCK!!
{
/********************************************************** MATCHING DISTANCE **********************************************************/

//BCAL
for(auto locMapPair : locBCALTrackDistanceMap)
{
	auto locTrack = locMapPair.first;
	auto locMatchParams = locMapPair.second.first;
	double locDeltaPhi = locMatchParams->dDeltaPhiToShower*180.0/TMath::Pi();
	double locProjectedZ = locMapPair.second.second;
	dHistMap_BCALDeltaPhiVsP[locIsTimeBased]->Fill(locTrack->momentum().Mag(), locDeltaPhi);
	dHistMap_BCALDeltaZVsTheta[locIsTimeBased]->Fill(locTrack->momentum().Theta()*180.0/TMath::Pi(), locMatchParams->dDeltaZToShower);

	dHistMap_BCALDeltaPhiVsZ[locIsTimeBased]->Fill(locProjectedZ, locDeltaPhi);
	dHistMap_BCALDeltaZVsZ[locIsTimeBased]->Fill(locProjectedZ, locMatchParams->dDeltaZToShower);
}

//FCAL
for(auto locMapPair : locFCALTrackDistanceMap)
{
	auto locTrack = locMapPair.first;
	dHistMap_FCALTrackDistanceVsP[locIsTimeBased]->Fill(locTrack->momentum().Mag(), locMapPair.second->dDOCAToShower);
	dHistMap_FCALTrackDistanceVsTheta[locIsTimeBased]->Fill(locTrack->momentum().Theta()*180.0/TMath::Pi(), locMapPair.second->dDOCAToShower);
}

//TOF Paddle
//Horizontal
auto locTOFPaddleIterator = locHorizontalTOFPaddleTrackDistanceMap.begin();
for(; locTOFPaddleIterator != locHorizontalTOFPaddleTrackDistanceMap.end(); ++locTOFPaddleIterator)
{
	double locDeltaY = locTOFPaddleIterator->second.second.first;
	dHistMap_TOFPaddleTrackDeltaY[locIsTimeBased]->Fill(locDeltaY);
}
//Vertical
locTOFPaddleIterator = locVerticalTOFPaddleTrackDistanceMap.begin();
for(; locTOFPaddleIterator != locVerticalTOFPaddleTrackDistanceMap.end(); ++locTOFPaddleIterator)
{
	double locDeltaX = locTOFPaddleIterator->second.second.first;
	dHistMap_TOFPaddleTrackDeltaX[locIsTimeBased]->Fill(locDeltaX);
}

//TOF Point
for(auto locMapPair : locTOFPointTrackDistanceMap)
{
	auto locTrack = locMapPair.first;
	const DTOFPoint* locTOFPoint = locMapPair.second->dTOFPoint;
	double locDeltaX = locMapPair.second->dDeltaXToHit;
	double locDeltaY = locMapPair.second->dDeltaYToHit;

	double locDistance = sqrt(locDeltaX*locDeltaX + locDeltaY*locDeltaY);
	if((fabs(locDeltaX) < 500.0) && (fabs(locDeltaY) < 500.0)) //else position not well-defined
	{
		dHistMap_TOFPointTrackDistanceVsP[locIsTimeBased]->Fill(locTrack->momentum().Mag(), locDistance);
		dHistMap_TOFPointTrackDistanceVsTheta[locIsTimeBased]->Fill(locTrack->momentum().Theta()*180.0/TMath::Pi(), locDistance);
		if((locTOFPoint->dHorizontalBar != 0) && (locTOFPoint->dVerticalBar != 0))
			dHistMap_TOFPointTrackDistance_BothPlanes[locIsTimeBased]->Fill(locDistance);
		else
			dHistMap_TOFPointTrackDistance_OnePlane[locIsTimeBased]->Fill(locDistance);
	}

	dHistMap_TOFPointTrackDeltaXVsHorizontalPaddle[locIsTimeBased]->Fill(locTOFPoint->dHorizontalBar, locDeltaX);
	dHistMap_TOFPointTrackDeltaXVsVerticalPaddle[locIsTimeBased]->Fill(locTOFPoint->dVerticalBar, locDeltaX);

	dHistMap_TOFPointTrackDeltaYVsHorizontalPaddle[locIsTimeBased]->Fill(locTOFPoint->dHorizontalBar, locDeltaY);
	dHistMap_TOFPointTrackDeltaYVsVerticalPaddle[locIsTimeBased]->Fill(locTOFPoint->dVerticalBar, locDeltaY);
}

//SC
if(locSCHits.size() <= 4) //don't fill if every paddle fired!
{
	for(auto locMapPair : locSCTrackDistanceMap)
	{
		auto locTrack = locMapPair.first;
		auto locMatchParams = locMapPair.second.first;
		double locDeltaPhi = locMatchParams->dDeltaPhiToHit*180.0/TMath::Pi();
		double locProjectedZ = locMapPair.second.second;
		dHistMap_SCTrackDeltaPhiVsP[locIsTimeBased]->Fill(locTrack->momentum().Mag(), locDeltaPhi);
		dHistMap_SCTrackDeltaPhiVsTheta[locIsTimeBased]->Fill(locTrack->momentum().Theta()*180.0/TMath::Pi(), locDeltaPhi);
		dHistMap_SCTrackDeltaPhiVsZ[locIsTimeBased]->Fill(locProjectedZ, locDeltaPhi);
	}
}

/********************************************************* MATCHING EFFICINECY *********************************************************/

//Does-it-match, by detector
for(auto locMapPair : locBestTrackMap)
{
	auto locTrack = locMapPair.second;
	double locTheta = locTrack->momentum().Theta()*180.0/TMath::Pi();
	double locPhi = locTrack->momentum().Phi()*180.0/TMath::Pi();
	double locP = locTrack->momentum().Mag();

	//BCAL
	if(locDetectorMatches->Get_IsMatchedToDetector(locTrack, SYS_START))
	{
		if(locDetectorMatches->Get_IsMatchedToDetector(locTrack, SYS_BCAL))
		{
			dHistMap_PVsTheta_HasHit[SYS_BCAL][locIsTimeBased]->Fill(locTheta, locP);
			dHistMap_PhiVsTheta_HasHit[SYS_BCAL][locIsTimeBased]->Fill(locTheta, locPhi);
			if(locProjectedBCALModuleSectorMap.find(locTrack) != locProjectedBCALModuleSectorMap.end())
			{
				pair<float, float>& locPositionPair = locProjectedBCALPhiZMap[locTrack];
				dHistMap_TrackBCALPhiVsZ_HasHit[locIsTimeBased]->Fill(locPositionPair.first, locPositionPair.second);
				pair<float, int>& locElementPair = locProjectedBCALModuleSectorMap[locTrack];
				dHistMap_TrackBCALModuleVsZ_HasHit[locIsTimeBased]->Fill(locElementPair.first, locElementPair.second);
			}
		}
		else
		{
			dHistMap_PVsTheta_NoHit[SYS_BCAL][locIsTimeBased]->Fill(locTheta, locP);
			dHistMap_PhiVsTheta_NoHit[SYS_BCAL][locIsTimeBased]->Fill(locTheta, locPhi);
			if(locProjectedBCALModuleSectorMap.find(locTrack) != locProjectedBCALModuleSectorMap.end())
			{
				pair<float, float>& locPositionPair = locProjectedBCALPhiZMap[locTrack];
				dHistMap_TrackBCALPhiVsZ_NoHit[locIsTimeBased]->Fill(locPositionPair.first, locPositionPair.second);
				pair<float, int>& locElementPair = locProjectedBCALModuleSectorMap[locTrack];
				dHistMap_TrackBCALModuleVsZ_NoHit[locIsTimeBased]->Fill(locElementPair.first, locElementPair.second);
			}
		}
	}

	//FCAL
	if(locDetectorMatches->Get_IsMatchedToDetector(locTrack, SYS_FCAL))
	{
		dHistMap_PVsTheta_HasHit[SYS_FCAL][locIsTimeBased]->Fill(locTheta, locP);
		if(locP > 1.0)
			dHistMap_PhiVsTheta_HasHit[SYS_FCAL][locIsTimeBased]->Fill(locTheta, locPhi);
		if(locProjectedFCALRowColumnMap.find(locTrack) != locProjectedFCALRowColumnMap.end())
		{
			dHistMap_TrackFCALP_HasHit[locIsTimeBased]->Fill(locP);
			if(locP > 1.0)
			{
				pair<float, float>& locPositionPair = locProjectedFCALXYMap[locTrack];
				dHistMap_TrackFCALYVsX_HasHit[locIsTimeBased]->Fill(locPositionPair.first, locPositionPair.second);
				float locFCALR = sqrt(locPositionPair.first*locPositionPair.first + locPositionPair.second*locPositionPair.second);
				dHistMap_TrackFCALR_HasHit[locIsTimeBased]->Fill(locFCALR);
				pair<int, int>& locElementPair = locProjectedFCALRowColumnMap[locTrack];
				dHistMap_TrackFCALRowVsColumn_HasHit[locIsTimeBased]->Fill(locElementPair.first, locElementPair.second);
			}
		}
	}
	else
	{
		dHistMap_PVsTheta_NoHit[SYS_FCAL][locIsTimeBased]->Fill(locTheta, locP);
		if(locP > 1.0)
			dHistMap_PhiVsTheta_NoHit[SYS_FCAL][locIsTimeBased]->Fill(locTheta, locPhi);
		if(locProjectedFCALRowColumnMap.find(locTrack) != locProjectedFCALRowColumnMap.end())
		{
			dHistMap_TrackFCALP_NoHit[locIsTimeBased]->Fill(locP);
			if(locP > 1.0)
			{
				pair<float, float>& locPositionPair = locProjectedFCALXYMap[locTrack];
				dHistMap_TrackFCALYVsX_NoHit[locIsTimeBased]->Fill(locPositionPair.first, locPositionPair.second);
				float locFCALR = sqrt(locPositionPair.first*locPositionPair.first + locPositionPair.second*locPositionPair.second);
				dHistMap_TrackFCALR_NoHit[locIsTimeBased]->Fill(locFCALR);
				pair<int, int>& locElementPair = locProjectedFCALRowColumnMap[locTrack];
				dHistMap_TrackFCALRowVsColumn_NoHit[locIsTimeBased]->Fill(locElementPair.first, locElementPair.second);
			}
		}
	}

	//TOF Paddle
	if((locP > 1.0) && (locProjectedTOFXYMap.find(locTrack) != locProjectedTOFXYMap.end()))
	{
		pair<float, float>& locPositionPair = locProjectedTOFXYMap[locTrack];
		pair<int, int>& locPaddlePair = locProjectedTOF2DPaddlesMap[locTrack]; //vertical, horizontal

		//Horizontal
		if(locHorizontalTOFPaddleTrackDistanceMap.find(locTrack) != locHorizontalTOFPaddleTrackDistanceMap.end())
		{
			auto& locMatch = locHorizontalTOFPaddleTrackDistanceMap[locTrack];
			const DTOFPaddleHit* locTOFPaddleHit = locMatch.first;
			bool locDoubleEndedHitFlag = ((locTOFPaddleHit->E_north > TOF_E_THRESHOLD) && (locTOFPaddleHit->E_south > TOF_E_THRESHOLD));
			double locDistance = locDoubleEndedHitFlag ? locMatch.second.second : locMatch.second.first;
			if(locDistance <= dMinTOFPaddleMatchDistance) //match
				dHistMap_TOFPaddleHorizontalPaddleVsTrackX_HasHit[locIsTimeBased]->Fill(locPositionPair.first, locPaddlePair.second);
			else //no match
				dHistMap_TOFPaddleHorizontalPaddleVsTrackX_NoHit[locIsTimeBased]->Fill(locPositionPair.first, locPaddlePair.second);
		}
		else // no match
			dHistMap_TOFPaddleHorizontalPaddleVsTrackX_NoHit[locIsTimeBased]->Fill(locPositionPair.first, locPaddlePair.second);

		//Vertical
		if(locVerticalTOFPaddleTrackDistanceMap.find(locTrack) != locVerticalTOFPaddleTrackDistanceMap.end())
		{
			auto& locMatch = locVerticalTOFPaddleTrackDistanceMap[locTrack];
			const DTOFPaddleHit* locTOFPaddleHit = locMatch.first;
			bool locDoubleEndedHitFlag = ((locTOFPaddleHit->E_north > TOF_E_THRESHOLD) && (locTOFPaddleHit->E_south > TOF_E_THRESHOLD));
			double locDistance = locDoubleEndedHitFlag ? locMatch.second.second : locMatch.second.first;
			if(locDistance <= dMinTOFPaddleMatchDistance) //match
				dHistMap_TOFPaddleTrackYVsVerticalPaddle_HasHit[locIsTimeBased]->Fill(locPaddlePair.first, locPositionPair.second);
			else //no match
				dHistMap_TOFPaddleTrackYVsVerticalPaddle_NoHit[locIsTimeBased]->Fill(locPaddlePair.first, locPositionPair.second);
		}
		else // no match
			dHistMap_TOFPaddleTrackYVsVerticalPaddle_NoHit[locIsTimeBased]->Fill(locPaddlePair.first, locPositionPair.second);
	}

	//TOF Point
	if(locDetectorMatches->Get_IsMatchedToDetector(locTrack, SYS_TOF))
	{
		dHistMap_PVsTheta_HasHit[SYS_TOF][locIsTimeBased]->Fill(locTheta, locP);
		if(locP > 1.0)
			dHistMap_PhiVsTheta_HasHit[SYS_TOF][locIsTimeBased]->Fill(locTheta, locPhi);
		if(locProjectedTOFXYMap.find(locTrack) != locProjectedTOFXYMap.end())
		{
			dHistMap_TrackTOFP_HasHit[locIsTimeBased]->Fill(locP);
			if(locP > 1.0)
			{
				pair<float, float>& locPositionPair = locProjectedTOFXYMap[locTrack];
				dHistMap_TrackTOFYVsX_HasHit[locIsTimeBased]->Fill(locPositionPair.first, locPositionPair.second);
				float locTOFR = sqrt(locPositionPair.first*locPositionPair.first + locPositionPair.second*locPositionPair.second);
				dHistMap_TrackTOFR_HasHit[locIsTimeBased]->Fill(locTOFR);
				pair<int, int>& locElementPair = locProjectedTOF2DPaddlesMap[locTrack];
				dHistMap_TrackTOF2DPaddles_HasHit[locIsTimeBased]->Fill(locElementPair.first, locElementPair.second);
			}
		}
	}
	else
	{
		dHistMap_PVsTheta_NoHit[SYS_TOF][locIsTimeBased]->Fill(locTheta, locP);
		if(locP > 1.0)
			dHistMap_PhiVsTheta_NoHit[SYS_TOF][locIsTimeBased]->Fill(locTheta, locPhi);
		if(locProjectedTOFXYMap.find(locTrack) != locProjectedTOFXYMap.end())
		{
			dHistMap_TrackTOFP_NoHit[locIsTimeBased]->Fill(locP);
			if(locP > 1.0)
			{
				pair<float, float>& locPositionPair = locProjectedTOFXYMap[locTrack];
				dHistMap_TrackTOFYVsX_NoHit[locIsTimeBased]->Fill(locPositionPair.first, locPositionPair.second);
				float locTOFR = sqrt(locPositionPair.first*locPositionPair.first + locPositionPair.second*locPositionPair.second);
				dHistMap_TrackTOFR_NoHit[locIsTimeBased]->Fill(locTOFR);
				pair<int, int>& locElementPair = locProjectedTOF2DPaddlesMap[locTrack];
				dHistMap_TrackTOF2DPaddles_NoHit[locIsTimeBased]->Fill(locElementPair.first, locElementPair.second);
			}
		}
	}

	//SC
	if(locDetectorMatches->Get_IsMatchedToDetector(locTrack, SYS_BCAL) || locDetectorMatches->Get_IsMatchedToDetector(locTrack, SYS_FCAL) || locDetectorMatches->Get_IsMatchedToDetector(locTrack, SYS_TOF))
	{
		if(locDetectorMatches->Get_IsMatchedToDetector(locTrack, SYS_START))
		{
			dHistMap_PVsTheta_HasHit[SYS_START][locIsTimeBased]->Fill(locTheta, locP);
			dHistMap_PhiVsTheta_HasHit[SYS_START][locIsTimeBased]->Fill(locTheta, locPhi);
			if(locProjectedSCPaddleMap.find(locTrack) != locProjectedSCPaddleMap.end())
			{
				dHistMap_SCPaddleVsTheta_HasHit[locIsTimeBased]->Fill(locTheta, locProjectedSCPaddleMap[locTrack].first);
				if(locProjectedSCPaddleMap[locTrack].second)
					dHistMap_SCPaddle_BarrelRegion_HasHit[locIsTimeBased]->Fill(locProjectedSCPaddleMap[locTrack].first);
				else
					dHistMap_SCPaddle_NoseRegion_HasHit[locIsTimeBased]->Fill(locProjectedSCPaddleMap[locTrack].first);
				if(locSCTrackDistanceMap.find(locTrack) != locSCTrackDistanceMap.end())
				{
					double locProjectedZ = locSCTrackDistanceMap[locTrack].second;
					dHistMap_SCPaddleVsZ_HasHit[locIsTimeBased]->Fill(locProjectedZ, locProjectedSCPaddleMap[locTrack].first);
				}
			}
		}
		else
		{
			dHistMap_PVsTheta_NoHit[SYS_START][locIsTimeBased]->Fill(locTheta, locP);
			dHistMap_PhiVsTheta_NoHit[SYS_START][locIsTimeBased]->Fill(locTheta, locPhi);
			if(locProjectedSCPaddleMap.find(locTrack) != locProjectedSCPaddleMap.end())
			{
				dHistMap_SCPaddleVsTheta_NoHit[locIsTimeBased]->Fill(locTheta, locProjectedSCPaddleMap[locTrack].first);
				if(locProjectedSCPaddleMap[locTrack].second)
					dHistMap_SCPaddle_BarrelRegion_NoHit[locIsTimeBased]->Fill(locProjectedSCPaddleMap[locTrack].first);
				else
					dHistMap_SCPaddle_NoseRegion_NoHit[locIsTimeBased]->Fill(locProjectedSCPaddleMap[locTrack].first);
				if(locSCTrackDistanceMap.find(locTrack) != locSCTrackDistanceMap.end())
				{
					double locProjectedZ = locSCTrackDistanceMap[locTrack].second;
					dHistMap_SCPaddleVsZ_NoHit[locIsTimeBased]->Fill(locProjectedZ, locProjectedSCPaddleMap[locTrack].first);
				}
			}
		}
	}
}

//Is-Matched to Something
for(auto locMapPair : locBestTrackMap)
{
	auto locTrack = locMapPair.second;
	double locTheta = locTrack->momentum().Theta()*180.0/TMath::Pi();
	double locP = locTrack->momentum().Mag();
	if(locDetectorMatches->Get_IsMatchedToHit(locTrack))
		dHistMap_TrackPVsTheta_HitMatch[locIsTimeBased]->Fill(locTheta, locP);
	else
		dHistMap_TrackPVsTheta_NoHitMatch[locIsTimeBased]->Fill(locTheta, locP);
}
}
Unlock_Action(); //RELEASE ROOT LOCK!!
1672}

1674void DHistogramAction_DetectorPID::Initialize(JEventLoop* locEventLoop)
1675{
//Create any histograms/trees/etc. within a ROOT lock.
//This is so that when running multithreaded, only one thread is writing to the ROOT file at a time.

//When creating a reaction-independent action, only modify member variables within a ROOT lock.
//Objects created within a plugin (such as reaction-independent actions) can be accessed by many threads simultaneously.

string locHistName, locHistTitle, locParticleROOTName;

string locTrackSelectionTag = "NotATag", locShowerSelectionTag = "NotATag";
if(gPARMS->Exists("COMBO:TRACK_SELECT_TAG"))
gPARMS->GetParameter("COMBO:TRACK_SELECT_TAG", locTrackSelectionTag);
if(gPARMS->Exists("COMBO:SHOWER_SELECT_TAG"))
gPARMS->GetParameter("COMBO:SHOWER_SELECT_TAG", locShowerSelectionTag);

//CREATE THE HISTOGRAMS
//Since we are creating histograms, the contents of gDirectory will be modified: must use JANA-wide ROOT lock
japp->RootWriteLock(); //ACQUIRE ROOT LOCK!!
{
//So: Default tag is "", User can set it to something else
//In here, if tag is "", get from gparms, if not, leave it alone
	//If gparms value does not exist, set it to (and use) "PreSelect"
if(dTrackSelectionTag == "NotATag")
	dTrackSelectionTag = (locTrackSelectionTag == "NotATag") ? "PreSelect" : locTrackSelectionTag;
if(dShowerSelectionTag == "NotATag")
	dShowerSelectionTag = (locShowerSelectionTag == "NotATag") ? "PreSelect" : locShowerSelectionTag;

//Required: Create a folder in the ROOT output file that will contain all of the output ROOT objects (if any) for this action.
	//If another thread has already created the folder, it just changes to it.
CreateAndChangeTo_ActionDirectory();

//q = 0
locParticleROOTName = ParticleName_ROOT(Gamma);
//BCAL
CreateAndChangeTo_Directory("BCAL", "BCAL");

locHistName = "BetaVsP_q0";
locHistTitle = "BCAL q^{0};Shower Energy (GeV);#beta";
dHistMap_BetaVsP[SYS_BCAL][0] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxBCALP, dNum2DBetaBins, dMinBeta, dMaxBeta);

locHistName = "DeltaTVsShowerE_Photon";
locHistTitle = string("BCAL q^{0}") + locParticleROOTName + string(";Shower Energy (GeV);#Deltat_{BCAL - RF}");
dHistMap_DeltaTVsP[SYS_BCAL][Gamma] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DDeltaTBins, dMinDeltaT, dMaxDeltaT);

1719/*
//Uncomment when ready!
locHistName = "TimePullVsShowerE_Photon";
locHistTitle = string("BCAL ") + locParticleROOTName + string(";Shower Energy (GeV);#Deltat/#sigma_{#Deltat}");
dHistMap_TimePullVsP[SYS_BCAL][Gamma] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DPullBins, dMinPull, dMaxPull);

locHistName = "TimeFOMVsShowerE_Photon";
locHistTitle = string("BCAL ") + locParticleROOTName + string(";Shower Energy (GeV);Timing PID Confidence Level");
dHistMap_TimeFOMVsP[SYS_BCAL][Gamma] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DFOMBins, 0.0, 1.0);
1728*/
gDirectory(TDirectory::CurrentDirectory())->cd("..");

//FCAL
CreateAndChangeTo_Directory("FCAL", "FCAL");

locHistName = "BetaVsP_q0";
locHistTitle = "FCAL q^{0};Shower Energy (GeV);#beta";
dHistMap_BetaVsP[SYS_FCAL][0] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DBetaBins, dMinBeta, dMaxBeta);

locHistName = "DeltaTVsShowerE_Photon";
locHistTitle = string("FCAL ") + locParticleROOTName + string(";Shower Energy (GeV);#Deltat_{FCAL - RF}");
dHistMap_DeltaTVsP[SYS_FCAL][Gamma] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DDeltaTBins, dMinDeltaT, dMaxDeltaT);

1742/*
//Uncomment when ready!
locHistName = "TimePullVsShowerE_Photon";
locHistTitle = string("FCAL ") + locParticleROOTName + string(";Shower Energy (GeV);#Deltat/#sigma_{#Deltat}");
dHistMap_TimePullVsP[SYS_FCAL][Gamma] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DPullBins, dMinPull, dMaxPull);

locHistName = "TimeFOMVsShowerE_Photon";
locHistTitle = string("FCAL ") + locParticleROOTName + string(";Shower Energy (GeV);Timing PID Confidence Level");
dHistMap_TimeFOMVsP[SYS_FCAL][Gamma] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DFOMBins, 0.0, 1.0);
1751*/

gDirectory(TDirectory::CurrentDirectory())->cd("..");

//CCAL
CreateAndChangeTo_Directory("CCAL", "CCAL");

locHistName = "BetaVsP_q0";
locHistTitle = "CCAL q^{0};Shower Energy (GeV);#beta";
dHistMap_BetaVsP[SYS_CCAL][0] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DBetaBins, dMinBeta, dMaxBeta);

locHistName = "DeltaTVsShowerE_Photon";
locHistTitle = string("CCAL ") + locParticleROOTName + string(";Shower Energy (GeV);#Deltat_{CCAL - RF}");
dHistMap_DeltaTVsP[SYS_CCAL][Gamma] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DDeltaTBins, dMinDeltaT, dMaxDeltaT);

gDirectory(TDirectory::CurrentDirectory())->cd("..");

//q +/-
for(int locCharge = -1; locCharge <= 1; locCharge += 2)
{
	string locParticleName = (locCharge == -1) ? "q-" : "q+";
	string locParticleROOTName = (locCharge == -1) ? "q^{-}" : "q^{+}";

	//SC
	CreateAndChangeTo_Directory("SC", "SC");

	locHistName = string("dEdXVsP_") + locParticleName;
	locHistTitle = locParticleROOTName + ";p (GeV/c);SC dE/dX (MeV/cm)";
	dHistMap_dEdXVsP[SYS_START][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DdEdxBins, dMindEdX, dMaxdEdX);

	locHistName = string("BetaVsP_") + locParticleName;
	locHistTitle = string("SC ") + locParticleROOTName + string(";p (GeV/c);#beta");
	dHistMap_BetaVsP[SYS_START][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DBetaBins, dMinBeta, dMaxBeta);

	gDirectory(TDirectory::CurrentDirectory())->cd("..");

	//TOF
	CreateAndChangeTo_Directory("TOF", "TOF");

	locHistName = string("dEdXVsP_") + locParticleName;
	locHistTitle = locParticleROOTName + ";p (GeV/c);TOF dE/dX (MeV/cm)";
	dHistMap_dEdXVsP[SYS_TOF][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DdEdxBins, dMindEdX, dMaxdEdX);

	locHistName = string("BetaVsP_") + locParticleName;
	locHistTitle = string("TOF ") + locParticleROOTName + string(";p (GeV/c);#beta");
	dHistMap_BetaVsP[SYS_TOF][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DBetaBins, dMinBeta, dMaxBeta);

	gDirectory(TDirectory::CurrentDirectory())->cd("..");

	//BCAL
	CreateAndChangeTo_Directory("BCAL", "BCAL");

	locHistName = string("BetaVsP_") + locParticleName;
	locHistTitle = string("BCAL ") + locParticleROOTName + string(";p (GeV/c);#beta");
	dHistMap_BetaVsP[SYS_BCAL][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxBCALP, dNum2DBetaBins, dMinBeta, dMaxBeta);

	locHistName = string("EOverPVsP_") + locParticleName;
	locHistTitle = string("BCAL ") + locParticleROOTName + string(";p (GeV/c);E_{Shower}/p_{Track} (c);");
	dHistMap_BCALEOverPVsP[locCharge] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxBCALP, dNum2DEOverPBins, dMinEOverP, dMaxEOverP);

	locHistName = string("EOverPVsTheta_") + locParticleName;
	locHistTitle = string("BCAL ") + locParticleROOTName + string(";#theta#circ;E_{Shower}/p_{Track} (c);");
	dHistMap_BCALEOverPVsTheta[locCharge] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DBCALThetaBins, dMinBCALTheta, dMaxBCALTheta, dNum2DEOverPBins, dMinEOverP, dMaxEOverP);

	gDirectory(TDirectory::CurrentDirectory())->cd("..");

	//FCAL
	CreateAndChangeTo_Directory("FCAL", "FCAL");

	locHistName = string("BetaVsP_") + locParticleName;
	locHistTitle = string("FCAL ") + locParticleROOTName + string(";p (GeV/c);#beta");
	dHistMap_BetaVsP[SYS_FCAL][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DBetaBins, dMinBeta, dMaxBeta);

	locHistName = string("EOverPVsP_") + locParticleName;
	locHistTitle = string("FCAL ") + locParticleROOTName + string(";p (GeV/c);E_{Shower}/p_{Track} (c);");
	dHistMap_FCALEOverPVsP[locCharge] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DEOverPBins, dMinEOverP, dMaxEOverP);

	locHistName = string("EOverPVsTheta_") + locParticleName;
	locHistTitle = string("FCAL ") + locParticleROOTName + string(";#theta#circ;E_{Shower}/p_{Track} (c);");
	dHistMap_FCALEOverPVsTheta[locCharge] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DFCALThetaBins, dMinFCALTheta, dMaxFCALTheta, dNum2DEOverPBins, dMinEOverP, dMaxEOverP);

	gDirectory(TDirectory::CurrentDirectory())->cd("..");

	//CDC
	CreateAndChangeTo_Directory("CDC", "CDC");

	locHistName = string("dEdXVsP_Int_") + locParticleName;
	locHistTitle = locParticleROOTName + string(";p (GeV/c);CDC dE/dx [Integral-based] (keV/cm)");
	dHistMap_dEdXVsP[SYS_CDC][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DdEdxBins, dMindEdX, dMaxdEdX);
	locHistName = string("dEdXVsP_Amp_") + locParticleName;
	locHistTitle = locParticleROOTName + string(";p (GeV/c);CDC dE/dx [Amplitude-based] (keV/cm)");
	dHistMap_dEdXVsP[SYS_CDC_AMP][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DdEdxBins, dMindEdX, dMaxdEdX);

	gDirectory(TDirectory::CurrentDirectory())->cd("..");

	//FDC
	CreateAndChangeTo_Directory("FDC", "FDC");

	locHistName = string("dEdXVsP_") + locParticleName;
	locHistTitle = locParticleROOTName + string(";p (GeV/c);FDC dE/dx (keV/cm)");
	dHistMap_dEdXVsP[SYS_FDC][locCharge] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DdEdxBins, dMindEdX, dMaxdEdX);

	gDirectory(TDirectory::CurrentDirectory())->cd("..");
}

//delta's by PID
for(size_t loc_i = 0; loc_i < dFinalStatePIDs.size(); ++loc_i)
{
	Particle_t locPID = dFinalStatePIDs[loc_i];
	string locParticleName = ParticleType(locPID);
	string locParticleROOTName = ParticleName_ROOT(locPID);

	//SC
	CreateAndChangeTo_Directory("SC", "SC");

	locHistName = string("DeltadEdXVsP_") + locParticleName;
	locHistTitle = locParticleROOTName + " Candidates;p (GeV/c);SC #Delta(dE/dX) (MeV/cm)";
	dHistMap_DeltadEdXVsP[SYS_START][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DDeltadEdxBins, dMinDeltadEdx, dMaxDeltadEdx);

	locHistName = string("DeltaBetaVsP_") + locParticleName;
	locHistTitle = string("SC ") + locParticleROOTName + string(" Candidates;p (GeV/c);#Delta#beta");
	dHistMap_DeltaBetaVsP[SYS_START][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DDeltaBetaBins, dMinDeltaBeta, dMaxDeltaBeta);

	locHistName = string("DeltaTVsP_") + locParticleName;
	locHistTitle = string("SC ") + locParticleROOTName + string(" Candidates;p (GeV/c);#Deltat_{SC - RF}");
	dHistMap_DeltaTVsP[SYS_START][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DDeltaTBins, dMinDeltaT, dMaxDeltaT);

1878/*
	//Uncomment when ready!
	locHistName = string("TimePullVsP_") + locParticleName;
	locHistTitle = string("SC ") + locParticleROOTName + string(" Candidates;p (GeV/c);#Deltat/#sigma_{#Deltat}");
	dHistMap_TimePullVsP[SYS_START][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DPullBins, dMinPull, dMaxPull);

	locHistName = string("TimeFOMVsP_") + locParticleName;
	locHistTitle = string("SC ") + locParticleROOTName + string(" Candidates;p (GeV/c);Timing PID Confidence Level");
	dHistMap_TimeFOMVsP[SYS_START][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DFOMBins, 0.0, 1.0);
1887*/
	gDirectory(TDirectory::CurrentDirectory())->cd("..");

	//TOF
	CreateAndChangeTo_Directory("TOF", "TOF");

	locHistName = string("DeltadEdXVsP_") + locParticleName;
	locHistTitle = locParticleROOTName + " Candidates;p (GeV/c);TOF #Delta(dE/dX) (MeV/cm)";
	dHistMap_DeltadEdXVsP[SYS_TOF][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DDeltadEdxBins, dMinDeltadEdx, dMaxDeltadEdx);

	locHistName = string("DeltaBetaVsP_") + locParticleName;
	locHistTitle = string("TOF ") + locParticleROOTName + string(" Candidates;p (GeV/c);#Delta#beta");
	dHistMap_DeltaBetaVsP[SYS_TOF][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DDeltaBetaBins, dMinDeltaBeta, dMaxDeltaBeta);

	locHistName = string("DeltaTVsP_") + locParticleName;
	locHistTitle = string("TOF ") + locParticleROOTName + string(" Candidates;p (GeV/c);#Deltat_{TOF - RF}");
	dHistMap_DeltaTVsP[SYS_TOF][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DDeltaTBins, dMinDeltaT, dMaxDeltaT);

1905/*
	//Uncomment when ready!
	locHistName = string("TimePullVsP_") + locParticleName;
	locHistTitle = string("TOF ") + locParticleROOTName + string(" Candidates;p (GeV/c);#Deltat/#sigma_{#Deltat}");
	dHistMap_TimePullVsP[SYS_TOF][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DPullBins, dMinPull, dMaxPull);

	locHistName = string("TimeFOMVsP_") + locParticleName;
	locHistTitle = string("TOF ") + locParticleROOTName + string(" Candidates;p (GeV/c);Timing PID Confidence Level");
	dHistMap_TimeFOMVsP[SYS_TOF][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DFOMBins, 0.0, 1.0);
1914*/
	gDirectory(TDirectory::CurrentDirectory())->cd("..");

	//BCAL
	CreateAndChangeTo_Directory("BCAL", "BCAL");

	locHistName = string("DeltaBetaVsP_") + locParticleName;
	locHistTitle = string("BCAL ") + locParticleROOTName + string(" Candidates;p (GeV/c);#Delta#beta");
	dHistMap_DeltaBetaVsP[SYS_BCAL][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxBCALP, dNum2DDeltaBetaBins, dMinDeltaBeta, dMaxDeltaBeta);

	locHistName = string("DeltaTVsP_") + locParticleName;
	locHistTitle = string("BCAL ") + locParticleROOTName + string(" Candidates;p (GeV/c);#Deltat_{BCAL - RF}");
	dHistMap_DeltaTVsP[SYS_BCAL][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DDeltaTBins, dMinDeltaT, dMaxDeltaT);

1928/*
	//Uncomment when ready!
	locHistName = string("TimePullVsP_") + locParticleName;
	locHistTitle = string("BCAL ") + locParticleROOTName + string(" Candidates;p (GeV/c);#Deltat/#sigma_{#Deltat}");
	dHistMap_TimePullVsP[SYS_BCAL][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DPullBins, dMinPull, dMaxPull);

	locHistName = string("TimeFOMVsP_") + locParticleName;
	locHistTitle = string("BCAL ") + locParticleROOTName + string(" Candidates;p (GeV/c);Timing PID Confidence Level");
	dHistMap_TimeFOMVsP[SYS_BCAL][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DFOMBins, 0.0, 1.0);
1937*/
	gDirectory(TDirectory::CurrentDirectory())->cd("..");

	//FCAL
	CreateAndChangeTo_Directory("FCAL", "FCAL");

	locHistName = string("DeltaBetaVsP_") + locParticleName;
	locHistTitle = string("FCAL ") + locParticleROOTName + string(" Candidates;p (GeV/c);#Delta#beta");
	dHistMap_DeltaBetaVsP[SYS_FCAL][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DDeltaBetaBins, dMinDeltaBeta, dMaxDeltaBeta);

	locHistName = string("DeltaTVsP_") + locParticleName;
	locHistTitle = string("FCAL ") + locParticleROOTName + string(" Candidates;p (GeV/c);#Deltat_{FCAL - RF}");
	dHistMap_DeltaTVsP[SYS_FCAL][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DDeltaTBins, dMinDeltaT, dMaxDeltaT);

1951/*
	//Uncomment when ready!
	locHistName = string("TimePullVsP_") + locParticleName;
	locHistTitle = string("FCAL ") + locParticleROOTName + string(" Candidates;p (GeV/c);#Deltat/#sigma_{#Deltat}");
	dHistMap_TimePullVsP[SYS_FCAL][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DPullBins, dMinPull, dMaxPull);

	locHistName = string("TimeFOMVsP_") + locParticleName;
	locHistTitle = string("FCAL ") + locParticleROOTName + string(" Candidates;p (GeV/c);Timing PID Confidence Level");
	dHistMap_TimeFOMVsP[SYS_FCAL][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DFOMBins, 0.0, 1.0);
1960*/

	gDirectory(TDirectory::CurrentDirectory())->cd("..");

	//CCAL
	CreateAndChangeTo_Directory("CCAL", "CCAL");

	locHistName = string("DeltaBetaVsP_") + locParticleName;
	locHistTitle = string("CCAL ") + locParticleROOTName + string(" Candidates;p (GeV/c);#Delta#beta");
	dHistMap_DeltaBetaVsP[SYS_CCAL][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DDeltaBetaBins, dMinDeltaBeta, dMaxDeltaBeta);

	locHistName = string("DeltaTVsP_") + locParticleName;
	locHistTitle = string("CCAL ") + locParticleROOTName + string(" Candidates;p (GeV/c);#Deltat_{CCAL - RF}");
	dHistMap_DeltaTVsP[SYS_CCAL][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DDeltaTBins, dMinDeltaT, dMaxDeltaT);

	gDirectory(TDirectory::CurrentDirectory())->cd("..");

	//CDC
	CreateAndChangeTo_Directory("CDC", "CDC");

	locHistName = string("DeltadEdXVsP_Int_") + locParticleName;
	locHistTitle = locParticleROOTName + string(" Candidates;p (GeV/c);CDC #Delta(dE/dX) [Integral-based] (keV/cm)");
	dHistMap_DeltadEdXVsP[SYS_CDC][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DDeltadEdxBins, dMinDeltadEdx, dMaxDeltadEdx);

	locHistName = string("DeltadEdXVsP_Amp_") + locParticleName;
	locHistTitle = locParticleROOTName + string(" Candidates;p (GeV/c);CDC #Delta(dE/dX) [Amplitude-based] (keV/cm)");
	dHistMap_DeltadEdXVsP[SYS_CDC_AMP][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DDeltadEdxBins, dMinDeltadEdx, dMaxDeltadEdx);

1988/*
	//Uncomment when ready!
	locHistName = string("dEdXPullVsP_") + locParticleName;
	locHistTitle = locParticleROOTName + string(" Candidates;p (GeV/c);CDC #Delta(dE/dX)/#sigma_{#Delta(dE/dX)}");
	dHistMap_dEdXPullVsP[SYS_CDC][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DPullBins, dMinPull, dMaxPull);

	locHistName = string("dEdXFOMVsP_") + locParticleName;
	locHistTitle = locParticleROOTName + string(" Candidates;p (GeV/c);CDC dE/dx PID Confidence Level");
	dHistMap_dEdXFOMVsP[SYS_CDC][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DFOMBins, 0.0, 1.0);
1997*/
	gDirectory(TDirectory::CurrentDirectory())->cd("..");

	//FDC
	CreateAndChangeTo_Directory("FDC", "FDC");

	locHistName = string("DeltadEdXVsP_") + locParticleName;
	locHistTitle = locParticleROOTName + string(" Candidates;p (GeV/c);FDC #Delta(dE/dX) (keV/cm)");
	dHistMap_DeltadEdXVsP[SYS_FDC][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DDeltadEdxBins, dMinDeltadEdx, dMaxDeltadEdx);

2007/*
	//Uncomment when ready!
	locHistName = string("dEdXPullVsP_") + locParticleName;
	locHistTitle = locParticleROOTName + string(" Candidates;p (GeV/c);FDC #Delta(dE/dX)/#sigma_{#Delta(dE/dX)}");
	dHistMap_dEdXPullVsP[SYS_FDC][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DPullBins, dMinPull, dMaxPull);

	locHistName = string("dEdXFOMVsP_") + locParticleName;
	locHistTitle = locParticleROOTName + string(" Candidates;p (GeV/c);FDC dE/dx PID Confidence Level");
	dHistMap_dEdXFOMVsP[SYS_FDC][locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DFOMBins, 0.0, 1.0);
2016*/
	gDirectory(TDirectory::CurrentDirectory())->cd("..");

	// DIRC
	CreateAndChangeTo_Directory("DIRC", "DIRC");
	
	locHistName = string("NumPhotons_") + locParticleName;
	locHistTitle = locParticleROOTName + string("; DIRC NumPhotons");
	dHistMap_NumPhotons_DIRC[locPID] = new TH1I(locHistName.c_str(), locHistTitle.c_str(), dDIRCNumPhotonsBins, dDIRCMinNumPhotons, dDIRCMaxNumPhotons);
	
	locHistName = string("ThetaCVsP_") + locParticleName;
	locHistTitle = locParticleROOTName + string("; Momentum (GeV); DIRC #theta_{C}");
	dHistMap_ThetaCVsP_DIRC[locPID] = new TH2I(locHistName.c_str(), locHistTitle.c_str(), dNum2DPBins, dMinP, dMaxP, dDIRCThetaCBins, dDIRCMinThetaC, dDIRCMaxThetaC);
	
	locHistName = string("Ldiff_kpiVsP_") + locParticleName;
	locHistTitle = locParticleROOTName + string("; Momentum (GeV); DIRC L_{K}-L_{#pi}");
	dHistMap_Ldiff_kpiVsP_DIRC[locPID] = new TH2I(locHistName.c_str(), locHistTitle.c_str(), dNum2DPBins, dMinP, dMaxP, dDIRCLikelihoodBins, -1*dDIRCMaxLikelihood, dDIRCMaxLikelihood);

	locHistName = string("Ldiff_pkVsP_") + locParticleName;
	locHistTitle = locParticleROOTName + string("; Momentum (GeV); DIRC L_{p}-L_{K}");
	dHistMap_Ldiff_pkVsP_DIRC[locPID] = new TH2I(locHistName.c_str(), locHistTitle.c_str(), dNum2DPBins, dMinP, dMaxP, dDIRCLikelihoodBins, -1*dDIRCMaxLikelihood, dDIRCMaxLikelihood);

	gDirectory(TDirectory::CurrentDirectory())->cd("..");
}

//Return to the base directory
ChangeTo_BaseDirectory();
}
japp->RootUnLock(); //RELEASE ROOT LOCK!!
2045}

2047bool DHistogramAction_DetectorPID::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
2048{
//Expect locParticleCombo to be NULL since this is a reaction-independent action.

if(Get_CalledPriorWithComboFlag())
return true; //else double-counting!

vector<const DChargedTrack*> locChargedTracks;
locEventLoop->Get(locChargedTracks, dTrackSelectionTag.c_str());

vector<const DNeutralParticle*> locNeutralParticles;
locEventLoop->Get(locNeutralParticles, dShowerSelectionTag.c_str());

const DDetectorMatches* locDetectorMatches = NULL__null;
locEventLoop->GetSingle(locDetectorMatches);

const DEventRFBunch* locEventRFBunch = NULL__null;
locEventLoop->GetSingle(locEventRFBunch);

const DParticleID* locParticleID = NULL__null;
locEventLoop->GetSingle(locParticleID);

//FILL HISTOGRAMS
//Since we are filling histograms local to this action, it will not interfere with other ROOT operations: can use action-wide ROOT lock
//Note, the mutex is unique to this DReaction + action_string combo: actions of same class with different hists will have a different mutex
Lock_Action(); //ACQUIRE ROOT LOCK!!
{
if(locEventRFBunch->dTimeSource != SYS_NULL) //only histogram beta for neutrals if the t0 is well known
{
	for(size_t loc_i = 0; loc_i < locNeutralParticles.size(); ++loc_i)
	{
		//doesn't matter which hypothesis you use for beta: t0 is from DEventVertex time
		const DNeutralParticleHypothesis* locNeutralParticleHypothesis = locNeutralParticles[loc_i]->Get_BestFOM();
		double locBeta_Timing = locNeutralParticleHypothesis->measuredBeta();
		const DNeutralShower* locNeutralShower = locNeutralParticles[loc_i]->dNeutralShower;
		double locShowerEnergy = locNeutralShower->dEnergy;

		double locDeltaT = locNeutralParticleHypothesis->time() - locEventRFBunch->dTime;
		if(locNeutralShower->dDetectorSystem == SYS_BCAL)
		{
			dHistMap_BetaVsP[SYS_BCAL][0]->Fill(locShowerEnergy, locBeta_Timing);
			dHistMap_DeltaTVsP[SYS_BCAL][Gamma]->Fill(locShowerEnergy, locDeltaT);
		}
		else if(locNeutralShower->dDetectorSystem == SYS_FCAL)
		{
			dHistMap_BetaVsP[SYS_FCAL][0]->Fill(locShowerEnergy, locBeta_Timing);
			dHistMap_DeltaTVsP[SYS_FCAL][Gamma]->Fill(locShowerEnergy, locDeltaT);
		}
		else if(locNeutralShower->dDetectorSystem == SYS_CCAL)
		{
			dHistMap_BetaVsP[SYS_CCAL][0]->Fill(locShowerEnergy, locBeta_Timing);
			dHistMap_DeltaTVsP[SYS_CCAL][Gamma]->Fill(locShowerEnergy, locDeltaT);
		}
	}
}

for(size_t loc_i = 0; loc_i < locChargedTracks.size(); ++loc_i)
{
	const DChargedTrackHypothesis* locChargedTrackHypothesis = locChargedTracks[loc_i]->Get_BestTrackingFOM();
	int locCharge = ParticleCharge(locChargedTrackHypothesis->PID());
	if(dHistMap_dEdXVsP[SYS_START].find(locCharge) == dHistMap_dEdXVsP[SYS_START].end())
		continue;

	double locStartTime = locParticleID->Calc_PropagatedRFTime(locChargedTrackHypothesis, locEventRFBunch);
	auto locTrackTimeBased = locChargedTrackHypothesis->Get_TrackTimeBased();

	Particle_t locPID = locChargedTrackHypothesis->PID();
	double locP = locTrackTimeBased->momentum().Mag();
	double locTheta = locTrackTimeBased->momentum().Theta()*180.0/TMath::Pi();

	//if RF time is indeterminate, start time will be NaN
	auto locBCALShowerMatchParams = locChargedTrackHypothesis->Get_BCALShowerMatchParams();
	auto locFCALShowerMatchParams = locChargedTrackHypothesis->Get_FCALShowerMatchParams();
	auto locTOFHitMatchParams = locChargedTrackHypothesis->Get_TOFHitMatchParams();
	auto locSCHitMatchParams = locChargedTrackHypothesis->Get_SCHitMatchParams();
	auto locDIRCMatchParams = locChargedTrackHypothesis->Get_DIRCMatchParams();

	if(locSCHitMatchParams != NULL__null)
	{
		dHistMap_dEdXVsP[SYS_START][locCharge]->Fill(locP, locSCHitMatchParams->dEdx*1.0E3);
		if((locEventRFBunch->dTimeSource != SYS_START) && (locEventRFBunch->dNumParticleVotes > 1))
		{
			//If SC was used for RF time, don't compute delta-beta
			double locBeta_Timing = locSCHitMatchParams->dPathLength/(29.9792458*(locSCHitMatchParams->dHitTime - locChargedTrackHypothesis->t0()));
			dHistMap_BetaVsP[SYS_START][locCharge]->Fill(locP, locBeta_Timing);
			if(dHistMap_DeltaBetaVsP[SYS_START].find(locPID) != dHistMap_DeltaBetaVsP[SYS_START].end())
			{
				double locDeltaBeta = locChargedTrackHypothesis->lorentzMomentum().Beta() - locBeta_Timing;
				dHistMap_DeltaBetaVsP[SYS_START][locPID]->Fill(locP, locDeltaBeta);
				double locDeltaT = locSCHitMatchParams->dHitTime - locSCHitMatchParams->dFlightTime - locStartTime;
				dHistMap_DeltaTVsP[SYS_START][locPID]->Fill(locP, locDeltaT);
			}
		}
		if(dHistMap_DeltadEdXVsP[SYS_START].find(locPID) != dHistMap_DeltadEdXVsP[SYS_START].end())
		{
			double locdx = locSCHitMatchParams->dHitEnergy/locSCHitMatchParams->dEdx;
			double locProbabledEdx = 0.0, locSigmadEdx = 0.0;
			locParticleID->GetScintMPdEandSigma(locP, locChargedTrackHypothesis->mass(), locdx, locProbabledEdx, locSigmadEdx);
			dHistMap_DeltadEdXVsP[SYS_START][locPID]->Fill(locP, (locSCHitMatchParams->dEdx - locProbabledEdx)*1.0E3);
		}
	}
	if(locTOFHitMatchParams != NULL__null)
	{
		dHistMap_dEdXVsP[SYS_TOF][locCharge]->Fill(locP, locTOFHitMatchParams->dEdx*1.0E3);
		if(locEventRFBunch->dNumParticleVotes > 1)
		{
			double locBeta_Timing = locTOFHitMatchParams->dPathLength/(29.9792458*(locTOFHitMatchParams->dHitTime - locChargedTrackHypothesis->t0()));
			dHistMap_BetaVsP[SYS_TOF][locCharge]->Fill(locP, locBeta_Timing);
			if(dHistMap_DeltaBetaVsP[SYS_TOF].find(locPID) != dHistMap_DeltaBetaVsP[SYS_TOF].end())
			{
				double locDeltaBeta = locChargedTrackHypothesis->lorentzMomentum().Beta() - locBeta_Timing;
				dHistMap_DeltaBetaVsP[SYS_TOF][locPID]->Fill(locP, locDeltaBeta);
				double locDeltaT = locTOFHitMatchParams->dHitTime - locTOFHitMatchParams->dFlightTime - locStartTime;
				dHistMap_DeltaTVsP[SYS_TOF][locPID]->Fill(locP, locDeltaT);
			}
		}
		if(dHistMap_DeltadEdXVsP[SYS_TOF].find(locPID) != dHistMap_DeltadEdXVsP[SYS_TOF].end())
		{
			double locdx = locTOFHitMatchParams->dHitEnergy/locTOFHitMatchParams->dEdx;
			double locProbabledEdx = 0.0, locSigmadEdx = 0.0;
			locParticleID->GetScintMPdEandSigma(locP, locChargedTrackHypothesis->mass(), locdx, locProbabledEdx, locSigmadEdx);
			dHistMap_DeltadEdXVsP[SYS_TOF][locPID]->Fill(locP, (locTOFHitMatchParams->dEdx - locProbabledEdx)*1.0E3);
		}
	}
	if(locBCALShowerMatchParams != NULL__null)
	{
		const DBCALShower* locBCALShower = locBCALShowerMatchParams->dBCALShower;
		double locEOverP = locBCALShower->E/locP;
		dHistMap_BCALEOverPVsP[locCharge]->Fill(locP, locEOverP);
		dHistMap_BCALEOverPVsTheta[locCharge]->Fill(locTheta, locEOverP);
		if(locEventRFBunch->dNumParticleVotes > 1)
		{
			double locBeta_Timing = locBCALShowerMatchParams->dPathLength/(29.9792458*(locBCALShower->t - locChargedTrackHypothesis->t0()));
			dHistMap_BetaVsP[SYS_BCAL][locCharge]->Fill(locP, locBeta_Timing);
			if(dHistMap_DeltaBetaVsP[SYS_BCAL].find(locPID) != dHistMap_DeltaBetaVsP[SYS_BCAL].end())
			{
				double locDeltaBeta = locChargedTrackHypothesis->lorentzMomentum().Beta() - locBeta_Timing;
				dHistMap_DeltaBetaVsP[SYS_BCAL][locPID]->Fill(locP, locDeltaBeta);
				double locDeltaT = locBCALShower->t - locBCALShowerMatchParams->dFlightTime - locStartTime;
				dHistMap_DeltaTVsP[SYS_BCAL][locPID]->Fill(locP, locDeltaT);
			}
		}
	}
	if(locFCALShowerMatchParams != NULL__null)
	{
		const DFCALShower* locFCALShower = locFCALShowerMatchParams->dFCALShower;
		double locEOverP = locFCALShower->getEnergy()/locP;
		dHistMap_FCALEOverPVsP[locCharge]->Fill(locP, locEOverP);
		dHistMap_FCALEOverPVsTheta[locCharge]->Fill(locTheta, locEOverP);
		if(locEventRFBunch->dNumParticleVotes > 1)
		{
			double locBeta_Timing = locFCALShowerMatchParams->dPathLength/(29.9792458*(locFCALShower->getTime() - locChargedTrackHypothesis->t0()));
			dHistMap_BetaVsP[SYS_FCAL][locCharge]->Fill(locP, locBeta_Timing);
			if(dHistMap_DeltaBetaVsP[SYS_FCAL].find(locPID) != dHistMap_DeltaBetaVsP[SYS_FCAL].end())
			{
				double locDeltaBeta = locChargedTrackHypothesis->lorentzMomentum().Beta() - locBeta_Timing;
				dHistMap_DeltaBetaVsP[SYS_FCAL][locPID]->Fill(locP, locDeltaBeta);
				double locDeltaT = locFCALShower->getTime() - locFCALShowerMatchParams->dFlightTime - locStartTime;
				dHistMap_DeltaTVsP[SYS_FCAL][locPID]->Fill(locP, locDeltaT);
			}
		}
	}
	if(locDIRCMatchParams != NULL__null && (dHistMap_NumPhotons_DIRC.find(locPID) != dHistMap_NumPhotons_DIRC.end())) {
		int locNumPhotons_DIRC = locDIRCMatchParams->dNPhotons;
		double locThetaC_DIRC = locDIRCMatchParams->dThetaC;
		dHistMap_NumPhotons_DIRC[locPID]->Fill(locNumPhotons_DIRC);
		dHistMap_ThetaCVsP_DIRC[locPID]->Fill(locP, locThetaC_DIRC);
		double locLpi_DIRC = locDIRCMatchParams->dLikelihoodPion;
		double locLk_DIRC = locDIRCMatchParams->dLikelihoodKaon;
		double locLp_DIRC = locDIRCMatchParams->dLikelihoodProton;
		dHistMap_Ldiff_kpiVsP_DIRC[locPID]->Fill(locP, locLk_DIRC-locLpi_DIRC);
		dHistMap_Ldiff_pkVsP_DIRC[locPID]->Fill(locP, locLp_DIRC-locLk_DIRC);
	}

	if(locTrackTimeBased->dNumHitsUsedFordEdx_CDC > 0)
	{
		dHistMap_dEdXVsP[SYS_CDC][locCharge]->Fill(locP, locTrackTimeBased->ddEdx_CDC*1.0E6);
		dHistMap_dEdXVsP[SYS_CDC_AMP][locCharge]->Fill(locP, locTrackTimeBased->ddEdx_CDC_amp*1.0E6);
		if(dHistMap_DeltadEdXVsP[SYS_CDC].find(locPID) != dHistMap_DeltadEdXVsP[SYS_CDC].end())
		{
			double locProbabledEdx = locParticleID->GetMostProbabledEdx_DC(locP, locChargedTrackHypothesis->mass(), locTrackTimeBased->ddx_CDC, true);
			dHistMap_DeltadEdXVsP[SYS_CDC][locPID]->Fill(locP, (locTrackTimeBased->ddEdx_CDC - locProbabledEdx)*1.0E6);
		}
		if(dHistMap_DeltadEdXVsP[SYS_CDC_AMP].find(locPID) != dHistMap_DeltadEdXVsP[SYS_CDC_AMP].end())
		{
			double locProbabledEdx = locParticleID->GetMostProbabledEdx_DC(locP, locChargedTrackHypothesis->mass(), locTrackTimeBased->ddx_CDC_amp, true);
			dHistMap_DeltadEdXVsP[SYS_CDC_AMP][locPID]->Fill(locP, (locTrackTimeBased->ddEdx_CDC_amp - locProbabledEdx)*1.0E6);
		}
	}
	if(locTrackTimeBased->dNumHitsUsedFordEdx_FDC > 0)
	{
		dHistMap_dEdXVsP[SYS_FDC][locCharge]->Fill(locP, locTrackTimeBased->ddEdx_FDC*1.0E6);
		if(dHistMap_DeltadEdXVsP[SYS_FDC].find(locPID) != dHistMap_DeltadEdXVsP[SYS_FDC].end())
		{
			double locProbabledEdx = locParticleID->GetMostProbabledEdx_DC(locP, locChargedTrackHypothesis->mass(), locTrackTimeBased->ddx_FDC, false);
			dHistMap_DeltadEdXVsP[SYS_FDC][locPID]->Fill(locP, (locTrackTimeBased->ddEdx_FDC - locProbabledEdx)*1.0E6);
		}
	}
}
}
Unlock_Action(); //RELEASE ROOT LOCK!!

return true; //return false if you want to use this action to apply a cut (and it fails the cut!)
2250}

2252void DHistogramAction_Neutrals::Initialize(JEventLoop* locEventLoop)
2253{
//Create any histograms/trees/etc. within a ROOT lock.
//This is so that when running multithreaded, only one thread is writing to the ROOT file at a time.

//When creating a reaction-independent action, only modify member variables within a ROOT lock.
//Objects created within a plugin (such as reaction-independent actions) can be accessed by many threads simultaneously.

Run_Update(locEventLoop);

string locHistName;

//CREATE THE HISTOGRAMS
//Since we are creating histograms, the contents of gDirectory will be modified: must use JANA-wide ROOT lock
japp->RootWriteLock(); //ACQUIRE ROOT LOCK!!
{
//Required: Create a folder in the ROOT output file that will contain all of the output ROOT objects (if any) for this action.
	//If another thread has already created the folder, it just changes to it.
CreateAndChangeTo_ActionDirectory();


//BCAL
locHistName = "BCALTrackDOCA";
dHist_BCALTrackDOCA = GetOrCreate_Histogram<TH1I>(locHistName, ";BCAL Shower Distance to Nearest Track (cm)", dNumTrackDOCABins, dMinTrackDOCA, dMaxTrackDOCA);
locHistName = "BCALTrackDeltaPhi";
dHist_BCALTrackDeltaPhi = GetOrCreate_Histogram<TH1I>(locHistName, ";BCAL Shower #Delta#phi#circ to Nearest Track", dNumDeltaPhiBins, dMinDeltaPhi, dMaxDeltaPhi);
locHistName = "BCALTrackDeltaZ";
dHist_BCALTrackDeltaZ = GetOrCreate_Histogram<TH1I>(locHistName, ";BCAL Shower #DeltaZ to Nearest Track (cm)", dNumTrackDOCABins, dMinTrackDOCA, dMaxTrackDOCA);
locHistName = "BCALNeutralShowerEnergy";
dHist_BCALNeutralShowerEnergy = GetOrCreate_Histogram<TH1I>(locHistName, ";BCAL Neutral Shower Energy (GeV)", dNumShowerEnergyBins, dMinShowerEnergy, dMaxShowerEnergy);
locHistName = "BCALNeutralShowerDeltaT";
dHist_BCALNeutralShowerDeltaT = GetOrCreate_Histogram<TH1I>(locHistName, ";BCAL Neutral Shower #Deltat (Propagated - RF) (ns)", dNumDeltaTBins, dMinDeltaT, dMaxDeltaT);
locHistName = "BCALNeutralShowerDeltaTVsE";
dHist_BCALNeutralShowerDeltaTVsE = GetOrCreate_Histogram<TH2I>(locHistName, ";BCAL Neutral Shower Energy (GeV);BCAL Neutral Shower #Deltat (ns)", dNum2DShowerEnergyBins, dMinShowerEnergy, dMaxShowerEnergy, dNum2DDeltaTBins, dMinDeltaT, dMaxDeltaT);
locHistName = "BCALNeutralShowerDeltaTVsZ";
dHist_BCALNeutralShowerDeltaTVsZ = GetOrCreate_Histogram<TH2I>(locHistName, ";BCAL Neutral Shower Z (cm);BCAL Neutral Shower #Deltat (ns)", dNum2DBCALZBins, 0.0, 450.0, dNum2DDeltaTBins, dMinDeltaT, dMaxDeltaT);

//FCAL
locHistName = "FCALTrackDOCA";
dHist_FCALTrackDOCA = GetOrCreate_Histogram<TH1I>(locHistName, ";FCAL Shower Distance to Nearest Track (cm)", dNumTrackDOCABins, dMinTrackDOCA, dMaxTrackDOCA);
locHistName = "FCALNeutralShowerEnergy";
dHist_FCALNeutralShowerEnergy = GetOrCreate_Histogram<TH1I>(locHistName, ";FCAL Neutral Shower Energy (GeV)", dNumShowerEnergyBins, dMinShowerEnergy, dMaxShowerEnergy);
locHistName = "FCALNeutralShowerDeltaT";
dHist_FCALNeutralShowerDeltaT = GetOrCreate_Histogram<TH1I>(locHistName, ";FCAL Neutral Shower #Deltat (Propagated - RF) (ns)", dNumDeltaTBins, dMinDeltaT, dMaxDeltaT);
locHistName = "FCALNeutralShowerDeltaTVsE";
dHist_FCALNeutralShowerDeltaTVsE = GetOrCreate_Histogram<TH2I>(locHistName, ";FCAL Neutral Shower Energy (GeV);FCAL Neutral Shower #Deltat (ns)", dNum2DShowerEnergyBins, dMinShowerEnergy, dMaxShowerEnergy, dNum2DDeltaTBins, dMinDeltaT, dMaxDeltaT);


//CCAL
//locHistName = "CCALTrackDOCA";
//dHist_CCALTrackDOCA = GetOrCreate_Histogram<TH1I>(locHistName, ";CCAL Shower Distance to Nearest Track (cm)", dNumTrackDOCABins, dMinTrackDOCA, dMaxTrackDOCA);
locHistName = "CCALNeutralShowerEnergy";
dHist_CCALNeutralShowerEnergy = GetOrCreate_Histogram<TH1I>(locHistName, ";CCAL Neutral Shower Energy (GeV)", dNumShowerEnergyBins, dMinShowerEnergy, dMaxShowerEnergy);
locHistName = "CCALNeutralShowerDeltaT";
dHist_CCALNeutralShowerDeltaT = GetOrCreate_Histogram<TH1I>(locHistName, ";CCAL Neutral Shower #Deltat (Propagated - RF) (ns)", dNumDeltaTBins, dMinDeltaT, dMaxDeltaT);
locHistName = "CCALNeutralShowerDeltaTVsE";
dHist_CCALNeutralShowerDeltaTVsE = GetOrCreate_Histogram<TH2I>(locHistName, ";CCAL Neutral Shower Energy (GeV);CCAL Neutral Shower #Deltat (ns)", dNum2DShowerEnergyBins, dMinShowerEnergy, dMaxShowerEnergy, dNum2DDeltaTBins, dMinDeltaT, dMaxDeltaT);

//Return to the base directory
ChangeTo_BaseDirectory();
}
japp->RootUnLock(); //RELEASE ROOT LOCK!!
2314}

2316void DHistogramAction_Neutrals::Run_Update(JEventLoop* locEventLoop)
2317{
DApplication* locApplication = dynamic_cast<DApplication*>(locEventLoop->GetJApplication());
DGeometry* locGeometry = locApplication->GetDGeometry(locEventLoop->GetJEvent().GetRunNumber());
double locTargetZCenter = 0.0;
locGeometry->GetTargetZ(locTargetZCenter);

if(dTargetCenter.Z() < -9.8E9)
dTargetCenter.SetXYZ(0.0, 0.0, locTargetZCenter);
2325}

2327bool DHistogramAction_Neutrals::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
2328{
//Expect locParticleCombo to be NULL since this is a reaction-independent action.

if(Get_CalledPriorWithComboFlag())
return true; //else double-counting!

vector<const DNeutralShower*> locNeutralShowers;
locEventLoop->Get(locNeutralShowers);

vector<const DTrackTimeBased*> locTrackTimeBasedVector;
locEventLoop->Get(locTrackTimeBasedVector);

const DDetectorMatches* locDetectorMatches = NULL__null;
locEventLoop->GetSingle(locDetectorMatches);

vector<const DEventRFBunch*> locEventRFBunches;
locEventLoop->Get(locEventRFBunches);
double locStartTime = locEventRFBunches.empty() ? 0.0 : locEventRFBunches[0]->dTime;

//FILL HISTOGRAMS
//Since we are filling histograms local to this action, it will not interfere with other ROOT operations: can use action-wide ROOT lock
//Note, the mutex is unique to this DReaction + action_string combo: actions of same class with different hists will have a different mutex
Lock_Action(); //ACQUIRE ROOT LOCK!!
{
for(size_t loc_i = 0; loc_i < locNeutralShowers.size(); ++loc_i)
{
	//assume is photon
	double locPathLength = (locNeutralShowers[loc_i]->dSpacetimeVertex.Vect() - dTargetCenter).Mag();
	double locDeltaT = locNeutralShowers[loc_i]->dSpacetimeVertex.T() - locPathLength/29.9792458 - locStartTime;
	
	if(locNeutralShowers[loc_i]->dDetectorSystem == SYS_FCAL)
	{
		const DFCALShower* locFCALShower = NULL__null;
		locNeutralShowers[loc_i]->GetSingle(locFCALShower);

		double locDistance = 9.9E9;
		if(locDetectorMatches->Get_DistanceToNearestTrack(locFCALShower, locDistance))
			dHist_FCALTrackDOCA->Fill(locDistance);

		dHist_FCALNeutralShowerEnergy->Fill(locNeutralShowers[loc_i]->dEnergy);
		dHist_FCALNeutralShowerDeltaT->Fill(locDeltaT);
		dHist_FCALNeutralShowerDeltaTVsE->Fill(locNeutralShowers[loc_i]->dEnergy, locDeltaT);
	}
	else if(locNeutralShowers[loc_i]->dDetectorSystem == SYS_BCAL)
	{
		const DBCALShower* locBCALShower = NULL__null;
		locNeutralShowers[loc_i]->GetSingle(locBCALShower);

		double locDistance = 9.9E9, locDeltaPhi = 9.9E9, locDeltaZ = 9.9E9;
		if(locDetectorMatches->Get_DistanceToNearestTrack(locBCALShower, locDistance))
			dHist_BCALTrackDOCA->Fill(locDistance);
		if(locDetectorMatches->Get_DistanceToNearestTrack(locBCALShower, locDeltaPhi, locDeltaZ))
		{
			dHist_BCALTrackDeltaPhi->Fill(180.0*locDeltaPhi/TMath::Pi());
			dHist_BCALTrackDeltaZ->Fill(locDeltaZ);
		}

		dHist_BCALNeutralShowerEnergy->Fill(locNeutralShowers[loc_i]->dEnergy);
		dHist_BCALNeutralShowerDeltaT->Fill(locDeltaT);
		dHist_BCALNeutralShowerDeltaTVsE->Fill(locNeutralShowers[loc_i]->dEnergy, locDeltaT);
		dHist_BCALNeutralShowerDeltaTVsZ->Fill(locNeutralShowers[loc_i]->dSpacetimeVertex.Z(), locDeltaT);
	}
	else if(locNeutralShowers[loc_i]->dDetectorSystem == SYS_CCAL)
	{
		const DCCALShower* locCCALShower = NULL__null;
		locNeutralShowers[loc_i]->GetSingle(locCCALShower);

		//double locDistance = 9.9E9;
		//if(locDetectorMatches->Get_DistanceToNearestTrack(locFCALShower, locDistance))
		//	dHist_FCALTrackDOCA->Fill(locDistance);

		dHist_CCALNeutralShowerEnergy->Fill(locNeutralShowers[loc_i]->dEnergy);
		dHist_CCALNeutralShowerDeltaT->Fill(locDeltaT);
		dHist_CCALNeutralShowerDeltaTVsE->Fill(locNeutralShowers[loc_i]->dEnergy, locDeltaT);
	}
}
}
Unlock_Action(); //RELEASE ROOT LOCK!!

return true; //return false if you want to use this action to apply a cut (and it fails the cut!)
2408}

2410void DHistogramAction_DetectorMatchParams::Initialize(JEventLoop* locEventLoop)
2411{
//Create any histograms/trees/etc. within a ROOT lock.
//This is so that when running multithreaded, only one thread is writing to the ROOT file at a time.

//When creating a reaction-independent action, only modify member variables within a ROOT lock.
//Objects created within a plugin (such as reaction-independent actions) can be accessed by many threads simultaneously.

string locHistName, locHistTitle;

Run_Update(locEventLoop);

vector<const DMCThrown*> locMCThrowns;
locEventLoop->Get(locMCThrowns);

string locTrackSelectionTag = "NotATag";
if(gPARMS->Exists("COMBO:TRACK_SELECT_TAG"))
gPARMS->GetParameter("COMBO:TRACK_SELECT_TAG", locTrackSelectionTag);

//CREATE THE HISTOGRAMS
//Since we are creating histograms, the contents of gDirectory will be modified: must use JANA-wide ROOT lock
japp->RootWriteLock(); //ACQUIRE ROOT LOCK!!
{
//So: Default tag is "", User can set it to something else
//In here, if tag is "", get from gparms, if not, leave it alone
	//If gparms value does not exist, set it to (and use) "PreSelect"
if(dTrackSelectionTag == "NotATag")
	dTrackSelectionTag = (locTrackSelectionTag == "NotATag") ? "PreSelect" : locTrackSelectionTag;

//Required: Create a folder in the ROOT output file that will contain all of the output ROOT objects (if any) for this action.
	//If another thread has already created the folder, it just changes to it.
CreateAndChangeTo_ActionDirectory();

//Track Matched to Hit
for(int locTruePIDFlag = 0; locTruePIDFlag < 2; ++locTruePIDFlag)
{
	if(locMCThrowns.empty() && (locTruePIDFlag == 1))
		continue; //not a simulated event: don't histogram thrown info!

	string locDirName = (locTruePIDFlag == 1) ? "TruePID" : "ReconstructedPID";
	CreateAndChangeTo_Directory(locDirName.c_str(), locDirName.c_str());

	//By PID
	for(int loc_i = -2; loc_i < int(dTrackingPIDs.size()); ++loc_i) //-2 = q-, -1 = q+
	{
		string locParticleName, locParticleROOTName;
		int locPID = loc_i;
		if(loc_i == -2)
		{
			locParticleName = "q-";
			locParticleROOTName = "#it{q}^{-}";
		}
		else if(loc_i == -1)
		{
			locParticleName = "q+";
			locParticleROOTName = "#it{q}^{+}";
		}
		else
		{
			locParticleName = ParticleType(dTrackingPIDs[loc_i]);
			locParticleROOTName = ParticleName_ROOT(dTrackingPIDs[loc_i]);
			locPID = int(dTrackingPIDs[loc_i]);
		}
		CreateAndChangeTo_Directory(locParticleName, locParticleName);
		pair<int, bool> locPIDPair(locPID, bool(locTruePIDFlag));

		//BCAL
		locHistName = "BCALShowerEnergy";
		locHistTitle = locParticleROOTName + ";BCAL Shower Energy (GeV)";
		dHistMap_BCALShowerEnergy[locPIDPair] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumShowerEnergyBins, dMinShowerEnergy, dMaxShowerEnergy);

		locHistName = "BCALShowerTrackDepth";
		locHistTitle = locParticleROOTName + ";BCAL Shower Track Depth (cm)";
		dHistMap_BCALShowerTrackDepth[locPIDPair] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumShowerDepthBins, dMinShowerDepth, dMaxShowerDepth);

		locHistName = "BCALShowerTrackDepthVsP";
		locHistTitle = locParticleROOTName + ";p (GeV/c);BCAL Shower Track Depth (cm)";
		dHistMap_BCALShowerTrackDepthVsP[locPIDPair] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxBCALP, dNumShowerDepthBins, dMinShowerDepth, dMaxShowerDepth);

		//FCAL
		locHistName = "FCALShowerEnergy";
		locHistTitle = locParticleROOTName + ";FCAL Shower Energy (GeV)";
		dHistMap_FCALShowerEnergy[locPIDPair] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumShowerEnergyBins, dMinShowerEnergy, dMaxShowerEnergy);

		locHistName = "FCALShowerTrackDepth";
		locHistTitle = locParticleROOTName + ";FCAL Shower Track Depth (cm)";
		dHistMap_FCALShowerTrackDepth[locPIDPair] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumShowerDepthBins, dMinShowerDepth, dMaxShowerDepth);

		locHistName = "FCALShowerTrackDepthVsP";
		locHistTitle = locParticleROOTName + ";p (GeV/c);FCAL Shower Track Depth (cm)";
		dHistMap_FCALShowerTrackDepthVsP[locPIDPair] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNumShowerDepthBins, dMinShowerDepth, dMaxShowerDepth);

		//CCAL
		locHistName = "CCALShowerEnergy";
		locHistTitle = locParticleROOTName + ";CCAL Shower Energy (GeV)";
		dHistMap_CCALShowerEnergy[locPIDPair] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumShowerEnergyBins, dMinShowerEnergy, dMaxShowerEnergy);

		//SC
		locHistName = "SCEnergyVsTheta";
		locHistTitle = locParticleROOTName + ";#theta#circ;SC Point Energy (MeV)";
		dHistMap_SCEnergyVsTheta[locPIDPair] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DHitEnergyBins, dMinHitEnergy, dMaxHitEnergy);

		locHistName = "SCPhiVsTheta";
		locHistTitle = locParticleROOTName + ";#theta#circ;#phi#circ";
		dHistMap_SCPhiVsTheta[locPIDPair] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DPhiBins, dMinPhi, dMaxPhi);

		gDirectory(TDirectory::CurrentDirectory())->cd(".."); //end of PID
	}
	gDirectory(TDirectory::CurrentDirectory())->cd(".."); //end of true/recon PID
}

//Return to the base directory
ChangeTo_BaseDirectory();
}
japp->RootUnLock(); //RELEASE ROOT LOCK!!
2525}

2527void DHistogramAction_DetectorMatchParams::Run_Update(JEventLoop* locEventLoop)
2528{
DApplication* locApplication = dynamic_cast<DApplication*>(locEventLoop->GetJApplication());
DGeometry* locGeometry = locApplication->GetDGeometry(locEventLoop->GetJEvent().GetRunNumber());
double locTargetZCenter = 0.0;
locGeometry->GetTargetZ(locTargetZCenter);

if(dTargetCenterZ < -9.8E9)
dTargetCenterZ = locTargetZCenter; //only set if not already set
2536}

2538bool DHistogramAction_DetectorMatchParams::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
2539{
//Expect locParticleCombo to be NULL since this is a reaction-independent action.

if(Get_CalledPriorWithComboFlag())
return true; //else double-counting!

vector<const DMCThrown*> locMCThrowns;
locEventLoop->Get(locMCThrowns);

Fill_Hists(locEventLoop, false);
if(!locMCThrowns.empty())
Fill_Hists(locEventLoop, true);

return true; //return false if you want to use this action to apply a cut (and it fails the cut!)
2553}

2555void DHistogramAction_DetectorMatchParams::Fill_Hists(JEventLoop* locEventLoop, bool locUseTruePIDFlag)
2556{
vector<const DChargedTrack*> locChargedTracks;
locEventLoop->Get(locChargedTracks, dTrackSelectionTag.c_str());

vector<const DMCThrownMatching*> locMCThrownMatchingVector;
locEventLoop->Get(locMCThrownMatchingVector);

const DEventRFBunch* locEventRFBunch = NULL__null;
locEventLoop->GetSingle(locEventRFBunch);

//FILL HISTOGRAMS
//Since we are filling histograms local to this action, it will not interfere with other ROOT operations: can use action-wide ROOT lock
//Note, the mutex is unique to this DReaction + action_string combo: actions of same class with different hists will have a different mutex
Lock_Action(); //ACQUIRE ROOT LOCK!!
{
for(size_t loc_i = 0; loc_i < locChargedTracks.size(); ++loc_i)
{
	const DChargedTrackHypothesis* locChargedTrackHypothesis = locChargedTracks[loc_i]->Get_BestFOM();

	if(locUseTruePIDFlag && (!locMCThrownMatchingVector.empty()))
	{
		double locMatchFOM = 0.0;
		const DMCThrown* locMCThrown = locMCThrownMatchingVector[0]->Get_MatchingMCThrown(locChargedTrackHypothesis, locMatchFOM);
		if(locMCThrown == NULL__null)
			continue;
		//OK, have the thrown. Now, grab the best charged track hypothesis to get the best matching
		locChargedTrackHypothesis = locMCThrownMatchingVector[0]->Get_MatchingChargedHypothesis(locMCThrown, locMatchFOM);
	}

	pair<int, bool> locPIDPair(int(locChargedTrackHypothesis->PID()), locUseTruePIDFlag);
	bool locDisregardPIDFlag = (dHistMap_BCALShowerEnergy.find(locPIDPair) == dHistMap_BCALShowerEnergy.end());
	int locQIndex = (locChargedTrackHypothesis->charge() > 0.0) ? -1 : -2;
	pair<int, bool> locChargePair(locQIndex, locUseTruePIDFlag);

	DVector3 locMomentum = locChargedTrackHypothesis->momentum();
	auto locFCALShowerMatchParams = locChargedTrackHypothesis->Get_FCALShowerMatchParams();
	auto locSCHitMatchParams = locChargedTrackHypothesis->Get_SCHitMatchParams();
	auto locBCALShowerMatchParams = locChargedTrackHypothesis->Get_BCALShowerMatchParams();

	//BCAL
	if(locBCALShowerMatchParams != NULL__null)
	{
		const DBCALShower* locBCALShower = locBCALShowerMatchParams->dBCALShower;
		dHistMap_BCALShowerEnergy[locChargePair]->Fill(locBCALShower->E);
		dHistMap_BCALShowerTrackDepth[locChargePair]->Fill(locBCALShowerMatchParams->dx);
		dHistMap_BCALShowerTrackDepthVsP[locChargePair]->Fill(locMomentum.Mag(), locBCALShowerMatchParams->dx);

		if(!locDisregardPIDFlag)
		{
			dHistMap_BCALShowerEnergy[locPIDPair]->Fill(locBCALShower->E);
			dHistMap_BCALShowerTrackDepth[locPIDPair]->Fill(locBCALShowerMatchParams->dx);
			dHistMap_BCALShowerTrackDepthVsP[locPIDPair]->Fill(locMomentum.Mag(), locBCALShowerMatchParams->dx);
		}
	}

	//FCAL
	if(locFCALShowerMatchParams != NULL__null)
	{
		const DFCALShower* locFCALShower = locFCALShowerMatchParams->dFCALShower;
		dHistMap_FCALShowerEnergy[locChargePair]->Fill(locFCALShower->getEnergy());
		dHistMap_FCALShowerTrackDepth[locChargePair]->Fill(locFCALShowerMatchParams->dx);
		dHistMap_FCALShowerTrackDepthVsP[locChargePair]->Fill(locMomentum.Mag(), locFCALShowerMatchParams->dx);

		if(!locDisregardPIDFlag)
		{
			dHistMap_FCALShowerEnergy[locPIDPair]->Fill(locFCALShower->getEnergy());
			dHistMap_FCALShowerTrackDepth[locPIDPair]->Fill(locFCALShowerMatchParams->dx);
			dHistMap_FCALShowerTrackDepthVsP[locPIDPair]->Fill(locMomentum.Mag(), locFCALShowerMatchParams->dx);
		}
	}

	//SC
	if(locSCHitMatchParams != NULL__null)
	{
		dHistMap_SCEnergyVsTheta[locChargePair]->Fill(locMomentum.Theta()*180.0/TMath::Pi(), locSCHitMatchParams->dHitEnergy*1.0E3);
		dHistMap_SCPhiVsTheta[locChargePair]->Fill(locMomentum.Theta()*180.0/TMath::Pi(), locMomentum.Phi()*180.0/TMath::Pi());

		if(!locDisregardPIDFlag)
		{
			dHistMap_SCEnergyVsTheta[locPIDPair]->Fill(locMomentum.Theta()*180.0/TMath::Pi(), locSCHitMatchParams->dHitEnergy*1.0E3);
			dHistMap_SCPhiVsTheta[locPIDPair]->Fill(locMomentum.Theta()*180.0/TMath::Pi(), locMomentum.Phi()*180.0/TMath::Pi());
		}
	}
}
}
Unlock_Action(); //RELEASE ROOT LOCK!!
2642}

2644void DHistogramAction_EventVertex::Initialize(JEventLoop* locEventLoop)
2645{
string locHistName, locHistTitle;

string locTrackSelectionTag = "NotATag";
if(gPARMS->Exists("COMBO:TRACK_SELECT_TAG"))
gPARMS->GetParameter("COMBO:TRACK_SELECT_TAG", locTrackSelectionTag);

//CREATE THE HISTOGRAMS
//Since we are creating histograms, the contents of gDirectory will be modified: must use JANA-wide ROOT lock
japp->RootWriteLock(); //ACQUIRE ROOT LOCK!!
{
//So: Default tag is "", User can set it to something else
//In here, if tag is "", get from gparms, if not, leave it alone
	//If gparms value does not exist, set it to (and use) "PreSelect"
if(dTrackSelectionTag == "NotATag")
	dTrackSelectionTag = (locTrackSelectionTag == "NotATag") ? "PreSelect" : locTrackSelectionTag;

CreateAndChangeTo_ActionDirectory();

// Event RF Bunch Time
locHistName = "RFTrackDeltaT";
locHistTitle = ";#Deltat_{RF - Track} (ns)";
dRFTrackDeltaT = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumRFTBins, -3.0, 3.0);

// ALL EVENTS
CreateAndChangeTo_Directory("AllEvents", "AllEvents");

// Event Vertex-Z
locHistName = "EventVertexZ";
locHistTitle = ";Event Vertex-Z (cm)";
dEventVertexZ_AllEvents = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumVertexZBins, dMinVertexZ, dMaxVertexZ);

// Event Vertex-Y Vs Vertex-X
locHistName = "EventVertexYVsX";
locHistTitle = ";Event Vertex-X (cm);Event Vertex-Y (cm)";
dEventVertexYVsX_AllEvents = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNumVertexXYBins, dMinVertexXY, dMaxVertexXY, dNumVertexXYBins, dMinVertexXY, dMaxVertexXY);

// Event Vertex-T
locHistName = "EventVertexT";
locHistTitle = ";Event Vertex Time (ns)";
dEventVertexT_AllEvents = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumTBins, dMinT, dMaxT);

gDirectory(TDirectory::CurrentDirectory())->cd("..");


// 2+ Good Tracks
CreateAndChangeTo_Directory("2+GoodTracks", "2+GoodTracks");

// Event Vertex-Z
locHistName = "EventVertexZ";
locHistTitle = ";Event Vertex-Z (cm)";
dEventVertexZ_2OrMoreGoodTracks = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumVertexZBins, dMinVertexZ, dMaxVertexZ);

// Event Vertex-Y Vs Vertex-X
locHistName = "EventVertexYVsX";
locHistTitle = ";Event Vertex-X (cm);Event Vertex-Y (cm)";
dEventVertexYVsX_2OrMoreGoodTracks = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNumVertexXYBins, dMinVertexXY, dMaxVertexXY, dNumVertexXYBins, dMinVertexXY, dMaxVertexXY);

// Event Vertex-T
locHistName = "EventVertexT";
locHistTitle = ";Event Vertex Time (ns)";
dEventVertexT_2OrMoreGoodTracks = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumTBins, dMinT, dMaxT);

// Confidence Level
locHistName = "ConfidenceLevel";
dHist_KinFitConfidenceLevel = GetOrCreate_Histogram<TH1I>(locHistName, "Event Vertex Kinematic Fit;Confidence Level;# Events", dNumConfidenceLevelBins, 0.0, 1.0);

//final particle pulls
for(size_t loc_i = 0; loc_i < dFinalStatePIDs.size(); ++loc_i)
{
	Particle_t locPID = dFinalStatePIDs[loc_i];
	string locParticleDirName = string("Pulls_") + string(ParticleType(locPID));
	string locParticleROOTName = ParticleName_ROOT(locPID);
	CreateAndChangeTo_Directory(locParticleDirName, locParticleDirName);

	//Px Pull
	locHistName = "Pull_Px";
	locHistTitle = locParticleROOTName + string(", Vertex Fit;p_{x} Pull;# Events");
	dHistMap_KinFitPulls[locPID][d_PxPull] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumPullBins, dMinPull, dMaxPull);

	//Py Pull
	locHistName = "Pull_Py";
	locHistTitle = locParticleROOTName + string(", Vertex Fit;p_{y} Pull;# Events");
	dHistMap_KinFitPulls[locPID][d_PyPull] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumPullBins, dMinPull, dMaxPull);

	//Pz Pull
	locHistName = "Pull_Pz";
	locHistTitle = locParticleROOTName + string(", Vertex Fit;p_{z} Pull;# Events");
	dHistMap_KinFitPulls[locPID][d_PzPull] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumPullBins, dMinPull, dMaxPull);

	//Xx Pull
	locHistName = "Pull_Xx";
	locHistTitle = locParticleROOTName + string(", Vertex Fit;x_{x} Pull;# Events");
	dHistMap_KinFitPulls[locPID][d_XxPull] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumPullBins, dMinPull, dMaxPull);

	//Xy Pull
	locHistName = "Pull_Xy";
	locHistTitle = locParticleROOTName + string(", Vertex Fit;x_{y} Pull;# Events");
	dHistMap_KinFitPulls[locPID][d_XyPull] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumPullBins, dMinPull, dMaxPull);

	//Xz Pull
	locHistName = "Pull_Xz";
	locHistTitle = locParticleROOTName + string(", Vertex Fit;x_{z} Pull;# Events");
	dHistMap_KinFitPulls[locPID][d_XzPull] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumPullBins, dMinPull, dMaxPull);

	gDirectory(TDirectory::CurrentDirectory())->cd("..");
}

gDirectory(TDirectory::CurrentDirectory())->cd("..");

//Return to the base directory
ChangeTo_BaseDirectory();
}
japp->RootUnLock(); //RELEASE ROOT LOCK!!
2759}

2761bool DHistogramAction_EventVertex::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
2762{
if(Get_CalledPriorWithComboFlag())
return true; //else double-counting!

const DVertex* locVertex = NULL__null;
locEventLoop->GetSingle(locVertex);

vector<const DChargedTrack*> locChargedTracks;
locEventLoop->Get(locChargedTracks, dTrackSelectionTag.c_str());

const DDetectorMatches* locDetectorMatches = NULL__null;
locEventLoop->GetSingle(locDetectorMatches);

const DParticleID* locParticleID = NULL__null;
locEventLoop->GetSingle(locParticleID);

const DEventRFBunch* locEventRFBunch = NULL__null;
locEventLoop->GetSingle(locEventRFBunch);

//Make sure that brun() is called (to get rf period) before using.
//Cannot call JEventLoop->Get() because object may be in datastream (REST), bypassing factory brun() call.
//Must do here rather than in Initialize() function because this object is shared by all threads (which each have their own factory)
DRFTime_factory* locRFTimeFactory = static_cast<DRFTime_factory*>(locEventLoop->GetFactory("DRFTime"));
if(!locRFTimeFactory->brun_was_called())
{
locRFTimeFactory->brun(locEventLoop, locEventLoop->GetJEvent().GetRunNumber());
locRFTimeFactory->Set_brun_called();
}

//Get time-based tracks: use best PID FOM
//Note that these may not be the PIDs that were used in the fit!!!
//e.g. for a DTrackTimeBased the proton hypothesis has the highest tracking FOM, so it is used in the fit, but the pi+ PID has the highest PID FOM
vector<const DTrackTimeBased*> locTrackTimeBasedVector;
for(size_t loc_i = 0; loc_i < locChargedTracks.size(); ++loc_i)
{
const DChargedTrackHypothesis* locChargedTrackHypothesis = locChargedTracks[loc_i]->Get_BestFOM();
auto locTrackTimeBased = locChargedTrackHypothesis->Get_TrackTimeBased();
if(locTrackTimeBased != NULL__null)
	locTrackTimeBasedVector.push_back(locTrackTimeBased);
}

//Event Vertex
//FILL HISTOGRAMS
//Since we are filling histograms local to this action, it will not interfere with other ROOT operations: can use action-wide ROOT lock
//Note, the mutex is unique to this DReaction + action_string combo: actions of same class with different hists will have a different mutex
Lock_Action();
{
for(size_t loc_i = 0; loc_i < locChargedTracks.size(); ++loc_i)
{
	const DChargedTrackHypothesis* locChargedTrackHypothesis = locChargedTracks[loc_i]->Get_BestFOM();
	double locPropagatedRFTime = locParticleID->Calc_PropagatedRFTime(locChargedTrackHypothesis, locEventRFBunch);
	double locShiftedRFTime = locRFTimeFactory->Step_TimeToNearInputTime(locPropagatedRFTime, locChargedTrackHypothesis->time());
	double locDeltaT = locShiftedRFTime - locChargedTrackHypothesis->time();
	dRFTrackDeltaT->Fill(locDeltaT);
}
dEventVertexZ_AllEvents->Fill(locVertex->dSpacetimeVertex.Z());
dEventVertexYVsX_AllEvents->Fill(locVertex->dSpacetimeVertex.X(), locVertex->dSpacetimeVertex.Y());
dEventVertexT_AllEvents->Fill(locVertex->dSpacetimeVertex.T());

if(locChargedTracks.size() >= 2)
{
	dEventVertexZ_2OrMoreGoodTracks->Fill(locVertex->dSpacetimeVertex.Z());
	dEventVertexYVsX_2OrMoreGoodTracks->Fill(locVertex->dSpacetimeVertex.X(), locVertex->dSpacetimeVertex.Y());
	dEventVertexT_2OrMoreGoodTracks->Fill(locVertex->dSpacetimeVertex.T());
}
}
Unlock_Action();

if(locVertex->dKinFitNDF == 0)
return true; //kin fit not performed or didn't converge: no results to histogram

double locConfidenceLevel = TMath::Prob(locVertex->dKinFitChiSq, locVertex->dKinFitNDF);

//FILL HISTOGRAMS
//Since we are filling histograms local to this action, it will not interfere with other ROOT operations: can use action-wide ROOT lock
//Note, the mutex is unique to this DReaction + action_string combo: actions of same class with different hists will have a different mutex
Lock_Action();
{
dHist_KinFitConfidenceLevel->Fill(locConfidenceLevel);

//pulls
if(locConfidenceLevel > dPullHistConfidenceLevelCut)
{
	for(size_t loc_i = 0; loc_i < locTrackTimeBasedVector.size(); ++loc_i)
	{
		const DKinematicData* locKinematicData = static_cast<const DKinematicData*>(locTrackTimeBasedVector[loc_i]);
		Particle_t locPID = locKinematicData->PID();
		if(dHistMap_KinFitPulls.find(locPID) == dHistMap_KinFitPulls.end())
			continue; //PID not histogrammed

		map<const JObject*, map<DKinFitPullType, double> >::const_iterator locParticleIterator = locVertex->dKinFitPulls.find(locKinematicData);
		if(locParticleIterator == locVertex->dKinFitPulls.end())
			continue;

		const map<DKinFitPullType, double>& locPullMap = locParticleIterator->second;
		map<DKinFitPullType, double>::const_iterator locPullIterator = locPullMap.begin();
		for(; locPullIterator != locPullMap.end(); ++locPullIterator)
			dHistMap_KinFitPulls[locPID][locPullIterator->first]->Fill(locPullIterator->second);
	}
}
}
Unlock_Action();

return true;
2866}

2868void DHistogramAction_DetectedParticleKinematics::Initialize(JEventLoop* locEventLoop)
2869{
string locHistName, locHistTitle, locParticleName, locParticleROOTName;
Particle_t locPID;

string locTrackSelectionTag = "NotATag", locShowerSelectionTag = "NotATag";
if(gPARMS->Exists("COMBO:TRACK_SELECT_TAG"))
gPARMS->GetParameter("COMBO:TRACK_SELECT_TAG", locTrackSelectionTag);
if(gPARMS->Exists("COMBO:SHOWER_SELECT_TAG"))
gPARMS->GetParameter("COMBO:SHOWER_SELECT_TAG", locShowerSelectionTag);

//CREATE THE HISTOGRAMS
//Since we are creating histograms, the contents of gDirectory will be modified: must use JANA-wide ROOT lock
japp->RootWriteLock(); //ACQUIRE ROOT LOCK!!
{
//So: Default tag is "", User can set it to something else
//In here, if tag is "", get from gparms, if not, leave it alone
	//If gparms value does not exist, set it to (and use) "PreSelect"
if(dTrackSelectionTag == "NotATag")
	dTrackSelectionTag = (locTrackSelectionTag == "NotATag") ? "PreSelect" : locTrackSelectionTag;
if(dShowerSelectionTag == "NotATag")
	dShowerSelectionTag = (locShowerSelectionTag == "NotATag") ? "PreSelect" : locShowerSelectionTag;

CreateAndChangeTo_ActionDirectory();

// Beam Particle
locPID = Gamma;
locParticleName = string("Beam_") + ParticleType(locPID);
locParticleROOTName = ParticleName_ROOT(locPID);
CreateAndChangeTo_Directory(locParticleName, locParticleName);
locHistName = "Momentum";
locHistTitle = string("Beam ") + locParticleROOTName + string(";p (GeV/c)");
dBeamParticle_P = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumBeamEBins, dMinP, dMaxBeamE);
gDirectory(TDirectory::CurrentDirectory())->cd("..");

//PID
CreateAndChangeTo_Directory("PID", "PID");
{
	//beta vs p
	locHistName = "BetaVsP_Q+";
	locHistTitle = "q^{+};p (GeV/c);#beta";
	dHistMap_QBetaVsP[1] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNumBetaBins, dMinBeta, dMaxBeta);

	locHistName = "BetaVsP_Q-";
	locHistTitle = "q^{-};p (GeV/c);#beta";
	dHistMap_QBetaVsP[-1] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNumBetaBins, dMinBeta, dMaxBeta);
}
gDirectory(TDirectory::CurrentDirectory())->cd("..");

for(size_t loc_i = 0; loc_i < dFinalStatePIDs.size(); ++loc_i)
{
	locPID = dFinalStatePIDs[loc_i];
	locParticleName = ParticleType(locPID);
	locParticleROOTName = ParticleName_ROOT(locPID);
	CreateAndChangeTo_Directory(locParticleName, locParticleName);

	// Momentum
	locHistName = "Momentum";
	locHistTitle = locParticleROOTName + string(";p (GeV/c)");
	dHistMap_P[locPID] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumPBins, dMinP, dMaxP);

	// Theta
	locHistName = "Theta";
	locHistTitle = locParticleROOTName + string(";#theta#circ");
	dHistMap_Theta[locPID] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumThetaBins, dMinTheta, dMaxTheta);

	// Phi
	locHistName = "Phi";
	locHistTitle = locParticleROOTName + string(";#phi#circ");
	dHistMap_Phi[locPID] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumPhiBins, dMinPhi, dMaxPhi);

	// P Vs Theta
	locHistName = "PVsTheta";
	locHistTitle = locParticleROOTName + string(";#theta#circ;p (GeV/c)");
	dHistMap_PVsTheta[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DPBins, dMinP, dMaxP);

	// Phi Vs Theta
	locHistName = "PhiVsTheta";
	locHistTitle = locParticleROOTName + string(";#theta#circ;#phi#circ");
	dHistMap_PhiVsTheta[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DPhiBins, dMinPhi, dMaxPhi);

	//beta vs p
	locHistName = "BetaVsP";
	locHistTitle = locParticleROOTName + string(";p (GeV/c);#beta");
	dHistMap_BetaVsP[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNumBetaBins, dMinBeta, dMaxBeta);

	//delta-beta vs p
	locHistName = "DeltaBetaVsP";
	locHistTitle = locParticleROOTName + string(";p (GeV/c);#Delta#beta");
	dHistMap_DeltaBetaVsP[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DDeltaBetaBins, dMinDeltaBeta, dMaxDeltaBeta);

	// Vertex-Z
	locHistName = "VertexZ";
	locHistTitle = locParticleROOTName + string(";Vertex-Z (cm)");
	dHistMap_VertexZ[locPID] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumVertexZBins, dMinVertexZ, dMaxVertexZ);

	// Vertex-Y Vs Vertex-X
	locHistName = "VertexYVsX";
	locHistTitle = locParticleROOTName + string(";Vertex-X (cm);Vertex-Y (cm)");
	dHistMap_VertexYVsX[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNumVertexXYBins, dMinVertexXY, dMaxVertexXY, dNumVertexXYBins, dMinVertexXY, dMaxVertexXY);

	// Vertex-T
	locHistName = "VertexT";
	locHistTitle = locParticleROOTName + string(";Vertex-T (ns)");
	dHistMap_VertexT[locPID] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumTBins, dMinT, dMaxT);

	// histogram shower energy for massive neutrals reconstructed in the calorimeter
	if(locPID == Neutron) {
		locHistName = "ShowerE";
		locHistTitle = locParticleROOTName + string(";Shower Energy (GeV)");
		dHistMap_ShowerE[locPID] = GetOrCreate_Histogram<TH1I>(locHistName, locHistTitle, dNumPBins, dMinP, dMaxP);
	}

	gDirectory(TDirectory::CurrentDirectory())->cd("..");
}

//Return to the base directory
ChangeTo_BaseDirectory();
}
japp->RootUnLock(); //RELEASE ROOT LOCK!!
2988}

2990bool DHistogramAction_DetectedParticleKinematics::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
2991{
if(Get_CalledPriorWithComboFlag())
return true; //else double-counting!

vector<const DBeamPhoton*> locBeamPhotons;
locEventLoop->Get(locBeamPhotons);

//FILL HISTOGRAMS
//Since we are filling histograms local to this action, it will not interfere with other ROOT operations: can use action-wide ROOT lock
//Note, the mutex is unique to this DReaction + action_string combo: actions of same class with different hists will have a different mutex
Lock_Action();
{
for(size_t loc_i = 0; loc_i < locBeamPhotons.size(); ++loc_i)
	dBeamParticle_P->Fill(locBeamPhotons[loc_i]->energy());
}
Unlock_Action();

vector<const DChargedTrack*> locPreSelectChargedTracks;
locEventLoop->Get(locPreSelectChargedTracks, dTrackSelectionTag.c_str());

for(size_t loc_i = 0; loc_i < locPreSelectChargedTracks.size(); ++loc_i)
{
const DChargedTrackHypothesis* locChargedTrackHypothesis = locPreSelectChargedTracks[loc_i]->Get_BestTrackingFOM();
int locCharge = ParticleCharge(locChargedTrackHypothesis->PID());

DVector3 locMomentum = locChargedTrackHypothesis->momentum();
double locP = locMomentum.Mag();
double locBeta_Timing = locChargedTrackHypothesis->measuredBeta();

if(dHistMap_QBetaVsP.find(locCharge) == dHistMap_QBetaVsP.end())
	continue;

//FILL HISTOGRAMS
//Since we are filling histograms local to this action, it will not interfere with other ROOT operations: can use action-wide ROOT lock
//Note, the mutex is unique to this DReaction + action_string combo: actions of same class with different hists will have a different mutex
Lock_Action();
{
	//Extremely inefficient, I know ...
	dHistMap_QBetaVsP[locCharge]->Fill(locP, locBeta_Timing);
}
Unlock_Action();
}

for(size_t loc_i = 0; loc_i < locPreSelectChargedTracks.size(); ++loc_i)
{
const DChargedTrackHypothesis* locChargedTrackHypothesis = locPreSelectChargedTracks[loc_i]->Get_BestFOM();

DVector3 locMomentum = locChargedTrackHypothesis->momentum();
double locPhi = locMomentum.Phi()*180.0/TMath::Pi();
double locTheta = locMomentum.Theta()*180.0/TMath::Pi();
double locP = locMomentum.Mag();
double locBeta_Timing = locChargedTrackHypothesis->measuredBeta();
double locDeltaBeta = locBeta_Timing - locChargedTrackHypothesis->lorentzMomentum().Beta();

Particle_t locPID = (locChargedTrackHypothesis->Get_FOM() < dMinPIDFOM) ? Unknown : locChargedTrackHypothesis->PID();
if(dHistMap_P.find(locPID) == dHistMap_P.end())
	continue; //not interested in histogramming

//FILL HISTOGRAMS
//Since we are filling histograms local to this action, it will not interfere with other ROOT operations: can use action-wide ROOT lock
//Note, the mutex is unique to this DReaction + action_string combo: actions of same class with different hists will have a different mutex
Lock_Action();
{
	dHistMap_P[locPID]->Fill(locP);
	dHistMap_Phi[locPID]->Fill(locPhi);
	dHistMap_Theta[locPID]->Fill(locTheta);
	dHistMap_PVsTheta[locPID]->Fill(locTheta, locP);
	dHistMap_PhiVsTheta[locPID]->Fill(locTheta, locPhi);
	dHistMap_BetaVsP[locPID]->Fill(locP, locBeta_Timing);
	dHistMap_DeltaBetaVsP[locPID]->Fill(locP, locDeltaBeta);
	dHistMap_VertexZ[locPID]->Fill(locChargedTrackHypothesis->position().Z());
	dHistMap_VertexYVsX[locPID]->Fill(locChargedTrackHypothesis->position().X(), locChargedTrackHypothesis->position().Y());
	dHistMap_VertexT[locPID]->Fill(locChargedTrackHypothesis->time());
}
Unlock_Action();
}

vector<const DNeutralParticle*> locNeutralParticles;
locEventLoop->Get(locNeutralParticles, dShowerSelectionTag.c_str());

for(size_t loc_i = 0; loc_i < locNeutralParticles.size(); ++loc_i)
{
const DNeutralParticleHypothesis* locNeutralParticleHypothesis = locNeutralParticles[loc_i]->Get_BestFOM();

Particle_t locPID = locNeutralParticleHypothesis->PID();
if(dHistMap_P.find(locPID) == dHistMap_P.end())
	continue; //e.g. a decaying particle, or not interested in histogramming

DVector3 locMomentum = locNeutralParticleHypothesis->momentum();
double locPhi = locMomentum.Phi()*180.0/TMath::Pi();
double locTheta = locMomentum.Theta()*180.0/TMath::Pi();
double locP = locMomentum.Mag();

double locBeta_Timing = locNeutralParticleHypothesis->measuredBeta();
double locDeltaBeta = locBeta_Timing - locNeutralParticleHypothesis->lorentzMomentum().Beta();

double locShowerEnergy = locNeutralParticleHypothesis->Get_NeutralShower()->dEnergy;

//FILL HISTOGRAMS
//Since we are filling histograms local to this action, it will not interfere with other ROOT operations: can use action-wide ROOT lock
//Note, the mutex is unique to this DReaction + action_string combo: actions of same class with different hists will have a different mutex
Lock_Action();
{
	dHistMap_P[locPID]->Fill(locP);
	dHistMap_Phi[locPID]->Fill(locPhi);
	dHistMap_Theta[locPID]->Fill(locTheta);
	dHistMap_PVsTheta[locPID]->Fill(locTheta, locP);
	dHistMap_PhiVsTheta[locPID]->Fill(locTheta, locPhi);
	dHistMap_BetaVsP[locPID]->Fill(locP, locBeta_Timing);
	dHistMap_DeltaBetaVsP[locPID]->Fill(locP, locDeltaBeta);
	dHistMap_VertexZ[locPID]->Fill(locNeutralParticleHypothesis->position().Z());
	dHistMap_VertexYVsX[locPID]->Fill(locNeutralParticleHypothesis->position().X(), locNeutralParticleHypothesis->position().Y());
	dHistMap_VertexT[locPID]->Fill(locNeutralParticleHypothesis->time());
	
	if(locPID == Neutron) {
		dHistMap_ShowerE[locPID]->Fill(locShowerEnergy);
	}
}
Unlock_Action();
}
return true;
3112}

3114void DHistogramAction_TrackShowerErrors::Initialize(JEventLoop* locEventLoop)
3115{
string locHistName, locHistTitle, locParticleName, locParticleROOTName;
Particle_t locPID;

string locTrackSelectionTag = "NotATag", locShowerSelectionTag = "NotATag";
if(gPARMS->Exists("COMBO:TRACK_SELECT_TAG"))
gPARMS->GetParameter("COMBO:TRACK_SELECT_TAG", locTrackSelectionTag);
if(gPARMS->Exists("COMBO:SHOWER_SELECT_TAG"))
gPARMS->GetParameter("COMBO:SHOWER_SELECT_TAG", locShowerSelectionTag);

//CREATE THE HISTOGRAMS
//Since we are creating histograms, the contents of gDirectory will be modified: must use JANA-wide ROOT lock
japp->RootWriteLock(); //ACQUIRE ROOT LOCK!!
{
//So: Default tag is "", User can set it to something else
//In here, if tag is "", get from gparms, if not, leave it alone
	//If gparms value does not exist, set it to (and use) "PreSelect"
if(dTrackSelectionTag == "NotATag")
	dTrackSelectionTag = (locTrackSelectionTag == "NotATag") ? "PreSelect" : locTrackSelectionTag;
if(dShowerSelectionTag == "NotATag")
	dShowerSelectionTag = (locShowerSelectionTag == "NotATag") ? "PreSelect" : locShowerSelectionTag;

CreateAndChangeTo_ActionDirectory();

//TRACKS
for(size_t loc_i = 0; loc_i < dFinalStatePIDs.size(); ++loc_i)
{
	locPID = dFinalStatePIDs[loc_i];
	locParticleName = ParticleType(locPID);
	locParticleROOTName = ParticleName_ROOT(locPID);
	CreateAndChangeTo_Directory(locParticleName, locParticleName);

	// Px
	locHistName = "PxErrorVsP";
	locHistTitle = locParticleROOTName + string(";p (GeV/c);#sigma_{p_{x}} (GeV/c)");
	dHistMap_TrackPxErrorVsP[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DPxyErrorBins, 0.0, dMaxPxyError);

	locHistName = "PxErrorVsTheta";
	locHistTitle = locParticleROOTName + string(";#theta#circ;#sigma_{p_{x}} (GeV/c)");
	dHistMap_TrackPxErrorVsTheta[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DPxyErrorBins, 0.0, dMaxPxyError);

	locHistName = "PxErrorVsPhi";
	locHistTitle = locParticleROOTName + string(";#phi#circ;#sigma_{p_{x}} (GeV/c)");
	dHistMap_TrackPxErrorVsPhi[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPhiBins, dMinPhi, dMaxPhi, dNum2DPxyErrorBins, 0.0, dMaxPxyError);

	// Py
	locHistName = "PyErrorVsP";
	locHistTitle = locParticleROOTName + string(";p (GeV/c);#sigma_{p_{y}} (GeV/c)");
	dHistMap_TrackPyErrorVsP[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DPxyErrorBins, 0.0, dMaxPxyError);

	locHistName = "PyErrorVsTheta";
	locHistTitle = locParticleROOTName + string(";#theta#circ;#sigma_{p_{y}} (GeV/c)");
	dHistMap_TrackPyErrorVsTheta[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DPxyErrorBins, 0.0, dMaxPxyError);

	locHistName = "PyErrorVsPhi";
	locHistTitle = locParticleROOTName + string(";#phi#circ;#sigma_{p_{y}} (GeV/c)");
	dHistMap_TrackPyErrorVsPhi[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPhiBins, dMinPhi, dMaxPhi, dNum2DPxyErrorBins, 0.0, dMaxPxyError);

	// Pz
	locHistName = "PzErrorVsP";
	locHistTitle = locParticleROOTName + string(";p (GeV/c);#sigma_{p_{z}} (GeV/c)");
	dHistMap_TrackPzErrorVsP[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DPzErrorBins, 0.0, dMaxPzError);

	locHistName = "PzErrorVsTheta";
	locHistTitle = locParticleROOTName + string(";#theta#circ;#sigma_{p_{z}} (GeV/c)");
	dHistMap_TrackPzErrorVsTheta[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DPzErrorBins, 0.0, dMaxPzError);

	locHistName = "PzErrorVsPhi";
	locHistTitle = locParticleROOTName + string(";#phi#circ;#sigma_{p_{z}} (GeV/c)");
	dHistMap_TrackPzErrorVsPhi[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPhiBins, dMinPhi, dMaxPhi, dNum2DPzErrorBins, 0.0, dMaxPzError);

	// X
	locHistName = "XErrorVsP";
	locHistTitle = locParticleROOTName + string(";p (GeV/c);#sigma_{x} (cm)");
	dHistMap_TrackXErrorVsP[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DXYErrorBins, 0.0, dMaxXYError);

	locHistName = "XErrorVsTheta";
	locHistTitle = locParticleROOTName + string(";#theta#circ;#sigma_{x} (cm)");
	dHistMap_TrackXErrorVsTheta[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DXYErrorBins, 0.0, dMaxXYError);

	locHistName = "XErrorVsPhi";
	locHistTitle = locParticleROOTName + string(";#phi#circ;#sigma_{x} (cm)");
	dHistMap_TrackXErrorVsPhi[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPhiBins, dMinPhi, dMaxPhi, dNum2DXYErrorBins, 0.0, dMaxXYError);

	// Y
	locHistName = "YErrorVsP";
	locHistTitle = locParticleROOTName + string(";p (GeV/c);#sigma_{y} (cm)");
	dHistMap_TrackYErrorVsP[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DXYErrorBins, 0.0, dMaxXYError);

	locHistName = "YErrorVsTheta";
	locHistTitle = locParticleROOTName + string(";#theta#circ;#sigma_{y} (cm)");
	dHistMap_TrackYErrorVsTheta[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DXYErrorBins, 0.0, dMaxXYError);

	locHistName = "YErrorVsPhi";
	locHistTitle = locParticleROOTName + string(";#phi#circ;#sigma_{y} (cm)");
	dHistMap_TrackYErrorVsPhi[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPhiBins, dMinPhi, dMaxPhi, dNum2DXYErrorBins, 0.0, dMaxXYError);

	// Z
	locHistName = "ZErrorVsP";
	locHistTitle = locParticleROOTName + string(";p (GeV/c);#sigma_{z} (cm)");
	dHistMap_TrackZErrorVsP[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, dMaxP, dNum2DZErrorBins, 0.0, dMaxZError);

	locHistName = "ZErrorVsTheta";
	locHistTitle = locParticleROOTName + string(";#theta#circ;#sigma_{z} (cm)");
	dHistMap_TrackZErrorVsTheta[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, dMinTheta, dMaxTheta, dNum2DZErrorBins, 0.0, dMaxZError);

	locHistName = "ZErrorVsPhi";
	locHistTitle = locParticleROOTName + string(";#phi#circ;#sigma_{z} (cm)");
	dHistMap_TrackZErrorVsPhi[locPID] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPhiBins, dMinPhi, dMaxPhi, dNum2DZErrorBins, 0.0, dMaxZError);

	gDirectory(TDirectory::CurrentDirectory())->cd("..");
}

//SHOWERS
for(bool locIsBCALFlag : {false, true})
{
  string locDirName = locIsBCALFlag ? "Photon_BCAL" : "Photon_FCAL";
	locParticleROOTName = ParticleName_ROOT(Gamma);
	CreateAndChangeTo_Directory(locDirName, locDirName);

	double locMaxP = locIsBCALFlag ? dMaxPBCAL : dMaxP;
	double locMinTheta = locIsBCALFlag ? dMinThetaBCAL : dMinTheta;
	double locMaxTheta = locIsBCALFlag ? dMaxTheta : dMaxThetaFCAL;

	// E
	locHistName = "EErrorVsP";
	locHistTitle = locParticleROOTName + string(";p (GeV/c);#sigma_{E} (GeV)");
	dHistMap_ShowerEErrorVsP[locIsBCALFlag] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, locMaxP, dNum2DEErrorBins, 0.0, dMaxEError);

	locHistName = "EErrorVsTheta";
	locHistTitle = locParticleROOTName + string(";#theta#circ;#sigma_{E} (GeV)");
	dHistMap_ShowerEErrorVsTheta[locIsBCALFlag] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, locMinTheta, locMaxTheta, dNum2DEErrorBins, 0.0, dMaxEError);

	locHistName = "EErrorVsPhi";
	locHistTitle = locParticleROOTName + string(";#phi#circ;#sigma_{E} (GeV)");
	dHistMap_ShowerEErrorVsPhi[locIsBCALFlag] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPhiBins, dMinPhi, dMaxPhi, dNum2DEErrorBins, 0.0, dMaxEError);

	// X
	locHistName = "XErrorVsP";
	locHistTitle = locParticleROOTName + string(";p (GeV/c);#sigma_{x} (cm)");
	dHistMap_ShowerXErrorVsP[locIsBCALFlag] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, locMaxP, dNum2DXYErrorBins, 0.0, dMaxXYError);

	locHistName = "XErrorVsTheta";
	locHistTitle = locParticleROOTName + string(";#theta#circ;#sigma_{x} (cm)");
	dHistMap_ShowerXErrorVsTheta[locIsBCALFlag] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, locMinTheta, locMaxTheta, dNum2DXYErrorBins, 0.0, dMaxXYError);

	locHistName = "XErrorVsPhi";
	locHistTitle = locParticleROOTName + string(";#phi#circ;#sigma_{x} (cm)");
	dHistMap_ShowerXErrorVsPhi[locIsBCALFlag] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPhiBins, dMinPhi, dMaxPhi, dNum2DXYErrorBins, 0.0, dMaxXYError);

	// Y
	locHistName = "YErrorVsP";
	locHistTitle = locParticleROOTName + string(";p (GeV/c);#sigma_{y} (cm)");
	dHistMap_ShowerYErrorVsP[locIsBCALFlag] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, locMaxP, dNum2DXYErrorBins, 0.0, dMaxXYError);

	locHistName = "YErrorVsTheta";
	locHistTitle = locParticleROOTName + string(";#theta#circ;#sigma_{y} (cm)");
	dHistMap_ShowerYErrorVsTheta[locIsBCALFlag] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, locMinTheta, locMaxTheta, dNum2DXYErrorBins, 0.0, dMaxXYError);

	locHistName = "YErrorVsPhi";
	locHistTitle = locParticleROOTName + string(";#phi#circ;#sigma_{y} (cm)");
	dHistMap_ShowerYErrorVsPhi[locIsBCALFlag] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPhiBins, dMinPhi, dMaxPhi, dNum2DXYErrorBins, 0.0, dMaxXYError);

	// Z
	locHistName = "ZErrorVsP";
	locHistTitle = locParticleROOTName + string(";p (GeV/c);#sigma_{z} (cm)");
	dHistMap_ShowerZErrorVsP[locIsBCALFlag] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, locMaxP, dNum2DShowerZErrorBins, 0.0, dMaxShowerZError);

	locHistName = "ZErrorVsTheta";
	locHistTitle = locParticleROOTName + string(";#theta#circ;#sigma_{z} (cm)");
	dHistMap_ShowerZErrorVsTheta[locIsBCALFlag] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, locMinTheta, locMaxTheta, dNum2DShowerZErrorBins, 0.0, dMaxShowerZError);

	locHistName = "ZErrorVsPhi";
	locHistTitle = locParticleROOTName + string(";#phi#circ;#sigma_{z} (cm)");
	dHistMap_ShowerZErrorVsPhi[locIsBCALFlag] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPhiBins, dMinPhi, dMaxPhi, dNum2DShowerZErrorBins, 0.0, dMaxShowerZError);

	// T
	locHistName = "TErrorVsP";
	locHistTitle = locParticleROOTName + string(";p (GeV/c);#sigma_{t} (ns)");
	dHistMap_ShowerTErrorVsP[locIsBCALFlag] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPBins, dMinP, locMaxP, dNum2DTErrorBins, 0.0, dMaxTError);

	locHistName = "TErrorVsTheta";
	locHistTitle = locParticleROOTName + string(";#theta#circ;#sigma_{t} (ns)");
	dHistMap_ShowerTErrorVsTheta[locIsBCALFlag] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DThetaBins, locMinTheta, locMaxTheta, dNum2DTErrorBins, 0.0, dMaxTError);

	locHistName = "TErrorVsPhi";
	locHistTitle = locParticleROOTName + string(";#phi#circ;#sigma_{t} (ns)");
	dHistMap_ShowerTErrorVsPhi[locIsBCALFlag] = GetOrCreate_Histogram<TH2I>(locHistName, locHistTitle, dNum2DPhiBins, dMinPhi, dMaxPhi, dNum2DTErrorBins, 0.0, dMaxTError);

	gDirectory(TDirectory::CurrentDirectory())->cd("..");
}

//Return to the base directory
ChangeTo_BaseDirectory();
}
japp->RootUnLock(); //RELEASE ROOT LOCK!!
3311}

3313bool DHistogramAction_TrackShowerErrors::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
3314{
if(Get_CalledPriorWithComboFlag())
return true; //else double-counting!

vector<const DChargedTrack*> locPreSelectChargedTracks;
locEventLoop->Get(locPreSelectChargedTracks, dTrackSelectionTag.c_str());

for(size_t loc_i = 0; loc_i < locPreSelectChargedTracks.size(); ++loc_i)
{
const DChargedTrackHypothesis* locChargedTrackHypothesis = locPreSelectChargedTracks[loc_i]->Get_BestFOM();

Particle_t locPID = (locChargedTrackHypothesis->Get_FOM() < dMinPIDFOM) ? Unknown : locChargedTrackHypothesis->PID();
if(dHistMap_TrackPxErrorVsP.find(locPID) == dHistMap_TrackPxErrorVsP.end())
	continue; //not interested in histogramming

DVector3 locMomentum = locChargedTrackHypothesis->momentum();
double locPhi = locMomentum.Phi()*180.0/TMath::Pi();
double locTheta = locMomentum.Theta()*180.0/TMath::Pi();
double locP = locMomentum.Mag();

const TMatrixFSym& locCovarianceMatrix = *(locChargedTrackHypothesis->errorMatrix().get());
double locPxError = sqrt(locCovarianceMatrix(0, 0));
double locPyError = sqrt(locCovarianceMatrix(1, 1));
double locPzError = sqrt(locCovarianceMatrix(2, 2));
double locXError = sqrt(locCovarianceMatrix(3, 3));
double locYError = sqrt(locCovarianceMatrix(4, 4));
double locZError = sqrt(locCovarianceMatrix(5, 5));

//FILL HISTOGRAMS
//Since we are filling histograms local to this action, it will not interfere with other ROOT operations: can use action-wide ROOT lock
//Note, the mutex is unique to this DReaction + action_string combo: actions of same class with different hists will have a different mutex
Lock_Action();
{
	dHistMap_TrackPxErrorVsP[locPID]->Fill(locP, locPxError);
	dHistMap_TrackPxErrorVsTheta[locPID]->Fill(locTheta, locPxError);
	dHistMap_TrackPxErrorVsPhi[locPID]->Fill(locPhi, locPxError);

	dHistMap_TrackPyErrorVsP[locPID]->Fill(locP, locPyError);
	dHistMap_TrackPyErrorVsTheta[locPID]->Fill(locTheta, locPyError);
	dHistMap_TrackPyErrorVsPhi[locPID]->Fill(locPhi, locPyError);

	dHistMap_TrackPzErrorVsP[locPID]->Fill(locP, locPzError);
	dHistMap_TrackPzErrorVsTheta[locPID]->Fill(locTheta, locPzError);
	dHistMap_TrackPzErrorVsPhi[locPID]->Fill(locPhi, locPzError);

	dHistMap_TrackXErrorVsP[locPID]->Fill(locP, locXError);
	dHistMap_TrackXErrorVsTheta[locPID]->Fill(locTheta, locXError);
	dHistMap_TrackXErrorVsPhi[locPID]->Fill(locPhi, locXError);

	dHistMap_TrackYErrorVsP[locPID]->Fill(locP, locYError);
	dHistMap_TrackYErrorVsTheta[locPID]->Fill(locTheta, locYError);
	dHistMap_TrackYErrorVsPhi[locPID]->Fill(locPhi, locYError);

	dHistMap_TrackZErrorVsP[locPID]->Fill(locP, locZError);
	dHistMap_TrackZErrorVsTheta[locPID]->Fill(locTheta, locZError);
	dHistMap_TrackZErrorVsPhi[locPID]->Fill(locPhi, locZError);
}
Unlock_Action();
}

vector<const DNeutralParticle*> locNeutralParticles;
locEventLoop->Get(locNeutralParticles, dShowerSelectionTag.c_str());

for(size_t loc_i = 0; loc_i < locNeutralParticles.size(); ++loc_i)
{
// Only plotting photons for now, maybe we want to include neutrons at some point?
const DNeutralParticleHypothesis* locNeutralParticleHypothesis = locNeutralParticles[loc_i]->Get_Hypothesis(Gamma);
if(locNeutralParticleHypothesis == nullptr)  // no photon hypothesis!
	continue;
if(locNeutralParticleHypothesis->Get_FOM() < dMinPIDFOM)
	continue;

DVector3 locMomentum = locNeutralParticleHypothesis->momentum();
double locPhi = locMomentum.Phi()*180.0/TMath::Pi();
double locTheta = locMomentum.Theta()*180.0/TMath::Pi();
double locP = locMomentum.Mag();

const DNeutralShower* locNeutralShower = locNeutralParticles[loc_i]->dNeutralShower;
const TMatrixFSym& locCovarianceMatrix = *(locNeutralShower->dCovarianceMatrix);
bool locIsBCALFlag = (locNeutralShower->dDetectorSystem == SYS_BCAL);
double locEError = sqrt(locCovarianceMatrix(0, 0));
double locXError = sqrt(locCovarianceMatrix(1, 1));
double locYError = sqrt(locCovarianceMatrix(2, 2));
double locZError = sqrt(locCovarianceMatrix(3, 3));
double locTError = sqrt(locCovarianceMatrix(4, 4));

//FILL HISTOGRAMS
//Since we are filling histograms local to this action, it will not interfere with other ROOT operations: can use action-wide ROOT lock
//Note, the mutex is unique to this DReaction + action_string combo: actions of same class with different hists will have a different mutex
Lock_Action();
{
	dHistMap_ShowerEErrorVsP[locIsBCALFlag]->Fill(locP, locEError);
	dHistMap_ShowerEErrorVsTheta[locIsBCALFlag]->Fill(locTheta, locEError);
	dHistMap_ShowerEErrorVsPhi[locIsBCALFlag]->Fill(locPhi, locEError);

	dHistMap_ShowerXErrorVsP[locIsBCALFlag]->Fill(locP, locXError);
	dHistMap_ShowerXErrorVsTheta[locIsBCALFlag]->Fill(locTheta, locXError);
	dHistMap_ShowerXErrorVsPhi[locIsBCALFlag]->Fill(locPhi, locXError);

	dHistMap_ShowerYErrorVsP[locIsBCALFlag]->Fill(locP, locYError);
	dHistMap_ShowerYErrorVsTheta[locIsBCALFlag]->Fill(locTheta, locYError);
	dHistMap_ShowerYErrorVsPhi[locIsBCALFlag]->Fill(locPhi, locYError);

	dHistMap_ShowerZErrorVsP[locIsBCALFlag]->Fill(locP, locZError);
	dHistMap_ShowerZErrorVsTheta[locIsBCALFlag]->Fill(locTheta, locZError);
	dHistMap_ShowerZErrorVsPhi[locIsBCALFlag]->Fill(locPhi, locZError);

	dHistMap_ShowerTErrorVsP[locIsBCALFlag]->Fill(locP, locTError);
	dHistMap_ShowerTErrorVsTheta[locIsBCALFlag]->Fill(locTheta, locTError);
	dHistMap_ShowerTErrorVsPhi[locIsBCALFlag]->Fill(locPhi, locTError);
}
Unlock_Action();
}

return true;
3429}

3431void DHistogramAction_NumReconstructedObjects::Initialize(JEventLoop* locEventLoop)
3432{
string locHistName;

bool locIsRESTEvent = locEventLoop->GetJEvent().GetStatusBit(kSTATUS_REST);

//CREATE THE HISTOGRAMS
//Since we are creating histograms, the contents of gDirectory will be modified: must use JANA-wide ROOT lock
japp->RootWriteLock(); //ACQUIRE ROOT LOCK!!
{
CreateAndChangeTo_ActionDirectory();

//2D Summary
locHistName = "NumHighLevelObjects";
if(gDirectory(TDirectory::CurrentDirectory())->Get(locHistName.c_str()) != NULL__null) //already created by another thread, or directory name is duplicate (e.g. two identical steps)
	dHist_NumHighLevelObjects = static_cast<TH2D*>(gDirectory(TDirectory::CurrentDirectory())->Get(locHistName.c_str()));
else
{
	dHist_NumHighLevelObjects = new TH2D(locHistName.c_str(), ";;# Objects / Event", 14, 0.5, 14.5, dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);
	dHist_NumHighLevelObjects->GetXaxis()->SetBinLabel(1, "DRFTime");
	dHist_NumHighLevelObjects->GetXaxis()->SetBinLabel(2, "DSCHit");
	dHist_NumHighLevelObjects->GetXaxis()->SetBinLabel(3, "DTOFPoint");
	dHist_NumHighLevelObjects->GetXaxis()->SetBinLabel(4, "DBCALShower");
	dHist_NumHighLevelObjects->GetXaxis()->SetBinLabel(5, "DFCALShower");
	dHist_NumHighLevelObjects->GetXaxis()->SetBinLabel(6, "DTimeBasedTrack");
	dHist_NumHighLevelObjects->GetXaxis()->SetBinLabel(7, "TrackSCMatches");
	dHist_NumHighLevelObjects->GetXaxis()->SetBinLabel(8, "TrackTOFMatches");
	dHist_NumHighLevelObjects->GetXaxis()->SetBinLabel(9, "TrackBCALMatches");
	dHist_NumHighLevelObjects->GetXaxis()->SetBinLabel(10, "TrackFCALMatches");
	dHist_NumHighLevelObjects->GetXaxis()->SetBinLabel(11, "DBeamPhoton");
	dHist_NumHighLevelObjects->GetXaxis()->SetBinLabel(12, "DChargedTrack");
	dHist_NumHighLevelObjects->GetXaxis()->SetBinLabel(13, "DNeutralShower");
	dHist_NumHighLevelObjects->GetXaxis()->SetBinLabel(14, "DCCALShower");
	
}

//Charged
locHistName = "NumChargedTracks";
dHist_NumChargedTracks = GetOrCreate_Histogram<TH1D>(locHistName, ";# DChargedTrack", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);
locHistName = "NumPosChargedTracks";
dHist_NumPosChargedTracks = GetOrCreate_Histogram<TH1D>(locHistName, ";# #it{q}^{+} DChargedTrack", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);
locHistName = "NumNegChargedTracks";
dHist_NumNegChargedTracks = GetOrCreate_Histogram<TH1D>(locHistName, ";# #it{q}^{-} DChargedTrack", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);

//TBT
locHistName = "NumTimeBasedTracks";
dHist_NumTimeBasedTracks = GetOrCreate_Histogram<TH1D>(locHistName, ";# Time-Based Tracks", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);
locHistName = "NumPosTimeBasedTracks";
dHist_NumPosTimeBasedTracks = GetOrCreate_Histogram<TH1D>(locHistName, ";# #it{q}^{+} Time-Based Tracks", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);
locHistName = "NumNegTimeBasedTracks";
dHist_NumNegTimeBasedTracks = GetOrCreate_Histogram<TH1D>(locHistName, ";# #it{q}^{-} Time-Based Tracks", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);

if(!locIsRESTEvent)
{
	//WBT
	locHistName = "NumWireBasedTracks";
	dHist_NumWireBasedTracks = GetOrCreate_Histogram<TH1D>(locHistName, ";# Wire-Based Tracks", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);
	locHistName = "NumPosWireBasedTracks";
	dHist_NumPosWireBasedTracks = GetOrCreate_Histogram<TH1D>(locHistName, ";# #it{q}^{-} Wire-Based Tracks", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);
	locHistName = "NumNegWireBasedTracks";
	dHist_NumNegWireBasedTracks = GetOrCreate_Histogram<TH1D>(locHistName, ";# #it{q}^{-} Wire-Based Tracks", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);

	//Track Candidates
	locHistName = "NumTrackCandidates";
	dHist_NumTrackCandidates = GetOrCreate_Histogram<TH1D>(locHistName, ";# Track Candidates", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);
	locHistName = "NumPosTrackCandidates";
	dHist_NumPosTrackCandidates = GetOrCreate_Histogram<TH1D>(locHistName, ";# #it{q}^{+} Track Candidates", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);
	locHistName = "NumNegTrackCandidates";
	dHist_NumNegTrackCandidates = GetOrCreate_Histogram<TH1D>(locHistName, ";# #it{q}^{-} Track Candidates", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);

	//CDC Track Candidates
	locHistName = "NumPosTrackCandidates_CDC";
	dHist_NumPosTrackCandidates_CDC = GetOrCreate_Histogram<TH1D>(locHistName, ";# #it{q}^{+} CDC Track Candidates", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);
	locHistName = "NumNegTrackCandidates_CDC";
	dHist_NumNegTrackCandidates_CDC = GetOrCreate_Histogram<TH1D>(locHistName, ";# #it{q}^{-} CDC Track Candidates", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);

	//FDC Track Candidates
	locHistName = "NumPosTrackCandidates_FDC";
	dHist_NumPosTrackCandidates_FDC = GetOrCreate_Histogram<TH1D>(locHistName, ";# #it{q}^{+} FDC Track Candidates", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);
	locHistName = "NumNegTrackCandidates_FDC";
	dHist_NumNegTrackCandidates_FDC = GetOrCreate_Histogram<TH1D>(locHistName, ";# #it{q}^{-} FDC Track Candidates", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);
}

//Beam Photons
locHistName = "NumBeamPhotons";
dHist_NumBeamPhotons = GetOrCreate_Histogram<TH1D>(locHistName, ";# DBeamPhoton", dMaxNumBeamPhotons + 1, -0.5, (float)dMaxNumBeamPhotons + 0.5);

//Showers / Neutrals / TOF / SC
locHistName = "NumFCALShowers";
dHist_NumFCALShowers = GetOrCreate_Histogram<TH1D>(locHistName, ";# DFCALShower", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);
locHistName = "NumCCALShowers";
dHist_NumCCALShowers = GetOrCreate_Histogram<TH1D>(locHistName, ";# DCCALShower", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);
locHistName = "NumBCALShowers";
dHist_NumBCALShowers = GetOrCreate_Histogram<TH1D>(locHistName, ";# DBCALShower", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);
locHistName = "NumNeutralShowers";
dHist_NumNeutralShowers = GetOrCreate_Histogram<TH1D>(locHistName, ";# DNeutralShower", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);
locHistName = "NumTOFPoints";
dHist_NumTOFPoints = GetOrCreate_Histogram<TH1D>(locHistName, ";# DTOFPoint", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);
locHistName = "NumSCHits";
dHist_NumSCHits = GetOrCreate_Histogram<TH1D>(locHistName, ";# DSCHit", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);

if(!locIsRESTEvent)
{
	locHistName = "NumTAGMHits";
	dHist_NumTAGMHits = GetOrCreate_Histogram<TH1D>(locHistName, ";# DTAGMHit", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);
	locHistName = "NumTAGHHits";
	dHist_NumTAGHHits = GetOrCreate_Histogram<TH1D>(locHistName, ";# DTAGHHit", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);
}

//Matches
locHistName = "NumTrackBCALMatches";
dHist_NumTrackBCALMatches = GetOrCreate_Histogram<TH1D>(locHistName, ";# Track-BCAL Matches", dMaxNumMatchObjects + 1, -0.5, (float)dMaxNumMatchObjects + 0.5);
locHistName = "NumTrackFCALMatches";
dHist_NumTrackFCALMatches = GetOrCreate_Histogram<TH1D>(locHistName, ";# Track-FCAL Matches", dMaxNumMatchObjects + 1, -0.5, (float)dMaxNumMatchObjects + 0.5);
locHistName = "NumTrackTOFMatches";
dHist_NumTrackTOFMatches = GetOrCreate_Histogram<TH1D>(locHistName, ";# Track-TOF Matches", dMaxNumMatchObjects + 1, -0.5, (float)dMaxNumMatchObjects + 0.5);
locHistName = "NumTrackSCMatches";
dHist_NumTrackSCMatches = GetOrCreate_Histogram<TH1D>(locHistName, ";# Track-SC Matches", dMaxNumMatchObjects + 1, -0.5, (float)dMaxNumMatchObjects + 0.5);

if(!locIsRESTEvent)
{
	//Hits
	locHistName = "NumCDCHits";
	dHist_NumCDCHits = GetOrCreate_Histogram<TH1I>(locHistName, ";# DCDCHit", dMaxNumCDCHits + 1, -0.5, (float)dMaxNumCDCHits + 0.5);
	locHistName = "NumFDCWireHits";
	dHist_NumFDCWireHits = GetOrCreate_Histogram<TH1I>(locHistName, ";# Wire DFDCHit", dMaxNumFDCHits/2 + 1, -0.5, (float)dMaxNumFDCHits - 0.5 + 2.0);
	locHistName = "NumFDCCathodeHits";
	dHist_NumFDCCathodeHits = GetOrCreate_Histogram<TH1I>(locHistName, ";# Cathode DFDCHit", dMaxNumFDCHits/2 + 1, -0.5, (float)dMaxNumFDCHits - 0.5 + 2.0);
	locHistName = "NumFDCPseudoHits";
	dHist_NumFDCPseudoHits = GetOrCreate_Histogram<TH1I>(locHistName, ";# FDC Pseudo Hits", dMaxNumFDCHits/2 + 1, -0.5, (float)dMaxNumFDCHits - 0.5 + 2.0);

	locHistName = "NumTOFHits";
	dHist_NumTOFHits = GetOrCreate_Histogram<TH1I>(locHistName, ";# DTOFHit", dMaxNumTOFCalorimeterHits + 1, -0.5, (float)dMaxNumTOFCalorimeterHits + 0.5);
	locHistName = "NumBCALHits";
	dHist_NumBCALHits = GetOrCreate_Histogram<TH1I>(locHistName, ";# DBCALHit", dMaxNumTOFCalorimeterHits + 1, -0.5, (float)dMaxNumTOFCalorimeterHits + 0.5);
	locHistName = "NumFCALHits";
	dHist_NumFCALHits = GetOrCreate_Histogram<TH1I>(locHistName, ";# DFCALHit", dMaxNumTOFCalorimeterHits + 1, -0.5, (float)dMaxNumTOFCalorimeterHits + 0.5);
	locHistName = "NumCCALHits";
	dHist_NumCCALHits = GetOrCreate_Histogram<TH1I>(locHistName, ";# DFCALHit", dMaxNumTOFCalorimeterHits + 1, -0.5, (float)dMaxNumTOFCalorimeterHits + 0.5);

	locHistName = "NumRFSignals";
	dHist_NumRFSignals = GetOrCreate_Histogram<TH1I>(locHistName, ";# DRFDigiTime + # DRFTDCDigiTime", dMaxNumObjects + 1, -0.5, (float)dMaxNumObjects + 0.5);
}

//Return to the base directory
ChangeTo_BaseDirectory();
}
japp->RootUnLock(); //RELEASE ROOT LOCK!!
3579}

3581bool DHistogramAction_NumReconstructedObjects::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
3582{
if(Get_CalledPriorWithComboFlag())
return true; //else double-counting!

bool locIsRESTEvent = locEventLoop->GetJEvent().GetStatusBit(kSTATUS_REST);

vector<const DTrackTimeBased*> locTrackTimeBasedVector;
locEventLoop->Get(locTrackTimeBasedVector);

vector<const DBeamPhoton*> locBeamPhotons;
locEventLoop->Get(locBeamPhotons);

vector<const DFCALShower*> locFCALShowers;
locEventLoop->Get(locFCALShowers);

vector<const DCCALShower*> locCCALShowers;
locEventLoop->Get(locCCALShowers);

vector<const DChargedTrack*> locChargedTracks;
locEventLoop->Get(locChargedTracks);

vector<const DBCALShower*> locBCALShowers;
locEventLoop->Get(locBCALShowers);

vector<const DNeutralShower*> locNeutralShowers;
locEventLoop->Get(locNeutralShowers);

vector<const DTOFPoint*> locTOFPoints;
locEventLoop->Get(locTOFPoints);

vector<const DSCHit*> locSCHits;
locEventLoop->Get(locSCHits);

vector<const DRFTime*> locRFTimes;
locEventLoop->Get(locRFTimes);

const DDetectorMatches* locDetectorMatches = NULL__null;
locEventLoop->GetSingle(locDetectorMatches);

//if not REST
vector<const DTrackWireBased*> locTrackWireBasedVector;
vector<const DTrackCandidate*> locTrackCandidates;
vector<const DTrackCandidate*> locTrackCandidates_CDC;
vector<const DTrackCandidate*> locTrackCandidates_FDC;
vector<const DCDCHit*> locCDCHits;
vector<const DFDCHit*> locFDCHits;
vector<const DTOFHit*> locTOFHits;
vector<const DBCALHit*> locBCALHits;
vector<const DFCALHit*> locFCALHits;
vector<const DCCALHit*> locCCALHits;
vector<const DTAGMHit*> locTAGMHits;
vector<const DTAGHHit*> locTAGHHits;
vector<const DFDCPseudo*> locFDCPseudoHits;
vector<const DRFDigiTime*> locRFDigiTimes;
vector<const DRFTDCDigiTime*> locRFTDCDigiTimes;

size_t locNumFDCWireHits = 0, locNumFDCCathodeHits = 0;
if(!locIsRESTEvent)
{
locEventLoop->Get(locTrackWireBasedVector);
locEventLoop->Get(locTrackCandidates);
locEventLoop->Get(locTrackCandidates_CDC, "CDC");
locEventLoop->Get(locTrackCandidates_FDC, "FDCCathodes");
locEventLoop->Get(locCDCHits);
locEventLoop->Get(locFDCHits);
locEventLoop->Get(locFDCPseudoHits);
locEventLoop->Get(locTOFHits);
locEventLoop->Get(locBCALHits);
locEventLoop->Get(locFCALHits);
locEventLoop->Get(locCCALHits);
locEventLoop->Get(locTAGHHits);
locEventLoop->Get(locTAGMHits);
locEventLoop->Get(locRFDigiTimes);
locEventLoop->Get(locRFTDCDigiTimes);

for(size_t loc_i = 0; loc_i < locFDCHits.size(); ++loc_i)
{
	if(locFDCHits[loc_i]->type == DFDCHit::AnodeWire)
		++locNumFDCWireHits;
	else
		++locNumFDCCathodeHits;
}
}

//FILL HISTOGRAMS
//Since we are filling histograms local to this action, it will not interfere with other ROOT operations: can use action-wide ROOT lock
//Note, the mutex is unique to this DReaction + action_string combo: actions of same class with different hists will have a different mutex
Lock_Action(); //ACQUIRE ROOT LOCK!!
{
//# High-Level Objects
dHist_NumHighLevelObjects->Fill(1, (Double_t)locRFTimes.size());
dHist_NumHighLevelObjects->Fill(2, (Double_t)locSCHits.size());
dHist_NumHighLevelObjects->Fill(3, (Double_t)locTOFPoints.size());
dHist_NumHighLevelObjects->Fill(4, (Double_t)locBCALShowers.size());
dHist_NumHighLevelObjects->Fill(5, (Double_t)locFCALShowers.size());
dHist_NumHighLevelObjects->Fill(6, (Double_t)locTrackTimeBasedVector.size());
dHist_NumHighLevelObjects->Fill(7, (Double_t)locDetectorMatches->Get_NumTrackSCMatches());
dHist_NumHighLevelObjects->Fill(8, (Double_t)locDetectorMatches->Get_NumTrackTOFMatches());
dHist_NumHighLevelObjects->Fill(9, (Double_t)locDetectorMatches->Get_NumTrackBCALMatches());
dHist_NumHighLevelObjects->Fill(10, (Double_t)locDetectorMatches->Get_NumTrackFCALMatches());
dHist_NumHighLevelObjects->Fill(11, (Double_t)locBeamPhotons.size());
dHist_NumHighLevelObjects->Fill(12, (Double_t)locChargedTracks.size());
dHist_NumHighLevelObjects->Fill(13, (Double_t)locNeutralShowers.size());
dHist_NumHighLevelObjects->Fill(14, (Double_t)locCCALShowers.size());
//Charged
unsigned int locNumPos = 0, locNumNeg = 0;
for(size_t loc_i = 0; loc_i < locChargedTracks.size(); ++loc_i)
{
	if(ParticleCharge(locChargedTracks[loc_i]->Get_BestFOM()->PID()) > 0)
		++locNumPos;
	else
		++locNumNeg;
}
dHist_NumChargedTracks->Fill(locChargedTracks.size());
dHist_NumPosChargedTracks->Fill(locNumPos);
dHist_NumNegChargedTracks->Fill(locNumNeg);

//TBT
locNumPos = 0;  locNumNeg = 0;
for(size_t loc_i = 0; loc_i < locTrackTimeBasedVector.size(); ++loc_i)
{
	if(ParticleCharge(locTrackTimeBasedVector[loc_i]->PID()) > 0)
		++locNumPos;
	else
		++locNumNeg;
}
dHist_NumTimeBasedTracks->Fill(locTrackTimeBasedVector.size());
dHist_NumPosTimeBasedTracks->Fill(locNumPos);
dHist_NumNegTimeBasedTracks->Fill(locNumNeg);

if(!locIsRESTEvent)
{
	//WBT
	locNumPos = 0;  locNumNeg = 0;
	for(size_t loc_i = 0; loc_i < locTrackWireBasedVector.size(); ++loc_i)
	{
		if(ParticleCharge(locTrackWireBasedVector[loc_i]->PID()) > 0)
			++locNumPos;
		else
			++locNumNeg;
	}
	dHist_NumWireBasedTracks->Fill(locTrackWireBasedVector.size());
	dHist_NumPosWireBasedTracks->Fill(locNumPos);
	dHist_NumNegWireBasedTracks->Fill(locNumNeg);

	//Candidates
	locNumPos = 0;  locNumNeg = 0;
	for(size_t loc_i = 0; loc_i < locTrackCandidates.size(); ++loc_i)
	{
		if(locTrackCandidates[loc_i]->charge() > 0.0)
			++locNumPos;
		else
			++locNumNeg;
	}
	dHist_NumTrackCandidates->Fill(locTrackCandidates.size());
	dHist_NumPosTrackCandidates->Fill(locNumPos);
	dHist_NumNegTrackCandidates->Fill(locNumNeg);

	//CDC Candidates
	locNumPos = 0;  locNumNeg = 0;
	for(size_t loc_i = 0; loc_i < locTrackCandidates_CDC.size(); ++loc_i)
	{
		if(locTrackCandidates_CDC[loc_i]->charge() > 0.0)
			++locNumPos;
		else
			++locNumNeg;
	}
	dHist_NumPosTrackCandidates_CDC->Fill(locNumPos);
	dHist_NumNegTrackCandidates_CDC->Fill(locNumNeg);

	//FDC Candidates
	locNumPos = 0;  locNumNeg = 0;
	for(size_t loc_i = 0; loc_i < locTrackCandidates_FDC.size(); ++loc_i)
	{
		if(locTrackCandidates_FDC[loc_i]->charge() > 0.0)
			++locNumPos;
		else
			++locNumNeg;
	}
	dHist_NumPosTrackCandidates_FDC->Fill(locNumPos);
	dHist_NumNegTrackCandidates_FDC->Fill(locNumNeg);
}

//Beam Photons
dHist_NumBeamPhotons->Fill((Double_t)locBeamPhotons.size());

//Showers
dHist_NumFCALShowers->Fill((Double_t)locFCALShowers.size());
dHist_NumCCALShowers->Fill((Double_t)locCCALShowers.size());
dHist_NumBCALShowers->Fill((Double_t)locBCALShowers.size());
dHist_NumNeutralShowers->Fill((Double_t)locNeutralShowers.size());

//TOF & SC
dHist_NumTOFPoints->Fill((Double_t)locTOFPoints.size());
dHist_NumSCHits->Fill((Double_t)locSCHits.size());

//TAGGER
if(!locIsRESTEvent)
{
	dHist_NumTAGMHits->Fill((Double_t)locTAGMHits.size());
	dHist_NumTAGHHits->Fill((Double_t)locTAGHHits.size());
}

//Matches
dHist_NumTrackBCALMatches->Fill((Double_t)locDetectorMatches->Get_NumTrackBCALMatches());
dHist_NumTrackFCALMatches->Fill((Double_t)locDetectorMatches->Get_NumTrackFCALMatches());
dHist_NumTrackTOFMatches->Fill((Double_t)locDetectorMatches->Get_NumTrackTOFMatches());
dHist_NumTrackSCMatches->Fill((Double_t)locDetectorMatches->Get_NumTrackSCMatches());

//Hits
if(!locIsRESTEvent)
{
	dHist_NumCDCHits->Fill((Double_t)locCDCHits.size());
	dHist_NumFDCWireHits->Fill((Double_t)locNumFDCWireHits);
	dHist_NumFDCCathodeHits->Fill((Double_t)locNumFDCCathodeHits);
	dHist_NumFDCPseudoHits->Fill((Double_t)locFDCPseudoHits.size());
	dHist_NumTOFHits->Fill((Double_t)locTOFHits.size());
	dHist_NumBCALHits->Fill((Double_t)locBCALHits.size());
	dHist_NumFCALHits->Fill((Double_t)locFCALHits.size());
	dHist_NumCCALHits->Fill((Double_t)locCCALHits.size());
	dHist_NumRFSignals->Fill((Double_t)(locRFDigiTimes.size() + locRFTDCDigiTimes.size()));
}
}
Unlock_Action(); //RELEASE ROOT LOCK!!

return true;
3808}

3810void DHistogramAction_TrackMultiplicity::Initialize(JEventLoop* locEventLoop)
3811{
string locTrackSelectionTag = "NotATag", locShowerSelectionTag = "NotATag";
if(gPARMS->Exists("COMBO:TRACK_SELECT_TAG"))
gPARMS->GetParameter("COMBO:TRACK_SELECT_TAG", locTrackSelectionTag);
if(gPARMS->Exists("COMBO:SHOWER_SELECT_TAG"))
gPARMS->GetParameter("COMBO:SHOWER_SELECT_TAG", locShowerSelectionTag);

//CREATE THE HISTOGRAMS
//Since we are creating histograms, the contents of gDirectory will be modified: must use JANA-wide ROOT lock
japp->RootWriteLock(); //ACQUIRE ROOT LOCK!!
{
//So: Default tag is "", User can set it to something else
//In here, if tag is "", get from gparms, if not, leave it alone
	//If gparms value does not exist, set it to (and use) "PreSelect"
if(dTrackSelectionTag == "NotATag")
	dTrackSelectionTag = (locTrackSelectionTag == "NotATag") ? "PreSelect" : locTrackSelectionTag;
if(dShowerSelectionTag == "NotATag")
	dShowerSelectionTag = (locShowerSelectionTag == "NotATag") ? "PreSelect" : locShowerSelectionTag;

CreateAndChangeTo_ActionDirectory();

string locHistName("NumReconstructedParticles");
if(gDirectory(TDirectory::CurrentDirectory())->Get(locHistName.c_str()) != NULL__null) //already created by another thread, or directory name is duplicate (e.g. two identical steps)
	dHist_NumReconstructedParticles = static_cast<TH2D*>(gDirectory(TDirectory::CurrentDirectory())->Get(locHistName.c_str()));
else
{
	dHist_NumReconstructedParticles = new TH2D("NumReconstructedParticles", ";Particle Type;Num Particles / Event", 5 + dFinalStatePIDs.size(), -0.5, 4.5 + dFinalStatePIDs.size(), dMaxNumTracks + 1, -0.5, (float)dMaxNumTracks + 0.5);
	dHist_NumReconstructedParticles->GetXaxis()->SetBinLabel(1, "# Total");
	dHist_NumReconstructedParticles->GetXaxis()->SetBinLabel(2, "# q != 0");
	dHist_NumReconstructedParticles->GetXaxis()->SetBinLabel(3, "# q = 0");
	dHist_NumReconstructedParticles->GetXaxis()->SetBinLabel(4, "# q = +");
	dHist_NumReconstructedParticles->GetXaxis()->SetBinLabel(5, "# q = -");
	for(size_t loc_i = 0; loc_i < dFinalStatePIDs.size(); ++loc_i)
	{
		string locLabelName = string("# ") + string(ParticleName_ROOT(dFinalStatePIDs[loc_i]));
		dHist_NumReconstructedParticles->GetXaxis()->SetBinLabel(6 + loc_i, locLabelName.c_str());
	}
}

locHistName = "NumGoodReconstructedParticles";
if(gDirectory(TDirectory::CurrentDirectory())->Get(locHistName.c_str()) != NULL__null) //already created by another thread, or directory name is duplicate (e.g. two identical steps)
	dHist_NumGoodReconstructedParticles = static_cast<TH2D*>(gDirectory(TDirectory::CurrentDirectory())->Get(locHistName.c_str()));
else
{
	dHist_NumGoodReconstructedParticles = new TH2D("NumGoodReconstructedParticles", ";Particle Type;Num Particles / Event", 5 + dFinalStatePIDs.size(), -0.5, 4.5 + dFinalStatePIDs.size(), dMaxNumTracks + 1, -0.5, (float)dMaxNumTracks + 0.5);
	dHist_NumGoodReconstructedParticles->GetXaxis()->SetBinLabel(1, "# Total");
	dHist_NumGoodReconstructedParticles->GetXaxis()->SetBinLabel(2, "# q != 0");
	dHist_NumGoodReconstructedParticles->GetXaxis()->SetBinLabel(3, "# q = 0");
	dHist_NumGoodReconstructedParticles->GetXaxis()->SetBinLabel(4, "# q = +");
	dHist_NumGoodReconstructedParticles->GetXaxis()->SetBinLabel(5, "# q = -");
	for(size_t loc_i = 0; loc_i < dFinalStatePIDs.size(); ++loc_i)
	{
		string locLabelName = string("# ") + string(ParticleName_ROOT(dFinalStatePIDs[loc_i]));
		dHist_NumGoodReconstructedParticles->GetXaxis()->SetBinLabel(6 + loc_i, locLabelName.c_str());
	}
}

//Return to the base directory
ChangeTo_BaseDirectory();
}
japp->RootUnLock(); //RELEASE ROOT LOCK!!
3872}

3874bool DHistogramAction_TrackMultiplicity::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
3875{
if(Get_CalledPriorWithComboFlag())
return true; //else double-counting!

vector<const DChargedTrack*> locChargedTracks;
locEventLoop->Get(locChargedTracks);

vector<const DChargedTrack*> locGoodChargedTracks;
locEventLoop->Get(locGoodChargedTracks, dTrackSelectionTag.c_str());

// get #tracks by PID/q type 
size_t locNumPositiveTracks = 0, locNumNegativeTracks = 0; 
map<Particle_t, size_t> locNumTracksByPID;
for(size_t loc_i = 0; loc_i < locChargedTracks.size(); ++loc_i)
{
const DChargedTrackHypothesis* locChargedTrackHypothesis = locChargedTracks[loc_i]->Get_BestFOM();
Particle_t locPID = locChargedTrackHypothesis->PID();

if(locChargedTrackHypothesis->charge() > 0.0)
	++locNumPositiveTracks;
else
	++locNumNegativeTracks;

if(locNumTracksByPID.find(locPID) != locNumTracksByPID.end())
	++locNumTracksByPID[locPID];
else
	locNumTracksByPID[locPID] = 1;
}

// get # good tracks by PID/q type 
size_t locNumGoodPositiveTracks = 0, locNumGoodNegativeTracks = 0;
map<Particle_t, size_t> locNumGoodTracksByPID;
for(size_t loc_i = 0; loc_i < locGoodChargedTracks.size(); ++loc_i)
{
const DChargedTrackHypothesis* locChargedTrackHypothesis = locGoodChargedTracks[loc_i]->Get_BestFOM();
Particle_t locPID = locChargedTrackHypothesis->PID();

double locPIDFOM = locChargedTrackHypothesis->Get_FOM();

if(locChargedTrackHypothesis->charge() > 0.0)
	++locNumGoodPositiveTracks;
else
	++locNumGoodNegativeTracks;

if(locPIDFOM < dMinPIDFOM)
	continue;

if(locNumGoodTracksByPID.find(locPID) != locNumGoodTracksByPID.end())
	++locNumGoodTracksByPID[locPID];
else
	locNumGoodTracksByPID[locPID] = 1;
}

vector<const DNeutralParticle*> locNeutralParticles;
locEventLoop->Get(locNeutralParticles);

vector<const DNeutralParticle*> locGoodNeutralParticles;
locEventLoop->Get(locGoodNeutralParticles, dShowerSelectionTag.c_str());

// neutrals by pid
for(size_t loc_i = 0; loc_i < locNeutralParticles.size(); ++loc_i)
{
const DNeutralParticleHypothesis* locNeutralParticleHypothesis = locNeutralParticles[loc_i]->Get_BestFOM();
if(locNeutralParticleHypothesis->Get_FOM() < dMinPIDFOM)
	continue;

Particle_t locPID = locNeutralParticleHypothesis->PID();
if(locNumTracksByPID.find(locPID) != locNumTracksByPID.end())
	++locNumTracksByPID[locPID];
else
	locNumTracksByPID[locPID] = 1;
}

// good neutrals
for(size_t loc_i = 0; loc_i < locGoodNeutralParticles.size(); ++loc_i)
{
const DNeutralParticleHypothesis* locNeutralParticleHypothesis = locGoodNeutralParticles[loc_i]->Get_BestFOM();
if(locNeutralParticleHypothesis->Get_FOM() < dMinPIDFOM)
	continue;

Particle_t locPID = locNeutralParticleHypothesis->PID();
if(locNumGoodTracksByPID.find(locPID) != locNumGoodTracksByPID.end())
	++locNumGoodTracksByPID[locPID];
else
	locNumGoodTracksByPID[locPID] = 1;
}

size_t locNumGoodTracks = locNumGoodPositiveTracks + locNumGoodNegativeTracks;

//FILL HISTOGRAMS
//Since we are filling histograms local to this action, it will not interfere with other ROOT operations: can use action-wide ROOT lock
//Note, the mutex is unique to this DReaction + action_string combo: actions of same class with different hists will have a different mutex
Lock_Action();
{
dHist_NumReconstructedParticles->Fill(0.0, (Double_t)(locChargedTracks.size() + locNeutralParticles.size()));
dHist_NumReconstructedParticles->Fill(1.0, (Double_t)locChargedTracks.size());
dHist_NumReconstructedParticles->Fill(2.0, (Double_t)locNeutralParticles.size());
dHist_NumReconstructedParticles->Fill(3.0, (Double_t)locNumPositiveTracks);
dHist_NumReconstructedParticles->Fill(4.0, (Double_t)locNumNegativeTracks);
for(size_t loc_i = 0; loc_i < dFinalStatePIDs.size(); ++loc_i)
	dHist_NumReconstructedParticles->Fill(5.0 + (Double_t)loc_i, (Double_t)locNumTracksByPID[dFinalStatePIDs[loc_i]]);

dHist_NumGoodReconstructedParticles->Fill(0.0, (Double_t)(locNumGoodTracks + locGoodNeutralParticles.size()));
dHist_NumGoodReconstructedParticles->Fill(1.0, (Double_t)locNumGoodTracks);
dHist_NumGoodReconstructedParticles->Fill(2.0, (Double_t)locGoodNeutralParticles.size());
dHist_NumGoodReconstructedParticles->Fill(3.0, (Double_t)locNumGoodPositiveTracks);
dHist_NumGoodReconstructedParticles->Fill(4.0, (Double_t)locNumGoodNegativeTracks);
for(size_t loc_i = 0; loc_i < dFinalStatePIDs.size(); ++loc_i)
	dHist_NumGoodReconstructedParticles->Fill(5.0 + (Double_t)loc_i, (Double_t)locNumGoodTracksByPID[dFinalStatePIDs[loc_i]]);
}
Unlock_Action();

return true;
3988}

3990// DHistogramAction_TriggerStudies
3991// dHist_Trigger_FCALBCAL_Energy

3993void DHistogramAction_TriggerStudies::Initialize(JEventLoop* locEventLoop)
3994{

//CREATE THE HISTOGRAMS
//Since we are creating histograms, the contents of gDirectory will be modified: must use JANA-wide ROOT lock
japp->RootWriteLock(); //ACQUIRE ROOT LOCK!!
{
CreateAndChangeTo_ActionDirectory();

string locHistName("Trigger_BCALFCAL_Energy");
if(gDirectory(TDirectory::CurrentDirectory())->Get(locHistName.c_str()) != NULL__null) //already created by another thread, or directory name is duplicate (e.g. two identical steps)
	dHist_Trigger_FCALBCAL_Energy = static_cast<TH2D*>(gDirectory(TDirectory::CurrentDirectory())->Get(locHistName.c_str()));
else
{
	dHist_Trigger_FCALBCAL_Energy = new TH2D("Trigger_BCALFCAL_Energy", ";GTP FCAL Energy [GeV] / 5 MeV;GTP BCAL Energy [GeV] / 5 MeV", dFCALBins, 0, dMaxFCALEnergy, dBCALBins, 0, dMaxBCALEnergy);
}

//Return to the base directory
ChangeTo_BaseDirectory();
}
japp->RootUnLock(); //RELEASE ROOT LOCK!!
4014}

4016bool DHistogramAction_TriggerStudies::Perform_Action(JEventLoop* locEventLoop, const DParticleCombo* locParticleCombo)
4017{
if(Get_CalledPriorWithComboFlag())
return true; //else double-counting!

//CHECK TRIGGER TYPE
const DTrigger* locTrigger = NULL__null;
locEventLoop->GetSingle(locTrigger);
if(locTrigger == nullptr)
return true;


//FILL HISTOGRAMS
//Since we are filling histograms local to this action, it will not interfere with other ROOT operations: can use action-wide ROOT lock
//Note, the mutex is unique to this DReaction + action_string combo: actions of same class with different hists will have a different mutex
Lock_Action();
{
dHist_Trigger_FCALBCAL_Energy->Fill(locTrigger->Get_GTP_FCALEnergy(), locTrigger->Get_GTP_BCALEnergy());
}
Unlock_Action();

return true;
4038}


←

/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//
7 
8#ifndef _JEventLoop_
9#define _JEventLoop_
10 
11#include <sys/time.h>
12 
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;
25 
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>
36 
37// The following is here just so we can use ROOT's THtml class to generate documentation.
38#include "cint.h"
39 
40 
41// Place everything in JANA namespace
42namespace jana{
43 
44 
45template<class T> class JFactory;
46class JApplication;
47class JEventProcessor;
48 
49 
50class JEventLoop{
51	public:
52	
53		friend class JApplication;
54	
55		enum data_source_t{
56			DATA_NOT_AVAILABLE = 1,
57			DATA_FROM_CACHE,
58			DATA_FROM_SOURCE,
59			DATA_FROM_FACTORY
60		};
61		
62		typedef struct{
63			string caller_name;
64			string caller_tag;
65			string callee_name;
66			string callee_tag;
67			double start_time;
68			double end_time;
69			data_source_t data_source;
70		}call_stack_t;
71		
72		typedef struct{
73			const char* factory_name;
74			string tag;
75			const char* filename;
76			int line;
77		}error_call_stack_t;
78 
79	                                   JEventLoop(JApplication *app); ///< Constructor
80							   virtual ~JEventLoop(); ////< Destructor
81				   virtual const char* className(void){return static_className();}
82					static const char* static_className(void){return "JEventLoop";}
83		
84						 JApplication* GetJApplication(void) const {return app;} ///< Get pointer to the JApplication object
85                                  void RefreshProcessorListFromJApplication(void); ///< Re-copy the list of JEventProcessors from JApplication
86                      virtual jerror_t AddFactory(JFactory_base* factory); ///< Add a factory
87							  jerror_t RemoveFactory(JFactory_base* factory); ///< Remove a factory
88                        JFactory_base* GetFactory(const string data_name, const char *tag="", bool allow_deftag=true); ///< Get a specific factory pointer
89                vector<JFactory_base*> GetFactories(void) const {return factories;} ///< Get all factory pointers
90                                  void GetFactoryNames(vector<string> &factorynames); ///< Get names of all factories in name:tag format
91                                  void GetFactoryNames(map<string,string> &factorynames); ///< Get names of all factories in map with key=name, value=tag
92                    map<string,string> GetDefaultTags(void) const {return default_tags;}
93                              jerror_t ClearFactories(void); ///< Reset all factories in preparation for next event.
94							  jerror_t PrintFactories(int sparsify=0); ///< Print a list of all factories.
95                              jerror_t Print(const string data_name, const char *tag=""); ///< Print the data of the given type
96 
97						 JCalibration* GetJCalibration();
98                template<class T> bool GetCalib(string namepath, map<string,T> &vals);
99                template<class T> bool GetCalib(string namepath, vector<T> &vals);
100                template<class T> bool GetCalib(string namepath, T &val);
101 
102                            JGeometry* GetJGeometry();
103                template<class T> bool GetGeom(string namepath, map<string,T> &vals);
104			    template<class T> bool GetGeom(string namepath, T &val);
105 
106                     JResourceManager* GetJResourceManager(void);
107                                string GetResource(string namepath);
108                template<class T> bool GetResource(string namepath, T vals, int event_number=0);
109 
110                                  void Initialize(void); ///< Do initializations just before event processing starts
111                              jerror_t Loop(void); ///< Loop over events
112                              jerror_t OneEvent(uint64_t event_number); ///< Process a specific single event (if source supports it)
113                              jerror_t OneEvent(void); ///< Process a single event
114                           inline void Pause(void){pause = 1;} ///< Pause event processing
115                           inline void Resume(void){pause = 0;} ///< Resume event processing
116                           inline void Quit(void){quit = 1;} ///< Clean up and exit the event loop
117                           inline bool GetQuit(void) const {return quit;}
118                                  void QuitProgram(void);
119 
120		                               // Support for random access of events
121		                          bool HasRandomAccess(void);
122		                          void AddToEventQueue(uint64_t event_number){ next_events_to_process.push_back(event_number); }
123		                          void AddToEventQueue(list<uint64_t> &event_numbers) { next_events_to_process.insert(next_events_to_process.end(), event_numbers.begin(), event_numbers.end()); }
124		                list<uint64_t> GetEventQueue(void){ return next_events_to_process; }
125		                          void ClearEventQueue(void){ next_events_to_process.clear(); }
126 
127        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).
128        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)
129        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
130            template<class T> jerror_t GetFromSource(vector<const T*> &t, JFactory_base *factory=NULL__null); ///< Get data object pointers from source.
131                        inline JEvent& GetJEvent(void){return event;} ///< Get pointer to the current JEvent object.
132                           inline void SetJEvent(JEvent *event){this->event = *event;} ///< Set the JEvent pointer.
133                           inline void SetAutoFree(int auto_free){this->auto_free = auto_free;} ///< Set the Auto-Free flag on/off
134                      inline pthread_t GetPThreadID(void) const {return pthread_id;} ///< Get the pthread of the thread to which this JEventLoop belongs
135                                double GetInstantaneousRate(void) const {return rate_instantaneous;} ///< Get the current event processing rate
136                                double GetIntegratedRate(void) const {return rate_integrated;} ///< Get the current event processing rate
137                                double GetLastEventProcessingTime(void) const {return delta_time_single;}
138                          unsigned int GetNevents(void) const {return Nevents;}
139 
140                           inline bool CheckEventBoundary(uint64_t event_numberA, uint64_t event_numberB);
141 
142                           inline bool GetCallStackRecordingStatus(void){ return record_call_stack; }
143                           inline void DisableCallStackRecording(void){ record_call_stack = false; }
144                           inline void EnableCallStackRecording(void){ record_call_stack = true; }
145		                     inline void CallStackStart(JEventLoop::call_stack_t &cs, const string &caller_name, const string &caller_tag, const string callee_name, const string callee_tag);
146		                     inline void CallStackEnd(JEventLoop::call_stack_t &cs);
147           inline vector<call_stack_t> GetCallStack(void){return call_stack;} ///< Get the current factory call stack
148                           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
149                           inline void AddToErrorCallStack(error_call_stack_t &cs){error_call_stack.push_back(cs);} ///< Add layer to the factory call stack
150     inline vector<error_call_stack_t> GetErrorCallStack(void){return error_call_stack;} ///< Get the current factory error call stack
151                                  void PrintErrorCallStack(void); ///< Print the current factory call stack
152 
153                        const JObject* FindByID(JObject::oid_t id); ///< Find a data object by its identifier.
154            template<class T> const T* FindByID(JObject::oid_t id); ///< Find a data object by its type and identifier
155                        JFactory_base* FindOwner(const JObject *t); ///< Find the factory that owns a data object by pointer
156                        JFactory_base* FindOwner(JObject::oid_t id); ///< Find a factory that owns a data object by identifier
157 
158                                       // User defined references
159                template<class T> void SetRef(T *t);    ///< Add a user reference to this JEventLoop (must be a pointer)
160                  template<class T> T* GetRef(void);   ///< Get a user-defined reference of a specific type
161          template<class T> vector<T*> GetRefsT(void); ///< Get all user-defined refrences of a specicif type
162     vector<pair<const char*, void*> > GetRefs(void){ return user_refs; }  ///< Get copy of full list of user-defined references
163                template<class T> void RemoveRef(T *t); ///< Remove user reference from list
164 
165									   // Convenience methods wrapping JEvent methods of same name
166		                      uint64_t GetStatus(void){return event.GetStatus();}
167		                          bool GetStatusBit(uint32_t bit){return event.GetStatusBit(bit);}
168		                          bool SetStatusBit(uint32_t bit, bool val=true){return event.SetStatusBit(bit, val);}
169		                          bool ClearStatusBit(uint32_t bit){return event.ClearStatusBit(bit);}
170		                          void ClearStatus(void){event.ClearStatus();}
171		                          void SetStatusBitDescription(uint32_t bit, string description){event.SetStatusBitDescription(bit, description);}
172		                        string GetStatusBitDescription(uint32_t bit){return event.GetStatusBitDescription(bit);}
173		                          void GetStatusBitDescriptions(map<uint32_t, string> &status_bit_descriptions){return event.GetStatusBitDescriptions(status_bit_descriptions);}
174                                string StatusWordToString(void);
175 
176	private:
177		JEvent event;
178		vector<JFactory_base*> factories;
179		vector<JEventProcessor*> processors;
180		vector<error_call_stack_t> error_call_stack;
181		vector<call_stack_t> call_stack;
182		JApplication *app;
183		JThread *jthread;
184		bool initialized;
185		bool print_parameters_called;
186		int pause;
187		int quit;
188		int auto_free;
189		pthread_t pthread_id;
190		map<string, string> default_tags;
191		vector<pair<string,string> > auto_activated_factories;
192		bool record_call_stack;
193		string caller_name;
194		string caller_tag;
195		vector<uint64_t> event_boundaries;
196		int32_t event_boundaries_run; ///< Run number boundaries were retrieved from (possbily 0)
197		list<uint64_t> next_events_to_process;
198		
199		uint64_t Nevents;			      ///< Total events processed (this thread)
200		uint64_t Nevents_rate;		   ///< Num. events accumulated for "instantaneous" rate
201		double delta_time_single;		///< Time spent processing last event
202		double delta_time_rate;			///< Integrated time accumulated "instantaneous" rate (partial number of events)
203		double delta_time;				///< Total time spent processing events (this thread)
204		double rate_instantaneous;		///< Latest instantaneous rate
205		double rate_integrated;			///< Rate integrated over all events
206   
207		static data_source_t null_data_source;
208 
209		vector<pair<const char*, void*> > user_refs;
210};
211 
212 
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
218 
219#if !defined(__CINT__) && !defined(__CLING__)
220 
221//-------------
222// GetSingle
223//-------------
224template<class T>
225JFactory<T>* JEventLoop::GetSingle(const T* &t, const char *tag, bool exception_if_not_one)
226{
227	/// This is a convenience method that can be used to get a pointer to the single
228	/// object of type T from the specified factory. It simply calls the Get(vector<...>) method
229	/// and copies the first pointer into "t" (or NULL if something other than 1 object is returned).
230	/// 
231	/// This is intended to address the common situation in which there is an interest
232	/// in the event if and only if there is exactly 1 object of type T. If the event
233	/// has no objects of that type or more than 1 object of that type (for the specified
234	/// factory) then an exception of type "unsigned long" is thrown with the value
235	/// being the number of objects of type T. You can supress the exception by setting
236	/// exception_if_not_one to false. In that case, you will have to check if t==NULL to
237	/// know if the call succeeded.
238	vector<const T*> v;
239	JFactory<T> *fac = Get(v, tag);
2
←
Calling 'JEventLoop::Get'→
240 
241	if(v.size()!=1){
242		t = NULL__null;
243		if(exception_if_not_one) throw v.size();
244	}
245	
246	t = v[0];
247	
248	return fac;
249}
250 
251//-------------
252// Get
253//-------------
254template<class T> 
255JFactory<T>* JEventLoop::Get(vector<const T*> &t, const char *tag, bool allow_deftag)
256{
257	/// Retrieve or generate the array of objects of
258	/// type T for the curent event being processed
259	/// by this thread.
260	///
261	/// By default, preference is given to reading the
262	/// objects from the data source(e.g. file) before generating
263	/// them in the factory. A flag exists in the factory
264	/// however to change this so that the factory is
265	/// given preference.
266	///
267	/// Note that regardless of the setting of this flag,
268	/// the data are only either read in or generated once.
269	/// Ownership of the objects will always be with the
270	/// factory so subsequent calls will always return pointers to
271	/// the same data.
272	///
273	/// If the factory is called on to generate the data,
274	/// it is done by calling the factory's Get() method
275	/// which, in turn, calls the evnt() method. 
276	/// 
277	/// First, we just call the GetFromFactory() method.
278	/// It will make the initial decision as to whether
279	/// it should look in the source first or not. If
280	/// it returns NULL, then the factory couldn't be
281	/// found so we automatically try the file.
282	///
283	/// Note that if no factory exists to hold the objects
284	/// from the file, one can be created automatically
285	/// providing the <i>JANA:AUTOFACTORYCREATE</i>
286	/// configuration parameter is set.
287 
288	// Check if a tag was specified for this data type to use for the
289	// default.
290	const char *mytag = tag2.1
'tag' is not equal to NULL
2.1
'tag' is not equal to NULL
2.1
'tag' is not equal to NULL
==NULL__null ? "":tag; // protection against NULL tags
3
←
'?' condition is false→
291	if(strlen(mytag)==0 && allow_deftag3.1
'allow_deftag' is true
3.1
'allow_deftag' is true
3.1
'allow_deftag' is true
){
4
←
Taking true branch→
292		map<string, string>::const_iterator iter = default_tags.find(T::static_className());
293		if(iter!=default_tags.end())tag = iter->second.c_str();
5
←
Assuming the condition is true→
6
←
Taking true branch→
7
←
Value assigned to 'tag'→
294	}
295	
296	
297	// If we are trying to keep track of the call stack then we
298	// need to add a new call_stack_t object to the the list
299	// and initialize it with the start time and caller/callee
300	// info.
301	call_stack_t cs;
302 
303	// Optionally record starting info of call stack entry
304	if(record_call_stack) CallStackStart(cs, caller_name, caller_tag, T::static_className(), tag);
8
←
Assuming field 'record_call_stack' is false→
9
←
Taking false branch→
305 
306	// Get the data (or at least try to)
307	JFactory<T>* factory=NULL__null;
308	try{
309		factory = GetFromFactory(t, tag, cs.data_source, allow_deftag);
10
←
Passing value via 2nd parameter 'tag'→
11
←
Calling 'JEventLoop::GetFromFactory'→
310		if(!factory){
311			// No factory exists for this type and tag. It's possible
312			// that the source may be able to provide the objects
313			// but it will need a place to put them. We can create a
314			// dumb JFactory just to hold the data in case the source
315			// can provide the objects. Before we do though, make sure
316			// the user condones this via the presence of the
317			// "JANA:AUTOFACTORYCREATE" config parameter.
318			string p;
319			try{
320				gPARMS->GetParameter("JANA:AUTOFACTORYCREATE", p);
321			}catch(...){}
322			if(p.size()==0){
323				jout<<std::endl;
324				_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;
325				jout<<"No factory of type \""<<T::static_className()<<"\" with tag \""<<tag<<"\" exists."<<std::endl;
326				jout<<"If you are reading objects from a file, I can auto-create a factory"<<std::endl;
327				jout<<"of the appropriate type to hold the objects, but this feature is turned"<<std::endl;
328				jout<<"off by default. To turn it on, set the \"JANA:AUTOFACTORYCREATE\""<<std::endl;
329				jout<<"configuration parameter. This can usually be done by passing the"<<std::endl;
330				jout<<"following argument to the program from the command line:"<<std::endl;
331				jout<<std::endl;
332				jout<<"   -PJANA:AUTOFACTORYCREATE=1"<<std::endl;
333				jout<<std::endl;
334				jout<<"Note that since the most commonly expected occurance of this situation."<<std::endl;
335				jout<<"is an error, the program will now throw an exception so that the factory."<<std::endl;
336				jout<<"call stack can be printed."<<std::endl;
337				jout<<std::endl;
338				throw exception();
339			}else{
340				AddFactory(new JFactory<T>(tag));
341				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;
342			
343				// Now try once more. The GetFromFactory method will call
344				// GetFromSource since it's empty.
345				factory = GetFromFactory(t, tag, cs.data_source, allow_deftag);
346			}
347		}
348	}catch(exception &e){
349		// Uh-oh, an exception was thrown. Add us to the call stack
350		// and re-throw the exception
351		error_call_stack_t ecs;
352		ecs.factory_name = T::static_className();
353		ecs.tag = tag;
354		ecs.filename = NULL__null;
355		error_call_stack.push_back(ecs);
356		throw e;
357	}
358	
359	// If recording the call stack, update the end_time field and add to stack
360	if(record_call_stack) CallStackEnd(cs);
361	
362	return factory;
363}
364 
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{
371	// We need to find the factory providing data type T with
372	// tag given by "tag". 
373	vector<JFactory_base*>::iterator iter=factories.begin();
374	JFactory<T> *factory = NULL__null;
375	string className(T::static_className());
376	
377	// Check if a tag was specified for this data type to use for the
378	// default.
379	const char *mytag = tag==NULL__null ? "":tag; // protection against NULL tags
12
←
Assuming 'tag' is equal to NULL→
13
←
Assuming pointer value is null→
14
←
'?' condition is true→
380	if(strlen(mytag)==0 && allow_deftag14.1
'allow_deftag' is true
14.1
'allow_deftag' is true
14.1
'allow_deftag' is true
){
15
←
Taking true branch→
381		map<string, string>::const_iterator iter = default_tags.find(className);
382		if(iter!=default_tags.end())tag = iter->second.c_str();
16
←
Assuming the condition is false→
17
←
Taking false branch→
383	}
384	
385	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→
386		// It turns out a long standing bug in g++ makes dynamic_cast return
387		// zero improperly when used on objects created on one side of
388		// a dynamically shared object (DSO) and the cast occurs on the 
389		// other side. I saw bug reports ranging from 2001 to 2004. I saw
390		// saw it first-hand on LinuxEL4 using g++ 3.4.5. This is too bad
391		// since it is much more elegant (and safe) to use dynamic_cast.
392		// To avoid this problem which can occur with plugins, we check
393		// the name of the data classes are the same. (sigh)
394		//factory = dynamic_cast<JFactory<T> *>(*iter);
395		if(className == (*iter)->GetDataClassName())factory = (JFactory<T>*)(*iter);
23
←
Taking true branch→
396		if(factory == NULL__null)continue;
24
←
Assuming 'factory' is not equal to NULL→
25
←
Taking false branch→
397		const char *factag = factory->Tag()==NULL__null ? "":factory->Tag();
26
←
Assuming the condition is true→
27
←
'?' condition is true→
398		if(!strcmp(factag, tag)){
28
←
Null pointer passed to 2nd parameter expecting 'nonnull'
399			break;
400		}else{
401			factory=NULL__null;
402		}
403	}
404	
405	// If factory not found, just return now
406	if(!factory){
407		data_source = DATA_NOT_AVAILABLE;
408		return NULL__null;
409	}
410	
411	// OK, we found the factory. If the evnt() routine has already
412	// been called, then just call the factory's Get() routine
413	// to return a copy of the existing data
414	if(factory->evnt_was_called()){
415		factory->CopyFrom(t);
416		data_source = DATA_FROM_CACHE;
417		return factory;
418	}
419	
420	// Next option is to get the objects from the data source
421	if(factory->GetCheckSourceFirst()){
422		// If the object type/tag is found in the source, it
423		// will return NOERROR, even if there are zero instances
424		// of it. If it is not available in the source then it
425		// will return OBJECT_NOT_AVAILABLE.
426		
427		jerror_t err = GetFromSource(t, factory);
428		if(err == NOERROR){
429			// A return value of NOERROR means the source had the objects
430			// even if there were zero of them.(If the source had no
431			// information about the objects OBJECT_NOT_AVAILABLE would 
432			// have been returned.)
433			// The GetFromSource() call will eventually lead to a call to
434			// the GetObjects() method of the concrete class derived
435			// from JEventSource. That routine should copy the object
436			// pointers into the factory using the factory's CopyTo()
437			// method which also sets the evnt_called flag for the factory.
438			// Note also that the "t" vector is then filled with a call
439			// to the factory's CopyFrom() method in JEvent::GetObjects().
440			// All we need to do now is just set the factory pointers in
441			// the newly generated JObjects and return the factory pointer.
442 
443			factory->SetFactoryPointers();
444			data_source = DATA_FROM_SOURCE;
445 
446			return factory;
447		}
448	}
449		
450	// OK. It looks like we have to have the factory make this.
451	// Get pointers to data from the factory.
452	factory->Get(t);
453	factory->SetFactoryPointers();
454	data_source = DATA_FROM_FACTORY;
455	
456	return factory;
457}
458 
459//-------------
460// GetFromSource
461//-------------
462template<class T> 
463jerror_t JEventLoop::GetFromSource(vector<const T*> &t, JFactory_base *factory)
464{
465	/// This tries to get objects from the event source.
466	/// "factory" must be a valid pointer to a JFactory
467	/// object since that will take ownership of the objects
468	/// created by the source.
469	/// This should usually be called from JEventLoop::GetFromFactory
470	/// which is called from JEventLoop::Get. The latter will
471	/// create a dummy JFactory of the proper flavor and tag if
472	/// one does not already exist so if objects exist in the
473	/// file without a corresponding factory to create them, they
474	/// can still be used.
475	if(!factory)throw OBJECT_NOT_AVAILABLE;
476	
477	return event.GetObjects(t, factory);
478}
479 
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{
485	/// This is used to fill initial info into a call_stack_t stucture
486	/// for recording the call stack. It should be matched with a call
487	/// to CallStackEnd. It is normally called from the Get() method
488	/// above, but may also be used by external actors to manipulate
489	/// the call stack (presumably for good and not evil).
490 
491	struct itimerval tmr;
492	getitimer(ITIMER_PROFITIMER_PROF, &tmr);
493 
494	cs.caller_name    = this->caller_name;
495	cs.caller_tag     = this->caller_tag;
496	this->caller_name = cs.callee_name = callee_name;
497	this->caller_tag  = cs.callee_tag  = callee_tag;
498	cs.start_time = tmr.it_value.tv_sec + tmr.it_value.tv_usec/1.0E6;
499}
500 
501//-------------
502// CallStackEnd
503//-------------
504inline void JEventLoop::CallStackEnd(JEventLoop::call_stack_t &cs)
505{
506	/// Complete a call stack entry. This should be matched
507	/// with a previous call to CallStackStart which was
508	/// used to fill the cs structure.
509 
510	struct itimerval tmr;
511	getitimer(ITIMER_PROFITIMER_PROF, &tmr);
512	cs.end_time = tmr.it_value.tv_sec + tmr.it_value.tv_usec/1.0E6;
513	caller_name = cs.caller_name;
514	caller_tag  = cs.caller_tag;
515	call_stack.push_back(cs);
516}
517 
518//-------------
519// CheckEventBoundary
520//-------------
521inline bool JEventLoop::CheckEventBoundary(uint64_t event_numberA, uint64_t event_numberB)
522{
523	/// Check whether the two event numbers span one or more boundaries
524	/// in the calibration/conditions database for the current run number.
525	/// Return true if they do and false if they don't. The first parameter
526	/// "event_numberA" is also checked if it lands on a boundary in which
527	/// case true is also returned. If event_numberB lands on a boundary,
528	/// but event_numberA does not, then false is returned.
529	///
530	/// This method is not expected to be called by a user. It is, however called,
531	/// everytime a JFactory's Get() method is called.
532 
533	// Make sure our copy of the boundaries is up to date
534	if(event.GetRunNumber()!=event_boundaries_run){
535		event_boundaries.clear(); // in case we can't get the JCalibration pointer
536		JCalibration *jcalib = GetJCalibration();
537		if(jcalib)jcalib->GetEventBoundaries(event_boundaries);
538		event_boundaries_run = event.GetRunNumber();
539	}
540	
541	// Loop over boundaries
542	for(unsigned int i=0; i<event_boundaries.size(); i++){
543		uint64_t eb = event_boundaries[i];
544		if((eb - event_numberA)*(eb - event_numberB) < 0.0 || eb==event_numberA){ // think about it ....
545			// events span a boundary or is on a boundary. Return true
546			return true;
547		}
548	}
549 
550	return false;
551}
552 
553//-------------
554// FindByID
555//-------------
556template<class T> 
557const T* JEventLoop::FindByID(JObject::oid_t id)
558{
559	/// This is a templated method that can be used in place
560	/// of the non-templated FindByID(oid_t) method if one knows
561	/// the class of the object with the specified id.
562	/// This method is faster than calling the non-templated
563	/// FindByID and dynamic_cast-ing the JObject since
564	/// this will only search the objects of factories that
565	/// produce the desired data type.
566	/// This method will cast the JObject pointer to one
567	/// of the specified type. To use this method,
568	/// a type is specified in the call as follows:
569	///
570	/// const DMyType *t = loop->FindByID<DMyType>(id);
571	
572	// Loop over factories looking for ones that provide
573	// specified data type.
574	for(unsigned int i=0; i<factories.size(); i++){
575		if(factories[i]->GetDataClassName() != T::static_className())continue;
576 
577		// This factory provides data of type T. Search it for
578		// the object with the specified id.
579		const JObject *my_obj = factories[i]->GetByID(id);
580		if(my_obj)return dynamic_cast<const T*>(my_obj);
581	}
582 
583	return NULL__null;
584}
585 
586//-------------
587// GetCalib (map)
588//-------------
589template<class T>
590bool JEventLoop::GetCalib(string namepath, map<string,T> &vals)
591{
592	/// Get the JCalibration object from JApplication for the run number of
593	/// the current event and call its Get() method to get the constants.
594 
595	// Note that we could do this by making "vals" a generic type T thus, combining
596	// this with the vector version below. However, doing this explicitly will make
597	// it easier for the user to understand how to call us.
598 
599	vals.clear();
600 
601	JCalibration *calib = GetJCalibration();
602	if(!calib){
603		_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;
604		return true;
605	}
606	
607	return calib->Get(namepath, vals, event.GetEventNumber());
608}
609 
610//-------------
611// GetCalib (vector)
612//-------------
613template<class T> bool JEventLoop::GetCalib(string namepath, vector<T> &vals)
614{
615	/// Get the JCalibration object from JApplication for the run number of
616	/// the current event and call its Get() method to get the constants.
617 
618	vals.clear();
619 
620	JCalibration *calib = GetJCalibration();
621	if(!calib){
622		_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;
623		return true;
624	}
625	
626	return calib->Get(namepath, vals, event.GetEventNumber());
627}
628 
629//-------------
630// GetCalib (single)
631//-------------
632template<class T> bool JEventLoop::GetCalib(string namepath, T &val)
633{
634	/// This is a convenience method for getting a single entry. It
635	/// simply calls the vector version and returns the first entry.
636	/// It returns true if the vector version returns true AND there
637	/// is at least one entry in the vector. No check is made for there
638	/// there being more than one entry in the vector.
639 
640	vector<T> vals;
641	bool ret = GetCalib(namepath, vals);
642	if(vals.empty()) return true;
643	val = vals[0];
644	
645	return ret;
646}
647 
648//-------------
649// GetGeom (map)
650//-------------
651template<class T>
652bool JEventLoop::GetGeom(string namepath, map<string,T> &vals)
653{
654	/// Get the JGeometry object from JApplication for the run number of
655	/// the current event and call its Get() method to get the constants.
656 
657	// Note that we could do this by making "vals" a generic type T thus, combining
658	// this with the vector version below. However, doing this explicitly will make
659	// it easier for the user to understand how to call us.
660 
661	vals.clear();
662 
663	JGeometry *geom = GetJGeometry();
664	if(!geom){
665		_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;
666		return true;
667	}
668	
669	return geom->Get(namepath, vals);
670}
671 
672//-------------
673// GetGeom (atomic)
674//-------------
675template<class T> bool JEventLoop::GetGeom(string namepath, T &val)
676{
677	/// Get the JCalibration object from JApplication for the run number of
678	/// the current event and call its Get() method to get the constants.
679 
680	JGeometry *geom = GetJGeometry();
681	if(!geom){
682		_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;
683		return true;
684	}
685	
686	return geom->Get(namepath, val);
687}
688 
689//-------------
690// SetRef
691//-------------
692template<class T>
693void JEventLoop::SetRef(T *t)
694{
695	pair<const char*, void*> p(typeid(T).name(), (void*)t);
696	user_refs.push_back(p);
697}
698 
699//-------------
700// GetResource
701//-------------
702template<class T> bool JEventLoop::GetResource(string namepath, T vals, int event_number)
703{
704	JResourceManager *resource_manager = GetJResourceManager();
705	if(!resource_manager){
706		string mess = string("Unable to get the JResourceManager object (namepath=\"")+namepath+"\")";
707		throw JException(mess);
708	}
709 
710	return resource_manager->Get(namepath, vals, event_number);
711}
712 
713//-------------
714// GetRef
715//-------------
716template<class T>
717T* JEventLoop::GetRef(void)
718{
719	/// Get a user-defined reference (a pointer)
720	for(unsigned int i=0; i<user_refs.size(); i++){
721		if(user_refs[i].first == typeid(T).name()) return (T*)user_refs[i].second;
722	}
723 
724	return NULL__null;
725}
726 
727//-------------
728// GetRefsT
729//-------------
730template<class T>
731vector<T*> JEventLoop::GetRefsT(void)
732{
733	vector<T*> refs;
734	for(unsigned int i=0; i<user_refs.size(); i++){
735		if(user_refs[i].first == typeid(T).name()){
736			refs.push_back((T*)user_refs[i].second);
737		}
738	}
739 
740	return refs;
741}
742 
743//-------------
744// RemoveRef
745//-------------
746template<class T>
747void JEventLoop::RemoveRef(T *t)
748{
749	vector<pair<const char*, void*> >::iterator iter;
750	for(iter=user_refs.begin(); iter!= user_refs.end(); iter++){
751		if(iter->second == (void*)t){
752			user_refs.erase(iter);
753			return;
754		}
755	}
756	_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}
758 
759 
760#endif //__CINT__  __CLING__
761 
762} // Close JANA namespace
763 
764 
765 
766#endif // _JEventLoop_
767 

←

/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