/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_6_2_5/src/CondTools/Ecal/src/EcalSRPHandler.cc

Go to the documentation of this file.

#include<iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <xercesc/dom/DOMNode.hpp>
#include <xercesc/dom/DOM.hpp>
#include <xercesc/parsers/XercesDOMParser.hpp>
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/sax/SAXException.hpp>
#include <xercesc/framework/LocalFileFormatTarget.hpp>

#include "CondTools/Ecal/interface/EcalSRPHandler.h"
#include "CondTools/Ecal/interface/EcalCondHeader.h"
#include "CondTools/Ecal/interface/DOMHelperFunctions.h"
#include "DataFormats/EcalDetId/interface/EcalSubdetector.h"
#include "CondFormats/EcalObjects/interface/EcalSRSettings.h"

#include "OnlineDB/EcalCondDB/interface/RunConfigDat.h"
#include "OnlineDB/EcalCondDB/interface/ODRunConfigInfo.h"
#include "OnlineDB/EcalCondDB/interface/ODRunConfigSeqInfo.h"

#include "OnlineDB/EcalCondDB/interface/FEConfigMainInfo.h"
#include "OnlineDB/EcalCondDB/interface/FEConfigBadTTInfo.h"

#include "FWCore/ParameterSet/interface/ParameterSetfwd.h"

#include "SimCalorimetry/EcalSelectiveReadoutProducers/interface/EcalSRCondTools.h"

using namespace XERCES_CPP_NAMESPACE;
using namespace xuti;

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

  m_firstRun =(unsigned long)atoi( ps.getParameter<std::string>("firstRun").c_str());
  m_lastRun  =(unsigned long)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_location = ps.getParameter<std::string>("location"); 
  m_runtype  = ps.getParameter<std::string>("runtype"); 
  m_gentag   = ps.getParameter<std::string>("gentag"); 
  m_i_tag    = "";
  m_debug    = ps.getParameter<bool>("debug"); 
  m_i_version= 0;

}

popcon::EcalSRPHandler::~EcalSRPHandler() {}

