Collimator60BeamLine Class Reference

#include <Collimator60BeamLine.hh>

Inheritance diagram for Collimator60BeamLine:

Collaboration diagram for Collimator60BeamLine:

Public Member Functions
	Collimator60BeamLine ()
	~Collimator60BeamLine ()
G4VPhysicalVolume *	Construct ()
void	IortBeamLineVacuumSource ()
void	IortBeamLineTitaniumWindows ()
void	IortBeamLineMonitorChambers ()
void	IortBeamLineBlocks ()
void	IortBeamLineJunctions ()
void	IortBeamLineFinalCollimator ()
void	SetInnerRadiusFinalCollimatorIORT (G4double)
void	SetOuterRadiusFinalCollimatorIORT (G4double)
Public Member Functions inherited from G4VUserDetectorConstruction
	G4VUserDetectorConstruction ()
virtual	~G4VUserDetectorConstruction ()
virtual void	ConstructSDandField ()
virtual void	CloneSD ()
virtual void	CloneF ()
void	RegisterParallelWorld (G4VUserParallelWorld *)
G4int	ConstructParallelGeometries ()
void	ConstructParallelSD ()
G4int	GetNumberOfParallelWorld () const
G4VUserParallelWorld *	GetParallelWorld (G4int i) const

Additional Inherited Members
Protected Member Functions inherited from G4VUserDetectorConstruction
void	SetSensitiveDetector (const G4String &logVolName, G4VSensitiveDetector *aSD, G4bool multi=false)
void	SetSensitiveDetector (G4LogicalVolume *logVol, G4VSensitiveDetector *aSD)

Detailed Description

Definition at line 58 of file Collimator60BeamLine.hh.

Constructor & Destructor Documentation

Collimator60BeamLine::Collimator60BeamLine

(

)

Definition at line 59 of file Collimator60BeamLine.cc.

                                          :
  physicalTreatmentRoom(0),iortDetectorConstruction(0),
  
  

  solidFinalCollimatorIORT(0),
  physiFinalCollimatorIORT(0),

  solidGiunz1FinalCollIORT(0),
  physiGiunz1FinalCollIORT(0),

  solidGiunz2FinalCollIORT(0),  
  physiGiunz2FinalCollIORT(0),

  solidGiunz3FinalCollIORT(0),
  physiGiunz3FinalCollIORT(0),  

  solidGiunz3FinalCollIntIORT(0),
  physiGiunz3FinalCollIntIORT(0), 
  
  solidGiunz4FinalCollIORT(0),
  physiGiunz4FinalCollIORT(0),

  solidGiunz5FinalCollIORT(0),
  physiGiunz5FinalCollIORT(0),
  
  solidBlocco1IORT(0),
  physiBlocco1IORT(0),

  solidBlocco2IORT(0),
  physiBlocco2IORT(0),

  solidBlocco3IORT(0),
  physiBlocco3IORT(0),

  solidBlocco20mmIORT(0),
  physiBlocco20mmIORT(0),  

  solidCM1_1_2IORT(0),
  physiCM1_1_2IORT(0),
  
  solidCM1_2_2IORT(0),
  physiCM1_2_2IORT(0),
  
  solidCM2_1_2IORT(0),
  physiCM2_1_2IORT(0),

  solidCM2_2_2IORT(0),
  physiCM2_2_2IORT(0),  

  solidCCMIORT(0),
  physiCCMIORT(0),

  solidPFS1IORT(0),
  physiPFS1IORT(0),

  solidPFS2IORT(0),
  physiPFS2IORT(0),

  solidPFS3IORT(0),
  physiPFS3IORT(0),

  solidFTIORT(0),
  physiFTIORT(0)


{
  // Messenger to change parameters of the collimator60BeamLine geometry
  collimatorMessenger = new Collimator60BeamLineMessenger(this);

}

Collimator60BeamLine::~Collimator60BeamLine

(

)

Definition at line 131 of file Collimator60BeamLine.cc.

{
  delete collimatorMessenger;
  delete iortDetectorConstruction;
}

Member Function Documentation

G4VPhysicalVolume * Collimator60BeamLine::Construct ( void  )

virtual

Implements G4VUserDetectorConstruction.

Definition at line 140 of file Collimator60BeamLine.cc.

{ 
  // Sets default geometry and materials
  SetDefaultDimensions();
  
  // Construct the whole Collimator Beam Line 
  ConstructCollimator60BeamLine();

  
  // IORTDetectorConstruction builds ONLY the phantom and the detector with its associated ROGeometry
  iortDetectorConstruction = new IORTDetectorConstruction(physicalTreatmentRoom); 
  
  return physicalTreatmentRoom;
}

void Collimator60BeamLine::IortBeamLineBlocks

