#include <RecoTracker/DeDxDiscriminatorLearner/src/DeDxDiscriminatorLearner.cc>

Inheritance diagram for DeDxDiscriminatorLearner:

Public Member Functions
	DeDxDiscriminatorLearner (const edm::ParameterSet &)

	~DeDxDiscriminatorLearner () override

Public Member Functions inherited from ConditionDBWriter< PhysicsTools::Calibration::HistogramD3D >
	ConditionDBWriter (const edm::ParameterSet &iConfig)

	~ConditionDBWriter () override

Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

	~EDAnalyzer () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase &	operator= (EDConsumerBase &&)=default

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	algoAnalyze (const edm::Event &, const edm::EventSetup &) override

void	algoAnalyzeTheTree (const edm::EventSetup &iSetup)

void	algoBeginJob (const edm::EventSetup &) override

void	algoEndJob () override

std::unique_ptr< PhysicsTools::Calibration::HistogramD3D >	getNewObject () override

void	processHit (const TrackingRecHit *recHit, float trackMomentum, float &cosine, const TrajectoryStateOnSurface &trajState)

Private Attributes
std::string	algoMode

std::vector< std::vector< float > >	calibGains

float	Charge_Max

float	Charge_Min

int	Charge_NBins

TH3F *	Charge_Vs_Path

std::string	HistoFile

std::string	m_calibrationPath

unsigned int	m_off

edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	m_tkGeomToken

edm::EDGetTokenT< reco::TrackCollection >	m_tracksTag

edm::EDGetTokenT< TrajTrackAssociationCollection >	m_trajTrackAssociationTag

unsigned int	MaxNrStrips

float	MaxTrackChiOverNdf

float	MaxTrackEta

float	MaxTrackMomentum

float	MinTrackEta

unsigned int	MinTrackHits

float	MinTrackMomentum

float	P_Max

float	P_Min

int	P_NBins

float	Path_Max

float	Path_Min

int	Path_NBins

bool	shapetest

bool	useCalibration

std::vector< std::string >	VInputFiles

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsInputProcessBlocks ()

static bool	wantsProcessBlocks ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from ConditionDBWriter< PhysicsTools::Calibration::HistogramD3D >
void	setDoStore (const bool doStore)
	When set to false the payload will not be written to the db. More...

void	storeOnDbNow ()

cond::Time_t	timeOfLastIOV ()

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

Description: <one line="" class="" summary>="">

Implementation: <Notes on="" implementation>="">

Definition at line 23 of file DeDxDiscriminatorLearner.h.

Constructor & Destructor Documentation

◆ DeDxDiscriminatorLearner()

DeDxDiscriminatorLearner::DeDxDiscriminatorLearner ( const edm::ParameterSet & iConfig )

explicit

Definition at line 34 of file DeDxDiscriminatorLearner.cc.

     : ConditionDBWriter<PhysicsTools::Calibration::HistogramD3D>(iConfig) {
   m_tracksTag = consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("tracks"));
   m_trajTrackAssociationTag =
       consumes<TrajTrackAssociationCollection>(iConfig.getParameter<edm::InputTag>("trajectoryTrackAssociation"));
   m_tkGeomToken = esConsumes<edm::Transition::BeginRun>();
  
   P_Min = iConfig.getParameter<double>("P_Min");
   P_Max = iConfig.getParameter<double>("P_Max");
   P_NBins = iConfig.getParameter<int>("P_NBins");
   Path_Min = iConfig.getParameter<double>("Path_Min");
   Path_Max = iConfig.getParameter<double>("Path_Max");
   Path_NBins = iConfig.getParameter<int>("Path_NBins");
   Charge_Min = iConfig.getParameter<double>("Charge_Min");
   Charge_Max = iConfig.getParameter<double>("Charge_Max");
   Charge_NBins = iConfig.getParameter<int>("Charge_NBins");
  
   MinTrackMomentum = iConfig.getUntrackedParameter<double>("minTrackMomentum", 5.0);
   MaxTrackMomentum = iConfig.getUntrackedParameter<double>("maxTrackMomentum", 99999.0);
   MinTrackEta = iConfig.getUntrackedParameter<double>("minTrackEta", -5.0);
   MaxTrackEta = iConfig.getUntrackedParameter<double>("maxTrackEta", 5.0);
   MaxNrStrips = iConfig.getUntrackedParameter<unsigned>("maxNrStrips", 255);
   MinTrackHits = iConfig.getUntrackedParameter<unsigned>("MinTrackHits", 4);
  
   algoMode = iConfig.getUntrackedParameter<string>("AlgoMode", "SingleJob");
   HistoFile = iConfig.getUntrackedParameter<string>("HistoFile", "out.root");
   VInputFiles = iConfig.getUntrackedParameter<vector<string> >("InputFiles");
  
   shapetest = iConfig.getParameter<bool>("ShapeTest");
   useCalibration = iConfig.getUntrackedParameter<bool>("UseCalibration");
   m_calibrationPath = iConfig.getUntrackedParameter<string>("calibrationPath");
 }

