The Geant4 VMC example E03c test application. More...

#include "Ex03PrimaryGenerator.h"
#include "Ex03cMCApplication.h"
#include "TROOT.h"
#include <iostream>
#include <string>

Include dependency graph for testE03c.cxx:

Go to the source code of this file.

Functions
int	main (int argc, char **argv)
	Application main program.

Variables
std::string	firstEngine = "g3"

std::string	rootMacro = ""

std::string	verbose = "yes"

Detailed Description

The Geant4 VMC example E03c test application.

The Geant4 VMC test application with explicitely instantiated TGeant3 or TGeant4 and linked with all libraries.

Usage:
testE03c
  [-g4g,  --g4-geometry]:        Geant4 VMC geometry option
  [-g4pl, --g4-physics-list]:    Geant4 physics list selection
  [-g4sp, --g4-special-physics]: Geant4 special physics selection
  [-g4m,  --g4-macro]:           Geant4 macro
  [-g4vm, --g4-vis-macro]:       Geant4 visualization macro
  [-g3g,  --g3-geometry]:        Geant3 geometry option
  (TGeant3,TGeant3TGeo)
  [-r4m,  --root-macro]:         Root macro
  [-v,    --verbose]:            verbose option (yes,no)

Note that the g4* and g3* options are available only when built
with the corresponding VMC_WITH_Geant4 or VMC_WITH_Geant3 option.
Root macro with arguments should be passed within '', eg.
 --root-macro 'test_E03c_1.C("",kFALSE)'

Date: 30/04/2019 Benedikt Volkel, CERN

Definition in file testE03c.cxx.

Function Documentation

◆ main()

int main	(	int	argc,
		char **	argv )

Application main program.

Definition at line 196 of file testE03c.cxx.

{
// Initialize Root threading.
// (Multi-threading is triggered automatically if Geant4 was built
//  in MT mode.)
#ifdef G4MULTITHREADED
  ROOT::EnableThreadSafety();
#endif
 
  // Process arguments
  for (Int_t i = 1; i < argc; i = i + 2) {
    std::cout << "processing " << argv[i] << " with " << argv[i + 1]
              << std::endl;
    if (std::string(argv[i]) == "--root-macro" || std::string(argv[i]) == "-rm")
      rootMacro = argv[i + 1];
    else if (std::string(argv[i]) == "--verbose" ||
             std::string(argv[i]) == "-v")
      verbose = argv[i + 1];
#ifdef USE_GEANT4
    else if (std::string(argv[i]) == "--g4-geometry" ||
             std::string(argv[i]) == "-g4g")
      g4Geometry = argv[i + 1];
    else if (std::string(argv[i]) == "--g4-physics-list" ||
             std::string(argv[i]) == "-g4pl")
      g4PhysicsList = argv[i + 1];
    else if (std::string(argv[i]) == "--g4-special-physics" ||
             std::string(argv[i]) == "-g4sp")
      g4SpecialPhysics = argv[i + 1];
    else if (std::string(argv[i]) == "--g4-macro" ||
             std::string(argv[i]) == "-g4m")
      g4Macro = argv[i + 1];
    else if (std::string(argv[i]) == "--g4-vis-macro" ||
             std::string(argv[i]) == "-g4vm")
      g4VisMacro = argv[i + 1];
    else if (std::string(argv[i]) == "--g4-session" ||
             std::string(argv[i]) == "-g4s")
      g4Session = argv[i + 1];
    // the following option is specific to use of Geant4 dependent classes
    else if (std::string(argv[i]) == "--g4-user-class" ||
             std::string(argv[i]) == "-g4uc")
      g4UserClass = argv[i + 1];
#endif
#ifdef USE_GEANT3
    else if (std::string(argv[i]) == "--g3-geometry" ||
             std::string(argv[i]) == "-g3g")
      g3Geometry = argv[i + 1];
#endif
#ifdef USE_MULTI
    else if (std::string(argv[i]) == "--first-engine" ||
             std::string(argv[i]) == "-fe")
      firstEngine = argv[i + 1];
#endif
    else {
      PrintUsage("testE03c");
      return 1;
    }
  }
 
  if (verbose == "yes") {
    PrintConfiguration("testE03c");
  }
  //
  // end of code to process arguments
 
  Bool_t isMulti = false;
  Int_t debug = 0;
#ifdef USE_MULTI
  isMulti = true;
  debug = 1;
#endif
 
  // Create MC application (thread local)
  Ex03cMCApplication* appl = new Ex03cMCApplication(
    "ExampleE03", "The exampleE03 MC application", isMulti, isMulti);
  appl->SetDebug(debug);
 
  if (firstEngine == "g3") {
    CreateGeant3();
    CreateGeant4(argc, argv);
  }
  else {
    CreateGeant4(argc, argv);
    CreateGeant3();
  }
 
  if (!rootMacro.size()) {
    // Run example without Root macro
#ifdef USE_MULTI
    appl->InitMC();
#else
    appl->InitMC("");
#endif
 
    // Setting Geant4 visualization
    // #ifdef USE_GEANT4
    // #ifndef USE_MULTI
    //     if (g4VisMacro.size()) {
    //       geant4->ProcessGeantMacro(g4VisMacro.data());
    //     }
    // #endif
    // #endif
    appl->RunMC(5);
  }
  else {
    // Run from Root macro
    std::cout << "Go to call macro" << std::endl;
    gROOT->Macro(rootMacro.data());
  }
 
  delete appl;
}

Variable Documentation

◆ firstEngine

std::string firstEngine = "g3"

Definition at line 73 of file testE03c.cxx.

◆ rootMacro

std::string rootMacro = ""

Definition at line 74 of file testE03c.cxx.

◆ verbose

std::string verbose = "yes"

Definition at line 75 of file testE03c.cxx.

Functions