G4NeutronHPChannel Class Reference

#include <G4NeutronHPChannel.hh>

Public Member Functions
	G4NeutronHPChannel ()
	~G4NeutronHPChannel ()
G4double	GetXsec (G4double energy)
G4double	GetWeightedXsec (G4double energy, G4int isoNumber)
G4double	GetFSCrossSection (G4double energy, G4int isoNumber)
G4bool	IsActive (G4int isoNumber)
G4bool	HasFSData (G4int isoNumber)
G4bool	HasAnyData (G4int isoNumber)
G4bool	Register (G4NeutronHPFinalState *theFS)
void	Init (G4Element *theElement, const G4String dirName)
void	Init (G4Element *theElement, const G4String dirName, const G4String fsType)
void	UpdateData (G4int A, G4int Z, G4int index, G4double abundance)
void	UpdateData (G4int A, G4int Z, G4int M, G4int index, G4double abundance)
void	Harmonise (G4NeutronHPVector *&theStore, G4NeutronHPVector *theNew)
G4HadFinalState *	ApplyYourself (const G4HadProjectile &theTrack, G4int isoNumber=-1)
G4int	GetNiso ()
G4double	GetN (G4int i)
G4double	GetZ (G4int i)
G4double	GetM (G4int i)
G4bool	HasDataInAnyFinalState ()

Detailed Description

Definition at line 54 of file G4NeutronHPChannel.hh.

Constructor & Destructor Documentation

G4NeutronHPChannel::G4NeutronHPChannel ( )

inline

Definition at line 58 of file G4NeutronHPChannel.hh.

  : wendtFissionGenerator(getenv("G4NEUTRON_HP_USE_WENDT_FISSION_MODEL") == NULL ? NULL : G4WendtFissionFragmentGenerator::GetInstance())
  {
    theChannelData = new G4NeutronHPVector; 
    theBuffer = 0;
    theIsotopeWiseData = 0;
    theFinalStates = 0;
    active = 0;
    registerCount = -1;
  }

G4NeutronHPChannel::~G4NeutronHPChannel ( )

inline

Definition at line 69 of file G4NeutronHPChannel.hh.

  {
    delete theChannelData; 
    // Following statement disabled to avoid SEGV
    // theBuffer is also deleted as "theChannelData" in
    // ~G4NeutronHPIsoData.  FWJ 06-Jul-1999
    //if(theBuffer != 0) delete theBuffer; 
    if(theIsotopeWiseData != 0) delete [] theIsotopeWiseData;
    // Deletion of FinalStates disabled to avoid endless looping
    // in the destructor heirarchy.  FWJ 06-Jul-1999
    //if(theFinalStates != 0)
    //{
    //  for(i=0; i<niso; i++)
    //  {
    //    delete theFinalStates[i];
    //  }
    //  delete [] theFinalStates;
    //}
    // FWJ experiment
    //if(active!=0) delete [] active;
// T.K. 
   if ( theFinalStates != 0 )
   {
      for ( G4int i = 0 ; i < niso ; i++ )
      {
         delete theFinalStates[i];
      }
      delete [] theFinalStates;
   }
   if ( active != 0 ) delete [] active;
    
  }

Member Function Documentation

G4HadFinalState * G4NeutronHPChannel::ApplyYourself	(	const G4HadProjectile &	theTrack,
		G4int	isoNumber = -1
	)

Definition at line 218 of file G4NeutronHPChannel.cc.

References G4WendtFissionFragmentGenerator::ApplyYourself(), G4NeutronHPFinalState::ApplyYourself(), G4UniformRand, G4NeutronHPManager::GetInstance(), GetM(), G4HadProjectile::GetMaterial(), G4NeutronHPFinalState::GetN(), GetN(), G4NeutronHPManager::GetReactionWhiteBoard(), G4Material::GetTemperature(), G4NeutronHPThermalBoost::GetThermalEnergy(), G4NeutronHPIsoData::GetXsec(), G4NeutronHPFinalState::GetZ(), GetZ(), HasAnyData(), G4NeutronHPReactionWhiteBoard::SetTargA(), G4NeutronHPReactionWhiteBoard::SetTargM(), and G4NeutronHPReactionWhiteBoard::SetTargZ().

