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;
}
Beispiel #2
0
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;
}