int main(int argc, char** argv) { if(argc!=2) { perror("Invalid arguements : SMROStats <file.lba>\n"); exit(1); } // Get the filename from the command line char* filename = argv[1]; // Get stats for input file struct stat file_stats; if(stat(filename,&file_stats)) { perror("Couldn't retrieve file information.\n"); exit(1); } // Check length of input file int max=1024; // No. of blocks to read. When max=1024;64MB of input used if(file_stats.st_size<(BLK_SIZE*max)) max=file_stats.st_size/BLK_SIZE; // Data loader dsp::SMROFile* loader = new dsp::SMROFile; loader->open( filename ); loader->set_output( new dsp::BitSeries ); loader->set_block_size( BLK_SIZE ); // Convert to a dsp::TimeSeries dsp::SMROTwoBitCorrection* unpacker = new dsp::SMROTwoBitCorrection; unpacker->set_input( loader->get_output() ); unpacker->set_output( new dsp::TimeSeries ); // Go to work int count; for(count=0;count<max;count++) // Load and unpack (BLK_SIZE*max) bytes { loader->operate(); unpacker->operate(); } loader->close(); // Plot Histogram cpgopen("?"); cpglab("","","SMRO Sampler Statistics"); cpgsvp(0.1,0.9,0.1,0.9); dsp::TwoBitStatsPlotter* plot = new dsp::TwoBitStatsPlotter; plot->set_data(unpacker); plot->plot(); cpgclos(); // Free memory delete loader,unpacker; }
static void _pgclos (void) { void (*sig_func)(int); sig_func = SLsignal (SIGSEGV, sig_segv); if (sig_func == SIG_ERR) fprintf (stderr, "warning: failed initializing signal handler for SIGSEGV\n"); cpgclos (); if (SLsignal (SIGSEGV, sig_func) == SIG_ERR) fprintf (stderr, "warning: failed to re-set signal handler\n"); }
int main(int argc, char *argv[]) { float minval = SMALLNUM, maxval = LARGENUM, inx = 0, iny = 0; int centern, offsetn; int zoomlevel, maxzoom = 0, minzoom, xid, psid; char *rootfilenm, inchar; datapart *lodp; dataview *dv; basicstats *statvals; if (argc == 1) { printf("\nusage: exploredat datafilename\n\n"); exit(0); } printf("\n\n"); printf(" Interactive Data Explorer\n"); printf(" by Scott M. Ransom\n"); printf(" November, 2001\n"); print_help(); { int hassuffix = 0; char *suffix; hassuffix = split_root_suffix(argv[1], &rootfilenm, &suffix); if (hassuffix) { if (strcmp(suffix, "dat") != 0) { printf ("\nInput file ('%s') must be a single PRESTO data file ('.dat')!\n\n", argv[1]); free(suffix); exit(0); } free(suffix); } else { printf("\nInput file ('%s') must be a PRESTO data file ('.dat')!\n\n", argv[1]); exit(0); } } /* Read the info file */ readinf(&idata, rootfilenm); if (idata.object) { printf("Examining %s data from '%s'.\n\n", remove_whitespace(idata.object), argv[1]); } else { printf("Examining data from '%s'.\n\n", argv[1]); } #ifdef USEMMAP mmap_file = open(argv[1], O_RDONLY); { int rt; struct stat buf; rt = fstat(mmap_file, &buf); if (rt == -1) { perror("\nError in fstat() in exploredat.c"); printf("\n"); exit(-1); } Ndat = buf.st_size / sizeof(float); } lodp = get_datapart(0, Ndat); #else { int numsamp; datfile = chkfopen(argv[1], "rb"); Ndat = chkfilelen(datfile, sizeof(float)); numsamp = (Ndat > MAXPTS) ? (int) MAXPTS : (int) Ndat; lodp = get_datapart(0, numsamp); } #endif /* Plot the initial data */ centern = 0.5 * INITIALNUMPTS; if (centern > lodp->nn) centern = lodp->nn / 2; zoomlevel = LOGMAXDISPNUM - LOGINITIALNUMPTS; minzoom = LOGMAXDISPNUM - LOGMAXPTS; maxzoom = LOGMAXDISPNUM - LOGMINDISPNUM; dv = get_dataview(centern, zoomlevel, lodp); /* Prep the XWIN device for PGPLOT */ xid = cpgopen("/XWIN"); if (xid <= 0) { free_datapart(lodp); #ifdef USEMMAP close(mmap_file); #else fclose(datfile); #endif free(dv); exit(EXIT_FAILURE); } cpgask(0); cpgpage(); offsetn = plot_dataview(dv, minval, maxval, 1.0); do { cpgcurs(&inx, &iny, &inchar); if (DEBUGOUT) printf("You pressed '%c'\n", inchar); switch (inchar) { case ' ': /* Toggle stats and sample plotting on/off */ /* 0 = both, 1 = stats only, 2 = data only */ plotstats++; plotstats = plotstats % 3; cpgpage(); offsetn = plot_dataview(dv, minval, maxval, 1.0); break; case 'M': /* Toggle between median and average */ case 'm': usemedian = (usemedian) ? 0 : 1; free(dv); dv = get_dataview(centern, zoomlevel, lodp); cpgpage(); offsetn = plot_dataview(dv, minval, maxval, 1.0); break; case 'A': /* Zoom in */ case 'a': centern = inx + offsetn; case 'I': case 'i': if (DEBUGOUT) printf(" Zooming in (zoomlevel = %d)...\n", zoomlevel); if (zoomlevel < maxzoom) { zoomlevel++; free(dv); dv = get_dataview(centern, zoomlevel, lodp); cpgpage(); offsetn = plot_dataview(dv, minval, maxval, 1.0); } else printf(" Already at maximum zoom level (%d).\n", zoomlevel); break; case 'X': /* Zoom out */ case 'x': case 'O': case 'o': if (DEBUGOUT) printf(" Zooming out (zoomlevel = %d)...\n", zoomlevel); if (zoomlevel > minzoom) { zoomlevel--; free(dv); dv = get_dataview(centern, zoomlevel, lodp); cpgpage(); offsetn = plot_dataview(dv, minval, maxval, 1.0); } else printf(" Already at minimum zoom level (%d).\n", zoomlevel); break; case '<': /* Shift left 1 full screen */ centern -= dv->numsamps + dv->numsamps / 8; case ',': /* Shift left 1/8 screen */ if (DEBUGOUT) printf(" Shifting left...\n"); centern -= dv->numsamps / 8; { /* Should probably get the previous chunk from the datfile... */ double lowestr; lowestr = 0.5 * dv->numsamps; if (centern < lowestr) centern = lowestr; } free(dv); dv = get_dataview(centern, zoomlevel, lodp); cpgpage(); offsetn = plot_dataview(dv, minval, maxval, 1.0); break; case '>': /* Shift right 1 full screen */ centern += dv->numsamps - dv->numsamps / 8; case '.': /* Shift right 1/8 screen */ centern += dv->numsamps / 8; if (DEBUGOUT) printf(" Shifting right...\n"); { /* Should probably get the next chunk from the datfile... */ double highestr; highestr = lodp->nlo + lodp->nn - 0.5 * dv->numsamps; if (centern > highestr) centern = highestr; } free(dv); dv = get_dataview(centern, zoomlevel, lodp); cpgpage(); offsetn = plot_dataview(dv, minval, maxval, 1.0); break; case '+': /* Increase height of top edge */ { float dy; if (maxval > 0.5 * LARGENUM) { printf(" Auto-scaling of top edge is off.\n"); if (minval < 0.5 * SMALLNUM) dy = dv->maxval - dv->minval; else dy = dv->maxval - minval; maxval = dv->maxval + 0.1 * dy; } else { if (minval < 0.5 * SMALLNUM) dy = maxval - dv->minval; else dy = maxval - minval; maxval += 0.1 * dy; } cpgpage(); offsetn = plot_dataview(dv, minval, maxval, 1.0); break; } case '_': /* Decrease height of top edge */ { float dy; if (maxval > 0.5 * LARGENUM) { printf(" Auto-scaling of top edge is off.\n"); if (minval < 0.5 * SMALLNUM) dy = dv->maxval - dv->minval; else dy = dv->maxval - minval; maxval = dv->maxval - 0.1 * dy; } else { if (minval < 0.5 * SMALLNUM) dy = maxval - dv->minval; else dy = maxval - minval; maxval -= 0.1 * dy; } cpgpage(); offsetn = plot_dataview(dv, minval, maxval, 1.0); break; } case '=': /* Increase height of bottom edge */ { float dy; if (minval < 0.5 * SMALLNUM) { printf(" Auto-scaling of bottom edge is off.\n"); if (maxval > 0.5 * LARGENUM) dy = dv->maxval - dv->minval; else dy = maxval - dv->minval; minval = dv->minval + 0.1 * dy; } else { if (maxval > 0.5 * LARGENUM) dy = dv->maxval - minval; else dy = maxval - minval; minval += 0.1 * dy; } cpgpage(); offsetn = plot_dataview(dv, minval, maxval, 1.0); break; } case '-': /* Decrease height of bottom edge */ { float dy; if (minval < 0.5 * SMALLNUM) { printf(" Auto-scaling of bottom edge is off.\n"); if (maxval > 0.5 * LARGENUM) dy = dv->maxval - dv->minval; else dy = maxval - dv->minval; minval = dv->minval - 0.1 * dy; } else { if (maxval > 0.5 * LARGENUM) dy = dv->maxval - minval; else dy = maxval - minval; minval -= 0.1 * dy; } cpgpage(); offsetn = plot_dataview(dv, minval, maxval, 1.0); break; } case 'S': /* Auto-scale */ case 's': printf(" Auto-scaling is on.\n"); minval = SMALLNUM; maxval = LARGENUM; cpgpage(); offsetn = plot_dataview(dv, minval, maxval, 1.0); break; case 'G': /* Goto a time */ case 'g': { char timestr[50]; double time = -1.0; while (time < 0.0) { printf (" Enter the time (s) from the beginning of the file to go to:\n"); fgets(timestr, 50, stdin); timestr[strlen(timestr) - 1] = '\0'; time = atof(timestr); } offsetn = 0.0; centern = (int) (time / idata.dt + 0.5); printf(" Moving to time %.15g (data point %d).\n", time, centern); free(dv); dv = get_dataview(centern, zoomlevel, lodp); cpgpage(); offsetn = plot_dataview(dv, minval, maxval, 1.0); } break; case '?': /* Print help screen */ print_help(); break; case 'P': /* Print the current plot */ case 'p': { int len; char filename[200]; printf(" Enter the filename to save the plot as:\n"); fgets(filename, 195, stdin); len = strlen(filename) - 1; filename[len + 0] = '/'; filename[len + 1] = 'C'; filename[len + 2] = 'P'; filename[len + 3] = 'S'; filename[len + 4] = '\0'; psid = cpgopen(filename); cpgslct(psid); cpgpap(10.25, 8.5 / 11.0); cpgiden(); offsetn = plot_dataview(dv, minval, maxval, 1.0); cpgclos(); cpgslct(xid); filename[len] = '\0'; printf(" Wrote the plot to the file '%s'.\n", filename); } break; case 'V': /* Show the basic statistics for the current dataview */ case 'v': statvals = calc_stats(dv, lodp); printf("\n Statistics:\n" " Low sample %d\n" " Number of samples %d\n" " Low time (s) %.7g\n" " Duration of samples (s) %.7g\n" " Maximum value %.7g\n" " Minimum value %.7g\n" " Average value %.7g\n" " Median value %.7g\n" " Standard Deviation %.7g\n" " Skewness %.7g\n" " Kurtosis %.7g\n\n", dv->lon, dv->numsamps, dv->lon * idata.dt, dv->numsamps * idata.dt, statvals->max, statvals->min, statvals->average, statvals->median, statvals->stdev, statvals->skewness, statvals->kurtosis); free(statvals); break; case 'Q': /* Quit */ case 'q': printf(" Quitting...\n"); free(dv); cpgclos(); break; default: printf(" Unrecognized option '%c'.\n", inchar); break; } } while (inchar != 'Q' && inchar != 'q'); free_datapart(lodp); #ifdef USEMMAP close(mmap_file); #else fclose(datfile); #endif printf("Done\n\n"); return 0; }
void rfifind_plot(int numchan, int numint, int ptsperint, float timesigma, float freqsigma, float inttrigfrac, float chantrigfrac, float **dataavg, float **datastd, float **datapow, int *userchan, int numuserchan, int *userints, int numuserints, infodata * idata, unsigned char **bytemask, mask * oldmask, mask * newmask, rfi * rfivect, int numrfi, int rfixwin, int rfips, int xwin) /* Make the beautiful multi-page rfifind plots */ { int ii, jj, ct, loops = 1; float *freqs, *chans, *times, *ints; float *avg_chan_avg, *std_chan_avg, *pow_chan_avg; float *avg_chan_med, *std_chan_med, *pow_chan_med; float *avg_chan_std, *std_chan_std, *pow_chan_std; float *avg_int_avg, *std_int_avg, *pow_int_avg; float *avg_int_med, *std_int_med, *pow_int_med; float *avg_int_std, *std_int_std, *pow_int_std; float dataavg_avg, datastd_avg, datapow_avg; float dataavg_med, datastd_med, datapow_med; float dataavg_std, datastd_std, datapow_std; float avg_reject, std_reject, pow_reject; double inttim, T, lof, hif; inttim = ptsperint * idata->dt; T = inttim * numint; lof = idata->freq - 0.5 * idata->chan_wid; hif = lof + idata->freqband; avg_chan_avg = gen_fvect(numchan); std_chan_avg = gen_fvect(numchan); pow_chan_avg = gen_fvect(numchan); avg_int_avg = gen_fvect(numint); std_int_avg = gen_fvect(numint); pow_int_avg = gen_fvect(numint); avg_chan_med = gen_fvect(numchan); std_chan_med = gen_fvect(numchan); pow_chan_med = gen_fvect(numchan); avg_int_med = gen_fvect(numint); std_int_med = gen_fvect(numint); pow_int_med = gen_fvect(numint); avg_chan_std = gen_fvect(numchan); std_chan_std = gen_fvect(numchan); pow_chan_std = gen_fvect(numchan); avg_int_std = gen_fvect(numint); std_int_std = gen_fvect(numint); pow_int_std = gen_fvect(numint); chans = gen_fvect(numchan); freqs = gen_fvect(numchan); for (ii = 0; ii < numchan; ii++) { chans[ii] = ii; freqs[ii] = idata->freq + ii * idata->chan_wid; } ints = gen_fvect(numint); times = gen_fvect(numint); for (ii = 0; ii < numint; ii++) { ints[ii] = ii; times[ii] = 0.0 + ii * inttim; } /* Calculate the statistics of the full set */ ct = numchan * numint; calc_avgmedstd(dataavg[0], ct, 0.8, 1, &dataavg_avg, &dataavg_med, &dataavg_std); calc_avgmedstd(datastd[0], ct, 0.8, 1, &datastd_avg, &datastd_med, &datastd_std); calc_avgmedstd(datapow[0], ct, 0.5, 1, &datapow_avg, &datapow_med, &datapow_std); avg_reject = timesigma * dataavg_std; std_reject = timesigma * datastd_std; pow_reject = power_for_sigma(freqsigma, 1, ptsperint / 2); /* Calculate the channel/integration statistics vectors */ for (ii = 0; ii < numint; ii++) { calc_avgmedstd(dataavg[0] + ii * numchan, numchan, 0.8, 1, avg_int_avg + ii, avg_int_med + ii, avg_int_std + ii); calc_avgmedstd(datastd[0] + ii * numchan, numchan, 0.8, 1, std_int_avg + ii, std_int_med + ii, std_int_std + ii); calc_avgmedstd(datapow[0] + ii * numchan, numchan, 0.5, 1, pow_int_avg + ii, pow_int_med + ii, pow_int_std + ii); } for (ii = 0; ii < numchan; ii++) { calc_avgmedstd(dataavg[0] + ii, numint, 0.8, numchan, avg_chan_avg + ii, avg_chan_med + ii, avg_chan_std + ii); calc_avgmedstd(datastd[0] + ii, numint, 0.8, numchan, std_chan_avg + ii, std_chan_med + ii, std_chan_std + ii); calc_avgmedstd(datapow[0] + ii, numint, 0.5, numchan, pow_chan_avg + ii, pow_chan_med + ii, pow_chan_std + ii); /* fprintf(stderr, "%12.7g %12.7g %12.7g %12.7g %12.7g %12.7g %12.7g %12.7g %12.7g \n", avg_chan_avg[ii], avg_chan_med[ii], avg_chan_std[ii], std_chan_avg[ii], std_chan_med[ii], std_chan_std[ii], pow_chan_avg[ii], pow_chan_med[ii], pow_chan_std[ii]); */ } /* Generate the byte mask */ /* Set the channels/intervals picked by the user */ if (numuserints) for (ii = 0; ii < numuserints; ii++) if (userints[ii] >= 0 && userints[ii] < numint) for (jj = 0; jj < numchan; jj++) bytemask[userints[ii]][jj] |= USERINTS; if (numuserchan) for (ii = 0; ii < numuserchan; ii++) if (userchan[ii] >= 0 && userchan[ii] < numchan) for (jj = 0; jj < numint; jj++) bytemask[jj][userchan[ii]] |= USERCHAN; /* Compare each point in an interval (or channel) with */ /* the interval's (or channel's) median and the overall */ /* standard deviation. If the channel/integration */ /* medians are more than sigma different than the global */ /* value, set them to the global. */ { float int_med, chan_med; for (ii = 0; ii < numint; ii++) { for (jj = 0; jj < numchan; jj++) { { /* Powers */ if (datapow[ii][jj] > pow_reject) if (!(bytemask[ii][jj] & PADDING)) bytemask[ii][jj] |= BAD_POW; } { /* Averages */ if (fabs(avg_int_med[ii] - dataavg_med) > timesigma * dataavg_std) int_med = dataavg_med; else int_med = avg_int_med[ii]; if (fabs(avg_chan_med[jj] - dataavg_med) > timesigma * dataavg_std) chan_med = dataavg_med; else chan_med = avg_chan_med[jj]; if (fabs(dataavg[ii][jj] - int_med) > avg_reject || fabs(dataavg[ii][jj] - chan_med) > avg_reject) if (!(bytemask[ii][jj] & PADDING)) bytemask[ii][jj] |= BAD_AVG; } { /* Standard Deviations */ if (fabs(std_int_med[ii] - datastd_med) > timesigma * datastd_std) int_med = datastd_med; else int_med = std_int_med[ii]; if (fabs(std_chan_med[jj] - datastd_med) > timesigma * datastd_std) chan_med = datastd_med; else chan_med = std_chan_med[jj]; if (fabs(datastd[ii][jj] - int_med) > std_reject || fabs(datastd[ii][jj] - chan_med) > std_reject) if (!(bytemask[ii][jj] & PADDING)) bytemask[ii][jj] |= BAD_STD; } } } } /* Step over the intervals and channels and count how many are set "bad". */ /* For a given interval, if the number of bad channels is greater than */ /* chantrigfrac*numchan then reject the whole interval. */ /* For a given channel, if the number of bad intervals is greater than */ /* inttrigfrac*numint then reject the whole channel. */ { int badnum, trignum; /* Loop over the intervals */ trignum = (int) (numchan * chantrigfrac); for (ii = 0; ii < numint; ii++) { if (!(bytemask[ii][0] & USERINTS)) { badnum = 0; for (jj = 0; jj < numchan; jj++) if (bytemask[ii][jj] & BADDATA) badnum++; if (badnum > trignum) { userints[numuserints++] = ii; for (jj = 0; jj < numchan; jj++) bytemask[ii][jj] |= USERINTS; } } } /* Loop over the channels */ trignum = (int) (numint * inttrigfrac); for (ii = 0; ii < numchan; ii++) { if (!(bytemask[0][ii] & USERCHAN)) { badnum = 0; for (jj = 0; jj < numint; jj++) if (bytemask[jj][ii] & BADDATA) badnum++; if (badnum > trignum) { userchan[numuserchan++] = ii; for (jj = 0; jj < numint; jj++) bytemask[jj][ii] |= USERCHAN; } } } } /* Generate the New Mask */ fill_mask(timesigma, freqsigma, idata->mjd_i + idata->mjd_f, ptsperint * idata->dt, idata->freq, idata->chan_wid, numchan, numint, ptsperint, numuserchan, userchan, numuserints, userints, bytemask, newmask); /* Place the oldmask over the newmask for plotting purposes */ if (oldmask->numchan) set_oldmask_bits(oldmask, bytemask); /* * Now plot the results */ if (xwin) loops = 2; for (ct = 0; ct < loops; ct++) { /* PS/XWIN Plot Loop */ float min, max, tr[6], locut, hicut; float left, right, top, bottom; float xl, xh, yl, yh; float tt, ft, th, fh; /* thin and fat thicknesses and heights */ float lm, rm, tm, bm; /* LRTB margins */ float xarr[2], yarr[2]; char outdev[100]; int ii, mincol, maxcol, numcol; /*Set the PGPLOT device to an X-Window */ if (ct == 1) strcpy(outdev, "/XWIN"); else sprintf(outdev, "%s.ps/CPS", idata->name); /* Open and prep our device */ cpgopen(outdev); cpgpap(10.25, 8.5 / 11.0); cpgpage(); cpgiden(); cpgsch(0.7); cpgqcir(&mincol, &maxcol); numcol = maxcol - mincol + 1; for (ii = mincol; ii <= maxcol; ii++) { float color; color = (float) (maxcol - ii) / (float) numcol; cpgscr(ii, color, color, color); } /* Set thicknesses and margins */ lm = 0.04; rm = 0.04; bm = 0.08; tm = 0.05; ft = 3.0; /* This sets fat thickness = 3 x thin thickness */ tt = 0.92 / (6.0 + 4.0 * ft); ft *= tt; fh = 0.55; th = tt * 11.0 / 8.5; { /* Powers Histogram */ float *theo, *hist, *hpows, *tpows, maxhist = 0.0, maxtheo = 0.0; int numhist = 40, numtheo = 200, bin, numpows; double dtheo, dhist, spacing; /* Calculate the predicted distribution of max powers */ numpows = numint * numchan; find_min_max_arr(numpows, datapow[0], &min, &max); min = (min < 5.0) ? log10(5.0 * 0.95) : log10(min * 0.95); max = log10(max * 1.05); dhist = (max - min) / numhist; theo = gen_fvect(numtheo); tpows = gen_fvect(numtheo); hist = gen_fvect(numhist); hpows = gen_fvect(numhist); for (ii = 0; ii < numhist; ii++) { hist[ii] = 0.0; hpows[ii] = min + ii * dhist; } for (ii = 0; ii < numpows; ii++) { bin = (*(datapow[0] + ii) == 0.0) ? 0 : (log10(*(datapow[0] + ii)) - min) / dhist; if (bin < 0) bin = 0; if (bin >= numhist) bin = numhist; hist[bin] += 1.0; } for (ii = 0; ii < numhist; ii++) if (hist[ii] > maxhist) maxhist = hist[ii]; maxhist *= 1.1; dtheo = (max - min) / (double) (numtheo - 1); for (ii = 0; ii < numtheo; ii++) { tpows[ii] = min + ii * dtheo; theo[ii] = single_power_pdf(pow(10.0, tpows[ii]), ptsperint / 2) * numpows; spacing = (pow(10.0, tpows[ii] + dhist) - pow(10.0, tpows[ii])); theo[ii] *= spacing; if (theo[ii] > maxtheo) maxtheo = theo[ii]; } maxtheo *= 1.1; if (maxtheo > maxhist) maxhist = maxtheo; left = lm; right = lm + ft + tt; bottom = 0.80; top = 0.96; cpgsvp(left, right, bottom, top); xl = min; xh = max; yl = 0.0; yh = maxhist; cpgswin(xl, xh, yl, yh); cpgmtxt("L", 1.1, 0.5, 0.5, "Number"); cpgmtxt("B", 2.1, 0.5, 0.5, "Max Power"); cpgbin(numhist, hpows, hist, 0); cpgscr(maxcol, 0.5, 0.5, 0.5); cpgsci(maxcol); /* Grey */ cpgline(numtheo, tpows, theo); xarr[0] = log10(power_for_sigma(freqsigma, 1, ptsperint / 2)); xarr[1] = xarr[0]; yarr[0] = yl; yarr[1] = yh; cpgsls(4); /* Dotted line */ cpgscr(maxcol, 1.0, 0.0, 0.0); cpgsci(maxcol); /* Red */ cpgline(2, xarr, yarr); cpgsls(1); /* Solid line */ cpgsci(1); /* Default color */ cpgbox("BCLNST", 0.0, 0, "BC", 0.0, 0); vect_free(hist); vect_free(theo); vect_free(tpows); vect_free(hpows); } /* Maximum Powers */ left = lm; right = lm + ft; bottom = bm; top = bm + fh; xl = 0.0; xh = numchan; yl = 0.0; yh = T; cpgsvp(left, right, bottom, top); cpgswin(xl, xh, yl, yh); cpgscr(maxcol, 1.0, 0.0, 0.0); /* Red */ locut = 0.0; hicut = pow_reject; tr[2] = tr[4] = 0.0; tr[1] = (xh - xl) / numchan; tr[0] = xl - (tr[1] / 2); tr[5] = (yh - yl) / numint; tr[3] = yl - (tr[5] / 2); cpgimag(datapow[0], numchan, numint, 1, numchan, 1, numint, locut, hicut, tr); cpgswin(xl, xh, yl, yh); cpgbox("BNST", 0.0, 0, "BNST", 0.0, 0); cpgmtxt("B", 2.6, 0.5, 0.5, "Channel"); cpgmtxt("L", 2.1, 0.5, 0.5, "Time (s)"); xl = lof; xh = hif; yl = 0.0; yh = numint; cpgswin(xl, xh, yl, yh); cpgbox("CST", 0.0, 0, "CST", 0.0, 0); /* Max Power Label */ left = lm + ft; right = lm + ft + tt; bottom = bm + fh; top = bm + fh + th; cpgsvp(left, right, bottom, top); cpgswin(0.0, 1.0, 0.0, 1.0); cpgscr(maxcol, 1.0, 0.0, 0.0); cpgsci(maxcol); /* Red */ cpgptxt(0.5, 0.7, 0.0, 0.5, "Max"); cpgptxt(0.5, 0.3, 0.0, 0.5, "Power"); cpgsci(1); /* Default color */ /* Max Power versus Time */ left = lm + ft; right = lm + ft + tt; bottom = bm; top = bm + fh; cpgsvp(left, right, bottom, top); find_min_max_arr(numint, pow_int_med, &min, &max); xl = 0.0; xh = 1.5 * pow_reject; yl = 0.0; yh = T; cpgswin(xl, xh, yl, yh); cpgbox("BCST", 0.0, 0, "BST", 0.0, 0); cpgscr(maxcol, 1.0, 0.0, 0.0); cpgsci(maxcol); /* Red */ yarr[0] = yl; yarr[1] = yh; xarr[0] = xarr[1] = datapow_med; cpgline(2, xarr, yarr); cpgsls(4); /* Dotted line */ xarr[0] = xarr[1] = pow_reject; cpgline(2, xarr, yarr); cpgsls(1); /* Solid line */ cpgsci(1); /* Default color */ cpgline(numint, pow_int_med, times); yl = 0.0; yh = numint; cpgswin(xl, xh, yl, yh); cpgbox("", 0.0, 0, "CMST", 0.0, 0); /* cpgmtxt("R", 2.3, 0.5, 0.5, "Interval Number"); */ /* Max Power versus Channel */ left = lm; right = lm + ft; bottom = bm + fh; top = bm + fh + th; cpgsvp(left, right, bottom, top); find_min_max_arr(numchan, pow_chan_med, &min, &max); xl = 0.0; xh = numchan; yl = 0.0; yh = 1.5 * pow_reject; cpgswin(xl, xh, yl, yh); cpgbox("BST", 0.0, 0, "BCST", 0.0, 0); cpgscr(maxcol, 1.0, 0.0, 0.0); cpgsci(maxcol); /* Red */ xarr[0] = xl; xarr[1] = xh; yarr[0] = yarr[1] = datapow_med; cpgline(2, xarr, yarr); cpgsls(4); /* Dotted line */ yarr[0] = yarr[1] = pow_reject; cpgline(2, xarr, yarr); cpgsls(1); /* Solid line */ cpgsci(1); /* Default color */ cpgline(numchan, chans, pow_chan_med); xl = lof; xh = hif; cpgswin(xl, xh, yl, yh); cpgbox("CMST", 0.0, 0, "", 0.0, 0); cpgmtxt("T", 1.8, 0.5, 0.5, "Frequency (MHz)"); /* Standard Deviations */ left = lm + ft + 2.0 * tt; right = lm + 2.0 * ft + 2.0 * tt; bottom = bm; top = bm + fh; xl = 0.0; xh = numchan; yl = 0.0; yh = T; cpgsvp(left, right, bottom, top); cpgswin(xl, xh, yl, yh); cpgscr(mincol, 0.7, 1.0, 0.7); /* Light Green */ cpgscr(maxcol, 0.3, 1.0, 0.3); /* Dark Green */ locut = datastd_med - timesigma * datastd_std; hicut = datastd_med + timesigma * datastd_std; tr[2] = tr[4] = 0.0; tr[1] = (xh - xl) / numchan; tr[0] = xl - (tr[1] / 2); tr[5] = (yh - yl) / numint; tr[3] = yl - (tr[5] / 2); cpgimag(datastd[0], numchan, numint, 1, numchan, 1, numint, locut, hicut, tr); cpgswin(xl, xh, yl, yh); cpgbox("BNST", 0.0, 0, "BNST", 0.0, 0); cpgmtxt("B", 2.6, 0.5, 0.5, "Channel"); xl = lof; xh = hif; yl = 0.0; yh = numint; cpgswin(xl, xh, yl, yh); cpgbox("CST", 0.0, 0, "CST", 0.0, 0); /* Data Sigma Label */ left = lm + 2.0 * ft + 2.0 * tt; right = lm + 2.0 * ft + 3.0 * tt; bottom = bm + fh; top = bm + fh + th; cpgsvp(left, right, bottom, top); cpgswin(0.0, 1.0, 0.0, 1.0); cpgscr(maxcol, 0.0, 1.0, 0.0); cpgsci(maxcol); /* Green */ cpgptxt(0.5, 0.7, 0.0, 0.5, "Data"); cpgptxt(0.5, 0.3, 0.0, 0.5, "Sigma"); cpgsci(1); /* Default color */ /* Data Sigma versus Time */ left = lm + 2.0 * ft + 2.0 * tt; right = lm + 2.0 * ft + 3.0 * tt; bottom = bm; top = bm + fh; cpgsvp(left, right, bottom, top); xl = datastd_med - 2.0 * std_reject; xh = datastd_med + 2.0 * std_reject; yl = 0.0; yh = T; cpgswin(xl, xh, yl, yh); cpgbox("BCST", 0.0, 0, "BST", 0.0, 0); cpgscr(maxcol, 0.0, 1.0, 0.0); cpgsci(maxcol); /* Green */ yarr[0] = yl; yarr[1] = yh; xarr[0] = xarr[1] = datastd_med; cpgline(2, xarr, yarr); cpgsls(4); /* Dotted line */ xarr[0] = xarr[1] = datastd_med + std_reject; cpgline(2, xarr, yarr); xarr[0] = xarr[1] = datastd_med - std_reject; cpgline(2, xarr, yarr); cpgsls(1); /* Solid line */ cpgsci(1); /* Default color */ cpgline(numint, std_int_med, times); yl = 0.0; yh = numint; cpgswin(xl, xh, yl, yh); cpgbox("", 0.0, 0, "CMST", 0.0, 0); /* cpgmtxt("R", 2.3, 0.5, 0.5, "Interval Number"); */ /* Data Sigma versus Channel */ left = lm + ft + 2.0 * tt; right = lm + 2.0 * ft + 2.0 * tt; bottom = bm + fh; top = bm + fh + th; cpgsvp(left, right, bottom, top); xl = 0.0; xh = numchan; yl = datastd_med - 2.0 * std_reject; yh = datastd_med + 2.0 * std_reject; cpgswin(xl, xh, yl, yh); cpgbox("BST", 0.0, 0, "BCST", 0.0, 0); cpgscr(maxcol, 0.0, 1.0, 0.0); cpgsci(maxcol); /* Green */ xarr[0] = xl; xarr[1] = xh; yarr[0] = yarr[1] = datastd_med; cpgline(2, xarr, yarr); cpgsls(4); /* Dotted line */ yarr[0] = yarr[1] = datastd_med + std_reject; cpgline(2, xarr, yarr); yarr[0] = yarr[1] = datastd_med - std_reject; cpgline(2, xarr, yarr); cpgsls(1); /* Solid line */ cpgsci(1); /* Default color */ cpgline(numchan, chans, std_chan_med); xl = lof; xh = hif; cpgswin(xl, xh, yl, yh); cpgbox("CMST", 0.0, 0, "", 0.0, 0); cpgmtxt("T", 1.8, 0.5, 0.5, "Frequency (MHz)"); /* Data Mean */ left = lm + 2.0 * ft + 4.0 * tt; right = lm + 3.0 * ft + 4.0 * tt; bottom = bm; top = bm + fh; xl = 0.0; xh = numchan; yl = 0.0; yh = T; cpgsvp(left, right, bottom, top); cpgswin(xl, xh, yl, yh); cpgscr(mincol, 0.7, 0.7, 1.0); /* Light Blue */ cpgscr(maxcol, 0.3, 0.3, 1.0); /* Dark Blue */ locut = dataavg_med - timesigma * dataavg_std; hicut = dataavg_med + timesigma * dataavg_std; tr[2] = tr[4] = 0.0; tr[1] = (xh - xl) / numchan; tr[0] = xl - (tr[1] / 2); tr[5] = (yh - yl) / numint; tr[3] = yl - (tr[5] / 2); cpgimag(dataavg[0], numchan, numint, 1, numchan, 1, numint, locut, hicut, tr); cpgswin(xl, xh, yl, yh); cpgbox("BNST", 0.0, 0, "BNST", 0.0, 0); cpgmtxt("B", 2.6, 0.5, 0.5, "Channel"); xl = lof; xh = hif; yl = 0.0; yh = numint; cpgswin(xl, xh, yl, yh); cpgbox("CST", 0.0, 0, "CST", 0.0, 0); /* Data Mean Label */ left = lm + 3.0 * ft + 4.0 * tt; right = lm + 3.0 * ft + 5.0 * tt; bottom = bm + fh; top = bm + fh + th; cpgsvp(left, right, bottom, top); cpgswin(0.0, 1.0, 0.0, 1.0); cpgscr(maxcol, 0.0, 0.0, 1.0); cpgsci(maxcol); /* Blue */ cpgptxt(0.5, 0.7, 0.0, 0.5, "Data"); cpgptxt(0.5, 0.3, 0.0, 0.5, "Mean"); cpgsci(1); /* Default color */ /* Data Mean versus Time */ left = lm + 3.0 * ft + 4.0 * tt; right = lm + 3.0 * ft + 5.0 * tt; bottom = bm; top = bm + fh; cpgsvp(left, right, bottom, top); xl = dataavg_med - 2.0 * avg_reject; xh = dataavg_med + 2.0 * avg_reject; yl = 0.0; yh = T; cpgswin(xl, xh, yl, yh); cpgbox("BCST", 0.0, 0, "BST", 0.0, 0); cpgscr(maxcol, 0.0, 0.0, 1.0); cpgsci(maxcol); /* Blue */ yarr[0] = yl; yarr[1] = yh; xarr[0] = xarr[1] = dataavg_med; cpgline(2, xarr, yarr); cpgsls(4); /* Dotted line */ xarr[0] = xarr[1] = dataavg_med + avg_reject; cpgline(2, xarr, yarr); xarr[0] = xarr[1] = dataavg_med - avg_reject; cpgline(2, xarr, yarr); cpgsls(1); /* Solid line */ cpgsci(1); /* Default color */ cpgline(numint, avg_int_med, times); yl = 0.0; yh = numint; cpgswin(xl, xh, yl, yh); cpgbox("", 0.0, 0, "CMST", 0.0, 0); /* Data Mean versus Channel */ left = lm + 2.0 * ft + 4.0 * tt; right = lm + 3.0 * ft + 4.0 * tt; bottom = bm + fh; top = bm + fh + th; cpgsvp(left, right, bottom, top); xl = 0.0; xh = numchan; yl = dataavg_med - 2.0 * avg_reject; yh = dataavg_med + 2.0 * avg_reject; cpgswin(xl, xh, yl, yh); cpgbox("BST", 0.0, 0, "BCST", 0.0, 0); cpgscr(maxcol, 0.0, 0.0, 1.0); cpgsci(maxcol); /* Blue */ xarr[0] = xl; xarr[1] = xh; yarr[0] = yarr[1] = dataavg_med; cpgline(2, xarr, yarr); cpgsls(4); /* Dotted line */ yarr[0] = yarr[1] = dataavg_med + avg_reject; cpgline(2, xarr, yarr); yarr[0] = yarr[1] = dataavg_med - avg_reject; cpgline(2, xarr, yarr); cpgsls(1); /* Solid line */ cpgsci(1); /* Default color */ cpgline(numchan, chans, avg_chan_med); xl = lof; xh = hif; cpgswin(xl, xh, yl, yh); cpgbox("CMST", 0.0, 0, "", 0.0, 0); cpgmtxt("T", 1.8, 0.5, 0.5, "Frequency (MHz)"); { /* Add the Data Info area */ char out[200], out2[100]; float dy = 0.025; cpgsvp(0.0, 1.0, 0.0, 1.0); cpgswin(0.0, 1.0, 0.0, 1.0); left = lm + ft + 1.5 * tt; top = 1.0 - tm; cpgsch(1.0); sprintf(out, "%-s", idata->name); cpgptxt(0.5, 1.0 - 0.5 * tm, 0.0, 0.5, out); cpgsch(0.8); sprintf(out, "Object:"); cpgtext(left + 0.0, top - 0 * dy, out); sprintf(out, "%-s", idata->object); cpgtext(left + 0.1, top - 0 * dy, out); sprintf(out, "Telescope:"); cpgtext(left + 0.0, top - 1 * dy, out); sprintf(out, "%-s", idata->telescope); cpgtext(left + 0.1, top - 1 * dy, out); sprintf(out, "Instrument:"); cpgtext(left + 0.0, top - 2 * dy, out); sprintf(out, "%-s", idata->instrument); cpgtext(left + 0.1, top - 2 * dy, out); ra_dec_to_string(out2, idata->ra_h, idata->ra_m, idata->ra_s); sprintf(out, "RA\\dJ2000\\u"); cpgtext(left + 0.0, top - 3 * dy, out); sprintf(out, "= %-s", out2); cpgtext(left + 0.08, top - 3 * dy, out); ra_dec_to_string(out2, idata->dec_d, idata->dec_m, idata->dec_s); sprintf(out, "DEC\\dJ2000\\u"); cpgtext(left + 0.0, top - 4 * dy, out); sprintf(out, "= %-s", out2); cpgtext(left + 0.08, top - 4 * dy, out); sprintf(out, "Epoch\\dtopo\\u"); cpgtext(left + 0.0, top - 5 * dy, out); sprintf(out, "= %-.11f", idata->mjd_i + idata->mjd_f); cpgtext(left + 0.08, top - 5 * dy, out); sprintf(out, "T\\dsample\\u (s)"); cpgtext(left + 0.0, top - 6 * dy, out); sprintf(out, "= %g", idata->dt); cpgtext(left + 0.08, top - 6 * dy, out); sprintf(out, "T\\dtotal\\u (s)"); cpgtext(left + 0.0, top - 7 * dy, out); sprintf(out, "= %g", T); cpgtext(left + 0.08, top - 7 * dy, out); left = lm + ft + 7.8 * tt; sprintf(out, "Num channels"); cpgtext(left + 0.0, top - 0 * dy, out); sprintf(out, "= %-d", numchan); cpgtext(left + 0.12, top - 0 * dy, out); sprintf(out, "Pts per int"); cpgtext(left + 0.19, top - 0 * dy, out); sprintf(out, "= %-d", ptsperint); cpgtext(left + 0.29, top - 0 * dy, out); sprintf(out, "Num intervals"); cpgtext(left + 0.0, top - 1 * dy, out); sprintf(out, "= %-d", numint); cpgtext(left + 0.12, top - 1 * dy, out); sprintf(out, "Time per int"); cpgtext(left + 0.19, top - 1 * dy, out); sprintf(out, "= %-g", inttim); cpgtext(left + 0.29, top - 1 * dy, out); sprintf(out, "Power:"); cpgtext(left + 0.0, top - 2 * dy, out); sprintf(out, "median"); cpgtext(left + 0.06, top - 2 * dy, out); sprintf(out, "= %-.3f", datapow_med); cpgtext(left + 0.12, top - 2 * dy, out); sprintf(out, "\\gs"); cpgtext(left + 0.21, top - 2 * dy, out); sprintf(out, "= %-.3g", datapow_std); cpgtext(left + 0.245, top - 2 * dy, out); find_min_max_arr(numint * numchan, datapow[0], &min, &max); sprintf(out, "min"); cpgtext(left + 0.06, top - 3 * dy, out); sprintf(out, "= %-.3f", min); cpgtext(left + 0.12, top - 3 * dy, out); sprintf(out, "max"); cpgtext(left + 0.21, top - 3 * dy, out); sprintf(out, "= %-.3f", max); cpgtext(left + 0.245, top - 3 * dy, out); sprintf(out, "Sigma:"); cpgtext(left + 0.0, top - 4 * dy, out); sprintf(out, "median"); cpgtext(left + 0.06, top - 4 * dy, out); sprintf(out, "= %-.3f", datastd_med); cpgtext(left + 0.12, top - 4 * dy, out); sprintf(out, "\\gs"); cpgtext(left + 0.21, top - 4 * dy, out); sprintf(out, "= %-.3g", datastd_std); cpgtext(left + 0.245, top - 4 * dy, out); find_min_max_arr(numint * numchan, datastd[0], &min, &max); sprintf(out, "min"); cpgtext(left + 0.06, top - 5 * dy, out); sprintf(out, "= %-.3f", min); cpgtext(left + 0.12, top - 5 * dy, out); sprintf(out, "max"); cpgtext(left + 0.21, top - 5 * dy, out); sprintf(out, "= %-.3f", max); cpgtext(left + 0.245, top - 5 * dy, out); sprintf(out, "Mean:"); cpgtext(left + 0.0, top - 6 * dy, out); sprintf(out, "median"); cpgtext(left + 0.06, top - 6 * dy, out); sprintf(out, "= %-.3f", dataavg_med); cpgtext(left + 0.12, top - 6 * dy, out); sprintf(out, "\\gs"); cpgtext(left + 0.21, top - 6 * dy, out); sprintf(out, "= %-.3g", dataavg_std); cpgtext(left + 0.245, top - 6 * dy, out); find_min_max_arr(numint * numchan, dataavg[0], &min, &max); sprintf(out, "min"); cpgtext(left + 0.06, top - 7 * dy, out); sprintf(out, "= %-.3f", min); cpgtext(left + 0.12, top - 7 * dy, out); sprintf(out, "max"); cpgtext(left + 0.21, top - 7 * dy, out); sprintf(out, "= %-.3f", max); cpgtext(left + 0.245, top - 7 * dy, out); } { /* Plot the Mask */ unsigned char byte; char temp[200]; float **plotmask, rr, gg, bb, page; plotmask = gen_fmatrix(numint, numchan); for (ii = 0; ii < numint; ii++) { for (jj = 0; jj < numchan; jj++) { byte = bytemask[ii][jj]; plotmask[ii][jj] = 0.0; if (byte & PADDING) plotmask[ii][jj] = 1.0; if (byte & OLDMASK) plotmask[ii][jj] = 2.0; if (byte & USERZAP) plotmask[ii][jj] = 3.0; if (byte & BAD_POW) plotmask[ii][jj] = 4.0; else if (byte & BAD_AVG) plotmask[ii][jj] = 5.0; else if (byte & BAD_STD) plotmask[ii][jj] = 6.0; } } /* Set the colors */ numcol = 7; maxcol = mincol + numcol - 1; cpgscir(mincol, maxcol); cpgqcr(0, &rr, &gg, &bb); cpgscr(mincol + 0, rr, gg, bb); /* GOODDATA = background */ cpgscr(mincol + 1, 0.7, 0.7, 0.7); /* PADDING = light grey */ cpgscr(mincol + 2, 0.3, 0.3, 0.3); /* OLDMASK = dark grey */ cpgqcr(1, &rr, &gg, &bb); cpgscr(mincol + 3, rr, gg, bb); /* USERZAP = foreground */ cpgscr(mincol + 4, 1.0, 0.0, 0.0); /* BAD+POW = red */ cpgscr(mincol + 5, 0.0, 0.0, 1.0); /* BAD+AVG = blue */ cpgscr(mincol + 6, 0.0, 1.0, 0.0); /* BAD+STD = green */ /* Prep the image */ for (page = 0; page <= 1; page++) { xl = 0.0; xh = numchan; yl = 0.0; yh = T; locut = 0.0; hicut = 6.0; tr[2] = tr[4] = 0.0; tr[1] = (xh - xl) / numchan; tr[0] = xl - (tr[1] / 2); tr[5] = (yh - yl) / numint; tr[3] = yl - (tr[5] / 2); if (page == 0) { left = lm + 3.0 * ft + 6.0 * tt; right = lm + 4.0 * ft + 6.0 * tt; bottom = bm; top = bm + fh; } else { cpgpage(); cpgiden(); left = 0.06; right = 0.94; bottom = 0.06; top = 0.88; } cpgsvp(left, right, bottom, top); cpgswin(xl, xh, yl, yh); cpgimag(plotmask[0], numchan, numint, 1, numchan, 1, numint, locut, hicut, tr); cpgswin(xl, xh, yl, yh); cpgbox("BNST", 0.0, 0, "BNST", 0.0, 0); cpgmtxt("B", 2.6, 0.5, 0.5, "Channel"); if (page) cpgmtxt("L", 2.1, 0.5, 0.5, "Time (s)"); xl = lof; xh = hif; yl = 0.0; yh = numint; cpgswin(xl, xh, yl, yh); cpgbox("CMST", 0.0, 0, "CMST", 0.0, 0); cpgmtxt("T", 1.8, 0.5, 0.5, "Frequency (MHz)"); cpgmtxt("R", 2.3, 0.5, 0.5, "Interval Number"); /* Add the Labels */ cpgsvp(0.0, 1.0, 0.0, 1.0); cpgswin(0.0, 1.0, 0.0, 1.0); cpgsch(0.8); if (page == 0) { cpgsci(mincol + 1); cpgptxt(left, top + 0.1, 0.0, 0.0, "Padding"); cpgsci(mincol + 2); cpgptxt(left, top + 0.08, 0.0, 0.0, "Old Mask"); cpgsci(mincol + 3); cpgptxt(left, top + 0.06, 0.0, 0.0, "User Zap"); cpgsci(mincol + 4); cpgptxt(right, top + 0.1, 0.0, 1.0, "Power"); cpgsci(mincol + 6); cpgptxt(right, top + 0.08, 0.0, 1.0, "Sigma"); cpgsci(mincol + 5); cpgptxt(right, top + 0.06, 0.0, 1.0, "Mean"); cpgsci(1); } else { cpgsci(mincol + 1); cpgptxt(1.0 / 12.0, 0.955, 0.0, 0.5, "Padding"); cpgsci(mincol + 2); cpgptxt(3.0 / 12.0, 0.955, 0.0, 0.5, "Old Mask"); cpgsci(mincol + 3); cpgptxt(5.0 / 12.0, 0.955, 0.0, 0.5, "User Zap"); cpgsci(mincol + 4); cpgptxt(7.0 / 12.0, 0.955, 0.0, 0.5, "Max Power"); cpgsci(mincol + 6); cpgptxt(9.0 / 12.0, 0.955, 0.0, 0.5, "Data Sigma"); cpgsci(mincol + 5); cpgptxt(11.0 / 12.0, 0.955, 0.0, 0.5, "Data Mean"); cpgsci(1); cpgsch(0.9); sprintf(temp, "Recommended Mask for '%-s'", idata->name); cpgptxt(0.5, 0.985, 0.0, 0.5, temp); } } vect_free(plotmask[0]); vect_free(plotmask); } if (ct == 0) printf("There are %d RFI instances.\n\n", numrfi); if ((ct == 0 && rfips) || (ct == 1 && rfixwin)) { /* Plot the RFI instances */ int maxcol, mincol, numperpage = 25, numtoplot; float dy = 0.035, top = 0.95, rr, gg, bb; char temp[200]; qsort(rfivect, numrfi, sizeof(rfi), compare_rfi_freq); /* qsort(rfivect, numrfi, sizeof(rfi), compare_rfi_sigma); */ for (ii = 0; ii <= (numrfi - 1) / numperpage; ii++) { cpgpage(); cpgiden(); cpgsvp(0.0, 1.0, 0.0, 1.0); cpgswin(0.0, 1.0, 0.0, 1.0); cpgsch(0.8); sprintf(temp, "%-s", idata->name); cpgtext(0.05, 0.985, temp); cpgsch(0.6); sprintf(temp, "Freq (Hz)"); cpgptxt(0.03, 0.96, 0.0, 0.0, temp); sprintf(temp, "Period (ms)"); cpgptxt(0.12, 0.96, 0.0, 0.0, temp); sprintf(temp, "Sigma"); cpgptxt(0.21, 0.96, 0.0, 0.0, temp); sprintf(temp, "Number"); cpgptxt(0.27, 0.96, 0.0, 0.0, temp); cpgsvp(0.33, 0.64, top - dy, top); cpgswin(lof, hif, 0.0, 1.0); cpgbox("CIMST", 0.0, 0, "", 0.0, 0); cpgmtxt("T", 2.5, 0.5, 0.5, "Frequency (MHz)"); cpgsvp(0.65, 0.96, top - dy, top); cpgswin(0.0, T, 0.0, 1.0); cpgbox("CIMST", 0.0, 0, "", 0.0, 0); cpgmtxt("T", 2.5, 0.5, 0.5, "Time (s)"); cpgqcir(&mincol, &maxcol); maxcol = mincol + 1; cpgscir(mincol, maxcol); cpgqcr(0, &rr, &gg, &bb); cpgscr(mincol, rr, gg, bb); /* background */ cpgqcr(1, &rr, &gg, &bb); /* cpgscr(maxcol, rr, gg, bb); foreground */ cpgscr(maxcol, 0.5, 0.5, 0.5); /* grey */ if (ii == (numrfi - 1) / numperpage) numtoplot = numrfi % numperpage; else numtoplot = numperpage; for (jj = 0; jj < numtoplot; jj++) plot_rfi(rfivect + ii * numperpage + jj, top - jj * dy, numint, numchan, T, lof, hif); cpgsvp(0.33, 0.64, top - jj * dy, top - (jj - 1) * dy); cpgswin(0.0, numchan, 0.0, 1.0); cpgbox("BINST", 0.0, 0, "", 0.0, 0); cpgmtxt("B", 2.5, 0.5, 0.5, "Channel"); cpgsvp(0.65, 0.96, top - jj * dy, top - (jj - 1) * dy); cpgswin(0.0, numint, 0.0, 1.0); cpgbox("BINST", 0.0, 0, "", 0.0, 0); cpgmtxt("B", 2.5, 0.5, 0.5, "Interval"); } } cpgclos(); } /* Plot for loop */ /* Free our arrays */ vect_free(freqs); vect_free(chans); vect_free(times); vect_free(ints); vect_free(avg_chan_avg); vect_free(std_chan_avg); vect_free(pow_chan_avg); vect_free(avg_int_avg); vect_free(std_int_avg); vect_free(pow_int_avg); vect_free(avg_chan_med); vect_free(std_chan_med); vect_free(pow_chan_med); vect_free(avg_int_med); vect_free(std_int_med); vect_free(pow_int_med); vect_free(avg_chan_std); vect_free(std_chan_std); vect_free(pow_chan_std); vect_free(avg_int_std); vect_free(std_int_std); vect_free(pow_int_std); }
/* * Class: pulsarhunter_PgplotInterface * Method: pgclose * Signature: ()V */ JNIEXPORT void JNICALL Java_pulsarhunter_PgplotInterface_pgclose (JNIEnv *env, jclass cl){ cpgclos(); }
int main(int argc, char **argv) { float lm, hm; int ID; float x1, y1, x2, y2; char ch; char filename[1024]; int enhanceid = -1; int sectionmode = LON; int histmode = DEP; float binw = 10.0; reset(&mainset); load(&mainset); rangeadjust(&control, &mainset, NULL, NULL, NULL, NULL); ID = cpgopen("/xwindow"); resizemax(0.85); cpgask(0); /* * This a bug-fix for the gmt command that outputs the borders wrapped. */ int i; for(i=0; i < nborders; i++) if (borders[i][0] != -999 && borders[i][0] > 180) borders[i][0] = borders[i][0] - 360.0; lm = hm = -1.0; while (ch != 'Q') { if (control.printout) { lerchar("Entre com o nome do arquivo", filename, 1000); if (strlen(filename) == 0) { strcpy(message, "Nome invalido."); alert(ERROR); control.printout = 0; } else { if (strlen(filename) < 3 || strncasecmp( &filename[strlen(filename)-3], ".ps", 3) != 0) { sprintf(filename,"%s.ps/cps",filename); } else { sprintf(filename,"%s/cps",filename); } cpgopen(filename); cpgask(0); } } plot(&control, &mainset); if (control.printout == 0 && enhanceid != -1) { enhanceid = enhance(&control, &mainset, enhanceid); } if (mainset.region) { plotsection(&mainset, &control, sectionmode); plothistogram(&mainset, binw, histmode, lm, hm); } if (control.printout) { cpgclos(); cpgslct(ID); control.printout = 0; filename[strlen(filename) - 4] = '\0'; sprintf(message, "Print Out saved to file %s", filename); alert(INFO); continue; } // Restore default map position cpgsvp(0.07, 0.93, 0.35, 0.9); cpgswin(control.xmin, control.xmax, control.ymin, control.ymax); ch = getonechar(&x1, &y1, 0); switch(ch) { case('='): { control.printout = 1; break; } case('R'): { reset(&mainset); load(&mainset); break; } case('B'): { binw = lerfloat("Entre com o valor da largura do bin?"); break; } case('A'): { enhanceid = findpt(&mainset, x1, y1); break; } case('2'): { control.hasplates = (control.hasplates == 1) ? 0 : 1; break; } case('1'): { control.hascontinents++; if (control.hascontinents > 2) control.hascontinents = 0; break; } case ('W'): { control.xmax = 180; control.xmin = -180; control.ymax = 90; control.ymin = -90; break; } case('0'): { mainset.lon1 = -180; mainset.lon2 = 180; mainset.lat1 = -90; mainset.lat2 = 90; load(&mainset); mainset.region = 0; break; } case ('L'): { sectionmode = (sectionmode == LAT) ? LON : LAT; break; } case ('H'): { histmode = (histmode == MAG) ? DEP : MAG; binw = (histmode == MAG) ? 0.1 : 10.0; break; } case ('S'): { x2 = x1; y2 = y1; getonechar(&x2, &y2, 1); order(&x1,&x2); order(&y1,&y2); mainset.lon1 = x1; mainset.lon2 = x2; mainset.lat1 = y1; mainset.lat2 = y2; load(&mainset); mainset.region = 1; break; } case('X'): { // ZOOM x2 = x1; y2 = y1; getonechar(&x2, &y2, 1); order(&x1,&x2); order(&y1,&y2); rangeadjust(&control, &mainset, &x1, &x2, &y1, &y2); break; } case('C'): { // Color mode control.colormode ++; if (control.colormode>COLORMAG) control.colormode = COLORNONE; break; } case('N'): { /* Ano */ int y1, y2; y1 = lerint("Entre com ano inicial?"); y2 = lerint("Entre com ano final?"); orderint(&y1,&y2); mainset.y1 = y1; mainset.y2 = y2; load(&mainset); break; } case('M'): { /* Magnitude */ float m1, m2; m1 = lerfloat("Entre com a Magnitude Inicial?"); m2 = lerfloat("Entre com a Magnitude Final?"); order(&m1,&m2); mainset.m1 = m1; mainset.m2 = m2; load(&mainset); break; } case('J'): { /* Ajuste */ lm = lerfloat("Entre com o menor valor de mag. para ajuste."); hm = lerfloat("Entre com o maior valor de mag. para ajuste."); if (lm == hm) { lm = hm = -1; } break; } case('P'): { /* Profundidade */ float d1, d2; d1 = lerfloat("Entre com a Profundidade Minima?"); d2 = lerfloat("Entre com a Profundidade Maxima?"); order(&d1,&d2); mainset.d1 = d1; mainset.d2 = d2; load(&mainset); break; } } } cpgclos(); }
void Plotter2::close() { if (hasDevice) { cpgclos(); hasDevice = false; } }
int main(int argc, char *argv[]) { int ii, jj, numbirds; double lofreq, hifreq; char *rootfilenm; birdie *newbird; GSList *zapped = NULL; infodata idata; Cmdline *cmd; /* Call usage() if we have no command line arguments */ if (argc == 1) { Program = argv[0]; printf("\n"); usage(); exit(1); } /* Parse the command line using the excellent program Clig */ cmd = parseCmdline(argc, argv); #ifdef DEBUG showOptionValues(); #endif printf("\n\n"); printf(" Interactive/Automatic Birdie Zapping Program\n"); printf(" by Scott M. Ransom\n"); printf(" January, 2001\n\n"); if (!cmd->zapP && !cmd->inzapfileP && !cmd->outzapfileP) { printf("You must specify '-in' and '-out' if you are not\n"); printf("automatically zapping a file (with '-zap').\n\n"); exit(0); } { int hassuffix = 0; char *suffix; hassuffix = split_root_suffix(cmd->argv[0], &rootfilenm, &suffix); if (hassuffix) { if (strcmp(suffix, "fft") != 0) { printf("\nInput file ('%s') must be a FFT file ('.fft')!\n\n", cmd->argv[0]); free(suffix); exit(0); } free(suffix); } else { printf("\nInput file ('%s') must be a FFT file ('.fft')!\n\n", cmd->argv[0]); exit(0); } } /* Read the info file */ readinf(&idata, rootfilenm); if (idata.object) { printf("Examining %s data from '%s'.\n\n", remove_whitespace(idata.object), cmd->argv[0]); } else { printf("Examining data from '%s'.\n\n", cmd->argv[0]); } T = idata.dt * idata.N; dr = 1.0 / NUMBETWEEN; if (cmd->zapP) { /* Automatic */ double *bird_lobins, *bird_hibins, hibin; if (!cmd->zapfileP) { printf("You must specify a 'zapfile' containing freqs\n"); printf("and widths if you want to write to the FFT file.\n\n"); free(rootfilenm); exit(0); } hibin = idata.N / 2; /* Read the Standard bird list */ numbirds = get_birdies(cmd->zapfile, T, cmd->baryv, &bird_lobins, &bird_hibins); /* Zap the birdies */ fftfile = chkfopen(cmd->argv[0], "rb+"); for (ii = 0; ii < numbirds; ii++) { if (bird_lobins[ii] >= hibin) break; if (bird_hibins[ii] >= hibin) bird_hibins[ii] = hibin - 1; zapbirds(bird_lobins[ii], bird_hibins[ii], fftfile, NULL); } vect_free(bird_lobins); vect_free(bird_hibins); } else { /* Interactive */ int *bird_numharms; double *bird_basebins; /* Read the Standard bird list */ numbirds = get_std_birds(cmd->inzapfile, T, cmd->baryv, &bird_basebins, &bird_numharms); /* Create our correlation kernel */ { int numkern; fcomplex *resp; khw = r_resp_halfwidth(LOWACC); numkern = 2 * NUMBETWEEN * khw; resp = gen_r_response(0.0, NUMBETWEEN, numkern); kernel = gen_cvect(FFTLEN); place_complex_kernel(resp, numkern, kernel, FFTLEN); COMPLEXFFT(kernel, FFTLEN, -1); vect_free(resp); } /* Loop over the birdies */ fftfile = chkfopen(cmd->argv[0], "rb"); cpgstart_x("landscape"); cpgask(0); for (ii = 0; ii < numbirds; ii++) { for (jj = 0; jj < bird_numharms[ii]; jj++) { process_bird(bird_basebins[ii], jj + 1, &lofreq, &hifreq); if (lofreq && hifreq) { newbird = birdie_create(lofreq, hifreq, cmd->baryv); zapped = g_slist_insert_sorted(zapped, newbird, birdie_compare); } } } cpgclos(); /* Output the birdies */ { FILE *outfile; outfile = chkfopen(cmd->outzapfile, "w"); fprintf(outfile, "#\n"); fprintf(outfile, "# Topocentric birdies found using 'zapbirds' for '%s'\n", cmd->argv[0]); fprintf(outfile, "#\n"); fprintf(outfile, "# Frequency (Hz) Width (Hz)\n"); fprintf(outfile, "#\n"); g_slist_foreach(zapped, birdie_print, outfile); fclose(outfile); } printf("\nOutput birdie file is '%s'.\n\n", cmd->outzapfile); /* Free the memory */ g_slist_foreach(zapped, birdie_free, NULL); g_slist_free(zapped); vect_free(kernel); vect_free(bird_numharms); vect_free(bird_basebins); } fclose(fftfile); free(rootfilenm); printf("Done\n\n"); return 0; }
int main(int argc, char *argv[]) { float maxpow = 0.0, inx = 0.0, iny = 0.0; double centerr, offsetf; int zoomlevel, maxzoom, minzoom, xid, psid; char *rootfilenm, inchar; fftpart *lofp; fftview *fv; if (argc == 1) { printf("\nusage: explorefft fftfilename\n\n"); exit(0); } printf("\n\n"); printf(" Interactive FFT Explorer\n"); printf(" by Scott M. Ransom\n"); printf(" October, 2001\n"); print_help(); { int hassuffix = 0; char *suffix; hassuffix = split_root_suffix(argv[1], &rootfilenm, &suffix); if (hassuffix) { if (strcmp(suffix, "fft") != 0) { printf("\nInput file ('%s') must be a FFT file ('.fft')!\n\n", argv[1]); free(suffix); exit(0); } free(suffix); } else { printf("\nInput file ('%s') must be a FFT file ('.fft')!\n\n", argv[1]); exit(0); } } /* Read the info file */ readinf(&idata, rootfilenm); if (strlen(remove_whitespace(idata.object)) > 0) { printf("Examining %s data from '%s'.\n\n", remove_whitespace(idata.object), argv[1]); } else { printf("Examining data from '%s'.\n\n", argv[1]); } N = idata.N; T = idata.dt * idata.N; #ifdef USEMMAP printf("Memory mapping the input FFT. This may take a while...\n"); mmap_file = open(argv[1], O_RDONLY); { int rt; struct stat buf; rt = fstat(mmap_file, &buf); if (rt == -1) { perror("\nError in fstat() in explorefft.c"); printf("\n"); exit(-1); } Nfft = buf.st_size / sizeof(fcomplex); } lofp = get_fftpart(0, Nfft); #else { int numamps; fftfile = chkfopen(argv[1], "rb"); Nfft = chkfilelen(fftfile, sizeof(fcomplex)); numamps = (Nfft > MAXBINS) ? (int) MAXBINS : (int) Nfft; lofp = get_fftpart(0, numamps); } #endif /* Plot the initial data */ { int initnumbins = INITIALNUMBINS; if (initnumbins > Nfft) { initnumbins = next2_to_n(Nfft) / 2; zoomlevel = LOGDISPLAYNUM - (int) (log(initnumbins) / log(2.0)); minzoom = zoomlevel; } else { zoomlevel = LOGDISPLAYNUM - LOGINITIALNUMBINS; minzoom = LOGDISPLAYNUM - LOGMAXBINS; } maxzoom = LOGDISPLAYNUM - LOGMINBINS; centerr = initnumbins / 2; } fv = get_fftview(centerr, zoomlevel, lofp); /* Prep the XWIN device for PGPLOT */ xid = cpgopen("/XWIN"); if (xid <= 0) { free(fv); #ifdef USEMMAP close(mmap_file); #else fclose(fftfile); #endif free_fftpart(lofp); exit(EXIT_FAILURE); } cpgscr(15, 0.4, 0.4, 0.4); cpgask(0); cpgpage(); offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0); do { cpgcurs(&inx, &iny, &inchar); if (DEBUGOUT) printf("You pressed '%c'\n", inchar); switch (inchar) { case 'A': /* Zoom in */ case 'a': centerr = (inx + offsetf) * T; case 'I': case 'i': if (DEBUGOUT) printf(" Zooming in (zoomlevel = %d)...\n", zoomlevel); if (zoomlevel < maxzoom) { zoomlevel++; free(fv); fv = get_fftview(centerr, zoomlevel, lofp); cpgpage(); offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0); } else printf(" Already at maximum zoom level (%d).\n", zoomlevel); break; case 'X': /* Zoom out */ case 'x': case 'O': case 'o': if (DEBUGOUT) printf(" Zooming out (zoomlevel = %d)...\n", zoomlevel); if (zoomlevel > minzoom) { zoomlevel--; free(fv); fv = get_fftview(centerr, zoomlevel, lofp); cpgpage(); offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0); } else printf(" Already at minimum zoom level (%d).\n", zoomlevel); break; case '<': /* Shift left 1 full screen */ centerr -= fv->numbins + fv->numbins / 8; case ',': /* Shift left 1/8 screen */ if (DEBUGOUT) printf(" Shifting left...\n"); centerr -= fv->numbins / 8; { /* Should probably get the previous chunk from the fftfile... */ double lowestr; lowestr = 0.5 * fv->numbins; if (centerr < lowestr) centerr = lowestr; } free(fv); fv = get_fftview(centerr, zoomlevel, lofp); cpgpage(); offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0); break; case '>': /* Shift right 1 full screen */ centerr += fv->numbins - fv->numbins / 8; case '.': /* Shift right 1/8 screen */ if (DEBUGOUT) printf(" Shifting right...\n"); centerr += fv->numbins / 8; { /* Should probably get the next chunk from the fftfile... */ double highestr; highestr = lofp->rlo + lofp->numamps - 0.5 * fv->numbins; if (centerr > highestr) centerr = highestr; } free(fv); fv = get_fftview(centerr, zoomlevel, lofp); cpgpage(); offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0); break; case '+': /* Increase height of powers */ case '=': if (maxpow == 0.0) { printf(" Auto-scaling is off.\n"); maxpow = 1.1 * fv->maxpow; } maxpow = 3.0 / 4.0 * maxpow; cpgpage(); offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0); break; case '-': /* Decrease height of powers */ case '_': if (maxpow == 0.0) { printf(" Auto-scaling is off.\n"); maxpow = 1.1 * fv->maxpow; } maxpow = 4.0 / 3.0 * maxpow; cpgpage(); offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0); break; case 'S': /* Auto-scale */ case 's': if (maxpow == 0.0) break; else { printf(" Auto-scaling is on.\n"); maxpow = 0.0; cpgpage(); offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0); break; } case 'G': /* Goto a frequency */ case 'g': { char freqstr[50]; double freq = -1.0; while (freq < 0.0) { printf(" Enter the frequency (Hz) to go to:\n"); fgets(freqstr, 50, stdin); freqstr[strlen(freqstr) - 1] = '\0'; freq = atof(freqstr); } offsetf = 0.0; centerr = freq * T; printf(" Moving to frequency %.15g.\n", freq); free(fv); fv = get_fftview(centerr, zoomlevel, lofp); cpgpage(); offsetf = plot_fftview(fv, maxpow, 1.0, centerr, 2); } break; case 'H': /* Show harmonics */ case 'h': { double retval; retval = harmonic_loop(xid, centerr, zoomlevel, lofp); if (retval > 0.0) { offsetf = 0.0; centerr = retval; free(fv); fv = get_fftview(centerr, zoomlevel, lofp); cpgpage(); offsetf = plot_fftview(fv, maxpow, 1.0, centerr, 2); } } break; case '?': /* Print help screen */ print_help(); break; case 'D': /* Show details about a selected point */ case 'd': { double newr; printf(" Searching for peak near freq = %.7g Hz...\n", (inx + offsetf)); newr = find_peak(inx + offsetf, fv, lofp); centerr = newr; free(fv); fv = get_fftview(centerr, zoomlevel, lofp); cpgpage(); offsetf = plot_fftview(fv, maxpow, 1.0, centerr, 2); } break; case 'L': /* Load a zaplist */ case 'l': { int ii, len; char filename[200]; double *lobins, *hibins; printf(" Enter the filename containing the zaplist to load:\n"); fgets(filename, 199, stdin); len = strlen(filename) - 1; filename[len] = '\0'; numzaplist = get_birdies(filename, T, 0.0, &lobins, &hibins); lenzaplist = numzaplist + 20; /* Allow some room to add more */ if (lenzaplist) free(zaplist); zaplist = (bird *) malloc(sizeof(bird) * lenzaplist); for (ii = 0; ii < numzaplist; ii++) { zaplist[ii].lobin = lobins[ii]; zaplist[ii].hibin = hibins[ii]; } vect_free(lobins); vect_free(hibins); printf("\n"); cpgpage(); offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0); } break; case 'Z': /* Add a birdie to a zaplist */ case 'z': { int badchoice = 2; float lox, hix, loy, hiy; double rs[2]; char choice; if (numzaplist + 1 > lenzaplist) { lenzaplist += 10; zaplist = (bird *) realloc(zaplist, sizeof(bird) * lenzaplist); } cpgqwin(&lox, &hix, &loy, &hiy); printf(" Click the left mouse button on the first frequency limit.\n"); while (badchoice) { cpgcurs(&inx, &iny, &choice); if (choice == 'A' || choice == 'a') { rs[2 - badchoice] = ((double) inx + offsetf) * T; cpgsave(); cpgsci(7); cpgmove(inx, 0.0); cpgdraw(inx, hiy); cpgunsa(); badchoice--; if (badchoice == 1) printf (" Click the left mouse button on the second frequency limit.\n"); } else { printf(" Option not recognized.\n"); } }; if (rs[1] > rs[0]) { zaplist[numzaplist].lobin = rs[0]; zaplist[numzaplist].hibin = rs[1]; } else { zaplist[numzaplist].lobin = rs[1]; zaplist[numzaplist].hibin = rs[0]; } printf(" The new birdie has: f_avg = %.15g f_width = %.15g\n\n", 0.5 * (zaplist[numzaplist].hibin + zaplist[numzaplist].lobin) / T, (zaplist[numzaplist].hibin - zaplist[numzaplist].lobin) / T); numzaplist++; qsort(zaplist, numzaplist, sizeof(bird), compare_birds); cpgpage(); offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0); } break; case 'P': /* Print the current plot */ case 'p': { int len; char filename[200]; printf(" Enter the filename to save the plot as:\n"); fgets(filename, 196, stdin); len = strlen(filename) - 1; filename[len + 0] = '/'; filename[len + 1] = 'P'; filename[len + 2] = 'S'; filename[len + 3] = '\0'; psid = cpgopen(filename); cpgslct(psid); cpgpap(10.25, 8.5 / 11.0); cpgiden(); cpgscr(15, 0.8, 0.8, 0.8); offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0); cpgclos(); cpgslct(xid); cpgscr(15, 0.4, 0.4, 0.4); filename[len] = '\0'; printf(" Wrote the plot to the file '%s'.\n", filename); } break; case 'N': /* Changing power normalization */ case 'n': { float inx2 = 0.0, iny2 = 0.0; char choice; unsigned char badchoice = 1; printf(" Specify the type of power normalization:\n" " m,M : Median values determined locally\n" " d,D : DC frequency amplitude\n" " r,R : Raw powers (i.e. no normalization)\n" " u,U : User specified interval (the average powers)\n"); while (badchoice) { cpgcurs(&inx2, &iny2, &choice); switch (choice) { case 'M': case 'm': norm_const = 0.0; maxpow = 0.0; badchoice = 0; printf (" Using local median normalization. Autoscaling is on.\n"); break; case 'D': case 'd': norm_const = 1.0 / r0; maxpow = 0.0; badchoice = 0; printf (" Using DC frequency (%f) normalization. Autoscaling is on.\n", r0); break; case 'R': case 'r': norm_const = 1.0; maxpow = 0.0; badchoice = 0; printf (" Using raw powers (i.e. no normalization). Autoscaling is on.\n"); break; case 'U': case 'u': { char choice2; float xx = inx, yy = iny; int lor, hir, numr; double avg, var; printf (" Use the left mouse button to select a left and right boundary\n" " of a region to calculate the average power.\n"); do { cpgcurs(&xx, &yy, &choice2); } while (choice2 != 'A' && choice2 != 'a'); lor = (int) ((xx + offsetf) * T); cpgsci(7); cpgmove(xx, 0.0); cpgdraw(xx, 10.0 * fv->maxpow); do { cpgcurs(&xx, &yy, &choice2); } while (choice2 != 'A' && choice2 != 'a'); hir = (int) ((xx + offsetf) * T); cpgmove(xx, 0.0); cpgdraw(xx, 10.0 * fv->maxpow); cpgsci(1); if (lor > hir) { int tempr; tempr = hir; hir = lor; lor = tempr; } numr = hir - lor + 1; avg_var(lofp->rawpowers + lor - lofp->rlo, numr, &avg, &var); printf(" Selection has: average = %.5g\n" " std dev = %.5g\n", avg, sqrt(var)); norm_const = 1.0 / avg; maxpow = 0.0; badchoice = 0; printf (" Using %.5g as the normalization constant. Autoscaling is on.\n", avg); break; } default: printf(" Unrecognized choice '%c'.\n", choice); break; } } free(fv); fv = get_fftview(centerr, zoomlevel, lofp); cpgpage(); offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0); } break; case 'Q': /* Quit */ case 'q': printf(" Quitting...\n"); free(fv); cpgclos(); break; default: printf(" Unrecognized option '%c'.\n", inchar); break; } } while (inchar != 'Q' && inchar != 'q'); free_fftpart(lofp); #ifdef USEMMAP close(mmap_file); #else fclose(fftfile); #endif if (lenzaplist) free(zaplist); printf("Done\n\n"); return 0; }
static double harmonic_loop(int xid, double rr, int zoomlevel, fftpart * fp) { float inx = 0.0, iny = 0.0; double retval = 0.0; int xid2, psid, badchoice = 1; char choice; xid2 = cpgopen("/XWIN"); cpgpap(10.25, 8.5 / 11.0); cpgask(0); cpgslct(xid2); plot_harmonics(rr, zoomlevel, fp); printf(" Click on the harmonic to go it,\n" " press 'P' to print, or press 'Q' to close.\n"); while (badchoice) { cpgcurs(&inx, &iny, &choice); if (choice == 'Q' || choice == 'q') { badchoice = 0; } else if (choice == 'P' || choice == 'p') { int len, numharmbins; double offsetf; char filename[200]; fftpart *harmpart; fftview *harmview; printf(" Enter the filename to save the plot as:\n"); fgets(filename, 195, stdin); len = strlen(filename) - 1; strcpy(filename + len, "/CPS"); psid = cpgopen(filename); cpgslct(psid); cpgpap(10.25, 8.5 / 11.0); cpgiden(); cpgscr(15, 0.8, 0.8, 0.8); numharmbins = (1 << (LOGDISPLAYNUM - zoomlevel)); harmpart = get_fftpart((int) (rr - numharmbins), 2 * numharmbins); harmview = get_fftview(rr, zoomlevel, harmpart); free_fftpart(harmpart); offsetf = plot_fftview(harmview, 0.0, 1.0, rr, 2); cpgpage(); plot_harmonics(rr, zoomlevel, fp); cpgclos(); cpgslct(xid2); cpgscr(15, 0.4, 0.4, 0.4); filename[len] = '\0'; printf(" Wrote the plot to the file '%s'.\n", filename); } else if (choice == 'A' || choice == 'a') { if (iny > 1.0) retval = rr * (int) (inx); else if (iny > 0.0) retval = rr * ((int) (inx) + 4.0); else if (iny > -1.0) retval = rr / (int) (inx); else retval = rr / ((int) (inx) + 4.0); badchoice = 0; } else { printf(" Option not recognized.\n"); } }; cpgclos(); cpgslct(xid); return retval; }
int main(int argc, char** argv){ float tr[6]; const float ZAP=32; const uint64_t TSIZE=18; const uint64_t zapE=64; fftwf_init_threads(); fftwf_plan_with_nthreads(omp_get_max_threads()); logmsg("Open file '%s'",argv[1]); FILE* f = fopen(argv[1],"r"); int hdr_bytes = read_header(f); const uint64_t nskip = hdr_bytes; const uint64_t nchan = nchans; logmsg("Nchan=%"PRIu64", tsamp=%f",nchan,tsamp); mjk_rand_t *random = mjk_rand_init(12345); rewind(f); FILE* of = fopen("clean.fil","w"); uint8_t hdr[nskip]; fread(hdr,1,nskip,f); fwrite(hdr,1,nskip,of); const uint64_t nsamp_per_block=round(pow(2,TSIZE)); logmsg("Tblock = %f",nsamp_per_block*tsamp); mjk_clock_t *t_all = init_clock(); start_clock(t_all); mjk_clock_t *t_read = init_clock(); mjk_clock_t *t_trns= init_clock(); mjk_clock_t *t_rms = init_clock(); mjk_clock_t *t_fft = init_clock(); mjk_clock_t *t_spec = init_clock(); const uint64_t bytes_per_block = nchan*nsamp_per_block; uint8_t *buffer = calloc(bytes_per_block,1); float **data = malloc_2df(nchan,nsamp_per_block); float **clean = malloc_2df(nchan,nsamp_per_block); float *bpass = calloc(nchan,sizeof(float)); float *ch_var=NULL; float *ch_mean=NULL; float *ch_fft_n=NULL; float *ch_fft_p=NULL; logmsg("Planning FFT - this will take a long time the first time it is run!"); start_clock(t_fft); FILE * wisfile; if(wisfile=fopen("wisdom.txt","r")){ fftwf_import_wisdom_from_file(wisfile); fclose(wisfile); } const int fftX=nsamp_per_block; const int fftY=nchan; const int fftXo=nsamp_per_block/2+1; float *X = fftwf_malloc(sizeof(float)*fftX); for (uint64_t i = 0; i < nsamp_per_block ; i++){ X[i]=i; } float *tseries = fftwf_malloc(sizeof(float)*fftX); float complex *fseries = fftwf_malloc(sizeof(float complex)*fftXo); float *pseries = fftwf_malloc(sizeof(float)*fftXo); uint8_t *mask = malloc(sizeof(uint8_t)*fftXo); fftwf_plan fft_1d = fftwf_plan_dft_r2c_1d(fftX,tseries,fseries,FFTW_MEASURE|FFTW_DESTROY_INPUT); complex float * fftd = fftwf_malloc(sizeof(complex float)*(fftXo*fftY)); fftwf_plan fft_plan = fftwf_plan_many_dft_r2c( 1,&fftX,fftY, data[0] ,&fftX,1,fftX, fftd ,&fftXo,1,fftXo, FFTW_MEASURE|FFTW_PRESERVE_INPUT); logmsg("Planning iFFT - this will take a long time the first time it is run!"); fftwf_plan ifft_plan = fftwf_plan_many_dft_c2r( 1,&fftX,fftY, fftd ,&fftXo,1,fftXo, clean[0] ,&fftX,1,fftX, FFTW_MEASURE|FFTW_PRESERVE_INPUT); if(!fft_plan){ logmsg("Error - could not do FFT plan"); exit(2); } wisfile=fopen("wisdom.txt","w"); fftwf_export_wisdom_to_file(wisfile); fclose(wisfile); stop_clock(t_fft); logmsg("T(planFFT)= %.2lfs",read_clock(t_fft)); reset_clock(t_fft); float min_var=1e9; float max_var=0; float min_fft_n=1e9; float max_fft_n=0; float min_fft_p=1e9; float max_fft_p=0; float min_mean=1e9; float max_mean=0; uint64_t nblocks=0; uint64_t totread=0; while(!feof(f)){ nblocks++; ch_var = realloc(ch_var,nchan*nblocks*sizeof(float)); ch_mean = realloc(ch_mean,nchan*nblocks*sizeof(float)); ch_fft_n = realloc(ch_fft_n,nchan*nblocks*sizeof(float)); ch_fft_p = realloc(ch_fft_p,nchan*nblocks*sizeof(float)); start_clock(t_read); uint64_t read = fread(buffer,1,bytes_per_block,f); stop_clock(t_read); if (read!=bytes_per_block){ nblocks--; break; } totread+=read; logmsg("read=%"PRIu64" bytes. T=%fs",read,totread*tsamp/(float)nchan); uint64_t offset = (nblocks-1)*nchan; start_clock(t_trns); // transpose with small blocks in order to increase cache efficiency. #define BLK 8 #pragma omp parallel for schedule(static,2) shared(buffer,data) for (uint64_t j = 0; j < nchan ; j+=BLK){ for (uint64_t i = 0; i < nsamp_per_block ; i++){ for (uint64_t k = 0; k < BLK ; k++){ data[j+k][i] = buffer[i*nchan+j+k]; } } } #pragma omp parallel for shared(data) for (uint64_t j = 0; j < nchan ; j++){ if(j<zapE || (nchan-j) < zapE){ for (uint64_t i = 0; i < nsamp_per_block ; i++){ data[j][i]=ZAP; } } } if(nblocks==1){ #pragma omp parallel for shared(data,bpass) for (uint64_t j = 0; j < nchan ; j++){ for (uint64_t i = 0; i < nsamp_per_block ; i++){ bpass[j]+=data[j][i]; } bpass[j]/=(float)nsamp_per_block; bpass[j]-=ZAP; } } #pragma omp parallel for shared(data,bpass) for (uint64_t j = 0; j < nchan ; j++){ for (uint64_t i = 0; i < nsamp_per_block ; i++){ data[j][i]-=bpass[j]; } } stop_clock(t_trns); start_clock(t_rms); #pragma omp parallel for shared(data,ch_mean,ch_var) for (uint64_t j = 0; j < nchan ; j++){ float mean=0; for (uint64_t i = 0; i < nsamp_per_block ; i++){ mean+=data[j][i]; } mean/=(float)nsamp_per_block; if(mean > ZAP+5 || mean < ZAP-5){ logmsg("ZAP ch=%"PRIu64,j); for (uint64_t i = 0; i < nsamp_per_block ; i++){ data[j][i]=ZAP; } } float ss=0; float x=0; for (uint64_t i = 0; i < nsamp_per_block ; i++){ x = data[j][i]-mean; ss+=x*x; } float var=ss/(float)nsamp_per_block; if (var > 0){ for (uint64_t i = 0; i < nsamp_per_block ; i++){ float v = (data[j][i]-mean)/sqrt(var); if(v > 3 || v < -3){ data[j][i]=mjk_rand_gauss(random)*sqrt(var)+mean; } } } ch_var[offset+j] = var; ch_mean[offset+j] = mean; } stop_clock(t_rms); for (uint64_t i = 0; i < nsamp_per_block ; i++){ tseries[i]=0; } float tmean=0; float tvar=0; float max=0; float min=1e99; //#pragma omp parallel for shared(data,tseries) // NOT THREAD SAFE for (uint64_t j = 0; j < nchan ; j++){ tmean+=ch_mean[offset+j]; tvar+=ch_var[offset+j]; for (uint64_t i = 0; i < nsamp_per_block ; i++){ tseries[i]+=data[j][i]; if(data[j][i]>max)max=data[j][i]; if(data[j][i]<min)min=data[j][i]; } } float ss=0; float mm=0; for (uint64_t i = 0; i < nsamp_per_block ; i++){ float x=tseries[i]-tmean; mm+=tseries[i]; ss+=x*x; } float rvar=ss/(float)nsamp_per_block; logmsg("var=%g tvar=%g",ss/(float)nsamp_per_block,tvar); logmsg("mean=%g tmean=%g",mm/(float)nsamp_per_block,tmean); cpgopen("3/xs"); cpgsvp(0.1,0.9,0.1,0.9); cpgswin(0,fftX,tmean-sqrt(tvar)*30,tmean+sqrt(tvar)*30); cpgbox("ABN",0,0,"ABN",0,0); cpgline(fftX,X,tseries); cpgsci(2); cpgclos(); tr[0] = 0.0 ; tr[1] = 1; tr[2] = 0; tr[3] = 0.5; tr[4] = 0; tr[5] = 1; logmsg("max=%g min=%g",max,min); cpgopen("4/xs"); cpgsvp(0.1,0.9,0.1,0.9); cpgswin(0,nsamp_per_block,0,nchan); cpgbox("ABN",0,0,"ABN",0,0); cpggray(*data,nsamp_per_block,nchan,1,nsamp_per_block,1,nchan,tmean/(float)nchan+sqrt(rvar/(float)nchan),tmean/(float)nchan-sqrt(rvar/(float)nchan),tr); cpgclos(); start_clock(t_fft); fftwf_execute(fft_1d); fftwf_execute(fft_plan); stop_clock(t_fft); { float T = sqrt(fftXo*tvar)*12; logmsg("Zap T=%.2e",T); float fx[fftXo]; float fT[fftXo]; #pragma omp parallel for shared(fseries,pseries,mask) for (uint64_t i = 0; i < fftXo ; i++){ mask[i]=1; } #pragma omp parallel for shared(fseries,pseries,mask) for (uint64_t i = 0; i < fftXo ; i++){ pseries[i]=camp(fseries[i]); fx[i]=i; float TT = T; if (i>512)TT=T/2.0; if(i>32){ fT[i]=TT; if (pseries[i] > TT) { mask[i]=0; } } else fT[i]=0; } uint64_t nmask=0; for (uint64_t i = 0; i < fftXo ; i++){ if (mask[i]==0){ nmask++; } } logmsg("masked=%d (%.2f%%)",nmask,100*nmask/(float)fftXo); cpgopen("1/xs"); cpgsvp(0.1,0.9,0.1,0.9); cpgswin(0,fftXo,0,T*10); cpgbox("ABN",0,0,"ABN",0,0); cpgline(fftXo,fx,pseries); cpgsci(2); cpgline(fftXo,fx,fT); cpgclos(); } // exit(1); start_clock(t_spec); //FILE* ff=fopen("plot","w"); #pragma omp parallel for shared(fftd,ch_mean,ch_fft_n,ch_fft_p) for (uint64_t j = 0; j < nchan ; j++){ float var = ch_var[offset+j]; float m=sqrt(var*fftXo/2.0); float T = sqrt(var*fftXo)*3; uint64_t n=0; float p=0; float complex *fftch = fftd + fftXo*j; for(uint64_t i = 1; i < fftXo; i++){ if (camp(fftch[i]) > T) { n++; p+=camp(fftch[i]); } // if(j==512)fprintf(ff,"%f ",camp(fftch[i])); if(mask[i]==0){ fftch[i]=m*(mjk_rand_gauss(random) + I*mjk_rand_gauss(random)); } // if(j==512)fprintf(ff,"%f\n",camp(fftch[i])); } ch_fft_n[offset+j]=n; ch_fft_p[offset+j]=p; } // fclose(ff); logmsg("iFFT"); fftwf_execute(ifft_plan); #pragma omp parallel for schedule(static,2) shared(buffer,clean) for (uint64_t j = 0; j < nchan ; j+=BLK){ for (uint64_t i = 0; i < nsamp_per_block ; i++){ for (uint64_t k = 0; k < BLK ; k++){ clean[j+k][i]/=(float)fftX; buffer[i*nchan+j+k] = round(clean[j+k][i]); } } if(j==512){ cpgopen("2/xs"); cpgsvp(0.1,0.9,0.1,0.9); cpgswin(0,fftX,ch_mean[j]-sqrt(ch_var[j])*10,ch_mean[j]+sqrt(ch_var[j])*10); cpgbox("ABN",0,0,"ABN",0,0); cpgline(fftX,X,data[j]); cpgsci(2); cpgline(fftX,X,clean[j]); cpgclos(); } } fwrite(buffer,1,bytes_per_block,of); for (uint64_t i = 0; i < nsamp_per_block ; i++){ tseries[i]=0; } tmean=0; tvar=0; max=0; min=1e99; //#pragma omp parallel for shared(clean,tseries) // NOT THREAD SAFE for (uint64_t j = 0; j < nchan ; j++){ tmean+=ch_mean[offset+j]; tvar+=ch_var[offset+j]; for (uint64_t i = 0; i < nsamp_per_block ; i++){ tseries[i]+=clean[j][i]; if(clean[j][i]>max)max=clean[j][i]; if(clean[j][i]<min)min=clean[j][i]; } } ss=0; mm=0; for (uint64_t i = 0; i < nsamp_per_block ; i++){ float x=tseries[i]-tmean; mm+=tseries[i]; ss+=x*x; } rvar=ss/(float)nsamp_per_block; logmsg("var=%g tvar=%g",ss/(float)nsamp_per_block,tvar); logmsg("mean=%g tmean=%g",mm/(float)nsamp_per_block,tmean); cpgopen("5/xs"); cpgsvp(0.1,0.9,0.1,0.9); cpgswin(0,fftX,tmean-sqrt(tvar)*30,tmean+sqrt(tvar)*30); cpgbox("ABN",0,0,"ABN",0,0); cpgline(fftX,X,tseries); cpgsci(2); cpgclos(); tr[0] = 0.0 ; tr[1] = 1; tr[2] = 0; tr[3] = 0.5; tr[4] = 0; tr[5] = 1; logmsg("max=%g min=%g",max,min); cpgopen("6/xs"); cpgsvp(0.1,0.9,0.1,0.9); cpgswin(0,nsamp_per_block,0,nchan); cpgbox("ABN",0,0,"ABN",0,0); cpggray(*clean,nsamp_per_block,nchan,1,nsamp_per_block,1,nchan,tmean/(float)nchan+sqrt(rvar/(float)nchan),tmean/(float)nchan-sqrt(rvar/(float)nchan),tr); cpgclos(); stop_clock(t_spec); for (uint64_t j = 0; j < nchan ; j++){ float mean=ch_mean[offset+j]; if (mean > max_mean)max_mean=mean; if (mean < min_mean)min_mean=mean; float var=ch_var[offset+j]; if (var > max_var)max_var=var; if (var < min_var)min_var=var; float fft_n=ch_fft_n[offset+j]; if (fft_n > max_fft_n)max_fft_n=fft_n; if (fft_n < min_fft_n)min_fft_n=fft_n; float fft_p=ch_fft_p[offset+j]; if (fft_p > max_fft_p)max_fft_p=fft_p; if (fft_p < min_fft_p)min_fft_p=fft_p; } } stop_clock(t_all); fclose(of); logmsg("T(all) = %.2lfs",read_clock(t_all)); logmsg("T(read) = %.2lfs",read_clock(t_read)); logmsg("T(trans)= %.2lfs",read_clock(t_trns)); logmsg("T(fft) = %.2lfs",read_clock(t_fft)); logmsg("T(fan) = %.2lfs",read_clock(t_spec)); logmsg("T(rms) = %.2lfs",read_clock(t_rms)); logmsg("T(rest) = %.2lfs",read_clock(t_all)-read_clock(t_read)-read_clock(t_trns)-read_clock(t_rms)-read_clock(t_fft)-read_clock(t_spec)); tr[0] = -tsamp*nsamp_per_block*0.5; tr[2] = tsamp*nsamp_per_block; tr[1] = 0; tr[3] = 0.5; tr[5] = 0; tr[4] = 1; cpgopen("1/xs"); cpgsvp(0.1,0.9,0.1,0.9); cpgswin(0,nblocks*tsamp*nsamp_per_block,0,nchan); cpgbox("ABN",600,10,"ABN",100,1); cpggray(ch_mean,nchan,nblocks,1,nchan,1,nblocks,max_mean,min_mean,tr); cpgclos(); cpgopen("2/xs"); cpgsvp(0.1,0.9,0.1,0.9); cpgswin(0,nblocks*tsamp*nsamp_per_block,0,nchan); cpgbox("ABN",600,10,"ABN",100,1); cpggray(ch_var,nchan,nblocks,1,nchan,1,nblocks,max_var,min_var,tr); cpgclos(); cpgopen("3/xs"); cpgsvp(0.1,0.9,0.1,0.9); cpgswin(0,nblocks*tsamp*nsamp_per_block,0,nchan); cpgbox("ABN",600,10,"ABN",100,1); cpggray(ch_fft_n,nchan,nblocks,1,nchan,1,nblocks,max_fft_n,min_fft_n,tr); cpgclos(); cpgopen("4/xs"); cpgsvp(0.1,0.9,0.1,0.9); cpgswin(0,nblocks*tsamp*nsamp_per_block,0,nchan); cpgbox("ABN",600,10,"ABN",100,1); cpggray(ch_fft_p,nchan,nblocks,1,nchan,1,nblocks,max_fft_p,min_fft_p,tr); cpgclos(); cpgopen("mean.ps/vcps"); cpgsvp(0.1,0.9,0.1,0.9); cpgswin(0,nblocks*tsamp*nsamp_per_block,0,nchan); cpgbox("ABN",600,10,"ABN",100,1); cpggray(ch_mean,nchan,nblocks,1,nchan,1,nblocks,max_mean,min_mean,tr); cpgclos(); cpgopen("var.ps/vcps"); cpgsvp(0.1,0.9,0.1,0.9); cpgswin(0,nblocks*tsamp*nsamp_per_block,0,nchan); cpgbox("ABN",600,10,"ABN",100,1); cpggray(ch_var,nchan,nblocks,1,nchan,1,nblocks,max_var,min_var,tr); cpgclos(); cpgopen("fft_n.ps/vcps"); cpgsvp(0.1,0.9,0.1,0.9); cpgswin(0,nblocks*tsamp*nsamp_per_block,0,nchan); cpgbox("ABN",600,10,"ABN",100,1); cpggray(ch_fft_n,nchan,nblocks,1,nchan,1,nblocks,max_fft_n,min_fft_n,tr); cpgclos(); cpgopen("fft_p.ps/vcps"); cpgsvp(0.1,0.9,0.1,0.9); cpgswin(0,nblocks*tsamp*nsamp_per_block,0,nchan); cpgbox("ABN",600,10,"ABN",100,1); cpggray(ch_fft_p,nchan,nblocks,1,nchan,1,nblocks,max_fft_p,min_fft_p,tr); cpgclos(); fclose(f); free(buffer); free_2df(data); return 0; }
int main(int argc, char *argv[]) { float *x=NULL,*y=NULL,minx,maxx,miny,maxy,cx, *oparams=NULL,*nparams=NULL; float *rx=NULL,*ry=NULL,*w=NULL,*wparams=NULL,*wx=NULL,*wy=NULL,*ww=NULL; float *y_sault_fit=NULL, *x_fit=NULL, *y_new_fit=NULL, *y_reynolds_fit=NULL; float *y_stevens_fit=NULL,*y_whole_fit=NULL,*y_old_fit=NULL; int i,j,n=0,n_fit=100,new_fit_order=2,whole_fit_order=5,nr=0,nw=0; /* float extra_x[NEXTRA]={ 93, 95 }, extra_y[NEXTRA] = { 0.1223, 0.1168 }; */ float extra_x[NEXTRA]= { 93, 95 }, extra_y[NEXTRA] = { 0.1116, 0.1056 }; float extra_u[NEXTRA]= { 0.01356, 0.01399 }; float fitp_sault[NFIT_SAULT]= { -202.6259, 149.7321, -36.4943, 2.9372 }; float fitp_reynolds[NFIT_REYNOLDS]= { -30.7667, 26.4908, -7.0977, 0.605334 }; float fitp_stevens[NFIT_STEVENS]= { -1.237160, 2.005317, -0.400622 }; float fitp_old[NFIT_OLD]= { -23.839, 19.569, -4.8168, 0.35836 }; float *ratio_reynolds_fit=NULL,*ratio_stevens_fit=NULL,*ratio_sault_fit=NULL; float *ratio_new_fit=NULL; float vpx1, vpx2, vpy1, vpy2, vpy3, lx, ly, dly; char fitlabel[BUFSIZE]; /* Generate the cm fit points. */ for (cx=1.0; cx<10.0; cx+=0.1) { nr++; rx = realloc(rx, nr * sizeof(float)); ry = realloc(ry, nr * sizeof(float)); rx[nr-1] = log10f(cx * 1000); ry[nr-1] = 0.0; for (i=0; i<NFIT_REYNOLDS; i++) { ry[nr-1] += fitp_reynolds[i] * powf(rx[n-1], (float)i); } } /* Generate the 15mm fit points. */ for (cx=10.0; cx<=24.0; cx+=0.128) { n++; x = realloc(x, n * sizeof(float)); y = realloc(y, n * sizeof(float)); w = realloc(w, n * sizeof(float)); x[n-1] = log10f(cx * 1000); y[n-1] = 0.0; for (i=0; i<NFIT_REYNOLDS; i++) { y[n-1] += fitp_sault[i] * powf(x[n-1], (float)i); } w[n-1] = 1.0/0.1; } /* Do the fit. */ linfit_order(NFIT_SAULT, n, x, y, w, &oparams); for (i=0; i<NFIT_SAULT; i++) { printf("i = %d c[i] = %.4f\n", i, oparams[i]); } /* Add the 3mm flux points. */ for (i=0; i<NEXTRA; i++) { n++; x = realloc(x, n * sizeof(float)); y = realloc(y, n * sizeof(float)); w = realloc(w, n * sizeof(float)); x[n-1] = log10f(extra_x[i] * 1000); y[n-1] = log10f(extra_y[i]); w[n-1] = 1/extra_u[i]; } /* Do another fit. */ linfit_order(new_fit_order, n, x, y, w, &nparams); for (i=0; i<new_fit_order; i++) { printf("i = %d nc[i] = %.4f\n", i, nparams[i]); } /* Generate the whole range fit points. */ minx=log10f(900); maxx=log10f(100000); miny=-2; maxy=log10f(20); x_fit = malloc(n_fit * sizeof(float)); for (i=0; i<n_fit; i++) { x_fit[i] = minx + i * ((maxx - minx)/(float)n_fit); nw++; wx = realloc(wx, nw * sizeof(float)); wy = realloc(wy, nw * sizeof(float)); ww = realloc(ww, nw * sizeof(float)); wx[nw-1] = x_fit[i]; wy[nw-1] = 0.0; ww[nw-1] = 1; if (x_fit[i] < log10f(11143)) { /* Use the Reynolds fit. */ for (j=0; j<NFIT_REYNOLDS; j++) { wy[nw-1] += fitp_reynolds[j] * powf(x_fit[i], (float)j); } } else { /* Use the new fit. */ for (j=0; j<new_fit_order; j++) { wy[nw-1] += nparams[j] * powf(x_fit[i], (float)j); } } } /* Do a whole-range fit. */ linfit_order(whole_fit_order, nw, wx, wy, ww, &wparams); for (i=0; i<whole_fit_order; i++) { printf("i = %d wc[i] = %.4f\n", i, wparams[i]); } // minmax(n, x, &minx, &maxx); // minmax(n, y, &miny, &maxy); y_sault_fit = malloc(n_fit * sizeof(float)); y_reynolds_fit = malloc(n_fit * sizeof(float)); y_stevens_fit = malloc(n_fit * sizeof(float)); y_new_fit = malloc(n_fit * sizeof(float)); y_whole_fit = malloc(n_fit * sizeof(float)); y_old_fit = malloc(n_fit * sizeof(float)); ratio_reynolds_fit = malloc(n_fit * sizeof(float)); ratio_stevens_fit = malloc(n_fit * sizeof(float)); ratio_sault_fit = malloc(n_fit * sizeof(float)); ratio_new_fit = malloc(n_fit * sizeof(float)); /* minx=log10f(50); */ minx=log10f(1000); /* maxx=log10f(500000); */ maxx=log10f(110000); for (i=0; i<n_fit; i++) { x_fit[i] = minx + i * ((maxx - minx)/(float)n_fit); y_sault_fit[i] = 0.0; y_reynolds_fit[i] = 0.0; y_new_fit[i] = 0.0; y_stevens_fit[i] = 0.0; y_whole_fit[i] = 0.0; y_old_fit[i] = 0.0; for (j=0; j<NFIT_SAULT; j++) { y_sault_fit[i] += fitp_sault[j] * powf(x_fit[i], (float)j); } for (j=0; j<NFIT_REYNOLDS; j++) { y_reynolds_fit[i] += fitp_reynolds[j] * powf(x_fit[i], (float)j); } for (j=0; j<NFIT_STEVENS; j++) { y_stevens_fit[i] += fitp_stevens[j] * powf(x_fit[i], (float)j); } for (j=0; j<new_fit_order; j++) { y_new_fit[i] += nparams[j] * powf(x_fit[i], (float)j); } for (j=0; j<whole_fit_order; j++) { y_whole_fit[i] += wparams[j] * powf(x_fit[i], (float)j); } for (j=0; j<NFIT_OLD; j++) { y_old_fit[i] += fitp_old[j] * powf(x_fit[i], (float)j); } ratio_reynolds_fit[i] = powf(10, (y_reynolds_fit[i] - y_whole_fit[i])); ratio_stevens_fit[i] = powf(10, (y_stevens_fit[i] - y_whole_fit[i])); ratio_sault_fit[i] = powf(10, (y_sault_fit[i] - y_whole_fit[i])); ratio_new_fit[i] = powf(10, (y_new_fit[i] - y_whole_fit[i])); } /* cpgopen("11/xs"); */ cpgopen("1934-638_models.ps/cps"); /* cpgopen("1934-638_models.png/png"); */ cpgqvp(0, &vpx1, &vpx2, &vpy1, &vpy2); vpy3 = vpy1 + (vpy2 - vpy1) / 5.0; /* cpgsvp(vpx1, vpx2, vpy3, vpy2); */ cpgswin(minx, maxx, miny, maxy); lx = minx + (maxx - minx) / 9.0; ly = miny + (maxy - miny) / 3.0; dly = (maxy - miny) / 20.0; cpgsch(1.0); cpgbox("BCLNTS",0,0,"BCLNTS",0,0); cpglab("Frequency (MHz)", "Flux Density (Jy)", "1934-638 Model Comparison"); cpgsch(0.8); cpgpt(n, x, y, 4); /* cpgpt(nw, wx, wy, 4); */ cpgsci(2); /* cpgpt(nr, rx, ry, 4); */ cpgline(n_fit, x_fit, y_sault_fit); strcpy(fitlabel, "Sault: "); fitstring(fitp_sault, NFIT_SAULT, fitlabel); cpgtext(lx, ly, fitlabel); cpgsci(3); cpgline(n_fit, x_fit, y_new_fit); strcpy(fitlabel, "Stevens (linear): "); fitstring(nparams, new_fit_order, fitlabel); ly -= dly; cpgtext(lx, ly, fitlabel); cpgsci(4); cpgline(n_fit, x_fit, y_reynolds_fit); strcpy(fitlabel, "Reynolds: "); fitstring(fitp_reynolds, NFIT_REYNOLDS, fitlabel); ly -= dly; cpgtext(lx, ly, fitlabel); cpgsci(5); cpgline(n_fit, x_fit, y_stevens_fit); strcpy(fitlabel, "Stevens (Miriad): "); fitstring(fitp_stevens, NFIT_STEVENS, fitlabel); ly -= dly; cpgtext(lx, ly, fitlabel); cpgsci(6); cpgline(n_fit, x_fit, y_old_fit); strcpy(fitlabel, "Pre-1994: "); fitstring(fitp_old, NFIT_OLD, fitlabel); ly -= dly; cpgtext(lx, ly, fitlabel); /* cpgsci(6); */ /* cpgline(n_fit, x_fit, y_whole_fit); */ /* strcpy(fitlabel, "Stevens (New): "); */ /* fitstring(wparams, whole_fit_order, fitlabel); */ /* ly -= dly; */ /* cpgtext(lx, ly, fitlabel); */ /* cpgsvp(vpx1, vpx2, vpy1, vpy3); */ /* cpgsci(1); */ /* cpgswin(minx, maxx, 0.9, 1.1); */ /* cpgsch(1.0); */ /* cpgbox("BCLNTS",0,0,"BCMTS",0,0); */ /* cpglab("Frequency (MHz)", "Model Ratio", ""); */ /* cpgsci(2); */ /* cpgline(n_fit, x_fit, ratio_sault_fit); */ /* cpgsci(3); */ /* cpgline(n_fit, x_fit, ratio_new_fit); */ /* cpgsci(4); */ /* cpgline(n_fit, x_fit, ratio_reynolds_fit); */ /* cpgsci(5); */ /* cpgline(n_fit, x_fit, ratio_stevens_fit); */ cpgclos(); exit(0); }