collapse.h

Go to the documentation of this file.

#pragma once
 
#include <map>
#include <sstream>
 
#include "tools/math.h"
#include "element.h"
 
//https://github.com/stevenlovegrove/Pangolin/issues/352
#ifdef max
#undef max
#endif
 
#ifdef min
#undef min
#endif
 
namespace dnf_composer::element
{
    enum class CompressionType : int
    {
        SUM,     
        AVERAGE, 
        MAXIMUM, 
        MINIMUM  
    };
 
    inline const std::map<CompressionType, std::string> CompressionTypeToString = {
        {CompressionType::SUM, "sum"},
        {CompressionType::AVERAGE, "average"},
        {CompressionType::MAXIMUM, "maximum"},
        {CompressionType::MINIMUM, "minimum"}
    };
 
    enum class ProjectionAxis : int
    {
        X, 
        Y  
    };
 
    inline const std::map<ProjectionAxis, std::string> ProjectionAxisToString = {
        {ProjectionAxis::X, "x"},
        {ProjectionAxis::Y, "y"}
    };
 
    inline tools::math::ReduceOp toReduceOp(const CompressionType type)
    {
        switch (type)
        {
        case CompressionType::SUM:     return tools::math::ReduceOp::SUM;
        case CompressionType::AVERAGE: return tools::math::ReduceOp::AVERAGE;
        case CompressionType::MAXIMUM: return tools::math::ReduceOp::MAXIMUM;
        case CompressionType::MINIMUM: return tools::math::ReduceOp::MINIMUM;
        }
        return tools::math::ReduceOp::SUM;
    }
 
    struct CollapseParameters final : ElementSpecificParameters
    {
        CompressionType compression;       
        ProjectionAxis keepAxis;           
        ElementDimensions inputDimensions; 
 
        explicit CollapseParameters(const CompressionType compression = CompressionType::SUM,
            const ProjectionAxis keepAxis = ProjectionAxis::X,
            const ElementDimensions& inputDimensions = ElementDimensions{ 100, 100, 1.0, 1.0 })
            : compression(compression), keepAxis(keepAxis), inputDimensions(inputDimensions)
        {}
 
        bool operator==(const CollapseParameters& other) const
        {
            return compression == other.compression &&
                keepAxis == other.keepAxis &&
                inputDimensions == other.inputDimensions;
        }
 
        [[nodiscard]] std::string toString() const override
        {
            std::ostringstream result;
            result << "Parameters: ["
                << "Compression: " << CompressionTypeToString.at(compression) << ", "
                << "Keep axis: " << ProjectionAxisToString.at(keepAxis) << ", "
                << "Input field dimensions: " << inputDimensions.toString()
                << "]";
            return result.str();
        }
    };
 
    class Collapse final : public Element
    {
    private:
        CollapseParameters parameters;
        std::vector<double> scratch; 
    public:
        Collapse(const ElementCommonParameters& elementCommonParameters,
            const CollapseParameters& parameters);
 
        void init() override;
        void step(double t, double deltaT) override;
        void addInput(const std::shared_ptr<Element>& inputElement,
            const std::string& inputComponent = "output") override;
        std::string toString() const override;
        std::shared_ptr<Element> clone() const override;
 
        void changeInputDimensions(const ElementDimensions& newInputDimensions);
 
        void setParameters(const CollapseParameters& parameters);
        [[nodiscard]] CollapseParameters getParameters() const;
    };
}