Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/parameterisation/include/G4FastSimulationManager.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/parameterisation/include/G4FastSimulationManager.hh (Version 11.3.0) and /processes/parameterisation/include/G4FastSimulationManager.hh (Version 10.6.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 //                                                 25 //
 26 //                                                 26 //
 27 //                                                 27 //
 28 //                                             <<  28 // 
 29 //--------------------------------------------     29 //---------------------------------------------------------------
 30 //                                                 30 //
 31 //  G4FastSimulationManager.hh                     31 //  G4FastSimulationManager.hh
 32 //                                                 32 //
 33 //  Description:                                   33 //  Description:
 34 //    Manages the Fast Simulation models attac     34 //    Manages the Fast Simulation models attached to a envelope.
 35 //                                                 35 //
 36 //  History:                                       36 //  History:
 37 //    Oct 97: Verderi && MoraDeFreitas - First     37 //    Oct 97: Verderi && MoraDeFreitas - First Implementation.
 38 //                                                 38 //
 39 //--------------------------------------------     39 //---------------------------------------------------------------
 40                                                    40 
                                                   >>  41 
 41 #ifndef G4FastSimulationManager_h                  42 #ifndef G4FastSimulationManager_h
 42 #define G4FastSimulationManager_h 1                43 #define G4FastSimulationManager_h 1
 43                                                    44 
 44 #include "G4FastSimulationVector.hh"           <<  45 #include "globals.hh"
 45 #include "G4FastStep.hh"                       <<  46 
 46 #include "G4FastTrack.hh"                      << 
 47 #include "G4LogicalVolume.hh"                      47 #include "G4LogicalVolume.hh"
 48 #include "G4ParticleDefinition.hh"             << 
 49 #include "G4ParticleTable.hh"                  << 
 50 #include "G4Region.hh"                             48 #include "G4Region.hh"
                                                   >>  49 #include "G4VPhysicalVolume.hh"
                                                   >>  50 #include "G4ParticleTable.hh"
                                                   >>  51 #include "G4ParticleDefinition.hh"
                                                   >>  52 #include "G4VParticleChange.hh"
                                                   >>  53 #include "G4FastTrack.hh"
                                                   >>  54 #include "G4FastStep.hh"
                                                   >>  55 #include "G4VFastSimulationModel.hh"
 51 #include "G4RotationMatrix.hh"                     56 #include "G4RotationMatrix.hh"
 52 #include "G4ThreeVector.hh"                        57 #include "G4ThreeVector.hh"
 53 #include "G4Transform3D.hh"                        58 #include "G4Transform3D.hh"
 54 #include "G4VFastSimulationModel.hh"           <<  59 #include "G4FastSimulationVector.hh"
 55 #include "G4VParticleChange.hh"                <<  60 
 56 #include "G4VPhysicalVolume.hh"                << 
 57 #include "G4ios.hh"                                61 #include "G4ios.hh"
 58 #include "globals.hh"                          <<  62 
                                                   >>  63 //---------------------------
                                                   >>  64 // For possible future needs:
                                                   >>  65 //---------------------------
                                                   >>  66 typedef G4Region G4Envelope;
 59                                                    67 
 60 //-------------------------------------------      68 //-------------------------------------------
 61 //                                                 69 //
 62 //        G4FastSimulationManager class            70 //        G4FastSimulationManager class
 63 //                                                 71 //
 64 //-------------------------------------------      72 //-------------------------------------------
 65                                                    73 
 66 // Class Description:                              74 // Class Description:
 67 //  The G4VFastSimulationModel objects are att     75 //  The G4VFastSimulationModel objects are attached to the envelope
 68 // through a G4FastSimulationManager.              76 // through a G4FastSimulationManager.
 69 //   This object will manage the list of model     77 //   This object will manage the list of models and will message them
 70 // at tracking time.                               78 // at tracking time.
 71 //                                                 79 //
 72                                                    80 
                                                   >>  81 
 73 class G4FastSimulationManager                      82 class G4FastSimulationManager
 74 {                                                  83 {
 75   public:  // with description                 <<  84 public:  // with description
 76     //------------------------                 <<  85   //------------------------
 77     // Constructor/Destructor                  <<  86   // Constructor/Destructor
 78     //------------------------                 <<  87   //------------------------
 79     // Only one Constructor. By default the en <<  88   // Only one Constructor. By default the envelope can
 80     // be placed n-Times.                      <<  89   // be placed n-Times. 
 81     // If the user is sure that it is placed j <<  90   // If the user is sure that it is placed just one time,
 82     // the IsUnique flag should be set TRUE to <<  91   // the IsUnique flag should be set TRUE to avoid the
 83     // G4AffineTransform re-calculations each  <<  92   // G4AffineTransform re-calculations each time we reach
 84     // the envelope.                           <<  93   // the envelope.
 85                                                <<  94 
 86     G4FastSimulationManager(G4Envelope* anEnve <<  95   G4FastSimulationManager(G4Envelope *anEnvelope,
 87     // This is the only constructor. In this c <<  96         G4bool        IsUnique = FALSE);
 88     // the envelope by giving the G4Region (ty <<  97   // This is the only constructor. In this constructor you specify 
 89     // pointer. The G4FastSimulationManager ob <<  98   // the envelope by giving the G4Region (typedef-ed as G4Envelope)
 90     // this envelope and will notify this G4Re <<  99   // pointer. The G4FastSimulationManager object will bind itself to
 91     // If you know that this region is used fo << 100   // this envelope and will notify this G4Region to become an envelope.
 92     // you can turn the IsUnique boolean to "t << 101   // If you know that this region is used for only one logical volume,
 93     //                                         << 102   // you can turn the IsUnique boolean to "true" to allow some optimization. 
 94     // Note that if you choose to use the G4VF << 103   //
 95     // G4Region*, G4bool) constructor for you  << 104   // Note that if you choose to use the G4VFastSimulationModel(const G4String&,
 96     // will be constructed using the given G4R << 105   // G4Region*, G4bool) constructor for you model, the G4FastSimulationManager
 97     // model constructor.                      << 106   // will be constructed using the given G4Region* and G4bool values of the
 98     //                                         << 107   // model constructor.
 99                                                << 108   //
100     // Destructor                              << 109 
101     ~G4FastSimulationManager();                << 110 public:  // without description
102                                                << 111   ~G4FastSimulationManager();
103     // Add a model to the Model List.          << 112 
104     void AddFastSimulationModel(G4VFastSimulat << 113 
105                                                << 114 public:  // with description
106     // Remove a model from the Model List.     << 115   // Methods to add/remove models to/from the Model 
107     void RemoveFastSimulationModel(G4VFastSimu << 116   // List.
108                                                << 117   //
109     // Activate a model in the Model List.     << 118   void AddFastSimulationModel(G4VFastSimulationModel*);
110     G4bool ActivateFastSimulationModel(const G << 119   // Add a model to the Model List.
111                                                << 120 
112     // Inactivate a model in the Model List.   << 121   void RemoveFastSimulationModel(G4VFastSimulationModel*);
113     G4bool InActivateFastSimulationModel(const << 122   // Remove a model from the Model List.
114                                                << 123 
115     // Methods for print/control commands      << 124   // Methods to activate/inactivate models from the Model 
116     void ListTitle() const;                    << 125   // List.
117     void ListModels() const;                   << 126 
118     void ListModels(const G4ParticleDefinition << 127   G4bool ActivateFastSimulationModel(const G4String&);
119     void ListModels(const G4String& aName) con << 128   // Activate a model in the Model List.
120     const G4Envelope* GetEnvelope() const;     << 129 
121                                                << 130   G4bool InActivateFastSimulationModel(const G4String&);
122     G4VFastSimulationModel* GetFastSimulationM << 131   // Inactivate a model in the Model List.
123                                                << 132 
124                                                << 133 public:  // without description  
125                                                << 134   // Methods for print/control commands
126     const std::vector<G4VFastSimulationModel*> << 135   void ListTitle() const;
127     {                                          << 136   void ListModels() const;
128       return ModelList;                        << 137   void ListModels(const G4ParticleDefinition*) const;
129     }                                          << 138   void ListModels(const G4String& aName) const;
130                                                << 139   const G4Envelope* GetEnvelope() const;
131     void FlushModels();                        << 140 
132                                                << 141   G4VFastSimulationModel* GetFastSimulationModel(const G4String& modelName,
133     //---------------------------------------- << 142              const G4VFastSimulationModel* previousFound,
134     // Interface methods for the               << 143              bool &foundPrevious) const;
135     // G4FastSimulationManagerProcess process. << 144 
136     //---------------------------------------- << 145   const std::vector<G4VFastSimulationModel*>& GetFastSimulationModelList() const
137     // Trigger                                 << 146   {return ModelList;}
138     G4bool PostStepGetFastSimulationManagerTri << 147 
139     // DoIt                                    << 148 
140     G4VParticleChange* InvokePostStepDoIt();   << 149   //----------------------------------------------
141                                                << 150   // Interface methods for the 
142     // AtRest methods:                         << 151   // G4FastSimulationManagerProcess process.
143     G4bool AtRestGetFastSimulationManagerTrigg << 152   //----------------------------------------------
144     G4VParticleChange* InvokeAtRestDoIt();     << 153   // Trigger
145                                                << 154   G4bool PostStepGetFastSimulationManagerTrigger(const G4Track &,
146     // For management                          << 155              const G4Navigator* a = 0);
147     G4bool operator==(const G4FastSimulationMa << 156   // DoIt
148                                                << 157   G4VParticleChange* InvokePostStepDoIt();
149   private:                                     << 158 
150     // Private members :                       << 159   // AtRest methods:
151     G4FastTrack fFastTrack;                    << 160   G4bool AtRestGetFastSimulationManagerTrigger(const G4Track &,
152     G4FastStep fFastStep;                      << 161                  const G4Navigator* a = 0);
153     G4VFastSimulationModel* fTriggedFastSimula << 162   G4VParticleChange*  InvokeAtRestDoIt();
154     G4FastSimulationVector<G4VFastSimulationMo << 163 
155     G4FastSimulationVector<G4VFastSimulationMo << 164   // For management
                                                   >> 165   G4bool operator == ( const G4FastSimulationManager&) const;
                                                   >> 166 
                                                   >> 167 private:
                                                   >> 168   // Private members :
                                                   >> 169   G4FastTrack fFastTrack;
                                                   >> 170   G4FastStep  fFastStep;
                                                   >> 171   G4VFastSimulationModel* fTriggedFastSimulationModel;
                                                   >> 172   G4FastSimulationVector <G4VFastSimulationModel> ModelList;
                                                   >> 173   G4FastSimulationVector <G4VFastSimulationModel> fInactivatedModels;
156                                                   174 
157     G4ParticleDefinition* fLastCrossedParticle << 175   G4ParticleDefinition* fLastCrossedParticle;
158     G4FastSimulationVector<G4VFastSimulationMo << 176   G4FastSimulationVector <G4VFastSimulationModel> fApplicableModelList;
159                                                   177 
160     // -- *** depracating, to be dropped @ nex << 178   // -- *** depracating, to be dropped @ next major release:
161     G4FastSimulationVector<G4Transform3D> Ghos << 179   G4FastSimulationVector <G4Transform3D> GhostPlacements;
162 };                                                180 };
163                                                   181 
164 inline void G4FastSimulationManager::AddFastSi << 182 inline void 
                                                   >> 183 G4FastSimulationManager::AddFastSimulationModel(G4VFastSimulationModel* fsm)
165 {                                                 184 {
166   ModelList.push_back(fsm);                       185   ModelList.push_back(fsm);
167   // forces the fApplicableModelList to be reb    186   // forces the fApplicableModelList to be rebuild
168   fLastCrossedParticle = nullptr;              << 187   fLastCrossedParticle = 0;
169 }                                                 188 }
170                                                   189 
171 inline void G4FastSimulationManager::RemoveFas << 190 inline void 
                                                   >> 191 G4FastSimulationManager::RemoveFastSimulationModel(G4VFastSimulationModel* fsm)
172 {                                                 192 {
173   if (ModelList.remove(fsm) == nullptr) fInact << 193   if(!ModelList.remove(fsm)) fInactivatedModels.remove(fsm);
174   // forces the fApplicableModelList to be reb    194   // forces the fApplicableModelList to be rebuild
175   fLastCrossedParticle = nullptr;              << 195   fLastCrossedParticle = 0;
176 }                                                 196 }
177                                                   197 
178 inline G4bool G4FastSimulationManager::operato << 198 inline G4bool 
                                                   >> 199 G4FastSimulationManager::operator == (const G4FastSimulationManager& fsm) const
179 {                                                 200 {
180   return this == &fsm;                         << 201   return (this==&fsm) ? true : false;
181 }                                                 202 }
182                                                   203 
183 inline const G4Envelope* G4FastSimulationManag << 204 inline const G4Envelope* 
                                                   >> 205 G4FastSimulationManager::GetEnvelope() const
184 {                                                 206 {
185   return fFastTrack.GetEnvelope();                207   return fFastTrack.GetEnvelope();
186 }                                                 208 }
187                                                   209 
188 #endif                                            210 #endif
189                                                   211