#include <EcalSRPHandler.h>

Inheritance diagram for popcon::EcalSRPHandler:

Public Member Functions
void	ChangePayload (EcalSRSettings &sref, EcalSRSettings &sr)

	EcalSRPHandler (edm::ParameterSet const &)

void	getNewObjects () override

std::string	id () const override

void	importDccConfigFile (EcalSRSettings &sr, const std::string &filename, bool debug=false)

void	PrintPayload (EcalSRSettings &sr, std::ofstream &fout)

	~EcalSRPHandler () override

Public Member Functions inherited from popcon::PopConSourceHandler< EcalSRSettings >
void	initialize (const cond::persistency::Session &dbSession, cond::TagInfo_t const &tagInfo, cond::LogDBEntry_t const &logDBEntry)

Ref	lastPayload () const

cond::LogDBEntry_t const &	logDBEntry () const

std::pair< Container const *, std::string const >	operator() (const cond::persistency::Session &session, cond::TagInfo_t const &tagInfo, cond::LogDBEntry_t const &logDBEntry) const

	PopConSourceHandler ()

Container const &	returnData ()

cond::TagInfo_t const &	tagInfo () const

std::string const &	userTextLog () const

virtual	~PopConSourceHandler ()

Public Attributes
EcalCondDBInterface *	econn

Private Attributes
bool	m_debug

unsigned long	m_firstRun

std::string	m_gentag

std::string	m_i_tag

int	m_i_version

unsigned long	m_lastRun

std::string	m_location

std::string	m_name

std::string	m_pass

std::string	m_runtype

std::string	m_sid

std::string	m_user

Additional Inherited Members
Public Types inherited from popcon::PopConSourceHandler< EcalSRSettings >
typedef std::map< Time_t, std::shared_ptr < EcalSRSettings > >	Container

typedef std::unique_ptr < EcalSRSettings >	Ref

typedef PopConSourceHandler < EcalSRSettings >	self

typedef cond::Time_t	Time_t

typedef EcalSRSettings	value_type

Protected Member Functions inherited from popcon::PopConSourceHandler< EcalSRSettings >
cond::persistency::Session &	dbSession () const

Protected Attributes inherited from popcon::PopConSourceHandler< EcalSRSettings >
Container	m_iovs

std::vector< std::pair < EcalSRSettings *, Time_t > >	m_to_transfer

std::string	m_userTextLog

Detailed Description

Definition at line 41 of file EcalSRPHandler.h.

Constructor & Destructor Documentation

popcon::EcalSRPHandler::EcalSRPHandler ( edm::ParameterSet const & ps )

Definition at line 33 of file EcalSRPHandler.cc.

References edm::ParameterSet::getParameter(), m_debug, m_firstRun, m_gentag, m_i_tag, m_i_version, m_lastRun, m_location, m_pass, m_runtype, m_sid, m_user, and AlCaHLTBitMon_QueryRunRegistry::string.

     : 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 ( )

override

Definition at line 48 of file EcalSRPHandler.cc.

48 {}

Member Function Documentation

void popcon::EcalSRPHandler::ChangePayload	(	EcalSRSettings &	sref,
		EcalSRSettings &	sr
	)

Definition at line 957 of file EcalSRPHandler.cc.

References EcalSRSettings::actions_, EcalSRSettings::automaticMasks_, EcalSRSettings::automaticSrpSelect_, EcalSRSettings::bxGlobalOffset_, EcalSRSettings::bxOffsets_, EcalSRSettings::dccMasks_, EcalSRSettings::dccNormalizedWeights_, EcalSRSettings::deltaEta_, EcalSRSettings::deltaPhi_, EcalSRSettings::ebDccAdcToGeV_, EcalSRSettings::ecalDccZs1stSample_, EcalSRSettings::eeDccAdcToGeV_, EcalSRSettings::srfMasks_, EcalSRSettings::srpHighInterestChannelZS_, EcalSRSettings::srpLowInterestChannelZS_, EcalSRSettings::srpMasksFromConfig_, EcalSRSettings::substitutionSrfs_, EcalSRSettings::symetricZS_, EcalSRSettings::tccMasksFromConfig_, EcalSRSettings::testerDccTestSrpIds_, EcalSRSettings::testerSrpEmuSrpIds_, EcalSRSettings::testerSrpTestSrpIds_, and EcalSRSettings::testerTccEmuSrpIds_.

                                                                                  {
   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_;
 }

