RPixLinearChargeDivider Class Reference

#include <RPixLinearChargeDivider.h>

Public Member Functions
std::vector < RPixEnergyDepositUnit >	divide (const PSimHit &hit)
	RPixLinearChargeDivider (const edm::ParameterSet &params, CLHEP::HepRandomEngine &eng, uint32_t det_id)
	~RPixLinearChargeDivider ()

Private Member Functions
void	FluctuateEloss (int pid, double particleMomentum, double eloss, double length, int NumberOfSegs, std::vector< RPixEnergyDepositUnit > &elossVector)

Private Attributes
int	chargedivisions_
double	deltaCut_
uint32_t	det_id_
SiG4UniversalFluctuation *	fluctuate
bool	fluctuateCharge_
double	pitch_
CLHEP::HepRandomEngine &	rndEngine_
std::vector < RPixEnergyDepositUnit >	the_energy_path_distribution_
double	thickness_
int	verbosity_

Detailed Description

Definition at line 13 of file RPixLinearChargeDivider.h.

Constructor & Destructor Documentation

RPixLinearChargeDivider::RPixLinearChargeDivider	(	const edm::ParameterSet &	params,
		CLHEP::HepRandomEngine &	eng,
		uint32_t	det_id
	)

Definition at line 6 of file RPixLinearChargeDivider.cc.

References chargedivisions_, deltaCut_, fluctuate, fluctuateCharge_, edm::ParameterSet::getParameter(), and verbosity_.

    : rndEngine_(eng), det_id_(det_id) {
  verbosity_ = params.getParameter<int>("RPixVerbosity");
  fluctuate = new SiG4UniversalFluctuation();
  fluctuateCharge_ = params.getParameter<bool>("RPixLandauFluctuations");
  chargedivisions_ = params.getParameter<int>("RPixChargeDivisions");
  deltaCut_ = params.getParameter<double>("RPixDeltaProductionCut");
}

RPixLinearChargeDivider::~RPixLinearChargeDivider

(

)

Definition at line 17 of file RPixLinearChargeDivider.cc.

References fluctuate.

{ delete fluctuate; }

Member Function Documentation

std::vector< RPixEnergyDepositUnit > RPixLinearChargeDivider::divide

(

const PSimHit &

hit

)

Definition at line 19 of file RPixLinearChargeDivider.cc.

References chargedivisions_, det_id_, PSimHit::energyLoss(), PSimHit::entryPoint(), PSimHit::exitPoint(), fluctuateCharge_, FluctuateEloss(), mps_fire::i, PV3DBase< T, PVType, FrameType >::mag(), PSimHit::pabs(), PSimHit::particleType(), the_energy_path_distribution_, verbosity_, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                   {
  LocalVector direction = hit.exitPoint() - hit.entryPoint();
  if (direction.z() > 10 || direction.x() > 200 || direction.y() > 200) {
    the_energy_path_distribution_.clear();
    return the_energy_path_distribution_;
  }

  int NumberOfSegmentation = chargedivisions_;
  double eLoss = hit.energyLoss();  // Eloss in GeV
  the_energy_path_distribution_.resize(NumberOfSegmentation);

  if (fluctuateCharge_) {
    int pid = hit.particleType();
    double momentum = hit.pabs();
    double length = direction.mag();  // Track length in Silicon
    FluctuateEloss(pid, momentum, eLoss, length, NumberOfSegmentation, the_energy_path_distribution_);
    for (int i = 0; i < NumberOfSegmentation; i++) {
      the_energy_path_distribution_[i].setPosition(hit.entryPoint() +
                                                   double((i + 0.5) / NumberOfSegmentation) * direction);
    }
  } else {
    for (int i = 0; i < NumberOfSegmentation; i++) {
      the_energy_path_distribution_[i].setPosition(hit.entryPoint() +
                                                   double((i + 0.5) / NumberOfSegmentation) * direction);
      the_energy_path_distribution_[i].setEnergy(eLoss / (double)NumberOfSegmentation);
    }
  }

  if (verbosity_) {
    edm::LogInfo("PPS") << "RPixLinearChargeDivider " << det_id_ << " charge along the track:";
    double sum = 0;
    for (unsigned int i = 0; i < the_energy_path_distribution_.size(); i++) {
      edm::LogInfo("RPixLinearChargeDivider")
          << the_energy_path_distribution_[i].Position().x() << " " << the_energy_path_distribution_[i].Position().y()
          << " " << the_energy_path_distribution_[i].Position().z() << " " << the_energy_path_distribution_[i].Energy();
      sum += the_energy_path_distribution_[i].Energy();
    }
    edm::LogInfo("PPS") << "RPixLinearChargeDivider "
                        << "energy dep. sum=" << sum;
  }

  return the_energy_path_distribution_;
}