Referenced by G4NeutronHPChannelList::ApplyYourself(), and G4FissLib::ApplyYourself().

  {
//    G4cout << "G4NeutronHPChannel::ApplyYourself+"<<niso<<G4endl;
    if ( anIsotope != -1 && anIsotope != -2 ) 
    {
       //Inelastic Case
       //G4cout << "G4NeutronHPChannel Inelastic Case" 
       //<< " Z= " << this->GetZ(it) << " A = " << this->GetN(it) << G4endl;
       G4NeutronHPManager::GetInstance()->GetReactionWhiteBoard()->SetTargA( (G4int)this->GetN(anIsotope) ); 
       G4NeutronHPManager::GetInstance()->GetReactionWhiteBoard()->SetTargZ( (G4int)this->GetZ(anIsotope) ); 
       return theFinalStates[anIsotope]->ApplyYourself(theTrack);
    }
    G4double sum=0;
    G4int it=0;
    G4double * xsec = new G4double[niso];
    G4NeutronHPThermalBoost aThermalE;
    for (G4int i=0; i<niso; i++)
    {
      if(theFinalStates[i]->HasAnyData())
      {
        xsec[i] = theIsotopeWiseData[i].GetXsec(aThermalE.GetThermalEnergy(theTrack,
                                                                   theFinalStates[i]->GetN(),
                                       theFinalStates[i]->GetZ(),
                                           theTrack.GetMaterial()->GetTemperature()));
        sum += xsec[i];
      }
      else
      {
        xsec[i]=0;
      }
    } 
    if(sum == 0) 
    {
//      G4cout << "G4NeutronHPChannel::ApplyYourself theFinalState->Initialize+"<<G4endl;
//      G4cout << "G4NeutronHPChannel::ApplyYourself theFinalState->Initialize-"<<G4endl;
      it = static_cast<G4int>(niso*G4UniformRand());
    }
    else
    {
//      G4cout << "Are we still here? "<<sum<<G4endl;
//      G4cout << "TESTHP 23 NISO="<<niso<<G4endl;
      G4double random = G4UniformRand();
      G4double running=0;
//      G4cout << "G4NeutronHPChannel::ApplyYourself Done the sum"<<niso<<G4endl;
//      G4cout << "TESTHP 24 NISO="<<niso<<G4endl;
      for (G4int ix=0; ix<niso; ix++)
      {
        running += xsec[ix];
        //if(random<=running/sum) 
        if( sum == 0 || random <= running/sum ) 
        { 
          it = ix;
      break;
        }
      }
      if(it==niso) it--;
    }
    delete [] xsec;
    G4HadFinalState * theFinalState=0;
    const G4int A = (G4int)this->GetN(it);
    const G4int Z = (G4int)this->GetZ(it);
    const G4int M = (G4int)this->GetM(it);

                                       //-2:Marker for Fission
    if(wendtFissionGenerator&&anIsotope==-2)
    {
        theFinalState = wendtFissionGenerator->ApplyYourself(theTrack, Z, A);
    }

    // Use the standard procedure if the G4FissionFragmentGenerator model fails
    if (!theFinalState)
    {
       while(theFinalState==0)
       {
//        G4cout << "TESTHP 24 it="<<it<<G4endl;
          theFinalState = theFinalStates[it]->ApplyYourself(theTrack);
       }
    }

    //G4cout <<"THE IMPORTANT RETURN"<<G4endl;
    //G4cout << "TK G4NeutronHPChannel Elastic, Capture and Fission Cases "
    //<< " Z= " << this->GetZ(it) << " A = " << this->GetN(it) << G4endl;
    G4NeutronHPManager::GetInstance()->GetReactionWhiteBoard()->SetTargA( A );
    G4NeutronHPManager::GetInstance()->GetReactionWhiteBoard()->SetTargZ( Z );
    G4NeutronHPManager::GetInstance()->GetReactionWhiteBoard()->SetTargM( M );

    return theFinalState;
  }

