parallel/test/SplitMapTest.java

package appl.parallel.test;

import java.awt.Rectangle;
import java.io.File;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import schmitzm.data.WritableGrid;
import schmitzm.geotools.io.GeoImportUtil;
import appl.parallel.data.splittable.SplittableLLProxyGrid;
import appl.parallel.spmd.split.AbstractSplitMap;
import appl.parallel.spmd.split.SplitMap;
import appl.parallel.spmd.split.SplitMap1DHorizontal;
import appl.parallel.spmd.split.SplitMap1DVertical;
import appl.parallel.spmd.split.SplitMap2D;
import appl.util.RasterMetaData;
import appl.util.RasterUtil;

/**
 * Generated code for the test suite <b>SplitMapTest</b> located at
 * <i>/XuluSVN/javasrc/appl/parallel/test/SplitMapTest.testsuite</i>.
 *
 * Tests different splitmaps
 */
public class SplitMapTest extends TestCase {

        Rectangle globalCalcBounds;

        Rectangle partitionCalcBounds;

        Rectangle partitionNeighborhoodBounds;

        Rectangle globalNeighborhoodBounds;

        Rectangle localCalcBounds;

        Rectangle localNeighborhoodBounds;

        private SplittableLLProxyGrid baseGrid;

        private SplitMap map;

        /**
         * Constructor for SplitMapTest.
         * @param name
         */
        public SplitMapTest(String name) {
                super(name);
        }

        /**
         * Returns the JUnit test suite that implements the <b>SplitMapTest</b>
         * definition.
         */
        public static Test suite() {
                TestSuite splitMapTest = new TestSuite("SplitMapTest");
                //              splitMapTest.setArbiter(DefaultTestArbiter.INSTANCE).setId(
                //                              "D35DB07792EF13413F23D9D0B19111DB");
                //      
                //              splitMapTest.addTest(new SplitMapTest("test1DSplitMap").setId(
                //                              "D35DB07792EF134149AEAC40B19111DB").setTestInvocationId(
                //                              "D35DB07792EF134168064FE0B19111DB"));
                return splitMapTest;
        }

        /**
         * @see junit.framework.TestCase#setUp()
         */
        protected void setUp() throws Exception {
                //              load a very simple 10x10 Grid 
                WritableGrid loadGrid = GeoImportUtil
                                .readGridRasterFromArcInfoASCII(new File(
                                                "../Xulu-Data/regularGrid.arc"));
                baseGrid = new SplittableLLProxyGrid(new RasterMetaData(loadGrid),2);
                RasterUtil.copyInto(loadGrid, baseGrid);
                //RasterUtil.printGrid(baseGrid, "Base grid");
        }

        /**
         * @see junit.framework.TestCase#tearDown()
         */
        protected void tearDown() throws Exception {
        }

        public void basicTest() {
                //make simply 2 Partitions without neighborhood
                map.makeMap();
                //check first partition
                initVariables(map, 0);
                assertEquals(new Rectangle(0, 0, 10, 10), globalCalcBounds);
                assertEquals(new Rectangle(0, 0, 10, 10), globalNeighborhoodBounds);
                assertEquals(new Rectangle(0, 0, 5, 10), partitionCalcBounds);
                assertEquals(new Rectangle(0, 0, 5, 10), partitionNeighborhoodBounds);
                assertEquals(new Rectangle(0, 0, 5, 10), localCalcBounds);
                assertEquals(new Rectangle(0, 0, 5, 10), localNeighborhoodBounds);
                //check second partition
                initVariables(map, 1);
                assertEquals(globalCalcBounds, new Rectangle(0, 0, 10, 10));
                assertEquals(globalNeighborhoodBounds, new Rectangle(0, 0, 10, 10));
                assertEquals(partitionCalcBounds, new Rectangle(5, 0, 5, 10));
                assertEquals(partitionNeighborhoodBounds, new Rectangle(5, 0, 5, 10));
                assertEquals(localCalcBounds, new Rectangle(0, 0, 5, 10));
                assertEquals(localNeighborhoodBounds, new Rectangle(0, 0, 5, 10));
        }

        public void test1DHorizontal() {
        //2 Partitions
                map = new SplitMap1DHorizontal(baseGrid.getWidth(), baseGrid.getHeight(),
                                1, 2, AbstractSplitMap.NeighborhoodBoxingMode.inBoxing);
                
                
            
            map = new SplitMap1DHorizontal(baseGrid.getWidth(), baseGrid.getHeight(),
                                1, 3, AbstractSplitMap.NeighborhoodBoxingMode.inBoxing);
           
            
        }
        
        public void print(){
                for(int i=0; i < map.getCount(); i++){
                        RasterUtil.printGrid(baseGrid.getPartition(map.getPartitionCalculationBounds(i)),3,0,"Calculation Partition " + (i+1) + "/" + map.getCount());
                }
                for(int i=0; i < map.getCount(); i++){
                        RasterUtil.printGrid(baseGrid.getPartition(map.getPartitionNeighborhoodBounds(i)),3,0,"Neighborhood Partition " + (i+1) + "/" + map.getCount());
                }
        }
        
