public string GetVariableName(NetCdfVariable ncVariable) { var nameBuilder = new StringBuilder((int)NetCdfWrapper.Limits.NC_MAX_NAME); CheckResult(NetCdfWrapper.nc_inq_varname(id, ncVariable, nameBuilder)); return(nameBuilder.ToString()); }
public NetCdfDataType GetVariableDataType(NetCdfVariable ncVariable) { NetCdfDataType type; CheckResult(NetCdfWrapper.nc_inq_vartype(id, ncVariable, out type)); return(type); }
public int GetDimensionLength(NetCdfDimension ncDimension) { IntPtr length; CheckResult(NetCdfWrapper.nc_inq_dimlen(id, ncDimension, out length)); return(length.ToInt32()); }
public string GetDimensionName(NetCdfDimension ncDimension) { var nameBuilder = new StringBuilder((int)NetCdfWrapper.Limits.NC_MAX_NAME); CheckResult(NetCdfWrapper.nc_inq_dimname(id, ncDimension, nameBuilder)); return(nameBuilder.ToString()); }
public NetCdfDimension AddUnlimitedDimension(string dimName) { int dimId; CheckResult(NetCdfWrapper.nc_def_dim(id, dimName, new IntPtr(NetCdfWrapper.NC_UNLIMITED), out dimId)); return(new NetCdfDimension(dimId)); }
public NetCdfDimension AddDimension(string dimName, int dimSize) { int dimId; CheckResult(NetCdfWrapper.nc_def_dim(id, dimName, new IntPtr(dimSize), out dimId)); return(new NetCdfDimension(dimId)); }
/// <summary> /// Check native netcdf status code, throws when error, and displays error code and message /// </summary> /// <param name="result"></param> private static void CheckResult(int result) { if (result != (int)NetCdfWrapper.ResultCode.NC_NOERR) { throw new Exception(String.Format("NetCDF error code {0}: " + NetCdfWrapper.nc_strerror(result), result)); } }
public NetCdfDimension GetDimension(string dimName) { int dimId; var status = NetCdfWrapper.nc_inq_dimid(id, dimName, out dimId); return((status == (int)NetCdfWrapper.ResultCode.NC_NOERR) ? new NetCdfDimension(dimId) : null); }
/// <summary> /// Note that only char array can be higher dimensional here, it will then /// be flattened before written /// </summary> public void Write(NetCdfVariable ncVariable, int[] origin, int[] shape, Array array) { var originPtr = NetCdfFileHelper.ConvertToIntPtr(origin); var shapePtr = NetCdfFileHelper.ConvertToIntPtr(shape); var ncDataType = GetNetCdfDataType(array); switch (ncDataType) { case NetCdfDataType.NC_BYTE: CheckResult(NetCdfWrapper.nc_put_vara(id, ncVariable, originPtr, shapePtr, (byte[])array)); break; case NetCdfDataType.NC_CHAR: var bytes = NetCdfFileHelper.FlattenCharArray(array, shape); CheckResult(NetCdfWrapper.nc_put_vara_text(id, ncVariable, originPtr, shapePtr, bytes)); break; case NetCdfDataType.NC_INT: CheckResult(NetCdfWrapper.nc_put_vara_int(id, ncVariable, originPtr, shapePtr, (int[])array)); break; case NetCdfDataType.NC_FLOAT: CheckResult(NetCdfWrapper.nc_put_vara_float(id, ncVariable, originPtr, shapePtr, (float[])array)); break; case NetCdfDataType.NC_DOUBLE: CheckResult(NetCdfWrapper.nc_put_vara_double(id, ncVariable, originPtr, shapePtr, (double[])array)); break; default: throw new Exception( String.Format("Unknown type for writing NetCDF variable to file: type {0} to file {1}", ncDataType, path)); } }
public void SetFill(bool shouldFill) { int oldMode; CheckResult(NetCdfWrapper.nc_set_fill(id, shouldFill ? (int)NetCdfWrapper.CreateMode.NC_FILL : (int)NetCdfWrapper.CreateMode.NC_NOFILL, out oldMode)); }
public IEnumerable <NetCdfDimension> GetAllDimensions() { int nDims; CheckResult(NetCdfWrapper.nc_inq_ndims(id, out nDims)); // NETCDF-3: dimension has id between 0 and nDims-1: return(Enumerable.Range(0, nDims).Select(d => new NetCdfDimension(d))); }
/// <summary> /// Get mapped netcdf data type for array elements, special case for char[] /// </summary> /// <param name="array"></param> /// <returns></returns> private NetCdfDataType GetNetCdfDataType(Array array) { var type = array.GetType().GetElementType(); if (type == typeof(char[])) { return(NetCdfDataType.NC_CHAR); } return(NetCdfWrapper.GetNetCdf3DataType(type)); }
public static NetCdfFile CreateNew(string path, bool fill = false) { int id; CheckResult(NetCdfWrapper.nc_create(path, FileCreateMode, out id)); var ncFile = new NetCdfFile(path, id); ncFile.SetFill(fill); return(ncFile); }
private int[] GetDimensionIds(NetCdfVariable ncVariable) { int nDims; CheckResult(NetCdfWrapper.nc_inq_varndims(id, ncVariable, out nDims)); var dimIds = new int[nDims]; NetCdfWrapper.nc_inq_vardimid(id, ncVariable, dimIds); return(dimIds); }
public NetCdfVariable AddVariable(string varName, Type type, NetCdfDimension[] ncDimensions) { int varId; CheckResult(NetCdfWrapper.nc_def_var(id, varName, NetCdfWrapper.GetNetCdf3DataType(type), ncDimensions.Length, ncDimensions.Select(d => (int)d).ToArray(), out varId)); var ncVar = new NetCdfVariable(varId); // variable name is unique here, guaranteed by nc_def_var call above ncVariableLookupByName.Add(varName, ncVar); return(ncVar); }
public IEnumerable <string> GetVariableDimensionNames(NetCdfVariable ncVariable) { var dimensions = GetDimensionIds(ncVariable); foreach (var dimId in dimensions) { var nameBuilder = new StringBuilder((int)NetCdfWrapper.Limits.NC_MAX_NAME); CheckResult(NetCdfWrapper.nc_inq_dimname(id, dimId, nameBuilder)); yield return(nameBuilder.ToString()); } }
/// <summary> /// /// </summary> /// <param name="path"></param> /// <param name="writeAccess">opens readonly when true</param> /// <returns></returns> public static NetCdfFile OpenExisting(string path, bool writeAccess = false) { int id; var mode = writeAccess ? NetCdfWrapper.CreateMode.NC_WRITE : NetCdfWrapper.CreateMode.NC_NOWRITE; CheckResult(NetCdfWrapper.nc_open(path, mode, out id)); var netcdf = new NetCdfFile(path, id); netcdf.BuildVariableLookup(); return(netcdf); }
/// <summary> /// Read a part of the variable from file, given a certain stride /// </summary> /// <param name="ncVariable"></param> /// <param name="origin"></param> /// <param name="shape">When shape is -1, this corresponds to reading that entire dimension</param> /// <param name="stride"></param> /// <returns></returns> public Array Read(NetCdfVariable ncVariable, int[] origin, int[] shape, int[] stride) { CreateShapeForFullRange(ncVariable, ref shape); var count = Enumerable.Range(0, origin.Length).Select(i => (shape[i] - origin[i]) / stride[i]).ToArray(); var size = NetCdfFileHelper.GetSize(count); var originPtr = NetCdfFileHelper.ConvertToIntPtr(origin); var stridePtr = NetCdfFileHelper.ConvertToIntPtr(stride); var countPtr = NetCdfFileHelper.ConvertToIntPtr(count); var type = GetDataType(ncVariable); switch (type) { case NetCdfDataType.NC_BYTE: var byteArray = new byte[size]; CheckResult(NetCdfWrapper.nc_get_vars(id, ncVariable, originPtr, countPtr, stridePtr, byteArray)); return(NetCdfFileHelper.CreateArrayFromShape(byteArray, count)); case NetCdfDataType.NC_CHAR: if (shape.Length != 2) { throw new NotSupportedException( "NetCdf: only char arrays for independent string variables supported"); } var charArray = new byte[size]; CheckResult(NetCdfWrapper.nc_get_vars_text(id, ncVariable, originPtr, countPtr, stridePtr, charArray)); return(NetCdfFileHelper.CreateCharArrayFromShape(charArray, count)); case NetCdfDataType.NC_INT: var intArray = new int[size]; CheckResult(NetCdfWrapper.nc_get_vars_int(id, ncVariable, originPtr, countPtr, stridePtr, intArray)); return(NetCdfFileHelper.CreateArrayFromShape(intArray, count)); case NetCdfDataType.NC_FLOAT: var floatArray = new float[size]; CheckResult(NetCdfWrapper.nc_get_vars_float(id, ncVariable, originPtr, countPtr, stridePtr, floatArray)); return(NetCdfFileHelper.CreateArrayFromShape(floatArray, count)); case NetCdfDataType.NC_DOUBLE: var doubleArray = new double[size]; CheckResult(NetCdfWrapper.nc_get_vars_double(id, ncVariable, originPtr, countPtr, stridePtr, doubleArray)); return(NetCdfFileHelper.CreateArrayFromShape(doubleArray, count)); default: throw new Exception( String.Format("Unknown type for reading NetCDF variable from file: type {0} from file {1}", type, path)); } }
public int[] GetShape(NetCdfVariable ncVariable) { var dimIds = GetDimensionIds(ncVariable); var nDims = dimIds.Length; var shape = new int[nDims]; for (int i = 0; i < nDims; ++i) { IntPtr len; CheckResult(NetCdfWrapper.nc_inq_dimlen(id, dimIds[i], out len)); shape[i] = len.ToInt32(); } return(shape); }
public bool IsCharArray(NetCdfVariable ncVariable) { int nDims; NetCdfWrapper.nc_inq_varndims(id, ncVariable, out nDims); if (nDims < 2) { return(false); } NetCdfDataType ncType; CheckResult(NetCdfWrapper.nc_inq_vartype(id, ncVariable, out ncType)); return(ncType == NetCdfDataType.NC_CHAR); }
/// <summary> /// Reads the variables from the netcdf file, needed when opening a new file /// </summary> /// <returns></returns> private void UpdateVariableLookup(ref IDictionary <string, NetCdfVariable> lookup) { lookup.Clear(); int nVars; CheckResult(NetCdfWrapper.nc_inq_nvars(id, out nVars)); var variables = Enumerable.Range(0, nVars).Select(vi => new NetCdfVariable(vi)).ToList(); foreach (var ncVar in variables) { lookup.Add(GetVariableName(ncVar), ncVar); } }
public bool IsVariableUnlimited(NetCdfVariable ncVariable) { int nDims; CheckResult(NetCdfWrapper.nc_inq_varndims(id, ncVariable, out nDims)); var dimIds = new int[nDims]; CheckResult(NetCdfWrapper.nc_inq_vardimid(id, ncVariable, dimIds)); int unlimitedDimId; CheckResult(NetCdfWrapper.nc_inq_unlimdim(id, out unlimitedDimId)); return(dimIds.Contains(unlimitedDimId)); }
/// <summary> /// /// </summary> /// <param name="varId"></param> /// <param name="attributeName"></param> /// <returns>null when attribute does not exist</returns> private NetCdfAttribute GetAttribute(int varId, string attributeName) { NetCdfDataType type; IntPtr lengthPtr; var status = NetCdfWrapper.nc_inq_att(id, varId, attributeName, out type, out lengthPtr); int length = lengthPtr.ToInt32(); if (status == (int)NetCdfWrapper.ResultCode.NC_ENOTATT) { return(null); } CheckResult(status); switch (type) { case NetCdfDataType.NC_CHAR: var charArray = new byte[length + 1]; IntPtr ptr = UTF8Marshal.BytesUTF8ToPtr(charArray); CheckResult(NetCdfWrapper.nc_get_att_text(id, varId, attributeName, ptr)); charArray[length] = 0; return(new NetCdfAttribute(attributeName, UTF8Marshal.PtrToStringUTF8(ptr))); case NetCdfDataType.NC_INT: var intArray = new int[length]; CheckResult(NetCdfWrapper.nc_get_att_int(id, varId, attributeName, intArray)); return(new NetCdfAttribute(attributeName, intArray[0])); case NetCdfDataType.NC_FLOAT: var floatArray = new float[length]; CheckResult(NetCdfWrapper.nc_get_att_float(id, varId, attributeName, floatArray)); return(new NetCdfAttribute(attributeName, floatArray[0])); case NetCdfDataType.NC_DOUBLE: var doubleArray = new double[length]; CheckResult(NetCdfWrapper.nc_get_att_double(id, varId, attributeName, doubleArray)); return(new NetCdfAttribute(attributeName, doubleArray[0])); default: throw new Exception( String.Format("Unknown type {0} for reading NetCDF attribute {1} from file {2}", type, attributeName, path)); } }
public Dictionary <string, object> GetAttributes(NetCdfVariable ncVariable) { var nameValueDictionary = new Dictionary <string, object>(); int nAtts; CheckResult(NetCdfWrapper.nc_inq_varnatts(id, ncVariable, out nAtts)); for (int i = 0; i < nAtts; ++i) { var nameBuilder = new StringBuilder((int)NetCdfWrapper.Limits.NC_MAX_NAME); NetCdfWrapper.nc_inq_attname(id, ncVariable, i, nameBuilder); var name = nameBuilder.ToString(); var attribute = GetAttribute(ncVariable, name); nameValueDictionary.Add(attribute.Name, attribute.Value); } return(nameValueDictionary); }
/// <summary> /// Read out the entire variable from the file /// </summary> /// <param name="ncVariable"></param> /// <returns></returns> public Array Read(NetCdfVariable ncVariable) { var type = GetDataType(ncVariable); var size = GetSize(ncVariable); var shape = GetShape(ncVariable); switch (type) { case NetCdfDataType.NC_BYTE: var byteArray = new byte[size]; CheckResult(NetCdfWrapper.nc_get_var(id, ncVariable, byteArray)); return(NetCdfFileHelper.CreateArrayFromShape(byteArray, shape)); case NetCdfDataType.NC_CHAR: var charArray = new byte[size]; CheckResult(NetCdfWrapper.nc_get_var_text(id, ncVariable, charArray)); return(NetCdfFileHelper.CreateCharArrayFromShape(charArray, shape)); case NetCdfDataType.NC_INT: var intArray = new int[size]; CheckResult(NetCdfWrapper.nc_get_var_int(id, ncVariable, intArray)); return(NetCdfFileHelper.CreateArrayFromShape(intArray, shape)); case NetCdfDataType.NC_FLOAT: var floatArray = new float[size]; CheckResult(NetCdfWrapper.nc_get_var_float(id, ncVariable, floatArray)); return(NetCdfFileHelper.CreateArrayFromShape(floatArray, shape)); case NetCdfDataType.NC_DOUBLE: var doubleArray = new double[size]; CheckResult(NetCdfWrapper.nc_get_var_double(id, ncVariable, doubleArray)); return(NetCdfFileHelper.CreateArrayFromShape(doubleArray, shape)); default: throw new Exception( String.Format("Unknown type for reading NetCDF variable from file: type {0} from file {1}", type, path)); } }
private void WriteAttribute(int varId, NetCdfAttribute ncAttribute) { var value = ncAttribute.Value; if (value is string) { var str = (string)value; CheckResult(NetCdfWrapper.nc_put_att_text(id, varId, ncAttribute.Name, new IntPtr(str.Length), UTF8Marshal.StringUTF8ToPtr(str))); } else if (value is double) { var d = (double)value; CheckResult(NetCdfWrapper.nc_put_att_double(id, varId, ncAttribute.Name, NetCdfDataType.NC_DOUBLE, new IntPtr(1), new[] { d })); } else if (value is float) { var i = (float)value; CheckResult(NetCdfWrapper.nc_put_att_float(id, varId, ncAttribute.Name, NetCdfDataType.NC_FLOAT, new IntPtr(1), new[] { i })); } else if (value is int) { var i = (int)value; CheckResult(NetCdfWrapper.nc_put_att_int(id, varId, ncAttribute.Name, NetCdfDataType.NC_INT, new IntPtr(1), new[] { i })); } else { throw new NotImplementedException(string.Format("NetCdf Attribute type '{0}' not implemented", value != null ? value.GetType().ToString() : "<null>")); } }
public static extern int nc_create(string path, NetCdfWrapper.CreateMode mode, out int ncidp);
public void Flush() { CheckResult(NetCdfWrapper.nc_sync(id)); }
public void Close() { ncVariableLookupByName.Clear(); CheckResult(NetCdfWrapper.nc_close(id)); }
public void EndDefine() { CheckResult(NetCdfWrapper.nc_enddef(id)); }
public void ReDefine() { CheckResult(NetCdfWrapper.nc_redef(id)); }