MissingETComponent_v1.h

Go to the documentation of this file.

// -*- c++ -*-
 
/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef XAODMISSINGET_VERSIONS_MISSINGETCOMPONENT_V1_H
#define XAODMISSINGET_VERSIONS_MISSINGETCOMPONENT_V1_H
 
#include "AthContainers/AuxElement.h"
 
#include "xAODBase/IParticle.h"
#include "xAODBase/IParticleContainer.h"
 
#include "xAODMissingET/versions/MissingETCompositionBase.h"
#include "xAODMissingET/MissingETContainer.h"
 
#include <vector>
 
namespace xAOD
{ 
  class MissingETComponent_v1 : public SG::AuxElement
  {
  public:                                                                                                                                
    class Weight
    {
    public:
      Weight();                                 
      Weight(double wpx,double wpy,double wet); 
      // Weight(const Weight& wght);               /*!< @brief Copy constructor */
      ~Weight();                                
      double wpx() const; 
      double wpy() const; 
      double wet() const; 
      void setWpx(double wpx); 
      void setWpy(double wpy); 
      void setWet(double wet); 
      double& wpx();                          
      double& wpy();                          
      double& wet();                          
      Weight& operator+=(const Weight& wght); 
      Weight& operator-=(const Weight& wght); 
      Weight& operator*=(const Weight& wght); 
      Weight& operator*=(double scale);        
      Weight& operator/=(const Weight& wght); 
      Weight& operator/=(double scale);       
      bool operator==(const Weight& wght) const; 
      bool operator!=(const Weight& wght) const; 
     private:
      double m_wpx; 
      double m_wpy; 
      double m_wet; 
    }; // MissingETComponent_v1::Weight
 
    MissingETComponent_v1(bool createStore=false);                                                                                
    MissingETComponent_v1(const MissingET* pmetObj,MissingETBase::Types::bitmask_t sw=MissingETBase::Status::clearedStatus()); 
    MissingETComponent_v1(const MissingET* pmetObj,const IParticle* pPart,const Weight& wght=Weight(),MissingETBase::Types::bitmask_t sw=MissingETBase::Status::clearedStatus());
    MissingETComponent_v1(const MissingET* pmetObj,const IParticle* pPart,double wpx,double wpy,double wet,MissingETBase::Types::bitmask_t sw=MissingETBase::Status::clearedStatus());
    MissingETComponent_v1(const MissingETComponent_v1& compDescr);                                    
    MissingETComponent_v1(const MissingETComponent_v1& compDescr,MissingETBase::Types::bitmask_t sw); 
    MissingETComponent_v1& operator=(const MissingETComponent_v1& compDescr);                         
    virtual ~MissingETComponent_v1();                                                                 

    bool setMET(const MissingET* pmetObj,MissingETBase::Types::bitmask_t sw=MissingETBase::Status::clearedStatus());
    bool setMET(const MissingETContainer_v1* pmetCont,size_t pmedIdx,MissingETBase::Types::bitmask_t sw=MissingETBase::Status::clearedStatus());
 
    bool addObject(const IParticle* pPart,const Weight& wght=Weight());      
    bool addObject(const IParticle* pPart,double wpx,double wpy,double wet); 

    const std::vector<double>& wpx() const;                                     
    double wpx(const IParticle* pPart) const;                                   
    double wpx(size_t pIdx) const;                                              
    //
    bool setWpx(const std::vector<double>& wcv);                                
    bool setWpx(const IParticle* pPart,double wpx);                             
    bool setWpx(size_t pIdx,double wpx);                                        
    //
    const std::vector<double>& wpy() const;                                     
    double wpy(const IParticle* pPart) const;                                   
    double wpy(size_t pIdx) const;                                              
    //
    bool setWpy(const std::vector<double>& wpyVector);                          
    bool setWpy(const IParticle* pPart,double wpy);                             
    bool setWpy(size_t pIdx,double wpy);                                        
    //
    const std::vector<double>& wet() const;                                     
    double wet(const IParticle* pPart) const;                                   
    double wet(size_t pIdx) const;                                              
    //
    bool setWet(const std::vector<double>& wcv);                                
    bool setWet(const IParticle* pPart,double wet);                             
    bool setWet(size_t pIdx,double wet);                                        
    //
    bool setWeight(const IParticle* pPart,const Weight& wght=Weight());         
    bool setWeight(const IParticle* pPart,double wpx,double wpy,double wet);    
    bool setWeight(size_t pIdx,const Weight& wght=Weight());                    
    bool setWeight(size_t pIdx,double wpx,double wpy,double wet);               
    //
    const MissingETBase::Types::metlink_t& metLink() const;                     
    bool setMetLink(const MissingETBase::Types::metlink_t& metLnk);             
    const MissingETBase::Types::objlink_vector_t& objectLinks() const;          
    bool setObjectLinks(const MissingETBase::Types::objlink_vector_t& objLnks); 
    MissingETBase::Types::bitmask_t statusWord() const;                         
    bool setStatusWord(MissingETBase::Types::bitmask_t sw=MissingETBase::Status::clearedStatus()); 