References algoMode, Charge_Max, Charge_Min, Charge_NBins, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), HistoFile, m_calibrationPath, m_tkGeomToken, m_tracksTag, m_trajTrackAssociationTag, MaxNrStrips, MaxTrackEta, MaxTrackMomentum, MinTrackEta, MinTrackHits, MinTrackMomentum, P_Max, P_Min, P_NBins, Path_Max, Path_Min, Path_NBins, shapetest, useCalibration, and VInputFiles.

◆ ~DeDxDiscriminatorLearner()

DeDxDiscriminatorLearner::~DeDxDiscriminatorLearner ( )

override

Definition at line 67 of file DeDxDiscriminatorLearner.cc.

67 {}

Member Function Documentation

◆ algoAnalyze()

void DeDxDiscriminatorLearner::algoAnalyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivatevirtual

Reimplemented from ConditionDBWriter< PhysicsTools::Calibration::HistogramD3D >.

Definition at line 120 of file DeDxDiscriminatorLearner.cc.

                                                                                               {
   Handle<TrajTrackAssociationCollection> trajTrackAssociationHandle;
   iEvent.getByToken(m_trajTrackAssociationTag, trajTrackAssociationHandle);
  
   edm::Handle<reco::TrackCollection> trackCollectionHandle;
   iEvent.getByToken(m_tracksTag, trackCollectionHandle);
  
   unsigned track_index = 0;
   for (TrajTrackAssociationCollection::const_iterator it = trajTrackAssociationHandle->begin();
        it != trajTrackAssociationHandle->end();
        ++it, track_index++) {
     const Track& track = *it->val;
     const Trajectory& traj = *it->key;
  
     if (track.eta() < MinTrackEta || track.eta() > MaxTrackEta) {
       continue;
     }
     if (track.pt() < MinTrackMomentum || track.pt() > MaxTrackMomentum) {
       continue;
     }
     if (track.found() < MinTrackHits) {
       continue;
     }
  
     const vector<TrajectoryMeasurement>& measurements = traj.measurements();
     for (vector<TrajectoryMeasurement>::const_iterator it = measurements.begin(); it != measurements.end(); it++) {
       TrajectoryStateOnSurface trajState = it->updatedState();
       if (!trajState.isValid())
         continue;
  
       const TrackingRecHit* recHit = (*it->recHit()).hit();
       if (!recHit || !recHit->isValid())
         continue;
       LocalVector trackDirection = trajState.localDirection();
       float cosine = trackDirection.z() / trackDirection.mag();
  
       processHit(recHit, trajState.localMomentum().mag(), cosine, trajState);
     }
   }
 }

