PHG4VtxPoint* SvtxTruthEval::get_vertex(PHG4Particle* particle) {
PHG4TruthInfoContainer* truthinfo = findNode::getClass<PHG4TruthInfoContainer>(_topNode,"G4TruthInfo");
if (!truthinfo) {
cerr << PHWHERE << " ERROR: Can't find G4TruthInfo" << endl;
exit(-1);
}
return truthinfo->GetVtx( particle->get_vtx_id() );
}
int
RICHEvaluator::process_event(PHCompositeNode *topNode)
{
_ievent ++;
/* Get truth information */
PHG4TruthInfoContainer* truthinfo = findNode::getClass<PHG4TruthInfoContainer>(topNode, "G4TruthInfo");
/* Get all photon hits in RICH for this event */
PHG4HitContainer* richhits = findNode::getClass<PHG4HitContainer>(topNode,_richhits_name);
/* Get track collection with all tracks in this event */
SvtxTrackMap* trackmap = findNode::getClass<SvtxTrackMap>(topNode,_trackmap_name);
/* Check if collections found */
if (!truthinfo) {
cout << PHWHERE << "PHG4TruthInfoContainer not found on node tree" << endl;
return Fun4AllReturnCodes::ABORTEVENT;
}
if (!richhits) {
cout << PHWHERE << "PHG4HitContainer not found on node tree" << endl;
return Fun4AllReturnCodes::ABORTEVENT;
}
if (!trackmap) {
cout << PHWHERE << "SvtxTrackMap node not found on node tree" << endl;
return Fun4AllReturnCodes::ABORTEVENT;
}
/* Loop over tracks */
for (SvtxTrackMap::ConstIter track_itr = trackmap->begin(); track_itr != trackmap->end(); track_itr++)
{
bool use_reconstructed_momentum = false;
bool use_truth_momentum = false;
bool use_emission_momentum = true;
bool use_reconstructed_point = false;
bool use_approximate_point = true;
/* Store angles to get RMS value */
TH1F *ch_ang = new TH1F("","",1000,0.0,1.0);
SvtxTrack* track_j = dynamic_cast<SvtxTrack*>(track_itr->second);
/* Check if track_j is a null pointer. */
if (track_j == NULL)
continue;
/* Fill momv object which is the normalized momentum vector of the track in the RICH (i.e. its direction) */
double momv[3] = {0.,0.,0.};
if (use_reconstructed_momentum) {
/* 'Continue' with next track if RICH projection not found for this track */
if ( ! _trackproj->get_projected_momentum( track_j, momv, TrackProjectorPid::SPHERE, _radius ) )
{
cout << "RICH track projection momentum NOT FOUND; next iteration" << endl;
continue;
}
}
if (use_truth_momentum) {
/* Fill with truth momentum instead of reco */
if ( ! _acquire->get_true_momentum( truthinfo, track_j, momv) )
{
cout << "No truth momentum found for track; next iteration" << endl;
continue;
}
}
if (use_emission_momentum) {
/* Fill with vector constructed from emission points (from truth) */
if ( ! _acquire->get_emission_momentum( truthinfo, richhits, track_j, momv) )
{
cout << "No truth momentum from emission points found for track; next iteration" << endl;
continue;
}
}
double momv_norm = sqrt( momv[0]*momv[0] + momv[1]*momv[1] + momv[2]*momv[2] );
momv[0] /= momv_norm;
momv[1] /= momv_norm;
momv[2] /= momv_norm;
/* Get mean emission point from track in RICH */
double m_emi[3] = {0.,0.,0.};
if (use_reconstructed_point) {
/* 'Continue' with next track if RICH projection not found for this track */
if ( ! _trackproj->get_projected_position( track_j, m_emi, TrackProjectorPid::SPHERE, _radius ) )
{
cout << "RICH track projection position NOT FOUND; next iteration" << endl;
continue;
}
}
if (use_approximate_point) {
m_emi[0] = ((_radius)/momv[2])*momv[0];
m_emi[1] = ((_radius)/momv[2])*momv[1];
m_emi[2] = ((_radius)/momv[2])*momv[2];
}
/* 'Continue' with next track if track doesn't pass through RICH */
if ( ! _trackproj->is_in_RICH( momv ) )
continue;
/* Calculate truth emission angle and truth mass */
if (truthinfo)
{
_theta_true = calculate_true_emission_angle( truthinfo , track_j , _refractive_index );
}
/* Loop over all G4Hits in container (i.e. RICH photons in event) */
PHG4HitContainer::ConstRange rich_hits_begin_end = richhits->getHits();
PHG4HitContainer::ConstIterator rich_hits_iter;
for (rich_hits_iter = rich_hits_begin_end.first; rich_hits_iter != rich_hits_begin_end.second; ++rich_hits_iter)
{
PHG4Hit *hit_i = rich_hits_iter->second;
PHG4Particle* particle = NULL;
PHG4Particle* parent = NULL;
PHG4VtxPoint* vertex = NULL;
if ( truthinfo )
{
particle = truthinfo->GetParticle( hit_i->get_trkid() );
parent = truthinfo->GetParticle( particle->get_parent_id() );
vertex = truthinfo->GetVtx( particle->get_vtx_id() );
}
_hit_x0 = hit_i->get_x(0);
_hit_y0 = hit_i->get_y(0);
_hit_z0 = hit_i->get_z(0);
_emi_x = vertex->get_x();
_emi_y = vertex->get_y();
_emi_z = vertex->get_z();
_track_px = particle->get_px();
_track_py = particle->get_py();
_track_pz = particle->get_pz();
_mtrack_px = parent->get_px();
_mtrack_py = parent->get_py();
_mtrack_pz = parent->get_pz();
_mtrack_ptot = sqrt( _mtrack_px*_mtrack_px + _mtrack_py*_mtrack_py + _mtrack_pz*_mtrack_pz );
_track_e = particle->get_e();
_mtrack_e = parent->get_e();
_edep = hit_i->get_edep();
_bankid = 0;
_volumeid = hit_i->get_detid();
_hitid = hit_i->get_hit_id();
_pid = particle->get_pid();
_mpid = parent->get_pid();
_trackid = particle->get_track_id();
_mtrackid = parent->get_track_id();
_otrackid = track_j->get_id();
/* Set reconstructed emission angle and reconstructed mass for output tree */
_theta_reco = _acquire->calculate_emission_angle( m_emi, momv, hit_i );
ch_ang->Fill(_theta_reco);
/* Fill tree */
_tree_rich->Fill();
} // END loop over photons
_theta_rms = ch_ang->GetRMS();
_theta_mean = ch_ang->GetMean();
/* Fill condensed tree after every track */
_tree_rich_small->Fill();
} // END loop over tracks
return 0;
}
int MomentumEvaluator::process_event( PHCompositeNode *topNode )
{
PHG4TruthInfoContainer* truthinfo = findNode::getClass<PHG4TruthInfoContainer>(topNode,"G4TruthInfo");
PHG4HitContainer* g4hits = findNode::getClass<PHG4HitContainer>(topNode,"G4HIT_SVTX");
if(g4hits == nullptr){cout<<"can't find PHG4HitContainer"<<endl;exit(1);}
PHG4HitContainer::ConstRange g4range = g4hits->getHits();
// set<int> trkids;
map<int, pair<unsigned int,unsigned int> > trkids;
for( PHG4HitContainer::ConstIterator iter = g4range.first; iter != g4range.second; ++iter )
{
PHG4Hit* hit = iter->second;
int layer = hit->get_layer();
float length = outer_z_length;
if(((unsigned int)layer)<n_inner_layers){length=inner_z_length;}
if(fabs(hit->get_z(0))>length){continue;}
int trk_id = hit->get_trkid();
if(trkids.find(trk_id) == trkids.end())
{
trkids[trk_id].first = 0;
trkids[trk_id].second = 0;
}
if( hit->get_layer() < 32 )
{
trkids[trk_id].first = (trkids[trk_id].first | (1<<(hit->get_layer())));
}
else
{
trkids[trk_id].second = (trkids[trk_id].second | (1<<(hit->get_layer()-32)));
}
// cout<<"trk_id = "<<trk_id<<endl;
// cout<<"layer = "<<hit->get_layer()<<endl;
// cout<<"nlayer = "<<__builtin_popcount(trkids[trk_id].first)+__builtin_popcount(trkids[trk_id].second)<<endl<<endl;
// trkids.insert(trk_id);
}
SvtxTrackMap* trackmap = findNode::getClass<SvtxTrackMap>(topNode,"SvtxTrackMap");
PHG4VtxPoint *gvertex = truthinfo->GetPrimaryVtx( truthinfo->GetPrimaryVertexIndex() );
float gvx = gvertex->get_x();
float gvy = gvertex->get_y();
float gvz = gvertex->get_z();
RecursiveMomentumContainer true_sorted( -20., 20., -20., 20., -20., 20., 10 );
// PHG4TruthInfoContainer::Map primarymap = truthinfo->GetPrimaryMap();
PHG4TruthInfoContainer::Map primarymap = truthinfo->GetMap();
for(PHG4TruthInfoContainer::Iterator iter = primarymap.begin();iter != primarymap.end();++iter)
{
PHG4Particle *particle = iter->second;
float vx = truthinfo->GetVtx(particle->get_vtx_id())->get_x();
float vy = truthinfo->GetVtx(particle->get_vtx_id())->get_y();
float vz = truthinfo->GetVtx(particle->get_vtx_id())->get_z();
TrivialTrack track( particle->get_px(), particle->get_py(), particle->get_pz(), vx-gvx, vy-gvy, vz-gvz );
if( ( (track.px * track.px) + (track.py * track.py) ) < (0.1*0.1) ){continue;}
if( trkids.find(particle->get_track_id()) == trkids.end() )
{
continue;
}
// cout<<"trk, nhits = "<<particle->get_track_id()<<" "<<__builtin_popcount(trkids[particle->get_track_id()].first)+__builtin_popcount(trkids[particle->get_track_id()].second)<<endl;
if( __builtin_popcount(trkids[particle->get_track_id()].first)+__builtin_popcount(trkids[particle->get_track_id()].second) < (int)n_required_layers )
{
continue;
}
true_sorted.insert( track );
}
RecursiveMomentumContainer reco_sorted( -20., 20., -20., 20., -20., 20., 10 );
for(SvtxTrackMap::Iter iter = trackmap->begin();iter != trackmap->end();++iter)
{
SvtxTrack* track = iter->second;
TrivialTrack ttrack( track->get_px(), track->get_py(), track->get_pz(), track->get_x()-gvx, track->get_y()-gvy, track->get_z()-gvz, track->get_quality() );
reco_sorted.insert(ttrack);
}
TrivialTrack* t_track = true_sorted.begin();
vector<TrivialTrack*> pointer_list;
while(t_track != nullptr)
{
pointer_list.clear();
float pt = sqrt((t_track->px * t_track->px) + (t_track->py * t_track->py));
float pt_diff = pt*pt_search_scale;
float px_lo = t_track->px - pt_diff;
float px_hi = t_track->px + pt_diff;
float py_lo = t_track->py - pt_diff;
float py_hi = t_track->py + pt_diff;
float pz_diff = fabs( t_track->pz )*pz_search_scale;
float pz_lo = t_track->pz - pz_diff;
float pz_hi = t_track->pz + pz_diff;
reco_sorted.append_list( pointer_list, px_lo,px_hi, py_lo,py_hi, pz_lo,pz_hi );
if(pointer_list.size() > 0)
{
float mom_true = sqrt(pt*pt + (t_track->pz)*(t_track->pz));
float best_ind = 0;
float mom_reco = sqrt( (pointer_list[0]->px)*(pointer_list[0]->px) + (pointer_list[0]->py)*(pointer_list[0]->py) + (pointer_list[0]->pz)*(pointer_list[0]->pz) );
float best_mom = mom_reco;
for(unsigned int i=1;i<pointer_list.size();++i)
{
mom_reco = sqrt( (pointer_list[i]->px)*(pointer_list[i]->px) + (pointer_list[i]->py)*(pointer_list[i]->py) + (pointer_list[i]->pz)*(pointer_list[i]->pz) );
if( fabs( mom_true - mom_reco ) < fabs( mom_true - best_mom ) )
{
best_mom = mom_reco;
best_ind = i;
}
}
float ntp_data[14] = { (float) event_counter, t_track->px, t_track->py, t_track->pz, t_track->dcax, t_track->dcay, t_track->dcaz, pointer_list[best_ind]->px, pointer_list[best_ind]->py, pointer_list[best_ind]->pz, pointer_list[best_ind]->dcax, pointer_list[best_ind]->dcay, pointer_list[best_ind]->dcaz, pointer_list[best_ind]->quality };
ntp_true->Fill(ntp_data);
}
else
{
float ntp_data[14] = { (float) event_counter, t_track->px, t_track->py, t_track->pz, t_track->dcax, t_track->dcay, t_track->dcaz, -9999.,-9999.,-9999.,-9999.,-9999.,-9999., -9999. };
ntp_true->Fill(ntp_data);
}
t_track = true_sorted.next();
}
TrivialTrack* r_track = reco_sorted.begin();
while(r_track != nullptr)
{
pointer_list.clear();
float pt = sqrt((r_track->px * r_track->px) + (r_track->py * r_track->py));
float pt_diff = pt*pt_search_scale;
float px_lo = r_track->px - pt_diff;
float px_hi = r_track->px + pt_diff;
float py_lo = r_track->py - pt_diff;
float py_hi = r_track->py + pt_diff;
float pz_diff = fabs( r_track->pz )*pz_search_scale;
float pz_lo = r_track->pz - pz_diff;
float pz_hi = r_track->pz + pz_diff;
true_sorted.append_list( pointer_list, px_lo,px_hi, py_lo,py_hi, pz_lo,pz_hi );
if(pointer_list.size() > 0)
{
float mom_reco = sqrt(pt*pt + (r_track->pz)*(r_track->pz));
float best_ind = 0;
float mom_true = sqrt( (pointer_list[0]->px)*(pointer_list[0]->px) + (pointer_list[0]->py)*(pointer_list[0]->py) + (pointer_list[0]->pz)*(pointer_list[0]->pz) );
float best_mom = mom_true;
for(unsigned int i=1;i<pointer_list.size();++i)
{
mom_true = sqrt( (pointer_list[i]->px)*(pointer_list[i]->px) + (pointer_list[i]->py)*(pointer_list[i]->py) + (pointer_list[i]->pz)*(pointer_list[i]->pz) );
if( fabs( mom_reco - mom_true ) < fabs( mom_reco - best_mom ) )
{
best_mom = mom_true;
best_ind = i;
}
}
float ntp_data[14] = { (float) event_counter, r_track->px, r_track->py, r_track->pz, r_track->dcax, r_track->dcay, r_track->dcaz, pointer_list[best_ind]->px, pointer_list[best_ind]->py, pointer_list[best_ind]->pz, pointer_list[best_ind]->dcax, pointer_list[best_ind]->dcay, pointer_list[best_ind]->dcaz, r_track->quality };
ntp_reco->Fill(ntp_data);
}
else
{
float ntp_data[14] = { (float) event_counter, r_track->px, r_track->py, r_track->pz, r_track->dcax, r_track->dcay, r_track->dcaz, -9999.,-9999.,-9999.,-9999.,-9999.,-9999., r_track->quality };
ntp_reco->Fill(ntp_data);
}
r_track = reco_sorted.next();
}
event_counter += 1;
return Fun4AllReturnCodes::EVENT_OK;
}
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;
}
int
Proto2ShowerCalib::process_event(PHCompositeNode *topNode)
{
if (verbosity > 2)
cout << "Proto2ShowerCalib::process_event() entered" << endl;
// init eval objects
_eval_run.reset();
_eval_3x3_raw.reset();
_eval_5x5_raw.reset();
_eval_3x3_prod.reset();
_eval_5x5_prod.reset();
_eval_3x3_temp.reset();
_eval_5x5_temp.reset();
_eval_3x3_recalib.reset();
_eval_5x5_recalib.reset();
Fun4AllHistoManager *hm = get_HistoManager();
assert(hm);
if (not _is_sim)
{
PdbParameterMap *info = findNode::getClass<PdbParameterMap>(topNode,
"RUN_INFO");
assert(info);
PHG4Parameters run_info_copy("RunInfo");
run_info_copy.FillFrom(info);
_eval_run.beam_mom = run_info_copy.get_double_param("beam_MTNRG_GeV");
TH1F * hBeam_Mom = dynamic_cast<TH1F *>(hm->getHisto("hBeam_Mom"));
assert(hBeam_Mom);
hBeam_Mom->Fill(_eval_run.beam_mom);
}
EventHeader* eventheader = findNode::getClass<EventHeader>(topNode,
"EventHeader");
if (not _is_sim)
{
assert(eventheader);
_eval_run.run = eventheader->get_RunNumber();
if (verbosity > 4)
cout << __PRETTY_FUNCTION__ << _eval_run.run << endl;
_eval_run.event = eventheader->get_EvtSequence();
}
if (_is_sim)
{
PHG4TruthInfoContainer* truthInfoList = findNode::getClass<
PHG4TruthInfoContainer>(topNode, "G4TruthInfo");
assert(truthInfoList);
_eval_run.run = -1;
const PHG4Particle * p = truthInfoList->GetPrimaryParticleRange().first->second;
assert(p);
const PHG4VtxPoint * v = truthInfoList->GetVtx(p->get_vtx_id());
assert(v);
_eval_run.beam_mom = sqrt(
p->get_px() * p->get_px() + p->get_py() * p->get_py()
+ p->get_pz() * p->get_pz());
_eval_run.truth_y = v->get_y();
_eval_run.truth_z = v->get_z();
}
// normalization
TH1F * hNormalization = dynamic_cast<TH1F *>(hm->getHisto("hNormalization"));
assert(hNormalization);
hNormalization->Fill("ALL", 1);
RawTowerContainer* TOWER_RAW_CEMC = findNode::getClass<RawTowerContainer>(
topNode, _is_sim ? "TOWER_RAW_LG_CEMC" : "TOWER_RAW_CEMC");
assert(TOWER_RAW_CEMC);
RawTowerContainer* TOWER_CALIB_CEMC = findNode::getClass<RawTowerContainer>(
topNode, _is_sim ? "TOWER_CALIB_LG_CEMC" : "TOWER_CALIB_CEMC");
assert(TOWER_CALIB_CEMC);
// other nodes
RawTowerContainer* TOWER_CALIB_TRIGGER_VETO = findNode::getClass<
RawTowerContainer>(topNode, "TOWER_CALIB_TRIGGER_VETO");
if (not _is_sim)
{
assert(TOWER_CALIB_TRIGGER_VETO);
}
RawTowerContainer* TOWER_CALIB_HODO_HORIZONTAL = findNode::getClass<
RawTowerContainer>(topNode, "TOWER_CALIB_HODO_HORIZONTAL");
if (not _is_sim)
{
assert(TOWER_CALIB_HODO_HORIZONTAL);
}
RawTowerContainer* TOWER_CALIB_HODO_VERTICAL = findNode::getClass<
RawTowerContainer>(topNode, "TOWER_CALIB_HODO_VERTICAL");
if (not _is_sim)
{
assert(TOWER_CALIB_HODO_VERTICAL);
}
RawTowerContainer* TOWER_TEMPERATURE_EMCAL = findNode::getClass<
RawTowerContainer>(topNode, "TOWER_TEMPERATURE_EMCAL");
if (not _is_sim)
{
assert(TOWER_TEMPERATURE_EMCAL);
}
RawTowerContainer* TOWER_CALIB_C1 = findNode::getClass<RawTowerContainer>(
topNode, "TOWER_CALIB_C1");
if (not _is_sim)
{
assert(TOWER_CALIB_C1);
}
RawTowerContainer* TOWER_CALIB_C2 = findNode::getClass<RawTowerContainer>(
topNode, "TOWER_CALIB_C2");
if (not _is_sim)
{
assert(TOWER_CALIB_C2);
}
// Cherenkov
bool cherekov_e = false;
if (not _is_sim)
{
RawTower * t_c2_in = NULL;
RawTower * t_c2_out = NULL;
assert(eventheader);
if (eventheader->get_RunNumber() >= 2105)
{
t_c2_in = TOWER_CALIB_C2->getTower(10);
t_c2_out = TOWER_CALIB_C2->getTower(11);
}
else
{
t_c2_in = TOWER_CALIB_C2->getTower(0);
t_c2_out = TOWER_CALIB_C2->getTower(1);
}
assert(t_c2_in);
assert(t_c2_out);
const double c2_in = t_c2_in->get_energy();
const double c2_out = t_c2_out->get_energy();
const double c1 = TOWER_CALIB_C1->getTower(0)->get_energy();
_eval_run.C2_sum = c2_in + c2_out;
cherekov_e = (_eval_run.C2_sum) > 100;
hNormalization->Fill("C2-e", cherekov_e);
TH2F * hCheck_Cherenkov = dynamic_cast<TH2F *>(hm->getHisto(
"hCheck_Cherenkov"));
assert(hCheck_Cherenkov);
hCheck_Cherenkov->Fill(c1, "C1", 1);
hCheck_Cherenkov->Fill(c2_in, "C2 in", 1);
hCheck_Cherenkov->Fill(c2_out, "C2 out", 1);
hCheck_Cherenkov->Fill(c2_in + c2_out, "C2 sum", 1);
}
// veto
TH1F * hCheck_Veto = dynamic_cast<TH1F *>(hm->getHisto("hCheck_Veto"));
assert(hCheck_Veto);
bool trigger_veto_pass = true;
if (not _is_sim)
{
auto range = TOWER_CALIB_TRIGGER_VETO->getTowers();
for (auto it = range.first; it != range.second; ++it)
{
RawTower* tower = it->second;
assert(tower);
hCheck_Veto->Fill(tower->get_energy());
if (abs(tower->get_energy()) > 15)
trigger_veto_pass = false;
}
}
hNormalization->Fill("trigger_veto_pass", trigger_veto_pass);
_eval_run.trigger_veto_pass = trigger_veto_pass;
// hodoscope
TH1F * hCheck_Hodo_H = dynamic_cast<TH1F *>(hm->getHisto("hCheck_Hodo_H"));
assert(hCheck_Hodo_H);
int hodo_h_count = 0;
if (not _is_sim)
{
auto range = TOWER_CALIB_HODO_HORIZONTAL->getTowers();
for (auto it = range.first; it != range.second; ++it)
{
RawTower* tower = it->second;
assert(tower);
hCheck_Hodo_H->Fill(tower->get_energy());
if (abs(tower->get_energy()) > 30)
{
hodo_h_count++;
_eval_run.hodo_h = tower->get_id();
}
}
}
const bool valid_hodo_h = hodo_h_count == 1;
hNormalization->Fill("valid_hodo_h", valid_hodo_h);
_eval_run.valid_hodo_h = valid_hodo_h;
TH1F * hCheck_Hodo_V = dynamic_cast<TH1F *>(hm->getHisto("hCheck_Hodo_V"));
assert(hCheck_Hodo_V);
int hodo_v_count = 0;
if (not _is_sim)
{
auto range = TOWER_CALIB_HODO_VERTICAL->getTowers();
for (auto it = range.first; it != range.second; ++it)
{
RawTower* tower = it->second;
assert(tower);
hCheck_Hodo_V->Fill(tower->get_energy());
if (abs(tower->get_energy()) > 30)
{
hodo_v_count++;
_eval_run.hodo_v = tower->get_id();
}
}
}
const bool valid_hodo_v = hodo_v_count == 1;
_eval_run.valid_hodo_v = valid_hodo_v;
hNormalization->Fill("valid_hodo_v", valid_hodo_v);
const bool good_e = (valid_hodo_v and valid_hodo_h and cherekov_e
and trigger_veto_pass) and (not _is_sim);
hNormalization->Fill("good_e", good_e);
// simple clustering
pair<int, int> max_3x3 = find_max(TOWER_CALIB_CEMC, 3);
pair<int, int> max_5x5 = find_max(TOWER_CALIB_CEMC, 5);
_eval_3x3_raw.max_col = max_3x3.first;
_eval_3x3_raw.max_row = max_3x3.second;
_eval_3x3_prod.max_col = max_3x3.first;
_eval_3x3_prod.max_row = max_3x3.second;
_eval_3x3_temp.max_col = max_3x3.first;
_eval_3x3_temp.max_row = max_3x3.second;
_eval_3x3_recalib.max_col = max_3x3.first;
_eval_3x3_recalib.max_row = max_3x3.second;
_eval_5x5_raw.max_col = max_5x5.first;
_eval_5x5_raw.max_row = max_5x5.second;
_eval_5x5_prod.max_col = max_5x5.first;
_eval_5x5_prod.max_row = max_5x5.second;
_eval_5x5_temp.max_col = max_5x5.first;
_eval_5x5_temp.max_row = max_5x5.second;
_eval_5x5_recalib.max_col = max_5x5.first;
_eval_5x5_recalib.max_row = max_5x5.second;
// tower
bool good_temp = true;
double sum_energy_calib = 0;
double sum_energy_T = 0;
TH1F * hTemperature = dynamic_cast<TH1F *>(hm->getHisto("hTemperature"));
assert(hTemperature);
stringstream sdata;
if (good_e)
sdata << abs(_eval_run.beam_mom) << "\t";
// tower temperature and recalibration
{
auto range = TOWER_CALIB_CEMC->getTowers();
for (auto it = range.first; it != range.second; ++it)
{
RawTowerDefs::keytype key = it->first;
RawTower* tower = it->second;
assert(tower);
const int col = tower->get_bineta();
const int row = tower->get_binphi();
if (col < 0 or col >= 8)
continue;
if (row < 0 or row >= 8)
continue;
const double energy_calib = tower->get_energy();
sum_energy_calib += energy_calib;
RawTower* tower_raw = TOWER_RAW_CEMC->getTower(key);
assert(tower_raw);
double energy_T = 0;
if (not _is_sim)
{
RawTower_Temperature * temp_t =
dynamic_cast<RawTower_Temperature *>(TOWER_TEMPERATURE_EMCAL->getTower(
tower->get_row(), tower->get_column())); // note swap of col/row in temperature storage
assert(temp_t);
const double T = temp_t->get_temperature_from_time(
eventheader->get_TimeStamp());
hTemperature->Fill(T);
if (T < 25 or T > 35)
good_temp = false;
energy_T = TemperatureCorrection::Apply(energy_calib, T);
}
// recalibration
assert(
_recalib_const.find(make_pair(col, row)) != _recalib_const.end());
const double energy_recalib = energy_T
* _recalib_const[make_pair(col, row)];
// energy sums
sum_energy_T += energy_T;
// calibration file
// sdata << tower->get_energy() << "\t";
// calibration file - only output 5x5 towers
if (col >= max_5x5.first - 2 and col <= max_5x5.first + 2
and row >= max_5x5.second - 2 and row <= max_5x5.second + 2)
{
sdata << tower->get_energy() << "\t";
}
else
{
sdata << 0 << "\t";
}
// cluster 3x3
if (col >= max_3x3.first - 1 and col <= max_3x3.first + 1)
if (row >= max_3x3.second - 1 and row <= max_3x3.second + 1)
{
// in cluster
_eval_3x3_raw.average_col += abs(tower_raw->get_energy()) * col;
_eval_3x3_raw.average_row += abs(tower_raw->get_energy()) * row;
_eval_3x3_raw.sum_E += abs(tower_raw->get_energy());
_eval_3x3_prod.average_col += energy_calib * col;
_eval_3x3_prod.average_row += energy_calib * row;
_eval_3x3_prod.sum_E += energy_calib;
_eval_3x3_temp.average_col += energy_T * col;
_eval_3x3_temp.average_row += energy_T * row;
_eval_3x3_temp.sum_E += energy_T;
_eval_3x3_recalib.average_col += energy_recalib * col;
_eval_3x3_recalib.average_row += energy_recalib * row;
_eval_3x3_recalib.sum_E += energy_recalib;
}
// cluster 5x5
if (col >= max_5x5.first - 2 and col <= max_5x5.first + 2)
if (row >= max_5x5.second - 2 and row <= max_5x5.second + 2)
{
// in cluster
_eval_5x5_raw.average_col += abs(tower_raw->get_energy()) * col;
_eval_5x5_raw.average_row += abs(tower_raw->get_energy()) * row;
_eval_5x5_raw.sum_E += abs(tower_raw->get_energy());
_eval_5x5_prod.average_col += energy_calib * col;
_eval_5x5_prod.average_row += energy_calib * row;
_eval_5x5_prod.sum_E += energy_calib;
_eval_5x5_temp.average_col += energy_T * col;
_eval_5x5_temp.average_row += energy_T * row;
_eval_5x5_temp.sum_E += energy_T;
_eval_5x5_recalib.average_col += energy_recalib * col;
_eval_5x5_recalib.average_row += energy_recalib * row;
_eval_5x5_recalib.sum_E += energy_recalib;
}
}
}
_eval_3x3_raw.reweight_clus_pol();
_eval_5x5_raw.reweight_clus_pol();
_eval_3x3_prod.reweight_clus_pol();
_eval_5x5_prod.reweight_clus_pol();
_eval_3x3_temp.reweight_clus_pol();
_eval_5x5_temp.reweight_clus_pol();
_eval_3x3_recalib.reweight_clus_pol();
_eval_5x5_recalib.reweight_clus_pol();
const double EoP = sum_energy_T / abs(_eval_run.beam_mom);
hNormalization->Fill("good_temp", good_temp);
bool good_data = good_e and good_temp;
hNormalization->Fill("good_data", good_data);
_eval_run.good_temp = good_temp;
_eval_run.good_e = good_e;
_eval_run.good_data = good_data;
_eval_run.sum_energy_T = sum_energy_T;
_eval_run.EoP = EoP;
// E/p
if (good_data)
{
if (verbosity >= 3)
cout << __PRETTY_FUNCTION__ << " sum_energy_calib = "
<< sum_energy_calib << " sum_energy_T = " << sum_energy_T
<< " _eval_run.beam_mom = " << _eval_run.beam_mom << endl;
TH2F * hEoP = dynamic_cast<TH2F *>(hm->getHisto("hEoP"));
assert(hEoP);
hEoP->Fill(EoP, abs(_eval_run.beam_mom));
}
// calibration file
if (good_data and abs(_eval_run.beam_mom) >= 4
and abs(_eval_run.beam_mom) <= 8)
{
assert(fdata.is_open());
fdata << sdata.str();
fdata << endl;
}
TTree * T = dynamic_cast<TTree *>(hm->getHisto("T"));
assert(T);
T->Fill();
return Fun4AllReturnCodes::EVENT_OK;
}
