Collimator80BeamLine Class Reference

#include <Collimator80BeamLine.hh>

Inheritance diagram for Collimator80BeamLine:

Collaboration diagram for Collimator80BeamLine:

Public Member Functions
	Collimator80BeamLine ()
	~Collimator80BeamLine ()
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

Private Member Functions
void	SetDefaultDimensions ()
void	ConstructCollimator80BeamLine ()

Private Attributes
Collimator80BeamLineMessenger *	collimatorMessenger
G4VPhysicalVolume *	physicalTreatmentRoom
IORTDetectorConstruction *	iortDetectorConstruction
G4VisAttributes *	blue
G4VisAttributes *	gray
G4VisAttributes *	white
G4VisAttributes *	red
G4VisAttributes *	yellow
G4VisAttributes *	green
G4VisAttributes *	darkGreen
G4VisAttributes *	darkOrange3
G4VisAttributes *	skyBlue
G4double	innerRadiusFinalCollimatorIORT
G4double	OuterRadiusFinalCollimatorIORT
G4Tubs *	solidFinalCollimatorIORT
G4VPhysicalVolume *	physiFinalCollimatorIORT
G4Material *	finalCollimatorMaterialIORT
G4Tubs *	solidGiunz1FinalCollIORT
G4VPhysicalVolume *	physiGiunz1FinalCollIORT
G4Material *	Giunz1FinalCollMaterialIORT
G4Tubs *	solidGiunz2FinalCollIORT
G4VPhysicalVolume *	physiGiunz2FinalCollIORT
G4Material *	Giunz2FinalCollMaterialIORT
G4Tubs *	solidGiunz3FinalCollIORT
G4VPhysicalVolume *	physiGiunz3FinalCollIORT
G4Material *	Giunz3FinalCollMaterialIORT
G4Cons *	solidGiunz3FinalCollIntIORT
G4Material *	Giunz3FinalCollMaterialIntIORT
G4VPhysicalVolume *	physiGiunz3FinalCollIntIORT
G4Tubs *	solidGiunz4FinalCollIORT
G4VPhysicalVolume *	physiGiunz4FinalCollIORT
G4Material *	Giunz4FinalCollMaterialIORT
G4Tubs *	solidGiunz5FinalCollIORT
G4VPhysicalVolume *	physiGiunz5FinalCollIORT
G4Material *	Giunz5FinalCollMaterialIORT
G4Tubs *	solidBlocco1IORT
G4VPhysicalVolume *	physiBlocco1IORT
G4Material *	Blocco1IORTMaterialIORT
G4Tubs *	solidBlocco2IORT
G4VPhysicalVolume *	physiBlocco2IORT
G4Material *	Blocco2IORTMaterialIORT
G4Tubs *	solidBlocco3IORT
G4VPhysicalVolume *	physiBlocco3IORT
G4Material *	Blocco3IORTMaterialIORT
G4Tubs *	solidBlocco20mmIORT
G4VPhysicalVolume *	physiBlocco20mmIORT
G4Material *	Blocco20mmIORTMaterialIORT
G4Tubs *	solidCM1_1_2IORT
G4VPhysicalVolume *	physiCM1_1_2IORT
G4Material *	CM1_1_2IORTMaterialIORT
G4Tubs *	solidCM1_2_2IORT
G4VPhysicalVolume *	physiCM1_2_2IORT
G4Material *	CM1_2_2IORTMaterialIORT
G4Tubs *	solidCM2_1_2IORT
G4VPhysicalVolume *	physiCM2_1_2IORT
G4Material *	CM2_1_2IORTMaterialIORT
G4Tubs *	solidCM2_2_2IORT
G4VPhysicalVolume *	physiCM2_2_2IORT
G4Material *	CM2_2_2IORTMaterialIORT
G4Tubs *	solidCCMIORT
G4VPhysicalVolume *	physiCCMIORT
G4Material *	CCMIORTMaterialIORT
G4Tubs *	solidPFS1IORT
G4VPhysicalVolume *	physiPFS1IORT
G4Material *	PFS1IORTMaterialIORT
G4Tubs *	solidPFS2IORT
G4VPhysicalVolume *	physiPFS2IORT
G4Material *	PFS2IORTMaterialIORT
G4Tubs *	solidPFS3IORT
G4VPhysicalVolume *	physiPFS3IORT
G4Material *	PFS3IORTMaterialIORT
G4Tubs *	solidFTIORT
G4VPhysicalVolume *	physiFTIORT
G4Material *	FTIORTMaterialIORT
G4Tubs *	solidVSIORT
G4VPhysicalVolume *	physiVSIORT
G4Material *	VSIORTMaterialIORT

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 Collimator80BeamLine.hh.

