package BoxTools;
import java.lang.Math;
/**
*	A <code>BoxLayout</code> object contains a set of boxes(RectDomains) along with their processor/
*	process assignments. Each box in a <code>BoxLayout</code> has a processor/process number assigned
*	to it, and each processor/process may be assigned to  multiple boxes. These boxes may not be 
*	disjointed. A <code>BoxLayout</code> object serves as the metadata of a distributed data structure
*	defined on the boxes  this <code>BoxLayout</code> object contains and their processor assignments. 
*	The default constructor constructs an open <code>BoxLayout</code>. Boxes may be added/deleted to an 
*	open <code> BoxLayout </code>. But  when a <code>BoxLayout</code> is closed, no change is allowed.
*	Before a <code>BoxLayout</code> being closed, boxes and their processor/process assignments are 
*	stored in linked lists, so that users can add or delete them easily. When a <code>BoxLayout</code> 
*	is closed, information stored in lists is copied to arrays for better performance. Users can use  
*	the methods <code>coarsen</code>, <code>refine</code>, and <code>highBoundary</code> as well as 
*	<code>lowBoundary</code> to generate a new <code>BoxLayout</code> object. The Layout information
* 	in <code>BoxLayout</code> is single, and all the data in <code>BoxLayout</code> is local. We do not
*	use "single" keyword everywhere to prevent propagating effect of this qualifier.
*	<p> Usage: a <code> BoxLayout </code> object must be declared local. 
*	@see List, LayoutIndex
*	@see <a href="http://davis.lbl.gov/NASA/chombomanual/classBoxLayout.html">Chombo Specification</a>
*	@version 1.1 
*		Modified on Feb 24. Add m_neighbors.
*		//Modified on Aug 09, 2004. Add m_iterator.
*	@author Tong Wen, LBNL
*	@since 1.0
*/ 
public class BoxLayout {
	//static SharedRegion  REGION=new SharedRegion();
	//PrivateRegion  REGION=new PrivateRegion();
	private static final int  SPACE_DIM  =Util.SPACE_DIM;
	private static final int  SORT_DIM  =Util.SORT_DIM;
	private	static int m_counts=0;
	private final int  m_layoutID;
	
	protected String  local m_layoutName;
	/**The <code>i</code>th element in <code>m_procAssignments</code> is the processor/process number  
	 * assigned to the <code>i</code>th box. The size of this array is the number of all the boxes.
	 */
	template List<int >  local temp_procAssignments;
	protected  int [1d] local m_procAssignments;
	/**If the <code>i</code>th box is the <code>j</code>th one assigned to its processor/process, then 
	 * the <code>i</code>th element in <code>m_localIndexes</code> is equal to <code>j</code>.
	 */
	template List<int >  local temp_localIndexes;
	protected int  [1d]   local m_localIndexes;
	/**<code>m_boxes</code> stores all the boxes. */
	template List<RectDomain<SPACE_DIM> > local temp_boxes;	
	protected RectDomain<SPACE_DIM> [1d] local m_boxes;	
	/**<code>m_boxAssignments[i]</code> stores the indexes of all the boxes assigned to the 
	 * <code>i</code>th processor/process. */
	template List<int > local [] local temp_boxAssignments;
	protected int  [1d] local  [1d]  local m_boxAssignments;
	protected int single  m_numOfBoxes;
	protected final int single  m_numOfProcs;
	/**If <code>BoxLayoutA</code> is a copy of or generated from <code>BoxLayoutB</code>, then   
	 * <code>BoxLayoutA.m_root</code> is set to <code> BoxLayoutB.m_root</code>. Otherwise, it is set to 
	 * <code>this</code>.
	 */
	private BoxLayout local m_root;
		
	//private LayoutIterator local m_iterator;

