#include <HadrontherapyMatrix.hh>

Public Member Functions
	~HadrontherapyMatrix ()

void	PrintNuclides ()

void	ClearHitTrack ()

G4int *	GetHitTrack (G4int i, G4int j, G4int k)

void	Initialize ()

void	Clear ()

G4bool	Fill (G4int, G4ParticleDefinition *particleDef, G4int i, G4int j, G4int k, G4double energyDeposit, G4bool fluence=false)

void	Fill (G4int i, G4int j, G4int k, G4double energyDeposit)

void	TotalEnergyDeposit ()

void	StoreMatrix (G4String file, void *data, size_t psize)

void	StoreFluenceData ()

void	StoreDoseData ()

void	StoreDoseFluenceAscii (G4String filename="")

G4int	Index (G4int i, G4int j, G4int k)

G4double *	GetMatrix ()

G4int	GetNvoxel ()

G4int	GetNumberOfVoxelAlongX ()

G4int	GetNumberOfVoxelAlongY ()

G4int	GetNumberOfVoxelAlongZ ()

Static Public Member Functions
static HadrontherapyMatrix *	GetInstance ()

static HadrontherapyMatrix *	GetInstance (G4int nX, G4int nY, G4int nZ, G4double mass)

Static Public Attributes
static G4bool	secondary = false

Detailed Description

Definition at line 61 of file HadrontherapyMatrix.hh.

Constructor & Destructor Documentation

HadrontherapyMatrix::~HadrontherapyMatrix ( )

Definition at line 95 of file HadrontherapyMatrix.cc.

References Clear().

 {
     delete[] matrix;
     delete[] hitTrack;
     // free fluences/dose data memory
     Clear();
 }

Member Function Documentation

void HadrontherapyMatrix::Clear ( )

Definition at line 104 of file HadrontherapyMatrix.cc.

Referenced by Initialize(), and ~HadrontherapyMatrix().

 {
     for (size_t i=0; i<ionStore.size(); i++)
     {
     delete[] ionStore[i].dose; 
     delete[] ionStore[i].fluence; 
     }
     ionStore.clear();
 }

void HadrontherapyMatrix::ClearHitTrack ( )

Definition at line 138 of file HadrontherapyMatrix.cc.

 {
     for(G4int i=0; i<numberOfVoxelAlongX*numberOfVoxelAlongY*numberOfVoxelAlongZ; i++) hitTrack[i] = 0;
 }

G4bool HadrontherapyMatrix::Fill	(	G4int	trackID,
		G4ParticleDefinition *	particleDef,
		G4int	i,
		G4int	j,
		G4int	k,
		G4double	energyDeposit,
		G4bool	fluence = `false`
	)

Definition at line 154 of file HadrontherapyMatrix.cc.

References ion::dose, ion::fluence, Index(), and secondary.

 {
     if ( (energyDeposit <=0. && !fluence) || !secondary) return false;
     // Get Particle Data Group particle ID 
     G4int PDGencoding = particleDef -> GetPDGEncoding();
     PDGencoding -= PDGencoding%10;
     
     // Search for already allocated data...
     for (size_t l=0; l < ionStore.size(); l++)
     {
         if (ionStore[l].PDGencoding == PDGencoding ) 
         {   // Is it a primary or a secondary particle? 
           if ( (trackID ==1 && ionStore[l].isPrimary) || (trackID !=1 && !ionStore[l].isPrimary))
             {
                 if (energyDeposit > 0.) ionStore[l].dose[Index(i, j, k)] += energyDeposit;
                 
                     // Fill a matrix per each ion with the fluence
                 if (fluence) ionStore[l].fluence[Index(i, j, k)]++;
                 return true;
             }
         }
     }
     
     G4int Z = particleDef-> GetAtomicNumber();
     G4int A = particleDef-> GetAtomicMass();
 
     G4String fullName = particleDef -> GetParticleName();
     G4String name = fullName.substr (0, fullName.find("[") ); // cut excitation energy  
   // Let's put a new particle in our store...
     ion newIon = 
     {
         (trackID == 1) ? true:false,
         PDGencoding,
         name,
         name.length(), 
         Z, 
         A, 
         new G4double[numberOfVoxelAlongX * numberOfVoxelAlongY * numberOfVoxelAlongZ],
         new unsigned int[numberOfVoxelAlongX * numberOfVoxelAlongY * numberOfVoxelAlongZ]
     }; 
         // Initialize data
     if (newIon.dose && newIon.fluence)
     {
         for(G4int q=0; q<numberOfVoxelAlongX*numberOfVoxelAlongY*numberOfVoxelAlongZ; q++)
         {
             newIon.dose[q] = 0.;
             newIon.fluence[q] = 0;
         }
         if (energyDeposit > 0.) newIon.dose[Index(i, j, k)] += energyDeposit;
         if (fluence) newIon.fluence[Index(i, j, k)]++;
         
         ionStore.push_back(newIon);
         
         // TODO Put some verbosity check
         /*
          G4cout << "Memory space to store the DOSE/FLUENCE into " <<  
          numberOfVoxelAlongX*numberOfVoxelAlongY*numberOfVoxelAlongZ << 
          " voxels has been allocated for the nuclide " << newIon.name << 
          " (Z = " << Z << ", A = " << A << ")" << G4endl ;
          */
         return true;
     }
     else // XXX Out of memory! XXX
     {
         return false;
     }
     
 }