(

)

Definition at line 643 of file Collimator60BeamLine.cc.

{

   G4double phi4 = 90. *deg;     

            
   G4RotationMatrix rm4;               
   rm4.rotateY(phi4);


  // IORT BEAM LINE BLOCKS
  

  // ------------------------------------------------//
  //        Block 4       //
  // ------------------------------------------------//

  const G4double outRadiusBlocco20mmIORT = 36.5 *mm;
  const G4double innRadiusBlocco20mmIORT = 10. *mm;
  const G4double hightBlocco20mmIORT = 3. *mm;
  const G4double startAngleBlocco20mmIORT = 0.*deg;
  const G4double spanningAngleBlocco20mmIORT = 360.*deg;
  const G4double XPositionBlocco20mmIORT = -830. *mm;

  solidBlocco20mmIORT = new G4Tubs("Blocco20mmIORT", innRadiusBlocco20mmIORT, 
                    outRadiusBlocco20mmIORT,
                    hightBlocco20mmIORT, 
                    startAngleBlocco20mmIORT, 
                    spanningAngleBlocco20mmIORT);

  G4LogicalVolume* logBlocco20mmIORT = new G4LogicalVolume(solidBlocco20mmIORT, 
                                  Blocco20mmIORTMaterialIORT, "Blocco20mmIORT", 0, 0, 0);

  physiBlocco20mmIORT = new G4PVPlacement(G4Transform3D(rm4, G4ThreeVector((XPositionBlocco20mmIORT),0.,0.)),
                       "Blocco20mmORT", logBlocco20mmIORT, physicalTreatmentRoom, false, 0); 

  logBlocco20mmIORT -> SetVisAttributes(green);


  // -----------------------//
  //        Block 3        //
  // -----------------------//

  const G4double outRadiusBlocco3IORT = 36.5 *mm;
  const G4double innRadiusBlocco3IORT = 15. *mm;
  const G4double hightBlocco3IORT = 3.5 *mm;
  const G4double startAngleBlocco3IORT = 0.*deg;
  const G4double spanningAngleBlocco3IORT = 360.*deg;
  const G4double XPositionBlocco3IORT = -823.5 *mm;
    
  
  solidBlocco3IORT = new G4Tubs("Blocco3IORT", innRadiusBlocco3IORT, 
                    outRadiusBlocco3IORT,
                    hightBlocco3IORT, 
                    startAngleBlocco3IORT, 
                    spanningAngleBlocco3IORT);

  G4LogicalVolume* logBlocco3IORT = new G4LogicalVolume(solidBlocco3IORT, 
                                  Blocco3IORTMaterialIORT, "Blocco3IORT", 0, 0, 0);

  physiBlocco3IORT = new G4PVPlacement(G4Transform3D(rm4, G4ThreeVector((XPositionBlocco3IORT),0.,0.)),
                       "Blocco3ORT", logBlocco3IORT, physicalTreatmentRoom, false, 0); 

  logBlocco3IORT -> SetVisAttributes(yellow);

 // -----------------------//
  //        Block 2        //
  // -----------------------//

  const G4double outRadiusBlocco2IORT = 41.5 *mm;
  const G4double innRadiusBlocco2IORT = 15. *mm;
  const G4double hightBlocco2IORT = 8. *mm;
  const G4double startAngleBlocco2IORT = 0.*deg;
  const G4double spanningAngleBlocco2IORT = 360.*deg;
  const G4double XPositionBlocco2IORT = -812. *mm;
    
  
  solidBlocco2IORT = new G4Tubs("Blocco2IORT", innRadiusBlocco2IORT, 
                    outRadiusBlocco2IORT,
                    hightBlocco2IORT, 
                    startAngleBlocco2IORT, 
                    spanningAngleBlocco2IORT);

  G4LogicalVolume* logBlocco2IORT = new G4LogicalVolume(solidBlocco2IORT, 
                                  Blocco2IORTMaterialIORT, "Blocco2IORT", 0, 0, 0);

  physiBlocco2IORT = new G4PVPlacement(G4Transform3D(rm4, G4ThreeVector((XPositionBlocco2IORT),0.,0.)),
                       "Blocco2IORT", logBlocco2IORT, physicalTreatmentRoom, false, 0); 

  logBlocco2IORT -> SetVisAttributes(red);

  // ----------------------- //
  //       Block 1          //
  // ----------------------- //

  const G4double outRadiusBlocco1IORT = 52.0 *mm;
  const G4double innRadiusBlocco1IORT = 15. *mm;
  const G4double hightBlocco1IORT = 8.5 *mm;
  const G4double startAngleBlocco1IORT = 0.*deg;
  const G4double spanningAngleBlocco1IORT = 360.*deg;
  const G4double XPositionBlocco1IORT = -795.5*mm;

  solidBlocco1IORT = new G4Tubs("Blocco1IORT", innRadiusBlocco1IORT, 
                    outRadiusBlocco1IORT,
                    hightBlocco1IORT, 
                    startAngleBlocco1IORT, 
                    spanningAngleBlocco1IORT);

  G4LogicalVolume* logBlocco1IORT = new G4LogicalVolume(solidBlocco1IORT, 
                                  Blocco1IORTMaterialIORT, "Blocco1IORT", 0, 0, 0);

  physiBlocco1IORT = new G4PVPlacement(G4Transform3D(rm4, G4ThreeVector((XPositionBlocco1IORT),0.,0.)),
                       "Blocco1IORT", logBlocco1IORT, physicalTreatmentRoom, false, 0); 

  logBlocco1IORT -> SetVisAttributes(white);
}

