EcalADCToGeVHandler.cc

Go to the documentation of this file.

#include "CondTools/Ecal/interface/EcalADCToGeVHandler.h"
#include "FWCore/ParameterSet/interface/ParameterSetfwd.h"
#include "CondFormats/EcalObjects/interface/EcalIntercalibConstants.h"
#include "CondTools/Ecal/interface/EcalADCToGeVXMLTranslator.h"


#include<iostream>

popcon::EcalADCToGeVHandler::EcalADCToGeVHandler(const edm::ParameterSet & ps)
  :    m_name(ps.getUntrackedParameter<std::string>("name","EcalADCToGeVHandler")) {

    std::cout << "EcalADCToGeV Source handler constructor\n" << std::endl;
        m_firstRun=static_cast<unsigned int>(atoi( ps.getParameter<std::string>("firstRun").c_str()));
        m_lastRun=static_cast<unsigned int>(atoi( ps.getParameter<std::string>("lastRun").c_str()));
        m_sid= ps.getParameter<std::string>("OnlineDBSID");
        m_user= ps.getParameter<std::string>("OnlineDBUser");
        m_pass= ps.getParameter<std::string>("OnlineDBPassword");
        m_locationsource= ps.getParameter<std::string>("LocationSource");
        m_location=ps.getParameter<std::string>("Location");
        m_gentag=ps.getParameter<std::string>("GenTag");
        m_file_lowfield= ps.getParameter<std::string>("FileLowField");
        m_file_highfield= ps.getParameter<std::string>("FileHighField");



        std::cout << m_sid<<"/"<<m_user<<"/"<<m_location<<"/"<<m_gentag   << std::endl;


}

popcon::EcalADCToGeVHandler::~EcalADCToGeVHandler() {}


