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 // G4UIcmdWithADoubleAndUnit << 27 // 23 // 28 // Author: M.Asai, 1998 << 24 // $Id: G4UIcmdWithADoubleAndUnit.cc,v 1.3 2001/07/11 10:01:16 gunter Exp $ 29 // ------------------------------------------- << 25 // GEANT4 tag $Name: geant4-04-00 $ >> 26 // >> 27 // 30 28 31 #include "G4UIcmdWithADoubleAndUnit.hh" 29 #include "G4UIcmdWithADoubleAndUnit.hh" >> 30 #include "g4std/strstream" 32 31 33 #include "G4Tokenizer.hh" << 32 G4UIcmdWithADoubleAndUnit::G4UIcmdWithADoubleAndUnit 34 #include "G4UIcommandStatus.hh" << 33 (const char * theCommandPath,G4UImessenger * theMessenger) 35 #include "G4UnitsTable.hh" << 34 :G4UIcommand(theCommandPath,theMessenger) 36 << 37 #include <sstream> << 38 #include <vector> << 39 << 40 // ------------------------------------------- << 41 G4UIcmdWithADoubleAndUnit::G4UIcmdWithADoubleA << 42 << 43 : G4UIcommand(theCommandPath, theMessenger) << 44 { 35 { 45 auto* dblParam = new G4UIparameter('d'); << 36 G4UIparameter * dblParam = new G4UIparameter('d'); 46 SetParameter(dblParam); 37 SetParameter(dblParam); 47 auto* untParam = new G4UIparameter('s'); << 38 G4UIparameter * untParam = new G4UIparameter('s'); 48 untParam->SetParameterName("Unit"); << 49 SetParameter(untParam); 39 SetParameter(untParam); 50 SetCommandType(WithADoubleAndUnitCmd); << 40 untParam->SetParameterName("Unit"); 51 } << 52 << 53 // ------------------------------------------- << 54 G4int G4UIcmdWithADoubleAndUnit::DoIt(const G4 << 55 { << 56 std::vector<G4String> token_vector; << 57 G4Tokenizer tkn(parameterList); << 58 G4String str; << 59 while (!(str = tkn()).empty()) { << 60 token_vector.push_back(str); << 61 } << 62 << 63 // convert a value in default unit << 64 G4String converted_parameter; << 65 G4String default_unit = GetParameter(1)->Get << 66 if (!default_unit.empty() && token_vector.si << 67 if (CategoryOf(token_vector[1]) != Categor << 68 return fParameterOutOfCandidates + 1; << 69 } << 70 G4double value_given = ValueOf(token_vecto << 71 G4double value_default = ValueOf(default_u << 72 G4double value = ConvertToDouble(token_vec << 73 // reconstruct parameter list << 74 converted_parameter += ConvertToString(val << 75 converted_parameter += " "; << 76 converted_parameter += default_unit; << 77 for (std::size_t i = 2; i < token_vector.s << 78 converted_parameter += " "; << 79 converted_parameter += token_vector[i]; << 80 } << 81 } << 82 else { << 83 converted_parameter = parameterList; << 84 } << 85 << 86 return G4UIcommand::DoIt(converted_parameter << 87 } 41 } 88 42 89 // ------------------------------------------- << 43 G4double G4UIcmdWithADoubleAndUnit::GetNewDoubleValue(G4String paramString) 90 G4double G4UIcmdWithADoubleAndUnit::GetNewDoub << 91 { 44 { 92 return ConvertToDimensionedDouble(paramStrin << 45 G4double vl; >> 46 char unts[30]; >> 47 >> 48 const char* t = paramString; >> 49 G4std::istrstream is((char*)t); >> 50 is >> vl >> unts; >> 51 G4String unt = unts; >> 52 >> 53 return (vl*ValueOf(unt)); 93 } 54 } 94 55 95 // ------------------------------------------- << 56 G4double G4UIcmdWithADoubleAndUnit::GetNewDoubleRawValue(G4String paramString) 96 G4double G4UIcmdWithADoubleAndUnit::GetNewDoub << 97 { 57 { 98 G4double vl; 58 G4double vl; 99 char unts[30]; 59 char unts[30]; 100 << 60 101 std::istringstream is(paramString); << 61 const char* t = paramString; >> 62 G4std::istrstream is((char*)t); 102 is >> vl >> unts; 63 is >> vl >> unts; 103 << 64 104 return vl; 65 return vl; 105 } 66 } 106 67 107 // ------------------------------------------- << 68 G4double G4UIcmdWithADoubleAndUnit::GetNewUnitValue(G4String paramString) 108 G4double G4UIcmdWithADoubleAndUnit::GetNewUnit << 109 { 69 { 110 G4double vl; 70 G4double vl; 111 char unts[30]; 71 char unts[30]; 112 << 72 113 std::istringstream is(paramString); << 73 const char* t = paramString; >> 74 G4std::istrstream is((char*)t); 114 is >> vl >> unts; 75 is >> vl >> unts; 115 G4String unt = unts; 76 G4String unt = unts; 116 << 77 117 return ValueOf(unt); 78 return ValueOf(unt); 118 } 79 } 119 80 120 // ------------------------------------------- << 81 G4String G4UIcmdWithADoubleAndUnit::ConvertToString 121 G4String G4UIcmdWithADoubleAndUnit::ConvertToS << 82 (G4double dblValue,const char * unitName) 122 { 83 { 123 G4UIparameter* unitParam = GetParameter(1); << 84 G4String unt = unitName; 124 G4String canList = unitParam->GetParameterCa << 85 G4double uv = ValueOf(unitName); 125 G4Tokenizer candidateTokenizer(canList); << 86 126 G4String aToken = candidateTokenizer(); << 87 char st[50]; 127 std::ostringstream os; << 88 G4std::ostrstream os(st,50); 128 os << G4BestUnit(val, CategoryOf(aToken)); << 89 os << dblValue/uv << " " << unitName << '\0'; 129 << 90 G4String vl = st; 130 G4String st = os.str(); << 91 return vl; 131 return st; << 92 } 132 } << 93 133 << 94 void G4UIcmdWithADoubleAndUnit::SetParameterName 134 // ------------------------------------------- << 95 (const char * theName,G4bool omittable,G4bool currentAsDefault) 135 G4String G4UIcmdWithADoubleAndUnit::ConvertToS << 136 { << 137 G4UIparameter* unitParam = GetParameter(1); << 138 G4String st; << 139 if (unitParam->IsOmittable()) { << 140 st = ConvertToString(val, unitParam->GetDe << 141 } << 142 else { << 143 st = ConvertToStringWithBestUnit(val); << 144 } << 145 return st; << 146 } << 147 << 148 // ------------------------------------------- << 149 void G4UIcmdWithADoubleAndUnit::SetParameterNa << 150 << 151 { 96 { 152 G4UIparameter* theParam = GetParameter(0); << 97 G4UIparameter * theParam = GetParameter(0); 153 theParam->SetParameterName(theName); 98 theParam->SetParameterName(theName); 154 theParam->SetOmittable(omittable); 99 theParam->SetOmittable(omittable); 155 theParam->SetCurrentAsDefault(currentAsDefau 100 theParam->SetCurrentAsDefault(currentAsDefault); 156 } 101 } 157 102 158 // ------------------------------------------- << 159 void G4UIcmdWithADoubleAndUnit::SetDefaultValu 103 void G4UIcmdWithADoubleAndUnit::SetDefaultValue(G4double defVal) 160 { 104 { 161 G4UIparameter* theParam = GetParameter(0); << 105 G4UIparameter * theParam = GetParameter(0); 162 theParam->SetDefaultValue(defVal); 106 theParam->SetDefaultValue(defVal); 163 } 107 } 164 108 165 // ------------------------------------------- << 109 void G4UIcmdWithADoubleAndUnit::SetUnitCategory(const char * unitCategory) 166 void G4UIcmdWithADoubleAndUnit::SetUnitCategor << 167 { 110 { 168 SetUnitCandidates(UnitsList(unitCategory)); 111 SetUnitCandidates(UnitsList(unitCategory)); 169 } 112 } 170 113 171 // ------------------------------------------- << 114 void G4UIcmdWithADoubleAndUnit::SetUnitCandidates(const char * candidateList) 172 void G4UIcmdWithADoubleAndUnit::SetUnitCandida << 173 { 115 { 174 G4UIparameter* untParam = GetParameter(1); << 116 G4UIparameter * untParam = GetParameter(1); 175 G4String canList = candidateList; 117 G4String canList = candidateList; 176 untParam->SetParameterCandidates(canList); 118 untParam->SetParameterCandidates(canList); 177 } 119 } 178 120 179 // ------------------------------------------- << 121 void G4UIcmdWithADoubleAndUnit::SetDefaultUnit(const char * defUnit) 180 void G4UIcmdWithADoubleAndUnit::SetDefaultUnit << 181 { 122 { 182 G4UIparameter* untParam = GetParameter(1); << 123 G4UIparameter * untParam = GetParameter(1); 183 untParam->SetOmittable(true); 124 untParam->SetOmittable(true); 184 untParam->SetDefaultValue(defUnit); 125 untParam->SetDefaultValue(defUnit); 185 SetUnitCategory(CategoryOf(defUnit)); 126 SetUnitCategory(CategoryOf(defUnit)); 186 } 127 } >> 128 187 129