#include <G4DNASamplingTable.hh>

Public Member Functions
	G4DNASamplingTable (std::size_t npoint)
	~G4DNASamplingTable ()
void	LoadData (const G4String &filename, G4double factorE, G4double scaleFactor, G4bool verbose)
G4double	GetValue (G4double ekinPrimary, G4double ekinSecondary, G4int shell) const
G4double	SampleCumulative (G4double ekinPrimary, G4int shell) const
	G4DNASamplingTable (const G4DNASamplingTable &copy)=delete
G4DNASamplingTable &	operator= (const G4DNASamplingTable &right)=delete

Detailed Description

Definition at line 38 of file G4DNASamplingTable.hh.

Constructor & Destructor Documentation

◆ G4DNASamplingTable() [1/2]

G4DNASamplingTable::G4DNASamplingTable ( std::size_t npoint )

explicit

Definition at line 39 of file G4DNASamplingTable.cc.

{
  fPrimaryEnergy.reserve(npoints);
  fSecEnergy.reserve(npoints);
  for (G4int i=0; i<5; ++i) { (fPDF[i]).reserve(npoints); }
}

Referenced by G4DNASamplingTable(), and operator=().

◆ ~G4DNASamplingTable()

G4DNASamplingTable::~G4DNASamplingTable ( )

Definition at line 46 of file G4DNASamplingTable.cc.

{
  for (auto & p : fSecEnergy) { delete p; }
  for (G4int i=0; i<5; ++i) {
    for (auto & p : fPDF[i]) { delete p; }
  }
}

◆ G4DNASamplingTable() [2/2]

G4DNASamplingTable::G4DNASamplingTable ( const G4DNASamplingTable & copy )

delete

Member Function Documentation

◆ GetValue()

G4double G4DNASamplingTable::GetValue	(	G4double	ekinPrimary,
		G4double	ekinSecondary,
		G4int	shell ) const

Definition at line 108 of file G4DNASamplingTable.cc.

{
  std::vector<G4double>* e1{nullptr};
  std::vector<G4double>* e2{nullptr};
  std::vector<G4double>* s1{nullptr};
  std::vector<G4double>* s2{nullptr};
  G4int idx = GetIndex(fPrimaryEnergy, ekinPrimary);
  if (idx == -1) {
    e1 = fSecEnergy[0];
    s1 = (fPDF[shell])[0];
  } else if (idx > fNpoints) {
    e1 = fSecEnergy[fNpoints];
    s1 = (fPDF[shell])[fNpoints];
  } else {
    e1 = fSecEnergy[idx];
    s1 = (fPDF[shell])[idx];
    e2 = fSecEnergy[idx + 1];
    s2 = (fPDF[shell])[idx + 1];
  }
  // edge cases
  G4double res1 = VecInterpolation(e1, s1, ekinSec);
  if (nullptr == e2) { return res1; }
 
  // ordinary case
  G4double res2 = VecInterpolation(e2, s2, ekinSec);
  G4double res = Interpolate(fPrimaryEnergy[idx], fPrimaryEnergy[idx + 1],
                 ekinPrimary, res1, res2);
  return res;
}

◆ LoadData()

void G4DNASamplingTable::LoadData	(	const G4String &	filename,
		G4double	factorE,
		G4double	scaleFactor,
		G4bool	verbose )

Definition at line 54 of file G4DNASamplingTable.cc.

{
  std::ostringstream ost;
  ost << G4EmParameters::Instance()->GetDirLEDATA() << "/" << fname;
  std::ifstream fin(ost.str().c_str());
  if (!fin.is_open()) {
    G4ExceptionDescription ed;
    ed << "File <" << ost.str().c_str() << "> is not opened!";
    G4Exception("G4DNASamplingTable::LoadDifferential ", "em0003",
        FatalException, ed, "");
    return;
  }
 
  G4double t, e, sig;
  G4double e0{0.0};
  G4int ntmax{0};
  G4int nt{0};
  std::vector<G4double>* v = nullptr;
  std::vector<G4double>* vPDF[5];
  for (;;) {
    fin >> e;
    if (fin.eof()) { break; }
    if (e != e0 || nullptr == v) {
      fPrimaryEnergy.push_back(e*factE);
      e0 = e;
      ++fNpoints;
      v = new std::vector<G4double>;
      fSecEnergy.push_back(v);
      for (G4int i=0; i<5; ++i) {
        vPDF[i] = new std::vector<G4double>;
        (fPDF[i]).push_back(vPDF[i]);
      }
      ntmax = std::max(ntmax, nt);
      nt = 0;
    }
    fin >> t;
    v->push_back(t*factE);
    ++nt;
    for (G4int i=0; i<5; ++i) {
      fin >> sig;
      sig *= fact;
      (vPDF[i])->push_back(sig);
    }
    if (fin.eof()) { break; }
  }
  if (verbose) {
    G4cout << "G4DNASamplingTable::LoadData from file:" << G4endl;
    G4cout << fname << G4endl;
    G4cout << "    Nenergy= " << fNpoints << " NmaxT= " << ntmax << G4endl;
  }
  if (fNpoints > 0) { --fNpoints; }
}

◆ operator=()

G4DNASamplingTable & G4DNASamplingTable::operator= ( const G4DNASamplingTable & right )