RaveKinematicVertexFitter.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <analysis/dataobjects/Particle.h>
#include <analysis/VertexFitting/RaveInterface/RaveSetup.h>
 
#include <mdst/dataobjects/TrackFitResult.h>
//std
#include <string>
 
//root
#include <TMatrixFSym.h>
#include <Math/Vector3D.h>
#include <Math/Vector4D.h>
//rave
#include <rave/Vertex.h>
#include <rave/Track.h>
#include <rave/KinematicTree.h>
 
// for intercepting rave output
#include <framework/utilities/IOIntercept.h>
 
#include <iostream>
 
namespace Belle2 {
  namespace analysis {
    class RaveKinematicVertexFitter {
    public:
      RaveKinematicVertexFitter();
 
      //RaveKinematicVertexFitter(std::string howToInterfaceRave);
      ~RaveKinematicVertexFitter();
 
      void addTrack(const Particle* aParticlePtr);
 
      void addMother(const Particle* aMotherParticlePtr);
 
      void setMother(const Particle* aMotherParticlePtr);
 
      int fit();
 
      ROOT::Math::XYZVector getPos() ;
 
      double getPValue();
 
      double getNdf();
 
      double getChi2() ;
 
      TMatrixDSym getCov();
 
      TMatrixDSym getVertexErrorMatrix();
 
      void useBeamSpot(bool beamSpot = true)
      {
        if (beamSpot == true) {
          if (RaveSetup::getRawInstance()->m_useBeamSpot == false) {
            B2FATAL("Beam spot information cannot be used because the beam spot position and covariance was not set in RaveSetup");
          }
          m_useBeamSpot = true;
        } else {
          m_useBeamSpot = false;
        }
      }
 
      Particle* getMother();
 
      void updateMother();
 
      void updateDaughters();
 
      void clearTracks()
      {
        m_inputParticles.clear();
        m_motherParticlePtr = nullptr;
      }
 
      void setMassConstFit(bool isConstFit = true);
 
      void setVertFit(bool isVertFit = true);
 
      void Print() const
      {
        B2INFO("useBeamSpot: " << m_useBeamSpot);
        B2INFO("number of rave::Tracks: " << m_inputParticles.size());
      }
 
 
 
 
    protected:
 
      bool m_useBeamSpot;
 
      Particle* m_motherParticlePtr;
 
      std::string m_raveAlgorithm;
 
      rave::KinematicTree m_fittedResult;
 
      std::vector<rave::Track> m_raveTracks;
 
      std::vector < rave::Vertex > m_raveVertices;
 
      std::vector< rave::KinematicParticle > m_inputParticles;
      rave::KinematicParticle m_fittedParticle;
 
      std::vector<Particle*> m_belleDaughters;
 
      bool m_massConstFit;
      bool m_vertFit;
      double m_fittedNdf;
      double m_fittedPValue;
      double m_fittedChi2;
      ROOT::Math::XYZVector m_fittedPos;
      ROOT::Math::PxPyPzEVector m_fitted4Vector;
      TMatrixFSym m_fitted7Cov;
 
 
    private:
 
      TMatrixDSym ErrorMatrixMassToEnergy(const ROOT::Math::PxPyPzEVector& p4, const TMatrixDSym& MassErr);
 
      TMatrixDSym ErrorMatrixEnergyToMass(const ROOT::Math::PxPyPzEVector& p4, const TMatrixDSym& EnergyErr);
 
      IOIntercept::InterceptorScopeGuard<IOIntercept::OutputToLogMessages> captureOutput();
    };
  }
 
}