/** * Flatten the Structures into a 1D array of Structures of length getTotalNumberOfStructures(). * @return Array of Structures */ public ArrayStructure flatten() { ArrayStructureW aw = new ArrayStructureW( getStructureMembers(), new int[] {total}); for (int i=0; i<total; i++) { StructureData sdata = new StructureDataA( this, i); aw.setStructureData(sdata, i); } return aw; }
/** * Flatten the Structures into a 1D array of Structures of length getTotalNumberOfStructures(). * @return Array of Structures */ public ArrayStructure flatten() { ArrayStructureW aw = new ArrayStructureW( getStructureMembers(), new int[] {total}); for (int i=0; i<total; i++) { StructureData sdata = new StructureDataA( this, i); aw.setStructureData(sdata, i); } return aw; }
/** * Flatten the Structures into a 1D array of Structures of length getTotalNumberOfStructures(). * @return Array of Structures */ public ArrayStructure flatten() { ArrayStructureW aw = new ArrayStructureW( getStructureMembers(), new int[] {total}); for (int i=0; i<total; i++) { StructureData sdata = new StructureDataA( this, i); aw.setStructureData(sdata, i); } return aw; }
public ArrayStructure getArrayStructure(int recnum, StructureMembers.Member m) { if (m.getDataType() == DataType.STRUCTURE) { ArrayStructure data = (ArrayStructure) m.getDataArray(); // we need to subset this array structure to deal with just the subset for this recno // use "brute force" for now, see if we can finesse later int count = m.getSize(); StructureData[] sdata = new StructureData[count]; for (int i=0; i<count; i++) sdata[i] = data.getStructureData( recnum * count + i); return new ArrayStructureW( data.getStructureMembers(), m.getShape(), sdata); } throw new IllegalArgumentException("Type is " + m.getDataType() + ", must be Structure"); }
public ArrayStructure getArrayStructure(int recnum, StructureMembers.Member m) { if (m.getDataType() == DataType.STRUCTURE) { ArrayStructure data = (ArrayStructure) m.getDataArray(); // we need to subset this array structure to deal with just the subset for this recno // use "brute force" for now, see if we can finesse later int count = m.getSize(); StructureData[] sdata = new StructureData[count]; for (int i=0; i<count; i++) sdata[i] = data.getStructureData( recnum * count + i); return new ArrayStructureW( data.getStructureMembers(), m.getShape(), sdata); } throw new IllegalArgumentException("Type is " + m.getDataType() + ", must be Structure"); }
public ArrayStructure getArrayStructure(int recnum, StructureMembers.Member m) { if (m.getDataType() == DataType.STRUCTURE) { ArrayStructure data = (ArrayStructure) m.getDataArray(); // we need to subset this array structure to deal with just the subset for this recno // use "brute force" for now, see if we can finesse later int count = m.getSize(); StructureData[] sdata = new StructureData[count]; for (int i=0; i<count; i++) sdata[i] = data.getStructureData( recnum * count + i); return new ArrayStructureW( data.getStructureMembers(), m.getShape(), sdata); } throw new IllegalArgumentException("Type is " + m.getDataType() + ", must be Structure"); }
public void writeRecord(String stnName, double timeCoordValue, CalendarDate obsDate, StructureData sdata) throws IOException { trackBB(null, obsDate); Integer parentIndex = stationMap.get(stnName); if (parentIndex == null) throw new RuntimeException("Cant find station " + stnName); // needs to be wrapped as an ArrayStructure, even though we are only writing one at a time. ArrayStructureW sArray = new ArrayStructureW(sdata.getStructureMembers(), new int[]{1}); sArray.setStructureData(sdata, 0); timeArray.set(0, timeCoordValue); parentArray.set(0, parentIndex); // write the recno record origin[0] = recno; try { writer.write(record, origin, sArray); writer.write(time, origin, timeArray); writer.write(stationIndex, origin, parentArray); } catch (InvalidRangeException e) { e.printStackTrace(); throw new IllegalStateException(e); } recno++; }
protected int writeStructureData(int recno, Structure s, StructureData sdata, Map<String, Variable> varMap) throws IOException { // write the recno record int[] origin = new int[1]; origin[0] = recno; try { if (isExtendedModel) { if (s.isUnlimited()) return writer.appendStructureData(s, sdata); // can write it all at once along unlimited dimension else { ArrayStructureW as = new ArrayStructureW(sdata.getStructureMembers(), new int[] {1}); as.setStructureData(sdata, 0); writer.write(s, origin, as); // can write it all at once along regular dimension return recno + 1; } } else { writeStructureDataClassic(varMap, origin, sdata); } } catch (InvalidRangeException e) { e.printStackTrace(); throw new IllegalStateException(e); } return recno+1; }
protected int writeStructureData(int recno, Structure s, StructureData sdata, Map<String, Variable> varMap) throws IOException { // write the recno record int[] origin = new int[1]; origin[0] = recno; try { if (isExtendedModel) { if (s.isUnlimited()) return writer.appendStructureData(s, sdata); // can write it all at once along unlimited dimension else { ArrayStructureW as = new ArrayStructureW(sdata.getStructureMembers(), new int[] {1}); as.setStructureData(sdata, 0); writer.write(s, origin, as); // can write it all at once along regular dimension return recno + 1; } } else { writeStructureDataClassic(varMap, origin, sdata); } } catch (InvalidRangeException e) { e.printStackTrace(); throw new IllegalStateException(e); } return recno+1; }
@Override public Array sectionNoReduce(List<Range> ranges) throws InvalidRangeException { Section viewSection = new Section(ranges); ArrayStructureW result = new ArrayStructureW(this.members, viewSection.getShape()); int count = 0; Section.Iterator iter = viewSection.getIterator(getShape()); while (iter.hasNext()) { int recno = iter.next(null); StructureData sd = getStructureData(recno); result.setStructureData(sd, count++); } return result; }
@Override public Array sectionNoReduce(List<Range> ranges) throws InvalidRangeException { Section viewSection = new Section(ranges); ArrayStructureW result = new ArrayStructureW(this.members, viewSection.getShape()); int count = 0; Section.Iterator iter = viewSection.getIterator(getShape()); while (iter.hasNext()) { int recno = iter.next(null); StructureData sd = getStructureData(recno); result.setStructureData(sd, count++); } return result; }
static private ArrayStructure sectionArrayStructure(ParsedSectionSpec child, ArrayStructure innerData, StructureMembers.Member m) throws IOException, InvalidRangeException { StructureMembers membersw = new StructureMembers(m.getStructureMembers()); // no data arrays get propagated ArrayStructureW result = new ArrayStructureW(membersw, child.section.getShape()); int count = 0; Section.Iterator iter = child.section.getIterator(child.v.getShape()); while (iter.hasNext()) { int recno = iter.next(); StructureData sd = innerData.getStructureData(recno); result.setStructureData(sd, count++); } return result; }
static private ArrayStructure sectionArrayStructure(ParsedSectionSpec child, ArrayStructure innerData, StructureMembers.Member m) throws IOException, InvalidRangeException { StructureMembers membersw = new StructureMembers(m.getStructureMembers()); // no data arrays get propagated ArrayStructureW result = new ArrayStructureW(membersw, child.section.getShape()); int count = 0; Section.Iterator iter = child.section.getIterator(child.v.getShape()); while (iter.hasNext()) { int recno = iter.next(null); StructureData sd = innerData.getStructureData(recno); result.setStructureData(sd, count++); } return result; }
static private ArrayStructure sectionArrayStructure(ParsedSectionSpec child, ArrayStructure innerData, StructureMembers.Member m) throws IOException, InvalidRangeException { StructureMembers membersw = new StructureMembers(m.getStructureMembers()); // no data arrays get propagated ArrayStructureW result = new ArrayStructureW(membersw, child.section.getShape()); int count = 0; Section.Iterator iter = child.section.getIterator(child.v.getShape()); while (iter.hasNext()) { int recno = iter.next(null); StructureData sd = innerData.getStructureData(recno); result.setStructureData(sd, count++); } return result; }
/** * Get member data of type array of Structure. * * @param recnum get data from the recnum-th StructureData of the ArrayStructure. Must be less than getSize(); * @param m get data from this StructureMembers.Member. Must be of type Structure. * @return nested ArrayStructure. */ public ArrayStructure getArrayStructure(int recnum, StructureMembers.Member m) { if ((m.getDataType() != DataType.STRUCTURE) && (m.getDataType() != DataType.SEQUENCE)) throw new IllegalArgumentException("Type is " + m.getDataType() + ", must be Structure or Sequence"); if (m.getDataType() == DataType.SEQUENCE) return getArraySequence(recnum, m); ArrayStructure array = (ArrayStructure) m.getDataArray(); int count = m.getSize(); StructureData[] this_sdata = new StructureData[count]; for (int i = 0; i < count; i++) this_sdata[i] = array.getStructureData(recnum * count + i); // make a copy of the members, but remove the data arrays, since the structureData must be used instead StructureMembers membersw = new StructureMembers(array.getStructureMembers()); return new ArrayStructureW(membersw, m.getShape(), this_sdata); }
/** * Get member data of type array of Structure. * * @param recnum get data from the recnum-th StructureData of the ArrayStructure. Must be less than getSize(); * @param m get data from this StructureMembers.Member. Must be of type Structure. * @return nested ArrayStructure. */ public ArrayStructure getArrayStructure(int recnum, StructureMembers.Member m) { if ((m.getDataType() != DataType.STRUCTURE) && (m.getDataType() != DataType.SEQUENCE)) throw new IllegalArgumentException("Type is " + m.getDataType() + ", must be Structure or Sequence"); if (m.getDataType() == DataType.SEQUENCE) return getArraySequence(recnum, m); ArrayStructure array = (ArrayStructure) m.getDataArray(); int count = m.getSize(); StructureData[] this_sdata = new StructureData[count]; for (int i = 0; i < count; i++) this_sdata[i] = array.getStructureData(recnum * count + i); // make a copy of the members, but remove the data arrays, since the structureData must be used instead StructureMembers membersw = new StructureMembers(array.getStructureMembers()); return new ArrayStructureW(membersw, m.getShape(), this_sdata); }
/** * Get member data of type array of Structure. * * @param recnum get data from the recnum-th StructureData of the ArrayStructure. Must be less than getSize(); * @param m get data from this StructureMembers.Member. Must be of type Structure. * @return nested ArrayStructure. */ public ArrayStructure getArrayStructure(int recnum, StructureMembers.Member m) { if ((m.getDataType() != DataType.STRUCTURE) && (m.getDataType() != DataType.SEQUENCE)) throw new IllegalArgumentException("Type is " + m.getDataType() + ", must be Structure or Sequence"); if (m.getDataType() == DataType.SEQUENCE) return getArraySequence(recnum, m); ArrayStructure array = (ArrayStructure) m.getDataArray(); int count = m.getSize(); StructureData[] this_sdata = new StructureData[count]; for (int i = 0; i < count; i++) this_sdata[i] = array.getStructureData(recnum * count + i); // make a copy of the members, but remove the data arrays, since the structureData must be used instead StructureMembers membersw = new StructureMembers(array.getStructureMembers()); return new ArrayStructureW(membersw, m.getShape(), this_sdata); }
public void writeRecord(double timeCoordValue, CalendarDate obsDate, EarthLocation loc, StructureData sdata) throws IOException { trackBB(loc, obsDate); // needs to be wrapped as an ArrayStructure, even though we are only writing one at a time. ArrayStructureW sArray = new ArrayStructureW(sdata.getStructureMembers(), new int[]{1}); sArray.setStructureData(sdata, 0); timeArray.set(0, timeCoordValue); latArray.set(0, loc.getLatitude()); lonArray.set(0, loc.getLongitude()); if (altUnits != null) altArray.set(0, loc.getAltitude()); // write the recno record origin[0] = recno; try { writer.write(record, origin, sArray); writer.write(time, origin, timeArray); writer.write(lat, origin, latArray); writer.write(lon, origin, lonArray); if (altUnits != null) writer.write(alt, origin, altArray); } catch (InvalidRangeException e) { e.printStackTrace(); throw new IllegalStateException(e); } recno++; }
public Array makeNested2(StructureMembers.Member nested, int who, int size) throws IOException, InvalidRangeException { StructureMembers members = new StructureMembers(nested.getName()); nested.setStructureMembers(members); StructureMembers.Member h1 = members.addMember("h1", "desc", "units", DataType.INT, new int[]{1}); StructureMembers.Member h2 = members.addMember("h2", "desc", "units", DataType.DOUBLE, new int[]{2}); StructureData[] sdata = new StructureData[size]; for (int i=0; i<size; i++) { StructureDataW sdw = new StructureDataW( members); sdata[i] = sdw; Array data = Array.factory(DataType.INT, new int[]{1}); sdw.setMemberData(h1, data); fill(data, i * 303 + who); data = Array.factory(DataType.DOUBLE, new int[]{2}); sdw.setMemberData(h2, data); fill(data, i * 3003+ who); } return new ArrayStructureW(members, new int[]{size}, sdata); }
public Array makeNested1(StructureMembers.Member nested1, int size1, int size2) throws IOException, InvalidRangeException { StructureMembers members = new StructureMembers(nested1.getName()); nested1.setStructureMembers(members); StructureMembers.Member g1 = members.addMember("g1", "desc", "units", DataType.INT, new int[]{1}); StructureMembers.Member g2 = members.addMember("g2", "desc", "units", DataType.DOUBLE, new int[]{2}); StructureMembers.Member g3 = members.addMember("g3", "desc", "units", DataType.DOUBLE, new int[]{3, 4}); StructureMembers.Member nested2 = members.addMember("nested2", "desc", "units", DataType.STRUCTURE, new int[]{7}); StructureData[] sdata = new StructureData[size1]; for (int i=0; i<size1; i++) { StructureDataW sdw = new StructureDataW( members); sdata[i] = sdw; Array data = Array.factory(DataType.INT, new int[]{1}); sdw.setMemberData(g1, data); fill(data, i * 22); data = Array.factory(DataType.DOUBLE, new int[]{2}); sdw.setMemberData(g2, data); fill(data, i * 222); data = Array.factory(DataType.DOUBLE, new int[]{3, 4}); sdw.setMemberData(g3, data); fill(data, i * 2222); data = makeNested2(nested2, i, size2); sdw.setMemberData(nested2, data); } return new ArrayStructureW(members, new int[]{size1}, sdata); }