DerivationFramework::JpsiUpsilonCommon Class Reference

#include <JpsiUpsilonCommon.h>

Collaboration diagram for DerivationFramework::JpsiUpsilonCommon:

Static Public Member Functions
static double	getInvariantMass (const xAOD::TrackParticle *trk1, double mass1, const xAOD::TrackParticle *trk2, double mass2)
static double	getInvariantMass (std::span< const xAOD::TrackParticle * > trk, std::span< const double > masses)
static double	getPt (std::span< const xAOD::TrackParticle *const > tracks)
template<typename... Tracks>
static double	getPt (const xAOD::TrackParticle *first, const Tracks *... rest)
static bool	isContainedIn (const xAOD::TrackParticle *, std::span< const xAOD::TrackParticle *const >) noexcept
static bool	isContainedIn (const xAOD::TrackParticle *, const xAOD::MuonContainer *)
static bool	cutRangeOR (std::span< double const > values, double min, double max) noexcept
static bool	cutRange (double value, double min, double max) noexcept
static bool	cutAcceptGreaterOR (std::span< double const > values, double min) noexcept
static bool	cutAcceptGreater (double value, double min) noexcept
static Analysis::CleanUpVertex	ClosestRefPV (xAOD::BPhysHelper &, const xAOD::VertexContainer *, const Analysis::PrimaryVertexRefitter *)
static void	RelinkVertexTracks (std::span< const xAOD::TrackParticleContainer *const > trkcols, xAOD::Vertex *vtx)
static void	RelinkVertexMuons (std::span< const xAOD::MuonContainer *const > muoncols, xAOD::Vertex *vtx)

Detailed Description

Definition at line 41 of file JpsiUpsilonCommon.h.

Member Function Documentation

ClosestRefPV()

Analysis::CleanUpVertex Analysis::JpsiUpsilonCommon::ClosestRefPV ( xAOD::BPhysHelper & bHelper, const xAOD::VertexContainer * importedPVerticesCollection, const Analysis::PrimaryVertexRefitter * pvRefitter )

static

Definition at line 97 of file JpsiUpsilonCommon.cxx.

                                                                            {
       const xAOD::Vertex* vtx_closest = nullptr; // vertex closest to bVertex track
       if(importedPVerticesCollection->empty()) return Analysis::CleanUpVertex(nullptr, false);
       double dc = 1e10;
       std::vector<const xAOD::Vertex*> tocleanup;
       if(pvRefitter) tocleanup.reserve(importedPVerticesCollection->size());
       bool vertexrefitted = false;
       for (const xAOD::Vertex* PV : *importedPVerticesCollection) {
          const xAOD::Vertex* refPV = pvRefitter ? pvRefitter->refitVertex(PV, bHelper.vtx(), false) : nullptr;
          const xAOD::Vertex* vtx = refPV ? refPV : PV;
          if(refPV) tocleanup.push_back(refPV);
          TVector3 posPV(vtx->position().x(),vtx->position().y(),vtx->position().z());
          auto &helperpos = bHelper.vtx()->position();
          TVector3 posV(helperpos.x(), helperpos.y(), helperpos.z());
          TVector3 nV = bHelper.totalP().Unit();
          TVector3 dposV = posPV-posV;
          double dposVnV = dposV*nV;
          double d = std::sqrt(std::abs(dposV.Mag2()-dposVnV*dposVnV));
          if (d<dc) {
             dc = d;
             vtx_closest = vtx;
             vertexrefitted = (vtx_closest == refPV);
          }
       }
       for(auto ptr : tocleanup){
           if(ptr != vtx_closest) delete ptr;
       }
       return Analysis::CleanUpVertex(vtx_closest, vertexrefitted);
    }

cutAcceptGreater()

bool Analysis::JpsiUpsilonCommon::cutAcceptGreater ( double value, double min )

staticnoexcept

Definition at line 86 of file JpsiUpsilonCommon.cxx.

                                                                               {
        return (min <=0.0 || value >= min);
    }

cutAcceptGreaterOR()

bool Analysis::JpsiUpsilonCommon::cutAcceptGreaterOR ( std::span< double const > values, double min )

staticnoexcept

Definition at line 90 of file JpsiUpsilonCommon.cxx.

                                                                                                {
        for(double m : values) {
           if(min <=0.0 || m >= min) return true;
        }
        return false;
    }

cutRange()

bool Analysis::JpsiUpsilonCommon::cutRange ( double value, double min, double max )

staticnoexcept

Definition at line 75 of file JpsiUpsilonCommon.cxx.

                                                                                  {
        return (min<=0.0 || value >= min) && (max <= 0.0 || value <= max);
    }

cutRangeOR()

bool Analysis::JpsiUpsilonCommon::cutRangeOR ( std::span< double const > values, double min, double max )

staticnoexcept

Definition at line 79 of file JpsiUpsilonCommon.cxx.

                                                                                                    {
        for(double m : values) {
           if( (min<=0.0 || m >= min) && (max <= 0.0 || m <= max)) return true;
        }
        return false;
    }

getInvariantMass() [1/2]

double Analysis::JpsiUpsilonCommon::getInvariantMass ( const xAOD::TrackParticle * trk1, double mass1, const xAOD::TrackParticle * trk2, double mass2 )

static

Definition at line 34 of file JpsiUpsilonCommon.cxx.

    {
        auto mom1 = trk1->genvecP4();
        mom1.SetM(mass1);
        auto mom2 = trk2->genvecP4();
        mom2.SetM(mass2);
        return (mom1 + mom2).M();
    }

getInvariantMass() [2/2]

