Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/divisions/src/G4VDivisionParameterisation.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/G4VDivisionParameterisation.cc (Version 11.3.0) and /geometry/divisions/src/G4VDivisionParameterisation.cc (Version 9.6.p4)


  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 // G4VDivisionParameterisation implementation  <<  26 //
                                                   >>  27 // $Id: G4VDivisionParameterisation.cc 69784 2013-05-15 09:16:06Z gcosmo $
                                                   >>  28 //
                                                   >>  29 // class G4VDivisionParameterisation Implementation file
 27 //                                                 30 //
 28 // 26.05.03 - P.Arce, Initial version              31 // 26.05.03 - P.Arce, Initial version
 29 // 08.04.04 - I.Hrivnacova, Implemented reflec     32 // 08.04.04 - I.Hrivnacova, Implemented reflection
 30 // 21.04.10 - M.Asai, Added gaps                   33 // 21.04.10 - M.Asai, Added gaps
 31 // -------------------------------------------     34 // --------------------------------------------------------------------
 32                                                    35 
 33 #include "G4VDivisionParameterisation.hh"          36 #include "G4VDivisionParameterisation.hh" 
 34 #include "G4VSolid.hh"                             37 #include "G4VSolid.hh"
 35 #include "G4VPhysicalVolume.hh"                    38 #include "G4VPhysicalVolume.hh"
 36 #include "G4RotationMatrix.hh"                     39 #include "G4RotationMatrix.hh"
 37 #include "G4ReflectedSolid.hh"                     40 #include "G4ReflectedSolid.hh"
 38 #include "G4GeometryTolerance.hh"                  41 #include "G4GeometryTolerance.hh"
 39 #include "G4AutoDelete.hh"                     << 
 40                                                    42 
 41 const G4int G4VDivisionParameterisation::verbo <<  43 G4int G4VDivisionParameterisation::verbose = 5;
 42 G4ThreadLocal G4RotationMatrix* G4VDivisionPar << 
 43                                                    44 
 44 //--------------------------------------------     45 //--------------------------------------------------------------------------
 45 G4VDivisionParameterisation::                      46 G4VDivisionParameterisation::
 46 G4VDivisionParameterisation( EAxis axis, G4int     47 G4VDivisionParameterisation( EAxis axis, G4int nDiv,
 47                              G4double step, G4     48                              G4double step, G4double offset,
 48                              DivisionType divT     49                              DivisionType divType, G4VSolid* motherSolid )
 49   : faxis(axis), fnDiv( nDiv), fwidth(step), f     50   : faxis(axis), fnDiv( nDiv), fwidth(step), foffset(offset),
 50     fDivisionType(divType), fmotherSolid( moth <<  51     fDivisionType(divType), fmotherSolid( motherSolid ), fReflectedSolid(false),
                                                   >>  52     fDeleteSolid(false), theVoluFirstCopyNo(1), fhgap(0.)
 51 {                                                  53 {
 52 #ifdef G4DIVDEBUG                                  54 #ifdef G4DIVDEBUG
 53   if (verbose >= 1)                                55   if (verbose >= 1)
 54   {                                                56   {
 55     G4cout << " G4VDivisionParameterisation  n     57     G4cout << " G4VDivisionParameterisation  no divisions " << fnDiv
 56            << " = " << nDiv << G4endl              58            << " = " << nDiv << G4endl
 57            << " offset " << foffset << " = " <     59            << " offset " << foffset << " = " << offset << G4endl
 58            << " step " << fwidth << " = " << s     60            << " step " << fwidth << " = " << step << G4endl;
 59   }                                                61   }
 60 #endif                                             62 #endif
 61   kCarTolerance = G4GeometryTolerance::GetInst     63   kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
 62 }                                                  64 }
 63                                                    65 
 64 //--------------------------------------------     66 //--------------------------------------------------------------------------
 65 G4VDivisionParameterisation::~G4VDivisionParam     67 G4VDivisionParameterisation::~G4VDivisionParameterisation()
 66 {                                                  68 {
 67   if (fDeleteSolid)  { delete fmotherSolid; }  <<  69   if (fDeleteSolid) delete fmotherSolid; 
 68 }                                                  70 }
 69                                                    71 
 70 //--------------------------------------------     72 //--------------------------------------------------------------------------
 71 G4VSolid*                                          73 G4VSolid* 
 72 G4VDivisionParameterisation::                      74 G4VDivisionParameterisation::
 73 ComputeSolid( const G4int i, G4VPhysicalVolume     75 ComputeSolid( const G4int i, G4VPhysicalVolume* pv )
 74 {                                                  76 {
 75   G4VSolid* solid = G4VPVParameterisation::Com     77   G4VSolid* solid = G4VPVParameterisation::ComputeSolid(i, pv);
 76   if (solid->GetEntityType() == "G4ReflectedSo     78   if (solid->GetEntityType() == "G4ReflectedSolid")
 77   {                                                79   {
 78     solid = ((G4ReflectedSolid*)solid)->GetCon     80     solid = ((G4ReflectedSolid*)solid)->GetConstituentMovedSolid();
 79   }                                                81   }
 80   return solid;                                    82   return solid;
 81 }                                                  83 }      
 82                                                    84 
 83 //--------------------------------------------     85 //--------------------------------------------------------------------------
 84 void                                               86 void
 85 G4VDivisionParameterisation::                      87 G4VDivisionParameterisation::
 86 ChangeRotMatrix( G4VPhysicalVolume* physVol, G <<  88 ChangeRotMatrix( G4VPhysicalVolume *physVol, G4double rotZ ) const
 87 {                                                  89 {
 88   if (fRot == nullptr)                         <<  90   G4RotationMatrix* rm = new G4RotationMatrix();
 89   {                                            <<  91   rm->rotateZ( rotZ );
 90     fRot = new G4RotationMatrix();             <<  92   //----- set rotation
 91     G4AutoDelete::Register(fRot);              <<  93   //----- delete first old rotation matrix 
 92   }                                            <<  94   G4RotationMatrix* rmold = physVol->GetRotation();
 93   fRot->rotateZ( rotZ );                       <<  95   delete rmold;
 94   physVol->SetRotation(fRot);                  <<  96   physVol->SetRotation(rm);
 95 }                                                  97 }
 96                                                    98 
 97 //--------------------------------------------     99 //--------------------------------------------------------------------------
 98 G4int                                             100 G4int
 99 G4VDivisionParameterisation::                     101 G4VDivisionParameterisation::
100 CalculateNDiv( G4double motherDim, G4double wi    102 CalculateNDiv( G4double motherDim, G4double width, G4double offset ) const
101 {                                                 103 {
102 #ifdef G4DIVDEBUG                                 104 #ifdef G4DIVDEBUG
103   G4cout << " G4VDivisionParameterisation::Cal    105   G4cout << " G4VDivisionParameterisation::CalculateNDiv: "
104          << ( motherDim - offset ) / width        106          << ( motherDim - offset ) / width 
105          << " Motherdim: " <<  motherDim << ",    107          << " Motherdim: " <<  motherDim << ", Offset: " << offset
106          << ", Width: " << width << G4endl;       108          << ", Width: " << width << G4endl;
107 #endif                                            109 #endif
108                                                   110 
109   return G4int( ( motherDim - offset ) / width    111   return G4int( ( motherDim - offset ) / width );
110 }                                                 112 }
111                                                   113 
112 //--------------------------------------------    114 //--------------------------------------------------------------------------
113 G4double                                          115 G4double
114 G4VDivisionParameterisation::                     116 G4VDivisionParameterisation::
115 CalculateWidth( G4double motherDim, G4int nDiv    117 CalculateWidth( G4double motherDim, G4int nDiv, G4double offset ) const
116 {                                                 118 { 
117 #ifdef G4DIVDEBUG                                 119 #ifdef G4DIVDEBUG
118   G4cout << " G4VDivisionParameterisation::Cal    120   G4cout << " G4VDivisionParameterisation::CalculateWidth: "
119          << ( motherDim - offset ) / nDiv         121          << ( motherDim - offset ) / nDiv
120          << ", Motherdim: " << motherDim << ",    122          << ", Motherdim: " << motherDim << ", Offset: " << offset
121          << ", Number of divisions: " << nDiv     123          << ", Number of divisions: " << nDiv << G4endl;
122 #endif                                            124 #endif
123                                                   125 
124   return ( motherDim - offset ) / nDiv;           126   return ( motherDim - offset ) / nDiv;
125 }                                                 127 }
126                                                   128 
127 //--------------------------------------------    129 //--------------------------------------------------------------------------
128 void G4VDivisionParameterisation::CheckParamet    130 void G4VDivisionParameterisation::CheckParametersValidity()
129 {                                                 131 {
130   G4double maxPar = GetMaxParameter();            132   G4double maxPar = GetMaxParameter();
131   CheckOffset( maxPar );                          133   CheckOffset( maxPar );
132   CheckNDivAndWidth( maxPar );                    134   CheckNDivAndWidth( maxPar );
133 }                                                 135 }
134                                                   136 
135 //--------------------------------------------    137 //--------------------------------------------------------------------------
136 void G4VDivisionParameterisation::CheckOffset(    138 void G4VDivisionParameterisation::CheckOffset( G4double maxPar )
137 {                                                 139 {
138   if( foffset >= maxPar )                         140   if( foffset >= maxPar )
139   {                                               141   {
140     std::ostringstream message;                   142     std::ostringstream message;
141     message << "Configuration not supported."     143     message << "Configuration not supported." << G4endl
142             << "Division of solid " << fmother    144             << "Division of solid " << fmotherSolid->GetName()
143             << " has too big offset = " << G4e    145             << " has too big offset = " << G4endl
144             << "        " << foffset << " > "     146             << "        " << foffset << " > " << maxPar << " !";
145     G4Exception("G4VDivisionParameterisation::    147     G4Exception("G4VDivisionParameterisation::CheckOffset()",
146                 "GeomDiv0001", FatalException,    148                 "GeomDiv0001", FatalException, message);
147   }                                               149   }
148 }                                                 150 }
149                                                   151 
150 //--------------------------------------------    152 //--------------------------------------------------------------------------
151 void G4VDivisionParameterisation::CheckNDivAnd    153 void G4VDivisionParameterisation::CheckNDivAndWidth( G4double maxPar )
152 {                                                 154 {
153   if( (fDivisionType == DivNDIVandWIDTH)          155   if( (fDivisionType == DivNDIVandWIDTH)
154       && (foffset + fwidth*fnDiv - maxPar > kC    156       && (foffset + fwidth*fnDiv - maxPar > kCarTolerance ) )
155   {                                               157   {
156     std::ostringstream message;                   158     std::ostringstream message;
157     message << "Configuration not supported."     159     message << "Configuration not supported." << G4endl
158             << "Division of solid " << fmother    160             << "Division of solid " << fmotherSolid->GetName()
159            << " has too big offset + width*nDi    161            << " has too big offset + width*nDiv = " << G4endl
160            << "        " << foffset + fwidth*f    162            << "        " << foffset + fwidth*fnDiv << " > "
161            << foffset << ". Width = "             163            << foffset << ". Width = "
162            << G4endl                              164            << G4endl
163            << "        " << fwidth << ". nDiv     165            << "        " << fwidth << ". nDiv = " << fnDiv << " !";
164     G4Exception("G4VDivisionParameterisation::    166     G4Exception("G4VDivisionParameterisation::CheckNDivAndWidth()",
165                 "GeomDiv0001", FatalException,    167                 "GeomDiv0001", FatalException, message);
166   }                                               168   }
167 }                                                 169 }
168                                                   170 
169 //--------------------------------------------    171 //--------------------------------------------------------------------------
170 G4double G4VDivisionParameterisation::OffsetZ(    172 G4double G4VDivisionParameterisation::OffsetZ() const
171 {                                                 173 {
172   // take into account reflection in the offse    174   // take into account reflection in the offset
173                                                << 
174   G4double offset = foffset;                      175   G4double offset = foffset;
175   if (fReflectedSolid)                         << 176   if (fReflectedSolid) offset = GetMaxParameter() - fwidth*fnDiv - foffset; 
176   {                                            << 
177     offset = GetMaxParameter() - fwidth*fnDiv  << 
178   }                                            << 
179                                                   177 
180   return offset;                                  178   return offset;
181 }                                                 179 }  
182                                                   180 
183                                                   181   
184                                                   182