scansun.h

Go to the documentation of this file.

/* --------------------------------------------------------------------
Copyright (C) 2010 Royal Netherlands Meteorological Institute, KNMI and
                   Swedish Meteorological and Hydrological Institute, SMHI,
 
This 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.
 
This software 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 HLHDF.  If not, see <http://www.gnu.org/licenses/>.
------------------------------------------------------------------------*/
 
#ifndef SCANSUN_H
#define SCANSUN_H
#include <time.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
 
#include "rave_debug.h"
#include "rave_io.h"
#include "polarscan.h"
#include "polarvolume.h"
#include "rave_object.h"
#include "rave_types.h"
#include "rave_attribute.h"
#include "rave_alloc.h"
#include "rave_list.h"
 
/******************************************************************************/
/*Definition of analysis parameters.                                          */
/******************************************************************************/
 
#define HEIGMIN1   (8.0)          /*Minimum height for first analyses in km.*/
#define HEIGMIN2   (4.0)          /*Minimum height for second analyses in km.*/
#define RAYMIN     (20.0)         /*Minimum length of rays for analyses in km.*/
#define FRACDATA   (0.70)         /*Fraction of rangebins passing the analyses.*/
#define DBDIFX     (2.0)          /*Maximum dev. of power from 1st fit in dB.*/
#define ANGLEDIF   (5.0)          /*Maximum dev. from calculated sun in deg.*/
#define GASATTN    (0.016)        /*Two-way gaseous attenuation in dB/km.*/
#define CWIDTH     (1.2)          /*Factor between bandwidth and 1/pulselength.*/
 
/******************************************************************************/
/*Definition of radar parameters for solar analysis:                          */
/******************************************************************************/
 
#define WAVELENGTH (0.053)        /*Default wavelength in meters*/
#define ANTVEL     (18.0)         /*Default antenna velocity in deg/s*/
#define ANTGAIN    (45.0)         /*Default antenna gain in dB*/
#define ASTART     (0.0)          /*Default azimuthal offset from 0 in degrees*/
#define PULSEWIDTH (2.0)          /*Default pulse width in microseconds*/
#define RXLOSS     (0.0)          /*Default receiver chain loss in dB*/
#define RADCNST    (64.0)         /*Super-arbitrary default radar constant*/
 
#define ONEPOL     (3.01)         /*Losses due to one-pol RX only in dB.*/
#define AVGATTN    (1.39)         /*Averaging and overlap losses in dB for 1deg.*/
 
/******************************************************************************/
/*Definition of standard parameters.                                          */
/******************************************************************************/
 
#define DEG2RAD    (0.017453293)  /*Degrees to radians.*/
#define RAD2DEG    (57.29578)     /*Radians to degrees.*/
#define LSTR       (128)          /*Length of all strings used.*/
#define NELEVX     (64)           /*Maximum number of elevations.*/
#define RADIUS43   (8495.0)       /*Earth radius used for height calculations.*/
 
/******************************************************************************/
/*Definition of parameters for refraction correction.                         */
/******************************************************************************/
 
#define EARTHRAD   (6371.0)       /*Radius of spherical earth in km.*/
#define KFACT      (1.25)         /*K-factor in Equivalent Earth Model.*/
#define N0         (313.0)        /*Atmospherc refractivity at the surface.*/
 
typedef enum ZdrType {
  ZdrType_None = 0,      
  ZdrType_READ = 1,      
  ZdrType_CALCULATE = 2  
} ZdrType;
 
/******************************************************************************/
/*Structure for containing SCAN metadata:                                     */
/******************************************************************************/
 
