Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/particles/utils/src/G4IsotopeMagneticMomentTable.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /particles/utils/src/G4IsotopeMagneticMomentTable.cc (Version 11.3.0) and /particles/utils/src/G4IsotopeMagneticMomentTable.cc (Version 9.4.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%     26 // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 27 //                                                 27 //
 28 // MODULE:              G4IsotopeMagneticMomen     28 // MODULE:              G4IsotopeMagneticMomentTable.cc
 29 //                                                 29 //
 30 // Date:                16/03/07                   30 // Date:                16/03/07
 31 // Author:              H.Kurashige                31 // Author:              H.Kurashige
 32 //                                                 32 //
 33 // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%     33 // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 34 //                                                 34 //
 35 // HISTORY                                         35 // HISTORY
 36 ////////////////////////////////////////////// <<  36 ////////////////////////////////////////////////////////////////////////////////
 37 /// added                         30 Apr. 2013 <<  37 //
 38                                                << 
 39 #include "G4IsotopeMagneticMomentTable.hh"         38 #include "G4IsotopeMagneticMomentTable.hh"
 40                                                    39 
 41 #include "G4PhysicalConstants.hh"              << 
 42 #include "G4SystemOfUnits.hh"                  << 
 43 #include "G4ios.hh"                                40 #include "G4ios.hh"
 44 #include "globals.hh"                              41 #include "globals.hh"
 45                                                <<  42 #include <iomanip>
 46 #include <fstream>                                 43 #include <fstream>
                                                   >>  44 #include <sstream>
 47                                                    45 
                                                   >>  46 const G4double G4IsotopeMagneticMomentTable::levelTolerance = 0.001;
 48 // 0.1% torelance for excitation energy            47 // 0.1% torelance for excitation energy
 49 const G4double G4IsotopeMagneticMomentTable::l <<  48   
 50                                                <<  49 const G4double G4IsotopeMagneticMomentTable::nuclearMagneton = eplus*hbar_Planck/2./(proton_mass_c2 /c_squared);
 51 // Nuclear Magneton                                50 // Nuclear Magneton
 52 const G4double G4IsotopeMagneticMomentTable::n <<  51  
 53   eplus * hbar_Planck / 2. / (proton_mass_c2 / <<  52 ///////////////////////////////////////////////////////////////////////////////
 54                                                <<  53 G4IsotopeMagneticMomentTable::G4IsotopeMagneticMomentTable()
 55 G4IsotopeMagneticMomentTable::G4IsotopeMagneti << 
 56 {                                                  54 {
 57   if (std::getenv("G4IONMAGNETICMOMENT") == nu <<  55   if ( !getenv("G4IONMAGNETICMOMENT")) {
 58 #ifdef G4VERBOSE                                   56 #ifdef G4VERBOSE
 59     if (GetVerboseLevel() > 1) {               <<  57     if (GetVerboseLevel()>1) {
 60       G4cout << "G4IsotopeMagneticMomentTable: <<  58       G4cout << "G4IsotopeMagneticMomentTable::G4IsotopeMagneticMomentTable():  " 
 61              << "Please setenv G4IONMAGNETICMO <<  59        <<  "Please setenv G4IONMAGNETICMOMENT for the magnetic moment data." 
 62       G4Exception("G4IsotopeMagneticMomentTabl <<  60        << G4endl;
 63                   "Please setenv G4IONMAGNETIC <<  61       G4Exception( "G4IsotopeMagneticMomentTable",
                                                   >>  62        "File Not Found",
                                                   >>  63        JustWarning, 
                                                   >>  64        "Please setenv G4IONMAGNETICMOMENT");
 64     }                                              65     }
 65 #endif                                             66 #endif
 66     G4Exception("G4IsotopeMagneticMomentTable" <<  67     G4Exception( "G4IsotopeMagneticMomentTable",
 67                 "Please setenv G4IONMAGNETICMO <<  68      "File Not Found",
                                                   >>  69      JustWarning, 
                                                   >>  70      "Please setenv G4IONMAGNETICMOMENT");
 68     return;                                        71     return;
 69   }                                                72   }
 70                                                <<  73   
 71   G4String file = std::getenv("G4IONMAGNETICMO <<  74   G4String file = getenv("G4IONMAGNETICMOMENT");
 72   std::ifstream DataFile(file);                    75   std::ifstream DataFile(file);
 73                                                    76 
 74   if (!DataFile) {                             <<  77   if (!DataFile ) {
 75 #ifdef G4VERBOSE                                   78 #ifdef G4VERBOSE
 76     if (GetVerboseLevel() > 0) {               <<  79     if (GetVerboseLevel()>0) {
 77       G4cout << "G4IsotopeMagneticMomentTable: <<  80       G4cout << "G4IsotopeMagneticMomentTable::G4IsotopeMagneticMomentTable():  " 
 78              << " is not found " << G4endl;    <<  81       << file << " is not found " << G4endl;
 79     }                                              82     }
 80 #endif                                             83 #endif
 81     G4Exception("G4IsotopeMagneticMomentTable" <<  84     G4Exception( "G4IsotopeMagneticMomentTable",
 82                 "Can not open G4IONMAGNETICMOM <<  85      "File Not Found",
                                                   >>  86      JustWarning, 
                                                   >>  87      "Can not open G4IONMAGNETICMOMENT file");
 83     return;                                        88     return;
 84   }                                                89   }
 85                                                <<  90   
 86   char inputChars[80] = {' '};                 <<  91   char inputChars[80]={' '};
 87                                                <<  92    
 88   while (!DataFile.eof()) {  // Loop checking, <<  93   while ( !DataFile.eof() ) {
 89     DataFile.getline(inputChars, 80);              94     DataFile.getline(inputChars, 80);
 90     G4String inputLine = inputChars;               95     G4String inputLine = inputChars;
 91     G4int ionA, ionZ, ionJ, isomer;            <<  96     G4int ionA, ionZ, ionJ;
 92     G4double ionE, ionMu, ionLife;                 97     G4double ionE, ionMu, ionLife;
 93     G4String ionName, ionLifeUnit;                 98     G4String ionName, ionLifeUnit;
 94                                                <<  99  
 95     if (inputChars[0] != '#' && inputLine.leng    100     if (inputChars[0] != '#' && inputLine.length() != 0) {
 96       std::istringstream tmpstream(inputLine);    101       std::istringstream tmpstream(inputLine);
 97       tmpstream >> ionZ >> ionName >> ionA >>  << 102       tmpstream >> ionZ >>  ionName >> ionA >>  ionE 
 98         >> ionMu;                              << 103     >> ionLife >> ionLifeUnit
 99                                                << 104     >> ionJ >> ionMu;
100       auto fProperty = new G4IsotopeProperty() << 105           
                                                   >> 106       G4IsotopeProperty* fProperty = new G4IsotopeProperty();   
101       // Set Isotope Property                     107       // Set Isotope Property
102       fProperty->SetAtomicNumber(ionZ);           108       fProperty->SetAtomicNumber(ionZ);
103       fProperty->SetAtomicMass(ionA);             109       fProperty->SetAtomicMass(ionA);
104       fProperty->SetIsomerLevel(isomer);       << 
105       fProperty->SetEnergy(ionE * MeV);           110       fProperty->SetEnergy(ionE * MeV);
106       fProperty->SetiSpin(ionJ);                  111       fProperty->SetiSpin(ionJ);
107       fProperty->SetMagneticMoment(ionMu * nuc << 112       fProperty->SetMagneticMoment(ionMu*nuclearMagneton);
108                                                << 113       
109       fIsotopeList.push_back(fProperty);          114       fIsotopeList.push_back(fProperty);
110                                                   115 
111       // if (GetVerboseLevel()>2) {            << 116       //if (GetVerboseLevel()>2) {
112       //  fProperty->DumpInfo();               << 117       // fProperty->DumpInfo();
113       // }                                     << 118       //}
                                                   >> 119   
114     }                                             120     }
115   }                                               121   }
116                                                   122 
117   DataFile.close();                               123   DataFile.close();
118 }                                                 124 }
119                                                   125 
                                                   >> 126 ///////////////////////////////////////////////////////////////////////////////
120 G4IsotopeMagneticMomentTable::~G4IsotopeMagnet    127 G4IsotopeMagneticMomentTable::~G4IsotopeMagneticMomentTable()
121 {                                                 128 {
122   for (const auto& i : fIsotopeList) {         << 129   for (size_t i = 0 ; i< fIsotopeList.size(); i++) {
123     delete i;                                  << 130     delete fIsotopeList[i];
124   }                                               131   }
125   fIsotopeList.clear();                           132   fIsotopeList.clear();
126 }                                                 133 }
127                                                   134 
128 G4IsotopeMagneticMomentTable::G4IsotopeMagneti << 
129   const G4IsotopeMagneticMomentTable& right)   << 
130   : G4VIsotopeTable(right), fIsotopeList(0)    << 
131 {}                                             << 
132                                                << 
133 G4IsotopeMagneticMomentTable&                  << 
134 G4IsotopeMagneticMomentTable::operator=(const  << 
135 {                                              << 
136   return *this;                                << 
137 }                                              << 
138                                                   135 
                                                   >> 136 ///////////////////////////////////////////////////////////////////////////////
139 G4bool G4IsotopeMagneticMomentTable::FindIsoto    137 G4bool G4IsotopeMagneticMomentTable::FindIsotope(G4IsotopeProperty* pP)
140 {                                                 138 {
141   for (const auto fP : fIsotopeList) {         << 139   for (size_t i = 0 ; i< fIsotopeList.size(); ++i) {
                                                   >> 140     G4IsotopeProperty*  fP = fIsotopeList[i];
                                                   >> 141     
142     // check Z                                    142     // check Z
143     if (fP->GetAtomicNumber() > pP->GetAtomicN << 143     if ( fP->GetAtomicNumber() > pP->GetAtomicNumber()) {
144       // Not Found                                144       // Not Found
145       break;                                      145       break;
146     }                                             146     }
147     if (fP->GetAtomicNumber() < pP->GetAtomicN << 147     if ( fP->GetAtomicNumber() < pP->GetAtomicNumber()) {
148       // next                                     148       // next
149       continue;                                   149       continue;
150     }                                             150     }
151                                                << 151     
152     // check A                                    152     // check A
153     if (fP->GetAtomicMass() != pP->GetAtomicMa << 153     if ( fP->GetAtomicMass() != pP->GetAtomicMass()) {
154       // next                                  << 
155       continue;                                << 
156     }                                          << 
157                                                << 
158     // check isomerLevel                       << 
159     if (fP->GetIsomerLevel() != pP->GetIsomerL << 
160       // next                                     154       // next
161       continue;                                   155       continue;
162     }                                             156     }
163                                                << 157     
164     // check E                                 << 158     //check E
165     if (std::fabs(fP->GetEnergy() - pP->GetEne << 159     if (std::fabs(fP->GetEnergy() - pP->GetEnergy()) <= fP->GetEnergy()*levelTolerance) {
166       // Found                                    160       // Found
167       return true;                             << 161       return true;     
168     }                                             162     }
                                                   >> 163     
169   }                                               164   }
170   return false;                                   165   return false;
171 }                                                 166 }
172                                                << 167 ///////////////////////////////////////////////////////////////////////////////
173 G4IsotopeProperty* G4IsotopeMagneticMomentTabl << 168 //
174                                                << 169 G4IsotopeProperty* G4IsotopeMagneticMomentTable::GetIsotope(G4int Z, G4int A, G4double E)
175 {                                              << 170 {
176   G4IsotopeProperty* fProperty = nullptr;      << 171   G4IsotopeProperty* fProperty = 0;
177   for (const auto fP : fIsotopeList) {         << 172   for (size_t i = 0 ; i< fIsotopeList.size(); ++i) {
178     // check Z                                 << 173     G4IsotopeProperty*  fP = fIsotopeList[i];
179     if (fP->GetAtomicNumber() > Z) {           << 174  
                                                   >> 175      // check Z
                                                   >> 176     if ( fP->GetAtomicNumber() > Z) {
180       // Not Found                                177       // Not Found
181       break;                                      178       break;
182     }                                             179     }
183     if (fP->GetAtomicNumber() < Z) {           << 180     if ( fP->GetAtomicNumber() < Z) {
184       // next                                     181       // next
185       continue;                                   182       continue;
186     }                                             183     }
187                                                << 184     
188     // check A                                    185     // check A
189     if (fP->GetAtomicMass() != A) {            << 186     if ( fP->GetAtomicMass() != A ) {
190       // next                                     187       // next
191       continue;                                   188       continue;
192     }                                             189     }
193                                                << 190     
194     // check E                                 << 191     //check E
195     if (std::fabs(fP->GetEnergy() - E) < level << 192     if (std::fabs(fP->GetEnergy() - E) <= fP->GetEnergy()*levelTolerance) {
196       // Found                                    193       // Found
197       fProperty = fP;                             194       fProperty = fP;
198       // fP->DumpInfo();                       << 195       fP->DumpInfo();
199       break;                                   << 196       break;     
200     }                                          << 
201   }                                            << 
202                                                << 
203   return fProperty;                            << 
204 }                                              << 
205                                                << 
206 G4IsotopeProperty* G4IsotopeMagneticMomentTabl << 
207 {                                              << 
208   G4IsotopeProperty* fProperty = nullptr;      << 
209   for (const auto fP : fIsotopeList) {         << 
210     // check Z                                 << 
211     if (fP->GetAtomicNumber() > Z) {           << 
212       // Not Found                             << 
213       break;                                   << 
214     }                                          << 
215     if (fP->GetAtomicNumber() < Z) {           << 
216       // next                                  << 
217       continue;                                << 
218     }                                          << 
219     // check A                                 << 
220     if (fP->GetAtomicMass() != A) {            << 
221       // next                                  << 
222       continue;                                << 
223     }                                          << 
224                                                << 
225     // check isomerLevel                       << 
226     if (fP->GetIsomerLevel() == lvl) {         << 
227       // Found                                 << 
228       fProperty = fP;                          << 
229       // fP->DumpInfo();                       << 
230       break;                                   << 
231     }                                             197     }
                                                   >> 198     
232   }                                               199   }
233                                                   200 
234   return fProperty;                               201   return fProperty;
                                                   >> 202   
235 }                                                 203 }
236                                                   204