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 1.1)


                                                   >>   1 // This code implementation is the intellectual property of
                                                   >>   2 // the GEANT4 collaboration.
  1 //                                                  3 //
  2 // ******************************************* <<   4 // By copying, distributing or modifying the Program (or any work
  3 // * License and Disclaimer                    <<   5 // based on the Program) you indicate your acceptance of this statement,
  4 // *                                           <<   6 // and all its terms.
  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 //                                                  7 //
                                                   >>   8 // $Id: G4VFastSimulationModel.hh,v 1.2.4.1 1999/12/07 20:52:52 gunter Exp $
                                                   >>   9 // GEANT4 tag $Name: geant4-01-01 $
 28 //                                                 10 //
                                                   >>  11 // 
 29 //--------------------------------------------     12 //---------------------------------------------------------------
 30 //                                                 13 //
 31 //  G4VFastSimulationModel.hh                      14 //  G4VFastSimulationModel.hh
 32 //                                                 15 //
 33 //  Description:                                   16 //  Description:
 34 //    Base class for fast simulation models.       17 //    Base class for fast simulation models.
 35 //                                                 18 //
 36 //  History:                                       19 //  History:
 37 //    Oct 97: Verderi && MoraDeFreitas - First     20 //    Oct 97: Verderi && MoraDeFreitas - First Implementation.
 38 //                                                 21 //
 39 //--------------------------------------------     22 //---------------------------------------------------------------
 40                                                    23 
                                                   >>  24 
 41 #ifndef G4VFastSimulationModel_h                   25 #ifndef G4VFastSimulationModel_h
 42 #define G4VFastSimulationModel_h                   26 #define G4VFastSimulationModel_h
 43                                                    27 
 44 #include "G4FastStep.hh"                       << 
 45 #include "G4FastTrack.hh"                          28 #include "G4FastTrack.hh"
                                                   >>  29 #include "G4FastStep.hh"
                                                   >>  30 
                                                   >>  31 //---------------------------
                                                   >>  32 // For possible future needs:
                                                   >>  33 //---------------------------
                                                   >>  34 typedef G4LogicalVolume G4Envelope;
 46                                                    35 
 47 //-------------------------------------------      36 //-------------------------------------------
 48 //                                                 37 //
 49 //        G4VFastSimulationModel class             38 //        G4VFastSimulationModel class
 50 //                                                 39 //
 51 //-------------------------------------------      40 //-------------------------------------------
 52                                                    41 
 53 // Class Description:                              42 // Class Description:
 54 //   This is the abstract class for the implem <<  43 //   This is the abstract class for the implementation of parameterisations. 
 55 //   You have to inherit from it to implement  <<  44 //   You have to inherit from it to implement your concrete parameterisation 
 56 //   model.                                        45 //   model.
 57 //                                                 46 //
 58                                                    47 
 59 class G4VFastSimulationModel                   <<  48  class G4VFastSimulationModel 
 60 {                                                  49 {
 61   public:                                      <<  50  public: // With description
 62     // aName identifies the parameterisation m <<  51 
 63     G4VFastSimulationModel(const G4String& aNa <<  52   G4VFastSimulationModel(const G4String& aName);
 64                                                <<  53   // aName identifies the parameterisation model.
 65     // This constructor allows you to get a qu <<  54 
 66     // In addition to the model name, this con <<  55   G4VFastSimulationModel(const G4String& aName, G4Envelope*, 
 67     // pointer. This volume will automatically <<  56        G4bool IsUnique=FALSE);
 68     // needed G4FastSimulationManager object i <<  57   // This constructor allows you to get a quick "getting started".
 69     // it the G4LogicalVolume pointer and the  <<  58   // In addition to the model name, this constructor accepts a G4LogicalVolume 
 70     // exists, the model is simply added to th <<  59   // pointer. This volume will automatically becomes the envelope, and the 
 71     // G4VFastSimulationModel object will not  <<  60   // needed G4FastSimulationManager object is constructed if necessary giving 
 72     // in the constructor.                     <<  61   // it the G4LogicalVolume pointer and the boolean value. If it already 
 73     // The boolean argument is there for optim <<  62   // exists, the model is simply added to this manager. However the 
 74     // the G4LogicalVolume envelope is placed  <<  63   // G4VFastSimulationModel object will not keep track of the envelope given 
 75     // boolean value to "true" (an automated m <<  64   // in the constructor.
 76     G4VFastSimulationModel(const G4String& aNa <<  65   // The boolean argument is there for optimization purpose: if you know that 
 77                                                <<  66   // the G4LogicalVolume envelope is placed only once you can turn this 
 78     virtual ~G4VFastSimulationModel() = defaul <<  67   // boolean value to "true" (an automated mechanism is foreseen here.)
 79                                                <<  68 
 80     // In your implementation, you have to ret <<  69 public: // Without description
 81     // applicable to the G4ParticleDefinition  <<  70   virtual ~G4VFastSimulationModel() {};
 82     // G4ParticleDefinition provides all intri <<  71 
 83     // charge, spin, name ...).                <<  72 public: // With description
 84     virtual G4bool IsApplicable(const G4Partic <<  73 
 85                                                <<  74   virtual G4bool IsApplicable(const G4ParticleDefinition&) = 0;
 86     // You have to return "true" when the dyna <<  75   // In your implementation, you have to return "true" when your model is 
 87     // parameterisation are fulfiled. The G4Fa <<  76   // applicable to the G4ParticleDefinition passed to this method. The 
 88     // the current G4Track, gives simple acces <<  77   // G4ParticleDefinition provides all intrisic particle informations (mass, 
 89     // (G4LogicalVolume, G4VSolid, G4AffineTra <<  78   // charge, spin, name ...).
 90     // global and the envelope local coordinat <<  79 
 91     // the position, momentum expressed in the <<  80   virtual G4bool ModelTrigger(const G4FastTrack &) = 0;
 92     // Using those quantities and the G4VSolid <<  81   // You have to return "true" when the dynamics conditions to trigger your
 93     // easily check how far you are from the e <<  82   // parameterisation are fulfiled. The G4FastTrack provides you access to 
 94     virtual G4bool ModelTrigger(const G4FastTr <<  83   // the current G4Track, gives simple access to envelope related features 
 95                                                <<  84   // (G4LogicalVolume, G4VSolid, G4AffineTransform references between the 
 96     // Your parameterisation properly said. Th <<  85   // global and the envelope local coordinates systems) and simple access to 
 97     // input informations. The final state of  <<  86   // the position, momentum expressed in the envelope coordinate system. 
 98     // has to be returned through the G4FastSt <<  87   // Using those quantities and the G4VSolid methods, you can for example 
 99     // described has "requests" the tracking w <<  88   // easily check how far you are from the envelope boundary. 
100     // parameterisation has been invoked.      <<  89 
101     virtual void DoIt(const G4FastTrack&, G4Fa <<  90   virtual void DoIt(const G4FastTrack&, G4FastStep&) = 0;
102                                                <<  91   // Your parameterisation properly said. The G4FastTrack reference provides 
103     // ---------------------------             <<  92   // input informations. The final state of the particles after parameterisation
104     // -- Idem for AtRest methods:             <<  93   // has to be returned through the G4FastStep reference. This final state is 
105     // ---------------------------             <<  94   // described has "requests" the tracking will apply after your 
106     // -- A default dummy implementation is pr <<  95   // parameterisation has been invoked.
107                                                <<  96 
108     // You have to return "true" when the dyna <<  97   // ---------------------------
109     // parameterisation are fulfiled. The G4Fa <<  98   // -- Idem for AtRest methods:
110     // the current G4Track, gives simple acces <<  99   // ---------------------------
111     // (G4LogicalVolume, G4VSolid, G4AffineTra << 100   // -- A default dummy implementation is provided.
112     // global and the envelope local coordinat << 101 
113     // the position, momentum expressed in the << 102   virtual 
114     // Using those quantities and the G4VSolid << 103   G4bool AtRestModelTrigger(const G4FastTrack& fastTrack) {return false;}
115     // easily check how far you are from the e << 104   // You have to return "true" when the dynamics conditions to trigger your
116     virtual G4bool AtRestModelTrigger(const G4 << 105   // parameterisation are fulfiled. The G4FastTrack provides you access to 
117                                                << 106   // the current G4Track, gives simple access to envelope related features 
118     // Your parameterisation properly said. Th << 107   // (G4LogicalVolume, G4VSolid, G4AffineTransform references between the 
119     // input informations. The final state of  << 108   // global and the envelope local coordinates systems) and simple access to 
120     // has to be returned through the G4FastSt << 109   // the position, momentum expressed in the envelope coordinate system. 
121     // described has "requests" the tracking w << 110   // Using those quantities and the G4VSolid methods, you can for example 
122     // parameterisation has been invoked.      << 111   // easily check how far you are from the envelope boundary. 
123     virtual void AtRestDoIt(const G4FastTrack& << 112 
124                                                << 113   virtual 
125     // Complete processing of any buffered or  << 114   void   AtRestDoIt  (const G4FastTrack& fastTrack, G4FastStep& fastStep) {}
126     virtual void Flush() {}                    << 115   // Your parameterisation properly said. The G4FastTrack reference provides 
127                                                << 116   // input informations. The final state of the particles after parameterisation
128     // Useful public methods :                 << 117   // has to be returned through the G4FastStep reference. This final state is 
129     const G4String GetName() const;            << 118   // described has "requests" the tracking will apply after your 
130     G4bool operator==(const G4VFastSimulationM << 119   // parameterisation has been invoked.
131                                                << 120   
132   private:                                     << 121 public: // Without description
133     //-------------                            << 122 
134     // Model Name:                             << 123   // Useful public methods :
135     //-------------                            << 124   const G4String GetName() const;
136     G4String theModelName;                     << 125   G4bool operator == ( const G4VFastSimulationModel&) const;
                                                   >> 126 
                                                   >> 127 private:
                                                   >> 128   //-------------
                                                   >> 129   // Model Name:
                                                   >> 130   //-------------
                                                   >> 131   G4String theModelName;
137 };                                                132 };
138                                                   133 
139 inline const G4String G4VFastSimulationModel:: << 134 inline const G4String G4VFastSimulationModel::GetName() const 
140 {                                                 135 {
141   return theModelName;                            136   return theModelName;
142 }                                                 137 }
143                                                   138 
144 inline G4bool G4VFastSimulationModel::operator << 139 inline G4bool 
                                                   >> 140 G4VFastSimulationModel::operator == (const G4VFastSimulationModel& fsm) const
145 {                                                 141 {
146   return this == &fsm;                         << 142   return (this==&fsm) ? true : false;
147 }                                                 143 }
148 #endif                                            144 #endif
149                                                   145