	/**If this BoxLayout is closed, then <code>m_closed</code> is set to <code>ture</code>. */
	protected boolean single m_closed=false;
	/**If the boxes are disjointed, then <code>m_disjointed</code> is set to <code>ture</code>. */
	protected boolean single m_disjointed=false;
	protected int [] local [] local m_neighbors;
	/**If findNeighbors() are called, then <code>m_neighborsFound</code> is set to <code>ture</code>. */
	protected boolean m_neighborsFound=false;
	protected boolean single m_tempUsed=false;
	SharedRegion single m_region;
	protected boolean single m_sorted=false;
	protected DataIndex local [] local m_indexes;

	/** The simple <code>O(n^2)</code> sorting algorithm. */	
	public final  local void sort(RectDomain<SPACE_DIM> single [] single a_Boxes, int single [] single a_procIDs){
				m_sorted=Util.sort(a_Boxes,a_procIDs,SORT_DIM);
	}
	/** To check if boxes in a_Boxes are disjointed. */
	final boolean  single isDisjointed(RectDomain<SPACE_DIM> single [] single a_Boxes, boolean single sorted){
				int single n=a_Boxes.length-1;
				int single i,j,k;
				boolean single disjointed=true;
			checking:	
				for (i=0; i<n;i++){
					//k=(a_Boxes[i].upb())[SORT_DIM];
					for (j=i+1;j<=n;j++){
						if ((a_Boxes[i].upb())[SORT_DIM]<(a_Boxes[j].lwb())[SORT_DIM] && sorted) break;
						if (Util.isJointed(a_Boxes[i],a_Boxes[j])) {disjointed=false; break checking;}
					}
				}
				return disjointed;
	}
	/** To check if boxes in this layout are disjointed. */
	public final local void checkIfDisjointed(){
		if (m_closed){	
				RectDomain<SPACE_DIM> single [] single boxes=new RectDomain<SPACE_DIM> single [m_numOfBoxes];
			        for (int single i=0;i<m_numOfBoxes;i++) boxes[i]=(RectDomain<SPACE_DIM> single)m_boxes[i];
				if (!m_sorted) Util.sort(boxes, SORT_DIM);
				m_disjointed=isDisjointed(boxes, true);
		    }
		else{
			Util.printErrMsg("BoxLayout::checkIfDisjointed: Layout must be closed!");
		}
	}

	private final local void generateDataIndexes(){
		if (m_closed){
			//m_indexes=new(REGION) DataIndex local [m_numOfBoxes] local;
			m_indexes=new DataIndex local [m_numOfBoxes] local;
			DataIndex local DI;
			for(int i=0;i<m_numOfBoxes;i++){
				//DI=new(REGION) DataIndex();
				DI=new DataIndex();
				DI.m_index=i;
				DI.m_root=m_root;
				DI.m_procID=m_procAssignments[i];
				DI.m_dataIndex=m_localIndexes[i];
				m_indexes[i]=DI;
			}		
		}
	}
	public final inline local int getCounts(){return m_counts;}
	public final inline local int getLayoutID(){return m_layoutID;}
	public final inline local String getLayoutName(){return m_layoutName;}
	public final inline local BoxLayout local getRoot(){return m_root;}
	//public final inline local LayoutIterator local getIterator(){m_iterator.reset();m_iterator.Reset();return m_iterator;}

