network.h

Go to the documentation of this file.

/* MIT License
 */

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

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

#ifndef __SBNW_NETWORK_H_
#define __SBNW_NETWORK_H_

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

#include "SagittariusCore.h"
#include "point.h"
#include "curve.h"
#include "box.h"
#include "transform.h"

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

#include "autolayoutSBML.h"

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

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

namespace LibsbmlDraw {
    
    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(COORD_SYSTEM coord = COORD_SYSTEM_LOCAL) const { return getExtents(coord).getMin().x; }
            Real getMaxX(COORD_SYSTEM coord = COORD_SYSTEM_LOCAL) const { return getExtents(coord).getMax().x; }
            Real getMinY(COORD_SYSTEM coord = COORD_SYSTEM_LOCAL) const { return getExtents(coord).getMin().y; }
            Real getMaxY(COORD_SYSTEM coord = COORD_SYSTEM_LOCAL) const { return getExtents(coord).getMax().y; }
            
            Real getWidth(COORD_SYSTEM coord = COORD_SYSTEM_LOCAL) const { AT(getMaxX(coord) >= getMinX(coord)); return getMaxX(coord) - getMinX(coord); }
            Real getHeight(COORD_SYSTEM coord = COORD_SYSTEM_LOCAL) const { AT(getMaxY(coord) >= getMinY(coord)); return getMaxY(coord) - getMinY(coord); }
            
            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();

                        Real calcArrowGap(RxnBezier* c, Node* n);
            
            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<LibsbmlDraw::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(); }
            
            LibsbmlDraw::NetworkElement* getElt(const uint64 i) { return _elt.at(i); }
            
            const LibsbmlDraw::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<LibsbmlDraw::Reaction*> RxnVec;
            typedef std::vector<LibsbmlDraw::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