diff --git a/VistaCoreLibs/VistaDataFlowNet/VdfnCompositeNode.cpp b/VistaCoreLibs/VistaDataFlowNet/VdfnCompositeNode.cpp
index 670b77ad369357119fb165c160ddab121ed5582c..825faf8eb3c8555d061742ee26dbeaf3584d3e2b 100644
--- a/VistaCoreLibs/VistaDataFlowNet/VdfnCompositeNode.cpp
+++ b/VistaCoreLibs/VistaDataFlowNet/VdfnCompositeNode.cpp
@@ -101,6 +101,8 @@ bool VdfnCompositeNode::SetInPort(const std::string &sName, IVdfnPort *pPort)
 	}
 
 	std::string sMappedName = (*cit).second.m_strPortName;
+	// if we found cit in the inport map, m_pTargetNode is not NULL!,
+	// see CreatePorts(), so no need to test against NULL here.
 	if((*cit).second.m_pTargetNode->SetInPort( sMappedName, pPort ))
 	{
 		// register as mine...
diff --git a/VistaCoreLibs/VistaDataFlowNet/VdfnGraph.cpp b/VistaCoreLibs/VistaDataFlowNet/VdfnGraph.cpp
index e23309add93f4fdeb3d268e0f53e9bf17d7b5516..e52b0a3dd7a20d77a1e751fcb65368280db41a41 100644
--- a/VistaCoreLibs/VistaDataFlowNet/VdfnGraph.cpp
+++ b/VistaCoreLibs/VistaDataFlowNet/VdfnGraph.cpp
@@ -124,7 +124,7 @@ bool VdfnGraph::EvaluateGraph(double nTimeStamp)
 	if( EvaluateSubGraph( m_vecTraversal, nTimeStamp ) == false )
 		return false;
 
-	//check if any node needs a reevaluation
+	// check if any node needs a reevaluation
 	std::map<IVdfnReEvalNode*, NodeVec>::reverse_iterator ritReEvalNode;
 	std::map<IVdfnReEvalNode*, NodeVec>::reverse_iterator rbegin = m_mpReEvalSubgraphs.rbegin();
 	std::map<IVdfnReEvalNode*, NodeVec>::reverse_iterator rend   = m_mpReEvalSubgraphs.rend();
@@ -133,7 +133,7 @@ bool VdfnGraph::EvaluateGraph(double nTimeStamp)
 		// Determines if another evaluation run is required for the nodes
 		// NeedsEval will usually true in the first, normal evaluation run,
 		// but also indicated if a ReEvalNode needs another run afterwards
-		// The tests and reevaluations are performed back-to-front in order
+		// The tests and re-evaluations are performed back-to-front in order
 		// to ensure that a further-down ReEvalNode is fully evaluated before
 		// a ReEvalNode further-up can trigger and change the input
 		if( (*ritReEvalNode).first->NeedsEval() )
@@ -247,6 +247,7 @@ IVdfnNode *VdfnGraph::GetNodeByName(const std::string &strName) const
 	}
 	return NULL;
 }
+
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // EDGE MANAGEMENT
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@@ -273,14 +274,13 @@ bool VdfnGraph::GetIsConnectedFromTo( IVdfnNode *pFrom, IVdfnNode *pTo) const
 	return false;
 }
 
-bool VdfnGraph::UpdatePorts()
+void VdfnGraph::PrepareAllPorts()
 {
 	for(Nodes::iterator uit = m_liNodes.begin(); uit != m_liNodes.end(); ++uit )
 	{
 		if((*uit)->PreparePorts() == false)
 			(*uit)->SetIsEnabled(false);
 	}
-	return true;
 }
 
 
@@ -332,8 +332,11 @@ bool VdfnGraph::ReloadActionObjects()
 				{
 					// ok, we found a parent node
 					// add an edge to the edge-list
-					Connect &edges = GetAdjacencyList( (*pit).second, pit->first );
-					edges.second.push_back( std::pair<IVdfnNode*, IVdfnPort*>(*cit, pPort) ); // add edge from (in_p) -> (sink_p)
+					Connect &edges = GetOrCreateAdjacencyListForNode(
+							(*pit).second, pit->first );
+					// add edge from (in_p) -> (sink_p)
+					edges.second.push_back( std::pair<IVdfnNode*,
+							ConPortInfo>(*cit, ConPortInfo( *sit, pPort) ) );
 				}
 			}
 