Constructor & Destructor Documentation

Collimator80BeamLine()

Collimator80BeamLine::Collimator80BeamLine

(

)

Definition at line 59 of file Collimator80BeamLine.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 collimator80BeamLine geometry
  collimatorMessenger = new Collimator80BeamLineMessenger(this);

}

~Collimator80BeamLine()

Collimator80BeamLine::~Collimator80BeamLine

(

)

Definition at line 131 of file Collimator80BeamLine.cc.

{
  delete collimatorMessenger;
  delete iortDetectorConstruction;
}

Member Function Documentation

Construct()

G4VPhysicalVolume * Collimator80BeamLine::Construct ( void  )

virtual

Implements G4VUserDetectorConstruction.

Definition at line 140 of file Collimator80BeamLine.cc.

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

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

Here is the call graph for this function:

ConstructCollimator80BeamLine()

void Collimator80BeamLine::ConstructCollimator80BeamLine ( )

private

Definition at line 315 of file Collimator80BeamLine.cc.

{ 
  // -----------------------------
  // Treatment room - World volume
  //------------------------------
  // Treatment room sizes
  const G4double worldX = 400.0 *cm;
  const G4double worldY = 400.0 *cm;
  const G4double worldZ = 400.0 *cm;
  G4bool isotopes = false;
 
  G4Material* airNist =  G4NistManager::Instance()->FindOrBuildMaterial("G4_AIR", isotopes);
  G4Box* treatmentRoom = new G4Box("TreatmentRoom",worldX,worldY,worldZ);
  G4LogicalVolume* logicTreatmentRoom = new G4LogicalVolume(treatmentRoom, 
                                                            airNist, 
                                                            "logicTreatmentRoom", 
                                0,0,0);
  physicalTreatmentRoom = new G4PVPlacement(0,
                        G4ThreeVector(),
                        "physicalTreatmentRoom", 
                        logicTreatmentRoom, 
                        0,false,0);
 

  // The treatment room is invisible in the Visualisation
  logicTreatmentRoom -> SetVisAttributes (G4VisAttributes::Invisible);
 
  // Components of the Collimator Beam Line

  IortBeamLineVacuumSource();
  IortBeamLineTitaniumWindows();
  IortBeamLineMonitorChambers();
  IortBeamLineBlocks() ;
  IortBeamLineJunctions(); 
  IortBeamLineFinalCollimator();
    
}

Here is the call graph for this function:

Here is the caller graph for this function:

IortBeamLineBlocks()

void Collimator80BeamLine::IortBeamLineBlocks

(

)

Definition at line 643 of file Collimator80BeamLine.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:

Here is the caller graph for this function:

IortBeamLineFinalCollimator()

void Collimator80BeamLine::IortBeamLineFinalCollimator

(

)

Definition at line 916 of file Collimator80BeamLine.cc.

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

 // const G4double outRadiusFinalCollimatorIORT = 45. *mm;
 // const G4double innRadiusFinalCollimatorIORT = 40. *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::Invisible); 
  logFinalCollimatorIORT -> SetVisAttributes(red); 
}

Here is the call graph for this function:

Here is the caller graph for this function:

IortBeamLineJunctions()

void Collimator80BeamLine::IortBeamLineJunctions

(

)

Definition at line 760 of file Collimator80BeamLine.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::Invisible);



  // --------------------------------- //
  // 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 = 55. *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:

Here is the caller graph for this function:

IortBeamLineMonitorChambers()

void Collimator80BeamLine::IortBeamLineMonitorChambers

(

)

Definition at line 424 of file Collimator80BeamLine.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:

Here is the caller graph for this function:

IortBeamLineTitaniumWindows()

void Collimator80BeamLine::IortBeamLineTitaniumWindows

(

)

Definition at line 389 of file Collimator80BeamLine.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:

Here is the caller graph for this function:

IortBeamLineVacuumSource()

