#include <L1RPCHwConfigSourceHandler.h>

Inheritance diagram for popcon::L1RPCHwConfigSourceHandler:

Public Member Functions
int	Compare2Configs (const Ref &set1, L1RPCHwConfig *set2)

void	ConnectOnlineDB (std::string connect, std::string authPath)

void	DisconnectOnlineDB ()

void	getNewObjects () override

std::string	id () const override

	L1RPCHwConfigSourceHandler (const edm::ParameterSet &ps)

void	readHwConfig1 ()

	~L1RPCHwConfigSourceHandler () override

Public Member Functions inherited from popcon::PopConSourceHandler< L1RPCHwConfig >
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 ()

Private Attributes
L1RPCHwConfig *	disabledDevs

std::string	m_authpath

std::string	m_connect

std::vector< int >	m_disableCrates

std::vector< int >	m_disableTowers

int	m_dummy

std::string	m_name

int	m_validate

cond::persistency::Session	session

Additional Inherited Members
Public Types inherited from popcon::PopConSourceHandler< L1RPCHwConfig >
typedef std::vector< Triplet >	Container

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

typedef PopConSourceHandler< L1RPCHwConfig >	self

typedef cond::Summary	Summary

typedef cond::Time_t	Time_t

typedef L1RPCHwConfig	value_type

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

cond::persistency::Session &	dbSession () const

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

std::string	m_userTextLog

Detailed Description

Definition at line 31 of file L1RPCHwConfigSourceHandler.h.

Constructor & Destructor Documentation

◆ L1RPCHwConfigSourceHandler()

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

Definition at line 7 of file L1RPCHwConfigSourceHandler.cc.

     : m_name(ps.getUntrackedParameter<std::string>("name", "L1RPCHwConfigSourceHandler")),
       m_dummy(ps.getUntrackedParameter<int>("WriteDummy", 0)),
       m_validate(ps.getUntrackedParameter<int>("Validate", 0)),
       m_disableCrates(ps.getUntrackedParameter<std::vector<int> >("DisabledCrates")),
       m_disableTowers(ps.getUntrackedParameter<std::vector<int> >("DisabledTowers")),
       m_connect(ps.getUntrackedParameter<std::string>("OnlineConn", "")),
       m_authpath(ps.getUntrackedParameter<std::string>("OnlineAuthPath", ".")) {}

◆ ~L1RPCHwConfigSourceHandler()

popcon::L1RPCHwConfigSourceHandler::~L1RPCHwConfigSourceHandler ( )

override

Definition at line 16 of file L1RPCHwConfigSourceHandler.cc.

16 {}

Member Function Documentation

◆ Compare2Configs()

int popcon::L1RPCHwConfigSourceHandler::Compare2Configs	(	const Ref &	set1,
		L1RPCHwConfig *	set2
	)

Definition at line 221 of file L1RPCHwConfigSourceHandler.cc.

                                                                                            {
   const Ref& set1 = _set1;
   std::cout << "Size of new object is : " << std::flush;
   std::cout << set2->size() << std::endl;
   std::cout << "Size of ref object is : " << std::flush;
   std::cout << set1->size() << std::endl;
  
   if (set1->size() != set2->size()) {
     std::cout << " Number of disabled devices changed " << std::endl;
     return 1;
   }
   for (int tower = -16; tower < 17; tower++) {
     for (int sector = 0; sector < 12; sector++) {
       for (int segment = 0; segment < 12; segment++)
         if (set1->isActive(tower, sector, segment) != set2->isActive(tower, sector, segment)) {
           std::cout << " Configuration changed for tower " << tower << ", sector " << sector << ", segment " << segment
                     << std::endl;
           return 1;
         }
     }
   }
   return 0;
 }

References gather_cfg::cout, L1RPCHwConfig::isActive(), L1RPCHwConfig::size(), and hgcalTowerProducer_cfi::tower.

◆ ConnectOnlineDB()

void popcon::L1RPCHwConfigSourceHandler::ConnectOnlineDB	(	std::string	connect,
		std::string	authPath
	)

