source: JEM-EUSO/esaf_lal/tags/v1_r0/esaf/packages/simulation/detector/G4Detector/optics/src/G4TransportManager.cc @ 117

#include "OpticsFactory.hh"
#include "Config.hh"

#include "PhotonsOnPupil.hh"
#include "Photon.hh"
#include "EConst.hh"

#include "EsafMsg.hh"
#include "EsafMsgSource.hh"

#include <G4RunManager.hh>
#include <G4StateManager.hh>
#include <G4TrackingManager.hh>
#include <G4ApplicationState.hh>
#include <G4UImanager.hh>
#include <G4UIterminal.hh>
#include <G4UItcsh.hh>
#include <G4UIcommand.hh>
#include <G4UIcmdWithAString.hh>
#include <G4UImessenger.hh>
#include <G4Track.hh>
#ifdef G4VIS_USE
  #include <G4VisManager.hh>
  #include <G4VisExecutive.hh>
#endif

#include <utils.hh>
#include <globals.hh>

#include "G4TransportManager.hh"

#include "DetectorFactory.hh"

#include "OptPhysicsList.hh"
#include "OptPrimaryGeneratorAction.hh"
#include "OptRunAction.hh"
#include "OptSteppingAction.hh"
#include "OptUserStackingAction.hh"
#include "IdealFocalSurface.hh"
#include "OpticsFactory.hh"
#include "FocalPlane.hh"

#include "SimuApplication.hh"


using namespace sou;
//______________________________________________________________________________
G4TransportManager::G4TransportManager()
{

    SetSender("G4TransportManager");

    fOptics     = OpticsFactory::Get()->MakeOpticalSystem();
    fFocalPlane = OpticsFactory::Get()->MakeFocalPlane();
    fIdealFocalSurface=OpticsFactory::Get()->MakeIdealFocalSurface();
    fFocalPlane = OpticsFactory::Get()->MakeFocalPlane();
                
                fEffectiveEfficiencyFactor = 
                Config::Get()->GetCF("G4TransportManager","NOpticalSystem")->GetNum("NOpticalSystem.fEffectiveEfficiencyFactor");
    // Run manager
    runManager = new G4RunManager();

    // UserInitialization classes - mandatory
    G4VUserDetectorConstruction* detector = DetectorFactory::Instance()->GetDetector();
    runManager->SetUserInitialization((G4VUserDetectorConstruction*)detector);

    G4VUserPhysicsList* physics = new OptPhysicsList;
    runManager-> SetUserInitialization(physics);

    G4UserRunAction* run_action = new OptRunAction;
    runManager->SetUserAction(run_action);

    bool active = (bool)Conf()->GetNum("G4TransportManager.ActivatePrimaryGenAction");
    if(active)MsgForm(EsafMsg::Info,"Geant4 generator is available");
    gen_action = new OptPrimaryGeneratorAction(active);
    runManager->SetUserAction((G4VUserPrimaryGeneratorAction*)gen_action);

    stack_action = new OptUserStackingAction(fIdealFocalSurface);
    runManager->SetUserAction((G4UserStackingAction*)stack_action);
    int nevents = (int)Conf()->GetNum("G4TransportManager.Nphotons");
    if ( nevents ) stack_action->SetNmax(nevents);

    OptSteppingAction* stepping_action = new OptSteppingAction(stack_action);
    runManager->SetUserAction((G4UserSteppingAction*)stepping_action);
    stack_action->stepping=stepping_action;

    //G4UserTrackingAction* tracking_action = new OptTrackingAction;
    runManager->SetUserAction((G4UserTrackingAction*)stack_action);
    runManager->SetUserAction((G4UserEventAction*)stack_action);
    //stack_action->tracking=tracking_action;

    #ifdef G4VIS_USE
    // visualization manager
    printf("VisManager is created.\n");
    visManager = new G4VisExecutive;
    visManager->Initialize();
    #endif

    // Initialize G4 kernel
    runManager->Initialize();
    
    
    if(nevents==-2){
      fNTracked=0;
      bool state=G4RunManagerKernel::GetRunManagerKernel()->RunInitialization();
      if (!state) { printf("Error\n"); exit(1); }
      trackManager = G4EventManager::GetEventManager()->GetTrackingManager();
      G4StateManager* stateManager = G4StateManager::GetStateManager();
      G4ApplicationState currentState = stateManager->GetCurrentState();
      if(currentState!=G4State_GeomClosed)
      {
        G4Exception("G4EventManager::ProcessOneEvent",
                    "IllegalApplicationState",JustWarning,
                    "Geometry is not closed : cannot process an event.");
        return;
      }

      stateManager->SetNewState(G4State_EventProc);
      
    }
    MsgForm(EsafMsg::Info,"Creating Geant4 transport manager.");
}