    bool removeContrib(const IParticle* pPart);               
    bool removeContrib(size_t pIdx);                          
    bool removeContrib();                                     
    bool resetContrib(const IParticle* pPart);                
    bool resetContrib(size_t pIdx);                           
    bool resetContrib();                                      
    bool mergeStatusWord(MissingETBase::Types::bitmask_t sw); 
    bool clearStatusWord();                                   

    const MissingET* metObject() const;                                      
    const MissingETContainer_v1* metObjectContainer() const;                    
    size_t metObjectIndex() const;                                              
    std::vector<const IParticle*> objects() const;                              
    std::vector<const IParticle*> objects(std::vector<Weight>& kinePars) const; 
    std::vector<const IParticle*> objects(const std::vector<double>*& wpxPtr,    
                      const std::vector<double>*& wpyPtr,
                      const std::vector<double>*& wetPtr) const; 
    Weight weight(const IParticle* pPart) const;                                     
    Weight weight(size_t pIdx) const;                                                 
 

    size_t findIndex(const IParticle* pPart) const;

    // void updateLinks();
    // void updateMETLink();
    size_t size() const;
    bool empty() const;

    bool operator==(const MissingETComponent_v1& contrib) const; 
    bool operator!=(const MissingETComponent_v1& contrib) const;
 
  protected:
    void createPrivateStore();

    MissingETBase::Types::objlink_vector_t&  f_objectLinks(); 
    MissingETBase::Types::metlink_t&         f_metLink();     
    std::vector<double>&                     f_wpx();           
    std::vector<double>&                     f_wpy();
    std::vector<double>&                     f_wet();
    MissingETBase::Types::bitmask_t&         f_statusWord();

    bool f_removeContrib(size_t pIdx);
    void copyData(const MissingETComponent_v1& compDescr,MissingETBase::Types::bitmask_t sw=MissingETBase::Status::clearedStatus());
    template<class POBJ,class LINK> void f_setObject(const POBJ* pObj,LINK& elemLink);
    template<class LINK> bool f_setLink(LINK& elemLink);
  }; // MissingETComponenet_v1
}
 
namespace MissingETBase
{ 
  namespace Types
  {
    typedef xAOD::MissingETComponent_v1::Weight weight_t;        
    typedef std::vector<weight_t>               weight_vector_t; 
  }
}

MissingETBase::Types::weight_t operator+(const MissingETBase::Types::weight_t& w0,const MissingETBase::Types::weight_t& w1);
MissingETBase::Types::weight_t operator-(const MissingETBase::Types::weight_t& w0,const MissingETBase::Types::weight_t& w1);
MissingETBase::Types::weight_t operator*(const MissingETBase::Types::weight_t& w0,const MissingETBase::Types::weight_t& w1);
MissingETBase::Types::weight_t operator/(const MissingETBase::Types::weight_t& w0,const MissingETBase::Types::weight_t& w1);
MissingETBase::Types::weight_t operator*(const MissingETBase::Types::weight_t& wght,double scale);
MissingETBase::Types::weight_t operator*(double scale,const MissingETBase::Types::weight_t& wght);
MissingETBase::Types::weight_t operator/(const MissingETBase::Types::weight_t& wght,double scale);
#include "xAODMissingET/versions/MissingETComponent_v1.icc"
#endif