aoflagger.h

Go to the documentation of this file.

 
#ifndef AOFLAGGER_INTERFACE_H
#define AOFLAGGER_INTERFACE_H
 
#include <cstring>
#include <string>
 
namespace aoflagger {
 
        enum TelescopeId {
                GENERIC_TELESCOPE,
                ARECIBO_TELESCOPE,
                BIGHORNS_TELESCOPE,
                JVLA_TELESCOPE,
                LOFAR_TELESCOPE,
                MWA_TELESCOPE,
                PARKES_TELESCOPE,
                WSRT_TELESCOPE,
                AARTFAAC_TELESCOPE
        };
 
        class StrategyFlags
        {
                public:
                        static const unsigned NONE;
                        
                        static const unsigned LARGE_BANDWIDTH;
                        
                        static const unsigned SMALL_BANDWIDTH;
                        
                        static const unsigned TRANSIENTS;
                        
                        static const unsigned ROBUST;
                        
                        static const unsigned FAST;
                        
                        static const unsigned INSENSITIVE;
                        
                        static const unsigned SENSITIVE;
                        
                        static const unsigned USE_ORIGINAL_FLAGS;
                        
                        //static const unsigned CLEAR_FLAGS;
                        
                        static const unsigned AUTO_CORRELATION;
                        
                        static const unsigned HIGH_TIME_RESOLUTION;
                        
                private:
                        StrategyFlags() = delete;
        };
 
        class ImageSet
        {
                public:
                        friend class AOFlagger;
                        
                        ImageSet();
                        
                        ImageSet(const ImageSet& sourceImageSet);
                        
                        ImageSet(ImageSet&& sourceImageSet);
                        
                        ~ImageSet();
                        
                        ImageSet& operator=(const ImageSet& sourceImageSet);
                        
                        ImageSet& operator=(ImageSet&& sourceImageSet);
                        
                        float* ImageBuffer(size_t imageIndex);
                        
                        const float* ImageBuffer(size_t imageIndex) const;
                        
                        size_t Width() const;
                        
                        size_t Height() const;
                        
                        size_t ImageCount() const;
                        
                        size_t HorizontalStride() const;
                        
                        void Set(float newValue);
 
                        void ResizeWithoutReallocation(size_t newWidth) const;
                        
                private:
                        ImageSet(size_t width, size_t height, size_t count);
                        
                        ImageSet(size_t width, size_t height, size_t count, float initialValue);
                        
                        ImageSet(size_t width, size_t height, size_t count, size_t widthCapacity);
                        
                        ImageSet(size_t width, size_t height, size_t count, float initialValue, size_t widthCapacity);
                        
                        static void assertValidCount(size_t count);
                        
                        class ImageSetData* _data;
        };
 
        class FlagMask
        {
                public:
                        friend class AOFlagger;
                        
                        FlagMask();
                        
                        FlagMask(const FlagMask& sourceMask);
                        
                        FlagMask(FlagMask&& sourceMask);
                        
                        FlagMask& operator=(const FlagMask& source);
                        
                        FlagMask& operator=(FlagMask&& source);
                        
                        ~FlagMask();
                        
                        size_t Width() const;
                        
                        size_t Height() const;
                        
                        size_t HorizontalStride() const;
                        
                        bool* Buffer();
                        
                        const bool* Buffer() const;
                        
                private:
                        FlagMask(size_t width, size_t height);
                        FlagMask(size_t width, size_t height, bool initialValue);
                        
                        class FlagMaskData* _data;
        };
 
        class Strategy
        {
                public:
                        friend class AOFlagger;
                        
                        Strategy(const Strategy& sourceStrategy);
                        
                        Strategy(Strategy&& sourceStrategy);
                        
                        ~Strategy();
                        
                        Strategy& operator=(const Strategy& sourceStrategy);
                        
                        Strategy& operator=(Strategy&& sourceStrategy);
                        
                private:
                        Strategy(enum TelescopeId telescopeId, unsigned strategyFlags, double frequency=0.0, double timeRes=0.0, double frequencyRes=0.0);
                        
                        explicit Strategy(const std::string& filename);
                        
                        class StrategyData* _data;
        };
 
        class QualityStatistics
        {
                public:
                        friend class AOFlagger;
                        