Here is the call graph for this function:

void Collimator60BeamLine::IortBeamLineFinalCollimator

(

)

Definition at line 920 of file Collimator60BeamLine.cc.

{
// -----------------------//
  // FINAL COLLIMATOR IORT  //
  //------------------------//

 // const G4double OuterRadiusFinalCollimatorIORT = 35. *mm;
 // const G4double innerRadiusFinalCollimatorIORT = 30. *mm;
  const G4double hightFinalCollimatorIORT = 334. *mm;
  const G4double startAngleFinalCollimatorIORT = 0.*deg;
  const G4double spanningAngleFinalCollimatorIORT = 360.*deg;
  const G4double finalCollimatorXPositionIORT = -389.*mm;

  
 
  
  G4double phi6 = 90. *deg;     

          
   G4RotationMatrix rm6;               
   rm6.rotateY(phi6);

    
  solidFinalCollimatorIORT = new G4Tubs("FinalCollimatorIORT", innerRadiusFinalCollimatorIORT, 
                    OuterRadiusFinalCollimatorIORT,
                    hightFinalCollimatorIORT, 
                    startAngleFinalCollimatorIORT, 
                    spanningAngleFinalCollimatorIORT);

  G4LogicalVolume* logFinalCollimatorIORT = new G4LogicalVolume(solidFinalCollimatorIORT, 
                                  finalCollimatorMaterialIORT, "FinalCollimatorIORT", 0, 0, 0);

  physiFinalCollimatorIORT = new G4PVPlacement(G4Transform3D(rm6, G4ThreeVector((finalCollimatorXPositionIORT),0.,0.)),
                       "FinalCollimatorIORT", logFinalCollimatorIORT, physicalTreatmentRoom, false, 0); 

  //  logFinalCollimatorIORT -> SetVisAttributes(G4VisAttributes::GetInvisible()); 
  logFinalCollimatorIORT -> SetVisAttributes(blue);
}

Here is the call graph for this function:

void Collimator60BeamLine::IortBeamLineJunctions

(

)

Definition at line 762 of file Collimator60BeamLine.cc.

