#include <G4ConcreteNNToNDeltaStar.hh>

Inheritance diagram for G4ConcreteNNToNDeltaStar:

Public Member Functions
virtual G4double	CrossSection (const G4KineticTrack &trk1, const G4KineticTrack &trk2) const

void	establish_G4MT_TLS_G4ConcreteNNTwoBodyResonance (const G4ParticleDefinition aPrimary, const G4ParticleDefinition bPriamry, const G4ParticleDefinition aSecondary, const G4ParticleDefinition bSecondary, const G4VXResonanceTable &sigmaTable)

void	establish_G4MT_TLS_G4VCollision ()

void	establish_G4MT_TLS_G4VScatteringCollision ()

virtual G4KineticTrackVector *	FinalState (const G4KineticTrack &trk1, const G4KineticTrack &trk2) const

	G4ConcreteNNToNDeltaStar (const G4ParticleDefinition aPrimary, const G4ParticleDefinition bPriamry, const G4ParticleDefinition aSecondary, const G4ParticleDefinition bSecondary)

virtual const G4VAngularDistribution *	GetAngularDistribution () const

virtual const std::vector< G4String > &	GetListOfColliders (G4int) const

virtual G4String	GetName () const

virtual G4bool	IsInCharge (const G4KineticTrack &trk1, const G4KineticTrack &trk2) const

G4bool	operator!= (const G4ConcreteNNTwoBodyResonance &right) const

G4bool	operator!= (const G4VCollision &right) const

G4bool	operator!= (const G4VScatteringCollision &right) const

G4bool	operator== (const G4ConcreteNNTwoBodyResonance &right) const

G4bool	operator== (const G4VCollision &right) const

G4bool	operator== (const G4VScatteringCollision &right) const

virtual void	Print () const

virtual void	Print (const G4KineticTrack &trk1, const G4KineticTrack &trk2) const

virtual	~G4ConcreteNNToNDeltaStar ()

Protected Member Functions
virtual const G4CollisionVector *	GetComponents () const

virtual const G4VCrossSectionSource *	GetCrossSectionSource () const

G4int	GetNumberOfPartons (const G4ParticleDefinition *aP) const

virtual const std::vector< const G4ParticleDefinition * > &	GetOutgoingParticles () const

Private Member Functions
double	BrWigInt0 (const double x, const double gamma, const double m0) const

G4double	BrWigInt1 (const G4double x, const G4double gamma, const G4double m0) const

double	BrWigInv (const double x, const double gamma, const double m0) const

	G4ConcreteNNToNDeltaStar (const G4ConcreteNNToNDeltaStar &)

G4ConcreteNNToNDeltaStar &	operator= (const G4ConcreteNNToNDeltaStar &)

double	SampleResonanceMass (const double poleMass, const double width, const double minMass, const double maxMass) const

Private Attributes
G4VCrossSectionSource *	crossSectionSource

G4VAngularDistribution *	theAngularDistribution

std::vector< const G4ParticleDefinition * >	theOutGoing

const G4ParticleDefinition *	thePrimary1

const G4ParticleDefinition *	thePrimary2

Static Private Attributes
static G4ThreadLocal G4XNDeltastarTable *	theSigmaTable_G4MT_TLS_ = 0

Detailed Description

Definition at line 42 of file G4ConcreteNNToNDeltaStar.hh.

Constructor & Destructor Documentation

◆ G4ConcreteNNToNDeltaStar() [1/2]

G4ConcreteNNToNDeltaStar::G4ConcreteNNToNDeltaStar	(	const G4ParticleDefinition *	aPrimary,
		const G4ParticleDefinition *	bPriamry,
		const G4ParticleDefinition *	aSecondary,
		const G4ParticleDefinition *	bSecondary
	)

