CDCDedxPIDCreatorModule.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 <framework/logging/Logger.h>
#include <framework/datastore/StoreArray.h>
#include <mdst/dataobjects/Track.h>
#include <mdst/dataobjects/MCParticle.h>
#include <mdst/dataobjects/EventLevelTriggerTimeInfo.h>
#include <cdc/dataobjects/CDCDedxHit.h>
#include <cdc/dataobjects/CDCDedxTrack.h>
#include <cdc/dataobjects/CDCDedxLikelihood.h>
 
#include <framework/database/DBObjPtr.h>
#include <cdc/dbobjects/CDCDedxScaleFactor.h>
#include <cdc/dbobjects/CDCDedxWireGain.h>
#include <cdc/dbobjects/CDCDedxRunGain.h>
#include <cdc/dbobjects/CDCDedxCosineCor.h>
#include <cdc/dbobjects/CDCDedx2DCell.h>
#include <cdc/dbobjects/CDCDedx1DCell.h>
#include <cdc/dbobjects/CDCDedxADCNonLinearity.h>
#include <cdc/dbobjects/CDCDedxCosineEdge.h>
#include <cdc/dbobjects/CDCDedxMeanPars.h>
#include <cdc/dbobjects/CDCDedxSigmaPars.h>
#include <cdc/dbobjects/CDCDedxHadronCor.h>
#include <cdc/dbobjects/CDCDedxInjectionTime.h>
 
namespace Belle2 {

  class CDCDedxPIDCreatorModule : public Module {
 
  public:

    CDCDedxPIDCreatorModule();

    virtual ~CDCDedxPIDCreatorModule();

    virtual void initialize() override;

    virtual void event() override;
 
  private:

    struct DEDX {
      const CDCDedxHit* hit = nullptr; 
      int cWire = -1; 
      int cLayer = -1; 
      double dx = 0; 
      double dE = 0; 
      int nhits = 0; 
      double dxMax = 0; 

      void add(const CDCDedxHit& hit_in, int cWire_in, int cLayer_in, double dx_in, double dE_in)
      {
        if (not hit) {
          hit = &hit_in;
          cWire = cWire_in;
          cLayer = cLayer_in;
          dx = dx_in;
          dE = dE_in;
          nhits = 1;
          dxMax = dx;
        } else if (hit_in.getWireID() == hit->getWireID()) {
          dx += dx_in;
          if (hit->getADCCount() != hit_in.getADCCount()) dE += dE_in; // these hits are not piled-up
          nhits++;
          if (dx_in > dxMax) dxMax = dx_in;
        } else {
          B2ERROR("DEDX helper: measurements on different wires cannot be merged");
        }
      }

      void add(const DEDX& dedx)
      {
        if (cLayer < 0) {
          cWire = dedx.cWire;
          cLayer = dedx.cLayer;
          dx = dedx.dx;
          dE = dedx.dE;
          nhits = dedx.nhits;
          dxMax = dedx.dxMax;
        } else if (dedx.cLayer == cLayer) {
          dx += dedx.dx;
          dE += dedx.dE;
          nhits += dedx.nhits;
          if (dedx.dxMax > dxMax) {
            dxMax = dedx.dxMax;
            cWire = dedx.cWire; // wire ID with longest hit
          }
        } else {
          B2ERROR("DEDX helper: measurements in different layers cannot be merged");
        }
      }
    };
 
    // module steering parameters
    double m_removeLowest; 
    double m_removeHighest; 
    bool m_useBackHalfCurlers; 
    bool m_trackLevel; 
    bool m_enableDebugOutput; 
    std::string m_likelihoodsName; 
    std::string m_dedxTracksName; 
 
    // collections
    StoreArray<Track> m_tracks; 
    StoreArray<CDCDedxHit> m_hits; 
    StoreArray<MCParticle> m_mcParticles; 
    StoreObjPtr<EventLevelTriggerTimeInfo> m_TTDInfo; 
    StoreArray<CDCDedxLikelihood> m_likelihoods; 
    StoreArray<CDCDedxTrack> m_dedxTracks; 
 
    // parameters: calibration constants
    DBObjPtr<CDCDedxScaleFactor> m_DBScaleFactor; 
    DBObjPtr<CDCDedxRunGain> m_DBRunGain; 
    DBObjPtr<CDCDedxInjectionTime> m_DBInjectTime; 
    DBObjPtr<CDCDedxCosineCor> m_DBCosineCor; 
    DBObjPtr<CDCDedxCosineEdge> m_DBCosEdgeCor; 
    DBObjPtr<CDCDedxWireGain> m_DBWireGains; 
    DBObjPtr<CDCDedx2DCell> m_DB2DCell; 
    DBObjPtr<CDCDedx1DCell> m_DB1DCell; 
    DBObjPtr<CDCDedxADCNonLinearity> m_DBNonlADC; 
 
    // parameters to determine the predicted means and resolutions, and hadron correction
    DBObjPtr<CDCDedxMeanPars> m_DBMeanPars; 
    DBObjPtr<CDCDedxSigmaPars> m_DBSigmaPars; 
    DBObjPtr<CDCDedxHadronCor> m_DBHadronCor; 
 
    // other
    int m_nLayerWires[9] = {0}; 
    int m_warnCount = 0; 
 
  };

} // Belle2 namespace