EnergyLossUpdator Class Reference

#include <EnergyLossUpdator.h>

Inheritance diagram for EnergyLossUpdator:

Public Member Functions
virtual EnergyLossUpdator *	clone () const
virtual void	compute (const TrajectoryStateOnSurface &, const PropagationDirection, Effect &effect) const
	EnergyLossUpdator (double mass)
Public Member Functions inherited from MaterialEffectsUpdator
double	mass () const
	MaterialEffectsUpdator (double mass)
virtual TrajectoryStateOnSurface	updateState (const TrajectoryStateOnSurface &TSoS, const PropagationDirection propDir) const
virtual bool	updateStateInPlace (TrajectoryStateOnSurface &TSoS, const PropagationDirection propDir) const
virtual	~MaterialEffectsUpdator ()

Private Member Functions
void	computeBetheBloch (const LocalVector &, const MediumProperties &, Effect &effect) const
void	computeElectrons (const LocalVector &, const MediumProperties &, const PropagationDirection, Effect &effect) const

Additional Inherited Members
Public Types inherited from MaterialEffectsUpdator
typedef materialEffect::Covariance	Covariance
typedef materialEffect::CovIndex	CovIndex
typedef materialEffect::Effect	Effect

Detailed Description

Energy loss according to Bethe-Bloch + special treatment for electrons. Adds effects from energy loss according to Bethe-Bloch formula without density effect. Assumes silicon as material. For electrons energy loss due to radiation added according to formulae by Bethe & Heitler. Ported from ORCA.

Definition at line 20 of file EnergyLossUpdator.h.

Constructor & Destructor Documentation

EnergyLossUpdator::EnergyLossUpdator ( double  mass )

inline

Definition at line 28 of file EnergyLossUpdator.h.

Referenced by clone().

                                   :
    MaterialEffectsUpdator(mass) {}

Member Function Documentation

virtual EnergyLossUpdator* EnergyLossUpdator::clone ( void  ) const

inlinevirtual

Implements MaterialEffectsUpdator.

Definition at line 23 of file EnergyLossUpdator.h.

References EnergyLossUpdator().

                                           {
    return new EnergyLossUpdator(*this);
  }

void EnergyLossUpdator::compute ( const TrajectoryStateOnSurface &  TSoS, const PropagationDirection  propDir, Effect &  effect  ) const

virtual

Implements MaterialEffectsUpdator.

Definition at line 22 of file EnergyLossUpdator.cc.

References alongMomentum, computeBetheBloch(), computeElectrons(), materialEffect::Effect::deltaP, MediumProperties::isValid(), TrajectoryStateOnSurface::localMomentum(), MaterialEffectsUpdator::mass(), Surface::mediumProperties(), and TrajectoryStateOnSurface::surface().

Referenced by CombinedMaterialEffectsUpdator::compute().

{
  //
  // Get surface
  //
  const Surface& surface = TSoS.surface();
  //
  //
  // Now get information on medium
  //
  if (surface.mediumProperties().isValid()) {
    //
    // Bethe-Bloch
    //
    if ( mass()>0.001 )
      computeBetheBloch(TSoS.localMomentum(),surface.mediumProperties(),effect);
    //
    // Special treatment for electrons (currently rather crude
    // distinction using mass)
    //
    else
      computeElectrons(TSoS.localMomentum(),surface.mediumProperties(),
               propDir,effect);
    if (propDir != alongMomentum) effect.deltaP *= -1.;
  }
}

void EnergyLossUpdator::computeBetheBloch ( const LocalVector &  localP, const MediumProperties &  materialConstants, Effect &  effect  ) const

private

Definition at line 53 of file EnergyLossUpdator.cc.