struct scanmeta {
        long date;             
        long time;             
        double elev;           /*Elevation of scan in deg.*/
        long nrang;            /*Number of range bins in scan.*/
        long nazim;            /*Number of azimuth rays in scan.*/
        double rscale;         /*Size of range bins in scan in km.*/
        double ascale;         /*Size of azimuth steps in scan in deg.*/
        long azim0;            /*Ray number with which radar scan started.*/
        double astart;         /*Azimuthal offset in degrees from 0*/
        double pulse;          /*Pulse length in microsec.*/
        double bandwidth;      /*Receiver bandwidth in MHz.*/
        double radcnst;        /*Radar constant in dB.*/
        double antvel;         /*Antenna velocity in deg/s.*/
        double lon;            /*Longitude of radar in deg.*/
        double lat;            /*Latitude of radar in deg.*/
        double RXLoss;         /*Total losses between reference and feed (dB).*/
        double AntGain;        /*Antenna gain (dB)*/
        double LAntGain;       /*Linear antenna gain*/
        double AntArea;        /*Effective antenna area (m2)*/
        double wavelength;     /*Wavelength in meters*/
        char quant1[1024];    /*what/quantity for the given scan's parameter, either TH or DBZH*/
        char quant2[1024];    /*ZDR or either TV or DBZV*/
        double* startazA;      /*Simple array of starting azimuth angles in degrees*/
        double* stopazA;       /*Simple array of ending azimuth angles in degrees*/
        double* elangles;      /*Simple array of elevation angles (mid-point) in degrees*/
        double* startazT;      /*Simple array of starting ray acquisition times in epoch seconds*/
        double* stopazT;       /*Simple array of ending ray acquisition times in epoch seconds*/
        ZdrType Zdr;           /*Flag used to note presence of ZDR, either read or calculated*/
};
typedef struct scanmeta SCANMETA;
 
/*
 * Structure for containing output values:
 */
struct rvals {
        long date;        /* Date of scan data in YYYYMMDD */
        long time;        /* Time of scan data in HHMMSS */
        double timer;     /* Time of scan data in HHMMSS.DCm */
        double Elev;      /* Elevation of scan in deg. */
        double Azimuth;   /* Azimuth of scan in deg. */
        double ElevSun;   /* Elevation angle of the sun in deg. */
        double AzimSun;   /* Azimuth angle of the sun in deg. */
        double SunMean;   /* Sun's reflectivity in dBm */
        double SunStdd;   /* Standard deviation of the sun's reflectivity in dBm */
        double dBSunFlux; /* Sun flux in dB */
        double ZdrMean;   /* Zdr mean */
        double ZdrStdd;   /* Zdr standard deviation */
        char quant1[1024];     /* what/quantity for the given scan's parameter: TH, DBZH, TV, or DBZV */
        char quant2[1024];     /* ZDR or either TV or DBZV */
        double RelevSun;  /* Refraction-corrected (perceived) elevation angle of the sun in deg. */
        int n;            /* Sample size along the ray comprising a hit */
};
typedef struct rvals RVALS;
 
/******************************************************************************/
/*Prototypes of local functions:                                              */
/******************************************************************************/
 
int getDoubleAttribute(RaveCoreObject* obj, const char* aname, double* tmpd);
 
int getDoubleArrayAttribute(PolarScan_t* scan, const char* aname, double** array, PolarScanParam_t* param);
 
void fill_toplevelmeta(RaveCoreObject* object, SCANMETA *meta);
 
void fill_meta(PolarScan_t* scan, PolarScanParam_t* dbzh, SCANMETA *meta);
 
double ElevHeig2Rang(double elev,float heig);
 
void datetime(long date1, long time1, long ss, long *date2, long *time2);
 
double refraction(double *elev);
 
void solar_elev_azim(double lon, double lat, long yyyymmdd, long hhmmss, double *elev, double *azim, double *relev);
 
void readoutTiming(SCANMETA* meta, int ia, long* date, long* time, double* timer);
 
int processData(PolarScan_t* scan, SCANMETA* meta, RaveList_t* list);
 
int processScan(PolarScan_t* scan, SCANMETA* meta, RaveList_t* list);
 
void outputMeta(SCANMETA* meta);
 
int scansunFromObject(RaveCoreObject* object, Rave_ObjectType ot, RaveList_t* list, char** source);
 
int scansun(const char* filename, RaveList_t* list, char** source);
 
#endif