/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/xAODJet/xAODJet/JetAccessors.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
#ifndef XAODJET_JETACCESSORS_H
#define XAODJET_JETACCESSORS_H

#include <string>
#include "AthContainers/AuxElement.h"
#include "xAODBase/IParticle.h"
#include "xAODJet/JetTypes.h"

using SG::AuxElement;
namespace xAOD {


  namespace JetAttributeAccessor {


    struct Named { 
      Named(const std::string & n) : m_name(n){}
      std::string name(){return m_name;}
    protected:
      std::string m_name;
    };

    template<class TYPE>
    class AccessorWrapper : public Named {
    public:
      typedef typename SG::AuxElement::Accessor< TYPE > AccessorType;
      AccessorWrapper(const std::string & n) : Named(n), m_a(n) {}
      
      void setAttribute(SG::AuxElement& p, const TYPE& v){
        m_a(p) = v;
      }
      
      void getAttribute(const SG::AuxElement& p,  TYPE& v){
        v = m_a(p);
      }

      const TYPE & getAttribute(const SG::AuxElement& p){
        return m_a(p);
      }
      
      bool isAvailable(const SG::AuxElement& p){ return m_a.isAvailable(p);}

      // forward calls to internal accessor. useful for performance critical code.
      const TYPE& operator()(const SG::AuxElement& p)  { return m_a(p);}
      TYPE& operator()(SG::AuxElement& p)  { return m_a(p);}

    protected:
      AccessorType m_a;
    };

    template<>
    class AccessorWrapper<double> : public Named {
    public:
      typedef SG::AuxElement::Accessor< float > AccessorType;
      AccessorWrapper(const std::string & n) : Named(n) , m_a(n) {}
      
      void setAttribute(SG::AuxElement& p, const double& v){
        m_a(p) = v;
      }
      
      void getAttribute(const SG::AuxElement& p,  double& v){
        v = m_a(p);
      }

      // can't return a reference, since the internal is a float.
      double  getAttribute(const SG::AuxElement& p){
        return  m_a(p);
      }

      
      bool isAvailable(const SG::AuxElement& p){ return m_a.isAvailable(p);}

    protected:
      AccessorType m_a;
    };


    template<>
    class AccessorWrapper< std::vector<double> > : public Named{
    public:
      typedef SG::AuxElement::Accessor< std::vector<float>  > AccessorType;
      AccessorWrapper(const std::string & n) : Named(n), m_a(n) {}
      
      void setAttribute(SG::AuxElement& p, const std::vector<double>& v){
        m_a(p).assign( v.begin() , v.end() );
      }
      
      void getAttribute(const SG::AuxElement& p,  std::vector<double>& v){
        const std::vector<float> & vecF = m_a(p);
        v.assign( vecF.begin() , vecF.end() );
      }

      // can't return a reference, since the internal is a float.
      std::vector<double>  getAttribute(const SG::AuxElement& p){
        std::vector<double> v; getAttribute(p,v);
        return v;
      }

      
      bool isAvailable(const SG::AuxElement& p){ return m_a.isAvailable(p);}

    protected:
      AccessorType m_a;
    };


    

    class FourMomAccessor : public Named {
    public:
      FourMomAccessor(const std::string& name, const std::string& n0, const std::string& n1, const std::string& n2, const std::string& n3) :Named(name) , m_p0(n0), m_p1(n1), m_p2(n2), m_p3(n3) {}
      
      bool isAvailable(const SG::AuxElement& e) const {return m_p0.isAvailable(e);}
      
    protected:
      SG::AuxElement::Accessor< float > m_p0;
      SG::AuxElement::Accessor< float > m_p1;
      SG::AuxElement::Accessor< float > m_p2;
      SG::AuxElement::Accessor< float > m_p3;            
    };


