Gabriele Cosmo
783 lines
28 KiB
C++
783 lines
28 KiB
C++
//
|
|
// ********************************************************************
|
|
// * License and Disclaimer *
|
|
// * *
|
|
// * The Geant4 software is copyright of the Copyright Holders of *
|
|
// * the Geant4 Collaboration. It is provided under the terms and *
|
|
// * conditions of the Geant4 Software License, included in the file *
|
|
// * LICENSE and available at http://cern.ch/geant4/license . These *
|
|
// * include a list of copyright holders. *
|
|
// * *
|
|
// * Neither the authors of this software system, nor their employing *
|
|
// * institutes,nor the agencies providing financial support for this *
|
|
// * work make any representation or warranty, express or implied, *
|
|
// * regarding this software system or assume any liability for its *
|
|
// * use. Please see the license in the file LICENSE and URL above *
|
|
// * for the full disclaimer and the limitation of liability. *
|
|
// * *
|
|
// * This code implementation is the result of the scientific and *
|
|
// * technical work of the GEANT4 collaboration. *
|
|
// * By using, copying, modifying or distributing the software (or *
|
|
// * any work based on the software) you agree to acknowledge its *
|
|
// * use in resulting scientific publications, and indicate your *
|
|
// * acceptance of all terms of the Geant4 Software license. *
|
|
// ********************************************************************
|
|
//
|
|
//
|
|
//
|
|
#ifndef G4FTFParameters_h
|
|
#define G4FTFParameters_h 1
|
|
|
|
#include <CLHEP/Units/SystemOfUnits.h>
|
|
#include <vector>
|
|
#include "G4Types.hh"
|
|
#include "G4Exp.hh"
|
|
|
|
class G4ParticleDefinition;
|
|
class G4VComponentCrossSection;
|
|
class G4LundStringFragmentation;
|
|
|
|
|
|
// NOTE: the settings are different for:
|
|
// * baryons projectile
|
|
// * anti-baryons projectile
|
|
// * pions (chg or pi0) projectile
|
|
// * kaons projectile (pdg = +/-321, 311, 130, or 310)
|
|
// * "undefined" projectile - nucleon assumed
|
|
|
|
class G4FTFParamCollection {
|
|
public:
|
|
|
|
//dtor
|
|
virtual ~G4FTFParamCollection() {}
|
|
|
|
// parameters of excitation
|
|
//
|
|
// Proc=0 --> Qexchg w/o excitation
|
|
//
|
|
double GetProc0A1() const { return fProc0A1; }
|
|
double GetProc0B1() const { return fProc0B1; }
|
|
double GetProc0A2() const { return fProc0A2; }
|
|
double GetProc0B2() const { return fProc0B2; }
|
|
double GetProc0A3() const { return fProc0A3; }
|
|
double GetProc0Atop() const { return fProc0Atop; }
|
|
double GetProc0Ymin() const { return fProc0Ymin; }
|
|
//
|
|
// Proc=1 --> Qexchg w/excitation
|
|
//
|
|
double GetProc1A1() const { return fProc1A1; }
|
|
double GetProc1B1() const { return fProc1B1; }
|
|
double GetProc1A2() const { return fProc1A2; }
|
|
double GetProc1B2() const { return fProc1B2; }
|
|
double GetProc1A3() const { return fProc1A3; }
|
|
double GetProc1Atop() const { return fProc1Atop; }
|
|
double GetProc1Ymin() const { return fProc1Ymin; }
|
|
//
|
|
// Proc=2 & Proc=3 in case ( AbsProjectileBaryonNumber > 1 || NumberOfTargetNucleons > 1 )
|
|
// Update: Proc=2 & Proc=3 in case ( AbsProjectileBaryonNumber > 10 || NumberOfTargetNucleons > 10 )
|
|
// (diffraction dissociation)
|
|
//
|
|
// Other parameters have a complex form for baryon projectile
|
|
// although they're just numbers for e.g. pions projectile
|
|
//
|
|
// Proc=2 --> Projectile diffraction
|
|
//
|
|
double GetProc2A1() const { return fProc2A1; }
|
|
double GetProc2B1() const { return fProc2B1; }
|
|
double GetProc2A2() const { return fProc2A2; }
|
|
double GetProc2B2() const { return fProc2B2; }
|
|
double GetProc2A3() const { return fProc2A3; }
|
|
double GetProc2Atop() const { return fProc2Atop; }
|
|
double GetProc2Ymin() const { return fProc2Ymin; }
|
|
//
|
|
// Proc=3 --> Target diffraction
|
|
//
|
|
double GetProc3A1() const { return fProc3A1; }
|
|
double GetProc3B1() const { return fProc3B1; }
|
|
double GetProc3A2() const { return fProc3A2; }
|
|
double GetProc3B2() const { return fProc3B2; }
|
|
double GetProc3A3() const { return fProc3A3; }
|
|
double GetProc3Atop() const { return fProc3Atop; }
|
|
double GetProc3Ymin() const { return fProc3Ymin; }
|
|
//
|
|
bool IsProjDiffDissociation() const { return fProjDiffDissociation; }
|
|
bool IsTgtDiffDissociation() const { return fTgtDiffDissociation; }
|
|
//
|
|
// Proc=4 --> Qexchg "w/additional multiplier" in excitation
|
|
//
|
|
double GetProc4A1() const { return fProc4A1; }
|
|
double GetProc4B1() const { return fProc4B1; }
|
|
double GetProc4A2() const { return fProc4A2; }
|
|
double GetProc4B2() const { return fProc4B2; }
|
|
double GetProc4A3() const { return fProc4A3; }
|
|
double GetProc4Atop() const { return fProc4Atop; }
|
|
double GetProc4Ymin() const { return fProc4Ymin; }
|
|
//
|
|
//
|
|
double GetDeltaProbAtQuarkExchange() const { return fDeltaProbAtQuarkExchange; }
|
|
double GetProbOfSameQuarkExchange() const { return fProbOfSameQuarkExchange; }
|
|
double GetProjMinDiffMass() const { return fProjMinDiffMass; }
|
|
double GetProjMinNonDiffMass() const { return fProjMinNonDiffMass; }
|
|
double GetTgtMinDiffMass() const { return fTgtMinDiffMass; }
|
|
double GetTgtMinNonDiffMass() const { return fTgtMinNonDiffMass; }
|
|
double GetAveragePt2() const { return fAveragePt2; }
|
|
double GetProbLogDistrPrD() const { return fProbLogDistrPrD; }
|
|
double GetProbLogDistr() const { return fProbLogDistr; }
|
|
|
|
// NOTE (JVY): There is also the Pt2Kind parameter but for now it's set to 0., so we'll leave it aside
|
|
|
|
// --> FIXME !!! --> void Get/SetBaryonMaxNumberOfCollisions( const double, const double ); // 1st is Plab, 2nd - D=2.
|
|
//
|
|
double GetNuclearProjDestructP1() const { return fNuclearProjDestructP1; }
|
|
bool IsNuclearProjDestructP1_NBRNDEP() const { return fNuclearProjDestructP1_NBRNDEP; }
|
|
double GetNuclearTgtDestructP1() const { return fNuclearTgtDestructP1; }
|
|
bool IsNuclearTgtDestructP1_ADEP() const { return fNuclearTgtDestructP1_ADEP; }
|
|
double GetNuclearProjDestructP2() const { return fNuclearProjDestructP2; }
|
|
double GetNuclearProjDestructP3() const { return fNuclearProjDestructP3; }
|
|
double GetNuclearTgtDestructP2() const { return fNuclearTgtDestructP2; }
|
|
double GetNuclearTgtDestructP3() const { return fNuclearTgtDestructP3; }
|
|
double GetPt2NuclearDestructP1() const { return fPt2NuclearDestructP1; }
|
|
double GetPt2NuclearDestructP2() const { return fPt2NuclearDestructP2; }
|
|
double GetPt2NuclearDestructP3() const { return fPt2NuclearDestructP3; }
|
|
double GetPt2NuclearDestructP4() const { return fPt2NuclearDestructP4; }
|
|
//
|
|
// separately for baryons, mesons, etc.
|
|
//
|
|
double GetR2ofNuclearDestruct() const { return fR2ofNuclearDestruct; }
|
|
double GetExciEnergyPerWoundedNucleon() const { return fExciEnergyPerWoundedNucleon; }
|
|
double GetDofNuclearDestruct() const { return fDofNuclearDestruct; }
|
|
double GetMaxPt2ofNuclearDestruct() const { return fMaxPt2ofNuclearDestruct; }
|
|
|
|
protected:
|
|
|
|
// ctor
|
|
G4FTFParamCollection();
|
|
|
|
// parameters of excitation
|
|
//
|
|
//
|
|
// these are for Inelastic interactions, i.e. Xinelastic=(Xtotal-Xelastix)>0.
|
|
// for elastic, all the A's & B's, Atop & Ymin are zeros
|
|
// general formula: Pp = A1*exp(B1*Y) + A2*exp(B2*Y) + A3
|
|
// but if Y<Ymin, then Pp=max(0.,Atop)
|
|
// for details, see also G4FTFParameters::GetProcProb( ProcN, y )
|
|
//
|
|
// Proc=0 --> Qexchg w/o excitation
|
|
double fProc0A1; // D=13.71
|
|
double fProc0B1; // D=1.75
|
|
double fProc0A2; // D=-30.69 (or -214.5 as in Doc ?)
|
|
double fProc0B2; // D=3. ( or 4. as in Doc ?)
|
|
double fProc0A3; // D=0.
|
|
double fProc0Atop; // D=1. ( or 0.5 as in Doc ?)
|
|
double fProc0Ymin; // D=0.93 (or 1.1 as in Doc ?)
|
|
// Proc=1 --> Qexchg w/excitation
|
|
double fProc1A1; // D=25.
|
|
double fProc1B1; // D=1.
|
|
double fProc1A2; // D=-50.34
|
|
double fProc1B2; // D=1.5
|
|
double fProc1A3; // D=0.
|
|
double fProc1Atop; // D=0.
|
|
double fProc1Ymin; // D=1.4
|
|
//
|
|
// NOTE: Proc #2 & 3 are projectile & target diffraction
|
|
// they have more complex definition of A1 & A2
|
|
// for *baryons* although they're just numbers for pions
|
|
// (example for baryons below)
|
|
// SetParams( 2, 6.0/Xinel, 0.0 ,-6.0/Xinel*16.28, 3.0 , 0.0, 0.0 , 0.93);// Projectile diffraction
|
|
// SetParams( 3, 6.0/Xinel, 0.0 ,-6.0/Xinel*16.28, 3.0 , 0.0, 0.0 , 0.93);// Target diffraction
|
|
//
|
|
// Also, for ( AbsProjectileBaryonNumber > 1 || NumberOfTargetNucleons > 1 )
|
|
// projectile and/or target diffraction (dissociation) may be switched ON/OFF
|
|
bool fProjDiffDissociation;
|
|
bool fTgtDiffDissociation;
|
|
// Proc=2 --> Projectile diffraction
|
|
double fProc2A1;
|
|
double fProc2B1;
|
|
double fProc2A2;
|
|
double fProc2B2;
|
|
double fProc2A3;
|
|
double fProc2Atop;
|
|
double fProc2Ymin;
|
|
// Proc=3 --> Target diffraction
|
|
double fProc3A1;
|
|
double fProc3B1;
|
|
double fProc3A2;
|
|
double fProc3B2;
|
|
double fProc3A3;
|
|
double fProc3Atop;
|
|
double fProc3Ymin;
|
|
// Proc=4 --> Qexchg w/additional multiplier in excitation
|
|
double fProc4A1; // D=0.6 (or 1. as in Doc ?)
|
|
double fProc4B1; // D=0.
|
|
double fProc4A2; // D=-1.2 (or -2.01 as in Doc ?)
|
|
double fProc4B2; // D=0.5
|
|
double fProc4A3; // D=0.
|
|
double fProc4Atop; // D=0.
|
|
double fProc4Ymin; // D=1.4
|
|
//
|
|
// parameters of participating baryon excitation
|
|
// NOTE: baryon ot HADRON ???
|
|
// NOTE: this parameters (as C++ class data members) are used for all types of hadrons
|
|
// but the values for a specific group of particles can be are different from
|
|
// another group of particles
|
|
// the defaults listed under coments are for baryons,
|
|
// and they may be different or the same for other hadrons (e.g. mesons)
|
|
//
|
|
double fDeltaProbAtQuarkExchange; // D=0.
|
|
double fProbOfSameQuarkExchange; // D=0. if A<=26, otherwise D=1.
|
|
double fProjMinDiffMass; // projectile, D=1.16GeV
|
|
double fProjMinNonDiffMass; // projectile, D=1.16GeV
|
|
double fTgtMinDiffMass; // target, D=1.16GeV
|
|
double fTgtMinNonDiffMass; // target, D=1.16GeV
|
|
double fAveragePt2; // D=0.3GeV**2 ( or 0.15 as in the Doc ???)
|
|
double fProbLogDistrPrD; // D=0.55 (or 0.6 ??? or 0.3 ???)
|
|
double fProbLogDistr; // D=0.55 (or 0.6 ??? or 0.3 ???)
|
|
|
|
// parameters of nuclear distruction
|
|
//
|
|
// NOTE (JVY): there're 3 cases here:
|
|
// * baryon projectile
|
|
// * anti-baryon projectile
|
|
// * meson projectile
|
|
//
|
|
// double fBaryonMaxNumberOfCollisions; // D=2.
|
|
// void SetBaryonProbOfInteraction( const double ); // ??? this is prob. of inelastic interaction
|
|
// that is set internally based on certain conditions...
|
|
// general (i.e. for used for baryons,anti-baryons, and mesons)
|
|
// NOTE: these parameters have stayed THE SAME for quite a while
|
|
double fNuclearProjDestructP1; // D=0.00481 in 10.3.ref04 !!!
|
|
// BUT !!! In 10.3.ref04 as well as in 10.2-seriesit's multiplied of AbsProjectileBaryonNumber
|
|
// which somehow is 0 for the proton projectile (see in 10.3.ref04 around lines 130-140 In G4FTFParameters.cc).
|
|
// For the target destr. it's multipled by the number of target nucleons (12 for Carbon).
|
|
// In 10.3.p01 it's set to 1. FLAT OUT for both projectile & target, no multiplications, etc.
|
|
// Now, make default at 1.
|
|
bool fNuclearProjDestructP1_NBRNDEP;
|
|
double fNuclearTgtDestructP1; // Make D=1. as in 10.3.p01
|
|
bool fNuclearTgtDestructP1_ADEP;
|
|
double fNuclearProjDestructP2; // D=4.0
|
|
double fNuclearProjDestructP3; // D=2.1
|
|
double fNuclearTgtDestructP2; // D=4.0
|
|
double fNuclearTgtDestructP3; // D=2.1
|
|
//
|
|
double fPt2NuclearDestructP1; // D=0.035
|
|
double fPt2NuclearDestructP2; // D=0.04
|
|
double fPt2NuclearDestructP3; // D=4.0
|
|
double fPt2NuclearDestructP4; // D=2.5
|
|
// baryons... well, in fact also mesons...
|
|
double fR2ofNuclearDestruct; // D=1.5*fermi*fermi
|
|
double fExciEnergyPerWoundedNucleon; // D=40MeV
|
|
double fDofNuclearDestruct; // D=0.3
|
|
// NOTE: this parameter has changed from 1. to 9. between 10.2 and 10.4.ref04 !!!
|
|
// ... but that's for baryons !
|
|
// ... while for mesons it's 1GeV**2
|
|
double fMaxPt2ofNuclearDestruct; // D=9GeV**2
|
|
|
|
private:
|
|
|
|
void Reset();
|
|
};
|
|
|
|
|
|
class G4FTFParamCollBaryonProj : public G4FTFParamCollection {
|
|
public:
|
|
// ctor
|
|
G4FTFParamCollBaryonProj();
|
|
};
|
|
|
|
class G4FTFParamCollMesonProj : public G4FTFParamCollection {
|
|
|
|
public:
|
|
|
|
// ctor
|
|
G4FTFParamCollMesonProj();
|
|
|
|
};
|
|
|
|
class G4FTFParamCollPionProj : public G4FTFParamCollMesonProj {
|
|
|
|
public:
|
|
|
|
// ctor
|
|
G4FTFParamCollPionProj();
|
|
|
|
};
|
|
|
|
class G4FTFParameters {
|
|
public:
|
|
G4FTFParameters();
|
|
~G4FTFParameters();
|
|
|
|
void InitForInteraction( const G4ParticleDefinition* , G4int theA, G4int theZ, G4double s );
|
|
|
|
// Set geometrical parameteres
|
|
void SethNcmsEnergy( const G4double s );
|
|
void SetTotalCrossSection( const G4double Xtotal );
|
|
void SetElastisCrossSection( const G4double Xelastic );
|
|
void SetInelasticCrossSection( const G4double Xinelastic );
|
|
void SetProbabilityOfElasticScatt( const G4double Xtotal, const G4double Xelastic );
|
|
void SetProbabilityOfElasticScatt( const G4double aValue );
|
|
void SetProbabilityOfAnnihilation( const G4double aValue );
|
|
void SetRadiusOfHNinteractions2( const G4double Radius2 );
|
|
|
|
void SetSlope( const G4double Slope );
|
|
void SetGamma0( const G4double Gamma0 );
|
|
G4double GammaElastic( const G4double impactsquare );
|
|
|
|
// Set parameters of elastic scattering
|
|
void SetAvaragePt2ofElasticScattering( const G4double aPt2 );
|
|
|
|
// Set parameters of excitations
|
|
void SetParams( const G4int ProcN,
|
|
const G4double A1, const G4double B1, const G4double A2, const G4double B2,
|
|
const G4double A3, const G4double Atop, const G4double Ymin );
|
|
|
|
void SetDeltaProbAtQuarkExchange( const G4double aValue );
|
|
void SetProbOfSameQuarkExchange( const G4double aValue );
|
|
|
|
void SetProjMinDiffMass( const G4double aValue );
|
|
void SetProjMinNonDiffMass( const G4double aValue );
|
|
//void SetProbabilityOfProjDiff( const G4double aValue );
|
|
void SetProbLogDistrPrD( const G4double aValue );
|
|
|
|
void SetTarMinDiffMass( const G4double aValue );
|
|
void SetTarMinNonDiffMass( const G4double aValue );
|
|
//void SetProbabilityOfTarDiff( const G4double aValue );
|
|
|
|
void SetAveragePt2( const G4double aValue );
|
|
void SetProbLogDistr( const G4double aValue );
|
|
|
|
// Set parameters of a string kink
|
|
void SetPt2Kink( const G4double aValue );
|
|
void SetQuarkProbabilitiesAtGluonSplitUp( const G4double Puubar, const G4double Pddbar,
|
|
const G4double Pssbar );
|
|
|
|
// Set parameters of nuclear destruction
|
|
void SetMaxNumberOfCollisions( const G4double aValue, const G4double bValue );
|
|
void SetProbOfInteraction( const G4double aValue );
|
|
|
|
void SetCofNuclearDestructionPr( const G4double aValue );
|
|
void SetCofNuclearDestruction( const G4double aValue );
|
|
void SetR2ofNuclearDestruction( const G4double aValue );
|
|
|
|
void SetExcitationEnergyPerWoundedNucleon( const G4double aValue );
|
|
|
|
void SetDofNuclearDestruction( const G4double aValue );
|
|
void SetPt2ofNuclearDestruction( const G4double aValue );
|
|
void SetMaxPt2ofNuclearDestruction( const G4double aValue );
|
|
|
|
// Get geometrical parameteres
|
|
G4double GetTotalCrossSection();
|
|
G4double GetElasticCrossSection();
|
|
G4double GetInelasticCrossSection();
|
|
|
|
G4double GetProbabilityOfInteraction( const G4double impactsquare );
|
|
G4double GetInelasticProbability( const G4double impactsquare );
|
|
G4double GetProbabilityOfElasticScatt();
|
|
G4double GetSlope();
|
|
G4double GetProbabilityOfAnnihilation();
|
|
|
|
// Get parameters of elastic scattering
|
|
G4double GetAvaragePt2ofElasticScattering();
|
|
|
|
// Get parameters of excitations
|
|
G4double GetProcProb( const G4int ProcN, const G4double y );
|
|
|
|
G4double GetDeltaProbAtQuarkExchange();
|
|
G4double GetProbOfSameQuarkExchange();
|
|
|
|
G4double GetProjMinDiffMass();
|
|
G4double GetProjMinNonDiffMass();
|
|
G4double GetProbLogDistrPrD();
|
|
|
|
G4double GetTarMinDiffMass();
|
|
G4double GetTarMinNonDiffMass();
|
|
|
|
G4double GetAveragePt2();
|
|
G4double GetProbLogDistr();
|
|
|
|
// Get parameters of a string kink
|
|
G4double GetPt2Kink();
|
|
std::vector< G4double > GetQuarkProbabilitiesAtGluonSplitUp();
|
|
|
|
// Get parameters of nuclear destruction
|
|
G4double GetMaxNumberOfCollisions();
|
|
G4double GetProbOfInteraction();
|
|
|
|
G4double GetCofNuclearDestructionPr();
|
|
G4double GetCofNuclearDestruction();
|
|
G4double GetR2ofNuclearDestruction();
|
|
|
|
G4double GetExcitationEnergyPerWoundedNucleon();
|
|
|
|
G4double GetDofNuclearDestruction();
|
|
G4double GetPt2ofNuclearDestruction();
|
|
G4double GetMaxPt2ofNuclearDestruction();
|
|
|
|
// JVY, July 31, 2017: Is there any reason for NOT making
|
|
// all the members data private ???
|
|
//
|
|
// private:
|
|
|
|
// Initial energy of hN interactions
|
|
G4double FTFhNcmsEnergy; // Initial hN CMS energy
|
|
|
|
// Geometrical parameteres
|
|
G4double FTFXtotal; // Total X in mb
|
|
G4double FTFXelastic; // Elastic X in mb
|
|
G4double FTFXinelastic; // Inelastic X in mb
|
|
G4double FTFXannihilation; // Annihilation X in mb
|
|
G4double ProbabilityOfAnnihilation; // Xannih/Xinelast
|
|
G4double ProbabilityOfElasticScatt; // Xel/Xtot
|
|
G4double RadiusOfHNinteractions2; // Xtot/pi, in fm^2
|
|
G4double FTFSlope; // in fm^-1
|
|
G4double AvaragePt2ofElasticScattering; // in MeV^2
|
|
G4double FTFGamma0;
|
|
|
|
// Parameters of excitations
|
|
G4double ProcParams[5][7];
|
|
|
|
G4double DeltaProbAtQuarkExchange;
|
|
G4double ProbOfSameQuarkExchange;
|
|
|
|
G4double ProjMinDiffMass;
|
|
G4double ProjMinNonDiffMass;
|
|
G4double ProbLogDistrPrD;
|
|
G4double TarMinDiffMass;
|
|
G4double TarMinNonDiffMass;
|
|
|
|
G4double AveragePt2;
|
|
G4double ProbLogDistr;
|
|
|
|
// Parameters of kink
|
|
G4double Pt2kink;
|
|
std::vector< G4double > QuarkProbabilitiesAtGluonSplitUp;
|
|
|
|
// Parameters of nuclear destruction
|
|
G4double MaxNumberOfCollisions;
|
|
G4double ProbOfInelInteraction;
|
|
|
|
G4double CofNuclearDestructionPr; // Cnd of nuclear destruction of projectile nucleus
|
|
G4double CofNuclearDestruction; // Cnd of nuclear destruction
|
|
G4double R2ofNuclearDestruction; // R2nd
|
|
|
|
G4double ExcitationEnergyPerWoundedNucleon;
|
|
|
|
G4double DofNuclearDestruction; // Dispersion for momentum sampling
|
|
G4double Pt2ofNuclearDestruction; // Pt2
|
|
G4double MaxPt2ofNuclearDestruction; // Max Pt2
|
|
|
|
private:
|
|
G4LundStringFragmentation* StringMass;
|
|
G4double GetMinMass( const G4ParticleDefinition* aParticle );
|
|
|
|
void Reset();
|
|
|
|
// JVY, July 31, 2017: encapsulates (current set of) parameters for the baryon projectile
|
|
//
|
|
G4FTFParamCollBaryonProj fParCollBaryonProj;
|
|
|
|
// JVY, Feb 14, 2019: encapsulates (current set of) parameters for meson/pion (+/-/0) projectile
|
|
G4FTFParamCollMesonProj fParCollMesonProj;
|
|
G4FTFParamCollPionProj fParCollPionProj;
|
|
|
|
// Glauber-Gribov hN x-section
|
|
G4VComponentCrossSection* csGGinstance;
|
|
};
|
|
|
|
|
|
inline G4double G4FTFParameters::GammaElastic( const G4double impactsquare ) {
|
|
return ( FTFGamma0 * G4Exp( -FTFSlope * impactsquare ) );
|
|
}
|
|
|
|
inline void G4FTFParameters::SethNcmsEnergy( const G4double S ) {
|
|
FTFhNcmsEnergy = S;
|
|
}
|
|
|
|
// Set geometrical parameteres
|
|
|
|
inline void G4FTFParameters::SetTotalCrossSection( const G4double Xtotal ) {
|
|
FTFXtotal = Xtotal;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetElastisCrossSection( const G4double Xelastic ) {
|
|
FTFXelastic = Xelastic;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetInelasticCrossSection( const G4double Xinelastic ) {
|
|
FTFXinelastic = Xinelastic;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetProbabilityOfElasticScatt( const G4double Xtotal,
|
|
const G4double Xelastic ) {
|
|
if ( Xtotal == 0.0 ) {
|
|
ProbabilityOfElasticScatt = 0.0;
|
|
} else {
|
|
ProbabilityOfElasticScatt = Xelastic / Xtotal;
|
|
}
|
|
}
|
|
|
|
inline void G4FTFParameters::SetProbabilityOfElasticScatt( const G4double aValue ) {
|
|
ProbabilityOfElasticScatt = aValue;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetProbabilityOfAnnihilation( const G4double aValue ) {
|
|
ProbabilityOfAnnihilation = aValue;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetRadiusOfHNinteractions2( const G4double Radius2 ) {
|
|
RadiusOfHNinteractions2 = Radius2;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetSlope( const G4double Slope ) {
|
|
FTFSlope = 12.84 / Slope; // Slope is in GeV^-2, FTFSlope in fm^-2
|
|
}
|
|
|
|
inline void G4FTFParameters::SetGamma0( const G4double Gamma0 ) {
|
|
FTFGamma0 = Gamma0;
|
|
}
|
|
|
|
// Set parameters of elastic scattering
|
|
inline void G4FTFParameters::SetAvaragePt2ofElasticScattering( const G4double aPt2 ) {
|
|
AvaragePt2ofElasticScattering = aPt2;
|
|
}
|
|
|
|
// Set parameters of excitations
|
|
|
|
inline void G4FTFParameters::SetParams( const G4int ProcN,
|
|
const G4double A1, const G4double B1, const G4double A2,
|
|
const G4double B2, const G4double A3, const G4double Atop,
|
|
const G4double Ymin ) {
|
|
ProcParams[ProcN][0] = A1; ProcParams[ProcN][1] = B1;
|
|
ProcParams[ProcN][2] = A2; ProcParams[ProcN][3] = B2;
|
|
ProcParams[ProcN][4] = A3;
|
|
ProcParams[ProcN][5] = Atop; ProcParams[ProcN][6] = Ymin;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetDeltaProbAtQuarkExchange( const G4double aValue ) {
|
|
DeltaProbAtQuarkExchange = aValue;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetProbOfSameQuarkExchange( const G4double aValue ) {
|
|
ProbOfSameQuarkExchange = aValue;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetProjMinDiffMass( const G4double aValue ) {
|
|
ProjMinDiffMass = aValue*CLHEP::GeV;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetProjMinNonDiffMass( const G4double aValue ) {
|
|
ProjMinNonDiffMass = aValue*CLHEP::GeV;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetTarMinDiffMass( const G4double aValue ) {
|
|
TarMinDiffMass = aValue*CLHEP::GeV;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetTarMinNonDiffMass( const G4double aValue ) {
|
|
TarMinNonDiffMass = aValue*CLHEP::GeV;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetAveragePt2( const G4double aValue ) {
|
|
AveragePt2 = aValue*CLHEP::GeV*CLHEP::GeV;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetProbLogDistrPrD( const G4double aValue ) {
|
|
ProbLogDistrPrD = aValue;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetProbLogDistr( const G4double aValue ) {
|
|
ProbLogDistr = aValue;
|
|
}
|
|
|
|
// Set parameters of a string kink
|
|
|
|
inline void G4FTFParameters::SetPt2Kink( const G4double aValue ) {
|
|
Pt2kink = aValue;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetQuarkProbabilitiesAtGluonSplitUp( const G4double Puubar,
|
|
const G4double Pddbar,
|
|
const G4double Pssbar ) {
|
|
QuarkProbabilitiesAtGluonSplitUp.push_back( Puubar );
|
|
QuarkProbabilitiesAtGluonSplitUp.push_back( Puubar + Pddbar );
|
|
QuarkProbabilitiesAtGluonSplitUp.push_back( Puubar + Pddbar + Pssbar );
|
|
}
|
|
|
|
// Set parameters of nuclear destruction
|
|
inline void G4FTFParameters::SetMaxNumberOfCollisions( const G4double Plab,
|
|
const G4double Pbound ) {
|
|
if ( Plab > Pbound ) {
|
|
MaxNumberOfCollisions = Plab/Pbound;
|
|
SetProbOfInteraction( -1.0 );
|
|
} else {
|
|
//MaxNumberOfCollisions = -1.0;
|
|
//SetProbOfInteraction( G4Exp( 0.25*(Plab-Pbound) ) );
|
|
MaxNumberOfCollisions = 1;
|
|
SetProbOfInteraction( -1.0 );
|
|
}
|
|
}
|
|
|
|
inline void G4FTFParameters::SetProbOfInteraction( const G4double aValue ) {
|
|
ProbOfInelInteraction = aValue;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetCofNuclearDestructionPr( const G4double aValue ) {
|
|
CofNuclearDestructionPr = aValue;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetCofNuclearDestruction( const G4double aValue ) {
|
|
CofNuclearDestruction = aValue;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetR2ofNuclearDestruction( const G4double aValue ) {
|
|
R2ofNuclearDestruction = aValue;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetExcitationEnergyPerWoundedNucleon( const G4double aValue ) {
|
|
ExcitationEnergyPerWoundedNucleon = aValue;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetDofNuclearDestruction( const G4double aValue ) {
|
|
DofNuclearDestruction = aValue;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetPt2ofNuclearDestruction( const G4double aValue ) {
|
|
Pt2ofNuclearDestruction = aValue;
|
|
}
|
|
|
|
inline void G4FTFParameters::SetMaxPt2ofNuclearDestruction( const G4double aValue ) {
|
|
MaxPt2ofNuclearDestruction = aValue;
|
|
}
|
|
|
|
// Get geometrical parameteres
|
|
inline G4double G4FTFParameters::GetTotalCrossSection() {
|
|
return FTFXtotal;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetElasticCrossSection() {
|
|
return FTFXelastic;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetInelasticCrossSection() {
|
|
return FTFXinelastic;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetSlope() {
|
|
return FTFSlope;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetProbabilityOfInteraction( const G4double impactsquare ) {
|
|
if ( RadiusOfHNinteractions2 > impactsquare ) {
|
|
return 1.0;
|
|
} else {
|
|
return 0.0;
|
|
}
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetProbabilityOfElasticScatt() {
|
|
return ProbabilityOfElasticScatt;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetInelasticProbability( const G4double impactsquare ) {
|
|
G4double Gamma = GammaElastic( impactsquare );
|
|
return 2*Gamma - Gamma*Gamma;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetProbabilityOfAnnihilation() {
|
|
return ProbabilityOfAnnihilation;
|
|
}
|
|
|
|
// Get parameters of elastic scattering
|
|
inline G4double G4FTFParameters::GetAvaragePt2ofElasticScattering() {
|
|
return AvaragePt2ofElasticScattering;
|
|
}
|
|
|
|
// Get parameters of excitations
|
|
|
|
inline G4double G4FTFParameters::GetDeltaProbAtQuarkExchange() {
|
|
return DeltaProbAtQuarkExchange;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetProbOfSameQuarkExchange() {
|
|
return ProbOfSameQuarkExchange;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetProjMinDiffMass() {
|
|
return ProjMinDiffMass;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetProjMinNonDiffMass() {
|
|
return ProjMinNonDiffMass;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetTarMinDiffMass() {
|
|
return TarMinDiffMass;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetTarMinNonDiffMass() {
|
|
return TarMinNonDiffMass;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetAveragePt2() {
|
|
return AveragePt2;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetProbLogDistrPrD() {
|
|
return ProbLogDistrPrD;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetProbLogDistr() {
|
|
return ProbLogDistr;
|
|
}
|
|
|
|
// Get parameters of a string kink
|
|
|
|
inline G4double G4FTFParameters::GetPt2Kink() {
|
|
return Pt2kink;
|
|
}
|
|
|
|
inline std::vector< G4double > G4FTFParameters::GetQuarkProbabilitiesAtGluonSplitUp() {
|
|
return QuarkProbabilitiesAtGluonSplitUp;
|
|
}
|
|
|
|
// Get parameters of nuclear destruction
|
|
|
|
inline G4double G4FTFParameters::GetMaxNumberOfCollisions() {
|
|
return MaxNumberOfCollisions;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetProbOfInteraction() {
|
|
return ProbOfInelInteraction;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetCofNuclearDestructionPr() {
|
|
return CofNuclearDestructionPr;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetCofNuclearDestruction() {
|
|
return CofNuclearDestruction;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetR2ofNuclearDestruction() {
|
|
return R2ofNuclearDestruction;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetExcitationEnergyPerWoundedNucleon() {
|
|
return ExcitationEnergyPerWoundedNucleon;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetDofNuclearDestruction() {
|
|
return DofNuclearDestruction;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetPt2ofNuclearDestruction() {
|
|
return Pt2ofNuclearDestruction;
|
|
}
|
|
|
|
inline G4double G4FTFParameters::GetMaxPt2ofNuclearDestruction() {
|
|
return MaxPt2ofNuclearDestruction;
|
|
}
|
|
|
|
#endif
|
|
|