G4Analyser Class Reference

#include <G4Analyser.hh>

Collaboration diagram for G4Analyser:

Public Member Functions
	G4Analyser ()
void	setInelCsec (G4double csec, G4bool withn)
void	setWatchers (const std::vector< G4NuclWatcher > &watchers)
void	try_watchers (G4int a, G4int z, G4bool if_nucl)
void	analyse (const G4CollisionOutput &output)
void	printResults ()
void	printResultsSimple ()
void	handleWatcherStatistics ()
void	printResultsNtuple ()

Private Attributes
G4int	verboseLevel
G4double	eventNumber
G4double	averageMultiplicity
G4double	averageProtonNumber
G4double	averageNeutronNumber
G4double	averagePionNumber
G4double	averageNucleonKinEnergy
G4double	averageProtonKinEnergy
G4double	averageNeutronKinEnergy
G4double	averagePionKinEnergy
G4double	averageExitationEnergy
G4double	averageOutgoingNuclei
G4double	fissy_prob
G4double	averagePionPl
G4double	averagePionMin
G4double	averagePion0
G4double	averageA
G4double	averageZ
std::vector< G4NuclWatcher >	ana_watchers
G4double	inel_csec
G4bool	withNuclei

Detailed Description

Definition at line 44 of file G4Analyser.hh.

Constructor & Destructor Documentation

G4Analyser()

G4Analyser::G4Analyser

(

)

Definition at line 36 of file G4Analyser.cc.

  : verboseLevel(0), eventNumber(0.0), averageMultiplicity(0.0),
    averageProtonNumber(0.0), averageNeutronNumber(0.0),
    averagePionNumber(0.0),  averageNucleonKinEnergy(0.0),
    averageProtonKinEnergy(0.0), averageNeutronKinEnergy(0.0),
    averagePionKinEnergy(0.0), averageExitationEnergy(0.0),
    averageOutgoingNuclei(0.0), fissy_prob(0.0), averagePionPl(0.0),
    averagePionMin(0.0), averagePion0(0.0), averageA(0.0), averageZ(0.0),
    inel_csec(0.0), withNuclei(false) {
  if (verboseLevel > 3) {
    G4cout << " >>> G4Analyser::G4Analyser" << G4endl;
  }
}

Member Function Documentation

analyse()

void G4Analyser::analyse

(

const G4CollisionOutput &

output

)

Definition at line 96 of file G4Analyser.cc.

                                                        {

  if (verboseLevel > 3) {
    G4cout << " >>> G4Analyser::analyse" << G4endl;
  }

  if (withNuclei) {
    const std::vector<G4InuclNuclei>& nucleus = output.getOutgoingNuclei();

    //    if (nucleus.size() >= 0) {
    if (nucleus.size() > 0) {
      G4int nbig = 0;
      averageOutgoingNuclei += nucleus.size();

      for (G4int in = 0; in < G4int(nucleus.size()); in++) {
    averageExitationEnergy += nucleus[in].getExitationEnergy();

    G4int a = nucleus[in].getA();
    G4int z = nucleus[in].getZ();

    if (in == 0) { 
      averageA += a; 
      averageZ += z; 
    };

    if (a > 10) nbig++;
    try_watchers(a, z, true);
      };

      if (nbig > 1) fissy_prob += 1.0;
      eventNumber += 1.0;
      const std::vector<G4InuclElementaryParticle>& particles =
    output.getOutgoingParticles();
      averageMultiplicity += particles.size();

      for (G4int i = 0; i < G4int(particles.size()); i++) {
    G4int ap = 0;
    G4int zp = 0;

    if (particles[i].nucleon()) {
      averageNucleonKinEnergy += particles[i].getKineticEnergy();

      if (particles[i].type() == 1) {
        zp = 1;
        ap = 1;
        averageProtonNumber += 1.0;
        averageProtonKinEnergy += particles[i].getKineticEnergy();

      } else {
        ap = 1;
        zp = 0;
        averageNeutronNumber += 1.0;
        averageNeutronKinEnergy += particles[i].getKineticEnergy();
      };  

    } else if (particles[i].pion()) {
      averagePionKinEnergy += particles[i].getKineticEnergy();
      averagePionNumber += 1.0;
      ap = 0;

      if (particles[i].type() == 3) {
        zp = 1;
        averagePionPl += 1.0;

      } else if (particles[i].type() == 5) {  
        zp = -1;
        averagePionMin += 1.0;

      } else if (particles[i].type() == 7) { 
        zp = 0;
        averagePion0 += 1.0;
      };
    };
    try_watchers(ap, zp, false);
      };
    };

  } else {
    eventNumber += 1.0;
    const std::vector<G4InuclElementaryParticle>& particles =
      output.getOutgoingParticles();
    averageMultiplicity += particles.size();

    for (G4int i = 0; i < G4int(particles.size()); i++) {

      if (particles[i].nucleon()) {
    averageNucleonKinEnergy += particles[i].getKineticEnergy();

    if (particles[i].type() == 1) {
      averageProtonNumber += 1.0;
      averageProtonKinEnergy += particles[i].getKineticEnergy();

    } else {
      averageNeutronNumber += 1.0;
      averageNeutronKinEnergy += particles[i].getKineticEnergy();
    }

      } else if (particles[i].pion()) {
    averagePionKinEnergy += particles[i].getKineticEnergy();
    averagePionNumber += 1.0;
      }
    }
  }
}