G4double G4NeutronHPChannel::GetFSCrossSection	(	G4double	energy,
		G4int	isoNumber
	)

Definition at line 55 of file G4NeutronHPChannel.cc.

References G4NeutronHPFinalState::GetXsec().

Referenced by G4NeutronHPChannelList::ApplyYourself().

  {
    return theFinalStates[isoNumber]->GetXsec(energy);
  }

G4double G4NeutronHPChannel::GetM ( G4int  i )

inline

Definition at line 132 of file G4NeutronHPChannel.hh.

References G4NeutronHPFinalState::GetM().

Referenced by ApplyYourself().

{return theFinalStates[i]->GetM();}

G4double G4NeutronHPChannel::GetN ( G4int  i )

inline

Definition at line 130 of file G4NeutronHPChannel.hh.

References G4NeutronHPFinalState::GetN().

Referenced by G4NeutronHPChannelList::ApplyYourself(), and ApplyYourself().

{return theFinalStates[i]->GetN();}

G4int G4NeutronHPChannel::GetNiso ( )

inline

Definition at line 128 of file G4NeutronHPChannel.hh.

Referenced by G4NeutronHPChannelList::ApplyYourself().

{return niso;}

G4double G4NeutronHPChannel::GetWeightedXsec	(	G4double	energy,
		G4int	isoNumber
	)

Definition at line 50 of file G4NeutronHPChannel.cc.

References G4NeutronHPIsoData::GetXsec().

Referenced by G4NeutronHPChannelList::ApplyYourself().

  {
    return theIsotopeWiseData[isoNumber].GetXsec(energy);
  }

G4double G4NeutronHPChannel::GetXsec

(

G4double

energy

)

Definition at line 45 of file G4NeutronHPChannel.cc.

References G4NeutronHPVector::GetXsec(), and G4INCL::Math::max().

Referenced by G4FissLib::ApplyYourself().

  {
    return std::max(0., theChannelData->GetXsec(energy));
  }

G4double G4NeutronHPChannel::GetZ ( G4int  i )

inline

Definition at line 131 of file G4NeutronHPChannel.hh.

References G4NeutronHPFinalState::GetZ().

Referenced by G4NeutronHPChannelList::ApplyYourself(), ApplyYourself(), and Register().

{return theFinalStates[i]->GetZ();}

void G4NeutronHPChannel::Harmonise	(	G4NeutronHPVector *&	theStore,
		G4NeutronHPVector *	theNew
	)

Definition at line 173 of file G4NeutronHPChannel.cc.

References test::a, G4NeutronHPVector::GetEnergy(), G4NeutronHPVector::GetVectorLength(), G4NeutronHPVector::GetXsec(), G4INCL::Math::max(), n, and G4NeutronHPVector::SetData().

Referenced by UpdateData().

  {
    G4int s_tmp = 0, n=0, m_tmp=0;
    G4NeutronHPVector * theMerge = new G4NeutronHPVector;
    G4NeutronHPVector * anActive = theStore;
    G4NeutronHPVector * aPassive = theNew;
    G4NeutronHPVector * tmp;
    G4int a = s_tmp, p = n, t;
    while (a<anActive->GetVectorLength()&&p<aPassive->GetVectorLength())
    {
      if(anActive->GetEnergy(a) <= aPassive->GetEnergy(p))
      {
        G4double xa  = anActive->GetEnergy(a);
        theMerge->SetData(m_tmp, xa, anActive->GetXsec(a)+std::max(0., aPassive->GetXsec(xa)) );
        m_tmp++;
        a++;
        G4double xp = aPassive->GetEnergy(p);
        if( std::abs(std::abs(xp-xa)/xa)<0.001 )
        {
          p++;
        }
      } else {
        tmp = anActive; t=a;
        anActive = aPassive; a=p;
        aPassive = tmp; p=t;
      }
    }
    while (a!=anActive->GetVectorLength())
    {
      theMerge->SetData(m_tmp++, anActive->GetEnergy(a), anActive->GetXsec(a));
      a++;
    }
    while (p!=aPassive->GetVectorLength())
    {
      if(std::abs(theMerge->GetEnergy(std::max(0,m_tmp-1))-aPassive->GetEnergy(p))/aPassive->GetEnergy(p)>0.001)
        theMerge->SetData(m_tmp++, aPassive->GetEnergy(p), aPassive->GetXsec(p));
      p++;
    }
    delete theStore;
    theStore = theMerge;
  }

