MomentumResolVariation Class Reference

Inheritance diagram for MomentumResolVariation:

Public Types
enum	ModeEnum { kCorr, kSyst }

Public Member Functions
virtual void	ApplyVariation (AnaTrackB *track, const ToyExperiment &exp)
virtual void	ApplyVariationTPCBased (AnaTrackB *track, const ToyExperiment &exp)
virtual void	ApplyVariationTPC (AnaTPCParticleB *track, const ToyExperiment &exp)
	Smear TPC track based on the corresponding true track.
virtual bool	GetVariation (AnaTrackB *track, Float_t &variation, const ToyExperiment &exp)=0
	Abstract class to get the variation given a track.
virtual bool	GetVariationTPC (AnaTPCParticleB *track, Float_t &variation, const ToyExperiment &exp)
	Abstract class to get the variation given a TPC object.

Static Public Member Functions
static AnaParticleB *	GetClosestTPCSegmentWithGoodDQ (const AnaTrackB &track, const Float_t *pos)
	Get TPC segment that satisfies DQ and is closest.

Protected Member Functions
bool	GetXBinnedValues (AnaTrackB *track, Float_t &value1, Float_t &value2, Int_t &index1, Int_t &index2, ModeEnum mode)
	Get parameters for this global track assumed one uses X bins.
bool	GetXBinnedValues (AnaTPCParticleB *tpcTrack, Float_t &value1, Float_t &value2, Int_t &index1, Int_t &index2, ModeEnum mode)
	Get parameters for this tpc track assumed one uses X bins.
bool	GetXBinnedValues (Float_t xmin, Float_t xmax, Float_t &value1, Float_t &value2, Int_t &index1, Int_t &index2, ModeEnum mode)

Protected Attributes
BinnedParams *	_params
	Binned data to read the parameters.

Detailed Description

Definition at line 11 of file MomentumResolVariation.hxx.

Member Function Documentation

ApplyVariation()

void MomentumResolVariation::ApplyVariation ( AnaTrackB *  track, const ToyExperiment &  exp  )

virtual

Apply the variation to the track, the variation is assumed to be an additional factor one adds to the true-rec difference of pt_inv pt_inv_var = (1 + var)(pt_inv_rec - pt_inv_true) + pt_inv_true the variation is calculated on the fly

Definition at line 12 of file MomentumResolVariation.cxx.

                                                                                     {
  //********************************************************************

  if (!track) return;

  // Initial momenum to be varied
  Float_t p = track->Momentum;

  // Get the true momentum
  if (!track->TrueObject) return;

  // Then the change cannot be undone
  if(!track->Original) return;

  
#ifdef DEBUG
  std::cout << " MomentumResolVariation::ApplyVariation() - start " << std::endl;
#endif
  
  Float_t variation;

  if (!GetVariation(track, variation, exp)) return; // for prod6 only depends on coordinates

  Float_t p0_true = track->GetTrueParticle()->Momentum;

#ifdef DEBUG
  std::cout << " MomentumResolVariation::ApplyVariation() p0, p0_true = " << p << " " << p0_true << std::endl;
#endif

  // Get the inverse transverse momentum 
  Float_t pt0_inv = anaUtils::ComputeInversePT(*track);
  
  Float_t pt0_inv_flip = anaUtils::ComputeInversePTFlip(*track);
  
  if (pt0_inv < 0) return;

  // Get the true inverse transverse momentum
  Float_t pt0_inv_true  = anaUtils::ComputeInversePT(*(track->GetTrueParticle())); 

#ifdef DEBUG
  std::cout << " MomentumResolVariation::ApplyVariation() 1/pt0, 1/pt0_true = " << pt0_inv << " " << pt0_inv_true << std::endl;    
  std::cout << " MomentumResolVariation::ApplyVariation() 1/pt0_flip = " << pt0_inv_flip << std::endl;    
  std::cout << " MomentumResolVariation::ApplyVariation() var = " << variation << std::endl;
#endif

  // Apply momentum resolution smearing
  Float_t pt_inv = (1 + variation) * (pt0_inv - pt0_inv_true) + pt0_inv_true;
  
  // Same for the flip,  since we assume this will be used as a correct one when ToF applied...
  Float_t pt_inv_flip = (1 + variation) * (pt0_inv_flip - pt0_inv_true) + pt0_inv_true;
 
  // Convert back to the full momentum
  p = fabs(anaUtils::ComputeMomentumFromInversePT( *(track), pt_inv));

  if (p < 0) return;
   

  // Set the new momentum
  track->Momentum = p;

  Float_t p_flip = fabs(anaUtils::ComputeMomentumFromInversePTFlip( *(track), pt_inv_flip));
  if (p_flip > 0)
    track->MomentumFlip = p_flip;
  
  
  // Apply the smearing to the TPC constituents
  if (track->nTPCSegments == 0) return;


  Float_t p0 = track->GetOriginalTrack()->Momentum;

  // Translate the smearing on the error of the local momentum and its error
  Float_t smearingFact    = (p - p0_true)/(p0 - p0_true);
  Float_t smearingFactMom = p / p0;

  for(int iseg = 0; iseg < track->nTPCSegments; iseg++){
    AnaTPCParticleB* tpcTrackOrig = static_cast<const AnaTrackB*>(track->Original)->TPCSegments[iseg];
    AnaTPCParticleB* tpcTrack     = track->TPCSegments[iseg];
    Float_t          tpcmomerr    = tpcTrackOrig->MomentumError;
    Float_t          tpcmom       = tpcTrackOrig->Momentum;

    tpcTrack->MomentumError = tpcmomerr * smearingFact;
    tpcTrack->Momentum      = tpcmom    * smearingFactMom;
  }

#ifdef DEBUG
  std::cout << " MomentumResolVariation::ApplyVariation() p0 new = "     << track->Momentum     << std::endl;
  std::cout << " MomentumResolVariation::ApplyVariation() p0flip new = " << track->MomentumFlip << std::endl;
#endif 

}

