B2BIIConvertMdstModule.h

//+
// File : PantherInputModule.h
// Description : A module to read Panther record in basf2
//
// Author : Ryosuke Itoh, IPNS, KEK
// Date : 16 - Feb - 2015
//
// Contirbutors: Anze Zupanc, Matic Lubej,
//-
 
#ifndef B2BII_CONVERT_MDST_H
#define B2BII_CONVERT_MDST_H
 
#include <framework/core/Module.h>
 
#define BELLE_TARGET_H "belle-x86_64-unknown-linux-gnu-g++.h"
#include "belle_legacy/panther/panther.h"
#include "belle_legacy/panther/panther_group.h"
 
// Belle objects (Panther tables)
#include "belle_legacy/tables/belletdf.h"
#include "belle_legacy/tables/mdst.h"
 
#include "belle_legacy/helix/Helix.h"
 
// Belle2 objects
#include <mdst/dataobjects/V0.h>
#include <mdst/dataobjects/ECLCluster.h>
#include <mdst/dataobjects/KLMCluster.h>
#include <analysis/dataobjects/Particle.h>
#include <analysis/dataobjects/ParticleList.h>
#include <mdst/dataobjects/MCParticle.h>
#include <mdst/dataobjects/MCParticleGraph.h>
#include <mdst/dataobjects/Track.h>
#include <mdst/dataobjects/PIDLikelihood.h>
#include <analysis/dataobjects/EventExtraInfo.h>
#include <b2bii/dataobjects/BelleTrkExtra.h>
 
// Replace BeamParameters
#include <mdst/dbobjects/BeamSpot.h>
#include <mdst/dbobjects/CollisionBoostVector.h>
#include <mdst/dbobjects/CollisionInvariantMass.h>
 
#include <framework/datastore/StoreArray.h>
#include <framework/database/DBObjPtr.h>
#include <framework/gearbox/Const.h>
 
#include "CLHEP/Vector/ThreeVector.h"
#include "CLHEP/Vector/LorentzVector.h"
#include "CLHEP/Matrix/SymMatrix.h"
#include "CLHEP/Geometry/Point3D.h"
 
typedef HepGeom::Point3D<double> HepPoint3D;
 
#include <string>
#include <map>
 
//enable ACC conversion (needs externals >= v00-06-01)
#define HAVE_KID_ACC
 
//enable EID conversion (needs externals > v00-07-01)
#define HAVE_EID
 
// enable findKs (needs externals > v00-07-01)
#define HAVE_FINDKS
 
// enable nisKsFinder (needs externals > v00-07-01)
#define HAVE_NISKSFINDER
 
// enable goodLambda (needs externals >= v01-08-00)
#define HAVE_GOODLAMBDA
 
namespace Belle2 {
  class B2BIIConvertMdstModule : public Module {
 
    enum MCMatchingMode {
 
      c_Direct,
 
      c_GeneratorLevel,
 
    };
 
    // Public functions
  public:
 
    B2BIIConvertMdstModule();
    virtual ~B2BIIConvertMdstModule() override;
 
    virtual void initialize() override;
 
    virtual void beginRun() override; 
    virtual void event() override; 
    virtual void endRun() override; 
    virtual void terminate() override; 
    // Data members
  private:
 
    void initializeDataStore();
 
    // true = real data
    // false = mc
    bool m_realData;
 
    bool m_convertBeamParameters;
 
    // true = use 6x6 (position, momentum) covariance matrix
    // false = use 5x5 (helix parameters) covariance matrix
    bool m_use6x6CovarianceMatrix4Tracks;
 
    std::string m_mcMatchingModeString;
 
    MCMatchingMode m_mcMatchingMode;
 
    bool m_convertEvtcls; 
    bool m_nisEnable; 
    bool m_convertRecTrg; 
    bool m_convertTrkExtra; 
    double m_matchType2E9oE25Threshold;
 
    int m_lastIPProfileBin{ -1};
 
    //-----------------------------------------------------------------------------
    // CONVERT TABLES
    //-----------------------------------------------------------------------------
 
    void convertRecTrgTable();
 
    void convertEvtclsTable();
 
    void convertGenHepEvtTable();
 
    void convertMdstECLTable();
 
    void convertMdstKLMTable();
 
    void convertMdstChargedTable();
 
    void convertMdstGammaTable();
 
    void convertMdstKLongTable();
 
    void convertMdstPi0Table();
 
    void convertMdstVee2Table();
 
    void convertBeamEnergy();
 
    void convertIPProfile(bool beginRun = false);
 
    //-----------------------------------------------------------------------------
    // CONVERT OBJECTS
    //-----------------------------------------------------------------------------
 
    void convertGenHepevtObject(const Belle::Gen_hepevt& genHepevt, MCParticleGraph::GraphParticle* mcParticle);
 
    void convertMdstECLObject(const Belle::Mdst_ecl& ecl, const Belle::Mdst_ecl_aux& eclAux, ECLCluster* eclCluster);
 
    void convertMdstKLMObject(const Belle::Mdst_klm_cluster& klm, KLMCluster* klmCluster);
 
