G4ConvergenceTester Class Reference

#include <G4ConvergenceTester.hh>

Collaboration diagram for G4ConvergenceTester:

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

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

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

Detailed Description

Definition at line 58 of file G4ConvergenceTester.hh.

Constructor & Destructor Documentation

G4ConvergenceTester() [1/2]

G4ConvergenceTester::G4ConvergenceTester

(

G4String

theName = "NONAME"

)

Definition at line 46 of file G4ConvergenceTester.cc.

 : name(theName), n(0), sum(0.), mean(0.), var(0.), sd(0.), r(0.), efficiency(0.),
   r2eff(0.), r2int(0.), shift(0.), vov(0.), fom(0.), largest(0.),
   largest_score_happened(0), mean_1(0.), var_1(0.), sd_1(0.), r_1(0.),
   shift_1(0.), vov_1(0.), fom_1(0.), noBinOfHistory(16), slope(0.),
   noBinOfPDF(10), minimizer(0), noPass(0), noTotal(8), statsAreUpdated(true)
   , showHistory(true) , calcSLOPE(true)
{
   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 );
}

Here is the call graph for this function:

~G4ConvergenceTester()

G4ConvergenceTester::~G4ConvergenceTester

(

)

Definition at line 78 of file G4ConvergenceTester.cc.

{
   delete timer;
}

G4ConvergenceTester() [2/2]

G4ConvergenceTester::G4ConvergenceTester

(

G4double

)

Member Function Documentation

AddScore()

void G4ConvergenceTester::AddScore

(

G4double

x

)

Definition at line 85 of file G4ConvergenceTester.cc.

{ 

   //G4cout << x << G4endl;

   timer->Stop();
   cpu_time.push_back( timer->GetSystemElapsed() + timer->GetUserElapsed() );

   if ( x < 0.0 ) {
      G4cout << "Warning: G4convergenceTester expects zero or positive number as inputs, but received a negative number." << G4endl;
   }

   if ( x == 0.0 ) 
   { 
   }
   else
   {
       nonzero_histories.insert( std::pair< G4int , G4double > ( n , x ) );
       if ( x > largest_scores.back() )  
       { 
//        Following serch should become faster if begin from bottom.
          std::vector< G4double >::iterator it; 
          for ( 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();
          } 
          //G4cout << largest_scores.size() << " " << largest_scores.front() << " " << largest_scores.back() << G4endl;
       }
       sum += x; 
   }

    // Data has been added so statistics have not been updated to new values
   statsAreUpdated = false;
   n++;
   return; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

calc_grid_point_of_history()

void G4ConvergenceTester::calc_grid_point_of_history ( )

private

Definition at line 263 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

   G4int i;
   for ( i = 1 ; i <= noBinOfHistory ; i++ )
   { 
      history_grid [ i-1 ] = int ( n / ( double( noBinOfHistory ) ) * i - 0.1 );
      //G4cout << "history_grid " << i-1  << " " << history_grid [ i-1 ] << G4endl;
   }

}

Here is the caller graph for this function:

calc_Pearson_r()

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

private

Definition at line 623 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; 
}

Here is the caller graph for this function:

calc_slope_fit()

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

private

Definition at line 674 of file G4ConvergenceTester.cc.

