RunAction Class Reference

#include <RunAction.hh>

List of all members.

Public Member Functions
	RunAction ()
virtual	~RunAction ()
void	BeginOfRunAction (const G4Run *)
void	EndOfRunAction (const G4Run *)
G4int	find_volume (G4VPhysicalVolume *volume)
G4int	find_process (G4String process)
Private Attributes
std::map< G4VPhysicalVolume *, G4int >	m_volume
std::map< G4String, int >	m_process
double	t_begin
double	t_end

---

Detailed Description

Definition at line 49 of file RunAction.hh.

---

Constructor & Destructor Documentation

RunAction::RunAction

(

)

Definition at line 63 of file RunAction.cc.

{
}

RunAction::~RunAction

(

)

[virtual]

Definition at line 69 of file RunAction.cc.

{
}

---

Member Function Documentation

void RunAction::BeginOfRunAction

(

const G4Run *

aRun

)

Definition at line 75 of file RunAction.cc.

References MyAnalysisSvc::BeginOfRunAction(), MyGlobalField::getFields(), MyAnalysisSvc::GetMyAnalysisSvc(), and MyGlobalField::getObject().

{ 
  G4cout << "### Run " << aRun->GetRunID() << " start." << G4endl;

  //inform the runManager to save random number seed
  G4RunManager::GetRunManager()->SetRandomNumberStore(true);

        //deal with analysis
        MyAnalysisSvc::GetMyAnalysisSvc()->BeginOfRunAction();

        //t_begin = (double)clock();

    FieldList* fields = MyGlobalField::getObject()->getFields();
    if (fields) {
        if (fields->size()>0) {
            FieldList::iterator i;
            for (i=fields->begin(); i!=fields->end(); ++i) {
                (*i)->construct();
                //G4cout << "Constructed field " << G4endl;
            }
        }
    }

        /*
//#################################################################################333  
        //Print dE/dx tables with binning identical to the Geant3 JMATE bank.
        //The printout is readable as Geant3 ffread data cards (by the program g4mat).
        //
        const G4double tkmin=10*keV, tkmax=20*GeV;
        const G4int nbin=100;
        G4double tk[nbin];

        const G4int ncolumn = 1;

        //compute the kinetic energies
        //
        const G4double dp = std::log10(tkmax/tkmin)/nbin;
        const G4double dt = std::pow(10.,dp);
        tk[0] = tkmin;
        for (G4int i=1; i<nbin; ++i) tk[i] = tk[i-1]*dt;

        //print the kinetic energies
        //
        std::ios::fmtflags mode = G4cout.flags();
        G4cout.setf(std::ios::fixed,std::ios::floatfield);
        G4int  prec = G4cout.precision(3);

        //print the dE/dx tables
        //
        G4cout.setf(std::ios::scientific,std::ios::floatfield);

        G4ParticleDefinition*
        //      part = G4ParticleTable::GetParticleTable()->FindParticle("e-");
                        part = G4ParticleTable::GetParticleTable()->FindParticle("mu-");

        G4ProductionCutsTable* theCoupleTable =
                G4ProductionCutsTable::GetProductionCutsTable();
        size_t numOfCouples = theCoupleTable->GetTableSize();
        const G4MaterialCutsCouple* couple = 0;

        for (size_t i=0; i<numOfCouples; i++) {
                couple = theCoupleTable->GetMaterialCutsCouple(i);
                const G4Material* mat = couple->GetMaterial();
                G4cout << "\nLIST";
                G4cout << "\nC \nC  dE/dx (MeV/cm) for " << part->GetParticleName()
                        << " in " << mat ->GetName() << "\nC";
                G4cout.precision(6);
                G4cout << "\nEnergy/MeV   dE/dx (MeV/cm)\n ";
                for (G4int l=0;l<nbin; ++l)
                {
                        G4cout << tk[l]/MeV<< "\t";
                        G4double dedx = G4LossTableManager::Instance()
                                ->GetDEDX(part,tk[l],couple);
                        G4cout << dedx/(MeV/cm) << "\n";
                }
                G4cout << G4endl;
        }

        G4cout.precision(prec);
        G4cout.setf(mode,std::ios::floatfield);
//#################################################################################333  
        */


}

void RunAction::EndOfRunAction

(

const G4Run *

aRun

)

Definition at line 163 of file RunAction.cc.

References MyAnalysisSvc::EndOfRunAction(), and MyAnalysisSvc::GetMyAnalysisSvc().

{

        //deal with analysis
        MyAnalysisSvc::GetMyAnalysisSvc()->EndOfRunAction(aRun);

  G4int NbOfEvents = aRun->GetNumberOfEvent();
  if (NbOfEvents == 0) return;

        //t_end = clock();
        //double duration = (t_end-t_begin)/CLOCKS_PER_SEC;
        //std::cout<<"TOTAL TIME COST FOR THIS RUN:     "<<duration<<"s"<<std::endl;
        //std::cout<<"TIME COST PER EVENT FOR THIS RUN: "<<duration/NbOfEvents<<"s"<<std::endl;
}

G4int RunAction::find_process

(

G4String

process

)

[inline]

Definition at line 67 of file RunAction.hh.

References m_process.

                                      {
    std::map<G4String,G4int>::const_iterator cit = m_process.find(process);
    if ( cit != m_process.end() )
      return cit->second;
    else
      return -2;
  };

G4int RunAction::find_volume

(

G4VPhysicalVolume *

volume

)

[inline]

Definition at line 59 of file RunAction.hh.

References m_volume.

                                              {
    std::map<G4VPhysicalVolume*,G4int>::const_iterator cit = m_volume.find(volume);
    if ( cit != m_volume.end() )
      return cit->second;
    else
      return 0;
  };

---

Member Data Documentation

std::map<G4String,int> RunAction::m_process [private]

Definition at line 77 of file RunAction.hh.

Referenced by find_process().

std::map<G4VPhysicalVolume*,G4int> RunAction::m_volume [private]

Definition at line 73 of file RunAction.hh.

Referenced by find_volume().

double RunAction::t_begin [private]

Definition at line 78 of file RunAction.hh.

double RunAction::t_end [private]

Definition at line 79 of file RunAction.hh.

---

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

• include/RunAction.hh
• src/RunAction.cc