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