CoolQuery Class Reference

#include <CoolQuery.h>

Collaboration diagram for CoolQuery:

Classes
struct	L1CountFolderData
struct	LumiFolderData

Public Member Functions
	CoolQuery (const std::string &database, const std::string &triggerchain)
	~CoolQuery ()
void	setDb (const std::string &database)
void	setTrigger (const std::string &triggerchain)
bool	openDbConn ()
void	setIOV (const cool::ValidityKey start, const cool::ValidityKey stop)
void	setIOVForRun (unsigned int runnum)
cool::ChannelId	getHLTChannelId (const std::string &trigger, const std::string &folder_name)
cool::ChannelId	getL1ChannelId (const std::string &trigger, const std::string &folder_name)
cool::ChannelId	getLumiChannelId (const std::string &lumimethod, const std::string &folder_name)
bool	channelIdValid ()
std::string	getHLTLowerChainName (const std::string &trigger, const std::string &folder_name)
cool::Int32	getL1PrescaleFromChannelId (const std::string &folder_name, const cool::ChannelId &id)
cool::Float	getHLTPrescaleFromChannelId (const std::string &folder_name, const cool::ChannelId &id)
void	printL1Triggers (const std::string &folder_name)
void	printHLTTriggers (const std::string &folder_name)
template<class T >
std::map< cool::ValidityKey, T >	getObjMapFromFolderAtChan (const std::string &obj_name, const std::string &folder_name, const cool::ChannelId &id)
template<class T >
std::map< cool::ValidityKey, T >	getTrigObjMapFromFolderByName (const std::string &obj_name, const std::string &folder_name, const std::string &trigger)
template<class T >
std::map< cool::ValidityKey, T >	getLumiIterator (const std::string &luminame, const std::string &folder_name, const std::string &tag, const cool::ChannelId &id)
unsigned int	getTriggerLevel (const std::string &triggername)
std::map< cool::ValidityKey, LumiFolderData >	getLumiFolderData (const std::string &folder_name, const std::string &tag, const cool::ChannelId &id)
std::map< cool::ValidityKey, L1CountFolderData >	getL1CountFolderData (const std::string &folder_name, const cool::ChannelId &id)
template<class T >
IOVData< T >	getIOVData (const std::string &name, const std::string &folder_name, const cool::ChannelId &id, const std::string &tag="")

Private Member Functions
std::string	transConn (const std::string &inconn)

Private Attributes
coral::ConnectionService	m_coralsvc
ReplicaSorter *	m_repsort
cool::IDatabasePtr	m_sourceDbPtr
std::string	m_database
std::string	m_triggerchain
cool::ValidityKey	m_VKstart
cool::ValidityKey	m_VKstop
Root::TMsgLogger	m_logger
bool	m_valid

Detailed Description

Definition at line 217 of file CoolQuery.h.

Constructor & Destructor Documentation

CoolQuery()

CoolQuery::CoolQuery	(	const std::string &	database,
		const std::string &	triggerchain
	)

Definition at line 9 of file CoolQuery.cxx.

                                                                            : 
  m_repsort(0),
  m_database(database), 
  m_triggerchain(triggerchain),
  m_VKstart(0),
  m_VKstop(0),
  m_logger( "CoolQuery" ),
  m_valid(false)
{
 
}

~CoolQuery()

CoolQuery::~CoolQuery

(

)

Definition at line 22 of file CoolQuery.cxx.

                      {
  if ( m_sourceDbPtr.use_count()>0 && m_sourceDbPtr->isOpen() ) {
     m_logger << Root::kINFO << "Closing database '" << m_sourceDbPtr->databaseName() << Root::GEndl;
     m_sourceDbPtr->closeDatabase();
  }
}

Member Function Documentation

channelIdValid()

bool CoolQuery::channelIdValid

(

)

Definition at line 250 of file CoolQuery.cxx.

                          {
  // m_logger << Root::kINFO << "channelIdValid = " << m_valid << Root::GEndl;
  return m_valid;
}

getHLTChannelId()

