CutBookkeeper_v1.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
// $Id$
#ifndef XAODCUTFLOW_VERSIONS_CUTBOOKKEEPER_V1_H
#define XAODCUTFLOW_VERSIONS_CUTBOOKKEEPER_V1_H
 
// STL includes
#include <string>
#include <iosfwd>
#include <stdint.h>
#include <vector>
 
// Core include(s):
#include "AthContainers/AuxElement.h"
#include "CxxUtils/checker_macros.h"
namespace xAOD {

  class CutBookkeeper_v1 : public SG::AuxElement {
 
  public:

    enum CutLogic {
      UNKNOWN            = 0,
      ALLEVENTSPROCESSED = 1,
      ALLEVENTSWRITTEN   = 2,
      OTHER              = 3,
      ACCEPT             = 4,
      REQUIRE            = 5,
      VETO               = 6,
    };
 

    struct Payload {
    public:
      Payload operator+( const Payload& rhs ) {
        Payload result;
        result.nAcceptedEvents          = this->nAcceptedEvents + rhs.nAcceptedEvents;
        result.sumOfEventWeights        = this->sumOfEventWeights + rhs.sumOfEventWeights;
        result.sumOfEventWeightsSquared = this->sumOfEventWeightsSquared + rhs.sumOfEventWeightsSquared;
        return result;
      }
 
      Payload& operator+=( const Payload& rhs ) {
        this->nAcceptedEvents          += rhs.nAcceptedEvents;
        this->sumOfEventWeights        += rhs.sumOfEventWeights;
        this->sumOfEventWeightsSquared += rhs.sumOfEventWeightsSquared;
        return *this;
      }
 
    public:
      uint64_t nAcceptedEvents;
      double   sumOfEventWeights;
      double   sumOfEventWeightsSquared;
    };
 
 

    CutBookkeeper_v1();
 
 

    ~CutBookkeeper_v1();
 
 

    bool operator==( const CutBookkeeper_v1& rhs ) {
      return this->isEqualTo( &rhs );
    }
 


    unsigned int nameIdentifier() const;
    unsigned int uniqueIdentifier() const;
 
  private:
    void setNameIdentifier( unsigned int hash );
    void setUniqueIdentifier( unsigned int hash );
 
  public:
    const std::string& name() const;
    void setName( const std::string& name );

    const std::string& description() const;
    void setDescription( const std::string &description );
 

    bool isTopFilter() const;
    void setTopFilter( bool isTopFilter );
 

    CutLogic cutLogic() const;
    void setCutLogic( CutLogic logic );

    int cycle() const;
    void setCycle( int cycle );

    const std::string& inputStream() const;
    void setInputStream( const std::string& inputstream );

    const std::vector<std::string>& outputStreams() const;
    bool hasOutputStream( const std::string& outputstream ) const;
    void addOutputStream( const std::string& outputstream );
    void addOutputStreamForAllUsed ATLAS_NOT_THREAD_SAFE ( const std::string& outputstream );
    void setOutputStreams( const std::vector<std::string>& outputstreams );

 


    Payload payload() const;
    void setPayload( const Payload& payload );

    uint64_t nAcceptedEvents() const;
    void setNAcceptedEvents( uint64_t nEvents );
    void addNAcceptedEvents( uint64_t nEvents );

    double sumOfEventWeights() const;
    void setSumOfEventWeights( double nWeightedEvents );
    void addSumOfEventWeights( double nWeightedEvents );

    double sumOfEventWeightsSquared() const;
    void setSumOfEventWeightsSquared( double nWeightedEventsSquared );
    void addSumOfEventWeightsSquared( double nWeightedEventsSquared );

 

    bool isEqualTo( const CutBookkeeper_v1 *eb ) const;
 
 


    bool hasParent() const;
    const xAOD::CutBookkeeper_v1* parent() const;
    void setParent( const CutBookkeeper_v1* parentEB );
    std::size_t nChildren() const;
    bool hasChild( const xAOD::CutBookkeeper_v1* testCBK ) const;
    const xAOD::CutBookkeeper_v1* child( std::size_t i ) const;
    void setChildren( const std::vector< CutBookkeeper_v1* >& childrenEB );
    void addChildren( const std::vector< CutBookkeeper_v1* >& childrenEB );
    void addChild( CutBookkeeper_v1* childEB );
    CutBookkeeper_v1* addNewChild( const std::string& name,
                                     const std::string& description );

 
 


    std::size_t nUsedOthers() const;
    bool hasUsedOther( const xAOD::CutBookkeeper_v1* testCBK ) const;
    const xAOD::CutBookkeeper_v1* usedOther( std::size_t i ) const;
    void setUsedOthers( const std::vector< CutBookkeeper_v1* >& usedOthers );
    void addUsedOthers( const std::vector< CutBookkeeper_v1* >& usedOthers );
    void addUsedOther( CutBookkeeper_v1* usedOtherEB );

 
 


    std::size_t nSiblings() const;
    bool hasSibling( const xAOD::CutBookkeeper_v1* testCBK ) const;
    const xAOD::CutBookkeeper_v1* sibling( std::size_t i ) const;
    void setSiblings( const std::vector< CutBookkeeper_v1* >& siblings );
    void addSiblings( const std::vector< CutBookkeeper_v1* >& siblings );
    void addSibling( CutBookkeeper_v1* siblingsEB );

 

    void toPersistent();
 
 
  };
 
 
} // namespace xAOD
 
 
#endif //> XAODCUTFLOW_VERSIONS_CUTBOOKKEEPER_V1_H