References edm::AssociationMap< Tag >::begin(), edm::AssociationMap< edm::OneToOne< std::vector< Trajectory >, reco::TrackCollection, unsigned short > >::const_iterator, edm::AssociationMap< Tag >::end(), iEvent, TrajectoryStateOnSurface::isValid(), TrajectoryStateOnSurface::localDirection(), TrajectoryStateOnSurface::localMomentum(), m_tracksTag, m_trajTrackAssociationTag, PV3DBase< T, PVType, FrameType >::mag(), MaxTrackEta, MaxTrackMomentum, Trajectory::measurements(), MinTrackEta, MinTrackHits, MinTrackMomentum, processHit(), rpcPointValidation_cfi::recHit, HLT_FULL_cff::track, and PV3DBase< T, PVType, FrameType >::z().

◆ algoAnalyzeTheTree()

void DeDxDiscriminatorLearner::algoAnalyzeTheTree ( const edm::EventSetup & iSetup )

private

Definition at line 239 of file DeDxDiscriminatorLearner.cc.

                                                                              {
   const auto& tkGeom = iSetup.getData(m_tkGeomToken);
  
   unsigned int NEvent = 0;
   for (unsigned int i = 0; i < VInputFiles.size(); i++) {
     printf("Openning file %3i/%3i --> %s\n", i + 1, (int)VInputFiles.size(), (char*)(VInputFiles[i].c_str()));
     fflush(stdout);
     TChain* tree = new TChain("gainCalibrationTree/tree");
     tree->Add(VInputFiles[i].c_str());
  
     TString EventPrefix("");
     TString EventSuffix("");
  
     TString TrackPrefix("track");
     TString TrackSuffix("");
  
     TString CalibPrefix("GainCalibration");
     TString CalibSuffix("");
  
     unsigned int eventnumber = 0;
     tree->SetBranchAddress(EventPrefix + "event" + EventSuffix, &eventnumber, nullptr);
     unsigned int runnumber = 0;
     tree->SetBranchAddress(EventPrefix + "run" + EventSuffix, &runnumber, nullptr);
     std::vector<bool>* TrigTech = nullptr;
     tree->SetBranchAddress(EventPrefix + "TrigTech" + EventSuffix, &TrigTech, nullptr);
  
     std::vector<double>* trackchi2ndof = nullptr;
     tree->SetBranchAddress(TrackPrefix + "chi2ndof" + TrackSuffix, &trackchi2ndof, nullptr);
     std::vector<float>* trackp = nullptr;
     tree->SetBranchAddress(TrackPrefix + "momentum" + TrackSuffix, &trackp, nullptr);
     std::vector<float>* trackpt = nullptr;
     tree->SetBranchAddress(TrackPrefix + "pt" + TrackSuffix, &trackpt, nullptr);
     std::vector<double>* tracketa = nullptr;
     tree->SetBranchAddress(TrackPrefix + "eta" + TrackSuffix, &tracketa, nullptr);
     std::vector<double>* trackphi = nullptr;
     tree->SetBranchAddress(TrackPrefix + "phi" + TrackSuffix, &trackphi, nullptr);
     std::vector<unsigned int>* trackhitsvalid = nullptr;
     tree->SetBranchAddress(TrackPrefix + "hitsvalid" + TrackSuffix, &trackhitsvalid, nullptr);
  
     std::vector<int>* trackindex = nullptr;
     tree->SetBranchAddress(CalibPrefix + "trackindex" + CalibSuffix, &trackindex, nullptr);
     std::vector<unsigned int>* rawid = nullptr;
     tree->SetBranchAddress(CalibPrefix + "rawid" + CalibSuffix, &rawid, nullptr);
     std::vector<unsigned short>* firststrip = nullptr;
     tree->SetBranchAddress(CalibPrefix + "firststrip" + CalibSuffix, &firststrip, nullptr);
     std::vector<unsigned short>* nstrips = nullptr;
     tree->SetBranchAddress(CalibPrefix + "nstrips" + CalibSuffix, &nstrips, nullptr);
     std::vector<unsigned int>* charge = nullptr;
     tree->SetBranchAddress(CalibPrefix + "charge" + CalibSuffix, &charge, nullptr);
     std::vector<float>* path = nullptr;
     tree->SetBranchAddress(CalibPrefix + "path" + CalibSuffix, &path, nullptr);
     std::vector<unsigned char>* amplitude = nullptr;
     tree->SetBranchAddress(CalibPrefix + "amplitude" + CalibSuffix, &amplitude, nullptr);
     std::vector<double>* gainused = nullptr;
     tree->SetBranchAddress(CalibPrefix + "gainused" + CalibSuffix, &gainused, nullptr);
  
     printf("Number of Events = %i + %i = %i\n",
            NEvent,
            (unsigned int)tree->GetEntries(),
            (unsigned int)(NEvent + tree->GetEntries()));
     NEvent += tree->GetEntries();
     printf("Progressing Bar              :0%%       20%%       40%%       60%%       80%%       100%%\n");
     printf("Looping on the Tree          :");
     int TreeStep = tree->GetEntries() / 50;
     if (TreeStep <= 1)
       TreeStep = 1;
     for (unsigned int ientry = 0; ientry < tree->GetEntries(); ientry++) {
       if (ientry % TreeStep == 0) {
         printf(".");
         fflush(stdout);
       }
       tree->GetEntry(ientry);
  
       int FirstAmplitude = 0;
       for (unsigned int c = 0; c < (*path).size(); c++) {
         FirstAmplitude += (*nstrips)[c];
         int t = (*trackindex)[c];
         if ((*trackpt)[t] < 5)
           continue;
         if ((*trackhitsvalid)[t] < 5)
           continue;
  
         int Charge = 0;
         if (useCalibration) {
           auto& gains = calibGains[tkGeom.idToDetUnit(DetId((*rawid)[c]))->index() - m_off];
           auto& gain = gains[(*firststrip)[c] / 128];
           for (unsigned int s = 0; s < (*nstrips)[c]; s++) {
             int StripCharge = (*amplitude)[FirstAmplitude - (*nstrips)[c] + s];
             if (StripCharge < 254) {
               StripCharge = (int)(StripCharge / gain);
               if (StripCharge >= 1024) {
                 StripCharge = 255;
               } else if (StripCharge >= 254) {
                 StripCharge = 254;
               }
             }
             Charge += StripCharge;
           }
         } else {
           Charge = (*charge)[c];
         }
  
         //          printf("ChargeDifference = %i Vs %i with Gain = %f\n",(*charge)[c],Charge,Gains[(*rawid)[c]]);
         double ClusterChargeOverPath = ((double)Charge) / (*path)[c];
         Charge_Vs_Path->Fill((*trackp)[t], (*path)[c], ClusterChargeOverPath);
       }
     }
     printf("\n");
   }
 }