        public void test2DIrregular(){
//              map = new SplitMap2D(10, 10,
//                              1, 3, AbstractSplitMap.NeighborhoodBoxingMode.inBoxing);
                
            map = new SplitMap2D(baseGrid.getWidth(), baseGrid.getHeight(),
                                1, 9, AbstractSplitMap.NeighborhoodBoxingMode.inBoxing);
            print();
        }

        /**
         * 1DSplitMap
         * @throws Exception
         */
        public void test1DVertical() throws Exception {
                //2 Partitions
                map = new SplitMap1DVertical(baseGrid.getWidth(), baseGrid.getHeight(),
                                0, 2, AbstractSplitMap.NeighborhoodBoxingMode.inBoxing);
                basicTest();
                //make 3 Partitions
                map = new SplitMap1DVertical(baseGrid.getWidth(), baseGrid.getHeight(),
                                0, 3, AbstractSplitMap.NeighborhoodBoxingMode.inBoxing);
                
                //make 2 Partitions with neighborhoodrange 2
                map = new SplitMap1DVertical(baseGrid.getWidth(), baseGrid.getHeight(),
                                2, 2, AbstractSplitMap.NeighborhoodBoxingMode.inBoxing);
                //intersect the partitions and see if you have the right rect

                Rectangle r = map.getPartitionNeighborhoodBounds(0).intersection(
                                map.getPartitionNeighborhoodBounds(1));
                assertEquals(new Rectangle(3, 0, 4, 10), r);

                initVariables(map, 1);
        }

