EMShower.cc

Go to the documentation of this file.

//FAMOS Headers
#include "FastSimulation/ShowerDevelopment/interface/EMShower.h"
#include "FastSimulation/CaloHitMakers/interface/EcalHitMaker.h"
#include "FastSimulation/CaloHitMakers/interface/PreshowerHitMaker.h"
#include "FastSimulation/CaloHitMakers/interface/HcalHitMaker.h"

#include "FastSimulation/Utilities/interface/RandomEngineAndDistribution.h"
#include "FastSimulation/Utilities/interface/GammaFunctionGenerator.h"

#include <cmath>

//#include "FastSimulation/Utilities/interface/Histos.h"

using std::vector;


EMShower::EMShower(const RandomEngineAndDistribution* engine,
                   GammaFunctionGenerator* gamma,
           EMECALShowerParametrization* const myParam, 
           vector<const RawParticle*>* const myPart, 
           EcalHitMaker * const myGrid,
           PreshowerHitMaker * const myPresh,
           bool bFixedLength)
             
  : theParam(myParam), 
    thePart(myPart), 
    theGrid(myGrid),
    thePreshower(myPresh),
    random(engine),
    myGammaGenerator(gamma),
    bFixedLength_(bFixedLength)
{ 

  // Get the Famos Histos pointer
  //  myHistos = Histos::instance();
  //  myGammaGenerator = GammaFunctionGenerator::instance();
  stepsCalculated=false;
  hasPreshower = myPresh!=nullptr;
  theECAL = myParam->ecalProperties();
  theHCAL = myParam->hcalProperties();
  theLayer1 = myParam->layer1Properties();
  theLayer2 = myParam->layer2Properties();

  
  double fotos = theECAL->photoStatistics() 
               * theECAL->lightCollectionEfficiency();

  nPart = thePart->size();
  totalEnergy = 0.;
  globalMaximum = 0.;
  double meanDepth=0.;
  // Initialize the shower parameters for each particle

  for ( unsigned int i=0; i<nPart; ++i ) {
    //    std::cout << " AAA " << *(*thePart)[i] << std::endl;
    // The particle and the shower energy
    Etot.push_back(0.);
    E.push_back(((*thePart)[i])->e());
    totalEnergy+=E[i];
    
    double lny = std::log ( E[i] / theECAL->criticalEnergy() );

    // Average and Sigma for T and alpha
    double theMeanT        = myParam->meanT(lny);
    double theMeanAlpha    = myParam->meanAlpha(lny);
    double theMeanLnT      = myParam->meanLnT(lny);
    double theMeanLnAlpha  = myParam->meanLnAlpha(lny);
    double theSigmaLnT     = myParam->sigmaLnT(lny);
    double theSigmaLnAlpha = myParam->sigmaLnAlpha(lny);


    // The correlation matrix
    double theCorrelation = myParam->correlationAlphaT(lny);
    double rhop = std::sqrt( (1.+theCorrelation)/2. );
    double rhom = std::sqrt( (1.-theCorrelation)/2. );

    // The number of spots in ECAL / HCAL
    theNumberOfSpots.push_back(myParam->nSpots(E[i]));
    //    theNumberOfSpots.push_back(myParam->nSpots(E[i])*spotFraction);
    //theNumberOfSpots = random->poissonShoot(myParam->nSpots(myPart->e()));

    // Photo-statistics
    photos.push_back(E[i] * fotos);
    
    // The longitudinal shower development parameters
    // Fluctuations of alpha, T and beta
    double z1=0.;
    double z2=0.;
    double aa=0.;

    // Protect against too large fluctuations (a < 1) for small energies
    while ( aa <= 1. ) {
      z1 = random->gaussShoot(0.,1.);
      z2 = random->gaussShoot(0.,1.);
      aa = std::exp(theMeanLnAlpha + theSigmaLnAlpha * (z1*rhop-z2*rhom));
    }

    a.push_back(aa);
    T.push_back(std::exp(theMeanLnT + theSigmaLnT * (z1*rhop+z2*rhom)));
    b.push_back((a[i]-1.)/T[i]);
    maximumOfShower.push_back((a[i]-1.)/b[i]);
    globalMaximum += maximumOfShower[i]*E[i];
    meanDepth += a[i]/b[i]*E[i];
    //    std::cout << " Adding max " << maximumOfShower[i] << " " << E[i] << " " <<maximumOfShower[i]*E[i] << std::endl; 
    //    std::cout << std::setw(8) << std::setprecision(5) << " a /b " << a[i] << " " << b[i] << std::endl;
    Ti.push_back(
         a[i]/b[i] * (std::exp(theMeanLnAlpha)-1.) / std::exp(theMeanLnAlpha));
  
    // The parameters for the number of energy spots
    TSpot.push_back(theParam->meanTSpot(theMeanT));
    aSpot.push_back(theParam->meanAlphaSpot(theMeanAlpha));
    bSpot.push_back((aSpot[i]-1.)/TSpot[i]);
    //    myHistos->fill("h7000",a[i]);
    //    myHistos->fill("h7002",E[i],a[i]);
  }
//  std::cout << " PS1 : " << myGrid->ps1TotalX0()
//         << " PS2 : " << myGrid->ps2TotalX0()
//         << " ECAL : " << myGrid->ecalTotalX0()
//         << " HCAL : " << myGrid->hcalTotalX0() 
//         << " Offset : " << myGrid->x0DepthOffset()
//         << std::endl;

 globalMaximum/=totalEnergy;
 meanDepth/=totalEnergy;
 // std::cout << " Total Energy " << totalEnergy << " Global max " << globalMaximum << std::endl;
}