{
 

  G4double phi5 = 90. *deg;     

            
   G4RotationMatrix rm5;               
   rm5.rotateY(phi5);

  // --------------------------------- //
  // Junction 5 FINAL COLLIMATOR IORT //
  // --------------------------------- //

  const G4double outRadiusGiunz5FinalCollIORT = 48.25 *mm;
  const G4double innRadiusGiunz5FinalCollIORT = 13.75 *mm;
  const G4double hightGiunz5FinalCollIORT = 3.5 *mm;
  const G4double startAngleGiunz5FinalCollIORT = 0.*deg;
  const G4double spanningAngleGiunz5FinalCollIORT = 360.*deg;
  const G4double Giunz5FinalCollXPositionIORT = -783.5 *mm;

  solidGiunz5FinalCollIORT = new G4Tubs("Giunz5FinalCollIORT", innRadiusGiunz5FinalCollIORT, 
                    outRadiusGiunz5FinalCollIORT,
                    hightGiunz5FinalCollIORT, 
                    startAngleGiunz5FinalCollIORT, 
                    spanningAngleGiunz5FinalCollIORT);

  G4LogicalVolume* logGiunz5FinalCollIORT = new G4LogicalVolume(solidGiunz5FinalCollIORT, 
                                  Giunz5FinalCollMaterialIORT, "Giunz5FinalCollIORT", 0, 0, 0);

  physiGiunz5FinalCollIORT = new G4PVPlacement(G4Transform3D(rm5, G4ThreeVector((Giunz5FinalCollXPositionIORT),0.,0.)),
                       "Giunz5FinalCollIORT", logGiunz5FinalCollIORT, physicalTreatmentRoom, false, 0); 

  logGiunz5FinalCollIORT -> SetVisAttributes(yellow);

// --------------------------------- //
  // Junction 4 FINAL COLLIMATOR IORT //
  // --------------------------------- //

  const G4double outRadiusGiunz4FinalCollIORT = 42. *mm;
  const G4double innRadiusGiunz4FinalCollIORT = 13.75 *mm;
  const G4double hightGiunz4FinalCollIORT = 8.5 *mm;
  const G4double startAngleGiunz4FinalCollIORT = 0.*deg;
  const G4double spanningAngleGiunz4FinalCollIORT = 360.*deg;
  const G4double Giunz4FinalCollXPositionIORT = -771.5 *mm;

  solidGiunz4FinalCollIORT = new G4Tubs("Giunz4FinalCollIORT", innRadiusGiunz4FinalCollIORT, 
                    outRadiusGiunz4FinalCollIORT,
                    hightGiunz4FinalCollIORT, 
                    startAngleGiunz4FinalCollIORT, 
                    spanningAngleGiunz4FinalCollIORT);

  G4LogicalVolume* logGiunz4FinalCollIORT = new G4LogicalVolume(solidGiunz4FinalCollIORT, 
                                  Giunz4FinalCollMaterialIORT, "Giunz4FinalCollIORT", 0, 0, 0);

  physiGiunz4FinalCollIORT = new G4PVPlacement(G4Transform3D(rm5, G4ThreeVector((Giunz4FinalCollXPositionIORT),0.,0.)),
                       "Giunz4FinalCollIORT", logGiunz4FinalCollIORT, physicalTreatmentRoom, false, 0); 

  logGiunz4FinalCollIORT -> SetVisAttributes(blue); 


  
 // --------------------------------- //
  // Junction 3 FINAL COLLIMATOR IORT //
  // --------------------------------- //
   
  const G4double outRadiusGiunz3FinalCollIORT = 42. *mm;
  const G4double innRadiusGiunz3FinalCollIORT = 0. *mm;
  const G4double hightGiunz3FinalCollIORT = 4.25 *mm;
  const G4double startAngleGiunz3FinalCollIORT = 0.*deg;
  const G4double spanningAngleGiunz3FinalCollIORT = 360.*deg;
  const G4double Giunz3FinalCollXPositionIORT = -758.75 *mm;
    
     
  solidGiunz3FinalCollIORT = new G4Tubs("Giunz3FinalCollIORT", innRadiusGiunz3FinalCollIORT, 
                    outRadiusGiunz3FinalCollIORT,
                    hightGiunz3FinalCollIORT, 
                    startAngleGiunz3FinalCollIORT, 
                    spanningAngleGiunz3FinalCollIORT);

  G4LogicalVolume* logicsolidGiunz3FinalCollIORT = new G4LogicalVolume(solidGiunz3FinalCollIORT, 
                                  Giunz3FinalCollMaterialIORT, "Giunz3FinalCollIORT", 0, 0, 0);

  physiGiunz3FinalCollIORT = new G4PVPlacement(G4Transform3D(rm5, G4ThreeVector((Giunz3FinalCollXPositionIORT),0.,0.)),
                       "Giunz3FinalCollIORT", logicsolidGiunz3FinalCollIORT, physicalTreatmentRoom, false, 0); 

  logicsolidGiunz3FinalCollIORT -> SetVisAttributes(yellow);
 //  logicsolidGiunz3FinalCollIORT -> SetVisAttributes (G4VisAttributes::GetInvisible());



  // --------------------------------- //
  // Junction 3 FINAL COLLIMATOR IORT internal //
  // --------------------------------- //
   
 
     
  solidGiunz3FinalCollIntIORT = new G4Cons("Giunz3FinalCollIntIORT",0.*mm,13.75*mm,0.*mm,22.25*mm,4.25*mm,0.*deg,360.*deg);

  G4LogicalVolume* logicsolidGiunz3FinalCollIntIORT = new G4LogicalVolume(solidGiunz3FinalCollIntIORT, 
                                  Giunz3FinalCollMaterialIntIORT, "Giunz3FinalCollIntIORT", 0, 0, 0);

  physiGiunz3FinalCollIntIORT = new G4PVPlacement(0, G4ThreeVector(0.,0.,0.),"Giunz3FinalCollIntIORT", logicsolidGiunz3FinalCollIntIORT,physiGiunz3FinalCollIORT, false, 0); 

  logicsolidGiunz3FinalCollIntIORT -> SetVisAttributes(yellow); 


// --------------------------------- //
  // Junction 2 FINAL COLLIMATOR IORT //
  // --------------------------------- //

  const G4double outRadiusGiunz2FinalCollIORT = 42. *mm;
  const G4double innRadiusGiunz2FinalCollIORT = 22.25 *mm;
  const G4double hightGiunz2FinalCollIORT = 5.75 *mm;
  const G4double startAngleGiunz2FinalCollIORT = 0.*deg;
  const G4double spanningAngleGiunz2FinalCollIORT = 360.*deg;
  const G4double Giunz2FinalCollXPositionIORT = -748.75 *mm;

  solidGiunz2FinalCollIORT = new G4Tubs("Giunz2FinalCollIORT", innRadiusGiunz2FinalCollIORT, 
                    outRadiusGiunz2FinalCollIORT,
                    hightGiunz2FinalCollIORT, 
                    startAngleGiunz2FinalCollIORT, 
                    spanningAngleGiunz2FinalCollIORT);

  G4LogicalVolume* logGiunz2FinalCollIORT = new G4LogicalVolume(solidGiunz2FinalCollIORT, 
                                  Giunz2FinalCollMaterialIORT, "Giunz2FinalCollIORT", 0, 0, 0);

  physiGiunz2FinalCollIORT = new G4PVPlacement(G4Transform3D(rm5, G4ThreeVector((Giunz2FinalCollXPositionIORT),0.,0.)),
                       "Giunz2FinalCollIORT", logGiunz2FinalCollIORT, physicalTreatmentRoom, false, 0); 

  logGiunz2FinalCollIORT -> SetVisAttributes(red); 
 
// --------------------------------- //
  // Junction 1 FINAL COLLIMATOR IORT //
  // --------------------------------- //

  const G4double outRadiusGiunz1FinalCollIORT = 45. *mm;
  const G4double innRadiusGiunz1FinalCollIORT = 22.25 *mm;
  const G4double hightGiunz1FinalCollIORT = 10. *mm;
  const G4double startAngleGiunz1FinalCollIORT = 0.*deg;
  const G4double spanningAngleGiunz1FinalCollIORT = 360.*deg;
  const G4double Giunz1FinalCollXPositionIORT = -733.*mm;

  solidGiunz1FinalCollIORT = new G4Tubs("Giunz1FinalCollIORT", innRadiusGiunz1FinalCollIORT, 
                    outRadiusGiunz1FinalCollIORT,
                    hightGiunz1FinalCollIORT, 
                    startAngleGiunz1FinalCollIORT, 
                    spanningAngleGiunz1FinalCollIORT);

  G4LogicalVolume* logGiunz1FinalCollIORT = new G4LogicalVolume(solidGiunz1FinalCollIORT, 
                                  Giunz1FinalCollMaterialIORT, "Giunz1FinalCollIORT", 0, 0, 0);

  physiGiunz1FinalCollIORT = new G4PVPlacement(G4Transform3D(rm5, G4ThreeVector((Giunz1FinalCollXPositionIORT),0.,0.)),
                       "Giunz1FinalCollIORT", logGiunz1FinalCollIORT, physicalTreatmentRoom, false, 0); 

  logGiunz1FinalCollIORT -> SetVisAttributes(gray);
}

