G4ConvergenceTester Class Reference

#include <G4ConvergenceTester.hh>

Public Member Functions
void	AddScore (G4double)
void	ComputeStatistics ()
	G4ConvergenceTester (const G4String &theName="NONAME")
	G4ConvergenceTester (G4double)
G4double	GetEfficiency ()
G4double	GetFOM ()
G4double	GetMean ()
G4double	GetR ()
G4double	GetR2eff ()
G4double	GetR2int ()
G4double	GetShift ()
G4double	GetStandardDeviation ()
G4double	GetValueOfMinimizingFunction (std::vector< G4double > x)
G4double	GetVariance ()
G4double	GetVOV ()
G4ConvergenceTester &	operator+= (G4double val)
void	ShowHistory (std::ostream &out=G4cout)
void	ShowResult (std::ostream &out=G4cout)
	~G4ConvergenceTester ()

Private Member Functions
void	calc_grid_point_of_history ()
G4double	calc_Pearson_r (G4int, std::vector< G4double >, std::vector< G4double >)
void	calc_slope_fit (std::vector< G4double >)
void	calc_stat_history ()
void	calStat ()
void	check_stat_history (std::ostream &out=G4cout)
void	CheckIsUpdated ()
G4bool	is_monotonically_decrease (std::vector< G4double >)
G4double	slope_fitting_function (std::vector< G4double >)

Private Attributes
G4bool	calcSLOPE = true
std::vector< G4double >	cpu_time
std::vector< G4double >	e_history
G4double	efficiency = 0.0
std::vector< G4double >	f_xi
std::vector< G4double >	f_yi
G4double	fom = 0.0
G4double	fom_1 = 0.0
std::vector< G4double >	fom_history
std::vector< G4int >	history_grid
G4double	largest = 0.0
G4int	largest_score_happened = 0
std::vector< G4double >	largest_scores
G4double	mean = 0.0
G4double	mean_1 = 0.0
std::vector< G4double >	mean_history
G4SimplexDownhill< G4ConvergenceTester > *	minimizer = nullptr
G4int	n = 0
G4String	name
G4int	noBinOfHistory = 16
G4int	noBinOfPDF = 10
std::map< G4int, G4double >	nonzero_histories
G4int	noPass = 0
G4int	noTotal = 8
G4double	r = 0.0
G4double	r2eff = 0.0
std::vector< G4double >	r2eff_history
G4double	r2int = 0.0
std::vector< G4double >	r2int_history
G4double	r_1 = 0.0
std::vector< G4double >	r_history
G4double	sd = 0.0
G4double	sd_1 = 0.0
std::vector< G4double >	sd_history
G4double	shift = 0.0
G4double	shift_1 = 0.0
std::vector< G4double >	shift_history
G4bool	showHistory = true
G4double	slope = 0.0
G4bool	statsAreUpdated = true
G4double	sum = 0.0
G4Timer *	timer = nullptr
G4double	var = 0.0
G4double	var_1 = 0.0
std::vector< G4double >	var_history
G4double	vov = 0.0
G4double	vov_1 = 0.0
std::vector< G4double >	vov_history

Detailed Description

Definition at line 54 of file G4ConvergenceTester.hh.

Constructor & Destructor Documentation

G4ConvergenceTester() [1/2]

G4ConvergenceTester::G4ConvergenceTester

(

const G4String &

theName = "NONAME"

)

Definition at line 40 of file G4ConvergenceTester.cc.

  : name(theName)
{
  nonzero_histories.clear();
  largest_scores.clear();
  largest_scores.push_back(0.0);
 
  history_grid.resize(noBinOfHistory, 0);
  mean_history.resize(noBinOfHistory, 0.0);
  var_history.resize(noBinOfHistory, 0.0);
  sd_history.resize(noBinOfHistory, 0.0);
  r_history.resize(noBinOfHistory, 0.0);
  vov_history.resize(noBinOfHistory, 0.0);
  fom_history.resize(noBinOfHistory, 0.0);
  shift_history.resize(noBinOfHistory, 0.0);
  e_history.resize(noBinOfHistory, 0.0);
  r2eff_history.resize(noBinOfHistory, 0.0);
  r2int_history.resize(noBinOfHistory, 0.0);
 
  timer = new G4Timer();
  timer->Start();
  cpu_time.clear();
  cpu_time.push_back(0.0);
}

References cpu_time, e_history, fom_history, history_grid, largest_scores, mean_history, noBinOfHistory, nonzero_histories, r2eff_history, r2int_history, r_history, sd_history, shift_history, G4Timer::Start(), timer, var_history, and vov_history.

~G4ConvergenceTester()

G4ConvergenceTester::~G4ConvergenceTester

(

)

Definition at line 65 of file G4ConvergenceTester.cc.

{
  delete timer;
}

References timer.

G4ConvergenceTester() [2/2]

G4ConvergenceTester::G4ConvergenceTester

(

G4double

)

Member Function Documentation

AddScore()

void G4ConvergenceTester::AddScore

(

G4double

x

)

Definition at line 70 of file G4ConvergenceTester.cc.

{
  G4AutoLock l(&aMutex);
 
  timer->Stop();
  cpu_time.push_back(timer->GetSystemElapsed() + timer->GetUserElapsed());
 
  if(x < 0.0)
  {
    std::ostringstream message;
    message << "Expecting zero or positive number as inputs,\n"
            << "but received a negative number.";
    G4Exception("G4ConvergenceTester::AddScore()", "Warning",
                JustWarning, message);
  }
 
  if(x == 0.0)
  {
  }
  else
  {
    nonzero_histories.insert(std::pair<G4int, G4double>(n, x));
    if(x > largest_scores.back())
    {
      // Following search should become faster if begin from bottom.
      for(auto it = largest_scores.begin(); it != largest_scores.end(); ++it)
      {
        if(x > *it)
        {
          largest_scores.insert(it, x);
          break;
        }
      }
 
      if(largest_scores.size() > 201)
      {
        largest_scores.pop_back();
      }
    }
    sum += x;
  }
 
  // Data has been added so statistics have now been updated to new values
  statsAreUpdated = false;
  ++n;
  l.unlock();
  return;
}