G4bool G4NeutronHPChannel::HasAnyData ( G4int  isoNumber )

inline

Definition at line 112 of file G4NeutronHPChannel.hh.

References G4NeutronHPFinalState::HasAnyData().

Referenced by ApplyYourself(), HasDataInAnyFinalState(), and UpdateData().

{ return theFinalStates[isoNumber]->HasAnyData(); }

G4bool G4NeutronHPChannel::HasDataInAnyFinalState ( )

inline

Definition at line 134 of file G4NeutronHPChannel.hh.

References HasAnyData().

Referenced by Register().

  {
    G4bool result = false;
    G4int i;
    for(i=0; i<niso; i++)
    {
      if(theFinalStates[i]->HasAnyData()) result = true;
    }
    return result;
  }

G4bool G4NeutronHPChannel::HasFSData ( G4int  isoNumber )

inline

Definition at line 110 of file G4NeutronHPChannel.hh.

References G4NeutronHPFinalState::HasFSData().

{ return theFinalStates[isoNumber]->HasFSData(); }

void G4NeutronHPChannel::Init	(	G4Element *	theElement,
		const G4String	dirName
	)

Definition at line 67 of file G4NeutronHPChannel.cc.

Referenced by G4FissLib::G4FissLib(), Init(), and G4NeutronHPChannelList::Register().

  {
    theDir = dirName;
    theElement = anElement;
  }

void G4NeutronHPChannel::Init	(	G4Element *	theElement,
		const G4String	dirName,
		const G4String	fsType
	)

Definition at line 61 of file G4NeutronHPChannel.cc.

References Init().

  {
    theFSType = aFSType;
    Init(anElement, dirName);
  }

G4bool G4NeutronHPChannel::IsActive ( G4int  isoNumber )

inline

Definition at line 108 of file G4NeutronHPChannel.hh.

{ return active[isoNumber]; }

G4bool G4NeutronHPChannel::Register

(

G4NeutronHPFinalState *

theFS

)

Definition at line 73 of file G4NeutronHPChannel.cc.

References G4lrint(), G4StableIsotopes::GetAbundance(), G4StableIsotopes::GetFirstIsotope(), G4Element::GetIsotope(), G4StableIsotopes::GetIsotopeNucleonCount(), G4Isotope::Getm(), G4Isotope::GetN(), G4StableIsotopes::GetNumberOfIsotopes(), G4Element::GetNumberOfIsotopes(), G4Element::GetRelativeAbundanceVector(), G4Element::GetZ(), GetZ(), HasDataInAnyFinalState(), G4NeutronHPFinalState::New(), python.hepunit::perCent, G4NeutronHPFinalState::SetA_Z(), and UpdateData().

