G4FastPathHadronicCrossSection.hh

이 파일의 문서화 페이지로 가기

//
// ********************************************************************
// * 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.          *
// ********************************************************************
//
#ifndef G4FastPathHadronicCrossSection_hh
#define G4FastPathHadronicCrossSection_hh

#include "G4PhysicsFreeVector.hh"
#include "G4ParticleDefinition.hh"
#include "G4Material.hh"
#include <functional>
#include <utility>
#include <unordered_map>
#include <iostream>
#include <set>
#include <stdint.h>

class G4DynamicParticle;
class G4Material;
class G4CrossSectionDataStore;

//To measure performances and debug info on fast cross-section enable this
//#define FPDEBUG

//TODO: Move all logging and debug functionality to separate header
namespace G4FastPathHadronicCrossSection {
  //This data type contains the simplified representation of the
  //cross-section, by default it is a G4PhysicsVector type
  using XSParam=G4PhysicsFreeVector;
  //The key used to search in the cache.
  using G4CrossSectionDataStore_Key=std::pair<const G4ParticleDefinition*,const G4Material*>;
  //This represents the fast XS implementation.
  struct fastPathEntry{
    //fastPathEntry();
    fastPathEntry(const G4ParticleDefinition *par,const G4Material* mat,G4double min_cutoff);
    ~fastPathEntry();
    inline G4double GetCrossSection(G4double ene) const { return physicsVector->Value(ene); }
    void Initialize(G4CrossSectionDataStore* );
    const G4ParticleDefinition * const particle;
    const G4Material * const material;
    const G4double min_cutoff;

    XSParam *physicsVector;
#       ifdef FPDEBUG
    //stats for debug
    G4int count;
    G4double slowpath_sum; //sum of all slowpath xs
    G4double max_delta;
    G4double min_delta;
    G4double sum_delta;
    G4double sum_delta_square;
#   endif
  };

  //A cache entry.
  struct cycleCountEntry{
    cycleCountEntry(const G4String& pname , const G4Material* mat);
    ~cycleCountEntry();
    const G4String& particle;
    const G4Material * const material;

    //optional fastPathEntry
    fastPathEntry* fastPath;

    //cache per element of material test
    G4double energy;
    G4double crossSection;
#   ifdef FPDEBUG
    uint64_t cacheHitCount;//
    uint64_t initCyclesFastPath;
    uint64_t invocationCountSlowPath;
    uint64_t totalCyclesSlowPath;
    uint64_t invocationCountFastPath;
    uint64_t totalCyclesFastPath;
    uint64_t invocationCountTriedOneLineCache;//
    uint64_t invocationCountOneLineCache;//
#   endif
  };

  struct timing {
    unsigned long long rdtsc_start;
    unsigned long long rdtsc_stop;
  };

  struct getCrossSectionCount {
    getCrossSectionCount();
    inline void MethodCalled();
    inline void HitOneLine();
    inline void FastPath();
    inline void SlowPath();
    inline void SampleZandA();
#ifdef FPDEBUG
    uint64_t methodCalled;
    uint64_t hitOneLineCache;
    uint64_t fastPath;
    uint64_t slowPath;
    uint64_t sampleZandA;
#endif
  };

  //Hashing the key
  struct G4CrossSectionDataStore_Key_Hash {
    std::hash<uint64_t> hash_uint64_t;
    inline size_t operator()(const G4CrossSectionDataStore_Key& x) const throw() {
      return hash_uint64_t(hash_uint64_t( ((uint64_t)(x.first)) ) +  hash_uint64_t(((uint64_t)(x.second))));
    }
  };
  //Equality for two key elements
  struct G4CrossSectionDataStore_Key_EqualTo {
    inline bool operator()(const G4CrossSectionDataStore_Key& lhs, const G4CrossSectionDataStore_Key& rhs ) const {
      //TODO: Verify this: particles are singletons, materials use operator==
            //TODO: in ref-10, G4Material::operator== becomes deleted, investigating why
      return (lhs.first==rhs.first)&&(lhs.second == rhs.second);
    }
  };
//  The cache itself
  using G4CrossSectionDataStore_Cache=std::unordered_map<G4CrossSectionDataStore_Key,cycleCountEntry*,
      G4CrossSectionDataStore_Key_Hash,G4CrossSectionDataStore_Key_EqualTo>;