References anonymous_namespace{G4ConvergenceTester.cc}::aMutex, cpu_time, G4Exception(), G4Timer::GetSystemElapsed(), G4Timer::GetUserElapsed(), JustWarning, largest_scores, n, nonzero_histories, statsAreUpdated, G4Timer::Stop(), sum, timer, and G4TemplateAutoLock< _Mutex_t >::unlock().

Referenced by operator+=().

calc_grid_point_of_history()

void G4ConvergenceTester::calc_grid_point_of_history ( )

private

Definition at line 247 of file G4ConvergenceTester.cc.

{
  // histroy_grid [ 0,,,15 ]
  // history_grid [0] 1/16 ,,, history_grid [15] 16/16
  // if number of event is x then history_grid [15] become x-1.
  // 16 -> noBinOfHisotry
 
  for(G4int i = 1; i <= noBinOfHistory; ++i)
  {
    history_grid[i - 1] = G4int(n / (G4double(noBinOfHistory)) * i - 0.1);
  }
}

References history_grid, n, and noBinOfHistory.

Referenced by calStat().

calc_Pearson_r()

G4double G4ConvergenceTester::calc_Pearson_r ( G4int  N, std::vector< G4double >  first_ally, std::vector< G4double >  second_ally  )

private

Definition at line 634 of file G4ConvergenceTester.cc.

{
  G4double first_mean  = 0.0;
  G4double second_mean = 0.0;
 
  G4int i;
  for(i = 0; i < N; i++)
  {
    first_mean += first_ally[i];
    second_mean += second_ally[i];
  }
  first_mean  = first_mean / N;
  second_mean = second_mean / N;
 
  G4double a = 0.0;
  for(i = 0; i < N; ++i)
  {
    a += (first_ally[i] - first_mean) * (second_ally[i] - second_mean);
  }
 
  G4double b1 = 0.0;
  G4double b2 = 0.0;
  for(i = 0; i < N; ++i)
  {
    b1 += (first_ally[i] - first_mean) * (first_ally[i] - first_mean);
    b2 += (second_ally[i] - second_mean) * (second_ally[i] - second_mean);
  }
 
  G4double rds = a / std::sqrt(b1 * b2);
 
  return rds;
}

Referenced by check_stat_history().

calc_slope_fit()

void G4ConvergenceTester::calc_slope_fit ( std::vector< G4double >  )

private

Definition at line 682 of file G4ConvergenceTester.cc.

{
  // create PDF bins
  G4double max = largest_scores.front();
  G4int last   = G4int(largest_scores.size());
  G4double min = 0.0;
  if(largest_scores.back() != 0)
  {
    min = largest_scores.back();
  }
  else
  {
    min  = largest_scores[last - 1];
    last = last - 1;
  }
 
  if(max * 0.99 < min)
  {
    // upper limit is assumed to have been reached
    slope = 10.0;
    return;
  }
 
  std::vector<G4double> pdf_grid;
 
  pdf_grid.resize(noBinOfPDF + 1);  // no grid  = no bins + 1
  pdf_grid[0]          = max;
  pdf_grid[noBinOfPDF] = min;
  G4double log10_max   = std::log10(max);
  G4double log10_min   = std::log10(min);
  G4double log10_delta = log10_max - log10_min;
  for(G4int i = 1; i < noBinOfPDF; ++i)
  {
    pdf_grid[i] = std::pow(10.0, log10_max - log10_delta / 10.0 * (i));
  }
 
  std::vector<G4double> pdf;
  pdf.resize(noBinOfPDF);
 
  for(G4int j = 0; j < last; ++j)
  {
    for(G4int i = 0; i < 11; ++i)
    {
      if(largest_scores[j] >= pdf_grid[i + 1])
      {
        pdf[i] += 1.0 / (pdf_grid[i] - pdf_grid[i + 1]) / n;
        break;
      }
    }
  }
 
  f_xi.resize(noBinOfPDF);
  f_yi.resize(noBinOfPDF);
  for(G4int i = 0; i < noBinOfPDF; ++i)
  {
    f_xi[i] = (pdf_grid[i] + pdf_grid[i + 1]) / 2;
    f_yi[i] = pdf[i];
  }
 
  // number of variables ( a and k )
  minimizer = new G4SimplexDownhill<G4ConvergenceTester>(this, 2);
  // G4double minimum =  minimizer->GetMinimum();
  std::vector<G4double> mp = minimizer->GetMinimumPoint();
  G4double k               = mp[1];
 
  // G4cout << "SLOPE " << 1/mp[1]+1 << G4endl;
  // G4cout << "SLOPE  a " << mp[0] << G4endl;
  // G4cout << "SLOPE  k " << mp[1] << G4endl;
  // G4cout << "SLOPE  minimum " << minimizer->GetMinimum() << G4endl;
 
  slope = 1 / mp[1] + 1;
  if(k < 1.0 / 9)  // Please look Pareto distribution with "sigma=a" and "k"
  {
    slope = 10;
  }
  if(slope > 10)
  {
    slope = 10;
  }
}

References f_xi, f_yi, G4SimplexDownhill< T >::GetMinimumPoint(), largest_scores, G4INCL::Math::max(), G4INCL::Math::min(), minimizer, n, noBinOfPDF, and slope.

