| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer << 3 // * DISCLAIMER *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers *
6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which *
7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: *
8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license *
9 // * include a list of copyright holders. <<
10 // * 9 // * *
11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file << 14 // * use. *
16 // * for the full disclaimer and the limitatio <<
17 // * 15 // * *
18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the *
19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. *
20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work *
21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this *
22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. *
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* 21 // ********************************************************************
25 // 22 //
26 // 23 //
27 #include "G4UIcmdWithNucleusLimits.hh" 24 #include "G4UIcmdWithNucleusLimits.hh"
28 #include <sstream> << 25 #include <strstream>
29 ////////////////////////////////////////////// 26 ////////////////////////////////////////////////////////////////////////////////
30 // 27 //
31 G4UIcmdWithNucleusLimits::G4UIcmdWithNucleusLi 28 G4UIcmdWithNucleusLimits::G4UIcmdWithNucleusLimits
32 (const char * theCommandPath, G4UImessenger * << 29 (const char * theCommandPath,G4UImessenger * theMessenger)
33 : G4UIcommand(theCommandPath, theMessenger) << 30 :G4UIcommand(theCommandPath,theMessenger)
34 { 31 {
35 G4UIparameter * intParamAMin = new G4UIparam 32 G4UIparameter * intParamAMin = new G4UIparameter('i');
36 SetParameter(intParamAMin); 33 SetParameter(intParamAMin);
37 G4UIparameter * intParamAMax = new G4UIparam 34 G4UIparameter * intParamAMax = new G4UIparameter('i');
38 SetParameter(intParamAMax); 35 SetParameter(intParamAMax);
39 G4UIparameter * intParamZMin = new G4UIparam 36 G4UIparameter * intParamZMin = new G4UIparameter('i');
40 SetParameter(intParamZMin); 37 SetParameter(intParamZMin);
41 G4UIparameter * intParamZMax = new G4UIparam 38 G4UIparameter * intParamZMax = new G4UIparameter('i');
42 SetParameter(intParamZMax); 39 SetParameter(intParamZMax);
43 } 40 }
44 41
45 ////////////////////////////////////////////// 42 ////////////////////////////////////////////////////////////////////////////////
46 // 43 //
47 G4UIcmdWithNucleusLimits::~G4UIcmdWithNucleusL 44 G4UIcmdWithNucleusLimits::~G4UIcmdWithNucleusLimits()
48 { 45 {
49 ; 46 ;
50 } 47 }
51 ////////////////////////////////////////////// 48 ////////////////////////////////////////////////////////////////////////////////
52 // 49 //
53 G4NucleusLimits G4UIcmdWithNucleusLimits:: 50 G4NucleusLimits G4UIcmdWithNucleusLimits::
54 GetNewNucleusLimitsValue(const G4String& par << 51 GetNewNucleusLimitsValue(G4String paramString)
55 { 52 {
56 G4int aMin; 53 G4int aMin;
57 G4int aMax; 54 G4int aMax;
58 G4int zMin; 55 G4int zMin;
59 G4int zMax; 56 G4int zMax;
60 std::istringstream is(paramString); << 57 const char* t = paramString;
>> 58 std::istrstream is((char*)t);
61 is >> aMin >> aMax >> zMin >> zMax; 59 is >> aMin >> aMax >> zMin >> zMax;
62 return G4NucleusLimits(aMin,aMax,zMin,zMax); 60 return G4NucleusLimits(aMin,aMax,zMin,zMax);
63 } 61 }
64 ////////////////////////////////////////////// 62 ////////////////////////////////////////////////////////////////////////////////
65 // 63 //
66 G4String G4UIcmdWithNucleusLimits::ConvertToSt 64 G4String G4UIcmdWithNucleusLimits::ConvertToString
67 (G4NucleusLimits defLimits) 65 (G4NucleusLimits defLimits)
68 { 66 {
69 std::ostringstream os; << 67 char st[100];
>> 68 std::ostrstream os(st,100);
70 os << defLimits.GetAMin() << " " << defLimit 69 os << defLimits.GetAMin() << " " << defLimits.GetAMax()
71 << defLimits.GetZMin() << " " << defLimit << 70 << defLimits.GetZMin() << " " << defLimits.GetZMax()<< '\0';
72 G4String vl = os.str(); << 71 G4String vl = st;
73 return vl; 72 return vl;
74 } 73 }
75 ////////////////////////////////////////////// 74 ////////////////////////////////////////////////////////////////////////////////
76 // 75 //
77 void G4UIcmdWithNucleusLimits::SetParameterNam 76 void G4UIcmdWithNucleusLimits::SetParameterName
78 (const char * theNameAMin,const char * theName 77 (const char * theNameAMin,const char * theNameAMax,const char * theNameZMin,
79 const char * theNameZMax,G4bool omittable,G4bo 78 const char * theNameZMax,G4bool omittable,G4bool currentAsDefault)
80 { 79 {
81 G4UIparameter * theParamAMin = GetParameter( 80 G4UIparameter * theParamAMin = GetParameter(0);
82 theParamAMin->SetParameterName(theNameAMin); 81 theParamAMin->SetParameterName(theNameAMin);
83 theParamAMin->SetOmittable(omittable); 82 theParamAMin->SetOmittable(omittable);
84 theParamAMin->SetCurrentAsDefault(currentAsD 83 theParamAMin->SetCurrentAsDefault(currentAsDefault);
85 G4UIparameter * theParamAMax = GetParameter( 84 G4UIparameter * theParamAMax = GetParameter(1);
86 theParamAMax->SetParameterName(theNameAMax); 85 theParamAMax->SetParameterName(theNameAMax);
87 theParamAMax->SetOmittable(omittable); 86 theParamAMax->SetOmittable(omittable);
88 theParamAMax->SetCurrentAsDefault(currentAsD 87 theParamAMax->SetCurrentAsDefault(currentAsDefault);
89 G4UIparameter * theParamZMin = GetParameter( 88 G4UIparameter * theParamZMin = GetParameter(2);
90 theParamZMin->SetParameterName(theNameZMin); 89 theParamZMin->SetParameterName(theNameZMin);
91 theParamZMin->SetOmittable(omittable); 90 theParamZMin->SetOmittable(omittable);
92 theParamZMin->SetCurrentAsDefault(currentAsD 91 theParamZMin->SetCurrentAsDefault(currentAsDefault);
93 G4UIparameter * theParamZMax = GetParameter( 92 G4UIparameter * theParamZMax = GetParameter(3);
94 theParamZMax->SetParameterName(theNameZMax); 93 theParamZMax->SetParameterName(theNameZMax);
95 theParamZMax->SetOmittable(omittable); 94 theParamZMax->SetOmittable(omittable);
96 theParamZMax->SetCurrentAsDefault(currentAsD 95 theParamZMax->SetCurrentAsDefault(currentAsDefault);
97 } 96 }
98 ////////////////////////////////////////////// 97 ////////////////////////////////////////////////////////////////////////////////
99 // 98 //
100 void G4UIcmdWithNucleusLimits::SetDefaultValue 99 void G4UIcmdWithNucleusLimits::SetDefaultValue(G4NucleusLimits defLimits)
101 { 100 {
102 G4UIparameter * theParamAMin = GetParameter( 101 G4UIparameter * theParamAMin = GetParameter(0);
103 theParamAMin->SetDefaultValue(defLimits.GetA 102 theParamAMin->SetDefaultValue(defLimits.GetAMin());
104 G4UIparameter * theParamAMax = GetParameter( 103 G4UIparameter * theParamAMax = GetParameter(1);
105 theParamAMax->SetDefaultValue(defLimits.GetA 104 theParamAMax->SetDefaultValue(defLimits.GetAMax());
106 G4UIparameter * theParamZMin = GetParameter( 105 G4UIparameter * theParamZMin = GetParameter(2);
107 theParamZMin->SetDefaultValue(defLimits.GetZ 106 theParamZMin->SetDefaultValue(defLimits.GetZMin());
108 G4UIparameter * theParamZMax = GetParameter( 107 G4UIparameter * theParamZMax = GetParameter(3);
109 theParamZMax->SetDefaultValue(defLimits.GetZ 108 theParamZMax->SetDefaultValue(defLimits.GetZMax());
110 } 109 }
>> 110
>> 111
>> 112
>> 113
>> 114
>> 115
111 116