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