Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/divisions/src/G4PVDivision.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/G4PVDivision.cc (Version 11.3.0) and /geometry/divisions/src/G4PVDivision.cc (Version 9.1.p1)


  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 // G4PVDivision Implementation file            << 
 27 //                                                 26 //
 28 // 26.05.03 - P.Arce, Initial version          <<  27 // $Id: G4PVDivision.cc,v 1.20 2006/06/29 18:18:31 gunter Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-09-01-patch-01 $
                                                   >>  29 //
                                                   >>  30 // class G4PVDivision Implementation file
                                                   >>  31 //
                                                   >>  32 // 26.05.03 - P.Arce Initial version
 29 // -------------------------------------------     33 // --------------------------------------------------------------------
 30                                                    34 
 31 #include "G4PVDivision.hh"                         35 #include "G4PVDivision.hh"
 32 #include "G4LogicalVolume.hh"                      36 #include "G4LogicalVolume.hh"
 33 #include "G4VSolid.hh"                             37 #include "G4VSolid.hh"
 34 #include "G4ReflectedSolid.hh"                     38 #include "G4ReflectedSolid.hh"
 35 #include "G4ParameterisationBox.hh"                39 #include "G4ParameterisationBox.hh"
 36 #include "G4ParameterisationTubs.hh"               40 #include "G4ParameterisationTubs.hh"
 37 #include "G4ParameterisationCons.hh"               41 #include "G4ParameterisationCons.hh"
 38 #include "G4ParameterisationTrd.hh"                42 #include "G4ParameterisationTrd.hh"
 39 #include "G4ParameterisationPara.hh"               43 #include "G4ParameterisationPara.hh"
 40 #include "G4ParameterisationPolycone.hh"           44 #include "G4ParameterisationPolycone.hh"
 41 #include "G4ParameterisationPolyhedra.hh"          45 #include "G4ParameterisationPolyhedra.hh"
 42                                                    46 
 43 //--------------------------------------------     47 //--------------------------------------------------------------------------
 44 G4PVDivision::G4PVDivision(const G4String& pNa     48 G4PVDivision::G4PVDivision(const G4String& pName,
 45                                  G4LogicalVolu     49                                  G4LogicalVolume* pLogical,
 46                                  G4LogicalVolu     50                                  G4LogicalVolume* pMotherLogical,
 47                            const EAxis pAxis,      51                            const EAxis pAxis,
 48                            const G4int nDivs,      52                            const G4int nDivs,
 49                            const G4double widt     53                            const G4double width,
 50                            const G4double offs     54                            const G4double offset )
 51   : G4PVReplica(pName, nDivs, pAxis, pLogical, <<  55   : G4VPhysicalVolume(0,G4ThreeVector(),pName,pLogical,0),
                                                   >>  56     fcopyNo(-1)
 52 {                                                  57 {
 53   if (pMotherLogical == nullptr)               <<  58   if (!pMotherLogical)
 54   {                                                59   {
 55     std::ostringstream message;                <<  60     G4String message_1 =
 56     message << "Invalid setup." << G4endl      <<  61       "NULL pointer specified as mother,\n for volume: " + pName;
 57             << "NULL pointer specified as moth <<  62     G4Exception("G4PVDivision::G4PVDivision()", "InvalidSetup",
 58     G4Exception("G4PVDivision::G4PVDivision()" <<  63                 FatalException, message_1);
 59                 FatalException, message);      << 
 60     return;                                    << 
 61   }                                                64   }
 62   if (pLogical == pMotherLogical)                  65   if (pLogical == pMotherLogical)
 63   {                                                66   {
 64     std::ostringstream message;                <<  67     G4String message_2 =
 65     message << "Invalid setup." << G4endl      <<  68       "Cannot place a volume inside itself! Volume: " + pName;
 66             << "Cannot place a volume inside i <<  69     G4Exception("G4PVDivision::G4PVDivision()", "InvalidSetup",
 67     G4Exception("G4PVDivision::G4PVDivision()" <<  70                 FatalException, message_2);
 68                 FatalException, message);      << 
 69   }                                                71   }
 70   pMotherLogical->AddDaughter(this);               72   pMotherLogical->AddDaughter(this);
 71   SetMotherLogical(pMotherLogical);                73   SetMotherLogical(pMotherLogical);
 72   SetParameterisation(pMotherLogical, pAxis, n     74   SetParameterisation(pMotherLogical, pAxis, nDivs,
 73                       width, offset, DivNDIVan     75                       width, offset, DivNDIVandWIDTH);
 74   CheckAndSetParameters (pAxis, nDivs, width,      76   CheckAndSetParameters (pAxis, nDivs, width, offset,
 75                          DivNDIVandWIDTH, pMot     77                          DivNDIVandWIDTH, pMotherLogical);
 76 }                                                  78 }
 77                                                    79 
 78 //--------------------------------------------     80 //--------------------------------------------------------------------------
 79 G4PVDivision::G4PVDivision(const G4String& pNa     81 G4PVDivision::G4PVDivision(const G4String& pName,
 80                                  G4LogicalVolu     82                                  G4LogicalVolume* pLogical,
 81                                  G4LogicalVolu     83                                  G4LogicalVolume* pMotherLogical,
 82                            const EAxis pAxis,      84                            const EAxis pAxis,
 83                            const G4int nDivs,      85                            const G4int nDivs,
 84                            const G4double offs     86                            const G4double offset )
 85   : G4PVReplica(pName, nDivs, pAxis, pLogical, <<  87   : G4VPhysicalVolume(0,G4ThreeVector(),pName,pLogical,0),
                                                   >>  88     fcopyNo(-1)
 86 {                                                  89 {
 87   if (pMotherLogical == nullptr)               <<  90   if (!pMotherLogical)
 88   {                                                91   {
 89     std::ostringstream message;                <<  92     G4String message_1 =
 90     message << "Invalid setup." << G4endl      <<  93       "NULL pointer specified as mother! Volume: " + pName;
 91             << "NULL pointer specified as moth <<  94     G4Exception("G4PVDivision::G4PVDivision()", "InvalidSetup",
 92     G4Exception("G4PVDivision::G4PVDivision()" <<  95                 FatalException, message_1);
 93                 FatalException, message);      << 
 94     return;                                    << 
 95   }                                                96   }
 96   if (pLogical == pMotherLogical)                  97   if (pLogical == pMotherLogical)
 97   {                                                98   {
 98     std::ostringstream message;                <<  99     G4String message_2 =
 99     message << "Invalid setup." << G4endl      << 100       "Cannot place a volume inside itself! Volume: " + pName;
100             << "Cannot place a volume inside i << 101     G4Exception("G4PVDivision::G4PVDivision()", "InvalidSetup",
101     G4Exception("G4PVDivision::G4PVDivision()" << 102                 FatalException, message_2);
102                 FatalException, message);      << 
103   }                                               103   }
104   pMotherLogical->AddDaughter(this);              104   pMotherLogical->AddDaughter(this);
105   SetMotherLogical(pMotherLogical);               105   SetMotherLogical(pMotherLogical);
106   SetParameterisation(pMotherLogical, pAxis, n    106   SetParameterisation(pMotherLogical, pAxis, nDivs, 0., offset, DivNDIV);
107   CheckAndSetParameters (pAxis, nDivs, 0., off    107   CheckAndSetParameters (pAxis, nDivs, 0., offset, DivNDIV, pMotherLogical);
108 }                                                 108 }
109                                                   109 
110 //--------------------------------------------    110 //--------------------------------------------------------------------------
111 G4PVDivision::G4PVDivision(const G4String& pNa    111 G4PVDivision::G4PVDivision(const G4String& pName,
112                                  G4LogicalVolu    112                                  G4LogicalVolume* pLogical,
113                                  G4LogicalVolu    113                                  G4LogicalVolume* pMotherLogical,
114                            const EAxis pAxis,     114                            const EAxis pAxis,
115                            const G4double widt    115                            const G4double width,
116                            const G4double offs    116                            const G4double offset )
117   : G4PVReplica(pName, 0, pAxis, pLogical, pMo << 117   : G4VPhysicalVolume(0,G4ThreeVector(),pName,pLogical,0),
                                                   >> 118     fcopyNo(-1)
118 {                                                 119 {
119   if (pMotherLogical == nullptr)               << 120   if (!pMotherLogical)
120   {                                               121   {
121     std::ostringstream message;                << 122     G4String message_1 =
122     message << "Invalid setup." << G4endl      << 123       "NULL pointer specified as mother! Volume: " + pName;
123             << "NULL pointer specified as moth << 124     G4Exception("G4PVDivision::G4PVDivision()", "InvalidSetup",
124     G4Exception("G4PVDivision::G4PVDivision()" << 125                 FatalException, message_1);
125                 FatalException, message);      << 
126     return;                                    << 
127   }                                               126   }
128   if (pLogical == pMotherLogical)                 127   if (pLogical == pMotherLogical)
129   {                                               128   {
130     std::ostringstream message;                << 129     G4String message_2 =
131     message << "Invalid setup." << G4endl      << 130       "Cannot place a volume inside itself! Volume: " + pName;
132             << "Cannot place a volume inside i << 131     G4Exception("G4PVDivision::G4PVDivision()", "InvalidSetup",
133     G4Exception("G4PVDivision::G4PVDivision()" << 132                 FatalException, message_2);
134                 FatalException, message);      << 
135   }                                               133   }
136   pMotherLogical->AddDaughter(this);              134   pMotherLogical->AddDaughter(this);
137   SetMotherLogical(pMotherLogical);               135   SetMotherLogical(pMotherLogical);
138   SetParameterisation(pMotherLogical, pAxis, 0    136   SetParameterisation(pMotherLogical, pAxis, 0, width, offset, DivWIDTH);
139   CheckAndSetParameters (pAxis, 0, width, offs    137   CheckAndSetParameters (pAxis, 0, width, offset, DivWIDTH, pMotherLogical);
140 }                                                 138 }
141                                                   139 
142 //--------------------------------------------    140 //--------------------------------------------------------------------------
143 G4PVDivision::G4PVDivision(const G4String& pNa << 
144                                  G4LogicalVolu << 
145                                  G4VPhysicalVo << 
146                            const EAxis pAxis,  << 
147                            const G4int nDivs,  << 
148                            const G4double widt << 
149                            const G4double offs << 
150   : G4PVReplica(pName, nDivs, pAxis, pLogical, << 
151                 pMotherPhysical != nullptr ? p << 
152 {                                              << 
153   if (pMotherPhysical == nullptr)              << 
154   {                                            << 
155     std::ostringstream message;                << 
156     message << "Invalid setup." << G4endl      << 
157             << "NULL pointer specified as moth << 
158     G4Exception("G4PVDivision::G4PVDivision()" << 
159                 FatalException, message);      << 
160     return;                                    << 
161   }                                            << 
162   G4LogicalVolume* pMotherLogical = pMotherPhy << 
163   if (pLogical == pMotherLogical)              << 
164   {                                            << 
165     std::ostringstream message;                << 
166     message << "Invalid setup." << G4endl      << 
167             << "Cannot place a volume inside i << 
168     G4Exception("G4PVDivision::G4PVDivision()" << 
169                 FatalException, message);      << 
170   }                                            << 
171   pMotherLogical->AddDaughter(this);           << 
172   SetMotherLogical(pMotherLogical);            << 
173   SetParameterisation(pMotherLogical, pAxis, n << 
174                       width, offset, DivNDIVan << 
175   CheckAndSetParameters (pAxis, nDivs, width,  << 
176                          DivNDIVandWIDTH, pMot << 
177 }                                              << 
178                                                << 
179 //-------------------------------------------- << 
180 void                                              141 void
181 G4PVDivision::CheckAndSetParameters( const EAx    142 G4PVDivision::CheckAndSetParameters( const EAxis pAxis,
182                                      const G4i    143                                      const G4int nDivs,
183                                      const G4d    144                                      const G4double width,
184                                      const G4d    145                                      const G4double offset, 
185                                            Div    146                                            DivisionType divType,
186                                      const G4L    147                                      const G4LogicalVolume* pMotherLogical )
187 {                                                 148 {
188   if( divType == DivWIDTH )                       149   if( divType == DivWIDTH )
189   {                                               150   {
190     fnReplicas = fparam->GetNoDiv();              151     fnReplicas = fparam->GetNoDiv();
191   }                                               152   }
192   else                                            153   else
193   {                                               154   {
194     fnReplicas = nDivs;                           155     fnReplicas = nDivs;
195   }                                               156   }
196   if (fnReplicas < 1 )                            157   if (fnReplicas < 1 )
197   {                                               158   {
198     G4Exception("G4PVDivision::CheckAndSetPara << 159     G4Exception("G4PVDivision::G4PVDivision()", "IllegalConstruct",
199                 FatalException, "Illegal numbe    160                 FatalException, "Illegal number of replicas!");
200   }                                               161   }
201                                                   162 
202   if( divType != DivNDIV)                         163   if( divType != DivNDIV)
203   {                                               164   {
204     fwidth = fparam->GetWidth();                  165     fwidth = fparam->GetWidth();
205   }                                               166   }
206   else                                            167   else
207   {                                               168   {
208     fwidth = width;                               169     fwidth = width;
209   }                                               170   }
210   if( fwidth < 0 )                                171   if( fwidth < 0 )
211   {                                               172   {
212     G4Exception("G4PVDivision::CheckAndSetPara << 173     G4Exception("G4PVDivision::G4PVDivision()", "IllegalConstruct",
213                 FatalException, "Width must be    174                 FatalException, "Width must be positive!");
214   }                                               175   }
215                                                   176   
216   foffset = offset;                               177   foffset = offset;
217   fdivAxis = pAxis;                               178   fdivAxis = pAxis;
218                                                   179 
219   //!!!!! axis has to be x/y/z in G4VoxelLimit    180   //!!!!! axis has to be x/y/z in G4VoxelLimits::GetMinExtent
220   //                                              181   //
221   if( pAxis == kRho || pAxis == kRadial3D || p    182   if( pAxis == kRho || pAxis == kRadial3D || pAxis == kPhi )
222   {                                               183   {
223     faxis = kZAxis;                               184     faxis = kZAxis;
224   }                                               185   }
225   else                                            186   else
226   {                                               187   {
227     faxis = pAxis;                                188     faxis = pAxis;
228   }                                               189   }
229                                                   190   
230   // Create rotation matrix: for phi axis it w    191   // Create rotation matrix: for phi axis it will be changed
231   // in G4VPVParameterisation::ComputeTransfor    192   // in G4VPVParameterisation::ComputeTransformation, for others
232   // it will stay the unity                       193   // it will stay the unity
233   //                                              194   //
234   auto  pRMat = new G4RotationMatrix();        << 195   G4RotationMatrix *pRMat = new G4RotationMatrix();
235   SetRotation(pRMat);                             196   SetRotation(pRMat);
236                                                   197   
237   switch (faxis)                                  198   switch (faxis)
238   {                                               199   {
239     case kPhi:                                    200     case kPhi:
240       break;                                      201       break;
241     case kRho:                                    202     case kRho:
242     case kXAxis:                                  203     case kXAxis:
243     case kYAxis:                                  204     case kYAxis:
244     case kZAxis:                                  205     case kZAxis:
245       break;                                      206       break;
246     default:                                      207     default:
247       G4Exception("G4PVDivision::CheckAndSetPa << 208       G4Exception("G4PVDivision::G4PVDivision()", "IllegalConstruct",
248                   FatalException, "Unknown axi    209                   FatalException, "Unknown axis of replication.");
249       break;                                      210       break;
250   }                                               211   }
251                                                   212 
252                                                   213 
253   //----- Check that mother solid is of the sa    214   //----- Check that mother solid is of the same type than
254   //      daughter solid (otherwise, the corre    215   //      daughter solid (otherwise, the corresponding
255   //      Parameterisation::ComputeDimension()    216   //      Parameterisation::ComputeDimension() will not be called)
256   //                                              217   //
257   G4String msolType = pMotherLogical->GetSolid    218   G4String msolType = pMotherLogical->GetSolid()->GetEntityType();
258   G4String dsolType = GetLogicalVolume()->GetS    219   G4String dsolType = GetLogicalVolume()->GetSolid()->GetEntityType();
259   if( msolType != dsolType && ( msolType != "G << 220   if( msolType != dsolType )
260   {                                               221   {
261     std::ostringstream message;                << 222     G4String message =
262     message << "Incorrect solid type for divis << 223       "Incorrect solid type for division of volume " + GetName()
263             << GetName() << "." << G4endl      << 224     + "    It is: " + msolType + ", while it should be: " + dsolType;
264             << "It is: " << msolType           << 225     G4Exception("G4VDivisionParameterisation::CheckAndSetParameters()",
265             << ", while it should be: " << dso << 226                 "IllegalConstruct", FatalException, message );
266     G4Exception("G4PVDivision::CheckAndSetPara << 
267                 "GeomDiv0002", FatalException, << 
268   }                                               227   }
269 }                                                 228 }
270                                                   229 
271 //--------------------------------------------    230 //--------------------------------------------------------------------------
272 G4PVDivision::~G4PVDivision() = default;       << 231 G4PVDivision::~G4PVDivision()
                                                   >> 232 {
                                                   >> 233   delete GetRotation();
                                                   >> 234 }
273                                                   235 
274 //--------------------------------------------    236 //--------------------------------------------------------------------------
275 EAxis G4PVDivision::GetDivisionAxis() const       237 EAxis G4PVDivision::GetDivisionAxis() const
276 {                                                 238 {
277   return fdivAxis;                                239   return fdivAxis;
278 }                                                 240 }
279                                                   241 
280 //--------------------------------------------    242 //--------------------------------------------------------------------------
281 G4bool G4PVDivision::IsParameterised() const      243 G4bool G4PVDivision::IsParameterised() const
282 {                                                 244 { 
283   return true;                                    245   return true;
284 }                                                 246 }
285                                                   247 
286 //--------------------------------------------    248 //--------------------------------------------------------------------------
287 G4bool G4PVDivision::IsMany() const               249 G4bool G4PVDivision::IsMany() const
288 {                                                 250 {
289   return false;                                   251   return false; 
290 }                                                 252 }
291                                                   253 
292 //--------------------------------------------    254 //--------------------------------------------------------------------------
293 G4bool G4PVDivision::IsReplicated() const      << 255 G4int G4PVDivision::GetCopyNo() const
294 {                                                 256 {
295   return true;                                 << 257   return fcopyNo;
296 }                                                 258 }
297                                                   259 
298 //--------------------------------------------    260 //--------------------------------------------------------------------------
299 G4int G4PVDivision::GetMultiplicity() const    << 261 void  G4PVDivision::SetCopyNo(G4int newCopyNo)
300 {                                                 262 {
301   return fnReplicas;                           << 263   fcopyNo= newCopyNo;
                                                   >> 264 }
                                                   >> 265 
                                                   >> 266 //--------------------------------------------------------------------------
                                                   >> 267 G4bool G4PVDivision::IsReplicated() const
                                                   >> 268 {
                                                   >> 269   return true;
302 }                                                 270 }
303                                                   271 
304 //--------------------------------------------    272 //--------------------------------------------------------------------------
305 G4VPVParameterisation* G4PVDivision::GetParame    273 G4VPVParameterisation* G4PVDivision::GetParameterisation() const
306 {                                                 274 {
307   return fparam;                                  275   return fparam;
308 }                                                 276 }
309                                                   277 
310 //--------------------------------------------    278 //--------------------------------------------------------------------------
311 void G4PVDivision::GetReplicationData(EAxis& a    279 void G4PVDivision::GetReplicationData(EAxis& axis,
312                                       G4int& n    280                                       G4int& nDivs,
313                                       G4double    281                                       G4double& width,
314                                       G4double    282                                       G4double& offset,
315                                       G4bool&     283                                       G4bool& consuming ) const
316 {                                                 284 {
317   axis = faxis;                                << 285   axis=faxis;
318   nDivs = fnReplicas;                          << 286   nDivs=fnReplicas;
319   width = fwidth;                              << 287   width=fwidth;
320   offset = foffset;                            << 288   offset=foffset;
321   consuming = false;                           << 289   consuming=false;
322 }                                                 290 }
323                                                   291 
324 //-------------------------------------------- << 
325 EVolume G4PVDivision::VolumeType() const       << 
326 {                                              << 
327   return kParameterised;                       << 
328 }                                              << 
329                                                   292 
330 //--------------------------------------------    293 //--------------------------------------------------------------------------
331 // TODO: this method should check that the chi << 294 //TODO: this method should check that the child lv is of the correct type,
332 //       else the ComputeDimensions will never << 295 //      else the ComputeDimensions will never be called
333 //                                             << 
334 void G4PVDivision::SetParameterisation( G4Logi    296 void G4PVDivision::SetParameterisation( G4LogicalVolume* motherLogical,
335                                   const EAxis     297                                   const EAxis axis,
336                                   const G4int     298                                   const G4int nDivs,
337                                   const G4doub    299                                   const G4double width,
338                                   const G4doub    300                                   const G4double offset,
339                                         Divisi    301                                         DivisionType divType )
340 {                                                 302 {
341   // Check that solid is compatible with mothe    303   // Check that solid is compatible with mother solid and axis of division   
342   // CheckSolid( solid, motherSolid );            304   // CheckSolid( solid, motherSolid );
343   // G4cout << " Axis " << axis << G4endl;        305   // G4cout << " Axis " << axis << G4endl;
344                                                   306 
345   G4VSolid* mSolid = motherLogical->GetSolid()    307   G4VSolid* mSolid = motherLogical->GetSolid();
346   G4String mSolidType = mSolid->GetEntityType(    308   G4String mSolidType = mSolid->GetEntityType();
347                                                   309 
348   // If the solid is a reflected one, update t    310   // If the solid is a reflected one, update type to its
349   // real constituent solid.                      311   // real constituent solid.
350   //                                              312   // 
351   if (mSolidType == "G4ReflectedSolid")           313   if (mSolidType == "G4ReflectedSolid")
352   {                                               314   {
353       mSolidType = ((G4ReflectedSolid*)mSolid)    315       mSolidType = ((G4ReflectedSolid*)mSolid)->GetConstituentMovedSolid()
354                  ->GetEntityType();               316                  ->GetEntityType(); 
355   }                                               317   }    
356                                                   318 
357   // Parameterisation type depend of mother so    319   // Parameterisation type depend of mother solid type and axis of division
358   //                                              320   //
359   if( mSolidType == "G4Box" )                     321   if( mSolidType == "G4Box" )
360   {                                               322   {
361     switch( axis )                                323     switch( axis )
362     {                                             324     {
363       case kXAxis:                                325       case kXAxis:
364         fparam = new G4ParameterisationBoxX( a    326         fparam = new G4ParameterisationBoxX( axis, nDivs, width,
365                                              o    327                                              offset, mSolid, divType );
366         break;                                    328         break;
367       case kYAxis:                                329       case kYAxis:
368         fparam = new G4ParameterisationBoxY( a    330         fparam = new G4ParameterisationBoxY( axis, nDivs, width,
369                                              o    331                                              offset, mSolid, divType );
370         break;                                    332         break;
371       case kZAxis:                                333       case kZAxis:
372         fparam = new G4ParameterisationBoxZ( a    334         fparam = new G4ParameterisationBoxZ( axis, nDivs, width,
373                                              o    335                                              offset, mSolid, divType );
374         break;                                    336         break;
375       default:                                    337       default:
376         ErrorInAxis( axis, mSolid );              338         ErrorInAxis( axis, mSolid );
377         break;                                    339         break;
378     }                                             340     }
379   }                                               341   }
380   else if( mSolidType == "G4Tubs" )               342   else if( mSolidType == "G4Tubs" )
381   {                                               343   {
382     switch( axis )                                344     switch( axis )
383     {                                             345     {
384       case kRho:                                  346       case kRho:
385         fparam = new G4ParameterisationTubsRho    347         fparam = new G4ParameterisationTubsRho( axis, nDivs, width,
386                                                   348                                                 offset, mSolid, divType );
387         break;                                    349         break;
388       case kPhi:                                  350       case kPhi:
389         fparam = new G4ParameterisationTubsPhi    351         fparam = new G4ParameterisationTubsPhi( axis, nDivs, width,
390                                                   352                                                 offset, mSolid, divType );
391         break;                                    353         break;
392       case kZAxis:                                354       case kZAxis:
393         fparam = new G4ParameterisationTubsZ(     355         fparam = new G4ParameterisationTubsZ( axis, nDivs, width,
394                                                   356                                               offset, mSolid, divType );
395         break;                                    357         break;
396       default:                                    358       default:
397         ErrorInAxis( axis, mSolid );              359         ErrorInAxis( axis, mSolid );
398         break;                                    360         break;
399     }                                             361     }
400   }                                               362   }
401   else if( mSolidType == "G4Cons" )               363   else if( mSolidType == "G4Cons" )
402   {                                               364   {
403     switch( axis )                                365     switch( axis )
404     {                                             366     {
405       case kRho:                                  367       case kRho:
406         fparam = new G4ParameterisationConsRho    368         fparam = new G4ParameterisationConsRho( axis, nDivs, width,
407                                                   369                                                 offset, mSolid, divType );
408         break;                                    370         break;
409       case kPhi:                                  371       case kPhi:
410         fparam = new G4ParameterisationConsPhi    372         fparam = new G4ParameterisationConsPhi( axis, nDivs, width,
411                                                   373                                                 offset, mSolid, divType );
412         break;                                    374         break;
413       case kZAxis:                                375       case kZAxis:
414         fparam = new G4ParameterisationConsZ(     376         fparam = new G4ParameterisationConsZ( axis, nDivs, width,
415                                                   377                                               offset, mSolid, divType );
416         break;                                    378         break;
417       default:                                    379       default:
418         ErrorInAxis( axis, mSolid );              380         ErrorInAxis( axis, mSolid );
419         break;                                    381         break;
420     }                                             382     }
421   }                                               383   }
422   else if( mSolidType == "G4Trd" )                384   else if( mSolidType == "G4Trd" )
423   {                                               385   { 
424     switch( axis )                                386     switch( axis )
425     {                                             387     {
426       case kXAxis:                                388       case kXAxis:
427         fparam = new G4ParameterisationTrdX( a    389         fparam = new G4ParameterisationTrdX( axis, nDivs, width,
428                                              o    390                                              offset, mSolid, divType );
429         break;                                    391         break;
430       case kYAxis:                                392       case kYAxis:
431         fparam = new G4ParameterisationTrdY( a    393         fparam = new G4ParameterisationTrdY( axis, nDivs, width,
432                                              o    394                                              offset, mSolid, divType );
433         break;                                    395         break;
434       case kZAxis:                                396       case kZAxis:
435         fparam = new G4ParameterisationTrdZ( a    397         fparam = new G4ParameterisationTrdZ( axis, nDivs, width,
436                                              o    398                                              offset, mSolid, divType );
437         break;                                    399         break;
438       default:                                    400       default:
439         ErrorInAxis( axis, mSolid );              401         ErrorInAxis( axis, mSolid );
440         break;                                    402         break;
441     }                                             403     }
442   }                                               404   }
443   else if( mSolidType == "G4Para" )               405   else if( mSolidType == "G4Para" )
444   {                                               406   { 
445     switch( axis )                                407     switch( axis )
446     {                                             408     {
447       case kXAxis:                                409       case kXAxis:
448         fparam = new G4ParameterisationParaX(     410         fparam = new G4ParameterisationParaX( axis, nDivs, width,
449                                              o    411                                              offset, mSolid, divType );
450         break;                                    412         break;
451       case kYAxis:                                413       case kYAxis:
452         fparam = new G4ParameterisationParaY(     414         fparam = new G4ParameterisationParaY( axis, nDivs, width,
453                                              o    415                                              offset, mSolid, divType );
454         break;                                    416         break;
455       case kZAxis:                                417       case kZAxis:
456         fparam = new G4ParameterisationParaZ(     418         fparam = new G4ParameterisationParaZ( axis, nDivs, width,
457                                              o    419                                              offset, mSolid, divType );
458         break;                                    420         break;
459       default:                                    421       default:
460         ErrorInAxis( axis, mSolid );              422         ErrorInAxis( axis, mSolid );
461         break;                                    423         break;
462     }                                             424     }
463   }                                               425   }
464 //  else if( mSolidType == "G4Trap" )             426 //  else if( mSolidType == "G4Trap" )
465 //  {                                             427 //  {
466 //  }                                             428 //  }
467   else if( mSolidType == "G4Polycone" )           429   else if( mSolidType == "G4Polycone" )
468   {                                               430   {
469     switch( axis )                                431     switch( axis )
470     {                                             432     {
471       case kRho:                                  433       case kRho:
472         fparam = new G4ParameterisationPolycon    434         fparam = new G4ParameterisationPolyconeRho( axis, nDivs, width,
473                                                   435                                                     offset, mSolid, divType );
474         break;                                    436         break;
475       case kPhi:                                  437       case kPhi:
476         fparam = new G4ParameterisationPolycon    438         fparam = new G4ParameterisationPolyconePhi( axis, nDivs, width,
477                                                   439                                                     offset, mSolid, divType );
478         break;                                    440         break;
479       case kZAxis:                                441       case kZAxis:
480         fparam = new G4ParameterisationPolycon    442         fparam = new G4ParameterisationPolyconeZ( axis, nDivs, width,
481                                                   443                                                   offset, mSolid, divType );
482         break;                                    444         break;
483       default:                                    445       default:
484         ErrorInAxis( axis, mSolid );              446         ErrorInAxis( axis, mSolid );
485       break;                                      447       break;
486     }                                             448     }
487   }                                               449   }
488   else if( mSolidType == "G4Polyhedra" )          450   else if( mSolidType == "G4Polyhedra" )
489   {                                               451   {
490     switch( axis )                                452     switch( axis )
491     {                                             453     {
492       case kRho:                                  454       case kRho:
493         fparam = new G4ParameterisationPolyhed    455         fparam = new G4ParameterisationPolyhedraRho( axis, nDivs, width,
494                                                   456                                                     offset, mSolid, divType );
495         break;                                    457         break;
496       case kPhi:                                  458       case kPhi:
497         fparam = new G4ParameterisationPolyhed    459         fparam = new G4ParameterisationPolyhedraPhi( axis, nDivs, width,
498                                                   460                                                     offset, mSolid, divType );
499         break;                                    461         break;
500       case kZAxis:                                462       case kZAxis:
501         fparam = new G4ParameterisationPolyhed    463         fparam = new G4ParameterisationPolyhedraZ( axis, nDivs, width,
502                                                   464                                                   offset, mSolid, divType );
503         break;                                    465         break;
504       default:                                    466       default:
505         ErrorInAxis( axis, mSolid );              467         ErrorInAxis( axis, mSolid );
506       break;                                      468       break;
507     }                                             469     }
508   }                                               470   }
509   else                                            471   else
510   {                                               472   {
511     std::ostringstream message;                << 473     G4cerr << "ERROR - G4PVDivision::SetParameterisation()" << G4endl
512     message << "Solid type " << mSolidType <<  << 474            << "        Divisions for " << mSolidType
513             << "Divisions for " << mSolidType  << 475            << " not implemented." << G4endl;
514     G4Exception("G4PVDivision::SetParameterisa << 476     G4String message = "Solid type not supported: " + mSolidType;
                                                   >> 477     G4Exception("G4PVDivision::SetParameterisation()", "IllegalConstruct",
515                 FatalException, message);         478                 FatalException, message);
516   }                                               479   }
517 }                                                 480 }
518                                                   481 
519 //--------------------------------------------    482 //--------------------------------------------------------------------------
520 void G4PVDivision::ErrorInAxis( EAxis axis, G4    483 void G4PVDivision::ErrorInAxis( EAxis axis, G4VSolid* solid )
521 {                                                 484 {
522   G4String error = "Trying to divide solid " +    485   G4String error = "Trying to divide solid " + solid->GetName()
523                  + " of type " + solid->GetEnt    486                  + " of type " + solid->GetEntityType() + " along axis ";
524   switch( axis )                                  487   switch( axis )
525   {                                               488   {
526     case kXAxis:                                  489     case kXAxis:
527       error += "X.";                              490       error += "X.";
528       break;                                      491       break;
529     case kYAxis:                                  492     case kYAxis:
530       error += "Y.";                              493       error += "Y.";
531       break;                                      494       break;
532     case kZAxis:                                  495     case kZAxis:
533       error += "Z.";                              496       error += "Z.";
534       break;                                      497       break;
535     case kRho:                                    498     case kRho:
536       error += "Rho.";                            499       error += "Rho.";
537       break;                                      500       break;
538     case kRadial3D:                               501     case kRadial3D:
539       error += "Radial3D.";                       502       error += "Radial3D.";
540       break;                                      503       break;
541     case kPhi:                                    504     case kPhi:
542       error += "Phi.";                            505       error += "Phi.";
543       break;                                      506       break;
544     default:                                      507     default:
545       break;                                      508       break;
546   }                                               509   }
547   G4Exception("G4PVDivision::ErrorInAxis()", " << 510   G4Exception("G4PVDivision::ErrorInAxis()", "IllegalConstruct",
548               FatalException, error);             511               FatalException, error);
549 }                                                 512 }
550                                                << 513 // The next methods are for specialised repeated volumes 
551 // The next methods are for specialised repeat << 514 //     (replicas, parameterised vol.) which are completely regular.
552 // parameterised vol.) which are completely re << 
553 // Currently this is not applicable to divisio    515 // Currently this is not applicable to divisions  ( J.A. Nov 2005 )
554                                                << 
555 // -------------------------------------------    516 // ----------------------------------------------------------------------
556 // IsRegularStructure()                        << 517 // IsRegularRepeatedStructure()
557 //                                                518 //
558 G4bool G4PVDivision::IsRegularStructure() cons    519 G4bool G4PVDivision::IsRegularStructure() const
559 {                                                 520 {
560   return false;                                   521   return false;
561 }                                                 522 }           
562                                                   523 
563 // -------------------------------------------    524 // ----------------------------------------------------------------------
564 // GetRegularStructureId()                     << 525 // IsRegularRepeatedStructure()
565 //                                                526 //
566 G4int G4PVDivision::GetRegularStructureId() co    527 G4int G4PVDivision::GetRegularStructureId() const
567 {                                                 528 {
568   return 0;                                       529   return 0;  
569 }                                                 530 }           
                                                   >> 531 // This is for specialised repeated volumes (replicas, parameterised vol.)
570                                                   532