From de112777bdce4ee855b44dcfc6b4fec102d917e7 Mon Sep 17 00:00:00 2001 From: Paul Tilles Date: Mon, 21 Sep 2015 17:12:14 +0000 Subject: [PATCH] VLab Issue #9986 - Revert VLab Issue #9986 - HPE change to mean field bias logic; fixes #9986 This reverts commit 4c1637974b3d58329b92b57e4343f26f46cd41da [formerly d3388798e0f55a35f429347c24b408d0e8ae3b7f]. Change-Id: I76b2eb1e28297eed288555d056c88812fe76faac Former-commit-id: 954250c0b33bab2538cceea77afa2946b0c19445 --- .../src/hpe_fieldgen/TEXT/empe_fieldgen.h | 888 +++++++---- .../hpe_fieldgen/TEXT/main_empe_fieldgen.c | 801 ++++++---- .../src/hpe_fieldgen/TEXT/read_rwbiasdyn2.c | 631 +++++--- .../src/hpe_fieldgen/TEXT/run_dhrmosaic.c | 892 +++++++----- .../src/hpe_fieldgen/TEXT/run_ermosaic.c | 1294 ++++++++++------- 5 files changed, 2715 insertions(+), 1791 deletions(-) diff --git a/nativeLib/rary.ohd.pproc/src/hpe_fieldgen/TEXT/empe_fieldgen.h b/nativeLib/rary.ohd.pproc/src/hpe_fieldgen/TEXT/empe_fieldgen.h index bf36bcba61..16959f674b 100644 --- a/nativeLib/rary.ohd.pproc/src/hpe_fieldgen/TEXT/empe_fieldgen.h +++ b/nativeLib/rary.ohd.pproc/src/hpe_fieldgen/TEXT/empe_fieldgen.h @@ -1,20 +1,20 @@ /******************************************************************************* - * FILENAME: empe_fieldgen.h - * - * DESCRIPTION: This file contains parameters and - * user-defined types for the empe_fieldgen main function. - * - * ORIGINAL AUTHOR: Guoxian Zhou - * CREATION DATE: January 2007 - * ORGANIZATION: HSEB / OHD - * MACHINE: Dell-Redhat Linux - * MODIFICATION HISTORY: - * DATE PROGRAMMER DESCRIPTION/REASON - * 07/2013 JingtaoD add prototypes for dual pol proudcts DSA/DPR - * 02/2015 JingtaoD A2 OB14.4.1 DR#17123 - HPE Bias Source field - * update wrtodb_HPERadarResult() - ******************************************************************************** - */ +* FILENAME: empe_fieldgen.h +* +* DESCRIPTION: This file contains parameters and +* user-defined types for the empe_fieldgen main function. +* +* ORIGINAL AUTHOR: Guoxian Zhou +* CREATION DATE: January 2007 +* ORGANIZATION: HSEB / OHD +* MACHINE: Dell-Redhat Linux +* MODIFICATION HISTORY: +* DATE PROGRAMMER DESCRIPTION/REASON +* 07/2013 JingtaoD add prototypes for dual pol proudcts DSA/DPR +* 02/2015 JingtaoD A2 OB14.4.1 DR#17123 - HPE Bias Source field +* update wrtodb_HPERadarResult() +******************************************************************************** +*/ #ifndef EMPE_FIELDGEN_H #define EMPE_FIELDGEN_H @@ -50,32 +50,21 @@ /* Ordering of the elements in this list must be the same as the beginning * of the enum DisplayFieldData type in the mpe_field_names.h header file. */ -typedef enum { - dhrmosaic = 0, - bdhrmosaic, - ermosaic, - avgermosaic, - maxermosaic, - gaugeonly, - ebmosaic, - lmosaic, - mmosaic, - mlmosaic, - lsatpre, - p3lmosaic, - num_mosaics -} mosaicType; +typedef enum {dhrmosaic = 0, bdhrmosaic, ermosaic, avgermosaic, maxermosaic, + gaugeonly, ebmosaic, lmosaic, mmosaic, mlmosaic, lsatpre, + p3lmosaic, num_mosaics}mosaicType ; -extern char currTime[HHMMSS_LEN + 1]; -extern char message[MESSAGE_LEN]; +extern char currTime[HHMMSS_LEN + 1]; +extern char message[MESSAGE_LEN] ; -extern FILE * logFile; +extern FILE * logFile ; -extern run_date_struct * ptrRunDate; -extern geo_data_struct * ptrGeoData; +extern run_date_struct * ptrRunDate ; -extern empe_params_struct * ptrEMPEParams; +extern geo_data_struct * ptrGeoData ; + +extern empe_params_struct * ptrEMPEParams ; extern gage_table_struct ** ptrGageTable; extern gage_table_struct ** ptrGageTableP3; @@ -88,389 +77,674 @@ extern radarLoc_table_struct * ptrRadarLocTable; /* function prototypes */ /*-----------------------------*/ -void apply_mpe_polygons(double ** real_mosaic, const char * dateYMD, int year, - int month, int day, int hour, enum DisplayFieldData field, - const geo_data_struct * pGeoData, double factor, int add_flag, - int draw_only_persistent); +void apply_mpe_polygons ( double ** real_mosaic, + const char * dateYMD, + int year, + int month, + int day, + int hour, + enum DisplayFieldData field, + const geo_data_struct * pGeoData, + double factor, + int add_flag, + int draw_only_persistent ); -void hpe_fieldgen_constructor(); -void hpe_fieldgen_constructorByRunTime(); -void hpe_fieldgen_constructorByGeodata(int blnMosaic[]); -void constructorForMeanBias(int radarLocNum); +void hpe_fieldgen_constructor() ; +void hpe_fieldgen_constructorByRunTime() ; +void hpe_fieldgen_constructorByGeodata(int blnMosaic[]) ; +void constructorForMeanBias(int radarLocNum) ; -void hpe_fieldgen_destructor(); +void hpe_fieldgen_destructor() ; -void editPolygonConstructor(const geo_data_struct * pGeoData); -void editPolygonDestructor(const geo_data_struct * pGeoData); +void editPolygonConstructor ( const geo_data_struct * pGeoData ); +void editPolygonDestructor ( const geo_data_struct * pGeoData ); -void readGeoData(const int hrap_grid_factor, geo_data_struct* pGeoData); +void readGeoData(const int hrap_grid_factor, + geo_data_struct* pGeoData); -void readParams(empe_params_struct *); +void readParams(empe_params_struct *) ; -void readDBParams(empe_params_struct *); +void readDBParams(empe_params_struct *) ; -void readRWParams(RWParams *, long int *); +void readRWParams ( RWParams * , long int * ) ; -void readRWBiasStat(RWBiasStat * pRWBiasStat, const char * office_id, - long int * ircbia); +void readRWBiasStat ( RWBiasStat * pRWBiasStat, + const char * office_id, + long int * ircbia ) ; -void writeParams(const empe_params_struct *); +void writeParams(const empe_params_struct *) ; -void hpe_fieldgen_parseArgs(const int, char **, run_date_struct *); +void hpe_fieldgen_parseArgs(const int , char **, run_date_struct *); -void readGageData(const run_date_struct * pRunDate, - const empe_params_struct * pMPEParams, const geo_data_struct *pGeoData, - gage_table_struct ** pGageTable, gage_table_struct ** pGageTableP3, - gage_table_struct ** pQCGageTable); +void readGageData(const run_date_struct * pRunDate , + const empe_params_struct * pMPEParams , + const geo_data_struct *pGeoData , + gage_table_struct ** pGageTable , + gage_table_struct ** pGageTableP3 , + gage_table_struct ** pQCGageTable ); -void checkMultiple(gage_table_struct * pGageTable); +void checkMultiple( gage_table_struct * pGageTable); -void readGagePrecip(const int runHours, char ** datetimes, - const int hrap_grid_factor, const geo_data_struct *pGeoData, - const int gage_qc, gage_table_struct ** pGageTable, - gage_table_struct ** pGageTableP3, int * gageSize, int * gageSizeP3); +void readGagePrecip ( const int runHours , + char ** datetimes , + const int hrap_grid_factor , + const geo_data_struct *pGeoData, + const int gage_qc, + gage_table_struct ** pGageTable, + gage_table_struct ** pGageTableP3, + int * gageSize, + int * gageSizeP3 ) ; -void readPseudoPrecip(const int runHours, char ** datetimes, - const int hrap_grid_factor, const geo_data_struct * pGeoData, - gage_table_struct ** pGageTable, gage_table_struct ** pGageTableP3, - int * gageSize, int * gageSizeP3); +void readPseudoPrecip( const int runHours , + char ** datetimes , + const int hrap_grid_factor , + const geo_data_struct * pGeoData, + gage_table_struct ** pGageTable, + gage_table_struct ** pGageTableP3, + int * gageSize, + int * gageSizeP3 ) ; -void read_lightning(char dt[19], int *ihrap, int *jhrap, int *num_strike, - long int *irc); +void read_lightning(char dt[19], int *ihrap, int *jhrap, + int *num_strike, long int *irc) ; -double readPrecipLimit(const char * gageID, const time_t datetime); +double readPrecipLimit( const char * gageID , + const time_t datetime) ; void checkSpatialConsistency(const empe_params_struct * pMPEParams, - const geo_data_struct *pGeoData, const gage_table_struct * pGageTable, - int * gageqc); + const geo_data_struct *pGeoData, + const gage_table_struct * pGageTable, + int * gageqc) ; -void writeGageQC(const char * lid, const double value, const char * ts, - const int dur, const char * dt, const int qctype, long int *irc, - int *messageid); +void writeGageQC ( const char * lid, + const double value, + const char * ts, + const int dur, + const char * dt, + const int qctype, + long int *irc, + int *messageid ) ; -void writeRWResult(const char *rfc, const char * dt, const int ngag, - const int isat, const int nrad, const char *field, int * overwrt, - long int *irc); +void writeRWResult ( const char *rfc, + const char * dt, + const int ngag, + const int isat, + const int nrad, + const char *field, + int * overwrt, + long int *irc ) ; -void writeArrayConstructor(const geo_data_struct * pGeoData); -void writeArrayDestructor(const geo_data_struct * pGeoData); +void writeArrayConstructor ( const geo_data_struct * pGeoData ); +void writeArrayDestructor ( const geo_data_struct * pGeoData ); -void writeArray(const geo_data_struct * pGeoData, const char * filedir, - const char * filename, const double factor, const int replace_missing, - const char * user, const time_t tRunTime, const char * proc_flag, - double ** real_mosaic, long int * irc); +void writeArray( const geo_data_struct * pGeoData , + const char * filedir , + const char * filename , + const double factor , + const int replace_missing , + const char * user , + const time_t tRunTime , + const char * proc_flag , + double ** real_mosaic , + long int * irc ) ; -void writeQPE(const run_date_struct * pRunDate, - const empe_params_struct * pMPEParams, const geo_data_struct * pGeoData, - const int gageNum, const int gageNumP3, double ** pQPEMosaic); +void writeQPE(const run_date_struct * pRunDate , + const empe_params_struct * pMPEParams , + const geo_data_struct * pGeoData , + const int gageNum , + const int gageNumP3 , + double ** pQPEMosaic ) ; -void writeRadarResult(const char * rad, const char * dt, const int ngag, - const int irad, const double bias_used, const double mem_span_bias, - long int * irc); +void writeRadarResult(const char * rad, + const char * dt, + const int ngag, + const int irad, + const double bias_used, + const double mem_span_bias, + long int * irc) ; -void saveGif(const geo_data_struct * pGeoData, const char * datestring, - const char * filen, double ** mosaic, long int * irc); +void saveGif( const geo_data_struct * pGeoData , + const char * datestring, + const char * filen, + double ** mosaic, + long int * irc) ; -void saveNetCDF(const int max_x, const int max_y, const char * strDateTime, - const char * fname, double ** pMosaic, const char * proc_flag, - const char * external_dir, long int *irc); +void saveNetCDF( const int max_x , + const int max_y, + const char * strDateTime , + const char * fname, + double ** pMosaic , + const char * proc_flag , + const char * external_dir , + long int *irc) ; -void checkMultisensorQC(const char * datetime, double ** mosaic, - const geo_data_struct * pGeoData, const gage_table_struct * pGageArray); +void checkMultisensorQC(const char * datetime , + double ** mosaic , + const geo_data_struct * pGeoData, + const gage_table_struct * pGageArray ) ; void runERMosaic(const run_date_struct * pRunDate, - const geo_data_struct * pGeoData, empe_params_struct * pMPEParams, - const radarLoc_table_struct * pRadarLocTable, - const gage_table_struct * pGageTable, - const gage_table_struct * pGageTableP3, - const gage_table_struct * pQCGageTable, double * meanFieldBias, - double ** RadarBeamHeight, int ** ID, double ** RMosaic, - double ** QPEMosaic, int * blnMosaic); + const geo_data_struct * pGeoData, + empe_params_struct * pMPEParams, + const radarLoc_table_struct * pRadarLocTable , + const gage_table_struct * pGageTable, + const gage_table_struct * pGageTableP3, + const gage_table_struct * pQCGageTable, + double * meanFieldBias, + double ** RadarBeamHeight, + int ** ID, + double ** RMosaic, + double ** QPEMosaic, + int * blnMosaic) ; -void readRadarLoc(radarLoc_table_struct * pRadarLocTable); +void readRadarLoc ( radarLoc_table_struct * pRadarLocTable ) ; + +void readRadarResult (const char * datetime, + radar_result_struct * pRadarResult, + short * count , + int * dual_pol_flag, + long int * irc) ; -void readRadarResult(const char * datetime, radar_result_struct * pRadarResult, - short * count, int * dual_pol_flag, long int * irc); void readDAARadarResult(const char * datetime, - radar_result_struct * pRadarResult, short * count, int * dual_pol_flag, - long int * irc); + radar_result_struct * pRadarResult, + short * count, + int * dual_pol_flag, + long int * irc); -void readRadarData(const char * radarID, const char * datetime, - const int dpa_wind, const int ignoreRadarFlag, - float radar[][NUM_DPA_COLS], int * radarAvailFlag); +void readRadarData(const char * radarID, + const char * datetime, + const int dpa_wind, + const int ignoreRadarFlag, + float radar [ ] [ NUM_DPA_COLS ] , + int * radarAvailFlag) ; -void readDPARadar(const char * rad, const char * datetime, const int idpawind, - double * maxvald, double * bias, char * fname, int * itim, - long int * irc); +void readDPARadar(const char * rad, + const char * datetime, + const int idpawind, + double * maxvald, + double * bias, + char * fname, + int * itim, + long int * irc) ; void readMisc(const radarLoc_table_struct * pRadarLocTable, - short int ** radarMiscBins); + short int ** radarMiscBins ) ; void getMeanBias(const radarLoc_record_struct * pRadarLocRecord, - const char * datetime, const int grid_rows, const int grid_cols, - short ** radarMiscBins, float ** radar, - const geo_data_struct * pGeoData, const gage_table_struct * pGageArray, - const empe_params_struct * pMPEParams, int dualpol_data_avail, - double * meanBias, double * memSpanBias, int * gageRadarPairNum); + const char * datetime , + const int grid_rows, + const int grid_cols, + short ** radarMiscBins , + float ** radar, + const geo_data_struct * pGeoData , + const gage_table_struct * pGageArray , + const empe_params_struct * pMPEParams , + int dualpol_data_avail, + double * meanBias, + double * memSpanBias, + int * gageRadarPairNum) ; -void retrieveMeanBias(const char * radarID, const char * datetime, - const empe_params_struct * pMPEParams, int dualpol_data_avail, - double * meanBias, double * memSpanBias); +void retrieveMeanBias(const char * radarID, + const char * datetime , + const empe_params_struct * pMPEParams , + int dualpol_data_avail, + double * meanBias, + double * memSpanBias ); void readMeanBias(const run_date_struct * pRunDate, - const radarLoc_table_struct * pRadarLocTable, - const empe_params_struct * pMPEParams, double * meanFieldBias, - int dualpol_data_avail); + const radarLoc_table_struct * pRadarLocTable , + const empe_params_struct * pMPEParams , + double * meanFieldBias, + int dualpol_data_avail); void pairGageRadar(const radarLoc_record_struct * pRadarLocRecord, - const int grid_rows, const int grid_cols, short ** radarMiscBins, - float ** radar, const geo_data_struct * pGeoData, - const gage_table_struct * pGageArray, - const empe_params_struct * pMPEParams, - gage_radar_pair_table_struct * pGageRadarPairTable); + const int grid_rows, + const int grid_cols, + short ** radarMiscBins, + float ** radar, + const geo_data_struct * pGeoData , + const gage_table_struct * pGageArray , + const empe_params_struct * pMPEParams , + gage_radar_pair_table_struct * pGageRadarPairTable) ; -void calculatePixelHeight(const double lon_coord, const double lat_coord, - const double hrap_coord_x, const double hrap_coord_y, - const double hrap_x, const double hrap_y, double * pixelHeight); +void calculatePixelHeight(const double lon_coord, + const double lat_coord, + const double hrap_coord_x, + const double hrap_coord_y, + const double hrap_x, + const double hrap_y, + double * pixelHeight ) ; -void calculateMeanBias(const char * radarID, const char * datetime, - const empe_params_struct * pMPEParams, - const gage_table_struct * pGageArray, - gage_radar_pair_table_struct * pGageRadarPairTable, - int dualpol_data_avail, double * meanBias, double * memSpanBias); +void calculateMeanBias(const char * radarID, + const char * datetime , + const empe_params_struct * pMPEParams , + const gage_table_struct * pGageArray, + gage_radar_pair_table_struct * pGageRadarPairTable , + int dualpol_data_avail, + double * meanBias, + double * memSpanBias ) ; -void gageRadarPairsQC(const empe_params_struct * pMPEParams, - const double bias_long, - gage_radar_pair_table_struct * pGageRadarPairTable, int * flag); +void gageRadarPairsQC(const empe_params_struct * pMPEParams , + const double bias_long , + gage_radar_pair_table_struct * pGageRadarPairTable , + int * flag) ; -void updateStateVariable(const empe_params_struct * pMPEParams, - const float mem_span[], const int lag, - const gage_radar_pair_table_struct * pGageRadarPairTable, - double sumGage[], double sumRadar[], double num_pairs[]); +void updateStateVariable(const empe_params_struct * pMPEParams , + const float mem_span[] , + const int lag , + const gage_radar_pair_table_struct * pGageRadarPairTable , + double sumGage[] , + double sumRadar[] , + double num_pairs[] ) ; -void write_rwbiasdyn(const char *rad, const char * dt, const int num_span, - double * num_pairs, double * sumgag, double * sumrad, double * bb, - long int *irc); +void write_rwbiasdyn(const char *rad, + const char * dt, + const int num_span, + double * num_pairs, + double * sumgag, + double * sumrad, + double * bb, + long int *irc) ; -void readRWBiasDyn(const char *radar_id, const char *office_id, - const char * str, const int lag_cut, double *num_pairs, double *sumgag, - double *sumrad, double *bias, int *lag, char sstr1[19], - int dualpol_data_avail, long int *irc); +void readRWBiasDyn(const char *radar_id, + const char *office_id, + const char * str, + const int lag_cut, + double *num_pairs, + double *sumgag, + double *sumrad, + double *bias, + int *lag, + char sstr1[19], + int dualpol_data_avail, + long int *irc) ; -void readDAABiasDyn(const char *radar_id, const char *office_id, - const char * str, const int lag_cut, double *num_pairs, double *sumgag, - double *sumrad, double *bias, int *lag, char sstr1[19], long int *irc); +void readDAABiasDyn(const char *radar_id, + const char *office_id, + const char * str, + const int lag_cut, + double *num_pairs, + double *sumgag, + double *sumrad, + double *bias, + int *lag, + char sstr1[19], + long int *irc); -void read_spe(const char * satpre_filename, const geo_data_struct * pGeoData, - const int hrap_grid_factor, double ** pSatPre, int * spe_status); -double ** read_satellite(const run_date_struct * pRunDate, - const geo_data_struct * pGeoData, const int hrap_grid_factor, - int run_hour, int * is_sat_avail); +void read_spe ( const char * satpre_filename , + const geo_data_struct * pGeoData, + const int hrap_grid_factor, + double ** pSatPre, + int * spe_status ); -void free_spe_memory(const geo_data_struct * pGeoData, - const int hrap_grid_factor); +double ** read_satellite ( const run_date_struct * pRunDate, + const geo_data_struct * pGeoData, + const int hrap_grid_factor, + int run_hour, + int * is_sat_avail ); + +void free_spe_memory ( const geo_data_struct * pGeoData, + const int hrap_grid_factor ); void free_locbias_memory(const geo_data_struct * pGeoData, - const int hrap_grid_factor); + const int hrap_grid_factor); -void deleteZeros(int * gageSize, short * iug, short * ivg, float * zg, - double ** mosaic); +void deleteZeros( int * gageSize, + short * iug, short * ivg, float * zg, + double ** mosaic) ; -void get_climate(const char * os, const int rowSize, const int colSize, - const char* cem, double ** umeang); +void get_climate(const char * os, const int rowSize, const int colSize, + const char* cem, double ** umeang) ; void readxmrg(const char * os, const int rowSize, const int colSize, - const char * fname, const int lenf, const double factor, double ** xmrg, - int * irc); + const char * fname, const int lenf, const double factor, + double ** xmrg , int * irc); void runGageonly(const run_date_struct * pRunDate, - const geo_data_struct * pGeoData, empe_params_struct * pMPEParams, - const int gageSize, short * iug, short * ivg, float * zg, - double ** umeang, double ** QPEMosaic); + const geo_data_struct * pGeoData, + empe_params_struct * pMPEParams, + const int gageSize, + short * iug , + short * ivg , + float * zg , + double ** umeang, + double ** QPEMosaic) ; -void check_autosave(const char * rfcname, const int * rfclen, - const char dt[ANSI_YEARSEC_TIME_LEN], const int * datelen, - int * ioverwrt); -void apply_mfb(const double * mfbias, const int rowSize, const int colSize, - int ** ID, double ** RMosaic, double ** BMosaic); +void check_autosave ( const char * rfcname, const int * rfclen, + const char dt[ANSI_YEARSEC_TIME_LEN], + const int * datelen, + int * ioverwrt ) ; -int applyLocalBias(const time_t tRunTime, const geo_data_struct * pGeoData, - const empe_params_struct * pEMPEParams, double ** ERMosaic, - double ** EBMosaic); +void apply_mfb(const double * mfbias , + const int rowSize , + const int colSize , + int ** ID , + double ** RMosaic , + double ** BMosaic) ; -void runEBMosaic(const run_date_struct * pRunDate, - const geo_data_struct * pGeoData, const empe_params_struct * pMPEParams, - double * meanFieldBias, int ** ID, double ** RMosaic, double ** BMosaic, - double ** QPEMosaic); +int applyLocalBias(const time_t tRunTime , + const geo_data_struct * pGeoData , + const empe_params_struct * pEMPEParams , + double ** ERMosaic , + double ** EBMosaic); -void runLMosaic(const run_date_struct * pRunDate, - const geo_data_struct * pGeoData, empe_params_struct * pMPEParams, - const int gageSize, short * iug, short * ivg, float * zg, - double ** RMosaic, double ** LMosaic, double ** QPEMosaic); +void runEBMosaic(const run_date_struct * pRunDate , + const geo_data_struct * pGeoData , + const empe_params_struct * pMPEParams , + double * meanFieldBias , + int ** ID , + double ** RMosaic , + double ** BMosaic, + double ** QPEMosaic) ; -void lb_gr_pairs(float gr_min_value, const int gageSize, short * iug, - short * ivg, float * zg, double ** mosaic, - gage_radar_pair_table_struct * pGageRadarPairTable); +void runLMosaic(const run_date_struct * pRunDate , + const geo_data_struct * pGeoData , + empe_params_struct * pMPEParams , + const int gageSize, + short * iug , + short * ivg , + float * zg , + double ** RMosaic , + double ** LMosaic, + double ** QPEMosaic) ; -void runMMosaic(const run_date_struct * pRunDate, - const geo_data_struct * pGeoData, empe_params_struct * pMPEParams, - const int gageSize, short * iug, short * ivg, float * zg, int ** ID, - double ** RMosaic, double ** BMosaic, double ** umeang, - double ** QPEMosaic); +void lb_gr_pairs ( float gr_min_value , + const int gageSize, + short * iug , + short * ivg , + float * zg , + double ** mosaic , + gage_radar_pair_table_struct * pGageRadarPairTable) ; -void runMLMosaic(const run_date_struct * pRunDate, - const geo_data_struct * pGeoData, empe_params_struct * pMPEParams, - const int gageSize, short * iug, short * ivg, float * zg, int ** ID, - double ** RMosaic, double ** LMosaic, double ** umeang, - double ** QPEMosaic); +void runMMosaic(const run_date_struct * pRunDate , + const geo_data_struct * pGeoData , + empe_params_struct * pMPEParams , + const int gageSize, + short * iug , + short * ivg , + float * zg , + int ** ID , + double ** RMosaic , + double ** BMosaic , + double ** umeang , + double ** QPEMosaic) ; -void runLSatpre(const run_date_struct * pRunDate, - const geo_data_struct * pGeoData, empe_params_struct * pMPEParams, - const int gageSize, short * iug, short * ivg, float * zg, - double ** RMosaic, double ** LSatpre, double ** QPEMosaic); +void runMLMosaic(const run_date_struct * pRunDate , + const geo_data_struct * pGeoData , + empe_params_struct * pMPEParams , + const int gageSize, + short * iug , + short * ivg , + float * zg , + int ** ID , + double ** RMosaic , + double ** LMosaic , + double ** umeang , + double ** QPEMosaic) ; -int runP3LMosaic(const run_date_struct * pRunDate, - const empe_params_struct * pMPEParams, - const radarLoc_table_struct * pRadarLocTable, - const gage_table_struct * pGageTableP3, - const geo_data_struct * pGeoData, - enum DisplayFieldData radar_display_type, double ** P3Mosaic, - double ** AvgMosaic, double ** QPEMosaic); +void runLSatpre ( const run_date_struct * pRunDate, + const geo_data_struct * pGeoData, + empe_params_struct * pMPEParams, + const int gageSize, + short * iug , + short * ivg , + float * zg , + double ** RMosaic, + double ** LSatpre, + double ** QPEMosaic ) ; + +int runP3LMosaic ( const run_date_struct * pRunDate, + const empe_params_struct * pMPEParams, + const radarLoc_table_struct * pRadarLocTable, + const gage_table_struct * pGageTableP3, + const geo_data_struct * pGeoData, + enum DisplayFieldData radar_display_type, + double ** P3Mosaic, + double ** AvgMosaic, + double ** QPEMosaic); /* Routines for computing local bias fields. */ -const local_bias_params * getLocalBiasParams(); -void local_bias(const run_date_struct * pRunDate, - const geo_data_struct * pGeoData, const int gageSize, short * iug, - short * ivg, float * zg, empe_params_struct * pMPEParams, - const local_bias_params * pLocalBiasParams, float si_cut, - gage_radar_pair_table_struct * pGageRadarPair, double ** RMosaic, - short int ** local_span, double ** local_bias, const char * dirname, - double ** lmosaic, int * ierr); +const local_bias_params * getLocalBiasParams ( ); +void local_bias ( const run_date_struct * pRunDate, + const geo_data_struct * pGeoData, + const int gageSize, + short * iug , + short * ivg , + float * zg , + empe_params_struct * pMPEParams, + const local_bias_params * pLocalBiasParams, + float si_cut, + gage_radar_pair_table_struct * pGageRadarPair, + double ** RMosaic, + short int ** local_span, + double ** local_bias, + const char * dirname, + double ** lmosaic, + int * ierr ) ; + /* Quick sort routines. */ -void qksort4(gage_radar_pair_table_struct * pGageRadarTable); -void qksort22(int n, float * dd, short * ii); -void qksort32(int n, double * dd, short * ii, short * jj); -void qksorti22(int n, short * dd, short * ii); +void qksort4 ( gage_radar_pair_table_struct * pGageRadarTable ); +void qksort22 ( int n, float * dd, short * ii ); +void qksort32 ( int n, double * dd, short * ii, short * jj ); +void qksorti22 ( int n, short * dd, short * ii ); /* heap sort functionss. */ -void heapSortForGeoIndex(float heapArray[], short hrap_x[], short hrap_y[], - int arraySize); +void heapSortForGeoIndex(float heapArray[], short hrap_x[], + short hrap_y[], int arraySize) ; void heapSortForDoubleAndGeoIndex(double heapArray[], int index_x[], - int index_y[], int arraySize); + int index_y[], int arraySize) ; + /* Routines for handling binary search for station - latitude and longitude data. */ + latitude and longitude data. */ -void free_mpe_latlon_info(); +void free_mpe_latlon_info ( ); void freeRadarLocMemory(); -int get_mpe_loc_latlon(char * lid, double * dlat, double * dlon); -int get_mpe_loc_latlon_list(int * arraySize, double * dlat, double * dlon); +int get_mpe_loc_latlon ( char * lid, double * dlat, double * dlon ); +int get_mpe_loc_latlon_list ( int * arraySize , + double * dlat , + double * dlon ) ; -void buildNeighborList(const geo_data_struct * pGeoData, - empe_params_struct * pMPEParams, const int gageSize, short * iug, - short * ivg, float * zg); +void buildNeighborList (const geo_data_struct * pGeoData , + empe_params_struct * pMPEParams, + const int gageSize, short * iug, + short * ivg, float * zg ) ; -void findNeighborList(const int radius, const int index_x, const int index_y, - short * arrIndex, float * arrDist, int * listNum); +void findNeighborList ( + const int radius, + const int index_x, + const int index_y, + short * arrIndex, + float * arrDist, + int * listNum ) ; -void findLocalBiasNeighborList( - const gage_radar_pair_table_struct * pGageRadarPair, const short * iug, - const short * ivg, const int radius, const int index_x, - const int index_y, short * arrIndex, float * arrDist, int * listNum); +void findLocalBiasNeighborList ( + const gage_radar_pair_table_struct * pGageRadarPair, + const short * iug, + const short * ivg, + const int radius, + const int index_x, + const int index_y, + short * arrIndex, + float * arrDist, + int * listNum ); -void find_nbrsX(const int size, short * iu, short * iv, const int iu0, - const int iv0, const int iradi, int * k, short * ilist, float * rlist, - int * iu0_prev, int * m, short * ivv, short * in); +void find_nbrsX(const int size , + short * iu , + short * iv , + const int iu0 , + const int iv0 , + const int iradi , + int * k , + short * ilist , + float * rlist , + int * iu0_prev , + int * m , + short * ivv , + short * in ) ; -void freeNeighborList(const geo_data_struct * pGeoData); +void freeNeighborList(const geo_data_struct * pGeoData) ; void createMosaic(const radarLoc_record_struct * pRadarLocRecord, - const int grid_rows, const int grid_cols, float ** radar, - short ** radarMiscBins, const geo_data_struct * pGeoData, - const int index, double ** RadarBeamHeight, double ** RMosaic, - double ** MHeight, int ** ID, double ** MaxMosaic, double ** AvgMosaic, - int ** AvgMosaicNumRadars, int * blnMosaic); + const int grid_rows, + const int grid_cols, + float ** radar , + short ** radarMiscBins, + const geo_data_struct * pGeoData , + const int index , + double ** RadarBeamHeight, + double ** RMosaic , + double ** MHeight, + int ** ID, + double ** MaxMosaic, + double ** AvgMosaic, + int ** AvgMosaicNumRadars, + int * blnMosaic); -void rfcw_load_static(const int hrap_grid_factor, int * status); +void rfcw_load_static (const int hrap_grid_factor, int * status ); void runDHRMosaic(const run_date_struct * pRunDate, - const geo_data_struct * pGeoData, empe_params_struct * pMPEParams, - const radarLoc_table_struct * pRadarLocTable, - const gage_table_struct * pGageTable, double * meanFieldBias, - double ** radar_bean_height, int ** ID, double ** DHRMosaic, - double ** QPEMosaic); + const geo_data_struct * pGeoData, + empe_params_struct * pMPEParams, + const radarLoc_table_struct * pRadarLocTable , + double * meanFieldBias, + double ** radar_bean_height, + int ** ID, + double ** DHRMosaic, + double ** QPEMosaic); -void runBDHRMosaic(const run_date_struct * pRunDate, - const geo_data_struct * pGeoData, const empe_params_struct * pMPEParams, - double * meanFieldBias, int ** ID, double ** RMosaic, - double ** QPEMosaic); +void runBDHRMosaic(const run_date_struct * pRunDate , + const geo_data_struct * pGeoData , + const empe_params_struct * pMPEParams , + double * meanFieldBias , + int ** ID , + double ** RMosaic , + double ** QPEMosaic); void createDHRMosaic(const radarLoc_record_struct * pRadarLocRecord, - const int grid_rows, const int grid_cols, float ** radar, - short ** radarMiscBins, const geo_data_struct * pGeoData, - const int index, double ** RadarBeamHeight, double ** height, int ** ID, - double ** mosaic); + const int grid_rows, + const int grid_cols, + float ** radar , + short ** radarMiscBins, + const geo_data_struct * pGeoData , + const int index , + double ** RadarBeamHeight, + double ** height, + int ** ID, + double ** mosaic); -void readDHRData(const char * radarID, const char * datetime, - const int dhr_wind, const int ignoreRadarFlag, float ** radar, - int * radarAvailFlag); +void readDHRData(const char * radarID, + const char * datetime, + const int dhr_wind, + const int ignoreRadarFlag, + float ** radar, + int * radarAvailFlag); -void readDPRData(const char * radarID, const char * datetime, - const int dhr_wind, const int ignoreRadarFlag, float ** radar, - int * radarAvailFlag); +void readDPRData(const char * radarID, + const char * datetime, + const int dhr_wind, + const int ignoreRadarFlag, + float ** radar, + int * radarAvailFlag); -void readDHRRadar(const char * radid, const char * datetime, - const int dhr_window, double * prev_bias, double * post_bias, - char * prev_filename, char * post_filename, int * prev_offset, - int * post_offset, int * status); -void readDPRRadar(const char * radid, const char * datetime, - const int dhr_window, double * prev_bias, double * post_bias, - char * prev_filename, char * post_filename, int * prev_offset, - int * post_offset, int * status); +void readDHRRadar(const char * radid, + const char * datetime, + const int dhr_window, + double * prev_bias, + double * post_bias, + char * prev_filename, + char * post_filename, + int * prev_offset, + int * post_offset, + int * status); -void readDecodedDHR(const char * filename, float ** radar, int * status); +void readDPRRadar(const char * radid, + const char * datetime, + const int dhr_window, + double * prev_bias, + double * post_bias, + char * prev_filename, + char * post_filename, + int * prev_offset, + int * post_offset, + int * status); -void readDecodedDPR(const char * filename, float ** radar, int * status); +void readDecodedDHR(const char * filename, + float ** radar , + int * status); -void readDecodedDSP(const char * filename, float ** radar, int * status); +void readDecodedDPR(const char * filename, + float ** radar, + int * status); -void readDecodedDSA(const char * filename, float ** radar, int * status); +void readDecodedDSP(const char * filename, + float ** radar, + int * status); -void readDSPRadar(const char * radid, const char * datetime, - const int dsp_window, const int dsp_duration, const int ignoreRadarFlag, - float ** radar, int * radarAvailFlag); +void readDecodedDSA(const char * filename, + float ** radar, + int * status); -void readDSARadar(const char * radid, const char * datetime, - const int dsp_window, const int dsp_duration, const int ignoreRadarFlag, - float ** radar, int * radarAvailFlag); +void readDSPRadar(const char * radid, + const char * datetime, + const int dsp_window, + const int dsp_duration, + const int ignoreRadarFlag, + float ** radar, + int * radarAvailFlag); + +void readDSARadar(const char * radid, + const char * datetime, + const int dsp_window, + const int dsp_duration, + const int ignoreRadarFlag, + float ** radar, + int * radarAvailFlag); -void loadRadarBeamHeight(double ** radar_bean_height, const int grid_rows, - const int grid_cols); +void loadRadarBeamHeight(double ** radar_bean_height, + const int grid_rows, + const int grid_cols); void writeFormattedXMRG(const empe_params_struct * pEMPEParams, - const geo_data_struct * pGeoData, const char * mosaic_dir, - const char * fname_mosaic, const char * proc_flag, - const char * save_grib_token, const char * save_gif_token, - const char * gif_dir_token, const char * gif_id_token, - const char * save_netcdf_token, const char * netcdf_dir_token, - const char * netcdf_id_token, const char * save_jpeg_token, - double ** pMosaic); + const geo_data_struct * pGeoData, + const char * mosaic_dir, + const char * fname_mosaic, + const char * proc_flag , + const char * save_grib_token, + const char * save_gif_token, + const char * gif_dir_token, + const char * gif_id_token, + const char * save_netcdf_token, + const char * netcdf_dir_token, + const char * netcdf_id_token, + const char * save_jpeg_token, + double ** pMosaic); -void read_daabiasdyn(const char *radar_id, const char *office_id, - const char * str, const int lag_cut, double *num_pairs, double *sumgag, - double *sumrad, double *bias, int *lag, char sstr1[19], long int *irc); - -void wrtodb_HPERadarResult(const char * hpe_productname, - const char * producttime, const empe_params_struct * pEMPEParams, - const int radar_data_source, const int nobias_flag); +void read_daabiasdyn(const char *radar_id, + const char *office_id, + const char * str, + const int lag_cut, + double *num_pairs, + double *sumgag, + double *sumrad, + double *bias, + int *lag, + char sstr1[19], + long int *irc); + + +void wrtodb_HPERadarResult(const char * hpe_productname, + const char * producttime, + const empe_params_struct * pEMPEParams, + const int radar_data_source, + const int nobias_flag); #endif /* #ifndef MPE_FIELDGEN_H */ diff --git a/nativeLib/rary.ohd.pproc/src/hpe_fieldgen/TEXT/main_empe_fieldgen.c b/nativeLib/rary.ohd.pproc/src/hpe_fieldgen/TEXT/main_empe_fieldgen.c index d2584d41ec..51fd529093 100644 --- a/nativeLib/rary.ohd.pproc/src/hpe_fieldgen/TEXT/main_empe_fieldgen.c +++ b/nativeLib/rary.ohd.pproc/src/hpe_fieldgen/TEXT/main_empe_fieldgen.c @@ -2,11 +2,11 @@ #include "get_empe_product_state.h" #include "p3.h" -run_date_struct * ptrRunDate; +run_date_struct * ptrRunDate ; -geo_data_struct * ptrGeoData; +geo_data_struct * ptrGeoData ; -empe_params_struct * ptrEMPEParams; +empe_params_struct * ptrEMPEParams ; gage_table_struct ** ptrGageTable; @@ -20,71 +20,72 @@ gage_table_struct ** ptrQCGageTable; radarLoc_table_struct * ptrRadarLocTable; -char * Mosaics[num_mosaics] = { "dhrmosaic", "bdhrmosaic", "ermosaic", - "avgermosaic", "maxermosaic", "gageonly", "ebmosaic", "lmosaic", - "mmosaic", "mlmosaic", "lsatpre", "p3lmosaic" }; +char * Mosaics[num_mosaics] = {"dhrmosaic", "bdhrmosaic", "ermosaic", + "avgermosaic", "maxermosaic", "gageonly", + "ebmosaic","lmosaic", "mmosaic", "mlmosaic", + "lsatpre", "p3lmosaic"}; double ** BaseRMosaic = NULL; -double ** RMosaic = NULL; +double ** RMosaic = NULL ; -double ** DHRMosaic = NULL; +double ** DHRMosaic = NULL ; -double ** BMosaic = NULL; +double ** BMosaic = NULL ; -double ** LMosaic = NULL; +double ** LMosaic = NULL ; /* * Added by Ram for the average and max mosaic calculation * structure to hold the max mosaic values throughout the program run */ -double ** MaxMosaic = NULL; +double ** MaxMosaic = NULL; /* * structure to hold the average mosaic values */ -double ** AvgMosaic = NULL; +double ** AvgMosaic = NULL; /* * structure to hold the number of radars contributed to a hrap grid bin * this will be used to calculate the average mosaic. */ -int ** AvgMosaicNumRadars = NULL; +int ** AvgMosaicNumRadars = NULL; /* * variable for the p3 lmosaic calculation */ -double ** P3Mosaic = NULL; +double ** P3Mosaic = NULL; int p3_return_value = -1; int readradartriangles_once_for_all_hours = 0; -int ** ID = NULL; +int ** ID = NULL ; /* This two dimensional array hold the "best estimate" mosaic */ -double ** QPEMosaic = NULL; +double ** QPEMosaic = NULL ; -/* prism data */ + /* prism data */ -double ** umeang = NULL; +double ** umeang = NULL ; -/* radar bean height data */ + /* radar bean height data */ -double ** RadarBeamHeight = NULL; +double ** RadarBeamHeight = NULL ; -short ** radarMiscBins = NULL; +short ** radarMiscBins = NULL ; /* The local bias satellite precipitation array. */ -double ** LSatpre = NULL; +double ** LSatpre = NULL ; /* mean field bias array */ -double * meanFieldBias = NULL; +double * meanFieldBias = NULL ; extern void free_tr(); @@ -93,25 +94,28 @@ extern void free_tr(); int dualpol_on_flag = 1; int dualpol_used = 0; -int hpe_fieldgen_main(int argc, const char ** argv) { +int hpe_fieldgen_main(int argc, const char ** argv) +{ enum DisplayFieldData radar_display_type = display_erMosaic; mosaicType indexMosaic; mosaicType indexBaseRadar = ermosaic; int i, j, k, status; int blnMosaic[num_mosaics]; - int blnGetPrism = 0; + int blnGetPrism = 0 ; time_t tmpTime, start_time, end_time; - static char strTempTime[50] = { '\0' }; - int flag, mosaicLength; + static char strTempTime[50] = {'\0'} ; + int flag , mosaicLength ; int radar_processed; int empe_base_radar_len = BESTFIELD_LEN; - int verbose = VERBOSE; - char cemr[3] = { '\0' }; /* char month of run */ - struct tm * pRunTime = NULL; - char datetime[ANSI_YEARSEC_TIME_LEN + 1] = { '\0' }; - int blnOverwrite = 1; /* 0 = overwrite best xmrg; 1 = don't overwrite */ - char tokenvalue[TOKEN_VALUE_LEN] = { '\0' }; + int verbose = VERBOSE ; + char cemr[3] = {'\0'} ; /* char month of run */ + struct tm * pRunTime = NULL ; + char datetime[ANSI_YEARSEC_TIME_LEN + 1] = {'\0'} ; + int blnOverwrite = 1 ; /* 0 = overwrite best xmrg; 1 = don't overwrite */ + + const char * HPE_DUALPOL_ON_TOKEN = "hpe_dualpol_on"; + char dualpol_on[TOKEN_LEN] = {'\0'}; short * iug = NULL; short * ivg = NULL; float * zg = NULL; @@ -125,25 +129,33 @@ int hpe_fieldgen_main(int argc, const char ** argv) { ptrRunDate = NULL; ptrGeoData = NULL; ptrEMPEParams = NULL; - ptrRadarLocTable = NULL; - ptrGageTable = NULL; - ptrGageTableP3 = NULL; - ptrQCGageTable = NULL; + ptrRadarLocTable = NULL ; + ptrGageTable = NULL ; + ptrGageTableP3 = NULL ; + ptrQCGageTable = NULL ; - time(&start_time); + /* determin if dual pol product can be retrived */ + + getAppsDefaults(HPE_DUALPOL_ON_TOKEN, dualpol_on); + if (strcmp(toLowerCase(dualpol_on), "yes") != 0 ) + dualpol_on_flag = 0; + else + dualpol_on_flag = 1; + + time(&start_time); /* * allocates memory for global struct data and initialization. */ - hpe_fieldgen_constructor(); + hpe_fieldgen_constructor() ; /* * Verify the argument list * and parse the values into variable ptrRunDate. */ - hpe_fieldgen_parseArgs(argc, argv, ptrRunDate); + hpe_fieldgen_parseArgs(argc, argv, ptrRunDate) ; /* * open the log file. @@ -153,77 +165,97 @@ int hpe_fieldgen_main(int argc, const char ** argv) { time(&tmpTime); strftime(strTempTime, 50, "%Y-%m-%d %X %Z", gmtime(&tmpTime)); - sprintf(message, "\n\n\tHPE Precip Processing -- %s\n", strTempTime); + sprintf ( message , "\n\n\tHPE Precip Processing -- %s\n", strTempTime) ; printLogMessage(message); - sprintf(message, "\t\tVersion OB16.2.1 -- August 08, 2015 \n"); - printMessage(message, logFile); + sprintf ( message , "\t\tVersion OB14.3.1 -- March 08, 2014 \n") ; + printMessage( message, logFile ); + +/* + sprintf( message , "STATUS: HPE Fieldgen is running for %d hour(s)\n", + ptrRunDate->hourNum) ; + printMessage( message); +*/ /* * retrieve the value of the base radar product. */ - get_empe_base_radar(&verbose, ptrEMPEParams->base_radar_mosaic, - &empe_base_radar_len, &status); + get_empe_base_radar ( &verbose, ptrEMPEParams->base_radar_mosaic, + &empe_base_radar_len, &status ); - if (status != 0) { - sprintf(message, "Error occurred when retrieving base radar " - "mosaic.\n\tProgram Exit."); - shutdown(message); + if ( status != 0 ) + { + sprintf ( message, "Error occurred when retrieving base radar " + "mosaic.\n\tProgram Exit." ); + shutdown( message ); } hpe_fieldgen_toLowerCase(ptrEMPEParams->base_radar_mosaic); - if (strcmp(ptrEMPEParams->base_radar_mosaic, "ermosaic") == 0) { + if ( strcmp ( ptrEMPEParams->base_radar_mosaic, "ermosaic" ) == 0 ) + { indexBaseRadar = ermosaic; radar_display_type = display_erMosaic; - } else if (strcmp(ptrEMPEParams->base_radar_mosaic, "avgermosaic") == 0) { + } + else if ( strcmp ( ptrEMPEParams->base_radar_mosaic, "avgermosaic" ) == 0 ) + { indexBaseRadar = avgermosaic; radar_display_type = display_avgerMosaic; - } else if (strcmp(ptrEMPEParams->base_radar_mosaic, "maxermosaic") == 0) { + } + else if ( strcmp ( ptrEMPEParams->base_radar_mosaic, "maxermosaic" ) == 0 ) + { indexBaseRadar = maxermosaic; radar_display_type = display_maxerMosaic; - } else { - sprintf(message, "Error: Unrecognized base radar mosaic %s.\n" - "\tProgram Exit.", ptrEMPEParams->base_radar_mosaic); - shutdown(message); + } + else + { + sprintf ( message, "Error: Unrecognized base radar mosaic %s.\n" + "\tProgram Exit.", + ptrEMPEParams->base_radar_mosaic ); + shutdown( message ); } - sprintf(message, "STATUS: Using %s as the base radar mosaic...", - ptrEMPEParams->base_radar_mosaic); - hpe_fieldgen_printMessage(message); + sprintf ( message, "STATUS: Using %s as the base radar mosaic...", + ptrEMPEParams->base_radar_mosaic ); + hpe_fieldgen_printMessage( message ); /* * read status for qpe generate types. * and flag indicates if need calculate mean field bias. */ - sprintf(message, "STATUS: loading qpe generate types..."); - hpe_fieldgen_printMessage(message); + sprintf( message , "STATUS: loading qpe generate types...") ; + hpe_fieldgen_printMessage( message); ptrEMPEParams->blnMeanFieldBias = 0; ptrEMPEParams->blnDHRMeanFieldBias = 0; - for (indexMosaic = dhrmosaic; indexMosaic < num_mosaics; indexMosaic++) { + for( indexMosaic = dhrmosaic; indexMosaic < num_mosaics; indexMosaic++) + { blnMosaic[indexMosaic] = 0; - mosaicLength = strlen(Mosaics[indexMosaic]); - get_empe_product_state(Mosaics[indexMosaic], &mosaicLength, &verbose, - &flag, &status); - if (status != 0) { - sprintf(message, "Error(s) occur when set generate type: %s." - "\n\tProgram exit.", Mosaics[indexMosaic]); - shutdown(message); + mosaicLength = strlen(Mosaics[indexMosaic]) ; + get_empe_product_state(Mosaics[indexMosaic], &mosaicLength, + &verbose, &flag, &status); + if(status != 0) + { + sprintf ( message , "Error(s) occur when set generate type: %s." + "\n\tProgram exit." , Mosaics[indexMosaic]) ; + shutdown( message ); } - blnMosaic[indexMosaic] = flag; + blnMosaic[indexMosaic] = flag ; - if (blnMosaic[indexMosaic] == 1) { - sprintf(message, "\tgenerate type: \"%s\" is set \"ON\" ", - Mosaics[indexMosaic]); - hpe_fieldgen_printMessage(message); - } else { - sprintf(message, "\tgenerate type: \"%s\" is set \"OFF\" ", - Mosaics[indexMosaic]); - hpe_fieldgen_printMessage(message); + if(blnMosaic[indexMosaic] == 1) + { + sprintf ( message , "\tgenerate type: \"%s\" is set \"ON\" ", + Mosaics[indexMosaic]) ; + hpe_fieldgen_printMessage( message); + } + else + { + sprintf ( message , "\tgenerate type: \"%s\" is set \"OFF\" ", + Mosaics[indexMosaic]) ; + hpe_fieldgen_printMessage( message); } /* @@ -231,7 +263,9 @@ int hpe_fieldgen_main(int argc, const char ** argv) { * when ebmosaic or mmosaic is ON */ - if ((indexMosaic == ebmosaic) && blnMosaic[indexMosaic] == 1) { + if((indexMosaic == ebmosaic) + && blnMosaic[indexMosaic] == 1) + { ptrEMPEParams->blnMeanFieldBias = 1; } @@ -240,7 +274,9 @@ int hpe_fieldgen_main(int argc, const char ** argv) { * when bdhrmosaic is ON */ - if ((indexMosaic == bdhrmosaic) && blnMosaic[indexMosaic] == 1) { + if((indexMosaic == bdhrmosaic) + && blnMosaic[indexMosaic] == 1) + { blnMosaic[dhrmosaic] = 1; ptrEMPEParams->blnDHRMeanFieldBias = 1; } @@ -250,8 +286,10 @@ int hpe_fieldgen_main(int argc, const char ** argv) { * when mmosiac or mlmosaic or gageonly is ON */ - if ((indexMosaic == mmosaic || indexMosaic == mlmosaic - || indexMosaic == gaugeonly) && blnMosaic[indexMosaic] == 1) + if((indexMosaic == mmosaic || + indexMosaic == mlmosaic || + indexMosaic == gaugeonly ) + && blnMosaic[indexMosaic] == 1) blnGetPrism = 1; } @@ -260,67 +298,30 @@ int hpe_fieldgen_main(int argc, const char ** argv) { * which are determined by the run time data. */ - hpe_fieldgen_constructorByRunTime(); + hpe_fieldgen_constructorByRunTime() ; /* * read in static parameters from Apps_defaults files. */ - readParams(ptrEMPEParams); - - /* - * print out dualPol bias info - */ - - if (hpe_fieldgen_getAppsDefaults("hpe_dualpol_on", tokenvalue) == -1) { - /* default to Yes */ - dualpol_on_flag = 1; - sprintf(message, "\tDefault HPE dualPol radar product flag = ON"); - hpe_fieldgen_printMessage(message); - } else { - if (strcmp(toLowerCase(tokenvalue), "yes") != 0) { - dualpol_on_flag = 0; - sprintf(message, "\tHPE dualPol radar product flag = OFF"); - hpe_fieldgen_printMessage(message); - } else { - dualpol_on_flag = 1; - sprintf(message, "\tHPE dualPol radar product flag = ON"); - hpe_fieldgen_printMessage(message); - } - } - if (hpe_fieldgen_getAppsDefaults("hpe_bias_source", tokenvalue) == -1) { - /* default to RFC*/ - sprintf(message, "\tDefault HPE Bias Source = RFC"); - hpe_fieldgen_printMessage(message); - } else { - sprintf(message, "\tHPE Bias Source = %s", tokenvalue); - hpe_fieldgen_printMessage(message); - } - - if (hpe_fieldgen_getAppsDefaults("hpe_rfc_bias_flag", tokenvalue) == -1) { - /* default to 2 minutes*/ - sprintf(message, "\tDefault HPE RFC bias flag = 2"); - hpe_fieldgen_printMessage(message); - } else { - sprintf(message, "\tHPE RFC bias flag = %s", tokenvalue); - hpe_fieldgen_printMessage(message); - } + readParams(ptrEMPEParams) ; /* * read in geo grid data. */ - readGeoData(ptrEMPEParams->hrap_grid_factor, ptrGeoData); + readGeoData(ptrEMPEParams->hrap_grid_factor, ptrGeoData) ; /* * read in the overlays */ - rfcw_load_static(ptrEMPEParams->hrap_grid_factor, &status); + rfcw_load_static (ptrEMPEParams->hrap_grid_factor, & status ); - if (status != 0) { - sprintf(message, "Error occurred when reading overlay data.\n"); - hpe_fieldgen_printMessage(message); + if ( status != 0 ) + { + sprintf ( message, "Error occurred when reading overlay data.\n" ); + hpe_fieldgen_printMessage( message ); } ptrEMPEParams->irc_load_stat = status; @@ -329,30 +330,31 @@ int hpe_fieldgen_main(int argc, const char ** argv) { * which are determined by the geographic grid data. */ - hpe_fieldgen_constructorByGeodata(blnMosaic); + hpe_fieldgen_constructorByGeodata(blnMosaic) ; /* * Open the database. */ - if ((status = OpenDbms(ptrEMPEParams->db_name)) != 0) { - sprintf(message, "Error(s) occur during opening database %s." - " SQLCODE: %ld\n\tProgram exit.", ptrEMPEParams->db_name, - SQLCODE); - shutdown(message); + if ( (status = OpenDbms ( ptrEMPEParams->db_name )) != 0 ) + { + sprintf ( message , "Error(s) occur during opening database %s." + " SQLCODE: %ld\n\tProgram exit.", + ptrEMPEParams->db_name , SQLCODE ) ; + shutdown( message ); } /* - * read static parameters from database for running hpe_fieldgen. + * read static parameters from database for running mpe_fieldgen. */ - readDBParams(ptrEMPEParams); + readDBParams(ptrEMPEParams) ; /* * write static data to log file. */ - writeParams(ptrEMPEParams); + writeParams(ptrEMPEParams) ; /* * read in gage data for entire area and whole time range @@ -362,13 +364,16 @@ int hpe_fieldgen_main(int argc, const char ** argv) { pRunTime = gmtime(&(ptrRunDate->tRunTime)); - if ((ptrEMPEParams->dsp_duration == 60) && (pRunTime->tm_min == 0)) { + if( (ptrEMPEParams->dsp_duration == 60) && + (pRunTime->tm_min == 0) ) + { isTopHour = 1; } - if (isTopHour == 1) { - readGageData(ptrRunDate, ptrEMPEParams, ptrGeoData, ptrGageTable, - ptrGageTableP3, ptrQCGageTable); + if(isTopHour == 1) + { + readGageData(ptrRunDate, ptrEMPEParams, ptrGeoData, + ptrGageTable, ptrGageTableP3, ptrQCGageTable); } /* @@ -376,21 +381,20 @@ int hpe_fieldgen_main(int argc, const char ** argv) { * store in radarloc struct variable */ - readRadarLoc(ptrRadarLocTable); + readRadarLoc(ptrRadarLocTable) ; /* * allocate memory and Initialize the mean bias struct data * which is determined by the radarLoc number. */ - constructorForMeanBias(ptrRadarLocTable->radarNum); + constructorForMeanBias(ptrRadarLocTable->radarNum) ; /* * build the category name based on dsp_duration */ - buildCategoryName(ptrEMPEParams->dsp_duration, - ptrEMPEParams->category_name); + buildCategoryName(ptrEMPEParams->dsp_duration, ptrEMPEParams->category_name); /* * for multiple hours case: @@ -405,48 +409,51 @@ int hpe_fieldgen_main(int argc, const char ** argv) { */ loadRadarBeamHeight(RadarBeamHeight, - NUM_DPA_ROWS * ptrEMPEParams->hrap_grid_factor, - NUM_DPA_COLS * ptrEMPEParams->hrap_grid_factor); + NUM_DPA_ROWS * ptrEMPEParams->hrap_grid_factor, + NUM_DPA_COLS * ptrEMPEParams->hrap_grid_factor); - for (i = 0; i < ptrRunDate->hourNum; i++) { + for( i = 0; i < ptrRunDate->hourNum; i++) + { radar_processed = 0; ptrEMPEParams->sat_avail = 0; - ptrEMPEParams->build_neighbor_list = 0; + ptrEMPEParams->build_neighbor_list = 0 ; - gageSize = ptrGageTable[i]->totalGageNum; - gageSizeP3 = ptrGageTableP3[i]->totalGageNum; + gageSize = ptrGageTable[i]->totalGageNum ; + gageSizeP3 = ptrGageTableP3[i]->totalGageNum ; - if (isTopHour == 1) { + if( isTopHour == 1 ) + { iug = init1DShortArray(ZERO_CONSTANT, gageSize); ivg = init1DShortArray(ZERO_CONSTANT, gageSize); - zg = init1DFloatArray(MOSAIC_DEFAULT, gageSize); + zg = init1DFloatArray(MOSAIC_DEFAULT, gageSize); - for (j = 0; j < gageSize; j++) { - iug[j] = ptrGageTable[i]->ptrGageRecords[j].hrap_x; - ivg[j] = ptrGageTable[i]->ptrGageRecords[j].hrap_y; - zg[j] = ptrGageTable[i]->ptrGageRecords[j].gageValue; + for(j = 0; j < gageSize; j ++) + { + iug[j] = ptrGageTable[i]->ptrGageRecords[j].hrap_x ; + ivg[j] = ptrGageTable[i]->ptrGageRecords[j].hrap_y ; + zg[j] = ptrGageTable[i]->ptrGageRecords[j].gageValue ; } } pRunTime = gmtime(&(ptrRunDate->tRunTime)); sprintf(cemr, "%02d", (pRunTime->tm_mon + 1)); - strftime(datetime, ANSI_YEARSEC_TIME_LEN + 1, "%Y-%m-%d %H:%M:00", - pRunTime); + strftime ( datetime, ANSI_YEARSEC_TIME_LEN + 1, + "%Y-%m-%d %H:%M:00", pRunTime ) ; - hpe_fieldgen_getCurrentTime(currTime); - sprintf(message, - "\n%s = time begin HPE fieldgen MOSAIC generation for: %s.", - currTime, datetime); - hpe_fieldgen_printMessage(message); + hpe_fieldgen_getCurrentTime(currTime) ; + sprintf( message , "\n%s = time begin HPE fieldgen MOSAIC generation for: %s." , + currTime, datetime) ; + hpe_fieldgen_printMessage( message); /* * read in prism data if required. */ - if (blnGetPrism == 1) { - get_climate(ptrEMPEParams->os, ptrGeoData->num_rows, - ptrGeoData->num_cols, cemr, umeang); + if(blnGetPrism == 1) + { + get_climate(ptrEMPEParams->os , ptrGeoData->num_rows, + ptrGeoData->num_cols, cemr, umeang) ; } /* @@ -457,8 +464,25 @@ int hpe_fieldgen_main(int argc, const char ** argv) { int irfclen = strlen(ptrEMPEParams->rfc_name); int idatelen = strlen(datetime); - check_autosave(ptrEMPEParams->rfc_name, &irfclen, datetime, &idatelen, - &blnOverwrite); + check_autosave(ptrEMPEParams->rfc_name, &irfclen, + datetime, &idatelen, &blnOverwrite) ; + + /* + * load the mean bias data for each radar ID + * if need compute ebmosaic and/or bdhrmosaic. + */ + +/* if( (ptrEMPEParams->blnDHRMeanFieldBias == 1) || + (ptrEMPEParams->blnMeanFieldBias == 1) )*/ + + /*if (ptrEMPEParams->blnDHRMeanFieldBias == 1) + { + readMeanBias(ptrRunDate, + ptrRadarLocTable, + ptrEMPEParams, + meanFieldBias ); + + }*/ /* * run mosaic functions based on mosaic status value. @@ -472,161 +496,310 @@ int hpe_fieldgen_main(int argc, const char ** argv) { * -- gzhou 09/2007 */ - for (indexMosaic = dhrmosaic; indexMosaic < num_mosaics; - indexMosaic++) { - if (blnMosaic[indexMosaic] == 0) { + for( indexMosaic = dhrmosaic; indexMosaic < num_mosaics; indexMosaic++) + { + if(blnMosaic[indexMosaic] == 0) + { continue; } - switch (indexMosaic) { - case dhrmosaic: - runDHRMosaic(ptrRunDate, ptrGeoData, ptrEMPEParams, - ptrRadarLocTable, ptrGageTable[i], meanFieldBias, - RadarBeamHeight, ID, DHRMosaic, QPEMosaic); - break; + switch(indexMosaic) + { + case dhrmosaic : + runDHRMosaic(ptrRunDate, + ptrGeoData, + ptrEMPEParams, + ptrRadarLocTable, + meanFieldBias, + RadarBeamHeight, + ID, + DHRMosaic, + QPEMosaic) ; + break ; - case bdhrmosaic: - runBDHRMosaic(ptrRunDate, ptrGeoData, ptrEMPEParams, - meanFieldBias, ID, DHRMosaic, QPEMosaic); - break; + case bdhrmosaic : + runBDHRMosaic(ptrRunDate, + ptrGeoData, + ptrEMPEParams, + meanFieldBias, + ID, + DHRMosaic, + QPEMosaic) ; + break ; - case avgermosaic: - case maxermosaic: - case ermosaic: - if (radar_processed == 0) { - runERMosaic(ptrRunDate, ptrGeoData, ptrEMPEParams, - ptrRadarLocTable, ptrGageTable[i], - ptrGageTableP3[i], ptrQCGageTable[i], meanFieldBias, - RadarBeamHeight, ID, RMosaic, QPEMosaic, blnMosaic); + case avgermosaic: + case maxermosaic: + case ermosaic : + if ( radar_processed == 0 ) + { + runERMosaic(ptrRunDate, + ptrGeoData, + ptrEMPEParams, + ptrRadarLocTable, + ptrGageTable[i], + ptrGageTableP3[i], + ptrQCGageTable[i], + meanFieldBias, + RadarBeamHeight, + ID, + RMosaic, + QPEMosaic, + blnMosaic) ; - /* - * Assign the base radar mosaic. This radar mosaic - * will be used as the base for all of the radar - * derived MPE products. - */ + /* + * Assign the base radar mosaic. This radar mosaic + * will be used as the base for all of the radar + * derived MPE products. + */ - switch (indexBaseRadar) { - case ermosaic: - BaseRMosaic = RMosaic; - break; + switch ( indexBaseRadar ) + { + case ermosaic: + BaseRMosaic = RMosaic; + break; - case avgermosaic: - BaseRMosaic = AvgMosaic; - break; + case avgermosaic: + BaseRMosaic = AvgMosaic; + break; - case maxermosaic: - BaseRMosaic = MaxMosaic; - break; + case maxermosaic: + BaseRMosaic = MaxMosaic; + break; - default: - sprintf(message, "Error: Unrecognized base " - "radar mosaic index.\n\t" - "Program Exit."); - shutdown(message); - break; + default: + sprintf ( message, "Error: Unrecognized base " + "radar mosaic index.\n\t" + "Program Exit." ); + shutdown ( message ); + break; + } + + /* + * delete zero gage values where radar says that + * it is raining note that this will delete good + * gage values in ap and virga but most of the + * time will delete bad values + */ + + if( ptrEMPEParams->del_gage_zeros == 1 ) + { + deleteZeros( &gageSize, iug, ivg, zg, + BaseRMosaic) ; + } } + radar_processed = 1; + break ; + + case ebmosaic : + runEBMosaic(ptrRunDate, + ptrGeoData, + ptrEMPEParams, + meanFieldBias, + ID, + BaseRMosaic, + BMosaic, + QPEMosaic) ; + break ; + + case p3lmosaic : + sprintf ( message , "STATUS: P3LMosaic product is " + "not available for current version."); + hpe_fieldgen_printMessage( message); + +/* + p3_return_value = runP3LMosaic ( ptrRunDate, + ptrEMPEParams, + ptrRadarLocTable, + ptrGageTableP3[i], + ptrGeoData, + radar_display_type, + P3Mosaic, + BaseRMosaic, + QPEMosaic); + + if(p3_return_value == -1) + { + sprintf ( message , "oops!...Problem calculating P3" + " Mosaic..." + " seems like there is no gage data\n"); + printMessage( message); + } + readradartriangles_once_for_all_hours = 1; +*/ + break; + + case gaugeonly : + /* - * delete zero gage values where radar says that - * it is raining note that this will delete good - * gage values in ap and virga but most of the - * time will delete bad values + * The gageonly can be calculated + * only when the DSP duration is 60 minutes and + * the run time is the top of the hour. */ - if (ptrEMPEParams->del_gage_zeros == 1) { - deleteZeros(&gageSize, iug, ivg, zg, BaseRMosaic); + sprintf ( message , "STATUS: Gageonly product is " + "not available for current version."); + hpe_fieldgen_printMessage( message); +/* + if( isTopHour == 1 ) + { + runGageonly(ptrRunDate, + ptrGeoData, + ptrEMPEParams, + gageSize, iug, ivg, zg, + umeang, + QPEMosaic) ; } - } + else + { + sprintf ( message , "STATUS: Gageonly could not be " + "calculated due to " + "it is at non-top hour or " + "DSP duration is not 60 minutes."); + printMessage( message); + } +*/ + break ; - radar_processed = 1; - break; + case lmosaic : - case ebmosaic: - runEBMosaic(ptrRunDate, ptrGeoData, ptrEMPEParams, - meanFieldBias, ID, BaseRMosaic, BMosaic, QPEMosaic); - break; + /* + * The lmosaic can be calculated + * only when the DSP duration is 60 minutes and + * the run time is the top of the hour. + */ - case p3lmosaic: - sprintf(message, "STATUS: P3LMosaic product is " - "not available for current version."); - hpe_fieldgen_printMessage(message); + sprintf ( message , "STATUS: LMosaic product is " + "not available for current version."); + hpe_fieldgen_printMessage( message); +/* + if( isTopHour == 1 ) + { + runLMosaic( ptrRunDate, + ptrGeoData, + ptrEMPEParams, + gageSize, iug, ivg, zg, + BaseRMosaic, + LMosaic, + QPEMosaic) ; + } + else + { + sprintf ( message , "STATUS: LMosaic could not be " + "calculated due to " + "it is at non-top hour or " + "DSP duration is not 60 minutes."); + printMessage( message); + } +*/ + break ; - break; + case mmosaic : - case gaugeonly: + /* + * The mmosaic can be calculated + * only when the DSP duration is 60 minutes and + * the run time is the top of the hour. + */ - /* - * The gageonly can be calculated - * only when the DSP duration is 60 minutes and - * the run time is the top of the hour. - */ + sprintf ( message , "STATUS: MMosaic product is " + "not available for current version."); + hpe_fieldgen_printMessage( message); +/* + if( isTopHour == 1 ) + { + runMMosaic(ptrRunDate, + ptrGeoData, + ptrEMPEParams, + gageSize, iug, ivg, zg, + ID, + BaseRMosaic , + BMosaic , + umeang , + QPEMosaic) ; + } + else + { + sprintf ( message , "STATUS: MMosaic could not be " + "calculated due to " + "it is at non-top hour or " + "DSP duration is not 60 minutes."); + printMessage( message); + } +*/ + break ; - sprintf(message, "STATUS: Gageonly product is " - "not available for current version."); - hpe_fieldgen_printMessage(message); + case mlmosaic : - break; + /* + * The mlmosaic can be calculated + * only when the DSP duration is 60 minutes and + * the run time is the top of the hour. + */ - case lmosaic: + sprintf ( message , "STATUS: MLMosaic product is " + "not available for current version."); + hpe_fieldgen_printMessage( message); +/* + if( isTopHour == 1 ) + { + runMLMosaic( ptrRunDate, + ptrGeoData, + ptrEMPEParams, + gageSize, iug, ivg, zg, + ID, + BaseRMosaic , + LMosaic , + umeang , + QPEMosaic) ; + } + else + { + sprintf ( message , "STATUS: MLMosaic could not be " + "calculated due to " + "it is at non-top hour or " + "DSP duration is not 60 minutes."); + printMessage( message); + } +*/ + break ; - /* - * The lmosaic can be calculated - * only when the DSP duration is 60 minutes and - * the run time is the top of the hour. - */ + case lsatpre : - sprintf(message, "STATUS: LMosaic product is " - "not available for current version."); - hpe_fieldgen_printMessage(message); + /* + * The lsatpre can be calculated + * only when the DSP duration is 60 minutes and + * the run time is the top of the hour. + */ - break; + sprintf ( message , "STATUS: LSatpre product is " + "not available for current version."); + hpe_fieldgen_printMessage( message); +/* + if( isTopHour == 1 ) + { + runLSatpre ( ptrRunDate, + ptrGeoData, + ptrEMPEParams, + gageSize, iug, ivg, zg, + BaseRMosaic, + LSatpre, + QPEMosaic ); + } + else + { + sprintf ( message , "STATUS: LSatpre could not be " + "calculated due to " + "it is at non-top hour or " + "DSP duration is not 60 minutes."); + printMessage( message); + } +*/ + break ; - case mmosaic: - - /* - * The mmosaic can be calculated - * only when the DSP duration is 60 minutes and - * the run time is the top of the hour. - */ - - sprintf(message, "STATUS: MMosaic product is " - "not available for current version."); - hpe_fieldgen_printMessage(message); - - break; - - case mlmosaic: - - /* - * The mlmosaic can be calculated - * only when the DSP duration is 60 minutes and - * the run time is the top of the hour. - */ - - sprintf(message, "STATUS: MLMosaic product is " - "not available for current version."); - hpe_fieldgen_printMessage(message); - - break; - - case lsatpre: - - /* - * The lsatpre can be calculated - * only when the DSP duration is 60 minutes and - * the run time is the top of the hour. - */ - - sprintf(message, "STATUS: LSatpre product is " - "not available for current version."); - hpe_fieldgen_printMessage(message); - - break; - - default: - sprintf(message, "ERROR: Unknown mosaic type!"); - hpe_fieldgen_printMessage(message); - break; + default: + sprintf ( message , "ERROR: Unknown mosaic type!"); + hpe_fieldgen_printMessage( message); } } @@ -638,23 +811,24 @@ int hpe_fieldgen_main(int argc, const char ** argv) { * -- gzhou 05-2007 */ - blnOverwrite = 1; - if (blnOverwrite == 0) { - writeQPE(ptrRunDate, ptrEMPEParams, ptrGeoData, - ptrGageTable[i]->totalGageNum, - ptrGageTableP3[i]->totalGageNum, QPEMosaic); + blnOverwrite = 1 ; + if( blnOverwrite == 0) + { + writeQPE(ptrRunDate, ptrEMPEParams, ptrGeoData , + ptrGageTable[i]->totalGageNum, + ptrGageTableP3[i]->totalGageNum, QPEMosaic ) ; } - hpe_fieldgen_getCurrentTime(currTime); - sprintf(message, - "%s = time end HPE Fieldgen MOSAIC generation for: %s.\n", - currTime, datetime); - hpe_fieldgen_printMessage(message); + hpe_fieldgen_getCurrentTime(currTime) ; + sprintf( message , "%s = time end HPE Fieldgen MOSAIC generation for: %s.\n" , + currTime, datetime) ; + hpe_fieldgen_printMessage( message); - if (isTopHour == 1) { - free1DShortArray(iug); - free1DShortArray(ivg); - free1DFloatArray(zg); + if( isTopHour == 1 ) + { + free1DShortArray( iug ); + free1DShortArray( ivg ); + free1DFloatArray( zg ); } /* @@ -671,19 +845,20 @@ int hpe_fieldgen_main(int argc, const char ** argv) { * releases memory for global struct data. */ - hpe_fieldgen_destructor(); + hpe_fieldgen_destructor() ; time(&end_time); - sprintf(message, "STATUS: Program exit normally" - " with elapse time: %ld second(s)", (end_time - start_time)); - hpe_fieldgen_printMessage(message); + sprintf ( message , "STATUS: Program exit normally" + " with elapse time: %ld second(s)", + (end_time - start_time)); + hpe_fieldgen_printMessage( message); /* * close db connection and free memory of global variables. */ - hpeDeleteLogFile(); + hpeDeleteLogFile ( ); CloseDbms(); exit(0); diff --git a/nativeLib/rary.ohd.pproc/src/hpe_fieldgen/TEXT/read_rwbiasdyn2.c b/nativeLib/rary.ohd.pproc/src/hpe_fieldgen/TEXT/read_rwbiasdyn2.c index b8e257dcbd..31999e6ea2 100644 --- a/nativeLib/rary.ohd.pproc/src/hpe_fieldgen/TEXT/read_rwbiasdyn2.c +++ b/nativeLib/rary.ohd.pproc/src/hpe_fieldgen/TEXT/read_rwbiasdyn2.c @@ -6,30 +6,48 @@ #include "RadarLoc.h" #define HPE_RFC_BIAS_LAG 2 // default number of bias lag hours -RadarLoc * pRadarLocHead = NULL; + +RadarLoc * pRadarLocHead = NULL ; extern int dualpol_on_flag; -void retrieveOfficeIDByRadarID(const char * radarID, char * officeID, - long int * status); +void retrieveOfficeIDByRadarID(const char * radarID, + char * officeID, + long int * status); -void read_rwbiasdyn2(const char *radar_id, const char *office_id, - const char * str, const int lag_cut, double *num_pairs, double *sumgag, - double *sumrad, double *bias, int *lag, char sstr1[19], long int *irc); +void read_rwbiasdyn2(const char *radar_id, + const char *office_id, + const char * str, + const int lag_cut, + double *num_pairs, + double *sumgag, + double *sumrad, + double *bias, + int *lag, + char sstr1[19], + long int *irc); -void readRWBiasDyn(const char *radar_id, const char *site_id, - const char *datehour, const int lag_cut, double *num_pairs, - double *sumgag, double *sumrad, double *bias, int *lag, - char datetime1[19], int dualpol_data_avail, long int *irc) +void readRWBiasDyn(const char *radar_id, + const char *site_id, + const char *datehour, + const int lag_cut, + double *num_pairs, + double *sumgag, + double *sumrad, + double *bias, + int *lag, + char datetime1[19], + int dualpol_data_avail, + long int *irc) { - const char * HPE_RFC_BIAS_LAG_TOKEN = "hpe_rfc_bias_lag"; - const char * HPE_BIAS_SOURCE_TOKEN = "hpe_bias_source"; + const char * HPE_RFC_BIAS_LAG_TOKEN = "hpe_rfc_bias_lag"; + const char * HPE_BIAS_SOURCE_TOKEN = "hpe_bias_source"; - static int first = 1; + static int first = 1 ; static int rfc_bias_lag = HPE_RFC_BIAS_LAG; - static char bias_source[6] = "rfc"; // RFC or LOCAL, default to RFC - char officeID[WFO_LEN + 1] = { '\0' }; - char strTokenValue[6] = { '\0' }; + static char bias_source[6] = "rfc"; // RFC or LOCAL, default to RFC + char officeID[WFO_LEN + 1] = {'\0'}; + char strTokenValue[6] = {'\0'} ; /* * load and store the token values: @@ -37,103 +55,138 @@ void readRWBiasDyn(const char *radar_id, const char *site_id, * HPE_BIAS_SOURCE_TOKEN */ - if (first == 1) { - if ((hpe_fieldgen_getAppsDefaults(HPE_RFC_BIAS_LAG_TOKEN, strTokenValue) - != -1) && (hpe_fieldgen_isDigits(strTokenValue) == 1)) { + if(first == 1) + { + if((hpe_fieldgen_getAppsDefaults(HPE_RFC_BIAS_LAG_TOKEN, strTokenValue) != -1) + && (hpe_fieldgen_isDigits(strTokenValue) == 1)) + { int value = atoi(strTokenValue); - - if (value > 0) { + if(value > 0) + { rfc_bias_lag = value; - sprintf(message, - "STATUS:in readRWBiasDyn - token value for \"%s\" is: %d", - HPE_RFC_BIAS_LAG_TOKEN, rfc_bias_lag); - hpe_fieldgen_printMessage(message); - } else { - sprintf(message, "ERROR:in readRWBiasDyn - Invalid token value" - " for token \"%s\". Default value is set to: %d", - HPE_RFC_BIAS_LAG_TOKEN, HPE_RFC_BIAS_LAG); - hpe_fieldgen_printMessage(message); + sprintf ( message , "STATUS: token value for \"%s\" is: %d.", + HPE_RFC_BIAS_LAG_TOKEN, rfc_bias_lag) ; + hpe_fieldgen_printMessage( message ); } - } else { - sprintf(message, "ERROR:in readRWBiasDyn - Invalid token value" - " for token \"%s\". Default value is set to: %d", - HPE_RFC_BIAS_LAG_TOKEN, HPE_RFC_BIAS_LAG); - hpe_fieldgen_printMessage(message); + else + { + sprintf ( message , "ERROR: Invalid token value" + " for token \"%s\". Default it's value to: %d.", + HPE_RFC_BIAS_LAG_TOKEN, HPE_RFC_BIAS_LAG) ; + hpe_fieldgen_printMessage( message ); + } + } + else + { + sprintf ( message , "ERROR: Invalid token value" + " for token \"%s\". Default it's value to: %d.", + HPE_RFC_BIAS_LAG_TOKEN, HPE_RFC_BIAS_LAG) ; + hpe_fieldgen_printMessage( message ); } - if (hpe_fieldgen_getAppsDefaults(HPE_BIAS_SOURCE_TOKEN, strTokenValue) - != -1) { - if (strcmp(hpe_fieldgen_toLowerCase(strTokenValue), "local") == 0) { + if(hpe_fieldgen_getAppsDefaults(HPE_BIAS_SOURCE_TOKEN, strTokenValue) != -1) + { + if(strcmp(hpe_fieldgen_toLowerCase(strTokenValue), "local") == 0) + { strcpy(bias_source, "local"); - sprintf(message, - "STATUS:in readRWBiasDyn - token value for \"%s\" is: %s", - HPE_BIAS_SOURCE_TOKEN, bias_source); - hpe_fieldgen_printMessage(message); - } else if (strcmp(hpe_fieldgen_toLowerCase(strTokenValue), "rfc") - == 0) { + sprintf ( message , "STATUS: token value for \"%s\" is: %s.", + HPE_BIAS_SOURCE_TOKEN, bias_source) ; + hpe_fieldgen_printMessage( message ); + } + else if(strcmp(hpe_fieldgen_toLowerCase(strTokenValue), "rfc") == 0) + { strcpy(bias_source, "rfc"); - sprintf(message, - "STATUS:in readRWBiasDyn - token value for \"%s\" is: %s", - HPE_BIAS_SOURCE_TOKEN, bias_source); - hpe_fieldgen_printMessage(message); + sprintf ( message , "STATUS: token value for \"%s\" is: %s.", + HPE_BIAS_SOURCE_TOKEN, bias_source) ; + hpe_fieldgen_printMessage( message ); + } - } else { - sprintf(message, "ERROR:in readRWBiasDyn - Invalid token value" - " for token \"%s\". Default value is set to: rfc", - HPE_BIAS_SOURCE_TOKEN); - hpe_fieldgen_printMessage(message); + + } + else + { + sprintf ( message , "ERROR: Invalid token value" + " for token \"%s\".", + HPE_BIAS_SOURCE_TOKEN) ; + hpe_fieldgen_printMessage( message ); } first = 0; } - + /* * if the bias source is LOCAL, * pick up bias value based on the FXA_LOCAL_SITE */ - if (strcmp(bias_source, "local") == 0) /*for LOCAL MFB */ + if(strcmp(bias_source, "local") == 0) { - if (dualpol_on_flag == 0) { - sprintf(message, - " STATUS:in readRWBiasDyn - Loading SP LOCAL MFB bias from RWBiasDyn " - "table for siteID (token fxa_local_site) = %s, lag time = %d", - site_id, lag_cut); - hpe_fieldgen_printMessage(message); - - read_rwbiasdyn2(radar_id, site_id, datehour, lag_cut, num_pairs, - sumgag, sumrad, bias, lag, datetime1, irc); - } else { - sprintf(message, - "STATUS:in readRWBiasDyn - Loading DP LOCAL MFB bias from DAABiasDyn " - "table for siteID (token fxa_local_site) = %s, lag time = %d", - site_id, lag_cut); - hpe_fieldgen_printMessage(message); - - read_daabiasdyn(radar_id, site_id, datehour, lag_cut, num_pairs, - sumgag, sumrad, bias, lag, datetime1, irc); - } - } else /* for RFC MFB */ + sprintf ( message , "STATUS: in readRWBiasDyn,loading bias value based on FXA_LOCAL_SITE.") ; + hpe_fieldgen_printMessage( message ); + + if (dualpol_on_flag == 0) + { + read_rwbiasdyn2(radar_id, site_id, datehour, + lag_cut, num_pairs, sumgag, + sumrad, bias, lag, datetime1, irc) ; + + sprintf (message, " STATUS:in readRWBiasDyn, dualpol_on_flag is NO, loading bias value from RWBiasDyn table."); + hpe_fieldgen_printMessage( message ); + } + else + { + sprintf (message, "STATUS: in readRWBiasDyn, dualpol_on_flag is YES, loading bias value from DAABiasDyn table"); + hpe_fieldgen_printMessage( message ); + + read_daabiasdyn(radar_id, site_id, datehour, + lag_cut, num_pairs, sumgag, + sumrad, bias, lag, datetime1, irc) ; + if (*irc != 0) + { + read_rwbiasdyn2(radar_id, site_id, datehour, + lag_cut, num_pairs, sumgag, + sumrad, bias, lag, datetime1, irc) ; + + sprintf(message, "STATUS: in readRWBiasDyn, dualpol_on_flag is YES. Fail to load bias value from DAABiasDyn table. Try RWBiasDyn table"); + hpe_fieldgen_printMessage( message ); + } + else + { + if (dualpol_data_avail == 0) + { + read_rwbiasdyn2(radar_id, site_id, datehour, + lag_cut, num_pairs, sumgag, + sumrad, bias, lag, datetime1, irc) ; + + sprintf( message, "STATUS: in readRWBiasDyn, bias value is found in DAABiasDyn table.But dualpol raw data is not available. " + "Try RWBiasDyn table."); + hpe_fieldgen_printMessage( message ); + } + else + { + sprintf( message, "STATUS: in readRWBiasDyn, bias value is found in DAABiasDyn table. Dualpol raw data is available."); + hpe_fieldgen_printMessage( message ); + } + } + } + } + else { /* * retrieve the office ID from RadarLoc table */ - + retrieveOfficeIDByRadarID(radar_id, officeID, irc); - - if (*irc == -1) { - sprintf(message, - "ERROR:in readRWBiasDyn - could not find office ID for radar: %s", - radar_id); - shutdown(message); + + if(*irc == -1) + { + sprintf ( message, "ERROR: could not find office ID for radar: %s", + radar_id); + shutdown( message ); } - - sprintf(message, "STATUS:in readRWBiasDyn - officeID = %s, siteID = %s", - officeID, site_id); - hpe_fieldgen_printMessage(message); - + /* * Pick up the bias value based on the radar's office ID. * If there is no record found, check if the office ID is @@ -141,215 +194,345 @@ void readRWBiasDyn(const char *radar_id, const char *site_id, * FXA_LOCAL_SITE as office ID to pick up the bias value again. */ - if (strcmp(officeID, site_id) != 0) { + if(strcmp(officeID, site_id) != 0) + { /* * if the office ID != FXA_LOCAL_SITE, * then use the HPE_RFC_BIAS_LAG_TOKEN value * to pick up the bias value. */ - if (dualpol_on_flag == 0) { - sprintf(message, - "STATUS:in readRWBiasDyn - start to load SP RFC MFB from RWBiasDyn table" - " for officeID = %s, lag time = %d", officeID, - rfc_bias_lag); - hpe_fieldgen_printMessage(message); - read_rwbiasdyn2(radar_id, officeID, datehour, rfc_bias_lag, - num_pairs, sumgag, sumrad, bias, lag, datetime1, irc); - if (*irc != 0) { - sprintf(message, - "STATUS:in readRWBiasDyn - can not load SP RFC MFB bias from RWBiasDyn" - " table for officeID = %s. Loading SP LOCAL MFB for siteID = %s, lag time = %d", - officeID, site_id, lag_cut); - hpe_fieldgen_printMessage(message); - - read_rwbiasdyn2(radar_id, site_id, datehour, lag_cut, - num_pairs, sumgag, sumrad, bias, lag, datetime1, - irc); - } else { - sprintf(message, - "STATUS:in readRWBiasDyn - Loading SP RFC MFB bias from RWBiasDyn " - "table for officeID = %s, lag time = %d", - officeID, rfc_bias_lag); - hpe_fieldgen_printMessage(message); - } - } else { - sprintf(message, - "STATUS:in readRWBiasDyn - start to load DP RFC MFB from DAABiasDyn table" - " for officeID = %s, lag time = %d", officeID, - rfc_bias_lag); - hpe_fieldgen_printMessage(message); - - read_daabiasdyn(radar_id, officeID, datehour, rfc_bias_lag, - num_pairs, sumgag, sumrad, bias, lag, datetime1, irc); - if (*irc != 0) { - sprintf(message, - "STATUS:in readRWBiasDyn - can not load DP RFC MFB from DAABiasDyn table" - " for officeID = %s. Loading DP LOCAL MFB for siteID = %s, lag time = %d", - officeID, site_id, lag_cut); - hpe_fieldgen_printMessage(message); - - read_daabiasdyn(radar_id, site_id, datehour, lag_cut, - num_pairs, sumgag, sumrad, bias, lag, datetime1, - irc); - } else { - sprintf(message, - "STATUS:in readRWBiasDyn - Loading DP RFC MFB bias from DAABiasDyn table" - " for officeID = %s, lag time = %d", - officeID, rfc_bias_lag); - hpe_fieldgen_printMessage(message); + sprintf ( message , "STATUS: loading bias value based on" + " %s and lag time: %d", + officeID, rfc_bias_lag) ; + hpe_fieldgen_printMessage( message ); + + if (dualpol_on_flag == 0) + { + read_rwbiasdyn2(radar_id, officeID, datehour, + rfc_bias_lag, num_pairs, sumgag, + sumrad, bias, lag, datetime1, irc) ; + sprintf (message, "STATUS: in readRWBiasDyn, dualpol_on_flag is NO, loading bias value from RWBiasDyn table."); + hpe_fieldgen_printMessage( message ); + + } + else + { + sprintf (message, "STATUS: in readRWBiasDyn, dualpol_on_flag is YES, loading bias value from DAABiasDyn table"); + hpe_fieldgen_printMessage( message ); + + read_daabiasdyn(radar_id, officeID, datehour, + rfc_bias_lag, num_pairs, sumgag, + sumrad, bias, lag, datetime1, irc) ; + + if (*irc != 0) + { + read_rwbiasdyn2(radar_id, officeID, datehour, + rfc_bias_lag, num_pairs, sumgag, + sumrad, bias, lag, datetime1, irc) ; + sprintf(message, "STATUS: in readRWBiasDyn, Fail to load bias value from DAABiasDyn table. Try RWBiasDyn table"); + hpe_fieldgen_printMessage( message ); } + else + { + if (dualpol_data_avail == 0) + { + read_rwbiasdyn2(radar_id, officeID, datehour, + rfc_bias_lag, num_pairs, sumgag, + sumrad, bias, lag, datetime1, irc) ; + sprintf( message, "STATUS: in readRWBiasDyn, bias value is found in DAABiasDyn table.But dualpol data is not available. " + "Try RWBiasDyn table."); + hpe_fieldgen_printMessage( message ); + } + else + { + sprintf( message, "STATUS: in readRWBiasDyn, bias value is found in DAABiasDyn table. Dualpol data is available."); + hpe_fieldgen_printMessage( message ); + } + } } - } else { - if (dualpol_on_flag == 0) { - read_rwbiasdyn2(radar_id, officeID, datehour, lag_cut, - num_pairs, sumgag, sumrad, bias, lag, datetime1, irc); + } + else + { + sprintf ( message , "STATUS: in readRWBiasDyn, loading bias value based on" + " %s and lag time: %d", + officeID, lag_cut) ; + hpe_fieldgen_printMessage( message ); + + if (dualpol_on_flag == 0) + { + read_rwbiasdyn2(radar_id, officeID, datehour, + lag_cut, num_pairs, sumgag, + sumrad, bias, lag, datetime1, irc) ; + sprintf (message, "STATUS: in readRWBiasDyn, dualpol_on_flag is NO. Loading bias value from RWBiasDyn table."); + hpe_fieldgen_printMessage( message ); + } + else + { + sprintf (message, "STATUS: in readRWBiasDyn, dualpol_on_flag is YES. Loading bias value from DAABiasDyn table"); + hpe_fieldgen_printMessage( message ); + + read_daabiasdyn(radar_id, officeID, datehour, + lag_cut, num_pairs, sumgag, + sumrad, bias, lag, datetime1, irc) ; + if (*irc != 0) + { + sprintf(message, "STATUS: in readRWBiasDyn, faild to load bias value from DAABiasDyn table. Try RWBiasDyn table."); + hpe_fieldgen_printMessage( message ); + + read_rwbiasdyn2(radar_id, officeID, datehour, + lag_cut, num_pairs, sumgag, + sumrad, bias, lag, datetime1, irc) ; + + } + else + { + if (dualpol_data_avail == 0) + { + read_rwbiasdyn2(radar_id, officeID, datehour, + rfc_bias_lag, num_pairs, sumgag, + sumrad, bias, lag, datetime1, irc) ; + sprintf( message, "STATUS: in readRWBiasDyn, bias value is found in DAABiasDyn table.But dualpol data is not available. " + "Try RWBiasDyn table."); + hpe_fieldgen_printMessage( message ); + } + else + { + sprintf(message, "STATUS: in readRWBiasDyn, bias value is found in DAABiasDyn table. Dualpol data is available."); + hpe_fieldgen_printMessage( message ); + } + } + } - sprintf(message, - "STATUS:in readRWBiasDyn - Loading SP RFC MFB bias from RWBiasDyn table" - " for officeID(siteID) = %s, lag time = %d", - officeID, lag_cut); - hpe_fieldgen_printMessage(message); - } else { - read_daabiasdyn(radar_id, officeID, datehour, lag_cut, - num_pairs, sumgag, sumrad, bias, lag, datetime1, irc); + } - sprintf(message, - "STATUS:in readRWBiasDyn - Loading DP RFC MFB bias from DAABiasDyn table " - "for officeID(siteID) = %s, lag time = %d", - officeID, lag_cut); - hpe_fieldgen_printMessage(message); + /* + * Record not found in RWBiasDyn table based on office ID. + * try to pick up bias value based on the FXA_LOCAL_SITE + * if it is different from office ID. + */ + + if(*irc == 100) + { + + if(strcmp(officeID, site_id) != 0) + { + sprintf ( message , "STATUS: in readRWBiasDyn,Record not found in" + " RWBiasDyn table based on %s." + " try to pick up the bias value" + " based on the %s", + officeID, site_id) ; + hpe_fieldgen_printMessage( message ); + + if (dualpol_on_flag == 0) + { + read_rwbiasdyn2(radar_id, site_id, datehour, + lag_cut, num_pairs, sumgag, + sumrad, bias, lag, datetime1, irc) ; + sprintf (message, "STATUS: in readRWBiasDyn, dualpol_on_flag is NO. Loading bias value from RWBiasDyn table."); + hpe_fieldgen_printMessage( message ); + } + else + { + sprintf (message, "STATUS: in readRWBiasDyn, dualpol_on_flag is YES. Loading bias value from DAABiasDyn table."); + hpe_fieldgen_printMessage( message ); + + read_daabiasdyn(radar_id, site_id, datehour, + lag_cut, num_pairs, sumgag, + sumrad, bias, lag, datetime1, irc) ; + if (*irc != 0) + { + sprintf(message, "STATUS: in readRWBiasDyn, faild to find bias value in DAABiasDyn table. Try RWBiasDyn table."); + hpe_fieldgen_printMessage( message ); + read_rwbiasdyn2(radar_id, site_id, datehour, + lag_cut, num_pairs, sumgag, + sumrad, bias, lag, datetime1, irc) ; + } + else + { + if (dualpol_data_avail == 0) + { + read_rwbiasdyn2(radar_id, site_id, datehour, + lag_cut, num_pairs, sumgag, + sumrad, bias, lag, datetime1, irc) ; + + sprintf( message, "STATUS: in readRWBiasDyn, bias value is found in DAABiasDyn table.But dualpol data is not available. " + "Try RWBiasDyn table."); + hpe_fieldgen_printMessage( message ); + } + else + { + sprintf(message, "STATUS: in readRWBiasDyn, bias value is found in DAABiasDyn table. Dualpol data is available.s"); + hpe_fieldgen_printMessage( message ); + } + } + } } } } } -void read_rwbiasdyn2(const char *radar_id, const char *office_id, - const char * str, const int lag_cut, double *num_pairs, double *sumgag, - double *sumrad, double *bias, int *lag, char sstr1[19], long int *irc) +void read_rwbiasdyn2(const char *radar_id, + const char *office_id, + const char * str, + const int lag_cut, + double *num_pairs, + double *sumgag, + double *sumrad, + double *bias, + int *lag, + char sstr1[19], + long int *irc) /* - this function reads records from the RWBiasDyn table for previous hours - these records contain the state variables used in the bias calculations - each previous hour up to lag_cut hours is searched to find records in the - table if no records is found, then state variables are reinitialized + this function reads records from the RWBiasDyn table for previous hours + these records contain the state variables used in the bias calculations + each previous hour up to lag_cut hours is searched to find records in the + table if no records is found, then state variables are reinitialized - calling function: mfb_subr - */ + calling function: mfb_subr +*/ { - int j, irec, ctr; - RWBiasDyn *bdHead = NULL; - RWBiasDyn *bdPtr = NULL; - char rrad[4] = { '\0' }; - char strp[22] = { '\0' }; - char dude[22] = { '\0' }; - char where[BUFSIZ] = { '\0' }; - char obstime_ANSI[ANSI_TIME_LEN + 1] = { '\0' }; - time_t firstTime = 0; + int j, irec, ctr; + RWBiasDyn *bdHead = NULL; + RWBiasDyn *bdPtr = NULL; + char rrad[4] = {'\0'}; + char strp[22] = {'\0'}; + char dude[22] = {'\0'}; + char where[BUFSIZ] = {'\0'}; + char obstime_ANSI[ANSI_TIME_LEN+1] = {'\0'}; + time_t firstTime = 0; - strncpy(rrad, radar_id, 3); - strncpy(dude, str, 19); + strncpy(rrad, radar_id, 3); + strncpy(dude, str, 19); - yearsec_ansi_to_timet(dude, &firstTime); + yearsec_ansi_to_timet(dude, &firstTime); + + /*------------------------------------------------*/ + /* subtract 1 hour and attempt to select record */ + /*------------------------------------------------*/ - /*------------------------------------------------*/ - /* subtract 1 hour and attempt to select record */ - /*------------------------------------------------*/ - - *irc = -1; - for (j = 0; j < lag_cut; j++) { + *irc = -1; + for(j = 0; j < lag_cut; j ++) + { firstTime -= SECONDS_PER_HOUR; timet_to_yearsec_ansi(firstTime, strp); strncpy(sstr1, strp, 19); irec = 0; - *lag = j + 1; + *lag = j+1; /*------------------------------------------*/ /* select records for all mem_span values */ /*------------------------------------------*/ - + timet_to_yearsec_ansi(firstTime, obstime_ANSI); sprintf(where, " WHERE radid='%s' AND obstime='%s' AND " - " office_id = '%s'", rrad, obstime_ANSI, office_id); + " office_id = '%s'", + rrad, obstime_ANSI, office_id); bdHead = GetRWBiasDyn(where); - if (bdHead) { - bdPtr = (RWBiasDyn *) ListFirst(&bdHead->list); + if (bdHead) + { + bdPtr = (RWBiasDyn *) ListFirst(&bdHead->list); ctr = 0; - while (bdPtr) { - num_pairs[ctr] = (double) bdPtr->numpairs; - sumgag[ctr] = (double) bdPtr->sumgag; - sumrad[ctr] = (double) bdPtr->sumrad; - bias[ctr] = (double) bdPtr->bias; - + while (bdPtr) + { + num_pairs[ctr] = (double)bdPtr->numpairs; + sumgag[ctr] = (double)bdPtr->sumgag; + sumrad[ctr] = (double)bdPtr->sumrad; + bias[ctr] = (double)bdPtr->bias; + ctr++; bdPtr = (RWBiasDyn *) ListNext(&bdPtr->node); } - if (bdHead != NULL) { + if ( bdHead != NULL ) + { FreeRWBiasDyn(bdHead); - bdHead = NULL; + bdHead = NULL ; } - if (ctr > 0) { + if (ctr > 0) + { *irc = 0; break; } - } else { + } + else + { *irc = 100; } - } /* end for (j=0 ... */ + } /* end for (j=0 ... */ - return; + return ; -} /* end read_rwbiasdyn2 function */ +} /* end read_rwbiasdyn2 function */ -void retrieveOfficeIDByRadarID(const char * radarID, char * officeID, - long int * status) { - char where_clause[BUFSIZ] = { '\0' }; - RadarLoc * pRadarLocNode = NULL; - *status = 0; +void retrieveOfficeIDByRadarID(const char * radarID, + char * officeID, + long int * status) +{ + char where_clause [ BUFSIZ ] = {'\0'}; + RadarLoc * pRadarLocNode = NULL ; + + *status = 0 ; strcpy(officeID, ""); - sprintf(where_clause, " "); + sprintf ( where_clause, " "); - if (pRadarLocHead == NULL) { - pRadarLocHead = GetRadarLoc(where_clause); + if(pRadarLocHead == NULL) + { + pRadarLocHead = GetRadarLoc ( where_clause ) ; } - if (pRadarLocHead != NULL) { - pRadarLocNode = (RadarLoc *) ListFirst(&pRadarLocHead->list); + if ( pRadarLocHead != NULL ) + { + pRadarLocNode = ( RadarLoc * ) ListFirst (&pRadarLocHead->list); - while (pRadarLocNode != NULL) { - if (strcmp(pRadarLocNode->radid, radarID) == 0) { + while (pRadarLocNode != NULL) + { + if(strcmp(pRadarLocNode->radid, radarID) == 0) + { strcpy(officeID, pRadarLocNode->office_id); - sprintf(message, - "STATUS:in retrieveOfficeIDByRadarID - From RadarLoc table, Radar ID: %s, Office ID: %s", - radarID, officeID); - hpe_fieldgen_printMessage(message); + sprintf ( message , "From RadarLoc table, Radar ID: %s, Office ID: %s", + radarID, officeID ); + hpe_fieldgen_printMessage( message); break; - } else { + } + else + { pRadarLocNode = (RadarLoc *) ListNext(&pRadarLocNode->node); } } - } else { - *status = -1; + } + else + { + * status = -1 ; } - return; + return ; } -void freeRadarLocMemory() { + +void freeRadarLocMemory() +{ /* Deallocate the RadarLoc linked list. */ - if (pRadarLocHead != NULL) { - FreeRadarLoc(pRadarLocHead); - pRadarLocHead = NULL; + if ( pRadarLocHead != NULL ) + { + FreeRadarLoc ( pRadarLocHead ) ; + pRadarLocHead = NULL ; } + +/* ============== Statements containing RCS keywords: */ +{static char rcs_id1[] = "$Source: /fs/hseb/ob83/ohd/pproc/src/hpe_fieldgen/RCS/read_rwbiasdyn2.c,v $"; + static char rcs_id2[] = "$Id: read_rwbiasdyn2.c,v 1.2 2007/10/30 13:33:13 gzhou Exp $";} +/* =================================================== */ + } diff --git a/nativeLib/rary.ohd.pproc/src/hpe_fieldgen/TEXT/run_dhrmosaic.c b/nativeLib/rary.ohd.pproc/src/hpe_fieldgen/TEXT/run_dhrmosaic.c index 42ed4a3a1a..e72cf4728d 100644 --- a/nativeLib/rary.ohd.pproc/src/hpe_fieldgen/TEXT/run_dhrmosaic.c +++ b/nativeLib/rary.ohd.pproc/src/hpe_fieldgen/TEXT/run_dhrmosaic.c @@ -1,90 +1,89 @@ /*********************************************************************** - * Filename: run_dhrmosaic.c - * - * Original Author: Guoxian Zhou - * - * File Creation Date: 08/13/2006 - * - * Development Group: HSEB/OHD - * - * Description: - * compute the raw DHR mosaic data - * - * Modules: - * runDHRMosaic - * - ***********************************************************************/ +* Filename: run_dhrmosaic.c +* +* Original Author: Guoxian Zhou +* +* File Creation Date: 08/13/2006 +* +* Development Group: HSEB/OHD +* +* Description: +* compute the raw DHR mosaic data +* +* Modules: +* runDHRMosaic +* +***********************************************************************/ /* Include files, definitions, globals go here. */ #include "empe_fieldgen.h" /*********************************************************************** - * Module Name: createDHRMosaic - * - * Original Author: Guoxian Zhou - * - * Module Creation Date: 08/13/2006 - * - * Description: - * This function computes the raw DHR mosaic data. - * - * calling function: main_empe_fieldgen - * functions called: readRadarResult , - * readDHRData, readMisc, - * createDHRMosaic, writeArray - * - * Calling Arguments: - * Name Input/Output Type Description - * - * pRunDate Input run_date_struct* date/time - * pGeoData Input geo_data_struct* global HRAP lowerleft-corner - * bin and dimension and dimension - * of the RFC estimation domain - * pMPEParams Input mpe_params_struct* static parameters - * pRadarLocRecord Input radarLoc_table_struct* info from radarLoc table - * DHRMosaic Output double ** the DHR radar mosaic product - * QPEMosaic Output double ** the mosaic of radars - * for best estimate - * - * - * Required - * None - * - * Required Files/Databases: - * None - * - * Non System Routines Called: - * - * - * Return Value: - * Type Description - * None - * - * Error Codes/Exceptions: - * - * - * OS Specific Assumptions: - * None - * - * Local Variables: - * Name Type Description - * - * Modification History: - * Date Developer Action - * 8/13/2006 Guoxian Zhou Build operational version - * 07/2013 Jingtao Deng Modify for adding dual pol producat DPR - * first try to find the DPR product from dprradar - * table and calculate the rain rate. if - * not able to get DPR product, then use DHR product - * 02/2015 JingtaoD A2 OB14.4.1 DR#17123 - HPE Bias Source field - * 09/2015 JingtaoD A2 OB16.2.1 DR#17860 - HPE DualPol Mean field bias - ***********************************************************************/ +* Module Name: createDHRMosaic +* +* Original Author: Guoxian Zhou +* +* Module Creation Date: 08/13/2006 +* +* Description: +* This function computes the raw DHR mosaic data. +* +* calling function: main_empe_fieldgen +* functions called: readRadarResult , +* readDHRData, readMisc, +* createDHRMosaic, writeArray +* +* Calling Arguments: +* Name Input/Output Type Description +* +* pRunDate Input run_date_struct* date/time +* pGeoData Input geo_data_struct* global HRAP lowerleft-corner +* bin and dimension and dimension +* of the RFC estimation domain +* pMPEParams Input mpe_params_struct* static parameters +* pRadarLocRecord Input radarLoc_table_struct* info from radarLoc table +* DHRMosaic Output double ** the DHR radar mosaic product +* QPEMosaic Output double ** the mosaic of radars +* for best estimate +* +* +* Required +* None +* +* Required Files/Databases: +* None +* +* Non System Routines Called: +* +* +* Return Value: +* Type Description +* None +* +* Error Codes/Exceptions: +* +* +* OS Specific Assumptions: +* None +* +* Local Variables: +* Name Type Description +* +* Modification History: +* Date Developer Action +* 8/13/2006 Guoxian Zhou Build operational version +* 07/2013 Jingtao Deng Modify for adding dual pol producat DPR +* first try to find the DPR product from dprradar +* table and calculate the rain rate. if +* not able to get DPR product, then use DHR product +* 02/2015 JingtaoD A2 OB14.4.1 DR#17123 - HPE Bias Source field +***********************************************************************/ -extern short ** radarMiscBins; +extern short ** radarMiscBins ; -static double ** tempID = NULL; -static double ** DHRHeight = NULL; +static double ** tempID = NULL; +static double ** DHRHeight = NULL ; static float ** origRadar = NULL; static short ** hrapMiscBins = NULL; @@ -95,25 +94,30 @@ extern int dualpol_used; extern int dualpol_on_flag; static void initMosaicArray(const geo_data_struct * pGeoData, - const int grid_rows, const int grid_cols); + const int grid_rows, + const int grid_cols) ; static void freeMosaicArray(const geo_data_struct * pGeoData, - const int grid_rows); + const int grid_rows) ; void runDHRMosaic(const run_date_struct * pRunDate, - const geo_data_struct * pGeoData, empe_params_struct * pEMPEParams, - const radarLoc_table_struct * pRadarLocTable, - const gage_table_struct * pGageTable, double * meanFieldBias, - double ** RadarBeamHeight, int ** ID, double ** Mosaic, - double ** QPEMosaic) { - const int rowSize = pGeoData->num_rows; - const int colSize = pGeoData->num_cols; - const int replace_missing = 0; + const geo_data_struct * pGeoData, + empe_params_struct * pEMPEParams, + const radarLoc_table_struct * pRadarLocTable , + double * meanFieldBias, + double ** RadarBeamHeight, + int ** ID, + double ** Mosaic, + double ** QPEMosaic) +{ + const int rowSize = pGeoData->num_rows ; + const int colSize = pGeoData->num_cols ; + const int replace_missing = 0 ; const char * MOSAIC_DIR_TOKEN = "hpe_dhrmosaic_dir"; const char * SAVE_HEIGHT_TOKEN = "hpe_save_dhrheight"; const char * HEIGHT_DIR_TOKEN = "hpe_dhrheight_dir"; - const char * SAVE_INDEX_TOKEN = "hpe_save_dhrindex"; - const char * INDEX_DIR_TOKEN = "hpe_dhrindex_dir"; + const char * SAVE_INDEX_TOKEN = "hpe_save_dhrindex"; + const char * INDEX_DIR_TOKEN = "hpe_dhrindex_dir"; const char * SAVE_GRIB_TOKEN = "dhrmosaic_save_grib"; @@ -127,25 +131,24 @@ void runDHRMosaic(const run_date_struct * pRunDate, const char * SAVE_JPEG_TOKEN = "dhrmosaic_save_jpeg"; - char saveflag[TOKEN_LEN] = { '\0' }; + char saveflag[TOKEN_LEN]= {'\0'}; - const int RADAR_ROWS = NUM_DPA_ROWS * pEMPEParams->hrap_grid_factor; - const int RADAR_COLS = NUM_DPA_COLS * pEMPEParams->hrap_grid_factor; + const int RADAR_ROWS = NUM_DPA_ROWS * pEMPEParams->hrap_grid_factor ; + const int RADAR_COLS = NUM_DPA_COLS * pEMPEParams->hrap_grid_factor ; - static char datetime[ANSI_YEARSEC_TIME_LEN + 1] = { '\0' }; - static char datehour[ANSI_YEARSEC_TIME_LEN + 1] = { '\0' }; - static char strDateTime[ANSI_YEARSEC_TIME_LEN + 1] = { '\0' }; - static char prdDateTime[ANSI_YEARSEC_TIME_LEN + 1] = { '\0' }; - static char radarID[RADAR_ID_LEN + 1] = { '\0' }; - register int i, j, k; + static char datetime[ANSI_YEARSEC_TIME_LEN + 1] = {'\0'} ; + static char datehour[ANSI_YEARSEC_TIME_LEN + 1] = {'\0'} ; + static char strDateTime[ANSI_YEARSEC_TIME_LEN + 1] = {'\0'} ; + static char prdDateTime[ANSI_YEARSEC_TIME_LEN + 1] = {'\0'} ; + static char radarID[ RADAR_ID_LEN + 1] = {'\0'} ; + register int i, j, k; - long int irc; - register int year, month, day, hour; + long int irc ; int radarAvailFlag = 0; - int dp_blnEditBias, sp_blnEditBias; - double dp_editBiasValue, sp_editBiasValue; - int dp_ignoreRadarFlag, sp_ignoreRadarFlag; + int dp_ignoreRadarFlag = 0; + int sp_ignoreRadarFlag = 0; + register int year, month, day, hour; static char fileName[PATH_LEN] = { '\0' }; static char dhrmosaic_fileName[PRESET_DESCR_LEN] = { '\0' }; @@ -158,308 +161,369 @@ void runDHRMosaic(const run_date_struct * pRunDate, short pps_radar_count = 0, dp_radar_count = 0; int index; - double meanBias = 0.0; - double memSpanBias; - int gageRadarPairNum = 0; /* number of positive gage/radar pairs */ - int dualpol_meanbias_flag[MAX_RADAR_NUM]; - int sp_meanbias_flag[MAX_RADAR_NUM]; + + int dualpol_meanbias_flag[MAX_RADAR_NUM]; + int sp_meanbias_flag[MAX_RADAR_NUM]; int dualpol_data_avail[MAX_RADAR_NUM]; int nobias_flag; /* for DHR product, there is no bias applied */ nobias_flag = 1; - + /* initialize no dualpol MFB and no dual pol product avialble for each radar */ - for (i = 0; i < MAX_RADAR_NUM; i++) { - dualpol_meanbias_flag[i] = 0; - sp_meanbias_flag[i] = 0; - dualpol_data_avail[i] = 0; + for (i = 0; i < MAX_RADAR_NUM; i++) + { + dualpol_meanbias_flag[i] = 0; + sp_meanbias_flag[i] = 0; + dualpol_data_avail[i] = 0; } + - pEMPEParams->radar_avail_num = 0; + pEMPEParams->radar_avail_num = 0 ; /* * Allocates memory for data arrays * based on the geo grid size data. */ - initMosaicArray(pGeoData, RADAR_ROWS, RADAR_COLS); + initMosaicArray(pGeoData, RADAR_ROWS, RADAR_COLS) ; /* * strDateTime string should be in format: yyyymmddHHMM */ - pRunTime = gmtime(&(pRunDate->tRunTime)); - strftime(datetime, ANSI_YEARSEC_TIME_LEN + 1, "%Y-%m-%d %H:%M:00", - pRunTime); - strftime(datehour, ANSI_YEARSEC_TIME_LEN + 1, "%Y-%m-%d %H:00:00", - pRunTime); - strftime(strDateTime, ANSI_YEARSEC_TIME_LEN + 1, "%Y%m%d%H%M", pRunTime); - strftime(prdDateTime, ANSI_YEARSEC_TIME_LEN + 1, "%Y-%m-%d %H:%M:%S", - pRunTime); + pRunTime = gmtime(&(pRunDate->tRunTime)) ; + strftime ( datetime, ANSI_YEARSEC_TIME_LEN + 1, + "%Y-%m-%d %H:%M:00", pRunTime ) ; + strftime ( datehour, ANSI_YEARSEC_TIME_LEN + 1, + "%Y-%m-%d %H:00:00", pRunTime ) ; + strftime(strDateTime, ANSI_YEARSEC_TIME_LEN + 1, + "%Y%m%d%H%M", pRunTime); + strftime(prdDateTime, ANSI_YEARSEC_TIME_LEN + 1, + "%Y-%m-%d %H:%M:%S", pRunTime); year = pRunTime->tm_year + 1900; month = pRunTime->tm_mon + 1; day = pRunTime->tm_mday; hour = pRunTime->tm_hour; - hpe_fieldgen_getCurrentTime(currTime); - sprintf(message, "%s = time begin DHRMOSAIC calculation.", currTime); - hpe_fieldgen_printMessage(message); + hpe_fieldgen_getCurrentTime(currTime) ; + sprintf( message , "%s = time begin DHRMOSAIC calculation." , + currTime) ; + hpe_fieldgen_printMessage( message ); + + sprintf ( message , "STATUS: In DHRMOSAIC - Dual pol product flag is %d.", dualpol_on_flag) ; + printLogMessage( message ); radar_result_struct * pRadarResult = NULL; - pRadarResult = (radar_result_struct *) malloc( - pRadarLocTable->radarNum * sizeof(radar_result_struct)); - if (pRadarResult == NULL) { + pRadarResult = (radar_result_struct *) malloc(pRadarLocTable->radarNum + * sizeof(radar_result_struct)); + if (pRadarResult == NULL) + { sprintf(message, "ERROR: memory allocation failure" - " in runDHRMosaic function." - "\n\tProgram exit."); + " in runDHRMosaic function." + "\n\tProgram exit.") ; shutdown(message); } - /* for dual pol proudcts which use daaradarresult table */ + /* for dual pol proudcts which use daaradarresult table */ radar_result_struct * pDAARadarResult = NULL; - - pDAARadarResult = (radar_result_struct *) malloc( - pRadarLocTable->radarNum * sizeof(radar_result_struct)); - if (pDAARadarResult == NULL) { - sprintf(message, "ERROR: memory allocation failure" - " in runDHRMosaic function." - "\n\tProgram exit."); - shutdown(message); + + pDAARadarResult = (radar_result_struct *) + malloc(pRadarLocTable->radarNum * sizeof(radar_result_struct)); + if(pDAARadarResult == NULL) + { + sprintf ( message , "ERROR: memory allocation failure" + " in runDHRMosaic function." + "\n\tProgram exit.") ; + shutdown( message ); } - for (i = 0; i < pRadarLocTable->radarNum; i++) { - memset(pRadarResult[i].radID, '\0', RADAR_ID_LEN + 1); + for(i = 0; i < pRadarLocTable->radarNum; i++ ) + { + memset(pRadarResult[i].radID, '\0', RADAR_ID_LEN + 1) ; pRadarResult[i].ignore_radar = 0; - pRadarResult[i].edit_bias = 0; - pRadarResult[i].bias = 0.0; - memset(pDAARadarResult[i].radID, '\0', RADAR_ID_LEN + 1); - pDAARadarResult[i].ignore_radar = 0; - pDAARadarResult[i].edit_bias = 0; - pDAARadarResult[i].bias = 0.0; + memset(pDAARadarResult[i].radID, '\0', RADAR_ID_LEN + 1) ; + pDAARadarResult[i].ignore_radar = 0; } /* - * Read from RWRadarResult table for SinglePol or DAARadarResult table for DualPol + * Read the ignore radar flag + * from RWRadarResult table */ - if (dualpol_on_flag == 0) { - readRadarResult(datetime, pRadarResult, &pps_radar_count, - sp_meanbias_flag, &irc); - if (irc < 0) { - sprintf(message, - "ERROR:in runDHRMosaic - Database error #%ld attempting to " - "select record from RWRadarResult table.", irc); - printLogMessage(message); - } - } else { - readDAARadarResult(datehour, pDAARadarResult, &dp_radar_count, - dualpol_meanbias_flag, &irc); /* for dual pol */ - - if (irc < 0) { - sprintf(message, - "ERROR:in runDHRMosaic - Database error #%ld attempting to " - "select record from DAARadarResult table.", irc); - hpe_fieldgen_printMessage(message); - } + /* when dualpol_on_flag is set as zero, no any dual pol products will be used even + though they are available. Only single pol radar producats are used. This keeps the old + functionality */ + + if (dualpol_on_flag == 0) + { + readRadarResult(datetime, pRadarResult, &pps_radar_count,sp_meanbias_flag, &irc) ; + if (irc < 0) + { + sprintf(message, "ERROR: in runDHRMosaic - Database error #%ld attempting to " + "select record from RWRadarResult table.", irc) ; + printLogMessage(message); + } } + /* Able to use dual pol products if available for this radar, if not available for this radar, use the single + pol product */ + else + { + readDAARadarResult (datehour, pDAARadarResult, &dp_radar_count, dualpol_meanbias_flag, &irc) ; /* for dual pol */ + + if (irc < 0 || dp_radar_count <= 0) + { + if (irc < 0) + { + sprintf ( message , "ERROR: in runDHRMosaic - Database error #%ld attempting to " + "select record from DAARadarResult table. Try RWRadarResult table.", irc) ; + hpe_fieldgen_printMessage( message ); + } + + else if (dp_radar_count <= 0) + { + sprintf ( message , "STATUS: in runDHRMosaic - No data found for radar " + "from DAARadarResult table, then select data from RWRadarResult table.") ; + hpe_fieldgen_printMessage( message ); + } + } + + readRadarResult (datehour, pRadarResult, &pps_radar_count, sp_meanbias_flag, &irc) ; /* for single pol */ + if (irc < 0) + { + sprintf ( message , "ERROR: in runDHRMosaic - Database error #%ld attempting to " + "select record from RWRadarResult table.", irc) ; + printLogMessage( message ); + } + } /* * Read the misbin information if the token hpe_load_misbin is ON, * otherwise the misbin will be default value(1). + * Do this only once per EMPE_fieldgen run. */ - if (radarMiscBins == NULL) { - radarMiscBins = init2DShortArray(MISBIN_DEFAULT, - pRadarLocTable->radarNum, NUM_DPA_ELEMENTS); + if ( radarMiscBins == NULL ) + { + radarMiscBins = init2DShortArray(MISBIN_DEFAULT, + pRadarLocTable->radarNum, + NUM_DPA_ELEMENTS ); - if (pEMPEParams->load_misbin == 1) { - readMisc(pRadarLocTable, radarMiscBins); + if(pEMPEParams->load_misbin == 1) + { + readMisc ( pRadarLocTable, radarMiscBins ) ; } } + /* * begin loop on radars */ - for (i = 0; i < pRadarLocTable->radarNum; i++) { + for(i = 0; i < pRadarLocTable->radarNum; i++ ) + { - strcpy(radarID, pRadarLocTable->ptrRadarLocRecords[i].radarID); + strcpy(radarID, pRadarLocTable->ptrRadarLocRecords[i].radarID) ; - sprintf(message, "\n******* radar: %s *******", radarID); - hpe_fieldgen_printMessage(message); + sprintf ( message , "\n******* radar: %s *******", radarID); + hpe_fieldgen_printMessage( message ); - radar_result_struct * dp_pRadarInfo = NULL; + radar_result_struct * dp_pRadarInfo = NULL ; radar_result_struct * sp_pRadarInfo = NULL; - /* - * initialize edit bias flag, ignore radar flag - */ - - dp_blnEditBias = 0; - dp_editBiasValue = 0.0; - dp_ignoreRadarFlag = 0; - sp_blnEditBias = 0; - sp_editBiasValue = 0.0; - sp_ignoreRadarFlag = 0; - - if (pDAARadarResult != NULL) { - dp_pRadarInfo = (radar_result_struct *) binary_search( - pDAARadarResult, radarID, dp_radar_count, - sizeof(radar_result_struct), compare_radar_id); - if (dp_pRadarInfo != NULL) { - dp_ignoreRadarFlag = dp_pRadarInfo->ignore_radar; - dp_editBiasValue = dp_pRadarInfo->bias; - dp_blnEditBias = dp_pRadarInfo->edit_bias; - } - } - - if (pRadarResult != NULL) { - sp_pRadarInfo = (radar_result_struct *) binary_search(pRadarResult, - radarID, pps_radar_count, sizeof(radar_result_struct), - compare_radar_id); - if (sp_pRadarInfo != NULL) { - sp_ignoreRadarFlag = sp_pRadarInfo->ignore_radar; - sp_editBiasValue = sp_pRadarInfo->bias; - sp_blnEditBias = sp_pRadarInfo->edit_bias; - } - } - + if (pDAARadarResult != NULL) + { + dp_pRadarInfo = (radar_result_struct *) + binary_search ( pDAARadarResult, radarID, dp_radar_count, + sizeof ( radar_result_struct), compare_radar_id ); + if (dp_pRadarInfo != NULL) + dp_ignoreRadarFlag = dp_pRadarInfo->ignore_radar; + + } + + if (pRadarResult != NULL) + { + sp_pRadarInfo = (radar_result_struct *) binary_search(pRadarResult, + radarID, pps_radar_count, sizeof(radar_result_struct), + compare_radar_id); + if (sp_pRadarInfo != NULL) + sp_ignoreRadarFlag = sp_pRadarInfo->ignore_radar; + + } + /* * Read in gridded radar data * count number of available radars * an "ignored" radar is considered "not available" */ - if (dualpol_on_flag == 1) { + if (dualpol_on_flag == 1) + { readDPRData(radarID, datetime, pEMPEParams->dhr_window, - dp_ignoreRadarFlag, origRadar, &radarAvailFlag); - - if (radarAvailFlag > 0) { - sprintf(message, - "STATUS:In runDHRMosaic - dual pol product DPR is used for radar %s", - radarID); - hpe_fieldgen_printMessage(message); - dualpol_data_avail[i] = 1; - } - } else { + dp_ignoreRadarFlag, origRadar, &radarAvailFlag); + + if (radarAvailFlag > 0) + { + sprintf ( message , "STATUS: In runDHRMosaic - dual pol product DPR is used for radar %s", radarID); + hpe_fieldgen_printMessage( message ); + dualpol_data_avail[i] = 1; + } + else + { + readDHRData(radarID, datetime, pEMPEParams->dhr_window, + sp_ignoreRadarFlag, origRadar, &radarAvailFlag) ; + + dualpol_data_avail[i] = 0; + if (radarAvailFlag > 0) + { + sprintf ( message , "STATUS: In runDHRMosaic - single pol product DHR is used for radar %s", radarID); + hpe_fieldgen_printMessage( message ); + } + } + } + else + { readDHRData(radarID, datetime, pEMPEParams->dhr_window, - sp_ignoreRadarFlag, origRadar, &radarAvailFlag); - - if (radarAvailFlag > 0) { - sprintf(message, - "STATUS:In runDHRMosaic - single pol product DHR is used for radar %s", - radarID); - hpe_fieldgen_printMessage(message); - dualpol_data_avail[i] = 0; - } - } - - if (radarAvailFlag > 0) { - pEMPEParams->radar_avail_num++; - } + sp_ignoreRadarFlag, origRadar, &radarAvailFlag) ; + dualpol_data_avail[i] = 0; + + if (radarAvailFlag > 0) + { + sprintf ( message , "STATUS: In runDHRMosaic - single pol product DHR is used for radar %s", radarID); + hpe_fieldgen_printMessage( message ); + } + } + + if(radarAvailFlag > 0) + pEMPEParams->radar_avail_num ++ ; + sprintf ( message , "STATUS: In runDHRMosaic - the dualpol_data_avail flag is %d for radarID %s", dualpol_data_avail[i], radarID); + hpe_fieldgen_printMessage( message ); + /* * Convert radar array to current hrap grid */ - convertFloatArray(NUM_DHR_ROWS, NUM_DHR_COLS, origRadar, RADAR_DEFAULT, - RADAR_ROWS, RADAR_COLS, currRadar); + convertFloatArray(NUM_DHR_ROWS, + NUM_DHR_COLS, + origRadar, + RADAR_DEFAULT, + RADAR_ROWS, + RADAR_COLS , + currRadar ); /* * pick up the misbin for current running radar and * convert it to current hrap grid */ - for (j = 0; j < NUM_DPA_ROWS; j++) { - for (k = 0; k < NUM_DPA_COLS; k++) { + for(j = 0; j < NUM_DPA_ROWS; j ++) + { + for(k = 0; k < NUM_DPA_COLS; k ++) + { index = j * NUM_DPA_COLS + k; hrapMiscBins[j][k] = radarMiscBins[i][index]; } } - convertShortArray(NUM_DPA_ROWS, NUM_DPA_COLS, hrapMiscBins, - MISBIN_DEFAULT, RADAR_ROWS, RADAR_COLS, currMiscBins); - - /* + convertShortArray(NUM_DPA_ROWS, + NUM_DPA_COLS, + hrapMiscBins, + MISBIN_DEFAULT, + RADAR_ROWS, + RADAR_COLS, + currMiscBins); + + /* * get mean field bias if it is set to "ON" */ - if (pEMPEParams->blnDHRMeanFieldBias == 1) { - getMeanBias(&(pRadarLocTable->ptrRadarLocRecords[i]), datetime, - RADAR_ROWS, RADAR_COLS, currMiscBins, currRadar, pGeoData, - pGageTable, pEMPEParams, dualpol_data_avail[i], &meanBias, - &memSpanBias, &gageRadarPairNum); - meanFieldBias[i] = meanBias; + if(pEMPEParams->blnDHRMeanFieldBias == 1) + { - if (dualpol_on_flag == 1 && dp_blnEditBias == 1) { - sprintf(message, - "STATUS:In runDHRMosaic - Edited Bias is used for radar %s", - radarID); - hpe_fieldgen_printMessage(message); - meanFieldBias[i] = dp_editBiasValue; - } else if (dualpol_on_flag == 0 && sp_blnEditBias == 1) { - sprintf(message, - "STATUS:In runDHRMosaic - Edited Bias is used for radar %s", - radarID); - hpe_fieldgen_printMessage(message); - meanFieldBias[i] = sp_editBiasValue; - } + /* + * load the mean field bias value + * and save it to meanFieldBias[i] + * use DAABiasDyn table to load mean field bias for dual pol product, if not available + * use RWBiasDyn table to load mean field bias for PPS product + */ + readMeanBias(ptrRunDate, + ptrRadarLocTable, + ptrEMPEParams, + meanFieldBias, + dualpol_data_avail[i] ); + - } /*end of pEMPEParams->blnMeanFieldBias == 1 */ - - sprintf(message, "\nSTATUS:In runDHRMosaic - MFB is %f for radid %s.", - meanFieldBias[i], radarID); - hpe_fieldgen_printMessage(message); + + } /*end of ptrEMPEParams->blnMeanFieldBias == 1 */ + + sprintf( message , "STATUS: In runDHRMosaic - MFB is %f for radid %s." , + meanFieldBias[i], radarID) ; + hpe_fieldgen_printMessage( message ); /* * mosaicking algorithm */ - createDHRMosaic(&(pRadarLocTable->ptrRadarLocRecords[i]), RADAR_ROWS, - RADAR_COLS, currRadar, currMiscBins, pGeoData, i + 1, - RadarBeamHeight, DHRHeight, ID, Mosaic); + createDHRMosaic(&(pRadarLocTable->ptrRadarLocRecords[i]), + RADAR_ROWS , RADAR_COLS , + currRadar, currMiscBins, + pGeoData, i+1, RadarBeamHeight, + DHRHeight, ID, Mosaic); } - hpe_fieldgen_getCurrentTime(currTime); - sprintf(message, "\n%s = time end DHRMOSAIC calculation.", currTime); - hpe_fieldgen_printMessage(message); + + hpe_fieldgen_getCurrentTime(currTime) ; + sprintf( message , "%s = time end DHRMOSAIC calculation.", currTime) ; + hpe_fieldgen_printMessage( message ); /* * write out gridded data in xmrg format to flat files */ - hpe_fieldgen_getCurrentTime(currTime); - sprintf(message, "%s = time begin writing DHRMOSAIC fields to flat files.", - currTime); - hpe_fieldgen_printMessage(message); + hpe_fieldgen_getCurrentTime(currTime) ; + sprintf( message, "%s = time begin writing DHRMOSAIC fields to flat files.", + currTime) ; + hpe_fieldgen_printMessage( message ); - if (first == 1) { - if (hpe_fieldgen_getAppsDefaults(MOSAIC_DIR_TOKEN, mosaicDir) == -1) { - sprintf(message, "ERROR: Invalid token value" - " for token \"%s\".\n\tProgram exit.", MOSAIC_DIR_TOKEN); - shutdown(message); + if(first == 1) + { + if(hpe_fieldgen_getAppsDefaults(MOSAIC_DIR_TOKEN, mosaicDir) == -1) + { + sprintf ( message , "ERROR: Invalid token value" + " for token \"%s\".\n\tProgram exit.", + MOSAIC_DIR_TOKEN) ; + shutdown( message ); } } - sprintf(dhrmosaic_fileName, "DHRMOSAIC%sz", strDateTime); - sprintf(fileName, "DHRMOSAIC%sz", strDateTime); - writeArray(pGeoData, mosaicDir, fileName, FACTOR_PRECIP, replace_missing, - pEMPEParams->user, pRunDate->tRunTime, DHR_PROC_FLAG, Mosaic, &irc); + sprintf(dhrmosaic_fileName, "DHRMOSAIC%sz", strDateTime ); + sprintf(fileName, "DHRMOSAIC%sz", strDateTime ); + writeArray(pGeoData, mosaicDir, fileName, FACTOR_PRECIP, + replace_missing, pEMPEParams->user, pRunDate->tRunTime, + DHR_PROC_FLAG, Mosaic, &irc) ; - if (irc != 0) { - sprintf(message, "ERROR: error number = %ld" - " attempting to write file: %s/%s", irc, mosaicDir, fileName); - printLogMessage(message); - } else { - sprintf(message, "STATUS: file written to: %s/%s", mosaicDir, fileName); - printLogMessage(message); + if(irc != 0) + { + sprintf( message , "ERROR: error number = %ld" + " attempting to write file: %s/%s" , + irc, mosaicDir, fileName) ; + printLogMessage( message ); + } + else + { + sprintf( message , "STATUS: file written to: %s/%s" , + mosaicDir, fileName) ; + printLogMessage( message ); - writeFormattedXMRG(pEMPEParams, pGeoData, mosaicDir, fileName, - DHR_PROC_FLAG, SAVE_GRIB_TOKEN, SAVE_GIF_TOKEN, GIF_DIR_TOKEN, - GIF_ID_TOKEN, SAVE_NETCDF_TOKEN, NETCDF_DIR_TOKEN, - NETCDF_ID_TOKEN, SAVE_JPEG_TOKEN, Mosaic); + writeFormattedXMRG(pEMPEParams, pGeoData, + mosaicDir, fileName, DHR_PROC_FLAG, + SAVE_GRIB_TOKEN, + SAVE_GIF_TOKEN, GIF_DIR_TOKEN, GIF_ID_TOKEN, + SAVE_NETCDF_TOKEN, NETCDF_DIR_TOKEN, NETCDF_ID_TOKEN, + SAVE_JPEG_TOKEN, + Mosaic); } #if APPLY_POLYGON @@ -470,135 +534,172 @@ void runDHRMosaic(const run_date_struct * pRunDate, */ apply_mpe_polygons ( (void * )&Mosaic, - strDateTime, - year, - month, - day, - hour, - display_erMosaic, - pGeoData, - FACTOR_PRECIP, - 0, - 0 ); + strDateTime, + year, + month, + day, + hour, + display_erMosaic, + pGeoData, + FACTOR_PRECIP, + 0, + 0 ); #endif hpe_fieldgen_getAppsDefaults(SAVE_HEIGHT_TOKEN, saveflag); - if (strcmp(hpe_fieldgen_toLowerCase(saveflag), "save") == 0) { - if (first == 1) { - if (hpe_fieldgen_getAppsDefaults(HEIGHT_DIR_TOKEN, heightDir) - == -1) { - sprintf(message, "ERROR: Invalid token value" - " for token \"%s\".\n\tProgram exit.", - HEIGHT_DIR_TOKEN); - shutdown(message); - } - } + if(strcmp(hpe_fieldgen_toLowerCase(saveflag), "save") == 0) + { + if(first == 1) + { + if(hpe_fieldgen_getAppsDefaults(HEIGHT_DIR_TOKEN, heightDir) == -1) + { + sprintf ( message , "ERROR: Invalid token value" + " for token \"%s\".\n\tProgram exit.", + HEIGHT_DIR_TOKEN) ; + shutdown( message ); + } + } - sprintf(fileName, "DHRHEIGHT%sz", strDateTime); - writeArray(pGeoData, heightDir, fileName, FACTOR_OTHER, replace_missing, - pEMPEParams->user, pRunDate->tRunTime, DHR_PROC_FLAG, DHRHeight, - &irc); + sprintf(fileName, "DHRHEIGHT%sz", strDateTime ); + writeArray(pGeoData, heightDir, fileName, FACTOR_OTHER, + replace_missing, pEMPEParams->user, pRunDate->tRunTime, + DHR_PROC_FLAG, DHRHeight, &irc) ; - if (irc != 0) { - sprintf(message, "ERROR: error number = %ld" - " attempting to write file: %s/%s", irc, heightDir, - fileName); - printLogMessage(message); - } else { - sprintf(message, "STATUS: file written to: %s/%s", heightDir, - fileName); - printLogMessage(message); - } + if(irc != 0) + { + sprintf( message , "ERROR: error number = %ld" + " attempting to write file: %s/%s" , + irc, heightDir, fileName) ; + printLogMessage( message ); + } + else + { + sprintf( message , "STATUS: file written to: %s/%s" , + heightDir, fileName) ; + printLogMessage( message ); + } } hpe_fieldgen_getAppsDefaults(SAVE_INDEX_TOKEN, saveflag); - if (strcmp(hpe_fieldgen_toLowerCase(saveflag), "save") == 0) { - if (first == 1) { - if (hpe_fieldgen_getAppsDefaults(INDEX_DIR_TOKEN, indexDir) == -1) { - sprintf(message, "ERROR: Invalid token value" - " for token \"%s\".\n\tProgram exit.", INDEX_DIR_TOKEN); - shutdown(message); - } - } + if(strcmp(hpe_fieldgen_toLowerCase(saveflag), "save") == 0) + { + if(first == 1) + { + if(hpe_fieldgen_getAppsDefaults(INDEX_DIR_TOKEN, indexDir) == -1) + { + sprintf ( message , "ERROR: Invalid token value" + " for token \"%s\".\n\tProgram exit.", + INDEX_DIR_TOKEN) ; + shutdown( message ); + } + } - sprintf(fileName, "DHRINDEX%sz", strDateTime); + sprintf(fileName, "DHRINDEX%sz", strDateTime ); - /* - * * fill in tempID array - */ + /* + * fill in tempID array + */ - for (i = 0; i < rowSize; i++) { - for (j = 0; j < colSize; j++) { - tempID[i][j] = (double) ID[i][j]; - } - } + for(i = 0; i < rowSize; i ++) + { + for(j = 0; j < colSize; j ++) + { + tempID[i][j] = (double)ID[i][j] ; + } + } - writeArray(pGeoData, indexDir, fileName, FACTOR_OTHER, replace_missing, - pEMPEParams->user, pRunDate->tRunTime, DHR_PROC_FLAG, tempID, - &irc); + writeArray(pGeoData, indexDir, fileName, FACTOR_OTHER, + replace_missing, pEMPEParams->user, pRunDate->tRunTime, + DHR_PROC_FLAG, tempID, &irc) ; - if (irc != 0) { - sprintf(message, "ERROR: error number = %ld" - " attempting to write file: %s/%s", irc, indexDir, - fileName); - printLogMessage(message); - } else { - sprintf(message, "STATUS: file written to: %s/%s", indexDir, - fileName); - printLogMessage(message); - } + if(irc != 0) + { + sprintf( message , "ERROR: error number = %ld" + " attempting to write file: %s/%s" , + irc, indexDir, fileName) ; + printLogMessage( message ); + } + else + { + sprintf( message, "STATUS: file written to: %s/%s" , + indexDir, fileName) ; + printLogMessage( message ); + } } - hpe_fieldgen_getCurrentTime(currTime); - sprintf(message, "%s = time end writing DHRMOSAIC fields to flat files.", - currTime); - printLogMessage(message); + hpe_fieldgen_getCurrentTime(currTime) ; + sprintf( message, "%s = time end writing DHRMOSAIC fields to flat files." , + currTime) ; + hpe_fieldgen_printMessage( message ); - sprintf(message, - "\nSTATUS:In DHRMOSAIC - insert/update HPERadarResult table"); - printLogMessage(message); - - wrtodb_HPERadarResult(dhrmosaic_fileName, prdDateTime, pEMPEParams, - dualpol_used, nobias_flag); - - sprintf(message, - "\nSTATUS:In DHRMOSAIC - complete insert/update HPERadarResult table"); - printLogMessage(message); + /* check dual_pol_flag */ + if (dualpol_on_flag == 0) + dualpol_used = 0; + else + { + for (i = 0; i < pRadarLocTable->radarNum; i++) + { + if (dualpol_data_avail[i] != 0) + { + dualpol_used = 1; + break; + } + else + dualpol_used = 0; + } + } + + sprintf ( message , "\nSTATUS: In DHRMOSAIC, the flag dualpol_used = %d\n", dualpol_used); + printLogMessage( message ); + + sprintf ( message , "\nSTATUS: In DHRMOSAIC, insert/update HPERadarResult table"); + printLogMessage( message ); + + wrtodb_HPERadarResult(dhrmosaic_fileName, prdDateTime, pEMPEParams, dualpol_used, nobias_flag); + sprintf ( message , "\nSTATUS: In DHRMOSAIC, complete insert/update HPERadarResult table"); + printLogMessage( message ); + /* * run the nowcast */ - if (pEMPEParams->blnRunNowcast == 1) { + if (pEMPEParams->blnRunNowcast == 1) + { const char * mosaicID = "DHR"; runNowcast(pGeoData, pRunDate->tRunTime, mosaicID, pEMPEParams, mosaicDir, Mosaic, dualpol_used); } + - freeMosaicArray(pGeoData, RADAR_ROWS); + freeMosaicArray(pGeoData, RADAR_ROWS) ; - if (pRadarResult != NULL) { + if(pRadarResult != NULL) + { free(pRadarResult); pRadarResult = NULL; } - if (pDAARadarResult != NULL) { + if (pDAARadarResult != NULL) + { free(pDAARadarResult); pDAARadarResult = NULL; - } + } first = 0; } static void initMosaicArray(const geo_data_struct * pGeoData, - const int radar_rows, const int radar_cols) { + const int radar_rows, + const int radar_cols) +{ - const int rowSize = pGeoData->num_rows; - const int colSize = pGeoData->num_cols; + const int rowSize = pGeoData->num_rows ; + const int colSize = pGeoData->num_cols ; - DHRHeight = init2DDoubleArray(HEIGHT_DEFAULT, rowSize, colSize); + DHRHeight = init2DDoubleArray(HEIGHT_DEFAULT, rowSize, colSize ); - tempID = init2DDoubleArray(ID_DEFAULT, rowSize, colSize); + tempID = init2DDoubleArray(ID_DEFAULT, rowSize, colSize ); origRadar = init2DFloatArray(RADAR_DEFAULT, NUM_DHR_ROWS, NUM_DHR_COLS); @@ -610,19 +711,20 @@ static void initMosaicArray(const geo_data_struct * pGeoData, } static void freeMosaicArray(const geo_data_struct * pGeoData, - const int radar_rows) { - const int rowSize = pGeoData->num_rows; + const int radar_rows) +{ + const int rowSize = pGeoData->num_rows ; - free2DDoubleArray(DHRHeight, rowSize); + free2DDoubleArray(DHRHeight, rowSize ); - free2DDoubleArray(tempID, rowSize); + free2DDoubleArray(tempID, rowSize ); - free2DFloatArray(origRadar, NUM_DHR_ROWS); + free2DFloatArray(origRadar, NUM_DHR_ROWS ); - free2DFloatArray(currRadar, radar_rows); + free2DFloatArray(currRadar, radar_rows ); - free2DShortArray(hrapMiscBins, NUM_DPA_ROWS); + free2DShortArray(hrapMiscBins, NUM_DPA_ROWS ); - free2DShortArray(currMiscBins, radar_rows); + free2DShortArray(currMiscBins, radar_rows ); } diff --git a/nativeLib/rary.ohd.pproc/src/hpe_fieldgen/TEXT/run_ermosaic.c b/nativeLib/rary.ohd.pproc/src/hpe_fieldgen/TEXT/run_ermosaic.c index 1a2804828b..e7f5cccfff 100644 --- a/nativeLib/rary.ohd.pproc/src/hpe_fieldgen/TEXT/run_ermosaic.c +++ b/nativeLib/rary.ohd.pproc/src/hpe_fieldgen/TEXT/run_ermosaic.c @@ -1,138 +1,148 @@ /*********************************************************************** - * Filename: run_ermosaic.c - * - * Original Author: Guoxian Zhou - * - * File Creation Date: 08/21/2006 - * - * Development Group: HSEB/OHD - * - * Description: - * compute the raw DSP radar mosaic data - * - * Modules: - * runERMosaic - * - ***********************************************************************/ +* Filename: run_ermosaic.c +* +* Original Author: Guoxian Zhou +* +* File Creation Date: 08/21/2006 +* +* Development Group: HSEB/OHD +* +* Description: +* compute the raw DSP radar mosaic data +* +* Modules: +* runERMosaic +* +***********************************************************************/ /* Include files, definitions, globals go here. */ #include "empe_fieldgen.h" /*********************************************************************** - * Module Name: runERMosaic - * - * Original Author: Guoxian Zhou - * - * Module Creation Date: 08/21/2006 - * - * Description: - * This function computes the raw DSP radar mosaic data. - * - * Calling Arguments: - * Name Input/Output Type Description - * - * pRunDate Input const run_date_struct * date/time - * pGeoData Input const geo_data_struct * - * global HRAP lowerleft-corner - * bin and dimension and dimension - * of the RFC estimation domain - * pMPEParams Input/Output mpe_params_struct * - * static parameters - * pRadarLocRecord Input const radarLoc_table_struct * - * info from radarLoc table - * meanFieldBias Output double ** the mean field bias value - * computed for each radar. - * - * ID Output int ** the mosaic id array of radars. - * - * RMosaic Output double ** the raw dsp mosaic. - * QPEMosaic Output double ** the best estimate mosaic - * - * Required - * None - * - * Required Files/Databases: - * None - * - * Non System Routines Called: - * readRadarLoc, readRadarResult , readMisc, getMeanBias, - * writeRadarResult, createMosaic, checkMultisensorQC, writeArray - * - * Return Value: - * Type Description - * None - * - * Error Codes/Exceptions: - * - * - * OS Specific Assumptions: - * None - * - * Local Variables: - * Name Type Description - * - * Modification History: - * Date Developer Action - * C. R. Kondragunta Original FORTRAN code - * March 2005 Guoxian Zhou convert to C Language - * 9/06/2006 Guoxian Zhou Modify for empe dsp mosaic - * 12/2012 Jingtao Deng Modify for adding dual pol producat DSA - * first try to find the DSA product from dsaradar - * table and calculate the 1 hour precipitation. if - * not able to get DSA product, then use DSP product - * 02/2015 JingtaoD A2 OB14.4.1 DR#17123 - HPE Bias Source field - * 09/2015 JingtaoD A2 OB16.2.1 DR#17860 - HPE DualPol Mean field bias - ***********************************************************************/ +* Module Name: runERMosaic +* +* Original Author: Guoxian Zhou +* +* Module Creation Date: 08/21/2006 +* +* Description: +* This function computes the raw DSP radar mosaic data. +* +* Calling Arguments: +* Name Input/Output Type Description +* +* pRunDate Input const run_date_struct * date/time +* pGeoData Input const geo_data_struct * +* global HRAP lowerleft-corner +* bin and dimension and dimension +* of the RFC estimation domain +* pMPEParams Input/Output mpe_params_struct * +* static parameters +* pRadarLocRecord Input const radarLoc_table_struct * +* info from radarLoc table +* meanFieldBias Output double ** the mean field bias value +* computed for each radar. +* +* ID Output int ** the mosaic id array of radars. +* +* RMosaic Output double ** the raw dsp mosaic. +* QPEMosaic Output double ** the best estimate mosaic +* +* Required +* None +* +* Required Files/Databases: +* None +* +* Non System Routines Called: +* readRadarLoc, readRadarResult , readMisc, getMeanBias, +* writeRadarResult, createMosaic, checkMultisensorQC, writeArray +* +* Return Value: +* Type Description +* None +* +* Error Codes/Exceptions: +* +* +* OS Specific Assumptions: +* None +* +* Local Variables: +* Name Type Description +* +* Modification History: +* Date Developer Action +* C. R. Kondragunta Original FORTRAN code +* March 2005 Guoxian Zhou convert to C Language +* 9/06/2006 Guoxian Zhou Modify for empe dsp mosaic +* 12/2012 Jingtao Deng Modify for adding dual pol producat DSA +* first try to find the DSA product from dsaradar +* table and calculate the 1 hour precipitation. if +* not able to get DSA product, then use DSP product +* 02/2015 JingtaoD A2 OB14.4.1 DR#17123 - HPE Bias Source field +***********************************************************************/ -extern short ** radarMiscBins; +extern short ** radarMiscBins ; + +static double ** MHeight = NULL ; +static double ** tempID = NULL ; +static float ** origRadar = NULL; +static float ** currRadar = NULL ; +static short ** hrapMiscBins = NULL ; +static short ** currMiscBins = NULL ; -static double ** MHeight = NULL; -static double ** tempID = NULL; -static float ** origRadar = NULL; -static float ** currRadar = NULL; -static short ** hrapMiscBins = NULL; -static short ** currMiscBins = NULL; // Added by Ram for the average and max mosaic calculation // --------------------------- -extern double ** MaxMosaic; -extern double ** AvgMosaic; -extern int ** AvgMosaicNumRadars; +extern double ** MaxMosaic; +extern double ** AvgMosaic; +extern int ** AvgMosaicNumRadars; +extern double ** P3Mosaic; // -------------------------- + extern int dualpol_used; extern int dualpol_on_flag; +extern void set_best_estimate_p3(); static void initMosaicArray(const geo_data_struct * pGeoData, - const int grid_rows, const int grid_cols); + const int grid_rows, + const int grid_cols) ; static void freeMosaicArray(const geo_data_struct * pGeoData, - const int grid_rows); + const int grid_rows) ; void runERMosaic(const run_date_struct * pRunDate, - const geo_data_struct * pGeoData, empe_params_struct * pEMPEParams, - const radarLoc_table_struct * pRadarLocTable, - const gage_table_struct * pGageTable, - const gage_table_struct * pGageTableP3, - const gage_table_struct * pQCGageTable, double * meanFieldBias, - double ** RadarBeamHeight, int ** ID, double ** RMosaic, - double ** QPEMosaic, int * blnMosaic) { - const int rowSize = pGeoData->num_rows; - const int colSize = pGeoData->num_cols; - const int replace_missing = 0; + const geo_data_struct * pGeoData, + empe_params_struct * pEMPEParams, + const radarLoc_table_struct * pRadarLocTable , + const gage_table_struct * pGageTable, + const gage_table_struct * pGageTableP3, + const gage_table_struct * pQCGageTable, + double * meanFieldBias, + double ** RadarBeamHeight, + int ** ID, + double ** RMosaic, + double ** QPEMosaic, + int * blnMosaic) +{ + const int rowSize = pGeoData->num_rows ; + const int colSize = pGeoData->num_cols ; + const int replace_missing = 0 ; - const int GRID_ROWS = NUM_DPA_ROWS * pEMPEParams->hrap_grid_factor; - const int GRID_COLS = NUM_DPA_COLS * pEMPEParams->hrap_grid_factor; + const int GRID_ROWS = NUM_DPA_ROWS * pEMPEParams->hrap_grid_factor ; + const int GRID_COLS = NUM_DPA_COLS * pEMPEParams->hrap_grid_factor ; - const char * MOSAIC_DIR_TOKEN = "hpe_ermosaic_dir"; - const char * AVG_ERMOSAIC_DIR_TOKEN = "hpe_avg_ermosaic_dir"; - const char * MAX_ERMOSAIC_DIR_TOKEN = "hpe_max_ermosaic_dir"; + const char * MOSAIC_DIR_TOKEN = "hpe_ermosaic_dir"; + const char * AVG_ERMOSAIC_DIR_TOKEN = "hpe_avg_ermosaic_dir"; + const char * MAX_ERMOSAIC_DIR_TOKEN = "hpe_max_ermosaic_dir"; const char * SAVE_HEIGHT_TOKEN = "hpe_save_dspheight"; const char * HEIGHT_DIR_TOKEN = "hpe_dspheight_dir"; - const char * SAVE_INDEX_TOKEN = "hpe_save_dspindex"; - const char * INDEX_DIR_TOKEN = "hpe_dspindex_dir"; + const char * SAVE_INDEX_TOKEN = "hpe_save_dspindex"; + const char * INDEX_DIR_TOKEN = "hpe_dspindex_dir"; const char * SAVE_GRIB_TOKEN = "ermosaic_save_grib"; @@ -148,66 +158,69 @@ void runERMosaic(const run_date_struct * pRunDate, double ** pMosaic = NULL; - char saveflag[TOKEN_LEN] = { '\0' }; + char saveflag[TOKEN_LEN]= {'\0'}; - static char datetime[ANSI_YEARSEC_TIME_LEN + 1] = { '\0' }; - static char strDateTime[ANSI_YEARSEC_TIME_LEN + 1] = { '\0' }; - static char prdDateTime[ANSI_YEARSEC_TIME_LEN + 1] = { '\0' }; - static char datehour[ANSI_YEARSEC_TIME_LEN + 1] = { '\0' }; - static char radarID[RADAR_ID_LEN + 1] = { '\0' }; - register int i = 0, j, k, l; - int gageRadarPairNum = 0; /* number of positive gage/radar pairs */ + static char datetime[ANSI_YEARSEC_TIME_LEN + 1] = {'\0'} ; + static char strDateTime[ANSI_YEARSEC_TIME_LEN + 1] = {'\0'} ; + static char prdDateTime[ANSI_YEARSEC_TIME_LEN + 1] = {'\0'} ; + static char datehour[ANSI_YEARSEC_TIME_LEN + 1] = {'\0'} ; + static char radarID[ RADAR_ID_LEN + 1] = {'\0'} ; + register int i = 0, j, k, l; + int gageRadarPairNum = 0 ; /* number of positive gage/radar pairs */ + + long int irc ; - long int irc; int radarAvailFlag = 0; + int dp_blnEditBias, sp_blnEditBias ; + int dp_blnIgnoreRadar, sp_blnIgnoreRadar ; register int year, month, day, hour; - int dp_blnEditBias, sp_blnEditBias; - double dp_editBiasValue, sp_editBiasValue; - int dp_blnIgnoreRadar, sp_blnIgnoreRadar; + double dp_editBiasValue = 0.0, sp_editBiasValue= 0.0 ; + double memSpanBias ; + double meanBias = 0.0 ; - double memSpanBias; - double meanBias = 0.0; + static char fileName[PATH_LEN] = {'\0'} ; + static char ermosaic_fileName[PRESET_DESCR_LEN] = {'\0'} ; + static char heightDir[PATH_LEN] = {'\0'} ; + static char indexDir[PATH_LEN] = {'\0'} ; + static char mosaicDir[PATH_LEN] = {'\0'} ; + static char avgRMosaicDir[PATH_LEN] = {'\0'} ; + static char maxRMosaicDir[PATH_LEN] = {'\0'} ; - static char fileName[PATH_LEN] = { '\0' }; - static char ermosaic_fileName[PRESET_DESCR_LEN] = { '\0' }; - static char heightDir[PATH_LEN] = { '\0' }; - static char indexDir[PATH_LEN] = { '\0' }; - static char mosaicDir[PATH_LEN] = { '\0' }; - static char avgRMosaicDir[PATH_LEN] = { '\0' }; - static char maxRMosaicDir[PATH_LEN] = { '\0' }; - - static int first = 1; + static int first = 1 ; struct tm * pRunTime = NULL; - short pps_radar_count, dp_radar_count; - int index; - - int dualpol_meanbias_flag[MAX_RADAR_NUM]; - int sp_meanbias_flag[MAX_RADAR_NUM]; - int dualpol_data_avail[MAX_RADAR_NUM]; + short pps_radar_count, dp_radar_count ; + int index ; + + int dualpol_meanbias_flag[MAX_RADAR_NUM]; + int sp_meanbias_flag[MAX_RADAR_NUM]; + int dualpol_data_avail[MAX_RADAR_NUM]; int nobias_flag; /*ERMOSAIC product has no bias applied */ nobias_flag = 1; - + /* initialize no dualpol MFB and no dual pol product avialble for each radar */ - for (i = 0; i < MAX_RADAR_NUM; i++) { - dualpol_meanbias_flag[i] = 0; - sp_meanbias_flag[i] = 0; - dualpol_data_avail[i] = 0; + for (i = 0; i < MAX_RADAR_NUM; i++) + { + dualpol_meanbias_flag[i] = 0; + sp_meanbias_flag[i] = 0; + dualpol_data_avail[i] = 0; } - - pEMPEParams->radar_avail_num = 0; + + pEMPEParams->radar_avail_num = 0 ; // Additional check added by Ram to see if any of the Radar mosaics are // to be calculated. if not we abort here // --------------------- - if (blnMosaic[ermosaic] == 0 && blnMosaic[avgermosaic] == 0 - && blnMosaic[maxermosaic] == 0) { - sprintf(message, "\nErroneous call to ERMosaic\n"); - printLogMessage(message); + if(blnMosaic[ermosaic] == 0 && + blnMosaic[avgermosaic] == 0 && + blnMosaic[maxermosaic] == 0) + { + sprintf ( message , "\nErroneous call to ERMosaic\n"); + printLogMessage( message ); return; } @@ -216,266 +229,357 @@ void runERMosaic(const run_date_struct * pRunDate, * based on the geo grid size data. */ - initMosaicArray(pGeoData, GRID_ROWS, GRID_COLS); + initMosaicArray(pGeoData, GRID_ROWS, GRID_COLS) ; /* * strDateTime string should be in format: yyyymmddHHMM */ - pRunTime = gmtime(&(pRunDate->tRunTime)); - strftime(datetime, ANSI_YEARSEC_TIME_LEN + 1, "%Y-%m-%d %H:%M:00", - pRunTime); - strftime(datehour, ANSI_YEARSEC_TIME_LEN + 1, "%Y-%m-%d %H:00:00", - pRunTime); - strftime(strDateTime, ANSI_YEARSEC_TIME_LEN + 1, "%Y%m%d%H%M", pRunTime); - strftime(prdDateTime, ANSI_YEARSEC_TIME_LEN + 1, "%Y-%m-%d %H:%M:%S", - pRunTime); + pRunTime = gmtime(&(pRunDate->tRunTime)) ; + strftime ( datetime, ANSI_YEARSEC_TIME_LEN + 1, + "%Y-%m-%d %H:%M:00", pRunTime ) ; + strftime ( datehour, ANSI_YEARSEC_TIME_LEN + 1, + "%Y-%m-%d %H:00:00", pRunTime ) ; + strftime(strDateTime, ANSI_YEARSEC_TIME_LEN + 1, + "%Y%m%d%H%M", pRunTime); + strftime(prdDateTime, ANSI_YEARSEC_TIME_LEN + 1, + "%Y-%m-%d %H:%M:%S", pRunTime); year = pRunTime->tm_year + 1900; month = pRunTime->tm_mon + 1; day = pRunTime->tm_mday; hour = pRunTime->tm_hour; - hpe_fieldgen_getCurrentTime(currTime); - sprintf(message, "%s = time begin ERMOSAIC calculation.", currTime); - hpe_fieldgen_printMessage(message); + hpe_fieldgen_getCurrentTime(currTime) ; + sprintf( message , "%s = time begin ERMOSAIC calculation." , + currTime) ; + hpe_fieldgen_printMessage( message ); + + sprintf ( message , "STATUS: In runERMosaic - Dual pol product flag is %d.", dualpol_on_flag) ; + printLogMessage( message ); /* for single pol product which use rwradarresult table */ radar_result_struct * pRadarResult = NULL; - pRadarResult = (radar_result_struct *) malloc( - pRadarLocTable->radarNum * sizeof(radar_result_struct)); - if (pRadarResult == NULL) { - sprintf(message, "ERROR: memory allocation failure" - " in runRMosaic function." - "\n\tProgram exit."); - shutdown(message); + pRadarResult = (radar_result_struct *) + malloc(pRadarLocTable->radarNum * sizeof(radar_result_struct)); + if(pRadarResult == NULL) + { + sprintf ( message , "ERROR: memory allocation failure" + " in runRMosaic function." + "\n\tProgram exit.") ; + shutdown( message ); } - - /* for dual pol proudcts which use daaradarresult table */ + + /* for dual pol proudcts which use daaradarresult table */ radar_result_struct * pDAARadarResult = NULL; - - pDAARadarResult = (radar_result_struct *) malloc( - pRadarLocTable->radarNum * sizeof(radar_result_struct)); - if (pDAARadarResult == NULL) { - sprintf(message, "ERROR: memory allocation failure" - " in runRMosaic function." - "\n\tProgram exit."); - shutdown(message); + + pDAARadarResult = (radar_result_struct *) + malloc(pRadarLocTable->radarNum * sizeof(radar_result_struct)); + if(pDAARadarResult == NULL) + { + sprintf ( message , "ERROR: memory allocation failure" + " in runRMosaic function." + "\n\tProgram exit.") ; + shutdown( message ); } - for (i = 0; i < pRadarLocTable->radarNum; i++) { - memset(pRadarResult[i].radID, '\0', RADAR_ID_LEN + 1); - pRadarResult[i].ignore_radar = 0; + for(i = 0; i < pRadarLocTable->radarNum; i++ ) + { + memset(pRadarResult[i].radID, '\0', RADAR_ID_LEN + 1) ; pRadarResult[i].edit_bias = 0; - pRadarResult[i].bias = 0.0; - memset(pDAARadarResult[i].radID, '\0', RADAR_ID_LEN + 1); - pDAARadarResult[i].ignore_radar = 0; + pRadarResult[i].ignore_radar = 0; + pRadarResult[i].bias = 0.0 ; + + memset(pDAARadarResult[i].radID, '\0', RADAR_ID_LEN + 1) ; pDAARadarResult[i].edit_bias = 0; - pDAARadarResult[i].bias = 0.0; + pDAARadarResult[i].ignore_radar = 0; + pDAARadarResult[i].bias = 0.0 ; } /* * Read the edit bias flag, edited bias, ignore radar flag - * from RWRadarResult table for the top hour for Single Pol, from DAARadarResult table for DualPol + * from RWRadarResult table for the top hour */ - if (dualpol_on_flag == 0) { - readRadarResult(datehour, pRadarResult, &pps_radar_count, - sp_meanbias_flag, &irc); /* for single pol */ - if (irc < 0) { - sprintf(message, - "ERROR: In runERMosaic - Database error #%ld attempting to " - "select record from RWRadarResult table.", irc); - printLogMessage(message); + /* when dualpol_on_flag is set as zero, no any dual pol products will be used even + though they are available. Only single pol radar producats are used. This keeps the old + functionality */ + if (dualpol_on_flag == 0) + { + readRadarResult (datehour, pRadarResult, &pps_radar_count, sp_meanbias_flag, &irc) ; /* for single pol */ + if (irc < 0) + { + sprintf ( message , "ERROR: In runERMosaic - Database error #%ld attempting to " + "select record from RWRadarResult table.", irc) ; + printLogMessage( message ); } - } else { - readDAARadarResult(datehour, pDAARadarResult, &dp_radar_count, - dualpol_meanbias_flag, &irc); /* for dual pol */ - - if (irc < 0) { - sprintf(message, - "ERROR: In runERMosaic - Database error #%ld attempting to " - "select record from DAARadarResult table.", irc); - hpe_fieldgen_printMessage(message); - } - } + + } + /* Able to use dual pol products if available for this radar, if not available for this radar, use the single + pol product */ + else + { + readDAARadarResult (datehour, pDAARadarResult, &dp_radar_count, dualpol_meanbias_flag, &irc) ; /* for dual pol */ + + if (irc < 0 || dp_radar_count <= 0) + { + if (irc < 0) + { + sprintf ( message , "ERROR: In runERMosaic - Database error #%ld attempting to " + "select record from DAARadarResult table. Try RWRadarResult table.", irc) ; + hpe_fieldgen_printMessage( message ); + } + + else if (dp_radar_count <= 0) + { + sprintf ( message , "STATUS: in RunERMosaic - No data found for radar " + "from DAARadarResult table, then select data from RWRadarResult table.") ; + hpe_fieldgen_printMessage( message ); + } + } + readRadarResult (datehour, pRadarResult, &pps_radar_count, sp_meanbias_flag, &irc) ; /* for single pol */ + if (irc < 0) + { + sprintf ( message , "ERROR: in RunERMosaic - Database error #%ld attempting to " + "select record from RWRadarResult table.", irc) ; + printLogMessage( message ); + } + + } /* * Read the misbin information if the token hpe_load_misbin is ON, * otherwise the misbin will be default value(1). * Do this only once per EMPE_fieldgen run. */ - if (radarMiscBins == NULL) { + if ( radarMiscBins == NULL ) + { radarMiscBins = init2DShortArray(MISBIN_DEFAULT, - pRadarLocTable->radarNum, NUM_DPA_ELEMENTS); + pRadarLocTable->radarNum, + NUM_DPA_ELEMENTS ); - if (pEMPEParams->load_misbin == 1) { - readMisc(pRadarLocTable, radarMiscBins); + if(pEMPEParams->load_misbin == 1) + { + readMisc ( pRadarLocTable, radarMiscBins ) ; } } - + /* * begin loop on radars */ - for (i = 0; i < pRadarLocTable->radarNum; i++) { - meanFieldBias[i] = 0.0; + for(i = 0; i < pRadarLocTable->radarNum; i++ ) + { + meanFieldBias[i] = 0.0 ; - strcpy(radarID, pRadarLocTable->ptrRadarLocRecords[i].radarID); + strcpy(radarID, pRadarLocTable->ptrRadarLocRecords[i].radarID) ; - sprintf(message, "\n******* radar: %s *******", radarID); - hpe_fieldgen_printMessage(message); + sprintf ( message , "\n******* radar: %s *******", radarID); + hpe_fieldgen_printMessage( message ); /* * initialize edit bias flag, ignore radar flag */ - radar_result_struct * dp_pRadarInfo = NULL; - radar_result_struct * sp_pRadarInfo = NULL; - /* - * initialize edit bias flag, ignore radar flag - */ - dp_blnEditBias = 0; - dp_editBiasValue = 0.0; - dp_blnIgnoreRadar = 0; - sp_blnEditBias = 0; - sp_editBiasValue = 0.0; - sp_blnIgnoreRadar = 0; + dp_blnEditBias = 0 ; + dp_blnIgnoreRadar = 0 ; + dp_editBiasValue = 0.0 ; + sp_blnEditBias = 0 ; + sp_blnIgnoreRadar = 0 ; + sp_editBiasValue = 0.0 ; - if (pDAARadarResult != NULL) { - dp_pRadarInfo = (radar_result_struct *) binary_search( - pDAARadarResult, radarID, dp_radar_count, - sizeof(radar_result_struct), compare_radar_id); + radar_result_struct * dp_pRadarInfo = NULL ; + radar_result_struct * sp_pRadarInfo = NULL ; - if (dp_pRadarInfo != NULL) { - dp_blnIgnoreRadar = dp_pRadarInfo->ignore_radar; - dp_editBiasValue = dp_pRadarInfo->bias; - dp_blnEditBias = dp_pRadarInfo->edit_bias; + /* Try dual-pol first from DAARadarResult table first, not available, then use + single-pol RWRadarResult table */ + + if (dp_radar_count > 0) + { + dp_pRadarInfo = (radar_result_struct *) + binary_search ( pDAARadarResult, radarID, dp_radar_count, + sizeof ( radar_result_struct), compare_radar_id ); + if ( dp_pRadarInfo != NULL ) + { + dp_editBiasValue = dp_pRadarInfo->bias; + dp_blnEditBias = dp_pRadarInfo->edit_bias; + dp_blnIgnoreRadar = dp_pRadarInfo->ignore_radar; } } - if (pRadarResult != NULL) { - sp_pRadarInfo = (radar_result_struct *) binary_search(pRadarResult, - radarID, pps_radar_count, sizeof(radar_result_struct), - compare_radar_id); - - if (sp_pRadarInfo != NULL) { - sp_blnIgnoreRadar = sp_pRadarInfo->ignore_radar; - sp_editBiasValue = sp_pRadarInfo->bias; - sp_blnEditBias = sp_pRadarInfo->edit_bias; - } - } + sp_pRadarInfo = (radar_result_struct *) + binary_search ( pRadarResult, radarID, pps_radar_count, + sizeof ( radar_result_struct), compare_radar_id ); + if ( sp_pRadarInfo != NULL ) + { + sp_editBiasValue = sp_pRadarInfo->bias; + sp_blnEditBias = sp_pRadarInfo->edit_bias; + sp_blnIgnoreRadar = sp_pRadarInfo->ignore_radar; + } /* * Read in gridded radar data * count number of available radars * an "ignored" radar is considered "not available" */ - - if (dualpol_on_flag == 1) { + + /* read the DSA gridded data first, if not available, then use DSP data */ + if (dualpol_on_flag == 1) + { readDSARadar(radarID, datetime, pEMPEParams->dsp_window, - pEMPEParams->dsp_duration, dp_blnIgnoreRadar, origRadar, - &radarAvailFlag); + pEMPEParams->dsp_duration, dp_blnIgnoreRadar, + origRadar, &radarAvailFlag); - if (radarAvailFlag > 0) { - sprintf(message, - "STATUS: In runERMosaic - dual pol product DSA is used for radar %s", - radarID); - hpe_fieldgen_printMessage(message); - dualpol_data_avail[i] = 1; - } - } else { - readDSPRadar(radarID, datetime, pEMPEParams->dsp_window, - pEMPEParams->dsp_duration, sp_blnIgnoreRadar, origRadar, - &radarAvailFlag); + if (radarAvailFlag > 0) + { + sprintf ( message , "STATUS: In runERMosaic - dual pol product DSA is used for radar %s", radarID); + hpe_fieldgen_printMessage( message ); + dualpol_data_avail[i] = 1; + + } + else + { + readDSPRadar(radarID, datetime, pEMPEParams->dsp_window, + pEMPEParams->dsp_duration, sp_blnIgnoreRadar, + origRadar, &radarAvailFlag); - if (radarAvailFlag > 0) { - sprintf(message, - "STATUS: In runERMosaic - single pol product DSP is used for radar %s", - radarID); - hpe_fieldgen_printMessage(message); - dualpol_data_avail[i] = 0; - } - } - - if (radarAvailFlag > 0) { - pEMPEParams->radar_avail_num++; + dualpol_data_avail[i] = 0; + + if (radarAvailFlag > 0) + { + sprintf ( message , "STATUS: In runERMosaic - single pol product DSP is used for radar %s", radarID); + hpe_fieldgen_printMessage( message ); + } + } + } + else + { + readDSPRadar(radarID, datetime, pEMPEParams->dsp_window, + pEMPEParams->dsp_duration, sp_blnIgnoreRadar, + origRadar, &radarAvailFlag); + + dualpol_data_avail[i] = 0; + + if (radarAvailFlag > 0) + { + sprintf ( message , "STATUS: In runERMosaic - single pol product DSP is used for radar %s", radarID); + hpe_fieldgen_printMessage( message ); + } + } + + + if(radarAvailFlag > 0) + { + pEMPEParams->radar_avail_num ++ ; } + sprintf ( message , "STATUS: In runERMosaic - the dualpol_data_avail flag is %d for radarID %s", dualpol_data_avail[i], radarID); + hpe_fieldgen_printMessage( message ); /* * Convert radar array to current hrap grid */ - convertFloatArray(NUM_DSP_ROWS, NUM_DSP_COLS, origRadar, RADAR_DEFAULT, - GRID_ROWS, GRID_COLS, currRadar); + convertFloatArray(NUM_DSP_ROWS, + NUM_DSP_COLS, + origRadar, + RADAR_DEFAULT, + GRID_ROWS, + GRID_COLS, + currRadar ); /* * pick up the misbin for current running radar and * convert it to current hrap grid */ - for (j = 0; j < NUM_DPA_ROWS; j++) { - for (k = 0; k < NUM_DPA_COLS; k++) { + for(j = 0; j < NUM_DPA_ROWS; j ++) + { + for(k = 0; k < NUM_DPA_COLS; k ++) + { index = j * NUM_DPA_COLS + k; - hrapMiscBins[j][k] = radarMiscBins[i][index]; + hrapMiscBins[j][k] = radarMiscBins[i][index]; } } - convertShortArray(NUM_DPA_ROWS, NUM_DPA_COLS, hrapMiscBins, - MISBIN_DEFAULT, GRID_ROWS, GRID_COLS, currMiscBins); + convertShortArray(NUM_DPA_ROWS, + NUM_DPA_COLS, + hrapMiscBins, + MISBIN_DEFAULT, + GRID_ROWS, + GRID_COLS, + currMiscBins ); /* * get mean field bias if it is set to "ON" */ - if (pEMPEParams->blnMeanFieldBias == 1) { + if(pEMPEParams->blnMeanFieldBias == 1) + { + /* * load the mean field bias value * and save it to meanFieldBias[i] + * use DAABiasDyn table to load mean field bias for dual pol product, if not available + * use RWBiasDyn table to load mean field bias for PPS product */ - getMeanBias(&(pRadarLocTable->ptrRadarLocRecords[i]), datetime, - GRID_ROWS, GRID_COLS, currMiscBins, currRadar, pGeoData, - pGageTable, pEMPEParams, dualpol_data_avail[i], &meanBias, - &memSpanBias, &gageRadarPairNum); + getMeanBias(&(pRadarLocTable->ptrRadarLocRecords[i]), + datetime, GRID_ROWS, GRID_COLS, + currMiscBins, currRadar, + pGeoData, pGageTable, pEMPEParams, dualpol_data_avail[i], + &meanBias, &memSpanBias, &gageRadarPairNum ) ; - meanFieldBias[i] = meanBias; + meanFieldBias[i] = meanBias ; - if (dualpol_on_flag == 1 && dp_blnEditBias == 1) { - sprintf(message, - "STATUS:In runDHRMosaic - Edited Bias is used for radar %s", - radarID); - hpe_fieldgen_printMessage(message); - meanFieldBias[i] = dp_editBiasValue; - } else if (dualpol_on_flag == 0 && sp_blnEditBias == 1) { - sprintf(message, - "STATUS:In runDHRMosaic - Edited Bias is used for radar %s", - radarID); - hpe_fieldgen_printMessage(message); - meanFieldBias[i] = sp_editBiasValue; - } - - } - - sprintf(message, "\nSTATUS: In runERMosaic - MFB is %f for radid %s.", - meanFieldBias[i], radarID); - hpe_fieldgen_printMessage(message); + /* + * if blnEditBias = 1, then use edited bias value + */ + if(dualpol_data_avail[i] == 1) + { + if(dp_blnEditBias == 1) + { + meanFieldBias[i] = dp_editBiasValue ; + sprintf ( message , "STATUS: in runERMosaic - Edited bias value = %4.2f used.", + dp_editBiasValue); + hpe_fieldgen_printMessage( message ); + } + } + else + { + if(sp_blnEditBias == 1) + { + meanFieldBias[i] = sp_editBiasValue ; + sprintf ( message , "STATUS: in runERMosaic - Edited bias value = %4.2f used.", + sp_editBiasValue); + hpe_fieldgen_printMessage( message ); + } + } + + + } /*end of ptrEMPEParams->blnMeanFieldBias == 1 */ + + sprintf( message , "STATUS: In runERMosaic - MFB is %f for radid %s." , + meanFieldBias[i], radarID) ; + hpe_fieldgen_printMessage( message ); + /* * mosaicking algorithm */ - createMosaic(&(pRadarLocTable->ptrRadarLocRecords[i]), GRID_ROWS, - GRID_COLS, currRadar, currMiscBins, pGeoData, i + 1, - RadarBeamHeight, RMosaic, MHeight, ID, MaxMosaic, AvgMosaic, - AvgMosaicNumRadars, blnMosaic); + createMosaic(&(pRadarLocTable->ptrRadarLocRecords[i]), + GRID_ROWS, GRID_COLS, + currRadar, currMiscBins, pGeoData, i+1, + RadarBeamHeight, RMosaic, MHeight, ID, + MaxMosaic, AvgMosaic, AvgMosaicNumRadars, blnMosaic ); } /* end loop on radars */ - hpe_fieldgen_getCurrentTime(currTime); - sprintf(message, "%s = time end ERMOSAIC calculation.", currTime); - hpe_fieldgen_printMessage(message); + hpe_fieldgen_getCurrentTime(currTime) ; + sprintf( message , "%s = time end ERMOSAIC calculation." , + currTime) ; + hpe_fieldgen_printMessage( message ); /* * Added by Ram for the average and max ermosaic calculations @@ -490,339 +594,419 @@ void runERMosaic(const run_date_struct * pRunDate, * at this time. */ - if (blnMosaic[avgermosaic] == 1) { - for (k = 0; k < rowSize; k++) { - for (l = 0; l < colSize; l++) { - if (AvgMosaicNumRadars[k][l] > 0) { - if (AvgMosaic[k][l] >= 0.0) { + if(blnMosaic[avgermosaic] == 1) + { + for(k=0;k 0) + { + if(AvgMosaic[k][l] >= 0.0) + { AvgMosaic[k][l] /= AvgMosaicNumRadars[k][l]; - } else { - sprintf(message, "grid cell calculation error" - " for cell [%d][%d] = %lf in the avg mosaic.", - k, l, AvgMosaic[k][l]); - hpe_fieldgen_printMessage(message); } - } else { - if (AvgMosaic[k][l] >= 0.0) { + else + { + sprintf(message, "grid cell calculation error" + " for cell [%d][%d] = %lf in the avg mosaic.", + k, l, AvgMosaic[k][l]); + hpe_fieldgen_printMessage( message ); + } + } + else + { + if(AvgMosaic[k][l] >= 0.0) + { sprintf(message, "grid cell calculation error" " for cell [%d][%d] = %lf in the avg mosaic.", k, l, AvgMosaic[k][l]); - hpe_fieldgen_printMessage(message); + hpe_fieldgen_printMessage( message ); } } } } - if (first == 1) { - if (hpe_fieldgen_getAppsDefaults(AVG_ERMOSAIC_DIR_TOKEN, - avgRMosaicDir) == -1) { - sprintf(message, "ERROR: Invalid token value" - " for token \"%s\".\n\tProgram exit.", - AVG_ERMOSAIC_DIR_TOKEN); - shutdown(message); + if(first == 1) + { + if(hpe_fieldgen_getAppsDefaults(AVG_ERMOSAIC_DIR_TOKEN, avgRMosaicDir)==-1) + { + sprintf ( message , "ERROR: Invalid token value" + " for token \"%s\".\n\tProgram exit.", + AVG_ERMOSAIC_DIR_TOKEN) ; + shutdown( message ); } } - sprintf(fileName, "AVGRMOSAIC%s%sz", pEMPEParams->category_name, - strDateTime); + sprintf(fileName, "AVGRMOSAIC%s%sz", + pEMPEParams->category_name, strDateTime ); + + writeArray( pGeoData, avgRMosaicDir, fileName, + FACTOR_PRECIP, replace_missing, + pEMPEParams->user, pRunDate->tRunTime, + DSP_PROC_FLAG, AvgMosaic, &irc ) ; - writeArray(pGeoData, avgRMosaicDir, fileName, FACTOR_PRECIP, - replace_missing, pEMPEParams->user, pRunDate->tRunTime, - DSP_PROC_FLAG, AvgMosaic, &irc); - - if (irc != 0) { - sprintf(message, "ERROR: error number = %ld" - " attempting to write file: %s/%s", irc, avgRMosaicDir, - fileName); - printLogMessage(message); - } else { - sprintf(message, "STATUS: file written to: %s/%s", avgRMosaicDir, - fileName); - printLogMessage(message); + if(irc != 0) + { + sprintf( message , "ERROR: error number = %ld" + " attempting to write file: %s/%s" , + irc, avgRMosaicDir, fileName) ; + printLogMessage( message ); + } + else + { + sprintf( message , "STATUS: file written to: %s/%s" , + avgRMosaicDir, fileName) ; + printLogMessage( message ); } #if APPLY_POLYGON /* Apply edit polygons to the avgrmosaic product for - use in furture products. */ + use in furture products. */ apply_mpe_polygons ( AvgMosaic, - strDateTime, - year, - month, - day, - hour, - display_avgerMosaic, - pGeoData, - FACTOR_PRECIP, - 0, - 0); + strDateTime, + year, + month, + day, + hour, + display_avgerMosaic, + pGeoData, + FACTOR_PRECIP, + 0, + 0); #endif - } //end blnMosaic condition - - if (blnMosaic[maxermosaic] == 1) { - if (first == 1) { - if (hpe_fieldgen_getAppsDefaults(MAX_ERMOSAIC_DIR_TOKEN, - maxRMosaicDir) == -1) { - sprintf(message, "ERROR: Invalid token value" - " for token \"%s\".\n\tProgram exit.", - MAX_ERMOSAIC_DIR_TOKEN); - shutdown(message); + }//end blnMosaic condition + + if(blnMosaic[maxermosaic] == 1) + { + if(first == 1) + { + if(hpe_fieldgen_getAppsDefaults(MAX_ERMOSAIC_DIR_TOKEN, maxRMosaicDir)==-1) + { + sprintf ( message , "ERROR: Invalid token value" + " for token \"%s\".\n\tProgram exit.", + MAX_ERMOSAIC_DIR_TOKEN) ; + shutdown( message ); } } - sprintf(fileName, "MAXRMOSAIC%s%sz", pEMPEParams->category_name, - strDateTime); - writeArray(pGeoData, maxRMosaicDir, fileName, FACTOR_PRECIP, - replace_missing, pEMPEParams->user, pRunDate->tRunTime, - DSP_PROC_FLAG, MaxMosaic, &irc); + sprintf(fileName, "MAXRMOSAIC%s%sz", + pEMPEParams->category_name, strDateTime ); + writeArray(pGeoData, maxRMosaicDir, fileName, + FACTOR_PRECIP, replace_missing, + pEMPEParams->user, pRunDate->tRunTime, + DSP_PROC_FLAG, MaxMosaic, &irc) ; - if (irc != 0) { - sprintf(message, "ERROR: error number = %ld" - " attempting to write file: %s/%s", irc, maxRMosaicDir, - fileName); - printLogMessage(message); - } else { - sprintf(message, "STATUS: file written to: %s/%s", maxRMosaicDir, - fileName); - printLogMessage(message); + if(irc != 0) + { + sprintf( message , "ERROR: error number = %ld" + " attempting to write file: %s/%s" , + irc, maxRMosaicDir, fileName) ; + printLogMessage( message ); + } + else + { + sprintf( message , "STATUS: file written to: %s/%s" , + maxRMosaicDir, fileName) ; + printLogMessage( message ); } #if APPLY_POLYGON /* Apply edit polygons to the avgrmosaic product for - use in furture products. */ + use in furture products. */ apply_mpe_polygons ( MaxMosaic, - strDateTime, - year, - month, - day, - hour, - display_maxerMosaic, - pGeoData, - FACTOR_PRECIP, - 0, - 0 ); + strDateTime, + year, + month, + day, + hour, + display_maxerMosaic, + pGeoData, + FACTOR_PRECIP, + 0, + 0 ); #endif - } // end of blnMosaic condition - // ------------------------------------------------- - // average and max mosaic xmrg's written to file. + }// end of blnMosaic condition + // ------------------------------------------------- + // average and max mosaic xmrg's written to file. /* * Gage QC - Point Check using Radar Mosaic data. */ - if (blnMosaic[ermosaic] == 1) { - if (pEMPEParams->gage_qc == 1) { - hpe_fieldgen_getCurrentTime(currTime); - sprintf(message, "%s = time begin Gage QC multisensor check.", - currTime); - hpe_fieldgen_printMessage(message); + if(blnMosaic[ermosaic] == 1) + { + if(pEMPEParams->gage_qc == 1) + { + hpe_fieldgen_getCurrentTime(currTime) ; + sprintf( message , "%s = time begin Gage QC multisensor check." , + currTime) ; + hpe_fieldgen_printMessage( message ); - if (pGageTable->pseudoGageNum == pGageTable->totalGageNum) { - sprintf(message, "STATUS: No hourly gages data available," - " skip Multisensor Check."); - hpe_fieldgen_printMessage(message); - } else { - checkMultisensorQC(datetime, RMosaic, pGeoData, pQCGageTable); + if(pGageTable->pseudoGageNum == pGageTable->totalGageNum) + { + sprintf( message , "STATUS: No hourly gages data available," + " skip Multisensor Check." ) ; + hpe_fieldgen_printMessage( message ); } - hpe_fieldgen_getCurrentTime(currTime); - sprintf(message, "%s = time end Gage QC multisensor check.", - currTime); - hpe_fieldgen_printMessage(message); + else + { + checkMultisensorQC(datetime , RMosaic , + pGeoData, pQCGageTable) ; + } + hpe_fieldgen_getCurrentTime(currTime) ; + sprintf( message , "%s = time end Gage QC multisensor check." , + currTime) ; + hpe_fieldgen_printMessage( message ); } - } //end blnMosaic condition + }//end blnMosaic condition /* * write out gridded data in xmrg format to flat files */ - if (blnMosaic[ermosaic] == 1) { - hpe_fieldgen_getCurrentTime(currTime); - sprintf(message, "%s = time begin writing ERMOSAIC" - " fields to flat files.", currTime); - hpe_fieldgen_printMessage(message); + if(blnMosaic[ermosaic] == 1) + { + hpe_fieldgen_getCurrentTime(currTime) ; + sprintf( message , "%s = time begin writing ERMOSAIC" + " fields to flat files.", currTime) ; + hpe_fieldgen_printMessage( message ); - if (first == 1) { - if (hpe_fieldgen_getAppsDefaults(MOSAIC_DIR_TOKEN, mosaicDir) - == -1) { - sprintf(message, "ERROR: Invalid token value" - " for token \"%s\".\n\tProgram exit.", - MOSAIC_DIR_TOKEN); - shutdown(message); + if(first == 1) + { + if(hpe_fieldgen_getAppsDefaults(MOSAIC_DIR_TOKEN, mosaicDir) == -1) + { + sprintf ( message , "ERROR: Invalid token value" + " for token \"%s\".\n\tProgram exit.", + MOSAIC_DIR_TOKEN) ; + shutdown( message ); } } - sprintf(fileName, "ERMOSAIC%s%sz", pEMPEParams->category_name, - strDateTime); - sprintf(ermosaic_fileName, "ERMOSAIC%s%sz", pEMPEParams->category_name, - strDateTime); - writeArray(pGeoData, mosaicDir, fileName, FACTOR_PRECIP, - replace_missing, pEMPEParams->user, pRunDate->tRunTime, - DSP_PROC_FLAG, RMosaic, &irc); + sprintf(fileName, "ERMOSAIC%s%sz", + pEMPEParams->category_name, strDateTime ); + sprintf(ermosaic_fileName, "ERMOSAIC%s%sz", + pEMPEParams->category_name, strDateTime ); + writeArray(pGeoData, mosaicDir, fileName, FACTOR_PRECIP, + replace_missing, pEMPEParams->user, pRunDate->tRunTime, + DSP_PROC_FLAG, RMosaic, &irc) ; - if (irc != 0) { - sprintf(message, "ERROR: error number = %ld" - " attempting to write file: %s/%s", irc, mosaicDir, - fileName); - printLogMessage(message); - } else { - sprintf(message, "STATUS: file written to: %s/%s", mosaicDir, - fileName); - printLogMessage(message); + if(irc != 0) + { + sprintf( message , "ERROR: error number = %ld" + " attempting to write file: %s/%s" , + irc, mosaicDir, fileName) ; + printLogMessage( message ); + } + else + { + sprintf( message , "STATUS: file written to: %s/%s" , + mosaicDir, fileName) ; + printLogMessage( message ); } #if APPLY_POLYGON - /* Apply edit polygons to the avgrmosaic product for - use in future products. */ - apply_mpe_polygons ( RMosaic, - strDateTime, - year, - month, - day, - hour, - display_erMosaic, - pGeoData, - FACTOR_PRECIP, - 0, - 0 ); + /* Apply edit polygons to the avgrmosaic product for + use in future products. */ + apply_mpe_polygons ( RMosaic, + strDateTime, + year, + month, + day, + hour, + display_erMosaic, + pGeoData, + FACTOR_PRECIP, + 0, + 0 ); #endif hpe_fieldgen_getAppsDefaults(SAVE_HEIGHT_TOKEN, saveflag); - if (strcmp(hpe_fieldgen_toLowerCase(saveflag), "save") == 0) { - if (first == 1) { - if (hpe_fieldgen_getAppsDefaults(HEIGHT_DIR_TOKEN, heightDir) - == -1) { - sprintf(message, "ERROR: Invalid token value" - " for token \"%s\".\n\tProgram exit.", - HEIGHT_DIR_TOKEN); - shutdown(message); + if(strcmp(hpe_fieldgen_toLowerCase(saveflag), "save") == 0) + { + if(first == 1) + { + if(hpe_fieldgen_getAppsDefaults(HEIGHT_DIR_TOKEN, heightDir) == -1) + { + sprintf ( message , "ERROR: Invalid token value" + " for token \"%s\".\n\tProgram exit.", + HEIGHT_DIR_TOKEN) ; + shutdown( message ); } } - - sprintf(fileName, "DSPHEIGHT%s%sz", pEMPEParams->category_name, - strDateTime); - writeArray(pGeoData, heightDir, fileName, FACTOR_OTHER, - replace_missing, pEMPEParams->user, pRunDate->tRunTime, - DSP_PROC_FLAG, MHeight, &irc); - - if (irc != 0) { - sprintf(message, "ERROR: error number = %ld" - " attempting to write file: %s/%s.", irc, heightDir, - fileName); - printLogMessage(message); - } else { - sprintf(message, "STATUS: file written to: %s/%s.", heightDir, - fileName); - printLogMessage(message); + + sprintf(fileName, "DSPHEIGHT%s%sz", + pEMPEParams->category_name, strDateTime ); + writeArray(pGeoData, heightDir, fileName, FACTOR_OTHER, + replace_missing, pEMPEParams->user, pRunDate->tRunTime, + DSP_PROC_FLAG, MHeight, &irc) ; + + if(irc != 0) + { + sprintf( message , "ERROR: error number = %ld" + " attempting to write file: %s/%s." , + irc, heightDir, fileName) ; + printLogMessage( message ); + } + else + { + sprintf( message , "STATUS: file written to: %s/%s." , + heightDir, fileName) ; + printLogMessage( message ); } } hpe_fieldgen_getAppsDefaults(SAVE_INDEX_TOKEN, saveflag); - if (strcmp(hpe_fieldgen_toLowerCase(saveflag), "save") == 0) { - if (first == 1) { - if (hpe_fieldgen_getAppsDefaults(INDEX_DIR_TOKEN, indexDir) - == -1) { - sprintf(message, "ERROR: Invalid token value" - " for token \"%s\".\n\tProgram exit.", - INDEX_DIR_TOKEN); - shutdown(message); + if(strcmp(hpe_fieldgen_toLowerCase(saveflag), "save") == 0) + { + if(first == 1) + { + if(hpe_fieldgen_getAppsDefaults(INDEX_DIR_TOKEN, indexDir) == -1) + { + sprintf ( message , "ERROR: Invalid token value" + " for token \"%s\".\n\tProgram exit.", + INDEX_DIR_TOKEN) ; + shutdown( message ); } } - - sprintf(fileName, "DSPINDEX%s%sz", pEMPEParams->category_name, - strDateTime); - + + sprintf(fileName, "DSPINDEX%s%sz", + pEMPEParams->category_name, strDateTime ); + /* * fill in tempID array */ - - for (i = 0; i < rowSize; i++) { - for (j = 0; j < colSize; j++) { - tempID[i][j] = (double) ID[i][j]; + + for(i = 0; i < rowSize; i ++) + { + for(j = 0; j < colSize; j ++) + { + tempID[i][j] = (double)ID[i][j] ; } } - - writeArray(pGeoData, indexDir, fileName, FACTOR_OTHER, - replace_missing, pEMPEParams->user, pRunDate->tRunTime, - DSP_PROC_FLAG, tempID, &irc); - - if (irc != 0) { - sprintf(message, "ERROR: error number = %ld" - " attempting to write file: %s/%s.", irc, indexDir, - fileName); - printLogMessage(message); - } else { - sprintf(message, "STATUS: file written to: %s/%s.", indexDir, - fileName); - printLogMessage(message); + + writeArray(pGeoData, indexDir, fileName, FACTOR_OTHER, + replace_missing, pEMPEParams->user, pRunDate->tRunTime, + DSP_PROC_FLAG, tempID, &irc) ; + + if(irc != 0) + { + sprintf( message , "ERROR: error number = %ld" + " attempting to write file: %s/%s." , + irc, indexDir, fileName) ; + printLogMessage( message ); + } + else + { + sprintf( message, "STATUS: file written to: %s/%s.", indexDir, + fileName) ; + printLogMessage( message ); } } - if (strcmp(pEMPEParams->base_radar_mosaic, "ermosaic") == 0) { - sprintf(fileName, "ERMOSAIC%s%sz", pEMPEParams->category_name, - strDateTime); + if(strcmp(pEMPEParams->base_radar_mosaic, "ermosaic") == 0) + { + sprintf(fileName, "ERMOSAIC%s%sz", + pEMPEParams->category_name, strDateTime ); pMosaic = RMosaic; - } else if (strcmp(pEMPEParams->base_radar_mosaic, "avgermosaic") == 0) { - sprintf(fileName, "AVGRMOSAIC%s%sz", pEMPEParams->category_name, - strDateTime); + } + else if(strcmp(pEMPEParams->base_radar_mosaic, "avgermosaic") == 0) + { + sprintf(fileName, "AVGRMOSAIC%s%sz", + pEMPEParams->category_name, strDateTime ); pMosaic = AvgMosaic; - } else if (strcmp(pEMPEParams->base_radar_mosaic, "maxermosaic") == 0) { - sprintf(fileName, "MAXRMOSAIC%s%sz", pEMPEParams->category_name, - strDateTime); + } + else if(strcmp(pEMPEParams->base_radar_mosaic, "maxermosaic") == 0) + { + sprintf(fileName, "MAXRMOSAIC%s%sz", + pEMPEParams->category_name, strDateTime ); pMosaic = MaxMosaic; } - writeFormattedXMRG(pEMPEParams, pGeoData, mosaicDir, fileName, - DSP_PROC_FLAG, SAVE_GRIB_TOKEN, SAVE_GIF_TOKEN, GIF_DIR_TOKEN, - GIF_ID_TOKEN, SAVE_NETCDF_TOKEN, NETCDF_DIR_TOKEN, - NETCDF_ID_TOKEN, SAVE_JPEG_TOKEN, pMosaic); + writeFormattedXMRG(pEMPEParams, pGeoData, + mosaicDir, fileName, DSP_PROC_FLAG, + SAVE_GRIB_TOKEN, + SAVE_GIF_TOKEN, GIF_DIR_TOKEN, GIF_ID_TOKEN, + SAVE_NETCDF_TOKEN, NETCDF_DIR_TOKEN, NETCDF_ID_TOKEN, + SAVE_JPEG_TOKEN, + pMosaic); - hpe_fieldgen_getCurrentTime(currTime); - sprintf(message, "%s = time end writing ERMOSAIC fields to flat files.", - currTime); - hpe_fieldgen_printMessage(message); - } //end blnMosaic condition + hpe_fieldgen_getCurrentTime(currTime) ; + sprintf( message, "%s = time end writing ERMOSAIC fields to flat files.", + currTime) ; + hpe_fieldgen_printMessage( message ); - sprintf(message, - "\nSTATUS: In ERMOSAIC - insert/update HPERadarResult table"); - printLogMessage(message); + }//end blnMosaic condition + + /* check dual_pol_flag */ + if (dualpol_on_flag == 0) + dualpol_used = 0; + else + { + for (i = 0; i < pRadarLocTable->radarNum; i++) + { + if (dualpol_data_avail[i] != 0) + { + dualpol_used = 1; + + /* if dualpol data is available, however no record found in the DAARadarResult table */ + if (dualpol_meanbias_flag[i] == 0) + meanFieldBias[i] = 1.0; + + break; + } + else + dualpol_used = 0; + } + } + + sprintf ( message , "\nSTATUS: In ERMOSAIC, the flag dualpol_used = %d\n", dualpol_used); + printLogMessage( message ); + + sprintf ( message , "\nSTATUS: In ERMOSAIC, insert/update HPERadarResult table"); + printLogMessage( message ); + + if(blnMosaic[ermosaic] == 1) + wrtodb_HPERadarResult(ermosaic_fileName, prdDateTime, pEMPEParams, dualpol_used, nobias_flag); + + sprintf ( message , "\nSTATUS: In ERMOSAIC, complete insert/update HPERadarResult table"); + printLogMessage( message ); + + freeMosaicArray(pGeoData, GRID_ROWS) ; - if (blnMosaic[ermosaic] == 1) - wrtodb_HPERadarResult(ermosaic_fileName, prdDateTime, pEMPEParams, - dualpol_used, nobias_flag); - - sprintf(message, - "\nSTATUS: In ERMOSAIC - complete insert/update HPERadarResult table"); - printLogMessage(message); - - freeMosaicArray(pGeoData, GRID_ROWS); - - if (pRadarResult != NULL) { + if(pRadarResult != NULL) + { free(pRadarResult); pRadarResult = NULL; } - if (pDAARadarResult != NULL) { + if (pDAARadarResult != NULL) + { free(pDAARadarResult); pDAARadarResult = NULL; } + - first = 0; + first = 0 ; } static void initMosaicArray(const geo_data_struct * pGeoData, - const int radar_rows, const int radar_cols) { - const int rowSize = pGeoData->num_rows; - const int colSize = pGeoData->num_cols; + const int radar_rows, + const int radar_cols) +{ + const int rowSize = pGeoData->num_rows ; + const int colSize = pGeoData->num_cols ; - MHeight = init2DDoubleArray(HEIGHT_DEFAULT, rowSize, colSize); + MHeight = init2DDoubleArray(HEIGHT_DEFAULT, rowSize, colSize ); - tempID = init2DDoubleArray(ID_DEFAULT, rowSize, colSize); + tempID = init2DDoubleArray(ID_DEFAULT, rowSize, colSize ); origRadar = init2DFloatArray(RADAR_DEFAULT, NUM_DSP_ROWS, NUM_DSP_COLS); @@ -834,19 +1018,25 @@ static void initMosaicArray(const geo_data_struct * pGeoData, } static void freeMosaicArray(const geo_data_struct * pGeoData, - const int radar_rows) { - const int rowSize = pGeoData->num_rows; + const int radar_rows) +{ + const int rowSize = pGeoData->num_rows ; - free2DDoubleArray(MHeight, rowSize); + free2DDoubleArray(MHeight, rowSize ); + + free2DDoubleArray(tempID, rowSize ); - free2DDoubleArray(tempID, rowSize); + free2DFloatArray(origRadar, NUM_DSP_ROWS ); - free2DFloatArray(origRadar, NUM_DSP_ROWS); + free2DFloatArray(currRadar, radar_rows ); - free2DFloatArray(currRadar, radar_rows); + free2DShortArray(hrapMiscBins, NUM_DPA_ROWS ); - free2DShortArray(hrapMiscBins, NUM_DPA_ROWS); + free2DShortArray(currMiscBins, radar_rows ); - free2DShortArray(currMiscBins, radar_rows); +/* ============== Statements containing RCS keywords: */ +{static char rcs_id1[] = "$Source$"; + static char rcs_id2[] = "$Id$";} +/* =================================================== */ }