parallel/test/SplitMapTest.java

package appl.parallel.test;

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


import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

import appl.parallel.data.splittable.SplittableGridLLFactory;
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.parallel.util.Helper;
import appl.util.GeneralUtil;
import appl.util.RasterMetaData;
import appl.util.RasterUtil;

import schmitzm.data.WritableGrid;
import schmitzm.data.WritableGridRaster;
import schmitzm.geotools.io.GeoImportUtil;

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