ucar.nc2.dt.radial.Dorade2Dataset 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.
The newest version!
// $Id:Dorade2Dataset.java 51 2006-07-12 17:13:13Z caron $
/*
* 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.dt.radial;
import ucar.nc2.dataset.*;
import ucar.nc2.constants.*;
import ucar.nc2.constants.FeatureType;
import ucar.nc2.dt.*;
import ucar.nc2.units.DateUnit;
import ucar.nc2.units.SimpleUnit;
import ucar.nc2.VariableSimpleIF;
import ucar.nc2.Variable;
import ucar.ma2.*;
import java.io.IOException;
import java.util.List;
import java.util.Date;
import java.util.Iterator;
import java.util.ArrayList;
/**
* Make a Dorade 2 NetcdfDataset into a RadialDataset.
*
* @author yuan
* @version $Revision:51 $ $Date:2006-07-12 17:13:13Z $
*/
public class Dorade2Dataset extends RadialDatasetSweepAdapter implements TypedDatasetFactoryIF {
protected ucar.nc2.units.DateUnit dateUnits;
private NetcdfDataset ncd;
float [] elev, aziv, disv, lonv, altv, latv;
double[] timv;
float ranv, cellv, angv, nyqv, rangv, contv, rgainv, bwidthv;
/////////////////////////////////////////////////
// TypedDatasetFactoryIF
public boolean isMine(NetcdfDataset ds) {
String convention = ds.findAttValueIgnoreCase(null, "Conventions", null);
if ((null != convention) && convention.equals(_Coordinate.Convention)) {
String format = ds.findAttValueIgnoreCase(null, "Format", null);
if (format.equals("Unidata/netCDF/Dorade"))
return true;
}
return false;
}
public TypedDataset open(NetcdfDataset ncd, ucar.nc2.util.CancelTask task, StringBuilder errlog) throws IOException {
return new Dorade2Dataset(ncd);
}
public FeatureType getScientificDataType() { return FeatureType.RADIAL; }
public Dorade2Dataset() {}
/**
* Constructor.
*
* @param ds must be from dorade IOSP
*/
public Dorade2Dataset(NetcdfDataset ds) {
super(ds);
this.ncd = ds;
desc = "dorade radar dataset";
//EarthLocation y = getEarthLocation() ;
try {
elev = (float []) ncd.findVariable("elevation").read().get1DJavaArray(Float.TYPE);
aziv = (float []) ncd.findVariable("azimuth").read().get1DJavaArray(Float.TYPE);
altv = (float []) ncd.findVariable("altitudes_1").read().get1DJavaArray(Float.TYPE);
lonv = (float []) ncd.findVariable("longitudes_1").read().get1DJavaArray(Float.TYPE);
latv = (float []) ncd.findVariable("latitudes_1").read().get1DJavaArray(Float.TYPE);
disv = (float []) ncd.findVariable("distance_1").read().get1DJavaArray(Float.TYPE);
timv = (double []) ncd.findVariable("rays_time").read().get1DJavaArray(Double.TYPE);
angv = ncd.findVariable("Fixed_Angle").readScalarFloat();
nyqv = ncd.findVariable("Nyquist_Velocity").readScalarFloat();
rangv = ncd.findVariable("Unambiguous_Range").readScalarFloat();
contv = ncd.findVariable("Radar_Constant").readScalarFloat();
rgainv = ncd.findVariable("rcvr_gain").readScalarFloat();
//bwidthv = ncd.findVariable("bm_width").readScalarFloat();
} catch (IOException e) {
e.printStackTrace();
}
setStartDate();
setEndDate();
}
public String getRadarID() {
return ncd.findGlobalAttribute("radar_name").getStringValue();
}
public String getRadarName() {
return "Dorade Radar";
}
public String getDataFormat() {
return "DORADE";
}
public ucar.unidata.geoloc.EarthLocation getCommonOrigin() {
if (isStationary())
return new ucar.unidata.geoloc.EarthLocationImpl(latv[0], lonv[0], elev[0]);
return null;
}
public boolean isStationary() {
String t = ncd.findGlobalAttribute("IsStationary").getStringValue();
return t.equals("1"); // if t == "1" return true
}
//public boolean isRadial() {
// return true;
//}
public boolean isVolume() {
return false;
}
protected void setEarthLocation() {
if (isStationary())
origin = new ucar.unidata.geoloc.EarthLocationImpl(latv[0], lonv[0], elev[0]);
origin = null;
}
protected void addRadialVariable(NetcdfDataset nds, Variable var) {
RadialVariable rsvar = null;
String vName = var.getShortName() ;
int rnk = var.getRank();
if(rnk == 2) {
VariableSimpleIF v = new MyRadialVariableAdapter(vName, var.getAttributes());
rsvar = makeRadialVariable(nds, v, var);
}
if(rsvar != null)
dataVariables.add(rsvar);
}
protected RadialVariable makeRadialVariable(NetcdfDataset nds, VariableSimpleIF v, Variable v0) {
return new Dorade2Variable(nds, v, v0);
}
public java.util.List getDataVariables() {
return dataVariables;
}
protected void setStartDate() {
Date da = new Date((long) timv[0]);
String start_datetime = da.toString();
if (start_datetime != null)
startDate = da;
else
parseInfo.append("*** start_datetime not Found\n");
}
protected void setEndDate() {
Date da = new Date((long) timv[timv.length - 1]);
String end_datetime = da.toString();
if (end_datetime != null)
endDate = da;
else
parseInfo.append("*** end_datetime not Found\n");
}
protected void setTimeUnits() throws Exception {
List axes = ncd.getCoordinateAxes();
for (int i = 0; i < axes.size(); i++) {
CoordinateAxis axis = (CoordinateAxis) axes.get(i);
if (axis.getAxisType() == AxisType.Time) {
String units = axis.getUnitsString();
dateUnits = new DateUnit(units);
return;
}
}
parseInfo.append("*** Time Units not Found\n");
}
public List getAttributes() {
return ncd.getRootGroup().getAttributes();
}
public ucar.nc2.units.DateUnit getTimeUnits() {
return dateUnits;
}
public void getTimeUnits(ucar.nc2.units.DateUnit dateUnits) {
this.dateUnits = dateUnits;
}
public void clearDatasetMemory() {
List rvars = getDataVariables();
Iterator iter = rvars.iterator();
while (iter.hasNext()) {
RadialVariable radVar = (RadialVariable)iter.next();
radVar.clearVariableMemory();
}
}
private class Dorade2Variable extends MyRadialVariableAdapter implements RadialDatasetSweep.RadialVariable {//extends VariableSimpleAdapter {
ArrayList sweeps;
int nsweeps;
String name;
float ele, azi, alt, lon, lat;
//float rt;
//RadialDatasetSweep.Sweep sweep;
public int getNumSweeps() {
return 1;
}
public Sweep getSweep(int nsw) {
return (Sweep) sweeps.get(nsw);
}
private Dorade2Variable(NetcdfDataset nds, VariableSimpleIF v, Variable v0) {
super(v.getShortName(), v0.getAttributes());
sweeps = new ArrayList();
nsweeps = 0;
name = v.getShortName();
int[] shape = v0.getShape();
int count = v0.getRank() - 1;
int ngates = shape[count];
count--;
int nrays = shape[count];
sweeps.add( new Dorade2Sweep(v0, 0, nrays, ngates)) ;
}
public String toString() {
return name;
}
public float[] readAllData() throws java.io.IOException {
Array allData;
Sweep spn = (Sweep)sweeps.get(0);
Variable v = spn.getsweepVar();
try {
allData = v.read();
} catch (IOException e) {
throw new IOException(e.getMessage());
}
return (float []) allData.get1DJavaArray(Float.TYPE);
}
public void clearVariableMemory() {
// doing nothing
}
//////////////////////////////////////////////////////////////////////
private class Dorade2Sweep implements RadialDatasetSweep.Sweep {
int nrays, ngates;
double meanElevation = Double.NaN;
Variable sweepVar;
int sweepno;
//int[] shape, origi;
Dorade2Sweep(Variable v, int sweepno, int rays, int gates){
this.sweepVar = v;
this.nrays = rays;
this.ngates = gates;
this.sweepno = sweepno;
}
public Variable getsweepVar(){
return sweepVar;
}
public RadialDatasetSweep.Type getType() {
return null;
}
public float getLon(int ray) {
return lonv[ray];
}
public int getGateNumber() {
return ngates;
}
public int getRadialNumber() {
return nrays;
}
public int getSweepIndex() {
return 0;
}
public float[] readData() throws java.io.IOException {
return readAllData();
}
public float[] readData(int ray) throws java.io.IOException {
Array rayData;
int [] shape = sweepVar.getShape();
int [] origi = new int[ sweepVar.getRank()];
shape[0] = 1;
origi[0] = ray;
try {
rayData = sweepVar.read(origi, shape);
} catch (ucar.ma2.InvalidRangeException e) {
throw new IOException(e.getMessage());
}
return (float []) rayData.get1DJavaArray(Float.TYPE);
}
public float getBeamWidth() { // degrees
try {
bwidthv = ncd.findVariable("bm_width").readScalarFloat();
} catch (java.io.IOException e) {
e.printStackTrace();
}
return bwidthv;
}
public float getNyquistFrequency() {
return 0.0f;
}
public float getRangeToFirstGate() { // meters
try {
ranv = ncd.findVariable("Range_to_First_Cell").readScalarFloat();
} catch (java.io.IOException e) {
e.printStackTrace();
}
return ranv;
}
public float getGateSize() { // meters
try {
cellv = ncd.findVariable("Cell_Spacing").readScalarFloat();
} catch (java.io.IOException e) {
e.printStackTrace();
}
return cellv;
}
// coordinates of the radial data, relative to radial origin.
public float getMeanElevation() {// degrees from horisontal earth tangent, towards zenith
int[] shapeRadial = new int[1];
shapeRadial[0] = nrays;
Array data = Array.factory(Float.class, shapeRadial, elev);
meanElevation = MAMath.sumDouble(data) / data.getSize();
return (float) meanElevation;
}
public float getElevation(int ray) {// degrees from horisontal earth tangent, towards zenith
return elev[ray];
}
public float[] getElevation() {// degrees from horisontal earth tangent, towards zenith
return elev;
}
public float getAzimuth(int ray) { // degrees clockwise from true North
return aziv[ray];
}
public float[] getAzimuth() { // degrees clockwise from true North
return aziv;
}
public float getTime() {
return (float) timv[0];
}
public float getTime(int ray) {
return (float) timv[ray];
}
/**
* Location of the origin of the radial
*/
public ucar.unidata.geoloc.EarthLocation getOrigin(int ray) {
return new ucar.unidata.geoloc.EarthLocationImpl(latv[ray], lonv[ray], altv[ray]);
}
public float getMeanAzimuth() {
if (getType() != null)
return azi;
return 0f;
}
public Date getStartingTime() {
return startDate;
}
public Date getEndingTime() {
return endDate;
}
public void clearSweepMemory() {
// doing nothing for dorade adapter
}
} // Dorade2Sweep class
} // Dorade2Variable
private static void testRadialVariable(RadialDatasetSweep.RadialVariable rv) throws IOException {
//ucar.nc2.dt.radial.RadialCoordSys rcsys = rv.getRadialCoordSys();
//assert rcsys != null;
int nsweep = rv.getNumSweeps();
if (nsweep != 1) {
}
Sweep sw = rv.getSweep(0);
int nrays = sw.getRadialNumber();
float [] ddd = sw.readData();
for (int i = 0; i < nrays; i++) {
int ngates = sw.getGateNumber();
float [] d = sw.readData(i);
float azi = sw.getAzimuth(i);
float ele = sw.getElevation(i);
double t = sw.getTime(i);
Date da = new Date((long) t);
//da.setTime((long)t);
String start_datetime = da.toString();
float dis = sw.getRangeToFirstGate();
float beamW = sw.getBeamWidth();
float gsize = sw.getGateSize();
float la = (float) sw.getOrigin(i).getLatitude();
float lo = (float) sw.getOrigin(i).getLongitude();
float al = (float) sw.getOrigin(i).getAltitude();
}
}
public static void main(String args[]) throws Exception, IOException, InstantiationException, IllegalAccessException {
String fileIn = "/home/yuanho/dorade/swp.1020511015815.SP0L.573.1.2_SUR_v1";
RadialDatasetSweep rds = (RadialDatasetSweep) TypedDatasetFactory.open( FeatureType.RADIAL, fileIn, null, new StringBuilder());
String st = rds.getStartDate().toString();
String et = rds.getEndDate().toString();
if (rds.isStationary()) {
System.out.println("*** radar is stationary\n");
}
List rvars = rds.getDataVariables();
RadialDatasetSweep.RadialVariable vDM = (RadialDatasetSweep.RadialVariable) rds.getDataVariable("DM");
testRadialVariable(vDM);
for (int i = 0; i < rvars.size(); i++) {
RadialDatasetSweep.RadialVariable rv = (RadialDatasetSweep.RadialVariable) rvars.get(i);
testRadialVariable(rv);
// RadialCoordSys.makeRadialCoordSys( "desc", CoordinateSystem cs, VariableEnhanced v);
// ucar.nc2.dt.radial.RadialCoordSys rcsys = rv.getRadialCoordSys();
}
}
} // Dorade2Dataset