InnerDetector/InDetMonitoring/InDetGlobalMonitoring/macros/EnhancedPrimaryVertexMonitoring/TrigD3PD/ChainGroup.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
// $Id: ChainGroup.cxx 318255 2010-08-27 11:46:34Z krasznaa $
 
// STL include(s):
#include <algorithm>
#include <cmath>
 
// ROOT include(s):
#include <TRegexp.h>
#include <TString.h>
 
// Local include(s):
#include "ChainGroup.h"
#include "IDataAccess.h"
#include "TrigConfigSvcD3PD.h"
 
ClassImp( D3PD::ChainGroup )
 
namespace D3PD {
 
   ChainGroup::ChainGroup( const std::vector< std::string >& triggerNames,
                           const Trig::IDataAccess& parent,
                           TrigConfigSvcD3PD& svc )
      : TNamed( "ChainGroup", "A particular chain group" ),
        m_parent( parent ), m_configSvc( svc ), m_triggerNames( triggerNames ) {
 
   }
 
   Bool_t ChainGroup::IsPassed( TrigDefs::DecisionTypes type ) {
 
      //
      // Make sure the object is up to date:
      //
      if( ! Update() ) {
         Error( "IsPassed", "Trigger(s) can't be evaluated" );
         return kFALSE;
      }
 
      //
      // Loop over the matching triggers:
      //
      for( size_t i = 0; i < m_existingTriggers.size(); ++i ) {
 
         // If this is a LVL1 item:
         if( m_existingTriggers[ i ].find( "L1_" ) != std::string::npos ) {
 
            // Variables helping in looking up the correct bit in the result:
            const Int_t word = m_existingIDs[ i ] / 32;
            const Int_t bit  = m_existingIDs[ i ] % 32;
 
            switch( type ) {
 
            case TrigDefs::Physics:
               if( m_parent.GetDetailLevel() >= 0 ) {
                  // Return right away if the trigger fired
                  if( ( ( * m_parent.GetL1Result( Trig::IDataAccess::TAV ) )[ word ] >> bit ) & 0x1 ) {
                     return kTRUE;
                  }
               } else {
                  Warning( "IsPassed",
                           "The requested information is not available in the input" );
                  return kFALSE;
               }
               break;
            case TrigDefs::L1_TBP:
               if( m_parent.GetDetailLevel() >= 1 ) {
                  // Return right away if the trigger fired
                  if( ( ( * m_parent.GetL1Result( Trig::IDataAccess::TBP ) )[ word ] >> bit ) & 0x1 ) {
                     return kTRUE;
                  }
               } else {
                  Warning( "IsPassed",
                           "The requested information is not available in the input" );
                  return kFALSE;
               }
               break;
            case TrigDefs::L1_TAP:
               if( m_parent.GetDetailLevel() >= 1 ) {
                  // Return right away if the trigger fired
                  if( ( ( * m_parent.GetL1Result( Trig::IDataAccess::TAP ) )[ word ] >> bit ) & 0x1 ) {
                     return kTRUE;
                  }
               } else {
                  Warning( "IsPassed",
                           "The requested information is not available in the input" );
                  return kFALSE;
               }
               break;
            default:
               Warning( "IsPassed", "Decision type not recognised for LVL1 items!" );
               break;
            }
 
         }
         // If this is a LVL2 chain:
         else if( m_existingTriggers[ i ].find( "L2_" ) != std::string::npos ) {
 
            std::vector< short >::const_iterator begin, end;
            switch( type ) {
 
            case TrigDefs::Physics:
               if( m_parent.GetDetailLevel() >= 0 ) {
                  begin = m_parent.GetL2Result( Trig::IDataAccess::Physics )->begin();
                  end   = m_parent.GetL2Result( Trig::IDataAccess::Physics )->end();
               } else {
                  Warning( "IsPassed",
                           "The requested information is not available in the input" );
                  return kFALSE;
               }
               break;
            case TrigDefs::requireDecision:
               if( m_parent.GetDetailLevel() >= 1 ) {
                  begin = m_parent.GetL2Result( Trig::IDataAccess::Raw )->begin();
                  end   = m_parent.GetL2Result( Trig::IDataAccess::Raw )->end();
               } else {
                  Warning( "IsPassed",
                           "The requested information is not available in the input" );
                  return kFALSE;
               }
               break;
            case TrigDefs::allowResurrected:
               if( m_parent.GetDetailLevel() >= 2 ) {
                  begin = m_parent.GetL2Result( Trig::IDataAccess::Resurrected )->begin();
                  end   = m_parent.GetL2Result( Trig::IDataAccess::Resurrected )->end();
               } else {
                  Warning( "IsPassed",
                           "The requested information is not available in the input" );
                  return kFALSE;
               }
               break;
            case TrigDefs::passedThrough:
               if( m_parent.GetDetailLevel() >= 2 ) {
                  begin = m_parent.GetL2Result( Trig::IDataAccess::PassedThrough )->begin();
                  end   = m_parent.GetL2Result( Trig::IDataAccess::PassedThrough )->end();
               } else {
                  Warning( "IsPassed",
                           "The requested information is not available in the input" );
                  return kFALSE;
               }
               break;
            default:
               Warning( "IsPassed", "Decision type not recognised for HLT chains!" );
               break;
            }
 
            if( std::find( begin, end, m_existingIDs[ i ] ) != end ) {
               return kTRUE; // Return right away if the trigger fired
            }
 
         }
         // If this is an EF chain:
         else if( m_existingTriggers[ i ].find( "EF_" ) != std::string::npos ) {
 
            std::vector< short >::const_iterator begin, end;
            switch( type ) {
 
            case TrigDefs::Physics:
               if( m_parent.GetDetailLevel() >= 0 ) {
                  begin = m_parent.GetEFResult( Trig::IDataAccess::Physics )->begin();
                  end   = m_parent.GetEFResult( Trig::IDataAccess::Physics )->end();
               } else {
                  Warning( "IsPassed",
                           "The requested information is not available in the input" );
                  return kFALSE;
               }
               break;
            case TrigDefs::requireDecision:
               if( m_parent.GetDetailLevel() >= 1 ) {
                  begin = m_parent.GetEFResult( Trig::IDataAccess::Raw )->begin();
                  end   = m_parent.GetEFResult( Trig::IDataAccess::Raw )->end();
               } else {
                  Warning( "IsPassed",
                           "The requested information is not available in the input" );
                  return kFALSE;
               }
               break;
            case TrigDefs::allowResurrected:
               if( m_parent.GetDetailLevel() >= 2 ) {
                  begin = m_parent.GetEFResult( Trig::IDataAccess::Resurrected )->begin();
                  end   = m_parent.GetEFResult( Trig::IDataAccess::Resurrected )->end();
               } else {
                  Warning( "IsPassed",
                           "The requested information is not available in the input" );
                  return kFALSE;
               }
               break;
            case TrigDefs::passedThrough:
               if( m_parent.GetDetailLevel() >= 2 ) {
                  begin = m_parent.GetEFResult( Trig::IDataAccess::PassedThrough )->begin();
                  end   = m_parent.GetEFResult( Trig::IDataAccess::PassedThrough )->end();
               } else {
                  Warning( "IsPassed",
                           "The requested information is not available in the input" );
                  return kFALSE;
               }
               break;
            default:
               Warning( "IsPassed", "Decision type not recognised for HLT chains!" );
               break;
            }
 
            if( std::find( begin, end, m_existingIDs[ i ] ) != end ) {
               return kTRUE; // Return right away if the trigger fired
            }
 
         } else {
            Fatal( "IsPassed", "Something seems to be wrong with this function!" );
            return kFALSE;
         }
 
      }
 
      return kFALSE; // If none of the matching triggers fired in the event
   }
 
