LatticeBase.cxx

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:     Lattice
// Module:      LatticeBase
// 
// Description: Lattice methods (see comments in header)
//
// Implementation: +---------------+
//                 | See LatticeBase.h |
//                 +---------------+
//
// Author:      Jon Thaler
// Created:     Fri July 30, 1999
//
//  Minos Revision History
//  
//  This file has been converted automatically from the corresponding CLEO
//  Lattice code by Nick West on: 14/03/2000 08:38:06
//  
//  It is being used to explore the possibility that a modified Lattice
//  can be used in MINOS.  The main changes are:-
//  
//      1)  The removal Lattice templates classes:-
//  
//           a)  LinkData is dummy
//           b)  Left and Right ID types are void*
//  
//      2)  Conversion of CLEO types and includes to MINOS equivalents
//          e.g.:-
//  
//           a)  DABoolean -> Bool_t
//           b)  report    -> MSG

//

//-------------+
// Environment |
//-------------+

//----------------------+
// system include files |
//----------------------+
#if defined(AMBIGUOUS_STRING_FUNCTIONS_BUG)
#include <string>
#endif             

#if defined(STL_TEMPLATE_DEFAULT_PARAMS_FIRST_BUG)
#include <vector>
#include <algorithm>
#endif

//--------------------+
// user include files |
//--------------------+
#include "Lattice/LatticeBase.h"
#include "MessageService/MsgService.h"
CVSID("$Id: LatticeBase.cxx,v 1.2 2000/05/10 10:07:04 west Exp $");

//-------------+
// STL classes |
//-------------+
#include <vector>
#include <algorithm>

//-------------------------------+
// constants, enums and typedefs |
//-------------------------------+
const char* const kLLString = "Lattice.LatticeBase";

//----------------------------+
// constructor and destructor |
//----------------------------+
LatticeBase::
LatticeBase(LatticeTopology i,
            LatticeTopology j,
            LatticeTopology k,
            LatticeTopology l)
          : m_LeftNodes (*new LeftNodes),
            m_RightNodes(*new RightNodes),
            m_Links     (*new Links),
            m_VLeftID   (*new VectorLeftID),
            m_VRightID  (*new VectorRightID)
{
  MSG("Lat",Msg::kDebug) << "In ctor()." << endl;
  //--------------------------------------------------+
  // Initialize topology.                             |
  // The default value of i,j,k,l is 0, but           |
  // m_Topology[0] isn't used, so this ought to work. |
  //--------------------------------------------------+
  for (int index=0;  index < 5;  m_Topology[index++] = false);
  m_Topology[i] = true;
  m_Topology[j] = true;
  m_Topology[k] = true;
  m_Topology[l] = true;
  MSG("Lat",Msg::kDebug) << "Topology is" << "Sorry, not available yet" << endl;
}

//-----------------------------------------------------------+
// Destructor                                                |
//  Delete the nodes and links before deleting the pointers. |
//-----------------------------------------------------------+
LatticeBase::
~LatticeBase()
{
  MSG("Lat",Msg::kDebug) << "in Lattice dtor()" << endl;

  for (LeftNodes::iterator i  = m_LeftNodes.begin();
                           i != m_LeftNodes.end();  ++i)
  {
    delete *i;
  }
  delete &m_LeftNodes;
  delete &m_VLeftID;

  for (RightNodes::iterator j  = m_RightNodes.begin();
                            j != m_RightNodes.end();  ++j)
  {
    delete *j;
  }
  delete &m_RightNodes;
  delete &m_VRightID;

  for (LinkItr k = m_Links.begin();  k != m_Links.end();  ++k)
  {
    delete *k;
  }
  delete &m_Links;
}

//------------------+
// member functions |
//------------------+
//---------------------------------+
// connect();                      |
//  Make or modify a Lattice Link. |
//---------------------------------+
//--- connect(id,id,LinkData&) -------------------------------------------
LatticeBase::Link*
LatticeBase::
connect(LeftID leftID, RightID rightID, const LinkData& LinkData)
{
  // Point to the nodes having the two IDs.
  // If no node exists (pointer=0), make a new node.

  LeftNode*  pLN   = leftNode(leftID);
  LeftNode*  lNode = (pLN)? pLN : newLeftNode(leftID);
                     
  RightNode* pRN   = rightNode(rightID);
  RightNode* rNode = (pRN)? pRN : newRightNode(rightID);

  // Make the link if the nodes will still satisfy the topology constraint.
  if (checkLNtopo(lNode) && checkRNtopo(rNode))
  {
    Link* link = new Link(lNode, rNode, LinkData);
    m_Links.push_back(link);

    // Update the nodes.
    // Can't use data access methods, because they return const.
    lNode->m_Links   .push_back(link);
    rNode->m_Links   .push_back(link);
    lNode->m_VRightID.push_back(rightID);
    rNode->m_VLeftID .push_back(leftID);

    return link;
  }
  
  MSG("Lat",Msg::kWarning)
    << " connect attempts to violate topology constraint." << endl;
  return 0;
}