void popcon::EcalSRPHandler::getNewObjects() {

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

  unsigned long long max_since = 1;

  // this is the last inserted run 
  max_since = tagInfo().lastInterval.first;

  // this is the last object in the DB 
  Ref srp_db = lastPayload();
  if(m_debug)
    std::cout << " max_since : "  << max_since
              << "\n retrieved last payload "  << std::endl;

  // we copy the last valid record to a temporary object
  EcalSRSettings* sref = new EcalSRSettings();
  sref->deltaEta_ = srp_db->deltaEta_;
  sref->deltaPhi_ = srp_db->deltaPhi_;
  sref->ecalDccZs1stSample_ = srp_db->ecalDccZs1stSample_;
  sref->ebDccAdcToGeV_ = srp_db->ebDccAdcToGeV_;
  sref->eeDccAdcToGeV_ = srp_db->eeDccAdcToGeV_;
  sref->dccNormalizedWeights_ = srp_db->dccNormalizedWeights_;
  sref->symetricZS_ = srp_db->symetricZS_;
  sref->srpLowInterestChannelZS_ = srp_db->srpLowInterestChannelZS_;
  sref->srpHighInterestChannelZS_ = srp_db->srpHighInterestChannelZS_;
  sref->actions_ = srp_db->actions_;
  sref->tccMasksFromConfig_ = srp_db->tccMasksFromConfig_;
  sref->srpMasksFromConfig_ = srp_db->srpMasksFromConfig_;
  sref->dccMasks_ = srp_db->dccMasks_;
  sref->srfMasks_ = srp_db->srfMasks_;
  sref->substitutionSrfs_= srp_db->substitutionSrfs_;
  sref->testerTccEmuSrpIds_ = srp_db->testerTccEmuSrpIds_;
  sref->testerSrpEmuSrpIds_ = srp_db->testerSrpEmuSrpIds_;
  sref->testerDccTestSrpIds_ = srp_db->testerDccTestSrpIds_;
  sref->testerSrpTestSrpIds_ = srp_db->testerSrpTestSrpIds_;
  sref->bxOffsets_ = srp_db->bxOffsets_;
  sref->bxGlobalOffset_ = srp_db->bxGlobalOffset_;
  sref->automaticMasks_ = srp_db->automaticMasks_;
  sref->automaticSrpSelect_ = srp_db->automaticSrpSelect_;

  // now read the actual status from the online DB

  std::cout << "Retrieving DAQ status from OMDS DB ... " << std::endl;
  econn = new EcalCondDBInterface( m_sid, m_user, m_pass );
  std::cout << "Connection done" << std::endl;
        
  if (!econn) {
    std::cout << " Problem with OMDS: connection parameters " << m_sid << "/" << m_user << std::endl;
    throw cms::Exception("OMDS not available");
  }

  LocationDef my_locdef;
  my_locdef.setLocation(m_location); 

  RunTypeDef my_rundef;
  my_rundef.setRunType(m_runtype); 

  RunTag my_runtag;
  my_runtag.setLocationDef( my_locdef );
  my_runtag.setRunTypeDef( my_rundef );
  my_runtag.setGeneralTag(m_gentag); 

  // range of validity
  int min_run = 0;
  if(m_firstRun <= (unsigned long)max_since) {
    min_run=  (int)max_since+1;    // we have to add 1 to the last transferred one
  } 
  else { min_run=(int)m_firstRun; }

  int max_run=(int)m_lastRun;
  if(m_debug)
    std::cout << "min_run " << min_run << " max_run " << max_run << std::endl;

  std::ofstream fout;
  if(m_debug) {
    char outfile[800];
    sprintf(outfile,"SRP_run%d.txt",min_run);
    fout.open(outfile, std::fstream::out);
    fout << " ORCOFF last run max_since : "  << max_since << std::endl;
    PrintPayload(*sref, fout);
  }

  RunList my_list; 
  my_list = econn->fetchRunListByLocation(my_runtag, min_run, max_run, my_locdef); 
              
  std::vector<RunIOV> run_vec = my_list.getRuns();
  int num_runs = run_vec.size();

  if(m_debug) {
    fout << " number of runs is : " << num_runs << std::endl;
  }
  unsigned long irun = 0;
  if(num_runs > 0){
    int fe_conf_id_old = 0;
    //    int krmax = std::min(num_runs, 100);
    //    for(int kr = 0; kr < krmax; kr++) {
    for(int kr = 0; kr < num_runs; kr++) {  // allow any number of runs, exit on transfert size
      irun = (unsigned long) run_vec[kr].getRunNumber();
      std::string geneTag = run_vec[kr].getRunTag().getGeneralTag();
      if(geneTag != "GLOBAL") {
        if(m_debug)
          fout <<  "\n New run " << irun << " with tag " << geneTag << " giving up " << std::endl;
        continue;
      }
      if(m_debug)
        fout << "\n New run " << irun << " geneTag " << geneTag << std::endl;

      // First, RUN_CONFIGURATION
      std::map<EcalLogicID, RunConfigDat> dataset;
      econn->fetchDataSet(&dataset, &run_vec[kr]);
      std::string myconfig_tag = "";
      int myconfig_version = 0;
      std::map< EcalLogicID, RunConfigDat>::const_iterator it;
      if(dataset.size() != 1) {
        std::cout << "\n\n run " << irun << " strange number of dataset "
                  << dataset.size() << std::endl;
        if(m_debug)
          fout << "\n\n run " << irun << " strange number of dataset "
               << dataset.size() << " giving up " << std::endl;
        continue;
      }

      it = dataset.begin();
      RunConfigDat dat = it->second;
      myconfig_tag = dat.getConfigTag();
      if(myconfig_tag.substr(0,15) == "ZeroSuppression") {
        if(m_debug)
          fout << " run " << irun << " tag " << myconfig_tag << " giving up " << std::endl;
        continue;
      }

      // Now  FE_DAQ_CONFIG
      typedef std::map<EcalLogicID, RunFEConfigDat>::const_iterator feConfIter;
      std::map<EcalLogicID, RunFEConfigDat> feconfig;
      econn->fetchDataSet(&feconfig, &run_vec[kr]);
      if(feconfig.size() != 1) {
        if(m_debug)
          fout << "\n\n run " << irun << " strange number of FE config "
               << feconfig.size() << " giving up " << std::endl;
        continue;
      }
      RunFEConfigDat rd_fe;
      int fe_conf_id = 0;
      feConfIter p=feconfig.begin();
      rd_fe   = p->second;
      fe_conf_id = rd_fe.getConfigId();

      myconfig_version = dat.getConfigVersion();
      if(m_debug)
        fout << " run " << irun << " tag " << myconfig_tag 
             << " version " << myconfig_version 
             << " Fe config " << fe_conf_id << std::endl;
      // here we should check if it is the same as previous run.
      if(myconfig_tag != m_i_tag || myconfig_version != m_i_version || fe_conf_id != fe_conf_id_old) {
        if(m_debug)
          fout << " run= " << irun 
               << " different tag  ... retrieving last config set from DB" << std::endl;

        bool FromCLOB = false;
        EcalSRSettings* sr = new EcalSRSettings;
        sr->ebDccAdcToGeV_ = 0.035;
        sr->eeDccAdcToGeV_ = 0.060;
        sr->symetricZS_.push_back(0);

        ODRunConfigInfo od_run_info;
        od_run_info.setTag(myconfig_tag);
        od_run_info.setVersion(myconfig_version);

        try { 
          econn-> fetchConfigSet(&od_run_info);
          int config_id = od_run_info.getId();

          ODRunConfigSeqInfo seq;
          seq.setEcalConfigId(config_id);
          seq.setSequenceNumber(0);
          econn-> fetchConfigSet(&seq);
          int sequenceid = seq.getSequenceId();

          ODEcalCycle ecal_cycle;
          ecal_cycle.setSequenceId(sequenceid);
          econn-> fetchConfigSet(&ecal_cycle);
          int cycle_id = ecal_cycle.getId();
          int srp_id = ecal_cycle.getSRPId();
          if(srp_id == 0) {
            if(m_debug)
              fout << " no SRP config for this run, give up " << std::endl;
            delete sr;
            continue;    //  no SRP config
          }
          int dcc_id = ecal_cycle.getDCCId();
          if(m_debug)
            fout << " cycleid " << cycle_id << " SRP id " << srp_id << " DCC id " << dcc_id << std::endl;
            /**************************/
           /*          SRP           */ 
          /**************************/
          ODSRPConfig srp;
          srp.setId(srp_id);
          econn-> fetchConfigSet(&srp);

          unsigned char* cbuffer = srp.getSRPClob();
          unsigned int SRPClobSize = srp.getSRPClobSize();
          std::string srpstr((char*)cbuffer, SRPClobSize);
          std::string SRPClob = srpstr;
          std::fstream myfile;
          myfile.open ("srp.txt", std::fstream::out);
          for (std::string::iterator it = SRPClob.begin() ; it < SRPClob.end(); it++ )
            myfile << *it;
          myfile.close();
          std::ifstream f("srp.txt");
          if(!f.good()){
            throw cms::Exception("EcalSRPHandler") << " Failed to open file srp.txt";
            if(m_debug)
              fout << " Failed to open file srp.txt" << std::endl;
          }
          EcalSRCondTools::importSrpConfigFile(*sr, f, m_debug);
          f.close();
          int rv = system("rm srp.txt");
          if(m_debug && rv != 0) fout << "rm srp.txt result code: " << rv << "\n";

          sr->bxGlobalOffset_ = srp.getSRP0BunchAdjustPosition();
          sr->automaticMasks_ = srp.getAutomaticMasks();
          sr->automaticSrpSelect_ = srp.getAutomaticSrpSelect();
            /**************************/
           /*          DCC           */ 
          /**************************/
          ODDCCConfig dcc;
          dcc.setId(dcc_id);
          econn-> fetchConfigSet(&dcc);
          std::string weightsMode = dcc.getDCCWeightsMode();
          if(m_debug)
            fout << " DCC weightsMode " << weightsMode << std::endl
                 << " weight size beg " <<  sr->dccNormalizedWeights_.size() << std::endl;
          if(weightsMode == "CLOB") {
            FromCLOB = true;
            if(m_debug)
              fout << " will read weights from DCC CLOB " << std::endl;
          }
          cbuffer = dcc.getDCCClob();
          unsigned int DCCClobSize = dcc.getDCCClobSize();
          std::string dccstr((char*)cbuffer, DCCClobSize);
          std::string DCCClob = dccstr;
          std::ostringstream osd;
          osd << "dcc.txt";
          std::string fname = osd.str();
          myfile.open (fname.c_str(), std::fstream::out);
          for (std::string::iterator it = DCCClob.begin() ; it < DCCClob.end(); it++ )
            myfile << *it;
          myfile.close();
          importDccConfigFile(*sr, fname, FromCLOB);
          if(m_debug)
            fout << " weight size after CLOB " <<  sr->dccNormalizedWeights_.size() << std::endl;
          rv = system("rm dcc.txt");
          if(m_debug && rv != 0) fout << "rm dcc.txt result code: " << rv << "\n";
        }
        catch (std::exception &e) { 
          // we should not come here... 
          std::cout << "ERROR: This config does not exist: tag " << myconfig_tag
                    <<" version "<< myconfig_version<< std::endl;
          if(m_debug)
            fout << "ERROR: This config does not exist: tag " << myconfig_tag
                 <<" version "<< myconfig_version<< std::endl;
          //        m_i_run_number = irun;
        }
        if(m_debug)
          fout << " FromCLOB " << FromCLOB << std::endl;
        if(!FromCLOB) {  // data from FE, we need to get FE_DAQ_CONFIG table
          // reading this configuration
          ODFEDAQConfig myconfig;
          myconfig.setId(fe_conf_id);
          econn->fetchConfigSet(&myconfig);

          // list weights
          int mywei = myconfig.getWeightId();
          if(m_debug)
            fout << " WEI_ID " << mywei << std::endl;

          if(mywei != 0) {
            ODWeightsSamplesDat samp;
            samp.setId(mywei);
            econn->fetchConfigSet(&samp);
            int mySample = samp.getSampleId();
            if(m_debug)
              fout << " SAMPLE_ID " << mySample << std::endl;
            sr->ecalDccZs1stSample_.push_back(mySample);

            ODWeightsDat weights;
            weights.setId(mywei);
            econn->fetchConfigSet(&weights);

            std::vector<std::vector<float> > my_dccw =  weights.getWeight();
            int imax = my_dccw.size();
            if(m_debug)
              fout << " weight size before check " << imax << std::endl;
            if(imax == 75848) {  // all the channel present. Check for change
              bool WeightsChange = false, WeightsChangeEB = false, WeightsChangeEE = false;
              for (int i = 1; i < 61200 ; i++)   // EB
                for (int ich = 0; ich < 6 ; ich++) 
                  if(my_dccw[i][ich] != my_dccw[0][ich]) WeightsChangeEB = true;
              if(m_debug)
                fout << " WeightsChangeEB " << WeightsChangeEB << std::endl;
              for(int i = 61201; i < 75848 ; i++)   // EE
                for (int ich = 0; ich < 6 ; ich++) 
                  if(my_dccw[i][ich] != my_dccw[61200][ich]) WeightsChangeEE = true;
              if(m_debug)
                fout << " WeightsChangeEE " << WeightsChangeEE << std::endl;
              for(int ich = 0; ich < 6 ; ich++) 
                if(my_dccw[0][ich] != my_dccw[61200][ich]) WeightsChange = true;
              if(m_debug)
                fout << " WeightsChange " << WeightsChange << std::endl;

              if(WeightsChangeEB || WeightsChangeEE)  // differences between channels, keep them all
                sr->dccNormalizedWeights_ = my_dccw;
              else if (WeightsChange) {  // difference between EB and EE, keep only 1 channel from each
                std::vector<float> dccwRowEB, dccwRowEE;
                for (int ich = 0; ich < 6 ; ich++) {
                  dccwRowEB.push_back(my_dccw[0][ich]);
                  dccwRowEE.push_back(my_dccw[61200][ich]);
                }
                sr->dccNormalizedWeights_.push_back(dccwRowEB);
                sr->dccNormalizedWeights_.push_back(dccwRowEE);
              }
              else {  // no difference keep only one
                std::vector<float> dccwRow;
                for (int ich = 0; ich < 6 ; ich++) {
                  dccwRow.push_back(my_dccw[0][ich]);
                }
                sr->dccNormalizedWeights_.push_back(dccwRow);
                if(m_debug) {
                  fout << " weight ";
                  for(int ich = 0; ich < 6 ; ich++) 
                    fout << " ch " << ich << " " <<  sr->dccNormalizedWeights_[0][ich] ;
                  fout << std::endl;
                }
              }
            }   // all channels
            else {
              sr->dccNormalizedWeights_ = my_dccw;
            }
            if(m_debug)
              fout << " weight size after DB " <<  sr->dccNormalizedWeights_.size() << std::endl;
          } // WEI_ID != 0
        }  // weights got from FE

        // check if we have found the weights
        if(sr->dccNormalizedWeights_.size() == 0) {  // use the firmware default weights
          //          float opt[] = { -383, -383, -372, 279, 479, 380};
          float def[] = {-1215,   20,  297, 356, 308, 232};
          std::vector<float> dccw(def,def+6);
          if(m_debug)
            fout << " default weights " ;
          for(int i = 0; i < 6; i++) {
            if(m_debug)
              fout << " i " << i << " def " << def [i] << " dccw " << dccw[i] << " \n";
          }
          sr->dccNormalizedWeights_.push_back(dccw);  // vector vector
        }
        // normalize online weights
        int imax = sr->dccNormalizedWeights_.size();
        if(m_debug)
          fout << " weight size " << imax << " normalized weights : "<< std::endl;
        for(int i = 0; i < imax ; i++)
          for(int ich = 0; ich < 6 ; ich++) {
            sr->dccNormalizedWeights_[i][ich] /= 1024.;
            if (m_debug && i == 0) 
              fout << " ch " << ich << " weight " <<  sr->dccNormalizedWeights_[i][ich] << std::endl;
          }

          /**************************/
         /*  checking for change   */
        /**************************/
        if(m_debug)
          fout << " checking for change " << std::endl;
        bool nochange = true;
        int imaxref, imaxnew;

        if(sref->deltaEta_ != sr->deltaEta_) {
          nochange = false;
          if(m_debug) {
            imaxref = sref->deltaEta_.size();
            imaxnew = sr->deltaEta_.size();
            if(imaxref != imaxnew) {
              fout << " deltaEta_ size ref " << imaxref << " now " << imaxnew << std::endl;
            }
            else {
              for(int i = 0; i < imaxref ; i++) {
                if(sref->deltaEta_[i]  != sr->deltaEta_[i]) {
                  fout << " deltaEta_[" << i << "] ref "<< sref->deltaEta_[i] 
                       << " now " <<sr->deltaEta_[i] << std::endl;
                }
              }
            }
          }
        }

        if(sref->deltaPhi_ != sr->deltaPhi_) {
          nochange = false;
          if(m_debug) {
            imaxref = sref->deltaPhi_.size();
            imaxnew = sr->deltaPhi_.size();
            if(imaxref != imaxnew) {
              fout << " deltaPhi size ref " << imaxref << " now " << imaxnew << std::endl;
            }
            else {
              for(int i = 0; i < imaxref ; i++) {
                if(sref->deltaPhi_[i]  != sr->deltaPhi_[i]) {
                  fout << " deltaPhi[" << i << "] ref "<< sref->deltaPhi_[i] 
                       << " now " <<sr->deltaPhi_[i] << std::endl;
                }
              }
            }
          }
        }

        if(sref->ecalDccZs1stSample_ != sr->ecalDccZs1stSample_) {
          nochange = false;
          if(m_debug) {
            imaxref = sref->ecalDccZs1stSample_.size();
            imaxnew = sr->ecalDccZs1stSample_.size();
            if(imaxref != imaxnew) {
              fout << " ecalDccZs1stSample size ref " << imaxref << " now " << imaxnew << std::endl;
            }
            else {
              for(int i = 0; i < imaxref ; i++) {
                if(sref->ecalDccZs1stSample_[i]  != sr->ecalDccZs1stSample_[i]) {
                  fout << " ecalDccZs1stSample_[" << i << "] ref "<< sref->ecalDccZs1stSample_[i] 
                       << " now " <<sr->ecalDccZs1stSample_[i] << std::endl;
                }
              }
            }
          }
        }

        if(sref->ebDccAdcToGeV_  != sr->ebDccAdcToGeV_ || sref->eeDccAdcToGeV_  != sr->eeDccAdcToGeV_) {
          nochange = false;
          if(m_debug)
            fout << " ebDccAdcToGeV ref " << sref->ebDccAdcToGeV_ << " ee " << sref->eeDccAdcToGeV_
                 << " now " << sr->ebDccAdcToGeV_ << " ee " << sr->eeDccAdcToGeV_ << std::endl;
        }

        if(sref->dccNormalizedWeights_ != sr->dccNormalizedWeights_) {
          nochange = false;
          if(m_debug) {
            imaxref = sref->dccNormalizedWeights_.size();
            imaxnew = sr->dccNormalizedWeights_.size();
            if(imaxref != imaxnew) {
              fout << " dccNormalizedWeights size ref " << imaxref << " now " << imaxnew << std::endl;
            }
            else {
              int i = 0;
              for(int ich = 0; ich < 6 ; ich++) {
                if(sref->dccNormalizedWeights_[i][ich]  != sr->dccNormalizedWeights_[i][ich]) {
                  fout << " dccNormalizedWeights_[" << i << "][" << ich << "] ref "
                       << sref->dccNormalizedWeights_[i][ich] 
                       << " now " << sr->dccNormalizedWeights_[i][ich] << std::endl;
                }
              }
            }
          }
        }

        if(sref->symetricZS_ != sr->symetricZS_) {
          nochange = false;
          if(m_debug) {
            imaxref = sref->symetricZS_.size();
            imaxnew = sr->symetricZS_.size();
            if(imaxref != imaxnew) {
              fout << " symetricZS size ref " << imaxref << " now " << imaxnew << std::endl;
            }
            else {
              for(int i = 0; i < imaxref ; i++) {
                if(sref->symetricZS_[i]  != sr->symetricZS_[i]) {
                  fout << " symetricZS[" << i << "] ref "<< sref->symetricZS_[i] 
                       << " now " <<sr->symetricZS_[i] << std::endl;
                }
              }
            }
          }
        }

        if(sref->srpLowInterestChannelZS_ != sr->srpLowInterestChannelZS_) {
          nochange = false;
          if(m_debug) {
            imaxref = sref->srpLowInterestChannelZS_.size();
            imaxnew = sr->srpLowInterestChannelZS_.size();
            if(imaxref != imaxnew) {
              fout << " srpLowInterestChannelZS size ref " << imaxref << " now " << imaxnew << std::endl;
            }
            else {
              for(int i = 0; i < imaxref ; i++) {
                if(sref->srpLowInterestChannelZS_[i]  != sr->srpLowInterestChannelZS_[i]) {
                  fout << " srpLowInterestChannelZS[" << i << "] ref "<< sref->srpLowInterestChannelZS_[i] 
                       << " now " <<sr->srpLowInterestChannelZS_[i] << std::endl;
                }
              }
            }
          }
        }

        if(sref->srpHighInterestChannelZS_ != sr->srpHighInterestChannelZS_) {
          nochange = false;
          if(m_debug) {
            imaxref = sref->srpHighInterestChannelZS_.size();
            imaxnew = sr->srpHighInterestChannelZS_.size();
            if(imaxref != imaxnew) {
              fout << " srpHighInterestChannelZS size ref " << imaxref << " now " << imaxnew << std::endl;
            }
            else {
              for(int i = 0; i < imaxref ; i++) {
                if(sref->srpHighInterestChannelZS_[i]  != sr->srpHighInterestChannelZS_[i]) {
                  fout << " srpHighInterestChannelZS[" << i << "] ref "<< sref->srpHighInterestChannelZS_[i] 
                       << " now " <<sr->srpHighInterestChannelZS_[i] << std::endl;
                }
              }
            }
          }
        }

        if(sref->actions_ != sr->actions_) {
          nochange = false;
          if(m_debug) {
            for(int i = 0; i < 4; i++) {
              if(sref->actions_[i] != sr->actions_[i]) {
                fout << " actions " << i <<" ref " << sref->actions_[i] 
                     << " now " << sr->actions_[i] << std::endl;
              }
            }
          }
        }

        if(sref->tccMasksFromConfig_ != sr->tccMasksFromConfig_) {
          nochange = false;
          if(m_debug) {
            for(int i = 0; i < 108; i++) {
              if(sref->tccMasksFromConfig_[i] != sr->tccMasksFromConfig_[i]) {
                fout << " tccMasks " << i << " ref " << sref->tccMasksFromConfig_[i] 
                     << " now " << sr->tccMasksFromConfig_[i] << std::endl;
              }
            }
          }
        }

        if(sref->srpMasksFromConfig_ != sr->srpMasksFromConfig_) {
          nochange = false;
          if(m_debug) {
            for(int i = 0; i < 12; i++) {
              for(int ich = 0; ich < 8; ich++) {
                if(sref->srpMasksFromConfig_[i][ich] != sr->srpMasksFromConfig_[i][ich]) {
                  fout << " srpMasks " << i << " " << ich << " ref " << sref->srpMasksFromConfig_[i][ich] 
                       << " now " << sr->srpMasksFromConfig_[i][ich] << std::endl;
                }
              }
            }
          }
        }

        if(sref->dccMasks_ != sr->dccMasks_) {
          nochange = false;
          if(m_debug) {
            for(int i = 0; i < 54; i++) {
              if(sref->dccMasks_[i] != sr->dccMasks_[i]) {
                fout << " dccMasks " << i << " ref " << sref->dccMasks_[i] 
                     << " now " << sr->dccMasks_[i] << std::endl;
              }
            }
          }
        }

        if(sref->srfMasks_ != sr->srfMasks_) {
          nochange = false;
          if(m_debug) {
            for(int i = 0; i < 12; i++) {
              if(sref->srfMasks_[i] != sr->srfMasks_[i]) {
                fout << " srfMasks " << i << " ref " << sref->srfMasks_[i] 
                     << " now " << sr->srfMasks_[i] << std::endl;
              }
            }
          }
        }

        if(sref->substitutionSrfs_ != sr->substitutionSrfs_) {
          nochange = false;
          if(m_debug) {
            for(int i = 0; i < 12; i++) {
              for(int ich = 0; ich < 68; ich++) {
                if(sref->substitutionSrfs_[i][ich] != sr->substitutionSrfs_[i][ich]) {
                  fout << " substitutionSrfs " << i << " " << ich << " ref " << sref->substitutionSrfs_[i][ich] 
                       << " now " << sr->substitutionSrfs_[i][ich] << std::endl;
                }
              }
            }
          }
        }

        if(sref->testerTccEmuSrpIds_ != sr->testerTccEmuSrpIds_) {
          nochange = false;
          if(m_debug) {
            for(int i = 0; i < 12; i++) {
              fout << " testerTccEmuSrpIds " << i << " ref " << sref->testerTccEmuSrpIds_[i] 
                   << " now " << sr->testerTccEmuSrpIds_[i] << std::endl;
            }
          }
        }

        if(sref->testerSrpEmuSrpIds_ != sr->testerSrpEmuSrpIds_) {
          nochange = false;
          if(m_debug)
            for(int i = 0; i < 12; i++) {
              fout << " testerSrpEmuSrpIds " << i << " ref " << sref->testerSrpEmuSrpIds_[i] 
                   << " now " << sr->testerSrpEmuSrpIds_[i] << std::endl;
            }     
        }

        if(sref->testerDccTestSrpIds_ != sr->testerDccTestSrpIds_) {
          nochange = false;
          if(m_debug)
            for(int i = 0; i < 12; i++) {
              fout << " testerDccTestSrpIds " << i << " ref " << sref->testerDccTestSrpIds_[i] 
                   << " now " << sr->testerDccTestSrpIds_[i] << std::endl;
            }
        }

        if(sref->testerSrpTestSrpIds_ != sr->testerSrpTestSrpIds_) {
          nochange = false;
          if(m_debug)
            for(int i = 0; i < 12; i++) {
              fout << " testerSrpTestSrpIds " << i << " ref " << sref->testerSrpTestSrpIds_[i] 
                   << " now " << sr->testerSrpTestSrpIds_[i] << std::endl;
            }
        }

        if(sref->bxOffsets_ != sr->bxOffsets_) {
          nochange = false;
          if(m_debug)
            for(int i = 0; i < 12; i++) {
              fout << " bxOffsets " << i << " ref " << sref->bxOffsets_[i] 
                   << " now " << sr->bxOffsets_[i] << std::endl;
            }
        }

        if(sref->bxGlobalOffset_ != sr->bxGlobalOffset_) {
          nochange = false;
          if(m_debug)
            fout << " bxGlobalOffset ref " << sr->bxGlobalOffset_ 
                 << " now " << sr->bxGlobalOffset_ << std::endl;
        }

        if(sref->automaticMasks_ != sr->automaticMasks_) {
          nochange = false;
          if(m_debug)
            fout << " automaticMasks ref " << sref->automaticMasks_ 
                 << " now " << sr->automaticMasks_ << std::endl;
        }

        if(sref->automaticSrpSelect_ != sref->automaticSrpSelect_) {
          nochange = false;
          if(m_debug)
            fout << " automaticSrpSelect ref " << sref->automaticSrpSelect_ 
                 << " now " << sr->automaticSrpSelect_ << std::endl;
        }

        if(nochange) {
          if(m_debug)
            fout << " no change has been found " << std::endl;
          std::ostringstream ss; 
          ss << "Run=" << irun << "_SRPunchanged_"<<std::endl; 
          m_userTextLog = ss.str()+";";
        }
        else {
          if(m_debug) {
            fout << " Change has been found !\n   New payload :"  << std::endl;
            PrintPayload(*sr, fout);
          }
          ChangePayload(*sref, *sr);  // new reference
          // write the new payload to ORCON/ORCOFF
          EcalSRSettings* srp_pop = new EcalSRSettings();
          ChangePayload(*srp_pop, *sr);  // add this payload to DB
          m_to_transfer.push_back(std::make_pair(srp_pop, irun));

          std::ostringstream ss; 
          ss << "Run=" << irun << "_SRPchanged_"<<std::endl; 
          m_userTextLog = ss.str()+";";

          if(m_to_transfer.size() >= 20 ) break;
        }
        delete sr;
        m_i_tag = myconfig_tag;
        m_i_version = myconfig_version;
        fe_conf_id_old = fe_conf_id;
      }  // different tag or version or fe config
    }  // loop over runs
  }  // test on number of runs

  // disconnect from DB 
  delete econn;
  fout.close();

}

