GflashShowino.cc

Go to the documentation of this file.

#include "SimGeneral/GFlash/interface/GflashShowino.h"
#include <CLHEP/Random/Randomize.h>
 
GflashShowino::GflashShowino()
    : theShowerType(-1),
      theEnergy(0),
      thePositionAtShower(0, 0, 0),
      thePathLengthAtShower(0),
      thePathLengthOnEcal(0),
      theStepLengthToHcal(0),
      theStepLengthToOut(0),
      thePathLength(0),
      theGlobalTime(0),
      thePosition(0, 0, 0),
      theEnergyDeposited(0) {
  theHelix = new GflashTrajectory;
}
 
GflashShowino::~GflashShowino() { delete theHelix; }
 
void GflashShowino::initialize(int showerType,
                               double energy,
                               double globalTime,
                               double charge,
                               Gflash3Vector &position,
                               Gflash3Vector &momentum,
                               double magneticField) {
  theEnergy = energy;
  theGlobalTime = globalTime;
  theEnergyDeposited = 0.0;
 
  // inside the magnetic field (tesla unit);
  theHelix->initializeTrajectory(momentum, position, charge, magneticField);
 
  if (showerType < 100) {
    thePositionAtShower = position;
    thePosition = thePositionAtShower;
    theShowerType = showerType;
 
  } else {
    // this input is from FastSimulation
    // 1. simulate the shower starting position
    thePositionAtShower = simulateFirstInteractionPoint(showerType, position);
    thePosition = thePositionAtShower;
 
    // 2. find shower type depending on where is the shower starting point
    theShowerType = Gflash::findShowerType(thePositionAtShower);
  }
 
  evaluateLengths();
}
 
void GflashShowino::updateShowino(double deltaStep) {
  thePathLength += deltaStep;
  // trajectory point of showino along the shower depth at the pathLength
  GflashTrajectoryPoint trajectoryShowino;
  theHelix->getGflashTrajectoryPoint(trajectoryShowino, thePathLength);
 
  thePosition = trajectoryShowino.getPosition();
 
  theGlobalTime += (theEnergy / 100.0) * deltaStep / 30.0;  //@@@calculate exact time change in nsec
}
 
void GflashShowino::evaluateLengths() {
  // thePathLengthAtShower: path Length from the origin to the shower starting
  // point in cm theStepLengthToOut: the total path length from the starting
  // point of
  //                    shower to the maximum distance inside paramerized
  //                    envelopes
  double eta = thePosition.getEta();
 
  if (std::fabs(eta) < Gflash::EtaMax[Gflash::kESPM]) {
    thePathLengthOnEcal = theHelix->getPathLengthAtRhoEquals(Gflash::RFrontCrystalEB);
    thePathLengthAtShower = theHelix->getPathLengthAtRhoEquals(thePosition.getRho());
    double pathLengthAtHcalBack = theHelix->getPathLengthAtRhoEquals(Gflash::Rmax[Gflash::kHB]);
    if (pathLengthAtHcalBack > 0) {
      theStepLengthToOut = std::min(300., pathLengthAtHcalBack - thePathLengthAtShower);
    } else {
      theStepLengthToOut = 200.;
    }
    theStepLengthToHcal = theHelix->getPathLengthAtRhoEquals(Gflash::Rmin[Gflash::kHB]) - thePathLengthAtShower;
 
  } else if (std::fabs(eta) < Gflash::EtaMax[Gflash::kENCA]) {
    double zsign = (eta > 0) ? 1.0 : -1.0;
    thePathLengthOnEcal = theHelix->getPathLengthAtZ(zsign * Gflash::ZFrontCrystalEE);
    thePathLengthAtShower = theHelix->getPathLengthAtZ(thePosition.getZ());
    theStepLengthToOut =
        std::min(300., theHelix->getPathLengthAtZ(zsign * Gflash::Zmax[Gflash::kHE]) - thePathLengthAtShower);
    theStepLengthToHcal = theHelix->getPathLengthAtZ(zsign * Gflash::Zmin[Gflash::kHE]) - thePathLengthAtShower;
  } else {
    //@@@extend for HF later
    theStepLengthToOut = 200.0;
  }
 
  thePathLength = thePathLengthAtShower;
}
 