//--- connect(id,id) ---------------------------------------------
LatticeBase::Link*
LatticeBase::
connect(LeftID leftID, RightID rightID)
{ 
  // Point to the nodes having the two IDs.
  // If no node exists (pointer=0), make a new node.
  LeftNode*  pLN   = leftNode(leftID);
  LeftNode*  lNode = (pLN)? pLN : newLeftNode(leftID);
                     
  RightNode* pRN   = rightNode(rightID);
  RightNode* rNode = (pRN)? pRN : newRightNode(rightID);

  // Make the link if the nodes will still satisfy the topology constraint.
  if (checkLNtopo(lNode) && checkRNtopo(rNode))
  {
    Link* link = new Link(lNode, rNode);
    m_Links.push_back(link);

    // Update the nodes.
    // Can't use data access methods, because they return const.
    lNode->m_Links   .push_back(link);
    rNode->m_Links   .push_back(link);
    lNode->m_VRightID.push_back(rightID);
    rNode->m_VLeftID .push_back(leftID);

    return link;
  }
  
  MSG("Lat",Msg::kWarning)
    << " connect attempts to violate topology constraint." << endl;
  return 0;
}

//--- connect(id,Link&,id) ---------------------------------------
LatticeBase::Link*
LatticeBase::
connect(LeftID lid, Link& link, RightID rid)
{
  VectorLeftID&  ld     = link.m_VLeftID;
  VectorRightID& rd     = link.m_VRightID;
  LeftNode*      pLeft  = leftNode (lid);
  RightNode*     pRight = rightNode(rid);

  // Make the connection if topology constraint is satisfied. 
  if (   (    find(ld.begin(),ld.end(),lid) != ld.end()
          || (checkLNtopo(pLeft) && checkLLtopo(link)) )
      && (    find(rd.begin(),rd.end(),rid) != rd.end()
          || (checkRNtopo(pRight)&& checkRLtopo(link)) ) )
  {
    addLeftNodeToLink (lid, link);
    addRightNodeToLink(rid, link);
    return &link;
  }
  else
  {
    MSG("Lat",Msg::kWarning)
      << " connect attempts to violate topology constraint." << endl;
    return 0;
  }
}

//--- connect(id,Link*,id) ---------------------------------------
LatticeBase::Link*
LatticeBase::
connect(LeftID lid, Link* pLink, RightID rid)
{
  return (0 == pLink) ? connect(lid, rid) : connect(lid, *pLink, rid);
}

//--- connect(id,Link&) -------------------------------------------
LatticeBase::Link*
LatticeBase::connect(LeftID lid, Link& link)
{
  VectorLeftID& ld    = link.m_VLeftID;
  LeftNode*     pLeft = leftNode(lid);

  // Make the connection if topology constraint is satisfied.
  if (    find(ld.begin(),ld.end(),lid) != ld.end()
      || (checkLNtopo(pLeft) && checkLLtopo(link)) )
  {
    addLeftNodeToLink(lid, link);
    return &link;
  }
  else
  {
    MSG("Lat",Msg::kWarning)
      << " connect attempts to violate topology constraint." << endl;
    return 0;
  }
}

//--- connect(Link&,id) ------------------------------------------
LatticeBase::Link*
LatticeBase::connect(Link& link, RightID rid)
{
  VectorRightID& rd     = link.m_VRightID;
  RightNode*     pRight = rightNode(rid);


  // Make the connection if topology constraint is satisfied.
  if (    find(rd.begin(),rd.end(),rid) != rd.end()
      || (checkRNtopo(pRight) && checkRLtopo(link)) )
  {
    addRightNodeToLink(rid, link);  
    return &link;
  }
  else
  {
    MSG("Lat",Msg::kWarning)
      << " connect attempts to violate topology constraint." << endl;
    return 0;
  }
}

//----------------------------------------------------------------+
// removeLink(link) Remove the specified link, deleting its data. |
//----------------------------------------------------------------+
void LatticeBase::removeLink(Link& link)
{
  delete &link;
}