cool::ChannelId CoolQuery::getHLTChannelId	(	const std::string &	trigger,
		const std::string &	folder_name
	)

Definition at line 191 of file CoolQuery.cxx.

                                                                                              {
 
  // m_logger << Root::kINFO << "Getting channel id for HLT trigger [" << trigger << "] from folder [" << folder_name << "]" << Root::GEndl;
 
  m_valid = false;
 
  if (trigger == "") return UINT_MAX;
 
  cool::IFolderPtr folder_ptr = m_sourceDbPtr->getFolder(folder_name);
  cool::IObjectIteratorPtr obj_itr=folder_ptr->browseObjects(m_VKstart,m_VKstart, cool::ChannelSelection::all());
  // loop through all triggers
  // loop through all triggers
  while (obj_itr->goToNext()){
    const cool::IRecord& payload=obj_itr->currentRef().payload();
    if(payload["ChainName"].data<std::string>() == trigger){
      m_valid = true;
      // m_logger << Root::kINFO << "Found channel id: " << payload["ChainCounter"].data<cool::UInt32>() << Root::GEndl;
      return payload["ChainCounter"].data<cool::UInt32>();
    }
  }
  
  if(!m_valid){
    m_logger << Root::kERROR << "Couldn't find HLT trigger [" << trigger << "] in folder [" << folder_name << "]" << Root::GEndl;
  }
 
  // Nonsense value
  return UINT_MAX;
}

getHLTLowerChainName()

std::string CoolQuery::getHLTLowerChainName	(	const std::string &	trigger,
		const std::string &	folder_name
	)

Definition at line 256 of file CoolQuery.cxx.

                                                                                               {
 
  //  cout << "Getting lower chain name for trigger [" << trigger << "] from folder [" << folder_name << "] " << endl;
  bool found = false;
  cool::IFolderPtr folder_ptr = m_sourceDbPtr->getFolder(folder_name);
  cool::IObjectIteratorPtr obj_itr=folder_ptr->browseObjects(m_VKstart,m_VKstart, cool::ChannelSelection::all());
  // loop through all triggers
  while (obj_itr->goToNext()){
    const cool::IRecord& payload=obj_itr->currentRef().payload();
    if(payload["ChainName"].data<std::string>() == trigger){
      found = true;
      return payload["LowerChainName"].data<std::string>();
 
    }
  }
 
  if (!found) {
    m_logger << Root::kERROR << "Couldn't find HLT trigger [" << trigger << "] in folder [" << folder_name << "]" << Root::GEndl;
 
    //    m_logger << Root::kINFO << "List of triggers, hth: " << Root::GEndl;
    //    cool::IObjectIteratorPtr obj_itr2=folder_ptr->browseObjects(m_VKstart,m_VKstart, cool::ChannelSelection::all());
    //    while (obj_itr2->goToNext()){
    //      const cool::IRecord& payload2=obj_itr2->currentRef().payload();
    //      m_logger << Root::kINFO << payload2["ChainName"].data<std::string>()  << ", ";
    //    }
    //    m_logger << Root::kINFO << Root::GEndl;
  }
 
  return "";
 
}

getHLTPrescaleFromChannelId()

cool::Float CoolQuery::getHLTPrescaleFromChannelId	(	const std::string &	folder_name,
		const cool::ChannelId &	id
	)

Definition at line 123 of file CoolQuery.cxx.

                                                                                                      {
 
  cool::IFolderPtr folder_ptr = m_sourceDbPtr->getFolder(folder_name);
  cool::IObjectIteratorPtr itr = folder_ptr->browseObjects(m_VKstart, m_VKstop,id);
 
  // Need to iterate once to get to first valid record, do it this way to avoid Coverity warning
  if (itr->goToNext()) {
    const cool::IRecord& payload=itr->currentRef().payload();    
    return payload["Prescale"].data<cool::Float>();
  }
 
  // Nonsense value
  return -1.;
 
}

getIOVData()

template<class T >