void popcon::EcalSRPHandler::getNewObjects ( )

overridevirtual

Implements popcon::PopConSourceHandler< EcalSRSettings >.

Definition at line 50 of file EcalSRPHandler.cc.

References EcalSRSettings::actions_, EcalSRSettings::automaticMasks_, EcalSRSettings::automaticSrpSelect_, EcalSRSettings::bxGlobalOffset_, EcalSRSettings::bxOffsets_, gather_cfg::cout, dat, writedatasetfile::dataset, EcalSRSettings::dccMasks_, EcalSRSettings::dccNormalizedWeights_, spu::def(), EcalSRSettings::deltaEta_, EcalSRSettings::deltaPhi_, alignCSCRings::e, EcalSRSettings::ebDccAdcToGeV_, EcalSRSettings::ecalDccZs1stSample_, test_db_connect::econn, EcalSRSettings::eeDccAdcToGeV_, cppFunctionSkipper::exception, Exception, validate-o2o-wbm::f, alignmentValidation::fname, groupFilesInBlocks::fout, ODSRPConfig::getAutomaticMasks(), ODSRPConfig::getAutomaticSrpSelect(), RunFEConfigDat::getConfigId(), RunConfigDat::getConfigTag(), RunConfigDat::getConfigVersion(), ODDCCConfig::getDCCClob(), ODDCCConfig::getDCCClobSize(), ODEcalCycle::getDCCId(), ODDCCConfig::getDCCWeightsMode(), ODEcalCycle::getId(), ODRunConfigInfo::getId(), DeadROCCounter::getRunNumber(), RunList::getRuns(), ODWeightsSamplesDat::getSampleId(), ODRunConfigSeqInfo::getSequenceId(), ODSRPConfig::getSRP0BunchAdjustPosition(), ODSRPConfig::getSRPClob(), ODSRPConfig::getSRPClobSize(), ODEcalCycle::getSRPId(), ODWeightsDat::getWeight(), ODFEDAQConfig::getWeightId(), mps_fire::i, EcalSRCondTools::importSrpConfigFile(), test_db_connect::my_locdef, test_db_connect::my_rundef, ecalTB2006H4_GenSimDigiReco_cfg::mySample, submitPVResolutionJobs::out, timingPdfMaker::outfile, AlCaHLTBitMon_ParallelJobs::p, cmsswSequenceInfo::seq, ODRunConfigSeqInfo::setEcalConfigId(), RunTag::setGeneralTag(), ODFEDAQConfig::setId(), ODWeightsDat::setId(), ODWeightsSamplesDat::setId(), ODDCCConfig::setId(), ODSRPConfig::setId(), LocationDef::setLocation(), RunTag::setLocationDef(), RunTypeDef::setRunType(), RunTag::setRunTypeDef(), ODEcalCycle::setSequenceId(), ODRunConfigSeqInfo::setSequenceNumber(), ODRunConfigInfo::setTag(), ODRunConfigInfo::setVersion(), EcalSRSettings::srfMasks_, EcalSRSettings::srpHighInterestChannelZS_, EcalSRSettings::srpLowInterestChannelZS_, EcalSRSettings::srpMasksFromConfig_, contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, EcalSRSettings::substitutionSrfs_, EcalSRSettings::symetricZS_, dumpRecoGeometry_cfg::tagInfo, EcalSRSettings::tccMasksFromConfig_, EcalSRSettings::testerDccTestSrpIds_, EcalSRSettings::testerSrpEmuSrpIds_, EcalSRSettings::testerSrpTestSrpIds_, EcalSRSettings::testerTccEmuSrpIds_, and HLT_FULL_cff::weights.

                                          {
   std::ostringstream ss;
   ss << "ECAL ";
 
   unsigned long long max_since = 1;
 
   // this is the last inserted run
   max_since = tagInfo().lastInterval.since;
 
   // 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 (myconfig_tag.substr(0, 15) == "ZeroSuppression" || myconfig_tag.substr(0, 11) == "FullReadout" ||
           myconfig_tag.substr(0, 11) == "AlmostEmpty") {
         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;
                 dccwRow.reserve(6);
                 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_.empty()) {  // 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_ != sr->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();
 }

