G4NuclWatcher Class Reference

#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::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::~G4NuclWatcher ( )

inline

Definition at line 50 of file G4NuclWatcher.hh.

{}

Member Function Documentation

getAverageRatio()

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); 
  }

getChsq()

G4double G4NuclWatcher::getChsq ( ) const

inline

Definition at line 55 of file G4NuclWatcher.hh.

{ return izotop_chsq; }

getExpCs()

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);
}

getInuclCs()

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);
}

getLhood()

G4double G4NuclWatcher::getLhood ( ) const

inline

Definition at line 58 of file G4NuclWatcher.hh.

{ return aver_lhood; }

getNmatched()

G4double G4NuclWatcher::getNmatched ( ) const

inline

Definition at line 59 of file G4NuclWatcher.hh.

{ return aver_matched; }

look_forNuclei()

G4bool G4NuclWatcher::look_forNuclei ( ) const

inline

Definition at line 57 of file G4NuclWatcher.hh.

{ return nucleable; }

print()

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;
}

setInuclCs()

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);    
  }
}

to_check()

G4bool G4NuclWatcher::to_check ( ) const

inline

Definition at line 56 of file G4NuclWatcher.hh.

{ return checkable; }

watch()

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:

• G4NuclWatcher.hh
• G4NuclWatcher.cc