polarvolume.h

Go to the documentation of this file.

/* --------------------------------------------------------------------
Copyright (C) 2009 Swedish Meteorological and Hydrological Institute, SMHI,
 
This file is part of RAVE.
 
RAVE is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
 
RAVE is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License
along with RAVE.  If not, see <http://www.gnu.org/licenses/>.
------------------------------------------------------------------------*/
 
#ifndef POLARVOLUME_H
#define POLARVOLUME_H
#include "polarscan.h"
#include "projection.h"
#include "rave_object.h"
#include "raveobject_list.h"
 
typedef struct _PolarVolume_t PolarVolume_t;
 
extern RaveCoreObjectType PolarVolume_TYPE;
 
int PolarVolume_setTime(PolarVolume_t* pvol, const char* value);
 
const char* PolarVolume_getTime(PolarVolume_t* pvol);
 
int PolarVolume_setDate(PolarVolume_t* pvol, const char* value);
 
const char* PolarVolume_getDate(PolarVolume_t* pvol);
 
int PolarVolume_setSource(PolarVolume_t* pvol, const char* value);
 
const char* PolarVolume_getSource(PolarVolume_t* pvol);
 
void PolarVolume_setLongitude(PolarVolume_t* pvol, double lon);
 
double PolarVolume_getLongitude(PolarVolume_t* pvol);
 
void PolarVolume_setLatitude(PolarVolume_t* pvol, double lat);
 
double PolarVolume_getLatitude(PolarVolume_t* pvol);
 
void PolarVolume_setHeight(PolarVolume_t* pvol, double height);
 
double PolarVolume_getHeight(PolarVolume_t* pvol);
 
void PolarVolume_setBeamwidth(PolarVolume_t* pvol, double bw);
 
double PolarVolume_getBeamwidth(PolarVolume_t* pvol);
 
void PolarVolume_setBeamwH(PolarVolume_t* self, double beamwidth);
 
double PolarVolume_getBeamwH(PolarVolume_t* self);
 
void PolarVolume_setBeamwV(PolarVolume_t* self, double beamwidth);
 
double PolarVolume_getBeamwV(PolarVolume_t* self);
 
double PolarVolume_getDistance(PolarVolume_t* pvol, double lon, double lat);
 
double PolarVolume_getMaxDistance(PolarVolume_t* pvol);
 
PolarScan_t* PolarVolume_getScanWithMaxDistance(PolarVolume_t* pvol);
 
void PolarVolume_setProjection(PolarVolume_t* pvol, Projection_t* projection);
 
Projection_t* PolarVolume_getProjection(PolarVolume_t* pvol);
 
int PolarVolume_addScan(PolarVolume_t* pvol, PolarScan_t* scan);
 
PolarScan_t* PolarVolume_getScan(PolarVolume_t* pvol, int index);
 
int PolarVolume_getNumberOfScans(PolarVolume_t* pvol);
 
int PolarVolume_removeScan(PolarVolume_t* pvol, int index);
 
PolarScan_t* PolarVolume_getScanClosestToElevation(PolarVolume_t* pvol, double e, int inside);
 
int PolarVolume_indexOf(PolarVolume_t* pvol, PolarScan_t* scan);
 
void PolarVolume_getLonLatNavigationInfo(PolarVolume_t* pvol, double lon, double lat, double height, PolarNavigationInfo* info);
 
PolarNavigationInfo* PolarVolume_getVerticalLonLatNavigationInfo(PolarVolume_t* pvol, double lon, double lat, int *nrNavInfo);
 
RaveValueType PolarVolume_getNearest(PolarVolume_t* pvol, double lon, double lat, double height, int insidee, double* v);
 
RaveValueType PolarVolume_getNearestParameterValue(PolarVolume_t* pvol, const char* quantity, double lon, double lat, double height, int insidee, double* v);
 
RaveValueType PolarVolume_getConvertedVerticalMaxValue(PolarVolume_t* self, const char* quantity, double lon, double lat, double* v, PolarNavigationInfo* navinfo);
 