Here is the call graph for this function:

handleWatcherStatistics()

void G4Analyser::handleWatcherStatistics

(

)

Definition at line 266 of file G4Analyser.cc.

                                         {

  if (verboseLevel > 3) {
    G4cout << " >>> G4Analyser::handleWatcherStatistics" << G4endl;
  }

  // const G4double small = 1.0e-10;

  if (verboseLevel > 3) {
    G4cout << " >>>Izotop analysis:" << G4endl;
  };

  G4double fgr = 0.0;
  G4double averat = 0.0;
  G4double ave_err = 0.0;
  G4double gl_chsq = 0.0;
  G4double tot_exper = 0.0;
  G4double tot_exper_err = 0.0;
  G4double tot_inucl = 0.0;
  G4double tot_inucl_err = 0.0;
  G4double checked = 0.0;

  for (G4int iw = 0; iw < G4int(ana_watchers.size()); iw++) {
    ana_watchers[iw].setInuclCs(inel_csec, G4int(eventNumber));
    ana_watchers[iw].print();

    if (ana_watchers[iw].to_check()) {
      std::pair<G4double, G4double> rat_err = ana_watchers[iw].getAverageRatio();
      averat += rat_err.first;
      ave_err += rat_err.second;
      gl_chsq += ana_watchers[iw].getChsq();   
      std::pair<G4double, G4double> cs_err = ana_watchers[iw].getExpCs();
      tot_exper += cs_err.first;
      tot_exper_err += cs_err.second;
      std::pair<G4double, G4double> inucl_cs_err = ana_watchers[iw].getInuclCs();
      tot_inucl += inucl_cs_err.first;
      tot_inucl_err += inucl_cs_err.second;
      G4double iz_checked = ana_watchers[iw].getNmatched();

      if (iz_checked > 0.0) {
    fgr += ana_watchers[iw].getLhood();
    checked += iz_checked;    
      };
    };
  };

  if (checked > 0.0) {
    gl_chsq = std::sqrt(gl_chsq) / checked;
    averat /= checked;
    ave_err /= checked;
    fgr = std::pow(10.0, std::sqrt(fgr / checked)); 
  };

  if (verboseLevel > 3) {
    G4cout << " total exper c.s. " << tot_exper << " err " << tot_exper_err <<
      " tot inucl c.s. " << tot_inucl << " err " << tot_inucl_err << G4endl;
    G4cout << " checked total " << checked << " lhood " << fgr << G4endl
       << " average ratio " << averat << " err " << ave_err << G4endl
       << " global chsq " << gl_chsq << G4endl;
  }
}

Here is the caller graph for this function:

printResults()

void G4Analyser::printResults

(

)