Referenced by calStat().

calc_stat_history()

void G4ConvergenceTester::calc_stat_history ( )

private

Definition at line 260 of file G4ConvergenceTester.cc.

{
  if(history_grid[0] == 0)
  {
    showHistory = false;
    return;
  }
 
  for(G4int i = 0; i < noBinOfHistory; ++i)
  {
    G4int ith = history_grid[i];
 
    G4int nonzero_till_ith = 0;
    G4double xi;
    G4double mean_till_ith = 0.0;
 
    for(const auto& itr : nonzero_histories)
    {
      if(itr.first <= ith)
      {
        xi = itr.second;
        mean_till_ith += xi;
        ++nonzero_till_ith;
      }
    }
 
    if(nonzero_till_ith == 0)
      continue;
 
    mean_till_ith   = mean_till_ith / (ith + 1);
    mean_history[i] = mean_till_ith;
 
    G4double sum_x2_till_ith = 0.0;
    G4double var_till_ith    = 0.0;
    G4double vov_till_ith    = 0.0;
    G4double shift_till_ith  = 0.0;
 
    for(const auto& itr : nonzero_histories)
    {
      if(itr.first <= ith)
      {
        xi = itr.second;
        sum_x2_till_ith += std::pow(xi, 2.0);
        var_till_ith += std::pow(xi - mean_till_ith, 2.0);
        shift_till_ith += std::pow(xi - mean_till_ith, 3.0);
        vov_till_ith += std::pow(xi - mean_till_ith, 4.0);
      }
    }
 
    var_till_ith +=
      ((ith + 1) - nonzero_till_ith) * std::pow(mean_till_ith, 2.0);
    vov_till_ith +=
      ((ith + 1) - nonzero_till_ith) * std::pow(mean_till_ith, 4.0);
 
    G4double sum_till_ith = mean_till_ith * (ith + 1);
 
    if(!(std::fabs(var_till_ith) > 0.0))
      continue;
    if(!(std::fabs(mean_till_ith) > 0.0))
      continue;
    if(!(std::fabs(sum_till_ith) > 0.0))
      continue;
 
    vov_till_ith = vov_till_ith / std::pow(var_till_ith, 2.0) - 1.0 / (ith + 1);
    vov_history[i] = vov_till_ith;
 
    var_till_ith   = var_till_ith / (ith + 1 - 1);
    var_history[i] = var_till_ith;
    sd_history[i]  = std::sqrt(var_till_ith);
    r_history[i] =
      std::sqrt(var_till_ith) / mean_till_ith / std::sqrt(1.0 * (ith + 1));
 
    if(std::fabs(cpu_time[ith]) > 0.0 && std::fabs(r_history[i]) > 0.0)
    {
      fom_history[i] = 1.0 / std::pow(r_history[i], 2.0) / cpu_time[ith];
    }
    else
    {
      fom_history[i] = 0.0;
    }
 
    shift_till_ith +=
      ((ith + 1) - nonzero_till_ith) * std::pow(mean_till_ith, 3.0) * (-1.0);
    shift_till_ith   = shift_till_ith / (2 * var_till_ith * (ith + 1));
    shift_history[i] = shift_till_ith;
 
    e_history[i] = 1.0 * nonzero_till_ith / (ith + 1);
    if(std::fabs(e_history[i]) > 0.0)
    {
      r2eff_history[i] = (1 - e_history[i]) / (e_history[i] * (ith + 1));
 
      r2int_history[i] = (sum_x2_till_ith) / std::pow(sum_till_ith, 2.0) -
                         1 / (e_history[i] * (ith + 1));
    }
  }
}

References cpu_time, e_history, fom_history, history_grid, mean_history, noBinOfHistory, nonzero_histories, r2eff_history, r2int_history, r_history, sd_history, shift_history, showHistory, var_history, and vov_history.

Referenced by calStat().

calStat()

void G4ConvergenceTester::calStat ( )

private

Definition at line 119 of file G4ConvergenceTester.cc.