Referenced by G4FissLib::G4FissLib(), and G4NeutronHPChannelList::Register().

  {
    registerCount++;
    G4int Z = G4lrint(theElement->GetZ());

    Z = Z-registerCount;
    if ( registerCount > 5 ) throw G4HadronicException(__FILE__, __LINE__, "Channel: Do not know what to do with this material"); // for Elastic, Capture, Fission case 
    if ( Z < 1 ) return false; 
/*
    if(registerCount<5)
    {
      Z = Z-registerCount;
    }
*/
    //if(Z=theElement->GetZ()-5) throw G4HadronicException(__FILE__, __LINE__, "Channel: Do not know what to do with this material");
    // Bug fix by TK on behalf of AH
    if ( Z <=theElement->GetZ()-5 ) throw G4HadronicException(__FILE__, __LINE__, "Channel: Do not know what to do with this material");
    G4int count = 0;
    if(registerCount==0) count = theElement->GetNumberOfIsotopes();
    if(count == 0||registerCount!=0) count +=
         theStableOnes.GetNumberOfIsotopes(Z);
    niso = count;
    delete [] theIsotopeWiseData;
    theIsotopeWiseData = new G4NeutronHPIsoData [niso];
    delete [] active;
    active = new G4bool[niso];

    delete [] theFinalStates;
    theFinalStates = new G4NeutronHPFinalState * [niso];
    delete theChannelData;
    theChannelData = new G4NeutronHPVector; 
    for(G4int i=0; i<niso; i++)
    {
      theFinalStates[i] = theFS->New();
    }
    count = 0;
    G4int nIsos = niso;
    if(theElement->GetNumberOfIsotopes()!=0&&registerCount==0)
    {
      for (G4int i1=0; i1<nIsos; i1++)
      {
        // G4cout <<" Init: normal case"<<G4endl;
        G4int A = theElement->GetIsotope(i1)->GetN();
        G4int M = theElement->GetIsotope(i1)->Getm();
        G4double frac = theElement->GetRelativeAbundanceVector()[i1]/perCent;
        //theFinalStates[i1]->SetA_Z(A, Z);
    //UpdateData(A, Z, count++, frac);
        theFinalStates[i1]->SetA_Z(A, Z, M);
    UpdateData(A, Z, M, count++, frac);
      }
    } else {
      //G4cout <<" Init: mean case: "
      //       <<theStableOnes.GetNumberOfIsotopes(Z)<<" "
    //     <<Z<<" "<<theElement
    //     << G4endl;
      G4int first = theStableOnes.GetFirstIsotope(Z);
      for(G4int i1=0; 
        i1<theStableOnes.GetNumberOfIsotopes(Z);
        i1++)
      {
        G4int A = theStableOnes.GetIsotopeNucleonCount(first+i1);
        G4double frac = theStableOnes.GetAbundance(first+i1);
        theFinalStates[i1]->SetA_Z(A, Z);
        UpdateData(A, Z, count++, frac);
      }
    }
    G4bool result = HasDataInAnyFinalState();
    return result;
  }

void G4NeutronHPChannel::UpdateData ( G4int  A, G4int  Z, G4int  index, G4double  abundance  )

inline

Definition at line 121 of file G4NeutronHPChannel.hh.

References UpdateData().

Referenced by Register(), and UpdateData().

{ G4int M = 0; UpdateData( A, Z, M, index, abundance); };

void G4NeutronHPChannel::UpdateData	(	G4int	A,
		G4int	Z,
		G4int	M,
		G4int	index,
		G4double	abundance
	)

Definition at line 144 of file G4NeutronHPChannel.cc.

References G4NeutronHPIsoData::FillChannelData(), G4NeutronHPFinalState::GetXsec(), Harmonise(), HasAnyData(), G4NeutronHPIsoData::Init(), G4NeutronHPFinalState::Init(), G4WendtFissionFragmentGenerator::InitializeANucleus(), G4NeutronHPIsoData::MakeChannelData(), and G4NeutronHPVector::Times().

  {
    // Initialze the G4FissionFragment generator for this isomer if needed
    if(wendtFissionGenerator)
    {
      wendtFissionGenerator->InitializeANucleus(A, Z, M, theDir);
    }

    theFinalStates[index]->Init(A, Z, M, theDir, theFSType);
    if(!theFinalStates[index]->HasAnyData()) return; // nothing there for exactly this isotope.

    // the above has put the X-sec into the FS
    theBuffer = 0;
    if(theFinalStates[index]->HasXsec())
    {
      theBuffer = theFinalStates[index]->GetXsec();
      theBuffer->Times(abundance/100.);
      theIsotopeWiseData[index].FillChannelData(theBuffer);
    }
    else // get data from CrossSection directory
    {
      G4String tString = "/CrossSection";
      //active[index] = theIsotopeWiseData[index].Init(A, Z, abundance, theDir, tString);
      active[index] = theIsotopeWiseData[index].Init(A, Z, M, abundance, theDir, tString);
      if(active[index]) theBuffer = theIsotopeWiseData[index].MakeChannelData();
    }
    if(theBuffer != 0) Harmonise(theChannelData, theBuffer);
  }

---

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

• G4NeutronHPChannel.hh
• G4NeutronHPChannel.cc