IOVData< T > CoolQuery::getIOVData	(	const std::string &	name,
		const std::string &	folder_name,
		const cool::ChannelId &	id,
		const std::string &	tag = ""
	)

Definition at line 421 of file CoolQuery.h.

                                                                                                                            {
 
  IOVData<T> mydata;
 
  cool::IFolderPtr folder_ptr = m_sourceDbPtr->getFolder(folder_name);
  cool::ChannelSelection chsel(id);
  if(!folder_ptr->existsChannel(id)){
    m_logger << Root::kWARNING << "Channel " << id << " does not exist in database " << folder_name << "!" << Root::GEndl; 
    return mydata;
  }
 
  // Try with or without tag
  cool::IObjectIteratorPtr itr;
  if (folder_ptr->existsUserTag(tag)) {
    itr = folder_ptr->browseObjects(m_VKstart, m_VKstop, id, tag);
  } else {
    itr = folder_ptr->browseObjects(m_VKstart, m_VKstop, id);
  }
 
  while (itr->goToNext()) {
    IOVTime since, until;
    since.setRETime(itr->currentRef().since());
    until.setRETime(itr->currentRef().until());
 
    IOVRange range(since, until);
 
    const cool::IRecord& payload=itr->currentRef().payload();
 
    mydata.add( range, payload[obj_name].data<T>() );
  }
 
  return  mydata;
}

getL1ChannelId()

cool::ChannelId CoolQuery::getL1ChannelId	(	const std::string &	trigger,
		const std::string &	folder_name
	)

Definition at line 139 of file CoolQuery.cxx.

                                                                                             {
 
  //  m_logger << Root::kINFO << "Getting channel id for L1 trigger [" << trigger << "] from folder [" << folder_name << "]" << Root::GEndl;
 
  m_valid = false;
 
  if (trigger == "") return UINT_MAX;
 
  cool::IFolderPtr folder_ptr = m_sourceDbPtr->getFolder(folder_name);
  cool::IObjectIteratorPtr obj_itr=folder_ptr->browseObjects(m_VKstart,m_VKstart, cool::ChannelSelection::all());
  // loop through all triggers
  while (obj_itr->goToNext()){
    const cool::IRecord& payload=obj_itr->currentRef().payload();
    // find the L1 trigger chain
    if(payload["ItemName"].data<std::string>() == trigger){
      m_valid = true;
      //      cout << "Channel id: " << obj_itr->currentRef().channelId() << endl;
      return obj_itr->currentRef().channelId();
    }
  }
 
  if(!m_valid){
    m_logger << Root::kERROR << "Couldn't find L1 trigger [" << trigger << "] in folder [" << folder_name << "]" << Root::GEndl;
  }
 
 
  // Nonsense value
  return UINT_MAX;
}

getL1CountFolderData()

std::map< cool::ValidityKey, CoolQuery::L1CountFolderData > CoolQuery::getL1CountFolderData	(	const std::string &	folder_name,
		const cool::ChannelId &	id
	)

Definition at line 324 of file CoolQuery.cxx.

                                                                                     {
 
  std::map<cool::ValidityKey, L1CountFolderData> mymap;
  L1CountFolderData folderData;
 
  cool::IFolderPtr folder_ptr = m_sourceDbPtr->getFolder(folder_name);
  //  m_logger << Root::kWARNING << "Getting from database " << m_database << " tag " << tag << Root::GEndl; 
  if (!folder_ptr->existsChannel(id)) {
    m_logger << Root::kWARNING << "Lumi channel id " << id << " does not exist in database " << folder_name << "!" << Root::GEndl;
    return mymap;
  }
 
  cool::IObjectIteratorPtr itr;
 
  itr = folder_ptr->browseObjects(m_VKstart, m_VKstop, id);
 
  while (itr->goToNext()) {
    const cool::IRecord& payload=itr->currentRef().payload();
    folderData.BeforePrescale = payload["BeforePrescale"].data<cool::UInt63>();
    folderData.AfterPrescale = payload["AfterPrescale"].data<cool::UInt63>();
    folderData.L1Accept = payload["L1Accept"].data<cool::UInt63>();
    mymap.insert( std::pair<cool::ValidityKey, L1CountFolderData>(itr->currentRef().since(), folderData));
  }
  
  return mymap;
 
}

