HDK: GAS/GAS_Analysis.h Source File

00001 /*
00002  * PROPRIETARY INFORMATION.  This software is proprietary to
00003  * Side Effects Software Inc., and is not to be reproduced,
00004  * transmitted, or disclosed in any way without written permission.
00005  *
00006  * Produced by:
00007  *      Jeff Lait
00008  *      Side Effects Software Inc
00009  *      123 Front Street West, Suite 1401
00010  *      Toronto, Ontario
00011  *      Canada   M5J 2M2
00012  *      416-504-9876
00013  *
00014  * NAME:        GAS_Analysis.h ( GAS Library, C++)
00015  *
00016  * COMMENTS:
00017  */
00018 
00019 #ifndef __GAS_Analysis__
00020 #define __GAS_Analysis__
00021 
00022 #include "GAS_API.h"
00023 
00024 #include <UT/UT_ThreadedAlgorithm.h>
00025 #include <GU/GU_Detail.h>
00026 
00027 #include <SIM/SIM_RawField.h>
00028 #include <SIM/SIM_ScalarField.h>
00029 #include <SIM/SIM_VectorField.h>
00030 #include <SIM/SIM_PhysicalParms.h>
00031 
00032 #include "GAS_SubSolver.h"
00033 #include "GAS_Utils.h"
00034 
00035 class SIM_ScalarField;
00036 class SIM_VectorField;
00037 class SIM_MatrixField;
00038 
00039 class GAS_API GAS_Analysis : public GAS_SubSolver
00040 {
00041 public:
00042     GET_DATA_FUNC_S(GAS_NAME_FIELDDEST, FieldDstName);
00043     GET_DATA_FUNC_S(GAS_NAME_FIELDSOURCE, FieldSrcName);
00044 
00045     GET_DATA_FUNC_I("analysis", Analysis);
00046 
00047     // Analysis methods
00048     enum ANALYSIS_NAMES
00049     {
00050         CURVATURE,
00051         GRADIENT,
00052         LAPLACIAN,
00053         DIVERGENCE,
00054         CURL,
00055         NORMALIZE,
00056         LENGTH,
00057         NUM_ANALYSIS
00058     };
00059 
00060 protected:
00061     explicit             GAS_Analysis(const SIM_DataFactory *factory);
00062     virtual             ~GAS_Analysis();
00063 
00064     bool                 shouldMultiThread(const SIM_RawField *field) const 
00065                          { return field->field()->numTiles() > 1; }
00066 
00067     virtual bool         solveGasSubclass(SIM_Engine &engine,
00068                                 SIM_Object *obj,
00069                                 SIM_Time time,
00070                                 SIM_Time timestep);
00071 
00072 private:
00073     static const SIM_DopDescription     *getDopDescription();
00074 
00075 
00076     // We have helper wrappers around the same->same methods to avoid
00077     // read/modify/write problems where the source and destination fields
00078     // are the same.  This is impossible for the ones that change
00079     // dimensions.
00080     void                calculateCurvature(SIM_RawField *dst, SIM_RawField *src) const;
00081     THREADED_METHOD2_CONST(GAS_Analysis, shouldMultiThread(dst),
00082                         threadCurvature,
00083                         SIM_RawField *, dst,
00084                         const SIM_RawField *, src);
00085     void                threadCurvaturePartial(SIM_RawField *dst, 
00086                                     const SIM_RawField *src, 
00087                                     const UT_JobInfo &info) const;
00088 
00089     void                calculateLaplacian(SIM_RawField *dst, const SIM_RawField *src) const;
00090     THREADED_METHOD2_CONST(GAS_Analysis, shouldMultiThread(dst),
00091                         threadLaplacian,
00092                         SIM_RawField *, dst,
00093                         const SIM_RawField *, src);
00094     void                threadLaplacianPartial(SIM_RawField *dst, 
00095                                     const SIM_RawField *src, 
00096                                     const UT_JobInfo &info) const;
00097 
00098     THREADED_METHOD2_CONST(GAS_Analysis, shouldMultiThread(src->getField()),
00099                         calculateScalarGradientAligned,
00100                         SIM_VectorField *, dst,
00101                         const SIM_ScalarField *, src);
00102     void                calculateScalarGradientAlignedPartial(
00103                                     SIM_VectorField *dst, 
00104                                     const SIM_ScalarField *src, 
00105                                     const UT_JobInfo &info) const;
00106     THREADED_METHOD3_CONST(GAS_Analysis, shouldMultiThread(dst),
00107                         calculateScalarGradient,
00108                         SIM_RawField *, dst,
00109                         int, axis,
00110                         const SIM_ScalarField *, src);
00111     void                calculateScalarGradientPartial(SIM_RawField *dst, 
00112                                     int axis, 
00113                                     const SIM_ScalarField *src, 
00114                                     const UT_JobInfo &info) const;
00115     THREADED_METHOD2_CONST(GAS_Analysis, shouldMultiThread(src->getField(0)),
00116                         calculateVectorGradientAligned,
00117                         SIM_MatrixField *, dst,
00118                         const SIM_VectorField *, src);
00119     void                calculateVectorGradientAlignedPartial(
00120                                     SIM_MatrixField *dst, 
00121                                     const SIM_VectorField *src, 
00122                                     const UT_JobInfo &info) const;
00123     THREADED_METHOD4_CONST(GAS_Analysis, shouldMultiThread(dst),
00124                         calculateVectorGradient,
00125                         SIM_RawField *, dst,
00126                         int, a1,
00127                         int, a2,
00128                         const SIM_VectorField *, src);
00129     void                calculateVectorGradientPartial(SIM_RawField *dst, 
00130                                     int a1, int a2, 
00131                                     const SIM_VectorField *src, 
00132                                     const UT_JobInfo &info) const;
00133 
00134     THREADED_METHOD2_CONST(GAS_Analysis, shouldMultiThread(dst),
00135                         calculateDivergence,
00136                         SIM_RawField *, dst,
00137                         const SIM_VectorField *, src);
00138     void                calculateDivergencePartial(SIM_RawField *dst, 
00139                                     const SIM_VectorField *src, 
00140                                     const UT_JobInfo &info) const;
00141 
00142     void                calculateCurl(SIM_VectorField *dst, const SIM_VectorField *src);
00143 
00144     THREADED_METHOD2_CONST(GAS_Analysis, shouldMultiThread(dst[0]),
00145                         threadCurlAligned,
00146                         SIM_RawField **, dst,
00147                         const SIM_VectorField *, src);
00148     void                threadCurlAlignedPartial(SIM_RawField **dst,
00149                                 const SIM_VectorField *src,
00150                                 const UT_JobInfo &info) const;
00151     THREADED_METHOD2_CONST(GAS_Analysis, shouldMultiThread(dst[0]),
00152                         threadCurlAlignedFace,
00153                         SIM_RawField **, dst,
00154                         const SIM_VectorField *, src);
00155     void                threadCurlAlignedFacePartial(SIM_RawField **dst,
00156                                 const SIM_VectorField *src,
00157                                 const UT_JobInfo &info) const;
00158     THREADED_METHOD3_CONST(GAS_Analysis, shouldMultiThread(dst),
00159                         threadCurl,
00160                         SIM_RawField *, dst,
00161                         int, axis,
00162                         const SIM_VectorField *, src);
00163     void                threadCurlPartial(SIM_RawField *dst, 
00164                                     int axis, 
00165                                     const SIM_VectorField *src, 
00166                                     const UT_JobInfo &info) const;
00167 
00168     void                calculateNormalize(SIM_VectorField *dst, const SIM_VectorField *src);
00169     THREADED_METHOD2_CONST(GAS_Analysis, shouldMultiThread(dst->getField(0)),
00170                         threadNormalizeAligned,
00171                         SIM_VectorField *, dst,
00172                         const SIM_VectorField *, src);
00173     void                threadNormalizeAlignedPartial(SIM_VectorField *dst, 
00174                                     const SIM_VectorField *src, 
00175                                     const UT_JobInfo &info) const;
00176     THREADED_METHOD3_CONST(GAS_Analysis, shouldMultiThread(dst),
00177                         threadNormalize,
00178                         SIM_RawField *, dst,
00179                         int, axis,
00180                         const SIM_VectorField *, src);
00181     void                threadNormalizePartial(SIM_RawField *dst, 
00182                                     int axis, 
00183                                     const SIM_VectorField *src, 
00184                                     const UT_JobInfo &info) const;
00185 
00186     THREADED_METHOD2_CONST(GAS_Analysis, shouldMultiThread(dst),
00187                         calculateLengthAligned,
00188                         SIM_RawField *, dst,
00189                         const SIM_VectorField *, src);
00190     void                calculateLengthAlignedPartial(SIM_RawField *dst, 
00191                                     const SIM_VectorField *src, 
00192                                     const UT_JobInfo &info) const;
00193     THREADED_METHOD2_CONST(GAS_Analysis, shouldMultiThread(dst),
00194                         calculateLength,
00195                         SIM_RawField *, dst,
00196                         const SIM_VectorField *, src);
00197     void                calculateLengthPartial(SIM_RawField *dst, 
00198                                     const SIM_VectorField *src, 
00199                                     const UT_JobInfo &info) const;
00200 
00201     DECLARE_STANDARD_GETCASTTOTYPE();
00202     DECLARE_DATAFACTORY(GAS_Analysis,
00203                         GAS_SubSolver,
00204                         "Gas Analysis",
00205                         getDopDescription());
00206 
00207     // Cache our timestep for so we can calculate the timescale
00208     // effects.
00209     float               myTimeStep;
00210 };
00211 
00212 #endif