    template<>
    class AccessorWrapper<JetFourMom_t> : public FourMomAccessor {
    public:
      AccessorWrapper() :  FourMomAccessor("_unnamed_","pt", "eta","phi", "m") {}
      AccessorWrapper(const std::string &name) : FourMomAccessor(name, name+"_pt", name+"_eta",name+"_phi", name+"_m") {}
      
      const float & pt(const SG::AuxElement& p){ return m_p0(p);}
      const float & eta(const SG::AuxElement& p){ return m_p1(p);}
      const float & phi(const SG::AuxElement& p){ return m_p2(p);}
      const float & m(const SG::AuxElement& p){ return m_p3(p);}

      void setAttribute(SG::AuxElement& p, const JetFourMom_t& v){
        m_p0(p) = v.Pt();
        m_p1(p) = v.Eta();
        m_p2(p) = v.Phi();
        m_p3(p) = v.M();
      }
      
      void getAttribute(const SG::AuxElement& p,  JetFourMom_t& v){
        v.SetPt(  m_p0(p) );
        v.SetEta(  m_p1(p) );
        v.SetPhi(  m_p2(p) );
        v.SetM(  m_p3(p) );
      }           

      JetFourMom_t getAttribute(const SG::AuxElement &p){
        JetFourMom_t v; getAttribute(p,v);
        return v;
      }

      // other convenience function
      void setPtEtaPhiM(SG::AuxElement& p, float pt, float eta, float phi, float m ){
        m_p0(p) = pt ;
        m_p1(p) = eta ;
        m_p2(p) = phi ;
        m_p3(p) = m ;
      }


    };


    template<>
    class AccessorWrapper<IParticle::FourMom_t> : public FourMomAccessor {
    public:
      AccessorWrapper(const std::string &name) : FourMomAccessor(name, name+"_px", name+"_py",name+"_pz", name+"_e") {}
      void setAttribute(SG::AuxElement& p, const IParticle::FourMom_t& v){
        m_p0(p) = v.Px();
        m_p1(p) = v.Py();
        m_p2(p) = v.Pz();
        m_p3(p) = v.E();
      }
      
      void getAttribute(const SG::AuxElement& p,  IParticle::FourMom_t& v){
        v.SetPx( m_p0(p) );
        v.SetPy( m_p1(p) );
        v.SetPz( m_p2(p) );
        v.SetE( m_p3(p) );
      }           

      IParticle::FourMom_t getAttribute(const SG::AuxElement &p){
        IParticle::FourMom_t v; getAttribute(p,v);
        return v;
      }
      
    };



    namespace {

      template<typename Obj>
      class InheritsIParticle
      {
       
        class No { };
        class Yes { No no[3]; };
        
        static Yes testFunc( IParticle* ); // declared, but not defined
        static No testFunc( ... ); // declared, but not defined
        
      public:
        enum { Test = sizeof(testFunc(static_cast<Obj*>(0))) == sizeof(Yes) };
      }; 
      

      template<typename Obj, bool IsIP> 
      struct InternalTypes {
        typedef DataVector<Obj> ContainerType;
        typedef ElementLink< ContainerType > LinkType;
        typedef SG::AuxElement::Accessor< LinkType > AccessorType;        
        static const Obj* fromEL(const LinkType&el){if(el.isValid())return *el; return NULL;}
      };

      template<typename Obj> 
      struct InternalTypes<Obj,true> {
        typedef IParticleContainer ContainerType;
        typedef ElementLink< ContainerType >  LinkType;
        typedef SG::AuxElement::Accessor< LinkType > AccessorType;        
        static const Obj* fromEL(const LinkType&el){if(el.isValid()) return dynamic_cast<const Obj*>(*el); return NULL;}
      };

      template<typename Obj, bool IsIP> 
      struct InternalVectorTypes : public InternalTypes<Obj,IsIP> {
        typedef typename InternalTypes<Obj,IsIP>::LinkType LinkType;
        typedef SG::AuxElement::Accessor< std::vector<LinkType> > AccessorType;
      };
      


    }


