Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | Protected Member Functions | List of all members
G4PolarizedCompton Class Reference

#include <G4PolarizedCompton.hh>

+ Inheritance diagram for G4PolarizedCompton:

Public Member Functions

 G4PolarizedCompton (const G4String &processName="pol-compt", G4ProcessType type=fElectromagnetic)
 
virtual ~G4PolarizedCompton ()
 
G4bool IsApplicable (const G4ParticleDefinition &)
 
virtual void PrintInfo ()
 
void SetModel (const G4String &name)
 
- Public Member Functions inherited from G4VEmProcess
 G4VEmProcess (const G4String &name, G4ProcessType type=fElectromagnetic)
 
virtual ~G4VEmProcess ()
 
virtual G4bool IsApplicable (const G4ParticleDefinition &p)=0
 
virtual void PrintInfo ()=0
 
void PreparePhysicsTable (const G4ParticleDefinition &)
 
void BuildPhysicsTable (const G4ParticleDefinition &)
 
void PrintInfoDefinition ()
 
void StartTracking (G4Track *)
 
G4double PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
 
G4VParticleChange * PostStepDoIt (const G4Track &, const G4Step &)
 
G4bool StorePhysicsTable (const G4ParticleDefinition *, const G4String &directory, G4bool ascii=false)
 
G4bool RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &directory, G4bool ascii)
 
G4double CrossSectionPerVolume (G4double kineticEnergy, const G4MaterialCutsCouple *couple)
 
G4double ComputeCrossSectionPerAtom (G4double kineticEnergy, G4double Z, G4double A=0., G4double cut=0.0)
 
G4double MeanFreePath (const G4Track &track)
 
G4double GetLambda (G4double &kinEnergy, const G4MaterialCutsCouple *couple)
 
void SetLambdaBinning (G4int nbins)
 
G4int LambdaBinning () const
 
void SetMinKinEnergy (G4double e)
 
G4double MinKinEnergy () const
 
void SetMaxKinEnergy (G4double e)
 
G4double MaxKinEnergy () const
 
void SetMinKinEnergyPrim (G4double e)
 
const G4PhysicsTable * LambdaTable () const
 
const G4ParticleDefinition * Particle () const
 
const G4ParticleDefinition * SecondaryParticle () const
 
G4VEmModel * SelectModelForMaterial (G4double kinEnergy, size_t &idxRegion) const
 
void AddEmModel (G4int, G4VEmModel *, const G4Region *region=0)
 
void SetModel (G4VEmModel *, G4int index=1)
 
G4VEmModel * Model (G4int index=1)
 
G4VEmModel * EmModel (G4int index=1)
 
void SetEmModel (G4VEmModel *, G4int index=1)
 
void UpdateEmModel (const G4String &, G4double, G4double)
 
G4VEmModel * GetModelByIndex (G4int idx=0, G4bool ver=false)
 
const G4Element * GetCurrentElement () const
 
void SetCrossSectionBiasingFactor (G4double f, G4bool flag=true)
 
G4double CrossSectionBiasingFactor () const
 
void ActivateForcedInteraction (G4double length=0.0, const G4String &r="", G4bool flag=true)
 
void ActivateSecondaryBiasing (const G4String &region, G4double factor, G4double energyLimit)
 
void SetPolarAngleLimit (G4double a)
 
G4double PolarAngleLimit () const
 
void SetLambdaFactor (G4double val)
 
void SetIntegral (G4bool val)
 
G4bool IsIntegral () const
 
void SetApplyCuts (G4bool val)
 
void SetBuildTableFlag (G4bool val)
 
- Public Member Functions inherited from G4VDiscreteProcess
 G4VDiscreteProcess (const G4String &, G4ProcessType aType=fNotDefined)
 
 G4VDiscreteProcess (G4VDiscreteProcess &)
 
virtual ~G4VDiscreteProcess ()
 
virtual G4double PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
 
virtual G4VParticleChange * PostStepDoIt (const G4Track &, const G4Step &)
 
virtual G4double AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)
 
virtual G4double AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)
 
virtual G4VParticleChange * AtRestDoIt (const G4Track &, const G4Step &)
 
virtual G4VParticleChange * AlongStepDoIt (const G4Track &, const G4Step &)
 
- Public Member Functions inherited from G4VProcess
 G4VProcess (const G4String &aName="NoName", G4ProcessType aType=fNotDefined)
 
 G4VProcess (const G4VProcess &right)
 
