#include <EcalSRPHandler.h>

Inheritance diagram for popcon::EcalSRPHandler:

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

	EcalSRPHandler (edm::ParameterSet const &)

void	getNewObjects ()

std::string	id () const

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

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

	~EcalSRPHandler ()

Public Member Functions inherited from popcon::PopConSourceHandler< EcalSRSettings >
void	convertFromOld ()

Summary *	dummySummary (typename OldContainer::value_type const &) const

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

void	sort ()

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::vector< Triplet >	Container

typedef std::vector< std::pair < EcalSRSettings *, cond::Time_t > >	OldContainer

typedef PopConSourceHandler < EcalSRSettings >	self

typedef cond::Summary	Summary

typedef cond::Time_t	Time_t

typedef EcalSRSettings	value_type

Protected Member Functions inherited from popcon::PopConSourceHandler< EcalSRSettings >
int	add (value_type payload, Summary summary, Time_t time)

Protected Attributes inherited from popcon::PopConSourceHandler< EcalSRSettings >
OldContainer	m_to_transfer

std::string	m_userTextLog

Detailed Description

Definition at line 43 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 ( )

Definition at line 50 of file EcalSRPHandler.cc.

50 {}

Member Function Documentation

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

Definition at line 969 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 ( )

virtual

Implements popcon::PopConSourceHandler< EcalSRSettings >.

Definition at line 52 of file EcalSRPHandler.cc.

References EcalSRSettings::actions_, EcalSRSettings::automaticMasks_, EcalSRSettings::automaticSrpSelect_, EcalSRSettings::bxGlobalOffset_, EcalSRSettings::bxOffsets_, gather_cfg::cout, dataset::dataset, EcalSRSettings::dccMasks_, EcalSRSettings::dccNormalizedWeights_, def, EcalSRSettings::deltaEta_, EcalSRSettings::deltaPhi_, alignCSCRings::e, EcalSRSettings::ebDccAdcToGeV_, EcalSRSettings::ecalDccZs1stSample_, EcalSRSettings::eeDccAdcToGeV_, cppFunctionSkipper::exception, Exception, 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(), RunList::getRuns(), ODWeightsSamplesDat::getSampleId(), ODRunConfigSeqInfo::getSequenceId(), ODSRPConfig::getSRP0BunchAdjustPosition(), ODSRPConfig::getSRPClob(), ODSRPConfig::getSRPClobSize(), ODEcalCycle::getSRPId(), ODWeightsDat::getWeight(), ODFEDAQConfig::getWeightId(), i, EcalSRCondTools::importSrpConfigFile(), ecalTB2006H4_GenSimDigiReco_cfg::mySample, GenerateHcalLaserBadRunList::out, timingPdfMaker::outfile, AlCaHLTBitMon_ParallelJobs::p, 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 create_public_pileup_plots::weights.

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

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

inlinevirtual

Implements popcon::PopConSourceHandler< EcalSRSettings >.

Definition at line 50 of file EcalSRPHandler.h.

References m_name.

50 { return m_name;}

popcon::EcalSRPHandler::m_name

std::string m_name

Definition: EcalSRPHandler.h:62

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

Definition at line 752 of file EcalSRPHandler.cc.

References gather_cfg::cout, EcalSRSettings::dccNormalizedWeights_, EcalSRSettings::ecalDccZs1stSample_, xuti::GetNodeData(), info(), j, geometryXMLtoCSV::parser, EcalSRSettings::srpHighInterestChannelZS_, EcalSRSettings::srpLowInterestChannelZS_, AlCaHLTBitMon_QueryRunRegistry::string, xuti::toNative(), 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 = 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;
   cms::concurrency::xercesTerminate();
 }

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

Definition at line 832 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_, i, 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;
 }