	/*two single qualifiers should be removed? (Asked on Jan 03, 2003)*/
	final inline local boolean  single checkProcIndex(int single i){
		boolean single res=(i >=0 && i<m_numOfProcs);
		if (!res) Util.printErrMsg("BoxLayout: the processor ID is out of range!");
		return res;	
	}
	final inline local boolean checkLayoutIndex(LayoutIndex local a_li){
		boolean res=(a_li.m_root==m_root) && (a_li.m_index >=0) && (a_li.m_index<m_numOfBoxes);
		if (!res) Util.printErrMsg("BoxLayout: invalid LayoutIndex!");
		return res;	
	}
	final inline local boolean checkBoxIndex(int i){
		boolean res=(i >=0 && i<m_numOfBoxes);
		if (!res) Util.printErrMsg("BoxLayout: the box index is out of range!");
		return 	res;
	}
	public final inline local int size(){return m_numOfBoxes;}
	public final inline local boolean single isClosed(){return m_closed;}
	public final inline local boolean single isDisjointed(){return m_disjointed;}
	public final inline local boolean single isSorted(){return m_sorted;}
	/* the single qualifier for method is removed on Dec 18, 2002
	 * this method should be called after using intitialize(). 		
	 */
	public final local void close(){
		int single i;
		if (m_tempUsed){
			m_numOfBoxes=(int single)temp_boxes.size();	
			m_boxes=temp_boxes.toTiArray();
			m_procAssignments=temp_procAssignments.toTiArray();
			m_localIndexes=temp_localIndexes.toTiArray();
			m_boxAssignments=new int [[0:m_numOfProcs-1]] local [1d] local;
			for (i=0;i<m_numOfProcs;i++) m_boxAssignments[i]=temp_boxAssignments[i].toTiArray();
			try{
				m_region.delete();
			}
			catch (RegionInUse oops){
				Util.printErrMsg("BoxLayout::close(): failed to delete m_region");
			}
		}		
		/* temps should be deleted here!*/
		m_closed=true;
		generateDataIndexes();
		//m_iterator=new LayoutIterator(this);
		//checkIfDisjointed();
	}

	public final inline local RectDomain<SPACE_DIM> getBox(LayoutIndex local a_index){
		
		if (checkLayoutIndex(a_index) && m_closed)
			return m_boxes[a_index.m_index];
		else
			return Util.NULL_BOX;
	}

	public final inline local RectDomain<SPACE_DIM> op[](LayoutIndex local a_index){
		
		if (checkLayoutIndex(a_index) && m_closed)
			return m_boxes[a_index.m_index];
		else
			return Util.NULL_BOX;
	}

	public BoxLayout(){
		m_counts++;
		m_layoutID=m_counts;
		m_layoutName="BoxLayout"+m_layoutID;
		m_root=this;
		m_numOfProcs=Ti.numProcs();

	}

