ucar.nc2.iosp.uf.UFheader Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of netcdf Show documentation
Show all versions of netcdf Show documentation
The NetCDF-Java Library is a Java interface to NetCDF files,
as well as to many other types of scientific data formats.
/*
* Copyright 1998-2009 University Corporation for Atmospheric Research/Unidata
*
* Portions of this software were developed by the Unidata Program at the
* University Corporation for Atmospheric Research.
*
* Access and use of this software shall impose the following obligations
* and understandings on the user. The user is granted the right, without
* any fee or cost, to use, copy, modify, alter, enhance and distribute
* this software, and any derivative works thereof, and its supporting
* documentation for any purpose whatsoever, provided that this entire
* notice appears in all copies of the software, derivative works and
* supporting documentation. Further, UCAR requests that the user credit
* UCAR/Unidata in any publications that result from the use of this
* software or in any product that includes this software. The names UCAR
* and/or Unidata, however, may not be used in any advertising or publicity
* to endorse or promote any products or commercial entity unless specific
* written permission is obtained from UCAR/Unidata. The user also
* understands that UCAR/Unidata is not obligated to provide the user with
* any support, consulting, training or assistance of any kind with regard
* to the use, operation and performance of this software nor to provide
* the user with any updates, revisions, new versions or "bug fixes."
*
* THIS SOFTWARE IS PROVIDED BY UCAR/UNIDATA "AS IS" AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL UCAR/UNIDATA BE LIABLE FOR ANY SPECIAL,
* INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE ACCESS, USE OR PERFORMANCE OF THIS SOFTWARE.
*/
package ucar.nc2.iosp.uf;
import ucar.unidata.io.RandomAccessFile;
import ucar.nc2.iosp.cinrad.Cinrad2Record;
import java.nio.ByteBuffer;
import java.io.IOException;
import java.util.*;
/**
* Created by IntelliJ IDEA.
* User: yuanho
* Date: Sep 24, 2008
* Time: 3:53:18 PM
* To change this template use File | Settings | File Templates.
*/
public class UFheader {
ucar.unidata.io.RandomAccessFile raf;
ucar.nc2.NetcdfFile ncfile;
static final boolean littleEndianData = true;
String dataFormat = "UNIVERSALFORMAT"; // temp setting
Ray firstRay = null;
HashMap variableGroup;
private int max_radials = 0;
private int min_radials = Integer.MAX_VALUE;
public boolean isValidFile(ucar.unidata.io.RandomAccessFile raf){
try
{
raf.seek(0);
raf.order(RandomAccessFile.BIG_ENDIAN);
byte [] b6 = new byte[6];
byte [] b4 = new byte[4];
raf.read(b6, 0, 6);
String ufStr = new String(b6, 4, 2);
if(!ufStr.equals("UF"))
return false;
//if ufStr is UF, then a further checking apply
raf.seek(0);
raf.read(b4, 0, 4);
int rsize = bytesToInt(b4, false);
byte [] buffer = new byte[rsize];
long offset = raf.getFilePointer();
raf.read(buffer, 0, rsize);
raf.read(b4, 0, 4);
int endPoint = bytesToInt(b4, false);
if(endPoint != rsize) {
return false;
}
ByteBuffer bos = ByteBuffer.wrap(buffer);
firstRay = new Ray(bos, rsize, offset);
}
catch ( IOException e )
{
return( false );
}
return true;
}
void read(ucar.unidata.io.RandomAccessFile raf, ucar.nc2.NetcdfFile ncfile ) throws IOException {
this.raf = raf;
this.ncfile = ncfile;
variableGroup = new HashMap();
raf.seek(0);
raf.order(RandomAccessFile.BIG_ENDIAN);
int rayNumber = 0;
/* get bad data flag from universal header */
while (!raf.isAtEndOfFile()) {
byte [] b4 = new byte[4];
raf.read(b4, 0, 4);
int rsize = bytesToInt(b4, false);
byte [] buffer = new byte[rsize];
long offset = raf.getFilePointer();
raf.read(buffer, 0, rsize);
raf.read(b4, 0, 4);
int endPoint = bytesToInt(b4, false);
if(endPoint != rsize || rsize == 0) {
// System.out.println("Herr " +velocityList.size());
continue;
}
ByteBuffer bos = ByteBuffer.wrap(buffer);
Ray r = new Ray(bos, rsize, offset);
if(firstRay == null) firstRay = r;
rayNumber ++;
HashMap rayMap = r.field_header_map;
Set kSet = rayMap.keySet();
for(Iterator it = kSet.iterator(); it.hasNext();) {
String ab = (String)it.next();
ArrayList group = (ArrayList) variableGroup.get(ab);
if (null == group) {
group = new ArrayList();
variableGroup.put(ab, group);
}
group.add(r);
}
// System.out.println("Ray Number = " + rayNumber);
}
Set vSet = variableGroup.keySet();
for(Iterator it = vSet.iterator(); it.hasNext();) {
String key = (String)it.next();
ArrayList group = (ArrayList) variableGroup.get(key);
ArrayList sgroup = sortScans(key, group);
//variableGroup.remove(key);
variableGroup.put(key, sgroup);
}
//System.out.println("Herr " +velocityList.size());
//return;
}
private ArrayList sortScans(String name, List rays) {
// now group by elevation_num
HashMap groupHash = new HashMap(600);
for (int i = 0; i < rays.size(); i++) {
Ray r = (Ray) rays.get(i);
Integer groupNo = new Integer(r.uf_header2.sweepNumber); //.elevation);
ArrayList group = (ArrayList) groupHash.get(groupNo);
if (null == group) {
group = new ArrayList();
groupHash.put(groupNo, group);
}
group.add(r);
}
// sort the groups by elevation_num
ArrayList groups = new ArrayList(groupHash.values());
Collections.sort(groups, new GroupComparator());
for (int i = 0; i < groups.size(); i++) {
ArrayList group = (ArrayList) groups.get(i);
max_radials = Math.max(max_radials, group.size());
min_radials = Math.min(min_radials, group.size());
}
return groups;
}
public float getMeanElevation(String key, int eNum){
ArrayList gp = (ArrayList)getGroup(key);
float meanEle = getMeanElevation(gp);
return meanEle;
}
public float getMeanElevation(ArrayList gList){
float sum = 0;
int size = 0;
Iterator it = gList.iterator();
while(it.hasNext()){
Ray r = (Ray)it.next();
sum += r.getElevation();
size++;
}
return sum/size;
}
public List getGroup(String key){
return (ArrayList)variableGroup.get(key);
}
public int getMaxRadials() {
return max_radials;
}
public String getDataFormat() {
return dataFormat;
}
public Date getStartDate() {
return firstRay.getDate();
}
public Date getEndDate() {
return firstRay.getDate();
}
public float getHorizontalBeamWidth(String ab){
return firstRay.getHorizontalBeamWidth(ab);
}
public String getStationId(){
return firstRay.uf_header2.siteName;
}
public Short getSweepMode(){
return firstRay.uf_header2.sweepMode;
}
public float getStationLatitude(){
return firstRay.getLatitude();
}
public float getStationLongitude(){
return firstRay.getLongtitude();
}
public float getStationElevation() {
return firstRay.getElevation();
}
public short getMissingData() {
return firstRay.getMissingData();
}
private class GroupComparator implements Comparator {
public int compare(Object o1, Object o2) {
List group1 = (List) o1;
List group2 = (List) o2;
Ray ray1 = (Ray) group1.get(0);
Ray ray2 = (Ray) group2.get(0);
//if (record1.elevation_num != record2.elevation_num)
return (ray1.uf_header2.elevation - ray2.uf_header2.elevation < 13 ? 0 : 1);
//return record1.cut - record2.cut;
}
}
protected short getShort(byte[] bytes, int offset) {
int ndx0 = offset + (littleEndianData ? 1 : 0);
int ndx1 = offset + (littleEndianData ? 0 : 1);
// careful that we only allow sign extension on the highest order byte
return (short)(bytes[ndx0] << 8 | (bytes[ndx1] & 0xff));
}
public static int bytesToShort(byte a, byte b, boolean swapBytes) {
// again, high order bit is expressed left into 32-bit form
if (swapBytes) {
return (a & 0xff) + ((int)b << 8);
} else {
return ((int)a << 8) + (b & 0xff);
}
}
public static int bytesToInt(byte [] bytes, boolean swapBytes) {
byte a = bytes[0];
byte b = bytes[1];
byte c = bytes[2];
byte d = bytes[3];
if (swapBytes) {
return ((a & 0xff) ) +
((b & 0xff) << 8 ) +
((c & 0xff) << 16 ) +
((d & 0xff) << 24);
} else {
return ((a & 0xff) << 24 ) +
((b & 0xff) << 16 ) +
((c & 0xff) << 8 ) +
((d & 0xff) );
}
}
}