Event/xAOD/xAODMissingET/xAODMissingET/MissingETComposition.h

Go to the documentation of this file.

// -*- c++ -*-
 
/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef XAODMISSINGET_MISSINGETCOMPOSITION_H
#define XAODMISSINGET_MISSINGETCOMPOSITION_H
 
#include "xAODMissingET/versions/MissingETCompositionBase.h"
#include "xAODMissingET/MissingET.h"
#include "xAODMissingET/MissingETComponent.h"
#include "xAODMissingET/MissingETComponentMap.h"
#include "xAODMissingET/MissingETAssociation.h"
#include "xAODMissingET/MissingETAssociationMap.h"
#include "xAODMissingET/MissingETAssociationHelper.h"
#include "xAODJet/Jet.h"
 
namespace xAOD 
{
  struct MissingETComposition
  {
    static bool add(MissingETComponentMap* pMap,const MissingET* pMET,MissingETBase::Types::bitmask_t sw=MissingETBase::Status::clearedStatus());
    static bool insert(MissingETComponentMap* pMap,const MissingET* pMET,const IParticle* pPart,MissingETBase::Types::weight_t weight=MissingETBase::Types::weight_t());
    static bool insert(MissingETComponentMap* pMap,const MissingET* pMET,const IParticle* pPart,const MissingETBase::Types::object_vector_t& signalList,
               MissingETBase::Types::weight_t weight=MissingETBase::Types::weight_t(),
               MissingETBase::UsageHandler::Policy p=MissingETBase::UsageHandler::OnlyCluster);
    static bool insert(MissingETComponentMap* pMap,const MissingET* pMET,const IParticle* pPart,double wpx,double wpy,double wet);
    static bool insert(MissingETComponentMap* pMap,const MissingET* pMET,const IParticle* pPart,const MissingETBase::Types::object_vector_t& signalList,double wpx,double wpy,double wet,
               MissingETBase::UsageHandler::Policy p=MissingETBase::UsageHandler::OnlyCluster);

    static MissingETComponentMap::const_iterator find(const MissingETComponentMap* pMap,const MissingET* pmetObj);
    static MissingETComponentMap::iterator       find(MissingETComponentMap* pMap,const MissingET* pmetObj);
    static MissingETComponentMap::const_iterator find(const MissingETComponentMap* pMap,const std::string& metName);
    static MissingETComponentMap::iterator       find(MissingETComponentMap* pMap,const std::string& metName);
    static MissingETComponentMap::const_iterator find(const MissingETComponentMap* pMap,MissingETBase::Types::bitmask_t src);
    static MissingETComponentMap::iterator       find(MissingETComponentMap* pMap,MissingETBase::Types::bitmask_t src);
    static size_t findIndex(const MissingETComponentMap* pMap,const MissingET* pmetObj);
    static size_t findIndex(const MissingETComponentMap* pMap,const std::string& metName);
    static size_t findIndex(const MissingETComponentMap* pMap,MissingETBase::Types::bitmask_t src);
 

    static MissingETComponentMap::const_iterator find(const MissingETComponentMap* pMap,const IParticle* pPart);
    static MissingETComponentMap::iterator find(MissingETComponentMap* pMap,const IParticle* pPart);

    static MissingETComponentMap::const_iterator begin(const MissingETComponentMap* pMap);
    static MissingETComponentMap::iterator begin(MissingETComponentMap* pMap);
    static MissingETComponentMap::const_iterator end(const MissingETComponentMap* pMap);
    static MissingETComponentMap::iterator end(MissingETComponentMap* pMap);
    static const MissingETComponent* getComponent(const MissingETComponentMap* pMap,const IParticle* pPart);
    static const MissingETComponent* getComponent(const MissingETComponentMap* pMap,const MissingET* pmetObj);
    static const MissingETComponent* getComponent(const MissingETComponentMap* pMap,const std::string& metName);
    static const MissingETComponent* getComponent(const MissingETComponentMap* pMap,MissingETBase::Types::bitmask_t src);
    static MissingETComponent* getComponent(MissingETComponentMap* pMap,const IParticle* pPart);
    static MissingETComponent* getComponent(MissingETComponentMap* pMap,const MissingET* pmetObj);
    static MissingETComponent* getComponent(MissingETComponentMap* pMap,const std::string& metName);
    static MissingETComponent* getComponent(MissingETComponentMap* pMap,MissingETBase::Types::bitmask_t src);