void HadrontherapyMatrix::Fill	(	G4int	i,
		G4int	j,
		G4int	k,
		G4double	energyDeposit
	)

Definition at line 383 of file HadrontherapyMatrix.cc.

References Index().

 {
     if (matrix)
         matrix[Index(i,j,k)] += energyDeposit;
     
     // Store the energy deposit in the matrix element corresponding 
     // to the phantom voxel  
 }

G4int * HadrontherapyMatrix::GetHitTrack	(	G4int	i,
		G4int	j,
		G4int	k
	)

Definition at line 143 of file HadrontherapyMatrix.cc.

References Index().

 {
     return &(hitTrack[Index(i,j,k)]);
 }

HadrontherapyMatrix * HadrontherapyMatrix::GetInstance ( )

static

Definition at line 54 of file HadrontherapyMatrix.cc.

Referenced by HadrontherapyEventAction::EndOfEventAction(), main(), HadrontherapyDetectorSD::ProcessHits(), HadrontherapyAnalysisFileMessenger::SetNewValue(), and HadrontherapyDetectorConstruction::UpdateGeometry().

 {
     return instance;
 }

HadrontherapyMatrix * HadrontherapyMatrix::GetInstance	(	G4int	nX,
		G4int	nY,
		G4int	nZ,
		G4double	mass
	)

static

Definition at line 60 of file HadrontherapyMatrix.cc.

References Initialize().

 {
     if (instance) delete instance;
     instance = new HadrontherapyMatrix(voxelX, voxelY, voxelZ, mass);
     instance -> Initialize(); 
     return instance;
 }

G4double* HadrontherapyMatrix::GetMatrix ( )

inline

Definition at line 120 of file HadrontherapyMatrix.hh.

120 {return matrix;}

G4int HadrontherapyMatrix::GetNumberOfVoxelAlongX ( )

inline

Definition at line 124 of file HadrontherapyMatrix.hh.

124 {return numberOfVoxelAlongX;}

G4int HadrontherapyMatrix::GetNumberOfVoxelAlongY ( )

inline

Definition at line 125 of file HadrontherapyMatrix.hh.

125 {return numberOfVoxelAlongY;}

G4int HadrontherapyMatrix::GetNumberOfVoxelAlongZ ( )

inline

Definition at line 126 of file HadrontherapyMatrix.hh.

126 {return numberOfVoxelAlongZ;}

G4int HadrontherapyMatrix::GetNvoxel ( )

inline

Definition at line 122 of file HadrontherapyMatrix.hh.

122 {return numberOfVoxelAlongX*numberOfVoxelAlongY*numberOfVoxelAlongZ;}

G4int HadrontherapyMatrix::Index	(	G4int	i,
		G4int	j,
		G4int	k
	)

inline

Definition at line 117 of file HadrontherapyMatrix.hh.

Referenced by Fill(), GetHitTrack(), StoreDoseFluenceAscii(), StoreMatrix(), and TotalEnergyDeposit().

117 { return (i * numberOfVoxelAlongY + j) * numberOfVoxelAlongZ + k; }

void HadrontherapyMatrix::Initialize ( )

Definition at line 116 of file HadrontherapyMatrix.cc.

References Clear().

Referenced by GetInstance().

 { 
     // Clear ions store
     Clear();
     // Clear dose
     for(int i=0;i<numberOfVoxelAlongX*numberOfVoxelAlongY*numberOfVoxelAlongZ;i++)
     {
         matrix[i] = 0;
     }
 }

void HadrontherapyMatrix::PrintNuclides ( )

Definition at line 129 of file HadrontherapyMatrix.cc.

References G4cout, and G4endl.

 {
     for (size_t i=0; i<ionStore.size(); i++)
     {
         G4cout << ionStore[i].name << G4endl;
     }
 }

void HadrontherapyMatrix::StoreDoseData ( )

Definition at line 273 of file HadrontherapyMatrix.cc.

References StoreMatrix().

 {
     
     for (size_t i=0; i < ionStore.size(); i++){
         StoreMatrix(ionStore[i].name + "_Dose.out", ionStore[i].dose, sizeof(G4double));
     }
 }

void HadrontherapyMatrix::StoreDoseFluenceAscii ( G4String filename = "" )

Definition at line 284 of file HadrontherapyMatrix.cc.