getL1PrescaleFromChannelId()

cool::Int32 CoolQuery::getL1PrescaleFromChannelId	(	const std::string &	folder_name,
		const cool::ChannelId &	id
	)

Definition at line 107 of file CoolQuery.cxx.

                                                                                                     {
 
  cool::IFolderPtr folder_ptr = m_sourceDbPtr->getFolder(folder_name);
  cool::IObjectIteratorPtr itr = folder_ptr->browseObjects(m_VKstart, m_VKstop,id);
 
  // Need to iterate once to get to first valid record, do it this way to avoid Coverity warning
  if (itr->goToNext()) {
    const cool::IRecord& payload=itr->currentRef().payload();    
    return payload["Lvl1Prescale"].data<cool::Int32>();
  }
 
  // Nonsense value
  return UINT_MAX;
 
}

getLumiChannelId()

cool::ChannelId CoolQuery::getLumiChannelId	(	const std::string &	lumimethod,
		const std::string &	folder_name
	)

Definition at line 170 of file CoolQuery.cxx.

                                                                                                  {
 
  m_valid = false;
 
  if (lumimethod == "") return UINT_MAX;
 
  // m_logger << Root::kINFO << "Getting channel id for Lumi method: " << lumimethod << " in folder " << folder_name << Root::GEndl;
 
  cool::IFolderPtr folder_ptr = m_sourceDbPtr->getFolder(folder_name);
  if(folder_ptr->existsChannel(lumimethod)){
    m_valid = true;
    return folder_ptr->channelId(lumimethod);
  }else{
    m_logger << Root::kWARNING << "Couldn't find lumimethod: " << lumimethod << " in COOL database!" << Root::GEndl;
  }
 
  // Nonsense value
  return UINT_MAX;
}

getLumiFolderData()

std::map< cool::ValidityKey, CoolQuery::LumiFolderData > CoolQuery::getLumiFolderData	(	const std::string &	folder_name,
		const std::string &	tag,
		const cool::ChannelId &	id
	)

Definition at line 290 of file CoolQuery.cxx.

                                                                                                        {
 
  std::map<cool::ValidityKey, LumiFolderData> mymap;
  LumiFolderData folderData;
 
  cool::IFolderPtr folder_ptr = m_sourceDbPtr->getFolder(folder_name);
  //  m_logger << Root::kWARNING << "Getting from database " << m_database << " tag " << tag << Root::GEndl; 
  if (!folder_ptr->existsChannel(id)) {
    m_logger << Root::kWARNING << "Lumi channel id " << id << " does not exist in database " << folder_name << "!" << Root::GEndl;
    return mymap;
  }
 
  cool::IObjectIteratorPtr itr;
  if(folder_ptr->existsUserTag(tag)) {
    itr = folder_ptr->browseObjects(m_VKstart, m_VKstop, id, tag);
  } else {
    // Try without specifying tag
    itr = folder_ptr->browseObjects(m_VKstart, m_VKstop, id);
  }
 
  while (itr->goToNext()) {
    const cool::IRecord& payload=itr->currentRef().payload();
    folderData.LBAvInstLumi = payload["LBAvInstLumi"].data<float>();
    folderData.LBAvEvtsPerBX = payload["LBAvEvtsPerBX"].data<float>();
    folderData.Valid = payload["Valid"].data<cool::UInt32>();
    mymap.insert( std::pair<cool::ValidityKey, LumiFolderData>(itr->currentRef().since(), folderData));
  }
  
  return mymap;
 
}

getLumiIterator()

template<class T >

std::map< cool::ValidityKey, T > CoolQuery::getLumiIterator	(	const std::string &	luminame,
		const std::string &	folder_name,
		const std::string &	tag,
		const cool::ChannelId &	id
	)

