#include <G4NuclWatcher.hh>

Public Member Functions
	G4NuclWatcher (G4int z, const std::vector< G4double > &expa, const std::vector< G4double > &expcs, const std::vector< G4double > &experr, G4bool check, G4bool nucl)

	~G4NuclWatcher ()

void	watch (G4int a, G4int z)

void	setInuclCs (G4double csec, G4int nev)

G4double	getChsq () const

G4bool	to_check () const

G4bool	look_forNuclei () const

G4double	getLhood () const

G4double	getNmatched () const

std::pair< G4double, G4double >	getExpCs () const

std::pair< G4double, G4double >	getInuclCs () const

std::pair< G4double, G4double >	getAverageRatio () const

void	print ()

Detailed Description

Definition at line 41 of file G4NuclWatcher.hh.

Constructor & Destructor Documentation

G4NuclWatcher::G4NuclWatcher	(	G4int	z,
		const std::vector< G4double > &	expa,
		const std::vector< G4double > &	expcs,
		const std::vector< G4double > &	experr,
		G4bool	check,
		G4bool	nucl
	)

Definition at line 40 of file G4NuclWatcher.cc.

   : nuclz(z), izotop_chsq(0.), average_ratio(0.), aver_rat_err(0.),
     aver_lhood(0.), aver_matched(0.), exper_as(expa), exper_cs(expcs),
     exper_err(experr), checkable(check), nucleable(nucl) {}

G4NuclWatcher::~G4NuclWatcher ( )

inline

Definition at line 50 of file G4NuclWatcher.hh.

50 {}

Member Function Documentation

std::pair<G4double, G4double> G4NuclWatcher::getAverageRatio ( ) const

inline

Definition at line 64 of file G4NuclWatcher.hh.

                                                       { 
     return std::pair<G4double, G4double>(average_ratio, aver_rat_err); 
   }

G4double G4NuclWatcher::getChsq ( ) const

inline

Definition at line 55 of file G4NuclWatcher.hh.

55 { return izotop_chsq; }

std::pair< G4double, G4double > G4NuclWatcher::getExpCs ( ) const

Definition at line 81 of file G4NuclWatcher.cc.

                                                           {
   G4double cs = 0.0;
   G4double err = 0.0;
   
   G4int experAsSize = exper_as.size();
   for(G4int iz = 0; iz < experAsSize; iz++) {
     cs += exper_cs[iz];
     err += exper_err[iz];
   }
   
   return std::pair<G4double, G4double>(cs, err);
 }

std::pair< G4double, G4double > G4NuclWatcher::getInuclCs ( ) const

Definition at line 94 of file G4NuclWatcher.cc.

                                                             {
   G4double cs = 0.0;
   G4double err = 0.0;
   G4int  simulatedAsSize = simulated_as.size();
   for(G4int iz = 0; iz < simulatedAsSize; iz++) {
     cs += simulated_cs[iz];
     err += simulated_errors[iz];
   }
   
   return std::pair<G4double, G4double>(cs, err);
 }

G4double G4NuclWatcher::getLhood ( ) const

inline

Definition at line 58 of file G4NuclWatcher.hh.

58 { return aver_lhood; }

G4double G4NuclWatcher::getNmatched ( ) const

inline

Definition at line 59 of file G4NuclWatcher.hh.

59 { return aver_matched; }

G4bool G4NuclWatcher::look_forNuclei ( ) const

inline

Definition at line 57 of file G4NuclWatcher.hh.

57 { return nucleable; }

void G4NuclWatcher::print ( )