//------------------------------------------------+
// Lattice data.                                  |
//  vLeftID ()                                    |
//  vRightID()                                    |
//  links   ()                                    |
//   Returns the Lattice's identifiers and links. |
//------------------------------------------------+
//--- vLeftID ----------------------------------------------------
const LatticeBase::VectorLeftID&
LatticeBase      ::vLeftID() const
{
  return m_VLeftID;
}

//--- vRightID ---------------------------------------------------
const LatticeBase::VectorRightID&
LatticeBase      ::vRightID() const
{
  return m_VRightID;
}

//--- links ------------------------------------------------------
const LatticeBase::Links&
LatticeBase      ::links() const
{
  return m_Links;
}

//--------------------------------------------------------------+
// Identifier specific data.                                    |
//  Given a datum, retrieve its associated links or other data. |
//--------------------------------------------------------------+

//---------------------------------------------------------+
// linksGivenLeft (LeftID  or LeftItr)                     |
// linksGivenRight(RightID or RightItr)                    |
//   Returns a pointer to the table of links used by the   |
//   given object.  If the object does not exist, return 0.|
//---------------------------------------------------------+
//--- linksGivenLeft ----------------------------------------------------
const LatticeBase::Links*
LatticeBase::
linksGivenLeft(LeftID leftID) const
{
  const LeftNode* pLN = leftNode(leftID);
  return (0==pLN) ? 0 : &(pLN->links());
}

const LatticeBase::Links*
LatticeBase::
linksGivenLeft(LeftItr leftItr) const
{
  return linksGivenLeft(*leftItr);
}

//--- linksGivenRight -----------------------------------------------------
const LatticeBase::Links*
LatticeBase::
linksGivenRight(RightID rID) const
{
  const RightNode* pRN = rightNode(rID);
  return (0==pRN) ? 0 : &(pRN->links());
}

const LatticeBase::Links*
LatticeBase::
linksGivenRight(RightItr rightItr) const
{
  return linksGivenRight(*rightItr);
}

//----------------------------------------------------------------+
// linkGivenLeft (LeftID  or LeftItr)                             |
// linkGivenRight(RightID or RightItr)                            |
//  Retrieve one datum's only link.                               |
//  Fails (returns 0) if there is not exactly one link present.   |
// Both const and non-const versions, so user can change LinkData.|
//----------------------------------------------------------------+
//--- linkGivenLeft -----------------------------------------------------
const LatticeBase::Link*
LatticeBase      ::
linkGivenLeft(LeftID leftID) const
{
  const LeftNode* pLN = leftNode(leftID);
  return ( (0==pLN)  || (1 != pLN->links().size()) )?
    0 : pLN->links().front();
}

LatticeBase::Link*
LatticeBase::
linkGivenLeft(LeftID leftID)
{
  const LeftNode* pLN = leftNode(leftID);
  return ( (0==pLN)  || (1 != pLN->links().size()) )?
    0 : pLN->links().front();
}

const LatticeBase::Link*
LatticeBase      ::
linkGivenLeft(LeftItr leftItr) const
{
  return linkGivenLeft(*leftItr);
}

LatticeBase::Link*
LatticeBase::
linkGivenLeft(LeftItr leftItr)
{
  return linkGivenLeft(*leftItr);
}

//--- linkGivenRight ------------------------------------------------------
const LatticeBase::Link*
LatticeBase      ::
linkGivenRight(RightID rightID) const
{
  const RightNode* pRN = rightNode(rightID);
  return ( (0==pRN) || (1 != pRN->links().size()) ) ? 0 : pRN->links().front();
}

LatticeBase::Link*
LatticeBase::
linkGivenRight(RightID rightID)
{
  const RightNode* pRN = rightNode(rightID);
  return ( (0==pRN) || (1 != pRN->links().size()) ) ? 0 : pRN->links().front();
}

const LatticeBase::Link*
LatticeBase      ::
linkGivenRight(RightItr rightItr) const
{
  return linkGivenRight(*rightItr);
}

LatticeBase::Link*
LatticeBase::
linkGivenRight(RightItr rightItr)
{
  return linkGivenRight(*rightItr);
}