void EMShower::prepareSteps()
{
  //  TimeMe theT("EMShower::compute");
  
  // Determine the longitudinal intervals
  //  std::cout << " EMShower compute" << std::endl;
  double dt;
  double radlen;
  int stps;
  int first_Ecal_step=0;
  int last_Ecal_step=0;

  // The maximum is in principe 8 (with 5X0 steps in the ECAL)
  steps.reserve(24);

  /*  
  std::cout << " PS1 : " << theGrid->ps1TotalX0()
        << " PS2 : " << theGrid->ps2TotalX0()
        << " PS2 and ECAL : " << theGrid->ps2eeTotalX0()
        << " ECAL : " << theGrid->ecalTotalX0()
        << " HCAL : " << theGrid->hcalTotalX0() 
        << " Offset : " << theGrid->x0DepthOffset()
        << std::endl;
  */
  
  radlen = -theGrid->x0DepthOffset();
  
  // Preshower Layer 1
  radlen += theGrid->ps1TotalX0();
  if ( radlen > 0. ) {
    steps.push_back(Step(0,radlen));
    radlen = 0.;
  }
  
  // Preshower Layer 2
  radlen += theGrid->ps2TotalX0();
  if ( radlen > 0. ) {
    steps.push_back(Step(1,radlen));
    radlen = 0.;
  }
  
  // add a step between preshower and ee
  radlen += theGrid->ps2eeTotalX0();
  if ( radlen > 0.) {
    steps.push_back(Step(5,radlen));
    radlen = 0.;  
  }
  
  // ECAL
  radlen += theGrid->ecalTotalX0();

  //  std::cout << "theGrid->ecalTotalX0() = " << theGrid->ecalTotalX0() << std::endl;

  if ( radlen > 0. ) {

    if (!bFixedLength_){
      stps=(int)((radlen+2.5)/5.);
      //    stps=(int)((radlen+.5)/1.);
      if ( stps == 0 ) stps = 1;
      dt = radlen/(double)stps;
      Step step(2,dt);
      first_Ecal_step=steps.size();
      for ( int ist=0; ist<stps; ++ist )
    steps.push_back(step);
      last_Ecal_step=steps.size()-1;
      radlen = 0.;
    } else {
      dt = 1.0;
      stps = static_cast<int>(radlen); 
      if (stps == 0) stps = 1;
      Step step(2,dt);
      first_Ecal_step=steps.size();
      for ( int ist=0; ist<stps; ++ist ) steps.push_back(step);
      dt = radlen-stps;
      if (dt>0) {
    Step stepLast (2,dt);
    steps.push_back(stepLast);
      }
      last_Ecal_step=steps.size()-1;
      //      std::cout << "radlen = "  << radlen << " stps = " << stps << " dt = " << dt << std::endl;
      radlen = 0.;

    }
  } 

  // I should had a gap here ! 
 
 // HCAL 
 radlen += theGrid->hcalTotalX0();
 if ( radlen > 0. ) {
   double dtFrontHcal=theGrid->totalX0()-theGrid->hcalTotalX0();
   // One single step for the full HCAL
   if(dtFrontHcal<30.) 
     {
       dt=30.-dtFrontHcal;
       Step step(3,dt);
       steps.push_back(step);
     }
 } 

 nSteps=steps.size();
 if(nSteps==0) return;
 double ESliceTot=0.;
 double MeanDepth=0.;
 depositedEnergy.resize(nSteps);
 meanDepth.resize(nSteps);
 double t=0.;

 int offset=0;
 for(unsigned iStep=0;iStep<nSteps;++iStep)
   {
     ESliceTot=0.;
     MeanDepth=0.;
     double realTotalEnergy=0;
     dt=steps[iStep].second;
     t+=dt;
     for ( unsigned int i=0; i<nPart; ++i ) {
       depositedEnergy[iStep].push_back(deposit(t,a[i],b[i],dt));     
       ESliceTot +=depositedEnergy[iStep][i];
       MeanDepth += deposit(t,a[i]+1.,b[i],dt)/b[i]*a[i];
       realTotalEnergy+=depositedEnergy[iStep][i]*E[i];
     }

     if( ESliceTot > 0. )  // can happen for the shower tails; this depth will be skipped anyway
       MeanDepth/=ESliceTot;
     else
       MeanDepth=t-dt;

     meanDepth[iStep]=MeanDepth;
     if(realTotalEnergy<0.001)
       {
     offset-=1;
       }
   }

 innerDepth=meanDepth[first_Ecal_step];
 if(last_Ecal_step+offset>=0)
   outerDepth=meanDepth[last_Ecal_step+offset];
 else
   outerDepth=innerDepth;

 stepsCalculated=true;
}

