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)
G4bool	HasDataInAnyFinalState ()

Detailed Description

Definition at line 54 of file G4NeutronHPChannel.hh.

Constructor & Destructor Documentation

G4NeutronHPChannel()

G4NeutronHPChannel::G4NeutronHPChannel ( )

inline

Definition at line 58 of file G4NeutronHPChannel.hh.

  {
    theChannelData = new G4NeutronHPVector; 
    theBuffer = 0;
    theIsotopeWiseData = 0;
    theFinalStates = 0;
    active = 0;
    registerCount = -1;
  }

~G4NeutronHPChannel()

G4NeutronHPChannel::~G4NeutronHPChannel ( )

inline

Definition at line 68 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

ApplyYourself()

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

Definition at line 210 of file G4NeutronHPChannel.cc.

  {
//    G4cout << "G4NeutronHPChannel::ApplyYourself+"<<niso<<G4endl;
    if ( anIsotope != -1 ) 
    {
       //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;
    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( (G4int)this->GetN(it) ); 
    G4NeutronHPManager::GetInstance()->GetReactionWhiteBoard()->SetTargZ( (G4int)this->GetZ(it) ); 
    return theFinalState;
  }

Referenced by G4NeutronHPChannelList::ApplyYourself(), G4FissLib::ApplyYourself(), G4NeutronHPorLCapture::ApplyYourself(), G4NeutronHPorLElastic::ApplyYourself(), and G4NeutronHPorLFission::ApplyYourself().

GetFSCrossSection()

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

Definition at line 53 of file G4NeutronHPChannel.cc.

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

Referenced by G4NeutronHPChannelList::ApplyYourself().

GetN()

G4double G4NeutronHPChannel::GetN ( G4int  i )

inline

Definition at line 129 of file G4NeutronHPChannel.hh.

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

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

GetNiso()

G4int G4NeutronHPChannel::GetNiso ( )

inline

Definition at line 127 of file G4NeutronHPChannel.hh.

{return niso;}

Referenced by G4NeutronHPChannelList::ApplyYourself(), G4NeutronHPorLCapture::GetNiso(), G4NeutronHPorLElastic::GetNiso(), and G4NeutronHPorLFission::GetNiso().

GetWeightedXsec()

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

Definition at line 48 of file G4NeutronHPChannel.cc.

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

Referenced by G4NeutronHPChannelList::ApplyYourself().

GetXsec()

G4double G4NeutronHPChannel::GetXsec

(

G4double

energy

)

Definition at line 43 of file G4NeutronHPChannel.cc.

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

Referenced by G4FissLib::ApplyYourself(), G4NeutronHPorLCapture::ApplyYourself(), G4NeutronHPorLElastic::ApplyYourself(), G4NeutronHPorLFission::ApplyYourself(), G4NeutronHPorLCaptureData::GetCrossSection(), G4NeutronHPorLElasticData::GetCrossSection(), and G4NeutronHPorLFissionData::GetCrossSection().

GetZ()

G4double G4NeutronHPChannel::GetZ ( G4int  i )

inline

Definition at line 130 of file G4NeutronHPChannel.hh.

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

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

Harmonise()

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

Definition at line 166 of file G4NeutronHPChannel.cc.

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

Referenced by UpdateData().

HasAnyData()

G4bool G4NeutronHPChannel::HasAnyData ( G4int  isoNumber )

inline

Definition at line 111 of file G4NeutronHPChannel.hh.

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

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

HasDataInAnyFinalState()

G4bool G4NeutronHPChannel::HasDataInAnyFinalState ( )

inline

Definition at line 132 of file G4NeutronHPChannel.hh.

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

Referenced by Register().

HasFSData()

G4bool G4NeutronHPChannel::HasFSData ( G4int  isoNumber )

inline

Definition at line 109 of file G4NeutronHPChannel.hh.

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

Init() [1/2]

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

Definition at line 65 of file G4NeutronHPChannel.cc.

  {
    theDir = dirName;
    theElement = anElement;
  }

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

Init() [2/2]

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

Definition at line 58 of file G4NeutronHPChannel.cc.

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

IsActive()

G4bool G4NeutronHPChannel::IsActive ( G4int  isoNumber )

inline

Definition at line 107 of file G4NeutronHPChannel.hh.

{ return active[isoNumber]; }

Register()

G4bool G4NeutronHPChannel::Register

(

G4NeutronHPFinalState *

theFS

)

Definition at line 71 of file G4NeutronHPChannel.cc.

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

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

UpdateData() [1/2]

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

inline

Definition at line 120 of file G4NeutronHPChannel.hh.

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

Referenced by Register(), and UpdateData().

UpdateData() [2/2]

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

Definition at line 142 of file G4NeutronHPChannel.cc.

  {
    //theFinalStates[index]->Init(A, Z, theDir, theFSType);
    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