XPS4XPS.H

Go to the documentation of this file.

//: xps4xps.h
#if defined (__GNUG__)
    #pragma interface "xps4xps.h"
#endif

#ifndef xps4xps_h
#define xps4xps_h

#include <wx/wxprec.h>

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include <wx/wx.h>
#endif

#include    <math.h>
#include    "xprule.h"
//#include    "panelc1s.h"

extern double EnergyTolerance;
// forward declarations
class   xpSpectrumBase;
class   xpPeakBase;
class   xpSampleBase;
class   xpPeakPanel;


class xpSpectrumObjectAgent : public xpAgent
{   protected:
        float MaxEnergy;    
        float MinEnergy;    
        float XEnergy;      
        xboolean::xbool EnergyBE;   
        xboolean::xbool XEnergyKnown;   
    public:
        xpSpectrumObjectAgent(void)
        {   EnergyBE    = xboolean::Unknown;
            XEnergyKnown= xboolean::Unknown;
            MinEnergy = 100; MaxEnergy = 1400;
            XEnergy = 1486.6f;
        }
        xpSpectrumObjectAgent(const xpSpectrumObjectAgent& S)
        {
            EnergyBE    = S.EnergyBE;
            XEnergyKnown= S.XEnergyKnown;
            MinEnergy = S.MinEnergy; MaxEnergy = S.MaxEnergy;
            XEnergy = S.XEnergy;
        }
        xboolean::xbool GetEnergyBE(void)
            {   return EnergyBE ; }
        float GetMaxEnergy(void)
            {   return MaxEnergy;}
        float GetMinEnergy(void)
            {   return MinEnergy;}
        float GetXEnergy(void)
            {   return XEnergy;}
        xboolean::xbool GetXEnergyKnown(void)
            {   return XEnergyKnown; }
        bool IsEnergyBE(void)
            {   return static_cast<bool> (xboolean::True == EnergyBE); }
        bool IsEnergyKE(void)
            {   return static_cast<bool> (xboolean::False == EnergyBE); }
        static bool IsInRangeE(float E1, float E2, float E)
            {   return  (E+EnergyTolerance >= E1) && (E-EnergyTolerance <= E2); } 
        bool IsXEnergyKnown(void)
        {   return static_cast<bool> (xboolean::True == XEnergyKnown); }
        void    SetEnergyBE(xboolean::xbool B)
        {   EnergyBE = B; }
        inline void SetMaxEnergy(float E)
        {   MaxEnergy = E;}
        inline void SetMinEnergy(float E)
        {   MinEnergy = E;}
        inline void    SetXEnergy(float XE)
            {   XEnergy = XE; SetXEnergyKnown( xboolean::True); }
        inline void    SetXEnergyKnown(xboolean::xbool B)
            {   XEnergyKnown = B;}
        float ToBE(float KE)
            {   return XEnergy - KE;}   
        float ToKE(float BE)
            {   return XEnergy - BE;}   
};//xpSpectrumObjectAgent


class xpSpectrumBase  : public xpSpectrumObjectAgent
{   protected:
        float   ChargingEnergy;     
        float   EnergySeparation;   
        wxList  PeakList;       
        xpSampleBase *sample;       
    public:
        xpSpectrumBase(void)
        {
            EnergySeparation = 12.0f; 
            ChargingEnergy = 0.0f;
            sample = NULL; 
        }
        xpSpectrumBase(const xpSpectrumBase& S)
        {
            sample = S.sample;
            ChargingEnergy = S.ChargingEnergy;
            EnergySeparation = S.EnergySeparation;
        }
//*------List!
        virtual
        ~xpSpectrumBase(void) {       };
        float GetChargingEnergy(void)
            {   return ChargingEnergy;}
        float GetEnergySeparation(void)
            {   return EnergySeparation;}
        wxList* GetPeaks(void)
            {   return &PeakList;}
        xpSampleBase* GetSample(void)
            {   return sample;}
        void SetChargingEnergy(float EC)
            {   ChargingEnergy = EC;}
        void SetEnergySeparation(float ES)
            {   EnergySeparation = ES;}
        void SetSample(xpSampleBase* S)
        {   sample = S;}
        void SetConcentrations(void);
};//xpSpectrumBase
/*
    Calibrate
    IsMonochromatic
 */