Here is the call graph for this function:

void Collimator60BeamLine::IortBeamLineMonitorChambers

(

)

Definition at line 424 of file Collimator60BeamLine.cc.

{

   G4double phi3 = 90. *deg;     

     // Matrix definition for a 90 deg rotation. Also used for other volumes       
   G4RotationMatrix rm3;               
   rm3.rotateY(phi3);

  // Monitor Chambers System

 

  // ---------------------------------------------------------------//
  //             Superior Final Part Monitor Chambers   3      //
  // ---------------------------------------------------------------//

  const G4double outRadiusPFS3IORT = 44.75 *mm;
  const G4double innRadiusPFS3IORT = 17.5 *mm;
  const G4double hightPFS3IORT = 3.03 *mm;
  const G4double startAnglePFS3IORT = 0.*deg;
  const G4double spanningAnglePFS3IORT = 360.*deg;
  const G4double XPositionPFS3IORT = -848.755 *mm;

  solidPFS3IORT = new G4Tubs("PFS3IORT", innRadiusPFS3IORT, 
                    outRadiusPFS3IORT,
                    hightPFS3IORT, 
                    startAnglePFS3IORT, 
                    spanningAnglePFS3IORT);

  G4LogicalVolume* logPFS3IORT = new G4LogicalVolume(solidPFS3IORT, 
                                  PFS3IORTMaterialIORT, "PFS3IORT", 0, 0, 0);

  physiPFS3IORT = new G4PVPlacement(G4Transform3D(rm3, G4ThreeVector((XPositionPFS3IORT),0.,0.)),
                       "PFS3IORT", logPFS3IORT, physicalTreatmentRoom, false, 0); 

  logPFS3IORT -> SetVisAttributes(white);

  
  // ---------------------------------------------------------------//
  //             Superior Final Part Monitor Chambers   2       //
  // ---------------------------------------------------------------//

  const G4double outRadiusPFS2IORT = 44.75 *mm;
  const G4double innRadiusPFS2IORT = 10. *mm;
  const G4double hightPFS2IORT = 1.47 *mm;
  const G4double startAnglePFS2IORT = 0.*deg;
  const G4double spanningAnglePFS2IORT = 360.*deg;
  const G4double XPositionPFS2IORT = -844.255 *mm;

  solidPFS2IORT = new G4Tubs("PFS2IORT", innRadiusPFS2IORT, 
                    outRadiusPFS2IORT,
                    hightPFS2IORT, 
                    startAnglePFS2IORT, 
                    spanningAnglePFS2IORT);

  G4LogicalVolume* logPFS2IORT = new G4LogicalVolume(solidPFS2IORT, 
                                  PFS2IORTMaterialIORT, "PFS2IORT", 0, 0, 0);

  physiPFS2IORT = new G4PVPlacement(G4Transform3D(rm3, G4ThreeVector((XPositionPFS2IORT),0.,0.)),
                       "PFS2IORT", logPFS2IORT, physicalTreatmentRoom, false, 0); 

  logPFS2IORT -> SetVisAttributes(green);

  // ---------------------------------------------------------------//
  //             Superior Final Part Monitor Chambers   1       //
  // ---------------------------------------------------------------//

  const G4double outRadiusPFS1IORT = 35. *mm;
  const G4double innRadiusPFS1IORT = 10. *mm;
  const G4double hightPFS1IORT = 0.88 *mm;
  const G4double startAnglePFS1IORT = 0.*deg;
  const G4double spanningAnglePFS1IORT = 360.*deg;
  const G4double XPositionPFS1IORT = -841.905 *mm;

  solidPFS1IORT = new G4Tubs("PFS1IORT", innRadiusPFS1IORT, 
                    outRadiusPFS1IORT,
                    hightPFS1IORT, 
                    startAnglePFS1IORT, 
                    spanningAnglePFS1IORT);

  G4LogicalVolume* logPFS1IORT = new G4LogicalVolume(solidPFS1IORT, 
                                  PFS1IORTMaterialIORT, "PFS1IORT", 0, 0, 0);

  physiPFS1IORT = new G4PVPlacement(G4Transform3D(rm3, G4ThreeVector((XPositionPFS1IORT),0.,0.)),
                       "PFS1IORT", logPFS1IORT, physicalTreatmentRoom, false, 0); 

  logPFS1IORT -> SetVisAttributes(green);

  // ------------------------------------------------//
  //           Monitor Chambers Cylinder               //
  // ------------------------------------------------//

  const G4double outRadiusCCMIORT = 35. *mm;
  const G4double innRadiusCCMIORT = 10. *mm;
  const G4double hightCCMIORT = 4.0125 *mm;
  const G4double startAngleCCMIORT = 0.*deg;
  const G4double spanningAngleCCMIORT = 360.*deg;
  const G4double XPositionCCMIORT = -837.0125 *mm;

  solidCCMIORT = new G4Tubs("CCMIORT", innRadiusCCMIORT, 
                    outRadiusCCMIORT,
                    hightCCMIORT, 
                    startAngleCCMIORT, 
                    spanningAngleCCMIORT);

  G4LogicalVolume* logCCMIORT = new G4LogicalVolume(solidCCMIORT, 
                                  CCMIORTMaterialIORT, "CCMIORT", 0, 0, 0);

  physiCCMIORT = new G4PVPlacement(G4Transform3D(rm3, G4ThreeVector((XPositionCCMIORT),0.,0.)),
                       "CCMIORT", logCCMIORT, physicalTreatmentRoom, false, 0); 

  logCCMIORT -> SetVisAttributes(green);


  // ------------------------------------------------//
  //        Second Monitor Chamber Lamina Al 2 of 2  //
  // ------------------------------------------------//

  const G4double outRadiusCM2_2_2IORT = 20. *mm;
  const G4double innRadiusCM2_2_2IORT = 0. *mm;
  const G4double hightCM2_2_2IORT = 0.025 *mm;
  const G4double startAngleCM2_2_2IORT = 0.*deg;
  const G4double spanningAngleCM2_2_2IORT = 360.*deg;
  const G4double XPositionCM2_2_2IORT = -841. *mm;

  solidCM2_2_2IORT = new G4Tubs("CM2_2_2IORT", innRadiusCM2_2_2IORT, 
                    outRadiusCM2_2_2IORT,
                    hightCM2_2_2IORT, 
                    startAngleCM2_2_2IORT, 
                    spanningAngleCM2_2_2IORT);

  G4LogicalVolume* logCM2_2_2IORT = new G4LogicalVolume(solidCM2_2_2IORT, 
                                  CM2_2_2IORTMaterialIORT, "CM2_2_2IORT", 0, 0, 0);

  physiCM2_2_2IORT = new G4PVPlacement(G4Transform3D(rm3, G4ThreeVector((XPositionCM2_2_2IORT),0.,0.)),
                       "CM2_2_2ORT", logCM2_2_2IORT, physicalTreatmentRoom, false, 0); 

  logCM2_2_2IORT -> SetVisAttributes(green);  


// ------------------------------------------------//
  //        Second Monitor Chamber Lamina Al 1 of 2  //
  // ------------------------------------------------//

  const G4double outRadiusCM2_1_2IORT = 20. *mm;
  const G4double innRadiusCM2_1_2IORT = 0. *mm;
  const G4double hightCM2_1_2IORT = 0.025 *mm;
  const G4double startAngleCM2_1_2IORT = 0.*deg;
  const G4double spanningAngleCM2_1_2IORT = 360.*deg;
  const G4double XPositionCM2_1_2IORT = -839. *mm;

  solidCM2_1_2IORT = new G4Tubs("CM2_1_2IORT", innRadiusCM2_1_2IORT, 
                    outRadiusCM2_1_2IORT,
                    hightCM2_1_2IORT, 
                    startAngleCM2_1_2IORT, 
                    spanningAngleCM2_1_2IORT);

  G4LogicalVolume* logCM2_1_2IORT = new G4LogicalVolume(solidCM2_1_2IORT, 
                                  CM2_1_2IORTMaterialIORT, "CM2_1_2IORT", 0, 0, 0);

  physiCM2_1_2IORT = new G4PVPlacement(G4Transform3D(rm3, G4ThreeVector((XPositionCM2_1_2IORT),0.,0.)),
                       "CM2_1_2ORT", logCM2_1_2IORT, physicalTreatmentRoom, false, 0); 

  logCM2_1_2IORT -> SetVisAttributes(yellow); 

  // ------------------------------------------------//
  //        First Monitor Chamber Lamina Al 2 of 2    //
  // ------------------------------------------------//

  const G4double outRadiusCM1_2_2IORT = 20. *mm;
  const G4double innRadiusCM1_2_2IORT = 0. *mm;
  const G4double hightCM1_2_2IORT = 0.025 *mm;
  const G4double startAngleCM1_2_2IORT = 0.*deg;
  const G4double spanningAngleCM1_2_2IORT = 360.*deg;
  const G4double XPositionCM1_2_2IORT = -837. *mm;

  solidCM1_2_2IORT = new G4Tubs("CM1_2_2IORT", innRadiusCM1_2_2IORT, 
                    outRadiusCM1_2_2IORT,
                    hightCM1_2_2IORT, 
                    startAngleCM1_2_2IORT, 
                    spanningAngleCM1_2_2IORT);

  G4LogicalVolume* logCM1_2_2IORT = new G4LogicalVolume(solidCM1_2_2IORT, 
                              CM1_2_2IORTMaterialIORT, "CM1_2_2IORT", 0, 0, 0);

  physiCM1_2_2IORT = new G4PVPlacement(G4Transform3D(rm3, G4ThreeVector((XPositionCM1_2_2IORT),0.,0.)),
                       "CM1_2_2ORT", logCM1_2_2IORT, physicalTreatmentRoom, false, 0); 

  logCM1_2_2IORT -> SetVisAttributes(yellow);
  
  // ------------------------------------------------//
  //        First Monitor Chamber Lamina Al 1 of 2         //
  // ------------------------------------------------//

  const G4double outRadiusCM1_1_2IORT = 20. *mm;
  const G4double innRadiusCM1_1_2IORT = 0. *mm;
  const G4double hightCM1_1_2IORT = 0.025 *mm;
  const G4double startAngleCM1_1_2IORT = 0.*deg;
  const G4double spanningAngleCM1_1_2IORT = 360.*deg;
  const G4double XPositionCM1_1_2IORT = -835. *mm;

  solidCM1_1_2IORT = new G4Tubs("CM1_1_2IORT", innRadiusCM1_1_2IORT, 
                    outRadiusCM1_1_2IORT,
                    hightCM1_1_2IORT, 
                    startAngleCM1_1_2IORT, 
                    spanningAngleCM1_1_2IORT);

  G4LogicalVolume* logCM1_1_2IORT = new G4LogicalVolume(solidCM1_1_2IORT, 
                                  CM1_1_2IORTMaterialIORT, "CM1_1_2IORT", 0, 0, 0);

  physiCM1_1_2IORT = new G4PVPlacement(G4Transform3D(rm3, G4ThreeVector((XPositionCM1_1_2IORT),0.,0.)),
                       "CM1_1_2ORT", logCM1_1_2IORT, physicalTreatmentRoom, false, 0); 

  logCM1_1_2IORT -> SetVisAttributes(yellow);
}