Definition at line 397 of file CoolQuery.h.

                                                                                                                                                            {
 
  std::map<cool::ValidityKey, T> mymap;
  cool::IFolderPtr folder_ptr = m_sourceDbPtr->getFolder(folder_name);
  //  m_logger << Root::kWARNING << "Getting from database " << m_database << " tag " << tag << Root::GEndl; 
  if(folder_ptr->existsChannel(id) && folder_ptr->existsUserTag(tag)){
    cool::IObjectIteratorPtr itr = folder_ptr->browseObjects(m_VKstart, m_VKstop, id, tag);
    while (itr->goToNext()) {
      const cool::IRecord& payload=itr->currentRef().payload();
      mymap.insert( std::pair<cool::ValidityKey, T>(itr->currentRef().since() ,payload[luminame].data<T>()));
    }
  }else if(folder_ptr->existsChannel(id) && !folder_ptr->existsUserTag(tag)){
    // ok, tag doesn't exist, still try to use an untagged way of accessing data
    mymap = CoolQuery::getObjMapFromFolderAtChan<T>(luminame, folder_name,id);
  }else{
    m_logger << Root::kWARNING << "Lumi tag " << tag << " does not exist, or Lumi channel id " << id << " does not exist in database." << Root::GEndl;
  }
  return mymap;
 
}

getObjMapFromFolderAtChan()

template<class T >

std::map< cool::ValidityKey, T > CoolQuery::getObjMapFromFolderAtChan	(	const std::string &	obj_name,
		const std::string &	folder_name,
		const cool::ChannelId &	id
	)

Definition at line 375 of file CoolQuery.h.

                                                                                                                                               {
  //  m_logger << Root::kWARNING << "Getting object [" << obj_name << "] from folder [" << folder_name << "], in channel: " << id << ", in LB range: " << (m_VKstart >> 32) << ", " << (m_VKstart & 0xFFFFFFFF) << " - " << (m_VKstop >> 32) << ","<< (m_VKstop & 0xFFFFFFFF)  << Root::GEndl;
  std::map<cool::ValidityKey, T> mymap;
  cool::IFolderPtr folder_ptr = m_sourceDbPtr->getFolder(folder_name);
  cool::ChannelSelection chsel(id);
  if(folder_ptr->existsChannel(id)){
    cool::IObjectIteratorPtr itr = folder_ptr->browseObjects(m_VKstart, m_VKstop,chsel);
    while (itr->goToNext()) {
      const cool::IRecord& payload=itr->currentRef().payload();
      //     std::cout << "Inserting: " << (itr->currentRef().since() >> 32) << " - " << (itr->currentRef().since() & 0xFFFFFF) << ", " << payload[obj_name].data<T>() << std::endl;
      mymap.insert( std::pair<cool::ValidityKey, T>(itr->currentRef().since() ,payload[obj_name].data<T>()));
    }
  }else{
    m_logger << Root::kWARNING << "Channel " << id << " does not exist in database." << Root::GEndl; 
/*     const std::map<cool::ChannelId,std::string> list = folder_ptr->listChannelsWithNames(); */
  }
  return  mymap;
}

getTriggerLevel()

unsigned int CoolQuery::getTriggerLevel

(

const std::string &

triggername

)

Definition at line 79 of file CoolQuery.cxx.

                                                                   {
 
  size_t found = triggername.find_first_of('_');
  if(found != std::string::npos){
    std::string s_lvl = triggername.substr(0,found);
    if(s_lvl == "EF") return 3;
    if(s_lvl == "L2") return 2;
    if(s_lvl == "L1") return 1;
    if(s_lvl == "HLT") return 2;
  }
 
  // Indicate no valid trigger name passed
  return 0;
    
}

getTrigObjMapFromFolderByName()

template<class T >

std::map< cool::ValidityKey, T > CoolQuery::getTrigObjMapFromFolderByName	(	const std::string &	obj_name,
		const std::string &	folder_name,
		const std::string &	trigger
	)