double Analysis::JpsiUpsilonCommon::getInvariantMass ( std::span< const xAOD::TrackParticle * > trk, std::span< const double > masses )

static

Definition at line 43 of file JpsiUpsilonCommon.cxx.

    {
        assert(tracks.size() == masses.size());
        // Start with the four-momentum of the first track
        auto Totalmomentum = tracks[0]->genvecP4();
        Totalmomentum.SetM(masses[0]);
 
        for (size_t i = 1; i < tracks.size(); ++i) {
           auto momentum = tracks[i]->genvecP4();
           momentum.SetM(masses[i]);
           Totalmomentum += momentum;
        }
        return Totalmomentum.M();
    }

getPt() [1/2]

template<typename... Tracks>

double Analysis::JpsiUpsilonCommon::getPt ( const xAOD::TrackParticle * first, const Tracks *... rest )

inlinestatic

Definition at line 58 of file JpsiUpsilonCommon.h.

        {
            // Start with the four-momentum of the first track
            auto momentum = first->genvecP4();
        
            // Fold the rest of the tracks into the sum using += 
            // (The expansion applies += to each subsequent genvecP4())
            ( (momentum += rest->genvecP4()), ... );
        
            return std::sqrt(momentum.Perp2());
        }

getPt() [2/2]

double Analysis::JpsiUpsilonCommon::getPt ( std::span< const xAOD::TrackParticle *const > tracks )

static

Definition at line 17 of file JpsiUpsilonCommon.cxx.

    {
        if (tracks.empty()) {
            return 0.0;
        }
    
        // Start with the four-momentum of the first track
        auto momentum = tracks[0]->genvecP4();
    
        // Add the rest
        for (size_t i = 1; i < tracks.size(); ++i) {
            momentum += tracks[i]->genvecP4();
        }
    
        return std::sqrt(momentum.Perp2());
    }

isContainedIn() [1/2]

bool Analysis::JpsiUpsilonCommon::isContainedIn ( const xAOD::TrackParticle * theTrack, const xAOD::MuonContainer * theColl )

static

Definition at line 69 of file JpsiUpsilonCommon.cxx.

                                                                                                             {
        return std::find_if(theColl->begin(), theColl->end(), [theTrack](const xAOD::Muon* muon){
            return muon->trackParticle(xAOD::Muon::TrackParticleType::InnerDetectorTrackParticle) == theTrack;
        }) != theColl->end();
    }

isContainedIn() [2/2]

bool Analysis::JpsiUpsilonCommon::isContainedIn ( const xAOD::TrackParticle * theTrack, std::span< const xAOD::TrackParticle *const > theColl )

staticnoexcept

Definition at line 65 of file JpsiUpsilonCommon.cxx.

                                                                                                                                     {
        return std::find(theColl.begin(), theColl.end(), theTrack) != theColl.end();
    }

RelinkVertexMuons()

void Analysis::JpsiUpsilonCommon::RelinkVertexMuons ( std::span< const xAOD::MuonContainer *const > muoncols, xAOD::Vertex * vtx )

static

Definition at line 151 of file JpsiUpsilonCommon.cxx.

                                                                                                              {
       using MuonLink = ElementLink<xAOD::MuonContainer>;
       using MuonLinkVector = std::vector<MuonLink>;
       static const SG::AuxElement::Decorator<MuonLinkVector> muonLinksDecor("MuonLinks");
       const MuonLinkVector &mlinksold = muonLinksDecor(*vtx);
       auto size = mlinksold.size();
       MuonLinkVector newmulinks;
       for(size_t i = 0; i<size; i++){
          const xAOD::Muon* mylink= *(mlinksold[i]);
          for(const xAOD::MuonContainer* mucol : muoncols){
            auto itr = std::find(mucol->begin(), mucol->end(), mylink);
            if(itr != mucol->end()){
                auto mylink=mlinksold[i];
                mylink.setStorableObject(*mucol, true);
                newmulinks.push_back( mylink );
                break;
            }
          }
       }
       if(size != newmulinks.size()){
        throw std::runtime_error("JpsiUpsilonCommon::RelinkVertexMuons: Could not relink all tracks");
       }
       muonLinksDecor(*vtx) = std::move(newmulinks);
    }

RelinkVertexTracks()

void Analysis::JpsiUpsilonCommon::RelinkVertexTracks ( std::span< const xAOD::TrackParticleContainer *const > trkcols, xAOD::Vertex * vtx )

static

Definition at line 129 of file JpsiUpsilonCommon.cxx.

                                                                                                                        {
      std::vector<ElementLink<DataVector<xAOD::TrackParticle> > > newLinkVector;
      auto size = vtx->trackParticleLinks().size();
      for(size_t i = 0; i<size; i++){
          const xAOD::TrackParticle* mylink= *(vtx->trackParticleLinks()[i]);
          for(const xAOD::TrackParticleContainer* trkcol : trkcols){
              auto itr = std::find(trkcol->begin(), trkcol->end(), mylink);
              if(itr != trkcol->end()){
                auto mylink=vtx->trackParticleLinks()[i];
                mylink.setStorableObject(*trkcol, true);
                newLinkVector.push_back( mylink );
                break;
              }
          }
      }
      if(size != newLinkVector.size()){
        throw std::runtime_error("JpsiUpsilonCommon::RelinkVertexTracks: Could not relink all tracks");
      }
      vtx->clearTracks();
      vtx->setTrackParticleLinks( newLinkVector );
    }

---

The documentation for this class was generated from the following files:

• JpsiUpsilonCommon.h
• JpsiUpsilonCommon.cxx