void Collimator80BeamLine::IortBeamLineVacuumSource

(

)

Definition at line 354 of file Collimator80BeamLine.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:

Here is the caller graph for this function:

SetDefaultDimensions()

void Collimator80BeamLine::SetDefaultDimensions ( )

private

Definition at line 165 of file Collimator80BeamLine.cc.

{

   // Set of coulors that can be used
  white = new G4VisAttributes( G4Colour());
  white -> SetVisibility(true);
  //white -> SetForceSolid(true);
    
  blue = new G4VisAttributes(G4Colour(0. ,0. ,1.));
  blue -> SetVisibility(true);
  //blue -> SetForceSolid(true);
    
  gray = new G4VisAttributes( G4Colour(0.5, 0.5, 0.5 ));
  gray-> SetVisibility(true);
  //gray-> SetForceSolid(true);
    
  red = new G4VisAttributes(G4Colour(1. ,0. ,0.));
  red-> SetVisibility(true);
  //red-> SetForceSolid(true);
    
  yellow = new G4VisAttributes(G4Colour(1., 1., 0. ));
  yellow-> SetVisibility(true);
  //yellow-> SetForceSolid(true);
    
  green = new G4VisAttributes( G4Colour(25/255. , 255/255. ,  25/255. ));
  green -> SetVisibility(true);
  //green -> SetForceSolid(true);
    
  darkGreen = new G4VisAttributes( G4Colour(0/255. , 100/255. ,  0/255. ));
  darkGreen -> SetVisibility(true);
  //darkGreen -> SetForceSolid(true);
        
  darkOrange3 = new G4VisAttributes( G4Colour(205/255. , 102/255. ,  000/255. ));
  darkOrange3 -> SetVisibility(true);
  //darkOrange3 -> SetForceSolid(true);
    
  skyBlue = new G4VisAttributes( G4Colour(135/255. , 206/255. ,  235/255. ));
  skyBlue -> SetVisibility(true);
  //skyBlue -> SetForceSolid(true);

  

  // Geometry FINAL COLLIMATOR DEFAULTS

  G4double defaultOuterRadiusFinalCollimatorIORT = 45. *mm;
  OuterRadiusFinalCollimatorIORT = defaultOuterRadiusFinalCollimatorIORT;

  G4double defaultinnerRadiusFinalCollimatorIORT = 40. *mm;
  innerRadiusFinalCollimatorIORT = defaultinnerRadiusFinalCollimatorIORT;

  // DEFAULT DEFINITION OF THE MATERIALS
  // All elements and compound definition follows the NIST database
 
  // ELEMENTS
  G4bool isotopes = false;
  G4Material* aluminumNist = G4NistManager::Instance()->FindOrBuildMaterial("G4_Al", isotopes);
  //G4Material* tantalumNist = G4NistManager::Instance()->FindOrBuildMaterial("G4_Ta", isotopes); 
  //G4Material* copperNistAsMaterial = G4NistManager::Instance()->FindOrBuildMaterial("G4_Cu", isotopes);
  G4Element* zincNist = G4NistManager::Instance()->FindOrBuildElement("Zn");
  G4Element* copperNist = G4NistManager::Instance()->FindOrBuildElement("Cu");

  // COMPOUND
  G4Material* airNist =  G4NistManager::Instance()->FindOrBuildMaterial("G4_AIR", isotopes);
  //G4Material* kaptonNist = G4NistManager::Instance()->FindOrBuildMaterial("G4_KAPTON", isotopes);
  G4Material* galacticNist = G4NistManager::Instance()->FindOrBuildMaterial("G4_Galactic", isotopes);
  G4Material* PMMANist = G4NistManager::Instance()->FindOrBuildMaterial("G4_PLEXIGLASS", isotopes);
  //G4Material* mylarNist = G4NistManager::Instance()->FindOrBuildMaterial("G4_MYLAR", isotopes);
  G4Material* titanioNist = G4NistManager::Instance()->FindOrBuildMaterial("G4_Ti", isotopes); 
  
  
  G4double d; // Density
  G4int nComponents;// Number of components 
  G4double fractionmass; // Fraction in mass of an element in a material

  d = 8.40*g/cm3;   // brass 
  nComponents = 2;
  G4Material* brass = new G4Material("Brass", d, nComponents);  
  brass -> AddElement(zincNist, fractionmass = 30 *perCent);
  brass -> AddElement(copperNist, fractionmass = 70 *perCent);

 
  // MATERIAL ASSIGNMENT


// Material of the FINAL COLLIMATOR IORT
  finalCollimatorMaterialIORT = PMMANist;

 // Junction 1 FINAL COLLIMATOR IORT
  Giunz1FinalCollMaterialIORT = PMMANist;

 // Junction 2 FINAL COLLIMATOR IORT
  Giunz2FinalCollMaterialIORT = PMMANist;
 
 // Junction 3 FINAL COLLIMATOR IORT
  Giunz3FinalCollMaterialIORT = PMMANist;
 
 // Junction 3 FINAL COLLIMATOR Int IORT
  Giunz3FinalCollMaterialIntIORT = airNist;

 // Junction 4 FINAL COLLIMATOR IORT
  Giunz4FinalCollMaterialIORT = PMMANist;

 // Junction 5 FINAL COLLIMATOR IORT
  Giunz5FinalCollMaterialIORT = PMMANist;

 // Block 1 Diameter 30 mm 
  Blocco1IORTMaterialIORT = PMMANist; 

 // Block 2 Diameter 30 mm 
  Blocco2IORTMaterialIORT = PMMANist; 

 // Block 3 Diameter 30 mm 
  Blocco3IORTMaterialIORT = PMMANist;

 // Block Diameter 20 mm 
  Blocco20mmIORTMaterialIORT = PMMANist;

 // First Monitor Chamber Lamina Al 1 of 2  
    CM1_1_2IORTMaterialIORT = aluminumNist;

 // First Monitor Chamber Lamina Al 2 of 2  
    CM1_2_2IORTMaterialIORT = aluminumNist;

 // Second Monitor Chamber Lamina Al 1 of 2  
    CM2_1_2IORTMaterialIORT = aluminumNist;

 // Second Monitor Chamber Lamina Al 2 of 2  
    CM2_2_2IORTMaterialIORT = aluminumNist;
    
 // Monitor Chamber Cylinder 
    CCMIORTMaterialIORT = PMMANist;

 // Superior Final Part Monitor Chambers
    PFS1IORTMaterialIORT = PMMANist;

 // Superior Final Part Monitor Chambers
    PFS2IORTMaterialIORT = PMMANist;

 // Superior Final Part Monitor Chambers
    PFS3IORTMaterialIORT = PMMANist;

 // Superior Final Part Monitor Chambers Material
    FTIORTMaterialIORT = titanioNist;

 // Vacuum Source
    VSIORTMaterialIORT = galacticNist;

}

