ParticleKinematicFitterModule.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 <framework/core/Module.h>
#include <string>
#include <analysis/DecayDescriptor/DecayDescriptor.h>
 
// OrcaKinFit
#include <analysis/OrcaKinFit/BaseFitter.h>
#include <analysis/OrcaKinFit/TextTracer.h>
 
// Constraints
#include <analysis/OrcaKinFit/MomentumConstraint.h>
#include <analysis/OrcaKinFit/RecoilMassConstraint.h>
#include <analysis/OrcaKinFit/MassConstraint.h>
 
// Fitobjects
#include <analysis/OrcaKinFit/ParticleFitObject.h>
 
// analysis dataobjects
#include <analysis/dataobjects/EventExtraInfo.h>
#include <analysis/dataobjects/ParticleList.h>
 
// framework datastore
#include <framework/datastore/StoreObjPtr.h>
 
// ROOT
#include <TLorentzVector.h>
#include <TMatrixFSym.h>
 
// CLHEOP
#include <CLHEP/Matrix/SymMatrix.h>
#include <CLHEP/Vector/LorentzVector.h>
 
namespace Belle2 {
  class Particle;
  namespace OrcaKinFit {
 
    class ParticleKinematicFitterModule : public Module {
 
    public:
 
      ParticleKinematicFitterModule();
 
      virtual void initialize() override;
 
      virtual void terminate() override;
 
      virtual void event() override;
 
    private:
 
      // module parameters
      std::string m_listName;            
      std::string m_kinematicFitter;     
      std::string m_orcaFitterEngine;    
      std::string m_orcaTracer;          
      std::string m_orcaConstraint;      
      bool m_debugFitter;                
      int m_debugFitterLevel;            
      bool m_addUnmeasuredPhoton;        
      bool m_add3CPhoton;                
      bool m_updateMother;               
      bool m_updateDaughters;            
      double m_recoilMass;               
      double m_invMass;                  
      // internal variables
      TextTracer* m_textTracer;                           
      StoreObjPtr<EventExtraInfo> m_eventextrainfo;       
      std::vector <double> m_unmeasuredLeptonFitObject;   
      std::vector <double> m_unmeasuredGammaFitObject;    
      StoreObjPtr<ParticleList> m_plist;                  
      // hard constraints
      MomentumConstraint m_hardConstraintPx;  
      MomentumConstraint m_hardConstraintPy;  
      MomentumConstraint m_hardConstraintPz;  
      MomentumConstraint m_hardConstraintE;   
      RecoilMassConstraint m_hardConstraintRecoilMass;  
      MassConstraint m_hardConstraintMass;  
      // UNUSED YET
      std::string m_decayString;         
      DecayDescriptor m_decaydescriptor; 
      bool doKinematicFit(Particle* p);
 
      bool doOrcaKinFitFit(Particle* p);
 
      bool fillFitParticles(Particle* mother, std::vector<Particle*>& particleChildren);
 
      bool AddFour(Particle* mother);
 
      void addParticleToOrcaKinFit(BaseFitter& fitter, Particle* particle, const int index);
 
      void addFitObjectToConstraints(ParticleFitObject& fitobject);
 
      void addConstraintsToFitter(BaseFitter& fitter);
 
      void addTracerToFitter(BaseFitter& fitter);
 
      void setConstraints();
 
      TLorentzVector getTLorentzVectorConstraints();
 
 
      void resetFitter(BaseFitter& fitter);
 
      void addUnmeasuredGammaToOrcaKinFit(BaseFitter& fitter);
 
      void updateOrcaKinFitMother(BaseFitter& fitter, std::vector<Particle*>& particleChildren, Particle* mother);
 
 
      bool updateOrcaKinFitDaughters(BaseFitter& fitter, Particle* mother);
 
      void updateMapOfTrackAndDaughter(unsigned& l,  std::vector<std::vector<unsigned>>& pars, std::vector<unsigned>& pard,
                                       std::vector<Particle*>&  allparticles, const Particle* daughter);
 
      bool storeOrcaKinFitParticles(const std::string& prefix, BaseFitter& fitter, std::vector<Particle*>& particleChildren,
                                    Particle* mother);
 
 
      CLHEP::HepSymMatrix getCLHEPMomentumErrorMatrix(Particle* particle);
 
      CLHEP::HepSymMatrix getCLHEPMomentumVertexErrorMatrix(Particle* particle);
 
      CLHEP::HepLorentzVector getCLHEPLorentzVector(Particle* particle);
 
      TLorentzVector getTLorentzVector(ParticleFitObject* fitobject);
 
      float getFitObjectError(ParticleFitObject* fitobject, int ilocal);
 
      TMatrixFSym getFitObjectCovMat(ParticleFitObject* fitobject);
 
      TMatrixFSym getCovMat7(ParticleFitObject* fitobject);
 
      TMatrixFSym getTMatrixFSymMomentumErrorMatrix();
 
      TMatrixFSym getTMatrixFSymMomentumVertexErrorMatrix();
 
    };
 
  }// end OrcaKinFit namespace
} // Belle2 namespace