Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/divisions/src/G4ParameterisationBox.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /geometry/divisions/src/G4ParameterisationBox.cc (Version 11.3.0) and /geometry/divisions/src/G4ParameterisationBox.cc (Version 8.0.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
 26 // G4ParameterisationBox[X/Y/Z] implementation <<  23 //
                                                   >>  24 // $Id: G4ParameterisationBox.cc,v 1.7 2004/05/17 07:20:40 gcosmo Exp $
                                                   >>  25 // GEANT4 tag $Name: geant4-08-00-patch-01 $
                                                   >>  26 //
                                                   >>  27 // class G4ParameterisationBox Implementation file
 27 //                                                 28 //
 28 // 26.05.03 - P.Arce, Initial version              29 // 26.05.03 - P.Arce, Initial version
 29 // 08.04.04 - I.Hrivnacova, Implemented reflec     30 // 08.04.04 - I.Hrivnacova, Implemented reflection
 30 // 21.04.10 - M.Asai, Added gaps               << 
 31 // -------------------------------------------     31 // --------------------------------------------------------------------
 32                                                    32 
 33 #include "G4ParameterisationBox.hh"                33 #include "G4ParameterisationBox.hh"
 34                                                    34 
 35 #include <iomanip>                                 35 #include <iomanip>
 36 #include "G4ThreeVector.hh"                        36 #include "G4ThreeVector.hh"
 37 #include "G4Transform3D.hh"                        37 #include "G4Transform3D.hh"
 38 #include "G4RotationMatrix.hh"                     38 #include "G4RotationMatrix.hh"
 39 #include "G4VPhysicalVolume.hh"                    39 #include "G4VPhysicalVolume.hh"
 40 #include "G4ReflectedSolid.hh"                     40 #include "G4ReflectedSolid.hh"
 41 #include "G4Box.hh"                                41 #include "G4Box.hh"
 42                                                    42 
 43 //--------------------------------------------     43 //--------------------------------------------------------------------------
 44 G4VParameterisationBox::                           44 G4VParameterisationBox::
 45 G4VParameterisationBox( EAxis axis, G4int nDiv     45 G4VParameterisationBox( EAxis axis, G4int nDiv, G4double width,
 46                         G4double offset, G4VSo     46                         G4double offset, G4VSolid* msolid,
 47                         DivisionType divType )     47                         DivisionType divType )
 48   :  G4VDivisionParameterisation( axis, nDiv,      48   :  G4VDivisionParameterisation( axis, nDiv, width, offset, divType, msolid )
 49 {                                                  49 {
 50   auto msol = (G4Box*)(msolid);                <<  50   G4Box* msol = (G4Box*)(msolid);
 51   if (msolid->GetEntityType() == "G4ReflectedS     51   if (msolid->GetEntityType() == "G4ReflectedSolid")
 52   {                                                52   {
 53     // Get constituent solid                       53     // Get constituent solid  
 54     G4VSolid* mConstituentSolid                    54     G4VSolid* mConstituentSolid 
 55        = ((G4ReflectedSolid*)msolid)->GetConst     55        = ((G4ReflectedSolid*)msolid)->GetConstituentMovedSolid();
 56     msol = (G4Box*)(mConstituentSolid);            56     msol = (G4Box*)(mConstituentSolid);
 57     fmotherSolid = msol;                           57     fmotherSolid = msol;
 58     fReflectedSolid = true;                        58     fReflectedSolid = true;
 59   }                                                59   }    
 60 }                                                  60 }
 61                                                    61 
 62 //--------------------------------------------     62 //--------------------------------------------------------------------------
 63 G4VParameterisationBox::~G4VParameterisationBo <<  63 G4VParameterisationBox::~G4VParameterisationBox()
                                                   >>  64 {
                                                   >>  65 }
 64                                                    66 
 65 //--------------------------------------------     67 //--------------------------------------------------------------------------
 66 G4ParameterisationBoxX::                           68 G4ParameterisationBoxX::
 67 G4ParameterisationBoxX( EAxis axis, G4int nDiv     69 G4ParameterisationBoxX( EAxis axis, G4int nDiv, G4double width,
 68                         G4double offset, G4VSo     70                         G4double offset, G4VSolid* msolid,
 69                         DivisionType divType )     71                         DivisionType divType )
 70   :  G4VParameterisationBox( axis, nDiv, width     72   :  G4VParameterisationBox( axis, nDiv, width, offset, msolid, divType )
 71 {                                                  73 {
 72   CheckParametersValidity();                       74   CheckParametersValidity();
 73   SetType( "DivisionBoxX" );                       75   SetType( "DivisionBoxX" );
 74                                                    76 
 75   auto mbox = (G4Box*)(fmotherSolid);          <<  77   G4Box* mbox = (G4Box*)(fmotherSolid);
 76   if( divType == DivWIDTH )                        78   if( divType == DivWIDTH )
 77   {                                                79   {
 78     fnDiv = CalculateNDiv( 2*mbox->GetXHalfLen     80     fnDiv = CalculateNDiv( 2*mbox->GetXHalfLength(), width, offset );
 79   }                                                81   }
 80   else if( divType == DivNDIV )                    82   else if( divType == DivNDIV )
 81   {                                                83   {
 82     fwidth = CalculateWidth( 2*mbox->GetXHalfL     84     fwidth = CalculateWidth( 2*mbox->GetXHalfLength(), nDiv, offset );
 83   }                                                85   }
 84 #ifdef G4DIVDEBUG                                  86 #ifdef G4DIVDEBUG
 85   if( verbose >= 1 )                               87   if( verbose >= 1 )
 86   {                                                88   {
 87     G4cout << " G4ParameterisationBoxX - no di     89     G4cout << " G4ParameterisationBoxX - no divisions "
 88            << fnDiv << " = " << nDiv << G4endl     90            << fnDiv << " = " << nDiv << G4endl
 89            << " Offset " << foffset << " = " <     91            << " Offset " << foffset << " = " << offset << G4endl
 90            << " Width " << fwidth << " = " <<      92            << " Width " << fwidth << " = " << width << G4endl;
 91   }                                                93   }
 92 #endif                                             94 #endif
 93 }                                                  95 }
 94                                                    96 
 95 //--------------------------------------------     97 //------------------------------------------------------------------------
 96 G4ParameterisationBoxX::~G4ParameterisationBox <<  98 G4ParameterisationBoxX::~G4ParameterisationBoxX()
                                                   >>  99 {
                                                   >> 100 }
 97                                                   101 
 98 //--------------------------------------------    102 //------------------------------------------------------------------------
 99 G4double G4ParameterisationBoxX::GetMaxParamet    103 G4double G4ParameterisationBoxX::GetMaxParameter() const
100 {                                                 104 {
101   auto msol = (G4Box*)(fmotherSolid);          << 105   G4Box* msol = (G4Box*)(fmotherSolid);
102   return 2*msol->GetXHalfLength();                106   return 2*msol->GetXHalfLength();
103 }                                                 107 }
104                                                   108 
105 //--------------------------------------------    109 //------------------------------------------------------------------------
106 void                                              110 void
107 G4ParameterisationBoxX::                          111 G4ParameterisationBoxX::
108 ComputeTransformation( const G4int copyNo, G4V    112 ComputeTransformation( const G4int copyNo, G4VPhysicalVolume* physVol ) const
109 {                                                 113 {
110   auto msol = (G4Box*)(fmotherSolid );         << 114   G4Box* msol = (G4Box*)(fmotherSolid );
111   G4double mdx = msol->GetXHalfLength( );         115   G4double mdx = msol->GetXHalfLength( );
112                                                   116 
113   //----- translation                             117   //----- translation 
114   G4ThreeVector origin(0.,0.,0.);                 118   G4ThreeVector origin(0.,0.,0.); 
115   G4double posi = -mdx + foffset+(copyNo+0.5)*    119   G4double posi = -mdx + foffset+(copyNo+0.5)*fwidth;
116                                                   120 
117   if( faxis == kXAxis )                           121   if( faxis == kXAxis )
118   {                                               122   {
119     origin.setX( posi );                          123     origin.setX( posi ); 
120   }                                               124   }
121   else                                            125   else
122   {                                            << 126   { 
123     std::ostringstream message;                << 127     G4cerr << "ERROR - G4ParameterisationBoxX::ComputeTransformation()"
124     message << "Only axes along X are allowed  << 128            << G4endl
                                                   >> 129            << "        Axis is along " << faxis << " !" << G4endl;
125     G4Exception("G4ParameterisationBoxX::Compu    130     G4Exception("G4ParameterisationBoxX::ComputeTransformation()",
126                 "GeomDiv0002", FatalException, << 131                 "IllegalConstruct", FatalException,
                                                   >> 132                 "Only axes along X are allowed !");
127   }                                               133   }
128 #ifdef G4DIVDEBUG                                 134 #ifdef G4DIVDEBUG
129   if( verbose >= 2 )                              135   if( verbose >= 2 )
130   {                                               136   {
131     G4cout << std::setprecision(8) << " G4Para    137     G4cout << std::setprecision(8) << " G4ParameterisationBoxX: "
132            << copyNo << G4endl                    138            << copyNo << G4endl
133            << " Position " << origin << " Axis    139            << " Position " << origin << " Axis " << faxis << G4endl;
134   }                                               140   }
135 #endif                                            141 #endif
136   //----- set translation                         142   //----- set translation 
137   physVol->SetTranslation( origin );              143   physVol->SetTranslation( origin );
138 }                                                 144 }
139                                                   145 
140 //--------------------------------------------    146 //------------------------------------------------------------------------
141 void                                              147 void
142 G4ParameterisationBoxX::                          148 G4ParameterisationBoxX::
143 ComputeDimensions( G4Box& box, const G4int,       149 ComputeDimensions( G4Box& box, const G4int,
144                    const G4VPhysicalVolume* )     150                    const G4VPhysicalVolume* ) const
145 {                                                 151 {
146   auto msol = (G4Box*)(fmotherSolid);          << 152   G4Box* msol = (G4Box*)(fmotherSolid);
147                                                   153 
148   G4double pDx = fwidth/2. - fhgap;            << 154   G4double pDx = fwidth/2.;
149   G4double pDy = msol->GetYHalfLength();          155   G4double pDy = msol->GetYHalfLength();
150   G4double pDz = msol->GetZHalfLength();          156   G4double pDz = msol->GetZHalfLength();
151                                                   157 
152   box.SetXHalfLength( pDx );                      158   box.SetXHalfLength( pDx );
153   box.SetYHalfLength( pDy );                      159   box.SetYHalfLength( pDy );
154   box.SetZHalfLength( pDz );                      160   box.SetZHalfLength( pDz );
155                                                   161 
156 #ifdef G4DIVDEBUG                                 162 #ifdef G4DIVDEBUG
157   if( verbose >= 2 )                              163   if( verbose >= 2 )
158   {                                               164   {
159     G4cout << " G4ParameterisationBoxX::Comput    165     G4cout << " G4ParameterisationBoxX::ComputeDimensions()" << G4endl
160            << " pDx: " << pDz << G4endl;          166            << " pDx: " << pDz << G4endl;
161     box.DumpInfo();                               167     box.DumpInfo();
162   }                                               168   }
163 #endif                                            169 #endif
164 }                                                 170 }
165                                                   171 
166 //--------------------------------------------    172 //------------------------------------------------------------------------
167 G4ParameterisationBoxY::                          173 G4ParameterisationBoxY::
168 G4ParameterisationBoxY( EAxis axis, G4int nDiv    174 G4ParameterisationBoxY( EAxis axis, G4int nDiv, G4double width,
169                         G4double offset, G4VSo    175                         G4double offset, G4VSolid* msolid,
170                         DivisionType divType)     176                         DivisionType divType)
171   :  G4VParameterisationBox( axis, nDiv, width    177   :  G4VParameterisationBox( axis, nDiv, width, offset, msolid, divType )
172 {                                                 178 {
173   CheckParametersValidity();                      179   CheckParametersValidity();
174   SetType( "DivisionBoxY" );                      180   SetType( "DivisionBoxY" );
175                                                   181 
176   auto mbox = (G4Box*)(fmotherSolid);          << 182   G4Box* mbox = (G4Box*)(fmotherSolid);
177   if( divType == DivWIDTH )                       183   if( divType == DivWIDTH )
178   {                                               184   {
179     fnDiv = CalculateNDiv( 2*mbox->GetYHalfLen    185     fnDiv = CalculateNDiv( 2*mbox->GetYHalfLength(), width, offset );
180   }                                               186   }
181   else if( divType == DivNDIV )                   187   else if( divType == DivNDIV )
182   {                                               188   {
183     fwidth = CalculateWidth( 2*mbox->GetYHalfL    189     fwidth = CalculateWidth( 2*mbox->GetYHalfLength(), nDiv, offset );
184   }                                               190   }
185                                                   191 
186 #ifdef G4DIVDEBUG                                 192 #ifdef G4DIVDEBUG
187   if( verbose >= 1 )                              193   if( verbose >= 1 )
188   {                                               194   {
189     G4cout << " G4ParameterisationBoxY - no di    195     G4cout << " G4ParameterisationBoxY - no divisions " << fnDiv << " = "
190            << nDiv << ". Offset " << foffset <    196            << nDiv << ". Offset " << foffset << " = " << offset
191            << ". Width " << fwidth << " = " <<    197            << ". Width " << fwidth << " = " << width << G4endl;
192   }                                               198   }
193 #endif                                            199 #endif
194 }                                                 200 }
195                                                   201 
196 //--------------------------------------------    202 //------------------------------------------------------------------------
197 G4ParameterisationBoxY::~G4ParameterisationBox << 203 G4ParameterisationBoxY::~G4ParameterisationBoxY()
                                                   >> 204 {
                                                   >> 205 }
198                                                   206 
199 //--------------------------------------------    207 //------------------------------------------------------------------------
200 G4double G4ParameterisationBoxY::GetMaxParamet    208 G4double G4ParameterisationBoxY::GetMaxParameter() const
201 {                                                 209 {
202   auto msol = (G4Box*)(fmotherSolid);          << 210   G4Box* msol = (G4Box*)(fmotherSolid);
203   return 2*msol->GetYHalfLength();                211   return 2*msol->GetYHalfLength();
204 }                                                 212 }
205                                                   213 
206 //--------------------------------------------    214 //------------------------------------------------------------------------
207 void                                              215 void
208 G4ParameterisationBoxY::                          216 G4ParameterisationBoxY::
209 ComputeTransformation( const G4int copyNo, G4V    217 ComputeTransformation( const G4int copyNo, G4VPhysicalVolume* physVol ) const
210 {                                                 218 {
211   auto msol = (G4Box*)(fmotherSolid);          << 219   G4Box* msol = (G4Box*)(fmotherSolid);
212   G4double mdy = msol->GetYHalfLength();          220   G4double mdy = msol->GetYHalfLength();
213                                                   221 
214   //----- translation                             222   //----- translation 
215   G4ThreeVector origin(0.,0.,0.);                 223   G4ThreeVector origin(0.,0.,0.); 
216   G4double posi = -mdy + foffset + (copyNo+0.5    224   G4double posi = -mdy + foffset + (copyNo+0.5)*fwidth;
217   if( faxis == kYAxis )                           225   if( faxis == kYAxis )
218   {                                               226   {
219     origin.setY( posi );                          227     origin.setY( posi ); 
220   }                                               228   }
221   else                                            229   else
222   {                                               230   {
223     std::ostringstream message;                << 231     G4cerr << "ERROR - G4ParameterisationBoxY::ComputeTransformation()"
224     message << "Only axes along Y are allowed  << 232            << G4endl
                                                   >> 233            << "        Axis is along " << faxis << " !" << G4endl;
225     G4Exception("G4ParameterisationBoxY::Compu    234     G4Exception("G4ParameterisationBoxY::ComputeTransformation()",
226                 "GeomDiv0002", FatalException, << 235                 "IllegalConstruct", FatalException,
                                                   >> 236                 "Only axes along Y are allowed !");
227   }                                               237   }
228 #ifdef G4DIVDEBUG                                 238 #ifdef G4DIVDEBUG
229   if( verbose >= 2 )                              239   if( verbose >= 2 )
230   {                                               240   {
231     G4cout << std::setprecision(8) << " G4Para    241     G4cout << std::setprecision(8) << " G4ParameterisationBoxY: "
232            << copyNo << G4endl                    242            << copyNo << G4endl
233            << " Position " << origin << " Axis    243            << " Position " << origin << " Axis " << faxis << G4endl;
234   }                                               244   }
235 #endif                                            245 #endif
236    //----- set translation                        246    //----- set translation 
237   physVol->SetTranslation( origin );              247   physVol->SetTranslation( origin );
238 }                                                 248 }
239                                                   249 
240 //--------------------------------------------    250 //------------------------------------------------------------------------
241 void                                              251 void
242 G4ParameterisationBoxY::                          252 G4ParameterisationBoxY::
243 ComputeDimensions( G4Box& box, const G4int,       253 ComputeDimensions( G4Box& box, const G4int,
244                    const G4VPhysicalVolume* )     254                    const G4VPhysicalVolume* ) const
245 {                                                 255 {
246   auto msol = (G4Box*)(fmotherSolid);          << 256   G4Box* msol = (G4Box*)(fmotherSolid);
247                                                   257 
248   G4double pDx = msol->GetXHalfLength();          258   G4double pDx = msol->GetXHalfLength();
249   G4double pDy = fwidth/2. - fhgap;            << 259   G4double pDy = fwidth/2.;
250   G4double pDz = msol->GetZHalfLength();          260   G4double pDz = msol->GetZHalfLength();
251                                                   261 
252   box.SetXHalfLength( pDx );                      262   box.SetXHalfLength( pDx );
253   box.SetYHalfLength( pDy );                      263   box.SetYHalfLength( pDy );
254   box.SetZHalfLength( pDz );                      264   box.SetZHalfLength( pDz );
255                                                   265 
256 #ifdef G4DIVDEBUG                                 266 #ifdef G4DIVDEBUG
257   if( verbose >= 2 )                              267   if( verbose >= 2 )
258   {                                               268   {
259     G4cout << " G4ParameterisationBoxY::Comput    269     G4cout << " G4ParameterisationBoxY::ComputeDimensions()" << G4endl
260            << " pDx: " << pDz << G4endl;          270            << " pDx: " << pDz << G4endl;
261     box.DumpInfo();                               271     box.DumpInfo();
262   }                                               272   }
263 #endif                                            273 #endif
264 }                                                 274 }
265                                                   275 
266 //--------------------------------------------    276 //------------------------------------------------------------------------
267 G4ParameterisationBoxZ::                          277 G4ParameterisationBoxZ::
268 G4ParameterisationBoxZ( EAxis axis, G4int nDiv    278 G4ParameterisationBoxZ( EAxis axis, G4int nDiv, G4double width,
269                         G4double offset, G4VSo    279                         G4double offset, G4VSolid* msolid,
270                         DivisionType divType )    280                         DivisionType divType )
271   :  G4VParameterisationBox( axis, nDiv, width    281   :  G4VParameterisationBox( axis, nDiv, width, offset, msolid, divType )
272 {                                                 282 {
273   CheckParametersValidity();                      283   CheckParametersValidity();
274   SetType( "DivisionBoxZ" );                      284   SetType( "DivisionBoxZ" );
275                                                   285 
276   auto mbox = (G4Box*)(fmotherSolid);          << 286   G4Box* mbox = (G4Box*)(fmotherSolid);
277   if( divType == DivWIDTH )                       287   if( divType == DivWIDTH )
278   {                                               288   {
279     fnDiv = CalculateNDiv( 2*mbox->GetZHalfLen    289     fnDiv = CalculateNDiv( 2*mbox->GetZHalfLength(), width, offset );
280   }                                               290   }
281   else if ( divType == DivNDIV )                  291   else if ( divType == DivNDIV )
282   {                                               292   {
283     fwidth = CalculateWidth( 2*mbox->GetZHalfL    293     fwidth = CalculateWidth( 2*mbox->GetZHalfLength(), nDiv, offset );
284   }                                               294   }
285 #ifdef G4DIVDEBUG                                 295 #ifdef G4DIVDEBUG
286   if( verbose >= 1 )                              296   if( verbose >= 1 )
287   {                                               297   {
288     G4cout << " G4ParameterisationBoxZ - no di    298     G4cout << " G4ParameterisationBoxZ - no divisions " << fnDiv << " = "
289            << nDiv << ". Offset " << foffset <    299            << nDiv << ". Offset " << foffset << " = " << offset
290            << ". Width " << fwidth << " = " <<    300            << ". Width " << fwidth << " = " << width << G4endl;
291   }                                               301   }
292 #endif                                            302 #endif
293 }                                                 303 }
294                                                   304 
295 //--------------------------------------------    305 //------------------------------------------------------------------------
296 G4ParameterisationBoxZ::~G4ParameterisationBox << 306 G4ParameterisationBoxZ::~G4ParameterisationBoxZ()
                                                   >> 307 {
                                                   >> 308 }
297                                                   309 
298 //--------------------------------------------    310 //------------------------------------------------------------------------
299 G4double G4ParameterisationBoxZ::GetMaxParamet    311 G4double G4ParameterisationBoxZ::GetMaxParameter() const
300 {                                                 312 {
301   auto msol = (G4Box*)(fmotherSolid);          << 313   G4Box* msol = (G4Box*)(fmotherSolid);
302   return 2*msol->GetZHalfLength();                314   return 2*msol->GetZHalfLength();
303 }                                                 315 }
304                                                   316 
305 //--------------------------------------------    317 //------------------------------------------------------------------------
306 void                                              318 void
307 G4ParameterisationBoxZ::                          319 G4ParameterisationBoxZ::
308 ComputeTransformation( const G4int copyNo, G4V    320 ComputeTransformation( const G4int copyNo, G4VPhysicalVolume *physVol ) const
309 {                                                 321 {
310   auto msol = (G4Box*)(fmotherSolid );         << 322   G4Box* msol = (G4Box*)(fmotherSolid );
311   G4double mdz = msol->GetZHalfLength();          323   G4double mdz = msol->GetZHalfLength();
312                                                   324 
313    //----- translation                            325    //----- translation 
314   G4ThreeVector origin(0.,0.,0.);                 326   G4ThreeVector origin(0.,0.,0.); 
315   G4double posi = -mdz + OffsetZ() + (copyNo+0    327   G4double posi = -mdz + OffsetZ() + (copyNo+0.5)*fwidth;
316                                                   328 
317   if( faxis == kZAxis )                           329   if( faxis == kZAxis )
318   {                                               330   {
319     origin.setZ( posi );                          331     origin.setZ( posi ); 
320   }                                               332   }
321   else                                            333   else
322   {                                               334   { 
323     std::ostringstream message;                << 335     G4cerr << "ERROR - G4ParameterisationBoxZ::ComputeTransformation()"
324     message << "Only axes along Z are allowed  << 336            << G4endl;
325     G4Exception("G4ParameterisationBoxZ::Compu    337     G4Exception("G4ParameterisationBoxZ::ComputeTransformation()",
326                 "GeomDiv0002", FatalException, << 338                 "IllegalConstruct", FatalException,
                                                   >> 339                 "Only axes along Z are allowed !");
327   }                                               340   }
328 #ifdef G4DIVDEBUG                                 341 #ifdef G4DIVDEBUG
329   if( verbose >= 2 )                              342   if( verbose >= 2 )
330   {                                               343   {
331     G4cout << std::setprecision(8) << " G4Para    344     G4cout << std::setprecision(8) << " G4ParameterisationBoxZ: "
332            << copyNo << G4endl                    345            << copyNo << G4endl
333            << " Position " << origin << " Axis    346            << " Position " << origin << " Axis " << faxis << G4endl;
334   }                                               347   }
335 #endif                                            348 #endif
336    //----- set translation                        349    //----- set translation 
337   physVol->SetTranslation( origin );              350   physVol->SetTranslation( origin );
338 }                                                 351 }
339                                                   352 
340 //--------------------------------------------    353 //------------------------------------------------------------------------
341 void                                              354 void
342 G4ParameterisationBoxZ::                          355 G4ParameterisationBoxZ::
343 ComputeDimensions( G4Box& box, const G4int,       356 ComputeDimensions( G4Box& box, const G4int,
344                    const G4VPhysicalVolume* )     357                    const G4VPhysicalVolume* ) const
345 {                                                 358 {
346   auto msol = (G4Box*)(fmotherSolid);          << 359   G4Box* msol = (G4Box*)(fmotherSolid);
347                                                   360 
348   G4double pDx = msol->GetXHalfLength();          361   G4double pDx = msol->GetXHalfLength();
349   G4double pDy = msol->GetYHalfLength();          362   G4double pDy = msol->GetYHalfLength();
350   G4double pDz = fwidth/2. - fhgap;            << 363   G4double pDz = fwidth/2.;
351                                                   364 
352   box.SetXHalfLength( pDx );                      365   box.SetXHalfLength( pDx );
353   box.SetYHalfLength( pDy );                      366   box.SetYHalfLength( pDy );
354   box.SetZHalfLength( pDz );                      367   box.SetZHalfLength( pDz );
355                                                   368 
356 #ifdef G4DIVDEBUG                                 369 #ifdef G4DIVDEBUG
357   if( verbose >= 2 )                              370   if( verbose >= 2 )
358   {                                               371   {
359     G4cout << " G4ParameterisationBoxZ::Comput    372     G4cout << " G4ParameterisationBoxZ::ComputeDimensions()" << G4endl
360            << " pDx: " << pDz << G4endl;          373            << " pDx: " << pDz << G4endl;
361     box.DumpInfo();                               374     box.DumpInfo();
362   }                                               375   }
363 #endif                                            376 #endif
364 }                                                 377 }
                                                   >> 378 
365                                                   379