Here is the call graph for this function:

Here is the caller graph for this function:

SetInnerRadiusFinalCollimatorIORT()

void Collimator80BeamLine::SetInnerRadiusFinalCollimatorIORT

(

G4double

value

)

Definition at line 960 of file Collimator80BeamLine.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:

SetOuterRadiusFinalCollimatorIORT()

void Collimator80BeamLine::SetOuterRadiusFinalCollimatorIORT

(

G4double

value

)

Definition at line 971 of file Collimator80BeamLine.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:

Member Data Documentation

Blocco1IORTMaterialIORT

G4Material* Collimator80BeamLine::Blocco1IORTMaterialIORT

private

Definition at line 150 of file Collimator80BeamLine.hh.

Blocco20mmIORTMaterialIORT

G4Material* Collimator80BeamLine::Blocco20mmIORTMaterialIORT

private

Definition at line 165 of file Collimator80BeamLine.hh.

Blocco2IORTMaterialIORT

G4Material* Collimator80BeamLine::Blocco2IORTMaterialIORT

private

Definition at line 155 of file Collimator80BeamLine.hh.

Blocco3IORTMaterialIORT

G4Material* Collimator80BeamLine::Blocco3IORTMaterialIORT

private

Definition at line 160 of file Collimator80BeamLine.hh.

blue

G4VisAttributes* Collimator80BeamLine::blue

private

Definition at line 101 of file Collimator80BeamLine.hh.

CCMIORTMaterialIORT

G4Material* Collimator80BeamLine::CCMIORTMaterialIORT

private

Definition at line 190 of file Collimator80BeamLine.hh.

CM1_1_2IORTMaterialIORT

