Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/electromagnetic/polarisation/src/G4PolarizedCompton.cc

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/polarisation/src/G4PolarizedCompton.cc (Version 11.3.0) and /processes/electromagnetic/polarisation/src/G4PolarizedCompton.cc (Version 10.0)


  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 //
                                                   >>  27 // $Id: G4PolarizedCompton.cc 76244 2013-11-08 11:12:59Z gcosmo $
                                                   >>  28 // 
                                                   >>  29 //
 26 // File name:     G4PolarizedCompton               30 // File name:     G4PolarizedCompton
 27 //                                                 31 //
 28 // Author:        Andreas Schaelicke               32 // Author:        Andreas Schaelicke
 29 //                based on code by Michel Mair     33 //                based on code by Michel Maire / Vladimir IVANTCHENKO
 30 //                                             << 
 31 // Class description                               34 // Class description
 32 //   modified version respecting media and bea <<  35 //
 33 //   using the stokes formalism                <<  36 // modified version respecting media and beam polarization
                                                   >>  37 //     using the stokes formalism
                                                   >>  38 //
                                                   >>  39 // Creation date: 01.05.2005
                                                   >>  40 //
                                                   >>  41 // Modifications:
                                                   >>  42 //
                                                   >>  43 // 01-01-05, include polarization description (A.Stahl)
                                                   >>  44 // 01-01-05, create asymmetry table and determine interactionlength (A.Stahl)
                                                   >>  45 // 01-05-05, update handling of media polarization (A.Schalicke)
                                                   >>  46 // 01-05-05, update polarized differential cross section (A.Schalicke)
                                                   >>  47 // 20-05-05, added polarization transfer (A.Schalicke)
                                                   >>  48 // 10-06-05, transformation between different reference frames (A.Schalicke)
                                                   >>  49 // 17-10-05, correct reference frame dependence in GetMeanFreePath (A.Schalicke)
                                                   >>  50 // 26-07-06, cross section recalculated (P.Starovoitov)
                                                   >>  51 // 09-08-06, make it work under current geant4 release (A.Schalicke)
                                                   >>  52 // 11-06-07, add PostStepGetPhysicalInteractionLength (A.Schalicke)
                                                   >>  53 // -----------------------------------------------------------------------------
 34                                                    54 
 35 #include "G4PolarizedCompton.hh"               << 
 36                                                    55 
                                                   >>  56 #include "G4PolarizedCompton.hh"
                                                   >>  57 #include "G4SystemOfUnits.hh"
 37 #include "G4Electron.hh"                           58 #include "G4Electron.hh"
 38 #include "G4EmParameters.hh"                   <<  59 
 39 #include "G4KleinNishinaCompton.hh"            <<  60 #include "G4StokesVector.hh"
 40 #include "G4PhysicsTableHelper.hh"             << 
 41 #include "G4PolarizationManager.hh"                61 #include "G4PolarizationManager.hh"
 42 #include "G4PolarizedComptonModel.hh"              62 #include "G4PolarizedComptonModel.hh"
 43 #include "G4ProductionCutsTable.hh"                63 #include "G4ProductionCutsTable.hh"
 44 #include "G4StokesVector.hh"                   <<  64 #include "G4PhysicsTableHelper.hh"
 45 #include "G4SystemOfUnits.hh"                  <<  65 #include "G4KleinNishinaCompton.hh"
                                                   >>  66 #include "G4PolarizedComptonModel.hh"
 46                                                    67 
 47 //....oooOO0OOooo........oooOO0OOooo........oo     68 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 48 G4PhysicsTable* G4PolarizedCompton::theAsymmet << 
 49                                                    69 
 50 G4PolarizedCompton::G4PolarizedCompton(const G     70 G4PolarizedCompton::G4PolarizedCompton(const G4String& processName,
 51                                        G4Proce <<  71   G4ProcessType type):
 52   : G4VEmProcess(processName, type)            <<  72   G4VEmProcess (processName, type),
 53   , fType(10)                                  <<  73   buildAsymmetryTable(true),
 54   , fBuildAsymmetryTable(true)                 <<  74   useAsymmetryTable(true),
 55   , fUseAsymmetryTable(true)                   <<  75   isInitialised(false),
 56   , fIsInitialised(false)                      <<  76   selectedModel(0),
 57 {                                              <<  77   mType(10),
 58   SetStartFromNullFlag(true);                  <<  78   theAsymmetryTable(NULL)
 59   SetBuildTableFlag(true);                     <<  79 {
 60   SetSecondaryParticle(G4Electron::Electron()) <<  80   SetLambdaBinning(90);
                                                   >>  81   SetMinKinEnergy(0.1*keV);
                                                   >>  82   SetMaxKinEnergy(100.0*GeV);
 61   SetProcessSubType(fComptonScattering);           83   SetProcessSubType(fComptonScattering);
 62   SetMinKinEnergyPrim(1. * MeV);               <<  84   emModel = 0;
 63   SetSplineFlag(true);                         << 
 64   fEmModel = nullptr;                          << 
 65 }                                              << 
 66                                                << 
 67 //....oooOO0OOooo........oooOO0OOooo........oo << 
 68 G4PolarizedCompton::~G4PolarizedCompton() { Cl << 
 69                                                << 
 70 //....oooOO0OOooo........oooOO0OOooo........oo << 
 71 void G4PolarizedCompton::ProcessDescription(st << 
 72 {                                              << 
 73   out << "Polarized model for Compton scatteri << 
 74                                                << 
 75   G4VEmProcess::ProcessDescription(out);       << 
 76 }                                                  85 }
 77                                                    86 
 78 //....oooOO0OOooo........oooOO0OOooo........oo     87 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 79 void G4PolarizedCompton::CleanTable()          <<  88  
                                                   >>  89 G4PolarizedCompton::~G4PolarizedCompton()
 80 {                                                  90 {
 81   if(theAsymmetryTable)                        <<  91   if (theAsymmetryTable) {
 82   {                                            << 
 83     theAsymmetryTable->clearAndDestroy();      << 
 84     delete theAsymmetryTable;                      92     delete theAsymmetryTable;
 85     theAsymmetryTable = nullptr;               << 
 86   }                                                93   }
 87 }                                                  94 }
 88                                                    95 
 89 //....oooOO0OOooo........oooOO0OOooo........oo     96 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 90 G4bool G4PolarizedCompton::IsApplicable(const  << 
 91 {                                              << 
 92   return (&p == G4Gamma::Gamma());             << 
 93 }                                              << 
 94                                                    97 
 95 //....oooOO0OOooo........oooOO0OOooo........oo << 
 96 void G4PolarizedCompton::InitialiseProcess(con     98 void G4PolarizedCompton::InitialiseProcess(const G4ParticleDefinition*)
 97 {                                                  99 {
 98   if(!fIsInitialised)                          << 100   if(!isInitialised) {
 99   {                                            << 101     isInitialised = true;
100     fIsInitialised = true;                     << 102     SetBuildTableFlag(true);
101     if(0 == fType)                             << 103     SetSecondaryParticle(G4Electron::Electron());
102     {                                          << 104     G4double emin = MinKinEnergy();
103       if(nullptr == EmModel(0))                << 105     G4double emax = MaxKinEnergy();
104       {                                        << 106     emModel = new G4PolarizedComptonModel();
105         SetEmModel(new G4KleinNishinaCompton() << 107     if(0 == mType) selectedModel = new G4KleinNishinaCompton();
106       }                                        << 108     else if(10 == mType) selectedModel = emModel;
107     }                                          << 109     selectedModel->SetLowEnergyLimit(emin);
108     else                                       << 110     selectedModel->SetHighEnergyLimit(emax);
109     {                                          << 111     AddEmModel(1, selectedModel);
110       fEmModel = new G4PolarizedComptonModel() << 112   } 
111       SetEmModel(fEmModel);                    << 
112     }                                          << 
113     G4EmParameters* param = G4EmParameters::In << 
114     EmModel(0)->SetLowEnergyLimit(param->MinKi << 
115     EmModel(0)->SetHighEnergyLimit(param->MaxK << 
116     AddEmModel(1, EmModel(0));                 << 
117   }                                            << 
118 }                                                 113 }
119                                                   114 
120 //....oooOO0OOooo........oooOO0OOooo........oo    115 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
                                                   >> 116 
                                                   >> 117 void G4PolarizedCompton::PrintInfo()
                                                   >> 118 {
                                                   >> 119   G4cout << " Total cross sections has a good parametrisation"
                                                   >> 120          << " from 10 KeV to (100/Z) GeV" 
                                                   >> 121          << "\n      Sampling according " << selectedModel->GetName() << " model" 
                                                   >> 122    << G4endl;
                                                   >> 123 }         
                                                   >> 124 
                                                   >> 125 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
                                                   >> 126 
121 void G4PolarizedCompton::SetModel(const G4Stri    127 void G4PolarizedCompton::SetModel(const G4String& ss)
122 {                                                 128 {
123   if(ss == "Klein-Nishina")                    << 129   if(ss == "Klein-Nishina") mType = 0;
124   {                                            << 130   if(ss == "Polarized-Compton") mType = 10;
125     fType = 0;                                 << 
126   }                                            << 
127   if(ss == "Polarized-Compton")                << 
128   {                                            << 
129     fType = 10;                                << 
130   }                                            << 
131 }                                                 131 }
132                                                   132 
                                                   >> 133 
                                                   >> 134 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
133 //....oooOO0OOooo........oooOO0OOooo........oo    135 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
134 G4double G4PolarizedCompton::GetMeanFreePath(c << 136 
135                                              G << 137 
136                                              G << 138 
                                                   >> 139 G4double G4PolarizedCompton::GetMeanFreePath(
                                                   >> 140            const G4Track& aTrack,
                                                   >> 141            G4double   previousStepSize,
                                                   >> 142            G4ForceCondition* condition)
137 {                                                 143 {
138   // *** get unploarised mean free path from l    144   // *** get unploarised mean free path from lambda table ***
139   G4double mfp =                               << 145   G4double mfp = G4VEmProcess::GetMeanFreePath(aTrack, previousStepSize, condition);
140     G4VEmProcess::GetMeanFreePath(aTrack, prev << 
141                                                   146 
142   if(theAsymmetryTable && fUseAsymmetryTable & << 147 
143   {                                            << 148    if (theAsymmetryTable && useAsymmetryTable) {
144     mfp *= ComputeSaturationFactor(aTrack);    << 149      // *** get asymmetry, if target is polarized ***
145   }                                            << 150      const G4DynamicParticle* aDynamicGamma = aTrack.GetDynamicParticle();
146   if(verboseLevel >= 2)                        << 151      const G4double GammaEnergy = aDynamicGamma->GetKineticEnergy();
147   {                                            << 152      const G4StokesVector GammaPolarization = aTrack.GetPolarization();
148     G4cout << "G4PolarizedCompton::MeanFreePat << 153      const G4ParticleMomentum GammaDirection0 = aDynamicGamma->GetMomentumDirection();
149            << G4endl;                          << 154 
150   }                                            << 155      G4Material*         aMaterial = aTrack.GetMaterial();
151   return mfp;                                  << 156      G4VPhysicalVolume*  aPVolume  = aTrack.GetVolume();
                                                   >> 157      G4LogicalVolume*    aLVolume  = aPVolume->GetLogicalVolume();
                                                   >> 158 
                                                   >> 159      //   G4Material* bMaterial = aLVolume->GetMaterial();
                                                   >> 160      G4PolarizationManager * polarizationManger = G4PolarizationManager::GetInstance();
                                                   >> 161 
                                                   >> 162      const G4bool VolumeIsPolarized = polarizationManger->IsPolarized(aLVolume);
                                                   >> 163      G4StokesVector ElectronPolarization = polarizationManger->GetVolumePolarization(aLVolume);
                                                   >> 164 
                                                   >> 165      if (!VolumeIsPolarized || mfp == DBL_MAX) return mfp;
                                                   >> 166      
                                                   >> 167      if (verboseLevel>=2) {
                                                   >> 168 
                                                   >> 169        G4cout << " Mom " << GammaDirection0  << G4endl;
                                                   >> 170        G4cout << " Polarization " << GammaPolarization  << G4endl;
                                                   >> 171        G4cout << " MaterialPol. " << ElectronPolarization  << G4endl;
                                                   >> 172        G4cout << " Phys. Volume " << aPVolume->GetName() << G4endl;
                                                   >> 173        G4cout << " Log. Volume  " << aLVolume->GetName() << G4endl;
                                                   >> 174        G4cout << " Material     " << aMaterial          << G4endl;
                                                   >> 175      }
                                                   >> 176 
                                                   >> 177      G4int midx= CurrentMaterialCutsCoupleIndex();
                                                   >> 178      G4PhysicsVector * aVector=(*theAsymmetryTable)(midx);
                                                   >> 179      
                                                   >> 180      G4double asymmetry=0;
                                                   >> 181      if (aVector) {
                                                   >> 182        G4bool isOutRange;
                                                   >> 183        asymmetry = aVector->GetValue(GammaEnergy, isOutRange);
                                                   >> 184      } else {
                                                   >> 185        G4cout << " MaterialIndex     " << midx << " is out of range \n";
                                                   >> 186        asymmetry=0;
                                                   >> 187      }
                                                   >> 188 
                                                   >> 189      //  we have to determine angle between particle motion 
                                                   >> 190      //  and target polarisation here  
                                                   >> 191      //      circ pol * Vec(ElectronPol)*Vec(PhotonMomentum)
                                                   >> 192      //  both vectors in global reference frame
                                                   >> 193      
                                                   >> 194      G4double pol=ElectronPolarization*GammaDirection0;
                                                   >> 195      
                                                   >> 196      G4double polProduct = GammaPolarization.p3() * pol;
                                                   >> 197      mfp *= 1. / ( 1. + polProduct * asymmetry );
                                                   >> 198 
                                                   >> 199      if (verboseLevel>=2) {
                                                   >> 200        G4cout << " MeanFreePath:  " << mfp / mm << " mm " << G4endl;
                                                   >> 201        G4cout << " Asymmetry:     " << asymmetry          << G4endl;
                                                   >> 202        G4cout << " PolProduct:    " << polProduct         << G4endl;
                                                   >> 203      }
                                                   >> 204    }
                                                   >> 205 
                                                   >> 206    return mfp;
152 }                                                 207 }
153                                                   208 
154 //....oooOO0OOooo........oooOO0OOooo........oo << 
155 G4double G4PolarizedCompton::PostStepGetPhysic    209 G4double G4PolarizedCompton::PostStepGetPhysicalInteractionLength(
156   const G4Track& aTrack, G4double previousStep << 210            const G4Track& aTrack,
                                                   >> 211            G4double   previousStepSize,
                                                   >> 212            G4ForceCondition* condition)
157 {                                                 213 {
158   // save previous values                      << 214   // *** get unploarised mean free path from lambda table ***
159   G4double nLength = theNumberOfInteractionLen << 215   G4double mfp = G4VEmProcess::PostStepGetPhysicalInteractionLength(aTrack, previousStepSize, condition);
160   G4double iLength = currentInteractionLength; << 216 
161                                                << 217 
162   // *** compute unpolarized step limit ***    << 218    if (theAsymmetryTable && useAsymmetryTable) {
163   // this changes theNumberOfInteractionLength << 219      // *** get asymmetry, if target is polarized ***
164   G4double x = G4VEmProcess::PostStepGetPhysic << 220      const G4DynamicParticle* aDynamicGamma = aTrack.GetDynamicParticle();
165     aTrack, previousStepSize, condition);      << 221      const G4double GammaEnergy = aDynamicGamma->GetKineticEnergy();
166   G4double x0      = x;                        << 222      const G4StokesVector GammaPolarization = aTrack.GetPolarization();
167   G4double satFact = 1.0;                      << 223      const G4ParticleMomentum GammaDirection0 = aDynamicGamma->GetMomentumDirection();
168                                                << 224 
169   // *** add corrections on polarisation ***   << 225      G4Material*         aMaterial = aTrack.GetMaterial();
170   if(theAsymmetryTable && fUseAsymmetryTable & << 226      G4VPhysicalVolume*  aPVolume  = aTrack.GetVolume();
171   {                                            << 227      G4LogicalVolume*    aLVolume  = aPVolume->GetLogicalVolume();
172     satFact            = ComputeSaturationFact << 228 
173     G4double curLength = currentInteractionLen << 229      //   G4Material* bMaterial = aLVolume->GetMaterial();
174     G4double prvLength = iLength * satFact;    << 230      G4PolarizationManager * polarizationManger = G4PolarizationManager::GetInstance();
175     if(nLength > 0.0)                          << 231 
176     {                                          << 232      const G4bool VolumeIsPolarized = polarizationManger->IsPolarized(aLVolume);
177       theNumberOfInteractionLengthLeft =       << 233      G4StokesVector ElectronPolarization = polarizationManger->GetVolumePolarization(aLVolume);
178         std::max(nLength - previousStepSize /  << 234 
179     }                                          << 235      if (!VolumeIsPolarized || mfp == DBL_MAX) return mfp;
180     x = theNumberOfInteractionLengthLeft * cur << 236      
181   }                                            << 237      if (verboseLevel>=2) {
182   if(verboseLevel >= 2)                        << 238 
183   {                                            << 239        G4cout << " Mom " << GammaDirection0  << G4endl;
184     G4cout << "G4PolarizedCompton::PostStepGPI << 240        G4cout << " Polarization " << GammaPolarization  << G4endl;
185            << x / mm << " mm;" << G4endl       << 241        G4cout << " MaterialPol. " << ElectronPolarization  << G4endl;
186            << "               unpolarized valu << 242        G4cout << " Phys. Volume " << aPVolume->GetName() << G4endl;
187            << x0 / mm << " mm." << G4endl;     << 243        G4cout << " Log. Volume  " << aLVolume->GetName() << G4endl;
188   }                                            << 244        G4cout << " Material     " << aMaterial          << G4endl;
189   return x;                                    << 245      }
                                                   >> 246 
                                                   >> 247      G4int midx= CurrentMaterialCutsCoupleIndex();
                                                   >> 248      G4PhysicsVector * aVector=(*theAsymmetryTable)(midx);
                                                   >> 249      
                                                   >> 250      G4double asymmetry=0;
                                                   >> 251      if (aVector) {
                                                   >> 252        G4bool isOutRange;
                                                   >> 253        asymmetry = aVector->GetValue(GammaEnergy, isOutRange);
                                                   >> 254      } else {
                                                   >> 255        G4cout << " MaterialIndex     " << midx << " is out of range \n";
                                                   >> 256        asymmetry=0;
                                                   >> 257      }
                                                   >> 258 
                                                   >> 259      //  we have to determine angle between particle motion 
                                                   >> 260      //  and target polarisation here  
                                                   >> 261      //      circ pol * Vec(ElectronPol)*Vec(PhotonMomentum)
                                                   >> 262      //  both vectors in global reference frame
                                                   >> 263      
                                                   >> 264      G4double pol=ElectronPolarization*GammaDirection0;
                                                   >> 265      
                                                   >> 266      G4double polProduct = GammaPolarization.p3() * pol;
                                                   >> 267      mfp *= 1. / ( 1. + polProduct * asymmetry );
                                                   >> 268 
                                                   >> 269      if (verboseLevel>=2) {
                                                   >> 270        G4cout << " MeanFreePath:  " << mfp / mm << " mm " << G4endl;
                                                   >> 271        G4cout << " Asymmetry:     " << asymmetry          << G4endl;
                                                   >> 272        G4cout << " PolProduct:    " << polProduct         << G4endl;
                                                   >> 273      }
                                                   >> 274    }
                                                   >> 275 
                                                   >> 276    return mfp;
190 }                                                 277 }
191                                                   278 
192 //....oooOO0OOooo........oooOO0OOooo........oo    279 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
193 G4double G4PolarizedCompton::ComputeSaturation << 
194 {                                              << 
195   G4double factor = 1.0;                       << 
196                                                   280 
197   // *** get asymmetry, if target is polarized << 281 void G4PolarizedCompton::PreparePhysicsTable(const G4ParticleDefinition& part)
198   const G4DynamicParticle* aDynamicGamma = aTr << 282 {
199   const G4double GammaEnergy             = aDy << 283   G4VEmProcess::PreparePhysicsTable(part);
200   const G4StokesVector GammaPolarization =     << 284   if(buildAsymmetryTable)
201     G4StokesVector(aTrack.GetPolarization());  << 285     theAsymmetryTable = G4PhysicsTableHelper::PreparePhysicsTable(theAsymmetryTable);
202   const G4ParticleMomentum GammaDirection0 =   << 
203     aDynamicGamma->GetMomentumDirection();     << 
204                                                << 
205   const G4Material* aMaterial = aTrack.GetMate << 
206   G4VPhysicalVolume* aPVolume = aTrack.GetVolu << 
207   G4LogicalVolume* aLVolume   = aPVolume->GetL << 
208                                                << 
209   G4PolarizationManager* polarizationManager = << 
210     G4PolarizationManager::GetInstance();      << 
211                                                << 
212   const G4bool VolumeIsPolarized = polarizatio << 
213   G4StokesVector ElectronPolarization =        << 
214     polarizationManager->GetVolumePolarization << 
215                                                << 
216   if(VolumeIsPolarized)                        << 
217   {                                            << 
218     if(verboseLevel >= 2)                      << 
219     {                                          << 
220       G4cout << "G4PolarizedCompton::ComputeSa << 
221       G4cout << " Mom " << GammaDirection0 <<  << 
222       G4cout << " Polarization " << GammaPolar << 
223       G4cout << " MaterialPol. " << ElectronPo << 
224       G4cout << " Phys. Volume " << aPVolume-> << 
225       G4cout << " Log. Volume  " << aLVolume-> << 
226       G4cout << " Material     " << aMaterial  << 
227     }                                          << 
228                                                << 
229     std::size_t midx               = CurrentMa << 
230     const G4PhysicsVector* aVector = nullptr;  << 
231     if(midx < theAsymmetryTable->size())       << 
232     {                                          << 
233       aVector = (*theAsymmetryTable)(midx);    << 
234     }                                          << 
235     if(aVector)                                << 
236     {                                          << 
237       G4double asymmetry = aVector->Value(Gamm << 
238                                                << 
239       //  we have to determine angle between p << 
240       //  and target polarisation here         << 
241       //      circ pol * Vec(ElectronPol)*Vec( << 
242       //  both vectors in global reference fra << 
243                                                << 
244       G4double pol        = ElectronPolarizati << 
245       G4double polProduct = GammaPolarization. << 
246       factor /= (1. + polProduct * asymmetry); << 
247       if(verboseLevel >= 2)                    << 
248       {                                        << 
249         G4cout << " Asymmetry:     " << asymme << 
250         G4cout << " PolProduct:    " << polPro << 
251         G4cout << " Factor:        " << factor << 
252       }                                        << 
253     }                                          << 
254     else                                       << 
255     {                                          << 
256       G4ExceptionDescription ed;               << 
257       ed << "Problem with asymmetry table: mat << 
258          << " is out of range or the table is  << 
259       G4Exception("G4PolarizedComptonModel::Co << 
260                   JustWarning, ed, "");        << 
261     }                                          << 
262   }                                            << 
263   return factor;                               << 
264 }                                                 286 }
265                                                   287 
266 //....oooOO0OOooo........oooOO0OOooo........oo    288 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
                                                   >> 289 
                                                   >> 290 
267 void G4PolarizedCompton::BuildPhysicsTable(con    291 void G4PolarizedCompton::BuildPhysicsTable(const G4ParticleDefinition& part)
268 {                                                 292 {
269   // *** build (unpolarized) cross section tab    293   // *** build (unpolarized) cross section tables (Lambda)
270   G4VEmProcess::BuildPhysicsTable(part);          294   G4VEmProcess::BuildPhysicsTable(part);
271   if(fBuildAsymmetryTable && fEmModel)         << 295   if(buildAsymmetryTable)
272   {                                            << 296     BuildAsymmetryTable(part);
273     G4bool isMaster = true;                    << 
274     const G4PolarizedCompton* masterProcess =  << 
275       static_cast<const G4PolarizedCompton*>(G << 
276     if(masterProcess && masterProcess != this) << 
277     {                                          << 
278       isMaster = false;                        << 
279     }                                          << 
280     if(isMaster)                               << 
281     {                                          << 
282       BuildAsymmetryTable(part);               << 
283     }                                          << 
284   }                                            << 
285 }                                                 297 }
286                                                   298 
287 //....oooOO0OOooo........oooOO0OOooo........oo    299 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
                                                   >> 300 
                                                   >> 301 
288 void G4PolarizedCompton::BuildAsymmetryTable(c    302 void G4PolarizedCompton::BuildAsymmetryTable(const G4ParticleDefinition& part)
289 {                                                 303 {
290   // cleanup old, initialise new table         << 
291   CleanTable();                                << 
292   theAsymmetryTable =                          << 
293     G4PhysicsTableHelper::PreparePhysicsTable( << 
294                                                << 
295   // Access to materials                          304   // Access to materials
296   const G4ProductionCutsTable* theCoupleTable  << 305   const G4ProductionCutsTable* theCoupleTable=
297     G4ProductionCutsTable::GetProductionCutsTa << 306         G4ProductionCutsTable::GetProductionCutsTable();
298   G4int numOfCouples = (G4int)theCoupleTable-> << 307   size_t numOfCouples = theCoupleTable->GetTableSize();
299   if(!theAsymmetryTable)                       << 308   for(size_t i=0; i<numOfCouples; ++i) {
300   {                                            << 309     if (!theAsymmetryTable) break;
301     return;                                    << 310     if (theAsymmetryTable->GetFlag(i)) {
302   }                                            << 311 
303   G4int nbins                 = LambdaBinning( << 
304   G4double emin               = MinKinEnergy() << 
305   G4double emax               = MaxKinEnergy() << 
306   G4PhysicsLogVector* aVector = nullptr;       << 
307   G4PhysicsLogVector* bVector = nullptr;       << 
308                                                << 
309   for(G4int i = 0; i < numOfCouples; ++i)      << 
310   {                                            << 
311     if(theAsymmetryTable->GetFlag(i))          << 
312     {                                          << 
313       // create physics vector and fill it        312       // create physics vector and fill it
314       const G4MaterialCutsCouple* couple =     << 313       const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(i);
315         theCoupleTable->GetMaterialCutsCouple( << 
316       // use same parameters as for lambda        314       // use same parameters as for lambda
317       if(!aVector)                             << 315       G4PhysicsVector* aVector = LambdaPhysicsVector(couple);
318       {                                        << 316       //      modelManager->FillLambdaVector(aVector, couple, startFromNull);
319         aVector = new G4PhysicsLogVector(emin, << 
320         bVector = aVector;                     << 
321       }                                        << 
322       else                                     << 
323       {                                        << 
324         bVector = new G4PhysicsLogVector(*aVec << 
325       }                                        << 
326                                                   317 
327       for(G4int j = 0; j <= nbins; ++j)        << 318       for (G4int j = 0 ; j < LambdaBinning() ; ++j ) {
328       {                                        << 319   G4double lowEdgeEnergy = aVector->GetLowEdgeEnergy(j);
329         G4double energy = bVector->Energy(j);  << 320   G4double tasm=0.;
330         G4double tasm   = 0.;                  << 321   G4double asym = ComputeAsymmetry(lowEdgeEnergy, couple, part, 0., tasm);
331         G4double asym   = ComputeAsymmetry(ene << 322   aVector->PutValue(j,asym);
332         bVector->PutValue(j, asym);            << 
333       }                                           323       }
334       bVector->FillSecondDerivatives();        << 324 
335       G4PhysicsTableHelper::SetPhysicsVector(t << 325       G4PhysicsTableHelper::SetPhysicsVector(theAsymmetryTable, i, aVector);
336     }                                             326     }
337   }                                               327   }
                                                   >> 328 
338 }                                                 329 }
339                                                   330 
340 //....oooOO0OOooo........oooOO0OOooo........oo    331 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
341 G4double G4PolarizedCompton::ComputeAsymmetry( << 332 
342   G4double energy, const G4MaterialCutsCouple* << 333 
343   const G4ParticleDefinition& aParticle, G4dou << 334 G4double G4PolarizedCompton::ComputeAsymmetry(G4double energy,
                                                   >> 335        const G4MaterialCutsCouple* couple,
                                                   >> 336            const G4ParticleDefinition& aParticle,
                                                   >> 337              G4double cut,
                                                   >> 338              G4double & tAsymmetry)
344 {                                                 339 {
345   G4double lAsymmetry = 0.0;                      340   G4double lAsymmetry = 0.0;
346   tAsymmetry          = 0;                     << 341   tAsymmetry=0;
347                                                   342 
                                                   >> 343   //
348   // calculate polarized cross section            344   // calculate polarized cross section
349   G4ThreeVector thePolarization = G4ThreeVecto << 345   //
350   fEmModel->SetTargetPolarization(thePolarizat << 346   G4ThreeVector thePolarization=G4ThreeVector(0.,0.,1.);
351   fEmModel->SetBeamPolarization(thePolarizatio << 347   emModel->SetTargetPolarization(thePolarization);
352   G4double sigma2 =                            << 348   emModel->SetBeamPolarization(thePolarization);
353     fEmModel->CrossSection(couple, &aParticle, << 349   G4double sigma2=emModel->CrossSection(couple,&aParticle,energy,cut,energy);
354                                                   350 
                                                   >> 351   //
355   // calculate unpolarized cross section          352   // calculate unpolarized cross section
356   thePolarization = G4ThreeVector();           << 353   //
357   fEmModel->SetTargetPolarization(thePolarizat << 354   thePolarization=G4ThreeVector();
358   fEmModel->SetBeamPolarization(thePolarizatio << 355   emModel->SetTargetPolarization(thePolarization);
359   G4double sigma0 =                            << 356   emModel->SetBeamPolarization(thePolarization);
360     fEmModel->CrossSection(couple, &aParticle, << 357   G4double sigma0=emModel->CrossSection(couple,&aParticle,energy,cut,energy);
361                                                << 358 
362   // determine asymmetries                     << 359   // determine assymmetries
363   if(sigma0 > 0.)                              << 360   if (sigma0>0.) {
364   {                                            << 361     lAsymmetry=sigma2/sigma0-1.;
365     lAsymmetry = sigma2 / sigma0 - 1.;         << 
366   }                                               362   }
367   return lAsymmetry;                              363   return lAsymmetry;
368 }                                                 364 }
                                                   >> 365 
                                                   >> 366 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
369                                                   367