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

Inheritance diagram for DeDxDiscriminatorLearner:

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

	~DeDxDiscriminatorLearner ()

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

virtual	~ConditionDBWriter ()

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

	EDAnalyzer ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

virtual	~EDAnalyzer ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

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

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

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

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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

void	algoAnalyzeTheTree (const edm::EventSetup &iSetup)

virtual void	algoBeginJob (const edm::EventSetup &)

virtual void	algoEndJob ()

PhysicsTools::Calibration::HistogramD3D *	getNewObject ()

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

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 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 22 of file DeDxDiscriminatorLearner.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 35 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 ( )

Definition at line 67 of file DeDxDiscriminatorLearner.cc.

67 {}

Member Function Documentation

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

privatevirtual

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

Definition at line 111 of file DeDxDiscriminatorLearner.cc.

References edm::AssociationMap< edm::OneToOne< std::vector< Trajectory >, reco::TrackCollection, unsigned short > >::const_iterator, 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(), 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 201 of file DeDxDiscriminatorLearner.cc.

References EnergyCorrector::c, calibGains, Charge_Vs_Path, edm::EventSetup::get(), i, m_off, NULL, cmsHarvester::path, cond::runnumber, alignCSCRings::s, edmStreamStallGrapher::t, MainPageGenerator::tree, 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   , NULL);
       unsigned int                 runnumber      = 0;    tree->SetBranchAddress(EventPrefix + "run"            + EventSuffix, &runnumber     , NULL);
       std::vector<bool>*           TrigTech       = 0;    tree->SetBranchAddress(EventPrefix + "TrigTech"       + EventSuffix, &TrigTech   , NULL);
 
       std::vector<double>*         trackchi2ndof  = 0;    tree->SetBranchAddress(TrackPrefix + "chi2ndof"       + TrackSuffix, &trackchi2ndof , NULL);
       std::vector<float>*          trackp         = 0;    tree->SetBranchAddress(TrackPrefix + "momentum"       + TrackSuffix, &trackp        , NULL);
       std::vector<float>*          trackpt        = 0;    tree->SetBranchAddress(TrackPrefix + "pt"             + TrackSuffix, &trackpt       , NULL);
       std::vector<double>*         tracketa       = 0;    tree->SetBranchAddress(TrackPrefix + "eta"            + TrackSuffix, &tracketa      , NULL);
       std::vector<double>*         trackphi       = 0;    tree->SetBranchAddress(TrackPrefix + "phi"            + TrackSuffix, &trackphi      , NULL);
       std::vector<unsigned int>*   trackhitsvalid = 0;    tree->SetBranchAddress(TrackPrefix + "hitsvalid"      + TrackSuffix, &trackhitsvalid, NULL);
 
       std::vector<int>*            trackindex     = 0;    tree->SetBranchAddress(CalibPrefix + "trackindex"     + CalibSuffix, &trackindex    , NULL);
       std::vector<unsigned int>*   rawid          = 0;    tree->SetBranchAddress(CalibPrefix + "rawid"          + CalibSuffix, &rawid         , NULL);
       std::vector<unsigned short>* firststrip     = 0;    tree->SetBranchAddress(CalibPrefix + "firststrip"     + CalibSuffix, &firststrip    , NULL);
       std::vector<unsigned short>* nstrips        = 0;    tree->SetBranchAddress(CalibPrefix + "nstrips"        + CalibSuffix, &nstrips       , NULL);
       std::vector<unsigned int>*   charge         = 0;    tree->SetBranchAddress(CalibPrefix + "charge"         + CalibSuffix, &charge        , NULL);
       std::vector<float>*          path           = 0;    tree->SetBranchAddress(CalibPrefix + "path"           + CalibSuffix, &path          , NULL);
       std::vector<unsigned char>*  amplitude      = 0;    tree->SetBranchAddress(CalibPrefix + "amplitude"      + CalibSuffix, &amplitude     , NULL);
       std::vector<double>*         gainused       = 0;    tree->SetBranchAddress(CalibPrefix + "gainused"       + CalibSuffix, &gainused      , NULL);
 
       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 )

privatevirtual

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

Definition at line 71 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(), 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.size()==0){
       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 ( )

privatevirtual

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

Definition at line 89 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();
    }
 }

PhysicsTools::Calibration::HistogramD3D * DeDxDiscriminatorLearner::getNewObject ( )

privatevirtual

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

Definition at line 285 of file DeDxDiscriminatorLearner.cc.

References Charge_Vs_Path, getGTfromDQMFile::obj, and PhysicsTools::Calibration::Histogram3D< Value_t, AxisX_t, AxisY_t, AxisZ_t >::setBinContent().

 {
    PhysicsTools::Calibration::HistogramD3D* obj;
    obj = new 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 146 of file DeDxDiscriminatorLearner.cc.

References calibGains, Charge_Vs_Path, compareJSON::const, TrackingRecHit::det(), TrackingRecHit::detUnit(), DeDxTools::getCharge(), DeDxTools::IsFarFromBorder(), DeDxTools::IsSpanningOver2APV(), m_off, MaxNrStrips, SiStripMatchedRecHit2D::monoCluster(), GluedGeomDet::monoDet(), DeDxTools::shapeSelection(), shapetest, SiStripMatchedRecHit2D::stereoCluster(), and GluedGeomDet::stereoDet().

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