| Geant4 Cross Reference |
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 // G4DataVector class implementation <<
27 // 26 //
28 // Author: H.Kurashige, 18 September 2001 << 27 // $Id$
29 // ------------------------------------------- << 28 //
>> 29 //
>> 30 // --------------------------------------------------------------
>> 31 // GEANT 4 class implementation file
>> 32 //
>> 33 // G4DataVector.cc
>> 34 //
>> 35 // History:
>> 36 // 18 Sep. 2001, H.Kurashige : Structure created based on object model
>> 37 // --------------------------------------------------------------
30 38
31 #include "G4DataVector.hh" 39 #include "G4DataVector.hh"
32 #include <iomanip> 40 #include <iomanip>
33 41
34 // ------------------------------------------- << 42 G4DataVector::G4DataVector()
35 G4DataVector::G4DataVector(std::size_t cap) << 43 : std::vector<G4double>()
>> 44 {
>> 45 }
>> 46
>> 47 G4DataVector::G4DataVector(size_t cap)
36 : std::vector<G4double>(cap, 0.0) 48 : std::vector<G4double>(cap, 0.0)
37 {} << 49 {
>> 50 }
38 51
39 // ------------------------------------------- << 52 G4DataVector::G4DataVector(size_t cap, G4double value)
40 G4DataVector::G4DataVector(std::size_t cap, G4 <<
41 : std::vector<G4double>(cap, value) 53 : std::vector<G4double>(cap, value)
42 {} << 54 {
>> 55 }
>> 56
>> 57 G4DataVector::~G4DataVector()
>> 58 {
>> 59 }
43 60
44 // ------------------------------------------- <<
45 G4bool G4DataVector::Store(std::ofstream& fOut 61 G4bool G4DataVector::Store(std::ofstream& fOut, G4bool ascii)
46 { 62 {
47 // Ascii mode 63 // Ascii mode
48 if(ascii) << 64 if (ascii)
49 { 65 {
50 fOut << *this; 66 fOut << *this;
51 return true; 67 return true;
52 } << 68 }
53 69
54 // Binary Mode 70 // Binary Mode
55 auto sizeV = G4int(size()); << 71 size_t sizeV = size();
56 fOut.write((char*) (&sizeV), sizeof sizeV); << 72 fOut.write((char*)(&sizeV), sizeof sizeV);
57 <<
58 auto value = new G4double[sizeV]; <<
59 std::size_t i = 0; <<
60 for(auto itr = cbegin(); itr != cend(); ++it <<
61 { <<
62 value[i] = *itr; <<
63 } <<
64 fOut.write((char*) (value), sizeV * (sizeof( <<
65 delete[] value; <<
66 73
>> 74 G4double* value = new G4double[sizeV];
>> 75 size_t i=0;
>> 76 for (const_iterator itr=begin(); itr!=end(); itr++, i++)
>> 77 {
>> 78 value[i] = *itr;
>> 79 }
>> 80 fOut.write((char*)(value), sizeV*(sizeof (G4double)) );
>> 81 delete [] value;
>> 82
67 return true; 83 return true;
68 } 84 }
69 85
70 // ------------------------------------------- <<
71 G4bool G4DataVector::Retrieve(std::ifstream& f 86 G4bool G4DataVector::Retrieve(std::ifstream& fIn, G4bool ascii)
72 { 87 {
73 clear(); 88 clear();
74 G4int sizeV = 0; << 89 G4int sizeV=0;
75 << 90
76 // retrieve in ascii mode 91 // retrieve in ascii mode
77 if(ascii) << 92 if (ascii)
78 { 93 {
79 // contents 94 // contents
80 fIn >> sizeV; 95 fIn >> sizeV;
81 if(fIn.fail()) << 96 if (fIn.fail()) { return false; }
>> 97 if (sizeV<=0)
82 { 98 {
83 return false; << 99 #ifdef G4VERBOSE
84 } <<
85 if(sizeV <= 0) <<
86 { <<
87 #ifdef G4VERBOSE <<
88 G4cerr << "G4DataVector::Retrieve():"; 100 G4cerr << "G4DataVector::Retrieve():";
89 G4cerr << " Invalid vector size: " << si 101 G4cerr << " Invalid vector size: " << sizeV << G4endl;
90 #endif 102 #endif
91 return false; 103 return false;
92 } 104 }
93 105
94 reserve(sizeV); 106 reserve(sizeV);
95 for(G4int i = 0; i < sizeV; ++i) << 107 for(G4int i = 0; i < sizeV ; i++)
96 { 108 {
97 G4double vData = 0.0; << 109 G4double vData=0.0;
98 fIn >> vData; 110 fIn >> vData;
99 if(fIn.fail()) << 111 if (fIn.fail()) { return false; }
100 { <<
101 return false; <<
102 } <<
103 push_back(vData); 112 push_back(vData);
104 } 113 }
105 return true; << 114 return true ;
106 } 115 }
107 << 116
108 // retrieve in binary mode 117 // retrieve in binary mode
109 fIn.read((char*) (&sizeV), sizeof sizeV); << 118 fIn.read((char*)(&sizeV), sizeof sizeV);
110 << 119
111 auto value = new G4double[sizeV]; << 120 G4double* value = new G4double[sizeV];
112 fIn.read((char*) (value), sizeV * (sizeof(G4 << 121 fIn.read((char*)(value), sizeV*(sizeof(G4double)) );
113 if(G4int(fIn.gcount()) != G4int(sizeV * (siz << 122 if (G4int(fIn.gcount()) != G4int(sizeV*(sizeof(G4double))) )
114 { 123 {
115 delete[] value; << 124 delete [] value;
116 return false; 125 return false;
117 } 126 }
118 127
119 reserve(sizeV); 128 reserve(sizeV);
120 for(G4int i = 0; i < sizeV; ++i) << 129 for(G4int i = 0; i < sizeV; i++)
121 { 130 {
122 push_back(value[i]); 131 push_back(value[i]);
123 } 132 }
124 delete[] value; << 133 delete [] value;
125 return true; 134 return true;
126 } 135 }
127 << 136
128 // ------------------------------------------- <<
129 std::ostream& operator<<(std::ostream& out, co 137 std::ostream& operator<<(std::ostream& out, const G4DataVector& pv)
130 { 138 {
131 out << pv.size() << std::setprecision(12) << << 139 out << pv.size() << std::setprecision(12) << G4endl;
132 for(std::size_t i = 0; i < pv.size(); ++i) << 140 for(size_t i = 0; i < pv.size(); i++)
133 { 141 {
134 out << pv[i] << G4endl; 142 out << pv[i] << G4endl;
135 } 143 }
136 out << std::setprecision(6); 144 out << std::setprecision(6);
137 145
138 return out; 146 return out;
139 } 147 }
>> 148
140 149