Geant4.10
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Public Member Functions
DicomPhantomZSliceHeader Class Reference

#include <DicomPhantomZSliceHeader.hh>

Public Member Functions

 DicomPhantomZSliceHeader (const G4String &)
 
 DicomPhantomZSliceHeader (const DicomPhantomZSliceHeader &rhs)
 
 DicomPhantomZSliceHeader (std::ifstream &fin)
 
 ~DicomPhantomZSliceHeader ()
 
G4int GetNoVoxelX () const
 
G4int GetNoVoxelY () const
 
G4int GetNoVoxelZ () const
 
G4int GetNoVoxels () const
 
G4double GetMinX () const
 
G4double GetMinY () const
 
G4double GetMinZ () const
 
G4double GetMaxX () const
 
G4double GetMaxY () const
 
G4double GetMaxZ () const
 
G4double GetVoxelHalfX () const
 
G4double GetVoxelHalfY () const
 
G4double GetVoxelHalfZ () const
 
const std::vector< G4String > & GetMaterialNames () const
 
void SetNoVoxelX (const G4int &val)
 
void SetNoVoxelY (const G4int &val)
 
void SetNoVoxelZ (const G4int &val)
 
void SetMinX (const G4double &val)
 
void SetMaxX (const G4double &val)
 
void SetMinY (const G4double &val)
 
void SetMaxY (const G4double &val)
 
void SetMinZ (const G4double &val)
 
void SetMaxZ (const G4double &val)
 
void SetMaterialNames (std::vector< G4String > &mn)
 
void operator+= (const DicomPhantomZSliceHeader &rhs)
 
DicomPhantomZSliceHeader operator+ (const DicomPhantomZSliceHeader &rhs)
 
void SetFilename (const G4String &val)
 
void SetSliceLocation (const G4double &val)
 
void AddMaterial (const G4String &val)
 
const G4double & GetSliceLocation () const
 
void AddRow ()
 
void AddValue (G4double val)
 
void AddValue (const std::vector< G4double > &val)
 
void AddValue (const std::vector< std::vector< G4double > > &val)
 
void AddMateID (G4int val)
 
void AddMateID (const std::vector< G4int > &val)
 
void AddMateID (const std::vector< std::vector< G4int > > &val)
 
const std::vector< std::vector
< G4double > > & 		GetValues () const
 
const std::vector< std::vector
< G4int > > & 		GetMateIDs () const
 
void DumpToFile ()
 
void ReadDataFromFile ()
 
void DumpExcessMemory ()
 
void FlipData ()
 

Detailed Description

DicomPhantomZSliceHeader class

Contains the meta data information corresponding to one or several Z slices (number of voxels, dimension)

History: 30.11.07 First version

Author
P. Arce

Definition at line 50 of file DicomPhantomZSliceHeader.hh.

Constructor & Destructor Documentation

DicomPhantomZSliceHeader::DicomPhantomZSliceHeader ( const G4String &  fname)

Definition at line 42 of file DicomPhantomZSliceHeader.cc.

43 : fNoVoxelX(0),fNoVoxelY(0),fNoVoxelZ(0),
44  fMinX(0),fMinY(0),fMinZ(0),
45  fMaxX(0),fMaxY(0),fMaxZ(0),
46  fFilename(fname),fSliceLocation(0)
47 {
48 
49 }
DicomPhantomZSliceHeader::DicomPhantomZSliceHeader ( const DicomPhantomZSliceHeader &  rhs)

Definition at line 58 of file DicomPhantomZSliceHeader.cc.

References GetMaterialNames(), GetMaxX(), GetMaxY(), GetMaxZ(), GetMinX(), GetMinY(), GetMinZ(), GetNoVoxelX(), GetNoVoxelY(), and GetNoVoxelZ().