Definition at line 106 of file G4NuclWatcher.cc.

                           {
   const G4double small = 0.001;
   
   G4cout << "\n ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ "
      << "\n **** izotop Z **** " << nuclz << G4endl;
   
   izotop_chsq = 0.0;
   average_ratio = 0.0;
   aver_rat_err = 0.0;
   G4double exp_cs = 0.0;
   G4double exp_cs_err = 0.0;
   G4double inucl_cs = 0.0;
   G4double inucl_cs_err = 0.0;
   std::vector<G4bool> not_used(simulated_cs.size(), true);
   G4int nmatched = exper_as.size();
   G4int nused = simulated_cs.size();
   G4double lhood = 0.0;
   G4int experAsSize = exper_as.size();
 
   for (G4int iz = 0; iz < experAsSize; iz++) {
     G4double a = exper_as[iz];
     
     exp_cs += exper_cs[iz];
     exp_cs_err += exper_err[iz];
     
     G4bool found = false;
     G4int  simulatedAsSize = simulated_as.size();
     for (G4int i = 0; i<simulatedAsSize && !found; i++) {
       if (std::fabs(simulated_as[i] - a) < small) {
     G4double rat = simulated_cs[i] / exper_cs[iz];
     
     lhood += std::log10(rat) * std::log10(rat);
     
     G4double rat_err
       = std::sqrt(simulated_errors[i]*simulated_errors[i] +
               exper_err[iz]*exper_err[iz] * rat*rat) / exper_cs[iz];
     average_ratio += rat;
     aver_rat_err += rat_err; 
     
     G4cout << " A " << a << " exp.cs " << exper_cs[iz] << " err " 
            << exper_err[iz] << G4endl << " sim. cs " << simulated_cs[i]
            << " err " << simulated_errors[i] << G4endl
            << " ratio " << rat << " err " << rat_err << G4endl
            << " simulated production rate " << simulated_prob[i] << G4endl;
     
     not_used[i] = false;
     izotop_chsq += (rat - 1.0) * (rat - 1.0) / rat_err / rat_err; 
     found = true;
     nused--;
       }
     }
 
     if (found) nmatched--;
     else
       G4cout << " not found exper.: A " << a << " exp.cs " << exper_cs[iz] 
          << " err " << exper_err[iz] << G4endl;
   }
   
   G4cout << " not found in simulations " << nmatched << G4endl
      << " not found in exper: " << nused << G4endl;
 
   G4int  simulatedAsSize = simulated_as.size();
   for(G4int i = 0; i < simulatedAsSize; i++) {
     inucl_cs += simulated_cs[i];
     inucl_cs_err += simulated_errors[i];
     
     if(not_used[i]) 
       G4cout << " extra simul.: A " << simulated_as[i] << " sim. cs "
          << simulated_cs[i] << " err " << simulated_errors[i] << G4endl;
 
     G4cout << " simulated production rate " << simulated_prob[i] << G4endl;
   }
 
   G4int matched = exper_as.size() - nmatched;
   
   if (matched > 0) {
     aver_lhood = lhood;
     aver_matched = matched;    
     lhood = std::pow(10.0, std::sqrt(lhood/matched));
     
     G4cout << " matched " << matched << " CHSQ " << std::sqrt(izotop_chsq) / matched
        << G4endl
        << " raw chsq " << izotop_chsq << G4endl
        << " average ratio " << average_ratio / matched 
        << " err " << aver_rat_err / matched << G4endl 
        << " lhood " << lhood << G4endl;
   }
   else {
     izotop_chsq = 0.0;
     aver_lhood = 0.0;    
   } 
   
   G4cout << " exper. cs " << exp_cs << " err " << exp_cs_err << G4endl
      << " inucl. cs " << inucl_cs << " err " << inucl_cs_err << G4endl
      <<  " ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ "
      << G4endl;
 }

void G4NuclWatcher::setInuclCs	(	G4double	csec,
		G4int	nev
	)

Definition at line 70 of file G4NuclWatcher.cc.

                                                        { 
   G4int  simulatedAsSize = simulated_as.size();
   for(G4int i = 0; i < simulatedAsSize ; i++) {
     double err = std::sqrt(simulated_cs[i]) / simulated_cs[i];
     
     simulated_prob.push_back(simulated_cs[i] / nev);
     simulated_cs[i] *= csec / nev;
     simulated_errors.push_back(simulated_cs[i] * err);    
   }
 }

G4bool G4NuclWatcher::to_check ( ) const

inline

Definition at line 56 of file G4NuclWatcher.hh.

56 { return checkable; }

void G4NuclWatcher::watch	(	G4int	a,
		G4int	z
	)

Definition at line 50 of file G4NuclWatcher.cc.

                                           {
   const G4double small = 0.001;
   
   if (std::abs(z-nuclz) >= small) return;
 
   G4bool here = false;      // Increment specified nucleus count
   G4int  simulatedAsSize = simulated_as.size();
   for (G4int i = 0; i<simulatedAsSize && !here; i++) {
     if (std::abs(simulated_as[i] - a) < small) {
       simulated_cs[i] += 1.0;
       here = true;      // Terminates loop
     }
   }
 
   if (!here) {          // Nothing found, so add new entry
     simulated_as.push_back(a); 
     simulated_cs.push_back(1.0); 
   }
 }

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

source/geant4.10.03.p03/source/processes/hadronic/models/cascade/cascade/include/G4NuclWatcher.hh
source/geant4.10.03.p03/source/processes/hadronic/models/cascade/cascade/src/G4NuclWatcher.cc

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation