B2BIIConvertMdstModule.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>
 
#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 <framework/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 <mdst/dbobjects/CollisionAxisCMS.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_evtgenProcessing; 
 
    bool m_convertEvtcls; 
 
    bool m_nisEnable; 
 
    bool m_convertRecTrg; 
 
    bool m_convertTrkExtra; 
 
    bool m_convertNbar; 
    double m_matchType2E9oE25Threshold;

    int m_lastIPProfileBin{ -1};
 
    //-----------------------------------------------------------------------------
    // CONVERT TABLES
    //-----------------------------------------------------------------------------

    void convertRecTrgTable();

    void convertEvtclsTable();

    void convertGenHepEvtTable();

    void convertMdstECLTable();

    void convertMdstKLMTable();

    void convertMdstChargedTable();

    void convertMdstGammaTable();

    void copyNbarFromGamma();

    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);

    double computeTrkMinDistanceBelle(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);

    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; 

    OptionalDBObjPtr<CollisionAxisCMS> m_collisionAxisCMSDB;
    CollisionAxisCMS m_collisionAxisCMS; 

    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