    void convertMdstChargedObject(const Belle::Mdst_charged& belleTrack, Track* track);
 
    TrackFitResult createTrackFitResult(const CLHEP::HepLorentzVector& momentum,
                                        const HepPoint3D&              position,
                                        const CLHEP::HepSymMatrix&     error,
                                        const short int charge,
                                        const Const::ParticleType& pType,
                                        const float pValue,
                                        const uint64_t hitPatternCDCInitializer,
                                        const uint32_t hitPatternVXDInitializer,
                                        const uint16_t ndf);
 
    int getHelixParameters(const Belle::Mdst_trk_fit& trk_fit,
                           const double mass,
                           const HepPoint3D& newPivot,
                           std::vector<float>& helixParams,
                           CLHEP::HepSymMatrix& error5x5,
                           CLHEP::HepLorentzVector& momentum,
                           HepPoint3D& position,
                           CLHEP::HepSymMatrix& error7x7,
                           const double dPhi = 0.0);
 
    void convertHelix(Belle::Helix& helix, std::vector<float>& helixParams, CLHEP::HepSymMatrix& error5x5);
 
    void convertHelix(const Belle::Mdst_trk_fit& trk_fit, const HepPoint3D& newPivot, std::vector<float>& helixParams,
                      std::vector<float>& helixError);
 
    int belleHelixToCartesian(const Belle::Mdst_trk_fit& trk_fit, const double mass, const HepPoint3D& newPivot,
                              CLHEP::HepLorentzVector& momentum, HepPoint3D& position, CLHEP::HepSymMatrix& error, double dPhi = 0.0);
 
    void belleHelixToHelix(const Belle::Mdst_trk_fit& trk_fit,
                           std::vector<float>& helixParam, std::vector<float>& helixError);
 
    void belleVeeDaughterToCartesian(const Belle::Mdst_vee2& vee, const int charge, const Const::ParticleType& pType,
                                     CLHEP::HepLorentzVector& momentum, HepPoint3D& position, CLHEP::HepSymMatrix& error);
 
    void belleVeeDaughterHelix(const Belle::Mdst_vee2& vee, const int charge, std::vector<float>& helixParam,
                               std::vector<float>& helixError);
 
    void convertPIDData(const Belle::Mdst_charged& belleTrack, const Track* track);
 
    const static int c_nHyp = 5;
    const static Const::ChargedStable c_belleHyp_to_chargedStable[c_nHyp];
 
    void setLikelihoods(PIDLikelihood* pid, Const::EDetector det, double likelihoods[c_nHyp], bool discard_allzero = false);
 
#ifdef HAVE_KID_ACC
 
    static double acc_pid(const Belle::Mdst_charged& chg, int idp);
    double cdc_pid(const Belle::Mdst_charged& chg, int idp);
#endif
 
    double atcPID(const PIDLikelihood* pid, int sigHyp, int bkgHyp);
 
    //-----------------------------------------------------------------------------
    // RELATIONS
    //-----------------------------------------------------------------------------
 
    void setTracksToECLClustersRelations();
 
    void setKLMClustersRelations();
 
    //-----------------------------------------------------------------------------
    // MISC
    //-----------------------------------------------------------------------------
 
    int recoverMoreThan24bitIDHEP(int id);
 
    void testMCRelation(const Belle::Gen_hepevt& belleMC, const MCParticle* mcP, const std::string& objectName);
 
    Belle2::MCParticleGraph m_particleGraph;
 
    std::map<int, int> genHepevtToMCParticle;
    std::map<int, int> mdstEclToECLCluster;
    std::map<int, int> mdstGammaToParticle;
    std::map<int, int> mdstKlmToKLMCluster;
    std::map<int, int> mdstKlongToParticle;
 
    StoreArray<MCParticle> m_mcParticles;
 
    StoreArray<ECLCluster> m_eclClusters;
 
    StoreArray<KLMCluster> m_klmClusters;
 
    StoreArray<Track> m_tracks;
 
    StoreArray<TrackFitResult> m_trackFitResults;
 
    StoreArray<V0> m_v0s;
 
    StoreArray<Particle> m_particles;
 
    StoreArray<BelleTrkExtra> m_belleTrkExtra;
 
    StoreArray<PIDLikelihood> m_pidLikelihoods;
 
    StoreObjPtr<EventExtraInfo> m_evtInfo;
 
    OptionalDBObjPtr<BeamSpot> m_beamSpotDB;
    BeamSpot m_beamSpot; 
    OptionalDBObjPtr<CollisionBoostVector> m_collisionBoostVectorDB;
    CollisionBoostVector m_collisionBoostVector; 
    OptionalDBObjPtr<CollisionInvariantMass> m_collisionInvMDB;
    CollisionInvariantMass m_collisionInvM; 
    const int ERRMCONV[7] = {3, 4, 5, -1, 0, 1, 2};
 
    const double BFIELD = 1.5;
 
    const double KAPPA2OMEGA = 1.5 * TMath::C() * 1E-11;
 
  };
 
} // end namespace Belle2
 
#endif