XRXPS.H

Go to the documentation of this file.

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

#ifndef xrxps_h
#define xrxps_h

#include <wx/wxprec.h>

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

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

#include    "xps4xps.h"
#include    "utils.h"

extern float E4Background; 

class   xpRuleXPS : public xpRuleGeneric
{   protected:
    public:
        xpRuleXPS(  xpAgent *MyAgent=NULL)
        :xpRuleGeneric(MyAgent)
        {   }// of xpRuleXPS::xpRuleXPS
        xpRuleXPS(const xpRuleXPS &xr) 
        {   }
};//xpRuleXPS

class xrIsEnergyBE : public xpRuleXPS
{
    public:
        xrIsEnergyBE(   xpAgent *MyAgent=NULL);
        xpRuleGeneric   Fire(void);
};// of xrIsEnergyBE


class xrIsEnergyKE : public xpRuleXPS
{
    public:
        xrIsEnergyKE(   xpAgent *MyAgent=NULL);
        xpRuleGeneric   Fire(void);
};// of xrIsEnergyKE


class xrIsXEnergyKnown : public xpRuleXPS
{
    public:
        xrIsXEnergyKnown(   xpAgent *MyAgent=NULL)
        :xpRuleXPS(MyAgent)
        {   Name = _("Exciting energy known"); }
        xpRuleGeneric   Fire(void)
        {   xpSpectrumBase *xpS = (xpSpectrumBase *) Agent;
            if(xpS)
                value = xpS->GetXEnergyKnown();
            else
            {
                value = Unknown; HistoryString << _("No spectrum known");
                return *this;
            }
            if(xboolean::True == value)
                HistoryString << _("Excitation energy is given");
            else if (xboolean::False == value)
                HistoryString << _("Excitation energy is NOT given");
            else HistoryString << _("Excitation energy is unknown");
            return *this;
        }
};// of xrIsXEnergyKnown


class xrIsEnergyAvailBE : public xpRuleXPS
{
    public:
        xrIsEnergyAvailBE(  xpAgent *MyAgent=NULL)
        :xpRuleXPS(MyAgent)
        {   Name = _("Binding energy available");  }
        xpRuleGeneric   Fire(void)
        {
            return  xrIsEnergyBE(Agent).Fire()
                      OR
                      ( xrIsEnergyKE(Agent).Fire()
                        AND
                        xrIsXEnergyKnown(Agent).Fire()
                      );
        }
};// of xrIsEnergyAvailBE


class xrIsEnergyAvailKE : public xpRuleXPS
{
    public:
        xrIsEnergyAvailKE(  xpAgent *MyAgent=NULL)
        :xpRuleXPS(MyAgent)
        {   Name = _("Kinetic energy available");  }
        xpRuleGeneric   Fire(void)
        {   
            return xrIsEnergyKE(Agent).Fire()
                      OR
                      ( xrIsEnergyBE(Agent).Fire()
                        AND
                        xrIsXEnergyKnown(Agent).Fire()
                      );
        }
};// of xrIsEnergyAvailKE