void popcon::EcalSRPHandler::importDccConfigFile(EcalSRSettings& sr, const std::string& filename, bool useCLOB){
  XMLPlatformUtils::Initialize();

  XercesDOMParser* parser = new XercesDOMParser;
  parser->setValidationScheme( XercesDOMParser::Val_Never );
  parser->setDoNamespaces( false );
  parser->setDoSchema( false );
  
  parser->parse(filename.c_str());

  DOMDocument* xmlDoc = parser->getDocument();
  if (!xmlDoc) {
    std::cout << "importDccConfigFile Error parsing document" << std::endl;
  }

  DOMElement* element = xmlDoc->getDocumentElement();
  std::string type = toNative(element->getTagName());

  // 1st level
  int EBEE = -1;
  int L1ZS[2] = {0, 0}, L2ZS[2] = {0, 0};
  for (DOMNode* childNode = element->getFirstChild(); 
       childNode; childNode = childNode->getNextSibling()) {    
    if (childNode->getNodeType() == DOMNode::ELEMENT_NODE) {
      const std::string foundName = toNative(childNode->getNodeName());
      DOMElement *child = static_cast<DOMElement *>(childNode);
      DOMNamedNodeMap *attributes = child->getAttributes();
      unsigned int numAttributes = attributes->getLength();
      for (unsigned int j = 0; j < numAttributes; ++j) {
        DOMNode *attributeNode = attributes->item(j);
        DOMAttr *attribute = static_cast<DOMAttr *>(attributeNode);
        const std::string info = toNative(attribute->getName());
        const std::string scope = toNative(attribute->getValue());
        if(info == "_scope") {
          if(scope.substr(0,2) == "EE") EBEE = 1;
          else EBEE = 0;
        }
      }
      // 2nd level
      for (DOMNode* subchildNode = childNode->getFirstChild(); 
           subchildNode; subchildNode = subchildNode->getNextSibling()) {    
        if (subchildNode->getNodeType() == DOMNode::ELEMENT_NODE) {
          const std::string subName = toNative(subchildNode->getNodeName());
          // 3rd level
          for (DOMNode* subsubchildNode = subchildNode->getFirstChild(); 
               subsubchildNode; subsubchildNode = subsubchildNode->getNextSibling()) {    
            if (subsubchildNode->getNodeType() == DOMNode::ELEMENT_NODE) {
              const std::string subName = toNative(subsubchildNode->getNodeName());
              if(subName == "L1ZSUPPRESSION")
                GetNodeData(subsubchildNode,L1ZS[EBEE]);
              if(subName == "L2ZSUPPRESSION")
                GetNodeData(subsubchildNode,L2ZS[EBEE]);
              if(subName == "FIRSTZSSAMPLE") {
                int ZS;
                GetNodeData(subsubchildNode,ZS);
                if(useCLOB) sr.ecalDccZs1stSample_.push_back(ZS);
              }
              if(subName == "CXTALWEIGHTS") {
                std::vector<float> dcc(6);
                float w;
                for(int iw = 0; iw < 6; iw++) {
                  GetNodeData(subsubchildNode,w);
                  dcc.push_back( w );
                }
                if(useCLOB) sr.dccNormalizedWeights_.push_back(dcc);  // vector vector
              }
            }
          }  // loop over subsubchild 
        }
      }  // loop over subchild 
    }
  }  // loop over child 
  sr.srpLowInterestChannelZS_.push_back(L1ZS[0]*0.035/4);  //  EB
  sr.srpLowInterestChannelZS_.push_back(L1ZS[1]*0.060/4);  //  EE
  sr.srpHighInterestChannelZS_.push_back(L2ZS[0]*0.035/4);  //  EB
  sr.srpHighInterestChannelZS_.push_back(L2ZS[1]*0.060/4);  //  EE
  delete parser;
  XMLPlatformUtils::Terminate();
}

