return new ArrayFloat.D2(dimensions[0], dimensions[1]); } else if (varDataType == DataType.DOUBLE) { return new ArrayDouble.D2(dimensions[0], dimensions[1]); } else if (varDataType == DataType.BYTE) { return new ArrayByte.D2(dimensions[0], dimensions[1]);
private void writeExpressionMatrixValues( NetcdfFileWriteable netCDF, Collection<Integer> designElements, List<Assay> assays, Map<Integer, Map<Integer, Float>> expressionValues) throws IOException, InvalidRangeException { if (netCDF.findDimension("AS") != null && netCDF.findDimension("DE") != null) { ArrayDouble bdc = new ArrayDouble.D2( netCDF.findDimension("DE").getLength(), netCDF.findDimension("AS").getLength()); // initialise everything to -1000000, default value IndexIterator bdcIt = bdc.getIndexIterator(); for(int designElementId : designElements) { for(Assay assay : assays) { double value = -1000000; Map<Integer,Float> evmap = expressionValues.get(assay.getAssayID()); if(evmap != null) { Float v = evmap.get(designElementId); if(v != null) value = Double.valueOf(v); } bdcIt.setDoubleNext(value); } } netCDF.write("BDC", bdc); } log.debug("Wrote expression data matrix ok."); }
/** * {@inheritDoc} */ public void writeBandRasterData(final Band sourceBand, final int regionX, final int regionY, final int regionWidth, final int regionHeight, final ProductData regionData, ProgressMonitor pm) throws IOException { final int[] origin = new int[2]; origin[1] = regionX; origin[0] = regionY; try { final ArrayDouble dataTemp = new ArrayDouble.D2(regionHeight, regionWidth); final Index index = dataTemp.getIndex(); int i = 0; for (int y = 0; y < regionHeight; ++y) { for (int x = 0; x < regionWidth; ++x) { index.set(y, x); dataTemp.set(index, regionData.getElemDoubleAt(i)); ++i; } } netCDFWriteable.write(sourceBand.getName(), origin, dataTemp); pm.worked(1); } catch (Exception e) { System.out.println(e.getMessage()); } }
/** * Experimental: for WRF rotated (NMM "E") Grids * @param midx x coordinates of midpoints * @return x coordinates of edges with shape (ny+2, nx+1) */ static public ArrayDouble.D2 makeXEdgesRotated(ArrayDouble.D2 midx) { int[] shape = midx.getShape(); int ny = shape[0]; int nx = shape[1]; ArrayDouble.D2 edgex = new ArrayDouble.D2(ny+2, nx+1); // compute the interior rows for (int y=0; y<ny; y++) { for (int x=1; x<nx; x++) { double xval = (midx.get(y,x-1) + midx.get(y,x))/2; edgex.set(y+1, x, xval); } edgex.set(y+1, 0, midx.get(y,0) - (edgex.get(y+1,1) - midx.get(y,0))); edgex.set(y+1, nx, midx.get(y, nx-1) - (edgex.get(y+1,nx-1) - midx.get(y,nx-1))); } // compute the first row for (int x=0; x<nx; x++) { edgex.set(0, x, midx.get(0,x)); } // compute the last row for (int x=0; x<nx-1; x++) { edgex.set(ny+1, x, midx.get(ny-1,x)); } return edgex; }
/** * Normal case: do something reasonable in deciding on the edges when we have the midpoints of a 2D coordinate. * * @param midy y coordinates of midpoints * @return y coordinates of edges with shape (ny+1, nx+1) */ static public ArrayDouble.D2 makeYEdges(ArrayDouble.D2 midy) { int[] shape = midy.getShape(); int ny = shape[0]; int nx = shape[1]; ArrayDouble.D2 edgey = new ArrayDouble.D2(ny + 1, nx + 1); for (int y = 0; y < ny - 1; y++) { for (int x = 0; x < nx - 1; x++) { // the interior edges are the average of the 4 surrounding midpoints double xval = (midy.get(y, x) + midy.get(y, x + 1) + midy.get(y + 1, x) + midy.get(y + 1, x + 1)) / 4; edgey.set(y + 1, x + 1, xval); } // extrapolate to exterior points edgey.set(y + 1, 0, edgey.get(y + 1, 1) - (edgey.get(y + 1, 2) - edgey.get(y + 1, 1))); edgey.set(y + 1, nx, edgey.get(y + 1, nx - 1) + (edgey.get(y + 1, nx - 1) - edgey.get(y + 1, nx - 2))); } // extrapolate to the first and last row for (int x = 0; x < nx + 1; x++) { edgey.set(0, x, edgey.get(1, x) - (edgey.get(2, x) - edgey.get(1, x))); edgey.set(ny, x, edgey.get(ny - 1, x) + (edgey.get(ny - 1, x) - edgey.get(ny - 2, x))); } return edgey; }
/** * Normal case: do something reasonable in deciding on the edges when we have the midpoints of a 2D coordinate. * @param midx x coordinates of midpoints * @return x coordinates of edges with shape (ny+1, nx+1) */ static public ArrayDouble.D2 makeXEdges(ArrayDouble.D2 midx) { int[] shape = midx.getShape(); int ny = shape[0]; int nx = shape[1]; ArrayDouble.D2 edgex = new ArrayDouble.D2(ny+1, nx+1); for (int y=0; y<ny-1; y++) { for (int x=0; x<nx-1; x++) { // the interior edges are the average of the 4 surrounding midpoints double xval = (midx.get(y,x) + midx.get(y,x+1) + midx.get(y+1,x) + midx.get(y+1,x+1))/4; edgex.set(y+1, x+1, xval); } // extrapolate to exterior points edgex.set(y+1, 0, edgex.get(y+1,1) - (edgex.get(y+1,2) - edgex.get(y+1,1))); edgex.set(y+1, nx, edgex.get(y+1,nx-1) + (edgex.get(y+1,nx-1) - edgex.get(y+1,nx-2))); } // extrapolate to the first and last row for (int x=0; x<nx+1; x++) { edgex.set(0, x, edgex.get(1,x) - (edgex.get(2,x) - edgex.get(1,x))); edgex.set(ny, x, edgex.get(ny-1,x) + (edgex.get(ny-1,x) - edgex.get(ny-2,x))); } return edgex; }
/** * Experimental: for WRF rotated (NMM "E") Grids * * @param midx x coordinates of midpoints * @return x coordinates of edges with shape (ny+2, nx+1) */ static public ArrayDouble.D2 makeXEdgesRotated(ArrayDouble.D2 midx) { int[] shape = midx.getShape(); int ny = shape[0]; int nx = shape[1]; ArrayDouble.D2 edgex = new ArrayDouble.D2(ny + 2, nx + 1); // compute the interior rows for (int y = 0; y < ny; y++) { for (int x = 1; x < nx; x++) { double xval = (midx.get(y, x - 1) + midx.get(y, x)) / 2; edgex.set(y + 1, x, xval); } edgex.set(y + 1, 0, midx.get(y, 0) - (edgex.get(y + 1, 1) - midx.get(y, 0))); edgex.set(y + 1, nx, midx.get(y, nx - 1) - (edgex.get(y + 1, nx - 1) - midx.get(y, nx - 1))); } // compute the first row for (int x = 0; x < nx; x++) { edgex.set(0, x, midx.get(0, x)); } // compute the last row for (int x = 0; x < nx - 1; x++) { edgex.set(ny + 1, x, midx.get(ny - 1, x)); } return edgex; }
/** * Normal case: do something reasonable in deciding on the edges when we have the midpoints of a 2D coordinate. * * @param midpoints values of midpoints with shape (ny, nx) * @return values of edges with shape (ny+1, nx+1) */ static public ArrayDouble.D2 makeEdges(ArrayDouble.D2 midpoints) { int[] shape = midpoints.getShape(); int ny = shape[0]; int nx = shape[1]; ArrayDouble.D2 edge = new ArrayDouble.D2(ny + 1, nx + 1); for (int y = 0; y < ny - 1; y++) { for (int x = 0; x < nx - 1; x++) { // the interior edges are the average of the 4 surrounding midpoints double xval = (midpoints.get(y, x) + midpoints.get(y, x + 1) + midpoints.get(y + 1, x) + midpoints.get(y + 1, x + 1)) / 4; edge.set(y + 1, x + 1, xval); } // extrapolate to exterior points edge.set(y + 1, 0, edge.get(y + 1, 1) - (edge.get(y + 1, 2) - edge.get(y + 1, 1))); edge.set(y + 1, nx, edge.get(y + 1, nx - 1) + (edge.get(y + 1, nx - 1) - edge.get(y + 1, nx - 2))); } // extrapolate to the first and last row for (int x = 0; x < nx + 1; x++) { edge.set(0, x, edge.get(1, x) - (edge.get(2, x) - edge.get(1, x))); edge.set(ny, x, edge.get(ny - 1, x) + (edge.get(ny - 1, x) - edge.get(ny - 2, x))); } return edge; }
/** * Normal case: do something reasonable in deciding on the edges when we have the midpoints of a 2D coordinate. * * @param midx x coordinates of midpoints * @return x coordinates of edges with shape (ny+1, nx+1) */ static public ArrayDouble.D2 makeXEdges(ArrayDouble.D2 midx) { int[] shape = midx.getShape(); int ny = shape[0]; int nx = shape[1]; ArrayDouble.D2 edgex = new ArrayDouble.D2(ny + 1, nx + 1); for (int y = 0; y < ny - 1; y++) { for (int x = 0; x < nx - 1; x++) { // the interior edges are the average of the 4 surrounding midpoints double xval = (midx.get(y, x) + midx.get(y, x + 1) + midx.get(y + 1, x) + midx.get(y + 1, x + 1)) / 4; edgex.set(y + 1, x + 1, xval); } // extrapolate to exterior points edgex.set(y + 1, 0, edgex.get(y + 1, 1) - (edgex.get(y + 1, 2) - edgex.get(y + 1, 1))); edgex.set(y + 1, nx, edgex.get(y + 1, nx - 1) + (edgex.get(y + 1, nx - 1) - edgex.get(y + 1, nx - 2))); } // extrapolate to the first and last row for (int x = 0; x < nx + 1; x++) { edgex.set(0, x, edgex.get(1, x) - (edgex.get(2, x) - edgex.get(1, x))); edgex.set(ny, x, edgex.get(ny - 1, x) + (edgex.get(ny - 1, x) - edgex.get(ny - 2, x))); } return edgex; }
/** * Matrix multiply: return m1 * m2. * @param m1 left matrix * @param m2 right matrix * @return MAMatrix result: new matrix * @exception IllegalArgumentException if m1.getNcols() != m2.getNrows(). */ static public MAMatrix multiply(MAMatrix m1, MAMatrix m2) { if (m1.getNcols() != m2.getNrows()) throw new IllegalArgumentException("MAMatrix.multiply "+m1.getNcols()+" != "+ m2.getNrows()); int kdims = m1.getNcols(); ArrayDouble.D2 result = new ArrayDouble.D2(m1.getNrows(), m2.getNcols()); Index imr = result.getIndex(); for (int i=0; i<m1.getNrows(); i++) { for (int j=0; j<m2.getNcols(); j++) { double sum = 0.0; for (int k=0; k<kdims; k++) sum += m1.getDouble(i, k) * m2.getDouble(k, j); result.setDouble( imr.set(i,j), sum); } } return new MAMatrix( result); }
/** * Experimental: for WRF rotated (NMM "E") Grids * * @param midx x coordinates of midpoints * @return x coordinates of edges with shape (ny+2, nx+1) */ static public ArrayDouble.D2 makeXEdgesRotated(ArrayDouble.D2 midx) { int[] shape = midx.getShape(); int ny = shape[0]; int nx = shape[1]; ArrayDouble.D2 edgex = new ArrayDouble.D2(ny + 2, nx + 1); // compute the interior rows for (int y = 0; y < ny; y++) { for (int x = 1; x < nx; x++) { double xval = (midx.get(y, x - 1) + midx.get(y, x)) / 2; edgex.set(y + 1, x, xval); } edgex.set(y + 1, 0, midx.get(y, 0) - (edgex.get(y + 1, 1) - midx.get(y, 0))); edgex.set(y + 1, nx, midx.get(y, nx - 1) - (edgex.get(y + 1, nx - 1) - midx.get(y, nx - 1))); } // compute the first row for (int x = 0; x < nx; x++) { edgex.set(0, x, midx.get(0, x)); } // compute the last row for (int x = 0; x < nx - 1; x++) { edgex.set(ny + 1, x, midx.get(ny - 1, x)); } return edgex; }
/** * Matrix multiply: return m1 * m2. * @param m1 left matrix * @param m2 right matrix * @return MAMatrix result: new matrix * @exception IllegalArgumentException if m1.getNcols() != m2.getNrows(). */ static public MAMatrix multiply(MAMatrix m1, MAMatrix m2) { if (m1.getNcols() != m2.getNrows()) throw new IllegalArgumentException("MAMatrix.multiply "+m1.getNcols()+" != "+ m2.getNrows()); int kdims = m1.getNcols(); ArrayDouble.D2 result = new ArrayDouble.D2(m1.getNrows(), m2.getNcols()); Index imr = result.getIndex(); for (int i=0; i<m1.getNrows(); i++) { for (int j=0; j<m2.getNcols(); j++) { double sum = 0.0; for (int k=0; k<kdims; k++) sum += m1.getDouble(i, k) * m2.getDouble(k, j); result.setDouble( imr.set(i,j), sum); } } return new MAMatrix( result); }
/** * Matrix multiply: return m1 * m2. * @param m1 left matrix * @param m2 right matrix * @return MAMatrix result: new matrix * @exception IllegalArgumentException if m1.getNcols() != m2.getNrows(). */ static public MAMatrix multiply(MAMatrix m1, MAMatrix m2) { if (m1.getNcols() != m2.getNrows()) throw new IllegalArgumentException("MAMatrix.multiply "+m1.getNcols()+" != "+ m2.getNrows()); int kdims = m1.getNcols(); ArrayDouble.D2 result = new ArrayDouble.D2(m1.getNrows(), m2.getNcols()); Index imr = result.getIndex(); for (int i=0; i<m1.getNrows(); i++) { for (int j=0; j<m2.getNcols(); j++) { double sum = 0.0; for (int k=0; k<kdims; k++) sum += m1.getDouble(i, k) * m2.getDouble(k, j); result.setDouble( imr.set(i,j), sum); } } return new MAMatrix( result); }
private void writeStatsValues(NetcdfFileWriteable netCDF, Collection<Integer> designElements, Map<String, List<String>> experimentFactorMap) throws IOException, InvalidRangeException { if (netCDF.findDimension("DE") != null && netCDF.findDimension("uEFV") != null) { int deMaxLength = netCDF.findDimension("DE").getLength(); int uefvMaxLength = netCDF.findDimension("uEFV").getLength(); ArrayDouble pval = new ArrayDouble.D2( deMaxLength, uefvMaxLength); ArrayDouble tstat = new ArrayDouble.D2( deMaxLength, uefvMaxLength); netCDF.write("PVAL", pval); netCDF.write("TSTAT", tstat); } log.debug("Wrote stats data matrix ok."); } }
static ArrayDouble factory( Index index, double [] storage) { if (index instanceof Index0D) { return new ArrayDouble.D0(index, storage); } else if (index instanceof Index1D) { return new ArrayDouble.D1(index, storage); } else if (index instanceof Index2D) { return new ArrayDouble.D2(index, storage); } else if (index instanceof Index3D) { return new ArrayDouble.D3(index, storage); } else if (index instanceof Index4D) { return new ArrayDouble.D4(index, storage); } else if (index instanceof Index5D) { return new ArrayDouble.D5(index, storage); } else if (index instanceof Index6D) { return new ArrayDouble.D6(index, storage); } else if (index instanceof Index7D) { return new ArrayDouble.D7(index, storage); } else { return new ArrayDouble(index, storage); } }
static ArrayDouble factory( Index index, double [] storage) { switch (index.getRank()) { case 0 : return new ArrayDouble.D0(index, storage); case 1 : return new ArrayDouble.D1(index, storage); case 2 : return new ArrayDouble.D2(index, storage); case 3 : return new ArrayDouble.D3(index, storage); case 4 : return new ArrayDouble.D4(index, storage); case 5 : return new ArrayDouble.D5(index, storage); case 6 : return new ArrayDouble.D6(index, storage); case 7 : return new ArrayDouble.D7(index, storage); default : return new ArrayDouble(index, storage); } }
static ArrayDouble factory( Index index, double [] storage) { switch (index.getRank()) { case 0 : return new ArrayDouble.D0(index, storage); case 1 : return new ArrayDouble.D1(index, storage); case 2 : return new ArrayDouble.D2(index, storage); case 3 : return new ArrayDouble.D3(index, storage); case 4 : return new ArrayDouble.D4(index, storage); case 5 : return new ArrayDouble.D5(index, storage); case 6 : return new ArrayDouble.D6(index, storage); case 7 : return new ArrayDouble.D7(index, storage); default : return new ArrayDouble(index, storage); } }
/** * Create an MAMatrix of the given shape. * @param nrows number of rows * @param ncols number of cols */ public MAMatrix( int nrows, int ncols) { this.a = new ArrayDouble.D2(nrows, ncols); this.nrows = nrows; this.ncols = ncols; ima = a.getIndex(); } /**
/** * Create an MAMatrix of the given shape. * @param nrows number of rows * @param ncols number of cols */ public MAMatrix( int nrows, int ncols) { this.a = new ArrayDouble.D2(nrows, ncols); this.nrows = nrows; this.ncols = ncols; ima = a.getIndex(); } /**
/** * Create an MAMatrix of the given shape. * @param nrows number of rows * @param ncols number of cols */ public MAMatrix( int nrows, int ncols) { this.a = new ArrayDouble.D2(nrows, ncols); this.nrows = nrows; this.ncols = ncols; ima = a.getIndex(); } /**