{
  efficiency = G4double(nonzero_histories.size()) / n;
 
  mean = sum / n;
 
  G4double sum_x2 = 0.0;
  var             = 0.0;
  shift           = 0.0;
  vov             = 0.0;
 
  G4double xi;
  for(auto it = nonzero_histories.cbegin(); it != nonzero_histories.cend();
      ++it)
  {
    xi = it->second;
    sum_x2 += xi * xi;
    var += (xi - mean) * (xi - mean);
    shift += (xi - mean) * (xi - mean) * (xi - mean);
    vov += (xi - mean) * (xi - mean) * (xi - mean) * (xi - mean);
  }
 
  var += (n - nonzero_histories.size()) * mean * mean;
  shift += (n - nonzero_histories.size()) * mean * mean * mean * (-1);
  vov += (n - nonzero_histories.size()) * mean * mean * mean * mean;
 
  if(var != 0.0)
  {
    vov = vov / (var * var) - 1.0 / n;
 
    var = var / (n - 1);
 
    sd = std::sqrt(var);
 
    r = sd / mean / std::sqrt(G4double(n));
 
    r2eff = (1 - efficiency) / (efficiency * n);
    r2int = sum_x2 / (sum * sum) - 1 / (efficiency * n);
 
    shift = shift / (2 * var * n);
 
    fom = 1 / (r * r) / cpu_time.back();
  }
 
  // Find Largest History
  // G4double largest = 0.0;
  largest                        = 0.0;
  largest_score_happened         = 0;
  G4double spend_time_of_largest = 0.0;
  for(auto it = nonzero_histories.cbegin(); it != nonzero_histories.cend();
      ++it)
  {
    if(std::abs(it->second) > largest)
    {
      largest                = it->second;
      largest_score_happened = it->first;
      spend_time_of_largest  = cpu_time[it->first + 1] - cpu_time[it->first];
    }
  }
 
  mean_1  = 0.0;
  var_1   = 0.0;
  shift_1 = 0.0;
  vov_1   = 0.0;
  sd_1    = 0.0;
  r_1     = 0.0;
  vov_1   = 0.0;
 
  mean_1 = (sum + largest) / (n + 1);
 
  for(auto it = nonzero_histories.cbegin(); it != nonzero_histories.cend();
      ++it)
  {
    xi = it->second;
    var_1 += (xi - mean_1) * (xi - mean_1);
    shift_1 += (xi - mean_1) * (xi - mean_1) * (xi - mean_1);
    vov_1 += (xi - mean_1) * (xi - mean_1) * (xi - mean_1) * (xi - mean_1);
  }
  xi = largest;
  var_1 += (xi - mean_1) * (xi - mean_1);
  shift_1 += (xi - mean_1) * (xi - mean_1) * (xi - mean_1);
  vov_1 += (xi - mean_1) * (xi - mean_1) * (xi - mean_1) * (xi - mean_1);
 
  var_1 += (n - nonzero_histories.size()) * mean_1 * mean_1;
 
  if(var_1 != 0.0)
  {
    shift_1 += (n - nonzero_histories.size()) * mean_1 * mean_1 * mean_1 * (-1);
    vov_1 += (n - nonzero_histories.size()) * mean_1 * mean_1 * mean_1 * mean_1;
 
    vov_1 = vov_1 / (var_1 * var_1) - 1.0 / (n + 1);
 
    var_1 = var_1 / n;
 
    sd_1 = std::sqrt(var_1);
 
    r_1 = sd_1 / mean_1 / std::sqrt(G4double(n + 1));
 
    shift_1 = shift_1 / (2 * var_1 * (n + 1));
 
    fom_1 = 1 / (r * r) / (cpu_time.back() + spend_time_of_largest);
  }
 
  if(nonzero_histories.size() < 500)
  {
    calcSLOPE = false;
  }
  else
  {
    G4int i = G4int(nonzero_histories.size());
 
    // 5% criterion
    G4int j = G4int(i * 0.05);
    while(G4int(largest_scores.size()) > j)
    {
      largest_scores.pop_back();
    }
    calc_slope_fit(largest_scores);
  }
 
  calc_grid_point_of_history();
  calc_stat_history();
 
  // statistics have been calculated and this function does not need
  // to be called again until data has been added
  statsAreUpdated = true;
}

References calc_grid_point_of_history(), calc_slope_fit(), calc_stat_history(), calcSLOPE, cpu_time, efficiency, fom, fom_1, largest, largest_score_happened, largest_scores, mean, mean_1, n, nonzero_histories, r, r2eff, r2int, r_1, sd, sd_1, shift, shift_1, statsAreUpdated, sum, var, var_1, vov, and vov_1.

Referenced by CheckIsUpdated(), ComputeStatistics(), and ShowResult().

check_stat_history()

void G4ConvergenceTester::check_stat_history ( std::ostream &  out = G4cout )

private

Definition at line 496 of file G4ConvergenceTester.cc.

{
  // 1 sigma rejection for null hypothesis
 
  std::vector<G4double> first_ally;
  std::vector<G4double> second_ally;
 
  // use 2nd half of hisories
  G4int N = mean_history.size() / 2;
  G4int i;
 
  G4double pearson_r;
  G4double t;
 
  first_ally.resize(N);
  second_ally.resize(N);
 
  G4double sum_of_var =
    std::accumulate(var_history.begin(), var_history.end(), 0.0);
  if(sum_of_var == 0.0)
  {
    out << "Variances in all historical grids are zero." << G4endl;
    out << "Terminating checking behavior of statistics numbers." << G4endl;
    return;
  }
 
  // Mean
 
  for(i = 0; i < N; ++i)
  {
    first_ally[i]  = history_grid[N + i];
    second_ally[i] = mean_history[N + i];
  }
 
  pearson_r = calc_Pearson_r(N, first_ally, second_ally);
  t         = pearson_r * std::sqrt((N - 2) / (1 - pearson_r * pearson_r));
 
  if(t < 0.429318)  // Student t of (Degree of freedom = N-2 )
  {
    out << "MEAN distribution is  RANDOM" << G4endl;
    noPass++;
  }
  else
  {
    out << "MEAN distribution is not RANDOM" << G4endl;
  }
 
  // R
 
  for(i = 0; i < N; ++i)
  {
    first_ally[i]  = 1.0 / std::sqrt(G4double(history_grid[N + i]));
    second_ally[i] = r_history[N + i];
  }
 
  pearson_r = calc_Pearson_r(N, first_ally, second_ally);
  t         = pearson_r * std::sqrt((N - 2) / (1 - pearson_r * pearson_r));
 
  if(t > 1.090546)
  {
    out << "r follows 1/std::sqrt(N)" << G4endl;
    noPass++;
  }
  else
  {
    out << "r does not follow 1/std::sqrt(N)" << G4endl;
  }
 
  if(is_monotonically_decrease(second_ally) == true)
  {
    out << "r is monotonically decrease " << G4endl;
  }
  else
  {
    out << "r is NOT monotonically decrease " << G4endl;
  }
 
  if(r_history.back() < 0.1)
  {
    out << "r is less than 0.1. r = " << r_history.back() << G4endl;
    noPass++;
  }
  else
  {
    out << "r is NOT less than 0.1. r = " << r_history.back() << G4endl;
  }
 
  // VOV
  for(i = 0; i < N; ++i)
  {
    first_ally[i]  = 1.0 / history_grid[N + i];
    second_ally[i] = vov_history[N + i];
  }
 
  pearson_r = calc_Pearson_r(N, first_ally, second_ally);
  t         = pearson_r * std::sqrt((N - 2) / (1 - pearson_r * pearson_r));
 
  if(t > 1.090546)
  {
    out << "VOV follows 1/std::sqrt(N)" << G4endl;
    noPass++;
  }
  else
  {
    out << "VOV does not follow 1/std::sqrt(N)" << G4endl;
  }
 
  if(is_monotonically_decrease(second_ally) == true)
  {
    out << "VOV is monotonically decrease " << G4endl;
  }
  else
  {
    out << "VOV is NOT monotonically decrease " << G4endl;
  }
 
  // FOM
 
  for(i = 0; i < N; ++i)
  {
    first_ally[i]  = history_grid[N + i];
    second_ally[i] = fom_history[N + i];
  }
 
  pearson_r = calc_Pearson_r(N, first_ally, second_ally);
  t         = pearson_r * std::sqrt((N - 2) / (1 - pearson_r * pearson_r));
 
  if(t < 0.429318)
  {
    out << "FOM distribution is RANDOM" << G4endl;
    noPass++;
  }
  else
  {
    out << "FOM distribution is not RANDOM" << G4endl;
  }
}