void popcon::EcalADCToGeVHandler::getNewObjects() {
  std::cout << "------- Ecal - > getNewObjects\n";

  std::ostringstream ss; 
  ss<<"ECAL ";

    unsigned int max_since=0;
    max_since=static_cast<unsigned int>(tagInfo().lastInterval.first);
    std::cout << "max_since : "  << max_since << std::endl;
  bool magnet_high = false; 
  bool something_to_transfer = false;
  if(tagInfo().size) {
    Ref ped_db = lastPayload();
    
    // we parse the last record in the DB and check if it is low or high field 

    std::cout << "retrieved last payload "  << std::endl;


    EcalADCToGeVConstant the_cal ;

    //unused    float adc_eb=ped_db->getEBValue();
    float adc_ee=ped_db->getEEValue();
 
    //  float the_value_high_eb=0.03894;
    //      float the_value_high_ee=0.06285;
    // float the_value_high_eb=0.03894;
    // float the_value_high_ee=0.06378;

    
    // bool magnet_high=true; 
    // if(adc_eb!= the_value_high_eb || adc_ee!= the_value_high_ee ) magnet_high=false; 


    //unused    float the_value_low_eb=0.03894;
    // Run 1 :  float the_value_low_ee=0.05678;
        float the_value_low_ee = 0.0590975;
        if( adc_ee > the_value_low_ee ) magnet_high = true;
  }  // check if there is already a payload
  else something_to_transfer = true;

  // here we connect to the online DB to check the value of the magnetic field 
    std::cout << "Connecting to ONLINE DB ... " << std::endl;
    econn = new EcalCondDBInterface( m_sid, m_user, m_pass );
    std::cout << "Connection done" << std::endl;
    

    std::cout << "Retrieving last run from ONLINE DB ... " << std::endl;
    std::map<EcalLogicID, RunDat> rundat;
    RunIOV rp ;
    run_t runmax=10000000;
    std::string location_p5="P5_Co";
    econn->fetchValidDataSet(&rundat , &rp, location_p5 ,runmax);
    
    unsigned long long  irun=(unsigned long long) rp.getRunNumber();

    std::cout<< "retrieved run number "<< irun <<std::endl;  

  if(irun>max_since) {
      // retrieve from last value data record 
      // always call this method at first run
      
      std::map<EcalLogicID, RunDCSMagnetDat> dataset;
      
      econn->fetchDataSet(&dataset, &rp);
      
      if (dataset.empty()) {
        throw(std::runtime_error("Zero rows read back"));
      } else {
        std::cout<< "retrieved magnet current"<<std::endl;  
      }
      
      float mag_cur=0;
      
      std::map<  EcalLogicID, RunDCSMagnetDat >::iterator it;
      for (it=dataset.begin(); it!=dataset.end(); ++it){
        
        RunDCSMagnetDat  a_mag = (*it).second;
        mag_cur= a_mag.getMagnetCurrent();
        
      }
      
      
      std::string file_=m_file_highfield;
    if(tagInfo().size) {
      if(mag_cur>7000. && magnet_high ) {
        
        std::cout << " the magnet is ON and the constants are for magnet ON " << std::endl; 
        
      } else if(mag_cur>7000. && !magnet_high ) {
        something_to_transfer=true;
        std::cout << " the magnet is ON and the constants are for magnet OFF " << std::endl; 
        std::cout << " I transfer the ON constants "<< std::endl; 
        file_=m_file_highfield;
        
      } else if(mag_cur<6000. && magnet_high ) {
        something_to_transfer=true;
        std::cout << " the magnet is OFF and the constants are for magnet ON "<< std::endl;
        std::cout << " I transfer the OFF constants "<< std::endl;
        file_=m_file_lowfield;
        
      } else if( mag_cur<6000. && !magnet_high ){
        
        std::cout << " the magnet is OFF and the constants are for magnet OFF "<< std::endl;
        file_=m_file_lowfield;
        
      } else {
        
        std::cout << " the magnet is in a strange situation I do nothing ... just be patient "<< std::endl;
        
      }
    }
    else {
      if(mag_cur>7000.)
    std::cout <<" first payload, the magnet is ON " << std::endl;
      else if( mag_cur<6000.) {
    std::cout <<" first payload, the magnet is OFF " << std::endl;
    file_=m_file_lowfield;
      }
      else
    std::cout << " the magnet is in a strange situation I do nothing ... just be patient "<< std::endl;
    }
      
    if(something_to_transfer) {
      std::cout << "Generating popcon record for run " << irun 
        << "  going to open file " << file_ << "\n" << std::flush;
      EcalADCToGeVConstant * payload = new EcalADCToGeVConstant;
      //      EcalCondHeader   header;   // DBv1
      //        EcalADCToGeVXMLTranslator::readXML(file_,header,*payload);   // DBv1
      // DBv2 poor xml file :-(
      std::ifstream fxml;
      fxml.open(file_.c_str());
      std::string line, bid, bid2;
      float val;
      for (int il = 0; il < 4; il++) {
    std::getline(fxml, line);
    //  std::cout << line << "\n";
      }
      for (int iPart = 0; iPart < 2; iPart++) {    //  EB, EE
    fxml >> bid;
    std::size_t begin = bid.find_first_of(">");
    std::size_t end = bid.find_last_of("<");
    begin++;
    std::string str2 = bid.substr(begin, end - begin);
    std::size_t endmantissa = str2.find("e");
    std::string mantissa = str2.substr(0, endmantissa);
    std::size_t string_size = str2.size();
    std::string exponent = str2.substr(endmantissa + 1, string_size);
    std::istringstream is(mantissa);
    is >> val;
    float mult;
    std::istringstream ise(exponent);
    ise >> mult;
    val = val * pow(10, mult);
    std::cout << " Partition " << iPart << " ADCToGeV " << val << "\n";
    if(iPart < 1) payload->setEBValue(val);
    else payload->setEEValue(val);
      }
      // end change for DBv2
        
      Time_t snc= (Time_t) irun ;
      popcon::PopConSourceHandler<EcalADCToGeVConstant>::m_to_transfer.push_back(std::make_pair(payload,snc));
      ss << "Run=" << irun << "_Magnet_changed_" << std::endl; 
      m_userTextLog = ss.str()+";";
    } else {
      std::cout << "Run " << irun << " nothing sent to the DB" << std::endl;
      ss<< "Run=" << irun << "_Magnet_NOT_changed_" << std::endl; 
      m_userTextLog = ss.str()+";";
    }
    
    delete econn;
  }  // irun > max_since
  else {
    std::cout << "Run " << irun << " nothing sent to the DB" << std::endl;
    ss<< "Run=" << irun << "_no_new_runs_"<<std::endl; 
    m_userTextLog = ss.str()+";";
  }
  std::cout << "Ecal - > end of getNewObjects -----------\n";
}