virtual ~G4VProcess ()
 
G4int operator== (const G4VProcess &right) const
 
G4int operator!= (const G4VProcess &right) const
 
virtual G4VParticleChange * PostStepDoIt (const G4Track &track, const G4Step &stepData)=0
 
virtual G4VParticleChange * AlongStepDoIt (const G4Track &track, const G4Step &stepData)=0
 
virtual G4VParticleChange * AtRestDoIt (const G4Track &track, const G4Step &stepData)=0
 
virtual G4double AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)=0
 
virtual G4double AtRestGetPhysicalInteractionLength (const G4Track &track, G4ForceCondition *condition)=0
 
virtual G4double PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)=0
 
G4double GetCurrentInteractionLength () const
 
void SetPILfactor (G4double value)
 
G4double GetPILfactor () const
 
G4double AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)
 
G4double AtRestGPIL (const G4Track &track, G4ForceCondition *condition)
 
G4double PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
 
virtual G4bool IsApplicable (const G4ParticleDefinition &)
 
virtual void BuildPhysicsTable (const G4ParticleDefinition &)
 
virtual void PreparePhysicsTable (const G4ParticleDefinition &)
 
virtual G4bool StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
 
virtual G4bool RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
 
const G4String & GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)
 
const G4String & GetProcessName () const
 
G4ProcessType GetProcessType () const
 
void SetProcessType (G4ProcessType)
 
G4int GetProcessSubType () const
 
void SetProcessSubType (G4int)
 
virtual void StartTracking (G4Track *)
 
virtual void EndTracking ()
 
virtual void SetProcessManager (const G4ProcessManager *)
 
virtual const G4ProcessManager * GetProcessManager ()
 
virtual void ResetNumberOfInteractionLengthLeft ()
 
G4double GetNumberOfInteractionLengthLeft () const
 
G4double GetTotalNumberOfInteractionLengthTraversed () const
 
G4bool isAtRestDoItIsEnabled () const
 
G4bool isAlongStepDoItIsEnabled () const
 
G4bool isPostStepDoItIsEnabled () const
 
virtual void DumpInfo () const
 
void SetVerboseLevel (G4int value)
 
G4int GetVerboseLevel () const
 

Protected Member Functions

virtual void InitialiseProcess (const G4ParticleDefinition *)
 
virtual void BuildPhysicsTable (const G4ParticleDefinition &)
 
virtual void PreparePhysicsTable (const G4ParticleDefinition &)
 
void BuildAsymmetryTable (const G4ParticleDefinition &part)
 
G4double ComputeAsymmetry (G4double energy, const G4MaterialCutsCouple *couple, const G4ParticleDefinition &particle, G4double cut, G4double &tAsymmetry)
 
virtual G4double GetMeanFreePath (const G4Track &aTrack, G4double previousStepSize, G4ForceCondition *condition)
 
virtual G4double PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
 
- Protected Member Functions inherited from G4VEmProcess
virtual void InitialiseProcess (const G4ParticleDefinition *)=0
 
virtual G4double MinPrimaryEnergy (const G4ParticleDefinition *, const G4Material *)
 
G4VEmModel * SelectModel (G4double &kinEnergy, size_t index)
 