@@ -346,8 +349,8 @@ bool VdfnGraph::ReloadActionObjects()
 
 bool VdfnGraph::UpdateTraversalVector()
 {
-	UpdatePorts();
-	UpdatePortLookupMap();
+	PrepareAllPorts();
+	UpdateOutportLookupMap();
 	UpdateEdgeMap();
 
 	m_vecTraversal.clear();
@@ -360,9 +363,6 @@ bool VdfnGraph::UpdateTraversalVector()
 			t != liPrts.end(); ++t )
 		{
 			const ConInfo &liChildren = (*t).second;
-
-			//		ConInfo &liChildren = (*cit).second.second;
-
 			// add node with children to topology graph
 			for( ConInfo::const_iterator nit = liChildren.begin();
 				nit != liChildren.end(); ++nit)
@@ -375,11 +375,12 @@ bool VdfnGraph::UpdateTraversalVector()
 
 	std::list<VistaTopologyGraph<IVdfnNode*>::Node*> liNodes = topology.CalcTopology();
 
-	for(std::list<VistaTopologyGraph<IVdfnNode*>::Node*>::const_iterator tcit = liNodes.begin();
+	for(std::list<VistaTopologyGraph<IVdfnNode*>::Node*>::const_iterator
+		tcit = liNodes.begin();
 		tcit != liNodes.end(); ++tcit)
 	{
 		m_vecTraversal.push_back( (*tcit)->m_oElement );
-		//check if node is a reevalnode. if so, create its subgraph
+		//check if node is a re-evalnode. if so, create its subgraph
 		IVdfnReEvalNode* pReEvalNode = dynamic_cast<IVdfnReEvalNode*>( (*tcit)->m_oElement );
 		// If a node is a ReEvalNode, it may become necessary to evaluate it multiple times per
 		// frame. While the full graph is evaluated on the first run, a reevaluation should
@@ -396,9 +397,11 @@ bool VdfnGraph::UpdateTraversalVector()
 			std::vector<IVdfnNode*>& vecSubgraph = m_mpReEvalSubgraphs[pReEvalNode];
 			vecSubgraph.resize( liSubgraph.size() );
 
-			std::list<VistaTopologyGraph<IVdfnNode*>::Node*>::const_iterator citOrigNode = liSubgraph.begin();
+			std::list<VistaTopologyGraph<IVdfnNode*>::Node*>::const_iterator
+										citOrigNode = liSubgraph.begin();
 			std::vector<IVdfnNode*>::iterator itCopyNode = vecSubgraph.begin();
-			std::list<VistaTopologyGraph<IVdfnNode*>::Node*>::const_iterator end = liSubgraph.end();
+			std::list<VistaTopologyGraph<IVdfnNode*>::Node*>::const_iterator
+										end = liSubgraph.end();
 
 			for( ; citOrigNode != end; ++citOrigNode, ++itCopyNode )
 				(*itCopyNode) = (*citOrigNode)->m_oElement;
@@ -411,7 +414,8 @@ bool VdfnGraph::UpdateTraversalVector()
 			vstr::warnp() << "[VdfnGraph--"
 				<< strUserTag
 				<< "]: PrepareEvaluationRun() on node ["
-				<< (*tcit)->m_oElement->GetNameForNameable() << "] failed to initialize." << std::endl;
+				<< (*tcit)->m_oElement->GetNameForNameable()
+				<< "] failed to initialize." << std::endl;
 		}
 	}
 
@@ -424,16 +428,19 @@ bool VdfnGraph::UpdateTraversalVector()
 
 	for(Nodes::const_iterator ucit = begin; ucit != end; ++ucit )
 	{
-		if( !topology.GetNodeByValue( *ucit ) ) // not in topology graph, so it is not in the edge list
+		// not in topology graph, so it is not in the edge list
+		if( !topology.GetNodeByValue( *ucit ) )
 		{
 			// while we are at it: call initialize on these nodes :)
 			if( (*ucit)->PrepareEvaluationRun() == true )
-				m_vecTraversal.push_back( *ucit ); // order is not important, could be anywhere in the list
+				// order is not important, could be anywhere in the list
+				m_vecTraversal.push_back( *ucit );
 			else
 			{
 				// omit broken nodes
 				vstr::warnp() << "[VdfnGraph]: PrepareEvaluationRun() on node ["
-					<< (*ucit)->GetNameForNameable() << "] failed to initialize." << std::endl;
+					<< (*ucit)->GetNameForNameable()
+					<< "] failed to initialize." << std::endl;
 			}
 
 		}
@@ -441,7 +448,7 @@ bool VdfnGraph::UpdateTraversalVector()
 	return true;
 }
 
-bool VdfnGraph::UpdatePortLookupMap()
+bool VdfnGraph::UpdateOutportLookupMap()
 {
 	// clear old values
 	m_mpPortLookup.clear();
@@ -487,15 +494,19 @@ bool VdfnGraph::UpdateEdgeMap()
 				{
 					// ok, we found a parent node
 					// add an edge to the edge-list
-					Connect &edges = GetAdjacencyList( (*pit).second, pit->first );
-					edges.second.push_back( std::pair<IVdfnNode*, IVdfnPort*>(*cit, pPort) ); // add edge from (in_p) -> (sink_p)
+					Connect &edges = GetOrCreateAdjacencyListForNode(
+							                     (*pit).second, pit->first );
+					// add edge and note the name as well
+					edges.second.push_back(
+							std::pair<IVdfnNode*, ConPortInfo>(*cit,
+									ConPortInfo( *sit, pPort) ) );
 				}
 			}
 
 		}
 	}
 
