RootCore Packages: /cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/xAODMissingET/xAODMissingET/MissingETComposition.h Source File

00001 // -*- c++ -*-
00002 #ifndef XAODMISSINGET_MISSINGETCOMPOSITION_H
00003 #define XAODMISSINGET_MISSINGETCOMPOSITION_H
00004 
00005 #include "xAODMissingET/versions/MissingETCompositionBase.h"
00006 #include "xAODMissingET/MissingET.h"
00007 #include "xAODMissingET/MissingETComponent.h"
00008 #include "xAODMissingET/MissingETComponentMap.h"
00009 #include "xAODMissingET/MissingETAssociation.h"
00010 #include "xAODMissingET/MissingETAssociationMap.h"
00011 #include "xAODJet/Jet.h"
00012 
00013 namespace xAOD 
00014 {
00015   struct MissingETComposition
00016   {
00034     static bool add(MissingETComponentMap* pMap,const MissingET* pMET,MissingETBase::Types::bitmask_t sw=MissingETBase::Status::clearedStatus());
00044     static bool insert(MissingETComponentMap* pMap,const MissingET* pMET,const IParticle* pPart,MissingETBase::Types::weight_t weight=MissingETBase::Types::weight_t());
00052     static bool insert(MissingETComponentMap* pMap,const MissingET* pMET,const IParticle* pPart,const MissingETBase::Types::object_vector_t& signalList,
00053                MissingETBase::Types::weight_t weight=MissingETBase::Types::weight_t(),
00054                MissingETBase::UsageHandler::Policy p=MissingETBase::UsageHandler::OnlyCluster);
00065     static bool insert(MissingETComponentMap* pMap,const MissingET* pMET,const IParticle* pPart,double wpx,double wpy,double wet);
00073     static bool insert(MissingETComponentMap* pMap,const MissingET* pMET,const IParticle* pPart,const MissingETBase::Types::object_vector_t& signalList,double wpx,double wpy,double wet,
00074                MissingETBase::UsageHandler::Policy p=MissingETBase::UsageHandler::OnlyCluster);
00098     static bool updateLinks(MissingETComponentMap* pMap);
00115     static bool updateMETLinks(MissingETComponentMap* pMap);
00130     static MissingETComponentMap::const_iterator find(const MissingETComponentMap* pMap,const MissingET* pmetObj);
00131     static MissingETComponentMap::iterator       find(MissingETComponentMap* pMap,const MissingET* pmetObj);
00132     static MissingETComponentMap::const_iterator find(const MissingETComponentMap* pMap,const std::string& metName);
00133     static MissingETComponentMap::iterator       find(MissingETComponentMap* pMap,const std::string& metName);
00134     static MissingETComponentMap::const_iterator find(const MissingETComponentMap* pMap,MissingETBase::Types::bitmask_t src);
00135     static MissingETComponentMap::iterator       find(MissingETComponentMap* pMap,MissingETBase::Types::bitmask_t src);
00136     static size_t findIndex(const MissingETComponentMap* pMap,const MissingET* pmetObj);
00137     static size_t findIndex(const MissingETComponentMap* pMap,const std::string& metName);
00138     static size_t findIndex(const MissingETComponentMap* pMap,MissingETBase::Types::bitmask_t src);
00139 
00140 
00149     static MissingETComponentMap::const_iterator find(const MissingETComponentMap* pMap,const IParticle* pPart);
00158     static MissingETComponentMap::iterator find(MissingETComponentMap* pMap,const IParticle* pPart);
00172     static MissingETComponentMap::const_iterator begin(const MissingETComponentMap* pMap);
00182     static MissingETComponentMap::iterator begin(MissingETComponentMap* pMap);
00183     static MissingETComponentMap::const_iterator end(const MissingETComponentMap* pMap);
00184     static MissingETComponentMap::iterator end(MissingETComponentMap* pMap);
00194     static const MissingETComponent* getComponent(const MissingETComponentMap* pMap,const IParticle* pPart);
00195     static const MissingETComponent* getComponent(const MissingETComponentMap* pMap,const MissingET* pmetObj);
00196     static const MissingETComponent* getComponent(const MissingETComponentMap* pMap,const std::string& metName);
00197     static const MissingETComponent* getComponent(const MissingETComponentMap* pMap,MissingETBase::Types::bitmask_t src);
00203     static MissingETComponent* getComponent(MissingETComponentMap* pMap,const IParticle* pPart);
00204     static MissingETComponent* getComponent(MissingETComponentMap* pMap,const MissingET* pmetObj);
00205     static MissingETComponent* getComponent(MissingETComponentMap* pMap,const std::string& metName);
00206     static MissingETComponent* getComponent(MissingETComponentMap* pMap,MissingETBase::Types::bitmask_t src);
00211     static MissingETBase::Types::weight_t getWeight(const MissingETComponentMap* pMap,const IParticle* pPart);
00212     static MissingETBase::Types::weight_t getWeight(MissingETComponentMap::const_iterator fCont,const IParticle* pPart);
00213     static MissingETBase::Types::bitmask_t getStatusWord(const MissingETComponentMap* pMap,const MissingET* pmetObj);
00214     static MissingETBase::Types::bitmask_t getStatusWord(MissingETComponentMap::const_iterator fCont);
00215     static const MissingET* getMissingET(const MissingETComponentMap* pMap,const IParticle* pPart);
00216     static const MissingET* getMissingET(MissingETComponentMap::const_iterator fCont);
00217     static const MissingET* getMissingET(const MissingETComponentMap* pMap,const std::string& name);
00218     static const MissingET* getMissingET(const MissingETComponentMap* pMap,MissingETBase::Types::bitmask_t sw);
00235     template<int OBJTYPE>
00236     static bool fillMissingET(const MissingETComponentMap* pMap,MissingET* pMET,
00237                               MissingETBase::Types::bitmask_t /*status*/=MissingETBase::Status::clearedStatus())
00238     {
00239       if ( pMap == 0 || pMap->empty() ) return false;
00240       //
00241       double sumet(pMET->sumet());
00242       MissingETComponentMap::const_iterator fComp(pMap->begin());
00243       MissingETComponentMap::const_iterator lComp(pMap->end());
00244       for ( ; fComp != lComp; ++fComp ) 
00245     { 
00246       const MissingETComponent* pCont = *fComp;
00247       if ( pCont != 0 )
00248         {
00249           // get objects from contribution
00250           MissingETBase::Types::weight_vector_t kinePars;
00251           MissingETBase::Types::object_vector_t objs = pCont->objects(kinePars);
00252           for ( size_t iObj(0); iObj<objs.size(); ++iObj )
00253         { 
00254           if ( objs[iObj]->type() == OBJTYPE ) 
00255             { // this is really stupid!!!!
00256               pMET->add(objs.at(iObj)->p4().Px()*kinePars.at(iObj).wpx(),
00257                 objs.at(iObj)->p4().Py()*kinePars.at(iObj).wpy(),
00258                 objs.at(iObj)->pt()*kinePars.at(iObj).wet());
00259             } // requested type
00260         } // loop on contributing objects
00261         } // contribution valid
00262     } // loop on all contributions
00263       return pMET->sumet() != sumet;
00264     } // fillMissingET
00265 
00283     static bool add(MissingETAssociationMap* pMap,const Jet* pJet,
00284             const std::vector<ElementLink<IParticleContainer> >& jetconst=std::vector<ElementLink<IParticleContainer> >(),
00285             const MissingETBase::Types::constvec_t& trkvec=MissingETBase::Types::constvec_t());
00299     static bool add(MissingETAssociationMap* pMap,const Jet* pJet,
00300             const std::vector<const IParticle*>& jetracks=std::vector<const IParticle*>());
00311     static bool addMiscAssociation(MissingETAssociationMap* pMap);
00321     static bool insert(MissingETAssociationMap* pMap,size_t jetIndex,const IParticle* pPart,const std::vector<const IParticle*>& constlist);
00331     static bool insert(MissingETAssociationMap* pMap,const Jet* pJet,const IParticle* pPart,const std::vector<const IParticle*>& constlist);
00339     static bool insert(MissingETAssociationMap* pMap,const IParticle* pPart,const std::vector<const IParticle*>& constlist,
00340                std::map<const IParticle*,MissingETBase::Types::constvec_t> pOverride=std::map<const IParticle*,MissingETBase::Types::constvec_t>());
00341 
00342     static bool setJetConstSum(MissingETAssociationMap* metMap,const Jet* jet,const std::vector<const IParticle*>& altConsts,
00343                    std::map<const IParticle*,MissingETBase::Types::constvec_t> pOverride);
00351     static bool insertMisc(MissingETAssociationMap* pMap,const IParticle* pPart,const std::vector<const IParticle*>& constlist);
00366     static MissingETAssociationMap::const_iterator find(const MissingETAssociationMap* pMap,const Jet* pJet);
00367     static MissingETAssociationMap::iterator       find(MissingETAssociationMap* pMap,const Jet* pJet);
00368 
00377     static MissingETAssociationMap::const_iterator find(const MissingETAssociationMap* pMap,const IParticle* pPart);
00386     static MissingETAssociationMap::iterator find(MissingETAssociationMap* pMap,const IParticle* pPart);
00400     static std::vector<const MissingETAssociation*> getAssociations(const MissingETAssociationMap* pMap,const IParticle* pPart);
00401     static MissingETBase::Types::constvec_t getConstVec(const MissingETAssociationMap* pMap,const IParticle* pPart,MissingETBase::UsageHandler::Policy p);
00402     static bool objSelected(const MissingETAssociationMap* pMap,const IParticle* obj);
00403     static bool selectIfNoOverlaps(const MissingETAssociationMap* pMap,const IParticle* obj,MissingETBase::UsageHandler::Policy p);
00404     static const MissingETAssociation* getAssociation(const MissingETAssociationMap* pMap,const Jet* pJet);
00405     //    static const MissingETAssociation* getMiscAssociation(const MissingETAssociationMap* pMap);
00411     static std::vector<MissingETAssociation*> getAssociations(MissingETAssociationMap* pMap,const IParticle* pPart);
00412     static MissingETAssociation* getAssociation(MissingETAssociationMap* pMap,const Jet* pJet);
00413     //    static MissingETAssociation* getMiscAssociation(MissingETAssociationMap* pMap);
00418     // Leave these for now -- decide how to treat calo vs track vs jet vs signal
00419     // static MissingETBase::Types::constvec_t getConstVec(const MissingETAssociationMap* pMap,const IParticle* pPart);
00420     // static MissingETBase::Types::constvec_t getConstVec(MissingETAssociationMap::const_iterator fCont,const IParticle* pPart);
00421     static const Jet* getRefJet(const MissingETAssociationMap* pMap,const IParticle* pPart);
00422     static const Jet* getRefJet(MissingETAssociationMap::const_iterator fCont);
00425   }; // MissingETComposition
00426 } // namespace xAOD
00427 
00498     // /*! @brief Object factories for a MET contribution object 
00499     //  *
00500     //  *  These functions can be helpful to generate @link xAOD::MissingETComponent MissingETComponent @endlink objects. They invoke the respective constructor
00501     //  *  with the given list of arguments. 
00502     //  *
00503     //  *  @warning These functions expose the  @link xAOD::MissingETComponent MissingETComponent @endlink object to clients, which may not be desirable. 
00504     //  *  Non-experts should probably not use them. 
00505     //  *
00506     //  */
00507     // struct Contribution
00508     // {
00509     //   /*! @name Object factories for contribution object
00510     //    *  @anchor contrib_factory 
00511     //    */
00512     //   /*!@{*/
00513     //   /*! @brief Default construction
00514     //    *
00515     //    *  Instantiates an empty @link xAOD::MissingETComponent MissingETComponent @endlink object with default parameters given in 
00516     //    *  @link xAOD::MissingETComponent::MissingETComponent() MissingETComponent::MissingETComponent() @endlink.
00517     //    *
00518     //    *  @return Pointer to valid but empty @link xAOD::MissingETComponent MissingETComponent @endlink object.
00519     //    */
00520     //   static MissingETComponent* generate();
00521     //   /*! @brief Construct with a given MET object 
00522     //    *
00523     //    *  Instantiates an incomplete (not fully loaded) @link xAOD::MissingETComponent MissingETComponent @endlink object with a link 
00524     //    *  to a @link xAOD::MissingET MissingET @endlink object and otherwise default data.
00525     //    *
00526     //    *  @return Pointer to valid but incomplete @link xAOD::MissingETComponent MissingETComponent @endlink object.
00527     //    *
00528     //    *  @param[in] pmetObj pointer to non-modifiable MET object.
00529     //    *
00530     //    *  @note If the given pointer to the @link xAOD::MissingET MissingET @endlink is NULL, the returned contribution object
00531     //    *        is empty. This is the same behaviour as implemented in the xAOD::MissingETComposition::generate() function.
00532     //    *        If the reference to the container in the MET object is invalid, 
00533     //    *        @link xAOD::MissingETComponent::updateMETLink() MissingETComponent::updateMETlink() @endlink
00534     //    *        must be called after the @link xAOD::MissingET MissingET @endlink object has been inserted into a storable 
00535     //    *        @link xAOD::MissingETContainer MissingETContainer @endlink. Only then is the EL complete and valid. 
00536     //    */
00537     //   static MissingETComponent* generate(const MissingET* pmetObj);
00538     //   /*! @brief Construct with a given MET object and a first contributing object
00539     //    *
00540     //    *  Instantiates a complete (loaded with one contributing object) @link xAOD::MissingETComponent MissingETComponent @endlink 
00541     //    *  object with a link to a @link xAOD::MissingET MissingET @endlink object and otherwise default data.
00542     //    *
00543     //    *  @return Pointer to valid and loaded @link xAOD::MissingETComponent MissingETComponent @endlink object. Returns NULL if problems 
00544     //    *          with the generation occur.
00545     //    *
00546     //    *  @param[in] pmetObj pointer to non-modifiable MET object.
00547     //    *  @param[in] pPart   pointer to non-modifiable contributing object.
00548     //    *  @param[in] weight  reference to non-modifiable kinematic weight object MissingETComposition::Weight (optional, 
00549     //    *                     default is given by Weight::Weight()).
00550     //    *  @param[in] sw      status of contribution (optional, default is MissingETBase::Status::defaultAccept).
00551     //    *
00552     //    *  @note If the reference to the container in the MET object is invalid, 
00553     //    *        xAOD::MissingETComposition::Contribution::updateMETLink() must be called after the @link MissingET MissingET @endlink object has been inserted into a storable 
00554     //    *        @link MissingETContainer MissingETContainer @endlink. Only then is the EL complete and valid. 
00555     //    *
00556     //    *  @warning Any invalid input (expecially NULL pointers) suppresses generation of the @link MissingETComponent MissingETComponent @endlink 
00557     //    *           object (a NULL pointer is returned).
00558     //    */
00559     //   static MissingETComponent* generate(const MissingET* pmetObj,const IParticle* pPart,const MissingETBase::Types::weight_t& weight=MissingETBase::Types::weight_t(),
00560     //                       MissingETBase::Types::bitmask_t sw=MissingETBase::Status::defaultAccept);
00561     //   /*! @brief Construct with a given MET object and a first contributing object
00562     //    *
00563     //    *  Instantiates a complete (loaded with one contributing object) @link MissingETComponent MissingETComponent @endlink 
00564     //    *  object with a link to a @link MissingET MissingET @endlink  object and otherwise default data.
00565     //    *
00566     //    *  @return Pointer to valid and loaded @link MissingETComponent MissingETComponent @endlink object. Returns NULL if problem with generation.
00567     //    *
00568     //    *  @param[in] pmetObj pointer to non-modifiable MET object.
00569     //    *  @param[in] pPart   pointer to non-modifiable contributing object.
00570     //    *  @param[in] wpx     kinematic weight @f$ w_{x} @f$
00571     //    *  @param[in] wpy     kinematic weight @f$ w_{y} @f$
00572     //    *  @param[in] wet     kinematic weight @f$ w_{\rm T} @f$
00573     //    *  @param[in] sw      status of contribution (optional, default is MissingETBase::Status::defaultAccept.
00574     //    *
00575     //    *  @note If the reference to the container in the MET object is invalid, 
00576     //    *        Contribution::updateMETLink() must be called after the @link MissingET MissingET @endlink object has been inserted into a storable 
00577     //    *        @link MissingETContainer MissingETContainer @endlink. Only then is the EL complete and valid. The same
00578     //    *        applies to the EL to all contributing objects. 
00579     //    *        Invoking Contribution::updateLinks() updates all EL with the container pointers, making them valid if the container pointers are not 
00580     //    *        NULL. This action involves a loop over the full list of contributing objects. 
00581     //    *
00582     //    *  @warning Any invalid input (expecially NULL pointers) suppresses generation of the @link MissingETComponent MissingETComponent @endlink 
00583     //    *           object (a NULL pointer is returned).
00584     //    */
00585     //   static MissingETComponent* generate(const MissingET* pmetObj,const IParticle* pPart,double wpx,double wpy,double wet,MissingETBase::Types::bitmask_t sw=MissingETBase::Status::clearedStatus());
00586 
00587     //   /*!@}*/
00588     // }; // Contribution
00589 
00590 #endif