    static MissingETBase::Types::weight_t getWeight(const MissingETComponentMap* pMap,const IParticle* pPart);
    static MissingETBase::Types::weight_t getWeight(MissingETComponentMap::const_iterator fCont,const IParticle* pPart);
    static MissingETBase::Types::bitmask_t getStatusWord(const MissingETComponentMap* pMap,const MissingET* pmetObj);
    static MissingETBase::Types::bitmask_t getStatusWord(MissingETComponentMap::const_iterator fCont);
    static const MissingET* getMissingET(const MissingETComponentMap* pMap,const IParticle* pPart);
    static const MissingET* getMissingET(MissingETComponentMap::const_iterator fCont);
    static const MissingET* getMissingET(const MissingETComponentMap* pMap,const std::string& name);
    static const MissingET* getMissingET(const MissingETComponentMap* pMap,MissingETBase::Types::bitmask_t sw);

    template<int OBJTYPE>
    static bool fillMissingET(const MissingETComponentMap* pMap,MissingET* pMET,
                              MissingETBase::Types::bitmask_t /*status*/=MissingETBase::Status::clearedStatus())
    {
      if ( pMap == 0 || pMap->empty() ) return false;
      //
      double sumet(pMET->sumet());
      MissingETComponentMap::const_iterator fComp(pMap->begin());
      MissingETComponentMap::const_iterator lComp(pMap->end());
      for ( ; fComp != lComp; ++fComp ) 
    { 
      const MissingETComponent* pCont = *fComp;
      if ( pCont != 0 )
        {
          // get objects from contribution
          MissingETBase::Types::weight_vector_t kinePars;
          MissingETBase::Types::object_vector_t objs = pCont->objects(kinePars);
          for ( size_t iObj(0); iObj<objs.size(); ++iObj )
        { 
          if ( objs[iObj]->type() == OBJTYPE ) 
            { // this is really stupid!!!!
              pMET->add(objs.at(iObj)->p4().Px()*kinePars.at(iObj).wpx(),
                objs.at(iObj)->p4().Py()*kinePars.at(iObj).wpy(),
                objs.at(iObj)->pt()*kinePars.at(iObj).wet());
            } // requested type
        } // loop on contributing objects
        } // contribution valid
    } // loop on all contributions
      return pMET->sumet() != sumet;
    } // fillMissingET

    static bool add(MissingETAssociationMap* pMap,const Jet* pJet,
            const std::vector<ElementLink<IParticleContainer> >& jetconst=std::vector<ElementLink<IParticleContainer> >(),
            const MissingETBase::Types::constvec_t& trkvec=MissingETBase::Types::constvec_t());
    static bool add(MissingETAssociationMap* pMap,const Jet* pJet,
            const std::vector<const IParticle*>& jetracks=std::vector<const IParticle*>());
    static bool addMiscAssociation(MissingETAssociationMap* pMap);
    static bool insert(MissingETAssociationMap* pMap,size_t jetIndex,const IParticle* pPart,const std::vector<const IParticle*>& constlist);
    static bool insert(MissingETAssociationMap* pMap,const Jet* pJet,const IParticle* pPart,const std::vector<const IParticle*>& constlist);
    static bool insert(MissingETAssociationMap* pMap,const IParticle* pPart,const std::vector<const IParticle*>& constlist,
               std::map<const IParticle*,MissingETBase::Types::constvec_t> pOverride=std::map<const IParticle*,MissingETBase::Types::constvec_t>());
 
    static bool setJetConstSum(MissingETAssociationMap* metMap,const Jet* jet,const std::vector<const IParticle*>& altConsts,
                   std::map<const IParticle*,MissingETBase::Types::constvec_t> pOverride);
    static bool insertMisc(MissingETAssociationMap* pMap,const IParticle* pPart,const std::vector<const IParticle*>& constlist);

