StoppingCondition.h

Go to the documentation of this file.

#ifndef __STOPPING_CONDITION_H
#define __STOPPING_CONDITION_H

#include "../Core/SharedLibraryExportMacros.h"
#include "../Core/Common.h"

#include <cassert>

namespace Evolve {

    enum StoppingConditionType {
        NO_STOP,
        
        SYNCHRONIZED,
        
        BREAK_LOCK,
        
        PLANET_DEATH,
        
        WIND_SATURATION,

        LARGE_EXPANSION_ERROR,

        SMALL_EXPANSION_ERROR,
        
        EXTERNAL
    }; //End StoppingConditionType enumeration.

    LIB_LOCAL std::ostream &operator<<(std::ostream &os,
            const StoppingConditionType &stop_cond_type);

    class LIB_LOCAL StoppingCondition {
    private:
        short __expected_crossing_deriv_sign;
    public:
        StoppingCondition(
            short expected_crossing_deriv_sign = 0
        )
            : __expected_crossing_deriv_sign(expected_crossing_deriv_sign)
        {}

        virtual std::valarray<double> operator()(
            Core::EvolModeType evol_mode,

            const std::valarray<double> &orbit, 

            const std::valarray<double> &derivatives,

            std::valarray<double> &stop_deriv
        ) const = 0;

        virtual size_t num_subconditions() const {return 1;}

        virtual StoppingConditionType type(unsigned index=0) const=0;

        virtual void reached(
            short deriv_sign,

            unsigned 
#ifndef NDEBUG
            index
#endif
            =0)
        {
            assert(index == 0);
            assert(__expected_crossing_deriv_sign == deriv_sign);

            __expected_crossing_deriv_sign = -deriv_sign;
        }

        virtual short expected_crossing_deriv_sign(
            unsigned 
#ifndef NDEBUG
            index
#endif
            =0) const
        {
            assert(index == 0);

            return __expected_crossing_deriv_sign;
        }

        virtual std::string describe(int index = -1) const = 0;

        virtual ~StoppingCondition() {}
    };//End StoppingCondition class.

    class LIB_LOCAL NoStopCondition : public StoppingCondition {
    public:
        std::valarray<double> operator()(
                Core::EvolModeType, const std::valarray<double> &, 
                const std::valarray<double> &, 
                std::valarray<double> &stop_deriv) const
        {stop_deriv.resize(1, Core::NaN); return std::valarray<double>(1, 1);}

        StoppingConditionType type(unsigned =0) const {return NO_STOP;}

        void reached(short, unsigned=0)
        {assert(false);}
    }; //End NoStopCondition class.

    class LIB_LOCAL ExternalStoppingCondition : public StoppingCondition {
    public:
        StoppingConditionType type(unsigned =0) const {return EXTERNAL;}
    };

}//End Evolve namespace.

#endif