Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/parameterisation/include/G4VFastSimulationModel.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/G4VFastSimulationModel.hh (Version 11.3.0) and /processes/parameterisation/include/G4VFastSimulationModel.hh (Version 11.1.3)


  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 //  G4VFastSimulationModel.hh                      31 //  G4VFastSimulationModel.hh
 32 //                                                 32 //
 33 //  Description:                                   33 //  Description:
 34 //    Base class for fast simulation models.       34 //    Base class for fast simulation models.
 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 G4VFastSimulationModel_h                   42 #ifndef G4VFastSimulationModel_h
 42 #define G4VFastSimulationModel_h                   43 #define G4VFastSimulationModel_h
 43                                                    44 
 44 #include "G4FastStep.hh"                       << 
 45 #include "G4FastTrack.hh"                          45 #include "G4FastTrack.hh"
                                                   >>  46 #include "G4FastStep.hh"
 46                                                    47 
 47 //-------------------------------------------      48 //-------------------------------------------
 48 //                                                 49 //
 49 //        G4VFastSimulationModel class             50 //        G4VFastSimulationModel class
 50 //                                                 51 //
 51 //-------------------------------------------      52 //-------------------------------------------
 52                                                    53 
 53 // Class Description:                              54 // Class Description:
 54 //   This is the abstract class for the implem <<  55 //   This is the abstract class for the implementation of parameterisations. 
 55 //   You have to inherit from it to implement  <<  56 //   You have to inherit from it to implement your concrete parameterisation 
 56 //   model.                                        57 //   model.
 57 //                                                 58 //
 58                                                    59 
 59 class G4VFastSimulationModel                   <<  60  class G4VFastSimulationModel 
 60 {                                                  61 {
 61   public:                                      <<  62  public: // With description
 62     // aName identifies the parameterisation m <<  63 
 63     G4VFastSimulationModel(const G4String& aNa <<  64   G4VFastSimulationModel(const G4String& aName);
 64                                                <<  65   // aName identifies the parameterisation model.
 65     // This constructor allows you to get a qu <<  66 
 66     // In addition to the model name, this con <<  67   G4VFastSimulationModel(const G4String& aName, G4Envelope*, 
 67     // pointer. This volume will automatically <<  68        G4bool IsUnique=FALSE);
 68     // needed G4FastSimulationManager object i <<  69   // This constructor allows you to get a quick "getting started".
 69     // it the G4LogicalVolume pointer and the  <<  70   // In addition to the model name, this constructor accepts a G4LogicalVolume 
 70     // exists, the model is simply added to th <<  71   // pointer. This volume will automatically becomes the envelope, and the 
 71     // G4VFastSimulationModel object will not  <<  72   // needed G4FastSimulationManager object is constructed if necessary giving 
 72     // in the constructor.                     <<  73   // it the G4LogicalVolume pointer and the boolean value. If it already 
 73     // The boolean argument is there for optim <<  74   // exists, the model is simply added to this manager. However the 
 74     // the G4LogicalVolume envelope is placed  <<  75   // G4VFastSimulationModel object will not keep track of the envelope given 
 75     // boolean value to "true" (an automated m <<  76   // in the constructor.
 76     G4VFastSimulationModel(const G4String& aNa <<  77   // The boolean argument is there for optimization purpose: if you know that 
 77                                                <<  78   // the G4LogicalVolume envelope is placed only once you can turn this 
 78     virtual ~G4VFastSimulationModel() = defaul <<  79   // boolean value to "true" (an automated mechanism is foreseen here.)
 79                                                <<  80 
 80     // In your implementation, you have to ret <<  81 public: // Without description
 81     // applicable to the G4ParticleDefinition  <<  82   virtual ~G4VFastSimulationModel() {};
 82     // G4ParticleDefinition provides all intri <<  83 
 83     // charge, spin, name ...).                <<  84 public: // With description
 84     virtual G4bool IsApplicable(const G4Partic <<  85 
 85                                                <<  86   virtual G4bool IsApplicable(const G4ParticleDefinition&) = 0;
 86     // You have to return "true" when the dyna <<  87   // In your implementation, you have to return "true" when your model is 
 87     // parameterisation are fulfiled. The G4Fa <<  88   // applicable to the G4ParticleDefinition passed to this method. The 
 88     // the current G4Track, gives simple acces <<  89   // G4ParticleDefinition provides all intrisic particle informations (mass, 
 89     // (G4LogicalVolume, G4VSolid, G4AffineTra <<  90   // charge, spin, name ...).
 90     // global and the envelope local coordinat <<  91 
 91     // the position, momentum expressed in the <<  92   virtual G4bool ModelTrigger(const G4FastTrack &) = 0;
 92     // Using those quantities and the G4VSolid <<  93   // You have to return "true" when the dynamics conditions to trigger your
 93     // easily check how far you are from the e <<  94   // parameterisation are fulfiled. The G4FastTrack provides you access to 
 94     virtual G4bool ModelTrigger(const G4FastTr <<  95   // the current G4Track, gives simple access to envelope related features 
 95                                                <<  96   // (G4LogicalVolume, G4VSolid, G4AffineTransform references between the 
 96     // Your parameterisation properly said. Th <<  97   // global and the envelope local coordinates systems) and simple access to 
 97     // input informations. The final state of  <<  98   // the position, momentum expressed in the envelope coordinate system. 
 98     // has to be returned through the G4FastSt <<  99   // Using those quantities and the G4VSolid methods, you can for example 
 99     // described has "requests" the tracking w << 100   // easily check how far you are from the envelope boundary. 
100     // parameterisation has been invoked.      << 101 
101     virtual void DoIt(const G4FastTrack&, G4Fa << 102   virtual void DoIt(const G4FastTrack&, G4FastStep&) = 0;
102                                                << 103   // Your parameterisation properly said. The G4FastTrack reference provides 
103     // ---------------------------             << 104   // input informations. The final state of the particles after parameterisation
104     // -- Idem for AtRest methods:             << 105   // has to be returned through the G4FastStep reference. This final state is 
105     // ---------------------------             << 106   // described has "requests" the tracking will apply after your 
106     // -- A default dummy implementation is pr << 107   // parameterisation has been invoked.
107                                                << 108 
108     // You have to return "true" when the dyna << 109   // ---------------------------
109     // parameterisation are fulfiled. The G4Fa << 110   // -- Idem for AtRest methods:
110     // the current G4Track, gives simple acces << 111   // ---------------------------
111     // (G4LogicalVolume, G4VSolid, G4AffineTra << 112   // -- A default dummy implementation is provided.
112     // global and the envelope local coordinat << 113 
113     // the position, momentum expressed in the << 114   virtual 
114     // Using those quantities and the G4VSolid << 115   G4bool AtRestModelTrigger(const G4FastTrack&) {return false;}
115     // easily check how far you are from the e << 116   // You have to return "true" when the dynamics conditions to trigger your
116     virtual G4bool AtRestModelTrigger(const G4 << 117   // parameterisation are fulfiled. The G4FastTrack provides you access to 
117                                                << 118   // the current G4Track, gives simple access to envelope related features 
118     // Your parameterisation properly said. Th << 119   // (G4LogicalVolume, G4VSolid, G4AffineTransform references between the 
119     // input informations. The final state of  << 120   // global and the envelope local coordinates systems) and simple access to 
120     // has to be returned through the G4FastSt << 121   // the position, momentum expressed in the envelope coordinate system. 
121     // described has "requests" the tracking w << 122   // Using those quantities and the G4VSolid methods, you can for example 
122     // parameterisation has been invoked.      << 123   // easily check how far you are from the envelope boundary. 
123     virtual void AtRestDoIt(const G4FastTrack& << 124 
124                                                << 125   virtual 
125     // Complete processing of any buffered or  << 126   void   AtRestDoIt  (const G4FastTrack&, G4FastStep&) {}
126     virtual void Flush() {}                    << 127   // Your parameterisation properly said. The G4FastTrack reference provides 
127                                                << 128   // input informations. The final state of the particles after parameterisation
128     // Useful public methods :                 << 129   // has to be returned through the G4FastStep reference. This final state is 
129     const G4String GetName() const;            << 130   // described has "requests" the tracking will apply after your 
130     G4bool operator==(const G4VFastSimulationM << 131   // parameterisation has been invoked.
131                                                << 132   
132   private:                                     << 133 
133     //-------------                            << 134   virtual
134     // Model Name:                             << 135   void Flush(){}
135     //-------------                            << 136   
136     G4String theModelName;                     << 137 public: // Without description
                                                   >> 138 
                                                   >> 139   // Useful public methods :
                                                   >> 140   const G4String GetName() const;
                                                   >> 141   G4bool operator == ( const G4VFastSimulationModel&) const;
                                                   >> 142 
                                                   >> 143 private:
                                                   >> 144   //-------------
                                                   >> 145   // Model Name:
                                                   >> 146   //-------------
                                                   >> 147   G4String theModelName;
137 };                                                148 };
138                                                   149 
139 inline const G4String G4VFastSimulationModel:: << 150 inline const G4String G4VFastSimulationModel::GetName() const 
140 {                                                 151 {
141   return theModelName;                            152   return theModelName;
142 }                                                 153 }
143                                                   154 
144 inline G4bool G4VFastSimulationModel::operator << 155 inline G4bool 
                                                   >> 156 G4VFastSimulationModel::operator == (const G4VFastSimulationModel& fsm) const
145 {                                                 157 {
146   return this == &fsm;                         << 158   return (this==&fsm) ? true : false;
147 }                                                 159 }
148 #endif                                            160 #endif
149                                                   161