#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 const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (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 const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

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::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	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
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

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

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<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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

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

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, 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 ( const edm::ParameterSet & iConfig )

explicit

Definition at line 36 of file DeDxDiscriminatorLearner.cc.

References algoMode, Charge_Max, Charge_Min, Charge_NBins, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), HistoFile, m_calibrationPath, 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.

                                                                                  : ConditionDBWriter<PhysicsTools::Calibration::HistogramD3D>(iConfig)
 {
    m_tracksTag                 = consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("tracks"));
    m_trajTrackAssociationTag   = consumes<TrajTrackAssociationCollection>(iConfig.getParameter<edm::InputTag>("trajectoryTrackAssociation"));
 
    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");
 }

DeDxDiscriminatorLearner::~DeDxDiscriminatorLearner ( )

override

Definition at line 68 of file DeDxDiscriminatorLearner.cc.

68 {}

Member Function Documentation

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

overrideprivatevirtual

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

Definition at line 112 of file DeDxDiscriminatorLearner.cc.

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

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

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

private

Definition at line 202 of file DeDxDiscriminatorLearner.cc.

References CustomPhysics_cfi::amplitude, EnergyCorrector::c, calibGains, ALCARECOTkAlJpsiMuMu_cff::charge, Charge_Vs_Path, muonCSCDigis_cfi::gain, edm::EventSetup::get(), mps_fire::i, TrackerGeometry::idToDetUnit(), GeomDet::index(), createfilelist::int, m_off, callgraph::path, cond::runnumber, alignCSCRings::s, mps_setup::stdout, lumiQTWidget::t, useCalibration, and VInputFiles.

Referenced by algoBeginJob().

 {
    edm::ESHandle<TrackerGeometry> tkGeom;
    iSetup.get<TrackerDigiGeometryRecord>().get( tkGeom );
 
    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");
   }
 }

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

overrideprivatevirtual

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

Definition at line 72 of file DeDxDiscriminatorLearner.cc.

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

 {
    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()){
       edm::ESHandle<TrackerGeometry> tkGeom;
       iSetup.get<TrackerDigiGeometryRecord>().get( tkGeom );
       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);
 }

void DeDxDiscriminatorLearner::algoEndJob ( )

overrideprivatevirtual

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

Definition at line 90 of file DeDxDiscriminatorLearner.cc.

References algoMode, Charge_Vs_Path, HistoFile, Input, and Output.

 {
    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();
    }
 }

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

overrideprivatevirtual

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

Definition at line 286 of file DeDxDiscriminatorLearner.cc.

References Charge_Vs_Path, DEFINE_FWK_MODULE, and hgcalPlots::obj.

 {
    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;
 }

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

private

Definition at line 147 of file DeDxDiscriminatorLearner.cc.

References calibGains, ALCARECOTkAlJpsiMuMu_cff::charge, Charge_Vs_Path, TrackingRecHit::det(), TrackingRecHit::detUnit(), BaseTrackerRecHit::firstClusterRef(), DeDxTools::getCharge(), DeDxTools::IsFarFromBorder(), DeDxTools::IsSpanningOver2APV(), m_off, MaxNrStrips, SiStripMatchedRecHit2D::monoCluster(), GluedGeomDet::monoDet(), rpcPointValidation_cfi::recHit, DeDxTools::shapeSelection(), shapetest, SiStripMatchedRecHit2D::stereoCluster(), GluedGeomDet::stereoDet(), and OmniClusterRef::stripCluster().

Referenced by algoAnalyze().

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