Definition at line 76 of file L1RPCHwConfigSourceHandler.cc.

                                                                                             {
   std::cout << "L1RPCHwConfigSourceHandler: connecting to " << connect << "..." << std::flush;
   cond::persistency::ConnectionPool connection;
   //  session->configuration().setAuthenticationMethod(cond::XML);
   connection.setAuthenticationPath(authPath);
   connection.configure();
   session = connection.createSession(connect, true);
   std::cout << "Done." << std::endl;
 }

References lumi_dqm_sourceclient-live_cfg::authPath, cond::persistency::ConnectionPool::configure(), DBConfiguration_cff::connect, gather_cfg::cout, cond::persistency::ConnectionPool::createSession(), and cond::persistency::ConnectionPool::setAuthenticationPath().

◆ DisconnectOnlineDB()

void popcon::L1RPCHwConfigSourceHandler::DisconnectOnlineDB ( )

Definition at line 86 of file L1RPCHwConfigSourceHandler.cc.

86 { session.close(); }

◆ getNewObjects()

void popcon::L1RPCHwConfigSourceHandler::getNewObjects ( )

overridevirtual

Implements popcon::PopConSourceHandler< L1RPCHwConfig >.

Definition at line 18 of file L1RPCHwConfigSourceHandler.cc.

                                                      {
   std::cout << "L1RPCHwConfigSourceHandler: L1RPCHwConfigSourceHandler::getNewObjects begins\n";
   edm::Service<cond::service::PoolDBOutputService> mydbservice;
  
   //  std::cerr << "------- " << m_name
   //           << " - > getNewObjects" << std::endl;
   //  std::cerr<<"Got offlineInfo, tag: "<<std::endl;
   //  std::cerr << tagInfo().name << " , last object valid from "
   //          << tagInfo().lastInterval.first << " to "
   //            << tagInfo().lastInterval.second << " , token is "
   //            << tagInfo().token << " and this is the payload "
   //            << tagInfo().lastPayloadToken << std::endl;
  
   // first check what is already there in offline DB
   Ref payload;
  
   if (m_validate == 1) {
     std::cout << " Validation was requested, so will check present contents" << std::endl;
     std::cout << "Name of tag : " << tagInfo().name << ", tag size : " << tagInfo().size << ", last object valid since "
               << tagInfo().lastInterval.since << std::endl;
     payload = lastPayload();
   } else {
     std::cout << "L1RPCHwConfigSourceHandler: no validation requested" << std::endl;
   }
  
   // now construct new object from online DB
   disabledDevs = new L1RPCHwConfig();
   if (m_dummy == 1) {
     std::vector<int>::iterator crIt = m_disableCrates.begin();
     for (; crIt != m_disableCrates.end(); ++crIt) {
       disabledDevs->enableCrate(*crIt, false);
     }
     std::vector<int>::iterator twIt = m_disableTowers.begin();
     for (; twIt != m_disableTowers.end(); ++twIt) {
       disabledDevs->enableTower(*twIt, false);
     }
   } else {
     ConnectOnlineDB(m_connect, m_authpath);
     readHwConfig1();
     DisconnectOnlineDB();
   }
  
   cond::Time_t snc = mydbservice->currentTime();
  
   // look for recent changes
   int difference = 1;
   if (m_validate == 1)
     difference = Compare2Configs(payload, disabledDevs);
   if (!difference)
     std::cout << "No changes - will not write anything!!!" << std::endl;
   if (difference == 1) {
     std::cout << "Will write new object to offline DB!!!" << std::endl;
     m_to_transfer.push_back(std::make_pair((L1RPCHwConfig*)disabledDevs, snc + 1));
   }
  
   std::cout << "L1RPCHwConfigSourceHandler: L1RPCHwConfigSourceHandler::getNewObjects ends\n";
 }

References gather_cfg::cout, cond::service::PoolDBOutputService::currentTime(), jets_cff::payload, and dumpRecoGeometry_cfg::tagInfo.

