void plot(g_ctl * ctl, float *y, int npts, float delta, float b,
int overlay, int color, float zoom)
{
float *x = NULL;
int i;
int oldcolor;
cpgqci(&oldcolor);
x = malloc(sizeof(float) * npts);
for (i = 0; i < npts; i++)
x[i] = i * delta + b;
if (!overlay) {
ctl_yupdate_ndb(ctl, y, npts, delta, b);
ctl->ymin /= zoom;
ctl->ymax /= zoom;
ctl->h = ctl->ymax - ctl->ymin;
ctl_resizeview(ctl);
ctl_drawaxis(ctl);
}
cpgsci(color);
cpgline(npts, x, y);
cpgsci(oldcolor);
x = io_freeData(x);
}
int staticText::draw(){
cpgsci(ci); cpgsch(size);
cpgptxt(x,y,orientation,0.0,label);
cpgsci(1);
cpgsch(1.0);
return (0);
}
int plot_fit_curve(float *a, int ncoeff, float tmin, float tmax)
{
int i,j; /* Looping variables */
int nstep=500; /* Number of steps used to compute curve */
float xtmp,ytmp; /* Values of x,y used in constructing the curve */
float *polyx=NULL; /* Polynomial in x */
cpgsci(2);
cpgslw(5);
/*
* Allocate memory for container for polynomial values
*/
if(!(polyx = new_array(ncoeff,1))) {
fprintf(stderr,"ERROR: plot_fit_curve\n");
return 1;
}
/*
* Loop through range of x values in step sizes determined by nstep.
* At each value of x, compute the value of y by first calling poly
* to compute the values of the various powers of x at that step, and
* then multiplying by the coefficients contained in a.
*/
for(i=0; i<nstep; i++) {
/*
* Compute the values of x and y at this step
*/
xtmp = tmin + i*(tmax - tmin)/(1.0 * nstep);
sinpoly(xtmp,polyx-1,ncoeff);
ytmp = 0;
for(j=0; j<ncoeff; j++)
ytmp += a[j] * polyx[j];
/*
* Now connect this point to the previous one with a cpgdraw call
*/
if(i == 0)
cpgmove(xtmp,ytmp);
else
cpgdraw(xtmp,ytmp);
}
/*
* Clean up and exit
*/
cpgslw(1);
cpgsci(1);
polyx = del_array(polyx);
return 0;
}
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);
}
void markcatobj(Secat object)
{
cpgsci(2);
cpgsfs(2);
cpgslw(3);
cpgcirc(object.x,object.y,3.0*object.fwhm);
cpgsci(1);
cpgslw(1);
}
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;
}
static void demo3()
{
#define TWOPI (2.0*3.14159265)
#define NPOL 6
int i, j, k;
int n1[] = {3, 4, 5, 5, 6, 8};
int n2[] = {1, 1, 1, 2, 1, 3};
float x[10], y[10], y0;
char* lab[] = {"Fill style 1 (solid)",
"Fill style 2 (outline)",
"Fill style 3 (hatched)",
"Fill style 4 (cross-hatched)"};
/* Initialize the viewport and window. */
cpgbbuf();
cpgsave();
cpgpage();
cpgsvp(0.0, 1.0, 0.0, 1.0);
cpgwnad(0.0, 10.0, 0.0, 10.0);
/* Label the graph. */
cpgsci(1);
cpgmtxt("T", -2.0, 0.5, 0.5,
"PGPLOT fill area: routines cpgpoly(), cpgcirc(), cpgrect()");
/* Draw assorted polygons. */
for (k=1; k<5; k++) {
cpgsci(1);
y0 = 10.0 -2.0*k;
cpgtext(0.2, y0+0.6, lab[k-1]);
cpgsfs(k);
for (i=0; i<NPOL; i++) {
cpgsci(i+1);
for (j=0; j<n1[i]; j++) {
x[j] = i+1 + 0.5*cos(n2[i]*TWOPI*j/n1[i]);
y[j] = y0 + 0.5*sin(n2[i]*TWOPI*j/n1[i]);
}
cpgpoly(n1[i], x, y);
}
cpgsci(7);
cpgshs(0.0, 1.0, 0.0);
cpgcirc(7.0, y0, 0.5);
cpgsci(8);
cpgshs(-45.0, 1.0, 0.0);
cpgrect(7.8, 9.5, y0-0.5, y0+0.5);
}
cpgunsa();
cpgebuf();
return;
}
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;
}
void fillcircle(float x, float y, int ci){
float xpts[40], ypts[40];
for (int i=0;i<40;i++){
xpts[i]=x+0.01*cos(2.0*M_PI*i/40);
ypts[i]=y+0.01*sin(2.0*M_PI*i/40);
}
cpgsfs(1);
cpgsci(ci);
cpgpoly(40,xpts,ypts);
cpgsfs(2);
cpgsci(1);
cpgpoly(40,xpts,ypts);
}
void mark(g_ctl * ctl, float x, char *c, int color)
{
int oldcolor;
cpgqci(&oldcolor);
cpgsci(color);
cpgmove(x, ctl->ymin + ctl->h * 0.05);
cpgdraw(x, ctl->ymax - ctl->h * 0.05);
cpgptxt(x, ctl->ymin + ctl->h * 0.1, 0.0, -0.05, c);
cpgsci(oldcolor);
}
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 aitoffGrid(void) {
int i,j;
double phi[MM], lam[MM], x[MM], y[MM];
double rr, dd;
cpgsci(DARKGRAY);
cpgslw(1);
for(i=0; i<MM; i++) phi[i] = i*M_PI/(double)(MM-1) - M_PI/2.0;
// make meridians for each ra in (-180,180)
for(i=0; i<NM; i++) {
rr = i*2.0*M_PI/(double)(NM-1) - M_PI;
// steps in dec on (-90,90)
for(j=0; j<MM; j++) {
project(rr,phi[j],&x[j],&y[j]);
}
for(j=1; j<MM; j++) {
cpgmove(x[j-1],y[j-1]);
cpgdraw(x[j],y[j]);
}
}
// make parallels
// steps in dec on (-90,90)
for(i=0; i<MM; i++) phi[i] *= 2.0;
for(i=0; i<NP; i++) {
dd = i*M_PI/(double)(NP-1) - M_PI/2.0;
// steps in RA from (-180,180)
for(j=0; j<MM; j++) {
project(phi[j],dd,&x[j],&y[j]);
}
for(j=1; j<MM; j++) {
cpgmove(x[j-1],y[j-1]);
cpgdraw(x[j],y[j]);
}
}
cpgsci(1);
cpgslw(1);
}
void Plotter2::resetAttributes(const Plotter2ViewportInfo& vi) {
cpgstbg(0); // reset background colour to the initial one (white)
cpgsci(1); // reset foreground colour to the initial one (black)
cpgsls(1); // reset line style to solid
cpgslw(1); // reset line width to 1
cpgscf(1); // reset font style to normal
cpgsch(vi.fontSizeDef);// reset font size
cpgsfs(1); // reset fill style (solid)
}
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 check::draw(){
if (on) {
cpgsci(2);
cpgsfs(1);
cpgrect(xmin,xmax,ymin,ymax);
cpgsci(1);
cpgsfs(2);
cpgrect(xmin,xmax,ymin,ymax);
}
else{
cpgsci(0);
cpgsfs(1);
cpgrect(xmin,xmax,ymin,ymax);
cpgsci(1);
cpgsfs(2);
cpgrect(xmin,xmax,ymin,ymax);
}
cpgtext(x+0.05,y,label);
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;
}
void plot_image(struct image img,struct transformation t,struct catalog c,char *filename,float mmin)
{
int i;
float tr[]={-0.5,1.0,0.0,-0.5,0.0,1.0};
float heat_l[]={0.0,0.2,0.4,0.6,1.0};
float heat_r[]={0.0,0.5,1.0,1.0,1.0};
float heat_g[]={0.0,0.0,0.5,1.0,1.0};
float heat_b[]={0.0,0.0,0.0,0.3,1.0};
float zmin,zmax,zavg,zstd;
for (i=0,zavg=0.0;i<img.naxis1*img.naxis2;i++)
zavg+=img.zavg[i];
zavg/=(float) img.naxis1*img.naxis2;
for (i=0,zstd=0.0;i<img.naxis1*img.naxis2;i++)
zstd+=pow(img.zavg[i]-zavg,2);
zstd=sqrt(zstd/(float) (img.naxis1*img.naxis2));
zmin=zavg-2*zstd;
zmax=zavg+6*zstd;
cpgopen("1/xs");
cpgwnad(0.0,img.naxis1,0.0,img.naxis2);
cpgctab (heat_l,heat_r,heat_g,heat_b,5,1.0,0.5);
cpgimag(img.zavg,img.naxis1,img.naxis2,1,img.naxis1,1,img.naxis2,zmin,zmax,tr);
cpgbox("BCTSNI",0.,0,"BCTSNI",0.,0);
cpgsci(3);
plot_pixel_catalog(filename);
cpgsci(4);
plot_astrometric_catalog(t,img,mmin);
cpgsci(2);
for (i=0;i<c.n;i++)
cpgpt1(c.x[i]+t.x0,c.y[i]+t.y0,24);
cpgend();
return;
}
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);
}
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;
}
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();
}
int plot(float ***u, const int nx, const int ny) {
#ifdef PGPLOT
const int ng=2;
double xl, xr, yl, yr, dx, dy;
float denscontours[NCONTOURS], prescontours[NCONTOURS];
float *dens, *pres;
double maxd=-1e19, mind=+1e-19;
double maxp=-1e19, minp=+1e-19;
static int called = 0;
int i, j, count;
float tr[6] = {0.,0.,0.,0.,0.,0.};
xl = 0.; xr = nx-2*ng-1;
yl = 0.; yr = ny-2*ng-1;
dx = 1.; dy = 1.;
dens = (float *)malloc((nx-2*ng)*(ny-2*ng)*sizeof(float));
pres = (float *)malloc((nx-2*ng)*(ny-2*ng)*sizeof(float));
count = 0;
for (j=ny-ng; j>ng; j--) {
for (i=ng; i<nx-ng; i++) {
dens[count] = u[j][i][IDENS];
float vx = u[j][i][IMOMX]/dens[count];
float vy = u[j][i][IMOMY]/dens[count];
pres[count] = (u[j][i][IENER] - 0.5*(vx*vx+vy*vy)*dens[count]);
if (dens[count] > maxd) maxd = dens[count];
if (dens[count] < mind) mind = dens[count];
if (pres[count] > maxp) maxp = pres[count];
if (pres[count] < minp) minp = pres[count];
count++;
}
}
tr[0] = xl; tr[3] = yl;
tr[1] = dx; tr[5] = dy;
for (i=0; i<NCONTOURS; i++) {
denscontours[i] = mind + (i+1)*(maxd-mind)/(NCONTOURS+1);
prescontours[i] = minp + (i+1)*(maxp-minp)/(NCONTOURS+1);
}
if (!called) {
cpgbeg(0, "/XWINDOW", 1, 1);
called = 1;
cpgask(0);
}
cpgenv(xl, xr, yl, yr, 1, 1);
cpgsci(2);
cpgcont(dens, nx-2*ng, ny-2*ng, 1, nx-2*ng, 1, ny-2*ng, denscontours, NCONTOURS, tr);
if (minp != maxp) {
cpgsci(3);
cpgcont(pres, nx-2*ng, ny-2*ng, 1, nx-2*ng, 1, ny-2*ng, prescontours, NCONTOURS, tr);
}
cpgsci(1);
free(dens); free(pres);
#endif
return 0;
}
// Process dedispersion output
void* process_output(void* output_params)
{
OUTPUT_PARAMS* params = (OUTPUT_PARAMS *) output_params;
OBSERVATION *obs = params -> obs;
int i, iters = 0, ret, loop_counter = 0, pnsamp = params -> obs -> nsamp;
int ppnsamp = params -> obs-> nsamp;
time_t start = params -> start, beg_read;
double pptimestamp = 0, ptimestamp = 0;
double ppblockRate = 0, pblockRate = 0;
// Initialise pg plotter
#if PLOT
if(cpgbeg(0, "/xwin", 1, 1) != 1)
printf("Couldn't initialise PGPLOT\n");
cpgask(false);
#endif
printf("%d: Started output thread\n", (int) (time(NULL) - start));
FILE *fp = fopen("chanOutput.dat", "wb");
// Processing loop
while (1) {
// Wait input barrier
ret = pthread_barrier_wait(params -> input_barrier);
if (!(ret == 0 || ret == PTHREAD_BARRIER_SERIAL_THREAD))
{ fprintf(stderr, "Error during input barrier synchronisation [output]\n"); exit(0); }
// Process output
if (loop_counter >= params -> iterations)
{
unsigned nsamp = ppnsamp, nchans = obs -> nchans;
double timestamp = pptimestamp, blockRate = ppblockRate;
beg_read = time(NULL);
#if PLOT
if (!obs -> folding)
{
// Process and plot output
unsigned startChan = 0, endChan = startChan + 32, decFactor = 512;
// unsigned startChan = 0, endChan = startChan + 32, decFactor = 4;
float xr[nsamp / decFactor], yr[endChan - startChan][nsamp / decFactor];
float ymin = 9e12, ymax=9e-12;
for (unsigned c = 0; c < endChan - startChan; c++)
{
// Decimate before plotting
for (unsigned i = 0; i < nsamp / decFactor; i++)
{
unsigned index = (startChan + c) * nsamp + i * decFactor;
xr[i] = i;
yr[c][i] = 0;
for (unsigned j = 0; j < decFactor; j++)
yr[c][i] += params -> host_odata[index+j].x *
params -> host_odata[index+j].x +
params -> host_odata[index+j].y *
params -> host_odata[index+j].y;
// yr[c][i] = (yr[c][i] / decFactor) + c * 1e5;
yr[c][i] = (yr[c][i] / decFactor) + c * 4;
if (ymax < yr[c][i]) ymax = yr[c][i];
if (ymin > yr[c][i]) ymin = yr[c][i];
}
}
unsigned plotChan = 1;
float *chan = (float *) malloc(nsamp * sizeof(float));
for (unsigned i = 0; i < nsamp; i++)
chan[i] = params -> host_odata[plotChan * nsamp + i].x *
params -> host_odata[plotChan * nsamp + i].x +
params -> host_odata[plotChan * nsamp + i].y *
params -> host_odata[plotChan * nsamp + i].y;
fwrite(chan, sizeof(float), nsamp, fp);
fflush(fp);
free(chan);
cpgenv(0.0, pnsamp / decFactor, ymin, ymax, 0, 1);
cpgsci(7);
for (unsigned i = 0; i < endChan - startChan; i++)
cpgline(nsamp / decFactor, xr, yr[i]);
cpgmtxt("T", 2.0, 0.0, 0.0, "Dedispersed Channel Plot");
}
else
{
unsigned plotChannel = 15;
unsigned decFactor = 256;
float *xr = (float *) malloc(obs -> profile_bins / decFactor * sizeof(float));
float *yr = (float *) malloc(obs -> profile_bins / decFactor * sizeof(float));
float ymin = 9e12, ymax = 9e-12;
unsigned fullProfiles = obs -> nsamp * (loop_counter - 1) /
obs -> profile_bins;
unsigned leftover = (obs -> nsamp * (loop_counter - 1)) % obs -> profile_bins;
if (fullProfiles > 0)
{
// Decimate before plotting
for (unsigned i = 0; i < obs -> profile_bins / decFactor; i++)
{
unsigned index = plotChannel * obs -> profile_bins + i * decFactor;
xr[i] = i;
yr[i] = 0;
for (unsigned j = 0; j < decFactor; j++)
yr[i] += params -> host_profile[index + j];
yr[i] = (yr[i] / decFactor);
yr[i] = (i < leftover / decFactor)
? yr[i] / (fullProfiles + 1)
: yr[i] / fullProfiles;
if (ymax < yr[i]) ymax = yr[i];
if (ymin > yr[i]) ymin = yr[i];
}
cpgenv(0.0, obs -> profile_bins / decFactor, ymin, ymax, 0, 1);
cpgsci(7);
cpgline(obs -> profile_bins / decFactor, xr, yr);
cpgmtxt("T", 2.0, 0.0, 0.0, "Pulsar Profile");
free(xr);
free(yr);
}
}
#endif
printf("%d: Processed output %d [output]: %d\n", (int) (time(NULL) - start), loop_counter,
(int) (time(NULL) - beg_read));
}
sleep(2);
// Wait output barrier
ret = pthread_barrier_wait(params -> output_barrier);
if (!(ret == 0 || ret == PTHREAD_BARRIER_SERIAL_THREAD))
{ fprintf(stderr, "Error during output barrier synchronisation [output]\n"); exit(0); }
// Acquire rw lock
if (pthread_rwlock_rdlock(params -> rw_lock))
{ fprintf(stderr, "Unable to acquire rw_lock [output]\n"); exit(0); }
// Update params
ppnsamp = pnsamp;
pnsamp = params -> obs -> nsamp;
pptimestamp = ptimestamp;
ptimestamp = params -> obs -> timestamp;
ppblockRate = pblockRate;
pblockRate = params -> obs -> blockRate;
// Stopping clause
if (((OUTPUT_PARAMS *) output_params) -> stop) {
if (iters >= params -> iterations - 1) {
// Release rw_lock
if (pthread_rwlock_unlock(params -> rw_lock))
{ fprintf(stderr, "Error releasing rw_lock [output]\n"); exit(0); }
for(i = 0; i < params -> maxiters - params -> iterations; i++) {
pthread_barrier_wait(params -> input_barrier);
pthread_barrier_wait(params -> output_barrier);
}
break;
}
else
iters++;
}
// Release rw_lock
if (pthread_rwlock_unlock(params -> rw_lock))
{ fprintf(stderr, "Error releasing rw_lock [output]\n"); exit(0); }
loop_counter++;
}
printf("%d: Exited gracefully [output]\n", (int) (time(NULL) - start));
pthread_exit((void*) output_params);
}
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;
}
int main (int argc, char *argv[])
{
int ntimglobal=0; // number of time samples in original
int ngulp_original=0; // number of time samples to look at at once
int nskipstart=0; // number skipped at start
int nrejects; //ZAPPER
int zapswitch = 0; //ZAPPER
double tsamp_orig=0;
//gsearch setup & defaults
float Gsigmacut=6.0;
float delta, tstart;
vector<Gpulse> * Giant = new vector<Gpulse>[MAXFILES];
bool Gsearched=false;
int i,ntim,headersize[MAXFILES],noff=0,gulp;
float *time_series[MAXFILES],sum=0.0,sumsq=0.0,mean,meansq,sigma;
int MAXMARKERS = 1024;
int nfiles = 0;
FILE *inputfile[MAXFILES];
char filename[MAXFILES][256];
int spectra=0;
int powerspectra=0;
double dmoffirstfile;
char *killfile;
bool dokill=false;
bool ssigned=true;
bool fsigned=false;
int topfold=-1;
int topgiant=-1;
int toppeak=-1; //?!? sarah added this
bool askdevice=false;
char devicename[200];
if (argc<2 || help_required(argv[1])) {
helpmenu();
// fprintf(stderr,"Usage: giant filenames\n\t(e.g.>> giant *.tim)\n\n\t-s N\tskip N samples\n\t-n N\tread N samples\n\t-S read spectra instead of amplitudes\n-i interpret signed chars as unsigned\n\t-z make a zap list of bad time samples\n");
exit(0);
}
print_version(argv[0],argv[1]);
i=1;
while (i<argc) {
if (file_exists(argv[i])) {
inputfile[nfiles]=open_file(argv[i],"r");
strcpy(filename[nfiles],argv[i]);
nfiles++;
}
if (strings_equal(argv[i],"-s")) sscanf(argv[++i],"%d",&nskipstart);
if (strings_equal(argv[i],"-S")) spectra=1;
if (strings_equal(argv[i],"-i")) ssigned=false;
if (strings_equal(argv[i],"-f")) fsigned=true;
if (strings_equal(argv[i],"-n")) sscanf(argv[++i],"%d",&ngulp_original);
if (strings_equal(argv[i],"-c")) sscanf(argv[++i],"%f",&Gsigmacut);
if (strings_equal(argv[i],"-z")) zapswitch=1;
if (strings_equal(argv[i],"-g")) {askdevice=true;sscanf(argv[++i],"%s",&devicename);}
if (strings_equal(argv[i],"-k")) {killfile=(char*)malloc(strlen(argv[++i])+1); strcpy(killfile,argv[i]);dokill=true;}
if (nfiles>MAXFILES) error_message("too many open files");
i++;
}
int ntimglobal_smallest=0, nsamp;
for (i=0; i<nfiles; i++) {
if (spectra){
int npf;
double rate;
time_series[i]=Creadspec(filename[i],&npf,&rate);
tsamp = 1.0/(rate);
//normalise(npf,time_series[i]);
nsamp = ntimglobal = ntimglobal_smallest = npf;
}
else
{
if ((headersize[i]=read_header(inputfile[i]))) {
if (! fsigned){
if (isign > 0) {
ssigned=false;
fprintf(stderr,"using signed header variable to set UNSIGNED\n");
}
if (isign < 0) {
ssigned=true;
fprintf(stderr,"using signed header variable to set SIGNED\n");
}
}
if (i==0) dmoffirstfile = refdm;
if (nbits!=8 && nbits!=32)
error_message("giant currently only works for 8- or 32-bit data");
nsamp = nsamples(filename[i],headersize[i],nbits,nifs,nchans);
if (i == 0) {
ntimglobal_smallest=nsamp;
} else {
ntimglobal= nsamp;
if (ntimglobal < ntimglobal_smallest) ntimglobal_smallest = ntimglobal;
}
// Space for data (time_series)
time_series[i]=(float *) malloc((nsamp+2)*sizeof(float));
if (time_series[i]==NULL){
fprintf(stderr,"Error mallocing %d floats of %d size\n",nsamp,
sizeof(float));
exit(-1);
}
tsamp_orig = tsamp;
// Skip data
fprintf(stderr,"Skipping %d bytes\n",nskipstart*nbits/8);
fseek(inputfile[i],nskipstart*nbits/8,SEEK_CUR);
} // each file
} // spectra or not
} // for (i...)
puti(ntimglobal_smallest);
if (ngulp_original==0) ngulp_original=ntimglobal_smallest;
// ****** SAM'S ZAP SWITCH ******
// Sam Bates 2009
// Integrated into new giant by SBS
// Switch to make a .killtchan file for time samples > 3.5 sigma
// SARAHZAP tag means addition was added later by Sarah
// ******************************
int ngulp=ngulp_original;
// int nrejects_max=ngulp_original/100;
int * mown = new int[ngulp_original];
int nstart=0;
if (zapswitch){
float dummy;
int NActuallyRead;
char *buffer;
buffer = new char[ngulp*nbits/8];
for (i=0; i<nfiles; i++){
NActuallyRead = fread(buffer,nbits/8,ngulp,inputfile[i]);
if (nbits==32){
memcpy(time_series[i],buffer,sizeof(float)*ngulp);
} else {
for (int j=0;j<NActuallyRead;j++){
if (ssigned) time_series[i][j]=(float)buffer[j];
if (!ssigned) time_series[i][j]=(float)((unsigned char)buffer[j]);
}
}
puti(ngulp);
find_baseline(ngulp,time_series[i],10.0/tsamp,5.0);
mowlawn(ngulp,time_series[i],5,256);
}
printf("%f\n",dummy);
printf("Bad time samples found...\n");
exit(0);
}
int pgpID;
if (askdevice){
pgpID = cpgbeg(0,devicename,1,1);
} else {
pgpID = cpgbeg(0,"/xs",1,1);
}
cpgsch(0.5);
cpgtext(0.6,0.0,"Press 'h' over the main window for help and full options list.");
cpgsch(1.0);
/* create the dialog */
dialog * d = new dialog();
/* add the "action" buttons */
int QUIT = d->addbutton(0.02,0.95,"Quit");
int POWER = d->addbutton(0.07,0.85,"POWER");
int SMHRM = d->addbutton(0.075,0.80,"SMHRM");
int FFT = d->addbutton(0.02,0.85,"FFT");
int PLOT = d->addbutton(0.02,0.80,"Plot");
int NEXT = d->addbutton(0.02,0.75,"Next");
int ZAPPEAK = d->addbutton(0.075,0.75,"ZapPeak");
int RESET = d->addbutton(0.02,0.70,"Reset");
int GLOBALRESET = d->addbutton(0.02,0.65,"Global Reset");
int HALVEPLOT = d->addbutton(0.02,0.60,"Halve Plot");
int BASELINE = d->addbutton(0.02,0.50,"Baseline");
int ZAPCOMMON = d->addbutton(0.02,0.45,"Zap Common");
int SUBTRACTMEAN = d->addbutton(0.02,0.40,"ZAP Mean");
int BSCRUNCH = d->addbutton(0.02,0.35,"Bscrunch");
int NORMALISE = d->addbutton(0.02,0.30,"Normalise");
int HISTOGRAM = d->addbutton(0.02,0.25,"Histogram");
int GSEARCH = d->addbutton(0.02,0.20,"Find Giants");
int MOWLAWN = d->addbutton(0.08,0.70,"LAWN");
int SEEFIL = d->addbutton(0.02,0.15,"View Band");
int FWRITE = d->addbutton(0.02,0.05,"Write File");
/* add the plot regions */
d->addplotregion(0.2,0.99,0.98,0.99);
float deltay = 0.9/(float)nfiles;
for (i=0; i<nfiles; i++)
d->addplotregion(0.2,0.99,0.95-deltay*(float)(i+1),0.95-deltay*(float)i);
d->draw();
float x,y;
char ans;
int button=-1; int plotno=-1;
int NPIXELS = 1024;
float * xaxis = new float[NPIXELS];
float * ymaxes = new float[NPIXELS];
float * ymins = new float[NPIXELS];
int scrunch=1;
int nmarkers=0;
int * markers= new int[MAXMARKERS];
int nfileptr=nskipstart;
int nplot=ngulp_original;
nstart=0; //COMMENTED IN ZAPPER VERSION: MAY CAUSE CONFLICTS IN THIS VER.
ngulp=ngulp_original; //COMMENTED IN ZAPPER VERSION: MAY CAUSE CONFLICTS IN THIS VER.
double trialperiod;
int doperiod=-1;
double xperiod;
bool zoneplot=false;
int ngates=0;
float xgate=0.0;
button=NEXT;
if (spectra) button = PLOT;
while (button!=QUIT){
// Plot the zone
// Entire file is white
if (button!=NEXT)button=d->manage(&x,&y,&ans,&plotno);
if (ans=='h'){
buttonexplain();
continue;
}
// printf("manage x %f y %f plotno %d\n",x,y,plotno);
if (button==BASELINE) {
for (i=0; i<nfiles; i++){
find_baseline(ngulp,time_series[i],10.0/tsamp,5.0);
}
button = PLOT;
zoneplot=false;
plotno = -1;
}
if (button==FWRITE) {
// reread first header and close it. Sets globals.
fclose(inputfile[0]);
inputfile[0]=open_file(argv[1],"r");
headersize[0]=read_header(inputfile[0]);
output = open_file("giant.tim","w");
nobits=32;
nbands=1;
dedisperse_header();
fprintf(stderr,"Opened file, writing data\n");
fwrite(time_series[0],sizeof(float),ngulp,output);
fclose(output);
button = -1;
zoneplot=false;
plotno =-1;
}
if (button==BSCRUNCH) {
for (i=0; i<nfiles; i++){
bscrunch(ngulp,time_series[i]);
}
tsamp*=2;
scrunch*=2;
ngulp/=2;
nplot/=2;
button = PLOT;
zoneplot=false;
Gsearched=false;
plotno = -1;
}
if (button==FFT) {
for (i=0; i<nfiles; i++){
ngulp = ngulp_original;
find_fft(&ngulp,time_series[i]);
// Zap DC spike
time_series[i][0]=0.0;
time_series[i][1]=0.0;
}
spectra = 1;
nplot = ngulp;
button = PLOT;
Gsearched=false;
plotno = -1;
}
if (button==POWER) {
for (i=0; i<nfiles; i++){
find_formspec(ngulp,time_series[i]);
}
ngulp/=2;
powerspectra = 1;
nplot = ngulp;
button = PLOT;
plotno = -1;
}
if (button==SMHRM) {
nfiles = 6;
for (i=1; i<nfiles; i++){
time_series[i]=(float *) malloc((ngulp+2)*sizeof(float));
if (time_series[i]==NULL){
fprintf(stderr,"Error allocating memory\n");
exit(-1);
}
}
for (i=1;i<nfiles;i++) memcpy(time_series[i],time_series[0],
(ngulp+2)*sizeof(float));
d->nplotregion=1;
float deltay = 0.9/(float)nfiles;
for (i=0; i<nfiles; i++)
d->addplotregion(0.2,0.99,0.95-deltay*(float)(i+1),
0.95-deltay*(float)i);
cpgeras();
d->draw();
float * workspace = new float[ngulp];
// Set up space for data, now actually sumhrm
int one=1;
newoldsumhrm_(&time_series[0][1],workspace,&ngulp,&one,
// newoldsumhrm_(&time_series[0][0],workspace,&ngulp,&one,
time_series[1],time_series[2],time_series[3],
time_series[4],time_series[5]);
/* newnewsumhrm_(time_series[0],&ngulp,&one,
time_series[1],time_series[2],time_series[3],
time_series[4],time_series[5]);*/
for (int iff=2;iff<6;iff++){
for (int i=0;i<ngulp;i++){
time_series[iff][i]/=sqrt(pow(2.0,(float)(iff-1)));
}
}
delete [] workspace;
button = PLOT;
plotno = -1;
}
if (button==NORMALISE) {
for (i=0; i<nfiles; i++){
normalise(ngulp,time_series[i],5.0);
}
button = PLOT;
Gsearched=false;
plotno = -1;
}
if (button==HISTOGRAM) {
float pdfs[nfiles][MAXSIGMA];
// create pdfs for each beam
for (int i=0;i<nfiles;i++)
formpdf(pdfs[i],MAXSIGMA,ngulp,time_series[i]);
for (int i=0;i<nfiles;i++){
for (int j=0;j<MAXSIGMA; j++){
fprintf(stderr, "pdfs[%d][%2d]=%8.0f %f \%\n", i, j+1, pdfs[i][j], 100*pdfs[i][j]/ngulp);
}
}
button = PLOT;
plotno = -1;
}
if (button==HALVEPLOT) {
nplot/=2;
button = PLOT;
zoneplot=true;
Gsearched=false;
plotno = -1;
}
if (button==GLOBALRESET) {
plotno = -1;
nstart = 0;
scrunch=1;
tsamp = tsamp_orig;
nplot=ngulp_original;
ngulp=ngulp_original;
button=PLOT;
// Skip to end of skipped data
for (i=0; i<nfiles; i++){
fseek(inputfile[i],-(nfileptr-nskipstart)*nbits/8,SEEK_CUR);
Giant[i].clear();
}
nfileptr=nskipstart;
zoneplot=false;
Gsearched=false;
doperiod=-1;
button=NEXT;
}
if (button==SUBTRACTMEAN && nfiles>1) {
plotno = -1;
nstart = 0;
nplot=ngulp_original;
ngulp=ngulp_original;
button=PLOT;
// Skip to end of skipped data
for (int jj=0;jj<ngulp;jj++){
float sum;
sum=0.0;
for (i=1;i<nfiles;i++){
sum+=time_series[i][jj];
}
time_series[0][jj]-=sum/(float(nfiles-1));
}
Gsearched=false;
}
if (button==ZAPCOMMON && nfiles>1) {
plotno = -1;
nstart = 0;
nplot=ngulp_original;
ngulp=ngulp_original;
button=PLOT;
float pdfs[nfiles][MAXSIGMA];
// create pdfs for each beam
for (int i=0;i<nfiles;i++)
formpdf(pdfs[i],MAXSIGMA,ngulp,time_series[i]);
// for each point in each beam, mask if improbable
float thresh = 3.0;
int nbeammax = 5;
zap_improbables(pdfs,time_series,nfiles,ngulp,MAXSIGMA,thresh,nbeammax);
// Skip to end of skipped data
//for (int jj=0;jj<ngulp;jj++){
// float sum;
// sum=0.0;
// for (i=1;i<nfiles;i++){
// sum+=time_series[i][jj];
// }
// time_series[0][jj]-=sum/(float(nfiles-1));
//}
//Gsearched=false;
}
if (button==NEXT) {
ngulp=ngulp_original;
nstart=0;
nplot=ngulp_original;
// Read the data
int NActuallyRead;
// unsigned char *buffer;
char *buffer;
buffer = new char[ngulp*nbits/8];
//buffer = new char[ngulp*nbits/8];
for (i=0; i<nfiles; i++) {
// NActuallyRead = fread(time_series[i],sizeof(float),ngulp,inputfile[i]);
NActuallyRead = fread(buffer,nbits/8,ngulp,inputfile[i]);
if (nbits==32){
memcpy(time_series[i],buffer,sizeof(float)*ngulp);
} else {
for (int j=0;j<NActuallyRead;j++){
if (ssigned) time_series[i][j]=(float)buffer[j];
if (!ssigned) time_series[i][j]=(float)((unsigned char)buffer[j]);
}
}
puti(ngulp);
if (NActuallyRead!=ngulp){
fprintf(stderr,"Could not read %d floats from file\n",ngulp);
ngulp = NActuallyRead;
}
if(nfiles==1){
// Add fake pulsar here....
// for (int ii=0;ii<ngulp;ii++) time_series[i][ii]+= 10.0*pow(sin(float(ii*2.0*M_PI/60.0)),250.0);
}
//normalise(ngulp,time_series[i]);
}
nfileptr+=ngulp;
button = PLOT;
plotno= -1;
zoneplot=true;
}
if (button==RESET) {
button = plotno = -1;
nstart=0;
nplot=ngulp;
button=PLOT;
zoneplot=true;
Gsearched=false;
if (ans=='p'){
doperiod=-1;
}
}
if (plotno>0){
/* if (ans=='p'){ // hit p on a plot to type in a period
d->plotregions[plotno].reset();
//plot the thing;
fprintf(stderr,"Please enter a period in seconds: ");
cin>>trialperiod;
xperiod = x;
doperiod=plotno;
button=PLOT;
}*/
if (ans=='p'){ // hit p on a plot to type in a period
d->plotregions[plotno].reset();
//plot the thing;
fprintf(stderr,"Please enter a period in seconds: ");
cin>>trialperiod;
xperiod = (double)x;
doperiod=plotno;
button=PLOT;
}
if (ans=='m'){ // subtract 0.0000005 seconds from period
d->plotregions[plotno].reset();
trialperiod-=0.0000005;
fprintf(stderr,"Trial period is now %lf\n",trialperiod);
doperiod=plotno;
button=PLOT;
}
if (ans=='/'){ // add 0.0000005 seconds to period
d->plotregions[plotno].reset();
trialperiod+=0.0000005;
fprintf(stderr,"Trial period is now %lf\n",trialperiod);
doperiod=plotno;
button=PLOT;
}
if (ans==','){ // subtract 0.000005 seconds from period
d->plotregions[plotno].reset();
trialperiod-=0.000005;
fprintf(stderr,"Trial period is now %lf\n",trialperiod);
doperiod=plotno;
button=PLOT;
}
if (ans=='.'){ // add 0.000005 seconds to period
d->plotregions[plotno].reset();
trialperiod+=0.000005;
fprintf(stderr,"Trial period is now %lf\n",trialperiod);
doperiod=plotno;
button=PLOT;
}
if (ans=='<'){ // subtract 0.001 seconds from period
d->plotregions[plotno].reset();
trialperiod-=0.001;
fprintf(stderr,"Trial period is now %lf\n",trialperiod);
doperiod=plotno;
button=PLOT;
}
if (ans=='>'){ // add 0.001 seconds to period
d->plotregions[plotno].reset();
trialperiod+=0.001;
fprintf(stderr,"Trial period is now %lf\n",trialperiod);
doperiod=plotno;
button=PLOT;
}
if (ans=='X'){ // right click two points on a plot to calculate and plot a period
d->plotregions[plotno].reset();
cpgsci(3);
cpgmove(x,-1000);
cpgdraw(x,1000);
if (ngates==0){
xgate=x;
ngates++;
} else {
min_means_min(&x,&xgate);
printf("Period from %f to %f is %f\n",x,xgate,xgate-x);
doperiod=plotno;
xperiod = (double)x;
trialperiod=(double)(xgate-x);
ngates=0;
button=PLOT;
}
}
if (ans=='D'){
markers[nmarkers]=(int)(x/NPIXELS)*nplot+nstart+nfileptr-ngulp;
nmarkers++;
zoneplot=true;
}
if (ans=='A'){
d->plotregions[plotno].reset();
cpgsci(2);
cpgmove(x,-1000);
cpgdraw(x,1000);
if (ngates==0){
xgate=x;
ngates++;
} else {
min_means_min(&x,&xgate);
// printf("x %f xgate %f tstart %f\n",x,xgate,tstart);
nstart=(int)((x-tstart)/delta)+nstart;
nplot=(int)((xgate-x)/delta);
//if (nplot<NPIXELS) nplot=NPIXELS;
ngates=0;
button=PLOT;
zoneplot=true;
// printf("nplot %d nstart %d\n",nplot,nstart);
}
}
if (ans=='z'){
if (NPIXELS>nplot) {
nstart+=(int)x;
}else
nstart=(int)(x/(float)NPIXELS*nplot)+nstart;
printf("nstart %d\n",nstart);
nplot/=4;
printf("nplot %d\n",nplot);
nstart-=nplot/2;
printf("nstart %d\n",nstart);
//if (nplot<NPIXELS){nplot=NPIXELS;}
button=PLOT;
zoneplot=true;
}
}
int main()
{
char infile[] = "pih.fits";
char devtyp[16], idents[3][80], nlcprm[1], opt[2];
int c0[] = {-1, -1, -1, -1, -1, -1, -1};
int i, ic, gcode[2], naxis[2], nkeyrec, nreject, nwcs, relax, status;
float blc[2], trc[2];
double cache[257][4], grid1[1], grid2[1], nldprm[1];
struct wcsprm *wcs;
nlfunc_t pgwcsl_;
#if defined HAVE_CFITSIO && defined DO_CFITSIO
char *header;
fitsfile *fptr;
#else
char keyrec[81], header[28801];
int gotend, j, k;
FILE *fptr;
#endif
/* Set line buffering in case stdout is redirected to a file, otherwise
* stdout and stderr messages will be jumbled (stderr is unbuffered). */
setvbuf(stdout, NULL, _IOLBF, 0);
printf("Testing WCSLIB parser for FITS image headers (tpih2.c)\n"
"------------------------------------------------------\n\n");
/* Read in the FITS header, excluding COMMENT and HISTORY keyrecords. */
#if defined HAVE_CFITSIO && defined DO_CFITSIO
status = 0;
if (fits_open_file(&fptr, infile, READONLY, &status)) {
fits_report_error(stderr, status);
return 1;
}
if (fits_hdr2str(fptr, 1, NULL, 0, &header, &nkeyrec, &status)) {
fits_report_error(stderr, status);
return 1;
}
fits_close_file(fptr, &status);
#else
if ((fptr = fopen(infile, "r")) == 0x0) {
printf("ERROR opening %s\n", infile);
return 1;
}
k = 0;
nkeyrec = 0;
gotend = 0;
for (j = 0; j < 10; j++) {
for (i = 0; i < 36; i++) {
if (fgets(keyrec, 81, fptr) == 0) {
break;
}
if (strncmp(keyrec, " ", 8) == 0) continue;
if (strncmp(keyrec, "COMMENT ", 8) == 0) continue;
if (strncmp(keyrec, "HISTORY ", 8) == 0) continue;
strncpy(header+k, keyrec, 80);
k += 80;
nkeyrec++;
if (strncmp(keyrec, "END ", 8) == 0) {
/* An END keyrecord was read, but read the rest of the block. */
gotend = 1;
}
}
if (gotend) break;
}
fclose(fptr);
#endif
fprintf(stderr, "Found %d non-comment header keyrecords.\n", nkeyrec);
relax = WCSHDR_all;
if ((status = wcspih(header, nkeyrec, relax, 2, &nreject, &nwcs, &wcs))) {
fprintf(stderr, "wcspih ERROR %d: %s.\n", status, wcs_errmsg[status]);
}
#if defined HAVE_CFITSIO && defined DO_CFITSIO
free(header);
#endif
/* Plot setup. */
naxis[0] = 1024;
naxis[1] = 1024;
blc[0] = 0.5f;
blc[1] = 0.5f;
trc[0] = naxis[0] + 0.5f;
trc[1] = naxis[1] + 0.5f;
strcpy(devtyp, "/XWINDOW");
cpgbeg(0, devtyp, 1, 1);
cpgvstd();
cpgwnad(0.0f, 1.0f, 0.0f, 1.0f);
cpgask(1);
cpgpage();
/* Annotation. */
strcpy(idents[0], "Right ascension");
strcpy(idents[1], "Declination");
opt[0] = 'G';
opt[1] = 'E';
/* Compact lettering. */
cpgsch(0.8f);
/* Draw full grid lines. */
cpgsci(1);
gcode[0] = 2;
gcode[1] = 2;
grid1[0] = 0.0;
grid2[0] = 0.0;
for (i = 0; i < nwcs; i++) {
if ((status = wcsset(wcs+i))) {
fprintf(stderr, "wcsset ERROR %d: %s.\n", status, wcs_errmsg[status]);
continue;
}
/* Get WCSNAME out of the wcsprm struct. */
strcpy(idents[2], (wcs+i)->wcsname);
printf("\n%s\n", idents[2]);
/* Draw the celestial grid. The grid density is set for each world */
/* coordinate by specifying LABDEN = 1224. */
ic = -1;
cpgsbox(blc, trc, idents, opt, 0, 1224, c0, gcode, 0.0, 0, grid1, 0,
grid2, 0, pgwcsl_, 1, WCSLEN, 1, nlcprm, (int *)(wcs+i), nldprm, 256,
&ic, cache, &status);
/* Draw the frame. */
cpgbox("BC", 0.0f, 0, "BC", 0.0f, 0);
cpgpage();
}
status = wcsvfree(&nwcs, &wcs);
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;
}
int plot_resid(Fluxrec *flux, int npoints, float *a, int ncoeff,
float *meanrms)
{
int i,j; /* Looping variables */
int no_error=1; /* Flag set to 0 on error */
float ytmp; /* Value of fitted function at a given day */
float mean; /* Mean of residual curve */
float *polyx=NULL; /* Polynomial in x */
Fluxrec *resid=NULL; /* Residual curve */
Fluxrec *rptr; /* Pointer to navigate resid */
Fluxrec *fptr; /* Pointer to navigate flux */
/*
* Allocate memory
*/
if(!(polyx = new_array(ncoeff,1))) {
fprintf(stderr,"ERROR: plot_resid\n");
return 1;
}
if(!(resid = new_fluxrec(npoints)))
no_error = 0;
/*
* Loop through flux, at each step compute the value of the function
* and then subtract it from the flux.
*/
if(no_error) {
for(i=0,fptr=flux,rptr=resid; i<npoints; i++,fptr++,rptr++) {
/*
* Compute the function value at this step
*/
sinpoly(fptr->day,polyx-1,ncoeff);
ytmp = 0;
for(j=0; j<ncoeff; j++)
ytmp += a[j] * polyx[j];
/*
* Now set resid->flux to be the difference between flux->flux and the
* fitted function
*/
*rptr = *fptr;
rptr->flux -= ytmp;
}
}
/*
* Now plot the points
*/
if(no_error)
if(plot_lcurve(resid,npoints,"Days","Residual Flux Density",""))
no_error = 0;
/*
* Draw a line at 0.0 residual
*/
if(no_error) {
cpgsci(2);
cpgslw(5);
cpgmove(-999,0.0);
cpgdraw(999,0.0);
cpgslw(1);
cpgsci(1);
}
/*
* Calculate mean and rms
*/
if(no_error) {
if(calc_mean(resid,npoints,&mean,meanrms))
no_error = 0;
else {
*meanrms /= sqrt(npoints);
printf("\nplot_resid: Mean of residuals = %8.4f. ",mean);
printf("RMS uncertainty in mean = %6.4f\n",*meanrms);
}
}
/*
* Clean up and exit
*/
cpgslw(1);
cpgsci(1);
polyx = del_array(polyx);
resid = del_fluxrec(resid);
if(no_error)
return 0;
else {
fprintf(stderr,"ERROR: plot_resid\n");
return 1;
}
}
