G4FermiBreakUp Class Reference

#include <G4FermiBreakUp.hh>

Inheritance diagram for G4FermiBreakUp:

Collaboration diagram for G4FermiBreakUp:

Public Member Functions
	G4FermiBreakUp ()
virtual	~G4FermiBreakUp ()
G4FragmentVector *	BreakItUp (const G4Fragment &theNucleus)
void	BreakFragment (G4FragmentVector *, G4Fragment *theNucleus)
Public Member Functions inherited from G4VFermiBreakUp
	G4VFermiBreakUp ()
virtual	~G4VFermiBreakUp ()

Private Member Functions
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)
const G4FermiBreakUp &	operator= (const G4FermiBreakUp &right)
G4bool	operator== (const G4FermiBreakUp &right) const
G4bool	operator!= (const G4FermiBreakUp &right) const

Private Attributes
G4FermiFragmentsPool *	thePool
std::vector< G4double >	NormalizedWeights
G4double	Coef
G4double	ConstCoeff
size_t	nmax
G4Pow *	g4pow
const G4FermiPhaseSpaceDecay *	thePhaseSpace
std::vector< G4double >	massRes
std::vector< const G4VFermiFragment * >	frag

Detailed Description

Definition at line 44 of file G4FermiBreakUp.hh.

Constructor & Destructor Documentation

G4FermiBreakUp() [1/2]

G4FermiBreakUp::G4FermiBreakUp

(

)

Definition at line 47 of file G4FermiBreakUp.cc.

{
  thePool = G4FermiFragmentsPool::Instance(); 
  g4pow = G4Pow::GetInstance();
  Coef = 0.6*(CLHEP::elm_coupling/r0)/g4pow->Z13(1+G4int(Kappa));
  ConstCoeff = g4pow->powN(r0/hbarc,3)*Kappa/(6.0*pi*pi);

  thePhaseSpace = thePool->GetFermiPhaseSpaceDecay();

  nmax = 16;
  NormalizedWeights.resize(nmax,0.0);
  massRes.reserve(4);
  frag.resize(4, 0);
}

Here is the call graph for this function:

~G4FermiBreakUp()

G4FermiBreakUp::~G4FermiBreakUp ( )

virtual

Definition at line 62 of file G4FermiBreakUp.cc.

{}

G4FermiBreakUp() [2/2]

G4FermiBreakUp::G4FermiBreakUp ( const G4FermiBreakUp &  right )

private

Member Function Documentation

BreakFragment()

void G4FermiBreakUp::BreakFragment ( G4FragmentVector *  theResult, G4Fragment *  theNucleus  )

virtual

Implements G4VFermiBreakUp.

Definition at line 92 of file G4FermiBreakUp.cc.

{
  // 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

BreakItUp()

G4FragmentVector * G4FermiBreakUp::BreakItUp ( const G4Fragment &  theNucleus )

virtual

Implements G4VFermiBreakUp.

Definition at line 84 of file G4FermiBreakUp.cc.

{
  G4FragmentVector* result = new G4FragmentVector();
  G4Fragment* nucleus = new G4Fragment(theNucleus);
  BreakFragment(result, nucleus);
  return result;
}

Here is the call graph for this function:

CoulombBarrier()

G4double G4FermiBreakUp::CoulombBarrier ( const std::vector< const G4VFermiFragment *> *  v )

private

Definition at line 65 of file G4FermiBreakUp.cc.

{
  //  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)/g4pow->Z13(a);
    SumA += a;
    SumZ += z;
  }
  CoulombEnergy -= SumZ*SumZ/g4pow->Z13(SumA);
  return -Coef * CoulombEnergy;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DecayProbability()

G4double G4FermiBreakUp::DecayProbability ( G4int  A, G4double  TotalE, const G4FermiConfiguration *  conf  )

private

Definition at line 181 of file G4FermiBreakUp.cc.

{
  // 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 = g4pow->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 = g4pow->factorial(N - 1);
    Energ = g4pow->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;
    Gamma = sqrtpi*g4pow->factorial(n2)/
      (g4pow->powN(4.0,n1)*g4pow->factorial(n1));
    Energ = g4pow->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 *= g4pow->factorial(nf); }
    }
  }

  G4double Weight = Coeff*MassFactor*S_n*Energ/(G_n*Gamma*KineticEnergy);

  return Weight; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator!=()

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

private

operator=()

const G4FermiBreakUp& G4FermiBreakUp::operator= ( const G4FermiBreakUp &  right )

private

operator==()

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

private

SelectConfiguration()

const std::vector< const G4VFermiFragment * > * G4FermiBreakUp::SelectConfiguration ( G4int  Z, G4int  A, G4double  mass  )

private

Definition at line 145 of file G4FermiBreakUp.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

Coef

G4double G4FermiBreakUp::Coef

private

Definition at line 78 of file G4FermiBreakUp.hh.

ConstCoeff

G4double G4FermiBreakUp::ConstCoeff

private

Definition at line 79 of file G4FermiBreakUp.hh.

frag

std::vector<const G4VFermiFragment*> G4FermiBreakUp::frag

private

Definition at line 86 of file G4FermiBreakUp.hh.

g4pow

G4Pow* G4FermiBreakUp::g4pow

private

Definition at line 82 of file G4FermiBreakUp.hh.

massRes

std::vector<G4double> G4FermiBreakUp::massRes

private

Definition at line 85 of file G4FermiBreakUp.hh.

nmax

size_t G4FermiBreakUp::nmax

private

Definition at line 80 of file G4FermiBreakUp.hh.

NormalizedWeights

std::vector<G4double> G4FermiBreakUp::NormalizedWeights

private

Definition at line 76 of file G4FermiBreakUp.hh.

thePhaseSpace

const G4FermiPhaseSpaceDecay* G4FermiBreakUp::thePhaseSpace

private

Definition at line 84 of file G4FermiBreakUp.hh.

thePool

G4FermiFragmentsPool* G4FermiBreakUp::thePool

private

Definition at line 74 of file G4FermiBreakUp.hh.

---

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

• G4FermiBreakUp.hh
• G4FermiBreakUp.cc