   Float_t ChainGroup::GetPrescale() {
 
      //
      // Make sure the object is up to date:
      //
      if( ! Update() ) {
         Error( "IsPassed", "Trigger(s) can't be evaluated" );
         return 0.0;
      }
 
      // We handle the case when there's only one trigger in the chain group
      // in a distinct way:
      const Bool_t singleTrigger = ( m_existingTriggers.size() == 1 );
 
      //
      // Loop over all the matching triggers:
      //
      std::vector< std::string >::const_iterator name_itr = m_existingTriggers.begin();
      std::vector< std::string >::const_iterator name_end = m_existingTriggers.end();
      for( ; name_itr != name_end; ++name_itr ) {
 
         //
         // Calculate the overall prescale of the chain, or just request the
         // prescale of LVL1 items:
         //
         Float_t chainPrescale = 1.0;
         if( name_itr->find( "EF_" ) != name_itr->npos ) {
 
            chainPrescale = m_configSvc.GetPrescale( *name_itr );
            const std::string& l2name = m_configSvc.GetLowerChainName( *name_itr );
            chainPrescale *= m_configSvc.GetPrescale( l2name );
            const std::string& l1name = m_configSvc.GetLowerChainName( l2name );
            chainPrescale *= m_configSvc.GetPrescale( l1name );
 
         } else if( name_itr->find( "L2_" ) != name_itr->npos ) {
 
            chainPrescale = m_configSvc.GetPrescale( *name_itr );
            const std::string& l1name = m_configSvc.GetLowerChainName( *name_itr );
            chainPrescale *= m_configSvc.GetPrescale( l1name );
 
         } else if( name_itr->find( "L1_" ) != name_itr->npos ) {
 
            chainPrescale = m_configSvc.GetPrescale( *name_itr );
 
         } else {
            Fatal( "GetPrescale", "Something seems to be wrong with this function!" );
            return 0.0;
         }
 
         // If we just have this one trigger in the group, just return now:
         if( singleTrigger ) return chainPrescale;
 
         // If we have multiple triggers, but one of them is unprescaled, then the
         // whole group is labelled as unprescaled as well:
         const Bool_t unprescaled = ( std::abs( chainPrescale - 1.0 ) < 1e-5 );
         if( unprescaled ) return 1.0;
 
      }
 
      // If we have multiple triggers, and all are prescaled:
      return 0.0;
   }
 
