Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/volumes/src/G4PVParameterised.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/volumes/src/G4PVParameterised.cc (Version 11.3.0) and /geometry/volumes/src/G4PVParameterised.cc (Version 11.2.1)


  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 // class G4PVParameterised implementation          26 // class G4PVParameterised implementation
 27 //                                                 27 //
 28 // 29.07.95, P.Kent - first non-stub version       28 // 29.07.95, P.Kent - first non-stub version
 29 // -------------------------------------------     29 // ----------------------------------------------------------------------
 30                                                    30 
 31 #include "G4PVParameterised.hh"                    31 #include "G4PVParameterised.hh"
 32 #include "G4VPVParameterisation.hh"                32 #include "G4VPVParameterisation.hh"
 33 #include "G4AffineTransform.hh"                    33 #include "G4AffineTransform.hh"
 34 #include "G4UnitsTable.hh"                         34 #include "G4UnitsTable.hh"
 35 #include "G4VSolid.hh"                             35 #include "G4VSolid.hh"
 36 #include "G4LogicalVolume.hh"                      36 #include "G4LogicalVolume.hh"
 37                                                    37 
 38 // -------------------------------------------     38 // ----------------------------------------------------------------------
 39 // Constructor                                     39 // Constructor
 40 //                                                 40 //
 41 G4PVParameterised::G4PVParameterised( const G4     41 G4PVParameterised::G4PVParameterised( const G4String& pName,
 42                                             G4     42                                             G4LogicalVolume* pLogical,
 43                                             G4     43                                             G4VPhysicalVolume* pMotherPhysical,
 44                                       const EA     44                                       const EAxis pAxis,
 45                                       const G4     45                                       const G4int nReplicas,
 46                                             G4     46                                             G4VPVParameterisation* pParam,
 47                                             G4     47                                             G4bool pSurfChk )
 48 : G4PVReplica(pName, nReplicas, pAxis, pLogica     48 : G4PVReplica(pName, nReplicas, pAxis, pLogical,
 49               pMotherPhysical != nullptr ? pMo     49               pMotherPhysical != nullptr ? pMotherPhysical->GetLogicalVolume() : nullptr ),
 50     fparam(pParam)                                 50     fparam(pParam)
 51 {                                                  51 {
 52   G4LogicalVolume* motherLogical= pMotherPhysi     52   G4LogicalVolume* motherLogical= pMotherPhysical != nullptr ?
 53       pMotherPhysical->GetLogicalVolume() : nu     53       pMotherPhysical->GetLogicalVolume() : nullptr;
 54                                                    54 
 55   SetMotherLogical( motherLogical );               55   SetMotherLogical( motherLogical );
 56   if( motherLogical != nullptr )                   56   if( motherLogical != nullptr )
 57   {                                                57   {
 58     // Registration moved here to ensure that      58     // Registration moved here to ensure that the volume is recognised as Parameterised     
 59     motherLogical->AddDaughter(this);              59     motherLogical->AddDaughter(this);
 60   }                                                60   }
 61                                                    61 
 62 #ifdef G4VERBOSE                                   62 #ifdef G4VERBOSE  
 63   if ((pMotherPhysical != nullptr) && (pMother     63   if ((pMotherPhysical != nullptr) && (pMotherPhysical->IsParameterised()))
 64   {                                                64   {
 65     std::ostringstream message, hint;              65     std::ostringstream message, hint;
 66     message << "A parameterised volume is bein     66     message << "A parameterised volume is being placed" << G4endl
 67             << "inside another parameterised v     67             << "inside another parameterised volume !";
 68     hint << "To make sure that no overlaps are     68     hint << "To make sure that no overlaps are generated," << G4endl
 69          << "you should verify the mother repl     69          << "you should verify the mother replicated shapes" << G4endl
 70          << "are of the same type and dimensio     70          << "are of the same type and dimensions." << G4endl
 71          << "   Mother physical volume: " << p     71          << "   Mother physical volume: " << pMotherPhysical->GetName() << G4endl
 72          << "   Parameterised volume: " << pNa     72          << "   Parameterised volume: " << pName << G4endl
 73          << "  (To switch this warning off, co     73          << "  (To switch this warning off, compile with G4_NO_VERBOSE)";
 74     G4Exception("G4PVParameterised::G4PVParame     74     G4Exception("G4PVParameterised::G4PVParameterised()", "GeomVol1002",
 75                 JustWarning, message, G4String     75                 JustWarning, message, G4String(hint.str()));
 76   }                                                76   }
 77 #endif                                             77 #endif
 78   if (pSurfChk) { CheckOverlaps(); }               78   if (pSurfChk) { CheckOverlaps(); }
 79 }                                                  79 }
 80                                                    80 
 81 // -------------------------------------------     81 // ----------------------------------------------------------------------
 82 // Constructor                                     82 // Constructor
 83 //                                                 83 //
 84 G4PVParameterised::G4PVParameterised( const G4     84 G4PVParameterised::G4PVParameterised( const G4String& pName,
 85                                             G4     85                                             G4LogicalVolume* pLogical,
 86                                             G4     86                                             G4LogicalVolume* pMotherLogical,
 87                                       const EA     87                                       const EAxis pAxis,
 88                                       const G4     88                                       const G4int nReplicas,
 89                                             G4     89                                             G4VPVParameterisation* pParam,
 90                                             G4     90                                             G4bool pSurfChk )
 91   : G4PVReplica(pName, nReplicas, pAxis, pLogi     91   : G4PVReplica(pName, nReplicas, pAxis, pLogical, pMotherLogical ),
 92     fparam(pParam)                                 92     fparam(pParam)
 93 {                                                  93 {
 94   SetMotherLogical( pMotherLogical );              94   SetMotherLogical( pMotherLogical );
 95   if( pMotherLogical != nullptr )                  95   if( pMotherLogical != nullptr )
 96   {                                                96   {
 97     // Registration moved here to ensure that      97     // Registration moved here to ensure that the volume is recognised as Parameterised
 98     pMotherLogical->AddDaughter(this);             98     pMotherLogical->AddDaughter(this);
 99   }                                                99   }
100   if (pSurfChk) { CheckOverlaps(); }              100   if (pSurfChk) { CheckOverlaps(); }
101 }                                                 101 }
102                                                   102 
103 // -------------------------------------------    103 // ----------------------------------------------------------------------
104 // Fake default constructor - sets only member    104 // Fake default constructor - sets only member data and allocates memory
105 //                            for usage restri    105 //                            for usage restricted to object persistency.
106 //                                                106 //
107 G4PVParameterised::G4PVParameterised( __void__    107 G4PVParameterised::G4PVParameterised( __void__& a )
108   : G4PVReplica(a)                                108   : G4PVReplica(a)
109 {                                                 109 {
110 }                                                 110 }
111                                                   111 
112 // -------------------------------------------    112 // ----------------------------------------------------------------------
113 // Destructor                                     113 // Destructor
114 //                                                114 //
115 G4PVParameterised::~G4PVParameterised() = defa    115 G4PVParameterised::~G4PVParameterised() = default;
116                                                   116 
117 // -------------------------------------------    117 // ----------------------------------------------------------------------
118 // GetParameterisation                            118 // GetParameterisation
119 //                                                119 //
120 G4VPVParameterisation* G4PVParameterised::GetP    120 G4VPVParameterisation* G4PVParameterised::GetParameterisation() const
121 {                                                 121 {
122   return fparam;                                  122   return fparam;
123 }                                                 123 }
124                                                   124 
125 // -------------------------------------------    125 // ----------------------------------------------------------------------
126 // IsParameterised                                126 // IsParameterised
127 //                                                127 //
128 G4bool G4PVParameterised::IsParameterised() co    128 G4bool G4PVParameterised::IsParameterised() const
129 {                                                 129 {
130   return true;                                    130   return true;
131 }                                                 131 }
132                                                   132 
133 // -------------------------------------------    133 // ----------------------------------------------------------------------
134 // VolumeType                                     134 // VolumeType
135 //                                                135 //
136 EVolume G4PVParameterised::VolumeType() const     136 EVolume G4PVParameterised::VolumeType() const 
137 {                                                 137 {
138   return kParameterised;                          138   return kParameterised;
139 }                                                 139 }
140                                                   140 
141 // -------------------------------------------    141 // ----------------------------------------------------------------------
142 // GetReplicationData                             142 // GetReplicationData
143 //                                                143 //
144 void G4PVParameterised::GetReplicationData( EA    144 void G4PVParameterised::GetReplicationData( EAxis& axis,
145                                             G4    145                                             G4int& nReplicas,
146                                             G4    146                                             G4double& width,
147                                             G4    147                                             G4double& offset,
148                                             G4    148                                             G4bool& consuming) const
149 {                                                 149 {
150   axis = faxis;                                   150   axis = faxis;
151   nReplicas = fnReplicas;                         151   nReplicas = fnReplicas;
152   width = fwidth;                                 152   width = fwidth;
153   offset = foffset;                               153   offset = foffset;
154   consuming = false;                              154   consuming = false;
155 }                                                 155 }
156                                                   156 
157 // -------------------------------------------    157 // ----------------------------------------------------------------------
158 // SetRegularStructureId                          158 // SetRegularStructureId
159 //                                                159 //
160 void  G4PVParameterised::SetRegularStructureId    160 void  G4PVParameterised::SetRegularStructureId( G4int code )
161 {                                                 161 {
162   G4PVReplica::SetRegularStructureId( code );     162   G4PVReplica::SetRegularStructureId( code );
163   // To undertake additional preparation, a de    163   // To undertake additional preparation, a derived volume must
164   // redefine this method, while calling also     164   // redefine this method, while calling also the above method
165 }                                                 165 }
166                                                   166 
167                                                   167 
168 // -------------------------------------------    168 // ----------------------------------------------------------------------
169 // CheckOverlaps                                  169 // CheckOverlaps
170 //                                                170 //
171 G4bool                                            171 G4bool
172 G4PVParameterised::CheckOverlaps(G4int res, G4    172 G4PVParameterised::CheckOverlaps(G4int res, G4double tol,
173                                  G4bool verbos    173                                  G4bool verbose, G4int maxErr)
174 {                                                 174 {
175   if (res<=0) { return false; }                   175   if (res<=0) { return false; }
176                                                   176 
177   G4int trials = 0;                               177   G4int trials = 0;
178   G4bool retval = false;                          178   G4bool retval = false;
179   G4VSolid *solidA = nullptr, *solidB = nullpt    179   G4VSolid *solidA = nullptr, *solidB = nullptr;
180   G4LogicalVolume* motherLog = GetMotherLogica    180   G4LogicalVolume* motherLog = GetMotherLogical();
181   G4VSolid *motherSolid = motherLog->GetSolid(    181   G4VSolid *motherSolid = motherLog->GetSolid();
182   std::vector<G4ThreeVector> points;              182   std::vector<G4ThreeVector> points;
183                                                   183 
184   if (verbose)                                    184   if (verbose)
185   {                                               185   {
186     G4cout << "Checking overlaps for parameter    186     G4cout << "Checking overlaps for parameterised volume "
187            << GetName() << " ... ";               187            << GetName() << " ... ";
188   }                                               188   }
189                                                   189 
190   for (auto i=0; i<GetMultiplicity(); ++i)        190   for (auto i=0; i<GetMultiplicity(); ++i)
191   {                                               191   {
192     solidA = fparam->ComputeSolid(i, this);       192     solidA = fparam->ComputeSolid(i, this);
193     solidA->ComputeDimensions(fparam, i, this)    193     solidA->ComputeDimensions(fparam, i, this);
194     fparam->ComputeTransformation(i, this);       194     fparam->ComputeTransformation(i, this);
195                                                   195 
196     // Create the transformation from daughter    196     // Create the transformation from daughter to mother
197     //                                            197     //
198     G4AffineTransform Tm( GetRotation(), GetTr    198     G4AffineTransform Tm( GetRotation(), GetTranslation() );
199                                                   199 
200     // Generate random points on surface accor    200     // Generate random points on surface according to the given resolution,
201     // transform them to the mother's coordina    201     // transform them to the mother's coordinate system and if no overlaps
202     // with the mother volume, cache them in a    202     // with the mother volume, cache them in a vector for later use with
203     // the daughters                              203     // the daughters
204     //                                            204     //
205     for (auto n=0; n<res; ++n)                    205     for (auto n=0; n<res; ++n)
206     {                                             206     {
207       G4ThreeVector mp = Tm.TransformPoint(sol    207       G4ThreeVector mp = Tm.TransformPoint(solidA->GetPointOnSurface());
208                                                   208 
209       // Checking overlaps with the mother vol    209       // Checking overlaps with the mother volume
210       //                                          210       //
211       if (motherSolid->Inside(mp)==kOutside)      211       if (motherSolid->Inside(mp)==kOutside)
212       {                                           212       {
213         G4double distin = motherSolid->Distanc    213         G4double distin = motherSolid->DistanceToIn(mp);
214         if (distin > tol)                         214         if (distin > tol)
215         {                                         215         {
216           ++trials; retval = true;                216           ++trials; retval = true;
217           std::ostringstream message;             217           std::ostringstream message;
218           message << "Overlap with mother volu    218           message << "Overlap with mother volume !" << G4endl
219                   << "         Overlap is dete    219                   << "         Overlap is detected for volume "
220                   << GetName() << ", parameter    220                   << GetName() << ", parameterised instance: " << i << G4endl
221                   << "          with its mothe    221                   << "          with its mother volume "
222                   << motherLog->GetName() << G    222                   << motherLog->GetName() << G4endl
223                   << "          at mother loca    223                   << "          at mother local point " << mp << ", "
224                   << "overlapping by at least:    224                   << "overlapping by at least: "
225                   << G4BestUnit(distin, "Lengt    225                   << G4BestUnit(distin, "Length");
226           if (trials>=maxErr)                     226           if (trials>=maxErr)
227           {                                       227           {
228             message << G4endl                     228             message << G4endl
229                     << "NOTE: Reached maximum     229                     << "NOTE: Reached maximum fixed number -" << maxErr
230                     << "- of overlaps reports     230                     << "- of overlaps reports for this volume !";
231           }                                       231           }
232           G4Exception("G4PVParameterised::Chec    232           G4Exception("G4PVParameterised::CheckOverlaps()",
233                       "GeomVol1002", JustWarni    233                       "GeomVol1002", JustWarning, message);
234           if (trials>=maxErr)  { return true;     234           if (trials>=maxErr)  { return true; }
235         }                                         235         }
236       }                                           236       }
237       points.push_back(mp);                       237       points.push_back(mp);
238     }                                             238     }
239                                                   239 
240     // Checking overlaps with each other param    240     // Checking overlaps with each other parameterised instance
241     //                                            241     //
242     for (auto j=i+1; j<GetMultiplicity(); ++j)    242     for (auto j=i+1; j<GetMultiplicity(); ++j)
243     {                                             243     {
244       solidB = fparam->ComputeSolid(j,this);      244       solidB = fparam->ComputeSolid(j,this);
245       solidB->ComputeDimensions(fparam, j, thi    245       solidB->ComputeDimensions(fparam, j, this);
246       fparam->ComputeTransformation(j, this);     246       fparam->ComputeTransformation(j, this);
247                                                   247 
248       // Create the transformation for daughte    248       // Create the transformation for daughter volume
249       //                                          249       //
250       G4AffineTransform Td( GetRotation(), Get    250       G4AffineTransform Td( GetRotation(), GetTranslation() );
251                                                   251 
252       for (const auto & point : points)           252       for (const auto & point : points)
253       {                                           253       {
254         // Transform each point according to d    254         // Transform each point according to daughter's frame
255         //                                        255         //
256         G4ThreeVector md = Td.InverseTransform    256         G4ThreeVector md = Td.InverseTransformPoint(point);
257                                                   257 
258         if (solidB->Inside(md)==kInside)          258         if (solidB->Inside(md)==kInside)
259         {                                         259         {
260           G4double distout = solidB->DistanceT    260           G4double distout = solidB->DistanceToOut(md);
261           if (distout > tol)                      261           if (distout > tol)
262           {                                       262           {
263             ++trials; retval = true;              263             ++trials; retval = true;
264             std::ostringstream message;           264             std::ostringstream message;
265             message << "Overlap within paramet    265             message << "Overlap within parameterised volumes !" << G4endl
266                     << "          Overlap is d    266                     << "          Overlap is detected for volume "
267                     << GetName() << ", paramet    267                     << GetName() << ", parameterised instance: " << i << G4endl
268                     << "          with paramet    268                     << "          with parameterised volume instance: " << j
269                     << G4endl                     269                     << G4endl
270                     << "          at local poi    270                     << "          at local point " << md << ", "
271                     << "overlapping by at leas    271                     << "overlapping by at least: "
272                     << G4BestUnit(distout, "Le    272                     << G4BestUnit(distout, "Length")
273                     << ", related to volume in    273                     << ", related to volume instance: " << j << ".";
274             if (trials>=maxErr)                   274             if (trials>=maxErr)
275             {                                     275             {
276               message << G4endl                   276               message << G4endl
277                       << "NOTE: Reached maximu    277                       << "NOTE: Reached maximum fixed number -" << maxErr
278                       << "- of overlaps report    278                       << "- of overlaps reports for this volume !";
279             }                                     279             }
280             G4Exception("G4PVParameterised::Ch    280             G4Exception("G4PVParameterised::CheckOverlaps()",
281                         "GeomVol1002", JustWar    281                         "GeomVol1002", JustWarning, message);
282             if (trials>=maxErr)  { return true    282             if (trials>=maxErr)  { return true; }
283           }                                       283           }
284         }                                         284         }
285       }                                           285       }
286     }                                             286     }
287   }                                               287   }
288   if (verbose)                                    288   if (verbose)
289   {                                               289   {
290     G4cout << "OK! " << G4endl;                   290     G4cout << "OK! " << G4endl;
291   }                                               291   }
292                                                   292 
293   return retval;                                  293   return retval;
294 }                                                 294 }
295                                                   295