{

   // create PDF bins 
   G4double max = largest_scores.front();
   G4int last = int ( 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;
   }
    
   //G4cout << "largest " << max << G4endl;
   //G4cout << "last  " << min << G4endl;

   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) );    
      //G4cout << "pdf i " << i << " " << pdf_grid[i] << G4endl;
   }
   
   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;
            //G4cout << "pdf " << j << " " << i << " " <<  largest_scores[j]  << " " << G4endl;
            break;
         }
      }
   }

   f_xi.resize( noBinOfPDF );
   f_yi.resize( noBinOfPDF );
   for ( G4int i = 0 ; i < noBinOfPDF ; i++ )
   {
      //G4cout << "pdf i " << i << " " <<  (pdf_grid[i]+pdf_grid[i+1])/2 << " " << pdf[i] << G4endl;
      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; 
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

calc_stat_history()

void G4ConvergenceTester::calc_stat_history ( )

private

Definition at line 282 of file G4ConvergenceTester.cc.

{
//   G4cout << "i/16  till_ith  mean  var  sd  r  vov  fom  shift  e  r2eff  r2int" << G4endl;

   if ( history_grid [ 0 ] == 0 ) {
      showHistory=false;
      return; 
   } 

   G4int i;
   for ( i = 1 ; i <=  noBinOfHistory  ; i++ )
   {

      G4int ith = history_grid [ i-1 ];

      G4int nonzero_till_ith = 0;
      G4double xi;
      G4double mean_till_ith = 0.0;  
      std::map< G4int , G4double >::iterator it;

      for ( it = nonzero_histories.begin() ; it !=nonzero_histories.end() ; it++ )
      {
         if ( it->first <= ith )
         {
            xi = it->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-1 ] = 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 ( it = nonzero_histories.begin() ; it !=nonzero_histories.end() ; it++ )
      {
         if ( it->first <= ith )
         {
         xi = it->second;
         sum_x2_till_ith += xi * xi; 
         var_till_ith += ( xi - mean_till_ith ) * ( xi - mean_till_ith );
         shift_till_ith += ( xi - mean_till_ith ) * ( xi - mean_till_ith ) * ( xi - mean_till_ith );
         vov_till_ith += ( xi - mean_till_ith ) * ( xi - mean_till_ith ) * ( xi - mean_till_ith ) * ( xi - mean_till_ith );
         }
      }

      var_till_ith += ( (ith+1) - nonzero_till_ith ) * mean_till_ith * mean_till_ith;
      vov_till_ith += ( (ith+1) - nonzero_till_ith ) * mean_till_ith * mean_till_ith * mean_till_ith * mean_till_ith ;


      if ( var_till_ith == 0 ) continue; 
      vov_till_ith = vov_till_ith / ( var_till_ith * var_till_ith ) - 1.0 / (ith+1); 
      vov_history [ i-1 ] = vov_till_ith;

      var_till_ith = var_till_ith / ( ith+1 - 1 );
      var_history [ i-1 ] = var_till_ith;

      sd_history [ i-1 ] = std::sqrt( var_till_ith );
      r_history [ i-1 ] = std::sqrt( var_till_ith ) / mean_till_ith / std::sqrt ( 1.0*(ith+1) );

      fom_history [ i-1 ] = 1 / ( r_history [ i-1 ] *  r_history [ i-1 ] ) / cpu_time [ ith ];
   
      shift_till_ith += ( (ith+1) - nonzero_till_ith ) * mean_till_ith * mean_till_ith * mean_till_ith * ( -1 );
      shift_till_ith = shift_till_ith / ( 2 * var_till_ith * (ith+1) );
      shift_history [ i-1 ] = shift_till_ith;

      e_history [ i-1 ] = 1.0*nonzero_till_ith / (ith+1);
      r2eff_history [ i-1 ] = ( 1 - e_history [ i-1 ] ) / (  e_history [ i-1 ] * (ith+1) );

      G4double sum_till_ith =  mean_till_ith * (ith+1); 
      r2int_history [ i-1 ] = ( sum_x2_till_ith ) / ( sum_till_ith * sum_till_ith ) - 1 / ( e_history [ i-1 ] * (ith+1) );

   }

}

Here is the caller graph for this function:

calStat()

void G4ConvergenceTester::calStat ( )

private

Definition at line 133 of file G4ConvergenceTester.cc.

{
    
   efficiency = double( nonzero_histories.size() ) / n; 

   mean = sum / n;
   
   G4double sum_x2 = 0.0; 
   var = 0.0;
   shift = 0.0;
   vov = 0.0;

   G4double xi; 
   std::map< G4int , G4double >::iterator it;
   for ( it = nonzero_histories.begin() ; it != nonzero_histories.end() ; 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 ( it = nonzero_histories.begin() ; it != nonzero_histories.end() ; 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;

//   G4cout << "The largest history  = " << largest << G4endl;

   mean_1 = ( sum + largest ) / ( n + 1 );

   for ( it = nonzero_histories.begin() ; it != nonzero_histories.end() ; 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 = int ( nonzero_histories.size() );

      // 5% criterion
      G4int j = int ( i * 0.05 );
      while ( int( 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_stat_history()

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

private

Definition at line 480 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; 
   }

}

Here is the call graph for this function:

Here is the caller graph for this function:

CheckIsUpdated()

void G4ConvergenceTester::CheckIsUpdated ( )

inlineprivate

Definition at line 84 of file G4ConvergenceTester.hh.

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

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeStatistics()

void G4ConvergenceTester::ComputeStatistics ( )

inline

Definition at line 88 of file G4ConvergenceTester.hh.

{ calStat(); }

Here is the call graph for this function:

GetEfficiency()

G4double G4ConvergenceTester::GetEfficiency ( )

inline

Definition at line 95 of file G4ConvergenceTester.hh.

{ CheckIsUpdated(); return efficiency; }

Here is the call graph for this function:

GetFOM()

G4double G4ConvergenceTester::GetFOM ( )

inline

Definition at line 100 of file G4ConvergenceTester.hh.

{ CheckIsUpdated(); return fom; }

Here is the call graph for this function:

GetMean()

G4double G4ConvergenceTester::GetMean ( )

inline

Definition at line 91 of file G4ConvergenceTester.hh.

{ CheckIsUpdated(); return mean; }

Here is the call graph for this function:

GetR()

G4double G4ConvergenceTester::GetR ( )

inline

Definition at line 94 of file G4ConvergenceTester.hh.

{ CheckIsUpdated(); return r; }

Here is the call graph for this function:

GetR2eff()

G4double G4ConvergenceTester::GetR2eff ( )

inline

Definition at line 96 of file G4ConvergenceTester.hh.

{ CheckIsUpdated(); return r2eff; }

Here is the call graph for this function:

GetR2int()

G4double G4ConvergenceTester::GetR2int ( )

inline

Definition at line 97 of file G4ConvergenceTester.hh.

{ CheckIsUpdated(); return r2int; }

Here is the call graph for this function:

GetShift()

G4double G4ConvergenceTester::GetShift ( )

inline

Definition at line 98 of file G4ConvergenceTester.hh.

{ CheckIsUpdated(); return shift; }

Here is the call graph for this function:

GetStandardDeviation()

G4double G4ConvergenceTester::GetStandardDeviation ( )

inline

Definition at line 92 of file G4ConvergenceTester.hh.

{ CheckIsUpdated(); return sd; }

Here is the call graph for this function:

GetValueOfMinimizingFunction()

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

inline

Definition at line 74 of file G4ConvergenceTester.hh.

             { return slope_fitting_function( x ); }

Here is the call graph for this function:

GetVariance()

G4double G4ConvergenceTester::GetVariance ( )

inline

Definition at line 93 of file G4ConvergenceTester.hh.

{ CheckIsUpdated(); return var; }

Here is the call graph for this function:

GetVOV()

G4double G4ConvergenceTester::GetVOV ( )

inline

Definition at line 99 of file G4ConvergenceTester.hh.

{ CheckIsUpdated(); return vov; }

Here is the call graph for this function:

is_monotonically_decrease()

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

private

Definition at line 658 of file G4ConvergenceTester.cc.

{

   std::vector<G4double>::iterator it;
   for ( it = ally.begin() ; it != ally.end() - 1 ; it++ )
   {
      if ( *it < *(it+1) ) return FALSE;
   }

   noPass++;
   return TRUE;
}

Here is the caller graph for this function:

ShowHistory()

void G4ConvergenceTester::ShowHistory

(

std::ostream &

out = G4cout

)

Definition at line 439 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;
   }
}

Here is the caller graph for this function:

ShowResult()

void G4ConvergenceTester::ShowResult

(

std::ostream &

out = G4cout

)

Definition at line 366 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 happend 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 orignal 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 orignal 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 orignal 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 orignal 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 orignal 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;

}

Here is the call graph for this function:

Here is the caller graph for this function:

slope_fitting_function()

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

private

Definition at line 764 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;
   G4int i;
   for ( i = 0 ; i < int ( 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 ) );
      }
   }
//   G4cout << "y = " << y << G4endl;

   return y;
}

