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

Import Geant4 11.3.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2024-06-28 13:08:51 +02:00
parent f7b23877ed
commit e58e650b32
5232 changed files with 239416 additions and 244360 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/extended/errorpropagation/errProp/errProp.cc
+115 -119
View File
@@ -36,32 +36,30 @@
//
#include "ExErrorDetectorConstruction.hh"
#include "G4SteppingVerbose.hh"
#include "G4ErrorCylSurfaceTarget.hh"
#include "G4ErrorFreeTrajState.hh"
#include "G4ErrorGeomVolumeTarget.hh"
#include "G4ErrorPlaneSurfaceTarget.hh"
#include "G4ErrorPropagator.hh"
#include "G4ErrorPropagatorData.hh"
#include "G4ErrorPropagatorManager.hh"
#include "G4ErrorPlaneSurfaceTarget.hh"
#include "G4ErrorCylSurfaceTarget.hh"
#include "G4ErrorGeomVolumeTarget.hh"
#include "G4ErrorTrackLengthTarget.hh"
#include "G4ErrorFreeTrajState.hh"
#include "G4UImanager.hh"
#include "G4SteppingVerbose.hh"
#include "G4SystemOfUnits.hh"
#include "G4UImanager.hh"
void Initialize();
G4ErrorTarget* BuildTarget( G4int iTarget );
void ProcessEvent( G4int iProp, size_t nEv );
G4ErrorTarget* BuildTarget(G4int iTarget);
void ProcessEvent(G4int iProp, size_t nEv);
void Finalize();
G4ErrorTarget* theTarget;
G4ErrorMode theG4ErrorMode;
//-------------------------------------------------------------
int main()
int main()
{
Initialize();
//----- Choose propagation mode
@@ -69,45 +67,43 @@ int main()
// 1: propagate until target, returning control to the user at each step
G4int iProp = 0;
char* prop = std::getenv("G4ERROR_PROP");
if( prop ) {
if( G4String(prop) == G4String("UNTIL_TARGET") ){
if (prop) {
if (G4String(prop) == G4String("UNTIL_TARGET")) {
iProp = 0;
} else if ( G4String(prop) == G4String("STEP_BY_STEP") ) {
iProp = 1;
} else {
G4Exception("exG4eReco","Fatal error in Argument",
FatalErrorInArgument,
G4String("Variable G4ERROR_PROP = " + G4String(prop) +
" It must be: UNTIL_TARGET or STEP_BY_STEP").c_str());
}
} else {
G4Exception("exG4eReco","Fatal error in Argument",
JustWarning,
"Variable G4ERROR_PROP not defined, taking it = UNTIL_TARGET");
}
else if (G4String(prop) == G4String("STEP_BY_STEP")) {
iProp = 1;
}
else {
G4Exception("exG4eReco", "Fatal error in Argument", FatalErrorInArgument,
G4String("Variable G4ERROR_PROP = " + G4String(prop)
+ " It must be: UNTIL_TARGET or STEP_BY_STEP")
.c_str());
}
}
else {
G4Exception("exG4eReco", "Fatal error in Argument", JustWarning,
"Variable G4ERROR_PROP not defined, taking it = UNTIL_TARGET");
}
size_t nEvents = 3;
for( size_t ii = 0; ii < nEvents; ii++ ){
ProcessEvent( iProp, ii );
for (size_t ii = 0; ii < nEvents; ii++) {
ProcessEvent(iProp, ii);
}
Finalize();
}
//-------------------------------------------------------------
void Initialize()
void Initialize()
{
G4VSteppingVerbose::SetInstance(new G4SteppingVerbose);
// Initialize the GEANT4e manager
G4ErrorPropagatorManager* g4emgr
= G4ErrorPropagatorManager::GetErrorPropagatorManager();
G4ErrorPropagatorData* g4edata
= G4ErrorPropagatorData::GetErrorPropagatorData();
// Initialize the GEANT4e manager
G4ErrorPropagatorManager* g4emgr = G4ErrorPropagatorManager::GetErrorPropagatorManager();
G4ErrorPropagatorData* g4edata = G4ErrorPropagatorData::GetErrorPropagatorData();
g4emgr->SetUserInitialization(new ExErrorDetectorConstruction);
g4emgr->SetUserInitialization(new ExErrorDetectorConstruction);
G4UImanager::GetUIpointer()->ApplyCommand("/exerror/setField -10. kilogauss");
@@ -124,92 +120,93 @@ void Initialize()
// 4: TrackLengthTarget
G4int iTarget = 1;
char* target = std::getenv("G4ERROR_TARGET");
if( target ) {
if( G4String(target) == G4String("PLANE_SURFACE") ) {
if (target) {
if (G4String(target) == G4String("PLANE_SURFACE")) {
iTarget = 1;
}else if( G4String(target) == G4String("CYL_SURFACE") ) {
iTarget = 2;
}else if( G4String(target) == G4String("VOLUME") ) {
iTarget = 3;
}else if( G4String(target) == G4String("TRKLEN") ) {
iTarget = 4;
}else {
G4Exception("exG4eReco","Fatal error in Argument",
FatalErrorInArgument,
G4String("Variable G4ERROR_TARGET = " + G4String(target) +
" It must be: PLANE_SURFACE, CYL_SURFACE, VOLUME, TRKLEN").c_str());
}
} else {
G4Exception("exG4eReco","Fatal error in Argument",
JustWarning,"Variable G4ERROR_TARGET not defined, taking it = PLANE_SURFACE");
}
else if (G4String(target) == G4String("CYL_SURFACE")) {
iTarget = 2;
}
else if (G4String(target) == G4String("VOLUME")) {
iTarget = 3;
}
else if (G4String(target) == G4String("TRKLEN")) {
iTarget = 4;
}
else {
G4Exception("exG4eReco", "Fatal error in Argument", FatalErrorInArgument,
G4String("Variable G4ERROR_TARGET = " + G4String(target)
+ " It must be: PLANE_SURFACE, CYL_SURFACE, VOLUME, TRKLEN")
.c_str());
}
}
else {
G4Exception("exG4eReco", "Fatal error in Argument", JustWarning,
"Variable G4ERROR_TARGET not defined, taking it = PLANE_SURFACE");
}
theTarget = BuildTarget( iTarget );
g4edata->SetTarget( theTarget );
theTarget = BuildTarget(iTarget);
g4edata->SetTarget(theTarget);
theG4ErrorMode = G4ErrorMode_PropBackwards;
char* mode = std::getenv("G4ERROR_MODE");
if( mode ) {
if( G4String(mode) == G4String("FORWARDS") ) {
if (mode) {
if (G4String(mode) == G4String("FORWARDS")) {
theG4ErrorMode = G4ErrorMode_PropForwards;
} else if( G4String(mode) == G4String("BACKWARDS") ) {
theG4ErrorMode = G4ErrorMode_PropBackwards;
} else {
G4Exception("exG4eReco","Fatal error in Argument",
FatalErrorInArgument,
G4String("Variable G4ERROR_MODE = " + G4String(mode) +
" It must be: FORWARDS or BACKWARDS").c_str());
}
} else {
G4Exception("exG4eReco","Fatal error in Argument",
JustWarning,"Variable G4ERROR_MODE not defined, taking it = BACKWARDS");
}
else if (G4String(mode) == G4String("BACKWARDS")) {
theG4ErrorMode = G4ErrorMode_PropBackwards;
}
else {
G4Exception("exG4eReco", "Fatal error in Argument", FatalErrorInArgument,
G4String("Variable G4ERROR_MODE = " + G4String(mode)
+ " It must be: FORWARDS or BACKWARDS")
.c_str());
}
}
else {
G4Exception("exG4eReco", "Fatal error in Argument", JustWarning,
"Variable G4ERROR_MODE not defined, taking it = BACKWARDS");
}
}
void ProcessEvent( G4int iProp, size_t )
void ProcessEvent(G4int iProp, size_t)
{
// Set the starting trajectory.
G4ThreeVector xv3( 0, 0, 0 );
G4ThreeVector pv3( 20.0*GeV, 0.0, 0.0 );
G4ErrorTrajErr error( 5, 0 );
G4ErrorFreeTrajState* g4ErrorTrajState
= new G4ErrorFreeTrajState( "mu-", xv3, pv3, error );
// Set the starting trajectory.
G4ThreeVector xv3(0, 0, 0);
G4ThreeVector pv3(20.0 * GeV, 0.0, 0.0);
G4ErrorTrajErr error(5, 0);
G4ErrorFreeTrajState* g4ErrorTrajState = new G4ErrorFreeTrajState("mu-", xv3, pv3, error);
G4ErrorPropagatorManager* g4emgr
= G4ErrorPropagatorManager::GetErrorPropagatorManager();
G4ErrorPropagatorManager* g4emgr = G4ErrorPropagatorManager::GetErrorPropagatorManager();
//int ierr = 0;
// int ierr = 0;
G4Point3D surfPos(224.*cm,0.,0.);
G4Normal3D surfNorm(1.,0.,0.);
//- G4ErrorTarget* theG4ErrorTarget
G4Point3D surfPos(224. * cm, 0., 0.);
G4Normal3D surfNorm(1., 0., 0.);
//- G4ErrorTarget* theG4ErrorTarget
// = new G4ErrorPlaneSurfaceTarget(surfNorm, surfPos );
if( iProp == 0){
if (iProp == 0) {
// Propagate until G4ErrorTarget is found all in one go
//ierr =
g4emgr->Propagate( g4ErrorTrajState, theTarget, theG4ErrorMode );
} else if( iProp == 1){
// ierr =
g4emgr->Propagate(g4ErrorTrajState, theTarget, theG4ErrorMode);
}
else if (iProp == 1) {
// Propagate until G4ErrorTarget is reached step by step
g4emgr->InitTrackPropagation();
// G4Track* aTrack
// G4Track* aTrack
// = G4EventManager::GetEventManager()->GetTrackingManager()->GetTrack();
bool moreEvt = TRUE;
while( moreEvt ){
//ierr =
g4emgr->PropagateOneStep( g4ErrorTrajState, theG4ErrorMode );
while (moreEvt) {
// ierr =
g4emgr->PropagateOneStep(g4ErrorTrajState, theG4ErrorMode);
//---- Check if target is reached
if( g4emgr->GetPropagator()->CheckIfLastStep( g4ErrorTrajState->GetG4Track() )) {
g4emgr->GetPropagator()
->InvokePostUserTrackingAction( g4ErrorTrajState->GetG4Track() );
if (g4emgr->GetPropagator()->CheckIfLastStep(g4ErrorTrajState->GetG4Track())) {
g4emgr->GetPropagator()->InvokePostUserTrackingAction(g4ErrorTrajState->GetG4Track());
moreEvt = 0;
G4cout << "STEP_BY_STEP propagation: Last Step " << G4endl;
}
@@ -222,39 +219,38 @@ void ProcessEvent( G4int iProp, size_t )
G4Normal3D momEnd = g4ErrorTrajState->GetMomentum();
G4ErrorTrajErr errorEnd = g4ErrorTrajState->GetError();
G4cout << " Position: " << posEnd << G4endl
<< " Momentum: " << momEnd << G4endl
<< " Error: " << errorEnd << G4endl;
G4cout << " Position: " << posEnd << G4endl << " Momentum: " << momEnd << G4endl
<< " Error: " << errorEnd << G4endl;
}
//-------------------------------------------------------------
G4ErrorTarget* BuildTarget( G4int iTarget )
G4ErrorTarget* BuildTarget(G4int iTarget)
{
G4ErrorTarget* target = 0;
if( iTarget == 1 ) {
G4Point3D surfPos(221.*cm,0.,0.);
G4Normal3D surfNorm(1.,0.,0.);
target = new G4ErrorPlaneSurfaceTarget(surfNorm, surfPos );
}else if( iTarget == 2 ) {
G4double radius = 222*cm;
if (iTarget == 1) {
G4Point3D surfPos(221. * cm, 0., 0.);
G4Normal3D surfNorm(1., 0., 0.);
target = new G4ErrorPlaneSurfaceTarget(surfNorm, surfPos);
}
else if (iTarget == 2) {
G4double radius = 222 * cm;
target = new G4ErrorCylSurfaceTarget(radius);
}else if( iTarget == 3 ) {
}
else if (iTarget == 3) {
target = new G4ErrorGeomVolumeTarget("MUON");
}else if( iTarget == 4 ) {
target = new G4ErrorTrackLengthTarget(223.*cm);
}else {
G4Exception("exG4eReco","Fatal error in Argument",
FatalErrorInArgument,"Target type has to be between 1 and 4");
}
else if (iTarget == 4) {
target = new G4ErrorTrackLengthTarget(223. * cm);
}
else {
G4Exception("exG4eReco", "Fatal error in Argument", FatalErrorInArgument,
"Target type has to be between 1 and 4");
}
return target;
}
//-------------------------------------------------------------
void Finalize()
{
G4ErrorPropagatorManager::GetErrorPropagatorManager()->CloseGeometry();
}