G4MesonAbsorption Class Reference

#include <G4MesonAbsorption.hh>

Inheritance diagram for G4MesonAbsorption:

Public Member Functions
	G4MesonAbsorption ()
virtual	~G4MesonAbsorption ()
virtual const std::vector< G4CollisionInitialState * > &	GetCollisions (G4KineticTrack *aProjectile, std::vector< G4KineticTrack * > &someCandidates, G4double aCurrentTime)
virtual G4KineticTrackVector *	GetFinalState (G4KineticTrack *aProjectile, std::vector< G4KineticTrack * > &theTargets)
G4CollisionInitialState *	GetCollision (G4KineticTrack *projectile, std::vector< G4KineticTrack * > targets)
Public Member Functions inherited from G4BCAction
	G4BCAction ()
virtual	~G4BCAction ()
virtual const std::vector< G4CollisionInitialState * > &	GetCollisions (G4KineticTrack *aProjectile, std::vector< G4KineticTrack * > &someCandidates, G4double aCurrentTime)=0
virtual G4KineticTrackVector *	GetFinalState (G4KineticTrack *aProjectile, std::vector< G4KineticTrack * > &theTargets)=0

Detailed Description

Definition at line 34 of file G4MesonAbsorption.hh.

Constructor & Destructor Documentation

G4MesonAbsorption()

G4MesonAbsorption::G4MesonAbsorption ( )

inline

Definition at line 37 of file G4MesonAbsorption.hh.

{}

~G4MesonAbsorption()

virtual G4MesonAbsorption::~G4MesonAbsorption ( )

inlinevirtual

Definition at line 38 of file G4MesonAbsorption.hh.

{}

Member Function Documentation

GetCollision()

G4CollisionInitialState * G4MesonAbsorption::GetCollision	(	G4KineticTrack *	projectile,
		std::vector< G4KineticTrack * >	targets
	)

GetCollisions()

const std::vector< G4CollisionInitialState * > & G4MesonAbsorption::GetCollisions ( G4KineticTrack *  aProjectile, std::vector< G4KineticTrack * > &  someCandidates, G4double  aCurrentTime  )

virtual

Implements G4BCAction.

Definition at line 43 of file G4MesonAbsorption.cc.

{
  theCollisions.clear();
  if(someCandidates.size() >1)
  {
    std::vector<G4KineticTrack *>::iterator j=someCandidates.begin();
    for(; j != someCandidates.end(); ++j)
    {
      G4double collisionTime = GetTimeToAbsorption(*aProjectile, **j);
      if(collisionTime == DBL_MAX) 
      {
        continue;
      }
      G4KineticTrackVector aTarget;
      aTarget.push_back(*j);
      FindAndFillCluster(aTarget, aProjectile, someCandidates);
      if(aTarget.size()>=2)
      {
        theCollisions.push_back(
        new G4CollisionInitialState(collisionTime+aCurrentTime, aProjectile, aTarget, this) );
      }
    }
  }
  return theCollisions;
}

GetFinalState()

G4KineticTrackVector * G4MesonAbsorption::GetFinalState ( G4KineticTrack *  aProjectile, std::vector< G4KineticTrack * > &  theTargets  )

virtual

Implements G4BCAction.

Definition at line 103 of file G4MesonAbsorption.cc.

