---

l1t::DataWriter Class Reference

#include <CondTools/L1Trigger/interface/DataWriter.h>

Inheritance diagram for l1t::DataWriter:

List of all members.

Public Member Functions
	DataWriter (const std::string &connectString, const std::string &authenticationPath)
void	updateIOV (const std::string &tag, const std::string &payloadToken, const edm::RunNumber_t sinceRun)
void	writeKey (L1TriggerKey *key, const std::string &tag, const edm::RunNumber_t sinceRun)
void	writeKeyList (L1TriggerKeyList *keyList, const std::string &tag, edm::RunNumber_t sinceRun=0)
std::string	writePayload (const edm::EventSetup &setup, const std::string &recordType)
void	writePayload (L1TriggerKey &key, const edm::EventSetup &setup, const std::string &record, const std::string &type)
template<typename T>
void	writePayload (L1TriggerKey &key, T *payload, const std::string &recordName)
virtual	~DataWriter ()
Protected Types
typedef std::map< std::string, std::string >	TagToToken
Protected Member Functions
void	addMappings (const std::string tag, const std::string iovToken)
std::string	findTokenForTag (const std::string &tag)
Protected Attributes
TagToToken	tagToToken

---

Detailed Description

Definition at line 46 of file DataWriter.h.

---

Member Typedef Documentation

typedef std::map<std::string, std::string> l1t::DataWriter::TagToToken [protected]

Definition at line 101 of file DataWriter.h.

---

Constructor & Destructor Documentation

l1t::DataWriter::DataWriter	(	const std::string &	connectString,
		const std::string &	authenticationPath
	)			[inline, explicit]

Definition at line 55 of file DataWriter.h.

    : DataManager( connectString, authenticationPath ) {};

virtual l1t::DataWriter::~DataWriter

(

)

[inline, virtual]

Definition at line 58 of file DataWriter.h.

{};

---

Member Function Documentation

void l1t::DataWriter::addMappings	(	const std::string	tag,
		const std::string	iovToken
	)			[protected]

Definition at line 114 of file DataWriter.cc.

References cond::MetaData::addMapping(), cond::CoralTransaction::commit(), l1t::DataManager::connection, cond::Connection::coralTransaction(), l1t::DataManager::metadata, and cond::CoralTransaction::start().

Referenced by updateIOV(), writeKey(), and writeKeyList().

{
  //    coral->connect (cond::ReadWriteCreate);
  //connection->connect( session ) ;
  cond::CoralTransaction& coral = connection->coralTransaction() ;
  //    coral->startTransaction (false);
    coral.start (false);

    metadata->addMapping (tag, iovToken); // default timetype = run number

    coral.commit ();
    //    coral->disconnect ();
    //connection->disconnect ();
}

std::string l1t::DataWriter::findTokenForTag

(

const std::string &

tag

)

[protected]

Definition at line 17 of file DataWriter.cc.

References l1t::DataManager::connection, cond::Connection::coralTransaction(), cond::MetaData::getToken(), cond::MetaData::hasTag(), l1t::DataManager::metadata, and tagToToken.

Referenced by updateIOV(), writeKey(), and writeKeyList().

{
    // fast check in cashe
    TagToToken::const_iterator found = tagToToken.find (tag);
    if (found != tagToToken.end ())
        return found->second;

    // else slow way, also we may need to create db
//     coral->connect (cond::ReadWriteCreate);
//     coral->startTransaction (false);
    // connection->connect ( session );
  cond::CoralTransaction& coral = connection->coralTransaction() ;
    coral.start (false);

    std::string tagToken;
    if (metadata->hasTag (tag))
        tagToken = metadata->getToken (tag);

    coral.commit ();
//     coral->disconnect ();
    //connection->disconnect ();

    // if not found empty string is returned
    return tagToken;
}

void l1t::DataWriter::updateIOV	(	const std::string &	tag,
		const std::string &	payloadToken,
		const edm::RunNumber_t	sinceRun
	)

Definition at line 274 of file DataWriter.cc.

References addMappings(), cond::IOVEditor::append(), cond::PoolTransaction::commit(), l1t::DataManager::connection, cond::IOVEditor::create(), findTokenForTag(), cond::IOVEditor::insert(), cond::IOVService::newIOVEditor(), cond::IOVService::payloadToken(), cond::Connection::poolTransaction(), cond::runnumber, cond::PoolTransaction::start(), tagToToken, HLT_VtxMuL3::timetype, cond::timeTypeSpecs, and cond::IOVEditor::token().

Referenced by L1CondDBIOVWriter::analyze().

{
  edm::LogVerbatim( "L1-O2O" )<< tag << " PAYLOAD TOKEN " << payloadToken ;

   // Get IOVToken for given tag
   std::string tagToken = findTokenForTag( tag ) ;
   bool requireMapping = tagToken.empty() ;

    cond::PoolTransaction& pool = connection->poolTransaction() ;
    pool.start( false ) ;

    cond::IOVService iov( pool ) ;

    // Create editor, with or without tagToken
    cond::IOVEditor* editor ;
    editor = iov.newIOVEditor( tagToken ) ;

    // Insert new IOV
    cond::TimeType timetype = cond::runnumber; 
    cond::Time_t globalSince = cond::timeTypeSpecs[timetype].beginValue; 

    if( requireMapping )
      {
        // insert() sets till-time, not since-time -- will this work?
        editor->create( globalSince, timetype ) ;
      }

    if( sinceRun == globalSince || requireMapping )
      {
        cond::Time_t globalTill = cond::timeTypeSpecs[timetype].endValue; 
        editor->insert (globalTill, payloadToken );
        tagToken = editor->token() ;
        edm::LogVerbatim( "L1-O2O" ) << tag << " IOV TOKEN " << tagToken
                                     << " SINCE " << globalSince ;
      }
    else
      {
        if( iov.payloadToken( tagToken, sinceRun ) != payloadToken )
          {
            editor->append( sinceRun, payloadToken ) ;
            edm::LogVerbatim( "L1-O2O" ) << tag << " IOV TOKEN " << tagToken
                                         << " SINCE " << sinceRun ;
          }
        else
          {
            edm::LogVerbatim( "L1-O2O" ) << "IOV already up to date." ;
          }
      }
    delete editor ;

    // Is this necessary?
    pool.commit() ;

    if( tagToToken.find( tag ) != tagToToken.end () )
    {
       tagToToken.insert( std::make_pair( tag, tagToken ) ) ;
    }

    // Assign payload token with IOV value
    if( requireMapping )
    {
       addMappings( tag, tagToken ) ;
    }
}

void l1t::DataWriter::writeKey	(	L1TriggerKey *	key,
		const std::string &	tag,
		const edm::RunNumber_t	sinceRun
	)

Definition at line 43 of file DataWriter.cc.

References addMappings(), cond::IOVEditor::append(), cond::PoolTransaction::commit(), l1t::DataManager::connection, cond::IOVEditor::create(), findTokenForTag(), cond::IOVEditor::insert(), cond::TypedRef< T >::markWrite(), cond::IOVService::newIOVEditor(), cond::IOVService::payloadToken(), cond::Connection::poolTransaction(), cond::runnumber, cond::PoolTransaction::start(), tagToToken, HLT_VtxMuL3::timetype, cond::timeTypeSpecs, cond::TypedRef< T >::token(), and cond::IOVEditor::token().

{
    // writting key as bit more complicated. At this time we have to worry
    // about such things if the key already exists or not
    // Also we need to get IOVToken for given tag if key exist
    // if it does not, then we need to addMapping in the end

    // Bad part - get TagTokent for given tag.
    // We use layzy cash to save all tag adn tokens, in case we save key with same tag
    std::string tagToken = findTokenForTag (tag);
    bool requireMapping = tagToken.empty ();

    //    pool->connect ();
    //connection->connect ( session );
    cond::PoolTransaction& pool = connection->poolTransaction() ;
    pool.start (false);

    cond::TypedRef<L1TriggerKey> ref (pool, key);
    ref.markWrite ("L1TriggerKeyRcd");

    cond::IOVService iov (pool);

    // Create editor, with or wothoug TagToken
    cond::IOVEditor * editor;
    editor = iov.newIOVEditor (tagToken);

    // finally insert new IOV
    cond::TimeType timetype = cond::runnumber; 
    cond::Time_t globalSince = cond::timeTypeSpecs[timetype].beginValue; 

    if( requireMapping )
      {
        editor->create( globalSince, timetype ) ;
      }

    if( sinceRun == globalSince || requireMapping )
      {
        cond::Time_t globalTill = cond::timeTypeSpecs[timetype].endValue; 
        editor->insert (globalTill, ref.token ());
        tagToken = editor->token ();
        edm::LogVerbatim( "L1-O2O" ) << "L1TriggerKey IOV TOKEN " << tagToken ;
      }
    else
      {
        if( iov.payloadToken( tagToken, sinceRun ) != ref.token() )
          {
            editor->append( sinceRun, ref.token() ) ;
            edm::LogVerbatim( "L1-O2O" ) << tag << "L1TriggerKey IOV TOKEN "
                                         << tagToken ;
          }
        else
          {
            edm::LogVerbatim( "L1-O2O" ) << "IOV already up to date." ;
          }
      }
    delete editor;

    pool.commit ();
    //    pool->disconnect ();
    //connection->disconnect ();

    if (tagToToken.find (tag) != tagToToken.end ())
        tagToToken.insert (std::make_pair (tag, tagToken));

    // Assign payload token with IOV value
    if (requireMapping)
        addMappings (tag, tagToken);
}

void l1t::DataWriter::writeKeyList	(	L1TriggerKeyList *	keyList,
		const std::string &	tag,
		edm::RunNumber_t	sinceRun = 0
	)

Definition at line 200 of file DataWriter.cc.

References addMappings(), cond::IOVEditor::append(), cond::PoolTransaction::commit(), l1t::DataManager::connection, cond::IOVEditor::create(), findTokenForTag(), cond::IOVEditor::insert(), cond::TypedRef< T >::markWrite(), cond::IOVService::newIOVEditor(), cond::IOVService::newIOVIterator(), cond::IOVIterator::next(), cond::Connection::poolTransaction(), cond::runnumber, cond::PoolTransaction::start(), tagToToken, HLT_VtxMuL3::timetype, cond::timeTypeSpecs, cond::TypedRef< T >::token(), cond::IOVEditor::token(), and cond::IOVIterator::validity().

Referenced by L1CondDBPayloadWriter::analyze().

{
   // Get IOVToken for given tag
   std::string tagToken = findTokenForTag( tag ) ;
   bool requireMapping = tagToken.empty() ;

    cond::PoolTransaction& pool = connection->poolTransaction() ;
    pool.start( false ) ;

    cond::TypedRef< L1TriggerKeyList > ref( pool, keyList ) ;
    ref.markWrite( "L1TriggerKeyListRcd" ) ;

    cond::IOVService iov( pool ) ;

    // Create editor, with or without tagToken
    cond::IOVEditor* editor ;
    editor = iov.newIOVEditor( tagToken ) ;

    // Insert new IOV
    cond::TimeType timetype = cond::runnumber; 
    cond::Time_t globalSince = cond::timeTypeSpecs[timetype].beginValue; 

    if( requireMapping )
      {
        edm::LogVerbatim( "L1-O2O" ) << "GLOBAL SINCE " << globalSince
                                     << " SINCE " << sinceRun ;

        editor->create( globalSince, timetype ) ;
        sinceRun = globalSince ;
      }
    else if( sinceRun == 0 ) // find last since and add 1
      {
        cond::IOVIterator* itr = iov.newIOVIterator( tagToken ) ;
        while( itr->next() )
          {
            sinceRun = itr->validity().first ;
          }
        ++sinceRun ;
        delete itr ;
      }

    if( sinceRun == globalSince )
      {
        cond::Time_t globalTill = cond::timeTypeSpecs[timetype].endValue; 
        editor->insert (globalTill, ref.token ());
      }
    else
      {
        editor->append( sinceRun, ref.token() ) ;
      }
    tagToken = editor->token() ;
    delete editor ;

    // Is this necessary?
    pool.commit() ;

    if( tagToToken.find( tag ) != tagToToken.end () )
    {
       tagToToken.insert( std::make_pair( tag, tagToken ) ) ;
    }

    // Assign payload token with IOV value
    if( requireMapping )
    {
       addMappings( tag, tagToken ) ;
    }

    edm::LogVerbatim( "L1-O2O" ) << "L1TriggerKeyList IOV TOKEN " << tagToken
                                 << " TAG " << tag << " SINCE " << sinceRun ;
}