59 {
60  fNoVoxelX = rhs.GetNoVoxelX();
61  fNoVoxelY = rhs.GetNoVoxelY();
62  fNoVoxelZ = rhs.GetNoVoxelZ();
63  fMinX = rhs.GetMinX();
64  fMaxX = rhs.GetMaxX();
65  fMinY = rhs.GetMinY();
66  fMaxY = rhs.GetMaxY();
67  fMinZ = rhs.GetMinZ();
68  fMaxZ = rhs.GetMaxZ();
69  fMaterialNames = rhs.GetMaterialNames();
70  fFilename = rhs.fFilename;
71  fValues = rhs.fValues;
72  fMateIDs = rhs.fMateIDs;
73  fSliceLocation = rhs.fSliceLocation;
74 }
DicomPhantomZSliceHeader::GetMaterialNames
const std::vector< G4String > & GetMaterialNames() const
Definition: DicomPhantomZSliceHeader.hh:80
DicomPhantomZSliceHeader::DicomPhantomZSliceHeader ( std::ifstream &  fin)

Definition at line 77 of file DicomPhantomZSliceHeader.cc.

References FatalErrorInArgument, G4cout, G4endl, and G4Exception().

78 {
79  //----- Read material indices and names
80  G4int nmate;
81  G4String mateindex;
82  G4String matename;
83  fin >> nmate;
84 #ifdef G4VERBOSE
85  G4cout << " DicomPhantomZSliceHeader reading number of materials " << nmate << G4endl;
86 #endif
87 
88  for( G4int im = 0; im < nmate; im++ ){
89  fin >> mateindex >> matename;
90 #ifdef G4VERBOSE
91  G4cout << " DicomPhantomZSliceHeader reading material " << im << " : "
92  << mateindex << " " << matename << G4endl;
93 #endif
94 
95  if( ! CheckMaterialExists( matename ) ) {
96  G4Exception("DicomPhantomZSliceHeader::DicomPhantomZSliceHeader",
97  "A material is found in file that is not built in the C++ code",
98  FatalErrorInArgument, matename.c_str());
99  }
100 
101  fMaterialNames.push_back(matename);
102  }
103 
104  //----- Read number of voxels
105  fin >> fNoVoxelX >> fNoVoxelY >> fNoVoxelZ;
106 #ifdef G4VERBOSE
107  G4cout << " Number of voxels " << fNoVoxelX << " " << fNoVoxelY << " " << fNoVoxelZ << G4endl;
108 #endif
109 
110  //----- Read minimal and maximal extensions (= walls of phantom)
111  fin >> fMinX >> fMaxX;
112  fin >> fMinY >> fMaxY;
113  fin >> fMinZ >> fMaxZ;
114 #ifdef G4VERBOSE
115  G4cout << " Extension in X " << fMinX << " " << fMaxX << G4endl
116  << " Extension in Y " << fMinY << " " << fMaxY << G4endl
117  << " Extension in Z " << fMinZ << " " << fMaxZ << G4endl;
118 #endif
119 
120  fSliceLocation = 0.5*(fMinZ + fMaxZ);
121 }
G4int
int G4int
Definition: G4Types.hh:78
G4cout
G4GLOB_DLL std::ostream G4cout
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
FatalErrorInArgument
Definition: G4ExceptionSeverity.hh:61
G4endl
#define G4endl
Definition: G4ios.hh:61
DicomPhantomZSliceHeader::~DicomPhantomZSliceHeader ( )

Definition at line 52 of file DicomPhantomZSliceHeader.cc.

53 {
54 
55 }

Member Function Documentation

void DicomPhantomZSliceHeader::AddMateID ( G4int  val)
inline

Definition at line 128 of file DicomPhantomZSliceHeader.hh.

128 { (fMateIDs.size() > 0) ? fMateIDs.back().push_back(val) : fMateIDs.push_back(std::vector<G4int>(1,val)); }
void DicomPhantomZSliceHeader::AddMateID ( const std::vector< G4int > &  val)
inline

Definition at line 129 of file DicomPhantomZSliceHeader.hh.

129 { fMateIDs.push_back(val); }
void DicomPhantomZSliceHeader::AddMateID ( const std::vector< std::vector< G4int > > &  val)
inline

Definition at line 130 of file DicomPhantomZSliceHeader.hh.

130  {
131  for(unsigned int i = 0; i < val.size(); ++i) { fMateIDs.push_back(val.at(i)); }
132  }
void DicomPhantomZSliceHeader::AddMaterial ( const G4String &  val)
inline

Definition at line 116 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomHandler::ReadFile().