{
  // G4cout << "We have an absorption !!!!!!!!!!!!!!!!!!!!!!"<<G4endl;
  // Only 2-body absorption for the time being.
  // If insufficient, use 2-body absorption and clusterization to emulate 3-,4-,etc body absorption.
  G4LorentzVector thePro = projectile->Get4Momentum();
  G4LorentzVector theT1 = targets[0]->Get4Momentum();
  G4LorentzVector theT2 = targets[1]->Get4Momentum();
  G4LorentzVector incoming = thePro + theT1 + theT2;
  G4double energyBalance = incoming.t();
  G4int chargeBalance = G4lrint(projectile->GetDefinition()->GetPDGCharge()
                       + targets[0]->GetDefinition()->GetPDGCharge()
                       + targets[1]->GetDefinition()->GetPDGCharge());
               
  G4int baryonBalance = projectile->GetDefinition()->GetBaryonNumber()
                       + targets[0]->GetDefinition()->GetBaryonNumber()
                       + targets[1]->GetDefinition()->GetBaryonNumber();
   
  
  // boost all to MMS
  G4LorentzRotation toSPS((-1)*(thePro + theT1 + theT2).boostVector());
  theT1 = toSPS * theT1;
  theT2 = toSPS * theT2;
  thePro = toSPS * thePro;
  G4LorentzRotation fromSPS(toSPS.inverse());
 
  // rotate to z
  G4LorentzRotation toZ;
  G4LorentzVector Ptmp=projectile->Get4Momentum();
  toZ.rotateZ(-1*Ptmp.phi());
  toZ.rotateY(-1*Ptmp.theta());
  theT1 = toZ * theT1;
  theT2 = toZ * theT2;
  thePro = toZ * thePro;
  G4LorentzRotation toLab(toZ.inverse());
  
  // Get definitions
  G4ParticleDefinition * d1 = targets[0]->GetDefinition();
  G4ParticleDefinition * d2 = targets[1]->GetDefinition();
  if(0.5>G4UniformRand())
  {
    G4ParticleDefinition * temp;
    temp=d1;d1=d2;d2=temp;
  }
  G4ParticleDefinition * dp = projectile->GetDefinition();
  if(dp->GetPDGCharge()<-.5)
  {
    if(d1->GetPDGCharge()>.5)
    {
      if(d2->GetPDGCharge()>.5 && 0.5>G4UniformRand())
      {
        d2 = G4Neutron::NeutronDefinition();
      }
      else
      {
        d1 = G4Neutron::NeutronDefinition();
      }
    }
    else if(d2->GetPDGCharge()>.5)
    {
      d2 = G4Neutron::NeutronDefinition();  
    }
  }
  else if(dp->GetPDGCharge()>.5)
  {
    if(d1->GetPDGCharge()<.5)
    {
      if(d2->GetPDGCharge()<.5 && 0.5>G4UniformRand())
      {
        d2 = G4Proton::ProtonDefinition();
      }
      else
      {
        d1 = G4Proton::ProtonDefinition();
      }
    }
    else if(d2->GetPDGCharge()<.5)
    {
      d2 = G4Proton::ProtonDefinition();  
    }
  }
  
  // calculate the momenta.
  G4double M_sq  = (thePro+theT1+theT2).mag2();
  G4double m1_sq = sqr(d1->GetPDGMass());
  G4double m2_sq = sqr(d2->GetPDGMass());
  G4double m_sq  = M_sq-m1_sq-m2_sq;
  G4double p = std::sqrt((m_sq*m_sq - 4.*m1_sq * m2_sq)/(4.*M_sq));
  G4double costh = 2.*G4UniformRand()-1.;
  G4double phi = 2.*pi*G4UniformRand();
  G4ThreeVector pFinal(p*std::sin(std::acos(costh))*std::cos(phi), p*std::sin(std::acos(costh))*std::sin(phi), p*costh);
  
  // G4cout << "testing p "<<p-pFinal.mag()<<G4endl;
  // construct the final state particles lorentz momentum.
  G4double eFinal1 = std::sqrt(m1_sq+pFinal.mag2());
  G4LorentzVector final1(pFinal, eFinal1);
  G4double eFinal2 = std::sqrt(m2_sq+pFinal.mag2());
  G4LorentzVector final2(-1.*pFinal, eFinal2);
  
  // rotate back.
  final1 = toLab * final1;
  final2 = toLab * final2;
  
  // boost back to LAB
  final1 = fromSPS * final1;
  final2 = fromSPS * final2;
  
  // make the final state
  G4KineticTrack * f1 = 
      new G4KineticTrack(d1, 0., targets[0]->GetPosition(), final1);
  G4KineticTrack * f2 = 
      new G4KineticTrack(d2, 0., targets[1]->GetPosition(), final2);
  G4KineticTrackVector * result = new G4KineticTrackVector;
  result->push_back(f1);
  result->push_back(f2);
 
  for(size_t hpw=0; hpw<result->size(); hpw++)
  {
    energyBalance-=result->operator[](hpw)->Get4Momentum().t();
    chargeBalance-=G4lrint(result->operator[](hpw)->GetDefinition()->GetPDGCharge());
    baryonBalance-=result->operator[](hpw)->GetDefinition()->GetBaryonNumber();
  }
  if(getenv("AbsorptionEnergyBalanceCheck"))
    std::cout << "DEBUGGING energy balance B: "
              <<energyBalance<<" "
          <<chargeBalance<<" "
          <<baryonBalance<<" "
          <<G4endl;
  return result;
}

---

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

• G4MesonAbsorption.hh
• G4MesonAbsorption.cc