docs/hdk/_g_a_s___analysis_8h_source.html

 /*

  * 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_Analysis.h ( GAS Library, C++)

  *

  * COMMENTS:

  */


 #ifndef __GAS_Analysis__

 #define __GAS_Analysis__


 #include "GAS_API.h"


 #include <UT/UT_ThreadedAlgorithm.h>

 #include <GU/GU_Detail.h>


 #include <SIM/SIM_RawField.h>

 #include <SIM/SIM_ScalarField.h>

 #include <SIM/SIM_VectorField.h>

 #include <SIM/SIM_PhysicalParms.h>


 #include "GAS_SubSolver.h"

 #include "GAS_Utils.h"


 class SIM_ScalarField;

 class SIM_VectorField;

 class SIM_MatrixField;


 class GAS_API GAS_Analysis : public GAS_SubSolver

 {

 public:

     GET_DATA_FUNC_S(GAS_NAME_FIELDDEST, FieldDstName);

     GET_DATA_FUNC_S(GAS_NAME_FIELDSOURCE, FieldSrcName);

     GET_DATA_FUNC_S(GAS_NAME_STENCIL, StencilName);


     GET_DATA_FUNC_I("analysis", Analysis);

     GET_DATA_FUNC_B(SIM_NAME_OPENCL, UseOpenCL);


     // Analysis methods

     enum ANALYSIS_NAMES

     {

         CURVATURE,

         GRADIENT,

         LAPLACIAN,

         DIVERGENCE,

         CURL,

         NORMALIZE,

         LENGTH,

         NUM_ANALYSIS

     };


 protected:

     explicit             GAS_Analysis(const SIM_DataFactory *factory);

                         ~GAS_Analysis() override;


     bool                 shouldMultiThread(const SIM_RawField *field) const

                          { return field->field()->numTiles() > 1; }


     bool                 solveGasSubclass(SIM_Engine &engine,

                                 SIM_Object *obj,

                                 SIM_Time time,

                                 SIM_Time timestep) override;


 private:

     static const SIM_DopDescription     *getDopDescription();


     // We have helper wrappers around the same->same methods to avoid

     // read/modify/write problems where the source and destination fields

     // are the same.  This is impossible for the ones that change

     // dimensions.

     void                calculateCurvature(SIM_RawField *dst, SIM_RawField *src,

                                            const SIM_RawField *stencil) const;

     THREADED_METHOD3_CONST(GAS_Analysis, shouldMultiThread(dst),

                         threadCurvature,

                         SIM_RawField *, dst,

                         const SIM_RawField *, src,

                         const SIM_RawField *, stencil);

     void                threadCurvaturePartial(SIM_RawField *dst,

                                     const SIM_RawField *src,

                                     const SIM_RawField *stencil,

                                     const UT_JobInfo &info) const;


     void                calculateLaplacian(SIM_RawField *dst, const SIM_RawField *src,

                                            const SIM_RawField *stencil) const;

     THREADED_METHOD3_CONST(GAS_Analysis, shouldMultiThread(dst),

                         threadLaplacian,

                         SIM_RawField *, dst,

                         const SIM_RawField *, src,

                         const SIM_RawField *, stencil);

     void                threadLaplacianPartial(SIM_RawField *dst,

                                     const SIM_RawField *src,

                                     const SIM_RawField *stencil,

                                     const UT_JobInfo &info) const;


     THREADED_METHOD3_CONST(GAS_Analysis, shouldMultiThread(src->getField()),

                         calculateScalarGradientAligned,

                         SIM_VectorField *, dst,

                         const SIM_ScalarField *, src,

                         const SIM_RawField *, stencil);

     void                calculateScalarGradientAlignedPartial(

                                     SIM_VectorField *dst,

                                     const SIM_ScalarField *src,

                                     const SIM_RawField *stencil,

                                     const UT_JobInfo &info) const;

     THREADED_METHOD4_CONST(GAS_Analysis, shouldMultiThread(dst),

                         calculateScalarGradient,

                         SIM_RawField *, dst,

                         int, axis,

                         const SIM_ScalarField *, src,

                         const SIM_RawField *, stencil);

     void                calculateScalarGradientPartial(SIM_RawField *dst,

                                     int axis,

                                     const SIM_ScalarField *src,

                                     const SIM_RawField *stencil,

                                     const UT_JobInfo &info) const;

     THREADED_METHOD3_CONST(GAS_Analysis, shouldMultiThread(src->getField(0)),

                         calculateVectorGradientAligned,

                         SIM_MatrixField *, dst,

                         const SIM_VectorField *, src,

                         const SIM_RawField *, stencil);

     void                calculateVectorGradientAlignedPartial(

                                     SIM_MatrixField *dst,

                                     const SIM_VectorField *src,

                                     const SIM_RawField *stencil,

                                     const UT_JobInfo &info) const;

     THREADED_METHOD5_CONST(GAS_Analysis, shouldMultiThread(dst),

                         calculateVectorGradient,

                         SIM_RawField *, dst,

                         int, a1,

                         int, a2,

                         const SIM_VectorField *, src,

                         const SIM_RawField *, stencil0);

     void                calculateVectorGradientPartial(SIM_RawField *dst,

                                     int a1, int a2,

                                     const SIM_VectorField *src,

                                     const SIM_RawField *stencil,

                                     const UT_JobInfo &info) const;


     THREADED_METHOD3_CONST(GAS_Analysis, shouldMultiThread(dst),

                         calculateDivergence,

                         SIM_RawField *, dst,

                         const SIM_VectorField *, src,

                         const SIM_RawField *, stencil);

     void                calculateDivergencePartial(SIM_RawField *dst,

                                     const SIM_VectorField *src,

                                     const SIM_RawField *stencil,

                                     const UT_JobInfo &info) const;


     void                calculateCurl(SIM_VectorField *dst, const SIM_VectorField *src,

                                       const SIM_RawField *stencil);


     THREADED_METHOD3_CONST(GAS_Analysis, shouldMultiThread(dst[0]),

                         threadCurlAligned,

                         SIM_RawField **, dst,

                         const SIM_VectorField *, src,

                         const SIM_RawField *, stencil);

     void                threadCurlAlignedPartial(SIM_RawField **dst,

                                 const SIM_VectorField *src,

                                 const SIM_RawField *stencil,

                                 const UT_JobInfo &info) const;

     THREADED_METHOD3_CONST(GAS_Analysis, shouldMultiThread(dst[0]),

                         threadCurlAlignedFace,

                         SIM_RawField **, dst,

                         const SIM_VectorField *, src,

                         const SIM_RawField *, stencil);

     void                threadCurlAlignedFacePartial(SIM_RawField **dst,

                                 const SIM_VectorField *src,

                                 const SIM_RawField *stencil,

                                 const UT_JobInfo &info) const;

     THREADED_METHOD4_CONST(GAS_Analysis, shouldMultiThread(dst),

                         threadCurl,

                         SIM_RawField *, dst,

                         int, axis,

                         const SIM_VectorField *, src,

                         const SIM_RawField *, stencil);

     void                threadCurlPartial(SIM_RawField *dst,

                                     int axis,

                                     const SIM_VectorField *src,

                                     const SIM_RawField *stencil,

                                     const UT_JobInfo &info) const;


     void                calculateNormalize(SIM_VectorField *dst, const SIM_VectorField *src,

                                            const SIM_RawField *stencil);

     THREADED_METHOD3_CONST(GAS_Analysis, shouldMultiThread(dst->getField(0)),

                         threadNormalizeAligned,

                         SIM_VectorField *, dst,

                         const SIM_VectorField *, src,

                         const SIM_RawField *, stencil);

     void                threadNormalizeAlignedPartial(SIM_VectorField *dst,

                                     const SIM_VectorField *src,

                                     const SIM_RawField *stencil,

                                     const UT_JobInfo &info) const;

     THREADED_METHOD4_CONST(GAS_Analysis, shouldMultiThread(dst),

                         threadNormalize,

                         SIM_RawField *, dst,

                         int, axis,

                         const SIM_VectorField *, src,

                         const SIM_RawField *, stencil);

     void                threadNormalizePartial(SIM_RawField *dst,

                                     int axis,

                                     const SIM_VectorField *src,

                                     const SIM_RawField *stencil,

                                     const UT_JobInfo &info) const;


     THREADED_METHOD3_CONST(GAS_Analysis, shouldMultiThread(dst),

                         calculateLength,

                         SIM_RawField *, dst,

                         const SIM_VectorField *, src,

                         const SIM_RawField *, stencil);

     void                calculateLengthPartial(SIM_RawField *dst,

                                     const SIM_VectorField *src,

                                     const SIM_RawField *stencil,

                                     const UT_JobInfo &info) const;


     THREADED_METHOD3_CONST(GAS_Analysis, shouldMultiThread(dst),

                         calculateMatrixLengthAligned,

                         SIM_RawField *, dst,

                         const SIM_MatrixField *, src,

                         const SIM_RawField *, stencil);

     void                calculateMatrixLengthAlignedPartial(SIM_RawField *dst,

                                     const SIM_MatrixField *src,

                                     const SIM_RawField *stencil,

                                     const UT_JobInfo &info) const;

     THREADED_METHOD3_CONST(GAS_Analysis, shouldMultiThread(dst),

                         calculateMatrixLength,

                         SIM_RawField *, dst,

                         const SIM_MatrixField *, src,

                         const SIM_RawField *, stencil);

     void                calculateMatrixLengthPartial(SIM_RawField *dst,

                                     const SIM_MatrixField *src,

                                     const SIM_RawField *stencil,

                                     const UT_JobInfo &info) const;


     // OpenCL functions

     void        calculateCurlCL(SIM_Object *obj,

                                 SIM_VectorField *dst,

                                 const SIM_VectorField *src);

     void        calculateLengthCL(SIM_Object *obj,

                                   SIM_ScalarField *dst,

                                   const SIM_VectorField *src);

     void        calculateScalarGradientCL(SIM_Object *obj,

                                           SIM_VectorField *dst,

                                           const SIM_ScalarField* src,

                                           bool doNormalize = false);

     void        calculateNormalizeCL(SIM_Object *obj,

                                      SIM_VectorField* dst,

                                      SIM_VectorField* src);

     void        calculateDivergenceCL(SIM_Object *obj,

                                      SIM_ScalarField* dst,

                                      SIM_VectorField* src);


     DECLARE_STANDARD_GETCASTTOTYPE();

     DECLARE_DATAFACTORY(GAS_Analysis,

                         GAS_SubSolver,

                         "Gas Analysis",

                         getDopDescription());


     // Cache our timestep for so we can calculate the timescale

     // effects.

     float               myTimeStep;

 };


 #endif