    static MissingETAssociationMap::const_iterator find(const MissingETAssociationMap* pMap,const Jet* pJet);
    static MissingETAssociationMap::iterator       find(MissingETAssociationMap* pMap,const Jet* pJet);

    static MissingETAssociationMap::const_iterator find(const MissingETAssociationMap* pMap,const IParticle* pPart);
    static MissingETAssociationMap::iterator find(MissingETAssociationMap* pMap,const IParticle* pPart);

    static std::vector<const MissingETAssociation*> getAssociations(const MissingETAssociationMap* pMap,const IParticle* pPart);
    static MissingETBase::Types::constvec_t getConstVec(const MissingETAssociationMap* pMap,const IParticle* pPart,MissingETBase::UsageHandler::Policy p);
    static bool objSelected(const MissingETAssociationHelper& helper,const IParticle* obj);
    static bool selectIfNoOverlaps(MissingETAssociationHelper& helper,const IParticle* obj,MissingETBase::UsageHandler::Policy p);
    static const MissingETAssociation* getAssociation(const MissingETAssociationMap* pMap,const Jet* pJet);
    //    static const MissingETAssociation* getMiscAssociation(const MissingETAssociationMap* pMap);
    static std::vector<MissingETAssociation*> getAssociations(MissingETAssociationMap* pMap,const IParticle* pPart);
    static MissingETAssociation* getAssociation(MissingETAssociationMap* pMap,const Jet* pJet);
    //    static MissingETAssociation* getMiscAssociation(MissingETAssociationMap* pMap);

