DBInt RGPSetColorMap(RGPColorMapEntry *colorMap, DBInt colorNum) {
DBInt color, shade, shadeNum = RGPColorShadeNum;
float red, red0, red1, green, green0, green1, blue, blue0, blue1, mColor;
if (colorNum < 3) return (DBFault);
red = (float) colorMap[0].Red / 255.0;
green = (float) colorMap[0].Green / 255.0;
blue = (float) colorMap[0].Blue / 255.0;
cpgscr(RGPStartColorIndex, red, green, blue);
for (shade = 0; shade < shadeNum; ++shade) {
color = (DBInt)(floor((double) (colorNum - 2) * (double) shade / (double) (shadeNum - 1)));
red0 = (float) colorMap[color + 1].Red / 255.0;
green0 = (float) colorMap[color + 1].Green / 255.0;
blue0 = (float) colorMap[color + 1].Blue / 255.0;
red1 = (float) colorMap[color + 2].Red / 255.0;
green1 = (float) colorMap[color + 2].Green / 255.0;
blue1 = (float) colorMap[color + 2].Blue / 255.0;
mColor = shade - ((float) color * (float) (shadeNum - 1) / (float) (colorNum - 2));
red = red0 + (red1 - red0) * (float) mColor / ((float) shadeNum / (float) (colorNum - 2));
green = green0 + (green1 - green0) * (float) mColor / ((float) shadeNum / (float) (colorNum - 2));
blue = blue0 + (blue1 - blue0) * (float) mColor / ((float) shadeNum / (float) (colorNum - 2));
cpgscr(RGPStartColorIndex + 1 + shade, red, green, blue);
}
red = (float) colorMap[colorNum - 1].Red / 255.0;
green = (float) colorMap[colorNum - 1].Green / 255.0;
blue = (float) colorMap[colorNum - 1].Blue / 255.0;
cpgscr(RGPStartColorIndex + 1 + shade, red, green, blue);
cpgscir(RGPStartColorIndex, RGPStartColorIndex + shadeNum + 1);
return (shadeNum + 2);
}
void RGPInitPenColors() {
DBInt color;
float red, green, blue;
for (color = 0; color < (DBInt)(sizeof(_RGPStandardColors) / sizeof(RGPColorMapEntry)); color++) {
red = (float) _RGPStandardColors[color].Red / 255.0;
green = (float) _RGPStandardColors[color].Green / 255.0;
blue = (float) _RGPStandardColors[color].Blue / 255.0;
cpgscr(color + 1, red, green, blue);
}
}
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);
}
int main()
{
char text[80];
int ci, crval1, crval2, ilat, ilng, j, k, latpole, lonpole, stat[361],
status;
float xr[512], yr[512];
double lat[181], lng[361], phi[361], theta[361], x[361], y[361];
struct celprm native, celestial;
printf(
"Testing WCSLIB celestial coordinate transformation routines (tcel1.c)\n"
"---------------------------------------------------------------------\n");
/* List status return messages. */
printf("\nList of cel status return values:\n");
for (status = 1; status <= 6; status++) {
printf("%4d: %s.\n", status, cel_errmsg[status]);
}
printf("\n");
/* Initialize. */
celini(&native);
/* Reference angles for the native graticule (in fact, the defaults). */
native.ref[0] = 0.0;
native.ref[1] = 0.0;
/* Set up Bonne's projection with conformal latitude at +35. */
strcpy(native.prj.code, "BON");
native.prj.pv[1] = 35.0;
/* Celestial graticule. */
celini(&celestial);
celestial.prj = native.prj;
/* PGPLOT initialization. */
strcpy(text, "/xwindow");
cpgbeg(0, text, 1, 1);
/* Define pen colours. */
cpgscr(0, 0.0f, 0.0f, 0.0f);
cpgscr(1, 1.0f, 1.0f, 0.0f);
cpgscr(2, 1.0f, 1.0f, 1.0f);
cpgscr(3, 0.5f, 0.5f, 0.8f);
cpgscr(4, 0.8f, 0.5f, 0.5f);
cpgscr(5, 0.8f, 0.8f, 0.8f);
cpgscr(6, 0.5f, 0.5f, 0.8f);
cpgscr(7, 0.8f, 0.5f, 0.5f);
cpgscr(8, 0.3f, 0.5f, 0.3f);
/* Define PGPLOT viewport. */
cpgenv(-180.0f, 180.0f, -90.0f, 140.0f, 1, -2);
/* Loop over CRVAL2, LONPOLE, and LATPOLE with CRVAL1 incrementing by */
/* 15 degrees each time (it has an uninteresting effect). */
crval1 = -180;
for (crval2 = -90; crval2 <= 90; crval2 += 30) {
for (lonpole = -180; lonpole <= 180; lonpole += 30) {
for (latpole = -1; latpole <= 1; latpole += 2) {
/* For the celestial graticule, set the celestial coordinates of
* the reference point of the projection (which for Bonne's
* projection is at the intersection of the native equator and
* prime meridian), the native longitude of the celestial pole,
* and extra information needed to determine the celestial
* latitude of the native pole. These correspond to FITS keywords
* CRVAL1, CRVAL2, LONPOLE, and LATPOLE.
*/
celestial.ref[0] = (double)crval1;
celestial.ref[1] = (double)crval2;
celestial.ref[2] = (double)lonpole;
celestial.ref[3] = (double)latpole;
/* Skip invalid values of LONPOLE. */
if (celset(&celestial)) {
continue;
}
/* Skip redundant values of LATPOLE. */
if (latpole == 1 && fabs(celestial.ref[3]) < 0.1) {
continue;
}
/* Buffer PGPLOT output. */
cpgbbuf();
cpgeras();
/* Write a descriptive title. */
sprintf(text, "Bonne's projection (BON) - 15 degree graticule");
printf("\n%s\n", text);
cpgtext(-180.0f, -100.0f, text);
sprintf(text, "centred on celestial coordinates (%7.2f,%6.2f)",
celestial.ref[0], celestial.ref[1]);
printf("%s\n", text);
cpgtext (-180.0f, -110.0f, text);
sprintf(text, "with north celestial pole at native coordinates "
"(%7.2f,%7.2f)", celestial.ref[2], celestial.ref[3]);
printf("%s\n", text);
cpgtext(-180.0f, -120.0f, text);
/* Draw the native graticule faintly in the background. */
cpgsci(8);
/* Draw native meridians of longitude. */
for (j = 0, ilat = -90; ilat <= 90; ilat++, j++) {
lat[j] = (double)ilat;
}
for (ilng = -180; ilng <= 180; ilng += 15) {
lng[0] = (double)ilng;
if (ilng == -180) lng[0] = -179.99;
if (ilng == 180) lng[0] = 179.99;
/* Dash the longitude of the celestial pole. */
if ((ilng-lonpole)%360 == 0) {
cpgsls(2);
cpgslw(5);
}
cels2x(&native, 1, 181, 1, 1, lng, lat, phi, theta, x, y, stat);
k = 0;
for (j = 0; j < 181; j++) {
if (stat[j]) {
if (k > 1) cpgline(k, xr, yr);
k = 0;
continue;
}
xr[k] = -x[j];
yr[k] = y[j];
k++;
}
cpgline(k, xr, yr);
cpgsls(1);
cpgslw(1);
}
/* Draw native parallels of latitude. */
lng[0] = -179.99;
lng[360] = 179.99;
for (j = 1, ilng = -179; ilng < 180; ilng++, j++) {
lng[j] = (double)ilng;
}
for (ilat = -90; ilat <= 90; ilat += 15) {
lat[0] = (double)ilat;
cels2x(&native, 361, 1, 1, 1, lng, lat, phi, theta, x, y, stat);
k = 0;
for (j = 0; j < 361; j++) {
if (stat[j]) {
if (k > 1) cpgline(k, xr, yr);
k = 0;
continue;
}
xr[k] = -x[j];
yr[k] = y[j];
k++;
}
cpgline(k, xr, yr);
}
/* Draw a colour-coded celestial coordinate graticule. */
ci = 1;
/* Draw celestial meridians of longitude. */
for (j = 0, ilat = -90; ilat <= 90; ilat++, j++) {
lat[j] = (double)ilat;
}
for (ilng = -180; ilng <= 180; ilng += 15) {
lng[0] = (double)ilng;
if (++ci > 7) ci = 2;
cpgsci(ilng?ci:1);
/* Dash the reference longitude. */
if ((ilng-crval1)%360 == 0) {
cpgsls(2);
cpgslw(5);
}
cels2x(&celestial, 1, 181, 1, 1, lng, lat, phi, theta, x, y, stat);
k = 0;
for (j = 0; j < 181; j++) {
if (stat[j]) {
if (k > 1) cpgline(k, xr, yr);
k = 0;
continue;
}
/* Test for discontinuities. */
if (j > 0) {
if (fabs(x[j]-x[j-1]) > 4.0 || fabs(y[j]-y[j-1]) > 4.0) {
if (k > 1) cpgline(k, xr, yr);
k = 0;
}
}
xr[k] = -x[j];
yr[k] = y[j];
k++;
}
cpgline(k, xr, yr);
cpgsls(1);
cpgslw(1);
}
/* Draw celestial parallels of latitude. */
for (j = 0, ilng = -180; ilng <= 180; ilng++, j++) {
lng[j] = (double)ilng;
}
ci = 1;
for (ilat = -90; ilat <= 90; ilat += 15) {
lat[0] = (double)ilat;
if (++ci > 7) ci = 2;
cpgsci(ilat?ci:1);
/* Dash the reference latitude. */
if (ilat == crval2) {
cpgsls(2);
cpgslw(5);
}
cels2x(&celestial, 361, 1, 1, 1, lng, lat, phi, theta, x, y, stat);
k = 0;
for (j = 0; j < 361; j++) {
if (stat[j]) {
if (k > 1) cpgline(k, xr, yr);
k = 0;
continue;
}
/* Test for discontinuities. */
if (j > 0) {
if (fabs(x[j]-x[j-1]) > 4.0 || fabs(y[j]-y[j-1]) > 4.0) {
if (k > 1) cpgline(k, xr, yr);
k = 0;
}
}
xr[k] = -x[j];
yr[k] = y[j];
k++;
}
cpgline(k, xr, yr);
cpgsls(1);
cpgslw(1);
}
/* Flush PGPLOT buffer. */
cpgebuf();
printf(" Type <RETURN> for next page: ");
getc(stdin);
/* Cycle through celestial longitudes. */
if ((crval1 += 15) > 180) crval1 = -180;
/* Skip boring celestial latitudes. */
if (crval2 == 0) break;
}
if (crval2 == 0) break;
}
}
cpgask(0);
cpgend();
return 0;
}
int main(){
printf("\n====================================================================\n");
printf("This program is able to simulate the diffusion of heat\n");
printf("across a metal plate of size %i x %i\n", ENV_SIZE_X, ENV_SIZE_Y);
printf("====================================================================\n");
//==========================================================================
//--------------------------SYSTEM INITIALIZATIONS--------------------------
//==========================================================================
// initialize random seed
srand(time(NULL));
// force print all outputs (remove stdout buffer)
setbuf(stdout, NULL);
// initialize pgplot window
if (!cpgopen("/XWINDOW"))
errorCase(ERR_PGPLOT);
cpgpap(0.0, 0.6); // set window size
cpgsubp(1,3); // subdivide window into panels
// heatmap
cpgpanl(1,1);
cpgsvp(0.0, 1.0, 0.0, 1.0);
cpgswin(0, ENV_SIZE_X, 0, ENV_SIZE_Y);
// flux plot
cpgpanl(1,2);
cpgsvp(0.08, 0.92, 0.08, 0.92);
cpgswin(LINE_PLOT_X1, LINE_PLOT_X2, FLUX_PLOT_Y1, FLUX_PLOT_Y2);
cpgbox("ABCINTS", 0.0, 0, "ABCINTS", 0.0, 0);
cpglab("Time", "Flux", "");
// heat plot
cpgpanl(1,3);
cpgsvp(0.08, 0.92, 0.08, 0.92);
cpgswin(LINE_PLOT_X1, LINE_PLOT_X2, LINE_PLOT_Y1, LINE_PLOT_Y2);
cpgbox("ABCINTS", 0.0, 0, "ABCINTS", 0.0, 0);
cpglab("Time", "Total Heat", "");
// initialize color table for pgplot display
float rl[9] = {-0.5, 0.0, 0.17, 0.33, 0.50, 0.67, 0.83, 1.0, 1.7};
float rr[9] = { 0.0, 0.0, 0.0, 0.0, 0.6, 1.0, 1.0, 1.0, 1.0};
float rg[9] = { 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.6, 0.0, 1.0};
float rb[9] = { 0.0, 0.3, 0.8, 1.0, 0.3, 0.0, 0.0, 0.0, 1.0};
cpgctab(rl, rr, rg, rb, 512, 1.0, 0.5);
cpgscr(10, 0.0, 0.0, 1.0);
cpgscr(11, 1.0, 0.0, 0.0);
cpgsfs(3);
//==========================================================================
//--------------------------VARIABLE INITIALIZATIONS------------------------
//==========================================================================
// generic variables
int i, j, k; // counters
// simulation environment
float** simEnvEven = allocateArray2D(ENV_SIZE_X, ENV_SIZE_Y);
float** simEnvOdd = allocateArray2D(ENV_SIZE_X, ENV_SIZE_Y);
float* simLocal = allocateArray1D(5);
// mnist handwritten numbers
float** mnistDatabase = readCSV("mnist_train_100.csv", 100, 785);
for (i=0; i<100; i++)
for (j=0; j<785; j++)
mnistDatabase[i][j] = mnistDatabase[i][j]/255.0;
// current location and time
int x,y,z;
int t, tGlobal;
// student number
int studentNumbRaw;
int studentNumbWorking;
int studentNumb[7];
// rates
float rateDiff = 0.2;
float delta;
// flux variables
float flux;
float fluxTotal;
float fluxAverage;
float fluxHeat;
float totalHeat;
int x1, x2, y1, y2;
// background heat
float bgHeat;
// tracking variables
float totalHeatOld;
float totalHeatPre;
float tGlobalOld;
float fluxOld;
// pgplot variables
float* plotImg = allocateArray1D(ENV_SIZE_TOTAL);
float TR[6] = {0, 0, 1, ENV_SIZE_Y, -1, 0};
float plotMinBound = 0;
float plotMaxBound = 1;
//==========================================================================
//--------------------------------SETUP-------------------------------------
//==========================================================================
// ask for student number
printf("Please enter your student number:\n");
if (scanf("%i", &studentNumbRaw) == 0)
errorCase(ERR_INVALID_INPUT);
studentNumbWorking = studentNumbRaw;
for (i=0; i<SN_LENGTH; i++){
studentNumb[6-i] = studentNumbWorking%10;
studentNumbWorking /= 10;
}
printf("\nYour student number is:\n");
for (i=0; i<SN_LENGTH; i++)
printf("%i", studentNumb[i]);
printf("\n\n");
// set and print diffusion rate based on last digit of student number
rateDiff = ((((float)(studentNumb[6]))/10.0)*0.19)+0.01;
printf("Your Diffusion Rate is: \n%f\n\n", rateDiff);
// set and print background heat added based on last 4 digits of student number
studentNumbRaw -= 1410000;
bgHeat = ((float)((studentNumbRaw%97)%10));
bgHeat += ((float)((studentNumbRaw%101)%8))*10;
bgHeat /= 100;
printf("Your Background Heat is: \n%f\n\n", bgHeat*100);
// set and print domain for calculating flux
// x1, y1 based on last four digits of student number
x1 = studentNumbRaw % ENV_SIZE_X;
y1 = studentNumbRaw % ENV_SIZE_Y;
// x2, y2 based on last four digits of student number
x2 = x1 + (studentNumbRaw % (97));
if (x2 >= ENV_SIZE_X)
x2 = ENV_SIZE_X - 1;
y2 = y1 + (studentNumbRaw % (29));
if (y2 >= ENV_SIZE_Y)
y2 = ENV_SIZE_Y - 1;
printf("Your Domain is: \n(%i, %i) X (%i, %i)\n\n", x1, y1, x2, y2);
// environment initialization:
// select digits and place into environment
for (i=0; i<SN_LENGTH; i++){
if (studentNumb[i] == 0)
z = 0;
else if (studentNumb[i] == 1)
z = 13;
else if (studentNumb[i] == 2)
z = 27;
else if (studentNumb[i] == 3)
z = 33;
else if (studentNumb[i] == 4)
z = 44;
else if (studentNumb[i] == 5)
z = 55;
else if (studentNumb[i] == 6)
z = 60;
else if (studentNumb[i] == 7)
z = 71;
else if (studentNumb[i] == 8)
z = 81;
else
z = 89;
for (x=0; x<28; x++)
for (y=0; y<28; y++) {
simEnvEven[x+(i*28)+1][y+1] = mnistDatabase[z][y*28+x] + bgHeat;
if (simEnvEven[x+(i*28)+1][y+1] > 1.0)
simEnvEven[x+(i*28)+1][y+1] = 1.0;
}
}
//==========================================================================
//--------------------------ACTUAL CODE-------------------------------------
//==========================================================================
// initialize display
fixBoundaryConditions(simEnvEven);
copyArray2D(simEnvEven, simEnvOdd, ENV_SIZE_X, ENV_SIZE_Y);
loadImage(simEnvEven, plotImg);
cpgpanl(1,1);
cpgsvp(0.0, 1.0, 0.0, 1.0);
cpgswin(0, ENV_SIZE_X, 0, ENV_SIZE_Y);
cpgimag(plotImg, ENV_SIZE_Y, ENV_SIZE_X, 1, ENV_SIZE_Y, 1, ENV_SIZE_X, plotMinBound, plotMaxBound, TR);
cpgrect(x1, x2, y1, y2);
// initialize trackers
tGlobalOld = 0;
fluxOld = 0;
totalHeatOld = 0;
for (x=x1; x<=x2; x++)
for (y=y1; y<=y2; y++)
totalHeatOld += simEnvEven[x][y];
// initial delay to visualize starting matrix
for (t=0; t<500000000; t++){}
t = 0;
tGlobal = 0;
flux = 0;
fluxAverage = 0;
fluxTotal = 0;
while(1){
flux = 0;
cpgpanl(1,1);
cpgsvp(0.0, 1.0, 0.0, 1.0);
cpgswin(0, ENV_SIZE_X, 0, ENV_SIZE_Y);
// calculate heat changes using numeric methods
fixBoundaryConditions(simEnvEven);
//simEnvEven[50][15] = 100;
//simEnvEven[60][15] = -10;
copyArray2D(simEnvEven, simEnvOdd, ENV_SIZE_X, ENV_SIZE_Y);
for (x=1; x<(ENV_SIZE_X-1); x++)
for (y=1; y<(ENV_SIZE_Y-1); y++)
if ((x+y)%2 == 0) {
delta = rateDiff*(simEnvEven[x][y+1] - 2*simEnvEven[x][y] + simEnvEven[x][y-1]);
simEnvOdd[x][y] += delta;
if (INSIDE_BOX)
flux += delta;
delta = rateDiff*(simEnvEven[x+1][y] - 2*simEnvEven[x][y] + simEnvEven[x-1][y]);
simEnvOdd[x][y] += delta;
if (INSIDE_BOX)
flux += delta;
}
for (x=1; x<(ENV_SIZE_X-1); x++)
for (y=1; y<(ENV_SIZE_Y-1); y++)
if ((x+y)%2 == 1) {
delta = rateDiff*(simEnvOdd[x][y+1] - 2*simEnvOdd[x][y] + simEnvOdd[x][y-1]);
simEnvOdd[x][y] += delta;
if (INSIDE_BOX)
flux += delta;
delta = rateDiff*(simEnvOdd[x+1][y] - 2*simEnvOdd[x][y] + simEnvOdd[x-1][y]);
simEnvOdd[x][y] += delta;
if (INSIDE_BOX)
flux += delta;
}
loadImage(simEnvOdd, plotImg);
cpgimag(plotImg, ENV_SIZE_Y, ENV_SIZE_X, 1, ENV_SIZE_Y, 1, ENV_SIZE_X, plotMinBound, plotMaxBound, TR);
cpgrect(x1, x2, y1, y2);
fluxTotal += flux;
tGlobal++;
flux = 0;
//simEnvOdd[50][15] = 100;
//simEnvOdd[60][15] = -10;
fixBoundaryConditions(simEnvOdd);
for (x=1; x<(ENV_SIZE_X-1); x++)
for (y=1; y<(ENV_SIZE_Y-1); y++)
if ((x+y)%2 == 1) {
delta = rateDiff*(simEnvOdd[x][y+1] - 2*simEnvOdd[x][y] + simEnvOdd[x][y-1]);
simEnvEven[x][y] += delta;
if (INSIDE_BOX)
flux += delta;
delta = rateDiff*(simEnvOdd[x+1][y] - 2*simEnvOdd[x][y] + simEnvOdd[x-1][y]);
simEnvEven[x][y] += delta;
if (INSIDE_BOX)
flux += delta;
}
for (x=1; x<(ENV_SIZE_X-1); x++)
for (y=1; y<(ENV_SIZE_Y-1); y++)
if ((x+y)%2 == 0) {
delta = rateDiff*(simEnvEven[x][y+1] - 2*simEnvEven[x][y] + simEnvEven[x][y-1]);
simEnvEven[x][y] += delta;
if (INSIDE_BOX)
flux += delta;
delta = rateDiff*(simEnvEven[x+1][y] - 2*simEnvEven[x][y] + simEnvEven[x-1][y]);
simEnvEven[x][y] += delta;
if (INSIDE_BOX)
flux += delta;
}
loadImage(simEnvEven, plotImg);
cpgimag(plotImg, ENV_SIZE_Y, ENV_SIZE_X, 1, ENV_SIZE_Y, 1, ENV_SIZE_X, plotMinBound, plotMaxBound, TR);
cpgrect(x1, x2, y1, y2);
fluxTotal += flux;
tGlobal++;
// flux line plot
cpgpanl(1,2);
cpgsvp(0.08, 0.92, 0.08, 0.92);
cpgswin(LINE_PLOT_X1, LINE_PLOT_X2, FLUX_PLOT_Y1, FLUX_PLOT_Y2);
cpgmove(tGlobalOld, fluxOld);
cpgdraw(tGlobal, flux);
// heat line plot
totalHeat = 0;
for (x=x1; x<=x2; x++)
for (y=y1; y<=y2; y++)
totalHeat += simEnvEven[x][y];
cpgpanl(1,3);
cpgsvp(0.08, 0.92, 0.08, 0.92);
cpgswin(LINE_PLOT_X1, LINE_PLOT_X2, LINE_PLOT_Y1, LINE_PLOT_Y2);
cpgmove(tGlobalOld, totalHeatOld);
cpgdraw(tGlobal, totalHeat);
// set trackers
tGlobalOld = tGlobal;
totalHeatOld = totalHeat;
fluxOld = flux;
if (tGlobal%100 == 0) {
totalHeat = 0;
for (x=x1; x<=x2; x++)
for (y=y1; y<=y2; y++)
totalHeat += simEnvEven[x][y];
fluxAverage = fluxTotal/tGlobal;
fluxHeat = totalHeat - totalHeatPre;
printf("Total Heat: %f \n Current Divergence: %f \n Current Flux: %f\n\n", totalHeat, flux, fluxHeat);
}
totalHeatPre = 0;
for (x=x1; x<=x2; x++)
for (y=y1; y<=y2; y++)
totalHeatPre += simEnvEven[x][y];
}
}
void Plotter2::plot() {
open();
if ((width > 0.0) && (aspect > 0.0)) {
cpgpap(width, aspect);
}
cpgscr(0, 1.0, 1.0, 1.0); // set background color white
cpgscr(1, 0.0, 0.0, 0.0); // set foreground color black
for (unsigned int i = 0; i < vInfo.size(); ++i) {
Plotter2ViewportInfo vi = vInfo[i];
if (vi.showViewport) {
resetAttributes(vi);
// setup viewport
cpgsvp(vi.vpPosXMin, vi.vpPosXMax, vi.vpPosYMin, vi.vpPosYMax);
cpgswin(vi.vpRangeXMin, vi.vpRangeXMax, vi.vpRangeYMin, vi.vpRangeYMax);
// background color (default is transparent)
if (vi.vpBColor >= 0) {
cpgsci(vi.vpBColor);
cpgrect(vi.vpRangeXMin, vi.vpRangeXMax, vi.vpRangeYMin, vi.vpRangeYMax);
cpgsci(1); // reset foreground colour to the initial one (black)
}
// data
for (unsigned int j = 0; j < vi.vData.size(); ++j) {
resetAttributes(vi);
Plotter2DataInfo di = vi.vData[j];
std::vector<float> vxdata = di.xData;
int ndata = vxdata.size();
float* pxdata = new float[ndata];
float* pydata = new float[ndata];
for (int k = 0; k < ndata; ++k) {
pxdata[k] = di.xData[k];
pydata[k] = di.yData[k];
}
if (di.drawLine) {
cpgsls(di.lineStyle);
cpgslw(di.lineWidth);
int colorIdx = di.lineColor;
if (colorIdx < 0) {
colorIdx = (j + 1) % 15 + 1;
}
cpgsci(colorIdx);
cpgline(ndata, pxdata, pydata);
}
if (di.drawMarker) {
cpgsch(di.markerSize);
cpgsci(di.markerColor);
cpgpt(ndata, pxdata, pydata, di.markerType);
}
delete [] pxdata;
delete [] pydata;
}
//calculate y-range of xmasks
std::vector<float> yrange = vi.getRangeY();
float yexcess = 0.1*(yrange[1] - yrange[0]);
float xmaskymin = yrange[0] - yexcess;
float xmaskymax = yrange[1] + yexcess;
// masks
for (unsigned int j = 0; j < vi.vRect.size(); ++j) {
resetAttributes(vi);
Plotter2RectInfo ri = vi.vRect[j];
cpgsci(ri.color);
cpgsfs(ri.fill);
cpgslw(ri.width);
cpgshs(45.0, ri.hsep, 0.0);
float* mxdata = new float[4];
float* mydata = new float[4];
mxdata[0] = ri.xmin;
mxdata[1] = ri.xmax;
mxdata[2] = ri.xmax;
mxdata[3] = ri.xmin;
mydata[0] = xmaskymin;
mydata[1] = xmaskymin;
mydata[2] = xmaskymax;
mydata[3] = xmaskymax;
cpgpoly(4, mxdata, mydata);
}
// arrows
for (unsigned int j = 0; j < vi.vArro.size(); ++j) {
resetAttributes(vi);
Plotter2ArrowInfo ai = vi.vArro[j];
cpgsci(ai.color);
cpgslw(ai.width);
cpgsls(ai.lineStyle);
cpgsch(ai.headSize);
cpgsah(ai.headFillStyle, ai.headAngle, ai.headVent);
cpgarro(ai.xtail, ai.ytail, ai.xhead, ai.yhead);
}
// arbitrary texts
for (unsigned int j = 0; j < vi.vText.size(); ++j) {
resetAttributes(vi);
Plotter2TextInfo ti = vi.vText[j];
cpgsch(ti.size);
cpgsci(ti.color);
cpgstbg(ti.bgcolor);
cpgptxt(ti.posx, ti.posy, ti.angle, ti.fjust, ti.text.c_str());
}
// viewport outline and ticks
resetAttributes(vi);
cpgbox("BCTS", vi.majorTickIntervalX, vi.nMinorTickWithinMajorTicksX,
"BCTSV", vi.majorTickIntervalY, vi.nMinorTickWithinMajorTicksY);
// viewport numberings
std::string numformatx, numformaty;
if (vi.numLocationX == "b") {
numformatx = "N";
} else if (vi.numLocationX == "t") {
numformatx = "M";
} else if (vi.numLocationX == "") {
numformatx = "";
}
if (vi.numLocationY == "l") {
numformaty = "NV";
} else if (vi.numLocationY == "r") {
numformaty = "MV";
} else if (vi.numLocationY == "") {
numformaty = "";
}
cpgbox(numformatx.c_str(), vi.majorTickIntervalX * vi.nMajorTickWithinTickNumsX, 0,
numformaty.c_str(), vi.majorTickIntervalY * vi.nMajorTickWithinTickNumsY, 0);
float xpos, ypos;
// x-label
vi.getWorldCoordByWindowCoord(vi.labelXPosX, vi.labelXPosY, &xpos, &ypos);
cpgsch(vi.labelXSize);
cpgsci(vi.labelXColor);
cpgstbg(vi.labelXBColor); //outside viewports, works ONLY with /xwindow
cpgptxt(xpos, ypos, vi.labelXAngle, vi.labelXFJust, vi.labelXString.c_str());
// y-label
vi.getWorldCoordByWindowCoord(vi.labelYPosX, vi.labelYPosY, &xpos, &ypos);
cpgsch(vi.labelYSize);
cpgsci(vi.labelYColor);
cpgstbg(vi.labelYBColor); //outside viewports, works ONLY with /xwindow
cpgptxt(xpos, ypos, vi.labelYAngle, vi.labelYFJust, vi.labelYString.c_str());
// title
vi.getWorldCoordByWindowCoord(vi.titlePosX, vi.titlePosY, &xpos, &ypos);
cpgsch(vi.titleSize);
cpgsci(vi.titleColor);
cpgstbg(vi.titleBColor); //outside viewports, works ONLY with /xwindow
cpgptxt(xpos, ypos, vi.titleAngle, vi.titleFJust, vi.titleString.c_str());
}
}
close();
}
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()
{
/* Set up the lookup table. */
const int M = 2;
const int K[] = {K1, K2};
const int map[] = {0, 1};
const double crval[] = {135.0, 95.0};
char text[80];
int ci, i, ilat, ilng, j, k, m, stat[K2][K1], status;
float xr[361], yr[361];
double *dp, world[361][2], x[K1], xy[361][2], y[K2];
struct tabprm tab;
struct prjprm prj;
printf(
"Testing WCSLIB inverse coordinate lookup table routines (ttab3.c)\n"
"-----------------------------------------------------------------\n");
/* List status return messages. */
printf("\nList of tab status return values:\n");
for (status = 1; status <= 5; status++) {
printf("%4d: %s.\n", status, tab_errmsg[status]);
}
printf("\n");
/* PGPLOT initialization. */
strcpy(text, "/xwindow");
cpgbeg(0, text, 1, 1);
cpgvstd();
cpgsch(0.7f);
cpgwnad(-135.0f, 135.0f, -95.0f, 140.0f);
cpgbox("BC", 0.0f, 0, "BC", 0.0f, 0);
cpgscr(0, 0.00f, 0.00f, 0.00f);
cpgscr(1, 1.00f, 1.00f, 0.00f);
cpgscr(2, 1.00f, 1.00f, 1.00f);
cpgscr(3, 0.50f, 0.50f, 0.80f);
cpgscr(4, 0.80f, 0.50f, 0.50f);
cpgscr(5, 0.80f, 0.80f, 0.80f);
cpgscr(6, 0.50f, 0.50f, 0.80f);
cpgscr(7, 0.80f, 0.50f, 0.50f);
cpgscr(8, 0.30f, 0.50f, 0.30f);
/* Set up the lookup table. */
tab.flag = -1;
if ((status = tabini(1, M, K, &tab))) {
printf("tabini ERROR %d: %s.\n", status, tab_errmsg[status]);
return 1;
}
tab.M = M;
for (m = 0; m < tab.M; m++) {
tab.K[m] = K[m];
tab.map[m] = map[m];
tab.crval[m] = crval[m];
for (k = 0; k < tab.K[m]; k++) {
tab.index[m][k] = (double)k;
}
}
/* Set up the lookup table to approximate Bonne's projection. */
for (i = 0; i < K1; i++) {
x[i] = 135 - i;
}
for (j = 0; j < K2; j++) {
y[j] = j - 95;
}
prjini(&prj);
prj.pv[1] = 35.0;
status = bonx2s(&prj, K1, K2, 1, 2, x, y, tab.coord, tab.coord+1,
(int *)stat);
dp = tab.coord;
for (j = 0; j < K2; j++) {
for (i = 0; i < K1; i++) {
if (stat[j][i]) {
*dp = 999.0;
*(dp+1) = 999.0;
}
dp += 2;
}
}
/* Draw meridians. */
ci = 1;
for (ilng = -180; ilng <= 180; ilng += 15) {
if (++ci > 7) ci = 2;
cpgsci(ilng?ci:1);
for (j = 0, ilat = -90; ilat <= 90; ilat++, j++) {
world[j][0] = (double)ilng;
world[j][1] = (double)ilat;
}
/* A fudge to account for the singularity at the poles. */
world[0][0] = 0.0;
world[180][0] = 0.0;
status = tabs2x(&tab, 181, 2, (double *)world, (double *)xy,
(int *)stat);
k = 0;
for (j = 0; j < 181; j++) {
if (stat[0][j]) {
if (k > 1) cpgline(k, xr, yr);
k = 0;
continue;
}
xr[k] = xy[j][0];
yr[k] = xy[j][1];
k++;
}
cpgline(k, xr, yr);
}
/* Draw parallels. */
ci = 1;
for (ilat = -75; ilat <= 75; ilat += 15) {
if (++ci > 7) ci = 2;
cpgsci(ilat?ci:1);
for (j = 0, ilng = -180; ilng <= 180; ilng++, j++) {
world[j][0] = (double)ilng;
world[j][1] = (double)ilat;
}
status = tabs2x(&tab, 361, 2, (double *)world, (double *)xy,
(int *)stat);
k = 0;
for (j = 0; j < 361; j++) {
if (stat[0][j]) {
if (k > 1) cpgline(k, xr, yr);
k = 0;
continue;
}
xr[k] = xy[j][0];
yr[k] = xy[j][1];
k++;
}
cpgline(k, xr, yr);
}
cpgend();
return 0;
}
int main()
{
void prjplt();
int status;
char text[80], text1[80], text2[80];
struct prjprm prj;
printf("Testing WCSLIB spherical projection routines (tprj2.c)\n"
"------------------------------------------------------\n");
/* List status return messages. */
printf("\nList of prj status return values:\n");
for (status = 1; status <= 4; status++) {
printf("%4d: %s.\n", status, prj_errmsg[status]);
}
printf("\n");
/* PGPLOT initialization. */
strcpy(text, "/xwindow");
cpgbeg(0, text, 1, 1);
/* Define pen colours. */
cpgscr(0, 0.00f, 0.00f, 0.00f);
cpgscr(1, 1.00f, 1.00f, 0.00f);
cpgscr(2, 1.00f, 1.00f, 1.00f);
cpgscr(3, 0.50f, 0.50f, 0.80f);
cpgscr(4, 0.80f, 0.50f, 0.50f);
cpgscr(5, 0.80f, 0.80f, 0.80f);
cpgscr(6, 0.50f, 0.50f, 0.80f);
cpgscr(7, 0.80f, 0.50f, 0.50f);
cpgscr(8, 0.30f, 0.50f, 0.30f);
strcpy(text1, "\n%s projection\n");
strcpy(text2, "\n%s projection\nParameters:");
prjini(&prj);
/* AZP: zenithal/azimuthal perspective. */
prj.pv[1] = 2.0;
prj.pv[2] = 30.0;
printf(text2, "Zenithal/azimuthal perspective");
printf("%12.5f%12.5f\n", prj.pv[1], prj.pv[2]);
prjplt("AZP", 90, -90, &prj);
/* SZP: slant zenithal perspective. */
prj.pv[1] = 2.0;
prj.pv[2] = 210.0;
prj.pv[3] = 60.0;
printf(text2, "Slant zenithal perspective");
printf("%12.5f%12.5f%12.5f\n", prj.pv[1], prj.pv[2], prj.pv[3]);
prjplt("SZP", 90, -90, &prj);
/* TAN: gnomonic. */
printf(text1, "Gnomonic");
prjplt("TAN", 90, 5, &prj);
/* STG: stereographic. */
printf(text1, "Stereographic");
prjplt("STG", 90, -85, &prj);
/* SIN: orthographic. */
prj.pv[1] = -0.3;
prj.pv[2] = 0.5;
printf(text2, "Orthographic/synthesis");
printf("%12.5f%12.5f\n", prj.pv[1], prj.pv[2]);
prjplt("SIN", 90, -90, &prj);
/* ARC: zenithal/azimuthal equidistant. */
printf(text1, "Zenithal/azimuthal equidistant");
prjplt("ARC", 90, -90, &prj);
/* ZPN: zenithal/azimuthal polynomial. */
prj.pv[0] = 0.05000;
prj.pv[1] = 0.95000;
prj.pv[2] = -0.02500;
prj.pv[3] = -0.15833;
prj.pv[4] = 0.00208;
prj.pv[5] = 0.00792;
prj.pv[6] = -0.00007;
prj.pv[7] = -0.00019;
prj.pv[8] = 0.00000;
prj.pv[9] = 0.00000;
printf(text2, "Zenithal/azimuthal polynomial");
printf("%12.5f%12.5f%12.5f%12.5f%12.5f\n",
prj.pv[0], prj.pv[1], prj.pv[2], prj.pv[3], prj.pv[4]);
printf(" %12.5f%12.5f%12.5f%12.5f%12.5f\n",
prj.pv[5], prj.pv[6], prj.pv[7], prj.pv[8], prj.pv[9]);
prjplt("ZPN", 90, 10, &prj);
/* ZEA: zenithal/azimuthal equal area. */
printf(text1, "Zenithal/azimuthal equal area");
prjplt("ZEA", 90, -90, &prj);
/* AIR: Airy's zenithal projection. */
prj.pv[1] = 45.0;
printf(text2, "Airy's zenithal");
printf("%12.5f\n", prj.pv[1]);
prjplt("AIR", 90, -85, &prj);
/* CYP: cylindrical perspective. */
prj.pv[1] = 3.0;
prj.pv[2] = 0.8;
printf(text2, "Cylindrical perspective");
printf("%12.5f%12.5f\n", prj.pv[1], prj.pv[2]);
prjplt("CYP", 90, -90, &prj);
/* CEA: cylindrical equal area. */
prj.pv[1] = 0.75;
printf(text2, "Cylindrical equal area");
printf("%12.5f\n", prj.pv[1]);
prjplt("CEA", 90, -90, &prj);
/* CAR: plate carree. */
printf(text1, "Plate carree");
prjplt("CAR", 90, -90, &prj);
/* MER: Mercator's. */
printf(text1, "Mercator's");
prjplt("MER", 85, -85, &prj);
/* SFL: Sanson-Flamsteed. */
printf(text1, "Sanson-Flamsteed (global sinusoid)");
prjplt("SFL", 90, -90, &prj);
/* PAR: parabolic. */
printf(text1, "Parabolic");
prjplt("PAR", 90, -90, &prj);
/* MOL: Mollweide's projection. */
printf(text1, "Mollweide's");
prjplt("MOL", 90, -90, &prj);
/* AIT: Hammer-Aitoff. */
printf(text1, "Hammer-Aitoff");
prjplt("AIT", 90, -90, &prj);
/* COP: conic perspective. */
prj.pv[1] = 60.0;
prj.pv[2] = 15.0;
printf(text2, "Conic perspective");
printf("%12.5f%12.5f\n", prj.pv[1], prj.pv[2]);
prjplt("COP", 90, -25, &prj);
/* COE: conic equal area. */
prj.pv[1] = 60.0;
prj.pv[2] = -15.0;
printf(text2, "Conic equal area");
printf("%12.5f%12.5f\n", prj.pv[1], prj.pv[2]);
prjplt("COE", 90, -90, &prj);
/* COD: conic equidistant. */
prj.pv[1] = -60.0;
prj.pv[2] = 15.0;
printf(text2, "Conic equidistant");
printf("%12.5f%12.5f\n", prj.pv[1], prj.pv[2]);
prjplt("COD", 90, -90, &prj);
/* COO: conic orthomorphic. */
prj.pv[1] = -60.0;
prj.pv[2] = -15.0;
printf(text2, "Conic orthomorphic");
printf("%12.5f%12.5f\n", prj.pv[1], prj.pv[2]);
prjplt("COO", 85, -90, &prj);
/* BON: Bonne's projection. */
prj.pv[1] = 30.0;
printf(text2, "Bonne's");
printf("%12.5f\n", prj.pv[1]);
prjplt("BON", 90, -90, &prj);
/* PCO: polyconic. */
printf(text1, "Polyconic");
prjplt("PCO", 90, -90, &prj);
/* TSC: tangential spherical cube. */
printf(text1, "Tangential spherical cube");
prjplt("TSC", 90, -90, &prj);
/* CSC: COBE quadrilateralized spherical cube. */
printf(text1, "COBE quadrilateralized spherical cube");
prjplt("CSC", 90, -90, &prj);
/* QSC: quadrilateralized spherical cube. */
printf(text1, "Quadrilateralized spherical cube");
prjplt("QSC", 90, -90, &prj);
/* HPX: HEALPix projection. */
prj.pv[1] = 4.0;
prj.pv[2] = 3.0;
printf(text1, "HEALPix");
prjplt("HPX", 90, -90, &prj);
/* XPH: HEALPix polar, aka "butterfly" projection. */
printf(text1, "Butterfly");
prjplt("XPH", 90, -90, &prj);
cpgask(0);
cpgend();
return 0;
}
int main()
{
//
printf("\n====================================================================\n");
printf("This program is able to simulate a variety of ecological\n");
printf("situations in a 2D lattice\n");
printf("====================================================================\n");
//==========================================================================
//--------------------------SYSTEM INITIALIZATIONS--------------------------
//==========================================================================
// initialize random seed
srand(time(NULL));
// force print all outputs (remove stdout buffer)
setbuf(stdout, NULL);
// initialize pgplot window
if (!cpgopen("/XWINDOW"))
errorCase(ERR_PGPLOT);
cpgpap(20.0, 0.33); // set window size
cpgsubp(3,1); // subdivide window into panels
// color indexes (R, G, B)
cpgscr(0, 0.0, 0.0, 0.0); // empty space, black
cpgscr(1, 1.0, 1.0, 1.0);
cpgscr(10, 0.0, 0.0, 0.0); // empty space, black
cpgscr(11, 0.5, 0.5, 0.5); // Trophic 1, gray
cpgscr(12, 0.5, 1.0, 1.0); // Trophic 2, cyan
cpgscr(13, 1.0, 0.5, 0.0); // Trophic 3, orange
cpgscr(14, 1.0, 0.0, 0.0);
cpgscir(10,NUMB_TROPHIC+10);
//==========================================================================
//--------------------------VARIABLE INITIALIZATIONS------------------------
//==========================================================================
// generic variables
int i, j, k; // counters
// simulation environment
int** simEnv = allocateArray2DInt(ENV_SIZE_X, ENV_SIZE_Y);
int** simEnvAge = allocateArray2DInt(ENV_SIZE_X, ENV_SIZE_Y);
int* simLocal = allocateArray1DInt(5);
// inputs
char input;
// current location and time
int x,y;
int tGlobal,t;
int flagUpdate;
// rates
float predationRates[NUMB_TROPHIC-1] = RATE_PRED;
float deathRates[NUMB_TROPHIC] = RATE_DEATH;
//float aBirth = 0; // A+0 -> A+A
// float abPred = 0; // B+A -> B+B
// float bDeath = 0; // B -> 0
// int aFlag; int abFlag; int bFlag;
// population counts;
int popCount[NUMB_TROPHIC];
float popDens[NUMB_TROPHIC];
float popDensOld[NUMB_TROPHIC];
for (i=0; i<NUMB_TROPHIC; i++){
popCount[i] = 0;
popDens[i] = 0.0;
popDensOld[i] = 1.0/(float)INIT_DENSITY;
}
float* ageStructure = allocateArray1D(ENV_SIZE_TOTAL);
// pgplot variables
float* plotImg = allocateArray1D(ENV_SIZE_TOTAL);
//float TR[6] = {0, 1, 0, 0, 0, 1};
float TR[6] = {0, 0, 1, ENV_SIZE_Y, -1, 0};
float plotMinBound = 0.0;
float plotMaxBound = (float)NUMB_TROPHIC;
//==========================================================================
//--------------------------ACTUAL CODE-------------------------------------
//==========================================================================
// environment initialization
randomizeArray2DInt(simEnv, ENV_SIZE_X, ENV_SIZE_Y, NUMB_TROPHIC);
// load initial display
for (i=0; i<ENV_SIZE_X; i++)
for (j=0; j<ENV_SIZE_Y; j++)
plotImg[i*ENV_SIZE_Y+j] = (float)(simEnv[i][j]);
cpgpanl(1,1);
cpgswin(0, ENV_SIZE_X-1, 0, ENV_SIZE_Y-1);
cpgsvp(0.01, 0.99, 0.01, 0.99);
cpgimag(plotImg, ENV_SIZE_Y, ENV_SIZE_X, 1, ENV_SIZE_Y, 1, ENV_SIZE_X, plotMinBound, plotMaxBound, TR);
// Load graph labels
// Population Density vs Time Plot
cpgpanl(2,1);
cpgsvp(0.08, 0.92, 0.08, 0.92);
cpgswin(0, ENV_SIZE_X, 0, 1);
cpgbox("ABCINTS", 0.0, 0, "ABCINTS", 0.0, 0);
cpglab("Time", "Population Density", "");
// Phase Portrait Plot
cpgpanl(3,1);
cpgsvp(0.08, 0.92, 0.08, 0.92);
cpgswin(0, 1, 0, 1);
cpgbox("ABCINTS", 0.0, 0, "ABCINTS", 0.0, 0);
cpglab("", "", "Phase Portrait");
cpgsci(11);
cpglab("Population Density SpA", "", "");
cpgsci(12);
cpglab("", "Population Density SpB", "");
// initial delay to visualize starting matrix
for (t=0; t<500000000; t++){}
tGlobal = 1;
while(1){
//aFlag = 0; abFlag = 0; bFlag = 0;
// run simulation for a full Monte Carlo timestep (ENV_SIZE_X*ENV_SIZE_Y)
for (t=0; t<ENV_SIZE_TOTAL; t++){
ecoRun(simEnv, simEnvAge, simLocal, predationRates, deathRates);
}
incrementAge(simEnvAge);
// plot stuffs
if ((tGlobal%1) == 0){
// calculate population densities
updatePopDens(simEnv, popCount, popDens);
// PLOT population densities
cpgpanl(2,1);
cpgsvp(0.08, 0.92, 0.08, 0.92);
cpgswin(0, ENV_SIZE_X, 0, 1);
for (i=0; i<NUMB_TROPHIC; i++){
cpgsls(1); cpgsci(i+11); // line style and color
cpgmove((tGlobal-1), popDensOld[i]);
cpgdraw(tGlobal, popDens[i]);
}
//printArray2DInt(simEnvAge, ENV_SIZE_X, ENV_SIZE_Y);
// PLOT age structure
/*updateAgeStructure(simEnv, simEnvAge, ageStructure, 1);
cpgpanl(3,1);
cpgsvp(0.08, 0.92, 0.08, 0.92);
cpgswin(0, 10, 0, (ENV_SIZE_TOTAL/10));
cpgsls(1); cpgsci(1); // line style and color
cpgeras();
cpgbox("ABCINTS", 0.0, 0, "ABCINTS", 0.0, 0);
cpglab("Age", "Number of Individuals", "Age Structure");
cpghist(popCount[1], ageStructure, 0, 10, 10, 1);*/
// PLOT phase portrait
cpgpanl(3,1);
cpgsvp(0.08, 0.92, 0.08, 0.92);
cpgswin(0, 1, 0, 1);
cpgsls(1); cpgsci(1); // line style and color
cpgmove(popDensOld[0], popDensOld[1]);
cpgdraw(popDens[0], popDens[1]);
for (i=0; i<NUMB_TROPHIC; i++)
popDensOld[i] = popDens[i];
}
// load array and display on pgplot
if ((tGlobal%1) == 0){
cpgpanl(1,1);
cpgswin(0, ENV_SIZE_X, 0, ENV_SIZE_Y);
cpgsvp(0.01, 0.99, 0.01, 0.99);
for (i=0; i<ENV_SIZE_X; i++)
for (j=0; j<ENV_SIZE_Y; j++)
plotImg[i*ENV_SIZE_Y+j] = (float)(simEnv[i][j]);
cpgimag(plotImg, ENV_SIZE_Y, ENV_SIZE_X, 1, ENV_SIZE_Y, 1, ENV_SIZE_X, plotMinBound, plotMaxBound, TR);
}
tGlobal++;
//for (t=0; t<10000000; t++){}
}
}
/* assign RGB color to a color index */
static void _pgscr (int *ci, double *red, double *green, double *blue)
{
cpgscr (*ci, (float) *red, (float) *green, (float) *blue);
}
int main()
{
char text[80];
register int status;
printf("Testing WCSLIB wcsmix() routine (twcsmix.c)\n"
"-------------------------------------------\n");
/* List status return messages. */
printf("\nList of wcs status return values:\n");
for (status = 1; status <= 13; status++) {
printf("%4d: %s.\n", status, wcs_errmsg[status]);
}
/* PGPLOT initialization. */
strcpy(text, "/xwindow");
cpgbeg(0, text, 1, 1);
/* Define pen colours. */
cpgscr(0, 0.00f, 0.00f, 0.00f);
cpgscr(1, 1.00f, 1.00f, 0.00f);
cpgscr(2, 1.00f, 1.00f, 1.00f);
cpgscr(3, 0.50f, 0.50f, 0.80f);
cpgscr(4, 0.80f, 0.50f, 0.50f);
cpgscr(5, 0.80f, 0.80f, 0.80f);
cpgscr(6, 0.50f, 0.50f, 0.80f);
cpgscr(7, 0.80f, 0.50f, 0.50f);
cpgscr(8, 0.30f, 0.50f, 0.30f);
cpgscr(9, 1.00f, 0.75f, 0.00f);
/*----------------------------------------------------------*/
/* Set the PVi_m keyvalues for the longitude axis so that */
/* the fiducial native coordinates are at the native pole, */
/* i.e. (phi0,theta0) = (0,90), but without any fiducial */
/* offset. We do this as a test, and also so that all */
/* projections will be exercised with the same obliquity */
/* parameters. */
/*----------------------------------------------------------*/
PV[0].i = 4; /* Longitude is on axis 4. */
PV[0].m = 1; /* Parameter number 1. */
PV[0].value = 0.0; /* Fiducial native longitude. */
PV[1].i = 4; /* Longitude is on axis 4. */
PV[1].m = 2; /* Parameter number 2. */
PV[1].value = 90.0; /* Fiducial native latitude. */
/* Set the PVi_m keyvalues for the latitude axis. */
PV[2].i = 2; /* Latitude is on axis 2. */
PV[2].m = 1; /* Parameter number 1. */
PV[2].value = 0.0; /* PVi_1 (set below). */
PV[3].i = 2; /* Latitude is on axis 2. */
PV[3].m = 2; /* Parameter number 2. */
PV[3].value = 0.0; /* PVi_2 (set below). */
/* ARC: zenithal/azimuthal equidistant. */
strncpy(&CTYPE[1][5], "ARC", 3);
strncpy(&CTYPE[3][5], "ARC", 3);
NPV = 2;
mixex(-190.0, 190.0, -190.0, 190.0);
/* ZEA: zenithal/azimuthal equal area. */
strncpy(&CTYPE[1][5], "ZEA", 3);
strncpy(&CTYPE[3][5], "ZEA", 3);
NPV = 2;
mixex(-120.0, 120.0, -120.0, 120.0);
/* CYP: cylindrical perspective. */
strncpy(&CTYPE[1][5], "CYP", 3);
strncpy(&CTYPE[3][5], "CYP", 3);
NPV = 4;
PV[2].value = 3.0;
PV[3].value = 0.8;
mixex(-170.0, 170.0, -170.0, 170.0);
/* CEA: cylindrical equal area. */
strncpy(&CTYPE[1][5], "CEA", 3);
strncpy(&CTYPE[3][5], "CEA", 3);
NPV = 3;
PV[2].value = 0.75;
mixex(-200.0, 200.0, -200.0, 200.0);
/* CAR: plate carree. */
strncpy(&CTYPE[1][5], "CAR", 3);
strncpy(&CTYPE[3][5], "CAR", 3);
NPV = 2;
mixex(-210.0, 210.0, -210.0, 210.0);
/* SFL: Sanson-Flamsteed. */
strncpy(&CTYPE[1][5], "SFL", 3);
strncpy(&CTYPE[3][5], "SFL", 3);
NPV = 2;
mixex(-190.0, 190.0, -190.0, 190.0);
/* PAR: parabolic. */
strncpy(&CTYPE[1][5], "PAR", 3);
strncpy(&CTYPE[3][5], "PAR", 3);
NPV = 2;
mixex(-190.0, 190.0, -190.0, 190.0);
/* MOL: Mollweide's projection. */
strncpy(&CTYPE[1][5], "MOL", 3);
strncpy(&CTYPE[3][5], "MOL", 3);
NPV = 2;
mixex(-170.0, 170.0, -170.0, 170.0);
/* AIT: Hammer-Aitoff. */
strncpy(&CTYPE[1][5], "AIT", 3);
strncpy(&CTYPE[3][5], "AIT", 3);
NPV = 2;
mixex(-170.0, 170.0, -170.0, 170.0);
/* COE: conic equal area. */
strncpy(&CTYPE[1][5], "COE", 3);
strncpy(&CTYPE[3][5], "COE", 3);
NPV = 4;
PV[2].value = 60.0;
PV[3].value = 15.0;
mixex(-140.0, 140.0, -120.0, 160.0);
/* COD: conic equidistant. */
strncpy(&CTYPE[1][5], "COD", 3);
strncpy(&CTYPE[3][5], "COD", 3);
NPV = 4;
PV[2].value = 60.0;
PV[3].value = 15.0;
mixex(-200.0, 200.0, -180.0, 220.0);
/* BON: Bonne's projection. */
strncpy(&CTYPE[1][5], "BON", 3);
strncpy(&CTYPE[3][5], "BON", 3);
NPV = 3;
PV[2].value = 30.0;
mixex(-160.0, 160.0, -160.0, 160.0);
/* PCO: polyconic. */
strncpy(&CTYPE[1][5], "PCO", 3);
strncpy(&CTYPE[3][5], "PCO", 3);
NPV = 2;
mixex(-190.0, 190.0, -190.0, 190.0);
/* TSC: tangential spherical cube. */
strncpy(&CTYPE[1][5], "TSC", 3);
strncpy(&CTYPE[3][5], "TSC", 3);
NPV = 2;
mixex(-340.0, 80.0, -210.0, 210.0);
/* QSC: quadrilateralized spherical cube. */
strncpy(&CTYPE[1][5], "QSC", 3);
strncpy(&CTYPE[3][5], "QSC", 3);
NPV = 2;
mixex(-340.0, 80.0, -210.0, 210.0);
cpgend();
return 0;
}