//--------------------------------------------------------+
// Go from left to right, left to left, etc.              |
//  vLeftGivenLeft  (LeftID  or LeftItr)                  |
//  vRightGivenRight(RightID or RightItr)                 |
//  vRightGivenLeft (LeftID  or LeftItr)                  |
//  vLeftGivenRight (RightID or RightItr)                 |
//   Returns a pointer to a vector of IDs connected to or |
//   sharing links with a given datum.  If the datum does |
//   not exist, return 0.                                 |
//--------------------------------------------------------+
//--- vLeftGivenLeft --------------------------------------------------------
const LatticeBase::VectorLeftID*
LatticeBase      ::
vLeftGivenLeft(LeftID leftID) const
{
  const LeftNode* pLN = leftNode(leftID);
  return (0==pLN) ? 0 : &(pLN->m_VLeftID);
}

const LatticeBase::VectorLeftID*
LatticeBase      ::
vLeftGivenLeft(LeftItr i) const
{
  return vLeftGivenLeft(*i);;
}

//--- vRightGivenRight ------------------------------------------------------
const LatticeBase::VectorRightID*
LatticeBase      ::
vRightGivenRight(RightID rightID) const
{
  const RightNode* pRN = rightNode(rightID);
  return (0==pRN) ? 0 : &(pRN->m_VRightID);
}

const LatticeBase::VectorRightID*
LatticeBase      ::
vRightGivenRight(RightItr i) const
{
  return vRightGivenRight(*i);
}

//--- vRightGivenLeft(LeftID) -----------------------------------------------
const LatticeBase::VectorRightID*
LatticeBase      ::
vRightGivenLeft(LeftID leftID) const
{
  const LeftNode* pLN = leftNode(leftID);
  return (0==pLN) ? 0 : &(pLN->m_VRightID);
}

const LatticeBase::VectorRightID*
LatticeBase      ::
vRightGivenLeft(LeftItr i) const
{
  return vRightGivenLeft(*i);
}

//--- vLeftGivenRight ------------------------------------------------------
const LatticeBase::VectorLeftID*
LatticeBase      ::
vLeftGivenRight(RightID rightID) const
{
  const RightNode* pRN = rightNode(rightID);
  return (0==pRN) ? 0 : &(pRN->m_VLeftID);
}

const LatticeBase::VectorLeftID*
LatticeBase      ::
vLeftGivenRight(RightItr i) const
{
  return vLeftGivenRight(*i);
}

//--------------------------------------------------------------+
// Fill a vector (supplied by the user) that points to the      |
// links that connect one datum to another, or that they share. |
//  connectLinks   (left,  right, Links&) \  Left and right     |
//  shareLinksLeft (left,  left,  Links&)  > can be identifier  |
//  shareLinksRight(right, right, Links&) /  or iterator.       |
//--------------------------------------------------------------+
//--- connectLinks -------------------------------------------------------
void
LatticeBase::
connectLinks(LeftID leftID, RightID rightID , Links& links) const
{
  // Get the left node's right data container (rd=0 if leftID is not valid).
  const VectorRightID* rd = vRightGivenLeft(leftID);
  if(0 != rd)
  {
    // If rightID is in it, look for the links that make the connection
    if (find(rd->begin(), rd->end(), rightID) != rd->end())
    {
      // Look for rightID in each link's right data container.
      // If it's there, put the link in the user provided link container.
      const Links* list = linksGivenLeft(leftID);
      for (LinkItr i = list->begin();  i != list->end(); ++i)
      { const VectorRightID& rd2 = (*i)->vRightID();
        if (find(rd2.begin(), rd2.end(), rightID) != rd2.end())
        {
          links.push_back(*i);
        }
      }
    }
  }
}

void
LatticeBase::
connectLinks(LeftItr li, RightItr ri, Links& links) const
{
  connectLinks(*li, *ri, links);
}

//--- shareLinksLeft ---------------------------------------------------
void
LatticeBase::
shareLinksLeft(LeftID leftID1, LeftID leftID2, Links& links) const
{
  // Get the first node's left data container (ld1=0 if leftID1 is not valid).
  const VectorLeftID* ld1 = vLeftGivenLeft(leftID1);
  if(0 != ld1)
  {
    // If leftID2 is in it, look for the links that make the connection
    if (find(ld1->begin(), ld1->end(), leftID2) != ld1->end())
    {
      // Look for leftID2 in each link's left data container.
      // If it's there, put the link in the user provided link container.
      const Links* list = linksGivenLeft(leftID2);
      for (LinkItr i = list->begin();  i != list->end(); ++i)
      { const VectorLeftID& ld2 = (*i)->vLeftID();
        if (find(ld2.begin(), ld2.end(), leftID2) != ld2.end())
        {
          links.push_back(*i);
        }
      }
    }
  }
}

void
LatticeBase::
shareLinksLeft(LeftItr li1, LeftItr li2, Links& links) const
{
  shareLinksLeft(*li1, *li2, links);
}