void popcon::EcalSRPHandler::PrintPayload(EcalSRSettings& sr, std::ofstream& fout){
  int imax = sr.deltaEta_.size();
  fout << " deltaEta[" << imax << "] ";
  for(int i = 0; i < imax ; i++) {
    fout << sr.deltaEta_[i] << " ";
  }
  fout << std::endl;

  imax = sr.deltaPhi_.size();
  fout << " deltaPhi[" << imax << "] ";
  for(int i = 0; i < imax ; i++) {
    fout << sr.deltaPhi_[i] << " ";
  }
  fout << std::endl;

  imax = sr.ecalDccZs1stSample_.size();
  fout << " ecalDccZs1stSample[" << imax << "] ";
  for(int i = 0; i < imax ; i++) {
    fout << sr.ecalDccZs1stSample_[i] << " ";
  }
  fout << std::endl;

  fout << " ebDccAdcToGeV " << sr.ebDccAdcToGeV_ << std::endl;

  fout << " eeDccAdcToGeV " << sr.eeDccAdcToGeV_ << std::endl;

  fout << " dccNormalizedWeights" << std::endl;
  for(int i = 0; i < (int)sr.dccNormalizedWeights_.size(); ++i){
    fout << " Channel " << i;
    for(int j = 0; j < (int)sr.dccNormalizedWeights_[i].size(); ++j) 
      fout  << " " << sr.dccNormalizedWeights_[i][j];
    fout << std::endl;
  }

  imax = sr.symetricZS_.size();
  fout << " symetricZS["<< imax << "] ";
  for(int i = 0; i < imax ; i++) {
    fout << sr.symetricZS_[i] << " ";
  }
  fout << std::endl;

  imax = sr.srpLowInterestChannelZS_.size();
  fout << " srpLowInterestChannelZS["<< imax << "] ";
  for(int i = 0; i < imax ; i++) {
    fout << sr.srpLowInterestChannelZS_[i] << " ";
  }
  fout << std::endl;

  imax = sr.srpHighInterestChannelZS_.size();
  fout << " srpHighInterestChannelZS["<< imax << "] ";
  for(int i = 0; i < imax ; i++) {
    fout << sr.srpHighInterestChannelZS_[i] << " ";
  }
  fout << std::endl;

  imax = sr.actions_.size();
  fout << " actions["<< imax << "] ";
  for(int i = 0; i < imax ; i++) {
    fout << sr.actions_[i] << " ";
  }
  fout << std::endl;

  imax = sr.tccMasksFromConfig_.size();
  fout << " tccMasksFromConfig["<< imax << "] ";
  for(int i = 0; i < imax ; i++) {
    fout << sr.tccMasksFromConfig_[i] << " ";
  }
  fout << std::endl;

  fout << " srpMasksFromConfig" << std::endl;
  for(int i = 0; i < (int)sr.srpMasksFromConfig_.size(); ++i){
    for(int j = 0; j < (int)sr.srpMasksFromConfig_[i].size(); ++j) 
      fout << sr.srpMasksFromConfig_[i][j] << " ";
    fout << std::endl;
  }

  imax = sr.dccMasks_.size();
  fout << " dccMasks[" << imax << "] ";
  for(int i = 0; i < imax ; i++) {
    fout << sr.dccMasks_[i] << " ";
  }
  fout << std::endl;

  imax = sr.srfMasks_.size();
  fout << " srfMasks[" << imax << "] ";
  for(int i = 0; i < imax ; i++) {
    fout << sr.srfMasks_[i] << " ";
  }
  fout << std::endl;

  fout << "substitutionSrfs" << std::endl;
  for(int i = 0; i < (int)sr.substitutionSrfs_.size(); ++i){
    for(int j = 0; j < (int)sr.substitutionSrfs_[i].size(); ++j) 
      fout << sr.substitutionSrfs_[i][j] << " ";
    fout << std::endl;
  }

  imax = sr.testerTccEmuSrpIds_.size();
  fout << " testerTccEmuSrpIds[" << imax << "] ";
  for(int i = 0; i < imax ; i++) {
    fout << sr.testerTccEmuSrpIds_[i] << " ";
  }
  fout << std::endl;

  imax = sr.testerSrpEmuSrpIds_.size();
  fout << " testerSrpEmuSrpIds[" << imax << "] ";
  for(int i = 0; i < imax ; i++) {
    fout << sr.testerSrpEmuSrpIds_[i] << " ";
  }
  fout << std::endl;

  imax = sr.testerDccTestSrpIds_.size();
  fout << " testerDccTestSrpIds[" << imax << "] ";
  for(int i = 0; i < imax ; i++) {
    fout << sr.testerDccTestSrpIds_[i] << " ";
  }
  fout << std::endl;

  imax = sr. testerSrpTestSrpIds_.size();
  fout << " testerSrpTestSrpIds[" << imax << "] ";
  for(int i = 0; i < imax ; i++) {
    fout << sr.testerSrpTestSrpIds_[i] << " ";
  }
  fout << std::endl;

  imax = sr.bxOffsets_.size();
  fout << " bxOffsets[" << imax << "] ";
  for(int i = 0; i < imax ; i++) {
    fout << sr.bxOffsets_[i] << " ";
  }
  fout << std::endl;

  fout << " bxGlobalOffset " << sr.bxGlobalOffset_ << std::endl;
  fout << " automaticMasks " << sr.automaticMasks_ << std::endl;
  fout << " automaticSrpSelect " << sr.automaticSrpSelect_ << std::endl;
}

