public ArrayStructureComposite(StructureMembers members, List<ArrayStructure> c, int total) { super(members, new int[total]); this.compose = c; start = new int[total]; int count = 0; int i = 0; for (ArrayStructure as : compose) { start[i++] = count; count += (int) as.getSize(); } }
/** * Constructor. * * @param sa StructureData is always contained in a StructureArray. * @param recno the recno in the StructureArray. */ public StructureDataA(ArrayStructure sa, int recno) { super(sa.getStructureMembers()); this.sa = sa; this.recno = recno; }
/** * Get the index-th StructureData of this ArrayStructure. * * @param index which one to get, specified by an integer. * @return object of type StructureData. */ public Object getObject(int index) { return getStructureData(index); }
double makeObsTimeValue(ArrayStructure abb) { int year = abb.convertScalarInt(0, abb.findMember(yearName)); int hour = abb.convertScalarInt(0, abb.findMember(hourName)); int min = (minName == null) ? 0 : abb.convertScalarInt(0, abb.findMember(minName)); int sec = (secName == null) ? 0 : abb.convertScalarInt(0, abb.findMember(secName)); if (dayName != null) { int day = abb.convertScalarInt(0, abb.findMember(dayName)); int month = abb.convertScalarInt(0, abb.findMember(monthName)); cal.set(year, month-1, day, hour, min, sec); } else { int doy = abb.convertScalarInt(0, abb.findMember(doyName)); cal.set(Calendar.YEAR, year); cal.set(Calendar.DAY_OF_YEAR, doy); cal.set(Calendar.HOUR_OF_DAY, hour); cal.set(Calendar.MINUTE, min); cal.set(Calendar.SECOND, sec); } Date d = cal.getTime(); return dateUnit.makeValue(d); }
/** * Turn any ArrayStructure into a ArrayStructureMA * @param from copy from here. If from is a ArrayStructureMA, return it. * @return equivilent ArrayStructureMA * @throws java.io.IOException on error reading a sequence */ static public ArrayStructureMA factoryMA(ArrayStructure from) throws IOException { if (from instanceof ArrayStructureMA) return (ArrayStructureMA) from; StructureMembers tosm = new StructureMembers( new StructureMembers(from.getStructureMembers())); ArrayStructureMA to = new ArrayStructureMA(tosm, from.getShape()); for (StructureMembers.Member m : from.getMembers()) { to.setMemberArray(m.getName(), from.extractMemberArray(m)); } return to; }
double[] pa = getJavaArrayDouble(recno, m); return Array.factory(double.class, m.getShape(), pa); float[] pa = getJavaArrayFloat(recno, m); return Array.factory(float.class, m.getShape(), pa); byte[] pa = getJavaArrayByte(recno, m); return Array.factory(byte.class, m.getShape(), pa); short[] pa = getJavaArrayShort(recno, m); return Array.factory(short.class, m.getShape(), pa); int[] pa = getJavaArrayInt(recno, m); return Array.factory(int.class, m.getShape(), pa); long[] pa = getJavaArrayLong(recno, m); return Array.factory(long.class, m.getShape(), pa); char[] pa = getJavaArrayChar(recno, m); return Array.factory(char.class, m.getShape(), pa); String[] pa = getJavaArrayString(recno, m); return Array.factory(String.class, m.getShape(), pa); return getArrayStructure(recno, m); return getArraySequence(recno, m); return getArrayObject(recno, m);
public List getData(CancelTask cancel) throws IOException { String CE = outerSequence.getFullName(); ArrayStructure as = (ArrayStructure) dodsFile.readWithCE(outerSequence, CE); extractMembers(as); int n = (int) as.getSize(); List<SeqPointObs> dataList = new ArrayList<SeqPointObs>(n); for (int i=0; i<n; i++) dataList.add( new SeqPointObs( i, as.getStructureData(i))); return dataList; }
TableArrayStructure(NetcdfDataset ds, TableConfig config) { super(ds, config); this.as = config.as; this.dim = new Dimension(config.structName, (int) config.as.getSize(), false); assert (this.as != null); for (StructureMembers.Member m : config.as.getStructureMembers().getMembers()) cols.add(new VariableSimpleAdapter(m)); }
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"); }
static private void extractSection(ParsedSectionSpec child, ArrayStructure outerData, IndexIterator to) throws IOException, InvalidRangeException { long wantNelems = child.section.computeSize(); StructureMembers.Member m = outerData.findMember(child.v.getShortName()); for (int recno = 0; recno < outerData.getSize(); recno++) { Array innerData = outerData.getArray(recno, m); if (child.child == null) { // inner variable if (wantNelems != innerData.getSize()) innerData = innerData.section(child.section.getRanges()); MAMath.copy(child.v.getDataType(), innerData.getIndexIterator(), to); } else { // not an inner variable - must be an ArrayStructure if (innerData instanceof ArraySequence) extractSectionFromSequence(child.child, (ArraySequence) innerData, to); else { if (wantNelems != innerData.getSize()) innerData = sectionArrayStructure(child, (ArrayStructure) innerData, m); extractSection(child.child, (ArrayStructure) innerData, to); } } } }
protected ArrayStructure convert(Array data, Section section) throws IOException { ArrayStructure orgAS = (ArrayStructure) data; if (!convertNeeded(orgAS.getStructureMembers())) { convertMemberInfo(orgAS.getStructureMembers()); return orgAS; for (StructureMembers.Member m : newAS.getMembers()) { VariableEnhanced v2 = (VariableEnhanced) findVariable(m.getName()); if ((v2 == null) && (orgVar != null)) // these are from orgVar - may have been renamed VariableDS vds = (VariableDS) v2; if (vds.needConvert()) { Array mdata = newAS.extractMemberArray(m); mdata = vds.convert(mdata); newAS.setMemberArray(m, mdata); ArrayObject.D1 seqArray = (ArrayObject.D1) newAS.extractMemberArray(m); ArrayObject.D1 newSeq = new ArrayObject.D1(ArraySequence.class, (int) seqArray.getSize()); Array mdata = newAS.extractMemberArray(m); mdata = innerStruct.convert(mdata, null); newAS.setMemberArray(m, mdata); StructureMembers sm = newAS.getStructureMembers(); convertMemberInfo(sm); newAS.setMemberArray(m, mdata); } catch (InvalidRangeException e) { throw new IOException(e.getMessage());
private void addTime(ArrayStructure as) throws IOException { int n = (int) as.getSize(); Array timeData = Array.factory(double.class, new int[]{n}); IndexIterator ii = timeData.getIndexIterator(); StructureDataIterator iter = as.getStructureDataIterator(); while (iter.hasNext()) ii.setDoubleNext(construct.makeObsTimeValue(iter.next())); StructureMembers.Member m = as.findMember(ConstructNC.TIME_NAME); m.setDataArray(timeData); }
for (StructureMembers.Member sm : attData.getStructureMembers().getMembers()) { Array memberData = attData.extractMemberArray(sm); attList.add(new Attribute(matt.name+"."+sm.getName(), memberData)); StructureMembers smember = attData.getStructureMembers(); for (Variable v : s.getVariables()) { StructureMembers.Member sm = smember.findMember(v.getShortName()); if (null != sm) { Array memberData = attData.extractMemberArray(sm); v.addAttribute(new Attribute(matt.name, memberData)); for (StructureMembers.Member sm : attData.getStructureMembers().getMembers()) { if (s.findVariable(sm.getName()) == null) { Array memberData = attData.extractMemberArray(sm); attList.add(new Attribute(matt.name+"."+sm.getName(), memberData));
StructureMembers.Member g1 = nested1Data.getStructureMembers().findMember("g1"); int g1data = nested1Data.getScalarInt(3, g1); assert g1data == 66; StructureMembers.Member g3 = nested1Data.getStructureMembers().findMember("g3"); double[] g3data = nested1Data.getJavaArrayDouble(3, g3); assert g3data[0] == 73326.0; StructureMembers.Member nested2 = nested1Data.getStructureMembers().findMember("nested2"); ArrayStructure nested2Data = nested1Data.getArrayStructure(6, nested2); StructureMembers.Member h1 = nested2Data.getStructureMembers().findMember("h1"); int val = nested2Data.getScalarInt(4, h1); assert (val == 1218) : val; StructureMembers.Member h2 = nested2Data.getStructureMembers().findMember("h2"); double[] h2data = nested2Data.getJavaArrayDouble(4, h2); assert (h2data[0] == 12018); assert (h2data[1] == 12019);
@Override public StructureDataIterator getStructureDataIterator(Cursor cursor, int bufferSize) throws IOException { return as.getStructureDataIterator(); }
public void testReadStructureSubset() throws IOException, InvalidRangeException { Structure record = (Structure) ncfile.findVariable("record"); assert record != null; List<String> vars = new ArrayList<String>(); vars.add( "wind_speed"); vars.add( "wind_gust"); vars.add( "report"); Structure subset = record.select(vars); // read entire subset ArrayStructure dataAll = (ArrayStructure) subset.read(); StructureMembers sm = dataAll.getStructureMembers(); for(StructureMembers.Member m : sm.getMembers()) { Variable v = subset.findVariable(m.getName()); assert v != null; Array mdata = dataAll.extractMemberArray(m); assert mdata.getShape()[0] == dataAll.getShape()[0]; assert mdata.getElementType() == m.getDataType().getPrimitiveClassType(); System.out.println(m.getName()+ " shape="+new Section(mdata.getShape())); } System.out.println("*** TestStructureSubset ok"); }
StructureMembers.Member g1 = nested1Data.getStructureMembers().findMember("g1"); int g1data = nested1Data.getScalarInt(6, g1); assert g1data == 26; StructureMembers.Member nested2 = nested1Data.getStructureMembers().findMember("nested2"); ArrayStructure nested2Data = nested1Data.getArrayStructure(6, nested2); StructureMembers.Member h1 = nested2Data.getStructureMembers().findMember("h1"); int val = nested2Data.getScalarInt(4, h1); assert (val == 264);
/** * public by accident, do not call directly. * @return Array * @throws IOException on error */ @Override public Array reallyRead(Variable client, CancelTask cancelTask) throws IOException { if (isMemberOfStructure()) { // LOOK should be UnsupportedOperationException ?? List<String> memList = new ArrayList<String>(); memList.add(this.getShortName()); Structure s = getParentStructure().select(memList); ArrayStructure as = (ArrayStructure) s.read(); return as.extractMemberArray( as.findMember( getShortName())); } try { return ncfile.readData(this, getShapeAsSection()); } catch (InvalidRangeException e) { e.printStackTrace(); throw new IOException(e.getMessage()); // cant happen haha } }
public double[] getJavaArrayDouble(StructureMembers.Member m) { return sa.getJavaArrayDouble(recno, m); }
public ArrayStructure getArrayStructure(StructureMembers.Member m) { return sa.getArrayStructure(recno, m); }