Definition at line 35 of file G4ConcreteNNToNDeltaStar.cc.

                                                                :
    G4ConcreteNNTwoBodyResonance(NULL, NULL, NULL, NULL, NULL, NULL, NULL)
{
   if (!theSigmaTable_G4MT_TLS_) theSigmaTable_G4MT_TLS_ = new G4XNDeltastarTable;
   G4XNDeltastarTable &theSigmaTable = *theSigmaTable_G4MT_TLS_;
   establish_G4MT_TLS_G4ConcreteNNTwoBodyResonance(aPrimary,bPrimary,aSecondary,bSecondary,
                                                   G4NDeltastarBuilder(bSecondary->GetParticleName(),theSigmaTable));
}

References G4ConcreteNNTwoBodyResonance::establish_G4MT_TLS_G4ConcreteNNTwoBodyResonance(), G4ParticleDefinition::GetParticleName(), and theSigmaTable_G4MT_TLS_.

◆ ~G4ConcreteNNToNDeltaStar()

G4ConcreteNNToNDeltaStar::~G4ConcreteNNToNDeltaStar ( )

virtual

Definition at line 47 of file G4ConcreteNNToNDeltaStar.cc.

{
   if (theSigmaTable_G4MT_TLS_) delete theSigmaTable_G4MT_TLS_;
    theSigmaTable_G4MT_TLS_=0;
}

References theSigmaTable_G4MT_TLS_.

◆ G4ConcreteNNToNDeltaStar() [2/2]

G4ConcreteNNToNDeltaStar::G4ConcreteNNToNDeltaStar ( const G4ConcreteNNToNDeltaStar & )

private

Member Function Documentation

◆ BrWigInt0()

double G4VScatteringCollision::BrWigInt0	(	const double	x,
		const double	gamma,
		const double	m0
	)		const

inlineprivateinherited

Definition at line 84 of file G4VScatteringCollision.hh.

85 { return 2.0*gamma*std::atan( 2.0 * (x-m0)/ gamma ); }

Referenced by G4VScatteringCollision::BrWigInt1(), and G4VScatteringCollision::SampleResonanceMass().

◆ BrWigInt1()

G4double G4VScatteringCollision::BrWigInt1	(	const G4double	x,
		const G4double	gamma,
		const G4double	m0
	)		const

inlineprivateinherited

Definition at line 87 of file G4VScatteringCollision.hh.

88 { return 0.5*gamma*gamma*G4Log( (x-m0)*(x-m0)+gamma*gamma/4.0 ) + m0*BrWigInt0(x,gamma,m0); }

G4Log

G4double G4Log(G4double x)

Definition: G4Log.hh:226

G4VScatteringCollision::BrWigInt0

double BrWigInt0(const double x, const double gamma, const double m0) const

Definition: G4VScatteringCollision.hh:84

References G4VScatteringCollision::BrWigInt0(), and G4Log().

◆ BrWigInv()

double G4VScatteringCollision::BrWigInv	(	const double	x,
		const double	gamma,
		const double	m0
	)		const

inlineprivateinherited

Definition at line 90 of file G4VScatteringCollision.hh.

91 { return 0.5*gamma*std::tan( 0.5*x/gamma )+m0; }

Referenced by G4VScatteringCollision::SampleResonanceMass().

◆ CrossSection()

G4double G4VCollision::CrossSection	(	const G4KineticTrack &	trk1,
		const G4KineticTrack &	trk2
	)		const

virtualinherited

Reimplemented in G4CollisionComposite, G4CollisionMesonBaryonToResonance, and G4CollisionNN.

Definition at line 54 of file G4VCollision.cc.

{
    G4double sigma = 0.;
 
    const G4VCrossSectionSource* xSource = GetCrossSectionSource();
 
    if (xSource != 0)
    {
        // There is a cross section for this Collision
        sigma = xSource->CrossSection(aTrk1,aTrk2);
    }
    return sigma;
}

References G4VCrossSectionSource::CrossSection(), and G4VCollision::GetCrossSectionSource().

Referenced by G4Scatterer::GetCrossSection(), G4Scatterer::GetTimeToInteraction(), G4VCollision::Print(), and G4Scatterer::Scatter().

◆ establish_G4MT_TLS_G4ConcreteNNTwoBodyResonance()

void G4ConcreteNNTwoBodyResonance::establish_G4MT_TLS_G4ConcreteNNTwoBodyResonance	(	const G4ParticleDefinition *	aPrimary,
		const G4ParticleDefinition *	bPriamry,
		const G4ParticleDefinition *	aSecondary,
		const G4ParticleDefinition *	bSecondary,
		const G4VXResonanceTable &	sigmaTable
	)

inherited

Definition at line 82 of file G4ConcreteNNTwoBodyResonance.cc.

{
  establish_G4MT_TLS_G4VScatteringCollision();
  thePrimary1=aPrimary;
  thePrimary2=bPrimary;
  theOutGoing.push_back(aSecondary);
  theOutGoing.push_back(bSecondary);
 
  crossSectionSource = new G4XResonance(aPrimary, bPrimary, 
                    aSecondary->GetPDGiIsospin(), 
                    aSecondary->GetPDGiSpin(),
                    aSecondary->GetPDGMass(),
                    bSecondary->GetPDGiIsospin(), 
                    bSecondary->GetPDGiSpin(),
                    bSecondary->GetPDGMass(),
                    aSecondary->GetParticleName(),
                    bSecondary->GetParticleName(),
                    sigmaTable);
}