Here is the call graph for this function:

void Collimator60BeamLine::IortBeamLineTitaniumWindows

(

)

Definition at line 390 of file Collimator60BeamLine.cc.

{
// ---------------------------------------------------------------//
  //                     Titanium Window                        //
  // ---------------------------------------------------------------//

  G4double phi2 = 90. *deg;     

            
   G4RotationMatrix rm2;               
   rm2.rotateY(phi2);

  const G4double outRadiusFTIORT = 44.75 *mm;
  const G4double innRadiusFTIORT = 8.5 *mm;
  const G4double hightFTIORT = 0.006 *mm;
  const G4double startAngleFTIORT = 0.*deg;
  const G4double spanningAngleFTIORT = 360.*deg;
  const G4double XPositionFTIORT = -861.791 *mm;

  solidFTIORT = new G4Tubs("FTIORT", innRadiusFTIORT, 
                    outRadiusFTIORT,
                    hightFTIORT, 
                    startAngleFTIORT, 
                    spanningAngleFTIORT);

  G4LogicalVolume* logFTIORT = new G4LogicalVolume(solidFTIORT, 
                                  FTIORTMaterialIORT, "FTIORT", 0, 0, 0);

  physiFTIORT = new G4PVPlacement(G4Transform3D(rm2, G4ThreeVector((XPositionFTIORT),0.,0.)),
                       "FTIORT", logFTIORT, physicalTreatmentRoom, false, 0); 

  logFTIORT -> SetVisAttributes(yellow);
}