void popcon::EcalSRPHandler::ChangePayload(EcalSRSettings& sref, EcalSRSettings& sr ){
  sref.deltaEta_ =  sr.deltaEta_;
  sref.deltaPhi_ = sr.deltaPhi_;
  sref.ecalDccZs1stSample_ = sr.ecalDccZs1stSample_;
  sref.ebDccAdcToGeV_ = sr.ebDccAdcToGeV_;
  sref.eeDccAdcToGeV_ = sr.eeDccAdcToGeV_;
  sref.dccNormalizedWeights_ = sr.dccNormalizedWeights_;
  sref.symetricZS_ = sr.symetricZS_;
  sref.srpLowInterestChannelZS_ = sr.srpLowInterestChannelZS_;
  sref.srpHighInterestChannelZS_ = sr.srpHighInterestChannelZS_;
  sref.actions_ = sr.actions_;
  sref.tccMasksFromConfig_ = sr.tccMasksFromConfig_;
  sref.srpMasksFromConfig_ = sr.srpMasksFromConfig_;
  sref.dccMasks_ = sr.dccMasks_;
  sref.srfMasks_ = sr.srfMasks_;
  sref.substitutionSrfs_ = sr.substitutionSrfs_;
  sref.testerTccEmuSrpIds_ = sr.testerTccEmuSrpIds_;
  sref.testerSrpEmuSrpIds_ = sr.testerSrpEmuSrpIds_;
  sref.testerDccTestSrpIds_ = sr.testerDccTestSrpIds_;
  sref.testerSrpTestSrpIds_ = sr.testerSrpTestSrpIds_;
  sref.bxOffsets_ = sr.bxOffsets_;
  sref.bxGlobalOffset_ = sr.bxGlobalOffset_;
  sref.automaticMasks_ = sr.automaticMasks_;
  sref.automaticSrpSelect_ = sr.automaticSrpSelect_;
}