GAS_Analysis
Definition: GAS_Analysis.h:31

SIM_Engine
Definition: SIM_Engine.h:65

DECLARE_STANDARD_GETCASTTOTYPE
#define DECLARE_STANDARD_GETCASTTOTYPE()
Definition: SIM_DataUtils.h:50

THREADED_METHOD4_CONST
#define THREADED_METHOD4_CONST(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4)
Definition: UT_ThreadedAlgorithm.h:522

SIM_ScalarField.h

UT_ThreadedAlgorithm.h

SIM_Time
Definition: SIM_Time.h:19

GT_Names::time
GT_API const UT_StringHolder time

GAS_Analysis::shouldMultiThread
bool shouldMultiThread(const SIM_RawField *field) const
Definition: GAS_Analysis.h:58

GAS_API
#define GAS_API
Definition: GAS_API.h:10

SIM_RawField.h

GAS_SubSolver::solveGasSubclass
virtual bool solveGasSubclass(SIM_Engine &engine, SIM_Object *obj, SIM_Time time, SIM_Time timestep)=0

GAS_Analysis::NORMALIZE
Definition: GAS_Analysis.h:49

GU_Detail.h

THREADED_METHOD5_CONST
#define THREADED_METHOD5_CONST(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5)
Definition: UT_ThreadedAlgorithm.h:527