  struct fastPathRequestConfig_t {
    G4CrossSectionDataStore_Key part_mat;
    G4double min_cutoff;
  };
  //Two of the elements are identical if the part_mat part is
  struct fastPathRequestConfig_Less {
    std::less<G4CrossSectionDataStore_Key> less;
    inline bool operator()(const fastPathRequestConfig_t& lhs,const fastPathRequestConfig_t& rhs ) const {
      return less(lhs.part_mat,rhs.part_mat);
    }
  };
  using G4CrossSectionDataStore_Requests=std::set<fastPathRequestConfig_t,fastPathRequestConfig_Less>;

  //Configure the caching mechanism
  struct controlFlag {
    G4bool prevCalcUsedFastPath;
    G4bool useFastPathIfAvailable;
    G4bool initializationPhase;
    controlFlag() : prevCalcUsedFastPath(false),useFastPathIfAvailable(false),initializationPhase(false) {}
  };
  //Parameters to control sampling
  struct fastPathParameters {
    fastPathParameters() {
      //default
      //TODO: are these ok?
        queryMax = 10000;
        sampleMin = 0.0001;
        sampleMax = 10000;
        sampleCount = 200000;
        dpTol = 0.01;
    }
    //PRUTH vars for sampling and surragate model
    G4double queryMax;
    G4double sampleMin;
    G4double sampleMax;
    G4int sampleCount;
    G4double dpTol;
  };

  //Logging functionalities, disabled if not in FPDEBUG mode
  static inline void logInvocationTriedOneLine( cycleCountEntry* );
  static inline void logInvocationOneLine( cycleCountEntry* );
  static inline void logHit(cycleCountEntry*);
  static inline void logInvocationCountFastPath( cycleCountEntry* );
  static inline void logInvocationCountSlowPAth( cycleCountEntry* );
#ifdef FPDEBUG
  void logStartCountCycles( timing& );
  void logStopCountCycles( timing& );
#else
  inline void logStartCountCycles(timing&) {}
  inline void logStopCountCycles(timing&) {}
#endif
  static inline void logInitCyclesFastPath( cycleCountEntry* , timing& );
  static inline void logTotalCyclesFastPath( cycleCountEntry* , timing& );
  static inline void logTotalCyclesSlowPath( cycleCountEntry* , timing& );
  static inline void logTiming( cycleCountEntry* , fastPathEntry* , timing& );
}

inline std::ostream& operator<<(std::ostream& os, const G4FastPathHadronicCrossSection::fastPathEntry& fp);

//Implementation of inline functions. Note the ifdef

