Changeset 370

Timestamp:

Mar 21, 2006 11:00:11 PM (18 years ago)

Author:

mmc

Message:

Added support for triangular and prismatic meshes.

Serialization sort of works. Needs better treatment of pointers for
classes derived from Rappture::Serializable.

Location:

trunk/src2/core

Files:

• Makefile (modified) (1 diff)
• RpField1D.cc (modified) (1 diff)
• RpField1D.h (modified) (1 diff)
• RpFieldPrism3D.cc (added)
• RpFieldPrism3D.h (added)
• RpFieldRect3D.cc (modified) (9 diffs)
• RpFieldRect3D.h (modified) (3 diffs)
• RpFieldTri2D.cc (added)
• RpFieldTri2D.h (added)
• RpMesh1D.cc (modified) (3 diffs)
• RpMesh1D.h (modified) (5 diffs)
• RpMeshPrism3D.cc (added)
• RpMeshPrism3D.h (added)
• RpMeshRect3D.cc (modified) (3 diffs)
• RpMeshRect3D.h (modified) (2 diffs)
• RpMeshTri2D.cc (added)
• RpMeshTri2D.h (added)
• RpNode.h (modified) (1 diff)
• RpOutcome.cc (modified) (4 diffs)
• RpPtr.h (modified) (4 diffs)
• RpSerializable.cc (modified) (5 diffs)
• RpSerializable.h (modified) (4 diffs)
• RpSerializer.cc (modified) (7 diffs)
• RpSerializer.h (modified) (4 diffs)
• test.cc (modified) (2 diffs)
• viz.cc (modified) (5 diffs)

trunk/src2/core/Makefile

@@ +1 @@
+CFLAGS = -g
 all: viz
 
-viz: viz.o RpOutcome.o RpMesh1D.o RpField1D.o RpMeshRect3D.o RpFieldRect3D.o
-        g++ -g -o viz viz.o RpOutcome.o RpMesh1D.o RpField1D.o RpMeshRect3D.o RpFieldRect3D.o
+viz: viz.o RpOutcome.o RpMesh1D.o RpField1D.o RpMeshTri2D.o RpMeshRect3D.o RpFieldRect3D.o RpMeshPrism3D.o RpFieldPrism3D.o RpSerialBuffer.o RpSerializer.o RpSerializable.o
+        g++ $(CFLAGS) -o viz viz.o RpOutcome.o RpMesh1D.o RpField1D.o RpMeshTri2D.o RpMeshRect3D.o RpFieldRect3D.o RpMeshPrism3D.o RpFieldPrism3D.o RpSerialBuffer.o RpSerializer.o RpSerializable.o
 
 viz.o: viz.cc
-        g++ -c -g -o viz.o viz.cc
+        g++ $(CFLAGS) -c -o viz.o viz.cc
 
-test: test.o RpOutcome.o RpMesh1D.o RpField1D.o RpMeshRect3D.o RpFieldRect3D.o RpSerialBuffer.o
-        g++ -g -o test test.o RpOutcome.o RpMesh1D.o RpField1D.o RpMeshRect3D.o RpFieldRect3D.o RpSerialBuffer.o
+test: test.o RpOutcome.o RpMesh1D.o RpField1D.o RpMeshTri2D.o RpFieldTri2D.o RpMeshRect3D.o RpFieldRect3D.o RpMeshPrism3D.o RpFieldPrism3D.o RpSerialBuffer.o RpSerializer.o RpSerializable.o
+        g++ $(CFLAGS) -o test test.o RpOutcome.o RpMesh1D.o RpField1D.o RpMeshTri2D.o RpFieldTri2D.o RpMeshRect3D.o RpFieldRect3D.o RpMeshPrism3D.o RpFieldPrism3D.o RpSerialBuffer.o RpSerializer.o RpSerializable.o
 
 test.o: test.cc RpPtr.h
-        g++ -c -g -o test.o test.cc
+        g++ $(CFLAGS) -c -o test.o test.cc
 
 RpOutcome.o: RpOutcome.cc RpPtr.h
-        g++ -c -g -o RpOutcome.o RpOutcome.cc
+        g++ $(CFLAGS) -c -o RpOutcome.o RpOutcome.cc
 
 RpMesh1D.o: RpMesh1D.cc RpMesh1D.h RpNode.h
-        g++ -c -g -o RpMesh1D.o RpMesh1D.cc
+        g++ $(CFLAGS) -c -o RpMesh1D.o RpMesh1D.cc
 
 RpField1D.o: RpField1D.cc RpField1D.h RpMesh1D.h RpNode.h
-        g++ -c -g -o RpField1D.o RpField1D.cc
+        g++ $(CFLAGS) -c -o RpField1D.o RpField1D.cc
+
+RpMeshTri2D.o: RpMeshTri2D.cc RpMeshTri2D.h RpNode.h
+        g++ $(CFLAGS) -c -o RpMeshTri2D.o RpMeshTri2D.cc
+
+RpFieldTri2D.o: RpFieldTri2D.cc RpFieldTri2D.h RpNode.h
+        g++ $(CFLAGS) -c -o RpFieldTri2D.o RpFieldTri2D.cc
 
 RpMeshRect3D.o: RpMeshRect3D.cc RpMeshRect3D.h RpNode.h
-        g++ -c -g -o RpMeshRect3D.o RpMeshRect3D.cc
+        g++ $(CFLAGS) -c -o RpMeshRect3D.o RpMeshRect3D.cc
 
 RpFieldRect3D.o: RpFieldRect3D.cc RpFieldRect3D.h RpNode.h