G4TransportManager::~G4TransportManager() {

    //delete stack_action;
    G4EventManager::GetEventManager()->SetUserAction((G4UserTrackingAction*)0);
    G4EventManager::GetEventManager()->SetUserAction((G4UserEventAction*)0);
    delete runManager;
#ifdef G4VIS_USE
    delete visManager;
#endif
}

void G4TransportManager::UIterminal(){
    int v = (int)Conf()->GetNum("G4TransportManager.Vis");
    int t = (int)Conf()->GetNum("G4TransportManager.Terminal");
    int nevents = (int)Conf()->GetNum("G4TransportManager.NumberOfEvents");
    G4UImanager* UI = G4UImanager::GetUIpointer();
    if(t==1)  // Define (G)UI terminal for interactive mode
    {
        // G4UIterminal is a (dumb) terminal
        //
        G4UIsession * session = 0;
        #ifdef G4UI_USE_TCSH
        session = new G4UIterminal(new G4UItcsh);
        #else
        session = new G4UIterminal();
        #endif

        if(v!=0) UI->ApplyCommand("/control/execute config/G4/vis.mac");
        session->SessionStart();
        delete session;
    }
    else   // Batch mode
    {
        UI->ApplyCommand("/run/verbose 0");
        UI->ApplyCommand("/event/verbose 0");
        UI->ApplyCommand("/tracking/verbose 0");
        UI->ApplyCommand("/process/verbose 0");
        UI->ApplyCommand("/control/verbose 0");
        UI->ApplyCommand("/process/eLoss/verbose 0");
        if(v!=0) UI->ApplyCommand("/control/execute config/G4/vis.mac");
        runManager->BeamOn(nevents);
        if(v!=0) UI->ApplyCommand("/control/execute config/G4/vis_post.mac");
    }

}
//______________________________________________________________________________
void G4TransportManager::Go( PhotonsOnPupil* pupil ) {
    //
    // Get and trace all the photons in PhotonsOnPupil
    //
    if ( !pupil ) {
        MsgForm(EsafMsg::Warning,"PhotonsOnPupil is NULL. Photon tracing disabled.");
        return;
    }

    stack_action->SetPupil(pupil);
    UIterminal();
    fTimeFirstPhoton=stack_action->GetTimeFirst();
    fTimeLastPhoton=stack_action->GetTimeLast();
}

//______________________________________________________________________________
Photon* G4TransportManager::Transport(Photon* p) const {
  
        
        if(EsafRandom::Get()->Rndm()>=fEffectiveEfficiencyFactor){
                p->history=0;
                return 0;
        }
  stack_action->Reset();
  G4Track* track = (G4Track*)stack_action->NewPhoton(p, 0, 0);
  G4TrackingManager* trackManager = G4EventManager::GetEventManager()->GetTrackingManager();
  EVector& phpos=p->pos;
  G4ThreeVector pos(phpos[X],phpos[Y],phpos[Z]);
  G4Navigator* navigator =
  G4TransportationManager::GetTransportationManager()->GetNavigatorForTracking();
  navigator->LocateGlobalPointAndSetup(pos,0,false);
  trackManager->ProcessOneTrack (track);
  delete track;

  return 0;
}

//______________________________________________________________________________
void G4TransportManager::Reset() {

}