References CustomPhysics_cfi::amplitude, HltBtagPostValidation_cff::c, calibGains, ALCARECOTkAlJpsiMuMu_cff::charge, PixelTestBeamValidation_cfi::Charge, Charge_Vs_Path, PedestalClient_cfi::gain, edm::EventSetup::getData(), mps_fire::i, createfilelist::int, m_off, m_tkGeomToken, castor_dqm_sourceclient_file_cfg::path, cond::runnumber, alignCSCRings::s, mps_setup::stdout, submitPVValidationJobs::t, useCalibration, and VInputFiles.

Referenced by algoBeginJob().

◆ algoBeginJob()

void DeDxDiscriminatorLearner::algoBeginJob ( const edm::EventSetup & iSetup )

overrideprivatevirtual

Reimplemented from ConditionDBWriter< PhysicsTools::Calibration::HistogramD3D >.

Definition at line 71 of file DeDxDiscriminatorLearner.cc.

                                                                        {
   Charge_Vs_Path = new TH3F("Charge_Vs_Path",
                             "Charge_Vs_Path",
                             P_NBins,
                             P_Min,
                             P_Max,
                             Path_NBins,
                             Path_Min,
                             Path_Max,
                             Charge_NBins,
                             Charge_Min,
                             Charge_Max);
  
   if (useCalibration && calibGains.empty()) {
     const auto& tkGeom = iSetup.getData(m_tkGeomToken);
  
     m_off = tkGeom.offsetDU(GeomDetEnumerators::PixelBarrel);  //index start at the first pixel
  
     DeDxTools::makeCalibrationMap(m_calibrationPath, tkGeom, calibGains, m_off);
   }
  
   //Read the calibTree if in calibTree mode
   if (strcmp(algoMode.c_str(), "CalibTree") == 0)
     algoAnalyzeTheTree(iSetup);
 }