    template<class TYPE>
    class ObjectAccessorWrapper: public Named {
    public:
      typedef InternalTypes<TYPE, InheritsIParticle<TYPE>::Test> InternalType;
      typedef typename InternalType::ContainerType ContainerType;
      typedef typename InternalType::LinkType LinkType;
      typedef typename InternalType::AccessorType AccessorType;

      ObjectAccessorWrapper(const std::string & n) : Named(n), m_a(n) {}

      void setAttribute(SG::AuxElement& p, const TYPE* o){
        LinkType &el = m_a(p);
        el.toIndexedElement( *( dynamic_cast< const ContainerType* >( o->container() ) ), o->index() );  
        el.toPersistent();
      }
      

      const TYPE * getAttribute(const SG::AuxElement& p){
        return InternalType::fromEL(  m_a(p) );
      }

      void getAttribute(const SG::AuxElement& p, const TYPE *& att){
        att= InternalType::fromEL(  m_a(p) );
      }
      
      bool isAvailable(const SG::AuxElement& p){ return m_a.isAvailable(p);}
      
      // // forward calls to internal accessor. useful for performance critical code.
      const TYPE* operator()(const SG::AuxElement& p)  { return getAttribute(p); }
      // TYPE& operator()(SG::AuxElement& p)  { LinkType &el=m_a(p); return *el;}

    protected:
      AccessorType m_a;      
    };

    template<class TYPE>
    class ObjectAccessorWrapper<std::vector<const TYPE*> > : public Named {
    public:
      typedef InternalVectorTypes<TYPE, InheritsIParticle<TYPE>::Test> InternalType;
      typedef typename InternalType::ContainerType ContainerType;
      typedef typename InternalType::LinkType LinkType;
      typedef typename InternalType::AccessorType AccessorType;

      ObjectAccessorWrapper(const std::string & n) : Named(n), m_a(n) {}

      
      void vector2vectorEL(const std::vector<const TYPE*> & vec, std::vector< LinkType > & elv) {
        
        for(size_t i=0; i< vec.size() ; i++) { 
          LinkType el;
          el.toIndexedElement( *( dynamic_cast< const ContainerType* >( vec[i]->container() ) ), vec[i]->index() );      
          elv.push_back(el); 
          elv.back().toPersistent(); // The EL will not change anymore since it is purely internal. We can call toPersistent() to be sure it will be saved as expected.
        }
      }
      
      void setAttribute(SG::AuxElement& p, const std::vector<const TYPE*> &vec){
        std::vector<LinkType> &elv = m_a(p); elv.clear();elv.reserve(vec.size());
        this->vector2vectorEL(vec, elv);
      }
      
      void getAttribute(const SG::AuxElement& p,  std::vector<const TYPE*>& v){
        const std::vector<LinkType> &elv = m_a(p); 
        v.resize(elv.size());
        for(size_t i=0;i<elv.size(); i++) {v[i] = InternalType::fromEL(elv[i]) ; }
      }

      std::vector<const TYPE *> getAttribute(const SG::AuxElement& p){
        const std::vector<LinkType> &elv = m_a(p); 
        std::vector<const TYPE*>  ipvec(elv.size() );
        for(size_t i=0;i<elv.size(); i++) ipvec[i] = InternalType::fromEL(elv[i]) ;
        return ipvec;
      }
      
      bool isAvailable(const SG::AuxElement& p){ return m_a.isAvailable(p);}
      
      // // forward calls to internal accessor. useful for performance critical code.
      // const TYPE* operator()(const AuxElement& p)  { const LinkType &el = m_a(p) ;return *el;}
      // TYPE& operator()(AuxElement& p)  { LinkType &el=m_a(p); return *el;}

    protected:
      AccessorType m_a;
    };




  }// namespace JetAttributeAccessor
}
#endif

---