References calc_Pearson_r(), fom_history, G4endl, history_grid, is_monotonically_decrease(), mean_history, noPass, r_history, var_history, and vov_history.

Referenced by ShowResult().

CheckIsUpdated()

void G4ConvergenceTester::CheckIsUpdated ( )

inlineprivate

Definition at line 103 of file G4ConvergenceTester.hh.

    {
      if(!statsAreUpdated) { calStat(); }
    }

References calStat(), and statsAreUpdated.

Referenced by GetEfficiency(), GetFOM(), GetMean(), GetR(), GetR2eff(), GetR2int(), GetShift(), GetStandardDeviation(), GetVariance(), and GetVOV().

ComputeStatistics()

void G4ConvergenceTester::ComputeStatistics ( )

inline

Definition at line 79 of file G4ConvergenceTester.hh.

{ calStat(); }

References calStat().

GetEfficiency()

G4double G4ConvergenceTester::GetEfficiency ( )

inline

Definition at line 88 of file G4ConvergenceTester.hh.

{ CheckIsUpdated(); return efficiency; }

References CheckIsUpdated(), and efficiency.

GetFOM()

G4double G4ConvergenceTester::GetFOM ( )

inline

Definition at line 93 of file G4ConvergenceTester.hh.

{ CheckIsUpdated(); return fom; }

References CheckIsUpdated(), and fom.

GetMean()

G4double G4ConvergenceTester::GetMean ( )

inline

Definition at line 84 of file G4ConvergenceTester.hh.

{ CheckIsUpdated(); return mean; }

References CheckIsUpdated(), and mean.

GetR()

G4double G4ConvergenceTester::GetR ( )

inline

Definition at line 87 of file G4ConvergenceTester.hh.

{ CheckIsUpdated(); return r; }

References CheckIsUpdated(), and r.

GetR2eff()

G4double G4ConvergenceTester::GetR2eff ( )

inline

Definition at line 89 of file G4ConvergenceTester.hh.

{ CheckIsUpdated(); return r2eff; }

References CheckIsUpdated(), and r2eff.

GetR2int()

G4double G4ConvergenceTester::GetR2int ( )

inline

Definition at line 90 of file G4ConvergenceTester.hh.

{ CheckIsUpdated(); return r2int; }

References CheckIsUpdated(), and r2int.

GetShift()

G4double G4ConvergenceTester::GetShift ( )

inline

Definition at line 91 of file G4ConvergenceTester.hh.

{ CheckIsUpdated(); return shift; }

References CheckIsUpdated(), and shift.

GetStandardDeviation()

G4double G4ConvergenceTester::GetStandardDeviation ( )

inline

Definition at line 85 of file G4ConvergenceTester.hh.

{ CheckIsUpdated(); return sd; }

References CheckIsUpdated(), and sd.

GetValueOfMinimizingFunction()

G4double G4ConvergenceTester::GetValueOfMinimizingFunction ( std::vector< G4double >  x )

inline

Definition at line 74 of file G4ConvergenceTester.hh.

    {
      return slope_fitting_function(x);
    }

References slope_fitting_function().

GetVariance()

G4double G4ConvergenceTester::GetVariance ( )

inline

Definition at line 86 of file G4ConvergenceTester.hh.

{ CheckIsUpdated(); return var; }

References CheckIsUpdated(), and var.

GetVOV()

G4double G4ConvergenceTester::GetVOV ( )

inline

Definition at line 92 of file G4ConvergenceTester.hh.

{ CheckIsUpdated(); return vov; }

References CheckIsUpdated(), and vov.

is_monotonically_decrease()

G4bool G4ConvergenceTester::is_monotonically_decrease ( std::vector< G4double >  ally )

private

Definition at line 669 of file G4ConvergenceTester.cc.

{
  for(auto it = ally.cbegin(); it != ally.cend() - 1; ++it)
  {
    if(*it < *(it + 1))
      return FALSE;
  }
 
  ++noPass;
  return TRUE;
}

References FALSE, noPass, and TRUE.

Referenced by check_stat_history().

operator+=()

G4ConvergenceTester & G4ConvergenceTester::operator+= ( G4double  val )

inline

Definition at line 64 of file G4ConvergenceTester.hh.

    {
      this->AddScore(val);
      return *this;
    }

References AddScore().

ShowHistory()

void G4ConvergenceTester::ShowHistory

(

std::ostream &

out = G4cout

)

Definition at line 465 of file G4ConvergenceTester.cc.

