source: snovis/trunk/applications/snovis_session.cc@ 90

/* 
 * Version of prog_snova.cc to handle a G4Lab::UIOnX session
 */

#include <snova/snova_const.hh>
#include <snova/geometry2.hh>         // Geometry definition
#include <snova/physics.hh>           // Physical proceses to consider
#include <snova/generator.hh>         // Initial particles generator
#include <snova/run.hh>               // User actions per run basis
#include <snova/event.hh>             // User actions per event basis
#include <snova/tracking.hh>          // User actions per track basis
#include <snova/stacking.hh>          // User actions related with tracks stacking
#include <snova/stepping.hh>          // User actions per step basis
#include <snova/stepping_verbose.hh>  // Information dump per step basis

#include <G4RunManager.hh>  // Program manager
#include <G4UImanager.hh>   // User Interface manager

#include <bhep/bhep_svc.h>
#include <bhep/sreader.h>

// G4Lab :
#include <G4Lab/UIOnX.h> //UIOnX
#include "Environment.h"

using namespace snova;

int main( int argc , char** argv ) 
{
  if(argc<=0) return 1;
  if(!check_envs(argv[0])) return 1;

  //std::string params_filename = snova::constants::DEF_PARAMS_FILENAME;
  std::string SNOVISROOT;
  if(!Lib::System::getenv("SNOVISROOT",SNOVISROOT)) {
    G4cout << "snovis_session :"
           << " Environment variable SNOVISROOT not defined."
           << G4endl;
    return 1;
  }
  std::string params_filename = SNOVISROOT+"/scripts/snova.par";
  G4String geom_filename = SNOVISROOT+"/scripts/snemo.geom";

  // create a generic store:
  bhep::gstore store;
  G4cout << G4endl << "***** Reading parameters from '" 
         << params_filename << "' file ..." 
         << G4endl << G4endl;

  // and a reader:
  bhep::sreader reader(store);
  reader.file(params_filename);
  reader.info_level(NORMAL);
  reader.group("GLOBAL");
  reader.read();

  G4String sim_verbosity = store.fetch_sstore("simulation_verbosity");
  G4cout << "***** Simulation verbosity set to: " << sim_verbosity << G4endl;

  G4String G4Tracking_verbosity = store.fetch_sstore("G4Tracking_verbosity");
  G4cout << "***** G4 Tracking verbosity set to: " << G4Tracking_verbosity << G4endl;

  G4String dst_fname = store.fetch_sstore("dst_fname");
  G4cout << "***** DST output file name:" << dst_fname << G4endl;

  G4String gen_source = store.fetch_sstore("gen_source");
  G4double gen_min_E  = store.fetch_dstore("gen_min_E");
  G4double gen_max_E  = store.fetch_dstore("gen_max_E");
  G4int    num_events = store.fetch_istore("num_events");
  G4String part_name  = store.fetch_sstore("part_name");

  if (gen_source == "random") {
    G4cout << "***** Generator data will follow a flat random distribution in: " << G4endl;
    G4cout << "*****           Ekin  (Mev): (" << gen_min_E << " , " 
           << gen_max_E << ")" << G4endl;
    G4cout << "*****           Theta (deg): (0 , 90)" <<  G4endl;
    G4cout << "*****           Phi   (deg): (0 , 180)" <<  G4endl;
    G4cout << "***** Initial events: " << num_events << " " << part_name << G4endl;
  }
  else {
    G4cout << "***** Generator data source read from:" << gen_source << G4endl;
    G4cout << "***** Initial events: " << num_events << " pairs of " << part_name << G4endl;
  }

  if(geom_filename=="") 
    geom_filename = store.fetch_sstore("geom_file");

  //G4String geom_filename = store.fetch_sstore("geom_file");
  G4cout << "***** Reading geometry parameters from: '" 
         << geom_filename << "'" << G4endl;
  G4cout << "***** Reading physics parameters from:  '" 
         << params_filename << "'" << G4endl;
  
  G4cout << "**********************************************************"
         << G4endl << G4endl;
  
  // The ihep::event service is generated. This server must be instantiated
  // wherever you want to access all the info.
  bhep::bhep_svc bsvc;  

  // my Verbose output class:
  G4VSteppingVerbose* verbosity = new stepping_verbose;
  G4VSteppingVerbose::SetInstance(verbosity);

  // Run manager:
  G4RunManager* runManager = new G4RunManager;

  // UserInitialization classes (mandatory)

  // geometry
  geometry* geom = new geometry(geom_filename,params_filename);
  geom->set_info_level(sim_verbosity);
  runManager->SetUserInitialization(geom);

  // physics
  physics* phys = new physics(params_filename);
  phys->set_info_level(sim_verbosity);
  runManager->SetUserInitialization(phys);

  // UserAction classes
  // generator
  generator* my_gen = new generator( part_name , 
                                     gen_source , 
                                     gen_min_E , 
                                     gen_max_E , 
                                     geom->get_geom_mgr() , 
                                     params_filename );
  my_gen->set_info_level(sim_verbosity);
  runManager->SetUserAction(my_gen);

  // run
  run* my_run = new run(dst_fname);
  runManager->SetUserAction(my_run);  

  //event
  snova::event* my_evt = new snova::event(part_name, dst_fname);
  my_evt->set_info_level(sim_verbosity);
  runManager->SetUserAction(my_evt);

  // track
  tracking* my_tracking = new tracking();
  my_tracking->set_info_level(sim_verbosity);
  runManager->SetUserAction(my_tracking);

  // step
  stepping* my_stepping = new stepping(part_name);
  my_stepping->set_info_level(sim_verbosity);
  runManager->SetUserAction(my_stepping);

  // stack
  stacking* my_stacking = new stacking(part_name);
  my_stacking->set_info_level(sim_verbosity);
  runManager->SetUserAction(my_stacking);


  //Initialize G4 kernel
  runManager->Initialize();

    G4UImanager * UI = G4UImanager::GetUIpointer();  

    G4String command = "/control/shell cp currentEvent.rndm currentRun.rndm";
    UI->ApplyCommand(command);
    command = "/random/setSavingFlag true";
    UI->ApplyCommand(command);
    command = "/random/resetEngineFrom currentRun.rndm";
    UI->ApplyCommand(command);

    command = "/tracking/verbose ";
    UI->ApplyCommand(command + G4Tracking_verbosity);
  
    command = "/tracking/storeTrajectory 1";
    UI->ApplyCommand(command);
  
  std::string gui = "$SNOVISROOT/scripts/OnX/snovis_session.onx"; //UIOnX
  G4UIsession* session = new G4Lab::UIOnX(*runManager,gui,argc,argv); //UIOnX

  session->SessionStart();
  delete session;
  
  delete runManager;
  delete verbosity;
  
  return 0;
}

// end of prog_snova.cc