Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/digits_hits/scorer/src/G4PSSphereSurfaceFlux.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 /digits_hits/scorer/src/G4PSSphereSurfaceFlux.cc (Version 11.3.0) and /digits_hits/scorer/src/G4PSSphereSurfaceFlux.cc (Version 11.0)


  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 //                                                 26 //
 27 //                                                 27 //
 28 // G4PSSphereSurfaceFlux                           28 // G4PSSphereSurfaceFlux
 29 #include "G4PSSphereSurfaceFlux.hh"                29 #include "G4PSSphereSurfaceFlux.hh"
 30                                                    30 
 31 #include "G4SystemOfUnits.hh"                      31 #include "G4SystemOfUnits.hh"
 32 #include "G4StepStatus.hh"                         32 #include "G4StepStatus.hh"
 33 #include "G4Track.hh"                              33 #include "G4Track.hh"
 34 #include "G4VSolid.hh"                             34 #include "G4VSolid.hh"
 35 #include "G4VPhysicalVolume.hh"                    35 #include "G4VPhysicalVolume.hh"
 36 #include "G4VPVParameterisation.hh"                36 #include "G4VPVParameterisation.hh"
 37 #include "G4UnitsTable.hh"                         37 #include "G4UnitsTable.hh"
 38 #include "G4GeometryTolerance.hh"                  38 #include "G4GeometryTolerance.hh"
 39 //////////////////////////////////////////////     39 ////////////////////////////////////////////////////////////////////////////////
 40 // (Description)                                   40 // (Description)
 41 //   This is a primitive scorer class for scor     41 //   This is a primitive scorer class for scoring only Surface Flux.
 42 //  Flux version assumes only for G4Sphere sha     42 //  Flux version assumes only for G4Sphere shape.
 43 //                                                 43 //
 44 // Surface is defined  at the inside of sphere     44 // Surface is defined  at the inside of sphere.
 45 // Direction                  -Rmin   +Rmax        45 // Direction                  -Rmin   +Rmax
 46 //   0  IN || OUT            ->|<-     |           46 //   0  IN || OUT            ->|<-     |
 47 //   1  IN                   ->|       |           47 //   1  IN                   ->|       |
 48 //   2  OUT                    |<-     |           48 //   2  OUT                    |<-     |
 49 //                                                 49 //
 50 // Created: 2005-11-14  Tsukasa ASO, Akinori K     50 // Created: 2005-11-14  Tsukasa ASO, Akinori Kimura.
 51 // 29-Mar-2007  T.Aso,  Bug fix for momentum d     51 // 29-Mar-2007  T.Aso,  Bug fix for momentum direction at outgoing flux.
 52 // 2010-07-22   Introduce Unit specification.      52 // 2010-07-22   Introduce Unit specification.
 53 // 2010-07-22   Add weighted and divideByAre o     53 // 2010-07-22   Add weighted and divideByAre options
 54 // 2011-02-21   Get correct momentum direction     54 // 2011-02-21   Get correct momentum direction in Flux_Out.
 55 // 2011-09-09   Modify comment in PrintAll().      55 // 2011-09-09   Modify comment in PrintAll().
 56 // 2014-03-03  T.Aso,  To use always positive      56 // 2014-03-03  T.Aso,  To use always positive value for anglefactor.
 57 //////////////////////////////////////////////     57 ///////////////////////////////////////////////////////////////////////////////
 58                                                    58 
 59 G4PSSphereSurfaceFlux::G4PSSphereSurfaceFlux(c <<  59 G4PSSphereSurfaceFlux::G4PSSphereSurfaceFlux(G4String name, G4int direction,
 60                                              G     60                                              G4int depth)
 61   : G4PSSphereSurfaceFlux(name, direction, "pe <<  61   : G4VPrimitiveScorer(name, depth)
 62 {}                                             <<  62   , HCID(-1)
                                                   >>  63   , fDirection(direction)
                                                   >>  64   , EvtMap(0)
                                                   >>  65   , weighted(true)
                                                   >>  66   , divideByArea(true)
                                                   >>  67 {
                                                   >>  68   DefineUnitAndCategory();
                                                   >>  69   SetUnit("percm2");
                                                   >>  70 }
 63                                                    71 
 64 G4PSSphereSurfaceFlux::G4PSSphereSurfaceFlux(c <<  72 G4PSSphereSurfaceFlux::G4PSSphereSurfaceFlux(G4String name, G4int direction,
 65                                              c     73                                              const G4String& unit, G4int depth)
 66   : G4VPrimitiveScorer(name, depth)                74   : G4VPrimitiveScorer(name, depth)
 67   , HCID(-1)                                       75   , HCID(-1)
 68   , fDirection(direction)                          76   , fDirection(direction)
 69   , EvtMap(nullptr)                            <<  77   , EvtMap(0)
 70   , weighted(true)                                 78   , weighted(true)
 71   , divideByArea(true)                             79   , divideByArea(true)
 72 {                                                  80 {
 73   DefineUnitAndCategory();                         81   DefineUnitAndCategory();
 74   SetUnit(unit);                                   82   SetUnit(unit);
 75 }                                                  83 }
 76                                                    84 
                                                   >>  85 G4PSSphereSurfaceFlux::~G4PSSphereSurfaceFlux() { ; }
                                                   >>  86 
 77 G4bool G4PSSphereSurfaceFlux::ProcessHits(G4St     87 G4bool G4PSSphereSurfaceFlux::ProcessHits(G4Step* aStep, G4TouchableHistory*)
 78 {                                                  88 {
 79   G4StepPoint* preStep = aStep->GetPreStepPoin     89   G4StepPoint* preStep = aStep->GetPreStepPoint();
 80                                                    90 
 81   G4VPhysicalVolume* physVol       = preStep->     91   G4VPhysicalVolume* physVol       = preStep->GetPhysicalVolume();
 82   G4VPVParameterisation* physParam = physVol->     92   G4VPVParameterisation* physParam = physVol->GetParameterisation();
 83   G4VSolid* solid                  = nullptr;  <<  93   G4VSolid* solid                  = 0;
 84   if(physParam != nullptr)                     <<  94   if(physParam)
 85   {  // for parameterized volume                   95   {  // for parameterized volume
 86     G4int idx =                                    96     G4int idx =
 87       ((G4TouchableHistory*) (aStep->GetPreSte     97       ((G4TouchableHistory*) (aStep->GetPreStepPoint()->GetTouchable()))
 88         ->GetReplicaNumber(indexDepth);            98         ->GetReplicaNumber(indexDepth);
 89     solid = physParam->ComputeSolid(idx, physV     99     solid = physParam->ComputeSolid(idx, physVol);
 90     solid->ComputeDimensions(physParam, idx, p    100     solid->ComputeDimensions(physParam, idx, physVol);
 91   }                                               101   }
 92   else                                            102   else
 93   {  // for ordinary volume                       103   {  // for ordinary volume
 94     solid = physVol->GetLogicalVolume()->GetSo    104     solid = physVol->GetLogicalVolume()->GetSolid();
 95   }                                               105   }
 96                                                   106 
 97   auto  sphereSolid = (G4Sphere*) (solid);     << 107   G4Sphere* sphereSolid = (G4Sphere*) (solid);
 98                                                   108 
 99   G4int dirFlag = IsSelectedSurface(aStep, sph    109   G4int dirFlag = IsSelectedSurface(aStep, sphereSolid);
100   if(dirFlag > 0)                                 110   if(dirFlag > 0)
101   {                                               111   {
102     if(fDirection == fFlux_InOut || fDirection    112     if(fDirection == fFlux_InOut || fDirection == dirFlag)
103     {                                             113     {
104       G4StepPoint* thisStep = nullptr;         << 114       G4StepPoint* thisStep = 0;
105       if(dirFlag == fFlux_In)                     115       if(dirFlag == fFlux_In)
106       {                                           116       {
107         thisStep = preStep;                       117         thisStep = preStep;
108       }                                           118       }
109       else if(dirFlag == fFlux_Out)               119       else if(dirFlag == fFlux_Out)
110       {                                           120       {
111         thisStep = aStep->GetPostStepPoint();     121         thisStep = aStep->GetPostStepPoint();
112       }                                           122       }
113       else                                        123       else
114       {                                           124       {
115         return false;                          << 125         return FALSE;
116       }                                           126       }
117                                                   127 
118       G4TouchableHandle theTouchable = thisSte    128       G4TouchableHandle theTouchable = thisStep->GetTouchableHandle();
119       G4ThreeVector pdirection       = thisSte    129       G4ThreeVector pdirection       = thisStep->GetMomentumDirection();
120       G4ThreeVector localdir =                    130       G4ThreeVector localdir =
121         theTouchable->GetHistory()->GetTopTran    131         theTouchable->GetHistory()->GetTopTransform().TransformAxis(pdirection);
122       G4double localdirL2 = localdir.x() * loc    132       G4double localdirL2 = localdir.x() * localdir.x() +
123                             localdir.y() * loc    133                             localdir.y() * localdir.y() +
124                             localdir.z() * loc    134                             localdir.z() * localdir.z();
125       G4ThreeVector stppos1 = aStep->GetPreSte    135       G4ThreeVector stppos1 = aStep->GetPreStepPoint()->GetPosition();
126       G4ThreeVector localpos1 =                   136       G4ThreeVector localpos1 =
127         theTouchable->GetHistory()->GetTopTran    137         theTouchable->GetHistory()->GetTopTransform().TransformPoint(stppos1);
128       G4double localR2 = localpos1.x() * local    138       G4double localR2 = localpos1.x() * localpos1.x() +
129                          localpos1.y() * local    139                          localpos1.y() * localpos1.y() +
130                          localpos1.z() * local    140                          localpos1.z() * localpos1.z();
131       G4double anglefactor =                      141       G4double anglefactor =
132         (localdir.x() * localpos1.x() + locald    142         (localdir.x() * localpos1.x() + localdir.y() * localpos1.y() +
133          localdir.z() * localpos1.z()) /          143          localdir.z() * localpos1.z()) /
134         std::sqrt(localdirL2) / std::sqrt(loca    144         std::sqrt(localdirL2) / std::sqrt(localR2);
135       if(anglefactor < 0.0)                       145       if(anglefactor < 0.0)
136         anglefactor *= -1.0;                      146         anglefactor *= -1.0;
137                                                   147 
138       G4double current = 1.0 / anglefactor;       148       G4double current = 1.0 / anglefactor;
139       if(weighted)                                149       if(weighted)
140         current *= thisStep->GetWeight();  //     150         current *= thisStep->GetWeight();  // Flux (Particle Weight)
141       if(divideByArea)                     //     151       if(divideByArea)                     // Flux with angle.
142       {                                           152       {
143         G4double radi = sphereSolid->GetInnerR    153         G4double radi = sphereSolid->GetInnerRadius();
144         G4double dph  = sphereSolid->GetDeltaP    154         G4double dph  = sphereSolid->GetDeltaPhiAngle() / radian;
145         G4double stth = sphereSolid->GetStartT    155         G4double stth = sphereSolid->GetStartThetaAngle() / radian;
146         G4double enth = stth + sphereSolid->Ge    156         G4double enth = stth + sphereSolid->GetDeltaThetaAngle() / radian;
147         current /= radi * radi * dph * (-std::    157         current /= radi * radi * dph * (-std::cos(enth) + std::cos(stth));
148       }                                           158       }
149                                                   159 
150       G4int index = GetIndex(aStep);              160       G4int index = GetIndex(aStep);
151       EvtMap->add(index, current);                161       EvtMap->add(index, current);
152     }                                             162     }
153   }                                               163   }
154                                                   164 
155   return true;                                 << 165   return TRUE;
156 }                                                 166 }
157                                                   167 
158 G4int G4PSSphereSurfaceFlux::IsSelectedSurface    168 G4int G4PSSphereSurfaceFlux::IsSelectedSurface(G4Step* aStep,
159                                                   169                                                G4Sphere* sphereSolid)
160 {                                                 170 {
161   G4TouchableHandle theTouchable =                171   G4TouchableHandle theTouchable =
162     aStep->GetPreStepPoint()->GetTouchableHand    172     aStep->GetPreStepPoint()->GetTouchableHandle();
163   G4double kCarTolerance =                        173   G4double kCarTolerance =
164     G4GeometryTolerance::GetInstance()->GetSur    174     G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
165                                                   175 
166   if(aStep->GetPreStepPoint()->GetStepStatus()    176   if(aStep->GetPreStepPoint()->GetStepStatus() == fGeomBoundary)
167   {                                               177   {
168     // Entering Geometry                          178     // Entering Geometry
169     G4ThreeVector stppos1 = aStep->GetPreStepP    179     G4ThreeVector stppos1 = aStep->GetPreStepPoint()->GetPosition();
170     G4ThreeVector localpos1 =                     180     G4ThreeVector localpos1 =
171       theTouchable->GetHistory()->GetTopTransf    181       theTouchable->GetHistory()->GetTopTransform().TransformPoint(stppos1);
172     G4double localR2 = localpos1.x() * localpo    182     G4double localR2 = localpos1.x() * localpos1.x() +
173                        localpos1.y() * localpo    183                        localpos1.y() * localpos1.y() +
174                        localpos1.z() * localpo    184                        localpos1.z() * localpos1.z();
175     // G4double InsideRadius2 =                   185     // G4double InsideRadius2 =
176     //  sphereSolid->GetInsideRadius()*sphereS    186     //  sphereSolid->GetInsideRadius()*sphereSolid->GetInsideRadius();
177     // if(std::fabs( localR2 - InsideRadius2 )    187     // if(std::fabs( localR2 - InsideRadius2 ) < kCarTolerance ){
178     G4double InsideRadius = sphereSolid->GetIn    188     G4double InsideRadius = sphereSolid->GetInnerRadius();
179     if(localR2 >                                  189     if(localR2 >
180          (InsideRadius - kCarTolerance) * (Ins    190          (InsideRadius - kCarTolerance) * (InsideRadius - kCarTolerance) &&
181        localR2 <                                  191        localR2 <
182          (InsideRadius + kCarTolerance) * (Ins    192          (InsideRadius + kCarTolerance) * (InsideRadius + kCarTolerance))
183     {                                             193     {
184       return fFlux_In;                            194       return fFlux_In;
185     }                                             195     }
186   }                                               196   }
187                                                   197 
188   if(aStep->GetPostStepPoint()->GetStepStatus(    198   if(aStep->GetPostStepPoint()->GetStepStatus() == fGeomBoundary)
189   {                                               199   {
190     // Exiting Geometry                           200     // Exiting Geometry
191     G4ThreeVector stppos2 = aStep->GetPostStep    201     G4ThreeVector stppos2 = aStep->GetPostStepPoint()->GetPosition();
192     G4ThreeVector localpos2 =                     202     G4ThreeVector localpos2 =
193       theTouchable->GetHistory()->GetTopTransf    203       theTouchable->GetHistory()->GetTopTransform().TransformPoint(stppos2);
194     G4double localR2 = localpos2.x() * localpo    204     G4double localR2 = localpos2.x() * localpos2.x() +
195                        localpos2.y() * localpo    205                        localpos2.y() * localpos2.y() +
196                        localpos2.z() * localpo    206                        localpos2.z() * localpos2.z();
197     // G4double InsideRadius2 =                   207     // G4double InsideRadius2 =
198     //  sphereSolid->GetInsideRadius()*sphereS    208     //  sphereSolid->GetInsideRadius()*sphereSolid->GetInsideRadius();
199     // if(std::facb(localR2 - InsideRadius2) )    209     // if(std::facb(localR2 - InsideRadius2) ) < kCarTolerance ){
200     G4double InsideRadius = sphereSolid->GetIn    210     G4double InsideRadius = sphereSolid->GetInnerRadius();
201     if(localR2 >                                  211     if(localR2 >
202          (InsideRadius - kCarTolerance) * (Ins    212          (InsideRadius - kCarTolerance) * (InsideRadius - kCarTolerance) &&
203        localR2 <                                  213        localR2 <
204          (InsideRadius + kCarTolerance) * (Ins    214          (InsideRadius + kCarTolerance) * (InsideRadius + kCarTolerance))
205     {                                             215     {
206       return fFlux_Out;                           216       return fFlux_Out;
207     }                                             217     }
208   }                                               218   }
209                                                   219 
210   return -1;                                      220   return -1;
211 }                                                 221 }
212                                                   222 
213 void G4PSSphereSurfaceFlux::Initialize(G4HCofT    223 void G4PSSphereSurfaceFlux::Initialize(G4HCofThisEvent* HCE)
214 {                                                 224 {
215   EvtMap = new G4THitsMap<G4double>(detector->    225   EvtMap = new G4THitsMap<G4double>(detector->GetName(), GetName());
216   if(HCID < 0)                                    226   if(HCID < 0)
217     HCID = GetCollectionID(0);                    227     HCID = GetCollectionID(0);
218   HCE->AddHitsCollection(HCID, (G4VHitsCollect    228   HCE->AddHitsCollection(HCID, (G4VHitsCollection*) EvtMap);
219 }                                                 229 }
220                                                   230 
                                                   >> 231 void G4PSSphereSurfaceFlux::EndOfEvent(G4HCofThisEvent*) { ; }
                                                   >> 232 
221 void G4PSSphereSurfaceFlux::clear() { EvtMap->    233 void G4PSSphereSurfaceFlux::clear() { EvtMap->clear(); }
222                                                   234 
                                                   >> 235 void G4PSSphereSurfaceFlux::DrawAll() { ; }
                                                   >> 236 
223 void G4PSSphereSurfaceFlux::PrintAll()            237 void G4PSSphereSurfaceFlux::PrintAll()
224 {                                                 238 {
225   G4cout << " MultiFunctionalDet  " << detecto    239   G4cout << " MultiFunctionalDet  " << detector->GetName() << G4endl;
226   G4cout << " PrimitiveScorer " << GetName() <    240   G4cout << " PrimitiveScorer " << GetName() << G4endl;
227   G4cout << " Number of entries " << EvtMap->e    241   G4cout << " Number of entries " << EvtMap->entries() << G4endl;
228   for(const auto& [copy, flux] : *(EvtMap->Get << 242   std::map<G4int, G4double*>::iterator itr = EvtMap->GetMap()->begin();
                                                   >> 243   for(; itr != EvtMap->GetMap()->end(); itr++)
229   {                                               244   {
230     G4cout << "  copy no.: " << copy           << 245     G4cout << "  copy no.: " << itr->first
231            << "  Flux  : " << *(flux) / GetUni << 246            << "  Flux  : " << *(itr->second) / GetUnitValue() << " ["
232            << GetUnit() << "]" << G4endl;         247            << GetUnit() << "]" << G4endl;
233   }                                               248   }
234 }                                                 249 }
235                                                   250 
236 void G4PSSphereSurfaceFlux::SetUnit(const G4St    251 void G4PSSphereSurfaceFlux::SetUnit(const G4String& unit)
237 {                                                 252 {
238   if(divideByArea)                                253   if(divideByArea)
239   {                                               254   {
240     CheckAndSetUnit(unit, "Per Unit Surface");    255     CheckAndSetUnit(unit, "Per Unit Surface");
241   }                                               256   }
242   else                                            257   else
243   {                                               258   {
244     if(unit.empty())                           << 259     if(unit == "")
245     {                                             260     {
246       unitName  = unit;                           261       unitName  = unit;
247       unitValue = 1.0;                            262       unitValue = 1.0;
248     }                                             263     }
249     else                                          264     else
250     {                                             265     {
251       G4String msg = "Invalid unit [" + unit +    266       G4String msg = "Invalid unit [" + unit + "] (Current  unit is [" +
252                      GetUnit() + "] ) for " +     267                      GetUnit() + "] ) for " + GetName();
253       G4Exception("G4PSSphereSurfaceFlux::SetU    268       G4Exception("G4PSSphereSurfaceFlux::SetUnit", "DetPS0016", JustWarning,
254                   msg);                           269                   msg);
255     }                                             270     }
256   }                                               271   }
257 }                                                 272 }
258                                                   273 
259 void G4PSSphereSurfaceFlux::DefineUnitAndCateg    274 void G4PSSphereSurfaceFlux::DefineUnitAndCategory()
260 {                                                 275 {
261   // Per Unit Surface                             276   // Per Unit Surface
262   new G4UnitDefinition("percentimeter2", "perc    277   new G4UnitDefinition("percentimeter2", "percm2", "Per Unit Surface",
263                        (1. / cm2));               278                        (1. / cm2));
264   new G4UnitDefinition("permillimeter2", "perm    279   new G4UnitDefinition("permillimeter2", "permm2", "Per Unit Surface",
265                        (1. / mm2));               280                        (1. / mm2));
266   new G4UnitDefinition("permeter2", "perm2", "    281   new G4UnitDefinition("permeter2", "perm2", "Per Unit Surface", (1. / m2));
267 }                                                 282 }
268                                                   283