lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 10.0.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-10 11:51:14 +02:00
parent e2d2f9810a
commit 286caacf06
12421 changed files with 730077 additions and 502383 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/advanced/gammaray_telescope/src/GammaRayTelAnalysis.cc
+107 -188
View File
@@ -23,9 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#ifdef G4ANALYSIS_USE
//
// $Id$
// $Id: GammaRayTelAnalysis.cc 68794 2013-04-05 13:23:26Z gcosmo $
// ------------------------------------------------------------
// GEANT 4 class implementation file
// CERN Geneva Switzerland
@@ -34,6 +32,9 @@
// ------------ GammaRayAnalysisManager ------
// by R.Giannitrapani, F.Longo & G.Santin (03 dic 2000)
//
// 03.04.2013 F.Longo/L.Pandola
// - migrated to G4tools
//
// 29.05.2003 F.Longo
// - anaphe 5.0.5 compliant
//
@@ -51,6 +52,7 @@
//
// ************************************************************
#include <fstream>
#include <iomanip>
#include "G4RunManager.hh"
@@ -64,11 +66,7 @@ GammaRayTelAnalysis* GammaRayTelAnalysis::instance = 0;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
GammaRayTelAnalysis::GammaRayTelAnalysis()
:GammaRayTelDetector(0),analysisFactory(0), tree(0)//, plotter(0),
,tuple(0)
,energy(0), hits(0), posXZ(0), posYZ(0)
,histo1DDraw("enable"),histo1DSave("enable"),histo2DDraw("enable")
,histo2DSave("enable"),histo2DMode("strip")
:GammaRayTelDetector(0),histo2DMode("strip")
{
G4RunManager* runManager = G4RunManager::GetRunManager();
GammaRayTelDetector =
@@ -78,93 +76,9 @@ GammaRayTelAnalysis::GammaRayTelAnalysis()
// Define the messenger and the analysis system
analysisMessenger = new GammaRayTelAnalysisMessenger(this);
histoFileName = "gammaraytel";
analysisFactory = AIDA_createAnalysisFactory(); // create the Analysis Factory
if(analysisFactory) {
AIDA::ITreeFactory* treeFactory = analysisFactory->createTreeFactory();
// create Tree Factory
if(treeFactory) {
// Tree in memory :
// Create a "tree" associated to an xml file
// tree = treeFactory->create("gammaraytel.hbook", "hbook", false, false);
// (hbook implementation)
tree = treeFactory->create("gammaraytel.aida","xml",false,true,"");
if(tree) {
// Get a tuple factory :
ITupleFactory* tupleFactory = analysisFactory->createTupleFactory(*tree);
if(tupleFactory) {
// Create a tuple :
tuple = tupleFactory->create("1","1", "float energy, plane, x, y, z");
assert(tuple);
delete tupleFactory;
}
IHistogramFactory* histoFactory = analysisFactory->createHistogramFactory(*tree);
if(histoFactory) {
// Create histos :
int Nplane = GammaRayTelDetector->GetNbOfTKRLayers();
int Nstrip = GammaRayTelDetector->GetNbOfTKRStrips();
int Ntile = GammaRayTelDetector->GetNbOfTKRTiles();
double sizexy = GammaRayTelDetector->GetTKRSizeXY();
double sizez = GammaRayTelDetector->GetTKRSizeZ();
int N = Nstrip*Ntile;
// 1D histogram that store the energy deposition of the
// particle in the last (number 0) TKR X-plane
energy = histoFactory->createHistogram1D("10","Edep in the last X plane (keV)", 100, 50, 200);
// 1D histogram that store the hits distribution along the TKR X-planes
hits = histoFactory->createHistogram1D("20","Hits dist in TKR X planes",Nplane, 0, Nplane-1);
// 2D histogram that store the position (mm) of the hits (XZ projection)
if (histo2DMode == "strip"){
posXZ = histoFactory->createHistogram2D("30","Tracker Hits XZ (strip,plane)",
N, 0, N-1,
2*Nplane, 0, Nplane-1);
}
else
{
posXZ = histoFactory->createHistogram2D("30","Tracker Hits XZ (x,z) in mm",
int(sizexy/5), -sizexy/2, sizexy/2,
int(sizez/5), -sizez/2, sizez/2);
}
// 2D histogram that store the position (mm) of the hits (YZ projection)
if(histo2DMode=="strip")
posYZ = histoFactory->createHistogram2D("40","Tracker Hits YZ (strip,plane)",
N, 0, N-1,
2*Nplane, 0, Nplane-1);
else
posYZ = histoFactory->createHistogram2D("40","Tracker Hits YZ (y,z) in mm",
int(sizexy/5), -sizexy/2, sizexy/2,
int(sizez/5), -sizez/2, sizez/2);
delete histoFactory;
}
}
}
delete treeFactory; // Will not delete the ITree.
}
// IPlotterFactory* plotterFactory = analysisFactory->createPlotterFactory(0,0);
// if(plotterFactory) {
// plotter = plotterFactory->create();
// if(plotter) {
// plotter->show();
// plotter->setParameter("pageTitle","Gamma Ray Tel");
// }
// delete plotterFactory;
// }
#endif
}
@@ -176,17 +90,12 @@ GammaRayTelAnalysis::~GammaRayTelAnalysis() {
void GammaRayTelAnalysis::Init()
{
}
{;}
void GammaRayTelAnalysis::Finish()
{
#ifdef G4ANALYSIS_USE
delete tree;
//delete plotter;
// delete analysisFactory; // Will delete tree and histos.
delete analysisMessenger;
analysisMessenger = 0;
#endif
}
@@ -201,7 +110,8 @@ GammaRayTelAnalysis* GammaRayTelAnalysis::getInstance()
void GammaRayTelAnalysis::InsertPositionXZ(double x, double z)
{
#ifdef G4ANALYSIS_USE
if(posXZ) posXZ->fill(x, z);
G4AnalysisManager* man = G4AnalysisManager::Instance();
man->FillH2(1,x,z);
#endif
}
@@ -209,7 +119,8 @@ void GammaRayTelAnalysis::InsertPositionXZ(double x, double z)
void GammaRayTelAnalysis::InsertPositionYZ(double y, double z)
{
#ifdef G4ANALYSIS_USE
if(posYZ) posYZ->fill(y, z);
G4AnalysisManager* man = G4AnalysisManager::Instance();
man->FillH2(2,y,z);
#endif
}
@@ -217,7 +128,8 @@ void GammaRayTelAnalysis::InsertPositionYZ(double y, double z)
void GammaRayTelAnalysis::InsertEnergy(double en)
{
#ifdef G4ANALYSIS_USE
if(energy) energy->fill(en);
G4AnalysisManager* man = G4AnalysisManager::Instance();
man->FillH1(1,en);
#endif
}
@@ -225,19 +137,23 @@ void GammaRayTelAnalysis::InsertEnergy(double en)
void GammaRayTelAnalysis::InsertHits(int nplane)
{
#ifdef G4ANALYSIS_USE
if(hits) hits->fill(nplane);
G4AnalysisManager* man = G4AnalysisManager::Instance();
man->FillH1(2,nplane);
#endif
}
void GammaRayTelAnalysis::setNtuple(float E, float p, float x, float y, float z)
{
#ifdef G4ANALYSIS_USE
tuple->fill(tuple->findColumn("energy"),E);
tuple->fill(tuple->findColumn("plane"),p);
tuple->fill(tuple->findColumn("x"),x);
tuple->fill(tuple->findColumn("y"),y);
tuple->fill(tuple->findColumn("z"),z);
tuple->addRow();
G4AnalysisManager* man = G4AnalysisManager::Instance();
man->FillNtupleDColumn(0,E);
man->FillNtupleDColumn(1,p);
man->FillNtupleDColumn(2,x);
man->FillNtupleDColumn(3,y);
man->FillNtupleDColumn(4,z);
man->AddNtupleRow();
#endif
}
@@ -252,11 +168,79 @@ void GammaRayTelAnalysis::setNtuple(float E, float p, float x, float y, float z)
void GammaRayTelAnalysis::BeginOfRun()
{
#ifdef G4ANALYSIS_USE
G4AnalysisManager* man = G4AnalysisManager::Instance();
if(energy) energy->reset();
if(hits) hits->reset();
if(posXZ) posXZ->reset();
if(posYZ) posYZ->reset();
// Open an output file
G4cout << "Opening output file " << histoFileName << " ... ";
man->OpenFile(histoFileName);
man->SetFirstHistoId(1);
G4cout << " done" << G4endl;
int Nplane = GammaRayTelDetector->GetNbOfTKRLayers();
int Nstrip = GammaRayTelDetector->GetNbOfTKRStrips();
int Ntile = GammaRayTelDetector->GetNbOfTKRTiles();
double sizexy = GammaRayTelDetector->GetTKRSizeXY();
double sizez = GammaRayTelDetector->GetTKRSizeZ();
int N = Nstrip*Ntile;
// Book1D histograms
//------------------
// 1D histogram that store the energy deposition of the
// particle in the last (number 0) TKR X-plane
man->CreateH1("1","Edep in the last X plane (keV)", 100, 50, 200);
// 1D histogram that store the hits distribution along the TKR X-planes
man->CreateH1("2","Hits dist in TKR X planes",Nplane, 0, Nplane-1);
// Book 2D histograms
//-------------------
// 2D histogram that store the position (mm) of the hits (XZ projection)
if (histo2DMode == "strip")
{
man->CreateH2("1","Tracker Hits XZ (strip,plane)",
N, 0, N-1,
2*Nplane, 0, Nplane-1);
}
else
{
man->CreateH2("1","Tracker Hits XZ (x,z) in mm",
int(sizexy/5), -sizexy/2, sizexy/2,
int(sizez/5), -sizez/2, sizez/2);
}
// 2D histogram that store the position (mm) of the hits (YZ projection)
if (histo2DMode == "strip")
{
man->CreateH2("2","Tracker Hits YZ (strip,plane)",
N, 0, N-1,
2*Nplane, 0, Nplane-1);
}
else
{
man->CreateH2("2","Tracker Hits YZ (x,z) in mm",
int(sizexy/5), -sizexy/2, sizexy/2,
int(sizez/5), -sizez/2, sizez/2);
}
// Book Ntuples (energy / plane/ x / y / z)
//------------------------------------------
man->CreateNtuple("1","Track ntuple");
man->CreateNtupleDColumn("energy");
man->CreateNtupleDColumn("plane"); // can I use Int values?
man->CreateNtupleDColumn("x"); // can I use Int values?
man->CreateNtupleDColumn("y"); // can I use Int values?
man->CreateNtupleDColumn("z"); // can I use Int values?
man->FinishNtuple();
#endif
}
@@ -266,94 +250,29 @@ void GammaRayTelAnalysis::BeginOfRun()
/*
This member is called at the end of each run
*/
void GammaRayTelAnalysis::EndOfRun(G4int)
void GammaRayTelAnalysis::EndOfRun()
{
#ifdef G4ANALYSIS_USE
if(tree) {
tree->commit();
tree->close();
}
// if(plotter) {
//Save histograms
G4AnalysisManager* man = G4AnalysisManager::Instance();
man->Write();
man->CloseFile();
// Complete clean-up
delete G4AnalysisManager::Instance();
// // We set one single region for the plotter
// // We now print the histograms, each one in a separate file
// if(histo2DSave == "enable") {
// char name[15];
// plotter->createRegions(1,1);
// sprintf(name,"posxz_%d.ps", n);
// plotter->currentRegion().plot(*posXZ);
// plotter->refresh();
// // plotter->write(name,"ps"); // temporary unavailable
// plotter->createRegions(1,1);
// sprintf(name,"posyz_%d.ps", n);
// plotter->currentRegion().plot(*posYZ);
// plotter->next().plot(*posYZ);
// plotter->refresh();
// // plotter->write(name,"ps"); // temporary unavailable
// }
// if(histo1DSave == "enable") {
// plotter->createRegions(1,1);
// char name[15];
// sprintf(name,"energy_%d.ps", n);
// plotter->currentRegion().plot(*energy);
// plotter->refresh();
// // plotter->write(name,"ps"); // temporary unavailable
// plotter->createRegions(1,1);
// sprintf(name,"hits_%d.ps", n);
// plotter->currentRegion().plot(*hits);
// plotter->refresh();
// // plotter->write(name,"ps"); // temporary unavailable
// plotter->createRegions(1,2);
// plotter->currentRegion().plot(*energy);
// plotter->next().plot(*hits);
// plotter->refresh();
// }
#endif
}
/* This member is called at the end of every event */
void GammaRayTelAnalysis::EndOfEvent(G4int flag)
void GammaRayTelAnalysis::EndOfEvent(G4int /* flag */ )
{
// The plotter is updated only if there is some
// hits in the event
if(!flag) return;
#ifdef G4ANALYSIS_USE
// Set the plotter ; set the number of regions and attach histograms
// to plot for each region.
// It is done here, since then EndOfRun set regions
// for paper output.
// if(plotter) {
// if((histo2DDraw == "enable") && (histo1DDraw == "enable")) {
// plotter->createRegions(1,2);
// //plotter->currentRegion().plot(*posXZ); //temporary unavailable
// plotter->currentRegion().plot(*hits);
// // plotter->next().plot(*posYZ); //temporary unavailable
// plotter->next().plot(*energy);
// //plotter->next().plot(*energy);
// // plotter->currentRegion().plot(*hits);
// //plotter->next().plot(*hits);
// } else if((histo1DDraw == "enable") && (histo2DDraw != "enable")) {
// plotter->createRegions(1,2);
// plotter->currentRegion().plot(*energy);
// plotter->next().plot(*hits);
// } else if((histo1DDraw != "enable") && (histo2DDraw == "enable")) {
// /* plotter->createRegions(1,2);
// plotter->currentRegion().plot(*posXZ);
// plotter->next().plot(*posYZ);*/
// G4cout << "Temporary Unavailable " << G4endl;
// } else { // Nothing to plot.
// plotter->createRegions(1,1);
// }
// plotter->refresh();
// }
#endif
}
#endif
examples/advanced/gammaray_telescope/src/GammaRayTelAnalysisMessenger.cc
+1 -81
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelAnalysisMessenger.cc 68794 2013-04-05 13:23:26Z gcosmo $
//
// ------------------------------------------------------------
// GEANT 4 class implementation file
@@ -52,66 +52,6 @@ GammaRayTelAnalysisMessenger::GammaRayTelAnalysisMessenger(GammaRayTelAnalysis*
gammaRayTelAnalysisDir = new G4UIdirectory("/analysis/");
gammaRayTelAnalysisDir->SetGuidance("GammaRayTel analysis control.");
/*
Commands for the 1D histograms (energy deposition in the last
TKR layer and hits distribution along the TKR)
The Draw command gives the possibility to draw the 1d histograms
at every event.
The Save command gives the possibility to save the 1d histograms in
two separate PostScript files at the end of the run.
*/
Histo1DDrawCmd = new G4UIcmdWithAString("/analysis/histo1dDraw",this);
Histo1DDrawCmd->SetGuidance("Enable the drawing of the 1d histograms every event.");
Histo1DDrawCmd->SetGuidance("Choice: disable, enable(default)");
Histo1DDrawCmd->SetParameterName("choice",true);
Histo1DDrawCmd->SetDefaultValue("ebable");
Histo1DDrawCmd->SetCandidates("disable enable");
Histo1DDrawCmd->AvailableForStates(G4State_Idle);
Histo1DSaveCmd = new G4UIcmdWithAString("/analysis/histo1dSave",this);
Histo1DSaveCmd->SetGuidance("Enable the saving of the 1d histograms every run.");
Histo1DSaveCmd->SetGuidance("Choice: disable, enable(default)");
Histo1DSaveCmd->SetParameterName("choice",true);
Histo1DSaveCmd->SetDefaultValue("enable");
Histo1DSaveCmd->SetCandidates("disable enable");
Histo1DSaveCmd->AvailableForStates(G4State_Idle);
/*
Commands for the 2D histograms (hits positions along the TKR)
The Draw command gives the possibility to draw the 1d histograms
at every event.
The Save command gives the possibility to save the 1d histograms in
two separate PostScript files at the end of the run.
Moreover there is the possibility to set the 2d histograms so
that the info stored are true position ((x,z) or (y,z)
coordinates with respect to the payload reference frame in mm) or
the number of the Strip and the number of the Plane in which the
hit occur. To note that this feature is just for visualization
purpouse since both the information are saved in the external ASCII
file.
*/
Histo2DDrawCmd = new G4UIcmdWithAString("/analysis/histo2dDraw",this);
Histo2DDrawCmd->SetGuidance("Enable the drawing of the 2d histograms every events.");
Histo2DDrawCmd->SetGuidance("Choice: disable, enable(default)");
Histo2DDrawCmd->SetParameterName("choice",true);
Histo2DDrawCmd->SetDefaultValue("enable");
Histo2DDrawCmd->SetCandidates("disable enable");
Histo2DDrawCmd->AvailableForStates(G4State_Idle);
Histo2DSaveCmd = new G4UIcmdWithAString("/analysis/histo2dSave",this);
Histo2DSaveCmd->SetGuidance("Enable the saving of the 2d histograms every run.");
Histo2DSaveCmd->SetGuidance("Choice: disable, enable(default)");
Histo2DSaveCmd->SetParameterName("choice",true);
Histo2DSaveCmd->SetDefaultValue("enable");
Histo2DSaveCmd->SetCandidates("disable enable");
Histo2DSaveCmd->AvailableForStates(G4State_Idle);
Histo2DModeCmd = new G4UIcmdWithAString("/analysis/histo2dMode",this);
Histo2DModeCmd->SetGuidance("Select the mode for the 2d histograms.");
Histo2DModeCmd->SetGuidance("Choice: position, strip(default)");
@@ -127,10 +67,6 @@ GammaRayTelAnalysisMessenger::GammaRayTelAnalysisMessenger(GammaRayTelAnalysis*
GammaRayTelAnalysisMessenger::~GammaRayTelAnalysisMessenger()
{
delete Histo1DDrawCmd;
delete Histo1DSaveCmd;
delete Histo2DDrawCmd;
delete Histo2DSaveCmd;
delete Histo2DModeCmd;
}
@@ -139,22 +75,6 @@ GammaRayTelAnalysisMessenger::~GammaRayTelAnalysisMessenger()
void GammaRayTelAnalysisMessenger::SetNewValue(G4UIcommand* command,G4String newValue)
{
// 1D Histograms
if( command == Histo1DDrawCmd )
{ gammaRayTelAnalysis->SetHisto1DDraw(newValue);}
if( command == Histo1DSaveCmd )
{ gammaRayTelAnalysis->SetHisto1DSave(newValue);}
// 2D Histograms
if( command == Histo2DDrawCmd )
{ gammaRayTelAnalysis->SetHisto2DDraw(newValue);}
if( command == Histo2DSaveCmd )
{ gammaRayTelAnalysis->SetHisto2DSave(newValue);}
if( command == Histo2DModeCmd )
{ gammaRayTelAnalysis->SetHisto2DMode(newValue);}
examples/advanced/gammaray_telescope/src/GammaRayTelAnticoincidenceHit.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelAnticoincidenceHit.cc 66508 2012-12-19 10:16:45Z gcosmo $
// ------------------------------------------------------------
// GEANT 4 class implementation file
// CERN Geneva Switzerland
examples/advanced/gammaray_telescope/src/GammaRayTelAnticoincidenceSD.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelAnticoincidenceSD.cc 66508 2012-12-19 10:16:45Z gcosmo $
// ------------------------------------------------------------
// GEANT 4 class implementation file
// CERN Geneva Switzerland
examples/advanced/gammaray_telescope/src/GammaRayTelCalorimeterHit.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelCalorimeterHit.cc 66508 2012-12-19 10:16:45Z gcosmo $
// ------------------------------------------------------------
// GEANT 4 class implementation file
// CERN Geneva Switzerland
examples/advanced/gammaray_telescope/src/GammaRayTelCalorimeterSD.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelCalorimeterSD.cc 66508 2012-12-19 10:16:45Z gcosmo $
// ------------------------------------------------------------
// GEANT 4 class implementation file
// CERN Geneva Switzerland
examples/advanced/gammaray_telescope/src/GammaRayTelDetectorConstruction.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelDetectorConstruction.cc 66508 2012-12-19 10:16:45Z gcosmo $
// ------------------------------------------------------------
// GEANT 4 class implementation file
// CERN Geneva Switzerland
examples/advanced/gammaray_telescope/src/GammaRayTelDetectorMessenger.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelDetectorMessenger.cc 66508 2012-12-19 10:16:45Z gcosmo $
//
// ------------------------------------------------------------
// GEANT 4 class implementation file
examples/advanced/gammaray_telescope/src/GammaRayTelDigi.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelDigi.cc 66508 2012-12-19 10:16:45Z gcosmo $
// ------------------------------------------------------------
// GEANT 4 class implementation file
// CERN Geneva Switzerland
examples/advanced/gammaray_telescope/src/GammaRayTelDigitizer.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelDigitizer.cc 66508 2012-12-19 10:16:45Z gcosmo $
// ------------------------------------------------------------
// GEANT 4 class implementation file
// CERN Geneva Switzerland
examples/advanced/gammaray_telescope/src/GammaRayTelDigitizerMessenger.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelDigitizerMessenger.cc 66508 2012-12-19 10:16:45Z gcosmo $
// ------------------------------------------------------------
// GEANT 4 class implementation file
// CERN Geneva Switzerland
examples/advanced/gammaray_telescope/src/GammaRayTelEMlowePhysics.cc
+5 -5
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelEMlowePhysics.cc 66508 2012-12-19 10:16:45Z gcosmo $
//
//
@@ -81,13 +81,13 @@ void GammaRayTelEMlowePhysics::ConstructProcess()
pManager = G4Gamma::Gamma()->GetProcessManager();
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
theRayleigh->SetModel(new G4LivermoreRayleighModel());
theRayleigh->SetEmModel(new G4LivermoreRayleighModel());
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
thePhotoElectricEffect->SetModel(new G4LivermorePhotoElectricModel());
thePhotoElectricEffect->SetEmModel(new G4LivermorePhotoElectricModel());
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
theComptonScattering->SetModel(new G4LivermoreComptonModel());
theComptonScattering->SetEmModel(new G4LivermoreComptonModel());
G4GammaConversion* theGammaConversion = new G4GammaConversion();
theGammaConversion->SetModel(new G4LivermoreGammaConversionModel());
theGammaConversion->SetEmModel(new G4LivermoreGammaConversionModel());
pManager->AddDiscreteProcess(theRayleigh);
pManager->AddDiscreteProcess(thePhotoElectricEffect);
examples/advanced/gammaray_telescope/src/GammaRayTelEMstdPhysics.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelEMstdPhysics.cc 66508 2012-12-19 10:16:45Z gcosmo $
//
//
examples/advanced/gammaray_telescope/src/GammaRayTelEventAction.cc
+1 -2
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelEventAction.cc 68794 2013-04-05 13:23:26Z gcosmo $
// ------------------------------------------------------------
// GEANT 4 class implementation file
// CERN Geneva Switzerland
@@ -201,7 +201,6 @@ void GammaRayTelEventAction::EndOfEventAction(const G4Event* evt)
#endif
}
// Here we call the analysis manager function for visualization
#ifdef G4ANALYSIS_USE
GammaRayTelAnalysis* analysis = GammaRayTelAnalysis::getInstance();
analysis->EndOfEvent(n_hit);
examples/advanced/gammaray_telescope/src/GammaRayTelGeneralPhysics.cc
+3 -3
View File
@@ -51,9 +51,9 @@ void GammaRayTelGeneralPhysics::ConstructParticle()
void GammaRayTelGeneralPhysics::ConstructProcess()
{
// Add Decay Process
theParticleIterator->reset();
while( (*theParticleIterator)() ){
G4ParticleDefinition* particle = theParticleIterator->value();
aParticleIterator->reset();
while( (*aParticleIterator)() ){
G4ParticleDefinition* particle = aParticleIterator->value();
G4ProcessManager* pmanager = particle->GetProcessManager();
if (fDecayProcess.IsApplicable(*particle) && !particle->IsShortLived()) {
pmanager ->AddProcess(&fDecayProcess);
examples/advanced/gammaray_telescope/src/GammaRayTelHadronPhysics.cc
+65 -249
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelHadronPhysics.cc 76280 2013-11-08 12:54:34Z gcosmo $
//
#include <iomanip>
@@ -38,10 +38,7 @@
GammaRayTelHadronPhysics::GammaRayTelHadronPhysics(const G4String& name)
: G4VPhysicsConstructor(name)
{
}
{;}
GammaRayTelHadronPhysics::~GammaRayTelHadronPhysics()
{
@@ -66,33 +63,49 @@ void GammaRayTelHadronPhysics::ConstructProcess()
*/
// Elastic Process
theElasticModel = new G4LElastic();
theElasticModel = new G4HadronElastic();
theElasticProcess.RegisterMe(theElasticModel);
// pi+ and pi-
const G4double theBERTMin = 0.0*GeV;
const G4double theBERTMax = 5.0*GeV;
const G4double theFTFMin = 4.0*GeV;
const G4double theFTFMax = 100.0*TeV;
theCascade = new G4GeneratorPrecompoundInterface();
thePreEquilib = new G4PreCompoundModel(&theHandler);
theCascade -> SetDeExcitation(thePreEquilib);
theStringModel = new G4QGSModel< G4QGSParticipants >;
theStringDecay = new G4ExcitedStringDecay(new G4QGSMFragmentation);
theStringModel -> SetFragmentationModel(theStringDecay);
theModel = new G4TheoFSGenerator();
theModel -> SetTransport(theCascade);
theModel -> SetHighEnergyGenerator(theStringModel);
theModel -> SetMinEnergy(15*GeV);
theModel -> SetMaxEnergy(100*TeV);
theStringModel = new G4FTFModel;
theStringDecay = new G4ExcitedStringDecay( new G4LundStringFragmentation );
theStringModel->SetFragmentationModel( theStringDecay );
thePreEquilib = new G4PreCompoundModel( new G4ExcitationHandler );
theCascade = new G4GeneratorPrecompoundInterface( thePreEquilib );
theModel = new G4TheoFSGenerator( "FTFP" );
theModel->SetHighEnergyGenerator( theStringModel );
theModel->SetTransport( theCascade );
theModel->SetMinEnergy( theFTFMin );
theModel->SetMaxEnergy( theFTFMax );
G4TheoFSGenerator* theModelDownToZero = new G4TheoFSGenerator( "FTFP" );
theModelDownToZero->SetHighEnergyGenerator( theStringModel );
theModelDownToZero->SetTransport( theCascade );
theModelDownToZero->SetMinEnergy(0*eV);
theModelDownToZero->SetMaxEnergy(theFTFMax );
G4CascadeInterface * theBERTModel = new G4CascadeInterface;
theBERTModel->SetMinEnergy( theBERTMin );
theBERTModel->SetMaxEnergy( theBERTMax );
// pi+ and pi-
G4VCrossSectionDataSet * thePiData = new G4CrossSectionPairGG( new G4PiNuclearCrossSection, 91*GeV );
G4VCrossSectionDataSet * theAntiNucleonData = new G4CrossSectionInelastic( new G4ComponentAntiNuclNuclearXS );
// PionPlus
G4ParticleDefinition* pion = G4PionPlus::PionPlusDefinition();
pManager = pion ->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLEPionPlusModel = new G4LEPionPlusInelastic();
thePionPlusInelastic.RegisterMe(theLEPionPlusModel);
thePionPlusInelastic.AddDataSet(thePiData);
thePionPlusInelastic.RegisterMe(theBERTModel);
thePionPlusInelastic.RegisterMe(theModel);
pManager->AddDiscreteProcess(&thePionPlusInelastic);
@@ -107,9 +120,8 @@ void GammaRayTelHadronPhysics::ConstructProcess()
pManager = pionMinus -> GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLEPionMinusModel = new G4LEPionMinusInelastic();
thePionMinusInelastic.RegisterMe(theLEPionMinusModel);
thePionMinusInelastic.AddDataSet(thePiData);
thePionMinusInelastic.RegisterMe(theBERTModel);
thePionMinusInelastic.RegisterMe(theModel);
pManager->AddDiscreteProcess(&thePionMinusInelastic);
@@ -126,10 +138,9 @@ void GammaRayTelHadronPhysics::ConstructProcess()
pManager = kaonPlus->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLEKaonPlusModel = new G4LEKaonPlusInelastic();
theHEKaonPlusModel = new G4HEKaonPlusInelastic();
theKaonPlusInelastic.RegisterMe(theLEKaonPlusModel);
theKaonPlusInelastic.AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
GetCrossSectionDataSet(G4ChipsKaonPlusInelasticXS::Default_Name()));
theKaonPlusInelastic.RegisterMe(theBERTModel);
theKaonPlusInelastic.RegisterMe(theModel);
pManager->AddDiscreteProcess(&theKaonPlusInelastic);
@@ -144,11 +155,10 @@ void GammaRayTelHadronPhysics::ConstructProcess()
pManager = kaonMinus->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLEKaonMinusModel = new G4LEKaonMinusInelastic();
theHEKaonMinusModel = new G4HEKaonMinusInelastic();
theKaonMinusInelastic.RegisterMe(theLEKaonMinusModel);
theKaonMinusInelastic.RegisterMe(theHEKaonMinusModel);
theKaonMinusInelastic.AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
GetCrossSectionDataSet(G4ChipsKaonMinusInelasticXS::Default_Name()));
theKaonMinusInelastic.RegisterMe(theBERTModel);
theKaonMinusInelastic.RegisterMe(theModel);
pManager->AddDiscreteProcess(&theKaonMinusInelastic);
pManager->AddProcess(&theKaonMinusIonisation, ordInActive,2, 2);
@@ -163,32 +173,28 @@ void GammaRayTelHadronPhysics::ConstructProcess()
pManager = G4KaonZeroLong::KaonZeroLong()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLEKaonZeroLModel = new G4LEKaonZeroLInelastic();
theHEKaonZeroLModel = new G4HEKaonZeroInelastic();
theKaonZeroLInelastic.RegisterMe(theLEKaonZeroLModel);
theKaonZeroLInelastic.RegisterMe(theHEKaonZeroLModel);
theKaonZeroLInelastic.AddDataSet( G4CrossSectionDataSetRegistry::Instance()
->GetCrossSectionDataSet(G4ChipsKaonZeroInelasticXS::Default_Name()));
theKaonZeroLInelastic.RegisterMe(theBERTModel);
theKaonZeroLInelastic.RegisterMe(theModel);
pManager->AddDiscreteProcess(&theKaonZeroLInelastic);
// KaonZeroS
pManager = G4KaonZeroShort::KaonZeroShort()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLEKaonZeroSModel = new G4LEKaonZeroSInelastic();
theHEKaonZeroSModel = new G4HEKaonZeroInelastic();
theKaonZeroSInelastic.RegisterMe(theLEKaonZeroSModel);
theKaonZeroSInelastic.RegisterMe(theHEKaonZeroSModel);
theKaonZeroSInelastic.AddDataSet( G4CrossSectionDataSetRegistry::Instance()
->GetCrossSectionDataSet(G4ChipsKaonZeroInelasticXS::Default_Name()));
theKaonZeroSInelastic.RegisterMe(theBERTModel);
theKaonZeroSInelastic.RegisterMe(theModel);
pManager->AddDiscreteProcess(&theKaonZeroSInelastic);
// Proton
pManager = G4Proton::Proton()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLEProtonModel = new G4LEProtonInelastic();
theHEProtonModel = new G4HEProtonInelastic();
theProtonInelastic.RegisterMe(theLEProtonModel);
theProtonInelastic.AddDataSet(new G4BGGNucleonInelasticXS( G4Proton::Proton() ) );
theProtonInelastic.RegisterMe(theBERTModel);
theProtonInelastic.RegisterMe(theModel);
pManager->AddDiscreteProcess(&theProtonInelastic);
@@ -202,11 +208,8 @@ void GammaRayTelHadronPhysics::ConstructProcess()
pManager = G4AntiProton::AntiProton()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLEAntiProtonModel = new G4LEAntiProtonInelastic();
theHEAntiProtonModel = new G4HEAntiProtonInelastic();
theAntiProtonInelastic.RegisterMe(theLEAntiProtonModel);
theAntiProtonInelastic.RegisterMe(theHEAntiProtonModel);
theAntiProtonInelastic.AddDataSet( theAntiNucleonData );
theAntiProtonInelastic.RegisterMe(theModelDownToZero);
pManager->AddDiscreteProcess(&theAntiProtonInelastic);
pManager->AddProcess(&theAntiProtonIonisation, ordInActive,2, 2);
@@ -221,10 +224,8 @@ void GammaRayTelHadronPhysics::ConstructProcess()
pManager = G4Neutron::Neutron()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLENeutronModel = new G4LENeutronInelastic();
theHENeutronModel = new G4HENeutronInelastic();
theNeutronInelastic.RegisterMe(theLENeutronModel);
theNeutronInelastic.AddDataSet( new G4BGGNucleonInelasticXS( G4Neutron::Neutron() ));
theNeutronInelastic.RegisterMe(theBERTModel);
theNeutronInelastic.RegisterMe(theModel);
pManager->AddDiscreteProcess(&theNeutronInelastic);
@@ -232,201 +233,16 @@ void GammaRayTelHadronPhysics::ConstructProcess()
theNeutronFission.RegisterMe(theNeutronFissionModel);
pManager->AddDiscreteProcess(&theNeutronFission);
theNeutronCaptureModel = new G4LCapture();
theNeutronCapture.RegisterMe(theNeutronCaptureModel);
pManager->AddDiscreteProcess(&theNeutronCapture);
theNeutronCapture = new G4HadronCaptureProcess();
theNeutronCapture->AddDataSet(new G4NeutronCaptureXS());
pManager->AddDiscreteProcess(theNeutronCapture);
// AntiNeutron
pManager = G4AntiNeutron::AntiNeutron()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLEAntiNeutronModel = new G4LEAntiNeutronInelastic();
theHEAntiNeutronModel = new G4HEAntiNeutronInelastic();
theAntiNeutronInelastic.RegisterMe(theLEAntiNeutronModel);
theAntiNeutronInelastic.RegisterMe(theHEAntiNeutronModel);
pManager->AddDiscreteProcess(&theElasticProcess);
theAntiNeutronInelastic.AddDataSet( theAntiNucleonData );
theAntiNeutronInelastic.RegisterMe(theModelDownToZero);
pManager->AddDiscreteProcess(&theAntiNeutronInelastic);
pManager->AddRestProcess(&theAntiNeutronAnnihilation);
// Lambda
pManager = G4Lambda::Lambda()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLELambdaModel = new G4LELambdaInelastic();
theHELambdaModel = new G4HELambdaInelastic();
theLambdaInelastic.RegisterMe(theLELambdaModel);
theLambdaInelastic.RegisterMe(theHELambdaModel);
pManager->AddDiscreteProcess(&theLambdaInelastic);
// AntiLambda
pManager = G4AntiLambda::AntiLambda()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLEAntiLambdaModel = new G4LEAntiLambdaInelastic();
theHEAntiLambdaModel = new G4HEAntiLambdaInelastic();
theAntiLambdaInelastic.RegisterMe(theLEAntiLambdaModel);
theAntiLambdaInelastic.RegisterMe(theHEAntiLambdaModel);
pManager->AddDiscreteProcess(&theAntiLambdaInelastic);
// SigmaMinus
pManager = G4SigmaMinus::SigmaMinus()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLESigmaMinusModel = new G4LESigmaMinusInelastic();
theHESigmaMinusModel = new G4HESigmaMinusInelastic();
theSigmaMinusInelastic.RegisterMe(theLESigmaMinusModel);
theSigmaMinusInelastic.RegisterMe(theHESigmaMinusModel);
pManager->AddDiscreteProcess(&theSigmaMinusInelastic);
pManager->AddProcess(&theSigmaMinusIonisation, ordInActive,2, 2);
pManager->AddProcess(&theSigmaMinusMult);
pManager->SetProcessOrdering(&theSigmaMinusMult, idxAlongStep, 1);
pManager->SetProcessOrdering(&theSigmaMinusMult, idxPostStep, 1);
// anti-SigmaMinus
pManager = G4AntiSigmaMinus::AntiSigmaMinus()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLEAntiSigmaMinusModel = new G4LEAntiSigmaMinusInelastic();
theHEAntiSigmaMinusModel = new G4HEAntiSigmaMinusInelastic();
theAntiSigmaMinusInelastic.RegisterMe(theLEAntiSigmaMinusModel);
theAntiSigmaMinusInelastic.RegisterMe(theHEAntiSigmaMinusModel);
pManager->AddDiscreteProcess(&theAntiSigmaMinusInelastic);
pManager->AddProcess(&theAntiSigmaMinusIonisation, ordInActive,2, 2);
pManager->AddProcess(&theAntiSigmaMinusMult);
pManager->SetProcessOrdering(&theAntiSigmaMinusMult, idxAlongStep, 1);
pManager->SetProcessOrdering(&theAntiSigmaMinusMult, idxPostStep, 1);
// SigmaPlus
pManager = G4SigmaPlus::SigmaPlus()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLESigmaPlusModel = new G4LESigmaPlusInelastic();
theHESigmaPlusModel = new G4HESigmaPlusInelastic();
theSigmaPlusInelastic.RegisterMe(theLESigmaPlusModel);
theSigmaPlusInelastic.RegisterMe(theHESigmaPlusModel);
pManager->AddDiscreteProcess(&theSigmaPlusInelastic);
pManager->AddProcess(&theSigmaPlusIonisation, ordInActive,2, 2);
pManager->AddProcess(&theSigmaPlusMult);
pManager->SetProcessOrdering(&theSigmaPlusMult, idxAlongStep, 1);
pManager->SetProcessOrdering(&theSigmaPlusMult, idxPostStep, 1);
// anti-SigmaPlus
pManager = G4AntiSigmaPlus::AntiSigmaPlus()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLEAntiSigmaPlusModel = new G4LEAntiSigmaPlusInelastic();
theHEAntiSigmaPlusModel = new G4HEAntiSigmaPlusInelastic();
theAntiSigmaPlusInelastic.RegisterMe(theLEAntiSigmaPlusModel);
theAntiSigmaPlusInelastic.RegisterMe(theHEAntiSigmaPlusModel);
pManager->AddDiscreteProcess(&theAntiSigmaPlusInelastic);
pManager->AddProcess(&theAntiSigmaPlusIonisation, ordInActive,2, 2);
pManager->AddProcess(&theAntiSigmaPlusMult);
pManager->SetProcessOrdering(&theAntiSigmaPlusMult, idxAlongStep, 1);
pManager->SetProcessOrdering(&theAntiSigmaPlusMult, idxPostStep, 1);
// XiMinus
pManager = G4XiMinus::XiMinus()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLEXiMinusModel = new G4LEXiMinusInelastic();
theHEXiMinusModel = new G4HEXiMinusInelastic();
theXiMinusInelastic.RegisterMe(theLEXiMinusModel);
theXiMinusInelastic.RegisterMe(theHEXiMinusModel);
pManager->AddDiscreteProcess(&theXiMinusInelastic);
pManager->AddProcess(&theXiMinusIonisation, ordInActive,2, 2);
pManager->AddProcess(&theXiMinusMult);
pManager->SetProcessOrdering(&theXiMinusMult, idxAlongStep, 1);
pManager->SetProcessOrdering(&theXiMinusMult, idxPostStep, 1);
// anti-XiMinus
pManager = G4AntiXiMinus::AntiXiMinus()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLEAntiXiMinusModel = new G4LEAntiXiMinusInelastic();
theHEAntiXiMinusModel = new G4HEAntiXiMinusInelastic();
theAntiXiMinusInelastic.RegisterMe(theLEAntiXiMinusModel);
theAntiXiMinusInelastic.RegisterMe(theHEAntiXiMinusModel);
pManager->AddDiscreteProcess(&theAntiXiMinusInelastic);
pManager->AddProcess(&theAntiXiMinusIonisation, ordInActive,2, 2);
pManager->AddProcess(&theAntiXiMinusMult);
pManager->SetProcessOrdering(&theAntiXiMinusMult, idxAlongStep, 1);
pManager->SetProcessOrdering(&theAntiXiMinusMult, idxPostStep, 1);
// XiZero
pManager = G4XiZero::XiZero()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLEXiZeroModel = new G4LEXiZeroInelastic();
theHEXiZeroModel = new G4HEXiZeroInelastic();
theXiZeroInelastic.RegisterMe(theLEXiZeroModel);
theXiZeroInelastic.RegisterMe(theHEXiZeroModel);
pManager->AddDiscreteProcess(&theXiZeroInelastic);
// anti-XiZero
pManager = G4AntiXiZero::AntiXiZero()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLEAntiXiZeroModel = new G4LEAntiXiZeroInelastic();
theHEAntiXiZeroModel = new G4HEAntiXiZeroInelastic();
theAntiXiZeroInelastic.RegisterMe(theLEAntiXiZeroModel);
theAntiXiZeroInelastic.RegisterMe(theHEAntiXiZeroModel);
pManager->AddDiscreteProcess(&theAntiXiZeroInelastic);
// OmegaMinus
pManager = G4OmegaMinus::OmegaMinus()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLEOmegaMinusModel = new G4LEOmegaMinusInelastic();
theHEOmegaMinusModel = new G4HEOmegaMinusInelastic();
theOmegaMinusInelastic.RegisterMe(theLEOmegaMinusModel);
theOmegaMinusInelastic.RegisterMe(theHEOmegaMinusModel);
pManager->AddDiscreteProcess(&theOmegaMinusInelastic);
pManager->AddProcess(&theOmegaMinusIonisation, ordInActive,2, 2);
pManager->AddProcess(&theOmegaMinusMult);
pManager->SetProcessOrdering(&theOmegaMinusMult, idxAlongStep, 1);
pManager->SetProcessOrdering(&theOmegaMinusMult, idxPostStep, 1);
// anti-OmegaMinus
pManager = G4AntiOmegaMinus::AntiOmegaMinus()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLEAntiOmegaMinusModel = new G4LEAntiOmegaMinusInelastic();
theHEAntiOmegaMinusModel = new G4HEAntiOmegaMinusInelastic();
theAntiOmegaMinusInelastic.RegisterMe(theLEAntiOmegaMinusModel);
theAntiOmegaMinusInelastic.RegisterMe(theHEAntiOmegaMinusModel);
pManager->AddDiscreteProcess(&theAntiOmegaMinusInelastic);
pManager->AddProcess(&theAntiOmegaMinusIonisation, ordInActive,2, 2);
pManager->AddProcess(&theAntiOmegaMinusMult);
pManager->SetProcessOrdering(&theAntiOmegaMinusMult, idxAlongStep, 1);
pManager->SetProcessOrdering(&theAntiOmegaMinusMult, idxPostStep, 1);
}
examples/advanced/gammaray_telescope/src/GammaRayTelIonPhysics.cc
+38 -17
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelIonPhysics.cc 76280 2013-11-08 12:54:34Z gcosmo $
//
//
@@ -37,17 +37,13 @@
GammaRayTelIonPhysics::GammaRayTelIonPhysics(const G4String& name)
: G4VPhysicsConstructor(name)
{
}
{;}
GammaRayTelIonPhysics::~GammaRayTelIonPhysics()
{
}
{;}
void GammaRayTelIonPhysics::ConstructParticle()
{
}
{;}
#include "G4ProcessManager.hh"
@@ -57,8 +53,29 @@ void GammaRayTelIonPhysics::ConstructProcess()
{
G4ProcessManager * pManager = 0;
const G4double theBERTMin = 0.0*GeV;
const G4double theBERTMax = 5.0*GeV;
const G4double theFTFMin = 4.0*GeV;
const G4double theFTFMax = 100.0*TeV;
G4FTFModel* theStringModel = new G4FTFModel;
G4ExcitedStringDecay* theStringDecay = new G4ExcitedStringDecay( new G4LundStringFragmentation );
theStringModel->SetFragmentationModel( theStringDecay );
G4PreCompoundModel* thePreEquilib = new G4PreCompoundModel( new G4ExcitationHandler );
G4GeneratorPrecompoundInterface* theCascade = new G4GeneratorPrecompoundInterface( thePreEquilib );
G4TheoFSGenerator* theModel = new G4TheoFSGenerator( "FTFP" );
theModel->SetHighEnergyGenerator( theStringModel );
theModel->SetTransport( theCascade );
theModel->SetMinEnergy( theFTFMin );
theModel->SetMaxEnergy( theFTFMax );
G4CascadeInterface * theBERTModel = new G4CascadeInterface;
theBERTModel->SetMinEnergy( theBERTMin );
theBERTModel->SetMaxEnergy( theBERTMax );
// Elastic Process
theElasticModel = new G4LElastic();
theElasticModel = new G4HadronElastic();
theElasticProcess.RegisterMe(theElasticModel);
// Generic Ion
@@ -72,13 +89,16 @@ void GammaRayTelIonPhysics::ConstructProcess()
pManager->SetProcessOrdering(&fIonMultipleScattering, idxAlongStep, 1);
pManager->SetProcessOrdering(&fIonMultipleScattering, idxPostStep, 1);
G4VCrossSectionDataSet * theGGNuclNuclData = G4CrossSectionDataSetRegistry::Instance()->
GetCrossSectionDataSet(G4GGNuclNuclCrossSection::Default_Name());
// Deuteron
pManager = G4Deuteron::Deuteron()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
fDeuteronModel = new G4LEDeuteronInelastic();
fDeuteronProcess.RegisterMe(fDeuteronModel);
fDeuteronProcess.AddDataSet(theGGNuclNuclData);
fDeuteronProcess.RegisterMe(theBERTModel);
fDeuteronProcess.RegisterMe(theModel);
pManager->AddDiscreteProcess(&fDeuteronProcess);
pManager->AddProcess(&fDeuteronIonisation, ordInActive, 2, 2);
@@ -91,9 +111,9 @@ void GammaRayTelIonPhysics::ConstructProcess()
pManager = G4Triton::Triton()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
fTritonModel = new G4LETritonInelastic();
fTritonProcess.RegisterMe(fTritonModel);
fTritonProcess.AddDataSet(theGGNuclNuclData);
fTritonProcess.RegisterMe(theBERTModel);
fTritonProcess.RegisterMe(theModel);
pManager->AddDiscreteProcess(&fTritonProcess);
pManager->AddProcess(&fTritonIonisation, ordInActive, 2, 2);
@@ -107,8 +127,9 @@ void GammaRayTelIonPhysics::ConstructProcess()
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
fAlphaModel = new G4LEAlphaInelastic();
fAlphaProcess.RegisterMe(fAlphaModel);
fAlphaProcess.AddDataSet(theGGNuclNuclData);
fAlphaProcess.RegisterMe(theBERTModel);
fAlphaProcess.RegisterMe(theModel);
pManager->AddDiscreteProcess(&fAlphaProcess);
pManager->AddProcess(&fAlphaIonisation, ordInActive, 2, 2);
examples/advanced/gammaray_telescope/src/GammaRayTelMuonPhysics.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelMuonPhysics.cc 66508 2012-12-19 10:16:45Z gcosmo $
//
#include "GammaRayTelMuonPhysics.hh"
examples/advanced/gammaray_telescope/src/GammaRayTelPhysicsList.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelPhysicsList.cc 66508 2012-12-19 10:16:45Z gcosmo $
//
//
#include <iomanip>
examples/advanced/gammaray_telescope/src/GammaRayTelPrimaryGeneratorAction.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelPrimaryGeneratorAction.cc 66508 2012-12-19 10:16:45Z gcosmo $
// ------------------------------------------------------------
// GEANT 4 class implementation file
// CERN Geneva Switzerland
examples/advanced/gammaray_telescope/src/GammaRayTelPrimaryGeneratorMessenger.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelPrimaryGeneratorMessenger.cc 66508 2012-12-19 10:16:45Z gcosmo $
// ------------------------------------------------------------
// GEANT 4 class implementation file
// CERN Geneva Switzerland
examples/advanced/gammaray_telescope/src/GammaRayTelRunAction.cc
+2 -2
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelRunAction.cc 68794 2013-04-05 13:23:26Z gcosmo $
// ------------------------------------------------------------
// GEANT 4 class implementation file
// CERN Geneva Switzerland
@@ -119,7 +119,7 @@ void GammaRayTelRunAction::EndOfRunAction(const G4Run* aRun)
// If analysis is used, print out the histograms
#ifdef G4ANALYSIS_USE
GammaRayTelAnalysis* analysis = GammaRayTelAnalysis::getInstance();
analysis->EndOfRun(aRun->GetRunID());
analysis->EndOfRun();
#endif
}
examples/advanced/gammaray_telescope/src/GammaRayTelTrackerHit.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelTrackerHit.cc 66508 2012-12-19 10:16:45Z gcosmo $
// ------------------------------------------------------------
// GEANT 4 class implementation file
// CERN Geneva Switzerland
examples/advanced/gammaray_telescope/src/GammaRayTelTrackerROGeometry.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: GammaRayTelTrackerROGeometry.cc 66508 2012-12-19 10:16:45Z gcosmo $
//
//
// ------------------------------------------------------------