Definition at line 345 of file CoolQuery.h.

                                                                                                                                                    {
  // m_logger << Root::kWARNING << "Getting object [" << obj_name << "] from folder [" << folder_name << "], in LB range: " << (m_VKstart >> 32) << ", " << (m_VKstart & 0xFFFFFFFF) << " - " << (m_VKstop >> 32) << ","<< (m_VKstop & 0xFFFFFFFF)  << Root::GEndl;
  std::map<cool::ValidityKey, T> mymap;
  bool found = false;
  cool::IFolderPtr folder_ptr = m_sourceDbPtr->getFolder(folder_name);
  cool::IObjectIteratorPtr obj_itr=folder_ptr->browseObjects(m_VKstart,m_VKstart, cool::ChannelSelection::all());
  // loop through all triggers
  while (obj_itr->goToNext()){
 
    const cool::IRecord& payload=obj_itr->currentRef().payload();
    //    std::cout << "ChainNames: " << payload["ChainName"].data<std::string>() << std::endl;
 
    if(payload["ChainName"].data<std::string>() == trigger){
      found = true;
      const cool::IRecord& payload=obj_itr->currentRef().payload();
      //      std::cout << "Inserting: " << (obj_itr->currentRef().since() >> 32) << " - " << (obj_itr->currentRef().since() & 0xFFFFFF) << ", " << payload[obj_name].data<T>() << std::endl;
      mymap.insert( std::pair<cool::ValidityKey, T>(obj_itr->currentRef().since() ,payload[obj_name].data<T>()));
    }
  }
 
  if(!found){
    m_logger << Root::kERROR << "Couldn't find HLT trigger [" << trigger << "] in folder [" << folder_name << "]" << Root::GEndl;
  }
 
  return  mymap;
}

openDbConn()

bool CoolQuery::openDbConn

(

)

Definition at line 30 of file CoolQuery.cxx.

                           {
 
  m_logger << Root::kINFO << "Trying to connect to database " << m_database << "..." << Root::GEndl;
 
  //  CoraCoolDatabaseSvc& corasvc = CoraCoolDatabaseSvcFactory::databaseService();
 
  cool::IDatabaseSvc& databasesvc = cool::DatabaseSvcFactory::databaseService();
  //std::cout << "Done the CoraCool initialisation" << std::endl;
  //std::cout << "Opening CORAL database" << std::endl;
  try {
    m_repsort=new ReplicaSorter();
    coral::IConnectionServiceConfiguration& csconfig=m_coralsvc.configuration();
    csconfig.setReplicaSortingAlgorithm(*m_repsort);
 
    m_sourceDbPtr = databasesvc.openDatabase(m_database,true);// true --> readonly
    //    m_sourceCoraPtr=corasvc.openDatabase(m_database,true);// true --> readonly
    //std::cout << "....database connections open OK" << std::endl;
    return true;
   }
  catch (std::exception&e) {
    m_logger << Root::kERROR << "Problem opening CORAL database: " << e.what() << Root::GEndl;
    return false;
  }
  //  std::cout << "Done the database opening" << std::endl;
  
  // list the COOL folders found in the database
 
//    const std::vector<std::string>& folders=m_sourceDbPtr->listAllNodes();
//    std::cout << "COOL database has " << folders.size() << " folders defined"
//          << std::endl;
//    for (std::vector<std::string>::const_iterator itr=folders.begin();
//         itr!=folders.end();++itr) std::cout << *itr << std::endl;
 
  return false;
 
}

printHLTTriggers()

void CoolQuery::printHLTTriggers

(

const std::string &

folder_name

)

Definition at line 235 of file CoolQuery.cxx.

                                                        {
 
  m_logger << Root::kINFO << "Listing available triggers [triggername(prescale, chanid)]: " << Root::GEndl;
 
  cool::IFolderPtr folder_ptr = m_sourceDbPtr->getFolder(folder_name);
  cool::IObjectIteratorPtr obj_itr2=folder_ptr->browseObjects(m_VKstart,m_VKstart, cool::ChannelSelection::all());
  while (obj_itr2->goToNext()){
    const cool::IRecord& payload2=obj_itr2->currentRef().payload();
    //      m_logger << Root::kINFO << payload2["ChainName"].data<std::string>()  << ", ";
    m_logger << Root::kINFO << payload2["ChainName"].data<std::string>()  << "(" << payload2["Prescale"].data<cool::Float>() << ", " << payload2["ChainCounter"].data<cool::UInt32>() << "), ";
  }
  m_logger << Root::kINFO << Root::GEndl;
}

