void SvtxEvaluator::fillOutputNtuples(PHCompositeNode *topNode) {
if (verbosity > 1) cout << "SvtxEvaluator::fillOutputNtuples() entered" << endl;
SvtxVertexEval* vertexeval = _svtxevalstack->get_vertex_eval();
SvtxTrackEval* trackeval = _svtxevalstack->get_track_eval();
SvtxClusterEval* clustereval = _svtxevalstack->get_cluster_eval();
SvtxHitEval* hiteval = _svtxevalstack->get_hit_eval();
SvtxTruthEval* trutheval = _svtxevalstack->get_truth_eval();
//-----------------------
// fill the Vertex NTuple
//-----------------------
if (_ntp_vertex) {
//cout << "Filling ntp_vertex " << endl;
SvtxVertexMap* vertexmap = findNode::getClass<SvtxVertexMap>(topNode,"SvtxVertexMap");
PHG4TruthInfoContainer* truthinfo = findNode::getClass<PHG4TruthInfoContainer>(topNode,"G4TruthInfo");
if (vertexmap && truthinfo) {
for (SvtxVertexMap::Iter iter = vertexmap->begin();
iter != vertexmap->end();
++iter) {
SvtxVertex* vertex = iter->second;
PHG4VtxPoint* point = vertexeval->max_truth_point_by_ntracks(vertex);
float vx = vertex->get_x();
float vy = vertex->get_y();
float vz = vertex->get_z();
float ntracks = vertex->size_tracks();
float gvx = NAN;
float gvy = NAN;
float gvz = NAN;
float gvt = NAN;
float gntracks = truthinfo->GetNumPrimaryVertexParticles();
float nfromtruth = NAN;
if (point) {
gvx = point->get_x();
gvy = point->get_y();
gvz = point->get_z();
gvt = point->get_t();
gntracks = truthinfo->GetNumPrimaryVertexParticles();
nfromtruth = vertexeval->get_ntracks_contribution(vertex,point);
}
float vertex_data[11] = {(float) _ievent,
vx,
vy,
vz,
ntracks,
gvx,
gvy,
gvz,
gvt,
gntracks,
nfromtruth
};
/*
cout << "vertex: "
<< " ievent " << vertex_data[0]
<< " vx " << vertex_data[1]
<< " vy " << vertex_data[2]
<< " vz " << vertex_data[3]
<< endl;
*/
_ntp_vertex->Fill(vertex_data);
}
}
}
//-----------------------
// fill the gpoint NTuple
//-----------------------
if (_ntp_gpoint) {
//cout << "Filling ntp_gpoint " << endl;
SvtxVertexMap* vertexmap = findNode::getClass<SvtxVertexMap>(topNode,"SvtxVertexMap");
PHG4TruthInfoContainer* truthinfo = findNode::getClass<PHG4TruthInfoContainer>(topNode,"G4TruthInfo");
if (vertexmap && truthinfo) {
PHG4VtxPoint* point = truthinfo->GetPrimaryVtx(truthinfo->GetPrimaryVertexIndex());
if (point) {
SvtxVertex* vertex = vertexeval->best_vertex_from(point);
float gvx = point->get_x();
float gvy = point->get_y();
float gvz = point->get_z();
float gvt = point->get_t();
float gntracks = truthinfo->GetNumPrimaryVertexParticles();
float vx = NAN;
float vy = NAN;
float vz = NAN;
float ntracks = NAN;
float nfromtruth = NAN;
if (vertex) {
vx = vertex->get_x();
vy = vertex->get_y();
vz = vertex->get_z();
ntracks = vertex->size_tracks();
nfromtruth = vertexeval->get_ntracks_contribution(vertex,point);
}
float gpoint_data[11] = {(float) _ievent,
gvx,
gvy,
gvz,
gvt,
gntracks,
vx,
vy,
vz,
ntracks,
nfromtruth
};
_ntp_gpoint->Fill(gpoint_data);
}
}
}
//---------------------
// fill the G4hit NTuple
//---------------------
if (_ntp_g4hit) {
//cout << "Filling ntp_g4hit " << endl;
std::set<PHG4Hit*> g4hits = trutheval->all_truth_hits();
for (std::set<PHG4Hit*>::iterator iter = g4hits.begin();
iter != g4hits.end();
++iter) {
PHG4Hit *g4hit = *iter;
PHG4Particle *g4particle = trutheval->get_particle(g4hit);
float g4hitID = g4hit->get_hit_id();
float gx = g4hit->get_avg_x();
float gy = g4hit->get_avg_y();
float gz = g4hit->get_avg_z();
float gt = g4hit->get_avg_t();
float gedep = g4hit->get_edep();
float glayer = g4hit->get_layer();
float gtrackID = g4hit->get_trkid();
float gflavor = NAN;
float gpx = NAN;
float gpy = NAN;
float gpz = NAN;
float gvx = NAN;
float gvy = NAN;
float gvz = NAN;
float gembed = NAN;
float gprimary = NAN;
float gfpx = 0.;
float gfpy = 0.;
float gfpz = 0.;
float gfx = 0.;
float gfy = 0.;
float gfz = 0.;
if (g4particle) {
if (_scan_for_embedded) {
if (trutheval->get_embed(g4particle) == 0) continue;
}
gflavor = g4particle->get_pid();
gpx = g4particle->get_px();
gpy = g4particle->get_py();
gpz = g4particle->get_pz();
PHG4VtxPoint* vtx = trutheval->get_vertex(g4particle);
if (vtx) {
gvx = vtx->get_x();
gvy = vtx->get_y();
gvz = vtx->get_z();
}
PHG4Hit* outerhit = trutheval->get_outermost_truth_hit(g4particle);
if (outerhit) {
gfpx = outerhit->get_px(1);
gfpy = outerhit->get_py(1);
gfpz = outerhit->get_pz(1);
gfx = outerhit->get_x(1);
gfy = outerhit->get_y(1);
gfz = outerhit->get_z(1);
}
gembed = trutheval->get_embed(g4particle);
gprimary = trutheval->is_primary(g4particle);
} // if (g4particle)
std::set<SvtxCluster*> clusters = clustereval->all_clusters_from(g4hit);
float nclusters = clusters.size();
// best cluster reco'd
SvtxCluster* cluster = clustereval->best_cluster_from(g4hit);
float clusID = NAN;
float x = NAN;
float y = NAN;
float z = NAN;
float e = NAN;
float adc = NAN;
float layer = NAN;
float size = NAN;
float phisize = NAN;
float zsize = NAN;
float efromtruth = NAN;
if (cluster) {
clusID = cluster->get_id();
x = cluster->get_x();
y = cluster->get_y();
z = cluster->get_z();
e = cluster->get_e();
adc = cluster->get_adc();
layer = cluster->get_layer();
size = cluster->size_hits();
phisize = cluster->get_phi_size();
zsize = cluster->get_z_size();
if (g4particle) {
efromtruth = clustereval->get_energy_contribution(cluster,g4particle);
}
}
float g4hit_data[36] = {(float) _ievent,
g4hitID,
gx,
gy,
gz,
gt,
gedep,
glayer,
gtrackID,
gflavor,
gpx,
gpy,
gpz,
gvx,
gvy,
gvz,
gfpx,
gfpy,
gfpz,
gfx,
gfy,
gfz,
gembed,
gprimary,
nclusters,
clusID,
x,
y,
z,
e,
adc,
layer,
size,
phisize,
zsize,
efromtruth
};
_ntp_g4hit->Fill(g4hit_data);
}
}
//--------------------
// fill the Hit NTuple
//--------------------
if (_ntp_hit) {
//cout << "Filling ntp_hit " << endl;
// need things off of the DST...
SvtxHitMap* hitmap = findNode::getClass<SvtxHitMap>(topNode,"SvtxHitMap");
if (hitmap) {
for (SvtxHitMap::Iter iter = hitmap->begin();
iter != hitmap->end();
++iter) {
SvtxHit* hit = iter->second;
PHG4Hit* g4hit = hiteval->max_truth_hit_by_energy(hit);
PHG4CylinderCell* g4cell = hiteval->get_cell(hit);
PHG4Particle* g4particle = trutheval->get_particle(g4hit);
float event = _ievent;
float hitID = hit->get_id();
float e = hit->get_e();
float adc = hit->get_adc();
float layer = hit->get_layer();
float cellID = hit->get_cellid();
float ecell = g4cell->get_edep();
float g4hitID = NAN;
float gedep = NAN;
float gx = NAN;
float gy = NAN;
float gz = NAN;
float gt = NAN;
float gtrackID = NAN;
float gflavor = NAN;
float gpx = NAN;
float gpy = NAN;
float gpz = NAN;
float gvx = NAN;
float gvy = NAN;
float gvz = NAN;
float gfpx = NAN;
float gfpy = NAN;
float gfpz = NAN;
float gfx = NAN;
float gfy = NAN;
float gfz = NAN;
float gembed = NAN;
float gprimary = NAN;
float efromtruth = NAN;
if (g4hit) {
g4hitID = g4hit->get_hit_id();
gedep = g4hit->get_edep();
gx = g4hit->get_avg_x();
gy = g4hit->get_avg_y();
gz = g4hit->get_avg_z();
gt = g4hit->get_avg_t();
if (g4particle) {
if (_scan_for_embedded) {
if (trutheval->get_embed(g4particle) == 0) continue;
}
gtrackID = g4particle->get_track_id();
gflavor = g4particle->get_pid();
gpx = g4particle->get_px();
gpy = g4particle->get_py();
gpz = g4particle->get_pz();
PHG4VtxPoint* vtx = trutheval->get_vertex(g4particle);
if (vtx) {
gvx = vtx->get_x();
gvy = vtx->get_y();
gvz = vtx->get_z();
}
PHG4Hit* outerhit = trutheval->get_outermost_truth_hit(g4particle);
if (outerhit) {
gfpx = outerhit->get_px(1);
gfpy = outerhit->get_py(1);
gfpz = outerhit->get_pz(1);
gfx = outerhit->get_x(1);
gfy = outerhit->get_y(1);
gfz = outerhit->get_z(1);
}
gembed = trutheval->get_embed(g4particle);
gprimary = trutheval->is_primary(g4particle);
} // if (g4particle){
}
if (g4particle) {
efromtruth = hiteval->get_energy_contribution(hit,g4particle);
}
float hit_data[33] = {
event,
hitID,
e,
adc,
layer,
cellID,
ecell,
g4hitID,
gedep,
gx,
gy,
gz,
gt,
gtrackID,
gflavor,
gpx,
gpy,
gpz,
gvx,
gvy,
gvz,
gfpx,
gfpy,
gfpz,
gfx,
gfy,
gfz,
gembed,
gprimary,
efromtruth
};
_ntp_hit->Fill(hit_data);
}
}
}
//------------------------
// fill the Cluster NTuple
//------------------------
//cout << "check for ntp_cluster" << endl;
if (_ntp_cluster && !_scan_for_embedded) {
//cout << "Filling ntp_cluster 1 " << endl;
// need things off of the DST...
SvtxClusterMap* clustermap = findNode::getClass<SvtxClusterMap>(topNode,"SvtxClusterMap");
if (clustermap) {
for (SvtxClusterMap::Iter iter = clustermap->begin();
iter != clustermap->end();
++iter) {
SvtxCluster* cluster = iter->second;
SvtxTrack* track = trackeval->best_track_from(cluster);
PHG4Hit *g4hit = clustereval->max_truth_hit_by_energy(cluster);
PHG4Particle *g4particle = trutheval->get_particle(g4hit);
float hitID = cluster->get_id();
float x = cluster->get_x();
float y = cluster->get_y();
float z = cluster->get_z();
float ex = sqrt(cluster->get_error(0,0));
float ey = sqrt(cluster->get_error(1,1));
float ez = cluster->get_z_error();
float ephi = cluster->get_phi_error();
float e = cluster->get_e();
float adc = cluster->get_adc();
float layer = cluster->get_layer();
float size = cluster->size_hits();
float phisize = cluster->get_phi_size();
float zsize = cluster->get_z_size();
float trackID = NAN;
if (track) trackID = track->get_id();
float g4hitID = NAN;
float gx = NAN;
float gy = NAN;
float gz = NAN;
float gt = NAN;
float gtrackID = NAN;
float gflavor = NAN;
float gpx = NAN;
float gpy = NAN;
float gpz = NAN;
float gvx = NAN;
float gvy = NAN;
float gvz = NAN;
float gfpx = NAN;
float gfpy = NAN;
float gfpz = NAN;
float gfx = NAN;
float gfy = NAN;
float gfz = NAN;
float gembed = NAN;
float gprimary = NAN;
float efromtruth = NAN;
if (g4hit) {
g4hitID = g4hit->get_hit_id();
gx = g4hit->get_avg_x();
gy = g4hit->get_avg_y();
gz = g4hit->get_avg_z();
gt = g4hit->get_avg_t();
if (g4particle) {
gtrackID = g4particle->get_track_id();
gflavor = g4particle->get_pid();
gpx = g4particle->get_px();
gpy = g4particle->get_py();
gpz = g4particle->get_pz();
PHG4VtxPoint* vtx = trutheval->get_vertex(g4particle);
if (vtx) {
gvx = vtx->get_x();
gvy = vtx->get_y();
gvz = vtx->get_z();
}
PHG4Hit* outerhit = trutheval->get_outermost_truth_hit(g4particle);
if (outerhit) {
gfpx = outerhit->get_px(1);
gfpy = outerhit->get_py(1);
gfpz = outerhit->get_pz(1);
gfx = outerhit->get_x(1);
gfy = outerhit->get_y(1);
gfz = outerhit->get_z(1);
}
gembed = trutheval->get_embed(g4particle);
gprimary = trutheval->is_primary(g4particle);
} // if (g4particle){
} // if (g4hit) {
if (g4particle){
efromtruth = clustereval->get_energy_contribution(cluster,g4particle);
}
float cluster_data[38] = {(float) _ievent,
hitID,
x,
y,
z,
ex,
ey,
ez,
ephi,
e,
adc,
layer,
size,
phisize,
zsize,
trackID,
g4hitID,
gx,
gy,
gz,
gt,
gtrackID,
gflavor,
gpx,
gpy,
gpz,
gvx,
gvy,
gvz,
gfpx,
gfpy,
gfpz,
gfx,
gfy,
gfz,
gembed,
gprimary,
efromtruth};
_ntp_cluster->Fill(cluster_data);
}
}
} else if (_ntp_cluster && _scan_for_embedded) {
//cout << "Filling ntp_cluster 2 " << endl;
// if only scanning embedded signals, loop over all the tracks from
// embedded particles and report all of their clusters, including those
// from other sources (noise hits on the embedded track)
// need things off of the DST...
SvtxTrackMap* trackmap = findNode::getClass<SvtxTrackMap>(topNode,"SvtxTrackMap");
SvtxClusterMap* clustermap = findNode::getClass<SvtxClusterMap>(topNode,"SvtxClusterMap");
if (trackmap) {
for (SvtxTrackMap::Iter iter = trackmap->begin();
iter != trackmap->end();
++iter) {
SvtxTrack* track = iter->second;
PHG4Particle* truth = trackeval->max_truth_particle_by_nclusters(track);
if (truth) {
if (trutheval->get_embed(truth) == 0) continue;
}
for (SvtxTrack::ConstClusterIter iter = track->begin_clusters();
iter != track->end_clusters();
++iter) {
unsigned int cluster_id = *iter;
SvtxCluster* cluster = clustermap->get(cluster_id);
PHG4Hit *g4hit = clustereval->max_truth_hit_by_energy(cluster);
PHG4Particle *g4particle = trutheval->get_particle(g4hit);
float hitID = cluster->get_id();
float x = cluster->get_x();
float y = cluster->get_y();
float z = cluster->get_z();
float ex = sqrt(cluster->get_error(0,0));
float ey = sqrt(cluster->get_error(1,1));
float ez = cluster->get_z_error();
float ephi = cluster->get_phi_error();
float e = cluster->get_e();
float adc = cluster->get_adc();
float layer = cluster->get_layer();
float size = cluster->size_hits();
float phisize = cluster->get_phi_size();
float zsize = cluster->get_z_size();
float trackID = NAN;
if (track) trackID = track->get_id();
float g4hitID = NAN;
float gx = NAN;
float gy = NAN;
float gz = NAN;
float gt = NAN;
float gtrackID = NAN;
float gflavor = NAN;
float gpx = NAN;
float gpy = NAN;
float gpz = NAN;
float gvx = NAN;
float gvy = NAN;
float gvz = NAN;
float gfpx = NAN;
float gfpy = NAN;
float gfpz = NAN;
float gfx = NAN;
float gfy = NAN;
float gfz = NAN;
float gembed = NAN;
float gprimary = NAN;
float efromtruth = NAN;
if (g4hit) {
g4hitID = g4hit->get_hit_id();
gx = g4hit->get_avg_x();
gy = g4hit->get_avg_y();
gz = g4hit->get_avg_z();
gt = g4hit->get_avg_t();
if (g4particle) {
gtrackID = g4particle->get_track_id();
gflavor = g4particle->get_pid();
gpx = g4particle->get_px();
gpy = g4particle->get_py();
gpz = g4particle->get_pz();
PHG4VtxPoint* vtx = trutheval->get_vertex(g4particle);
if (vtx) {
gvx = vtx->get_x();
gvy = vtx->get_y();
gvz = vtx->get_z();
}
PHG4Hit* outerhit = trutheval->get_outermost_truth_hit(g4particle);
if (outerhit) {
gfpx = outerhit->get_px(1);
gfpy = outerhit->get_py(1);
gfpz = outerhit->get_pz(1);
gfx = outerhit->get_x(1);
gfy = outerhit->get_y(1);
gfz = outerhit->get_z(1);
}
gembed = trutheval->get_embed(g4particle);
gprimary = trutheval->is_primary(g4particle);
} // if (g4particle){
} // if (g4hit) {
if (g4particle){
efromtruth = clustereval->get_energy_contribution(cluster,g4particle);
}
float cluster_data[38] = {(float) _ievent,
hitID,
x,
y,
z,
ex,
ey,
ez,
ephi,
e,
adc,
layer,
size,
phisize,
zsize,
trackID,
g4hitID,
gx,
gy,
gz,
gt,
gtrackID,
gflavor,
gpx,
gpy,
gpz,
gvx,
gvy,
gvz,
gfpx,
gfpy,
gfpz,
gfx,
gfy,
gfz,
gembed,
gprimary,
efromtruth};
_ntp_cluster->Fill(cluster_data);
}
}
}
}
//------------------------
// fill the Gtrack NTuple
//------------------------
// need things off of the DST...
//cout << "check for ntp_gtrack" << endl;
if (_ntp_gtrack) {
//cout << "Filling ntp_gtrack " << endl;
PHG4TruthInfoContainer* truthinfo = findNode::getClass<PHG4TruthInfoContainer>(topNode,"G4TruthInfo");
SvtxClusterMap* clustermap = findNode::getClass<SvtxClusterMap>(topNode,"SvtxClusterMap");
if (truthinfo) {
PHG4TruthInfoContainer::ConstRange range = truthinfo->GetPrimaryParticleRange();
for (PHG4TruthInfoContainer::ConstIterator iter = range.first;
iter != range.second;
++iter) {
PHG4Particle* g4particle = iter->second;
if (_scan_for_embedded) {
if (trutheval->get_embed(g4particle) == 0) continue;
}
float gtrackID = g4particle->get_track_id();
float gflavor = g4particle->get_pid();
std::set<PHG4Hit*> g4hits = trutheval->all_truth_hits(g4particle);
float ng4hits = g4hits.size();
float gpx = g4particle->get_px();
float gpy = g4particle->get_py();
float gpz = g4particle->get_pz();
PHG4VtxPoint* vtx = trutheval->get_vertex(g4particle);
float gvx = vtx->get_x();
float gvy = vtx->get_y();
float gvz = vtx->get_z();
float gvt = vtx->get_t();
float gfpx = 0.;
float gfpy = 0.;
float gfpz = 0.;
float gfx = 0.;
float gfy = 0.;
float gfz = 0.;
PHG4Hit* outerhit = trutheval->get_outermost_truth_hit(g4particle);
if (outerhit) {
gfpx = outerhit->get_px(1);
gfpy = outerhit->get_py(1);
gfpz = outerhit->get_pz(1);
gfx = outerhit->get_x(1);
gfy = outerhit->get_y(1);
gfz = outerhit->get_z(1);
}
float gembed = trutheval->get_embed(g4particle);
float gprimary = trutheval->is_primary(g4particle);
SvtxTrack* track = trackeval->best_track_from(g4particle);
float trackID = NAN;
float charge = NAN;
float quality = NAN;
float chisq = NAN;
float ndf = NAN;
float nhits = NAN;
unsigned int layers = 0x0;
float dca2d = NAN;
float dca2dsigma = NAN;
float px = NAN;
float py = NAN;
float pz = NAN;
float pcax = NAN;
float pcay = NAN;
float pcaz = NAN;
float nfromtruth = NAN;
float layersfromtruth = NAN;
if (track) {
trackID = track->get_id();
charge = track->get_charge();
quality = track->get_quality();
chisq = track->get_chisq();
ndf = track->get_ndf();
nhits = track->size_clusters();
for (SvtxTrack::ConstClusterIter iter = track->begin_clusters();
iter != track->end_clusters();
++iter) {
unsigned int cluster_id = *iter;
SvtxCluster* cluster = clustermap->get(cluster_id);
unsigned int layer = cluster->get_layer();
if (layer < 32) layers |= (0x1 << layer);
}
dca2d = track->get_dca2d();
dca2dsigma = track->get_dca2d_error();
px = track->get_px();
py = track->get_py();
pz = track->get_pz();
pcax = track->get_x();
pcay = track->get_y();
pcaz = track->get_z();
nfromtruth = trackeval->get_nclusters_contribution(track,g4particle);
layersfromtruth = trackeval->get_nclusters_contribution_by_layer(track,g4particle);
}
float gtrack_data[36] = {(float) _ievent,
gtrackID,
gflavor,
ng4hits,
gpx,
gpy,
gpz,
gvx,
gvy,
gvz,
gvt,
gfpx,
gfpy,
gfpz,
gfx,
gfy,
gfz,
gembed,
gprimary,
trackID,
px,
py,
pz,
charge,
quality,
chisq,
ndf,
nhits,
(float) layers,
dca2d,
dca2dsigma,
pcax,
pcay,
pcaz,
nfromtruth,
layersfromtruth
};
/*
cout << " ievent " << _ievent
<< " gtrackID " << gtrackID
<< " gflavor " << gflavor
<< " ng4hits " << ng4hits
<< endl;
*/
_ntp_gtrack->Fill(gtrack_data);
}
}
}
//------------------------
// fill the Track NTuple
//------------------------
if (_ntp_track) {
//cout << "Filling ntp_track " << endl;
// need things off of the DST...
SvtxTrackMap* trackmap = findNode::getClass<SvtxTrackMap>(topNode,"SvtxTrackMap");
SvtxClusterMap* clustermap = findNode::getClass<SvtxClusterMap>(topNode,"SvtxClusterMap");
if (trackmap) {
for (SvtxTrackMap::Iter iter = trackmap->begin();
iter != trackmap->end();
++iter) {
SvtxTrack* track = iter->second;
float trackID = track->get_id();
float charge = track->get_charge();
float quality = track->get_quality();
float chisq = track->get_chisq();
float ndf = track->get_ndf();
float nhits = track->size_clusters();
unsigned int layers = 0x0;
for (SvtxTrack::ConstClusterIter iter = track->begin_clusters();
iter != track->end_clusters();
++iter) {
unsigned int cluster_id = *iter;
SvtxCluster* cluster = clustermap->get(cluster_id);
unsigned int layer = cluster->get_layer();
if (layer < 31) layers |= (0x1 << layer);
}
float dca2d = track->get_dca2d();
float dca2dsigma = track->get_dca2d_error();
float px = track->get_px();
float py = track->get_py();
float pz = track->get_pz();
float pcax = track->get_x();
float pcay = track->get_y();
float pcaz = track->get_z();
float presdphi = track->get_cal_dphi(SvtxTrack::PRES);
float presdeta = track->get_cal_deta(SvtxTrack::PRES);
float prese3x3 = track->get_cal_energy_3x3(SvtxTrack::PRES);
float prese = track->get_cal_cluster_e(SvtxTrack::PRES);
float cemcdphi = track->get_cal_dphi(SvtxTrack::CEMC);
float cemcdeta = track->get_cal_deta(SvtxTrack::CEMC);
float cemce3x3 = track->get_cal_energy_3x3(SvtxTrack::CEMC);
float cemce = track->get_cal_cluster_e(SvtxTrack::CEMC);
float hcalindphi = track->get_cal_dphi(SvtxTrack::HCALIN);
float hcalindeta = track->get_cal_deta(SvtxTrack::HCALIN);
float hcaline3x3 = track->get_cal_energy_3x3(SvtxTrack::HCALIN);
float hcaline = track->get_cal_cluster_e(SvtxTrack::HCALIN);
float hcaloutdphi = track->get_cal_dphi(SvtxTrack::HCALOUT);
float hcaloutdeta = track->get_cal_deta(SvtxTrack::HCALOUT);
float hcaloute3x3 = track->get_cal_energy_3x3(SvtxTrack::HCALOUT);
float hcaloute = track->get_cal_cluster_e(SvtxTrack::HCALOUT);
float gtrackID = NAN;
float gflavor = NAN;
float ng4hits = NAN;
float gpx = NAN;
float gpy = NAN;
float gpz = NAN;
float gvx = NAN;
float gvy = NAN;
float gvz = NAN;
float gvt = NAN;
float gfpx = NAN;
float gfpy = NAN;
float gfpz = NAN;
float gfx = NAN;
float gfy = NAN;
float gfz = NAN;
float gembed = NAN;
float gprimary = NAN;
float nfromtruth = NAN;
float layersfromtruth = NAN;
PHG4Particle* g4particle = trackeval->max_truth_particle_by_nclusters(track);
if (g4particle) {
if (_scan_for_embedded) {
if (trutheval->get_embed(g4particle) == 0) continue;
}
gtrackID = g4particle->get_track_id();
gflavor = g4particle->get_pid();
std::set<PHG4Hit*> g4hits = trutheval->all_truth_hits(g4particle);
ng4hits = g4hits.size();
gpx = g4particle->get_px();
gpy = g4particle->get_py();
gpz = g4particle->get_pz();
PHG4VtxPoint* vtx = trutheval->get_vertex(g4particle);
gvx = vtx->get_x();
gvy = vtx->get_y();
gvz = vtx->get_z();
gvt = vtx->get_t();
PHG4Hit* outerhit = trutheval->get_outermost_truth_hit(g4particle);
if (outerhit) {
gfpx = outerhit->get_px(1);
gfpy = outerhit->get_py(1);
gfpz = outerhit->get_pz(1);
gfx = outerhit->get_x(1);
gfy = outerhit->get_y(1);
gfz = outerhit->get_z(1);
}
gembed = trutheval->get_embed(g4particle);
gprimary = trutheval->is_primary(g4particle);
nfromtruth = trackeval->get_nclusters_contribution(track,g4particle);
layersfromtruth = trackeval->get_nclusters_contribution_by_layer(track,g4particle);
}
float track_data[52] = {(float) _ievent,
trackID,
px,
py,
pz,
charge,
quality,
chisq,
ndf,
nhits,
(float) layers,
dca2d,
dca2dsigma,
pcax,
pcay,
pcaz,
presdphi,
presdeta,
prese3x3,
prese,
cemcdphi,
cemcdeta,
cemce3x3,
cemce,
hcalindphi,
hcalindeta,
hcaline3x3,
hcaline,
hcaloutdphi,
hcaloutdeta,
hcaloute3x3,
hcaloute,
gtrackID,
gflavor,
ng4hits,
gpx,
gpy,
gpz,
gvx,
gvy,
gvz,
gvt,
gfpx,
gfpy,
gfpz,
gfx,
gfy,
gfz,
gembed,
gprimary,
nfromtruth,
layersfromtruth
};
/*
cout << "ievent " << _ievent
<< " trackID " << trackID
<< " nhits " << nhits
<< " px " << px
<< " py " << py
<< " pz " << pz
<< " gembed " << gembed
<< " gprimary " << gprimary
<< endl;
*/
_ntp_track->Fill(track_data);
}
}
}
return;
}
int SvtxSimPerformanceCheckReco::process_event(PHCompositeNode *topNode) {
++_event;
// need things off of the DST...
PHG4TruthInfoContainer* truthinfo = findNode::getClass<PHG4TruthInfoContainer>(topNode,"G4TruthInfo");
if (!truthinfo) {
cerr << PHWHERE << " ERROR: Can't find G4TruthInfo" << endl;
exit(-1);
}
SvtxTrackMap* trackmap = findNode::getClass<SvtxTrackMap>(topNode,"SvtxTrackMap");
if (!trackmap) {
cerr << PHWHERE << " ERROR: Can't find SvtxTrackMap" << endl;
exit(-1);
}
SvtxVertexMap* vertexmap = findNode::getClass<SvtxVertexMap>(topNode,"SvtxVertexMap");
if (!vertexmap) {
cerr << PHWHERE << " ERROR: Can't find SvtxVertexMap" << endl;
exit(-1);
}
// create SVTX eval stack
SvtxEvalStack svtxevalstack(topNode);
SvtxVertexEval* vertexeval = svtxevalstack.get_vertex_eval();
SvtxTrackEval* trackeval = svtxevalstack.get_track_eval();
SvtxTruthEval* trutheval = svtxevalstack.get_truth_eval();
// loop over all truth particles
PHG4TruthInfoContainer::Range range = truthinfo->GetPrimaryParticleRange();
for (PHG4TruthInfoContainer::ConstIterator iter = range.first;
iter != range.second;
++iter) {
PHG4Particle* g4particle = iter->second;
if (trutheval->get_embed(g4particle) <= 0) continue;
std::set<PHG4Hit*> g4hits = trutheval->all_truth_hits(g4particle);
float ng4hits = g4hits.size();
float truept = sqrt(pow(g4particle->get_px(),2)+pow(g4particle->get_py(),2));
// examine truth particles that leave 7 detector hits
if (ng4hits == _nlayers) {
_truept_particles_leaving7Hits->Fill(truept);
SvtxTrack* track = trackeval->best_track_from(g4particle);
if (!track) {continue;}
unsigned int nfromtruth = trackeval->get_nclusters_contribution(track,g4particle);
float recopt = track->get_pt();
unsigned int ndiff = abs((int)nfromtruth-(int)_nlayers);
if (ndiff <= 2) {
_truept_particles_recoWithin2Hits->Fill(truept);
}
if (ndiff <= 1) {
_truept_particles_recoWithin1Hit->Fill(truept);
}
if (ndiff == 0) {
_truept_particles_recoWithExactHits->Fill(truept);
}
unsigned int layersfromtruth = trackeval->get_nclusters_contribution_by_layer(track,g4particle);
unsigned int innerhits = (layersfromtruth & _inner_layer_mask);
unsigned int ninnerhitsfromtruth = 0;
unsigned int ninnerlayers = 0;
for (unsigned int i = 0; i < 32; ++i) {
ninnerhitsfromtruth += (0x1 & (innerhits >> i));
ninnerlayers += (0x1 & (_inner_layer_mask >> i));
}
ndiff = abs((int)ninnerhitsfromtruth-(int)ninnerlayers);
if (ndiff <= 2) {
_truept_particles_recoWithin2InnerHits->Fill(truept);
}
if (ndiff <= 1) {
_truept_particles_recoWithin1InnerHit->Fill(truept);
}
if (ndiff == 0) {
_truept_particles_recoWithExactInnerHits->Fill(truept);
}
float diff = fabs(recopt-truept)/truept;
if (diff < 0.05) {
_truept_particles_recoWithin5Percent->Fill(truept);
}
if (diff < 0.04) {
_truept_particles_recoWithin4Percent->Fill(truept);
_truept_quality_particles_recoWithin4Percent->Fill(truept,track->get_quality());
}
if (diff < 0.03) {
_truept_particles_recoWithin3Percent->Fill(truept);
}
}
}
