Geant4 Cross Reference |
1 // 1 // 2 // ******************************************* 2 // ******************************************************************** 3 // * License and Disclaimer 3 // * License and Disclaimer * 4 // * 4 // * * 5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of * 6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and * 7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file * 8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These * 9 // * include a list of copyright holders. 9 // * include a list of copyright holders. * 10 // * 10 // * * 11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing * 12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this * 13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, * 14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its * 15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above * 16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. * 17 // * 17 // * * 18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and * 19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. * 20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or * 21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its * 22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your * 23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. * 24 // ******************************************* 24 // ******************************************************************** 25 // 25 // 26 /// \file GB06/src/GB06ParallelWorldForSlices. 26 /// \file GB06/src/GB06ParallelWorldForSlices.cc 27 /// \brief Implementation of the GB06ParallelW 27 /// \brief Implementation of the GB06ParallelWorldForSlices class 28 // 28 // >> 29 // $Id: $ 29 // 30 // 30 #include "GB06ParallelWorldForSlices.hh" 31 #include "GB06ParallelWorldForSlices.hh" 31 32 32 #include "GB06BOptrSplitAndKillByImportance.hh << 33 << 34 #include "G4Box.hh" 33 #include "G4Box.hh" 35 #include "G4LogicalVolume.hh" 34 #include "G4LogicalVolume.hh" 36 #include "G4LogicalVolumeStore.hh" 35 #include "G4LogicalVolumeStore.hh" 37 #include "G4PVPlacement.hh" 36 #include "G4PVPlacement.hh" 38 #include "G4PVReplica.hh" 37 #include "G4PVReplica.hh" 39 #include "G4PhysicalVolumeStore.hh" 38 #include "G4PhysicalVolumeStore.hh" 40 #include "G4SystemOfUnits.hh" << 41 #include "G4ThreeVector.hh" 39 #include "G4ThreeVector.hh" >> 40 #include "G4SystemOfUnits.hh" >> 41 >> 42 #include "GB06BOptrSplitAndKillByImportance.hh" 42 43 43 //....oooOO0OOooo........oooOO0OOooo........oo 44 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 44 45 45 GB06ParallelWorldForSlices::GB06ParallelWorldF 46 GB06ParallelWorldForSlices::GB06ParallelWorldForSlices(G4String worldName) 46 : G4VUserParallelWorld(worldName) 47 : G4VUserParallelWorld(worldName) 47 { << 48 {;} 48 ; << 49 } << 50 49 51 //....oooOO0OOooo........oooOO0OOooo........oo 50 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 52 51 53 GB06ParallelWorldForSlices::~GB06ParallelWorld 52 GB06ParallelWorldForSlices::~GB06ParallelWorldForSlices() 54 { << 53 {;} 55 ; << 56 } << 57 54 58 //....oooOO0OOooo........oooOO0OOooo........oo 55 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 59 56 60 void GB06ParallelWorldForSlices::Construct() 57 void GB06ParallelWorldForSlices::Construct() 61 { 58 { 62 // -- Inform about construction: 59 // -- Inform about construction: 63 // -- (fWorldName is a protected data member 60 // -- (fWorldName is a protected data member of the base parallel world class) 64 G4cout << "Parallel World `" << fWorldName < 61 G4cout << "Parallel World `" << fWorldName << "' constructed." << G4endl; 65 62 66 // ------------------------- 63 // ------------------------- 67 // Build parallel geometry: 64 // Build parallel geometry: 68 // ------------------------- 65 // ------------------------- 69 << 66 70 // -- Obtain clone of mass geometry world fr 67 // -- Obtain clone of mass geometry world from GetWorld() base class utility: 71 G4VPhysicalVolume* physicalParallelWorld = G 68 G4VPhysicalVolume* physicalParallelWorld = GetWorld(); 72 G4LogicalVolume* logicalParallelWorld = phys << 69 G4LogicalVolume* logicalParallelWorld = physicalParallelWorld->GetLogicalVolume(); >> 70 73 71 74 // -- We overlay a sliced geometry on top of 72 // -- We overlay a sliced geometry on top of the block of concrete in the mass geometry 75 // -- (ie, in the detector construction clas 73 // -- (ie, in the detector construction class), using the same dimensions. 76 // -- [Note that this is a choice : we can u 74 // -- [Note that this is a choice : we can use different dimensions and shapes, creating 77 // -- a new solid for that.] 75 // -- a new solid for that.] 78 // -- For this we: 76 // -- For this we: 79 // -- - 1) get back the solid used to cr 77 // -- - 1) get back the solid used to create the concrete shield; 80 // -- - 2) create a new logical volume o 78 // -- - 2) create a new logical volume of same shape than the shield and we place 81 // -- inside the slices 79 // -- inside the slices 82 // -- - 3) place the sliced structure, u 80 // -- - 3) place the sliced structure, using the placement of the physical volume of 83 // -- the concrete shield 81 // -- the concrete shield 84 // -- In all this construction, no materials 82 // -- In all this construction, no materials are used, as only the volumes boundaries 85 // -- are of interest. Note that the absence 83 // -- are of interest. Note that the absence of materials is only possible in parallel 86 // -- geometries. 84 // -- geometries. 87 85 >> 86 88 // -- 1) get back the solid used to create t 87 // -- 1) get back the solid used to create the concrete shield: 89 // ----------------------------------- 88 // ------------------------------------------------------ 90 << 89 91 // -- get back the logical volume of the shi 90 // -- get back the logical volume of the shield, using its name: 92 G4LogicalVolume* shieldLogical = G4LogicalVo << 91 G4LogicalVolume* shieldLogical = 93 << 92 G4LogicalVolumeStore::GetInstance()->GetVolume("shield.logical"); >> 93 94 // -- get back the solid, a G4box in this ca 94 // -- get back the solid, a G4box in this case. We cast the pointer to access later on 95 // -- the G4Box class specific methods: 95 // -- the G4Box class specific methods: 96 auto shieldSolid = (G4Box*)shieldLogical->Ge << 96 G4Box* shieldSolid = (G4Box*) shieldLogical->GetSolid(); 97 << 97 98 // -- we now re-create a logical volume for 98 // -- we now re-create a logical volume for the mother volume of the slices: 99 G4LogicalVolume* motherForSlicesLogical = 99 G4LogicalVolume* motherForSlicesLogical = 100 new G4LogicalVolume(shieldSolid, // its s << 100 new G4LogicalVolume(shieldSolid, // its solid 101 nullptr, // no materi << 101 nullptr, // no material 102 "motherForSlices.logic 102 "motherForSlices.logical"); // its name 103 103 >> 104 >> 105 104 // -- 2) new logical volume of same shape th 106 // -- 2) new logical volume of same shape than the shield and place inside the slices: 105 // ----------------------------------- 107 // ----------------------------------------------------------------------------- 106 << 108 107 // -- We create now the slices; we choose 20 109 // -- We create now the slices; we choose 20 slices: 108 const G4int nSlices(20); 110 const G4int nSlices(20); 109 // -- the solid for slices: 111 // -- the solid for slices: 110 G4double halfSliceZ = shieldSolid->GetZHalfL 112 G4double halfSliceZ = shieldSolid->GetZHalfLength() / nSlices; 111 G4Box* sliceSolid = new G4Box("slice.solid", << 113 G4Box* sliceSolid = new G4Box("slice.solid", 112 shieldSolid->G << 114 shieldSolid->GetXHalfLength(), 113 << 115 shieldSolid->GetYHalfLength(), >> 116 halfSliceZ ); >> 117 114 // -- the logical volume for slices: 118 // -- the logical volume for slices: 115 sliceLogical = new G4LogicalVolume(sliceSoli << 119 G4LogicalVolume* sliceLogical = new G4LogicalVolume(sliceSolid, // its solid 116 nullptr, << 120 nullptr, // no material 117 "slice.lo << 121 "slice.logical"); // its name 118 << 122 119 // -- we use a replica, to place the 20 slic 123 // -- we use a replica, to place the 20 slices in one go, along the Z axis: 120 slicePhysical = new G4PVReplica("slice.physi << 124 new G4PVReplica( "slice.physical", // its name 121 sliceLogical << 125 sliceLogical, // its logical volume 122 motherForSli << 126 motherForSlicesLogical, // its mother volume 123 kZAxis, // << 127 kZAxis, // axis of replication 124 nSlices, // << 128 nSlices, // number of replica 125 2 * halfSlic << 129 2*halfSliceZ); // width of replica 126 << 130 >> 131 127 // -- 3) place the sliced structure, using t 132 // -- 3) place the sliced structure, using the concrete shield placement: 128 // ----------------------------------- 133 // ---------------------------------------------------------------- 129 << 134 130 // -- get back the physical volume of the sh 135 // -- get back the physical volume of the shield, using its name: 131 // -- (note that we know we have only one ph 136 // -- (note that we know we have only one physical volume with this name. If we had 132 // -- several, we should loop by ourselves o 137 // -- several, we should loop by ourselves on the store which is of 133 // -- std::vector<G4VPhysicalVolume*> type.) 138 // -- std::vector<G4VPhysicalVolume*> type.) 134 G4VPhysicalVolume* shieldPhysical = << 139 G4VPhysicalVolume* 135 G4PhysicalVolumeStore::GetInstance()->GetV << 140 shieldPhysical = G4PhysicalVolumeStore::GetInstance()->GetVolume("shield.physical"); 136 << 141 137 // -- get back the translation 142 // -- get back the translation 138 // -- (we don't try to get back the rotation 143 // -- (we don't try to get back the rotation, we know we used nullptr): 139 G4ThreeVector translation = shieldPhysical-> 144 G4ThreeVector translation = shieldPhysical->GetObjectTranslation(); 140 << 145 141 // -- finally, we place the sliced structure 146 // -- finally, we place the sliced structure: 142 new G4PVPlacement(nullptr, // no rotation << 147 new G4PVPlacement( nullptr, // no rotation 143 translation, // translate << 148 translation, // translate as for the shield 144 motherForSlicesLogical, / << 149 motherForSlicesLogical, // its logical volume 145 "motherForSlices.physical" << 150 "motherForSlices.physical", // its name 146 logicalParallelWorld, // << 151 logicalParallelWorld, // its mother volume 147 false, // no boolean oper << 152 false, // no boolean operation 148 0); // copy number << 153 0); // copy number >> 154 149 } 155 } 150 156 151 //....oooOO0OOooo........oooOO0OOooo........oo 157 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 152 158 153 void GB06ParallelWorldForSlices::ConstructSD() 159 void GB06ParallelWorldForSlices::ConstructSD() 154 { 160 { 155 // -- Create the biasing operator: 161 // -- Create the biasing operator: 156 auto biasingOperator = new GB06BOptrSplitAnd << 162 auto biasingOperator = new GB06BOptrSplitAndKillByImportance("neutron","parallelOptr"); 157 // -- Tell it it is active for this parallel 163 // -- Tell it it is active for this parallel geometry, passing the world 158 // -- volume of this geometry : 164 // -- volume of this geometry : 159 biasingOperator->SetParallelWorld(GetWorld() << 165 biasingOperator->SetParallelWorld( GetWorld() ); 160 166 161 // -- Attach to the logical volume where the 167 // -- Attach to the logical volume where the biasing has to be applied: 162 biasingOperator->AttachTo(sliceLogical); << 168 auto slice = G4LogicalVolumeStore::GetInstance()->GetVolume("slice.logical"); >> 169 biasingOperator->AttachTo(slice); 163 170 164 // -- Create a simple "volume importance" ma 171 // -- Create a simple "volume importance" map, linking replica numbers to importances: 165 // -------------------------------------- 172 // -------------------------------------------------------------------------------- 166 // -- we define the map as going from an imp 173 // -- we define the map as going from an importance to 2*importance when going from 167 // -- a slice to the next one, in the Z dire 174 // -- a slice to the next one, in the Z direction. 168 // -- Get back the replica of slices: 175 // -- Get back the replica of slices: >> 176 G4PVReplica* slicePhysical = >> 177 (G4PVReplica*)(G4PhysicalVolumeStore::GetInstance()->GetVolume("slice.physical")); 169 G4int nReplica = slicePhysical->GetMultiplic 178 G4int nReplica = slicePhysical->GetMultiplicity(); 170 // -- We use and fill the map we defined in 179 // -- We use and fill the map we defined in the biasing operator: 171 G4int importance = 1; 180 G4int importance = 1; 172 for (G4int iReplica = 0; iReplica < nReplica << 181 for ( G4int iReplica = 0 ; iReplica < nReplica ; iReplica++ ) 173 (biasingOperator->GetImportanceMap())[iRep << 182 { 174 importance *= 2; << 183 (biasingOperator->GetImportanceMap())[ iReplica ] = importance; 175 } << 184 importance *= 2; >> 185 } >> 186 176 } 187 } 177 188