-        g++ -c -g -o RpFieldRect3D.o RpFieldRect3D.cc
+        g++ $(CFLAGS) -c -o RpFieldRect3D.o RpFieldRect3D.cc
+
+RpMeshPrism3D.o: RpMeshPrism3D.cc RpMeshPrism3D.h RpNode.h
+        g++ $(CFLAGS) -c -o RpMeshPrism3D.o RpMeshPrism3D.cc
+
+RpFieldPrism3D.o: RpFieldPrism3D.cc RpFieldPrism3D.h RpNode.h
+        g++ $(CFLAGS) -c -o RpFieldPrism3D.o RpFieldPrism3D.cc
 
 RpSerialBuffer.o: RpSerialBuffer.cc RpSerialBuffer.h
-        g++ -c -g -o RpSerialBuffer.o RpSerialBuffer.cc
+        g++ $(CFLAGS) -c -o RpSerialBuffer.o RpSerialBuffer.cc
+
+RpSerializer.o: RpSerializer.cc RpSerializer.h
+        g++ $(CFLAGS) -c -o RpSerializer.o RpSerializer.cc
 
 RpSerializable.o: RpSerializable.cc RpSerializable.h
-        g++ -c -g -o RpSerializable.o RpSerializable.cc
+        g++ $(CFLAGS) -c -o RpSerializable.o RpSerializable.cc
 
 clean:

trunk/src2/core/RpField1D.cc

@@ -88 +88 @@
 
 Node1D&
-Field1D::nodeAt(int pos)
+Field1D::atNode(int pos)
 {
     return _meshPtr->at(pos);

trunk/src2/core/RpField1D.h

@@ -36 +36 @@
 
     virtual int size() const;
-    virtual Node1D& nodeAt(int pos);
+    virtual Node1D& atNode(int pos);
     virtual double rangeMin() const;
     virtual double rangeMax() const;

trunk/src2/core/RpFieldRect3D.cc

@@ -31 +31 @@
 {
     _meshPtr = Ptr<MeshRect3D>( new MeshRect3D(xg,yg,zg) );
+    int npts = xg.size()*yg.size()*zg.size();
+    _valuelist.reserve(npts);
 }
 
@@ -46 +48 @@
     _meshPtr = field._meshPtr;
     _counter = field._counter;
+    return *this;
 }
 
