Spectrum.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 _Spectrum_
#define _Spectrum_
 
#include <string>
#include <iosfwd>
#include <vector>
 
using namespace std;
#include "Material.hxx"
 
class Material;
 
 
class Spectrum
{
  public:
 
 
    Spectrum(double Emin, double Emax, int NumberOfbins, bool log = false); 
 
 
    Spectrum(vector<double> LowerEnergy, bool check = true);
 
 
    Spectrum(double *LowerEnergy, int NumberOfBins, bool check = true); 
 
 
    Spectrum(string BinningFileName, bool check = true);
 
 
    Spectrum(int NumberOfBins, double a, double b, double c, bool check = true);
 
    Spectrum(const Spectrum  &spect); 
    ~Spectrum(); 
 
    void SetZ(int Z)
    {
        fZ = Z;   
    }
    void SetA(int A)
    {
        fA = A;   
    }
    void SetName(string Name)
    {
        fName = Name;   
    }
    void SetNumberOfbins(int nbins)
    {
        fNumberOfbins = nbins;   
    }
    void SetBin(int i, double intensity)
    {
        fHistogram[i] = intensity;   
    }
    //void SetCalibration(double KeVbyChan){fEnergyCalibration=KeVbyChan;}//!< Set the calibration in keV per Channel
 
    int GetZ()
    {
        return fZ;   
    }
    int GetA()
    {
        return fA;   
    }
    string GetName()
    {
        return fName;   
    }
    double GetBin(int i)
    {
        return fHistogram[i];   
    }
    double *GetBin()
    {
        return fHistogram;   
    }
    double *GetLowerEnergy()
    {
        return fLowerEnergy;   
    }
    double GetLowerEnergy(int i)
    {
        return fLowerEnergy[i];   
    }
    //double GetCalibration() {return fEnergyCalibration;}  //!< Return the kev by bins coefficient
    double GetEnergyBinWidth(int i);            
    double GetMiddleEnergy(int i);          
    int GetBinNumber(double Energy);        
    int GetNumberOfbins()
    {
        return fNumberOfbins;   
    }
    bool IsLog()
    {
        return fIsLog;   
    }
    bool IsAlpha()
    {
        return fIsAlpha;   
    }
    bool IsNeutron()
    {
        return fIsNeutron;   
    }
    bool IsGamma()
    {
        return fIsGamma;   
    }
    bool IsBeta()
    {
        return fIsBeta;   
    }
    int GetParticleType();                      
    bool GotTheSameBinning(Spectrum *aSpectrum);
    bool IsEmpty();                 
    bool IsTheSameSpectrum(Spectrum *SameOrNot);    
    void Initialize();              
    void CheckBin();                
    void AddEnergy(double Energy, double Intensity);    
    void Contract(int ContractionFactor);               
    double TotalActivity();                             
    double GetTotalNumberOfParticlesPerDecay()
    {
        return fTotalNumberOfParticlesPerDecay;
    };
    double GetTotalBecquerel()
    {
        return fTotalBecquerel;
    };
 
    void Fill(Material *material, double volume);
    void FillFromFile(string filename);
    void Dump(string filename = "Spectrum.dat", bool WithEnergies = false); 
    void Normalize(double Multiplicateur);   
    void AddSpectrum(Spectrum *aSpectrum);      
    void RemoveSpectrum(Spectrum *aSpectrum);   
    Spectrum *NewSpectrumNormalized(Spectrum *UnNormalized, double Norm); 
    Spectrum *NewSpectrumNormalized2(Spectrum *UnNormalized, double Norm); 
    Spectrum *ConvertRayToGaussian(Spectrum *Spect_Raie, double FWHM); 
 
  protected:
    bool        fIsLog; 
    int         fNumberOfbins;
    double    *fHistogram; 
    double    *fLowerEnergy; 
    double fTotalParticlesEmitted;
    double fTotalNumberOfParticlesPerDecay;
    double fTotalBecquerel;
    int         fZ;     
    int         fA;     
    string      fName;   
    bool    fIsAlpha;   
    bool    fIsBeta;    
    bool    fIsGamma;   
    bool    fIsNeutron; 
    void ElementSymbol(int Zd, char &Z1, char &Z2); 
    void CreateBins(double EnergyMin, double EnergyMax, int NumberOfbins); 
    void CreateBins(vector<double> LowerEnergy);
    void CreateBins(double *LowerEnergy); 
    bool IsDouble(const std::string &s);
    void ReadENSDFFile(int Adaughter, vector <string> &Buffer, int &NumOfLine); 
    bool FindFirstLinesOfDecayModeCard(vector<string>  const &Buffer, char Z1, char Z2, vector<int> &BeginRecordLine, string DecayMode, string DecayModeBis = ""); //<!Find the first lines of ensdf decay mode cards
 
};
#endif