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.5 2003/06/16 16:55:40 gunter Exp $ 29 // ------------------------------------------- << 25 // GEANT4 tag $Name: geant4-06-00 $ >> 26 // >> 27 // 30 28 31 #include "G4UIcmdWithADoubleAndUnit.hh" 29 #include "G4UIcmdWithADoubleAndUnit.hh" >> 30 #include <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 // ------------------------------------------- << 90 G4double G4UIcmdWithADoubleAndUnit::GetNewDoub 43 G4double G4UIcmdWithADoubleAndUnit::GetNewDoubleValue(const char* paramString) 91 { 44 { 92 return ConvertToDimensionedDouble(paramStrin << 45 G4double vl; >> 46 char unts[30]; >> 47 >> 48 std::istrstream is((char*)paramString); >> 49 is >> vl >> unts; >> 50 G4String unt = unts; >> 51 >> 52 return (vl*ValueOf(unt)); 93 } 53 } 94 54 95 // ------------------------------------------- << 96 G4double G4UIcmdWithADoubleAndUnit::GetNewDoub 55 G4double G4UIcmdWithADoubleAndUnit::GetNewDoubleRawValue(const char* paramString) 97 { 56 { 98 G4double vl; 57 G4double vl; 99 char unts[30]; 58 char unts[30]; 100 << 59 101 std::istringstream is(paramString); << 60 std::istrstream is((char*)paramString); 102 is >> vl >> unts; 61 is >> vl >> unts; 103 << 62 104 return vl; 63 return vl; 105 } 64 } 106 65 107 // ------------------------------------------- << 108 G4double G4UIcmdWithADoubleAndUnit::GetNewUnit 66 G4double G4UIcmdWithADoubleAndUnit::GetNewUnitValue(const char* paramString) 109 { 67 { 110 G4double vl; 68 G4double vl; 111 char unts[30]; 69 char unts[30]; 112 << 70 113 std::istringstream is(paramString); << 71 std::istrstream is((char*)paramString); 114 is >> vl >> unts; 72 is >> vl >> unts; 115 G4String unt = unts; 73 G4String unt = unts; 116 << 74 117 return ValueOf(unt); 75 return ValueOf(unt); 118 } 76 } 119 77 120 // ------------------------------------------- << 78 G4String G4UIcmdWithADoubleAndUnit::ConvertToString 121 G4String G4UIcmdWithADoubleAndUnit::ConvertToS << 79 (G4double dblValue,const char * unitName) 122 { 80 { 123 G4UIparameter* unitParam = GetParameter(1); << 81 G4String unt = unitName; 124 G4String canList = unitParam->GetParameterCa << 82 G4double uv = ValueOf(unitName); 125 G4Tokenizer candidateTokenizer(canList); << 83 126 G4String aToken = candidateTokenizer(); << 84 char st[50]; 127 std::ostringstream os; << 85 std::ostrstream os(st,50); 128 os << G4BestUnit(val, CategoryOf(aToken)); << 86 os << dblValue/uv << " " << unitName << '\0'; 129 << 87 G4String vl = st; 130 G4String st = os.str(); << 88 return vl; 131 return st; << 89 } 132 } << 90 133 << 91 void G4UIcmdWithADoubleAndUnit::SetParameterName 134 // ------------------------------------------- << 92 (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 { 93 { 152 G4UIparameter* theParam = GetParameter(0); << 94 G4UIparameter * theParam = GetParameter(0); 153 theParam->SetParameterName(theName); 95 theParam->SetParameterName(theName); 154 theParam->SetOmittable(omittable); 96 theParam->SetOmittable(omittable); 155 theParam->SetCurrentAsDefault(currentAsDefau 97 theParam->SetCurrentAsDefault(currentAsDefault); 156 } 98 } 157 99 158 // ------------------------------------------- << 159 void G4UIcmdWithADoubleAndUnit::SetDefaultValu 100 void G4UIcmdWithADoubleAndUnit::SetDefaultValue(G4double defVal) 160 { 101 { 161 G4UIparameter* theParam = GetParameter(0); << 102 G4UIparameter * theParam = GetParameter(0); 162 theParam->SetDefaultValue(defVal); 103 theParam->SetDefaultValue(defVal); 163 } 104 } 164 105 165 // ------------------------------------------- << 106 void G4UIcmdWithADoubleAndUnit::SetUnitCategory(const char * unitCategory) 166 void G4UIcmdWithADoubleAndUnit::SetUnitCategor << 167 { 107 { 168 SetUnitCandidates(UnitsList(unitCategory)); 108 SetUnitCandidates(UnitsList(unitCategory)); 169 } 109 } 170 110 171 // ------------------------------------------- << 111 void G4UIcmdWithADoubleAndUnit::SetUnitCandidates(const char * candidateList) 172 void G4UIcmdWithADoubleAndUnit::SetUnitCandida << 173 { 112 { 174 G4UIparameter* untParam = GetParameter(1); << 113 G4UIparameter * untParam = GetParameter(1); 175 G4String canList = candidateList; 114 G4String canList = candidateList; 176 untParam->SetParameterCandidates(canList); 115 untParam->SetParameterCandidates(canList); 177 } 116 } 178 117 179 // ------------------------------------------- << 118 void G4UIcmdWithADoubleAndUnit::SetDefaultUnit(const char * defUnit) 180 void G4UIcmdWithADoubleAndUnit::SetDefaultUnit << 181 { 119 { 182 G4UIparameter* untParam = GetParameter(1); << 120 G4UIparameter * untParam = GetParameter(1); 183 untParam->SetOmittable(true); 121 untParam->SetOmittable(true); 184 untParam->SetDefaultValue(defUnit); 122 untParam->SetDefaultValue(defUnit); 185 SetUnitCategory(CategoryOf(defUnit)); 123 SetUnitCategory(CategoryOf(defUnit)); 186 } 124 } >> 125 187 126