class xrIsRegionMeasuredBE : public xpRuleXPS
{   protected:
        float   BELow,      
            BEHigh;     
    public:
        xrIsRegionMeasuredBE(   xpAgent *MyAgent, float Low, float High)
        :xpRuleXPS(MyAgent)
        {   Name << wxString::Format(_("BE region [%s,%s] is measured")
                    , GetFormatted(Low), GetFormatted(High)); 
            BELow = Low; BEHigh = High;
        }
        xpRuleGeneric   Fire(void)
        {   xpSpectrumBase *xpS = (xpSpectrumBase *) Agent;
            if(xpS )
            {   // Yes, we have a spectrum
                float MyLow, MyHigh, MyE = 0.0f;
                if (!( xboolean::Unknown == xpS->GetEnergyBE()) )
                    // return the charging-correction energy
                    MyE = xpS->GetChargingEnergy();
                if( xpS->IsEnergyBE())
                {// the energy data are given on BE scale
                    MyLow = xpS->GetMinEnergy()+MyE;
                    MyHigh = xpS->GetMaxEnergy()+MyE;
                }
                else if(( xpS->IsEnergyKE()) AND ( xpS->IsXEnergyKnown()))
                {// then we have to calculate the value from the kinetic energy
                    MyLow = xpS->ToBE(xpS->GetMaxEnergy()+MyE);
                    MyHigh = xpS->ToBE(xpS->GetMinEnergy()+MyE);
                }
                else
                {   value = Unknown; HistoryString << _("No energy info given"); return *this;}
                // Now we know that the energy type is known and MyLow and MyHigh contain 
                // the correct values, on binding scale
                value = (xboolean::xbool)
                        (xpSpectrumBase::IsInRangeE(MyLow,MyHigh, BELow)
                           &&
                         xpSpectrumBase::IsInRangeE(MyLow,MyHigh, BEHigh)
                        );
                if(xboolean::True == value)
                    HistoryString << wxString::Format(_("BE region [%s,%s] is within measured range [%s,%s] ")
                                    , GetFormatted(BELow), GetFormatted(BEHigh), GetFormatted(MyLow), GetFormatted(MyHigh));
                else if (xboolean::False == value)
                    HistoryString << wxString::Format(_("BE region [%s,%s] is NOT within measured range [%s,%s] ")
                                    , GetFormatted(BELow), GetFormatted(BEHigh), GetFormatted(MyLow), GetFormatted(MyHigh) );
                else HistoryString << _("Some error occurred");
                    return *this;
            }
            else 
            {   value = Unknown;  HistoryString << _("No spectrum known"); 
                return *this;
            }
        }// of Fire
};// of xrIsRegionMeasuredBE


class xrIsRegionMeasuredKE : public xpRuleXPS
{   protected:
        float   KELow,      
                KEHigh;     
    public:
        xrIsRegionMeasuredKE(   xpAgent *MyAgent, float Low, float High)
        :xpRuleXPS(MyAgent)
        {   Name << wxString::Format(_("KE region [%s,%s] is measured")
                        , GetFormatted(Low), GetFormatted(High));
             KELow = Low; KEHigh = High;
        }
        xpRuleGeneric   Fire(void)
        {   xpSpectrumBase *xpS = (xpSpectrumBase *) Agent;
            if(xpS )
            {   // Yes, we have a spectrum
                float MyLow, MyHigh, MyE = 0.0f;
                if (!( xboolean::Unknown == xpS->GetEnergyBE()) )
                    // return the charging-correction energy
                    MyE = xpS->GetChargingEnergy();
                if( xpS->IsEnergyKE())
                {// the energy data are given on KE scale
                    MyLow = xpS->GetMinEnergy()+MyE;
                    MyHigh = xpS->GetMaxEnergy()+MyE;
                }
                else if(( xpS->IsEnergyBE()) AND ( xpS->IsXEnergyKnown()))
                {// then we have to calculate the value from the bindinf energy
                    MyLow = xpS->ToKE(xpS->GetMaxEnergy()+MyE);
                    MyHigh = xpS->ToKE(xpS->GetMinEnergy()+MyE);
                }
                else
                {   value = Unknown; HistoryString << _("No energy info given"); return *this;}
                    // Now we know that the energy type is known and MyLow and MyHigh contain 
                    // the correct values, on kinetic scale
                value = (xboolean::xbool)
                        (
                            xpSpectrumBase::IsInRangeE(MyLow,MyHigh, KELow)
                                &&
                            xpSpectrumBase::IsInRangeE(MyLow,MyHigh, KEHigh)
                        );
                if(xboolean::True == value)
                    HistoryString << wxString::Format(_("KE region [%s,%s] is within measured range [%s,%s] ")
                                    , GetFormatted(KELow), GetFormatted(KEHigh), GetFormatted(MyLow), GetFormatted(MyHigh) );
                 else if (xboolean::False == value)
                     HistoryString << wxString::Format(_("KE region [%s,%s] is NOT within measured range [%s,%s] ")
                                    , GetFormatted(KELow), GetFormatted(KEHigh), GetFormatted(MyLow), GetFormatted(MyHigh) );
                 else HistoryString << _("Some error occurred");
                return *this;
            }
            else 
            {   value = Unknown;  HistoryString << _("No spectrum known"); 
                return *this;
            }
        }// of Fire
};// of xrIsRegionMeasuredKE