116 { fMaterialNames.push_back(val); }
void DicomPhantomZSliceHeader::AddRow ( )
inline

Definition at line 120 of file DicomPhantomZSliceHeader.hh.

120 { fValues.push_back(std::vector<G4double>(0)); fMateIDs.push_back(std::vector<G4int>(0)); }
void DicomPhantomZSliceHeader::AddValue ( G4double  val)
inline

Definition at line 122 of file DicomPhantomZSliceHeader.hh.

122 { (fValues.size() > 0) ? fValues.back().push_back(val) : fValues.push_back(std::vector<G4double>(1,val)); }
void DicomPhantomZSliceHeader::AddValue ( const std::vector< G4double > &  val)
inline

Definition at line 123 of file DicomPhantomZSliceHeader.hh.

123 { fValues.push_back(val); }
void DicomPhantomZSliceHeader::AddValue ( const std::vector< std::vector< G4double > > &  val)
inline

Definition at line 124 of file DicomPhantomZSliceHeader.hh.

124  {
125  for(unsigned int i = 0; i < val.size(); ++i) { fValues.push_back(val.at(i)); }
126  }
void DicomPhantomZSliceHeader::DumpExcessMemory ( )
inline

Definition at line 140 of file DicomPhantomZSliceHeader.hh.

140 { if(fFilename.length() != 0) { fValues.clear(); fMateIDs.clear(); } }
void DicomPhantomZSliceHeader::DumpToFile ( )

Definition at line 212 of file DicomPhantomZSliceHeader.cc.

References FatalException, G4cout, G4endl, G4Exception(), and ReadDataFromFile().

213 {
214 
215  G4cout << "DicomPhantomZSliceHeader::Dumping Z Slice data to " << fFilename << "..." << G4endl;
216  //sleep(5);
217 
218  // May seen counter-intuitive (dumping to file you are reading from), but
219  // the reason for this is modification slice spacing
220  if(fMateIDs.size() == 0 || fValues.size() == 0) { ReadDataFromFile(); }
221 
222 
223  std::ofstream out;
224  out.open(fFilename.c_str());
225 
226  if(!out) {
227  G4String descript = "DicomPhantomZSliceHeader::DumpToFile: could not open "+fFilename;
228  G4Exception(descript.c_str(),"", FatalException, "");
229  }
230 
231 
232  out << fMaterialNames.size() << std::endl;
233  for(unsigned int i = 0; i < fMaterialNames.size(); ++i) {
234  out << i << " " << fMaterialNames.at(i) << std::endl;
235  }
236 
237  out << fNoVoxelX << " " << fNoVoxelY << " " << fNoVoxelZ << std::endl;
238  out << fMinX << " " << fMaxX << std::endl;
239  out << fMinY << " " << fMaxY << std::endl;
240  out << fMinZ << " " << fMaxZ << std::endl;
241 
242  for(unsigned int i = 0; i < fMateIDs.size(); ++i) { print(out,fMateIDs.at(i)," "); }
243  for(unsigned int i = 0; i < fValues.size(); ++i) { print(out,fValues.at(i)," ",6); }
244 
245  out.close();
246 
247 }
G4cout
G4GLOB_DLL std::ostream G4cout
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
FatalException
Definition: G4ExceptionSeverity.hh:60
G4endl
#define G4endl
Definition: G4ios.hh:61
print
void print(const std::vector< T > &data)
Definition: DicomRun.hh:111
void DicomPhantomZSliceHeader::FlipData ( )
inline

Definition at line 174 of file DicomPhantomZSliceHeader.hh.

References reverse.

175 {
176  std::reverse(fValues.begin(), fValues.end());
177  std::reverse(fMateIDs.begin(), fMateIDs.end());
178 }
reverse
Definition: F04UserTrackInformation.hh:37
const std::vector<std::vector<G4int> >& DicomPhantomZSliceHeader::GetMateIDs ( ) const
inline

Definition at line 135 of file DicomPhantomZSliceHeader.hh.

135 { return fMateIDs; }
const std::vector<G4String>& DicomPhantomZSliceHeader::GetMaterialNames ( ) const
inline

Definition at line 80 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomPhantomZSliceHeader(), and operator+().

