MeasurementAdder.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 <tracking/trackFitting/measurementCreator/adder/MeasurementAdder.h>
 
#include <tracking/trackFitting/measurementCreator/factories/CDCMeasurementCreatorFactory.h>
#include <tracking/trackFitting/measurementCreator/factories/SVDMeasurementCreatorFactory.h>
#include <tracking/trackFitting/measurementCreator/factories/PXDMeasurementCreatorFactory.h>
#include <tracking/trackFitting/measurementCreator/factories/BKLMMeasurementCreatorFactory.h>
#include <tracking/trackFitting/measurementCreator/factories/EKLMMeasurementCreatorFactory.h>
#include <tracking/trackFitting/measurementCreator/factories/AdditionalMeasurementCreatorFactory.h>
 
#include <genfit/MeasurementFactory.h>
#include <string>
#include <map>
 
 
namespace genfit {
  class AbsMeasurement;
}
 
 
namespace Belle2 {
 
  class RecoTrack;

  class MeasurementAdder {
  public:
    MeasurementAdder(const std::string& storeArrayNameOfPXDHits,
                     const std::string& storeArrayNameOfSVDHits,
                     const std::string& storeArrayNameOfCDCHits,
                     const std::string& storeArrayNameOfBKLMHits,
                     const std::string& storeArrayNameOfEKLMHits,
                     const bool initializeCDCTranslators = true,
                     bool fromTrackCreator = false);

    void resetMeasurementCreatorsToDefaultSettings();

    void resetMeasurementCreators(
      const std::vector<std::shared_ptr<PXDBaseMeasurementCreator>>& pxdMeasurementCreators,
      const std::vector<std::shared_ptr<SVDBaseMeasurementCreator>>& svdMeasurementCreators,
      const std::vector<std::shared_ptr<CDCBaseMeasurementCreator>>& cdcMeasurementCreators,
      const std::vector<std::shared_ptr<BKLMBaseMeasurementCreator>>& bklmMeasurementCreators,
      const std::vector<std::shared_ptr<EKLMBaseMeasurementCreator>>& eklmMeasurementCreators,
      const std::vector<std::shared_ptr<BaseMeasurementCreator>>& additionalMeasurementCreators);

    void resetMeasurementCreatorsUsingFactories(
      const std::map<std::string, std::map<std::string, std::string>>& pxdMeasurementCreators,
      const std::map<std::string, std::map<std::string, std::string>>& svdMeasurementCreators,
      const std::map<std::string, std::map<std::string, std::string>>& cdcMeasurementCreators,
      const std::map<std::string, std::map<std::string, std::string>>& bklmMeasurementCreators,
      const std::map<std::string, std::map<std::string, std::string>>& eklmMeasurementCreators,
      const std::map<std::string, std::map<std::string, std::string>>& additionalMeasurementCreators);

    bool addMeasurements(RecoTrack& recoTrack) const;
 
  private:
    std::string m_param_storeArrayNameOfPXDHits = "";
    std::string m_param_storeArrayNameOfSVDHits = "";
    std::string m_param_storeArrayNameOfCDCHits = "";
    std::string m_param_storeArrayNameOfBKLMHits = "";
    std::string m_param_storeArrayNameOfEKLMHits = "";
    bool m_skipDirtyCheck = false;

    std::vector<std::shared_ptr<PXDBaseMeasurementCreator>> m_pxdMeasurementCreators;
    std::vector<std::shared_ptr<SVDBaseMeasurementCreator>> m_svdMeasurementCreators;
    std::vector<std::shared_ptr<CDCBaseMeasurementCreator>> m_cdcMeasurementCreators;
    std::vector<std::shared_ptr<BKLMBaseMeasurementCreator>> m_bklmMeasurementCreators;
    std::vector<std::shared_ptr<EKLMBaseMeasurementCreator>> m_eklmMeasurementCreators;
    std::vector<std::shared_ptr<BaseMeasurementCreator>> m_additionalMeasurementCreators;

    genfit::MeasurementFactory<genfit::AbsMeasurement> m_genfitMeasurementFactory;

    void createGenfitMeasurementFactory();

    template <class HitType, Const::EDetector detector>
    void addMeasurementsFromHitToRecoTrack(RecoTrack& recoTrack, RecoHitInformation& recoHitInformation, HitType* hit,
                                           const std::vector<std::shared_ptr<BaseMeasurementCreatorFromHit<HitType, detector>>>& measurementCreators,
                                           std::map<genfit::TrackPoint*, RecoHitInformation*>& trackPointHitMapping) const
    {
      if (not recoHitInformation.useInFit()) {
        return;
      }
 
      genfit::Track& genfitTrack = RecoTrackGenfitAccess::getGenfitTrack(recoTrack);
 
      for (const auto& measurementCreator : measurementCreators) {
        const std::vector<genfit::TrackPoint*>& trackPoints = measurementCreator->createMeasurementPoints(hit, recoTrack,
                                                              recoHitInformation);
        for (genfit::TrackPoint* trackPoint : trackPoints) {
          genfitTrack.insertPoint(trackPoint);
          // FIXME: hotfix: to get a correct mapping between reco hit information and the track point.
          // We are not able to store the TrackPoint in the RecoHitInformation directly because of problems in streaming
          // the genfit::TrackPoint. So what we do is store the index of the track points in the vector of the genfit::Track.
          // As this vector is sorted after this function, we can not set it here directly.
          trackPointHitMapping[trackPoint] = &recoHitInformation;
        }
      }
    }

    void addMeasurementsToRecoTrack(RecoTrack& recoTrack,
                                    const std::vector<std::shared_ptr<BaseMeasurementCreator>>& measurementCreators) const;
  };

}