int Proto2ShowerCalib::End(PHCompositeNode *topNode) { cout << "Proto2ShowerCalib::End - write to " << _filename << endl; PHTFileServer::get().cd(_filename); Fun4AllHistoManager *hm = get_HistoManager(); assert(hm); for (unsigned int i = 0; i < hm->nHistos(); i++) hm->getHisto(i)->Write(); // if (_T_EMCalTrk) // _T_EMCalTrk->Write(); fdata.close(); return Fun4AllReturnCodes::EVENT_OK; }
int QAG4SimulationCalorimeter::process_event(PHCompositeNode *topNode) { if (verbosity > 2) cout << "QAG4SimulationCalorimeter::process_event() entered" << endl; if (_caloevalstack) _caloevalstack->next_event(topNode); if (flag(kProcessG4Hit)) { int ret = process_event_G4Hit(topNode); if (ret != Fun4AllReturnCodes::EVENT_OK) return ret; } if (flag(kProcessTower)) { int ret = process_event_Tower(topNode); if (ret != Fun4AllReturnCodes::EVENT_OK) return ret; } if (flag(kProcessCluster)) { int ret = process_event_Cluster(topNode); if (ret != Fun4AllReturnCodes::EVENT_OK) return ret; } // at the end, count success events Fun4AllHistoManager *hm = QAHistManagerDef::getHistoManager(); assert(hm); TH1D* h_norm = dynamic_cast<TH1D*>(hm->getHisto( get_histo_prefix() + "_Normalization")); assert(h_norm); h_norm->Fill("Event", 1); 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; }
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 QAG4SimulationCalorimeter::process_event_Cluster(PHCompositeNode *topNode) { if (verbosity > 2) cout << "QAG4SimulationCalorimeter::process_event_Cluster() entered" << endl; Fun4AllHistoManager *hm = QAHistManagerDef::getHistoManager(); assert(hm); 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; } //get a cluster count TH1D* h_norm = dynamic_cast<TH1D*>(hm->getHisto( get_histo_prefix() + "_Normalization")); assert(h_norm); std::string nodename = "CLUSTER_" + _calo_name; RawClusterContainer* clusters = findNode::getClass<RawClusterContainer>( topNode, nodename.c_str()); assert(clusters); h_norm->Fill("Cluster", clusters->size()); // get primary assert(_truth_container); assert(not _truth_container->GetMap().empty()); PHG4Particle * last_primary = _truth_container->GetMap().rbegin()->second; assert(last_primary); if (verbosity > 2) { cout << "QAG4SimulationCalorimeter::process_event_Cluster() handle this truth particle" << endl; last_primary->identify(); } assert(_caloevalstack); CaloRawClusterEval* clustereval = _caloevalstack->get_rawcluster_eval(); assert(clustereval); TH1F* h = dynamic_cast<TH1F*>(hm->getHisto( get_histo_prefix() + "_Cluster_BestMatchERatio")); assert(h); RawCluster* cluster = clustereval->best_cluster_from(last_primary); if (cluster) { // has a cluster matched and best cluster selected if (verbosity > 3) cout << "QAG4SimulationCalorimeter::process_event_Cluster::" << _calo_name << " - get cluster with energy " << cluster->get_energy() << " VS primary energy " << last_primary->get_e() << endl; h->Fill(cluster->get_energy() / (last_primary->get_e() + 1e-9)); //avoids divide zero // now work on the projection: const CLHEP::Hep3Vector hit(cluster->get_position()); const PHG4VtxPoint* primary_vtx = // _truth_container->GetPrimaryVtx(last_primary->get_vtx_id()); assert(primary_vtx); if (verbosity > 2) { cout << "QAG4SimulationCalorimeter::process_event_Cluster() handle this vertex" << endl; primary_vtx->identify(); } const CLHEP::Hep3Vector vertex(primary_vtx->get_x(), primary_vtx->get_y(), primary_vtx->get_z()); // projection axis CLHEP::Hep3Vector axis_proj(last_primary->get_px(), last_primary->get_py(), last_primary->get_pz()); if (axis_proj.mag() == 0) axis_proj.set(0, 0, 1); axis_proj = axis_proj.unit(); // azimuthal direction axis CLHEP::Hep3Vector axis_azimuth = axis_proj.cross(CLHEP::Hep3Vector(0, 0, 1)); if (axis_azimuth.mag() == 0) axis_azimuth.set(1, 0, 0); axis_azimuth = axis_azimuth.unit(); // polar direction axis CLHEP::Hep3Vector axis_polar = axis_proj.cross(axis_azimuth); assert(axis_polar.mag() > 0); axis_polar = axis_polar.unit(); TH2F * hlat = dynamic_cast<TH2F*>(hm->getHisto( get_histo_prefix() + "_Cluster_LateralTruthProjection")); assert(hlat); const double hit_azimuth = axis_azimuth.dot(hit - vertex); const double hit_polar = axis_polar.dot(hit - vertex); hlat->Fill(hit_polar, hit_azimuth); } else { if (verbosity > 3) cout << "QAG4SimulationCalorimeter::process_event_Cluster::" << _calo_name << " - missing cluster !"; h->Fill(0); // no cluster matched } return Fun4AllReturnCodes::EVENT_OK; }
int QAG4SimulationCalorimeter::process_event_Tower(PHCompositeNode *topNode) { const string detector(_calo_name); if (verbosity > 2) cout << "QAG4SimulationCalorimeter::process_event_Tower() entered" << endl; Fun4AllHistoManager *hm = QAHistManagerDef::getHistoManager(); assert(hm); TH1D* h_norm = dynamic_cast<TH1D*>(hm->getHisto( get_histo_prefix() + "_Normalization")); assert(h_norm); string towernodename = "TOWER_CALIB_" + detector; // 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_" + detector; RawTowerGeomContainer *towergeom = findNode::getClass<RawTowerGeomContainer>( topNode, towergeomnodename.c_str()); if (!towergeom) { cout << PHWHERE << ": Could not find node " << towergeomnodename.c_str() << endl; return Fun4AllReturnCodes::ABORTRUN; } static const int max_size = 5; map<int, string> size_label; size_label[1] = "1x1"; size_label[2] = "2x2"; size_label[3] = "3x3"; size_label[4] = "4x4"; size_label[5] = "5x5"; map<int, double> max_energy; map<int, TH1F*> energy_hist_list; map<int, TH1F*> max_energy_hist_list; for (int size = 1; size <= max_size; ++size) { max_energy[size] = 0; TH1F* h = dynamic_cast<TH1F*>(hm->getHisto( get_histo_prefix() + "_Tower_" + size_label[size])); assert(h); energy_hist_list[size] = h; h = dynamic_cast<TH1F*>(hm->getHisto( get_histo_prefix() + "_Tower_" + size_label[size] + "_max")); assert(h); max_energy_hist_list[size] = h; } h_norm->Fill("Tower", towergeom->size()); // total tower count h_norm->Fill("Tower Hit", towers->size()); for (int binphi = 0; binphi < towergeom->get_phibins(); ++binphi) { for (int bineta = 0; bineta < towergeom->get_etabins(); ++bineta) { for (int size = 1; size <= max_size; ++size) { // for 2x2 and 4x4 use slide-2 window as implemented in DAQ if ((size == 2 or size == 4) and ((binphi % 2 != 0) and (bineta % 2 != 0))) continue; double energy = 0; // sliding window made from 2x2 sums for (int iphi = binphi; iphi < binphi + size; ++iphi) { for (int ieta = bineta; ieta < bineta + size; ++ieta) { if (ieta > towergeom->get_etabins()) continue; // wrap around int wrapphi = iphi; assert(wrapphi >= 0); if (wrapphi >= towergeom->get_phibins()) { wrapphi = wrapphi - towergeom->get_phibins(); } RawTower* tower = towers->getTower(ieta, wrapphi); if (tower) { const double e_intput = tower->get_energy(); energy += e_intput; } } } energy_hist_list[size]->Fill(energy == 0 ? 9.1e-4 : energy); // trick to fill 0 energy tower to the first bin if (energy > max_energy[size]) max_energy[size] = energy; } // for (int size = 1; size <= 4; ++size) } } for (int size = 1; size <= max_size; ++size) { max_energy_hist_list[size]->Fill(max_energy[size]); } return Fun4AllReturnCodes::EVENT_OK; }
int QAG4SimulationCalorimeter::process_event_G4Hit(PHCompositeNode *topNode) { if (verbosity > 2) cout << "QAG4SimulationCalorimeter::process_event_G4Hit() entered" << endl; TH1F* h = nullptr; Fun4AllHistoManager *hm = QAHistManagerDef::getHistoManager(); assert(hm); TH1D* h_norm = dynamic_cast<TH1D*>(hm->getHisto( get_histo_prefix() + "_Normalization")); assert(h_norm); // get primary assert(_truth_container); PHG4TruthInfoContainer::ConstRange primary_range = _truth_container->GetPrimaryParticleRange(); double total_primary_energy = 1e-9; //make it zero energy epsilon samll so it can be used for denominator for (PHG4TruthInfoContainer::ConstIterator particle_iter = primary_range.first; particle_iter != primary_range.second; ++particle_iter) { const PHG4Particle *particle = particle_iter->second; assert(particle); total_primary_energy += particle->get_e(); } assert(not _truth_container->GetMap().empty()); const PHG4Particle * last_primary = _truth_container->GetMap().rbegin()->second; assert(last_primary); if (verbosity > 2) { cout << "QAG4SimulationCalorimeter::process_event_G4Hit() handle this truth particle" << endl; last_primary->identify(); } const PHG4VtxPoint* primary_vtx = // _truth_container->GetPrimaryVtx(last_primary->get_vtx_id()); assert(primary_vtx); if (verbosity > 2) { cout << "QAG4SimulationCalorimeter::process_event_G4Hit() handle this vertex" << endl; primary_vtx->identify(); } const double t0 = primary_vtx->get_t(); const TVector3 vertex(primary_vtx->get_x(), primary_vtx->get_y(), primary_vtx->get_z()); // projection axis TVector3 axis_proj(last_primary->get_px(), last_primary->get_py(), last_primary->get_pz()); if (axis_proj.Mag() == 0) axis_proj.SetXYZ(0, 0, 1); axis_proj = axis_proj.Unit(); // azimuthal direction axis TVector3 axis_azimuth = axis_proj.Cross(TVector3(0, 0, 1)); if (axis_azimuth.Mag() == 0) axis_azimuth.SetXYZ(1, 0, 0); axis_azimuth = axis_azimuth.Unit(); // polar direction axis TVector3 axis_polar = axis_proj.Cross(axis_azimuth); assert(axis_polar.Mag() > 0); axis_polar = axis_polar.Unit(); double e_calo = 0.0; // active energy deposition double ev_calo = 0.0; // visible energy double ea_calo = 0.0; // absorber energy double ev_calo_em = 0.0; // EM visible energy if (_calo_hit_container) { TH2F * hrz = dynamic_cast<TH2F*>(hm->getHisto( get_histo_prefix() + "_G4Hit_RZ")); assert(hrz); TH2F * hxy = dynamic_cast<TH2F*>(hm->getHisto( get_histo_prefix() + "_G4Hit_XY")); assert(hxy); TH1F * ht = dynamic_cast<TH1F*>(hm->getHisto( get_histo_prefix() + "_G4Hit_HitTime")); assert(ht); TH2F * hlat = dynamic_cast<TH2F*>(hm->getHisto( get_histo_prefix() + "_G4Hit_LateralTruthProjection")); assert(hlat); h_norm->Fill("G4Hit Active", _calo_hit_container->size()); PHG4HitContainer::ConstRange calo_hit_range = _calo_hit_container->getHits(); for (PHG4HitContainer::ConstIterator hit_iter = calo_hit_range.first; hit_iter != calo_hit_range.second; hit_iter++) { PHG4Hit *this_hit = hit_iter->second; assert(this_hit); e_calo += this_hit->get_edep(); ev_calo += this_hit->get_light_yield(); // EM visible energy that is only associated with electron energy deposition PHG4Particle* particle = _truth_container->GetParticle( this_hit->get_trkid()); if (!particle) { cout <<__PRETTY_FUNCTION__<<" - Error - this PHG4hit missing particle: "; this_hit -> identify(); } assert(particle); if (abs(particle->get_pid()) == 11) ev_calo_em += this_hit->get_light_yield(); const TVector3 hit(this_hit->get_avg_x(), this_hit->get_avg_y(), this_hit->get_avg_z()); hrz->Fill(hit.Z(), hit.Perp(), this_hit->get_edep()); hxy->Fill(hit.X(), hit.Y(), this_hit->get_edep()); ht->Fill(this_hit->get_avg_t() - t0, this_hit->get_edep()); const double hit_azimuth = axis_azimuth.Dot(hit - vertex); const double hit_polar = axis_polar.Dot(hit - vertex); hlat->Fill(hit_polar, hit_azimuth, this_hit->get_edep()); } } if (_calo_abs_hit_container) { h_norm->Fill("G4Hit Absor.", _calo_abs_hit_container->size()); PHG4HitContainer::ConstRange calo_abs_hit_range = _calo_abs_hit_container->getHits(); for (PHG4HitContainer::ConstIterator hit_iter = calo_abs_hit_range.first; hit_iter != calo_abs_hit_range.second; hit_iter++) { PHG4Hit *this_hit = hit_iter->second; assert(this_hit); ea_calo += this_hit->get_edep(); } } if (verbosity > 3) cout << "QAG4SimulationCalorimeter::process_event_G4Hit::" << _calo_name << " - SF = " << e_calo / (e_calo + ea_calo + 1e-9) << ", VSF = " << ev_calo / (e_calo + ea_calo + 1e-9) << endl; if (e_calo + ea_calo > 0) { h = dynamic_cast<TH1F*>(hm->getHisto(get_histo_prefix() + "_G4Hit_SF")); assert(h); h->Fill(e_calo / (e_calo + ea_calo)); h = dynamic_cast<TH1F*>(hm->getHisto(get_histo_prefix() + "_G4Hit_VSF")); assert(h); h->Fill(ev_calo / (e_calo + ea_calo)); } h = dynamic_cast<TH1F*>(hm->getHisto( get_histo_prefix() + "_G4Hit_FractionTruthEnergy")); assert(h); h->Fill((e_calo + ea_calo) / total_primary_energy); if (ev_calo > 0) { h = dynamic_cast<TH1F*>(hm->getHisto( get_histo_prefix() + "_G4Hit_FractionEMVisibleEnergy")); assert(h); h->Fill(ev_calo_em / (ev_calo)); } if (verbosity > 3) cout << "QAG4SimulationCalorimeter::process_event_G4Hit::" << _calo_name << " - histogram " << h->GetName() << " Get Sum = " << h->GetSum() << endl; return Fun4AllReturnCodes::EVENT_OK; }