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 // G4ParameterisationCons[Rho/Phi/Z] implement << 26 // >> 27 // $Id: G4ParameterisationCons.cc 66356 2012-12-18 09:02:32Z gcosmo $ >> 28 // >> 29 // class G4ParameterisationCons Implementation file 27 // 30 // 28 // 26.05.03 - P.Arce, Initial version 31 // 26.05.03 - P.Arce, Initial version 29 // 08.04.04 - I.Hrivnacova, Implemented reflec 32 // 08.04.04 - I.Hrivnacova, Implemented reflection 30 // 21.04.10 - M.Asai, Added gaps 33 // 21.04.10 - M.Asai, Added gaps 31 // ------------------------------------------- 34 // -------------------------------------------------------------------- 32 35 33 #include "G4ParameterisationCons.hh" 36 #include "G4ParameterisationCons.hh" 34 37 35 #include <iomanip> 38 #include <iomanip> 36 #include "G4ThreeVector.hh" 39 #include "G4ThreeVector.hh" 37 #include "G4RotationMatrix.hh" 40 #include "G4RotationMatrix.hh" 38 #include "G4VPhysicalVolume.hh" 41 #include "G4VPhysicalVolume.hh" 39 #include "G4LogicalVolume.hh" 42 #include "G4LogicalVolume.hh" 40 #include "G4ReflectedSolid.hh" 43 #include "G4ReflectedSolid.hh" 41 #include "G4Cons.hh" 44 #include "G4Cons.hh" 42 45 43 //-------------------------------------------- 46 //-------------------------------------------------------------------------- 44 G4VParameterisationCons:: 47 G4VParameterisationCons:: 45 G4VParameterisationCons( EAxis axis, G4int nDi 48 G4VParameterisationCons( EAxis axis, G4int nDiv, G4double width, 46 G4double offset, G4VSo 49 G4double offset, G4VSolid* msolid, 47 DivisionType divType ) 50 DivisionType divType ) 48 : G4VDivisionParameterisation( axis, nDiv, 51 : G4VDivisionParameterisation( axis, nDiv, width, offset, divType, msolid ) 49 { 52 { 50 auto msol = (G4Cons*)(msolid); << 53 G4Cons* msol = (G4Cons*)(msolid); 51 if (msolid->GetEntityType() == "G4ReflectedS 54 if (msolid->GetEntityType() == "G4ReflectedSolid") 52 { 55 { 53 // Get constituent solid 56 // Get constituent solid 54 G4VSolid* mConstituentSolid 57 G4VSolid* mConstituentSolid 55 = ((G4ReflectedSolid*)msolid)->GetConst 58 = ((G4ReflectedSolid*)msolid)->GetConstituentMovedSolid(); 56 msol = (G4Cons*)(mConstituentSolid); 59 msol = (G4Cons*)(mConstituentSolid); 57 60 58 // Create a new solid with inversed parame 61 // Create a new solid with inversed parameters 59 auto newSolid << 62 G4Cons* newSolid 60 = new G4Cons(msol->GetName(), 63 = new G4Cons(msol->GetName(), 61 msol->GetInnerRadiusPlusZ() 64 msol->GetInnerRadiusPlusZ(), msol->GetOuterRadiusPlusZ(), 62 msol->GetInnerRadiusMinusZ( 65 msol->GetInnerRadiusMinusZ(), msol->GetOuterRadiusMinusZ(), 63 msol->GetZHalfLength(), 66 msol->GetZHalfLength(), 64 msol->GetStartPhiAngle(), m 67 msol->GetStartPhiAngle(), msol->GetDeltaPhiAngle()); 65 msol = newSolid; 68 msol = newSolid; 66 fmotherSolid = newSolid; 69 fmotherSolid = newSolid; 67 fReflectedSolid = true; 70 fReflectedSolid = true; 68 fDeleteSolid = true; 71 fDeleteSolid = true; 69 } 72 } 70 } 73 } 71 74 72 //-------------------------------------------- 75 //------------------------------------------------------------------------ 73 G4VParameterisationCons::~G4VParameterisationC << 76 G4VParameterisationCons::~G4VParameterisationCons() >> 77 { >> 78 } 74 79 75 //-------------------------------------------- 80 //-------------------------------------------------------------------------- 76 G4ParameterisationConsRho:: 81 G4ParameterisationConsRho:: 77 G4ParameterisationConsRho( EAxis axis, G4int n 82 G4ParameterisationConsRho( EAxis axis, G4int nDiv, 78 G4double width, G4d 83 G4double width, G4double offset, 79 G4VSolid* msolid, D 84 G4VSolid* msolid, DivisionType divType ) 80 : G4VParameterisationCons( axis, nDiv, widt 85 : G4VParameterisationCons( axis, nDiv, width, offset, msolid, divType ) 81 { 86 { 82 CheckParametersValidity(); 87 CheckParametersValidity(); 83 SetType( "DivisionConsRho" ); 88 SetType( "DivisionConsRho" ); 84 89 85 auto msol = (G4Cons*)(fmotherSolid); << 90 G4Cons* msol = (G4Cons*)(fmotherSolid); 86 if( msol->GetInnerRadiusPlusZ() == 0. ) 91 if( msol->GetInnerRadiusPlusZ() == 0. ) 87 { 92 { 88 std::ostringstream message; 93 std::ostringstream message; 89 message << "OuterRadiusMinusZ = 0" << G4en 94 message << "OuterRadiusMinusZ = 0" << G4endl 90 << "Width is calculated as that of 95 << "Width is calculated as that of OuterRadiusMinusZ !"; 91 G4Exception("G4ParameterisationConsRho::G4 96 G4Exception("G4ParameterisationConsRho::G4ParameterisationConsRho()", 92 "GeomDiv1001", JustWarning, me 97 "GeomDiv1001", JustWarning, message); 93 } 98 } 94 99 95 if( divType == DivWIDTH ) 100 if( divType == DivWIDTH ) 96 { 101 { 97 fnDiv = CalculateNDiv( msol->GetOuterRadiu 102 fnDiv = CalculateNDiv( msol->GetOuterRadiusMinusZ() 98 - msol->GetInnerRadiu 103 - msol->GetInnerRadiusMinusZ(), width, offset ); 99 } 104 } 100 else if( divType == DivNDIV ) 105 else if( divType == DivNDIV ) 101 { 106 { 102 auto mconsol = (G4Cons*)(msolid); << 107 G4Cons* mconsol = (G4Cons*)(msolid); 103 fwidth = CalculateWidth( mconsol->GetOuter 108 fwidth = CalculateWidth( mconsol->GetOuterRadiusMinusZ() 104 - mconsol->GetInner 109 - mconsol->GetInnerRadiusMinusZ(), nDiv, offset ); 105 } 110 } 106 111 107 #ifdef G4DIVDEBUG 112 #ifdef G4DIVDEBUG 108 if( verbose >= 1 ) 113 if( verbose >= 1 ) 109 { 114 { 110 G4cout << " G4ParameterisationConsRho - no 115 G4cout << " G4ParameterisationConsRho - no divisions " << fnDiv << " = " 111 << nDiv << G4endl 116 << nDiv << G4endl 112 << " Offset " << foffset << " = " < 117 << " Offset " << foffset << " = " << offset 113 << " - Width " << fwidth << " = " < 118 << " - Width " << fwidth << " = " << width << G4endl; 114 } 119 } 115 #endif 120 #endif 116 } 121 } 117 122 118 //-------------------------------------------- 123 //-------------------------------------------------------------------------- 119 G4ParameterisationConsRho::~G4Parameterisation << 124 G4ParameterisationConsRho::~G4ParameterisationConsRho() >> 125 { >> 126 } 120 127 121 //-------------------------------------------- 128 //------------------------------------------------------------------------ 122 G4double G4ParameterisationConsRho::GetMaxPara 129 G4double G4ParameterisationConsRho::GetMaxParameter() const 123 { 130 { 124 auto msol = (G4Cons*)(fmotherSolid); << 131 G4Cons* msol = (G4Cons*)(fmotherSolid); 125 return msol->GetOuterRadiusMinusZ() - msol-> 132 return msol->GetOuterRadiusMinusZ() - msol->GetInnerRadiusMinusZ(); 126 } 133 } 127 134 128 //-------------------------------------------- 135 //-------------------------------------------------------------------------- 129 void 136 void 130 G4ParameterisationConsRho:: 137 G4ParameterisationConsRho:: 131 ComputeTransformation( const G4int, G4VPhysica 138 ComputeTransformation( const G4int, G4VPhysicalVolume *physVol ) const 132 { 139 { 133 //----- translation 140 //----- translation 134 G4ThreeVector origin(0.,0.,0.); 141 G4ThreeVector origin(0.,0.,0.); 135 //----- set translation 142 //----- set translation 136 physVol->SetTranslation( origin ); 143 physVol->SetTranslation( origin ); 137 144 138 //----- calculate rotation matrix: unit 145 //----- calculate rotation matrix: unit 139 146 140 #ifdef G4DIVDEBUG 147 #ifdef G4DIVDEBUG 141 if( verbose >= 2 ) 148 if( verbose >= 2 ) 142 { 149 { 143 G4cout << " G4ParameterisationConsRho " < 150 G4cout << " G4ParameterisationConsRho " << G4endl 144 << " Offset: " << foffset 151 << " Offset: " << foffset 145 << " - Width: " << fwidth << G4endl 152 << " - Width: " << fwidth << G4endl; 146 } 153 } 147 #endif 154 #endif 148 155 149 ChangeRotMatrix( physVol ); 156 ChangeRotMatrix( physVol ); 150 157 151 #ifdef G4DIVDEBUG 158 #ifdef G4DIVDEBUG 152 if( verbose >= 2 ) 159 if( verbose >= 2 ) 153 { 160 { 154 G4cout << std::setprecision(8) << " G4Para 161 G4cout << std::setprecision(8) << " G4ParameterisationConsRho" << G4endl 155 << " Position: " << origin << " - W 162 << " Position: " << origin << " - Width: " << fwidth 156 << " - Axis: " << faxis << G4endl; 163 << " - Axis: " << faxis << G4endl; 157 } 164 } 158 #endif 165 #endif 159 } 166 } 160 167 161 //-------------------------------------------- 168 //-------------------------------------------------------------------------- 162 void 169 void 163 G4ParameterisationConsRho:: 170 G4ParameterisationConsRho:: 164 ComputeDimensions( G4Cons& cons, const G4int c 171 ComputeDimensions( G4Cons& cons, const G4int copyNo, 165 const G4VPhysicalVolume* ) 172 const G4VPhysicalVolume* ) const 166 { 173 { 167 auto msol = (G4Cons*)(fmotherSolid); << 174 G4Cons* msol = (G4Cons*)(fmotherSolid); 168 175 169 G4double pRMin1 = msol->GetInnerRadiusMinusZ << 176 G4double pRMin1 = msol->GetInnerRadiusMinusZ() + foffset + fwidth * copyNo; 170 G4double pRMax1 = msol->GetInnerRadiusMinusZ << 177 G4double pRMax1 = msol->GetInnerRadiusMinusZ() + foffset + fwidth * (copyNo+1); 171 178 172 //width at Z Plus 179 //width at Z Plus 173 //- G4double fwidthPlus = 180 //- G4double fwidthPlus = 174 // fwidth * ( msol->GetOuterRadiusPlusZ()/ 181 // fwidth * ( msol->GetOuterRadiusPlusZ()/ msol->GetInnerRadiusPlusZ()) 175 //- / ( msol->GetOuterRadiusMinusZ() 182 //- / ( msol->GetOuterRadiusMinusZ() - msol->GetInnerRadiusMinusZ()); 176 G4double fwidthPlus = CalculateWidth( msol-> 183 G4double fwidthPlus = CalculateWidth( msol->GetOuterRadiusPlusZ() 177 - msol->GetInnerRad 184 - msol->GetInnerRadiusPlusZ(), fnDiv, foffset ); 178 G4double pRMin2 = msol->GetInnerRadiusPlusZ( 185 G4double pRMin2 = msol->GetInnerRadiusPlusZ() 179 + foffset + fwidthPlus * cop 186 + foffset + fwidthPlus * copyNo; 180 G4double pRMax2 = msol->GetInnerRadiusPlusZ( 187 G4double pRMax2 = msol->GetInnerRadiusPlusZ() 181 + foffset + fwidthPlus * (co 188 + foffset + fwidthPlus * (copyNo+1); 182 G4double pDz = msol->GetZHalfLength(); 189 G4double pDz = msol->GetZHalfLength(); 183 190 184 G4double d_half_gap = fhgap * pRMax2 / pRMax 191 G4double d_half_gap = fhgap * pRMax2 / pRMax1; 185 //- already rotated double pSR = foffset + 192 //- already rotated double pSR = foffset + copyNo*fwidth; 186 G4double pSPhi = msol->GetStartPhiAngle(); 193 G4double pSPhi = msol->GetStartPhiAngle(); 187 G4double pDPhi = msol->GetDeltaPhiAngle();; 194 G4double pDPhi = msol->GetDeltaPhiAngle();; 188 195 189 cons.SetInnerRadiusMinusZ( pRMin1 + fhgap ); 196 cons.SetInnerRadiusMinusZ( pRMin1 + fhgap ); 190 cons.SetOuterRadiusMinusZ( pRMax1 - fhgap ); 197 cons.SetOuterRadiusMinusZ( pRMax1 - fhgap ); 191 cons.SetInnerRadiusPlusZ( pRMin2 + d_half_ga 198 cons.SetInnerRadiusPlusZ( pRMin2 + d_half_gap ); 192 cons.SetOuterRadiusPlusZ( pRMax2 - d_half_ga 199 cons.SetOuterRadiusPlusZ( pRMax2 - d_half_gap ); 193 cons.SetZHalfLength( pDz ); 200 cons.SetZHalfLength( pDz ); 194 cons.SetStartPhiAngle( pSPhi, false ); 201 cons.SetStartPhiAngle( pSPhi, false ); 195 cons.SetDeltaPhiAngle( pDPhi ); 202 cons.SetDeltaPhiAngle( pDPhi ); 196 203 197 #ifdef G4DIVDEBUG 204 #ifdef G4DIVDEBUG 198 if( verbose >= 2 ) 205 if( verbose >= 2 ) 199 { 206 { 200 G4cout << " G4ParameterisationConsRho::Com 207 G4cout << " G4ParameterisationConsRho::ComputeDimensions()" << G4endl 201 << " pRMin: " << pRMin1 << " - pRMa 208 << " pRMin: " << pRMin1 << " - pRMax: " << pRMax1 << G4endl; 202 if( verbose >= 4 ) cons.DumpInfo(); 209 if( verbose >= 4 ) cons.DumpInfo(); 203 } 210 } 204 #endif 211 #endif 205 } 212 } 206 213 207 //-------------------------------------------- 214 //-------------------------------------------------------------------------- 208 G4ParameterisationConsPhi:: 215 G4ParameterisationConsPhi:: 209 G4ParameterisationConsPhi( EAxis axis, G4int n 216 G4ParameterisationConsPhi( EAxis axis, G4int nDiv, 210 G4double width, G4d 217 G4double width, G4double offset, 211 G4VSolid* msolid, D 218 G4VSolid* msolid, DivisionType divType ) 212 : G4VParameterisationCons( axis, nDiv, widt 219 : G4VParameterisationCons( axis, nDiv, width, offset, msolid, divType ) 213 { 220 { 214 CheckParametersValidity(); 221 CheckParametersValidity(); 215 SetType( "DivisionConsPhi" ); 222 SetType( "DivisionConsPhi" ); 216 223 217 auto msol = (G4Cons*)(fmotherSolid); << 224 G4Cons* msol = (G4Cons*)(fmotherSolid); 218 if( divType == DivWIDTH ) 225 if( divType == DivWIDTH ) 219 { 226 { 220 fnDiv = CalculateNDiv( msol->GetDeltaPhiAn 227 fnDiv = CalculateNDiv( msol->GetDeltaPhiAngle(), width, offset ); 221 } 228 } 222 else if( divType == DivNDIV ) 229 else if( divType == DivNDIV ) 223 { 230 { 224 fwidth = CalculateWidth( msol->GetDeltaPhi 231 fwidth = CalculateWidth( msol->GetDeltaPhiAngle(), nDiv, offset ); 225 } 232 } 226 233 227 #ifdef G4DIVDEBUG 234 #ifdef G4DIVDEBUG 228 if( verbose >= 1 ) 235 if( verbose >= 1 ) 229 { 236 { 230 G4cout << " G4ParameterisationConsPhi no d 237 G4cout << " G4ParameterisationConsPhi no divisions " << fnDiv << " = " 231 << nDiv << G4endl 238 << nDiv << G4endl 232 << " Offset " << foffset << " = " < 239 << " Offset " << foffset << " = " << offset << G4endl 233 << " Width " << fwidth << " = " << 240 << " Width " << fwidth << " = " << width << G4endl; 234 } 241 } 235 #endif 242 #endif 236 } 243 } 237 244 238 //-------------------------------------------- 245 //-------------------------------------------------------------------------- 239 G4ParameterisationConsPhi::~G4Parameterisation << 246 G4ParameterisationConsPhi::~G4ParameterisationConsPhi() >> 247 { >> 248 } 240 249 241 //-------------------------------------------- 250 //------------------------------------------------------------------------ 242 G4double G4ParameterisationConsPhi::GetMaxPara 251 G4double G4ParameterisationConsPhi::GetMaxParameter() const 243 { 252 { 244 auto msol = (G4Cons*)(fmotherSolid); << 253 G4Cons* msol = (G4Cons*)(fmotherSolid); 245 return msol->GetDeltaPhiAngle(); 254 return msol->GetDeltaPhiAngle(); 246 } 255 } 247 256 248 //-------------------------------------------- 257 //-------------------------------------------------------------------------- 249 void 258 void 250 G4ParameterisationConsPhi:: 259 G4ParameterisationConsPhi:: 251 ComputeTransformation( const G4int copyNo, G4V 260 ComputeTransformation( const G4int copyNo, G4VPhysicalVolume *physVol ) const 252 { 261 { 253 //----- translation 262 //----- translation 254 G4ThreeVector origin(0.,0.,0.); 263 G4ThreeVector origin(0.,0.,0.); 255 //----- set translation 264 //----- set translation 256 physVol->SetTranslation( origin ); 265 physVol->SetTranslation( origin ); 257 266 258 //----- calculate rotation matrix (so that a 267 //----- calculate rotation matrix (so that all volumes point to the centre) 259 G4double posi = foffset + copyNo*fwidth; 268 G4double posi = foffset + copyNo*fwidth; 260 269 261 #ifdef G4DIVDEBUG 270 #ifdef G4DIVDEBUG 262 if( verbose >= 2 ) 271 if( verbose >= 2 ) 263 { 272 { 264 G4cout << " G4ParameterisationConsPhi - po << 273 G4cout << " G4ParameterisationConsPhi - position: " << posi/deg << G4endl 265 << " Origin: " << origin << " copyN 274 << " Origin: " << origin << " copyNo: " << copyNo 266 << " - foffset: " << foffset/CLHEP: << 275 << " - foffset: " << foffset/deg 267 << " - fwidth: " << fwidth/CLHEP::d << 276 << " - fwidth: " << fwidth/deg << G4endl 268 << " - Axis: " << faxis << G4endl; 277 << " - Axis: " << faxis << G4endl; 269 } 278 } 270 #endif 279 #endif 271 280 272 ChangeRotMatrix( physVol, -posi ); 281 ChangeRotMatrix( physVol, -posi ); 273 } 282 } 274 283 275 //-------------------------------------------- 284 //-------------------------------------------------------------------------- 276 void 285 void 277 G4ParameterisationConsPhi:: 286 G4ParameterisationConsPhi:: 278 ComputeDimensions( G4Cons& cons, const G4int, 287 ComputeDimensions( G4Cons& cons, const G4int, 279 const G4VPhysicalVolume* ) 288 const G4VPhysicalVolume* ) const 280 { 289 { 281 auto msol = (G4Cons*)(fmotherSolid); << 290 G4Cons* msol = (G4Cons*)(fmotherSolid); 282 291 283 G4double pRMin1 = msol->GetInnerRadiusMinusZ 292 G4double pRMin1 = msol->GetInnerRadiusMinusZ(); 284 G4double pRMax1 = msol->GetOuterRadiusMinusZ 293 G4double pRMax1 = msol->GetOuterRadiusMinusZ(); 285 G4double pRMin2 = msol->GetInnerRadiusPlusZ( 294 G4double pRMin2 = msol->GetInnerRadiusPlusZ(); 286 G4double pRMax2 = msol->GetOuterRadiusPlusZ( 295 G4double pRMax2 = msol->GetOuterRadiusPlusZ(); 287 G4double pDz = msol->GetZHalfLength(); 296 G4double pDz = msol->GetZHalfLength(); 288 297 289 //- already rotated double pSPhi = foffset 298 //- already rotated double pSPhi = foffset + copyNo*fwidth; 290 G4double pSPhi = foffset + msol->GetStartPhi 299 G4double pSPhi = foffset + msol->GetStartPhiAngle() + fhgap; 291 G4double pDPhi = fwidth - 2.*fhgap; 300 G4double pDPhi = fwidth - 2.*fhgap; 292 301 293 cons.SetInnerRadiusMinusZ( pRMin1 ); 302 cons.SetInnerRadiusMinusZ( pRMin1 ); 294 cons.SetOuterRadiusMinusZ( pRMax1 ); 303 cons.SetOuterRadiusMinusZ( pRMax1 ); 295 cons.SetInnerRadiusPlusZ( pRMin2 ); 304 cons.SetInnerRadiusPlusZ( pRMin2 ); 296 cons.SetOuterRadiusPlusZ( pRMax2 ); 305 cons.SetOuterRadiusPlusZ( pRMax2 ); 297 cons.SetZHalfLength( pDz ); 306 cons.SetZHalfLength( pDz ); 298 cons.SetStartPhiAngle( pSPhi, false ); 307 cons.SetStartPhiAngle( pSPhi, false ); 299 cons.SetDeltaPhiAngle( pDPhi ); 308 cons.SetDeltaPhiAngle( pDPhi ); 300 309 301 #ifdef G4DIVDEBUG 310 #ifdef G4DIVDEBUG 302 if( verbose >= 2 ) 311 if( verbose >= 2 ) 303 { 312 { 304 G4cout << " G4ParameterisationConsPhi::Com 313 G4cout << " G4ParameterisationConsPhi::ComputeDimensions" << G4endl 305 << " pSPhi: " << pSPhi << " - pDPhi 314 << " pSPhi: " << pSPhi << " - pDPhi: " << pDPhi << G4endl; 306 if( verbose >= 4 ) cons.DumpInfo(); 315 if( verbose >= 4 ) cons.DumpInfo(); 307 } 316 } 308 #endif 317 #endif 309 } 318 } 310 319 311 //-------------------------------------------- 320 //-------------------------------------------------------------------------- 312 G4ParameterisationConsZ:: 321 G4ParameterisationConsZ:: 313 G4ParameterisationConsZ( EAxis axis, G4int nDi 322 G4ParameterisationConsZ( EAxis axis, G4int nDiv, 314 G4double width, G4dou 323 G4double width, G4double offset, 315 G4VSolid* msolid, Div 324 G4VSolid* msolid, DivisionType divType ) 316 : G4VParameterisationCons( axis, nDiv, widt 325 : G4VParameterisationCons( axis, nDiv, width, offset, msolid, divType ) 317 { 326 { 318 CheckParametersValidity(); 327 CheckParametersValidity(); 319 SetType( "DivisionConsZ" ); 328 SetType( "DivisionConsZ" ); 320 329 321 auto msol = (G4Cons*)(fmotherSolid); << 330 G4Cons* msol = (G4Cons*)(fmotherSolid); 322 if( divType == DivWIDTH ) 331 if( divType == DivWIDTH ) 323 { 332 { 324 fnDiv = CalculateNDiv( 2*msol->GetZHalfLen 333 fnDiv = CalculateNDiv( 2*msol->GetZHalfLength(), width, offset ); 325 } 334 } 326 else if( divType == DivNDIV ) 335 else if( divType == DivNDIV ) 327 { 336 { 328 fwidth = CalculateWidth( 2*msol->GetZHalfL 337 fwidth = CalculateWidth( 2*msol->GetZHalfLength(), nDiv, offset ); 329 } 338 } 330 339 331 #ifdef G4DIVDEBUG 340 #ifdef G4DIVDEBUG 332 if( verbose >= 1 ) 341 if( verbose >= 1 ) 333 { 342 { 334 G4cout << " G4ParameterisationConsZ: # div 343 G4cout << " G4ParameterisationConsZ: # divisions " << fnDiv << " = " 335 << nDiv << G4endl 344 << nDiv << G4endl 336 << " Offset " << foffset << " = " < 345 << " Offset " << foffset << " = " << offset << G4endl 337 << " Width " << fwidth << " = " << 346 << " Width " << fwidth << " = " << width << G4endl 338 << " - Axis: " << faxis << G4endl; 347 << " - Axis: " << faxis << G4endl; 339 } 348 } 340 #endif 349 #endif 341 } 350 } 342 351 343 //-------------------------------------------- 352 //-------------------------------------------------------------------------- 344 G4ParameterisationConsZ::~G4ParameterisationCo << 353 G4ParameterisationConsZ::~G4ParameterisationConsZ() >> 354 { >> 355 } 345 356 346 //-------------------------------------------- 357 //------------------------------------------------------------------------ 347 G4double G4ParameterisationConsZ::GetMaxParame 358 G4double G4ParameterisationConsZ::GetMaxParameter() const 348 { 359 { 349 auto msol = (G4Cons*)(fmotherSolid); << 360 G4Cons* msol = (G4Cons*)(fmotherSolid); 350 return 2*msol->GetZHalfLength(); 361 return 2*msol->GetZHalfLength(); 351 } 362 } 352 363 353 //-------------------------------------------- 364 //-------------------------------------------------------------------------- 354 void 365 void 355 G4ParameterisationConsZ:: 366 G4ParameterisationConsZ:: 356 ComputeTransformation( const G4int copyNo, G4V 367 ComputeTransformation( const G4int copyNo, G4VPhysicalVolume* physVol ) const 357 { 368 { 358 //----- set translation: along Z axis 369 //----- set translation: along Z axis 359 auto motherCons = (G4Cons*)(GetMotherSolid() << 370 G4Cons* motherCons = (G4Cons*)(GetMotherSolid()); 360 G4double posi = - motherCons->GetZHalfLength 371 G4double posi = - motherCons->GetZHalfLength() + OffsetZ() 361 + fwidth/2 + copyNo*fwidth; 372 + fwidth/2 + copyNo*fwidth; 362 G4ThreeVector origin(0.,0.,posi); 373 G4ThreeVector origin(0.,0.,posi); 363 physVol->SetTranslation( origin ); 374 physVol->SetTranslation( origin ); 364 375 365 //----- calculate rotation matrix: unit 376 //----- calculate rotation matrix: unit 366 377 367 #ifdef G4DIVDEBUG 378 #ifdef G4DIVDEBUG 368 if( verbose >= 2 ) 379 if( verbose >= 2 ) 369 { 380 { 370 G4cout << " G4ParameterisationConsZ::Compu 381 G4cout << " G4ParameterisationConsZ::ComputeTransformation()" << G4endl 371 << " Origin: " << origin << " - cop 382 << " Origin: " << origin << " - copyNo: " << copyNo << G4endl 372 << " foffset: " << foffset << " - f 383 << " foffset: " << foffset << " - fwidth: " << fwidth 373 << G4endl; 384 << G4endl; 374 } 385 } 375 #endif 386 #endif 376 387 377 ChangeRotMatrix( physVol ); 388 ChangeRotMatrix( physVol ); 378 } 389 } 379 390 380 391 381 //-------------------------------------------- 392 //-------------------------------------------------------------------------- 382 void 393 void 383 G4ParameterisationConsZ:: 394 G4ParameterisationConsZ:: 384 ComputeDimensions( G4Cons& cons, const G4int c 395 ComputeDimensions( G4Cons& cons, const G4int copyNo, 385 const G4VPhysicalVolume* ) 396 const G4VPhysicalVolume* ) const 386 { 397 { 387 auto msol = (G4Cons*)(fmotherSolid); << 398 G4Cons* msol = (G4Cons*)(fmotherSolid); 388 399 389 G4double mHalfLength = msol->GetZHalfLength( 400 G4double mHalfLength = msol->GetZHalfLength() - fhgap; 390 G4double aRInner = (msol->GetInnerRadiusPlus 401 G4double aRInner = (msol->GetInnerRadiusPlusZ() 391 - msol->GetInnerRadiusMinus 402 - msol->GetInnerRadiusMinusZ()) / (2*mHalfLength); 392 G4double bRInner = (msol->GetInnerRadiusPlus 403 G4double bRInner = (msol->GetInnerRadiusPlusZ() 393 + msol->GetInnerRadiusMinus 404 + msol->GetInnerRadiusMinusZ()) / 2; 394 G4double aROuter = (msol->GetOuterRadiusPlus 405 G4double aROuter = (msol->GetOuterRadiusPlusZ() 395 - msol->GetOuterRadiusMinus 406 - msol->GetOuterRadiusMinusZ()) / (2*mHalfLength); 396 G4double bROuter = (msol->GetOuterRadiusPlus 407 G4double bROuter = (msol->GetOuterRadiusPlusZ() 397 + msol->GetOuterRadiusMinus 408 + msol->GetOuterRadiusMinusZ()) / 2; 398 G4double xMinusZ = -mHalfLength + OffsetZ() 409 G4double xMinusZ = -mHalfLength + OffsetZ() + fwidth*copyNo + fhgap; 399 G4double xPlusZ = -mHalfLength + OffsetZ() 410 G4double xPlusZ = -mHalfLength + OffsetZ() + fwidth*(copyNo+1) - fhgap; 400 cons.SetInnerRadiusMinusZ( aRInner * xMinusZ 411 cons.SetInnerRadiusMinusZ( aRInner * xMinusZ + bRInner ); 401 cons.SetOuterRadiusMinusZ( aROuter * xMinusZ 412 cons.SetOuterRadiusMinusZ( aROuter * xMinusZ + bROuter ); 402 cons.SetInnerRadiusPlusZ( aRInner * xPlusZ + 413 cons.SetInnerRadiusPlusZ( aRInner * xPlusZ + bRInner ); 403 cons.SetOuterRadiusPlusZ( aROuter * xPlusZ + 414 cons.SetOuterRadiusPlusZ( aROuter * xPlusZ + bROuter ); 404 415 405 G4double pDz = fwidth / 2. - fhgap; 416 G4double pDz = fwidth / 2. - fhgap; 406 G4double pSPhi = msol->GetStartPhiAngle(); 417 G4double pSPhi = msol->GetStartPhiAngle(); 407 G4double pDPhi = msol->GetDeltaPhiAngle(); 418 G4double pDPhi = msol->GetDeltaPhiAngle(); 408 419 409 cons.SetZHalfLength( pDz ); 420 cons.SetZHalfLength( pDz ); 410 cons.SetStartPhiAngle( pSPhi, false ); 421 cons.SetStartPhiAngle( pSPhi, false ); 411 cons.SetDeltaPhiAngle( pDPhi ); 422 cons.SetDeltaPhiAngle( pDPhi ); 412 423 413 #ifdef G4DIVDEBUG 424 #ifdef G4DIVDEBUG 414 if( verbose >= 2 ) 425 if( verbose >= 2 ) 415 { 426 { 416 G4cout << " G4ParameterisationConsZ::Compu 427 G4cout << " G4ParameterisationConsZ::ComputeDimensions()" << G4endl 417 << " pDz: " << pDz << G4endl; 428 << " pDz: " << pDz << G4endl; 418 if( verbose >= 4 ) cons.DumpInfo(); 429 if( verbose >= 4 ) cons.DumpInfo(); 419 } 430 } 420 #endif 431 #endif 421 432 422 } 433 } 423 434