void RPixLinearChargeDivider::FluctuateEloss ( int  pid, double  particleMomentum, double  eloss, double  length, int  NumberOfSegs, std::vector< RPixEnergyDepositUnit > &  elossVector  )

private

Definition at line 63 of file RPixLinearChargeDivider.cc.

References funct::abs(), deltaCut_, fluctuate, mps_fire::i, cuy::ii, rndEngine_, and SiG4UniversalFluctuation::SampleFluctuations().

Referenced by divide().

                                                                                            {
  double particleMass = 139.6;  // Mass in MeV, Assume pion
  pid = std::abs(pid);
  if (pid != 211) {  // Mass in MeV
    if (pid == 11)
      particleMass = 0.511;
    else if (pid == 13)
      particleMass = 105.7;
    else if (pid == 321)
      particleMass = 493.7;
    else if (pid == 2212)
      particleMass = 938.3;
  }

  double segmentLength = length / NumberOfSegs;

  // Generate charge fluctuations.
  double de = 0.;
  double sum = 0.;
  double segmentEloss = (eloss * 1000) / NumberOfSegs;  //eloss in MeV
  for (int i = 0; i < NumberOfSegs; i++) {
    double deltaCutoff = deltaCut_;
    de = fluctuate->SampleFluctuations(
             particleMomentum * 1000, particleMass, deltaCutoff, segmentLength, segmentEloss, &(rndEngine_)) /
         1000;  //convert to GeV
    elossVector[i].setEnergy(de);
    sum += de;
  }

  if (sum > 0.) {  // If fluctuations give eloss>0.
                   // Rescale to the same total eloss
    double ratio = eloss / sum;
    for (int ii = 0; ii < NumberOfSegs; ii++)
      elossVector[ii].setEnergy(ratio * elossVector[ii].Energy());
  } else {  // If fluctuations gives 0 eloss
    double averageEloss = eloss / NumberOfSegs;
    for (int ii = 0; ii < NumberOfSegs; ii++)
      elossVector[ii].setEnergy(averageEloss);
  }
  return;
}

Member Data Documentation

int RPixLinearChargeDivider::chargedivisions_

private

Definition at line 24 of file RPixLinearChargeDivider.h.

Referenced by divide(), and RPixLinearChargeDivider().

double RPixLinearChargeDivider::deltaCut_

private

Definition at line 25 of file RPixLinearChargeDivider.h.

Referenced by FluctuateEloss(), and RPixLinearChargeDivider().

uint32_t RPixLinearChargeDivider::det_id_

private

Definition at line 22 of file RPixLinearChargeDivider.h.

Referenced by divide().

SiG4UniversalFluctuation* RPixLinearChargeDivider::fluctuate

private

Definition at line 30 of file RPixLinearChargeDivider.h.

Referenced by FluctuateEloss(), RPixLinearChargeDivider(), and ~RPixLinearChargeDivider().

bool RPixLinearChargeDivider::fluctuateCharge_

private

Definition at line 23 of file RPixLinearChargeDivider.h.

Referenced by divide(), and RPixLinearChargeDivider().

double RPixLinearChargeDivider::pitch_

private

Definition at line 26 of file RPixLinearChargeDivider.h.

CLHEP::HepRandomEngine& RPixLinearChargeDivider::rndEngine_

private

Definition at line 21 of file RPixLinearChargeDivider.h.

Referenced by FluctuateEloss().

std::vector<RPixEnergyDepositUnit> RPixLinearChargeDivider::the_energy_path_distribution_

private

Definition at line 29 of file RPixLinearChargeDivider.h.

Referenced by divide().

double RPixLinearChargeDivider::thickness_

private

Definition at line 27 of file RPixLinearChargeDivider.h.

int RPixLinearChargeDivider::verbosity_

private

Definition at line 31 of file RPixLinearChargeDivider.h.

Referenced by divide(), and RPixLinearChargeDivider().