        /**
         * @param map
         */
        private void initVariables(SplitMap map, int pos) {
                globalCalcBounds = map.getGlobalCalculationBounds();
                partitionCalcBounds = map.getPartitionCalculationBounds(pos);
                partitionNeighborhoodBounds = map.getPartitionNeighborhoodBounds(pos);
                globalNeighborhoodBounds = map.getGlobalBounds();
                localCalcBounds = map.getLocalCalculationBounds(pos);
                localNeighborhoodBounds = map.getLocalNeighborhoodBounds(pos);

        }

}
1	mojays	2	package appl.parallel.test;
2
3			import java.awt.Rectangle;
4			import java.io.File;
5
6			import junit.framework.Test;
7			import junit.framework.TestCase;
8			import junit.framework.TestSuite;
9	alfonx	60	import schmitzm.data.WritableGrid;
10			import schmitzm.geotools.io.GeoImportUtil;
11	mojays	2	import appl.parallel.data.splittable.SplittableLLProxyGrid;
12			import appl.parallel.spmd.split.AbstractSplitMap;
13			import appl.parallel.spmd.split.SplitMap;
14			import appl.parallel.spmd.split.SplitMap1DHorizontal;
15			import appl.parallel.spmd.split.SplitMap1DVertical;
16			import appl.parallel.spmd.split.SplitMap2D;
17			import appl.util.RasterMetaData;
18			import appl.util.RasterUtil;
19
20			/**
21			* Generated code for the test suite <b>SplitMapTest</b> located at
22			* <i>/XuluSVN/javasrc/appl/parallel/test/SplitMapTest.testsuite</i>.
23			*
24			* Tests different splitmaps
25			*/
26			public class SplitMapTest extends TestCase {
27
28			Rectangle globalCalcBounds;
29
30			Rectangle partitionCalcBounds;
31
32			Rectangle partitionNeighborhoodBounds;
33
34			Rectangle globalNeighborhoodBounds;
35
36			Rectangle localCalcBounds;
37
38			Rectangle localNeighborhoodBounds;
39
40			private SplittableLLProxyGrid baseGrid;
41
42			private SplitMap map;
43
44			/**
45			* Constructor for SplitMapTest.
46			* @param name
47			*/
48			public SplitMapTest(String name) {
49			super(name);
50			}
51
52			/**
53			* Returns the JUnit test suite that implements the <b>SplitMapTest</b>
54			* definition.
55			*/
56			public static Test suite() {
57			TestSuite splitMapTest = new TestSuite("SplitMapTest");
58			// splitMapTest.setArbiter(DefaultTestArbiter.INSTANCE).setId(
59			// "D35DB07792EF13413F23D9D0B19111DB");
60			//
61			// splitMapTest.addTest(new SplitMapTest("test1DSplitMap").setId(
62			// "D35DB07792EF134149AEAC40B19111DB").setTestInvocationId(
63			// "D35DB07792EF134168064FE0B19111DB"));
64			return splitMapTest;
65			}
66
67			/**
68			* @see junit.framework.TestCase#setUp()
69			*/
70			protected void setUp() throws Exception {
71			// load a very simple 10x10 Grid
72			WritableGrid loadGrid = GeoImportUtil
73			.readGridRasterFromArcInfoASCII(new File(
74			"../Xulu-Data/regularGrid.arc"));
75			baseGrid = new SplittableLLProxyGrid(new RasterMetaData(loadGrid),2);
76			RasterUtil.copyInto(loadGrid, baseGrid);
77			//RasterUtil.printGrid(baseGrid, "Base grid");
78			}
79
80			/**
81			* @see junit.framework.TestCase#tearDown()
82			*/
83			protected void tearDown() throws Exception {
84			}
85
86			public void basicTest() {
87			//make simply 2 Partitions without neighborhood
88			map.makeMap();
89			//check first partition
90			initVariables(map, 0);
91			assertEquals(new Rectangle(0, 0, 10, 10), globalCalcBounds);
92			assertEquals(new Rectangle(0, 0, 10, 10), globalNeighborhoodBounds);
93			assertEquals(new Rectangle(0, 0, 5, 10), partitionCalcBounds);
94			assertEquals(new Rectangle(0, 0, 5, 10), partitionNeighborhoodBounds);
95			assertEquals(new Rectangle(0, 0, 5, 10), localCalcBounds);
96			assertEquals(new Rectangle(0, 0, 5, 10), localNeighborhoodBounds);
97			//check second partition
98			initVariables(map, 1);
99			assertEquals(globalCalcBounds, new Rectangle(0, 0, 10, 10));
100			assertEquals(globalNeighborhoodBounds, new Rectangle(0, 0, 10, 10));
101			assertEquals(partitionCalcBounds, new Rectangle(5, 0, 5, 10));
102			assertEquals(partitionNeighborhoodBounds, new Rectangle(5, 0, 5, 10));
103			assertEquals(localCalcBounds, new Rectangle(0, 0, 5, 10));
104			assertEquals(localNeighborhoodBounds, new Rectangle(0, 0, 5, 10));
105			}
106
107			public void test1DHorizontal() {
108			//2 Partitions
109			map = new SplitMap1DHorizontal(baseGrid.getWidth(), baseGrid.getHeight(),
110			1, 2, AbstractSplitMap.NeighborhoodBoxingMode.inBoxing);
111
112
113
114			map = new SplitMap1DHorizontal(baseGrid.getWidth(), baseGrid.getHeight(),
115			1, 3, AbstractSplitMap.NeighborhoodBoxingMode.inBoxing);
116
117
118			}
119
120			public void print(){
121			for(int i=0; i < map.getCount(); i++){
122			RasterUtil.printGrid(baseGrid.getPartition(map.getPartitionCalculationBounds(i)),3,0,"Calculation Partition " + (i+1) + "/" + map.getCount());
123			}
124			for(int i=0; i < map.getCount(); i++){
125			RasterUtil.printGrid(baseGrid.getPartition(map.getPartitionNeighborhoodBounds(i)),3,0,"Neighborhood Partition " + (i+1) + "/" + map.getCount());
126			}
127			}
128
129			public void test2DIrregular(){
130			// map = new SplitMap2D(10, 10,
131			// 1, 3, AbstractSplitMap.NeighborhoodBoxingMode.inBoxing);
132
133			map = new SplitMap2D(baseGrid.getWidth(), baseGrid.getHeight(),
134			1, 9, AbstractSplitMap.NeighborhoodBoxingMode.inBoxing);
135			print();
136			}
137
138			/**
139			* 1DSplitMap
140			* @throws Exception
141			*/
142			public void test1DVertical() throws Exception {
143			//2 Partitions
144			map = new SplitMap1DVertical(baseGrid.getWidth(), baseGrid.getHeight(),
145			0, 2, AbstractSplitMap.NeighborhoodBoxingMode.inBoxing);
146			basicTest();
147			//make 3 Partitions
148			map = new SplitMap1DVertical(baseGrid.getWidth(), baseGrid.getHeight(),
149			0, 3, AbstractSplitMap.NeighborhoodBoxingMode.inBoxing);
150
151			//make 2 Partitions with neighborhoodrange 2
152			map = new SplitMap1DVertical(baseGrid.getWidth(), baseGrid.getHeight(),
153			2, 2, AbstractSplitMap.NeighborhoodBoxingMode.inBoxing);
154			//intersect the partitions and see if you have the right rect
155
156			Rectangle r = map.getPartitionNeighborhoodBounds(0).intersection(
157			map.getPartitionNeighborhoodBounds(1));
158			assertEquals(new Rectangle(3, 0, 4, 10), r);
159
160			initVariables(map, 1);
161			}
162
163			/**
164			* @param map
165			*/
166			private void initVariables(SplitMap map, int pos) {
167			globalCalcBounds = map.getGlobalCalculationBounds();
168			partitionCalcBounds = map.getPartitionCalculationBounds(pos);
169			partitionNeighborhoodBounds = map.getPartitionNeighborhoodBounds(pos);
170			globalNeighborhoodBounds = map.getGlobalBounds();
171			localCalcBounds = map.getLocalCalculationBounds(pos);
172			localNeighborhoodBounds = map.getLocalNeighborhoodBounds(pos);
173
174			}
175
176			}