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

Import Geant4 4.0.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-08 16:18:25 +02:00
parent 36c080dca6
commit 921d3b1cda
3990 changed files with 185376 additions and 82884 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/hadronic/models/generator/string_fragmentation/include/G4ExcitedStringDecay.hh
+11 -11
View File
@@ -14,15 +14,15 @@
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * authors in the GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// $Id: G4ExcitedStringDecay.hh,v 1.6.8.1 2001/06/28 19:13:45 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4ExcitedStringDecay.hh,v 1.9 2001/10/04 20:00:31 hpw Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
#ifndef G4ExcitedStringDecay_h
#define G4ExcitedStringDecay_h 1
@@ -77,17 +77,17 @@ FragmentStrings(const G4ExcitedStringVector * theStrings)
G4LorentzVector KTsum;
G4bool NeedEnergyCorrector=false;
for ( G4int astring=0; astring < theStrings->entries(); astring++)
for ( unsigned int astring=0; astring < theStrings->size(); astring++)
{
KTsum+= theStrings->at(astring)->Get4Momentum();
KTsum+= theStrings->operator[](astring)->Get4Momentum();
G4KineticTrackVector * generatedKineticTracks = NULL;
if ( theStrings->at(astring)->IsExcited() )
if ( theStrings->operator[](astring)->IsExcited() )
{
generatedKineticTracks=FragmentString(*theStrings->at(astring));
generatedKineticTracks=FragmentString(*theStrings->operator[](astring));
} else {
generatedKineticTracks = new G4KineticTrackVector;
generatedKineticTracks->insert(theStrings->at(astring)->GetKineticTrack());
generatedKineticTracks->push_back(theStrings->operator[](astring)->GetKineticTrack());
}
if (generatedKineticTracks == NULL)
@@ -97,14 +97,14 @@ FragmentStrings(const G4ExcitedStringVector * theStrings)
}
G4LorentzVector KTsum1;
for ( G4int aTrack=0; aTrack<generatedKineticTracks->entries();aTrack++)
for ( unsigned int aTrack=0; aTrack<generatedKineticTracks->size();aTrack++)
{
theResult->insert(generatedKineticTracks->at(aTrack));
theResult->push_back(generatedKineticTracks->operator[](aTrack));
KTsum1+= (*generatedKineticTracks)[aTrack]->Get4Momentum();
}
if ( abs((KTsum1.e()-theStrings->at(astring)->Get4Momentum().e()) / KTsum1.e()) > perMillion )
if ( abs((KTsum1.e()-theStrings->operator[](astring)->Get4Momentum().e()) / KTsum1.e()) > perMillion )
{
NeedEnergyCorrector=true;
}
source/processes/hadronic/models/generator/string_fragmentation/include/G4FragmentingString.hh
+147
View File
@@ -0,0 +1,147 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// $Id: G4FragmentingString.hh,v 1.1 2001/10/09 10:38:32 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
#ifndef G4FragmentingString_h
#define G4FragmentingString_h 1
// ------------------------------------------------------------
// GEANT 4 class header file
//
// ---------------- G4FragmentingString ----------------
// by Gunter Folger, September 2001.
// class for an excited string used in Fragmention
// ------------------------------------------------------------
#include "G4ios.hh"
#include "globals.hh"
#include "G4ThreeVector.hh"
#include "G4LorentzVector.hh"
#include "G4ParticleDefinition.hh"
class G4ExcitedString;
class G4FragmentingString
{
public:
G4FragmentingString(const G4FragmentingString &right);
G4FragmentingString(const G4ExcitedString &excited);
G4FragmentingString(const G4FragmentingString &old,
G4ParticleDefinition * newdecay,
const G4LorentzVector *momentum);
~G4FragmentingString();
int operator==(const G4FragmentingString &right) const;
int operator!=(const G4FragmentingString &right) const;
G4LorentzVector Get4Momentum() const;
G4ThreeVector StablePt();
G4ThreeVector DecayPt();
G4double LightConePlus();
G4double LightConeMinus();
G4double LightConeDecay();
G4double Mass() const;
G4double Mass2() const;
G4ParticleDefinition* GetLeftParton(void) const;
G4ParticleDefinition* GetRightParton(void) const;
G4ParticleDefinition* GetStableParton() const; // stable at the moment
G4ParticleDefinition* GetDecayParton() const; // currently involved in fragmentation
void SetLeftPartonStable();
void SetRightPartonStable();
G4int GetDecayDirection() const;
G4bool DecayIsQuark();
G4bool StableIsQuark();
G4bool FourQuarkString(void) const;
private:
G4ParticleDefinition *LeftParton, *RightParton;
G4ThreeVector Ptleft,Ptright; // Pt (px,py) for partons (pz ignored!)
G4double Pplus, Pminus; // p-, p+ of string, Plus ass. to Left!
G4ParticleDefinition * theStableParton, * theDecayParton;
enum DecaySide { None, Left, Right };
DecaySide decaying;
};
inline
int G4FragmentingString::operator==(const G4FragmentingString &right) const
{
return this == &right;
}
inline
int G4FragmentingString::operator!=(const G4FragmentingString &right) const
{
return this != &right;
}
inline
G4ParticleDefinition * G4FragmentingString::GetStableParton() const
{
return theStableParton;
}
inline
G4ParticleDefinition * G4FragmentingString::GetDecayParton() const
{
return theDecayParton;
}
inline
G4ParticleDefinition* G4FragmentingString::GetLeftParton(void) const
{
return LeftParton;
}
inline
G4ParticleDefinition* G4FragmentingString::GetRightParton(void) const
{
return RightParton;
}
#endif
source/processes/hadronic/models/generator/string_fragmentation/include/G4HadronBuilder.hh
+76
View File
@@ -0,0 +1,76 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// $Id: G4HadronBuilder.hh,v 1.2 2001/10/30 08:33:26 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// -----------------------------------------------------------------------------
// GEANT 4 class header file
//
// History:
// Gunter Folger, August/September 2001
// Create class;
// -----------------------------------------------------------------------------
//
#ifndef G4HadronBuilder_h
#define G4HadronBuilder_h 1
#include "globals.hh"
#include <g4std/vector>
#include "G4ParticleDefinition.hh"
#include "G4ParticleDefinition.hh"
class G4HadronBuilder
{
public:
G4ParticleDefinition * Build(G4ParticleDefinition * black, G4ParticleDefinition * white);
G4ParticleDefinition * BuildLowSpin(G4ParticleDefinition * black, G4ParticleDefinition * white);
G4ParticleDefinition * BuildHighSpin(G4ParticleDefinition * black, G4ParticleDefinition * white);
// ctor
G4HadronBuilder(G4double mesonMix, G4double barionMix,
G4std::vector<double> scalarMesonMix,
G4std::vector<double> vectorMesonMix);
private:
G4HadronBuilder(); // no default ctor
enum Spin { SpinZero=1, SpinHalf=2, SpinOne=3, SpinThreeHalf=4 };
G4ParticleDefinition * Meson(G4ParticleDefinition * black, G4ParticleDefinition * white, Spin spin);
G4ParticleDefinition * Barion(G4ParticleDefinition * black, G4ParticleDefinition * white, Spin spin);
G4double mesonSpinMix;
G4double barionSpinMix;
G4std::vector<double> scalarMesonMixings;
G4std::vector<double> vectorMesonMixings;
};
#endif
source/processes/hadronic/models/generator/string_fragmentation/include/G4LundStringFragmentation.hh
+4 -4
View File
@@ -14,15 +14,15 @@
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * authors in the GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// $Id: G4LundStringFragmentation.hh,v 1.2.8.2 2001/06/28 20:20:00 gunter Exp $
// GEANT4 tag $Name: $ Maxim Komogorov
// $Id: G4LundStringFragmentation.hh,v 1.5 2001/10/04 20:00:31 hpw Exp $
// GEANT4 tag $Name: geant4-04-00 $ Maxim Komogorov
//
// -----------------------------------------------------------------------------
// GEANT 4 class implementation file
@@ -43,7 +43,7 @@ public:
G4LundStringFragmentation();
// G4LundStringFragmentation(G4double sigmaPt);
G4LundStringFragmentation(const G4LundStringFragmentation &right);
~G4LundStringFragmentation();
virtual ~G4LundStringFragmentation();
public:
const G4LundStringFragmentation & operator=(const G4LundStringFragmentation &right);
source/processes/hadronic/models/generator/string_fragmentation/include/G4QGSMFragmentation.hh
+3 -3
View File
@@ -14,15 +14,15 @@
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * authors in the GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// $Id: G4QGSMFragmentation.hh,v 1.3.8.2 2001/06/28 20:20:00 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4QGSMFragmentation.hh,v 1.5 2001/08/01 17:09:07 hpw Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// -----------------------------------------------------------------------------
// GEANT 4 class implementation file
source/processes/hadronic/models/generator/string_fragmentation/include/G4VKinkyStringDecay.hh
+69
View File
@@ -0,0 +1,69 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * authors in the GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// $Id: G4VKinkyStringDecay.hh,v 1.5 2001/10/05 16:17:36 hpw Exp $
// GEANT4 tag $Name: geant4-04-00 $
// Maxim Komogorov
//
// -----------------------------------------------------------------------------
// GEANT 4 class implementation file
//
// History: first implementation, Maxim Komogorov, 10-Oct-1998
// -----------------------------------------------------------------------------
#ifndef G4VKinkyStringDecay_h
#define G4VKinkyStringDecay_h 1
#include "G4VLongitudinalStringDecay.hh"
//***********************************************************************************************
class G4VKinkyStringDecay
{
// Constructors
public:
G4VKinkyStringDecay(G4VLongitudinalStringDecay* theModal);
virtual ~G4VKinkyStringDecay() {};
//
public:
G4KineticTrackVector* FragmentString(const G4ExcitedString& String);
virtual G4double GetLightConeGluonZ(G4double zmin, G4double zmax);
void SetLongitudinalStringDecay(G4VLongitudinalStringDecay*);
private:
G4VLongitudinalStringDecay* theLongitudinalStringDecay;
};
//*****************************************************************************************
inline void G4VKinkyStringDecay::SetLongitudinalStringDecay(G4VLongitudinalStringDecay* theModal)
{
theLongitudinalStringDecay = theModal;
}
//*****************************************************************************************************
#endif
source/processes/hadronic/models/generator/string_fragmentation/include/G4VLongitudinalStringDecay.hh
+52 -96
View File
@@ -14,15 +14,15 @@
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * authors in the GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// $Id: G4VLongitudinalStringDecay.hh,v 1.7.8.2 2001/06/28 20:20:00 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4VLongitudinalStringDecay.hh,v 1.12 2001/10/10 08:23:57 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// Maxim Komogorov
//
// -----------------------------------------------------------------------------
@@ -36,14 +36,16 @@
#include "G4DynamicParticle.hh"
#include "G4KineticTrack.hh"
#include "G4KineticTrackVector.hh"
#include "G4HadronBuilder.hh"
class G4FragmentingString;
//**********************************************************************************************
class G4VLongitudinalStringDecay
{
public:
G4VLongitudinalStringDecay();
~G4VLongitudinalStringDecay();
virtual ~G4VLongitudinalStringDecay();
private:
// G4VLongitudinalStringDecay(const G4VLongitudinalStringDecay &right);
@@ -53,20 +55,7 @@ private:
public:
G4KineticTrackVector* FragmentString(const G4ExcitedString& theString);
G4bool FragmentString(G4KineticTrackVector* aHadrons, const G4ExcitedString* theString);
G4KineticTrackVector* DecayResonans (G4KineticTrackVector* aHadrons);
G4int SampleQuarkFlavor(void);
void SampleQuarkPt(G4double* thePx, G4double* thePy);
G4double GetDiquarkSuppress() {return DiquarkSuppress;};
G4double GetDiquarkBreakProb() {return DiquarkBreakProb;};
G4double GetStrangeSuppress() {return StrangeSuppress;};
G4double GetClusterMass() {return ClusterMass;};
G4int GetClusterLoopInterrupt() {return ClusterLoopInterrupt;};
G4ParticleDefinition* CreateHadron(G4int id1, G4int id2, G4bool theGivenSpin, G4int theSpin);
void Sample4Momentum(G4LorentzVector* Mom, G4double Mass, G4LorentzVector* AntiMom, G4double AntiMass, G4double InitialMass);
void SetSigmaTransverseMomentum(G4double aQT);
void SetStrangenessSuppression(G4double aValue);
void SetDiquarkSuppression(G4double aValue);
@@ -77,14 +66,24 @@ public:
void SetScalarMesonMixings( G4std::vector<G4double> aVector);
void SetVectorMesonMixings( G4std::vector<G4double> aVector);
// used by G4VKinkyStringDecy..
G4int SampleQuarkFlavor(void);
G4ThreeVector SampleQuarkPt();
private:
G4double GetDiquarkSuppress() {return DiquarkSuppress;};
G4double GetDiquarkBreakProb() {return DiquarkBreakProb;};
G4double GetStrangeSuppress() {return StrangeSuppress;};
G4double GetClusterMass() {return ClusterMass;};
G4int GetClusterLoopInterrupt() {return ClusterLoopInterrupt;};
G4ParticleDefinition* CreateHadron(G4int id1, G4int id2, G4bool theGivenSpin, G4int theSpin);
void Sample4Momentum(G4LorentzVector* Mom, G4double Mass, G4LorentzVector* AntiMom, G4double AntiMass, G4double InitialMass);
protected:
// Additional protected declarations
virtual G4double GetLightConeZ(G4double zmin, G4double zmax, G4int PartonEncoding, G4ParticleDefinition* pHadron, G4double Px, G4double Py) = 0;
void CalculateHadronTimePosition(G4double theInitialStringMass, G4KineticTrackVector *);
G4ParticleDefinition* FindParticle(G4int Encoding);
// Additional Implementation Declarations
private:
G4double MassCut;
@@ -96,92 +95,49 @@ private:
G4double StrangeSuppress ;
G4int StringLoopInterrupt;
G4int ClusterLoopInterrupt;
G4int SideOfDecay;
G4HadronBuilder *hadronizer;
void ConstructParticle();
G4double pspin_meson;
G4double pspin_barion;
G4double pmix_meson1[6];
G4double pmix_meson0[6];
G4std::vector<G4double> vectorMesonMix;
G4std::vector<G4double> scalarMesonMix;
G4bool PastInitPhase;
class SimpleString
{
private:
class SideOfString;
public:
SimpleString(const G4ExcitedString& excitedString, G4VLongitudinalStringDecay * stringdecay)
: left(new SideOfString(excitedString.GetLeftParton()->GetPDGcode(),excitedString.Get4Momentum().mag())),
right(new SideOfString(excitedString.GetRightParton()->GetPDGcode(),excitedString.Get4Momentum().mag())),
MassSquare(excitedString.Get4Momentum().mag2()),
theStringDecay(stringdecay),
decay(0), stable(0), Side(0)
{};
~SimpleString()
{
delete right;
delete left;
};
SideOfString * Left(){return left;};
SideOfString * Right(){return right;};
SideOfString * Stable(){return stable;};
SideOfString * Decay(){return decay;};
const G4double MassSquared(){return MassSquare;};
G4ParticleDefinition * Splitup(G4int & NewDecayEncoding);
G4bool SplitLast(G4KineticTrackVector * LeftVector,G4KineticTrackVector * RightVector);
G4int GetDecayDirection() { return Side;};
void update();
G4KineticTrackVector * LightFragmentationTest(const G4ExcitedString * const theString);
G4bool StopFragmenting(const G4FragmentingString * const string);
G4bool IsFragmentable(const G4FragmentingString * const string);
// G4double MinFragmentationMass(G4ExcitedString * theString,
// G4ParticleDefinition*& Hadron1,
// G4ParticleDefinition*& Hadron2);
typedef G4std::pair<G4ParticleDefinition*, G4ParticleDefinition*> pDefPair;
typedef G4ParticleDefinition * (G4HadronBuilder::*Pcreate)
(G4ParticleDefinition*, G4ParticleDefinition*);
G4double FragmentationMass(
const G4FragmentingString * const string,
Pcreate build=0,
pDefPair * pdefs=0);
G4KineticTrack * Splitup(G4FragmentingString *string, G4FragmentingString *&newString);
G4LorentzVector * SplitEandP(G4ParticleDefinition * pHadron, G4FragmentingString * string);
G4bool SplitLast(G4FragmentingString * string,
G4KineticTrackVector * LeftVector,
G4KineticTrackVector * RightVector);
void CalculateHadronTimePosition(G4double theInitialStringMass, G4KineticTrackVector *);
G4ExcitedString *CPExcited(const G4ExcitedString& string);
G4ParticleDefinition* FindParticle(G4int Encoding);
private:
SimpleString(){G4cout << " error calling bad ctor for class SimpleString"<< G4endl;};
SideOfString * left, * right;
SideOfString * decay, * stable;
G4double MassSquare;
G4VLongitudinalStringDecay *theStringDecay;
G4int Side;
class SideOfString
{
public:
G4int Encoding(){return theEncoding;};
G4double w(){return thew;};
G4double Px(){return thepx;};
G4double Py(){return thepy;};
void decreasew(G4double deltaw){thew -= deltaw;};
void setEncoding(G4int aEncoding){theEncoding=aEncoding;};
void setpxpy(G4double px,G4double py){thepx=px; thepy=py;};
// Additional Implementation Declarations
G4ParticleDefinition * QuarkSplitup(G4ParticleDefinition* decay,
G4ParticleDefinition *&created);
G4ParticleDefinition * DiQuarkSplitup(G4ParticleDefinition* decay,
G4ParticleDefinition *&created);
pDefPair CreatePartonPair(G4int NeedParticle, G4bool AllowDiquarks=true);
SideOfString(G4int aEncoding, G4double aw)
{
theEncoding = aEncoding;
thew = aw;
thepx = thepy = 0;
}
;
SideOfString(void) {};
// void Init(G4int aEncoding, G4double aw) {
// theEncoding = aEncoding;
// thew = aw;
// thepx = thepy = 0;
// };
private:
G4int theEncoding;
G4double thew, thepx, thepy;
};
};
G4KineticTrackVector * LightFragmentationTest(const G4ExcitedString& theString);
G4bool StopFragmenting(SimpleString& string);
G4double IsFragmentable(SimpleString & theString);
G4double MinFragmentationMass(SimpleString & theString,
G4ParticleDefinition*& Hadron1,
G4ParticleDefinition*& Hadron2);
G4KineticTrack * SplitEandP(G4ParticleDefinition * pHadron,
SimpleString * string, G4int newDecayEncoding);
};