SIM_VectorField.h

DECLARE_DATAFACTORY
#define DECLARE_DATAFACTORY(DataClass, SuperClass, Description, DopParms)
Definition: SIM_DataUtils.h:63

SIM_PhysicalParms.h

GET_DATA_FUNC_I
#define GET_DATA_FUNC_I(DataName, FuncName)
Definition: SIM_OptionsUser.h:48

UT_VoxelArray::numTiles
int numTiles() const
Definition: UT_VoxelArray.h:1357

GAS_Utils.h

SIM_DopDescription
Definition: SIM_DopDescription.h:23

GAS_NAME_FIELDSOURCE
#define GAS_NAME_FIELDSOURCE
Definition: GAS_Utils.h:29

SIM_DataFactory
Definition: SIM_DataFactory.h:33

GAS_NAME_FIELDDEST
#define GAS_NAME_FIELDDEST
Definition: GAS_Utils.h:28

SIM_MatrixField
This class holds a three dimensional tensor field.
Definition: SIM_MatrixField.h:30

GAS_Analysis::ANALYSIS_NAMES
ANALYSIS_NAMES
Definition: GAS_Analysis.h:42

GAS_Analysis::CURL
Definition: GAS_Analysis.h:48

dst
GLenum GLenum dst
Definition: glcorearb.h:1793