References algoAnalyzeTheTree(), algoMode, calibGains, Charge_Max, Charge_Min, Charge_NBins, Charge_Vs_Path, edm::EventSetup::getData(), m_calibrationPath, m_off, m_tkGeomToken, DeDxTools::makeCalibrationMap(), P_Max, P_Min, P_NBins, Path_Max, Path_Min, Path_NBins, GeomDetEnumerators::PixelBarrel, and useCalibration.

◆ algoEndJob()

void DeDxDiscriminatorLearner::algoEndJob ( )

overrideprivatevirtual

Reimplemented from ConditionDBWriter< PhysicsTools::Calibration::HistogramD3D >.

Definition at line 99 of file DeDxDiscriminatorLearner.cc.

                                           {
   if (strcmp(algoMode.c_str(), "MultiJob") == 0) {
     TFile* Output = new TFile(HistoFile.c_str(), "RECREATE");
     Charge_Vs_Path->Write();
     Output->Write();
     Output->Close();
   } else if (strcmp(algoMode.c_str(), "WriteOnDB") == 0) {
     TFile* Input = new TFile(HistoFile.c_str());
     Charge_Vs_Path = (TH3F*)(Input->FindObjectAny("Charge_Vs_Path"))->Clone();
     Input->Close();
   } else if (strcmp(algoMode.c_str(), "CalibTree") == 0) {
     TFile* Output = new TFile(HistoFile.c_str(), "RECREATE");
     Charge_Vs_Path->Write();
     Output->Write();
     Output->Close();
     TFile* Input = new TFile(HistoFile.c_str());
     Charge_Vs_Path = (TH3F*)(Input->FindObjectAny("Charge_Vs_Path"))->Clone();
     Input->Close();
   }
 }

References algoMode, Charge_Vs_Path, HistoFile, TrackCandidateTopBottomHitFilter_cfi::Input, and GetRecoTauVFromDQM_MC_cff::Output.

◆ getNewObject()

std::unique_ptr< PhysicsTools::Calibration::HistogramD3D > DeDxDiscriminatorLearner::getNewObject ( )

overrideprivatevirtual

Implements ConditionDBWriter< PhysicsTools::Calibration::HistogramD3D >.

Definition at line 350 of file DeDxDiscriminatorLearner.cc.

                                                                                           {
   auto obj = std::make_unique<PhysicsTools::Calibration::HistogramD3D>(Charge_Vs_Path->GetNbinsX(),
                                                                        Charge_Vs_Path->GetXaxis()->GetXmin(),
                                                                        Charge_Vs_Path->GetXaxis()->GetXmax(),
                                                                        Charge_Vs_Path->GetNbinsY(),
                                                                        Charge_Vs_Path->GetYaxis()->GetXmin(),
                                                                        Charge_Vs_Path->GetYaxis()->GetXmax(),
                                                                        Charge_Vs_Path->GetNbinsZ(),
                                                                        Charge_Vs_Path->GetZaxis()->GetXmin(),
                                                                        Charge_Vs_Path->GetZaxis()->GetXmax());
  
   for (int ix = 0; ix <= Charge_Vs_Path->GetNbinsX() + 1; ix++) {
     for (int iy = 0; iy <= Charge_Vs_Path->GetNbinsY() + 1; iy++) {
       for (int iz = 0; iz <= Charge_Vs_Path->GetNbinsZ() + 1; iz++) {
         obj->setBinContent(ix, iy, iz, Charge_Vs_Path->GetBinContent(ix, iy, iz));
         //          if(Charge_Vs_Path->GetBinContent(ix,iy)!=0)printf("%i %i %i --> %f\n",ix,iy, iz, Charge_Vs_Path->GetBinContent(ix,iy,iz));
       }
     }
   }
  
   return obj;
 }