//--- shareLinksRight ------------------------------------------------------
void
LatticeBase::
shareLinksRight(RightID rightID1, RightID rightID2, Links& links) const
{
  // Get the first node's right data container (rd1=0 if rightID1 not valid).
  // If rightID2 is in it, look for the links that make the connection
  const VectorRightID* rd1 = vRightGivenRight(rightID1);
  if(0 != rd1)
  {
    if (find(rd1->begin(), rd1->end(), rightID2) != rd1->end())
    {
      // Look for rightID2 in each link's right data container.
      // If it's there, put the link in the user provided link container.
      const Links* list = linksGivenRight(rightID2);
      for (LinkItr i = list->begin();  i != list->end(); ++i)
      { const VectorRightID& rd2 = (*i)->vRightID();
        if (find(rd2.begin(), rd2.end(), rightID2) != rd2.end())
        {
          links.push_back(*i);
        }
      }
    }
  }
}

void
LatticeBase::
shareLinksRight(RightItr ri1, RightItr ri2, Links& links) const
{
  shareLinksRight(*ri1, *ri2, links);
}

//----------------------------------------------------------------+
// Return a pointer to the one link that connects one datum to    |
// another, or that they share.                                   |
//  connectLink   (left, right, Links&)  \  Left and right        |
//  shareLinkLeft (left, left,  Links&)   > can be identifier     |
//  shareLinkRight(left, left,  Links&)  /  or iterator.          |
// Return 0 if there are no links, or more than one.              |
// Both const and non-const versions, so user can change LinkData.|
//----------------------------------------------------------------+
//--- connectLink --------------------------------------------------------
// Code that is shared between const & non-const versions.
const LatticeBase::Link*
LatticeBase      ::
cLshared(LeftID lid, RightID rid) const
{
  const Link* pLink = 0;
  // Get the left node's right ID container.  Abort if lid is not valid.
  const VectorRightID* v1 = vRightGivenLeft(lid);
  if(0 == v1)
  {
    return 0;
  }

  // Look for the links that make the connection
  if (find(v1->begin(), v1->end(), rid) != v1->end())
  {
    // Look for rid in each link's right data container.
    // The first time it's found, set pLink.
    // If it's found a second time, abort (return 0).
    const Links* list = linksGivenLeft(lid);
    for (LinkItr i = list->begin();  i != list->end(); ++i)
    { const VectorRightID& v2 = (*i)->vRightID();
      if (find(v2.begin(), v2.end(), rid) != v2.end())
      {
        if (0 == pLink)
        {
          pLink = *i;
        }
        else
        {
          return 0;
        }
      }
    }
  }
  return pLink;
}

const LatticeBase::Link*
LatticeBase      ::
connectLink(LeftID lid, RightID rid) const
{
  return cLshared(lid,rid);
}

LatticeBase::Link*
LatticeBase::
connectLink(LeftID lid, RightID rid)
{
  return const_cast<Link*>(cLshared(lid,rid));
}

const LatticeBase::Link*
LatticeBase      ::
connectLink(LeftItr li, RightItr ri) const
{
  return connectLink(*li, *ri);
}

LatticeBase::Link*
LatticeBase::
connectLink(LeftItr li, RightItr ri)
{
  return connectLink(*li, *ri);
}

//--- shareLinkLeft ----------------------------------------------------------
// Code that is shared between const & non-const versions.
const LatticeBase::Link*
LatticeBase      ::
sLLshared(LeftID id1, LeftID id2) const
{
  const Link* pLink = 0;
  // Get the first node's left ID container.  Abort if the ID is not valid.
  const VectorLeftID* v1 = vLeftGivenLeft(id1);
  if(0 == v1)
  {
    return 0;
  }

  // Look for the links that make the connection
  if (find(v1->begin(), v1->end(), id2) != v1->end())
  {
    // Look for id2 in each link's left data container.
    // The first time it's found, set pLink.
    // If it's found a second time, abort (return 0).
    const Links* list = linksGivenLeft(id1);
    for (LinkItr i = list->begin();  i != list->end(); ++i)
    { const VectorLeftID& v2 = (*i)->vLeftID();
      if (find(v2.begin(), v2.end(), id2) != v2.end())
      {
        if (0 == pLink)
        {
          pLink = *i;
        }
        else
        {
          return 0;
        }
      }
    }
  }
  return pLink;
}

const LatticeBase::Link*
LatticeBase      ::
shareLinkLeft(LeftID id1, LeftID id2) const
{
  return sLLshared(id1,id2);
}

