GAS_Limit.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        GAS_Limit.h ( GAS Library, C++)
 *
 * COMMENTS:
 */

#ifndef __GAS_Limit__
#define __GAS_Limit__

#include "GAS_API.h"

#include <UT/UT_ThreadedAlgorithm.h>
#include <UT/UT_VoxelArray.h>
#include <GU/GU_Detail.h>

#include <SIM/SIM_RawField.h>

#include "GAS_SubSolver.h"
#include "GAS_Utils.h"

class GU_Detail;

class GAS_API GAS_Limit : public GAS_SubSolver
{
public:
    bool                 shouldMultiThread(const UT_VoxelArrayF *field) const 
                         { return field->numTiles() > 1; }

    GET_DATA_FUNC_S(GAS_NAME_STENCIL, StencilName);
    GET_DATA_FUNC_I("minchoice", MinChoice);
    GET_DATA_FUNC_I("maxchoice", MaxChoice);
    GET_DATA_FUNC_I("revertchoice", RevertChoice);
    GET_DATA_FUNC_V3("minvalue", MinValue);
    GET_DATA_FUNC_V3("maxvalue", MaxValue);
    GET_DATA_FUNC_V3("revertvalue", RevertValue);
    GET_DATA_FUNC_F("blendwidth", Blendwidth);

    struct      gas_limitsrc
    {
        const SIM_RawField      *field;
        float                    val;
        bool                     usefield;
    };

protected:
    explicit             GAS_Limit(const SIM_DataFactory *factory);
                        ~GAS_Limit() override;

    /// Limits scalar fields by moving along curvature or performing
    /// relaxation steps.
    bool                 solveGasSubclass(SIM_Engine &engine,
                                SIM_Object *obj,
                                SIM_Time time,
                                SIM_Time timestep) override;

    THREADED_METHOD6_CONST(GAS_Limit, shouldMultiThread(dstfield->field()),
                    limit,
                    SIM_RawField *, dstfield,
            const SIM_RawField *, stencil,
                    const gas_limitsrc &, minsrc,
                    const gas_limitsrc &, maxsrc,
                    const gas_limitsrc &, revertsrc,
                    float, blendwidth);
    void         limitPartial(SIM_RawField *dstfield,
                const SIM_RawField *stencil,
                            const gas_limitsrc &minsrc,
                            const gas_limitsrc &maxsrc,
                            const gas_limitsrc &revertsrc,
                            float blendwidth,
                            const UT_JobInfo &jobinfo) const;

    /// Does the actual work for limitPartial(), taking into account which parts
    /// of the limiting operation are applicable.
    template<bool HAS_MIN, bool HAS_MAX, bool HAS_REVERT>
    void limitPartialHelper(SIM_RawField *dstfield,
                            const SIM_RawField *stencil,
                            const gas_limitsrc &minsrc,
                            const gas_limitsrc &maxsrc,
                            const gas_limitsrc &revertsrc,
                            float blendwidth,
                            const UT_JobInfo &jobinfo) const;

    gas_limitsrc buildLimitSrc(SIM_Object *obj, int i, int j,
                        int choice,
                        const char *parmname,
                        UT_Vector3 val);
private:
    static const SIM_DopDescription     *getDopDescription();

    DECLARE_STANDARD_GETCASTTOTYPE();
    DECLARE_DATAFACTORY(GAS_Limit,
                        GAS_SubSolver,
                        "Gas Limit",
                        getDopDescription());
};

/// This class works as a functor to clamp/revert values.
template<bool HAS_MIN, bool HAS_MAX, bool HAS_REVERT>
class GAS_RevertOperation
{
public:
    /// Blend widths below this amount get clamped to 0.
    static constexpr float MINBLEND = 1e-3;

    GAS_RevertOperation(bool useMinField, float minValue, bool useMaxField,
                        float maxValue, bool useRevertField, float revertValue,
                        float blendwidth)
    {
        myUseMinField = useMinField;
        myMin = minValue;
        myUseMaxField = useMaxField;
        myMax = maxValue;
        myUseRevertField = useRevertField;
        myRevert = revertValue;

        myBlendwidth = blendwidth;
    }

    /// Returns the limited/reverted value. v is the current voxel value, mv is
    /// the voxel value of the minimum field, Mv is the voxel value of the maximum
    /// field, rv is the voxel value of the revert field.
    /// Depending on the template instantiations and parameters passed to the
    /// constructor, some of these operations may be skipped or their voxel values
    /// replaced by constant bounds.
    inline float operator()(float v, float mv, float Mv, float rv) const
    {
        bool clamped = clampBelow(v, mv) || clampAbove(v, Mv);
        if(HAS_REVERT && clamped)
            v = myUseRevertField ? rv : myRevert;
        if(!clamped && myBlendwidth >= MINBLEND)
            v = limitBlend(v, mv, Mv, rv);

        return v;
    }

private:
    bool            myUseMinField, myUseMaxField, myUseRevertField;
    float           myMin,         myMax,         myRevert;
    float           myBlendwidth;

private:
    /// Sets mv to the constant floor value if the field is not to be used.
    /// Clamps v0 if it is less than mv. Returns true if clamping was performed.
    inline bool clampBelow(float& v0, float& mv) const
    {
        if(HAS_MIN)
        {
            if(!myUseMinField)
                mv = myMin;
            if(v0 < mv)
            {
                v0 = mv;
                return true;
            }
        }
        return false;
    }

    /// Sets Mv to the constant ceiling value if the field is not to be used.
    /// Clamps v0 if it is greater than Mv. Returns true if clamping was performed.
    inline bool clampAbove(float& v0, float& Mv) const
    {
        if(HAS_MAX)
        {
            if(!myUseMaxField)
                Mv = myMax;
            if(v0 > Mv)
            {
                v0 = Mv;
                return true;
            }
        }
        return false;
    }

    /// Blends v with the appropriate clamping value.
    inline float limitBlend(float v, float mv, float Mv, float rv) const
    {
        float d;
        // If there is no revert value, it is set to the closest clamping value.
        if(HAS_MIN && HAS_MAX)
        {
            // If there is minimum and maximum, blendwidth has to be adjusted using the
            // interval length.
            float bw = myBlendwidth * (Mv - mv);
            d = SYSsmooth(mv, mv + bw, v) * (1 - SYSsmooth(Mv - bw, Mv, v));
            if(!HAS_REVERT)
                rv = (v - mv < Mv - v) ? mv : Mv;
        }
        else if(HAS_MIN)
        {
            d = SYSsmooth(mv, mv + myBlendwidth, v);
            if(!HAS_REVERT)
                rv = mv;
        }
        else    // Only other option: only clamp above.
        {
            d = SYSsmooth(Mv - myBlendwidth, Mv, v);
            if(!HAS_REVERT)
                rv = Mv;
        }

        if(HAS_REVERT && !myUseRevertField)
            rv = myRevert;
        return d * v + (1 - d) * rv;
    }
};

#endif