References Charge_Vs_Path, and getGTfromDQMFile::obj.

◆ processHit()

void DeDxDiscriminatorLearner::processHit	(	const TrackingRecHit *	recHit,
		float	trackMomentum,
		float &	cosine,
		const TrajectoryStateOnSurface &	trajState
	)

private

Definition at line 161 of file DeDxDiscriminatorLearner.cc.

                                                                                      {
   auto const& thit = static_cast<BaseTrackerRecHit const&>(*recHit);
   if (!thit.isValid())
     return;
  
   auto const& clus = thit.firstClusterRef();
   if (!clus.isValid())
     return;
  
   int NSaturating = 0;
   if (clus.isPixel()) {
     return;
   } else if (clus.isStrip() && !thit.isMatched()) {
     auto& detUnit = *(recHit->detUnit());
     auto& cluster = clus.stripCluster();
     if (cluster.amplitudes().size() > MaxNrStrips) {
       return;
     }
     if (DeDxTools::IsSpanningOver2APV(cluster.firstStrip(), cluster.amplitudes().size())) {
       return;
     }
     if (!DeDxTools::IsFarFromBorder(trajState, &detUnit)) {
       return;
     }
     float pathLen = 10.0 * detUnit.surface().bounds().thickness() / fabs(cosine);
     float chargeAbs = DeDxTools::getCharge(&cluster, NSaturating, detUnit, calibGains, m_off);
     float charge = chargeAbs / pathLen;
     if (!shapetest || (shapetest && DeDxTools::shapeSelection(cluster))) {
       Charge_Vs_Path->Fill(trackMomentum, pathLen, charge);
     }
   } else if (clus.isStrip() && thit.isMatched()) {
     const SiStripMatchedRecHit2D* matchedHit = dynamic_cast<const SiStripMatchedRecHit2D*>(recHit);
     if (!matchedHit)
       return;
     const GluedGeomDet* gdet = static_cast<const GluedGeomDet*>(matchedHit->det());
  
     auto& detUnitM = *(gdet->monoDet());
     auto& clusterM = matchedHit->monoCluster();
     if (clusterM.amplitudes().size() > MaxNrStrips) {
       return;
     }
     if (DeDxTools::IsSpanningOver2APV(clusterM.firstStrip(), clusterM.amplitudes().size())) {
       return;
     }
     if (!DeDxTools::IsFarFromBorder(trajState, &detUnitM)) {
       return;
     }
     float pathLen = 10.0 * detUnitM.surface().bounds().thickness() / fabs(cosine);
     float chargeAbs = DeDxTools::getCharge(&clusterM, NSaturating, detUnitM, calibGains, m_off);
     float charge = chargeAbs / pathLen;
     if (!shapetest || (shapetest && DeDxTools::shapeSelection(clusterM))) {
       Charge_Vs_Path->Fill(trackMomentum, pathLen, charge);
     }
  
     auto& detUnitS = *(gdet->stereoDet());
     auto& clusterS = matchedHit->stereoCluster();
     if (clusterS.amplitudes().size() > MaxNrStrips) {
       return;
     }
     if (DeDxTools::IsSpanningOver2APV(clusterS.firstStrip(), clusterS.amplitudes().size())) {
       return;
     }
     if (!DeDxTools::IsFarFromBorder(trajState, &detUnitS)) {
       return;
     }
     pathLen = 10.0 * detUnitS.surface().bounds().thickness() / fabs(cosine);
     chargeAbs = DeDxTools::getCharge(&clusterS, NSaturating, detUnitS, calibGains, m_off);
     charge = chargeAbs / pathLen;
     if (!shapetest || (shapetest && DeDxTools::shapeSelection(clusterS))) {
       Charge_Vs_Path->Fill(trackMomentum, pathLen, charge);
     }
   }
 }