80 { return fMaterialNames; };
G4double DicomPhantomZSliceHeader::GetMaxX ( ) const
inline

Definition at line 72 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomDetectorConstruction::ConstructPhantomContainer(), DicomPhantomZSliceHeader(), and operator+().

72 { return fMaxX; };
G4double DicomPhantomZSliceHeader::GetMaxY ( ) const
inline

Definition at line 73 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomDetectorConstruction::ConstructPhantomContainer(), DicomPhantomZSliceHeader(), and operator+().

73 { return fMaxY; };
G4double DicomPhantomZSliceHeader::GetMaxZ ( ) const
inline

Definition at line 74 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomPhantomZSliceMerged::CheckSlices(), DicomDetectorConstruction::ConstructPhantomContainer(), DicomPhantomZSliceHeader(), and operator+().

74 { return fMaxZ; };
G4double DicomPhantomZSliceHeader::GetMinX ( ) const
inline

Definition at line 69 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomDetectorConstruction::ConstructPhantomContainer(), DicomPhantomZSliceHeader(), and operator+().

69 { return fMinX; };
G4double DicomPhantomZSliceHeader::GetMinY ( ) const
inline

Definition at line 70 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomDetectorConstruction::ConstructPhantomContainer(), DicomPhantomZSliceHeader(), and operator+().

70 { return fMinY; };
G4double DicomPhantomZSliceHeader::GetMinZ ( ) const
inline

Definition at line 71 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomPhantomZSliceMerged::CheckSlices(), DicomDetectorConstruction::ConstructPhantomContainer(), DicomPhantomZSliceHeader(), and operator+().

71 { return fMinZ; };
G4int DicomPhantomZSliceHeader::GetNoVoxels ( ) const
inline

Definition at line 67 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomDetectorConstruction::ReadPhantomDataFile().

67 { return fNoVoxelX*fNoVoxelY*fNoVoxelZ; };
G4int DicomPhantomZSliceHeader::GetNoVoxelX ( ) const
inline

Definition at line 64 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomDetectorConstruction::ConstructPhantomContainer(), DicomPhantomZSliceHeader(), and operator+().

64 { return fNoVoxelX; };
G4int DicomPhantomZSliceHeader::GetNoVoxelY ( ) const
inline

Definition at line 65 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomDetectorConstruction::ConstructPhantomContainer(), DicomPhantomZSliceHeader(), and operator+().

65 { return fNoVoxelY; };
G4int DicomPhantomZSliceHeader::GetNoVoxelZ ( ) const
inline

Definition at line 66 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomDetectorConstruction::ConstructPhantomContainer(), DicomPhantomZSliceHeader(), and operator+().

66 { return fNoVoxelZ; };
const G4double& DicomPhantomZSliceHeader::GetSliceLocation ( ) const
inline

Definition at line 118 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomPhantomZSliceMerged::AddZSlice(), and DicomPhantomZSliceMerged::CheckSlices().

118 { return fSliceLocation; }
const std::vector<std::vector<G4double> >& DicomPhantomZSliceHeader::GetValues ( ) const
inline

Definition at line 134 of file DicomPhantomZSliceHeader.hh.

134 { return fValues; }
G4double DicomPhantomZSliceHeader::GetVoxelHalfX ( ) const
inline

Definition at line 76 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomDetectorConstruction::ConstructPhantomContainer().

76 { return (fMaxX-fMinX)/fNoVoxelX/2.; };
G4double DicomPhantomZSliceHeader::GetVoxelHalfY ( ) const
inline

Definition at line 77 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomDetectorConstruction::ConstructPhantomContainer().

77 { return (fMaxY-fMinY)/fNoVoxelY/2.; };
G4double DicomPhantomZSliceHeader::GetVoxelHalfZ ( ) const
inline

Definition at line 78 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomDetectorConstruction::ConstructPhantomContainer().

78 { return (fMaxZ-fMinZ)/fNoVoxelZ/2.; };
DicomPhantomZSliceHeader DicomPhantomZSliceHeader::operator+ ( const DicomPhantomZSliceHeader &  rhs)

Definition at line 143 of file DicomPhantomZSliceHeader.cc.