LatticeBase::Link*
LatticeBase::
shareLinkLeft(LeftID id1, LeftID id2)
{
  return const_cast<Link*>(sLLshared(id1,id2));
}

const LatticeBase::Link*
LatticeBase::
shareLinkLeft(LeftItr i1, LeftItr i2) const
{
  return shareLinkLeft(*i1, *i2);
}

LatticeBase::Link*
LatticeBase::
shareLinkLeft(LeftItr i1, LeftItr i2)
{
  return shareLinkLeft(*i1, *i2);
}

//--- shareLinkRight ----------------------------------------------------------
// Code that is shared between const & non-const versions.
const LatticeBase::Link*
LatticeBase      ::
sLRshared(RightID id1, RightID id2) const
{
  Link* pLink = 0;
  // Get the first node's left ID container.  Abort if the ID is not valid.
  const VectorRightID* v1 = vRightGivenRight(id1);
  if(0 == v1)
  {
    return 0;
  }

  // Look for the links that make the connection
  if (find(v1->begin(), v1->end(), id2) != v1->end())
  {
    // Look for id2 in each link's right data container.
    // The first time it's found, set pLink.
    // If it's found a second time, abort (return 0).
    const Links* list = linksGivenRight(id1);
    for (LinkItr i = list->begin();  i != list->end(); ++i)
    { const VectorRightID& v2 = (*i)->vRightID();
      if (find(v2.begin(), v2.end(), id2) != v2.end())
      {
        if (0 == pLink)
        {
          pLink = *i;
        }
        else
        {
          return 0;
        }
      }
    }
  }
  return pLink;
}

const LatticeBase::Link*
LatticeBase      ::
shareLinkRight(RightID id1, RightID id2) const
{

  return sLRshared(id1,id2);
}

LatticeBase::Link*
LatticeBase::
shareLinkRight(RightID id1, RightID id2)
{
  return const_cast<Link*>(sLRshared(id1,id2));
}

const LatticeBase::Link*
LatticeBase      ::
shareLinkRight(RightItr i1, RightItr i2) const
{
  return shareLinkRight(*i1, *i2);
}

LatticeBase::Link*
LatticeBase::
shareLinkRight(RightItr i1, RightItr i2)
{
  return shareLinkRight(*i1, *i2);
}

//----------------------------------------------+
// Status information.                          |
//  isEmpty()  True if no links have been made. |
//----------------------------------------------+
Bool_t
LatticeBase::isEmpty() const
{
  return 0 == m_Links.size();
} 

//-------------------------------------------------+
// Lattice topology information:                   |
//  isLNodeMulti(), etc                            |
//   Return a Bool_t, true if the corresponding |
//   topology characteristic is enabled.           |
//  topologyText()                                 |
//   Return a string describing the topology.      |
//-------------------------------------------------+
Bool_t
LatticeBase::isLNodeMulti() const
{
  return m_Topology[LNodeMulti];
} 

//--- isRNodeMulti() -----------------------------------------------
Bool_t
LatticeBase::isRNodeMulti() const
{
  return m_Topology[RNodeMulti];
}

//--- isLLinkMulti() -----------------------------------------------
Bool_t
LatticeBase::isLLinkMulti() const
{
  return m_Topology[LLinkMulti];
}

//--- isRLinkMulti -------------------------------------------------
Bool_t
LatticeBase::isRLinkMulti() const
{
  return m_Topology[RLinkMulti];
}

//--- topologyText() -----------------------------------------------
string
LatticeBase::topologyText() const
{
  if ( !(   isLNodeMulti() || isRNodeMulti()
         || isLLinkMulti() || isRLinkMulti()) )
  {
    return " default (single connections only)";
  }
  else 
  {
    string s = "";
    if (m_Topology[LNodeMulti]) { s += " LNodeMulti";}
    if (m_Topology[RNodeMulti]) { s += " RNodeMulti";}
    if (m_Topology[LLinkMulti]) { s += " LLinkMulti";}
    if (m_Topology[RLinkMulti]) { s += " RLinkMulti";}
    return s;
  }
}

