void plotsection(SET *p, GRAPHCONTROL *gr, int mode) {
float *x = (mode == LAT) ? p->y : p->x;
float *y = p->d;
int i;
float x1, x2, y1, y2;
/* Check we have data */
if (p->n ==0) {
cpgsvp(0.07, 0.52, 0.07, 0.30);
cpgswin(0.0, 1.0, 0.0, 1.0);
cpgmtxt("T",-3, 0.5, 0.5, "-- Sem Dados -- ");
return;
}
x1 = x2 = x[0];
y1 = y2 = y[0];
for(i=0;i<p->n; i++) {
if (x[i] < x1) x1 = x[i];
if (x[i] > x2) x2 = x[i];
if (y[i] < y1) y1 = y[i];
if (y[i] > y2) y2 = y[i];
}
y2 = (( (int)y2 / 50 ) + 1) * 50.0;
// Plot
cpgsvp(0.07, 0.52, 0.07, 0.30);
cpgswin(x1, x2, y2, 0.0);
cpgbox("BCNST", 0.0, 0, "BCNST", 0.0, 0);
cpgsch(0.7);
cpgmtxt("R", 1.0, 0.0, 0.0, "[L] Trocar Lat/Lon");
cpgmtxt("B", 3.0, 0.5, 0.5, (mode == LAT) ? "Latitude\\m94" : "Longitude\\m94");
cpgmtxt("L", 3.0, 0.5, 0.5, "Profundidade (km)");
(gr->printout) ? cpgsch(1.5) : (p->n > 50) ? cpgsch(FS) : cpgsch(1.0);
cpgbbuf();
for(i = 0; i< p->n; i++) {
if (gr->colormode == COLORDEPTH)
cpgsci(depthcolor(y[i]));
else if (gr->colormode == COLORMAG)
cpgsci(magcolor(p->m[i]));
cpgpt1(x[i], y[i], 1);
}
cpgebuf();
// Terminate
cpgsch(FS);
cpgsci(1);
cpgslw(1);
return;
}
void plot_spectrum(fcomplex * spect, int numspect,
double lor, double dr, double T, double average)
/* Plot a chunk of the Fourier power spectrum normalized by average */
/* The viewing area is left defined with the xvals as _bins_. */
{
int ii;
float *yvals, *xvals, maxy = 0.0;
double offsetr, hir;
char lab[100];
if (lor > 10000) {
offsetr = floor(lor / 1000.0) * 1000.0;
sprintf(lab, "Fourier Frequency - %.0f (bins)", offsetr);
} else {
offsetr = 0.0;
sprintf(lab, "Fourier Frequency (bins)");
}
lor = lor - offsetr;
hir = lor + numspect * dr;
xvals = (float *) malloc(sizeof(float) * numspect);
yvals = (float *) malloc(sizeof(float) * numspect);
for (ii = 0; ii < numspect; ii++) {
xvals[ii] = lor + ii * dr;
yvals[ii] =
(spect[ii].r * spect[ii].r + spect[ii].i * spect[ii].i) / average;
if (yvals[ii] > maxy)
maxy = yvals[ii];
}
maxy *= 1.1;
/* Setup the plot screen for the first set of y's: */
cpgpage();
cpgvstd();
/* Draw the box for the frequency (Hz) axis */
cpgswin((lor + offsetr) / T, (hir + offsetr) / T, 0.0, maxy);
cpgbox("BNST", 0.0, 0, "BCNST", 0.0, 0);
cpgmtxt("B", 2.5, 0.5, 0.5, "Frequency (Hz)");
/* Draw the box for the Fourier frequency (bins) axis */
cpgswin(lor, hir, 0.0, maxy);
cpgbox("CMST", 0.0, 0, "", 0.0, 0);
cpgmtxt("T", 2.0, 0.5, 0.5, lab);
cpgmtxt("L", 2.0, 0.5, 0.5, "Normalized Power");
/* Plot the points */
cpgline(numspect, xvals, yvals);
free(xvals);
free(yvals);
}
void plot_channel_data()
{
int samp=0;
int pg_id;
pg_id = cpgopen("/XSERVE");
cpgpap(8.0, 0.8);
cpgask(0);
cpgpage();
cpgslct(pg_id);
cpgsci(3);
cpgeras();
cpgsvp(0.15f, 0.95f, 0.2f, 0.8f);
cpgupdt();
cpgsch(2.0);
cpgswin(0, read_count, -0.1f, 0.1f);
cpgbox("BC1NST",0.0,0,"BCNST",0.0,0);
cpglab("Time [samples]", "Voltage [volts]", "Antenna Measurement Receiver");
cpgmove(samp, voltarray[0]);
for (samp=2; samp<read_count; samp++)
{
cpgdraw(samp, voltarray[samp]);
}
return 0;
}
void Cpg_Swin(double x1, double x2, double y1, double y2)
/* void cpgswin(float x1, float x2, float y1, float y2); */
{
cpgswin((float)x1, (float)x2, (float)y1, (float)y2);
return;
}
void xyline2lab(int npts, float *x, float *y, float *y2, const char *xlab,
const char *ylab, const char *ylab2, int id)
{
float xmin, xmax, ymin, ymax, ymin2, ymax2;
float overy, over = 0.1;
/* Determine min and max values to plot and scaling: */
find_min_max_arr(npts, x, &xmin, &xmax);
find_min_max_arr(npts, y, &ymin, &ymax);
find_min_max_arr(npts, y2, &ymin2, &ymax2);
overy = over * (ymax - ymin);
ymax += overy;
ymin -= overy;
overy = over * (ymax2 - ymin2);
ymax2 += overy;
ymin2 -= overy;
/* Choose the font: */
cpgscf(2);
/* Setup the plot screen for the first set of y's: */
cpgpage();
cpgvstd();
cpgswin(xmin, xmax, ymin, ymax);
cpgbox("BCNST", 0.0, 0, "BNST", 0.0, 0);
cpgmtxt("B", 3.0, 0.5, 0.5, xlab);
cpgmtxt("L", 2.6, 0.5, 0.5, ylab);
/* Plot the points for the 1st y axis: */
cpgline(npts, x, y);
/* Setup the plot screen for the second set of y's: */
cpgvstd();
cpgswin(xmin, xmax, ymin2, ymax2);
cpgbox("", 0.0, 0, "CMST", 0.0, 0);
cpgmtxt("R", 3.0, 0.5, 0.5, ylab2);
/* Plot the points for the 2nd y axis: */
cpgline(npts, x, y2);
/* Add ID line if required */
if (id == 1)
cpgiden();
}
int plotregion::erase(){
cpgsfs(1);
cpgsci(0);
cpgsvp(0.0,1.0,0.0,1.0);
cpgswin(0.0,1.0,0.0,1.0);
cpgrect(xmin-0.065,xmax,ymin-0.1,ymax+0.025);
cpgsci(1);
return (0);
}
int plotregion::erase(float dx1, float dx2, float dy1, float dy2){
cpgsfs(1);
cpgsci(0);
cpgsvp(0.0,1.0,0.0,1.0);
cpgswin(0.0,1.0,0.0,1.0);
cpgrect(xmin-dx1,xmax+dx2,ymin-dy1,ymax+dy2);
cpgsci(1);
return (0);
}
int enhance(GRAPHCONTROL *c, SET *p, int i) {
float x, y, d, m;
int yr, mo, dy;
char t[1024];
x = p->x[i];
y = p->y[i];
d = p->d[i];
m = p->m[i];
yr = p->yr[i];
mo = p->mo[i];
dy = p->dy[i];
float xhalfwindow = (c->xmax + c->xmin) / 2;
float yhalfwindow = (c->ymax + c->ymin) / 2;
// Mark the dot
cpgsch(FS+0.5);
if(c->colormode == COLORMAG)
cpgsci(magcolor(m));
else if (c->colormode == COLORDEPTH)
cpgsci(depthcolor(d));
else
cpgsci(1);
cpgpt1(x, y, -4);
cpgsci(1);
cpgsch(FS);
// Info box
if (x < xhalfwindow && y < yhalfwindow) {
cpgsvp(0.55, 0.9, 0.7, 0.8);
} else if (x < xhalfwindow && y > yhalfwindow) {
cpgsvp(0.55, 0.9, 0.45, 0.55);
} else if (x > xhalfwindow && y < yhalfwindow) {
cpgsvp(0.12, 0.47, 0.7, 0.8);
} else if (x > xhalfwindow && y > yhalfwindow) {
cpgsvp(0.12, 0.47, 0.45, 0.55);
}
cpgswin(0.0, 1.0, 0.0, 1.0);
cpgsci(1);
cpgrect(0.0, 1.0, 0.0, 1.0);
cpgsci(0);
cpgrect(0.02, .98, 0.02, 0.98);
cpgsci(1);
sprintf(t,"Evento, %d (%04d/%02d/%02d)",i, yr, mo, dy);
cpgmtxt("T", -1.0, 0.1, .0, t);
sprintf(t,"Long. %.2f Lat. %.2f",x,y);
cpgmtxt("T", -2.0, 0.1, .0, t);
sprintf(t,"Prof. %.1f Mag. %.1f",d, m);
cpgmtxt("T", -3.0, 0.1, .0, t);
return -1;
}
// make a single Aitoff sky projection plot
// using the data in ravec[field], decvec[field], and value[filter][field],
// using the min and max data values in valmin[filter] and valmax[filter]
// with filter=0
void plotOne(double nfields, double *value,
double *ravec, double *decvec,
double valmin, double valmax,
char *label, char *title, char *plotName) {
int nf;
double xmin, xmax, ymin, ymax;
// set up the plot
openPlot(plotName);
cpgbbuf();
cpgpap(PLOTSIZE/0.7,0.7);
cpgsvp(0.02,0.98,0.02,0.98);
xmax = M_PI; xmin = -xmax;
ymax = 0.67*M_PI; ymin = -ymax;
ymin -= 0.1*ymax; ymax -= 0.1*ymax;
setupImplot(0.0, 1.0);
cpgswin(xmin,xmax,ymin,ymax);
// make a projected field circle for each field
cpgsch(1.0);
for(nf=0; nf<nfields; nf++) {
projCircle(ravec[nf], decvec[nf], FIELD_RADIUS,
(value[nf]-valmin)/(valmax-valmin));
}
// the grids and galactic exclusion
aitoffGrid();
galaxy(peakL, taperL, taperB);
cpgslw(2);
cpgsch(2.0);
cpgswin(0,1,0,1);
mywedg(0.21, 0.15, 1.0, 12.0, valmin, valmax, label);
cpgptxt(0.5,0.95,0.0,0.5,title);
cpgslw(1);
cpgebuf();
closePlot();
}
int dialog::update(){ // Only draws what has changed
cpgbbuf();
cpgsvp(0.0,1.0,0.0,1.0);
cpgswin(0.0,1.0,0.0,1.0);
for (int i=0;i<nbutton;i++) buttons[i].draw();
for (int i=0;i<nradio;i++) radios[i].draw();
for (int i=0;i<ncheck;i++) checks[i].draw();
for (int i=0;i<nstaticText;i++) staticTexts[i].draw();
cpgebuf();
return(0);
}
int dialog::draw(){
cpgbbuf();
cpgsvp(0.0,1.0,0.0,1.0);
cpgswin(0.0,1.0,0.0,1.0);
for (int i=0;i<nbutton;i++) buttons[i].draw();
for (int i=0;i<nradio;i++) radios[i].draw();
for (int i=0;i<ncheck;i++) checks[i].draw();
for (int i=0;i<nstaticText;i++) staticTexts[i].draw();
cpgebuf();
return(0);
}
void scaledep() {
int i, d;
char t[24];
cpgsci(1);
cpgmtxt("T",1.0,0.0,0.0,"Prof.:");
cpgsvp(0.12, 0.25, 0.912, 0.922);
cpgswin(0.0,700.0, 0.0, 2.0);
cpgsch(0.4);
for(i=1.0;i<700.0;i+=10.0) {
cpgsci(depthcolor((float)i));
cpgpt1(i,1.0,16);
}
cpgsci(1);
d = 0;
cpgsci(depthcolor((float)d));
sprintf(t,"%.1d",d);
cpgtext(d-25.0,2.8,t);
d = 15;
cpgsci(depthcolor((float)d));
sprintf(t,"%.1d",d);
cpgtext(d-35.0,-1.8,t);
d = 35;
cpgsci(depthcolor((float)d));
sprintf(t,"%.1d",d);
cpgtext(d-20.0,2.8,t);
d = 70;
cpgsci(depthcolor((float)d));
sprintf(t,"%.1d",d);
cpgtext(d-25,-1.8,t);
d = 120;
cpgsci(depthcolor((float)d));
sprintf(t,"%.1d",d);
cpgtext(d-50,2.8,t);
d = 300;
cpgsci(depthcolor((float)d));
sprintf(t,"%.1d",d);
cpgtext(d-50,2.8,t);
cpgsch(FS);
cpgsci(1);
return;
}
static void demo2()
{
static int nx = 40, ny = 40;
int i, j, k, lw, ci, ls;
float f[1600], fmin, fmax, alev;
double x, y;
static float tr[6] = {0.0, 1.0, 0.0, 0.0, 0.0, 1.0};
/* Compute a suitable function. A C array is used to emulate
a 2D fortran array f(nx,ny). */
fmin = fmax = 0.0;
for (j=1; j<=ny; j++) {
for (i=1; i<=ny; i++) {
k = (j-1)*nx + (i-1); /* Fortran convention */
x = tr[0] + tr[1]*i + tr[2]*j;
y = tr[3] + tr[4]*i + tr[5]*j;
f[k] = cos(0.3*sqrt(x*2)-0.13333*y)*cos(0.13333*x)+
(x-y)/(double)nx;
if (f[k] < fmin) fmin = f[k];
if (f[k] > fmax) fmax = f[k];
}
}
/* Clear the screen. Set up window and viewport. */
cpgpage();
cpgsvp(0.05, 0.95, 0.05, 0.95);
cpgswin(1.0, (float) nx, 1.0, (float) ny);
cpgbox("bcts", 0.0, 0, "bcts", 0.0, 0);
cpgmtxt("t", 1.0, 0.0, 0.0, "Contouring using cpgcont()");
/* Draw the map. cpgcont is called once for each contour, using
different line attributes to distinguish contour levels. */
cpgbbuf();
for (i=1; i<21; i++) {
alev = fmin + i*(fmax-fmin)/20.0;
lw = (i%5 == 0) ? 3 : 1;
ci = (i < 10) ? 2 : 3;
ls = (i < 10) ? 2 : 1;
cpgslw(lw);
cpgsci(ci);
cpgsls(ls);
cpgcont(f, nx, ny, 1, nx, 1, ny, &alev, -1, tr);
}
cpgslw(1);
cpgsls(1);
cpgsci(1);
cpgebuf();
return;
}
static void plot_rfi(rfi * plotrfi, float top, int numint, int numchan,
float T, float lof, float hif)
{
int ii;
float period, perioderr, dy = 0.035, *temparr;
float tr[6] = { -0.5, 1.0, 0.0, -0.5, 0.0, 1.0 };
char temp[40];
if (plotrfi->freq_avg == 0.0)
period = 0.0;
else
period = 1000.0 / plotrfi->freq_avg;
if (plotrfi->freq_var == 0.0) /* Why are these zero? */
perioderr = 0.0;
else
perioderr = 1000.0 * sqrt(plotrfi->freq_var) /
(plotrfi->freq_avg * plotrfi->freq_avg);
cpgsvp(0.0, 1.0, 0.0, 1.0);
cpgswin(0.0, 1.0, 0.0, 1.0);
cpgnice_output_2(temp, plotrfi->freq_avg, sqrt(plotrfi->freq_var), 0);
cpgptxt(0.03, top - 0.6 * dy, 0.0, 0.0, temp);
cpgnice_output_2(temp, period, perioderr, 0);
cpgptxt(0.12, top - 0.6 * dy, 0.0, 0.0, temp);
sprintf(temp, "%-5.2f", plotrfi->sigma_avg);
cpgptxt(0.21, top - 0.6 * dy, 0.0, 0.0, temp);
sprintf(temp, "%d", plotrfi->numobs);
cpgptxt(0.27, top - 0.6 * dy, 0.0, 0.0, temp);
ii = (numint > numchan) ? numint : numchan;
temparr = gen_fvect(ii);
for (ii = 0; ii < numchan; ii++)
temparr[ii] = GET_BIT(plotrfi->chans, ii);
cpgsvp(0.33, 0.64, top - dy, top);
cpgswin(0.0, numchan, 0.0, 1.0);
cpgimag(temparr, numchan, 1, 1, numchan, 1, 1, 0.0, 1.0, tr);
cpgswin(0.0, numchan, 0.0, 1.0);
cpgbox("BST", 0.0, 0, "BC", 0.0, 0);
cpgswin(lof, hif, 0.0, 1.0);
cpgbox("CST", 0.0, 0, "", 0.0, 0);
for (ii = 0; ii < numint; ii++)
temparr[ii] = GET_BIT(plotrfi->times, ii);
cpgsvp(0.65, 0.96, top - dy, top);
cpgswin(0.0, numint, 0.0, 1.0);
cpgimag(temparr, numint, 1, 1, numint, 1, 1, 0.0, 1.0, tr);
cpgswin(0.0, numint, 0.0, 1.0);
cpgbox("BST", 0.0, 0, "BC", 0.0, 0);
cpgswin(0.0, T, 0.0, 1.0);
cpgbox("CST", 0.0, 0, "", 0.0, 0);
vect_free(temparr);
}
int button::draw(){
cpgsvp(0.0,1.0,0.0,1.0);
cpgswin(0.0,1.0,0.0,1.0);
cpgsfs(2);
float xl, yl;
cpglen(4,label,&xl,&yl);
xmin = x-2.0*0.005;
xmax = x + xl + 2.0 * 0.005;
ymin = y-2.0*0.005;
ymax = y+0.015 + 2.0 * 0.005;
cpgsci(1);
cpgrect(x-0.005, x+xl+0.005, y-0.005, y+0.015 + 0.005);
cpgrect(x-2.0*0.005, x+xl+2.0*0.005, y-2.0*0.005, y+0.015 + 2.0*0.005);
cpgtext(x,y,label);
return(0);
}
static void plot_harmonics(double rr, int zoomlevel, fftpart * fp)
{
int ii, hh;
double offsetf;
char label[20];
fftview *harmview;
cpgsubp(4, 4);
for (ii = 0, hh = 2; ii < 8; ii++, hh++) {
cpgpanl(ii % 4 + 1, ii / 4 + 1);
harmview = get_harmonic(hh * rr, zoomlevel, fp);
if (harmview != NULL) {
offsetf = plot_fftview(harmview, 0.0, 2.0, hh * rr, 2);
snprintf(label, 20, "Harmonic %d", hh);
cpgsave();
cpgsch(2.0);
cpgmtxt("T", -1.8, 0.05, 0.0, label);
cpgunsa();
free(harmview);
}
}
for (ii = 8, hh = 2; ii < 16; ii++, hh++) {
cpgpanl(ii % 4 + 1, ii / 4 + 1);
harmview = get_harmonic(rr / (double) hh, zoomlevel, fp);
if (harmview != NULL) {
offsetf = plot_fftview(harmview, 0.0, 2.0, rr / (double) hh, 2);
snprintf(label, 20, "Harmonic 1/%d", hh);
cpgsave();
cpgsch(2.0);
cpgmtxt("T", -1.8, 0.05, 0.0, label);
cpgunsa();
free(harmview);
}
}
cpgsubp(1, 1);
cpgpanl(1, 1);
cpgsvp(0.0, 1.0, 0.0, 1.0);
cpgswin(2.0, 6.0, -2.0, 2.0);
cpgmove(2.0, 0.0);
cpgslw(3);
cpgdraw(6.0, 0.0);
cpgslw(1);
}
void scalemag() {
int i;
char t[24];
cpgsci(1);
cpgmtxt("T",1.0,0.0,0.0,"Mag.:");
cpgsvp(0.12, 0.25, 0.912, 0.922);
cpgswin(0.0, 11.0, 0.0, 2.0);
cpgsch(0.4);
for(i=0.0;i<10.0;i++) {
cpgsci(magcolor((float)i));
sprintf(t,"%.1d",i);
cpgtext(i+1-0.12,2.8,t);
cpgpt1(i+1,1.0,16);
}
cpgsch(FS);
cpgsci(1);
return;
}
int plot_freq_data(void)
{
int bin=0;
printf("\nPlotting ...");
cpgask(0);
cpgpage();
cpgslct(pg_id);
cpgsci(1);
cpgeras();
cpgsvp(0.15f, 0.95f, 0.2f, 0.8f);
cpgupdt();
cpgsch(2.0);
cpgswin(0, (N/2)+1, 0.0f, 0.005f);
// cpgswin(80, 120, 0.0f, 0.01f);
cpgbox("BC1NST",0.0,0,"BCNST",0.0,0);
cpglab("Frequency [bins]", "Peak Voltage [volts]", "Antenna Measurement Receiver");
cpgmove(bin, accumFreqData[0]);
for (bin=1; bin<(N/2)+1; bin++)
{
cpgdraw(bin, accumFreqData[bin]);
}
return 0;
}
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()
{
float RES = (XMAX - XMIN)/N; //resolution
int i,j,p;
//************************* PGPLOT CODE ***************************
cpgbeg(0,"?",1,1);
cpgpage();
cpgsci(1); // axis color
cpgpap(0,1);
//axis limits
cpgswin(XMIN,XMAX,YMIN,YMAX);
cpgbox("BCN",1, 0, "BCN", 1, 0); // draw the axes
cpgsci(1); //data color
cpgsch(0.00000000000001); //data point size
//******************* GRID ALGORITHM AND PLOTTING ********************
struct cnum z; // z = (0,0) = initial number
struct cnum c; // c is a complex variable
z.cx = 0;
z.cy = 0;
for(i=0;i<N;i++) //look at every point on grid
{
for(j=0;j<N;j++)
{
c.cx = XMIN + i*RES; //assign c = current point
c.cy = YMIN + j*RES;
CPRINT(c);
for(p=0;p<MNI;p++) //apply MNI iterations to z
{ //using c = current point
z = FMANDEL(z,c);
if ( z.cx*z.cx + z.cy*z.cy > R) // if iteration "blows up"...
{
z.cx = 0;
z.cy = 0; //stay at z=c=0
c.cx = 0;
c.cy = 0;
}
} //end of interation. z = final number
if (z.cx*z.cx + z.cy*z.cy < R) //if iteration hasn't blown up...
{
float X[1], Y[1];
X[0] = c.cx;
Y[0] = c.cy;
cpgpt(1,X,Y,17); // plot point c
}
}
}
printf("\n\n");
cpgend();
}
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);
}
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;
}
/*
* Class: pulsarhunter_PgplotInterface
* Method: pgswin
* Signature: (FFFF)V
*/
JNIEXPORT void JNICALL Java_pulsarhunter_PgplotInterface_pgswin
(JNIEnv *env, jclass cl, jfloat xleft, jfloat xright, jfloat ybot, jfloat ytop){
cpgswin(xleft,xright,ybot,ytop);
}
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];
}
}
// make six Aitoff sky projection plots
// using the data in ravec[field], decvec[field], and value[filter][field],
// using the min and max data values in valmin[filter] and valmax[filter]
// with filter=0 to NFILTERS-1
void plotSix(double nfields, double **value,
double *ravec, double *decvec,
double *valmin, double *valmax,
int horizontal,
char *label, char *title, char* plotName, int mask) {
char str[1024];
int filt, nf;
double xmin, xmax, ymin, ymax;
openPlot(plotName);
cpgbbuf();
if(horizontal==1)
cpgpap(PLOTSIZE/0.5,0.5); else cpgpap(PLOTSIZE/1.0,1.0);
cpgsvp(0.02,0.98,0.15,0.95);
xmax = 0.9*(M_PI);
xmin = -xmax;
ymax = 0.9*(0.6*M_PI);
ymin = -ymax;
ymin -= 0.18*ymax;
ymax -= 0.18*ymax;
setupImplot(0.0, 1.0);
if(horizontal==1)
cpgsubp(3,2);
else
cpgsubp(2,3);
cpgsch(3.0);
cpgslw(2);
for(filt=0; filt<NFILTERS; filt++) {
int thereisdata = 0;
for(nf=0; nf<nfields; nf++) {
if (value[filt][nf] != 0.0) {
thereisdata = 1;
}
}
if ( thereisdata ) {
if(horizontal==1)
cpgpanl(hpanelx[filt],hpanely[filt]);
else
cpgpanl(vpanelx[filt],vpanely[filt]);
cpgswin(xmin,xmax,ymin,ymax);
for(nf=0; nf<nfields; nf++) {
if ( mask == 0 ) {
if(value[filt][nf] > 0.0)
projCircle(ravec[nf], decvec[nf], FIELD_RADIUS, (value[filt][nf]-valmin[filt])/(valmax[filt]-valmin[filt]));
} else if ( mask == 1) {
if(value[filt][nf] != 0.0)
projCircle(ravec[nf], decvec[nf], FIELD_RADIUS, (value[filt][nf]-valmin[filt])/(valmax[filt]-valmin[filt]));
}
}
aitoffGrid();
galaxy(peakL, taperL, taperB);
sprintf(str,"%s: %s", label, filtername[filt]);
if(valmax[filt]>valmin[filt])
mywedg(0.2, 0.15, 1.0, 8.0, valmin[filt], valmax[filt], str);
}
}
cpgsch(1.0);
cpgsubp(1,1);
cpgswin(0,1,0,1);
cpgptxt(0.5,1.02,0.0,0.5,title);
cpgslw(1);
cpgebuf();
closePlot();
}
void multi_prof_plot(int proflen, int numprofs, double *profiles,
double *sumprof, const char *xlbl,
double loly, double ldy, const char *lylbl,
double lory, double rdy, const char *rylbl)
{
float *x, *y, yoffset, ynorm;
float lox = 0.0, hix = 1.0, ddx = 0.01;
double ymin = 0.0, ymax = 0.0;
int i, j, index;
x = gen_fvect(proflen + 1);
y = gen_fvect(proflen + 1);
for (i = 0; i <= proflen; i++)
x[i] = (float) i / (float) proflen;
/* The multiplots... */
/* Define the Viewport */
cpgsvp(0.1, 0.85, 0.2, 0.9);
/* Define the Window */
cpgswin(lox - ddx, hix + ddx, (float) (loly - ldy),
(float) (loly + numprofs * ldy));
/* Define the left border */
cpgbox("CST", 0.2, 2, "BNST", 0.0, 0);
/* Write the left-hand label */
cpgmtxt("L", 2.6, 0.5, 0.5, lylbl);
/* Re-Define the Window */
cpgswin(lox - ddx, hix + ddx, (float) (lory - rdy),
(float) (lory + numprofs * rdy));
/* Define the right border */
cpgbox("", 0.2, 2, "CMST", 0.0, 0);
/* Write the right-hand label */
cpgmtxt("R", 3.0, 0.5, 0.5, rylbl);
/* Plot the individual channel profiles */
for (i = 0; i < numprofs; i++) {
/* Determine min and max values to plot */
index = i * proflen;
yoffset = lory + i * rdy;
dfind_min_max_arr(proflen, profiles + index, &ymin, &ymax);
ynorm = 0.9 * rdy / (ymax - ymin);
for (j = 0; j < proflen; j++)
y[j] = (profiles[index + j] - ymin) * ynorm + yoffset;
y[proflen] = y[0];
cpgbin(proflen + 1, x, y, 1);
}
/* The summed plot... */
/* Define the Viewport */
cpgsvp(0.1, 0.85, 0.1, 0.2);
/* Define the Window */
cpgswin(lox - ddx, hix + ddx, -0.1, 1.0);
/* Define the border */
cpgbox("BNST", 0.2, 2, "BC", 0.0, 0);
/* Write the bottom label */
cpgmtxt("B", 3.0, 0.5, 0.5, xlbl);
/* Determine min and max values to plot */
dfind_min_max_arr(proflen, sumprof, &ymin, &ymax);
ynorm = 0.9 / (ymax - ymin);
for (j = 0; j < proflen; j++)
y[j] = (sumprof[j] - ymin) * ynorm;
y[proflen] = y[0];
/* Plot the summed profile */
cpgbin(proflen + 1, x, y, 1);
/* Cleanup */
vect_free(x);
vect_free(y);
}
// Sets the plot back to last coordinates
int plotregion::reset(){
cpgsvp(xmin,xmax,ymin,ymax);
cpgswin(xminworld,xmaxworld,yminworld,ymaxworld);
return(0);
}
// Sets the plot coordinates
int plotregion::set(float xmn, float xmx, float ymn, float ymx){
xminworld = xmn; yminworld = ymn; xmaxworld = xmx; ymaxworld = ymx;
cpgsvp(xmin,xmax,ymin,ymax);
cpgswin(xmn,xmx,ymn,ymx);
return(0);
}
// 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;
}
int dialog::manage(float * x, float * y, char * ans, int * plotno){
int leave;
int button = 0;
*plotno = -1;
*ans = ' ';
static float lastx, lasty;
*x=lastx;
*y=lasty;
leave = 0;
while (!leave){
// get a keypress
cpgsvp(0.0,1.0,0.0,1.0);
cpgswin(0.0,1.0,0.0,1.0);
cpgcurs(x,y,ans);
lastx=*x;
lasty=*y;
button = -1;
// First of all, check if it is inside a plot
for (int i=0;i<nplotregion;i++){
if (plotregions[i].inside(x,y)){
button = -1;
*plotno = i;
leave = 1;
}
}
// Then check if it is inside a button
for (int i=0;i<nbutton;i++){
buttons[i].pressed = 0;
if (buttons[i].inside(*x,*y)){
button = i;
buttons[i].pressed = 1;
leave = 1;
}
}
// Then radio controls
for (int i=0;i<nradio;i++){
if (radios[i].inside(*x,*y)){
// zero all in the group
for (int j=0;j<nradio;j++)
if (radios[j].groupid==radios[i].groupid) {
radios[j].on=0;
radios[j].draw();
}
// draw this one
radios[i].on=1;
radios[i].draw();
leave = 0;
}
}
// Then check boxes controls
for (int i=0;i<ncheck;i++){
if (checks[i].inside(*x,*y)){
checks[i].toggle();
checks[i].draw();
leave=0;
}
}
// else stay in loop unless q pressed.
}
return(button);
}