-	return false;
+        return true;
 }
 
 IVdfnNode *VdfnGraph::GetNodeForPort( IVdfnPort *pPort ) const
@@ -507,7 +518,8 @@ IVdfnNode *VdfnGraph::GetNodeForPort( IVdfnPort *pPort ) const
 }
 
 
-VdfnGraph::Connect &VdfnGraph::GetAdjacencyList( IVdfnNode *pNode, IVdfnPort *pPort )
+VdfnGraph::Connect &
+VdfnGraph::GetOrCreateAdjacencyListForNode( IVdfnNode *pNode, IVdfnPort *pPort )
 {
 	// lookup node in edge map
 	Edges::iterator it = m_mpEdges.find( pNode );
@@ -515,7 +527,8 @@ VdfnGraph::Connect &VdfnGraph::GetAdjacencyList( IVdfnNode *pNode, IVdfnPort *pP
 	{
 		// add a new entry
 
-		it = m_mpEdges.insert( Edges::value_type( pNode, std::list<Connect>()) ).first;
+		it = m_mpEdges.insert(
+				Edges::value_type( pNode, std::list<Connect>()) ).first;
 		(*it).second.push_back(Connect( pPort, ConInfo() ));
 	}
 	else
@@ -524,6 +537,9 @@ VdfnGraph::Connect &VdfnGraph::GetAdjacencyList( IVdfnNode *pNode, IVdfnPort *pP
 		for(std::list<Connect>::iterator cit = (*it).second.begin();
 			cit != (*it).second.end(); ++cit )
 		{
+			// FIXME this is problematic, if a port is shared multiple times
+			// (as it only searches for the first match, it may skip at least
+			// one edge).
 			if( (*cit).first == pPort )
 			{
 				return (*cit);
@@ -549,7 +565,8 @@ void VdfnGraph::GetExports( ExportList &liExports ) const
 
 void VdfnGraph::SetExports(const ExportList &liExports)
 {
-	for(ExportList::const_iterator cit = liExports.begin(); cit != liExports.end(); ++cit)
+	for(ExportList::const_iterator cit = liExports.begin();
+			cit != liExports.end(); ++cit)
 	{
 		const VdfnGraph::ExportData &exp = *cit;
 		IVdfnNode *pNode = GetNodeByName( exp.m_strNodeName );
@@ -579,7 +596,7 @@ void VdfnGraph::SetExports(const ExportList &liExports)
 				}
 			}
 		}
-		else
+		else if( exp.m_nDirection == VdfnGraph::ExportData::OUTPORT )
 		{
 			if( pNode->GetOutPort( exp.m_strPortName ) == NULL )
 			{
@@ -588,6 +605,12 @@ void VdfnGraph::SetExports(const ExportList &liExports)
 					<< exp.m_strNodeName << std::endl;
 			}
 		}
+		else
+		{
+			vstr::errp() << "VdfnGraph::SetExports() -- port direction not"
+					     << " set (UNDEFINED), skipping this node declaration.";
+			continue; // for-loop
+		}
 		m_liExports.push_back( exp );
 	}
 }
diff --git a/VistaCoreLibs/VistaDataFlowNet/VdfnGraph.h b/VistaCoreLibs/VistaDataFlowNet/VdfnGraph.h
index a37a90c4124c44784f68c471ed47d88cb687a6a6..24257b12fe5c3c780a18b0e91eb87d4164e50f65 100644
--- a/VistaCoreLibs/VistaDataFlowNet/VdfnGraph.h
+++ b/VistaCoreLibs/VistaDataFlowNet/VdfnGraph.h
@@ -52,26 +52,49 @@ class IVdfnPort;
 /*============================================================================*/
 
 /**
- * The graph class. Contains nodes and edges.
- * It is really not meant to traverse this graph's structure by hand as a programmer.
- * There is code to do that. But you can do so, if you wish.
- * Consequently, the use of typedefs like Nodes, Edges, ConInfo and Connect
- * are used for expert access only.
+ * @brief Graph container and traversal interface.
+ *
+ * The VdfnGraph implements the following responsibilities.
+ * - management of nodes and detection of edges
+ * - definition of a traversal structure and evaluation algorithm
+ * - access structures for composite nodes (using Exports)
+ * - retrieval of "input nodes", i.e., nodes with 0 inports
+ *
+ * A graph can be active, i.e., the node traversal actually evaluates node
+ * values, or inactive, i.e., traversal does not change node values.
+ *
+ * @note It is really not meant to traverse this graph's structure by hand
+ *       as a programmer. Meaning: this is not a general purpose graph data
+ *       structure.
  */
 class VISTADFNAPI VdfnGraph : public IVistaSerializable
 {
 public:
+	/**
+	 * @brief helper structure to access graph 'exports'.
+	 * Usually required in conjunction with Composite Nodes, i.e., nodes
+	 * that contain graphs themselves.
+	 * Exports define virtual in- and output ports of a graph that are
+	 * reflected on a Composite Node.
+	 *
+	 * @see SetExports()
+	 * @see GetExports()
+	 */
 	class ExportData
 	{
 	public:
 
 		enum eDir
 		{
-			UNDEFINED=-1,
-			INPORT=0,
-			OUTPORT
+			UNDEFINED=-1, /**< error tag, initial value */
+			INPORT=0,     /**< export direction marks an inport  */
+			OUTPORT       /**< export direction marks an outport */
 		};
 
+		/**
+		 * @brief default c'tor.
+		 * Initializes export direction to UNDEFINED and target node as NULL
+		 */
 		ExportData()
 		: m_nDirection(UNDEFINED),
 		  m_pTargetNode(NULL)
@@ -79,26 +102,34 @@ public:
 
 		}
 
+
+		/**
+		 * @brief connection defining c'tor.
+		 * @param strNodeName export defining node name
+		 * @param strPortName port name from node <strNodeName> to export
+		 * @param strMapName  name to use when exporting the port
+		 * @param direction   choice between inport or outport. using
+		 *                    undefined is, well, undefined.
+		 */
 		ExportData( const std::string &strNodeName,
-				 const std::string &strPortName,
-				 const std::string &strMapName,
-				 eDir direction,
-				 IVdfnNode *pTargetNode = NULL)
+				    const std::string &strPortName,
+				    const std::string &strMapName,
+				    eDir direction)
 		: m_strNodeName(strNodeName),
 		  m_strPortName(strPortName),
 		  m_strMapName(strMapName),
 		  m_nDirection(direction),
-		  m_pTargetNode(pTargetNode)
+		  m_pTargetNode(NULL)
 		{
 
 		}
 
-		std::string m_strNodeName;
-		std::string m_strPortName;
-		std::string m_strMapName;
+		std::string m_strNodeName; /**< name of the node to export */
+		std::string m_strPortName; /**< name of the port to export */
+		std::string m_strMapName;  /**< export name, can be used to rename ports */
 
-		eDir m_nDirection;
-		IVdfnNode *m_pTargetNode;
+		eDir        m_nDirection;  /**< port direction, INPORT or OUTPORT */
+		IVdfnNode  *m_pTargetNode; /**< cache pointer in case of INPORT port */
 	};
 
 	/**
@@ -106,17 +137,23 @@ public:
 	 */
 	typedef std::list<IVdfnNode*>             Nodes;
 
+	/**
+	 * used to note to which port the connection was done and under
+	 * what name.
+	 */
+	typedef std::pair<std::string, IVdfnPort*> ConPortInfo;
+
 	/**
 	 * is meant to reflect a target node and a corresponding port
 	 * where the edge in coming in.
 	 */
-	typedef std::list<std::pair<IVdfnNode*, IVdfnPort*> > ConInfo;
+	typedef std::list< std::pair<IVdfnNode*, ConPortInfo> > ConInfo;
 
 	/**
 	 * maps all the nodes that are connected by Connect.first to
 	 * the list of Connect.second.
 	 */
-	typedef std::pair<IVdfnPort*, ConInfo > Connect;
+	typedef std::pair<IVdfnPort*, ConInfo> Connect;
 
 	/**
 	 * Edges define a mapping from a node which is connected over
@@ -125,7 +162,7 @@ public:
 	 * provides a link between the target node of the Connect.Port
 	 * and the TargetNode.Port
 	 */
-	typedef std::map <IVdfnNode*, std::list<Connect> >      Edges;
+	typedef std::map < IVdfnNode*, std::list<Connect> >      Edges;
 
 	/**
 	 * A list of exported ports.
@@ -140,7 +177,7 @@ public:
 	// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 	/**
-	 * @param nTimeStamp provide a timestamp that is passed as update time
+	 * @param nTimeStamp provide a time stamp that is passed as update time
 	                     stamp to all nodes that are evaluated.
 						 Pass 0 here for the initial build which will build
 						 up the edges and will call the PrepareEvaluationRun()
@@ -159,7 +196,7 @@ public:
 	 * If a graph is deactivated, it runs over <b>all</b> nodes in the graph
 	 * and calls IVdfnNode::OnDeactivate() on them, passing dTimeStamp.
 	 * @param bIsActive true if this graph is marked active, false else
-	 * @param dTimeStamp a timestamp, 0 for "force-state-propagation-to-nodes"
+	 * @param dTimeStamp a time stamp, 0 for "force-state-propagation-to-nodes"
 	 */
 	void SetIsActive( bool bIsActive, double dTimeStamp );
 
@@ -189,10 +226,10 @@ public:
 	// NODE MANAGEMENT
 	// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 	/**
-	 *  Adds a node to this graph. This has no direct conseqeuence.
+	 *  Adds a node to this graph. This has no direct consequence.
 	 *  It is not checked, whether the node is already part of this graph.
-	 *  The graph is markes dirty when a node is added. On the next request
-	 *  to evaluate the graph, the internal traversal stuctures will be rebuild.
+	 *  The graph is marked dirty when a node is added. On the next request
+	 *  to evaluate the graph, the internal traversal structures will be rebuild.
 	 *  @return always true
 	 *  @param pNode the node to be added for evaluation
 	 */
@@ -212,7 +249,7 @@ public:
 	 * Searches a node in this graph by name. Note that is is assumes that any
 	 * node in this graph has a unique name.
 	 * The node is searched by a case-sensitive comparison to the node name.
-	 * @return NULL iff a node with nam strName was not found in this graph.
+	 * @return NULL iff a node with name strName was not found in this graph.
 	 * @param strName the case sensitive name to be searched for.
 	 */
 	IVdfnNode *GetNodeByName(const std::string &strName) const;
@@ -297,7 +334,7 @@ public:
 	/**
 	 * control API, it tells the serializer of this graph to respect the
 	 * IVdfnNode::GetIsMasterSim() flag or not. If this method returns
-	 * fallse, the master sim flag can be ignored during serialization, which
+	 * false, the master sim flag can be ignored during serialization, which
 	 * will then dump <b>all</b> nodes of this graph,
 	 * not only the ones sitting on the master.
 	 * @see SetCheckMasterSim()
@@ -327,27 +364,62 @@ private:
 	typedef std::vector<IVdfnNode*>           NodeVec;
 
 protected:
+	/**
+	 * @brief evaluates nodes in the given vector, passing nTimeStamp as argument.
+	 */
 	bool EvaluateSubGraph( const NodeVec& vecSubGraph, const double nTimeStamp );
 
+	/**
+	 * @brief helper method to build the graph traversal vector out of the
+	 *        set of given nodes and their connection based on port links.
+	 */
 	bool UpdateTraversalVector();
-	bool UpdatePortLookupMap();
+
+	/**
+	 * @brief helper method to build an outport-cache when building the traversal
+	 *        structure. This map allows to lookup outports based on pointers
+	 *        quicker than a node/port lookup. This is needed for establishing
+	 *        a backlink structure for edge creation.
+	 */
+	bool UpdateOutportLookupMap();
+
+	/**
+	 * @brief create connect information based on port links, i.e., edges between
+	 *        ports.
+	 */
 	bool UpdateEdgeMap();
-	bool UpdatePorts();
+
+	/**
+	 * @brief calls PreparePorts() for all nodes in the traversal map.
+	 * If a node reports that it can not be prepared, it is disabled.
+	 */
+	void PrepareAllPorts();
 
 private:
-	Connect &GetAdjacencyList( IVdfnNode *, IVdfnPort * );
+	/**
+	 * @brief retrieves or generates the outward connect information
+	 *        for the given node and port.
+	 */
+	Connect &GetOrCreateAdjacencyListForNode( IVdfnNode *, IVdfnPort * );
 
+	// all nodes contained in this graph
 	Nodes      m_liNodes;
+	// ordered list of nodes to be traversed
 	NodeVec    m_vecTraversal;
+	// edge / connection lookup table
 	Edges      m_mpEdges;
+	// cache to speed up lookup of outports during edge creation
 	PortLookup m_mpPortLookup;
+
+	// cache to process re-evaluation nodes as subgraphs
 	std::map<IVdfnReEvalNode*, NodeVec> m_mpReEvalSubgraphs;
 
+	// exports defined for this graph
 	ExportList m_liExports;
 
-	bool m_bUpToDate,
-		 m_bIsActive,
-	     m_bCheckMasterSim;
+	bool m_bUpToDate,       // flag to show dirty (false) / clean state (true)
+		 m_bIsActive,       // global activation flag
+	     m_bCheckMasterSim; // toggle to care for master sim evaluation
 };
 
 /*============================================================================*/
