src/DomainMap/DomainMap.cpp

Go to the documentation of this file.

// -*- C++ -*-
/***************************************************************************
 *
 * The IPPL Framework
 * 
 * This program was prepared by PSI. 
 * All rights in the program are reserved by PSI.
 * Neither PSI nor the author(s)
 * makes any warranty, express or implied, or assumes any liability or
 * responsibility for the use of this software
 *
 * Visit http://www.acl.lanl.gov/POOMS for more details
 *
 ***************************************************************************/

// -*- C++ -*-
/***************************************************************************
 *
 * The IPPL Framework
 * 
 *
 * Visit http://people.web.psi.ch/adelmann/ for more details
 *
 ***************************************************************************/

// include files
#include "Index/NDIndex.h"
#include "Utility/RefCounted.h"
#include "Field/LField.h"
#include "FieldLayout/Vnode.h"
#include "Profile/Profiler.h"






// Insert a new key in the DomainMap.

template < class Key , class T , class Touches, class Contains, class Split > 
void
DomainMap<Key,T,Touches,Contains,Split>::insert(const value_type& d,
                                                bool noSplit)
{
  TAU_TYPE_STRING(taustr, CT(*this) + " void (value_type)"); 
  TAU_PROFILE("DomainMap::insert()", taustr, TAU_DOMAINMAP);

  // Tell the tree top to insert.
  Root->insert(d, noSplit);
  // Increment the total size.
  Size += 1;
  // Update the pointer to the first element.
  update_leftmost();
}


// Recalculate the first element in the tree.

template < class Key , class T , class Touches, class Contains, class Split > 
void
DomainMap<Key,T,Touches,Contains,Split>::update_leftmost()
{
  TAU_TYPE_STRING(taustr, CT(*this) + " void ()"); 
  TAU_PROFILE("DomainMap::update_leftmost()", taustr, TAU_DOMAINMAP);

  Node *p=Root;
  // First dive all the way left.
  while ( p->Left )
    p = p->Left;
  // Look for the first element.
  typename Node::cont_type::iterator v;
  while ( (v=p->cont.begin()) == p->cont.end() ) {
    // First look right.
    if ( p->Right ) {
      // If it is there, go there and then all the way left.
      p = p->Right;
      while ( p->Left )
        p = p->Left;
    }
    else {
      // If there is no right, go up until you can go right more.
      Node *y = p->Parent;
      while (y && (p==y->Right)) {
        p = y;
        y = y->Parent;
      }
      p = y;
    }
  }
  if ( (Leftmost.p=p) != 0 ) 
    Leftmost.v = v;
}


// Find the range that touches a given T.

template < class Key, class T , class Touches, class Contains, class Split > 
pair<typename DomainMap<Key,T,Touches,Contains,Split>::touch_iterator,
     typename DomainMap<Key,T,Touches,Contains,Split>::touch_iterator>
DomainMap<Key,T,Touches,Contains,Split>::touch_range(const Key& t) const
{ 
  TAU_TYPE_STRING(taustr, "pair<" + CT(*this)
    + "::touch_iterator, " + CT(*this) + "::touch_iterator > (Key) "); 
  TAU_PROFILE("DomainMap::iterator::op_pp()", taustr, TAU_DOMAINMAP);

  typedef pair<touch_iterator,touch_iterator> ret_pair;
  Node *p=Root;

  if ( p ) {

    // First dive left, checking touches.
    for ( Node* y=p->Left; y && Touches::test(t,y->MyDomain); y=y->Left )
      p = y;

    do {
      // Look for the first element that actually touches.
      for (typename Node::cont_type::iterator v=p->cont.begin();
           v!=p->cont.end(); ++v)
        if ( Touches::test(t,(*v).first) ) {
          // Found it!
          touch_iterator f;
          f.TouchThis = t;
          f.p = p;
          f.v = v;
          return pair<touch_iterator,touch_iterator>(f,touch_iterator());
        }

      // Didn't find one here. Move on.
      Node *y = p->Right;
      if ( y && Touches::test(t,y->MyDomain) ) {
        // If it is there, go there and then all the way left.
        p = y;
        for ( y=p->Left; y && Touches::test(t,y->MyDomain) ; y=y->Left ) 
          p = y;
      }
      else {
        // If there is no right, go up until you can go right more.
        for ( y = p->Parent; y && (p==y->Right); y = y->Parent )
          p = y;
        p = y;
      }
    } while (p);
  }
  // Didn't find any.
  return pair<touch_iterator,touch_iterator>(touch_iterator(),touch_iterator());
}


//
// Copy ctor and assign do deep copies.
//

template < class Key, class T , class Touches, class Contains, class Split > 
DomainMap<Key,T,Touches,Contains,Split>::
DomainMap(const DomainMap<Key,T,Touches,Contains,Split>& a)
: Root( new Node(a.Root->MyDomain) ), Size(0)
{
  TAU_TYPE_STRING(taustr, "void (" + CT(a) + ")"); 
  TAU_PROFILE("DomainMap::DomainMap()", taustr, TAU_DOMAINMAP);

  for (iterator p=a.begin(); p!=a.end(); ++p)
    insert_noupdate( *p );
  update_leftmost();
}

template < class Key, class T , class Touches, class Contains, class Split > 
void
DomainMap<Key,T,Touches,Contains,Split>::
operator=(const DomainMap<Key,T,Touches,Contains,Split>& a)
{
  TAU_TYPE_STRING(taustr, "void (" + CT(a) + ")" ); 
  TAU_PROFILE("DomainMap::operator=()", taustr, TAU_DOMAINMAP);

  if ( this != &a ) {
    // Clean out the current contents.
    delete Root;
    Root = new Node( a.Root->MyDomain );
    Size = 0;
    // Add the new stuff.
    for (iterator p=a.begin(); p!=a.end(); ++p)
      insert_noupdate( *p );
    // Reset the pointer to the first one.
    update_leftmost();
  }
}
/***************************************************************************
 * $RCSfile: DomainMap.cpp,v $   $Author: adelmann $
 * $Revision: 1.1.1.1 $   $Date: 2003/01/23 07:40:25 $
 * IPPL_VERSION_ID: $Id: DomainMap.cpp,v 1.1.1.1 2003/01/23 07:40:25 adelmann Exp $ 
 ***************************************************************************/

---