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;
}
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;
}
int
Proto2ShowerCalib::process_event(PHCompositeNode *topNode)
{
if (verbosity > 2)
cout << "Proto2ShowerCalib::process_event() entered" << endl;
// init eval objects
_eval_run.reset();
_shower.reset();
Fun4AllHistoManager *hm = get_HistoManager();
assert(hm);
PdbParameterMap *info = findNode::getClass<PdbParameterMap>(topNode,
"RUN_INFO");
//if(!_is_sim) assert(info);
if(info)
{
PHParameters 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(!_is_sim) assert(eventheader);
if( eventheader )
{
_eval_run.run = eventheader->get_RunNumber();
if (verbosity > 4)
cout << __PRETTY_FUNCTION__ << _eval_run.run << endl;
_eval_run.event = eventheader->get_EvtSequence();
}
// normalization
TH1F * hNormalization = dynamic_cast<TH1F *>(hm->getHisto("hNormalization"));
assert(hNormalization);
hNormalization->Fill("ALL", 1);
// other nodes
RawTowerContainer* TOWER_CALIB_TRIGGER_VETO = findNode::getClass<
RawTowerContainer>(topNode, "TOWER_CALIB_TRIGGER_VETO");
//if(!_is_sim) assert(TOWER_CALIB_TRIGGER_VETO);
RawTowerContainer* TOWER_CALIB_HODO_HORIZONTAL = findNode::getClass<
RawTowerContainer>(topNode, "TOWER_CALIB_HODO_HORIZONTAL");
//if(!_is_sim) assert(TOWER_CALIB_HODO_HORIZONTAL);
RawTowerContainer* TOWER_CALIB_HODO_VERTICAL = findNode::getClass<
RawTowerContainer>(topNode, "TOWER_CALIB_HODO_VERTICAL");
//if(!_is_sim) assert(TOWER_CALIB_HODO_VERTICAL);
RawTowerContainer* TOWER_RAW_CEMC;
if(!_is_sim)
{
TOWER_RAW_CEMC = findNode::getClass<RawTowerContainer>(
topNode, "TOWER_RAW_CEMC");
}else{
TOWER_RAW_CEMC = findNode::getClass<RawTowerContainer>(
topNode, "TOWER_RAW_LG_CEMC");
}
assert(TOWER_RAW_CEMC);
RawTowerContainer* TOWER_CALIB_CEMC;
if(!_is_sim)
{
TOWER_CALIB_CEMC = findNode::getClass<RawTowerContainer>(
topNode, "TOWER_CALIB_CEMC");
} else {
TOWER_CALIB_CEMC = findNode::getClass<RawTowerContainer>(
topNode, "TOWER_CALIB_LG_CEMC");
}
assert(TOWER_CALIB_CEMC);
RawTowerContainer* TOWER_RAW_LG_HCALIN = 0;
RawTowerContainer* TOWER_RAW_HG_HCALIN = 0;
if(!_is_sim)
{
TOWER_RAW_LG_HCALIN = findNode::getClass<RawTowerContainer>(
topNode, "TOWER_RAW_LG_HCALIN");
TOWER_RAW_HG_HCALIN= findNode::getClass<RawTowerContainer>(
topNode, "TOWER_RAW_HG_HCALIN");
assert(TOWER_RAW_LG_HCALIN);
assert(TOWER_RAW_HG_HCALIN);
}
RawTowerContainer* TOWER_CALIB_HCALIN;
if(!_is_sim)
{
TOWER_CALIB_HCALIN = findNode::getClass<RawTowerContainer>(
topNode, "TOWER_CALIB_LG_HCALIN");
} else {
TOWER_CALIB_HCALIN = findNode::getClass<RawTowerContainer>(
topNode, "TOWER_CALIB_LG_HCALIN");
}
assert(TOWER_CALIB_HCALIN);
RawTowerContainer* TOWER_RAW_LG_HCALOUT = 0;
RawTowerContainer* TOWER_RAW_HG_HCALOUT = 0;
if(!_is_sim)
{
TOWER_RAW_LG_HCALOUT = findNode::getClass<RawTowerContainer>(
topNode, "TOWER_RAW_LG_HCALOUT");
TOWER_RAW_HG_HCALOUT = findNode::getClass<RawTowerContainer>(
topNode, "TOWER_RAW_HG_HCALOUT");
assert(TOWER_RAW_LG_HCALOUT);
assert(TOWER_RAW_HG_HCALOUT);
}
RawTowerContainer* TOWER_CALIB_HCALOUT = findNode::getClass<RawTowerContainer>(
topNode, "TOWER_CALIB_LG_HCALOUT");
assert(TOWER_CALIB_HCALOUT);
RawTowerContainer* TOWER_TEMPERATURE_EMCAL = findNode::getClass<
RawTowerContainer>(topNode, "TOWER_TEMPERATURE_EMCAL");
if(!_is_sim) assert(TOWER_TEMPERATURE_EMCAL);
RawTowerContainer* TOWER_CALIB_C1 = findNode::getClass<RawTowerContainer>(
topNode, "TOWER_CALIB_C1");
//if(!_is_sim) assert(TOWER_CALIB_C1);
RawTowerContainer* TOWER_CALIB_C2 = findNode::getClass<RawTowerContainer>(
topNode, "TOWER_CALIB_C2");
//if(!_is_sim) assert(TOWER_CALIB_C2);
if(!_is_sim && TOWER_CALIB_C2 && TOWER_CALIB_C1 && eventheader)
{
// Cherenkov
RawTower * t_c2_in = NULL;
RawTower * t_c2_out = NULL;
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;
_eval_run.C1 = c1;
bool cherekov_e = (_eval_run.C2_sum) > 100;
hNormalization->Fill("C2-e", cherekov_e);
bool cherekov_h = (_eval_run.C2_sum) < 20;
hNormalization->Fill("C2-h", cherekov_h);
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;
{
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;
{
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;
{
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;
const bool good_h = valid_hodo_v and valid_hodo_h and cherekov_h and trigger_veto_pass;
hNormalization->Fill("good_e", good_e);
hNormalization->Fill("good_h", good_h);
_eval_run.good_temp = 1;
_eval_run.good_e = good_e;
_eval_run.good_h = good_h;
}
// tower
double emcal_sum_energy_calib = 0;
double emcal_sum_energy_recalib = 0;
double hcalin_sum_energy_calib = 0;
double hcalin_sum_energy_recalib = 0;
double hcalout_sum_energy_calib = 0;
double hcalout_sum_energy_recalib = 0;
stringstream sdata;
//EMCAL towers
{
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 double energy_calib = tower->get_energy();
emcal_sum_energy_calib += energy_calib;
if(_is_sim) continue;
const int col = tower->get_column();
const int row = tower->get_row();
// recalibration
assert(
_emcal_recalib_const.find(make_pair(col, row)) != _emcal_recalib_const.end());
const double energy_recalib = energy_calib
* _emcal_recalib_const[make_pair(col, row)];
// energy sums
emcal_sum_energy_recalib += energy_recalib;
}
}
//HCALIN towers
{
auto range = TOWER_CALIB_HCALIN->getTowers();
for (auto it = range.first; it != range.second; ++it)
{
RawTower* tower = it->second;
assert(tower);
const double energy_calib = tower->get_energy();
hcalin_sum_energy_calib += energy_calib;
if(_is_sim) continue;
const int col = tower->get_column();
const int row = tower->get_row();
assert(
_hcalin_recalib_const.find(make_pair(col, row)) != _hcalin_recalib_const.end());
const double energy_recalib = energy_calib
* _hcalin_recalib_const[make_pair(col, row)];
hcalin_sum_energy_recalib += energy_recalib;
}
}
//HCALOUT towers
{
auto range = TOWER_CALIB_HCALOUT->getTowers();
for (auto it = range.first; it != range.second; ++it)
{
RawTower* tower = it->second;
assert(tower);
const double energy_calib = tower->get_energy();
hcalout_sum_energy_calib += energy_calib;
if(_is_sim) continue;
const int col = tower->get_column();
const int row = tower->get_row();
assert(
_hcalout_recalib_const.find(make_pair(col, row)) != _hcalout_recalib_const.end());
const double energy_recalib = energy_calib
* _hcalout_recalib_const[make_pair(col, row)];
hcalout_sum_energy_recalib += energy_recalib;
}
}
const double EoP = emcal_sum_energy_recalib / abs(_eval_run.beam_mom);
_eval_run.EoP = EoP;
// E/p
if (_eval_run.good_e)
{
if (verbosity >= 3)
cout << __PRETTY_FUNCTION__ << " sum_energy_calib = "
<< emcal_sum_energy_calib << " sum_energy_recalib = " << emcal_sum_energy_recalib
<< " _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
assert(fdata.is_open());
fdata << sdata.str();
fdata << endl;
_shower.emcal_e = emcal_sum_energy_calib;
_shower.hcalin_e = hcalin_sum_energy_calib;
_shower.hcalout_e = hcalout_sum_energy_calib;
_shower.sum_e = emcal_sum_energy_calib + hcalin_sum_energy_calib + hcalout_sum_energy_calib ;
_shower.hcal_asym = (hcalin_sum_energy_calib - hcalout_sum_energy_calib)/(hcalin_sum_energy_calib + hcalout_sum_energy_calib);
_shower.emcal_e_recal = emcal_sum_energy_recalib;
_shower.hcalin_e_recal = hcalin_sum_energy_recalib;
_shower.hcalout_e_recal = hcalout_sum_energy_recalib;
_shower.sum_e_recal = emcal_sum_energy_recalib + hcalin_sum_energy_recalib + hcalout_sum_energy_recalib ;
if(_fill_time_samples && !_is_sim)
{
//HCALIN
{
auto range = TOWER_RAW_LG_HCALIN->getTowers();
for (auto it = range.first; it != range.second; ++it)
{
RawTower_Prototype2* tower = dynamic_cast<RawTower_Prototype2 *>(it->second);
assert(tower);
int col = tower->get_column();
int row = tower->get_row();
int towerid = row + 4*col;
for(int isample=0; isample<24; isample++)
_time_samples.hcalin_time_samples[towerid][isample] =
tower->get_signal_samples(isample);
}
}
//HCALOUT
{
auto range = TOWER_RAW_LG_HCALOUT->getTowers();
for (auto it = range.first; it != range.second; ++it)
{
RawTower_Prototype2* tower = dynamic_cast<RawTower_Prototype2 *>(it->second);
assert(tower);
int col = tower->get_column();
int row = tower->get_row();
int towerid = row + 4*col;
for(int isample=0; isample<24; isample++)
_time_samples.hcalout_time_samples[towerid][isample] =
tower->get_signal_samples(isample);
}
}
//EMCAL
{
auto range = TOWER_RAW_CEMC->getTowers();
for (auto it = range.first; it != range.second; ++it)
{
RawTower_Prototype2* tower = dynamic_cast<RawTower_Prototype2 *>(it->second);
assert(tower);
int col = tower->get_column();
int row = tower->get_row();
int towerid = row + 8*col;
for(int isample=0; isample<24; isample++)
_time_samples.emcal_time_samples[towerid][isample] =
tower->get_signal_samples(isample);
}
}
}
TTree * T = dynamic_cast<TTree *>(hm->getHisto("T"));
assert(T);
T->Fill();
return Fun4AllReturnCodes::EVENT_OK;
}
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;
}