	public BoxLayout(RectDomain<SPACE_DIM> single [] single a_Boxes, int single [] single a_procIDs){
		this();	
		//m_sorted=Util.sort(a_Boxes,a_procIDs,SORT_DIM);
		define(a_Boxes,a_procIDs, true);
		m_disjointed=isDisjointed(a_Boxes, m_sorted);
		findNeighbors(1);
		//m_iterator=new LayoutIterator(this);	
	}
	/**<code>a_Boxes</code> is an array of boxes and <code>a_procIDs</code> is the array of corresponding processor/process
	 * assignments. The layout information is single because <code>a_Boxes</code> and <code>a_procIDs</code> are single.
	 */
	public final local void define(RectDomain<SPACE_DIM> single [] single a_Boxes, int single [] single a_procIDs, boolean single sortFirst){
		if (m_closed) {
			Util.printErrMsg("BoxLayout::define( , ): this layout has already been closed!");
			return;
		    }
		else{
			if (a_Boxes.length != a_procIDs.length){
				Util.printErrMsg("BoxLayout::define( , ): the sizes of the two input arrarys must be equal!");
				return;		
			}
			else{
				if (sortFirst) m_sorted=Util.sort(a_Boxes,a_procIDs,SORT_DIM);
				m_numOfBoxes=a_Boxes.length;
				m_procAssignments=new int [[0:m_numOfBoxes-1]];
				m_localIndexes=new int [[0:m_numOfBoxes-1]];
				m_boxes =new RectDomain<SPACE_DIM> [[0:m_numOfBoxes-1]];
				m_boxAssignments=new int [[0:m_numOfProcs-1]] local [1d] local;
				PrivateRegion local region=new PrivateRegion();
				template List<int > local [] local temp_boxAssignments=new  (region) template List<int > local [m_numOfProcs];
				for (int i=0;i<m_numOfProcs;i++) temp_boxAssignments[i]=new (region) template List<int >();
				int single i, procID;
				for (i=0;i<a_procIDs.length;i++) 
					if (!checkProcIndex(a_procIDs[i])) return;					
				
				for (i=0;i<m_numOfBoxes;i++) {
					procID=a_procIDs[i];
					m_boxes[i]=a_Boxes[i];
					m_localIndexes[i]=temp_boxAssignments[procID].size();
					m_procAssignments[i]=procID;
					temp_boxAssignments[procID].addElement(i);
				}

				for (i=0;i<m_numOfProcs;i++) m_boxAssignments[i]=temp_boxAssignments[i].toTiArray();
				m_closed=true;
				generateDataIndexes();
				//m_disjointed=isDisjointed(a_Boxes);
				/*temp memory allocation should be deleted here!*/
				try{
					region.delete();
				}
				catch (RegionInUse oops){
					Util.printErrMsg("BoxLayout::define( , , ): failed to delete PrivateRegion region");
				}
				return;
			}
		}		
	}
	/**don't forget to call close() to close the BoxLayout. */
	public final local void initialize(RectDomain<SPACE_DIM> single [] single a_Boxes, int single [] single a_procIDs, boolean single sortFirst){
		if (m_closed) {
			Util.printErrMsg("BoxLayout::initialize( , ): this layout has already been closed!");
			return;
		    }
		else{
			if (a_Boxes.length != a_procIDs.length){
				Util.printErrMsg("BoxLayout::initialize( , ): the sizes of the two input arrarys must be equal!");
				return;		
			}
			else{
				if (sortFirst) m_sorted=Util.sort(a_Boxes,a_procIDs,SORT_DIM);
				m_region=new SharedRegion();
				temp_procAssignments=new (m_region) template List<int >();
				temp_localIndexes=new (m_region) template List<int >();
				temp_boxes =new (m_region) template List<RectDomain<SPACE_DIM> >();
				temp_boxAssignments=new (m_region) template List<int > local [m_numOfProcs];
				for (int i=0;i<m_numOfProcs;i++) temp_boxAssignments[i]=new (m_region) template List<int >();
				int single i, procID;
				for (i=0;i<a_procIDs.length;i++) 
					if (!checkProcIndex(a_procIDs[i])) {
						return;
					}					
				
				for (i=0;i<a_Boxes.length;i++) {
					procID=a_procIDs[i];
					temp_boxes.addElement(a_Boxes[i]);
					temp_localIndexes.addElement(temp_boxAssignments[procID].size());
					temp_procAssignments.addElement(procID);
					temp_boxAssignments[procID].addElement(i);
				}
				m_numOfBoxes=a_Boxes.length;
				m_tempUsed=true;
				return;
			}
		}		
	}
	/* May 01, 2003 the content of m_neighbors is changed from local to global.  
	public final  local void findNeighbors(int a_distance){
		if (!m_closed) {
			Util.printErrMsg("BoxLayout::findNeighbors(): layout must be closed!");
		    }
		else{	
			int procID=Ti.thisProc();
			int numOfLocalBoxes=m_boxAssignments[procID].domain().size();
			m_neighbors=new int [numOfLocalBoxes] local [] local;
			int [] local buffer=new int[m_numOfBoxes];
			int size,i,j;
			RectDomain<SPACE_DIM> box_i; 
			for (i=0;i<numOfLocalBoxes;i++){
				size=0;
				box_i=m_boxes[m_boxAssignments[procID][i]].accrete(a_distance);
				for (j=0;j<i;j++)
					if (Util.isJointed(m_boxes[j],box_i)){
						buffer[size]=j;size++;
					}
				for (j=i+1;j<m_numOfBoxes;j++){
					if ((box_i.upb())[SORT_DIM]<(m_boxes[j].lwb())[SORT_DIM]&&m_sorted && m_numOfProcs==1) break;
					if (Util.isJointed(m_boxes[j],box_i)){
						buffer[size]=j;size++;
					}
				}
				m_neighbors[i]=new int[size];
				for (j=0;j<size;j++) m_neighbors[i][j]=buffer[j];
				m_neighborsFound=true;
			}
		}
		return; 
	}	
	*/