G4Material* Collimator80BeamLine::CM1_1_2IORTMaterialIORT

private

Definition at line 170 of file Collimator80BeamLine.hh.

CM1_2_2IORTMaterialIORT

G4Material* Collimator80BeamLine::CM1_2_2IORTMaterialIORT

private

Definition at line 175 of file Collimator80BeamLine.hh.

CM2_1_2IORTMaterialIORT

G4Material* Collimator80BeamLine::CM2_1_2IORTMaterialIORT

private

Definition at line 180 of file Collimator80BeamLine.hh.

CM2_2_2IORTMaterialIORT

G4Material* Collimator80BeamLine::CM2_2_2IORTMaterialIORT

private

Definition at line 185 of file Collimator80BeamLine.hh.

collimatorMessenger

Collimator80BeamLineMessenger* Collimator80BeamLine::collimatorMessenger

private

Definition at line 97 of file Collimator80BeamLine.hh.

darkGreen

G4VisAttributes* Collimator80BeamLine::darkGreen

private

Definition at line 107 of file Collimator80BeamLine.hh.

darkOrange3

G4VisAttributes* Collimator80BeamLine::darkOrange3

private

Definition at line 108 of file Collimator80BeamLine.hh.

finalCollimatorMaterialIORT

G4Material* Collimator80BeamLine::finalCollimatorMaterialIORT

private

Definition at line 115 of file Collimator80BeamLine.hh.

FTIORTMaterialIORT

G4Material* Collimator80BeamLine::FTIORTMaterialIORT

private

Definition at line 210 of file Collimator80BeamLine.hh.

Giunz1FinalCollMaterialIORT

G4Material* Collimator80BeamLine::Giunz1FinalCollMaterialIORT

private

Definition at line 120 of file Collimator80BeamLine.hh.

Giunz2FinalCollMaterialIORT

G4Material* Collimator80BeamLine::Giunz2FinalCollMaterialIORT

private

Definition at line 125 of file Collimator80BeamLine.hh.

Giunz3FinalCollMaterialIntIORT

G4Material* Collimator80BeamLine::Giunz3FinalCollMaterialIntIORT

private

Definition at line 134 of file Collimator80BeamLine.hh.

Giunz3FinalCollMaterialIORT

G4Material* Collimator80BeamLine::Giunz3FinalCollMaterialIORT

private

Definition at line 130 of file Collimator80BeamLine.hh.

Giunz4FinalCollMaterialIORT

G4Material* Collimator80BeamLine::Giunz4FinalCollMaterialIORT

private

Definition at line 140 of file Collimator80BeamLine.hh.

Giunz5FinalCollMaterialIORT

G4Material* Collimator80BeamLine::Giunz5FinalCollMaterialIORT

private

Definition at line 145 of file Collimator80BeamLine.hh.

gray

G4VisAttributes* Collimator80BeamLine::gray

private

Definition at line 102 of file Collimator80BeamLine.hh.

green

G4VisAttributes* Collimator80BeamLine::green

private

Definition at line 106 of file Collimator80BeamLine.hh.

innerRadiusFinalCollimatorIORT

G4double Collimator80BeamLine::innerRadiusFinalCollimatorIORT

private

Definition at line 112 of file Collimator80BeamLine.hh.

iortDetectorConstruction

IORTDetectorConstruction* Collimator80BeamLine::iortDetectorConstruction

private

Definition at line 99 of file Collimator80BeamLine.hh.

OuterRadiusFinalCollimatorIORT

G4double Collimator80BeamLine::OuterRadiusFinalCollimatorIORT

private

Definition at line 112 of file Collimator80BeamLine.hh.

PFS1IORTMaterialIORT

G4Material* Collimator80BeamLine::PFS1IORTMaterialIORT

private

Definition at line 195 of file Collimator80BeamLine.hh.

PFS2IORTMaterialIORT

G4Material* Collimator80BeamLine::PFS2IORTMaterialIORT

private

Definition at line 200 of file Collimator80BeamLine.hh.

PFS3IORTMaterialIORT

G4Material* Collimator80BeamLine::PFS3IORTMaterialIORT

private

Definition at line 205 of file Collimator80BeamLine.hh.

physiBlocco1IORT

G4VPhysicalVolume* Collimator80BeamLine::physiBlocco1IORT

