Geant4 LXR

Cross-Referencing   Geant4
Geant4/examples/advanced/composite_calorimeter/src/CCalPrimaryGeneratorMessenger.cc

   //
   // ********************************************************************
   // * License and Disclaimer                                           *
   // *                                                                  *
   // * The  Geant4 software  is  copyright of the Copyright Holders  of *
   // * the Geant4 Collaboration.  It is provided  under  the terms  and *
   // * conditions of the Geant4 Software License,  included in the file *
   // * LICENSE and available at  http://cern.ch/geant4/license .  These *
   // * include a list of copyright holders.                             *
  // *                                                                  *
  // * Neither the authors of this software system, nor their employing *
  // * institutes,nor the agencies providing financial support for this *
  // * work  make  any representation or  warranty, express or implied, *
  // * regarding  this  software system or assume any liability for its *
  // * use.  Please see the license in the file  LICENSE  and URL above *
  // * for the full disclaimer and the limitation of liability.         *
  // *                                                                  *
  // * This  code  implementation is the result of  the  scientific and *
  // * technical work of the GEANT4 collaboration.                      *
  // * By using,  copying,  modifying or  distributing the software (or *
  // * any work based  on the software)  you  agree  to acknowledge its *
  // * use  in  resulting  scientific  publications,  and indicate your *
  // * acceptance of all terms of the Geant4 Software license.          *
  // ********************************************************************
  //
  ///////////////////////////////////////////////////////////////////////////////
  // File: CCalPrimaryGeneratorMessenger.cc
  // Description: CCalPrimaryGeneratorMessenger adds new commands for
  //              primary generator action
  ///////////////////////////////////////////////////////////////////////////////
  #include "CCalPrimaryGeneratorMessenger.hh"
  #include "CCalPrimaryGeneratorAction.hh"
  
  #include "globals.hh"
  #include "G4PhysicalConstants.hh"
  #include "G4UImanager.hh"
  #include "G4UIcmdWithAString.hh"
  #include "G4UIcmdWithADoubleAndUnit.hh"
  #include "G4UIcmdWithADouble.hh"
  #include "G4UIcmdWithABool.hh"
  #include "G4UIcmdWithAnInteger.hh"
  
  CCalPrimaryGeneratorMessenger::CCalPrimaryGeneratorMessenger(CCalPrimaryGeneratorAction* myGun) : myAction(myGun) {
  
    verboseCmd = new G4UIcmdWithAnInteger("/CCal/generator/verbose",this);
    verboseCmd->SetGuidance("set Verbosity level ");
    verboseCmd->SetParameterName("value",true);
    verboseCmd->SetDefaultValue(0);
    verboseCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  
    rndmCmd = new G4UIcmdWithAString("/CCal/generator/random",this);
    rndmCmd->SetGuidance("Choose randomly energy and direction of the incident particle.");
    rndmCmd->SetGuidance("  Choice : on,off(default)");
    rndmCmd->SetParameterName("choice",true);
    rndmCmd->SetDefaultValue("off");
    rndmCmd->SetCandidates("on off ON OFF");
    rndmCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  
    scanCmd = new G4UIcmdWithAString("/CCal/generator/scan",this);
    scanCmd->SetGuidance("Scan eta and phi ranges with single incident particle");
    scanCmd->SetGuidance("  Choice : on,off(default)");
    scanCmd->SetGuidance("  Ranges : etamin/max, phimin/max are set by other commands ");
    scanCmd->SetParameterName("choice",true);
    scanCmd->SetDefaultValue("off");
    scanCmd->SetCandidates("on off ON OFF");
    scanCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  
    minEnergyCmd = new G4UIcmdWithADoubleAndUnit("/CCal/generator/minEnergy",this);
    minEnergyCmd->SetGuidance("Set minimum Energy for the incident particle.");
    minEnergyCmd->SetParameterName("value",true);
    minEnergyCmd->SetDefaultValue(1.);
    minEnergyCmd->SetDefaultUnit("GeV");
    minEnergyCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
    
    maxEnergyCmd = new G4UIcmdWithADoubleAndUnit("/CCal/generator/maxEnergy",this);
    maxEnergyCmd->SetGuidance("Set maximum Energy for the incident particle.");
    maxEnergyCmd->SetParameterName("value",true);
    maxEnergyCmd->SetDefaultValue(1.);
    maxEnergyCmd->SetDefaultUnit("TeV");
    maxEnergyCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  
    minPhiCmd = new G4UIcmdWithADoubleAndUnit("/CCal/generator/minPhi",this);
    minPhiCmd->SetGuidance("Set minimum Phi angle for the incident particle direction");
    minPhiCmd->SetGuidance("  Choice : from 0 to 2*pi ");
    minPhiCmd->SetParameterName("value",true);
    minPhiCmd->SetDefaultValue(0);
    minPhiCmd->SetDefaultUnit("radian");
    minPhiCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  
    maxPhiCmd = new G4UIcmdWithADoubleAndUnit("/CCal/generator/maxPhi",this);
    maxPhiCmd->SetGuidance("Set maximum Phi angle for the incident particle direction");
    maxPhiCmd->SetGuidance("  Choice : from 0 to 2*pi ");
    maxPhiCmd->SetParameterName("value",true);
    maxPhiCmd->SetDefaultValue(2.*pi);
    maxPhiCmd->SetDefaultUnit("radian");
    maxPhiCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
  
    stepsPhiCmd = new G4UIcmdWithAnInteger("/CCal/generator/stepsPhi",this);
    stepsPhiCmd->SetGuidance("number of steps along Phi for scan ");
   stepsPhiCmd->SetParameterName("value",true);
   stepsPhiCmd->SetDefaultValue(1);
   stepsPhiCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
   minEtaCmd = new G4UIcmdWithADouble("/CCal/generator/minEta",this);
   minEtaCmd->SetGuidance("Set minimum Eta angle for the incident particle direction");
   minEtaCmd->SetGuidance("  Choice : from 0 to infinity");
   minEtaCmd->SetParameterName("value",true);
   minEtaCmd->SetDefaultValue(0);
   minEtaCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
   maxEtaCmd = new G4UIcmdWithADouble("/CCal/generator/maxEta",this);
   maxEtaCmd->SetGuidance("Set maximum Eta angle for the incident particle direction");
   maxEtaCmd->SetGuidance("  Choice : from 0 to infinity");
   maxEtaCmd->SetParameterName("value",true);
   maxEtaCmd->SetDefaultValue(3.5);
   maxEtaCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
   stepsEtaCmd = new G4UIcmdWithAnInteger("/CCal/generator/stepsEta",this);
   stepsEtaCmd->SetGuidance("number of steps along Eta for scan ");
   stepsEtaCmd->SetParameterName("value",true);
   stepsEtaCmd->SetDefaultValue(1);
   stepsEtaCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
   runNoCmd = new G4UIcmdWithAnInteger("/CCal/generator/runNo",this);
   runNoCmd->SetGuidance("set the run number ");
   runNoCmd->SetParameterName("value",true);
   runNoCmd->SetDefaultValue(0);
   runNoCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
 }
 
 CCalPrimaryGeneratorMessenger::~CCalPrimaryGeneratorMessenger() {
 
   if (verboseCmd)
     delete verboseCmd;
   if (scanCmd)
     delete rndmCmd;
   if (scanCmd)
     delete scanCmd;
   if (minEnergyCmd)
     delete minEnergyCmd;
   if (maxEnergyCmd)
     delete maxEnergyCmd;
   if (minPhiCmd)
     delete minPhiCmd;
   if (maxPhiCmd)
     delete maxPhiCmd;
   if (stepsPhiCmd)
     delete stepsPhiCmd;
   if (minEtaCmd)
     delete minEtaCmd;
   if (maxEtaCmd)
     delete maxEtaCmd;
   if (stepsEtaCmd)
     delete stepsEtaCmd;
   if (runNoCmd)
     delete runNoCmd;
 
 }
 
 void CCalPrimaryGeneratorMessenger::SetNewValue(G4UIcommand * command,
                                                 G4String newValues)    { 
   if (command == verboseCmd)
     myAction->SetVerboseLevel(verboseCmd->GetNewIntValue(newValues));
   else if (command == rndmCmd)
     myAction->SetRandom(newValues);
   else if (command == scanCmd)
     myAction->SetScan(newValues);
   else if (command == minEnergyCmd)
     myAction->SetMinimumEnergy(minEnergyCmd->GetNewDoubleValue(newValues));
   else if (command == maxEnergyCmd)
     myAction->SetMaximumEnergy(maxEnergyCmd->GetNewDoubleValue(newValues));
   else if (command == minPhiCmd)
     myAction->SetMinimumPhi(minPhiCmd->GetNewDoubleValue(newValues));
   else if (command == maxPhiCmd)
     myAction->SetMaximumPhi(maxPhiCmd->GetNewDoubleValue(newValues));
   else if (command == stepsPhiCmd)
     myAction->SetStepsPhi(stepsPhiCmd->GetNewIntValue(newValues));
   else if (command == minEtaCmd)
     myAction->SetMinimumEta(minEtaCmd->GetNewDoubleValue(newValues));
   else if (command == maxEtaCmd)
     myAction->SetMaximumEta(maxEtaCmd->GetNewDoubleValue(newValues));
   else if (command == stepsEtaCmd)
     myAction->SetStepsEta(stepsEtaCmd->GetNewIntValue(newValues));
   else if (command == runNoCmd)
     myAction->SetRunNo(runNoCmd->GetNewIntValue(newValues));
  
 }