//--------------------------+
// show(ostream&)           |
//  Shows Lattice contents. |
//--------------------------+
void
LatticeBase::show(ostream& os) const
{
  typedef LatticeBase Lattice;
  os << "Lattice has topology " << "Sorry, not available yet"          << endl
     << " It contains: " << m_LeftNodes.size()  << " left  data," << endl
     << "              " << m_RightNodes.size() << " right data," << endl
     << "          and " << m_Links.size()      << " links."      << endl;

  // Display the left nodes.
  Lattice::LNodeItr iL    = m_LeftNodes.begin();
  Lattice::LNodeItr iLend = m_LeftNodes.end();
  for ( ; iL != iLend; ++iL)
  {
    (*iL)->show(os);
  }

  // Display the right nodes.
  Lattice::RNodeItr iR    = m_RightNodes.begin();
  Lattice::RNodeItr iRend = m_RightNodes.end();
  for ( ; iR != iRend; ++iR)
  {
    (*iR)->show(os);
  }

  // Display the links.
  Lattice::LinkItr iLink    = links().begin();
  Lattice::LinkItr iLinkEnd = links().end();
  for ( ; iLink != iLinkEnd; ++iLink)
  {
    if (0 != *iLink)
    {
      (*iLink)->show(os);
    }
  }
}

//--- showLeft(LeftItr, ostream&) ------------------------------
void
LatticeBase::
showLeft(LeftItr i, ostream& os) const
{
  leftNode(*i)->show(os);
}

//--- showLeft(LeftID, ostream&) ------------------------------
void
LatticeBase::
showLeft(LeftID id, ostream& os) const
{
  leftNode(id)->show(os);
}

//--- showLeft(LeftItr, ostream&) ------------------------------
void
LatticeBase::
showRight(RightItr i, ostream& os) const
{
  rightNode(*i)->show(os);
}

//--- showRight(RightID, ostream&) ------------------------------
void
LatticeBase::
showRight(RightID id, ostream& os) const
{
  rightNode(id)->show(os);
}

//--- showLink(Link*, ostream&) ---------------------------------
void
LatticeBase::
showLink(Link* pLink, ostream& os) const
{
  pLink->show(os);
}

//--- showLink(LinkItr, ostream&) ---------------------------------
void
LatticeBase::
showLink(LinkItr i, ostream& os) const
{
  (*i)->show(os);
}

//------------------------------------------------------+
// Make new nodes:                                      |
//  newLeftNode (LeftID)                                |
//  newRightNode(RightID)                               |
//    Add a new node to the Lattice.  Keep two vectors, |
//    one of identifiers and one of pointers.           |
//    Return ->new node, or 0 if it failed.             |
//    Don't supercede an existing identifier.           |
//------------------------------------------------------+
LatticeBase::LeftNode*
LatticeBase::newLeftNode(LeftID id)
{
  LeftNode* pLN(0);
  if (find(m_VLeftID.begin(),m_VLeftID.end(),id) == m_VLeftID.end())
  {
    m_LeftNodes.push_back(pLN = new LeftNode(id));
    m_VLeftID  .push_back(id);
  }
  else
  {
    MSG("Lat",Msg::kWarning) << "Duplicate left identifier: " << id << endl;
  }
  return pLN;
}

//--- newRightNode(id) ---------------------------------------------
LatticeBase::RightNode*
LatticeBase::newRightNode(RightID id)
{
  RightNode* pRN(0);
  if (find(m_VRightID.begin(),m_VRightID.end(),id) == m_VRightID.end())
  {
    m_RightNodes.push_back(pRN = new RightNode(id));
    m_VRightID  .push_back(id);
  }
  else
  {
    MSG("Lat",Msg::kWarning) << "Duplicate right identifier: " << id << endl;
  }
  return pRN;
}

//----------------------------------------------+
// Data access aids (protected)                 |
//  leftNode(id), rightNode(id)                 |
//   Given an ID, return a pointer to the node. |
//   If no node exists, return 0.               |
//----------------------------------------------+
LatticeBase::LeftNode*
LatticeBase::leftNode(LeftID leftID) const
{
  LeftItr found = find(m_VLeftID.begin(),m_VLeftID.end(),leftID);
  if (found != m_VLeftID.end())
  {
    unsigned int index = found - m_VLeftID.begin();
    return m_LeftNodes[index];
  }
  else
  {
    return 0;
  }
}

//--- rightNode(id) -----------------------------------------------
LatticeBase::RightNode*
LatticeBase::rightNode(RightID rightID) const
{
  RightItr found = find(m_VRightID.begin(),m_VRightID.end(),rightID);
  if (found != m_VRightID.end())
  {
    unsigned int index = found - m_VRightID.begin();
    return m_RightNodes[index];
  }
  else
  {
    return 0;
  }
}