class xpSampleBase : public xpAgent
{   protected:
        xboolean::xbool ContainsCarbon;     
        xpSpectrumBase *ParentSpectrum;     
    public:
        xpSampleBase()
            : xpAgent()
        {   ParentSpectrum = NULL;
            ContainsCarbon = xboolean::Unknown; 
        }
        xpSampleBase(xpSpectrumBase* Parent)
            : xpAgent()
        {   ParentSpectrum = Parent;
            ParentSpectrum->SetSample(this);
            ContainsCarbon = xboolean::Unknown; 
        }
        xboolean::xbool GetContainsCarbon(void)
        {   return ContainsCarbon; }
        xpSpectrumBase* GetSpectrum()
        {   return ParentSpectrum;}
        void    SetContainsCarbon(xboolean::xbool B)
        {   ContainsCarbon = B; }
};//xpSampleBase


class xpComponentBase : public xpSpectrumObjectAgent
{   protected:
        xpSpectrumBase *ParentSpectrum; 
    public:
        xpComponentBase(void)
            : xpSpectrumObjectAgent()
        {   ParentSpectrum = NULL;
        }
        xpComponentBase(xpSpectrumBase* Parent)
            : xpSpectrumObjectAgent()
        {   ParentSpectrum = Parent;
            EnergyBE = ParentSpectrum->GetEnergyBE();       // Inherit parent's settings
            XEnergyKnown = ParentSpectrum->GetXEnergyKnown();
            XEnergy = ParentSpectrum->GetXEnergy();
        }
        xpComponentBase(const xpComponentBase& C)
        {   ParentSpectrum = C.ParentSpectrum;
            EnergyBE = C.EnergyBE;
            XEnergyKnown = C.XEnergyKnown;
            XEnergy = C.XEnergy;
        }
        xpSpectrumBase* GetSpectrum(void)
        {   return ParentSpectrum;}
};//xpComponentBase

/*
  xpElement
    AtomicNo
    Name
    Valence
  Compound
    Elements
    Name
  Specimen
    Kind(Homogen, layered,fractured,christalline)
    Conductivity(Metal,semicond,insulator)
    IsKindOf(Metal)
            (Polymer)
            IsEnvExp
*/
class xpSpectrumBase;

class xpPeakBase : public xpComponentBase 
{ protected:
        float Energy;               
        float PostPeakSlope;        
        float ShirleyTailHeight;    
        float AngleRatio;           
        float   meastime,           
                sensitivity,        
                concentration,      
                concentrationUncertainty,  
                peakcounts,         
                bgndcounts,         
                peakrate,           
                bgndrate,           
                relprec;            
        xboolean::xbool Carbon1sPeak;   
        xpPeakPanel *m_peakpanel;   
   public:
        xpPeakBase( xpSpectrumBase* Parent, float E = 0.0f)
            :xpComponentBase(Parent)
            {
                Energy = E;
                sensitivity = 1.0f;
                concentration = 0.0f;
                concentrationUncertainty = 0.0f;
                meastime = 1.0;           // Meas time, in secs
                peakcounts = 200.0;       // peak counts
                bgndcounts = 100.0;       // bgnd counts
                peakrate = GetRate(peakcounts); // peak count rate
                bgndrate = GetRate(bgndcounts); // bgnd count rate
                relprec = CalcRelPrec();        // relative precision of the measurement
                PostPeakSlope = 0.03f;          // Slope of the tail on the low kinetic enegy side of the peak
                ShirleyTailHeight = 0.05f;      // Tail height to the peak height
                AngleRatio = 0.6f;              // relative intensity seen at different angles
                Carbon1sPeak = xboolean::Unknown;
            }
        xpPeakBase(const xpPeakBase& C )
            {
                Energy = C.Energy;
                sensitivity = C.sensitivity;
                concentration = C.concentration;
                concentrationUncertainty = C.concentrationUncertainty;
                meastime = C.meastime;
                peakcounts = C.peakcounts;
                bgndcounts = C.bgndcounts;
                peakrate = C.peakrate;
                bgndrate = C.bgndrate;
                relprec = C.relprec;
                PostPeakSlope = C.PostPeakSlope;
                ShirleyTailHeight = C.ShirleyTailHeight;
                AngleRatio = C.AngleRatio;
                Carbon1sPeak = C.Carbon1sPeak;
            }
        xboolean::xbool GetCarbon1sPeak(void) const
            {   return Carbon1sPeak ; }
    // stuff dealing with count-related members
        float GetRate(const float counts) const
            {   return counts/meastime; }
        float GetMeasTime(void)
        {   return meastime;}
        float GetSensitivity(void)
        {   return sensitivity;}
        void SetSensitivity(const float S)
        {   sensitivity = S;}

        float GetConcentration(void)
        {   return concentration;}
        void SetConcentration(const float C)
        {   concentration = C;}
        float GetConcentrationUncertainty(void)
        {   return concentrationUncertainty;}
        void SetConcentrationUncertainty(const float C)
        {   concentrationUncertainty = C;}
                