References FatalErrorInArgument, G4cerr, G4endl, G4Exception(), G4GeometryTolerance::GetInstance(), GetMaterialNames(), GetMaxX(), GetMaxY(), GetMaxZ(), GetMinX(), GetMinY(), GetMinZ(), GetNoVoxelX(), GetNoVoxelY(), GetNoVoxelZ(), G4GeometryTolerance::GetRadialTolerance(), G4INCL::Math::max(), G4INCL::Math::min(), SetMaxZ(), SetMinZ(), and SetNoVoxelZ().

144 {
145  //----- Check that both slices has the same dimensions
146  if( fNoVoxelX != rhs.GetNoVoxelX()
147  || fNoVoxelY != rhs.GetNoVoxelY() ) {
148  G4cerr << "DicomPhantomZSliceHeader error adding two slice headers:\
149  !!! Different number of voxels: "
150  << " X= " << fNoVoxelX << " =? " << rhs.GetNoVoxelX()
151  << " Y= " << fNoVoxelY << " =? " << rhs.GetNoVoxelY()
152  << " Z= " << fNoVoxelZ << " =? " << rhs.GetNoVoxelZ()
153  << G4endl;
154  G4Exception("DicomPhantomZSliceHeader::DicomPhantomZSliceHeader",
155  "",FatalErrorInArgument,"");
156  }
157  //----- Check that both slices has the same extensions
158  if( fMinX != rhs.GetMinX() || fMaxX != rhs.GetMaxX()
159  || fMinY != rhs.GetMinY() || fMaxY != rhs.GetMaxY() ) {
160  G4cerr << "DicomPhantomZSliceHeader error adding two slice headers:\
161  !!! Different extensions: "
162  << " Xmin= " << fMinX << " =? " << rhs.GetMinX()
163  << " Xmax= " << fMaxX << " =? " << rhs.GetMaxX()
164  << " Ymin= " << fMinY << " =? " << rhs.GetMinY()
165  << " Ymax= " << fMaxY << " =? " << rhs.GetMaxY()
166  << G4endl;
167  G4Exception("DicomPhantomZSliceHeader::operator+","",FatalErrorInArgument,"");
168  }
169 
170  //----- Check that both slices has the same materials
171  std::vector<G4String> fMaterialNames2 = rhs.GetMaterialNames();
172  if( fMaterialNames.size() != fMaterialNames2.size() ) {
173  G4cerr << "DicomPhantomZSliceHeader error adding two slice headers:\
174  !!! Different number of materials: " << fMaterialNames.size() << " =? "
175  << fMaterialNames2.size() << G4endl;
176  G4Exception("DicomPhantomZSliceHeader::operator+","",FatalErrorInArgument,"");
177  }
178  for( unsigned int ii = 0; ii < fMaterialNames.size(); ii++ ) {
179  if( fMaterialNames[ii] != fMaterialNames2[ii] ) {
180  G4cerr << "DicomPhantomZSliceHeader error adding two slice headers:\
181  !!! Different material number " << ii << " : " << fMaterialNames[ii] << " =? "
182  << fMaterialNames2[ii] << G4endl;
183  G4Exception("DicomPhantomZSliceHeader::operator+","",FatalErrorInArgument,"");
184  }
185  }
186 
187  //----- Check that the slices are contiguous in Z
188  if( std::fabs( fMinZ - rhs.GetMaxZ() ) >
189  G4GeometryTolerance::GetInstance()->GetRadialTolerance() &&
190  std::fabs( fMaxZ - rhs.GetMinZ() ) >
191  G4GeometryTolerance::GetInstance()->GetRadialTolerance() ){
192  G4cerr << "DicomPhantomZSliceHeader error adding two slice headers: !!!\
193  Slices are not contiguous in Z "
194  << " Zmin= " << fMinZ << " & " << rhs.GetMinZ()
195  << " Zmax= " << fMaxZ << " & " << rhs.GetMaxZ()
196  << G4endl;
197  G4Exception("DicomPhantomZSliceHeader::operator+","",FatalErrorInArgument,"");
198  }
199 
200  //----- Build slice header copying first one
201  DicomPhantomZSliceHeader temp( *this );
202 
203  //----- Add data from second slice header
204  temp.SetMinZ( std::min( fMinZ, rhs.GetMinZ() ) );
205  temp.SetMaxZ( std::max( fMaxZ, rhs.GetMaxZ() ) );
206  temp.SetNoVoxelZ( fNoVoxelZ + rhs.GetNoVoxelZ() );
207 
208  return temp;
209 }
DicomPhantomZSliceHeader::GetMaterialNames
const std::vector< G4String > & GetMaterialNames() const
Definition: DicomPhantomZSliceHeader.hh:80
G4GeometryTolerance::GetRadialTolerance
G4double GetRadialTolerance() const
Definition: G4GeometryTolerance.cc:97
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
FatalErrorInArgument
Definition: G4ExceptionSeverity.hh:61
G4INCL::Math::max
T max(const T t1, const T t2)
brief Return the largest of the two arguments
Definition: G4INCLGlobals.hh:116
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:121
G4endl
#define G4endl
Definition: G4ios.hh:61
G4GeometryTolerance::GetInstance
static G4GeometryTolerance * GetInstance()
Definition: G4GeometryTolerance.cc:74
G4cerr
G4GLOB_DLL std::ostream G4cerr
void DicomPhantomZSliceHeader::operator+= ( const DicomPhantomZSliceHeader &  rhs)