@@ -55 +58 @@
 FieldRect3D::size(Axis which) const
 {
-    if (!_meshPtr.isnull()) {
+    if (!_meshPtr.isNull()) {
         return _meshPtr->size(which);
     }
@@ -62 +65 @@
 
 Node1D&
-FieldRect3D::nodeAt(Axis which, int pos)
+FieldRect3D::atNode(Axis which, int pos)
 {
     static Node1D null(0.0);
 
-    if (!_meshPtr.isnull()) {
+    if (!_meshPtr.isNull()) {
         return _meshPtr->at(which, pos);
     }
@@ -75 +78 @@
 FieldRect3D::rangeMin(Axis which) const
 {
-    if (!_meshPtr.isnull()) {
+    if (!_meshPtr.isNull()) {
         return _meshPtr->rangeMin(which);
     }
@@ -84 +87 @@
 FieldRect3D::rangeMax(Axis which) const
 {
-    if (!_meshPtr.isnull()) {
+    if (!_meshPtr.isNull()) {
         return _meshPtr->rangeMax(which);
     }
@@ -93 +96 @@
 FieldRect3D::define(int nodeId, double f)
 {
-    while (_valuelist.size() <= nodeId) {
-        _valuelist.push_back(0.0);
-    }
     _valuelist[nodeId] = f;
     return *this;
@@ -101 +101 @@
 
 double
-FieldRect3D::value(double x, double y, double z) const
+FieldRect3D::value(double x, double y, double z, double outside) const
 {
     double f0, f1, fy0, fy1, fz0, fz1;
 
-    if (!_meshPtr.isnull()) {
+    if (!_meshPtr.isNull()) {
         CellRect3D cell = _meshPtr->locate(Node3D(x,y,z));
+
+        // outside the defined data? then return the outside value
+        if (cell.isOutside()) {
+            return outside;
+        }
 
         // yuck! brute force...
@@ -138 +143 @@
         return _interpolate(cell.z(0),fz0, cell.z(4),fz1, z);
     }
-    return 0.0;
+    return outside;
 }
 

trunk/src2/core/RpFieldRect3D.h

@@ -17 +17 @@
 #define RAPPTURE_FIELDRECT3D_H
 
+#include <math.h>
+#include <vector>
 #include "RpPtr.h"
 #include "RpMeshRect3D.h"
@@ -31 +33 @@
 
     virtual int size(Axis which) const;
-    virtual Node1D& nodeAt(Axis which, int pos);
+    virtual Node1D& atNode(Axis which, int pos);
     virtual double rangeMin(Axis which) const;
     virtual double rangeMax(Axis which) const;
 
     virtual FieldRect3D& define(int nodeId, double f);
-    virtual double value(double x, double y, double z) const;
+    virtual double value(double x, double y, double z,
+        double outside=NAN) const;
 
 protected:
@@ -43 +46 @@
 
 private:
-    std::deque<double> _valuelist;  // list of all values, in nodeId order
+    std::vector<double> _valuelist; // list of all values, in nodeId order
     Ptr<MeshRect3D> _meshPtr;       // mesh for all (x,y,z) points
     int _counter;                   // counter for generating node IDs

trunk/src2/core/RpMesh1D.cc

@@ -22 +22 @@
 
 // serialization version 'A' for Mesh1D...
-////SerialConverter Mesh1D::versionA("Mesh1D", 'A',
-////    Mesh1D::serialize_A, Mesh1D::create, Mesh1D::deserialize_A);
+SerialConversion Mesh1D::versionA("Mesh1D", 'A',
+    (Serializable::serializeObjectMethod)&Mesh1D::serialize_A,
+    &Mesh1D::create,
+    (Serializable::deserializeObjectMethod)&Mesh1D::deserialize_A);
 
 
@@ -52 +54 @@
     assert(n >= 0 && n < 2);
     return _x[n];
+}
+
+int
+Cell1D::isOutside() const
+{
+    return (_nodeIds[0] < 0 || _nodeIds[1] < 0);
 }
 
@@ -317 +325 @@
 }
 
-////void
-////Mesh1D::serialize_A(SerialBuffer& buffer) const
-////{
-////}
-
-////Ptr<Serializable>
-////Mesh1D::create()
-////{
-////    return Ptr<Serializable>( new Mesh1D() );
-////}
-
-////Outcome
-////Mesh1D::deserialize_A(SerialBuffer& buffer)
-////{
-////}
+Ptr<Serializable>
+Mesh1D::create()
+{
+    return Ptr<Serializable>( (Serializable*) new Mesh1D() );
+}
+
+void
+Mesh1D::serialize_A(SerialBuffer& buffer) const
+{
+    Mesh1D* nonconst = (Mesh1D*)this;
+    buffer.writeInt(_nodelist.size());
+
+    std::deque<Node1D>::iterator iter = nonconst->_nodelist.begin();
+    while (iter != _nodelist.end()) {
+        buffer.writeInt( (*iter).id() );
+        buffer.writeDouble( (*iter).x() );
+        ++iter;
+    }
+    buffer.writeInt(_counter);
+}
+
+Outcome
+Mesh1D::deserialize_A(SerialBuffer& buffer)
+{
+    Outcome status;
+    Node1D newnode(0.0);
+
+    clear();
+    int npts = buffer.readInt();
+
+    for (int n=0; n < npts; n++) {
+        newnode.id( buffer.readInt() );
+        newnode.x( buffer.readDouble() );
+        _nodelist.push_back(newnode);
+    }
+    _counter = buffer.readInt();
+
+    return status;
+}

trunk/src2/core/RpMesh1D.h

@@ -21 +21 @@
 #include <deque>
 #include "RpNode.h"
-////#include "RpSerializable.h"
+#include "RpSerializable.h"
 
 namespace Rappture {
@@ -32 +32 @@
     double& x(int n);
 
+    int isOutside() const;
+
 private:
     int _nodeIds[2];
@@ -37 +39 @@
 };
 
-class Mesh1D {
+class Mesh1D : public Serializable {
 public:
     Mesh1D();
@@ -61 +63 @@
     char serializerVersion() const { return 'A'; }
 
-////    void serialize_A(SerialBuffer& buffer) const;
-////    static Ptr<Serializable> create();
-////    Outcome deserialize_A(SerialBuffer& buffer);
+    void serialize_A(SerialBuffer& buffer) const;
+    static Ptr<Serializable> create();
+    Outcome deserialize_A(SerialBuffer& buffer);
 
 protected:
@@ -77 +79 @@
 
     // methods for serializing/deserializing version 'A'
-////    static SerialConversion versionA;
+    static SerialConversion versionA;
 };
 

trunk/src2/core/RpMeshRect3D.cc

@@ -78 +78 @@
 }
 
+int
+CellRect3D::isOutside() const
+{
+    for (int i=0; i < 8; i++) {
+        if (_nodeIds[i] < 0) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
 
 MeshRect3D::MeshRect3D()
@@ -175 +186 @@
     coord.x(node.z());
     cells[2] = _axis[2].locate(coord);
-
-    // any of these cells on the edge? then set both sides to edge point
-    for (int c=0; c < 3; c++) {
-        if (cells[c].nodeId(0) < 0) {
-            cells[c].nodeId(0) = cells[c].nodeId(1);
-            cells[c].x(0) = cells[c].x(1);
-        }
-        else if (cells[c].nodeId(1) < 0) {
-            cells[c].nodeId(1) = cells[c].nodeId(0);
-            cells[c].x(1) = cells[c].x(0);
-        }
-    }
 
     int n = 0;
@@ -195 +194 @@
                 int ny = cells[1].nodeId(iy);
                 int nz = cells[2].nodeId(iz);
-                result.nodeId(n) = nz*(_axis[0].size()*_axis[1].size())
-                                   + ny*(_axis[0].size())
-                                   + nx;
-
-                result.x(n) = cells[0].x(ix);
-                result.y(n) = cells[1].x(iy);
-                result.z(n) = cells[2].x(iz);
+                if (nx >= 0 && ny >= 0 && nz >= 0) {
+                    result.nodeId(n) = nz*(_axis[0].size()*_axis[1].size())
+                                       + ny*(_axis[0].size())
+                                       + nx;
+                    result.x(n) = cells[0].x(ix);
+                    result.y(n) = cells[1].x(iy);
+                    result.z(n) = cells[2].x(iz);
+                }
                 n++;
             }

trunk/src2/core/RpMeshRect3D.h

@@ -21 +21 @@
 namespace Rappture {
 
-enum Axis {xaxis=0, yaxis, zaxis};
-
 class CellRect3D {
 public:
@@ -32 +30 @@
     double& y(int n);
     double& z(int n);
+
+    int isOutside() const;
 
 private:

trunk/src2/core/RpNode.h

@@ -20 +20 @@
 
 namespace Rappture {
+
+enum Axis {xaxis=0, yaxis, zaxis};
 
 class Node {

trunk/src2/core/RpOutcome.cc

@@ -76 +76 @@
 {
     _status &= oc._status;
-    if (!oc._contextPtr.isnull()) {
+    if (!oc._contextPtr.isNull()) {
         _remarkPtr = oc._remarkPtr;
         _contextPtr = oc._contextPtr;
@@ -85 +85 @@
 Outcome::remark() const
 {
-    if (!_remarkPtr.isnull()) {
+    if (!_remarkPtr.isNull()) {
         return _remarkPtr->data();
     }
@@ -94 +94 @@
 Outcome::addContext(const char *rem)
 {
-    if (_contextPtr.isnull()) {
+    if (_contextPtr.isNull()) {
         _contextPtr = new std::string();
     }
@@ -105 +105 @@
 Outcome::context() const
 {
-    if (!_contextPtr.isnull()) {
+    if (!_contextPtr.isNull()) {
         return _contextPtr->data();
     }

trunk/src2/core/RpPtr.h

@@ -87 +87 @@
 class Ptr {
 public:
-    explicit Ptr(Type* ptr);
+    explicit Ptr(Type* ptr=NULL);
     Ptr(const Ptr& ptr);
     Ptr& operator=(Type* ptr);
@@ -93 +93 @@
     ~Ptr();
 
-    int isnull() const;
+    int isNull() const;
     Type* operator->() const;
     Type* pointer() const;
+    Type& operator*() const;
     void clear();
 
@@ -154 +155 @@
 template <class Type>
 int
-Ptr<Type>::isnull() const
+Ptr<Type>::isNull() const
 {
     if (_pc) {
@@ -183 +184 @@
 
 template <class Type>
+Type&
+Ptr<Type>::operator*() const
+{
+    assert(_pc != NULL);
+    return *(Type*)_pc->pointer();
+}
+
+template <class Type>
 void
 Ptr<Type>::clear()

trunk/src2/core/RpSerializable.cc

@@ -21 +21 @@
 
 // initialize the global lists of registered serialization helper funcs
-Serializable::_name2createFunc = NULL;
-Serializable::_name2desMethod = NULL;
+Serializable::Name2ConvFuncsMap* Serializable::_name2convFuncs = NULL;
 
 Serializable::Serializable()
@@ -42 +41 @@
     cname += serializerVersion();
 
-    ConversionFuncs& cfuncs = (*_name2convFuncs)[cname];
-    this->(cfuncs.serialMethod)(buffer);
+    Serializable::ConversionFuncs& cfuncs = (*_name2convFuncs)[cname];
+    (this->*(cfuncs.serialMethod))(buffer);
 }
 
 Outcome
-Serializable::deserialize(SerialBuffer& buffer, Ptr<Serializable>& objPtr)
+Serializable::deserialize(SerialBuffer& buffer, Ptr<Serializable>* objPtrPtr)
 {
     Outcome result;
@@ -66 +65 @@
 
     ConversionFuncs& cfuncs = (*_name2convFuncs)[type];
-    objPtr = (cfuncs.createFunc)();
-    return objPtr->(cfuncs.deserialMethod)(buffer);
+    *objPtrPtr = (cfuncs.createFunc)();
+
+    Serializable *objPtr = objPtrPtr->pointer();
+    return (objPtr->*(cfuncs.deserialMethod))(buffer);
 }
 
-SerialConversion::SerialConversion(const char *class, char version,
-    Serializable::serializeObjectMethod serMethod)
+SerialConversion::SerialConversion(const char *className, char version,
+    Serializable::serializeObjectMethod serMethod,
     Serializable::createObjectFunc createFunc,
     Serializable::deserializeObjectMethod desMethod)
 {
-    if (Serializer::_name2convFuncs == NULL) {
-        Serializer::_name2convFuncs = new Name2ConvFuncsMap;
+    if (Serializable::_name2convFuncs == NULL) {
+        Serializable::_name2convFuncs = new Serializable::Name2ConvFuncsMap();
     }
 
     // register the conversion functions for this version
-    std::string vname(class);
+    std::string vname(className);
     vname += ":";
     vname += version;
 
-    ConversionFuncs& funcs = (*_name2convFuncs)[vname];
+    Serializable::ConversionFuncs& funcs
+        = (*Serializable::_name2convFuncs)[vname];
 
     funcs.version = version;
@@ -92 +94 @@
 
     // if this is the latest version, register it as "current"
-    std::string cname(class);
+    std::string cname(className);
     cname += ":current";
 
-    Name2ConvFuncsMap::iterator iter = _name2convFuncs->find(cname);
-    if (iter == _name2convFuncs->end()) {
+    Serializable::Name2ConvFuncsMap::iterator iter
+        = Serializable::_name2convFuncs->find(cname);
+
+    if (iter == Serializable::_name2convFuncs->end()) {
         // this is the first -- register it as "current"
-        ConversionFuncs& cfuncs = (*_name2convFuncs)[cname];
+        Serializable::ConversionFuncs& cfuncs
+            = (*Serializable::_name2convFuncs)[cname];
         cfuncs.version = version;
         cfuncs.serialMethod = serMethod;
@@ -104 +109 @@
         cfuncs.deserialMethod = desMethod;
     } else {
-        ConversionFuncs& cfuncs = (*_name2convFuncs)[cname];
+        Serializable::ConversionFuncs& cfuncs
+            = (*Serializable::_name2convFuncs)[cname];
+
         if (cfuncs.version < version) {
             // this is the latest -- register it as "current"

trunk/src2/core/RpSerializable.h

@@ -21 +21 @@
 #include <string>
 #include <map>
+#include "RpPtr.h"
+#include "RpOutcome.h"
 #include "RpSerialBuffer.h"
 
@@ -32 +34 @@
     virtual ~Serializable();
 
-    virtual const char* serializerType() = 0;
-    virtual char serializerVersion() = 0;
+    virtual const char* serializerType() const = 0;
+    virtual char serializerVersion() const = 0;
 
     virtual void serialize(SerialBuffer& bufferPtr) const;
-    static Outcome deserialize(SerialBuffer& buffer, Ptr<Serializable>& objPtr);
+    static Outcome deserialize(SerialBuffer& buffer, Ptr<Serializable>* objPtrPtr);
+
+    typedef void (Serializable::*serializeObjectMethod)(SerialBuffer& buffer) const;
+    typedef Ptr<Serializable> (*createObjectFunc)();
+    typedef Outcome (Serializable::*deserializeObjectMethod)(SerialBuffer& buffer);
 
 private:
     friend class SerialConversion;
 
-    typedef void serializeObjectMethod(SerialBuffer& buffer) const;
-    typedef static Ptr<Serializable> createObjectFunc();
-    typedef Outcome deserializeObjectMethod(SerialBuffer& buffer);
-
-    struct ConversionFuncs {
+    class ConversionFuncs {
+    public:
         char version;
         serializeObjectMethod serialMethod;
@@ -52 +55 @@
     };
 
-    typedef map<std::string, ConversionFuncs> Name2ConvFuncsMap;
+    typedef std::map<std::string, ConversionFuncs> Name2ConvFuncsMap;
     static Name2ConvFuncsMap *_name2convFuncs;
 };
@@ -58 +61 @@
 class SerialConversion {
 public:
-    SerialConversion(const char *class, char version,
+    SerialConversion(const char *className, char version,
         Serializable::serializeObjectMethod,
         Serializable::createObjectFunc,

trunk/src2/core/RpSerializer.cc

@@ -73 +73 @@
 
         // if there was an error, then bail out
-        if (!result) {
+        if (result != 0) {
             std::ostringstream context;
             context << "while deserializing object #" << i+1
               << " of " << nobj;
-            return result.addContext(context.str());
+            return result.addContext(context.str().data());
         }
 
@@ -106 +106 @@
         bufferPtr->writeString("RpObj:");
         bufferPtr->writeString(id);
-        objPtr->serialize(bufferPtr);
+        objPtr->serialize(*bufferPtr.pointer());
     }
     return bufferPtr;
@@ -120 +120 @@
 Serializer::get(int pos) const
 {
+    Serializer *nonconst = (Serializer*)this;
     assert(pos >= 0 && pos < _idlist.size());
 
     std::string id(_idlist[pos]);
-    return _id2obj[id];
+    return nonconst->_id2obj[id];
 }
 
@@ -134 +135 @@
 
 const char*
-Serializer::register(Ptr<Serializable> objPtr)
+Serializer::add(Serializable* objPtr)
 {
     const char* key = NULL;
@@ -140 +141 @@
     // build a unique string that represents this object
     std::ostringstream idbuffer;
-    idbuffer << (void*)objPtr.pointer();
+    idbuffer << (void*)objPtr;
     std::string id(idbuffer.str());
 
@@ -147 +148 @@
     if (iter == _id2obj.end()) {
         // if not, then add to map and also to list of all objects
-        _id2obj[id] = objPtr;
+        _id2obj[id] = Ptr<Serializable>(objPtr);
         iter = _id2obj.find(id);
         key = (*iter).first.data();
@@ -154 +155 @@
         // if so, then update map
         key = (*iter).first.data();
-        _id2obj[id] = objPtr;
+        _id2obj[id] = Ptr<Serializable>(objPtr);
     }
     return key;

trunk/src2/core/RpSerializer.h

@@ -21 +21 @@
 #include <map>
 #include "RpPtr.h"
+#include "RpOutcome.h"
 #include "RpSerialBuffer.h"
+#include "RpSerializable.h"
 
 namespace Rappture {
@@ -30 +32 @@
     virtual ~Serializer();
 
+    virtual Ptr<SerialBuffer> serialize();
     virtual Outcome deserialize(const char* bytes, int nbytes);
-    virtual Ptr<SerialBuffer> serialize();
 
     virtual int size() const;
@@ -37 +39 @@
 
     virtual Serializer& clear();
-    virtual const char* register(Ptr<Serializable> objPtr);
+    virtual const char* add(Serializable* objPtr);
 
 private:
@@ -48 +50 @@
 
     // map each id in _idlist to the corresponding object
-    typedef std::map<std::string, Ptr<Serializable>> SerializerId2Obj;
+    typedef std::map<std::string, Ptr<Serializable> > SerializerId2Obj;
     SerializerId2Obj _id2obj;
 };

trunk/src2/core/test.cc

@@ -6 +6 @@
 #include "RpNode.h"
 #include "RpField1D.h"
+#include "RpMeshTri2D.h"
+#include "RpFieldTri2D.h"
 #include "RpMeshRect3D.h"
 #include "RpFieldRect3D.h"
+#include "RpMeshPrism3D.h"
+#include "RpFieldPrism3D.h"
 #include "RpSerialBuffer.h"
-////#include "RpSerializable.h"
+#include "RpSerializer.h"
 
 class Foo {
@@ -67 +71 @@
     std::cout << "@ 8.8 = " << f.value(8.8) << std::endl;
 
-    Rappture::SerialBuffer buffer;
-    buffer.writeChar('a');
-    buffer.writeInt(1051);
-    buffer.writeDouble(2.51e12);
-    buffer.writeString("xyz");
-    buffer.writeString("pdq");
-
-    buffer.rewind();
-    std::cout << "buffer: ";
-    std::cout << buffer.readChar() << " ";
-    std::cout << buffer.readInt() << " ";
-    std::cout << buffer.readDouble() << " ";
-    std::cout << buffer.readString() << " ";
-    std::cout << buffer.readString() << std::endl;
-
-    Rappture::Mesh1D uni(1.0,5.0,16);
-    showmesh(uni);
+    Rappture::Ptr<Rappture::Mesh1D> uni(
+        new Rappture::Mesh1D(1.0,5.0,16)
+    );
+    showmesh(*uni);
 
     Rappture::Mesh1D uniy(0.0,2.0,10);
     Rappture::Mesh1D uniz(-1.0,1.0,20);
     Rappture::Ptr<Rappture::MeshRect3D> m3dPtr(
-        new Rappture::MeshRect3D(uni, uniy, uniz)
+        new Rappture::MeshRect3D(*uni, uniy, uniz)
     );
-    Rappture::FieldRect3D f3d(m3dPtr);
+    Rappture::Ptr<Rappture::FieldRect3D> f3d(
+        new Rappture::FieldRect3D(*uni, uniy, uniz)
+    );
 
     int n=0;
-    for (int iz=0; iz < f3d.size(Rappture::zaxis); iz++) {
-        double zval = f3d.nodeAt(Rappture::zaxis, iz).x();
-        for (int iy=0; iy < f3d.size(Rappture::yaxis); iy++) {
-            double yval = f3d.nodeAt(Rappture::yaxis, iy).x();
-            for (int ix=0; ix < f3d.size(Rappture::xaxis); ix++) {
-                double xval = f3d.nodeAt(Rappture::xaxis, ix).x();
-                f3d.define(n++, xval*yval*zval);
+    for (int iz=0; iz < f3d->size(Rappture::zaxis); iz++) {
+        double zval = f3d->atNode(Rappture::zaxis, iz).x();
+        for (int iy=0; iy < f3d->size(Rappture::yaxis); iy++) {
+            double yval = f3d->atNode(Rappture::yaxis, iy).x();
+            for (int ix=0; ix < f3d->size(Rappture::xaxis); ix++) {
+                double xval = f3d->atNode(Rappture::xaxis, ix).x();
+                f3d->define(n++, xval*yval*zval);
             }
         }
     }
 
-    std::cout << "at (1,0,-0.5) " << f3d.value(1.0,0.0,-0.5) << std::endl;
-    std::cout << "at (2,1,-0.5) " << f3d.value(2.0,1.0,-0.5) << std::endl;
-    std::cout << "at (3,0.7,-0.2) " << f3d.value(3.0,0.7,-0.2) << std::endl;
-    std::cout << "at (5,2,1) " << f3d.value(5.0,2.0,1.0) << std::endl;
+    std::cout << "at (1,0,-0.5) " << f3d->value(1.0,0.0,-0.5) << std::endl;
+    std::cout << "at (2,1,-0.5) " << f3d->value(2.0,1.0,-0.5) << std::endl;
+    std::cout << "at (3,0.7,-0.2) " << f3d->value(3.0,0.7,-0.2) << std::endl;
+    std::cout << "at (5,2,1) " << f3d->value(5.0,2.0,1.0) << std::endl;
 
-    Rappture::Ptr<Foo> ptr3(new Foo("q"));
-    std::ostringstream ss;
-    ss << (void*)ptr3.pointer();
-    std::cout << ss << std::endl;
 
-    Rappture::Outcome status = foo(1);
-    if (status) {
-        status.addContext("while in main program");
-        std::cout << status.remark() << std::endl;
-        std::cout << status.context() << std::endl;
+    Rappture::MeshTri2D m2d;
+    m2d.addNode( Rappture::Node2D(0.0,0.0) );
+    m2d.addNode( Rappture::Node2D(1.0,0.0) );
+    m2d.addNode( Rappture::Node2D(0.0,1.0) );
+    m2d.addNode( Rappture::Node2D(1.0,1.0) );
+    m2d.addNode( Rappture::Node2D(2.0,0.0) );
+    m2d.addNode( Rappture::Node2D(2.0,1.0) );
+    m2d.addCell(0,1,2);
+    m2d.addCell(1,2,3);
+    m2d.addCell(1,3,4);
+    m2d.addCell(3,4,5);
+
+    Rappture::FieldTri2D f2d(m2d);
+    f2d.define(0, 0.0);
+    f2d.define(1, 1.0);
+    f2d.define(2, 1.0);
+    f2d.define(3, 4.0);
+    f2d.define(4, 2.0);
+    f2d.define(5, 2.0);
+    std::cout << "value @(0.1,0.1): " << f2d.value(0.1,0.1) << std::endl;
+    std::cout << "value @(0.99,0.99): " << f2d.value(0.99,0.99) << std::endl;
+    std::cout << "value @(1.99,0.01): " << f2d.value(1.99,0.01) << std::endl;
+    std::cout << "value @(2.01,0.02): " << f2d.value(2.01,1.02) << std::endl;
+
+    Rappture::FieldPrism3D fp3d(m2d, uniy);
+    for (int i=0; i < 10; i++) {
+        fp3d.define(i*6+0, (i+1)*0.0);
+        fp3d.define(i*6+1, (i+1)*1.0);
+        fp3d.define(i*6+2, (i+1)*1.0);
+        fp3d.define(i*6+3, (i+1)*4.0);
+        fp3d.define(i*6+4, (i+1)*2.0);
+        fp3d.define(i*6+5, (i+1)*2.0);
+    }
+    std::cout << "value @(0.1,0.1,0.01): " << fp3d.value(0.1,0.1,0.01) << std::endl;
+    std::cout << "value @(0.1,0.1,0.21): " << fp3d.value(0.1,0.1,0.21) << std::endl;
+    std::cout << "value @(0.1,0.1,0.41): " << fp3d.value(0.1,0.1,0.41) << std::endl;
+    std::cout << "value @(0.99,0.99,0.01): " << fp3d.value(0.99,0.99,0.01) << std::endl;
+    std::cout << "value @(0.99,0.99,0.21): " << fp3d.value(0.99,0.99,0.21) << std::endl;
+    std::cout << "value @(0.99,0.99,0.41): " << fp3d.value(0.99,0.99,0.41) << std::endl;
+
+
+    std::cout << "original mesh:" << std::endl;
+    showmesh( *uni );
+    Rappture::Serializer objs;
+    objs.add( uni.pointer() );
+    Rappture::Ptr<Rappture::SerialBuffer> buffer = objs.serialize();
+
+    Rappture::Serializer objs2;
+    Rappture::Outcome err = objs2.deserialize(buffer->bytes(), buffer->size());
+
+    if (err) {
+        err.addContext("while in main program");
+        std::cout << err.remark() << std::endl;
+        std::cout << err.context() << std::endl;
         exit(1);
     }
+
+    Rappture::Ptr<Rappture::Serializable> uni2ptr = objs2.get(0);
+    Rappture::Ptr<Rappture::Mesh1D> uni2( (Rappture::Mesh1D*)uni2ptr.pointer() );
+    std::cout << "reconstituted mesh:" << std::endl;
+    showmesh( *uni2 );
+
     exit(0);
 }

trunk/src2/core/viz.cc

@@ -5 +5 @@
 #include <string>
 #include "RpFieldRect3D.h"
+#include "RpFieldPrism3D.h"
 
 /* Load a 3D volume from a dx-format file
@@ -10 +11 @@
 void
 load_volume_file(int index, char *fname) {
-    int dummy, nx, ny, nz, npts;
+    Rappture::MeshTri2D xymesh;
+    int dummy, nx, ny, nz, nxy, npts;
     double x0, y0, z0, dx, dy, dz, ddx, ddy, ddz;
-    char line[128], *start;
+    char line[128], type[128], *start;
     std::ifstream fin(fname);
+
+    int isrect = 1;
 
     do {
@@ -23 +27 @@
             if (sscanf(start, "object %d class gridpositions counts %d %d %d", &dummy, &nx, &ny, &nz) == 4) {
                 // found grid size
+                isrect = 1;
+            }
+            else if (sscanf(start, "object %d class array type float rank 1 shape 3 items %d data follows", &dummy, &nxy) == 2) {
+                std::ofstream ftmp("tmppts");
+                double xx, yy, zz;
+                isrect = 0;
+                for (int i=0; i < nxy; i++) {
+                    fin.getline(line,sizeof(line)-1);
+                    if (sscanf(line, "%lg %lg %lg", &xx, &yy, &zz) == 3) {
+                        xymesh.addNode( Rappture::Node2D(xx,yy) );
+                        ftmp << xx << " " << yy << std::endl;
+                    }
+                }
+                ftmp.close();
+
+                if (system("voronoi -t < tmppts > tmpcells") == 0) {
+                    int cx, cy, cz;
+                    std::ifstream ftri("tmpcells");
+                    while (!ftri.eof()) {
+                        ftri.getline(line,sizeof(line)-1);
+                        if (sscanf(line, "%d %d %d", &cx, &cy, &cz) == 3) {
+                            xymesh.addCell(cx, cy, cz);
+                        }
+                    }
+                    ftri.close();
+                } else {
+                    std::cerr << "WARNING: triangularization failed" << std::endl;
+                }
+            }
+            else if (sscanf(start, "object %d class regulararray count %d", &dummy, &nz) == 2) {
+                // found z-grid
             }
             else if (sscanf(start, "origin %lg %lg %lg", &x0, &y0, &z0) == 3) {
@@ -33 +68 @@
                 else if (ddz != 0.0) { dz = ddz; }
             }
-            else if (sscanf(start, "object %d class array type double rank 0 items %d data follows", &dummy, &npts) == 2) {
-                if (npts != nx*ny*nz) {
+            else if (sscanf(start, "object %d class array type %s rank 0 items %d data follows", &dummy, type, &npts) == 3) {
+                if (isrect && (npts != nx*ny*nz)) {
                     std::cerr << "inconsistent data: expected " << nx*ny*nz << " points but found " << npts << " points" << std::endl;
                     return;
                 }
+                else if (!isrect && (npts != nxy*nz)) {
+                    std::cerr << "inconsistent data: expected " << nxy*nz << " points but found " << npts << " points" << std::endl;
+                    return;
+                }
                 break;
-            }
-            else if (sscanf(start, "object %d class gridconnections", &dummy) == 1) {
-                // ignore this
             }
         }
@@ -48 +84 @@
     // read data points
     if (!fin.eof()) {
-        Rappture::Mesh1D xgrid(x0, x0+nx*dx, nx);
-        Rappture::Mesh1D ygrid(y0, y0+ny*dy, ny);
-        Rappture::Mesh1D zgrid(z0, z0+nz*dz, nz);
-        Rappture::FieldRect3D field(xgrid, ygrid, zgrid);
+        if (isrect) {
+            Rappture::Mesh1D xgrid(x0, x0+nx*dx, nx);
+            Rappture::Mesh1D ygrid(y0, y0+ny*dy, ny);
+            Rappture::Mesh1D zgrid(z0, z0+nz*dz, nz);
+            Rappture::FieldRect3D field(xgrid, ygrid, zgrid);
 
-        double dval;
-        int nread = 0;
-        while (!fin.eof()) {
-            if (!(fin >> dval).fail()) {
-                field.define(nread++, dval);
+            double dval;
+            int nread = 0;
+            while (!fin.eof() && nread < npts) {
+                if (!(fin >> dval).fail()) {
+                    field.define(nread++, dval);
+                }
             }
-        }
 
-        // make sure that we read all of the expected points
-        if (nread != nx*ny*nz) {
-            std::cerr << "inconsistent data: expected " << nx*ny*nz << " points but found " << nread << " points" << std::endl;
-            return;
-        }
+            // make sure that we read all of the expected points
+            if (nread != nx*ny*nz) {
+                std::cerr << "inconsistent data: expected " << nx*ny*nz << " points but found " << nread << " points" << std::endl;
+                return;
+            }
 
-        // figure out a good mesh spacing
-        int nsample = 100;
-        dx = field.rangeMax(Rappture::xaxis) - field.rangeMin(Rappture::xaxis);
-        dy = field.rangeMax(Rappture::yaxis) - field.rangeMin(Rappture::yaxis);
-        dz = field.rangeMax(Rappture::zaxis) - field.rangeMin(Rappture::zaxis);
-        double dmin = pow((dx*dy*dz)/(nsample*nsample*nsample), 0.333);
+            // figure out a good mesh spacing
+            int nsample = 100;
+            dx = field.rangeMax(Rappture::xaxis) - field.rangeMin(Rappture::xaxis);
+            dy = field.rangeMax(Rappture::yaxis) - field.rangeMin(Rappture::yaxis);
+            dz = field.rangeMax(Rappture::zaxis) - field.rangeMin(Rappture::zaxis);
+            double dmin = pow((dx*dy*dz)/(nsample*nsample*nsample), 0.333);
 
-        nx = (int)ceil(dx/dmin);
-        ny = (int)ceil(dy/dmin);
-        nz = (int)ceil(dz/dmin);
-        float *data = new float[nx*ny*nz];
-        std::cout << "generating " << nx << "x" << ny << "x" << nz << " = " << nx*ny*nz << " points" << std::endl;
+            nx = (int)ceil(dx/dmin);
+            ny = (int)ceil(dy/dmin);
+            nz = (int)ceil(dz/dmin);
+            float *data = new float[nx*ny*nz];
+            std::cout << "generating " << nx << "x" << ny << "x" << nz << " = " << nx*ny*nz << " points" << std::endl;
 
-        // generate the uniformly sampled data that we need for a volume
-        int ngen = 0;
-        for (int iz=0; iz < nz; iz++) {
-            double zval = z0 + iz*dmin;
-            for (int iy=0; iy < ny; iy++) {
-                double yval = y0 + iy*dmin;
-                for (int ix=0; ix < nx; ix++) {
-                    double xval = x0 + ix*dmin;
-                    data[ngen++] = field.value(xval,yval,zval);
+            // generate the uniformly sampled data that we need for a volume
+            int ngen = 0;
+            for (int iz=0; iz < nz; iz++) {
+                double zval = z0 + iz*dmin;
+                for (int iy=0; iy < ny; iy++) {
+                    double yval = y0 + iy*dmin;
+                    for (int ix=0; ix < nx; ix++) {
+                        double xval = x0 + ix*dmin;
+                        data[ngen++] = field.value(xval,yval,zval);
+                    }
+                }
+            }
+        } else {
+            Rappture::Mesh1D zgrid(z0, z0+nz*dz, nz);
+            Rappture::FieldPrism3D field(xymesh, zgrid);
+
+            double dval;
+            int nread = 0;
+            while (!fin.eof() && nread < npts) {
+                if (!(fin >> dval).fail()) {
+                    field.define(nread++, dval);
+                }
+            }
+
+            // make sure that we read all of the expected points
+            if (nread != nxy*nz) {
+                std::cerr << "inconsistent data: expected " << nxy*nz << " points but found " << nread << " points" << std::endl;
+                return;
+            }
+
+            // figure out a good mesh spacing
+            int nsample = 100;
+            dx = field.rangeMax(Rappture::xaxis) - field.rangeMin(Rappture::xaxis);
+            dy = field.rangeMax(Rappture::yaxis) - field.rangeMin(Rappture::yaxis);
+            dz = field.rangeMax(Rappture::zaxis) - field.rangeMin(Rappture::zaxis);
+            double dmin = pow((dx*dy*dz)/(nsample*nsample*nsample), 0.333);
+
+            nx = (int)ceil(dx/dmin);
+            ny = (int)ceil(dy/dmin);
+            nz = (int)ceil(dz/dmin);
+            float *data = new float[nx*ny*nz];
+            std::cout << "generating " << nx << "x" << ny << "x" << nz << " = " << nx*ny*nz << " points" << std::endl;
+
+            // generate the uniformly sampled data that we need for a volume
+            int ngen = 0;
+            for (int iz=0; iz < nz; iz++) {
+                double zval = z0 + iz*dmin;
+                for (int iy=0; iy < ny; iy++) {
+                    double yval = y0 + iy*dmin;
+                    for (int ix=0; ix < nx; ix++) {
+                        double xval = x0 + ix*dmin;
+                        data[ngen++] = field.value(xval,yval,zval);
+                    }
                 }
             }