Here is the call graph for this function:

void Collimator60BeamLine::IortBeamLineVacuumSource

(

)

Definition at line 354 of file Collimator60BeamLine.cc.

{
 // ---------------------------------------------------------------//
  //                     Vacuum Source                             //
  // ---------------------------------------------------------------//

  
  G4double phi1 = 90. *deg;     

          
   G4RotationMatrix rm1;               
   rm1.rotateY(phi1);

  const G4double outRadiusVSIORT = 44.75 *mm;
  const G4double innRadiusVSIORT = 0.*mm;
  const G4double hightVSIORT = 1. *mm;
  const G4double startAngleVSIORT = 0.*deg;
  const G4double spanningAngleVSIORT = 360.*deg;
  const G4double XPositionVSIORT = -862.797 *mm;
    
  solidVSIORT = new G4Tubs("VSIORT", innRadiusVSIORT, 
                    outRadiusVSIORT,
                    hightVSIORT, 
                    startAngleVSIORT, 
                    spanningAngleVSIORT);

  G4LogicalVolume* logVSIORT = new G4LogicalVolume(solidVSIORT, 
                                  VSIORTMaterialIORT, "VSIORT", 0, 0, 0);

  physiVSIORT = new G4PVPlacement(G4Transform3D(rm1, G4ThreeVector((XPositionVSIORT),0.,0.)),
                       "VSIORT", logVSIORT, physicalTreatmentRoom, false, 0); 

  logVSIORT -> SetVisAttributes(green);

}

