void PHG4SvtxClusterizer::PrintClusters(PHCompositeNode *topNode) {
if (verbosity >= 1) {
SvtxClusterMap *clusterlist = findNode::getClass<SvtxClusterMap>(topNode,"SvtxClusterMap");
if (!clusterlist) return;
cout << "================= PHG4SvtxClusterizer::process_event() ====================" << endl;
cout << " Found and recorded the following " << clusterlist->size() << " clusters: " << endl;
unsigned int icluster = 0;
for (SvtxClusterMap::Iter iter = clusterlist->begin();
iter != clusterlist->end();
++iter) {
SvtxCluster* cluster = &iter->second;
cout << icluster << " of " << clusterlist->size() << endl;
cluster->identify();
++icluster;
}
cout << "===========================================================================" << endl;
}
return;
}
std::set<SvtxCluster*> SvtxClusterEval::all_clusters_from(PHG4Hit* truthhit) {
if (!has_node_pointers()) {++_errors; return std::set<SvtxCluster*>();}
if (_strict) {assert(truthhit);}
else if (!truthhit) {++_errors; return std::set<SvtxCluster*>();}
if (_do_cache) {
std::map<PHG4Hit*,std::set<SvtxCluster*> >::iterator iter =
_cache_all_clusters_from_g4hit.find(truthhit);
if (iter != _cache_all_clusters_from_g4hit.end()) {
return iter->second;
}
}
std::set<SvtxCluster*> clusters;
unsigned int hit_layer = truthhit->get_layer();
// loop over all the clusters
for (SvtxClusterMap::Iter iter = _clustermap->begin();
iter != _clustermap->end();
++iter) {
SvtxCluster* cluster = iter->second;
if (cluster->get_layer() != hit_layer) continue;
// loop over all truth hits connected to this cluster
std::set<PHG4Hit*> hits = all_truth_hits(cluster);
for (std::set<PHG4Hit*>::iterator jter = hits.begin();
jter != hits.end();
++jter) {
PHG4Hit* candidate = *jter;
if (candidate->get_hit_id() == truthhit->get_hit_id()) {
clusters.insert(cluster);
}
}
}
if (_do_cache) _cache_all_clusters_from_g4hit.insert(make_pair(truthhit,clusters));
return clusters;
}
int PHG4HoughTransform::translate_input() {
for (SvtxClusterMap::Iter iter = _g4clusters->begin();
iter != _g4clusters->end(); ++iter) {
SvtxCluster* cluster = iter->second;
unsigned int ilayer = _layer_ilayer_map[cluster->get_layer()];
SimpleHit3D hit3d;
hit3d.set_id(cluster->get_id());
hit3d.set_layer(ilayer);
hit3d.set_x(cluster->get_x());
hit3d.set_y(cluster->get_y());
hit3d.set_z(cluster->get_z());
// hit3d.set_ex(2.0*sqrt(cluster->get_size(0,0)));
// hit3d.set_ey(2.0*sqrt(cluster->get_size(1,1)));
// hit3d.set_ez(2.0*sqrt(cluster->get_size(2,2)));
// copy covariance over
for (int i = 0; i < 3; ++i) {
for (int j = i; j < 3; ++j) {
hit3d.set_error(i, j, cluster->get_error(i, j));
hit3d.set_size(i, j, cluster->get_size(i, j));
}
}
_clusters.push_back(hit3d);
}
if (verbosity > 20) {
cout << "-------------------------------------------------------------------" << endl;
cout << "PHG4HoughTransform::process_event has the following input clusters:" << endl;
for (unsigned int i = 0; i < _clusters.size(); ++i) {
cout << "n init clusters = "<<_clusters.size() << endl;
_clusters[i].print();
}
cout << "-------------------------------------------------------------------" << endl;
}
return Fun4AllReturnCodes::EVENT_OK;
}
/*
* Make SvtxTrack from PHGenFit::Track and SvtxTrack
*/
SvtxTrack* PHG4TrackKalmanFitter::MakeSvtxTrack(const SvtxTrack* svtx_track,
const PHGenFit::Track* phgf_track) {
double chi2 = phgf_track->get_chi2();
double ndf = phgf_track->get_ndf();
genfit::MeasuredStateOnPlane* gf_state = phgf_track->extrapolateToLine(TVector3(0.,0.,0.), TVector3(0.,0.,1.));
TVector3 mom = gf_state->getMom();
TVector3 pos = gf_state->getPos();
TMatrixDSym cov = gf_state->get6DCov();
//const SvtxTrack_v1* temp_track = static_cast<const SvtxTrack_v1*> (svtx_track);
SvtxTrack_v1* out_track = new SvtxTrack_v1(*static_cast<const SvtxTrack_v1*> (svtx_track));
/*!
* 1/p, u'/z', v'/z', u, v
* u is defined as mom X beam line at POCA
* so u is the dca2d direction
*/
double dca2d = gf_state->getState()[3];
out_track->set_dca2d(dca2d);
if(gf_state->getCov()[3][3] > 0)
out_track->set_dca2d_error(sqrt(gf_state->getCov()[3][3]));
else {
out_track->set_dca2d_error(-9999);
if(verbosity >= 1)
LogWarning("gf_state->getCov()[3][3] <= 0");
}
double dca3d = sqrt(
dca2d*dca2d +
gf_state->getState()[4]*gf_state->getState()[4]);
out_track->set_dca(dca3d);
out_track->set_chisq(chi2);
out_track->set_ndf(ndf);
out_track->set_charge((_reverse_mag_field) ? -1.*phgf_track->get_charge() : phgf_track->get_charge());
out_track->set_px(mom.Px());
out_track->set_py(mom.Py());
out_track->set_pz(mom.Pz());
out_track->set_x(pos.X());
out_track->set_y(pos.Y());
out_track->set_z(pos.Z());
for(int i=0;i<6;i++)
{
for(int j=i;j<6;j++)
{
out_track->set_error(i,j,cov[i][j]);
}
}
for (SvtxTrack::ConstClusterIter iter = svtx_track->begin_clusters();
iter != svtx_track->end_clusters(); ++iter) {
unsigned int cluster_id = *iter;
SvtxCluster* cluster = _clustermap->get(cluster_id);
if(!cluster)
{
LogError("No cluster Found!");
continue;
}
//cluster->identify(); //DEBUG
//unsigned int l = cluster->get_layer();
TVector3 pos(cluster->get_x(), cluster->get_y(), cluster->get_z());
double radius = pos.Pt();
//TODO add exception handling
genfit::MeasuredStateOnPlane* gf_state = phgf_track->extrapolateToCylinder(radius,TVector3(0,0,0),TVector3(0,0,1), 0);
if (!gf_state) {
if (verbosity > 1)
LogWarning("Exrapolation failed!");
continue;
}
SvtxTrackState* state = new SvtxTrackState_v1(radius);
state->set_x(gf_state->getPos().x());
state->set_y(gf_state->getPos().y());
state->set_z(gf_state->getPos().z());
state->set_px(gf_state->getMom().x());
state->set_py(gf_state->getMom().y());
state->set_pz(gf_state->getMom().z());
//gf_state->getCov().Print();
for(int i=0;i<6;i++)
{
for(int j=i;j<6;j++)
{
out_track->set_error(i,j, gf_state->get6DCov()[i][j]);
}
}
out_track->insert_state(state);
// std::cout<<"===============\n";
// LogDebug(radius);
// std::cout<<"---------------\n";
// TVector3 temp_vec(state->get_x(),state->get_y(),state->get_z());
// LogDebug(temp_vec.Pt());
// //state->identify();
// std::cout<<"---------------\n";
// //out_track->get_state(radius)->identify();
}
return out_track;
}
/*
* fit track with SvtxTrack as input seed.
* \param intrack Input SvtxTrack
* \param invertex Input Vertex, if fit track as a primary vertex
*/
PHGenFit::Track* PHG4TrackKalmanFitter::ReFitTrack(const SvtxTrack* intrack, const SvtxVertex* invertex) {
if(!intrack){
cerr << PHWHERE << " Input SvtxTrack is NULL!"
<< endl;
return NULL;
}
// prepare seed from input SvtxTrack
TVector3 seed_mom(intrack->get_px(),intrack->get_py(),intrack->get_pz());
TVector3 seed_pos(intrack->get_x(),intrack->get_y(),intrack->get_z());
TMatrixDSym seed_cov(6);
for(int i=0;i<6;i++)
{
for(int j=0;j<6;j++)
{
seed_cov[i][j] = intrack->get_error(i,j);
}
}
/*!
* mu+: -13
* mu-: 13
* pi+: 211
* pi-: -211
* e-: 11
* e+: -11
*/
//TODO Add multiple TrackRep choices.
//int pid = 211;
genfit::AbsTrackRep* rep = new genfit::RKTrackRep(_primary_pid_guess);
PHGenFit::Track* track = new PHGenFit::Track(rep, seed_pos,
seed_mom, seed_cov);
// Create measurements
std::vector<PHGenFit::Measurement*> measurements;
/*!
* if fit track as a primary track
*/
// if(invertex and verbosity >= 2)
// {
// LogDebug(invertex->size_tracks());
// LogDebug(invertex->get_chisq());
// LogDebug(invertex->get_ndof());
// for (unsigned int i = 0; i < 3; i++)
// for (unsigned int j = 0; j < 3; j++)
// {
// LogDebug(invertex->get_error(i,j));
// }
//
// }
/*!
*
*/
#if _DEBUG_MODE_ == 1
if (invertex
// and invertex->size_tracks() == 1
) {
TRandom3 rand(0);
double dxy = 0.0007; //7 um
double dz = 0.003; //30 um
TVector3 pos(invertex->get_x(), invertex->get_y(), invertex->get_z());
TMatrixDSym cov(3);
// Use smeared position instead of reco'd one.
double x = rand.Gaus(0, dxy);
double y = rand.Gaus(0, dxy);
double z = rand.Gaus(0, dz);
pos.SetXYZ(x, y, z);
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
cov[i][j] = 0;
cov[0][0] = dxy * dxy;
cov[1][1] = dxy * dxy;
cov[2][2] =dz * dz;
PHGenFit::Measurement* meas = new PHGenFit::SpacepointMeasurement(
pos, cov);
measurements.push_back(meas);
}
#else
//! 1000 is a arbitrary number for now
const double vertex_chi2_over_dnf_cut = 1000;
const double vertex_cov_element_cut = 10000; //arbitrary cut cm*cm
if (invertex and invertex->size_tracks() > 1
and invertex->get_chisq() / invertex->get_ndof()
< vertex_chi2_over_dnf_cut) {
TVector3 pos(invertex->get_x(), invertex->get_y(), invertex->get_z());
TMatrixDSym cov(3);
cov.Zero();
bool is_vertex_cov_sane = true;
for (unsigned int i = 0; i < 3; i++)
for (unsigned int j = 0; j < 3; j++) {
cov(i, j) = invertex->get_error(i, j);
if (i == j) {
if (!(invertex->get_error(i, j) > 0
and invertex->get_error(i, j)
< vertex_cov_element_cut))
is_vertex_cov_sane = false;
}
}
if (is_vertex_cov_sane) {
PHGenFit::Measurement* meas = new PHGenFit::SpacepointMeasurement(
pos, cov);
measurements.push_back(meas);
// if(verbosity >= 2)
// {
// meas->getMeasurement()->Print();
// }
}
}
#endif
for (SvtxTrack::ConstClusterIter iter = intrack->begin_clusters();
iter != intrack->end_clusters(); ++iter) {
unsigned int cluster_id = *iter;
SvtxCluster* cluster = _clustermap->get(cluster_id);
if(!cluster)
{
LogError("No cluster Found!");
continue;
}
//cluster->identify(); //DEBUG
//unsigned int l = cluster->get_layer();
TVector3 pos(cluster->get_x(), cluster->get_y(), cluster->get_z());
TVector3 n(cluster->get_x(), cluster->get_y(), 0);
//TODO use u, v explicitly?
PHGenFit::Measurement* meas = new PHGenFit::PlanarMeasurement(pos, n,
cluster->get_phi_size(), cluster->get_z_size());
//meas->getMeasurement()->Print();// DEBUG
measurements.push_back(meas);
}
//TODO unsorted measurements, should use sorted ones?
track->addMeasurements(measurements);
/*!
* Fit the track
* ret code 0 means 0 error or good status
*/
if(_fitter->processTrack(track, false)!=0)
{
if(verbosity >= 1)
LogWarning("Track fitting failed");
return NULL;
}
return track;
}
int PHG4HoughTransformTPC::process_event(PHCompositeNode *topNode)
{
_timer.get()->restart();
if(_write_reco_tree==true){ _recoevent->tracks.clear();}
if(verbosity > 0) cout << "PHG4HoughTransformTPC::process_event -- entered" << endl;
// moving clearing to the beginning of event or we will have
// return bugs from early exits!
_clusters_init.clear();
_clusters.clear();
_tracks.clear();
//---------------------------------
// Get Objects off of the Node Tree
//---------------------------------
GetNodes(topNode);
// Translate into Helix_Hough objects
//-----------------------------------
//wrap_clusters_timer.get()->restart();
for (SvtxClusterMap::Iter iter = _g4clusters->begin();
iter != _g4clusters->end();
++iter) {
SvtxCluster* cluster = iter->second;
//cluster->identify();
float phi = atan2(cluster->get_position(1),cluster->get_position(0));
unsigned int ilayer = _layer_ilayer_map[cluster->get_layer()];
float xy_error=0.;float z_error=0.;
if (_use_cell_size) {
xy_error = _smear_xy_layer[ilayer] * _vote_error_scale[ilayer];
z_error = _smear_z_layer[ilayer] * _vote_error_scale[ilayer];
}
else {
if( cluster->get_phi_size() <= _max_cluster_error*_smear_xy_layer[ilayer] ){xy_error = cluster->get_phi_size() * _vote_error_scale[ilayer];}
else{xy_error = _max_cluster_error*_smear_xy_layer[ilayer] * _vote_error_scale[ilayer];}
if(cluster->get_z_size() <= _max_cluster_error*_smear_z_layer[ilayer]){z_error = cluster->get_z_size() * _vote_error_scale[ilayer];}
else{z_error = _max_cluster_error*_smear_z_layer[ilayer] * _vote_error_scale[ilayer];}
}
vector<SimpleHit3D>* which_vec = &_clusters;
if (ilayer<_seed_layers) {which_vec=&_clusters_init;}
//SimpleHit3D(float xx, float dxx, float yy, float dyy, float zz, float dzz, unsigned int ind, int lyr=-1)
SimpleHit3D hit3d(cluster->get_x(),fabs(xy_error*sin(phi)),
cluster->get_y(),fabs(xy_error*cos(phi)),
cluster->get_z(),z_error,
cluster->get_id(),ilayer);
// copy covariance over
for (int i=0; i<3; ++i) {
for (int j=i; j<3; ++j) {
hit3d.set_error(i,j,cluster->get_error(i,j));
}
}
which_vec->push_back(hit3d);
}
if (verbosity > 20) {
cout << "-------------------------------------------------------------------" << endl;
cout << "PHG4HoughTransformTPC::process_event has the following input clusters:" << endl;
if (!_clusters_init.empty()) {
for (unsigned int i = 0; i < _clusters_init.size(); ++i) {
cout << "n init clusters = "<<_clusters_init.size() << endl;
_clusters_init[i].print();
}
} else {
for (unsigned int i = 0; i < _clusters.size(); ++i) {
cout << "n clusters = "<<_clusters.size() << endl;
_clusters[i].print();
}
}
cout << "-------------------------------------------------------------------" << endl;
}
cout<<"_clusters_init.size() = "<<_clusters_init.size()<<endl;
//------------------------------------
// Perform the initial zvertex finding
//------------------------------------
if(verbosity > 0) cout << "PHG4HoughTransformTPC::process_event -- initial vertex finding..." << endl;
// Grab some initial tracks for initial z-vertex finding
_tracks.clear();
_vertex.clear();
_vertex.push_back(0.0); // x guess
_vertex.push_back(0.0); // y guess
_vertex.push_back(0.0); // z guess
if(_use_vertex) {
// find maxtracks tracks
unsigned int maxtracks = 100;
// _tracker->setRemoveHits(false);
_tracker->findHelices(_clusters_init, _req_seed, _max_hits_init, _tracks, maxtracks);
// _tracker->setRemoveHits(_remove_hits);
cout<<"found "<<_tracks.size()<<" tracks"<<endl;
if(_tracks.size() == 0){return Fun4AllReturnCodes::EVENT_OK;}
else if(_tracks.size() == 1)
{
_vertex[0] = cos(_tracks[0].phi) * _tracks[0].d;
_vertex[1] = sin(_tracks[0].phi) * _tracks[0].d;
_vertex[2] = _tracks[0].z0;
}
else
{
vector<vector<double> > pTmap;
for(unsigned int i=0;i<_tracks.size();++i)
{
if(_tracks[i].kappa == 0.0){continue;}
double pT = kappaToPt(_tracks[i].kappa);
pTmap.push_back(vector<double>());
pTmap.back().push_back(pT);
pTmap.back().push_back((double)i);
}
sort(pTmap.begin(), pTmap.end());
vector<SimpleTrack3D> vtxtracks;
unsigned int maxvtxtracks=100;
if(_tracks.size() < maxvtxtracks)
{
vtxtracks = _tracks;
}
else
{
for(unsigned int i=0;i<maxvtxtracks;++i)
{
vtxtracks.push_back(_tracks[ (int)(pTmap[pTmap.size()-1-i][1]) ]);
}
}
vector<double> zvertices(3,0.);
vector<float> temp_vertex(3,0.);
vector<unsigned int> vtracks(3,0);
for(unsigned int iter = 0;iter < 3; ++iter)
{
temp_vertex[2] = 0.;
TH1D z0_hist("z0_hist","z0_hist", 20, -10., 10.);
for(unsigned int i=0;i<vtxtracks.size();++i)
{
z0_hist.Fill(vtxtracks[i].z0);
}
temp_vertex[2] = z0_hist.GetBinCenter( z0_hist.GetMaximumBin() );
_vertexFinder.findVertex(vtxtracks, temp_vertex, 3., true);
_vertexFinder.findVertex(vtxtracks, temp_vertex, 0.1, true);
_vertexFinder.findVertex(vtxtracks, temp_vertex, 0.02, false);
vector<SimpleTrack3D> ttracks;
for(unsigned int t=0;t<vtxtracks.size();++t)
{
if( fabs(vtxtracks[t].z0 - temp_vertex[2]) < 0.1 ){vtracks[iter] += 1;}
else{ttracks.push_back(vtxtracks[t]);}
}
vtxtracks = ttracks;
zvertices[iter] = temp_vertex[2];
}
_vertex[2] = zvertices[0];
unsigned int zbest = 0;
for(unsigned int iter = 1;iter < 3; ++iter)
{
if(vtracks[iter] > vtracks[zbest])
{
_vertex[2] = zvertices[iter];
zbest = iter;
}
}
}
if(verbosity > 0) cout << "PHG4HoughTransformTPC::process_event -- found initial vertex : " << _vertex[0] << " " << _vertex[1] << " " << _vertex[2] << endl;
_tracks.clear();
// shift the vertex to the origin
for(unsigned int ht=0;ht<_clusters_init.size();++ht)
{
_clusters_init[ht].x -= _vertex[0];
_clusters_init[ht].y -= _vertex[1];
_clusters_init[ht].z -= _vertex[2];
}
for(unsigned int ht=0;ht<_clusters.size();++ht)
{
_clusters[ht].x -= _vertex[0];
_clusters[ht].y -= _vertex[1];
_clusters[ht].z -= _vertex[2];
}
} // if(_use_vertex)
//----------------------------------
// Preform the track finding
//----------------------------------
_tracker->clear();
_tracks.clear();
_timer_initial_hough.get()->restart();
_tracker->findHelices(_clusters_init, _min_hits_init, _max_hits_init, _tracks);
_timer_initial_hough.get()->stop();
if(verbosity > 0)
{
cout << "PHG4HoughTransformTPC::process_event -- full track finding pass found: " << _tracks.size() << " tracks" << endl;
}
//----------------------------
// Re-center event on detector
//----------------------------
if(verbosity > 0) cout << "PHG4HoughTransformTPC::process_event -- recentering event on detector..." << endl;
vector<double> chi_squareds;
for(unsigned int tt=0;tt<_tracks.size();tt++)
{
// move the hits in the track back to their original position
for(unsigned int hh=0;hh<_tracks[tt].hits.size();hh++)
{
_tracks[tt].hits[hh].x = _tracks[tt].hits[hh].x + _vertex[0];
_tracks[tt].hits[hh].y = _tracks[tt].hits[hh].y + _vertex[1];
_tracks[tt].hits[hh].z = _tracks[tt].hits[hh].z + _vertex[2];
// _tracks[tt].z0 += _vertex[2];
}
chi_squareds.push_back(_tracker->getKalmanStates()[tt].chi2);}
if(verbosity > 0)
{
cout << "PHG4HoughTransformTPC::process_event -- final track count: " << _tracks.size() << endl;
}
//---------------------------
// Final vertex determination
//---------------------------
// final best guess of the primary vertex position here...
if(verbosity > 0)
{
cout<< "PHG4HoughTransformTPC::process_event -- calculating final vertex" << endl;
}
// sort the tracks by pT
vector<vector<double> > pTmap;
for(unsigned int i=0;i<_tracks.size();++i)
{
double pT = kappaToPt(_tracks[i].kappa);
pTmap.push_back(vector<double>());
pTmap.back().push_back(pT);
pTmap.back().push_back((double)i);
}
sort(pTmap.begin(), pTmap.end());
vector<SimpleTrack3D> vtxtracks;
vector<Matrix<float,5,5> > vtxcovariances;
unsigned int maxvtxtracks=100;
if(_tracks.size() < maxvtxtracks){vtxtracks = _tracks;}
else
{
for(unsigned int i=0;i<maxvtxtracks;++i)
{
vtxtracks.push_back(_tracks[ (int)(pTmap[pTmap.size()-1-i][1]) ]);
vtxcovariances.push_back( (_tracker->getKalmanStates())[ (int)(pTmap[pTmap.size()-1-i][1]) ].C );
}
}
double vx = _vertex[0];
double vy = _vertex[1];
double vz = _vertex[2];
_vertex[0] = 0.;
_vertex[1] = 0.;
_vertex[2] = 0.;
_vertexFinder.findVertex(vtxtracks, vtxcovariances, _vertex, 0.3, false);
_vertexFinder.findVertex(vtxtracks, vtxcovariances, _vertex, 0.1, false);
_vertexFinder.findVertex(vtxtracks, vtxcovariances, _vertex, 0.02, false);
_vertexFinder.findVertex(vtxtracks, vtxcovariances, _vertex, 0.005, false);
_vertex[0] += vx;
_vertex[1] += vy;
_vertex[2] += vz;
if(verbosity > 0)
{
cout << "PHG4HoughTransformTPC::process_event -- final vertex: " << _vertex[0] << " " << _vertex[1] << " " << _vertex[2] << endl;
}
//--------------------------------
// Translate back into PHG4 objects
//--------------------------------
if(verbosity > 0)
{
cout << "PHG4HoughTransformTPC::process_event -- producing PHG4Track objects..." << endl;
}
SvtxVertex_v1 vertex;
vertex.set_t0(0.0);
for (int i=0;i<3;++i) vertex.set_position(i,_vertex[i]);
vertex.set_chisq(0.0);
vertex.set_ndof(0);
vertex.set_error(0,0,0.0);
vertex.set_error(0,1,0.0);
vertex.set_error(0,2,0.0);
vertex.set_error(1,0,0.0);
vertex.set_error(1,1,0.0);
vertex.set_error(1,2,0.0);
vertex.set_error(2,0,0.0);
vertex.set_error(2,1,0.0);
vertex.set_error(2,2,0.0);
// copy out the reconstructed vertex position
//_g4tracks->setVertex(_vertex[0],_vertex[1],_vertex[2]);
//_g4tracks->setVertexError(0.0,0.0,0.0);
// at this point we should already have an initial pt and pz guess...
// need to translate this into the PHG4Track object...
vector<SimpleHit3D> track_hits;
int clusterID;
int clusterLayer;
float cluster_x;
float cluster_y;
float cluster_z;
// float dEdx1;
// float dEdx2;
for(unsigned int itrack=0; itrack<_tracks.size();itrack++)
{
SvtxTrack_v1 track;
track.set_id(itrack);
track_hits.clear();
track_hits = _tracks.at(itrack).hits;
for(unsigned int ihit = 0; ihit<track_hits.size();ihit++)
{
// dEdx1=0;
// dEdx2=0;
if( (track_hits.at(ihit).index) >= _g4clusters->size()){continue;}
SvtxCluster *cluster = _g4clusters->get(track_hits.at(ihit).index);
clusterID = cluster->get_id();
clusterLayer = cluster->get_layer();
cluster_x = cluster->get_x();
cluster_y = cluster->get_y();
cluster_z = cluster->get_z();
if( (clusterLayer < (int)_seed_layers) && (clusterLayer >= 0) )
{
track.insert_cluster(clusterID);
}
}
float kappa = _tracks.at(itrack).kappa;
float d = _tracks.at(itrack).d;
float phi = _tracks.at(itrack).phi;
float dzdl = _tracks.at(itrack).dzdl;
float z0 = _tracks.at(itrack).z0;
// track.set_helix_phi(phi);
// track.set_helix_kappa(kappa);
// track.set_helix_d(d);
// track.set_helix_z0(z0);
// track.set_helix_dzdl(dzdl);
float pT = kappaToPt(kappa);
float x_center = cos(phi)*(d+1/kappa); // x coordinate of circle center
float y_center = sin(phi)*(d+1/kappa); // y " " " "
// find helicity from cross product sign
short int helicity;
if((track_hits[0].x-x_center)*(track_hits[track_hits.size()-1].y-y_center) -
(track_hits[0].y-y_center)*(track_hits[track_hits.size()-1].x-x_center) > 0)
{
helicity = 1;
}
else
{
helicity = -1;
}
float pZ = 0;
if(dzdl != 1)
{
pZ = pT * dzdl / sqrt(1.0 - dzdl*dzdl);
}
int ndf = 2*_tracks.at(itrack).hits.size() - 5;
track.set_chisq(chi_squareds[itrack]);
track.set_ndf(ndf);
track.set_px( pT*cos(phi-helicity*M_PI/2) );
track.set_py( pT*sin(phi-helicity*M_PI/2) );
track.set_pz( pZ );
track.set_dca2d( d );
track.set_dca2d_error(sqrt(_tracker->getKalmanStates()[itrack].C(1,1)));
if(_write_reco_tree==true)
{
_recoevent->tracks.push_back( SimpleRecoTrack() );
_recoevent->tracks.back().px = pT*cos(phi-helicity*M_PI/2);
_recoevent->tracks.back().py = pT*sin(phi-helicity*M_PI/2);
_recoevent->tracks.back().pz = pZ;
_recoevent->tracks.back().d = d;
_recoevent->tracks.back().z0 = z0;
_recoevent->tracks.back().quality = chi_squareds[itrack]/((float)ndf);
_recoevent->tracks.back().charge = (-1*helicity);
}
if(_magField > 0)
{
track.set_charge( helicity );
}
else
{
track.set_charge( -1.0*helicity );
}
Matrix<float,6,6> euclidean_cov = Matrix<float,6,6>::Zero(6,6);
convertHelixCovarianceToEuclideanCovariance( _magField, phi, d, kappa, z0, dzdl, _tracker->getKalmanStates()[itrack].C, euclidean_cov );
for(unsigned int row=0;row<6;++row)
{
for(unsigned int col=0;col<6;++col)
{
track.set_error(row,col,euclidean_cov(row,col));
}
}
track.set_x( vertex.get_x() + d*cos(phi) );
track.set_y( vertex.get_y() + d*sin(phi) );
track.set_z( vertex.get_z() + z0 );
_g4tracks->insert(&track);
vertex.insert_track(track.get_id());
if (verbosity > 5) {
cout << "track " << itrack << " quality = "
<< track.get_quality() << endl;
cout << "px = " << track.get_px()
<< " py = " << track.get_py()
<< " pz = " << track.get_pz() << endl;
}
} // track loop
SvtxVertex *vtxptr = _g4vertexes->insert(&vertex);
if (verbosity > 5) vtxptr->identify();
if(verbosity > 0)
{
cout << "PHG4HoughTransformTPC::process_event -- leaving process_event" << endl;
}
if(_write_reco_tree==true){ _reco_tree->Fill(); }
_timer.get()->stop();
return Fun4AllReturnCodes::EVENT_OK;
}
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;
}
void SvtxEvaluator::printOutputInfo(PHCompositeNode *topNode) {
if (verbosity > 1) cout << "SvtxEvaluator::printOutputInfo() entered" << endl;
//==========================================
// print out some useful stuff for debugging
//==========================================
if (verbosity > 0) {
SvtxTrackEval* trackeval = _svtxevalstack->get_track_eval();
SvtxClusterEval* clustereval = _svtxevalstack->get_cluster_eval();
SvtxTruthEval* trutheval = _svtxevalstack->get_truth_eval();
// event information
cout << endl;
cout << PHWHERE << " NEW OUTPUT FOR EVENT " << _ievent << endl;
cout << endl;
PHG4TruthInfoContainer* truthinfo = findNode::getClass<PHG4TruthInfoContainer>(topNode,"G4TruthInfo");
PHG4VtxPoint *gvertex = truthinfo->GetPrimaryVtx( truthinfo->GetPrimaryVertexIndex() );
float gvx = gvertex->get_x();
float gvy = gvertex->get_y();
float gvz = gvertex->get_z();
float vx = NAN;
float vy = NAN;
float vz = NAN;
SvtxVertexMap* vertexmap = findNode::getClass<SvtxVertexMap>(topNode,"SvtxVertexMap");
if (vertexmap) {
if (!vertexmap->empty()) {
SvtxVertex* vertex = (vertexmap->begin()->second);
vx = vertex->get_x();
vy = vertex->get_y();
vz = vertex->get_z();
}
}
cout << "===Vertex Reconstruction=======================" << endl;
cout << "vtrue = (" << gvx << "," << gvy << "," << gvz << ") => vreco = (" << vx << "," << vy << "," << vz << ")" << endl;
cout << endl;
cout << "===Tracking Summary============================" << endl;
unsigned int ng4hits[100] = {0};
std::set<PHG4Hit*> g4hits = trutheval->all_truth_hits();
for (std::set<PHG4Hit*>::iterator iter = g4hits.begin();
iter != g4hits.end();
++iter) {
PHG4Hit *g4hit = *iter;
++ng4hits[g4hit->get_layer()];
}
SvtxHitMap* hitmap = findNode::getClass<SvtxHitMap>(topNode,"SvtxHitMap");
unsigned int nhits[100] = {0};
if (hitmap) {
for (SvtxHitMap::Iter iter = hitmap->begin();
iter != hitmap->end();
++iter) {
SvtxHit* hit = iter->second;
++nhits[hit->get_layer()];
}
}
SvtxClusterMap* clustermap = findNode::getClass<SvtxClusterMap>(topNode,"SvtxClusterMap");
unsigned int nclusters[100] = {0};
if (clustermap) {
for (SvtxClusterMap::Iter iter = clustermap->begin();
iter != clustermap->end();
++iter) {
SvtxCluster* cluster = iter->second;
++nclusters[cluster->get_layer()];
}
}
for (unsigned int ilayer = 0; ilayer < 100; ++ilayer) {
cout << "layer " << ilayer << ": nG4hits = " << ng4hits[ilayer]
<< " => nHits = " << nhits[ilayer]
<< " => nClusters = " << nclusters[ilayer] << endl;
}
SvtxTrackMap* trackmap = findNode::getClass<SvtxTrackMap>(topNode,"SvtxTrackMap");
cout << "nGtracks = " << std::distance(truthinfo->GetPrimaryParticleRange().first,
truthinfo->GetPrimaryParticleRange().second);
cout << " => nTracks = ";
if (trackmap) cout << trackmap->size() << endl;
else cout << 0 << endl;
// cluster wise information
if (verbosity > 1) {
for(std::set<PHG4Hit*>::iterator iter = g4hits.begin();
iter != g4hits.end();
++iter) {
PHG4Hit *g4hit = *iter;
cout << endl;
cout << "===PHG4Hit===================================" << endl;
cout << " PHG4Hit: "; g4hit->identify();
std::set<SvtxCluster*> clusters = clustereval->all_clusters_from(g4hit);
for (std::set<SvtxCluster*>::iterator jter = clusters.begin();
jter != clusters.end();
++jter) {
SvtxCluster *cluster = *jter;
cout << "===Created-SvtxCluster================" << endl;
cout << "SvtxCluster: "; cluster->identify();
}
}
PHG4TruthInfoContainer::ConstRange range = truthinfo->GetPrimaryParticleRange();
for (PHG4TruthInfoContainer::ConstIterator iter = range.first;
iter != range.second;
++iter) {
PHG4Particle *particle = iter->second;
// track-wise information
cout << endl;
cout << "=== Gtrack ===================================================" << endl;
cout << " PHG4Particle id = " << particle->get_track_id() << endl;
particle->identify();
cout << " ptrue = (";
cout.width(5); cout << particle->get_px();
cout << ",";
cout.width(5); cout << particle->get_py();
cout << ",";
cout.width(5); cout << particle->get_pz();
cout << ")" << endl;
cout << " vtrue = (";
cout.width(5); cout << truthinfo->GetVtx(particle->get_vtx_id())->get_x();
cout << ",";
cout.width(5); cout << truthinfo->GetVtx(particle->get_vtx_id())->get_y();
cout << ",";
cout.width(5); cout << truthinfo->GetVtx(particle->get_vtx_id())->get_z();
cout << ")" << endl;
cout << " pt = " << sqrt(pow(particle->get_px(),2)+pow(particle->get_py(),2)) << endl;
cout << " phi = " << atan2(particle->get_py(),particle->get_px()) << endl;
cout << " eta = " << asinh(particle->get_pz()/sqrt(pow(particle->get_px(),2)+pow(particle->get_py(),2))) << endl;
cout << " embed flag = " << truthinfo->isEmbeded(particle->get_track_id()) << endl;
cout << " ---Associated-PHG4Hits-----------------------------------------" << endl;
std::set<PHG4Hit*> g4hits = trutheval->all_truth_hits(particle);
for(std::set<PHG4Hit*>::iterator jter = g4hits.begin();
jter != g4hits.end();
++jter) {
PHG4Hit *g4hit = *jter;
float x = 0.5*(g4hit->get_x(0)+g4hit->get_x(1));
float y = 0.5*(g4hit->get_y(0)+g4hit->get_y(1));
float z = 0.5*(g4hit->get_z(0)+g4hit->get_z(1));
cout << " #" << g4hit->get_hit_id() << " xtrue = (";
cout.width(5); cout << x;
cout << ",";
cout.width(5); cout << y;
cout << ",";
cout.width(5); cout << z;
cout << ")";
std::set<SvtxCluster*> clusters = clustereval->all_clusters_from(g4hit);
for (std::set<SvtxCluster*>::iterator kter = clusters.begin();
kter != clusters.end();
++kter) {
SvtxCluster *cluster = *kter;
float x = cluster->get_x();
float y = cluster->get_y();
float z = cluster->get_z();
cout << " => #" << cluster->get_id();
cout << " xreco = (";
cout.width(5); cout << x;
cout << ",";
cout.width(5); cout << y;
cout << ",";
cout.width(5); cout << z;
cout << ")";
}
cout << endl;
}
if (trackmap&&clustermap) {
std::set<SvtxTrack*> tracks = trackeval->all_tracks_from(particle);
for (std::set<SvtxTrack*>::iterator jter = tracks.begin();
jter != tracks.end();
++jter) {
SvtxTrack *track = *jter;
float px = track->get_px();
float py = track->get_py();
float pz = track->get_pz();
cout << "===Created-SvtxTrack==========================================" << endl;
cout << " SvtxTrack id = " << track->get_id() << endl;
cout << " preco = (";
cout.width(5); cout << px;
cout << ",";
cout.width(5); cout << py;
cout << ",";
cout.width(5); cout << pz;
cout << ")" << endl;
cout << " quality = " << track->get_quality() << endl;
cout << " nfromtruth = " << trackeval->get_nclusters_contribution(track,particle) << endl;
cout << " ---Associated-SvtxClusters-to-PHG4Hits-------------------------" << endl;
for (SvtxTrack::ConstClusterIter iter = track->begin_clusters();
iter != track->end_clusters();
++iter) {
unsigned int cluster_id = *iter;
SvtxCluster* cluster = clustermap->get(cluster_id);
float x = cluster->get_x();
float y = cluster->get_y();
float z = cluster->get_z();
cout << " #" << cluster->get_id() << " xreco = (";
cout.width(5); cout << x;
cout << ",";
cout.width(5); cout << y;
cout << ",";
cout.width(5); cout << z;
cout << ") =>";
PHG4Hit* g4hit = clustereval->max_truth_hit_by_energy(cluster);
if ((g4hit) && (g4hit->get_trkid() == particle->get_track_id())) {
x = 0.5*(g4hit->get_x(0)+g4hit->get_x(1));
y = 0.5*(g4hit->get_y(0)+g4hit->get_y(1));
z = 0.5*(g4hit->get_z(0)+g4hit->get_z(1));
cout << " #" << g4hit->get_hit_id()
<< " xtrue = (";
cout.width(5); cout << x;
cout << ",";
cout.width(5); cout << y;
cout << ",";
cout.width(5); cout << z;
cout << ") => Gtrack id = " << g4hit->get_trkid();
} else {
cout << " noise hit";
}
}
cout << endl;
}
}
}
}
cout << endl;
} // if verbosity
return;
}
void SvtxEvaluator::printInputInfo(PHCompositeNode *topNode) {
if (verbosity > 1) cout << "SvtxEvaluator::printInputInfo() entered" << endl;
if (verbosity > 3) {
// event information
cout << endl;
cout << PHWHERE << " INPUT FOR EVENT " << _ievent << endl;
cout << endl;
cout << "---PHG4HITS-------------" << endl;
_svtxevalstack->get_truth_eval()->set_strict(_strict);
std::set<PHG4Hit*> g4hits = _svtxevalstack->get_truth_eval()->all_truth_hits();
unsigned int ig4hit = 0;
for(std::set<PHG4Hit*>::iterator iter = g4hits.begin();
iter != g4hits.end();
++iter) {
PHG4Hit *g4hit = *iter;
cout << ig4hit << " of " << g4hits.size();
cout << ": PHG4Hit: " << endl;
g4hit->identify();
++ig4hit;
}
cout << "---SVTXCLUSTERS-------------" << endl;
SvtxClusterMap* clustermap = findNode::getClass<SvtxClusterMap>(topNode,"SvtxClusterMap");
if (clustermap) {
unsigned int icluster = 0;
for (SvtxClusterMap::Iter iter = clustermap->begin();
iter != clustermap->end();
++iter) {
SvtxCluster* cluster = iter->second;
cout << icluster << " of " << clustermap->size();
cout << ": SvtxCluster: " << endl;
cluster->identify();
++icluster;
}
}
cout << "---SVXTRACKS-------------" << endl;
SvtxTrackMap* trackmap = findNode::getClass<SvtxTrackMap>(topNode,"SvtxTrackMap");
if (trackmap) {
unsigned int itrack = 0;
for (SvtxTrackMap::Iter iter = trackmap->begin();
iter != trackmap->end();
++iter) {
cout << itrack << " of " << trackmap->size();
SvtxTrack *track = iter->second;
cout << " : SvtxTrack:" << endl;
track->identify();
cout << endl;
}
}
cout << "---SVXVERTEXES-------------" << endl;
SvtxVertexMap* vertexmap = findNode::getClass<SvtxVertexMap>(topNode,"SvtxVertexMap");
if (vertexmap) {
unsigned int ivertex = 0;
for (SvtxVertexMap::Iter iter = vertexmap->begin();
iter != vertexmap->end();
++iter) {
cout << ivertex << " of " << vertexmap->size();
SvtxVertex *vertex = iter->second;
cout << " : SvtxVertex:" << endl;
vertex->identify();
cout << endl;
}
}
}
return;
}
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) {
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 gntracks = truthinfo->GetNumPrimaryVertexParticles();
float nfromtruth = NAN;
if (point) {
gvx = point->get_x();
gvy = point->get_y();
gvz = point->get_z();
gntracks = truthinfo->GetNumPrimaryVertexParticles();
nfromtruth = vertexeval->get_ntracks_contribution(vertex,point);
}
float vertex_data[10] = {_ievent,
vx,
vy,
vz,
ntracks,
gvx,
gvy,
gvz,
gntracks,
nfromtruth
};
_ntp_vertex->Fill(vertex_data);
}
}
}
//-----------------------
// fill the gpoint NTuple
//-----------------------
if (_ntp_gpoint) {
SvtxVertexMap* vertexmap = findNode::getClass<SvtxVertexMap>(topNode,"SvtxVertexMap");
PHG4TruthInfoContainer* truthinfo = findNode::getClass<PHG4TruthInfoContainer>(topNode,"G4TruthInfo");
if (vertexmap && truthinfo) {
PHG4VtxPoint* point = truthinfo->GetPrimaryVtx(truthinfo->GetPrimaryVertexIndex());
SvtxVertex* vertex = vertexeval->best_vertex_from(point);
float gvx = point->get_x();
float gvy = point->get_y();
float gvz = point->get_z();
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[10] = {_ievent,
gvx,
gvy,
gvz,
gntracks,
vx,
vy,
vz,
ntracks,
nfromtruth
};
_ntp_gpoint->Fill(gpoint_data);
}
}
//---------------------
// fill the G4hit NTuple
//---------------------
if (_ntp_g4hit) {
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 = 0.5*(g4hit->get_x(0)+g4hit->get_x(1));
float gy = 0.5*(g4hit->get_y(0)+g4hit->get_y(1));
float gz = 0.5*(g4hit->get_z(0)+g4hit->get_z(1));
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 = NULL;
float gfpy = NULL;
float gfpz = NULL;
float gfx = NULL;
float gfy = NULL;
float gfz = NULL;
if (g4particle) {
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[35] = {_ievent,
g4hitID,
gx,
gy,
gz,
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) {
// 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 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 glast = NAN;
float gembed = NAN;
float gprimary = NAN;
float efromtruth = NAN;
if (g4hit) {
g4hitID = g4hit->get_hit_id();
gedep = g4hit->get_edep();
gx = 0.5*(g4hit->get_x(0)+g4hit->get_x(1));
gy = 0.5*(g4hit->get_y(0)+g4hit->get_y(1));
gz = 0.5*(g4hit->get_z(0)+g4hit->get_z(1));
gx = g4hit->get_x(0);
gy = g4hit->get_y(0);
gz = g4hit->get_z(0);
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);
}
glast = NAN;
gembed = trutheval->get_embed(g4particle);
gprimary = trutheval->is_primary(g4particle);
} // if (g4particle){
}
if (g4particle) {
efromtruth = hiteval->get_energy_contribution(hit,g4particle);
}
float hit_data[32] = {
event,
hitID,
e,
adc,
layer,
cellID,
ecell,
g4hitID,
gedep,
gx,
gy,
gz,
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
//------------------------
if (_ntp_cluster) {
// 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;
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 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 g4hitID = NAN;
float gx = NAN;
float gy = NAN;
float gz = 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 glast = NAN;
float gembed = NAN;
float gprimary = NAN;
float nhits = NAN;
float efromtruth = NAN;
if (g4hit) {
g4hitID = g4hit->get_hit_id();
gx = 0.5*(g4hit->get_x(0)+g4hit->get_x(1));
gy = 0.5*(g4hit->get_y(0)+g4hit->get_y(1));
gz = 0.5*(g4hit->get_z(0)+g4hit->get_z(1));
gx = g4hit->get_x(0);
gy = g4hit->get_y(0);
gz = g4hit->get_z(0);
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);
}
glast = NAN;
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[33] = {_ievent,
hitID,
x,
y,
z,
e,
adc,
layer,
size,
phisize,
zsize,
g4hitID,
gx,
gy,
gz,
gtrackID,
gflavor,
gpx,
gpy,
gpz,
gvx,
gvy,
gvz,
gfpx,
gfpy,
gfpz,
gfx,
gfy,
gfz,
gembed,
gprimary,
nhits,
efromtruth};
_ntp_cluster->Fill(cluster_data);
}
}
}
//------------------------
// fill the Gtrack NTuple
//------------------------
// need things off of the DST...
if (_ntp_gtrack) {
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;
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 gfpx = NULL;
float gfpy = NULL;
float gfpz = NULL;
float gfx = NULL;
float gfy = NULL;
float gfz = NULL;
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 dca = NAN;
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;
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);
}
dca = track->get_dca();
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);
}
float gtrack_data[34] = {_ievent,
gtrackID,
gflavor,
ng4hits,
gpx,
gpy,
gpz,
gvx,
gvy,
gvz,
gfpx,
gfpy,
gfpz,
gfx,
gfy,
gfz,
gembed,
gprimary,
trackID,
px,
py,
pz,
charge,
quality,
chisq,
ndf,
nhits,
layers,
dca2d,
dca2dsigma,
pcax,
pcay,
pcaz,
nfromtruth
};
_ntp_gtrack->Fill(gtrack_data);
}
}
}
//------------------------
// fill the Track NTuple
//------------------------
if (_ntp_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;
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 < 32) 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 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;
PHG4Particle* g4particle = trackeval->max_truth_particle_by_nclusters(track);
if (g4particle) {
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();
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);
}
float track_data[50] = {_ievent,
trackID,
px,
py,
pz,
charge,
quality,
chisq,
ndf,
nhits,
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,
gfpx,
gfpy,
gfpz,
gfx,
gfy,
gfz,
gembed,
gprimary,
nfromtruth
};
_ntp_track->Fill(track_data);
}
}
}
return;
}
int PHG4HoughTransform::export_output() {
if (_tracks.empty()) return Fun4AllReturnCodes::EVENT_OK;
SvtxVertex_v1 vertex;
vertex.set_t0(0.0);
for (int i=0;i<3;++i) vertex.set_position(i,_vertex[i]);
vertex.set_chisq(0.0);
vertex.set_ndof(0);
vertex.set_error(0,0,0.0);
vertex.set_error(0,1,0.0);
vertex.set_error(0,2,0.0);
vertex.set_error(1,0,0.0);
vertex.set_error(1,1,0.0);
vertex.set_error(1,2,0.0);
vertex.set_error(2,0,0.0);
vertex.set_error(2,1,0.0);
vertex.set_error(2,2,0.0);
// at this point we should already have an initial pt and pz guess...
// need to translate this into the PHG4Track object...
vector<SimpleHit3D> track_hits;
int clusterID;
int clusterLayer;
for (unsigned int itrack = 0; itrack < _tracks.size(); itrack++) {
SvtxTrack_v1 track;
track.set_id(itrack);
track_hits.clear();
track_hits = _tracks.at(itrack).hits;
for (unsigned int ihit = 0; ihit < track_hits.size(); ihit++) {
if ((track_hits.at(ihit).get_id()) >= _g4clusters->size()) {
continue;
}
SvtxCluster* cluster = _g4clusters->get(track_hits.at(ihit).get_id());
clusterID = cluster->get_id();
clusterLayer = cluster->get_layer();
if ((clusterLayer < (int)_nlayers) && (clusterLayer >= 0)) {
track.insert_cluster(clusterID);
}
}
float kappa = _tracks.at(itrack).kappa;
float d = _tracks.at(itrack).d;
float phi = _tracks.at(itrack).phi;
float dzdl = _tracks.at(itrack).dzdl;
float z0 = _tracks.at(itrack).z0;
// track.set_helix_phi(phi);
// track.set_helix_kappa(kappa);
// track.set_helix_d(d);
// track.set_helix_z0(z0);
// track.set_helix_dzdl(dzdl);
float pT = kappaToPt(kappa);
float x_center =
cos(phi) * (d + 1 / kappa); // x coordinate of circle center
float y_center = sin(phi) * (d + 1 / kappa); // y " " " "
// find helicity from cross product sign
short int helicity;
if ((track_hits[0].get_x() - x_center) *
(track_hits[track_hits.size() - 1].get_y() - y_center) -
(track_hits[0].get_y() - y_center) *
(track_hits[track_hits.size() - 1].get_x() - x_center) > 0) {
helicity = 1;
} else {
helicity = -1;
}
float pZ = 0;
if (dzdl != 1) {
pZ = pT * dzdl / sqrt(1.0 - dzdl * dzdl);
}
int ndf = 2 * _tracks.at(itrack).hits.size() - 5;
track.set_chisq(_track_errors[itrack]);
track.set_ndf(ndf);
track.set_px(pT * cos(phi - helicity * M_PI / 2));
track.set_py(pT * sin(phi - helicity * M_PI / 2));
track.set_pz(pZ);
track.set_dca2d(d);
track.set_dca2d_error(sqrt(_track_covars[itrack](1, 1)));
if (_magField > 0) {
track.set_charge(helicity);
} else {
track.set_charge(-1.0 * helicity);
}
Eigen::Matrix<float, 6, 6> euclidean_cov = Eigen::Matrix<float, 6, 6>::Zero(6, 6);
convertHelixCovarianceToEuclideanCovariance(
_magField, phi, d, kappa, z0, dzdl,
_track_covars[itrack], euclidean_cov);
for (unsigned int row = 0; row < 6; ++row) {
for (unsigned int col = 0; col < 6; ++col) {
track.set_error(row, col, euclidean_cov(row, col));
}
}
track.set_x(vertex.get_x() + d * cos(phi));
track.set_y(vertex.get_y() + d * sin(phi));
track.set_z(vertex.get_z() + z0);
_g4tracks->insert(&track);
vertex.insert_track(track.get_id());
if (verbosity > 5) {
cout << "track " << itrack << " quality = " << track.get_quality()
<< endl;
cout << "px = " << track.get_px() << " py = " << track.get_py()
<< " pz = " << track.get_pz() << endl;
}
} // track loop
SvtxVertex *vtxptr = _g4vertexes->insert(&vertex);
if (verbosity > 5) vtxptr->identify();
if (verbosity > 0) {
cout << "PHG4HoughTransform::process_event -- leaving process_event"
<< endl;
}
// we are done with these now...
_clusters.clear();
_tracks.clear();
_track_errors.clear();
_track_covars.clear();
_vertex.clear();
_vertex.assign(3,0.0);
return Fun4AllReturnCodes::EVENT_OK;
}
void PHG4SvtxClusterizer::ClusterLadderCells(PHCompositeNode *topNode) {
//----------
// Get Nodes
//----------
// get the SVX geometry object
PHG4CylinderGeomContainer* geom_container = findNode::getClass<PHG4CylinderGeomContainer>(topNode,"CYLINDERGEOM_SILICON_TRACKER");
if (!geom_container) return;
PHG4HitContainer* g4hits = findNode::getClass<PHG4HitContainer>(topNode,"G4HIT_SILICON_TRACKER");
if (!g4hits) return;
PHG4CylinderCellContainer* cells = findNode::getClass<PHG4CylinderCellContainer>(topNode,"G4CELL_SILICON_TRACKER");
if (!cells) return;
//-----------
// Clustering
//-----------
// sort hits layer by layer
std::multimap<int,SvtxHit*> layer_hits_mmap;
for (SvtxHitMap::Iter iter = _hits->begin();
iter != _hits->end();
++iter) {
SvtxHit* hit = &iter->second;
layer_hits_mmap.insert(make_pair(hit->get_layer(),hit));
}
PHG4CylinderGeomContainer::ConstRange layerrange = geom_container->get_begin_end();
for(PHG4CylinderGeomContainer::ConstIterator layeriter = layerrange.first;
layeriter != layerrange.second;
++layeriter) {
int layer = layeriter->second->get_layer();
std::map<PHG4CylinderCell*,SvtxHit*> cell_hit_map;
vector<PHG4CylinderCell*> cell_list;
for (std::multimap<int,SvtxHit*>::iterator hiter = layer_hits_mmap.lower_bound(layer);
hiter != layer_hits_mmap.upper_bound(layer);
++hiter) {
SvtxHit* hit = hiter->second;
PHG4CylinderCell* cell = cells->findCylinderCell(hit->get_cellid());
cell_list.push_back(cell);
cell_hit_map.insert(make_pair(cell,hit));
}
if (cell_list.size() == 0) continue; // if no cells, go to the next layer
// i'm not sure this sorting is ever really used
sort(cell_list.begin(), cell_list.end(), PHG4SvtxClusterizer::ladder_lessthan);
typedef adjacency_list <vecS, vecS, undirectedS> Graph;
typedef graph_traits<Graph>::vertex_descriptor Vertex;
Graph G;
for(unsigned int i=0; i<cell_list.size(); i++) {
for(unsigned int j=i+1; j<cell_list.size(); j++) {
if(ladder_are_adjacent(cell_list[i], cell_list[j]) )
add_edge(i,j,G);
}
add_edge(i,i,G);
}
// Find the connections between the vertices of the graph (vertices are the rawhits,
// connections are made when they are adjacent to one another)
vector<int> component(num_vertices(G));
// this is the actual clustering, performed by boost
connected_components(G, &component[0]);
// Loop over the components(hit cells) compiling a list of the
// unique connected groups (ie. clusters).
set<int> cluster_ids; // unique components
multimap<int, PHG4CylinderCell*> clusters;
for (unsigned int i=0; i<component.size(); i++) {
cluster_ids.insert( component[i] );
clusters.insert( make_pair(component[i], cell_list[i]) );
}
//
for (set<int>::iterator clusiter = cluster_ids.begin();
clusiter != cluster_ids.end();
clusiter++ ) {
int clusid = *clusiter;
pair<multimap<int, PHG4CylinderCell*>::iterator,
multimap<int, PHG4CylinderCell*>::iterator> clusrange = clusters.equal_range(clusid);
multimap<int, PHG4CylinderCell*>::iterator mapiter = clusrange.first;
int layer = mapiter->second->get_layer();
PHG4CylinderGeom* geom = geom_container->GetLayerGeom(layer);
SvtxCluster clus;
clus.set_layer( layer );
float clus_energy = 0.0;
unsigned int clus_adc = 0;
// determine the size of the cluster in phi and z
// useful for track fitting the cluster
set<int> phibins;
set<int> zbins;
for (mapiter = clusrange.first; mapiter != clusrange.second; mapiter++ ) {
PHG4CylinderCell* cell = mapiter->second;
phibins.insert(cell->get_binphi());
zbins.insert(cell->get_binz());
}
float thickness = geom->get_thickness();
float pitch = geom->get_strip_y_spacing();
float length = geom->get_strip_z_spacing();
float phisize = phibins.size()*pitch;
float zsize = zbins.size()*length;
float tilt = geom->get_strip_tilt();
// determine the cluster position...
double xsum = 0.0;
double ysum = 0.0;
double zsum = 0.0;
unsigned nhits = 0;
int ladder_z_index = -1;
int ladder_phi_index = -1;
for(mapiter = clusrange.first; mapiter != clusrange.second; mapiter++ ) {
PHG4CylinderCell* cell = mapiter->second;
SvtxHit* hit = cell_hit_map[cell];
clus.insert_hit(hit->get_id());
clus_energy += hit->get_e();
clus_adc += hit->get_adc();
double hit_location[3] = {0.0,0.0,0.0};
geom->find_strip_center(cell->get_ladder_z_index(),
cell->get_ladder_phi_index(),
cell->get_binz(),
cell->get_binphi(),
hit_location);
ladder_z_index = cell->get_ladder_z_index();
ladder_phi_index = cell->get_ladder_phi_index();
if (_make_e_weights[layer]) {
xsum += hit_location[0] * hit->get_adc();
ysum += hit_location[1] * hit->get_adc();
zsum += hit_location[2] * hit->get_adc();
} else {
xsum += hit_location[0];
ysum += hit_location[1];
zsum += hit_location[2];
}
++nhits;
}
double clusx = NAN;
double clusy = NAN;
double clusz = NAN;
if (_make_e_weights[layer]) {
clusx = xsum / clus_adc;
clusy = ysum / clus_adc;
clusz = zsum / clus_adc;
} else {
clusx = xsum / nhits;
clusy = ysum / nhits;
clusz = zsum / nhits;
}
double ladder_location[3] = {0.0,0.0,0.0};
geom->find_segment_center(ladder_z_index,
ladder_phi_index,
ladder_location);
double ladderphi = atan2( ladder_location[1], ladder_location[0] );
clus.set_position(0, clusx);
clus.set_position(1, clusy);
clus.set_position(2, clusz);
clus.set_e(clus_energy);
clus.set_adc(clus_adc);
float invsqrt12 = 1.0/sqrt(12.0);
TMatrixF DIM(3,3);
DIM[0][0] = pow(0.5*thickness,2);
DIM[0][1] = 0.0;
DIM[0][2] = 0.0;
DIM[1][0] = 0.0;
DIM[1][1] = pow(0.5*phisize,2);
DIM[1][2] = 0.0;
DIM[2][0] = 0.0;
DIM[2][1] = 0.0;
DIM[2][2] = pow(0.5*zsize,2);
TMatrixF ERR(3,3);
ERR[0][0] = pow(0.5*thickness*invsqrt12,2);
ERR[0][1] = 0.0;
ERR[0][2] = 0.0;
ERR[1][0] = 0.0;
ERR[1][1] = pow(0.5*phisize*invsqrt12,2);
ERR[1][2] = 0.0;
ERR[2][0] = 0.0;
ERR[2][1] = 0.0;
ERR[2][2] = pow(0.5*zsize*invsqrt12,2);
TMatrixF ROT(3,3);
ROT[0][0] = cos(ladderphi);
ROT[0][1] = -1.0*sin(ladderphi);
ROT[0][2] = 0.0;
ROT[1][0] = sin(ladderphi);
ROT[1][1] = cos(ladderphi);
ROT[1][2] = 0.0;
ROT[2][0] = 0.0;
ROT[2][1] = 0.0;
ROT[2][2] = 1.0;
TMatrixF TILT(3,3);
TILT[0][0] = 1.0;
TILT[0][1] = 0.0;
TILT[0][2] = 0.0;
TILT[1][0] = 0.0;
TILT[1][1] = cos(tilt);
TILT[1][2] = -1.0*sin(tilt);
TILT[2][0] = 0.0;
TILT[2][1] = sin(tilt);
TILT[2][2] = cos(tilt);
TMatrixF R(3,3);
R = ROT * TILT;
TMatrixF R_T(3,3);
R_T.Transpose(R);
TMatrixF COVAR_DIM(3,3);
COVAR_DIM = R * DIM * R_T;
clus.set_size( 0 , 0 , COVAR_DIM[0][0] );
clus.set_size( 0 , 1 , COVAR_DIM[0][1] );
clus.set_size( 0 , 2 , COVAR_DIM[0][2] );
clus.set_size( 1 , 0 , COVAR_DIM[1][0] );
clus.set_size( 1 , 1 , COVAR_DIM[1][1] );
clus.set_size( 1 , 2 , COVAR_DIM[1][2] );
clus.set_size( 2 , 0 , COVAR_DIM[2][0] );
clus.set_size( 2 , 1 , COVAR_DIM[2][1] );
clus.set_size( 2 , 2 , COVAR_DIM[2][2] );
TMatrixF COVAR_ERR(3,3);
COVAR_ERR = R * ERR * R_T;
clus.set_error( 0 , 0 , COVAR_ERR[0][0] );
clus.set_error( 0 , 1 , COVAR_ERR[0][1] );
clus.set_error( 0 , 2 , COVAR_ERR[0][2] );
clus.set_error( 1 , 0 , COVAR_ERR[1][0] );
clus.set_error( 1 , 1 , COVAR_ERR[1][1] );
clus.set_error( 1 , 2 , COVAR_ERR[1][2] );
clus.set_error( 2 , 0 , COVAR_ERR[2][0] );
clus.set_error( 2 , 1 , COVAR_ERR[2][1] );
clus.set_error( 2 , 2 , COVAR_ERR[2][2] );
if (clus_energy > get_threshold_by_layer(layer)) {
SvtxCluster* ptr = _clusterlist->insert(clus);
if (!ptr->IsValid()) {
static bool first = true;
if (first) {
cout << PHWHERE << "ERROR: Invalid SvtxClusters are being produced" << endl;
ptr->identify();
first = false;
}
}
if (verbosity>1) {
double radius = sqrt(clusx*clusx+clusy*clusy);
double clusphi = atan2(clusy,clusx);
cout << "r=" << radius << " phi=" << clusphi << " z=" << clusz << endl;
cout << "pos=(" << clus.get_position(0) << ", " << clus.get_position(1)
<< ", " << clus.get_position(2) << ")" << endl;
cout << endl;
}
} else if (verbosity>1) {
double radius = sqrt(clusx*clusx+clusy*clusy);
double clusphi = atan2(clusy,clusx);
cout << "removed r=" << radius << " phi=" << clusphi << " z=" << clusz << endl;
cout << "pos=(" << clus.get_position(0) << ", " << clus.get_position(1)
<< ", " << clus.get_position(2) << ")" << endl;
cout << endl;
}
}
}
return;
}
