G4FastPathHadronicCrossSection.cc

Go to the documentation of this file.

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
#include "G4FastPathHadronicCrossSection.hh"
#include "G4ios.hh"
#include "G4DynamicParticle.hh"
#include "G4Material.hh"
#include "G4CrossSectionDataStore.hh"
#include <vector>
#if defined(WIN32)
  //Needed for M_LN10
  #define _USE_MATH_DEFINES // for C++
  #include <math.h>
#endif
#include <cmath>
#include <array>
 
#ifdef FPDEBUG
#define DBG( msg ) G4cout<< msg <<G4endl;
#define DUMP() G4cout<< <<G4endl;
#else
#define DBG(msg)
#define DUMP()
#endif
 
using namespace G4FastPathHadronicCrossSection;
 
//Utility functions used to perform fast-path calculations.
//See later for details
namespace {
    struct Point_t {
        double e;
        double xs;
    };
    int  simplify_function(G4double tolerance,
                       std::vector<Point_t> & raw_data,
                       std::vector<Point_t>  & simplified_data);
    void RemoveBias( std::vector <Point_t> &,
            std::vector <Point_t> &,
            std::vector <Point_t> &);
}
 
fastPathEntry::fastPathEntry(const G4ParticleDefinition* part, const G4Material* mat, G4double min) :
        particle(part),material(mat),min_cutoff(min),physicsVector(nullptr)
    {
    DBG("Initializing a fastPathEntry");
#ifdef FPDEBUG
    count = 0;
    slowpath_sum=0.;
    max_delta=0.;
    min_delta=0.;
    sum_delta=0.;
    sum_delta_square=0.;
#endif
}
 
fastPathEntry::~fastPathEntry()
{
    DBG("Deleting fastPathEntry");
    DBG("Dumping status for: "<<(particle?particle->GetParticleName():"PART_NONE")<<" "\
          <<(material?material->GetName():"MAT_NONE")<<" min_cutoff:"<<min_cutoff<<" "\
          <<" count:"<<count<<" slowpath_sum:"<<slowpath_sum<<" max_delta:"<<max_delta\
          <<" min_delta"<<min_delta<<" sum_delta"<<sum_delta<<" sum_delta_squared:"<<sum_delta_square);
    delete physicsVector;
}
 
//namespace {
//  static inline G4double exp10(G4double x) {
//      return std::exp( M_LN10*x);
//  }
//}
 
void fastPathEntry::Initialize(G4CrossSectionDataStore* xsds)
{
    //Check this method is called when G4CrossSectionDataStore is in the correct state:
    //  FastPath is enabled and we are indeed initializing
    assert( xsds->GetFastPathControlFlags().useFastPathIfAvailable &&
            xsds->GetFastPathControlFlags().initializationPhase );
    using std::log10;
    std::vector<Point_t> data_in;
    const fastPathParameters& params = xsds->GetFastPathParameters();
    G4double xs;
 
      //G4double max_query = params.queryMax;
      //G4int count = sampleCount;
      //G4double tol = dpTol;
 
    //Shift so max and min are >= 1.
    //Don't forget to shift back before computing XS
    G4double min = params.sampleMin;
    G4double max = params.sampleMax;
    G4double shift = 0.0;
    if(min < 1.0){
        shift = 1.0 - min;
      }
    min += shift;
    max += shift;
 
    G4double log_max = std::log10(params.sampleMax);
    G4double log_min = std::log10(params.sampleMin);
    G4double log_step = (log_max-log_min)/(1.0*params.sampleCount);
 
    G4double max_xs = 0.0;
 
    //Utility particle to calculate XS, with 0 kin energy by default
    static const G4ThreeVector constDirection(0.,0.,1.);
    G4DynamicParticle* probingParticle = new G4DynamicParticle( particle , constDirection , 0 );
 
    //add the cutoff energy
    probingParticle->SetKineticEnergy(min_cutoff);
    //Sample cross-section
    xs = xsds->GetCrossSection(probingParticle,material);
    data_in.push_back({min_cutoff,xs});
 
    G4double currEnergy = 0.0;
    //log results
    auto exp10 = [](G4double x){ return std::exp( M_LN10*x); };
    for(G4double log_currEnergy = log_min; log_currEnergy < log_max; log_currEnergy += log_step){
        currEnergy = exp10(log_currEnergy) - shift;
        if (currEnergy <  min_cutoff) continue;
        probingParticle->SetKineticEnergy(currEnergy);
        xs=xsds->GetCrossSection(probingParticle,material);
        //G4cout << "PRUTH: energy value " << currEnergy << ", XS value " << xs << G4endl;
        if (xs > max_xs) max_xs = xs;
        data_in.push_back({currEnergy,xs});
    } // --- end of loop i
    probingParticle->SetKineticEnergy(max-shift);
    xs = xsds->GetCrossSection(probingParticle,material);
    data_in.push_back({max-shift,xs});
 
    G4double tol = max_xs * 0.01;
    std::vector<Point_t> decimated_data;
    simplify_function(tol,  data_in,  decimated_data);
    std::vector<Point_t> debiased_data;
    RemoveBias( data_in,  decimated_data,  debiased_data);
    if ( physicsVector != nullptr ) delete physicsVector;
    physicsVector = new XSParam(decimated_data.size());
    G4int physicsVectorIndex = 0;
    for(size_t i = 0; i < decimated_data.size(); i++){
        physicsVector->PutValue(physicsVectorIndex++, decimated_data[i].e, decimated_data[i].xs);
    }
    //xsds->DumpFastPath(particle,material,G4cout);
}
 