References test::a, G4cout, G4endl, Index(), left, n, secondary, sort(), and width.

 {
 #define width 15L
     filename = (file=="") ? stdFile:file;
     // Sort like periodic table
     std::sort(ionStore.begin(), ionStore.end());
     G4cout << "Dose is being written to " << filename << G4endl;
     ofs.open(filename, std::ios::out);
     if (ofs.is_open())
     {
     // Write the voxels index and the list of particles/ions 
     ofs << std::setprecision(6) << std::left <<
         "i\tj\tk\t"; 
     // Total dose 
     ofs << std::setw(width) << "Dose(Gy)";
     if (secondary)
     {
         for (size_t l=0; l < ionStore.size(); l++)
         {
         G4String a = (ionStore[l].isPrimary) ? "_1":""; // is it a primary?
         ofs << std::setw(width) << ionStore[l].name + a <<
             std::setw(width) << ionStore[l].name  + a;
         }
         ofs << G4endl;
 
         /*
          * PDGencondig
          */
         /*
         ofs << std::setprecision(6) << std::left <<
         "0\t0\t0\t"; 
 
         // Total dose 
         ofs << std::setw(width) << '0';
         for (size_t l=0; l < ionStore.size(); l++)
         {
         ofs << std::setw(width) << ionStore[l].PDGencoding  <<
         std::setw(width) << ionStore[l].PDGencoding;
         }
         ofs << G4endl;
         */
     }
     // Write data
     for(G4int i = 0; i < numberOfVoxelAlongX; i++) 
         for(G4int j = 0; j < numberOfVoxelAlongY; j++) 
         for(G4int k = 0; k < numberOfVoxelAlongZ; k++) 
         {
             G4int n = Index(i, j, k);
             // Write only not identically null data lines
             if (matrix[n])
             {
             ofs << G4endl;
             ofs << i << '\t' << j << '\t' << k << '\t';
             // Total dose 
             ofs << std::setw(width) << (matrix[n]/massOfVoxel)/doseUnit; 
             if (secondary)
             {
                 for (size_t l=0; l < ionStore.size(); l++)
                 {
                 // Fill ASCII file rows
                 ofs << std::setw(width) << ionStore[l].dose[n]/massOfVoxel/doseUnit <<
                     std::setw(width) << ionStore[l].fluence[n]; 
                 }
             }
             }
         }
     ofs.close();
     }
 }

void HadrontherapyMatrix::StoreFluenceData ( )

Definition at line 266 of file HadrontherapyMatrix.cc.

References StoreMatrix().

 {
     for (size_t i=0; i < ionStore.size(); i++){
         StoreMatrix(ionStore[i].name + "_Fluence.out", ionStore[i].fluence, sizeof(unsigned int));
     }
 }

void HadrontherapyMatrix::StoreMatrix	(	G4String	file,
		void *	data,
		size_t	psize
	)

Definition at line 234 of file HadrontherapyMatrix.cc.

References G4endl, Index(), and n.

Referenced by StoreDoseData(), and StoreFluenceData().

 {
     if (data)
     {
         ofs.open(file, std::ios::out);
         if (ofs.is_open())
         {
             for(G4int i = 0; i < numberOfVoxelAlongX; i++) 
                 for(G4int j = 0; j < numberOfVoxelAlongY; j++) 
                     for(G4int k = 0; k < numberOfVoxelAlongZ; k++) 
                     {
                         G4int n = Index(i, j, k);
                             // Check for data type: u_int, G4double, XXX 
                         if (psize == sizeof(unsigned int))
                         {
                             unsigned int* pdata = (unsigned int*)data;
                             if (pdata[n]) ofs << i << '\t' << j << '\t' <<
                                 k << '\t' << pdata[n] << G4endl;
                         }
                         else if (psize == sizeof(G4double))
                         {
                             G4double* pdata = (G4double*)data;
                             if (pdata[n]) ofs << i << '\t' << j << '\t' <<
                                 k << '\t' << pdata[n] << G4endl;
                         }
                     }
             ofs.close();
         }
     }
 }

void HadrontherapyMatrix::TotalEnergyDeposit ( )

Definition at line 392 of file HadrontherapyMatrix.cc.

References HadrontherapyAnalysisManager::GetInstance(), Index(), and n.

 {
     // Convert energy deposited to dose.
     // Store the information of the matrix in a ntuple and in 
     // a 1D Histogram
 #ifdef G4ANALYSIS_USE_ROOT
       HadrontherapyAnalysisManager* analysis = HadrontherapyAnalysisManager::GetInstance();
 #endif
 
     if (matrix)
     {  
     for(G4int i = 0; i < numberOfVoxelAlongX; i++) 
         for(G4int j = 0; j < numberOfVoxelAlongY; j++) 
         for(G4int k = 0; k < numberOfVoxelAlongZ; k++)
         {
 #ifdef G4ANALYSIS_USE_ROOT
             G4int n = Index(i,j,k);
             if (analysis -> IsTheTFile() )
             {
             analysis -> FillEnergyDeposit(i, j, k, matrix[n]/massOfVoxel/doseUnit);
             analysis -> BraggPeak(i, matrix[n]/massOfVoxel/doseUnit);
             }
 #endif
         }
     }
 }

Field Documentation

G4bool HadrontherapyMatrix::secondary = false

static

Definition at line 78 of file HadrontherapyMatrix.hh.

Referenced by Fill(), and StoreDoseFluenceAscii().

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation