G4VScatteringCollision Class Reference

#include <G4VScatteringCollision.hh>

Inheritance diagram for G4VScatteringCollision:

Collaboration diagram for G4VScatteringCollision:

Public Member Functions
	G4VScatteringCollision ()
void	establish_G4MT_TLS_G4VScatteringCollision ()
virtual	~G4VScatteringCollision ()
G4bool	operator== (const G4VScatteringCollision &right) const
G4bool	operator!= (const G4VScatteringCollision &right) const
virtual G4KineticTrackVector *	FinalState (const G4KineticTrack &trk1, const G4KineticTrack &trk2) const
virtual const G4VAngularDistribution *	GetAngularDistribution () const
Public Member Functions inherited from G4VCollision
	G4VCollision ()
void	establish_G4MT_TLS_G4VCollision ()
	G4VCollision (void *s1, void *s2, void *s3, void *s4, void *s5, void *s6, void *s7)
virtual	~G4VCollision ()
G4bool	operator== (const G4VCollision &right) const
G4bool	operator!= (const G4VCollision &right) const
virtual G4double	CrossSection (const G4KineticTrack &trk1, const G4KineticTrack &trk2) const
virtual G4bool	IsInCharge (const G4KineticTrack &trk1, const G4KineticTrack &trk2) const =0
virtual G4String	GetName () const =0
virtual void	Print () const
virtual void	Print (const G4KineticTrack &trk1, const G4KineticTrack &trk2) const

Protected Member Functions
virtual const std::vector< const G4ParticleDefinition * > &	GetOutgoingParticles () const =0
Protected Member Functions inherited from G4VCollision
G4int	GetNumberOfPartons (const G4ParticleDefinition *aP) const
virtual const G4CollisionVector *	GetComponents () const
virtual const G4VCrossSectionSource *	GetCrossSectionSource () const =0
virtual const std::vector< G4String > &	GetListOfColliders (G4int whichOne) const =0

Private Member Functions
	G4VScatteringCollision (const G4VScatteringCollision &)
G4VScatteringCollision &	operator= (const G4VScatteringCollision &)
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
double	SampleResonanceMass (const double poleMass, const double width, const double minMass, const double maxMass) const

Private Attributes
G4VAngularDistribution *	theAngularDistribution

Detailed Description

Definition at line 56 of file G4VScatteringCollision.hh.

Constructor & Destructor Documentation

G4VScatteringCollision() [1/2]

G4VScatteringCollision::G4VScatteringCollision

(

)

Definition at line 47 of file G4VScatteringCollision.cc.

{ 
  theAngularDistribution = new G4AngularDistribution(true);
}

Here is the caller graph for this function:

~G4VScatteringCollision()

G4VScatteringCollision::~G4VScatteringCollision ( )

virtual

Definition at line 53 of file G4VScatteringCollision.cc.

{ 
  delete theAngularDistribution;
  theAngularDistribution=0;
}

G4VScatteringCollision() [2/2]

G4VScatteringCollision::G4VScatteringCollision ( const G4VScatteringCollision &  )

private

Member Function Documentation

BrWigInt0()

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

inlineprivate

Definition at line 85 of file G4VScatteringCollision.hh.

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

Here is the caller graph for this function:

BrWigInt1()

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

inlineprivate

Definition at line 88 of file G4VScatteringCollision.hh.

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

Here is the call graph for this function:

BrWigInv()

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

inlineprivate

Definition at line 91 of file G4VScatteringCollision.hh.

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

Here is the call graph for this function:

Here is the caller graph for this function:

establish_G4MT_TLS_G4VScatteringCollision()

void G4VScatteringCollision::establish_G4MT_TLS_G4VScatteringCollision

(

)

Definition at line 180 of file G4VScatteringCollision.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

FinalState()

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

virtual

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(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;
}

Here is the call graph for this function:

GetAngularDistribution()

virtual const G4VAngularDistribution* G4VScatteringCollision::GetAngularDistribution ( ) const

inlinevirtual

Implements G4VCollision.

Definition at line 70 of file G4VScatteringCollision.hh.

  {
    return theAngularDistribution;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

GetOutgoingParticles()

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

protectedpure virtual

Implemented in G4ConcreteNNTwoBodyResonance.

Here is the caller graph for this function:

operator!=()

G4bool G4VScatteringCollision::operator!=

(

const G4VScatteringCollision &

right

)

const

operator=()

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

private

Here is the caller graph for this function:

operator==()

G4bool G4VScatteringCollision::operator==

(

const G4VScatteringCollision &

right

)

const

SampleResonanceMass()

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

private

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);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

theAngularDistribution

G4VAngularDistribution* G4VScatteringCollision::theAngularDistribution

private

Definition at line 100 of file G4VScatteringCollision.hh.

---

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

• G4VScatteringCollision.hh
• G4VScatteringCollision.cc