Geant4 Cross Reference |
1 // 1 2 // ******************************************* 3 // * License and Disclaimer 4 // * 5 // * The Geant4 software is copyright of th 6 // * the Geant4 Collaboration. It is provided 7 // * conditions of the Geant4 Software License 8 // * LICENSE and available at http://cern.ch/ 9 // * include a list of copyright holders. 10 // * 11 // * Neither the authors of this software syst 12 // * institutes,nor the agencies providing fin 13 // * work make any representation or warran 14 // * regarding this software system or assum 15 // * use. Please see the license in the file 16 // * for the full disclaimer and the limitatio 17 // * 18 // * This code implementation is the result 19 // * technical work of the GEANT4 collaboratio 20 // * By using, copying, modifying or distri 21 // * any work based on the software) you ag 22 // * use in resulting scientific publicati 23 // * acceptance of all terms of the Geant4 Sof 24 // ******************************************* 25 // 26 // Author: F. Poignant, floriane.poignant@gmai 27 // 28 // 29 // 30 // 31 // **************************************** 32 // * 33 // * STCyclotronDetectorConstruction.cc 34 // * 35 // **************************************** 36 // 37 // 38 #include "STCyclotronDetectorConstruction.hh" 39 40 #include "G4RunManager.hh" 41 #include "G4SDManager.hh" 42 #include "G4NistManager.hh" 43 44 #include "G4Element.hh" 45 #include "G4Material.hh" 46 47 #include "G4Box.hh" 48 #include "G4Tubs.hh" 49 #include "G4Cons.hh" 50 #include "G4Polyhedra.hh" 51 #include "G4LogicalVolume.hh" 52 #include "G4PVPlacement.hh" 53 #include "G4Transform3D.hh" 54 #include "G4RotationMatrix.hh" 55 #include "G4UnionSolid.hh" 56 #include "G4SubtractionSolid.hh" 57 #include "G4Region.hh" 58 #include "G4Isotope.hh" 59 #include "G4Element.hh" 60 61 #include "G4PhysicalConstants.hh" 62 #include "G4SystemOfUnits.hh" 63 #include "G4UnitsTable.hh" 64 65 #include "STCyclotronRun.hh" 66 #include "STCyclotronSensitiveTarget.hh" 67 #include "STCyclotronSensitiveFoil.hh" 68 #include "STCyclotronDetectorMessenger.hh" 69 #include "STCyclotronRunAction.hh" 70 71 72 STCyclotronDetectorConstruction::STCyclotronDe 73 :fTarget_diameter(0),fIsotopeName(0),fIsotope 74 fElementName(0),fElementSymbole(0),fElementN 75 fNaturalElementName(0),fNaturalMaterialFract 76 fTarget_NComponents(0), fMaterialFractionMas 77 fIsotopeZFoil(0),fIsotopeNFoil(0),fIsotopeAF 78 fElementSymboleFoil(0),fElementNComponentsFo 79 fNaturalElementNameFoil(0),fNaturalMaterialF 80 fDensity_foil(0), fFoil_NComponents(0), fMat 81 fTarget_thickness(0), fFoil_thickness(0), fT 82 fZ_foil_position(0), fSolidFoil(nullptr),fLo 83 fLogicWorld(nullptr), 84 fLayer_z_position_PART3(0), fPhysLayer_PART3 85 fTube_outerRadius_PART4(0), fTube_length_PAR 86 fPhysTube_PART4(nullptr), fPhysLayer_PART4(n 87 fLayer1_z_position_PART4(0),fPhysLayer1_PART 88 fLogicTarget(nullptr), fTarget_z_position(0) 89 fPhysTarget(nullptr), 90 fLayer1_z_position_PART5(0), fPhysLayer1_PAR 91 fLayer2_z_position_PART5(0), fPhysLayer2_PAR 92 fLayer3_z_position_PART5(0),fPhysLayer3_PART 93 fRegionTarget(nullptr), fRegionFoil(nullptr) 94 { 95 fDetectorMessenger = new STCyclotronDetector 96 } 97 98 STCyclotronDetectorConstruction::~STCyclotronD 99 { 100 delete fDetectorMessenger; 101 } 102 103 G4VPhysicalVolume* STCyclotronDetectorConstruc 104 { 105 //Initialization of messenger parameters 106 fTarget_diameter = 7.*mm; 107 fDensity_target = 8.9*g/cm3; 108 fTarget_thickness = 0.35*mm; 109 fFoil_thickness = 0.000001*mm; 110 fDensity_foil = 2.7*g/cm3; 111 112 113 //Get nist material manager 114 G4NistManager* nist = G4NistManager::Instanc 115 116 // Option to switch on/off checking of volum 117 G4bool checkOverlaps = true; 118 119 120 //Create the world 121 G4double world_hx = 1.*m; 122 G4double world_hy = 1.*m; 123 G4double world_hz = 1.*m; 124 G4Material* world_mat = nist->FindOrBuildMat 125 126 G4Box* solidWorld 127 = new G4Box("World", 128 world_hx, 129 world_hy, 130 world_hz); 131 132 fLogicWorld 133 = new G4LogicalVolume(solidWorld, 134 world_mat, 135 "World"); 136 137 G4VPhysicalVolume* physWorld 138 = new G4PVPlacement(0, 139 G4ThreeVector(), //at (0,0,0) 140 fLogicWorld, //its logical vo 141 "World", //its name 142 0, //its mother vol 143 false, //no boolean oper 144 0); //copy number 145 146 147 148 //////////////////////////////////////////// 149 ///////////////////////////Create the detect 150 //////////////////////////////////////////// 151 152 153 //Overall parameters 154 G4double startAngle = 0.*deg; 155 G4double spanningAngle = 360.*deg; 156 157 //////////////////////////////////// 158 /////////Define materials/////////// 159 //////////////////////////////////// 160 161 162 //ALUMINIUM// 163 164 G4Material* al = nist->FindOrBuildMaterial(" 165 166 167 168 //Create vacuum around the beam// 169 G4double vacuum_atomic_number, vacuum_mass_o 170 vacuum_atomic_number = 1.; 171 vacuum_mass_of_mole = 1.008*g/mole; 172 vacuum_density = 1.e-25*g/cm3; 173 vacuum_pressure = 1.e-8*bar; 174 vacuum_temperature = 293.*kelvin; //fro 175 G4Material* vacuum_beam = new G4Material("va 176 vacuum_mass_of_mole, vacuum_densi 177 kStateGas,vacuum_temperature, 178 vacuum_pressure); 179 180 181 182 //HELIUM 183 G4double helium_Z, helium_A, helium_density, 184 helium_Z = 2.; 185 helium_A = 4*g/mole; 186 helium_density = 0.1785e-3*g/cm3; // with T= 187 helium_pressure = 2.*bar; 188 helium_temperature = 293.*kelvin; //15 to 20 189 G4Material* helium = new G4Material("helium" 190 191 192 //PLATINIUM 193 G4Material* pt = nist->FindOrBuildMaterial( 194 195 196 //TARGET MATERIAL INITIALIZATION 197 /*G4String name; 198 G4String symbole; 199 G4int ncomponents; 200 G4int n; 201 G4double z_isotope; 202 G4double abundance; 203 G4double fractionmass; 204 G4double a;*/ 205 206 207 /* 208 //Pure Ni64 209 210 G4Isotope* Ni64 = new G4Isotope(name="Zi64", 211 212 G4Element* pureNi64 = new G4Element(name="pu 213 pureNi64->AddIsotope(Ni64, abundance = 100.* 214 215 216 fTarget_Material = new G4Material("FTarget_M 217 fTarget_Material->AddElement(pureNi64, fract 218 */ 219 /* 220 //Ni64 94% enriched - Sz 221 222 G4Isotope* Ni64 = new G4Isotope(name="Zi64", 223 G4Isotope* Ni58 = new G4Isotope(name="Zi58", 224 G4Isotope* Ni60 = new G4Isotope(name="Zi60", 225 G4Isotope* Ni61 = new G4Isotope(name="Zi61", 226 G4Isotope* Ni62 = new G4Isotope(name="Zi62", 227 228 229 G4Element* Ni64enriched95 = new G4Element(na 230 Ni64enriched95->AddIsotope(Ni64, abundance = 231 Ni64enriched95->AddIsotope(Ni58, abundance = 232 Ni64enriched95->AddIsotope(Ni60, abundance = 233 Ni64enriched95->AddIsotope(Ni61, abundance = 234 Ni64enriched95->AddIsotope(Ni62, abundance = 235 236 237 fTarget_Material = new G4Material("FTarget_M 238 fTarget_Material->AddElement(Ni64enriched95, 239 240 //fTarget_Material = nist->FindOrBuildMater 241 */ 242 243 /* 244 245 //Ni64 95% enriched - Obata 246 247 G4Isotope* Ni64 = new G4Isotope(name="Zi64", 248 G4Isotope* Ni58 = new G4Isotope(name="Zi58", 249 G4Isotope* Ni60 = new G4Isotope(name="Zi60", 250 G4Isotope* Ni61 = new G4Isotope(name="Zi61", 251 G4Isotope* Ni62 = new G4Isotope(name="Zi62", 252 253 254 G4Element* Ni64enriched95 = new G4Element(na 255 Ni64enriched95->AddIsotope(Ni64, abundance = 256 Ni64enriched95->AddIsotope(Ni58, abundance = 257 Ni64enriched95->AddIsotope(Ni60, abundance = 258 Ni64enriched95->AddIsotope(Ni61, abundance = 259 Ni64enriched95->AddIsotope(Ni62, abundance = 260 261 262 fTarget_Material = new G4Material("FTarget_M 263 fTarget_Material->AddElement(Ni64enriched95, 264 */ 265 266 fTarget_Material = nist->FindOrBuildMateria 267 268 //FOIL MATERIAL 269 fFoil_Material = nist->FindOrBuildMaterial( 270 271 272 //////////////////////////////////////////// 273 /////////////////////////////PART1////////// 274 //////////////////////////////////////////// 275 276 //////////////////////////////////////////// 277 //////////////////////////LAYER PART 1////// 278 //////////////////////////////////////////// 279 280 281 //Create the (external) layer around the bea 282 283 G4double layer1_length_PART1 = 98.9* 284 G4double layer1_innerRadius_PART1 = 11.5* 285 G4double layer1_outerRadius_PART1 = 16.*m 286 G4double layer1_hz_PART1 = 0.5*l 287 288 G4Tubs* solidLayer1_PART1 289 = new G4Tubs("Layer1_PART1", 290 layer1_innerRadius_PART1, 291 layer1_outerRadius_PART1, 292 layer1_hz_PART1, 293 startAngle, 294 spanningAngle); 295 296 297 G4double layer2_length_PART1 = 124.6 298 G4double layer2_innerRadius_PART1 = 7.5*m 299 G4double layer2_outerRadius_PART1 = 11.5* 300 G4double layer2_hz_PART1 = 0.5*l 301 302 G4Tubs* solidLayer2_PART1 303 = new G4Tubs("Layer2_PART1", 304 layer2_innerRadius_PART1, 305 layer2_outerRadius_PART1, 306 layer2_hz_PART1, 307 startAngle, 308 spanningAngle); 309 310 311 312 G4RotationMatrix rot_layer_PART1; 313 G4double z_layer_translation_PART1 = layer2_ 314 G4ThreeVector placement_layer_PART1 = G4Thre 315 G4Transform3D transform_layer_PART1(rot_laye 316 317 G4UnionSolid* solidLayer_PART1 = new G4Union 318 319 320 G4LogicalVolume* logicLayer_PART1 321 = new G4LogicalVolume(solidLayer_PART1, 322 al, 323 "Layer_PART1"); 324 325 /* G4VPhysicalVolume* physLayer1_PART1 = */ 326 new G4PVPlacement(0, 327 G4ThreeVector(0.*mm,0.*mm,0.5*layer2_l 328 logicLayer_PART1, 329 "Layer_PART1", 330 fLogicWorld, 331 false, 332 0, 333 checkOverlaps); 334 335 336 //////////////////////////////////////////// 337 ////////////////Create the beam vacuum tube/ 338 //////////////////////////////////////////// 339 340 341 G4double tube_length_PART1 = layer2_length_P 342 343 G4double tube_innerRadius_PART1 = 0.*mm; 344 G4double tube_outerRadius_PART1 = 7.5*mm; 345 G4double tube_hz_PART1 = 0.5*tub 346 347 G4Tubs* solidTube_PART1 348 = new G4Tubs("Tube_PART1", 349 tube_innerRadius_PART1, 350 tube_outerRadius_PART1, 351 tube_hz_PART1, 352 startAngle, 353 spanningAngle); 354 355 G4LogicalVolume* logicTube_PART1 356 = new G4LogicalVolume(solidTube_PART1, 357 vacuum_beam, 358 "Tube_PART1"); 359 360 /* G4VPhysicalVolume* physTube_PART1 = */ 361 new G4PVPlacement(0, 362 G4ThreeVector(0.*mm,0.*mm,0.5*tube_len 363 logicTube_PART1, 364 "Tube_PART1", 365 fLogicWorld, 366 false, 367 0, 368 checkOverlaps); 369 370 371 372 373 374 375 //////////////////////////////////////////// 376 /////////////////////////// PART 2 = FOIL PA 377 //////////////////////////////////////////// 378 379 //////////////////////////////////////////// 380 //////////////////////////LAYER PART 2////// 381 //////////////////////////////////////////// 382 383 //Create the (external) layer around the foi 384 385 G4double layer_length_PART2 = 12.*m 386 G4double layer_innerRadius_PART2 = 7.5*m 387 G4double layer_outerRadius_PART2 = 15.*m 388 G4double layer_hz_PART2 = 0.5*l 389 390 G4Tubs* solidLayer_PART2 391 = new G4Tubs("Layer_PART2", 392 layer_innerRadius_PART2, 393 layer_outerRadius_PART2, 394 layer_hz_PART2, 395 startAngle, 396 spanningAngle); 397 398 399 G4LogicalVolume* logicLayer_PART2 400 = new G4LogicalVolume(solidLayer_PART2, 401 al, 402 "Layer_PART2"); 403 404 G4double layer_z_position_PART2 = tube_leng 405 406 /* G4VPhysicalVolume* physLayer1_PART2 = 407 new G4PVPlacement(0, 408 G4ThreeVector(0.*mm,0.*mm,layer_z_pos 409 logicLayer_PART2, 410 "Layer_PART2", 411 fLogicWorld, 412 false, 413 0, 414 checkOverlaps); 415 416 417 418 //////////////////////////////////////////// 419 //////////////////////////TUBE PART 2/////// 420 //////////////////////////////////////////// 421 422 //Create the tube before the foil 423 424 G4double tube_length_PART2 = layer_length_PA 425 426 G4double tube_innerRadius_PART2 = 0.*mm; 427 G4double tube_outerRadius_PART2 = 7.5*mm 428 G4double tube_hz_PART2 = 0.5*tu 429 430 G4Tubs* solidTube_PART2 431 = new G4Tubs("Tube_PART2", 432 tube_innerRadius_PART2, 433 tube_outerRadius_PART2, 434 tube_hz_PART2, 435 startAngle, 436 spanningAngle); 437 438 G4LogicalVolume* logicTube_PART2 439 = new G4LogicalVolume(solidTube_PART2, 440 vacuum_beam, 441 "Tube_PART2"); 442 443 444 /* G4VPhysicalVolume* physTube_PART2 = */ 445 new G4PVPlacement(0, 446 G4ThreeVector(0.*mm,0.*mm, layer_z_pos 447 logicTube_PART2, 448 "Tube_PART2", 449 fLogicWorld, 450 false, 451 0, 452 checkOverlaps); 453 454 455 //////////////////////////////////////////// 456 //////////////////////// GRID PART ///////// 457 //////////////////////////////////////////// 458 459 460 //HEXAGONE 461 G4double hexagone_length = layer_length_PART 462 G4int numSide = 6; 463 G4int numZPlanes = 2; 464 const G4double zPlane[]={-0.5*hexagone_lengt 465 const G4double rInner[]={3.*mm,3.*mm}; 466 const G4double rOuter[]={3.3*mm,3.3*mm}; 467 468 G4Polyhedra* solidHexagone_0 469 = new G4Polyhedra("Grid", 470 0.*deg, 471 360.*deg, 472 numSide, 473 numZPlanes, 474 zPlane, 475 rInner, 476 rOuter); 477 478 479 G4LogicalVolume* logicHexagone 480 = new G4LogicalVolume(solidHexagone_0, 481 al, 482 "Grid"); 483 484 /* G4VPhysicalVolume* physHexagone = */ 485 new G4PVPlacement(0, 486 G4ThreeVector(0.*mm,0.*mm,0.*mm), 487 logicHexagone, 488 "Grid", 489 logicTube_PART2, 490 false, 491 0, 492 checkOverlaps); 493 494 495 496 497 498 //////////////////////////////////////////// 499 //////////////////////////CREATE THE FOIL // 500 //////////////////////////////////////////// 501 502 503 fZ_foil_position = 0.5*fFoil_thickness + tub 504 505 506 507 G4double foil_innerRadius = 0.*mm; 508 G4double foil_outerRadius = 16.*mm; 509 510 fSolidFoil 511 = new G4Tubs("Foil", 512 foil_innerRadius, 513 foil_outerRadius, 514 0.5*fFoil_thickness, 515 startAngle, 516 spanningAngle); 517 518 fFoilVolume = fSolidFoil->GetCubicVolume(); 519 520 fLogicFoil 521 = new G4LogicalVolume(fSolidFoil, 522 fFoil_Material, 523 "Foil"); 524 525 526 527 fPhysFoil 528 = new G4PVPlacement(0, 529 G4ThreeVector(0.*mm,0.*mm,fZ_foil_positi 530 fLogicFoil, 531 "Foil", 532 fLogicWorld, 533 false, 534 0, 535 checkOverlaps); 536 537 538 539 540 541 //////////////////////////////////////////// 542 /////////////////////////// PART 3 = AFTER T 543 //////////////////////////////////////////// 544 545 546 //////////////////////////////////////////// 547 //////////////////////////LAYER PART 3////// 548 //////////////////////////////////////////// 549 550 //Create the (external) layer around the bea 551 552 553 G4double layer_length_PART3 = 38.32*mm; 554 555 G4double layer_innerRadius_PART3 = 7.5*m 556 G4double layer_outerRadius_PART3 = 16.*m 557 G4double layer_hz_PART3 = 0.5*l 558 559 G4Tubs* solidLayer_PART3 560 = new G4Tubs("Layer_PART3", 561 layer_innerRadius_PART3, 562 layer_outerRadius_PART3, 563 layer_hz_PART3, 564 startAngle, 565 spanningAngle); 566 567 G4LogicalVolume* logicLayer_PART3 568 = new G4LogicalVolume(solidLayer_PART3, 569 al, 570 "Layer_PART3"); 571 572 fLayer_z_position_PART3 = tube_length_PART1 573 574 fPhysLayer_PART3 575 = new G4PVPlacement(0, 576 G4ThreeVector(0.*mm,0.*mm,fLayer_z_pos 577 logicLayer_PART3, 578 "Layer_PART3", 579 fLogicWorld, 580 false, 581 0, 582 checkOverlaps); 583 584 585 586 //////////////////////////////////////////// 587 //////////////////////////TUBE PART 3/////// 588 //////////////////////////////////////////// 589 590 //Create the tube after the foil, MATERIAL = 591 592 G4double tube_length_PART3 = layer_length_PA 593 594 G4double tube_innerRadius_PART3 = 0.*mm; 595 G4double tube_outerRadius_PART3 = 7.5*mm 596 G4double tube_hz_PART3 = 0.5*tu 597 598 G4Tubs* solidTube_PART3 599 = new G4Tubs("Tube_PART3", 600 tube_innerRadius_PART3, 601 tube_outerRadius_PART3, 602 tube_hz_PART3, 603 startAngle, 604 spanningAngle); 605 606 G4LogicalVolume* logicTube_PART3 607 = new G4LogicalVolume(solidTube_PART3, 608 helium, 609 "Tube_PART3"); 610 611 612 fPhysTube_PART3 613 = new G4PVPlacement(0, 614 G4ThreeVector(0.*mm,0.*mm,fLayer_z_posit 615 logicTube_PART3, 616 "Tube_PART3", 617 fLogicWorld, 618 false, 619 0, 620 checkOverlaps); 621 622 623 //////////////////////////////////////////// 624 /////////////////////////// PART 4 = BEFORE 625 //////////////////////////////////////////// 626 627 //////////////////////////////////////////// 628 //////////////////////////LAYER PART4/////// 629 //////////////////////////////////////////// 630 631 632 G4double layer1_length_PART4 = 11.5*mm; / 633 634 G4double layer2_length_PART4 = 4.6*mm; 635 G4double layer2_Rmin1_PART4 = 8.5*mm; 636 G4double layer2_Rmax1_PART4 = 9.*mm; 637 G4double layer2_Rmin2_PART4 = 8.5*mm; 638 G4double layer2_Rmax2_PART4 = 14.*mm; 639 G4double layer2_hz_PART4 = 0.5*layer2 640 641 G4Cons* solidLayer2_PART4 642 = new G4Cons("Layer2_PART4", 643 layer2_Rmin1_PART4, 644 layer2_Rmax1_PART4, 645 layer2_Rmin2_PART4, 646 layer2_Rmax2_PART4, 647 layer2_hz_PART4, 648 startAngle, 649 spanningAngle); 650 651 //Create the (external) aluminium layer arou 652 653 G4double layer3_length_PART4 = layer1_length 654 G4double layer3_innerRadius_PART4 = 8.5* 655 G4double layer3_outerRadius_PART4 = 14.* 656 G4double layer3_hz_PART4 = 0.5* 657 658 G4Tubs* solidLayer3_PART4 659 = new G4Tubs("Layer3_PART4", 660 layer3_innerRadius_PART4, 661 layer3_outerRadius_PART4, 662 layer3_hz_PART4, 663 startAngle, 664 spanningAngle); 665 666 667 668 G4RotationMatrix rot_layer_PART4; 669 G4double z_layer_translation_PART4 = 0.5*(la 670 G4ThreeVector placement_layer_PART4 = G4Thre 671 G4Transform3D transform_layer_PART4(rot_laye 672 673 G4UnionSolid* solidLayer_PART4 = new G4Union 674 675 676 677 G4LogicalVolume* logicLayer_PART4 678 = new G4LogicalVolume(solidLayer_PART4, 679 al, 680 "Layer_PART4"); 681 682 fLayer_z_position_PART4 = tube_length_PART1 683 684 fPhysLayer_PART4 685 = new G4PVPlacement(0, 686 G4ThreeVector(0.*mm,0.*mm,fLayer_z_posit 687 logicLayer_PART4, 688 "Layer_PART4", 689 fLogicWorld, 690 false, 691 0, 692 checkOverlaps); 693 694 695 696 697 698 //Create the (internal) gold layer around t 699 700 G4double layer1_innerRadius_PART4 = 8.*m 701 G4double layer1_outerRadius_PART4 = 8.5* 702 G4double layer1_hz_PART4 = 0.5* 703 704 G4Tubs* solidLayer1_PART4 705 = new G4Tubs("Layer1_PART4", 706 layer1_innerRadius_PART4, 707 layer1_outerRadius_PART4, 708 layer1_hz_PART4, 709 startAngle, 710 spanningAngle); 711 712 713 G4LogicalVolume* logicLayer1_PART4 714 = new G4LogicalVolume(solidLayer1_PART4, 715 pt, 716 "Layer1_PART4"); 717 718 fLayer1_z_position_PART4 = tube_length_PART1 719 720 721 fPhysLayer1_PART4 722 = new G4PVPlacement(0, 723 G4ThreeVector(0.*mm,0.*mm,fLayer1_z_posi 724 logicLayer1_PART4, 725 "Layer1_PART4", 726 fLogicWorld, 727 false, 728 0, 729 checkOverlaps); 730 731 //////////////////////////////////////////// 732 //////////////////////////TUBE PART 4/////// 733 //////////////////////////////////////////// 734 735 736 //Create the tube before the target 737 738 739 fTube_length_PART4 = layer1_length_PART4; 740 741 G4double tube_innerRadius_PART4 = 0.*mm; 742 fTube_outerRadius_PART4 = 8.*mm; 743 G4double tube_hz_PART4 = 0.5*fT 744 745 G4Tubs* solidTube_PART4 746 = new G4Tubs("Tube_PART4", 747 tube_innerRadius_PART4, 748 fTube_outerRadius_PART4, 749 tube_hz_PART4, 750 startAngle, 751 spanningAngle); 752 753 G4LogicalVolume* logicTube_PART4 754 = new G4LogicalVolume(solidTube_PART4, 755 helium, 756 "Tube_PART4"); 757 758 759 fPhysTube_PART4 760 = new G4PVPlacement(0, 761 G4ThreeVector(0.*mm,0.*mm,fLayer1_z_posi 762 logicTube_PART4, 763 "Tube_PART4", 764 fLogicWorld, 765 false, 766 0, 767 checkOverlaps); 768 769 770 771 772 //////////////////////////////////////////// 773 //////////////////////////// TARGET //////// 774 //////////////////////////////////////////// 775 776 777 778 779 //Design the target inside the tube 780 781 G4double target_innerRadius = 0.*mm; 782 G4double target_outerRadius = 0.5*fTarge 783 G4double target_hz = 0.5*fTarge 784 785 fSolidTarget 786 = new G4Tubs("Target", 787 target_innerRadius, 788 target_outerRadius, 789 target_hz, 790 startAngle, 791 spanningAngle); 792 793 fTargetVolume = fSolidTarget->GetCubicVolume 794 795 fLogicTarget 796 = new G4LogicalVolume(fSolidTarget, 797 fTarget_Material, 798 "Target"); 799 800 fTarget_z_position = 0.5*fTube_length_PART4- 801 802 803 fPhysTarget 804 = new G4PVPlacement(0, 805 G4ThreeVector(0.*mm,0.*mm, fTarget_z_pos 806 fLogicTarget, 807 "Target", 808 logicTube_PART4, 809 false, 810 0, 811 checkOverlaps); 812 813 814 815 //////////////////////////////////////////// 816 /////////////////////////// PART 5 = AFTER T 817 //////////////////////////////////////////// 818 819 //////////////////////////////////////////// 820 //////////////////////////LAYER PART 5////// 821 //////////////////////////////////////////// 822 823 //Create the (internal) platinium layer 824 825 G4double layer1_length_PART5 = 0.5*mm; 826 827 G4double layer1_innerRadius_PART5 = 0.*m 828 G4double layer1_outerRadius_PART5 = 8.5* 829 G4double layer1_hz_PART5 = 0.5* 830 831 G4Tubs* solidLayer1_PART5 832 = new G4Tubs("Layer1_PART5", 833 layer1_innerRadius_PART5, 834 layer1_outerRadius_PART5, 835 layer1_hz_PART5, 836 startAngle, 837 spanningAngle); 838 839 G4LogicalVolume* logicLayer1_PART5 840 = new G4LogicalVolume(solidLayer1_PART5, 841 pt, 842 "Layer1_PART5"); 843 844 fLayer1_z_position_PART5 = tube_length_PART1 845 846 fPhysLayer1_PART5 847 = new G4PVPlacement(0, 848 G4ThreeVector(0.*mm,0.*mm,fLayer1_z_posi 849 logicLayer1_PART5, 850 "Layer1_PART5", 851 fLogicWorld, 852 false, 853 0, 854 checkOverlaps); 855 856 857 858 //Create the (external) aluminium layer afte 859 860 G4double layer2_length_PART5 = 0.5*mm; 861 862 G4double layer2_innerRadius_PART5 = 8.5* 863 G4double layer2_outerRadius_PART5 = 14.* 864 G4double layer2_hz_PART5 = 0.5* 865 866 G4Tubs* solidLayer2_PART5 867 = new G4Tubs("Layer2_PART5", 868 layer2_innerRadius_PART5, 869 layer2_outerRadius_PART5, 870 layer2_hz_PART5, 871 startAngle, 872 spanningAngle); 873 874 G4LogicalVolume* logicLayer2_PART5 875 = new G4LogicalVolume(solidLayer2_PART5, 876 al, 877 "Layer2_PART5"); 878 879 fLayer2_z_position_PART5 = tube_length_PART1 880 881 fPhysLayer2_PART5 882 = new G4PVPlacement(0, 883 G4ThreeVector(0.*mm,0.*mm,fLayer2_z_posi 884 logicLayer2_PART5, 885 "Layer2_PART5", 886 fLogicWorld, 887 false, 888 0, 889 checkOverlaps); 890 891 892 893 //Create the end of the beam target machine 894 895 G4double layer3_length_PART5 = 3.*mm; 896 897 G4double layer3_innerRadius_PART5 = 0.*m 898 G4double layer3_outerRadius_PART5 = 14.* 899 G4double layer3_hz_PART5 = 0.5* 900 901 G4Tubs* solidLayer3_PART5 902 = new G4Tubs("Layer3_PART5", 903 layer3_innerRadius_PART5, 904 layer3_outerRadius_PART5, 905 layer3_hz_PART5, 906 startAngle, 907 spanningAngle); 908 909 G4LogicalVolume* logicLayer3_PART5 910 = new G4LogicalVolume(solidLayer3_PART5, 911 al, 912 "Layer3_PART5"); 913 914 fLayer3_z_position_PART5 = tube_length_PART1 915 916 fPhysLayer3_PART5 917 = new G4PVPlacement(0, 918 G4ThreeVector(0.*mm,0.*mm,fLayer3_z_posi 919 logicLayer3_PART5, 920 "Layer3_PART5", 921 fLogicWorld, 922 false, 923 0, 924 checkOverlaps); 925 926 927 928 929 //////////////////////////////////////////// 930 /////////// Set sensitive region /////////// 931 //////////////////////////////////////////// 932 933 934 if(!fRegionTarget) 935 { 936 fRegionTarget = new G4Region("Target"); 937 fLogicTarget -> SetRegion(fRegionTarget) 938 fRegionTarget -> AddRootLogicalVolume(fL 939 } 940 941 if(!fRegionFoil&&fPhysFoil!=nullptr) 942 { 943 fRegionFoil = new G4Region("Foil"); 944 fLogicFoil -> SetRegion(fRegionFoil); 945 fRegionFoil -> AddRootLogicalVolume(fLog 946 } 947 948 949 950 951 //Always return physical world// 952 953 return physWorld; 954 955 956 } 957 958 void STCyclotronDetectorConstruction::Construc 959 { 960 961 if(fLogicTarget != nullptr){ 962 STCyclotronSensitiveTarget* TargetSD = new 963 SetSensitiveDetector("Target",TargetSD); 964 } 965 966 967 if(fLogicFoil != nullptr){ 968 STCyclotronSensitiveFoil* FoilSD = new STC 969 SetSensitiveDetector("Foil",FoilSD); 970 } 971 } 972 973 void STCyclotronDetectorConstruction::SetTarge 974 { 975 976 if(fTarget_diameter!=targetDiameter){ 977 if(targetDiameter/2.>fTube_outerRadius_PAR 978 else{ 979 fTarget_diameter = targetDiameter; 980 if(fSolidTarget) fSolidTarget->SetOuterR 981 G4cout << "The new diameter of the targe 982 } 983 } 984 985 G4RunManager::GetRunManager() -> GeometryHas 986 G4cout << "... Geometry is notified .... " < 987 988 } 989 990 //SET MATERIAL METHODS// 991 992 void STCyclotronDetectorConstruction::SetTarge 993 fIsotopeName.push_back(name); 994 G4RunManager::GetRunManager() -> GeometryHas 995 G4cout << "... Geometry is notified .... " < 996 } 997 998 void STCyclotronDetectorConstruction::SetTarge 999 fIsotopeZ.push_back(z); 1000 G4RunManager::GetRunManager() -> GeometryHa 1001 G4cout << "... Geometry is notified .... " 1002 } 1003 1004 void STCyclotronDetectorConstruction::SetTarg 1005 fIsotopeN.push_back(n); 1006 G4RunManager::GetRunManager() -> GeometryHa 1007 G4cout << "... Geometry is notified .... " 1008 } 1009 1010 void STCyclotronDetectorConstruction::SetTarg 1011 fIsotopeA.push_back(a); 1012 G4RunManager::GetRunManager() -> GeometryHa 1013 G4cout << "... Geometry is notified .... " 1014 } 1015 1016 void STCyclotronDetectorConstruction::SetTarg 1017 fElementName.push_back(name); 1018 G4RunManager::GetRunManager() -> GeometryHa 1019 G4cout << "... Geometry is notified .... " 1020 } 1021 1022 void STCyclotronDetectorConstruction::SetTarg 1023 fElementSymbole.push_back(symbole); 1024 G4RunManager::GetRunManager() -> GeometryHa 1025 G4cout << "... Geometry is notified .... " 1026 } 1027 1028 void STCyclotronDetectorConstruction::SetTarg 1029 fElementNComponents.push_back(n); 1030 G4RunManager::GetRunManager() -> GeometryHa 1031 G4cout << "... Geometry is notified .... " 1032 } 1033 1034 void STCyclotronDetectorConstruction::SetTarg 1035 fElementAbundance.push_back(abundance); 1036 G4RunManager::GetRunManager() -> GeometryHa 1037 G4cout << "... Geometry is notified .... " 1038 } 1039 1040 void STCyclotronDetectorConstruction::SetTarg 1041 fDensity_target = materialDensity; 1042 G4RunManager::GetRunManager() -> GeometryHa 1043 G4cout << "... Geometry is notified .... " 1044 } 1045 1046 void STCyclotronDetectorConstruction::SetTarg 1047 fTarget_NComponents = n; 1048 G4RunManager::GetRunManager() -> GeometryHa 1049 G4cout << "... Geometry is notified .... " 1050 } 1051 1052 void STCyclotronDetectorConstruction::SetTarg 1053 fMaterialFractionMass.push_back(fractionMas 1054 G4RunManager::GetRunManager() -> GeometryHa 1055 G4cout << "... Geometry is notified .... " 1056 } 1057 1058 void STCyclotronDetectorConstruction::SetTarg 1059 fNaturalElementName.push_back(name); 1060 G4RunManager::GetRunManager() -> GeometryHa 1061 G4cout << "... Geometry is notified .... " 1062 } 1063 1064 void STCyclotronDetectorConstruction::SetTarg 1065 fNaturalMaterialFractionMass.push_back(frac 1066 G4RunManager::GetRunManager() -> GeometryHa 1067 G4cout << "... Geometry is notified .... " 1068 } 1069 1070 //UPDATE THE MATERIAL TO APPLY THE MODIFICATI 1071 1072 G4bool STCyclotronDetectorConstruction::Updat 1073 1074 G4int nElements = fTarget_NComponents; 1075 1076 G4double density = fDensity_target*g/cm3; 1077 G4Material* material = new G4Material("FTar 1078 1079 G4double checkFractionMass = 0; 1080 1081 1082 //CHECK THAT NUMBER OF ELEMENTS IN THE MATE 1083 1084 G4int counterElement = 0; 1085 1086 //std::vector<G4String>::size_type sz = fEl 1087 std::ptrdiff_t const sizeElementName = fEle 1088 std::ptrdiff_t const sizeNaturalElementName 1089 1090 1091 if(sizeElementName!=0){ 1092 1093 //ELEMENT LOOP 1094 if(nElements != sizeElementName + sizeNat 1095 G4cout << "Error : the number of elemen 1096 return false; 1097 } 1098 1099 for(int i = 0; i<sizeElementName ; i++){ 1100 1101 checkFractionMass = checkFractionMass + 1102 G4Element* elementi = new G4Element(fEl 1103 1104 G4double checkAbundance = 0.; 1105 1106 //ISOTOPE LOOP FOR THE ELEMENT 1107 std::ptrdiff_t const sizeIsotopeName = 1108 1109 if(fElementNComponents[i] != sizeIsotop 1110 G4cout << "Error : the number of isotopes d 1111 return false; 1112 } 1113 for(G4int j=counterElement;j<counterEle 1114 G4double A = fIsotopeA[j]*g/mole; 1115 G4Isotope* isotopeij = new G4Isotope(fIsoto 1116 checkAbundance = checkAbundance + fElementA 1117 elementi->AddIsotope(isotopeij,fElementAbun 1118 } 1119 if((1.-checkAbundance)>1E-5){ 1120 G4cout << "Error : the total abundance of i 1121 return false; 1122 } 1123 1124 counterElement = counterElement + fElem 1125 material->AddElement(elementi, fMateria 1126 1127 } 1128 } 1129 1130 1131 if(sizeNaturalElementName!=0){ 1132 for(int i=0;i<sizeNaturalElementName;i++) 1133 checkFractionMass = checkFractionMass + 1134 G4NistManager* man = G4NistManager::Ins 1135 G4Element* element = man->FindOrBuildEl 1136 material->AddElement(element, fNaturalM 1137 } 1138 } 1139 1140 if((1.-checkFractionMass)>1E-5){ 1141 G4cout << "Error : the sum of the fractio 1142 return false; 1143 } 1144 1145 fTarget_Material = material; 1146 G4cout << "You succesfully changed the mate 1147 G4cout << "Here is the new material : " << 1148 G4cout << "Number of elements : " << materi 1149 1150 std::ptrdiff_t const sizeMaterial = materia 1151 1152 1153 for(int i = 0; i<sizeMaterial;i++){ 1154 const G4Element* element = material->GetE 1155 G4cout << element->GetName() << " having 1156 1157 std::ptrdiff_t const sizeIsotope = eleme 1158 1159 1160 for(int j=0; j<sizeIsotope; j++){ 1161 const G4Isotope* isotope = element->Get 1162 G4cout << " - " << (element->GetRelativ 1163 } 1164 } 1165 fLogicTarget->SetMaterial(fTarget_Material) 1166 1167 // 1168 fIsotopeName.clear(); 1169 fIsotopeZ.clear(); 1170 fIsotopeN.clear(); 1171 fIsotopeA.clear(); 1172 fElementName.clear(); 1173 fElementSymbole.clear(); 1174 fElementNComponents.clear(); 1175 fElementAbundance.clear(); 1176 fNaturalElementName.clear(); 1177 fNaturalMaterialFractionMass.clear(); 1178 fMaterialFractionMass.clear(); 1179 // 1180 1181 G4RunManager::GetRunManager() -> GeometryHa 1182 G4cout << "... Geometry is notified .... " 1183 1184 1185 return true; 1186 1187 1188 1189 } 1190 1191 //SET TARGET MATERIAL WITH PHYSICS NIST LIST/ 1192 1193 void STCyclotronDetectorConstruction::SetTarg 1194 1195 G4NistManager* nistManager = G4NistManager: 1196 G4Material* targetMaterial = nistManager->F 1197 if(fTarget_Material!=targetMaterial){ 1198 1199 if(targetMaterial){ 1200 1201 fTarget_Material = targetMaterial; 1202 fLogicTarget->SetMaterial(fTarget_Materia 1203 1204 G4cout << "The new material of the target 1205 1206 } 1207 else{ G4cout << "This material wasn't fou 1208 1209 } 1210 1211 G4RunManager::GetRunManager() -> GeometryHa 1212 G4cout << "... Geometry is notified .... " 1213 1214 } 1215 1216 1217 void STCyclotronDetectorConstruction::SetFoil 1218 fIsotopeNameFoil.push_back(name); 1219 G4RunManager::GetRunManager() -> GeometryHa 1220 G4cout << "... Geometry is notified .... " 1221 } 1222 1223 void STCyclotronDetectorConstruction::SetFoil 1224 fIsotopeZFoil.push_back(z); 1225 G4RunManager::GetRunManager() -> GeometryHa 1226 G4cout << "... Geometry is notified .... " 1227 } 1228 1229 void STCyclotronDetectorConstruction::SetFoil 1230 fIsotopeNFoil.push_back(n); 1231 G4RunManager::GetRunManager() -> GeometryHa 1232 G4cout << "... Geometry is notified .... " 1233 } 1234 1235 void STCyclotronDetectorConstruction::SetFoil 1236 fIsotopeAFoil.push_back(a); 1237 G4RunManager::GetRunManager() -> GeometryHa 1238 G4cout << "... Geometry is notified .... " 1239 } 1240 1241 void STCyclotronDetectorConstruction::SetFoil 1242 fElementNameFoil.push_back(name); 1243 G4RunManager::GetRunManager() -> GeometryHa 1244 G4cout << "... Geometry is notified .... " 1245 } 1246 1247 void STCyclotronDetectorConstruction::SetFoil 1248 fElementSymboleFoil.push_back(symbole); 1249 G4RunManager::GetRunManager() -> GeometryHa 1250 G4cout << "... Geometry is notified .... " 1251 } 1252 1253 void STCyclotronDetectorConstruction::SetFoil 1254 fElementNComponentsFoil.push_back(n); 1255 G4RunManager::GetRunManager() -> GeometryHa 1256 G4cout << "... Geometry is notified .... " 1257 } 1258 1259 void STCyclotronDetectorConstruction::SetFoil 1260 fElementAbundanceFoil.push_back(abundance); 1261 G4RunManager::GetRunManager() -> GeometryHa 1262 G4cout << "... Geometry is notified .... " 1263 } 1264 1265 void STCyclotronDetectorConstruction::SetFoil 1266 fDensity_foil = materialDensity; 1267 G4RunManager::GetRunManager() -> GeometryHa 1268 G4cout << "... Geometry is notified .... " 1269 } 1270 1271 void STCyclotronDetectorConstruction::SetFoil 1272 fFoil_NComponents = n; 1273 G4RunManager::GetRunManager() -> GeometryHa 1274 G4cout << "... Geometry is notified .... " 1275 } 1276 1277 void STCyclotronDetectorConstruction::SetFoil 1278 fMaterialFractionMassFoil.push_back(fractio 1279 G4RunManager::GetRunManager() -> GeometryHa 1280 G4cout << "... Geometry is notified .... " 1281 } 1282 1283 void STCyclotronDetectorConstruction::SetFoil 1284 fNaturalElementNameFoil.push_back(name); 1285 G4RunManager::GetRunManager() -> GeometryHa 1286 G4cout << "... Geometry is notified .... " 1287 } 1288 1289 void STCyclotronDetectorConstruction::SetFoil 1290 fNaturalMaterialFractionMassFoil.push_back( 1291 G4RunManager::GetRunManager() -> GeometryHa 1292 G4cout << "... Geometry is notified .... " 1293 } 1294 1295 G4bool STCyclotronDetectorConstruction::Updat 1296 1297 G4int nElements = fFoil_NComponents; 1298 G4double density = fDensity_foil*g/cm3; 1299 1300 G4Material* material = new G4Material("FFoi 1301 1302 G4double checkFractionMass = 0; 1303 1304 1305 //CHECK THAT NUMBER OF ELEMENTS IN THE MATE 1306 1307 G4int counterElement = 0; 1308 1309 std::ptrdiff_t const sizeElementName = fElem 1310 std::ptrdiff_t const sizeNaturalElementName 1311 1312 1313 1314 if(sizeElementName!=0){ 1315 //ELEMENT LOOP 1316 if(nElements != sizeElementName + sizeNat 1317 G4cout << "Error : the number of elemen 1318 return false; 1319 } 1320 for(int i = 0; i<sizeElementName ; i++){ 1321 1322 checkFractionMass = checkFractionMass + 1323 G4Element* elementi = new G4Element(fEl 1324 1325 G4double checkAbundance = 0.; 1326 //ISOTOPE LOOP FOR THE ELEMENT 1327 1328 std::ptrdiff_t const sizeIsotopeName = 1329 1330 if(fElementNComponentsFoil[i] != sizeIs 1331 G4cout << "Error : the number of isotopes i 1332 return false; 1333 } 1334 for(G4int j=counterElement;j<counterEle 1335 G4double A = fIsotopeAFoil[j]*g/cm3; 1336 G4Isotope* isotopeij = new G4Isotope(fIsoto 1337 checkAbundance = checkAbundance + fElementA 1338 elementi->AddIsotope(isotopeij,fElementAbun 1339 } 1340 if((1.-checkAbundance)>1E-5){ 1341 G4cout << "Error : the total abundance of i 1342 return false; 1343 } 1344 1345 counterElement = counterElement + fElem 1346 material->AddElement(elementi, fMateria 1347 1348 } 1349 } 1350 1351 if(sizeNaturalElementName!=0){ 1352 for(int i=0;i<sizeNaturalElementName;i++) 1353 checkFractionMass = checkFractionMass + 1354 G4NistManager* man = G4NistManager::Ins 1355 G4Element* element = man->FindOrBuildEl 1356 material->AddElement(element, fNaturalM 1357 } 1358 } 1359 1360 if((1.-checkFractionMass)>1E-5){ 1361 G4cout << "Error : the sum of the fractio 1362 return false; 1363 } 1364 1365 fFoil_Material = material; 1366 G4cout << "You succesfully changed the mate 1367 G4cout << "Here is the new material : " << 1368 G4cout << "Number of elements : " << materi 1369 std::ptrdiff_t const sizeMaterial = materia 1370 1371 1372 for(int i = 0; i<sizeMaterial;i++){ 1373 const G4Element* element = material->GetE 1374 G4cout << element->GetName() << " having 1375 1376 std::ptrdiff_t const sizeIsotope = elemen 1377 1378 for(int j=0; j<sizeIsotope; j++){ 1379 const G4Isotope* isotope = element->Get 1380 G4cout << " - " << (element->GetRelativ 1381 } 1382 } 1383 fLogicFoil->SetMaterial(fFoil_Material); 1384 1385 // 1386 fIsotopeNameFoil.clear(); 1387 fIsotopeZFoil.clear(); 1388 fIsotopeNFoil.clear(); 1389 fIsotopeAFoil.clear(); 1390 fElementNameFoil.clear(); 1391 fElementSymboleFoil.clear(); 1392 fElementNComponentsFoil.clear(); 1393 fElementAbundanceFoil.clear(); 1394 fNaturalElementNameFoil.clear(); 1395 fNaturalMaterialFractionMassFoil.clear(); 1396 fMaterialFractionMassFoil.clear(); 1397 // 1398 1399 G4RunManager::GetRunManager() -> GeometryHa 1400 G4cout << "... Geometry is notified .... " 1401 1402 return true; 1403 } 1404 1405 1406 void STCyclotronDetectorConstruction::SetFoil 1407 1408 G4NistManager* nistManager = G4NistManager: 1409 G4Material* foilMaterial = nistManager->Fin 1410 if(fFoil_Material!=foilMaterial){ 1411 1412 if(foilMaterial){ 1413 1414 fFoil_Material = foilMaterial; 1415 fLogicFoil->SetMaterial(fFoil_Material); 1416 1417 G4cout << "The new material of the foil i 1418 1419 } 1420 else{ G4cout << "This material wasn't fou 1421 1422 } 1423 G4RunManager::GetRunManager() -> GeometryHa 1424 G4cout << "... Geometry is notified .... " 1425 1426 } 1427 1428 //SET PARAMETERS FOR THE TARGET 1429 1430 void STCyclotronDetectorConstruction::SetTarg 1431 { 1432 1433 if(fTarget_thickness!=targetThickness){ 1434 if(targetThickness > fTube_length_PART4){ 1435 else { 1436 //Modify the position of the target 1437 fTarget_z_position = fTarget_z_position 1438 fTarget_thickness = targetThickness; 1439 fTarget_z_position = fTarget_z_position 1440 fPhysTarget->SetTranslation(G4ThreeVect 1441 //Modify the thickness of the target 1442 fSolidTarget->SetZHalfLength(0.5*target 1443 G4cout << "The new thickness of the tar 1444 G4cout << "Position 1 = " << GetTargetP 1445 1446 } 1447 } 1448 1449 G4RunManager::GetRunManager() -> GeometryH 1450 G4cout << "... Geometry is notified .... " 1451 } 1452 1453 1454 void STCyclotronDetectorConstruction::SetFoil 1455 { 1456 1457 if(fFoil_thickness != foilThickness){ 1458 1459 1460 //Change de position of the detector part 1461 //Change the position to set it so there 1462 fLayer_z_position_PART3 = fLayer_z_positi 1463 fLayer_z_position_PART4 = fLayer_z_positi 1464 fLayer1_z_position_PART4 = fLayer1_z_posi 1465 fLayer1_z_position_PART5 = fLayer1_z_posi 1466 fLayer2_z_position_PART5 = fLayer2_z_posi 1467 fLayer3_z_position_PART5 = fLayer3_z_posi 1468 fZ_foil_position = fZ_foil_position - 0.5 1469 1470 fFoil_thickness = foilThickness; 1471 1472 //Change the position using the new foil 1473 fLayer_z_position_PART3 = fLayer_z_positi 1474 fLayer_z_position_PART4 = fLayer_z_positi 1475 fLayer1_z_position_PART4 = fLayer1_z_posi 1476 fLayer1_z_position_PART5 = fLayer1_z_posi 1477 fLayer2_z_position_PART5 = fLayer2_z_posi 1478 fLayer3_z_position_PART5 = fLayer3_z_posi 1479 fZ_foil_position = fZ_foil_position + 0.5 1480 1481 fPhysLayer_PART3->SetTranslation(G4ThreeV 1482 fPhysTube_PART3->SetTranslation(G4ThreeVe 1483 fPhysLayer_PART4->SetTranslation(G4ThreeV 1484 fPhysLayer1_PART4->SetTranslation(G4Three 1485 fPhysTube_PART4->SetTranslation(G4ThreeVe 1486 fPhysLayer1_PART5->SetTranslation(G4Three 1487 fPhysLayer2_PART5->SetTranslation(G4Three 1488 fPhysLayer3_PART5->SetTranslation(G4Three 1489 1490 1491 if(fPhysFoil) fPhysFoil->SetTranslation(G 1492 //Change the thickness 1493 if(fSolidFoil) fSolidFoil->SetZHalfLength 1494 G4cout << "The new thickness of the foil 1495 1496 } 1497 1498 G4RunManager::GetRunManager() -> GeometryHa 1499 G4cout << "... Geometry is notified .... " 1500 1501 } 1502 1503 1504