DETECUSE.H

gehe zur Dokumentation dieser Datei

/*
$Header: /vol/baal-vol3/projekt98/quellen/XCTL_32/INCLUDE/DETECUSE/DETECUSE.H,v 1.8 2004/05/19 14:54:42 reinecke Exp $

Projekt   : XCTL
Subsystem : Detektoren
Autor     : Jan Picard <picard@informatik.hu-berlin.de> 2001-2002
          Institut fuer Informatik,
          Humboldt-Universitaet Berlin
Inhalt    : Deklaration des Interface des Detektoren-Subsystems
*/

#ifndef __DETECUSE_H
#define __DETECUSE_H

#if defined ( Build_Counters )
#define _COUNTERCLASS __declspec(dllexport)
#elif defined( Use_Counters )
#define _COUNTERCLASS __declspec(dllimport)
#else
#define _COUNTERCLASS
#endif

#include "utils\u_utils.h"
#include "detecuse\range.h"
#include "motrstrg\motrstrg.h"
#include "difrkmty\d_extern.h"

//--||--\\--||--//--||--\\--||--//--||--\\--||--//--||--\\--||--//--||--\\--||--

enum EDetectorType
{
        CounterDetector= 1, PsdDetector, GenericDetector, CCDDetector
};

enum EHowReadOutPsd
{
        FinalRead= 1, FirstRead, AccumulationRead, IntermediateRead
};

enum EPsdDataType
{
        PsdEnergyData= 3000, PsdPositionData, PsdRestoreLast= 99, PsdUnknown= 0
};

//vormals in evrythng.h
#define  R_MeasOk          206

class _COUNTERCLASS TExposureSettings
{
public:
        TExposureSettings( float exposureTime= 0, DWORD exposureCounts= 0);

        float GetExposureTime() const
        {
                return fExposureTime;
        };
        DWORD GetExposureCounts() const
        {
                return dwExposureCounts;
        };

        void SetExposureTime(float exposureTime);
        void SetExposureCounts( DWORD exposureCounts );

#pragma warning( push )
#pragma warning( disable : 4251 )
        TRange<DWORD> CountBounds;
        TRange<float> TimeBounds;
#pragma warning( pop )

private:
        float fExposureTime;        // Belichtungszeit
        DWORD dwExposureCounts;     // Anzahl der zulässigen Photonen
};

// Struktur, die einen Schnappschuss der aktuellen Einstellungen eines
// Detektors speichern kann
struct _COUNTERCLASS TDSettings
{
        TExposureSettings exposure;
        int nAddedChannels;
};

// forward declaration
class TDetector;

//###########################################################################

class _COUNTERCLASS TDetectorManager
{
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Konstruktoren und Destruktor
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public:

        virtual  ~TDetectorManager();

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Methoden, die kontrollierten Zugriff auf Attribute bieten
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public:

        static TDetectorManager& DetectorManager();

        TDetector* GetDetector( void ) const;

        TDetector* GetDetector( int n, int nFilterDimension= -1 ) const;

        BOOL SetDetector( int n, int nFilterDimension= -1 );

        BOOL SetDetector( const TDetector* );

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Allgemeine Hifsmethoden
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public:

        void FillDetectorComboBox( HWND comboBox, int nFilterDimension= -1 ) const;

        BOOL DimAvailable(int dimension) const;

        int GetIdByDescription( LPCSTR detectorname ) const;

        BOOL IsValidId(int n) const;

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // private Konstruktoren
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
private:

        TDetectorManager();

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Verbotene Operationen
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
private:

        TDetectorManager(const TDetectorManager&);
        TDetectorManager& operator=(const TDetectorManager&);

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        //   private-Methoden
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
private:

        void CreateDetector(const char* type, int id);

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        //   private-Attribute
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
private:

        TDetector* ActiveDetector;
};

//###########################################################################

class _COUNTERCLASS TDetector
{

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Konstruktoren und Destruktor
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public:

        TDetector(int id);
        virtual ~TDetector( void );

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Methoden, die kontrollierten Zugriff auf Attribute bieten
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public:

        int GetId( void ) const
        {
                return nId;
        };

        BOOL IsActive( void ) const
        {
                return bActive;
        };

        float GetSigma( void ) const
        {
                return fSigma;
        };

        BOOL SetExposureSettings (const TExposureSettings& newExposureSettings);

        TExposureSettings& GetExposureSettings()
        {
                return exposure;
        };

        const char* const GetCharacteristic() const
        {
                return szCharacteristic;
        };

        BOOL IsDataValid() const
        {
                return bDataValid;
        };

        double GetRealTime() const
        {
                return dRealTime;
        };

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Interface-Methoden fuer alle Detektoren
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public:

        virtual BOOL Initialize( void );

        virtual int MeasureStart( void )= 0;

        virtual int MeasureStop( void )= 0;

        virtual int PollDetector( void ) { return R_Failure; }; // GR

        virtual int GetIntegral( float& )= 0; // ehemalig GetData

        virtual BOOL PushSettings( void );

        virtual BOOL PopSettings( void );

        BOOL SetParameters( void );

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // GUI-Methoden
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public:

        HWND GetDisplayWnd( void ) const
        {
                return hDisplayWnd;
        };

        HWND GetControlWnd( void ) const
        {
                return hControlWnd;
        };

        void SetDisplayWnd( HWND hwnd )
        {
                hDisplayWnd= hwnd;
        };

        void SetControlWnd( HWND hwnd )
        {
                hControlWnd= hwnd;
        };

        // Rückgabewert gibt an, ob der Dialog jetzt angezeigt wird
        // FALSE -> modeless Dialog wurde versteckt oder es existiert kein Dialog
        virtual BOOL RunSpecificParametersDlg( void )
        {
                return FALSE;
        };

        virtual BOOL HasSpecificParametersDlg( void ) const
        {
                return FALSE;
        };

        void UpdateViews(BOOL bDisplayOnly= FALSE) const;

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Typ-Identifikation
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public:

        virtual EDetectorType GetDetectorType() const= 0;

        virtual int GetDimension() const= 0;

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Allgemeine Hifsmethoden fuer alle Detektoren
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
protected:

        static double MillisecondsToSeconds( DWORD milliseconds);

        static float CalculateSigma(float intensity, float factor= 1.0);

        DWORD GetPrivateProfileString(
                LPCSTR lpKeyName, LPCSTR lpDefault, LPSTR lpReturnedString ) const;

        DWORD WritePrivateProfileString( LPCSTR lpKeyName, LPCSTR lpString) const;


        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Hook-Methoden, die jeder Detektor spezifisch definieren kann
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
protected:

        virtual BOOL _SetParameters(void)
        {
                return TRUE;
        };

        virtual void LoadDetectorSettings();

        virtual void SaveDetectorSettings() const;

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // protected-Attribute
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
protected:

        double dRealTime;

        BOOL bActive;

        HWND hWndFrame;

        BOOL bDebug;

        float fIntensity;

        float fSigma;

        BOOL bDataValid;

        UINT uAskTime;

        DWORD dwStartTime;

        TDSettings Settings;

        char szCharacteristic[ MaxString ];

        TExposureSettings exposure;

        TDetector* EventDetector;

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Verbotene Operationen
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
private:

        TDetector(const TDetector&);

        TDetector& operator=(const TDetector&);

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        //   private-Attribute
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
private:

        int nId;

        HWND hDisplayWnd;

        HWND hControlWnd;
};

class _COUNTERCLASS TZeroDimDetector : public TDetector
{

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Konstruktoren und Destruktor
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public:

        TZeroDimDetector(int id);
        virtual  ~TZeroDimDetector();

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Methoden, die kontrollierten Zugriff auf Attribute bieten
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public:

        void SetSound(BOOL);

        BOOL GetSound(void) const
        {
                return bSound;
        };

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Interface-Methoden fuer alle Detektoren
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public:

        int MeasureStart( void );
        int MeasureStop( void );
        virtual int GetIntegral( float& ); // ehemalig GetData

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // *Event*-Mechanismus, nur vom Continuous-Scan verwandt
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public:

        static CALLBACK EventHandler( UINT, UINT, DWORD, DWORD, DWORD );

        virtual BOOL InitializeEvent( HWND, int );

        virtual BOOL GetEventIntensity( float& );

        void SetEventHost(HWND);

        void KillEvent( void );

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Typ-Identifikation
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public:

        EDetectorType GetDetectorType() const
        {
                return CounterDetector;
        };

        int GetDimension() const
        {
                return 0;
        };

        BOOL Initialize( void );
        virtual int PollDetector( void )= 0;

private:
        void LoadDetectorSettings();
        void SaveDetectorSettings() const;

        BOOL bSound;
};

// forward declaration
class TCurve;

class _COUNTERCLASS TOneDimDetector : public TDetector
{

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Konstruktoren und Destruktor
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public:

        TOneDimDetector(int id);
        virtual  ~TOneDimDetector( void );

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Methoden, die kontrollierten Zugriff auf Attribute bieten
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public:

        virtual BOOL SetEnergyRange( UINT, UINT )
        {
                return TRUE;
        };

        virtual void GetEnergyRange( UINT& low, UINT& high ) const
        {
                high= 1;
                low= 0;
        };

