SIM_OpenCLEnforceBoundary.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:        SIM_OpenCLEnforceBoundary.h ( SIMZ Library, C++)
 *
 * COMMENTS:
 *  Performs IOP-style of boundary enforcement on the given fields. Fields are
 *  reset to 0 inside the colliders, while the velocity field is overridden by
 *  the collider's velocity.
 */

#ifndef __SIM_OpenCLEnforceBoundary__
#define __SIM_OpenCLEnforceBoundary__

#include "SIMZ_API.h"

#include <DOP/DOP_Node.h>
#include <DOP/DOP_AutoSolver.h>
#include <GAS/GAS_SubSolver.h>
#include <GAS/GAS_Utils.h>
#include <SIM/SIM_Query.h>
#include <SIM/SIM_QueryCombine.h>

#include "SIM_OpenCLEnforceBoundaryParms.proto.h"

class CE_Grid;
class CE_VDBGrid;

/// This class implements the solving logic.
class SIMZ_API SIM_GasOpenCLEnforceBoundary : public GAS_SubSolver
{
public:
    SIM_OpenCLEnforceBoundaryParms& param() { return myParms; }
    const SIM_OpenCLEnforceBoundaryParms& param() const { return myParms; }

    OP_VERSION versionParms() const { return myVersion; }
    void setVersionParms(OP_VERSION version) { myVersion = version; }

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

    void saveSubclass(std::ostream& os) const override
    {
        BaseClass::saveSubclass(os);
        myParms.save(os);
    }

    bool loadSubclass(UT_IStream& is) override
    {
        if (!BaseClass::loadSubclass(is))
            return false;
        if (!myParms.load(is))
            return false;
        return true;
    }

    SIM_Query* createQueryObjectSubclass() const override
    {
        return new SIM_QueryCombine(BaseClass::createQueryObjectSubclass(),
                                    myParms.createQueryObject(this));
    }

    void makeEqualSubclass(const SIM_Data* source) override
    {
        BaseClass::makeEqualSubclass(source);
        const SIM_GasOpenCLEnforceBoundary *src
            = SIM_DATA_CASTCONST(source, SIM_GasOpenCLEnforceBoundary);
        if (src)
        {
            myParms = src->param();
            myVersion = src->versionParms();
        }
    }

    bool solveGasSubclass(SIM_Engine& engine,
                          SIM_Object* obj,
                          SIM_Time time,
                          SIM_Time timestep) override;

    /// Does the sourcing work when set to use individual volumes.
    bool sourceVolumes(SIM_Object* obj,
                       const UT_Array<SIM_ScalarField*>& sfields,
                       const UT_Array<SIM_VectorField*>& vfields,
                       SIM_VectorField* vel, const GU_Detail* gdp,
                       const SIM_Geometry* inst_geo, const UT_Vector3& pos)
        const;
    /// Does the sourcing work when set to use packed sets.
    bool instancePackedSets(SIM_Object* obj,
                            const UT_Array<SIM_ScalarField*>& sfields,
                            const UT_Array<SIM_VectorField*>& vfields,
                            SIM_VectorField* vel, const GU_Detail* gdp,
                            const GU_Detail* inst_geo, const UT_Vector3& pos)
        const;

private:
    SIM_OpenCLEnforceBoundaryParms
                                myParms;
    OP_VERSION                  myVersion;

    static const SIM_DopDescription* getDopDescription();

    DECLARE_STANDARD_GETCASTTOTYPE();
    DECLARE_DATAFACTORY(SIM_GasOpenCLEnforceBoundary,
                        GAS_SubSolver,
                        "Gas OpenCL Enforce Boundary",
                        getDopDescription());
};

// This class applies parameters to SIM_GasOpenCLEnforceBoundary.
class SIMZ_API DOP_OpenCLEnforceBoundary : public DOP_AutoSolver
{
public:
    DOP_OpenCLEnforceBoundary(OP_Network* net, const char* name,
                              OP_Operator* entry);
    ~DOP_OpenCLEnforceBoundary() override;

    static OP_Node* myConstructor(OP_Network* net, const char* name,
                                  OP_Operator* entry);
    static PRM_Template myTemplateList[];
    static PRM_Template myObsoleteList[];

    bool updateParmsFlags() override;

protected:
    void doApplyOutputDataSubclass(fpreal time, int outputidx,
                                   SIM_RootData& rootdata,
                                   const char* parentdataname,
                                   DOP_Engine& engine,
                                   UT_StringArray* datanames,
                                   bool active) override;
    void getInputInfoSubclass(int inputidx, DOP_InOutInfo& info) const override;
};

#endif