References funct::abs(), constexpr, materialEffect::Effect::deltaCov, materialEffect::Effect::deltaP, alignCSCRings::e, materialEffect::elos, cmsBatch::log, PV3DBase< T, PVType, FrameType >::mag2(), MaterialEffectsUpdator::mass(), p2, mathSSE::sqrt(), MediumProperties::xi(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by compute().

                                                                                        {
  //
  // calculate absolute momentum and correction to path length from angle 
  // of incidence
  //

  typedef float Float;

  Float p2 = localP.mag2();
  Float xf = std::abs(std::sqrt(p2)/localP.z());
   
  // constants
  const Float m2 = mass()*mass();           // use mass hypothesis from constructor

  constexpr Float emass = 0.511e-3;
  constexpr Float poti = 16.e-9 * 10.75; // = 16 eV * Z**0.9, for Si Z=14
  const Float eplasma = 28.816e-9 * sqrt(2.33*0.498); // 28.816 eV * sqrt(rho*(Z/A)) for Si
  const Float delta0 = 2*log(eplasma/poti) - 1.;

  // calculate general physics things
  Float im2 = Float(1.)/m2;
  Float e2     = p2 + m2;
  Float e = std::sqrt(e2);
  Float beta2  = p2/e2;
  Float eta2  = p2*im2;
  Float ratio2 = (emass*emass)*im2;
  Float emax  = Float(2.)*emass*eta2/(Float(1.) + Float(2.)*emass*e*im2 + ratio2);
  
  Float xi = materialConstants.xi()*xf; xi /= beta2;
  
  Float dEdx = xi*(unsafe_logf<2>(Float(2.)*emass*emax/(poti*poti)) - Float(2.)*(beta2) - delta0);
  
  Float dEdx2 = xi*emax*(Float(1.)-Float(0.5)*beta2);
  Float dP    = dEdx/std::sqrt(beta2);
  Float sigp2 = dEdx2/(beta2*p2*p2);
  effect.deltaP += -dP;
  using namespace materialEffect;
  effect.deltaCov[elos] += sigp2;


  // std::cout << "pion new " <<  theDeltaP << " " << theDeltaCov(0,0) << std::endl;
  // oldComputeBetheBloch (localP, materialConstants, mass());

}

void EnergyLossUpdator::computeElectrons ( const LocalVector &  localP, const MediumProperties &  materialConstants, const PropagationDirection  propDir, Effect &  effect  ) const

private

Definition at line 102 of file EnergyLossUpdator.cc.

References funct::abs(), materialEffect::Effect::deltaCov, materialEffect::Effect::deltaP, materialEffect::elos, python.connectstrParser::f2, cmsBatch::log, PV3DBase< T, PVType, FrameType >::mag2(), oppositeToMomentum, AlCaHLTBitMon_ParallelJobs::p, p2, MediumProperties::radLen(), mathSSE::sqrt(), z, and PV3DBase< T, PVType, FrameType >::z().

Referenced by compute().

                                                                                {
  //
  // calculate absolute momentum and correction to path length from angle 
  // of incidence
  //
  float p2 = localP.mag2();
  float p = std::sqrt(p2);
  float normalisedPath = std::abs(p/localP.z())*materialConstants.radLen();
  //
  // Energy loss and variance according to Bethe and Heitler, see also
  // Comp. Phys. Comm. 79 (1994) 157. 
  //
  const float l3ol2 = std::log(3.)/std::log(2.);
  float z = unsafe_expf<3>(-normalisedPath);
  float varz = unsafe_expf<3>(-normalisedPath*l3ol2)- 
                z*z;
        // exp(-2*normalisedPath);

  if ( propDir==oppositeToMomentum ) {
    //
    // for backward propagation: delta(1/p) is linear in z=p_outside/p_inside
    // convert to obtain equivalent delta(p). Sign of deltaP is corrected
    // in method compute -> deltaP<0 at this place!!!
    //
    effect.deltaP += -p*(1.f/z-1.f);
    using namespace materialEffect;
    effect.deltaCov[elos]  += varz/p2;
  }
  else {    
    //
    // for forward propagation: calculate in p (linear in 1/z=p_inside/p_outside),
    // then convert sig(p) to sig(1/p). 
    //
    effect.deltaP += p*(z-1.f);
    //    float f = 1/p/z/z;
    // patch to ensure consistency between for- and backward propagation
    float f2 = 1.f/(p2*z*z);
    using namespace materialEffect;
    effect.deltaCov[elos] += f2*varz;
  }


  // std::cout << "electron new " <<  theDeltaP << " " << theDeltaCov(0,0) << std::endl;
  // oldComputeElectrons (localP, materialConstants, propDir);

}