RaveValueType PolarVolume_getConvertedParameterValueAt(PolarVolume_t* pvol, const char* quantity, int ei, int ri, int ai, double* v);
 
int PolarVolume_getNearestNavigationInfo(PolarVolume_t* pvol, double lon, double lat, double height, int insidee, PolarNavigationInfo* navinfo);
 
int PolarVolume_getSurroundingNavigationInfos(
    PolarVolume_t* pvol,
    double lon,
    double lat,
    double height,
    int insidee,
    int surroundingScans,
    int surroundingRangeBins,
    int surroundingRays,
    PolarNavigationInfo navinfos[]);
 
void PolarVolume_addEiForNavInfos(
    PolarVolume_t* pvol,
    PolarScan_t* scan,
    PolarNavigationInfo navinfos[],
    int noofNavinfos,
    int startNavInfoIndex);
 
RaveValueType PolarVolume_getNearestConvertedParameterValue(PolarVolume_t* pvol, const char* quantity, double lon, double lat, double height, int insidee, double* v, PolarNavigationInfo* navinfo);
 
int PolarVolume_getQualityValueAt(PolarVolume_t* pvol, const char* quantity, int ei, int ri, int ai, const char* name, int convert, double* v);
 
int PolarVolume_setDefaultParameter(PolarVolume_t* pvol, const char* quantity);
 
const char* PolarVolume_getDefaultParameter(PolarVolume_t* pvol);
 
void PolarVolume_sortByElevations(PolarVolume_t* pvol, int ascending);
 
int PolarVolume_isAscendingScans(PolarVolume_t* pvol);
 
int PolarVolume_isTransformable(PolarVolume_t* pvol);
 
int PolarVolume_addAttribute(PolarVolume_t* pvol,
  RaveAttribute_t* attribute);
 
int PolarVolume_addAttributeVersion(PolarVolume_t* pvol,
  RaveAttribute_t* attribute, RaveIO_ODIM_Version version);
 
RaveAttribute_t* PolarVolume_getAttribute(PolarVolume_t* pvol,
  const char* name);
 
RaveAttribute_t* PolarVolume_getAttributeVersion(PolarVolume_t* pvol,
  const char* name, RaveIO_ODIM_Version version);
 
void PolarVolume_removeAttribute(PolarVolume_t* pvol, const char* attrname);
 
RaveList_t* PolarVolume_getAttributeNames(PolarVolume_t* pvol);
 
RaveList_t* PolarVolume_getAttributeNamesVersion(PolarVolume_t* pvol, RaveIO_ODIM_Version version);
 
RaveObjectList_t* PolarVolume_getAttributeValues(PolarVolume_t* pvol);
 
RaveObjectList_t* PolarVolume_getAttributeValuesVersion(PolarVolume_t* pvol, RaveIO_ODIM_Version version);
 
int PolarVolume_hasAttribute(PolarVolume_t* pvol, const char* name);
 
int PolarVolume_isValid(PolarVolume_t* pvol);
 
PolarScan_t* PolarVolume_findScanWithQualityFieldByHowTask(PolarVolume_t* pvol, const char* howtaskvalue, const char* quantity);
 
PolarScan_t* PolarVolume_findAnyScanWithQualityFieldByHowTask(PolarVolume_t* pvol, const char* howtaskvalue);
 
RaveField_t* PolarVolume_getDistanceField(PolarVolume_t* self);
 
RaveField_t* PolarVolume_getHeightField(PolarVolume_t* self);
 
PolarObservation* PolarVolume_getCorrectedValuesAtHeight(PolarVolume_t* self, double height, double gap, int* nobservations);
 
void PolarVolume_setUseAzimuthalNavInformation(PolarVolume_t* self, int v);
 
int PolarVolume_useAzimuthalNavInformation(PolarVolume_t* self);
 
int PolarVolume_removeParametersExcept(PolarVolume_t* self, RaveList_t* parameters);
 
 
 
#endif