   const std::vector< std::string >& ChainGroup::GetListOfTriggers() {
 
      //
      // Make sure the object is up to date:
      //
      if( ! Update() ) {
         Error( "IsPassed", "Trigger(s) can't be evaluated" );
         m_existingTriggers.clear();
      }
 
      return m_existingTriggers;
   }
 
   Bool_t ChainGroup::Update() {
 
      // Return right away if we're already configured correctly:
      if( m_smk == m_parent.GetSMK() ) return kTRUE;
 
      // Load the configuration, and remember that the object is initialized with this
      // configuration:
      m_configSvc.Load( m_parent.GetSMK(), m_parent.GetL1PSK(), m_parent.GetHLTPSK() );
      m_smk = m_parent.GetSMK();
 
      // Clear the cache variables:
      m_existingTriggers.clear();
      m_existingIDs.clear();
 
      // Loop over the provided trigger names, and expand them in case they contain lists
      // or wildcards:
      std::vector< std::string >::const_iterator name_itr = m_triggerNames.begin();
      std::vector< std::string >::const_iterator name_end = m_triggerNames.end();
      for( ; name_itr != name_end; ++name_itr ) {
 
         // It's also possible to specify triggers like "L1_MU6,L1_EM5". In this case
         // the code has to split up these strings into separate trigger names.
         std::vector< std::string > split_names = ToVector( *name_itr );
         std::vector< std::string >::const_iterator splitname_itr = split_names.begin();
         std::vector< std::string >::const_iterator splitname_end = split_names.end();
         for( ; splitname_itr != splitname_end; ++splitname_itr ) {
 
            // Use a TRegexp object only if it's needed:
            TRegexp re( *splitname_itr );
            Ssiz_t len = 0;
            const Bool_t isWildcarded = ( ( splitname_itr->find( '^' ) != splitname_itr->npos ) ||
                                          ( splitname_itr->find( '$' ) != splitname_itr->npos ) ||
                                          ( splitname_itr->find( '.' ) != splitname_itr->npos ) ||
                                          ( splitname_itr->find( '[' ) != splitname_itr->npos ) ||
                                          ( splitname_itr->find( ']' ) != splitname_itr->npos ) ||
                                          ( splitname_itr->find( '*' ) != splitname_itr->npos ) ||
                                          ( splitname_itr->find( '+' ) != splitname_itr->npos ) ||
                                          ( splitname_itr->find( '?' ) != splitname_itr->npos ) );
 
            // Find out which LVL1 items match the selection:
            std::vector< std::string >::const_iterator trigger_itr =
               m_configSvc.GetLVL1Items().begin();
            std::vector< std::string >::const_iterator trigger_end =
               m_configSvc.GetLVL1Items().end();
            for( ; trigger_itr != trigger_end; ++trigger_itr ) {
               if( isWildcarded ) {
                  if( re.Index( *trigger_itr, &len ) != kNPOS ) {
                     m_existingTriggers.push_back( *trigger_itr );
                     m_existingIDs.push_back( m_configSvc.GetCTPId( *trigger_itr ) );
                  }
               } else {
                  if( *splitname_itr == *trigger_itr ) {
                     m_existingTriggers.push_back( *trigger_itr );
                     m_existingIDs.push_back( m_configSvc.GetCTPId( *trigger_itr ) );
                  }
               }
            }
 
            // Find out which HLT chains match the selection:
            trigger_itr = m_configSvc.GetHLTChains().begin();
            trigger_end = m_configSvc.GetHLTChains().end();
            for( ; trigger_itr != trigger_end; ++trigger_itr ) {
               if( isWildcarded ) {
                  if( re.Index( *trigger_itr, &len ) != kNPOS ) {
                     m_existingTriggers.push_back( *trigger_itr );
                     m_existingIDs.push_back( m_configSvc.GetChainId( *trigger_itr ) );
                  }
               } else {
                  if( *splitname_itr == *trigger_itr ) {
                     m_existingTriggers.push_back( *trigger_itr );
                     m_existingIDs.push_back( m_configSvc.GetChainId( *trigger_itr ) );
                  }
               }
            }
         }
      }
 
      // Do a final sanity check:
      if( m_existingTriggers.size() != m_existingIDs.size() ) {
         Fatal( "Update", "There is a serious problem in the code!" );
         return kFALSE;
      }
 
      return kTRUE; // The update was successful
   }
 
   std::vector< std::string > ChainGroup::ToVector( const std::string& names ) {
 
      // First let's erase all whitespaces:
      std::string local_names( names );
      std::string::size_type pos;
      while( ( pos = local_names.find_first_of( ' ' ) ) != local_names.npos ) {
         local_names.erase( pos, 1 );
      }
 
      // Now let's split it up:
      std::vector< std::string > result;
      std::string::size_type old_pos = 0;
      while( ( pos = local_names.find( ',', old_pos ) ) != local_names.npos ) {
         result.push_back( local_names.substr( old_pos, pos - old_pos ) );
         old_pos = pos + 1;
      }
      if( old_pos < local_names.size() ) {
         result.push_back( local_names.substr( old_pos, local_names.size() - old_pos ) );
      }
 
      return result;
   }
 
} // namespace D3PD