source: trunk/source/geometry/divisions/src/G4ParameterisationCons.cc @ 1347

Last change on this file since 1347 was 1347, checked in by garnier, 13 years ago

geant4 tag 9.4
File size: 14.6 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer                                           *
4// *                                                                  *
5// * The  Geant4 software  is  copyright of the Copyright Holders  of *
6// * the Geant4 Collaboration.  It is provided  under  the terms  and *
7// * conditions of the Geant4 Software License,  included in the file *
8// * LICENSE and available at  http://cern.ch/geant4/license .  These *
9// * include a list of copyright holders.                             *
10// *                                                                  *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work  make  any representation or  warranty, express or implied, *
14// * regarding  this  software system or assume any liability for its *
15// * use.  Please see the license in the file  LICENSE  and URL above *
16// * for the full disclaimer and the limitation of liability.         *
17// *                                                                  *
18// * This  code  implementation is the result of  the  scientific and *
19// * technical work of the GEANT4 collaboration.                      *
20// * By using,  copying,  modifying or  distributing the software (or *
21// * any work based  on the software)  you  agree  to acknowledge its *
22// * use  in  resulting  scientific  publications,  and indicate your *
23// * acceptance of all terms of the Geant4 Software license.          *
24// ********************************************************************
25//
26//
27// $Id: G4ParameterisationCons.cc,v 1.11 2010/11/10 09:15:58 gcosmo Exp $
28// GEANT4 tag $Name: geant4-09-04-ref-00 $
29//
30// class G4ParameterisationCons Implementation file
31//
32// 26.05.03 - P.Arce, Initial version
33// 08.04.04 - I.Hrivnacova, Implemented reflection
34// 21.04.10 - M.Asai, Added gaps
35// --------------------------------------------------------------------
36
37#include "G4ParameterisationCons.hh"
38
39#include <iomanip>
40#include "G4ThreeVector.hh"
41#include "G4RotationMatrix.hh"
42#include "G4VPhysicalVolume.hh"
43#include "G4LogicalVolume.hh"
44#include "G4ReflectedSolid.hh"
45#include "G4Cons.hh"
46
47//--------------------------------------------------------------------------
48G4VParameterisationCons::
49G4VParameterisationCons( EAxis axis, G4int nDiv, G4double width,
50                        G4double offset, G4VSolid* msolid,
51                        DivisionType divType )
52  :  G4VDivisionParameterisation( axis, nDiv, width, offset, divType, msolid )
53{
54  G4Cons* msol = (G4Cons*)(msolid);
55  if (msolid->GetEntityType() == "G4ReflectedSolid")
56  {
57    // Get constituent solid 
58    G4VSolid* mConstituentSolid
59       = ((G4ReflectedSolid*)msolid)->GetConstituentMovedSolid();
60    msol = (G4Cons*)(mConstituentSolid);
61 
62    // Create a new solid with inversed parameters
63    G4Cons* newSolid
64      = new G4Cons(msol->GetName(),
65                   msol->GetInnerRadiusPlusZ(), msol->GetOuterRadiusPlusZ(),
66                   msol->GetInnerRadiusMinusZ(), msol->GetOuterRadiusMinusZ(),
67                   msol->GetZHalfLength(),
68                   msol->GetStartPhiAngle(), msol->GetDeltaPhiAngle());
69    msol = newSolid;
70    fmotherSolid = newSolid;
71    fReflectedSolid = true;
72    fDeleteSolid = true;
73  }   
74}
75
76//------------------------------------------------------------------------
77G4VParameterisationCons::~G4VParameterisationCons()
78{
79}
80
81//--------------------------------------------------------------------------
82G4ParameterisationConsRho::
83G4ParameterisationConsRho( EAxis axis, G4int nDiv,
84                           G4double width, G4double offset,
85                           G4VSolid* msolid, DivisionType divType )
86  :  G4VParameterisationCons( axis, nDiv, width, offset, msolid, divType )
87{
88  CheckParametersValidity();
89  SetType( "DivisionConsRho" );
90
91  G4Cons* msol = (G4Cons*)(fmotherSolid);
92  if( msol->GetInnerRadiusPlusZ() == 0. )
93  {
94    G4cerr << "WARNING - G4ParameterisationConsRho, OuterRadiusMinusZ = 0. "
95           << G4endl
96           << "          Width is calculated as that of OuterRadiusMinusZ !"
97           << G4endl;
98  } 
99
100  if( divType == DivWIDTH )
101  {
102    fnDiv = CalculateNDiv( msol->GetOuterRadiusMinusZ()
103                         - msol->GetInnerRadiusMinusZ(), width, offset );
104  }
105  else if( divType == DivNDIV )
106  {
107    G4Cons* msol = (G4Cons*)(msolid);
108    fwidth = CalculateWidth( msol->GetOuterRadiusMinusZ()
109                           - msol->GetInnerRadiusMinusZ(), nDiv, offset );
110  }
111
112#ifdef G4DIVDEBUG
113  if( verbose >= 1 )
114  {
115    G4cout << " G4ParameterisationConsRho - no divisions " << fnDiv << " = "
116           << nDiv << G4endl
117           << " Offset " << foffset << " = " << offset
118           << " - Width " << fwidth << " = " << width << G4endl;
119  }
120#endif
121}
122
123//--------------------------------------------------------------------------
124G4ParameterisationConsRho::~G4ParameterisationConsRho()
125{
126}
127
128//------------------------------------------------------------------------
129G4double G4ParameterisationConsRho::GetMaxParameter() const
130{
131  G4Cons* msol = (G4Cons*)(fmotherSolid);
132  return msol->GetOuterRadiusMinusZ() - msol->GetInnerRadiusMinusZ();
133}
134
135//--------------------------------------------------------------------------
136void
137G4ParameterisationConsRho::
138ComputeTransformation( const G4int, G4VPhysicalVolume *physVol ) const
139{
140  //----- translation
141  G4ThreeVector origin(0.,0.,0.); 
142  //----- set translation
143  physVol->SetTranslation( origin );
144
145  //----- calculate rotation matrix: unit
146
147#ifdef G4DIVDEBUG
148  if( verbose >= 2 )
149  {
150    G4cout <<  " G4ParameterisationConsRho " << G4endl
151           << " Offset: " << foffset
152           << " - Width: " << fwidth << G4endl;
153  }
154#endif
155
156  ChangeRotMatrix( physVol );
157
158#ifdef G4DIVDEBUG
159  if( verbose >= 2 )
160  {
161    G4cout << std::setprecision(8) << " G4ParameterisationConsRho" << G4endl
162           << " Position: " << origin << " - Width: " << fwidth
163           << " - Axis: " << faxis  << G4endl;
164  }
165#endif
166}
167
168//--------------------------------------------------------------------------
169void
170G4ParameterisationConsRho::
171ComputeDimensions( G4Cons& cons, const G4int copyNo,
172                   const G4VPhysicalVolume* ) const
173{
174  G4Cons* msol = (G4Cons*)(fmotherSolid);
175
176  G4double pRMin1 = msol->GetInnerRadiusMinusZ() + foffset + fwidth * copyNo;
177  G4double pRMax1 = msol->GetInnerRadiusMinusZ() + foffset + fwidth * (copyNo+1);
178 
179  //width at Z Plus
180  //- G4double fwidthPlus =
181  //   fwidth * ( msol->GetOuterRadiusPlusZ()/ msol->GetInnerRadiusPlusZ())
182  //-         / ( msol->GetOuterRadiusMinusZ() - msol->GetInnerRadiusMinusZ());
183  G4double fwidthPlus = CalculateWidth( msol->GetOuterRadiusPlusZ()
184                           - msol->GetInnerRadiusPlusZ(), fnDiv, foffset );
185  G4double pRMin2 = msol->GetInnerRadiusPlusZ()
186                  + foffset + fwidthPlus * copyNo;
187  G4double pRMax2 = msol->GetInnerRadiusPlusZ()
188                  + foffset + fwidthPlus * (copyNo+1);
189  G4double pDz = msol->GetZHalfLength();
190
191  G4double d_half_gap = fhgap * pRMax2 / pRMax1;
192  //- already rotated  double pSR = foffset + copyNo*fwidth;
193  G4double pSPhi = msol->GetStartPhiAngle();
194  G4double pDPhi = msol->GetDeltaPhiAngle();;
195
196  cons.SetInnerRadiusMinusZ( pRMin1 + fhgap );
197  cons.SetOuterRadiusMinusZ( pRMax1 - fhgap );
198  cons.SetInnerRadiusPlusZ( pRMin2 + d_half_gap );
199  cons.SetOuterRadiusPlusZ( pRMax2 - d_half_gap );
200  cons.SetZHalfLength( pDz );
201  cons.SetStartPhiAngle( pSPhi );
202  cons.SetDeltaPhiAngle( pDPhi );
203
204#ifdef G4DIVDEBUG
205  if( verbose >= 2 )
206  {
207    G4cout << " G4ParameterisationConsRho::ComputeDimensions()" << G4endl
208           << " pRMin: " << pRMin1 << " - pRMax: " << pRMax1 << G4endl;
209    if( verbose >= 4 ) cons.DumpInfo();
210  }
211#endif
212}
213
214//--------------------------------------------------------------------------
215G4ParameterisationConsPhi::
216G4ParameterisationConsPhi( EAxis axis, G4int nDiv,
217                           G4double width, G4double offset,
218                           G4VSolid* msolid, DivisionType divType )
219  :  G4VParameterisationCons( axis, nDiv, width, offset, msolid, divType )
220{ 
221  CheckParametersValidity();
222  SetType( "DivisionConsPhi" );
223
224  G4Cons* msol = (G4Cons*)(fmotherSolid);
225  if( divType == DivWIDTH )
226  {
227    fnDiv = CalculateNDiv( msol->GetDeltaPhiAngle(), width, offset );
228  }
229  else if( divType == DivNDIV )
230  {
231    fwidth = CalculateWidth( msol->GetDeltaPhiAngle(), nDiv, offset );
232  }
233
234#ifdef G4DIVDEBUG
235  if( verbose >= 1 )
236  {
237    G4cout << " G4ParameterisationConsPhi no divisions " << fnDiv << " = "
238           << nDiv << G4endl
239           << " Offset " << foffset << " = " << offset << G4endl
240           << " Width " << fwidth << " = " << width << G4endl;
241  }
242#endif
243}
244
245//--------------------------------------------------------------------------
246G4ParameterisationConsPhi::~G4ParameterisationConsPhi()
247{
248}
249
250//------------------------------------------------------------------------
251G4double G4ParameterisationConsPhi::GetMaxParameter() const
252{
253  G4Cons* msol = (G4Cons*)(fmotherSolid);
254  return msol->GetDeltaPhiAngle();
255}
256
257//--------------------------------------------------------------------------
258void
259G4ParameterisationConsPhi::
260ComputeTransformation( const G4int copyNo, G4VPhysicalVolume *physVol ) const
261{
262  //----- translation
263  G4ThreeVector origin(0.,0.,0.); 
264  //----- set translation
265  physVol->SetTranslation( origin );
266
267  //----- calculate rotation matrix (so that all volumes point to the centre)
268  G4double posi = foffset  + copyNo*fwidth;
269
270#ifdef G4DIVDEBUG
271  if( verbose >= 2 )
272  {
273    G4cout << " G4ParameterisationConsPhi - position: " << posi/deg << G4endl
274           << " Origin: " << origin << " copyNo: " << copyNo
275           << " - foffset: " << foffset/deg
276           << " - fwidth: " << fwidth/deg << G4endl
277           << " - Axis: " << faxis << G4endl;
278  }
279#endif
280
281  ChangeRotMatrix( physVol, -posi );
282}
283
284//--------------------------------------------------------------------------
285void
286G4ParameterisationConsPhi::
287ComputeDimensions( G4Cons& cons, const G4int,
288                   const G4VPhysicalVolume* ) const
289{
290  G4Cons* msol = (G4Cons*)(fmotherSolid);
291
292  G4double pRMin1 = msol->GetInnerRadiusMinusZ();
293  G4double pRMax1 = msol->GetOuterRadiusMinusZ();
294  G4double pRMin2 = msol->GetInnerRadiusPlusZ();
295  G4double pRMax2 = msol->GetOuterRadiusPlusZ();
296  G4double pDz = msol->GetZHalfLength();
297
298  //- already rotated  double pSPhi = foffset + copyNo*fwidth;
299  G4double pSPhi = foffset + msol->GetStartPhiAngle() + fhgap;
300  G4double pDPhi = fwidth - 2.*fhgap;
301
302  cons.SetInnerRadiusMinusZ( pRMin1 );
303  cons.SetOuterRadiusMinusZ( pRMax1 );
304  cons.SetInnerRadiusPlusZ( pRMin2 );
305  cons.SetOuterRadiusPlusZ( pRMax2 );
306  cons.SetZHalfLength( pDz );
307  cons.SetStartPhiAngle( pSPhi );
308  cons.SetDeltaPhiAngle( pDPhi );
309
310#ifdef G4DIVDEBUG
311  if( verbose >= 2 )
312  {
313    G4cout << " G4ParameterisationConsPhi::ComputeDimensions" << G4endl
314           << " pSPhi: " << pSPhi << " - pDPhi: " << pDPhi << G4endl;
315    if( verbose >= 4 ) cons.DumpInfo();
316  }
317#endif
318}
319
320//--------------------------------------------------------------------------
321G4ParameterisationConsZ::
322G4ParameterisationConsZ( EAxis axis, G4int nDiv,
323                         G4double width, G4double offset,
324                         G4VSolid* msolid, DivisionType divType )
325  :  G4VParameterisationCons( axis, nDiv, width, offset, msolid, divType )
326{ 
327  CheckParametersValidity();
328  SetType( "DivisionConsZ" );
329
330  G4Cons* msol = (G4Cons*)(fmotherSolid);
331  if( divType == DivWIDTH )
332  {
333    fnDiv = CalculateNDiv( 2*msol->GetZHalfLength(), width, offset );
334  }
335  else if( divType == DivNDIV )
336  {
337    fwidth = CalculateWidth( 2*msol->GetZHalfLength(), nDiv, offset );
338  }
339
340#ifdef G4DIVDEBUG
341  if( verbose >= 1 )
342  {
343    G4cout << " G4ParameterisationConsZ: # divisions " << fnDiv << " = "
344           << nDiv << G4endl
345           << " Offset " << foffset << " = " << offset << G4endl
346           << " Width " << fwidth << " = " << width << G4endl
347           << " - Axis: " << faxis << G4endl;
348  }
349#endif
350}
351
352//--------------------------------------------------------------------------
353G4ParameterisationConsZ::~G4ParameterisationConsZ()
354{
355}
356
357//------------------------------------------------------------------------
358G4double G4ParameterisationConsZ::GetMaxParameter() const
359{
360  G4Cons* msol = (G4Cons*)(fmotherSolid);
361  return 2*msol->GetZHalfLength();
362}
363
364//--------------------------------------------------------------------------
365void
366G4ParameterisationConsZ::
367ComputeTransformation( const G4int copyNo, G4VPhysicalVolume* physVol ) const
368{
369  //----- set translation: along Z axis
370  G4Cons* motherCons = (G4Cons*)(GetMotherSolid());
371  G4double posi = - motherCons->GetZHalfLength() + OffsetZ()
372                  + fwidth/2 + copyNo*fwidth;
373  G4ThreeVector origin(0.,0.,posi); 
374  physVol->SetTranslation( origin );
375
376  //----- calculate rotation matrix: unit
377
378#ifdef G4DIVDEBUG
379  if( verbose >= 2 )
380  {
381    G4cout << " G4ParameterisationConsZ::ComputeTransformation()" << G4endl
382           << " Origin: " << origin << " - copyNo: " << copyNo << G4endl
383           << " foffset: " << foffset << " - fwidth: " << fwidth
384           << G4endl;
385  }
386#endif
387
388  ChangeRotMatrix( physVol );
389}
390
391
392//--------------------------------------------------------------------------
393void
394G4ParameterisationConsZ::
395ComputeDimensions( G4Cons& cons, const G4int copyNo,
396                   const G4VPhysicalVolume* ) const
397{
398  G4Cons* msol = (G4Cons*)(fmotherSolid);
399
400  G4double mHalfLength = msol->GetZHalfLength() - fhgap;
401  G4double aRInner = (msol->GetInnerRadiusPlusZ()
402                   - msol->GetInnerRadiusMinusZ()) / (2*mHalfLength);
403  G4double bRInner = (msol->GetInnerRadiusPlusZ()
404                   + msol->GetInnerRadiusMinusZ()) / 2;
405  G4double aROuter = (msol->GetOuterRadiusPlusZ()
406                   - msol->GetOuterRadiusMinusZ()) / (2*mHalfLength);
407  G4double bROuter = (msol->GetOuterRadiusPlusZ()
408                   + msol->GetOuterRadiusMinusZ()) / 2;
409  G4double xMinusZ = -mHalfLength + OffsetZ() + fwidth*copyNo + fhgap;
410  G4double xPlusZ  = -mHalfLength + OffsetZ() + fwidth*(copyNo+1) - fhgap;
411  cons.SetInnerRadiusMinusZ( aRInner * xMinusZ + bRInner );
412  cons.SetOuterRadiusMinusZ( aROuter * xMinusZ + bROuter );
413  cons.SetInnerRadiusPlusZ( aRInner * xPlusZ + bRInner );
414  cons.SetOuterRadiusPlusZ( aROuter * xPlusZ + bROuter );
415 
416  G4double pDz = fwidth / 2. - fhgap;
417  G4double pSPhi = msol->GetStartPhiAngle();
418  G4double pDPhi = msol->GetDeltaPhiAngle();
419
420  cons.SetZHalfLength( pDz );
421  cons.SetStartPhiAngle( pSPhi );
422  cons.SetDeltaPhiAngle( pDPhi );
423
424#ifdef G4DIVDEBUG
425  if( verbose >= 2 )
426  {
427    G4cout << " G4ParameterisationConsZ::ComputeDimensions()" << G4endl
428           << " pDz: " << pDz << G4endl;
429    if( verbose >= 4 ) cons.DumpInfo();
430  }
431#endif
432
433}
Note: See TracBrowser for help on using the repository browser.