Sequencer.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2023 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <Gaudi/Property.h>
#include <Gaudi/Sequence.h>
#include <mutex>
 
namespace Gaudi {
  class GAUDI_API Sequencer : public Gaudi::Sequence {
  public:
    using Gaudi::Sequence::Sequence;
 
    StatusCode initialize() override;
 
    StatusCode reinitialize() override;
 
    StatusCode start() override;
 
    StatusCode execute( const EventContext& ctx ) const override;
 
    StatusCode stop() override;
 
    StatusCode finalize() override;
 
    bool branchFilterPassed( const EventContext& ctx ) const;
 
    void setBranchFilterPassed( const EventContext& ctx, bool state ) const;
 
    StatusCode append( Gaudi::Algorithm* pAlgorithm );
 
    StatusCode appendToBranch( Gaudi::Algorithm* pAlgorithm );
 
    StatusCode createAndAppend( const std::string& type,      // The concrete algorithm class of the algorithm
                                const std::string& name,      // The name to be given to the algorithm
                                Gaudi::Algorithm*& pAlgorithm // Set to point to the newly created algorithm object
    );
 
    StatusCode createAndAppendToBranch( const std::string& type,      // The concrete algorithm class of the algorithm
                                        const std::string& name,      // The name to be given to the algorithm
                                        Gaudi::Algorithm*& pAlgorithm // Set to point to the newly created algorithm
                                                                      // object
    );
 
    StatusCode remove( Gaudi::Algorithm* pAlgorithm );
    StatusCode remove( const std::string& name );
    StatusCode removeFromBranch( Gaudi::Algorithm* pAlgorithm );
    StatusCode removeFromBranch( const std::string& name );
 
    const std::vector<Gaudi::Algorithm*>& branchAlgorithms() const;
    std::vector<Gaudi::Algorithm*>&       branchAlgorithms();
 
    StatusCode decodeMemberNames();
 
    StatusCode decodeBranchMemberNames();
 
  protected:
    StatusCode append( Gaudi::Algorithm* pAlgorithm, std::vector<Gaudi::Algorithm*>& theAlgs );
 
    StatusCode createAndAppend( const std::string& type,       // The concrete algorithm class of the algorithm
                                const std::string& name,       // The name to be given to the algorithm
                                Gaudi::Algorithm*& pAlgorithm, // Set to point to the newly created algorithm object
                                std::vector<Gaudi::Algorithm*>& theAlgs );
 
    StatusCode decodeNames( Gaudi::Property<std::vector<std::string>>& theNames,
                            std::vector<Gaudi::Algorithm*>& theAlgs, std::vector<bool>& theLogic );
 
    StatusCode execute( const EventContext& ctx, const std::vector<Gaudi::Algorithm*>& theAlgs,
                        const std::vector<bool>& theLogic, Gaudi::Algorithm*& lastAlgorithm,
                        std::size_t first = 0 ) const;
 
    StatusCode executeMember( Gaudi::Algorithm* theAlgorithm, const EventContext& context ) const;
 
    StatusCode remove( const std::string& algname, std::vector<Gaudi::Algorithm*>& theAlgs );
 
    // NO COPY / ASSIGNMENT  ALLOWED
    Sequencer( const Sequencer& a )              = delete;
    Sequencer& operator=( const Sequencer& rhs ) = delete;
 
  public:
    std::ostream& toControlFlowExpression( std::ostream& os ) const override;
 
  private:
    Gaudi::Property<std::vector<std::string>> m_names{ this,
                                                       "Members",
                                                       {},
                                                       [this]( auto& ) {
                                                         if ( this->isInitialized() )
                                                           this->decodeMemberNames().ignore();
                                                       },
                                                       "member names",
                                                       "vector<Algorithm>" };
    Gaudi::Property<std::vector<std::string>> m_branchNames{ this,
                                                             "BranchMembers",
                                                             {},
                                                             [this]( auto& ) {
                                                               if ( this->isInitialized() )
                                                                 this->decodeBranchMemberNames().ignore();
                                                             },
                                                             "branch member names",
                                                             "vector<Algorithm>" };
 
    Gaudi::Property<bool> m_shortCircuit{ this, "ShortCircuit", true, "stop processing as soon as possible" };
    Gaudi::Property<bool> m_sequential{ this, "Sequential", false, "execute members one at a time" };
    Gaudi::Property<bool> m_modeOR{ this, "ModeOR", false, "use OR logic instead of AND" };
    Gaudi::Property<bool> m_ignoreFilter{ this, "IgnoreFilterPassed", false, "always continue" };
    Gaudi::Property<bool> m_invert{ this, "Invert", false, "invert the logic result of the sequencer" };
 
    Gaudi::Property<std::vector<std::string>> m_vetoObjs{
        this, "VetoObjects", {}, "skip execute if one or more of these TES objects exist" };
    Gaudi::Property<std::vector<std::string>> m_requireObjs{
        this, "RequireObjects", {}, "execute only if one or more of these TES objects exist" };
 
    std::vector<bool>              m_isInverted;       // Member logic inverted list
    std::vector<Gaudi::Algorithm*> m_branchAlgs;       // Branch algorithms
    std::vector<bool>              m_isBranchInverted; // Branch Member logic inverted list
 
    mutable std::mutex                                m_branchFilterMutex;
    mutable std::map<EventContext::ContextID_t, bool> m_branchFilterPassed; // Branch filter passed flag
  };
} // namespace Gaudi