//---------------------------------------------------------+
// Check topology constraints (private).                   |
//  Return true if node or link can have a new connection. |
//---------------------------------------------------------+
Bool_t
LatticeBase::checkLNtopo(LeftNode* pLN)
{
  return m_Topology[LNodeMulti] || (0 == pLN->m_Links.size());
}

//--- checkRNtopo(RightNode*)---------------------------------------
Bool_t
LatticeBase::
checkRNtopo(RightNode* pRN)
{
  return m_Topology[RNodeMulti] || (0 == pRN->m_Links.size());
}

//--- checkLLtopo(Link&) -------------------------------------------
Bool_t
LatticeBase::checkLLtopo(Link& link)
{
  return m_Topology[LLinkMulti] || (0 == link.m_VLeftID.size());
}

//--- checkRLtopo(Link&) --------------------------------------------
Bool_t
LatticeBase::checkRLtopo(Link& link)
{
  return m_Topology[RLinkMulti] || (0 == link.m_VRightID.size());
}

//------------------------------------------------------------------+
// Add a node to a link:                                            |
// Add the node to the link's left map.                             |
// Add the node to the left or right data of the other linked nodes.|
// Add the other linked nodes to the left or right data of the node.|
// A node does not go into its own left or right data.              |
//  link     The link to be modified.                               |
//  id       Identifier of the node to be added.                    |
//  pThis    Pointer to the node to be added.                       |
//  ld,rd    The link's left and right node identifier vectors.     |
//------------------------------------------------------------------+
void
LatticeBase::
addLeftNodeToLink(LeftID id, Link& link)
{
  // If this node is already in the link's left vector, abort.
  VectorLeftID& ld = link.m_VLeftID;
  if (find(ld.begin(),ld.end(),id) != ld.end())
  {
    return;
  }

  LeftNode* pThis = leftNode(id);
  Links& links    = pThis->m_Links;

  // Iterate over the link's left vector.  Update the left node vectors.
  // We must test that two nodes aren't already connected by another link.
  for (LeftItr iL = ld.begin();  iL != ld.end();  ++iL)
  {
    VectorLeftID& nv = pThis->m_VLeftID;
    if (find(nv.begin(),nv.end(),*iL) == nv.end())
    {
      leftNode(*iL)->m_VLeftID.push_back(id);
      pThis        ->m_VLeftID.push_back(*iL);
    }
  }

  // Push this node onto the link's left node vector,
  // and the link onto the node's link vector.
  ld   .push_back(id);
  links.push_back(&link);

  // Iterate over the link's right vector.  Update the far node vectors.
  // We must test that two nodes aren't already connected by another link.
  VectorRightID& rd = link.m_VRightID;
  for (RightItr iR = rd.begin();  iR != rd.end();  ++iR)
  {
    VectorRightID&fv = pThis->m_VRightID;
    if (find(fv.begin(),fv.end(),*iR) == fv.end())
    {
      rightNode(*iR)->m_VLeftID. push_back(id);
      pThis         ->m_VRightID.push_back(*iR);
    }
  }
}

//--- addRightNodeToLink(id,Link&) -------------------------------
void
LatticeBase::
addRightNodeToLink(RightID id, Link& link)
{
  // If this node is already in the link's right vector, abort.
  VectorRightID& rd = link.m_VRightID;
  if (find(rd.begin(),rd.end(),id) != rd.end())
  {
    return;
  }
  
  RightNode* pThis = rightNode(id);
  Links&     links = pThis->m_Links;

  // Iterate over the link's right vector.  Update the right node vectors.
  // We must test that two nodes aren't already connected by another link.
  for (RightItr iR = rd.begin();  iR != rd.end(); ++iR)
  {
    VectorRightID nv = pThis->m_VRightID;
    if (find(nv.begin(),nv.end(),*iR) == nv.end())
    {
      rightNode(*iR)->m_VRightID.push_back(id);
      pThis         ->m_VRightID.push_back(*iR);
    }
  }

  // Push this node onto the link's right node vector,
  // and the link onto the node's link vector.
  rd   .push_back(id);
  links.push_back(&link);

  // Iterate over the link's left vector.  Update the far node vectors.
  // We must test that two nodes aren't already connected by another link.
  VectorLeftID& ld = link.m_VLeftID;
  for (LeftItr iL = ld.begin();  iL != ld.end();  ++iL)
  {
    VectorLeftID& fv = pThis->m_VLeftID;
    if (find(fv.begin(),fv.end(),*iL) == fv.end())
    {
      leftNode(*iL)->m_VRightID.push_back(id);
      pThis        ->m_VLeftID .push_back(*iL);
    }
  }
}

---