    // Leave these for now -- decide how to treat calo vs track vs jet vs signal
    // static MissingETBase::Types::constvec_t getConstVec(const MissingETAssociationMap* pMap,const IParticle* pPart);
    // static MissingETBase::Types::constvec_t getConstVec(MissingETAssociationMap::const_iterator fCont,const IParticle* pPart);
    static const Jet* getRefJet(const MissingETAssociationMap* pMap,const IParticle* pPart);
    static const Jet* getRefJet(MissingETAssociationMap::const_iterator fCont);
 
  }; // MissingETComposition
} // namespace xAOD

 
    // /*! @brief Object factories for a MET contribution object 
    //  *
    //  *  These functions can be helpful to generate @link xAOD::MissingETComponent MissingETComponent @endlink objects. They invoke the respective constructor
    //  *  with the given list of arguments. 
    //  *
    //  *  @warning These functions expose the  @link xAOD::MissingETComponent MissingETComponent @endlink object to clients, which may not be desirable. 
    //  *  Non-experts should probably not use them. 
    //  *
    //  */
    // struct Contribution
    // {
    //   /*! @name Object factories for contribution object
    //    *  @anchor contrib_factory 
    //    */
    //   /*!@{*/
    //   /*! @brief Default construction
    //    *
    //    *  Instantiates an empty @link xAOD::MissingETComponent MissingETComponent @endlink object with default parameters given in 
    //    *  @link xAOD::MissingETComponent::MissingETComponent() MissingETComponent::MissingETComponent() @endlink.
    //    *
    //    *  @return Pointer to valid but empty @link xAOD::MissingETComponent MissingETComponent @endlink object.
    //    */
    //   static MissingETComponent* generate();
    //   /*! @brief Construct with a given MET object 
    //    *
    //    *  Instantiates an incomplete (not fully loaded) @link xAOD::MissingETComponent MissingETComponent @endlink object with a link 
    //    *  to a @link xAOD::MissingET MissingET @endlink object and otherwise default data.
    //    *
    //    *  @return Pointer to valid but incomplete @link xAOD::MissingETComponent MissingETComponent @endlink object.
    //    *
    //    *  @param[in] pmetObj pointer to non-modifiable MET object.
    //    *
    //    *  @note If the given pointer to the @link xAOD::MissingET MissingET @endlink is NULL, the returned contribution object
    //    *        is empty. This is the same behaviour as implemented in the xAOD::MissingETComposition::generate() function.
    //    *        If the reference to the container in the MET object is invalid, 
    //    *        @link xAOD::MissingETComponent::updateMETLink() MissingETComponent::updateMETlink() @endlink
    //    *        must be called after the @link xAOD::MissingET MissingET @endlink object has been inserted into a storable 
    //    *        @link xAOD::MissingETContainer MissingETContainer @endlink. Only then is the EL complete and valid. 
    //    */
    //   static MissingETComponent* generate(const MissingET* pmetObj);
    //   /*! @brief Construct with a given MET object and a first contributing object
    //    *
    //    *  Instantiates a complete (loaded with one contributing object) @link xAOD::MissingETComponent MissingETComponent @endlink 
    //    *  object with a link to a @link xAOD::MissingET MissingET @endlink object and otherwise default data.
    //    *
    //    *  @return Pointer to valid and loaded @link xAOD::MissingETComponent MissingETComponent @endlink object. Returns NULL if problems 
    //    *          with the generation occur.
    //    *
    //    *  @param[in] pmetObj pointer to non-modifiable MET object.
    //    *  @param[in] pPart   pointer to non-modifiable contributing object.
    //    *  @param[in] weight  reference to non-modifiable kinematic weight object MissingETComposition::Weight (optional, 
    //    *                     default is given by Weight::Weight()).
    //    *  @param[in] sw      status of contribution (optional, default is MissingETBase::Status::defaultAccept).
    //    *
    //    *  @note If the reference to the container in the MET object is invalid, 
    //    *        xAOD::MissingETComposition::Contribution::updateMETLink() must be called after the @link MissingET MissingET @endlink object has been inserted into a storable 
    //    *        @link MissingETContainer MissingETContainer @endlink. Only then is the EL complete and valid. 
    //    *
    //    *  @warning Any invalid input (expecially NULL pointers) suppresses generation of the @link MissingETComponent MissingETComponent @endlink 
    //    *           object (a NULL pointer is returned).
    //    */
    //   static MissingETComponent* generate(const MissingET* pmetObj,const IParticle* pPart,const MissingETBase::Types::weight_t& weight=MissingETBase::Types::weight_t(),
    //                       MissingETBase::Types::bitmask_t sw=MissingETBase::Status::defaultAccept);
    //   /*! @brief Construct with a given MET object and a first contributing object
    //    *
    //    *  Instantiates a complete (loaded with one contributing object) @link MissingETComponent MissingETComponent @endlink 
    //    *  object with a link to a @link MissingET MissingET @endlink  object and otherwise default data.
    //    *
    //    *  @return Pointer to valid and loaded @link MissingETComponent MissingETComponent @endlink object. Returns NULL if problem with generation.
    //    *
    //    *  @param[in] pmetObj pointer to non-modifiable MET object.
    //    *  @param[in] pPart   pointer to non-modifiable contributing object.
    //    *  @param[in] wpx     kinematic weight @f$ w_{x} @f$
    //    *  @param[in] wpy     kinematic weight @f$ w_{y} @f$
    //    *  @param[in] wet     kinematic weight @f$ w_{\rm T} @f$
    //    *  @param[in] sw      status of contribution (optional, default is MissingETBase::Status::defaultAccept.
    //    *
    //    *  @note If the reference to the container in the MET object is invalid, 
    //    *        Contribution::updateMETLink() must be called after the @link MissingET MissingET @endlink object has been inserted into a storable 
    //    *        @link MissingETContainer MissingETContainer @endlink. Only then is the EL complete and valid. The same
    //    *        applies to the EL to all contributing objects. 
    //    *        Invoking Contribution::updateLinks() updates all EL with the container pointers, making them valid if the container pointers are not 
    //    *        NULL. This action involves a loop over the full list of contributing objects. 
    //    *
    //    *  @warning Any invalid input (expecially NULL pointers) suppresses generation of the @link MissingETComponent MissingETComponent @endlink 
    //    *           object (a NULL pointer is returned).
    //    */
    //   static MissingETComponent* generate(const MissingET* pmetObj,const IParticle* pPart,double wpx,double wpy,double wet,MissingETBase::Types::bitmask_t sw=MissingETBase::Status::clearedStatus());
 
    //   /*!@}*/
    // }; // Contribution
 
#endif