testA01.cxx File Reference

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

#include "A01MCApplication.h"
#include "A01PrimaryGenerator.h"
#include "TInterpreter.h"
#include "TROOT.h"
#include "TThread.h"
#include <iostream>
#include <string>

Include dependency graph for testA01.cxx:

Go to the source code of this file.

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

Detailed Description

The Geant4 VMC example A01 test application.

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

Usage: testA01 [-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) [-rm, –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_A01.C("",kFALSE)'

Date

26/02/2014

Author

I. Hrivnacova; IPN, Orsay

Definition in file testA01.cxx.

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Application main program.

Definition at line 144 of file testA01.cxx.

{
  // Initialize Root threading.
  // (Multi-threading is triggered automatically if Geant4 was built
  //  in MT mode.)
#ifdef G4MULTITHREADED
  ROOT::EnableThreadSafety();
#endif
 
  // Process arguments
  // This code is generic with the exception of the start values and
  // the program name
#ifdef USE_GEANT4
  std::string g4Geometry = "geomRootToGeant4";
  std::string g4PhysicsList = "FTFP_BERT";
  std::string g4SpecialPhysics = "stepLimiter";
  std::string g4Macro = "g4config.in";
  std::string g4VisMacro = "g4vis.in";
  std::string g4Session = "";
  std::string g4UserClass = "";
  std::string g4LocalField = "";
#endif
#ifdef USE_GEANT3
  std::string g3Geometry = "TGeant3TGeo";
#endif
  std::string rootMacro = "";
  std::string verbose = "yes";
 
  for (Int_t i = 1; i < argc; i = i + 2) {
    std::cout << "processing " << argv[i] << " with " << argv[i + 1]
              << std::endl;
#ifdef USE_GEANT4
    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];
    else if (std::string(argv[i]) == "--g4-local-field" ||
             std::string(argv[i]) == "-g4lf")
      g4LocalField = argv[i + 1];
#endif
#ifdef USE_GEANT3
    if (std::string(argv[i]) == "--g3-geometry" ||
        std::string(argv[i]) == "-g3g")
      g3Geometry = argv[i + 1];
#endif
    else 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];
    else {
      PrintUsage("testA01");
      return 1;
    }
  }
 
  if (verbose == "yes") {
#ifdef USE_GEANT4
    PrintG4Configuration("testA01", g4Geometry, g4PhysicsList, g4SpecialPhysics,
      g4Macro, g4VisMacro, g4Session, g4UserClass, g4LocalField, rootMacro);
#endif
#ifdef USE_GEANT3
    PrintG3Configuration("testA01", g3Geometry, rootMacro);
#endif
  }
  //
  // end of code to process arguments
 
  // Create MC application (thread local)
  A01MCApplication* appl =
    new A01MCApplication("ExampleA01", "The exampleA01 MC application");
#ifdef USE_GEANT4
  // Local magnetic field option
  if (g4LocalField.size()) {
    G4cout << "setting local field to true" << G4endl;
    appl->SetUseLocalMagField(true);
  }
 
  // RunConfiguration for Geant4
  TG4RunConfiguration* runConfiguration = 0;
  if (!g4UserClass.size()) {
    runConfiguration =
      new TG4RunConfiguration(g4Geometry, g4PhysicsList, g4SpecialPhysics);
  }
  else if (g4UserClass == "geometry") {
    runConfiguration = new A01RunConfiguration(g4PhysicsList, g4SpecialPhysics);
    // Local magnetic field option
    if (g4LocalField.size()) {
      static_cast<A01RunConfiguration*>(runConfiguration)
        ->SetUseLocalMagField(true);
    }
  }
  else {
    PrintUsage("testA01");
    return 1;
  }
 
  // TGeant4
  // TO DO: pass g4session here
  TGeant4* geant4 = new TGeant4(
    "TGeant4", "The Geant4 Monte Carlo", runConfiguration, argc, argv);
 
  // Customise Geant4 setting
  // (verbose level, global range cut, ..)
  if (g4Macro.size()) {
    geant4->ProcessGeantMacro(g4Macro.data());
  }
#endif
 
#ifdef USE_GEANT3
  if (g3Geometry == "TGeant3") {
    new TGeant3("C++ Interface to Geant3");
  }
  else if (g3Geometry == "TGeant3TGeo") {
    new TGeant3TGeo("C++ Interface to Geant3");
  }
  else {
    PrintUsage("testA01");
    return 1;
  }
  gMC->SetProcess("DRAY", 1);
  gMC->SetProcess("LOSS", 1);
  gMC->SetProcess("HADR", 1);
#endif
 
  // Run example
  if (!rootMacro.size()) {
    // Run from this main
    appl->GetPrimaryGenerator()->SetRandomize(false);
    appl->SetWriteStack(true);
    appl->SetWriteHits(true);
    appl->InitMC("");
#ifdef USE_GEANT4
    // Setting Geant4 visualization
    if (g4VisMacro.size()) {
      geant4->ProcessGeantMacro(g4VisMacro.data());
    }
#endif
    appl->RunMC(5);
  }
  else {
    // Run from Root macro
    gROOT->Macro(rootMacro.data());
  }
 
  delete appl;
}