	/**finds every box in this layout its neighbors. */
	public final  local int [] local [] local  findNeighbors(int a_distance){
		if (!m_closed) {
			Util.printErrMsg("BoxLayout::findNeighbors(): layout must be closed!");
			return null;
		    }
		else{	
			int [] local [] local myNeighbors=new int [m_numOfBoxes] local [] local;
			int i,j;
			PrivateRegion local region=new PrivateRegion();
			template List<int > local [] local temp_neighbors=new (region) template List<int > local [m_numOfBoxes] local;
			for (i=0;i<m_numOfBoxes;i++) temp_neighbors[i]=new (region) template List<int >();
			RectDomain<SPACE_DIM> box; 
			for (i=0;i<m_numOfBoxes;i++){
				box=m_boxes[i].accrete(a_distance);
				for (j=i+1;j<m_numOfBoxes;j++){
					if ((box.upb())[SORT_DIM]<(m_boxes[j].lwb())[SORT_DIM] && m_sorted) break;
					if (Util.isMyNeighbor(m_boxes[j],box)){
						temp_neighbors[i].addElement(j);
						temp_neighbors[j].addElement(i);
					}
				}

			}
			for (i=0;i<m_numOfBoxes;i++) myNeighbors[i]=temp_neighbors[i].toArray();
			
			try{
				region.delete();
			}
			catch (RegionInUse oops){
				Util.printErrMsg("BoxLayout::findNeighbors: failed to delete PrivateRegion region");
			}
			return myNeighbors; 
		}
		
	}
	
	public final  local void findNeighbors(){
		m_neighbors=findNeighbors(1);
		m_neighborsFound=true;	
		return;
	}

	public final  local RectDomain<SPACE_DIM> [] local getNeighbors(LayoutIndex a_index){
		RectDomain<SPACE_DIM> [] local result;
		if (!m_closed) {
			Util.printErrMsg("BoxLayout::getNeighbors(): layout must be closed!");
			return null;
		    }
		else{	
			if (!m_neighborsFound) findNeighbors();
			int index=a_index.m_index;
			int size=m_neighbors[index].length;
			//int size=m_neighbors[m_localIndexes[index]].length;
			result=new RectDomain<SPACE_DIM> [size];
			for (int i=0;i<size;i++) result[i]=m_boxes[m_neighbors[index][i]];
			//for (int i=0;i<size;i++) result[i]=m_boxes[m_neighbors[m_localIndexes[index]][i]];
			return result;
		}
		 
	}

	public final  local DataIndex local [] local getNeighborIdxes(LayoutIndex a_index){
		DataIndex local [] local result;
		if (!m_closed) {
			Util.printErrMsg("BoxLayout::getNeighbors(): layout must be closed!");
			return null;
		    }
		else{	
			if (!m_neighborsFound) findNeighbors();
			int index=a_index.m_index;
			int size=m_neighbors[index].length;
			//int size=m_neighbors[m_localIndexes[index]].length;
			result=new DataIndex local [size];
			DataIndex local DI;
			for (int i=0;i<size;i++){
				DI=new DataIndex();
				DI.m_index=m_neighbors[index][i];
				//DI.m_index=m_neighbors[m_localIndexes[index]][i];	
				DI.m_root=m_root;
				DI.m_procID=m_procAssignments[DI.m_index];
				DI.m_dataIndex=m_localIndexes[DI.m_index];
				result[i]=DI;
			} 
			return result;
		}
		 
	}

	public final  inline local int getProcID(LayoutIndex local a_li){
		//int m_boxIndex=a_li.m_index;
		if (checkLayoutIndex(a_li)){
			if (m_closed)
				return m_procAssignments[a_li.m_index];
			else
				return temp_procAssignments.elementAt(a_li.m_index);
		    }
		else{
			return -1;
		}	
	}

	//final int getBoxIndex(RectDomain<SPACE_DIM> a_box){ return m_boxes.indexOf(a_box);}

	public final inline local int numBoxesAt(int a_procID){
		if (checkProcIndex(a_procID))
			if (m_closed)
				return m_boxAssignments[a_procID].domain().size();
			else
				return temp_boxAssignments[a_procID].size();
		else{
			return 0;
		}
	}

