SOP_LinearSolver.proto.h

Go to the documentation of this file.

/* Automagically Generated by generate_proto.py
 * Do not Edit
 */
#pragma once

#include <SOP/SOP_API.h>
#include <SOP/SOP_NodeVerb.h>
#include <SOP/SOP_GraphProxy.h>

#include <OP/OP_Utils.h>
#include <PRM/PRM_Parm.h>
#include <UT/UT_IStream.h>
#include <UT/UT_NTStreamUtil.h>
#include <UT/UT_Ramp.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_StringStream.h>
#include <UT/UT_VectorTypes.h>
#include <UT/UT_EnvControl.h>
#include <SYS/SYS_Types.h>

class DEP_MicroNode;
namespace SOP_LinearSolverEnums
{
    enum class Mode
    {
        LINEARSYSTEMSOLVE = 0,
        DECOMPOSE,
        SOLVEWITHDECOMPOSITION,
        MULTIPLY
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Mode enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Mode::LINEARSYSTEMSOLVE: return "linearsystemsolve"_sh;
        case Mode::DECOMPOSE: return "decompose"_sh;
        case Mode::SOLVEWITHDECOMPOSITION: return "solvewithdecomposition"_sh;
        case Mode::MULTIPLY: return "multiply"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class Precision
    {
        AUTO = 0,
        _32,
        _64
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(Precision enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case Precision::AUTO: return "auto"_sh;
        case Precision::_32: return "32"_sh;
        case Precision::_64: return "64"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class DenseDirectSolver
    {
        PARTIALPIVLU = 0,
        FULLPIVLU,
        HOUSEHOLDERQR,
        COLPIVHOUSEHOLDERQR,
        FULLPIVHOUSEHOLDERQR,
        COMPLETEORTHOGONALDECOMPOSITION,
        LLT,
        LDLT,
        BDCSVD,
        JACOBISVD,
        EIGENSOLVER,
        SELFADJOINTEIGENSOLVER
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(DenseDirectSolver enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case DenseDirectSolver::PARTIALPIVLU: return "partialpivlu"_sh;
        case DenseDirectSolver::FULLPIVLU: return "fullpivlu"_sh;
        case DenseDirectSolver::HOUSEHOLDERQR: return "householderqr"_sh;
        case DenseDirectSolver::COLPIVHOUSEHOLDERQR: return "colpivhouseholderqr"_sh;
        case DenseDirectSolver::FULLPIVHOUSEHOLDERQR: return "fullpivhouseholderqr"_sh;
        case DenseDirectSolver::COMPLETEORTHOGONALDECOMPOSITION: return "completeorthogonaldecomposition"_sh;
        case DenseDirectSolver::LLT: return "llt"_sh;
        case DenseDirectSolver::LDLT: return "ldlt"_sh;
        case DenseDirectSolver::BDCSVD: return "bdcsvd"_sh;
        case DenseDirectSolver::JACOBISVD: return "jacobisvd"_sh;
        case DenseDirectSolver::EIGENSOLVER: return "eigensolver"_sh;
        case DenseDirectSolver::SELFADJOINTEIGENSOLVER: return "selfadjointeigensolver"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class SparseDirectSolver
    {
        LLT = 0,
        LDLT,
        LU,
        QR
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(SparseDirectSolver enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case SparseDirectSolver::LLT: return "llt"_sh;
        case SparseDirectSolver::LDLT: return "ldlt"_sh;
        case SparseDirectSolver::LU: return "lu"_sh;
        case SparseDirectSolver::QR: return "qr"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class SparseDirectSolverBackend
    {
        PARDISOACCELERATE = 0,
        EIGEN
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(SparseDirectSolverBackend enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case SparseDirectSolverBackend::PARDISOACCELERATE: return "pardisoaccelerate"_sh;
        case SparseDirectSolverBackend::EIGEN: return "eigen"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class IterativeSolver
    {
        GMRES = 0,
        DGMRES,
        MINRES,
        CONJUGATEGRADIENT,
        LEASTSQUARESCONJUGATEGRADIENT,
        BICGSTAB,
        IDRS
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(IterativeSolver enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case IterativeSolver::GMRES: return "gmres"_sh;
        case IterativeSolver::DGMRES: return "dgmres"_sh;
        case IterativeSolver::MINRES: return "minres"_sh;
        case IterativeSolver::CONJUGATEGRADIENT: return "conjugategradient"_sh;
        case IterativeSolver::LEASTSQUARESCONJUGATEGRADIENT: return "leastsquaresconjugategradient"_sh;
        case IterativeSolver::BICGSTAB: return "bicgstab"_sh;
        case IterativeSolver::IDRS: return "idrs"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class DensePreconditioner
    {
        IDENTITY = 0,
        DIAGONAL
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(DensePreconditioner enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case DensePreconditioner::IDENTITY: return "identity"_sh;
        case DensePreconditioner::DIAGONAL: return "diagonal"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class SparsePreconditioner
    {
        IDENTITY = 0,
        DIAGONAL,
        INCOMPLETELUT,
        INCOMPLETECHOLESKY
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(SparsePreconditioner enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case SparsePreconditioner::IDENTITY: return "identity"_sh;
        case SparsePreconditioner::DIAGONAL: return "diagonal"_sh;
        case SparsePreconditioner::INCOMPLETELUT: return "incompletelut"_sh;
        case SparsePreconditioner::INCOMPLETECHOLESKY: return "incompletecholesky"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class SpectraEigensolver
    {
        GENEIGSSOLVER = 0,
        SYMEIGSSOLVER,
        GENEIGSREALSHIFTSOLVER,
        SYMEIGSSHIFTSOLVER
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(SpectraEigensolver enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case SpectraEigensolver::GENEIGSSOLVER: return "geneigssolver"_sh;
        case SpectraEigensolver::SYMEIGSSOLVER: return "symeigssolver"_sh;
        case SpectraEigensolver::GENEIGSREALSHIFTSOLVER: return "geneigsrealshiftsolver"_sh;
        case SpectraEigensolver::SYMEIGSSHIFTSOLVER: return "symeigsshiftsolver"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class MatrixStorage
    {
        VOLUME = 0,
        POINTS,
        PRIMITIVES,
        DETAIL
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(MatrixStorage enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case MatrixStorage::VOLUME: return "volume"_sh;
        case MatrixStorage::POINTS: return "points"_sh;
        case MatrixStorage::PRIMITIVES: return "primitives"_sh;
        case MatrixStorage::DETAIL: return "detail"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class VolumeEncoding
    {
        DENSECOL = 0,
        DENSEROW
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(VolumeEncoding enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case VolumeEncoding::DENSECOL: return "densecol"_sh;
        case VolumeEncoding::DENSEROW: return "denserow"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class PointsPrimsEncoding
    {
        DENSECOL = 0,
        DENSEROW,
        COO,
        LILCOL,
        LILROW
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(PointsPrimsEncoding enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case PointsPrimsEncoding::DENSECOL: return "densecol"_sh;
        case PointsPrimsEncoding::DENSEROW: return "denserow"_sh;
        case PointsPrimsEncoding::COO: return "coo"_sh;
        case PointsPrimsEncoding::LILCOL: return "lilcol"_sh;
        case PointsPrimsEncoding::LILROW: return "lilrow"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class DetailEncoding
    {
        DENSECOL = 0,
        DENSEROW,
        COO
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(DetailEncoding enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case DetailEncoding::DENSECOL: return "densecol"_sh;
        case DetailEncoding::DENSEROW: return "denserow"_sh;
        case DetailEncoding::COO: return "coo"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class VectorSrcStorage
    {
        POINTS = 0,
        PRIMITIVES,
        DETAIL
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(VectorSrcStorage enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case VectorSrcStorage::POINTS: return "points"_sh;
        case VectorSrcStorage::PRIMITIVES: return "primitives"_sh;
        case VectorSrcStorage::DETAIL: return "detail"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

    enum class VectorDstStorage
    {
        POINTS = 0,
        PRIMITIVES,
        DETAIL
    };

    SYS_FORCE_INLINE UT_StringHolder
    getToken(VectorDstStorage enum_value) 
    {
        using namespace UT::Literal;
        switch (enum_value) {
        case VectorDstStorage::POINTS: return "points"_sh;
        case VectorDstStorage::PRIMITIVES: return "primitives"_sh;
        case VectorDstStorage::DETAIL: return "detail"_sh;
        default: UT_ASSERT(false); return ""_sh;
        }
    }

}


class SOP_API SOP_LinearSolverParms  : public SOP_NodeParms
{
public:
    static int version() { return 1; }

    SOP_LinearSolverParms()
    {
        myMode = 0;
        myCookInplace = false;
        myPrecision = 0;
        myUseIterativeSolver = false;
        myIterativeSolver = 5;
        mySolveWithGuess = false;
        myUseEigensolver = false;
        mySpectraEigensolver = 0;
        myNumEigenpairs = 0;
        myShift = -0.001;
        mySolverTolerance = 1e-4;
        myMatrixStorage = 0;
        myVolumeEncoding = 0;
        myPointsPrimsEncoding = 0;
        myDetailEncoding = 0;
        mySquareMatrix = false;
        myRows = 512;
        myCols = 512;
        myRowAttribute = "row"_UTsh;
        myColAttribute = "col"_UTsh;
        myMatrixValueAttribute = "value"_UTsh;
        myVectorSrcStorage = 0;
        myVectorSrcAttribute = "known"_UTsh;
        myVectorDstStorage = 0;
        myVectorDstAttribute = "unknown"_UTsh;
        myPinnedGroup = ""_UTsh;
        myReduceRows = true;
        myScale = 1;
        myAccumulateResult = false;
        myDenseDirectSolver = 0;
        mySparseDirectSolver = 1;
        mySparseDirectSolverBackend = 0;
        myDensePreconditioner = 1;
        mySparsePreconditioner = 1;

    }

    explicit SOP_LinearSolverParms(const SOP_LinearSolverParms &) = default;
    SOP_LinearSolverParms &operator=(const SOP_LinearSolverParms &) = default;
    SOP_LinearSolverParms(SOP_LinearSolverParms &&) noexcept = default;
    SOP_LinearSolverParms &operator=(SOP_LinearSolverParms &&) noexcept = default;

    ~SOP_LinearSolverParms() override {}

    bool operator==(const SOP_LinearSolverParms &src) const
    {
        if (myMode != src.myMode) return false;
        if (myCookInplace != src.myCookInplace) return false;
        if (myPrecision != src.myPrecision) return false;
        if (myUseIterativeSolver != src.myUseIterativeSolver) return false;
        if (myIterativeSolver != src.myIterativeSolver) return false;
        if (mySolveWithGuess != src.mySolveWithGuess) return false;
        if (myUseEigensolver != src.myUseEigensolver) return false;
        if (mySpectraEigensolver != src.mySpectraEigensolver) return false;
        if (myNumEigenpairs != src.myNumEigenpairs) return false;
        if (myShift != src.myShift) return false;
        if (mySolverTolerance != src.mySolverTolerance) return false;
        if (myMatrixStorage != src.myMatrixStorage) return false;
        if (myVolumeEncoding != src.myVolumeEncoding) return false;
        if (myPointsPrimsEncoding != src.myPointsPrimsEncoding) return false;
        if (myDetailEncoding != src.myDetailEncoding) return false;
        if (mySquareMatrix != src.mySquareMatrix) return false;
        if (myRows != src.myRows) return false;
        if (myCols != src.myCols) return false;
        if (myRowAttribute != src.myRowAttribute) return false;
        if (myColAttribute != src.myColAttribute) return false;
        if (myMatrixValueAttribute != src.myMatrixValueAttribute) return false;
        if (myVectorSrcStorage != src.myVectorSrcStorage) return false;
        if (myVectorSrcAttribute != src.myVectorSrcAttribute) return false;
        if (myVectorDstStorage != src.myVectorDstStorage) return false;
        if (myVectorDstAttribute != src.myVectorDstAttribute) return false;
        if (myPinnedGroup != src.myPinnedGroup) return false;
        if (myReduceRows != src.myReduceRows) return false;
        if (myScale != src.myScale) return false;
        if (myAccumulateResult != src.myAccumulateResult) return false;
        if (myDenseDirectSolver != src.myDenseDirectSolver) return false;
        if (mySparseDirectSolver != src.mySparseDirectSolver) return false;
        if (mySparseDirectSolverBackend != src.mySparseDirectSolverBackend) return false;
        if (myDensePreconditioner != src.myDensePreconditioner) return false;
        if (mySparsePreconditioner != src.mySparsePreconditioner) return false;

        return true;
    }
    bool operator!=(const SOP_LinearSolverParms &src) const
    {
        return !operator==(src);
    }
    using Mode = SOP_LinearSolverEnums::Mode;
    using Precision = SOP_LinearSolverEnums::Precision;
    using DenseDirectSolver = SOP_LinearSolverEnums::DenseDirectSolver;
    using SparseDirectSolver = SOP_LinearSolverEnums::SparseDirectSolver;
    using SparseDirectSolverBackend = SOP_LinearSolverEnums::SparseDirectSolverBackend;
    using IterativeSolver = SOP_LinearSolverEnums::IterativeSolver;
    using DensePreconditioner = SOP_LinearSolverEnums::DensePreconditioner;
    using SparsePreconditioner = SOP_LinearSolverEnums::SparsePreconditioner;
    using SpectraEigensolver = SOP_LinearSolverEnums::SpectraEigensolver;
    using MatrixStorage = SOP_LinearSolverEnums::MatrixStorage;
    using VolumeEncoding = SOP_LinearSolverEnums::VolumeEncoding;
    using PointsPrimsEncoding = SOP_LinearSolverEnums::PointsPrimsEncoding;
    using DetailEncoding = SOP_LinearSolverEnums::DetailEncoding;
    using VectorSrcStorage = SOP_LinearSolverEnums::VectorSrcStorage;
    using VectorDstStorage = SOP_LinearSolverEnums::VectorDstStorage;



    void        buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
    {
        myMode = 0;
        if (true)
            graph->evalOpParm(myMode, nodeidx, "mode", time, 0);
        myCookInplace = false;
        if (true)
            graph->evalOpParm(myCookInplace, nodeidx, "cookinplace", time, 0);
        myPrecision = 0;
        if (true)
            graph->evalOpParm(myPrecision, nodeidx, "precision", time, 0);
        myUseIterativeSolver = false;
        if (true && ( (true&&!(((int64(getMode())==3))||((int64(getMode())==2))||((int64(getMode())==1)))) ) )
            graph->evalOpParm(myUseIterativeSolver, nodeidx, "useiterativesolver", time, 0);
        myIterativeSolver = 5;
        if (true && ( (true&&!(((int64(getMode())==3))||((int64(getMode())==2))||((getUseIterativeSolver()==0))||((int64(getMode())!=0)))) ) )
            graph->evalOpParm(myIterativeSolver, nodeidx, "iterativesolver", time, 0);
        mySolveWithGuess = false;
        if (true && ( (true&&!(((int64(getMode())==3))||((int64(getMode())==2))||((getUseIterativeSolver()==0))||((int64(getMode())!=0)))) ) )
            graph->evalOpParm(mySolveWithGuess, nodeidx, "solvewithguess", time, 0);
        myUseEigensolver = false;
        if (true && ( (true&&!(((int64(getMode())==3))||((int64(getMode())==2))||((int64(getMode())!=1)))) ) )
            graph->evalOpParm(myUseEigensolver, nodeidx, "useeigensolver", time, 0);
        mySpectraEigensolver = 0;
        if (true && ( (true&&!(((int64(getMode())==3))||((int64(getMode())==2))||((getUseEigensolver()==0))||((int64(getMode())!=1)))) ) )
            graph->evalOpParm(mySpectraEigensolver, nodeidx, "spectraeigensolver", time, 0);
        myNumEigenpairs = 0;
        if (true && ( (true&&!(((int64(getMode())==3))||((int64(getMode())==2))||((getUseEigensolver()==0))||((int64(getMode())!=1)))) ) )
            graph->evalOpParm(myNumEigenpairs, nodeidx, "numeigenpairs", time, 0);
        myShift = -0.001;
        if (true && ( (true&&!(((int64(getMode())==3))||((int64(getMode())==2))||((getUseEigensolver()==0))||((int64(getSpectraEigensolver())!=2)&&(int64(getSpectraEigensolver())!=3))||((int64(getMode())!=1)))) ) )
            graph->evalOpParm(myShift, nodeidx, "shift", time, 0);
        mySolverTolerance = 1e-4;
        if (true && ( (true&&!(((int64(getMode())==3))||((int64(getMode())==2))||((getUseIterativeSolver()==0)&&(getUseEigensolver()==0)))) ) )
            graph->evalOpParm(mySolverTolerance, nodeidx, "solvertolerance", time, 0);
        myMatrixStorage = 0;
        if (true && ( (true&&!(((int64(getMode())==2)))) ) )
            graph->evalOpParm(myMatrixStorage, nodeidx, "matrixstorage", time, 0);
        myVolumeEncoding = 0;
        if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMatrixStorage())!=0)))) ) )
            graph->evalOpParm(myVolumeEncoding, nodeidx, "volumeencoding", time, 0);
        myPointsPrimsEncoding = 0;
        if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMatrixStorage())!=1)&&(int64(getMatrixStorage())!=2)))) ) )
            graph->evalOpParm(myPointsPrimsEncoding, nodeidx, "pointsprimsencoding", time, 0);
        myDetailEncoding = 0;
        if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMatrixStorage())!=3)))) ) )
            graph->evalOpParm(myDetailEncoding, nodeidx, "detailencoding", time, 0);
        mySquareMatrix = false;
        if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMatrixStorage())==0))||((int64(getMatrixStorage())==1)&&(int64(getPointsPrimsEncoding())==0))||((int64(getMatrixStorage())==2)&&(int64(getPointsPrimsEncoding())==0))||((int64(getMatrixStorage())==1)&&(int64(getPointsPrimsEncoding())==1))||((int64(getMatrixStorage())==2)&&(int64(getPointsPrimsEncoding())==1)))) ) )
            graph->evalOpParm(mySquareMatrix, nodeidx, "squarematrix", time, 0);
        myRows = 512;
        if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMatrixStorage())==0))||((int64(getMatrixStorage())==1)&&(int64(getPointsPrimsEncoding())!=3)&&(int64(getPointsPrimsEncoding())!=2))||((int64(getMatrixStorage())==2)&&(int64(getPointsPrimsEncoding())!=3)&&(int64(getPointsPrimsEncoding())!=2))||((getSquareMatrix()==1)&&(int64(getMatrixStorage())==1)&&(int64(getPointsPrimsEncoding())!=2))||((getSquareMatrix()==1)&&(int64(getMatrixStorage())==2)&&(int64(getPointsPrimsEncoding())!=2))||((getSquareMatrix()==1)&&(int64(getMatrixStorage())==3)&&(int64(getDetailEncoding())!=2)))) ) )
            graph->evalOpParm(myRows, nodeidx, "rows", time, 0);
        myCols = 512;
        if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMatrixStorage())==0))||((int64(getMatrixStorage())==1)&&(int64(getPointsPrimsEncoding())!=4)&&(int64(getPointsPrimsEncoding())!=2))||((int64(getMatrixStorage())==2)&&(int64(getPointsPrimsEncoding())!=4)&&(int64(getPointsPrimsEncoding())!=2))||((getSquareMatrix()==1)&&(int64(getMatrixStorage())==1))||((getSquareMatrix()==1)&&(int64(getMatrixStorage())==2))||((getSquareMatrix()==1)&&(int64(getMatrixStorage())==3)))) ) )
            graph->evalOpParm(myCols, nodeidx, "cols", time, 0);
        myRowAttribute = "row"_UTsh;
        if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMatrixStorage())==0))||((int64(getMatrixStorage())==1)&&(int64(getPointsPrimsEncoding())==4))||((int64(getMatrixStorage())==2)&&(int64(getPointsPrimsEncoding())==4))||((int64(getMatrixStorage())==3))||((int64(getMatrixStorage())==1)&&(int64(getPointsPrimsEncoding())==1))||((int64(getMatrixStorage())==2)&&(int64(getPointsPrimsEncoding())==1))||((int64(getMatrixStorage())==1)&&(int64(getPointsPrimsEncoding())==0))||((int64(getMatrixStorage())==2)&&(int64(getPointsPrimsEncoding())==0)))) ) )
            graph->evalOpParm(myRowAttribute, nodeidx, "rowattr", time, 0);
        myColAttribute = "col"_UTsh;
        if (true && ( (true&&!(((int64(getMode())==2))||((int64(getMatrixStorage())==0))||((int64(getMatrixStorage())==1)&&(int64(getPointsPrimsEncoding())==3))||((int64(getMatrixStorage())==2)&&(int64(getPointsPrimsEncoding())==3))||((int64(getMatrixStorage())==3))||((int64(getMatrixStorage())==1)&&(int64(getPointsPrimsEncoding())==1))||((int64(getMatrixStorage())==2)&&(int64(getPointsPrimsEncoding())==1))||((int64(getMatrixStorage())==1)&&(int64(getPointsPrimsEncoding())==0))||((int64(getMatrixStorage())==2)&&(int64(getPointsPrimsEncoding())==0)))) ) )
            graph->evalOpParm(myColAttribute, nodeidx, "colattr", time, 0);
        myMatrixValueAttribute = "value"_UTsh;
        if (true && ( (true&&!(((int64(getMode())==2)))) ) )
            graph->evalOpParm(myMatrixValueAttribute, nodeidx, "matrixvalueattr", time, 0);
        myVectorSrcStorage = 0;
        if (true && ( (true&&!(((int64(getMode())==1)))) ) )
            graph->evalOpParm(myVectorSrcStorage, nodeidx, "vectorsrcstorage", time, 0);
        myVectorSrcAttribute = "known"_UTsh;
        if (true && ( (true&&!(((int64(getMode())==1)))) ) )
            graph->evalOpParm(myVectorSrcAttribute, nodeidx, "vectorsrcattr", time, 0);
        myVectorDstStorage = 0;
        if (true)
            graph->evalOpParm(myVectorDstStorage, nodeidx, "vectordststorage", time, 0);
        myVectorDstAttribute = "unknown"_UTsh;
        if (true && ( (true&&!(((int64(getMode())==1)))) ) )
            graph->evalOpParm(myVectorDstAttribute, nodeidx, "vectordstattr", time, 0);
        myPinnedGroup = ""_UTsh;
        if (true && ( (true&&!(((int64(getVectorDstStorage())==2))||((int64(getMode())==3)))) ) )
            graph->evalOpParm(myPinnedGroup, nodeidx, "pinnedgroup", time, 0);
        myReduceRows = true;
        if (true && ( (true&&!(((int64(getVectorDstStorage())==2))||((int64(getMode())==3))||((getPinnedGroup()=="")))) ) )
            graph->evalOpParm(myReduceRows, nodeidx, "reducerows", time, 0);
        myScale = 1;
        if (true && ( (true&&!(((int64(getMode())==1)))) ) )
            graph->evalOpParm(myScale, nodeidx, "scale", time, 0);
        myAccumulateResult = false;
        if (true && ( (true&&!(((int64(getMode())==1)))) ) )
            graph->evalOpParm(myAccumulateResult, nodeidx, "accumulateresult", time, 0);
        myDenseDirectSolver = 0;
        if (true && ( (true&&!(((int64(getMode())==3))||((int64(getMode())==2))||((int64(getMode())==0)&&(getUseIterativeSolver()==1))||((int64(getMode())==1)&&(getUseEigensolver()==1))||((int64(getMatrixStorage())==3)&&(int64(getDetailEncoding())!=0)&&(int64(getDetailEncoding())!=1))||((int64(getMatrixStorage())==1)&&(int64(getPointsPrimsEncoding())!=0)&&(int64(getPointsPrimsEncoding())!=1))||((int64(getMatrixStorage())==2)&&(int64(getPointsPrimsEncoding())!=0)&&(int64(getPointsPrimsEncoding())!=1)))) ) )
            graph->evalOpParm(myDenseDirectSolver, nodeidx, "densedirectsolver", time, 0);
        mySparseDirectSolver = 1;
        if (true && ( (true&&!(((int64(getMode())==3))||((int64(getMode())==2))||((getUseIterativeSolver()==1))||((getUseEigensolver()==1))||((int64(getMatrixStorage())==0))||((int64(getMatrixStorage())==3)&&(int64(getDetailEncoding())==0))||((int64(getMatrixStorage())==3)&&(int64(getDetailEncoding())==1))||((int64(getMatrixStorage())==1)&&(int64(getPointsPrimsEncoding())==1))||((int64(getMatrixStorage())==2)&&(int64(getPointsPrimsEncoding())==1))||((int64(getMatrixStorage())==1)&&(int64(getPointsPrimsEncoding())==0))||((int64(getMatrixStorage())==2)&&(int64(getPointsPrimsEncoding())==0)))) ) )
            graph->evalOpParm(mySparseDirectSolver, nodeidx, "sparsedirectsolver", time, 0);
        mySparseDirectSolverBackend = 0;
        if (true && ( (true&&!(((int64(getMode())==3))||((int64(getMode())==2))||((int64(getMode())==0)&&(getUseIterativeSolver()==1))||((int64(getMatrixStorage())==0))||((int64(getMatrixStorage())==3)&&(int64(getDetailEncoding())==0))||((int64(getMatrixStorage())==3)&&(int64(getDetailEncoding())==1))||((int64(getMatrixStorage())==1)&&(int64(getPointsPrimsEncoding())==1))||((int64(getMatrixStorage())==2)&&(int64(getPointsPrimsEncoding())==1))||((int64(getMatrixStorage())==1)&&(int64(getPointsPrimsEncoding())==0))||((int64(getMatrixStorage())==2)&&(int64(getPointsPrimsEncoding())==0))||((int64(getMode())==1)))) ) )
            graph->evalOpParm(mySparseDirectSolverBackend, nodeidx, "sparsedirectsolverbackend", time, 0);
        myDensePreconditioner = 1;
        if (true && ( (true&&!(((int64(getMode())==3))||((int64(getMode())==2))||((getUseIterativeSolver()==0))||((int64(getMode())!=0))||((int64(getMatrixStorage())==3)&&(int64(getDetailEncoding())!=0)&&(int64(getDetailEncoding())!=1))||((int64(getMatrixStorage())==1)&&(int64(getPointsPrimsEncoding())!=0)&&(int64(getPointsPrimsEncoding())!=1))||((int64(getMatrixStorage())==2)&&(int64(getPointsPrimsEncoding())!=0)&&(int64(getPointsPrimsEncoding())!=1)))) ) )
            graph->evalOpParm(myDensePreconditioner, nodeidx, "densepreconditioner", time, 0);
        mySparsePreconditioner = 1;
        if (true && ( (true&&!(((int64(getMode())==3))||((int64(getMode())==2))||((getUseIterativeSolver()==0))||((int64(getMode())!=0))||((int64(getMatrixStorage())==0))||((int64(getMatrixStorage())==3)&&(int64(getDetailEncoding())==0))||((int64(getMatrixStorage())==3)&&(int64(getDetailEncoding())==1))||((int64(getMatrixStorage())==1)&&(int64(getPointsPrimsEncoding())==1))||((int64(getMatrixStorage())==2)&&(int64(getPointsPrimsEncoding())==1))||((int64(getMatrixStorage())==1)&&(int64(getPointsPrimsEncoding())==0))||((int64(getMatrixStorage())==2)&&(int64(getPointsPrimsEncoding())==0)))) ) )
            graph->evalOpParm(mySparsePreconditioner, nodeidx, "sparsepreconditioner", time, 0);

    }


    void loadFromOpSubclass(const LoadParms &loadparms) override
    {
        buildFromOp(loadparms.graph(), loadparms.nodeIdx(), loadparms.context().getTime(), loadparms.depnode());
    }


    void copyFrom(const OP_NodeParms *src) override
    {
        *this = *((const SOP_LinearSolverParms *)src);
    }

    template <typename T>
    void
    doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
    {
        if (idx.size() < 1)
            return;
        UT_ASSERT(idx.size() == instance.size()+1);
        if (idx.size() != instance.size()+1)
            return;
        switch (idx[0])
        {
            case 0:
                coerceValue(value, myMode);
                break;
            case 1:
                coerceValue(value, myCookInplace);
                break;
            case 2:
                coerceValue(value, myPrecision);
                break;
            case 3:
                coerceValue(value, myUseIterativeSolver);
                break;
            case 4:
                coerceValue(value, myIterativeSolver);
                break;
            case 5:
                coerceValue(value, mySolveWithGuess);
                break;
            case 6:
                coerceValue(value, myUseEigensolver);
                break;
            case 7:
                coerceValue(value, mySpectraEigensolver);
                break;
            case 8:
                coerceValue(value, myNumEigenpairs);
                break;
            case 9:
                coerceValue(value, myShift);
                break;
            case 10:
                coerceValue(value, mySolverTolerance);
                break;
            case 11:
                coerceValue(value, myMatrixStorage);
                break;
            case 12:
                coerceValue(value, myVolumeEncoding);
                break;
            case 13:
                coerceValue(value, myPointsPrimsEncoding);
                break;
            case 14:
                coerceValue(value, myDetailEncoding);
                break;
            case 15:
                coerceValue(value, mySquareMatrix);
                break;
            case 16:
                coerceValue(value, myRows);
                break;
            case 17:
                coerceValue(value, myCols);
                break;
            case 18:
                coerceValue(value, myRowAttribute);
                break;
            case 19:
                coerceValue(value, myColAttribute);
                break;
            case 20:
                coerceValue(value, myMatrixValueAttribute);
                break;
            case 21:
                coerceValue(value, myVectorSrcStorage);
                break;
            case 22:
                coerceValue(value, myVectorSrcAttribute);
                break;
            case 23:
                coerceValue(value, myVectorDstStorage);
                break;
            case 24:
                coerceValue(value, myVectorDstAttribute);
                break;
            case 25:
                coerceValue(value, myPinnedGroup);
                break;
            case 26:
                coerceValue(value, myReduceRows);
                break;
            case 27:
                coerceValue(value, myScale);
                break;
            case 28:
                coerceValue(value, myAccumulateResult);
                break;
            case 29:
                coerceValue(value, myDenseDirectSolver);
                break;
            case 30:
                coerceValue(value, mySparseDirectSolver);
                break;
            case 31:
                coerceValue(value, mySparseDirectSolverBackend);
                break;
            case 32:
                coerceValue(value, myDensePreconditioner);
                break;
            case 33:
                coerceValue(value, mySparsePreconditioner);
                break;

        }
    }

    bool isParmColorRamp(exint idx) const override
    { 
            switch (idx)
            {

            }
            return false;
    }

    void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr<UT_Ramp> &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
    { doGetParmValue(idx, instance, value); }

    template <typename T>
    void
    doSetParmValue(TempIndex idx, TempIndex instance, const T &value) 
    {
        if (idx.size() < 1)
            return;
        UT_ASSERT(idx.size() == instance.size()+1);
        if (idx.size() != instance.size()+1)
            return;
        switch (idx[0])
        {
            case 0:
                coerceValue(myMode, clampMinValue(0,  clampMaxValue(3,  value ) ));
                break;
            case 1:
                coerceValue(myCookInplace, ( ( value ) ));
                break;
            case 2:
                coerceValue(myPrecision, clampMinValue(0,  clampMaxValue(2,  value ) ));
                break;
            case 3:
                coerceValue(myUseIterativeSolver, ( ( value ) ));
                break;
            case 4:
                coerceValue(myIterativeSolver, clampMinValue(0,  clampMaxValue(6,  value ) ));
                break;
            case 5:
                coerceValue(mySolveWithGuess, ( ( value ) ));
                break;
            case 6:
                coerceValue(myUseEigensolver, ( ( value ) ));
                break;
            case 7:
                coerceValue(mySpectraEigensolver, clampMinValue(0,  clampMaxValue(3,  value ) ));
                break;
            case 8:
                coerceValue(myNumEigenpairs, clampMinValue(1,  ( value ) ));
                break;
            case 9:
                coerceValue(myShift, ( ( value ) ));
                break;
            case 10:
                coerceValue(mySolverTolerance, clampMinValue(0,  ( value ) ));
                break;
            case 11:
                coerceValue(myMatrixStorage, clampMinValue(0,  clampMaxValue(3,  value ) ));
                break;
            case 12:
                coerceValue(myVolumeEncoding, clampMinValue(0,  clampMaxValue(1,  value ) ));
                break;
            case 13:
                coerceValue(myPointsPrimsEncoding, clampMinValue(0,  clampMaxValue(4,  value ) ));
                break;
            case 14:
                coerceValue(myDetailEncoding, clampMinValue(0,  clampMaxValue(2,  value ) ));
                break;
            case 15:
                coerceValue(mySquareMatrix, ( ( value ) ));
                break;
            case 16:
                coerceValue(myRows, clampMinValue(1,  ( value ) ));
                break;
            case 17:
                coerceValue(myCols, clampMinValue(1,  ( value ) ));
                break;
            case 18:
                coerceValue(myRowAttribute, ( ( value ) ));
                break;
            case 19:
                coerceValue(myColAttribute, ( ( value ) ));
                break;
            case 20:
                coerceValue(myMatrixValueAttribute, ( ( value ) ));
                break;
            case 21:
                coerceValue(myVectorSrcStorage, clampMinValue(0,  clampMaxValue(2,  value ) ));
                break;
            case 22:
                coerceValue(myVectorSrcAttribute, ( ( value ) ));
                break;
            case 23:
                coerceValue(myVectorDstStorage, clampMinValue(0,  clampMaxValue(2,  value ) ));
                break;
            case 24:
                coerceValue(myVectorDstAttribute, ( ( value ) ));
                break;
            case 25:
                coerceValue(myPinnedGroup, ( ( value ) ));
                break;
            case 26:
                coerceValue(myReduceRows, ( ( value ) ));
                break;
            case 27:
                coerceValue(myScale, ( ( value ) ));
                break;
            case 28:
                coerceValue(myAccumulateResult, ( ( value ) ));
                break;
            case 29:
                coerceValue(myDenseDirectSolver, clampMinValue(0,  clampMaxValue(11,  value ) ));
                break;
            case 30:
                coerceValue(mySparseDirectSolver, clampMinValue(0,  clampMaxValue(3,  value ) ));
                break;
            case 31:
                coerceValue(mySparseDirectSolverBackend, clampMinValue(0,  clampMaxValue(1,  value ) ));
                break;
            case 32:
                coerceValue(myDensePreconditioner, clampMinValue(0,  clampMaxValue(1,  value ) ));
                break;
            case 33:
                coerceValue(mySparsePreconditioner, clampMinValue(0,  clampMaxValue(3,  value ) ));
                break;

        }
    }

    void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr<UT_Ramp> &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value)  override
    { doSetParmValue(idx, instance, value); }

    exint getNestNumParms(TempIndex idx) const override
    {
        if (idx.size() == 0)
            return 34;
        switch (idx[0])
        {

        }
        // Invalid
        return 0;
    }

    const char *getNestParmName(TempIndex fieldnum) const override
    {
        if (fieldnum.size() < 1)
            return 0;
        switch (fieldnum[0])
        {
            case 0:
                return "mode";
            case 1:
                return "cookinplace";
            case 2:
                return "precision";
            case 3:
                return "useiterativesolver";
            case 4:
                return "iterativesolver";
            case 5:
                return "solvewithguess";
            case 6:
                return "useeigensolver";
            case 7:
                return "spectraeigensolver";
            case 8:
                return "numeigenpairs";
            case 9:
                return "shift";
            case 10:
                return "solvertolerance";
            case 11:
                return "matrixstorage";
            case 12:
                return "volumeencoding";
            case 13:
                return "pointsprimsencoding";
            case 14:
                return "detailencoding";
            case 15:
                return "squarematrix";
            case 16:
                return "rows";
            case 17:
                return "cols";
            case 18:
                return "rowattr";
            case 19:
                return "colattr";
            case 20:
                return "matrixvalueattr";
            case 21:
                return "vectorsrcstorage";
            case 22:
                return "vectorsrcattr";
            case 23:
                return "vectordststorage";
            case 24:
                return "vectordstattr";
            case 25:
                return "pinnedgroup";
            case 26:
                return "reducerows";
            case 27:
                return "scale";
            case 28:
                return "accumulateresult";
            case 29:
                return "densedirectsolver";
            case 30:
                return "sparsedirectsolver";
            case 31:
                return "sparsedirectsolverbackend";
            case 32:
                return "densepreconditioner";
            case 33:
                return "sparsepreconditioner";

        }
        return 0;
    }

    ParmType getNestParmType(TempIndex fieldnum) const override
    {
        if (fieldnum.size() < 1)
            return PARM_UNSUPPORTED;
        switch (fieldnum[0])
        {
            case 0:
                return PARM_INTEGER;
            case 1:
                return PARM_INTEGER;
            case 2:
                return PARM_INTEGER;
            case 3:
                return PARM_INTEGER;
            case 4:
                return PARM_INTEGER;
            case 5:
                return PARM_INTEGER;
            case 6:
                return PARM_INTEGER;
            case 7:
                return PARM_INTEGER;
            case 8:
                return PARM_INTEGER;
            case 9:
                return PARM_FLOAT;
            case 10:
                return PARM_FLOAT;
            case 11:
                return PARM_INTEGER;
            case 12:
                return PARM_INTEGER;
            case 13:
                return PARM_INTEGER;
            case 14:
                return PARM_INTEGER;
            case 15:
                return PARM_INTEGER;
            case 16:
                return PARM_INTEGER;
            case 17:
                return PARM_INTEGER;
            case 18:
                return PARM_STRING;
            case 19:
                return PARM_STRING;
            case 20:
                return PARM_STRING;
            case 21:
                return PARM_INTEGER;
            case 22:
                return PARM_STRING;
            case 23:
                return PARM_INTEGER;
            case 24:
                return PARM_STRING;
            case 25:
                return PARM_STRING;
            case 26:
                return PARM_INTEGER;
            case 27:
                return PARM_FLOAT;
            case 28:
                return PARM_INTEGER;
            case 29:
                return PARM_INTEGER;
            case 30:
                return PARM_INTEGER;
            case 31:
                return PARM_INTEGER;
            case 32:
                return PARM_INTEGER;
            case 33:
                return PARM_INTEGER;

        }
        return PARM_UNSUPPORTED;
    }

    // Boiler plate to load individual types.
    static void  loadData(UT_IStream &is, int64 &v)
    { is.bread(&v, 1); }
    static void  loadData(UT_IStream &is, bool &v)
    { int64     iv; is.bread(&iv, 1); v = iv; }
    static void  loadData(UT_IStream &is, fpreal64 &v)
    { is.bread<fpreal64>(&v, 1); }
    static void  loadData(UT_IStream &is, UT_Vector2D &v)
    { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
    static void  loadData(UT_IStream &is, UT_Vector3D &v)
    { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
      is.bread<fpreal64>(&v.z(), 1); }
    static void  loadData(UT_IStream &is, UT_Vector4D &v)
    { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
      is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
    static void  loadData(UT_IStream &is, UT_Matrix2D &v)
    { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
    static void  loadData(UT_IStream &is, UT_Matrix3D &v)
    { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
    static void  loadData(UT_IStream &is, UT_Matrix4D &v)
    { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
    static void  loadData(UT_IStream &is, UT_Vector2I &v)
    { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
    static void  loadData(UT_IStream &is, UT_Vector3I &v)
    { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
      is.bread<int64>(&v.z(), 1); }
    static void  loadData(UT_IStream &is, UT_Vector4I &v)
    { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
      is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
    static void  loadData(UT_IStream &is, UT_StringHolder &v)
    { is.bread(v); }
    static void  loadData(UT_IStream &is, UT_SharedPtr<UT_Ramp> &v)
    {   UT_StringHolder   rampdata;
        loadData(is, rampdata);
        if (rampdata.isstring())
        {
            v.reset(new UT_Ramp());
            UT_IStream  istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
            v->load(istr);
        }
        else v.reset();
    }
    static void  loadData(UT_IStream &is, PRM_DataItemHandle &v)
    {   UT_StringHolder   data;
        loadData(is, data);
        if (data.isstring())
        {
            // Find the data type.
            const char *colon = UT_StringWrap(data).findChar(':');
            if (colon)
            {
                int             typelen = colon - data.buffer();
                UT_WorkBuffer   type;
                type.strncpy(data.buffer(), typelen);
                UT_IStream  istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
                
                v = PRM_DataFactory::parseBinary(type.buffer(), istr);
            }
        }
        else v.reset();
    }

    static void  saveData(std::ostream &os, int64 v)
    { UTwrite(os, &v); }
    static void  saveData(std::ostream &os, bool v)
    { int64 iv = v; UTwrite(os, &iv); }
    static void  saveData(std::ostream &os, fpreal64 v)
    { UTwrite<fpreal64>(os, &v); }
    static void  saveData(std::ostream &os, UT_Vector2D v)
    { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
    static void  saveData(std::ostream &os, UT_Vector3D v)
    { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
      UTwrite<fpreal64>(os, &v.z()); }
    static void  saveData(std::ostream &os, UT_Vector4D v)
    { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
      UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
    static void  saveData(std::ostream &os, UT_Matrix2D v)
    { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) UTwrite<fpreal64>(os, &v(r, c)); }
    static void  saveData(std::ostream &os, UT_Matrix3D v)
    { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) UTwrite<fpreal64>(os, &v(r, c)); }
    static void  saveData(std::ostream &os, UT_Matrix4D v)
    { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) UTwrite<fpreal64>(os, &v(r, c)); }
    static void  saveData(std::ostream &os, UT_StringHolder s)
    { UT_StringWrap(s).saveBinary(os); }
    static void  saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
    {   UT_StringHolder         result;
        UT_OStringStream        ostr;
        if (s) s->save(ostr);
        result = ostr.str();
        saveData(os, result);
    }
    static void  saveData(std::ostream &os, PRM_DataItemHandle s)
    {   UT_StringHolder         result;
        UT_OStringStream        ostr;
        if (s) 
        {
            ostr << s->getDataTypeToken();
            ostr << ":";
            s->saveBinary(ostr);
        }
        result = ostr.str();
        saveData(os, result);
    }


    void         save(std::ostream &os) const
    {
        int32           v = version();
        UTwrite(os, &v);
        saveData(os, myMode);
        saveData(os, myCookInplace);
        saveData(os, myPrecision);
        saveData(os, myUseIterativeSolver);
        saveData(os, myIterativeSolver);
        saveData(os, mySolveWithGuess);
        saveData(os, myUseEigensolver);
        saveData(os, mySpectraEigensolver);
        saveData(os, myNumEigenpairs);
        saveData(os, myShift);
        saveData(os, mySolverTolerance);
        saveData(os, myMatrixStorage);
        saveData(os, myVolumeEncoding);
        saveData(os, myPointsPrimsEncoding);
        saveData(os, myDetailEncoding);
        saveData(os, mySquareMatrix);
        saveData(os, myRows);
        saveData(os, myCols);
        saveData(os, myRowAttribute);
        saveData(os, myColAttribute);
        saveData(os, myMatrixValueAttribute);
        saveData(os, myVectorSrcStorage);
        saveData(os, myVectorSrcAttribute);
        saveData(os, myVectorDstStorage);
        saveData(os, myVectorDstAttribute);
        saveData(os, myPinnedGroup);
        saveData(os, myReduceRows);
        saveData(os, myScale);
        saveData(os, myAccumulateResult);
        saveData(os, myDenseDirectSolver);
        saveData(os, mySparseDirectSolver);
        saveData(os, mySparseDirectSolverBackend);
        saveData(os, myDensePreconditioner);
        saveData(os, mySparsePreconditioner);

    }

    bool         load(UT_IStream &is)
    {
        int32           v;
        is.bread(&v, 1);
        if (version() != v)
        {
            // Fail incompatible versions
            return false;
        }
        loadData(is, myMode);
        loadData(is, myCookInplace);
        loadData(is, myPrecision);
        loadData(is, myUseIterativeSolver);
        loadData(is, myIterativeSolver);
        loadData(is, mySolveWithGuess);
        loadData(is, myUseEigensolver);
        loadData(is, mySpectraEigensolver);
        loadData(is, myNumEigenpairs);
        loadData(is, myShift);
        loadData(is, mySolverTolerance);
        loadData(is, myMatrixStorage);
        loadData(is, myVolumeEncoding);
        loadData(is, myPointsPrimsEncoding);
        loadData(is, myDetailEncoding);
        loadData(is, mySquareMatrix);
        loadData(is, myRows);
        loadData(is, myCols);
        loadData(is, myRowAttribute);
        loadData(is, myColAttribute);
        loadData(is, myMatrixValueAttribute);
        loadData(is, myVectorSrcStorage);
        loadData(is, myVectorSrcAttribute);
        loadData(is, myVectorDstStorage);
        loadData(is, myVectorDstAttribute);
        loadData(is, myPinnedGroup);
        loadData(is, myReduceRows);
        loadData(is, myScale);
        loadData(is, myAccumulateResult);
        loadData(is, myDenseDirectSolver);
        loadData(is, mySparseDirectSolver);
        loadData(is, mySparseDirectSolverBackend);
        loadData(is, myDensePreconditioner);
        loadData(is, mySparsePreconditioner);

        return true;
    }

    Mode getMode() const { return Mode(myMode); }
    void setMode(Mode val) { myMode = int64(val); }
    Mode opMode(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getMode();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "mode", cookparms.getCookTime(), 0);
        return Mode(result);
    }
    bool getCookInplace() const { return myCookInplace; }
    void setCookInplace(bool val) { myCookInplace = val; }
    bool opCookInplace(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getCookInplace();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "cookinplace", cookparms.getCookTime(), 0);
        return result;
    }
    Precision getPrecision() const { return Precision(myPrecision); }
    void setPrecision(Precision val) { myPrecision = int64(val); }
    Precision opPrecision(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getPrecision();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "precision", cookparms.getCookTime(), 0);
        return Precision(result);
    }
    bool getUseIterativeSolver() const { return myUseIterativeSolver; }
    void setUseIterativeSolver(bool val) { myUseIterativeSolver = val; }
    bool opUseIterativeSolver(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUseIterativeSolver();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "useiterativesolver", cookparms.getCookTime(), 0);
        return result;
    }
    IterativeSolver getIterativeSolver() const { return IterativeSolver(myIterativeSolver); }
    void setIterativeSolver(IterativeSolver val) { myIterativeSolver = int64(val); }
    IterativeSolver opIterativeSolver(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getIterativeSolver();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "iterativesolver", cookparms.getCookTime(), 0);
        return IterativeSolver(result);
    }
    bool getSolveWithGuess() const { return mySolveWithGuess; }
    void setSolveWithGuess(bool val) { mySolveWithGuess = val; }
    bool opSolveWithGuess(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSolveWithGuess();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "solvewithguess", cookparms.getCookTime(), 0);
        return result;
    }
    bool getUseEigensolver() const { return myUseEigensolver; }
    void setUseEigensolver(bool val) { myUseEigensolver = val; }
    bool opUseEigensolver(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUseEigensolver();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "useeigensolver", cookparms.getCookTime(), 0);
        return result;
    }
    SpectraEigensolver getSpectraEigensolver() const { return SpectraEigensolver(mySpectraEigensolver); }
    void setSpectraEigensolver(SpectraEigensolver val) { mySpectraEigensolver = int64(val); }
    SpectraEigensolver opSpectraEigensolver(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSpectraEigensolver();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "spectraeigensolver", cookparms.getCookTime(), 0);
        return SpectraEigensolver(result);
    }
    int64 getNumEigenpairs() const { return myNumEigenpairs; }
    void setNumEigenpairs(int64 val) { myNumEigenpairs = val; }
    int64 opNumEigenpairs(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getNumEigenpairs();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "numeigenpairs", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getShift() const { return myShift; }
    void setShift(fpreal64 val) { myShift = val; }
    fpreal64 opShift(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getShift();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "shift", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getSolverTolerance() const { return mySolverTolerance; }
    void setSolverTolerance(fpreal64 val) { mySolverTolerance = val; }
    fpreal64 opSolverTolerance(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSolverTolerance();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "solvertolerance", cookparms.getCookTime(), 0);
        return result;
    }
    MatrixStorage getMatrixStorage() const { return MatrixStorage(myMatrixStorage); }
    void setMatrixStorage(MatrixStorage val) { myMatrixStorage = int64(val); }
    MatrixStorage opMatrixStorage(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getMatrixStorage();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "matrixstorage", cookparms.getCookTime(), 0);
        return MatrixStorage(result);
    }
    VolumeEncoding getVolumeEncoding() const { return VolumeEncoding(myVolumeEncoding); }
    void setVolumeEncoding(VolumeEncoding val) { myVolumeEncoding = int64(val); }
    VolumeEncoding opVolumeEncoding(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getVolumeEncoding();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "volumeencoding", cookparms.getCookTime(), 0);
        return VolumeEncoding(result);
    }
    PointsPrimsEncoding getPointsPrimsEncoding() const { return PointsPrimsEncoding(myPointsPrimsEncoding); }
    void setPointsPrimsEncoding(PointsPrimsEncoding val) { myPointsPrimsEncoding = int64(val); }
    PointsPrimsEncoding opPointsPrimsEncoding(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getPointsPrimsEncoding();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "pointsprimsencoding", cookparms.getCookTime(), 0);
        return PointsPrimsEncoding(result);
    }
    DetailEncoding getDetailEncoding() const { return DetailEncoding(myDetailEncoding); }
    void setDetailEncoding(DetailEncoding val) { myDetailEncoding = int64(val); }
    DetailEncoding opDetailEncoding(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getDetailEncoding();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "detailencoding", cookparms.getCookTime(), 0);
        return DetailEncoding(result);
    }
    bool getSquareMatrix() const { return mySquareMatrix; }
    void setSquareMatrix(bool val) { mySquareMatrix = val; }
    bool opSquareMatrix(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSquareMatrix();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "squarematrix", cookparms.getCookTime(), 0);
        return result;
    }
    int64 getRows() const { return myRows; }
    void setRows(int64 val) { myRows = val; }
    int64 opRows(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getRows();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "rows", cookparms.getCookTime(), 0);
        return result;
    }
    int64 getCols() const { return myCols; }
    void setCols(int64 val) { myCols = val; }
    int64 opCols(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getCols();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "cols", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getRowAttribute() const { return myRowAttribute; }
    void setRowAttribute(const UT_StringHolder & val) { myRowAttribute = val; }
    UT_StringHolder opRowAttribute(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getRowAttribute();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "rowattr", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getColAttribute() const { return myColAttribute; }
    void setColAttribute(const UT_StringHolder & val) { myColAttribute = val; }
    UT_StringHolder opColAttribute(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getColAttribute();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "colattr", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getMatrixValueAttribute() const { return myMatrixValueAttribute; }
    void setMatrixValueAttribute(const UT_StringHolder & val) { myMatrixValueAttribute = val; }
    UT_StringHolder opMatrixValueAttribute(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getMatrixValueAttribute();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "matrixvalueattr", cookparms.getCookTime(), 0);
        return result;
    }
    VectorSrcStorage getVectorSrcStorage() const { return VectorSrcStorage(myVectorSrcStorage); }
    void setVectorSrcStorage(VectorSrcStorage val) { myVectorSrcStorage = int64(val); }
    VectorSrcStorage opVectorSrcStorage(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getVectorSrcStorage();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "vectorsrcstorage", cookparms.getCookTime(), 0);
        return VectorSrcStorage(result);
    }
    const UT_StringHolder & getVectorSrcAttribute() const { return myVectorSrcAttribute; }
    void setVectorSrcAttribute(const UT_StringHolder & val) { myVectorSrcAttribute = val; }
    UT_StringHolder opVectorSrcAttribute(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getVectorSrcAttribute();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "vectorsrcattr", cookparms.getCookTime(), 0);
        return result;
    }
    VectorDstStorage getVectorDstStorage() const { return VectorDstStorage(myVectorDstStorage); }
    void setVectorDstStorage(VectorDstStorage val) { myVectorDstStorage = int64(val); }
    VectorDstStorage opVectorDstStorage(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getVectorDstStorage();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "vectordststorage", cookparms.getCookTime(), 0);
        return VectorDstStorage(result);
    }
    const UT_StringHolder & getVectorDstAttribute() const { return myVectorDstAttribute; }
    void setVectorDstAttribute(const UT_StringHolder & val) { myVectorDstAttribute = val; }
    UT_StringHolder opVectorDstAttribute(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getVectorDstAttribute();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "vectordstattr", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getPinnedGroup() const { return myPinnedGroup; }
    void setPinnedGroup(const UT_StringHolder & val) { myPinnedGroup = val; }
    UT_StringHolder opPinnedGroup(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getPinnedGroup();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "pinnedgroup", cookparms.getCookTime(), 0);
        return result;
    }
    bool getReduceRows() const { return myReduceRows; }
    void setReduceRows(bool val) { myReduceRows = val; }
    bool opReduceRows(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getReduceRows();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "reducerows", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getScale() const { return myScale; }
    void setScale(fpreal64 val) { myScale = val; }
    fpreal64 opScale(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getScale();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "scale", cookparms.getCookTime(), 0);
        return result;
    }
    bool getAccumulateResult() const { return myAccumulateResult; }
    void setAccumulateResult(bool val) { myAccumulateResult = val; }
    bool opAccumulateResult(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getAccumulateResult();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "accumulateresult", cookparms.getCookTime(), 0);
        return result;
    }
    DenseDirectSolver getDenseDirectSolver() const { return DenseDirectSolver(myDenseDirectSolver); }
    void setDenseDirectSolver(DenseDirectSolver val) { myDenseDirectSolver = int64(val); }
    DenseDirectSolver opDenseDirectSolver(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getDenseDirectSolver();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "densedirectsolver", cookparms.getCookTime(), 0);
        return DenseDirectSolver(result);
    }
    SparseDirectSolver getSparseDirectSolver() const { return SparseDirectSolver(mySparseDirectSolver); }
    void setSparseDirectSolver(SparseDirectSolver val) { mySparseDirectSolver = int64(val); }
    SparseDirectSolver opSparseDirectSolver(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSparseDirectSolver();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "sparsedirectsolver", cookparms.getCookTime(), 0);
        return SparseDirectSolver(result);
    }
    SparseDirectSolverBackend getSparseDirectSolverBackend() const { return SparseDirectSolverBackend(mySparseDirectSolverBackend); }
    void setSparseDirectSolverBackend(SparseDirectSolverBackend val) { mySparseDirectSolverBackend = int64(val); }
    SparseDirectSolverBackend opSparseDirectSolverBackend(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSparseDirectSolverBackend();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "sparsedirectsolverbackend", cookparms.getCookTime(), 0);
        return SparseDirectSolverBackend(result);
    }
    DensePreconditioner getDensePreconditioner() const { return DensePreconditioner(myDensePreconditioner); }
    void setDensePreconditioner(DensePreconditioner val) { myDensePreconditioner = int64(val); }
    DensePreconditioner opDensePreconditioner(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getDensePreconditioner();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "densepreconditioner", cookparms.getCookTime(), 0);
        return DensePreconditioner(result);
    }
    SparsePreconditioner getSparsePreconditioner() const { return SparsePreconditioner(mySparsePreconditioner); }
    void setSparsePreconditioner(SparsePreconditioner val) { mySparsePreconditioner = int64(val); }
    SparsePreconditioner opSparsePreconditioner(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSparsePreconditioner();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "sparsepreconditioner", cookparms.getCookTime(), 0);
        return SparsePreconditioner(result);
    }

private:
    int64 myMode;
    bool myCookInplace;
    int64 myPrecision;
    bool myUseIterativeSolver;
    int64 myIterativeSolver;
    bool mySolveWithGuess;
    bool myUseEigensolver;
    int64 mySpectraEigensolver;
    int64 myNumEigenpairs;
    fpreal64 myShift;
    fpreal64 mySolverTolerance;
    int64 myMatrixStorage;
    int64 myVolumeEncoding;
    int64 myPointsPrimsEncoding;
    int64 myDetailEncoding;
    bool mySquareMatrix;
    int64 myRows;
    int64 myCols;
    UT_StringHolder myRowAttribute;
    UT_StringHolder myColAttribute;
    UT_StringHolder myMatrixValueAttribute;
    int64 myVectorSrcStorage;
    UT_StringHolder myVectorSrcAttribute;
    int64 myVectorDstStorage;
    UT_StringHolder myVectorDstAttribute;
    UT_StringHolder myPinnedGroup;
    bool myReduceRows;
    fpreal64 myScale;
    bool myAccumulateResult;
    int64 myDenseDirectSolver;
    int64 mySparseDirectSolver;
    int64 mySparseDirectSolverBackend;
    int64 myDensePreconditioner;
    int64 mySparsePreconditioner;

};