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 // >> 26 // >> 27 // $Id: G4PVParameterised.cc,v 1.10 2007/04/11 07:56:38 gcosmo Exp $ >> 28 // GEANT4 tag $Name: geant4-08-03 $ >> 29 // 25 // 30 // 26 // class G4PVParameterised implementation << 31 // class G4PVParameterised >> 32 // >> 33 // Implementation 27 // 34 // 28 // 29.07.95, P.Kent - first non-stub version << 29 // ------------------------------------------- 35 // ---------------------------------------------------------------------- 30 36 31 #include "G4PVParameterised.hh" 37 #include "G4PVParameterised.hh" 32 #include "G4VPVParameterisation.hh" 38 #include "G4VPVParameterisation.hh" 33 #include "G4AffineTransform.hh" 39 #include "G4AffineTransform.hh" 34 #include "G4UnitsTable.hh" 40 #include "G4UnitsTable.hh" 35 #include "G4VSolid.hh" 41 #include "G4VSolid.hh" 36 #include "G4LogicalVolume.hh" 42 #include "G4LogicalVolume.hh" 37 43 38 // ------------------------------------------- 44 // ---------------------------------------------------------------------- 39 // Constructor 45 // Constructor 40 // 46 // 41 G4PVParameterised::G4PVParameterised( const G4 47 G4PVParameterised::G4PVParameterised( const G4String& pName, 42 G4 48 G4LogicalVolume* pLogical, 43 G4 << 49 G4VPhysicalVolume* pMother, 44 const EA 50 const EAxis pAxis, 45 const G4 51 const G4int nReplicas, 46 G4 << 52 G4VPVParameterisation *pParam, 47 G4 53 G4bool pSurfChk ) 48 : G4PVReplica(pName, nReplicas, pAxis, pLogica << 54 : G4PVReplica(pName, pLogical, pMother, pAxis, nReplicas, 0, 0), 49 pMotherPhysical != nullptr ? pMo << 50 fparam(pParam) 55 fparam(pParam) 51 { 56 { 52 G4LogicalVolume* motherLogical= pMotherPhysi << 53 pMotherPhysical->GetLogicalVolume() : nu << 54 << 55 SetMotherLogical( motherLogical ); << 56 if( motherLogical != nullptr ) << 57 { << 58 // Registration moved here to ensure that << 59 motherLogical->AddDaughter(this); << 60 } << 61 << 62 #ifdef G4VERBOSE 57 #ifdef G4VERBOSE 63 if ((pMotherPhysical != nullptr) && (pMother << 58 if ((pMother) && (pMother->IsParameterised())) 64 { 59 { 65 std::ostringstream message, hint; << 60 G4cout << "WARNING - G4PVParameterised::G4PVParameterised()" << G4endl 66 message << "A parameterised volume is bein << 61 << " A parameterised volume is being placed" << G4endl 67 << "inside another parameterised v << 62 << " inside another parameterised volume !" << G4endl 68 hint << "To make sure that no overlaps are << 63 << " To make sure that no overlaps are generated," << G4endl 69 << "you should verify the mother repl << 64 << " you should verify the mother replicated shapes" << G4endl 70 << "are of the same type and dimensio << 65 << " are of the same type and dimensions." << G4endl 71 << " Mother physical volume: " << p << 66 << " Mother physical volume: " << pMother->GetName() << G4endl 72 << " Parameterised volume: " << pNa << 67 << " Parameterised volume: " << pName << G4endl 73 << " (To switch this warning off, co << 68 << " (To switch this warning off, compile with G4_NO_VERBOSE)" << G4endl; 74 G4Exception("G4PVParameterised::G4PVParame << 75 JustWarning, message, G4String << 76 } 69 } 77 #endif 70 #endif 78 if (pSurfChk) { CheckOverlaps(); } 71 if (pSurfChk) { CheckOverlaps(); } 79 } 72 } 80 73 81 // ------------------------------------------- 74 // ---------------------------------------------------------------------- 82 // Constructor 75 // Constructor 83 // 76 // 84 G4PVParameterised::G4PVParameterised( const G4 77 G4PVParameterised::G4PVParameterised( const G4String& pName, 85 G4 78 G4LogicalVolume* pLogical, 86 G4 79 G4LogicalVolume* pMotherLogical, 87 const EA 80 const EAxis pAxis, 88 const G4 81 const G4int nReplicas, 89 G4 << 82 G4VPVParameterisation *pParam, 90 G4 83 G4bool pSurfChk ) 91 : G4PVReplica(pName, nReplicas, pAxis, pLogi << 84 : G4PVReplica(pName, pLogical, pMotherLogical, pAxis, nReplicas, 0, 0), 92 fparam(pParam) 85 fparam(pParam) 93 { 86 { 94 SetMotherLogical( pMotherLogical ); << 95 if( pMotherLogical != nullptr ) << 96 { << 97 // Registration moved here to ensure that << 98 pMotherLogical->AddDaughter(this); << 99 } << 100 if (pSurfChk) { CheckOverlaps(); } 87 if (pSurfChk) { CheckOverlaps(); } 101 } 88 } 102 89 103 // ------------------------------------------- 90 // ---------------------------------------------------------------------- 104 // Fake default constructor - sets only member 91 // Fake default constructor - sets only member data and allocates memory 105 // for usage restri 92 // for usage restricted to object persistency. 106 // 93 // 107 G4PVParameterised::G4PVParameterised( __void__ 94 G4PVParameterised::G4PVParameterised( __void__& a ) 108 : G4PVReplica(a) << 95 : G4PVReplica(a), fparam(0) 109 { 96 { 110 } 97 } 111 98 112 // ------------------------------------------- 99 // ---------------------------------------------------------------------- 113 // Destructor 100 // Destructor 114 // 101 // 115 G4PVParameterised::~G4PVParameterised() = defa << 102 G4PVParameterised::~G4PVParameterised() >> 103 { >> 104 } 116 105 117 // ------------------------------------------- 106 // ---------------------------------------------------------------------- 118 // GetParameterisation 107 // GetParameterisation 119 // 108 // 120 G4VPVParameterisation* G4PVParameterised::GetP 109 G4VPVParameterisation* G4PVParameterised::GetParameterisation() const 121 { 110 { 122 return fparam; 111 return fparam; 123 } 112 } 124 113 125 // ------------------------------------------- 114 // ---------------------------------------------------------------------- 126 // IsParameterised 115 // IsParameterised 127 // 116 // 128 G4bool G4PVParameterised::IsParameterised() co 117 G4bool G4PVParameterised::IsParameterised() const 129 { 118 { 130 return true; 119 return true; 131 } 120 } 132 121 133 // ------------------------------------------- 122 // ---------------------------------------------------------------------- 134 // VolumeType << 135 // << 136 EVolume G4PVParameterised::VolumeType() const << 137 { << 138 return kParameterised; << 139 } << 140 << 141 // ------------------------------------------- << 142 // GetReplicationData 123 // GetReplicationData 143 // 124 // 144 void G4PVParameterised::GetReplicationData( EA 125 void G4PVParameterised::GetReplicationData( EAxis& axis, 145 G4 126 G4int& nReplicas, 146 G4 127 G4double& width, 147 G4 128 G4double& offset, 148 G4 129 G4bool& consuming) const 149 { 130 { 150 axis = faxis; 131 axis = faxis; 151 nReplicas = fnReplicas; 132 nReplicas = fnReplicas; 152 width = fwidth; 133 width = fwidth; 153 offset = foffset; 134 offset = foffset; 154 consuming = false; 135 consuming = false; 155 } 136 } 156 137 157 // ------------------------------------------- 138 // ---------------------------------------------------------------------- 158 // SetRegularStructureId 139 // SetRegularStructureId 159 // 140 // 160 void G4PVParameterised::SetRegularStructureId << 141 void G4PVParameterised::SetRegularStructureId( G4int Code ) 161 { 142 { 162 G4PVReplica::SetRegularStructureId( code ); << 143 G4PVReplica::SetRegularStructureId( Code ); 163 // To undertake additional preparation, a de 144 // To undertake additional preparation, a derived volume must 164 // redefine this method, while calling also << 145 // redefine this method, while calling also the above method. 165 } 146 } 166 147 167 148 168 // ------------------------------------------- 149 // ---------------------------------------------------------------------- 169 // CheckOverlaps 150 // CheckOverlaps 170 // 151 // 171 G4bool 152 G4bool 172 G4PVParameterised::CheckOverlaps(G4int res, G4 << 153 G4PVParameterised::CheckOverlaps(G4int res, G4double tol, G4bool verbose) 173 G4bool verbos << 174 { 154 { 175 if (res<=0) { return false; } 155 if (res<=0) { return false; } 176 156 177 G4int trials = 0; << 157 G4VSolid *solidA = 0, *solidB = 0; 178 G4bool retval = false; << 158 G4LogicalVolume *motherLog = GetMotherLogical(); 179 G4VSolid *solidA = nullptr, *solidB = nullpt << 180 G4LogicalVolume* motherLog = GetMotherLogica << 181 G4VSolid *motherSolid = motherLog->GetSolid( 159 G4VSolid *motherSolid = motherLog->GetSolid(); 182 std::vector<G4ThreeVector> points; 160 std::vector<G4ThreeVector> points; 183 161 184 if (verbose) 162 if (verbose) 185 { 163 { 186 G4cout << "Checking overlaps for parameter 164 G4cout << "Checking overlaps for parameterised volume " 187 << GetName() << " ... "; 165 << GetName() << " ... "; 188 } 166 } 189 167 190 for (auto i=0; i<GetMultiplicity(); ++i) << 168 for (G4int i=0; i<GetMultiplicity(); i++) 191 { 169 { 192 solidA = fparam->ComputeSolid(i, this); 170 solidA = fparam->ComputeSolid(i, this); 193 solidA->ComputeDimensions(fparam, i, this) 171 solidA->ComputeDimensions(fparam, i, this); 194 fparam->ComputeTransformation(i, this); 172 fparam->ComputeTransformation(i, this); 195 173 196 // Create the transformation from daughter 174 // Create the transformation from daughter to mother 197 // 175 // 198 G4AffineTransform Tm( GetRotation(), GetTr 176 G4AffineTransform Tm( GetRotation(), GetTranslation() ); 199 177 200 // Generate random points on surface accor 178 // Generate random points on surface according to the given resolution, 201 // transform them to the mother's coordina 179 // transform them to the mother's coordinate system and if no overlaps 202 // with the mother volume, cache them in a 180 // with the mother volume, cache them in a vector for later use with 203 // the daughters 181 // the daughters 204 // 182 // 205 for (auto n=0; n<res; ++n) << 183 for (G4int n=0; n<res; n++) 206 { 184 { 207 G4ThreeVector mp = Tm.TransformPoint(sol 185 G4ThreeVector mp = Tm.TransformPoint(solidA->GetPointOnSurface()); 208 186 209 // Checking overlaps with the mother vol 187 // Checking overlaps with the mother volume 210 // 188 // 211 if (motherSolid->Inside(mp)==kOutside) 189 if (motherSolid->Inside(mp)==kOutside) 212 { 190 { 213 G4double distin = motherSolid->Distanc 191 G4double distin = motherSolid->DistanceToIn(mp); 214 if (distin > tol) 192 if (distin > tol) 215 { 193 { 216 ++trials; retval = true; << 194 G4cout << G4endl; 217 std::ostringstream message; << 195 G4cout << "WARNING - G4PVParameterised::CheckOverlaps()" << G4endl 218 message << "Overlap with mother volu << 196 << " Overlap is detected for volume " 219 << " Overlap is dete << 197 << GetName() << ", parameterised instance: " << i << G4endl 220 << GetName() << ", parameter << 198 << " with its mother volume " 221 << " with its mothe << 199 << motherLog->GetName() << G4endl 222 << motherLog->GetName() << G << 200 << " at mother local point " << mp << ", " 223 << " at mother loca << 201 << "overlapping by at least: " << G4BestUnit(distin, "Length") 224 << "overlapping by at least: << 202 << G4endl; 225 << G4BestUnit(distin, "Lengt << 203 G4Exception("G4PVParameterised::CheckOverlaps()", "InvalidSetup", 226 if (trials>=maxErr) << 204 JustWarning, "Overlap with mother volume !"); 227 { << 205 return true; 228 message << G4endl << 229 << "NOTE: Reached maximum << 230 << "- of overlaps reports << 231 } << 232 G4Exception("G4PVParameterised::Chec << 233 "GeomVol1002", JustWarni << 234 if (trials>=maxErr) { return true; << 235 } 206 } 236 } 207 } 237 points.push_back(mp); 208 points.push_back(mp); 238 } 209 } 239 210 240 // Checking overlaps with each other param 211 // Checking overlaps with each other parameterised instance 241 // 212 // 242 for (auto j=i+1; j<GetMultiplicity(); ++j) << 213 std::vector<G4ThreeVector>::iterator pos; >> 214 for (G4int j=i+1; j<GetMultiplicity(); j++) 243 { 215 { 244 solidB = fparam->ComputeSolid(j,this); 216 solidB = fparam->ComputeSolid(j,this); 245 solidB->ComputeDimensions(fparam, j, thi 217 solidB->ComputeDimensions(fparam, j, this); 246 fparam->ComputeTransformation(j, this); 218 fparam->ComputeTransformation(j, this); 247 219 248 // Create the transformation for daughte 220 // Create the transformation for daughter volume 249 // 221 // 250 G4AffineTransform Td( GetRotation(), Get 222 G4AffineTransform Td( GetRotation(), GetTranslation() ); 251 223 252 for (const auto & point : points) << 224 for (pos=points.begin(); pos!=points.end(); pos++) 253 { 225 { 254 // Transform each point according to d 226 // Transform each point according to daughter's frame 255 // 227 // 256 G4ThreeVector md = Td.InverseTransform << 228 G4ThreeVector md = Td.Invert().TransformPoint(*pos); 257 229 258 if (solidB->Inside(md)==kInside) 230 if (solidB->Inside(md)==kInside) 259 { 231 { 260 G4double distout = solidB->DistanceT 232 G4double distout = solidB->DistanceToOut(md); 261 if (distout > tol) 233 if (distout > tol) 262 { 234 { 263 ++trials; retval = true; << 235 G4cout << G4endl; 264 std::ostringstream message; << 236 G4cout << "WARNING - G4PVParameterised::CheckOverlaps()" << G4endl 265 message << "Overlap within paramet << 237 << " Overlap is detected for volume " 266 << " Overlap is d << 238 << GetName() << ", parameterised instance: " << i << G4endl 267 << GetName() << ", paramet << 239 << " with parameterised volume instance: " << j 268 << " with paramet << 240 << G4endl 269 << G4endl << 241 << " at local point " << md << ", " 270 << " at local poi << 242 << "overlapping by at least: " 271 << "overlapping by at leas << 243 << G4BestUnit(distout, "Length") 272 << G4BestUnit(distout, "Le << 244 << ", related to volume instance: " << j << "." << G4endl; 273 << ", related to volume in << 245 G4Exception("G4PVParameterised::CheckOverlaps()", "InvalidSetup", 274 if (trials>=maxErr) << 246 JustWarning, "Overlap within parameterised volumes !"); 275 { << 247 return true; 276 message << G4endl << 277 << "NOTE: Reached maximu << 278 << "- of overlaps report << 279 } << 280 G4Exception("G4PVParameterised::Ch << 281 "GeomVol1002", JustWar << 282 if (trials>=maxErr) { return true << 283 } 248 } 284 } 249 } 285 } 250 } 286 } 251 } 287 } 252 } 288 if (verbose) 253 if (verbose) 289 { 254 { 290 G4cout << "OK! " << G4endl; 255 G4cout << "OK! " << G4endl; 291 } 256 } 292 257 293 return retval; << 258 return false; 294 } 259 } 295 260