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 6.2)


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