private

Definition at line 149 of file Collimator80BeamLine.hh.

physiBlocco20mmIORT

G4VPhysicalVolume* Collimator80BeamLine::physiBlocco20mmIORT

private

Definition at line 164 of file Collimator80BeamLine.hh.

physiBlocco2IORT

G4VPhysicalVolume* Collimator80BeamLine::physiBlocco2IORT

private

Definition at line 154 of file Collimator80BeamLine.hh.

physiBlocco3IORT

G4VPhysicalVolume* Collimator80BeamLine::physiBlocco3IORT

private

Definition at line 159 of file Collimator80BeamLine.hh.

physicalTreatmentRoom

G4VPhysicalVolume* Collimator80BeamLine::physicalTreatmentRoom

private

Definition at line 98 of file Collimator80BeamLine.hh.

physiCCMIORT

G4VPhysicalVolume* Collimator80BeamLine::physiCCMIORT

private

Definition at line 189 of file Collimator80BeamLine.hh.

physiCM1_1_2IORT

G4VPhysicalVolume* Collimator80BeamLine::physiCM1_1_2IORT

private

Definition at line 169 of file Collimator80BeamLine.hh.

physiCM1_2_2IORT

G4VPhysicalVolume* Collimator80BeamLine::physiCM1_2_2IORT

private

Definition at line 174 of file Collimator80BeamLine.hh.

physiCM2_1_2IORT

G4VPhysicalVolume* Collimator80BeamLine::physiCM2_1_2IORT

private

Definition at line 179 of file Collimator80BeamLine.hh.

physiCM2_2_2IORT

G4VPhysicalVolume* Collimator80BeamLine::physiCM2_2_2IORT

private

Definition at line 184 of file Collimator80BeamLine.hh.

physiFinalCollimatorIORT

G4VPhysicalVolume* Collimator80BeamLine::physiFinalCollimatorIORT

private

Definition at line 114 of file Collimator80BeamLine.hh.

physiFTIORT

G4VPhysicalVolume* Collimator80BeamLine::physiFTIORT

private

Definition at line 209 of file Collimator80BeamLine.hh.

physiGiunz1FinalCollIORT

G4VPhysicalVolume* Collimator80BeamLine::physiGiunz1FinalCollIORT

private

Definition at line 119 of file Collimator80BeamLine.hh.

physiGiunz2FinalCollIORT

G4VPhysicalVolume* Collimator80BeamLine::physiGiunz2FinalCollIORT

private

Definition at line 124 of file Collimator80BeamLine.hh.

physiGiunz3FinalCollIntIORT

G4VPhysicalVolume* Collimator80BeamLine::physiGiunz3FinalCollIntIORT

private

Definition at line 135 of file Collimator80BeamLine.hh.

physiGiunz3FinalCollIORT

G4VPhysicalVolume* Collimator80BeamLine::physiGiunz3FinalCollIORT

private

Definition at line 129 of file Collimator80BeamLine.hh.

physiGiunz4FinalCollIORT

G4VPhysicalVolume* Collimator80BeamLine::physiGiunz4FinalCollIORT

private

Definition at line 139 of file Collimator80BeamLine.hh.

physiGiunz5FinalCollIORT

G4VPhysicalVolume* Collimator80BeamLine::physiGiunz5FinalCollIORT

private

Definition at line 144 of file Collimator80BeamLine.hh.

physiPFS1IORT

G4VPhysicalVolume* Collimator80BeamLine::physiPFS1IORT

private

Definition at line 194 of file Collimator80BeamLine.hh.

physiPFS2IORT

G4VPhysicalVolume* Collimator80BeamLine::physiPFS2IORT

private

Definition at line 199 of file Collimator80BeamLine.hh.

physiPFS3IORT

G4VPhysicalVolume* Collimator80BeamLine::physiPFS3IORT

private

Definition at line 204 of file Collimator80BeamLine.hh.

physiVSIORT

G4VPhysicalVolume* Collimator80BeamLine::physiVSIORT

private

Definition at line 214 of file Collimator80BeamLine.hh.

red

G4VisAttributes* Collimator80BeamLine::red

private

Definition at line 104 of file Collimator80BeamLine.hh.

skyBlue

G4VisAttributes* Collimator80BeamLine::skyBlue

private