cycleCountEntry::cycleCountEntry(const G4String& pname , const G4Material* mat) :
        particle(pname),material(mat),fastPath(nullptr),
        energy(-1.),crossSection(-1.)
{
    DBG("Initializing cache entry");
#ifdef FPDEBUG
    cacheHitCount = 0;
    initCyclesFastPath=0;
    invocationCountSlowPath=0;
    totalCyclesSlowPath=0;
    invocationCountFastPath=0;
    totalCyclesFastPath=0;
    invocationCountTriedOneLineCache=0;
    invocationCountOneLineCache=0;
#endif
}
 
cycleCountEntry::~cycleCountEntry()
{
    DBG("Deleting cache entry");
    DBG(particle<<" "<<material<<" ("<<(material?material->GetName():"MAT_NONE")<<") "<<" "\
            <<"fast path pointer:"<<fastPath<<" stored:"<<energy<<" "<<crossSection<<" "\
            <<cacheHitCount<<" "<<initCyclesFastPath<<" "<<invocationCountSlowPath<<" "\
            <<totalCyclesSlowPath<<" "<<invocationCountFastPath<<" "<<totalCyclesFastPath<<" "\
            <<invocationCountTriedOneLineCache<<" "<<invocationCountOneLineCache);
}
 
#ifdef FPDEBUG
namespace {
    static inline unsigned long long rdtsc() {
        unsigned hi=0,lo=0;
#if defined(__GNUC__) &&( defined(__i386__)|| defined(__x86_64__) )
        __asm__ __volatile__ ("rdtsc":"=a"(lo),"=d"(hi));
#endif
        return ((unsigned long long)lo) | ((unsigned long long)hi<<32 );
    }
}
void G4FastPathHadronicCrossSection::logStartCountCycles(timing& tm)
{
    tm.rdtsc_start=rdtsc();
}
void G4FastPathHadronicCrossSection::logStopCountCycles(timing& tm)
{
    tm.rdtsc_stop=rdtsc();
}
#endif
getCrossSectionCount::getCrossSectionCount() {
#ifdef FPDEBUG
    methodCalled = 0;
    hitOneLineCache=0;
    fastPath=0;
    slowPath=0;
    sampleZandA = 0;
#endif
}
 