◆ id()

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

inlineoverridevirtual

Implements popcon::PopConSourceHandler< L1RPCHwConfig >.

Definition at line 36 of file L1RPCHwConfigSourceHandler.h.

36 { return m_name; }

References m_name.

◆ readHwConfig1()

void popcon::L1RPCHwConfigSourceHandler::readHwConfig1 ( )

Definition at line 88 of file L1RPCHwConfigSourceHandler.cc.

                                                      {
   session.transaction().start(true);
   coral::ISchema& schema = session.nominalSchema();
   std::string condition = "";
   coral::AttributeList conditionData;
   std::cout << std::endl
             << "L1RPCHwConfigSourceHandler: start to build L1RPC Hw Config..." << std::flush << std::endl
             << std::endl;
  
   // get disabled crates and translate into towers/sectors/segments
   coral::IQuery* query1 = schema.newQuery();
   query1->addToTableList("CRATEDISABLED");
   query1->addToTableList("CRATE");
   query1->addToTableList("BOARD");
   query1->addToTableList("TRIGGERBOARD");
   query1->addToOutputList("TRIGGERBOARD.TOWERTO", "TOWERTO");
   query1->addToOutputList("TRIGGERBOARD.TOWERFROM", "TOWERFROM");
   query1->addToOutputList("TRIGGERBOARD.SECTOR", "SECTOR");
   query1->addToOrderList("TOWERTO");
   query1->addToOrderList("SECTOR");
   condition =
       "CRATE.CRATEID=CRATEDISABLED.CRATE_CRATEID AND BOARD.CRATE_CRATEID=CRATE.CRATEID AND "
       "BOARD.BOARDID=TRIGGERBOARD.TRIGGERBOARDID AND CRATE.TYPE='TRIGGERCRATE'";
   query1->setCondition(condition, conditionData);
   coral::ICursor& cursor1 = query1->execute();
   while (cursor1.next()) {
     //    cursor1.currentRow().toOutputStream( std::cout ) << std::endl;
     const coral::AttributeList& row = cursor1.currentRow();
     int sector = atoi((row["SECTOR"].data<std::string>()).c_str());
     int first = atoi((row["TOWERTO"].data<std::string>()).c_str());
     int last = atoi((row["TOWERFROM"].data<std::string>()).c_str());
     for (int iTower = first; iTower <= last; iTower++) {
       for (int jSegment = 0; jSegment < 12; jSegment++) {
         disabledDevs->enablePAC(iTower, sector, jSegment, false);
       }
     }
   }
   delete query1;
  
   // get disabled triggerboards and translate into towers/sectors/segments
   coral::IQuery* query2 = schema.newQuery();
   query2->addToTableList("BOARDDISABLED");
   query2->addToTableList("BOARD");
   query2->addToTableList("TRIGGERBOARD");
   query2->addToOutputList("TRIGGERBOARD.TOWERTO", "TOWERTO");
   query2->addToOutputList("TRIGGERBOARD.TOWERFROM", "TOWERFROM");
   query2->addToOutputList("TRIGGERBOARD.SECTOR", "SECTOR");
   query2->addToOrderList("TOWERTO");
   query2->addToOrderList("SECTOR");
   condition = "BOARD.BOARDID=BOARDDISABLED.BOARD_BOARDID AND BOARD.BOARDID=TRIGGERBOARD.TRIGGERBOARDID";
   query2->setCondition(condition, conditionData);
   coral::ICursor& cursor2 = query2->execute();
   while (cursor2.next()) {
     //    cursor2.currentRow().toOutputStream( std::cout ) << std::endl;
     const coral::AttributeList& row = cursor2.currentRow();
     int sector = atoi((row["SECTOR"].data<std::string>()).c_str());
     int first = atoi((row["TOWERTO"].data<std::string>()).c_str());
     int last = atoi((row["TOWERFROM"].data<std::string>()).c_str());
     for (int iTower = first; iTower <= last; iTower++) {
       for (int jSegment = 0; jSegment < 12; jSegment++) {
         disabledDevs->enablePAC(iTower, sector, jSegment, false);
       }
     }
   }
   delete query2;
  
   // get disabled links - this is not usable here
   /*
   coral::IQuery* query3 = schema.newQuery();
   query3->addToTableList( "LINKDISABLED" );
   query3->addToTableList( "LINKCONN" );
   query3->addToTableList( "TRIGGERBOARD" );
   query3->addToOutputList("TRIGGERBOARD.TOWERTO","TOWERTO");
   query3->addToOutputList("TRIGGERBOARD.TOWERFROM","TOWERFROM");
   query3->addToOutputList("TRIGGERBOARD.SECTOR","SECTOR");
   query3->addToOutputList("LINKCONN.TRIGGERBOARDINPUTNUM","TBINPUTNUM");
   query3->addToOrderList( "TOWERTO" );
   query3->addToOrderList( "SECTOR" );
   query3->addToOrderList( "TBINPUTNUM" );
   condition = "LINKCONN.LINKCONNID=LINKDISABLED.LINK_LINKCONNID AND LINKCONN.TB_TRIGGERBOARDID=TRIGGERBOARD.TRIGGERBOARDID";
   query3->setCondition( condition, conditionData );
   coral::ICursor& cursor3 = query3->execute();
   while ( cursor3.next() ) {
 //    cursor3.currentRow().toOutputStream( std::cout ) << std::endl;
     const coral::AttributeList& row = cursor3.currentRow();
     int sector = atoi((row["SECTOR"].data<std::string>()).c_str());
     int first = atoi((row["TOWERTO"].data<std::string>()).c_str());
     int last = atoi((row["TOWERFROM"].data<std::string>()).c_str());
     for (int iTower=first; iTower<=last; iTower++) {
       for (int jSegment=0; jSegment<12; jSegment++) {
         disabledDevs->enablePAC(iTower,sector,jSegment,false);
       }
     }
   }
   delete query3;*/
  
   // get disabled chips and translate into towers/sectors
   // for the moment assume that chip position 8 corresponds to lowest tower number
   // and so on, ignoring bogus chip at position 11 if given TB operates 3 towers.
   coral::IQuery* query4 = schema.newQuery();
   query4->addToTableList("CHIPDISABLED");
   query4->addToTableList("CHIP");
   query4->addToTableList("BOARD");
   query4->addToTableList("TRIGGERBOARD");
   query4->addToOutputList("TRIGGERBOARD.TOWERTO", "TOWERTO");
   query4->addToOutputList("TRIGGERBOARD.TOWERFROM", "TOWERFROM");
   query4->addToOutputList("TRIGGERBOARD.SECTOR", "SECTOR");
   query4->addToOutputList("CHIP.POSITION", "POSITION");
   query4->addToOrderList("TOWERTO");
   query4->addToOrderList("SECTOR");
   query4->addToOrderList("POSITION");
   condition =
       "CHIP.CHIPID=CHIPDISABLED.CHIP_CHIPID AND CHIP.BOARD_BOARDID=BOARD.BOARDID AND "
       "BOARD.BOARDID=TRIGGERBOARD.TRIGGERBOARDID AND CHIP.TYPE='PAC'";
   query4->setCondition(condition, conditionData);
   coral::ICursor& cursor4 = query4->execute();
   while (cursor4.next()) {
     //    cursor4.currentRow().toOutputStream( std::cout ) << std::endl;
     const coral::AttributeList& row = cursor4.currentRow();
     int sector = atoi((row["SECTOR"].data<std::string>()).c_str());
     int first = atoi((row["TOWERTO"].data<std::string>()).c_str());
     int last = atoi((row["TOWERFROM"].data<std::string>()).c_str());
     int chipPos = row["POSITION"].data<short>();
     int tower = first + chipPos - 8;
     if (tower <= last) {
       for (int jSegment = 0; jSegment < 12; jSegment++) {
         disabledDevs->enablePAC(tower, sector, jSegment, false);
       }
     }
   }
   delete query4;
 }