Gflash3Vector &GflashShowino::simulateFirstInteractionPoint(int fastSimShowerType, Gflash3Vector &position) {
  // determine the shower starting point (ssp):
  // the position at the entrance + the mean free path till the inelastic
  // interaction inside calo
 
  double depthAtShower = 0.0;
 
  // set thePathLengthOnEcal, the pathLength at the reference (r=123.8 for
  // barrel and z=304.5 for endcap)
 
  // effective interaction length fitter to ssp from Geant4
  double effectiveLambda = 0.0;
  if (theEnergy > 0.0 && theEnergy < 15) {
    effectiveLambda = 24.6 + 2.6 * std::tanh(3.0 * (std::log(theEnergy) - 1.43));
  } else {
    effectiveLambda = 28.4 + 1.20 * std::tanh(1.5 * (std::log(theEnergy) - 4.3));
  }
  // fraction before the crystal, but inside Ecal
  //  double frac_ssp1
  //  = 1.5196e-01+1.3300e-01*tanh(-4.6971e-01*(std::log(theEnergy)+2.4162e+00));
  // fraction after the crystal, but before Hcal
  double frac_ssp2 = 2.8310e+00 + 2.6766e+00 * tanh(-4.8068e-01 * (std::log(theEnergy) + 3.4857e+00));
 
  if (fastSimShowerType == 100) {  // fastTrack.onEcal() == 1
 
    //    double rhoTemp = Gflash::ROffCrystalEB +
    //    Gflash::LengthCrystalEB*std::sin(position.getTheta());
    double rhoTemp = Gflash::LengthCrystalEB * std::sin(position.getTheta());
    thePathLengthOnEcal = theHelix->getPathLengthAtRhoEquals(Gflash::RFrontCrystalEB);
    double pathLengthAt2 = theHelix->getPathLengthAtRhoEquals(Gflash::RFrontCrystalEB + rhoTemp);
    double pathLengthAt3 = theHelix->getPathLengthAtRhoEquals(Gflash::Rmin[Gflash::kHB]);
 
    /*
    if(CLHEP::HepUniformRand() < frac_ssp1 ) {
      depthAtShower =
    (pathLengthAt1-thePathLengthOnEcal)*CLHEP::HepUniformRand();
    }
    else {
    */
    // inside the crystal
    //      depthAtShower = (pathLengthAt1-thePathLengthOnEcal) -
    //      effectiveLambda*log(CLHEP::HepUniformRand());
    depthAtShower = -effectiveLambda * log(CLHEP::HepUniformRand());
    // after the crystal
    if (depthAtShower > (pathLengthAt2 - thePathLengthOnEcal)) {
      // before Hcal
      if (CLHEP::HepUniformRand() < frac_ssp2) {
        depthAtShower =
            (pathLengthAt2 - thePathLengthOnEcal) + (pathLengthAt3 - pathLengthAt2) * CLHEP::HepUniformRand();
      }
      // inside Hcal
      else {
        depthAtShower = (pathLengthAt3 - thePathLengthOnEcal) - effectiveLambda * log(CLHEP::HepUniformRand());
        // check whether the shower starts beyond HB
        double pathLengthAt4 = theHelix->getPathLengthAtRhoEquals(Gflash::Rmax[Gflash::kHB]);
        if (depthAtShower > (pathLengthAt4 - thePathLengthOnEcal)) {
          depthAtShower = (pathLengthAt4 - pathLengthAt3) * CLHEP::HepUniformRand();
        }
      }
    }
    //    }
  } else if (fastSimShowerType == 101) {  // fastTrack.onEcal() == 2
 
    double zTemp = Gflash::LengthCrystalEE;
    double zsign = (position.getEta() > 0) ? 1.0 : -1.0;
 
    thePathLengthOnEcal = theHelix->getPathLengthAtZ(zsign * Gflash::ZFrontCrystalEE);
    double pathLengthAt2 = theHelix->getPathLengthAtZ(zsign * (Gflash::ZFrontCrystalEE + zTemp));
    double pathLengthAt3 = theHelix->getPathLengthAtZ(zsign * Gflash::Zmin[Gflash::kHE]);
 
    /*
    if(CLHEP::HepUniformRand() <  frac_ssp1 ) {
      depthAtShower =
    (pathLengthAt1-thePathLengthOnEcal)*CLHEP::HepUniformRand();
    }
    else {
    */
    //      depthAtShower =
    //      (pathLengthAt1-thePathLengthOnEcal)-effectiveLambda*std::log(CLHEP::HepUniformRand());
    depthAtShower = -effectiveLambda * std::log(CLHEP::HepUniformRand());
 
    if (depthAtShower > (pathLengthAt2 - thePathLengthOnEcal)) {
      if (CLHEP::HepUniformRand() < frac_ssp2) {
        depthAtShower =
            (pathLengthAt2 - thePathLengthOnEcal) + (pathLengthAt3 - pathLengthAt2) * CLHEP::HepUniformRand();
      } else {
        depthAtShower = (pathLengthAt3 - thePathLengthOnEcal) - effectiveLambda * std::log(CLHEP::HepUniformRand());
        // shower starts beyond HE
        double pathLengthAt4 = theHelix->getPathLengthAtZ(zsign * Gflash::Zmax[Gflash::kHE]);
        if (depthAtShower > (pathLengthAt4 - thePathLengthOnEcal)) {
          depthAtShower = (pathLengthAt4 - pathLengthAt3) * CLHEP::HepUniformRand();
        }
      }
    }
    //    }
  } else {
    depthAtShower = 0.0;
  }
 
  double pathLength = thePathLengthOnEcal + depthAtShower;
 
  theHelix->getGflashTrajectoryPoint(theTrajectoryPoint, pathLength);
 
  // return the initial showino position at the shower starting position
  return theTrajectoryPoint.getPosition();
}