std::vector<Jet*> TowerJetInput::get_input(PHCompositeNode *topNode) {
if (_verbosity > 0) cout << "TowerJetInput::process_event -- entered" << endl;
GlobalVertexMap* vertexmap = findNode::getClass<GlobalVertexMap>(topNode,"GlobalVertexMap");
if (!vertexmap) {
cout <<"TowerJetInput::get_input - Fatal Error - GlobalVertexMap node is missing. Please turn on the do_global flag in the main macro in order to reconstruct the global vertex."<<endl;
assert(vertexmap); // force quit
return std::vector<Jet*>();
}
RawTowerContainer *towers = NULL;
RawTowerGeomContainer *geom = NULL;
if (_input == Jet::CEMC_TOWER) {
towers = findNode::getClass<RawTowerContainer>(topNode,"TOWER_CALIB_CEMC");
geom = findNode::getClass<RawTowerGeomContainer>(topNode,"TOWERGEOM_CEMC");
if (!towers||!geom) {
return std::vector<Jet*>();
}
} else if (_input == Jet::HCALIN_TOWER) {
towers = findNode::getClass<RawTowerContainer>(topNode,"TOWER_CALIB_HCALIN");
geom = findNode::getClass<RawTowerGeomContainer>(topNode,"TOWERGEOM_HCALIN");
if (!towers||!geom) {
return std::vector<Jet*>();
}
} else if (_input == Jet::HCALOUT_TOWER) {
towers = findNode::getClass<RawTowerContainer>(topNode,"TOWER_CALIB_HCALOUT");
geom = findNode::getClass<RawTowerGeomContainer>(topNode,"TOWERGEOM_HCALOUT");
if (!towers||!geom) {
return std::vector<Jet*>();
}
} else if (_input == Jet::FEMC_TOWER) {
towers = findNode::getClass<RawTowerContainer>(topNode,"TOWER_CALIB_FEMC");
geom = findNode::getClass<RawTowerGeomContainer>(topNode,"TOWERGEOM_FEMC");
if (!towers||!geom) {
return std::vector<Jet*>();
}
} else if (_input == Jet::FHCAL_TOWER) {
towers = findNode::getClass<RawTowerContainer>(topNode,"TOWER_CALIB_FHCAL");
geom = findNode::getClass<RawTowerGeomContainer>(topNode,"TOWERGEOM_FHCAL");
if (!towers||!geom) {
return std::vector<Jet*>();
}
} else if (_input == Jet::CEMC_TOWER_SUB1) {
towers = findNode::getClass<RawTowerContainer>(topNode,"TOWER_CALIB_CEMC_RETOWER_SUB1");
geom = findNode::getClass<RawTowerGeomContainer>(topNode,"TOWERGEOM_HCALIN");
if (!towers||!geom) {
return std::vector<Jet*>();
}
} else if (_input == Jet::HCALIN_TOWER_SUB1) {
towers = findNode::getClass<RawTowerContainer>(topNode,"TOWER_CALIB_HCALIN_SUB1");
geom = findNode::getClass<RawTowerGeomContainer>(topNode,"TOWERGEOM_HCALIN");
if (!towers||!geom) {
return std::vector<Jet*>();
}
} else if (_input == Jet::HCALOUT_TOWER_SUB1) {
towers = findNode::getClass<RawTowerContainer>(topNode,"TOWER_CALIB_HCALOUT_SUB1");
geom = findNode::getClass<RawTowerGeomContainer>(topNode,"TOWERGEOM_HCALOUT");
if (!towers||!geom) {
return std::vector<Jet*>();
}
} else {
return std::vector<Jet*>();
}
// first grab the event vertex or bail
GlobalVertex* vtx = vertexmap->begin()->second;
float vtxz = NAN;
if (vtx) vtxz = vtx->get_z();
else return std::vector<Jet*>();
if (isnan(vtxz))
{
static bool once = true;
if (once)
{
once = false;
cout <<"TowerJetInput::get_input - WARNING - vertex is NAN. Drop all tower inputs (further NAN-vertex warning will be suppressed)."<<endl;
}
return std::vector<Jet*>();
}
std::vector<Jet*> pseudojets;
RawTowerContainer::ConstRange begin_end = towers->getTowers();
RawTowerContainer::ConstIterator rtiter;
for (rtiter = begin_end.first; rtiter != begin_end.second; ++rtiter) {
RawTower *tower = rtiter->second;
RawTowerGeom * tower_geom =
geom->get_tower_geometry(tower -> get_key());
assert(tower_geom);
double r = tower_geom->get_center_radius();
double phi = atan2(tower_geom->get_center_y(), tower_geom->get_center_x());
double z0 = tower_geom->get_center_z();
double z = z0 - vtxz;
double eta = asinh(z/r); // eta after shift from vertex
double pt = tower->get_energy() / cosh(eta);
double px = pt * cos(phi);
double py = pt * sin(phi);
double pz = pt * sinh(eta);
Jet *jet = new JetV1();
jet->set_px(px);
jet->set_py(py);
jet->set_pz(pz);
jet->set_e(tower->get_energy());
jet->insert_comp(_input,tower->get_id());
pseudojets.push_back(jet);
}
if (_verbosity > 0) cout << "TowerJetInput::process_event -- exited" << endl;
return pseudojets;
}
float
TrackProjectionTools::getE33Forward( string detName, float tkx, float tky )
{
float twr_sum = 0;
string towernodename = "TOWER_CALIB_" + detName;
// Grab the towers
RawTowerContainer* towers = findNode::getClass<RawTowerContainer>(_topNode, towernodename.c_str());
if (!towers)
{
std::cout << PHWHERE << ": Could not find node " << towernodename.c_str() << std::endl;
return -1;
}
string towergeomnodename = "TOWERGEOM_" + detName;
RawTowerGeomContainer *towergeom = findNode::getClass<RawTowerGeomContainer>(_topNode, towergeomnodename.c_str());
if (! towergeom)
{
cout << PHWHERE << ": Could not find node " << towergeomnodename.c_str() << endl;
return -1;
}
// Locate the central tower
float r_dist = 9999.0;
int twr_j = -1;
int twr_k = -1;
RawTowerDefs::CalorimeterId calo_id_ = RawTowerDefs::convert_name_to_caloid( detName );
RawTowerContainer::ConstRange begin_end = towers->getTowers();
RawTowerContainer::ConstIterator itr = begin_end.first;
for (; itr != begin_end.second; ++itr)
{
RawTowerDefs::keytype towerid = itr->first;
RawTowerGeom *tgeo = towergeom->get_tower_geometry(towerid);
float x = tgeo->get_center_x();
float y = tgeo->get_center_y();
float temp_rdist = sqrt(pow(tkx-x,2) + pow(tky-y,2)) ;
if(temp_rdist< r_dist){
r_dist = temp_rdist;
twr_j = RawTowerDefs::decode_index1(towerid);
twr_k = RawTowerDefs::decode_index2(towerid);
}
if( (fabs(tkx-x)<(tgeo->get_size_x()/2.0)) &&
(fabs(tky-y)<(tgeo->get_size_y()/2.0)) ) break;
}
// Use the central tower to sum up the 3x3 energy
if(twr_j>=0 && twr_k>=0){
for(int ij = -1; ij <=1; ij++){
for(int ik = -1; ik <=1; ik++){
RawTowerDefs::keytype temp_towerid = RawTowerDefs::encode_towerid( calo_id_ , twr_j + ij , twr_k + ik );
RawTower *rawtower = towers->getTower(temp_towerid);
if(rawtower) twr_sum += rawtower->get_energy();
}
}
}
return twr_sum;
}
void CaloEvaluator::fillOutputNtuples(PHCompositeNode *topNode) {
if (verbosity > 2) cout << "CaloEvaluator::fillOutputNtuples() entered" << endl;
CaloRawClusterEval* clustereval = _caloevalstack->get_rawcluster_eval();
CaloRawTowerEval* towereval = _caloevalstack->get_rawtower_eval();
CaloTruthEval* trutheval = _caloevalstack->get_truth_eval();
//----------------------
// fill the Event NTuple
//----------------------
if (_do_gpoint_eval) {
// need things off of the DST...
PHG4TruthInfoContainer* truthinfo = findNode::getClass<PHG4TruthInfoContainer>(topNode,"G4TruthInfo");
if (!truthinfo) {
cerr << PHWHERE << " ERROR: Can't find G4TruthInfo" << endl;
exit(-1);
}
// need things off of the DST...
SvtxVertexMap* vertexmap = findNode::getClass<SvtxVertexMap>(topNode,"SvtxVertexMap");
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;
if (vertexmap) {
if (!vertexmap->empty()) {
SvtxVertex* vertex = (vertexmap->begin()->second);
vx = vertex->get_x();
vy = vertex->get_y();
vz = vertex->get_z();
}
}
float gpoint_data[7] = {_ievent,
gvx,
gvy,
gvz,
vx,
vy,
vz
};
_ntp_gpoint->Fill(gpoint_data);
}
//------------------------
// fill the Gshower NTuple
//------------------------
if (_ntp_gshower) {
if (verbosity > 1) cout << "CaloEvaluator::filling gshower ntuple..." << endl;
PHG4TruthInfoContainer* truthinfo = findNode::getClass<PHG4TruthInfoContainer>(topNode,"G4TruthInfo");
if (!truthinfo) {
cerr << PHWHERE << " ERROR: Can't find G4TruthInfo" << endl;
exit(-1);
}
PHG4TruthInfoContainer::ConstRange range = truthinfo->GetPrimaryParticleRange();
for (PHG4TruthInfoContainer::ConstIterator iter = range.first;
iter != range.second;
++iter) {
PHG4Particle* primary = iter->second;
if (primary->get_e() < _truth_e_threshold) continue;
if (!_truth_trace_embed_flags.empty()) {
if (_truth_trace_embed_flags.find(trutheval->get_embed(primary)) ==
_truth_trace_embed_flags.end()) continue;
}
float gparticleID = primary->get_track_id();
float gflavor = primary->get_pid();
std::set<PHG4Hit*> g4hits = trutheval->get_shower_from_primary(primary);
float gnhits = g4hits.size();
float gpx = primary->get_px();
float gpy = primary->get_py();
float gpz = primary->get_pz();
float ge = primary->get_e();
float gpt = sqrt(gpx*gpx+gpy*gpy);
float geta = NAN;
if (gpt != 0.0) geta = asinh(gpz/gpt);
float gphi = atan2(gpy,gpx);
PHG4VtxPoint* vtx = trutheval->get_vertex(primary);
float gvx = vtx->get_x();
float gvy = vtx->get_y();
float gvz = vtx->get_z();
float gembed = trutheval->get_embed(primary);
float gedep = trutheval->get_shower_energy_deposit(primary);
float gmrad = trutheval->get_shower_moliere_radius(primary);
RawCluster* cluster = clustereval->best_cluster_from(primary);
float clusterID = NAN;
float ntowers = NAN;
float eta = NAN;
float phi = NAN;
float e = NAN;
float efromtruth = NAN;
if (cluster) {
clusterID = cluster->get_id();
ntowers = cluster->getNTowers();
eta = cluster->get_eta();
phi = cluster->get_phi();
e = cluster->get_energy();
efromtruth = clustereval->get_energy_contribution(cluster, primary);
}
float shower_data[20] = {_ievent,
gparticleID,
gflavor,
gnhits,
geta,
gphi,
ge,
gpt,
gvx,
gvy,
gvz,
gembed,
gedep,
gmrad,
clusterID,
ntowers,
eta,
phi,
e,
efromtruth
};
_ntp_gshower->Fill(shower_data);
}
}
//----------------------
// fill the Tower NTuple
//----------------------
if (_do_tower_eval) {
if (verbosity > 1) cout << "CaloEvaluator::filling tower ntuple..." << endl;
string towernode = "TOWER_CALIB_" + _caloname;
RawTowerContainer* towers = findNode::getClass<RawTowerContainer>(topNode,towernode.c_str());
if (!towers) {
cerr << PHWHERE << " ERROR: Can't find " << towernode << endl;
exit(-1);
}
string towergeomnode = "TOWERGEOM_" + _caloname;
RawTowerGeomContainer* towergeom = findNode::getClass<RawTowerGeomContainer>(topNode,towergeomnode.c_str());
if (!towergeom) {
cerr << PHWHERE << " ERROR: Can't find " << towergeomnode << endl;
exit(-1);
}
RawTowerContainer::ConstRange begin_end = towers->getTowers();
RawTowerContainer::ConstIterator rtiter;
for (rtiter = begin_end.first; rtiter != begin_end.second; ++rtiter) {
RawTower *tower = rtiter->second;
if (tower->get_energy() < _reco_e_threshold) continue;
float towerid = tower->get_id();
float ieta = tower->get_bineta();
float iphi = tower->get_binphi();
float eta = towergeom->get_etacenter(tower->get_bineta());
float phi = towergeom->get_phicenter(tower->get_binphi());
float e = tower->get_energy();
PHG4Particle* primary = towereval->max_truth_primary_by_energy(tower);
float gparticleID = NAN;
float gflavor = NAN;
float gnhits = NAN;
float gpx = NAN;
float gpy = NAN;
float gpz = NAN;
float ge = NAN;
float gpt = NAN;
float geta = NAN;
float gphi = NAN;
float gvx = NAN;
float gvy = NAN;
float gvz = NAN;
float gembed = NAN;
float gedep = NAN;
float gmrad = NAN;
float efromtruth = NAN;
if (primary) {
gparticleID = primary->get_track_id();
gflavor = primary->get_pid();
std::set<PHG4Hit*> g4hits = trutheval->get_shower_from_primary(primary);
gnhits = g4hits.size();
gpx = primary->get_px();
gpy = primary->get_py();
gpz = primary->get_pz();
ge = primary->get_e();
gpt = sqrt(gpx * gpx + gpy * gpy);
if (gpt != 0.0) geta = asinh(gpz / gpt);
gphi = atan2(gpy, gpx);
PHG4VtxPoint* vtx = trutheval->get_vertex(primary);
if (vtx) {
gvx = vtx->get_x();
gvy = vtx->get_y();
gvz = vtx->get_z();
}
gembed = trutheval->get_embed(primary);
gedep = trutheval->get_shower_energy_deposit(primary);
gmrad = trutheval->get_shower_moliere_radius(primary);
efromtruth = towereval->get_energy_contribution(tower, primary);
}
float tower_data[21] = {_ievent,
towerid,
ieta,
iphi,
eta,
phi,
e,
gparticleID,
gflavor,
gnhits,
geta,
gphi,
ge,
gpt,
gvx,
gvy,
gvz,
gembed,
gedep,
gmrad,
efromtruth
};
_ntp_tower->Fill(tower_data);
}
}
//------------------------
// fill the Cluster NTuple
//------------------------
if (_do_cluster_eval) {
if (verbosity > 1) cout << "CaloEvaluator::filling gcluster ntuple..." << endl;
string clusternode = "CLUSTER_" + _caloname;
RawClusterContainer* clusters = findNode::getClass<RawClusterContainer>(topNode,clusternode.c_str());
if (!clusters) {
cerr << PHWHERE << " ERROR: Can't find " << clusternode << endl;
exit(-1);
}
// for every cluster
for (unsigned int icluster = 0; icluster < clusters->size(); icluster++) {
RawCluster *cluster = clusters->getCluster(icluster);
if (cluster->get_energy() < _reco_e_threshold) continue;
float clusterID = cluster->get_id();
float ntowers = cluster->getNTowers();
float eta = cluster->get_eta();
float phi = cluster->get_phi();
float e = cluster->get_energy();
PHG4Particle* primary = clustereval->max_truth_primary_by_energy(cluster);
float gparticleID = NAN;
float gflavor = NAN;
float gnhits = NAN;
float gpx = NAN;
float gpy = NAN;
float gpz = NAN;
float ge = NAN;
float gpt = NAN;
float geta = NAN;
float gphi = NAN;
float gvx = NAN;
float gvy = NAN;
float gvz = NAN;
float gembed = NAN;
float gedep = NAN;
float gmrad = NAN;
float efromtruth = NAN;
if (primary) {
gparticleID = primary->get_track_id();
gflavor = primary->get_pid();
std::set<PHG4Hit*> g4hits = trutheval->get_shower_from_primary(primary);
gnhits = g4hits.size();
gpx = primary->get_px();
gpy = primary->get_py();
gpz = primary->get_pz();
ge = primary->get_e();
gpt = sqrt(gpx * gpx + gpy * gpy);
if (gpt != 0.0) geta = asinh(gpz / gpt);
gphi = atan2(gpy, gpx);
PHG4VtxPoint* vtx = trutheval->get_vertex(primary);
if (vtx) {
gvx = vtx->get_x();
gvy = vtx->get_y();
gvz = vtx->get_z();
}
gembed = trutheval->get_embed(primary);
gedep = trutheval->get_shower_energy_deposit(primary);
gmrad = trutheval->get_shower_moliere_radius(primary);
efromtruth = clustereval->get_energy_contribution(cluster,
primary);
}
float cluster_data[20] = {_ievent,
clusterID,
ntowers,
eta,
phi,
e,
gparticleID,
gflavor,
gnhits,
geta,
gphi,
ge,
gpt,
gvx,
gvy,
gvz,
gembed,
gedep,
gmrad,
efromtruth
};
_ntp_cluster->Fill(cluster_data);
}
}
return;
}
int PHG4DstCompressReco::process_event(PHCompositeNode *topNode) {
if (_g4hits.empty() && _g4cells.empty() && _towers.empty()) return Fun4AllReturnCodes::EVENT_OK;
//---cells--------------------------------------------------------------------
for (std::set<PHG4CellContainer*>::iterator iter = _g4cells.begin();
iter != _g4cells.end();
++iter) {
PHG4CellContainer* cells = *iter;
cells->Reset(); // DROP ALL COMPRESSED G4CELLS
}
//---hits---------------------------------------------------------------------
for (std::set<PHG4HitContainer*>::iterator iter = _g4hits.begin();
iter != _g4hits.end();
++iter) {
PHG4HitContainer* hits = *iter;
hits->Reset(); // DROP ALL COMPRESSED G4HITS
}
//---secondary particles and vertexes-----------------------------------------
std::set<int> keep_particle_ids;
for (std::set<PHG4HitContainer*>::iterator iter = _keep_g4hits.begin();
iter != _keep_g4hits.end();
++iter) {
PHG4HitContainer* hits = *iter;
for (PHG4HitContainer::ConstIterator jter = hits->getHits().first;
jter != hits->getHits().second;
++jter) {
PHG4Hit* hit = jter->second;
keep_particle_ids.insert(hit->get_trkid());
// this will need to include all parents too in a trace back to
// the primary, but let's start here for now
}
}
std::set<int> keep_vertex_ids;
PHG4TruthInfoContainer::Range range = _truth_info->GetSecondaryParticleRange();
for (PHG4TruthInfoContainer::Iterator iter = range.first;
iter != range.second;
) {
int id = iter->first;
PHG4Particle* particle = iter->second;
if (keep_particle_ids.find(id) != keep_particle_ids.end()) {
++iter;
keep_vertex_ids.insert(particle->get_vtx_id());
continue;
} else {
_truth_info->delete_particle(iter++); // DROP PARTICLES NOT ASSOCIATED TO A PRESERVED HIT
}
}
PHG4TruthInfoContainer::VtxRange vrange = _truth_info->GetSecondaryVtxRange();
for (PHG4TruthInfoContainer::VtxIterator iter = vrange.first;
iter != vrange.second;
) {
int id = iter->first;
if (keep_vertex_ids.find(id) != keep_vertex_ids.end()) {
++iter;
continue;
} else {
_truth_info->delete_vtx(iter++); // DROP VERTEXES NOT ASSOCIATED TO A PRESERVED HIT
}
}
//---shower entries-----------------------------------------------------------
PHG4TruthInfoContainer::ShowerRange srange = _truth_info->GetShowerRange();
for (PHG4TruthInfoContainer::ShowerIterator iter = srange.first;
iter != srange.second;
++iter) {
PHG4Shower* shower = iter->second;
shower->clear_g4particle_id();
shower->clear_g4vertex_id();
shower->clear_g4hit_id();
}
//---tower cell entries-------------------------------------------------------
for (std::set<RawTowerContainer*>::iterator iter = _towers.begin();
iter != _towers.end();
++iter) {
RawTowerContainer* towers = *iter;
// loop over all the towers
for (RawTowerContainer::Iterator jter = towers->getTowers().first;
jter != towers->getTowers().second;
++jter) {
RawTower* tower = jter->second;
tower->clear_g4cells();
}
}
return Fun4AllReturnCodes::EVENT_OK;
}
int
RecoInfoExport::process_event(PHCompositeNode *topNode)
{
++_event;
stringstream fname;
fname << _file_prefix << "_Event" << _event << ".dat";
fstream fdata(fname.str(), ios_base::out);
for (auto & calo_name : _calo_names)
{
string towernodename = "TOWER_CALIB_" + calo_name;
// Grab the towers
RawTowerContainer* towers = findNode::getClass<RawTowerContainer>(topNode,
towernodename.c_str());
if (!towers)
{
std::cout << PHWHERE << ": Could not find node "
<< towernodename.c_str() << std::endl;
return Fun4AllReturnCodes::ABORTRUN;
}
string towergeomnodename = "TOWERGEOM_" + calo_name;
RawTowerGeomContainer *towergeom = findNode::getClass<
RawTowerGeomContainer>(topNode, towergeomnodename.c_str());
if (!towergeom)
{
cout << PHWHERE << ": Could not find node "
<< towergeomnodename.c_str() << endl;
return Fun4AllReturnCodes::ABORTRUN;
}
set<const RawTower *> good_towers;
RawTowerContainer::ConstRange begin_end = towers->getTowers();
RawTowerContainer::ConstIterator rtiter;
for (rtiter = begin_end.first; rtiter != begin_end.second; ++rtiter)
{
const RawTower *tower = rtiter->second;
assert(tower);
if (tower->get_energy() > _tower_threshold)
{
good_towers.insert(tower);
}
}
fdata
<< (boost::format("%1% (1..%2% hits)") % calo_name
% good_towers.size()) << endl;
bool first = true;
for (const auto & tower : good_towers)
{
assert(tower);
float eta = towergeom->get_etacenter(tower->get_bineta());
float phi = towergeom->get_phicenter(tower->get_binphi());
phi = atan2(cos(phi), sin(phi));
if (first)
{
first = false;
}
else
fdata << ",";
fdata
<< (boost::format("[%1%,%2%,%3%]") % eta % phi
% tower->get_energy());
}
fdata << endl;
}
{
fdata << "Track list" << endl;
// need things off of the DST...
PHG4TruthInfoContainer* truthinfo = findNode::getClass<
PHG4TruthInfoContainer>(topNode, "G4TruthInfo");
if (!truthinfo)
{
cerr << PHWHERE << " ERROR: Can't find G4TruthInfo" << endl;
exit(-1);
}
// create SVTX eval stack
SvtxEvalStack svtxevalstack(topNode);
// SvtxVertexEval* vertexeval = svtxevalstack.get_vertex_eval();
// SvtxTrackEval* trackeval = svtxevalstack.get_track_eval();
SvtxTruthEval* trutheval = svtxevalstack.get_truth_eval();
// loop over all truth particles
PHG4TruthInfoContainer::Range range =
truthinfo->GetPrimaryParticleRange();
for (PHG4TruthInfoContainer::ConstIterator iter = range.first;
iter != range.second; ++iter)
{
PHG4Particle* g4particle = iter->second;
const TVector3 mom(g4particle->get_px(), g4particle->get_py(),
g4particle->get_pz());
std::set<PHG4Hit*> g4hits = trutheval->all_truth_hits(g4particle);
map<float, PHG4Hit *> time_sort;
map<float, PHG4Hit *> layer_sort;
for (auto & hit : g4hits)
{
if (hit)
{
time_sort[hit->get_avg_t()] = hit;
}
}
for (auto & hit_pair : time_sort)
{
if (hit_pair.second->get_layer() != UINT_MAX
and layer_sort.find(hit_pair.second->get_layer())
== layer_sort.end())
{
layer_sort[hit_pair.second->get_layer()] = hit_pair.second;
}
}
if (layer_sort.size() > 5 and mom.Pt() > _pT_threshold) // minimal track length cut
{
stringstream spts;
TVector3 last_pos(0, 0, 0);
bool first = true;
for (auto & hit_pair : layer_sort)
{
TVector3 pos(hit_pair.second->get_avg_x(),
hit_pair.second->get_avg_y(),
hit_pair.second->get_avg_z());
// hit step cuts
if ((pos - last_pos).Mag() < _min_track_hit_dist
and hit_pair.first != (layer_sort.rbegin()->first)
and hit_pair.first != (layer_sort.begin()->first))
continue;
last_pos = pos;
if (first)
{
first = false;
}
else
spts << ",";
spts << "[";
spts << pos.x();
spts << ",";
spts << pos.y();
spts << ",";
spts << pos.z();
spts << "]";
}
const int abs_pid = abs(g4particle->get_pid());
int t = 5;
if (abs_pid
== TDatabasePDG::Instance()->GetParticle("pi+")->PdgCode())
{
t = 1;
}
else if (abs_pid
== TDatabasePDG::Instance()->GetParticle("proton")->PdgCode())
{
t = 2;
}
else if (abs_pid
== TDatabasePDG::Instance()->GetParticle("K+")->PdgCode())
{
t = 3;
}
else if (abs_pid
== TDatabasePDG::Instance()->GetParticle("e-")->PdgCode())
{
t = 3;
}
const TParticlePDG * pdg_part =
TDatabasePDG::Instance()->GetParticle(11);
const int c =
(pdg_part != nullptr) ? (copysign(1, pdg_part->Charge())) : 0;
fdata
<< (boost::format(
"{ \"pt\": %1%, \"t\": %2%, \"e\": %3%, \"p\": %4%, \"c\": %5%, \"pts\":[ %6% ]}")
% mom.Pt() % t % mom.PseudoRapidity() % mom.Phi() % c
% spts.str()) << endl;
}
}
}
fdata.close();
return 0;
}