        void SetMeasTime(const float t)
        {
            meastime = t;
            peakcounts = peakrate*meastime;
            bgndcounts = bgndrate*meastime;
            CalcRelPrec();
        }
        float GetPeakCounts(void)
        {   return peakcounts;}
        void SetPeakCounts(const float c)
        {
            peakcounts = c;
            peakrate = peakcounts/meastime;
            CalcRelPrec();
        }
        float GetBgndCounts(void)
        {   return bgndcounts;}
        void SetBgndCounts(const float c)
        {
            bgndcounts = c;
            bgndrate = bgndcounts/meastime;
            CalcRelPrec();
        }
        float GetPeakRate(void)
        {   return peakrate;}
        void SetPeakRate(const float r)
        {
            peakrate = r;
            peakcounts = peakrate * meastime;
            CalcRelPrec();
        }
        float GetBgndRate(void)
        {   return bgndrate;}
        void SetBgndRate(const float r)
        {
            bgndrate = r;
            bgndcounts = bgndrate * meastime;
            CalcRelPrec();
        }
        float GetRelPrec(void)
        {   return  relprec; }
        float CalcRelPrec(void)
        {   relprec = 100*sqrt(peakcounts+bgndcounts)/(peakcounts-bgndcounts);
            return relprec;
        }
        void SetRelPrec(const float r)
        {   relprec = r;
            CalcRelPrec();
        }

    float GetEstimatedPeakCounts( float rp )
    {
        return 100/rp*sqrt(GetPeakCounts()+GetBgndCounts()) + GetBgndCounts();
    }
    //
        float GetChargingEnergy(void) const
            {   return ParentSpectrum->GetChargingEnergy(); }
        float GetEnergy(bool WithCharging = false) 
        {   float E = Energy;
            if(WithCharging && !( xboolean::Unknown == GetEnergyBE()) )
            {   // return the charging-corrected energy
                if(GetEnergyBE() == ParentSpectrum->GetEnergyBE())
                    //  The energy types in the peak and in the parent spectrum are identical
                    E += GetChargingEnergy();
                else
                    // The energy types in the peak and in the parent spectrum are different
                    E -= GetChargingEnergy();
            }
            return E;
        }
        xpPeakPanel* GetPanel(void) const
        {   return m_peakpanel; }      
        float GetPostPeakSlope(void) const
            {   return PostPeakSlope;}
        float GetShirleyTailHeight(void) const
            {   return ShirleyTailHeight;}
        float GetAngleRatio(void) const
            {   return AngleRatio;}
        bool IsCarbon1sPeak(void)
            {   return static_cast<bool> (xboolean::True == Carbon1sPeak); }
        bool IsPeakInRangeBE(const float BELow, const float BEHigh)
        {   if( IsEnergyBE() )
                {// the energy data are given on BE scale
                    return xpSpectrumBase::IsInRangeE(BELow, BEHigh, GetEnergy(true));
                }
            else if((IsEnergyKE()) && (IsXEnergyKnown()))
                {// then we have to calculate the value from the kinetic energy
                    return xpSpectrumBase::IsInRangeE(BELow, BEHigh, ToBE( GetEnergy(true) ) );
                }
            else
                {   return false;}
        }
        bool IsPeakInRangeKE(const float KELow, const float KEHigh)
            {   if( IsEnergyKE())
                    {// the energy data are given on KE scale
                        return xpSpectrumBase::IsInRangeE(KELow, KEHigh, GetEnergy(true));
                    }
                else if((IsEnergyBE()) && (IsXEnergyKnown()))
                    {// then we have to calculate the value from the kinetic energy
                        return xpSpectrumBase::IsInRangeE(KELow, KEHigh, ToKE( GetEnergy(true) ) );
                    }
                else
                    {   return false;}
            }
        void    SetCarbon1sPeak(const xboolean::xbool B)
            {   Carbon1sPeak = B; }
        void SetEnergy(const float E, bool WithCharging = false)
            {   if(WithCharging) // set the charging-corrected energy
                    ;
                else // set energy without charging correction
                Energy = E;
            }
        void SetPanel(xpPeakPanel* PP) 
            {   m_peakpanel = PP; }
        void SetPostPeakSlope(const float PPS)
            {   PostPeakSlope = PPS;}
        void SetShirleyTailHeight(const float STH)
            {   ShirleyTailHeight = STH;}
        void SetAngleRatio(const float AR)
            {   AngleRatio = AR;}

};//xpPeakBase

#endif //xps4xps_h

---