class xrIsPeakInRangeBE : public xpRuleXPS
{   protected:
        float   BELow,      
                BEHigh;     
    public:
        xrIsPeakInRangeBE(  xpAgent *MyAgent, float Low, float High)
        :xpRuleXPS(MyAgent)
        {
            Name << wxString::Format(_("Peak is in BE range [%s,%s] ")
                    , GetFormatted(Low), GetFormatted(High));
            BELow = Low; BEHigh = High;
        }
        xpRuleGeneric   Fire(void)
        {   xpPeakBase *xpP = (xpPeakBase *) Agent;
            if(xpP )
            {   // Yes, we have a peak
                float MyEnergy ;
                // Now calculate peak energy and put it on binding scale
                if( xpP->IsEnergyBE())
                {// the peak energy data is given on BE scale
                    MyEnergy = xpP->GetEnergy(true);
                }
                else if(( xpP->IsEnergyKE()) AND ( xpP->IsXEnergyKnown()))
                {// then we have to calculate the value from the kinetic energy
                    MyEnergy = xpP->ToBE(xpP->GetEnergy(true));
                }
                else
                {   value = Unknown; HistoryString << _("No peak energy info given"); return *this;}
                // Now calculate the peak energy limits, on BE scale
                xpSpectrumBase *xpS = xpP->GetSpectrum();
                //OK, let see if region is measured for peak + background
                xpRuleGeneric a = xrIsRegionMeasuredBE(xpS,BELow-E4Background,BEHigh+E4Background).Fire();
                if(!a.IsTrue())
                    {// The region is not measured, or the background region is not long enough
                        value = a.GetValue();
                        HistoryString = a.GetHistoryString();
                        return *this;
                    }
                // OK, the region is measured, with sufficiently long background
                value = (xboolean::xbool) (xpSpectrumBase::IsInRangeE(BELow, BEHigh, MyEnergy));
                if(xboolean::True == value)
                    HistoryString << wxString::Format(_("Peak energy %s is in BE range [%s,%s] ")
                                , GetFormatted(xpP->GetEnergy(true)), GetFormatted(BELow), GetFormatted(BEHigh));
                else if (xboolean::False == value)
                    HistoryString << wxString::Format(_("Peak energy %s is NOT in BE range [%s,%s] ")
                                , GetFormatted(xpP->GetEnergy(true)), GetFormatted(BELow), GetFormatted(BEHigh));
                else HistoryString << _("Some error occurred");
                return *this;
            }
            else 
            {   value = Unknown; return *this;}
        }// of Fire
};// of xrIsPeakInRangeBE


