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/MomentumConstraint.h>
#include <analysis/OrcaKinFit/RecoilMassConstraint.h>
#include <analysis/OrcaKinFit/MassConstraint.h>
 
// analysis dataobjects
#include <framework/dataobjects/EventExtraInfo.h>
#include <analysis/dataobjects/ParticleList.h>
 
// framework datastore
#include <framework/datastore/StoreObjPtr.h>
 
// ROOT
#include <Math/Vector4D.h>
#include <TMatrixFSym.h>
 
// CLHEOP
#include <CLHEP/Matrix/SymMatrix.h>
#include <CLHEP/Vector/LorentzVector.h>
 
namespace Belle2 {
  class Particle;
  namespace OrcaKinFit {
    class BaseFitter;
    class ParticleFitObject;
    class TextTracer;

    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_prefix;            
      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_fixUnmeasuredPhotonToHER;   
      bool m_fixUnmeasuredPhotonToLER;   
      bool m_add3CPhoton;                
      bool m_liftPhotonTheta;            
      bool m_updateMother;               
      bool m_updateDaughters;            
      double m_recoilMass;               
      double m_invMass;                  
      std::vector<int> m_listAlternateMassHypo;  
      std::vector<bool> m_listDirectionOnlyParticles;  
 
      // 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; 
 
      std::string m_decayStringForDirectionOnlyParticles;         
      DecayDescriptor m_decaydescriptorForDirectionOnlyParticles; 
 
      std::string m_decayStringForAlternateMassParticles;         
      DecayDescriptor m_decaydescriptorForAlternateMassParticles; 
 
      std::string m_decayStringForNeutronVsAntiNeutron;         
      DecayDescriptor m_decaydescriptorForNeutronVsAntiNeutron; 

      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, bool useOnlyDirection, int massHypoPDG);

      void addFitObjectToConstraints(ParticleFitObject& fitobject);

      void addConstraintsToFitter(BaseFitter& fitter);

      void addTracerToFitter(BaseFitter& fitter);

      void setConstraints();

      ROOT::Math::PxPyPzEVector getLorentzVectorConstraints();
 

      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& fitSuffix, BaseFitter& fitter, std::vector<Particle*>& particleChildren,
                                    Particle* mother);
 

      CLHEP::HepSymMatrix getCLHEPMomentumErrorMatrix(Particle* particle);

      CLHEP::HepSymMatrix getCLHEPMomentumVertexErrorMatrix(Particle* particle);

      CLHEP::HepLorentzVector getCLHEPLorentzVector(Particle* particle);

      ROOT::Math::PxPyPzEVector getLorentzVector(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