{
  if(!showHistory)
  {
    out << "Number of events of this run is too small to show history."
        << G4endl;
    return;
  }
 
  out << std::setprecision(6);
 
  out << G4endl;
  out << "G4ConvergenceTester Output History of " << name << G4endl;
  out << "i/" << noBinOfHistory << " till_ith      mean" << std::setw(13)
      << "var" << std::setw(13) << "sd" << std::setw(13) << "r" << std::setw(13)
      << "vov" << std::setw(13) << "fom" << std::setw(13) << "shift"
      << std::setw(13) << "e" << std::setw(13) << "r2eff" << std::setw(13)
      << "r2int" << G4endl;
  for(G4int i = 1; i <= noBinOfHistory; i++)
  {
    out << std::setw(4) << i << " " << std::setw(5) << history_grid[i - 1]
        << std::setw(13) << mean_history[i - 1] << std::setw(13)
        << var_history[i - 1] << std::setw(13) << sd_history[i - 1]
        << std::setw(13) << r_history[i - 1] << std::setw(13)
        << vov_history[i - 1] << std::setw(13) << fom_history[i - 1]
        << std::setw(13) << shift_history[i - 1] << std::setw(13)
        << e_history[i - 1] << std::setw(13) << r2eff_history[i - 1]
        << std::setw(13) << r2int_history[i - 1] << G4endl;
  }
}

References e_history, fom_history, G4endl, history_grid, mean_history, name, noBinOfHistory, r2eff_history, r2int_history, r_history, sd_history, shift_history, showHistory, var_history, and vov_history.

ShowResult()

void G4ConvergenceTester::ShowResult

(

std::ostream &

out = G4cout

)

Definition at line 357 of file G4ConvergenceTester.cc.

{
  // if data has been added since the last computation of the statistical values
  // (not statsAreUpdated) call calStat to recompute the statistical values
  if(!statsAreUpdated)
  {
    calStat();
  }
 
  out << std::setprecision(6);
 
  out << G4endl;
  out << "G4ConvergenceTester Output Result of " << name << G4endl;
  out << std::setw(20) << "EFFICIENCY = " << std::setw(13) << efficiency
      << G4endl;
  out << std::setw(20) << "MEAN = " << std::setw(13) << mean << G4endl;
  out << std::setw(20) << "VAR = " << std::setw(13) << var << G4endl;
  out << std::setw(20) << "SD = " << std::setw(13) << sd << G4endl;
  out << std::setw(20) << "R = " << std::setw(13) << r << G4endl;
  out << std::setw(20) << "SHIFT = " << std::setw(13) << shift << G4endl;
  out << std::setw(20) << "VOV = " << std::setw(13) << vov << G4endl;
  out << std::setw(20) << "FOM = " << std::setw(13) << fom << G4endl;
 
  out << std::setw(20) << "THE LARGEST SCORE = " << std::setw(13) << largest
      << " and it happened at " << largest_score_happened << "th event"
      << G4endl;
  if(mean != 0)
  {
    out << std::setw(20) << "Affected Mean = " << std::setw(13) << mean_1
        << " and its ratio to original is " << mean_1 / mean << G4endl;
  }
  else
  {
    out << std::setw(20) << "Affected Mean = " << std::setw(13) << mean_1
        << G4endl;
  }
  if(var != 0)
  {
    out << std::setw(20) << "Affected VAR = " << std::setw(13) << var_1
        << " and its ratio to original is " << var_1 / var << G4endl;
  }
  else
  {
    out << std::setw(20) << "Affected VAR = " << std::setw(13) << var_1
        << G4endl;
  }
  if(r != 0)
  {
    out << std::setw(20) << "Affected R = " << std::setw(13) << r_1
        << " and its ratio to original is " << r_1 / r << G4endl;
  }
  else
  {
    out << std::setw(20) << "Affected R = " << std::setw(13) << r_1 << G4endl;
  }
  if(shift != 0)
  {
    out << std::setw(20) << "Affected SHIFT = " << std::setw(13) << shift_1
        << " and its ratio to original is " << shift_1 / shift << G4endl;
  }
  else
  {
    out << std::setw(20) << "Affected SHIFT = " << std::setw(13) << shift_1
        << G4endl;
  }
  if(fom != 0)
  {
    out << std::setw(20) << "Affected FOM = " << std::setw(13) << fom_1
        << " and its ratio to original is " << fom_1 / fom << G4endl;
  }
  else
  {
    out << std::setw(20) << "Affected FOM = " << std::setw(13) << fom_1
        << G4endl;
  }
 
  if(!showHistory)
  {
    out << "Number of events of this run is too small to do convergence tests."
        << G4endl;
    return;
  }
 
  check_stat_history(out);
 
  // check SLOPE and output result
  if(calcSLOPE)
  {
    if(slope >= 3)
    {
      noPass++;
      out << "SLOPE is large enough" << G4endl;
    }
    else
    {
      out << "SLOPE is not large enough" << G4endl;
    }
  }
  else
  {
    out << "Number of non zero history too small to calculate SLOPE" << G4endl;
  }
 
  out << "This result passes " << noPass << " / " << noTotal
      << " Convergence Test." << G4endl;
  out << G4endl;
}

References calcSLOPE, calStat(), check_stat_history(), efficiency, fom, fom_1, G4endl, largest, largest_score_happened, mean, mean_1, name, noPass, noTotal, r, r_1, sd, shift, shift_1, showHistory, slope, statsAreUpdated, var, var_1, and vov.

slope_fitting_function()

G4double G4ConvergenceTester::slope_fitting_function ( std::vector< G4double >  x )

private

Definition at line 763 of file G4ConvergenceTester.cc.