diff --git a/VistaCoreLibs/VistaDataFlowNet/VdfnLoggerNode.cpp b/VistaCoreLibs/VistaDataFlowNet/VdfnLoggerNode.cpp
index 8eaede7ede3c2d0d6b1d02a011fb3e7060a83f93..18d857ac570bec8567efb221ea26691f2b7be5e0 100644
--- a/VistaCoreLibs/VistaDataFlowNet/VdfnLoggerNode.cpp
+++ b/VistaCoreLibs/VistaDataFlowNet/VdfnLoggerNode.cpp
@@ -161,24 +161,25 @@ bool VdfnLoggerNode::PrepareEvaluationRun()
 	std::list<std::string> liPortNames;
 	std::map<IVdfnPort*, std::string> lostNames;
 
-	std::set<IVdfnPort*> Ports, SetPorts, DiffPorts;
+	std::set< std::pair<std::string, IVdfnPort*> > Ports, SetPorts, DiffPorts;
 	for(PortMap::const_iterator it = m_mpInPorts.begin();
 		it != m_mpInPorts.end(); ++it )
 	{
 		if( (*it).second == m_pFileName )
 			continue; // skip diz...
-		 Ports.insert( (*it).second );
+		 Ports.insert( std::pair<std::string, IVdfnPort*>( (*it).first, (*it).second) );
 	}
 
 	for(std::list<std::string>::const_iterator cit = m_liInPorts.begin();
 		cit != m_liInPorts.end(); ++cit)
 	{
 
-		TVdfnPort<std::string> *pPort = VdfnUtil::GetInPortTyped<TVdfnPort<std::string>*>( *cit, this );
+		TVdfnPort<std::string> *pPort
+			= VdfnUtil::GetInPortTyped<TVdfnPort<std::string>*>( *cit, this );
 		if(pPort)
 		{
 			m_vecPorts.push_back( pPort );
-			SetPorts.insert( pPort );
+			SetPorts.insert( std::pair<std::string,IVdfnPort*> ( *cit, pPort ) );
 		}
 		else
 		{
@@ -196,20 +197,19 @@ bool VdfnLoggerNode::PrepareEvaluationRun()
 		                 SetPorts.begin(), SetPorts.end(),
 						 std::inserter( DiffPorts, DiffPorts.end() ) );
 
-	for( std::set<IVdfnPort*>::const_iterator dit = DiffPorts.begin();
-		dit != DiffPorts.end(); ++dit )
+	for( std::set< std::pair<std::string, IVdfnPort*> >::const_iterator dit
+			= DiffPorts.begin();
+	   dit != DiffPorts.end(); ++dit )
 	{
-		TVdfnPort<std::string> *pPort = dynamic_cast<TVdfnPort<std::string>*>( *dit );
+		TVdfnPort<std::string> *pPort
+			= dynamic_cast<TVdfnPort<std::string>*>( (*dit).second );
 		if(pPort)
-		{
 			m_vecPorts.push_back( pPort );
-		}
 		else
 			m_vecPorts.push_back( m_pNotSet );
 
-		std::string strName;
-		if(GetNameForInPort( pPort, strName ))
-			liPortNames.push_back(strName);
+		if( GetHasInPort( (*dit).first ) )
+			liPortNames.push_back( (*dit).first );
 		else
 		{
 			std::map<IVdfnPort*, std::string>::const_iterator lnit = lostNames.find( pPort );
diff --git a/VistaCoreLibs/VistaDataFlowNet/VdfnNode.cpp b/VistaCoreLibs/VistaDataFlowNet/VdfnNode.cpp
index 55775f44be2b52d54459cd5a1286e05e7dc52925..984a56df43d47cfe5806ecdf884755b37445c9cf 100644
--- a/VistaCoreLibs/VistaDataFlowNet/VdfnNode.cpp
+++ b/VistaCoreLibs/VistaDataFlowNet/VdfnNode.cpp
@@ -259,20 +259,6 @@ IVdfnPort *IVdfnNode::GetOutPort(const std::string &sName) const
 	return (*cit).second;
 }
 
-bool IVdfnNode::GetNameForInPort( IVdfnPort *pPort, std::string &strName ) const
-{
-	// reverse lookup in m_mpInPortMap
-	for(PortMap::const_iterator cit = m_mpInPorts.begin();
-		cit != m_mpInPorts.end(); ++cit)
-	{
-		if( (*cit).second == pPort )
-		{
-			strName = (*cit).first;
-			return true;
-		}
-	}
-	return false;
-}
 
 bool IVdfnNode::GetNameForOutPort( IVdfnPort *pPort, std::string &strName ) const
 {
diff --git a/VistaCoreLibs/VistaDataFlowNet/VdfnNode.h b/VistaCoreLibs/VistaDataFlowNet/VdfnNode.h
index 028acc6bb4778ed4eb2dda8c1fdba8b521b89dda..436e0785cc9e02deecd1959ea5d71665bc04349a 100644
--- a/VistaCoreLibs/VistaDataFlowNet/VdfnNode.h
+++ b/VistaCoreLibs/VistaDataFlowNet/VdfnNode.h
@@ -200,16 +200,6 @@ public:
 	 */
 	virtual bool RemInPort(const std::string &sName);
 
-	/**
-	 * Retrieve a name for an inport.
-	 * @param pPort the port to lookup in the inport map
-	 * @param strName the container to store the name to
-	 * @return true iff the port exists as inport, false if this pPort could not
-	           be retrieved from the set of inports.
-	 * @see GetNameForOutPort()
-	 */
-	bool GetNameForInPort( IVdfnPort *pPort, std::string &strName ) const;
-
 	/**
 	 * Retrieve a name for an outport.
 	 * @param pPort the port to lookup in the outport map
diff --git a/VistaCoreLibs/VistaDataFlowNet/VdfnPersistence.cpp b/VistaCoreLibs/VistaDataFlowNet/VdfnPersistence.cpp
index 7ec5698a20dbb89bc9f4a51a9b6295ac30c3cd8b..b31bbb9e78a0d40b3c61c323e434728fb1f78ec2 100644
--- a/VistaCoreLibs/VistaDataFlowNet/VdfnPersistence.cpp
+++ b/VistaCoreLibs/VistaDataFlowNet/VdfnPersistence.cpp
@@ -1150,11 +1150,8 @@ bool VdfnPersistence::SaveAsDot( VdfnGraph *pGraph,
 						(*cit)->GetNameForOutPort( (*t).first, strFromPortName );
 
 
-						std::string strToPortName;
-						if((*nit).first->GetNameForInPort( (*nit).second, strToPortName ) == false)
-						{
-							vstr::warnp() << "VdfnPersistence::SaveAsDot() - No port given" << std::endl;
-						}
+						std::string strToPortName = (*nit).second.first;
+
 						if( bWritePorts || bWriteValues )
 						{
 							std::string strNodeName = CleanNodeName((*cit)->GetNameForNameable());