Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/gMocren/src/G4GMocrenIO.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 /visualization/gMocren/src/G4GMocrenIO.cc (Version 11.3.0) and /visualization/gMocren/src/G4GMocrenIO.cc (Version 9.5)


  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 // $Id: G4GMocrenIO.cc,v 1.6 2010-11-10 23:53:23 akimura Exp $
                                                   >>  28 // GEANT4 tag $Name: not supported by cvs2svn $
 27 //                                                 29 //
 28 //                                                 30 //
 29 // File I/O manager class for writing or readi     31 // File I/O manager class for writing or reading calcuated dose
 30 // distribution and some event information         32 // distribution and some event information
 31 //                                                 33 //
 32 // Created:  Mar. 31, 2009  Akinori Kimura : r     34 // Created:  Mar. 31, 2009  Akinori Kimura : release for the gMocrenFile driver
 33 //                                                 35 //
 34 //                               Akinori Kimur     36 //                               Akinori Kimura
 35 //                               gMocren home      37 //                               gMocren home page:
 36 //                               http://geant4     38 //                               http://geant4.kek.jp/gMocren/
 37 //                                                 39 //
 38 //                                                 40 //
 39 #include "G4GMocrenIO.hh"                          41 #include "G4GMocrenIO.hh"
 40 #include <iostream>                                42 #include <iostream>
 41 #include <ctime>                                   43 #include <ctime>
 42 #include <sstream>                                 44 #include <sstream>
 43 #include <iomanip>                                 45 #include <iomanip>
 44 #include <cstdlib>                                 46 #include <cstdlib>
 45 #include <cstring>                                 47 #include <cstring>
 46                                                    48 
 47 #include "globals.hh"                              49 #include "globals.hh"
 48 #include "G4VisManager.hh"                         50 #include "G4VisManager.hh"
 49                                                    51 
 50 #if defined(_WIN32)                                52 #if defined(_WIN32)
 51 #define LITTLE_ENDIAN 1234                         53 #define LITTLE_ENDIAN 1234
 52 #define BYTE_ORDER LITTLE_ENDIAN                   54 #define BYTE_ORDER LITTLE_ENDIAN
 53 #endif                                             55 #endif
 54                                                    56 
 55 const int DOSERANGE = 25000;                       57 const int DOSERANGE = 25000;
 56                                                    58 
 57 //----- GMocrenDataPrimitive class in the GMoc     59 //----- GMocrenDataPrimitive class in the GMocrenDataIO class-----//
 58 template <typename T>                              60 template <typename T> 
 59 GMocrenDataPrimitive<T>::GMocrenDataPrimitive      61 GMocrenDataPrimitive<T>::GMocrenDataPrimitive () {
 60   clear();                                         62   clear();
 61 }                                                  63 }
 62 template <typename T>                              64 template <typename T> 
 63 GMocrenDataPrimitive<T>::~GMocrenDataPrimitive     65 GMocrenDataPrimitive<T>::~GMocrenDataPrimitive () {
 64   /*                                               66   /*
 65     std::vector<short *>::iterator itr = image     67     std::vector<short *>::iterator itr = image.begin();
 66     for(; itr != image.end(); itr++) {             68     for(; itr != image.end(); itr++) {
 67     delete [] *itr;                                69     delete [] *itr;
 68     }                                              70     }
 69   */                                               71   */
 70 }                                                  72 }
 71                                                    73 
 72 template <typename T> GMocrenDataPrimitive<T>      74 template <typename T> GMocrenDataPrimitive<T> & 
 73 GMocrenDataPrimitive<T>::operator = (const GMo     75 GMocrenDataPrimitive<T>::operator = (const GMocrenDataPrimitive<T> & _right) {
 74   if (this == &_right) return *this;           << 
 75   for(int i = 0; i < 3; i++) {                     76   for(int i = 0; i < 3; i++) {
 76     kSize[i] = _right.kSize[i];                    77     kSize[i] = _right.kSize[i];
 77     kCenter[i] = _right.kCenter[i];                78     kCenter[i] = _right.kCenter[i];
 78   }                                                79   }
 79   kScale = _right.kScale;                          80   kScale = _right.kScale;
 80   for(int i = 0; i < 2; i++) kMinmax[i] = _rig     81   for(int i = 0; i < 2; i++) kMinmax[i] = _right.kMinmax[i];
 81   int num = kSize[0]*kSize[1];                     82   int num = kSize[0]*kSize[1];
 82   kImage.clear();                                  83   kImage.clear();
 83   for(int z = 0; z < kSize[2]; z++) {              84   for(int z = 0; z < kSize[2]; z++) {
 84     T * img = new T[num];                          85     T * img = new T[num];
 85     for(int i = 0; i < num; i++) img[i] =_righ     86     for(int i = 0; i < num; i++) img[i] =_right.kImage[z][i];
 86     kImage.push_back(img);                         87     kImage.push_back(img);
 87   }                                                88   }
 88   return *this;                                    89   return *this;
 89 }                                                  90 }
 90                                                    91 
 91 template <typename T> GMocrenDataPrimitive<T>      92 template <typename T> GMocrenDataPrimitive<T> & 
 92 GMocrenDataPrimitive<T>::operator + (const GMo     93 GMocrenDataPrimitive<T>::operator + (const GMocrenDataPrimitive<T> & _right) {
 93                                                    94 
 94   GMocrenDataPrimitive<T> rprim;                   95   GMocrenDataPrimitive<T> rprim;
 95   bool stat = true;                                96   bool stat = true;
 96   for(int i = 0; i < 3; i++) {                     97   for(int i = 0; i < 3; i++) {
 97     if(kSize[i] != _right.kSize[i]) stat = fal     98     if(kSize[i] != _right.kSize[i]) stat = false;
 98     if(kCenter[i] != _right.kCenter[i]) stat =     99     if(kCenter[i] != _right.kCenter[i]) stat = false;
 99   }                                               100   }
100   if(!stat) {                                     101   if(!stat) {
101     if (G4VisManager::GetVerbosity() >= G4VisM    102     if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
102       G4cout << "Warning: operator + "            103       G4cout << "Warning: operator + "
103        << "         Cannot do the operator +"     104        << "         Cannot do the operator +"
104        << G4endl;                                 105        << G4endl;
105     return *this;                                 106     return *this;
106   }                                               107   }
107                                                   108 
108   rprim.setSize(kSize);                           109   rprim.setSize(kSize);
109   rprim.setCenterPosition(kCenter);               110   rprim.setCenterPosition(kCenter);
110                                                   111   
111   T mms[2] = {9e100,-9e100};                   << 112   T mm[2] = {9e100,-9e100};
112   //if(mms[0] > _right.minmax[0]) mms[0] = _ri << 113   //if(mm[0] > _right.minmax[0]) mm[0] = _right.minmax[0];
113   //if(mms[1] < _right.minmax[1]) mms[1] = _ri << 114   //if(mm[1] < _right.minmax[1]) mm[1] = _right.minmax[1];
114                                                   115 
115   int num = kSize[0]*kSize[1];                    116   int num = kSize[0]*kSize[1];
116   for(int z = 0; z < kSize[2]; z++) {             117   for(int z = 0; z < kSize[2]; z++) {
117     T * img = new T[num];                         118     T * img = new T[num];
118     for(int xy = 0; xy < num; xy++) {             119     for(int xy = 0; xy < num; xy++) {
119       img[xy] = kImage[z][xy] + _right.kImage[    120       img[xy] = kImage[z][xy] + _right.kImage[z][xy];
120       if(mms[0] > img[xy]) mms[0] = img[xy];   << 121       if(mm[0] > img[xy]) mm[0] = img[xy];
121       if(mms[1] < img[xy]) mms[1] = img[xy];   << 122       if(mm[1] < img[xy]) mm[1] = img[xy];
122     }                                             123     }
123     rprim.addImage(img);                          124     rprim.addImage(img);
124   }                                               125   }
125   rprim.setMinMax(mms);                        << 126   rprim.setMinMax(mm);
126                                                   127 
127   T scl = mms[1]/DOSERANGE;                    << 128   T scl = mm[1]/DOSERANGE;
128   rprim.setScale(scl);                            129   rprim.setScale(scl);
129                                                   130 
130   return rprim;                                   131   return rprim;
131 }                                                 132 }
132                                                   133 
133 template <typename T> GMocrenDataPrimitive<T>     134 template <typename T> GMocrenDataPrimitive<T> & 
134 GMocrenDataPrimitive<T>::operator += (const GM    135 GMocrenDataPrimitive<T>::operator += (const GMocrenDataPrimitive<T> & _right) {
135                                                   136 
136   bool stat = true;                               137   bool stat = true;
137   for(int i = 0; i < 3; i++) {                    138   for(int i = 0; i < 3; i++) {
138     if(kSize[i] != _right.kSize[i]) stat = fal    139     if(kSize[i] != _right.kSize[i]) stat = false;
139     if(kCenter[i] != _right.kCenter[i]) stat =    140     if(kCenter[i] != _right.kCenter[i]) stat = false;
140   }                                               141   }
141   if(!stat) {                                     142   if(!stat) {
142     if (G4VisManager::GetVerbosity() >= G4VisM    143     if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
143       G4cout << "Warning: operator += " << G4e    144       G4cout << "Warning: operator += " << G4endl
144        << "         Cannot do the operator +="    145        << "         Cannot do the operator +="
145        << G4endl;                                 146        << G4endl;
146     return *this;                                 147     return *this;
147   }                                               148   }
148                                                   149 
149   if(kMinmax[0] > _right.kMinmax[0]) kMinmax[0    150   if(kMinmax[0] > _right.kMinmax[0]) kMinmax[0] = _right.kMinmax[0];
150   if(kMinmax[1] < _right.kMinmax[1]) kMinmax[1    151   if(kMinmax[1] < _right.kMinmax[1]) kMinmax[1] = _right.kMinmax[1];
151                                                   152 
152   int num = kSize[0]*kSize[1];                    153   int num = kSize[0]*kSize[1];
153   for(int z = 0; z < kSize[2]; z++) {             154   for(int z = 0; z < kSize[2]; z++) {
154     for(int xy = 0; xy < num; xy++) {             155     for(int xy = 0; xy < num; xy++) {
155       kImage[z][xy] += _right.kImage[z][xy];      156       kImage[z][xy] += _right.kImage[z][xy];
156       if(kMinmax[0] > kImage[z][xy]) kMinmax[0    157       if(kMinmax[0] > kImage[z][xy]) kMinmax[0] = kImage[z][xy];
157       if(kMinmax[1] < kImage[z][xy]) kMinmax[1    158       if(kMinmax[1] < kImage[z][xy]) kMinmax[1] = kImage[z][xy];
158     }                                             159     }
159   }                                               160   }
160                                                   161 
161   kScale = kMinmax[1]/DOSERANGE;                  162   kScale = kMinmax[1]/DOSERANGE;
162                                                   163 
163   return *this;                                   164   return *this;
164 }                                                 165 }
165                                                   166 
166 template <typename T>                             167 template <typename T> 
167 void GMocrenDataPrimitive<T>::clear() {           168 void GMocrenDataPrimitive<T>::clear() {
168   for(int i = 0; i < 3; i++) {                    169   for(int i = 0; i < 3; i++) {
169     kSize[i] = 0;                                 170     kSize[i] = 0;
170     kCenter[i] = 0.;                              171     kCenter[i] = 0.;
171   }                                               172   }
172   kScale = 1.;                                    173   kScale = 1.;
173   kMinmax[0] = (T)32109;                          174   kMinmax[0] = (T)32109;
174   kMinmax[1] = (T)-32109;                         175   kMinmax[1] = (T)-32109;
175                                                   176 
176   clearImage();                                   177   clearImage();
177 }                                                 178 }
178 template <typename T>                             179 template <typename T> 
179 void GMocrenDataPrimitive<T>::clearImage() {      180 void GMocrenDataPrimitive<T>::clearImage() {
180   typename std::vector<T *>::iterator itr;        181   typename std::vector<T *>::iterator itr;
181   for(itr = kImage.begin(); itr != kImage.end(    182   for(itr = kImage.begin(); itr != kImage.end(); itr++) {
182     delete [] *itr;                               183     delete [] *itr;
183   }                                               184   }
184   kImage.clear();                                 185   kImage.clear();
185 }                                                 186 }
186 template <typename T>                             187 template <typename T> 
187 void GMocrenDataPrimitive<T>::setSize(int _siz    188 void GMocrenDataPrimitive<T>::setSize(int _size[3]) {
188   for(int i = 0; i < 3; i++) kSize[i] = _size[    189   for(int i = 0; i < 3; i++) kSize[i] = _size[i];
189 }                                                 190 }
190 template <typename T>                             191 template <typename T> 
191 void GMocrenDataPrimitive<T>::getSize(int _siz    192 void GMocrenDataPrimitive<T>::getSize(int _size[3]) {
192   for(int i = 0; i < 3; i++) _size[i] = kSize[    193   for(int i = 0; i < 3; i++) _size[i] = kSize[i];
193 }                                                 194 }
194 template <typename T>                             195 template <typename T> 
195 void GMocrenDataPrimitive<T>::setScale(double     196 void GMocrenDataPrimitive<T>::setScale(double & _scale) {
196   kScale = _scale;                                197   kScale = _scale;
197 }                                                 198 }
198 template <typename T>                             199 template <typename T> 
199 double GMocrenDataPrimitive<T>::getScale() {      200 double GMocrenDataPrimitive<T>::getScale() {
200   return kScale;                                  201   return kScale;
201 }                                                 202 }
202 template <typename T>                             203 template <typename T> 
203 void GMocrenDataPrimitive<T>::setMinMax(T _min    204 void GMocrenDataPrimitive<T>::setMinMax(T _minmax[2]) {
204   for(int i = 0; i < 2; i++) kMinmax[i] = _min    205   for(int i = 0; i < 2; i++) kMinmax[i] = _minmax[i];
205 }                                                 206 }
206 template <typename T>                             207 template <typename T> 
207 void GMocrenDataPrimitive<T>::getMinMax(T _min    208 void GMocrenDataPrimitive<T>::getMinMax(T _minmax[2]) {
208   for(int i = 0; i < 2; i++) _minmax[i] = kMin    209   for(int i = 0; i < 2; i++) _minmax[i] = kMinmax[i];
209                                                   210 
210 }                                                 211 }
211 template <typename T>                             212 template <typename T> 
212 void GMocrenDataPrimitive<T>::setImage(std::ve    213 void GMocrenDataPrimitive<T>::setImage(std::vector<T *> & _image) {
213   kImage = _image;                                214   kImage = _image;
214 }                                                 215 }
215 template <typename T>                             216 template <typename T> 
216 void GMocrenDataPrimitive<T>::addImage(T * _im    217 void GMocrenDataPrimitive<T>::addImage(T * _image) {
217   kImage.push_back(_image);                       218   kImage.push_back(_image);
218 }                                                 219 }
219 template <typename T>                             220 template <typename T> 
220 std::vector<T *> & GMocrenDataPrimitive<T>::ge    221 std::vector<T *> & GMocrenDataPrimitive<T>::getImage() {
221   return kImage;                                  222   return kImage;
222 }                                                 223 }
223 template <typename T>                             224 template <typename T> 
224 T * GMocrenDataPrimitive<T>::getImage(int _z)     225 T * GMocrenDataPrimitive<T>::getImage(int _z) {
225   if(_z >= (int)kImage.size())  return 0;         226   if(_z >= (int)kImage.size())  return 0;
226   return kImage[_z];                              227   return kImage[_z];
227 }                                                 228 }
228 template <typename T>                             229 template <typename T> 
229 void GMocrenDataPrimitive<T>::setCenterPositio    230 void GMocrenDataPrimitive<T>::setCenterPosition(float _center[3]) {
230   for(int i = 0; i < 3; i++) kCenter[i] = _cen    231   for(int i = 0; i < 3; i++) kCenter[i] = _center[i];
231 }                                                 232 }
232 template <typename T>                             233 template <typename T> 
233 void GMocrenDataPrimitive<T>::getCenterPositio    234 void GMocrenDataPrimitive<T>::getCenterPosition(float _center[3]) {
234   for(int i = 0; i < 3; i++) _center[i] = kCen    235   for(int i = 0; i < 3; i++) _center[i] = kCenter[i];
235 }                                                 236 }
236 template <typename T>                             237 template <typename T> 
237 void GMocrenDataPrimitive<T>::setName(std::str    238 void GMocrenDataPrimitive<T>::setName(std::string & _name) {
238   kDataName = _name;                              239   kDataName = _name;
239 }                                                 240 }
240 template <typename T>                             241 template <typename T> 
241 std::string GMocrenDataPrimitive<T>::getName()    242 std::string GMocrenDataPrimitive<T>::getName() {
242   return kDataName;                               243   return kDataName;
243 }                                                 244 }
244                                                   245 
245                                                   246 
246                                                   247 
247                                                   248 
248                                                   249 
249 GMocrenTrack::GMocrenTrack() {                    250 GMocrenTrack::GMocrenTrack() {
250     kTrack.clear();                               251     kTrack.clear();
251     for(int i = 0; i < 3; i++) kColor[i] = 0;     252     for(int i = 0; i < 3; i++) kColor[i] = 0;
252 }                                                 253 }
253                                                   254 
254 void GMocrenTrack::addStep(float _startx, floa    255 void GMocrenTrack::addStep(float _startx, float _starty, float _startz,
255          float _endx, float _endy, float _endz    256          float _endx, float _endy, float _endz) {
256   struct Step step;                               257   struct Step step;
257   step.startPoint[0] = _startx;                   258   step.startPoint[0] = _startx;
258   step.startPoint[1] = _starty;                   259   step.startPoint[1] = _starty;
259   step.startPoint[2] = _startz;                   260   step.startPoint[2] = _startz;
260   step.endPoint[0] = _endx;                       261   step.endPoint[0] = _endx;
261   step.endPoint[1] = _endy;                       262   step.endPoint[1] = _endy;
262   step.endPoint[2] = _endz;                       263   step.endPoint[2] = _endz;
263   kTrack.push_back(step);                         264   kTrack.push_back(step);
264 }                                                 265 }
265 void GMocrenTrack::getStep(float & _startx, fl    266 void GMocrenTrack::getStep(float & _startx, float & _starty, float & _startz,
266          float & _endx, float & _endy, float &    267          float & _endx, float & _endy, float & _endz,
267          int _num) {                              268          int _num) {
268   if(_num >= (int)kTrack.size()) {                269   if(_num >= (int)kTrack.size()) {
269     if (G4VisManager::GetVerbosity() >= G4VisM    270     if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
270       G4cout << "GMocrenTrack::getStep(...) Er    271       G4cout << "GMocrenTrack::getStep(...) Error: "
271        << "invalid step # : " << _num << G4end    272        << "invalid step # : " << _num << G4endl;
272     return;                                       273     return;
273   }                                               274   }
274                                                   275 
275   _startx = kTrack[_num].startPoint[0];           276   _startx = kTrack[_num].startPoint[0];
276   _starty = kTrack[_num].startPoint[1];           277   _starty = kTrack[_num].startPoint[1];
277   _startz = kTrack[_num].startPoint[2];           278   _startz = kTrack[_num].startPoint[2];
278   _endx = kTrack[_num].endPoint[0];               279   _endx = kTrack[_num].endPoint[0];
279   _endy = kTrack[_num].endPoint[1];               280   _endy = kTrack[_num].endPoint[1];
280   _endz = kTrack[_num].endPoint[2];               281   _endz = kTrack[_num].endPoint[2];
281 }                                                 282 }
282 void GMocrenTrack::translate(std::vector<float    283 void GMocrenTrack::translate(std::vector<float> & _translate) {
283   std::vector<struct Step>::iterator itr = kTr    284   std::vector<struct Step>::iterator itr = kTrack.begin();
284   for(; itr != kTrack.end(); itr++) {             285   for(; itr != kTrack.end(); itr++) {
285     for(int i = 0; i < 3; i++ ) {                 286     for(int i = 0; i < 3; i++ ) {
286       itr->startPoint[i] += _translate[i];        287       itr->startPoint[i] += _translate[i];
287       itr->endPoint[i] += _translate[i];          288       itr->endPoint[i] += _translate[i];
288     }                                             289     }
289   }                                               290   } 
290 }                                                 291 }
291                                                   292 
292                                                   293 
293                                                   294 
294                                                   295 
295                                                   296 
296                                                   297 
297                                                   298 
298                                                   299 
299                                                   300 
300 GMocrenDetector::GMocrenDetector() {              301 GMocrenDetector::GMocrenDetector() {
301     kDetector.clear();                            302     kDetector.clear();
302     for(int i = 0; i < 3; i++) kColor[i] = 0;     303     for(int i = 0; i < 3; i++) kColor[i] = 0;
303 }                                                 304 }
304                                                   305 
305 void GMocrenDetector::addEdge(float _startx, f    306 void GMocrenDetector::addEdge(float _startx, float _starty, float _startz,
306             float _endx, float _endy, float _e    307             float _endx, float _endy, float _endz) {
307   struct Edge edge;                               308   struct Edge edge;
308   edge.startPoint[0] = _startx;                   309   edge.startPoint[0] = _startx;
309   edge.startPoint[1] = _starty;                   310   edge.startPoint[1] = _starty;
310   edge.startPoint[2] = _startz;                   311   edge.startPoint[2] = _startz;
311   edge.endPoint[0] = _endx;                       312   edge.endPoint[0] = _endx;
312   edge.endPoint[1] = _endy;                       313   edge.endPoint[1] = _endy;
313   edge.endPoint[2] = _endz;                       314   edge.endPoint[2] = _endz;
314   kDetector.push_back(edge);                      315   kDetector.push_back(edge);
315 }                                                 316 }
316 void GMocrenDetector::getEdge(float & _startx,    317 void GMocrenDetector::getEdge(float & _startx, float & _starty, float & _startz,
317          float & _endx, float & _endy, float &    318          float & _endx, float & _endy, float & _endz,
318          int _num) {                              319          int _num) {
319   if(_num >= (int)kDetector.size()) {             320   if(_num >= (int)kDetector.size()) {
320     if (G4VisManager::GetVerbosity() >= G4VisM    321     if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
321       G4cout << "GMocrenDetector::getEdge(...)    322       G4cout << "GMocrenDetector::getEdge(...) Error: "
322        << "invalid edge # : " << _num << G4end    323        << "invalid edge # : " << _num << G4endl;
323     return;                                       324     return;
324   }                                               325   }
325                                                   326 
326   _startx = kDetector[_num].startPoint[0];        327   _startx = kDetector[_num].startPoint[0];
327   _starty = kDetector[_num].startPoint[1];        328   _starty = kDetector[_num].startPoint[1];
328   _startz = kDetector[_num].startPoint[2];        329   _startz = kDetector[_num].startPoint[2];
329   _endx = kDetector[_num].endPoint[0];            330   _endx = kDetector[_num].endPoint[0];
330   _endy = kDetector[_num].endPoint[1];            331   _endy = kDetector[_num].endPoint[1];
331   _endz = kDetector[_num].endPoint[2];            332   _endz = kDetector[_num].endPoint[2];
332 }                                                 333 }
333 void GMocrenDetector::translate(std::vector<fl    334 void GMocrenDetector::translate(std::vector<float> & _translate) {
334   std::vector<struct Edge>::iterator itr = kDe    335   std::vector<struct Edge>::iterator itr = kDetector.begin();
335   for(; itr != kDetector.end(); itr++) {          336   for(; itr != kDetector.end(); itr++) {
336     for(int i = 0; i < 3; i++) {                  337     for(int i = 0; i < 3; i++) {
337       itr->startPoint[i] += _translate[i];        338       itr->startPoint[i] += _translate[i];
338       itr->endPoint[i] += _translate[i];          339       itr->endPoint[i] += _translate[i];
339     }                                             340     } 
340   }                                               341   }
341 }                                                 342 }
342                                                   343 
343                                                   344 
344                                                   345 
345                                                   346 
346                                                   347 
347                                                   348 
348                                                   349 
349                                                   350 
350                                                   351 
351 // file information                               352 // file information
352 std::string G4GMocrenIO::kId;                     353 std::string G4GMocrenIO::kId;
353 std::string G4GMocrenIO::kVersion = "2.0.0";      354 std::string G4GMocrenIO::kVersion = "2.0.0";
354 int G4GMocrenIO::kNumberOfEvents = 0;             355 int G4GMocrenIO::kNumberOfEvents = 0;
355 char G4GMocrenIO::kLittleEndianInput = true;      356 char G4GMocrenIO::kLittleEndianInput = true;
356                                                   357 
357 #if BYTE_ORDER == LITTLE_ENDIAN                   358 #if BYTE_ORDER == LITTLE_ENDIAN
358 char G4GMocrenIO::kLittleEndianOutput = true;     359 char G4GMocrenIO::kLittleEndianOutput = true;
359 #else                                             360 #else
360 char G4GMocrenIO::kLittleEndianOutput = false;    361 char G4GMocrenIO::kLittleEndianOutput = false; // Big endian
361 #endif                                            362 #endif
362 std::string G4GMocrenIO::kComment;                363 std::string G4GMocrenIO::kComment;
363 //                                                364 //
364 std::string G4GMocrenIO::kFileName = "dose.gdd    365 std::string G4GMocrenIO::kFileName = "dose.gdd";
365                                                   366 
366 //                                                367 //
367 unsigned int G4GMocrenIO::kPointerToModalityDa    368 unsigned int G4GMocrenIO::kPointerToModalityData = 0;
368 std::vector<unsigned int> G4GMocrenIO::kPointe    369 std::vector<unsigned int> G4GMocrenIO::kPointerToDoseDistData;
369 unsigned int G4GMocrenIO::kPointerToROIData =     370 unsigned int G4GMocrenIO::kPointerToROIData = 0;
370 unsigned int G4GMocrenIO::kPointerToTrackData     371 unsigned int G4GMocrenIO::kPointerToTrackData = 0;
371 unsigned int G4GMocrenIO::kPointerToDetectorDa    372 unsigned int G4GMocrenIO::kPointerToDetectorData = 0;
372                                                   373 
373 // modality                                       374 // modality
374 float G4GMocrenIO::kVoxelSpacing[3] = {0., 0.,    375 float G4GMocrenIO::kVoxelSpacing[3] = {0., 0., 0.};
375 class GMocrenDataPrimitive<short>  G4GMocrenIO    376 class GMocrenDataPrimitive<short>  G4GMocrenIO::kModality;
376 std::vector<float> G4GMocrenIO::kModalityImage    377 std::vector<float> G4GMocrenIO::kModalityImageDensityMap;
377 std::string G4GMocrenIO::kModalityUnit = "g/cm    378 std::string G4GMocrenIO::kModalityUnit = "g/cm3       "; // 12 Bytes
378                                                   379 
379 // dose                                           380 // dose
380 std::vector<class GMocrenDataPrimitive<double>    381 std::vector<class GMocrenDataPrimitive<double> > G4GMocrenIO::kDose;
381 std::string G4GMocrenIO::kDoseUnit = "keV         382 std::string G4GMocrenIO::kDoseUnit = "keV         "; // 12 Bytes
382                                                   383 
383 // ROI                                            384 // ROI
384 std::vector<class GMocrenDataPrimitive<short>     385 std::vector<class GMocrenDataPrimitive<short> > G4GMocrenIO::kRoi;
385                                                   386 
386 // track                                          387 // track
387 std::vector<float *> G4GMocrenIO::kSteps;         388 std::vector<float *> G4GMocrenIO::kSteps;
388 std::vector<unsigned char *> G4GMocrenIO::kSte    389 std::vector<unsigned char *> G4GMocrenIO::kStepColors;
389 std::vector<class GMocrenTrack> G4GMocrenIO::k    390 std::vector<class GMocrenTrack> G4GMocrenIO::kTracks;
390                                                   391 
391 // detector                                       392 // detector
392 std::vector<class GMocrenDetector> G4GMocrenIO    393 std::vector<class GMocrenDetector> G4GMocrenIO::kDetectors;
393                                                   394 
394 // verbose                                        395 // verbose
395 int G4GMocrenIO::kVerbose = 0;                    396 int G4GMocrenIO::kVerbose = 0;
396                                                   397 
397 const int IDLENGTH  = 21;                         398 const int IDLENGTH  = 21;
398 const int VERLENGTH = 6;                          399 const int VERLENGTH = 6;
399                                                   400 
400 // constructor                                    401 // constructor
401 G4GMocrenIO::G4GMocrenIO()                        402 G4GMocrenIO::G4GMocrenIO()
402   : kTracksWillBeStored(true) {                   403   : kTracksWillBeStored(true) {
403   ;                                               404   ;
404 }                                                 405 }
405                                                   406 
406 // destructor                                     407 // destructor
407 G4GMocrenIO::~G4GMocrenIO() {                     408 G4GMocrenIO::~G4GMocrenIO() {
408   ;                                               409   ;
409 }                                                 410 }
410                                                   411 
411 // initialize                                     412 // initialize
412 void G4GMocrenIO::initialize() {                  413 void G4GMocrenIO::initialize() {
413                                                   414 
414   kId.clear();                                    415   kId.clear();
415   kVersion = "2.0.0";                             416   kVersion = "2.0.0";
416   kNumberOfEvents = 0;                            417   kNumberOfEvents = 0;
417   kLittleEndianInput = true;                      418   kLittleEndianInput = true;
418 #if BYTE_ORDER == LITTLE_ENDIAN                   419 #if BYTE_ORDER == LITTLE_ENDIAN
419   kLittleEndianOutput = true;                     420   kLittleEndianOutput = true;
420 #else // Big endian                               421 #else // Big endian
421   kLittleEndianOutput = false;                    422   kLittleEndianOutput = false;
422 #endif                                            423 #endif
423   kComment.clear();                               424   kComment.clear();
424   kFileName = "dose.gdd";                         425   kFileName = "dose.gdd";
425   kPointerToModalityData = 0;                     426   kPointerToModalityData = 0;
426   kPointerToDoseDistData.clear();                 427   kPointerToDoseDistData.clear();
427   kPointerToROIData = 0;                          428   kPointerToROIData = 0;
428   kPointerToTrackData = 0;                        429   kPointerToTrackData = 0;
429   // modality                                     430   // modality
430   for(int i = 0; i < 3; i++) kVoxelSpacing[i]     431   for(int i = 0; i < 3; i++) kVoxelSpacing[i] = 0.;
431   kModality.clear();                              432   kModality.clear();
432   kModalityImageDensityMap.clear();               433   kModalityImageDensityMap.clear();
433   kModalityUnit = "g/cm3       "; // 12 Bytes     434   kModalityUnit = "g/cm3       "; // 12 Bytes
434   // dose                                         435   // dose
435   kDose.clear();                                  436   kDose.clear();
436   kDoseUnit = "keV         "; // 12 Bytes         437   kDoseUnit = "keV         "; // 12 Bytes
437   // ROI                                          438   // ROI
438   kRoi.clear();                                   439   kRoi.clear();
439   // track                                        440   // track
440   std::vector<float *>::iterator itr;             441   std::vector<float *>::iterator itr;
441   for(itr = kSteps.begin(); itr != kSteps.end(    442   for(itr = kSteps.begin(); itr != kSteps.end(); itr++) delete [] *itr;
442   kSteps.clear();                                 443   kSteps.clear();
443   std::vector<unsigned char *>::iterator citr;    444   std::vector<unsigned char *>::iterator citr;
444   for(citr = kStepColors.begin(); citr != kSte    445   for(citr = kStepColors.begin(); citr != kStepColors.end(); citr++)
445     delete [] *citr;                              446     delete [] *citr;
446   kStepColors.clear();                            447   kStepColors.clear();
447   kTracksWillBeStored = true;                     448   kTracksWillBeStored = true;
448                                                   449 
449   // verbose                                      450   // verbose
450   kVerbose = 0;                                   451   kVerbose = 0;
451 }                                                 452 }
452                                                   453 
453 bool G4GMocrenIO::storeData() {                   454 bool G4GMocrenIO::storeData() {
454   return storeData4();                            455   return storeData4();
455 }                                                 456 }
456 //                                                457 //
457 bool G4GMocrenIO::storeData(char * _filename)     458 bool G4GMocrenIO::storeData(char * _filename) {
458   return storeData4(_filename);                   459   return storeData4(_filename);
459 }                                                 460 }
460                                                   461 
461 bool G4GMocrenIO::storeData4() {                  462 bool G4GMocrenIO::storeData4() {
462                                                   463 
463   bool DEBUG = false;//                           464   bool DEBUG = false;//
464                                                   465 
465   if(DEBUG || kVerbose > 0)                       466   if(DEBUG || kVerbose > 0)
466     G4cout << ">>>>>>>  store data (ver.4) <<<    467     G4cout << ">>>>>>>  store data (ver.4) <<<<<<<" << G4endl;
467   if(DEBUG || kVerbose > 0)                       468   if(DEBUG || kVerbose > 0)
468     G4cout << "         " << kFileName << G4en    469     G4cout << "         " << kFileName << G4endl;
469                                                   470 
470   // output file open                             471   // output file open
471   std::ofstream ofile(kFileName.c_str(),          472   std::ofstream ofile(kFileName.c_str(),
472           std::ios_base::out|std::ios_base::bi    473           std::ios_base::out|std::ios_base::binary);
473   if(DEBUG || kVerbose > 0)                       474   if(DEBUG || kVerbose > 0)
474     G4cout << "         file open status: " << << 475     G4cout << "         file open status: " << ofile << G4endl;
475                                                   476   
476   // file identifier                              477   // file identifier
477   ofile.write("gMocren ", 8);                     478   ofile.write("gMocren ", 8);
478                                                   479 
479   // file version                                 480   // file version
480   unsigned char ver = 0x04;                       481   unsigned char ver = 0x04;
481   ofile.write((char *)&ver, 1);                   482   ofile.write((char *)&ver, 1);
482                                                   483 
483   // endian                                       484   // endian
484   //ofile.write((char *)&kLittleEndianOutput,     485   //ofile.write((char *)&kLittleEndianOutput, sizeof(char));
485   char littleEndian = 0x01;                       486   char littleEndian = 0x01;
486   ofile.write((char *)&littleEndian, sizeof(ch    487   ofile.write((char *)&littleEndian, sizeof(char));
487   if(DEBUG || kVerbose > 0) {                     488   if(DEBUG || kVerbose > 0) {
488     //G4cout << "Endian: " << (int)kLittleEndi    489     //G4cout << "Endian: " << (int)kLittleEndianOutput << G4endl;
489     G4cout << "Endian: " << (int)littleEndian     490     G4cout << "Endian: " << (int)littleEndian << G4endl;
490   }                                               491   }
491                                                   492 
492   // for inverting the byte order                 493   // for inverting the byte order
493   float ftmp[6];                                  494   float ftmp[6];
494   int itmp[6];                                    495   int itmp[6];
495   short stmp[6];                                  496   short stmp[6];
496                                                   497 
497   // comment length (fixed size)                  498   // comment length (fixed size)
498   int commentLength = 1024;                       499   int commentLength = 1024;
499   if(kLittleEndianOutput) {                       500   if(kLittleEndianOutput) {
500     ofile.write((char *)&commentLength, 4);       501     ofile.write((char *)&commentLength, 4);
501   } else {                                        502   } else {
502     invertByteOrder((char *)&commentLength, it    503     invertByteOrder((char *)&commentLength, itmp[0]);
503     ofile.write((char *)itmp, 4);                 504     ofile.write((char *)itmp, 4);
504   }                                               505   }
505                                                   506 
506   // comment                                      507   // comment 
507   char cmt[1025];                                 508   char cmt[1025];
508   std::strncpy(cmt, kComment.c_str(), 1024);   << 509   for(int i = 0; i < 1025; i++) cmt[i] = '\0';
509   cmt[1024] = '\0';                            << 510   //std::strncpy(cmt, kComment.c_str(), 1024);
510   ofile.write(cmt, 1024);                      << 511   const char * cm = kComment.c_str();
                                                   >> 512   size_t lcm = std::strlen(cm);
                                                   >> 513   if(lcm > 1024) lcm = 1024;
                                                   >> 514   std::strncpy(cmt, cm, lcm);
                                                   >> 515   ofile.write((char *)cmt, 1024);
511   if(DEBUG || kVerbose > 0) {                     516   if(DEBUG || kVerbose > 0) {
512     G4cout << "Data comment : "                   517     G4cout << "Data comment : "
513         << kComment << G4endl;                    518         << kComment << G4endl;
514   }                                               519   }
515                                                   520 
516   // voxel spacings for all images                521   // voxel spacings for all images
517   if(kLittleEndianOutput) {                       522   if(kLittleEndianOutput) {
518     ofile.write((char *)kVoxelSpacing, 12);       523     ofile.write((char *)kVoxelSpacing, 12);
519   } else {                                        524   } else {
520     for(int j = 0; j < 3; j++)                    525     for(int j = 0; j < 3; j++)
521       invertByteOrder((char *)&kVoxelSpacing[j    526       invertByteOrder((char *)&kVoxelSpacing[j], ftmp[j]);
522     ofile.write((char *)ftmp, 12);                527     ofile.write((char *)ftmp, 12);
523   }                                               528   }
524   if(DEBUG || kVerbose > 0) {                     529   if(DEBUG || kVerbose > 0) {
525     G4cout << "Voxel spacing : ("                 530     G4cout << "Voxel spacing : ("
526         << kVoxelSpacing[0] << ", "               531         << kVoxelSpacing[0] << ", "
527         << kVoxelSpacing[1] << ", "               532         << kVoxelSpacing[1] << ", "
528         << kVoxelSpacing[2]                       533         << kVoxelSpacing[2]
529         << ") mm " << G4endl;                     534         << ") mm " << G4endl;
530   }                                               535   }
531                                                   536 
532   calcPointers4();                                537   calcPointers4();
533   if(!kTracksWillBeStored) kPointerToTrackData    538   if(!kTracksWillBeStored) kPointerToTrackData = 0;
534                                                   539 
535   // offset from file starting point to the mo    540   // offset from file starting point to the modality image data
536   if(kLittleEndianOutput) {                       541   if(kLittleEndianOutput) {
537     ofile.write((char *)&kPointerToModalityDat    542     ofile.write((char *)&kPointerToModalityData, 4);
538   } else {                                        543   } else {
539     invertByteOrder((char *)&kPointerToModalit    544     invertByteOrder((char *)&kPointerToModalityData, itmp[0]);
540     ofile.write((char *)itmp, 4);                 545     ofile.write((char *)itmp, 4);
541   }                                               546   }
542                                                   547 
543   // # of dose distributions                      548   // # of dose distributions
544   //int nDoseDist = (int)pointerToDoseDistData    549   //int nDoseDist = (int)pointerToDoseDistData.size();
545   int nDoseDist = getNumDoseDist();               550   int nDoseDist = getNumDoseDist();
546   if(kLittleEndianOutput) {                       551   if(kLittleEndianOutput) {
547     ofile.write((char *)&nDoseDist, 4);           552     ofile.write((char *)&nDoseDist, 4);
548   } else {                                        553   } else {
549     invertByteOrder((char *)&nDoseDist, itmp[0    554     invertByteOrder((char *)&nDoseDist, itmp[0]);
550     ofile.write((char *)itmp, 4);                 555     ofile.write((char *)itmp, 4);
551   }                                               556   }
552                                                   557 
553   // offset from file starting point to the do    558   // offset from file starting point to the dose image data
554   if(kLittleEndianOutput) {                       559   if(kLittleEndianOutput) {
555     for(int i = 0; i < nDoseDist; i++) {          560     for(int i = 0; i < nDoseDist; i++) {
556       ofile.write((char *)&kPointerToDoseDistD    561       ofile.write((char *)&kPointerToDoseDistData[i], 4);
557     }                                             562     }
558   } else {                                        563   } else {
559     for(int i = 0; i < nDoseDist; i++) {          564     for(int i = 0; i < nDoseDist; i++) {
560       invertByteOrder((char *)&kPointerToDoseD    565       invertByteOrder((char *)&kPointerToDoseDistData[i], itmp[0]);
561       ofile.write((char *)itmp, 4);               566       ofile.write((char *)itmp, 4);
562     }                                             567     }
563   }                                               568   }
564                                                   569 
565   // offset from file starting point to the RO    570   // offset from file starting point to the ROI image data
566   if(kLittleEndianOutput) {                       571   if(kLittleEndianOutput) {
567     ofile.write((char *)&kPointerToROIData, 4)    572     ofile.write((char *)&kPointerToROIData, 4);
568   } else {                                        573   } else {
569     invertByteOrder((char *)&kPointerToROIData    574     invertByteOrder((char *)&kPointerToROIData, itmp[0]);
570     ofile.write((char *)itmp, 4);                 575     ofile.write((char *)itmp, 4);
571   }                                               576   }
572                                                   577 
573   // offset from file starting point to the tr    578   // offset from file starting point to the track data
574   if(kLittleEndianOutput) {                       579   if(kLittleEndianOutput) {
575     ofile.write((char *)&kPointerToTrackData,     580     ofile.write((char *)&kPointerToTrackData, 4);
576   } else {                                        581   } else {
577     invertByteOrder((char *)&kPointerToTrackDa    582     invertByteOrder((char *)&kPointerToTrackData, itmp[0]);
578     ofile.write((char *)itmp, 4);                 583     ofile.write((char *)itmp, 4);
579   }                                               584   }
580                                                   585 
581   // offset from file starting point to the de    586   // offset from file starting point to the detector data
582   if(kLittleEndianOutput) {                       587   if(kLittleEndianOutput) {
583     ofile.write((char *)&kPointerToDetectorDat    588     ofile.write((char *)&kPointerToDetectorData, 4);
584   } else {                                        589   } else {
585     invertByteOrder((char *)&kPointerToDetecto    590     invertByteOrder((char *)&kPointerToDetectorData, itmp[0]);
586     ofile.write((char *)itmp, 4);                 591     ofile.write((char *)itmp, 4);
587   }                                               592   }
588                                                   593 
589   if(DEBUG || kVerbose > 0) {                     594   if(DEBUG || kVerbose > 0) {
590     G4cout << "Each pointer to data : "           595     G4cout << "Each pointer to data : "
591         << kPointerToModalityData << ", ";        596         << kPointerToModalityData << ", ";
592     for(int i = 0; i < nDoseDist; i++) {          597     for(int i = 0; i < nDoseDist; i++) {
593       G4cout << kPointerToDoseDistData[i] << "    598       G4cout << kPointerToDoseDistData[i] << ", ";
594     }                                             599     }
595     G4cout << kPointerToROIData << ", "           600     G4cout << kPointerToROIData << ", "
596         << kPointerToTrackData << ", "            601         << kPointerToTrackData << ", "
597         << kPointerToDetectorData                 602         << kPointerToDetectorData
598         << G4endl;                                603         << G4endl;
599   }                                               604   }
600                                                   605 
601   //----- modality image -----//                  606   //----- modality image -----//
602                                                   607 
603   int size[3];                                    608   int size[3];
604   float scale;                                    609   float scale;
605   short minmax[2];                                610   short minmax[2];
606   float fCenter[3];                               611   float fCenter[3];
607   int iCenter[3];                                 612   int iCenter[3];
608   // modality image size                          613   // modality image size
609   kModality.getSize(size);                        614   kModality.getSize(size);
610                                                   615 
611   if(kLittleEndianOutput) {                       616   if(kLittleEndianOutput) {
612     ofile.write((char *)size, 3*sizeof(int));     617     ofile.write((char *)size, 3*sizeof(int));
613   } else {                                        618   } else {
614     for(int j = 0; j < 3; j++)                    619     for(int j = 0; j < 3; j++)
615       invertByteOrder((char *)&size[j], itmp[j    620       invertByteOrder((char *)&size[j], itmp[j]);
616     ofile.write((char *)itmp, 12);                621     ofile.write((char *)itmp, 12);
617   }                                               622   }
618                                                   623 
619   if(DEBUG || kVerbose > 0) {                     624   if(DEBUG || kVerbose > 0) {
620     G4cout << "Modality image size : ("           625     G4cout << "Modality image size : ("
621         << size[0] << ", "                        626         << size[0] << ", "
622         << size[1] << ", "                        627         << size[1] << ", "
623         << size[2] << ")"                         628         << size[2] << ")"
624         << G4endl;                                629         << G4endl;
625   }                                               630   }
626                                                   631 
627   // modality image max. & min.                   632   // modality image max. & min.
628   kModality.getMinMax(minmax);                    633   kModality.getMinMax(minmax);
629   if(kLittleEndianOutput) {                       634   if(kLittleEndianOutput) {
630     ofile.write((char *)minmax, 4);               635     ofile.write((char *)minmax, 4);
631   } else {                                        636   } else {
632     for(int j = 0; j < 2; j++)                    637     for(int j = 0; j < 2; j++)
633       invertByteOrder((char *)&minmax[j], stmp    638       invertByteOrder((char *)&minmax[j], stmp[j]);
634     ofile.write((char *)stmp, 4);                 639     ofile.write((char *)stmp, 4);
635   }                                               640   }
636                                                   641 
637   // modality image unit                          642   // modality image unit
638   char munit[13] = "g/cm3\0";                     643   char munit[13] = "g/cm3\0";
639   ofile.write((char *)munit, 12);                 644   ofile.write((char *)munit, 12);
640                                                   645 
641   // modality image scale                         646   // modality image scale
642   scale = (float)kModality.getScale();            647   scale = (float)kModality.getScale();
643   if(kLittleEndianOutput) {                       648   if(kLittleEndianOutput) {
644     ofile.write((char *)&scale, 4);               649     ofile.write((char *)&scale, 4);
645   } else {                                        650   } else {
646     invertByteOrder((char *)&scale, ftmp[0]);     651     invertByteOrder((char *)&scale, ftmp[0]);
647     ofile.write((char *)ftmp, 4);                 652     ofile.write((char *)ftmp, 4);
648   }                                               653   }
649   if(DEBUG || kVerbose > 0) {                     654   if(DEBUG || kVerbose > 0) {
650     G4cout << "Modality image min., max., scal    655     G4cout << "Modality image min., max., scale : "
651         << minmax[0] << ", "                      656         << minmax[0] << ", "
652         << minmax[1] << ", "                      657         << minmax[1] << ", "
653         << scale << G4endl;                       658         << scale << G4endl;
654   }                                               659   }
655                                                   660 
656   // modality image                               661   // modality image
657   int psize = size[0]*size[1];                    662   int psize = size[0]*size[1];
658   if(DEBUG || kVerbose > 0) G4cout << "Modalit    663   if(DEBUG || kVerbose > 0) G4cout << "Modality image : ";
659   for(int i = 0; i < size[2]; i++) {              664   for(int i = 0; i < size[2]; i++) {
660     short * image = kModality.getImage(i);        665     short * image = kModality.getImage(i);
661     if(kLittleEndianOutput) {                     666     if(kLittleEndianOutput) {
662       ofile.write((char *)image, psize*sizeof(    667       ofile.write((char *)image, psize*sizeof(short));
663     } else {                                      668     } else {
664       for(int j = 0; j < psize; j++) {            669       for(int j = 0; j < psize; j++) {
665   invertByteOrder((char *)&image[j], stmp[0]);    670   invertByteOrder((char *)&image[j], stmp[0]);
666   ofile.write((char *)stmp, 2);                   671   ofile.write((char *)stmp, 2);
667       }                                           672       }
668     }                                             673     }
669                                                   674 
670     if(DEBUG || kVerbose > 0) G4cout << "[" <<    675     if(DEBUG || kVerbose > 0) G4cout << "[" << i << "]" << image[(size_t)(psize*0.55)] << ", ";
671   }                                               676   }
672   if(DEBUG || kVerbose > 0) G4cout << G4endl;     677   if(DEBUG || kVerbose > 0) G4cout << G4endl;
673                                                   678 
674   // modality desity map for CT value             679   // modality desity map for CT value
675   size_t msize = minmax[1] - minmax[0]+1;         680   size_t msize = minmax[1] - minmax[0]+1;
676   if(DEBUG || kVerbose > 0)                       681   if(DEBUG || kVerbose > 0) 
677     G4cout << "modality image : " << minmax[0]    682     G4cout << "modality image : " << minmax[0] << ", " << minmax[1] << G4endl;
678   float * pdmap = new float[msize];               683   float * pdmap = new float[msize];
679   for(int i = 0; i < (int)msize; i++) pdmap[i]    684   for(int i = 0; i < (int)msize; i++) pdmap[i] =kModalityImageDensityMap[i]; 
680                                                   685 
681   if(kLittleEndianOutput) {                       686   if(kLittleEndianOutput) {
682     ofile.write((char *)pdmap, msize*sizeof(fl    687     ofile.write((char *)pdmap, msize*sizeof(float));
683   } else {                                        688   } else {
684     for(int j = 0; j < (int)msize; j++) {         689     for(int j = 0; j < (int)msize; j++) {
685       invertByteOrder((char *)&pdmap[j], ftmp[    690       invertByteOrder((char *)&pdmap[j], ftmp[0]);
686       ofile.write((char *)ftmp, 4);               691       ofile.write((char *)ftmp, 4);
687     }                                             692     }
688   }                                               693   }
689                                                   694 
690   if(DEBUG || kVerbose > 0) {                     695   if(DEBUG || kVerbose > 0) {
691     G4cout << "density map : " << std::ends;      696     G4cout << "density map : " << std::ends;
692     for(int i = 0; i < (int)msize; i+=50)         697     for(int i = 0; i < (int)msize; i+=50)
693       G4cout <<kModalityImageDensityMap[i] <<     698       G4cout <<kModalityImageDensityMap[i] << ", ";
694     G4cout << G4endl;                             699     G4cout << G4endl;
695   }                                               700   }
696   delete [] pdmap;                                701   delete [] pdmap;
697                                                   702 
698                                                   703 
699   //----- dose distribution image -----//         704   //----- dose distribution image -----//
700                                                   705 
701   if(!isDoseEmpty()) {                            706   if(!isDoseEmpty()) {
702                                                   707 
703     calcDoseDistScale();                          708     calcDoseDistScale();
704                                                   709 
705     for(int ndose = 0; ndose < nDoseDist; ndos    710     for(int ndose = 0; ndose < nDoseDist; ndose++) {
706       // dose distrbution image size              711       // dose distrbution image size
707       kDose[ndose].getSize(size);                 712       kDose[ndose].getSize(size);
708       if(kLittleEndianOutput) {                   713       if(kLittleEndianOutput) {
709   ofile.write((char *)size, 3*sizeof(int));       714   ofile.write((char *)size, 3*sizeof(int));
710       } else {                                    715       } else {
711   for(int j = 0; j < 3; j++)                      716   for(int j = 0; j < 3; j++)
712     invertByteOrder((char *)&size[j], itmp[j])    717     invertByteOrder((char *)&size[j], itmp[j]);
713   ofile.write((char *)itmp, 12);                  718   ofile.write((char *)itmp, 12);
714       }                                           719       }
715       if(DEBUG || kVerbose > 0) {                 720       if(DEBUG || kVerbose > 0) {
716   G4cout << "Dose dist. [" << ndose << "] imag    721   G4cout << "Dose dist. [" << ndose << "] image size : ("
717       << size[0] << ", "                          722       << size[0] << ", "
718       << size[1] << ", "                          723       << size[1] << ", "
719       << size[2] << ")"                           724       << size[2] << ")"
720       << G4endl;                                  725       << G4endl;
721       }                                           726       }
722                                                   727 
723       // dose distribution max. & min.            728       // dose distribution max. & min.
724       getShortDoseDistMinMax(minmax, ndose);      729       getShortDoseDistMinMax(minmax, ndose);
725       if(kLittleEndianOutput) {                   730       if(kLittleEndianOutput) {
726   ofile.write((char *)minmax, 2*2); // sizeof(    731   ofile.write((char *)minmax, 2*2); // sizeof(shorft)*2
727       } else {                                    732       } else {
728   for(int j = 0; j < 2; j++)                      733   for(int j = 0; j < 2; j++)
729     invertByteOrder((char *)&minmax[j], stmp[j    734     invertByteOrder((char *)&minmax[j], stmp[j]);
730   ofile.write((char *)stmp, 4);                   735   ofile.write((char *)stmp, 4);
731       }                                           736       }
732                                                   737 
733       // dose distribution unit                   738       // dose distribution unit
734       char cdunit[13];                            739       char cdunit[13];
735       std::strncpy(cdunit, kDoseUnit.c_str(),  << 740       for(int i = 0; i < 13; i++) cdunit[i] = '\0';
736       cdunit[12] = '\0';                       << 741       const char * cu = kDoseUnit.c_str();
737       ofile.write(cdunit, 12);                 << 742       size_t lcu = std::strlen(cu);
                                                   >> 743       if(lcu > 1024) lcu = 1024;
                                                   >> 744       std::strncpy(cdunit, cu, lcu);
                                                   >> 745       ofile.write((char *)cdunit, 12);
738       if(DEBUG || kVerbose > 0) {                 746       if(DEBUG || kVerbose > 0) {
739   G4cout << "Dose dist. unit : " << kDoseUnit     747   G4cout << "Dose dist. unit : " << kDoseUnit << G4endl;
740       }                                           748       }
741                                                   749 
742       // dose distribution scaling                750       // dose distribution scaling 
743       double dscale;                              751       double dscale;
744       dscale = getDoseDistScale(ndose);           752       dscale = getDoseDistScale(ndose);
745       scale = float(dscale);                      753       scale = float(dscale);
746       if(kLittleEndianOutput) {                   754       if(kLittleEndianOutput) {
747   ofile.write((char *)&scale, 4);                 755   ofile.write((char *)&scale, 4);
748       } else {                                    756       } else {
749   invertByteOrder((char *)&scale, ftmp[0]);       757   invertByteOrder((char *)&scale, ftmp[0]);
750   ofile.write((char *)ftmp, 4);                   758   ofile.write((char *)ftmp, 4);
751       }                                           759       }
752       if(DEBUG || kVerbose > 0) {                 760       if(DEBUG || kVerbose > 0) {
753   G4cout << "Dose dist. [" << ndose               761   G4cout << "Dose dist. [" << ndose
754       << "] image min., max., scale : "           762       << "] image min., max., scale : "
755       << minmax[0] << ", "                        763       << minmax[0] << ", "
756       << minmax[1] << ", "                        764       << minmax[1] << ", "
757       << scale << G4endl;                         765       << scale << G4endl;
758       }                                           766       }
759                                                   767 
760       // dose distribution image                  768       // dose distribution image
761       int dsize = size[0]*size[1];                769       int dsize = size[0]*size[1];
762       short * dimage = new short[dsize];          770       short * dimage = new short[dsize];
763       for(int z = 0; z < size[2]; z++) {          771       for(int z = 0; z < size[2]; z++) {
764   getShortDoseDist(dimage, z, ndose);             772   getShortDoseDist(dimage, z, ndose);
765   if(kLittleEndianOutput) {                       773   if(kLittleEndianOutput) {
766     ofile.write((char *)dimage, dsize*2); //si    774     ofile.write((char *)dimage, dsize*2); //sizeof(short)
767   } else {                                        775   } else {
768     for(int j = 0; j < dsize; j++) {              776     for(int j = 0; j < dsize; j++) {
769       invertByteOrder((char *)&dimage[j], stmp    777       invertByteOrder((char *)&dimage[j], stmp[0]);
770       ofile.write((char *)stmp, 2);               778       ofile.write((char *)stmp, 2);
771     }                                             779     }
772   }                                               780   }
773                                                   781 
774   if(DEBUG || kVerbose > 0) {                     782   if(DEBUG || kVerbose > 0) {
775     for(int j = 0; j < dsize; j++) {              783     for(int j = 0; j < dsize; j++) {
776       if(dimage[j] < 0)                           784       if(dimage[j] < 0)
777         G4cout << "[" << j << "," << z << "]"     785         G4cout << "[" << j << "," << z << "]"
778       << dimage[j] << ", ";                       786       << dimage[j] << ", ";
779     }                                             787     }
780   }                                               788   }
781       }                                           789       }
782       if(DEBUG || kVerbose > 0) G4cout << G4en    790       if(DEBUG || kVerbose > 0) G4cout << G4endl;
783       delete [] dimage;                           791       delete [] dimage;
784                                                   792 
785       // relative location of the dose distrib    793       // relative location of the dose distribution image for 
786       // the modality image                       794       // the modality image
787       getDoseDistCenterPosition(fCenter, ndose    795       getDoseDistCenterPosition(fCenter, ndose);
788       for(int i = 0; i < 3; i++) iCenter[i] =     796       for(int i = 0; i < 3; i++) iCenter[i] = (int)fCenter[i];
789       if(kLittleEndianOutput) {                   797       if(kLittleEndianOutput) {
790   ofile.write((char *)iCenter, 3*4); // 3*size    798   ofile.write((char *)iCenter, 3*4); // 3*sizeof(int)
791       } else {                                    799       } else {
792   for(int j = 0; j < 3; j++)                      800   for(int j = 0; j < 3; j++)
793     invertByteOrder((char *)&iCenter[j], itmp[    801     invertByteOrder((char *)&iCenter[j], itmp[j]);
794   ofile.write((char *)itmp, 12);                  802   ofile.write((char *)itmp, 12);
795       }                                           803       }
796       if(DEBUG || kVerbose > 0) {                 804       if(DEBUG || kVerbose > 0) {
797   G4cout << "Dose dist. [" << ndose               805   G4cout << "Dose dist. [" << ndose
798       << "]image relative location : ("           806       << "]image relative location : ("
799       << iCenter[0] << ", "                       807       << iCenter[0] << ", "
800       << iCenter[1] << ", "                       808       << iCenter[1] << ", "
801       << iCenter[2] << ")" << G4endl;             809       << iCenter[2] << ")" << G4endl;
802       }                                           810       }
803                                                   811 
804       // dose distribution name                   812       // dose distribution name
805       std::string name = getDoseDistName(ndose    813       std::string name = getDoseDistName(ndose);
806       if(name.size() == 0) name = "dose";         814       if(name.size() == 0) name = "dose";
807       name.resize(80);                            815       name.resize(80);
808       ofile.write((char *)name.c_str(), 80);      816       ofile.write((char *)name.c_str(), 80);
809       if(DEBUG || kVerbose > 0) {                 817       if(DEBUG || kVerbose > 0) {
810   G4cout << "Dose dist. name : " << name << G4    818   G4cout << "Dose dist. name : " << name << G4endl;
811       }                                           819       }
812                                                   820 
813     }                                             821     }
814   }                                               822   }
815                                                   823 
816   //----- ROI image -----//                       824   //----- ROI image -----//
817   if(!isROIEmpty()) {                             825   if(!isROIEmpty()) {
818     // ROI image size                             826     // ROI image size
819     kRoi[0].getSize(size);                        827     kRoi[0].getSize(size);
820     if(kLittleEndianOutput) {                     828     if(kLittleEndianOutput) {
821       ofile.write((char *)size, 3*sizeof(int))    829       ofile.write((char *)size, 3*sizeof(int));
822     } else {                                      830     } else {
823       for(int j = 0; j < 3; j++)                  831       for(int j = 0; j < 3; j++)
824   invertByteOrder((char *)&size[j], itmp[j]);     832   invertByteOrder((char *)&size[j], itmp[j]);
825       ofile.write((char *)itmp, 12);              833       ofile.write((char *)itmp, 12);
826     }                                             834     }
827     if(DEBUG || kVerbose > 0) {                   835     if(DEBUG || kVerbose > 0) {
828       G4cout << "ROI image size : ("              836       G4cout << "ROI image size : ("
829     << size[0] << ", "                            837     << size[0] << ", "
830     << size[1] << ", "                            838     << size[1] << ", "
831     << size[2] << ")"                             839     << size[2] << ")"
832     << G4endl;                                    840     << G4endl;
833     }                                             841     }
834                                                   842 
835     // ROI max. & min.                            843     // ROI max. & min.
836     kRoi[0].getMinMax(minmax);                    844     kRoi[0].getMinMax(minmax);
837     if(kLittleEndianOutput) {                     845     if(kLittleEndianOutput) {
838       ofile.write((char *)minmax, sizeof(short    846       ofile.write((char *)minmax, sizeof(short)*2);
839     } else {                                      847     } else {
840       for(int j = 0; j < 2; j++)                  848       for(int j = 0; j < 2; j++)
841   invertByteOrder((char *)&minmax[j], stmp[j])    849   invertByteOrder((char *)&minmax[j], stmp[j]);
842       ofile.write((char *)stmp, 4);               850       ofile.write((char *)stmp, 4);
843     }                                             851     }
844                                                   852 
845     // ROI distribution scaling                   853     // ROI distribution scaling 
846     scale = (float)kRoi[0].getScale();            854     scale = (float)kRoi[0].getScale();
847     if(kLittleEndianOutput) {                     855     if(kLittleEndianOutput) {
848       ofile.write((char *)&scale, sizeof(float    856       ofile.write((char *)&scale, sizeof(float));
849     } else {                                      857     } else {
850       invertByteOrder((char *)&scale, ftmp[0])    858       invertByteOrder((char *)&scale, ftmp[0]);
851       ofile.write((char *)ftmp, 4);               859       ofile.write((char *)ftmp, 4);
852     }                                             860     }
853     if(DEBUG || kVerbose > 0) {                   861     if(DEBUG || kVerbose > 0) {
854       G4cout << "ROI image min., max., scale :    862       G4cout << "ROI image min., max., scale : "
855     << minmax[0] << ", "                          863     << minmax[0] << ", "
856     << minmax[1] << ", "                          864     << minmax[1] << ", "
857     << scale << G4endl;                           865     << scale << G4endl;
858     }                                             866     }
859                                                   867 
860     // ROI image                                  868     // ROI image
861     int rsize = size[0]*size[1];                  869     int rsize = size[0]*size[1];
862     for(int i = 0; i < size[2]; i++) {            870     for(int i = 0; i < size[2]; i++) {
863       short * rimage = kRoi[0].getImage(i);       871       short * rimage = kRoi[0].getImage(i);
864       if(kLittleEndianOutput) {                   872       if(kLittleEndianOutput) {
865   ofile.write((char *)rimage, rsize*sizeof(sho    873   ofile.write((char *)rimage, rsize*sizeof(short));
866       } else {                                    874       } else {
867   for(int j = 0; j < rsize; j++) {                875   for(int j = 0; j < rsize; j++) {
868     invertByteOrder((char *)&rimage[j], stmp[0    876     invertByteOrder((char *)&rimage[j], stmp[0]);
869     ofile.write((char *)stmp, 2);                 877     ofile.write((char *)stmp, 2);
870   }                                               878   }
871       }                                           879       }
872                                                   880 
873     }                                             881     }
874                                                   882 
875     // ROI relative location                      883     // ROI relative location
876     kRoi[0].getCenterPosition(fCenter);           884     kRoi[0].getCenterPosition(fCenter);
877     for(int i = 0; i < 3; i++) iCenter[i] = (i    885     for(int i = 0; i < 3; i++) iCenter[i] = (int)fCenter[i];
878     if(kLittleEndianOutput) {                     886     if(kLittleEndianOutput) {
879       ofile.write((char *)iCenter, 3*sizeof(in    887       ofile.write((char *)iCenter, 3*sizeof(int));
880     } else {                                      888     } else {
881       for(int j = 0; j < 3; j++)                  889       for(int j = 0; j < 3; j++)
882   invertByteOrder((char *)&iCenter[j], itmp[j]    890   invertByteOrder((char *)&iCenter[j], itmp[j]);
883       ofile.write((char *)itmp, 12);              891       ofile.write((char *)itmp, 12);
884     }                                             892     }
885     if(DEBUG || kVerbose > 0) {                   893     if(DEBUG || kVerbose > 0) {
886       G4cout << "ROI image relative location :    894       G4cout << "ROI image relative location : ("
887     << iCenter[0] << ", "                         895     << iCenter[0] << ", "
888     << iCenter[1] << ", "                         896     << iCenter[1] << ", "
889     << iCenter[2] << ")" << G4endl;               897     << iCenter[2] << ")" << G4endl;
890     }                                             898     }
891   }                                               899   }
892                                                   900 
893   //----- track information -----//               901   //----- track information -----//
894   // number of track                              902   // number of track 
895   if(kPointerToTrackData > 0) {                   903   if(kPointerToTrackData > 0) {
896                                                   904 
897     int ntrk = (int)kTracks.size();            << 905     int ntrk = kTracks.size();
898     if(kLittleEndianOutput) {                     906     if(kLittleEndianOutput) {
899       ofile.write((char *)&ntrk, sizeof(int));    907       ofile.write((char *)&ntrk, sizeof(int));
900     } else {                                      908     } else {
901       invertByteOrder((char *)&ntrk, itmp[0]);    909       invertByteOrder((char *)&ntrk, itmp[0]);
902       ofile.write((char *)itmp, 4);               910       ofile.write((char *)itmp, 4);
903     }                                             911     }
904     if(DEBUG || kVerbose > 0) {                   912     if(DEBUG || kVerbose > 0) {
905       G4cout << "# of tracks : "                  913       G4cout << "# of tracks : "
906     << ntrk << G4endl;                            914     << ntrk << G4endl;
907     }                                             915     }
908                                                   916 
909     for(int nt = 0; nt < ntrk; nt++) {            917     for(int nt = 0; nt < ntrk; nt++) {
910                                                   918 
911       // # of steps in a track                    919       // # of steps in a track
912       int nsteps = kTracks[nt].getNumberOfStep    920       int nsteps = kTracks[nt].getNumberOfSteps();
913       if(kLittleEndianOutput) {                   921       if(kLittleEndianOutput) {
914   ofile.write((char *)&nsteps, sizeof(int));      922   ofile.write((char *)&nsteps, sizeof(int));
915       } else {                                    923       } else {
916   invertByteOrder((char *)&nsteps, itmp[0]);      924   invertByteOrder((char *)&nsteps, itmp[0]);
917   ofile.write((char *)itmp, 4);                   925   ofile.write((char *)itmp, 4);
918       }                                           926       }
919       if(DEBUG || kVerbose > 0) {                 927       if(DEBUG || kVerbose > 0) {
920   G4cout << "# of steps : " << nsteps << G4end    928   G4cout << "# of steps : " << nsteps << G4endl;
921       }                                           929       }
922                                                   930 
923       // track color                              931       // track color
924       unsigned char tcolor[3];                    932       unsigned char tcolor[3];
925       kTracks[nt].getColor(tcolor);               933       kTracks[nt].getColor(tcolor);
926       ofile.write((char *)tcolor, 3);             934       ofile.write((char *)tcolor, 3);
927                                                   935 
928       // steps                                    936       // steps
929       float stepPoints[6];                        937       float stepPoints[6];
930       for(int isteps = 0; isteps < nsteps; ist << 938       for(int ns = 0; ns < nsteps; ns++) {
931   kTracks[nt].getStep(stepPoints[0], stepPoint    939   kTracks[nt].getStep(stepPoints[0], stepPoints[1], stepPoints[2],
932           stepPoints[3], stepPoints[4], stepPo    940           stepPoints[3], stepPoints[4], stepPoints[5],
933           isteps);                             << 941           ns);
934                                                   942 
935   if(kLittleEndianOutput) {                       943   if(kLittleEndianOutput) {
936     ofile.write((char *)stepPoints, sizeof(flo    944     ofile.write((char *)stepPoints, sizeof(float)*6);
937   } else {                                        945   } else {
938     for(int j = 0; j < 6; j++)                    946     for(int j = 0; j < 6; j++)
939       invertByteOrder((char *)&stepPoints[j],     947       invertByteOrder((char *)&stepPoints[j], ftmp[j]);
940     ofile.write((char *)ftmp, 24);                948     ofile.write((char *)ftmp, 24);
941   }                                               949   }
942       }                                           950       }
943     }                                             951     }
944   }                                               952   }
945                                                   953 
946   //----- detector information -----//            954   //----- detector information -----//
947   // number of detectors                          955   // number of detectors
948   if(kPointerToDetectorData > 0) {                956   if(kPointerToDetectorData > 0) {
949     int ndet = (int)kDetectors.size();         << 957     int ndet = kDetectors.size();
950     if(kLittleEndianOutput) {                     958     if(kLittleEndianOutput) {
951       ofile.write((char *)&ndet, sizeof(int));    959       ofile.write((char *)&ndet, sizeof(int));
952     } else {                                      960     } else {
953       invertByteOrder((char *)&ndet, itmp[0]);    961       invertByteOrder((char *)&ndet, itmp[0]);
954       ofile.write((char *)itmp, 4);               962       ofile.write((char *)itmp, 4);
955     }                                             963     }
956     if(DEBUG || kVerbose > 0) {                   964     if(DEBUG || kVerbose > 0) {
957       G4cout << "# of detectors : "               965       G4cout << "# of detectors : "
958     << ndet << G4endl;                            966     << ndet << G4endl;
959     }                                             967     }
960                                                   968 
961     for(int nd = 0; nd < ndet; nd++) {            969     for(int nd = 0; nd < ndet; nd++) {
962                                                   970 
963       // # of edges of a detector                 971       // # of edges of a detector
964       int nedges = kDetectors[nd].getNumberOfE    972       int nedges = kDetectors[nd].getNumberOfEdges();
965       if(kLittleEndianOutput) {                   973       if(kLittleEndianOutput) {
966   ofile.write((char *)&nedges, sizeof(int));      974   ofile.write((char *)&nedges, sizeof(int));
967       } else {                                    975       } else {
968   invertByteOrder((char *)&nedges, itmp[0]);      976   invertByteOrder((char *)&nedges, itmp[0]);
969   ofile.write((char *)itmp, 4);                   977   ofile.write((char *)itmp, 4);
970       }                                           978       }
971       if(DEBUG || kVerbose > 0) {                 979       if(DEBUG || kVerbose > 0) {
972   G4cout << "# of edges in a detector : " << n    980   G4cout << "# of edges in a detector : " << nedges << G4endl;
973       }                                           981       }
974                                                   982 
975       // edges                                    983       // edges
976       float edgePoints[6];                        984       float edgePoints[6];
977       for(int ne = 0; ne < nedges; ne++) {        985       for(int ne = 0; ne < nedges; ne++) {
978   kDetectors[nd].getEdge(edgePoints[0], edgePo    986   kDetectors[nd].getEdge(edgePoints[0], edgePoints[1], edgePoints[2],
979              edgePoints[3], edgePoints[4], edg    987              edgePoints[3], edgePoints[4], edgePoints[5],
980              ne);                                 988              ne);
981                                                   989 
982   if(kLittleEndianOutput) {                       990   if(kLittleEndianOutput) {
983     ofile.write((char *)edgePoints, sizeof(flo    991     ofile.write((char *)edgePoints, sizeof(float)*6);
984   } else {                                        992   } else {
985     for(int j = 0; j < 6; j++)                    993     for(int j = 0; j < 6; j++)
986       invertByteOrder((char *)&edgePoints[j],     994       invertByteOrder((char *)&edgePoints[j], ftmp[j]);
987     ofile.write((char *)ftmp, 24);                995     ofile.write((char *)ftmp, 24);
988   }                                               996   }
989                                                   997 
990   if(DEBUG || kVerbose > 0) {                     998   if(DEBUG || kVerbose > 0) {
991     if(ne < 1) {                                  999     if(ne < 1) {
992       G4cout << " edge : (" << edgePoints[0] <    1000       G4cout << " edge : (" << edgePoints[0] << ", "
993           << edgePoints[1] << ", "                1001           << edgePoints[1] << ", "
994           << edgePoints[2] << ") - ("             1002           << edgePoints[2] << ") - ("
995           << edgePoints[3] << ", "                1003           << edgePoints[3] << ", "
996           << edgePoints[4] << ", "                1004           << edgePoints[4] << ", "
997           << edgePoints[5] << ")" << G4endl;      1005           << edgePoints[5] << ")" << G4endl;
998     }                                             1006     }
999   }                                               1007   }
1000       }                                          1008       }
1001                                                  1009 
1002       // detector color                          1010       // detector color
1003       unsigned char dcolor[3];                   1011       unsigned char dcolor[3];
1004       kDetectors[nd].getColor(dcolor);           1012       kDetectors[nd].getColor(dcolor);
1005       ofile.write((char *)dcolor, 3);            1013       ofile.write((char *)dcolor, 3);
1006       if(DEBUG || kVerbose > 0) {                1014       if(DEBUG || kVerbose > 0) {
1007   G4cout << " rgb : (" << (int)dcolor[0] << "    1015   G4cout << " rgb : (" << (int)dcolor[0] << ", "
1008       << (int)dcolor[1] << ", "                  1016       << (int)dcolor[1] << ", "
1009       << (int)dcolor[2] << ")" << G4endl;        1017       << (int)dcolor[2] << ")" << G4endl;
1010       }                                          1018       }
1011                                                  1019 
1012       // detector name                           1020       // detector name
1013       std::string dname = kDetectors[nd].getN    1021       std::string dname = kDetectors[nd].getName();
1014       dname.resize(80);                          1022       dname.resize(80);
1015       ofile.write((char *)dname.c_str(), 80);    1023       ofile.write((char *)dname.c_str(), 80);
1016       if(DEBUG || kVerbose > 0) {                1024       if(DEBUG || kVerbose > 0) {
1017   G4cout << " detector name : " << dname << G    1025   G4cout << " detector name : " << dname << G4endl;
1018                                                  1026       
1019       }                                          1027       }
1020     }                                            1028     }
1021   }                                              1029   }
1022                                                  1030 
1023   // file end mark                               1031   // file end mark
1024   ofile.write("END", 3);                         1032   ofile.write("END", 3);
1025                                                  1033 
1026   ofile.close();                                 1034   ofile.close();
1027   if(DEBUG || kVerbose > 0)                      1035   if(DEBUG || kVerbose > 0)
1028     G4cout << ">>>> closed gdd file: " << kFi    1036     G4cout << ">>>> closed gdd file: " << kFileName << G4endl;
1029                                                  1037 
1030   return true;                                   1038   return true;
1031 }                                                1039 }
1032 bool G4GMocrenIO::storeData3() {                 1040 bool G4GMocrenIO::storeData3() {
1033                                                  1041 
1034   if(kVerbose > 0) G4cout << ">>>>>>>  store     1042   if(kVerbose > 0) G4cout << ">>>>>>>  store data (ver.3) <<<<<<<" << G4endl;
1035   if(kVerbose > 0) G4cout << "         " << k    1043   if(kVerbose > 0) G4cout << "         " << kFileName << G4endl;
1036                                                  1044 
1037   bool DEBUG = false;//                          1045   bool DEBUG = false;//
1038                                                  1046 
1039   // output file open                            1047   // output file open
1040   std::ofstream ofile(kFileName.c_str(),         1048   std::ofstream ofile(kFileName.c_str(),
1041           std::ios_base::out|std::ios_base::b    1049           std::ios_base::out|std::ios_base::binary);
1042                                                  1050 
1043   // file identifier                             1051   // file identifier
1044   ofile.write("gMocren ", 8);                    1052   ofile.write("gMocren ", 8);
1045                                                  1053 
1046   // file version                                1054   // file version
1047   unsigned char ver = 0x03;                      1055   unsigned char ver = 0x03;
1048   ofile.write((char *)&ver, 1);                  1056   ofile.write((char *)&ver, 1);
1049                                                  1057 
1050   // endian                                      1058   // endian
1051   ofile.write((char *)&kLittleEndianOutput, s    1059   ofile.write((char *)&kLittleEndianOutput, sizeof(char));
1052                                                  1060 
1053   // comment length (fixed size)                 1061   // comment length (fixed size)
1054   int commentLength = 1024;                      1062   int commentLength = 1024;
1055   ofile.write((char *)&commentLength, 4);        1063   ofile.write((char *)&commentLength, 4);
1056                                                  1064 
1057   // comment                                     1065   // comment 
1058   char cmt[1025];                                1066   char cmt[1025];
1059   std::strncpy(cmt, kComment.c_str(), 1024);     1067   std::strncpy(cmt, kComment.c_str(), 1024);
1060   ofile.write((char *)cmt, 1024);                1068   ofile.write((char *)cmt, 1024);
1061   if(DEBUG || kVerbose > 0) {                    1069   if(DEBUG || kVerbose > 0) {
1062     G4cout << "Data comment : "                  1070     G4cout << "Data comment : "
1063         << kComment << G4endl;                   1071         << kComment << G4endl;
1064   }                                              1072   }
1065                                                  1073 
1066   // voxel spacings for all images               1074   // voxel spacings for all images
1067   ofile.write((char *)kVoxelSpacing, 12);        1075   ofile.write((char *)kVoxelSpacing, 12);
1068   if(DEBUG || kVerbose > 0) {                    1076   if(DEBUG || kVerbose > 0) {
1069     G4cout << "Voxel spacing : ("                1077     G4cout << "Voxel spacing : ("
1070         << kVoxelSpacing[0] << ", "              1078         << kVoxelSpacing[0] << ", "
1071         << kVoxelSpacing[1] << ", "              1079         << kVoxelSpacing[1] << ", "
1072         << kVoxelSpacing[2]                      1080         << kVoxelSpacing[2]
1073         << ") mm " << G4endl;                    1081         << ") mm " << G4endl;
1074   }                                              1082   }
1075                                                  1083 
1076   calcPointers3();                               1084   calcPointers3();
1077                                                  1085 
1078   // offset from file starting point to the m    1086   // offset from file starting point to the modality image data
1079   ofile.write((char *)&kPointerToModalityData    1087   ofile.write((char *)&kPointerToModalityData, 4);
1080                                                  1088 
1081   // # of dose distributions                     1089   // # of dose distributions
1082   //int nDoseDist = (int)pointerToDoseDistDat    1090   //int nDoseDist = (int)pointerToDoseDistData.size();
1083   int nDoseDist = getNumDoseDist();              1091   int nDoseDist = getNumDoseDist();
1084   ofile.write((char *)&nDoseDist, 4);            1092   ofile.write((char *)&nDoseDist, 4);
1085                                                  1093 
1086   // offset from file starting point to the d    1094   // offset from file starting point to the dose image data
1087   for(int i = 0; i < nDoseDist; i++) {           1095   for(int i = 0; i < nDoseDist; i++) {
1088     ofile.write((char *)&kPointerToDoseDistDa    1096     ofile.write((char *)&kPointerToDoseDistData[i], 4);
1089   }                                              1097   }
1090                                                  1098 
1091   // offset from file starting point to the R    1099   // offset from file starting point to the ROI image data
1092   ofile.write((char *)&kPointerToROIData, 4);    1100   ofile.write((char *)&kPointerToROIData, 4);
1093                                                  1101 
1094   // offset from file starting point to the t    1102   // offset from file starting point to the track data
1095   ofile.write((char *)&kPointerToTrackData, 4    1103   ofile.write((char *)&kPointerToTrackData, 4);
1096   if(DEBUG || kVerbose > 0) {                    1104   if(DEBUG || kVerbose > 0) {
1097     G4cout << "Each pointer to data : "          1105     G4cout << "Each pointer to data : "
1098         << kPointerToModalityData << ", ";       1106         << kPointerToModalityData << ", ";
1099     for(int i = 0; i < nDoseDist; i++) {         1107     for(int i = 0; i < nDoseDist; i++) {
1100       G4cout << kPointerToDoseDistData[i] <<     1108       G4cout << kPointerToDoseDistData[i] << ", ";
1101     }                                            1109     }
1102     G4cout << kPointerToROIData << ", "          1110     G4cout << kPointerToROIData << ", "
1103         << kPointerToTrackData << G4endl;        1111         << kPointerToTrackData << G4endl;
1104   }                                              1112   }
1105                                                  1113 
1106   //----- modality image -----//                 1114   //----- modality image -----//
1107                                                  1115 
1108   int size[3];                                   1116   int size[3];
1109   float scale;                                   1117   float scale;
1110   short minmax[2];                               1118   short minmax[2];
1111   float fCenter[3];                              1119   float fCenter[3];
1112   int iCenter[3];                                1120   int iCenter[3];
1113   // modality image size                         1121   // modality image size
1114   kModality.getSize(size);                       1122   kModality.getSize(size);
1115   ofile.write((char *)size, 3*sizeof(int));      1123   ofile.write((char *)size, 3*sizeof(int));
1116   if(DEBUG || kVerbose > 0) {                    1124   if(DEBUG || kVerbose > 0) {
1117     G4cout << "Modality image size : ("          1125     G4cout << "Modality image size : ("
1118         << size[0] << ", "                       1126         << size[0] << ", "
1119         << size[1] << ", "                       1127         << size[1] << ", "
1120         << size[2] << ")"                        1128         << size[2] << ")"
1121         << G4endl;                               1129         << G4endl;
1122   }                                              1130   }
1123                                                  1131 
1124   // modality image max. & min.                  1132   // modality image max. & min.
1125   kModality.getMinMax(minmax);                   1133   kModality.getMinMax(minmax);
1126   ofile.write((char *)minmax, 4);                1134   ofile.write((char *)minmax, 4);
1127                                                  1135 
1128   // modality image unit                         1136   // modality image unit
1129   char munit[13] = "g/cm3       ";               1137   char munit[13] = "g/cm3       ";
1130   ofile.write((char *)munit, 12);                1138   ofile.write((char *)munit, 12);
1131                                                  1139 
1132   // modality image scale                        1140   // modality image scale
1133   scale = (float)kModality.getScale();           1141   scale = (float)kModality.getScale();
1134   ofile.write((char *)&scale, 4);                1142   ofile.write((char *)&scale, 4);
1135   if(DEBUG || kVerbose > 0) {                    1143   if(DEBUG || kVerbose > 0) {
1136     G4cout << "Modality image min., max., sca    1144     G4cout << "Modality image min., max., scale : "
1137         << minmax[0] << ", "                     1145         << minmax[0] << ", "
1138         << minmax[1] << ", "                     1146         << minmax[1] << ", "
1139         << scale << G4endl;                      1147         << scale << G4endl;
1140   }                                              1148   }
1141                                                  1149 
1142   // modality image                              1150   // modality image
1143   int psize = size[0]*size[1];                   1151   int psize = size[0]*size[1];
1144   if(DEBUG || kVerbose > 0) G4cout << "Modali    1152   if(DEBUG || kVerbose > 0) G4cout << "Modality image : ";
1145   for(int i = 0; i < size[2]; i++) {             1153   for(int i = 0; i < size[2]; i++) {
1146     short * image = kModality.getImage(i);       1154     short * image = kModality.getImage(i);
1147     ofile.write((char *)image, psize*sizeof(s    1155     ofile.write((char *)image, psize*sizeof(short));
1148                                                  1156 
1149     if(DEBUG || kVerbose > 0) G4cout << "[" <    1157     if(DEBUG || kVerbose > 0) G4cout << "[" << i << "]" << image[(size_t)(psize*0.55)] << ", ";
1150   }                                              1158   }
1151   if(DEBUG || kVerbose > 0) G4cout << G4endl;    1159   if(DEBUG || kVerbose > 0) G4cout << G4endl;
1152                                                  1160 
1153   // modality desity map for CT value            1161   // modality desity map for CT value
1154   size_t msize = minmax[1] - minmax[0]+1;        1162   size_t msize = minmax[1] - minmax[0]+1;
1155   float * pdmap = new float[msize];              1163   float * pdmap = new float[msize];
1156   for(int i = 0; i < (int)msize; i++) pdmap[i    1164   for(int i = 0; i < (int)msize; i++) pdmap[i] =kModalityImageDensityMap[i]; 
1157   ofile.write((char *)pdmap, msize*sizeof(flo    1165   ofile.write((char *)pdmap, msize*sizeof(float));
1158   if(DEBUG || kVerbose > 0) {                    1166   if(DEBUG || kVerbose > 0) {
1159     G4cout << "density map : " << std::ends;     1167     G4cout << "density map : " << std::ends;
1160     for(int i = 0; i < (int)msize; i+=50)        1168     for(int i = 0; i < (int)msize; i+=50)
1161       G4cout <<kModalityImageDensityMap[i] <<    1169       G4cout <<kModalityImageDensityMap[i] << ", ";
1162     G4cout << G4endl;                            1170     G4cout << G4endl;
1163   }                                              1171   }
1164   delete [] pdmap;                               1172   delete [] pdmap;
1165                                                  1173 
1166                                                  1174 
1167   //----- dose distribution image -----//        1175   //----- dose distribution image -----//
1168                                                  1176 
1169   if(!isDoseEmpty()) {                           1177   if(!isDoseEmpty()) {
1170                                                  1178 
1171     calcDoseDistScale();                         1179     calcDoseDistScale();
1172                                                  1180 
1173     for(int ndose = 0; ndose < nDoseDist; ndo    1181     for(int ndose = 0; ndose < nDoseDist; ndose++) {
1174       // dose distrbution image size             1182       // dose distrbution image size
1175       kDose[ndose].getSize(size);                1183       kDose[ndose].getSize(size);
1176       ofile.write((char *)size, 3*sizeof(int)    1184       ofile.write((char *)size, 3*sizeof(int));
1177       if(DEBUG || kVerbose > 0) {                1185       if(DEBUG || kVerbose > 0) {
1178   G4cout << "Dose dist. [" << ndose << "] ima    1186   G4cout << "Dose dist. [" << ndose << "] image size : ("
1179       << size[0] << ", "                         1187       << size[0] << ", "
1180       << size[1] << ", "                         1188       << size[1] << ", "
1181       << size[2] << ")"                          1189       << size[2] << ")"
1182       << G4endl;                                 1190       << G4endl;
1183       }                                          1191       }
1184                                                  1192 
1185       // dose distribution max. & min.           1193       // dose distribution max. & min.
1186       getShortDoseDistMinMax(minmax, ndose);     1194       getShortDoseDistMinMax(minmax, ndose);
1187       ofile.write((char *)minmax, 2*2); // si    1195       ofile.write((char *)minmax, 2*2); // sizeof(shorft)*2
1188                                                  1196 
1189       // dose distribution unit                  1197       // dose distribution unit
1190       ofile.write((char *)kDoseUnit.c_str(),     1198       ofile.write((char *)kDoseUnit.c_str(), 12);
1191       if(DEBUG || kVerbose > 0) {                1199       if(DEBUG || kVerbose > 0) {
1192   G4cout << "Dose dist. unit : " << kDoseUnit    1200   G4cout << "Dose dist. unit : " << kDoseUnit << G4endl;
1193       }                                          1201       }
1194                                                  1202 
1195       // dose distribution scaling               1203       // dose distribution scaling 
1196       double dscale;                             1204       double dscale;
1197       dscale = getDoseDistScale(ndose);          1205       dscale = getDoseDistScale(ndose);
1198       scale = float(dscale);                     1206       scale = float(dscale);
1199       ofile.write((char *)&scale, 4);            1207       ofile.write((char *)&scale, 4);
1200       if(DEBUG || kVerbose > 0) {                1208       if(DEBUG || kVerbose > 0) {
1201   G4cout << "Dose dist. [" << ndose              1209   G4cout << "Dose dist. [" << ndose
1202       << "] image min., max., scale : "          1210       << "] image min., max., scale : "
1203       << minmax[0] << ", "                       1211       << minmax[0] << ", "
1204       << minmax[1] << ", "                       1212       << minmax[1] << ", "
1205       << scale << G4endl;                        1213       << scale << G4endl;
1206       }                                          1214       }
1207                                                  1215 
1208       // dose distribution image                 1216       // dose distribution image
1209       int dsize = size[0]*size[1];               1217       int dsize = size[0]*size[1];
1210       short * dimage = new short[dsize];         1218       short * dimage = new short[dsize];
1211       for(int z = 0; z < size[2]; z++) {         1219       for(int z = 0; z < size[2]; z++) {
1212   getShortDoseDist(dimage, z, ndose);            1220   getShortDoseDist(dimage, z, ndose);
1213   ofile.write((char *)dimage, dsize*2); //siz    1221   ofile.write((char *)dimage, dsize*2); //sizeof(short)
1214                                                  1222 
1215   if(DEBUG || kVerbose > 0) {                    1223   if(DEBUG || kVerbose > 0) {
1216     for(int j = 0; j < dsize; j++) {             1224     for(int j = 0; j < dsize; j++) {
1217       if(dimage[j] < 0)                          1225       if(dimage[j] < 0)
1218         G4cout << "[" << j << "," << z << "]"    1226         G4cout << "[" << j << "," << z << "]"
1219       << dimage[j] << ", ";                      1227       << dimage[j] << ", ";
1220     }                                            1228     }
1221   }                                              1229   }
1222       }                                          1230       }
1223       if(DEBUG || kVerbose > 0) G4cout << G4e    1231       if(DEBUG || kVerbose > 0) G4cout << G4endl;
1224       delete [] dimage;                          1232       delete [] dimage;
1225                                                  1233 
1226       // relative location of the dose distri    1234       // relative location of the dose distribution image for 
1227       // the modality image                      1235       // the modality image
1228       getDoseDistCenterPosition(fCenter, ndos    1236       getDoseDistCenterPosition(fCenter, ndose);
1229       for(int i = 0; i < 3; i++) iCenter[i] =    1237       for(int i = 0; i < 3; i++) iCenter[i] = (int)fCenter[i];
1230       ofile.write((char *)iCenter, 3*4); // 3    1238       ofile.write((char *)iCenter, 3*4); // 3*sizeof(int)
1231       if(DEBUG || kVerbose > 0) {                1239       if(DEBUG || kVerbose > 0) {
1232   G4cout << "Dose dist. [" << ndose              1240   G4cout << "Dose dist. [" << ndose
1233       << "]image relative location : ("          1241       << "]image relative location : ("
1234       << iCenter[0] << ", "                      1242       << iCenter[0] << ", "
1235       << iCenter[1] << ", "                      1243       << iCenter[1] << ", "
1236       << iCenter[2] << ")" << G4endl;            1244       << iCenter[2] << ")" << G4endl;
1237       }                                          1245       }
1238     }                                            1246     }
1239   }                                              1247   }
1240                                                  1248 
1241   //----- ROI image -----//                      1249   //----- ROI image -----//
1242   if(!isROIEmpty()) {                            1250   if(!isROIEmpty()) {
1243     // ROI image size                            1251     // ROI image size
1244     kRoi[0].getSize(size);                       1252     kRoi[0].getSize(size);
1245     ofile.write((char *)size, 3*sizeof(int));    1253     ofile.write((char *)size, 3*sizeof(int));
1246     if(DEBUG || kVerbose > 0) {                  1254     if(DEBUG || kVerbose > 0) {
1247       G4cout << "ROI image size : ("             1255       G4cout << "ROI image size : ("
1248     << size[0] << ", "                           1256     << size[0] << ", "
1249     << size[1] << ", "                           1257     << size[1] << ", "
1250     << size[2] << ")"                            1258     << size[2] << ")"
1251     << G4endl;                                   1259     << G4endl;
1252     }                                            1260     }
1253                                                  1261 
1254     // ROI max. & min.                           1262     // ROI max. & min.
1255     kRoi[0].getMinMax(minmax);                   1263     kRoi[0].getMinMax(minmax);
1256     ofile.write((char *)minmax, sizeof(short)    1264     ofile.write((char *)minmax, sizeof(short)*2);
1257                                                  1265 
1258     // ROI distribution scaling                  1266     // ROI distribution scaling 
1259     scale = (float)kRoi[0].getScale();           1267     scale = (float)kRoi[0].getScale();
1260     ofile.write((char *)&scale, sizeof(float)    1268     ofile.write((char *)&scale, sizeof(float));
1261     if(DEBUG || kVerbose > 0) {                  1269     if(DEBUG || kVerbose > 0) {
1262       G4cout << "ROI image min., max., scale     1270       G4cout << "ROI image min., max., scale : "
1263     << minmax[0] << ", "                         1271     << minmax[0] << ", "
1264     << minmax[1] << ", "                         1272     << minmax[1] << ", "
1265     << scale << G4endl;                          1273     << scale << G4endl;
1266     }                                            1274     }
1267                                                  1275 
1268     // ROI image                                 1276     // ROI image
1269     int rsize = size[0]*size[1];                 1277     int rsize = size[0]*size[1];
1270     for(int i = 0; i < size[2]; i++) {           1278     for(int i = 0; i < size[2]; i++) {
1271       short * rimage = kRoi[0].getImage(i);      1279       short * rimage = kRoi[0].getImage(i);
1272       ofile.write((char *)rimage, rsize*sizeo    1280       ofile.write((char *)rimage, rsize*sizeof(short));
1273                                                  1281 
1274     }                                            1282     }
1275                                                  1283 
1276     // ROI relative location                     1284     // ROI relative location
1277     kRoi[0].getCenterPosition(fCenter);          1285     kRoi[0].getCenterPosition(fCenter);
1278     for(int i = 0; i < 3; i++) iCenter[i] = (    1286     for(int i = 0; i < 3; i++) iCenter[i] = (int)fCenter[i];
1279     ofile.write((char *)iCenter, 3*sizeof(int    1287     ofile.write((char *)iCenter, 3*sizeof(int));
1280     if(DEBUG || kVerbose > 0) {                  1288     if(DEBUG || kVerbose > 0) {
1281       G4cout << "ROI image relative location     1289       G4cout << "ROI image relative location : ("
1282     << iCenter[0] << ", "                        1290     << iCenter[0] << ", "
1283     << iCenter[1] << ", "                        1291     << iCenter[1] << ", "
1284     << iCenter[2] << ")" << G4endl;              1292     << iCenter[2] << ")" << G4endl;
1285     }                                            1293     }
1286   }                                              1294   }
1287                                                  1295 
1288   //----- track information -----//              1296   //----- track information -----//
1289   // number of track                             1297   // number of track 
1290   int ntrk = (int)kSteps.size();              << 1298   int ntrk = kSteps.size();
1291   ofile.write((char *)&ntrk, sizeof(int));       1299   ofile.write((char *)&ntrk, sizeof(int));
1292   if(DEBUG || kVerbose > 0) {                    1300   if(DEBUG || kVerbose > 0) {
1293     G4cout << "# of tracks : "                   1301     G4cout << "# of tracks : "
1294         << ntrk << G4endl;                       1302         << ntrk << G4endl;
1295   }                                              1303   }
1296   // track position                              1304   // track position
1297   for(int i = 0; i < ntrk; i++) {                1305   for(int i = 0; i < ntrk; i++) {
1298     float * tp = kSteps[i];                      1306     float * tp = kSteps[i];
1299     ofile.write((char *)tp, sizeof(float)*6);    1307     ofile.write((char *)tp, sizeof(float)*6);
1300   }                                              1308   }
1301   // track color                                 1309   // track color
1302   int ntcolor = int(kStepColors.size());         1310   int ntcolor = int(kStepColors.size());
1303   if(ntrk != ntcolor)                            1311   if(ntrk != ntcolor) 
1304     if (G4VisManager::GetVerbosity() >= G4Vis    1312     if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
1305       G4cout << "# of track color information    1313       G4cout << "# of track color information must be the same as # of tracks." 
1306        << G4endl;                                1314        << G4endl;
1307   unsigned char white[3] = {255,255,255}; //     1315   unsigned char white[3] = {255,255,255}; // default color
1308   for(int i = 0; i < ntrk; i++) {                1316   for(int i = 0; i < ntrk; i++) {
1309     if(i < ntcolor) {                            1317     if(i < ntcolor) {
1310       unsigned char * tcolor = kStepColors[i]    1318       unsigned char * tcolor = kStepColors[i];
1311       ofile.write((char *)tcolor, 3);            1319       ofile.write((char *)tcolor, 3);
1312     } else {                                     1320     } else {
1313       ofile.write((char *)white, 3);             1321       ofile.write((char *)white, 3);
1314     }                                            1322     }
1315   }                                              1323   }
1316                                                  1324   
1317   // file end mark                               1325   // file end mark
1318   ofile.write("END", 3);                         1326   ofile.write("END", 3);
1319                                                  1327 
1320   ofile.close();                                 1328   ofile.close();
1321                                                  1329 
1322   return true;                                   1330   return true;
1323 }                                                1331 }
1324 //                                               1332 //
1325 bool G4GMocrenIO::storeData4(char * _filename    1333 bool G4GMocrenIO::storeData4(char * _filename) {
1326   kFileName = _filename;                         1334   kFileName = _filename;
1327   return storeData4();                           1335   return storeData4();
1328 }                                                1336 }
1329                                                  1337 
1330 // version 2                                     1338 // version 2
1331 bool G4GMocrenIO::storeData2() {                 1339 bool G4GMocrenIO::storeData2() {
1332                                                  1340 
1333   if(kVerbose > 0) G4cout << ">>>>>>>  store     1341   if(kVerbose > 0) G4cout << ">>>>>>>  store data (ver.2) <<<<<<<" << G4endl;
1334   if(kVerbose > 0) G4cout << "         " << k    1342   if(kVerbose > 0) G4cout << "         " << kFileName << G4endl;
1335                                                  1343 
1336   bool DEBUG = false;//                          1344   bool DEBUG = false;//
1337                                                  1345 
1338   // output file open                            1346   // output file open
1339   std::ofstream ofile(kFileName.c_str(),         1347   std::ofstream ofile(kFileName.c_str(),
1340           std::ios_base::out|std::ios_base::b    1348           std::ios_base::out|std::ios_base::binary);
1341                                                  1349 
1342   // file identifier                             1350   // file identifier
1343   ofile.write("GRAPE    ", 8);                   1351   ofile.write("GRAPE    ", 8);
1344                                                  1352 
1345   // file version                                1353   // file version
1346   unsigned char ver = 0x02;                      1354   unsigned char ver = 0x02;
1347   ofile.write((char *)&ver, 1);                  1355   ofile.write((char *)&ver, 1);
1348   // file id for old file format support         1356   // file id for old file format support
1349   ofile.write(kId.c_str(), IDLENGTH);            1357   ofile.write(kId.c_str(), IDLENGTH);
1350   // file version for old file format support    1358   // file version for old file format support
1351   ofile.write(kVersion.c_str(), VERLENGTH);      1359   ofile.write(kVersion.c_str(), VERLENGTH);
1352   // endian                                      1360   // endian
1353   ofile.write((char *)&kLittleEndianOutput, s    1361   ofile.write((char *)&kLittleEndianOutput, sizeof(char));
1354                                                  1362 
1355   /*                                             1363   /*
1356   // event number                                1364   // event number
1357   ofile.write((char *)&numberOfEvents, sizeof    1365   ofile.write((char *)&numberOfEvents, sizeof(int));
1358   float imageSpacing[3];                         1366   float imageSpacing[3]; 
1359   imageSpacing[0] = modalityImageVoxelSpacing    1367   imageSpacing[0] = modalityImageVoxelSpacing[0];
1360   imageSpacing[1] = modalityImageVoxelSpacing    1368   imageSpacing[1] = modalityImageVoxelSpacing[1];
1361   imageSpacing[2] = modalityImageVoxelSpacing    1369   imageSpacing[2] = modalityImageVoxelSpacing[2];
1362   ofile.write((char *)imageSpacing, 12);         1370   ofile.write((char *)imageSpacing, 12);
1363   */                                             1371   */
1364                                                  1372 
1365                                                  1373 
1366   // voxel spacings for all images               1374   // voxel spacings for all images
1367   ofile.write((char *)kVoxelSpacing, 12);        1375   ofile.write((char *)kVoxelSpacing, 12);
1368   if(DEBUG || kVerbose > 0) {                    1376   if(DEBUG || kVerbose > 0) {
1369     G4cout << "Voxel spacing : ("                1377     G4cout << "Voxel spacing : ("
1370         << kVoxelSpacing[0] << ", "              1378         << kVoxelSpacing[0] << ", "
1371         << kVoxelSpacing[1] << ", "              1379         << kVoxelSpacing[1] << ", "
1372         << kVoxelSpacing[2]                      1380         << kVoxelSpacing[2]
1373         << ") mm " << G4endl;                    1381         << ") mm " << G4endl;
1374   }                                              1382   }
1375                                                  1383 
1376   calcPointers2();                               1384   calcPointers2();
1377   // offset from file starting point to the m    1385   // offset from file starting point to the modality image data
1378   ofile.write((char *)&kPointerToModalityData    1386   ofile.write((char *)&kPointerToModalityData, 4);
1379                                                  1387 
1380   // offset from file starting point to the d    1388   // offset from file starting point to the dose image data
1381   ofile.write((char *)&kPointerToDoseDistData    1389   ofile.write((char *)&kPointerToDoseDistData[0], 4);
1382                                                  1390 
1383   // offset from file starting point to the R    1391   // offset from file starting point to the ROI image data
1384   ofile.write((char *)&kPointerToROIData, 4);    1392   ofile.write((char *)&kPointerToROIData, 4);
1385                                                  1393 
1386   // offset from file starting point to the t    1394   // offset from file starting point to the track data
1387   ofile.write((char *)&kPointerToTrackData, 4    1395   ofile.write((char *)&kPointerToTrackData, 4);
1388   if(DEBUG || kVerbose > 0) {                    1396   if(DEBUG || kVerbose > 0) {
1389     G4cout << "Each pointer to data : "          1397     G4cout << "Each pointer to data : "
1390         << kPointerToModalityData << ", "        1398         << kPointerToModalityData << ", "
1391         << kPointerToDoseDistData[0] << ", "     1399         << kPointerToDoseDistData[0] << ", "
1392         << kPointerToROIData << ", "             1400         << kPointerToROIData << ", "
1393         << kPointerToTrackData << G4endl;        1401         << kPointerToTrackData << G4endl;
1394   }                                              1402   }
1395                                                  1403 
1396   //----- modality image -----//                 1404   //----- modality image -----//
1397                                                  1405 
1398   int size[3];                                   1406   int size[3];
1399   float scale;                                   1407   float scale;
1400   short minmax[2];                               1408   short minmax[2];
1401   float fCenter[3];                              1409   float fCenter[3];
1402   int iCenter[3];                                1410   int iCenter[3];
1403   // modality image size                         1411   // modality image size
1404   kModality.getSize(size);                       1412   kModality.getSize(size);
1405   ofile.write((char *)size, 3*sizeof(int));      1413   ofile.write((char *)size, 3*sizeof(int));
1406   if(DEBUG || kVerbose > 0) {                    1414   if(DEBUG || kVerbose > 0) {
1407     G4cout << "Modality image size : ("          1415     G4cout << "Modality image size : ("
1408         << size[0] << ", "                       1416         << size[0] << ", "
1409         << size[1] << ", "                       1417         << size[1] << ", "
1410         << size[2] << ")"                        1418         << size[2] << ")"
1411         << G4endl;                               1419         << G4endl;
1412   }                                              1420   }
1413                                                  1421 
1414   // modality image max. & min.                  1422   // modality image max. & min.
1415   kModality.getMinMax(minmax);                   1423   kModality.getMinMax(minmax);
1416   ofile.write((char *)minmax, 4);                1424   ofile.write((char *)minmax, 4);
1417                                                  1425 
1418   // modality image unit                         1426   // modality image unit
1419   //char munit[13] = "g/cm3       ";             1427   //char munit[13] = "g/cm3       ";
1420   //ofile.write((char *)&munit, 12);             1428   //ofile.write((char *)&munit, 12);
1421                                                  1429   
1422   // modality image scale                        1430   // modality image scale
1423   scale = (float)kModality.getScale();           1431   scale = (float)kModality.getScale();
1424   ofile.write((char *)&scale, 4);                1432   ofile.write((char *)&scale, 4);
1425   if(DEBUG || kVerbose > 0) {                    1433   if(DEBUG || kVerbose > 0) {
1426     G4cout << "Modality image min., max., sca    1434     G4cout << "Modality image min., max., scale : "
1427         << minmax[0] << ", "                     1435         << minmax[0] << ", "
1428         << minmax[1] << ", "                     1436         << minmax[1] << ", "
1429         << scale << G4endl;                      1437         << scale << G4endl;
1430   }                                              1438   }
1431                                                  1439 
1432   // modality image                              1440   // modality image
1433   int psize = size[0]*size[1];                   1441   int psize = size[0]*size[1];
1434   if(DEBUG || kVerbose > 0) G4cout << "Modali    1442   if(DEBUG || kVerbose > 0) G4cout << "Modality image : ";
1435   for(int i = 0; i < size[2]; i++) {             1443   for(int i = 0; i < size[2]; i++) {
1436     short * image =kModality.getImage(i);        1444     short * image =kModality.getImage(i);
1437     ofile.write((char *)image, psize*sizeof(s    1445     ofile.write((char *)image, psize*sizeof(short));
1438                                                  1446 
1439     if(DEBUG || kVerbose > 0) G4cout << "[" <    1447     if(DEBUG || kVerbose > 0) G4cout << "[" << i << "]" << image[(size_t)(psize*0.55)] << ", ";
1440   }                                              1448   }
1441   if(DEBUG || kVerbose > 0) G4cout << G4endl;    1449   if(DEBUG || kVerbose > 0) G4cout << G4endl;
1442                                                  1450 
1443   // modality desity map for CT value            1451   // modality desity map for CT value
1444   size_t msize = minmax[1] - minmax[0]+1;        1452   size_t msize = minmax[1] - minmax[0]+1;
1445   float * pdmap = new float[msize];              1453   float * pdmap = new float[msize];
1446   for(int i = 0; i < (int)msize; i++) pdmap[i    1454   for(int i = 0; i < (int)msize; i++) pdmap[i] =kModalityImageDensityMap[i]; 
1447   ofile.write((char *)pdmap, msize*sizeof(flo    1455   ofile.write((char *)pdmap, msize*sizeof(float));
1448   if(DEBUG || kVerbose > 0) {                    1456   if(DEBUG || kVerbose > 0) {
1449     G4cout << "density map : " << std::ends;     1457     G4cout << "density map : " << std::ends;
1450     for(int i = 0; i < (int)msize; i+=50)        1458     for(int i = 0; i < (int)msize; i+=50)
1451       G4cout <<kModalityImageDensityMap[i] <<    1459       G4cout <<kModalityImageDensityMap[i] << ", ";
1452     G4cout << G4endl;                            1460     G4cout << G4endl;
1453   }                                              1461   }
1454   delete [] pdmap;                               1462   delete [] pdmap;
1455                                                  1463 
1456                                                  1464 
1457   //----- dose distribution image -----//        1465   //----- dose distribution image -----//
1458                                                  1466 
1459   if(!isDoseEmpty()) {                           1467   if(!isDoseEmpty()) {
1460     calcDoseDistScale();                         1468     calcDoseDistScale();
1461                                                  1469 
1462     // dose distrbution image size               1470     // dose distrbution image size
1463     kDose[0].getSize(size);                      1471     kDose[0].getSize(size);
1464     ofile.write((char *)size, 3*sizeof(int));    1472     ofile.write((char *)size, 3*sizeof(int));
1465     if(DEBUG || kVerbose > 0) {                  1473     if(DEBUG || kVerbose > 0) {
1466       G4cout << "Dose dist. image size : ("      1474       G4cout << "Dose dist. image size : ("
1467     << size[0] << ", "                           1475     << size[0] << ", "
1468     << size[1] << ", "                           1476     << size[1] << ", "
1469     << size[2] << ")"                            1477     << size[2] << ")"
1470     << G4endl;                                   1478     << G4endl;
1471     }                                            1479     }
1472                                                  1480 
1473     // dose distribution max. & min.             1481     // dose distribution max. & min.
1474     getShortDoseDistMinMax(minmax);              1482     getShortDoseDistMinMax(minmax);
1475     ofile.write((char *)minmax, sizeof(short)    1483     ofile.write((char *)minmax, sizeof(short)*2);
1476                                                  1484 
1477     // dose distribution scaling                 1485     // dose distribution scaling 
1478     scale = (float)kDose[0].getScale();          1486     scale = (float)kDose[0].getScale();
1479     ofile.write((char *)&scale, sizeof(float)    1487     ofile.write((char *)&scale, sizeof(float));
1480     if(DEBUG || kVerbose > 0) {                  1488     if(DEBUG || kVerbose > 0) {
1481       G4cout << "Dose dist. image min., max.,    1489       G4cout << "Dose dist. image min., max., scale : "
1482     << minmax[0] << ", "                         1490     << minmax[0] << ", "
1483     << minmax[1] << ", "                         1491     << minmax[1] << ", "
1484     << scale << G4endl;                          1492     << scale << G4endl;
1485     }                                            1493     }
1486                                                  1494 
1487     // dose distribution image                   1495     // dose distribution image
1488     int dsize = size[0]*size[1];                 1496     int dsize = size[0]*size[1];
1489     short * dimage = new short[dsize];           1497     short * dimage = new short[dsize];
1490     for(int z = 0; z < size[2]; z++) {           1498     for(int z = 0; z < size[2]; z++) {
1491       getShortDoseDist(dimage, z);               1499       getShortDoseDist(dimage, z);
1492       ofile.write((char *)dimage, dsize*sizeo    1500       ofile.write((char *)dimage, dsize*sizeof(short));
1493                                                  1501 
1494       if(DEBUG || kVerbose > 0) {                1502       if(DEBUG || kVerbose > 0) {
1495   for(int j = 0; j < dsize; j++) {               1503   for(int j = 0; j < dsize; j++) {
1496     if(dimage[j] < 0)                            1504     if(dimage[j] < 0)
1497       G4cout << "[" << j << "," << z << "]"      1505       G4cout << "[" << j << "," << z << "]"
1498           << dimage[j] << ", ";                  1506           << dimage[j] << ", ";
1499   }                                              1507   }
1500       }                                          1508       }
1501     }                                            1509     }
1502     if(DEBUG || kVerbose > 0) G4cout << G4end    1510     if(DEBUG || kVerbose > 0) G4cout << G4endl;
1503     delete [] dimage;                            1511     delete [] dimage;
1504                                                  1512 
1505     // relative location of the dose distribu    1513     // relative location of the dose distribution image for 
1506     // the modality image                        1514     // the modality image
1507     kDose[0].getCenterPosition(fCenter);         1515     kDose[0].getCenterPosition(fCenter);
1508     for(int i = 0; i < 3; i++) iCenter[i] = (    1516     for(int i = 0; i < 3; i++) iCenter[i] = (int)fCenter[i];
1509     ofile.write((char *)iCenter, 3*sizeof(int    1517     ofile.write((char *)iCenter, 3*sizeof(int));
1510     if(DEBUG || kVerbose > 0) {                  1518     if(DEBUG || kVerbose > 0) {
1511       G4cout << "Dose dist. image relative lo    1519       G4cout << "Dose dist. image relative location : ("
1512     << iCenter[0] << ", "                        1520     << iCenter[0] << ", "
1513     << iCenter[1] << ", "                        1521     << iCenter[1] << ", "
1514     << iCenter[2] << ")" << G4endl;              1522     << iCenter[2] << ")" << G4endl;
1515     }                                            1523     }
1516                                                  1524 
1517   }                                              1525   }
1518                                                  1526 
1519   //----- ROI image -----//                      1527   //----- ROI image -----//
1520   if(!isROIEmpty()) {                            1528   if(!isROIEmpty()) {
1521     // ROI image size                            1529     // ROI image size
1522     kRoi[0].getSize(size);                       1530     kRoi[0].getSize(size);
1523     ofile.write((char *)size, 3*sizeof(int));    1531     ofile.write((char *)size, 3*sizeof(int));
1524     if(DEBUG || kVerbose > 0) {                  1532     if(DEBUG || kVerbose > 0) {
1525       G4cout << "ROI image size : ("             1533       G4cout << "ROI image size : ("
1526     << size[0] << ", "                           1534     << size[0] << ", "
1527     << size[1] << ", "                           1535     << size[1] << ", "
1528     << size[2] << ")"                            1536     << size[2] << ")"
1529     << G4endl;                                   1537     << G4endl;
1530     }                                            1538     }
1531                                                  1539 
1532     // ROI max. & min.                           1540     // ROI max. & min.
1533     kRoi[0].getMinMax(minmax);                   1541     kRoi[0].getMinMax(minmax);
1534     ofile.write((char *)minmax, sizeof(short)    1542     ofile.write((char *)minmax, sizeof(short)*2);
1535                                                  1543 
1536     // ROI distribution scaling                  1544     // ROI distribution scaling 
1537     scale = (float)kRoi[0].getScale();           1545     scale = (float)kRoi[0].getScale();
1538     ofile.write((char *)&scale, sizeof(float)    1546     ofile.write((char *)&scale, sizeof(float));
1539     if(DEBUG || kVerbose > 0) {                  1547     if(DEBUG || kVerbose > 0) {
1540       G4cout << "ROI image min., max., scale     1548       G4cout << "ROI image min., max., scale : "
1541     << minmax[0] << ", "                         1549     << minmax[0] << ", "
1542     << minmax[1] << ", "                         1550     << minmax[1] << ", "
1543     << scale << G4endl;                          1551     << scale << G4endl;
1544     }                                            1552     }
1545                                                  1553 
1546     // ROI image                                 1554     // ROI image
1547     int rsize = size[0]*size[1];                 1555     int rsize = size[0]*size[1];
1548     for(int i = 0; i < size[2]; i++) {           1556     for(int i = 0; i < size[2]; i++) {
1549       short * rimage = kRoi[0].getImage(i);      1557       short * rimage = kRoi[0].getImage(i);
1550       ofile.write((char *)rimage, rsize*sizeo    1558       ofile.write((char *)rimage, rsize*sizeof(short));
1551                                                  1559 
1552     }                                            1560     }
1553                                                  1561 
1554     // ROI relative location                     1562     // ROI relative location
1555     kRoi[0].getCenterPosition(fCenter);          1563     kRoi[0].getCenterPosition(fCenter);
1556     for(int i = 0; i < 3; i++) iCenter[i] = (    1564     for(int i = 0; i < 3; i++) iCenter[i] = (int)fCenter[i];
1557     ofile.write((char *)iCenter, 3*sizeof(int    1565     ofile.write((char *)iCenter, 3*sizeof(int));
1558     if(DEBUG || kVerbose > 0) {                  1566     if(DEBUG || kVerbose > 0) {
1559       G4cout << "ROI image relative location     1567       G4cout << "ROI image relative location : ("
1560     << iCenter[0] << ", "                        1568     << iCenter[0] << ", "
1561     << iCenter[1] << ", "                        1569     << iCenter[1] << ", "
1562     << iCenter[2] << ")" << G4endl;              1570     << iCenter[2] << ")" << G4endl;
1563     }                                            1571     }
1564   }                                              1572   }
1565                                                  1573 
1566                                                  1574 
1567   //----- track information -----//              1575   //----- track information -----//
1568   // track                                       1576   // track
1569   int ntrk = (int)kSteps.size();              << 1577   int ntrk = kSteps.size();
1570   ofile.write((char *)&ntrk, sizeof(int));       1578   ofile.write((char *)&ntrk, sizeof(int));
1571   if(DEBUG || kVerbose > 0) {                    1579   if(DEBUG || kVerbose > 0) {
1572     G4cout << "# of tracks : "                   1580     G4cout << "# of tracks : "
1573         << ntrk << G4endl;                       1581         << ntrk << G4endl;
1574   }                                              1582   }
1575   for(int i = 0; i < ntrk; i++) {                1583   for(int i = 0; i < ntrk; i++) {
1576     float * tp = kSteps[i];                      1584     float * tp = kSteps[i];
1577     ofile.write((char *)tp, sizeof(float)*6);    1585     ofile.write((char *)tp, sizeof(float)*6);
1578   }                                              1586   }
1579                                                  1587 
1580                                                  1588 
1581   // file end mark                               1589   // file end mark
1582   ofile.write("END", 3);                         1590   ofile.write("END", 3);
1583                                                  1591 
1584   ofile.close();                                 1592   ofile.close();
1585                                                  1593 
1586   return true;                                   1594   return true;
1587 }                                                1595 }
1588 //                                               1596 //
1589 bool G4GMocrenIO::storeData2(char * _filename    1597 bool G4GMocrenIO::storeData2(char * _filename) {
1590   kFileName = _filename;                         1598   kFileName = _filename;
1591   return storeData();                            1599   return storeData();
1592 }                                                1600 }
1593                                                  1601 
1594 bool G4GMocrenIO::retrieveData() {               1602 bool G4GMocrenIO::retrieveData() {
1595                                                  1603 
1596   // input file open                             1604   // input file open
1597   std::ifstream ifile(kFileName.c_str(), std:    1605   std::ifstream ifile(kFileName.c_str(), std::ios_base::in|std::ios_base::binary);
1598   if(!ifile) {                                   1606   if(!ifile) {
1599     if (G4VisManager::GetVerbosity() >= G4Vis    1607     if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
1600       G4cout << "Cannot open file: " << kFile    1608       G4cout << "Cannot open file: " << kFileName
1601        << " in G4GMocrenIO::retrieveData()."     1609        << " in G4GMocrenIO::retrieveData()." << G4endl;
1602     return false;                                1610     return false;
1603   }                                              1611   }
1604                                                  1612 
1605   // file identifier                             1613   // file identifier
1606   char verid[9];                                 1614   char verid[9];
1607   ifile.read((char *)verid, 8);                  1615   ifile.read((char *)verid, 8);
1608   // file version                                1616   // file version
1609   unsigned char ver;                             1617   unsigned char ver;
1610   ifile.read((char *)&ver, 1);                   1618   ifile.read((char *)&ver, 1);
1611   ifile.close();                                 1619   ifile.close();
1612                                                  1620 
1613   if(std::strncmp(verid, "gMocren", 7) == 0)     1621   if(std::strncmp(verid, "gMocren", 7) == 0) {
1614     if(ver == 0x03) {                            1622     if(ver == 0x03) {
1615       G4cout << ">>>>>>>  retrieve data (ver.    1623       G4cout << ">>>>>>>  retrieve data (ver.3) <<<<<<<" << G4endl;
1616       G4cout << "         " << kFileName << G    1624       G4cout << "         " << kFileName << G4endl;
1617       retrieveData3();                           1625       retrieveData3();
1618     } else if (ver == 0x04) {                    1626     } else if (ver == 0x04) {
1619       G4cout << ">>>>>>>  retrieve data (ver.    1627       G4cout << ">>>>>>>  retrieve data (ver.4) <<<<<<<" << G4endl;
1620       G4cout << "         " << kFileName << G    1628       G4cout << "         " << kFileName << G4endl;
1621       retrieveData4();                           1629       retrieveData4();
1622     } else {                                     1630     } else {
1623       if (G4VisManager::GetVerbosity() >= G4V    1631       if (G4VisManager::GetVerbosity() >= G4VisManager::errors) {
1624   G4cout << "Error -- invalid file version :     1632   G4cout << "Error -- invalid file version : " << (int)ver
1625       << G4endl;                                 1633       << G4endl;
1626   G4cout << "         " << kFileName << G4end    1634   G4cout << "         " << kFileName << G4endl;
1627       }                                          1635       }
1628       G4Exception("G4GMocrenIO::retrieveDadta << 1636       std::exit(-1);
1629                   "gMocren2001", FatalExcepti << 
1630                   "Error.");                  << 
1631                                               << 
1632     }                                            1637     }
1633   } else if(std::strncmp(verid, "GRAPE", 5) =    1638   } else if(std::strncmp(verid, "GRAPE", 5) == 0) {
1634     G4cout << ">>>>>>>  retrieve data (ver.2)    1639     G4cout << ">>>>>>>  retrieve data (ver.2) <<<<<<<" << G4endl;
1635     G4cout << "         " << kFileName << G4e    1640     G4cout << "         " << kFileName << G4endl;
1636     retrieveData2();                             1641     retrieveData2();
1637   } else {                                       1642   } else {
1638     if (G4VisManager::GetVerbosity() >= G4Vis    1643     if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
1639       G4cout << kFileName << " was not gdd fi    1644       G4cout << kFileName << " was not gdd file." << G4endl;
1640     return false;                                1645     return false;
1641   }                                              1646   }
1642                                                  1647 
1643   return true;                                   1648   return true;
1644 }                                                1649 }
1645                                                  1650 
1646 bool G4GMocrenIO::retrieveData(char * _filena    1651 bool G4GMocrenIO::retrieveData(char * _filename) {
1647   kFileName = _filename;                         1652   kFileName = _filename;
1648   return retrieveData();                         1653   return retrieveData();
1649 }                                                1654 }
1650                                                  1655 
1651 //                                               1656 // 
1652 bool G4GMocrenIO::retrieveData4() {              1657 bool G4GMocrenIO::retrieveData4() {
1653                                                  1658 
1654   bool DEBUG = false;//                          1659   bool DEBUG = false;//
1655                                                  1660 
1656   // input file open                             1661   // input file open
1657   std::ifstream ifile(kFileName.c_str(), std:    1662   std::ifstream ifile(kFileName.c_str(), std::ios_base::in|std::ios_base::binary);
1658   if(!ifile) {                                   1663   if(!ifile) {
1659     if (G4VisManager::GetVerbosity() >= G4Vis    1664     if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
1660       G4cout << "Cannot open file: " << kFile    1665       G4cout << "Cannot open file: " << kFileName
1661     << " in G4GMocrenIO::retrieveData3()." <<    1666     << " in G4GMocrenIO::retrieveData3()." << G4endl;
1662     return false;                                1667     return false;
1663   }                                              1668   }
1664                                                  1669 
1665   // data buffer                                 1670   // data buffer
1666   char ctmp[24];                                 1671   char ctmp[24];
1667                                                  1672 
1668   // file identifier                             1673   // file identifier
1669   char verid[9];                                 1674   char verid[9];
1670   ifile.read((char *)verid, 8);                  1675   ifile.read((char *)verid, 8);
1671                                                  1676 
1672   // file version                                1677   // file version
1673   unsigned char ver;                             1678   unsigned char ver;
1674   ifile.read((char *)&ver, 1);                   1679   ifile.read((char *)&ver, 1);
1675   std::stringstream ss;                          1680   std::stringstream ss;
1676   ss << (int)ver;                                1681   ss << (int)ver;
1677   kVersion = ss.str();                           1682   kVersion = ss.str();
1678   if(DEBUG || kVerbose > 0) G4cout << "File v    1683   if(DEBUG || kVerbose > 0) G4cout << "File version : " << kVersion << G4endl;
1679                                                  1684 
1680   // endian                                      1685   // endian
1681   ifile.read((char *)&kLittleEndianInput, siz    1686   ifile.read((char *)&kLittleEndianInput, sizeof(char));
1682   if(DEBUG || kVerbose > 0) {                    1687   if(DEBUG || kVerbose > 0) {
1683     G4cout << "Endian : ";                       1688     G4cout << "Endian : ";
1684     if(kLittleEndianInput == 1)                  1689     if(kLittleEndianInput == 1) 
1685       G4cout << " little" << G4endl;             1690       G4cout << " little" << G4endl;
1686     else {                                       1691     else {
1687       G4cout << " big" << G4endl;                1692       G4cout << " big" << G4endl;
1688     }                                            1693     }
1689   }                                              1694   }
1690                                                  1695 
1691   // comment length (fixed size)                 1696   // comment length (fixed size)
1692   int clength;                                   1697   int clength;
1693   ifile.read((char *)ctmp, 4);                   1698   ifile.read((char *)ctmp, 4);
1694   convertEndian(ctmp, clength);                  1699   convertEndian(ctmp, clength);
1695   // comment                                     1700   // comment
1696   char cmt[1025];                                1701   char cmt[1025];
1697   ifile.read((char *)cmt, clength);              1702   ifile.read((char *)cmt, clength);
1698   std::string scmt = cmt;                        1703   std::string scmt = cmt;
1699   scmt += '\0';                                  1704   scmt += '\0';
1700   setComment(scmt);                              1705   setComment(scmt);
1701   if(DEBUG || kVerbose > 0) {                    1706   if(DEBUG || kVerbose > 0) {
1702     G4cout << "Data comment : "                  1707     G4cout << "Data comment : "
1703         << kComment << G4endl;                   1708         << kComment << G4endl;
1704   }                                              1709   }
1705                                                  1710 
1706   // voxel spacings for all images               1711   // voxel spacings for all images
1707   ifile.read((char *)ctmp, 12);                  1712   ifile.read((char *)ctmp, 12);
1708   convertEndian(ctmp, kVoxelSpacing[0]);         1713   convertEndian(ctmp, kVoxelSpacing[0]);
1709   convertEndian(ctmp+4, kVoxelSpacing[1]);       1714   convertEndian(ctmp+4, kVoxelSpacing[1]);
1710   convertEndian(ctmp+8, kVoxelSpacing[2]);       1715   convertEndian(ctmp+8, kVoxelSpacing[2]);
1711   if(DEBUG || kVerbose > 0) {                    1716   if(DEBUG || kVerbose > 0) {
1712     G4cout << "Voxel spacing : ("                1717     G4cout << "Voxel spacing : ("
1713         << kVoxelSpacing[0] << ", "              1718         << kVoxelSpacing[0] << ", "
1714         << kVoxelSpacing[1] << ", "              1719         << kVoxelSpacing[1] << ", "
1715         << kVoxelSpacing[2]                      1720         << kVoxelSpacing[2]
1716         << ") mm " << G4endl;                    1721         << ") mm " << G4endl;
1717   }                                              1722   }
1718                                                  1723 
1719                                                  1724 
1720   // offset from file starting point to the m    1725   // offset from file starting point to the modality image data
1721   ifile.read((char *)ctmp, 4);                   1726   ifile.read((char *)ctmp, 4);
1722   convertEndian(ctmp, kPointerToModalityData)    1727   convertEndian(ctmp, kPointerToModalityData);
1723                                                  1728 
1724   // # of dose distributions                     1729   // # of dose distributions
1725   ifile.read((char *)ctmp, 4);                   1730   ifile.read((char *)ctmp, 4);
1726   int nDoseDist;                                 1731   int nDoseDist;
1727   convertEndian(ctmp, nDoseDist);                1732   convertEndian(ctmp, nDoseDist);
1728                                                  1733   
1729   // offset from file starting point to the d    1734   // offset from file starting point to the dose image data
1730   for(int i = 0; i < nDoseDist; i++) {           1735   for(int i = 0; i < nDoseDist; i++) {
1731     ifile.read((char *)ctmp, 4);                 1736     ifile.read((char *)ctmp, 4);
1732     unsigned int dptr;                           1737     unsigned int dptr;
1733     convertEndian(ctmp, dptr);                   1738     convertEndian(ctmp, dptr);
1734     addPointerToDoseDistData(dptr);              1739     addPointerToDoseDistData(dptr);
1735   }                                              1740   }
1736                                                  1741 
1737   // offset from file starting point to the R    1742   // offset from file starting point to the ROI image data
1738   ifile.read((char *)ctmp, 4);                   1743   ifile.read((char *)ctmp, 4);
1739   convertEndian(ctmp, kPointerToROIData);        1744   convertEndian(ctmp, kPointerToROIData);
1740                                                  1745 
1741   // offset from file starting point to the t    1746   // offset from file starting point to the track data
1742   ifile.read((char *)ctmp, 4);                   1747   ifile.read((char *)ctmp, 4);
1743   convertEndian(ctmp, kPointerToTrackData);      1748   convertEndian(ctmp, kPointerToTrackData);
1744                                                  1749 
1745   // offset from file starting point to the d    1750   // offset from file starting point to the detector data
1746   ifile.read((char *)ctmp, 4);                   1751   ifile.read((char *)ctmp, 4);
1747   convertEndian(ctmp, kPointerToDetectorData)    1752   convertEndian(ctmp, kPointerToDetectorData);
1748                                                  1753 
1749   if(DEBUG || kVerbose > 0) {                    1754   if(DEBUG || kVerbose > 0) {
1750     G4cout << "Each pointer to data : "          1755     G4cout << "Each pointer to data : "
1751         << kPointerToModalityData << ", ";       1756         << kPointerToModalityData << ", ";
1752     for(int i = 0; i < nDoseDist; i++)           1757     for(int i = 0; i < nDoseDist; i++)
1753       G4cout << kPointerToDoseDistData[i] <<     1758       G4cout << kPointerToDoseDistData[i] << ", ";
1754     G4cout << kPointerToROIData << ", "          1759     G4cout << kPointerToROIData << ", "
1755         << kPointerToTrackData << ", "           1760         << kPointerToTrackData << ", "
1756         << kPointerToDetectorData                1761         << kPointerToDetectorData
1757         << G4endl;                               1762         << G4endl;
1758   }                                              1763   }
1759                                                  1764 
1760                                                  1765 
1761                                                  1766 
1762   if(kPointerToModalityData == 0 && kPointerT    1767   if(kPointerToModalityData == 0 && kPointerToDoseDistData.size() == 0 &&
1763      kPointerToROIData == 0 && kPointerToTrac    1768      kPointerToROIData == 0 && kPointerToTrackData == 0) {
1764     if(DEBUG || kVerbose > 0) {                  1769     if(DEBUG || kVerbose > 0) {
1765       G4cout << "No data." << G4endl;            1770       G4cout << "No data." << G4endl;
1766     }                                            1771     }
1767     return false;                                1772     return false;
1768   }                                              1773   }
1769                                                  1774 
1770   // event number                                1775   // event number
1771   /* ver 1                                       1776   /* ver 1
1772      ifile.read(ctmp, sizeof(int));              1777      ifile.read(ctmp, sizeof(int));
1773      convertEndian(ctmp, numberOfEvents);        1778      convertEndian(ctmp, numberOfEvents);
1774   */                                             1779   */
1775                                                  1780 
1776   int size[3];                                   1781   int size[3];
1777   float scale;                                   1782   float scale;
1778   double dscale;                                 1783   double dscale;
1779   short minmax[2];                               1784   short minmax[2];
1780   float fCenter[3];                              1785   float fCenter[3];
1781   int iCenter[3];                                1786   int iCenter[3];
1782                                                  1787 
1783   //----- Modality image -----//                 1788   //----- Modality image -----//
1784   // modality image size                         1789   // modality image size
1785   ifile.read(ctmp, 3*sizeof(int));               1790   ifile.read(ctmp, 3*sizeof(int));
1786   convertEndian(ctmp, size[0]);                  1791   convertEndian(ctmp, size[0]);
1787   convertEndian(ctmp+sizeof(int), size[1]);      1792   convertEndian(ctmp+sizeof(int), size[1]);
1788   convertEndian(ctmp+2*sizeof(int), size[2]);    1793   convertEndian(ctmp+2*sizeof(int), size[2]);
1789   if(DEBUG || kVerbose > 0) {                    1794   if(DEBUG || kVerbose > 0) {
1790     G4cout << "Modality image size : ("          1795     G4cout << "Modality image size : ("
1791         << size[0] << ", "                       1796         << size[0] << ", "
1792         << size[1] << ", "                       1797         << size[1] << ", "
1793         << size[2] << ")"                        1798         << size[2] << ")"
1794         << G4endl;                               1799         << G4endl;
1795   }                                              1800   }
1796   kModality.setSize(size);                       1801   kModality.setSize(size);
1797                                                  1802 
1798   // modality image voxel spacing                1803   // modality image voxel spacing
1799   /*                                             1804   /*
1800     ifile.read(ctmp, 3*sizeof(float));           1805     ifile.read(ctmp, 3*sizeof(float));
1801     convertEndian(ctmp, modalityImageVoxelSpa    1806     convertEndian(ctmp, modalityImageVoxelSpacing[0]);
1802     convertEndian(ctmp+sizeof(float), modalit    1807     convertEndian(ctmp+sizeof(float), modalityImageVoxelSpacing[1]);
1803     convertEndian(ctmp+2*sizeof(float), modal    1808     convertEndian(ctmp+2*sizeof(float), modalityImageVoxelSpacing[2]);
1804   */                                             1809   */
1805                                                  1810 
1806   if(kPointerToModalityData != 0) {              1811   if(kPointerToModalityData != 0) {
1807                                                  1812 
1808     // modality density max. & min.              1813     // modality density max. & min.
1809     ifile.read((char *)ctmp, 4);                 1814     ifile.read((char *)ctmp, 4);
1810     convertEndian(ctmp, minmax[0]);              1815     convertEndian(ctmp, minmax[0]);
1811     convertEndian(ctmp+2, minmax[1]);            1816     convertEndian(ctmp+2, minmax[1]);
1812     kModality.setMinMax(minmax);                 1817     kModality.setMinMax(minmax);
1813                                                  1818 
1814     // modality image unit                       1819     // modality image unit
1815     char munit[13];                              1820     char munit[13];
1816     munit[12] = '\0';                            1821     munit[12] = '\0';
1817     ifile.read((char *)munit, 12);               1822     ifile.read((char *)munit, 12);
1818     std::string smunit = munit;                  1823     std::string smunit = munit;
1819     setModalityImageUnit(smunit);                1824     setModalityImageUnit(smunit);
1820                                                  1825 
1821     // modality density scale                    1826     // modality density scale
1822     ifile.read((char *)ctmp, 4);                 1827     ifile.read((char *)ctmp, 4);
1823     convertEndian(ctmp, scale);                  1828     convertEndian(ctmp, scale);
1824     kModality.setScale(dscale = scale);          1829     kModality.setScale(dscale = scale);
1825     if(DEBUG || kVerbose > 0) {                  1830     if(DEBUG || kVerbose > 0) {
1826       G4cout << "Modality image min., max., s    1831       G4cout << "Modality image min., max., scale : "
1827     << minmax[0] << ", "                         1832     << minmax[0] << ", "
1828     << minmax[1] << ", "                         1833     << minmax[1] << ", "
1829     << scale << G4endl;                          1834     << scale << G4endl;
1830     }                                            1835     }
1831                                                  1836 
1832     // modality density                          1837     // modality density
1833     int psize = size[0]*size[1];                 1838     int psize = size[0]*size[1];
1834     if(DEBUG || kVerbose > 0) G4cout << "Moda    1839     if(DEBUG || kVerbose > 0) G4cout << "Modality image (" << psize << "): ";
1835     char * cimage = new char[psize*sizeof(sho    1840     char * cimage = new char[psize*sizeof(short)];
1836     for(int i = 0; i < size[2]; i++) {           1841     for(int i = 0; i < size[2]; i++) {
1837       ifile.read((char *)cimage, psize*sizeof    1842       ifile.read((char *)cimage, psize*sizeof(short));
1838       short * mimage = new short[psize];         1843       short * mimage = new short[psize];
1839       for(int j = 0; j < psize; j++) {           1844       for(int j = 0; j < psize; j++) {
1840   convertEndian(cimage+j*sizeof(short), mimag    1845   convertEndian(cimage+j*sizeof(short), mimage[j]);
1841       }                                          1846       }
1842       kModality.addImage(mimage);                1847       kModality.addImage(mimage);
1843                                                  1848 
1844       if(DEBUG || kVerbose > 0) G4cout << "["    1849       if(DEBUG || kVerbose > 0) G4cout << "[" << i << "]" << mimage[(size_t)(psize*0.55)] << ", ";
1845     }                                            1850     }
1846     if(DEBUG || kVerbose > 0) G4cout << G4end    1851     if(DEBUG || kVerbose > 0) G4cout << G4endl;
1847     delete [] cimage;                            1852     delete [] cimage;
1848                                                  1853 
1849     // modality desity map for CT value          1854     // modality desity map for CT value
1850     size_t msize = minmax[1]-minmax[0]+1;        1855     size_t msize = minmax[1]-minmax[0]+1;
1851     if(DEBUG || kVerbose > 0) G4cout << "msiz    1856     if(DEBUG || kVerbose > 0) G4cout << "msize: " << msize << G4endl;
1852     char * pdmap = new char[msize*sizeof(floa    1857     char * pdmap = new char[msize*sizeof(float)];
1853     ifile.read((char *)pdmap, msize*sizeof(fl    1858     ifile.read((char *)pdmap, msize*sizeof(float));
1854     float ftmp;                                  1859     float ftmp;
1855     for(int i = 0; i < (int)msize; i++) {        1860     for(int i = 0; i < (int)msize; i++) {
1856       convertEndian(pdmap+i*sizeof(float), ft    1861       convertEndian(pdmap+i*sizeof(float), ftmp);
1857       kModalityImageDensityMap.push_back(ftmp    1862       kModalityImageDensityMap.push_back(ftmp); 
1858     }                                            1863     }
1859     delete [] pdmap;                             1864     delete [] pdmap;
1860                                                  1865 
1861     if(DEBUG || kVerbose > 0) {                  1866     if(DEBUG || kVerbose > 0) {
1862       G4cout << "density map : " << std::ends    1867       G4cout << "density map : " << std::ends;
1863       for(int i = 0; i < 10; i++)                1868       for(int i = 0; i < 10; i++)
1864   G4cout <<kModalityImageDensityMap[i] << ",     1869   G4cout <<kModalityImageDensityMap[i] << ", ";
1865       G4cout << G4endl;                          1870       G4cout << G4endl;
1866       for(int i = 0; i < 10; i++) G4cout << "    1871       for(int i = 0; i < 10; i++) G4cout << "..";
1867       G4cout << G4endl;                          1872       G4cout << G4endl;
1868       for(size_t i =kModalityImageDensityMap.    1873       for(size_t i =kModalityImageDensityMap.size() - 10; i <kModalityImageDensityMap.size(); i++)
1869   G4cout <<kModalityImageDensityMap[i] << ",     1874   G4cout <<kModalityImageDensityMap[i] << ", ";
1870       G4cout << G4endl;                          1875       G4cout << G4endl;
1871     }                                            1876     }
1872                                                  1877 
1873   }                                              1878   }
1874                                                  1879 
1875                                                  1880 
1876   //----- dose distribution image -----//        1881   //----- dose distribution image -----//
1877   for(int ndose = 0; ndose < nDoseDist; ndose    1882   for(int ndose = 0; ndose < nDoseDist; ndose++) {
1878                                                  1883 
1879     newDoseDist();                               1884     newDoseDist();
1880                                                  1885 
1881     // dose distrbution image size               1886     // dose distrbution image size
1882     ifile.read((char *)ctmp, 3*sizeof(int));     1887     ifile.read((char *)ctmp, 3*sizeof(int));
1883     convertEndian(ctmp, size[0]);                1888     convertEndian(ctmp, size[0]);
1884     convertEndian(ctmp+sizeof(int), size[1]);    1889     convertEndian(ctmp+sizeof(int), size[1]);
1885     convertEndian(ctmp+2*sizeof(int), size[2]    1890     convertEndian(ctmp+2*sizeof(int), size[2]);
1886     if(DEBUG || kVerbose > 0) {                  1891     if(DEBUG || kVerbose > 0) {
1887       G4cout << "Dose dist. image size : ("      1892       G4cout << "Dose dist. image size : ("
1888     << size[0] << ", "                           1893     << size[0] << ", "
1889     << size[1] << ", "                           1894     << size[1] << ", "
1890     << size[2] << ")"                            1895     << size[2] << ")"
1891     << G4endl;                                   1896     << G4endl;
1892     }                                            1897     }
1893     kDose[ndose].setSize(size);                  1898     kDose[ndose].setSize(size);
1894                                                  1899 
1895     // dose distribution max. & min.             1900     // dose distribution max. & min. 
1896     ifile.read((char *)ctmp, sizeof(short)*2)    1901     ifile.read((char *)ctmp, sizeof(short)*2);
1897     convertEndian(ctmp, minmax[0]);              1902     convertEndian(ctmp, minmax[0]);
1898     convertEndian(ctmp+2, minmax[1]);            1903     convertEndian(ctmp+2, minmax[1]);
1899                                                  1904 
1900     // dose distribution unit                    1905     // dose distribution unit
1901     char dunit[13];                              1906     char dunit[13];
1902     dunit[12] = '\0';                            1907     dunit[12] = '\0';
1903     ifile.read((char *)dunit, 12);               1908     ifile.read((char *)dunit, 12);
1904     std::string sdunit = dunit;                  1909     std::string sdunit = dunit;
1905     setDoseDistUnit(sdunit, ndose);              1910     setDoseDistUnit(sdunit, ndose);
1906     if(DEBUG || kVerbose > 0) {                  1911     if(DEBUG || kVerbose > 0) {
1907       G4cout << "Dose dist. unit : " << kDose    1912       G4cout << "Dose dist. unit : " << kDoseUnit << G4endl;
1908     }                                            1913     }
1909                                                  1914 
1910     // dose distribution scaling                 1915     // dose distribution scaling 
1911     ifile.read((char *)ctmp, 4); // sizeof(fl    1916     ifile.read((char *)ctmp, 4); // sizeof(float)
1912     convertEndian(ctmp, scale);                  1917     convertEndian(ctmp, scale);
1913     kDose[ndose].setScale(dscale = scale);       1918     kDose[ndose].setScale(dscale = scale);
1914                                                  1919 
1915     double dminmax[2];                           1920     double dminmax[2];
1916     for(int i = 0; i < 2; i++) dminmax[i] = m    1921     for(int i = 0; i < 2; i++) dminmax[i] = minmax[i]*dscale;
1917     kDose[ndose].setMinMax(dminmax);             1922     kDose[ndose].setMinMax(dminmax);
1918                                                  1923 
1919     if(DEBUG || kVerbose > 0) {                  1924     if(DEBUG || kVerbose > 0) {
1920       G4cout << "Dose dist. image min., max.,    1925       G4cout << "Dose dist. image min., max., scale : "
1921     << dminmax[0] << ", "                        1926     << dminmax[0] << ", "
1922     << dminmax[1] << ", "                        1927     << dminmax[1] << ", "
1923     << scale << G4endl;                          1928     << scale << G4endl;
1924     }                                            1929     }
1925                                                  1930 
1926     // dose distribution image                   1931     // dose distribution image
1927     int dsize = size[0]*size[1];                 1932     int dsize = size[0]*size[1];
1928     if(DEBUG || kVerbose > 0) G4cout << "Dose    1933     if(DEBUG || kVerbose > 0) G4cout << "Dose dist. (" << dsize << "): ";
1929     char * di = new char[dsize*sizeof(short)]    1934     char * di = new char[dsize*sizeof(short)];
1930     short * shimage = new short[dsize];          1935     short * shimage = new short[dsize];
1931     for(int z = 0; z < size[2]; z++) {           1936     for(int z = 0; z < size[2]; z++) {
1932       ifile.read((char *)di, dsize*sizeof(sho    1937       ifile.read((char *)di, dsize*sizeof(short));
1933       double * dimage = new double[dsize];       1938       double * dimage = new double[dsize];
1934       for(int xy = 0; xy < dsize; xy++) {        1939       for(int xy = 0; xy < dsize; xy++) {
1935   convertEndian(di+xy*sizeof(short), shimage[    1940   convertEndian(di+xy*sizeof(short), shimage[xy]);
1936   dimage[xy] = shimage[xy]*dscale;               1941   dimage[xy] = shimage[xy]*dscale;
1937       }                                          1942       }
1938       kDose[ndose].addImage(dimage);             1943       kDose[ndose].addImage(dimage);
1939                                                  1944 
1940       if(DEBUG || kVerbose > 0) G4cout << "["    1945       if(DEBUG || kVerbose > 0) G4cout << "[" << z << "]" << dimage[(size_t)(dsize*0.55)] << ", ";
1941                                                  1946 
1942       if(DEBUG || kVerbose > 0) {                1947       if(DEBUG || kVerbose > 0) {
1943   for(int j = 0; j < dsize; j++) {               1948   for(int j = 0; j < dsize; j++) {
1944     if(dimage[j] < 0)                            1949     if(dimage[j] < 0)
1945       G4cout << "[" << j << "," << z << "]"      1950       G4cout << "[" << j << "," << z << "]"
1946           << dimage[j] << ", ";                  1951           << dimage[j] << ", ";
1947   }                                              1952   }
1948       }                                          1953       }
1949     }                                            1954     }
1950     delete [] shimage;                           1955     delete [] shimage;
1951     delete [] di;                                1956     delete [] di;
1952     if(DEBUG || kVerbose > 0) G4cout << G4end    1957     if(DEBUG || kVerbose > 0) G4cout << G4endl;
1953                                                  1958 
1954     ifile.read((char *)ctmp, 3*4); // 3*sizeo    1959     ifile.read((char *)ctmp, 3*4); // 3*sizeof(int)
1955     convertEndian(ctmp, iCenter[0]);             1960     convertEndian(ctmp, iCenter[0]);
1956     convertEndian(ctmp+4, iCenter[1]);           1961     convertEndian(ctmp+4, iCenter[1]);
1957     convertEndian(ctmp+8, iCenter[2]);           1962     convertEndian(ctmp+8, iCenter[2]);
1958     for(int i = 0; i < 3; i++) fCenter[i] = (    1963     for(int i = 0; i < 3; i++) fCenter[i] = (float)iCenter[i];
1959     kDose[ndose].setCenterPosition(fCenter);     1964     kDose[ndose].setCenterPosition(fCenter);
1960                                                  1965 
1961     if(DEBUG || kVerbose > 0) {                  1966     if(DEBUG || kVerbose > 0) {
1962       G4cout << "Dose dist. image relative lo    1967       G4cout << "Dose dist. image relative location : ("
1963     << fCenter[0] << ", "                        1968     << fCenter[0] << ", "
1964     << fCenter[1] << ", "                        1969     << fCenter[1] << ", "
1965     << fCenter[2] << ")" << G4endl;              1970     << fCenter[2] << ")" << G4endl;
1966     }                                            1971     }
1967                                                  1972 
1968                                                  1973 
1969     // dose distribution name                    1974     // dose distribution name
1970     char cname[81];                              1975     char cname[81];
1971     ifile.read((char *)cname, 80);               1976     ifile.read((char *)cname, 80);
1972     std::string dosename = cname;                1977     std::string dosename = cname;
1973     setDoseDistName(dosename, ndose);            1978     setDoseDistName(dosename, ndose);
1974     if(DEBUG || kVerbose > 0) {                  1979     if(DEBUG || kVerbose > 0) {
1975       G4cout << "Dose dist. name : " << dosen    1980       G4cout << "Dose dist. name : " << dosename << G4endl;
1976     }                                            1981     }
1977                                                  1982 
1978   }                                              1983   }
1979                                                  1984 
1980   //----- ROI image -----//                      1985   //----- ROI image -----//
1981   if(kPointerToROIData != 0) {                   1986   if(kPointerToROIData != 0) {
1982                                                  1987 
1983     newROI();                                    1988     newROI();
1984                                                  1989 
1985     // ROI image size                            1990     // ROI image size
1986     ifile.read((char *)ctmp, 3*sizeof(int));     1991     ifile.read((char *)ctmp, 3*sizeof(int));
1987     convertEndian(ctmp, size[0]);                1992     convertEndian(ctmp, size[0]);
1988     convertEndian(ctmp+sizeof(int), size[1]);    1993     convertEndian(ctmp+sizeof(int), size[1]);
1989     convertEndian(ctmp+2*sizeof(int), size[2]    1994     convertEndian(ctmp+2*sizeof(int), size[2]);
1990     kRoi[0].setSize(size);                       1995     kRoi[0].setSize(size);
1991     if(DEBUG || kVerbose > 0) {                  1996     if(DEBUG || kVerbose > 0) {
1992       G4cout << "ROI image size : ("             1997       G4cout << "ROI image size : ("
1993     << size[0] << ", "                           1998     << size[0] << ", "
1994     << size[1] << ", "                           1999     << size[1] << ", "
1995     << size[2] << ")"                            2000     << size[2] << ")"
1996     << G4endl;                                   2001     << G4endl;
1997     }                                            2002     }
1998                                                  2003 
1999     // ROI max. & min.                           2004     // ROI max. & min.
2000     ifile.read((char *)ctmp, sizeof(short)*2)    2005     ifile.read((char *)ctmp, sizeof(short)*2);
2001     convertEndian(ctmp, minmax[0]);              2006     convertEndian(ctmp, minmax[0]);
2002     convertEndian(ctmp+sizeof(short), minmax[    2007     convertEndian(ctmp+sizeof(short), minmax[1]);
2003     kRoi[0].setMinMax(minmax);                   2008     kRoi[0].setMinMax(minmax);
2004                                                  2009 
2005     // ROI distribution scaling                  2010     // ROI distribution scaling 
2006     ifile.read((char *)ctmp, sizeof(float));     2011     ifile.read((char *)ctmp, sizeof(float));
2007     convertEndian(ctmp, scale);                  2012     convertEndian(ctmp, scale);
2008     kRoi[0].setScale(dscale = scale);            2013     kRoi[0].setScale(dscale = scale);
2009     if(DEBUG || kVerbose > 0) {                  2014     if(DEBUG || kVerbose > 0) {
2010       G4cout << "ROI image min., max., scale     2015       G4cout << "ROI image min., max., scale : "
2011     << minmax[0] << ", "                         2016     << minmax[0] << ", "
2012     << minmax[1] << ", "                         2017     << minmax[1] << ", "
2013     << scale << G4endl;                          2018     << scale << G4endl;
2014     }                                            2019     }
2015                                                  2020 
2016     // ROI image                                 2021     // ROI image
2017     int rsize = size[0]*size[1];                 2022     int rsize = size[0]*size[1];
2018     char * ri = new char[rsize*sizeof(short)]    2023     char * ri = new char[rsize*sizeof(short)];
2019     for(int i = 0; i < size[2]; i++) {           2024     for(int i = 0; i < size[2]; i++) {
2020       ifile.read((char *)ri, rsize*sizeof(sho    2025       ifile.read((char *)ri, rsize*sizeof(short));
2021       short * rimage = new short[rsize];         2026       short * rimage = new short[rsize];
2022       for(int j = 0; j < rsize; j++) {           2027       for(int j = 0; j < rsize; j++) {
2023   convertEndian(ri+j*sizeof(short), rimage[j]    2028   convertEndian(ri+j*sizeof(short), rimage[j]);
2024       }                                          2029       }
2025       kRoi[0].addImage(rimage);                  2030       kRoi[0].addImage(rimage);
2026                                                  2031 
2027     }                                            2032     }
2028     delete [] ri;                                2033     delete [] ri;
2029                                                  2034 
2030     // ROI relative location                     2035     // ROI relative location
2031     ifile.read((char *)ctmp, 3*sizeof(int));     2036     ifile.read((char *)ctmp, 3*sizeof(int));
2032     convertEndian(ctmp, iCenter[0]);             2037     convertEndian(ctmp, iCenter[0]);
2033     convertEndian(ctmp+sizeof(int), iCenter[1    2038     convertEndian(ctmp+sizeof(int), iCenter[1]);
2034     convertEndian(ctmp+2*sizeof(int), iCenter    2039     convertEndian(ctmp+2*sizeof(int), iCenter[2]);
2035     for(int i = 0; i < 3; i++) fCenter[i] = i    2040     for(int i = 0; i < 3; i++) fCenter[i] = iCenter[i];
2036     kRoi[0].setCenterPosition(fCenter);          2041     kRoi[0].setCenterPosition(fCenter);
2037     if(DEBUG || kVerbose > 0) {                  2042     if(DEBUG || kVerbose > 0) {
2038       G4cout << "ROI image relative location     2043       G4cout << "ROI image relative location : ("
2039     << fCenter[0] << ", "                        2044     << fCenter[0] << ", "
2040     << fCenter[1] << ", "                        2045     << fCenter[1] << ", "
2041     << fCenter[2] << ")" << G4endl;              2046     << fCenter[2] << ")" << G4endl;
2042     }                                            2047     }
2043                                                  2048 
2044   }                                              2049   }
2045                                                  2050 
2046   //----- track information -----//              2051   //----- track information -----//
2047   if(kPointerToTrackData != 0) {                 2052   if(kPointerToTrackData != 0) {
2048                                                  2053 
2049     // track                                     2054     // track
2050     ifile.read((char *)ctmp, sizeof(int));       2055     ifile.read((char *)ctmp, sizeof(int));
2051     int ntrk;                                    2056     int ntrk;
2052     convertEndian(ctmp, ntrk);                   2057     convertEndian(ctmp, ntrk);
2053     if(DEBUG || kVerbose > 0) {                  2058     if(DEBUG || kVerbose > 0) {
2054       G4cout << "# of tracks: " << ntrk << G4    2059       G4cout << "# of tracks: " << ntrk << G4endl;
2055     }                                            2060     }
2056                                                  2061 
2057     // track position                            2062     // track position
2058     unsigned char rgb[3];                        2063     unsigned char rgb[3];
2059     for(int i = 0; i < ntrk; i++) {              2064     for(int i = 0; i < ntrk; i++) {
2060                                                  2065 
2061                                                  2066 
2062       // # of steps in a track                   2067       // # of steps in a track
2063       ifile.read((char *)ctmp, sizeof(int));     2068       ifile.read((char *)ctmp, sizeof(int));
2064       int nsteps;                                2069       int nsteps;
2065       convertEndian(ctmp, nsteps);               2070       convertEndian(ctmp, nsteps);
2066                                                  2071       
2067       // track color                             2072       // track color
2068       ifile.read((char *)rgb, 3);                2073       ifile.read((char *)rgb, 3);
2069                                                  2074 
2070       std::vector<float *> steps;                2075       std::vector<float *> steps;
2071       // steps                                   2076       // steps
2072       for(int j = 0; j < nsteps; j++) {          2077       for(int j = 0; j < nsteps; j++) {
2073                                                  2078 
2074   float * steppoint = new float[6];              2079   float * steppoint = new float[6];
2075   ifile.read((char *)ctmp, sizeof(float)*6);     2080   ifile.read((char *)ctmp, sizeof(float)*6);
2076                                                  2081 
2077   for(int k = 0; k < 6; k++) {                   2082   for(int k = 0; k < 6; k++) {
2078     convertEndian(ctmp+k*sizeof(float), stepp    2083     convertEndian(ctmp+k*sizeof(float), steppoint[k]);
2079   }                                              2084   }
2080                                                  2085   
2081   steps.push_back(steppoint);                    2086   steps.push_back(steppoint);
2082       }                                          2087       }
2083                                                  2088 
2084       // add a track to the track container      2089       // add a track to the track container
2085       addTrack(steps, rgb);                      2090       addTrack(steps, rgb);
2086                                                  2091 
2087       if(DEBUG || kVerbose > 0) {                2092       if(DEBUG || kVerbose > 0) {
2088   if(i < 5) {                                    2093   if(i < 5) {
2089     G4cout << i << ": " ;                        2094     G4cout << i << ": " ;
2090     for(int j = 0; j < 3; j++) G4cout << step    2095     for(int j = 0; j < 3; j++) G4cout << steps[0][j] << " ";
2091     int nstp = (int)steps.size();             << 2096     int nstp = steps.size();
2092     G4cout << "<-> ";                            2097     G4cout << "<-> ";
2093     for(int j = 3; j < 6; j++) G4cout << step    2098     for(int j = 3; j < 6; j++) G4cout << steps[nstp-1][j] << " ";
2094     G4cout << "    rgb( ";                       2099     G4cout << "    rgb( ";
2095     for(int j = 0; j < 3; j++) G4cout << (int    2100     for(int j = 0; j < 3; j++) G4cout << (int)rgb[j] << " ";
2096     G4cout << ")" << G4endl;                     2101     G4cout << ")" << G4endl;
2097   }                                              2102   }
2098       }                                          2103       }
2099     }                                            2104     }
2100                                                  2105 
2101                                                  2106 
2102   }                                              2107   }
2103                                                  2108 
2104                                                  2109 
2105   //----- detector information -----//           2110   //----- detector information -----//
2106   if(kPointerToDetectorData != 0) {              2111   if(kPointerToDetectorData != 0) {
2107                                                  2112 
2108     // number of detectors                       2113     // number of detectors
2109     ifile.read((char *)ctmp, sizeof(int));       2114     ifile.read((char *)ctmp, sizeof(int));
2110     int ndet;                                    2115     int ndet;
2111     convertEndian(ctmp, ndet);                   2116     convertEndian(ctmp, ndet);
2112                                                  2117 
2113     if(DEBUG || kVerbose > 0) {                  2118     if(DEBUG || kVerbose > 0) {
2114       G4cout << "# of detectors : "              2119       G4cout << "# of detectors : "
2115     << ndet << G4endl;                           2120     << ndet << G4endl;
2116     }                                            2121     }
2117                                                  2122 
2118     for(int nd = 0; nd < ndet; nd++) {           2123     for(int nd = 0; nd < ndet; nd++) {
2119                                                  2124 
2120       // # of edges of a detector                2125       // # of edges of a detector
2121       ifile.read((char *)ctmp, sizeof(int));     2126       ifile.read((char *)ctmp, sizeof(int));
2122       int nedges;                                2127       int nedges;
2123       convertEndian(ctmp, nedges);               2128       convertEndian(ctmp, nedges);
2124       if(DEBUG || kVerbose > 0) {                2129       if(DEBUG || kVerbose > 0) {
2125   G4cout << "# of edges in a detector : " <<     2130   G4cout << "# of edges in a detector : " << nedges << G4endl;
2126       }                                          2131       }
2127                                                  2132 
2128       // edges                                   2133       // edges
2129       std::vector<float *> detector;             2134       std::vector<float *> detector;
2130       char cftmp[24];                            2135       char cftmp[24];
2131       for(int ne = 0; ne < nedges; ne++) {       2136       for(int ne = 0; ne < nedges; ne++) {
2132                                                  2137       
2133   ifile.read((char *)cftmp, sizeof(float)*6);    2138   ifile.read((char *)cftmp, sizeof(float)*6);
2134   float * edgePoints = new float[6];             2139   float * edgePoints = new float[6];
2135   for(int j = 0; j < 6; j++) convertEndian(&c    2140   for(int j = 0; j < 6; j++) convertEndian(&cftmp[sizeof(float)*j], edgePoints[j]);
2136   detector.push_back(edgePoints);                2141   detector.push_back(edgePoints);
2137                                                  2142 
2138       }                                          2143       }
2139                                                  2144 
2140       if(DEBUG || kVerbose > 0) {                2145       if(DEBUG || kVerbose > 0) {
2141   G4cout << " first edge : (" << detector[0][    2146   G4cout << " first edge : (" << detector[0][0] << ", "
2142       << detector[0][1] << ", "                  2147       << detector[0][1] << ", "
2143       << detector[0][2] << ") - ("               2148       << detector[0][2] << ") - ("
2144       << detector[0][3] << ", "                  2149       << detector[0][3] << ", "
2145       << detector[0][4] << ", "                  2150       << detector[0][4] << ", "
2146       << detector[0][5] << ")" << G4endl;        2151       << detector[0][5] << ")" << G4endl;
2147       }                                          2152       }
2148                                                  2153 
2149       // detector color                          2154       // detector color
2150       unsigned char dcolor[3];                   2155       unsigned char dcolor[3];
2151       ifile.read((char *)dcolor, 3);             2156       ifile.read((char *)dcolor, 3);
2152       if(DEBUG || kVerbose > 0) {                2157       if(DEBUG || kVerbose > 0) {
2153   G4cout << " detector color : rgb("             2158   G4cout << " detector color : rgb("
2154       << (int)dcolor[0] << ", "                  2159       << (int)dcolor[0] << ", "
2155       << (int)dcolor[1] << ", "                  2160       << (int)dcolor[1] << ", "
2156       << (int)dcolor[2] << G4endl;               2161       << (int)dcolor[2] << G4endl;
2157       }                                          2162       }
2158                                                  2163 
2159                                                  2164 
2160       // detector name                           2165       // detector name
2161       char cname[80];                            2166       char cname[80];
2162       ifile.read((char *)cname, 80);             2167       ifile.read((char *)cname, 80);
2163       std::string dname = cname;                 2168       std::string dname = cname;
2164       if(DEBUG || kVerbose > 0) {                2169       if(DEBUG || kVerbose > 0) {
2165   G4cout << " detector name : " << dname << G    2170   G4cout << " detector name : " << dname << G4endl;
2166       }                                          2171       }
2167                                                  2172 
2168                                                  2173 
2169       addDetector(dname, detector, dcolor);      2174       addDetector(dname, detector, dcolor);
2170                                                  2175 
2171     }                                            2176     }
2172   }                                              2177   }
2173                                                  2178 
2174                                                  2179 
2175   ifile.close();                                 2180   ifile.close();
2176                                                  2181 
2177   return true;                                   2182   return true;
2178 }                                                2183 }
2179 bool G4GMocrenIO::retrieveData4(char * _filen    2184 bool G4GMocrenIO::retrieveData4(char * _filename) {
2180   kFileName = _filename;                         2185   kFileName = _filename;
2181   return retrieveData();                         2186   return retrieveData();
2182 }                                                2187 }
2183                                                  2188 
2184 //                                               2189 // 
2185 bool G4GMocrenIO::retrieveData3() {              2190 bool G4GMocrenIO::retrieveData3() {
2186                                                  2191 
2187   bool DEBUG = false;//                          2192   bool DEBUG = false;//
2188                                                  2193 
2189   // input file open                             2194   // input file open
2190   std::ifstream ifile(kFileName.c_str(), std:    2195   std::ifstream ifile(kFileName.c_str(), std::ios_base::in|std::ios_base::binary);
2191   if(!ifile) {                                   2196   if(!ifile) {
2192     if (G4VisManager::GetVerbosity() >= G4Vis    2197     if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
2193       G4cout << "Cannot open file: " << kFile    2198       G4cout << "Cannot open file: " << kFileName
2194     << " in G4GMocrenIO::retrieveData3()." <<    2199     << " in G4GMocrenIO::retrieveData3()." << G4endl;
2195     return false;                                2200     return false;
2196   }                                              2201   }
2197                                                  2202 
2198   // data buffer                                 2203   // data buffer
2199   char ctmp[12];                                 2204   char ctmp[12];
2200                                                  2205 
2201   // file identifier                             2206   // file identifier
2202   char verid[9];                                 2207   char verid[9];
2203   ifile.read((char *)verid, 8);                  2208   ifile.read((char *)verid, 8);
2204                                                  2209 
2205   // file version                                2210   // file version
2206   unsigned char ver;                             2211   unsigned char ver;
2207   ifile.read((char *)&ver, 1);                   2212   ifile.read((char *)&ver, 1);
2208   std::stringstream ss;                          2213   std::stringstream ss;
2209   ss << (int)ver;                                2214   ss << (int)ver;
2210   kVersion = ss.str();                           2215   kVersion = ss.str();
2211   if(DEBUG || kVerbose > 0) G4cout << "File v    2216   if(DEBUG || kVerbose > 0) G4cout << "File version : " << kVersion << G4endl;
2212                                                  2217 
2213   // endian                                      2218   // endian
2214   ifile.read((char *)&kLittleEndianInput, siz    2219   ifile.read((char *)&kLittleEndianInput, sizeof(char));
2215   if(DEBUG || kVerbose > 0) {                    2220   if(DEBUG || kVerbose > 0) {
2216     G4cout << "Endian : ";                       2221     G4cout << "Endian : ";
2217     if(kLittleEndianInput == 1)                  2222     if(kLittleEndianInput == 1) 
2218       G4cout << " little" << G4endl;             2223       G4cout << " little" << G4endl;
2219     else {                                       2224     else {
2220       G4cout << " big" << G4endl;                2225       G4cout << " big" << G4endl;
2221     }                                            2226     }
2222   }                                              2227   }
2223                                                  2228 
2224   // comment length (fixed size)                 2229   // comment length (fixed size)
2225   int clength;                                   2230   int clength;
2226   ifile.read((char *)ctmp, 4);                   2231   ifile.read((char *)ctmp, 4);
2227   convertEndian(ctmp, clength);                  2232   convertEndian(ctmp, clength);
2228   // comment                                     2233   // comment
2229   char cmt[1025];                                2234   char cmt[1025];
2230   ifile.read((char *)cmt, clength);              2235   ifile.read((char *)cmt, clength);
2231   std::string scmt = cmt;                        2236   std::string scmt = cmt;
2232   setComment(scmt);                              2237   setComment(scmt);
2233   if(DEBUG || kVerbose > 0) {                    2238   if(DEBUG || kVerbose > 0) {
2234     G4cout << "Data comment : "                  2239     G4cout << "Data comment : "
2235         << kComment << G4endl;                   2240         << kComment << G4endl;
2236   }                                              2241   }
2237                                                  2242 
2238   // voxel spacings for all images               2243   // voxel spacings for all images
2239   ifile.read((char *)ctmp, 12);                  2244   ifile.read((char *)ctmp, 12);
2240   convertEndian(ctmp, kVoxelSpacing[0]);         2245   convertEndian(ctmp, kVoxelSpacing[0]);
2241   convertEndian(ctmp+4, kVoxelSpacing[1]);       2246   convertEndian(ctmp+4, kVoxelSpacing[1]);
2242   convertEndian(ctmp+8, kVoxelSpacing[2]);       2247   convertEndian(ctmp+8, kVoxelSpacing[2]);
2243   if(DEBUG || kVerbose > 0) {                    2248   if(DEBUG || kVerbose > 0) {
2244     G4cout << "Voxel spacing : ("                2249     G4cout << "Voxel spacing : ("
2245         << kVoxelSpacing[0] << ", "              2250         << kVoxelSpacing[0] << ", "
2246         << kVoxelSpacing[1] << ", "              2251         << kVoxelSpacing[1] << ", "
2247         << kVoxelSpacing[2]                      2252         << kVoxelSpacing[2]
2248         << ") mm " << G4endl;                    2253         << ") mm " << G4endl;
2249   }                                              2254   }
2250                                                  2255 
2251                                                  2256 
2252   // offset from file starting point to the m    2257   // offset from file starting point to the modality image data
2253   ifile.read((char *)ctmp, 4);                   2258   ifile.read((char *)ctmp, 4);
2254   convertEndian(ctmp, kPointerToModalityData)    2259   convertEndian(ctmp, kPointerToModalityData);
2255                                                  2260 
2256   // # of dose distributions                     2261   // # of dose distributions
2257   ifile.read((char *)ctmp, 4);                   2262   ifile.read((char *)ctmp, 4);
2258   int nDoseDist;                                 2263   int nDoseDist;
2259   convertEndian(ctmp, nDoseDist);                2264   convertEndian(ctmp, nDoseDist);
2260                                                  2265   
2261   // offset from file starting point to the d    2266   // offset from file starting point to the dose image data
2262   for(int i = 0; i < nDoseDist; i++) {           2267   for(int i = 0; i < nDoseDist; i++) {
2263     ifile.read((char *)ctmp, 4);                 2268     ifile.read((char *)ctmp, 4);
2264     unsigned int dptr;                           2269     unsigned int dptr;
2265     convertEndian(ctmp, dptr);                   2270     convertEndian(ctmp, dptr);
2266     addPointerToDoseDistData(dptr);              2271     addPointerToDoseDistData(dptr);
2267   }                                              2272   }
2268                                                  2273 
2269   // offset from file starting point to the R    2274   // offset from file starting point to the ROI image data
2270   ifile.read((char *)ctmp, 4);                   2275   ifile.read((char *)ctmp, 4);
2271   convertEndian(ctmp, kPointerToROIData);        2276   convertEndian(ctmp, kPointerToROIData);
2272                                                  2277 
2273   // offset from file starting point to the t    2278   // offset from file starting point to the track data
2274   ifile.read((char *)ctmp, 4);                   2279   ifile.read((char *)ctmp, 4);
2275   convertEndian(ctmp, kPointerToTrackData);      2280   convertEndian(ctmp, kPointerToTrackData);
2276   if(DEBUG || kVerbose > 0) {                    2281   if(DEBUG || kVerbose > 0) {
2277     G4cout << "Each pointer to data : "          2282     G4cout << "Each pointer to data : "
2278         << kPointerToModalityData << ", ";       2283         << kPointerToModalityData << ", ";
2279     for(int i = 0; i < nDoseDist; i++)           2284     for(int i = 0; i < nDoseDist; i++)
2280       G4cout << kPointerToDoseDistData[0] <<     2285       G4cout << kPointerToDoseDistData[0] << ", ";
2281     G4cout << kPointerToROIData << ", "          2286     G4cout << kPointerToROIData << ", "
2282         << kPointerToTrackData << G4endl;        2287         << kPointerToTrackData << G4endl;
2283   }                                              2288   }
2284                                                  2289 
2285   if(kPointerToModalityData == 0 && kPointerT    2290   if(kPointerToModalityData == 0 && kPointerToDoseDistData.size() == 0 &&
2286      kPointerToROIData == 0 && kPointerToTrac    2291      kPointerToROIData == 0 && kPointerToTrackData == 0) {
2287     if(DEBUG || kVerbose > 0) {                  2292     if(DEBUG || kVerbose > 0) {
2288       G4cout << "No data." << G4endl;            2293       G4cout << "No data." << G4endl;
2289     }                                            2294     }
2290     return false;                                2295     return false;
2291   }                                              2296   }
2292                                                  2297 
2293   // event number                                2298   // event number
2294   /* ver 1                                       2299   /* ver 1
2295      ifile.read(ctmp, sizeof(int));              2300      ifile.read(ctmp, sizeof(int));
2296      convertEndian(ctmp, numberOfEvents);        2301      convertEndian(ctmp, numberOfEvents);
2297   */                                             2302   */
2298                                                  2303 
2299   int size[3];                                   2304   int size[3];
2300   float scale;                                   2305   float scale;
2301   double dscale;                                 2306   double dscale;
2302   short minmax[2];                               2307   short minmax[2];
2303   float fCenter[3];                              2308   float fCenter[3];
2304   int iCenter[3];                                2309   int iCenter[3];
2305                                                  2310 
2306   //----- Modality image -----//                 2311   //----- Modality image -----//
2307   // modality image size                         2312   // modality image size
2308   ifile.read(ctmp, 3*sizeof(int));               2313   ifile.read(ctmp, 3*sizeof(int));
2309   convertEndian(ctmp, size[0]);                  2314   convertEndian(ctmp, size[0]);
2310   convertEndian(ctmp+sizeof(int), size[1]);      2315   convertEndian(ctmp+sizeof(int), size[1]);
2311   convertEndian(ctmp+2*sizeof(int), size[2]);    2316   convertEndian(ctmp+2*sizeof(int), size[2]);
2312   if(DEBUG || kVerbose > 0) {                    2317   if(DEBUG || kVerbose > 0) {
2313     G4cout << "Modality image size : ("          2318     G4cout << "Modality image size : ("
2314         << size[0] << ", "                       2319         << size[0] << ", "
2315         << size[1] << ", "                       2320         << size[1] << ", "
2316         << size[2] << ")"                        2321         << size[2] << ")"
2317         << G4endl;                               2322         << G4endl;
2318   }                                              2323   }
2319   kModality.setSize(size);                       2324   kModality.setSize(size);
2320                                                  2325 
2321   // modality image voxel spacing                2326   // modality image voxel spacing
2322   /*                                             2327   /*
2323     ifile.read(ctmp, 3*sizeof(float));           2328     ifile.read(ctmp, 3*sizeof(float));
2324     convertEndian(ctmp, modalityImageVoxelSpa    2329     convertEndian(ctmp, modalityImageVoxelSpacing[0]);
2325     convertEndian(ctmp+sizeof(float), modalit    2330     convertEndian(ctmp+sizeof(float), modalityImageVoxelSpacing[1]);
2326     convertEndian(ctmp+2*sizeof(float), modal    2331     convertEndian(ctmp+2*sizeof(float), modalityImageVoxelSpacing[2]);
2327   */                                             2332   */
2328                                                  2333 
2329   if(kPointerToModalityData != 0) {              2334   if(kPointerToModalityData != 0) {
2330                                                  2335 
2331     // modality density max. & min.              2336     // modality density max. & min.
2332     ifile.read((char *)ctmp, 4);                 2337     ifile.read((char *)ctmp, 4);
2333     convertEndian(ctmp, minmax[0]);              2338     convertEndian(ctmp, minmax[0]);
2334     convertEndian(ctmp+2, minmax[1]);            2339     convertEndian(ctmp+2, minmax[1]);
2335     kModality.setMinMax(minmax);                 2340     kModality.setMinMax(minmax);
2336                                                  2341 
2337     // modality image unit                       2342     // modality image unit
2338     char munit[13];                              2343     char munit[13];
2339     ifile.read((char *)munit, 12);               2344     ifile.read((char *)munit, 12);
2340     std::string smunit = munit;                  2345     std::string smunit = munit;
2341     setModalityImageUnit(smunit);                2346     setModalityImageUnit(smunit);
2342                                                  2347 
2343     // modality density scale                    2348     // modality density scale
2344     ifile.read((char *)ctmp, 4);                 2349     ifile.read((char *)ctmp, 4);
2345     convertEndian(ctmp, scale);                  2350     convertEndian(ctmp, scale);
2346     kModality.setScale(dscale = scale);          2351     kModality.setScale(dscale = scale);
2347     if(DEBUG || kVerbose > 0) {                  2352     if(DEBUG || kVerbose > 0) {
2348       G4cout << "Modality image min., max., s    2353       G4cout << "Modality image min., max., scale : "
2349     << minmax[0] << ", "                         2354     << minmax[0] << ", "
2350     << minmax[1] << ", "                         2355     << minmax[1] << ", "
2351     << scale << G4endl;                          2356     << scale << G4endl;
2352     }                                            2357     }
2353                                                  2358 
2354     // modality density                          2359     // modality density
2355     int psize = size[0]*size[1];                 2360     int psize = size[0]*size[1];
2356     if(DEBUG || kVerbose > 0) G4cout << "Moda    2361     if(DEBUG || kVerbose > 0) G4cout << "Modality image (" << psize << "): ";
2357     char * cimage = new char[psize*sizeof(sho    2362     char * cimage = new char[psize*sizeof(short)];
2358     for(int i = 0; i < size[2]; i++) {           2363     for(int i = 0; i < size[2]; i++) {
2359       ifile.read((char *)cimage, psize*sizeof    2364       ifile.read((char *)cimage, psize*sizeof(short));
2360       short * mimage = new short[psize];         2365       short * mimage = new short[psize];
2361       for(int j = 0; j < psize; j++) {           2366       for(int j = 0; j < psize; j++) {
2362   convertEndian(cimage+j*sizeof(short), mimag    2367   convertEndian(cimage+j*sizeof(short), mimage[j]);
2363       }                                          2368       }
2364       kModality.addImage(mimage);                2369       kModality.addImage(mimage);
2365                                                  2370 
2366       if(DEBUG || kVerbose > 0) G4cout << "["    2371       if(DEBUG || kVerbose > 0) G4cout << "[" << i << "]" << mimage[(size_t)(psize*0.55)] << ", ";
2367     }                                            2372     }
2368     if(DEBUG || kVerbose > 0) G4cout << G4end    2373     if(DEBUG || kVerbose > 0) G4cout << G4endl;
2369     delete [] cimage;                            2374     delete [] cimage;
2370                                                  2375 
2371     // modality desity map for CT value          2376     // modality desity map for CT value
2372     size_t msize = minmax[1]-minmax[0]+1;        2377     size_t msize = minmax[1]-minmax[0]+1;
2373     if(DEBUG || kVerbose > 0) G4cout << "msiz    2378     if(DEBUG || kVerbose > 0) G4cout << "msize: " << msize << G4endl;
2374     char * pdmap = new char[msize*sizeof(floa    2379     char * pdmap = new char[msize*sizeof(float)];
2375     ifile.read((char *)pdmap, msize*sizeof(fl    2380     ifile.read((char *)pdmap, msize*sizeof(float));
2376     float ftmp;                                  2381     float ftmp;
2377     for(int i = 0; i < (int)msize; i++) {        2382     for(int i = 0; i < (int)msize; i++) {
2378       convertEndian(pdmap+i*sizeof(float), ft    2383       convertEndian(pdmap+i*sizeof(float), ftmp);
2379       kModalityImageDensityMap.push_back(ftmp    2384       kModalityImageDensityMap.push_back(ftmp); 
2380     }                                            2385     }
2381     delete [] pdmap;                             2386     delete [] pdmap;
2382     if(DEBUG || kVerbose > 0) {                  2387     if(DEBUG || kVerbose > 0) {
2383       G4cout << "density map : " << std::ends    2388       G4cout << "density map : " << std::ends;
2384       for(int i = 0; i < 10; i++)                2389       for(int i = 0; i < 10; i++)
2385   G4cout <<kModalityImageDensityMap[i] << ",     2390   G4cout <<kModalityImageDensityMap[i] << ", ";
2386       G4cout << G4endl;                          2391       G4cout << G4endl;
2387       for(int i = 0; i < 10; i++) G4cout << "    2392       for(int i = 0; i < 10; i++) G4cout << "..";
2388       G4cout << G4endl;                          2393       G4cout << G4endl;
2389       for(size_t i =kModalityImageDensityMap.    2394       for(size_t i =kModalityImageDensityMap.size() - 10; i <kModalityImageDensityMap.size(); i++)
2390   G4cout <<kModalityImageDensityMap[i] << ",     2395   G4cout <<kModalityImageDensityMap[i] << ", ";
2391       G4cout << G4endl;                          2396       G4cout << G4endl;
2392     }                                            2397     }
2393                                                  2398 
2394   }                                              2399   }
2395                                                  2400 
2396                                                  2401 
2397   //----- dose distribution image -----//        2402   //----- dose distribution image -----//
2398   for(int ndose = 0; ndose < nDoseDist; ndose    2403   for(int ndose = 0; ndose < nDoseDist; ndose++) {
2399                                                  2404 
2400     newDoseDist();                               2405     newDoseDist();
2401                                                  2406 
2402     // dose distrbution image size               2407     // dose distrbution image size
2403     ifile.read((char *)ctmp, 3*sizeof(int));     2408     ifile.read((char *)ctmp, 3*sizeof(int));
2404     convertEndian(ctmp, size[0]);                2409     convertEndian(ctmp, size[0]);
2405     convertEndian(ctmp+sizeof(int), size[1]);    2410     convertEndian(ctmp+sizeof(int), size[1]);
2406     convertEndian(ctmp+2*sizeof(int), size[2]    2411     convertEndian(ctmp+2*sizeof(int), size[2]);
2407     if(DEBUG || kVerbose > 0) {                  2412     if(DEBUG || kVerbose > 0) {
2408       G4cout << "Dose dist. image size : ("      2413       G4cout << "Dose dist. image size : ("
2409     << size[0] << ", "                           2414     << size[0] << ", "
2410     << size[1] << ", "                           2415     << size[1] << ", "
2411     << size[2] << ")"                            2416     << size[2] << ")"
2412     << G4endl;                                   2417     << G4endl;
2413     }                                            2418     }
2414     kDose[ndose].setSize(size);                  2419     kDose[ndose].setSize(size);
2415                                                  2420 
2416     // dose distribution max. & min.             2421     // dose distribution max. & min. 
2417     ifile.read((char *)ctmp, sizeof(short)*2)    2422     ifile.read((char *)ctmp, sizeof(short)*2);
2418     convertEndian(ctmp, minmax[0]);              2423     convertEndian(ctmp, minmax[0]);
2419     convertEndian(ctmp+2, minmax[1]);            2424     convertEndian(ctmp+2, minmax[1]);
2420                                                  2425 
2421     // dose distribution unit                    2426     // dose distribution unit
2422     char dunit[13];                              2427     char dunit[13];
2423     ifile.read((char *)dunit, 12);               2428     ifile.read((char *)dunit, 12);
2424     std::string sdunit = dunit;                  2429     std::string sdunit = dunit;
2425     setDoseDistUnit(sdunit, ndose);              2430     setDoseDistUnit(sdunit, ndose);
2426     if(DEBUG || kVerbose > 0) {                  2431     if(DEBUG || kVerbose > 0) {
2427       G4cout << "Dose dist. unit : " << kDose    2432       G4cout << "Dose dist. unit : " << kDoseUnit << G4endl;
2428     }                                            2433     }
2429                                                  2434 
2430     // dose distribution scaling                 2435     // dose distribution scaling 
2431     ifile.read((char *)ctmp, 4); // sizeof(fl    2436     ifile.read((char *)ctmp, 4); // sizeof(float)
2432     convertEndian(ctmp, scale);                  2437     convertEndian(ctmp, scale);
2433     kDose[ndose].setScale(dscale = scale);       2438     kDose[ndose].setScale(dscale = scale);
2434                                                  2439 
2435     double dminmax[2];                           2440     double dminmax[2];
2436     for(int i = 0; i < 2; i++) dminmax[i] = m    2441     for(int i = 0; i < 2; i++) dminmax[i] = minmax[i]*dscale;
2437     kDose[ndose].setMinMax(dminmax);             2442     kDose[ndose].setMinMax(dminmax);
2438                                                  2443 
2439     if(DEBUG || kVerbose > 0) {                  2444     if(DEBUG || kVerbose > 0) {
2440       G4cout << "Dose dist. image min., max.,    2445       G4cout << "Dose dist. image min., max., scale : "
2441     << dminmax[0] << ", "                        2446     << dminmax[0] << ", "
2442     << dminmax[1] << ", "                        2447     << dminmax[1] << ", "
2443     << scale << G4endl;                          2448     << scale << G4endl;
2444     }                                            2449     }
2445                                                  2450 
2446     // dose distribution image                   2451     // dose distribution image
2447     int dsize = size[0]*size[1];                 2452     int dsize = size[0]*size[1];
2448     if(DEBUG || kVerbose > 0) G4cout << "Dose    2453     if(DEBUG || kVerbose > 0) G4cout << "Dose dist. (" << dsize << "): ";
2449     char * di = new char[dsize*sizeof(short)]    2454     char * di = new char[dsize*sizeof(short)];
2450     short * shimage = new short[dsize];          2455     short * shimage = new short[dsize];
2451     for(int z = 0; z < size[2]; z++) {           2456     for(int z = 0; z < size[2]; z++) {
2452       ifile.read((char *)di, dsize*sizeof(sho    2457       ifile.read((char *)di, dsize*sizeof(short));
2453       double * dimage = new double[dsize];       2458       double * dimage = new double[dsize];
2454       for(int xy = 0; xy < dsize; xy++) {        2459       for(int xy = 0; xy < dsize; xy++) {
2455   convertEndian(di+xy*sizeof(short), shimage[    2460   convertEndian(di+xy*sizeof(short), shimage[xy]);
2456   dimage[xy] = shimage[xy]*dscale;               2461   dimage[xy] = shimage[xy]*dscale;
2457       }                                          2462       }
2458       kDose[ndose].addImage(dimage);             2463       kDose[ndose].addImage(dimage);
2459                                                  2464 
2460       if(DEBUG || kVerbose > 0) G4cout << "["    2465       if(DEBUG || kVerbose > 0) G4cout << "[" << z << "]" << dimage[(size_t)(dsize*0.55)] << ", ";
2461                                                  2466 
2462       if(DEBUG || kVerbose > 0) {                2467       if(DEBUG || kVerbose > 0) {
2463   for(int j = 0; j < dsize; j++) {               2468   for(int j = 0; j < dsize; j++) {
2464     if(dimage[j] < 0)                            2469     if(dimage[j] < 0)
2465       G4cout << "[" << j << "," << z << "]"      2470       G4cout << "[" << j << "," << z << "]"
2466           << dimage[j] << ", ";                  2471           << dimage[j] << ", ";
2467   }                                              2472   }
2468       }                                          2473       }
2469     }                                            2474     }
2470     delete [] shimage;                           2475     delete [] shimage;
2471     delete [] di;                                2476     delete [] di;
2472     if(DEBUG || kVerbose > 0) G4cout << G4end    2477     if(DEBUG || kVerbose > 0) G4cout << G4endl;
2473                                                  2478 
2474     ifile.read((char *)ctmp, 3*4); // 3*sizeo    2479     ifile.read((char *)ctmp, 3*4); // 3*sizeof(int)
2475     convertEndian(ctmp, iCenter[0]);             2480     convertEndian(ctmp, iCenter[0]);
2476     convertEndian(ctmp+4, iCenter[1]);           2481     convertEndian(ctmp+4, iCenter[1]);
2477     convertEndian(ctmp+8, iCenter[2]);           2482     convertEndian(ctmp+8, iCenter[2]);
2478     for(int i = 0; i < 3; i++) fCenter[i] = (    2483     for(int i = 0; i < 3; i++) fCenter[i] = (float)iCenter[i];
2479     kDose[ndose].setCenterPosition(fCenter);     2484     kDose[ndose].setCenterPosition(fCenter);
2480                                                  2485 
2481     if(DEBUG || kVerbose > 0) {                  2486     if(DEBUG || kVerbose > 0) {
2482       G4cout << "Dose dist. image relative lo    2487       G4cout << "Dose dist. image relative location : ("
2483     << fCenter[0] << ", "                        2488     << fCenter[0] << ", "
2484     << fCenter[1] << ", "                        2489     << fCenter[1] << ", "
2485     << fCenter[2] << ")" << G4endl;              2490     << fCenter[2] << ")" << G4endl;
2486     }                                            2491     }
2487                                                  2492 
2488                                                  2493 
2489   }                                              2494   }
2490                                                  2495 
2491   //----- ROI image -----//                      2496   //----- ROI image -----//
2492   if(kPointerToROIData != 0) {                   2497   if(kPointerToROIData != 0) {
2493                                                  2498 
2494     newROI();                                    2499     newROI();
2495                                                  2500 
2496     // ROI image size                            2501     // ROI image size
2497     ifile.read((char *)ctmp, 3*sizeof(int));     2502     ifile.read((char *)ctmp, 3*sizeof(int));
2498     convertEndian(ctmp, size[0]);                2503     convertEndian(ctmp, size[0]);
2499     convertEndian(ctmp+sizeof(int), size[1]);    2504     convertEndian(ctmp+sizeof(int), size[1]);
2500     convertEndian(ctmp+2*sizeof(int), size[2]    2505     convertEndian(ctmp+2*sizeof(int), size[2]);
2501     kRoi[0].setSize(size);                       2506     kRoi[0].setSize(size);
2502     if(DEBUG || kVerbose > 0) {                  2507     if(DEBUG || kVerbose > 0) {
2503       G4cout << "ROI image size : ("             2508       G4cout << "ROI image size : ("
2504     << size[0] << ", "                           2509     << size[0] << ", "
2505     << size[1] << ", "                           2510     << size[1] << ", "
2506     << size[2] << ")"                            2511     << size[2] << ")"
2507     << G4endl;                                   2512     << G4endl;
2508     }                                            2513     }
2509                                                  2514 
2510     // ROI max. & min.                           2515     // ROI max. & min.
2511     ifile.read((char *)ctmp, sizeof(short)*2)    2516     ifile.read((char *)ctmp, sizeof(short)*2);
2512     convertEndian(ctmp, minmax[0]);              2517     convertEndian(ctmp, minmax[0]);
2513     convertEndian(ctmp+sizeof(short), minmax[    2518     convertEndian(ctmp+sizeof(short), minmax[1]);
2514     kRoi[0].setMinMax(minmax);                   2519     kRoi[0].setMinMax(minmax);
2515                                                  2520 
2516     // ROI distribution scaling                  2521     // ROI distribution scaling 
2517     ifile.read((char *)ctmp, sizeof(float));     2522     ifile.read((char *)ctmp, sizeof(float));
2518     convertEndian(ctmp, scale);                  2523     convertEndian(ctmp, scale);
2519     kRoi[0].setScale(dscale = scale);            2524     kRoi[0].setScale(dscale = scale);
2520     if(DEBUG || kVerbose > 0) {                  2525     if(DEBUG || kVerbose > 0) {
2521       G4cout << "ROI image min., max., scale     2526       G4cout << "ROI image min., max., scale : "
2522     << minmax[0] << ", "                         2527     << minmax[0] << ", "
2523     << minmax[1] << ", "                         2528     << minmax[1] << ", "
2524     << scale << G4endl;                          2529     << scale << G4endl;
2525     }                                            2530     }
2526                                                  2531 
2527     // ROI image                                 2532     // ROI image
2528     int rsize = size[0]*size[1];                 2533     int rsize = size[0]*size[1];
2529     char * ri = new char[rsize*sizeof(short)]    2534     char * ri = new char[rsize*sizeof(short)];
2530     for(int i = 0; i < size[2]; i++) {           2535     for(int i = 0; i < size[2]; i++) {
2531       ifile.read((char *)ri, rsize*sizeof(sho    2536       ifile.read((char *)ri, rsize*sizeof(short));
2532       short * rimage = new short[rsize];         2537       short * rimage = new short[rsize];
2533       for(int j = 0; j < rsize; j++) {           2538       for(int j = 0; j < rsize; j++) {
2534   convertEndian(ri+j*sizeof(short), rimage[j]    2539   convertEndian(ri+j*sizeof(short), rimage[j]);
2535       }                                          2540       }
2536       kRoi[0].addImage(rimage);                  2541       kRoi[0].addImage(rimage);
2537                                                  2542 
2538     }                                            2543     }
2539     delete [] ri;                                2544     delete [] ri;
2540                                                  2545 
2541     // ROI relative location                     2546     // ROI relative location
2542     ifile.read((char *)ctmp, 3*sizeof(int));     2547     ifile.read((char *)ctmp, 3*sizeof(int));
2543     convertEndian(ctmp, iCenter[0]);             2548     convertEndian(ctmp, iCenter[0]);
2544     convertEndian(ctmp+sizeof(int), iCenter[1    2549     convertEndian(ctmp+sizeof(int), iCenter[1]);
2545     convertEndian(ctmp+2*sizeof(int), iCenter    2550     convertEndian(ctmp+2*sizeof(int), iCenter[2]);
2546     for(int i = 0; i < 3; i++) fCenter[i] = i    2551     for(int i = 0; i < 3; i++) fCenter[i] = iCenter[i];
2547     kRoi[0].setCenterPosition(fCenter);          2552     kRoi[0].setCenterPosition(fCenter);
2548     if(DEBUG || kVerbose > 0) {                  2553     if(DEBUG || kVerbose > 0) {
2549       G4cout << "ROI image relative location     2554       G4cout << "ROI image relative location : ("
2550     << fCenter[0] << ", "                        2555     << fCenter[0] << ", "
2551     << fCenter[1] << ", "                        2556     << fCenter[1] << ", "
2552     << fCenter[2] << ")" << G4endl;              2557     << fCenter[2] << ")" << G4endl;
2553     }                                            2558     }
2554                                                  2559 
2555   }                                              2560   }
2556                                                  2561 
2557   //----- track information -----//              2562   //----- track information -----//
2558   if(kPointerToTrackData != 0) {                 2563   if(kPointerToTrackData != 0) {
2559                                                  2564 
2560     // track                                     2565     // track
2561     ifile.read((char *)ctmp, sizeof(int));       2566     ifile.read((char *)ctmp, sizeof(int));
2562     int ntrk;                                    2567     int ntrk;
2563     convertEndian(ctmp, ntrk);                   2568     convertEndian(ctmp, ntrk);
2564     if(DEBUG || kVerbose > 0) {                  2569     if(DEBUG || kVerbose > 0) {
2565       G4cout << "# of tracks: " << ntrk << G4    2570       G4cout << "# of tracks: " << ntrk << G4endl;
2566     }                                            2571     }
2567                                                  2572 
2568     // v4                                        2573     // v4
2569     std::vector<float *> trkv4;                  2574     std::vector<float *> trkv4;
2570                                                  2575 
2571     // track position                            2576     // track position
2572     for(int i = 0; i < ntrk; i++) {              2577     for(int i = 0; i < ntrk; i++) {
2573       float * tp = new float[6];                 2578       float * tp = new float[6];
2574                                                  2579 
2575       ifile.read((char *)ctmp, sizeof(float)*    2580       ifile.read((char *)ctmp, sizeof(float)*3);
2576       if(DEBUG || kVerbose > 0) if(i < 10) G4    2581       if(DEBUG || kVerbose > 0) if(i < 10) G4cout << i << ": " ;
2577       for(int j = 0; j < 3; j++) {               2582       for(int j = 0; j < 3; j++) {
2578   convertEndian(ctmp+j*sizeof(float), tp[j]);    2583   convertEndian(ctmp+j*sizeof(float), tp[j]);
2579   if(DEBUG || kVerbose > 0) if(i < 10) G4cout    2584   if(DEBUG || kVerbose > 0) if(i < 10) G4cout << tp[j] << ", ";
2580       }                                          2585       }
2581                                                  2586 
2582       ifile.read((char *)ctmp, sizeof(float)*    2587       ifile.read((char *)ctmp, sizeof(float)*3);
2583       for(int j = 0; j < 3; j++) {               2588       for(int j = 0; j < 3; j++) {
2584   convertEndian(ctmp+j*sizeof(float), tp[j+3]    2589   convertEndian(ctmp+j*sizeof(float), tp[j+3]);
2585   if(DEBUG || kVerbose > 0) if(i < 10) G4cout    2590   if(DEBUG || kVerbose > 0) if(i < 10) G4cout << tp[j+3] << ", ";
2586       }                                          2591       }
2587       addTrack(tp);                              2592       addTrack(tp);
2588       if(DEBUG || kVerbose > 0) if(i < 10) G4    2593       if(DEBUG || kVerbose > 0) if(i < 10) G4cout << G4endl;
2589                                                  2594 
2590       // v4                                      2595       // v4
2591       trkv4.push_back(tp);                       2596       trkv4.push_back(tp);
2592     }                                            2597     }
2593                                                  2598 
2594     //v4                                         2599     //v4
2595     unsigned char trkcolorv4[3];                 2600     unsigned char trkcolorv4[3];
2596                                                  2601 
2597     // track color                               2602     // track color
2598     for(int i = 0; i < ntrk; i++) {              2603     for(int i = 0; i < ntrk; i++) {
2599       unsigned char * rgb = new unsigned char    2604       unsigned char * rgb = new unsigned char[3];
2600       ifile.read((char *)rgb, 3);                2605       ifile.read((char *)rgb, 3);
2601       addTrackColor(rgb);                        2606       addTrackColor(rgb);
2602                                                  2607 
2603       // v4                                      2608       // v4
2604       for(int j = 0; j < 3; j++) trkcolorv4[j    2609       for(int j = 0; j < 3; j++) trkcolorv4[j] = rgb[j];
2605       std::vector<float *> trk;                  2610       std::vector<float *> trk;
2606       trk.push_back(trkv4[i]);                   2611       trk.push_back(trkv4[i]);
2607       addTrack(trk, trkcolorv4);                 2612       addTrack(trk, trkcolorv4);
2608                                                  2613 
2609     }                                            2614     }
2610                                                  2615 
2611   }                                              2616   }
2612                                                  2617 
2613   ifile.close();                                 2618   ifile.close();
2614                                                  2619 
2615   return true;                                   2620   return true;
2616 }                                                2621 }
2617 bool G4GMocrenIO::retrieveData3(char * _filen    2622 bool G4GMocrenIO::retrieveData3(char * _filename) {
2618   kFileName = _filename;                         2623   kFileName = _filename;
2619   return retrieveData();                         2624   return retrieveData();
2620 }                                                2625 }
2621                                                  2626 
2622 //                                               2627 // 
2623 bool G4GMocrenIO::retrieveData2() {              2628 bool G4GMocrenIO::retrieveData2() {
2624                                                  2629 
2625   bool DEBUG = false;//                          2630   bool DEBUG = false;//
2626                                                  2631 
2627   // input file open                             2632   // input file open
2628   std::ifstream ifile(kFileName.c_str(), std:    2633   std::ifstream ifile(kFileName.c_str(), std::ios_base::in|std::ios_base::binary);
2629   if(!ifile) {                                   2634   if(!ifile) {
2630     if (G4VisManager::GetVerbosity() >= G4Vis    2635     if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
2631       G4cout << "Cannot open file: " << kFile    2636       G4cout << "Cannot open file: " << kFileName
2632     << " in G4GMocrenIO::retrieveData2()." <<    2637     << " in G4GMocrenIO::retrieveData2()." << G4endl;
2633     return false;                                2638     return false;
2634   }                                              2639   }
2635                                                  2640 
2636   // data buffer                                 2641   // data buffer
2637   char ctmp[12];                                 2642   char ctmp[12];
2638                                                  2643 
2639   // file identifier                             2644   // file identifier
2640   char verid[9];                                 2645   char verid[9];
2641   ifile.read((char *)verid, 8);                  2646   ifile.read((char *)verid, 8);
2642                                                  2647 
2643   // file version                                2648   // file version
2644   unsigned char ver;                             2649   unsigned char ver;
2645   ifile.read((char *)&ver, 1);                   2650   ifile.read((char *)&ver, 1);
2646   std::stringstream ss;                          2651   std::stringstream ss;
2647   ss << (int)ver;                                2652   ss << (int)ver;
2648   kVersion = ss.str();                           2653   kVersion = ss.str();
2649   if(DEBUG || kVerbose > 0) G4cout << "File v    2654   if(DEBUG || kVerbose > 0) G4cout << "File version : " << kVersion << G4endl;
2650                                                  2655 
2651   // id of version 1                             2656   // id of version 1
2652   char idtmp[IDLENGTH];                          2657   char idtmp[IDLENGTH];
2653   ifile.read((char *)idtmp, IDLENGTH);           2658   ifile.read((char *)idtmp, IDLENGTH);
2654   kId = idtmp;                                   2659   kId = idtmp;
2655   // version of version 1                        2660   // version of version 1
2656   char vertmp[VERLENGTH];                        2661   char vertmp[VERLENGTH];
2657   ifile.read((char *)vertmp, VERLENGTH);         2662   ifile.read((char *)vertmp, VERLENGTH);
2658                                                  2663 
2659   // endian                                      2664   // endian
2660   ifile.read((char *)&kLittleEndianInput, siz    2665   ifile.read((char *)&kLittleEndianInput, sizeof(char));
2661   if(DEBUG || kVerbose > 0) {                    2666   if(DEBUG || kVerbose > 0) {
2662     G4cout << "Endian : ";                       2667     G4cout << "Endian : ";
2663     if(kLittleEndianInput == 1)                  2668     if(kLittleEndianInput == 1) 
2664       G4cout << " little" << G4endl;             2669       G4cout << " little" << G4endl;
2665     else {                                       2670     else {
2666       G4cout << " big" << G4endl;                2671       G4cout << " big" << G4endl;
2667     }                                            2672     }
2668   }                                              2673   }
2669                                                  2674 
2670   // voxel spacings for all images               2675   // voxel spacings for all images
2671   ifile.read((char *)ctmp, 12);                  2676   ifile.read((char *)ctmp, 12);
2672   convertEndian(ctmp, kVoxelSpacing[0]);         2677   convertEndian(ctmp, kVoxelSpacing[0]);
2673   convertEndian(ctmp+4, kVoxelSpacing[1]);       2678   convertEndian(ctmp+4, kVoxelSpacing[1]);
2674   convertEndian(ctmp+8, kVoxelSpacing[2]);       2679   convertEndian(ctmp+8, kVoxelSpacing[2]);
2675   if(DEBUG || kVerbose > 0) {                    2680   if(DEBUG || kVerbose > 0) {
2676     G4cout << "Voxel spacing : ("                2681     G4cout << "Voxel spacing : ("
2677         << kVoxelSpacing[0] << ", "              2682         << kVoxelSpacing[0] << ", "
2678         << kVoxelSpacing[1] << ", "              2683         << kVoxelSpacing[1] << ", "
2679         << kVoxelSpacing[2]                      2684         << kVoxelSpacing[2]
2680         << ") mm " << G4endl;                    2685         << ") mm " << G4endl;
2681   }                                              2686   }
2682                                                  2687 
2683                                                  2688 
2684   // offset from file starting point to the m    2689   // offset from file starting point to the modality image data
2685   ifile.read((char *)ctmp, 4);                   2690   ifile.read((char *)ctmp, 4);
2686   convertEndian(ctmp, kPointerToModalityData)    2691   convertEndian(ctmp, kPointerToModalityData);
2687                                                  2692 
2688   // offset from file starting point to the d    2693   // offset from file starting point to the dose image data
2689   unsigned int ptddd;                            2694   unsigned int ptddd;
2690   ifile.read((char *)ctmp, 4);                   2695   ifile.read((char *)ctmp, 4);
2691   convertEndian(ctmp, ptddd);                    2696   convertEndian(ctmp, ptddd);
2692   kPointerToDoseDistData.push_back(ptddd);       2697   kPointerToDoseDistData.push_back(ptddd);
2693                                                  2698 
2694   // offset from file starting point to the R    2699   // offset from file starting point to the ROI image data
2695   ifile.read((char *)ctmp, 4);                   2700   ifile.read((char *)ctmp, 4);
2696   convertEndian(ctmp, kPointerToROIData);        2701   convertEndian(ctmp, kPointerToROIData);
2697                                                  2702 
2698   // offset from file starting point to the t    2703   // offset from file starting point to the track data
2699   ifile.read((char *)ctmp, 4);                   2704   ifile.read((char *)ctmp, 4);
2700   convertEndian(ctmp, kPointerToTrackData);      2705   convertEndian(ctmp, kPointerToTrackData);
2701   if(DEBUG || kVerbose > 0) {                    2706   if(DEBUG || kVerbose > 0) {
2702     G4cout << "Each pointer to data : "          2707     G4cout << "Each pointer to data : "
2703         << kPointerToModalityData << ", "        2708         << kPointerToModalityData << ", "
2704         << kPointerToDoseDistData[0] << ", "     2709         << kPointerToDoseDistData[0] << ", "
2705         << kPointerToROIData << ", "             2710         << kPointerToROIData << ", "
2706         << kPointerToTrackData << G4endl;        2711         << kPointerToTrackData << G4endl;
2707   }                                              2712   }
2708                                                  2713 
2709   if(kPointerToModalityData == 0 && kPointerT    2714   if(kPointerToModalityData == 0 && kPointerToDoseDistData.size() == 0 &&
2710      kPointerToROIData == 0 && kPointerToTrac    2715      kPointerToROIData == 0 && kPointerToTrackData == 0) {
2711     if(DEBUG || kVerbose > 0) {                  2716     if(DEBUG || kVerbose > 0) {
2712       G4cout << "No data." << G4endl;            2717       G4cout << "No data." << G4endl;
2713     }                                            2718     }
2714     return false;                                2719     return false;
2715   }                                              2720   }
2716                                                  2721 
2717   // event number                                2722   // event number
2718   /* ver 1                                       2723   /* ver 1
2719      ifile.read(ctmp, sizeof(int));              2724      ifile.read(ctmp, sizeof(int));
2720      convertEndian(ctmp, numberOfEvents);        2725      convertEndian(ctmp, numberOfEvents);
2721   */                                             2726   */
2722                                                  2727 
2723   int size[3];                                   2728   int size[3];
2724   float scale;                                   2729   float scale;
2725   double dscale;                                 2730   double dscale;
2726   short minmax[2];                               2731   short minmax[2];
2727   float fCenter[3];                              2732   float fCenter[3];
2728   int iCenter[3];                                2733   int iCenter[3];
2729                                                  2734 
2730   //----- Modality image -----//                 2735   //----- Modality image -----//
2731   // modality image size                         2736   // modality image size
2732   ifile.read(ctmp, 3*sizeof(int));               2737   ifile.read(ctmp, 3*sizeof(int));
2733   convertEndian(ctmp, size[0]);                  2738   convertEndian(ctmp, size[0]);
2734   convertEndian(ctmp+sizeof(int), size[1]);      2739   convertEndian(ctmp+sizeof(int), size[1]);
2735   convertEndian(ctmp+2*sizeof(int), size[2]);    2740   convertEndian(ctmp+2*sizeof(int), size[2]);
2736   if(DEBUG || kVerbose > 0) {                    2741   if(DEBUG || kVerbose > 0) {
2737     G4cout << "Modality image size : ("          2742     G4cout << "Modality image size : ("
2738         << size[0] << ", "                       2743         << size[0] << ", "
2739         << size[1] << ", "                       2744         << size[1] << ", "
2740         << size[2] << ")"                        2745         << size[2] << ")"
2741         << G4endl;                               2746         << G4endl;
2742   }                                              2747   }
2743   kModality.setSize(size);                       2748   kModality.setSize(size);
2744                                                  2749 
2745   // modality image voxel spacing                2750   // modality image voxel spacing
2746   /*                                             2751   /*
2747     ifile.read(ctmp, 3*sizeof(float));           2752     ifile.read(ctmp, 3*sizeof(float));
2748     convertEndian(ctmp, modalityImageVoxelSpa    2753     convertEndian(ctmp, modalityImageVoxelSpacing[0]);
2749     convertEndian(ctmp+sizeof(float), modalit    2754     convertEndian(ctmp+sizeof(float), modalityImageVoxelSpacing[1]);
2750     convertEndian(ctmp+2*sizeof(float), modal    2755     convertEndian(ctmp+2*sizeof(float), modalityImageVoxelSpacing[2]);
2751   */                                             2756   */
2752                                                  2757 
2753   if(kPointerToModalityData != 0) {              2758   if(kPointerToModalityData != 0) {
2754                                                  2759 
2755     // modality density max. & min.              2760     // modality density max. & min.
2756     ifile.read((char *)ctmp, 4);                 2761     ifile.read((char *)ctmp, 4);
2757     convertEndian(ctmp, minmax[0]);              2762     convertEndian(ctmp, minmax[0]);
2758     convertEndian(ctmp+2, minmax[1]);            2763     convertEndian(ctmp+2, minmax[1]);
2759     kModality.setMinMax(minmax);                 2764     kModality.setMinMax(minmax);
2760                                                  2765 
2761     // modality density scale                    2766     // modality density scale
2762     ifile.read((char *)ctmp, 4);                 2767     ifile.read((char *)ctmp, 4);
2763     convertEndian(ctmp, scale);                  2768     convertEndian(ctmp, scale);
2764     kModality.setScale(dscale = scale);          2769     kModality.setScale(dscale = scale);
2765     if(DEBUG || kVerbose > 0) {                  2770     if(DEBUG || kVerbose > 0) {
2766       G4cout << "Modality image min., max., s    2771       G4cout << "Modality image min., max., scale : "
2767     << minmax[0] << ", "                         2772     << minmax[0] << ", "
2768     << minmax[1] << ", "                         2773     << minmax[1] << ", "
2769     << scale << G4endl;                          2774     << scale << G4endl;
2770     }                                            2775     }
2771                                                  2776 
2772     // modality density                          2777     // modality density
2773     int psize = size[0]*size[1];                 2778     int psize = size[0]*size[1];
2774     if(DEBUG || kVerbose > 0) G4cout << "Moda    2779     if(DEBUG || kVerbose > 0) G4cout << "Modality image (" << psize << "): ";
2775     char * cimage = new char[psize*sizeof(sho    2780     char * cimage = new char[psize*sizeof(short)];
2776     for(int i = 0; i < size[2]; i++) {           2781     for(int i = 0; i < size[2]; i++) {
2777       ifile.read((char *)cimage, psize*sizeof    2782       ifile.read((char *)cimage, psize*sizeof(short));
2778       short * mimage = new short[psize];         2783       short * mimage = new short[psize];
2779       for(int j = 0; j < psize; j++) {           2784       for(int j = 0; j < psize; j++) {
2780   convertEndian(cimage+j*sizeof(short), mimag    2785   convertEndian(cimage+j*sizeof(short), mimage[j]);
2781       }                                          2786       }
2782       kModality.addImage(mimage);                2787       kModality.addImage(mimage);
2783                                                  2788 
2784       if(DEBUG || kVerbose > 0) G4cout << "["    2789       if(DEBUG || kVerbose > 0) G4cout << "[" << i << "]" << mimage[(size_t)(psize*0.55)] << ", ";
2785     }                                            2790     }
2786     if(DEBUG || kVerbose > 0) G4cout << G4end    2791     if(DEBUG || kVerbose > 0) G4cout << G4endl;
2787     delete [] cimage;                            2792     delete [] cimage;
2788                                                  2793 
2789     // modality desity map for CT value          2794     // modality desity map for CT value
2790     size_t msize = minmax[1]-minmax[0]+1;        2795     size_t msize = minmax[1]-minmax[0]+1;
2791     if(DEBUG || kVerbose > 0) G4cout << "msiz    2796     if(DEBUG || kVerbose > 0) G4cout << "msize: " << msize << G4endl;
2792     char * pdmap = new char[msize*sizeof(floa    2797     char * pdmap = new char[msize*sizeof(float)];
2793     ifile.read((char *)pdmap, msize*sizeof(fl    2798     ifile.read((char *)pdmap, msize*sizeof(float));
2794     float ftmp;                                  2799     float ftmp;
2795     for(int i = 0; i < (int)msize; i++) {        2800     for(int i = 0; i < (int)msize; i++) {
2796       convertEndian(pdmap+i*sizeof(float), ft    2801       convertEndian(pdmap+i*sizeof(float), ftmp);
2797       kModalityImageDensityMap.push_back(ftmp    2802       kModalityImageDensityMap.push_back(ftmp); 
2798     }                                            2803     }
2799     delete [] pdmap;                             2804     delete [] pdmap;
2800     if(DEBUG || kVerbose > 0) {                  2805     if(DEBUG || kVerbose > 0) {
2801       G4cout << "density map : " << std::ends    2806       G4cout << "density map : " << std::ends;
2802       for(int i = 0; i < 10; i++)                2807       for(int i = 0; i < 10; i++)
2803   G4cout <<kModalityImageDensityMap[i] << ",     2808   G4cout <<kModalityImageDensityMap[i] << ", ";
2804       G4cout << G4endl;                          2809       G4cout << G4endl;
2805       for(int i = 0; i < 10; i++) G4cout << "    2810       for(int i = 0; i < 10; i++) G4cout << "..";
2806       G4cout << G4endl;                          2811       G4cout << G4endl;
2807       for(size_t i =kModalityImageDensityMap.    2812       for(size_t i =kModalityImageDensityMap.size() - 10; i <kModalityImageDensityMap.size(); i++)
2808   G4cout <<kModalityImageDensityMap[i] << ",     2813   G4cout <<kModalityImageDensityMap[i] << ", ";
2809       G4cout << G4endl;                          2814       G4cout << G4endl;
2810     }                                            2815     }
2811                                                  2816 
2812   }                                              2817   }
2813                                                  2818 
2814                                                  2819 
2815   //----- dose distribution image -----//        2820   //----- dose distribution image -----//
2816   if(kPointerToDoseDistData[0] != 0) {           2821   if(kPointerToDoseDistData[0] != 0) {
2817                                                  2822 
2818     newDoseDist();                               2823     newDoseDist();
2819                                                  2824 
2820     // dose distrbution image size               2825     // dose distrbution image size
2821     ifile.read((char *)ctmp, 3*sizeof(int));     2826     ifile.read((char *)ctmp, 3*sizeof(int));
2822     convertEndian(ctmp, size[0]);                2827     convertEndian(ctmp, size[0]);
2823     convertEndian(ctmp+sizeof(int), size[1]);    2828     convertEndian(ctmp+sizeof(int), size[1]);
2824     convertEndian(ctmp+2*sizeof(int), size[2]    2829     convertEndian(ctmp+2*sizeof(int), size[2]);
2825     if(DEBUG || kVerbose > 0) {                  2830     if(DEBUG || kVerbose > 0) {
2826       G4cout << "Dose dist. image size : ("      2831       G4cout << "Dose dist. image size : ("
2827     << size[0] << ", "                           2832     << size[0] << ", "
2828     << size[1] << ", "                           2833     << size[1] << ", "
2829     << size[2] << ")"                            2834     << size[2] << ")"
2830     << G4endl;                                   2835     << G4endl;
2831     }                                            2836     }
2832     kDose[0].setSize(size);                      2837     kDose[0].setSize(size);
2833                                                  2838 
2834     // dose distribution max. & min.             2839     // dose distribution max. & min. 
2835     ifile.read((char *)ctmp, sizeof(short)*2)    2840     ifile.read((char *)ctmp, sizeof(short)*2);
2836     convertEndian(ctmp, minmax[0]);              2841     convertEndian(ctmp, minmax[0]);
2837     convertEndian(ctmp+2, minmax[1]);            2842     convertEndian(ctmp+2, minmax[1]);
2838     // dose distribution scaling                 2843     // dose distribution scaling 
2839     ifile.read((char *)ctmp, sizeof(float));     2844     ifile.read((char *)ctmp, sizeof(float));
2840     convertEndian(ctmp, scale);                  2845     convertEndian(ctmp, scale);
2841     kDose[0].setScale(dscale = scale);           2846     kDose[0].setScale(dscale = scale);
2842                                                  2847 
2843     double dminmax[2];                           2848     double dminmax[2];
2844     for(int i = 0; i < 2; i++) dminmax[i] = m    2849     for(int i = 0; i < 2; i++) dminmax[i] = minmax[i]*dscale;
2845     kDose[0].setMinMax(dminmax);                 2850     kDose[0].setMinMax(dminmax);
2846                                                  2851 
2847     if(DEBUG || kVerbose > 0) {                  2852     if(DEBUG || kVerbose > 0) {
2848       G4cout << "Dose dist. image min., max.,    2853       G4cout << "Dose dist. image min., max., scale : "
2849     << dminmax[0] << ", "                        2854     << dminmax[0] << ", "
2850     << dminmax[1] << ", "                        2855     << dminmax[1] << ", "
2851     << scale << G4endl;                          2856     << scale << G4endl;
2852     }                                            2857     }
2853                                                  2858 
2854     // dose distribution image                   2859     // dose distribution image
2855     int dsize = size[0]*size[1];                 2860     int dsize = size[0]*size[1];
2856     if(DEBUG || kVerbose > 0) G4cout << "Dose    2861     if(DEBUG || kVerbose > 0) G4cout << "Dose dist. (" << dsize << "): ";
2857     char * di = new char[dsize*sizeof(short)]    2862     char * di = new char[dsize*sizeof(short)];
2858     short * shimage = new short[dsize];          2863     short * shimage = new short[dsize];
2859     for(int z = 0; z < size[2]; z++) {           2864     for(int z = 0; z < size[2]; z++) {
2860       ifile.read((char *)di, dsize*sizeof(sho    2865       ifile.read((char *)di, dsize*sizeof(short));
2861       double * dimage = new double[dsize];       2866       double * dimage = new double[dsize];
2862       for(int xy = 0; xy < dsize; xy++) {        2867       for(int xy = 0; xy < dsize; xy++) {
2863   convertEndian(di+xy*sizeof(short), shimage[    2868   convertEndian(di+xy*sizeof(short), shimage[xy]);
2864   dimage[xy] = shimage[xy]*dscale;               2869   dimage[xy] = shimage[xy]*dscale;
2865       }                                          2870       }
2866       kDose[0].addImage(dimage);                 2871       kDose[0].addImage(dimage);
2867                                                  2872 
2868       if(DEBUG || kVerbose > 0) G4cout << "["    2873       if(DEBUG || kVerbose > 0) G4cout << "[" << z << "]" << dimage[(size_t)(dsize*0.55)] << ", ";
2869                                                  2874 
2870       if(DEBUG || kVerbose > 0) {                2875       if(DEBUG || kVerbose > 0) {
2871   for(int j = 0; j < dsize; j++) {               2876   for(int j = 0; j < dsize; j++) {
2872     if(dimage[j] < 0)                            2877     if(dimage[j] < 0)
2873       G4cout << "[" << j << "," << z << "]"      2878       G4cout << "[" << j << "," << z << "]"
2874           << dimage[j] << ", ";                  2879           << dimage[j] << ", ";
2875   }                                              2880   }
2876       }                                          2881       }
2877     }                                            2882     }
2878     delete [] shimage;                           2883     delete [] shimage;
2879     delete [] di;                                2884     delete [] di;
2880     if(DEBUG || kVerbose > 0) G4cout << G4end    2885     if(DEBUG || kVerbose > 0) G4cout << G4endl;
2881                                                  2886 
2882     /* ver 1                                     2887     /* ver 1
2883        float doseDist;                           2888        float doseDist;
2884        int dosePid;                              2889        int dosePid;
2885        double * doseData = new double[numDose    2890        double * doseData = new double[numDoseImageVoxels];
2886        for(int i = 0; i < numDose; i++) {        2891        for(int i = 0; i < numDose; i++) {
2887        ifile.read(ctmp, sizeof(int));            2892        ifile.read(ctmp, sizeof(int));
2888        convertEndian(ctmp, dosePid);             2893        convertEndian(ctmp, dosePid);
2889        for(int j = 0; j < numDoseImageVoxels;    2894        for(int j = 0; j < numDoseImageVoxels; j++) {
2890        ifile.read(ctmp, sizeof(float));          2895        ifile.read(ctmp, sizeof(float));
2891        convertEndian(ctmp, doseDist);            2896        convertEndian(ctmp, doseDist);
2892        doseData[j] = doseDist;                   2897        doseData[j] = doseDist;
2893        }                                         2898        }
2894        setDose(dosePid, doseData);               2899        setDose(dosePid, doseData);
2895        }                                         2900        }
2896        delete [] doseData;                       2901        delete [] doseData;
2897        if(totalDose == NULL) totalDose = new     2902        if(totalDose == NULL) totalDose = new double[numDoseImageVoxels];
2898        for(int i = 0; i < numDoseImageVoxels;    2903        for(int i = 0; i < numDoseImageVoxels; i++) {
2899        ifile.read(ctmp, sizeof(float));          2904        ifile.read(ctmp, sizeof(float));
2900        convertEndian(ctmp, doseDist);            2905        convertEndian(ctmp, doseDist);
2901        totalDose[i] = doseDist;                  2906        totalDose[i] = doseDist;
2902        }                                         2907        }
2903     */                                           2908     */
2904                                                  2909 
2905     /* ver 1                                     2910     /* ver 1
2906     // relative location between the two imag    2911     // relative location between the two images
2907     ifile.read(ctmp, 3*sizeof(float));           2912     ifile.read(ctmp, 3*sizeof(float));
2908     convertEndian(ctmp, relativeLocation[0]);    2913     convertEndian(ctmp, relativeLocation[0]);
2909     convertEndian(ctmp+sizeof(float), relativ    2914     convertEndian(ctmp+sizeof(float), relativeLocation[1]);
2910     convertEndian(ctmp+2*sizeof(float), relat    2915     convertEndian(ctmp+2*sizeof(float), relativeLocation[2]);
2911     */                                           2916     */
2912                                                  2917 
2913     // relative location of the dose distribu    2918     // relative location of the dose distribution image for 
2914     // the modality image                        2919     // the modality image
2915     //ofile.write((char *)relativeLocation, 3    2920     //ofile.write((char *)relativeLocation, 3*sizeof(float));
2916     ifile.read((char *)ctmp, 3*sizeof(int));     2921     ifile.read((char *)ctmp, 3*sizeof(int));
2917     convertEndian(ctmp, iCenter[0]);             2922     convertEndian(ctmp, iCenter[0]);
2918     convertEndian(ctmp+sizeof(int), iCenter[1    2923     convertEndian(ctmp+sizeof(int), iCenter[1]);
2919     convertEndian(ctmp+2*sizeof(int), iCenter    2924     convertEndian(ctmp+2*sizeof(int), iCenter[2]);
2920     for(int i = 0; i < 3; i++) fCenter[i] = (    2925     for(int i = 0; i < 3; i++) fCenter[i] = (float)iCenter[i];
2921     kDose[0].setCenterPosition(fCenter);         2926     kDose[0].setCenterPosition(fCenter);
2922                                                  2927 
2923     if(DEBUG || kVerbose > 0) {                  2928     if(DEBUG || kVerbose > 0) {
2924       G4cout << "Dose dist. image relative lo    2929       G4cout << "Dose dist. image relative location : ("
2925     << fCenter[0] << ", "                        2930     << fCenter[0] << ", "
2926     << fCenter[1] << ", "                        2931     << fCenter[1] << ", "
2927     << fCenter[2] << ")" << G4endl;              2932     << fCenter[2] << ")" << G4endl;
2928     }                                            2933     }
2929                                                  2934 
2930                                                  2935 
2931   }                                              2936   }
2932                                                  2937 
2933   //----- ROI image -----//                      2938   //----- ROI image -----//
2934   if(kPointerToROIData != 0) {                   2939   if(kPointerToROIData != 0) {
2935                                                  2940 
2936     newROI();                                    2941     newROI();
2937                                                  2942 
2938     // ROI image size                            2943     // ROI image size
2939     ifile.read((char *)ctmp, 3*sizeof(int));     2944     ifile.read((char *)ctmp, 3*sizeof(int));
2940     convertEndian(ctmp, size[0]);                2945     convertEndian(ctmp, size[0]);
2941     convertEndian(ctmp+sizeof(int), size[1]);    2946     convertEndian(ctmp+sizeof(int), size[1]);
2942     convertEndian(ctmp+2*sizeof(int), size[2]    2947     convertEndian(ctmp+2*sizeof(int), size[2]);
2943     kRoi[0].setSize(size);                       2948     kRoi[0].setSize(size);
2944     if(DEBUG || kVerbose > 0) {                  2949     if(DEBUG || kVerbose > 0) {
2945       G4cout << "ROI image size : ("             2950       G4cout << "ROI image size : ("
2946     << size[0] << ", "                           2951     << size[0] << ", "
2947     << size[1] << ", "                           2952     << size[1] << ", "
2948     << size[2] << ")"                            2953     << size[2] << ")"
2949     << G4endl;                                   2954     << G4endl;
2950     }                                            2955     }
2951                                                  2956 
2952     // ROI max. & min.                           2957     // ROI max. & min.
2953     ifile.read((char *)ctmp, sizeof(short)*2)    2958     ifile.read((char *)ctmp, sizeof(short)*2);
2954     convertEndian(ctmp, minmax[0]);              2959     convertEndian(ctmp, minmax[0]);
2955     convertEndian(ctmp+sizeof(short), minmax[    2960     convertEndian(ctmp+sizeof(short), minmax[1]);
2956     kRoi[0].setMinMax(minmax);                   2961     kRoi[0].setMinMax(minmax);
2957                                                  2962 
2958     // ROI distribution scaling                  2963     // ROI distribution scaling 
2959     ifile.read((char *)ctmp, sizeof(float));     2964     ifile.read((char *)ctmp, sizeof(float));
2960     convertEndian(ctmp, scale);                  2965     convertEndian(ctmp, scale);
2961     kRoi[0].setScale(dscale = scale);            2966     kRoi[0].setScale(dscale = scale);
2962     if(DEBUG || kVerbose > 0) {                  2967     if(DEBUG || kVerbose > 0) {
2963       G4cout << "ROI image min., max., scale     2968       G4cout << "ROI image min., max., scale : "
2964     << minmax[0] << ", "                         2969     << minmax[0] << ", "
2965     << minmax[1] << ", "                         2970     << minmax[1] << ", "
2966     << scale << G4endl;                          2971     << scale << G4endl;
2967     }                                            2972     }
2968                                                  2973 
2969     // ROI image                                 2974     // ROI image
2970     int rsize = size[0]*size[1];                 2975     int rsize = size[0]*size[1];
2971     char * ri = new char[rsize*sizeof(short)]    2976     char * ri = new char[rsize*sizeof(short)];
2972     for(int i = 0; i < size[2]; i++) {           2977     for(int i = 0; i < size[2]; i++) {
2973       ifile.read((char *)ri, rsize*sizeof(sho    2978       ifile.read((char *)ri, rsize*sizeof(short));
2974       short * rimage = new short[rsize];         2979       short * rimage = new short[rsize];
2975       for(int j = 0; j < rsize; j++) {           2980       for(int j = 0; j < rsize; j++) {
2976   convertEndian(ri+j*sizeof(short), rimage[j]    2981   convertEndian(ri+j*sizeof(short), rimage[j]);
2977       }                                          2982       }
2978       kRoi[0].addImage(rimage);                  2983       kRoi[0].addImage(rimage);
2979                                                  2984 
2980     }                                            2985     }
2981     delete [] ri;                                2986     delete [] ri;
2982                                                  2987 
2983     // ROI relative location                     2988     // ROI relative location
2984     ifile.read((char *)ctmp, 3*sizeof(int));     2989     ifile.read((char *)ctmp, 3*sizeof(int));
2985     convertEndian(ctmp, iCenter[0]);             2990     convertEndian(ctmp, iCenter[0]);
2986     convertEndian(ctmp+sizeof(int), iCenter[1    2991     convertEndian(ctmp+sizeof(int), iCenter[1]);
2987     convertEndian(ctmp+2*sizeof(int), iCenter    2992     convertEndian(ctmp+2*sizeof(int), iCenter[2]);
2988     for(int i = 0; i < 3; i++) fCenter[i] = i    2993     for(int i = 0; i < 3; i++) fCenter[i] = iCenter[i];
2989     kRoi[0].setCenterPosition(fCenter);          2994     kRoi[0].setCenterPosition(fCenter);
2990     if(DEBUG || kVerbose > 0) {                  2995     if(DEBUG || kVerbose > 0) {
2991       G4cout << "ROI image relative location     2996       G4cout << "ROI image relative location : ("
2992     << fCenter[0] << ", "                        2997     << fCenter[0] << ", "
2993     << fCenter[1] << ", "                        2998     << fCenter[1] << ", "
2994     << fCenter[2] << ")" << G4endl;              2999     << fCenter[2] << ")" << G4endl;
2995     }                                            3000     }
2996                                                  3001 
2997   }                                              3002   }
2998                                                  3003 
2999   //----- track information -----//              3004   //----- track information -----//
3000   if(kPointerToTrackData != 0) {                 3005   if(kPointerToTrackData != 0) {
3001                                                  3006 
3002     // track                                     3007     // track
3003     ifile.read((char *)ctmp, sizeof(int));       3008     ifile.read((char *)ctmp, sizeof(int));
3004     int ntrk;                                    3009     int ntrk;
3005     convertEndian(ctmp, ntrk);                   3010     convertEndian(ctmp, ntrk);
3006     if(DEBUG || kVerbose > 0) {                  3011     if(DEBUG || kVerbose > 0) {
3007       G4cout << "# of tracks: " << ntrk << G4    3012       G4cout << "# of tracks: " << ntrk << G4endl;
3008     }                                            3013     }
3009                                                  3014 
3010     //v4                                         3015     //v4
3011     unsigned char trkcolorv4[3] = {255, 0, 0}    3016     unsigned char trkcolorv4[3] = {255, 0, 0};
3012                                                  3017 
3013     for(int i = 0; i < ntrk; i++) {              3018     for(int i = 0; i < ntrk; i++) {
3014       float * tp = new float[6];                 3019       float * tp = new float[6];
3015       // v4                                      3020       // v4
3016       std::vector<float *> trkv4;                3021       std::vector<float *> trkv4;
3017                                                  3022 
3018       ifile.read((char *)ctmp, sizeof(float)*    3023       ifile.read((char *)ctmp, sizeof(float)*3);
3019       if(DEBUG || kVerbose > 0) if(i < 10) G4    3024       if(DEBUG || kVerbose > 0) if(i < 10) G4cout << i << ": " ;
3020       for(int j = 0; j < 3; j++) {               3025       for(int j = 0; j < 3; j++) {
3021   convertEndian(ctmp+j*sizeof(float), tp[j]);    3026   convertEndian(ctmp+j*sizeof(float), tp[j]);
3022   if(DEBUG || kVerbose > 0) if(i < 10) G4cout    3027   if(DEBUG || kVerbose > 0) if(i < 10) G4cout << tp[j] << ", ";
3023       }                                          3028       }
3024                                                  3029 
3025       ifile.read((char *)ctmp, sizeof(float)*    3030       ifile.read((char *)ctmp, sizeof(float)*3);
3026       for(int j = 0; j < 3; j++) {               3031       for(int j = 0; j < 3; j++) {
3027   convertEndian(ctmp+j*sizeof(float), tp[j+3]    3032   convertEndian(ctmp+j*sizeof(float), tp[j+3]);
3028   if(DEBUG || kVerbose > 0) if(i < 10) G4cout    3033   if(DEBUG || kVerbose > 0) if(i < 10) G4cout << tp[j+3] << ", ";
3029       }                                          3034       }
3030                                                  3035 
3031       kSteps.push_back(tp);                      3036       kSteps.push_back(tp);
3032       // v4                                      3037       // v4
3033       trkv4.push_back(tp);                       3038       trkv4.push_back(tp);
3034       addTrack(trkv4, trkcolorv4);               3039       addTrack(trkv4, trkcolorv4);
3035                                                  3040       
3036       if(DEBUG || kVerbose > 0) if(i < 10) G4    3041       if(DEBUG || kVerbose > 0) if(i < 10) G4cout << G4endl;
3037     }                                            3042     }
3038                                                  3043 
3039   }                                              3044   }
3040                                                  3045 
3041   /* ver 1                                       3046   /* ver 1
3042   // track                                       3047   // track
3043   int ntracks;                                   3048   int ntracks;
3044   ifile.read(ctmp, sizeof(int));                 3049   ifile.read(ctmp, sizeof(int));
3045   convertEndian(ctmp, ntracks);                  3050   convertEndian(ctmp, ntracks);
3046   // track displacement                          3051   // track displacement
3047   ifile.read(ctmp, 3*sizeof(float));             3052   ifile.read(ctmp, 3*sizeof(float));
3048   convertEndian(ctmp, trackDisplacement[0]);     3053   convertEndian(ctmp, trackDisplacement[0]);
3049   convertEndian(ctmp+sizeof(float), trackDisp    3054   convertEndian(ctmp+sizeof(float), trackDisplacement[2]); // exchanged with [1]
3050   convertEndian(ctmp+2*sizeof(float), trackDi    3055   convertEndian(ctmp+2*sizeof(float), trackDisplacement[1]);
3051   //                                             3056   //
3052   //for(int i = 0; i < ntracks && i < 100; i+    3057   //for(int i = 0; i < ntracks && i < 100; i++) {
3053   for(int i = 0; i < ntracks; i++) {             3058   for(int i = 0; i < ntracks; i++) {
3054   DicomDoseTrack trk;                            3059   DicomDoseTrack trk;
3055   short trackid, parentid, pid;                  3060   short trackid, parentid, pid;
3056   int npoints;                                   3061   int npoints;
3057   ifile.read(ctmp, sizeof(short));               3062   ifile.read(ctmp, sizeof(short));
3058   convertEndian(ctmp, trackid);                  3063   convertEndian(ctmp, trackid);
3059   trk.setID(trackid);                            3064   trk.setID(trackid);
3060   ifile.read(ctmp, sizeof(short));               3065   ifile.read(ctmp, sizeof(short));
3061   convertEndian(ctmp, parentid);                 3066   convertEndian(ctmp, parentid);
3062   trk.setParentID(parentid);                     3067   trk.setParentID(parentid);
3063   ifile.read(ctmp, sizeof(short));               3068   ifile.read(ctmp, sizeof(short));
3064   convertEndian(ctmp, pid);                      3069   convertEndian(ctmp, pid);
3065   trk.setPID(pid);                               3070   trk.setPID(pid);
3066   ifile.read(ctmp, sizeof(int));                 3071   ifile.read(ctmp, sizeof(int));
3067   convertEndian(ctmp, npoints);                  3072   convertEndian(ctmp, npoints);
3068   for(int i = 0; i < npoints; i++) {             3073   for(int i = 0; i < npoints; i++) {
3069   ifile.read(ctmp, 3*sizeof(float));             3074   ifile.read(ctmp, 3*sizeof(float));
3070   // storing only start and end points           3075   // storing only start and end points
3071   //if(i == 0 || i == npoints - 1) {             3076   //if(i == 0 || i == npoints - 1) {
3072   float * point = new float[3];                  3077   float * point = new float[3];
3073   convertEndian(ctmp, point[0]);                 3078   convertEndian(ctmp, point[0]);
3074   convertEndian(ctmp+sizeof(float), point[1])    3079   convertEndian(ctmp+sizeof(float), point[1]);
3075   convertEndian(ctmp+2*sizeof(float), point[2    3080   convertEndian(ctmp+2*sizeof(float), point[2]);
3076   trk.addPoint(point);                           3081   trk.addPoint(point);
3077   //}                                            3082   //}
3078   }                                              3083   }
3079   track.push_back(trk);                          3084   track.push_back(trk);
3080   }                                              3085   }
3081   */                                             3086   */
3082                                                  3087 
3083   ifile.close();                                 3088   ifile.close();
3084                                                  3089 
3085   return true;                                   3090   return true;
3086 }                                                3091 }
3087                                                  3092 
3088 bool G4GMocrenIO::retrieveData2(char * _filen    3093 bool G4GMocrenIO::retrieveData2(char * _filename) {
3089   kFileName = _filename;                         3094   kFileName = _filename;
3090   return retrieveData();                         3095   return retrieveData();
3091 }                                                3096 }
3092                                                  3097 
3093 void G4GMocrenIO::setID() {                      3098 void G4GMocrenIO::setID() {
3094   time_t t;                                      3099   time_t t;
3095   time(&t);                                      3100   time(&t);
3096                                                  3101 
3097   tm * ti;                                       3102   tm * ti;
3098   ti = localtime(&t);                            3103   ti = localtime(&t);
3099                                                  3104 
3100   char cmonth[12][4] = {"Jan", "Feb", "Mar",     3105   char cmonth[12][4] = {"Jan", "Feb", "Mar", "Apr",
3101       "May", "Jun", "Jul", "Aug",                3106       "May", "Jun", "Jul", "Aug",
3102       "Sep", "Oct", "Nov", "Dec"};               3107       "Sep", "Oct", "Nov", "Dec"};
3103   std::stringstream ss;                          3108   std::stringstream ss;
3104   ss << std::setfill('0')                        3109   ss << std::setfill('0')
3105      << std::setw(2)                             3110      << std::setw(2)
3106      << ti->tm_hour << ":"                       3111      << ti->tm_hour << ":"
3107      << std::setw(2)                             3112      << std::setw(2)
3108      << ti->tm_min << ":"                        3113      << ti->tm_min << ":"
3109      << std::setw(2)                             3114      << std::setw(2)
3110      << ti->tm_sec << ","                        3115      << ti->tm_sec << ","
3111      << cmonth[ti->tm_mon] << "."                3116      << cmonth[ti->tm_mon] << "."
3112      << std::setw(2)                             3117      << std::setw(2)
3113      << ti->tm_mday << ","                       3118      << ti->tm_mday << ","
3114      << ti->tm_year+1900;                        3119      << ti->tm_year+1900;
3115                                                  3120 
3116   kId = ss.str();                                3121   kId = ss.str();
3117 }                                                3122 }
3118                                                  3123 
3119 // get & set the file version                    3124 // get & set the file version
3120 std::string & G4GMocrenIO::getVersion() {retu    3125 std::string & G4GMocrenIO::getVersion() {return kVersion;}
3121 void G4GMocrenIO::setVersion(std::string & _v    3126 void G4GMocrenIO::setVersion(std::string & _version) {kVersion = _version;}
3122                                                  3127 
3123 // set endians of input/output data              3128 // set endians of input/output data
3124 void G4GMocrenIO::setLittleEndianInput(bool _    3129 void G4GMocrenIO::setLittleEndianInput(bool _little) {kLittleEndianInput = _little;}
3125 void G4GMocrenIO::setLittleEndianOutput(bool     3130 void G4GMocrenIO::setLittleEndianOutput(bool _little) {kLittleEndianOutput = _little;}
3126                                                  3131 
3127 // voxel spacing                                 3132 // voxel spacing
3128 void G4GMocrenIO::setVoxelSpacing(float _spac    3133 void G4GMocrenIO::setVoxelSpacing(float _spacing[3]) {
3129   for(int i = 0; i < 3; i++) kVoxelSpacing[i]    3134   for(int i = 0; i < 3; i++) kVoxelSpacing[i] = _spacing[i];
3130 }                                                3135 }
3131 void G4GMocrenIO::getVoxelSpacing(float _spac    3136 void G4GMocrenIO::getVoxelSpacing(float _spacing[3]) {
3132   for(int i = 0; i < 3; i++) _spacing[i] = kV    3137   for(int i = 0; i < 3; i++) _spacing[i] = kVoxelSpacing[i];
3133 }                                                3138 }
3134                                                  3139 
3135 // get & set number of events                    3140 // get & set number of events
3136 int & G4GMocrenIO::getNumberOfEvents() {         3141 int & G4GMocrenIO::getNumberOfEvents() {
3137   return kNumberOfEvents;                        3142   return kNumberOfEvents;
3138 }                                                3143 }
3139 void G4GMocrenIO::setNumberOfEvents(int & _nu    3144 void G4GMocrenIO::setNumberOfEvents(int & _numberOfEvents) {
3140   kNumberOfEvents = _numberOfEvents;             3145   kNumberOfEvents = _numberOfEvents;
3141 }                                                3146 }
3142 void G4GMocrenIO::addOneEvent() {                3147 void G4GMocrenIO::addOneEvent() {
3143   kNumberOfEvents++;                             3148   kNumberOfEvents++;
3144 }                                                3149 }
3145                                                  3150 
3146 // set/get pointer the modality image data       3151 // set/get pointer the modality image data
3147 void G4GMocrenIO::setPointerToModalityData(un    3152 void G4GMocrenIO::setPointerToModalityData(unsigned int & _pointer) {
3148   kPointerToModalityData = _pointer;             3153   kPointerToModalityData = _pointer;
3149 }                                                3154 }
3150 unsigned int G4GMocrenIO::getPointerToModalit    3155 unsigned int G4GMocrenIO::getPointerToModalityData() {
3151   return kPointerToModalityData;                 3156   return kPointerToModalityData;
3152 }                                                3157 }
3153 // set/get pointer the dose distribution imag    3158 // set/get pointer the dose distribution image data
3154 void G4GMocrenIO::addPointerToDoseDistData(un    3159 void G4GMocrenIO::addPointerToDoseDistData(unsigned int & _pointer) {
3155   kPointerToDoseDistData.push_back(_pointer);    3160   kPointerToDoseDistData.push_back(_pointer);
3156 }                                                3161 }
3157 unsigned int G4GMocrenIO::getPointerToDoseDis    3162 unsigned int G4GMocrenIO::getPointerToDoseDistData(int _elem) {
3158   if(kPointerToDoseDistData.size() == 0 ||       3163   if(kPointerToDoseDistData.size() == 0 ||
3159      kPointerToDoseDistData.size() < (size_t)    3164      kPointerToDoseDistData.size() < (size_t)_elem)
3160     return 0;                                    3165     return 0;
3161   else                                           3166   else
3162     return kPointerToDoseDistData[_elem];        3167     return kPointerToDoseDistData[_elem];
3163 }                                                3168 }
3164                                                  3169 
3165 // set/get pointer the ROI image data            3170 // set/get pointer the ROI image data
3166 void G4GMocrenIO::setPointerToROIData(unsigne    3171 void G4GMocrenIO::setPointerToROIData(unsigned int & _pointer) {
3167   kPointerToROIData = _pointer;                  3172   kPointerToROIData = _pointer;
3168 }                                                3173 }
3169 unsigned int G4GMocrenIO::getPointerToROIData    3174 unsigned int G4GMocrenIO::getPointerToROIData() {
3170   return kPointerToROIData;                      3175   return kPointerToROIData;
3171 }                                                3176 }
3172 // set/get pointer the track data                3177 // set/get pointer the track data
3173 void G4GMocrenIO::setPointerToTrackData(unsig    3178 void G4GMocrenIO::setPointerToTrackData(unsigned int & _pointer) {
3174   kPointerToTrackData = _pointer;                3179   kPointerToTrackData = _pointer;
3175 }                                                3180 }
3176 unsigned int G4GMocrenIO::getPointerToTrackDa    3181 unsigned int G4GMocrenIO::getPointerToTrackData() {
3177   return kPointerToTrackData;                    3182   return kPointerToTrackData;
3178 }                                                3183 }
3179                                                  3184 
3180 // calculate pointers for version 4              3185 // calculate pointers for version 4
3181 void G4GMocrenIO::calcPointers4() {              3186 void G4GMocrenIO::calcPointers4() {
3182                                                  3187 
3183   // pointer to modality data                    3188   // pointer to modality data
3184   unsigned int pointer = 1070; // up to "poin    3189   unsigned int pointer = 1070; // up to "pointer to the detector data" except for "pointer to the dose dist data"
3185   int nDoseDist = getNumDoseDist();              3190   int nDoseDist = getNumDoseDist();
3186   pointer += nDoseDist*4;                        3191   pointer += nDoseDist*4;
3187                                                  3192 
3188   setPointerToModalityData(pointer);             3193   setPointerToModalityData(pointer);
3189                                                  3194 
3190   // pointer to dose data                        3195   // pointer to dose data
3191   // ct-density map for modality data            3196   // ct-density map for modality data
3192   int msize[3];                                  3197   int msize[3];
3193   getModalityImageSize(msize);                   3198   getModalityImageSize(msize);
3194   short mminmax[2];                              3199   short mminmax[2];
3195   getModalityImageMinMax(mminmax);               3200   getModalityImageMinMax(mminmax);
3196   int pmsize = 2*msize[0]*msize[1]*msize[2];     3201   int pmsize = 2*msize[0]*msize[1]*msize[2];
3197   int pmmap = 4*(mminmax[1] - mminmax[0] + 1)    3202   int pmmap = 4*(mminmax[1] - mminmax[0] + 1);
3198   pointer += 32 + pmsize + pmmap;                3203   pointer += 32 + pmsize + pmmap;
3199   //                                             3204   //
3200   kPointerToDoseDistData.clear();                3205   kPointerToDoseDistData.clear();
3201   if(nDoseDist == 0) {                           3206   if(nDoseDist == 0) {
3202     unsigned int pointer0 = 0;                   3207     unsigned int pointer0 = 0;
3203     addPointerToDoseDistData(pointer0);          3208     addPointerToDoseDistData(pointer0);
3204   }                                              3209   }
3205   for(int ndose = 0; ndose < nDoseDist; ndose    3210   for(int ndose = 0; ndose < nDoseDist; ndose++) {
3206     addPointerToDoseDistData(pointer);           3211     addPointerToDoseDistData(pointer);
3207     int dsize[3];                                3212     int dsize[3];
3208     getDoseDistSize(dsize);                      3213     getDoseDistSize(dsize);
3209     pointer += 44 + dsize[0]*dsize[1]*dsize[2    3214     pointer += 44 + dsize[0]*dsize[1]*dsize[2]*2 + 80;
3210   }                                              3215   }
3211                                                  3216 
3212   // pointer to roi data                         3217   // pointer to roi data
3213   if(!isROIEmpty()) {                            3218   if(!isROIEmpty()) {
3214     setPointerToROIData(pointer);                3219     setPointerToROIData(pointer);
3215                                                  3220     
3216     int rsize[3];                                3221     int rsize[3];
3217     getROISize(rsize);                           3222     getROISize(rsize);
3218     int prsize = 2*rsize[0]*rsize[1]*rsize[2]    3223     int prsize = 2*rsize[0]*rsize[1]*rsize[2];
3219     pointer += 20 + prsize + 12;                 3224     pointer += 20 + prsize + 12;
3220   } else {                                       3225   } else {
3221     unsigned int pointer0 = 0;                   3226     unsigned int pointer0 = 0;
3222     setPointerToROIData(pointer0);               3227     setPointerToROIData(pointer0);
3223   }                                              3228   }
3224                                                  3229 
3225   // pointer to track data                       3230   // pointer to track data
3226   int ntrk = (int)kTracks.size();             << 3231   int ntrk = kTracks.size();
3227   if(ntrk != 0) {                                3232   if(ntrk != 0) {
3228     setPointerToTrackData(pointer);              3233     setPointerToTrackData(pointer);
3229                                                  3234 
3230     pointer += 4; // # of tracks                 3235     pointer += 4; // # of tracks
3231     for(int nt = 0; nt < ntrk; nt++) {           3236     for(int nt = 0; nt < ntrk; nt++) {
3232       int nsteps = kTracks[nt].getNumberOfSte    3237       int nsteps = kTracks[nt].getNumberOfSteps();
3233       pointer += 4 + 3 + nsteps*(4*6); // # o    3238       pointer += 4 + 3 + nsteps*(4*6); // # of steps + color + steps(float*6)
3234     }                                            3239     }
3235   } else {                                       3240   } else {
3236     unsigned int pointer0 = 0;                   3241     unsigned int pointer0 = 0;
3237     setPointerToTrackData(pointer0);             3242     setPointerToTrackData(pointer0);
3238   }                                              3243   }
3239   if(kVerbose > 0) G4cout << " pointer to the    3244   if(kVerbose > 0) G4cout << " pointer to the track data :"
3240            << kPointerToTrackData << G4endl;     3245            << kPointerToTrackData << G4endl;
3241                                                  3246 
3242   // pointer to detector data                    3247   // pointer to detector data
3243   int ndet = (int)kDetectors.size();          << 3248   int ndet = kDetectors.size();
3244   if(ndet != 0) {                                3249   if(ndet != 0) {
3245     kPointerToDetectorData = pointer;            3250     kPointerToDetectorData = pointer;
3246   } else {                                       3251   } else {
3247     kPointerToDetectorData = 0;                  3252     kPointerToDetectorData = 0;
3248   }                                              3253   }
3249   if(kVerbose > 0) G4cout << " pointer to the    3254   if(kVerbose > 0) G4cout << " pointer to the detector data :"
3250            << kPointerToDetectorData << G4end    3255            << kPointerToDetectorData << G4endl;
3251                                                  3256 
3252 }                                                3257 }
3253                                                  3258 
3254 // calculate pointers for ver.3                  3259 // calculate pointers for ver.3
3255 void G4GMocrenIO::calcPointers3() {              3260 void G4GMocrenIO::calcPointers3() {
3256                                                  3261 
3257   // pointer to modality data                    3262   // pointer to modality data
3258   unsigned int pointer = 1066; // up to "poin    3263   unsigned int pointer = 1066; // up to "pointer to the track data" except for "pointer to the dose dist data"
3259   int nDoseDist = getNumDoseDist();              3264   int nDoseDist = getNumDoseDist();
3260   pointer += nDoseDist*4;                        3265   pointer += nDoseDist*4;
3261                                                  3266 
3262   setPointerToModalityData(pointer);             3267   setPointerToModalityData(pointer);
3263                                                  3268 
3264   // pointer to dose data                        3269   // pointer to dose data
3265   // ct-density map for modality data            3270   // ct-density map for modality data
3266   int msize[3];                                  3271   int msize[3];
3267   getModalityImageSize(msize);                   3272   getModalityImageSize(msize);
3268   short mminmax[2];                              3273   short mminmax[2];
3269   getModalityImageMinMax(mminmax);               3274   getModalityImageMinMax(mminmax);
3270   int pmsize = 2*msize[0]*msize[1]*msize[2];     3275   int pmsize = 2*msize[0]*msize[1]*msize[2];
3271   int pmmap = 4*(mminmax[1] - mminmax[0] + 1)    3276   int pmmap = 4*(mminmax[1] - mminmax[0] + 1);
3272   pointer += 32 + pmsize + pmmap;                3277   pointer += 32 + pmsize + pmmap;
3273   //                                             3278   //
3274   kPointerToDoseDistData.clear();                3279   kPointerToDoseDistData.clear();
3275   if(nDoseDist == 0) {                           3280   if(nDoseDist == 0) {
3276     unsigned int pointer0 = 0;                   3281     unsigned int pointer0 = 0;
3277     addPointerToDoseDistData(pointer0);          3282     addPointerToDoseDistData(pointer0);
3278   }                                              3283   }
3279   for(int ndose = 0; ndose < nDoseDist; ndose    3284   for(int ndose = 0; ndose < nDoseDist; ndose++) {
3280     addPointerToDoseDistData(pointer);           3285     addPointerToDoseDistData(pointer);
3281     int dsize[3];                                3286     int dsize[3];
3282     getDoseDistSize(dsize);                      3287     getDoseDistSize(dsize);
3283     pointer += 44 + dsize[0]*dsize[1]*dsize[2    3288     pointer += 44 + dsize[0]*dsize[1]*dsize[2]*2;
3284   }                                              3289   }
3285                                                  3290 
3286   // pointer to roi data                         3291   // pointer to roi data
3287   if(!isROIEmpty()) {                            3292   if(!isROIEmpty()) {
3288     setPointerToROIData(pointer);                3293     setPointerToROIData(pointer);
3289                                                  3294     
3290     int rsize[3];                                3295     int rsize[3];
3291     getROISize(rsize);                           3296     getROISize(rsize);
3292     int prsize = 2*rsize[0]*rsize[1]*rsize[2]    3297     int prsize = 2*rsize[0]*rsize[1]*rsize[2];
3293     pointer += 20 + prsize + 12;                 3298     pointer += 20 + prsize + 12;
3294   } else {                                       3299   } else {
3295     unsigned int pointer0 = 0;                   3300     unsigned int pointer0 = 0;
3296     setPointerToROIData(pointer0);               3301     setPointerToROIData(pointer0);
3297   }                                              3302   }
3298                                                  3303 
3299   //                                             3304   //
3300   if(getNumTracks() != 0)                        3305   if(getNumTracks() != 0) 
3301     setPointerToTrackData(pointer);              3306     setPointerToTrackData(pointer);
3302   else {                                         3307   else {
3303     unsigned int pointer0 = 0;                   3308     unsigned int pointer0 = 0;
3304     setPointerToTrackData(pointer0);             3309     setPointerToTrackData(pointer0);
3305   }                                              3310   }
3306                                                  3311 
3307 }                                                3312 }
3308                                                  3313 
3309 // calculate pointers for ver.2                  3314 // calculate pointers for ver.2
3310 void G4GMocrenIO::calcPointers2() {              3315 void G4GMocrenIO::calcPointers2() {
3311                                                  3316 
3312   // pointer to modality data                    3317   // pointer to modality data
3313   unsigned int pointer = 65;                     3318   unsigned int pointer = 65;
3314   setPointerToModalityData(pointer);             3319   setPointerToModalityData(pointer);
3315                                                  3320 
3316   // pointer to dose data                        3321   // pointer to dose data
3317   int msize[3];                                  3322   int msize[3];
3318   getModalityImageSize(msize);                   3323   getModalityImageSize(msize);
3319   short mminmax[2];                              3324   short mminmax[2];
3320   getModalityImageMinMax(mminmax);               3325   getModalityImageMinMax(mminmax);
3321   int pmsize = 2*msize[0]*msize[1]*msize[2];     3326   int pmsize = 2*msize[0]*msize[1]*msize[2];
3322   int pmmap = 4*(mminmax[1] - mminmax[0] + 1)    3327   int pmmap = 4*(mminmax[1] - mminmax[0] + 1);
3323   pointer += 20 + pmsize + pmmap;                3328   pointer += 20 + pmsize + pmmap;
3324   int dsize[3];                                  3329   int dsize[3];
3325   getDoseDistSize(dsize);                        3330   getDoseDistSize(dsize);
3326   kPointerToDoseDistData.clear();                3331   kPointerToDoseDistData.clear();
3327   if(dsize[0] != 0) {                            3332   if(dsize[0] != 0) {
3328     kPointerToDoseDistData.push_back(pointer)    3333     kPointerToDoseDistData.push_back(pointer);
3329                                                  3334 
3330     int pdsize = 2*dsize[0]*dsize[1]*dsize[2]    3335     int pdsize = 2*dsize[0]*dsize[1]*dsize[2];
3331     pointer += 20 + pdsize + 12;                 3336     pointer += 20 + pdsize + 12;
3332   } else {                                       3337   } else {
3333     unsigned int pointer0 = 0;                   3338     unsigned int pointer0 = 0;
3334     kPointerToDoseDistData.push_back(pointer0    3339     kPointerToDoseDistData.push_back(pointer0);
3335   }                                              3340   }
3336                                                  3341 
3337   // pointer to roi data                         3342   // pointer to roi data
3338   if(!isROIEmpty())  {                           3343   if(!isROIEmpty())  {
3339     int rsize[3];                                3344     int rsize[3];
3340     getROISize(rsize);                           3345     getROISize(rsize);
3341     setPointerToROIData(pointer);                3346     setPointerToROIData(pointer);
3342     int prsize = 2*rsize[0]*rsize[1]*rsize[2]    3347     int prsize = 2*rsize[0]*rsize[1]*rsize[2];
3343     pointer += 20 + prsize + 12;                 3348     pointer += 20 + prsize + 12;
3344                                                  3349 
3345   } else {                                       3350   } else {
3346     unsigned int pointer0 = 0;                   3351     unsigned int pointer0 = 0;
3347     setPointerToROIData(pointer0);               3352     setPointerToROIData(pointer0);
3348   }                                              3353   }
3349                                                  3354 
3350   //                                             3355   //
3351   if(getNumTracks() != 0)                        3356   if(getNumTracks() != 0) 
3352     setPointerToTrackData(pointer);              3357     setPointerToTrackData(pointer);
3353   else {                                         3358   else {
3354     unsigned int pointer0 = 0;                   3359     unsigned int pointer0 = 0;
3355     setPointerToTrackData(pointer0);             3360     setPointerToTrackData(pointer0);
3356   }                                              3361   }
3357                                                  3362 
3358 }                                                3363 }
3359                                                  3364 
3360                                                  3365 
3361 //----- Modality image -----//                   3366 //----- Modality image -----//
3362 void G4GMocrenIO::getModalityImageSize(int _s    3367 void G4GMocrenIO::getModalityImageSize(int _size[3]) {
3363                                                  3368 
3364   kModality.getSize(_size);                      3369   kModality.getSize(_size);
3365 }                                                3370 }
3366 void G4GMocrenIO::setModalityImageSize(int _s    3371 void G4GMocrenIO::setModalityImageSize(int _size[3]) {
3367                                                  3372 
3368   kModality.setSize(_size);                      3373   kModality.setSize(_size);
3369 }                                                3374 }
3370                                                  3375 
3371 // get & set the modality image size             3376 // get & set the modality image size
3372 void G4GMocrenIO::setModalityImageScale(doubl    3377 void G4GMocrenIO::setModalityImageScale(double & _scale) {
3373                                                  3378 
3374   kModality.setScale(_scale);                    3379   kModality.setScale(_scale);
3375 }                                                3380 }
3376 double G4GMocrenIO::getModalityImageScale() {    3381 double G4GMocrenIO::getModalityImageScale() {
3377                                                  3382 
3378   return kModality.getScale();                   3383   return kModality.getScale();
3379 }                                                3384 }
3380                                                  3385 
3381 // set the modality image in CT                  3386 // set the modality image in CT 
3382 void G4GMocrenIO::setModalityImage(short * _i    3387 void G4GMocrenIO::setModalityImage(short * _image) {
3383                                                  3388 
3384   kModality.addImage(_image);                    3389   kModality.addImage(_image);
3385 }                                                3390 }
3386 short * G4GMocrenIO::getModalityImage(int _z)    3391 short * G4GMocrenIO::getModalityImage(int _z) {
3387                                                  3392   
3388   return kModality.getImage(_z);                 3393   return kModality.getImage(_z);
3389 }                                                3394 }
3390 void G4GMocrenIO::clearModalityImage() {         3395 void G4GMocrenIO::clearModalityImage() {
3391                                                  3396   
3392   kModality.clearImage();                        3397   kModality.clearImage();
3393 }                                                3398 }
3394 // set/get the modality image density map        3399 // set/get the modality image density map
3395 void G4GMocrenIO::setModalityImageDensityMap(    3400 void G4GMocrenIO::setModalityImageDensityMap(std::vector<float> & _map) {
3396   kModalityImageDensityMap = _map;               3401   kModalityImageDensityMap = _map;
3397 }                                                3402 }
3398 std::vector<float> & G4GMocrenIO::getModality    3403 std::vector<float> & G4GMocrenIO::getModalityImageDensityMap() {
3399   return kModalityImageDensityMap;               3404   return kModalityImageDensityMap;
3400 }                                                3405 }
3401 // set the modality image min./max.              3406 // set the modality image min./max.
3402 void G4GMocrenIO::setModalityImageMinMax(shor    3407 void G4GMocrenIO::setModalityImageMinMax(short _minmax[2]) {
3403                                                  3408 
3404   kModality.setMinMax(_minmax);                  3409   kModality.setMinMax(_minmax);
3405 }                                                3410 }  
3406 // get the modality image min./max.              3411 // get the modality image min./max.
3407 void G4GMocrenIO::getModalityImageMinMax(shor    3412 void G4GMocrenIO::getModalityImageMinMax(short _minmax[2]) {
3408                                                  3413 
3409   short minmax[2];                               3414   short minmax[2];
3410   kModality.getMinMax(minmax);                   3415   kModality.getMinMax(minmax);
3411   for(int i = 0; i < 2; i++) _minmax[i] = min    3416   for(int i = 0; i < 2; i++) _minmax[i] = minmax[i];
3412 }                                                3417 }  
3413 short G4GMocrenIO::getModalityImageMax() {       3418 short G4GMocrenIO::getModalityImageMax() {
3414                                                  3419 
3415   short minmax[2];                               3420   short minmax[2];
3416   kModality.getMinMax(minmax);                   3421   kModality.getMinMax(minmax);
3417   return minmax[1];                              3422   return minmax[1];
3418 }                                                3423 }
3419 short G4GMocrenIO::getModalityImageMin() {       3424 short G4GMocrenIO::getModalityImageMin() {
3420                                                  3425 
3421   short minmax[2];                               3426   short minmax[2];
3422   kModality.getMinMax(minmax);                   3427   kModality.getMinMax(minmax);
3423   return minmax[0];                              3428   return minmax[0];
3424 }                                                3429 }
3425 // set/get position of the modality image cen    3430 // set/get position of the modality image center
3426 void G4GMocrenIO::setModalityCenterPosition(f    3431 void G4GMocrenIO::setModalityCenterPosition(float _center[3]) {
3427                                                  3432 
3428   kModality.setCenterPosition(_center);          3433   kModality.setCenterPosition(_center);
3429 }                                                3434 }
3430 void G4GMocrenIO::getModalityCenterPosition(f    3435 void G4GMocrenIO::getModalityCenterPosition(float _center[3]) {
3431                                                  3436 
3432   if(isROIEmpty())                               3437   if(isROIEmpty())
3433     for(int i = 0; i < 3; i++) _center[i] = 0    3438     for(int i = 0; i < 3; i++) _center[i] = 0;
3434   else                                           3439   else 
3435     kModality.getCenterPosition(_center);        3440     kModality.getCenterPosition(_center);
3436 }                                                3441 }
3437 // get & set the modality image unit             3442 // get & set the modality image unit
3438 std::string G4GMocrenIO::getModalityImageUnit    3443 std::string G4GMocrenIO::getModalityImageUnit() {
3439   return kModalityUnit;                          3444   return kModalityUnit;
3440 }                                                3445 }
3441 void G4GMocrenIO::setModalityImageUnit(std::s    3446 void G4GMocrenIO::setModalityImageUnit(std::string & _unit) {
3442   kModalityUnit = _unit;                         3447   kModalityUnit = _unit;
3443 }                                                3448 }
3444 //                                               3449 //
3445 short G4GMocrenIO::convertDensityToHU(float &    3450 short G4GMocrenIO::convertDensityToHU(float & _dens) {
3446   short rval = -1024; // default: air            3451   short rval = -1024; // default: air
3447   int nmap = (int)kModalityImageDensityMap.si    3452   int nmap = (int)kModalityImageDensityMap.size();
3448   if(nmap != 0) {                                3453   if(nmap != 0) {
3449     short minmax[2];                             3454     short minmax[2];
3450     kModality.getMinMax(minmax);                 3455     kModality.getMinMax(minmax);
3451     rval = minmax[1];                            3456     rval = minmax[1];
3452     for(int i = 0; i < nmap; i++) {              3457     for(int i = 0; i < nmap; i++) {
3453       //G4cout << kModalityImageDensityMap[i]    3458       //G4cout << kModalityImageDensityMap[i] << G4endl;
3454       if(_dens <= kModalityImageDensityMap[i]    3459       if(_dens <= kModalityImageDensityMap[i]) {
3455   rval = i + minmax[0];                          3460   rval = i + minmax[0];
3456   break;                                         3461   break;
3457       }                                          3462       }
3458     }                                            3463     }
3459   }                                              3464   }
3460   return rval;                                   3465   return rval;
3461 }                                                3466 }
3462                                                  3467 
3463                                                  3468 
3464 //----- Dose distribution -----//                3469 //----- Dose distribution -----//
3465 //                                               3470 //
3466 void G4GMocrenIO::newDoseDist() {                3471 void G4GMocrenIO::newDoseDist() {
3467   GMocrenDataPrimitive<double> doseData;         3472   GMocrenDataPrimitive<double> doseData;
3468   kDose.push_back(doseData);                     3473   kDose.push_back(doseData);
3469 }                                                3474 }
3470 int G4GMocrenIO::getNumDoseDist() {              3475 int G4GMocrenIO::getNumDoseDist() {
3471   return (int)kDose.size();                      3476   return (int)kDose.size();
3472 }                                                3477 }
3473                                                  3478 
3474 // get & set the dose distribution unit          3479 // get & set the dose distribution unit
3475 std::string G4GMocrenIO::getDoseDistUnit(int     3480 std::string G4GMocrenIO::getDoseDistUnit(int _num) {
3476   // to avoid a warning in the compile proces    3481   // to avoid a warning in the compile process
3477   if(kDoseUnit.size() > static_cast<size_t>(_    3482   if(kDoseUnit.size() > static_cast<size_t>(_num)) return kDoseUnit;
3478                                                  3483 
3479   return kDoseUnit;                              3484   return kDoseUnit;
3480 }                                                3485 }
3481 void G4GMocrenIO::setDoseDistUnit(std::string    3486 void G4GMocrenIO::setDoseDistUnit(std::string & _unit, int _num) {
3482   // to avoid a warning in the compile proces    3487   // to avoid a warning in the compile process
3483   if(_unit.size() > static_cast<size_t>(_num)    3488   if(_unit.size() > static_cast<size_t>(_num)) kDoseUnit = _unit;
3484                                                  3489 
3485   //char unit[13];                               3490   //char unit[13];
3486   //std::strncpy(unit, _unit.c_str(), 12);       3491   //std::strncpy(unit, _unit.c_str(), 12);
3487   //doseUnit = unit;                             3492   //doseUnit = unit;
3488   kDoseUnit = _unit;                             3493   kDoseUnit = _unit;
3489 }                                                3494 }
3490 //                                               3495 //
3491 void G4GMocrenIO::getDoseDistSize(int _size[3    3496 void G4GMocrenIO::getDoseDistSize(int _size[3], int _num) {
3492   if(isDoseEmpty())                              3497   if(isDoseEmpty())
3493     for(int i = 0; i < 3; i++) _size[i] = 0;     3498     for(int i = 0; i < 3; i++) _size[i] = 0;
3494   else                                           3499   else 
3495     kDose[_num].getSize(_size);                  3500     kDose[_num].getSize(_size);
3496 }                                                3501 }
3497 void G4GMocrenIO::setDoseDistSize(int _size[3    3502 void G4GMocrenIO::setDoseDistSize(int _size[3], int _num) {
3498                                                  3503 
3499   kDose[_num].setSize(_size);                    3504   kDose[_num].setSize(_size);
3500                                                  3505 
3501   //resetDose();                                 3506   //resetDose();
3502 }                                                3507 }
3503                                                  3508 
3504 void G4GMocrenIO::setDoseDistMinMax(short _mi    3509 void G4GMocrenIO::setDoseDistMinMax(short _minmax[2], int _num) {
3505                                                  3510 
3506   double minmax[2];                              3511   double minmax[2];
3507   double scale = kDose[_num].getScale();         3512   double scale = kDose[_num].getScale();
3508   for(int i = 0; i < 2; i++) minmax[i] = (dou    3513   for(int i = 0; i < 2; i++) minmax[i] = (double)_minmax[i]*scale;
3509   kDose[_num].setMinMax(minmax);                 3514   kDose[_num].setMinMax(minmax);
3510 }                                                3515 }  
3511 void G4GMocrenIO::getDoseDistMinMax(short _mi    3516 void G4GMocrenIO::getDoseDistMinMax(short _minmax[2], int _num) {
3512                                                  3517 
3513   if(isDoseEmpty())                              3518   if(isDoseEmpty())
3514     for(int i = 0; i < 2; i++) _minmax[i] = 0    3519     for(int i = 0; i < 2; i++) _minmax[i] = 0;
3515   else {                                         3520   else {
3516     double minmax[2];                            3521     double minmax[2];
3517     kDose[_num].getMinMax(minmax);               3522     kDose[_num].getMinMax(minmax);
3518     double scale = kDose[_num].getScale();       3523     double scale = kDose[_num].getScale();
3519     for(int i = 0; i < 2; i++) _minmax[i] = (    3524     for(int i = 0; i < 2; i++) _minmax[i] = (short)(minmax[i]/scale+0.5);
3520   }                                              3525   }
3521 }                                                3526 }  
3522 void G4GMocrenIO::setDoseDistMinMax(double _m    3527 void G4GMocrenIO::setDoseDistMinMax(double _minmax[2], int _num) {
3523                                                  3528 
3524   kDose[_num].setMinMax(_minmax);                3529   kDose[_num].setMinMax(_minmax);
3525 }                                                3530 }  
3526 void G4GMocrenIO::getDoseDistMinMax(double _m    3531 void G4GMocrenIO::getDoseDistMinMax(double _minmax[2], int _num) {
3527                                                  3532 
3528   if(isDoseEmpty())                              3533   if(isDoseEmpty())
3529     for(int i = 0; i < 2; i++) _minmax[i] = 0    3534     for(int i = 0; i < 2; i++) _minmax[i] = 0.;
3530   else                                           3535   else
3531     kDose[_num].getMinMax(_minmax);              3536     kDose[_num].getMinMax(_minmax);
3532 }                                                3537 }  
3533                                                  3538 
3534 // get & set the dose distribution image scal    3539 // get & set the dose distribution image scale
3535 void G4GMocrenIO::setDoseDistScale(double & _    3540 void G4GMocrenIO::setDoseDistScale(double & _scale, int _num) {
3536                                                  3541 
3537   kDose[_num].setScale(_scale);                  3542   kDose[_num].setScale(_scale);
3538 }                                                3543 }
3539 double G4GMocrenIO::getDoseDistScale(int _num    3544 double G4GMocrenIO::getDoseDistScale(int _num) {
3540                                                  3545 
3541   if(isDoseEmpty())                              3546   if(isDoseEmpty())
3542     return 0.;                                   3547     return 0.;
3543   else                                           3548   else 
3544     return kDose[_num].getScale();               3549     return kDose[_num].getScale();
3545 }                                                3550 }
3546                                                  3551 
3547 /*                                               3552 /*
3548   void G4GMocrenIO::initializeShortDoseDist()    3553   void G4GMocrenIO::initializeShortDoseDist() {
3549   ;                                              3554   ;
3550   }                                              3555   }
3551   void G4GMocrenIO::finalizeShortDoseDist() {    3556   void G4GMocrenIO::finalizeShortDoseDist() {
3552   ;                                              3557   ;
3553   }                                              3558   }
3554 */                                               3559 */
3555 // set the dose distribution image               3560 // set the dose distribution image
3556 void G4GMocrenIO::setShortDoseDist(short * _i    3561 void G4GMocrenIO::setShortDoseDist(short * _image, int _num) {
3557                                                  3562 
3558   int size[3];                                   3563   int size[3];
3559   kDose[_num].getSize(size);                     3564   kDose[_num].getSize(size);
3560   int dsize = size[0]*size[1];                   3565   int dsize = size[0]*size[1];
3561   double * ddata = new double[dsize];            3566   double * ddata = new double[dsize];
3562   double scale = kDose[_num].getScale();         3567   double scale = kDose[_num].getScale();
3563   double minmax[2];                              3568   double minmax[2];
3564   kDose[_num].getMinMax(minmax);                 3569   kDose[_num].getMinMax(minmax);
3565   for(int xy = 0; xy < dsize; xy++) {            3570   for(int xy = 0; xy < dsize; xy++) {
3566     ddata[xy] = _image[xy]*scale;                3571     ddata[xy] = _image[xy]*scale;
3567     if(ddata[xy] < minmax[0]) minmax[0] = dda    3572     if(ddata[xy] < minmax[0]) minmax[0] = ddata[xy];
3568     if(ddata[xy] > minmax[1]) minmax[1] = dda    3573     if(ddata[xy] > minmax[1]) minmax[1] = ddata[xy];
3569   }                                              3574   }
3570   kDose[_num].addImage(ddata);                   3575   kDose[_num].addImage(ddata);
3571                                                  3576 
3572   // set min./max.                               3577   // set min./max.
3573   kDose[_num].setMinMax(minmax);                 3578   kDose[_num].setMinMax(minmax);
3574 }                                                3579 }
3575 void G4GMocrenIO::getShortDoseDist(short * _d    3580 void G4GMocrenIO::getShortDoseDist(short * _data, int _z, int _num) {
3576                                                  3581 
3577   if(_data == NULL) {                            3582   if(_data == NULL) {
3578     if (G4VisManager::GetVerbosity() >= G4Vis    3583     if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
3579       G4cout << "In G4GMocrenIO::getShortDose    3584       G4cout << "In G4GMocrenIO::getShortDoseDist(), "
3580     << "first argument is NULL pointer. "        3585     << "first argument is NULL pointer. "
3581     << "The argument must be allocated array.    3586     << "The argument must be allocated array."
3582     << G4endl;                                   3587     << G4endl;
3583     G4Exception("G4GMocrenIO::getShortDoseDis << 3588     std::exit(-1);
3584                 "gMocren2002", FatalException << 
3585                 "Error.");                    << 
3586     return;                                   << 
3587   }                                              3589   }
3588                                                  3590 
3589   int size[3];                                   3591   int size[3];
3590   kDose[_num].getSize(size);                     3592   kDose[_num].getSize(size);
3591   //short * shdata = new short[size[0]*size[1    3593   //short * shdata = new short[size[0]*size[1]];
3592   double * ddata = kDose[_num].getImage(_z);     3594   double * ddata = kDose[_num].getImage(_z);
3593   double scale = kDose[_num].getScale();         3595   double scale = kDose[_num].getScale();
3594   for(int xy = 0; xy < size[0]*size[1]; xy++)    3596   for(int xy = 0; xy < size[0]*size[1]; xy++) {
3595     _data[xy] = (short)(ddata[xy]/scale+0.5);    3597     _data[xy] = (short)(ddata[xy]/scale+0.5); //there is never negative value
3596   }                                              3598   }
3597 }                                                3599 }
3598 void G4GMocrenIO::getShortDoseDistMinMax(shor    3600 void G4GMocrenIO::getShortDoseDistMinMax(short _minmax[2], int _num) {
3599   double scale = kDose[_num].getScale();         3601   double scale = kDose[_num].getScale();
3600   double minmax[2];                              3602   double minmax[2];
3601   kDose[_num].getMinMax(minmax);                 3603   kDose[_num].getMinMax(minmax);
3602   for(int i = 0; i < 2; i++)                     3604   for(int i = 0; i < 2; i++)
3603     _minmax[i] = (short)(minmax[i]/scale+0.5)    3605     _minmax[i] = (short)(minmax[i]/scale+0.5);
3604 }                                                3606 }
3605 //                                               3607 //
3606 void G4GMocrenIO::setDoseDist(double * _image    3608 void G4GMocrenIO::setDoseDist(double * _image, int _num) {
3607                                                  3609 
3608   kDose[_num].addImage(_image);                  3610   kDose[_num].addImage(_image);
3609 }                                                3611 }
3610 double * G4GMocrenIO::getDoseDist(int _z, int    3612 double * G4GMocrenIO::getDoseDist(int _z, int _num) {
3611                                                  3613 
3612   double * image;                                3614   double * image;
3613   if(isDoseEmpty()) {                            3615   if(isDoseEmpty()) {
3614     image = 0;                                   3616     image = 0;
3615   } else {                                       3617   } else {
3616     image = kDose[_num].getImage(_z);            3618     image = kDose[_num].getImage(_z);
3617   }                                              3619   }
3618   return image;                                  3620   return image;
3619 }                                                3621 }
3620 /*                                               3622 /*
3621   void G4GMocrenIO::getDoseDist(double * & _i    3623   void G4GMocrenIO::getDoseDist(double * & _image, int _z, int _num) {
3622                                                  3624 
3623   G4cout << " <" << (void*)_image << "> ";       3625   G4cout << " <" << (void*)_image << "> ";
3624   if(isDoseEmpty()) {                            3626   if(isDoseEmpty()) {
3625   _image = 0;                                    3627   _image = 0;
3626   } else {                                       3628   } else {
3627   _image = kDose[_num].getImage(_z);             3629   _image = kDose[_num].getImage(_z);
3628   G4cout << " <" << (void*)_image << "> ";       3630   G4cout << " <" << (void*)_image << "> ";
3629   G4cout << _image[100] << " ";                  3631   G4cout << _image[100] << " ";
3630   }                                              3632   }
3631   }                                              3633   }
3632 */                                               3634 */
3633 bool G4GMocrenIO::addDoseDist(std::vector<dou    3635 bool G4GMocrenIO::addDoseDist(std::vector<double *> & _image, int _num) {
3634                                                  3636 
3635   int size[3];                                   3637   int size[3];
3636   getDoseDistSize(size, _num);                   3638   getDoseDistSize(size, _num);
3637   std::vector<double *> dosedist = kDose[_num    3639   std::vector<double *> dosedist = kDose[_num].getImage();
3638                                                  3640 
3639   int nimg = size[0]*size[1];                    3641   int nimg = size[0]*size[1];
3640   for(int z = 0; z < size[2]; z++) {             3642   for(int z = 0; z < size[2]; z++) {
3641     for(int xy = 0; xy < nimg; xy++) {           3643     for(int xy = 0; xy < nimg; xy++) {
3642       dosedist[z][xy] += _image[z][xy];          3644       dosedist[z][xy] += _image[z][xy];
3643     }                                            3645     }
3644   }                                              3646   }
3645                                                  3647 
3646   return true;                                   3648   return true;
3647 }                                                3649 }
3648 //void setDoseDistDensityMap(float * _map) {d    3650 //void setDoseDistDensityMap(float * _map) {doseImageDensityMap = _map;};
3649 // set the dose distribution image displaceme    3651 // set the dose distribution image displacement
3650 void G4GMocrenIO::setDoseDistCenterPosition(f    3652 void G4GMocrenIO::setDoseDistCenterPosition(float _center[3], int _num) {
3651                                                  3653 
3652   kDose[_num].setCenterPosition(_center);        3654   kDose[_num].setCenterPosition(_center);
3653 }                                                3655 }
3654 void G4GMocrenIO::getDoseDistCenterPosition(f    3656 void G4GMocrenIO::getDoseDistCenterPosition(float _center[3], int _num) {
3655                                                  3657 
3656   if(isDoseEmpty())                              3658   if(isDoseEmpty())
3657     for(int i = 0; i < 3; i++) _center[i] = 0    3659     for(int i = 0; i < 3; i++) _center[i] = 0;
3658   else                                           3660   else 
3659     kDose[_num].getCenterPosition(_center);      3661     kDose[_num].getCenterPosition(_center);
3660 }                                                3662 }
3661 // set & get name of dose distribution           3663 // set & get name of dose distribution
3662 void G4GMocrenIO::setDoseDistName(std::string    3664 void G4GMocrenIO::setDoseDistName(std::string _name, int _num) {
3663                                                  3665 
3664   kDose[_num].setName(_name);                    3666   kDose[_num].setName(_name);
3665 }                                                3667 }
3666 std::string G4GMocrenIO::getDoseDistName(int     3668 std::string G4GMocrenIO::getDoseDistName(int _num) {
3667                                                  3669 
3668   std::string name;                              3670   std::string name;
3669   if(isDoseEmpty())                              3671   if(isDoseEmpty())
3670     return name;                                 3672     return name;
3671   else                                           3673   else 
3672     return kDose[_num].getName();                3674     return kDose[_num].getName();
3673 }                                                3675 }
3674 // copy dose distributions                       3676 // copy dose distributions
3675 void G4GMocrenIO::copyDoseDist(std::vector<cl    3677 void G4GMocrenIO::copyDoseDist(std::vector<class GMocrenDataPrimitive<double> > & _dose) {
3676   std::vector<class GMocrenDataPrimitive<doub    3678   std::vector<class GMocrenDataPrimitive<double> >::iterator itr;
3677   for(itr = kDose.begin(); itr != kDose.end()    3679   for(itr = kDose.begin(); itr != kDose.end(); itr++) {
3678     _dose.push_back(*itr);                       3680     _dose.push_back(*itr);
3679   }                                              3681   }
3680 }                                                3682 }
3681 // merge two dose distributions                  3683 // merge two dose distributions
3682 bool G4GMocrenIO::mergeDoseDist(std::vector<c    3684 bool G4GMocrenIO::mergeDoseDist(std::vector<class GMocrenDataPrimitive<double> > & _dose) {
3683   if(kDose.size() != _dose.size()) {             3685   if(kDose.size() != _dose.size()) {
3684     if (G4VisManager::GetVerbosity() >= G4Vis    3686     if (G4VisManager::GetVerbosity() >= G4VisManager::errors) {
3685       G4cout << "G4GMocrenIO::mergeDoseDist()    3687       G4cout << "G4GMocrenIO::mergeDoseDist() : Error" << G4endl; 
3686       G4cout << "   Unable to merge the dose     3688       G4cout << "   Unable to merge the dose distributions,"<< G4endl;
3687       G4cout << "   because of different size    3689       G4cout << "   because of different size of dose maps."<< G4endl;
3688     }                                            3690     }
3689     return false;                                3691     return false;
3690   }                                              3692   }
3691                                                  3693 
3692   int num = (int)kDose.size();                << 3694   int num = kDose.size();
3693   std::vector<class GMocrenDataPrimitive<doub    3695   std::vector<class GMocrenDataPrimitive<double> >::iterator itr1 = kDose.begin();
3694   std::vector<class GMocrenDataPrimitive<doub    3696   std::vector<class GMocrenDataPrimitive<double> >::iterator itr2 = _dose.begin();
3695   for(int i = 0; i < num; i++, itr1++, itr2++    3697   for(int i = 0; i < num; i++, itr1++, itr2++) {
3696     if (G4VisManager::GetVerbosity() >= G4Vis    3698     if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
3697       if(kVerbose > 0)                           3699       if(kVerbose > 0)
3698   G4cout << "merged dose distribution [" << i    3700   G4cout << "merged dose distribution [" << i << "]" << G4endl;
3699     *itr1 += *itr2;                              3701     *itr1 += *itr2;
3700   }                                              3702   }
3701                                                  3703 
3702   return true;                                   3704   return true;
3703 }                                                3705 }
3704 //                                               3706 //
3705 void G4GMocrenIO::clearDoseDistAll() {           3707 void G4GMocrenIO::clearDoseDistAll() {
3706                                                  3708 
3707   if(!isDoseEmpty()) {                           3709   if(!isDoseEmpty()) {
3708     for(int i = 0; i < getNumDoseDist(); i++)    3710     for(int i = 0; i < getNumDoseDist(); i++) {
3709       kDose[i].clear();                          3711       kDose[i].clear();
3710     }                                            3712     }
3711     kDose.clear();                               3713     kDose.clear();
3712   }                                              3714   }
3713 }                                                3715 }
3714 //                                               3716 //
3715 bool G4GMocrenIO::isDoseEmpty() {                3717 bool G4GMocrenIO::isDoseEmpty() {
3716   if(kDose.empty()) {                            3718   if(kDose.empty()) {
3717     //if (G4VisManager::GetVerbosity() >= G4V    3719     //if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
3718     //  G4cout << "!!! dose distribution data    3720     //  G4cout << "!!! dose distribution data is empty." << G4endl;
3719     return true;                                 3721     return true;
3720   } else {                                       3722   } else {
3721     return false;                                3723     return false;
3722   }                                              3724   }
3723 }                                                3725 }
3724                                                  3726 
3725 //                                               3727 //
3726 void G4GMocrenIO::calcDoseDistScale() {          3728 void G4GMocrenIO::calcDoseDistScale() {
3727                                                  3729 
3728   double scale;                                  3730   double scale;
3729   double minmax[2];                              3731   double minmax[2];
3730                                                  3732 
3731   for(int i = 0; i < (int)kDose.size(); i++)     3733   for(int i = 0; i < (int)kDose.size(); i++) {
3732     kDose[i].getMinMax(minmax);                  3734     kDose[i].getMinMax(minmax);
3733     scale = minmax[1]/DOSERANGE;                 3735     scale = minmax[1]/DOSERANGE;
3734     kDose[i].setScale(scale);                    3736     kDose[i].setScale(scale);
3735   }                                              3737   }
3736 }                                                3738 }
3737                                                  3739 
3738                                                  3740 
3739 //----- RoI -----//                              3741 //----- RoI -----//
3740                                                  3742 
3741 // add one RoI data                              3743 // add one RoI data
3742 void G4GMocrenIO::newROI() {                     3744 void G4GMocrenIO::newROI() {
3743   GMocrenDataPrimitive<short>  roiData;          3745   GMocrenDataPrimitive<short>  roiData;
3744   kRoi.push_back(roiData);                       3746   kRoi.push_back(roiData);
3745 }                                                3747 }
3746 int G4GMocrenIO::getNumROI() {                   3748 int G4GMocrenIO::getNumROI() {
3747   return (int)kRoi.size();                       3749   return (int)kRoi.size();
3748 }                                                3750 }
3749                                                  3751 
3750 // set/get the ROI image scale                   3752 // set/get the ROI image scale
3751 void G4GMocrenIO::setROIScale(double & _scale    3753 void G4GMocrenIO::setROIScale(double & _scale, int _num) {
3752                                                  3754 
3753   kRoi[_num].setScale(_scale);                   3755   kRoi[_num].setScale(_scale);
3754 }                                                3756 }
3755 double G4GMocrenIO::getROIScale(int _num) {      3757 double G4GMocrenIO::getROIScale(int _num) {
3756                                                  3758 
3757   if(isROIEmpty())                               3759   if(isROIEmpty())
3758     return 0.;                                   3760     return 0.;
3759   else                                           3761   else 
3760     return kRoi[_num].getScale();                3762     return kRoi[_num].getScale();
3761 }                                                3763 }
3762 // set the ROI image                             3764 // set the ROI image 
3763 void G4GMocrenIO::setROI(short * _image, int     3765 void G4GMocrenIO::setROI(short * _image, int _num) {
3764                                                  3766 
3765   kRoi[_num].addImage(_image);                   3767   kRoi[_num].addImage(_image);
3766 }                                                3768 }
3767 short * G4GMocrenIO::getROI(int _z, int _num)    3769 short * G4GMocrenIO::getROI(int _z, int _num) {
3768                                                  3770 
3769   if(isROIEmpty())                               3771   if(isROIEmpty())
3770     return 0;                                    3772     return 0;
3771   else                                           3773   else 
3772     return kRoi[_num].getImage(_z);              3774     return kRoi[_num].getImage(_z);
3773 }                                                3775 }
3774 // set/get the ROI image size                    3776 // set/get the ROI image size
3775 void G4GMocrenIO::setROISize(int _size[3], in    3777 void G4GMocrenIO::setROISize(int _size[3], int _num) {
3776                                                  3778 
3777   return kRoi[_num].setSize(_size);              3779   return kRoi[_num].setSize(_size);
3778 }                                                3780 }
3779 void G4GMocrenIO::getROISize(int _size[3], in    3781 void G4GMocrenIO::getROISize(int _size[3], int _num) {
3780                                                  3782 
3781   if(isROIEmpty())                               3783   if(isROIEmpty())
3782     for(int i = 0; i < 3; i++) _size[i] = 0;     3784     for(int i = 0; i < 3; i++) _size[i] = 0;
3783   else                                           3785   else 
3784     return kRoi[_num].getSize(_size);            3786     return kRoi[_num].getSize(_size);
3785 }                                                3787 }
3786 // set/get the ROI image min. and max.           3788 // set/get the ROI image min. and max.
3787 void G4GMocrenIO::setROIMinMax(short _minmax[    3789 void G4GMocrenIO::setROIMinMax(short _minmax[2], int _num) {
3788                                                  3790 
3789   kRoi[_num].setMinMax(_minmax);                 3791   kRoi[_num].setMinMax(_minmax);
3790 }                                                3792 }
3791 void G4GMocrenIO::getROIMinMax(short _minmax[    3793 void G4GMocrenIO::getROIMinMax(short _minmax[2], int _num) {
3792                                                  3794 
3793   if(isROIEmpty())                               3795   if(isROIEmpty())
3794     for(int i = 0; i < 2; i++) _minmax[i] = 0    3796     for(int i = 0; i < 2; i++) _minmax[i] = 0;
3795   else                                           3797   else 
3796     kRoi[_num].getMinMax(_minmax);               3798     kRoi[_num].getMinMax(_minmax);
3797 }                                                3799 }
3798 // set/get the ROI image displacement            3800 // set/get the ROI image displacement
3799 void G4GMocrenIO::setROICenterPosition(float     3801 void G4GMocrenIO::setROICenterPosition(float _center[3], int _num) {
3800                                                  3802 
3801   kRoi[_num].setCenterPosition(_center);         3803   kRoi[_num].setCenterPosition(_center);
3802 }                                                3804 }
3803 void G4GMocrenIO::getROICenterPosition(float     3805 void G4GMocrenIO::getROICenterPosition(float _center[3], int _num) {
3804                                                  3806 
3805   if(isROIEmpty())                               3807   if(isROIEmpty())
3806     for(int i = 0; i < 3; i++) _center[i] = 0    3808     for(int i = 0; i < 3; i++) _center[i] = 0;
3807   else                                           3809   else 
3808     kRoi[_num].getCenterPosition(_center);       3810     kRoi[_num].getCenterPosition(_center);
3809 }                                                3811 }
3810 //                                               3812 //
3811 void G4GMocrenIO::clearROIAll() {                3813 void G4GMocrenIO::clearROIAll() {
3812                                                  3814 
3813   if(!isROIEmpty()) {                            3815   if(!isROIEmpty()) {
3814     for(int i = 0; i < getNumROI(); i++) {       3816     for(int i = 0; i < getNumROI(); i++) {
3815       kRoi[i].clear();                           3817       kRoi[i].clear();
3816     }                                            3818     }
3817     kRoi.clear();                                3819     kRoi.clear();
3818   }                                              3820   }
3819 }                                                3821 }
3820 //                                               3822 //
3821 bool G4GMocrenIO::isROIEmpty() {                 3823 bool G4GMocrenIO::isROIEmpty() {
3822   if(kRoi.empty()) {                             3824   if(kRoi.empty()) {
3823     //if (G4VisManager::GetVerbosity() >= G4V    3825     //if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
3824     //  G4cout << "!!! ROI data is empty." <<    3826     //  G4cout << "!!! ROI data is empty." << G4endl;
3825     return true;                                 3827     return true;
3826   } else {                                       3828   } else {
3827     return false;                                3829     return false;
3828   }                                              3830   }
3829 }                                                3831 }
3830                                                  3832 
3831                                                  3833 
3832                                                  3834 
3833 //----- Track information -----//                3835 //----- Track information -----//
3834                                                  3836 
3835 int  G4GMocrenIO::getNumTracks() {               3837 int  G4GMocrenIO::getNumTracks() {
3836   return (int)kSteps.size();                     3838   return (int)kSteps.size();
3837 }                                                3839 }
3838 int  G4GMocrenIO::getNumTracks4() {              3840 int  G4GMocrenIO::getNumTracks4() {
3839   return (int)kTracks.size();                    3841   return (int)kTracks.size();
3840 }                                                3842 }
3841 void G4GMocrenIO::addTrack(float * _tracks) {    3843 void G4GMocrenIO::addTrack(float * _tracks) {
3842   kSteps.push_back(_tracks);                     3844   kSteps.push_back(_tracks);
3843 }                                                3845 }
3844 void G4GMocrenIO::setTracks(std::vector<float    3846 void G4GMocrenIO::setTracks(std::vector<float *> & _tracks) {
3845   kSteps = _tracks;                              3847   kSteps = _tracks;
3846 }                                                3848 }
3847 std::vector<float *> & G4GMocrenIO::getTracks    3849 std::vector<float *> & G4GMocrenIO::getTracks() {
3848   return kSteps;                                 3850   return kSteps;
3849 }                                                3851 }
3850 void G4GMocrenIO::addTrackColor(unsigned char    3852 void G4GMocrenIO::addTrackColor(unsigned char * _colors) {
3851   kStepColors.push_back(_colors);                3853   kStepColors.push_back(_colors);
3852 }                                                3854 }
3853 void G4GMocrenIO::setTrackColors(std::vector<    3855 void G4GMocrenIO::setTrackColors(std::vector<unsigned char *> & _trackColors) {
3854   kStepColors = _trackColors;                    3856   kStepColors = _trackColors;
3855 }                                                3857 }
3856 std::vector<unsigned char *> & G4GMocrenIO::g    3858 std::vector<unsigned char *> & G4GMocrenIO::getTrackColors() {
3857   return kStepColors;                            3859   return kStepColors;
3858 }                                                3860 }
3859 void G4GMocrenIO::copyTracks(std::vector<floa    3861 void G4GMocrenIO::copyTracks(std::vector<float *> & _tracks,
3860              std::vector<unsigned char *> & _    3862              std::vector<unsigned char *> & _colors) {
3861   std::vector<float *>::iterator titr;           3863   std::vector<float *>::iterator titr;
3862   for(titr = kSteps.begin(); titr != kSteps.e    3864   for(titr = kSteps.begin(); titr != kSteps.end(); titr++) {
3863     float * pts = new float[6];                  3865     float * pts = new float[6];
3864     for(int i = 0; i < 6; i++) {                 3866     for(int i = 0; i < 6; i++) {
3865       pts[i] = (*titr)[i];                       3867       pts[i] = (*titr)[i];
3866     }                                            3868     }
3867     _tracks.push_back(pts);                      3869     _tracks.push_back(pts);
3868   }                                              3870   }
3869                                                  3871 
3870   std::vector<unsigned char *>::iterator citr    3872   std::vector<unsigned char *>::iterator citr;
3871   for(citr = kStepColors.begin(); citr != kSt    3873   for(citr = kStepColors.begin(); citr != kStepColors.end(); citr++) {
3872     unsigned char * pts = new unsigned char[3    3874     unsigned char * pts = new unsigned char[3];
3873     for(int i = 0; i < 3; i++) {                 3875     for(int i = 0; i < 3; i++) {
3874       pts[i] = (*citr)[i];                       3876       pts[i] = (*citr)[i];
3875     }                                            3877     }
3876     _colors.push_back(pts);                      3878     _colors.push_back(pts);
3877   }                                              3879   }
3878 }                                                3880 }
3879 void G4GMocrenIO::mergeTracks(std::vector<flo    3881 void G4GMocrenIO::mergeTracks(std::vector<float *> & _tracks,
3880         std::vector<unsigned char *> & _color    3882         std::vector<unsigned char *> & _colors) {
3881   std::vector<float *>::iterator titr;           3883   std::vector<float *>::iterator titr;
3882   for(titr = _tracks.begin(); titr != _tracks    3884   for(titr = _tracks.begin(); titr != _tracks.end(); titr++) {
3883     addTrack(*titr);                             3885     addTrack(*titr);
3884   }                                              3886   }
3885                                                  3887 
3886   std::vector<unsigned char *>::iterator citr    3888   std::vector<unsigned char *>::iterator citr;
3887   for(citr = _colors.begin(); citr != _colors    3889   for(citr = _colors.begin(); citr != _colors.end(); citr++) {
3888     addTrackColor(*citr);                        3890     addTrackColor(*citr);
3889   }                                              3891   }
3890 }                                                3892 }
3891 void G4GMocrenIO::addTrack(std::vector<float     3893 void G4GMocrenIO::addTrack(std::vector<float *> & _steps, unsigned char _color[3]) {
3892                                                  3894 
3893   std::vector<float *>::iterator itr = _steps    3895   std::vector<float *>::iterator itr = _steps.begin();
3894     std::vector<struct GMocrenTrack::Step> st    3896     std::vector<struct GMocrenTrack::Step> steps;
3895     for(; itr != _steps.end(); itr++) {          3897     for(; itr != _steps.end(); itr++) {
3896       struct GMocrenTrack::Step step;            3898       struct GMocrenTrack::Step step;
3897       for(int i = 0; i < 3; i++) {               3899       for(int i = 0; i < 3; i++) {
3898   step.startPoint[i] = (*itr)[i];                3900   step.startPoint[i] = (*itr)[i];
3899   step.endPoint[i] = (*itr)[i+3];                3901   step.endPoint[i] = (*itr)[i+3];
3900       }                                          3902       }
3901       steps.push_back(step);                     3903       steps.push_back(step);
3902     }                                            3904     }
3903     GMocrenTrack track;                          3905     GMocrenTrack track;
3904     track.setTrack(steps);                       3906     track.setTrack(steps);
3905     track.setColor(_color);                      3907     track.setColor(_color);
3906     kTracks.push_back(track);                    3908     kTracks.push_back(track);
3907                                                  3909     
3908 }                                                3910 }
3909 void G4GMocrenIO::getTrack(int _num, std::vec    3911 void G4GMocrenIO::getTrack(int _num, std::vector<float *> & _steps,
3910            std::vector<unsigned char *> & _co    3912            std::vector<unsigned char *> & _color) {
3911                                                  3913 
3912   if(_num > (int)kTracks.size()) {               3914   if(_num > (int)kTracks.size()) {
3913     if (G4VisManager::GetVerbosity() >= G4Vis    3915     if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
3914       G4cout << "ERROR in getTrack() : " << G    3916       G4cout << "ERROR in getTrack() : " << G4endl;
3915     G4Exception("G4GMocrenIO::getTrack()",    << 3917     std::exit(-1);
3916                 "gMocren2003", FatalException << 
3917                 "Error.");                    << 
3918   }                                              3918   }
3919   unsigned char * color = new unsigned char[3    3919   unsigned char * color = new unsigned char[3];
3920   kTracks[_num].getColor(color);                 3920   kTracks[_num].getColor(color);
3921   _color.push_back(color);                       3921   _color.push_back(color);
3922                                                  3922 
3923   // steps                                       3923   // steps
3924   int nsteps = kTracks[_num].getNumberOfSteps    3924   int nsteps = kTracks[_num].getNumberOfSteps();
3925   for(int isteps = 0; isteps < nsteps; isteps << 3925   for(int ns = 0; ns < nsteps; ns++) {
3926     float * stepPoints = new float[6];           3926     float * stepPoints = new float[6];
3927     kTracks[_num].getStep(stepPoints[0], step    3927     kTracks[_num].getStep(stepPoints[0], stepPoints[1], stepPoints[2],
3928         stepPoints[3], stepPoints[4], stepPoi    3928         stepPoints[3], stepPoints[4], stepPoints[5],
3929         isteps);                              << 3929         ns);
3930     _steps.push_back(stepPoints);                3930     _steps.push_back(stepPoints);
3931   }                                              3931   }
3932 }                                                3932 }
3933                                                  3933 
3934 void G4GMocrenIO::translateTracks(std::vector    3934 void G4GMocrenIO::translateTracks(std::vector<float> & _translate) {
3935   std::vector<class GMocrenTrack>::iterator i    3935   std::vector<class GMocrenTrack>::iterator itr = kTracks.begin();
3936   for(; itr != kTracks.end(); itr++) {           3936   for(; itr != kTracks.end(); itr++) {
3937     itr->translate(_translate);                  3937     itr->translate(_translate);
3938   }                                              3938   }
3939 }                                                3939 }
3940                                                  3940 
3941                                                  3941 
3942                                                  3942 
3943                                                  3943 
3944 //----- Detector information -----//             3944 //----- Detector information -----//
3945 int  G4GMocrenIO::getNumberOfDetectors() {       3945 int  G4GMocrenIO::getNumberOfDetectors() {
3946   return (int)kDetectors.size();                 3946   return (int)kDetectors.size();
3947 }                                                3947 }
3948 void G4GMocrenIO::addDetector(std::string & _    3948 void G4GMocrenIO::addDetector(std::string & _name,
3949         std::vector<float *> & _det,             3949         std::vector<float *> & _det, 
3950         unsigned char _color[3]) {               3950         unsigned char _color[3]) {
3951                                                  3951 
3952     std::vector<float *>::iterator itr = _det    3952     std::vector<float *>::iterator itr = _det.begin();
3953     std::vector<struct GMocrenDetector::Edge>    3953     std::vector<struct GMocrenDetector::Edge> edges;
3954     for(; itr != _det.end(); itr++) {            3954     for(; itr != _det.end(); itr++) {
3955       struct GMocrenDetector::Edge edge;         3955       struct GMocrenDetector::Edge edge;
3956       for(int i = 0; i < 3; i++) {               3956       for(int i = 0; i < 3; i++) {
3957   edge.startPoint[i] = (*itr)[i];                3957   edge.startPoint[i] = (*itr)[i];
3958   edge.endPoint[i] = (*itr)[i+3];                3958   edge.endPoint[i] = (*itr)[i+3];
3959       }                                          3959       }
3960       edges.push_back(edge);                     3960       edges.push_back(edge);
3961     }                                            3961     }
3962     GMocrenDetector detector;                    3962     GMocrenDetector detector;
3963     detector.setDetector(edges);                 3963     detector.setDetector(edges);
3964     detector.setColor(_color);                   3964     detector.setColor(_color);
3965     detector.setName(_name);                     3965     detector.setName(_name);
3966     kDetectors.push_back(detector);              3966     kDetectors.push_back(detector);
3967                                                  3967     
3968 }                                                3968 }
3969                                                  3969 
3970 void G4GMocrenIO::getDetector(int _num, std::    3970 void G4GMocrenIO::getDetector(int _num, std::vector<float *> & _edges,
3971         std::vector<unsigned char *> & _color    3971         std::vector<unsigned char *> & _color,
3972         std::string & _detName) {                3972         std::string & _detName) {
3973                                                  3973 
3974   if(_num > (int)kDetectors.size()) {            3974   if(_num > (int)kDetectors.size()) {
3975     if (G4VisManager::GetVerbosity() >= G4Vis    3975     if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
3976       G4cout << "ERROR in getDetector() : " <    3976       G4cout << "ERROR in getDetector() : " << G4endl;
3977                                               << 3977     std::exit(-1);
3978     G4Exception("G4GMocrenIO::getDetector()", << 
3979                 "gMocren2004", FatalException << 
3980                 "Error.");                    << 
3981   }                                              3978   }
3982                                                  3979 
3983   _detName = kDetectors[_num].getName();         3980   _detName = kDetectors[_num].getName();
3984                                                  3981 
3985   unsigned char * color = new unsigned char[3    3982   unsigned char * color = new unsigned char[3];
3986   kDetectors[_num].getColor(color);              3983   kDetectors[_num].getColor(color);
3987   _color.push_back(color);                       3984   _color.push_back(color);
3988                                                  3985 
3989   // edges                                       3986   // edges
3990   int nedges = kDetectors[_num].getNumberOfEd    3987   int nedges = kDetectors[_num].getNumberOfEdges();
3991   for(int ne = 0; ne < nedges; ne++) {           3988   for(int ne = 0; ne < nedges; ne++) {
3992     float * edgePoints = new float[6];           3989     float * edgePoints = new float[6];
3993     kDetectors[_num].getEdge(edgePoints[0], e    3990     kDetectors[_num].getEdge(edgePoints[0], edgePoints[1], edgePoints[2],
3994            edgePoints[3], edgePoints[4], edge    3991            edgePoints[3], edgePoints[4], edgePoints[5],
3995            ne);                                  3992            ne);
3996     _edges.push_back(edgePoints);                3993     _edges.push_back(edgePoints);
3997   }                                              3994   }
3998 }                                                3995 }
3999                                                  3996 
4000 void G4GMocrenIO::translateDetector(std::vect    3997 void G4GMocrenIO::translateDetector(std::vector<float> & _translate) {
4001   std::vector<class GMocrenDetector>::iterato    3998   std::vector<class GMocrenDetector>::iterator itr = kDetectors.begin();
4002   for(; itr != kDetectors.end(); itr++) {        3999   for(; itr != kDetectors.end(); itr++) {
4003     itr->translate(_translate);                  4000     itr->translate(_translate);
4004   }                                              4001   }
4005 }                                                4002 }
4006                                                  4003 
4007 // endian conversion                             4004 // endian conversion
4008 template <typename T>                            4005 template <typename T>
4009 void G4GMocrenIO::convertEndian(char * _val,     4006 void G4GMocrenIO::convertEndian(char * _val, T & _rval) {
4010                                                  4007 
4011   if((kLittleEndianOutput && !kLittleEndianIn    4008   if((kLittleEndianOutput && !kLittleEndianInput) ||   // big endian
4012      (!kLittleEndianOutput && kLittleEndianIn    4009      (!kLittleEndianOutput && kLittleEndianInput)) {   // little endian
4013                                                  4010 
4014     const int SIZE = sizeof(_rval);              4011     const int SIZE = sizeof(_rval);
4015     char ctemp;                                  4012     char ctemp;
4016     for(int i = 0; i < SIZE/2; i++) {            4013     for(int i = 0; i < SIZE/2; i++) {
4017       ctemp = _val[i];                           4014       ctemp = _val[i];
4018       _val[i] = _val[SIZE - 1 - i];              4015       _val[i] = _val[SIZE - 1 - i];
4019       _val[SIZE - 1 - i] = ctemp;                4016       _val[SIZE - 1 - i] = ctemp;
4020     }                                            4017     }
4021   }                                              4018   }
4022   _rval = *(T *)_val;                            4019   _rval = *(T *)_val;
4023 }                                                4020 }
4024                                                  4021 
4025 // inversion of byte order                       4022 // inversion of byte order
4026 template <typename T>                            4023 template <typename T>
4027 void G4GMocrenIO::invertByteOrder(char * _val    4024 void G4GMocrenIO::invertByteOrder(char * _val, T & _rval) {
4028                                                  4025 
4029   const int SIZE = sizeof(_rval);                4026   const int SIZE = sizeof(_rval);
4030   //char * cval = new char[SIZE];                4027   //char * cval = new char[SIZE];
4031   union {                                        4028   union {
4032     char cu[16];                                 4029     char cu[16];
4033     T tu;                                        4030     T tu;
4034   } uni;                                         4031   } uni;
4035   for(int i = 0; i < SIZE; i++) {                4032   for(int i = 0; i < SIZE; i++) {
4036     uni.cu[i] = _val[SIZE-1-i];                  4033     uni.cu[i] = _val[SIZE-1-i];
4037     //cval[i] = _val[SIZE-i-1];                  4034     //cval[i] = _val[SIZE-i-1];
4038   }                                              4035   }
4039   //_rval = *(T *)cval;                          4036   //_rval = *(T *)cval;
4040   _rval = uni.tu;                                4037   _rval = uni.tu;
4041   //delete [] cval;                              4038   //delete [] cval;
4042 }                                                4039 }
4043                                                  4040 
4044 //----- kVerbose information -----//             4041 //----- kVerbose information -----//
4045 void G4GMocrenIO::setVerboseLevel(int _level)    4042 void G4GMocrenIO::setVerboseLevel(int _level) {
4046   kVerbose = _level;                             4043   kVerbose = _level;
4047 }                                                4044 }
4048                                                  4045 
4049                                                  4046