File indexing completed on 2025-12-16 09:20:05
0001 #include "TowerJetInput.h"
0002
0003 #include "Jet.h"
0004 #include "Jetv2.h"
0005
0006 #include <calobase/RawTower.h>
0007 #include <calobase/RawTowerContainer.h>
0008 #include <calobase/RawTowerDefs.h> // for encode_towerid
0009 #include <calobase/RawTowerGeom.h>
0010 #include <calobase/RawTowerGeomContainer.h>
0011 #include <calobase/TowerInfo.h>
0012 #include <calobase/TowerInfoContainer.h>
0013 #include <globalvertex/GlobalVertexv2.h>
0014 #include <globalvertex/GlobalVertexMapv1.h>
0015
0016 #include <phool/getClass.h>
0017
0018 #include <cassert>
0019 #include <cmath> // for asinh, atan2, cos, cosh
0020 #include <iostream>
0021 #include <map> // for _Rb_tree_const_iterator
0022 #include <utility> // for pair
0023 #include <vector>
0024
0025 TowerJetInput::TowerJetInput(Jet::SRC input, const std::string &prefix)
0026 : m_input(input)
0027 , m_towerNodePrefix(prefix)
0028 {
0029 }
0030
0031 void TowerJetInput::identify(std::ostream &os)
0032 {
0033 os << " TowerJetInput: ";
0034 if (m_input == Jet::CEMC_TOWER)
0035 {
0036 os << "TOWER_CEMC to Jet::CEMC_TOWER";
0037 }
0038 else if (m_input == Jet::EEMC_TOWER)
0039 {
0040 os << "TOWER_EEMC to Jet::EEMC_TOWER";
0041 }
0042 else if (m_input == Jet::HCALIN_TOWER)
0043 {
0044 os << "TOWER_HCALIN to Jet::HCALIN_TOWER";
0045 }
0046 else if (m_input == Jet::HCALOUT_TOWER)
0047 {
0048 os << "TOWER_HCALOUT to Jet::HCALOUT_TOWER";
0049 }
0050 else if (m_input == Jet::FEMC_TOWER)
0051 {
0052 os << "TOWER_FEMC to Jet::FEMC_TOWER";
0053 }
0054 else if (m_input == Jet::FHCAL_TOWER)
0055 {
0056 os << "TOWER_FHCAL to Jet::FHCAL_TOWER";
0057 }
0058 os << std::endl;
0059 }
0060
0061 std::vector<Jet *> TowerJetInput::get_input(PHCompositeNode *topNode)
0062 {
0063 if (Verbosity() > 0)
0064 {
0065 std::cout << "TowerJetInput::process_event -- entered" << std::endl;
0066 }
0067 float vtxz = 0;
0068 GlobalVertexMap *vertexmap = findNode::getClass<GlobalVertexMap>(topNode, "GlobalVertexMap");
0069 if (!vertexmap)
0070 {
0071 std::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." << std::endl;
0072 assert(vertexmap);
0073
0074 return std::vector<Jet *>();
0075 }
0076 if (vertexmap->empty())
0077 {
0078 if (Verbosity() > 0)
0079 {
0080 std::cout << "TowerJetInput::get_input - empty vertex map, continuing as if zvtx = 0" << std::endl;
0081 }
0082 }
0083 else
0084 {
0085 if(m_use_vertextype)
0086 {
0087 std::vector<GlobalVertex*> vertices = vertexmap->get_gvtxs_with_type(m_vertex_type);
0088 if(!vertices.empty())
0089 {
0090 if(vertices.at(0))
0091 {
0092 vtxz = vertices.at(0)->get_z();
0093 }
0094 if(vertices.size() > 1 && Verbosity() > 0)
0095 {
0096 std::cout << "TowerJetInput::WARNING!! More than one vertex of selected type!" << std::endl;
0097 }
0098 }
0099 }
0100 else
0101 {
0102 GlobalVertex *vtx = vertexmap->begin()->second;
0103 if (vtx)
0104 {
0105 vtxz = vtx->get_z();
0106 }
0107 }
0108 }
0109 if (std::isnan(vtxz))
0110 {
0111 static bool once = true;
0112 if (once)
0113 {
0114 once = false;
0115 std::cout << "TowerJetInput::get_input - WARNING - vertex is NAN. Continue with zvtx = 0 (further vertex warning will be suppressed)." << std::endl;
0116 }
0117 vtxz = 0;
0118 }
0119
0120 if (std::abs(vtxz) > 1e3)
0121 {
0122 static bool once = true;
0123 if (once)
0124 {
0125 once = false;
0126
0127 std::cout << "TowerJetInput::get_input - WARNING - vertex is " << vtxz << ". Set vtxz = 0 (further vertex warning will be suppressed)." << std::endl;
0128 }
0129 vtxz = 0;
0130 }
0131
0132 m_use_towerinfo = false;
0133
0134
0135
0136
0137
0138
0139
0140
0141
0142
0143
0144
0145
0146
0147
0148
0149
0150
0151
0152
0153
0154
0155
0156
0157 RawTowerContainer *towers = nullptr;
0158 TowerInfoContainer *towerinfos = nullptr;
0159 RawTowerGeomContainer *geom = nullptr;
0160 RawTowerGeomContainer *EMCal_geom = nullptr;
0161
0162
0163 if (m_input == Jet::CEMC_TOWER)
0164 {
0165 towers = findNode::getClass<RawTowerContainer>(topNode, "TOWER_CALIB_CEMC");
0166 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_CEMC");
0167 if ((!towers) || !geom)
0168 {
0169 return std::vector<Jet *>();
0170 }
0171 }
0172 else if (m_input == Jet::CEMC_TOWERINFO)
0173 {
0174 m_use_towerinfo = true;
0175 towerName = m_towerNodePrefix + "_CEMC";
0176 towerinfos = findNode::getClass<TowerInfoContainer>(topNode, towerName);
0177 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_CEMC");
0178 geocaloid = RawTowerDefs::CalorimeterId::CEMC;
0179 if ((!towerinfos) || !geom)
0180 {
0181 return std::vector<Jet *>();
0182 }
0183 }
0184 else if (m_input == Jet::CEMC_TOWERINFO_EMBED)
0185 {
0186 m_use_towerinfo = true;
0187 towerName = m_towerNodePrefix + "_EMBED_CEMC";
0188 towerinfos = findNode::getClass<TowerInfoContainer>(topNode, towerName);
0189 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_CEMC");
0190 geocaloid = RawTowerDefs::CalorimeterId::CEMC;
0191 if ((!towerinfos) || !geom)
0192 {
0193 return std::vector<Jet *>();
0194 }
0195 }
0196 else if (m_input == Jet::CEMC_TOWERINFO_SIM)
0197 {
0198 m_use_towerinfo = true;
0199 towerName = m_towerNodePrefix + "_SIM_CEMC";
0200 towerinfos = findNode::getClass<TowerInfoContainer>(topNode, towerName);
0201 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_CEMC");
0202 geocaloid = RawTowerDefs::CalorimeterId::CEMC;
0203 if ((!towerinfos) || !geom)
0204 {
0205 return std::vector<Jet *>();
0206 }
0207 }
0208 else if (m_input == Jet::EEMC_TOWER)
0209 {
0210 towers = findNode::getClass<RawTowerContainer>(topNode, "TOWER_CALIB_EEMC");
0211 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_EEMC");
0212 if ((!towers && !towerinfos) || !geom)
0213 {
0214 return std::vector<Jet *>();
0215 }
0216 }
0217 else if (m_input == Jet::HCALIN_TOWER)
0218 {
0219 towers = findNode::getClass<RawTowerContainer>(topNode, "TOWER_CALIB_HCALIN");
0220 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_HCALIN");
0221 if ((!towers) || !geom)
0222 {
0223 return std::vector<Jet *>();
0224 }
0225 }
0226 else if (m_input == Jet::HCALIN_TOWERINFO)
0227 {
0228 m_use_towerinfo = true;
0229 towerName = m_towerNodePrefix + "_HCALIN";
0230 towerinfos = findNode::getClass<TowerInfoContainer>(topNode, towerName);
0231 geocaloid = RawTowerDefs::CalorimeterId::HCALIN;
0232 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_HCALIN");
0233 if ((!towerinfos) || !geom)
0234 {
0235 return std::vector<Jet *>();
0236 }
0237 }
0238 else if (m_input == Jet::HCALIN_TOWERINFO_EMBED)
0239 {
0240 m_use_towerinfo = true;
0241 towerName = m_towerNodePrefix + "_EMBED_HCALIN";
0242 towerinfos = findNode::getClass<TowerInfoContainer>(topNode, towerName);
0243 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_HCALIN");
0244 geocaloid = RawTowerDefs::CalorimeterId::HCALIN;
0245 if ((!towerinfos) || !geom)
0246 {
0247 return std::vector<Jet *>();
0248 }
0249 }
0250 else if (m_input == Jet::HCALIN_TOWERINFO_SIM)
0251 {
0252 m_use_towerinfo = true;
0253 towerName = m_towerNodePrefix + "_SIM_HCALIN";
0254 towerinfos = findNode::getClass<TowerInfoContainer>(topNode, towerName);
0255 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_HCALIN");
0256 geocaloid = RawTowerDefs::CalorimeterId::HCALIN;
0257 if ((!towerinfos) || !geom)
0258 {
0259 return std::vector<Jet *>();
0260 }
0261 }
0262 else if (m_input == Jet::HCALOUT_TOWER)
0263 {
0264 towers = findNode::getClass<RawTowerContainer>(topNode, "TOWER_CALIB_HCALOUT");
0265 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_HCALOUT");
0266 if ((!towers) || !geom)
0267 {
0268 return std::vector<Jet *>();
0269 }
0270 }
0271 else if (m_input == Jet::HCALOUT_TOWERINFO)
0272 {
0273 m_use_towerinfo = true;
0274 towerName = m_towerNodePrefix + "_HCALOUT";
0275 towerinfos = findNode::getClass<TowerInfoContainer>(topNode, towerName);
0276 geocaloid = RawTowerDefs::CalorimeterId::HCALOUT;
0277 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_HCALOUT");
0278 if ((!towerinfos) || !geom)
0279 {
0280 return std::vector<Jet *>();
0281 }
0282 }
0283 else if (m_input == Jet::HCALOUT_TOWERINFO_EMBED)
0284 {
0285 m_use_towerinfo = true;
0286 towerName = m_towerNodePrefix + "_EMBED_HCALOUT";
0287 towerinfos = findNode::getClass<TowerInfoContainer>(topNode, towerName);
0288 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_HCALOUT");
0289 geocaloid = RawTowerDefs::CalorimeterId::HCALOUT;
0290 if ((!towerinfos) || !geom)
0291 {
0292 return std::vector<Jet *>();
0293 }
0294 }
0295 else if (m_input == Jet::HCALOUT_TOWERINFO_SIM)
0296 {
0297 m_use_towerinfo = true;
0298 towerName = m_towerNodePrefix + "_SIM_HCALOUT";
0299 towerinfos = findNode::getClass<TowerInfoContainer>(topNode, towerName);
0300 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_HCALOUT");
0301 geocaloid = RawTowerDefs::CalorimeterId::HCALOUT;
0302 if ((!towerinfos) || !geom)
0303 {
0304 return std::vector<Jet *>();
0305 }
0306 }
0307
0308 else if (m_input == Jet::FEMC_TOWER)
0309 {
0310 towers = findNode::getClass<RawTowerContainer>(topNode, "TOWER_CALIB_FEMC");
0311 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_FEMC");
0312 if ((!towers) || !geom)
0313 {
0314 return std::vector<Jet *>();
0315 }
0316 }
0317 else if (m_input == Jet::FHCAL_TOWER)
0318 {
0319 towers = findNode::getClass<RawTowerContainer>(topNode, "TOWER_CALIB_FHCAL");
0320 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_FHCAL");
0321 if ((!towers) || !geom)
0322 {
0323 return std::vector<Jet *>();
0324 }
0325 }
0326 else if (m_input == Jet::CEMC_TOWER_RETOWER)
0327 {
0328 towers = findNode::getClass<RawTowerContainer>(topNode, "TOWER_CALIB_CEMC_RETOWER");
0329 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_HCALIN");
0330 if ((!towers) || !geom)
0331 {
0332 return std::vector<Jet *>();
0333 }
0334 }
0335 else if (m_input == Jet::CEMC_TOWERINFO_RETOWER)
0336 {
0337 m_use_towerinfo = true;
0338 towerName = m_towerNodePrefix + "_CEMC_RETOWER";
0339 towerinfos = findNode::getClass<TowerInfoContainer>(topNode, towerName);
0340 geocaloid = RawTowerDefs::CalorimeterId::HCALIN;
0341 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_HCALIN");
0342 if ((!towerinfos) || !geom)
0343 {
0344 return std::vector<Jet *>();
0345 }
0346 }
0347 else if (m_input == Jet::CEMC_TOWER_SUB1)
0348 {
0349 towers = findNode::getClass<RawTowerContainer>(topNode, "TOWER_CALIB_CEMC_RETOWER_SUB1");
0350 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_HCALIN");
0351 if ((!towers) || !geom)
0352 {
0353 return std::vector<Jet *>();
0354 }
0355 }
0356 else if (m_input == Jet::CEMC_TOWERINFO_SUB1)
0357 {
0358 m_use_towerinfo = true;
0359 towerName = m_towerNodePrefix + "_CEMC_RETOWER_SUB1";
0360 towerinfos = findNode::getClass<TowerInfoContainer>(topNode, towerName);
0361 geocaloid = RawTowerDefs::CalorimeterId::HCALIN;
0362 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_HCALIN");
0363 if ((!towerinfos) || !geom)
0364 {
0365 return std::vector<Jet *>();
0366 }
0367 }
0368 else if (m_input == Jet::HCALIN_TOWER_SUB1)
0369 {
0370 towers = findNode::getClass<RawTowerContainer>(topNode, "TOWER_CALIB_HCALIN_SUB1");
0371 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_HCALIN");
0372 if ((!towers) || !geom)
0373 {
0374 return std::vector<Jet *>();
0375 }
0376 }
0377 else if (m_input == Jet::HCALIN_TOWERINFO_SUB1)
0378 {
0379 m_use_towerinfo = true;
0380 towerName = m_towerNodePrefix + "_HCALIN_SUB1";
0381 towerinfos = findNode::getClass<TowerInfoContainer>(topNode, towerName);
0382 geocaloid = RawTowerDefs::CalorimeterId::HCALIN;
0383 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_HCALIN");
0384 if ((!towerinfos) || !geom)
0385 {
0386 return std::vector<Jet *>();
0387 }
0388 }
0389 else if (m_input == Jet::HCALOUT_TOWER_SUB1)
0390 {
0391 towers = findNode::getClass<RawTowerContainer>(topNode, "TOWER_CALIB_HCALOUT_SUB1");
0392 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_HCALOUT");
0393 if ((!towers) || !geom)
0394 {
0395 return std::vector<Jet *>();
0396 }
0397 }
0398 else if (m_input == Jet::HCALOUT_TOWERINFO_SUB1)
0399 {
0400 m_use_towerinfo = true;
0401 towerName = m_towerNodePrefix + "_HCALOUT_SUB1";
0402 towerinfos = findNode::getClass<TowerInfoContainer>(topNode, towerName);
0403 geocaloid = RawTowerDefs::CalorimeterId::HCALOUT;
0404 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_HCALOUT");
0405 if ((!towerinfos) || !geom)
0406 {
0407 return std::vector<Jet *>();
0408 }
0409 }
0410 else if (m_input == Jet::CEMC_TOWER_SUB1CS)
0411 {
0412 towers = findNode::getClass<RawTowerContainer>(topNode, "TOWER_CALIB_CEMC_RETOWER_SUB1CS");
0413 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_HCALIN");
0414 if ((!towers) || !geom)
0415 {
0416 return std::vector<Jet *>();
0417 }
0418 }
0419 else if (m_input == Jet::HCALIN_TOWER_SUB1CS)
0420 {
0421 towers = findNode::getClass<RawTowerContainer>(topNode, "TOWER_CALIB_HCALIN_SUB1CS");
0422 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_HCALIN");
0423 if ((!towers) || !geom)
0424 {
0425 return std::vector<Jet *>();
0426 }
0427 }
0428 else if (m_input == Jet::HCALOUT_TOWER_SUB1CS)
0429 {
0430 towers = findNode::getClass<RawTowerContainer>(topNode, "TOWER_CALIB_HCALOUT_SUB1CS");
0431 geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_HCALOUT");
0432 if ((!towers) || !geom)
0433 {
0434 return std::vector<Jet *>();
0435 }
0436 }
0437 else
0438 {
0439 return std::vector<Jet *>();
0440 }
0441
0442
0443 if (m_input == Jet::CEMC_TOWER_RETOWER || m_input == Jet::CEMC_TOWERINFO_RETOWER || m_input == Jet::CEMC_TOWER_SUB1 || m_input == Jet::CEMC_TOWERINFO_SUB1 || m_input == Jet::CEMC_TOWER_SUB1CS)
0444 {
0445 EMCal_geom = findNode::getClass<RawTowerGeomContainer>(topNode, "TOWERGEOM_CEMC");
0446 if (!EMCal_geom)
0447 {
0448 return std::vector<Jet *>();
0449 }
0450 }
0451
0452
0453
0454
0455 std::vector<Jet *> pseudojets;
0456 if (m_use_towerinfo)
0457 {
0458 if (!towerinfos)
0459 {
0460 return std::vector<Jet *>();
0461 }
0462
0463 unsigned int nchannels = towerinfos->size();
0464 for (unsigned int channel = 0; channel < nchannels; channel++)
0465 {
0466 TowerInfo *tower = towerinfos->get_tower_at_channel(channel);
0467 assert(tower);
0468
0469 unsigned int calokey = towerinfos->encode_key(channel);
0470 int ieta = towerinfos->getTowerEtaBin(calokey);
0471 int iphi = towerinfos->getTowerPhiBin(calokey);
0472 const RawTowerDefs::keytype key = RawTowerDefs::encode_towerid(geocaloid, ieta, iphi);
0473
0474 if (tower->get_isHot() || tower->get_isNoCalib() || tower->get_isNotInstr() || tower->get_isBadChi2())
0475 {
0476 continue;
0477 }
0478 if (std::isnan(tower->get_energy()))
0479 {
0480 continue;
0481 }
0482 RawTowerGeom *tower_geom = geom->get_tower_geometry(key);
0483 assert(tower_geom);
0484 double r = tower_geom->get_center_radius();
0485 if (m_input == Jet::CEMC_TOWER_RETOWER || m_input == Jet::CEMC_TOWERINFO_RETOWER || m_input == Jet::CEMC_TOWER_SUB1 || m_input == Jet::CEMC_TOWERINFO_SUB1 || m_input == Jet::CEMC_TOWER_SUB1CS)
0486 {
0487 const RawTowerDefs::keytype EMCal_key = RawTowerDefs::encode_towerid(RawTowerDefs::CalorimeterId::CEMC, 0, 0);
0488 RawTowerGeom *EMCal_tower_geom = EMCal_geom->get_tower_geometry(EMCal_key);
0489 assert(EMCal_tower_geom);
0490 r = EMCal_tower_geom->get_center_radius();
0491 }
0492 double phi = atan2(tower_geom->get_center_y(), tower_geom->get_center_x());
0493 double towereta = tower_geom->get_eta();
0494 double z0 = sinh(towereta) * r;
0495 double z = z0 - vtxz;
0496 double eta = asinh(z / r);
0497 double pt = tower->get_energy() / cosh(eta);
0498 double e = tower->get_energy();
0499 double px = pt * cos(phi);
0500 double py = pt * sin(phi);
0501 double pz = pt * sinh(eta);
0502
0503 Jet *jet = new Jetv2();
0504 jet->set_px(px);
0505 jet->set_py(py);
0506 jet->set_pz(pz);
0507 jet->set_e(e);
0508 jet->insert_comp(m_input, channel);
0509 float tower_t = 17.6*tower->get_time();
0510 if(jet->size_properties() < Jet::PROPERTY::prop_t+1)
0511 {
0512 jet->resize_properties(Jet::PROPERTY::prop_t + 1);
0513 }
0514 if(e > m_timing_e_threshold)
0515 {
0516 jet->set_property(Jet::PROPERTY::prop_t, tower_t);
0517 }
0518 else
0519 {
0520 jet->set_property(Jet::PROPERTY::prop_t, std::numeric_limits<float>::quiet_NaN());
0521 }
0522 pseudojets.push_back(jet);
0523 }
0524 }
0525 else
0526 {
0527 RawTowerContainer::ConstRange begin_end = towers->getTowers();
0528 RawTowerContainer::ConstIterator rtiter;
0529 for (rtiter = begin_end.first; rtiter != begin_end.second; ++rtiter)
0530 {
0531 RawTower *tower = rtiter->second;
0532
0533 RawTowerGeom *tower_geom = geom->get_tower_geometry(tower->get_key());
0534 assert(tower_geom);
0535
0536 double r = tower_geom->get_center_radius();
0537 if (m_input == Jet::CEMC_TOWER_RETOWER || m_input == Jet::CEMC_TOWERINFO_RETOWER || m_input == Jet::CEMC_TOWER_SUB1 || m_input == Jet::CEMC_TOWERINFO_SUB1 || m_input == Jet::CEMC_TOWER_SUB1CS)
0538 {
0539 const RawTowerDefs::keytype EMCal_key = RawTowerDefs::encode_towerid(RawTowerDefs::CalorimeterId::CEMC, 0, 0);
0540 RawTowerGeom *EMCal_tower_geom = EMCal_geom->get_tower_geometry(EMCal_key);
0541 assert(EMCal_tower_geom);
0542 r = EMCal_tower_geom->get_center_radius();
0543 }
0544 double phi = atan2(tower_geom->get_center_y(), tower_geom->get_center_x());
0545 double towereta = tower_geom->get_eta();
0546 double z0 = sinh(towereta) * r;
0547 double z = z0 - vtxz;
0548 double eta = asinh(z / r);
0549 double pt = tower->get_energy() / cosh(eta);
0550 double px = pt * cos(phi);
0551 double py = pt * sin(phi);
0552 double pz = pt * sinh(eta);
0553
0554 Jet *jet = new Jetv2();
0555 jet->set_px(px);
0556 jet->set_py(py);
0557 jet->set_pz(pz);
0558 jet->set_e(tower->get_energy());
0559 jet->insert_comp(m_input, tower->get_id());
0560 pseudojets.push_back(jet);
0561 }
0562 }
0563 if (Verbosity() > 0)
0564 {
0565 std::cout << "TowerJetInput::process_event -- exited" << std::endl;
0566 }
0567 return pseudojets;
0568 }