class xrIsPeakInRangeKE : public xpRuleXPS
{   protected:
        float   KELow,      
                KEHigh;     
    public:
        xrIsPeakInRangeKE(  xpAgent *MyAgent, float Low, float High)
        :xpRuleXPS(MyAgent)
        {   Name << wxString::Format(_("Peak is in KE range [%s,%s] ")
                    , GetFormatted(Low), GetFormatted(High));
            KELow = Low; KEHigh = High;
        }
        xpRuleGeneric   Fire(void)
        {   xpPeakBase *xpP = (xpPeakBase *) Agent;
            if(xpP )
            {   // Yes, we have a peak
                float MyEnergy ;
                // Now calculate peak energy and put it on kinetic scale
                if( xpP->IsEnergyKE())
                {// the peak energy data is given on KE scale
                    MyEnergy = xpP->GetEnergy(true);
                }
                else if(( xpP->IsEnergyBE()) AND ( xpP->IsXEnergyKnown()))
                {// then we have to calculate the value from the binding energy
                    MyEnergy = xpP->ToKE(xpP->GetEnergy(true));
                }
                else
                {   value = Unknown; HistoryString << _("No peak energy info given"); return *this;}
                // Now calculate the peak energy limits, on KE scale
                xpSpectrumBase *xpS = xpP->GetSpectrum();
                //OK, let see if region is measured for peak + background
                xpRuleGeneric a = xrIsRegionMeasuredKE(xpS,KELow-E4Background,KEHigh+E4Background).Fire();
                if(!a.IsTrue())
                {// The region is not measured, or the background region is not long enough
                    value = a.GetValue();
                    HistoryString = a.GetHistoryString();
                    return *this;
                }
                // OK, the region is measured, with sufficiently long background
                value = (xboolean::xbool) (xpSpectrumBase::IsInRangeE(KELow, KEHigh, MyEnergy));
                if(xboolean::True == value)
                    HistoryString << wxString::Format(_("Peak energy %s is in KE range [%s,%s] ")
                                    , GetFormatted(xpP->GetEnergy(true)), GetFormatted(KELow), GetFormatted(KEHigh));
                else if (xboolean::False == value)
                    HistoryString << wxString::Format(_("Peak energy %s is NOT in KE range [%s,%s] ")
                                    , GetFormatted(xpP->GetEnergy(true)), GetFormatted(KELow), GetFormatted(KEHigh));
                else HistoryString << _("Some error occurred");
                return *this;
            }
            else 
            {   value = Unknown; return *this;}
        }// of Fire
};// of xrIsPeakInRangeKE


class xrHasPeakInRangeBE : public xpRuleXPS
{   protected:
        float   BELow,      
                BEHigh;     
    public:
        xrHasPeakInRangeBE( xpAgent *MyAgent, float Low, float High);
/*        :xpRuleXPS(MyAgent);
        {   Name << wxString::Format(_("Has peak in BE range [%s,%s]")
                    , GetFormatted(Low) , GetFormatted(High));
            BELow = Low; BEHigh = High;
        }*/
        xpRuleGeneric   Fire(void);
/*        {   xpSpectrumBase *xpS = (xpSpectrumBase *) Agent;
            if(!xpS) 
            {
                value = Unknown; 
                HistoryString << _("No spectrum is present");
                return *this;
            }
            // Yes, we have a spectrum, check if BE available
            xpRuleGeneric a = xrIsEnergyAvailBE(xpS).Fire();
            if(!a.IsTrue())
            {
                value = a.value;
                HistoryString = a.GetHistoryString();
                return *this;
            }
            // Check if we have spectrum
            int NP = xpS->GetPeaks()->Number();
            if(!NP)
            {   
                value = False;
                HistoryString << _("No peaks found in the spectrum");
            }
            else
            {// we have at least one peak
                xboolean Found = xboolean::False;
                xpPeakBase *xpP = (xpPeakBase *) NULL; 
                for(int i = 0; (i < NP) AND !Found.IsTrue(); i++)
                {   // Check all peaks if their energy is within the BE range
                    xpP = (xpPeakBase *)xpS->GetPeaks()->Nth(i)->GetData();
                    if(xrIsPeakInRangeBE(xpP,BELow,BEHigh).Fire().IsTrue())
                    {   
                        Found = xboolean::True;
                        HistoryString << wxString::Format(_("Peak at BE %s found in the BE range [%s,%s] ")
                                    , GetFormatted(xpP->GetEnergy()), GetFormatted(BELow), GetFormatted(BEHigh));
                        break;
                    }
                }
                value = Found.GetValue();
                if(Found.IsFalse())
                {
                    HistoryString << wxString::Format(_("No peak found in BE range [%s,%s] ")
                                , GetFormatted(BELow), GetFormatted(BEHigh) );
                    value = False;
                }
            }
            return *this;
        }// of Fire*/
};// of xrHasPeakInRangeBE


class xrHasPeakInRangeKE : public xpRuleXPS
{   protected:
        float   KELow,      
                KEHigh;     
    public:
        xrHasPeakInRangeKE( xpAgent *MyAgent, float Low, float High);
        xpRuleGeneric   Fire(void);
};// of xrHasPeakInRangeKE

#endif //xrxps_h

---