Import Geant4 9.0.0 source tree

2016-06-09 15:16:48 +02:00
parent 75c7fd177d
commit a8e9364cea
6592 changed files with 84274 additions and 69292 deletions
@@ -24,8 +24,8 @@
 // ********************************************************************
 //
 //
-// $Id: G4EnergyLossMessenger.cc,v 1.27 2007/03/17 19:24:39 vnivanch Exp $
-// GEANT4 tag $Name: geant4-08-03 $
+// $Id: G4EnergyLossMessenger.cc,v 1.29 2007/06/11 14:56:51 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-00 $
 //
 // -------------------------------------------------------------------
 //
@@ -47,6 +47,7 @@
 // 15-03-07 Send a message "/run/physicsModified" if reinitialisation
 //          is needed after the command (V.Ivanchenko)
 // 16-03-07 modify /process/eLoss/minsubsec command (V.Ivanchenko)
+// 18-05-07 add /process/msc directory and commands (V.Ivanchenko)
 //
 // -------------------------------------------------------------------
 //
@@ -57,7 +58,6 @@
 #include "G4EnergyLossMessenger.hh"

 #include "G4VEnergyLoss.hh"
-#include "G4LossTableManager.hh"

 #include "G4UIdirectory.hh"
 #include "G4UIcommand.hh"
@@ -66,8 +66,11 @@
 #include "G4UIcmdWithAnInteger.hh"
 #include "G4UIcmdWithADouble.hh"
 #include "G4UIcmdWithADoubleAndUnit.hh"
+#include "G4UIcmdWithAString.hh"
 #include "G4EmProcessOptions.hh"
 #include "G4UImanager.hh"
+#include "G4MscStepLimitType.hh"
+#include "G4EmProcessOptions.hh"

 #include <sstream>