printL1Triggers()

void CoolQuery::printL1Triggers

(

const std::string &

folder_name

)

Definition at line 221 of file CoolQuery.cxx.

                                                       {
 
  m_logger << Root::kINFO << "Listing available triggers [triggername(prescale, chanid)]: " << Root::GEndl;
 
  cool::IFolderPtr folder_ptr = m_sourceDbPtr->getFolder(folder_name);
  cool::IObjectIteratorPtr obj_itr=folder_ptr->browseObjects(m_VKstart,m_VKstart, cool::ChannelSelection::all());
  while (obj_itr->goToNext()){
    const cool::IRecord& payload=obj_itr->currentRef().payload();
    m_logger << Root::kINFO << payload["ItemName"].data<std::string>()  << "(" << this->getL1PrescaleFromChannelId("/TRIGGER/LVL1/Prescales",this->getL1ChannelId(payload["ItemName"].data<std::string>(), folder_name)) << ", " << obj_itr->currentRef().channelId() << "), ";
  }
  m_logger << Root::kINFO << Root::GEndl;
}

setDb()

void CoolQuery::setDb ( const std::string &  database )

inline

Definition at line 232 of file CoolQuery.h.

setIOV()

void CoolQuery::setIOV	(	const cool::ValidityKey	start,
		const cool::ValidityKey	stop
	)

Definition at line 96 of file CoolQuery.cxx.

                                                                             {
  m_VKstart = start;
  m_VKstop = stop;
}

setIOVForRun()

void CoolQuery::setIOVForRun

(

unsigned int

runnum

)

Definition at line 101 of file CoolQuery.cxx.

                                                {
  cool::ValidityKey run = runnum;
  m_VKstart = (run << 32);
  m_VKstop = ((run+1) << 32) - 1;
}

setTrigger()

void CoolQuery::setTrigger ( const std::string &  triggerchain )

inline

Definition at line 235 of file CoolQuery.h.

transConn()

std::string CoolQuery::transConn ( const std::string &  inconn )

private

Definition at line 68 of file CoolQuery.cxx.

                                                      {
  // translate simple connection string (no slash) to mycool.db with given                                                                                                              
  // instance name, all others are left alone                                                                                                                                           
  if (inconn.find('/')==std::string::npos) {
    return "sqlite://X;schema=mycool.db;dbname="+inconn;
  } else {
    return inconn;
  }
}

Member Data Documentation

m_coralsvc

coral::ConnectionService CoolQuery::m_coralsvc

private

Definition at line 326 of file CoolQuery.h.

m_database

std::string CoolQuery::m_database

private

Definition at line 329 of file CoolQuery.h.

m_logger

Root::TMsgLogger CoolQuery::m_logger

private

Definition at line 334 of file CoolQuery.h.

m_repsort

ReplicaSorter* CoolQuery::m_repsort

private

Definition at line 327 of file CoolQuery.h.

m_sourceDbPtr

cool::IDatabasePtr CoolQuery::m_sourceDbPtr

private

Definition at line 328 of file CoolQuery.h.

m_triggerchain

std::string CoolQuery::m_triggerchain

private

Definition at line 330 of file CoolQuery.h.

m_valid

bool CoolQuery::m_valid

private

Definition at line 336 of file CoolQuery.h.

m_VKstart

cool::ValidityKey CoolQuery::m_VKstart

private

Definition at line 331 of file CoolQuery.h.

m_VKstop

cool::ValidityKey CoolQuery::m_VKstop

private

Definition at line 332 of file CoolQuery.h.

---

The documentation for this class was generated from the following files:

• CoolQuery.h
• CoolQuery.cxx