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