Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/electromagnetic/xrays/include/G4Cerenkov.hh

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 /processes/electromagnetic/xrays/include/G4Cerenkov.hh (Version 11.3.0) and /processes/electromagnetic/xrays/include/G4Cerenkov.hh (Version ReleaseNotes)


** Warning: Cannot open xref database.

  1 //                                                  1 
  2 // *******************************************    
  3 // * License and Disclaimer                       
  4 // *                                              
  5 // * The  Geant4 software  is  copyright of th    
  6 // * the Geant4 Collaboration.  It is provided    
  7 // * conditions of the Geant4 Software License    
  8 // * LICENSE and available at  http://cern.ch/    
  9 // * include a list of copyright holders.         
 10 // *                                              
 11 // * Neither the authors of this software syst    
 12 // * institutes,nor the agencies providing fin    
 13 // * work  make  any representation or  warran    
 14 // * regarding  this  software system or assum    
 15 // * use.  Please see the license in the file     
 16 // * for the full disclaimer and the limitatio    
 17 // *                                              
 18 // * This  code  implementation is the result     
 19 // * technical work of the GEANT4 collaboratio    
 20 // * By using,  copying,  modifying or  distri    
 21 // * any work based  on the software)  you  ag    
 22 // * use  in  resulting  scientific  publicati    
 23 // * acceptance of all terms of the Geant4 Sof    
 24 // *******************************************    
 25 //                                                
 26 //////////////////////////////////////////////    
 27 // Cerenkov Radiation Class Definition            
 28 //////////////////////////////////////////////    
 29 //                                                
 30 // File:        G4Cerenkov.hh                     
 31 // Description: Discrete Process - Generation     
 32 // Version:     2.0                               
 33 // Created:     1996-02-21                        
 34 // Author:      Juliet Armstrong                  
 35 // Updated:     2007-09-30 change inheritance     
 36 //              2005-07-28 add G4ProcessType t    
 37 //              1999-10-29 add method and clas    
 38 //              1997-04-09 by Peter Gumplinger    
 39 //              > G4MaterialPropertiesTable; n    
 40 //                                                
 41 //////////////////////////////////////////////    
 42                                                   
 43 #ifndef G4Cerenkov_h                              
 44 #define G4Cerenkov_h 1                            
 45                                                   
 46 #include "globals.hh"                             
 47 #include "G4DynamicParticle.hh"                   
 48 #include "G4ForceCondition.hh"                    
 49 #include "G4GPILSelection.hh"                     
 50 #include "G4MaterialPropertyVector.hh"            
 51 #include "G4VProcess.hh"                          
 52                                                   
 53 class G4Material;                                 
 54 class G4ParticleDefinition;                       
 55 class G4PhysicsTable;                             
 56 class G4Step;                                     
 57 class G4Track;                                    
 58 class G4VParticleChange;                          
 59                                                   
 60 class G4Cerenkov : public G4VProcess              
 61 {                                                 
 62  public:                                          
 63   explicit G4Cerenkov(const G4String& processN    
 64                       G4ProcessType type          
 65   ~G4Cerenkov();                                  
 66                                                   
 67   explicit G4Cerenkov(const G4Cerenkov& right)    
 68                                                   
 69   G4Cerenkov& operator=(const G4Cerenkov& righ    
 70                                                   
 71   G4bool IsApplicable(const G4ParticleDefiniti    
 72   // Returns true -> 'is applicable', for all     
 73   // except short-lived particles.                
 74                                                   
 75   void BuildPhysicsTable(const G4ParticleDefin    
 76   // Build table at a right time                  
 77                                                   
 78   void PreparePhysicsTable(const G4ParticleDef    
 79   void Initialise();                              
 80                                                   
 81   G4double GetMeanFreePath(const G4Track& aTra    
 82   // Returns the discrete step limit and sets     
 83   // condition for the DoIt to be invoked at e    
 84                                                   
 85   G4double PostStepGetPhysicalInteractionLengt    
 86                                                   
 87   // Returns the discrete step limit and sets     
 88   // condition for the DoIt to be invoked at e    
 89                                                   
 90   G4VParticleChange* PostStepDoIt(const G4Trac    
 91                                   const G4Step    
 92   // This is the method implementing the Ceren    
 93                                                   
 94   //  no operation in  AtRestDoIt and  AlongSt    
 95   virtual G4double AlongStepGetPhysicalInterac    
 96     const G4Track&, G4double, G4double, G4doub    
 97   {                                               
 98     return -1.0;                                  
 99   };                                              
100                                                   
101   virtual G4double AtRestGetPhysicalInteractio    
102     const G4Track&, G4ForceCondition*) overrid    
103   {                                               
104     return -1.0;                                  
105   };                                              
106                                                   
107   //  no operation in  AtRestDoIt and  AlongSt    
108   virtual G4VParticleChange* AtRestDoIt(const     
109   {                                               
110     return nullptr;                               
111   };                                              
112                                                   
113   virtual G4VParticleChange* AlongStepDoIt(con    
114                                            con    
115   {                                               
116     return nullptr;                               
117   };                                              
118                                                   
119   void SetTrackSecondariesFirst(const G4bool s    
120   // If set, the primary particle tracking is     
121   // produced Cerenkov photons are tracked nex    
122   // been tracked, the tracking of the primary    
123                                                   
124   G4bool GetTrackSecondariesFirst() const;        
125   // Returns the boolean flag for tracking sec    
126                                                   
127   void SetMaxBetaChangePerStep(const G4double     
128   // Set the maximum allowed change in beta =     
129                                                   
130   G4double GetMaxBetaChangePerStep() const;       
131   // Returns the maximum allowed change in bet    
132                                                   
133   void SetMaxNumPhotonsPerStep(const G4int Num    
134   // Set the maximum number of Cerenkov photon    
135   // a tracking step. This is an average ONLY;    
136   // around this average. If invoked, the maxi    
137   // of the size set. If not called, the step     
138   // photons generated.                           
139                                                   
140   G4int GetMaxNumPhotonsPerStep() const;          
141   // Returns the maximum number of Cerenkov ph    
142   // generated during a tracking step.            
143                                                   
144   void SetStackPhotons(const G4bool);             
145   // Call by the user to set the flag for stac    
146                                                   
147   G4bool GetStackPhotons() const;                 
148   // Return the boolean for whether or not the    
149                                                   
150   G4int GetNumPhotons() const;                    
151   // Returns the current number of scint. phot    
152                                                   
153   G4PhysicsTable* GetPhysicsTable() const;        
154   // Returns the address of the physics table.    
155                                                   
156   void DumpPhysicsTable() const;                  
157   // Prints the physics table.                    
158                                                   
159   G4double GetAverageNumberOfPhotons(const G4d    
160                                      const G4M    
161                                      G4Materia    
162                                                   
163   void DumpInfo() const override {ProcessDescr    
164   void ProcessDescription(std::ostream& out) c    
165                                                   
166   void SetVerboseLevel(G4int);                    
167   // sets verbosity                               
168                                                   
169  protected:                                       
170   G4PhysicsTable* thePhysicsTable;                
171                                                   
172  private:                                         
173   G4double fMaxBetaChange;                        
174                                                   
175   G4int fMaxPhotons;                              
176   G4int fNumPhotons;                              
177                                                   
178   G4bool fStackingFlag;                           
179   G4bool fTrackSecondariesFirst;                  
180                                                   
181   G4int secID = -1;  // creator modelID           
182                                                   
183 };                                                
184                                                   
185 inline G4bool G4Cerenkov::GetTrackSecondariesF    
186 {                                                 
187   return fTrackSecondariesFirst;                  
188 }                                                 
189                                                   
190 inline G4double G4Cerenkov::GetMaxBetaChangePe    
191 {                                                 
192   return fMaxBetaChange;                          
193 }                                                 
194                                                   
195 inline G4int G4Cerenkov::GetMaxNumPhotonsPerSt    
196                                                   
197 inline G4bool G4Cerenkov::GetStackPhotons() co    
198                                                   
199 inline G4int G4Cerenkov::GetNumPhotons() const    
200                                                   
201 inline G4PhysicsTable* G4Cerenkov::GetPhysicsT    
202 {                                                 
203   return thePhysicsTable;                         
204 }                                                 
205                                                   
206 #endif /* G4Cerenkov_h */                         
207