lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 10.0.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-10 11:51:14 +02:00
parent e2d2f9810a
commit 286caacf06
12421 changed files with 730077 additions and 502383 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/hadronic/models/parton_string/CMakeLists.txt
+1 -1
View File
@@ -7,7 +7,7 @@
#
# Generated on : 24/9/2010
#
# $Id: CMakeLists.txt,v 1.1 2010-09-29 19:04:26 bmorgan Exp $
# $Id: CMakeLists.txt 66892 2013-01-17 10:57:59Z gunter $
#
#------------------------------------------------------------------------------
source/processes/hadronic/models/parton_string/diffraction/CMakeLists.txt
+1 -1
View File
@@ -7,7 +7,7 @@
#
# Generated on : 24/9/2010
#
# $Id: CMakeLists.txt,v 1.1 2010-09-29 19:04:35 bmorgan Exp $
# $Id: CMakeLists.txt 66892 2013-01-17 10:57:59Z gunter $
#
#------------------------------------------------------------------------------
source/processes/hadronic/models/parton_string/diffraction/GNUmakefile
+1 -1
View File
@@ -1,4 +1,4 @@
# $Id: GNUmakefile,v 1.2 2003-10-08 15:44:10 hpw Exp $
# $Id: GNUmakefile 66892 2013-01-17 10:57:59Z gunter $
# -----------------------------------------------------------
# GNUmakefile for hadronic library. JPW, 2003.
# -----------------------------------------------------------
source/processes/hadronic/models/parton_string/diffraction/History
+80 -1
View File
@@ -1,4 +1,4 @@
$Id: History,v 1.34 2010-11-15 10:10:16 vuzhinsk Exp $
$Id: History 74627 2013-10-17 07:04:38Z gcosmo $
-------------------------------------------------------------------
==========================================================
@@ -15,6 +15,85 @@ code and to keep track of all tags.
* Please list in reverse chronological order (last date on top)
---------------------------------------------------------------
16-Oct-2013 A. Ribon (hadr-string-diff-V09-06-18)
- Fixed a trivial warning error of the previous tag.
16-Oct-2013 A. Ribon (hadr-string-diff-V09-06-17)
- First, minor improvement of the code: clean-up, indentation,
removal of tabs and consistent use of spaces.
Neither changes of the algorithms nor of the physics.
31-Aug-2013 V. Uzhinsky (hadr-string-diff-V09-06-16)
- Division by 0 is erased in FTF model (AdjustNucleons, cases 2 and 3)
07-Aug-2013 A. Ribon (hadr-string-diff-V09-06-15)
- Set Delta-isobar probability to 10%, as a compromise between better
agreement with thin-target data and smaller impact on hadronic shower
observables with respect to G4 9.6.ref06.
02-Jul-2013 A. Ribon (hadr-string-diff-V09-06-14)
- Replaced CLHEP::RandFlat with G4RandFlat in G4DiffractiveExcitation.cc.
13-June-2012 V. Uzhinsky (hadr-string-diff-V09-06-13)
- New parameterizations of FTF process cross sections are implemented.
25 % of Delta-isobar probability was returned.
A best description of exp. data on hP, hA interactions is reached.
Results of FTF become close to QGSM, especially for heavy targets.
02-May-2013 A. Ribon (hadr-string-diff-V09-06-12)
- For thread safety, replaced CLHEP::RandFlat with G4RandFlat in
G4DiffractiveExcitation.cc and G4FTFAnnihilation.cc.
21-Mar-2013 A. Ribon (hadr-string-diff-V09-06-11)
- Fixed warning message in G4DiffractiveHHScatterer.
14-Feb-2013 V. Uzhinsky (hadr-string-diff-V09-06-10)
- Division by 0 erased in G4FTFAnnihilation for DbarPb
if(Prel2 <= 0. ) is inserted.
8-Feb-2013 V. Uzhinsky (hadr-string-diff-V09-06-09)
- Division by 0 erased in G4FTFParameters.cc for PbarP
X pion diffraction # 0.
6-Feb-2013 A. Ribon (hadr-string-diff-V09-06-08)
- Close writing of debugging information in G4FTFParameters.cc
5-Feb-2013 V.Uzhinsky (hadr-string-diff-V09-06-07)
- Annihilation at rest is improved.
4-Feb-2013 V.Uzhinsky (hadr-string-diff-V09-06-06)
- Warning message of G4FTFmodel (line 155) is erased.
1-Feb-2013 V.Uzhinsky (hadr-string-diff-V09-06-05)
- Bug is fixed in double delition of projectile nucleus
30-Jan-2013 V.Uzhinsky (hadr-string-diff-V09-06-04)
- Bug is fixed in reggeon cascading
29-Jan-2013 V.Uzhinsky (hadr-string-diff-V09-06-03)
- New attempt to implement nucl-nucl interaction simulation
12-Jan-2013 V.Uzhinsky (hadr-string-diff-V09-06-02)
- New attempt to implement nucl-nucl interaction simulation
19-Dec-2012 V. Uzhinsky (hadr-string-diff-V09-06-01)
- Unneeded print-out was closed. Stopping of particles in AA-interaction
below 2 GeV/N was blocked. Energy-momentum conservation in
AA-interactions was recovered.
18-Dec-2012 V. Uzhinsky (hadr-string-diff-V09-06-00)
- An interface for a manipulation with nucleus-nucleus interactions was
improved. A low energy limit of FTF model is lowered. Adjust method was
essential extended. It is expected that there will not be problem with
high energy interactions. Problem can be with anti-nuclei.
21-Nov-2012 V. Uzhinsky (hadr-string-diff-V09-05-19)
- Bug fixing.
20-Nov-2012 V. Uzhinsky (hadr-string-diff-V09-05-18)
- An interface for a manipulation with nucleus-nucleus interactions was
introduced, especially for treating remnants of projectile nuclei.
27 September 2012, G.Cosmo
= Explicitly use inclusion of headers for system of units and physical
constants, in plan to remove implicit inclusion from globals.hh.
source/processes/hadronic/models/parton_string/diffraction/include/G4DiffractiveExcitation.hh
+30 -31
View File
@@ -24,59 +24,58 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4DiffractiveExcitation.hh 74627 2013-10-17 07:04:38Z gcosmo $
#ifndef G4DiffractiveExcitation_h
#define G4DiffractiveExcitation_h 1
// ------------------------------------------------------------
// GEANT 4 class header file
//
// ---------------- G4DiffractiveExcitation --------------
// by Gunter Folger, October 1998.
// diffractive Excitation used by strings models
// Take a projectile and a target
// excite the projectile and target
// Take a projectile and a target
// excite the projectile and target
// ------------------------------------------------------------
#include "globals.hh"
class G4VSplitableHadron;
class G4ExcitedString;
#include "G4FTFParameters.hh"
#include "G4ElasticHNScattering.hh" // Uzhi 3.09.09
#include "G4ThreeVector.hh"
class G4DiffractiveExcitation
{
class G4VSplitableHadron;
class G4ExcitedString;
class G4DiffractiveExcitation {
public:
G4DiffractiveExcitation();
virtual ~G4DiffractiveExcitation();
G4DiffractiveExcitation();
virtual ~G4DiffractiveExcitation();
virtual G4bool ExciteParticipants( G4VSplitableHadron* aPartner,
G4VSplitableHadron* bPartner,
G4FTFParameters* theParameters,
G4ElasticHNScattering* theElastic ) const;
virtual G4bool ExciteParticipants (G4VSplitableHadron *aPartner,
G4VSplitableHadron * bPartner,
G4FTFParameters *theParameters,
G4ElasticHNScattering *theElastic) const;
virtual void CreateStrings (G4VSplitableHadron * aHadron,
G4bool isProjectile,
G4ExcitedString * &FirstString,
G4ExcitedString * &SecondString,
G4FTFParameters *theParameters) const;
virtual void CreateStrings( G4VSplitableHadron* aHadron,
G4bool isProjectile,
G4ExcitedString*& FirstString,
G4ExcitedString*& SecondString,
G4FTFParameters* theParameters ) const;
private:
G4DiffractiveExcitation(const G4DiffractiveExcitation &right);
G4DiffractiveExcitation( const G4DiffractiveExcitation& right );
const G4DiffractiveExcitation& operator=( const G4DiffractiveExcitation& right );
int operator==( const G4DiffractiveExcitation& right ) const;
int operator!=( const G4DiffractiveExcitation& right ) const;
G4ThreeVector GaussianPt(G4double AveragePt2, G4double maxPtSquare) const;
G4double ChooseP(G4double Pmin, G4double Pmax) const;
G4double GetQuarkFractionOfKink(G4double zmin, G4double zmax) const;
void UnpackMeson( G4int IdPDG, G4int &Q1, G4int &Q2) const; // Uzhi 7.09.09
void UnpackBaryon(G4int IdPDG, G4int &Q1, G4int &Q2, G4int &Q3) const; // Uzhi 7.09.09
G4int NewNucleonId(G4int Q1, G4int Q2, G4int Q3) const; // Uzhi 7.09.09
const G4DiffractiveExcitation & operator=(const G4DiffractiveExcitation &right);
int operator==(const G4DiffractiveExcitation &right) const;
int operator!=(const G4DiffractiveExcitation &right) const;
G4ThreeVector GaussianPt( G4double AveragePt2, G4double maxPtSquare ) const;
G4double ChooseP( G4double Pmin, G4double Pmax ) const;
G4double GetQuarkFractionOfKink( G4double zmin, G4double zmax ) const;
void UnpackMeson( G4int IdPDG, G4int& Q1, G4int& Q2 ) const;
void UnpackBaryon( G4int IdPDG, G4int& Q1, G4int& Q2, G4int& Q3 ) const;
G4int NewNucleonId( G4int Q1, G4int Q2, G4int Q3 ) const;
};
source/processes/hadronic/models/parton_string/diffraction/include/G4DiffractiveHHScatterer.hh
+16 -24
View File
@@ -24,50 +24,42 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4DiffractiveHHScatterer.hh 74627 2013-10-17 07:04:38Z gcosmo $
#ifndef G4DiffractiveHHScatterer_h
#define G4DiffractiveHHScatterer_h 1
// ------------------------------------------------------------
// GEANT 4 class header file
//
// ---------------- G4DiffractiveExcitation --------------
// by Gunter Folger, October 1998.
// diffractive Excitation used by strings models
// Take a projectile and a target
// excite the projectile and target
// Take a projectile and a target
// excite the projectile and target
// ------------------------------------------------------------
#include "globals.hh"
class G4DiffractiveExcitation;
class G4LundStringFragmentation;
class G4KineticTrack;
#include "G4KineticTrackVector.hh"
#include "G4FTFParameters.hh"
#include "G4ExcitedString.hh"
class G4DiffractiveHHScatterer
{
public:
class G4DiffractiveExcitation;
class G4LundStringFragmentation;
class G4KineticTrack;
G4DiffractiveHHScatterer();
virtual ~G4DiffractiveHHScatterer();
// G4KineticTrackVector * Scatter(const G4KineticTrack & aTrack, const G4KineticTrack & bTrack);
class G4DiffractiveHHScatterer {
virtual void CreateStrings() const;
/*
(G4VSplitableHadron * aHadron,
G4bool isProjectile,
G4ExcitedString * FirstString,
G4ExcitedString * SecondString,
G4FTFParameters *theParameters) const;
*/
private:
public:
G4DiffractiveHHScatterer();
virtual ~G4DiffractiveHHScatterer();
virtual void CreateStrings() const;
private:
const G4DiffractiveExcitation* theExcitation;
G4LundStringFragmentation* theStringFragmentation;
const G4DiffractiveExcitation * theExcitation;
G4LundStringFragmentation * theStringFragmentation;
G4FTFParameters *theParameters;
};
#endif
source/processes/hadronic/models/parton_string/diffraction/include/G4DiffractiveSplitableHadron.hh
+23 -29
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4DiffractiveSplitableHadron.hh 74627 2013-10-17 07:04:38Z gcosmo $
// GEANT4 tag $Name: $
//
@@ -43,41 +43,35 @@
#include "G4Nucleon.hh"
#include "G4Parton.hh"
class G4DiffractiveSplitableHadron : public G4VSplitableHadron
{
public:
class G4DiffractiveSplitableHadron : public G4VSplitableHadron {
G4DiffractiveSplitableHadron();
G4DiffractiveSplitableHadron(const G4ReactionProduct & aPrimary);
G4DiffractiveSplitableHadron(const G4Nucleon & aNucleon);
G4DiffractiveSplitableHadron(const G4VKineticNucleon * aNucleon);
~G4DiffractiveSplitableHadron();
public:
G4DiffractiveSplitableHadron();
G4DiffractiveSplitableHadron( const G4ReactionProduct& aPrimary );
G4DiffractiveSplitableHadron( const G4Nucleon& aNucleon );
G4DiffractiveSplitableHadron( const G4VKineticNucleon* aNucleon );
~G4DiffractiveSplitableHadron();
private:
G4DiffractiveSplitableHadron(const G4DiffractiveSplitableHadron &);
G4DiffractiveSplitableHadron& operator=(const G4DiffractiveSplitableHadron &);
int operator==(const G4DiffractiveSplitableHadron &right) const;
int operator!=(const G4DiffractiveSplitableHadron &right) const;
void SplitUp();
G4Parton* GetNextParton() ;
G4Parton* GetNextAntiParton();
public:
void SplitUp();
G4Parton * GetNextParton() ;
G4Parton * GetNextAntiParton();
void SetFirstParton( G4int PDGcode );
void SetSecondParton( G4int PDGcode );
void SetFirstParton(G4int PDGcode); // Uzhi 24.11.10
void SetSecondParton(G4int PDGcode); // Uzhi 24.11.10
private:
G4DiffractiveSplitableHadron( const G4DiffractiveSplitableHadron& );
G4DiffractiveSplitableHadron& operator=( const G4DiffractiveSplitableHadron& );
int operator==( const G4DiffractiveSplitableHadron& right ) const;
int operator!=( const G4DiffractiveSplitableHadron& right ) const;
private:
G4int Diquark( G4int aquark, G4int bquark, G4int Spin ) const;
void ChooseStringEnds( G4int PDGcode, G4int* aEnd, G4int* bEnd ) const;
//implementation
G4int Diquark(G4int aquark,G4int bquark,G4int Spin) const; // to splitable hadron
void ChooseStringEnds(G4int PDGcode,G4int * aEnd, G4int * bEnd) const; // to splitable hadron
private:
G4Parton *Parton[2];
G4int PartonIndex;
G4Parton* Parton[2];
G4int PartonIndex;
};
#endif
#endif
source/processes/hadronic/models/parton_string/diffraction/include/G4ElasticHNScattering.hh
+18 -23
View File
@@ -24,48 +24,43 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4ElasticHNScattering.hh 74627 2013-10-17 07:04:38Z gcosmo $
#ifndef G4ElasticHNScattering_h
#define G4ElasticHNScattering_h 1
// ------------------------------------------------------------
// GEANT 4 class header file
//
// ---------------- G4ElasticHNScattering --------------
// by V. Uzhinsky, March 2008.
// elastic scattering used by Fritiof model
// Take a projectile and a target
// scatter the projectile and target
// Take a projectile and a target
// scatter the projectile and target
// ------------------------------------------------------------
#include "globals.hh"
class G4VSplitableHadron;
class G4ExcitedString;
#include "G4FTFParameters.hh"
#include "G4ThreeVector.hh"
class G4ElasticHNScattering
{
class G4VSplitableHadron;
class G4ExcitedString;
class G4ElasticHNScattering {
public:
G4ElasticHNScattering();
virtual ~G4ElasticHNScattering();
virtual G4bool ElasticScattering( G4VSplitableHadron* aPartner, G4VSplitableHadron* bPartner,
G4FTFParameters* theParameters ) const;
G4ElasticHNScattering();
virtual ~G4ElasticHNScattering();
virtual G4bool ElasticScattering (G4VSplitableHadron *aPartner,
G4VSplitableHadron * bPartner,
G4FTFParameters *theParameters) const;
private:
G4ElasticHNScattering(const G4ElasticHNScattering &right);
G4ThreeVector GaussianPt(G4double AveragePt2, G4double maxPtSquare) const;
const G4ElasticHNScattering & operator=(const G4ElasticHNScattering &right);
int operator==(const G4ElasticHNScattering &right) const;
int operator!=(const G4ElasticHNScattering &right) const;
G4ElasticHNScattering( const G4ElasticHNScattering& right );
G4ThreeVector GaussianPt( G4double AveragePt2, G4double maxPtSquare ) const;
const G4ElasticHNScattering& operator=( const G4ElasticHNScattering& right );
int operator==( const G4ElasticHNScattering& right ) const;
int operator!=( const G4ElasticHNScattering& right ) const;
};
source/processes/hadronic/models/parton_string/diffraction/include/G4FTFAnnihilation.hh
+22 -24
View File
@@ -24,51 +24,49 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4FTFAnnihilation.hh 74627 2013-10-17 07:04:38Z gcosmo $
#ifndef G4FTFAnnihilation_h
#define G4FTFAnnihilation_h 1
// ------------------------------------------------------------
// GEANT 4 class header file
//
// ---------------- G4FTFAnnihilation --------------
// by Vladimir Uzhinsky, November 2010.
// Annihilation used by Fritiof (FTF) model
// Takes a projectile and a target
// Produces strings (excited hadrons)
// Takes a projectile and a target
// Produces strings (excited hadrons)
// ------------------------------------------------------------
#include "globals.hh"
class G4VSplitableHadron;
class G4ExcitedString;
#include "G4FTFParameters.hh"
#include "G4ThreeVector.hh"
class G4FTFAnnihilation
{
class G4VSplitableHadron;
class G4ExcitedString;
class G4FTFAnnihilation {
public:
G4FTFAnnihilation();
virtual ~G4FTFAnnihilation();
G4FTFAnnihilation();
virtual ~G4FTFAnnihilation();
virtual G4bool Annihilate (G4VSplitableHadron *aPartner,
G4VSplitableHadron * bPartner,
G4VSplitableHadron *& AdditionalString,
G4FTFParameters *theParameters) const;
virtual G4bool Annihilate( G4VSplitableHadron* aPartner,
G4VSplitableHadron* bPartner,
G4VSplitableHadron*& AdditionalString,
G4FTFParameters* theParameters ) const;
private:
G4FTFAnnihilation( const G4FTFAnnihilation& right );
const G4FTFAnnihilation& operator=( const G4FTFAnnihilation& right );
int operator==( const G4FTFAnnihilation& right ) const;
int operator!=( const G4FTFAnnihilation& right ) const;
G4FTFAnnihilation(const G4FTFAnnihilation &right);
G4ThreeVector GaussianPt(G4double AveragePt2, G4double maxPtSquare) const;
G4double ChooseX(G4double Alpha, G4double Beta) const;
void UnpackBaryon(G4int IdPDG, G4int &Q1, G4int &Q2, G4int &Q3) const;
const G4FTFAnnihilation & operator=(const G4FTFAnnihilation &right);
int operator==(const G4FTFAnnihilation &right) const;
int operator!=(const G4FTFAnnihilation &right) const;
G4ThreeVector GaussianPt( G4double AveragePt2, G4double maxPtSquare ) const;
G4double ChooseX( G4double Alpha, G4double Beta ) const;
void UnpackBaryon( G4int IdPDG, G4int& Q1, G4int& Q2, G4int& Q3 ) const;
};
source/processes/hadronic/models/parton_string/diffraction/include/G4FTFModel.hh
+73 -57
View File
@@ -24,11 +24,11 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4FTFModel.hh 74627 2013-10-17 07:04:38Z gcosmo $
// GEANT4 tag $Name: $
//
// Class Description
// Final state production code for hadron inelastic scattering above 20 GeV
// Final state production code for hadron inelastic scattering above 3 GeV
// based on the modeling ansatz used in FRITIOF.
// To be used in your physics list in case you need this physics.
// In this case you want to register an object of this class with an object
@@ -46,81 +46,97 @@
// class implementing the excitation in the FTF Parton String Model
// ------------------------------------------------------------
#include "G4VPartonStringModel.hh"
class G4VSplitableHadron;
class G4ExcitedString;
#include "G4FTFParameters.hh"
#include "G4FTFParticipants.hh"
#include "G4ExcitedStringVector.hh"
#include "G4DiffractiveExcitation.hh"
#include "G4ElasticHNScattering.hh"
#include "G4FTFAnnihilation.hh"
#include "G4Proton.hh"
#include "G4Neutron.hh"
class G4FTFModel : public G4VPartonStringModel
{
class G4VSplitableHadron;
class G4ExcitedString;
class G4FTFModel : public G4VPartonStringModel {
public:
G4FTFModel(const G4String& modelName = "FTF");
//G4FTFModel(G4double , G4double , G4double );
//G4FTFModel(G4DiffractiveExcitation * anExcitation);
~G4FTFModel();
private:
G4FTFModel(const G4FTFModel &right);
const G4FTFModel & operator=(const G4FTFModel &right);
int operator==(const G4FTFModel &right) const;
int operator!=(const G4FTFModel &right) const;
public:
void Init(const G4Nucleus & aNucleus, const G4DynamicParticle & aProjectile);
G4ExcitedStringVector * GetStrings();
G4V3DNucleus * GetWoundedNucleus() const;
virtual void ModelDescription(std::ostream&) const;
G4FTFModel( const G4String& modelName = "FTF" );
~G4FTFModel();
protected:
private:
void StoreInvolvedNucleon();
void ReggeonCascade();
G4bool PutOnMassShell();
G4bool ExciteParticipants();
G4ExcitedStringVector * BuildStrings();
void GetResidualNucleus();
void AjustTargetNucleonForAnnihilation(G4VSplitableHadron *SelectedAntiBaryon,
G4VSplitableHadron *SelectedTargetNucleon);
G4ThreeVector GaussianPt(G4double AveragePt2, G4double maxPtSquare) const;
private:
void Init( const G4Nucleus& aNucleus, const G4DynamicParticle& aProjectile );
G4ExcitedStringVector* GetStrings();
G4V3DNucleus* GetWoundedNucleus() const;
G4V3DNucleus* GetTargetNucleus() const;
G4V3DNucleus* GetProjectileNucleus() const;
G4ReactionProduct theProjectile;
G4FTFParticipants theParticipants;
virtual void ModelDescription( std::ostream& ) const;
private:
G4FTFModel( const G4FTFModel& right );
const G4FTFModel& operator=( const G4FTFModel& right );
int operator==( const G4FTFModel& right ) const;
int operator!=( const G4FTFModel& right ) const;
void StoreInvolvedNucleon();
void ReggeonCascade();
G4bool PutOnMassShell();
G4bool ExciteParticipants();
G4ExcitedStringVector* BuildStrings();
void GetResiduals();
G4bool AdjustNucleons( G4VSplitableHadron* SelectedAntiBaryon,
G4Nucleon* ProjectileNucleon,
G4VSplitableHadron* SelectedTargetNucleon,
G4Nucleon* TargetNucleon,
G4bool Annihilation );
G4ThreeVector GaussianPt( G4double AveragePt2, G4double maxPtSquare ) const;
G4ReactionProduct theProjectile;
G4FTFParticipants theParticipants;
G4Nucleon * TheInvolvedNucleon[250];
G4int NumberOfInvolvedNucleon;
G4int NumberOfInvolvedTargetNucleon;
G4Nucleon* TheInvolvedNucleonsOfTarget[250];
G4int NumberOfInvolvedNucleonsOfTarget;
G4Nucleon * TheInvolvedNucleonOfProjectile[250];
G4int NumberOfInvolvedNucleonOfProjectile;
G4Nucleon* TheInvolvedNucleonsOfProjectile[250];
G4int NumberOfInvolvedNucleonsOfProjectile;
G4FTFParameters *theParameters;
G4DiffractiveExcitation * theExcitation;
G4ElasticHNScattering * theElastic;
G4FTFAnnihilation * theAnnihilation; // Uzhi 17.11.10
G4FTFParameters* theParameters;
G4DiffractiveExcitation* theExcitation;
G4ElasticHNScattering* theElastic;
G4FTFAnnihilation* theAnnihilation;
std::vector<G4VSplitableHadron *> theAdditionalString; // Uzhi 17.11.10
std::vector< G4VSplitableHadron* > theAdditionalString;
G4LorentzVector Residual4Momentum;
G4double ResidualExcitationEnergy;
G4double LowEnergyLimit;
G4bool HighEnergyInter;
G4LorentzVector ProjectileResidual4Momentum;
G4int ProjectileResidualMassNumber;
G4int ProjectileResidualCharge;
G4double ProjectileResidualExcitationEnergy;
G4LorentzVector TargetResidual4Momentum;
G4int TargetResidualMassNumber;
G4int TargetResidualCharge;
G4double TargetResidualExcitationEnergy;
};
// ------------------------------------------------------------
inline
G4V3DNucleus * G4FTFModel::GetWoundedNucleus() const
{
return theParticipants.GetWoundedNucleus();
inline G4V3DNucleus* G4FTFModel::GetWoundedNucleus() const {
return theParticipants.GetWoundedNucleus();
}
inline G4V3DNucleus* G4FTFModel::GetTargetNucleus() const {
return theParticipants.GetWoundedNucleus();
}
inline G4V3DNucleus* G4FTFModel::GetProjectileNucleus() const {
return theParticipants.GetProjectileNucleus();
}
#endif
source/processes/hadronic/models/parton_string/diffraction/include/G4FTFParameters.hh
+364 -282
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4FTFParameters.hh 74627 2013-10-17 07:04:38Z gcosmo $
// GEANT4 tag $Name: $
//
#ifndef G4FTFParameters_h
@@ -36,367 +36,449 @@
#include "G4Neutron.hh"
#include "G4ChipsComponentXS.hh"
class G4FTFParameters
{
class G4FTFParameters {
public:
G4FTFParameters(const G4ParticleDefinition * , G4int theA,
G4int theZ,
G4double s);
// G4FTFParameters(const G4ParticleDefinition * , G4double theA,
// G4double theZ,
// G4double s);
G4FTFParameters( const G4ParticleDefinition* , G4int theA, G4int theZ, G4double s );
~G4FTFParameters();
~G4FTFParameters();
// 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 );
// --------- 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); // Uzhi 18.11.10
void SetSlope( const G4double Slope );
void SetGamma0( const G4double Gamma0 );
G4double GammaElastic( const G4double impactsquare );
void SetRadiusOfHNinteractions2(const G4double Radius2);
void SetSlope(const G4double Slope);
void SetGamma0(const G4double Gamma0);
// Set parameters of elastic scattering
void SetAvaragePt2ofElasticScattering( const G4double aPt2 );
G4double GammaElastic(const G4double impactsquare)
{return (FTFGamma0 * std::exp(-FTFSlope * impactsquare));};
// 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 );
// --------- Set parameters of elastic scattering --------------------
void SetAvaragePt2ofElasticScattering(const G4double aPt2);
void SetDeltaProbAtQuarkExchange( const G4double aValue );
void SetProbOfSameQuarkExchange( const G4double aValue );
// --------- Set parameters of excitations ---------------------------
void SetMagQuarkExchange(const G4double aValue);
void SetSlopeQuarkExchange(const G4double aValue);
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 SetProjMinDiffMass(const G4double aValue);
void SetProjMinNonDiffMass(const G4double aValue);
void SetProbabilityOfProjDiff(const G4double aValue);
void SetTarMinDiffMass( const G4double aValue );
void SetTarMinNonDiffMass( const G4double aValue );
void SetProbabilityOfTarDiff( 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 );
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 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 );
// --------- Set parameters of nuclear destruction--------------------
void SetMaxNumberOfCollisions(const G4double aValue, const G4double bValue);
void SetProbOfInteraction(const G4double aValue);
void SetCofNuclearDestruction( const G4double aValue );
void SetR2ofNuclearDestruction( const G4double aValue );
void SetCofNuclearDestruction(const G4double aValue);
void SetR2ofNuclearDestruction(const G4double aValue);
void SetExcitationEnergyPerWoundedNucleon( const G4double aValue );
void SetExcitationEnergyPerWoundedNucleon(const G4double aValue);
void SetDofNuclearDestruction( const G4double aValue );
void SetPt2ofNuclearDestruction( const G4double aValue );
void SetMaxPt2ofNuclearDestruction( 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();
//--------------------------------------------------------------------
// --------- 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();
G4double GetProbabilityOfInteraction(const G4double impactsquare);
G4double GetInelasticProbability(const G4double impactsquare);
G4double GetProbabilityOfElasticScatt();
G4double GetSlope();
G4double GetProbabilityOfAnnihilation(); // Uzhi 18.11.10
// Get parameters of elastic scattering
G4double GetAvaragePt2ofElasticScattering();
// --------- Get parameters of elastic scattering --------------------
G4double GetAvaragePt2ofElasticScattering();
// Get parameters of excitations
G4double GetProcProb( const G4int ProcN, const G4double y );
// --------- Get parameters of excitations ---------------------------
G4double GetMagQuarkExchange();
G4double GetSlopeQuarkExchange();
G4double GetDeltaProbAtQuarkExchange();
G4double GetProbOfSameQuarkExchange();
G4double GetDeltaProbAtQuarkExchange();
G4double GetProbOfSameQuarkExchange();
G4double GetProjMinDiffMass();
G4double GetProjMinNonDiffMass();
G4double GetProbabilityOfProjDiff();
G4double GetProjMinDiffMass();
G4double GetProjMinNonDiffMass();
G4double GetTarMinDiffMass();
G4double GetTarMinNonDiffMass();
G4double GetProbabilityOfTarDiff();
G4double GetTarMinDiffMass();
G4double GetTarMinNonDiffMass();
G4double GetAveragePt2();
G4double GetProbLogDistr();
G4double GetAveragePt2();
G4double GetProbLogDistr();
// --------- Get parameters of a string kink --------------------------------
G4double GetPt2Kink();
std::vector<G4double> GetQuarkProbabilitiesAtGluonSplitUp();
// Get parameters of a string kink
G4double GetPt2Kink();
std::vector< G4double > GetQuarkProbabilitiesAtGluonSplitUp();
// --------- Get parameters of nuclear destruction---------------------
G4double GetMaxNumberOfCollisions();
G4double GetProbOfInteraction();
// Get parameters of nuclear destruction
G4double GetMaxNumberOfCollisions();
G4double GetProbOfInteraction();
G4double GetCofNuclearDestruction();
G4double GetR2ofNuclearDestruction();
G4double GetCofNuclearDestruction();
G4double GetR2ofNuclearDestruction();
G4double GetExcitationEnergyPerWoundedNucleon();
G4double GetExcitationEnergyPerWoundedNucleon();
G4double GetDofNuclearDestruction();
G4double GetPt2ofNuclearDestruction();
G4double GetMaxPt2ofNuclearDestruction();
G4double GetDofNuclearDestruction();
G4double GetPt2ofNuclearDestruction();
G4double GetMaxPt2ofNuclearDestruction();
// private:
//private:
G4FTFParameters();
G4FTFParameters();
// Initial energy of hN interactions
G4double FTFhNcmsEnergy; // Initial hN CMS energy
// ------------ Initial energy of hN interactions --------------------
G4double FTFhNcmsEnergy; // Initial hN CMS energy
// hN cross section manager
G4ChipsComponentXS* FTFxsManager;
// ------------ hN cross section manager -----------------------------
G4ChipsComponentXS* FTFxsManager;
// ------------ 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 // Uzhi 18.11.10
G4double ProbabilityOfAnnihilation; // Xannih/Xinelast // Uzhi 18.11.10
G4double ProbabilityOfElasticScatt; // Xel/Xtot
G4double RadiusOfHNinteractions2; // Xtot/pi, in fn^2
G4double FTFSlope; // in fm^-1
G4double AvaragePt2ofElasticScattering; // in MeV^2
G4double FTFGamma0;
// 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 MagQuarkExchange;
G4double SlopeQuarkExchange;
G4double DeltaProbAtQuarkExchange;
G4double ProbOfSameQuarkExchange;
// Parameters of excitations
G4double ProcParams[4][7];
G4double ProjMinDiffMass;
G4double ProjMinNonDiffMass;
G4double ProbabilityOfProjDiff;
G4double DeltaProbAtQuarkExchange;
G4double ProbOfSameQuarkExchange;
G4double TarMinDiffMass;
G4double TarMinNonDiffMass;
G4double ProbabilityOfTarDiff;
G4double ProjMinDiffMass;
G4double ProjMinNonDiffMass;
G4double AveragePt2;
G4double ProbLogDistr;
G4double TarMinDiffMass;
G4double TarMinNonDiffMass;
// ---------- Parameters of kink -------------------------------------
G4double Pt2kink;
std::vector<G4double> QuarkProbabilitiesAtGluonSplitUp;
G4double AveragePt2;
G4double ProbLogDistr;
// --------- Parameters of nuclear destruction------------------------
G4double MaxNumberOfCollisions;
G4double ProbOfInelInteraction;
// Parameters of kink
G4double Pt2kink;
std::vector< G4double > QuarkProbabilitiesAtGluonSplitUp;
G4double CofNuclearDestruction; // Cnd of nuclear destruction
G4double R2ofNuclearDestruction; // R2nd
// Parameters of nuclear destruction
G4double MaxNumberOfCollisions;
G4double ProbOfInelInteraction;
G4double ExcitationEnergyPerWoundedNucleon;
G4double CofNuclearDestruction; // Cnd of nuclear destruction
G4double R2ofNuclearDestruction; // R2nd
G4double DofNuclearDestruction; // D for momentum sampling
G4double Pt2ofNuclearDestruction; // Pt2
G4double MaxPt2ofNuclearDestruction; // Max Pt2
G4double ExcitationEnergyPerWoundedNucleon;
G4double DofNuclearDestruction; // D for momentum sampling
G4double Pt2ofNuclearDestruction; // Pt2
G4double MaxPt2ofNuclearDestruction; // Max Pt2
// G4-MT changes
private:
static G4ThreadLocal bool chipsComponentXSisInitialized;
static G4ThreadLocal G4ChipsComponentXS* chipsComponentXSinstance;
};
// --------------------------------------------------------------------
inline void G4FTFParameters::SethNcmsEnergy(const G4double S)
{FTFhNcmsEnergy = S;}
// --------- Set geometrical parameteres ------------------------------
inline void G4FTFParameters::SetTotalCrossSection(const G4double Xtotal)
{FTFXtotal = Xtotal;}
inline G4double G4FTFParameters::GammaElastic( const G4double impactsquare ) {
return ( FTFGamma0 * std::exp( -FTFSlope * impactsquare ) );
}
inline void G4FTFParameters::SetElastisCrossSection(const G4double Xelastic)
{FTFXelastic = Xelastic;}
inline void G4FTFParameters::SethNcmsEnergy( const G4double S ) {
FTFhNcmsEnergy = S;
}
inline void G4FTFParameters::SetInelasticCrossSection(const G4double Xinelastic)
{FTFXinelastic = Xinelastic;}
// Set geometrical parameteres
inline void G4FTFParameters::SetProbabilityOfElasticScatt(const G4double Xtotal,
const G4double Xelastic)
{
if(Xtotal==0.) {ProbabilityOfElasticScatt = 0.;}
else {ProbabilityOfElasticScatt = Xelastic/Xtotal;};
}
inline void G4FTFParameters::SetTotalCrossSection( const G4double Xtotal ) {
FTFXtotal = Xtotal;
}
inline void G4FTFParameters::SetProbabilityOfElasticScatt(const G4double aValue)
{ProbabilityOfElasticScatt = aValue;}
inline void G4FTFParameters::SetElastisCrossSection( const G4double Xelastic ) {
FTFXelastic = Xelastic;
}
inline void G4FTFParameters::SetProbabilityOfAnnihilation(const G4double aValue)
{ProbabilityOfAnnihilation = aValue;} // Uzhi 18.11.10
inline void G4FTFParameters::SetInelasticCrossSection( const G4double Xinelastic ) {
FTFXinelastic = Xinelastic;
}
inline void G4FTFParameters::SetRadiusOfHNinteractions2(const G4double Radius2)
{RadiusOfHNinteractions2 = Radius2;}
inline void G4FTFParameters::SetProbabilityOfElasticScatt( const G4double Xtotal,
const G4double Xelastic ) {
if ( Xtotal == 0.0 ) {
ProbabilityOfElasticScatt = 0.0;
} else {
ProbabilityOfElasticScatt = Xelastic / Xtotal;
}
}
inline void G4FTFParameters::SetSlope(const G4double Slope)
{FTFSlope = 12.84/Slope;} // Slope is in GeV^-2, FTFSlope in fm^-2
inline void G4FTFParameters::SetProbabilityOfElasticScatt( const G4double aValue ) {
ProbabilityOfElasticScatt = aValue;
}
inline void G4FTFParameters::SetGamma0(const G4double Gamma0)
{FTFGamma0 = Gamma0;}
inline void G4FTFParameters::SetProbabilityOfAnnihilation( const G4double aValue ) {
ProbabilityOfAnnihilation = aValue;
}
// --------- Set parameters of elastic scattering ---------------------
inline void G4FTFParameters::SetAvaragePt2ofElasticScattering(const G4double aPt2)
{
AvaragePt2ofElasticScattering = aPt2;}
inline void G4FTFParameters::SetRadiusOfHNinteractions2( const G4double Radius2 ) {
RadiusOfHNinteractions2 = Radius2;
}
// --------- Set parameters of excitations ----------------------------
inline void G4FTFParameters::SetMagQuarkExchange(const G4double aValue)
{MagQuarkExchange = aValue;}
inline void G4FTFParameters::SetSlopeQuarkExchange(const G4double aValue)
{SlopeQuarkExchange = aValue;}
inline void G4FTFParameters::SetDeltaProbAtQuarkExchange(const G4double aValue)
{DeltaProbAtQuarkExchange = aValue;}
inline void G4FTFParameters::SetProbOfSameQuarkExchange(const G4double aValue)
{ProbOfSameQuarkExchange = aValue;}
inline void G4FTFParameters::SetSlope( const G4double Slope ) {
FTFSlope = 12.84 / Slope; // Slope is in GeV^-2, FTFSlope in fm^-2
}
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::SetProbabilityOfProjDiff(const G4double aValue)
{ProbabilityOfProjDiff = aValue;}
inline void G4FTFParameters::SetGamma0( const G4double Gamma0 ) {
FTFGamma0 = Gamma0;
}
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::SetProbabilityOfTarDiff(const G4double aValue)
{ProbabilityOfTarDiff = aValue;}
// Set parameters of elastic scattering
inline void G4FTFParameters::SetAvaragePt2ofElasticScattering( const G4double aPt2 ) {
AvaragePt2ofElasticScattering = aPt2;
}
inline void G4FTFParameters::SetAveragePt2(const G4double aValue)
{AveragePt2 = aValue*CLHEP::GeV*CLHEP::GeV;}
// Set parameters of excitations
inline void G4FTFParameters::SetProbLogDistr(const G4double aValue)
{ProbLogDistr = aValue;}
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;
}
// --------- Set parameters of a string kink --------------------------------
inline void G4FTFParameters::SetPt2Kink(const G4double aValue)
{Pt2kink = aValue;}
inline void G4FTFParameters::SetDeltaProbAtQuarkExchange( const G4double aValue ) {
DeltaProbAtQuarkExchange = 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);
}
inline void G4FTFParameters::SetProbOfSameQuarkExchange( const G4double aValue ) {
ProbOfSameQuarkExchange = aValue;
}
// --------- Set parameters of nuclear destruction--------------------
inline void G4FTFParameters::SetMaxNumberOfCollisions(const G4double Plab,
const G4double Pbound)
{
if(Plab > Pbound)
{
MaxNumberOfCollisions = Plab/Pbound;
SetProbOfInteraction(-1.);
} else
{
// MaxNumberOfCollisions = -1.;
// SetProbOfInteraction(std::exp(0.25*(Plab-Pbound)));
MaxNumberOfCollisions = 1;
SetProbOfInteraction(-1.);
}
}
inline void G4FTFParameters::SetProbOfInteraction(const G4double aValue)
{ProbOfInelInteraction = aValue;}
inline void G4FTFParameters::SetProjMinDiffMass( const G4double aValue ) {
ProjMinDiffMass = aValue*CLHEP::GeV;
}
inline void G4FTFParameters::SetCofNuclearDestruction(const G4double aValue)
{CofNuclearDestruction = aValue;}
inline void G4FTFParameters::SetR2ofNuclearDestruction(const G4double aValue)
{R2ofNuclearDestruction = aValue;}
inline void G4FTFParameters::SetProjMinNonDiffMass( const G4double aValue ) {
ProjMinNonDiffMass = aValue*CLHEP::GeV;
}
inline void G4FTFParameters::SetExcitationEnergyPerWoundedNucleon(const G4double aValue)
{ExcitationEnergyPerWoundedNucleon = aValue;}
inline void G4FTFParameters::SetTarMinDiffMass( const G4double aValue ) {
TarMinDiffMass = aValue*CLHEP::GeV;
}
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;}
inline void G4FTFParameters::SetTarMinNonDiffMass( const G4double aValue ) {
TarMinNonDiffMass = aValue*CLHEP::GeV;
}
// --------- Get geometrical parameteres ------------------------------
inline G4double G4FTFParameters::GetTotalCrossSection() {return FTFXtotal;}
inline G4double G4FTFParameters::GetElasticCrossSection() {return FTFXelastic;}
inline G4double G4FTFParameters::GetInelasticCrossSection() {return FTFXinelastic;}
inline void G4FTFParameters::SetAveragePt2( const G4double aValue ) {
AveragePt2 = aValue*CLHEP::GeV*CLHEP::GeV;
}
inline G4double G4FTFParameters::GetSlope() {return FTFSlope;}
inline void G4FTFParameters::SetProbLogDistr( const G4double aValue ) {
ProbLogDistr = aValue;
}
inline G4double G4FTFParameters::GetProbabilityOfInteraction(const G4double impactsquare)
{
if(RadiusOfHNinteractions2 > impactsquare) {return 1.;}
else {return 0.;}
}
// Set parameters of a string kink
inline G4double G4FTFParameters::GetProbabilityOfElasticScatt()
{return ProbabilityOfElasticScatt;}
inline void G4FTFParameters::SetPt2Kink( const G4double aValue ) {
Pt2kink = aValue;
}
inline G4double G4FTFParameters::GetInelasticProbability( const G4double impactsquare)
{
G4double Gamma = GammaElastic(impactsquare);
return 2 * Gamma - Gamma *Gamma;
}
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 );
}
inline G4double G4FTFParameters::GetProbabilityOfAnnihilation()
{return ProbabilityOfAnnihilation;}
// Uzhi 18.11.10
// 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( std::exp( 0.25*(Plab-Pbound) ) );
MaxNumberOfCollisions = 1;
SetProbOfInteraction( -1.0 );
}
}
// --------- Get parameters of elastic scattering ---------------------
inline G4double G4FTFParameters::GetAvaragePt2ofElasticScattering()
{return AvaragePt2ofElasticScattering;}
inline void G4FTFParameters::SetProbOfInteraction( const G4double aValue ) {
ProbOfInelInteraction = aValue;
}
// --------- Get parameters of excitations ---------------------------
inline G4double G4FTFParameters::GetMagQuarkExchange() {return MagQuarkExchange;}
inline G4double G4FTFParameters::GetSlopeQuarkExchange() {return SlopeQuarkExchange;}
inline G4double G4FTFParameters::GetDeltaProbAtQuarkExchange(){return
DeltaProbAtQuarkExchange;}
inline G4double G4FTFParameters::GetProbOfSameQuarkExchange(){return ProbOfSameQuarkExchange;}
inline void G4FTFParameters::SetCofNuclearDestruction( const G4double aValue ) {
CofNuclearDestruction = aValue;
}
inline G4double G4FTFParameters::GetProjMinDiffMass() {return ProjMinDiffMass;}
inline G4double G4FTFParameters::GetProjMinNonDiffMass() {return ProjMinNonDiffMass;}
inline G4double G4FTFParameters::GetProbabilityOfProjDiff() {return ProbabilityOfProjDiff;}
inline void G4FTFParameters::SetR2ofNuclearDestruction( const G4double aValue ) {
R2ofNuclearDestruction = aValue;
}
inline G4double G4FTFParameters::GetTarMinDiffMass() {return TarMinDiffMass;}
inline G4double G4FTFParameters::GetTarMinNonDiffMass() {return TarMinNonDiffMass;}
inline G4double G4FTFParameters::GetProbabilityOfTarDiff() {return ProbabilityOfTarDiff;}
inline void G4FTFParameters::SetExcitationEnergyPerWoundedNucleon( const G4double aValue ) {
ExcitationEnergyPerWoundedNucleon = aValue;
}
inline G4double G4FTFParameters::GetAveragePt2() {return AveragePt2;}
inline G4double G4FTFParameters::GetProbLogDistr() {return ProbLogDistr;}
inline void G4FTFParameters::SetDofNuclearDestruction( const G4double aValue ) {
DofNuclearDestruction = aValue;
}
// --------- Get parameters of a string kink --------------------------
inline G4double G4FTFParameters::GetPt2Kink() {return Pt2kink;}
inline std::vector<G4double>
G4FTFParameters::GetQuarkProbabilitiesAtGluonSplitUp()
{return QuarkProbabilitiesAtGluonSplitUp;}
inline void G4FTFParameters::SetPt2ofNuclearDestruction( const G4double aValue ) {
Pt2ofNuclearDestruction = aValue;
}
// --------- Get parameters of nuclear destruction---------------------
inline G4double G4FTFParameters::GetMaxNumberOfCollisions(){return MaxNumberOfCollisions;}
inline G4double G4FTFParameters::GetProbOfInteraction() {return ProbOfInelInteraction;}
inline void G4FTFParameters::SetMaxPt2ofNuclearDestruction( const G4double aValue ) {
MaxPt2ofNuclearDestruction = aValue;
}
inline G4double G4FTFParameters::GetCofNuclearDestruction(){return CofNuclearDestruction;}
inline G4double G4FTFParameters::GetR2ofNuclearDestruction(){return R2ofNuclearDestruction;}
// Get geometrical parameteres
inline G4double G4FTFParameters::GetTotalCrossSection() {
return FTFXtotal;
}
inline G4double G4FTFParameters::GetExcitationEnergyPerWoundedNucleon()
{return ExcitationEnergyPerWoundedNucleon;}
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::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::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;
}
inline G4double G4FTFParameters::GetDofNuclearDestruction()
{return DofNuclearDestruction;}
inline G4double G4FTFParameters::GetPt2ofNuclearDestruction(){return Pt2ofNuclearDestruction;}
inline G4double G4FTFParameters::GetMaxPt2ofNuclearDestruction()
{return MaxPt2ofNuclearDestruction;}
#endif
source/processes/hadronic/models/parton_string/diffraction/include/G4FTFParticipants.hh
+27 -45
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4FTFParticipants.hh 74627 2013-10-17 07:04:38Z gcosmo $
//
#ifndef G4FTFParticipants_h
@@ -47,61 +47,43 @@
#include "G4ReactionProduct.hh"
#include "G4InteractionContent.hh"
class G4FTFParticipants : public G4VParticipants
{
class G4FTFParticipants : public G4VParticipants {
public:
G4FTFParticipants();
const G4FTFParticipants & operator=(const G4FTFParticipants &right);
~G4FTFParticipants();
G4FTFParticipants();
const G4FTFParticipants& operator=( const G4FTFParticipants& right );
~G4FTFParticipants();
int operator==( const G4FTFParticipants& right ) const;
int operator!=( const G4FTFParticipants& right ) const;
int operator==(const G4FTFParticipants &right) const;
int operator!=(const G4FTFParticipants &right) const;
//---------------------------------------------------
void InitProjectileNucleus(G4int theZ, G4int theA);
void SetProjectileNucleus(G4V3DNucleus * aNucleus);
G4V3DNucleus * GetProjectileNucleus();
//---------------------------------------------------
void GetList(const G4ReactionProduct &thePrimary,
G4FTFParameters *theParameters);
void GetList( const G4ReactionProduct& thePrimary, G4FTFParameters* theParameters );
void StartLoop();
G4bool Next();
void SortInteractionsIncT();
void ShiftInteractionTime();
G4InteractionContent& GetInteraction();
std::vector< G4InteractionContent* > theInteractions;
void StartLoop();
G4bool Next();
//Vova const G4InteractionContent & GetInteraction() const;
G4InteractionContent & GetInteraction();
std::vector<G4InteractionContent *> theInteractions;
G4V3DNucleus *theProjectileNucleus;
private:
//A.R. 25-Jul-2012 Coverity fix : copy constructor becomes private.
G4FTFParticipants(const G4FTFParticipants &right);
// std::vector<G4InteractionContent *> theInteractions;
G4int currentInteraction;
G4FTFParticipants( const G4FTFParticipants& right );
G4int currentInteraction;
};
inline
void G4FTFParticipants::StartLoop()
{
currentInteraction=-1;
}
inline
G4bool G4FTFParticipants::Next()
{
return ++currentInteraction < static_cast<G4int>(theInteractions.size());
inline void G4FTFParticipants::StartLoop() {
currentInteraction = -1;
}
//inline
//const G4InteractionContent & G4FTFParticipants::GetInteraction() const
inline
G4InteractionContent & G4FTFParticipants::GetInteraction()
{
return *theInteractions[currentInteraction];
inline G4bool G4FTFParticipants::Next() {
return ++currentInteraction < static_cast< G4int >( theInteractions.size() );
}
inline G4InteractionContent& G4FTFParticipants::GetInteraction() {
return *theInteractions[ currentInteraction ];
}
#endif
source/processes/hadronic/models/parton_string/diffraction/sources.cmake
+1 -1
View File
@@ -11,7 +11,7 @@
#
# Generated on : 24/9/2010
#
# $Id: sources.cmake,v 1.2 2010-12-13 12:11:08 bmorgan Exp $
# $Id: sources.cmake 66892 2013-01-17 10:57:59Z gunter $
#
#------------------------------------------------------------------------------
source/processes/hadronic/models/parton_string/diffraction/src/G4DiffractiveExcitation.cc
+1285 -1422
View File
File diff suppressed because it is too large Load Diff
source/processes/hadronic/models/parton_string/diffraction/src/G4DiffractiveHHScatterer.cc
+12 -54
View File
@@ -23,71 +23,29 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#include "G4DiffractiveHHScatterer.hh"
#include "G4DiffractiveExcitation.hh"
#include "G4ExcitedString.hh"
#include "G4LundStringFragmentation.hh"
#include "G4KineticTrack.hh"
#include "G4DiffractiveSplitableHadron.hh"
#include "G4FTFParameters.hh" // Uzhi 21.04.08
#include "G4FTFParameters.hh"
G4DiffractiveHHScatterer::G4DiffractiveHHScatterer()
:
theExcitation(new G4DiffractiveExcitation()),
theStringFragmentation(new G4LundStringFragmentation())
//============================================================================
G4DiffractiveHHScatterer::G4DiffractiveHHScatterer() :
theExcitation( new G4DiffractiveExcitation() ),
theStringFragmentation( new G4LundStringFragmentation() )
{}
G4DiffractiveHHScatterer::~G4DiffractiveHHScatterer()
{}
void G4DiffractiveHHScatterer::CreateStrings()
/*
G4VSplitableHadron * aHadron,
G4bool isProjectile,
G4ExcitedString * FirstString,
G4ExcitedString * SecondString,
G4FTFParameters *theParameters)
*/
const
//============================================================================
{}
G4DiffractiveHHScatterer::~G4DiffractiveHHScatterer() {}
/* -------------------------------------------------------------------
G4KineticTrackVector * G4DiffractiveHHScatterer::
Scatter(const G4KineticTrack & aTrack, const G4KineticTrack & bTrack)
{
G4KineticTrackVector * result = new G4KineticTrackVector();
G4DiffractiveSplitableHadron aHadron(& aTrack);
G4DiffractiveSplitableHadron bHadron(& bTrack);
theParameters = new G4FTFParameters(aHadron.GetDefinition(), // -------- Uzhi 21.04.08
1.,1., 100.);
//s);// ------------------------- Uzhi 21.04.08
if ( ! theExcitation->ExciteParticipants(& aHadron,
& bHadron,
theParameters)) // -------- Uzhi 21.04.08
{
return NULL;
}
G4ExcitedString * string;
G4KineticTrackVector * fragments=NULL;
//============================================================================
string = theExcitation->String(& aHadron, true); // Projectile
fragments=theStringFragmentation->FragmentString(*string);
for (unsigned int aFragment=0; aFragment < fragments->size(); aFragment++)
{
result->push_back(fragments->operator[](aFragment));
}
string = theExcitation->String(& bHadron, false); // Target
fragments=theStringFragmentation->FragmentString(*string);
for (unsigned int bFragment=0; bFragment < fragments->size(); bFragment++)
{
result->push_back(fragments->operator[](bFragment));
}
return result;
}
*/
void G4DiffractiveHHScatterer::CreateStrings() const {}
source/processes/hadronic/models/parton_string/diffraction/src/G4DiffractiveSplitableHadron.cc
+156 -163
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4DiffractiveSplitableHadron.cc 74627 2013-10-17 07:04:38Z gcosmo $
// GEANT4 tag $Name: $
//
@@ -41,185 +41,178 @@
#include "G4ParticleDefinition.hh"
#include "Randomize.hh"
G4DiffractiveSplitableHadron::G4DiffractiveSplitableHadron()
{
PartonIndex=-1;
Parton[0] = new G4Parton(1);
Parton[1] = new G4Parton(-1);
}
//============================================================================
G4DiffractiveSplitableHadron::G4DiffractiveSplitableHadron(const G4ReactionProduct & aPrimary)
: G4VSplitableHadron(aPrimary)
{
PartonIndex=-2;
Parton[0]=NULL;
}
G4DiffractiveSplitableHadron::G4DiffractiveSplitableHadron(const G4Nucleon & aNucleon)
: G4VSplitableHadron(aNucleon)
{
PartonIndex=-2;
Parton[0]=NULL;
}
G4DiffractiveSplitableHadron::G4DiffractiveSplitableHadron(const G4VKineticNucleon * aNucleon)
: G4VSplitableHadron(aNucleon)
{
PartonIndex=-2;
Parton[0]=NULL;
}
G4DiffractiveSplitableHadron::~G4DiffractiveSplitableHadron()
{
//G4cout<<"Destruct G4DiffractiveSplitableHadron"<<Parton[0]<<" "<<Parton[1]<<G4endl;
// if(Parton[0] != NULL){delete Parton[0]; delete Parton[1];}
G4DiffractiveSplitableHadron::G4DiffractiveSplitableHadron() {
PartonIndex = -1;
Parton[0] = new G4Parton( 1 );
Parton[1] = new G4Parton(-1 );
}
void G4DiffractiveSplitableHadron::SplitUp()
//============================================================================
G4DiffractiveSplitableHadron::G4DiffractiveSplitableHadron( const G4ReactionProduct& aPrimary ) :
G4VSplitableHadron( aPrimary )
{
//G4cout<<"SplitUp() IsSplit() Parton[0] "<<IsSplit()<<" "<<Parton[0]<<G4endl;
if (IsSplit()) return;
PartonIndex = -2;
Parton[0] = NULL;
}
//============================================================================
G4DiffractiveSplitableHadron::G4DiffractiveSplitableHadron( const G4Nucleon& aNucleon ) :
G4VSplitableHadron( aNucleon )
{
PartonIndex = -2;
Parton[0] = NULL;
}
//============================================================================
G4DiffractiveSplitableHadron::G4DiffractiveSplitableHadron( const G4VKineticNucleon* aNucleon ) :
G4VSplitableHadron( aNucleon )
{
PartonIndex = -2;
Parton[0] = NULL;
}
//============================================================================
G4DiffractiveSplitableHadron::~G4DiffractiveSplitableHadron() {
//G4cout << "Destruct G4DiffractiveSplitableHadron" << Parton[0] << " " << Parton[1] << G4endl;
//if ( Parton[0] != NULL ) { delete Parton[0]; delete Parton[1]; }
}
//============================================================================
void G4DiffractiveSplitableHadron::SplitUp() {
//G4cout << "SplitUp() IsSplit() Parton[0] " << IsSplit() << " " << Parton[0] << G4endl;
if ( IsSplit() ) return;
Splitting();
// Split once only...
if (Parton[0] != NULL) return;
// Split once only...
if ( Parton[0] != NULL ) return;
// flavours of quark ends
G4int PDGcode=GetDefinition()->GetPDGEncoding();
// flavours of quark ends
G4int PDGcode = GetDefinition()->GetPDGEncoding();
G4int stringStart, stringEnd;
ChooseStringEnds( PDGcode, &stringStart, &stringEnd );
G4int stringStart, stringEnd;
ChooseStringEnds(PDGcode, &stringStart,&stringEnd);
Parton[0] = new G4Parton(stringStart);
Parton[1] = new G4Parton(stringEnd);
PartonIndex=-1;
Parton[0] = new G4Parton( stringStart );
Parton[1] = new G4Parton( stringEnd );
PartonIndex = -1;
}
G4Parton * G4DiffractiveSplitableHadron::GetNextParton()
{
++PartonIndex;
if ( PartonIndex > 1 || PartonIndex < 0 ) return NULL;
G4int PartonInd(PartonIndex); // Vova
if(PartonIndex == 1) PartonIndex=-1; // Vova
return Parton[PartonInd];
// return Parton[PartonIndex];
//============================================================================
G4Parton* G4DiffractiveSplitableHadron::GetNextParton() {
++PartonIndex;
if ( PartonIndex > 1 || PartonIndex < 0 ) return NULL;
G4int PartonInd( PartonIndex );
if ( PartonIndex == 1 ) PartonIndex = -1;
return Parton[ PartonInd ];
}
G4Parton * G4DiffractiveSplitableHadron::GetNextAntiParton()
{
++PartonIndex; // Uzhi 22.11.10
if ( PartonIndex > 1 || PartonIndex < 0 ) return NULL;
G4int PartonInd(PartonIndex);
if(PartonIndex == 1) PartonIndex=-1;
return Parton[PartonInd];
// return NULL; // to be looked at @@
//============================================================================
G4Parton* G4DiffractiveSplitableHadron::GetNextAntiParton() {
++PartonIndex;
if ( PartonIndex > 1 || PartonIndex < 0 ) return NULL;
G4int PartonInd( PartonIndex );
if ( PartonIndex == 1 ) PartonIndex = -1;
return Parton[ PartonInd ];
}
void G4DiffractiveSplitableHadron::SetFirstParton(G4int PDGcode)// Uzhi 24.11.10
{
delete Parton[0];
Parton[0]=new G4Parton(PDGcode);
//============================================================================
void G4DiffractiveSplitableHadron::SetFirstParton( G4int PDGcode ) {
delete Parton[0];
Parton[0] = new G4Parton( PDGcode );
}
void G4DiffractiveSplitableHadron::SetSecondParton(G4int PDGcode)// Uzhi 24.11.10
{
delete Parton[1];
Parton[1]=new G4Parton(PDGcode);
}
//
//----------------------- Implementation--------------------------
//
void G4DiffractiveSplitableHadron::ChooseStringEnds(G4int PDGcode,G4int * aEnd, G4int * bEnd) const
{
const G4double udspin1= 1./6.;
const G4double uuspin1= 1./3.;
// const G4double udspin0= 1./2.; //@
G4int absPDGcode=std::abs(PDGcode);
if ( absPDGcode < 1000 ) //-------------------- Meson -------------
{
G4int heavy= absPDGcode/ 100;
G4int light= (absPDGcode %100)/10;
// G4int anti= std::pow(-1 , std::max( heavy, light));
G4int anti= 1 -2 * ( std::max( heavy, light ) % 2 );
if (PDGcode < 0 ) anti *=-1;
heavy *= anti;
light *= -1 * anti;
if ( G4UniformRand() < 0.5 )
{
*aEnd=heavy;
*bEnd=light;
}
else
{
*aEnd=light;
*bEnd=heavy;
}
}
else //-------------------- Barion --------------
{
G4int j1000 = PDGcode/ 1000;
G4int j100 = (PDGcode % 1000) / 100;
G4int j10 = (PDGcode % 100) / 10;
G4double random= G4UniformRand();
if ( std::abs(j100) >= std::abs(j10) )
{
if ( random < udspin1 )
{
*aEnd=j1000;
*bEnd= Diquark( j100, j10, 1);
} else if ( random < (udspin1 + uuspin1) )
{
*aEnd= j10;
*bEnd= Diquark( j1000, j100, 1);
} else
{
*aEnd=j100;
// Careful, there is no diquark q1=q2, (q1 q2)0,
// possible for Omega-
*bEnd= Diquark( j1000, j10, j1000 != j100 ? 0 : 1);
}
} else
{
// Lambda-like hadrons have two lightest quarks in spin 0
if ( random < udspin1 )
{
*aEnd=j1000;
// as above, but with charmed barions
*bEnd= Diquark( j100, j10, j100 != j10 ? 0 : 10);
} else if ( random < (udspin1 + uuspin1) )
{
*aEnd= j10;
*bEnd= Diquark( j1000, j100, 1);
} else
{
*aEnd=j100;
*bEnd= Diquark( j1000, j10, 1);
}
}
}
//============================================================================
void G4DiffractiveSplitableHadron::SetSecondParton( G4int PDGcode ) {
delete Parton[1];
Parton[1] = new G4Parton( PDGcode );
}
G4int G4DiffractiveSplitableHadron::Diquark(G4int aquark,G4int bquark,G4int Spin) const
{
G4int diquarkPDG;
diquarkPDG = std::max( std::abs(aquark), std::abs(bquark) )*1000 +
std::min( std::abs(aquark), std::abs(bquark) )*100 +
2*Spin + 1;
return ( aquark > 0 && bquark > 0 ) ? diquarkPDG : -1*diquarkPDG;
}
//============================================================================
void G4DiffractiveSplitableHadron::ChooseStringEnds( G4int PDGcode, G4int* aEnd,
G4int* bEnd ) const {
const G4double udspin1 = 1.0/6.0;
const G4double uuspin1 = 1.0/3.0;
//const G4double udspin0 = 1.0/2.0;
G4int absPDGcode = std::abs( PDGcode );
if ( absPDGcode < 1000 ) { //-------------------- Meson -------------
G4int heavy = absPDGcode/100;
G4int light = (absPDGcode % 100)/10;
//G4int anti = std::pow( -1 , std::max( heavy, light ) );
G4int anti = 1 - 2*( std::max( heavy, light ) % 2 );
if (PDGcode < 0 ) anti *= -1;
heavy *= anti;
light *= -1 * anti;
if ( G4UniformRand() < 0.5 ) {
*aEnd = heavy;
*bEnd = light;
} else {
*aEnd = light;
*bEnd = heavy;
}
} else { //-------------------- Baryon --------------
G4int j1000 = PDGcode/1000;
G4int j100 = (PDGcode % 1000)/100;
G4int j10 = (PDGcode % 100)/10;
G4double random = G4UniformRand();
if ( std::abs( j100 ) >= std::abs( j10 ) ) {
if ( random < udspin1 ) {
*aEnd = j1000;
*bEnd = Diquark( j100, j10, 1 );
} else if ( random < udspin1 + uuspin1 ) {
*aEnd = j10;
*bEnd = Diquark( j1000, j100, 1 );
} else {
*aEnd = j100;
// Careful, there is no diquark q1=q2, (q1 q2)0, possible for Omega-
*bEnd = Diquark( j1000, j10, j1000 != j100 ? 0 : 1 );
}
} else {
// Lambda-like hadrons have two lightest quarks in spin 0
if ( random < udspin1 ) {
*aEnd = j1000;
// as above, but with charmed baryons
*bEnd = Diquark( j100, j10, j100 != j10 ? 0 : 10 );
} else if ( random < udspin1 + uuspin1 ) {
*aEnd = j10;
*bEnd = Diquark( j1000, j100, 1 );
} else {
*aEnd = j100;
*bEnd = Diquark( j1000, j10, 1 );
}
}
}
}
//============================================================================
G4int G4DiffractiveSplitableHadron::Diquark( G4int aquark, G4int bquark, G4int Spin) const {
G4int diquarkPDG = std::max( std::abs( aquark ), std::abs( bquark ) ) * 1000 +
std::min( std::abs( aquark ), std::abs( bquark ) ) * 100 +
2*Spin + 1;
return ( aquark > 0 && bquark > 0 ) ? diquarkPDG : -1*diquarkPDG;
}
source/processes/hadronic/models/parton_string/diffraction/src/G4ElasticHNScattering.cc
+155 -194
View File
@@ -24,18 +24,19 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4ElasticHNScattering.cc 74627 2013-10-17 07:04:38Z gcosmo $
//
// ------------------------------------------------------------
// GEANT 4 class implemetation file
//
// ---------------- G4ElasticHNScattering --------------
// by V. Uzhinsky, March 2008.
// elastic scattering used by Fritiof model
// Take a projectile and a target
// scatter the projectile and target
// Take a projectile and a target
// scatter the projectile and target
// ---------------------------------------------------------------------
#include "globals.hh"
#include "Randomize.hh"
#include "G4PhysicalConstants.hh"
@@ -49,233 +50,193 @@
#include "G4FTFParameters.hh"
//#include "G4ios.hh"
G4ElasticHNScattering::G4ElasticHNScattering()
{
}
G4bool G4ElasticHNScattering::
ElasticScattering (G4VSplitableHadron *projectile,
G4VSplitableHadron *target,
G4FTFParameters *theParameters) const
{
// -------------------- Projectile parameters -----------------------------------
G4LorentzVector Pprojectile=projectile->Get4Momentum();
//============================================================================
if(Pprojectile.z() < 0.)
{
target->SetStatus(2);
return false;
}
G4ElasticHNScattering::G4ElasticHNScattering() {}
G4bool PutOnMassShell(false);
G4double M0projectile = Pprojectile.mag();
if(M0projectile < projectile->GetDefinition()->GetPDGMass())
{
PutOnMassShell=true;
M0projectile=projectile->GetDefinition()->GetPDGMass();
}
//============================================================================
G4double Mprojectile2 = M0projectile * M0projectile;
G4bool G4ElasticHNScattering::ElasticScattering( G4VSplitableHadron* projectile,
G4VSplitableHadron* target,
G4FTFParameters* theParameters ) const {
projectile->IncrementCollisionCount( 1 );
target->IncrementCollisionCount( 1 );
G4double AveragePt2=theParameters->GetAvaragePt2ofElasticScattering();
// Projectile parameters
G4LorentzVector Pprojectile = projectile->Get4Momentum();
if ( Pprojectile.z() < 0.0 ) return false;
G4bool PutOnMassShell( false );
G4double M0projectile = Pprojectile.mag();
if ( M0projectile < projectile->GetDefinition()->GetPDGMass() ) {
PutOnMassShell = true;
M0projectile = projectile->GetDefinition()->GetPDGMass();
}
G4double M0projectile2 = M0projectile * M0projectile;
G4double AveragePt2 = theParameters->GetAvaragePt2ofElasticScattering();
// -------------------- Target parameters ----------------------------------------------
// Target parameters
G4LorentzVector Ptarget = target->Get4Momentum();
G4double M0target = Ptarget.mag();
if ( M0target < target->GetDefinition()->GetPDGMass() ) {
PutOnMassShell = true;
M0target = target->GetDefinition()->GetPDGMass();
}
G4double M0target2 = M0target * M0target;
G4LorentzVector Ptarget=target->Get4Momentum();
// Transform momenta to cms and then rotate parallel to z axis;
G4LorentzVector Psum;
Psum = Pprojectile + Ptarget;
G4LorentzRotation toCms( -1*Psum.boostVector() );
G4LorentzVector Ptmp = toCms*Pprojectile;
if ( Ptmp.pz() <= 0.0 ) return false;
// "String" moving backwards in CMS, abort collision !
//G4cout << " abort Collision! " << G4endl;
toCms.rotateZ( -1*Ptmp.phi() );
toCms.rotateY( -1*Ptmp.theta() );
G4LorentzRotation toLab( toCms.inverse() );
Pprojectile.transform( toCms );
Ptarget.transform( toCms );
G4double M0target = Ptarget.mag();
// Putting on mass-on-shell, if needed
G4double PZcms2, PZcms;
G4double S = Psum.mag2();
G4double SqrtS = std::sqrt( S );
if ( SqrtS < M0projectile + M0target ) return false;
if(M0target < target->GetDefinition()->GetPDGMass())
{
PutOnMassShell=true;
M0target=target->GetDefinition()->GetPDGMass();
}
G4double Mtarget2 = M0target * M0target;
PZcms2 = ( S*S + sqr( M0projectile2 ) + sqr( M0target2 )
- 2*S*M0projectile2 - 2*S*M0target2 - 2*M0projectile2*M0target2 ) / 4.0 / S;
// Transform momenta to cms and then rotate parallel to z axis;
if ( PZcms2 < 0.0 ) { // It can be in an interaction with off-shell nuclear nucleon
if ( M0projectile > projectile->GetDefinition()->GetPDGMass() ) {
// An attempt to de-excite the projectile
// It is assumed that the target is in the ground state
M0projectile = projectile->GetDefinition()->GetPDGMass();
M0projectile2 = M0projectile * M0projectile;
PZcms2= ( S*S + sqr( M0projectile2 ) + sqr( M0target2 )
- 2*S*M0projectile2 - 2*S*M0target2 - 2*M0projectile2*M0target2 ) / 4.0 / S;
if ( PZcms2 < 0.0 ) { return false; } // Nonsuccesful attempt to de-excitate the projectile
} else {
return false; // The projectile was not excited, but the energy was too low to put
// the target nucleon on mass-shell
}
}
G4LorentzVector Psum;
Psum=Pprojectile+Ptarget;
PZcms = std::sqrt( PZcms2 );
G4LorentzRotation toCms(-1*Psum.boostVector());
if ( PutOnMassShell ) {
if ( Pprojectile.z() > 0.0 ) {
Pprojectile.setPz( PZcms );
Ptarget.setPz( -PZcms );
} else {
Pprojectile.setPz( -PZcms );
Ptarget.setPz( PZcms );
};
Pprojectile.setE( std::sqrt( M0projectile2 + Pprojectile.x() * Pprojectile.x() +
Pprojectile.y() * Pprojectile.y() + PZcms2 ) );
Ptarget.setE( std::sqrt( M0target2 + Ptarget.x() * Ptarget.x() + Ptarget.y() * Ptarget.y() +
PZcms2 ) );
}
G4LorentzVector Ptmp=toCms*Pprojectile;
G4double maxPtSquare = PZcms2;
if ( Ptmp.pz() <= 0. )
{
// "String" moving backwards in CMS, abort collision !!
//G4cout << " abort Collision!! " << G4endl;
target->SetStatus(2);
return false;
}
toCms.rotateZ(-1*Ptmp.phi());
toCms.rotateY(-1*Ptmp.theta());
G4LorentzRotation toLab(toCms.inverse());
// Now we can calculate the transferred Pt
G4double Pt2;
G4double ProjMassT2, ProjMassT;
G4double TargMassT2, TargMassT;
G4LorentzVector Qmomentum;
Pprojectile.transform(toCms);
Ptarget.transform(toCms);
do {
Qmomentum = G4LorentzVector( GaussianPt( AveragePt2, maxPtSquare ), 0.0 );
Pt2 = G4ThreeVector( Qmomentum.vect() ).mag2();
ProjMassT2 = M0projectile2 + Pt2;
ProjMassT = std::sqrt( ProjMassT2 );
TargMassT2 = M0target2 + Pt2;
TargMassT = std::sqrt( TargMassT2 );
} while ( SqrtS < ProjMassT + TargMassT );
// ---------------------- Putting on mass-on-shell, if needed ------------------------
G4double PZcms2, PZcms;
PZcms2 = ( S*S + sqr( ProjMassT2 ) + sqr( TargMassT2 )
- 2.0*S*ProjMassT2 - 2.0*S*TargMassT2 - 2.0*ProjMassT2*TargMassT2 ) / 4.0 / S;
G4double S=Psum.mag2();
// G4double SqrtS=std::sqrt(S);
if ( PZcms2 < 0.0 ) { PZcms2 = 0.0; }; // to avoid the exactness problem
PZcms = std::sqrt( PZcms2 );
Pprojectile.setPz( PZcms );
Ptarget.setPz( -PZcms );
Pprojectile += Qmomentum;
Ptarget -= Qmomentum;
PZcms2=(S*S+Mprojectile2*Mprojectile2+Mtarget2*Mtarget2-
2*S*Mprojectile2-2*S*Mtarget2-2*Mprojectile2*Mtarget2)/4./S;
// Transform back and update SplitableHadron Participant.
Pprojectile.transform( toLab );
Ptarget.transform( toLab );
if(PZcms2 < 0.)
{ // It can be in an interaction with off-shell nuclear nucleon
if(M0projectile > projectile->GetDefinition()->GetPDGMass())
{ // An attempt to de-excite the projectile
// It is assumed that the target is in the ground state
M0projectile = projectile->GetDefinition()->GetPDGMass();
Mprojectile2=M0projectile*M0projectile;
PZcms2=(S*S+Mprojectile2*Mprojectile2+Mtarget2*Mtarget2-
2*S*Mprojectile2 - 2*S*Mtarget2 - 2*Mprojectile2*Mtarget2)
/4./S;
// Calculation of the creation time
projectile->SetTimeOfCreation( target->GetTimeOfCreation() );
projectile->SetPosition( target->GetPosition() );
if(PZcms2 < 0.){ return false;} // Non succesful attempt after the de-excitation
}
else // if(M0projectile > projectile->GetDefinition()->GetPDGMass())
{
target->SetStatus(2);
return false; // The projectile was not excited,
// but the energy was too low to put
// the target nucleon on mass-shell
} // end of if(M0projectile > projectile->GetDefinition()->GetPDGMass())
} // end of if(PZcms2 < 0.)
// Creation time and position of target nucleon were determined at
// ReggeonCascade() of G4FTFModel
PZcms = std::sqrt(PZcms2);
projectile->Set4Momentum( Pprojectile );
target->Set4Momentum( Ptarget );
if(PutOnMassShell)
{
if(Pprojectile.z() > 0.)
{
Pprojectile.setPz( PZcms);
Ptarget.setPz( -PZcms);
}
else // if(Pprojectile.z() > 0.)
{
Pprojectile.setPz(-PZcms);
Ptarget.setPz( PZcms);
};
//projectile->IncrementCollisionCount( 1 );
//target->IncrementCollisionCount( 1 );
Pprojectile.setE(std::sqrt(Mprojectile2+
Pprojectile.x()*Pprojectile.x()+
Pprojectile.y()*Pprojectile.y()+
PZcms2));
Ptarget.setE(std::sqrt( Mtarget2 +
Ptarget.x()*Ptarget.x()+
Ptarget.y()*Ptarget.y()+
PZcms2));
} // end of if(PutOnMassShell)
G4double maxPtSquare = PZcms2;
// ------ Now we can calculate the transfered Pt --------------------------
G4double Pt2;
G4double ProjMassT2; //, ProjMassT;
G4double TargMassT2; //, TargMassT;
G4LorentzVector Qmomentum;
Qmomentum=G4LorentzVector(GaussianPt(AveragePt2,maxPtSquare),0);
Pt2=G4ThreeVector(Qmomentum.vect()).mag2();
ProjMassT2=Mprojectile2+Pt2;
// ProjMassT =std::sqrt(ProjMassT2);
TargMassT2=Mtarget2+Pt2;
// TargMassT =std::sqrt(TargMassT2);
PZcms2=(S*S+ProjMassT2*ProjMassT2+
TargMassT2*TargMassT2-
2.*S*ProjMassT2-2.*S*TargMassT2-
2.*ProjMassT2*TargMassT2)/4./S;
if(PZcms2 < 0 ) {PZcms2=0;};// to avoid the exactness problem
PZcms =std::sqrt(PZcms2);
Pprojectile.setPz( PZcms);
Ptarget.setPz( -PZcms);
Pprojectile += Qmomentum;
Ptarget -= Qmomentum;
// Transform back and update SplitableHadron Participant.
Pprojectile.transform(toLab);
Ptarget.transform(toLab);
/* // Maybe it will be needed for an exact calculations--------------------
G4double TargetMomentum=std::sqrt(Ptarget.x()*Ptarget.x()+
Ptarget.y()*Ptarget.y()+
Ptarget.z()*Ptarget.z());
*/
// Calculation of the creation time ---------------------
projectile->SetTimeOfCreation(target->GetTimeOfCreation());
projectile->SetPosition(target->GetPosition());
// Creation time and position of target nucleon were determined at
// ReggeonCascade() of G4FTFModel
// ------------------------------------------------------
projectile->Set4Momentum(Pprojectile);
target->Set4Momentum(Ptarget);
projectile->IncrementCollisionCount(1);
target->IncrementCollisionCount(1);
return true;
return true;
}
// --------- private methods ----------------------
//============================================================================
G4ThreeVector G4ElasticHNScattering::GaussianPt(G4double AveragePt2, G4double maxPtSquare) const
{ // @@ this method is used in FTFModel as well. Should go somewhere common!
G4double Pt2(0.);
if(AveragePt2 <= 0.) {Pt2=0.;}
else
{
Pt2 = -AveragePt2 * std::log(1. + G4UniformRand() *
(std::exp(-maxPtSquare/AveragePt2)-1.));
}
G4double Pt=std::sqrt(Pt2);
G4double phi=G4UniformRand() * twopi;
return G4ThreeVector (Pt*std::cos(phi), Pt*std::sin(phi), 0.);
}
G4ElasticHNScattering::G4ElasticHNScattering(const G4ElasticHNScattering &)
{
throw G4HadronicException(__FILE__, __LINE__, "G4ElasticHNScattering copy contructor not meant to be called");
G4ThreeVector G4ElasticHNScattering::GaussianPt( G4double AveragePt2,
G4double maxPtSquare ) const {
// @@ this method is used in FTFModel as well. Should go somewhere common!
G4double Pt2( 0.0 );
if ( AveragePt2 <= 0.0 ) {
Pt2 = 0.0;
} else {
Pt2 = -AveragePt2 * std::log( 1.0 + G4UniformRand() *
( std::exp( -maxPtSquare/AveragePt2 ) -1.0 ) );
}
G4double Pt = std::sqrt( Pt2 );
G4double phi = G4UniformRand() * twopi;
return G4ThreeVector( Pt * std::cos( phi ), Pt * std::sin( phi ), 0.0 );
}
G4ElasticHNScattering::~G4ElasticHNScattering()
{
//============================================================================
G4ElasticHNScattering::G4ElasticHNScattering( const G4ElasticHNScattering& ) {
throw G4HadronicException( __FILE__, __LINE__,
"G4ElasticHNScattering copy contructor not meant to be called" );
}
const G4ElasticHNScattering & G4ElasticHNScattering::operator=(const G4ElasticHNScattering &)
{
throw G4HadronicException(__FILE__, __LINE__, "G4ElasticHNScattering = operator not meant to be called");
//return *this; //A.R. 25-Jul-2012 : fix Coverity
//============================================================================
G4ElasticHNScattering::~G4ElasticHNScattering() {}
//============================================================================
const G4ElasticHNScattering & G4ElasticHNScattering::operator=( const G4ElasticHNScattering& ) {
throw G4HadronicException( __FILE__, __LINE__,
"G4ElasticHNScattering = operator not meant to be called" );
}
int G4ElasticHNScattering::operator==(const G4ElasticHNScattering &) const
{
throw G4HadronicException(__FILE__, __LINE__, "G4ElasticHNScattering == operator not meant to be called");
//return false; //A.R. 25-Jul-2012 : fix Coverity
//============================================================================
int G4ElasticHNScattering::operator==( const G4ElasticHNScattering& ) const {
throw G4HadronicException( __FILE__, __LINE__,
"G4ElasticHNScattering == operator not meant to be called" );
}
int G4ElasticHNScattering::operator!=(const G4ElasticHNScattering &) const
{
throw G4HadronicException(__FILE__, __LINE__, "G4ElasticHNScattering != operator not meant to be called");
//return true; //A.R. 25-Jul-2012 : fix Coverity
//============================================================================
int G4ElasticHNScattering::operator!=( const G4ElasticHNScattering& ) const {
throw G4HadronicException( __FILE__, __LINE__,
"G4ElasticHNScattering != operator not meant to be called" );
}
source/processes/hadronic/models/parton_string/diffraction/src/G4FTFAnnihilation.cc
+893 -1023
View File
File diff suppressed because it is too large Load Diff
source/processes/hadronic/models/parton_string/diffraction/src/G4FTFModel.cc
+3069 -1591
View File
File diff suppressed because it is too large Load Diff
source/processes/hadronic/models/parton_string/diffraction/src/G4FTFParameters.cc
+636 -661
View File
File diff suppressed because it is too large Load Diff
source/processes/hadronic/models/parton_string/diffraction/src/G4FTFParticipants.cc
+263 -193
View File
@@ -24,9 +24,10 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4FTFParticipants.cc 74627 2013-10-17 07:04:38Z gcosmo $
// GEANT4 tag $Name: $
//
// ------------------------------------------------------------
// GEANT 4 class implementation file
//
@@ -47,233 +48,302 @@
#include "G4ios.hh"
#include "Randomize.hh"
#include "G4SystemOfUnits.hh"
#include "G4FTFParameters.hh" // Uzhi 29.03.08
#include "G4FTFParameters.hh"
#include "G4DiffractiveSplitableHadron.hh"
#include "G4VSplitableHadron.hh"
G4FTFParticipants::G4FTFParticipants() :
theProjectileNucleus(0),
currentInteraction(-1)
{
}
G4FTFParticipants::G4FTFParticipants(const G4FTFParticipants &): G4VParticipants()
, theProjectileNucleus(0), currentInteraction(-1) //A.R. 14-Aug-2012 Coverity fix.
//============================================================================
//#define debugFTFparticipant
//============================================================================
G4FTFParticipants::G4FTFParticipants() : currentInteraction( -1 ) {}
//============================================================================
G4FTFParticipants::G4FTFParticipants( const G4FTFParticipants& ) :
G4VParticipants(), currentInteraction( -1 )
{
G4Exception("G4FTFParticipants::G4FTFParticipants()","HAD_FTF_001",
FatalException," Must not use copy ctor()");
G4Exception( "G4FTFParticipants::G4FTFParticipants()", "HAD_FTF_001",
FatalException, " Must not use copy ctor()" );
}
G4FTFParticipants::~G4FTFParticipants()
{
if ( theProjectileNucleus != NULL ) delete theProjectileNucleus;
}
//============================================================================
//-------------------------------------------------------------------------
G4FTFParticipants::~G4FTFParticipants() {}
void G4FTFParticipants::SetProjectileNucleus(G4V3DNucleus * aNucleus)
{
if (theProjectileNucleus) delete theProjectileNucleus;
theProjectileNucleus = aNucleus;
}
G4V3DNucleus * G4FTFParticipants::GetProjectileNucleus()
{
return theProjectileNucleus;
}
//============================================================================
void G4FTFParticipants::InitProjectileNucleus(G4int theA, G4int theZ)
{
if ( theProjectileNucleus == NULL ) theProjectileNucleus = new G4Fancy3DNucleus();
theProjectileNucleus->Init(theA, theZ);
theProjectileNucleus->SortNucleonsDecZ();
}
//-------------------------------------------------------------------------
void G4FTFParticipants::GetList(const G4ReactionProduct &thePrimary,
G4FTFParameters *theParameters)
{
//G4cout<<"Participants::GetList"<<G4endl;
//G4cout<<"thePrimary "<<thePrimary.GetMomentum()<<G4endl;
StartLoop(); // reset Loop over Interactions
void G4FTFParticipants::GetList( const G4ReactionProduct& thePrimary,
G4FTFParameters* theParameters ) {
for(unsigned int i=0; i<theInteractions.size(); i++) delete theInteractions[i];
theInteractions.clear();
#ifdef debugFTFparticipant
G4cout << "Participants::GetList" << G4endl
<< "thePrimary " << thePrimary.GetMomentum() << G4endl << G4endl;
#endif
G4double deltaxy=2 * fermi; // Extra nuclear radius
//G4cout<<"theProjectileNucleus "<<theProjectileNucleus<<G4endl;
if(theProjectileNucleus == 0)
{ // Hadron-nucleus or anti-baryon-nucleus interactions
//G4cout<<"Hadron-nucleus or anti-baryon-nucleus interactions"<<G4endl;
G4double betta_z = thePrimary.GetMomentum().z() / thePrimary.GetTotalEnergy();
if ( betta_z < 1.0e-10 ) betta_z = 1.0e-10;
G4double impactX(0.), impactY(0.);
StartLoop(); // reset Loop over Interactions
G4VSplitableHadron * primarySplitable=new G4DiffractiveSplitableHadron(thePrimary);
//G4cout<<"Prim in Part "<<primarySplitable->Get4Momentum()<<G4endl;
G4double xyradius;
xyradius =theNucleus->GetOuterRadius() + deltaxy; // Impact parameter sampling
// G4bool nucleusNeedsShift = true; // Uzhi 20 July 2009
do
{
std::pair<G4double, G4double> theImpactParameter;
theImpactParameter = theNucleus->ChooseImpactXandY(xyradius);
impactX = theImpactParameter.first;
impactY = theImpactParameter.second;
for ( unsigned int i = 0; i < theInteractions.size(); i++ ) delete theInteractions[i];
theInteractions.clear();
G4ThreeVector thePosition(impactX, impactY, -DBL_MAX);
primarySplitable->SetPosition(thePosition);
G4double deltaxy = 2.0 * fermi; // Extra nuclear radius
theNucleus->StartLoop();
G4Nucleon * nucleon;
if ( theProjectileNucleus == 0 ) { // Hadron-nucleus or anti-baryon-nucleus interactions
G4int TrN(0);
while ( (nucleon=theNucleus->GetNextNucleon()) )
{
G4double impact2= sqr(impactX - nucleon->GetPosition().x()) +
sqr(impactY - nucleon->GetPosition().y());
G4double impactX( 0.0 ), impactY( 0.0 );
if ( theParameters->GetProbabilityOfInteraction(impact2/fermi/fermi)
> G4UniformRand() )
{
primarySplitable->SetStatus(1); // It takes part in the interaction
G4VSplitableHadron * targetSplitable=0;
if ( ! nucleon->AreYouHit() )
{
targetSplitable= new G4DiffractiveSplitableHadron(*nucleon);
nucleon->Hit(targetSplitable);
nucleon->SetBindingEnergy(3.*nucleon->GetBindingEnergy());
//G4cout<<" Part nucl "<<TrN<<" "<<nucleon->Get4Momentum()<<G4endl;
//G4cout<<" Part nucl "<<G4endl;
targetSplitable->SetStatus(1); // It takes part in the interaction
}
G4InteractionContent * aInteraction =
new G4InteractionContent(primarySplitable);
aInteraction->SetTarget(targetSplitable);
aInteraction->SetTargetNucleon(nucleon); // Uzhi 16.07.09
aInteraction->SetStatus(1); // Uzhi Feb26
theInteractions.push_back(aInteraction);
}
TrN++;
}
} while ( theInteractions.size() == 0 );
//if ( theInteractions.size() == 0 ) delete primarySplitable; //A.R. 14-Aug-2012 Coverity fix
// G4cout << "Number of Hit nucleons " << theInteractions.size()
// << "\t" << impactX/fermi << "\t"<<impactY/fermi
// << "\t" << std::sqrt(sqr(impactX)+sqr(impactY))/fermi <<G4endl;
return;
} // end of if(theProjectileNucleus == 0)
//-------------------------------------------------------------------
// Projectile and target are nuclei
//-------------------------------------------------------------------
//VU G4VSplitableHadron * primarySplitable=new G4DiffractiveSplitableHadron(thePrimary);
//G4cout<<"Prim in Part "<<primarySplitable->Get4Momentum()<<G4endl;
//G4cout<<"Projectile and target are nuclei"<<G4endl;
//G4cout<<thePrimary.GetMomentum()<<G4endl;
//G4cout<<"Part Pr Tr "<<theProjectileNucleus<<" "<<theNucleus<<G4endl;
G4VSplitableHadron* primarySplitable = new G4DiffractiveSplitableHadron( thePrimary );
#ifdef debugFTFparticipant
G4cout << "Hadron-nucleus or anti-baryon-nucleus interactions" << G4endl;
#endif
G4double xyradius;
xyradius =theProjectileNucleus->GetOuterRadius() + // Impact parameter sampling
theNucleus->GetOuterRadius() + deltaxy;
xyradius = theNucleus->GetOuterRadius() + deltaxy; // Range of impact parameter sampling
do { // while ( theInteractions.size() == 0 )
G4double impactX(0.), impactY(0.);
std::pair< G4double, G4double > theImpactParameter;
theImpactParameter = theNucleus->ChooseImpactXandY( xyradius );
impactX = theImpactParameter.first;
impactY = theImpactParameter.second;
do
{
//G4cout<<"New interaction list"<<G4endl;
std::pair<G4double, G4double> theImpactParameter;
theImpactParameter = theNucleus->ChooseImpactXandY(xyradius);
impactX = theImpactParameter.first;
impactY = theImpactParameter.second;
//G4cout<<"B "<<std::sqrt(sqr(impactX)+sqr(impactY))/fermi<<G4endl;
#ifdef debugFTFparticipant
G4cout << "New interaction list," << " b= "
<< std::sqrt( sqr(impactX ) + sqr( impactY ) )/fermi << G4endl;
#endif
G4ThreeVector thePosition(impactX, impactY, -DBL_MAX);
//VU primarySplitable->SetPosition(thePosition);
G4ThreeVector thePosition( impactX, impactY, 0.0 );
primarySplitable->SetPosition( thePosition );
theProjectileNucleus->StartLoop();
G4Nucleon * ProjectileNucleon;
G4int PrNuclN(0);
theNucleus->StartLoop();
G4Nucleon* nucleon;
while ( (ProjectileNucleon=theProjectileNucleus->GetNextNucleon()) )
{
G4VSplitableHadron * ProjectileSplitable=0;
//G4cout<<G4endl<<"Prj N mom "<<ProjectileNucleon->Get4Momentum()<<"-------------"<<G4endl;
theNucleus->StartLoop();
G4Nucleon * TargetNucleon;
#ifdef debugFTFparticipant
G4int TrN( 0 );
#endif
G4int TrNuclN(0);
while ( (TargetNucleon=theNucleus->GetNextNucleon()) )
{
//G4cout<<"Trg N mom "<<TargetNucleon->Get4Momentum()<<G4endl;
G4double impact2=
sqr(impactX+ProjectileNucleon->GetPosition().x()-TargetNucleon->GetPosition().x())+
sqr(impactY+ProjectileNucleon->GetPosition().y()-TargetNucleon->GetPosition().y());
while ( ( nucleon = theNucleus->GetNextNucleon() ) ) {
G4VSplitableHadron * TargetSplitable=0;
G4double impact2 = sqr( impactX - nucleon->GetPosition().x() ) +
sqr( impactY - nucleon->GetPosition().y() );
if ( theParameters->GetProbabilityOfInteraction(impact2/fermi/fermi)
> G4UniformRand() )
{ // An Interaction has happend!
//G4cout<<"An Interaction has happend"<<G4endl;
//G4cout<<"PrN TrN "<<PrNuclN<<" "<<TrNuclN<<" "<<ProjectileNucleon->GetPosition().z()/fermi<<" "<<TargetNucleon->GetPosition().z()/fermi<<" "<<ProjectileNucleon->GetPosition().z()/fermi + TargetNucleon->GetPosition().z()/fermi <<G4endl;
if ( theParameters->GetProbabilityOfInteraction( impact2/fermi/fermi ) >
G4UniformRand() ) {
primarySplitable->SetStatus( 1 ); // It takes part in the interaction
G4VSplitableHadron* targetSplitable = 0;
if ( ! nucleon->AreYouHit() ) {
targetSplitable = new G4DiffractiveSplitableHadron( *nucleon );
nucleon->Hit( targetSplitable );
targetSplitable->SetStatus( 1 ); // It takes part in the interaction
if ( ! ProjectileNucleon->AreYouHit() )
{ // Projectile nucleon was not involved until now.
ProjectileSplitable= new G4DiffractiveSplitableHadron(*ProjectileNucleon);
ProjectileNucleon->Hit(ProjectileSplitable);
ProjectileNucleon->SetBindingEnergy(3.*ProjectileNucleon->GetBindingEnergy());
ProjectileSplitable->SetStatus(1); // It takes part in the interaction
}
else
{ // Projectile nucleon was involved before.
ProjectileSplitable=ProjectileNucleon->GetSplitableHadron();
} // End of if ( ! Projectileucleon->AreYouHit() )
#ifdef debugFTFparticipant
G4cout << "Participated nucleons #, " << TrN << " " << "Splitable Pr* Tr* "
<< primarySplitable << " " << targetSplitable << G4endl;
#endif
if ( ! TargetNucleon->AreYouHit() )
{ // Target nucleon was not involved until now
TargetSplitable= new G4DiffractiveSplitableHadron(*TargetNucleon);
TargetNucleon->Hit(TargetSplitable);
TargetNucleon->SetBindingEnergy(3.*ProjectileNucleon->GetBindingEnergy());
TargetSplitable->SetStatus(1); // It takes part in the interaction
}
else
{ // Target nucleon was involved before.
TargetSplitable=TargetNucleon->GetSplitableHadron();
} // End of if ( ! TargetNeucleon->AreYouHit() )
}
G4InteractionContent* aInteraction = new G4InteractionContent( primarySplitable );
G4Nucleon* PrNucleon = 0;
aInteraction->SetProjectileNucleon( PrNucleon );
aInteraction->SetTarget( targetSplitable );
aInteraction->SetTargetNucleon( nucleon );
aInteraction->SetStatus( 1 );
aInteraction->SetInteractionTime( ( primarySplitable->GetPosition().z() +
nucleon->GetPosition().z() ) / betta_z );
theInteractions.push_back( aInteraction );
}
G4InteractionContent * anInteraction =
new G4InteractionContent(ProjectileSplitable);
anInteraction->SetTarget(TargetSplitable);
anInteraction->SetTargetNucleon(TargetNucleon);
anInteraction->SetStatus(1); // Uzhi Feb26
// anInteraction->SetInteractionTime(ProjectileNucleon->GetPosition().z()+
// TargetNucleon->GetPosition().z());
//G4cout<<"Z's pr tr "<<ProjectileNucleon->GetPosition().z()/fermi<<" "<<TargetNucleon->GetPosition().z()/fermi<<" "<<ProjectileNucleon->GetPosition().z()/fermi + TargetNucleon->GetPosition().z()/fermi <<G4endl;
theInteractions.push_back(anInteraction);
//G4cout<<"Ppr tr "<<ProjectileSplitable<<" "<<TargetSplitable<<G4endl;
} // End of An Interaction has happend!
TrNuclN++;
} // End of while ( (TargetNucleon=theNucleus->GetNextNucleon()) )
PrNuclN++;
} // End of while ( (ProjectileNucleon=theProjectileNucleus->GetNextNucleon()) )
} while ( theInteractions.size() == 0 ); // end of while ( theInteractions.size() == 0 )
#ifdef debugFTFparticipant
TrN++;
#endif
//std::sort(theInteractions.begin(),theInteractions.end()); // ????
}
// G4cout << "Number of primary collisions " << theInteractions.size()
// << "\t" << impactX/fermi << "\t"<<impactY/fermi
// << "\t" << std::sqrt(sqr(impactX)+sqr(impactY))/fermi <<G4endl;
//G4int Uzhi; G4cin >> Uzhi;
} while ( theInteractions.size() == 0 );
#ifdef debugFTFparticipant
G4cout << "Number of Hit nucleons " << theInteractions.size() << "\t Bx " << impactX/fermi
<< "\t By " << impactY/fermi << "\t B "
<< std::sqrt( sqr( impactX ) + sqr( impactY ) )/fermi << G4endl << G4endl;
#endif
//SortInteractionsIncT(); // Not need because nucleons are sorted in increasing z-coordinates.
ShiftInteractionTime(); // To put correct times and z-coordinates
return;
}
//--------------------------------------------------------------
// Implementation (private) methods
} // end of if ( theProjectileNucleus == 0 )
// Projectile and target are nuclei
#ifdef debugFTFparticipant
G4cout << "Projectile and target are nuclei" << G4endl;
#endif
G4double xyradius;
xyradius = theProjectileNucleus->GetOuterRadius() + // Range of impact parameter sampling
theNucleus->GetOuterRadius() + deltaxy;
G4double impactX( 0.0 ), impactY( 0.0 );
do { // while ( theInteractions.size() == 0 )
std::pair< G4double, G4double > theImpactParameter;
theImpactParameter = theNucleus->ChooseImpactXandY( xyradius );
impactX = theImpactParameter.first;
impactY = theImpactParameter.second;
#ifdef debugFTFparticipant
G4cout << "New interaction list, " << "b "
<< std::sqrt( sqr( impactX ) + sqr( impactY ) )/fermi << G4endl;
#endif
G4ThreeVector theBeamPosition( impactX, impactY, 0.0 );
theProjectileNucleus->StartLoop();
G4Nucleon* ProjectileNucleon;
#ifdef debugFTFparticipant
G4int PrNuclN( 0 );
#endif
while ( ( ProjectileNucleon = theProjectileNucleus->GetNextNucleon() ) ) {
G4VSplitableHadron* ProjectileSplitable = 0;
theNucleus->StartLoop();
G4Nucleon* TargetNucleon = 0;
#ifdef debugFTFparticipant
G4int TrNuclN( 0 );
#endif
while ( ( TargetNucleon = theNucleus->GetNextNucleon() ) ) {
G4double impact2 = sqr( impactX + ProjectileNucleon->GetPosition().x() -
TargetNucleon->GetPosition().x() ) +
sqr( impactY + ProjectileNucleon->GetPosition().y() -
TargetNucleon->GetPosition().y() );
G4VSplitableHadron* TargetSplitable = 0;
if ( theParameters->GetProbabilityOfInteraction( impact2/fermi/fermi ) >
G4UniformRand() ) { // An interaction has happend!
#ifdef debugFTFparticipant
G4cout << G4endl << "An Interaction has happend" << G4endl << "Proj N mom " << PrNuclN
<< " " << ProjectileNucleon->Get4Momentum() << "-------------" << G4endl
<< "Targ N mom " << TrNuclN << " " << TargetNucleon->Get4Momentum() << G4endl
<< "PrN TrN Z coords " << ProjectileNucleon->GetPosition().z()/fermi
<< " " << TargetNucleon->GetPosition().z()/fermi
<< " " << ProjectileNucleon->GetPosition().z()/fermi +
TargetNucleon->GetPosition().z()/fermi << G4endl;
#endif
if ( ! ProjectileNucleon->AreYouHit() ) {
// Projectile nucleon was not involved until now.
ProjectileSplitable = new G4DiffractiveSplitableHadron( *ProjectileNucleon );
ProjectileNucleon->Hit( ProjectileSplitable );
ProjectileSplitable->SetStatus( 1 ); // It takes part in the interaction
} else { // Projectile nucleon was involved before.
ProjectileSplitable = ProjectileNucleon->GetSplitableHadron();
}
if ( ! TargetNucleon->AreYouHit() ) { // Target nucleon was not involved until now
TargetSplitable = new G4DiffractiveSplitableHadron( *TargetNucleon );
TargetNucleon->Hit( TargetSplitable );
TargetSplitable->SetStatus( 1 ); // It takes part in the interaction
} else { // Target nucleon was involved before.
TargetSplitable = TargetNucleon->GetSplitableHadron();
}
G4InteractionContent* anInteraction = new G4InteractionContent( ProjectileSplitable );
anInteraction->SetTarget( TargetSplitable );
anInteraction->SetProjectileNucleon( ProjectileNucleon );
anInteraction->SetTargetNucleon( TargetNucleon );
anInteraction->SetInteractionTime( ( ProjectileNucleon->GetPosition().z() +
TargetNucleon->GetPosition().z() ) / betta_z );
anInteraction->SetStatus( 1 );
#ifdef debugFTFparticipant
G4cout << "Part anInteraction->GetInteractionTime() "
<< anInteraction->GetInteractionTime()/fermi << G4endl
<< "Splitable Pr* Tr* " << ProjectileSplitable << " "
<< TargetSplitable << G4endl;
#endif
theInteractions.push_back( anInteraction );
} // End of an Interaction has happend!
#ifdef debugFTFparticipant
TrNuclN++;
#endif
} // End of while ( ( TargetNucleon = theNucleus->GetNextNucleon() ) )
#ifdef debugFTFparticipant
PrNuclN++;
#endif
} // End of while ( ( ProjectileNucleon = theProjectileNucleus->GetNextNucleon() ) )
if ( theInteractions.size() != 0 ) theProjectileNucleus->DoTranslation( theBeamPosition );
} while ( theInteractions.size() == 0 );
SortInteractionsIncT();
ShiftInteractionTime();
#ifdef debugFTFparticipant
G4cout << G4endl << "Number of primary collisions " << theInteractions.size()
<< "\t Bx " << impactX/fermi << "\t By " << impactY/fermi
<< "\t B " << std::sqrt( sqr( impactX ) + sqr( impactY ) )/fermi << G4endl
<< "FTF participant End. #######################" << G4endl << G4endl;
#endif
return;
}
//============================================================================
bool G4FTFPartHelperForSortInT( const G4InteractionContent* Int1,
const G4InteractionContent* Int2 ) {
return Int1->GetInteractionTime() < Int2->GetInteractionTime();
}
//============================================================================
void G4FTFParticipants::SortInteractionsIncT() { // on increased T
if ( theInteractions.size() < 2 ) return; // Avoid unnecesary work
std::sort( theInteractions.begin(), theInteractions.end(), G4FTFPartHelperForSortInT );
}
//============================================================================
void G4FTFParticipants::ShiftInteractionTime() {
G4double InitialTime = theInteractions[0]->GetInteractionTime();
for ( unsigned int i = 1; i < theInteractions.size(); i++ ) {
G4double InterTime = theInteractions[i]->GetInteractionTime() - InitialTime;
theInteractions[i]->SetInteractionTime( InterTime );
G4InteractionContent* aCollision = theInteractions[i];
G4VSplitableHadron* projectile = aCollision->GetProjectile();
G4VSplitableHadron* target = aCollision->GetTarget();
G4ThreeVector prPosition = projectile->GetPosition();
prPosition.setZ( target->GetPosition().z() );
projectile->SetPosition( prPosition );
projectile->SetTimeOfCreation( InterTime );
target->SetTimeOfCreation( InterTime );
}
return;
}
source/processes/hadronic/models/parton_string/hadronization/CMakeLists.txt
+1 -1
View File
@@ -7,7 +7,7 @@
#
# Generated on : 24/9/2010
#
# $Id: CMakeLists.txt,v 1.1 2010-09-29 19:04:53 bmorgan Exp $
# $Id: CMakeLists.txt 66892 2013-01-17 10:57:59Z gunter $
#
#------------------------------------------------------------------------------
source/processes/hadronic/models/parton_string/hadronization/GNUmakefile
+1 -1
View File
@@ -1,4 +1,4 @@
# $Id: GNUmakefile,v 1.2 2003-10-08 16:42:21 hpw Exp $
# $Id: GNUmakefile 66892 2013-01-17 10:57:59Z gunter $
# -----------------------------------------------------------
# GNUmakefile for hadronic library. Gabriele Cosmo, 18/9/96.
# -----------------------------------------------------------
source/processes/hadronic/models/parton_string/hadronization/History
+12 -1
View File
@@ -1,4 +1,4 @@
$Id: History,v 1.18 2010-11-03 17:11:31 gunter Exp $
$Id: History 76744 2013-11-14 15:50:20Z gcosmo $
-------------------------------------------------------------------
==========================================================
@@ -15,6 +15,17 @@ code and to keep track of all tags.
* Please list in reverse chronological order (last date on top)
---------------------------------------------------------------
14-Nov-2013, A.Ribon (had-hadronization-V09-06-02)
- Fixed two mistakes in the index manipulation of the BaryonWeight
4-dimensional vector in G4LundStringFragmentation.cc .
29-July-2013, H.Kurashige (had-hadronization-V09-06-01)
- Remove inclusion of G4ShortLivedTable.hh (G4VLongitudinalStringDecay.cc)
02-May-2013, A.Ribon (had-hadronization-V09-06-00)
- For thread safety, replaced CLHEP::RandFlat with G4RandFlat in
G4VLongitudinalStringDecay.cc.
27-Sep-2012, G.Cosmo
- Explicitly use inclusion of headers for system of units and physical
constants, in plan to remove implicit inclusion from globals.hh.
source/processes/hadronic/models/parton_string/hadronization/include/G4ExcitedStringDecay.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4ExcitedStringDecay.hh 69569 2013-05-08 13:19:50Z gcosmo $
//
#ifndef G4ExcitedStringDecay_h
#define G4ExcitedStringDecay_h 1
source/processes/hadronic/models/parton_string/hadronization/include/G4FragmentingString.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4FragmentingString.hh 69569 2013-05-08 13:19:50Z gcosmo $
//
#ifndef G4FragmentingString_h
source/processes/hadronic/models/parton_string/hadronization/include/G4HadronBuilder.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4HadronBuilder.hh 69569 2013-05-08 13:19:50Z gcosmo $
//
// -----------------------------------------------------------------------------
// GEANT 4 class header file
source/processes/hadronic/models/parton_string/hadronization/include/G4LundStringFragmentation.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4LundStringFragmentation.hh 69569 2013-05-08 13:19:50Z gcosmo $
//
// -----------------------------------------------------------------------------
// GEANT 4 class implementation file
source/processes/hadronic/models/parton_string/hadronization/include/G4QGSMFragmentation.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4QGSMFragmentation.hh 69569 2013-05-08 13:19:50Z gcosmo $
//
// -----------------------------------------------------------------------------
// GEANT 4 class implementation file
source/processes/hadronic/models/parton_string/hadronization/include/G4VKinkyStringDecay.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4VKinkyStringDecay.hh 69569 2013-05-08 13:19:50Z gcosmo $
// Maxim Komogorov
//
// -----------------------------------------------------------------------------
source/processes/hadronic/models/parton_string/hadronization/include/G4VLongitudinalStringDecay.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4VLongitudinalStringDecay.hh 69569 2013-05-08 13:19:50Z gcosmo $
// Maxim Komogorov
//
// -----------------------------------------------------------------------------
source/processes/hadronic/models/parton_string/hadronization/sources.cmake
+1 -1
View File
@@ -11,7 +11,7 @@
#
# Generated on : 24/9/2010
#
# $Id: sources.cmake,v 1.1 2010-09-29 19:05:01 bmorgan Exp $
# $Id: sources.cmake 66892 2013-01-17 10:57:59Z gunter $
#
#------------------------------------------------------------------------------
source/processes/hadronic/models/parton_string/hadronization/src/G4HadronBuilder.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4HadronBuilder.cc 69569 2013-05-08 13:19:50Z gcosmo $
//
// -----------------------------------------------------------------------------
// GEANT 4 class implementation file
source/processes/hadronic/models/parton_string/hadronization/src/G4LundStringFragmentation.cc
+3 -3
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4LundStringFragmentation.cc 76744 2013-11-14 15:50:20Z gcosmo $
// GEANT4 tag $Name: $ 1.8
//
// -----------------------------------------------------------------------------
@@ -206,7 +206,7 @@ G4LundStringFragmentation::G4LundStringFragmentation()
BaryonWeight[0][1][2][0]=(1.-pspin_barion)*0.5;
Baryon[0][1][2][1]=3212; // Sigma0
BaryonWeight[0][1][2][2]=(1.-pspin_barion)*0.5;
BaryonWeight[0][1][2][1]=(1.-pspin_barion)*0.5;
Baryon[0][1][2][2]=3214; // Sigma*0
BaryonWeight[0][1][2][2]=pspin_barion;
@@ -349,7 +349,7 @@ G4LundStringFragmentation::G4LundStringFragmentation()
BaryonWeight[2][1][2][0]=1.-pspin_barion;
Baryon[2][1][2][1]=3324; // Theta*0
BaryonWeight[2][1][2][2]=pspin_barion;
BaryonWeight[2][1][2][1]=pspin_barion;
//---------------------------------------
Baryon[2][2][0][0]=3312; // Theta-
source/processes/hadronic/models/parton_string/hadronization/src/G4QGSMFragmentation.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4QGSMFragmentation.cc 69569 2013-05-08 13:19:50Z gcosmo $
//
// -----------------------------------------------------------------------------
// GEANT 4 class implementation file
source/processes/hadronic/models/parton_string/hadronization/src/G4VKinkyStringDecay.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4VKinkyStringDecay.cc 69569 2013-05-08 13:19:50Z gcosmo $
// Maxim Komogorov
//
// -----------------------------------------------------------------------------
source/processes/hadronic/models/parton_string/hadronization/src/G4VLongitudinalStringDecay.cc
+5 -6
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4VLongitudinalStringDecay.cc 73023 2013-08-15 09:10:04Z gcosmo $
//
// -----------------------------------------------------------------------------
// GEANT 4 class implementation file
@@ -45,7 +45,6 @@
#include "G4VShortLivedParticle.hh"
#include "G4ShortLivedConstructor.hh"
#include "G4ParticleTable.hh"
#include "G4ShortLivedTable.hh"
#include "G4PhaseSpaceDecayChannel.hh"
#include "G4VDecayChannel.hh"
#include "G4DecayTable.hh"
@@ -227,9 +226,9 @@ G4double G4VLongitudinalStringDecay::FragmentationMass(
{
G4double mass;
static G4bool NeedInit(true);
static std::vector<double> nomix;
static G4HadronBuilder * minMassHadronizer;
static G4ThreadLocal G4bool NeedInit(true);
static G4ThreadLocal std::vector<double> *nomix_G4MT_TLS_ = 0 ; if (!nomix_G4MT_TLS_) nomix_G4MT_TLS_ = new std::vector<double> ; std::vector<double> &nomix = *nomix_G4MT_TLS_;
static G4ThreadLocal G4HadronBuilder * minMassHadronizer;
if ( NeedInit )
{
NeedInit = false;
@@ -474,7 +473,7 @@ G4ThreeVector G4VLongitudinalStringDecay::SampleQuarkPt(G4double ptMax)
Pt = -std::log(G4UniformRand());
} else {
// sample in limited range
Pt = -std::log(CLHEP::RandFlat::shoot(std::exp(-sqr(ptMax)/sqr(SigmaQT)), 1.));
Pt = -std::log(G4RandFlat::shoot(std::exp(-sqr(ptMax)/sqr(SigmaQT)), 1.));
}
Pt = SigmaQT * std::sqrt(Pt);
G4double phi = 2.*pi*G4UniformRand();
source/processes/hadronic/models/parton_string/management/CMakeLists.txt
+1 -1
View File
@@ -7,7 +7,7 @@
#
# Generated on : 24/9/2010
#
# $Id: CMakeLists.txt,v 1.1 2010-09-29 19:05:09 bmorgan Exp $
# $Id: CMakeLists.txt 66892 2013-01-17 10:57:59Z gunter $
#
#------------------------------------------------------------------------------
source/processes/hadronic/models/parton_string/management/GNUmakefile
+1 -1
View File
@@ -1,4 +1,4 @@
# $Id: GNUmakefile,v 1.2 2003-10-08 15:56:36 hpw Exp $
# $Id: GNUmakefile 66892 2013-01-17 10:57:59Z gunter $
# -----------------------------------------------------------
# GNUmakefile for hadronic library. JPW 2003.
# -----------------------------------------------------------
source/processes/hadronic/models/parton_string/management/History
+23 -1
View File
@@ -1,4 +1,4 @@
$Id: History,v 1.10 2010-11-30 16:11:25 vuzhinsk Exp $
$Id: History 67999 2013-03-13 11:14:32Z gcosmo $
-------------------------------------------------------------------
==========================================================
@@ -14,6 +14,28 @@ code and to keep track of all tags.
---------------------------------------------------------------
* Please list in reverse chronological order (last date on top)
---------------------------------------------------------------
29-Jan-2013 V. Uzhinsky had-partonstring-mgt-V09-06-04
- New attempt to implement nucl-nucl interactions.
16-Jan-2013 V. Uzhinsky had-partonstring-mgt-V09-06-03
- Bug fixing.
10-Jan-2013 V. Uzhinsky had-partonstring-mgt-V09-06-02
- New attempt to implement nucl-nucl interactions.
18-Dec-2012 V. Uzhinsky had-partonstring-mgt-V09-06-01
- Print-out in the previouse tag is closed.
17-Dec-2012 V. Uzhinsky had-partonstring-mgt-V09-06-00
- An interface for a manipulation with nucleus-nucleus interactions was
introduced.
21-Nov-2012 V. Uzhinsky had-partonstring-mgt-V09-05-05
- Bug fixing.
20-Nov-2012 V. Uzhinsky had-partonstring-mgt-V09-05-04
- An interface for a manipulation with nucleus-nucleus interactions was
introduced, especially for treating remnants of projectile nuclei.
27-Sep-2012, G.Cosmo
- Explicitly use inclusion of headers for system of units and physical
source/processes/hadronic/models/parton_string/management/include/G4EventGenerator.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4EventGenerator.hh 67999 2013-03-13 11:14:32Z gcosmo $
//
#ifndef G4EventGenerator_h
#define G4EventGenerator_h 1
source/processes/hadronic/models/parton_string/management/include/G4InteractionCode.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4InteractionCode.hh 67999 2013-03-13 11:14:32Z gcosmo $
//
#ifndef G4InteractionCode_h
#define G4InteractionCode_h 1
source/processes/hadronic/models/parton_string/management/include/G4InteractionContent.hh
+20 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4InteractionContent.hh 67999 2013-03-13 11:14:32Z gcosmo $
//
#ifndef G4InteractionContent_h
@@ -39,6 +39,10 @@
// ------------------------------------------------------------
#include "globals.hh"
#include "G4PhysicalConstants.hh"
#include "G4SystemOfUnits.hh"
#include "G4VSplitableHadron.hh"
#include "G4Nucleon.hh" // Uzhi 16.07.09
@@ -63,6 +67,9 @@ class G4InteractionContent
G4VSplitableHadron * GetProjectile() const ;
G4VSplitableHadron * GetTarget() const;
void SetProjectileNucleon(G4Nucleon * aNucleon); // Uzhi Nov. 2012
G4Nucleon * GetProjectileNucleon() const;
void SetTargetNucleon(G4Nucleon * aNucleon);
G4Nucleon * GetTargetNucleon() const;
@@ -99,6 +106,8 @@ private:
G4VSplitableHadron * theTarget;
G4VSplitableHadron * theProjectile;
G4Nucleon * theProjectileNucleon;
G4Nucleon * theTargetNucleon;
G4int theNumberOfHard;
@@ -127,6 +136,16 @@ inline void G4InteractionContent::SetTarget(G4VSplitableHadron *aTarget)
theTarget = aTarget;
}
inline void G4InteractionContent::SetProjectileNucleon(G4Nucleon * aNucleon)// Uzhi Nov. 2012
{
theProjectileNucleon = aNucleon;
}
inline G4Nucleon * G4InteractionContent::GetProjectileNucleon() const
{
return theProjectileNucleon;
}
inline void G4InteractionContent::SetTargetNucleon(G4Nucleon * aNucleon)
{
theTargetNucleon = aNucleon;
source/processes/hadronic/models/parton_string/management/include/G4PomeronCrossSection.hh
+1 -1
View File
@@ -26,7 +26,7 @@
#ifndef G4PomeronCrossSection_h
#define G4PomeronCrossSection_h 1
//
// $Id$
// $Id: G4PomeronCrossSection.hh 67999 2013-03-13 11:14:32Z gcosmo $
//
#include "G4Proton.hh"
#include "G4Neutron.hh"
source/processes/hadronic/models/parton_string/management/include/G4StringModel.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4StringModel.hh 67999 2013-03-13 11:14:32Z gcosmo $
//
#ifndef G4StringModel_h
#define G4StringModel_h 1
source/processes/hadronic/models/parton_string/management/include/G4VParticipants.hh
+10 -3
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4VParticipants.hh 67999 2013-03-13 11:14:32Z gcosmo $
//
#ifndef G4VParticipants_h
@@ -61,9 +61,12 @@ class G4VParticipants
virtual void SetNucleus(G4V3DNucleus* aNucleus);
virtual G4V3DNucleus* GetWoundedNucleus() const;
// protected: // Uzhi 26 July 09
virtual void InitProjectileNucleus(G4int theZ, G4int theA); // Uzhi Nov. 2012
virtual void SetProjectileNucleus(G4V3DNucleus* aNucleus); // Uzhi Nov. 2012
virtual G4V3DNucleus* GetProjectileNucleus() const; // Uzhi Nov. 2012
G4V3DNucleus* theNucleus;
G4V3DNucleus* theProjectileNucleus; // Uzhi Nov. 2012
private:
};
@@ -75,6 +78,10 @@ inline G4V3DNucleus * G4VParticipants::GetWoundedNucleus() const
return theNucleus;
}
inline G4V3DNucleus * G4VParticipants::GetProjectileNucleus() const // Uzhi Nov. 2012
{
return theProjectileNucleus;
}
#endif
source/processes/hadronic/models/parton_string/management/include/G4VPartonStringModel.hh
+3 -3
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4VPartonStringModel.hh 67999 2013-03-13 11:14:32Z gcosmo $
//
#ifndef G4VPartonStringModel_h
#define G4VPartonStringModel_h 1
@@ -66,8 +66,8 @@ class G4VPartonStringModel : public G4VHighEnergyGenerator
G4KineticTrackVector * Scatter(const G4Nucleus &theNucleus, const G4DynamicParticle &thePrimary);
virtual G4V3DNucleus * GetWoundedNucleus() const = 0;
virtual void ModelDescription(std::ostream& outFile) const;
// virtual G4V3DNucleus * GetProjectileNucleus() const = 0; // Uzhi Nov. 2012
virtual G4V3DNucleus * GetProjectileNucleus() const; // Uzhi Nov. 2012
protected:
virtual void Init(const G4Nucleus &theNucleus, const G4DynamicParticle &thePrimary) = 0;
source/processes/hadronic/models/parton_string/management/include/G4VSplitableHadron.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4VSplitableHadron.hh 67999 2013-03-13 11:14:32Z gcosmo $
//
#ifndef G4VSplitableHadron_h
source/processes/hadronic/models/parton_string/management/include/G4VStringFragmentation.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4VStringFragmentation.hh 67999 2013-03-13 11:14:32Z gcosmo $
//
#ifndef G4VStringFragmentation_h
#define G4VStringFragmentation_h 1
source/processes/hadronic/models/parton_string/management/include/G4VertexCode.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4VertexCode.hh 67999 2013-03-13 11:14:32Z gcosmo $
//
#ifndef G4VertexCode_h
#define G4VertexCode_h 1
source/processes/hadronic/models/parton_string/management/sources.cmake
+1 -1
View File
@@ -11,7 +11,7 @@
#
# Generated on : 24/9/2010
#
# $Id: sources.cmake,v 1.1 2010-09-29 19:05:17 bmorgan Exp $
# $Id: sources.cmake 66892 2013-01-17 10:57:59Z gunter $
#
#------------------------------------------------------------------------------
source/processes/hadronic/models/parton_string/management/src/G4EventGenerator.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4EventGenerator.cc 67999 2013-03-13 11:14:32Z gcosmo $
//
// G4EventGenerator
source/processes/hadronic/models/parton_string/management/src/G4InteractionContent.cc
+5 -2
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4InteractionContent.cc 67999 2013-03-13 11:14:32Z gcosmo $
//
// ------------------------------------------------------------
// GEANT 4 class implementation file
@@ -42,6 +42,7 @@ G4InteractionContent::G4InteractionContent(G4VSplitableHadron *aPrimaryParticipa
{
theProjectile=aPrimaryParticipant;
theTarget=0;
theProjectileNucleon=0; // Uzhi Nov. 2012
theTargetNucleon=0;
}
@@ -51,7 +52,9 @@ G4InteractionContent::~G4InteractionContent()
G4bool G4InteractionContent::operator<(const G4InteractionContent &right) const
{
return this->GetInteractionTime() < right.GetInteractionTime();
G4cout<<this->GetInteractionTime()/fermi<<" "<<right.GetInteractionTime()/fermi<<G4endl;
return this->GetInteractionTime() < right.GetInteractionTime();
// return right.GetInteractionTime() < this->GetInteractionTime();
}
void G4InteractionContent::SetInteractionTime(G4double aValue)
source/processes/hadronic/models/parton_string/management/src/G4PomeronCrossSection.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4PomeronCrossSection.cc 67999 2013-03-13 11:14:32Z gcosmo $
//
#include "G4PomeronCrossSection.hh"
source/processes/hadronic/models/parton_string/management/src/G4StringModel.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4StringModel.cc 67999 2013-03-13 11:14:32Z gcosmo $
//
// G4StringModel
#include "G4StringModel.hh"
source/processes/hadronic/models/parton_string/management/src/G4VParticipants.cc
+18 -2
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4VParticipants.cc 67999 2013-03-13 11:14:32Z gcosmo $
//
// ------------------------------------------------------------
// GEANT 4 class implementation file
@@ -41,7 +41,8 @@
#include "G4Fancy3DNucleus.hh"
G4VParticipants::G4VParticipants() : theNucleus(NULL)
G4VParticipants::G4VParticipants() : theNucleus(NULL),
theProjectileNucleus(NULL) // Uzhi Nov. 2012
{}
@@ -49,6 +50,7 @@ G4VParticipants::~G4VParticipants()
{
// G4cout << "G4VParticipants::~G4VParticipants()" << G4endl;
if ( theNucleus != NULL ) delete theNucleus;
if ( theProjectileNucleus != NULL ) delete theProjectileNucleus; // Uzhi Nov. 2012
}
@@ -65,3 +67,17 @@ inline void G4VParticipants::SetNucleus(G4V3DNucleus * aNucleus)
if (theNucleus != NULL) delete theNucleus;
theNucleus = aNucleus;
}
inline void G4VParticipants::InitProjectileNucleus(G4int theA, G4int theZ) // Uzhi Nov. 2012
{
if ( theProjectileNucleus == NULL ) theProjectileNucleus = new G4Fancy3DNucleus();
theProjectileNucleus->Init(theA, theZ);
theProjectileNucleus->SortNucleonsDecZ();
}
inline void G4VParticipants::SetProjectileNucleus(G4V3DNucleus * aNucleus)
{
if (theProjectileNucleus != NULL) delete theProjectileNucleus;
theProjectileNucleus = aNucleus;
}
source/processes/hadronic/models/parton_string/management/src/G4VPartonStringModel.cc
+58 -18
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4VPartonStringModel.cc 67999 2013-03-13 11:14:32Z gcosmo $
//
//// ------------------------------------------------------------
// GEANT 4 class implementation file
@@ -44,6 +44,7 @@
#include "G4ParticleTable.hh"
#include "G4IonTable.hh"
//#define debug_PartonStringModel
G4VPartonStringModel::G4VPartonStringModel(const G4String& modelName)
: G4VHighEnergyGenerator(modelName),
@@ -65,6 +66,15 @@ G4KineticTrackVector * G4VPartonStringModel::Scatter(const G4Nucleus &theNucleus
G4ExcitedStringVector * strings = NULL;
G4DynamicParticle thePrimary=aPrimary;
#ifdef debug_PartonStringModel
G4cout<<"Parton-String model is runnung ------------"<<G4endl;
G4cout<<"Projectile Name Mass "<<thePrimary.GetDefinition()->GetParticleName()<<" "
<<thePrimary.GetMass()<<G4endl;
G4cout<<" Momentum "<<thePrimary.Get4Momentum()<<G4endl;
G4cout<<"Target nucleus A Z "<<theNucleus.GetA_asInt()<<" "
<<theNucleus.GetZ_asInt()<<G4endl<<G4endl;
#endif
G4LorentzRotation toZ;
G4LorentzVector Ptmp=thePrimary.Get4Momentum();
@@ -78,9 +88,9 @@ G4KineticTrackVector * G4VPartonStringModel::Scatter(const G4Nucleus &theNucleus
{
if (attempts++ > maxAttempts )
{
throw G4HadronicException(__FILE__, __LINE__, "G4VPartonStringModel::Scatter(): fails to generate strings");
throw G4HadronicException(__FILE__, __LINE__,
"G4VPartonStringModel::Scatter(): fails to generate strings");
}
theThis->Init(theNucleus,thePrimary);
strings = GetStrings();
@@ -89,6 +99,10 @@ G4KineticTrackVector * G4VPartonStringModel::Scatter(const G4Nucleus &theNucleus
G4double stringEnergy(0);
G4LorentzVector SumStringMom(0.,0.,0.,0.);
#ifdef debug_PartonStringModel
G4cout<<"Parton-String model: Number of produced strings "<<strings->size()<<G4endl;
#endif
for ( unsigned int astring=0; astring < strings->size(); astring++)
{
// rotate string to lab frame, models have it aligned to z
@@ -100,15 +114,16 @@ G4KineticTrackVector * G4VPartonStringModel::Scatter(const G4Nucleus &theNucleus
G4double InvMass=SumStringMom.mag();
//#define debug_PartonStringModel
#ifdef debug_PartonStringModel
G4cout<<"Parton-String model: SumStringMom "<<SumStringMom<<G4endl;
G4V3DNucleus * fancynucleus=theThis->GetWoundedNucleus();
// loop over wounded nucleus
G4int hits(0), charged_hits(0);
G4ThreeVector hitNucleonMomentum(0.,0.,0.);
G4Nucleon * theCurrentNucleon = fancynucleus->StartLoop() ? fancynucleus->GetNextNucleon() : NULL;
G4Nucleon * theCurrentNucleon = fancynucleus->StartLoop() ?
fancynucleus->GetNextNucleon() : NULL;
while( theCurrentNucleon )
{
if(theCurrentNucleon->AreYouHit())
@@ -122,12 +137,23 @@ G4KineticTrackVector * G4VPartonStringModel::Scatter(const G4Nucleus &theNucleus
G4int initialZ=fancynucleus->GetCharge();
G4int initialA=fancynucleus->GetMassNumber();
G4double initial_mass=G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(initialZ,initialA);
G4double final_mass = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(initialZ-charged_hits, initialA-hits);
G4cout << "G4VPSM: strE, hit nucleons, Primary, SumStringE, nucleus intial, nucleus final, excitation estimate "
<< stringEnergy << " " << hits << ", " << Ptmp.e() << ", "<< SumStringMom.e() << ", "
<< initial_mass<< ", " << final_mass<< ", " << Ptmp.e() + initial_mass - final_mass - stringEnergy << G4endl;
G4cout << "momentum balance " << thePrimary.GetMomentum() + hitNucleonMomentum - SumStringMom.vect()<< G4endl;
G4double initial_mass=
G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(initialZ,initialA);
G4double final_mass =
G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(
initialZ-charged_hits, initialA-hits);
G4cout << "G4VPSM: " <<G4endl
<< "strE "<<stringEnergy <<G4endl
<< "hit nucleons "<<hits <<G4endl
<< "Primary "<<Ptmp.e() <<G4endl
<< "SumStringE "<<SumStringMom.e() <<G4endl
<< "Nucleus intial "<<initial_mass <<G4endl
<< "Nucleus final "<<final_mass <<G4endl
<< "Excitation estimate "
<<Ptmp.e() + initial_mass - final_mass - stringEnergy << G4endl;
G4cout << "momentum balance "
<< thePrimary.GetMomentum() + hitNucleonMomentum -
SumStringMom.vect()<< G4endl;
#endif
// Fragment strings
@@ -147,24 +173,35 @@ G4KineticTrackVector * G4VPartonStringModel::Scatter(const G4Nucleus &theNucleus
theResult = stringFragmentationModel->FragmentStrings(strings);
if(attempts > maxAttempts ) break;
//G4cout<<"G4endl<<"G4VPartonStringModel:: Final Result, Size "<<theResult->size()<<G4endl;
#ifdef debug_PartonStringModel
G4cout<<"Parton-String model: Number of produced particles "<<theResult->size()<<G4endl;
G4LorentzVector SumPsecondr(0.,0.,0.,0.);
#endif
SumMass=0.;
//G4LorentzVector SumP(0.,0.,0.,0.);
for ( unsigned int i=0; i < theResult->size(); i++)
{
SumMass+=(*theResult)[i]->GetDefinition()->GetPDGMass();
//SumP+=(*theResult)[i]->Get4Momentum();
//G4cout<<i<<" : "<<(*theResult)[i]->GetDefinition()->GetParticleName();
//G4cout<<"p= " << (*theResult)[i]->Get4Momentum()<<" m= "<<(*theResult)[i]->Get4Momentum().mag()<<G4endl;
#ifdef debug_PartonStringModel
G4cout<<i<<" : "<<(*theResult)[i]->GetDefinition()->GetParticleName()<<" "
<<(*theResult)[i]->Get4Momentum()<<" "
<<(*theResult)[i]->Get4Momentum().mag()<<G4endl;
SumPsecondr+=(*theResult)[i]->Get4Momentum();
#endif
}
//G4cout<<"SumP "<<SumP<<G4endl;
#ifdef debug_PartonStringModel
G4cout<<"SumP secondaries "<<SumPsecondr<<G4endl;
#endif
} while(SumMass > InvMass);
std::for_each(strings->begin(), strings->end(), DeleteString() );
delete strings;
#ifdef debug_PartonStringModel
G4cout<<"End of string model work ------------"<<G4endl<<G4endl;
#endif
return theResult;
}
@@ -172,3 +209,6 @@ void G4VPartonStringModel::ModelDescription(std::ostream& outFile) const
{
outFile << GetModelName() << " has no description yet.\n";
}
G4V3DNucleus * G4VPartonStringModel::GetProjectileNucleus() const // Uzhi Jan. 2013
{ return 0;}
source/processes/hadronic/models/parton_string/management/src/G4VSplitableHadron.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4VSplitableHadron.cc 67999 2013-03-13 11:14:32Z gcosmo $
//
// ------------------------------------------------------------
source/processes/hadronic/models/parton_string/management/src/G4VStringFragmentation.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4VStringFragmentation.cc 67999 2013-03-13 11:14:32Z gcosmo $
//
// G4VStringFragmentation
#include "G4VStringFragmentation.hh"
source/processes/hadronic/models/parton_string/qgsm/CMakeLists.txt
+1 -1
View File
@@ -7,7 +7,7 @@
#
# Generated on : 24/9/2010
#
# $Id: CMakeLists.txt,v 1.1 2010-09-29 19:05:25 bmorgan Exp $
# $Id: CMakeLists.txt 66892 2013-01-17 10:57:59Z gunter $
#
#------------------------------------------------------------------------------
source/processes/hadronic/models/parton_string/qgsm/GNUmakefile
+1 -1
View File
@@ -1,4 +1,4 @@
# $Id: GNUmakefile,v 1.2 2003-10-08 16:42:21 hpw Exp $
# $Id: GNUmakefile 66892 2013-01-17 10:57:59Z gunter $
# -----------------------------------------------------------
# GNUmakefile for hadronic library. Gabriele Cosmo, 18/9/96.
# -----------------------------------------------------------
source/processes/hadronic/models/parton_string/qgsm/History
+13 -1
View File
@@ -1,4 +1,4 @@
$Id: History,v 1.10 2010-09-08 15:51:28 gunter Exp $
$Id: History 69570 2013-05-08 13:23:39Z gcosmo $
-------------------------------------------------------------------
==========================================================
@@ -14,6 +14,18 @@ code and to keep track of all tags.
---------------------------------------------------------------
* Please list in reverse chronological order (last date on top)
02 May 2013 Alberto Ribon (hadr-qgsm-V09-06-00)
--------------------------------------------------
- For thread safety, replaced CLHEP::RandFlat with G4RandFlat in
G4QGSMSplitableHadron.cc.
20 November 2012 V. Uzhinsky (hadr-qgsm-V09-05-04)
--------------------------------------------------
- An interface for a manipulation with nucleus-nucleus interactions was
introduced, especially for treating remnants of projectile nuclei.
27 September 2012, Gabriele Cosmo
--------------------------------------------------
- Explicitly use inclusion of headers for system of units and physical
source/processes/hadronic/models/parton_string/qgsm/include/G4QGSDiffractiveExcitation.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4QGSDiffractiveExcitation.hh 69570 2013-05-08 13:23:39Z gcosmo $
#ifndef G4QGSDiffractiveExcitation_h
#define G4QGSDiffractiveExcitation_h 1
source/processes/hadronic/models/parton_string/qgsm/include/G4QGSModel.hh
+1
View File
@@ -64,6 +64,7 @@ public:
// Method
public:
virtual G4V3DNucleus* GetWoundedNucleus() const;
virtual G4V3DNucleus* GetProjectileNucleus() const; // Uzhi Nov. 2012
virtual void Init(const G4Nucleus& Nucleus, const G4DynamicParticle& Projectile);
virtual G4ExcitedStringVector * GetStrings();
virtual void ModelDescription(std::ostream& outFile) const;
source/processes/hadronic/models/parton_string/qgsm/include/G4QGSModel.icc
+6
View File
@@ -134,6 +134,12 @@ G4V3DNucleus* G4QGSModel<ParticipantType>::GetWoundedNucleus() const
return theParticipants.GetWoundedNucleus();
}
template<class ParticipantType> // Uzhi Nov. 2012
G4V3DNucleus* G4QGSModel<ParticipantType>::GetProjectileNucleus() const
{
return 0;
}
template<class ParticipantType>
void G4QGSModel<ParticipantType>::ModelDescription(std::ostream& outFile) const
{
source/processes/hadronic/models/parton_string/qgsm/include/G4SingleDiffractiveExcitation.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4SingleDiffractiveExcitation.hh 69570 2013-05-08 13:23:39Z gcosmo $
#ifndef G4SingleDiffractiveExcitation_h
#define G4SingleDiffractiveExcitation_h 1
source/processes/hadronic/models/parton_string/qgsm/sources.cmake
+1 -1
View File
@@ -11,7 +11,7 @@
#
# Generated on : 24/9/2010
#
# $Id: sources.cmake,v 1.1 2010-09-29 19:05:33 bmorgan Exp $
# $Id: sources.cmake 66892 2013-01-17 10:57:59Z gunter $
#
#------------------------------------------------------------------------------
source/processes/hadronic/models/parton_string/qgsm/src/G4QGSDiffractiveExcitation.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4QGSDiffractiveExcitation.cc 69570 2013-05-08 13:23:39Z gcosmo $
// ------------------------------------------------------------
// GEANT 4 class implemetation file
//
source/processes/hadronic/models/parton_string/qgsm/src/G4QGSMSplitableHadron.cc
+1 -1
View File
@@ -418,7 +418,7 @@ SampleX(G4double anXmin, G4int nSea, G4int totalSea, G4double aBeta)
}
do
{
x1 = CLHEP::RandFlat::shoot(anXmin, xMax);
x1 = G4RandFlat::shoot(anXmin, xMax);
y = std::pow(x1, alpha);
y *= std::pow( std::pow(1-x1-totalSea*anXmin, alpha+1) - std::pow(anXmin, alpha+1), nSea);
y *= std::pow(1-x1-totalSea*anXmin, aBeta+1) - std::pow(anXmin, aBeta+1);
source/processes/hadronic/models/parton_string/qgsm/src/G4QGSParticipants.cc
+1 -1
View File
@@ -34,7 +34,7 @@
// HPW Feb 1999
// Promoting model parameters from local variables class properties
G4int G4QGSParticipants_NPart = 0;
G4ThreadLocal G4int G4QGSParticipants_NPart = 0;
G4QGSParticipants::G4QGSParticipants() : theDiffExcitaton(), //0.7*GeV, 250*MeV, 250*MeV),
ModelMode(SOFT),
source/processes/hadronic/models/parton_string/qgsm/src/G4SingleDiffractiveExcitation.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id$
// $Id: G4SingleDiffractiveExcitation.cc 69570 2013-05-08 13:23:39Z gcosmo $
// ------------------------------------------------------------
// GEANT 4 class implemetation file
//