Here is the caller graph for this function:

Member Data Documentation

calcSLOPE

G4bool G4ConvergenceTester::calcSLOPE

private

Definition at line 172 of file G4ConvergenceTester.hh.

cpu_time

std::vector<G4double> G4ConvergenceTester::cpu_time

private

Definition at line 122 of file G4ConvergenceTester.hh.

e_history

std::vector< G4double > G4ConvergenceTester::e_history

private

Definition at line 155 of file G4ConvergenceTester.hh.

efficiency

G4double G4ConvergenceTester::efficiency

private

Definition at line 128 of file G4ConvergenceTester.hh.

f_xi

std::vector< G4double > G4ConvergenceTester::f_xi

private

Definition at line 161 of file G4ConvergenceTester.hh.

f_yi

std::vector< G4double > G4ConvergenceTester::f_yi

private

Definition at line 162 of file G4ConvergenceTester.hh.

fom

G4double G4ConvergenceTester::fom

private

Definition at line 133 of file G4ConvergenceTester.hh.

fom_1

G4double G4ConvergenceTester::fom_1

private

Definition at line 144 of file G4ConvergenceTester.hh.

fom_history

std::vector< G4double > G4ConvergenceTester::fom_history

private

Definition at line 153 of file G4ConvergenceTester.hh.

history_grid

std::vector< G4int > G4ConvergenceTester::history_grid

private

Definition at line 147 of file G4ConvergenceTester.hh.

largest

G4double G4ConvergenceTester::largest

private

Definition at line 135 of file G4ConvergenceTester.hh.

largest_score_happened

G4int G4ConvergenceTester::largest_score_happened

private

Definition at line 136 of file G4ConvergenceTester.hh.

largest_scores

std::vector< G4double > G4ConvergenceTester::largest_scores