{
  G4double a = x[0];
  G4double k = x[1];
 
  if(a <= 0)
  {
    return 3.402823466e+38;  // FLOAT_MAX
  }
  if(k == 0)
  {
    return 3.402823466e+38;  // FLOAT_MAX
  }
 
  // f_xi and f_yi is filled at "calc_slope_fit"
 
  G4double y = 0.0;
  for(G4int i = 0; i < G4int(f_yi.size()); ++i)
  {
    // if ( 1/a * ( 1 + k * f_xi [ i ] / a ) < 0 )
    if((1 + k * f_xi[i] / a) < 0)
    {
      y += 3.402823466e+38;  // FLOAT_MAX
    }
    else
    {
      y += (f_yi[i] - 1 / a * std::pow(1 + k * f_xi[i] / a, -1 / k - 1)) *
           (f_yi[i] - 1 / a * std::pow(1 + k * f_xi[i] / a, -1 / k - 1));
    }
  }
 
  return y;
}

References f_xi, and f_yi.

Referenced by GetValueOfMinimizingFunction().

Field Documentation

calcSLOPE

G4bool G4ConvergenceTester::calcSLOPE = true

private

Definition at line 173 of file G4ConvergenceTester.hh.

Referenced by calStat(), and ShowResult().

cpu_time

std::vector<G4double> G4ConvergenceTester::cpu_time

private

Definition at line 124 of file G4ConvergenceTester.hh.

Referenced by AddScore(), calc_stat_history(), calStat(), and G4ConvergenceTester().

e_history

std::vector<G4double> G4ConvergenceTester::e_history

private

Definition at line 157 of file G4ConvergenceTester.hh.

Referenced by calc_stat_history(), G4ConvergenceTester(), and ShowHistory().

efficiency

G4double G4ConvergenceTester::efficiency = 0.0

private

Definition at line 130 of file G4ConvergenceTester.hh.

Referenced by calStat(), GetEfficiency(), and ShowResult().

f_xi

std::vector<G4double> G4ConvergenceTester::f_xi

private

Definition at line 163 of file G4ConvergenceTester.hh.

Referenced by calc_slope_fit(), and slope_fitting_function().

f_yi

std::vector<G4double> G4ConvergenceTester::f_yi

private

Definition at line 164 of file G4ConvergenceTester.hh.

Referenced by calc_slope_fit(), and slope_fitting_function().

fom

G4double G4ConvergenceTester::fom = 0.0

private

Definition at line 135 of file G4ConvergenceTester.hh.

Referenced by calStat(), GetFOM(), and ShowResult().

fom_1

G4double G4ConvergenceTester::fom_1 = 0.0

private

Definition at line 146 of file G4ConvergenceTester.hh.

Referenced by calStat(), and ShowResult().

fom_history

std::vector<G4double> G4ConvergenceTester::fom_history

private

Definition at line 155 of file G4ConvergenceTester.hh.

Referenced by calc_stat_history(), check_stat_history(), G4ConvergenceTester(), and ShowHistory().

history_grid

std::vector<G4int> G4ConvergenceTester::history_grid

private

Definition at line 149 of file G4ConvergenceTester.hh.

Referenced by calc_grid_point_of_history(), calc_stat_history(), check_stat_history(), G4ConvergenceTester(), and ShowHistory().

largest

G4double G4ConvergenceTester::largest = 0.0

private

Definition at line 137 of file G4ConvergenceTester.hh.

Referenced by calStat(), and ShowResult().

largest_score_happened

G4int G4ConvergenceTester::largest_score_happened = 0

private

Definition at line 138 of file G4ConvergenceTester.hh.

Referenced by calStat(), and ShowResult().

largest_scores

std::vector<G4double> G4ConvergenceTester::largest_scores

private

Definition at line 162 of file G4ConvergenceTester.hh.

Referenced by AddScore(), calc_slope_fit(), calStat(), and G4ConvergenceTester().

mean

G4double G4ConvergenceTester::mean = 0.0

private

Definition at line 126 of file G4ConvergenceTester.hh.

Referenced by calStat(), GetMean(), and ShowResult().

mean_1

G4double G4ConvergenceTester::mean_1 = 0.0

private

Definition at line 140 of file G4ConvergenceTester.hh.

Referenced by calStat(), and ShowResult().

mean_history

std::vector<G4double> G4ConvergenceTester::mean_history

private

Definition at line 150 of file G4ConvergenceTester.hh.

Referenced by calc_stat_history(), check_stat_history(), G4ConvergenceTester(), and ShowHistory().

minimizer

G4SimplexDownhill<G4ConvergenceTester>* G4ConvergenceTester::minimizer = nullptr

private

Definition at line 166 of file G4ConvergenceTester.hh.

Referenced by calc_slope_fit().

n

G4int G4ConvergenceTester::n = 0

private

Definition at line 120 of file G4ConvergenceTester.hh.

Referenced by AddScore(), calc_grid_point_of_history(), calc_slope_fit(), and calStat().

name

G4String G4ConvergenceTester::name

private

Definition at line 118 of file G4ConvergenceTester.hh.

Referenced by source.g4viscp.G4Scene::create_scene(), mcscore.MCParticle::printout(), ShowHistory(), ShowResult(), and source.g4viscp.G4Scene::update_scene().

noBinOfHistory

G4int G4ConvergenceTester::noBinOfHistory = 16

private

Definition at line 148 of file G4ConvergenceTester.hh.

Referenced by calc_grid_point_of_history(), calc_stat_history(), G4ConvergenceTester(), and ShowHistory().

noBinOfPDF

G4int G4ConvergenceTester::noBinOfPDF = 10

private

Definition at line 165 of file G4ConvergenceTester.hh.

Referenced by calc_slope_fit().

nonzero_histories

