WIP: Add TrackPVChecker algorithm

Algorithm to make histograms to compare different PV algorithms. Still a mess. Not ready for merge yet!

cc @dovombru @rquaglia who are maintaining the physics performance checking -- this should be done coherently with the existing and developing checking machinery

if it's a const std::vector<int> it can (and thus should) be a constexpr std::array, i.e.

constexpr auto pids = std::array{ 11, 13, 211, 321, 2212 };

how about:

   const auto& vtxs = particle->endVertices();
   const float L2 = std::accumulate( begin(vtxs), end(vtxs), 0.f,
                                     [&](float l2, const auto& decayvtx) {
                          auto thisL2 = (decayvtx->position() - particle->originVertex()->position()).Mag2() ;
                          return std::max(l2, thisL2);
                     });

instead?

How about:

const LHCb::MCParticle *bestmcp = std::accumulate( begin(mctracks), end(mctracks), std::pair{100.,(const LHCb::MCParticle*)nullptr},
                                                   [&](auto prev, const auto& mcp) {
        const float mctx = mcp->momentum().Px() / mcp->momentum().Pz() ;
	const float mcty = mcp->momentum().Py() / mcp->momentum().Pz() ;
	float dtx = s.tx() - mctx ;
	float dty = s.ty() - mcty ;
        if( std::abs(dtx) > 0.01 || std::abs(dty) > 0.01 ) return prev;

        const auto mcpos = mcp->originVertex()->position() ;
	float dz = s.z() - mcpos.z() ;
	float dx = s.x() - (mcpos.x() + mctx*dz ) ;
	float dy = s.y() - (mcpos.y() + mcty*dz ) ;
        if ( std::abs(dx) > 10*Gaudi::Units::mm || std::abs(dy) > 10*Gaudi::Units::mm ) return prev;

        // compute the chi2 for the match
	Gaudi::Vector4 delta{dx,dy,dtx,dty} ;
	double chi2 = ROOT::Math::Similarity(delta,weightmatrix) ;
        if ( chi2 >= pair.first ) return prev;

        return std::pair{ chi2, mcp };
} ).second;

One loop less, and less indenting...

when you have a 'sink' argument in the constructor, better to pass by value and move. In the case the constructor is then called with a temporary, this then effectively re-uses that temporary. Concretely:

MCVertexWithTracks(const LHCb::MCVertex* vtx,
		    const std::vector<const LHCb::Track*> tracks) :
      mcvertex{vtx},recotracks{std::move(tracks)} { std::sort(std::begin(recotracks),std::end(recotracks)) ; }

or, if you want to be more generic and accept any type of range:

template <typename RangeOfTracks>
MCVertexWithTracks(const LHCb::MCVertex* vtx,
		    RangeOfTracks tracks) :
      mcvertex{vtx},recotracks{std::forward<RangeOfTracks>(tracks)} { std::sort(begin(recotracks),end(recotracks)) ; }

there is a way of doing this with less copying of code. Take a look here which uses a small adaptor defined here.

why not include the pointer members (and the corresponding header) unconditionally, and only make their filling conditional?

mentioned in merge request !1477 (closed)

@wouter Is this still alive ? If yes, please rebase, apply comments, retest and unWIP. If not, please close.

@wouter ping. Should we do like for the LHCb MR we've discussed earlier today ? Close the MR and keep the branch in protected mode ? If no answer, I'll close this in a week

Agreed.

Done.

closed