Definition at line 230 of file G4Analyser.cc.

                              {

  if (verboseLevel > 3) {
    G4cout << " >>> G4Analyser::printResults" << G4endl;
  }

  G4cout << " Number of events " << G4int(eventNumber + 0.1) << G4endl
     << " average multiplicity " << averageMultiplicity / eventNumber << G4endl
     << " average proton number " << averageProtonNumber / eventNumber << G4endl
     << " average neutron number " << averageNeutronNumber / eventNumber << G4endl
     << " average nucleon Ekin " << averageNucleonKinEnergy /
    (averageProtonNumber + averageNeutronNumber) << G4endl
     << " average proton Ekin " << averageProtonKinEnergy / (averageProtonNumber +
                                 1.0e-10) << G4endl
     << " average neutron Ekin " << averageNeutronKinEnergy / (averageNeutronNumber +
                                   1.0e-10) << G4endl
     << " average pion number " << averagePionNumber / eventNumber << G4endl
     << " average pion Ekin " << averagePionKinEnergy / (averagePionNumber +
                                 1.0e-10) << G4endl
     << " average pi+ " << averagePionPl / eventNumber << G4endl
     << " average pi- " << averagePionMin / eventNumber << G4endl
     << " average pi0 " << averagePion0 / eventNumber << G4endl;
               
  if (withNuclei) {
    G4cout
      << " average A " << averageA / eventNumber << G4endl         
      << " average Z " << averageZ / eventNumber << G4endl         
      << " average Exitation Energy " << 
      averageExitationEnergy / averageOutgoingNuclei << G4endl
      << " average num of fragments " << averageOutgoingNuclei / eventNumber << G4endl;
    G4cout << " fission prob. " << fissy_prob / eventNumber << " c.sec " <<
      inel_csec * fissy_prob / eventNumber << G4endl;
    handleWatcherStatistics();
  }
}

Here is the call graph for this function:

printResultsNtuple()

void G4Analyser::printResultsNtuple

(

)

Definition at line 328 of file G4Analyser.cc.

                                    {

  if (verboseLevel > 3) {
    G4cout << " >>> G4Analyser::printResultsNtuple" << G4endl;
  }

  // Create one line of ACII data. 
  // Several runs should create ntuple for data-analysis 
  G4cout <<
    std::setw(15) << int(eventNumber + 0.1) <<
    std::setw(15) << averageMultiplicity / eventNumber << 
    std::setw(15) << averageProtonNumber / eventNumber <<
    std::setw(15) << averageNeutronNumber / eventNumber << " " <<
    std::setw(15) << averageNucleonKinEnergy / (averageProtonNumber + averageNeutronNumber) << " " <<
    std::setw(15) << averageProtonKinEnergy / (averageProtonNumber + 1.0e-10) << " " <<
    std::setw(15) << averageNeutronKinEnergy / (averageNeutronNumber + 1.0e-10) << " " <<
    std::setw(15) << averagePionNumber / eventNumber << " " <<
    std::setw(15) << averagePionKinEnergy / (averagePionNumber + 1.0e-10) << G4endl;
}

printResultsSimple()

void G4Analyser::printResultsSimple

(

)

Definition at line 201 of file G4Analyser.cc.

                                    {

  if (verboseLevel > 3) {
    G4cout << " >>> G4Analyser::printResultsSimple" << G4endl;
  }

  G4cout << " Number of events " << G4int(eventNumber + 0.1) << G4endl
     << " average multiplicity " << averageMultiplicity / eventNumber << G4endl
     << " average proton number " << averageProtonNumber / eventNumber << G4endl
     << " average neutron number " << averageNeutronNumber / eventNumber << G4endl
     << " average nucleon Ekin " << averageNucleonKinEnergy /
    (averageProtonNumber + averageNeutronNumber) << G4endl
     << " average proton Ekin " << averageProtonKinEnergy / (averageProtonNumber +
                                 1.0e-10) << G4endl
     << " average neutron Ekin " << averageNeutronKinEnergy / (averageNeutronNumber +
                                   1.0e-10) << G4endl
     << " average pion number " << averagePionNumber / eventNumber << G4endl
     << " average pion Ekin " << averagePionKinEnergy / (averagePionNumber +
                                 1.0e-10) << G4endl;
  if (withNuclei) {
    G4cout         
      << " average Exitation Energy " << 
      averageExitationEnergy / averageOutgoingNuclei << G4endl
      << " average num of fragments " << averageOutgoingNuclei / eventNumber << G4endl;
    G4cout << " fission prob. " << fissy_prob / eventNumber << " c.sec " <<
      inel_csec * fissy_prob / eventNumber << G4endl;
  }
}

setInelCsec()

void G4Analyser::setInelCsec	(	G4double	csec,
		G4bool	withn
	)