        void SetAddedChannels( int ach );

        int GetAddedChannels( void ) const
        {
                return nAddedChannels;
        };

        void SetChannelRange(int first, int last);

        int GetFirstChannel() const
        {
                return nFirstChannel;
        };

        int GetLastChannel() const
        {
                return nLastChannel;
        };

        BOOL GetHVControl() const
        {
                return bHVControl;
        };

        void SetHVControl(BOOL param)
        {
                bHVControl= param;
        };

        BOOL GetReadLeftFirst() const
        {
                return bReadLeftFirst;
        };

        void SetReadLeftFirst(BOOL param)
        {
                bReadLeftFirst= param;
        };

        //JP?
        void SetAngleRange( float );

        void SetSignalGrowUp( BOOL gup )
        {
                bSignalGrowUp= gup;
        };

        void SetAngleStep( float stp )
        {
                fAngleStep= stp;
        };
        float GetAngleStep( void ) const
        {
                return fAngleStep;
        };

        BOOL IsSoftOverflow( void ) const
        {
                return bSoftOverflow;
        };

        BOOL IsHardOverflow( void ) const
        {
                return bHardOverflow;
        };

        float GetWidth( EUnitType ) const;
        float GetWidth() const
        {
                return GetWidth(eUnit);
        };

        float GetAngleRange(EUnitType) const;
        float GetAngleRange() const
        {
                return GetAngleRange(eUnit);
        };

        void SetDataType( EPsdDataType typeParam )
        {
                eDataType= typeParam;
        };

        virtual int FillInCurve( TCurve& ); // ehemalig GetData

        virtual int GetIntegral( float& ); // ehemalig GetData

        int MeasureStart( void );
        int MeasureStop( void );
        int PollDetector( void );
        BOOL Initialize( void );
        BOOL PushSettings( void );
        BOOL PopSettings( void );

        BOOL RunSpecificParametersDlg( void );
        BOOL HasSpecificParametersDlg( void ) const
        {
                return TRUE;
        };

        UINT GetMaximumChannel( void ) const;

        float GetMaximumIntensity( void ) const
        {
                return (float)( dwMaxCounts / dRealTime );
        };

        virtual int PsdInit( void )
        {
                return R_OK;
        };

        virtual int GetBufferSize( void ) const
        {
                return GetChannelNumber();
        };

        virtual int GetChannelNumber( void ) const
        {
                return nLastChannel - nFirstChannel + 1;
        };

        // über welchen Antrieb wird Detektor bewegt (für Kanaloffset bei Manueller Justage)
        EAxisType GetAxis() const
        {
                return m_Axis;
        };

        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Typ-Identifikation
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public:

        EDetectorType GetDetectorType() const
        {
                return PsdDetector;
        };

        int GetDimension() const
        {
                return 1;
        };

protected:

        void CheckMaxChannel(UINT channel, DWORD counts);

        EUnitType eUnit;

        //JP?
        HGLOBAL hCountBuf;

        //JP?
        int nCountBufItems;

        DWORD dwMaxCounts;

        DWORD dwIntegratedCounts;

        UINT uMaximumChannel;

        BOOL bHardOverflow;

        BOOL bReadLeftFirst;

        BOOL bSignalGrowUp;

        //JP?
        EPsdDataType eDataType;

        BOOL bFirstReadOut;

        //JP? Vielleicht als Parameter uebergeben?
        DWORD dwElapsedTime;

private:

        void LoadDetectorSettings();
        void SaveDetectorSettings() const;
        float CalculateValueInSeconds(EUnitType eUnitTypeParam, float fValParam) const;

        //JP?
        float fAngleStep;

        int nAddedChannels;

        virtual int PsdStart( void )
        {
                return R_OK;
        };

        virtual int PsdStop( void )
        {
                return R_OK;
        };

        virtual int PsdReadOut( EHowReadOutPsd )= 0;

        //JP?
        virtual int PsdRead( int, LPWORD )
        {
                return R_OK;
        };

        BOOL bSoftOverflow;

        float OverflowIntensity;

        int nFirstChannel;

        int nLastChannel;

        int nMaxChannel;

        BOOL bHVControl;

        EAxisType m_Axis;
};

class _COUNTERCLASS TDetectorGUI
{
public:
        static void RunCommonDevParamDialog(HWND);

        static void RunPsdCalibrateDialog(TCurve &, HWND);
};

#ifdef __cplusplus
extern "C"
{
#endif
        LPCSTR __declspec(dllexport) WINAPI dlGetVersion( void );
        HINSTANCE __declspec(dllexport) WINAPI dlGetInstance( void );
#ifdef __cplusplus
}

#endif

#endif // __DETECUSE_H

---