References G4ConcreteNNTwoBodyResonance::crossSectionSource, G4VScatteringCollision::establish_G4MT_TLS_G4VScatteringCollision(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGiIsospin(), G4ParticleDefinition::GetPDGiSpin(), G4ParticleDefinition::GetPDGMass(), G4ConcreteNNTwoBodyResonance::theOutGoing, G4ConcreteNNTwoBodyResonance::thePrimary1, and G4ConcreteNNTwoBodyResonance::thePrimary2.

Referenced by G4ConcreteNNToDeltaDelta::G4ConcreteNNToDeltaDelta(), G4ConcreteNNToDeltaDeltastar::G4ConcreteNNToDeltaDeltastar(), G4ConcreteNNToDeltaNstar::G4ConcreteNNToDeltaNstar(), G4ConcreteNNToNDelta::G4ConcreteNNToNDelta(), G4ConcreteNNToNDeltaStar(), G4ConcreteNNToNNStar::G4ConcreteNNToNNStar(), and G4ConcreteNStarNToNN::G4ConcreteNStarNToNN().

◆ establish_G4MT_TLS_G4VCollision()

void G4VCollision::establish_G4MT_TLS_G4VCollision ( )

inherited

Definition at line 143 of file G4VCollision.cc.

143{ }

Referenced by G4VScatteringCollision::establish_G4MT_TLS_G4VScatteringCollision().

◆ establish_G4MT_TLS_G4VScatteringCollision()

void G4VScatteringCollision::establish_G4MT_TLS_G4VScatteringCollision ( )

inherited

Definition at line 180 of file G4VScatteringCollision.cc.

{
  establish_G4MT_TLS_G4VCollision();
  if ( theAngularDistribution ) delete theAngularDistribution;
  theAngularDistribution = new G4AngularDistribution(true);
}

References G4VCollision::establish_G4MT_TLS_G4VCollision(), and G4VScatteringCollision::theAngularDistribution.

Referenced by G4ConcreteNNTwoBodyResonance::establish_G4MT_TLS_G4ConcreteNNTwoBodyResonance().

◆ FinalState()

G4KineticTrackVector * G4VScatteringCollision::FinalState	(	const G4KineticTrack &	trk1,
		const G4KineticTrack &	trk2
	)		const

virtualinherited

Implements G4VCollision.

Definition at line 60 of file G4VScatteringCollision.cc.

{ 
  const G4VAngularDistribution* angDistribution = GetAngularDistribution();
  G4LorentzVector p = trk1.Get4Momentum() + trk2.Get4Momentum();
  G4double sqrtS = p.m();
  G4double S = sqrtS * sqrtS;
 
  std::vector<const G4ParticleDefinition*> OutputDefinitions = GetOutgoingParticles();
  if (OutputDefinitions.size() != 2)
    throw G4HadronicException(__FILE__, __LINE__, "G4VScatteringCollision: Too many output particles!");
 
  if (OutputDefinitions[0]->IsShortLived() && OutputDefinitions[1]->IsShortLived())
  {
    if(std::getenv("G4KCDEBUG")) G4cerr << "two shortlived for Type = "<<typeid(*this).name()<<G4endl;
    // throw G4HadronicException(__FILE__, __LINE__, "G4VScatteringCollision: can't handle two shortlived particles!"); // @hpw@
  }
  
  G4double outm1 = OutputDefinitions[0]->GetPDGMass();
  G4double outm2 = OutputDefinitions[1]->GetPDGMass();
 
  if (OutputDefinitions[0]->IsShortLived())
  {
    outm1 = SampleResonanceMass(outm1, 
                OutputDefinitions[0]->GetPDGWidth(),
        G4Neutron::NeutronDefinition()->GetPDGMass()+G4PionPlus::PionPlus()->GetPDGMass(),
        sqrtS-(G4Neutron::NeutronDefinition()->GetPDGMass()+G4PionPlus::PionPlus()->GetPDGMass()));
 
  }
  if (OutputDefinitions[1]->IsShortLived())
  {
    outm2 = SampleResonanceMass(outm2, OutputDefinitions[1]->GetPDGWidth(),
            G4Neutron::NeutronDefinition()->GetPDGMass()+G4PionPlus::PionPlus()->GetPDGMass(),
            sqrtS-outm1);
  }
  
  // Angles of outgoing particles
  G4double cosTheta = angDistribution->CosTheta(S, trk1.GetActualMass(), trk2.GetActualMass());
  G4double phi = angDistribution->Phi();
 
  // Unit vector of three-momentum
  G4LorentzRotation fromCMSFrame(p.boostVector());
  G4LorentzRotation toCMSFrame(fromCMSFrame.inverse());
  G4LorentzVector TempPtr = toCMSFrame*trk1.Get4Momentum();
  G4LorentzRotation toZ;
  toZ.rotateZ(-1*TempPtr.phi());
  toZ.rotateY(-1*TempPtr.theta());
  G4LorentzRotation toCMS(toZ.inverse());
 
  G4ThreeVector pFinal1(std::sin(std::acos(cosTheta))*std::cos(phi), std::sin(std::acos(cosTheta))*std::sin(phi), cosTheta);
 
  // Three momentum in cm system
  G4double pCM = std::sqrt( (S-(outm1+outm2)*(outm1+outm2)) * (S-(outm1-outm2)*(outm1-outm2)) /(4.*S));
  pFinal1 = pFinal1 * pCM;
  G4ThreeVector pFinal2 = -pFinal1;
 
  G4double eFinal1 = std::sqrt(pFinal1.mag2() + outm1*outm1);
  G4double eFinal2 = std::sqrt(pFinal2.mag2() + outm2*outm2);
 
  G4LorentzVector p4Final1(pFinal1, eFinal1);
  G4LorentzVector p4Final2(pFinal2, eFinal2);
  p4Final1 = toCMS*p4Final1;
  p4Final2 = toCMS*p4Final2;
 
 
  // Lorentz transformation
  G4LorentzRotation toLabFrame(p.boostVector());
  p4Final1 *= toLabFrame;
  p4Final2 *= toLabFrame;
 
  // Final tracks are copies of incoming ones, with modified 4-momenta
 
  G4double chargeBalance = OutputDefinitions[0]->GetPDGCharge()+OutputDefinitions[1]->GetPDGCharge();
  chargeBalance-= trk1.GetDefinition()->GetPDGCharge();
  chargeBalance-= trk2.GetDefinition()->GetPDGCharge();
  if(std::abs(chargeBalance) >.1)
  {
    G4cout << "Charges in "<<typeid(*this).name()<<G4endl;
    G4cout << OutputDefinitions[0]->GetPDGCharge()<<" "<<OutputDefinitions[0]->GetParticleName()
           << OutputDefinitions[1]->GetPDGCharge()<<" "<<OutputDefinitions[1]->GetParticleName()
       << trk1.GetDefinition()->GetPDGCharge()<<" "<<trk1.GetDefinition()->GetParticleName()
       << trk2.GetDefinition()->GetPDGCharge()<<" "<<trk2.GetDefinition()->GetParticleName()<<G4endl;
  }
  G4KineticTrack* final1 = new G4KineticTrack(OutputDefinitions[0], 0.0, trk1.GetPosition(), p4Final1);
  G4KineticTrack* final2 = new G4KineticTrack(OutputDefinitions[1], 0.0, trk2.GetPosition(), p4Final2);
 
  G4KineticTrackVector* finalTracks = new G4KineticTrackVector;
 
  finalTracks->push_back(final1);
  finalTracks->push_back(final2);
 
  return finalTracks;
}

References CLHEP::HepLorentzVector::boostVector(), G4VAngularDistribution::CosTheta(), G4cerr, G4cout, G4endl, G4KineticTrack::Get4Momentum(), G4KineticTrack::GetActualMass(), G4VScatteringCollision::GetAngularDistribution(), G4KineticTrack::GetDefinition(), G4VScatteringCollision::GetOutgoingParticles(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGCharge(), G4KineticTrack::GetPosition(), CLHEP::HepLorentzRotation::inverse(), CLHEP::HepLorentzVector::m(), CLHEP::Hep3Vector::mag2(), G4Neutron::NeutronDefinition(), CLHEP::HepLorentzVector::phi(), G4VAngularDistribution::Phi(), G4PionPlus::PionPlus(), CLHEP::HepLorentzRotation::rotateY(), CLHEP::HepLorentzRotation::rotateZ(), S(), G4VScatteringCollision::SampleResonanceMass(), and CLHEP::HepLorentzVector::theta().

◆ GetAngularDistribution()

virtual const G4VAngularDistribution * G4VScatteringCollision::GetAngularDistribution ( ) const

inlinevirtualinherited

Implements G4VCollision.

Definition at line 69 of file G4VScatteringCollision.hh.

  {
    return theAngularDistribution;
  }

References G4VScatteringCollision::theAngularDistribution.

Referenced by G4VScatteringCollision::FinalState().

◆ GetComponents()

virtual const G4CollisionVector * G4VCollision::GetComponents ( ) const

inlineprotectedvirtualinherited

◆ GetCrossSectionSource()

virtual const G4VCrossSectionSource * G4ConcreteNNTwoBodyResonance::GetCrossSectionSource ( ) const

inlineprotectedvirtualinherited

Implements G4VCollision.

Definition at line 80 of file G4ConcreteNNTwoBodyResonance.hh.

80{ return crossSectionSource; }

References G4ConcreteNNTwoBodyResonance::crossSectionSource.

◆ GetListOfColliders()

virtual const std::vector< G4String > & G4ConcreteNNTwoBodyResonance::GetListOfColliders ( G4int ) const

inlinevirtualinherited

Implements G4VCollision.

Definition at line 62 of file G4ConcreteNNTwoBodyResonance.hh.

  {
    throw G4HadronicException(__FILE__, __LINE__, "Tried to call G4ConcreteNNTwoBodyResonance::GetListOfColliders. Please find out why!");
    std::vector<G4String> * aList = new std::vector<G4String>;
    return *aList;
  } 

◆ GetName()

virtual G4String G4ConcreteNNToNDeltaStar::GetName ( ) const

inlinevirtual

Reimplemented from G4ConcreteNNTwoBodyResonance.

Definition at line 51 of file G4ConcreteNNToNDeltaStar.hh.

51{ return "ConcreteNNToNDeltaStar"; }

◆ GetNumberOfPartons()

G4int G4VCollision::GetNumberOfPartons ( const G4ParticleDefinition * aP ) const

inlineprotectedinherited

Definition at line 68 of file G4VCollision.hh.

  {
    G4int result = 0;
    for(G4int i=0; i<6; i++) 
    {
      result += aP->GetQuarkContent(i+1);
      result += aP->GetAntiQuarkContent(i+1);
    }
    return result;
  }

References G4ParticleDefinition::GetAntiQuarkContent(), and G4ParticleDefinition::GetQuarkContent().

Referenced by G4CollisionMesonBaryonElastic::IsInCharge().

◆ GetOutgoingParticles()

virtual const std::vector< const G4ParticleDefinition * > & G4ConcreteNNTwoBodyResonance::GetOutgoingParticles ( ) const

inlineprotectedvirtualinherited

Implements G4VScatteringCollision.

Definition at line 82 of file G4ConcreteNNTwoBodyResonance.hh.

  {
    return theOutGoing;
  }

References G4ConcreteNNTwoBodyResonance::theOutGoing.

◆ IsInCharge()

G4bool G4ConcreteNNTwoBodyResonance::IsInCharge	(	const G4KineticTrack &	trk1,
		const G4KineticTrack &	trk2
	)		const

virtualinherited

Implements G4VCollision.

Definition at line 70 of file G4ConcreteNNTwoBodyResonance.cc.

{
  if (trk1.GetDefinition()==thePrimary1 && trk2.GetDefinition()==thePrimary2) return true;
  if (trk1.GetDefinition()==thePrimary2 && trk2.GetDefinition()==thePrimary1) return true;
  return false;
}

References G4KineticTrack::GetDefinition(), G4ConcreteNNTwoBodyResonance::thePrimary1, and G4ConcreteNNTwoBodyResonance::thePrimary2.

◆ operator!=() [1/3]

G4bool G4ConcreteNNTwoBodyResonance::operator!= ( const G4ConcreteNNTwoBodyResonance & right ) const

inherited

◆ operator!=() [2/3]

G4bool G4VCollision::operator!= ( const G4VCollision & right ) const

inherited

Definition at line 48 of file G4VCollision.cc.

{
    return (this != (G4VCollision *) &right);
}

◆ operator!=() [3/3]

G4bool G4VScatteringCollision::operator!= ( const G4VScatteringCollision & right ) const

inherited

◆ operator=()

G4ConcreteNNToNDeltaStar & G4ConcreteNNToNDeltaStar::operator= ( const G4ConcreteNNToNDeltaStar & )

private

◆ operator==() [1/3]

G4bool G4ConcreteNNTwoBodyResonance::operator== ( const G4ConcreteNNTwoBodyResonance & right ) const

inherited

◆ operator==() [2/3]

G4bool G4VCollision::operator== ( const G4VCollision & right ) const

inherited

Definition at line 42 of file G4VCollision.cc.

{
    return (this == (G4VCollision *) &right);
}

◆ operator==() [3/3]

G4bool G4VScatteringCollision::operator== ( const G4VScatteringCollision & right ) const

inherited

◆ Print() [1/2]

void G4VCollision::Print ( ) const

virtualinherited

Definition at line 70 of file G4VCollision.cc.

{
    G4String name = GetName();
 
    G4cout << "---- " << name << "---- Cross section" << G4endl;
 
    const G4VCrossSectionSource* xSource = GetCrossSectionSource();
    if (xSource) xSource->Print();
 
    G4int nComponents = 0;
    const G4CollisionVector* components = GetComponents();
    if (components)
    {
        nComponents = components->size();
    }
    G4cout << "---- " << name << "---- has " << nComponents << " components" <<G4endl;
    G4int i = 0;
    G4CollisionVector::const_iterator iter;
    if (components)
    {
        for (iter = components->begin(); iter != components->end(); ++iter)
        {
            G4cout << "---- " << name << " ---- Component " << i << G4endl;
            ((*iter))->Print();
            i++;
        }
    }
 
}

References G4cout, G4endl, G4VCollision::GetComponents(), G4VCollision::GetCrossSectionSource(), G4VCollision::GetName(), G4InuclParticleNames::name(), G4VCollision::Print(), and G4VCrossSectionSource::Print().

Referenced by G4VCollision::Print().

◆ Print() [2/2]

void G4VCollision::Print	(	const G4KineticTrack &	trk1,
		const G4KineticTrack &	trk2
	)		const

virtualinherited

Definition at line 101 of file G4VCollision.cc.

{
    G4String name = GetName();
 
    if (IsInCharge(trk1,trk2))
    {
        G4cout << "---- " << name << "is in charge ---- " << G4endl;
    }
    else
    {
        G4cout << "---- " << name << "is not in charge ---- " << G4endl;
    }
 
    G4cout << "---- " << name << "---- Cross section" << G4endl;
 
    const G4VCrossSectionSource* xSource = GetCrossSectionSource();
    if (xSource) xSource->Print();
    G4cout << "Cross section = " << CrossSection(trk1,trk2) << G4endl;
 
    G4int nComponents = 0;
    const G4CollisionVector* components = GetComponents();
    if (components)
    {
        nComponents = components->size();
    }
    G4cout << "---- " << name << "has " << nComponents << " components" <<G4endl;
 
    G4int i = 0;
    G4CollisionVector::const_iterator iter;
    if (components)
    {
        for (iter = components->begin(); iter != components->end(); ++iter)
        {
            G4cout << "Component " << i << G4endl;
            ((*iter))->Print();
            i++;
        }
    }
}

References G4VCollision::CrossSection(), G4cout, G4endl, G4VCollision::GetComponents(), G4VCollision::GetCrossSectionSource(), G4VCollision::GetName(), G4VCollision::IsInCharge(), G4InuclParticleNames::name(), G4VCollision::Print(), and G4VCrossSectionSource::Print().

◆ SampleResonanceMass()

double G4VScatteringCollision::SampleResonanceMass	(	const double	poleMass,
		const double	width,
		const double	minMass,
		const double	maxMass
	)		const

privateinherited

Definition at line 156 of file G4VScatteringCollision.cc.

{
  // Chooses a mass randomly between minMass and maxMass 
  //     according to a Breit-Wigner function with constant 
  //     width gamma and pole poleMass
 
  G4double minMass = aMinMass;
  if (minMass > maxMass) G4cerr << "##################### SampleResonanceMass: particle out of mass range" << G4endl;
  if(minMass > maxMass) minMass -= G4PionPlus::PionPlus()->GetPDGMass();
  if(minMass > maxMass) minMass = 0;
 
  if (gamma < 1E-10*GeV)
    return std::max(minMass,std::min(maxMass, poleMass));
  else {
    double fmin = BrWigInt0(minMass, gamma, poleMass);
    double fmax = BrWigInt0(maxMass, gamma, poleMass);
    double f = fmin + (fmax-fmin)*G4UniformRand();
    return BrWigInv(f, gamma, poleMass);
  }
}

References G4VScatteringCollision::BrWigInt0(), G4VScatteringCollision::BrWigInv(), G4cerr, G4endl, G4UniformRand, G4ParticleDefinition::GetPDGMass(), GeV, G4INCL::Math::max(), G4INCL::Math::min(), and G4PionPlus::PionPlus().

Referenced by G4VScatteringCollision::FinalState().

Field Documentation

◆ crossSectionSource

G4VCrossSectionSource* G4ConcreteNNTwoBodyResonance::crossSectionSource

privateinherited

Definition at line 93 of file G4ConcreteNNTwoBodyResonance.hh.

Referenced by G4ConcreteNNTwoBodyResonance::establish_G4MT_TLS_G4ConcreteNNTwoBodyResonance(), G4ConcreteNNTwoBodyResonance::G4ConcreteNNTwoBodyResonance(), G4ConcreteNNTwoBodyResonance::GetCrossSectionSource(), and G4ConcreteNNTwoBodyResonance::~G4ConcreteNNTwoBodyResonance().

◆ theAngularDistribution

G4VAngularDistribution* G4VScatteringCollision::theAngularDistribution

privateinherited

Definition at line 99 of file G4VScatteringCollision.hh.

Referenced by G4VScatteringCollision::establish_G4MT_TLS_G4VScatteringCollision(), G4VScatteringCollision::G4VScatteringCollision(), G4VScatteringCollision::GetAngularDistribution(), and G4VScatteringCollision::~G4VScatteringCollision().

◆ theOutGoing

std::vector<const G4ParticleDefinition*> G4ConcreteNNTwoBodyResonance::theOutGoing

privateinherited

Definition at line 96 of file G4ConcreteNNTwoBodyResonance.hh.

Referenced by G4ConcreteNNTwoBodyResonance::establish_G4MT_TLS_G4ConcreteNNTwoBodyResonance(), G4ConcreteNNTwoBodyResonance::G4ConcreteNNTwoBodyResonance(), and G4ConcreteNNTwoBodyResonance::GetOutgoingParticles().

◆ thePrimary1

const G4ParticleDefinition* G4ConcreteNNTwoBodyResonance::thePrimary1

privateinherited

Definition at line 94 of file G4ConcreteNNTwoBodyResonance.hh.

Referenced by G4ConcreteNNTwoBodyResonance::establish_G4MT_TLS_G4ConcreteNNTwoBodyResonance(), and G4ConcreteNNTwoBodyResonance::IsInCharge().

◆ thePrimary2

const G4ParticleDefinition* G4ConcreteNNTwoBodyResonance::thePrimary2

privateinherited

Definition at line 95 of file G4ConcreteNNTwoBodyResonance.hh.

Referenced by G4ConcreteNNTwoBodyResonance::establish_G4MT_TLS_G4ConcreteNNTwoBodyResonance(), and G4ConcreteNNTwoBodyResonance::IsInCharge().

◆ theSigmaTable_G4MT_TLS_

G4ThreadLocal G4XNDeltastarTable * G4ConcreteNNToNDeltaStar::theSigmaTable_G4MT_TLS_ = 0

staticprivate

Definition at line 59 of file G4ConcreteNNToNDeltaStar.hh.

Referenced by G4ConcreteNNToNDeltaStar(), and ~G4ConcreteNNToNDeltaStar().

The documentation for this class was generated from the following files:

source/processes/hadronic/models/im_r_matrix/include/G4ConcreteNNToNDeltaStar.hh
source/processes/hadronic/models/im_r_matrix/src/G4ConcreteNNToNDeltaStar.cc

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4ConcreteNNToNDeltaStar() [1/2]

◆ ~G4ConcreteNNToNDeltaStar()

◆ G4ConcreteNNToNDeltaStar() [2/2]

Member Function Documentation

◆ BrWigInt0()

◆ BrWigInt1()

◆ BrWigInv()

◆ CrossSection()

◆ establish_G4MT_TLS_G4ConcreteNNTwoBodyResonance()

◆ establish_G4MT_TLS_G4VCollision()

◆ establish_G4MT_TLS_G4VScatteringCollision()

◆ FinalState()

◆ GetAngularDistribution()

◆ GetComponents()

◆ GetCrossSectionSource()

◆ GetListOfColliders()

◆ GetName()

◆ GetNumberOfPartons()

◆ GetOutgoingParticles()

◆ IsInCharge()

◆ operator!=() [1/3]

◆ operator!=() [2/3]

◆ operator!=() [3/3]

◆ operator=()

◆ operator==() [1/3]

◆ operator==() [2/3]

◆ operator==() [3/3]

◆ Print() [1/2]

◆ Print() [2/2]

◆ SampleResonanceMass()

Field Documentation

◆ crossSectionSource

◆ theAngularDistribution

◆ theOutGoing

◆ thePrimary1

◆ thePrimary2

◆ theSigmaTable_G4MT_TLS_