network.h

Go to the documentation of this file.

/*== SAGITTARIUS =====================================================================
 * Copyright (c) 2012, Jesse K Medley
 * All rights reserved.

 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.
    * Neither the name of The University of Washington nor the
      names of its contributors may be used to endorse or promote products
      derived from this software without specific prior written permission.

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

//== FILEDOC =========================================================================

//== BEGINNING OF CODE ===============================================================

#ifndef __SBNW_NETWORK_H_
#define __SBNW_NETWORK_H_

//== INCLUDES ========================================================================

#include "graphfab/core/SagittariusCore.h"
#include "graphfab/layout/point.h"
#include "graphfab/layout/curve.h"
#include "graphfab/layout/box.h"
#include "graphfab/math/transform.h"

//-- C++ code --
#ifdef __cplusplus

#include "graphfab/sbml/autolayoutSBML.h"

#include "sbml/SBMLTypes.h"
#include "sbml/packages/layout/common/LayoutExtensionTypes.h"

#include <string>
#include <iostream>
#include <typeinfo>
#include <stdint.h>

namespace Graphfab {
    
    typedef enum {
        NET_ELT_TYPE_SPEC,
        NET_ELT_TYPE_RXN,
        NET_ELT_TYPE_COMP
    } NetworkEltType;
    
    std::string eltTypeToStr(const NetworkEltType t);
    
    void dumpEltType(std::ostream& os, const NetworkEltType t, uint32 ind);
    
    inline bool typeMatchEither(const NetworkEltType a, const NetworkEltType b, const NetworkEltType z) {
        if(a == z)
            return true;
        else if(b == z)
            return true;
        else
            return false;
    }
    
    class Compartment;

    bool haveDefaultCompartmentId();

    void setDefaultCompartmentId(const std::string& id);

    std::string getDefaultCompartmentId();

    class SubCurve : public RxnBezier {
        public:
            RxnCurveType getRole() const {
                return RXN_CURVE_SUBSTRATE;
            }

            Point getCentroidCP() const { return c2; }

            bool isStartNodeSide() const { return true; }

            virtual bool hasArrowhead() const { return true; }

            ArrowheadStyle getArrowheadStyle() const;

            virtual Arrowhead* getArrowhead() {
              Arrowhead* result = new SubstrateArrowhead();
              transformArrowhead(*result);
              return result;
            }
    };

    class PrdCurve : public RxnBezier {
        public:
            RxnCurveType getRole() const {
                return RXN_CURVE_PRODUCT;
            }

            Point getCentroidCP() const { return c1; }

            bool isStartNodeSide() const { return false; }

            virtual bool hasArrowhead() const { return true; }

            ArrowheadStyle getArrowheadStyle() const;

            virtual Arrowhead* getArrowhead() {
              Arrowhead* result = new ProductArrowhead();
              transformArrowhead(*result);
              return result;
            }
    };

    class ActCurve : public RxnBezier {
        public:
            RxnCurveType getRole() const {
                return RXN_CURVE_ACTIVATOR;
            }

            Point getCentroidCP() const { return c2; }

            bool isStartNodeSide() const { return true; }

            virtual bool hasArrowhead() const { return true; }

            ArrowheadStyle getArrowheadStyle() const;

            virtual Arrowhead* getArrowhead() {
              Arrowhead* result = new ActivatorArrowhead();
              transformArrowhead(*result);
              return result;
            }
    };

    class InhCurve : public RxnBezier {
        public:
            RxnCurveType getRole() const {
                return RXN_CURVE_INHIBITOR;
            }

            Point getCentroidCP() const { return c2; }

            bool isStartNodeSide() const { return true; }

            virtual bool hasArrowhead() const { return true; }

            ArrowheadStyle getArrowheadStyle() const;

            virtual Arrowhead* getArrowhead() {
              Arrowhead* result = new InhibitorArrowhead();
              transformArrowhead(*result);
              return result;
            }
    };

    class ModCurve : public RxnBezier {
        public:
            RxnCurveType getRole() const {
                return RXN_CURVE_MODIFIER;
            }

            Point getCentroidCP() const { return c2; }

            bool isStartNodeSide() const { return true; }

            virtual bool hasArrowhead() const { return true; }

            ArrowheadStyle getArrowheadStyle() const;

            virtual Arrowhead* getArrowhead() {
              Arrowhead* result = new ModifierArrowhead();
              transformArrowhead(*result);
              return result;
            }
    };

    extern ArrowheadStyle sub_arrow_style_;
    inline ArrowheadStyle ArrowheadStyleLookup(const SubCurve* ) {
      return sub_arrow_style_;
    }

    extern ArrowheadStyle prod_arrow_style_;
    inline ArrowheadStyle ArrowheadStyleLookup(const PrdCurve* ) {
      return prod_arrow_style_;
    }

    extern ArrowheadStyle act_arrow_style_;
    inline ArrowheadStyle ArrowheadStyleLookup(const ActCurve* ) {
      return act_arrow_style_;
    }

    extern ArrowheadStyle inh_arrow_style_;
    inline ArrowheadStyle ArrowheadStyleLookup(const InhCurve* ) {
      return inh_arrow_style_;
    }

    extern ArrowheadStyle mod_arrow_style_;
    inline ArrowheadStyle ArrowheadStyleLookup(const ModCurve* ) {
      return mod_arrow_style_;
    }
    
    typedef enum {
        ELT_SHAPE_ROUND,
        ELT_SHAPE_RECT
    } NetworkEltShape;
    
    class NetworkElement {
        public:

            enum COORD_SYSTEM {
              COORD_SYSTEM_LOCAL,
              COORD_SYSTEM_GLOBAL
            };
            
            NetworkElement()
                : _pset(0), _v(0,0), _deg(0), _ldeg(0), _lock(0), networkEltBytePattern_(0x1199) {}
            
            NetworkEltType getType() const { return _type; }
            
            bool hasNetworkElementBase() {
                if(networkEltBytePattern_ == 0x1199)
                    return true;
                else
                    return false;
            }
            
            void set_degree(uint64 deg) { _deg = deg; }
            virtual uint64 degree() const { return _deg; }
            virtual uint64& degree() { return _deg; }
            
            virtual void resetActivity();
            
            void addDelta(const Point& d);
            
            void capDelta(const Real cap);
            
            virtual void capDelta2(const Real cap2);
            
            virtual void doMotion(const Real scale);
            
            virtual void setCentroid(const Point& p);
            virtual void setGlobalCentroid(const Point& p);
            void setCentroid(Real x, Real y) { setCentroid(Point(x,y)); }
            
            virtual bool isCentroidSet() const { return _pset; }
            
            virtual Point getCentroid(COORD_SYSTEM coord = COORD_SYSTEM_LOCAL) const;
            
//             SAGITTARIUS_DEPRECATED(Point getGlobalCentroid() const) { return tf_*_p; }
            
            Point getMin(COORD_SYSTEM coord = COORD_SYSTEM_LOCAL) const { return getExtents(coord).getMin(); }
            Point getMax(COORD_SYSTEM coord = COORD_SYSTEM_LOCAL) const { return getExtents(coord).getMax(); }
            
            Real getMinX() const { return getExtents().getMin().x; }
            Real getMaxX() const { return getExtents().getMax().x; }
            Real getMinY() const { return getExtents().getMin().y; }
            Real getMaxY() const { return getExtents().getMax().y; }
            
            Real getWidth() const { AT(getMaxX() >= getMinX()); return getMaxX() - getMinX(); }
            Real getHeight() const { AT(getMaxY() >= getMinY()); return getMaxY() - getMinY(); }
            
            Real getGlobalWidth() const { AT(getMaxX() >= getMinX()); return (getMaxX() - getMinX())*tf_.scaleFactor(); }
            Real getGlobalHeight() const { AT(getMaxY() >= getMinY()); return (getMaxY() - getMinY())*tf_.scaleFactor(); }
            
            virtual Box getExtents(COORD_SYSTEM coord = COORD_SYSTEM_LOCAL) const {
              switch (coord) {
                case COORD_SYSTEM_LOCAL:
                  return getLocalExtents();
                case COORD_SYSTEM_GLOBAL:
                  return tf_*getLocalExtents();
                default:
                  AN(0, "Unknown coord system");
                  return getLocalExtents();
              }
            }

            virtual Box getLocalExtents() const {
              return _ext;
            }
//             virtual SAGITTARIUS_DEPRECATED(Box getGlobalExtents() const) { return tf_*_ext; }
            
            void setExtents(const Box& b) { _ext = b; recalcCentroid(); }
            
            Box getBoundingBox() const { return getExtents(); }
//             Box getBoundingBox() const { return Box(); }
            
            virtual void applyTransform(const Affine2d& t) {
                _ext = xformBox(_ext, t);
                _p = xformPoint(_p, t);
            }

            virtual void applyDisplacement(const Point& d) {
                _ext.displace(d);
                _p += d;
            }
            
            void recalcCentroid() { _p = (_ext.getMin() + _ext.getMax())*0.5; }
            
            virtual void recalcExtents() = 0;
            
            void lock() { _lock = 1; }
            
            void unlock() { _lock = 0; }

            // Is the node locked?
            bool isLocked() const { return _lock; }
            
            NetworkEltShape getShape() const { return _shape; }
            
            //TODO: cache in member & ditch v func
            virtual bool isContainer() const = 0;
            
            Real radius() const { return _r; }
            
            Real distance(const NetworkElement& e) const;
            
            bool overlap(const NetworkElement& e) const;
            
            // TODO: rename; is actually displacement
            Point forceVec(const NetworkElement& e) const;

            Point centroidDisplacementFrom(const NetworkElement& e) const;
            
            void forceVec_(const NetworkElement& e, Point& p) const;
            
            virtual void dump(std::ostream& os, uint32 ind) = 0;
            
            virtual void dumpForces(std::ostream& os, uint32 ind) const = 0;
            
            virtual Affine2d getTransform() const { return tf_; }
            
            virtual void setTransform(const Affine2d& tf, bool recurse = true) { tf_ = tf; }
            
            virtual Affine2d getInverseTransform() const { return itf_; }
            
            virtual void setInverseTransform(const Affine2d& itf, bool recurse = true) { itf_ = itf; }
            
            Point _p;
            uint64 _deg;
            uint64 _ldeg;
        protected:
            int _pset;
            Point _v;
            Box _ext;
            Real _r;
            NetworkEltShape _shape;
            NetworkEltType _type;
            int _lock;
            Affine2d tf_;
            Affine2d itf_;
            
            long networkEltBytePattern_;
    };

    class Network;

    class Node : public NetworkElement {
        public:
            
            Node()
                : NetworkElement() {
                    _shape = ELT_SHAPE_RECT;
                    _comp = NULL;
                    _type = NET_ELT_TYPE_SPEC;
                    _ext = Box(0,0,40,20);
                    bytepattern = 0xc455;
                    isub_ = -1;
                }
            
            // Model:
            
            void setName(const std::string& name);

            const std::string& getName() const;
            
            const std::string& getId() const;
            
            void setId(const std::string& id);
            
            const std::string& getGlyph() const;
            
            void setGlyph(const std::string& id);
            
            // Alias info:
            
            uint32& numUses() { return _numUses; }
            uint32 numUses() const { return _numUses; }
            
            //TODO: change to isAliased. There is no such thing as an "alias node"
            bool isAlias() const { return _isAlias; }

            bool isCommonInstance(const Node* other) const;
            
            void setAlias(bool b) { _isAlias = b; }

            int alias(Network* net);

            int getSubgraphIndex() const {
                if (isub_ < 0)
                    SBNW_THROW(InvalidParameterException, "No subgraph index set", "Network::getSubgraphIndex");
                return isub_;
            }

            void setSubgraphIndex(int v) { isub_ = v; }

            bool isSetSubgraphIndex() { return isub_ < 0; }

            void clearSubgraphIndex() { isub_ = -1; }

            bool excludeFromSubgraphEnum() const { return exsub_; }

            bool setExcludeFromSubgraphEnum() { return exsub_ = true; }

            void clearExcludeFromSubgraphEnum() { exsub_ = false; }
            
            // Coordinates/dimensions:
            
            Point getUpperLeftCorner() const;
            Point getLowerRightCorner() const;
            
            void recalcExtents() {
                Real width = _ext.width();
                Real height = _ext.height();
                Point del(0.5*width, 0.5*height);
                
                _ext = Box(_p - del, _p + del);
                _r = _ext.maxDim()*0.5;
            }
            
            void setWidth(Real w);
            
            void setHeight(Real h);
            
            void affectGlobalWidth(Real w);
            
            void affectGlobalHeight(Real h);
            
            void set_i(size_t i) { i_ = i; } 
            size_t get_i() const { return i_; }
            
            // Layout:
            
            bool isContainer() const { return false; }
            
            // IO:
            
            void dump(std::ostream& os, uint32 ind);
            
            void dumpForces(std::ostream& os, uint32 ind) const;
            
            Compartment* _comp;
            
            bool doByteCheck() { if(bytepattern == 0xc455) return true; else return false; }
            
            long bytepattern;
        protected:
            // model info:
            std::string _name, _id;
            std::string _gly;
            // aliasing:
            uint32 _numUses;
            bool _isAlias;
            // rendering:
//             Real _hemiw, _hemih;
            
            // index in network
            size_t i_;
            int isub_;
            bool exsub_;
    };
    
    inline Node* CastToNode(void* p) {
        NetworkElement* e = (NetworkElement*)p;
        AN(e->hasNetworkElementBase(), "Runtime type check failed");
//         std::cout << typeid((Node&)*e).name() << std::endl;
        AN(dynamic_cast<Node*>(e), "Runtime type check failed");
        return dynamic_cast<Node*>(e);
//         Node* x = (Node*)e;
//         AN(x->doByteCheck(), "Runtime type check failed");
//         return x;
    }
    
    typedef enum {
        RXN_ROLE_SUBSTRATE,
        RXN_ROLE_PRODUCT,
        RXN_ROLE_SIDESUBSTRATE,
        RXN_ROLE_SIDEPRODUCT,
        RXN_ROLE_MODIFIER,
        RXN_ROLE_ACTIVATOR,
        RXN_ROLE_INHIBITOR,
    } RxnRoleType;

    class RxnCurveFactory {
        public:
            static RxnBezier* CreateCurve(RxnRoleType role);
    };
    
    class Reaction : public NetworkElement {
        public:
            // Exposed types:
            typedef std::pair<Node*, RxnRoleType> SpeciesElt;
            typedef std::vector< SpeciesElt > NodeVec;
            //typedef std::vector<RxnRoleType> RoleVec;
            typedef std::vector<RxnBezier*> CurveVec;
            
            // Iterators:
            typedef NodeVec::iterator NodeIt;
            typedef NodeVec::const_iterator ConstNodeIt;
            
            /*typedef RoleVec::iterator RoleIt;
            typedef RoleVec::const_iterator ConstRoleIt;*/
            
            typedef CurveVec::iterator CurveIt;
            typedef CurveVec::const_iterator ConstCurveIt;
            
            NodeIt NodesBegin() { return _spec.begin(); }
            NodeIt NodesEnd() { return _spec.end(); }
            
            ConstNodeIt NodesBegin() const { return _spec.begin(); }
            ConstNodeIt NodesEnd() const { return _spec.end(); }
            
            CurveIt CurvesBegin() { return _curv.begin(); }
            CurveIt CurvesEnd() { return _curv.end(); }
            
            ConstCurveIt CurvesBegin() const { return _curv.begin(); }
            ConstCurveIt CurvesEnd() const { return _curv.end(); }
            
            // Methods:
            
            Reaction()
                : NetworkElement() {
                    _shape = ELT_SHAPE_ROUND;
                    _type = NET_ELT_TYPE_RXN;
                    bytepattern = 0xff83;
                }
            
            void hierarchRelease();
            
            // Model:
            
            const std::string& getId() const { return _id; }
            
            void setId(const std::string& id) { _id = id; }

            void setName(const std::string& name) { name_ = name; }
            
            // Species:
            
            uint64 numSpecies() const { return _spec.size(); }
            
            void addSpeciesRef(Node* n, RxnRoleType role);
            
            void removeNode(Node* n);
            
            Node* findSpeciesById(const std::string& id);
            
            bool hasSpecies(const Node* n) const;

            uint64 degree(const Node* n);
            
            RxnRoleType getSpeciesRole(size_t i) { return _spec.at(i).second; }

            RxnRoleType getSpeciesRole(Node* n);
            
            Node* getSpecies(size_t i) { return _spec.at(i).first; }
            
            void substituteSpeciesById(const std::string& id, Node* spec);

            void substituteSpeciesByIdwRole(const std::string& id, Node* spec, RxnRoleType role);
            
            void substituteSpecies(Node* before, Node* after);
            
            CurveVec& getCurves();
            // this space intentionally left blank
            
            size_t getNumCurves() { curveGuard(); return _curv.size(); }
            
            
            RxnBezier* getCurve(size_t i) { curveGuard(); return _curv.at(i); }
            
            NodeVec& getSpec() { return _spec; }
            const NodeVec& getSpec() const { return _spec; }
            
            void forceRecalcCentroid();
            
            void rebuildCurves();
            
            void recalcCurveCPs();
            
            void recenter();
            
            // Layout
            
            bool isContainer() const { return false; }
            
            void recalcExtents() {
                _r = 10.;
                _ext = Box(_p - Point(_r,_r), _p + Point(_r,_r));
            }

            virtual Box getLocalExtents() const {
              return Box(getCentroid() - Point(5, 5), getCentroid() + Point(5, 5));
            }
            
            virtual void applyTransform(const Affine2d& t) {
                NetworkElement::applyTransform(t);
                for(CurveIt i = CurvesBegin(); i != CurvesEnd(); ++i) {
                    (*i)->applyTransform(t);
                }
            }
            
            virtual void setTransform(const Affine2d& tf, bool recurse = true) {
                tf_ = tf;
                for(CurveIt i = CurvesBegin(); i != CurvesEnd(); ++i) {
                    (*i)->setTransform(tf);
                }
            }
            
            virtual void setInverseTransform(const Affine2d& itf, bool recurse = true) {
                itf_ = itf;
                for(CurveIt i = CurvesBegin(); i != CurvesEnd(); ++i) {
                    (*i)->setInverseTransform(itf);
                }
            }
            
            // IO
            void dump(std::ostream& os, uint32 ind);
            
            void dumpForces(std::ostream& os, uint32 ind) const;
            
            bool doByteCheck() { if(bytepattern == 0xff83) return true; else return false; }

            void clearDirtyFlag() { _cdirty = false; }

            RxnBezier* addCurve(RxnRoleType role) {
                _curv.push_back(RxnCurveFactory::CreateCurve(role));
                _curv.back()->setTransform(itf_);
                _curv.back()->setInverseTransform(itf_);
                return _curv.back();
            }

            void deleteCurves();
            
        protected:
            // Methods:
            
            void rebuildAll();
            
            void recompCentroid();

            void doCentroidCalc();
            
            void curveGuard() {
                if(_cdirty && _spec.size()) {
                    rebuildCurves();
//                     recenter();
                }
            }
            
            // Variables:
            // model:
            std::string _id;
            std::string name_;
            // dims:
            Point _v;
            //NodeVec _rct;
            //NodeVec _prd;
            NodeVec _spec;
            //RoleVec _role;
            CurveVec _curv;
            bool _cdirty;
            
            long bytepattern;
    };
    
    inline Reaction* CastToReaction(void* p) {
        NetworkElement* e = (NetworkElement*)p;
        AN(e->hasNetworkElementBase(), "Runtime type check failed");
        AN(dynamic_cast<Reaction*>(e), "Runtime type check failed");
        return dynamic_cast<Reaction*>(e);
    }
    
    typedef enum {
        COMP_EDGE_TYPE_TOP,
        COMP_EDGE_TYPE_LEFT,
        COMP_EDGE_TYPE_BOTTOM,
        COMP_EDGE_TYPE_RIGHT
    } CompartmentEdgeType;
    
    class Compartment : public NetworkElement {
        public:
            
            // Exposed types:
            
            typedef std::vector<Graphfab::NetworkElement*> EltVec;
            
            typedef EltVec::iterator EltIt;
            typedef EltVec::const_iterator ConstEltIt;
            
            EltIt EltsBegin() { return _elt.begin(); }
            EltIt EltsEnd() { return _elt.end(); }
            
            ConstEltIt EltsBegin() const { return _elt.begin(); }
            ConstEltIt EltsEnd() const { return _elt.end(); }
            
            Graphfab::NetworkElement* getElt(const uint64 i) { return _elt.at(i); }
            
            const Graphfab::NetworkElement* getElt(const uint64 i) const { return _elt.at(i); }
            
            uint64 getNElts() const { return _elt.size(); }
            
            Compartment()
                : /*_nu(0.3),*/ _ra(50.*50.), _E(10.), _res(0.25), bytepattern(0xffae11), NetworkElement() {
                    _shape = ELT_SHAPE_RECT;
                    _type = NET_ELT_TYPE_COMP;
                }
            
            const std::string& getId() const { return _id; }
            
            void setId(const std::string& id) { _id = id; }

            void setName(const std::string& name) { name_ = name; }
            
            const std::string& getGlyph() const { return _gly; }
            
            void setGlyph(const std::string& glyph) { _gly = glyph; }
            
            void setCentroid(const Point& p) {
                AN(0, "setCentroid should not be called on a compt");
            }
            
            void recalcExtents() {
                _r = _ext.maxDim()*0.5;
                _p = (_ext.getMin() + _ext.getMax())*0.5;
            }
            
            // Elements
            
            void addElt(NetworkElement* e);
            
            bool containsElt(const NetworkElement* e) const;
            
            void removeElt(NetworkElement* e);
            
            void setRestExtents(const Box& ext);
            
            void resizeEnclose(double padding = 0);
            
            void autoSize();
            
            Real restArea() const { return _ra; }
            
            void setMin(const Point& p) { _ext.setMin(p); }
            void setMax(const Point& p) { _ext.setMax(p); }

            virtual Point getCentroid(COORD_SYSTEM coord = COORD_SYSTEM_LOCAL) const { return getExtents(coord).getCenter(); }
            
            // Layout engine:
            
            virtual void resetActivity();
            
            void applyBoundaryForce(const Real fx1, const Real fy1, const Real fx2, const Real fy2);
            
            void doInternalForce(NetworkElement* e, const Real f, const Real t);
            
            void doInternalForceAll(const Real f, const Real t);
            
            void doMotion(const Real scale);
            
            void capDelta2(const Real cap2);
            
            bool isContainer() const { return true; }
            
            bool contains(const NetworkElement* e) const;
            
            bool empty() const { return _elt.size() ? false : true; }
            
            void dump(std::ostream& os, uint32 ind);
            
            void dumpForces(std::ostream& os, uint32 ind) const;

            bool doByteCheck() { if(bytepattern == 0xffae11) return true; else return false; }
            
        protected:
            std::string _id;
            std::string name_;
            std::string _gly;
            EltVec _elt;
            Real _ra;
            Real _E;
            //Real _nu;
            Real _fx1, _fy1, _fx2, _fy2;
            Real _res;

            uint64_t bytepattern;
    };

    class Network : public Compartment {
        public:
            // Exposed types:
            
            typedef std::vector<Node*> NodeVec;
            typedef std::vector<Graphfab::Reaction*> RxnVec;
            typedef std::vector<Graphfab::Compartment*> CompVec;
            
            //iterators
            typedef NodeVec::iterator NodeIt;
            typedef NodeVec::const_iterator ConstNodeIt;
            
            typedef RxnVec::iterator RxnIt;
            typedef RxnVec::const_iterator ConstRxnIt;
            
            typedef CompVec::iterator CompIt;
            typedef CompVec::const_iterator ConstCompIt;
            
            // Constructors:
            
            Network() {
                bytepattern = 0x3355;
                layoutspecified_ = false;
            }
            
            // Methods:
            
            void hierarchRelease();
            
            // Nodes:
            
            void addNode(Node* n);
            
            void removeNode(Node* n);

            void connectNode(Node* n, Reaction* r, RxnRoleType role);

            bool isNodeConnected(Node* n, Reaction* r) const;
            
            Node* findNodeById(const std::string& id);
            const Node* findNodeById(const std::string& id) const;
            
            std::string getUniqueId() const;

            std::string getUniqueGlyphId(const Node& src) const;
            
            std::size_t getUniqueIndex() const;
            
            Node* findNodeByGlyph(const std::string& gly);
            
            Node* getNodeAt(const size_t i) { return _nodes.at(i); }

            Node* getUniqueNodeAt(const size_t n);

            size_t getNumInstances(const Node* u);

            Node* getInstance(const Node* u, const size_t n);
            
            bool containsNode(const Node* n) const;

            bool containsReaction(const Reaction* r) const;

            typedef std::vector<Reaction*> AttachedRxnList;

            AttachedRxnList getConnectedReactions(const Node* n);

            typedef std::vector<RxnBezier*> AttachedCurveList;

            AttachedCurveList getAttachedCurves(const Node* n);

            int getNumSubgraphs();

            void enumerateSubgraphs();

            void propagateSubgraphIndex(Node* x, int isub);

            void clearSubgraphInfo();

            void clearExcludeFromSubgraphEnum();
            
            Reaction* findReactionById(const std::string& id);
            
            Reaction* getRxnAt(const size_t i) { return _rxn.at(i); }
            
            void resetUsageInfo();
            
            const std::string& getId() const { return _id; }

            void setId(const std::string& id) { _id = id; }

            bool isSetId() const { return _id.size(); }
            
            bool isLayoutSpecified() const { return layoutspecified_; }
            
            void setLayoutSpecified(bool value) {
                layoutspecified_ = value;
            }
            
            // Reactions:
            
            void addReaction(Reaction* rxn);
            
            void removeReaction(Reaction* r);
            
            // Compartments:
            
            void addCompartment(Compartment* c) { _comp.push_back(c); addElt(c); }
            
            Compartment* findCompById(const std::string& id);
            
            Compartment* findCompByGlyph(const std::string& gly);
            
            Compartment* getCompAt(const size_t i) { return _comp.at(i); }
            
            Compartment* findContainingCompartment(const NetworkElement* e);
            
            // Layout:
            
            uint64 getTotalNumComps() const { return _comp.size(); }
            
            uint64 getTotalNumPts() const { return _nodes.size() + _rxn.size(); }

            uint64 getTotalNumRxns() const { return _rxn.size(); }

            uint64 getTotalNumNodes() const { return _nodes.size(); }

            uint64 getNumUniqueNodes() const;

            Box getBoundingBox() const;
            
            void fitToWindow(const Box& w);
            
            void applyTransform(const Affine2d& t);
            
            void setTransform(const Affine2d& t, bool recurse = true);
            
            void setInverseTransform(const Affine2d& it, bool recurse = true);

            void applyDisplacement(const Point& d);
            
            void elideEmptyComps();
            
            void randomizePositions(const Box& bounds);
            
            void rebuildCurves();

            void recalcCurveCPs();
            
            void recenterJunctions();
            
            void resetActivity();
            
            //void doNodeBoxContactForce(const Box& b, const Real f, const Real t);
            
            void capDeltas(const Real cap);
            
            void updatePositions(const Real scale);
            
            void updateExtents();
            
            void resizeCompsEnclose(double padding = 0);
            
            void autosizeComps();
            
            Point pmean() const;
            
            Point center() const;
            
            Box getExtents() const;
            
            void recenter(const Point& p);
            
            //Real diam(const Point& p);
            
            Point pvariance() const;
            
            // IO/Diagnostics:
            
            void dump(std::ostream& os, uint32 ind);
            
            void dumpEltForces(std::ostream& os, uint32 ind) const;

                        Node* getNodeAtIndex(int index) { return _nodes[index]; }
            
            //iterators
            
            NodeIt NodesBegin() { return _nodes.begin(); }
            NodeIt NodesEnd() { return _nodes.end(); }
            
            ConstNodeIt NodesBegin() const { return _nodes.begin(); }
            ConstNodeIt NodesEnd() const { return _nodes.end(); }
            
            RxnIt RxnsBegin() { return _rxn.begin(); }
            RxnIt RxnsEnd() { return _rxn.end(); }
            
            ConstRxnIt RxnsBegin() const { return _rxn.begin(); }
            ConstRxnIt RxnsEnd() const { return _rxn.end(); }
            
            CompIt CompsBegin() { return _comp.begin(); }
            CompIt CompsEnd() { return _comp.end(); }
            
            ConstCompIt CompsBegin() const { return _comp.begin(); }
            ConstCompIt CompsEnd() const { return _comp.end(); }
            
            bool doByteCheck() const { if(bytepattern == 0x3355) return true; else return false; }
        protected:
            
            void removeReactionsForNode(Node* n);
            
            NodeVec _nodes;
            RxnVec _rxn;
            CompVec _comp;
            
            long bytepattern;
            bool layoutspecified_;

            int nsub_;
    };
    
    inline Network* CastToNetwork(void* p) {
        NetworkElement* e = (NetworkElement*)p;
        AN(e->hasNetworkElementBase(), "Runtime type check failed");
        return dynamic_cast<Network*>(e);
    }
    
    // Methods:
    
    Network* networkFromLayout(const Layout& lay, const Model& mod);
    
    Network* networkFromModel(const Model& mod);
    
    int layout_getNumFloatingSpecies(const Layout& lay, const Model& mod);
    
}

#endif

#endif