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

Import Geant4 10.4.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2017-06-30 11:12:01 +02:00
parent 1a1316fea4
commit 2cce0e189d
238 changed files with 0 additions and 62655 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/hadronic/models/de_excitation/fermi_breakup/include/G4B9FermiFragment.hh
-60
View File
@@ -1,60 +0,0 @@
//
// ********************************************************************
// * 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: G4B9FermiFragment.hh 67983 2013-03-13 10:42:03Z gcosmo $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
//
// Modifications:
// 01.04.2011 General cleanup by V.Ivanchenko
#ifndef G4B9FermiFragment_h
#define G4B9FermiFragment_h 1
#include "G4UnstableFermiFragment.hh"
class G4B9FermiFragment : public G4UnstableFermiFragment
{
public:
G4B9FermiFragment(G4int anA, G4int aZ, G4int Pol, G4double ExE);
virtual ~G4B9FermiFragment();
private:
G4B9FermiFragment(const G4B9FermiFragment &right);
const G4B9FermiFragment & operator=(const G4B9FermiFragment &right);
G4bool operator==(const G4B9FermiFragment &right) const;
G4bool operator!=(const G4B9FermiFragment &right) const;
};
#endif
source/processes/hadronic/models/de_excitation/fermi_breakup/include/G4Be8FermiFragment.hh
-60
View File
@@ -1,60 +0,0 @@
//
// ********************************************************************
// * 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: G4Be8FermiFragment.hh 67983 2013-03-13 10:42:03Z gcosmo $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
//
// Modifications:
// 01.04.2011 General cleanup by V.Ivanchenko
#ifndef G4Be8FermiFragment_h
#define G4Be8FermiFragment_h 1
#include "G4UnstableFermiFragment.hh"
class G4Be8FermiFragment : public G4UnstableFermiFragment
{
public:
G4Be8FermiFragment(G4int anA, G4int aZ, G4int Pol, G4double ExE);
virtual ~G4Be8FermiFragment();
private:
G4Be8FermiFragment(const G4Be8FermiFragment &right);
const G4Be8FermiFragment & operator=(const G4Be8FermiFragment &right);
G4bool operator==(const G4Be8FermiFragment &right) const;
G4bool operator!=(const G4Be8FermiFragment &right) const;
};
#endif
source/processes/hadronic/models/de_excitation/fermi_breakup/include/G4FermiBreakUp.hh
-92
View File
@@ -1,92 +0,0 @@
//
// ********************************************************************
// * 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: G4FermiBreakUp.hh 100379 2016-10-19 15:05:35Z gcosmo $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
#ifndef G4FermiBreakUp_h
#define G4FermiBreakUp_h 1
#include "G4VFermiBreakUp.hh"
#include "globals.hh"
#include "G4FermiConfiguration.hh"
#include "G4VFermiFragment.hh"
#include "G4FermiPhaseSpaceDecay.hh"
#include <vector>
class G4FermiFragmentsPool;
class G4Pow;
class G4FermiBreakUp : public G4VFermiBreakUp
{
public:
explicit G4FermiBreakUp();
virtual ~G4FermiBreakUp();
virtual void Initialise() final;
virtual G4bool IsApplicable(G4int Z, G4int A, G4double mass) const final;
// new interface - vector of products is added to the provided vector
// primary fragment is deleted or is modified and added to the list
// of products
virtual void BreakFragment(G4FragmentVector*, G4Fragment* theNucleus) final;
private:
G4double CoulombBarrier(const std::vector<const G4VFermiFragment*>* v);
G4double DecayProbability(G4int A, G4double TotalE, const G4FermiConfiguration*);
const std::vector<const G4VFermiFragment*>*
SelectConfiguration(G4int Z, G4int A, G4double mass);
G4FermiBreakUp(const G4FermiBreakUp &right) = delete;
const G4FermiBreakUp & operator=(const G4FermiBreakUp &right) = delete;
G4bool operator==(const G4FermiBreakUp &right) const = delete;
G4bool operator!=(const G4FermiBreakUp &right) const = delete;
G4FermiFragmentsPool* thePool;
std::vector<G4double> NormalizedWeights;
G4double Coef;
G4double ConstCoeff;
size_t nmax;
G4Pow* g4calc;
const G4FermiPhaseSpaceDecay* thePhaseSpace;
std::vector<G4double> massRes;
std::vector<const G4VFermiFragment*> frag;
};
#endif
source/processes/hadronic/models/de_excitation/fermi_breakup/include/G4FermiConfiguration.hh
-92
View File
@@ -1,92 +0,0 @@
//
// ********************************************************************
// * 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: G4FermiConfiguration.hh 85841 2014-11-05 15:35:06Z gcosmo $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
// 23.04.2011 V.Ivanchenko: make this class to be a simple container and no physics
#ifndef G4FermiConfiguration_h
#define G4FermiConfiguration_h 1
#include "globals.hh"
#include "G4VFermiFragment.hh"
#include "G4Fragment.hh"
class G4FermiConfiguration
{
public:
G4FermiConfiguration(const std::vector<const G4VFermiFragment*>&);
~G4FermiConfiguration();
inline G4int GetA() const;
inline G4int GetZ() const;
inline G4double GetMass() const;
inline const std::vector<const G4VFermiFragment*>* GetFragmentList() const;
private:
inline G4FermiConfiguration(const G4FermiConfiguration &);
inline const G4FermiConfiguration & operator=(const G4FermiConfiguration &);
inline G4bool operator==(const G4FermiConfiguration &) const;
inline G4bool operator!=(const G4FermiConfiguration &) const;
G4int totalZ;
G4int totalA;
G4double totalMass;
std::vector<const G4VFermiFragment*> Configuration;
};
inline G4int G4FermiConfiguration::GetA() const
{
return totalA;
}
inline G4int G4FermiConfiguration::GetZ() const
{
return totalZ;
}
inline G4double G4FermiConfiguration::GetMass() const
{
return totalMass;
}
inline const std::vector<const G4VFermiFragment*>*
G4FermiConfiguration::GetFragmentList() const
{
return &Configuration;
}
#endif
source/processes/hadronic/models/de_excitation/fermi_breakup/include/G4FermiFragmentsPool.hh
-97
View File
@@ -1,97 +0,0 @@
//
// ********************************************************************
// * 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: G4FermiFragmentsPool.hh,v 1.5 2006-06-29 20:13:13 gunter Exp $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara
//
// Modifications:
// 01.04.2011 General cleanup by V.Ivanchenko - more clean usage of static
#ifndef G4FermiFragmentsPool_hh
#define G4FermiFragmentsPool_hh 1
#include "globals.hh"
#include "G4VFermiFragment.hh"
#include "G4FermiConfiguration.hh"
#include "G4FermiPhaseSpaceDecay.hh"
#include <vector>
class G4FermiFragmentsPool
{
public:
static G4FermiFragmentsPool* Instance();
~G4FermiFragmentsPool();
G4bool IsApplicable(G4int Z, G4int A, G4double mass) const;
const std::vector<const G4FermiConfiguration*>*
GetConfigurationList(G4int Z, G4int A, G4double mass) const;
const G4VFermiFragment* GetFragment(G4int Z, G4int A) const;
const G4FermiPhaseSpaceDecay* GetFermiPhaseSpaceDecay() const;
G4int GetMaxZ() const;
G4int GetMaxA() const;
void DumpFragment(const G4VFermiFragment* f) const;
void Dump() const;
private:
G4FermiFragmentsPool();
void Initialise();
G4bool IsExist(G4int Z, G4int A, std::vector<const G4VFermiFragment*>&) const;
G4bool IsAvailable(G4int Z, G4int A) const;
static G4FermiFragmentsPool* theInstance;
std::vector<const G4VFermiFragment*> fragment_pool;
G4int maxZ;
G4int maxA;
G4int verbose;
// list of configuration sorted by A for 1, 2, 3, 4 final fragments
std::vector<const G4FermiConfiguration*> list1[17];
std::vector<const G4FermiConfiguration*> list2[17];
std::vector<const G4FermiConfiguration*> list3[17];
std::vector<const G4FermiConfiguration*> list4[17];
G4FermiPhaseSpaceDecay thePhaseSpace;
};
#endif
source/processes/hadronic/models/de_excitation/fermi_breakup/include/G4He5FermiFragment.hh
-59
View File
@@ -1,59 +0,0 @@
//
// ********************************************************************
// * 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: G4He5FermiFragment.hh 67983 2013-03-13 10:42:03Z gcosmo $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
//
// Modifications:
// 01.04.2011 General cleanup by V.Ivanchenko: integer Z and A, constructor
#ifndef G4He5FermiFragment_h
#define G4He5FermiFragment_h 1
#include "G4UnstableFermiFragment.hh"
class G4He5FermiFragment : public G4UnstableFermiFragment
{
public:
G4He5FermiFragment(G4int anA, G4int aZ, G4int Pol, G4double ExE);
~G4He5FermiFragment();
private:
G4He5FermiFragment(const G4He5FermiFragment &right);
const G4He5FermiFragment & operator=(const G4He5FermiFragment &right);
G4bool operator==(const G4He5FermiFragment &right) const;
G4bool operator!=(const G4He5FermiFragment &right) const;
};
#endif
source/processes/hadronic/models/de_excitation/fermi_breakup/include/G4Li5FermiFragment.hh
-59
View File
@@ -1,59 +0,0 @@
//
// ********************************************************************
// * 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: G4Li5FermiFragment.hh 67983 2013-03-13 10:42:03Z gcosmo $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
//
// Modifications:
// 01.04.2011 General cleanup by V.Ivanchenko
#ifndef G4Li5FermiFragment_h
#define G4Li5FermiFragment_h 1
#include "G4UnstableFermiFragment.hh"
class G4Li5FermiFragment : public G4UnstableFermiFragment
{
public:
G4Li5FermiFragment(G4int anA, G4int aZ, G4int Pol, G4double ExE);
virtual ~G4Li5FermiFragment();
private:
G4Li5FermiFragment(const G4Li5FermiFragment &right);
const G4Li5FermiFragment & operator=(const G4Li5FermiFragment &right);
G4bool operator==(const G4Li5FermiFragment &right) const;
G4bool operator!=(const G4Li5FermiFragment &right) const;
};
#endif
source/processes/hadronic/models/de_excitation/fermi_breakup/include/G4StableFermiFragment.hh
-61
View File
@@ -1,61 +0,0 @@
//
// ********************************************************************
// * 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: G4StableFermiFragment.hh 97097 2016-05-25 07:50:31Z gcosmo $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
//
// Modifications:
// 01.04.2011 General cleanup by V.Ivanchenko
#ifndef G4StableFermiFragment_h
#define G4StableFermiFragment_h 1
#include "G4VFermiFragment.hh"
class G4StableFermiFragment : public G4VFermiFragment
{
public:
explicit G4StableFermiFragment(G4int anA, G4int aZ, G4int Pol, G4double ExE);
virtual ~G4StableFermiFragment();
virtual void FillFragment(G4FragmentVector*, const G4LorentzVector & aMomentum) const final;
private:
G4StableFermiFragment(const G4StableFermiFragment &right) = delete;
const G4StableFermiFragment & operator=(const G4StableFermiFragment &right) = delete;
G4bool operator==(const G4StableFermiFragment &right) const = delete;
G4bool operator!=(const G4StableFermiFragment &right) const = delete;
};
#endif
source/processes/hadronic/models/de_excitation/fermi_breakup/include/G4UnstableFermiFragment.hh
-68
View File
@@ -1,68 +0,0 @@
//
// ********************************************************************
// * 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: G4UnstableFermiFragment.hh 97097 2016-05-25 07:50:31Z gcosmo $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
//
// Modifications:
// 01.04.2011 General cleanup by V.Ivanchenko: integer Z and A, constructor
#ifndef G4UnstableFermiFragment_h
#define G4UnstableFermiFragment_h 1
#include "G4VFermiFragment.hh"
#include "G4FermiPhaseSpaceDecay.hh"
class G4UnstableFermiFragment : public G4VFermiFragment
{
public:
explicit G4UnstableFermiFragment(G4int anA, G4int aZ, G4int Pol, G4double ExE);
virtual ~G4UnstableFermiFragment();
virtual void FillFragment(G4FragmentVector*, const G4LorentzVector & aMomentum) const final;
private:
G4UnstableFermiFragment(const G4UnstableFermiFragment &right);
const G4UnstableFermiFragment & operator=(const G4UnstableFermiFragment &right);
G4bool operator==(const G4UnstableFermiFragment &right) const;
G4bool operator!=(const G4UnstableFermiFragment &right) const;
protected:
std::vector<G4double> Masses;
std::vector<G4int> Charges;
std::vector<G4int> AtomNum;
};
#endif
source/processes/hadronic/models/de_excitation/fermi_breakup/include/G4VFermiFragment.hh
-114
View File
@@ -1,114 +0,0 @@
//
// ********************************************************************
// * 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: G4VFermiFragment.hh 97097 2016-05-25 07:50:31Z gcosmo $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
//
// Modifications:
// 01.04.2011 General cleanup by V.Ivanchenko
#ifndef G4VFermiFragment_h
#define G4VFermiFragment_h 1
#include "G4FragmentVector.hh"
#include "globals.hh"
class G4VFermiFragment
{
public:
explicit G4VFermiFragment(G4int anA, G4int aZ, G4int Pol,
G4double exc, G4bool stable = true);
virtual ~G4VFermiFragment();
virtual void
FillFragment(G4FragmentVector*, const G4LorentzVector & aMomentum) const = 0;
inline G4FragmentVector * GetFragment(const G4LorentzVector & aMomentum) const
{
G4FragmentVector* vec = new G4FragmentVector();
FillFragment(vec, aMomentum);
return vec;
}
inline G4int GetA(void) const
{
return A;
}
inline G4int GetZ(void) const
{
return Z;
}
inline G4int GetPolarization(void) const
{
return Polarization;
}
inline G4double GetExcitationEnergy(void) const
{
return ExcitEnergy;
}
inline G4double GetFragmentMass(void) const
{
return fragmentMass;
}
inline G4double GetTotalEnergy(void) const
{
return (GetFragmentMass() + GetExcitationEnergy());
}
inline G4bool IsStable() const
{
return isStable;
}
private:
G4bool isStable;
G4int A;
G4int Z;
G4int Polarization;
G4double ExcitEnergy;
G4double fragmentMass;
G4VFermiFragment(const G4VFermiFragment &right) = delete;
const G4VFermiFragment & operator=(const G4VFermiFragment &right) = delete;
G4bool operator==(const G4VFermiFragment &right) const = delete;
G4bool operator!=(const G4VFermiFragment &right) const = delete;
};
#endif
source/processes/hadronic/models/de_excitation/fermi_breakup/src/G4B9FermiFragment.cc
-57
View File
@@ -1,57 +0,0 @@
//
// ********************************************************************
// * 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: G4B9FermiFragment.cc 67983 2013-03-13 10:42:03Z gcosmo $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
//
// Modifications:
// 01.04.2011 General cleanup by V.Ivanchenko:
#include "G4B9FermiFragment.hh"
#include "G4NucleiProperties.hh"
G4B9FermiFragment::G4B9FermiFragment(G4int anA, G4int aZ, G4int Pol, G4double ExE)
: G4UnstableFermiFragment(anA,aZ,Pol,ExE)
{
// B9 ----> alpha + alpha + proton
Masses.push_back(G4NucleiProperties::GetNuclearMass(4,2));
Masses.push_back(G4NucleiProperties::GetNuclearMass(4,2));
Masses.push_back(CLHEP::proton_mass_c2);
AtomNum.push_back(4);
AtomNum.push_back(4);
AtomNum.push_back(1);
Charges.push_back(2);
Charges.push_back(2);
Charges.push_back(1);
}
G4B9FermiFragment::~G4B9FermiFragment()
{}
source/processes/hadronic/models/de_excitation/fermi_breakup/src/G4Be8FermiFragment.cc
-55
View File
@@ -1,55 +0,0 @@
//
// ********************************************************************
// * 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: G4Be8FermiFragment.cc 67983 2013-03-13 10:42:03Z gcosmo $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
//
// Modifications:
// 01.04.2011 General cleanup by V.Ivanchenko:
#include "G4Be8FermiFragment.hh"
#include "G4NucleiProperties.hh"
G4Be8FermiFragment::G4Be8FermiFragment(G4int anA, G4int aZ, G4int Pol, G4double ExE)
: G4UnstableFermiFragment(anA,aZ,Pol,ExE)
{
// Be8 ----> alpha + alpha
Masses.push_back(G4NucleiProperties::GetNuclearMass(4,2));
Masses.push_back(G4NucleiProperties::GetNuclearMass(4,2));
AtomNum.push_back(4);
AtomNum.push_back(4);
Charges.push_back(2);
Charges.push_back(2);
}
G4Be8FermiFragment::~G4Be8FermiFragment()
{}
source/processes/hadronic/models/de_excitation/fermi_breakup/src/G4FermiBreakUp.cc
-272
View File
@@ -1,272 +0,0 @@
//
// ********************************************************************
// * 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: G4VFermiBreakUp.cc,v 1.5 2006-06-29 20:13:13 gunter Exp $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
//
// Modifications:
// 01.04.2011 General cleanup by V.Ivanchenko - use only one object
// theConfigurationList and do not instantiate it at each decay
#include "G4FermiBreakUp.hh"
#include "G4FermiFragmentsPool.hh"
#include "G4PhysicalConstants.hh"
#include "Randomize.hh"
#include "G4Pow.hh"
G4FermiBreakUp::G4FermiBreakUp() : thePhaseSpace(nullptr)
{
g4calc = G4Pow::GetInstance();
Coef = ConstCoeff = 0.0;
nmax = 16;
NormalizedWeights.resize(nmax,0.0);
massRes.reserve(4);
frag.resize(4, 0);
thePool = G4FermiFragmentsPool::Instance();
Initialise();
}
G4FermiBreakUp::~G4FermiBreakUp()
{}
void G4FermiBreakUp::Initialise()
{
if(thePhaseSpace != nullptr) { return; }
// Kappa = V/V_0 it is used in calculation of Coulomb energy
// Nuclear radius r0 (is a model parameter)
G4double Kappa = 6.0;
G4double r0 = 1.3*CLHEP::fermi;
Coef = 0.6*(CLHEP::elm_coupling/r0)/g4calc->Z13(1+G4int(Kappa));
ConstCoeff = g4calc->powN(r0/hbarc,3)*Kappa/(6.0*pi*pi);
thePhaseSpace = thePool->GetFermiPhaseSpaceDecay();
}
G4bool G4FermiBreakUp::IsApplicable(G4int Z, G4int A, G4double mass) const
{
return thePool->IsApplicable(Z, A, mass);
}
G4double G4FermiBreakUp::CoulombBarrier(
const std::vector<const G4VFermiFragment*>* conf)
{
// Calculates Coulomb Barrier (MeV) for given channel with K fragments.
G4int SumA = 0;
G4int SumZ = 0;
G4double CoulombEnergy = 0.;
size_t nn = conf->size();
for (size_t i=0; i<nn; ++i) {
G4int z = (*conf)[i]->GetZ();
G4int a = (*conf)[i]->GetA();
CoulombEnergy += G4double(z*z)/g4calc->Z13(a);
SumA += a;
SumZ += z;
}
CoulombEnergy -= SumZ*SumZ/g4calc->Z13(SumA);
return -Coef * CoulombEnergy;
}
void G4FermiBreakUp::BreakFragment(G4FragmentVector* theResult,
G4Fragment* theNucleus)
{
if(thePool == nullptr) { Initialise(); }
// Calculate Momenta of K fragments
G4double M = theNucleus->GetMomentum().m();
const std::vector<const G4VFermiFragment*>* conf =
SelectConfiguration(theNucleus->GetZ_asInt(),
theNucleus->GetA_asInt(), M);
// should never happen
if(!conf) {
theResult->push_back(theNucleus);
return;
}
size_t nn = conf->size();
// should never happen
if(0 == nn) {
theResult->push_back(theNucleus);
return;
}
G4LorentzVector fourMomentum = theNucleus->GetMomentum();
// one unstable fragment
if(1 == nn) {
(*conf)[0]->FillFragment(theResult, fourMomentum);
// normal case
} else {
G4ThreeVector boostVector = fourMomentum.boostVector();
massRes.clear();
for(size_t i=0; i<nn; ++i) {
massRes.push_back( (*conf)[i]->GetTotalEnergy() );
}
std::vector<G4LorentzVector*>* mom = thePhaseSpace->Decay(M, massRes);
// size_t nmom = mom->size();
// G4cout << "nmom= " << nmom << G4endl;
// Go back to the Lab Frame
for (size_t j=0; j<nn; ++j) {
(*mom)[j]->boost(boostVector);
(*conf)[j]->FillFragment(theResult, *((*mom)[j]));
delete (*mom)[j];
}
delete mom;
}
delete theNucleus;
}
const std::vector<const G4VFermiFragment*>*
G4FermiBreakUp::SelectConfiguration(G4int Z, G4int A, G4double mass)
{
const std::vector<const G4VFermiFragment*>* res = 0;
// new std::vector<const G4VFermiFragment*>;
const std::vector<const G4FermiConfiguration*>* conflist =
thePool->GetConfigurationList(Z, A, mass);
if(!conflist) { return res; }
size_t nn = conflist->size();
if(0 < nn) {
size_t idx = 0;
if(1 < nn) {
if(nn > nmax) {
nmax = nn;
NormalizedWeights.resize(nmax,0.0);
}
G4double prob = 0.0;
for(size_t i=0; i<nn; ++i) {
prob += DecayProbability(A, mass, (*conflist)[i]);
NormalizedWeights[i] = prob;
}
prob *= G4UniformRand();
for(idx=0; idx<nn; ++idx) {
if(NormalizedWeights[idx] >= prob) { break; }
}
}
//const std::vector<const G4VFermiFragment*> flist =
res = (*conflist)[idx]->GetFragmentList();
//size_t nf = flist.size();
//for(size_t i=0; i<nf; ++i) { res->push_back(flist[i]); }
//G4cout << "FermiBreakUp: " << nn << " conf; selected idx= "
// << idx << " Nprod= " << nf << G4endl;
}
delete conflist;
return res;
}
G4double G4FermiBreakUp::DecayProbability(G4int A, G4double TotalE,
const G4FermiConfiguration* conf)
// Decay probability for a given channel with K fragments
{
// A: Atomic Weight
// TotalE: Total energy of nucleus
G4double KineticEnergy = TotalE;
const std::vector<const G4VFermiFragment*>* flist =
conf->GetFragmentList();
// Number of fragments
size_t K = flist->size();
if(K > frag.size()) { frag.resize(K, 0); }
for (size_t i=0; i<K; ++i) {
frag[i] = (*flist)[i];
KineticEnergy -=
((*flist)[i]->GetFragmentMass() + (*flist)[i]->GetExcitationEnergy());
}
// Check that there is enough energy to produce K fragments
KineticEnergy -= CoulombBarrier(flist);
if (KineticEnergy <= 0.0) { return 0.0; }
// Spin factor S_n
G4double S_n = 1.0;
// mass factors
G4double ProdMass = 1.0;
G4double SumMass = 0.0;
for (size_t i=0; i<K; ++i) {
G4double mass = (*flist)[i]->GetFragmentMass();
ProdMass *= mass;
SumMass += mass;
S_n *= (*flist)[i]->GetPolarization();
}
G4double MassFactor = ProdMass/SumMass;
MassFactor *= std::sqrt(MassFactor);
G4double Coeff = g4calc->powN(ConstCoeff*A, K-1);
//JMQ 111009 Bug fixed: gamma function for odd K was wrong by a factor 2
//VI 251014 Use G4Pow
G4double Gamma = 1.0;
G4double Energ = twopi*KineticEnergy;
// integer argument of Gamma function
if ((K-1)%2 != 1) {
G4int N = 3*(K-1)/2;
Gamma = g4calc->factorial(N - 1);
Energ = g4calc->powN(Energ, N);
// n + 1/2 argument of Gamma function
// http://en.wikipedia.org/wiki/Gamma_function
} else {
G4int n2 = 3*K - 4;
G4int n1 = n2/2;
static const G4double sqrtpi = std::sqrt(CLHEP::pi);
Gamma = sqrtpi*g4calc->factorial(n2)/
(g4calc->powN(4.0,n1)*g4calc->factorial(n1));
Energ = g4calc->powN(Energ, n1)*std::sqrt(Energ);
}
// Permutation Factor G_n
// search for identical fragments
G4double G_n = 1.0;
for(size_t i=0; i<K-1; ++i) {
if(frag[i]) {
G4int nf = 1;
for(size_t j=i+1; j<K; ++j) {
if(frag[i] == frag[j]) {
++nf;
frag[j] = 0;
}
}
if(1 < nf) { G_n *= g4calc->factorial(nf); }
}
}
G4double Weight = Coeff*MassFactor*S_n*Energ/(G_n*Gamma*KineticEnergy);
return Weight;
}
source/processes/hadronic/models/de_excitation/fermi_breakup/src/G4FermiConfiguration.cc
-53
View File
@@ -1,53 +0,0 @@
//
// ********************************************************************
// * 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: G4FermiConfiguration.cc 67983 2013-03-13 10:42:03Z gcosmo $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
//
// Modifications:
// J. M. Quesada (12 October 2009) new implementation of Gamma function in configuration weight
// J. M. Quesada (09 March 2010) Kappa is set to 6.
// 01.04.2011 General cleanup by V.Ivanchenko: integer Z and A, constructor
// 23.04.2011 V.Ivanchenko: make this class to be a simple container and no physics
#include "G4FermiConfiguration.hh"
G4FermiConfiguration::G4FermiConfiguration(const std::vector<const G4VFermiFragment*>& v)
{
Configuration = v;
totalA = totalZ = 0;
totalMass = 0.0;
size_t nn = v.size();
for(size_t i=0; i<nn; ++i) {
totalA += v[i]->GetA();
totalZ += v[i]->GetZ();
totalMass += v[i]->GetTotalEnergy();
}
}
G4FermiConfiguration::~G4FermiConfiguration()
{}
source/processes/hadronic/models/de_excitation/fermi_breakup/src/G4FermiFragmentsPool.cc
-683
View File
@@ -1,683 +0,0 @@
//
// ********************************************************************
// * 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: G4FermiFragmentsPool.cc,v 1.5 2006-06-29 20:13:13 gunter Exp $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara
//
// Modifications:
// J.M.Quesada, July 2009, bug fixed in excitation energies:
// ALL of them are in MeV instead of keV (as they were expressed previously)
// source: http://www.nndc.bnl.gov/chart
// Unknown excitation energies in He5 and Li5 have been suppressed
// Long lived levels (half-lives of the order ps-fs have been included)
//
// J. M. Quesada, April 2010: excitation energies according to tabulated values
// in PhotonEvaporatoion2.0. Fake photons eliminated.
//
// 01.04.2011 General cleanup by V.Ivanchenko - more clean usage of static
//
// 04.05.2011 J. M. Quesada: added detailed printout for testing
#include "G4FermiFragmentsPool.hh"
#include "G4PhysicalConstants.hh"
#include "G4SystemOfUnits.hh"
#include "G4StableFermiFragment.hh"
#include "G4B9FermiFragment.hh"
#include "G4Be8FermiFragment.hh"
#include "G4He5FermiFragment.hh"
#include "G4Li5FermiFragment.hh"
G4FermiFragmentsPool* G4FermiFragmentsPool::theInstance = nullptr;
G4FermiFragmentsPool* G4FermiFragmentsPool::Instance()
{
if(0 == theInstance) {
static G4FermiFragmentsPool instance;
theInstance = &instance;
}
return theInstance;
}
G4FermiFragmentsPool::G4FermiFragmentsPool()
{
maxZ = 9;
maxA = 17;
verbose = 0;
Initialise();
}
G4FermiFragmentsPool::~G4FermiFragmentsPool()
{
size_t nn;
for(size_t i=0; i<17; ++i) {
nn = list1[i].size();
if(0 < nn) { for(size_t j=0; j<nn; ++j) { delete (list1[i])[j]; }}
nn = list2[i].size();
if(0 < nn) { for(size_t j=0; j<nn; ++j) { delete (list2[i])[j]; }}
nn = list3[i].size();
if(0 < nn) { for(size_t j=0; j<nn; ++j) { delete (list3[i])[j]; }}
nn = list4[i].size();
if(0 < nn) { for(size_t j=0; j<nn; ++j) { delete (list4[i])[j]; }}
}
nn = fragment_pool.size();
if(0 < nn) { for(size_t j=0; j<nn; ++j) { delete fragment_pool[j]; }}
}
G4bool G4FermiFragmentsPool::IsAvailable(G4int Z, G4int A) const
{
G4bool res = true;
if (2 == Z && 5 == A) { res = false; }
else if(3 == Z && 5 == A) { res = false; }
else if(4 == Z && 8 == A) { res = false; }
else if(5 == Z && 9 == A) { res = false; }
return res;
}
G4int G4FermiFragmentsPool::GetMaxZ() const
{
return maxZ;
}
G4int G4FermiFragmentsPool::GetMaxA() const
{
return maxA;
}
const G4FermiPhaseSpaceDecay*
G4FermiFragmentsPool::GetFermiPhaseSpaceDecay() const
{
return &thePhaseSpace;
}
void G4FermiFragmentsPool::Initialise()
{
// JMQ 30/06/09 unknown levels have been supressed
// JMQ 01/07/09 corrected excitation energies for 64-66, according to
// http://www.nndc.bnl.gov/chart
// JMQ 19/04/10 new level, fragment numbering shifted accordingly from here onwards
// A Z Pol ExcitE
fragment_pool.push_back(new G4StableFermiFragment( 1, 0, 2, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 1, 1, 2, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 2, 1, 3, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 3, 1, 2, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 3, 2, 2, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 4, 2, 1, 0.00*MeV ));
fragment_pool.push_back(new G4He5FermiFragment ( 5, 2, 4, 0.00*MeV ));
fragment_pool.push_back(new G4Li5FermiFragment ( 5, 3, 4, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 6, 2, 1, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 6, 3, 3, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 6, 3, 1, 3.562880*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 7, 3, 4, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 7, 3, 2, 0.4776120*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 7, 4, 4, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 7, 4, 2, 0.4290800*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 8, 3, 5, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 8, 3, 3, 0.9808000*MeV ));
fragment_pool.push_back(new G4Be8FermiFragment ( 8, 4, 1, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 9, 4, 4, 0.00*MeV ));
fragment_pool.push_back(new G4B9FermiFragment ( 9, 5, 4, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 10, 4, 1, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 10, 4, 5, 3.368030*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 10, 4, 8, 5.958390*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 10, 4, 1, 6.179300*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 10, 4, 5, 6.263300*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 10, 5, 7, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 10, 5, 3, 0.7183800*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 10, 5, 1, 1.740050*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 10, 5, 3, 2.154270*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 10, 5, 5, 3.587130*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 10, 6, 3, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 10, 6, 5, 3.353700*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 11, 5, 4, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 11, 5, 2, 2.124693*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 11, 5, 6, 4.444980*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 11, 5, 4, 5.020300*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 11, 5, 8, 6.741850*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 11, 5, 2, 6.791800*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 11, 5, 6, 7.285510*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 11, 5, 4, 7.977840*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 11, 5, 6, 8.560100*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 11, 6, 4, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 11, 6, 2, 2.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 11, 6, 6, 4.318800*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 11, 6, 4, 4.804200*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 11, 6, 2, 6.339200*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 11, 6, 8, 6.478200*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 11, 6, 6, 6.904800*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 11, 6, 4, 7.499700*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 11, 6, 4, 8.104500*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 11, 6, 6, 8.420000*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 12, 5, 3, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 12, 5, 5, 0.9531400*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 12, 5, 5, 1.673650*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 12, 5, 3, 2.620800*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 12, 6, 1, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 12, 6, 5, 4.438910*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 13, 6, 2, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 13, 6, 2, 3.089443*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 13, 6, 4, 3.684507*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 13, 6, 6, 3.853807*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 13, 7, 2, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 14, 6, 1, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 14, 6, 3, 6.093800*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 14, 6, 1, 6.589400*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 14, 6, 7, 6.728200*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 14, 6, 1, 6.902600*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 14, 6, 5, 7.012000*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 14, 6, 5, 7.341000*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 14, 7, 3, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 14, 7, 1, 2.312798*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 14, 7, 3, 3.948100*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 14, 7, 1, 4.915100*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 14, 7, 5, 5.105890*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 14, 7, 3, 5.691440*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 14, 7, 7, 5.834250*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 14, 7, 3, 6.203500*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 14, 7, 7, 6.446170*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 14, 7, 5, 7.029120*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 15, 7, 2, 0.00*MeV ));
// JMQ 010709 two very close levels instead of only one, with their own spins
fragment_pool.push_back(new G4StableFermiFragment( 15, 7, 6, 5.270155*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 15, 7, 2, 5.298822*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 15, 7, 4, 6.323780*MeV ));
//JMQ 010709 new level and corrected energy and spins
fragment_pool.push_back(new G4StableFermiFragment( 15, 7, 6, 7.155050*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 15, 7, 4, 7.300830*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 15, 7, 8, 7.567100*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 15, 7, 2, 8.312620*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 15, 7, 4, 8.571400*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 15, 7, 2, 9.049710*MeV ));
//JMQ 010709 new levels for N15
fragment_pool.push_back(new G4StableFermiFragment( 15, 7, 4, 9.151900*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 15, 7, 6, 9.154900*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 15, 7, 2, 9.222100*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 15, 7, 6, 9.760000*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 15, 7, 8, 9.829000*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 15, 7, 4, 9.925000*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 15, 7, 4, 10.06600*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 15, 8, 2, 0.00*MeV ));
//JMQ 010709 new level and spins
fragment_pool.push_back(new G4StableFermiFragment( 15, 8, 2, 5.183000*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 15, 8, 6, 5.240900*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 15, 8, 4, 6.176300*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 15, 8, 4, 6.793100*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 15, 8, 6, 6.859400*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 15, 8, 8, 7.275900*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 16, 7, 5, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 16, 7, 1, 0.1204200*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 16, 7, 7, 0.2982200*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 16, 7, 3, 0.3972700*MeV ));
//JMQ 010709 some energies and spins have been changed
fragment_pool.push_back(new G4StableFermiFragment( 16, 8, 1, 0.00*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 16, 8, 1, 6.049400*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 16, 8, 7, 6.129890*MeV ));
fragment_pool.push_back(new G4StableFermiFragment( 16, 8, 5, 6.917100*MeV ));
//JMQ 180510 fixed fragment 111
fragment_pool.push_back(new G4StableFermiFragment( 16, 8, 3, 7.116850*MeV ));
G4int nfrag = fragment_pool.size();
std::vector<const G4VFermiFragment*> newvec;
newvec.reserve(4);
// list of fragments ordered by A
newvec.resize(1);
for(G4int i=0; i<nfrag; ++i) {
newvec[0] = fragment_pool[i];
const G4FermiConfiguration* conf = new G4FermiConfiguration(newvec);
G4int A = fragment_pool[i]->GetA();
list1[A].push_back(conf);
}
if(verbose > 0) {
G4cout << "### G4FermiFragmentPool: " << nfrag
<< " fragments" << G4endl;
for(G4int A=1; A<maxA; ++A) {
G4cout << " A= " << A << " : Z= ";
for(size_t j=0; j<list1[A].size(); ++j) {
G4cout << (list1[A])[j]->GetZ() << " ";
}
G4cout << G4endl;
}
}
// list of fragment pairs ordered by A
G4int counter = 0;
G4int tot = 0;
newvec.resize(2);
for(G4int i=0; i<nfrag; ++i) {
G4int Z1 = fragment_pool[i]->GetZ();
G4int A1 = fragment_pool[i]->GetA();
for(G4int j=0; j<nfrag; ++j) {
G4int Z2 = fragment_pool[j]->GetZ();
G4int A2 = fragment_pool[j]->GetA();
G4int Z = Z1 + Z2;
G4int A = A1 + A2;
if(Z < maxZ && A < maxA && IsAvailable(Z, A)) {
newvec[0] = fragment_pool[i];
newvec[1] = fragment_pool[j];
if(!IsExist(Z, A, newvec)) {
const G4FermiConfiguration* conf = new G4FermiConfiguration(newvec);
list2[A].push_back(conf);
++counter;
}
}
}
}
if(verbose > 0) {
G4cout << G4endl;
G4cout << "### Pairs of fragments: " << counter << G4endl;
for(G4int A=2; A<maxA; ++A) {
G4cout << " A= " << A<<G4endl;
for(size_t j=0; j<list2[A].size(); ++j) {
const std::vector<const G4VFermiFragment*>* vec
= (list2[A])[j]->GetFragmentList();
G4int a1=(*vec)[0]->GetA();
G4int z1=(*vec)[0]->GetZ();
G4int a2=(*vec)[1]->GetA();
G4int z2=(*vec)[1]->GetZ();
G4cout << "("<<a1<<","<<z1<<")("<<a2<<","<<z2<<") % ";
}
G4cout<<G4endl;
G4cout<<"----------------------------------------------------------------"
<< G4endl;
}
}
// list of fragment triples ordered by A
tot += counter;
counter = 0;
newvec.resize(3);
for(G4int A1=2; A1<maxA; ++A1) {
size_t nz = list2[A1].size();
for(size_t idx=0; idx<nz; ++idx) {
const G4FermiConfiguration* conf2 = (list2[A1])[idx];
G4int Z1 = conf2->GetZ();
const std::vector<const G4VFermiFragment*>* vec2 =
conf2->GetFragmentList();
for(G4int j=0; j<nfrag; ++j) {
G4int Z2 = fragment_pool[j]->GetZ();
G4int A2 = fragment_pool[j]->GetA();
G4int Z = Z1 + Z2;
G4int A = A1 + A2;
if(Z < maxZ && A < maxA && IsAvailable(Z, A)) {
newvec[0] = (*vec2)[0];
newvec[1] = (*vec2)[1];
newvec[2] = fragment_pool[j];
if(!IsExist(Z, A, newvec)) {
const G4FermiConfiguration* conf3 = new G4FermiConfiguration(newvec);
list3[A].push_back(conf3);
++counter;
}
}
}
}
}
if(verbose > 0) {
G4cout << G4endl;
G4cout << "### Triples of fragments: " << counter << G4endl;
for(G4int A=3; A<maxA; ++A) {
G4cout << " A= " << A<<G4endl;
for(size_t j=0; j<list3[A].size(); ++j) {
const std::vector<const G4VFermiFragment*>* vec
= (list3[A])[j]->GetFragmentList();
G4int a1=(*vec)[0]->GetA();
G4int z1=(*vec)[0]->GetZ();
G4int a2=(*vec)[1]->GetA();
G4int z2=(*vec)[1]->GetZ();
G4int a3=(*vec)[2]->GetA();
G4int z3=(*vec)[2]->GetZ();
G4cout << "("<<a1<<","<<z1<<")("<<a2<<","<<z2<<")("<<a3<<","<<z3<<") % ";
}
G4cout<<G4endl;
G4cout<<"----------------------------------------------------------------"
<< G4endl;
}
}
// list of fragment quartets (3 + 1) ordered by A
tot += counter;
counter = 0;
newvec.resize(4);
for(G4int A1=3; A1<maxA; ++A1) {
size_t nz = list3[A1].size();
for(size_t idx=0; idx<nz; ++idx) {
const G4FermiConfiguration* conf3 = (list3[A1])[idx];
G4int Z1 = conf3->GetZ();
const std::vector<const G4VFermiFragment*>* vec3 =
conf3->GetFragmentList();
for(G4int j=0; j<nfrag; ++j) {
G4int Z2 = fragment_pool[j]->GetZ();
G4int A2 = fragment_pool[j]->GetA();
G4int Z = Z1 + Z2;
G4int A = A1 + A2;
if(Z < maxZ && A < maxA && IsAvailable(Z, A)) {
newvec[0] = (*vec3)[0];
newvec[1] = (*vec3)[1];
newvec[2] = (*vec3)[2];
newvec[3] = fragment_pool[j];
if(!IsExist(Z, A, newvec)) {
const G4FermiConfiguration* conf4 = new G4FermiConfiguration(newvec);
list4[A].push_back(conf4);
++counter;
}
}
}
}
}
// list of fragment quartets (2 + 2) ordered by A
for(G4int A1=2; A1<maxA; ++A1) {
size_t nz1 = list2[A1].size();
for(size_t id1=0; id1<nz1; ++id1) {
const G4FermiConfiguration* conf1 = (list2[A1])[id1];
G4int Z1 = conf1->GetZ();
const std::vector<const G4VFermiFragment*>* vec1 =
conf1->GetFragmentList();
for(G4int A2=2; A2<maxA; ++A2) {
size_t nz2 = list2[A2].size();
for(size_t id2=0; id2<nz2; ++id2) {
const G4FermiConfiguration* conf2 = (list2[A2])[id2];
G4int Z2 = conf2->GetZ();
const std::vector<const G4VFermiFragment*>* vec2 =
conf2->GetFragmentList();
G4int Z = Z1 + Z2;
G4int A = A1 + A2;
if(Z < maxZ && A < maxA && IsAvailable(Z, A)) {
newvec[0] = (*vec1)[0];
newvec[1] = (*vec1)[1];
newvec[2] = (*vec2)[0];
newvec[3] = (*vec2)[1];
if(!IsExist(Z, A, newvec)) {
const G4FermiConfiguration* conf4 =
new G4FermiConfiguration(newvec);
list4[A].push_back(conf4);
++counter;
}
}
}
}
}
}
if(verbose > 0) {
tot += counter;
G4cout << G4endl;
G4cout << "### Quartets of fragments: " << counter << G4endl;
for(G4int A=4; A<maxA; ++A) {
G4cout << " A= " << A<<G4endl;
for(size_t j=0; j<list4[A].size(); ++j) {
const std::vector<const G4VFermiFragment*>* vec
= (list4[A])[j]->GetFragmentList();
G4int a1=(*vec)[0]->GetA();
G4int z1=(*vec)[0]->GetZ();
G4int a2=(*vec)[1]->GetA();
G4int z2=(*vec)[1]->GetZ();
G4int a3=(*vec)[2]->GetA();
G4int z3=(*vec)[2]->GetZ();
G4int a4=(*vec)[3]->GetA();
G4int z4=(*vec)[3]->GetZ();
G4cout << "("<<a1<<","<<z1<<")("<<a2<<","<<z2<<")("<<a3<<","<<z3<<")("
<<a4<<","<<z4<<") % ";
}
G4cout<<G4endl;
G4cout<<"----------------------------------------------------------------"
<< G4endl;
}
G4cout << "Total number: " << tot << G4endl;
}
}
G4bool G4FermiFragmentsPool::IsApplicable(G4int Z, G4int A, G4double mass) const
{
if(Z >= maxZ || A >= maxA || A <= 0) { return false; }
// look into pair list
size_t nz = list2[A].size();
if(0 < nz) {
for(size_t j=0; j<nz; ++j) {
const G4FermiConfiguration* conf = (list2[A])[j];
if(Z == conf->GetZ() && mass >= conf->GetMass()) { return true; }
}
}
// look into triple list
nz = list3[A].size();
if(0 < nz) {
for(size_t j=0; j<nz; ++j) {
const G4FermiConfiguration* conf = (list3[A])[j];
if(Z == conf->GetZ() && mass >= conf->GetMass()) { return true; }
}
}
// look into quartet list
nz = list4[A].size();
if(0 < nz) {
for(size_t j=0; j<nz; ++j) {
const G4FermiConfiguration* conf = (list4[A])[j];
if(Z == conf->GetZ() && mass >= conf->GetMass()) { return true; }
}
}
// search in the pool and if found then return vector with one element
nz = list1[A].size();
if(0 < nz) {
for(size_t j=0; j<nz; ++j) {
const G4FermiConfiguration* conf = (list1[A])[j];
if(Z == conf->GetZ() && mass >= conf->GetMass()) {
if(!(*(conf->GetFragmentList()))[0]->IsStable()) { return true; }
}
}
}
return false;
}
const std::vector<const G4FermiConfiguration*>*
G4FermiFragmentsPool::GetConfigurationList(G4int Z, G4int A, G4double mass) const
{
std::vector<const G4FermiConfiguration*>* v =
new std::vector<const G4FermiConfiguration*>;
if(Z >= maxZ || A >= maxA) { return v; }
//G4cout << "G4FermiFragmentsPool::GetConfigurationList:"
// << " Z= " << Z << " A= " << A << " Mass(GeV)= " << mass/GeV<< G4endl;
// look into pair list
size_t nz = list2[A].size();
if(0 < nz) {
for(size_t j=0; j<nz; ++j) {
const G4FermiConfiguration* conf = (list2[A])[j];
if(Z == conf->GetZ() && mass >= conf->GetMass()) {
v->push_back(conf);
}
//G4cout << "Pair dM(MeV)= " << mass - conf->GetMass() << G4endl; }
}
}
// look into triple list
nz = list3[A].size();
if(0 < nz) {
for(size_t j=0; j<nz; ++j) {
const G4FermiConfiguration* conf = (list3[A])[j];
if(Z == conf->GetZ() && mass >= conf->GetMass()) {
v->push_back(conf);
}
//G4cout << "Triple dM(MeV)= " << mass - conf->GetMass() << G4endl; }
}
}
// look into quartet list
nz = list4[A].size();
if(0 < nz) {
for(size_t j=0; j<nz; ++j) {
const G4FermiConfiguration* conf = (list4[A])[j];
if(Z == conf->GetZ() && mass >= conf->GetMass()) {
v->push_back(conf);
}
// G4cout << "Quartet dM(MeV)= " << mass - conf->GetMass() << G4endl; }
}
}
// return if vector not empty
if(0 < v->size()) {
if(verbose > 0) {
G4double ExEn= mass - G4NucleiProperties::GetNuclearMass(A,Z);
G4cout<<"Total number of configurations = "<<v->size()<<" for A= "
<<A<<" Z= "<<Z<<" E*= "<< ExEn<<" MeV"<<G4endl;
size_t size_vector_conf = v->size();
for(size_t jc=0; jc<size_vector_conf; ++jc) {
const std::vector<const G4VFermiFragment*>* v_frag =
(*v)[jc]->GetFragmentList();
size_t size_vector_fragments = v_frag->size();
G4cout<<size_vector_fragments<<"-body configuration "<<jc+1<<": ";
for(size_t jf=0;jf<size_vector_fragments;++jf){
G4int af= (*v_frag)[jf]->GetA();
G4int zf= (*v_frag)[jf]->GetZ();
G4double ex=(*v_frag)[jf]->GetExcitationEnergy();
G4cout<<"(a="<<af<<", z="<<zf<<", ex="<<ex<<") ";
}
G4cout<<G4endl;
G4cout<<"-----------------------------------------------------"<<G4endl;
}
}
return v;
}
// search in the pool and if found then return vector with one element
nz = list1[A].size();
if(0 < nz) {
for(size_t j=0; j<nz; ++j) {
const G4FermiConfiguration* conf = (list1[A])[j];
// G4cout << "Single dM(MeV)= " << mass - conf->GetMass() << G4endl; }
if(Z == conf->GetZ() && mass >= conf->GetMass()) {
if(!(*(conf->GetFragmentList()))[0]->IsStable()) {
v->push_back(conf);
if(verbose > 0) {
G4double ExEn= mass -G4NucleiProperties::GetNuclearMass(A,Z);
G4cout<<"Only 1 configurations for A= "
<<A<<" Z= "<<Z<<" E*= "<< ExEn<<" MeV"<<G4endl;
const std::vector<const G4VFermiFragment*>* v_frag
= (*v)[0]->GetFragmentList();
size_t size_vector_fragments=v_frag->size();
G4cout<<"1 Fragment configuration: ";
for(size_t jf=0;jf<size_vector_fragments;++jf){
G4int af= (*v_frag)[jf]->GetA();
G4int zf= (*v_frag)[jf]->GetZ();
G4double ex=(*v_frag)[jf]->GetExcitationEnergy();
G4cout<<"(a="<<af<<", z="<<zf<<", ex="<<ex<<") ";
}
G4cout<<G4endl;
G4cout<<"-----------------------------------------------------"<<G4endl;
}
return v;
}
}
}
}
//failer
if(verbose > 0) {
G4cout << "G4FermiFragmentsPool::GetConfigurationList: WARNING: not "
<< "able decay fragment Z= " << Z << " A= " << A
<< " Mass(GeV)= " << mass/GeV<< G4endl;
}
return v;
}
G4bool G4FermiFragmentsPool::IsExist(G4int Z, G4int A,
std::vector<const G4VFermiFragment*>& newconf) const
{
size_t nn = newconf.size();
G4double mass = 0.0;
for(size_t i=0; i<nn; ++i) { mass += newconf[i]->GetTotalEnergy(); }
// look into pair list
if(2 == nn) {
size_t nz = list2[A].size();
if(0 < nz) {
for(size_t j=0; j<nz; ++j) {
const G4FermiConfiguration* conf = (list2[A])[j];
if(Z == conf->GetZ() && A == conf->GetA() &&
std::fabs(mass - conf->GetMass()) < keV) {return true; }
}
}
return false;
}
// look into triple list
if(3 == nn) {
size_t nz = list3[A].size();
if(0 < nz) {
for(size_t j=0; j<nz; ++j) {
const G4FermiConfiguration* conf = (list3[A])[j];
if(Z == conf->GetZ() && A == conf->GetA() &&
std::fabs(mass - conf->GetMass()) < keV) { return true; }
}
}
return false;
}
// look into quartet list
if(4 == nn) {
size_t nz = list4[A].size();
if(0 < nz) {
for(size_t j=0; j<nz; ++j) {
const G4FermiConfiguration* conf = (list4[A])[j];
if(Z == conf->GetZ() && A == conf->GetA() &&
std::fabs(mass - conf->GetMass()) < keV) { return true; }
}
}
return false;
}
return false;
}
const G4VFermiFragment*
G4FermiFragmentsPool::GetFragment(G4int Z, G4int A) const
{
const G4VFermiFragment* f = 0;
if(Z < maxZ && A < maxA) {
size_t nz = list1[A].size();
for(size_t j=0; j<nz; ++j) {
const G4FermiConfiguration* conf = (list1[A])[j];
if(Z == conf->GetZ()) {
f = (*(conf->GetFragmentList()))[0];
break;
}
}
}
return f;
}
void G4FermiFragmentsPool::DumpFragment(const G4VFermiFragment* f) const
{
if(f) {
G4cout << "Z= " << f->GetZ() << " A= " << f->GetA()
<< " Mass(GeV)= " << f->GetFragmentMass()/GeV
<< " Eexc(MeV)= " << f->GetExcitationEnergy() << G4endl;
}
}
void G4FermiFragmentsPool::Dump() const
{
G4cout << "##### List of Fragments in the Fermi Fragment Pool #####"
<< G4endl;
G4int nfrag = fragment_pool.size();
for(G4int i=0; i<nfrag; ++i) {
DumpFragment(fragment_pool[i]);
}
G4cout << G4endl;
}
source/processes/hadronic/models/de_excitation/fermi_breakup/src/G4He5FermiFragment.cc
-54
View File
@@ -1,54 +0,0 @@
//
// ********************************************************************
// * 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: G4He5FermiFragment.cc 67983 2013-03-13 10:42:03Z gcosmo $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
//
// Modifications:
// 01.04.2011 General cleanup by V.Ivanchenko:
#include "G4He5FermiFragment.hh"
#include "G4NucleiProperties.hh"
G4He5FermiFragment::G4He5FermiFragment(G4int anA, G4int aZ, G4int Pol, G4double ExE)
: G4UnstableFermiFragment(anA,aZ,Pol,ExE)
{
// He5 ----> alpha + neutron
Masses.push_back(G4NucleiProperties::GetNuclearMass(4,2));
Masses.push_back(CLHEP::neutron_mass_c2);
AtomNum.push_back(4);
AtomNum.push_back(1);
Charges.push_back(2);
Charges.push_back(0);
}
G4He5FermiFragment::~G4He5FermiFragment()
{}
source/processes/hadronic/models/de_excitation/fermi_breakup/src/G4Li5FermiFragment.cc
-49
View File
@@ -1,49 +0,0 @@
//
// ********************************************************************
// * 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: G4Li5FermiFragment.cc 67983 2013-03-13 10:42:03Z gcosmo $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
#include "G4Li5FermiFragment.hh"
#include "G4NucleiProperties.hh"
G4Li5FermiFragment::G4Li5FermiFragment(G4int anA, G4int aZ, G4int Pol, G4double ExE)
: G4UnstableFermiFragment(anA,aZ,Pol,ExE)
{
// Li5 ----> alpha + proton
Masses.push_back(G4NucleiProperties::GetNuclearMass(4,2));
Masses.push_back(CLHEP::proton_mass_c2);
AtomNum.push_back(4);
AtomNum.push_back(1);
Charges.push_back(2);
Charges.push_back(1);
}
G4Li5FermiFragment::~G4Li5FermiFragment()
{}
source/processes/hadronic/models/de_excitation/fermi_breakup/src/G4StableFermiFragment.cc
-48
View File
@@ -1,48 +0,0 @@
//
// ********************************************************************
// * 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: G4StableFermiFragment.cc 97097 2016-05-25 07:50:31Z gcosmo $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
//
// Modifications:
// 01.04.2011 General cleanup by V.Ivanchenko
#include "G4StableFermiFragment.hh"
G4StableFermiFragment::G4StableFermiFragment(G4int anA, G4int aZ,
G4int Pol, G4double ExE)
: G4VFermiFragment(anA,aZ,Pol,ExE, true)
{}
G4StableFermiFragment::~G4StableFermiFragment()
{}
void G4StableFermiFragment::FillFragment(G4FragmentVector* theResult,
const G4LorentzVector & aMomentum) const
{
theResult->push_back(new G4Fragment(GetA(),GetZ(),aMomentum));
}
source/processes/hadronic/models/de_excitation/fermi_breakup/src/G4UnstableFermiFragment.cc
-66
View File
@@ -1,66 +0,0 @@
//
// ********************************************************************
// * 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: G4UnstableFermiFragment.cc 97097 2016-05-25 07:50:31Z gcosmo $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
//
// Modifications:
// 01.04.2011 General cleanup by V.Ivanchenko: integer Z and A, constructor
#include "G4UnstableFermiFragment.hh"
#include "G4FermiFragmentsPool.hh"
G4UnstableFermiFragment::G4UnstableFermiFragment(G4int anA, G4int aZ,
G4int Pol, G4double ExE)
: G4VFermiFragment(anA,aZ,Pol,ExE, false)
{}
G4UnstableFermiFragment::~G4UnstableFermiFragment()
{}
void G4UnstableFermiFragment::FillFragment(G4FragmentVector* theResult,
const G4LorentzVector& aMomentum) const
{
const G4FermiPhaseSpaceDecay* thePhaseSpace
= G4FermiFragmentsPool::Instance()->GetFermiPhaseSpaceDecay();
std::vector<G4LorentzVector*> * P = thePhaseSpace->Decay(aMomentum.m(), Masses);
G4ThreeVector Beta = aMomentum.boostVector();
size_t N = P->size();
for (size_t i=0; i<N; ++i)
{
G4LorentzVector* v = (*P)[i];
v->boost(Beta);
theResult->push_back(new G4Fragment(AtomNum[i],Charges[i],*v));
delete v;
}
delete P;
}
source/processes/hadronic/models/de_excitation/fermi_breakup/src/G4VFermiFragment.cc
-49
View File
@@ -1,49 +0,0 @@
//
// ********************************************************************
// * 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: G4VFermiFragment.cc 97097 2016-05-25 07:50:31Z gcosmo $
//
// Hadronic Process: Nuclear De-excitations
// by V. Lara (Nov 1998)
#include "G4VFermiFragment.hh"
#include "G4NucleiProperties.hh"
G4VFermiFragment::G4VFermiFragment(G4int anA, G4int aZ, G4int Pol,
G4double exc, G4bool stable):
isStable(stable),
A(anA),
Z(aZ),
Polarization(Pol),
ExcitEnergy(exc)
{
fragmentMass = 0.0;
if(A > 0) { fragmentMass = G4NucleiProperties::GetNuclearMass(A, Z); }
}
G4VFermiFragment::~G4VFermiFragment()
{}
source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4PolarizedGammaTransition.hh
-78
View File
@@ -1,78 +0,0 @@
//
// ********************************************************************
// * 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: G4PolarizedGammaTransition.hh 85659 2014-11-03 10:59:10Z vnivanch $
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// CERN, Geneva, Switzerland
//
// File name: G4PolarizedGammaTransition
//
// Author: Vladimir Ivanchenko
//
// Creation date: 6 November 2015
//
// Modifications:
//
//
// -------------------------------------------------------------------
#ifndef G4POLARIZEDGAMMATRANSITION_HH
#define G4POLARIZEDGAMMATRANSITION_HH 1
#include "G4GammaTransition.hh"
class G4PolarizationTransition;
class G4PolarizedGammaTransition : public G4GammaTransition
{
public:
explicit G4PolarizedGammaTransition();
virtual ~G4PolarizedGammaTransition();
virtual void SampleDirection(G4Fragment* nuc, G4double ratio,
G4int twoJ1, G4int twoJ2, G4int mp);
private:
G4PolarizedGammaTransition(const G4PolarizedGammaTransition &right) = delete;
const G4PolarizedGammaTransition& operator=(const G4PolarizedGammaTransition &right) = delete;
G4bool operator==(const G4PolarizedGammaTransition &right) const = delete;
G4bool operator!=(const G4PolarizedGammaTransition &right) const = delete;
G4PolarizationTransition* fPolarization;
};
#endif
source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4PolarizedGammaTransition.cc
-61
View File
@@ -1,61 +0,0 @@
//
// ********************************************************************
// * 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: G4PolarizedGammaTransition.cc 85659 2014-11-03 10:59:10Z vnivanch $
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// CERN, Geneva, Switzerland
//
// File name: G4PolarizedGammaTransition
//
// Author V.Ivanchenko 6 November 2015
//
// -------------------------------------------------------------------
#include "G4PolarizedGammaTransition.hh"
#include "Randomize.hh"
#include "G4RandomDirection.hh"
#include "G4LorentzVector.hh"
#include "G4SystemOfUnits.hh"
#include "G4PhysicalConstants.hh"
#include "G4PolarizationTransition.hh"
G4PolarizedGammaTransition::G4PolarizedGammaTransition()
{
fPolarization = new G4PolarizationTransition();
}
G4PolarizedGammaTransition::~G4PolarizedGammaTransition()
{
delete fPolarization;
}
void G4PolarizedGammaTransition::SampleDirection(
G4Fragment*, G4double, G4int, G4int, G4int)
{
fDirection = G4RandomDirection();
}
source/processes/hadronic/models/parton_string/management/include/G4PomeronCrossSection.hh
-126
View File
@@ -1,126 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
#ifndef G4PomeronCrossSection_h
#define G4PomeronCrossSection_h 1
//
// $Id: G4PomeronCrossSection.hh 100828 2016-11-02 15:25:59Z gcosmo $
//
#include "G4Proton.hh"
#include "G4Neutron.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4PionZero.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4KaonZero.hh"
#include "G4KaonZeroShort.hh"
#include "G4KaonZeroLong.hh"
#include "G4Gamma.hh"
class G4PomeronCrossSection
{
public:
G4PomeronCrossSection(const G4ParticleDefinition * );
G4PomeronCrossSection(const G4Proton * );
G4PomeronCrossSection(const G4Neutron * );
G4PomeronCrossSection(const G4PionPlus * );
G4PomeronCrossSection(const G4PionMinus * );
G4PomeronCrossSection(const G4PionZero * );
G4PomeronCrossSection(const G4KaonPlus * );
G4PomeronCrossSection(const G4KaonMinus * );
G4PomeronCrossSection(const G4KaonZero * );
G4PomeronCrossSection(const G4KaonZeroLong * );
G4PomeronCrossSection(const G4KaonZeroShort * );
G4PomeronCrossSection(const G4Gamma * );
~G4PomeronCrossSection();
// s = (center of mass energy)**2
G4double GetTotalCrossSection(const G4double s);
G4double GetDiffractiveCrossSection(const G4double s);
G4double GetElasticCrossSection(const G4double s);
G4double GetInelasticCrossSection(const G4double s);
G4double GetTotalProbability(const G4double s, const G4double impactsquare);
G4double GetDiffractiveProbability(const G4double s, const G4double impactsquare);
G4double GetNondiffractiveProbability(const G4double s, const G4double impactsquare);
G4double GetElasticProbability(const G4double s, const G4double impactsquare);
G4double GetInelasticProbability(const G4double s, const G4double impactsquare);
G4double GetCutPomeronProbability(const G4double s, const G4double impactsquare,
const G4int nPomerons);
void Setgamma(const G4double agam); // temporary only! GF.
G4double SoftEikonal(G4double s, G4double impactsquare);
G4double HardEikonal(G4double s, G4double impactsquare);
void Pomeron_S(G4double apomeron_S){ pomeron_S = apomeron_S;}
void Pomeron_Gamma(G4double apomeron_Gamma){ pomeron_Gamma = apomeron_Gamma;}
void Pomeron_C(G4double apomeron_C){ pomeron_C = apomeron_C;}
void Pomeron_Rsquare(G4double apomeron_Rsquare){ pomeron_Rsquare = apomeron_Rsquare;}
void Pomeron_Alpha(G4double apomeron_Alpha){ pomeron_Alpha = apomeron_Alpha;}
void Pomeron_Alphaprime(G4double apomeron_Alphaprime){ pomeron_Alphaprime = apomeron_Alphaprime;}
void Pomeron_Gamma_Hard(G4double apomeron_Gamma_Hard){ pomeron_Gamma_Hard = apomeron_Gamma_Hard;}
void Pomeron_Alpha_Hard(G4double apomeron_Alpha_Hard){ pomeron_Alpha_Hard = apomeron_Alpha_Hard;}
private:
G4double PowerSoft(const G4double s);
G4double PowerHard(const G4double s);
G4double LambdaSoft(const G4double s);
G4double LambdaHard(const G4double s);
G4double Zsoft(const G4double s);
G4double Zhard(const G4double s);
G4PomeronCrossSection();
void InitForNucleon();
void InitForPion();
void InitForKaon();
void InitForGamma();
G4double Expand(G4double z);
inline G4double Z(const G4double Scms);
inline G4double SigP(const G4double Scms);
inline G4double Power(const G4double Scms);
inline G4double Lambda(const G4double s);
inline G4double Eikonal(const G4double s,const G4double impactsquare);
G4double pomeron_Alpha;
G4double pomeron_Alpha_Hard;
G4double pomeron_Alphaprime;
G4double pomeron_C;
G4double pomeron_Gamma;
G4double pomeron_Gamma_Hard;
G4double pomeron_Rsquare;
G4double pomeron_S;
};
#endif
source/processes/hadronic/models/parton_string/management/src/G4PomeronCrossSection.cc
-326
View File
@@ -1,326 +0,0 @@
//
// ********************************************************************
// * 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: G4PomeronCrossSection.cc 100828 2016-11-02 15:25:59Z gcosmo $
//
#include "G4PomeronCrossSection.hh"
#include "G4PhysicalConstants.hh"
#include "G4SystemOfUnits.hh"
#include "G4Pow.hh"
#include "G4Exp.hh"
#include "G4Log.hh"
G4PomeronCrossSection::G4PomeronCrossSection() :
pomeron_Alpha(0), pomeron_Alpha_Hard(0), pomeron_Alphaprime(0),
pomeron_C(0), pomeron_Gamma(0), pomeron_Gamma_Hard(0),
pomeron_Rsquare(0), pomeron_S(0)
{}
G4PomeronCrossSection::~G4PomeronCrossSection()
{;}
//**********************************************************************************************
G4PomeronCrossSection::G4PomeronCrossSection(const G4ParticleDefinition * particle)
{
G4int Encoding = std::abs(particle->GetPDGEncoding());
if (std::abs(particle->GetBaryonNumber())!=0)
InitForNucleon();
else if (Encoding/100== 3 || Encoding/10 == 3)
InitForKaon();
else
InitForPion();
}
//**********************************************************************************************
G4PomeronCrossSection::G4PomeronCrossSection(const G4Proton * )
{
InitForNucleon();
}
G4PomeronCrossSection::G4PomeronCrossSection(const G4Neutron * )
{
InitForNucleon();
}
G4PomeronCrossSection::G4PomeronCrossSection(const G4PionPlus * )
{
InitForPion();
}
G4PomeronCrossSection::G4PomeronCrossSection(const G4PionMinus * )
{
InitForPion();
}
G4PomeronCrossSection::G4PomeronCrossSection(const G4PionZero * )
{
InitForPion();
}
G4PomeronCrossSection::G4PomeronCrossSection(const G4KaonPlus * )
{
InitForKaon();
}
G4PomeronCrossSection::G4PomeronCrossSection(const G4KaonMinus * )
{
InitForKaon();
}
G4PomeronCrossSection::G4PomeronCrossSection(const G4KaonZero * )
{
InitForKaon();
}
G4PomeronCrossSection::G4PomeronCrossSection(const G4KaonZeroLong * )
{
InitForKaon();
}
G4PomeronCrossSection::G4PomeronCrossSection(const G4KaonZeroShort * )
{
InitForKaon();
}
G4PomeronCrossSection::G4PomeronCrossSection(const G4Gamma * )
{
InitForGamma();
}
G4double G4PomeronCrossSection::GetTotalCrossSection(const G4double S)
{
G4double FZ2= Expand(Z(S)/2);
return SigP(S) * FZ2;
}
G4double G4PomeronCrossSection::GetElasticCrossSection(const G4double S)
{
return SigP(S)/pomeron_C *(Expand(Z(S)/2) - Expand(Z(S)));
}
G4double G4PomeronCrossSection::GetDiffractiveCrossSection(const G4double S)
{
return ( pomeron_C -1) * GetElasticCrossSection(S);
}
G4double G4PomeronCrossSection::GetInelasticCrossSection(const G4double S)
{
return GetTotalCrossSection(S) - GetElasticCrossSection(S);
}
//-------------------------Probabilities ----------------------------
G4double G4PomeronCrossSection::GetTotalProbability(const G4double S,
const G4double impactsquare)
{
return 2/pomeron_C*(1-G4Exp(-1*Eikonal(S,impactsquare)));
}
G4double G4PomeronCrossSection::GetDiffractiveProbability(const G4double S,
const G4double impactsquare)
{
return (pomeron_C-1)/pomeron_C *
(GetTotalProbability(S,impactsquare) - GetNondiffractiveProbability(S,impactsquare));
}
G4double G4PomeronCrossSection::GetNondiffractiveProbability(const G4double S,
const G4double impactsquare)
{
return (1-G4Exp(-2*Eikonal(S,impactsquare)))/pomeron_C;
}
G4double G4PomeronCrossSection::GetElasticProbability(const G4double S,
const G4double impactsquare)
{
return (GetTotalProbability(S,impactsquare) - GetInelasticProbability(S,impactsquare));
}
G4double G4PomeronCrossSection::GetInelasticProbability(const G4double S,
const G4double impactsquare)
{
return GetNondiffractiveProbability(S,impactsquare) + GetDiffractiveProbability(S,impactsquare);
}
G4double G4PomeronCrossSection::GetCutPomeronProbability(const G4double S,
const G4double impactsquare, const G4int nPomerons)
{
G4double factorial=G4Pow::GetInstance()->factorial(nPomerons);
return G4Exp(-2*Eikonal(S,impactsquare))/pomeron_C*
G4Pow::GetInstance()->powN(2*Eikonal(S,impactsquare),nPomerons)/factorial;
}
// ---------------Temporary --- GF
void G4PomeronCrossSection::Setgamma(const G4double agam)
{
pomeron_Gamma=agam/GeV/GeV;
}
//----------------- private/Implementation methods
void G4PomeronCrossSection::InitForNucleon()
{
//pomeron_S= 3.0*GeV*GeV;
pomeron_S= 2.7*GeV*GeV;
//pomeron_Gamma= 2.16/GeV/GeV;
//pomeron_Gamma= 3.96/GeV/GeV;
pomeron_Gamma= (2.6+3.96)/GeV/GeV;
pomeron_C= 1.4;
pomeron_Rsquare= 3.56/GeV/GeV;
//pomeron_Alpha= 1.0808;
pomeron_Alpha= 0.9808;
pomeron_Alphaprime= 0.25/GeV/GeV;
pomeron_Gamma_Hard = 0.0002/GeV/GeV; // Note! if pomeron_Gamma_Hard != 0 to fit total pp-crosscection
// pomeron_Gamma_Soft shold be 2.35/GeV/GeV
pomeron_Alpha_Hard = 1.47;
}
void G4PomeronCrossSection::InitForPion()
{
pomeron_S= 1.5*GeV*GeV;
//pomeron_Gamma= 1.46/GeV/GeV;
pomeron_Gamma= 2.17/GeV/GeV;
pomeron_C= 1.6;
pomeron_Rsquare= 2.36/GeV/GeV;
pomeron_Alpha= 1.0808;
pomeron_Alphaprime= 0.25/GeV/GeV;
pomeron_Gamma_Hard = 0.0002/GeV/GeV;
pomeron_Alpha_Hard = 1.47;
}
void G4PomeronCrossSection::InitForKaon()
{
pomeron_S= 2.3*GeV*GeV;
//pomeron_Gamma= 1.31/GeV/GeV;
pomeron_Gamma= 1.92/GeV/GeV;
pomeron_C= 1.8;
pomeron_Rsquare= 1.96/GeV/GeV;
pomeron_Alpha= 1.0808;
pomeron_Alphaprime= 0.25/GeV/GeV;
pomeron_Gamma_Hard = 0.0002/GeV/GeV;
pomeron_Alpha_Hard = 1.47;
}
void G4PomeronCrossSection::InitForGamma()
{
pomeron_S= 1.7*GeV*GeV;
//pomeron_Gamma= 1.42/GeV/GeV;
pomeron_Gamma= 2.07/GeV/GeV;
pomeron_C= 1.7;
pomeron_Rsquare= 2.16/GeV/GeV;
pomeron_Alpha= 1.0808;
pomeron_Alphaprime= 0.25/GeV/GeV;
pomeron_Gamma_Hard = 0.0002/GeV/GeV;
pomeron_Alpha_Hard = 1.47;
}
G4double G4PomeronCrossSection::Expand(G4double z)
{
G4double sum=1.;
G4double current=1.;
for (G4int j=2; j<21; j++ ) {
current *= -z *(j-1)/sqr(j);
sum+=current;
}
return sum;
}
G4double G4PomeronCrossSection::Power(const G4double S)
{
return pomeron_Gamma * G4Pow::GetInstance()->powA(S/pomeron_S, pomeron_Alpha -1);
}
G4double G4PomeronCrossSection::Z(const G4double S)
{
return 2*pomeron_C * Power(S) / Lambda(S);
}
G4double G4PomeronCrossSection::Lambda(const G4double S)
{
return pomeron_Rsquare+pomeron_Alphaprime*G4Log(S/pomeron_S);
}
G4double G4PomeronCrossSection::SigP(const G4double S)
{
return 8 * pi * hbarc_squared * Power(S);
}
G4double G4PomeronCrossSection::Eikonal(const G4double S, const G4double impactsquare)
{
return Z(S)/2 * G4Exp(-impactsquare/(4*Lambda(S)*hbarc_squared));
}
//*************************************************************************************************
G4double G4PomeronCrossSection::PowerSoft(const G4double S)
{
return pomeron_Gamma * G4Pow::GetInstance()->powA(S/pomeron_S, pomeron_Alpha -1);
}
G4double G4PomeronCrossSection::PowerHard(const G4double S)
{
return pomeron_Gamma_Hard*G4Pow::GetInstance()->powA(S/pomeron_S, pomeron_Alpha_Hard -1);
}
G4double G4PomeronCrossSection::LambdaSoft(const G4double S)
{
return pomeron_Rsquare+pomeron_Alphaprime*G4Log(S/pomeron_S);
}
G4double G4PomeronCrossSection::LambdaHard(const G4double /*S*/)
{
return pomeron_Rsquare; //+pomeron_Alphaprime*G4Log(s/pomeron_S);
}
G4double G4PomeronCrossSection::Zsoft(const G4double S)
{
return 2*pomeron_C*PowerHard(S) / LambdaSoft(S);
}
G4double G4PomeronCrossSection::Zhard(const G4double S)
{
return 2*pomeron_C*PowerHard(S)/LambdaHard(S);
}
G4double G4PomeronCrossSection::SoftEikonal(G4double S, G4double impactsquare)
{
return Zsoft(S)/2*G4Exp(-impactsquare/LambdaSoft(S)/hbarc_squared/4);
}
G4double G4PomeronCrossSection::HardEikonal(G4double S, G4double impactsquare)
{
return Zhard(S)/2*G4Exp(-impactsquare/LambdaHard(S)/hbarc_squared/4);
}
//*************************************************************************************************