void
EMShower::compute() {

  double t = 0.;
  double dt = 0.;
  if(!stepsCalculated) prepareSteps();

  // Prepare the grids in EcalHitMaker
  // theGrid->setInnerAndOuterDepth(innerDepth,outerDepth);
  float pstot=0.;
  float ps2tot=0.;
  float ps1tot=0.;
  bool status=false; 
  //  double E1 = 0.;  // Energy layer 1
  //  double E2 = 0.;  // Energy layer 2
  //  double n1 = 0.;  // #mips layer 1
  //  double n2 = 0.;  // #mips layer 2
  //  double E9 = 0.;  // Energy ECAL

  // Loop over all segments for the longitudinal development
  double totECalc = 0;
  


  for (unsigned iStep=0; iStep<nSteps; ++iStep ) {
    
    // The length of the shower in this segment
    dt = steps[iStep].second;

    //    std::cout << " Detector " << steps[iStep].first << " t " << t << " " << dt << std::endl;

    // The elapsed length
    t += dt;
    
    // In what detector are we ?
    unsigned detector=steps[iStep].first;
       
    bool presh1 = detector==0;
    bool presh2 = detector==1;
    bool ecal = detector==2;
    bool hcal = detector==3;
    bool vfcal = detector==4;
    bool gap = detector==5;

    // Temporary. Will be removed 
    if ( theHCAL==nullptr) hcal=false;

    // Keep only ECAL for now
    if ( vfcal ) continue;

    // Nothing to do in the gap
    if( gap ) continue;

    //    cout << " t = " << t << endl;
    // Build the grid of crystals at this ECAL depth
    // Actually, it might be useful to check if this grid is empty or not. 
    // If it is empty (because no crystal at this depth), it is of no use 
    // (and time consuming) to generate the spots
    

   // middle of the step
    double tt = t-0.5*dt; 

    double realTotalEnergy=0.;
    for ( unsigned int i=0; i<nPart; ++i ) {
      realTotalEnergy += depositedEnergy[iStep][i]*E[i];
    }

//    std::cout << " Step " << tt << std::endl;
//    std::cout << "ecal " << ecal << " hcal "  << hcal <<std::endl;

    // If the amount of energy is greater than 1 MeV, make a new grid
    // otherwise put in the previous one.    
    bool usePreviousGrid=(realTotalEnergy<0.001);   

    // If the amount of energy is greater than 1 MeV, make a new grid
    // otherwise put in the previous one.    

    // If less than 1 kEV. Just skip
    if(iStep>2&&realTotalEnergy<0.000001) continue;

    if (ecal && !usePreviousGrid) 
      {
    status=theGrid->getPads(meanDepth[iStep]);
      }
    if (hcal) 
      {
    status=theHcalHitMaker->setDepth(tt);
      }
    if((ecal || hcal) && !status) continue;
    
    bool detailedShowerTail=false;
    // check if a detailed treatment of the rear leakage should be applied
    if(ecal && !usePreviousGrid) 
      {
    detailedShowerTail=(t-dt > theGrid->getX0back());
      }
    
    // The particles of the shower are processed in parallel
    for ( unsigned int i=0; i<nPart; ++i ) {

      //      double Edepo=deposit(t,a[i],b[i],dt);

     //  integration of the shower profile between t-dt and t
      double dE = (!hcal)? depositedEnergy[iStep][i]:1.-deposit(a[i],b[i],t-dt);

      // no need to do the full machinery if there is ~nothing to distribute)
      if(dE*E[i]<0.000001) continue;


      if (ecal && !theECAL->isHom()) {
    double mean = dE*E[i];
    double sigma = theECAL->resE()*sqrt(mean);
    
    /*
      double meanLn = log(mean);
      double kLn = sigma/mean+1;
      double sigmaLn = log(kLn);
    */

    double dE0 = dE;

    //    std::cout << "dE before shoot = " << dE << std::endl;
    dE = random->gaussShoot(mean, sigma)/E[i];
    
    //    myGammaGenerator->setParameters(aSam,bSam,0);
    //    dE = myGammaGenerator->shoot()/E[i];
    //    std::cout << "dE shooted = " << dE << " E[i] = " << E[i] << std::endl; 
    if (dE*E[i] < 0.000001) continue;
    photos[i] = photos[i]*dE/dE0;
    
      }



      /*
      if (ecal && !theParam->ecalProperties()->isHom()){

    double cSquare = TMath::Power(theParam->ecalProperties()->resE(),2);
    double aSam = dE/cSquare;
    double bSam = 1./cSquare;

    //  dE = dE*gam(bSam*dE, aSam)/tgamma(aSam);
      }
      */

      totECalc +=dE;
      
 
      // The number of energy spots (or mips)
      double nS = 0;
      
      // ECAL case : Account for photostatistics and long'al non-uniformity
      if (ecal) {


    //  double aSam = E[i]*dE*one_over_resoSquare;
    //  double bSam = one_over_resoSquare;


    dE = random->poissonShoot(dE*photos[i])/photos[i];
    double z0 = random->gaussShoot(0.,1.);
    dE *= 1. + z0*theECAL->lightCollectionUniformity();

    // Expected spot number
    nS = ( theNumberOfSpots[i] * gam(bSpot[i]*tt,aSpot[i]) 
                               * bSpot[i] * dt 
                           / tgamma(aSpot[i]) );
    
      // Preshower : Expected number of mips + fluctuation
      }
      else if ( hcal ) {

    nS = ( theNumberOfSpots[i] * gam(bSpot[i]*tt,aSpot[i]) 
           * bSpot[i] * dt 
           / tgamma(aSpot[i]))* theHCAL->spotFraction();
    double nSo = nS ;
    nS = random->poissonShoot(nS);
    // 'Quick and dirty' fix (but this line should be better removed):
    if( nSo > 0. && nS/nSo < 10.) dE *= nS/nSo;

//  if(true)
//    {
//      std::cout << " theHCAL->spotFraction = " <<theHCAL->spotFraction() <<std::endl;
//      std::cout << " nSpot Ecal : " << nSo/theHCAL->spotFraction() << " Final " << nS << std::endl;
//    }
      }
      else if ( presh1 ) {
    
    nS = random->poissonShoot(dE*E[i]*theLayer1->mipsPerGeV());
    //  std::cout << " dE *E[i] (1)" << dE*E[i] << " " << dE*E[i]*theLayer1->mipsPerGeV() << "  "<< nS << std::endl;
    pstot+=dE*E[i];
    ps1tot+=dE*E[i];
    dE = nS/(E[i]*theLayer1->mipsPerGeV());

    //        E1 += dE*E[i]; 
    //  n1 += nS; 
    //  if (presh2) { E2 += SpotEnergy; ++n2; }
      
      } else if ( presh2 ) {
    
    nS = random->poissonShoot(dE*E[i]*theLayer2->mipsPerGeV());
    //  std::cout << " dE *E[i] (2) " << dE*E[i] << " " << dE*E[i]*theLayer2->mipsPerGeV() << "  "<< nS << std::endl;
    pstot+=dE*E[i];
    ps2tot+=dE*E[i];
        dE = nS/(E[i]*theLayer2->mipsPerGeV());

    //        E2 += dE*E[i]; 
    //  n2 += nS; 
    
      }

      if(detailedShowerTail)
    myGammaGenerator->setParameters(floor(a[i]+0.5),b[i],t-dt);
    


      //    myHistos->fill("h100",t,dE);
      
      // The lateral development parameters  
 
      // Energy of the spots
      double eSpot = (nS>0.) ? dE/nS : 0.;
      double SpotEnergy=eSpot*E[i];

      if(hasPreshower&&(presh1||presh2)) thePreshower->setSpotEnergy(0.00009);
      if(hcal) 
    {
      SpotEnergy*=theHCAL->hOverPi();
      theHcalHitMaker->setSpotEnergy(SpotEnergy);
    }
      // Poissonian fluctuations for the number of spots
      //    int nSpot = random->poissonShoot(nS);
      int nSpot = (int)(nS+0.5);
      
      
      // Fig. 11 (right) *** Does not match.
      //    myHistos->fill("h101",t,(double)nSpot/theNumberOfSpots);
      
      //double taui = t/T;
      double taui = tt/Ti[i];
      double proba = theParam->p(taui,E[i]);
      double theRC = theParam->rC(taui,E[i]);
      double theRT = theParam->rT(taui,E[i]);
      
      // Fig. 10
      //    myHistos->fill("h300",taui,theRC);
      //    myHistos->fill("h301",taui,theRT);
      //    myHistos->fill("h302",taui,proba);
      
      double dSpotsCore = 
    random->gaussShoot(proba*nSpot,std::sqrt(proba*(1.-proba)*nSpot));
      
      if(dSpotsCore<0) dSpotsCore=0;
      
      unsigned nSpots_core = (unsigned)(dSpotsCore+0.5);
      unsigned nSpots_tail = ((unsigned)nSpot>nSpots_core) ? nSpot-nSpots_core : 0;
      
      for(unsigned icomp=0;icomp<2;++icomp)
    {     
      
      double theR=(icomp==0) ? theRC : theRT ;    
      unsigned ncompspots=(icomp==0) ? nSpots_core : nSpots_tail;
      
      RadialInterval radInterval(theR,ncompspots,SpotEnergy,random);
      if(ecal)
        {
          if(icomp==0)
        {
          setIntervals(icomp,radInterval);
        }
          else
        {
          setIntervals(icomp,radInterval);
        }
        }
      else
        {
          radInterval.addInterval(100.,1.);// 100% of the spots
        }
      
      radInterval.compute();
       // irad = 0 : central circle; irad=1 : outside

       unsigned nrad=radInterval.nIntervals();

       for(unsigned irad=0;irad<nrad;++irad)
         {
           double spote=radInterval.getSpotEnergy(irad);
           if(ecal) theGrid->setSpotEnergy(spote);
           if(hcal) theHcalHitMaker->setSpotEnergy(spote);
           unsigned nradspots=radInterval.getNumberOfSpots(irad);
           double umin=radInterval.getUmin(irad);
           double umax=radInterval.getUmax(irad);
           // Go for the lateral development
           //          std::cout << "Couche " << iStep << " irad = " << irad << " Ene = " << E[i] << " eSpot = " << eSpot << " spote = " << spote << " nSpot = " << nS << std::endl;

           for ( unsigned  ispot=0; ispot<nradspots; ++ispot ) 
         {
           double z3=random->flatShoot(umin,umax);
           double ri=theR * std::sqrt(z3/(1.-z3)) ;

           // Generate phi
           double phi = 2.*M_PI*random->flatShoot();
           
           // Add the hit in the crystal
           //   if( ecal ) theGrid->addHit(ri*theECAL->moliereRadius(),phi);
           // Now the *moliereRadius is done in EcalHitMaker
           if ( ecal )
             {
               if(detailedShowerTail) 
             {
               //              std::cout << "About to call addHitDepth " << std::endl;
               double depth;
               do
                 {
                   depth=myGammaGenerator->shoot(random);
                 }
               while(depth>t);
               theGrid->addHitDepth(ri,phi,depth);
               //              std::cout << " Done " << std::endl;
             }
               else
             theGrid->addHit(ri,phi);
             }
           else if (hasPreshower&&presh1) thePreshower->addHit(ri,phi,1);
           else if (hasPreshower&&presh2) thePreshower->addHit(ri,phi,2);
           else if (hcal) 
             {
               //              std::cout << " About to add a spot in the HCAL" << status << std::endl;
               theHcalHitMaker->addHit(ri,phi);
               //              std::cout << " Added a spot in the HCAL" << status << std::endl;
             }
           //   if (ecal) E9 += SpotEnergy;
           //   if (presh1) { E1 += SpotEnergy; ++n1; }
           //   if (presh2) { E2 += SpotEnergy; ++n2; }

           Etot[i] += spote;
         }
         }
    }
      //      std::cout << " Done with the step " << std::endl;
      // The shower!
      //myHistos->fill("h500",theSpot.z(),theSpot.perp());
    }
    //    std::cout << " nPart " << nPart << std::endl;
  }
  //  std::cout << " Finshed the step loop " << std::endl;
  //  myHistos->fill("h500",E1+0.7*E2,E9);
  //  myHistos->fill("h501",n1+0.7*n2,E9);
  //  myHistos->fill("h400",n1);
  //  myHistos->fill("h401",n2);
  //  myHistos->fill("h402",E9+E1+0.7*E2);
  //  if(!standalone)theGrid->printGrid();
  double Etotal=0.;
  for(unsigned i=0;i<nPart;++i)
    {
      //      myHistos->fill("h10",Etot[i]);
      Etotal+=Etot[i];
    }

  //  std::cout << "Etotal = " << Etotal << " nPart = "<< nPart << std::endl; 
  //  std::cout << "totECalc = " << totECalc << std::endl;

  //  myHistos->fill("h20",Etotal);
  //  if(thePreshower)
  //    std::cout << " PS " << thePreshower->layer1Calibrated() << " " << thePreshower->layer2Calibrated() << " " << thePreshower->totalCalibrated() << " " << ps1tot << " " <<ps2tot << " " << pstot << std::endl;
}


double
EMShower::gam(double x, double a) const {
  // A stupid gamma function
  return std::pow(x,a-1.)*std::exp(-x);
}

//double 
//EMShower::deposit(double t, double a, double b, double dt) {
//
//  // The number of integration steps (about 1 / X0)
//  int numberOfSteps = (int)dt+1;
//
//  // The size if the integration step
//  double integrationstep = dt/(double)numberOfSteps;
//
//  // Half this size
//  double halfis = 0.5*integrationstep;
//
//  double dE = 0.;
//  
//  for(double tt=t-dt+halfis;tt<t;tt+=integrationstep) {
//
//    // Simpson integration over each of these steps
//    dE +=   gam(b*(tt-halfis),a) 
//       + 4.*gam(b* tt        ,a)
//       +    gam(b*(tt+halfis),a);
//
//  }
//
//  // Normalization
//  dE *= b*integrationstep/tgamma(a)/6.;
//
//  // There we go.
//  return dE;
//}

double
EMShower::deposit(double t, double a, double b, double dt) {
  myIncompleteGamma.a().setValue(a);
  double b1=b*(t-dt);
  double b2=b*t;
  double result = 0.;  
  double rb1=(b1!=0.) ? myIncompleteGamma(b1) : 0.;
  double rb2=(b2!=0.) ?  myIncompleteGamma(b2) : 0.;
  result = (rb2-rb1);
  return result;
}