                        QualityStatistics();
                        
                        QualityStatistics(const QualityStatistics& sourceQS);
                        
                        QualityStatistics(QualityStatistics&& sourceQS);
                        
                        ~QualityStatistics();
                        
                        QualityStatistics& operator=(const QualityStatistics& sourceQS);
                        
                        QualityStatistics& operator=(QualityStatistics&& sourceQS);
                        
                        QualityStatistics& operator+=(const QualityStatistics& rhs);
                        
                private:
                        QualityStatistics(const double* scanTimes, size_t nScans, const double* channelFrequencies, size_t nChannels, size_t nPolarizations, bool computeHistograms);
                        
                        class QualityStatisticsData* _data;
        };
        
        class StatusListener
        {
                public:
                        virtual ~StatusListener() { }
                        virtual void OnStartTask(size_t taskNo, size_t taskCount, const std::string& description)
                        { }
                        virtual void OnEndTask()
                        { }
                        virtual void OnProgress(size_t progress, size_t maxProgress)
                        { }
                        virtual void OnException(std::exception& thrownException) = 0;
        };
        
        class AOFlagger
        {
                public:
                        AOFlagger() : _statusListener(nullptr) { }
                        
                        ~AOFlagger() { }
                        
                        ImageSet MakeImageSet(size_t width, size_t height, size_t count)
                        {
                                return ImageSet(width, height, count);
                        }
                        
                        ImageSet MakeImageSet(size_t width, size_t height, size_t count, size_t widthCapacity)
                        {
                                return ImageSet(width, height, count, widthCapacity);
                        }
                        
                        ImageSet MakeImageSet(size_t width, size_t height, size_t count, float initialValue)
                        {
                                return ImageSet(width, height, count, initialValue);
                        }
                        
                        ImageSet MakeImageSet(size_t width, size_t height, size_t count, float initialValue, size_t widthCapacity)
                        {
                                return ImageSet(width, height, count, initialValue, widthCapacity);
                        }
                        
                        FlagMask MakeFlagMask(size_t width, size_t height)
                        {
                                return FlagMask(width, height);
                        }
                        
                        FlagMask MakeFlagMask(size_t width, size_t height, bool initialValue)
                        {
                                return FlagMask(width, height, initialValue);
                        }
                        
                        Strategy MakeStrategy(enum TelescopeId telescopeId=GENERIC_TELESCOPE, unsigned strategyFlags=StrategyFlags::NONE, double frequency=0.0, double timeRes=0.0, double frequencyRes=0.0)
                        {
                                return Strategy(telescopeId, strategyFlags, frequency, timeRes, frequencyRes);
                        }
                        
                        Strategy LoadStrategy(const std::string& filename)
                        {
                                return Strategy(filename);
                        }
                        
                        FlagMask Run(Strategy& strategy, const ImageSet& input);
                        
                        FlagMask Run(Strategy& strategy, const ImageSet& input, const FlagMask& existingFlags);
                        
                        QualityStatistics MakeQualityStatistics(const double* scanTimes, size_t nScans, const double* channelFrequencies, size_t nChannels, size_t nPolarizations);
                        
                        QualityStatistics MakeQualityStatistics(const double* scanTimes, size_t nScans, const double* channelFrequencies, size_t nChannels, size_t nPolarizations, bool computeHistograms);
                        
                        void CollectStatistics(QualityStatistics& destination, const ImageSet& imageSet, const FlagMask& rfiFlags, const FlagMask& correlatorFlags, size_t antenna1, size_t antenna2);
                        
                        void WriteStatistics(const QualityStatistics& statistics, const std::string& measurementSetPath);
                        
                        static std::string GetVersionString();
                        
                        static void GetVersion(short& major, short& minor, short& subMinor);
                        
                        static std::string GetVersionDate();
                        
                        void SetStatusListener(StatusListener* statusListener)
                        {
                                _statusListener = statusListener;
                        }
                        
                private:
                        AOFlagger(const AOFlagger&) = delete;
                        
                        void operator=(const AOFlagger&) = delete;
                        
                        FlagMask run(Strategy& strategy, const ImageSet& input, const FlagMask* existingFlags);
                        
                        StatusListener* _statusListener;
        };
 
}
 
#endif