GET_DATA_FUNC_B
#define GET_DATA_FUNC_B(DataName, FuncName)
Definition: SIM_OptionsUser.h:64

GAS_SubSolver.h

SIM_Object
Definition: SIM_Object.h:33

SIM_ScalarField
This class holds a three dimensional scalar field.
Definition: SIM_ScalarField.h:30

SIM_NAME_OPENCL
#define SIM_NAME_OPENCL
Definition: SIM_Names.h:222

SOP_VolumeAnalysisEnums::Analysis
Analysis
Definition: SOP_VolumeAnalysis.proto.h:25

GAS_SubSolver
Definition: GAS_SubSolver.h:70

UT_JobInfo
Definition: UT_ThreadedAlgorithm.h:92

GAS_Analysis::LAPLACIAN
Definition: GAS_Analysis.h:46

stencil
GLint GLfloat GLint stencil
Definition: glcorearb.h:1278

GAS_Analysis::LENGTH
Definition: GAS_Analysis.h:50

THREADED_METHOD3_CONST
#define THREADED_METHOD3_CONST(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3)
Definition: UT_ThreadedAlgorithm.h:517

SIM_VectorField
This class holds a three dimensional vector field.
Definition: SIM_VectorField.h:34

GET_DATA_FUNC_S
#define GET_DATA_FUNC_S(DataName, FuncName)
Definition: SIM_OptionsUser.h:166

GAS_API.h

GAS_Analysis::DIVERGENCE
Definition: GAS_Analysis.h:47

GAS_NAME_STENCIL
#define GAS_NAME_STENCIL
Definition: GAS_Utils.h:19

SIM_RawField
Definition: SIM_RawField.h:108

GAS_Analysis::CURVATURE
Definition: GAS_Analysis.h:44

SIM_RawField::field
UT_VoxelArrayF UT_VoxelArrayF & field
Definition: SIM_RawField.h:1402

GAS_Analysis::GRADIENT
Definition: GAS_Analysis.h:45

src
GLenum src
Definition: glcorearb.h:1793