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

Import Geant4 9.0.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-09 15:16:48 +02:00
parent 75c7fd177d
commit a8e9364cea
6592 changed files with 84274 additions and 69292 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4ElectroNuclearReaction.hh
+1 -1
View File
@@ -26,7 +26,7 @@
//
//
// $Id: G4ElectroNuclearReaction.hh,v 1.23 2006/06/29 20:07:46 gunter Exp $
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// GEANT4 physics class: G4ElectroNuclearReaction -- header file
source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4GammaNuclearReaction.hh
+1 -1
View File
@@ -25,7 +25,7 @@
//
//
// $Id: G4GammaNuclearReaction.hh,v 1.13 2006/06/29 20:07:48 gunter Exp $
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// GEANT4 physics class: G4GammaNuclearReaction -- header file
source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4QANuMuNuclearCrossSection.hh
+1 -1
View File
@@ -25,7 +25,7 @@
//
//
// $Id: G4QANuMuNuclearCrossSection.hh,v 1.6 2006/12/01 10:57:46 mkossov Exp $
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// GEANT4 physics class: G4QANuMuNuclearCrossSection -- header file
source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4QAtomicElectronScattering.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
// $Id: G4QAtomicElectronScattering.hh,v 1.2 2006/12/13 15:45:16 gunter Exp $
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
// ---------------- G4QAtomicElectronScattering header ----------------
// by Mikhail Kossov, December 2003.
source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4QCaptureAtRest.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
// $Id: G4QCaptureAtRest.hh,v 1.3 2007/02/09 09:33:28 mkossov Exp $
// GEANT4 tag $Name: geant4-08-03 $
// GEANT4 tag $Name: geant4-09-00 $
//
// ---------------- G4QCaptureAtRest header ----------------
// by Mikhail Kossov, December 2003.
source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4QCoherentChargeExchange.hh
+131
View File
@@ -0,0 +1,131 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QCoherentChargeExchange.hh,v 1.3 2007/05/23 15:14:25 mkossov Exp $
// GEANT4 tag $Name: geant4-09-00 $
//
// ---------------- G4QCoherentChargeExchange header ----------------
// by Mikhail Kossov, December 2003.
// Header of G4QCoherentChargeExchange class (hadron+A) of the CHIPS Simulation Branch in GEANT4
// -------------------------------------------------------------------------------
// This is a unique CHIPS class for the Hadron-Nuclear Elastic Scattering Prosesses
// -------------------------------------------------------------------------------
// At present (Jan-06) only proton-proton scattering is implemented The interaction with
// nuclei are planned only. The scattering of nuclei on nuclei are possible...
// The simulation is based on the CHIPS approximation of total elastic and differential
// elastic cross sections from E=0 to the highest energyes.
// -------------------------------------------------------------------------------
#ifndef G4QCoherentChargeExchange_hh
#define G4QCoherentChargeExchange_hh
// GEANT4 Headers
#include "globals.hh"
#include "G4ios.hh"
#include "Randomize.hh"
#include "G4VDiscreteProcess.hh"
#include "G4Track.hh"
#include "G4Step.hh"
#include "G4ParticleTypes.hh"
#include "G4VParticleChange.hh"
#include "G4ParticleDefinition.hh"
#include "G4DynamicParticle.hh"
#include "G4NucleiPropertiesTable.hh"
#include "G4ThreeVector.hh"
#include "G4LorentzVector.hh"
// CHIPS Headers
#include "G4QElasticCrossSection.hh"
#include "G4QIsotope.hh"
#include "G4QPDGToG4Particle.hh"
#include "G4QCHIPSWorld.hh"
#include "G4QHadron.hh"
#include <vector>
class G4QCoherentChargeExchange : public G4VDiscreteProcess
{
public:
// Constructor
G4QCoherentChargeExchange(const G4String& processName ="CHIPS_CoherChargeExScattering");
// Destructor
~G4QCoherentChargeExchange();
G4bool IsApplicable(const G4ParticleDefinition& particle);
G4double GetMeanFreePath(const G4Track& aTrack, G4double previousStepSize,
G4ForceCondition* condition);
// It returns the MeanFreePath of the process for the current track :
// (energy, material)
// The previousStepSize and G4ForceCondition* are not used.
// This function overloads a virtual function of the base class.
// It is invoked by the ProcessManager of the Particle.
G4VParticleChange* PostStepDoIt(const G4Track& aTrack, const G4Step& aStep);
// It computes the final state of the process (at end of step),
// returned as a ParticleChange object.
// This function overloads a virtual function of the base class.
// It is invoked by the ProcessManager of the Particle.
G4LorentzVector GetEnegryMomentumConservation();
G4int GetNumberOfNeutronsInTarget();
private:
// Hide assignment operator as private
G4QCoherentChargeExchange& operator=(const G4QCoherentChargeExchange &right);
// Copy constructor
G4QCoherentChargeExchange(const G4QCoherentChargeExchange&);
// Calculate XS/t: oxs=true - only CS; xst=true - calculate XS, xst=false(oxs=f/t) - t/tm
G4double CalculateXSt(G4bool oxs, G4bool xst, G4double p, G4int Z, G4int N, G4int pPDG);
// Calculate ChEx/El suppression coefficient
G4double ChExElCoef(G4double p, G4int Z, G4int N, G4int pPDG);
// BODY
// Static Parameters --------------------------------------------------------------------
static G4int nPartCWorld; // The#of particles for hadronization (limit of A of fragm.)
//--------------------------------- End of static parameters ---------------------------
// Working parameters
G4VQCrossSection* theCS;
G4LorentzVector EnMomConservation; // Residual of Energy/Momentum Cons.
G4int nOfNeutrons; // #of neutrons in the target nucleus
// Modifires for the reaction
G4double Time; // Time shift of the capture reaction
G4double EnergyDeposition; // Energy deposited in the reaction
static std::vector <G4int> ElementZ; // Z of the element(i) in theLastCalc
static std::vector <G4double> ElProbInMat; // SumProbabilityElements in Material
static std::vector <std::vector<G4int>*> ElIsoN; // N of isotope(j) of Element(i)
static std::vector <std::vector<G4double>*> IsoProbInEl;// SumProbabIsotopes in Element i
};
#endif
source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4QCollision.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
// $Id: G4QCollision.hh,v 1.7 2006/10/30 10:33:36 mkossov Exp $
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
// ---------------- G4QCollision header ----------------
// by Mikhail Kossov, December 2003.
source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4QDiffractionRatio.hh
+82
View File
@@ -0,0 +1,82 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// GEANT4 tag $Name: geant4-09-00 $
//
//
// GEANT4 physics class: G4QDiffractionRatio -- header file
// M.V. Kossov, ITEP(Moscow), 24-OCT-01
// The last update: M.V. Kossov, CERN/ITEP (Moscow) 15-Oct-2006
//
#ifndef G4QDiffractionRatio_h
#define G4QDiffractionRatio_h 1
#include "globals.hh"
#include "G4ios.hh"
#include "Randomize.hh"
#include <vector>
//#include "G4DynamicParticle.hh"
//#include "G4Element.hh"
//#include "G4ParticleTable.hh"
//#include "G4NucleiProperties.hh"
//#include "G4NucleiPropertiesTable.hh"
#include "G4QPDGCode.hh"
#include "G4Quasmon.hh"
#include "G4QHadronVector.hh"
#include "G4VCrossSectionDataSet.hh"
#include "G4QElasticCrossSection.hh"
#include "G4RandomDirection.hh"
class G4QDiffractionRatio
{
protected:
G4QDiffractionRatio() {} // Constructor
public:
~G4QDiffractionRatio() {} // Destructor
static G4QDiffractionRatio* GetPointer(); // Gives a pointer to this singletone
// Diffraction/Prodaction Ratio (Production=Inelastic-QuasiElastic)
G4double GetRatio(G4double pIU, G4int prPDG, G4int tgZ, G4int tgN);
// ==> The following ill be a protected function for internal CHIPS usage
// Fragment(pPDG,p4M) on a nucleus (tgZ, tgN), result: Vector of secondary hadrons
// Whoeve uses this member function is responsible for DEL/DESTROY of the G4QHadronVector
G4QHadronVector* Fragment(G4int pPDG, G4LorentzVector p4M, G4int tgZ, G4int tgN);
private:
// These working member functions are in CHIPS units and must not be used externally
G4double CalcDiff2Prod_Ratio(G4double s, G4int A); // R=Diff/Prod (sqrt(s)(hN) in GeV, A)
// Body
private:
};
#endif
source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4QElastic.hh
+5 -2
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QElastic.hh,v 1.2 2006/06/29 20:08:04 gunter Exp $
// GEANT4 tag $Name: geant4-08-02 $
// $Id: G4QElastic.hh,v 1.3 2007/05/23 15:14:25 mkossov Exp $
// GEANT4 tag $Name: geant4-09-00 $
//
// ---------------- G4QElastic header ----------------
// by Mikhail Kossov, December 2003.
@@ -104,6 +104,9 @@ private:
// Copy constructor
G4QElastic(const G4QElastic&);
// Calculate XS/t: oxs=true - only CS; xst=true - calculate XS, xst=false(oxs=f/t) - t/tm
G4double CalculateXSt(G4bool oxs, G4bool xst, G4double p, G4int Z, G4int N, G4int pPDG);
// BODY
// Static Parameters --------------------------------------------------------------------
static G4int nPartCWorld; // The#of particles for hadronization (limit of A of fragm.)
source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4QElasticCrossSection.hh
+22 -4
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// GEANT4 physics class: G4QElasticCrossSection -- header file
@@ -48,16 +48,19 @@
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4VQCrossSection.hh"
#include "G4QElastic.hh"
#include "G4QCoherentChargeExchange.hh"
#include "G4QuasiFreeRatios.hh"
class G4QElasticCrossSection : public G4VQCrossSection
{
protected:
G4QElasticCrossSection() {} // Constructor
G4QElasticCrossSection(); // Constructor
public:
~G4QElasticCrossSection() {}
~G4QElasticCrossSection();
static G4VQCrossSection* GetPointer(); // Gives a pointer to this singletone
@@ -67,7 +70,10 @@ public:
G4double CalculateCrossSection(G4bool CS, G4int F, G4int I, G4int pPDG, G4int Z, G4int N,
G4double pP);
protected:
friend class G4QElastic;
friend class G4QCoherentChargeExchange;
friend class G4QuasiFreeRatios;
G4double GetExchangeT(G4int tZ, G4int tN, G4int pPDG); // Randomizes -t=Q2 (in IU=MeV^2)
G4double GetHMaxT(); // Currrent Max(-t=Q2)/2. (in IU=MeV^2)
@@ -120,5 +126,17 @@ private:
static G4double* lastB3T; // E-dep of the slope of the third difruction
static G4double* lastS4T; // E-dep of mantissa of the 4-th difruction
static G4double* lastB4T; // E-dep of the slope of the 4-th difruction
static std::vector <G4double*> PAR; // Vector of parameters for functional calculations
static std::vector <G4double*> CST; // Vector of cross-section table
static std::vector <G4double*> SST; // Vector of the first squared slope
static std::vector <G4double*> S1T; // Vector of the first mantissa
static std::vector <G4double*> B1T; // Vector of the first slope
static std::vector <G4double*> S2T; // Vector of the secon mantissa
static std::vector <G4double*> B2T; // Vector of the second slope
static std::vector <G4double*> S3T; // Vector of the third mantissa
static std::vector <G4double*> B3T; // Vector of the third slope
static std::vector <G4double*> S4T; // Vector of the 4-th mantissa (gloria)
static std::vector <G4double*> B4T; // Vector of the 4-th slope (gloria)
};
#endif
source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4QElectronNuclearCrossSection.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// GEANT4 physics class: G4QElectronNuclearCrossSection -- header file
source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4QGluonString.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
// $Id: G4QGluonString.hh,v 1.1 2006/10/30 10:33:38 mkossov Exp $
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
// ---------------- G4QGluonString header ----------------
// by Mikhail Kossov, October 2006.
source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4QMuonNuclearCrossSection.hh
+1 -1
View File
@@ -25,7 +25,7 @@
//
//
// $Id: G4QMuonNuclearCrossSection.hh,v 1.5 2006/12/01 10:57:46 mkossov Exp $
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// GEANT4 physics class: G4QMuonNuclearCrossSection -- header file
source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4QNuMuNuclearCrossSection.hh
+1 -1
View File
@@ -25,7 +25,7 @@
//
//
// $Id: G4QNuMuNuclearCrossSection.hh,v 1.6 2006/12/01 10:57:46 mkossov Exp $
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// GEANT4 physics class: G4QNuMuNuclearCrossSection -- header file
source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4QPhotonNuclearCrossSection.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// GEANT4 physics class: G4QPhotonNuclearCrossSection -- header file
source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4QProtonNuclearCrossSection.hh
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// GEANT4 physics class: G4QProtonNuclearCrossSection -- header file
source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4QTauNuclearCrossSection.hh
+1 -1
View File
@@ -25,7 +25,7 @@
//
//
// $Id: G4QTauNuclearCrossSection.hh,v 1.5 2006/12/01 10:57:46 mkossov Exp $
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// GEANT4 physics class: G4QTauNuclearCrossSection -- header file
source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4QuasiFreeRatios.hh
+16 -3
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// GEANT4 tag $Name: geant4-08-03 $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// GEANT4 physics class: G4QuasiFreeRatios -- header file
@@ -54,20 +54,29 @@ class G4QuasiFreeRatios
{
protected:
G4QuasiFreeRatios() {} // Constructor
G4QuasiFreeRatios(); // Constructor
public:
~G4QuasiFreeRatios() {} // Destructor
~G4QuasiFreeRatios(); // Destructor
static G4QuasiFreeRatios* GetPointer(); // Gives a pointer to this singletone
// Pair(QuasiFree/Inelastic,QuasiElastic/QuasiFree)
std::pair<G4double,G4double> GetRatios(G4double pIU, G4int prPDG, G4int tgZ, G4int tgN);
// ChargeExchange/QuasiElastic factor pair<for protons (Z), for neutrons(N)>
std::pair<G4double,G4double> GetChExFactor(G4double pIU, G4int pPDG, G4int Z, G4int N);
// scatter (pPDG,p4M) on a virtual nucleon (NPDG,N4M), result: final pair(newN4M,newp4M)
// if(newN4M.e()==0.) - below threshold, XS=0, no scattering of the progectile happened
std::pair<G4LorentzVector,G4LorentzVector> Scatter(G4int NPDG, G4LorentzVector N4M,
G4int pPDG, G4LorentzVector p4M);
// ChExer (pPDG,p4M) on a virtual nucleon (NPDG,N4M), result: final pair(newN4M,newp4M)
// if(newN4M.e()==0.) - keep projectile, XS=0, no interaction of the progectile happened
// User should himself change the charge (PDG) (e.g. pn->np, pi+n->pi0p, pi-p->pi0n etc.)
// Recepy: change target n to p or taget p to n and conserve enrgy, changing projectile
// Do not use for the nucleon, as it is already included in quasielastic, and for pi0.
std::pair<G4LorentzVector,G4LorentzVector> ChExer(G4int NPDG, G4LorentzVector N4M,
G4int pPDG, G4LorentzVector p4M);
// Mean hN El and Tot XS(IU) for the isotopic (Z,N): on p -> (Z=1,N=0), on n -> (Z=0,N=1)
std::pair<G4double,G4double> GetElTot(G4double pIU, G4int hPDG, G4int Z, G4int N); //(IU)
@@ -80,5 +89,9 @@ class G4QuasiFreeRatios
// Body
private:
static std::vector<G4double*> vE; // Vector of ElastPointers to LogTable
static std::vector<G4double*> vT; // Vector of pointers to LinTable
static std::vector<G4double*> vL; // Vector of pointers to LogTable
static std::vector<std::pair<G4double,G4double>*> vX; // Vector of ETPointers to LogTable
};
#endif
source/processes/hadronic/models/chiral_inv_phase_space/interface/include/G4VQCrossSection.hh
+1 -1
View File
@@ -25,7 +25,7 @@
//
//
// $Id: G4VQCrossSection.hh,v 1.8 2006/12/09 14:33:35 mkossov Exp $
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// GEANT4 virtual class: G4VQCrossSection -- header file
source/processes/hadronic/models/chiral_inv_phase_space/interface/src/G4QANuMuNuclearCrossSection.cc
+1 -1
View File
@@ -25,7 +25,7 @@
//
//
// $Id: G4QANuMuNuclearCrossSection.cc,v 1.9 2006/12/01 10:57:46 mkossov Exp $
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// G4 Physics class: G4QANuMuNuclearCrossSection for gamma+A cross sections
source/processes/hadronic/models/chiral_inv_phase_space/interface/src/G4QAtomicElectronScattering.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
// $Id: G4QAtomicElectronScattering.cc,v 1.2 2006/12/13 15:45:19 gunter Exp $
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
// ---------------- G4QAtomicElectronScattering class -----------------
// by Mikhail Kossov, December 2003.
source/processes/hadronic/models/chiral_inv_phase_space/interface/src/G4QCaptureAtRest.cc
+3 -3
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QCaptureAtRest.cc,v 1.11 2007/03/09 10:07:35 mkossov Exp $
// GEANT4 tag $Name: geant4-08-03 $
// $Id: G4QCaptureAtRest.cc,v 1.12 2007/04/20 15:50:56 mkossov Exp $
// GEANT4 tag $Name: geant4-09-00 $
//
// ---------------- G4QCaptureAtRest class -----------------
// by Mikhail Kossov, December 2003.
@@ -701,7 +701,7 @@ G4VParticleChange* G4QCaptureAtRest::AtRestDoIt(const G4Track& track, const G4St
cascT->push_back(aNewTrack);
}
// ----- Ericson mu to pi conversion ----- ????? -----
if(G4UniformRand()<.025) // .025 is a parameter !
if(G4UniformRand()<.04) // .04 is a parameter !
{
projPDG=-211;
// Phase space decay of mu->nu+q+aq M=1
source/processes/hadronic/models/chiral_inv_phase_space/interface/src/G4QCoherentChargeExchange.cc
+599
View File
@@ -0,0 +1,599 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QCoherentChargeExchange.cc,v 1.3 2007/05/23 15:14:25 mkossov Exp $
// GEANT4 tag $Name: geant4-09-00 $
//
// ---------------- G4QCoherentChargeExchange class -----------------
// by Mikhail Kossov, December 2003.
// G4QCoherentChargeExchange class of the CHIPS Simulation Branch in GEANT4
// ---------------------------------------------------------------
// ****************************************************************************************
// ********** This CLASS is temporary moved from the photolepton_hadron directory *********
// ****************************************************************************************
//#define debug
//#define pdebug
//#define tdebug
//#define nandebug
//#define ppdebug
#include "G4QCoherentChargeExchange.hh"
// Initialization of static vectors
G4int G4QCoherentChargeExchange::nPartCWorld=152; // #of particles initialized in CHIPS
std::vector<G4int> G4QCoherentChargeExchange::ElementZ; // Z of element(i) in theLastCalc
std::vector<G4double> G4QCoherentChargeExchange::ElProbInMat; // SumProbOfElem in Material
std::vector<std::vector<G4int>*> G4QCoherentChargeExchange::ElIsoN;// N of isotope(j), E(i)
std::vector<std::vector<G4double>*>G4QCoherentChargeExchange::IsoProbInEl;//SumProbIsotE(i)
// Constructor
G4QCoherentChargeExchange::G4QCoherentChargeExchange(const G4String& processName)
: G4VDiscreteProcess(processName)
{
#ifdef debug
G4cout<<"G4QCohChargeEx::Constructor is called processName="<<processName<<G4endl;
#endif
if (verboseLevel>0) G4cout << GetProcessName() << " process is created "<< G4endl;
//G4QCHIPSWorld::Get()->GetParticles(nPartCWorld); // Create CHIPS World (234 part. max)
}
// Destructor
G4QCoherentChargeExchange::~G4QCoherentChargeExchange() {}
G4LorentzVector G4QCoherentChargeExchange::GetEnegryMomentumConservation()
{return EnMomConservation;}
G4int G4QCoherentChargeExchange::GetNumberOfNeutronsInTarget() {return nOfNeutrons;}
// output of the function must be in units of length! L=1/sig_V,sig_V=SUM(n(j,i)*sig(j,i)),
// where n(i,j) is a number of nuclei of the isotop j of the element i in V=1(lengtUnit^3)
// ********** All CHIPS cross sections are calculated in the surface units ************
G4double G4QCoherentChargeExchange::GetMeanFreePath(const G4Track& aTrack,G4double Q,
G4ForceCondition* Fc)
{
*Fc = NotForced;
const G4DynamicParticle* incidentParticle = aTrack.GetDynamicParticle();
G4ParticleDefinition* incidentParticleDefinition=incidentParticle->GetDefinition();
if( !IsApplicable(*incidentParticleDefinition))
G4cout<<"*W*G4QCohChargeEx::GetMeanFreePath called for notImplementedParticle"<<G4endl;
// Calculate the mean Cross Section for the set of Elements(*Isotopes) in the Material
G4double Momentum = incidentParticle->GetTotalMomentum(); // 3-momentum of the Particle
#ifdef debug
G4double KinEn = incidentParticle->GetKineticEnergy();
G4cout<<"G4QCohChEx::GetMeanFreePath: kinE="<<KinEn<<",Mom="<<Momentum<<G4endl; // Result
#endif
const G4Material* material = aTrack.GetMaterial(); // Get the current material
const G4double* NOfNucPerVolume = material->GetVecNbOfAtomsPerVolume();
const G4ElementVector* theElementVector = material->GetElementVector();
G4int nE=material->GetNumberOfElements();
#ifdef debug
G4cout<<"G4QCohChargeExchange::GetMeanFreePath:"<<nE<<" Elem's in theMaterial"<<G4endl;
#endif
G4int pPDG=0;
if (incidentParticleDefinition == G4Proton::Proton() ) pPDG=2212;
else if(incidentParticleDefinition == G4Neutron::Neutron()) pPDG=2112;
else G4cout<<"G4QCohChargeEx::GetMeanFreePath: only nA & pA are implemented"<<G4endl;
G4QIsotope* Isotopes = G4QIsotope::Get(); // Pointer to the G4QIsotopes singleton
G4double sigma=0.; // Sums over elements for the material
G4int IPIE=IsoProbInEl.size(); // How many old elements?
if(IPIE) for(G4int ip=0; ip<IPIE; ++ip) // Clean up the SumProb's of Isotopes (SPI)
{
std::vector<G4double>* SPI=IsoProbInEl[ip]; // Pointer to the SPI vector
SPI->clear();
delete SPI;
std::vector<G4int>* IsN=ElIsoN[ip]; // Pointer to the N vector
IsN->clear();
delete IsN;
}
ElProbInMat.clear(); // Clean up the SumProb's of Elements (SPE)
ElementZ.clear(); // Clear the body vector for Z of Elements
IsoProbInEl.clear(); // Clear the body vector for SPI
ElIsoN.clear(); // Clear the body vector for N of Isotopes
for(G4int i=0; i<nE; ++i)
{
G4Element* pElement=(*theElementVector)[i]; // Pointer to the current element
G4int Z = static_cast<G4int>(pElement->GetZ()); // Z of the Element
ElementZ.push_back(Z); // Remember Z of the Element
G4int isoSize=0; // The default for the isoVectorLength is 0
G4int indEl=0; // Index of non-natural element or 0(default)
G4IsotopeVector* isoVector=pElement->GetIsotopeVector(); // Get the predefined IsoVect
if(isoVector) isoSize=isoVector->size();// Get size of the existing isotopeVector
#ifdef debug
G4cout<<"G4QCoherentChargeExchange::GetMeanFreePath:isovectorLength="<<isoSize<<G4endl;
#endif
if(isoSize) // The Element has non-trivial abundance set
{
indEl=pElement->GetIndex()+1; // Index of the non-trivial element is an order
#ifdef debug
G4cout<<"G4QCCX::GetMFP: iE="<<indEl<<", def="<<Isotopes->IsDefined(Z,indEl)<<G4endl;
#endif
if(!Isotopes->IsDefined(Z,indEl)) // This index is not defined for this Z: define
{
std::vector<std::pair<G4int,G4double>*>* newAbund =
new std::vector<std::pair<G4int,G4double>*>;
G4double* abuVector=pElement->GetRelativeAbundanceVector();
for(G4int j=0; j<isoSize; j++) // Calculation of abundance vector for isotopes
{
G4int N=pElement->GetIsotope(j)->GetN()-Z; // N means A=N+Z !
if(pElement->GetIsotope(j)->GetZ()!=Z)G4cerr<<"G4QCohChX::GetMeanFreePath: Z="
<<pElement->GetIsotope(j)->GetZ()<<"#"<<Z<<G4endl;
G4double abund=abuVector[j];
std::pair<G4int,G4double>* pr= new std::pair<G4int,G4double>(N,abund);
#ifdef debug
G4cout<<"G4QCohChEx::GetMeanFreePath:pair#="<<j<<",N="<<N<<",ab="<<abund<<G4endl;
#endif
newAbund->push_back(pr);
}
#ifdef debug
G4cout<<"G4QCohChEx::GetMeanFreePath: pairVectorLength="<<newAbund->size()<<G4endl;
#endif
indEl=G4QIsotope::Get()->InitElement(Z,indEl,newAbund); // definition of the newInd
for(G4int k=0; k<isoSize; k++) delete (*newAbund)[k]; // Cleaning temporary
delete newAbund; // Was "new" in the beginning of the name space
}
}
std::vector<std::pair<G4int,G4double>*>* cs= Isotopes->GetCSVector(Z,indEl);//CSPointer
std::vector<G4double>* SPI = new std::vector<G4double>; // Pointer to the SPI vector
IsoProbInEl.push_back(SPI);
std::vector<G4int>* IsN = new std::vector<G4int>; // Pointer to the N vector
ElIsoN.push_back(IsN);
G4int nIs=cs->size(); // A#Of Isotopes in the Element
#ifdef debug
G4cout<<"G4QCohChargEx::GMFP:=***=>,#isot="<<nIs<<", Z="<<Z<<", indEl="<<indEl<<G4endl;
#endif
G4double susi=0.; // sum of CS over isotopes
if(nIs) for(G4int j=0; j<nIs; j++) // Calculate CS for eachIsotope of El
{
std::pair<G4int,G4double>* curIs=(*cs)[j]; // A pointer, which is used twice
G4int N=curIs->first; // #of Neuterons in the isotope j of El i
IsN->push_back(N); // Remember Min N for the Element
#ifdef debug
G4cout<<"G4QCCX::GMFP:true, P="<<Momentum<<",Z="<<Z<<",N="<<N<<",PDG="<<pPDG<<G4endl;
#endif
G4bool ccsf=true;
if(Q==-27.) ccsf=false;
#ifdef debug
G4cout<<"G4QCoherentChargeExchange::GMFP: GetCS #1 j="<<j<<G4endl;
#endif
G4double CSI=CalculateXSt(ccsf, true, Momentum, Z, N, pPDG);// CS(j,i) for theIsotope
#ifdef debug
G4cout<<"G4QCohChEx::GetMeanFreePath:jI="<<j<<",Zt="<<Z<<",Nt="<<N<<",Mom="<<Momentum
<<", XSec="<<CSI/millibarn<<G4endl;
#endif
curIs->second = CSI;
susi+=CSI; // Make a sum per isotopes
SPI->push_back(susi); // Remember summed cross-section
} // End of temporary initialization of the cross sections in the G4QIsotope singeltone
sigma+=Isotopes->GetMeanCrossSection(Z,indEl)*NOfNucPerVolume[i];//SUM(MeanCS*NOfNperV)
#ifdef debug
G4cout<<"G4QCohChEx::GMFP:<S>="<<Isotopes->GetMeanCrossSection(Z,indEl)<<",AddToSigma="
<<Isotopes->GetMeanCrossSection(Z,indEl)*NOfNucPerVolume[i]<<G4endl;
#endif
ElProbInMat.push_back(sigma);
} // End of LOOP over Elements
// Check that cross section is not zero and return the mean free path
#ifdef debug
G4cout<<"G4QCoherentChargeExchange::GetMeanFreePath: MeanFreePath="<<1./sigma<<G4endl;
#endif
if(sigma > 0.) return 1./sigma; // Mean path [distance]
return DBL_MAX;
}
G4bool G4QCoherentChargeExchange::IsApplicable(const G4ParticleDefinition& particle)
{
if (particle == *( G4Proton::Proton() )) return true;
else if (particle == *( G4Neutron::Neutron() )) return true;
//else if (particle == *( G4MuonMinus::MuonMinus() )) return true;
//else if (particle == *( G4TauPlus::TauPlus() )) return true;
//else if (particle == *( G4TauMinus::TauMinus() )) return true;
//else if (particle == *( G4Electron::Electron() )) return true;
//else if (particle == *( G4Positron::Positron() )) return true;
//else if (particle == *( G4Gamma::Gamma() )) return true;
//else if (particle == *( G4MuonPlus::MuonPlus() )) return true;
//else if (particle == *(G4AntiNeutrinoMu::AntiNeutrinoMu())) return true;
//else if (particle == *( G4NeutrinoMu::NeutrinoMu() )) return true;
//else if (particle == *( G4PionMinus::PionMinus() )) return true;
//else if (particle == *( G4PionPlus::PionPlus() )) return true;
//else if (particle == *( G4KaonPlus::KaonPlus() )) return true;
//else if (particle == *( G4KaonMinus::KaonMinus() )) return true;
//else if (particle == *( G4KaonZeroLong::KaonZeroLong() )) return true;
//else if (particle == *( G4KaonZeroShort::KaonZeroShort() )) return true;
//else if (particle == *( G4Lambda::Lambda() )) return true;
//else if (particle == *( G4SigmaPlus::SigmaPlus() )) return true;
//else if (particle == *( G4SigmaMinus::SigmaMinus() )) return true;
//else if (particle == *( G4SigmaZero::SigmaZero() )) return true;
//else if (particle == *( G4XiMinus::XiMinus() )) return true;
//else if (particle == *( G4XiZero::XiZero() )) return true;
//else if (particle == *( G4OmegaMinus::OmegaMinus() )) return true;
//else if (particle == *( G4AntiNeutron::AntiNeutron() )) return true;
//else if (particle == *( G4AntiProton::AntiProton() )) return true;
#ifdef debug
G4cout<<"***>>G4QCoherChargeExch::IsApplicable: PDG="<<particle.GetPDGEncoding()<<G4endl;
#endif
return false;
}
G4VParticleChange* G4QCoherentChargeExchange::PostStepDoIt(const G4Track& track,
const G4Step& step)
{
static const G4double mProt= G4QPDGCode(2212).GetMass(); // CHIPS pMass in MeV
static const G4double mNeut= G4QPDGCode(2212).GetMass(); // CHIPS pMass in MeV
//
//-------------------------------------------------------------------------------------
static G4bool CWinit = true; // CHIPS Warld needs to be initted
if(CWinit)
{
CWinit=false;
G4QCHIPSWorld::Get()->GetParticles(nPartCWorld); // Create CHIPS World (234 part.max)
}
//-------------------------------------------------------------------------------------
const G4DynamicParticle* projHadron = track.GetDynamicParticle();
const G4ParticleDefinition* particle=projHadron->GetDefinition();
#ifdef debug
G4cout<<"G4QCohChargeExchange::PostStepDoIt: Before the GetMeanFreePath is called In4M="
<<projHadron->Get4Momentum()<<" of PDG="<<particle->GetPDGEncoding()<<", Type="
<<particle->GetParticleType()<<", Subtp="<<particle->GetParticleSubType()<<G4endl;
#endif
G4ForceCondition cond=NotForced;
GetMeanFreePath(track, -27., &cond); // @@ ?? jus to update parameters?
#ifdef debug
G4cout<<"G4QCohChargeExchange::PostStepDoIt: After GetMeanFreePath is called"<<G4endl;
#endif
G4LorentzVector proj4M=(projHadron->Get4Momentum())/MeV; // Convert to MeV!
G4double momentum = projHadron->GetTotalMomentum()/MeV; // 3-momentum of the Proj in MeV
G4double Momentum = proj4M.rho(); // @@ Just for the test purposes
if(std::fabs(Momentum-momentum)>.000001)
G4cerr<<"*Warning*G4QCohChEx::PostStepDoIt:P(IU)="<<Momentum<<"#"<<momentum<<G4endl;
#ifdef pdebug
G4cout<<"G4QCoherentChargeExchange::PostStepDoIt: pP(IU)="<<Momentum<<"="<<momentum
<<",pM="<<pM<<",proj4M="<<proj4M<<proj4M.m()<<G4endl;
#endif
if (!IsApplicable(*particle)) // Check applicability
{
G4cerr<<"G4QCoherentChargeExchange::PostStepDoIt: Only NA is implemented."<<G4endl;
return 0;
}
const G4Material* material = track.GetMaterial(); // Get the current material
G4int Z=0;
const G4ElementVector* theElementVector = material->GetElementVector();
G4int nE=material->GetNumberOfElements();
#ifdef debug
G4cout<<"G4QCohChargeExchange::PostStepDoIt: "<<nE<<" elements in the material."<<G4endl;
#endif
G4int projPDG=0; // PDG Code prototype for the captured hadron
// Not all these particles are implemented yet (see Is Applicable)
if (particle == G4Proton::Proton() ) projPDG= 2212;
else if (particle == G4Neutron::Neutron() ) projPDG= 2112;
//else if (particle == G4PionMinus::PionMinus() ) projPDG= -211;
//else if (particle == G4PionPlus::PionPlus() ) projPDG= 211;
//else if (particle == G4KaonPlus::KaonPlus() ) projPDG= 2112;
//else if (particle == G4KaonMinus::KaonMinus() ) projPDG= -321;
//else if (particle == G4KaonZeroLong::KaonZeroLong() ) projPDG= 130;
//else if (particle == G4KaonZeroShort::KaonZeroShort() ) projPDG= 310;
//else if (particle == G4MuonPlus::MuonPlus() ) projPDG= -13;
//else if (particle == G4MuonMinus::MuonMinus() ) projPDG= 13;
//else if (particle == G4NeutrinoMu::NeutrinoMu() ) projPDG= 14;
//else if (particle == G4AntiNeutrinoMu::AntiNeutrinoMu() ) projPDG= -14;
//else if (particle == G4Electron::Electron() ) projPDG= 11;
//else if (particle == G4Positron::Positron() ) projPDG= -11;
//else if (particle == G4NeutrinoE::NeutrinoE() ) projPDG= 12;
//else if (particle == G4AntiNeutrinoE::AntiNeutrinoE() ) projPDG= -12;
//else if (particle == G4Gamma::Gamma() ) projPDG= 22;
//else if (particle == G4TauPlus::TauPlus() ) projPDG= -15;
//else if (particle == G4TauMinus::TauMinus() ) projPDG= 15;
//else if (particle == G4NeutrinoTau::NeutrinoTau() ) projPDG= 16;
//else if (particle == G4AntiNeutrinoTau::AntiNeutrinoTau()) projPDG= -16;
//else if (particle == G4Lambda::Lambda() ) projPDG= 3122;
//else if (particle == G4SigmaPlus::SigmaPlus() ) projPDG= 3222;
//else if (particle == G4SigmaMinus::SigmaMinus() ) projPDG= 3112;
//else if (particle == G4SigmaZero::SigmaZero() ) projPDG= 3212;
//else if (particle == G4XiMinus::XiMinus() ) projPDG= 3312;
//else if (particle == G4XiZero::XiZero() ) projPDG= 3322;
//else if (particle == G4OmegaMinus::OmegaMinus() ) projPDG= 3334;
//else if (particle == G4AntiNeutron::AntiNeutron() ) projPDG=-2112;
//else if (particle == G4AntiProton::AntiProton() ) projPDG=-2212;
#ifdef debug
G4int prPDG=particle->GetPDGEncoding();
G4cout<<"G4QCohChrgExchange::PostStepDoIt: projPDG="<<projPDG<<", stPDG="<<prPDG<<G4endl;
#endif
if(!projPDG)
{
G4cerr<<"*Warning*G4QCoherentChargeExchange::PostStepDoIt:UndefinedProjHadron"<<G4endl;
return 0;
}
//G4double pM2=proj4M.m2(); // in MeV^2
//G4double pM=std::sqrt(pM2); // in MeV
G4double pM=mNeut;
G4int fPDG=2112;
if(projPDG==2112)
{
pM=mProt;
fPDG=2212;
}
G4double pM2=pM*pM;
// Element treatment
G4int EPIM=ElProbInMat.size();
#ifdef debug
G4cout<<"G4QCohChEx::PostStDoIt:m="<<EPIM<<",n="<<nE<<",T="<<ElProbInMat[EPIM-1]<<G4endl;
#endif
G4int i=0;
if(EPIM>1)
{
G4double rnd = ElProbInMat[EPIM-1]*G4UniformRand();
for(i=0; i<nE; ++i)
{
#ifdef debug
G4cout<<"G4QCohChEx::PostStepDoIt:EPM["<<i<<"]="<<ElProbInMat[i]<<",r="<<rnd<<G4endl;
#endif
if (rnd<ElProbInMat[i]) break;
}
if(i>=nE) i=nE-1; // Top limit for the Element
}
G4Element* pElement=(*theElementVector)[i];
Z=static_cast<G4int>(pElement->GetZ());
#ifdef debug
G4cout<<"G4QCoherentChargeExchange::PostStepDoIt: i="<<i<<", Z(element)="<<Z<<G4endl;
#endif
if(Z<=0)
{
G4cerr<<"-Warning-G4QCoherentChargeExchange::PostStepDoIt: Element with Z="<<Z<<G4endl;
if(Z<0) return 0;
}
std::vector<G4double>* SPI = IsoProbInEl[i];// Vector of summedProbabilities for isotopes
std::vector<G4int>* IsN = ElIsoN[i]; // Vector of "#of neutrons" in the isotope El[i]
G4int nofIsot=SPI->size(); // #of isotopes in the element i
#ifdef debug
G4cout<<"G4QCohChargeExchange::PosStDoIt:nI="<<nofIsot<<",T="<<(*SPI)[nofIsot-1]<<G4endl;
#endif
G4int j=0;
if(nofIsot>1)
{
G4double rndI=(*SPI)[nofIsot-1]*G4UniformRand(); // Randomize the isotop of the Element
for(j=0; j<nofIsot; ++j)
{
#ifdef debug
G4cout<<"G4QCohChargEx::PostStepDoIt: SP["<<j<<"]="<<(*SPI)[j]<<", r="<<rndI<<G4endl;
#endif
if(rndI < (*SPI)[j]) break;
}
if(j>=nofIsot) j=nofIsot-1; // Top limit for the isotope
}
G4int N =(*IsN)[j]; ; // Randomized number of neutrons
#ifdef debug
G4cout<<"G4QCohChargeEx::PostStepDoIt: j="<<i<<", N(isotope)="<<N<<", MeV="<<MeV<<G4endl;
#endif
if(N<0)
{
G4cerr<<"*Warning*G4QCohChEx::PostStepDoIt: Isotope with Z="<<Z<<", 0>N="<<N<<G4endl;
return 0;
}
nOfNeutrons=N; // Remember it for the energy-momentum check
#ifdef debug
G4cout<<"G4QCohChargeExchange::PostStepDoIt: N="<<N<<" for element with Z="<<Z<<G4endl;
#endif
if(N<0)
{
G4cerr<<"*Warning*G4QCoherentChargeExchange::PostStepDoIt:Element with N="<<N<< G4endl;
return 0;
}
aParticleChange.Initialize(track);
#ifdef debug
G4cout<<"G4QCoherentChargeExchange::PostStepDoIt: track is initialized"<<G4endl;
#endif
G4double localtime = track.GetGlobalTime();
G4ThreeVector position = track.GetPosition();
#ifdef debug
G4cout<<"G4QCoherentChargeExchange::PostStepDoIt: before Touchable extraction"<<G4endl;
#endif
G4TouchableHandle trTouchable = track.GetTouchableHandle();
#ifdef debug
G4cout<<"G4QCoherentChargeExchange::PostStepDoIt: Touchable is extracted"<<G4endl;
#endif
//
G4int targPDG=90000000+Z*1000+N; // CHIPS PDG Code of the target nucleus
if(projPDG==2212) targPDG+=999; // convert to final nucleus code
else if(projPDG==2112) targPDG-=999;
G4QPDGCode targQPDG(targPDG); // @@ use G4Ion and get rid of CHIPS World
G4double tM=targQPDG.GetMass(); // CHIPS final nucleus mass in MeV
G4double kinEnergy= projHadron->GetKineticEnergy()*MeV; // Kin energy in MeV (Is *MeV n?)
G4ParticleMomentum dir = projHadron->GetMomentumDirection();// It is a unit three-vector
G4LorentzVector tot4M=proj4M+G4LorentzVector(0.,0.,0.,tM); // Total 4-mom of the reaction
#ifdef debug
G4cout<<"G4QCohChrgEx::PostStepDoIt: tM="<<tM<<", p4M="<<proj4M<<", t4M="<<tot4M<<G4endl;
#endif
EnMomConservation=tot4M; // Total 4-mom of reaction for E/M conservation
// @@ Probably this is not necessary any more
#ifdef debug
G4cout<<"G4QCCX::PSDI:false, P="<<Momentum<<",Z="<<Z<<",N="<<N<<",PDG="<<projPDG<<G4endl;
#endif
G4double xSec=CalculateXSt(false, true, Momentum, Z, N, projPDG); // Recalc. CrossSection
#ifdef debug
G4cout<<"G4QCoChEx::PSDI:PDG="<<projPDG<<",P="<<Momentum<<",CS="<<xSec/millibarn<<G4endl;
#endif
#ifdef nandebug
if(xSec>0. || xSec<0. || xSec==0);
else G4cout<<"*Warning*G4QCohChargeExchange::PSDI: xSec="<<xSec/millibarn<<G4endl;
#endif
// @@ check a possibility to separate p, n, or alpha (!)
if(xSec <= 0.) // The cross-section iz 0 -> Do Nothing
{
#ifdef pdebug
G4cerr<<"*Warning*G4QCoherentChargeExchange::PSDoIt:*Zero cross-section* PDG="<<projPDG
<<",tPDG="<<targPDG<<",P="<<Momentum<<G4endl;
#endif
//Do Nothing Action insead of the reaction
aParticleChange.ProposeEnergy(kinEnergy);
aParticleChange.ProposeLocalEnergyDeposit(0.);
aParticleChange.ProposeMomentumDirection(dir) ;
return G4VDiscreteProcess::PostStepDoIt(track,step);
}
G4double mint=CalculateXSt(false, false, Momentum, Z, N, projPDG);// randomize t in MeV^2
#ifdef pdebug
G4cout<<"G4QCohChEx::PoStDoIt:pPDG="<<projPDG<<",tPDG="<<targPDG<<",P="<<Momentum<<",CS="
<<xSec<<",-t="<<mint<<G4endl;
#endif
#ifdef nandebug
if(mint>-.0000001);
else G4cout<<"*Warning*G4QCoherentChargeExchange::PostStDoIt:-t="<<mint<<G4endl;
#endif
G4double maxt=CalculateXSt(true, false, Momentum, Z, N, projPDG);
if(maxt<=0.) maxt=1.e-27;
G4double cost=1.-mint/maxt; // cos(theta) in CMS (@@ we neglect mass diff for ChEx)
//
#ifdef ppdebug
G4cout<<"G4QCoherentChargeExchange::PoStDoIt:t="<<mint<<",dpcm2="<<maxt
<<",Ek="<<kinEnergy<<",tM="<<tM<<",pM="<<pM<<",cost="<<cost<<G4endl;
#endif
if(cost>1. || cost<-1. || !(cost>-1. || cost<1.))
{
if(cost>1.000001 || cost<-1.000001 || !(cost>-1. || cost<1.))
{
G4double tM2=tM*tM; // Squared target mass
G4double pEn=pM+kinEnergy; // tot projectile Energy in MeV
G4double sM=(tM+tM)*pEn+tM2+pM2; // Mondelstam s
G4double twop2cm=(tM2+tM2)*(pEn*pEn-pM2)/sM;// Max_t/2 (2*p^2_cm)
G4cout<<"*Warning*G4QCohChEx::PostStepDoIt:cos="<<cost<<",t="<<mint<<",T="<<kinEnergy
<<",tM="<<tM<<",tmax="<<2*kinEnergy*tM<<",p="<<projPDG<<",t="<<targPDG<<G4endl;
G4cout<<"..G4QCohChEx::PoStDoI: dpcm2="<<twop2cm<<"="<<maxt<<G4endl;
}
if (cost>1.) cost=1.;
else if(cost<-1.) cost=-1.;
}
G4LorentzVector reco4M=G4LorentzVector(0.,0.,0.,tM); // 4mom of the recoil target
G4LorentzVector scat4M=G4LorentzVector(0.,0.,0.,pM); // 4mom of the recoil target
G4LorentzVector dir4M=tot4M-G4LorentzVector(0.,0.,0.,(tot4M.e()-tM-pM)*.01);
if(!G4QHadron(tot4M).RelDecayIn2(scat4M, reco4M, dir4M, cost, cost))
{
G4cerr<<"G4QCohChEx::PSDI:t4M="<<tot4M<<",pM="<<pM<<",tM="<<tM<<",cost="<<cost<<G4endl;
//G4Exception("G4QCoherentChargeExchange::PostStepDoIt:","009",FatalException,"Decay");
}
#ifdef debug
G4cout<<"G4QCohChEx::PoStDoIt:s4M="<<scat4M<<"+r4M="<<reco4M<<"="<<scat4M+reco4M<<G4endl;
G4cout<<"G4QCohChEx::PoStDoIt: scatE="<<scat4M.e()-pM<<", recoE="<<reco4M.e()-tM<<",d4M="
<<tot4M-scat4M-reco4M<<G4endl;
#endif
// Kill scattered hadron
aParticleChange.ProposeTrackStatus(fStopAndKill);
// Definition of the scattered nucleon
G4DynamicParticle* theSec = new G4DynamicParticle; // A secondary for the recoil hadron
G4ParticleDefinition* theDefinition=G4Proton::Proton();
if(projPDG==2212) theDefinition=G4Neutron::Neutron();
theSec->SetDefinition(theDefinition);
EnMomConservation-=scat4M;
theSec->Set4Momentum(scat4M);
G4Track* aNewTrack = new G4Track(theSec, localtime, position );
aNewTrack->SetTouchableHandle(trTouchable);
aParticleChange.AddSecondary( aNewTrack );
// Filling the recoil nucleus
theSec = new G4DynamicParticle; // A secondary for the recoil hadron
G4int aA = Z+N;
#ifdef pdebug
G4cout<<"G4QCoherentChargeExchange::PostStepDoIt: Ion Z="<<Z<<", A="<<aA<<G4endl;
#endif
theDefinition=G4ParticleTable::GetParticleTable()->FindIon(Z,aA,0,Z);
if(!theDefinition)G4cout<<"*Warning*G4QCohChEx::PostStepDoIt:drop PDG="<<targPDG<<G4endl;
#ifdef pdebug
G4cout<<"G4QCohChEx::PostStepDoIt:RecoilName="<<theDefinition->GetParticleName()<<G4endl;
#endif
theSec->SetDefinition(theDefinition);
EnMomConservation-=reco4M;
#ifdef tdebug
G4cout<<"G4QCohChEx::PostSDoIt:"<<targPDG<<reco4M<<reco4M.m()<<EnMomConservation<<G4endl;
#endif
theSec->Set4Momentum(reco4M);
#ifdef debug
G4ThreeVector curD=theSec->GetMomentumDirection();
G4double curM=theSec->GetMass();
G4double curE=theSec->GetKineticEnergy()+curM;
G4cout<<"G4QCohChEx::PostStpDoIt:p="<<curD<<curD.mag()<<",e="<<curE<<",m="<<curM<<G4endl;
#endif
// Make a recoil nucleus
aNewTrack = new G4Track(theSec, localtime, position );
aNewTrack->SetTouchableHandle(trTouchable);
aParticleChange.AddSecondary( aNewTrack );
#ifdef debug
G4cout<<"G4QCoherentChargeExchange::PostStepDoIt:*** PostStepDoIt is done ***"<<G4endl;
#endif
return G4VDiscreteProcess::PostStepDoIt(track, step);
}
G4double G4QCoherentChargeExchange::CalculateXSt(G4bool oxs, G4bool xst, G4double p,
G4int Z, G4int N, G4int pPDG)
{
static G4bool init=false;
static G4bool first=true;
static G4VQCrossSection* CSmanager;
if(first) // Connection with a singletone
{
CSmanager=G4QElasticCrossSection::GetPointer();
first=false;
}
G4double res=0.;
if(oxs && xst) // Only the Cross-Section can be returened
{
res=CSmanager->GetCrossSection(true, p, Z, N, pPDG); // XS for isotope
res*=ChExElCoef(p, Z, N, pPDG);
}
else if(!oxs && xst) // Calculate Cross-Section & prepare differential
{
res=CSmanager->GetCrossSection(false, p, Z, N, pPDG);// XS for isotope + init t-distr.
res*=ChExElCoef(p, Z, N, pPDG); // @@ is that necessary?
// The XS for the nucleus must be calculated the last
init=true;
}
else if(init) // Return t-value for scattering (=G4QElastic)
{
if(oxs) res=CSmanager->GetHMaxT(); // Calculate the max_t value
else res=CSmanager->GetExchangeT(Z, N, pPDG); // fanctionally randomized -t in MeV^2
}
else G4cout<<"*Warning*G4QCohChrgExchange::CalculateXSt: NotInitiatedScattering"<<G4endl;
return res;
}
G4double G4QCoherentChargeExchange::ChExElCoef(G4double p, G4int Z, G4int N, G4int pPDG)
{
G4double A=Z+N;
if(A<1.5) return 0.;
G4double C=0.;
if (pPDG==2212) C=N/A;
else if(pPDG==2112) C=Z/A;
else G4cout<<"*Warning*G4QCohChrgExchange::ChExElCoef: wrong PDG="<<pPDG<<G4endl;
C*=C; // Coherent processes squares the amplitude
// @@ This is true only for nucleons: other projectiles must be treated differently
G4double sp=std::sqrt(p);
G4double p2=p*p;
G4double p4=p2*p2;
G4double dl1=std::log(p)-5.;
G4double T=(6.75+.14*dl1*dl1+13./p)/(1.+.14/p4)+.6/(p4+.00013);
G4double U=(6.25+8.33e-5/p4/p)*(p*sp+.34)/p2/p;
G4double R=U/T;
return C*R*R;
}
source/processes/hadronic/models/chiral_inv_phase_space/interface/src/G4QCollision.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
// $Id: G4QCollision.cc,v 1.19 2007/05/02 14:59:57 gunter Exp $
// GEANT4 tag $Name: geant4-08-03 $
// GEANT4 tag $Name: geant4-09-00 $
//
// ---------------- G4QCollision class -----------------
// by Mikhail Kossov, December 2003.
source/processes/hadronic/models/chiral_inv_phase_space/interface/src/G4QDiffractionRatio.cc
+469
View File
@@ -0,0 +1,469 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G4QDiffractionRatio.cc,v 1.3 2007/06/01 07:22:18 mkossov Exp $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// G4 Physics class: G4QDiffractionRatio for N+A elastic cross sections
// Created: M.V. Kossov, CERN/ITEP(Moscow), 10-OCT-01
// The last update: M.V. Kossov, CERN/ITEP (Moscow) 15-Oct-06
//
//================================================================================
//#define debug
//#define pdebug
//#define nandebug
#include "G4QDiffractionRatio.hh"
// Returns Pointer to the G4VQCrossSection class
G4QDiffractionRatio* G4QDiffractionRatio::GetPointer()
{
static G4QDiffractionRatio theRatios; // *** Static body of the Diffraction Ratio ***
return &theRatios;
}
// Calculation of pair(QuasiFree/Inelastic,QuasiElastic/QuasiFree)
G4double G4QDiffractionRatio::GetRatio(G4double pIU, G4int pPDG, G4int tgZ, G4int tgN)
{
static const G4double mNeut= G4QPDGCode(2112).GetMass();
static const G4double mProt= G4QPDGCode(2212).GetMass();
static const G4double mN=.5*(mNeut+mProt);
static const G4double dmN=mN+mN;
static const G4double mN2=mN*mN;
// Table parameters
static const G4int nps=100; // Number of steps in the R(s) LinTable
static const G4int mps=nps+1; // Number of elements in the R(s) LinTable
static const G4double sma=6.; // The first LinTabEl(sqs=0)=1., sqs>sma -> logTab
static const G4double ds=sma/nps; // Step of the linear Table
static const G4int nls=150; // Number of steps in the R(lns) logTable
static const G4int mls=nls+1; // Number of elements in the R(lns) logTable
static const G4double lsi=1.79; // The min ln(sqs) logTabEl(sqs=5.99 < sma=6.)
static const G4double lsa=8.; // The max ln(sqs) logTabEl(sqs=5.99 - 2981 GeV)
static const G4double mi=std::exp(lsi);// The min s of logTabEl(~ 5.99 GeV)
static const G4double ms=std::exp(lsa);// The max s of logTabEl(~ 2981 GeV)
static const G4double dl=(lsa-lsi)/nls;// Step of the logarithmic Table
static const G4double edl=std::exp(dl);// Multiplication step of the logarithmic Table
static const G4double toler=.0001; // Tolarence (GeV) defining the same sqs
static G4double lastS=0.; // Last sqs value for which R was calculated
static G4double lastR=0.; // Last ratio R which was calculated
// Local Associative Data Base:
static std::vector<G4int> vA; // Vector of calculated A
static std::vector<G4double> vH; // Vector of max sqs initialized in the LinTable
static std::vector<G4int> vN; // Vector of topBin number initialized in LinTable
static std::vector<G4double> vM; // Vector of relMax ln(sqs) initialized in LogTable
static std::vector<G4int> vK; // Vector of topBin number initialized in LogTable
static std::vector<G4double*> vT; // Vector of pointers to LinTable in C++ heap
static std::vector<G4double*> vL; // Vector of pointers to LogTable in C++ heap
// Last values of the Associative Data Base:
static G4int lastPDG=0; // Last PDG for which R was calculated (now indep)
static G4int lastA=0; // theLast of calculated A
static G4double lastH=0.; // theLast of max sqs initialized in the LinTable
static G4int lastN=0; // theLast of topBin number initialized in LinTable
static G4double lastM=0.; // theLast of relMax ln(sqs) initialized in LogTab.
static G4int lastK=0; // theLast of topBin number initialized in LogTable
static G4double* lastT=0; // theLast of pointer to LinTable in the C++ heap
static G4double* lastL=0; // theLast of pointer to LogTable in the C++ heap
// LogTable is created only if necessary. R(sqs>2981GeV) calcul by formula for any nuclei
G4int A=tgN+tgZ;
if(pIU<toler || A<1) return 1.; // Fake use of toler as non zero number
if(A>238)
{
G4cout<<"-*-Warning-*-G4QuasiFreeRatio::GetRatio: A="<<A<<">238, return zero"<<G4endl;
return 0.;
}
lastPDG=pPDG; // @@ at present ratio is PDG independent @@
// Calculate sqs
G4double pM=G4QPDGCode(pPDG).GetMass()*.001; // Projectile mass in GeV
G4double pM2=pM*pM;
G4double mom=pIU/gigaelectronvolt; // Projectile momentum in GeV
G4double s=std::sqrt(mN2+pM2+dmN*std::sqrt(pM2+mom*mom));
G4int nDB=vA.size(); // A number of nuclei already initialized in AMDB
if(nDB && lastA==A && std::fabs(s-lastS)<toler) return lastR;
if(s>ms)
{
lastR=CalcDiff2Prod_Ratio(s,A); // @@ Probably user ought to be notified about bigS
return lastR;
}
G4bool found=false;
G4int i=-1;
if(nDB) for (i=0; i<nDB; i++) if(A==vA[i]) // Sirch for this A in AMDB
{
found=true; // The A value is found
break;
}
if(!nDB || !found) // Create new line in the AMDB
{
lastA = A;
lastT = new G4double[mps]; // Create the linear Table
lastN = static_cast<int>(s/ds)+1; // MaxBin to be initialized
if(lastN>nps)
{
lastN=nps;
lastH=sma;
}
else lastH = lastN*ds; // Calculate max initialized s for LinTab
G4double sv=0;
lastT[0]=1.;
for(G4int j=1; j<=lastN; j++) // Calculate LinTab values
{
sv+=ds;
lastT[j]=CalcDiff2Prod_Ratio(sv,A);
}
if(s>sma) // Initialize the logarithmic Table
{
lastL=new G4double[mls]; // Create the logarithmic Table
G4double ls=std::log(s);
lastK = static_cast<int>((ls-lsi)/dl)+1; // MaxBin to be initialized in LogTaB
if(lastK>nls)
{
lastK=nls;
lastM=lsa-lsi;
}
else lastM = lastK*dl; // Calculate max initialized ln(s)-lsi for LogTab
sv=mi;
for(G4int j=0; j<=lastK; j++) // Calculate LogTab values
{
lastL[j]=CalcDiff2Prod_Ratio(sv,A);
if(j!=lastK) sv*=edl;
}
}
else // LogTab is not initialized
{
lastL = 0;
lastK = 0;
lastM = 0.;
}
i++; // Make a new record to AMDB and position on it
vA.push_back(lastA);
vH.push_back(lastH);
vN.push_back(lastN);
vM.push_back(lastM);
vK.push_back(lastK);
vT.push_back(lastT);
vL.push_back(lastL);
}
else // The A value was found in AMDB
{
lastA=vA[i];
lastH=vH[i];
lastN=vN[i];
lastM=vM[i];
lastK=vK[i];
lastT=vT[i];
lastL=vL[i];
if(s>lastM) // At least LinTab must be updated
{
G4int nextN=lastN+1; // The next bin to be initialized
if(lastN<nps)
{
lastN = static_cast<int>(s/ds)+1;// MaxBin to be initialized
if(lastN>nps)
{
lastN=nps;
lastH=sma;
}
else lastH = lastN*ds; // Calculate max initialized s for LinTab
G4double sv=lastM;
for(G4int j=nextN; j<=lastN; j++)// Calculate LogTab values
{
sv+=ds;
lastT[j]=CalcDiff2Prod_Ratio(sv,A);
}
} // End of LinTab update
if(lastN>=nextN)
{
vH[i]=lastH;
vN[i]=lastN;
}
G4int nextK=lastK+1;
if(s>sma && lastK<nls) // LogTab must be updated
{
G4double sv=std::exp(lastM+lsi); // Define starting poit (lastM will be changed)
G4double ls=std::log(s);
lastK = static_cast<int>((ls-lsi)/dl)+1; // MaxBin to be initialized in LogTaB
if(lastK>nls)
{
lastK=nls;
lastM=lsa-lsi;
}
else lastM = lastK*dl; // Calculate max initialized ln(s)-lsi for LogTab
for(G4int j=nextK; j<=lastK; j++)// Calculate LogTab values
{
sv*=edl;
lastL[j]=CalcDiff2Prod_Ratio(sv,A);
}
} // End of LogTab update
if(lastK>=nextK)
{
vM[i]=lastM;
vK[i]=lastK;
}
}
}
// Now one can use tabeles to calculate the value
if(s<sma) // Use linear table
{
G4int n=static_cast<int>(s/ds); // Low edge number of the bin
G4double d=s-n*ds; // Linear shift
G4double v=lastT[n]; // Base
lastR=v+d*(lastT[n+1]-v)/ds; // Result
}
else // Use log table
{
G4double ls=std::log(s)-lsi; // ln(s)-l_min
G4int n=static_cast<int>(ls/dl); // Low edge number of the bin
G4double d=ls-n*dl; // Log shift
G4double v=lastL[n]; // Base
lastR=v+d*(lastL[n+1]-v)/dl; // Result
}
if(lastR<0.) lastR=0.;
if(lastR>1.) lastR=1.;
return lastR;
} // End of CalcDiff2Prod_Ratio
// Calculate Diffraction/Production Ratio as a function of total sq(s)(hN) (in GeV), A=Z+N
G4double G4QDiffractionRatio::CalcDiff2Prod_Ratio(G4double s, G4int A)
{
static G4int mA=0;
static G4double S=.1; // s=SQRT(M_N^2+M_h^2+2*E_h*M_N)
static G4double R=0.; // Prototype of the result
static G4double p1=0.;
static G4double p2=0.;
static G4double p4=0.;
static G4double p5=0.;
static G4double p6=0.;
static G4double p7=0.;
if(s<=0. || A<=1) return 0.;
if(A!=mA && A!=1)
{
mA=A;
G4double a=mA;
G4double sa=std::sqrt(a);
G4double a2=a*a;
G4double a3=a2*a;
G4double a4=a3*a;
G4double a5=a4*a;
G4double a6=a5*a;
G4double a7=a6*a;
G4double a8=a7*a;
G4double a11=a8*a3;
G4double a12=a8*a4;
G4double p=std::pow(a,0.37);
p1=(.023*p+3.5/a3+2.1e6/a12+4.e-14*a5)/(1.+7.6e-4*a*sa+2.15e7/a11);
p2=(1.42*std::pow(a,0.61)+1.6e5/a8+4.5e-8*a4)/(1.+4.e-8*a4+1.2e4/a6);
G4double q=std::pow(a,0.7);
p4=(.036/q+.0009*q)/(1.+6./a3+1.e-7*a3);
p5=1.3*std::pow(a,0.1168)/(1.+1.2e-8*a3);
p6=.00046*(a+11830./a2);
p7=1./(1.+6.17/a2+.00406*a);
}
else if(A==1 && mA!=1)
{
p1=.0315;
p2=.73417;
p4=.01109;
p5=1.0972;
p6=.065787;
p7=.62976;
}
else if(std::fabs(s-S)/S<.0001) return R;
G4double s2=s*s;
G4double s4=s2*s2;
G4double dl=std::log(s)-p5;
R=1./(1.+1./(p1+p2/s4+p4*dl*dl/(1.+p6*std::pow(s,p7))));
return R;
} // End of CalcQF2IN_Ratio
G4QHadronVector* G4QDiffractionRatio::Fragment(G4int pPDG, G4LorentzVector p4M,
G4int tgZ, G4int tgN)
{
static const G4double pFm= 250.; // Fermi momentum in MeV (delta function)
static const G4double pFm2= pFm*pFm; // Squared Fermi momentum in MeV^2 (delta function)
static const G4double mPi0= G4QPDGCode(111).GetMass(); // pi0 mass (MeV =min diffraction)
static const G4double mNeut= G4QPDGCode(2112).GetMass();
static const G4double mNeut2=mNeut*mNeut;
static const G4double dmNeut=mNeut+mNeut;
static const G4double mProt= G4QPDGCode(2212).GetMass();
static const G4double mProt2=mProt*mProt;
static const G4double dmProt=mProt+mProt;
G4LorentzVector pr4M=p4M/megaelectronvolt; // Convert 4-momenta in MeV (keep p4M)
// prepare the DONOTHING answer
G4QHadronVector* ResHV = new G4QHadronVector;// !! MUST BE DESTROYE/DDELETER by CALLER !!
G4QHadron* hadron = new G4QHadron(pPDG,p4M); // Hadron for not scattered projectile
ResHV->push_back(hadron); // It must be cleaned up for real scattering sec
// @@ diffraction is simulated as noncoherent (coherent is small)
G4int tgA=tgZ+tgN; // A of the target
G4int tPDG=90000000+tgZ*1000+tgN; // PDG code of the targetNucleus/recoilNucleus
G4double tgM=G4QPDGCode(tPDG).GetMass(); // Mass of the target nucleus
G4int rPDG=2112; // prototype of PDG code of the recoiled nucleon
if(tgA*G4UniformRand()>tgN) // Substitute by a proton
{
rPDG=2212; // PDG code of the recoiled QF nucleon
tPDG-=1000; // PDG code of the recoiled nucleus
}
else tPDG-=1; // PDG code of the recoiled nucleus
G4double tM=G4QPDGCode(tPDG).GetMass(); // Mass of the recoiled nucleus
G4double tE=std::sqrt(tM*tM+pFm2);
G4ThreeVector tP=pFm*G4RandomDirection();
G4LorentzVector t4M(tP,tE); // 4M of the recoil nucleus
G4LorentzVector tg4M(0.,0.,0.,tgM);
G4LorentzVector N4M=tg4M-t4M; // Quasi-free target nucleon
G4LorentzVector tot4M=N4M+p4M; // total momentum of quasi-free diffraction
G4double mT=mNeut;
G4double mT2=mNeut2; // Squared mass of the free nucleon spectator
G4double dmT=dmNeut;
G4int Z=0;
G4int N=1;
if(rPDG==2212)
{
mT=mProt;
mT2=mProt2;
dmT=dmProt;
Z=1;
N=0;
}
G4double mP2=pr4M.m2(); // Squared mass of the projectile
if(mP2<0.) mP2=0.; // A possible problem for photon (m_min = 2*m_pi0)
G4double s=tot4M.m2(); // @@ Check <0 ...
G4double E=(s-mT2-mP2)/dmT; // Effective interactin energy (virt. nucl. target)
G4double E2=E*E;
if(E<0. || E2<mP2)
{
#ifdef pdebug
G4cerr<<"Warning-G4DifR::Frag:*Negative Energy*E="<<E<<",E2="<<E2<<"<M2="<<mP2<<G4endl;
#endif
return ResHV; // Do Nothing Action
}
G4double mP=std::sqrt(mP2);
if(mP<.1)mP=mPi0; // For photons min diffraction is gamma+P->Pi0+Pi0
G4double mMin=mP+mPi0; // Minimum diffractive mass
G4double ss=std::sqrt(s); // CM compound mass (sqrt(s))
G4double mMax=ss-mT; // Maximum diffraction mass
if(mMin>=mMax)
{
#ifdef pdebug
G4cerr<<"Warning-G4DifR::Frag:ZeroDiffractionMRange, mi="<<mMin<<", ma="<<mMax<<G4endl;
#endif
return ResHV; // Do Nothing Action
}
G4double mDif=mMin/(1.-G4UniformRand()*(1.-mMin/mMax)); // Low Mass Approximation
G4double mDif2=mDif*mDif;
G4double ds=s-mT2-mDif2;
G4double e=ds/dmT;
G4double P=std::sqrt(e*e-mDif2); // Momentum in pseudo laboratory system
G4VQCrossSection* CSmanager=G4QElasticCrossSection::GetPointer();
#ifdef debug
G4cout<<"G4QDiffR::Frag: Before XS, P="<<P<<", Z="<<Z<<", N="<<N<<", PDG="<<pPDG<<G4endl;
#endif
// @@ Temporary NN t-dependence for all hadrons
if(pPDG>3400 || pPDG<-3400) G4cout<<"-Warning-G4QDifR::Fragment: pPDG="<<pPDG<<G4endl;
G4int PDG=2212; // *TMP* instead of pPDG
G4double xSec=CSmanager->GetCrossSection(false, P, tgZ, tgN, PDG);// Rec.CrossSect *TMP*
//G4double xSec=CSmanager->GetCrossSection(false, P, tgZ, tgN, pPDG); // Rec.CrossSect
#ifdef debug
G4cout<<"G4QElast::Scatter:pPDG="<<pPDG<<",P="<<P<<",CS="<<xSec/millibarn<<G4endl;
#endif
#ifdef nandebug
if(xSec>0. || xSec<0. || xSec==0);
else G4cout<<"***NAN***G4QDiffR::Fragment: xSec="<<xSec/millibarn<<G4endl;
#endif
// @@ check a possibility to separate p, n, or alpha (!)
if(xSec <= 0.) // The cross-section iz 0 -> Do Nothing
{
#ifdef pdebug
G4cerr<<"-Warning-G4QDiffR::Fragment:**Zero XS**PDG="<<pPDG<<",P="<<P<<G4endl;
#endif
return ResHV; //Do Nothing Action
}
G4double t=CSmanager->GetExchangeT(tgZ,tgN,pPDG); // functional randomized -t (MeV^2)
G4double maxt=(ds*ds-4*mT2*mDif2)/s; // maximum possible -t
#ifdef pdebug
G4cout<<"G4QDifR::Frag:ph="<<pPDG<<",P="<<P<<",X="<<xSec<<",t="<<mint<<"<"<<maxt<<G4endl;
#endif
#ifdef nandebug
if(mint>-.0000001); // To make the Warning for NAN
else G4cout<<"******G4QDiffR::Frag:-t="<<mint<<G4endl;
#endif
G4double rt=t/maxt;
G4double cost=1.-rt-rt; // cos(theta) in CMS
#ifdef ppdebug
G4cout<<"G4QDiffR::Fragment: -t="<<t<<", maxt="<<maxt<<", cost="<<cost<<G4endl;
#endif
if(cost>1. || cost<-1. || !(cost>-1. || cost<=1.))
{
if (cost>1.) cost=1.;
else if(cost<-1.) cost=-1.;
else
{
G4cerr<<"G4QDiffR::Fragm: *NAN* cost="<<cost<<",t="<<t<<",tmax="<<maxt<<G4endl;
return ResHV; // Do Nothing Action
}
}
G4LorentzVector r4M=G4LorentzVector(0.,0.,0.,mT); // 4mom of the recoil nucleon
G4LorentzVector d4M=G4LorentzVector(0.,0.,0.,mDif); // 4mom of the diffract. Quasmon
G4LorentzVector dir4M=tot4M-G4LorentzVector(0.,0.,0.,(tot4M.e()-mT)*.01);
if(!G4QHadron(tot4M).RelDecayIn2(pr4M, r4M, dir4M, cost, cost))
{
G4cerr<<"G4QDifR::Fra:M="<<tot4M.m()<<",T="<<mT<<",D="<<mDif<<",T+D="<<mT+mDif<<G4endl;
//G4Exception("G4QDifR::Fragm:","009",FatalException,"Decay of ElasticComp");
return ResHV; // Do Nothing Action
}
#ifdef debug
G4cout<<"G4QFR::Scat:p4M="<<p4M<<"+r4M="<<reco4M<<"="<<scat4M+reco4M<<"="<<tot4M<<G4endl;
#endif
// Now everything is ready for fragmentation and DoNothing projHadron must be wiped out
ResHV->pop_back(); // Clean up pointer to the fake (doNothing) projectile
delete hadron; // Deklete the fake (doNothing) projectile hadron
hadron = new G4QHadron(tPDG,t4M); // Hadron for the recoil neucleus
ResHV->push_back(hadron); // Fill the recoil nucleus
hadron = new G4QHadron(rPDG,r4M); // Hadron for the recoil neucleus
// Now the (pPdg,d4M) Quasmon must be fragmented
G4QHadronVector* leadhs=new G4QHadronVector;// Prototype of QuasmOutput G4QHadronVector
G4QContent dQC=G4QPDGCode(pPDG).GetQuarkContent(); // Quark Content of the projectile
G4Quasmon* pan= new G4Quasmon(dQC,d4M); // --->---->---->----->-----> DELETED -->---*
try // |
{ // |
G4QNucleus vac(90000000); // |
leadhs=pan->Fragment(vac,1); // DELETED after it is copied to ResHV vector -->---+-*
} // | |
catch (G4QException& error) // | |
{ // | |
G4cerr<<"***G4QDiffractionRatio::Fragment: G4Quasmon Exception"<<G4endl; //| |
G4Exception("G4QDiffractionRatio::Fragment","72",FatalException,"QuasmonCrash");//| |
} // | |
delete pan; // Delete the Nuclear Environment <----<---* |
G4int qNH=leadhs->size(); // A#of collected hadrons from diff.frag. |
if(qNH) for(G4int iq=0; iq<qNH; iq++) // Loop over hadrons to fill the result |
{ // |
G4QHadron* loh=(*leadhs)[iq]; // Pointer to the output hadron |
ResHV->push_back(loh); // Fill in the result |
} // |
delete leadhs; // <----<----<----<----<----<----<----<----<----<----<----<----<----<--*
return ResHV; // Result
} // End of Scatter
source/processes/hadronic/models/chiral_inv_phase_space/interface/src/G4QElastic.cc
+44 -12
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4QElastic.cc,v 1.21 2007/03/16 10:05:05 mkossov Exp $
// GEANT4 tag $Name: geant4-08-03 $
// $Id: G4QElastic.cc,v 1.23 2007/05/23 15:14:25 mkossov Exp $
// GEANT4 tag $Name: geant4-09-00 $
//
// ---------------- G4QElastic class -----------------
// by Mikhail Kossov, December 2003.
@@ -140,12 +140,12 @@ G4double G4QElastic::GetMeanFreePath(const G4Track& aTrack,G4double Q,G4ForceCon
for(G4int j=0; j<isoSize; j++) // Calculation of abundance vector for isotopes
{
G4int N=pElement->GetIsotope(j)->GetN()-Z; // N means A=N+Z !
if(pElement->GetIsotope(j)->GetZ()!=Z)G4cerr<<"G4QCaptureAtRest::GetMeanFreePath"
<<": Z="<<pElement->GetIsotope(j)->GetZ()<<"#"<<Z<<G4endl;
if(pElement->GetIsotope(j)->GetZ()!=Z)G4cerr<<"G4QElastic::GetMeanFreePath: Z="
<<pElement->GetIsotope(j)->GetZ()<<"#"<<Z<<G4endl;
G4double abund=abuVector[j];
std::pair<G4int,G4double>* pr= new std::pair<G4int,G4double>(N,abund);
#ifdef debug
G4cout<<"G4QElastic::GetMeanFreePath:pair#="<<j<<", N="<<N<<",ab="<<abund<<G4endl;
G4cout<<"G4QElastic::GetMeanFreePath:pair#="<<j<<",N="<<N<<",ab="<<abund<<G4endl;
#endif
newAbund->push_back(pr);
}
@@ -199,7 +199,7 @@ G4double G4QElastic::GetMeanFreePath(const G4Track& aTrack,G4double Q,G4ForceCon
} // End of LOOP over Elements
// Check that cross section is not zero and return the mean free path
#ifdef debug
G4cout<<"G4QEl::GMFP: MeanFreePath="<<1./sigma<<G4endl;
G4cout<<"G4QElastic::GetMeanFreePath: MeanFreePath="<<1./sigma<<G4endl;
#endif
if(sigma > 0.) return 1./sigma; // Mean path [distance]
return DBL_MAX;
@@ -271,7 +271,7 @@ G4VParticleChange* G4QElastic::PostStepDoIt(const G4Track& track, const G4Step&
G4double momentum = projHadron->GetTotalMomentum()/MeV; // 3-momentum of the Proj in MeV
G4double Momentum = proj4M.rho(); // @@ Just for the test purposes
if(std::fabs(Momentum-momentum)>.000001)
G4cerr<<"*War*G4QElastic::PostStepDoIt:P(IU)="<<Momentum<<"="<<momentum<<G4endl;
G4cerr<<"*War*G4QElastic::PostStepDoIt:P(IU)="<<Momentum<<"#"<<momentum<<G4endl;
G4double pM2=proj4M.m2(); // in MeV^2
G4double pM=std::sqrt(pM2); // in MeV
#ifdef pdebug
@@ -280,7 +280,7 @@ G4VParticleChange* G4QElastic::PostStepDoIt(const G4Track& track, const G4Step&
#endif
if (!IsApplicable(*particle)) // Check applicability
{
G4cerr<<"G4QElastic::PostStepDoIt:Only pp elastic is implemented."<<G4endl;
G4cerr<<"G4QElastic::PostStepDoIt: Only NA elastic is implemented."<<G4endl;
return 0;
}
const G4Material* material = track.GetMaterial(); // Get the current material
@@ -362,7 +362,7 @@ G4VParticleChange* G4QElastic::PostStepDoIt(const G4Track& track, const G4Step&
std::vector<G4int>* IsN = ElIsoN[i]; // Vector of "#of neutrons" in the isotope El[i]
G4int nofIsot=SPI->size(); // #of isotopes in the element i
#ifdef debug
G4cout<<"G4QElastic::PosStDoIt:n="<<nofIsot<<",T="<<(*SPI)[nofIsot-1]<<G4endl;
G4cout<<"G4QElastic::PosStDoIt: nI="<<nofIsot<<",T="<<(*SPI)[nofIsot-1]<<G4endl;
#endif
G4int j=0;
if(nofIsot>1)
@@ -430,13 +430,13 @@ G4VParticleChange* G4QElastic::PostStepDoIt(const G4Track& track, const G4Step&
#endif
#ifdef nandebug
if(xSec>0. || xSec<0. || xSec==0);
else G4cout<<"******G4QElast::PSDI:xSec="<<xSec/millibarn<<G4endl;
else G4cout<<"*Warning*G4QElastic::PostStDoIt: xSec="<<xSec/millibarn<<G4endl;
#endif
// @@ check a possibility to separate p, n, or alpha (!)
if(xSec <= 0.) // The cross-section iz 0 -> Do Nothing
{
#ifdef pdebug
G4cerr<<"*Warning*G4QElastic::PSDoIt:*Zero cross-sectionp* PDG="<<projPDG<<",tPDG="
G4cerr<<"*Warning*G4QElastic::PostStDoIt: *Zero cross-section* PDG="<<projPDG<<",tPDG="
<<targPDG<<",P="<<Momentum<<G4endl;
#endif
//Do Nothing Action insead of the reaction
@@ -452,7 +452,7 @@ G4VParticleChange* G4QElastic::PostStepDoIt(const G4Track& track, const G4Step&
#endif
#ifdef nandebug
if(mint>-.0000001);
else G4cout<<"******G4QElast::PSDI:-t="<<mint<<G4endl;
else G4cout<<"*Warning*G4QElastic::PostStDoIt:-t="<<mint<<G4endl;
#endif
//G4double cost=1.-mint/twop2cm; // cos(theta) in CMS
G4double cost=1.-mint/CSmanager->GetHMaxT();// cos(theta) in CMS
@@ -539,3 +539,35 @@ G4VParticleChange* G4QElastic::PostStepDoIt(const G4Track& track, const G4Step&
#endif
return G4VDiscreteProcess::PostStepDoIt(track, step);
}
// @@ For future improvement @@
G4double G4QElastic::CalculateXSt(G4bool oxs, G4bool xst, G4double p, G4int Z, G4int N,
G4int pPDG)
{
static G4bool init=false;
static G4bool first=true;
static G4VQCrossSection* CSmanager;
if(first) // Connection with a singletone
{
CSmanager=G4QElasticCrossSection::GetPointer();
first=false;
}
G4double res=0.;
if(oxs && xst) // Only the Cross-Section can be returened
{
res=CSmanager->GetCrossSection(true, p, Z, N, pPDG); // XS for isotope
}
else if(!oxs && xst) // Calculate Cross-Section & prepare differential
{
res=CSmanager->GetCrossSection(false, p, Z, N, pPDG);// XS for isotope + init t-distr.
// The XS for the nucleus must be calculated the last
init=true;
}
else if(init) // Return t-value for scattering (=G4QElastic)
{
if(oxs) res=CSmanager->GetHMaxT(); // Calculate the max_t value
else res=CSmanager->GetExchangeT(Z, N, pPDG); // fanctionally randomized -t in MeV^2
}
else G4cout<<"*Warning*G4QCohChrgExchange::CalculateXSt:*NotInitiatedScattering"<<G4endl;
return res;
}
source/processes/hadronic/models/chiral_inv_phase_space/interface/src/G4QElasticCrossSection.cc
+129 -459
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4QElasticCrossSection.cc,v 1.24 2007/03/30 10:53:31 mkossov Exp $
// GEANT4 tag $Name: geant4-08-03 $
// $Id: G4QElasticCrossSection.cc,v 1.29 2007/06/15 16:43:39 gcosmo Exp $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// G4 Physics class: G4QElasticCrossSection for N+A elastic cross sections
@@ -84,6 +84,60 @@ G4double G4QElasticCrossSection::lastTH=0.; // Last threshold momentum
G4double G4QElasticCrossSection::lastCS=0.; // Last value of the Cross Section
G4int G4QElasticCrossSection::lastI=0; // The last position in the DAMDB
std::vector<G4double*> G4QElasticCrossSection::PAR; // Vector of parameters for functional calculations
std::vector<G4double*> G4QElasticCrossSection::CST; // Vector of cross-section table
std::vector<G4double*> G4QElasticCrossSection::SST; // Vector of the first squared slope
std::vector<G4double*> G4QElasticCrossSection::S1T; // Vector of the first mantissa
std::vector<G4double*> G4QElasticCrossSection::B1T; // Vector of the first slope
std::vector<G4double*> G4QElasticCrossSection::S2T; // Vector of the secon mantissa
std::vector<G4double*> G4QElasticCrossSection::B2T; // Vector of the second slope
std::vector<G4double*> G4QElasticCrossSection::S3T; // Vector of the third mantissa
std::vector<G4double*> G4QElasticCrossSection::B3T; // Vector of the third slope
std::vector<G4double*> G4QElasticCrossSection::S4T; // Vector of the 4-th mantissa (gloria)
std::vector<G4double*> G4QElasticCrossSection::B4T; // Vector of the 4-th slope (gloria)
G4QElasticCrossSection::G4QElasticCrossSection()
{
}
G4QElasticCrossSection::~G4QElasticCrossSection()
{
std::vector<G4double*>::iterator pos;
for (pos=CST.begin(); pos<CST.end(); pos++)
{ delete [] *pos; }
CST.clear();
for (pos=PAR.begin(); pos<PAR.end(); pos++)
{ delete [] *pos; }
PAR.clear();
for (pos=SST.begin(); pos<SST.end(); pos++)
{ delete [] *pos; }
SST.clear();
for (pos=S1T.begin(); pos<S1T.end(); pos++)
{ delete [] *pos; }
S1T.clear();
for (pos=B1T.begin(); pos<B1T.end(); pos++)
{ delete [] *pos; }
B1T.clear();
for (pos=S2T.begin(); pos<S2T.end(); pos++)
{ delete [] *pos; }
S2T.clear();
for (pos=B2T.begin(); pos<B2T.end(); pos++)
{ delete [] *pos; }
B2T.clear();
for (pos=S3T.begin(); pos<S3T.end(); pos++)
{ delete [] *pos; }
S3T.clear();
for (pos=B3T.begin(); pos<B3T.end(); pos++)
{ delete [] *pos; }
B3T.clear();
for (pos=S4T.begin(); pos<S4T.end(); pos++)
{ delete [] *pos; }
S4T.clear();
for (pos=B4T.begin(); pos<B4T.end(); pos++)
{ delete [] *pos; }
B4T.clear();
}
// Returns Pointer to the G4VQCrossSection class
G4VQCrossSection* G4QElasticCrossSection::GetPointer()
{
@@ -275,17 +329,6 @@ G4double G4QElasticCrossSection::CalculateCrossSection(G4bool CS,G4int F,G4int I
{
// *** Begin of Associative Memory DB for acceleration of the cross section calculations
static std::vector <G4double> PIN; // Vector of max initialized log(P) in the table
static std::vector <G4double*> PAR; // Vector of parameters for functional calculations
static std::vector <G4double*> CST; // Vector of cross-section table
static std::vector <G4double*> SST; // Vector of the first squared slope
static std::vector <G4double*> S1T; // Vector of the first mantissa
static std::vector <G4double*> B1T; // Vector of the first slope
static std::vector <G4double*> S2T; // Vector of the secon mantissa
static std::vector <G4double*> B2T; // Vector of the second slope
static std::vector <G4double*> S3T; // Vector of the third mantissa
static std::vector <G4double*> B3T; // Vector of the third slope
static std::vector <G4double*> S4T; // Vector of the 4-th mantissa (gloria)
static std::vector <G4double*> B4T; // Vector of the 4-th slope (gloria)
// *** End of Static Definitions (Associative Memory Data Base) ***
if(tgZ==0 && tgN==1) // Temporary change for Quasi-Elastic
{
@@ -325,7 +368,7 @@ G4double G4QElasticCrossSection::CalculateCrossSection(G4bool CS,G4int F,G4int I
#endif
if(lastLP>lastPIN && lastLP<lPMax)
{
lastPIN = GetPTables(lastLP,lastPIN,PDG,tgZ,tgN);// Can update upper logP-Limit in tabs
lastPIN=GetPTables(lastLP,lastPIN,PDG,tgZ,tgN);// Can update upper logP-Limit in tabs
#ifdef pdebug
G4cout<<"G4QElCS::CalcCS:*updated(I)*,LP="<<lastLP<<"<IN["<<I<<"]="<<lastPIN<<G4endl;
#endif
@@ -474,10 +517,8 @@ G4double G4QElasticCrossSection::GetPTables(G4double LP,G4double ILP, G4int PDG,
{
// @@ At present all nA==pA ---------> Each neucleus can have not more than 51 parameters
static const G4double pwd=2727;
const G4int n_npel=24; // #of parameters for np-elastic (<nPoints=51)
const G4int n_ppel=32; // #of parameters for pp-elastic (<nPoints=51)
//const G4int n_pdel=30; // #of parameters for pp-elastic (<nPoints=51)
//const G4int n_phe4=32; // #of parameters for phe4-elastic (<nPoints=51)
const G4int n_npel=24; // #of parameters for np-elastic (<nPoints=128)
const G4int n_ppel=32; // #of parameters for pp-elastic (<nPoints=128)
// -0- -1- -2- -3- -4- -5- -6- -7- -8- -9--10--11--12--13- -14-
G4double np_el[n_npel]={12.,.05,.0001,5.,.35,6.75,.14,19.,.6,6.75,.14,13.,.14,.6,.00013,
75.,.001,7.2,4.32,.012,2.5,0.0,12.,.34};
@@ -489,17 +530,6 @@ G4double G4QElasticCrossSection::GetPTables(G4double LP,G4double ILP, G4int PDG,
// -14--15- -16- -17- -18- -19- -20- -21- -22- -23- -24- -25-
// -26- -27- -28- -29- -30- -31-
// -0- -1--2- -3- -4- -5- -6- -7- -8- -9- -10--11--12--13-
//G4double pd_el[n_pdel]={7.5,.09,5.,.06,.0013,.1,.000006,1.287,.001,34.,.4,4.726,7.5,.1,
// .05,.000017,.0004,1.15,5.5,.13,.02,.1911,4.857,46.,40.,2.,.01,
// .0000007,13.,.1};
// -14- -15- -16- -17--18- -19--20- -21- -22- -23--24--25--26-
// -27- -28- -29-
// -0- -1- -2- -3- -4- -5- -6- -7- -8- -9- -10--11--12-
//G4double p_he4[n_phe4]={22.5,.3,5.,.037,.004,.00003,12.9,2500.,.05,22.5,.3,.04,.0065,
// 12.5,2500.,.053,.035,2.5e-8,29.,.6,.7,.1,1.5,.03,.00015,4.24,
// .004,.005,1.5e-11,2.3,.002,23.};
// -13- -14- -15- -16- -17- -18--19--20-21--22--23- -24- -25-
// -26- -27- -28- -29- -30- -31-
if(tgZ==0 && tgN==1) // Temporary change for Quasi-Elastic
{
tgZ=1;
@@ -553,22 +583,48 @@ G4double G4QElasticCrossSection::GetPTables(G4double LP,G4double ILP, G4int PDG,
G4double a12=a6*a6;
G4double a14=a7*a7;
G4double a16=a8*a8;
// a17
G4double a17=a16*a;
G4double a32=a16*a16;
G4double r1a16=3.e16/a16;
G4double r2a16=2.e13/a16;
G4double r3a16=6.e13/a16;
G4double pa10=5.e-27*a10;
// Reaction cross-section parameters (pel=peh_fit.f)
lastPAR[0]=.28*a; // p1
lastPAR[1]=4.8*std::pow(a,1.14)/(1.+3.6/a3); // p2
lastPAR[2]=3.3/a+.8*ssa/(1.+2.e7/a8); // p3
lastPAR[3]=1./(1.+6.e-9*a12)+.6*a/(1.+1.6e15/a16); // p4
lastPAR[4]=6.e-4/(a4+3.e-6*a12)+.16/(a+9.e5/a3+r1a16*r1a16); // p5
lastPAR[5]=3.e-4/a2+(1.5e-3+3.e-14*a7)/(1.+r2a16*r2a16+3.e-12*a6); // p6
lastPAR[6]=4.e-30+(1.2e-28*a3+pa10*pa10)/(1.+r3a16*r3a16+4.e-26*a14); // p7
lastPAR[7]=.07/(1.+1.7e-8*a16)+.5/(1.+1.7e18/a16+4.5e-7*a4); // p8
lastPAR[8]=(1.5e-10+2.e-18*a8)/(1.+3.e-25*a16); // p10
lastPAR[0]=.28*a; // p1
lastPAR[1]=4.8*std::pow(a,1.14)/(1.+3.6/a3); // p2(p/n)
lastPAR[2]=3.3/a+.5*ssa/(1.+2.e7/a8); // p3
if(PDG==2112)
{
if(a<6.5)
{
lastPAR[3]=1./(1.+.00123*a4); // p4
lastPAR[4]=1.5e-4/a2/(a+1.2e-6*a12)+1.5e-6; // p5
lastPAR[5]=.0062/(a+5.e-11*a16); // p6
lastPAR[6]=3.2e-14/a6/(1.+4.e-10*a17); // p7
lastPAR[7]=.847/a4/(a+.0005*a8)+.00045; // p8
lastPAR[8]=.413/a16+7.e-7; // p10
}
else
{
lastPAR[1]/=1.+4.e-3*a; // @@ reduction for n, can be for p too // p2(n)
lastPAR[3]=a*(.5+1.e-10*a4)/(1.+7.e5/a6); // p4
lastPAR[4]=a*3.e-5/(1.+2.e12/a12); // p5
lastPAR[5]=(.0006+1.e-14*a5)/(1.+4.e5/a3)/(1.+3.e23/a16/a8); // p6
lastPAR[6]=1.e-22*a4/(1.+5.e16*(1.+5e31/a32)/a16); // p7
lastPAR[7]=(8.+.00016*a2)/(1.+1.4e14/a16); // p8
lastPAR[8]=.0013; // p10
}
}
else
{
lastPAR[2]=3.3/a+.7*ssa/(1.+2.e7/a8); // p3
lastPAR[3]=1./(1.+6.e-9*a12)+.6*a/(1.+1.6e15/a16); // p4
lastPAR[4]=6.e-4/(a4+3.e-6*a12)+.16/(a+9.e5/a3+r1a16*r1a16); // p5
lastPAR[5]=3.e-4/a2+(1.5e-3+3.e-14*a7)/(1.+r2a16*r2a16+3.e-12*a6); // p6
lastPAR[6]=4.e-30+(1.2e-28*a3+pa10*pa10)/(1.+r3a16*r3a16+4.e-26*a14); // p7
lastPAR[7]=.07/(1.+1.7e-8*a16)+.5/(1.+1.7e18/a16+4.5e-7*a4); // p8
lastPAR[8]=(1.5e-10+2.e-18*a8)/(1.+3.e-25*a16); // p10
}
// @@ the differential cross-section is parameterized separately for A>6 & A<7
if(a<6.5)
{
@@ -579,7 +635,7 @@ G4double G4QElasticCrossSection::GetPTables(G4double LP,G4double ILP, G4int PDG,
// a40
// The main pre-exponent (pel_sg)
lastPAR[ 9]=4000*a; // p1
lastPAR[10]=1.2e7*a8+380*a16*a; // p2
lastPAR[10]=1.2e7*a8+380*a17; // p2
lastPAR[11]=.7/(1.+4.e-12*a16); // p3
lastPAR[12]=2.5/a8/(a4+1.e-16*a32); // p4
lastPAR[13]=.28*a; // p5
@@ -1029,401 +1085,6 @@ G4double G4QElasticCrossSection::GetHMaxT()
// lastLP is used, so calculating tables, one need to remember and then recover lastLP
G4double G4QElasticCrossSection::GetTabValues(G4double lp, G4int PDG, G4int tgZ,G4int tgN)
{
static const G4double GeVSQ=gigaelectronvolt*gigaelectronvolt;
static const G4double mNeut= G4QPDGCode(2112).GetMass(); // Neutron mass in MeV
static const G4double dNM= (mNeut+mNeut)/GeVSQ;// Doubled neutron mass in ...
static const G4int nZ=92; // #0f covered elements
static const G4int n01=2; // Z= 1 H
static const G4int N01[n01]={0,1}; // #of neutrons in the isotope
static const G4double T01[n01]={0.,0.}; // Threshold in MeV
static const G4double X01[n01]={20000.,3395.}; // XS level in mb
static const G4int n02=2; // Z= 2 He
static const G4int N02[n02]={1,2};
static const G4double T02[n02]={0.,0.};
static const G4double X02[n02]={1000.,759.};
static const G4int n03=2; // Z= 3 Li
static const G4int N03[n03]={3,4};
static const G4double T03[n03]={0.,0.};
static const G4double X03[n03]={710.,1050.};
static const G4int n04=1; // Z= 4 Be
static const G4int N04[n04]={5};
static const G4double T04[n04]={0.};
static const G4double X04[n04]={6000.};
static const G4int n05=2; // Z= 5 B
static const G4int N05[n05]={5,6};
static const G4double T05[n05]={0.,0.};
static const G4double X05[n05]={2140.,4840.};
static const G4int n06=2; // Z= 6 C
static const G4int N06[n06]={6,7};
static const G4double T06[n06]={0.,0.};
static const G4double X06[n06]={4730.,4730.};
static const G4int n07=2; // Z= 7 N
static const G4int N07[n07]={7,8};
static const G4double T07[n07]={0.,0.};
static const G4double X07[n07]={9957.,1018.};
static const G4int n08=3; // Z= 8 O
static const G4int N08[n08]={8,9,10};
static const G4double T08[n08]={0.,0.,0.};
static const G4double X08[n08]={3880.,3740.,4000.};
static const G4int n09=1; // Z= 9 F
static const G4int N09[n09]={10};
static const G4double T09[n09]={0.};
static const G4double X09[n09]={3997.};
static const G4int n10=3; // Z=10 Ne
static const G4int N10[n10]={10,11,12};
static const G4double T10[n10]={0.,0.,0.};
static const G4double X10[n10]={1000.,1000.,1000.};
static const G4int n11=1; // Z=11 Na
static const G4int N11[n11]={12};
static const G4double T11[n11]={0.};
static const G4double X11[n11]={728.};
static const G4int n12=3; // Z=12 Mg
static const G4int N12[n12]={12,13,14};
static const G4double T12[n12]={.52,.22,.45};
static const G4double X12[n12]={3500.,4000.,4000.};
static const G4int n13=1; // Z=13 Al
static const G4int N13[n13]={14};
static const G4double T13[n13]={0.};
static const G4double X13[n13]={1400.};
static const G4int n14=3; // Z=14 Si
static const G4int N14[n14]={14,15,16};
static const G4double T14[n14]={1.75,.1,.5};
static const G4double X14[n14]={1770.,4700.,5000.};
static const G4int n15=1; // Z=15 P
static const G4int N15[n15]={16};
static const G4double T15[n15]={0.};
static const G4double X15[n15]={703.};
static const G4int n16=4; // Z=16 S
static const G4int N16[n16]={16,17,18,20};
static const G4double T16[n16]={1.57,.26,.48,1.};
static const G4double X16[n16]={4230.,6090.,6750.,5000.};
static const G4int n17=2; // Z=17 Cl
static const G4int N17[n17]={18,20};
static const G4double T17[n17]={.226,.202};
static const G4double X17[n17]={2000.,2000.};
static const G4int n18=3; // Z=18 Ar
static const G4int N18[n18]={18,20,22};
static const G4double T18[n18]={.00001,.3,.66};
static const G4double X18[n18]={50.,1000.,2500.};
static const G4int n19=3; // Z=19 K
static const G4int N19[n19]={20,21,22};
static const G4double T19[n19]={.2,0.,.125};
static const G4double X19[n19]={2200.,2200.,3000.};
static const G4int n20=6; // Z=20 Ca
static const G4int N20[n20]={20,22,23,24,26,28};
static const G4double T20[n20]={.5,.3,.04,.5,0.,.5};
static const G4double X20[n20]={700.,3500.,8000.,3000.,3900.,3700.};
static const G4int n21=1; // Z=21 Sc
static const G4int N21[n21]={24};
static const G4double T21[n21]={.0969};
static const G4double X21[n21]={4600.};
static const G4int n22=5; // Z=22 Ti
static const G4int N22[n22]={24,25,26,27,28};
static const G4double T22[n22]={.1,.1,.1,0.,.1};
static const G4double X22[n22]={4700.,5000.,5500.,1000.,6000.};
static const G4int n23=2; // Z=23 V
static const G4int N23[n23]={27,28};
static const G4double T23[n23]={.1,.1};
static const G4double X23[n23]={5000.,7000.};
static const G4int n24=4; // Z=24 Cr
static const G4int N24[n24]={26,28,29,30};
static const G4double T24[n24]={.595,.637,.248,.4};
static const G4double X24[n24]={4000.,3900.,5600.,2260.};
static const G4int n25=1; // Z=25 Mn
static const G4int N25[n25]={30};
static const G4double T25[n25]={.08};
static const G4double X25[n25]={1070.};
static const G4int n26=4; // Z=26 Fe
static const G4int N26[n26]={28,30,31,32};
static const G4double T26[n26]={.5,.862,0.,.37};
static const G4double X26[n26]={4540.,2500.,600.,5500.};
static const G4int n27=1; // Z=27 Co
static const G4int N27[n27]={32};
static const G4double T27[n27]={.08};
static const G4double X27[n27]={1070.};
static const G4int n28=5; // Z=28 Ni
static const G4int N28[n28]={30,32,33,34,36};
static const G4double T28[n28]={.812,.45,.07,.6,.6};
static const G4double X28[n28]={3000.,6000.,20000.,1200.,1200.};
static const G4int n29=2; // Z=29 Cu
static const G4int N29[n29]={34,36};
static const G4double T29[n29]={.0995,.0995};
static const G4double X29[n29]={3500.,10000.};
static const G4int n30=5; // Z=30 Zn
static const G4int N30[n30]={34,36,37,38,40};
static const G4double T30[n30]={.1,.1,.1,.1,.1};
static const G4double X30[n30]={7000.,7000.,7000.,7000.,7000.};
static const G4int n31=2; // Z=31 Ga
static const G4int N31[n31]={38,40};
static const G4double T31[n31]={.0059,.0056};
static const G4double X31[n31]={11000.,10000.};
static const G4int n32=5; // Z=32 Ge
static const G4int N32[n32]={38,40,41,42,44};
static const G4double T32[n32]={.015,.00553,.00059,.00627,.0175};
static const G4double X32[n32]={10000.,1470.,10000.,13000.,10000.};
static const G4int n33=1; // Z=33 As
static const G4int N33[n33]={42};
static const G4double T33[n33]={.00241};
static const G4double X33[n33]={15000.};
static const G4int n34=6; // Z=34 Se
static const G4int N34[n34]={40,42,43,44,46,48};
static const G4double T34[n34]={.0024,.00749,.00272,.0121,.00671,.0311};
static const G4double X34[n34]={14000.,11900.,14000.,10000.,11000.,8400.};
static const G4int n35=2; // Z=35 Br
static const G4int N35[n35]={44,46};
static const G4double T35[n35]={.000412,.00363};
static const G4double X35[n35]={17000.,11200.};
static const G4int n36=6; // Z=36 Kr
static const G4int N36[n36]={42,44,46,47,48,50};
static const G4double T36[n36]={.000865,.001,.0001,.000521,.002,.013};
static const G4double X36[n36]={9000.,20000.,9000.,7200.,11180.,11000.};
static const G4int n37=2; // Z=37 Rb
static const G4int N37[n37]={48,50};
static const G4double T37[n37]={.00923,.03};
static const G4double X37[n37]={9300.,9000.};
static const G4int n38=4; // Z=38 Sr
static const G4int N38[n38]={46,48,49,50};
static const G4double T38[n38]={.0035,.0199,.00289,.1655};
static const G4double X38[n38]={18000.,8500.,10600.,8000.};
static const G4int n39=1; // Z=39 Y
static const G4int N39[n39]={50};
static const G4double T39[n39]={0.0};
static const G4double X39[n39]={583.};
static const G4int n40=5; // Z=40 Zr
static const G4int N40[n40]={50,51,52,54,56};
static const G4double T40[n40]={.131,.1,.039,.0677,.1};
static const G4double X40[n40]={8650.,11300.,8700.,9000.,8600.};
static const G4int n41=1; // Z=41 Nb
static const G4int N41[n41]={52};
static const G4double T41[n41]={.1};
static const G4double X41[n41]={9200.};
static const G4int n42=7; // Z=42 Mo
static const G4int N42[n42]={50,52,53,54,55,56,58};
static const G4double T42[n42]={.000032,.00808,.00216,.00816,.00196,.05,.1};
static const G4double X42[n42]={7870,8000.,8100.,7800.,7700.,8000.,8500.};
static const G4int n43=1; // Z=43 Te - No stable isotopes
static const G4int N43[n43]={-1};
static const G4double T43[n43]={0.};
static const G4double X43[n43]={0.};
static const G4int n44=7; // Z=44 Mo
static const G4int N44[n44]={52,54,55,56,57,58,60};
static const G4double T44[n44]={0.,0.,.00101,.0005,.025,.00161,.00151};
static const G4double X44[n44]={8000,20000.,7000.,8000.,8000.,8000.,7200.};
static const G4int n45=1; // Z=45 Rh
static const G4int N45[n45]={58};
static const G4double T45[n45]={.039};
static const G4double X45[n45]={8000.};
static const G4int n46=6; // Z=46 Pd
static const G4int N46[n46]={56,58,59,60,62,64};
static const G4double T46[n46]={.0004,.1,.02,.1,.1,.1};
static const G4double X46[n46]={12000.,8000.,7400.,7500.,7400.,7300.};
static const G4int n47=2; // Z=47 Ag
static const G4int N47[n47]={60,62};
static const G4double T47[n47]={.00106,.000984};
static const G4double X47[n47]={12000.,670.};
static const G4int n48=8; // Z=48 Cd
static const G4int N48[n48]={58,60,62,63,64,65,66,68};
static const G4double T48[n48]={.00069,.1,.00718,.01,.00662,.001,.00341,.00289};
static const G4double X48[n48]={8000.,7500,6000.,7000.,6000.,6500.,6500.,6500.};
static const G4int n49=2; // Z=49 In
static const G4int N49[n49]={64,66};
static const G4double T49[n49]={.00033,.00112};
static const G4double X49[n49]={5700.,5700.};
static const G4int n50=10; // Z=50 Sn
static const G4int N50[n50]={62,64,65,66,67,68,69,70,72,74};
static const G4double T50[n50]={.15,.002,.000693,.00215,.000611,.00189,.000547,.014,
.0086,.00651};
static const G4double X50[n50]={6600.,6700,6700.,6700.,6700.,6500.,6500.,6300.,6300.,
6200.};
static const G4int n51=2; // Z=51 Sb
static const G4int N51[n51]={70,72};
static const G4double T51[n51]={.000922,.00151};
static const G4double X51[n51]={6000.,7000.};
static const G4int n52=8; // Z=52 Te
static const G4int N52[n52]={68,70,71,72,73,74,76,78};
static const G4double T52[n52]={0.,.00379,.000633,.0057,.00134,.00635,.0004,.034};
static const G4double X52[n52]={8000.,6000,6000.,6000.,7000.,6200.,300.,6000.};
static const G4int n53=1; // Z=53 I
static const G4int N53[n53]={74};
static const G4double T53[n53]={.06};
static const G4double X53[n53]={5400.};
static const G4int n54=9; // Z=54 Xe
static const G4int N54[n54]={70,72,74,75,76,77,78,80,82};
static const G4double T54[n54]={0.,.00065,.004,.0042,.004,.00219,.00426,.002,0.};
static const G4double X54[n54]={4200.,2350,14000.,12000.,14000.,16000.,15000.,20000.,
4300.};
static const G4int n55=1; // Z=55 Cs
static const G4int N55[n55]={78};
static const G4double T55[n55]={.00351};
static const G4double X55[n55]={3000.};
static const G4int n56=7; // Z=56 Ba
static const G4int N56[n56]={74,76,78,79,80,81,82};
static const G4double T56[n56]={.1,.1,.00207,.00486,.00318,.00195,.00303};
static const G4double X56[n56]={4000,5000.,13000.,20000.,13000.,16000.,300.};
static const G4int n57=2; // Z=57 La
static const G4int N57[n57]={81,82};
static const G4double T57[n57]={.1,.25};
static const G4double X57[n57]={5000.,5600.};
static const G4int n58=4; // Z=58 Ce
static const G4int N58[n58]={78,80,82,84};
static const G4double T58[n58]={.1,.1,.02,.01};
static const G4double X58[n58]={6000.,6000.,9000.,5290.};
static const G4int n59=1; // Z=59 Pr
static const G4int N59[n59]={82};
static const G4double T59[n59]={.00577};
static const G4double X59[n59]={600.};
static const G4int n60=7; // Z=60 Nd
static const G4int N60[n60]={82,83,84,85,86,88,90};
static const G4double T60[n60]={.011,.01,.05,.05,.05,.05,.00512};
static const G4double X60[n60]={12000,19000.,6000.,8000.,6000.,7000.,3400.};
static const G4int n61=1; // Z=61 Pm - No stable isotopes
static const G4int N61[n61]={-1};
static const G4double T61[n61]={0.};
static const G4double X61[n61]={0.};
static const G4int n62=7; // Z=62 Nd
static const G4int N62[n62]={82,85,86,87,88,90,92};
static const G4double T62[n62]={0.,.07,0.,.00015,.000593,.00369,.0031};
static const G4double X62[n62]={8000,9000.,5300.,5300.,30000.,3000.,2000.};
static const G4int n63=2; // Z=63 Eu
static const G4int N63[n63]={88,90};
static const G4double T63[n63]={.01,.01};
static const G4double X63[n63]={15000.,14000.};
static const G4int n64=7; // Z=64 Gd
static const G4int N64[n64]={88,90,91,92,93,94,96};
static const G4double T64[n64]={.1,.000276,.1,.01,.000215,.00604,.00288};
static const G4double X64[n64]={7400,30000.,6200.,11000.,20000.,20000.,40000.};
static const G4int n65=1; // Z=65 Tb
static const G4int N65[n65]={94};
static const G4double T65[n65]={.01};
static const G4double X65[n65]={13000.};
static const G4int n66=7; // Z=66 Dy
static const G4int N66[n66]={90,92,94,95,96,97,98};
static const G4double T66[n66]={.1,.1,.0000024,.0000068,.000043,.000049,0.};
static const G4double X66[n66]={7000,7000.,50000.,50000.,7000.,50000.,300000.};
static const G4int n67=1; // Z=67 Ho
static const G4int N67[n67]={98};
static const G4double T67[n67]={.01};
static const G4double X67[n67]={13000.};
static const G4int n68=6; // Z=68 Er
static const G4int N68[n68]={94,96,98,99,100,102};
static const G4double T68[n68]={0.,0.,.00201,.000134,0.,0.};
static const G4double X68[n68]={50000.,50000.,40000.,50000.,50000.,50000.};
static const G4int n69=1; // Z=69 Tm
static const G4int N69[n69]={100};
static const G4double T69[n69]={0.};
static const G4double X69[n69]={10000.};
static const G4int n70=7; // Z=70 Yb
static const G4int N70[n70]={98,100,101,102,103,104,106};
static const G4double T70[n70]={0.,0.,0.,0.,0.,0.,0.};
static const G4double X70[n70]={7000,7000.,7000.,7000.,7000.,7000.,7000.};
static const G4int n71=2; // Z=71 Lu
static const G4int N71[n71]={104,105};
static const G4double T71[n71]={0.,0.};
static const G4double X71[n71]={5280.,3160.};
static const G4int n72=6; // Z=72 Hf
static const G4int N72[n72]={102,104,105,106,107,108};
static const G4double T72[n72]={.0003,.00128,.001,.0024,.001,.011};
static const G4double X72[n72]={40000.,20000.,13000.,20000.,20000.,12000.};
static const G4int n73=2; // Z=73 Ta
static const G4int N73[n73]={107,108};
static const G4double T73[n73]={.1,.005};
static const G4double X73[n73]={10000.,10000.};
static const G4int n74=5; // Z=74 W
static const G4int N74[n74]={106,108,109,110,112};
static const G4double T74[n74]={.1,.1,.045,.1,.1};
static const G4double X74[n74]={8000.,8600.,10000.,8800.,8800.};
static const G4int n75=2; // Z=75 Re
static const G4int N75[n75]={110,112};
static const G4double T75[n75]={.1,.1};
static const G4double X75[n75]={8500.,8500.};
static const G4int n76=7; // Z=76 Os
static const G4int N76[n76]={108,110,111,112,113,114,116};
static const G4double T76[n76]={.000008,.000008,.000008,.000008,.000008,.000008,.000008};
static const G4double X76[n76]={25000,25000.,25000.,25000.,25000.,25000.,25000.};
static const G4int n77=2; // Z=77 Ir
static const G4int N77[n77]={114,116};
static const G4double T77[n77]={.1,.01};
static const G4double X77[n77]={14000.,15000.};
static const G4int n78=6; // Z=78 Pt
static const G4int N78[n78]={112,114,116,117,118,120};
static const G4double T78[n78]={0.,0.,0.,0.,0.,0.};
static const G4double X78[n78]={12000.,12000.,12000.,12000.,12000.,12000.};
static const G4int n79=1; // Z=79 Au
static const G4int N79[n79]={118};
static const G4double T79[n79]={.005};
static const G4double X79[n79]={14000.};
static const G4int n80=7; // Z=80 Hg
static const G4int N80[n80]={116,118,119,120,121,122,124};
static const G4double T80[n80]={0.,0.,0.,0.,0.,0.,0.};
static const G4double X80[n80]={30000,30000.,30000.,30000.,30000.,30000.,30000.};
static const G4int n81=2; // Z=81 Tl
static const G4int N81[n81]={122,124};
static const G4double T81[n81]={0.,0.};
static const G4double X81[n81]={10000.,10000.};
static const G4int n82=4; // Z=82 Pb
static const G4int N82[n82]={122,124,125,126};
static const G4double T82[n82]={.1,.1,.475,1.};
static const G4double X82[n82]={12000.,5000.,6000.,4700.};
static const G4int n83=1; // Z=79 Tm
static const G4int N83[n83]={126};
static const G4double T83[n83]={0.};
static const G4double X83[n83]={9000.};
static const G4int n84=1; // Z=84 Po - No stable isotopes
static const G4int N84[n84]={-1};
static const G4double T84[n84]={0.};
static const G4double X84[n84]={0.};
static const G4int n85=1; // Z=85 At - No stable isotopes
static const G4int N85[n85]={-1};
static const G4double T85[n85]={0.};
static const G4double X85[n85]={0.};
static const G4int n86=1; // Z=86 Rn - No stable isotopes
static const G4int N86[n86]={-1};
static const G4double T86[n86]={0.};
static const G4double X86[n86]={0.};
static const G4int n87=1; // Z=87 Fr - No stable isotopes
static const G4int N87[n87]={-1};
static const G4double T87[n87]={0.};
static const G4double X87[n87]={0.};
static const G4int n88=1; // Z=88 Ra - No stable isotopes
static const G4int N88[n88]={-1};
static const G4double T88[n88]={0.};
static const G4double X88[n88]={0.};
static const G4int n89=1; // Z=89 Ac - No stable isotopes
static const G4int N89[n89]={-1};
static const G4double T89[n89]={0.};
static const G4double X89[n89]={0.};
static const G4int n90=1; // Z=90 Th
static const G4int N90[n90]={142};
static const G4double T90[n90]={0.};
static const G4double X90[n90]={11800.};
static const G4int n91=1; // Z=91 Pa - No stable isotopes
static const G4int N91[n91]={-1};
static const G4double T91[n91]={0.};
static const G4double X91[n91]={0.};
static const G4int n92=3; // Z=92 U
static const G4int N92[n92]={142,143,146};
static const G4double T92[n92]={.1,0.,1.};
static const G4double X92[n92]={10400.,15100.,14700.};
static const G4int nn[nZ]={n01,n02,n03,n04,n05,n06,n07,n08,n09,n10,n11,n12,n13,n14,n15,
n16,n17,n18,n19,n20,n21,n22,n23,n24,n25,n26,n27,n28,n29,n30,n31,n32,n33,n34,n35,n36,n37,
n38,n39,n40,n41,n42,n43,n44,n45,n46,n47,n48,n49,n50,n51,n52,n53,n54,n55,n56,n57,n58,n59,
n60,n61,n62,n63,n64,n65,n66,n67,n68,n69,n70,n71,n72,n73,n74,n75,n76,n77,n78,n79,n80,n81,
n82,n83,n84,n85,n86,n87,n88,n89,n90,n91,n92};
static const G4int* nN[nZ]={N01,N02,N03,N04,N05,N06,N07,N08,N09,N10,N11,N12,N13,N14,N15,
N16,N17,N18,N19,N20,N21,N22,N23,N24,N25,N26,N27,N28,N29,N30,N31,N32,N33,N34,N35,N36,N37,
N38,N39,N40,N41,N42,N43,N44,N45,N46,N47,N48,N49,N50,N51,N52,N53,N54,N55,N56,N57,N58,N59,
N60,N61,N62,N63,N64,N65,N66,N67,N68,N69,N70,N71,N72,N73,N74,N75,N76,N77,N78,N79,N80,N81,
N82,N83,N84,N85,N86,N87,N88,N89,N90,N91,N92};
static const G4double* nT[nZ]={T01,T02,T03,T04,T05,T06,T07,T08,T09,T10,T11,T12,T13,T14,
T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,
T37,T38,T39,T40,T41,T42,T43,T44,T45,T46,T47,T48,T49,T50,T51,T52,T53,T54,T55,T56,T57,T58,
T59,T60,T61,T62,T63,T64,T65,T66,T67,T68,T69,T70,T71,T72,T73,T74,T75,T76,T77,T78,T79,T80,
T81,T82,T83,T84,T85,T86,T87,T88,T89,T90,T91,T92};
static const G4double* nX[nZ]={X01,X02,X03,X04,X05,X06,X07,X08,X09,X10,X11,X12,X13,X14,
X15,X16,X17,X18,X19,X20,X21,X22,X23,X24,X25,X26,X27,X28,X29,X30,X31,X32,X33,X34,X35,X36,
X37,X38,X39,X40,X41,X42,X43,X44,X45,X46,X47,X48,X49,X50,X51,X52,X53,X54,X55,X56,X57,X58,
X59,X60,X61,X62,X63,X64,X65,X66,X67,X68,X69,X70,X71,X72,X73,X74,X75,X76,X77,X78,X79,X80,
X81,X82,X83,X84,X85,X86,X87,X88,X89,X90,X91,X92};
if(tgZ==0 && tgN==1) // Temporary change for Quasi-Elastic
{
tgZ=1;
@@ -1443,13 +1104,13 @@ G4double G4QElasticCrossSection::GetTabValues(G4double lp, G4int PDG, G4int tgZ,
tgZ=1;
tgN=0;
}
if(nN[iZ][0] < 0)
{
//if(nN[iZ][0] < 0)
//{
#ifdef isodebug
G4cout<<"*Warning*G4QElasticCS::GetTabValue: No isotopes for Z="<<tgZ<<G4endl;
// G4cout<<"*Warning*G4QElasticCS::GetTabValue: No isotopes for Z="<<tgZ<<G4endl;
#endif
return 0.;
}
// return 0.;
//}
#ifdef pdebug
G4cout<<"G4QElasticCS::GetTabVal: lp="<<lp<<",Z="<<tgZ<<",N="<<tgN<<",PDG="<<PDG<<G4endl;
#endif
@@ -1504,7 +1165,7 @@ G4double G4QElasticCrossSection::GetTabValues(G4double lp, G4int PDG, G4int tgZ,
return lastPAR[0]/p2s/(1.+lastPAR[7]/p2s)+(lastPAR[1]+lastPAR[2]*dl1*dl1+lastPAR[4]/p)
/(1.+lastPAR[5]*lp)/(1.+lastPAR[6]/p4);
}
else if(PDG==2212 || PDG==2112) // n/p+A (isotope/projectile invariant)
else if(PDG==2212 || PDG==2112) // n/p + A
{
G4double p5=p4*p;
G4double p6=p5*p;
@@ -1558,30 +1219,39 @@ G4double G4QElasticCrossSection::GetTabValues(G4double lp, G4int PDG, G4int tgZ,
<<",B4="<<theB4<<G4endl;
#endif
}
G4double rp16=lastPAR[6]/p16;
// Returns the total elastic (n/p)A cross-section (to avoid spoiling lastSIG)
#ifdef tdebug
G4cout<<"G4QElCS::GetTabV: PDG="<<PDG<<",P="<<p<<",N="<<tgN<<",Z="<<tgZ<<G4endl;
#endif
if(PDG!=2112 || !tgN || p>.1) // No Low Energy neutron addition
return (lastPAR[0]*dl*dl+lastPAR[1])/(1.+lastPAR[2]/p2)+lastPAR[3]/(p4+lastPAR[4]/p2)+
lastPAR[5]/(p5+rp16*rp16)+lastPAR[7]/(p4+lastPAR[8]/p4);
else
//if(PDG!=2112 || !tgN || p>.1) // No Low Energy neutron addition
if(PDG==2212) // Unique formula for protons
{
G4int nI=nn[iZ];
for(G4int i=0; i<nI; i++) if(tgN==nN[iZ][i])
{
G4double kE=p2/dNM;
#ifdef tdebug
G4cout<<"G4QECS::GTV:P="<<p<<",E="<<kE<<",X="<<nX[iZ][i]<<",T="<<nT[iZ][i]<<G4endl;
#endif
if(kE<nT[iZ][i]) return 0.; // 0 below the threshold (in MeV)
if(p<2.) return nX[iZ][i]; // At very low momentum(<2MeV/c) -> only LECS
return lastPAR[3]/(p4+lastPAR[4]/p2)+lastPAR[5]/(p5+rp16*rp16)+
lastPAR[7]/(p4+lastPAR[8]/p4)+nX[iZ][i]/(1.+lastPAR[51]*p16);
}
G4cerr<<"*G4QElCS::GTV:PDG="<<PDG<<",Z="<<tgZ<<",N="<<tgN<<": Sig not found"<<G4endl;
G4double rp16=lastPAR[6]/p16;
return (lastPAR[0]*dl*dl+lastPAR[1])/(1.+lastPAR[2]/p)+lastPAR[3]/(p4+lastPAR[4]/p2)
+ lastPAR[5]/(p5+rp16*rp16)+lastPAR[7]/(p4+lastPAR[8]/p4);
}
else if(a<6.5) // neutrons on light nuclei
return (lastPAR[0]*dl*dl+lastPAR[1])/(1.+lastPAR[2]/p)+lastPAR[3]/(p4+lastPAR[4]/p2)+
lastPAR[5]/(p5+lastPAR[6]/p8)+lastPAR[7]/(p4+lastPAR[8]);
else // neutrons on heavy nuclei
return (lastPAR[0]*dl*dl+lastPAR[1])/(1.+lastPAR[2]/p)+lastPAR[3]/(p4+lastPAR[4]/p2)+
lastPAR[5]/(p8+lastPAR[6]/p8)+lastPAR[7]/(p2+lastPAR[8]);
//else
//{
// G4int nI=nn[iZ];
// for(G4int i=0; i<nI; i++) if(tgN==nN[iZ][i])
// {
// G4double kE=p2/dNM;
#ifdef tdebug
// G4cout<<"G4QECS::GTV:P="<<p<<",E="<<kE<<",X="<<nX[iZ][i]<<",T="<<nT[iZ][i]<<G4endl;
#endif
// if(kE<nT[iZ][i]) return 0.; // 0 below the threshold (in MeV)
// if(p<2.) return nX[iZ][i]; // At very low momentum(<2MeV/c) -> only LECS
// return lastPAR[3]/(p4+lastPAR[4]/p2)+lastPAR[5]/(p5+rp16*rp16)+
// lastPAR[7]/(p4+lastPAR[8]/p4)+nX[iZ][i]/(1.+lastPAR[51]*p16);
// }
//G4cerr<<"*G4QElCS::GTV:PDG="<<PDG<<",Z="<<tgZ<<",N="<<tgN<<": Sig not found"<<G4endl;
//}
}
else
{
source/processes/hadronic/models/chiral_inv_phase_space/interface/src/G4QElectronNuclearCrossSection.cc
+1 -1
View File
@@ -25,7 +25,7 @@
//
//
// $Id: G4QElectronNuclearCrossSection.cc,v 1.11 2006/12/04 10:44:22 mkossov Exp $
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// G4 Physics class: G4QElectronNuclearCrossSection for gamma+A cross sections
source/processes/hadronic/models/chiral_inv_phase_space/interface/src/G4QGluonString.cc
+1 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
// $Id: G4QGluonString.cc,v 1.1 2006/10/30 10:33:38 mkossov Exp $
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
// ---------------- G4QGluonString class -----------------
// by Mikhail Kossov, December 2003.
source/processes/hadronic/models/chiral_inv_phase_space/interface/src/G4QMuonNuclearCrossSection.cc
+1 -1
View File
@@ -25,7 +25,7 @@
//
//
// $Id: G4QMuonNuclearCrossSection.cc,v 1.11 2006/12/04 10:44:22 mkossov Exp $
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// G4 Physics class: G4QMuonNuclearCrossSection for gamma+A cross sections
source/processes/hadronic/models/chiral_inv_phase_space/interface/src/G4QNuMuNuclearCrossSection.cc
+1 -1
View File
@@ -25,7 +25,7 @@
//
//
// $Id: G4QNuMuNuclearCrossSection.cc,v 1.10 2006/12/01 10:57:47 mkossov Exp $
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// G4 Physics class: G4QNuMuNuclearCrossSection for gamma+A cross sections
source/processes/hadronic/models/chiral_inv_phase_space/interface/src/G4QPhotonNuclearCrossSection.cc
+1 -1
View File
@@ -25,7 +25,7 @@
//
//
// The lust update: M.V. Kossov, CERN/ITEP(Moscow) 17-June-02
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// G4 Physics class: G4QPhotonNuclearCrossSection for gamma+A cross sections
source/processes/hadronic/models/chiral_inv_phase_space/interface/src/G4QProtonNuclearCrossSection.cc
+1 -1
View File
@@ -25,7 +25,7 @@
//
//
// The lust update: M.V. Kossov, CERN/ITEP(Moscow) 17-June-02
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// G4 Physics class: G4QProtonNuclearCrossSection for gamma+A cross sections
source/processes/hadronic/models/chiral_inv_phase_space/interface/src/G4QTauNuclearCrossSection.cc
+1 -1
View File
@@ -25,7 +25,7 @@
//
//
// $Id: G4QTauNuclearCrossSection.cc,v 1.10 2006/12/04 10:44:22 mkossov Exp $
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// G4 Physics class: G4QTauNuclearCrossSection for gamma+A cross sections
source/processes/hadronic/models/chiral_inv_phase_space/interface/src/G4QuasiFreeRatios.cc
+212 -12
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4QuasiFreeRatios.cc,v 1.11 2007/05/02 15:00:02 gunter Exp $
// GEANT4 tag $Name: geant4-08-03 $
// $Id: G4QuasiFreeRatios.cc,v 1.14 2007/06/15 17:06:30 gcosmo Exp $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// G4 Physics class: G4QuasiFreeRatios for N+A elastic cross sections
@@ -40,6 +40,35 @@
#include "G4QuasiFreeRatios.hh"
// initialisation of statics
std::vector<G4double*> G4QuasiFreeRatios::vE; // Vector of ElastPointers to LogTable in C++ heap
std::vector<G4double*> G4QuasiFreeRatios::vT; // Vector of pointers to LinTable in C++ heap
std::vector<G4double*> G4QuasiFreeRatios::vL; // Vector of pointers to LogTable in C++ heap
std::vector<std::pair<G4double,G4double>*> G4QuasiFreeRatios::vX; // Vector of ETPointers to LogTable
G4QuasiFreeRatios::G4QuasiFreeRatios()
{
}
G4QuasiFreeRatios::~G4QuasiFreeRatios()
{
std::vector<G4double*>::iterator pos;
for(pos=vE.begin(); pos<vE.end(); pos++)
{ delete [] *pos; }
vE.clear();
for(pos=vT.begin(); pos<vT.end(); pos++)
{ delete [] *pos; }
vT.clear();
for(pos=vL.begin(); pos<vL.end(); pos++)
{ delete [] *pos; }
vL.clear();
std::vector<std::pair<G4double,G4double>*>::iterator pos2;
for(pos2=vX.begin(); pos2<vX.end(); pos2++)
{ delete [] *pos2; }
vX.clear();
}
// Returns Pointer to the G4VQCrossSection class
G4QuasiFreeRatios* G4QuasiFreeRatios::GetPointer()
{
@@ -86,8 +115,6 @@ G4double G4QuasiFreeRatios::GetQF2IN_Ratio(G4double s, G4int A)
static std::vector<G4int> vN; // Vector of topBin number initialized in LinTable
static std::vector<G4double> vM; // Vector of rel max ln(s) initialized in LogTable
static std::vector<G4int> vK; // Vector of topBin number initialized in LogTable
static std::vector<G4double*> vT; // Vector of pointers to LinTable in C++ heap
static std::vector<G4double*> vL; // Vector of pointers to LogTable in C++ heap
// Last values of the Associative Data Base:
static G4int lastA=0; // theLast of calculated A
static G4double lastH=0.; // theLast of max s initialized in the LinTable
@@ -545,8 +572,6 @@ std::pair<G4double,G4double> G4QuasiFreeRatios::FetchElTot(G4double p, G4int PDG
static std::vector<G4int> vI; // Vector of index for which XS was calculated
static std::vector<G4double> vM; // Vector of rel max ln(p) initialized in LogTable
static std::vector<G4int> vK; // Vector of topBin number initialized in LogTable
static std::vector<G4double*> vE; // Vector of ElastPointers to LogTable in C++ heap
static std::vector<std::pair<G4double,G4double>*> vX; // Vector of ETPointers to LogTable
// Last values of the Associative Data Base:
static G4int lastI=0; // The Last index for which XS was calculated
static G4double lastM=0.; // The Last rel max ln(p) initialized in LogTable
@@ -687,12 +712,54 @@ std::pair<G4double,G4double> G4QuasiFreeRatios::GetElTot(G4double pIU, G4int hPD
G4cout<<"-Warning-G4QuasiFreeRatio::GetElTot:Z="<<Z<<",N="<<N<<", return zero"<<G4endl;
return std::make_pair(0.,0.);
}
std::pair<G4double,G4double> pA=FetchElTot(pGeV, hPDG, true);
std::pair<G4double,G4double> nA=FetchElTot(pGeV, hPDG, false);
std::pair<G4double,G4double> hp=FetchElTot(pGeV, hPDG, true);
std::pair<G4double,G4double> hn=FetchElTot(pGeV, hPDG, false);
G4double A=(Z+N)/millibarn; // To make the result in independent units(IU)
return std::make_pair((Z*pA.first+N*nA.first)/A,(Z*pA.second+N*nA.second)/A);
return std::make_pair((Z*hp.first+N*hn.first)/A,(Z*hp.second+N*hn.second)/A);
} // End of GetElTot
// (Mean Elastic and Mean Total) Cross-Sections (mb) for PDG+(Z,N) at P=p[GeV/c]
std::pair<G4double,G4double> G4QuasiFreeRatios::GetChExFactor(G4double pIU, G4int hPDG,
G4int Z, G4int N)
{
G4double pGeV=pIU/gigaelectronvolt;
G4double resP=0.;
G4double resN=0.;
if(Z<1 && N<1)
{
G4cout<<"-Warning-G4QuasiFreeRatio::GetChExF:Z="<<Z<<",N="<<N<<", return zero"<<G4endl;
return std::make_pair(resP,resN);
}
G4double A=Z+N;
G4double pf=0.; // Possibility to interact with a proton
G4double nf=0.; // Possibility to interact with a neutron
if (hPDG==-211||hPDG==-321||hPDG==3112||hPDG==3212||hPDG==3312) pf=Z/A;
else if(hPDG==211||hPDG==321||hPDG==3222||hPDG==3212||hPDG==3322) nf=N/A;
else if(hPDG==-311||hPDG==311||hPDG==130||hPDG==310)
{
G4double dA=A+A;
pf=Z/dA;
nf=N/dA;
}
G4double mult=1.; // Factor of increasing multiplicity ( ? @@)
if(pGeV>.5)
{
mult=1./(1.+std::log(pGeV+pGeV))/pGeV;
if(mult>1.) mult=1.;
}
if(pf)
{
std::pair<G4double,G4double> hp=FetchElTot(pGeV, hPDG, true);
resP=pf*(hp.second/hp.first-1.)*mult;
}
if(nf)
{
std::pair<G4double,G4double> hn=FetchElTot(pGeV, hPDG, false);
resN=nf*(hn.second/hn.first-1.)*mult;
}
return std::make_pair(resP,resN);
} // End of GetChExFactor
// scatter (pPDG,p4M) on a virtual nucleon (NPDG,N4M), result: final pair(newN4M,newp4M)
// if(newN4M.e()==0.) - below threshold, XS=0, no scattering of the progectile happened
std::pair<G4LorentzVector,G4LorentzVector> G4QuasiFreeRatios::Scatter(G4int NPDG,
@@ -744,7 +811,7 @@ std::pair<G4LorentzVector,G4LorentzVector> G4QuasiFreeRatios::Scatter(G4int NPDG
#endif
#ifdef nandebug
if(xSec>0. || xSec<0. || xSec==0);
else G4cout<<"******G4QElast::Scatter:xSec="<<xSec/millibarn<<G4endl;
else G4cout<<"*Warning*G4QElast::Scatter: xSec="<<xSec/millibarn<<G4endl;
#endif
// @@ check a possibility to separate p, n, or alpha (!)
if(xSec <= 0.) // The cross-section iz 0 -> Do Nothing
@@ -757,11 +824,11 @@ std::pair<G4LorentzVector,G4LorentzVector> G4QuasiFreeRatios::Scatter(G4int NPDG
G4double mint=CSmanager->GetExchangeT(Z,N,PDG); // functional randomized -t (MeV^2) *TMP*
//G4double mint=CSmanager->GetExchangeT(Z,N,pPDG); // functional randomized -t in MeV^2
#ifdef pdebug
G4cout<<"G4QFR::SCAT:PDG="<<pPDG<<", P="<<Momentum<<", CS="<<xSec<<", -t="<<mint<<G4endl;
G4cout<<"G4QFR::Scat:PDG="<<pPDG<<", P="<<Momentum<<", CS="<<xSec<<", -t="<<mint<<G4endl;
#endif
#ifdef nandebug
if(mint>-.0000001);
else G4cout<<"******G4QFR::Scat:-t="<<mint<<G4endl;
else G4cout<<"*Warning*G4QFR::Scat: -t="<<mint<<G4endl;
#endif
G4double cost=1.-mint/CSmanager->GetHMaxT(); // cos(theta) in CMS
#ifdef ppdebug
@@ -790,3 +857,136 @@ std::pair<G4LorentzVector,G4LorentzVector> G4QuasiFreeRatios::Scatter(G4int NPDG
#endif
return std::make_pair(reco4M*megaelectronvolt,pr4M*megaelectronvolt); // Result
} // End of Scatter
// scatter (pPDG,p4M) on a virtual nucleon (NPDG,N4M), result: final pair(newN4M,newp4M)
// if(newN4M.e()==0.) - below threshold, XS=0, no scattering of the progectile happened
// User should himself change the charge (PDG) (e.g. pn->np, pi+n->pi0p, pi-p->pi0n etc.)
std::pair<G4LorentzVector,G4LorentzVector> G4QuasiFreeRatios::ChExer(G4int NPDG,
G4LorentzVector N4M, G4int pPDG, G4LorentzVector p4M)
{
static const G4double mNeut= G4QPDGCode(2112).GetMass();
static const G4double mProt= G4QPDGCode(2212).GetMass();
G4LorentzVector pr4M=p4M/megaelectronvolt; // Convert 4-momenta in MeV(keep p4M)
N4M/=megaelectronvolt;
G4LorentzVector tot4M=N4M+p4M;
G4int Z=0;
G4int N=1;
G4int RPDG=2212; // PDG of the recoil nucleon
G4int sPDG=0; // PDG code of the scattered hadron
G4double mS=0.; // proto of mass of scattered hadron
G4double mT=mProt; // mass of the recoil nucleon
if(NPDG==2212)
{
mT=mNeut;
Z=1;
N=0;
RPDG=2112; // PDG of the recoil nucleon
if(pPDG==-211) sPDG=111; // pi+ -> pi0
else if(pPDG==-321)
{
sPDG=310; // K+ -> K0S
if(G4UniformRand()>.5) sPDG=130; // K+ -> K0L
}
else if(pPDG==-311||pPDG==311||pPDG==130||pPDG==310) sPDG=321; // K0 -> K+ (?)
else if(pPDG==3112) sPDG=3212; // Sigma- -> Sigma0
else if(pPDG==3212) sPDG=3222; // Sigma0 -> Sigma+
else if(pPDG==3312) sPDG=3322; // Xi- -> Xi0
}
else if(NPDG==2112) // Default
{
if(pPDG==211) sPDG=111; // pi+ -> pi0
else if(pPDG==321)
{
sPDG=310; // K+ -> K0S
if(G4UniformRand()>.5) sPDG=130; // K+ -> K0L
}
else if(pPDG==-311||pPDG==311||pPDG==130||pPDG==310) sPDG=-321; // K0 -> K- (?)
else if(pPDG==3222) sPDG=3212; // Sigma+ -> Sigma0
else if(pPDG==3212) sPDG=3112; // Sigma0 -> Sigma-
else if(pPDG==3322) sPDG=3312; // Xi0 -> Xi-
}
else
{
G4cout<<"Error:G4QuasiFreeRatios::ChExer: NPDG="<<NPDG<<" is not 2212 or 2112"<<G4endl;
G4Exception("G4QuasiFreeRatios::ChExer:","21",FatalException,"CHIPS complain");
//return std::make_pair(G4LorentzVector(0.,0.,0.,0.),p4M);// Use this if not exception
}
if(sPDG) mS=G4QPDGCode(2112).GetMass();
else
{
G4cout<<"Error:G4QuasiFreeRatios::ChExer: BAD pPDG="<<pPDG<<", NPDG="<<NPDG<<G4endl;
G4Exception("G4QuasiFreeRatios::ChExer:","21",FatalException,"CHIPS complain");
//return std::make_pair(G4LorentzVector(0.,0.,0.,0.),p4M);// Use this if not exception
}
G4double mT2=mT*mT;
G4double mS2=mS*mS;
G4double E=(tot4M.m2()-mT2-mS2)/(mT+mT);
G4double E2=E*E;
if(E<0. || E2<mS2)
{
#ifdef pdebug
G4cerr<<"-Warning-G4QFR::ChEx:*Negative Energy*E="<<E<<",E2="<<E2<<"<M2="<<mS2<<G4endl;
#endif
return std::make_pair(G4LorentzVector(0.,0.,0.,0.),p4M); // Do Nothing Action
}
G4double P=std::sqrt(E2-mS2); // Momentum in pseudo laboratory system
G4VQCrossSection* CSmanager=G4QElasticCrossSection::GetPointer();
#ifdef debug
G4cout<<"G4QFR::ChExer: Before XS, P="<<P<<", Z="<<Z<<", N="<<N<<", PDG="<<pPDG<<G4endl;
#endif
// @@ Temporary NN t-dependence for all hadrons
G4int PDG=2212; // *TMP* instead of pPDG
G4double xSec=CSmanager->GetCrossSection(false, P, Z, N, PDG); // Rec.CrossSect *TMP*
//G4double xSec=CSmanager->GetCrossSection(false, P, Z, N, pPDG); // Rec.CrossSect
#ifdef debug
G4cout<<"G4QElast::ChExer:pPDG="<<pPDG<<",P="<<P<<",CS="<<xSec/millibarn<<G4endl;
#endif
#ifdef nandebug
if(xSec>0. || xSec<0. || xSec==0);
else G4cout<<"*Warning*G4QElast::ChExer: xSec="<<xSec/millibarn<<G4endl;
#endif
// @@ check a possibility to separate p, n, or alpha (!)
if(xSec <= 0.) // The cross-section iz 0 -> Do Nothing
{
#ifdef pdebug
G4cerr<<"-Warning-G4QFR::ChEx:**Zero XS**PDG="<<pPDG<<",NPDG="<<NPDG<<",P="<<P<<G4endl;
#endif
return std::make_pair(G4LorentzVector(0.,0.,0.,0.),p4M); //Do Nothing Action
}
G4double mint=CSmanager->GetExchangeT(Z,N,PDG); // functional randomized -t (MeV^2) *TMP*
//G4double mint=CSmanager->GetExchangeT(Z,N,pPDG); // functional randomized -t in MeV^2
#ifdef pdebug
G4cout<<"G4QFR::ChEx:PDG="<<pPDG<<", P="<<Momentum<<", CS="<<xSec<<", -t="<<mint<<G4endl;
#endif
#ifdef nandebug
if(mint>-.0000001);
else G4cout<<"*Warning*G4QFR::ChExer: -t="<<mint<<G4endl;
#endif
G4double cost=1.-mint/CSmanager->GetHMaxT(); // cos(theta) in CMS
#ifdef ppdebug
G4cout<<"G4QFR::ChEx:-t="<<mint<<",dpc2="<<CSmanager->GetHMaxT()<<",cost="<<cost<<G4endl;
#endif
if(cost>1. || cost<-1. || !(cost>-1. || cost<=1.))
{
if (cost>1.) cost=1.;
else if(cost<-1.) cost=-1.;
else
{
G4cerr<<"G4QFR::C:*NAN*c="<<cost<<",t="<<mint<<",tm="<<CSmanager->GetHMaxT()<<G4endl;
return std::make_pair(G4LorentzVector(0.,0.,0.,0.),p4M); // Do Nothing Action
}
}
G4LorentzVector reco4M=G4LorentzVector(0.,0.,0.,mT); // 4mom of the recoil nucleon
pr4M=G4LorentzVector(0.,0.,0.,mS); // 4mom of the scattered hadron
G4LorentzVector dir4M=tot4M-G4LorentzVector(0.,0.,0.,(tot4M.e()-mT)*.01);
if(!G4QHadron(tot4M).RelDecayIn2(pr4M, reco4M, dir4M, cost, cost))
{
G4cerr<<"G4QFR::ChEx:t="<<tot4M<<tot4M.m()<<",mT="<<mT<<",mP="<<mS<<G4endl;
//G4Exception("G4QFR::ChExer:","009",FatalException,"Decay of ElasticComp");
return std::make_pair(G4LorentzVector(0.,0.,0.,0.),p4M); // Do Nothing Action
}
#ifdef debug
G4cout<<"G4QFR::ChEx:p4M="<<p4M<<"+r4M="<<reco4M<<"="<<scat4M+reco4M<<"="<<tot4M<<G4endl;
#endif
return std::make_pair(reco4M*megaelectronvolt,pr4M*megaelectronvolt); // Result
} // End of ChExer
source/processes/hadronic/models/chiral_inv_phase_space/interface/src/G4StringChipsParticleLevelInterface.cc
+4 -3
View File
@@ -679,12 +679,13 @@ Propagate(G4KineticTrackVector* theSecondaries, G4V3DNucleus* theNucleus)
}
throw;
}
// clean up particles
std::for_each(projHV.begin(), projHV.end(), DeleteQHadron());
projHV.clear();
delete pan;
}
else output = new G4QHadronVector;
// clean up impinging particles
std::for_each(projHV.begin(), projHV.end(), DeleteQHadron());
projHV.clear();
// Fill the result.
#ifdef CHIPSdebug
source/processes/hadronic/models/chiral_inv_phase_space/interface/src/G4VQCrossSection.cc
+1 -1
View File
@@ -25,7 +25,7 @@
//
//
// $Id: G4VQCrossSection.cc,v 1.13 2006/12/09 14:33:35 mkossov Exp $
// GEANT4 tag $Name: geant4-08-02 $
// GEANT4 tag $Name: geant4-09-00 $
//
//
// CHIPS virtual class: G4VQCrossSection for the collision cross sections