PDS_VERSION_ID = PDS3 DATA_SET_ID = {"GO-J-PWS-2-REDR-RTS-SA-FULL-V1.0", "GO-J-PWS-2-REDR-LPW-SA-FULL-V1.0"} PRODUCT_ID = "PWSCAL_C_CODE.TXT" PRODUCT_TYPE = "SOFTWARE" PRODUCT_CREATION_TIME = 1998-02-07 OBJECT = TEXT PUBLICATION_DATE = 1998-02-07 NOTE = " This file contains C code that reads the calibration tables and will will apply various requested calibration operations. In order to compile this code, the PDS label must first be stripped off and the file renamed to pwscal.c." END_OBJECT = TEXT END /*--------------------------------------------------------------------- pwscal.c written by L. Granroth 12-28-95 as example code for using "PWSLRCAL.TAB" to calibrate Galileo PWS LRS data. These functions are available: int pwscal_init (int type); reads calibration tables and initializes returns 0 for success and errno for failure type is the requested calibration units to be returned 1 is either Volts or nano-Tesla 2 is either E or B field squared (V^2/m^2 or nT^2) 3 is spectral density, either V^2/m^2/Hz or nT^2/Hz float pwscal_SA (int dn, int chan, int antenna); calibrates spectrum analyzer data returns float calibrated type specified in pwscal_init dn is uncalibrated 8-bit data number (0 - 255) chan is SA channel number (1 - 4) antenna is 0 for electric and 1 for magnetic float pwscal_SFR (int dn, int chan, int antenna); calibrates sweep frequency receiver data returns float calibrated type specified in pwscal_init dn is uncalibrated 8-bit data number (0 - 255) chan is SFR channel number (1 - 112) antenna is 0 for electric and 1 for magnetic float pwscal_HFR (int dn, int chan); calibrates electric high frequency receiver data returns float calibrated type specified in pwscal_init dn is uncalibrated 8-bit data number (0 - 255) chan is HFR channel number (1 - 42) Note that if pwscal_init is not called successfully or if invalid arguments are passed to the calibration routines, float zero is returned. ---------------------------------------------------------------------*/ #define CALIBRATED 1 #define FIELDSQUARED 2 #define SPECTRALDENSITY 3 #define ELECTRIC 0 #define MAGNETIC 1 #define CALFILE "PWSLRCAL.TAB" #include #include FILE *calf; float SAcal[256]; float SFR1cal[256], SFR2cal[256], SFR3cal[256], SFR4cal[256]; float HFRcal[256]; float SAgain[2][4] = {{0.0}}; float SFRgain[2][112] = {{0.0}}; float HFRgain[42] = {0.0}; float SAbw[4] = {1.0}; float SFRbw[4] = {1.0}; float HFRbw = 1.0; float Elength = 1.0; /*--------------------------------------------------------------------- pwscal_init - initialize Galileo PWS LRS calibrations ---------------------------------------------------------------------*/ int pwscal_init (int type) { int i; float bw; if (calf) fclose (calf); if (!(calf = fopen (CALFILE, "r"))) return (errno); for (i = 0; i < 256; i++) if (!fscanf (calf, "%g", SAcal+i)) return (errno); for (i = 0; i < 256; i++) if (!fscanf (calf, "%g", SFR1cal+i)) return (errno); for (i = 0; i < 256; i++) if (!fscanf (calf, "%g", SFR2cal+i)) return (errno); for (i = 0; i < 256; i++) if (!fscanf (calf, "%g", SFR3cal+i)) return (errno); for (i = 0; i < 256; i++) if (!fscanf (calf, "%g", SFR4cal+i)) return (errno); for (i = 0; i < 256; i++) if (!fscanf (calf, "%g", HFRcal+i)) return (errno); for (i = 0; i < 8; i++) if (!fscanf (calf, "%g", SAgain[0]+i)) return (errno); for (i = 0; i < 224; i++) if (!fscanf (calf, "%g", SFRgain[0]+i)) return (errno); for (i = 0; i < 42; i++) if (!fscanf (calf, "%g", HFRgain+i)) return (errno); for (i = 0; i < 4; i++) if (!fscanf (calf, "%g", SAbw+i)) return (errno); for (i = 0; i < 4; i++) if (!fscanf (calf, "%g", SFRbw+i)) return (errno); if (!fscanf (calf, "%g", &HFRbw)) return (errno); if (!fscanf (calf, "%g", &Elength)) return (errno); fclose (calf); calf = (FILE *)0; /* manipulate the calibration and gain arrays for various units */ if (type > CALIBRATED) { /* convert calibrated Volts to Volts squared (or nano-Tesla to nT^2) */ for (i = 0; i < 256; i++) { SAcal[i] *= SAcal[i]; SFR1cal[i] *= SFR1cal[i]; SFR2cal[i] *= SFR2cal[i]; SFR3cal[i] *= SFR3cal[i]; SFR4cal[i] *= SFR4cal[i]; HFRcal[i] *= HFRcal[i]; } /* convert effective electrical length to meters squared */ Elength *= Elength; /* fold electrical length and bandwidths into squared gain multipliers */ for (i = 0; i < 4; i++) { bw = type > FIELDSQUARED ? SAbw[i] : 1.0; SAgain[ELECTRIC][i] *= SAgain[ELECTRIC][i] / Elength / bw; SAgain[MAGNETIC][i] *= SAgain[MAGNETIC][i] / bw; } for (i = 0; i < 112; i++) { bw = type > FIELDSQUARED ? SFRbw[i/28] : 1.0; SFRgain[ELECTRIC][i] *= SFRgain[ELECTRIC][i] / Elength / bw; SFRgain[MAGNETIC][i] *= SFRgain[MAGNETIC][i] / bw; } bw = type > FIELDSQUARED ? HFRbw : 1.0; for (i = 0; i < 42; i++) HFRgain[i] *= HFRgain[i] / Elength / bw; } /* if type > CALIBRATED */ return (0); } /* pwscal_init - initialize Galileo PWS LRS calibrations */ /*--------------------------------------------------------------------- pwscal_SA - calibrate Galileo PWS LRS SA ---------------------------------------------------------------------*/ float pwscal_SA (int dn, int chan, int antenna) { if ((dn < 1) || (dn > 255) || (chan < 1) || (chan > 4)) return (0.0); antenna &= 1; return (SAcal[dn] * SAgain[antenna][--chan]); } /* pwscal_SA - calibrate Galileo PWS LRS SA */ /*--------------------------------------------------------------------- pwscal_SFR - calibrate Galileo PWS LRS SFR ---------------------------------------------------------------------*/ float pwscal_SFR (int dn, int chan, int antenna) { if ((dn < 1) || (dn > 255) || (chan < 1) || (chan > 112)) return (0.0); antenna &= 1; chan--; switch (chan / 28) { case 0: return (SFR1cal[dn] * SFRgain[antenna][chan]); case 1: return (SFR2cal[dn] * SFRgain[antenna][chan]); case 2: return (SFR3cal[dn] * SFRgain[antenna][chan]); case 3: return (SFR4cal[dn] * SFRgain[antenna][chan]); } /* switch */ return 0.0; } /* pwscal_SFR - calibrate Galileo PWS LRS SFR */ /*--------------------------------------------------------------------- pwscal_HFR - calibrate Galileo PWS LRS HFR ---------------------------------------------------------------------*/ float pwscal_HFR (int dn, int chan) { if ((dn < 1) || (dn > 255) || (chan < 1) || (chan > 42)) return (0.0); return (HFRcal[dn] * HFRgain[--chan]); } /* pwscal_HFR - calibrate Galileo PWS LRS HFR */