DerivationFramework::JpsiUpsilonCommon Class Reference

#include <JpsiUpsilonCommon.h>

Collaboration diagram for DerivationFramework::JpsiUpsilonCommon:

Static Public Member Functions
static double	getPt (const xAOD::TrackParticle *, const xAOD::TrackParticle *)
static double	getPt (const xAOD::TrackParticle *trk1, const xAOD::TrackParticle *trk2, const xAOD::TrackParticle *trk3)
static double	getPt (const xAOD::TrackParticle *, const xAOD::TrackParticle *, const xAOD::TrackParticle *, const xAOD::TrackParticle *)
static bool	isContainedIn (const xAOD::TrackParticle *, const std::vector< const xAOD::TrackParticle * > &)
static bool	isContainedIn (const xAOD::TrackParticle *, const xAOD::MuonContainer *)
template<size_t N>
static bool	isContainedIn (const xAOD::TrackParticle *, const std::array< const xAOD::TrackParticle *, N > &)
static bool	cutRangeOR (const std::vector< double > &values, double min, double max)
static bool	cutRange (double value, double min, double max)
static bool	cutAcceptGreaterOR (const std::vector< double > &values, double min)
static bool	cutAcceptGreater (double value, double min)
static Analysis::CleanUpVertex	ClosestRefPV (xAOD::BPhysHelper &, const xAOD::VertexContainer *, const Analysis::PrimaryVertexRefitter *)
static void	RelinkVertexTracks (const std::vector< const xAOD::TrackParticleContainer * > &trkcols, xAOD::Vertex *vtx)
static void	RelinkVertexMuons (const std::vector< const xAOD::MuonContainer * > &muoncols, xAOD::Vertex *vtx)

Detailed Description

Definition at line 39 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 94 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 )

static

Definition at line 83 of file JpsiUpsilonCommon.cxx.

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

cutAcceptGreaterOR()

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

static

Definition at line 87 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 )

static

Definition at line 72 of file JpsiUpsilonCommon.cxx.

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

cutRangeOR()

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

static

Definition at line 76 of file JpsiUpsilonCommon.cxx.

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

getPt() [1/3]

double Analysis::JpsiUpsilonCommon::getPt ( const xAOD::TrackParticle * trk1, const xAOD::TrackParticle * trk2 )

static

Definition at line 17 of file JpsiUpsilonCommon.cxx.

                                                                                                {
        
        TLorentzVector momentum(trk1->p4() + trk2->p4() ); 
        return momentum.Perp();
        
    }

getPt() [2/3]

double Analysis::JpsiUpsilonCommon::getPt ( const xAOD::TrackParticle * trk1, const xAOD::TrackParticle * trk2, const xAOD::TrackParticle * trk3, const xAOD::TrackParticle * trk4 )

static

Definition at line 40 of file JpsiUpsilonCommon.cxx.

    {
        TLorentzVector momentum( trk1->p4() );
        momentum += trk2->p4();
        momentum += trk3->p4();
        momentum += trk4->p4();
        return momentum.Perp();
    }

getPt() [3/3]

double Analysis::JpsiUpsilonCommon::getPt ( const xAOD::TrackParticle * trk1, const xAOD::TrackParticle * trk2, const xAOD::TrackParticle * trk3 )

static

Definition at line 26 of file JpsiUpsilonCommon.cxx.

    {
        TLorentzVector momentum( trk1->p4() );
        momentum+= trk2->p4();
        momentum+= trk3->p4();
        return momentum.Perp();
    }

isContainedIn() [1/3]

template<size_t N>

bool Analysis::JpsiUpsilonCommon::isContainedIn ( const xAOD::TrackParticle * t, const std::array< const xAOD::TrackParticle *, N > & cont )

static

Definition at line 60 of file JpsiUpsilonCommon.h.

 {
    return std::find(cont.begin(), cont.end(), t) != cont.end();
 }

isContainedIn() [2/3]

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

static

Definition at line 58 of file JpsiUpsilonCommon.cxx.

                                                                                                                               {
        return std::find(theColl.cbegin(), theColl.cend(), theTrack) != theColl.cend();
    }

isContainedIn() [3/3]

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

static

Definition at line 62 of file JpsiUpsilonCommon.cxx.

                                                                                                             {
        bool isContained(false);
        xAOD::MuonContainer::const_iterator muItr;
        for (muItr=theColl->begin(); muItr!=theColl->end(); ++muItr) {
            auto& link = ( *muItr )->inDetTrackParticleLink();
            if ( link.isValid() && ( *link == theTrack ) ) {isContained=true; break;}
        }
        return isContained;
    }

RelinkVertexMuons()

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

static

Definition at line 148 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 ( const std::vector< const xAOD::TrackParticleContainer * > & trkcols, xAOD::Vertex * vtx )

static

Definition at line 126 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