L1CondDBIOVWriterExt.cc

Go to the documentation of this file.

#include <sstream>

#include "CondTools/L1TriggerExt/plugins/L1CondDBIOVWriterExt.h"
#include "CondTools/L1TriggerExt/interface/DataWriterExt.h"

#include "CondFormats/L1TObjects/interface/L1TriggerKeyExt.h"
#include "CondFormats/DataRecord/interface/L1TriggerKeyExtRcd.h"
#include "CondFormats/L1TObjects/interface/L1TriggerKeyListExt.h"
#include "CondFormats/DataRecord/interface/L1TriggerKeyListExtRcd.h"

#include "CondCore/CondDB/interface/Serialization.h"

L1CondDBIOVWriterExt::L1CondDBIOVWriterExt(const edm::ParameterSet& iConfig)
   : m_tscKey( iConfig.getParameter<std::string> ("tscKey") ),
     m_rsKey(  iConfig.getParameter<std::string> ("rsKey") ),
     m_ignoreTriggerKey( iConfig.getParameter<bool> ("ignoreTriggerKey") ),
     m_logKeys( iConfig.getParameter<bool>( "logKeys" ) ),
     m_logTransactions( iConfig.getParameter<bool>( "logTransactions" ) ),
     m_forceUpdate( iConfig.getParameter<bool>( "forceUpdate" ) )
{
   //now do what ever initialization is needed
   typedef std::vector<edm::ParameterSet> ToSave;
   ToSave toSave = iConfig.getParameter<ToSave> ("toPut");
   for (ToSave::const_iterator it = toSave.begin (); it != toSave.end (); it++)
   {
      std::string record = it->getParameter<std::string> ("record");
      std::string type = it->getParameter<std::string> ("type");
      m_recordTypes.push_back( record  + "@" + type ) ;
   }
}


L1CondDBIOVWriterExt::~L1CondDBIOVWriterExt()
{
 
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)

}

// ------------ method called to for each event  ------------
void
L1CondDBIOVWriterExt::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
{
   using namespace edm;

   // Get L1TriggerKeyListExt
   L1TriggerKeyListExt keyList ;
   l1t::DataWriterExt dataWriter ;
   if( !dataWriter.fillLastTriggerKeyList( keyList ) )
     {
       edm::LogError( "L1-O2O" )
         << "Problem getting last L1TriggerKeyListExt" ;
     }

   unsigned long long run = iEvent.id().run() ;

   L1TriggerKeyExt::RecordToKey recordTypeToKeyMap ;

   bool triggerKeyIOVUpdated = true ;

   // Start log string, convert run number into string
   std::stringstream ss ;
   ss << run ;
   std::string log = "KEYLOG runNumber=" + ss.str() ;
   bool logRecords = true ;

   std::string m_Key = m_tscKey + ":" + m_rsKey;

   if( !m_ignoreTriggerKey )
     {
       if( !m_tscKey.empty() && !m_rsKey.empty() )
     {
           edm::LogVerbatim( "L1-O2O" )
             << "Object key for L1TriggerKeyExt@L1TriggerKeyExtRcd: "
             << m_tscKey << " : " << m_rsKey ;

       // Use TSC key and L1TriggerKeyListExt to find next run's
       // L1TriggerKey token
       std::string keyToken = keyList.token( m_Key ) ;

       // Update IOV sequence for this token with since-time = new run 
       triggerKeyIOVUpdated =
         m_writer.updateIOV( "L1TriggerKeyExtRcd", keyToken, run, m_logTransactions ) ;

       // Read current L1TriggerKeyExt directly from ORCON using token
       L1TriggerKeyExt key ;
       m_writer.readObject( keyToken, key ) ;

       recordTypeToKeyMap = key.recordToKeyMap() ;

           // Replace spaces in key with ?s.  Do reverse substitution when
           // making L1TriggerKeyExt.
       std::string tmpKey = m_Key ;
           replace( tmpKey.begin(), tmpKey.end(), ' ', '?' ) ;
           log += " tscKey:rsKey=" + tmpKey ;
       logRecords = false ;
     }
       else
     {
       // For use with Run Settings, no corresponding L1TrigerKey in
       // ORCON.

       // Get L1TriggerKeyExt from EventSetup
       ESHandle< L1TriggerKeyExt > esKey ;
       iSetup.get< L1TriggerKeyExtRcd >().get( esKey ) ;

       recordTypeToKeyMap = esKey->recordToKeyMap() ;
     }
     }
   else
     {
       std::vector<std::string >::const_iterator
     recordTypeItr = m_recordTypes.begin() ;
       std::vector<std::string >::const_iterator
     recordTypeEnd = m_recordTypes.end() ;

       for( ; recordTypeItr != recordTypeEnd ; ++recordTypeItr )
     {
       recordTypeToKeyMap.insert(
         std::make_pair( *recordTypeItr, m_Key ) ) ;
     }
     }

   // If L1TriggerKeyExt IOV was already up to date, then so are all its
   // sub-records.
   bool throwException = false ;

   if( triggerKeyIOVUpdated || m_forceUpdate )
     {
       // Loop over record@type in L1TriggerKeyExt
       L1TriggerKeyExt::RecordToKey::const_iterator itr =
     recordTypeToKeyMap.begin() ;
       L1TriggerKeyExt::RecordToKey::const_iterator end =
     recordTypeToKeyMap.end() ;

       for( ; itr != end ; ++itr )
     {
       std::string recordType = itr->first ;
       std::string objectKey = itr->second ;

       std::string recordName( recordType,
                   0, recordType.find_first_of("@") ) ;

       if( logRecords )
         {
           // Replace spaces in key with ?s.  Do reverse substitution when
           // making L1TriggerKeyExt.
           std::string tmpKey = objectKey ;
           replace( tmpKey.begin(), tmpKey.end(), ' ', '?' ) ;
           log += " " + recordName + "Key=" + tmpKey ;
         }

       // Do nothing if object key is null.
       if( objectKey == L1TriggerKeyExt::kNullKey )
         {
           edm::LogVerbatim( "L1-O2O" )
         << "L1CondDBIOVWriterExt: null object key for "
         << recordType << "; skipping this record." ;
         }
       else
         {
           // Find payload token
               edm::LogVerbatim( "L1-O2O" )
                 << "Object key for "
                 << recordType << ": " << objectKey ;

           std::string payloadToken = keyList.token( recordType,
                             objectKey ) ;
           if( payloadToken.empty() )
         {
           edm::LogVerbatim( "L1-O2O" )
             << "L1CondDBIOVWriterExt: empty payload token for " +
             recordType + ", key " + objectKey ;

           throwException = true ;
         }
           else
         {
           m_writer.updateIOV( recordName,
                       payloadToken,
                       run,
                       m_logTransactions ) ;
         }
         }
     }
     }

   if( m_logKeys )
     {
       edm::LogVerbatim( "L1-O2O" ) << log ;
     }

   if( throwException )
     {
       throw cond::Exception( "L1CondDBIOVWriterExt: empty payload tokens" ) ;
     }
}


// ------------ method called once each job just before starting event loop  ------------
void 
L1CondDBIOVWriterExt::beginJob()
{
}

// ------------ method called once each job just after ending the event loop  ------------
void 
L1CondDBIOVWriterExt::endJob() {
}

//define this as a plug-in
//DEFINE_FWK_MODULE(L1CondDBIOVWriterExt);