Import Geant4 5.2.0 source tree

This commit is contained in:
Gabriele Cosmo
2016-06-09 10:28:22 +02:00
parent fbd4999cf7
commit 4aea781e80
5454 changed files with 223141 additions and 67347 deletions
@@ -25,8 +25,8 @@
// S.Guatelli
//
//
// $Id: BrachyAnalysisManager.hh,v 1.6 2002/11/27 11:11:22 guatelli Exp $
// GEANT4 tag $Name: geant4-05-01 $
// $Id: BrachyAnalysisManager.hh,v 1.8 2003/06/16 16:44:59 gunter Exp $
// GEANT4 tag $Name: geant4-05-02 $
//
// **********************************
// * *
@@ -34,7 +34,7 @@
// * *
// **********************************
//
//
// the class Analysis creates and managed histograms and ntuples
//
#ifdef G4ANALYSIS_USE
@@ -42,57 +42,54 @@
#define G4PROCESSTESTANALYSIS_HH
#include "globals.hh"
#include "g4std/vector"
#include <vector>
#include "G4ThreeVector.hh"
#include "AIDA/IHistogram1D.h"
#include "AIDA/IHistogram2D.h"
#include "AIDA/IAnalysisFactory.h"
namespace AIDA{
class ITree;
class IHistogramFactory;
class IAnalysisFactory;
class ITupleFactory;
class ITuple;
class ITreeFactory;
class ITree;
class IHistogramFactory;
class IAnalysisFactory;
class ITupleFactory;
class ITuple;
class ITreeFactory;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
class BrachyAnalysisManager
{
private:
BrachyAnalysisManager();
public:
~BrachyAnalysisManager();
~BrachyAnalysisManager();
static BrachyAnalysisManager* getInstance();
void book();
void FillNtupleWithEnergy(G4double,G4double,G4double,G4float);
void FillHistogramWithEnergy(G4double,G4double,G4float);
void PrimaryParticleEnergySpectrum(G4double);
void finish();
void book();
private:
void finish();
static BrachyAnalysisManager* getInstance();
void fill_Tuple(G4double,G4double,G4double,G4float);
void hist(G4double,G4double,G4float);
void Spectrum(G4double);
// G4double xx,zz,yy;
//G4float en;
//G4double x,y,z;
static BrachyAnalysisManager* instance;
private:
G4double xx,zz,yy;
G4float en;
G4double x,y,z;
static BrachyAnalysisManager* instance;
private:
BrachyAnalysisManager();
private:
AIDA::IAnalysisFactory* aFact;
AIDA::ITree* theTree;
AIDA::IHistogramFactory *histFact;
AIDA::ITupleFactory *tupFact;
AIDA::ITreeFactory *treeFact;
AIDA::IHistogram2D *h1;
AIDA::IHistogram1D *h2;
AIDA::ITuple *ntuple;
AIDA::IAnalysisFactory* aFact;
AIDA::ITree* theTree;
AIDA::IHistogramFactory *histFact;
AIDA::ITupleFactory *tupFact;
AIDA::ITreeFactory *treeFact;
AIDA::IHistogram2D *h1;
AIDA::IHistogram1D *h2;
AIDA::ITuple *ntuple;
};
#endif
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: BrachyDetectorConstruction.hh,v 1.13 2002/11/18 15:18:35 guatelli Exp $
// GEANT4 tag $Name: geant4-05-01 $
// $Id: BrachyDetectorConstruction.hh,v 1.15 2003/05/22 17:20:40 guatelli Exp $
// GEANT4 tag $Name: geant4-05-02 $
//
// ****************************************
// * *
@@ -53,110 +53,64 @@ class BrachyPhantomSD;
class BrachyPhantomROGeometry;
class G4VPhysicalVolume;
class BrachyMaterial;
class BrachyFactoryIr;
class BrachyFactoryI;
class BrachyFactoryLeipzig;
class BrachyFactory;
class BrachyVoxelParameterisation;
class BrachyDetectorConstruction : public G4VUserDetectorConstruction
{
public:
BrachyDetectorConstruction(G4String&);
~BrachyDetectorConstruction();
BrachyDetectorConstruction(G4String&);
~BrachyDetectorConstruction();
G4VPhysicalVolume* Construct();
void SwitchBrachytherapicSeed(); //Change radiactive source through GUI
void SelectBrachytherapicSeed(G4String val);
void ConstructPhantom();
void ConstructSensitiveDetector();
void PrintDetectorParameters();
void SetPhantomMaterial(G4String);
const G4double VoxelWidth_X(){return phantomDimensionX/numberOfVoxelsAlongX;}
const G4double VoxelWidth_Z(){return phantomDimensionZ/numberOfVoxelsAlongZ;}
const G4int GetNumVoxelX() {return numberOfVoxelsAlongX;}
const G4int GetNumVoxelZ() {return numberOfVoxelsAlongZ;}
const G4double GetDimX() {return phantomDimensionX;}
const G4double GetBoxDim_Z() {return phantomDimensionZ;}
void ComputeDimVoxel() {dimVoxel = phantomDimensionX/numberOfVoxelsAlongX;}
private:
G4int* pVoxel;
G4double m_BoxDimX;
G4double m_BoxDimY;
G4double m_BoxDimZ;
G4int NumVoxelX;
G4int NumVoxelZ;
G4double dimVoxel;
G4String m_SDName;
G4int detectorChoice;
G4double ExpHall_x ;
G4double ExpHall_y ;
G4double ExpHall_z ;
BrachyPhantomSD* pPhantomSD;
BrachyPhantomROGeometry* pPhantomROGeometry;
BrachyFactoryLeipzig* factoryLeipzig;
BrachyFactoryI* factoryI;
BrachyFactoryIr* factoryIr;
BrachyMaterial* pMat;
public:
void PrintDetectorParameters();
void SetAbsorberMaterial(G4String);
const G4double VoxelWidth_X() {return m_BoxDimX/NumVoxelX;};//num voxel
const G4double VoxelWidth_Z() {return m_BoxDimZ/NumVoxelZ;};
const G4int GetNumVoxelX(){return NumVoxelX;};
const G4int GetNumVoxelZ(){return NumVoxelZ;};
const G4double GetDimX(){return m_BoxDimX;};
const G4double GetBoxDim_Z() {return m_BoxDimZ;};
void SwitchDetector();
private:
BrachyDetectorMessenger* detectorMessenger;
G4Box* ExpHall; //pointer to the solid World
G4LogicalVolume* ExpHallLog; //pointer to the logical World
G4VPhysicalVolume* ExpHallPhys; //pointer to the physical World
G4Box* solidVoxel;
G4LogicalVolume* logicVoxel;
G4VPhysicalVolume* physiVoxel;
G4Box* Phantom;
G4LogicalVolume* PhantomLog;
G4VPhysicalVolume* PhantomPhys;
G4Box* Voxel;
G4LogicalVolume* VoxelLog;
G4VPhysicalVolume* VoxelPhys;
G4Material* AbsorberMaterial;
void ConstructPhantom();
void ConstructSensitiveDetector();
private:
G4VPhysicalVolume* Construct();
void ComputeDimVoxel();
public:
G4VPhysicalVolume* ConstructDetector();
void SelectDetector(G4String val);
G4int detectorChoice; //Select brachytherapic seed
BrachyPhantomSD* phantomSD;//pointer to sensitive detector
BrachyPhantomROGeometry* phantomROGeometry;//pointer to ROGeometry
BrachyFactory* factory;
// World ...
G4Box* World; //pointer to the solid World
G4LogicalVolume* WorldLog; //pointer to the logical World
G4VPhysicalVolume* WorldPhys; //pointer to the physical World
// Phantom ...
G4Box* Phantom; //pointer to solid phantom
G4LogicalVolume* PhantomLog; //pointer to logic phantom
G4VPhysicalVolume* PhantomPhys; //pointer to physical phantom
G4Material* phantomAbsorberMaterial;
G4double phantomDimensionX; //Phantom XDimension
G4double phantomDimensionY; //Phantom YDimension
G4double phantomDimensionZ; //Phantom ZDimension
G4int numberOfVoxelsAlongX; //Number of voxels along x axis
G4int numberOfVoxelsAlongZ; //Number of voxels along z axis
G4double Worldx ; //World XDimension
G4double Worldy ; //World YDimension
G4double Worldz ; //World XDimension
G4String sensitiveDetectorName;
BrachyDetectorMessenger* detectorMessenger;
BrachyMaterial* pMaterial;
G4double dimVoxel;
};
inline void BrachyDetectorConstruction::ComputeDimVoxel()
{
dimVoxel=m_BoxDimX/NumVoxelX;
}
#endif
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: BrachyDetectorConstructionI.hh,v 1.2 2002/11/18 15:18:35 guatelli Exp $
// GEANT4 tag $Name: geant4-05-01 $
// $Id: BrachyDetectorConstructionI.hh,v 1.3 2003/05/22 17:20:40 guatelli Exp $
// GEANT4 tag $Name: geant4-05-02 $
//
// ****************************************
// * *
@@ -38,9 +38,7 @@
#include "G4VUserDetectorConstruction.hh"
#include "G4LogicalVolume.hh"
class G4LogicalVolume;
class G4Tubs;
class G4Box;
class G4Sphere;
@@ -53,48 +51,38 @@ class BrachyMaterial;
class BrachyDetectorConstructionI
{
public:
BrachyDetectorConstructionI();
~BrachyDetectorConstructionI();
BrachyDetectorConstructionI();
~BrachyDetectorConstructionI();
void ConstructIodium(G4VPhysicalVolume*);// Construct iodium source
private:
G4VisAttributes* simpleMarkerVisAtt;
G4VisAttributes* simpleIodiumVisAtt;
//air tub ...
G4Tubs* defaultTub;
G4LogicalVolume* defaultTubLog;
G4VPhysicalVolume* defaultTubPhys;
//source titanium capsule ...
G4Tubs* capsule ;
G4LogicalVolume* capsuleLog;
G4VPhysicalVolume* capsulePhys;
G4VisAttributes* simpleCapsuleVisAtt;
G4VisAttributes* simpleCapsuleTipVisAtt;
G4Sphere* capsuleTip;
G4LogicalVolume* capsuleTipLog;
G4VPhysicalVolume* capsuleTipPhys1;
G4VPhysicalVolume* capsuleTipPhys2;
public:
//radioactive core ...
G4Tubs* iodiumCore;
G4LogicalVolume* iodiumCoreLog;
G4VPhysicalVolume* iodiumCorePhys;
// golden marker ...
G4Tubs* marker;
G4LogicalVolume* markerLog;
G4VPhysicalVolume* markerPhys;
void ConstructIodium(G4VPhysicalVolume*);
private:
G4Tubs* DefaultTub;
G4LogicalVolume* DefaultTub_log;
G4VPhysicalVolume*DefaultTub_Phys;
G4Tubs* Capsule ;
G4LogicalVolume* CapsuleLog; //pointer to the logical World
G4VPhysicalVolume* CapsulePhys;
G4Sphere* CapsuleTip;
G4LogicalVolume* CapsuleTipLog;
G4VPhysicalVolume* CapsuleTipPhys1;
G4VPhysicalVolume* CapsuleTipPhys2;
G4Tubs* IodiumCore;
G4LogicalVolume* ICoreLog;
G4VPhysicalVolume* ICorePhys;
G4Tubs* Marker;
G4LogicalVolume* MarkerLog;
G4VPhysicalVolume* MarkerPhys;
BrachyMaterial* pMat;
BrachyMaterial* pMaterial;
};
#endif
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: BrachyDetectorConstructionIr.hh,v 1.2 2002/11/18 15:18:36 guatelli Exp $
// GEANT4 tag $Name: geant4-05-01 $
// $Id: BrachyDetectorConstructionIr.hh,v 1.3 2003/05/22 17:20:41 guatelli Exp $
// GEANT4 tag $Name: geant4-05-02 $
//
// ****************************************
// * *
@@ -42,7 +42,6 @@
class G4LogicalVolume;
class G4Tubs;
class G4Box;
class G4Sphere;
@@ -54,47 +53,30 @@ class BrachyMaterial;
class BrachyDetectorConstructionIr
{
public:
BrachyDetectorConstructionIr();
~BrachyDetectorConstructionIr();
private:
G4VisAttributes* simpleCapsuleVisAtt;
G4VisAttributes* simpleCapsuleTipVisAtt;
G4VisAttributes* simpleIridiumVisAtt;
public:
void CleanIridium();
BrachyDetectorConstructionIr();
~BrachyDetectorConstructionIr();
void ConstructIridium(G4VPhysicalVolume*);
private:
G4Box* WaterBox;
G4LogicalVolume* WaterBoxLog;
G4VPhysicalVolume* WaterBoxPhys;
G4Tubs* Capsule ;
G4LogicalVolume* CapsuleLog; //pointer to the logical World
G4VPhysicalVolume* CapsulePhys;
G4Sphere* CapsuleTip;
G4LogicalVolume* CapsuleTipLog;
G4VPhysicalVolume* CapsuleTipPhys;
G4Tubs* IridiumCore;
G4LogicalVolume* IridiumCoreLog;
G4VPhysicalVolume* IridiumCorePhys;
BrachyMaterial* pMat;
};
void CleanIridium();
private:
G4Tubs* capsule ;
G4LogicalVolume* capsuleLog;
G4VPhysicalVolume* capsulePhys;
G4Sphere* capsuleTip;
G4LogicalVolume* capsuleTipLog;
G4VPhysicalVolume* capsuleTipPhys;
G4Tubs* iridiumCore;
G4LogicalVolume* iridiumCoreLog;
G4VPhysicalVolume* iridiumCorePhys;
BrachyMaterial* pMat;
G4VisAttributes* simpleCapsuleVisAtt;
G4VisAttributes* simpleCapsuleTipVisAtt;
G4VisAttributes* simpleIridiumVisAtt;
};
#endif
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: BrachyDetectorConstructionLeipzig.hh,v 1.2 2002/11/18 15:18:36 guatelli Exp $
// GEANT4 tag $Name: geant4-05-01 $
// $Id: BrachyDetectorConstructionLeipzig.hh,v 1.3 2003/05/22 17:20:41 guatelli Exp $
// GEANT4 tag $Name: geant4-05-02 $
//
//
// ************************************************
@@ -31,7 +31,7 @@
// * *
// ************************************************
//
//Management of Leipzig Applicator
//Management of Leipzig applicator
//
#ifndef BrachyDetectorConstructionLeipzig_H
#define BrachyDetectorConstructionLeipzig_H 1
@@ -42,7 +42,6 @@
class G4LogicalVolume;
class G4Tubs;
class G4Box;
class G4Sphere;
@@ -54,40 +53,33 @@ class BrachyMaterial;
class BrachyDetectorConstructionLeipzig
{
public:
BrachyDetectorConstructionLeipzig();
~BrachyDetectorConstructionLeipzig();
private:
G4VisAttributes* simpleCapsuleVisAtt;
G4VisAttributes* simpleCapsuleTipVisAtt;
public:
BrachyDetectorConstructionLeipzig();
~BrachyDetectorConstructionLeipzig();
void ConstructLeipzig(G4VPhysicalVolume*);
private:G4Tubs* Capsule ;
G4LogicalVolume* CapsuleLog; //pointer to the logical World
G4VPhysicalVolume* CapsulePhys;
private:
G4Tubs* capsule ;
G4LogicalVolume* capsuleLog;
G4VPhysicalVolume* capsulePhys;
G4Sphere* CapsuleTip;
G4LogicalVolume* CapsuleTipLog;
G4VPhysicalVolume* CapsuleTipPhys;
G4Sphere* capsuleTip;
G4LogicalVolume* capsuleTipLog;
G4VPhysicalVolume* capsuleTipPhys;
G4Tubs* IridiumCore;
G4LogicalVolume* IridiumCoreLog;
G4VPhysicalVolume* IridiumCorePhys;
G4Tubs* iridiumCore;
G4LogicalVolume* iridiumCoreLog;
G4VPhysicalVolume* iridiumCorePhys;
G4Tubs* Appl1;
G4LogicalVolume* Appl1Log ;
G4VPhysicalVolume* Appl1Phys;
G4Tubs* applicator1;
G4LogicalVolume* applicator1Log ;
G4VPhysicalVolume* applicator1Phys;
G4Tubs* Appl2;
G4LogicalVolume* Appl2Log ;
G4VPhysicalVolume* Appl2Phys;
G4Tubs* applicator2;
G4LogicalVolume* applicator2Log ;
G4VPhysicalVolume* applicator2Phys;
BrachyMaterial* pMat;
};
BrachyMaterial* pMaterial;
};
#endif
@@ -27,14 +27,10 @@
// * *
// *****************************************
//
// $Id: BrachyDetectorMessenger.hh,v 1.4 2002/11/18 15:18:36 guatelli Exp $
// GEANT4 tag $Name: geant4-05-01 $
// $Id: BrachyDetectorMessenger.hh,v 1.5 2003/05/22 17:20:41 guatelli Exp $
// GEANT4 tag $Name: geant4-05-02 $
//
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#ifndef BrachyDetectorMessenger_h
#define BrachyDetectorMessenger_h 1
@@ -50,31 +46,20 @@ class G4UIcmdWithAnInteger;
class G4UIcmdWithADoubleAndUnit;
class G4UIcmdWithoutParameter;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class BrachyDetectorMessenger: public G4UImessenger
{
public:
BrachyDetectorMessenger(BrachyDetectorConstruction* );
~BrachyDetectorMessenger();
public:
BrachyDetectorMessenger(BrachyDetectorConstruction* );
~BrachyDetectorMessenger();
void SetNewValue(G4UIcommand*, G4String);
void SetNewValue(G4UIcommand*, G4String);
private:
BrachyDetectorConstruction* Detector;
G4UIcmdWithAString* selDetCmd;
G4UIcmdWithAString* switchCmd;
G4UIcmdWithAString* cleanCmd;
G4UIdirectory* detDir;
G4UIdirectory* mydetDir;
G4UIcmdWithAString* AbsMaterCmd;
G4int detectorChoice;
G4int flag;
private:
BrachyDetectorConstruction* detector;//pointer to detector
G4UIdirectory* detectorDir;
G4UIcmdWithAString* phantomMaterialCmd; // change phantom material
G4UIcmdWithAString* sourceCmd; //change brachytherapis source
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
@@ -36,16 +36,16 @@ class G4Step;
class BrachyDummySD : public G4VSensitiveDetector
{
public:
BrachyDummySD();
~BrachyDummySD() {};
public:
BrachyDummySD();
~BrachyDummySD() {};
void Initialize(G4HCofThisEvent*HCE) {};
G4bool ProcessHits(G4Step*aStep,G4TouchableHistory*ROhist) {return false;}
void EndOfEvent(G4HCofThisEvent*HCE) {};
void clear() {};
void DrawAll() {};
void PrintAll() {};
void Initialize(G4HCofThisEvent* ) {};
G4bool ProcessHits(G4Step* ,G4TouchableHistory*) {return false;}
void EndOfEvent(G4HCofThisEvent*) {};
void clear() {};
void DrawAll() {};
void PrintAll() {};
};
BrachyDummySD::BrachyDummySD() : G4VSensitiveDetector("dummySD")
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: BrachyEventAction.hh,v 1.11 2002/11/18 15:18:36 guatelli Exp $
// GEANT4 tag $Name: geant4-05-01 $
// $Id: BrachyEventAction.hh,v 1.13 2003/05/27 08:37:54 guatelli Exp $
// GEANT4 tag $Name: geant4-05-02 $
//
// Code developed by:
// S.Guatelli
@@ -38,41 +38,25 @@
#include "G4UserEventAction.hh"
#include "globals.hh"
class BrachyDetectorConstruction;
class BrachyAnalysisManager;
class BrachyPrimaryGeneratorActionI;
class BrachyPrimaryGeneratorActionIr;
class BrachyEventAction : public G4UserEventAction
{
public:
BrachyEventAction(G4String&);
~BrachyEventAction();
BrachyEventAction(G4String&);
~BrachyEventAction();
public:
void BeginOfEventAction(const G4Event*);
void EndOfEventAction(const G4Event*);
void BeginOfEventAction(const G4Event*);
void EndOfEventAction(const G4Event*);
private:
G4double EnergyDep;
G4int m_NumVoxelX;
G4int m_NumVoxelZ;
G4double VoxelWidth_Z;
G4double VoxelWidth_X;
private:
G4int m_HitsCollectionID;
G4String drawFlag;
G4int j;
G4int i;
G4int k;
G4double x;
G4double z;
G4double y;
G4String SDname;
G4int printModulo;
BrachyDetectorConstruction* pDetector;
G4String drawFlag; //Visualisation flag
G4int hitsCollectionID;
BrachyDetectorConstruction* detector;
G4int numberOfVoxelZ;
G4double voxelWidthZ;
};
#endif
@@ -20,9 +20,10 @@
// * statement, and all its terms. *
// ********************************************************************
//
// Code developed by: Susanna Guatelli
//
// $Id: BrachyFactory.hh,v 1.2 2002/11/18 15:18:36 guatelli Exp $
// GEANT4 tag $Name: geant4-05-01 $
// $Id: BrachyFactory.hh,v 1.4 2003/05/22 17:20:41 guatelli Exp $
// GEANT4 tag $Name: geant4-05-02 $
//
// **********************************
// * *
@@ -30,41 +31,38 @@
// * *
// **********************************
//
// this is the abstract class which manages the sources
// this is the abstract class which manages the sources' realisation
// in terms of geometry and primary particle generated in the radioactive core
#ifndef BrachyFactory_h
#define BrachyFactory_h 1
#include "G4VUserPrimaryGeneratorAction.hh"
#include "G4RadioactiveDecay.hh"
class G4ParticleGun;
class G4Run;
class G4Event;
class G4VPhysicalVolume;
class BrachyAnalysisManager;
class BrachyFactory
{
public:
BrachyFactory();
virtual ~BrachyFactory();
virtual G4VUserPrimaryGeneratorAction* CreatePrimaryGeneratorAction()=0;
virtual void CreateSource(G4VPhysicalVolume*)=0;
virtual void CleanSource()=0;
virtual ~BrachyFactory();
//Source primary particles' management ...
virtual G4VUserPrimaryGeneratorAction* CreatePrimaryGeneratorAction() = 0;
// ...
// this function manages the creation of the source in terms of
// geometry ...
virtual void CreateSource(G4VPhysicalVolume*) = 0;
// ...
// This function deletes the source in the geometry (phantom); to be
// used when the user needs to substitute one source with another one ...
virtual void CleanSource() = 0;
};
#endif
@@ -20,8 +20,19 @@
// * statement, and all its terms. *
// ********************************************************************
//
// $Id: BrachyFactoryI.hh,v 1.3 2002/12/13 09:25:32 gcosmo Exp $
// GEANT4 tag $Name: geant4-05-01 $
// *******************************
// * *
// * BrachyFactoryI.cc *
// * *
// *******************************
//
//
// Code developed by:
// S.Guatelli
//
//
// $Id: BrachyFactoryI.hh,v 1.5 2003/05/22 17:20:41 guatelli Exp $
// GEANT4 tag $Name: geant4-05-02 $
//
//
// --------------------------------------------------------------
@@ -29,10 +40,10 @@
#define BrachyFactoryI_h 1
#include "G4VUserPrimaryGeneratorAction.hh"
#include "G4RadioactiveDecay.hh"
#include"BrachyDetectorConstructionI.hh"
#include"BrachyFactory.hh"
#include "BrachyDetectorConstructionI.hh"
#include "BrachyFactory.hh"
#include "G4RunManager.hh"
class G4ParticleGun;
class G4Run;
class G4Event;
@@ -40,17 +51,20 @@ class BrachyAnalysisManager;
class BrachyFactory;
class BrachyPrimaryGeneratorActionI;
class BrachyDetectorConstructionI;
// This class manages the creation of Bebig Isoseed I-125 source
// used in interstitial brachytherapy ...
class BrachyFactoryI:public BrachyFactory
{
public:
BrachyFactoryI();
~BrachyFactoryI();
G4VUserPrimaryGeneratorAction* CreatePrimaryGeneratorAction();
void CreateSource(G4VPhysicalVolume*);
void CleanSource();
private:
BrachyDetectorConstructionI* pIodio;
void CleanSource();
private:
BrachyDetectorConstructionI* iodiumSource;
};
#endif
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: BrachyFactoryIr.hh,v 1.2 2002/11/18 15:18:36 guatelli Exp $
// GEANT4 tag $Name: geant4-05-01 $
// $Id: BrachyFactoryIr.hh,v 1.4 2003/05/22 17:20:41 guatelli Exp $
// GEANT4 tag $Name: geant4-05-02 $
//
// **********************************
// * *
@@ -34,10 +34,11 @@
//
#ifndef BrachyFactoryIr_h
#define BrachyFactoryIr_h 1
#include "G4VUserPrimaryGeneratorAction.hh"
#include "G4RadioactiveDecay.hh"
#include"BrachyFactory.hh"
#include "BrachyFactory.hh"
#include "G4RunManager.hh"
class G4ParticleGun;
class G4Run;
class G4Event;
@@ -46,15 +47,19 @@ class BrachyFactory;
class BrachyPrimaryGeneratorActionIr;
class BrachyDetectorConstructionIr;
class BrachyFactoryIr:public BrachyFactory
// This class manages the creation of iridum source used in endocavitary
// brachytherapy ...
class BrachyFactoryIr : public BrachyFactory
{
public:
BrachyFactoryIr();
~BrachyFactoryIr();
G4VUserPrimaryGeneratorAction* CreatePrimaryGeneratorAction();
~BrachyFactoryIr();
G4VUserPrimaryGeneratorAction* CreatePrimaryGeneratorAction();
void CreateSource(G4VPhysicalVolume*);
void CleanSource();
private:
BrachyDetectorConstructionIr* pIridio;
BrachyDetectorConstructionIr* iridiumSource;
};
#endif
@@ -21,22 +21,25 @@
// ********************************************************************
//
//
// $Id: BrachyFactoryLeipzig.hh,v 1.2 2002/11/18 15:18:36 guatelli Exp $
// GEANT4 tag $Name: geant4-05-01 $
// $Id: BrachyFactoryLeipzig.hh,v 1.4 2003/05/22 17:20:41 guatelli Exp $
// GEANT4 tag $Name: geant4-05-02 $
//
// **********************************
// * *
// * BrachyFactoryLeipzig.hh *
// * *
// **********************************
//code developed by: Susanna Guatelli
//
//
// This class manages the creation of iridum source used in superficial
// brachytherapy ...
#ifndef BrachyFactoryLeipzig_h
#define BrachyFactoryLeipzig_h 1
#include "G4VUserPrimaryGeneratorAction.hh"
#include "G4RadioactiveDecay.hh"
#include"BrachyFactory.hh"
#include "BrachyFactory.hh"
#include "G4RunManager.hh"
class G4ParticleGun;
class G4Run;
class G4Event;
@@ -45,15 +48,17 @@ class BrachyFactory;
class BrachyPrimaryGeneratorActionIr;
class BrachyDetectorConstructionLeipzig;
class BrachyFactoryLeipzig:public BrachyFactory
class BrachyFactoryLeipzig : public BrachyFactory
{
public:
BrachyFactoryLeipzig();
~BrachyFactoryLeipzig();
G4VUserPrimaryGeneratorAction* CreatePrimaryGeneratorAction();
void CreateSource(G4VPhysicalVolume*);
void CleanSource();
private:
BrachyDetectorConstructionLeipzig* pLeipzig;
BrachyDetectorConstructionLeipzig* leipzigSource;
};
#endif
@@ -21,33 +21,50 @@
// ********************************************************************
//
//
// $Id: BrachyMaterial.hh,v 1.2 2002/11/18 15:18:36 guatelli Exp $
// GEANT4 tag $Name: geant4-05-01 $
// $Id: BrachyMaterial.hh,v 1.5 2003/05/27 08:37:54 guatelli Exp $
// GEANT4 tag $Name: geant4-05-02 $
//
// **********************************
// * *
// * BrachyMaterial.hh *
// * *
// **********************************
//This class manages the elments and materials nedded by the simulation
// set-up
//
//Code developed by: Susanna Guatelli
//
//This class manages the elements and materials needed by the simulation
// set-up ...
//
#ifndef BrachyMaterial_H
#define BrachyMaterial_H 1
#include "globals.hh"
class G4Material;
class BrachyMaterial
{ public:
{
public:
BrachyMaterial();
~ BrachyMaterial();
public:
void DefineMaterials();
G4Material* GetMat(G4String); //returns the material
public:
G4Material* GetMat(G4String);
private:
G4Material* matW;
G4Material* matplexiglass;
G4Material* matPb;
G4Material* matir192;
G4Material* Titanium;
G4Material* matAir;
G4Material* matH2O;
G4Material* soft;
G4Material* matsteel;
G4Material* gold;
G4Material* matI;
G4Material* ceramic;
G4Material*Vacuum;
G4Material* bone;
G4Material* muscle;
};
#endif
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: BrachyPhantomHit.hh,v 1.4 2002/11/18 15:18:36 guatelli Exp $
// GEANT4 tag $Name: geant4-05-01 $
// $Id: BrachyPhantomHit.hh,v 1.5 2003/05/22 17:20:41 guatelli Exp $
// GEANT4 tag $Name: geant4-05-02 $
//
//
// ********************************
@@ -30,7 +30,11 @@
// * BrachyPhantomHit.hh *
// * *
// ********************************
// It manages the hits
//
//Code developed by: S. Guatelli, M.Tropeano
//
// It manages the hits and the enrgy deposit in the phantom associated with
// each hit ...
#ifndef BrachyPhantomHit_h
#define BrachyPhantomHit_h 1
@@ -45,56 +49,68 @@
class BrachyPhantomHit : public G4VHit
{
public:
BrachyPhantomHit(G4LogicalVolume* ,G4int ,G4int ,G4int );
~BrachyPhantomHit();
BrachyPhantomHit(const BrachyPhantomHit &right);
const BrachyPhantomHit& operator=(const BrachyPhantomHit &right);
int operator==(const BrachyPhantomHit &right) const;
public:
BrachyPhantomHit(G4LogicalVolume* ,G4int ,G4int ,G4int );
~BrachyPhantomHit();
BrachyPhantomHit(const BrachyPhantomHit &right);
const BrachyPhantomHit& operator = (const BrachyPhantomHit &right);
int operator == (const BrachyPhantomHit &right) const;
inline void *operator new(size_t);
inline void operator delete(void *aHit);
inline void *operator new(size_t);
inline void operator delete(void *aHit);
void Draw();
void Print();
void Draw();
void Print();
private:
G4ThreeVector m_Pos;
G4RotationMatrix m_Rot;
const G4LogicalVolume* m_pLogV;
private:
const G4LogicalVolume* logicalVolume;// Logical volume where the hit happened
G4int xHitPosition; // Hit x coordinate
G4int zHitPosition; // Hit z coordinate
G4int yHitPosition; // Hit y coordinate
G4ThreeVector hitPosition; //position of the hit
G4RotationMatrix rotation; // rotation of the logical volume
G4double energyDeposit; // energy deposit associated with the hit
G4double m_Edep;
public:
//...
// Set Hit position
inline void SetCellID(G4int XID,G4int YID,G4int ZID)
{xHitPosition = XID; zHitPosition = ZID; yHitPosition = YID; }
inline G4int GetXID() // Get hit x coordinate
{return xHitPosition;}
G4int m_XID;
G4int m_ZID;
G4int m_YID;
public:
inline void SetCellID(G4int XID,G4int YID,G4int ZID)
{m_XID = XID;m_ZID = ZID; m_YID = YID; }
inline G4int GetXID()
{return m_XID;}
inline G4int GetZID()
{return m_ZID;}
inline G4int GetZID() // Get hit z coordinate
{return zHitPosition;}
inline G4int GetYID()
{return m_YID;}
inline G4int GetYID() // Get hit y coordinate
{return yHitPosition;}
inline void SetEdep(G4double edep)
{m_Edep = edep;}
inline void AddEdep(G4double edep)
{m_Edep += edep;}
inline G4double GetEdep()
{return m_Edep;}
inline void SetPos(G4ThreeVector xyz)
{m_Pos = xyz;}
inline G4ThreeVector GetPos()
{return m_Pos;}
inline void SetRot(G4RotationMatrix rmat)
{m_Rot = rmat;}
inline G4RotationMatrix GetRot()
{return m_Rot;}
inline const G4LogicalVolume * GetLogV()
{return m_pLogV;}
inline void SetEdep(G4double edep) //Set hit energy deposit
{energyDeposit = edep;}
inline void AddEdep(G4double edep) // Add energy deposit
{energyDeposit += edep;}
inline G4double GetEdep() // Get energy deposit
{return energyDeposit;}
inline void SetPos(G4ThreeVector xyz) // Set hit position
{hitPosition = xyz;}
inline G4ThreeVector GetPos() // Get hit position
{return hitPosition;}
inline void SetRot(G4RotationMatrix rmat) //set rotation
{rotation = rmat;}
inline G4RotationMatrix GetRot() //get rotation
{return rotation;}
//...
// It returns the logical volume where the hit happened
inline const G4LogicalVolume * GetLogicalVolume()
{return logicalVolume;}
};
typedef G4THitsCollection<BrachyPhantomHit> BrachyPhantomHitsCollection;
@@ -102,16 +118,15 @@ extern G4Allocator<BrachyPhantomHit> BrachyPhantomHitAllocator;
inline void* BrachyPhantomHit::operator new(size_t)
{
void *aHit;
aHit = (void *) BrachyPhantomHitAllocator.MallocSingle();
return aHit;
void *aHit;
aHit = (void *) BrachyPhantomHitAllocator.MallocSingle();
return aHit;
}
inline void BrachyPhantomHit::operator delete(void *aHit)
{
BrachyPhantomHitAllocator.FreeSingle((BrachyPhantomHit*) aHit);
BrachyPhantomHitAllocator.FreeSingle((BrachyPhantomHit*) aHit);
}
#endif
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: BrachyPhantomROGeometry.hh,v 1.3 2002/11/18 15:18:36 guatelli Exp $
// GEANT4 tag $Name: geant4-05-01 $
// $Id: BrachyPhantomROGeometry.hh,v 1.5 2003/05/27 08:37:54 guatelli Exp $
// GEANT4 tag $Name: geant4-05-02 $
//
// ************************************
// * *
@@ -39,18 +39,21 @@
class BrachyPhantomROGeometry : public G4VReadOutGeometry
{
public:
BrachyPhantomROGeometry(G4String aString,G4double DetDimX,G4double DetDimZ,G4int NumVoxelX,G4int NumVoxelZ);
~BrachyPhantomROGeometry();
public:
BrachyPhantomROGeometry(G4String aString,
G4double phantomDimX,
G4double phantomDimZ,
G4int numberOfVoxelsX,
G4int numberOfVoxelsZ);
~BrachyPhantomROGeometry();
private:
G4VPhysicalVolume* Build();
private:
const G4double m_DetDimX;
const G4double m_DetDimZ;
const G4int m_NumVoxelX;
const G4int m_NumVoxelZ;
private:
G4VPhysicalVolume* Build();
private:
const G4double phantomDimensionX;
const G4double phantomDimensionZ;
const G4int numberOfVoxelsAlongX;
const G4int numberOfVoxelsAlongZ;
G4VPhysicalVolume *ROPhantomYDivisionPhys;
};
#endif
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: BrachyPhantomSD.hh,v 1.3 2002/11/18 15:18:36 guatelli Exp $
// GEANT4 tag $Name: geant4-05-01 $
// $Id: BrachyPhantomSD.hh,v 1.5 2003/05/26 09:20:13 guatelli Exp $
// GEANT4 tag $Name: geant4-05-02 $
//
// ********************************
// * *
@@ -42,22 +42,22 @@ class G4TouchableHistory;
class BrachyPhantomSD : public G4VSensitiveDetector
{
public:
BrachyPhantomSD(G4String name, G4int NumVoxelX, G4int NumVoxelZ);
~BrachyPhantomSD();
public:
BrachyPhantomSD(G4String name, G4int NumVoxelX, G4int NumVoxelZ);
~BrachyPhantomSD();
void Initialize(G4HCofThisEvent*HCE);
G4bool ProcessHits(G4Step*aStep,G4TouchableHistory*ROhist);
void EndOfEvent(G4HCofThisEvent*HCE);
void clear();
void DrawAll();
void PrintAll();
private:
BrachyPhantomHitsCollection *m_pPhantomHitsCollection;
const G4int m_NumVoxelX;
const G4int m_NumVoxelZ;
G4int *m_pVoxelID;
void Initialize(G4HCofThisEvent*);
G4bool ProcessHits(G4Step*aStep,G4TouchableHistory*ROhist);
void EndOfEvent(G4HCofThisEvent*HCE);
void clear();
void DrawAll();
void PrintAll();
private:
const G4int numberOfVoxelsX;
const G4int numberOfVoxelsZ;
G4int *voxelID;
BrachyPhantomHitsCollection *phantomHitsCollection;
};
#endif
@@ -22,7 +22,7 @@
//
//
// $Id: BrachyPhysicsList.hh,v 1.6 2002/11/18 15:18:36 guatelli Exp $
// GEANT4 tag $Name: geant4-05-01 $
// GEANT4 tag $Name: geant4-05-02 $
//
// **********************************
// * *
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: BrachyPrimaryGeneratorAction.hh,v 1.8 2002/11/18 15:18:36 guatelli Exp $
// GEANT4 tag $Name: geant4-05-01 $
// $Id: BrachyPrimaryGeneratorAction.hh,v 1.10 2003/05/22 17:20:42 guatelli Exp $
// GEANT4 tag $Name: geant4-05-02 $
//
// ********************************************
// * *
@@ -30,12 +30,12 @@
// * *
// ********************************************
// This class must be implemented because it is mandatory
#ifndef BrachyPrimaryGeneratorAction_h
#define BrachyPrimaryGeneratorAction_h 1
#include "G4VUserPrimaryGeneratorAction.hh"
#include "G4RadioactiveDecay.hh"
class G4ParticleGun;
class G4Run;
@@ -44,15 +44,11 @@ class BrachyAnalysisManager;
class BrachyPrimaryGeneratorAction : public G4VUserPrimaryGeneratorAction
{
public:
BrachyPrimaryGeneratorAction();
~BrachyPrimaryGeneratorAction();
BrachyPrimaryGeneratorAction();
~BrachyPrimaryGeneratorAction();
public:
virtual void GeneratePrimaries(G4Event* anEvent)=0;
virtual void GeneratePrimaries(G4Event* anEvent) = 0;
};
#endif
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: BrachyPrimaryGeneratorActionI.hh,v 1.2 2002/11/18 15:18:37 guatelli Exp $
// GEANT4 tag $Name: geant4-05-01 $
// $Id: BrachyPrimaryGeneratorActionI.hh,v 1.5 2003/06/16 16:45:00 gunter Exp $
// GEANT4 tag $Name: geant4-05-02 $
//
//
//
@@ -38,35 +38,32 @@
#ifndef BrachyPrimaryGeneratorActionI_h
#define BrachyPrimaryGeneratorActionI_h 1
#include "globals.hh"
#include <vector>
#include "G4VUserPrimaryGeneratorAction.hh"
#include "G4RadioactiveDecay.hh"
#include "BrachyPrimaryGeneratorAction.hh"
class G4ParticleGun;
class G4Run;
class G4Event;
class BrachyAnalysisManager;
class BrachyPrimaryGeneratorAction;
//class BrachyPrimaryGeneratorMessenger;
class BrachyPrimaryGeneratorActionI : public G4VUserPrimaryGeneratorAction
{
public:
BrachyPrimaryGeneratorActionI();
BrachyPrimaryGeneratorActionI();
~BrachyPrimaryGeneratorActionI();
public:
void GeneratePrimaries(G4Event* anEvent);
G4double GetEnergy();
G4double GetEnergy();
private:
G4ParticleGun* m_pParticleGun;
G4RadioactiveDecay *m_pRadioactiveDecay;
G4double Energy;
// BrachyPrimaryGeneratorMessenger* gunMessenger;
G4std::vector<G4double> vettore;
G4ParticleGun* particleGun;
G4double primaryParticleEnergy;
std::vector<G4double> energySpectrum;
};
#endif
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: BrachyPrimaryGeneratorActionIr.hh,v 1.2 2002/11/18 15:18:37 guatelli Exp $
// GEANT4 tag $Name: geant4-05-01 $
// $Id: BrachyPrimaryGeneratorActionIr.hh,v 1.5 2003/06/16 16:45:01 gunter Exp $
// GEANT4 tag $Name: geant4-05-02 $
//
// *************************************************
// * *
@@ -37,8 +37,9 @@
#ifndef BrachyPrimaryGeneratorActionIr_h
#define BrachyPrimaryGeneratorActionIr_h 1
#include "globals.hh"
#include <vector>
#include "G4VUserPrimaryGeneratorAction.hh"
#include "G4RadioactiveDecay.hh"
#include "BrachyPrimaryGeneratorAction.hh"
class G4ParticleGun;
@@ -46,24 +47,21 @@ class G4Run;
class G4Event;
class BrachyAnalysisManager;
class BrachyPrimaryGeneratorAction;
class BrachyPrimaryGeneratorActionIr: public G4VUserPrimaryGeneratorAction
{
public:
BrachyPrimaryGeneratorActionIr();
~BrachyPrimaryGeneratorActionIr();
public:
public:
void GeneratePrimaries(G4Event* anEvent);
G4double GetEnergy(){return Energy;};
BrachyPrimaryGeneratorActionIr();
~BrachyPrimaryGeneratorActionIr();
void GeneratePrimaries(G4Event* anEvent);
G4double GetEnergy(){return primaryParticleEnergy;};
private:
// G4ParticleGun* m_pParticleGun;
G4ParticleGun* m_pParticleGun;
//G4RadioactiveDecay *m_pRadioactiveDecay;
G4double Energy;
G4RadioactiveDecay *m_pRadioactiveDecay;
// BrachyPrimaryGeneratorMessenger* gunMessenger;
G4std::vector<G4double> vettore;
private:
G4ParticleGun* particleGun;
G4double primaryParticleEnergy;
};
#endif
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: BrachyRunAction.hh,v 1.6 2002/11/18 15:18:37 guatelli Exp $
// GEANT4 tag $Name: geant4-05-01 $
// $Id: BrachyRunAction.hh,v 1.7 2003/05/22 17:20:42 guatelli Exp $
// GEANT4 tag $Name: geant4-05-02 $
//
//
//
@@ -39,37 +39,33 @@
#include "G4RunManager.hh"
#include "globals.hh"
class G4Run;
class BrachyAnalysisManager;
class BrachyDetectorConstruction;
class BrachyRunMessenger;
class BrachyFactory;
class BrachyFactoryIr;
class BrachyFactoryI;
class BrachyRunAction : public G4UserRunAction
{
public:
BrachyRunAction(G4String& );
~BrachyRunAction();
public:
BrachyRunAction(G4String& );
~BrachyRunAction();
public:
void BeginOfRunAction(const G4Run*);
void EndOfRunAction(const G4Run* );
public:
void BeginOfRunAction(const G4Run*);
void EndOfRunAction(const G4Run* );
void SelectEnergy(G4int);
private:
G4String SDname;
BrachyFactory *factory;
G4VUserDetectorConstruction* pDetector;
BrachyDetectorConstruction* pDet;
G4int a;
BrachyRunMessenger* pRun;
};
private:
G4String sensitiveDetectorName;
BrachyDetectorConstruction* detector;
BrachyRunMessenger* runMessenger;
BrachyFactory *factory;
G4int sourceChoice; //select primary particle
};
#endif
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: BrachyRunMessenger.hh,v 1.2 2002/11/18 15:18:37 guatelli Exp $
// GEANT4 tag $Name: geant4-05-01 $
// $Id: BrachyRunMessenger.hh,v 1.3 2003/05/22 17:20:42 guatelli Exp $
// GEANT4 tag $Name: geant4-05-02 $
//
//
//
@@ -35,8 +35,6 @@
// This class permits to switch the energy of the gamma delivered from the
//radionuclides (Iodium/Iridium)
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#ifndef BrachyRunMessenger_h
#define BrachyRunMessenger_h 1
@@ -45,36 +43,22 @@
#include "G4UImessenger.hh"
class BrachyRunAction;
class BrachyFactoryIr;
class BrachyRunAction;
class G4UIdirectory;
class G4UIcmdWithAString;
class G4UIcmdWithAnInteger;
class G4UIcmdWithADoubleAndUnit;
class G4UIcmdWithoutParameter;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class BrachyRunMessenger: public G4UImessenger
{
public:
BrachyRunMessenger(BrachyRunAction* );
~BrachyRunMessenger();
void SetNewValue(G4UIcommand*, G4String);
private:
BrachyRunAction* pRun;
G4UIcmdWithAString* selDetCmd;
G4UIdirectory* detDir;
G4UIdirectory* mydetDir;
public:
BrachyRunMessenger(BrachyRunAction* );
~BrachyRunMessenger();
void SetNewValue(G4UIcommand*, G4String);
private:
G4UIdirectory* runDir;
G4UIcmdWithAString* primaryParticleEnergySpectrumCmd;
BrachyRunAction* runManager;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: BrachyVisManager.hh,v 1.4 2002/11/18 15:18:37 guatelli Exp $
// GEANT4 tag $Name: geant4-05-01 $
// $Id: BrachyVisManager.hh,v 1.5 2003/05/22 17:20:42 guatelli Exp $
// GEANT4 tag $Name: geant4-05-02 $
//
//
//
@@ -41,10 +41,8 @@
#include "G4VisManager.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
class BrachyVisManager: public G4VisManager {
class BrachyVisManager: public G4VisManager
{
public:
BrachyVisManager ();
@@ -52,11 +50,8 @@ public:
private:
void RegisterGraphicsSystems ();
};
#endif
#endif