ApplyVariationTPCBased()

void MomentumResolVariation::ApplyVariationTPCBased ( AnaTrackB *  track, const ToyExperiment &  exp  )

virtual

Variation based on pure TPC (then propagated to global) the closest TPC will be used, will do the alternate momentum in the same manner

Definition at line 106 of file MomentumResolVariation.cxx.

                                                                                             {
  //********************************************************************

#ifdef DEBUG
  std::cout << " MomentumResolVariation::ApplyVariationTPCBased() - start " << std::endl;
#endif

  if (!track) return;

  // Get the true momentum
  if (!track->TrueObject) return;

  // Then the change cannot be undone
  if(!track->Original) return;

#ifdef DEBUG
  Float_t p0_true = track->GetTrueParticle()->Momentum;
  std::cout << " MomentumResolVariation::ApplyVariationTPCBased() p0, p0_true = "     << track->Momentum     << " " << p0_true << std::endl;
  std::cout << " MomentumResolVariation::ApplyVariationTPCBased() p0flip, p0_true = " << track->MomentumFlip << " " << p0_true << std::endl;
#endif 

  // Do nothing if there are no  TPC constituents
  if (track->nTPCSegments == 0) return;

  // Smear each constituent separately
  for (int iseg = 0; iseg < track->nTPCSegments; iseg++){
    if (!track->TPCSegments[iseg]) continue;

    // Smear the TPC momentum
    ApplyVariationTPC(track->TPCSegments[iseg], exp);
  }

  // Using the TPC closest to the starting point smear the global momentum
  AnaParticleMomB* tpcStart = static_cast<AnaParticleMomB*>(
      GetClosestTPCSegmentWithGoodDQ(*track, track->PositionStart));

  if (tpcStart)
    // Retrieve the original momentum and apply the differnece to the one of the global track
    if (tpcStart->Original)
      track->Momentum += tpcStart->Momentum - static_cast<const AnaParticleMomB*>(tpcStart->Original)->Momentum ;


  // Using the TPC closest to the end point smear the flip momentum
  AnaParticleMomB* tpcEnd = static_cast<AnaParticleMomB*>(
      GetClosestTPCSegmentWithGoodDQ(*track, track->PositionEnd));
  if (tpcEnd)
    // Retrieve the original momentum and apply the differnece to the one of the global track
    if (tpcEnd->Original)
      track->MomentumFlip += tpcEnd->Momentum - static_cast<const AnaParticleMomB*>(tpcEnd->Original)->Momentum ;

#ifdef DEBUG
  std::cout << " MomentumResolVariation::ApplyVariationTPCBased() p0 new = "     << track->Momentum     << std::endl;
  std::cout << " MomentumResolVariation::ApplyVariationTPCBased() p0flip new = " << track->MomentumFlip << std::endl;
#endif 

}

---

The documentation for this class was generated from the following files:

• /hep/T2K/nd280rep/ANALYSIS/HIGHLAND2/ANAPARTICLE/psyche/psycheND280Utils/v3r12/src/MomentumResolVariation.hxx
• /hep/T2K/nd280rep/ANALYSIS/HIGHLAND2/ANAPARTICLE/psyche/psycheND280Utils/v3r12/src/MomentumResolVariation.cxx