static int plot_dataview(dataview * dv, float minval, float maxval, float charhgt)
/* The return value is offsetn */
{
int ii, lon, hin, offsetn = 0, tmpn;
double lot, hit, offsett = 0.0;
float ns[MAXDISPNUM], hiavg[MAXDISPNUM], loavg[MAXDISPNUM];
float scalemin = 0.0, scalemax = 0.0, dscale;
cpgsave();
cpgbbuf();
/* Set the "Normal" plotting attributes */
cpgsls(1);
cpgslw(1);
cpgsch(charhgt);
cpgsci(1);
cpgvstd();
/* Autoscale for the maximum value */
if (maxval > 0.5 * LARGENUM)
scalemax = dv->maxval;
else
scalemax = maxval;
/* Autoscale for the minimum value */
if (minval < 0.5 * SMALLNUM)
scalemin = dv->minval;
else
scalemin = minval;
dscale = 0.1 * (scalemax - scalemin);
if (maxval > 0.5 * LARGENUM)
maxval = scalemax + dscale;
if (minval < 0.5 * SMALLNUM)
minval = scalemin - dscale;
lon = dv->lon;
lot = lon * idata.dt;
hin = lon + dv->numsamps;
hit = hin * idata.dt;
/* Time Labels (top of box) */
if ((hit - lot) / hit < 0.001) {
int numchar;
char label[50];
offsett = 0.5 * (hit + lot);
numchar = snprintf(label, 50, "Time - %.15g (s)", offsett);
cpgmtxt("T", 2.5, 0.5, 0.5, label);
} else {
cpgmtxt("T", 2.5, 0.5, 0.5, "Time (s)");
}
cpgswin(lot - offsett, hit - offsett, minval, maxval);
cpgbox("CMST", 0.0, 0, "", 0.0, 0);
/* Sample number labels */
if (lon > 10000000 || (double) (hin - lon) / (double) hin < 0.001) {
int numchar;
char label[50];
offsetn = (lon / 10000) * 10000;
numchar = snprintf(label, 50, "Sample - %d", offsetn);
cpgmtxt("B", 2.8, 0.5, 0.5, label);
} else {
cpgmtxt("B", 2.8, 0.5, 0.5, "Sample");
}
cpgswin(lon - offsetn, hin - offsetn, minval, maxval);
cpgbox("BNST", 0.0, 0, "BCNST", 0.0, 0);
/* Plot the rawdata if required */
tmpn = lon - offsetn;
if (plotstats == 0 || plotstats == 2) {
if (dv->zoomlevel > 0) {
for (ii = 0; ii < dv->dispnum; ii++)
ns[ii] = tmpn + ii;
cpgbin(dv->dispnum, ns, dv->vals, 0);
} else { /* Plot the min/max values */
for (ii = 0; ii < dv->numchunks; ii++, tmpn += dv->chunklen) {
cpgmove((float) tmpn, dv->mins[ii]);
cpgdraw((float) tmpn, dv->maxs[ii]);
}
}
}
/* Plot the other statistics if requested */
if (plotstats == 0 || plotstats == 1) {
tmpn = lon - offsetn;
for (ii = 0; ii < dv->numchunks; ii++, tmpn += dv->chunklen) {
ns[ii] = tmpn;
hiavg[ii] = dv->avgmeds[ii] + dv->stds[ii];
loavg[ii] = dv->avgmeds[ii] - dv->stds[ii];
}
if (dv->numchunks > 512) {
if (plotstats == 1) {
cpgline(dv->numchunks, ns, dv->mins);
cpgline(dv->numchunks, ns, dv->maxs);
}
cpgsci(AVGMED_COLOR);
cpgline(dv->numchunks, ns, dv->avgmeds);
if (usemedian)
cpgmtxt("T", -1.4, 0.02, 0.0, "Median");
else
cpgmtxt("T", -1.4, 0.02, 0.0, "Average");
cpgsci(STDDEV_COLOR);
cpgline(dv->numchunks, ns, hiavg);
cpgline(dv->numchunks, ns, loavg);
cpgmtxt("T", -2.6, 0.02, 0.0, "+/- 1 Std Dev");
} else {
if (plotstats == 1) {
cpgbin(dv->numchunks, ns, dv->mins, 0);
cpgbin(dv->numchunks, ns, dv->maxs, 0);
}
cpgsci(AVGMED_COLOR);
cpgbin(dv->numchunks, ns, dv->avgmeds, 0);
if (usemedian)
cpgmtxt("T", -1.4, 0.02, 0.0, "Median");
else
cpgmtxt("T", -1.4, 0.02, 0.0, "Average");
cpgsci(STDDEV_COLOR);
cpgbin(dv->numchunks, ns, hiavg, 0);
cpgbin(dv->numchunks, ns, loavg, 0);
cpgmtxt("T", -2.6, 0.02, 0.0, "+/- 1 Std Dev");
}
}
cpgsci(1);
cpgmtxt("L", 2.5, 0.5, 0.5, "Sample Value");
cpgebuf();
cpgunsa();
return offsetn;
}
void main() //main code
{
printf("\nRUNGE-KUTTA METHOD\n\nR M Rho\n"); //printing titles for values displayed
double c = 10.0; //the parameter rho(c)
int n; //the integer steps, n
//declare arrays
float x[N];
float y[N];
float z[N];
//r,m,p as the radius, mass and density
double r,m,p;
//declare initial conditons for arrays
x[0] = h; //first array is for r=h
y[0] = (h*h*h/3)*c; //initial conditon for scaled mass (m)
z[0] = c*(1-((h*h*c)/(6*gamma(c)))); //initial conditon for rho
//for loop for n=0,1,...,200
for(n=0;n<N;n++)
{
//declared how x(n+1) relates to x(n), y(n+1) relates to y(n), z(n+1) relates to z(n)
x[n+1] = x[n]+h;
y[n+1] = y[n]+(h/6)*(M(x[n],y[n],z[n])+2*M2(x[n],y[n],z[n])+2*M3(x[n],y[n],z[n])+M4(x[n],y[n],z[n]));
z[n+1] = z[n]+(h/6)*(rho(x[n],y[n],z[n])+2*rho2(x[n],y[n],z[n])+2*rho3(x[n],y[n],z[n])+rho4(x[n],y[n],z[n]));
if(isnan(z[n+1]))
{
break;
}
//r,m,p will be declared in pg-plot
r = x[n+1];
m = y[n+1];
p = z[n+1];
printf("%.2e %.2e %.2e\n",x[n+1],y[n+1],z[n+1]); //printed values for x and y respectively
}
//Use pg-plot to plot mass and density
// cpgbeg starts a plotting page, in this case with 2x1 panels
cpgbeg(0,"?",2,1);
// sets colour: 1-black, 2-red, 3-green, 4-blue
cpgsci(1);
// sets line style: 1-solid, 2-dashed, 3-dot-dashed, 4-dotted
cpgsls(1);
// sets charachter height, larger number = bigger
cpgsch(1.);
// cpgpage() moves to the next panel
cpgpage();
// sets the axes limits in the panel
cpgswin(0,r,0,m);
// draw the axes
cpgbox("BCNST", 0.0, 0, "BCNST", 0.0, 0);
// label the bottom axis
cpgmtxt("B",2.,.5,.5,"radius");
// label the left axis
cpgmtxt("L",2.5,.5,.5,"saclaed mass");
// connect N points in ax and ay with a line
cpgline(n,x,y);
// cpgpage() moves to the next panel
cpgpage();
// sets the axes limits in the panel
cpgswin(0,r,0,c);
// draw the axes
cpgbox("BCNST", 0.0, 0, "BCNST", 0.0, 0);
// label the bottom axis
cpgmtxt("B",2.,.5,.5,"radius");
// label the left axis
cpgmtxt("L",2.5,.5,.5,"density");
// connect N points in ax and ay with a line
cpgline(n,x,z);
// close all pgplot applications
cpgend();
// end program
return;
}
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;
}
/*
* Class: pulsarhunter_PgplotInterface
* Method: pgsls
* Signature: (I)V
*/
JNIEXPORT void JNICALL Java_pulsarhunter_PgplotInterface_pgsls
(JNIEnv *env, jclass cl, jint s){
cpgsls(s);
}
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();
}
// Main code
int main()
{
/**** Count to 10 in integers ****/
// Declare integer for loop counting
int i;
// Loop from 0 to 10, printing at each step
for(i=0; i<10; i++)
{
printf("i= %d\n", i);
}
/**** Plot a function y=f(x) ****/
// Declare arrays of N real numbers
float ax[N]; // x
float ay[N]; // y
float aylow[N]; // lower error in y
float ayhigh[N]; // upper error in y
// Set minimum and maximum for x
float xmin = 0.0;
float xmax = 10.0;
// Assigning ax with N values for x between xmin and xmax
for(i=0;i<N;i++)
{
ax[i] = xmin + (xmax-xmin)*(float)i/(float)(N-1);
}
// Fill ay using function fy
for(i=0;i<N;i++)
{
ay[i] = fy(ax[i]);
}
// Fill aylow and ayhigh using sqrt(y) as the error
for(i=0;i<N;i++)
{
aylow[i] = ay[i] - sqrt(ay[i]);
ayhigh[i] = ay[i] + sqrt(ay[i]);
}
/**** Use pgplot to plot this function ****/
// cpgbeg starts a plotting page, in this case with 2x1 panels
cpgbeg(0,"?",2,1);
// sets colour: 1-black, 2-red, 3-green, 4-blue
cpgsci(1);
// sets line style: 1-solid, 2-dashed, 3-dot-dashed, 4-dotted
cpgsls(1);
// sets charachter height, larger number = bigger
cpgsch(2.);
// cpgpage() moves to the next panel
cpgpage();
// sets the axes limits in the panel
cpgswin(xmin,xmax,0.,100.);
// draw the axes
cpgbox("BCNST", 0.0, 0, "BCNST", 0.0, 0);
// label the bottom axis
cpgmtxt("B",2.,.5,.5,"x");
// label the left axis
cpgmtxt("L",2.5,.5,.5,"f");
// connect N points in ax and ay with a line
cpgline(N,ax,ay);
// cpgpage() moves to the next panel
cpgpage();
// sets the axes limits in the panel
cpgswin(xmin,xmax,0.,100.);
// draw the axes
cpgbox("BCNST", 0.0, 0, "BCNST", 0.0, 0);
// label the bottom axis
cpgmtxt("B",2.,.5,.5,"x");
// label the left axis
cpgmtxt("L",2.5,.5,.5,"f");
// draw N points in ax and ay
// 17 - filled circles, 16 - filled squares, 13 - filled triangles
cpgpt(N,ax,ay,17);
// draw y error bars on the points
cpgerry(N,ax,aylow,ayhigh,1.0);
// close all pgplot applications
cpgend();
// end program
return 0;
}
static double plot_fftview(fftview * fv, float maxpow, float charhgt,
float vertline, int vertline_color)
/* The return value is offsetf */
{
int ii;
double lor, lof, hir, hif, offsetf = 0.0;
float *freqs;
cpgsave();
cpgbbuf();
/* Set the "Normal" plotting attributes */
cpgsls(1);
cpgslw(1);
cpgsch(charhgt);
cpgsci(1);
cpgvstd();
if (maxpow == 0.0) /* Autoscale for the maximum value */
maxpow = 1.1 * fv->maxpow;
lor = fv->lor;
lof = lor / T;
hir = lor + fv->dr * DISPLAYNUM;
hif = hir / T;
offsetf = 0.0;
/* Period Labels */
if (fv->zoomlevel >= 0 && lof > 1.0) {
double lop, hip, offsetp = 0.0;
lop = 1.0 / lof;
hip = 1.0 / hif;
offsetp = 0.0;
if ((lop - hip) / hip < 0.001) {
int numchar;
char label[50];
offsetp = 0.5 * (hip + lop);
numchar = snprintf(label, 50, "Period - %.15g (s)", offsetp);
cpgmtxt("T", 2.5, 0.5, 0.5, label);
} else {
cpgmtxt("T", 2.5, 0.5, 0.5, "Period (s)");
}
cpgswin(lop - offsetp, hip - offsetp, 0.0, maxpow);
cpgbox("CIMST", 0.0, 0, "", 0.0, 0);
}
/* Frequency Labels */
if ((hif - lof) / hif < 0.001) {
int numchar;
char label[50];
offsetf = 0.5 * (hif + lof);
numchar = snprintf(label, 50, "Frequency - %.15g (Hz)", offsetf);
cpgmtxt("B", 2.8, 0.5, 0.5, label);
} else {
cpgmtxt("B", 2.8, 0.5, 0.5, "Frequency (Hz)");
}
cpgswin(lof - offsetf, hif - offsetf, 0.0, maxpow);
/* Add zapboxes if required */
if (numzaplist) {
double zaplo, zaphi;
cpgsave();
cpgsci(15);
cpgsfs(1);
for (ii = 0; ii < numzaplist; ii++) {
zaplo = zaplist[ii].lobin;
zaphi = zaplist[ii].hibin;
if ((zaplo < hir && zaplo > lor) || (zaphi < hir && zaphi > lor)) {
cpgrect(zaplo / T - offsetf, zaphi / T - offsetf, 0.0, 0.95 * maxpow);
}
}
cpgunsa();
}
/* Add a background vertical line if requested */
if (vertline != 0.0 && vertline_color != 0) {
cpgsave();
cpgsci(vertline_color);
cpgmove(vertline / T - offsetf, 0.0);
cpgdraw(vertline / T - offsetf, maxpow);
cpgunsa();
}
if (fv->zoomlevel >= 0 && lof > 1.0)
cpgbox("BINST", 0.0, 0, "BCNST", 0.0, 0);
else
cpgbox("BCINST", 0.0, 0, "BCNST", 0.0, 0);
/* Plot the spectrum */
freqs = gen_fvect(DISPLAYNUM);
for (ii = 0; ii < DISPLAYNUM; ii++)
freqs[ii] = fv->rs[ii] / T - offsetf;
if (fv->zoomlevel > 0) { /* Magnified power spectrum */
cpgline(DISPLAYNUM, freqs, fv->powers);
} else { /* Down-sampled power spectrum */
for (ii = 0; ii < DISPLAYNUM; ii++) {
cpgmove(freqs[ii], 0.0);
cpgdraw(freqs[ii], fv->powers[ii]);
}
}
vect_free(freqs);
cpgmtxt("L", 2.5, 0.5, 0.5, "Normalized Power");
cpgebuf();
cpgunsa();
return offsetf;
}
int main(int argc,char *argv[])
{
int i;
char fname[128];
dSet *data;
float freq,bw,chanbw;
int nchan,npol;
float bpass[4096];
float fx[4096];
float miny,maxy,minx,maxx;
float ominy,omaxy,ominx,omaxx;
float mx,my,mx2,my2;
float binw;
char key;
char grDev[128]="/xs";
int interactive=1;
int noc1=0;
int zapChannels[4096];
int nzap=0;
int overlay=-1;
float overlayVal[MAX_OVERLAY];
char overlayStr[MAX_OVERLAY][128];
char overlayFile[128];
int noverlay=0;
fitsfile *fp;
data = initialiseDset();
for (i=0;i<argc;i++)
{
if (strcmp(argv[i],"-f")==0)
strcpy(fname,argv[++i]);
else if (strcmp(argv[i],"-noc1")==0)
noc1=1;
else if (strcmp(argv[i],"-g")==0)
{
strcpy(grDev,argv[++i]);
interactive=0;
}
else if (strcmp(argv[i],"-h")==0)
help();
else if (strcmp(argv[i],"-overlay")==0)
{
strcpy(overlayFile,argv[++i]);
overlay=1;
}
}
if (overlay==1)
{
FILE *fin;
char line[1024];
noverlay=0;
if (!(fin = fopen(overlayFile,"r")))
printf("Unable to open overlay file >%s<\n",overlayFile);
else
{
while (!feof(fin))
{
fgets(overlayStr[noverlay],1024,fin);
if (fscanf(fin,"%f",&overlayVal[noverlay])==1)
{
if (overlayStr[noverlay][strlen(overlayStr[noverlay])-1] == '\n')
overlayStr[noverlay][strlen(overlayStr[noverlay])-1]='\0';
noverlay++;
}
}
fclose(fin);
}
}
fp = openFitsFile(fname);
loadPrimaryHeader(fp,data);
displayHeaderInfo(data);
readBandpass(fp,bpass);
nchan = data->phead.nchan;
freq = data->phead.freq;
bw = data->phead.bw;
chanbw = data->phead.chanbw;
for (i=0;i<nchan;i++)
{
fx[i] = freq-bw/2+(i+0.5)*chanbw;
if (i==noc1)
{
miny = maxy = bpass[i];
minx = maxx = fx[i];
}
else if (i!=0)
{
if (bpass[i] > maxy) maxy = bpass[i];
if (bpass[i] < miny) miny = bpass[i];
if (fx[i] > maxx) maxx = fx[i];
if (fx[i] < minx) minx = fx[i];
}
}
ominx = minx;
omaxx = maxx;
ominy = miny;
omaxy = maxy;
binw = fx[1]-fx[0];
printf("Complete\n");
cpgbeg(0,grDev,1,1);
cpgask(0);
do {
cpgenv(minx,maxx,miny,maxy,0,1);
cpglab("Frequency (MHz)","Amplitude (arbitrary)",fname);
cpgbin(nchan-noc1,fx+noc1,bpass+noc1,0);
if (overlay==1)
{
float tx[2],ty[2];
cpgsls(4); cpgsci(2); cpgsch(0.8);
for (i=0;i<noverlay;i++)
{
tx[0] = tx[1] = overlayVal[i];
ty[0] = miny;
ty[1] = maxy;
if (tx[1] > minx && tx[1] < maxx)
{
cpgline(2,tx,ty);
// cpgtext(tx[1],ty[1]-0.05*(maxy-miny),overlayStr[i]);
cpgptxt(tx[1]-0.004*(maxx-minx),ty[0]+0.05*(maxy-miny),90,0.0,overlayStr[i]);
}
}
cpgsci(1); cpgsls(1); cpgsch(1);
}
if (interactive==1)
{
cpgcurs(&mx,&my,&key);
if (key=='A')
{
int cc=-1;
int i;
for (i=0;i<nchan-1;i++)
{
// if ((bw > 0 && (mx > fx[i]-binw/2 && mx < fx[i]+binw/2)) ||
// (bw < 0 && (mx > fx[i]+binw/2 && mx < fx[i]-binw/2)))
if ((bw > 0 && (mx > fx[i] && mx < fx[i]+binw)) ||
(bw < 0 && (mx > fx[i] && mx < fx[i]+binw)))
{
cc = i;
break;
}
}
printf("mouse x = %g MHz, mouse y = %g, channel = %d, channel frequency = %g MHz\n",mx,my,cc,fx[cc]);
}
else if (key=='X')
{
int cc=-1;
int i;
printf("Deleting %g %g %g\n",mx,fx[10],binw);
for (i=0;i<nchan-1;i++)
{
// if ((bw > 0 && (mx > fx[i]-binw/2 && mx < fx[i]+binw/2)) ||
// (bw < 0 && (mx > fx[i]+binw/2 && mx < fx[i]-binw/2)))
if ((bw > 0 && (mx > fx[i] && mx < fx[i]+binw)) ||
(bw < 0 && (mx > fx[i] && mx < fx[i]+binw)))
{
cc = i;
break;
}
}
printf("Want to delete = %d\n",cc);
if (cc != -1)
{
bpass[cc] = 0;
omaxy = bpass[noc1];
zapChannels[nzap++] = cc;
for (i=noc1;i<nchan;i++)
{
if (omaxy < bpass[i]) omaxy = bpass[i];
}
}
}
else if (key=='z')
{
cpgband(2,0,mx,my,&mx2,&my2,&key);
if (mx > mx2) {maxx = mx; minx = mx2;}
else {maxx = mx2; minx = mx;}
if (my > my2) {maxy = my; miny = my2;}
else {maxy = my2; miny = my;}
}
else if (key=='u')
{
minx = ominx;
maxx = omaxx;
miny = ominy;
maxy = omaxy;
}
else if (key=='l') // List the channels and frequencies to zap
{
int i;
sortInt(zapChannels,nzap);
printf("-------------------------------------------------------\n");
printf("Zap channels with first channel = 0\n\n");
for (i=0;i<nzap;i++)
printf("%d ",zapChannels[i]);
printf("\n\n");
printf("Zap channels with first channel = 1\n\n");
for (i=0;i<nzap;i++)
printf("%d ",zapChannels[i]+1);
printf("\n\n");
printf("Zap channels frequencies:\n\n");
for (i=0;i<nzap;i++)
printf("%g ",fx[zapChannels[i]]);
printf("\n\n");
printf("-------------------------------------------------------\n");
}
else if (key=='%') // Enter percentage of the band edges to zap
{
float percent;
int i;
printf("Enter band edge percentage to zap ");
scanf("%f",&percent);
for (i=0;i<nchan;i++)
{
if (i < nchan*percent/100.0 || i > nchan-(nchan*percent/100.0))
{
bpass[i] = 0;
zapChannels[nzap++] = i;
}
}
omaxy = bpass[noc1];
for (i=noc1;i<nchan;i++)
{
if (omaxy < bpass[i]) omaxy = bpass[i];
}
// Unzoom
minx = ominx;
maxx = omaxx;
miny = ominy;
maxy = omaxy;
}
}
} while (key != 'q' && interactive==1);
cpgend();
}
void doPlot(pulsar *psr,int npsr,float *scale,int nScale,char *grDev,int plotUs,float fontSize,float centreMJD,int ptStyle,float ptSize,int error,float minyv,float maxyv,float minxv,float maxxv,int nOverlay,float labelsize,float fracX)
{
int i,j,fitFlag=2,exitFlag=0,scale1=0,scale2,count[MAX_PSR],p,xautoscale=0,k,graphics=1;
int yautoscale=0,plotpre=1;
int ps,pe,pi;
int time=0;
char xstr[1000],ystr[1000];
float px[2],py[2],pye1[2],pye2[2];
float x[MAX_PSR][MAX_OBSN],y[MAX_PSR][MAX_OBSN],yerr1[MAX_PSR][MAX_OBSN],yerr2[MAX_PSR][MAX_OBSN],tmax,tmin,tmaxy1,tminy1,tmaxy2,tminy2;
float sminy[MAX_PSR],smaxy[MAX_PSR];
float minx[MAX_PSR],maxx[MAX_PSR],miny[MAX_PSR],maxy[MAX_PSR],plotx1,plotx2,ploty1,ploty2,mean;
float fx[2],fy[2];
float mouseX,mouseY;
char key;
// float widthPap=0.0,aspectPap=0.618;
float widthPap=0.0,aspectPap=1;
float xx[MAX_OBSN],yy[MAX_OBSN],yyerr1[MAX_OBSN],yyerr2[MAX_OBSN];
int num=0,colour;
/* Obtain a graphical PGPLOT window */
cpgbeg(0,grDev,1,1);
// cpgpap(widthPap,aspectPap);
cpgsch(fontSize);
cpgscf(2);
cpgslw(2);
cpgask(0);
for (p=0;p<npsr;p++)
{
scale2 = psr[p].nobs;
/* sprintf(xstr,"MJD-%.1Lf",psr[0].param[param_pepoch].val[0]); */
if (centreMJD == -1)
sprintf(xstr,"Year");
else
sprintf(xstr,"MJD-%.1f",centreMJD);
sprintf(ystr,"Residual (\\gmsec)");
count[p]=0;
printf("points = %d\n",psr[p].nobs);
for (i=0;i<psr[p].nobs;i++)
{
if (psr[p].obsn[i].deleted == 0 &&
(psr[p].param[param_start].paramSet[0]!=1 || psr[p].param[param_start].fitFlag[0]!=1 ||
psr[p].param[param_start].val[0] < psr[p].obsn[i].bat) &&
(psr[p].param[param_finish].paramSet[0]!=1 || psr[p].param[param_finish].fitFlag[0]!=1 ||
psr[p].param[param_finish].val[0] > psr[p].obsn[i].bat))
{
/* x[p][count[p]] = (double)(psr[p].obsn[i].bat-psr[0].param[param_pepoch].val[0]); */
if (centreMJD == -1)
x[p][count[p]] = calcYr(psr[p].obsn[i].bat);
else
x[p][count[p]] = (double)(psr[p].obsn[i].bat-centreMJD);
y[p][count[p]] = (double)psr[p].obsn[i].residual*1.0e6;
if (nScale>0)
y[p][count[p]] *= scale[p];
count[p]++;
}
}
/* Remove mean from the residuals and calculate error bars */
mean = findMean(y[p],psr,p,scale1,count[p]);
count[p]=0;
for (i=0;i<psr[p].nobs;i++)
{
if (psr[p].obsn[i].deleted==0 &&
(psr[p].param[param_start].paramSet[0]!=1 || psr[p].param[param_start].fitFlag[0]!=1 ||
psr[p].param[param_start].val[0] < psr[p].obsn[i].bat) &&
(psr[p].param[param_finish].paramSet[0]!=1 || psr[p].param[param_finish].fitFlag[0]!=1 ||
psr[p].param[param_finish].val[0] > psr[p].obsn[i].bat))
{
psr[p].obsn[i].residual-=mean/1.0e6;
y[p][count[p]]-=mean;
yerr1[p][count[p]] = y[p][count[p]]-(float)psr[p].obsn[i].toaErr;
yerr2[p][count[p]] = y[p][count[p]]+(float)psr[p].obsn[i].toaErr;
count[p]++;
}
}
/* Get scaling for graph */
if (minxv == maxxv) {
minx[p] = findMin(x[p],psr,p,scale1,count[p]);
maxx[p] = findMax(x[p],psr,p,scale1,count[p]);
}
else {
minx[p] = minxv;
maxx[p] = maxxv;
}
if (minyv == maxyv){
miny[p] = findMin(y[p],psr,p,scale1,count[p]);
maxy[p] = findMax(y[p],psr,p,scale1,count[p]);
}
else {
miny[p] = minyv;
maxy[p] = maxyv;
}
sminy[p] = miny[p]/1e6;
smaxy[p] = maxy[p]/1e6;
}
for (p=0;p<npsr;p++)
{
for (i=0;i<count[p];i++)
{
y[p][i] = (y[p][i]-miny[p])/(maxy[p]-miny[p]);
yerr1[p][i] = (yerr1[p][i]-miny[p])/(maxy[p]-miny[p]);
yerr2[p][i] = (yerr2[p][i]-miny[p])/(maxy[p]-miny[p]);
}
// maxy[p] = 1.0;
// miny[p] = 0.0;
}
tmin = findMinVal(minx,npsr);
tmax = findMaxVal(maxx,npsr);
tminy2 = 0.0; //findMinVal(miny,npsr);
tmaxy2 = 1.0; //findMaxVal(maxy,npsr);
plotx1 = tmin-(tmax-tmin)*0.1;
plotx2 = tmax+(tmax-tmin)*0.1;
// ploty1 = tminy2-(tmaxy2-tminy2)*0.1;
// ploty2 = tmaxy2+(tmaxy2-tminy2)*0.1;
ploty1 = 0.1;
ploty2 = 0.9;
for (p=0;p<npsr;p++)
{
for (i=0;i<count[p];i++)
{
y[p][i]=(p)+ploty1+y[p][i]*(ploty2-ploty1);
yerr1[p][i]=(p)+ploty1+yerr1[p][i]*(ploty2-ploty1);
yerr2[p][i]=(p)+ploty1+yerr2[p][i]*(ploty2-ploty1);
}
}
printf("ytick = %g\n",ploty2-ploty1);
/* cpgenv(plotx1,plotx2,ploty1,ploty2+(ploty2-ploty1)*(npsr-1),0,0); */
// cpgenv(plotx1,plotx2,0,npsr+1,0,-1);
if (labelsize!=-1)
cpgsch(labelsize);
cpgsvp(fracX,1.0,0.1,1.0);
cpgswin(0,1,0,npsr);
cpgbox("ABC",0.0,0,"C",0.0,0);
cpgsch(fontSize);
char str[1000];
for (p=0;p<npsr;p++)
{
cpgsch(fontSize);
// cpgtext(tmax+(tmax-tmin)*0.05,p+1.5-0.5,psr[p].name);
cpgtext(0,p+0.6,psr[p].name);
// cpgsch(fontSize);
if (plotUs==0)
{
sprintf(str,"%.2f",(double)((smaxy[p]-sminy[p])*psr[p].param[param_f].val[0]));
cpgtext(0,p+0.4,str);
// cpgtext(tmax+(tmax-tmin)*0.05,p+1.1-0.5,str);
}
else
{
sprintf(str,"%.2f\\gms",(double)((smaxy[p]-sminy[p])/1e-6));
// cpgtext(tmax+(tmax-tmin)*0.05,p+1.1-0.5,str);
cpgtext(0,p+0.1,str);
}
cpgsch(1);
px[0] = 0;
// px[1] = tmax; //+(tmax-tmin)*0.03;
px[1] = 1;
py[0] = p;
py[1] = p;
cpgline(2,px,py);
}
if (labelsize!=-1)
cpgsch(labelsize);
cpgsvp(0.1,fracX,0.1,1.0);
cpgswin(plotx1,plotx2,0,npsr);
cpgbox("ATNSBC",0.0,0,"B",0.0,0);
cpglab(xstr,"","");
cpgsch(fontSize);
for (p=0;p<npsr;p++)
{
cpgsls(1);
px[0] = plotx1;
// px[1] = tmax; //+(tmax-tmin)*0.03;
px[1] = plotx2;
py[0] = p;
py[1] = p;
cpgline(2,px,py);
cpgsls(4);
px[0] = tmin;
px[1] = tmax+(tmax-tmin)*0.03;
py[0]=py[1] =(p)+ploty1+(-miny[p]/(maxy[p]-miny[p]))*(ploty2-ploty1);
// py[0]=py[1] = (p)+ploty1;
// py[0] = py[1] = (0-miny[p])/(maxy[p]-miny[p])/(ploty2-ploty1)+p;
cpgline(2,px,py);
px[0] = plotx1+0.005*(plotx2-plotx1);
py[0] = p;
pye1[0] = p + 5/(ploty2-ploty1);
pye2[0] = p - 5/(ploty2-ploty1);
cpgsls(1);
cpgsch(3);
// cpgerry(1,px,pye1,pye2,1);
cpgsch(1);
for (colour=0;colour<5;colour++)
{
num=0;
for (i=0;i<count[p];i++)
{
if ((colour==0 && psr[p].obsn[i].freq<=500) ||
(colour==1 && psr[p].obsn[i].freq>500 && psr[p].obsn[i].freq<=1000) ||
(colour==2 && psr[p].obsn[i].freq>1000 && psr[p].obsn[i].freq<=1500) ||
(colour==3 && psr[p].obsn[i].freq>1500 && psr[p].obsn[i].freq<=3300) ||
(colour==4 && psr[p].obsn[i].freq>3300))
{
xx[num]=x[p][i];
yy[num]=y[p][i];
yyerr1[num]=yerr1[p][i];
yyerr2[num]=yerr2[p][i];
// printf("plotting: %g\n",yy[num]);
num++;
}
}
cpgsci(colour+1);
cpgsch(ptSize);
cpgpt(num,xx,yy,ptStyle);
if (error==1)
cpgerry(num,xx,yyerr1,yyerr2,1);
cpgsch(fontSize);
// Plot arrow giving one period
fx[0] = fx[1] = tmin-(tmax-tmin)*0.05;
// fy[0] = (p+1)+0.5-(float)(1.0/psr[p].param[param_f].val[0])/2.0/(ploty2-ploty1);
// fy[1] = (p+1)+0.5+(float)(1.0/psr[p].param[param_f].val[0])/2.0/(ploty2-ploty1);
// fy[0] = (-(float)(1.0/psr[p].param[param_f].val[0])/2.0/1.0e6 - miny[p])/(maxy[p]-miny[p])/(ploty2-ploty1) + (p+1)+0.5;
// fy[1] = ((float)(1.0/psr[p].param[param_f].val[0])/2.0/1.0e6 - miny[p])/(maxy[p]-miny[p])/(ploty2-ploty1) + (p+1)+0.5;
fy[0] = (p+1)+0.5+(float)(1.0/psr[p].param[param_f].val[0])/2.0/(maxy[p]-miny[p])*1e6;
fy[1] = (p+1)+0.5-(float)(1.0/psr[p].param[param_f].val[0])/2.0/(maxy[p]-miny[p])*1e6;
if (fy[0] > (p+1)+1) fy[0] = (p+1)+1;
if (fy[1] < (p+1)) fy[1] = (p+1);
// cpgsls(1); cpgline(2,fx,fy); cpgsls(1);
}
cpgsci(1);
}
cpgend();
}
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++){}
}
}
/* set line style */
static void _pgsls (int *i)
{
cpgsls (*i);
}