Definition at line 137 of file DicomPhantomZSliceHeader.cc.

138 {
139  *this = *this + rhs;
140 }
void DicomPhantomZSliceHeader::ReadDataFromFile ( )

Definition at line 250 of file DicomPhantomZSliceHeader.cc.

References FatalException, and G4Exception().

Referenced by DumpToFile().

251 {
252  std::ifstream in;
253  in.open(fFilename.c_str());
254 
255  if(!in) {
256  G4String descript = "DicomPhantomZSliceHeader::DumpToFile: could not open "+fFilename;
257  G4Exception(descript.c_str(),"", FatalException, "");
258  }
259 
260  G4int nMaterials;
261  in >> nMaterials;
262 
263  fMaterialNames.resize(nMaterials,"");
264  for(G4int i = 0; i < nMaterials; ++i) {
265  G4String str1, str2;
266  in >> str1 >> str2;
267  if(!IsInteger(str1)) {
268  G4String descript = "String : " + str1 + " supposed to be integer";
269  G4Exception("DicomPhantomZSliceHeader::ReadDataFromFile - error in \
270  formatting: missing material index","", FatalException,descript.c_str());
271  }
272  G4int index = g4s2n<G4int>(str1);
273  if(index > nMaterials || index < 0) {
274  G4String descript = "Index : " + str1;
275  G4Exception("DicomPhantomZSliceHeader::ReadDataFromFile - error:\
276  bad material index","", FatalException,descript.c_str());
277  }
278  fMaterialNames[index] = str2;
279  }
280 
281  in >> fNoVoxelX >> fNoVoxelY >> fNoVoxelZ;
282 
283  G4double tmpMinX, tmpMinY, tmpMinZ;
284  G4double tmpMaxX, tmpMaxY, tmpMaxZ;
285 
286  in >> tmpMinX >> tmpMaxX;
287  in >> tmpMinY >> tmpMaxY;
288  in >> tmpMinZ >> tmpMaxZ;
289 
290  fMinX = (CheckConsistency(tmpMinX,fMinX,"Min X value")) ?
291  fMinX : ((fMinX == 0) ? tmpMinX : fMinX);
292  fMaxX = (CheckConsistency(tmpMaxX,fMaxX,"Max X value")) ?
293  fMaxX : ((fMaxX == 0) ? tmpMaxX : fMaxX);
294 
295  fMinY = (CheckConsistency(tmpMinY,fMinY,"Min Y value")) ?
296  fMinY : ((fMinY == 0) ? tmpMinY : fMinY);
297  fMaxY = (CheckConsistency(tmpMaxY,fMaxY,"Max Y value")) ?
298  fMaxY : ((fMaxY == 0) ? tmpMaxY : fMaxY);
299 
300  fMinZ = (CheckConsistency(tmpMinZ,fMinZ,"Min Z value")) ?
301  fMinZ : ((fMinZ == 0) ? tmpMinZ : fMinZ);
302  fMaxZ = (CheckConsistency(tmpMaxZ,fMaxZ,"Max Z value")) ?
303  fMaxZ : ((fMaxZ == 0) ? tmpMaxZ : fMaxZ);
304 
305  fMateIDs.clear();
306  fValues.clear();
307  fMateIDs.resize(fNoVoxelY*fNoVoxelZ,std::vector<G4int>(fNoVoxelX,0));
308  fValues.resize(fNoVoxelY*fNoVoxelZ,std::vector<G4double>(fNoVoxelX,0.));
309  for(G4int k = 0; k < fNoVoxelZ; ++k) {
310  for(G4int j = 0; j < fNoVoxelY; ++j) {
311  for(G4int i = 0; i < fNoVoxelX; ++i) {
312  G4int tmpMateID;
313  in >> tmpMateID;
314  G4int row = j*(k+1);
315  fMateIDs[row][i] = tmpMateID;
316  }
317  }
318  }
319 
320  for(G4int k = 0; k < fNoVoxelZ; ++k) {
321  for(G4int j = 0; j < fNoVoxelY; ++j) {
322  for(G4int i = 0; i < fNoVoxelX; ++i) {
323  G4double tmpValue;
324  in >> tmpValue;
325  G4int row = j*(k+1);
326  fValues[row][i] = tmpValue;
327  }
328  }
329  }
330 
331 
332  in.close();
333 }
G4int
int G4int
Definition: G4Types.hh:78
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
FatalException
Definition: G4ExceptionSeverity.hh:60
G4double
double G4double
Definition: G4Types.hh:76
void DicomPhantomZSliceHeader::SetFilename ( const G4String &  val)
inline