Definition at line 50 of file G4Analyser.cc.

                                                        {

  if (verboseLevel > 3) {
    G4cout << " >>> G4Analyser::setInelCsec" << G4endl;
  }

  inel_csec = csec; // mb
  withNuclei = withn;

  if (verboseLevel > 3) {
    G4cout << " total inelastic " << inel_csec << G4endl;
  }
}

setWatchers()

void G4Analyser::setWatchers

(

const std::vector< G4NuclWatcher > &

watchers

)

Definition at line 64 of file G4Analyser.cc.

                                                                     {

  if (verboseLevel > 3) {
    G4cout << " >>> G4Analyser::setWatchers" << G4endl;
  }

  ana_watchers = watchers;
  if (verboseLevel > 3) {
    G4cout << " watchers set " << watchers.size() << G4endl;
  }
}

try_watchers()

void G4Analyser::try_watchers	(	G4int	a,
		G4int	z,
		G4bool	if_nucl
	)

Definition at line 76 of file G4Analyser.cc.

                                                              {

  if (verboseLevel > 3) {
    G4cout << " >>> G4Analyser::try_watchers" << G4endl;
  }

  for (G4int iw = 0; iw < G4int(ana_watchers.size()); iw++) { 

    if (if_nucl) {

      if (ana_watchers[iw].look_forNuclei()) ana_watchers[iw].watch(a, z); 

    } else {

      if (!ana_watchers[iw].look_forNuclei()) ana_watchers[iw].watch(a, z); 
    }
  }
}

Here is the caller graph for this function:

Member Data Documentation

ana_watchers

std::vector<G4NuclWatcher> G4Analyser::ana_watchers

private

Definition at line 78 of file G4Analyser.hh.

averageA

G4double G4Analyser::averageA

private

Definition at line 76 of file G4Analyser.hh.

averageExitationEnergy

G4double G4Analyser::averageExitationEnergy

private

Definition at line 70 of file G4Analyser.hh.

averageMultiplicity

G4double G4Analyser::averageMultiplicity

private

Definition at line 62 of file G4Analyser.hh.

averageNeutronKinEnergy

G4double G4Analyser::averageNeutronKinEnergy

private

Definition at line 68 of file G4Analyser.hh.

averageNeutronNumber

G4double G4Analyser::averageNeutronNumber

private

Definition at line 64 of file G4Analyser.hh.

averageNucleonKinEnergy

G4double G4Analyser::averageNucleonKinEnergy

private

Definition at line 66 of file G4Analyser.hh.

averageOutgoingNuclei

G4double G4Analyser::averageOutgoingNuclei

private

Definition at line 71 of file G4Analyser.hh.

averagePion0

G4double G4Analyser::averagePion0

private

Definition at line 75 of file G4Analyser.hh.

averagePionKinEnergy

G4double G4Analyser::averagePionKinEnergy

private

Definition at line 69 of file G4Analyser.hh.

averagePionMin

G4double G4Analyser::averagePionMin

private

Definition at line 74 of file G4Analyser.hh.

averagePionNumber

G4double G4Analyser::averagePionNumber

private

Definition at line 65 of file G4Analyser.hh.

averagePionPl

G4double G4Analyser::averagePionPl

private

Definition at line 73 of file G4Analyser.hh.

averageProtonKinEnergy

G4double G4Analyser::averageProtonKinEnergy

private

Definition at line 67 of file G4Analyser.hh.

averageProtonNumber

G4double G4Analyser::averageProtonNumber

private

Definition at line 63 of file G4Analyser.hh.

averageZ

G4double G4Analyser::averageZ

private

Definition at line 77 of file G4Analyser.hh.

eventNumber

G4double G4Analyser::eventNumber

private

Definition at line 61 of file G4Analyser.hh.

fissy_prob

G4double G4Analyser::fissy_prob

private

Definition at line 72 of file G4Analyser.hh.

inel_csec

G4double G4Analyser::inel_csec

private

Definition at line 79 of file G4Analyser.hh.

verboseLevel

G4int G4Analyser::verboseLevel

private

Definition at line 60 of file G4Analyser.hh.

withNuclei

G4bool G4Analyser::withNuclei

private

Definition at line 80 of file G4Analyser.hh.

---

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

• G4Analyser.hh
• G4Analyser.cc