void EMShower::setIntervals(unsigned icomp,  RadialInterval& rad)
{
  //  std::cout << " Got the pointer " << std::endl;
  const std::vector<double>& myValues((icomp)?theParam->getTailIntervals():theParam->getCoreIntervals());
  //  std::cout << " Got the vector " << myValues.size () << std::endl;
  unsigned nvals=myValues.size()/2;
  for(unsigned iv=0;iv<nvals;++iv)
    {
      //      std::cout << myValues[2*iv] << " " <<  myValues[2*iv+1] <<std::endl;
      rad.addInterval(myValues[2*iv],myValues[2*iv+1]);
    } 
} 

void EMShower::setPreshower(PreshowerHitMaker * const myPresh)
{
  if(myPresh!=nullptr)
    {
      thePreshower = myPresh;
      hasPreshower=true;
    }
}


void EMShower::setHcal(HcalHitMaker * const myHcal)
{
  theHcalHitMaker = myHcal;
}

double
EMShower::deposit( double a, double b, double t) {
  //  std::cout << " Deposit " << std::endl;
  myIncompleteGamma.a().setValue(a);
  double b2=b*t;
  double result = 0.;
  if(fabs(b2) < 1.e-9 ) b2 = 1.e-9;
  result=myIncompleteGamma(b2);
  //  std::cout << " deposit t = " << t  << " "  << result <<std::endl;
  return result;

}