Definition at line 114 of file DicomPhantomZSliceHeader.hh.

114 { fFilename = val; }
void DicomPhantomZSliceHeader::SetMaterialNames ( std::vector< G4String > &  mn)
inline

Definition at line 94 of file DicomPhantomZSliceHeader.hh.

94 { fMaterialNames = mn; }
void DicomPhantomZSliceHeader::SetMaxX ( const G4double &  val)
inline

Definition at line 88 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomHandler::ReadFile().

88 { fMaxX = val; };
void DicomPhantomZSliceHeader::SetMaxY ( const G4double &  val)
inline

Definition at line 90 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomHandler::ReadFile().

90 { fMaxY = val; };
void DicomPhantomZSliceHeader::SetMaxZ ( const G4double &  val)
inline

Definition at line 92 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomPhantomZSliceMerged::CheckSlices(), operator+(), and DicomHandler::ReadFile().

92 { fMaxZ = val; };
void DicomPhantomZSliceHeader::SetMinX ( const G4double &  val)
inline

Definition at line 87 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomHandler::ReadFile().

87 { fMinX = val; };
void DicomPhantomZSliceHeader::SetMinY ( const G4double &  val)
inline

Definition at line 89 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomHandler::ReadFile().

89 { fMinY = val; };
void DicomPhantomZSliceHeader::SetMinZ ( const G4double &  val)
inline

Definition at line 91 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomPhantomZSliceMerged::CheckSlices(), operator+(), and DicomHandler::ReadFile().

91 { fMinZ = val; };
void DicomPhantomZSliceHeader::SetNoVoxelX ( const G4int &  val)
inline

Definition at line 83 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomHandler::ReadFile().

83 { fNoVoxelX = val; }
void DicomPhantomZSliceHeader::SetNoVoxelY ( const G4int &  val)
inline

Definition at line 84 of file DicomPhantomZSliceHeader.hh.

Referenced by DicomHandler::ReadFile().

84 { fNoVoxelY = val; }
void DicomPhantomZSliceHeader::SetNoVoxelZ ( const G4int &  val)
inline

Definition at line 85 of file DicomPhantomZSliceHeader.hh.

Referenced by operator+(), and DicomHandler::ReadFile().

85 { fNoVoxelZ = val; }
void DicomPhantomZSliceHeader::SetSliceLocation ( const G4double &  val)
inline

Definition at line 115 of file DicomPhantomZSliceHeader.hh.

115 { fSliceLocation = val; }
The documentation for this class was generated from the following files:
Generated on Wed Apr 30 2014 15:56:01 for Geant4.10 by   doxygen 1.8.7