Definition at line 109 of file Collimator80BeamLine.hh.

solidBlocco1IORT

G4Tubs* Collimator80BeamLine::solidBlocco1IORT

private

Definition at line 148 of file Collimator80BeamLine.hh.

solidBlocco20mmIORT

G4Tubs* Collimator80BeamLine::solidBlocco20mmIORT

private

Definition at line 163 of file Collimator80BeamLine.hh.

solidBlocco2IORT

G4Tubs* Collimator80BeamLine::solidBlocco2IORT

private

Definition at line 153 of file Collimator80BeamLine.hh.

solidBlocco3IORT

G4Tubs* Collimator80BeamLine::solidBlocco3IORT

private

Definition at line 158 of file Collimator80BeamLine.hh.

solidCCMIORT

G4Tubs* Collimator80BeamLine::solidCCMIORT

private

Definition at line 188 of file Collimator80BeamLine.hh.

solidCM1_1_2IORT

G4Tubs* Collimator80BeamLine::solidCM1_1_2IORT

private

Definition at line 168 of file Collimator80BeamLine.hh.

solidCM1_2_2IORT

G4Tubs* Collimator80BeamLine::solidCM1_2_2IORT

private

Definition at line 173 of file Collimator80BeamLine.hh.

solidCM2_1_2IORT

G4Tubs* Collimator80BeamLine::solidCM2_1_2IORT

private

Definition at line 178 of file Collimator80BeamLine.hh.

solidCM2_2_2IORT

G4Tubs* Collimator80BeamLine::solidCM2_2_2IORT

private

Definition at line 183 of file Collimator80BeamLine.hh.

solidFinalCollimatorIORT

G4Tubs* Collimator80BeamLine::solidFinalCollimatorIORT

private

Definition at line 113 of file Collimator80BeamLine.hh.

solidFTIORT

G4Tubs* Collimator80BeamLine::solidFTIORT

private

Definition at line 208 of file Collimator80BeamLine.hh.

solidGiunz1FinalCollIORT

G4Tubs* Collimator80BeamLine::solidGiunz1FinalCollIORT

private

Definition at line 118 of file Collimator80BeamLine.hh.

solidGiunz2FinalCollIORT

G4Tubs* Collimator80BeamLine::solidGiunz2FinalCollIORT

private

Definition at line 123 of file Collimator80BeamLine.hh.

solidGiunz3FinalCollIntIORT

G4Cons* Collimator80BeamLine::solidGiunz3FinalCollIntIORT

private

Definition at line 133 of file Collimator80BeamLine.hh.

solidGiunz3FinalCollIORT

G4Tubs* Collimator80BeamLine::solidGiunz3FinalCollIORT

private

Definition at line 128 of file Collimator80BeamLine.hh.

solidGiunz4FinalCollIORT

G4Tubs* Collimator80BeamLine::solidGiunz4FinalCollIORT

private

Definition at line 138 of file Collimator80BeamLine.hh.

solidGiunz5FinalCollIORT

G4Tubs* Collimator80BeamLine::solidGiunz5FinalCollIORT

private

Definition at line 143 of file Collimator80BeamLine.hh.

solidPFS1IORT

G4Tubs* Collimator80BeamLine::solidPFS1IORT

private

Definition at line 193 of file Collimator80BeamLine.hh.

solidPFS2IORT

G4Tubs* Collimator80BeamLine::solidPFS2IORT

private

Definition at line 198 of file Collimator80BeamLine.hh.

solidPFS3IORT

G4Tubs* Collimator80BeamLine::solidPFS3IORT

private

Definition at line 203 of file Collimator80BeamLine.hh.

solidVSIORT

G4Tubs* Collimator80BeamLine::solidVSIORT

private

Definition at line 213 of file Collimator80BeamLine.hh.

VSIORTMaterialIORT

G4Material* Collimator80BeamLine::VSIORTMaterialIORT

private

Definition at line 215 of file Collimator80BeamLine.hh.

white

G4VisAttributes* Collimator80BeamLine::white

private

Definition at line 103 of file Collimator80BeamLine.hh.

yellow

G4VisAttributes* Collimator80BeamLine::yellow

private

Definition at line 105 of file Collimator80BeamLine.hh.

---

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

• Collimator80BeamLine.hh
• Collimator80BeamLine.cc