49 #include <gsl/gsl_randist.h>
50 #include <gsl/gsl_rng.h>
53 #include <TMatrixFfwd.h>
90 for(
unsigned int layer = _nlayers_maps + _nlayers_intt;
layer < _nlayers_maps + _nlayers_intt + 16; ++
layer)
100 for(
unsigned int layer = _nlayers_maps + _nlayers_intt +_nlayers_tpc;
layer < _nlayers_maps + _nlayers_intt +_nlayers_tpc + 1; ++
layer)
106 for(
unsigned int layer = _nlayers_maps + _nlayers_intt +_nlayers_tpc + 1;
layer < _nlayers_maps + _nlayers_intt +_nlayers_tpc + 2; ++
layer)
114 for(
unsigned int layer = 0;
layer < _nlayers_maps + _nlayers_intt +_nlayers_tpc + 2; ++
layer)
124 cout <<
"Filling truth cluster node " << endl;
127 auto m_clusterlist = findNode::getClass<TrkrClusterContainer>(topNode,
"TRKR_CLUSTER_TRUTH");
130 cout <<
PHWHERE <<
" ERROR: Can't find TRKR_CLUSTER_TRUTH" << endl;
137 iter != range.second;
147 float gflavor = g4particle->
get_pid();
150 bool is_primary =
false;
164 cout <<
PHWHERE <<
" PHG4Particle ID " << gtrackID <<
" gflavor " << gflavor <<
" is_primary " << is_primary
165 <<
" gembed " << gembed << endl;
168 std::map<unsigned int, TrkrCluster* > truth_clusters =
all_truth_clusters(g4particle);
171 if(
Verbosity() > 0) std::cout <<
" Truth cluster summary for g4particle " << g4particle->
get_track_id() <<
" by layer: " << std::endl;
172 for (
auto it = truth_clusters.begin();
it != truth_clusters.end(); ++
it )
174 unsigned int layer =
it->first;
177 float gx = gclus->
getX();
178 float gy = gclus->
getY();
179 float gz = gclus->
getZ();
180 float ng4hits = gclus->
getAdc();
182 TVector3 gpos(gx, gy, gz);
183 float gr = sqrt(gx*gx+gy*gy);
184 float gphi = gpos.Phi();
185 float geta = gpos.Eta();
187 float gphisize = gclus->
getSize(1,1);
188 float gzsize = gclus->
getSize(2,2);
195 std::cout <<
PHWHERE <<
" **** truth: layer " << layer <<
" truth cluster key " << ckey <<
" ng4hits " << ng4hits << std::endl;
196 std::cout <<
" gr " << gr <<
" gx " << gx <<
" gy " << gy <<
" gz " << gz
197 <<
" gphi " << gphi <<
" geta " << geta <<
" gphisize " << gphisize <<
" gzsize " << gzsize << endl;
204 if(iter->first != ckey)
205 std::cout <<
PHWHERE <<
" ------- Problem: ckey = " << ckey<<
" returned key " << iter->first << std::endl;
212 for (
auto hitsetitr = hitsetrange.first;
213 hitsetitr != hitsetrange.second;
216 for(
auto clusIter = range.first; clusIter != range.second; ++clusIter ){
227 std::cout <<
PHWHERE <<
" copying cluster in layer " << layer <<
" from reco clusters to truth clusters " << std::endl;;
232 if(iter->first != cluskey)
233 std::cout <<
PHWHERE <<
" ------- Problem: cluskey = " << cluskey<<
" returned key " << iter->first << std::endl;
239 std::cout <<
"Final TRKR_CLUSTER_TRUTH clusters:";
240 m_clusterlist->identify();
253 std::cout <<
PHWHERE <<
" Truth clustering for particle " << particle->
get_track_id() <<
" with ng4hits " << g4hits.size() << std::endl;;
255 float ng4hits = g4hits.size();
257 return std::map<unsigned int, TrkrCluster* >();
261 std::map<unsigned int, TrkrCluster*> truth_clusters;
274 std::vector<PHG4Hit*> contributing_hits;
275 std::vector<double> contributing_hits_energy;
276 std::vector<std::vector<double>> contributing_hits_entry;
277 std::vector<std::vector<double>> contributing_hits_exit;
278 LayerClusterG4Hits(g4hits, contributing_hits, contributing_hits_energy, contributing_hits_entry, contributing_hits_exit, layer, gx, gy, gz, gt, gedep);
279 if(!(gedep > 0))
continue;
286 unsigned int side = 0;
294 unsigned int stave = 0;
295 unsigned int chip = 0;
301 unsigned int ladderzid = 0;
302 unsigned int ladderphiid = 0;
307 unsigned int tile = 0;
315 std::cout <<
PHWHERE <<
"Bad layer number: " << layer << std::endl;
341 float g4phisize = NAN;
343 G4ClusterSize(layer, contributing_hits_entry, contributing_hits_exit, g4phisize, g4zsize);
354 double clusphi = atan2(gy, gx);
361 DIM[1][1] = pow(0.5 * g4phisize, 2);
365 DIM[2][2] = pow(0.5 * g4zsize,2);
379 ROT[0][0] = cos(clusphi);
380 ROT[0][1] = -sin(clusphi);
382 ROT[1][0] = sin(clusphi);
383 ROT[1][1] = cos(clusphi);
389 TMatrixF ROT_T(3, 3);
390 ROT_T.Transpose(ROT);
392 TMatrixF COVAR_DIM(3, 3);
393 COVAR_DIM = ROT * DIM * ROT_T;
395 clus->
setSize(0, 0, COVAR_DIM[0][0]);
396 clus->
setSize(0, 1, COVAR_DIM[0][1]);
397 clus->
setSize(0, 2, COVAR_DIM[0][2]);
398 clus->
setSize(1, 0, COVAR_DIM[1][0]);
399 clus->
setSize(1, 1, COVAR_DIM[1][1]);
400 clus->
setSize(1, 2, COVAR_DIM[1][2]);
401 clus->
setSize(2, 0, COVAR_DIM[2][0]);
402 clus->
setSize(2, 1, COVAR_DIM[2][1]);
403 clus->
setSize(2, 2, COVAR_DIM[2][2]);
406 TMatrixF COVAR_ERR(3, 3);
407 COVAR_ERR = ROT * ERR * ROT_T;
409 clus->
setError(0, 0, COVAR_ERR[0][0]);
410 clus->
setError(0, 1, COVAR_ERR[0][1]);
411 clus->
setError(0, 2, COVAR_ERR[0][2]);
412 clus->
setError(1, 0, COVAR_ERR[1][0]);
413 clus->
setError(1, 1, COVAR_ERR[1][1]);
414 clus->
setError(1, 2, COVAR_ERR[1][2]);
415 clus->
setError(2, 0, COVAR_ERR[2][0]);
416 clus->
setError(2, 1, COVAR_ERR[2][1]);
417 clus->
setError(2, 2, COVAR_ERR[2][2]);
421 std::cout <<
" layer " << layer <<
" cluskey " << ckey <<
" cluster phi " << clusphi <<
" local cluster error rphi " <<
clus_err_rphi[
layer]
425 std::cout <<
" global covariance matrix:" << std::endl;
426 for(
int i1=0;i1<3;++i1)
427 for(
int i2=0;i2<3;++i2)
428 std::cout <<
" " << i1 <<
" " << i2 <<
" cov " << clus->
getError(i1,i2) << std::endl;
432 truth_clusters.insert(make_pair(layer, clus));
436 return truth_clusters;
439 void PHTruthClustering::LayerClusterG4Hits(std::set<PHG4Hit*> truth_hits, std::vector<PHG4Hit*> &contributing_hits, std::vector<double> &contributing_hits_energy, std::vector<std::vector<double>> &contributing_hits_entry, std::vector<std::vector<double>> &contributing_hits_exit,
float layer,
float &
x,
float &
y,
float &
z,
float &
t,
float &
e)
467 cout <<
" PHTruthClustering::LayerCluster hits for layer " << layer <<
" with rbin " << rbin <<
" rbout " << rbout << endl;
470 for (std::set<PHG4Hit*>::iterator iter = truth_hits.begin();
471 iter != truth_hits.end();
476 float rbegin = sqrt(this_g4hit->
get_x(0) * this_g4hit->
get_x(0) + this_g4hit->
get_y(0) * this_g4hit->
get_y(0));
477 float rend = sqrt(this_g4hit->
get_x(1) * this_g4hit->
get_x(1) + this_g4hit->
get_y(1) * this_g4hit->
get_y(1));
487 xl[0] = this_g4hit->
get_x(0);
488 yl[0] = this_g4hit->
get_y(0);
489 zl[0] = this_g4hit->
get_z(0);
490 xl[1] = this_g4hit->
get_x(1);
491 yl[1] = this_g4hit->
get_y(1);
492 zl[1] = this_g4hit->
get_z(1);
496 xl[0] = this_g4hit->
get_x(1);
497 yl[0] = this_g4hit->
get_y(1);
498 zl[0] = this_g4hit->
get_z(1);
499 xl[1] = this_g4hit->
get_x(0);
500 yl[1] = this_g4hit->
get_y(0);
501 zl[1] = this_g4hit->
get_z(0);
507 if (rbegin < rbin && rend < rbin)
509 if (rbegin > rbout && rend > rbout)
515 cout <<
" keep g4hit with rbegin " << rbegin <<
" rend " << rend
516 <<
" xbegin " << xl[0] <<
" xend " << xl[1]
517 <<
" ybegin " << yl[0] <<
" yend " << yl[1]
518 <<
" zbegin " << zl[0] <<
" zend " << zl[1]
538 xin = xl[0] + t * (xl[1] - xl[0]);
539 yin = yl[0] + t * (yl[1] - yl[0]);
540 zin = zl[0] + t * (zl[1] - zl[0]);
550 xout = xl[0] + t * (xl[1] - xl[0]);
551 yout = yl[0] + t * (yl[1] - yl[0]);
552 zout = zl[0] + t * (zl[1] - zl[0]);
556 double rin = sqrt(xin*xin + yin*yin);
557 double rout = sqrt(xout*xout + yout*yout);
560 double efrac = this_g4hit->
get_edep() * (rout - rin) / (rend - rbegin);
561 gx += (xin + xout) * 0.5 * efrac;
562 gy += (yin + yout) * 0.5 * efrac;
563 gz += (zin + zout) * 0.5 * efrac;
565 gr += (rin + rout) * 0.5 * efrac;
570 cout <<
" rin " << rin <<
" rout " << rout
571 <<
" xin " << xin <<
" xout " << xout <<
" yin " << yin <<
" yout " << yout <<
" zin " << zin <<
" zout " << zout
572 <<
" edep " << this_g4hit->
get_edep()
573 <<
" this_edep " << efrac << endl;
574 cout <<
" xavge " << (xin+xout) * 0.5 <<
" yavge " << (yin+yout) * 0.5 <<
" zavge " << (zin+zout) * 0.5 <<
" ravge " << (rin+rout) * 0.5
579 std::vector<double> entry_loc;
580 entry_loc.push_back(xin);
581 entry_loc.push_back(yin);
582 entry_loc.push_back(zin);
583 std::vector<double> exit_loc;
584 exit_loc.push_back(xout);
585 exit_loc.push_back(yout);
586 exit_loc.push_back(zout);
589 contributing_hits.push_back(this_g4hit);
590 contributing_hits_energy.push_back( this_g4hit->
get_edep() * (zout - zin) / (zl[1] - zl[0]) );
591 contributing_hits_entry.push_back(entry_loc);
592 contributing_hits_exit.push_back(exit_loc);
605 gr = (rbin + rbout) * 0.5;
610 cout <<
" weighted means: gx " << gx <<
" gy " << gy <<
" gz " << gz <<
" gr " << gr <<
" e " << gwt << endl;
617 float rentry = 999.0;
618 float xentry = 999.0;
619 float yentry = 999.0;
620 float zentry = 999.0;
621 float rexit = - 999.0;
622 float xexit = -999.0;
623 float yexit = -999.0;
624 float zexit = -999.0;
626 for(
unsigned int ientry = 0; ientry < contributing_hits_entry.size(); ++ientry)
628 float tmpx = contributing_hits_entry[ientry][0];
629 float tmpy = contributing_hits_entry[ientry][1];
630 float tmpr = sqrt(tmpx*tmpx + tmpy*tmpy);
635 xentry = contributing_hits_entry[ientry][0];
636 yentry = contributing_hits_entry[ientry][1];
637 zentry = contributing_hits_entry[ientry][2];
640 tmpx = contributing_hits_exit[ientry][0];
641 tmpy = contributing_hits_exit[ientry][1];
642 tmpr = sqrt(tmpx*tmpx + tmpy*tmpy);
647 xexit = contributing_hits_exit[ientry][0];
648 yexit = contributing_hits_exit[ientry][1];
649 zexit = contributing_hits_exit[ientry][2];
653 float geo_r = (rentry+rexit)*0.5;
654 float geo_x = (xentry+xexit)*0.5;
655 float geo_y = (yentry+yexit)*0.5;
656 float geo_z = (zentry+zexit)*0.5;
669 cout <<
" rentry " << rentry <<
" rexit " << rexit
670 <<
" xentry " << xentry <<
" xexit " << xexit <<
" yentry " << yentry <<
" yexit " << yexit <<
" zentry " << zentry <<
" zexit " << zexit << endl;
672 cout <<
" geometric means: geo_x " << geo_x <<
" geo_y " << geo_y <<
" geo_z " << geo_z <<
" geo r " << geo_r <<
" e " << gwt << endl << endl;
680 for (std::set<PHG4Hit*>::iterator iter = truth_hits.begin();
681 iter != truth_hits.end();
687 if(this_g4hit->
get_layer() != (
unsigned int) layer)
continue;
696 std::vector<double> entry_loc;
697 entry_loc.push_back(this_g4hit->
get_x(0));
698 entry_loc.push_back(this_g4hit->
get_y(0));
699 entry_loc.push_back(this_g4hit->
get_z(0));
700 std::vector<double> exit_loc;
701 exit_loc.push_back(this_g4hit->
get_x(1));
702 exit_loc.push_back(this_g4hit->
get_y(1));
703 exit_loc.push_back(this_g4hit->
get_z(1));
706 contributing_hits.push_back(this_g4hit);
707 contributing_hits_energy.push_back( this_g4hit->
get_edep() );
708 contributing_hits_entry.push_back(entry_loc);
709 contributing_hits_exit.push_back(exit_loc);
722 void PHTruthClustering::G4ClusterSize(
unsigned int layer, std::vector<std::vector<double>> contributing_hits_entry,std::vector<std::vector<double>> contributing_hits_exit,
float &g4phisize,
float &g4zsize)
727 double inner_x = NAN;
728 double inner_y = NAN;
729 double inner_z = NAN;;
732 double outer_x = NAN;
733 double outer_y = NAN;
734 double outer_z = NAN;
736 for(
unsigned int ihit=0;
ihit<contributing_hits_entry.size(); ++
ihit)
738 double rad1 = sqrt(pow(contributing_hits_entry[
ihit][0], 2) + pow(contributing_hits_entry[ihit][1], 2));
739 if(rad1 < inner_radius)
742 inner_x = contributing_hits_entry[
ihit][0];
743 inner_y = contributing_hits_entry[
ihit][1];
744 inner_z = contributing_hits_entry[
ihit][2];
747 double rad2 = sqrt(pow(contributing_hits_exit[ihit][0], 2) + pow(contributing_hits_exit[ihit][1], 2));
748 if(rad2 > outer_radius)
751 outer_x = contributing_hits_exit[
ihit][0];
752 outer_y = contributing_hits_exit[
ihit][1];
753 outer_z = contributing_hits_exit[
ihit][2];
757 double inner_phi = atan2(inner_y, inner_x);
758 double outer_phi = atan2(outer_y, outer_x);
759 double avge_z = (outer_z + inner_z) / 2.0;
766 if(radius > 28 && radius < 80)
770 double tpc_length = 211.0;
771 double drift_velocity = 8.0 / 1000.0;
775 double diffusion_trans = 0.006;
776 double phidiffusion = diffusion_trans * sqrt(tpc_length / 2. - fabs(avge_z));
778 double added_smear_trans = 0.085;
779 double gem_spread = 0.04;
781 if(outer_phi < inner_phi)
swap(outer_phi, inner_phi);
784 double g4max_phi = outer_phi + sigmas * sqrt( pow(phidiffusion, 2) + pow(added_smear_trans, 2) + pow(gem_spread, 2) ) /
radius;
785 double g4min_phi = inner_phi - sigmas * sqrt( pow(phidiffusion, 2) + pow(added_smear_trans, 2) + pow(gem_spread, 2) ) /
radius;
788 unsigned int phibinmin = layergeom->
get_phibin(g4min_phi);
789 unsigned int phibinmax = layergeom->
get_phibin(g4max_phi);
790 unsigned int phibinwidth = phibinmax - phibinmin + 1;
798 outer_z = fabs(outer_z);
799 inner_z = fabs(inner_z);
801 double diffusion_long = 0.015;
802 double zdiffusion = diffusion_long * sqrt(tpc_length / 2. - fabs(avge_z)) ;
803 double zshaping_lead = 32.0 * drift_velocity;
804 double zshaping_tail = 48.0 * drift_velocity;
805 double added_smear_long = 0.105;
808 if(outer_z < inner_z)
swap(outer_z, inner_z);
809 g4max_z = outer_z + sigmas*sqrt(pow(zdiffusion,2) + pow(added_smear_long,2) + pow(zshaping_lead, 2));
810 g4min_z = inner_z - sigmas*sqrt(pow(zdiffusion,2) + pow(added_smear_long,2) + pow(zshaping_tail, 2));
813 unsigned int binmin = layergeom->
get_zbin(g4min_z);
814 unsigned int binmax = layergeom->
get_zbin(g4max_z);
815 if(binmax < binmin)
swap(binmax, binmin);
816 unsigned int binwidth = binmax - binmin + 1;
819 g4zsize = (double) binwidth * layergeom->
get_zstep();
821 else if(radius > 5 && radius < 20)
828 double world_inner[3] = {inner_x, inner_y, inner_z};
829 TVector3 world_inner_vec = {inner_x, inner_y, inner_z};
831 int segment_z_bin, segment_phi_bin;
835 double yin = local_inner_vec[1];
836 double zin = local_inner_vec[2];
837 int strip_y_index, strip_z_index;
841 double world_outer[3] = {outer_x, outer_y, outer_z};
842 TVector3 world_outer_vec = {outer_x, outer_y, outer_z};
847 double yout = local_outer_vec[1];
848 double zout = local_outer_vec[2];
849 int strip_y_index_out, strip_z_index_out;
852 int strips =
abs(strip_y_index_out - strip_y_index) + 1;
853 int cols =
abs(strip_z_index_out - strip_z_index) + 1;
859 g4phisize = strip_width;
860 g4zsize = strip_length;
876 unsigned int stave, stave_outer;
877 unsigned int chip, chip_outer;
879 int column, column_outer;
882 double max_diffusion_radius = 25.0e-4;
883 double min_diffusion_radius = 8.0e-4;
887 TVector3 world_inner = {inner_x, inner_y, inner_z};
888 std::vector<double> world_inner_vec = { world_inner[0], world_inner[1], world_inner[2] };
892 TVector3 world_outer = {outer_x, outer_y, outer_z};
893 std::vector<double> world_outer_vec = { world_outer[0], world_outer[1], world_outer[2] };
897 double diff = max_diffusion_radius * 0.6;
898 if(local_outer[0] < local_inner[0])
900 local_outer[0] += diff;
901 local_inner[0] -= diff;
903 double diff_outer = min_diffusion_radius * 0.6;
904 if(local_outer[2] < local_inner[2])
905 diff_outer = -diff_outer;
906 local_outer[2] += diff_outer;
907 local_inner[2] -= diff_outer;
912 if(row_outer < row)
swap(row_outer, row);
913 unsigned int rows = row_outer - row + 1;
914 g4phisize = (double) rows * layergeom->
get_pixel_x();
916 if(column_outer < column)
swap(column_outer, column);
917 unsigned int columns = column_outer - column + 1;
918 g4zsize = (double) columns * layergeom->
get_pixel_z();
931 std::set<PHG4Hit*> truth_hits;
940 PHG4Hit* g4hit = g4iter->second;
943 truth_hits.insert(g4hit);
955 PHG4Hit* g4hit = g4iter->second;
958 truth_hits.insert(g4hit);
970 PHG4Hit* g4hit = g4iter->second;
973 truth_hits.insert(g4hit);
985 PHG4Hit* g4hit = g4iter->second;
988 truth_hits.insert(g4hit);
1006 float A = (x[1] - x[0]) * (x[1] - x[0]) + (y[1] - y[0]) * (y[1] - y[0]);
1007 float B = 2.0 * x[0] * (x[1] - x[0]) + 2.0 * y[0] * (y[1] - y[0]);
1008 float C = x[0] * x[0] + y[0] * y[0] - radius *
radius;
1009 float tup = (-B + sqrt(B * B - 4.0 * A * C)) / (2.0 * A);
1010 float tdn = (-B - sqrt(B * B - 4.0 * A * C)) / (2.0 * A);
1014 if (tdn >= -0.0
e-4 && tdn <= 1.0004)
1016 else if (tup >= -0.0
e-4 && tup <= 1.0004)
1020 cout <<
PHWHERE <<
" **** Oops! No valid solution for tup or tdn, tdn = " << tdn <<
" tup = " << tup << endl;
1021 cout <<
" radius " << radius <<
" rbegin " << sqrt(x[0] * x[0] + y[0] * y[0]) <<
" rend " << sqrt(x[1] * x[1] + y[1] * y[1]) << endl;
1022 cout <<
" x0 " << x[0] <<
" x1 " << x[1] << endl;
1023 cout <<
" y0 " << y[0] <<
" y1 " << y[1] << endl;
1024 cout <<
" z0 " << z[0] <<
" z1 " << z[1] << endl;
1025 cout <<
" A " << A <<
" B " << B <<
" C " << C << endl;
1034 double phi = atan2(y, x);
1035 unsigned int sector = (
int) (12.0 * (phi +
M_PI) / (2.0 *
M_PI) );
1044 double Ne_dEdx = 1.56;
1045 double CF4_dEdx = 7.00;
1046 double Ne_NTotal = 43;
1047 double CF4_NTotal = 100;
1048 double Tpc_NTot = 0.5*Ne_NTotal + 0.5*CF4_NTotal;
1049 double Tpc_dEdx = 0.5*Ne_dEdx + 0.5*CF4_dEdx;
1050 double Tpc_ElectronsPerKeV = Tpc_NTot / Tpc_dEdx;
1051 double electrons_per_gev = Tpc_ElectronsPerKeV * 1
e6;
1053 double gem_amplification = 1400;
1054 double input_electrons = gedep * electrons_per_gev * gem_amplification;
1057 double ChargeToPeakVolts = 20;
1058 double ADCSignalConversionGain = ChargeToPeakVolts * 1.60e-04 * 2.4;
1059 double adc_input_voltage = input_electrons * ADCSignalConversionGain;
1060 unsigned int adc_output = (
unsigned int) (adc_input_voltage * 1024.0 / 2200.0);
1061 if (adc_output > 1023) adc_output = 1023;
1068 _g4truth_container = findNode::getClass<PHG4TruthInfoContainer>(topNode,
"G4TruthInfo");
1071 cerr <<
PHWHERE <<
" ERROR: Can't find node G4TruthInfo" << endl;
1075 _g4hits_mms = findNode::getClass<PHG4HitContainer>(topNode,
"G4HIT_MICROMEGAS");
1076 _g4hits_svtx = findNode::getClass<PHG4HitContainer>(topNode,
"G4HIT_TPC");
1077 _g4hits_tracker = findNode::getClass<PHG4HitContainer>(topNode,
"G4HIT_INTT");
1078 _g4hits_maps = findNode::getClass<PHG4HitContainer>(topNode,
"G4HIT_MVTX");
1080 _mms_geom_container = findNode::getClass<PHG4CylinderGeomContainer>(topNode,
"CYLINDERGEOM_MICROMEGAS_FULL");
1081 _tpc_geom_container = findNode::getClass<PHG4CylinderCellGeomContainer>(topNode,
"CYLINDERCELLGEOM_SVTX");
1082 _intt_geom_container = findNode::getClass<PHG4CylinderGeomContainer>(topNode,
"CYLINDERGEOM_INTT");
1083 _mvtx_geom_container = findNode::getClass<PHG4CylinderGeomContainer>(topNode,
"CYLINDERGEOM_MVTX");
1091 cout <<
PHWHERE <<
"DST Node missing, doing nothing." << endl;
1095 auto trkrclusters = findNode::getClass<TrkrClusterContainer>(dstNode,
"TRKR_CLUSTER_TRUTH");
1104 dstNode->addNode(DetNode);
1110 DetNode->
addNode(TrkrClusterContainerNode);
1113 _reco_cluster_map = findNode::getClass<TrkrClusterContainer>(topNode,
"TRKR_CLUSTER");
1116 cerr <<
PHWHERE <<
" ERROR: Can't find node TRKR_CLUSTER" << endl;