eFLASH_radiotherapy/src/FlashApplicator.cc

0001 //
0002 // ********************************************************************
0003 // * License and Disclaimer                                           *
0004 // *                                                                  *
0005 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
0006 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
0007 // * conditions of the Geant4 Software License,  included in the file *
0008 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
0009 // * include a list of copyright holders.                             *
0010 // *                                                                  *
0011 // * Neither the authors of this software system, nor their employing *
0012 // * institutes,nor the agencies providing financial support for this *
0013 // * work  make  any representation or  warranty, express or implied, *
0014 // * regarding  this  software system or assume any liability for its *
0015 // * use.  Please see the license in the file  LICENSE  and URL above *
0016 // * for the full disclaimer and the limitation of liability.         *
0017 // *                                                                  *
0018 // * This  code  implementation is the result of  the  scientific and *
0019 // * technical work of the GEANT4 collaboration.                      *
0020 // * By using,  copying,  modifying or  distributing the software (or *
0021 // * any work based  on the software)  you  agree  to acknowledge its *
0022 // * use  in  resulting  scientific  publications,  and indicate your *
0023 // * acceptance of all terms of the Geant4 Software license.          *
0024 // ********************************************************************
0025 //
0026 // This is the first version of Flash, a Geant4-based application
0027 //
0028 //
0029 //////////////////////////////////////////////////////////////////////////////////////////////
0030
0031 #include "FlashApplicator.hh"
0032 #include "FlashDetectorConstruction.hh"
0033 #include "G4Box.hh"
0034 #include "G4Colour.hh"
0035 #include "G4Cons.hh"
0036 #include "G4LogicalVolume.hh"
0037 #include "G4NistElementBuilder.hh"
0038 #include "G4NistManager.hh"
0039 #include "G4PVPlacement.hh"
0040 #include "G4RotationMatrix.hh"
0041 #include "G4RunManager.hh"
0042 #include "G4SubtractionSolid.hh"
0043 #include "G4SystemOfUnits.hh"
0044 #include "G4Tubs.hh"
0045 #include "G4VisAttributes.hh"
0046 #include "globals.hh"
0047
0048 FlashApplicator::FlashApplicator(G4VPhysicalVolume *physicalTreatmentRoom)
0049     : fMotherPhys(physicalTreatmentRoom),
0050
0051
0052       solidFTFlash(0), physiFTFlash(0) {
0053   ConstructCollimator(fMotherPhys);
0054
0055
0056
0057 }
0058
0059 FlashApplicator::~FlashApplicator() {}
0060
0061 void FlashApplicator::ConstructCollimator(G4VPhysicalVolume *) {
0062   // Sets default geometry and materials
0063   SetDefaultDimensions();
0064
0065   // DEFAULT APPLICATOR LENGTH AND RADIUS - UNIFORM FLASH CONFIGURATION
0066   SetOuterRadius(55*mm);
0067   SetApplicatorLength(365*mm);
0068
0069   //SET THE FOLLOWING APPLICATOR RADIUS AND LENGTH FOR MINIBEAM CONFIGURATION
0070
0071   // SetOuterRadius(25*mm);
0072   // SetApplicatorLength(173.5*mm);
0073
0074   // Construct the whole Applicator Beam Line
0075   ConstructApplicator();
0076 }
0077
0078 void FlashApplicator::SetDefaultDimensions() {
0079
0080   white = new G4VisAttributes(G4Colour());
0081   white->SetVisibility(true);
0082
0083   blue = new G4VisAttributes(G4Colour(0., 0., 1.));
0084   blue->SetVisibility(true);
0085
0086   gray = new G4VisAttributes(G4Colour(0.5, 0.5, 0.5));
0087   gray->SetVisibility(true);
0088
0089   red = new G4VisAttributes(G4Colour(1., 0., 0.));
0090   red->SetVisibility(true);
0091
0092   yellow = new G4VisAttributes(G4Colour(1., 1., 0.));
0093   yellow->SetVisibility(true);
0094
0095   green = new G4VisAttributes(G4Colour(25 / 255., 255 / 255., 25 / 255.));
0096   green->SetVisibility(true);
0097
0098   darkGreen = new G4VisAttributes(G4Colour(0 / 255., 100 / 255., 0 / 255.));
0099   darkGreen->SetVisibility(true);
0100
0101   darkOrange3 =
0102       new G4VisAttributes(G4Colour(205 / 255., 102 / 255., 000 / 255.));
0103   darkOrange3->SetVisibility(true);
0104
0105   skyBlue = new G4VisAttributes(G4Colour(135 / 255., 206 / 255., 235 / 255.));
0106   skyBlue->SetVisibility(true);
0107
0108   magenta = new G4VisAttributes(G4Colour(255 / 255., 0 / 255., 255 / 255.));
0109   magenta->SetVisibility(true);
0110
0111
0112   fInitial_pos = -113*cm; //set the same position in FlashPrimaryGeneratorAction.cc for DEFAULT CONFIGURATION - 100 MM DIAMETER APPLICATOR
0113   // fInitial_pos=-74.70005*cm; ////// Set this for MINIBEAM configuration
0114   // Geometry  APPLICATOR DEFAULTS
0115
0116
0117
0118   G4double defaultinnerRadiusFirstApplicatorFlash =
0119       fOuterRadiusFirstApplicatorFlash - 5. * mm;
0120    fInnerRadiusFirstApplicatorFlash = defaultinnerRadiusFirstApplicatorFlash;
0121
0122   // DEFAULT DEFINITION OF THE MATERIALS
0123
0124   // ELEMENTS
0125   G4double density;
0126   G4int ncomponents;
0127   G4bool isotopes = false;
0128   aluminumNist =
0129       G4NistManager::Instance()->FindOrBuildMaterial("G4_Al", isotopes);
0130
0131
0132   Fe = G4NistManager::Instance()->FindOrBuildMaterial("G4_Fe");
0133
0134   PVDF = new G4Material("PVDF",  density=1780 *kg/m3,  ncomponents=3);
0135
0136
0137
0138   PVDF->AddElement(G4NistManager::Instance()->FindOrBuildElement("C"), 34 * perCent);
0139   PVDF->AddElement(G4NistManager::Instance()->FindOrBuildElement("H"), 33 * perCent);
0140   PVDF->AddElement(G4NistManager::Instance()->FindOrBuildElement("F"), 33 * perCent);
0141
0142
0143
0144   FILM= new G4Material("FILM", density=1430 *kg/m3, ncomponents = 4);
0145
0146   FILM->AddElement(G4NistManager::Instance()->FindOrBuildElement("C"), 69 * perCent);
0147   FILM->AddElement(G4NistManager::Instance()->FindOrBuildElement("H"), 3 * perCent);
0148   FILM->AddElement(G4NistManager::Instance()->FindOrBuildElement("N"), 7 * perCent);
0149   FILM->AddElement(G4NistManager::Instance()->FindOrBuildElement("O"), 21 * perCent);
0150
0151
0152
0153
0154   G4Material *galacticNist =
0155       G4NistManager::Instance()->FindOrBuildMaterial("G4_Galactic", isotopes);
0156   PMMA =
0157       G4NistManager::Instance()->FindOrBuildMaterial("G4_PLEXIGLASS", isotopes);
0158
0159   G4Material *titanioNist =
0160       G4NistManager::Instance()->FindOrBuildMaterial("G4_Ti", isotopes);
0161
0162
0163   // MATERIAL ASSIGNMENT
0164
0165   // Material of the APPLICATOR Flash
0166   fFirstApplicatorMaterialFlash = PMMA;
0167
0168   // Titanium window
0169   FTFlashMaterialFlash = titanioNist;
0170
0171   // Vacuum Source
0172   VSFlashMaterialFlash = galacticNist;
0173 }
0174
0175 void FlashApplicator::ConstructApplicator() {
0176
0177   // Components of the Applicator
0178
0179   FlashBeamLineVacuumSource();
0180   FlashBeamLineTitaniumWindows();
0181   FlashVWAlcover();
0182   FlashAlCover2();
0183   FlashExitBit();
0184   FlashToroid();
0185   OverCover();
0186
0187   MonitorChamber();
0188   Flash_connector();
0189   Bigconnector();
0190   Bigconnector2();
0191   FlashBeamLineApplicator();//modify this function for applicator lenght
0192
0193
0194
0195 }
0196
0197 void FlashApplicator::FlashBeamLineVacuumSource() {
0198   // ---------------------------------------------------------------//
0199   //                     Vacuum Source                             //
0200   // ---------------------------------------------------------------//
0201
0202   G4double phi1 = 90. * deg;
0203
0204   G4RotationMatrix rm1;
0205   rm1.rotateY(phi1);
0206
0207   fOutRadiusVSFlash = 20 * mm;
0208   const G4double innRadiusVSFlash = 0. * mm;
0209    fHightVSFlash = 8 * mm;
0210   const G4double startAngleVSFlash = 0. * deg;
0211   const G4double spanningAngleVSFlash = 360. * deg;
0212   fXPositionVSFlash = fInitial_pos-fHightVSFlash-0.055/2*mm; //0.055 is titanium window
0213
0214   solidVSFlash =
0215       new G4Tubs("VSFlash", innRadiusVSFlash, fOutRadiusVSFlash, fHightVSFlash,
0216                  startAngleVSFlash, spanningAngleVSFlash);
0217
0218   G4LogicalVolume *logVSFlash = new G4LogicalVolume(
0219       solidVSFlash, VSFlashMaterialFlash, "VSFlash", 0, 0, 0);
0220
0221   physiVSFlash = new G4PVPlacement(
0222       G4Transform3D(rm1, G4ThreeVector((fXPositionVSFlash), 0., 0.)), "VSFlash",
0223       logVSFlash, fMotherPhys, false, 0);
0224
0225   logVSFlash->SetVisAttributes(green);
0226 }
0227
0228 void FlashApplicator::FlashBeamLineTitaniumWindows() {
0229   // ---------------------------------------------------------------//
0230   //                     Titanium Window                        //
0231   // ---------------------------------------------------------------//
0232   // with just this piece ssd=1.6cm
0233   G4double phi2 = 90. * deg;
0234
0235   G4RotationMatrix rm2;
0236   rm2.rotateY(phi2);
0237
0238    fOutRadiusFTFlash = fOutRadiusVSFlash;
0239   const G4double innRadiusFTFlash = 19 * mm;
0240    fHightFTFlash = 0.055/2 * mm;
0241   const G4double startAngleFTFlash = 0. * deg;
0242   const G4double spanningAngleFTFlash = 360. * deg;
0243   const G4double XPositionFTFlash = fInitial_pos ;
0244
0245   solidFTFlash =
0246       new G4Tubs("FTFlash", innRadiusFTFlash, fOutRadiusFTFlash, fHightFTFlash,
0247                  startAngleFTFlash, spanningAngleFTFlash);
0248
0249   G4LogicalVolume *logFTFlash = new G4LogicalVolume(
0250       solidFTFlash, FTFlashMaterialFlash, "FTFlash", 0, 0, 0);
0251
0252   physiFTFlash = new G4PVPlacement(
0253       G4Transform3D(rm2, G4ThreeVector((XPositionFTFlash), 0., 0.)), "FTFlash",
0254       logFTFlash, fMotherPhys, false, 0);
0255
0256   logFTFlash->SetVisAttributes(yellow);
0257 }
0258 void FlashApplicator::FlashVWAlcover(){
0259
0260  G4double phi2 = 90. * deg;
0261
0262   G4RotationMatrix rm2;
0263   rm2.rotateY(phi2);
0264
0265
0266   const G4double innRadius = fOutRadiusVSFlash;
0267     fOutRadius = innRadius+8*mm;
0268   const G4double hight = fHightVSFlash;
0269   const G4double startAngle = 0. * deg;
0270   const G4double spanningAngle = 360. * deg;
0271   const G4double XPosition = fXPositionVSFlash ;
0272
0273    G4VSolid * solid =
0274       new G4Tubs("cover1", innRadius, fOutRadius, hight,
0275                  startAngle, spanningAngle);
0276
0277   G4LogicalVolume *log = new G4LogicalVolume(
0278       solid, aluminumNist, "cover1log", 0, 0, 0);
0279
0280  new G4PVPlacement(
0281       G4Transform3D(rm2, G4ThreeVector((XPosition), 0., 0.)), "cover1phys",
0282       log, fMotherPhys, false, 0);
0283
0284   log->SetVisAttributes(white);
0285
0286
0287 }
0288 void FlashApplicator::FlashAlCover2(){
0289
0290 G4double phi2 = 90. * deg;
0291
0292   G4RotationMatrix rm2;
0293   rm2.rotateY(phi2);
0294
0295
0296   const G4double innRadius = fOutRadiusVSFlash;
0297
0298   const G4double hight = fHightVSFlash+fHightFTFlash;
0299   const G4double startAngle = 0. * deg;
0300   const G4double spanningAngle = 360. * deg;
0301   const G4double XPosition = fInitial_pos+hight+fHightFTFlash;
0302
0303    G4VSolid * solid =
0304       new G4Tubs("cover1", innRadius, fOutRadius, hight,
0305                  startAngle, spanningAngle);
0306
0307   G4LogicalVolume *log = new G4LogicalVolume(
0308       solid, aluminumNist, "cover1log", 0, 0, 0);
0309
0310 new G4PVPlacement(
0311       G4Transform3D(rm2, G4ThreeVector((XPosition), 0., 0.)), "cover1phys",
0312       log, fMotherPhys, false, 0);
0313
0314   log->SetVisAttributes(red);
0315
0316   fInitial_pos=fInitial_pos + fHightFTFlash;
0317 }
0318 void FlashApplicator::FlashExitBit(){
0319
0320 G4double phi2 = 90. * deg;
0321
0322   G4RotationMatrix rm2;
0323   rm2.rotateY(phi2);
0324
0325
0326   const G4double innRadius = 0*mm;
0327   fOutRadius = fOutRadiusVSFlash;
0328   const G4double hight = 16/2*mm;
0329   const G4double startAngle = 0. * deg;
0330   const G4double spanningAngle = 360. * deg;
0331   const G4double XPosition = fInitial_pos+hight;
0332
0333
0334     G4VSolid *t1 = new G4Tubs("t1", innRadius, fOutRadius, hight,
0335                  startAngle, spanningAngle);
0336
0337     G4VSolid *t2 = new G4Cons("t2", 0*mm,13/2*mm, 0*mm,38/2*mm,16.1/2*mm, startAngle,spanningAngle);
0338
0339     G4RotationMatrix rotm_t2 = G4RotationMatrix();
0340     rotm_t2.rotateX(0 * deg);
0341     G4ThreeVector zTrans(0, 0, 0);
0342
0343     G4SubtractionSolid *hollowcover =
0344         new G4SubtractionSolid("hollowcover_log", t1, t2, 0, zTrans);
0345
0346
0347     G4LogicalVolume *logic =
0348         new G4LogicalVolume(hollowcover, aluminumNist, "hollowcover", 0, 0, 0);
0349
0350     new G4PVPlacement(
0351       G4Transform3D(rm2, G4ThreeVector((XPosition), 0., 0.)), "cover1phys",
0352       logic, fMotherPhys, false, 0);
0353
0354   logic->SetVisAttributes(darkOrange3);
0355 fInitial_pos=XPosition+hight;
0356 }
0357 void FlashApplicator::FlashToroid(){
0358
0359 G4double phi2 = 90. * deg;
0360
0361   G4RotationMatrix rm2;
0362   rm2.rotateY(phi2);
0363
0364
0365   const G4double innRadius = 50.8/2*mm;
0366  fToroid_outRadius = innRadius + 45*mm;
0367   fToroid_hight = 50.8/2*mm;
0368   const G4double startAngle = 0. * deg;
0369   const G4double spanningAngle = 360. * deg;
0370   fToroid_XPosition = fInitial_pos+fToroid_hight + 8*mm;
0371
0372    G4VSolid * solid =
0373       new G4Tubs("toroid", innRadius, fToroid_outRadius, fToroid_hight,
0374                  startAngle, spanningAngle);
0375
0376   G4LogicalVolume *log = new G4LogicalVolume(
0377       solid, Fe, "toroidlog", 0, 0, 0);
0378
0379   new G4PVPlacement(
0380       G4Transform3D(rm2, G4ThreeVector((fToroid_XPosition), 0., 0.)), "toroidphys",
0381       log, fMotherPhys, false, 0);
0382
0383   log->SetVisAttributes(blue);
0384
0385 fInitial_pos=fToroid_XPosition+fToroid_hight;
0386 }
0387 void FlashApplicator::OverCover(){
0388
0389 G4double phi2 = 90. * deg;
0390
0391   G4RotationMatrix rm2;
0392   rm2.rotateY(phi2);
0393
0394
0395   const G4double innRadius = fOutRadius;
0396   const G4double out_Radius = 5*fOutRadius ;
0397   fBigcover_hight = 7.5*mm;
0398   const G4double startAngle = 0. * deg;
0399   const G4double spanningAngle = 360. * deg;
0400    fBigcover_XPosition = fXPositionVSFlash - fHightVSFlash+fBigcover_hight;
0401
0402    G4VSolid * solid =
0403       new G4Tubs("coverbig", innRadius, out_Radius, fBigcover_hight,
0404                  startAngle, spanningAngle);
0405
0406   G4LogicalVolume *log = new G4LogicalVolume(
0407       solid, aluminumNist, "coverbig_log", 0, 0, 0);
0408
0409   new G4PVPlacement(
0410       G4Transform3D(rm2, G4ThreeVector((fBigcover_XPosition), 0., 0.)), "coverbig_phys",
0411       log, fMotherPhys, false, 0);
0412
0413   log->SetVisAttributes(skyBlue);
0414
0415
0416   const G4double innRadius_2 = fToroid_outRadius;
0417   const G4double out_Radius_2 = innRadius_2 + 1.2*cm ;
0418   const G4double fBigcover_hight_2 = 30*mm;
0419   const G4double startAngle_2 = 0. * deg;
0420   const G4double spanningAngle_2 = 360. * deg;
0421    const double fBigcover_XPosition_2 = fBigcover_XPosition+fBigcover_hight_2+fBigcover_hight;
0422
0423    G4VSolid * solid_2 =
0424       new G4Tubs("coverbig_2", innRadius_2, out_Radius_2, fBigcover_hight_2,
0425                  startAngle_2, spanningAngle_2);
0426
0427   G4LogicalVolume *log_2 = new G4LogicalVolume(
0428       solid_2, aluminumNist, "coverbig_log", 0, 0, 0);
0429
0430   new G4PVPlacement(
0431       G4Transform3D(rm2, G4ThreeVector((fBigcover_XPosition_2), 0., 0.)), "coverbig_phys",
0432       log_2, fMotherPhys, false, 0);
0433
0434   log_2->SetVisAttributes(green);
0435
0436
0437 }
0438
0439 void FlashApplicator::OverCover2() {
0440
0441 G4double phi2 = 90. * deg;
0442
0443   G4RotationMatrix rm2;
0444   rm2.rotateY(phi2);
0445
0446
0447   const G4double innRadius = fToroid_outRadius;
0448   const G4double out_Radius = innRadius+40*mm ;
0449   const G4double hight = 34*mm;
0450   const G4double startAngle = 0. * deg;
0451   const G4double spanningAngle = 360. * deg;
0452   const G4double XPosition = fBigcover_XPosition+fBigcover_hight+hight;
0453
0454    G4VSolid * solid =
0455       new G4Tubs("coverbig", innRadius, out_Radius, hight,
0456                  startAngle, spanningAngle);
0457
0458   G4LogicalVolume *log = new G4LogicalVolume(
0459       solid, aluminumNist, "coverbig_log", 0, 0, 0);
0460
0461 new G4PVPlacement(
0462       G4Transform3D(rm2, G4ThreeVector((XPosition), 0., 0.)), "coverbig_phys",
0463       log, fMotherPhys, false, 0);
0464
0465   log->SetVisAttributes(yellow);
0466
0467 }
0468
0469 void FlashApplicator::MonitorChamber(){
0470
0471 G4double phi2 = 90. * deg;
0472
0473   G4RotationMatrix rm2;
0474   rm2.rotateY(phi2);
0475
0476
0477   const G4double innRadius = 20*mm;
0478   const G4double out_Radius = innRadius+1.7*mm ;
0479   const G4double hight = 3*mm;
0480   const G4double startAngle = 0. * deg;
0481   const G4double spanningAngle = 360. * deg;
0482    G4double XPosition = fInitial_pos+hight;
0483
0484    G4VSolid * solid =
0485       new G4Tubs("first", innRadius, out_Radius, hight,
0486                  startAngle, spanningAngle);
0487
0488
0489
0490 G4LogicalVolume *log = new G4LogicalVolume(
0491       solid, PVDF, "chamberfirst_log", 0, 0, 0);
0492
0493   new G4PVPlacement(
0494       G4Transform3D(rm2, G4ThreeVector((XPosition), 0., 0.)), "coverbig_phys",
0495       log, fMotherPhys, false, 0);
0496
0497   log->SetVisAttributes(red);
0498
0499   G4VSolid * solid_pvdf=
0500       new G4Tubs("s_pvdf", innRadius, out_Radius, 0.5*mm,
0501                  startAngle, spanningAngle);
0502
0503
0504       G4LogicalVolume *log_pvdf= new G4LogicalVolume(
0505       solid_pvdf, PVDF, "pvdf_log", 0, 0, 0);
0506
0507   G4VSolid * solid_film =
0508       new G4Tubs("s_film", innRadius, out_Radius, 0.05/2*mm,
0509                  startAngle, spanningAngle);
0510    G4LogicalVolume *log_film = new G4LogicalVolume(
0511       solid_film, FILM, "ka_log", 0, 0, 0);
0512
0513   G4VSolid * solid_al =
0514       new G4Tubs("s_al", innRadius, out_Radius, 0.005/2*mm,
0515                  startAngle, spanningAngle);
0516
0517   G4LogicalVolume *log_al = new G4LogicalVolume(
0518       solid_al, aluminumNist, "al_log", 0, 0, 0);
0519   XPosition=XPosition+hight;
0520
0521   G4int j=0;
0522   for(G4int i = 0;i<3;i++){
0523   XPosition=XPosition+(i+1)*0.05/2*mm;
0524   new G4PVPlacement(
0525       G4Transform3D(rm2, G4ThreeVector((XPosition), 0., 0.)), "ka_phys",
0526       log_film, fMotherPhys, false, j);
0527   XPosition=XPosition+(i+1)*0.005/2*mm;
0528   new G4PVPlacement(
0529       G4Transform3D(rm2, G4ThreeVector((XPosition), 0., 0.)), "al_phys",
0530       log_al, fMotherPhys, false, j);
0531
0532   XPosition=XPosition+(i+1)*1/2*mm;
0533   new G4PVPlacement(
0534       G4Transform3D(rm2, G4ThreeVector((XPosition), 0., 0.)), "pvdf_phys",
0535       log_pvdf, fMotherPhys, false, j);
0536
0537
0538
0539   }
0540   fChamberpos = XPosition +1/2*mm;
0541   log_film->SetVisAttributes(green);
0542     log_al->SetVisAttributes(blue);
0543       log_pvdf->SetVisAttributes(yellow);
0544
0545
0546 }
0547
0548 void FlashApplicator::Flash_connector(){
0549
0550 G4double phi2 = 90. * deg;
0551
0552   G4RotationMatrix rm2;
0553   rm2.rotateY(phi2);
0554
0555
0556   const G4double innRadius = 10*cm;
0557   const G4double out_Radius = innRadius+2.5*cm ;
0558   const G4double hight = 15*mm;
0559   const G4double startAngle = 0. * deg;
0560   const G4double spanningAngle = 360. * deg;
0561   const G4double XPosition = fChamberpos+hight;
0562
0563   G4VSolid * solid =
0564       new G4Tubs("cover", innRadius, out_Radius, hight,
0565                  startAngle, spanningAngle);
0566
0567   G4LogicalVolume *log = new G4LogicalVolume(
0568       solid, aluminumNist, "coverbig_log", 0, 0, 0);
0569
0570  new G4PVPlacement(
0571       G4Transform3D(rm2, G4ThreeVector((XPosition), 0., 0.)), "coverbig_phys",
0572       log, fMotherPhys, false, 0);
0573
0574   log->SetVisAttributes(magenta);
0575
0576
0577   G4VSolid * solid_ =
0578       new G4Tubs("littlecover", 22*mm, innRadius, 0.2*mm,
0579                  startAngle, spanningAngle);
0580   G4LogicalVolume *log_ = new G4LogicalVolume(
0581       solid_, aluminumNist, "covers_log", 0, 0, 0);
0582
0583     new G4PVPlacement(
0584       G4Transform3D(rm2, G4ThreeVector((fChamberpos+0.2*mm), 0., 0.)), "coverl_phys",
0585       log_, fMotherPhys, false, 0);
0586 log_->SetVisAttributes(green);
0587
0588 fInitial_pos=XPosition+hight;
0589 }
0590
0591 void FlashApplicator::Bigconnector() {
0592
0593 G4double phi2 = 90. * deg;
0594
0595   G4RotationMatrix rm2;
0596   rm2.rotateY(phi2);
0597
0598
0599   const G4double innRadius = 10*cm;
0600   const G4double out_Radius = innRadius+30*mm ;
0601   const G4double hight = 7.05*cm + 0.0075/2*mm;
0602   const G4double startAngle = 0. * deg;
0603   const G4double spanningAngle = 360. * deg;
0604   const G4double XPosition = fInitial_pos+hight;
0605
0606    G4VSolid * solid =
0607       new G4Tubs("coverbig", innRadius, out_Radius, hight,
0608                  startAngle, spanningAngle);
0609
0610   G4LogicalVolume *log = new G4LogicalVolume(
0611       solid, aluminumNist, "coverbig_log", 0, 0, 0);
0612
0613  new G4PVPlacement(
0614       G4Transform3D(rm2, G4ThreeVector((XPosition), 0., 0.)), "coverbig_phys",
0615       log, fMotherPhys, false, 0);
0616
0617   log->SetVisAttributes(red);
0618 fInitial_pos=XPosition+hight;
0619 }
0620 void FlashApplicator::Bigconnector2() {
0621
0622 G4double phi2 = 90. * deg;
0623
0624   G4RotationMatrix rm2;
0625   rm2.rotateY(phi2);
0626
0627
0628   const G4double innRadius = 6*cm;
0629   const G4double out_Radius = innRadius+70*mm ;
0630   const G4double hight = 4.4*cm-12/4*mm;
0631   const G4double startAngle = 0. * deg;
0632   const G4double spanningAngle = 360. * deg;
0633   const G4double XPosition = fInitial_pos+hight;
0634
0635    G4VSolid * solid =
0636       new G4Tubs("coverbig", innRadius, out_Radius, hight,
0637                  startAngle, spanningAngle);
0638
0639
0640
0641
0642       G4LogicalVolume *log = new G4LogicalVolume(
0643       solid, PVDF, "coverbig_log", 0, 0, 0);
0644
0645  new G4PVPlacement(
0646       G4Transform3D(rm2, G4ThreeVector((XPosition), 0., 0.)), "coverbig_phys",
0647       log, fMotherPhys, false, 0);
0648
0649   log->SetVisAttributes(blue);
0650 fInitial_pos=XPosition+hight;
0651 }
0652
0653 void FlashApplicator::Bigconnector3() {//this is a piece of the applicator that connects the tube to the optics
0654
0655 G4double phi2 = 90. * deg;
0656
0657   G4RotationMatrix rm2;
0658   rm2.rotateY(phi2);
0659
0660
0661   const G4double innRadius = 6*cm;
0662   const G4double out_Radius = innRadius+60*mm ;
0663   const G4double hight = 3.4*cm-11/4*mm;
0664   const G4double startAngle = 0. * deg;
0665   const G4double spanningAngle = 360. * deg;
0666   const G4double XPosition = fInitial_pos+hight;
0667
0668
0669
0670   G4VSolid *t1 = new G4Tubs("t1_", 0*mm, out_Radius, hight,
0671                  startAngle, spanningAngle);
0672
0673     G4VSolid *t2 = new G4Cons("t2_", 0*mm,60*mm, 0*mm,fInnerRadiusFirstApplicatorFlash,hight +0.1*mm, startAngle,spanningAngle);
0674
0675
0676     G4ThreeVector zTrans(0, 0, 0);
0677
0678     G4SubtractionSolid *hollowcover =
0679         new G4SubtractionSolid("hollowcover_log_", t1, t2, 0, zTrans);
0680
0681   G4LogicalVolume *log = new G4LogicalVolume(
0682       hollowcover, PMMA, "coverbig_log_", 0, 0, 0);
0683
0684  new G4PVPlacement(
0685       G4Transform3D(rm2, G4ThreeVector((XPosition), 0., 0.)), "coverbig_phys_",
0686       log, fMotherPhys, false, 0);
0687
0688   log->SetVisAttributes(yellow);
0689 fInitial_pos=XPosition+hight;
0690 }
0691
0692 void FlashApplicator::FlashBeamLineApplicator() {
0693
0694
0695
0696
0697   // hightFinalApplicatorFlash = 300 * mm;//modify this for length of applicator
0698    if (fHightFinalApplicatorFlash != 0*mm){//set to zero if you do not want the applicator
0699      Bigconnector3(); //comment this line to remove the applicator piece
0700   const G4double startAngleFirstApplicatorFlash = 0. * deg;
0701   const G4double spanningAngleFirstApplicatorFlash = 360. * deg;
0702    fFinalApplicatorXPositionFlash = fInitial_pos+fHightFinalApplicatorFlash;
0703
0704   G4double phi6 = 90. * deg;
0705
0706   G4RotationMatrix rm6;
0707   rm6.rotateY(phi6);
0708
0709   fSolidFirstApplicatorFlash = new G4Tubs(
0710       "FirstApplicatorFlash", fInnerRadiusFirstApplicatorFlash,
0711       fOuterRadiusFirstApplicatorFlash, fHightFinalApplicatorFlash,
0712       startAngleFirstApplicatorFlash, spanningAngleFirstApplicatorFlash);
0713
0714   G4LogicalVolume *logFirstApplicatorFlash = new G4LogicalVolume(
0715       fSolidFirstApplicatorFlash, fFirstApplicatorMaterialFlash,
0716       "FirstApplicatorFlash", 0, 0, 0);
0717
0718   fPhysiFirstApplicatorFlash = new G4PVPlacement(
0719       G4Transform3D(rm6,
0720                     G4ThreeVector((fFinalApplicatorXPositionFlash), 0., 0.)),
0721       "FirstApplicatorFlash", logFirstApplicatorFlash, fMotherPhys, false, 0);
0722
0723   logFirstApplicatorFlash->SetVisAttributes(magenta); } else{fFinalApplicatorXPositionFlash = fInitial_pos+3*cm;}
0724 }
0725
0726
0727 void FlashApplicator::SetOuterRadius(G4double radius)
0728 {
0729
0730   fOuterRadiusFirstApplicatorFlash=radius;
0731   fInnerRadiusFirstApplicatorFlash= fOuterRadiusFirstApplicatorFlash-5*mm;
0732
0733 }
0734
0735 void FlashApplicator::SetApplicatorLength(G4double length)
0736 {
0737   fHightFinalApplicatorFlash=length;
0738
0739 }
0740
0741
0742
0743
0744