namespace {
// Rob Fowler's simplify code
 
//  This is a curve simplification routine based on the Douglas-Peucker
//  algorithm.
//  Simplifying assumptions are that the input polyline is a piecewise
//  function with the x values monotonically increasing,  that the function
//  reaches an asymptote at the right (high energy) end.
//  Also, the correct error measure is the difference in y between the original
//  curve and the result.
//  In GEANT4 use, the assumption is that the calling program has identified
//  low- and high-energy cutoffs and that the vector passed in is restricted
//  to the region between the cutoffs.
 
 
// The raw_data vector comes in ordered left to right (small energy to large).
//  The simplified_data vector is initially empty.
 
//A.Dotti ( 16-July-2015): transform variable size C-array and use of size_t
//                         to remove compilation warnings
 
int  simplify_function(G4double tolerance,
                       std::vector<Point_t> & raw_data,
                       std::vector<Point_t>  & simplified_data)
{
 
  int  gap_left, gap_right;  // indices of the current region
 
  G4double tolsq = tolerance*tolerance;  // Alternative to working with absolute values.
 
  std::vector<int> working_stack;
  //A stack of the points to the right of the current interval that
  // are known to be selected.
 
  gap_right = raw_data.size() - 1;  // index of the last element.
 
  gap_left = 0;
 
  DBG("First and last elements  " << gap_left <<"  " <<gap_right);
 
  simplified_data.push_back(raw_data[0]); //copy first element over.
 
  DBG("first point ( 0  "
              <<simplified_data[0].e  <<",  "<<simplified_data[0].xs <<" )");
 
  working_stack.push_back(gap_right); // 0th element on the stack.
 
  while ( !working_stack.empty() )
    {  G4double   a, slope, delta;
      G4double deltasq_max= tolsq;
      int i_max;
 
      gap_right = working_stack.back();  //get current TOS
      i_max = gap_right;
 
 
      if ( (gap_left +1) < gap_right )  // At least three points in the range.
        {
          // co-efficients for the left to right affine line segment
          slope =  (raw_data[gap_right].xs - raw_data[gap_left].xs) /
            (raw_data[gap_right].e - raw_data[gap_left].e);
          a = raw_data[gap_left].xs - slope * raw_data[gap_left].e;
 
          for ( int i = gap_left +1; i <gap_right;  i++) {
            delta = raw_data[i].xs - a - slope * raw_data[i].e;
            if ( delta * delta > deltasq_max){
              deltasq_max = delta * delta;
              i_max = i;
            }
          }
        }  else {
            DBG("      Less than 3 point interval at [ "<< gap_left <<", " <<gap_right<< " ]");
    }
 
      if(i_max < gap_right) {  //  Found a new point, push it on the stack
    working_stack.push_back(i_max);
    DBG("         pushing point " << i_max);
    gap_right = i_max;
      }
      else { // didn't find a new point betweek gap_left and gap_right.
    simplified_data.push_back(raw_data[gap_right]);
    DBG("inserting point ("
               <<gap_right  <<",  "<<raw_data[gap_right].e <<", "
               << raw_data[gap_right].xs <<" )");
    gap_left = gap_right;
    working_stack.pop_back();
    gap_right = working_stack.back();
    DBG("      new gap_right " << gap_right);
      }
 
    }
  DBG("Simplified curve size "<< simplified_data.size());
  return (simplified_data.size());
}
 
// Rob Fowler's debias code
 
//  This is a de-biasing routine applied after using a curve simplification
//  routine based on the Douglas-Peucker
//  algorithm.
//  Simplifying assumptions are that the input polyline is a piecewise
//  function with the x values monotonically increasing, and
//  The right error measure is the difference in y between the original
//  curve and the result.
 
 
 
void RemoveBias(std::vector<Point_t> &  original, std::vector<Point_t> & simplified,
        std::vector<Point_t> & result){
 
 
  const size_t originalSize = original.size();
  const size_t simplifiedSize = simplified.size();
 
  //Create index mapping array
  std::vector<G4int>  xindex(simplifiedSize,0);
  //G4int xindex[simplifiedSize];
  G4int lastmatch = 0;
  G4int  j = 0;
 
  DBG("   original and simplified vector sizes  " << originalSize <<"  "<<simplifiedSize);
 
  for (size_t k = 0; k <simplifiedSize; k++) {
    for (size_t i = lastmatch; i < originalSize; i++) {
      if (original[i].e == simplified[k].e) {
        xindex[j++] = i;
        lastmatch = i;
      }
    }
  }
 
  DBG("Matched  " << j << " values of the simplified vector");
  // Use short names here.
  G4int m = simplifiedSize;
 
  std::vector<G4double> GArea(m-1,0);
  //G4double GArea [m-1];
  G4double GAreatotal = 0;
 
  //Area of original simplified curve
  for(int i = 0; i < m-1; i++){
    G4double GAreatemp = 0;
 
    for(j = xindex[i]; j< xindex[i+1]; j++){
      G4double trap = (original[j+1].xs + original[j].xs) * (original[j+1].e - original[j].e)/2.0;
      GAreatemp = GAreatemp + trap;
    }
    GArea[i] = GAreatemp;
    GAreatotal = GAreatotal + GAreatemp;
  }
 
  DBG("   Area under the original curve " << GAreatotal);
 
  //aleph        Why is this not alpha?
 
 
  std::vector<G4double> aleph(m-1,0);
  //G4double aleph [m-1];
  for(int i = 0; i< m-1; i++){
    aleph[i] = (simplified[i+1].e - simplified[i].e)/2.0;
  }
 
  //solve for f
  std::vector<G4double> adjustedy(m-1,0);
  //G4double adjustedy [m];
  adjustedy[m-1] = simplified[m-1].xs;
  for(int i = 2; i < m+1; i++) {
    adjustedy[m-i] = (GArea[m-i]/aleph[m-i]) - adjustedy[m-i+1];
    if (adjustedy[m-i] <0.0) {
      adjustedy[m-i] = 0.0;
      DBG("   Fixing negative cross section at index " << (m-i));
    }
  }
 
  //error and difference tracking
  std::vector<G4double> difference(m,0.);
  //G4double difference [m];
  G4double maxdiff = 0;
  G4double adjustedarea = 0;
  G4double simplifiedarea = 0;
  for(int i = 0; i < m-1; i++){
    G4double trap;
    trap = (adjustedy[i+1]+adjustedy[i])*(simplified[i+1].e-simplified[i].e)/2.0;
    adjustedarea = adjustedarea+trap;
    trap = (simplified[i+1].xs+simplified[i].xs)*(simplified[i+1].e-simplified[i].e)/2.0;
    simplifiedarea = simplifiedarea + trap;
  }
 
  DBG("   Area:  Simplified curve = " <<simplifiedarea);
  DBG("    Area:  Debiased curve  = " << adjustedarea);
 
  for(int i = 0; i <m; i++) {
    difference[i] = simplified[i].xs-adjustedy[i];
  }
  for(int i = 0; i <m; i++){
    if(std::fabs(difference[i]) > maxdiff) {
      maxdiff = std::fabs(difference[i]);
    }
  }
  //  what is the significance of the loops above ?
 
  for(size_t i = 0; i < simplifiedSize; i++){
    result.push_back( {simplified[i].e , adjustedy[i] } );
  }
 
}
 
 
}