std::string popcon::EcalSRPHandler::id ( ) const

inlineoverridevirtual

Implements popcon::PopConSourceHandler< EcalSRSettings >.

Definition at line 47 of file EcalSRPHandler.h.

References m_name.

47 { return m_name; }

popcon::EcalSRPHandler::m_name

std::string m_name

Definition: EcalSRPHandler.h:59

void popcon::EcalSRPHandler::importDccConfigFile	(	EcalSRSettings &	sr,
		const std::string &	filename,
		bool	debug = `false`
	)

Definition at line 737 of file EcalSRPHandler.cc.

References gather_cfg::cout, EcalSRSettings::dccNormalizedWeights_, EcalSRSettings::ecalDccZs1stSample_, xuti::GetNodeData(), info(), dqmiolumiharvest::j, writedatasetfile::parser, EcalSRSettings::srpHighInterestChannelZS_, EcalSRSettings::srpLowInterestChannelZS_, AlCaHLTBitMon_QueryRunRegistry::string, cms::xerces::toString(), w, cms::concurrency::xercesInitialize(), and cms::concurrency::xercesTerminate().

                                                                                                           {
   cms::concurrency::xercesInitialize();
 
   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 = cms::xerces::toString(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 = cms::xerces::toString(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 = cms::xerces::toString(attribute->getName());
         const std::string scope = cms::xerces::toString(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 = cms::xerces::toString(subchildNode->getNodeName());
           // 3rd level
           for (DOMNode* subsubchildNode = subchildNode->getFirstChild(); subsubchildNode;
                subsubchildNode = subsubchildNode->getNextSibling()) {
             if (subsubchildNode->getNodeType() == DOMNode::ELEMENT_NODE) {
               const std::string subName = cms::xerces::toString(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;
   cms::concurrency::xercesTerminate();
 }

void popcon::EcalSRPHandler::PrintPayload	(	EcalSRSettings &	sr,
		std::ofstream &	fout
	)

Definition at line 820 of file EcalSRPHandler.cc.

References EcalSRSettings::actions_, EcalSRSettings::automaticMasks_, EcalSRSettings::automaticSrpSelect_, EcalSRSettings::bxGlobalOffset_, EcalSRSettings::bxOffsets_, EcalSRSettings::dccMasks_, EcalSRSettings::dccNormalizedWeights_, EcalSRSettings::deltaEta_, EcalSRSettings::deltaPhi_, EcalSRSettings::ebDccAdcToGeV_, EcalSRSettings::ecalDccZs1stSample_, EcalSRSettings::eeDccAdcToGeV_, mps_fire::i, dqmiolumiharvest::j, EcalSRSettings::srfMasks_, EcalSRSettings::srpHighInterestChannelZS_, EcalSRSettings::srpLowInterestChannelZS_, EcalSRSettings::srpMasksFromConfig_, EcalSRSettings::substitutionSrfs_, EcalSRSettings::symetricZS_, EcalSRSettings::tccMasksFromConfig_, EcalSRSettings::testerDccTestSrpIds_, EcalSRSettings::testerSrpEmuSrpIds_, EcalSRSettings::testerSrpTestSrpIds_, and EcalSRSettings::testerTccEmuSrpIds_.

                                                                              {
   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;
 }