namespace G4FastPathHadronicCrossSection {

#ifdef FPDEBUG
inline void logInvocationTriedOneLine(cycleCountEntry* cl ) {
  if ( cl != nullptr ) ++(cl->invocationCountTriedOneLineCache);
}
inline void logInvocationOneLine( cycleCountEntry* cl ) {
  if ( cl != nullptr ) ++(cl->invocationCountOneLineCache);
}
inline void logHit(cycleCountEntry* cl) {
  if ( cl != nullptr ) ++(cl->cacheHitCount);
}
inline void logInvocationCountFastPath( cycleCountEntry* cl )
{
  if ( cl != nullptr ) ++(cl->invocationCountFastPath);
}
inline void logInvocationCountSlowPAth( cycleCountEntry* cl)
{
  if ( cl != nullptr ) ++(cl->invocationCountSlowPath);
}

inline void logInitCyclesFastPath(cycleCountEntry* cl,timing& tm)
{
  if ( cl != nullptr ) cl->initCyclesFastPath = tm.rdtsc_stop - tm.rdtsc_start;
}
inline void logTotalCyclesFastPath( cycleCountEntry* cl,timing& tm)
{
  if ( cl!=nullptr ) cl->totalCyclesFastPath = tm.rdtsc_stop - tm.rdtsc_start;
}
inline void logTotalCyclesSlowPath( cycleCountEntry* cl,timing& tm)
{
  if ( cl!=nullptr ) cl->totalCyclesSlowPath = tm.rdtsc_stop - tm.rdtsc_start;
}
inline void logTiming( cycleCountEntry* entry , fastPathEntry* fast_entry, timing& timing)
{
  if (fast_entry != nullptr ) {
    if ( entry->invocationCountFastPath == 0 ) {
      //PRUTH style initialization
      G4FastPathHadronicCrossSection::logInitCyclesFastPath(entry,timing);
      G4FastPathHadronicCrossSection::logInvocationCountFastPath(entry);
      } else {
      //PRUTH comment to understand:
      //the first one includes the initialization... don't count it for now
      G4FastPathHadronicCrossSection::logTotalCyclesFastPath(entry,timing);
      G4FastPathHadronicCrossSection::logInvocationCountFastPath(entry);
      }
       } else {
         G4FastPathHadronicCrossSection::logInvocationCountSlowPAth(entry);
         G4FastPathHadronicCrossSection::logTotalCyclesSlowPath(entry,timing);
       }
}
#else
inline void logInvocationTriedOneLine(cycleCountEntry*){}
inline void logInvocationOneLine( cycleCountEntry*){}
inline void logHit(cycleCountEntry*){}
inline void logInvocationCountFastPath( cycleCountEntry*){}
inline void logInvocationCountSlowPAth( cycleCountEntry*){}
inline void logInitCyclesFastPath( cycleCountEntry* , timing& ){}
inline void logTotalCyclesFastPath( cycleCountEntry* , timing& ){}
inline void logTotalCyclesSlowPath( cycleCountEntry* , timing& ){}
inline void logTiming( cycleCountEntry* , fastPathEntry* , timing& ) {}
#endif

inline void getCrossSectionCount::MethodCalled() {
#ifdef FPDEBUG
  ++methodCalled;
#endif
}

inline void getCrossSectionCount::HitOneLine() {
#ifdef FPDEBUG
  ++hitOneLineCache;
#endif
}

inline void getCrossSectionCount::FastPath() {
#ifdef FPDEBUG
  ++fastPath;
#endif
}

inline void getCrossSectionCount::SlowPath() {
#ifdef FPDEBUG
  ++slowPath;
#endif
}

inline void getCrossSectionCount::SampleZandA() {
#ifdef FPDEBUG
  ++sampleZandA;
#endif
}
}//namespace

inline std::ostream& operator<<(std::ostream& os, const G4FastPathHadronicCrossSection::fastPathEntry& fp) {
  using CLHEP::MeV;
  os<<"#Particle: "<<(fp.particle!=nullptr?fp.particle->GetParticleName():"UNDEFINED")<<"\n";
  os<<"#Material: "<<(fp.material!=nullptr?fp.material->GetName():"UNDEFINED")<<"\n";
  os<<"#min_cutoff(MeV): "<<fp.min_cutoff/MeV<<"\n";
#ifdef FPDEBUG
  os<<"#DEBUG COUNTERS: count="<<fp.count<<" slowpath_sum="<<fp.slowpath_sum<<" max_delta="<<fp.max_delta;
  os<<" min_delta="<<fp.min_delta<<" sum_delta="<<fp.sum_delta<<" sum_delta_square="<<fp.sum_delta_square<<"\n";
#endif
  os<<*(fp.physicsVector)<<"\n";
  return os;
}

#endif //G4FastPathHadronicCrossSection_hh