NeutronSpectrum.hxx

Go to the documentation of this file.

/*
  This file is part of MURE,
  Copyright (C) 2007-2021 MURE developers.
 
  MURE is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  MURE is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public License
  along with MURE.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef _NeutronSpectrum_
#define _NeutronSpectrum_
 
#include <cmath>
#include <vector>
#include <iostream>
#include <string>
 
using namespace std;
 
#include "AlphaSpectrum.hxx"
#include "Spectrum.hxx"
 
class AlphaSpectrum;
class Material;
 
 
 
class AlphaNTabs
{
  public:
 
    AlphaNTabs(int AlphaNumberOfBins = 8000, double Alpha_eVPerBin = 1e3);
 
    ~AlphaNTabs(); 
 
 
    double GetStopPower(int AlphaBin)
    {
        return fStopPower[AlphaBin] ;
    }
 
 
    void SetStopPower(int AlphaBin, double Value)
    {
        fStopPower[AlphaBin] = Value ;   
    }
 
 
    double GetXSectTot(int target, int AlphaBin)
    {
        return fXSectTot[target][AlphaBin] ;
    }
 
 
    void SetXSectTot(int target, int AlphaBin, double value)
    {
        fXSectTot[target][AlphaBin] = value;
    }
 
 
    double GetNeutronEmin(int target, int level, int AlphaBin)
    {
        return fNeutronEmin[target][level][AlphaBin] ;
    }
 
 
    void SetNeutronEmin(int target, int level, int AlphaBin, double value)
    {
        fNeutronEmin[target][level][AlphaBin] = value;   
    }
 
 
    double GetNeutronEmax(int target, int level, int AlphaBin)
    {
        return fNeutronEmax[target][level][AlphaBin] ;
    }
 
 
    void SetNeutronEmax(int target, int level, int AlphaBin, double value)
    {
        fNeutronEmax[target][level][AlphaBin] = value;
    }
 
 
    double GetBranchingLevel(int target, int level, int AlphaBin)
    {
        return fBranchingLevel[target][level][AlphaBin] ;
    }
 
 
    void SetBranchingLevel(int target, int level, int AlphaBin, double value)
    {
        fBranchingLevel[target][level][AlphaBin] = value;
    }
 
    Spectrum *GetSpectrum(int AlphaBin)
    {
        return fSpectra[AlphaBin] ;   
    }
    void SetSpectrum(int AlphaBin, Spectrum *spectrum)
    {
        fSpectra[AlphaBin] = spectrum;   
    }
 
    int GetLevelSize(int TargetNumber)
    {
        return fLevelSize[TargetNumber];
    }
 
    int GetAlphaNumberOfBins()
    {
        return fAlphaNumberOfBins;   
    }
    double GetAlphaCalibration()
    {
        return fAlpha_eVperBin;   
    }
 
  private:
    int     fAlphaNumberOfBins;  
    double fAlpha_eVperBin;     
    int     *fLevelSize;         
    double *fStopPower;         
    double **fXSectTot;         
    double  ***fNeutronEmin;        
    double  ***fNeutronEmax;        
    double  ***fBranchingLevel; 
    Spectrum **fSpectra;          
    void InitAlphaNTabs();      
 
};
 
 
class NeutronSpectrum : public Spectrum
{
  public:
 
    NeutronSpectrum(double Emin, double Emax, int NumberOfBins, bool log = false);
 
 
    NeutronSpectrum(vector < double > LowerEnergy);
 
 
    NeutronSpectrum(double *LowerEnergy, int NumberOfBins);
 
 
    NeutronSpectrum(string BinningFileName);
 
    NeutronSpectrum(int NumberOfBins, double a, double b, double c);
 
    NeutronSpectrum(const NeutronSpectrum  &spect);
 
 
    NeutronSpectrum *ReadENSDF(int Z, int A, int I, double NAtoms = 1);
 
 
    NeutronSpectrum *ReadSFDATA(int Z, int A, int I, double NAtoms = 1);
 
    NeutronSpectrum *AddAlphaNSpectra(Material *Waste, double WasteVolume, double UO2Density = - 1);
    NeutronSpectrum *AddAlphaNSpectra(int Z, int A, int I, double NAtoms, double UO2Density = 10.4);
    NeutronSpectrum *AddAlphaNSpectra(int Z, int A, int I, double NAtoms, double *OxygenDensity, double UO2Density = 10.4);
 
    void SetAlphaNumberOfBins(int nbins)
    {
        fAlphaNumberOfBins = nbins;
    }
 
 
    void SetAlpha_eVPerBin(double eV_bin)
    {
        fAlpha_eVPerBin = eV_bin;
    }
 
    double CalculateSFSpectra(double Param_a, double Param_b, double Energy);
 
 
    NeutronSpectrum *BuildAlphaNSpectra(AlphaSpectrum *AS, double *OxygenDensity, double UO2Density);
 
  private:
 
    double CalculateNeutronEnergy(string MinOrMax, int level, int TargetNumber, double EnergyAlpha);
    double CalculateStoppingPower(double Energy, double UO2Density);
    double FindSigmaAlphaN(int level, int TargetNumber, double Energy);
    double ProductNuclideLevelBranchingFraction(int level, int TargetNumber, double Energy);
    double LevelBranchingFraction(int level, int TargetNumber, double Energy);
 
    string FindXSFile(int level, int TargetNumber);
 
 
    double  EnergyRangeFraction(double NeutronEmin, double NeutronEmax, double LowerBinEnergyBound, double UpperBinEnergyBound);
 
    void ExtractDataFromLine(string Line, Material *TheParent, double NAtoms);
 
    bool fAllowToAdd;           
    double fDecayConst;         
    double fRelativeIntensity;  
    double fBranchingRatio;     
    double fEofDecayLevel;
    double fEnergy;             
    double fIntensity;          
    bool fIsomStateIsOk;
    static AlphaNTabs *fTabs;   
    static int fAlphaNumberOfBins;  
    static double fAlpha_eVPerBin;  
};
 
#endif