Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/global/management/src/G4PhysicsVector.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 /global/management/src/G4PhysicsVector.cc (Version 11.3.0) and /global/management/src/G4PhysicsVector.cc (Version 1.1)


                                                   >>   1 // This code implementation is the intellectual property of
                                                   >>   2 // the GEANT4 collaboration.
  1 //                                                  3 //
  2 // ******************************************* <<   4 // By copying, distributing or modifying the Program (or any work
  3 // * License and Disclaimer                    <<   5 // based on the Program) you indicate your acceptance of this statement,
  4 // *                                           <<   6 // and all its terms.
  5 // * The  Geant4 software  is  copyright of th << 
  6 // * the Geant4 Collaboration.  It is provided << 
  7 // * conditions of the Geant4 Software License << 
  8 // * LICENSE and available at  http://cern.ch/ << 
  9 // * include a list of copyright holders.      << 
 10 // *                                           << 
 11 // * Neither the authors of this software syst << 
 12 // * institutes,nor the agencies providing fin << 
 13 // * work  make  any representation or  warran << 
 14 // * regarding  this  software system or assum << 
 15 // * use.  Please see the license in the file  << 
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                           << 
 18 // * This  code  implementation is the result  << 
 19 // * technical work of the GEANT4 collaboratio << 
 20 // * By using,  copying,  modifying or  distri << 
 21 // * any work based  on the software)  you  ag << 
 22 // * use  in  resulting  scientific  publicati << 
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // ******************************************* << 
 25 //                                                  7 //
 26 // G4PhysicsVector class implementation        <<   8 // $Id: G4PhysicsVector.cc,v 1.4 1999/11/23 15:00:05 gcosmo Exp $
                                                   >>   9 // GEANT4 tag $Name: geant4-01-01 $
 27 //                                                 10 //
 28 // Authors:                                    <<  11 // 
 29 // - 02 Dec. 1995, G.Cosmo: Structure created  <<  12 // --------------------------------------------------------------
 30 // - 03 Mar. 1996, K.Amako: Implemented the 1s <<  13 //      GEANT 4 class implementation file
 31 // Revisions:                                  <<  14 //
 32 // - 11 Nov. 2000, H.Kurashige: Use STL vector <<  15 //  G4PhysicsVector.cc
 33 // ------------------------------------------- <<  16 //
                                                   >>  17 //  History: first implementation, based on object model of
                                                   >>  18 //    02 Dec. 1995, G.Cosmo : Structure created based on object model
                                                   >>  19 //    03 Mar. 1996, K.Amako : Implemented the 1st version
                                                   >>  20 //    01 Jul. 1996, K.Amako : Hidden bin from the user introduced
                                                   >>  21 //    12 Nov. 1998, K.Amako : A bug in GetVectorLength() fixed
                                                   >>  22 //
                                                   >>  23 // --------------------------------------------------------------
 34                                                    24 
 35 #include "G4PhysicsVector.hh"                      25 #include "G4PhysicsVector.hh"
 36 #include <iomanip>                             << 
 37                                                    26 
 38 // ------------------------------------------- <<  27 G4PhysicsVector::G4PhysicsVector()
 39 G4PhysicsVector::G4PhysicsVector(G4bool val)   <<  28  : edgeMin(0.), edgeMax(0.), numberOfBin(0),
 40   : useSpline(val)                             <<  29    lastEnergy(0.), lastValue(0.), lastBin(0),
 41 {}                                             <<  30    ptrNextTable(0) {}
 42                                                    31 
 43 // ------------------------------------------- <<  32 G4PhysicsVector::~G4PhysicsVector() {}
 44 void G4PhysicsVector::Initialise()             <<  33 
                                                   >>  34 G4int G4PhysicsVector::operator==(const G4PhysicsVector &right) const
 45 {                                                  35 {
 46   if (1 < numberOfNodes)                       <<  36   return (this == (G4PhysicsVector *) &right);
 47   {                                            << 
 48     idxmax = numberOfNodes - 2;                << 
 49     edgeMin = binVector[0];                    << 
 50     edgeMax = binVector[idxmax + 1];           << 
 51   }                                            << 
 52 }                                                  37 }
 53                                                    38 
 54 // ------------------------------------------- <<  39 G4int G4PhysicsVector::operator!=(const G4PhysicsVector &right) const
 55 G4bool G4PhysicsVector::Store(std::ofstream& f << 
 56 {                                                  40 {
 57   // Ascii mode                                <<  41   return (this != (G4PhysicsVector *) &right);
 58   if (ascii)                                   << 
 59   {                                            << 
 60     fOut << *this;                             << 
 61     return true;                               << 
 62   }                                            << 
 63   // Binary Mode                               << 
 64                                                << 
 65   // binning                                   << 
 66   fOut.write((char*) (&edgeMin), sizeof edgeMi << 
 67   fOut.write((char*) (&edgeMax), sizeof edgeMa << 
 68   fOut.write((char*) (&numberOfNodes), sizeof  << 
 69                                                << 
 70   // contents                                  << 
 71   std::size_t size = dataVector.size();        << 
 72   fOut.write((char*) (&size), sizeof size);    << 
 73                                                << 
 74   auto value = new G4double[2 * size];         << 
 75   for (std::size_t i = 0; i < size; ++i)       << 
 76   {                                            << 
 77     value[2 * i]     = binVector[i];           << 
 78     value[2 * i + 1] = dataVector[i];          << 
 79   }                                            << 
 80   fOut.write((char*) (value), 2 * size * (size << 
 81   delete[] value;                              << 
 82                                                << 
 83   return true;                                 << 
 84 }                                                  42 }
 85                                                    43 
 86 // ------------------------------------------- <<  44 void G4PhysicsVector::PutValue(size_t binNumber, G4double theValue)
 87 G4bool G4PhysicsVector::Retrieve(std::ifstream << 
 88 {                                                  45 {
 89   // clear properties;                         <<  46   dataVector(binNumber) = theValue;
 90   dataVector.clear();                          << 
 91   binVector.clear();                           << 
 92   secDerivative.clear();                       << 
 93                                                << 
 94   // retrieve in ascii mode                    << 
 95   if (ascii)                                   << 
 96   {                                            << 
 97     // binning                                 << 
 98     fIn >> edgeMin >> edgeMax >> numberOfNodes << 
 99     if (fIn.fail() || numberOfNodes < 2)       << 
100     {                                          << 
101       return false;                            << 
102     }                                          << 
103     // contents                                << 
104     G4int siz0 = 0;                            << 
105     fIn >> siz0;                               << 
106     if (siz0 < 2) { return false; }            << 
107     auto siz = static_cast<std::size_t>(siz0); << 
108     if (fIn.fail() || siz != numberOfNodes)    << 
109     {                                          << 
110       return false;                            << 
111     }                                          << 
112                                                << 
113     binVector.reserve(siz);                    << 
114     dataVector.reserve(siz);                   << 
115     G4double vBin, vData;                      << 
116                                                << 
117     for (std::size_t i = 0; i < siz; ++i)      << 
118     {                                          << 
119       vBin  = 0.;                              << 
120       vData = 0.;                              << 
121       fIn >> vBin >> vData;                    << 
122       if (fIn.fail())                          << 
123       {                                        << 
124         return false;                          << 
125       }                                        << 
126       binVector.push_back(vBin);               << 
127       dataVector.push_back(vData);             << 
128     }                                          << 
129     Initialise();                              << 
130     return true;                               << 
131   }                                            << 
132                                                << 
133   // retrieve in binary mode                   << 
134   // binning                                   << 
135   fIn.read((char*) (&edgeMin), sizeof edgeMin) << 
136   fIn.read((char*) (&edgeMax), sizeof edgeMax) << 
137   fIn.read((char*) (&numberOfNodes), sizeof nu << 
138                                                << 
139   // contents                                  << 
140   std::size_t size;                            << 
141   fIn.read((char*) (&size), sizeof size);      << 
142                                                << 
143   auto value = new G4double[2 * size];         << 
144   fIn.read((char*) (value), 2 * size * (sizeof << 
145   if (static_cast<G4int>(fIn.gcount()) != stat << 
146   {                                            << 
147     delete[] value;                            << 
148     return false;                              << 
149   }                                            << 
150                                                << 
151   binVector.reserve(size);                     << 
152   dataVector.reserve(size);                    << 
153   for (std::size_t i = 0; i < size; ++i)       << 
154   {                                            << 
155     binVector.push_back(value[2 * i]);         << 
156     dataVector.push_back(value[2 * i + 1]);    << 
157   }                                            << 
158   delete[] value;                              << 
159                                                    47 
160   Initialise();                                <<  48   // Fill the bin which is hidden to user with theValue. This is to 
161   return true;                                 <<  49   // handle correctly when Energy=theEmax in getValue.
                                                   >>  50   if(binNumber=numberOfBin-1) {
                                                   >>  51     dataVector(binNumber+1) = theValue;
                                                   >>  52   }                                 
162 }                                                  53 }
163                                                    54 
164 // ------------------------------------------- <<  55 G4double G4PhysicsVector::GetLowEdgeEnergy(size_t binNumber) const
165 void G4PhysicsVector::DumpValues(G4double unit << 
166 {                                                  56 {
167   for (std::size_t i = 0; i < numberOfNodes; + <<  57   return binVector(binNumber);
168   {                                            << 
169     G4cout << binVector[i] / unitE << "   " << << 
170            << G4endl;                          << 
171   }                                            << 
172 }                                                  58 }
173                                                    59 
174 // ------------------------------------------- <<  60 size_t G4PhysicsVector::GetVectorLength() const
175 std::size_t G4PhysicsVector::FindBin(const G4d << 
176                                      std::size << 
177 {                                                  61 {
178   if (idx + 1 < numberOfNodes &&               <<  62   return numberOfBin;
179       energy >= binVector[idx] && energy <= bi << 
180   {                                            << 
181     return idx;                                << 
182   }                                            << 
183   if (energy <= binVector[1])                  << 
184   {                                            << 
185     return 0;                                  << 
186   }                                            << 
187   if (energy >= binVector[idxmax])             << 
188   {                                            << 
189     return idxmax;                             << 
190   }                                            << 
191   return GetBin(energy);                       << 
192 }                                                  63 }
193                                                    64 
194 // ------------------------------------------- <<  65 G4bool G4PhysicsVector::IsFilledVectorExist() const
195 void G4PhysicsVector::ScaleVector(const G4doub << 
196                                   const G4doub << 
197 {                                                  66 {
198   for (std::size_t i = 0; i < numberOfNodes; + <<  67   G4bool status=false;
199   {                                            <<  68 
200     binVector[i] *= factorE;                   <<  69   if(numberOfBin > 0) status=true;
201     dataVector[i] *= factorV;                  <<  70   return status;
202   }                                            << 
203   Initialise();                                << 
204 }                                                  71 }
205                                                    72 
206 // ------------------------------------------- <<  73 void G4PhysicsVector::LinkPhysicsTable(G4RWTPtrOrderedVector<G4PhysicsVector>& theTable)
207 void G4PhysicsVector::FillSecondDerivatives(co << 
208               const G4double dir1,             << 
209               const G4double dir2)             << 
210 {                                                  74 {
211   if (!useSpline) { return; }                  <<  75   ptrNextTable = &theTable;
212   // cannot compute derivatives for less than  <<  76 } 
213   const std::size_t nmin = (stype == G4SplineT << 
214   if (nmin > numberOfNodes)                    << 
215   {                                            << 
216     if (0 < verboseLevel)                      << 
217     {                                          << 
218       G4cout << "### G4PhysicsVector: spline c << 
219        << numberOfNodes << " points - spline d << 
220        << G4endl;                              << 
221       DumpValues();                            << 
222     }                                          << 
223     useSpline = false;                         << 
224     return;                                    << 
225   }                                            << 
226   // check energies of free vector             << 
227   if (type == T_G4PhysicsFreeVector)           << 
228   {                                            << 
229     for (std::size_t i=0; i<=idxmax; ++i)      << 
230     {                                          << 
231       if (binVector[i + 1] <= binVector[i])    << 
232       {                                        << 
233         if (0 < verboseLevel)                  << 
234         {                                      << 
235     G4cout << "### G4PhysicsVector: spline can << 
236      << " E[" << i << "]=" << binVector[i]     << 
237      << " >= E[" << i+1 << "]=" << binVector[i << 
238      << G4endl;                                << 
239     DumpValues();                              << 
240         }                                      << 
241         useSpline = false;                     << 
242         return;                                << 
243       }                                        << 
244     }                                          << 
245   }                                            << 
246                                                << 
247   // spline is possible                        << 
248   Initialise();                                << 
249   secDerivative.resize(numberOfNodes);         << 
250                                                << 
251   if (1 < verboseLevel)                        << 
252   {                                            << 
253     G4cout << "### G4PhysicsVector:: FillSecon << 
254            << numberOfNodes << G4endl;         << 
255     DumpValues();                              << 
256   }                                            << 
257                                                << 
258   switch(stype)                                << 
259   {                                            << 
260     case G4SplineType::Base:                   << 
261       ComputeSecDerivative1();                 << 
262       break;                                   << 
263                                                << 
264     case G4SplineType::FixedEdges:             << 
265       ComputeSecDerivative2(dir1, dir2);       << 
266       break;                                   << 
267                                                << 
268     default:                                   << 
269       ComputeSecDerivative0();                 << 
270   }                                            << 
271 }                                              << 
272                                                    77 
273 // ------------------------------------------- <<  78 G4bool G4PhysicsVector::IsLinkedTableExist() const
274 void G4PhysicsVector::ComputeSecDerivative0()  << 
275 //  A simplified method of computation of seco << 
276 {                                                  79 {
277   std::size_t n = numberOfNodes - 1;           <<  80   G4bool status=false;
278                                                    81 
279   for (std::size_t i = 1; i < n; ++i)          <<  82   if(ptrNextTable != 0) status=true;
280   {                                            <<  83   return status;
281     secDerivative[i] = 3.0 *                   << 
282       ((dataVector[i + 1] - dataVector[i]) / ( << 
283        (dataVector[i] - dataVector[i - 1]) /   << 
284          (binVector[i] - binVector[i - 1])) /  << 
285       (binVector[i + 1] - binVector[i - 1]);   << 
286   }                                            << 
287   secDerivative[n] = secDerivative[n - 1];     << 
288   secDerivative[0] = secDerivative[1];         << 
289 }                                                  84 }
290                                                    85 
291 // ------------------------------------------- <<  86 void G4PhysicsVector::PutComment(const G4String& theComment)
292 void G4PhysicsVector::ComputeSecDerivative1()  << 
293 // Computation of second derivatives using "No << 
294 // B.I. Kvasov "Methods of shape-preserving sp << 
295 // World Scientific, 2000                      << 
296 {                                                  87 {
297   std::size_t n = numberOfNodes - 1;           <<  88   comment = theComment;
298   auto u = new G4double[n];                    << 
299   G4double p, sig;                             << 
300                                                << 
301   u[1] = ((dataVector[2] - dataVector[1]) / (b << 
302           (dataVector[1] - dataVector[0]) / (b << 
303   u[1] = 6.0 * u[1] * (binVector[2] - binVecto << 
304          ((binVector[2] - binVector[0]) * (bin << 
305                                                << 
306   // Decomposition loop for tridiagonal algori << 
307   // and u[i] are used for temporary storage o << 
308                                                << 
309   secDerivative[1] = (2.0 * binVector[1] - bin << 
310                      (2.0 * binVector[2] - bin << 
311                                                << 
312   for(std::size_t i = 2; i < n - 1; ++i)       << 
313   {                                            << 
314     sig =                                      << 
315       (binVector[i] - binVector[i - 1]) / (bin << 
316     p                = sig * secDerivative[i - << 
317     secDerivative[i] = (sig - 1.0) / p;        << 
318     u[i] =                                     << 
319       (dataVector[i + 1] - dataVector[i]) / (b << 
320       (dataVector[i] - dataVector[i - 1]) / (b << 
321     u[i] =                                     << 
322       (6.0 * u[i] / (binVector[i + 1] - binVec << 
323   }                                            << 
324                                                << 
325   sig =                                        << 
326     (binVector[n - 1] - binVector[n - 2]) / (b << 
327   p = sig * secDerivative[n - 3] + 2.0;        << 
328   u[n - 1] =                                   << 
329     (dataVector[n] - dataVector[n - 1]) / (bin << 
330     (dataVector[n - 1] - dataVector[n - 2]) /  << 
331       (binVector[n - 1] - binVector[n - 2]);   << 
332   u[n - 1] = 6.0 * sig * u[n - 1] / (binVector << 
333              (2.0 * sig - 1.0) * u[n - 2] / p; << 
334                                                << 
335   p = (1.0 + sig) + (2.0 * sig - 1.0) * secDer << 
336   secDerivative[n - 1] = u[n - 1] / p;         << 
337                                                << 
338   // The back-substitution loop for the triago << 
339   // a linear system of equations.             << 
340                                                << 
341   for (std::size_t k = n - 2; k > 1; --k)      << 
342   {                                            << 
343     secDerivative[k] *=                        << 
344       (secDerivative[k + 1] - u[k] * (binVecto << 
345                                 (binVector[k + << 
346   }                                            << 
347   secDerivative[n] =                           << 
348     (secDerivative[n - 1] - (1.0 - sig) * secD << 
349   sig = 1.0 - ((binVector[2] - binVector[1]) / << 
350   secDerivative[1] *= (secDerivative[2] - u[1] << 
351   secDerivative[0] = (secDerivative[1] - sig * << 
352                                                << 
353   delete[] u;                                  << 
354 }                                                  89 }
355                                                    90 
356 // ------------------------------------------- <<  91 G4String G4PhysicsVector::GetComment() const
357 void G4PhysicsVector::ComputeSecDerivative2(G4 << 
358                                             G4 << 
359 // A standard method of computation of second  << 
360 // First derivatives at the first and the last << 
361 // See for example W.H. Press et al. "Numerica << 
362 // Cambridge University Press, 1997.           << 
363 {                                                  92 {
364   std::size_t n = numberOfNodes - 1;           <<  93   return comment;
365   auto u = new G4double[n];                    << 
366   G4double p, sig, un;                         << 
367                                                << 
368   u[0] = (6.0 / (binVector[1] - binVector[0])) << 
369          ((dataVector[1] - dataVector[0]) / (b << 
370           firstPointDerivative);               << 
371                                                << 
372   secDerivative[0] = -0.5;                     << 
373                                                << 
374   // Decomposition loop for tridiagonal algori << 
375   // and u[i] are used for temporary storage o << 
376                                                << 
377   for (std::size_t i = 1; i < n; ++i)          << 
378   {                                            << 
379     sig =                                      << 
380       (binVector[i] - binVector[i - 1]) / (bin << 
381     p                = sig * (secDerivative[i  << 
382     secDerivative[i] = (sig - 1.0) / p;        << 
383     u[i] =                                     << 
384       (dataVector[i + 1] - dataVector[i]) / (b << 
385       (dataVector[i] - dataVector[i - 1]) / (b << 
386     u[i] =                                     << 
387       6.0 * u[i] / (binVector[i + 1] - binVect << 
388   }                                            << 
389                                                << 
390   sig =                                        << 
391     (binVector[n - 1] - binVector[n - 2]) / (b << 
392   p  = sig * secDerivative[n - 2] + 2.0;       << 
393   un = (6.0 / (binVector[n] - binVector[n - 1] << 
394          (endPointDerivative - (dataVector[n]  << 
395                                  (binVector[n] << 
396        u[n - 1] / p;                           << 
397   secDerivative[n] = un / (secDerivative[n - 1 << 
398                                                << 
399   // The back-substitution loop for the triago << 
400   // a linear system of equations.             << 
401                                                << 
402   for (std::size_t k = n - 1; k > 0; --k)      << 
403   {                                            << 
404     secDerivative[k] *=                        << 
405       (secDerivative[k + 1] - u[k] * (binVecto << 
406                                 (binVector[k + << 
407   }                                            << 
408   secDerivative[0] = 0.5 * (u[0] - secDerivati << 
409                                                << 
410   delete[] u;                                  << 
411 }                                                  94 }
412                                                    95 
413 // ------------------------------------------- << 
414 std::ostream& operator<<(std::ostream& out, co << 
415 {                                              << 
416   // binning                                   << 
417   G4long prec = out.precision();               << 
418   out << std::setprecision(12) << pv.edgeMin < << 
419       << pv.numberOfNodes << G4endl;           << 
420                                                << 
421   // contents                                  << 
422   out << pv.dataVector.size() << G4endl;       << 
423   for (std::size_t i = 0; i < pv.dataVector.si << 
424   {                                            << 
425     out << pv.binVector[i] << "  " << pv.dataV << 
426   }                                            << 
427   out.precision(prec);                         << 
428                                                    96 
429   return out;                                  << 
430 }                                              << 
431                                                    97 
432 //-------------------------------------------- << 
433 G4double G4PhysicsVector::GetEnergy(const G4do << 
434 {                                              << 
435   if (0 == numberOfNodes)                      << 
436   {                                            << 
437     return 0.0;                                << 
438   }                                            << 
439   if (1 == numberOfNodes || val <= dataVector[ << 
440   {                                            << 
441     return edgeMin;                            << 
442   }                                            << 
443   if (val >= dataVector[numberOfNodes - 1])    << 
444   {                                            << 
445     return edgeMax;                            << 
446   }                                            << 
447   std::size_t bin = std::lower_bound(dataVecto << 
448                   - dataVector.cbegin() - 1;   << 
449   if (bin > idxmax) { bin = idxmax; }          << 
450   G4double res = binVector[bin];               << 
451   G4double del = dataVector[bin + 1] - dataVec << 
452   if (del > 0.0)                               << 
453   {                                            << 
454     res += (val - dataVector[bin]) * (binVecto << 
455   }                                            << 
456   return res;                                  << 
457 }                                              << 
458                                                    98 
459 //-------------------------------------------- << 
460 void G4PhysicsVector::PrintPutValueError(std:: << 
461                                          G4dou << 
462                                          const << 
463 {                                              << 
464   G4ExceptionDescription ed;                   << 
465   ed << "Vector type: " << type << " length= " << 
466      << "; an attempt to put data at index= "  << 
467      << " value= " << val << " in " << text;   << 
468   G4Exception("G4PhysicsVector:", "gl0005",    << 
469               FatalException, ed, "Wrong opera << 
470 }                                              << 
471                                                    99 
472 //-------------------------------------------- << 100 
                                                   >> 101 
                                                   >> 102 
                                                   >> 103 
                                                   >> 104 
                                                   >> 105 
                                                   >> 106 
473                                                   107