private

Definition at line 160 of file G4ConvergenceTester.hh.

mean

G4double G4ConvergenceTester::mean

private

Definition at line 124 of file G4ConvergenceTester.hh.

mean_1

G4double G4ConvergenceTester::mean_1

private

Definition at line 138 of file G4ConvergenceTester.hh.

mean_history

std::vector< G4double > G4ConvergenceTester::mean_history

private

Definition at line 148 of file G4ConvergenceTester.hh.

minimizer

G4SimplexDownhill<G4ConvergenceTester>* G4ConvergenceTester::minimizer

private

Definition at line 164 of file G4ConvergenceTester.hh.

n

G4int G4ConvergenceTester::n

private

Definition at line 117 of file G4ConvergenceTester.hh.

name

G4String G4ConvergenceTester::name

private

Definition at line 114 of file G4ConvergenceTester.hh.

noBinOfHistory

G4int G4ConvergenceTester::noBinOfHistory

private

Definition at line 146 of file G4ConvergenceTester.hh.

noBinOfPDF

G4int G4ConvergenceTester::noBinOfPDF

private

Definition at line 163 of file G4ConvergenceTester.hh.

nonzero_histories

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

private

Definition at line 115 of file G4ConvergenceTester.hh.

noPass

G4int G4ConvergenceTester::noPass

private

Definition at line 166 of file G4ConvergenceTester.hh.

noTotal

G4int G4ConvergenceTester::noTotal

private

Definition at line 167 of file G4ConvergenceTester.hh.

r

G4double G4ConvergenceTester::r

private

Definition at line 127 of file G4ConvergenceTester.hh.

r2eff

G4double G4ConvergenceTester::r2eff

private

Definition at line 129 of file G4ConvergenceTester.hh.

r2eff_history

std::vector< G4double > G4ConvergenceTester::r2eff_history

private

Definition at line 156 of file G4ConvergenceTester.hh.

r2int

G4double G4ConvergenceTester::r2int

private

Definition at line 130 of file G4ConvergenceTester.hh.

r2int_history

std::vector< G4double > G4ConvergenceTester::r2int_history

private

Definition at line 157 of file G4ConvergenceTester.hh.

r_1

G4double G4ConvergenceTester::r_1

private

Definition at line 141 of file G4ConvergenceTester.hh.

r_history

std::vector< G4double > G4ConvergenceTester::r_history

private

Definition at line 151 of file G4ConvergenceTester.hh.

sd

G4double G4ConvergenceTester::sd

private

Definition at line 126 of file G4ConvergenceTester.hh.

sd_1

G4double G4ConvergenceTester::sd_1

private

Definition at line 140 of file G4ConvergenceTester.hh.

sd_history

std::vector< G4double > G4ConvergenceTester::sd_history

private

Definition at line 150 of file G4ConvergenceTester.hh.

shift

G4double G4ConvergenceTester::shift

private

Definition at line 131 of file G4ConvergenceTester.hh.

shift_1

G4double G4ConvergenceTester::shift_1

private

Definition at line 142 of file G4ConvergenceTester.hh.

shift_history

std::vector< G4double > G4ConvergenceTester::shift_history

private

Definition at line 154 of file G4ConvergenceTester.hh.

showHistory

G4bool G4ConvergenceTester::showHistory

private

Definition at line 171 of file G4ConvergenceTester.hh.

slope

G4double G4ConvergenceTester::slope

private

Definition at line 159 of file G4ConvergenceTester.hh.

statsAreUpdated

G4bool G4ConvergenceTester::statsAreUpdated

private

Definition at line 169 of file G4ConvergenceTester.hh.

sum

G4double G4ConvergenceTester::sum

private

Definition at line 119 of file G4ConvergenceTester.hh.

timer

G4Timer* G4ConvergenceTester::timer

private

Definition at line 121 of file G4ConvergenceTester.hh.

var

G4double G4ConvergenceTester::var

private

Definition at line 125 of file G4ConvergenceTester.hh.

var_1

G4double G4ConvergenceTester::var_1

private

Definition at line 139 of file G4ConvergenceTester.hh.

var_history

std::vector< G4double > G4ConvergenceTester::var_history

private

Definition at line 149 of file G4ConvergenceTester.hh.

vov

G4double G4ConvergenceTester::vov

private

Definition at line 132 of file G4ConvergenceTester.hh.

vov_1

G4double G4ConvergenceTester::vov_1

private

Definition at line 143 of file G4ConvergenceTester.hh.

vov_history

std::vector< G4double > G4ConvergenceTester::vov_history

private

Definition at line 152 of file G4ConvergenceTester.hh.

---

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

• G4ConvergenceTester.hh
• G4ConvergenceTester.cc