  	final local int [] boxesAt(int a_procID){
		//if (checkProcIndex(a_procID)){
			int size= m_boxAssignments[a_procID].domain().size();
			//Util.printErrMsg("size: "+size);
			int[] temp=new int[size];
			for (int i=0;i<size;i++) 
				if (m_closed)
					temp[i]=m_boxAssignments[a_procID][i];
				else
					temp[i]=temp_boxAssignments[a_procID].elementAt(i);	
			return temp;
		//    }
		//else{
		//	return null;
		//}
	}
	/**A deep copy is generated, but the info in m_neighbors is not copied.*/
	final local  BoxLayout local single copy(){
		if (m_closed){
			BoxLayout local single new_BL=new BoxLayout();
			new_BL.m_layoutName="copy of "+m_layoutName;
			new_BL.m_numOfBoxes=m_numOfBoxes;
			//new_BL.m_numOfProcs=m_numOfProcs;
			new_BL.m_disjointed=m_disjointed;
			new_BL.m_root=m_root;
			int i,j;
			new_BL.m_boxes=new  RectDomain<SPACE_DIM> [[0:m_numOfBoxes-1]];
			//for (i=0;i<m_numOfBoxes;i++) new_BL.m_boxes[i]=m_boxes[i];
			new_BL.m_boxes.copy(m_boxes);
			new_BL.m_procAssignments=new  int [[0:m_numOfBoxes-1]];
			//for (i=0;i<m_numOfBoxes;i++) new_BL.m_procAssignments[i]=m_procAssignments[i];
			new_BL.m_procAssignments.copy(m_procAssignments);
			new_BL.m_localIndexes=new  int [[0:m_numOfBoxes-1]];
			//for (i=0;i<m_numOfBoxes;i++) new_BL.m_localIndexes[i]=m_localIndexes[i];
			new_BL.m_localIndexes.copy(m_localIndexes);
			new_BL.m_boxAssignments=new int [[0:m_numOfProcs-1]] local [1d] local;
			for (i=0;i<m_numOfProcs;i++){
				int length=m_boxAssignments[i].domain().size();
				new_BL.m_boxAssignments[i]=new int [[0:length-1]]; 
				  //for (j=0;j<length;j++) new_BL.m_boxAssignments[i][j]=m_boxAssignments[i][j];
				if (length>0) new_BL.m_boxAssignments[i].copy(m_boxAssignments[i]);
			}
			new_BL.m_closed=true;
			new_BL.m_indexes=m_indexes;
			new_BL.m_sorted=m_sorted;
			//new_BL.m_iterator=new LayoutIterator(new_BL);
			return new_BL;
		    }
		else{
			Util.printErrMsg("BoxLayout::copy(): this layout is not closed!");
			return null;
		}
	}
	/**A deep copy is generated but with the boxes refined by a factor <code>a_factor</code>. */
	public final local BoxLayout  single local refine(int single a_factor){
		BoxLayout local single newLayout=this.copy();
		RectDomain<SPACE_DIM> box;
		Point<SPACE_DIM> lwb,upb;
		//Point<SPACE_DIM> temp;
		final Point<SPACE_DIM> STRIDE,stride;
		int i,j,k;

		if (m_numOfBoxes>0) {STRIDE=newLayout.m_boxes[0].stride();stride=STRIDE*a_factor;}
		for (i=0;i<m_numOfBoxes;i++){
			box=newLayout.m_boxes[i];
			lwb=box.min();upb=box.max();
			//temp=upb-lwb+Point<SPACE_DIM>.all(1);
			lwb=lwb*stride;
			//upb=lwb+temp*stride-Point<SPACE_DIM>.all(1);
			upb=(upb+STRIDE)*stride-STRIDE;
			newLayout.m_boxes[i]=[lwb:upb:STRIDE];
		}
		if (m_neighborsFound){
			newLayout.m_neighbors=new int [m_numOfBoxes] local [] local;
			for (i=0;i<m_numOfBoxes;i++){
				k=m_neighbors[i].length;
				newLayout.m_neighbors[i]=new int [k] local;
				for (j=0;j<k;j++)
					newLayout.m_neighbors[i][j]=m_neighbors[i][j];
			}
			newLayout.m_neighborsFound=true;
		}
		newLayout.m_layoutName="refined "+m_layoutName;
		//newLayout.m_iterator=new LayoutIterator(newLayout);
		return newLayout;
	}
	/**A deep copy is generated but with the boxes coarsened by a factor <code>a_factor</code>. */
	public final local BoxLayout  local single coarsen(int single a_factor){
		BoxLayout local single newLayout=this.copy();
		RectDomain<SPACE_DIM> box;
		Point<SPACE_DIM> lwb,upb;
		//Point<SPACE_DIM> temp;
		final Point<SPACE_DIM> STRIDE,stride;
		int i,j,k;
		if (m_numOfBoxes>0){STRIDE=newLayout.m_boxes[0].stride();stride=STRIDE*a_factor;}
		for (i=0;i<m_numOfBoxes;i++){
			box=newLayout.m_boxes[i];
			lwb=box.min();upb=box.max();
			//temp=lwb; changed on 03/19/03
			lwb=lwb/stride;
			//upb=lwb+(upb-temp)/stride; changed on 03/19/03
			upb=upb/stride;
			newLayout.m_boxes[i]=[lwb:upb:STRIDE];			
		}
		if (m_neighborsFound){
			newLayout.m_neighbors=new int [m_numOfBoxes] local [] local;
			for (i=0;i<m_numOfBoxes;i++){
				k=m_neighbors[i].length;
				newLayout.m_neighbors[i]=new int [k] local;
				for (j=0;j<k;j++)
					newLayout.m_neighbors[i][j]=m_neighbors[i][j];
			}
			newLayout.m_neighborsFound=true;
		}
		newLayout.m_layoutName="coarsened "+m_layoutName;
		//newLayout.m_iterator=new LayoutIterator(newLayout);
		return newLayout;
	}
	public final local BoxLayout  local single accrete(int single a_factor){
		BoxLayout local single newLayout=this.copy();
		final Point<SPACE_DIM> STRIDE;
		if (m_numOfBoxes>0) STRIDE=newLayout.m_boxes[0].stride();
		for (int i=0;i<m_numOfBoxes;i++){
			newLayout.m_boxes[i]=newLayout.m_boxes[i].accrete(a_factor,STRIDE);
		}
		newLayout.m_layoutName="accreted "+m_layoutName;
		//newLayout.m_iterator=new LayoutIterator(newLayout);
		return newLayout;
	}
	/**A deep copy is generated but with each box replaced by the box adjacent to its upper corner
	 * in the direction <code>a_direction </code> of length <code>a_length</code>. 
	 */
	public final local BoxLayout local single highBoundary(int single a_direction, int single a_length, boolean single a_expendBy1){
		int single d=java.lang.Math.abs(a_direction);
		if (d>0 && d<=SPACE_DIM){
			BoxLayout local single newLayout=this.copy();
			RectDomain<SPACE_DIM> box;
			Point<SPACE_DIM> lwb,upb,stride;
			for (int i=0;i<m_numOfBoxes;i++){
				box=newLayout.m_boxes[i];
				lwb=box.min();upb=box.max();stride=box.stride();
				lwb=lwb+Point<SPACE_DIM>.direction(d, upb[d]-lwb[d]+1);
				upb=upb+Point<SPACE_DIM>.direction(d, java.lang.Math.abs(a_length));
				if (a_expendBy1)
					for (int j=1;j<=SPACE_DIM;j++)
						if (j!=d){
							lwb=lwb-Point<SPACE_DIM>.direction(j,1);
							upb=upb+Point<SPACE_DIM>.direction(j,1);
						}
				newLayout.m_boxes[i]=[lwb:upb:stride];
			}
			newLayout.m_layoutName="high boundary of "+m_layoutName;
			//newLayout.m_iterator=new LayoutIterator(newLayout);
			return newLayout;
		}
		else{
			Util.printErrMsg("BoxLayout::highBoundary( , ): direction is out of range!");
			return null;
		}
	}
	/**A deep copy is generated but with each box replaced by the box adjacent to its lower corner
	 * in the direction <code>a_direction </code> of length <code>a_length</code>. 
	 */
	public final local BoxLayout local single lowBoundary(int single a_direction, int single a_length, boolean single a_expendBy1){
		int single d=java.lang.Math.abs(a_direction);
		if (d>0 && d<=SPACE_DIM){
			BoxLayout local single newLayout=this.copy();
			RectDomain<SPACE_DIM> box;
			Point<SPACE_DIM> lwb,upb,stride;
			for (int i=0;i<m_numOfBoxes;i++){
				box=newLayout.m_boxes[i];
				lwb=box.min();upb=box.max();stride=box.stride();
				upb=upb-Point<SPACE_DIM>.direction(d,upb[d]-lwb[d]+1);
				lwb=lwb-Point<SPACE_DIM>.direction(d, java.lang.Math.abs(a_length));
				
				if (a_expendBy1)
					for (int j=1;j<=SPACE_DIM;j++)
						if (j!=d){
							lwb=lwb-Point<SPACE_DIM>.direction(j,1);
							upb=upb+Point<SPACE_DIM>.direction(j,1);
						}
				newLayout.m_boxes[i]=[lwb:upb:stride];
			}
			newLayout.m_layoutName="low boundary of "+m_layoutName;
			//newLayout.m_iterator=new LayoutIterator(newLayout);
			return newLayout;
		}
		else{
			Util.printErrMsg("BoxLayout::lowBoundary( , ): direction is out of range!");
			return null;
		}
	}
	/**this method is used for debugging. */
	public local void myprint(){
		int i,j;
		if (Ti.thisProc()==0)
		if (!m_closed) {
			j=temp_boxes.size();
			System.out.println("temp_boxes.size(): "+j);
			for (i=0;i<j;i++) System.out.print(temp_boxes.elementAt(i).toString()+"; ");
			System.out.print("\n");
			System.out.flush();
			j=temp_procAssignments.size();
			System.out.println("temp_procAssignments.size(): "+j);
			for (i=0;i<j;i++) 
			  System.out.print(temp_procAssignments.elementAt(i)+" local index:"+temp_localIndexes.elementAt(i));
			System.out.print("\n");
			System.out.flush();
			//j=m_boxAssignments.length; /* this will crash the compiler */
			//Util.printErrMsg("m_boxAssignments.length:"+j);
			if (! temp_boxAssignments[0].isEmpty()){
				j=temp_boxAssignments[0].size();
				System.out.println("temp_boxAssignments[0].size(): "+j);
				for (i=0;i<j;i++) System.out.print("   "+temp_boxAssignments[0].elementAt(i));
				System.out.print("\n");
				System.out.flush();
			}
		}
		else{
			j=m_boxes.domain().size();
			System.out.println("m_boxes.size(): "+m_boxes.domain().size());
			for (i=0;i<j;i++) System.out.print(m_boxes[i].toString());
			System.out.print("\n");
			System.out.flush();
			j=m_procAssignments.domain().size();
			System.out.println("m_procAssignments.length: "+j);
			for (i=0;i<j;i++)
				System.out.print(m_procAssignments[i]+" local index:"+m_localIndexes[i]);
			System.out.print("\n");
			System.out.flush();
			//j=m_boxAssignments.length; /* this will crash the compiler */
			//Util.printErrMsg("m_boxAssignments.length:"+j);
			if (m_boxAssignments[0].domain().size()!=0){
				j=m_boxAssignments[0].domain().size();
				System.out.println("m_boxAssignments[0].length: "+j);
				for (i=0;i<j;i++) System.out.print("   "+m_boxAssignments[0][i]);
				System.out.print("\n");
				System.out.flush();
			}
		}
	}
}