std::string l1t::DataWriter::writePayload	(	const edm::EventSetup &	setup,
		const std::string &	recordType
	)

Definition at line 173 of file DataWriter.cc.

References cond::PoolTransaction::commit(), l1t::DataManager::connection, Exception, DBSPlugin::get(), cond::Connection::poolTransaction(), l1t::WriterProxy::save(), and cond::PoolTransaction::start().

{
    WriterFactory* factory = WriterFactory::get();
    WriterProxy* writer = factory->create( recordType + "@Writer" ) ;
    if( writer == 0 )
      {
        throw cond::Exception( "DataWriter: could not create WriterProxy with name "
                               + recordType + "@Writer" ) ;
      }
    //assert( writer != 0 );

    cond::PoolTransaction& pool = connection->poolTransaction() ;
    pool.start( false ) ;

    // update key to have new payload registered for record-type pair.
    std::string payloadToken = writer->save( setup, pool ) ;
    edm::LogVerbatim( "L1-O2O" ) << recordType << " PAYLOAD TOKEN "
                                 << payloadToken ;

    delete writer;
    pool.commit ();

    return payloadToken ;
}

void l1t::DataWriter::writePayload	(	L1TriggerKey &	key,
		const edm::EventSetup &	setup,
		const std::string &	record,
		const std::string &	type
	)

Definition at line 134 of file DataWriter.cc.

References L1TriggerKey::add(), l1t::buildName(), cond::PoolTransaction::commit(), l1t::DataManager::connection, Exception, DBSPlugin::get(), name, cond::Connection::poolTransaction(), l1t::WriterProxy::save(), and cond::PoolTransaction::start().

{
    WriterFactory * factory = WriterFactory::get();
    const std::string name = buildName(record, type);
    WriterProxy * writer = factory->create(name);
    if( writer == 0 )
      {
        throw cond::Exception( "DataWriter: could not create WriterProxy with name "
                               + name ) ;
      }
    //assert (writer != 0);

    //    pool->connect ();
    //connection->connect ( session );
    cond::PoolTransaction& pool = connection->poolTransaction() ;
    //    pool->startTransaction (false);
    pool.start (false);

    // update key to have new payload registered for record-type pair.
    std::string payloadToken = writer->save(setup, pool);
    edm::LogVerbatim( "L1-O2O" ) << "TOKEN " << payloadToken ;
    if( payloadToken.empty() )
      {
        throw cond::Exception( "DataWriter: failure to write payload in "
                               + name ) ;
      }
    //assert (!payloadToken.empty ());

    key.add (record, type, payloadToken);

    delete writer;

    pool.commit ();
    // pool->disconnect ();
  //connection->disconnect ();
}

template<typename T>

void l1t::DataWriter::writePayload	(	L1TriggerKey &	key,
		T *	payload,
		const std::string &	recordName
	)			[inline]

Definition at line 108 of file DataWriter.h.

References L1TriggerKey::add(), edm::eventsetup::heterocontainer::HCTypeTagTemplate< T, Group >::className(), cond::PoolTransaction::commit(), l1t::DataManager::connection, cond::TypedRef< T >::markWrite(), cond::Connection::poolTransaction(), cond::PoolTransaction::start(), and cond::TypedRef< T >::token().

Referenced by L1CondDBPayloadWriter::analyze().

{
/*     pool->connect (); */
  //connection->connect ( session );
/*     pool->startTransaction (false); */
  cond::PoolTransaction& pool = connection->poolTransaction() ;
    pool.start (false);

    cond::TypedRef<T> ref (pool, payload);
    ref.markWrite (recordName);

    std::string typeName = 
        edm::eventsetup::heterocontainer::HCTypeTagTemplate<T, edm::eventsetup::DataKey>::className ();

    key.add (recordName, typeName, ref.token ());

    pool.commit ();
/*     pool->disconnect (); */
    //connection->disconnect ();
}

---

Member Data Documentation

TagToToken l1t::DataWriter::tagToToken [protected]

Definition at line 102 of file DataWriter.h.

Referenced by findTokenForTag(), updateIOV(), writeKey(), and writeKeyList().

---

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

• CondTools/L1Trigger/interface/DataWriter.h
• CondTools/L1Trigger/src/DataWriter.cc

---