std::map<G4int, G4double> G4ConvergenceTester::nonzero_histories

private

Definition at line 119 of file G4ConvergenceTester.hh.

Referenced by AddScore(), calc_stat_history(), calStat(), and G4ConvergenceTester().

noPass

G4int G4ConvergenceTester::noPass = 0

private

Definition at line 168 of file G4ConvergenceTester.hh.

Referenced by check_stat_history(), is_monotonically_decrease(), and ShowResult().

noTotal

G4int G4ConvergenceTester::noTotal = 8

private

Definition at line 169 of file G4ConvergenceTester.hh.

Referenced by ShowResult().

r

G4double G4ConvergenceTester::r = 0.0

private

Definition at line 129 of file G4ConvergenceTester.hh.

Referenced by calStat(), GetR(), and ShowResult().

r2eff

G4double G4ConvergenceTester::r2eff = 0.0

private

Definition at line 131 of file G4ConvergenceTester.hh.

Referenced by calStat(), and GetR2eff().

r2eff_history

std::vector<G4double> G4ConvergenceTester::r2eff_history

private

Definition at line 158 of file G4ConvergenceTester.hh.

Referenced by calc_stat_history(), G4ConvergenceTester(), and ShowHistory().

r2int

G4double G4ConvergenceTester::r2int = 0.0

private

Definition at line 132 of file G4ConvergenceTester.hh.

Referenced by calStat(), and GetR2int().

r2int_history

std::vector<G4double> G4ConvergenceTester::r2int_history

private

Definition at line 159 of file G4ConvergenceTester.hh.

Referenced by calc_stat_history(), G4ConvergenceTester(), and ShowHistory().

r_1

G4double G4ConvergenceTester::r_1 = 0.0

private

Definition at line 143 of file G4ConvergenceTester.hh.

Referenced by calStat(), and ShowResult().

r_history

std::vector<G4double> G4ConvergenceTester::r_history

private

Definition at line 153 of file G4ConvergenceTester.hh.

Referenced by calc_stat_history(), check_stat_history(), G4ConvergenceTester(), and ShowHistory().

sd

G4double G4ConvergenceTester::sd = 0.0

private

Definition at line 128 of file G4ConvergenceTester.hh.

Referenced by calStat(), GetStandardDeviation(), and ShowResult().

sd_1

G4double G4ConvergenceTester::sd_1 = 0.0

private

Definition at line 142 of file G4ConvergenceTester.hh.

Referenced by calStat().

sd_history

std::vector<G4double> G4ConvergenceTester::sd_history

private

Definition at line 152 of file G4ConvergenceTester.hh.

Referenced by calc_stat_history(), G4ConvergenceTester(), and ShowHistory().

shift

G4double G4ConvergenceTester::shift = 0.0

private

Definition at line 133 of file G4ConvergenceTester.hh.

Referenced by calStat(), GetShift(), and ShowResult().

shift_1

G4double G4ConvergenceTester::shift_1 = 0.0

private

Definition at line 144 of file G4ConvergenceTester.hh.

Referenced by calStat(), and ShowResult().

shift_history

std::vector<G4double> G4ConvergenceTester::shift_history

private

Definition at line 156 of file G4ConvergenceTester.hh.

Referenced by calc_stat_history(), G4ConvergenceTester(), and ShowHistory().

showHistory

G4bool G4ConvergenceTester::showHistory = true

private

Definition at line 172 of file G4ConvergenceTester.hh.

Referenced by calc_stat_history(), ShowHistory(), and ShowResult().

slope

G4double G4ConvergenceTester::slope = 0.0

private

Definition at line 161 of file G4ConvergenceTester.hh.

Referenced by calc_slope_fit(), and ShowResult().

statsAreUpdated

G4bool G4ConvergenceTester::statsAreUpdated = true

private

Definition at line 171 of file G4ConvergenceTester.hh.

Referenced by AddScore(), calStat(), CheckIsUpdated(), and ShowResult().

sum

G4double G4ConvergenceTester::sum = 0.0

private

Definition at line 121 of file G4ConvergenceTester.hh.

Referenced by AddScore(), and calStat().

timer

G4Timer* G4ConvergenceTester::timer = nullptr

private

Definition at line 123 of file G4ConvergenceTester.hh.

Referenced by AddScore(), G4ConvergenceTester(), and ~G4ConvergenceTester().

var

G4double G4ConvergenceTester::var = 0.0

private

Definition at line 127 of file G4ConvergenceTester.hh.

Referenced by calStat(), GetVariance(), and ShowResult().

var_1

G4double G4ConvergenceTester::var_1 = 0.0

private

Definition at line 141 of file G4ConvergenceTester.hh.

Referenced by calStat(), and ShowResult().

var_history

std::vector<G4double> G4ConvergenceTester::var_history

private

Definition at line 151 of file G4ConvergenceTester.hh.

Referenced by calc_stat_history(), check_stat_history(), G4ConvergenceTester(), and ShowHistory().

vov

G4double G4ConvergenceTester::vov = 0.0

private

Definition at line 134 of file G4ConvergenceTester.hh.

Referenced by calStat(), GetVOV(), and ShowResult().

vov_1

G4double G4ConvergenceTester::vov_1 = 0.0

private

Definition at line 145 of file G4ConvergenceTester.hh.

Referenced by calStat().

vov_history

std::vector<G4double> G4ConvergenceTester::vov_history

private

Definition at line 154 of file G4ConvergenceTester.hh.

Referenced by calc_stat_history(), check_stat_history(), G4ConvergenceTester(), and ShowHistory().

---

The documentation for this class was generated from the following files:

• source/global/HEPNumerics/include/G4ConvergenceTester.hh
• source/global/HEPNumerics/src/G4ConvergenceTester.cc