Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/electromagnetic/adjoint/include/G4AdjointCSManager.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/adjoint/include/G4AdjointCSManager.hh (Version 11.3.0) and /processes/electromagnetic/adjoint/include/G4AdjointCSManager.hh (Version 9.6.p3)


  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 // $Id: G4AdjointCSManager.hh 69844 2013-05-16 09:19:33Z gcosmo $
 27 //  Class:    G4AdjointCSManager               << 
 28 //  Author:         L. Desorgher               << 
 29 //  Organisation:   SpaceIT GmbH               << 
 30 //                                                 27 //
 31 // Class is responsible for the management of  <<  28 /////////////////////////////////////////////////////////////////////////////////
 32 // matrices, and for the computation of the to <<  29 //      Class:    G4AdjointCSManager
 33 // sections. Total adjoint and forward cross s <<  30 //  Author:         L. Desorgher
 34 // weight of a particle after a tracking step  <<  31 //  Organisation:   SpaceIT GmbH
 35 // reverse reaction. It is also used to sample <<  32 //  Contract: ESA contract 21435/08/NL/AT
 36 // given adjoint cross section matrix.         <<  33 //  Customer:       ESA/ESTEC
                                                   >>  34 /////////////////////////////////////////////////////////////////////////////////
                                                   >>  35 //
                                                   >>  36 // CHANGE HISTORY
                                                   >>  37 // --------------
                                                   >>  38 //      ChangeHistory: 
                                                   >>  39 //    1st April 2007 creation by L. Desorgher     
                                                   >>  40 //    
                                                   >>  41 //    September-October 2009. Implementation of the mode where the adjoint cross sections are scaled such that the total used adjoint cross sections is in 
                                                   >>  42 //    most of the cases equal to the total forward cross section. L.Desorgher
                                                   >>  43 //
                                                   >>  44 //-------------------------------------------------------------
                                                   >>  45 //  Documentation:
                                                   >>  46 //    Is responsible for the management of all adjoint cross sections matrices, and for the computation of the total forward and adjoint cross sections.
                                                   >>  47 //    Total adjoint and forward cross sections are needed to correct the weight of a particle after a tracking step or after the occurence of a reverse reaction. 
                                                   >>  48 //    It is also used to sample an adjoint secondary from a given adjoint cross section matrix.
 37 //                                                 49 //
 38 ////////////////////////////////////////////// << 
 39                                                << 
 40 #ifndef G4AdjointCSManager_h                       50 #ifndef G4AdjointCSManager_h
 41 #define G4AdjointCSManager_h 1                     51 #define G4AdjointCSManager_h 1
 42                                                    52 
 43 #include "globals.hh"                          <<  53 #include"globals.hh"
 44 #include "G4AdjointCSMatrix.hh"                <<  54 #include<vector>
 45 #include "G4ThreadLocalSingleton.hh"           <<  55 #include"G4AdjointCSMatrix.hh"
 46                                                    56 
 47 #include <vector>                              << 
 48                                                    57 
 49 class G4Element;                               <<  58 class G4VEmAdjointModel;
 50 class G4Material;                              << 
 51 class G4MaterialCutsCouple;                        59 class G4MaterialCutsCouple;
                                                   >>  60 class G4Material;
 52 class G4ParticleDefinition;                        61 class G4ParticleDefinition;
 53 class G4PhysicsTable;                          <<  62 class G4Element;
 54 class G4VEmProcess;                                63 class G4VEmProcess;
 55 class G4VEmAdjointModel;                       << 
 56 class G4VEnergyLossProcess;                        64 class G4VEnergyLossProcess;
                                                   >>  65 class G4PhysicsTable;
 57                                                    66 
                                                   >>  67 ////////////////////////////////////////////////////////////////////////////////
                                                   >>  68 //
 58 class G4AdjointCSManager                           69 class G4AdjointCSManager
 59 {                                                  70 {
 60   friend class G4ThreadLocalSingleton<G4Adjoin <<  71   
 61                                                <<  72   public:
 62  public:                                       <<  73         ~G4AdjointCSManager();
 63   ~G4AdjointCSManager();                       <<  74   static G4AdjointCSManager* GetAdjointCSManager();
 64   static G4AdjointCSManager* GetAdjointCSManag <<  75 
 65                                                <<  76   public:
 66   G4int GetNbProcesses();                      <<  77         G4int GetNbProcesses();
 67                                                <<  78   
 68   // Registration of the different models and  <<  79   //Registration of the different models and processes
 69                                                <<  80   
 70   std::size_t RegisterEmAdjointModel(G4VEmAdjo <<  81   size_t RegisterEmAdjointModel(G4VEmAdjointModel*);
 71                                                <<  82   
 72   void RegisterEmProcess(G4VEmProcess* aProces <<  83   void RegisterEmProcess(G4VEmProcess* aProcess, G4ParticleDefinition* aPartDef);
 73                          G4ParticleDefinition* <<  84   
 74                                                <<  85   void RegisterEnergyLossProcess(G4VEnergyLossProcess* aProcess, G4ParticleDefinition* aPartDef);
 75   void RegisterEnergyLossProcess(G4VEnergyLoss <<  86   
 76                                  G4ParticleDef <<  87   void RegisterAdjointParticle(G4ParticleDefinition* aPartDef);
 77                                                <<  88   
 78   void RegisterAdjointParticle(G4ParticleDefin <<  89   //Building of the CS Matrices and Total Forward and Adjoint LambdaTables
 79                                                <<  90   //----------------------------------------------------------------------
 80   // Building of the CS Matrices and Total For <<  91   
 81   void BuildCrossSectionMatrices();            <<  92   void BuildCrossSectionMatrices();
 82                                                <<  93   void BuildTotalSigmaTables();
 83   void BuildTotalSigmaTables();                <<  94   
 84                                                <<  95   
 85   // Get TotalCrossSections form Total Lambda  <<  96   //Get TotalCrossSections form Total Lambda Tables, Needed for Weight correction and scaling of the 
 86   // correction and scaling of the             <<  97   //-------------------------------------------------
 87   G4double GetTotalAdjointCS(G4ParticleDefinit <<  98   G4double GetTotalAdjointCS(G4ParticleDefinition* aPartDef, G4double Ekin,
 88                              const G4MaterialC <<  99                const G4MaterialCutsCouple* aCouple);
 89                                                << 100   G4double GetTotalForwardCS(G4ParticleDefinition* aPartDef, G4double Ekin,
 90   G4double GetTotalForwardCS(G4ParticleDefinit << 101                const G4MaterialCutsCouple* aCouple);
 91                              const G4MaterialC << 102   
 92                                                << 103   G4double GetAdjointSigma(G4double Ekin_nuc, size_t index_model,G4bool is_scat_proj_to_proj,
 93   G4double GetAdjointSigma(G4double Ekin_nuc,  << 104                const G4MaterialCutsCouple* aCouple);
 94                            G4bool is_scat_proj << 105   
 95                            const G4MaterialCut << 106   void GetEminForTotalCS(G4ParticleDefinition* aPartDef,
 96                                                << 107                const G4MaterialCutsCouple* aCouple, G4double& emin_adj, G4double& emin_fwd);
 97   void GetEminForTotalCS(G4ParticleDefinition* << 108   void GetMaxFwdTotalCS(G4ParticleDefinition* aPartDef,
 98                          const G4MaterialCutsC << 109                const G4MaterialCutsCouple* aCouple, G4double& e_sigma_max, G4double& sigma_max);
 99                          G4double& emin_adj, G << 110   void GetMaxAdjTotalCS(G4ParticleDefinition* aPartDef,
100                                                << 111                const G4MaterialCutsCouple* aCouple, G4double& e_sigma_max, G4double& sigma_max);
101   void GetMaxFwdTotalCS(G4ParticleDefinition*  << 112              
102                         const G4MaterialCutsCo << 113                                  
103                         G4double& e_sigma_max, << 114   
104                                                << 115   //CrossSection Correction  1 or FwdCS/AdjCS following the G4boolean value of forward_CS_is_used and forward_CS_mode
105   void GetMaxAdjTotalCS(G4ParticleDefinition*  << 116   //-------------------------------------------------
106                         const G4MaterialCutsCo << 117   G4double GetCrossSectionCorrection(G4ParticleDefinition* aPartDef,G4double PreStepEkin,const G4MaterialCutsCouple* aCouple, G4bool& fwd_is_used, G4double& fwd_TotCS);
107                         G4double& e_sigma_max, << 118   
108                                                << 119   
109   // CrossSection Correction 1 or FwdCS/AdjCS  << 120   //Cross section mode
110   // forward_CS_is_used and forward_CS_mode    << 121   //------------------
111   G4double GetCrossSectionCorrection(G4Particl << 122   inline void SetFwdCrossSectionMode(G4bool aBool){forward_CS_mode=aBool;}
112                                      G4double  << 123   
113                                      const G4M << 124   
114                                      G4bool& f << 125   //Weight correction 
115                                                << 126   //------------------
116   // Cross section mode                        << 127   
117   inline void SetFwdCrossSectionMode(G4bool aB << 128   G4double GetContinuousWeightCorrection(G4ParticleDefinition* aPartDef, G4double PreStepEkin,G4double AfterStepEkin,
118                                                << 129                const G4MaterialCutsCouple* aCouple, G4double step_length);
119   // Weight correction                         << 130   G4double GetPostStepWeightCorrection();
120   G4double GetContinuousWeightCorrection(G4Par << 131              
121                                          G4dou << 132   
122                                          G4dou << 133   
123                                          const << 134   
124                                          G4dou << 135   //Method Called by the adjoint model to get there CS, if not precised otherwise
125                                                << 136   //-------------------------------
126   G4double GetPostStepWeightCorrection();      << 137   
127                                                << 138   G4double ComputeAdjointCS(G4Material* aMaterial,
128   // called by the adjoint model to get the CS << 139               G4VEmAdjointModel* aModel, 
129   G4double ComputeAdjointCS(G4Material* aMater << 140               G4double PrimEnergy,
130                             G4double PrimEnerg << 141               G4double Tcut,
131                             G4bool isScatProjT << 142               G4bool IsScatProjToProjCase,
132                             std::vector<G4doub << 143               std::vector<G4double>& 
133                                                << 144                    AdjointCS_for_each_element);
134   // called by the adjoint model to sample sec << 145            
135   G4Element* SampleElementFromCSMatrices(G4Mat << 146   //Method Called by the adjoint model to sample the secondary energy form the CS matrix
136                                          G4VEm << 147   //--------------------------------------------------------------------------------
137                                          G4dou << 148   G4Element*  SampleElementFromCSMatrices(G4Material* aMaterial,
138                                          G4boo << 149                    G4VEmAdjointModel* aModel,
139                                                << 150                    G4double PrimEnergy,
140   // Total Adjoint CS is computed at initialis << 151                     G4double Tcut,
141   G4double ComputeTotalAdjointCS(const G4Mater << 152                    G4bool IsScatProjToProjCase);
142                                  G4ParticleDef << 153                    
143                                  G4double Prim << 154                    
144                                                << 155   //Total Adjoint CS  is computed at initialisation phase 
145   G4ParticleDefinition* GetAdjointParticleEqui << 156   //-----------------------------------------------------                
146     G4ParticleDefinition* theFwdPartDef);      << 157   G4double ComputeTotalAdjointCS(const G4MaterialCutsCouple* aMatCutCouple,G4ParticleDefinition* aPart,G4double PrimEnergy);
147                                                << 158   
148   G4ParticleDefinition* GetForwardParticleEqui << 159   
149     G4ParticleDefinition* theAdjPartDef);      << 160   
150                                                << 161                 
151   // inline                                    << 162   G4ParticleDefinition* GetAdjointParticleEquivalent(G4ParticleDefinition* theFwdPartDef);
152   inline void SetIon(G4ParticleDefinition* adj << 163   G4ParticleDefinition* GetForwardParticleEquivalent(G4ParticleDefinition* theAdjPartDef);
153   {                                            << 164   
154     fAdjIon = adjIon;                          << 165   //inline
155     fFwdIon = fwdIon;                          << 166   inline void SetTmin(G4double aVal){Tmin=aVal;}
156   }                                            << 167   inline void SetTmax(G4double aVal){Tmax=aVal;}
157                                                << 168   inline void SetNbins(G4int aInt){nbins=aInt;}
158  private:                                      << 169   inline void SetIon(G4ParticleDefinition* adjIon,
159   G4AdjointCSManager();                        << 170                G4ParticleDefinition* fwdIon) {theAdjIon=adjIon; theFwdIon =fwdIon;}
160                                                << 171   
161   void DefineCurrentMaterial(const G4MaterialC << 172   
162                                                << 173   private:
163   void DefineCurrentParticle(const G4ParticleD << 174         static  G4AdjointCSManager* theInstance;
164                                                << 175     std::vector< std::vector<G4AdjointCSMatrix*> > theAdjointCSMatricesForScatProjToProj; //x dim is for G4VAdjointEM* while y dim is for elements
165   G4double ComputeAdjointCS(G4double aPrimEner << 176   std::vector< std::vector<G4AdjointCSMatrix*> > theAdjointCSMatricesForProdToProj;
166                             G4AdjointCSMatrix* << 177   std::vector< G4VEmAdjointModel*> listOfAdjointEMModel;
167                             G4double Tcut);    << 178     
168                                                << 179   std::vector<G4AdjointCSMatrix*> 
169   std::vector<G4AdjointCSMatrix*> BuildCrossSe << 180         BuildCrossSectionsMatricesForAGivenModelAndElement(G4VEmAdjointModel* aModel,
170     G4VEmAdjointModel* aModel, G4int Z, G4int  << 181                        G4int Z,
171                                                << 182                        G4int A,
172   std::vector<G4AdjointCSMatrix*> BuildCrossSe << 183                        G4int nbin_pro_decade);
173     G4VEmAdjointModel* aModel, G4Material* aMa << 184   
174                                                << 185   std::vector<G4AdjointCSMatrix*> 
175   static constexpr G4double fTmin = 0.1 * CLHE << 186         BuildCrossSectionsMatricesForAGivenModelAndMaterial(G4VEmAdjointModel* aModel,
176   static constexpr G4double fTmax = 100. * CLH << 187                        G4Material* aMaterial,
177   // fNbins chosen to avoid error              << 188                        G4int nbin_pro_decade);
178   // in the CS value close to CS jump. (For ex << 189   
179   static constexpr G4int fNbins = 320;         << 190   
180                                                << 191   G4Material* lastMaterial;
181   static G4ThreadLocal G4AdjointCSManager* fIn << 192   G4double    lastPrimaryEnergy;
182                                                << 193   G4double    lastTcut; 
183   // only one ion can be considered by simulat << 194   std::vector< size_t> listOfIndexOfAdjointEMModelInAction;
184   G4ParticleDefinition* fAdjIon = nullptr;     << 195   std::vector< G4bool> listOfIsScatProjToProjCase;
185   G4ParticleDefinition* fFwdIon = nullptr;     << 196   std::vector< std::vector<G4double> > lastAdjointCSVsModelsAndElements;
186                                                << 197   G4bool CrossSectionMatrixesAreBuilt;
187   G4MaterialCutsCouple* fCurrentCouple = nullp << 198   size_t  currentParticleIndex;
188   G4Material* fCurrentMaterial         = nullp << 199   G4ParticleDefinition* currentParticleDef;
189                                                << 200   
190   // x dim is for G4VAdjointEM*, y dim is for  << 201   //total adjoint and total forward cross section table in function of material and in function of adjoint particle type
191   std::vector<std::vector<G4AdjointCSMatrix*>> << 202   //--------------------------------------------------------------------------------------------------------------------
192     fAdjointCSMatricesForScatProjToProj;       << 203   std::vector<G4PhysicsTable*>        theTotalForwardSigmaTableVector;
193                                                << 204   std::vector<G4PhysicsTable*>        theTotalAdjointSigmaTableVector;
194   std::vector<std::vector<G4AdjointCSMatrix*>> << 205   std::vector< std::vector<G4double> >  EminForFwdSigmaTables;  
195                                                << 206   std::vector< std::vector<G4double> >  EminForAdjSigmaTables;  
196   std::vector<G4VEmAdjointModel*> fAdjointMode << 207   std::vector< std::vector<G4double> >  EkinofFwdSigmaMax;  
197                                                << 208   std::vector< std::vector<G4double> >  EkinofAdjSigmaMax;
198   std::vector<std::size_t> fIndexOfAdjointEMMo << 209   G4bool TotalSigmaTableAreBuilt;
199   std::vector<G4bool> fIsScatProjToProj;       << 210   
200   std::vector<std::vector<G4double>> fLastAdjo << 211   //Sigma tavle for each G4VAdjointEMModel 
201                                                << 212   std::vector<G4PhysicsTable*>        listSigmaTableForAdjointModelScatProjToProj;
202   // total adjoint and total forward cross sec << 213   std::vector<G4PhysicsTable*>        listSigmaTableForAdjointModelProdToProj;
203   // and in function of adjoint particle type  << 214   
204   std::vector<G4PhysicsTable*> fTotalFwdSigmaT << 215 
205   std::vector<G4PhysicsTable*> fTotalAdjSigmaT << 216   
206                                                << 217    
207   // Sigma table for each G4VAdjointEMModel    << 218   //list of forward G4VEMLossProcess and of G4VEMProcess for the different adjoint particle
208   std::vector<G4PhysicsTable*> fSigmaTableForA << 219   //--------------------------------------------------------------
209   std::vector<G4PhysicsTable*> fSigmaTableForA << 220   std::vector< std::vector<G4VEmProcess*>* >    listOfForwardEmProcess;
210                                                << 221   std::vector< std::vector<G4VEnergyLossProcess*>* >  listOfForwardEnergyLossProcess;
211   std::vector<std::vector<G4double>> fEminForF << 222   
212   std::vector<std::vector<G4double>> fEminForA << 223   //list of adjoint particles considered
213   std::vector<std::vector<G4double>> fEkinofFw << 224   //--------------------------------------------------------------
214   std::vector<std::vector<G4double>> fEkinofAd << 225   std::vector< G4ParticleDefinition*> theListOfAdjointParticlesInAction;
215                                                << 226   
216   // list of forward G4VEmProcess and of G4VEn << 227   
217   // adjoint particle                          << 228   G4double Tmin,Tmax;
218   std::vector<std::vector<G4VEmProcess*>*> fFo << 229   G4int nbins;
219   std::vector<std::vector<G4VEnergyLossProcess << 230   
220                                                << 231   
221   // list of adjoint particles considered      << 232   //Current material
222   std::vector<G4ParticleDefinition*> fAdjointP << 233   //----------------
223                                                << 234   G4MaterialCutsCouple* currentCouple;  
224   G4double fMassRatio              = 1.;  // i << 235   G4Material* currentMaterial;
225   G4double fLastCSCorrectionFactor = 1.;       << 236   size_t  currentMatIndex;
226                                                << 237   
227   G4ParticleDefinition* fCurrentParticleDef =  << 238   G4int verbose;
228   std::size_t fCurrentParticleIndex = 0;       << 239   
229   std::size_t fCurrentMatIndex      = 0;       << 240   
                                                   >> 241   
                                                   >> 242   
                                                   >> 243   //Two CS mode are possible :forward_CS_mode = false the Adjoint CS are used as it is implying a AlongStep Weight Correction.
                                                   >> 244   //         :forward_CS_mode = true the Adjoint CS are scaled to have the total adjoint CS eual to the fwd one implying a PostStep Weight Correction.
                                                   >> 245   //               For energy range  where the total FwdCS or the total adjoint CS are null, the scaling is not possble and
                                                   >> 246   //               forward_CS_is_used is set to false   
                                                   >> 247   //--------------------------------------------
                                                   >> 248   G4bool forward_CS_is_used;
                                                   >> 249   G4bool forward_CS_mode;
                                                   >> 250   
                                                   >> 251   //Adj and Fwd CS values for re-use 
                                                   >> 252   //------------------------
                                                   >> 253   
                                                   >> 254   G4double PreadjCS,PostadjCS;
                                                   >> 255   G4double PrefwdCS,PostfwdCS;
                                                   >> 256   G4double LastEkinForCS;
                                                   >> 257   G4double LastCSCorrectionFactor;
                                                   >> 258   G4ParticleDefinition* lastPartDefForCS;
                                                   >> 259   
                                                   >> 260   //Ion
                                                   >> 261   //----------------
                                                   >> 262   G4ParticleDefinition* theAdjIon; //at the moment Only one ion can be considered by simulation
                                                   >> 263   G4ParticleDefinition* theFwdIon;
                                                   >> 264   G4double massRatio;
                                                   >> 265   
                                                   >> 266   
                                                   >> 267   
                                                   >> 268 
                                                   >> 269   private:
                                                   >> 270         G4AdjointCSManager();  
                                                   >> 271   void DefineCurrentMaterial(const G4MaterialCutsCouple* couple);
                                                   >> 272   void DefineCurrentParticle(const G4ParticleDefinition* aPartDef);
                                                   >> 273   G4double ComputeAdjointCS(G4double aPrimEnergy, G4AdjointCSMatrix* anAdjointCSMatrix, G4double Tcut);
                                                   >> 274   size_t eindex;
230                                                   275 
231   G4bool fCSMatricesBuilt = false;             << 
232   G4bool fSigmaTableBuilt = false;             << 
233   G4bool fForwardCSUsed   = true;              << 
234   G4bool fForwardCSMode   = true;              << 
235   // Two CS mode are possible:                 << 
236   // 1) fForwardCSMode = false, the Adjoint CS << 
237   //    an AlongStep Weight Correction.        << 
238   // 2) fForwardCSMode = true, the Adjoint CS  << 
239   //    adjoint CS equal to the fwd one implyi << 
240   // For energies where the total Fwd CS or th << 
241   // the scaling is not possible and fForwardC << 
242 };                                                276 };
243 #endif                                            277 #endif
244                                                   278