@@ -75,8 +78,11 @@

 G4EnergyLossMessenger::G4EnergyLossMessenger()
 {
+  opt = 0;
  eLossDirectory = new G4UIdirectory("/process/eLoss/");
-  eLossDirectory->SetGuidance("Commands for G4VEnergyLoss.");
+  eLossDirectory->SetGuidance("Commands for EM processes.");
+  mscDirectory = new G4UIdirectory("/process/msc/");
+  mscDirectory->SetGuidance("Commands for EM scattering processes.");

  RndmStepCmd = new G4UIcmdWithABool("/process/eLoss/rndmStep",this);
  RndmStepCmd->SetGuidance("Randomize the proposed step by eLoss.");
@@ -156,25 +162,17 @@ G4EnergyLossMessenger::G4EnergyLossMessenger()
  lpmCmd->SetDefaultValue(true);
  lpmCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

-  latCmd = new G4UIcmdWithABool("/process/eLoss/MscLateralDisplacement",this);
-  latCmd->SetGuidance("Switch true/false sampling of latra dislacent.");
-  latCmd->SetParameterName("lat",true);
-  latCmd->SetDefaultValue(true);
-  latCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
-
  dedxCmd = new G4UIcmdWithAnInteger("/process/eLoss/binsDEDX",this);
  dedxCmd->SetGuidance("Set number of bins for DEDX tables.");
  dedxCmd->SetParameterName("binsDEDX",true);
-  //  dedxCmd->SetParameterRange("binsDEDX>59");
  dedxCmd->SetDefaultValue(120);
  dedxCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

-  lbCmd = new G4UIcmdWithAnInteger("/process/eLoss/binsLambda",this);
-  lbCmd->SetGuidance("Set number of bins for Lambda tables.");
-  lbCmd->SetParameterName("binsL",true);
-  //  lbCmd->SetParameterRange("binsL>59");
-  lbCmd->SetDefaultValue(120);
-  lbCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
+  lamCmd = new G4UIcmdWithAnInteger("/process/eLoss/binsLambda",this);
+  lamCmd->SetGuidance("Set number of bins for Lambda tables.");
+  lamCmd->SetParameterName("binsL",true);
+  lamCmd->SetDefaultValue(120);
+  lamCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

  verCmd = new G4UIcmdWithAnInteger("/process/eLoss/verbose",this);
  verCmd->SetGuidance("Set verbose level for EM physics.");
@@ -182,24 +180,42 @@ G4EnergyLossMessenger::G4EnergyLossMessenger()
  verCmd->SetDefaultValue(1);
  verCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

-  mscCmd = new G4UIcommand("/process/eLoss/MscStepLimit",this);
-  mscCmd->SetGuidance("Set msc step limit flag and facRange value.");
-  G4UIparameter* facRange = new G4UIparameter("facRange",'d',false);
-  facRange->SetGuidance("msc parameter facRange");
-  facRange->SetParameterRange("facRange>0.");
-  mscCmd->SetParameter(facRange);
-  G4UIparameter* msc = new G4UIparameter("algMsc",'s',true);
-  msc->SetGuidance("msc step algorithm flag");
-  msc->SetDefaultValue("true");
-  mscCmd->SetParameter(msc);
-  mscCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
-
  lllCmd = new G4UIcmdWithADouble("/process/eLoss/linLossLimit",this);
  lllCmd->SetGuidance("Set linearLossLimit parameter.");
  lllCmd->SetParameterName("linlim",true);
  lllCmd->AvailableForStates(G4State_PreInit,G4State_Idle);

-  skinCmd = new G4UIcmdWithADouble("/process/eLoss/MscSkin",this);
+  labCmd = new G4UIcmdWithADouble("/process/eLoss/lambdaFactor",this);
+  labCmd->SetGuidance("Set lambdaFactor parameter.");
+  labCmd->SetParameterName("Fl",true);
+  labCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
+
+  mscCmd = new G4UIcmdWithAString("/process/msc/StepLimit",this);
+  mscCmd->SetGuidance("Set msc step limitation type.");
+  mscCmd->SetParameterName("StepLim",true);
+  mscCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
+
+  latCmd = new G4UIcmdWithABool("/process/msc/LateralDisplacement",this);
+  latCmd->SetGuidance("Switch true/false sampling of latra dislacent.");
+  latCmd->SetParameterName("lat",true);
+  latCmd->SetDefaultValue(true);
+  latCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
+
+  frCmd = new G4UIcmdWithADouble("/process/msc/RangeFactor",this);
+  frCmd->SetGuidance("Set RangeFactor parameter for msc process.");
+  frCmd->SetParameterName("Fr",true);
+  frCmd->SetRange("Fr>0");
+  frCmd->SetDefaultValue(0.02);
+  frCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
+
+  fgCmd = new G4UIcmdWithADouble("/process/msc/GeomFactor",this);
+  fgCmd->SetGuidance("Set GeomFactor parameter for msc process.");
+  fgCmd->SetParameterName("Fg",true);
+  fgCmd->SetRange("Fg>0");
+  fgCmd->SetDefaultValue(3.5);
+  fgCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
+
+  skinCmd = new G4UIcmdWithADouble("/process/msc/Skin",this);
  skinCmd->SetGuidance("Set skin parameter for multiple scattering.");
  skinCmd->SetParameterName("skin",true);
  skinCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
@@ -210,12 +226,14 @@ G4EnergyLossMessenger::G4EnergyLossMessenger()

 G4EnergyLossMessenger::~G4EnergyLossMessenger()
 {
+  delete opt;
  delete RndmStepCmd;
  delete EnlossFlucCmd;
  delete SubSecCmd;
  delete MinSubSecCmd;
  delete StepFuncCmd;
  delete eLossDirectory;
+  delete mscDirectory;
  delete MinEnCmd;
  delete MaxEnCmd;
  delete IntegCmd;
@@ -225,8 +243,11 @@ G4EnergyLossMessenger::~G4EnergyLossMessenger()
  delete verCmd;
  delete mscCmd;
  delete dedxCmd;
-  delete lbCmd;
+  delete frCmd;
+  delete fgCmd;
  delete lllCmd;
+  delete lamCmd;
+  delete labCmd;
  delete skinCmd;
 }

@@ -234,26 +255,26 @@ G4EnergyLossMessenger::~G4EnergyLossMessenger()

 void G4EnergyLossMessenger::SetNewValue(G4UIcommand* command,G4String newValue)
 {
-  G4LossTableManager* lossTables = G4LossTableManager::Instance();
- 
+  if(!opt) opt = new G4EmProcessOptions();
+
  if (command == RndmStepCmd) {
    G4VEnergyLoss::SetRndmStep(RndmStepCmd->GetNewBoolValue(newValue));
-    lossTables->SetRandomStep(RndmStepCmd->GetNewBoolValue(newValue));
+    opt->SetRandomStep(RndmStepCmd->GetNewBoolValue(newValue));
  }

  if (command == EnlossFlucCmd) {
    G4VEnergyLoss::SetEnlossFluc(EnlossFlucCmd->GetNewBoolValue(newValue));
-    lossTables->SetLossFluctuations(EnlossFlucCmd->GetNewBoolValue(newValue));
+    opt->SetLossFluctuations(EnlossFlucCmd->GetNewBoolValue(newValue));
  }

  if (command == SubSecCmd) {
    G4VEnergyLoss::SetSubSec(SubSecCmd->GetNewBoolValue(newValue));
-    lossTables->SetSubCutoff(SubSecCmd->GetNewBoolValue(newValue));
+    opt->SetSubCutoff(SubSecCmd->GetNewBoolValue(newValue));
    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
  }

  if (command == MinSubSecCmd) {
-    lossTables->SetMinSubRange(MinSubSecCmd->GetNewDoubleValue(newValue));
+    opt->SetMinSubRange(MinSubSecCmd->GetNewDoubleValue(newValue));
    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
  }

@@ -264,65 +285,82 @@ void G4EnergyLossMessenger::SetNewValue(G4UIcommand* command,G4String newValue)
    is >> v1 >> v2 >> unt;
    v2 *= G4UIcommand::ValueOf(unt);
    G4VEnergyLoss::SetStepFunction(v1,v2);
-    lossTables->SetStepFunction(v1,v2);
+    opt->SetStepFunction(v1,v2);
  }

  if (command == mscCmd) {
-    G4double f;
-    G4bool a = true;
-    G4String s;
-    std::istringstream is(newValue);
-    is >> f >> s;
-    if(s == "false" || s == "0" || s == "no") a = false; 
-    lossTables->SetMscStepLimitation(a,f);
+    if(newValue == "Minimal") 
+      opt->SetMscStepLimitation(fMinimal);
+
+    else if(newValue == "UseDistanceToBoundary") 
+      opt->SetMscStepLimitation(fUseDistanceToBoundary);
+
+    else if(newValue == "UseSafety")
+      opt->SetMscStepLimitation(fUseSafety);
+
+    else {
+      G4cout << "### G4EnergyLossMessenger WARNING: StepLimit type <" 
+	     << newValue << "> unknown!" << G4endl;
+      return;
+    }
    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
  }

  if (command == MinEnCmd) {
-    lossTables->SetMinEnergy(MinEnCmd->GetNewDoubleValue(newValue));
+    opt->SetMinEnergy(MinEnCmd->GetNewDoubleValue(newValue));
    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
  }

  if (command == MaxEnCmd) { 
-    lossTables->SetMaxEnergy(MaxEnCmd->GetNewDoubleValue(newValue));
+    opt->SetMaxEnergy(MaxEnCmd->GetNewDoubleValue(newValue));
    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
  }  

  if (command == IntegCmd) 
-    lossTables->SetIntegral(IntegCmd->GetNewBoolValue(newValue));
-  
-  if (command == rangeCmd) 
-    lossTables->SetBuildCSDARange(rangeCmd->GetNewBoolValue(newValue));
+    opt->SetIntegral(IntegCmd->GetNewBoolValue(newValue));
  
+  if (command == rangeCmd) {
+    opt->SetBuildCSDARange(rangeCmd->GetNewBoolValue(newValue));
+    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
+  }  
+
  if (command == lpmCmd) {
-    lossTables->SetLPMFlag(lpmCmd->GetNewBoolValue(newValue));
+    opt->SetLPMFlag(lpmCmd->GetNewBoolValue(newValue));
    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
  }

  if (command == latCmd) {
-    lossTables->SetMscLateralDisplacement(latCmd->GetNewBoolValue(newValue));
+    opt->SetMscLateralDisplacement(latCmd->GetNewBoolValue(newValue));
    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
  }

  if (command == verCmd) 
-    lossTables->SetVerbose(verCmd->GetNewIntValue(newValue));
+    opt->SetVerbose(verCmd->GetNewIntValue(newValue));

  if (command == lllCmd) 
-    lossTables->SetLinearLossLimit(lllCmd->GetNewDoubleValue(newValue));
+    opt->SetLinearLossLimit(lllCmd->GetNewDoubleValue(newValue));
+
+  if (command == labCmd) 
+    opt->SetLambdaFactor(labCmd->GetNewDoubleValue(newValue));
  
  if (command == skinCmd) {
-    lossTables->SetSkin(skinCmd->GetNewDoubleValue(newValue));
+    opt->SetSkin(skinCmd->GetNewDoubleValue(newValue));
    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
  }  
-
-  G4EmProcessOptions opt;
  if (command == dedxCmd) { 
-    opt.SetDEDXBinning(dedxCmd->GetNewIntValue(newValue));
+    opt->SetDEDXBinning(dedxCmd->GetNewIntValue(newValue));
    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
  }
-
-  if (command == lbCmd) {
-    opt.SetDEDXBinning(lbCmd->GetNewIntValue(newValue));
+  if (command == lamCmd) { 
+    opt->SetLambdaBinning(lamCmd->GetNewIntValue(newValue));
+    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
+  }
+  if (command == frCmd) {
+    opt->SetMscRangeFactor(frCmd->GetNewDoubleValue(newValue));
+    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
+  }
+  if (command == fgCmd) {
+    opt->SetMscGeomFactor(fgCmd->GetNewDoubleValue(newValue));
    G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
  }
 }