Here is the call graph for this function:

void Collimator60BeamLine::SetInnerRadiusFinalCollimatorIORT

(

G4double

value

)

Definition at line 964 of file Collimator60BeamLine.cc.

{
  solidFinalCollimatorIORT -> SetInnerRadius(value);
  G4RunManager::GetRunManager() -> GeometryHasBeenModified();
  G4cout<<"Inner Radius of the final collimator IORT is (mm):"
    << solidFinalCollimatorIORT -> GetInnerRadius()/mm
    << G4endl; 
}

Here is the call graph for this function:

void Collimator60BeamLine::SetOuterRadiusFinalCollimatorIORT

(

G4double

value

)

Definition at line 975 of file Collimator60BeamLine.cc.

{
  solidFinalCollimatorIORT -> SetOuterRadius(value);
  G4RunManager::GetRunManager() -> GeometryHasBeenModified();
  G4cout<<"Outer Radius of the final collimator IORT is (mm):"
    << solidFinalCollimatorIORT -> GetOuterRadius()/mm
    << G4endl; 
}

Here is the call graph for this function:

---

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

• source/geant4.10.03.p03/examples/advanced/iort_therapy/include/Collimator60BeamLine.hh
• source/geant4.10.03.p03/examples/advanced/iort_therapy/src/Collimator60BeamLine.cc