G4double GetMeanFreePath (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
 
G4PhysicsVector * LambdaPhysicsVector (const G4MaterialCutsCouple *)
 
G4double RecalculateLambda (G4double kinEnergy, const G4MaterialCutsCouple *couple)
 
G4ParticleChangeForGamma * GetParticleChange ()
 
void SetParticle (const G4ParticleDefinition *p)
 
void SetSecondaryParticle (const G4ParticleDefinition *p)
 
size_t CurrentMaterialCutsCoupleIndex () const
 
G4double GetGammaEnergyCut ()
 
G4double GetElectronEnergyCut ()
 
void SetStartFromNullFlag (G4bool val)
 
void SetSplineFlag (G4bool val)
 
virtual G4double GetMeanFreePath (const G4Track &aTrack, G4double previousStepSize, G4ForceCondition *condition)=0
 
- Protected Member Functions inherited from G4VProcess
void SubtractNumberOfInteractionLengthLeft (G4double previousStepSize)
 
void ClearNumberOfInteractionLengthLeft ()
 

Additional Inherited Members

- Static Public Member Functions inherited from G4VProcess
static const G4String & GetProcessTypeName (G4ProcessType)
 
- Protected Attributes inherited from G4VEmProcess
G4ParticleChangeForGamma fParticleChange
 
- Protected Attributes inherited from G4VProcess
const G4ProcessManager * aProcessManager
 
G4VParticleChange * pParticleChange
 
G4ParticleChange aParticleChange
 
G4double theNumberOfInteractionLengthLeft
 
G4double currentInteractionLength
 
G4double theInitialNumberOfInteractionLength
 
G4String theProcessName
 
G4String thePhysicsTableFileName
 
G4ProcessType theProcessType
 
G4int theProcessSubType
 
G4double thePILfactor
 
G4bool enableAtRestDoIt
 
G4bool enableAlongStepDoIt
 
G4bool enablePostStepDoIt
 
G4int verboseLevel
 

Detailed Description

Definition at line 73 of file G4PolarizedCompton.hh.

Constructor & Destructor Documentation

◆ G4PolarizedCompton()

G4PolarizedCompton::G4PolarizedCompton ( const G4String &  processName = "pol-compt",
G4ProcessType  type = fElectromagnetic 
)

Definition at line 70 of file G4PolarizedCompton.cc.

71 :
72 G4VEmProcess (processName, type),
73 buildAsymmetryTable(true),
74 useAsymmetryTable(true),
75 isInitialised(false),
76 selectedModel(0),
77 mType(10),
78 theAsymmetryTable(NULL)
79{
80 SetLambdaBinning(90);
81 SetMinKinEnergy(0.1*keV);
82 SetMaxKinEnergy(100.0*GeV);
83 SetProcessSubType(fComptonScattering);
84 emModel = 0;
85}
fComptonScattering
@ fComptonScattering
Definition: G4EmProcessSubType.hh:59
G4VEmProcess::SetMinKinEnergy
void SetMinKinEnergy(G4double e)
Definition: G4VEmProcess.cc:1091
G4VEmProcess::SetLambdaBinning
void SetLambdaBinning(G4int nbins)
Definition: G4VEmProcess.hh:539
G4VEmProcess::SetMaxKinEnergy
void SetMaxKinEnergy(G4double e)
Definition: G4VEmProcess.cc:1100
G4VProcess::SetProcessSubType
void SetProcessSubType(G4int)
Definition: G4VProcess.hh:403

◆ ~G4PolarizedCompton()

G4PolarizedCompton::~G4PolarizedCompton ( )
virtual

Definition at line 89 of file G4PolarizedCompton.cc.

90{
91 if (theAsymmetryTable) {
92 theAsymmetryTable->clearAndDestroy();
93 delete theAsymmetryTable;
94 }
95}
G4PhysicsTable::clearAndDestroy
void clearAndDestroy()

Member Function Documentation

◆ BuildAsymmetryTable()

void G4PolarizedCompton::BuildAsymmetryTable ( const G4ParticleDefinition &  part)
protected

Definition at line 303 of file G4PolarizedCompton.cc.

304{
305 // Access to materials
306 const G4ProductionCutsTable* theCoupleTable=
307 G4ProductionCutsTable::GetProductionCutsTable();
308 size_t numOfCouples = theCoupleTable->GetTableSize();
309 for(size_t i=0; i<numOfCouples; ++i) {
310 if (!theAsymmetryTable) break;
311 if (theAsymmetryTable->GetFlag(i)) {
312
313 // create physics vector and fill it
314 const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(i);
315 // use same parameters as for lambda
316 G4PhysicsVector* aVector = LambdaPhysicsVector(couple);
317 // modelManager->FillLambdaVector(aVector, couple, startFromNull);
318
319 for (G4int j = 0 ; j < LambdaBinning() ; ++j ) {
320 G4double lowEdgeEnergy = aVector->GetLowEdgeEnergy(j);
321 G4double tasm=0.;
322 G4double asym = ComputeAsymmetry(lowEdgeEnergy, couple, part, 0., tasm);
323 aVector->PutValue(j,asym);
324 }
325
326 G4PhysicsTableHelper::SetPhysicsVector(theAsymmetryTable, i, aVector);
327 }
328 }
329
330}
G4double
double G4double
Definition: G4Types.hh:64
G4int
int G4int
Definition: G4Types.hh:66
G4PhysicsTableHelper::SetPhysicsVector
static void SetPhysicsVector(G4PhysicsTable *physTable, size_t idx, G4PhysicsVector *vec)
Definition: G4PhysicsTableHelper.cc:199
G4PhysicsTable::GetFlag
G4bool GetFlag(size_t i) const
G4PhysicsVector::GetLowEdgeEnergy
virtual G4double GetLowEdgeEnergy(size_t binNumber) const
Definition: G4PhysicsVector.cc:158
G4PhysicsVector::PutValue
void PutValue(size_t index, G4double theValue)
G4PolarizedCompton::ComputeAsymmetry
G4double ComputeAsymmetry(G4double energy, const G4MaterialCutsCouple *couple, const G4ParticleDefinition &particle, G4double cut, G4double &tAsymmetry)
Definition: G4PolarizedCompton.cc:335
G4ProductionCutsTable::GetMaterialCutsCouple
const G4MaterialCutsCouple * GetMaterialCutsCouple(G4int i) const
Definition: G4ProductionCutsTable.hh:262
G4ProductionCutsTable::GetProductionCutsTable
static G4ProductionCutsTable * GetProductionCutsTable()
Definition: G4ProductionCutsTable.cc:63
G4VEmProcess::LambdaPhysicsVector
G4PhysicsVector * LambdaPhysicsVector(const G4MaterialCutsCouple *)
Definition: G4VEmProcess.cc:1009
G4VEmProcess::LambdaBinning
G4int LambdaBinning() const
Definition: G4VEmProcess.hh:546

Referenced by BuildPhysicsTable().

◆ BuildPhysicsTable()

void G4PolarizedCompton::BuildPhysicsTable ( const G4ParticleDefinition &  part)
protectedvirtual

Reimplemented from G4VProcess.

Definition at line 292 of file G4PolarizedCompton.cc.

293{
294 // *** build (unpolarized) cross section tables (Lambda)
295 G4VEmProcess::BuildPhysicsTable(part);
296 if(buildAsymmetryTable)
297 BuildAsymmetryTable(part);
298}
G4PolarizedCompton::BuildAsymmetryTable
void BuildAsymmetryTable(const G4ParticleDefinition &part)
Definition: G4PolarizedCompton.cc:303
G4VEmProcess::BuildPhysicsTable
void BuildPhysicsTable(const G4ParticleDefinition &)
Definition: G4VEmProcess.cc:336

◆ ComputeAsymmetry()

G4double G4PolarizedCompton::ComputeAsymmetry ( G4double  energy,
const G4MaterialCutsCouple *  couple,
const G4ParticleDefinition &  particle,
G4double  cut,
G4double &  tAsymmetry 
)
protected

Definition at line 335 of file G4PolarizedCompton.cc.

340{
341 G4double lAsymmetry = 0.0;
342 tAsymmetry=0;
343
344 //
345 // calculate polarized cross section
346 //
347 G4ThreeVector thePolarization=G4ThreeVector(0.,0.,1.);
348 emModel->SetTargetPolarization(thePolarization);
349 emModel->SetBeamPolarization(thePolarization);
350 G4double sigma2=emModel->CrossSection(couple,&aParticle,energy,cut,energy);
351
352 //
353 // calculate unpolarized cross section
354 //
355 thePolarization=G4ThreeVector();
356 emModel->SetTargetPolarization(thePolarization);
357 emModel->SetBeamPolarization(thePolarization);
358 G4double sigma0=emModel->CrossSection(couple,&aParticle,energy,cut,energy);
359
360 // determine assymmetries
361 if (sigma0>0.) {
362 lAsymmetry=sigma2/sigma0-1.;
363 }
364 return lAsymmetry;
365}
G4ThreeVector
CLHEP::Hep3Vector G4ThreeVector
Definition: G4ThreeVector.hh:42
G4PolarizedComptonModel::SetTargetPolarization
void SetTargetPolarization(const G4ThreeVector &pTarget)
Definition: G4PolarizedComptonModel.hh:111
G4PolarizedComptonModel::SetBeamPolarization
void SetBeamPolarization(const G4ThreeVector &pBeam)
Definition: G4PolarizedComptonModel.hh:115
G4VEmModel::CrossSection
G4double CrossSection(const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
Definition: G4VEmModel.hh:418

Referenced by BuildAsymmetryTable().

◆ GetMeanFreePath()

G4double G4PolarizedCompton::GetMeanFreePath ( const G4Track &  aTrack,
G4double  previousStepSize,
G4ForceCondition *  condition 
)
protectedvirtual

Implements G4VDiscreteProcess.

Definition at line 140 of file G4PolarizedCompton.cc.

144{
145 // *** get unploarised mean free path from lambda table ***
146 G4double mfp = G4VEmProcess::GetMeanFreePath(aTrack, previousStepSize, condition);
147
148
149 if (theAsymmetryTable && useAsymmetryTable) {
150 // *** get asymmetry, if target is polarized ***
151 const G4DynamicParticle* aDynamicGamma = aTrack.GetDynamicParticle();
152 const G4double GammaEnergy = aDynamicGamma->GetKineticEnergy();
153 const G4StokesVector GammaPolarization = aTrack.GetPolarization();
154 const G4ParticleMomentum GammaDirection0 = aDynamicGamma->GetMomentumDirection();
155
156 G4Material* aMaterial = aTrack.GetMaterial();
157 G4VPhysicalVolume* aPVolume = aTrack.GetVolume();
158 G4LogicalVolume* aLVolume = aPVolume->GetLogicalVolume();
159
160 // G4Material* bMaterial = aLVolume->GetMaterial();
161 G4PolarizationManager * polarizationManger = G4PolarizationManager::GetInstance();
162
163 const G4bool VolumeIsPolarized = polarizationManger->IsPolarized(aLVolume);
164 G4StokesVector ElectronPolarization = polarizationManger->GetVolumePolarization(aLVolume);
165
166 if (!VolumeIsPolarized || mfp == DBL_MAX) return mfp;
167
168 if (verboseLevel>=2) {
169
170 G4cout << " Mom " << GammaDirection0 << G4endl;
171 G4cout << " Polarization " << GammaPolarization << G4endl;
172 G4cout << " MaterialPol. " << ElectronPolarization << G4endl;
173 G4cout << " Phys. Volume " << aPVolume->GetName() << G4endl;
174 G4cout << " Log. Volume " << aLVolume->GetName() << G4endl;
175 G4cout << " Material " << aMaterial << G4endl;
176 }
177
178 G4int midx= CurrentMaterialCutsCoupleIndex();
179 G4PhysicsVector * aVector=(*theAsymmetryTable)(midx);
180
181 G4double asymmetry=0;
182 if (aVector) {
183 G4bool isOutRange;
184 asymmetry = aVector->GetValue(GammaEnergy, isOutRange);
185 } else {
186 G4cout << " MaterialIndex " << midx << " is out of range \n";
187 asymmetry=0;
188 }
189
190 // we have to determine angle between particle motion
191 // and target polarisation here
192 // circ pol * Vec(ElectronPol)*Vec(PhotonMomentum)
193 // both vectors in global reference frame
194
195 G4double pol=ElectronPolarization*GammaDirection0;
196
197 G4double polProduct = GammaPolarization.p3() * pol;
198 mfp *= 1. / ( 1. + polProduct * asymmetry );
199
200 if (verboseLevel>=2) {
201 G4cout << " MeanFreePath: " << mfp / mm << " mm " << G4endl;
202 G4cout << " Asymmetry: " << asymmetry << G4endl;
203 G4cout << " PolProduct: " << polProduct << G4endl;
204 }
205 }
206
207 return mfp;
208}
condition
G4double condition(const G4ErrorSymMatrix &m)
G4bool
bool G4bool
Definition: G4Types.hh:67
G4endl
#define G4endl
Definition: G4ios.hh:52
G4cout
G4DLLIMPORT std::ostream G4cout
G4DynamicParticle::GetMomentumDirection
const G4ThreeVector & GetMomentumDirection() const
G4DynamicParticle::GetKineticEnergy
G4double GetKineticEnergy() const
G4LogicalVolume::GetName
G4String GetName() const
G4PhysicsVector::GetValue
G4double GetValue(G4double theEnergy, G4bool &isOutRange)
G4PolarizationManager::IsPolarized
bool IsPolarized(G4LogicalVolume *lVol) const
Definition: G4PolarizationManager.hh:108
G4PolarizationManager::GetInstance
static G4PolarizationManager * GetInstance()
Definition: G4PolarizationManager.cc:52
G4PolarizationManager::GetVolumePolarization
const G4ThreeVector & GetVolumePolarization(G4LogicalVolume *lVol) const
Definition: G4PolarizationManager.hh:98
G4StokesVector::p3
G4double p3() const
Definition: G4StokesVector.hh:76
G4Track::GetVolume
G4VPhysicalVolume * GetVolume() const
G4Track::GetMaterial
G4Material * GetMaterial() const
G4Track::GetDynamicParticle
const G4DynamicParticle * GetDynamicParticle() const
G4Track::GetPolarization
const G4ThreeVector & GetPolarization() const
G4VEmProcess::GetMeanFreePath
G4double GetMeanFreePath(const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
Definition: G4VEmProcess.cc:920
G4VEmProcess::CurrentMaterialCutsCoupleIndex
size_t CurrentMaterialCutsCoupleIndex() const
Definition: G4VEmProcess.hh:404
G4VPhysicalVolume::GetLogicalVolume
G4LogicalVolume * GetLogicalVolume() const
G4VPhysicalVolume::GetName
const G4String & GetName() const
G4VProcess::verboseLevel
G4int verboseLevel
Definition: G4VProcess.hh:368
DBL_MAX
#define DBL_MAX
Definition: templates.hh:83

◆ InitialiseProcess()

void G4PolarizedCompton::InitialiseProcess ( const G4ParticleDefinition *  )
protectedvirtual

Implements G4VEmProcess.

Definition at line 99 of file G4PolarizedCompton.cc.

100{
101 if(!isInitialised) {
102 isInitialised = true;
103 SetBuildTableFlag(true);
104 SetSecondaryParticle(G4Electron::Electron());
105 G4double emin = MinKinEnergy();
106 G4double emax = MaxKinEnergy();
107 emModel = new G4PolarizedComptonModel();
108 if(0 == mType) selectedModel = new G4KleinNishinaCompton();
109 else if(10 == mType) selectedModel = emModel;
110 selectedModel->SetLowEnergyLimit(emin);
111 selectedModel->SetHighEnergyLimit(emax);
112 AddEmModel(1, selectedModel);
113 }
114}
G4Electron::Electron
static G4Electron * Electron()
Definition: G4Electron.cc:94
G4VEmModel::SetHighEnergyLimit
void SetHighEnergyLimit(G4double)
Definition: G4VEmModel.hh:585
G4VEmModel::SetLowEnergyLimit
void SetLowEnergyLimit(G4double)
Definition: G4VEmModel.hh:592
G4VEmProcess::AddEmModel
void AddEmModel(G4int, G4VEmModel *, const G4Region *region=0)
Definition: G4VEmProcess.cc:182
G4VEmProcess::SetBuildTableFlag
void SetBuildTableFlag(G4bool val)
Definition: G4VEmProcess.hh:646
G4VEmProcess::SetSecondaryParticle
void SetSecondaryParticle(const G4ParticleDefinition *p)
Definition: G4VEmProcess.hh:668
G4VEmProcess::MaxKinEnergy
G4double MaxKinEnergy() const
Definition: G4VEmProcess.hh:560
G4VEmProcess::MinKinEnergy
G4double MinKinEnergy() const
Definition: G4VEmProcess.hh:553

◆ IsApplicable()

G4bool G4PolarizedCompton::IsApplicable ( const G4ParticleDefinition &  p)
inlinevirtual

Implements G4VEmProcess.

Definition at line 138 of file G4PolarizedCompton.hh.

139{
140 return (&p == G4Gamma::Gamma());
141}
G4Gamma::Gamma
static G4Gamma * Gamma()
Definition: G4Gamma.cc:86

◆ PostStepGetPhysicalInteractionLength()

G4double G4PolarizedCompton::PostStepGetPhysicalInteractionLength ( const G4Track &  track,
G4double  previousStepSize,
G4ForceCondition *  condition 
)
protectedvirtual

Reimplemented from G4VDiscreteProcess.

Definition at line 210 of file G4PolarizedCompton.cc.

214{
215 // *** get unploarised mean free path from lambda table ***
216 G4double mfp = G4VEmProcess::PostStepGetPhysicalInteractionLength(aTrack, previousStepSize, condition);
217
218
219 if (theAsymmetryTable && useAsymmetryTable) {
220 // *** get asymmetry, if target is polarized ***
221 const G4DynamicParticle* aDynamicGamma = aTrack.GetDynamicParticle();
222 const G4double GammaEnergy = aDynamicGamma->GetKineticEnergy();
223 const G4StokesVector GammaPolarization = aTrack.GetPolarization();
224 const G4ParticleMomentum GammaDirection0 = aDynamicGamma->GetMomentumDirection();
225
226 G4Material* aMaterial = aTrack.GetMaterial();
227 G4VPhysicalVolume* aPVolume = aTrack.GetVolume();
228 G4LogicalVolume* aLVolume = aPVolume->GetLogicalVolume();
229
230 // G4Material* bMaterial = aLVolume->GetMaterial();
231 G4PolarizationManager * polarizationManger = G4PolarizationManager::GetInstance();
232
233 const G4bool VolumeIsPolarized = polarizationManger->IsPolarized(aLVolume);
234 G4StokesVector ElectronPolarization = polarizationManger->GetVolumePolarization(aLVolume);
235
236 if (!VolumeIsPolarized || mfp == DBL_MAX) return mfp;
237
238 if (verboseLevel>=2) {
239
240 G4cout << " Mom " << GammaDirection0 << G4endl;
241 G4cout << " Polarization " << GammaPolarization << G4endl;
242 G4cout << " MaterialPol. " << ElectronPolarization << G4endl;
243 G4cout << " Phys. Volume " << aPVolume->GetName() << G4endl;
244 G4cout << " Log. Volume " << aLVolume->GetName() << G4endl;
245 G4cout << " Material " << aMaterial << G4endl;
246 }
247
248 G4int midx= CurrentMaterialCutsCoupleIndex();
249 G4PhysicsVector * aVector=(*theAsymmetryTable)(midx);
250
251 G4double asymmetry=0;
252 if (aVector) {
253 G4bool isOutRange;
254 asymmetry = aVector->GetValue(GammaEnergy, isOutRange);
255 } else {
256 G4cout << " MaterialIndex " << midx << " is out of range \n";
257 asymmetry=0;
258 }
259
260 // we have to determine angle between particle motion
261 // and target polarisation here
262 // circ pol * Vec(ElectronPol)*Vec(PhotonMomentum)
263 // both vectors in global reference frame
264
265 G4double pol=ElectronPolarization*GammaDirection0;
266
267 G4double polProduct = GammaPolarization.p3() * pol;
268 mfp *= 1. / ( 1. + polProduct * asymmetry );
269
270 if (verboseLevel>=2) {
271 G4cout << " MeanFreePath: " << mfp / mm << " mm " << G4endl;
272 G4cout << " Asymmetry: " << asymmetry << G4endl;
273 G4cout << " PolProduct: " << polProduct << G4endl;
274 }
275 }
276
277 return mfp;
278}
G4Material::GetMaterial
static G4Material * GetMaterial(const G4String &name, G4bool warning=true)
Definition: G4Material.cc:576
G4VEmProcess::PostStepGetPhysicalInteractionLength
G4double PostStepGetPhysicalInteractionLength(const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
Definition: G4VEmProcess.cc:557

◆ PreparePhysicsTable()

void G4PolarizedCompton::PreparePhysicsTable ( const G4ParticleDefinition &  part)
protectedvirtual

Reimplemented from G4VProcess.

Definition at line 282 of file G4PolarizedCompton.cc.

283{
284 G4VEmProcess::PreparePhysicsTable(part);
285 if(buildAsymmetryTable)
286 theAsymmetryTable = G4PhysicsTableHelper::PreparePhysicsTable(theAsymmetryTable);
287}
G4PhysicsTableHelper::PreparePhysicsTable
static G4PhysicsTable * PreparePhysicsTable(G4PhysicsTable *physTable)
Definition: G4PhysicsTableHelper.cc:64
G4VEmProcess::PreparePhysicsTable
void PreparePhysicsTable(const G4ParticleDefinition &)
Definition: G4VEmProcess.cc:254

◆ PrintInfo()

void G4PolarizedCompton::PrintInfo ( )
virtual

Implements G4VEmProcess.

Definition at line 118 of file G4PolarizedCompton.cc.

119{
120 G4cout << " Total cross sections has a good parametrisation"
121 << " from 10 KeV to (100/Z) GeV"
122 << "\n Sampling according " << selectedModel->GetName() << " model"
123 << G4endl;
124}
G4VEmModel::GetName
const G4String & GetName() const
Definition: G4VEmModel.hh:655

◆ SetModel()

void G4PolarizedCompton::SetModel ( const G4String &  name)

Definition at line 128 of file G4PolarizedCompton.cc.

129{
130 if(ss == "Klein-Nishina") mType = 0;
131 if(ss == "Polarized-Compton") mType = 10;
132}
The documentation for this class was generated from the following files: