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;
}
/**
* This method will expand the graphics panel already openned to the maximun of the display area scaled by the scale value supplied.
*
* @param scale Porcentage (0-100) of the display width to use.
*/
void resizemax(float scale)
{
Display *disp;
float ax, ay;
int X, Y;
/* Xlib code */
disp = XOpenDisplay(NULL);
if (disp == NULL) {
fprintf(stderr, "No Display.\n");
exit(-1);
} else {
Y = XDisplayHeightMM(disp, 0);
X = XDisplayWidthMM(disp, 0) / (0.9);
}
XCloseDisplay(disp);
/* End of Xlib code */
ay = (double) Y / (double) X;
ax = X / 25.4 * scale;
cpgpap(ax, ay);
cpgpage();
BASIC_ASPECT = ay;
}
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;
}
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 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 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 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;
}
int main(int argc, char *argv[])
{
fitsfile* fptr;
//char filename[] = "guppi_56590_B1133+16_0003_0001.fits";
char filename[] = "~/pulsar_data/B0329.fits";
int status = 0;
float realDm = 26.8;
double psrFreq = 1.399541539;
int i,j; //for loop
int sampNum;
fits_open_file(&fptr,filename,READONLY,&status);
//初始化fits文件信息
struct Fitsinfo* fi = (struct Fitsinfo*)malloc(sizeof(struct Fitsinfo));
initFitsInfo(fptr,fi,realDm,&status);
sampNum = fi->nSBLK*fi->nROW;
//初始化保存所有流量数据的二维数组
/*
unsigned char** ptr = (unsigned char**)malloc(fi->nROW*fi->nSBLK*sizeof(unsigned char*));
for (i=0; i<fi->nROW*fi->nSBLK; i++) {
ptr[i] = (unsigned char*)malloc(fi->nCHAN*sizeof(unsigned char));
}
initTotalData(fptr,fi,ptr,&status);
*/
//初始化合适的频道
unsigned char** ptr = (unsigned char**)malloc(fi->nROW*fi->nSBLK*sizeof(unsigned char*));
for (i=0; i<fi->nROW*fi->nSBLK; i++) {
ptr[i] = (unsigned char*)malloc((fi->highF-fi->lowF+1)*sizeof(unsigned char));
}
initSuitData(fptr,fi,ptr,&status);
//给需要处理的某两个通道分配空间
struct FreqData* fdm = (struct FreqData*)malloc(sizeof(struct FreqData));
fdm->data = (int*)malloc(sizeof(int)*fi->nSBLK*fi->nROW);
struct FreqData** fd = (struct FreqData**)malloc(DMNUM*sizeof(struct FreqData*));
for (i=0; i<DMNUM; i++) {
fd[i] = (struct FreqData*)malloc(sizeof(struct FreqData));
fd[i]->data = (int*)malloc(sizeof(int)*fi->nSBLK*fi->nROW);
//addSuitFreqData(fptr,fd[i],fdm,ptr,fi->dmArr[i],fi,&status);
addSuitFreqDataWithZeroDm(fptr,fd[i],fdm,ptr,fi->dmArr[i],fi,&status);
}
for (i=0; i<fi->nROW*fi->nSBLK; i++) {
free(ptr[i]);
}
free(ptr);
/* draw fd[DMNUM/2]->data */
/* draw fd[DMNUM/2]->data */
if (cpgbeg(0, "/xs", 1, 1) != 1) {
return EXIT_FAILURE;
}
float ns = fi->nROW * fi->nSBLK;
float *x_coor, *data_adm;
x_coor = (float *)malloc(sizeof(float) * fi->nROW * fi->nSBLK);
data_adm = (float *)malloc(sizeof(float) * ns);
for (i = 0; i < fi->nROW * fi->nSBLK; i++) {
*(x_coor + i) = i;
*(data_adm + i) = (float)fd[DMNUM/2]->data[i];
}
cpgpage();
cpgenv(0.0, fi->nROW * fi->nSBLK, -5000.0f, 5000.0f, 0, 1);
cpgline(ns, x_coor, data_adm);
cpgbbuf();
cpgend();
return EXIT_SUCCESS;
float aveData[20000] = {0};
writeIntData("26.8.dat",26.8,fd[DMNUM/2]->data,fi->nSBLK*fi->nROW);
calcAveArr(aveData,fd[DMNUM/2]->data,2000000,100);
writeFloatData("ave26.8.dat",26.8,aveData,20000);
int foldData[20000] = {0};
fold(foldData,fd[DMNUM/2]->data,fi->tBIN,psrFreq,fi->nSBLK*fi->nROW);
writeHistogramData(fd,fi);
fits_close_file(fptr,&status);
}
// 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 main()
{
/* Set up a 2 x 2 lookup table. */
const int M = 2;
const int K[] = {K1, K2};
const int map[] = {0, 1};
const double crval[] = {0.0, 0.0};
char text[80];
int i, j, k, l, l1, l2, l3, lstep, m, stat[NP*NP], status;
float array[NP][NP], clev[31], v0, v1, w;
const float scl = 2.0f/(NP-1);
float ltm[6];
double x[NP][NP][2], world[NP][NP][2];
struct tabprm tab;
printf("Testing WCSLIB coordinate lookup table routines (ttab2.c)\n"
"---------------------------------------------------------\n");
/* List status return messages. */
printf("\nList of tab status return values:\n");
for (status = 1; status <= 5; status++) {
printf("%4d: %s.\n", status, tab_errmsg[status]);
}
printf("\n");
/* PGPLOT initialization. */
strcpy(text, "/xwindow");
cpgbeg(0, text, 1, 1);
cpgvstd();
cpgsch(0.7f);
/* The viewport is slightly oversized. */
cpgwnad(-0.65f, 1.65f, -0.65f, 1.65f);
for (l = 0; l <= 30; l++) {
clev[l] = 0.2f*(l-10);
}
ltm[0] = -scl*(1.0f + (NP-1)/4.0f);
ltm[1] = scl;
ltm[2] = 0.0f;
ltm[3] = -scl*(1.0f + (NP-1)/4.0f);
ltm[4] = 0.0f;
ltm[5] = scl;
/* Set up the lookup table. */
tab.flag = -1;
if ((status = tabini(1, M, K, &tab))) {
printf("tabini ERROR %d: %s.\n", status, tab_errmsg[status]);
return 1;
}
tab.M = M;
for (m = 0; m < tab.M; m++) {
tab.K[m] = K[m];
tab.map[m] = map[m];
tab.crval[m] = crval[m];
for (k = 0; k < tab.K[m]; k++) {
tab.index[m][k] = (double)k;
}
}
/* Subdivide the interpolation element. */
for (i = 0; i < NP; i++) {
for (j = 0; j < NP; j++) {
x[i][j][0] = j*(K1-1.0)*scl - 0.5 - crval[0];
x[i][j][1] = i*(K2-1.0)*scl - 0.5 - crval[1];
}
}
/* The first coordinate element is static. */
tab.coord[0] = 0.0;
tab.coord[2] = 0.0;
tab.coord[4] = 0.0;
tab.coord[6] = 0.0;
/* (k1,k2) = (0,0). */
tab.coord[1] = 0.0;
/* The second coordinate element varies in three of the corners. */
for (l3 = 0; l3 <= 100; l3 += 20) {
/* (k1,k2) = (1,1). */
tab.coord[7] = 0.01 * l3;
for (l2 = 0; l2 <= 100; l2 += 20) {
/* (k1,k2) = (0,1). */
tab.coord[5] = 0.01 * l2;
cpgpage();
for (l1 = 0; l1 <= 100; l1 += 2) {
/* (k1,k2) = (1,0). */
tab.coord[3] = 0.01 * l1;
/* Compute coordinates within the interpolation element. */
tab.flag = 0;
if ((status = tabx2s(&tab, NP*NP, 2, (double *)x, (double *)world,
stat))) {
printf("tabx2s ERROR %d: %s.\n", status, tab_errmsg[status]);
}
/* Start a new plot. */
cpgbbuf();
cpgeras();
cpgsci(1);
cpgslw(3);
cpgbox("BCNST", 0.0f, 0, "BCNSTV", 0.0f, 0);
cpgmtxt("T", 0.7f, 0.5f, 0.5f, "-TAB coordinates: "
"linear interpolation / extrapolation in 2-D");
/* Draw the boundary of the interpolation element in red. */
cpgsci(2);
cpgmove(-0.5f, 0.0f);
cpgdraw( 1.5f, 0.0f);
cpgmove( 1.0f, -0.5f);
cpgdraw( 1.0f, 1.5f);
cpgmove( 1.5f, 1.0f);
cpgdraw(-0.5f, 1.0f);
cpgmove( 0.0f, 1.5f);
cpgdraw( 0.0f, -0.5f);
/* Label the value of the coordinate element in each corner. */
sprintf(text, "%.1f", tab.coord[1]);
cpgtext(-0.09f, -0.05f, text);
sprintf(text, "%.2f", tab.coord[3]);
cpgtext( 1.02f, -0.05f, text);
sprintf(text, "%.1f", tab.coord[5]);
cpgtext(-0.13f, 1.02f, text);
sprintf(text, "%.1f", tab.coord[7]);
cpgtext( 1.02f, 1.02f, text);
cpgsci(1);
/* Contour labelling: bottom. */
v0 = world[0][0][1];
v1 = world[0][NP-1][1];
if (v0 != v1) {
lstep = (abs((int)((v1-v0)/0.2f)) < 10) ? 20 : 40;
for (l = -200; l <= 300; l += lstep) {
w = -0.5f + 2.0f * (l*0.01f - v0) / (v1 - v0);
if (w < -0.5 || w > 1.5) continue;
sprintf(text, "%4.1f", l*0.01f);
cpgptxt(w+0.04f, -0.56f, 0.0f, 1.0f, text);
}
}
/* Contour labelling: left. */
v0 = world[0][0][1];
v1 = world[NP-1][0][1];
if (v0 != v1) {
lstep = (abs((int)((v1-v0)/0.2f)) < 10) ? 20 : 40;
for (l = -200; l <= 300; l += lstep) {
w = -0.5f + 2.0f * (l*0.01f - v0) / (v1 - v0);
if (w < -0.5 || w > 1.5) continue;
sprintf(text, "%4.1f", l*0.01f);
cpgptxt(-0.52f, w-0.02f, 0.0f, 1.0f, text);
}
}
/* Contour labelling: right. */
v0 = world[0][NP-1][1];
v1 = world[NP-1][NP-1][1];
if (v0 != v1) {
lstep = (abs((int)((v1-v0)/0.2f)) < 10) ? 20 : 40;
for (l = -200; l <= 300; l += lstep) {
w = -0.5f + 2.0f * (l*0.01f - v0) / (v1 - v0);
if (w < -0.5 || w > 1.5) continue;
sprintf(text, "%.1f", l*0.01f);
cpgptxt(1.52f, w-0.02f, 0.0f, 0.0f, text);
}
}
/* Contour labelling: top. */
v0 = world[NP-1][0][1];
v1 = world[NP-1][NP-1][1];
if (v0 != v1) {
lstep = (abs((int)((v1-v0)/0.2f)) < 10) ? 20 : 40;
for (l = -200; l <= 300; l += lstep) {
w = -0.5f + 2.0f * (l*0.01f - v0) / (v1 - v0);
if (w < -0.5 || w > 1.5) continue;
sprintf(text, "%4.1f", l*0.01f);
cpgptxt(w+0.04f, 1.52f, 0.0f, 1.0f, text);
}
}
/* Draw contours for the second coordinate element. */
for (i = 0; i < NP; i++) {
for (j = 0; j < NP; j++) {
array[i][j] = world[i][j][1];
}
}
cpgsci(4);
cpgslw(2);
cpgcont(array[0], NP, NP, 1, NP, 1, NP, clev, 10, ltm);
cpgsci(7);
cpgcont(array[0], NP, NP, 1, NP, 1, NP, clev+10, 1, ltm);
cpgsci(5);
cpgcont(array[0], NP, NP, 1, NP, 1, NP, clev+11, 20, ltm);
cpgebuf();
}
}
}
cpgend();
tabfree(&tab);
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();
}
static double harmonic_loop(int xid, double rr, int zoomlevel, fftpart * fp)
{
float inx = 0.0, iny = 0.0;
double retval = 0.0;
int xid2, psid, badchoice = 1;
char choice;
xid2 = cpgopen("/XWIN");
cpgpap(10.25, 8.5 / 11.0);
cpgask(0);
cpgslct(xid2);
plot_harmonics(rr, zoomlevel, fp);
printf(" Click on the harmonic to go it,\n"
" press 'P' to print, or press 'Q' to close.\n");
while (badchoice) {
cpgcurs(&inx, &iny, &choice);
if (choice == 'Q' || choice == 'q') {
badchoice = 0;
} else if (choice == 'P' || choice == 'p') {
int len, numharmbins;
double offsetf;
char filename[200];
fftpart *harmpart;
fftview *harmview;
printf(" Enter the filename to save the plot as:\n");
fgets(filename, 195, stdin);
len = strlen(filename) - 1;
strcpy(filename + len, "/CPS");
psid = cpgopen(filename);
cpgslct(psid);
cpgpap(10.25, 8.5 / 11.0);
cpgiden();
cpgscr(15, 0.8, 0.8, 0.8);
numharmbins = (1 << (LOGDISPLAYNUM - zoomlevel));
harmpart = get_fftpart((int) (rr - numharmbins), 2 * numharmbins);
harmview = get_fftview(rr, zoomlevel, harmpart);
free_fftpart(harmpart);
offsetf = plot_fftview(harmview, 0.0, 1.0, rr, 2);
cpgpage();
plot_harmonics(rr, zoomlevel, fp);
cpgclos();
cpgslct(xid2);
cpgscr(15, 0.4, 0.4, 0.4);
filename[len] = '\0';
printf(" Wrote the plot to the file '%s'.\n", filename);
} else if (choice == 'A' || choice == 'a') {
if (iny > 1.0)
retval = rr * (int) (inx);
else if (iny > 0.0)
retval = rr * ((int) (inx) + 4.0);
else if (iny > -1.0)
retval = rr / (int) (inx);
else
retval = rr / ((int) (inx) + 4.0);
badchoice = 0;
} else {
printf(" Option not recognized.\n");
}
};
cpgclos();
cpgslct(xid);
return retval;
}
int main(int argc, char **argv)
{
char alt = '\0', *header, idents[3][80], *infile, keyword[16], nlcprm[1],
opt[2], pgdev[16];
int c0[] = {-1, -1, -1, -1, -1, -1, -1};
int alts[27], gcode[2], hdunum = 1, hdutype, i, ic, naxes, naxis[2],
nkeyrec, nreject, nwcs, stat[NWCSFIX], status;
float blc[2], trc[2];
double cache[257][4], grid1[3], grid2[3], nldprm[1];
struct wcsprm *wcs;
nlfunc_t pgwcsl_;
fitsfile *fptr;
/* Parse options. */
strcpy(pgdev, "/XWINDOW");
for (i = 1; i < argc && argv[i][0] == '-'; i++) {
if (!argv[i][1]) break;
switch (argv[i][1]) {
case 'a':
alt = toupper(argv[i][2]);
break;
case 'd':
if (argv[i][2] == '?') {
cpgldev();
return 0;
}
if (argv[i][2] == '/') {
strncpy(pgdev+1, argv[i]+3, 15);
} else {
strncpy(pgdev+1, argv[i]+2, 15);
}
break;
case 'h':
hdunum = atoi(argv[i]+2);
break;
default:
fprintf(stderr, "%s", usage);
return 1;
}
}
if (i < argc) {
infile = argv[i++];
if (i < argc) {
fprintf(stderr, "%s", usage);
return 1;
}
} else {
infile = "-";
}
/* Check accessibility of the input file. */
if (strcmp(infile, "-") && access(infile, R_OK) == -1) {
printf("wcsgrid: Cannot access %s.\n", infile);
return 1;
}
/* Open the FITS file and move to the required HDU. */
status = 0;
if (fits_open_file(&fptr, infile, READONLY, &status)) goto fitserr;
if (fits_movabs_hdu(fptr, hdunum, &hdutype, &status)) goto fitserr;
if (hdutype != IMAGE_HDU) {
fprintf(stderr, "ERROR, HDU number %d does not contain an image array.\n",
hdunum);
return 1;
}
/* Check that we have at least two image axes. */
if (fits_read_key(fptr, TINT, "NAXIS", &naxes, NULL, &status)) {
goto fitserr;
}
if (naxes < 2) {
fprintf(stderr, "ERROR, HDU number %d does not contain a 2-D image.\n",
hdunum);
return 1;
} else if (naxes > 2) {
printf("HDU number %d contains a %d-D image array.\n", hdunum, naxes);
}
/* Read in the FITS header, excluding COMMENT and HISTORY keyrecords. */
if (fits_hdr2str(fptr, 1, NULL, 0, &header, &nkeyrec, &status)) {
goto fitserr;
}
/* Interpret the WCS keywords. */
if ((status = wcspih(header, nkeyrec, WCSHDR_all, -3, &nreject, &nwcs,
&wcs))) {
fprintf(stderr, "wcspih ERROR %d: %s.\n", status, wcshdr_errmsg[status]);
return 1;
}
free(header);
/* Read -TAB arrays from the binary table extension (if necessary). */
if (fits_read_wcstab(fptr, wcs->nwtb, (wtbarr *)wcs->wtb, &status)) {
goto fitserr;
}
/* Translate non-standard WCS keyvalues. */
if ((status = wcsfix(7, 0, wcs, stat))) {
status = 0;
for (i = 0; i < NWCSFIX; i++) {
if (stat[i] > 0) {
fprintf(stderr, "wcsfix ERROR %d: %s.\n", stat[i],
wcsfix_errmsg[stat[i]]);
/* Ignore problems with CDi_ja and DATE-OBS. */
if (!(i == CDFIX || i == DATFIX)) status = 1;
}
}
if (status) return 1;
}
/* Sort out alternates. */
if (alt) {
wcsidx(nwcs, &wcs, alts);
if (alt == ' ') {
if (alts[0] == -1) {
fprintf(stderr, "WARNING, no primary coordinate representation, "
"doing all.\n");
alt = '\0';
}
} else if (alt < 'A' || alt > 'Z') {
fprintf(stderr, "WARNING, alternate specifier \"%c\" is invalid, "
"doing all.\n", alt);
alt = '\0';
} else {
if (alts[alt - 'A' + 1] == -1) {
fprintf(stderr, "WARNING, no alternate coordinate representation "
"\"%c\", doing all.\n", alt);
alt = '\0';
}
}
}
/* Get image dimensions from the header. */
sprintf(keyword, "NAXIS%d", wcs->lng + 1);
fits_read_key(fptr, TINT, "NAXIS1", naxis, NULL, &status);
sprintf(keyword, "NAXIS%d", wcs->lat + 1);
fits_read_key(fptr, TINT, "NAXIS2", naxis+1, NULL, &status);
if ((naxis[0] < 2) || (naxis[1] < 2)) {
fprintf(stderr, "ERROR, HDU number %d contains degenerate image axes.\n",
hdunum);
return 1;
}
fits_close_file(fptr, &status);
/* Plot setup. */
blc[0] = 0.5f;
blc[1] = 0.5f;
trc[0] = naxis[0] + 0.5f;
trc[1] = naxis[1] + 0.5f;
if (cpgbeg(0, pgdev, 1, 1) != 1) {
fprintf(stderr, "ERROR, failed to open PGPLOT device %s.\n", pgdev);
return 1;
}
cpgvstd();
cpgwnad(blc[0], trc[0], blc[0], trc[1]);
cpgask(1);
cpgpage();
/* Compact lettering. */
cpgsch(0.8f);
/* Draw full grid lines. */
gcode[0] = 2;
gcode[1] = 2;
grid1[0] = 0.0;
grid2[0] = 0.0;
/* These are for the projection boundary. */
grid1[1] = -180.0;
grid1[2] = 180.0;
grid2[1] = -90.0;
grid2[2] = 90.0;
cpgsci(1);
for (i = 0; i < nwcs; i++) {
if (alt && (wcs+i)->alt[0] != alt) {
continue;
}
if ((status = wcsset(wcs+i))) {
fprintf(stderr, "wcsset ERROR %d: %s.\n", status, wcs_errmsg[status]);
continue;
}
/* Draw the frame. */
cpgbox("BC", 0.0f, 0, "BC", 0.0f, 0);
/* Axis labels; use CNAMEia in preference to CTYPEia. */
if ((wcs+i)->cname[0][0]) {
strcpy(idents[0], (wcs+i)->cname[0]);
} else {
strcpy(idents[0], (wcs+i)->ctype[0]);
}
if ((wcs+i)->cname[1][0]) {
strcpy(idents[1], (wcs+i)->cname[1]);
} else {
strcpy(idents[1], (wcs+i)->ctype[1]);
}
/* Title; use WCSNAME. */
strcpy(idents[2], (wcs+i)->wcsname);
if (strlen(idents[2])) {
printf("\n%s\n", idents[2]);
}
/* Formatting control for celestial coordinates. */
if (strncmp((wcs+i)->ctype[0], "RA", 2) == 0) {
/* Right ascension in HMS, declination in DMS. */
opt[0] = 'G';
opt[1] = 'E';
} else {
/* Other angles in decimal degrees. */
opt[0] = 'A';
opt[1] = 'B';
}
/* 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);
/* Delimit the projection boundary. */
if ((wcs+i)->cel.prj.category != ZENITHAL) {
/* Reset to the native coordinate graticule. */
(wcs+i)->crval[0] = (wcs+i)->cel.prj.phi0;
(wcs+i)->crval[1] = (wcs+i)->cel.prj.theta0;
(wcs+i)->lonpole = 999.0;
(wcs+i)->latpole = 999.0;
status = wcsset(wcs+i);
ic = -1;
cpgsbox(blc, trc, idents, opt, -1, 0, c0, gcode, 0.0, 2, grid1, 2,
grid2, 0, pgwcsl_, 1, WCSLEN, 1, nlcprm, (int *)(wcs+i), nldprm, 256,
&ic, cache, &status);
}
cpgpage();
}
status = wcsvfree(&nwcs, &wcs);
return 0;
fitserr:
fits_report_error(stderr, status);
fits_close_file(fptr, &status);
return 1;
}
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; //complex variables z and c introduced
struct cnum c;
for(i=0;i<N;i++) //look at every point on grid
{
for(j=0;j<N;j++)
{
z.cx = XMIN + i*RES; // z = current point
z.cy = YMIN + j*RES;
CPRINT(z);
c.cx = z.cx; // keep z, feed c=z in to iteration
c.cy = z.cy;
for(p=0;p<MNI;p++) //apply MNI iterations to c
{
c = FJULIA(c);
if ( c.cx*c.cx + c.cy*c.cy > R) // if iteration "blows up"...
{
z.cx = 0;
z.cy = 0;
c.cx = 0;
c.cy = 0;
}
}
if (c.cx*c.cx + c.cy*c.cy < R) //if iteration hasn't blown up...
{
float X[1], Y[1];
X[0] = z.cx;
Y[0] = z.cy;
cpgpt(1,X,Y,17); // plot point z
}
}
}
printf("\n\n");
cpgend();
}
void main() //main code
{
printf("\nRUNGE-KUTTA METHOD\n\nR M Rho\n"); //printing titles for values displayed
double c = 10.0; //the parameter rho(c)
int n; //the integer steps, n
//declare arrays
float x[N];
float y[N];
float z[N];
//r,m,p as the radius, mass and density
double r,m,p;
//declare initial conditons for arrays
x[0] = h; //first array is for r=h
y[0] = (h*h*h/3)*c; //initial conditon for scaled mass (m)
z[0] = c*(1-((h*h*c)/(6*gamma(c)))); //initial conditon for rho
//for loop for n=0,1,...,200
for(n=0;n<N;n++)
{
//declared how x(n+1) relates to x(n), y(n+1) relates to y(n), z(n+1) relates to z(n)
x[n+1] = x[n]+h;
y[n+1] = y[n]+(h/6)*(M(x[n],y[n],z[n])+2*M2(x[n],y[n],z[n])+2*M3(x[n],y[n],z[n])+M4(x[n],y[n],z[n]));
z[n+1] = z[n]+(h/6)*(rho(x[n],y[n],z[n])+2*rho2(x[n],y[n],z[n])+2*rho3(x[n],y[n],z[n])+rho4(x[n],y[n],z[n]));
if(isnan(z[n+1]))
{
break;
}
//r,m,p will be declared in pg-plot
r = x[n+1];
m = y[n+1];
p = z[n+1];
printf("%.2e %.2e %.2e\n",x[n+1],y[n+1],z[n+1]); //printed values for x and y respectively
}
//Use pg-plot to plot mass and density
// cpgbeg starts a plotting page, in this case with 2x1 panels
cpgbeg(0,"?",2,1);
// sets colour: 1-black, 2-red, 3-green, 4-blue
cpgsci(1);
// sets line style: 1-solid, 2-dashed, 3-dot-dashed, 4-dotted
cpgsls(1);
// sets charachter height, larger number = bigger
cpgsch(1.);
// cpgpage() moves to the next panel
cpgpage();
// sets the axes limits in the panel
cpgswin(0,r,0,m);
// draw the axes
cpgbox("BCNST", 0.0, 0, "BCNST", 0.0, 0);
// label the bottom axis
cpgmtxt("B",2.,.5,.5,"radius");
// label the left axis
cpgmtxt("L",2.5,.5,.5,"saclaed mass");
// connect N points in ax and ay with a line
cpgline(n,x,y);
// cpgpage() moves to the next panel
cpgpage();
// sets the axes limits in the panel
cpgswin(0,r,0,c);
// draw the axes
cpgbox("BCNST", 0.0, 0, "BCNST", 0.0, 0);
// label the bottom axis
cpgmtxt("B",2.,.5,.5,"radius");
// label the left axis
cpgmtxt("L",2.5,.5,.5,"density");
// connect N points in ax and ay with a line
cpgline(n,x,z);
// close all pgplot applications
cpgend();
// end program
return;
}
void rfifind_plot(int numchan, int numint, int ptsperint,
float timesigma, float freqsigma,
float inttrigfrac, float chantrigfrac,
float **dataavg, float **datastd, float **datapow,
int *userchan, int numuserchan,
int *userints, int numuserints,
infodata * idata, unsigned char **bytemask,
mask * oldmask, mask * newmask,
rfi * rfivect, int numrfi, int rfixwin, int rfips, int xwin)
/* Make the beautiful multi-page rfifind plots */
{
int ii, jj, ct, loops = 1;
float *freqs, *chans, *times, *ints;
float *avg_chan_avg, *std_chan_avg, *pow_chan_avg;
float *avg_chan_med, *std_chan_med, *pow_chan_med;
float *avg_chan_std, *std_chan_std, *pow_chan_std;
float *avg_int_avg, *std_int_avg, *pow_int_avg;
float *avg_int_med, *std_int_med, *pow_int_med;
float *avg_int_std, *std_int_std, *pow_int_std;
float dataavg_avg, datastd_avg, datapow_avg;
float dataavg_med, datastd_med, datapow_med;
float dataavg_std, datastd_std, datapow_std;
float avg_reject, std_reject, pow_reject;
double inttim, T, lof, hif;
inttim = ptsperint * idata->dt;
T = inttim * numint;
lof = idata->freq - 0.5 * idata->chan_wid;
hif = lof + idata->freqband;
avg_chan_avg = gen_fvect(numchan);
std_chan_avg = gen_fvect(numchan);
pow_chan_avg = gen_fvect(numchan);
avg_int_avg = gen_fvect(numint);
std_int_avg = gen_fvect(numint);
pow_int_avg = gen_fvect(numint);
avg_chan_med = gen_fvect(numchan);
std_chan_med = gen_fvect(numchan);
pow_chan_med = gen_fvect(numchan);
avg_int_med = gen_fvect(numint);
std_int_med = gen_fvect(numint);
pow_int_med = gen_fvect(numint);
avg_chan_std = gen_fvect(numchan);
std_chan_std = gen_fvect(numchan);
pow_chan_std = gen_fvect(numchan);
avg_int_std = gen_fvect(numint);
std_int_std = gen_fvect(numint);
pow_int_std = gen_fvect(numint);
chans = gen_fvect(numchan);
freqs = gen_fvect(numchan);
for (ii = 0; ii < numchan; ii++) {
chans[ii] = ii;
freqs[ii] = idata->freq + ii * idata->chan_wid;
}
ints = gen_fvect(numint);
times = gen_fvect(numint);
for (ii = 0; ii < numint; ii++) {
ints[ii] = ii;
times[ii] = 0.0 + ii * inttim;
}
/* Calculate the statistics of the full set */
ct = numchan * numint;
calc_avgmedstd(dataavg[0], ct, 0.8, 1, &dataavg_avg, &dataavg_med, &dataavg_std);
calc_avgmedstd(datastd[0], ct, 0.8, 1, &datastd_avg, &datastd_med, &datastd_std);
calc_avgmedstd(datapow[0], ct, 0.5, 1, &datapow_avg, &datapow_med, &datapow_std);
avg_reject = timesigma * dataavg_std;
std_reject = timesigma * datastd_std;
pow_reject = power_for_sigma(freqsigma, 1, ptsperint / 2);
/* Calculate the channel/integration statistics vectors */
for (ii = 0; ii < numint; ii++) {
calc_avgmedstd(dataavg[0] + ii * numchan, numchan, 0.8, 1,
avg_int_avg + ii, avg_int_med + ii, avg_int_std + ii);
calc_avgmedstd(datastd[0] + ii * numchan, numchan, 0.8, 1,
std_int_avg + ii, std_int_med + ii, std_int_std + ii);
calc_avgmedstd(datapow[0] + ii * numchan, numchan, 0.5, 1,
pow_int_avg + ii, pow_int_med + ii, pow_int_std + ii);
}
for (ii = 0; ii < numchan; ii++) {
calc_avgmedstd(dataavg[0] + ii, numint, 0.8, numchan,
avg_chan_avg + ii, avg_chan_med + ii, avg_chan_std + ii);
calc_avgmedstd(datastd[0] + ii, numint, 0.8, numchan,
std_chan_avg + ii, std_chan_med + ii, std_chan_std + ii);
calc_avgmedstd(datapow[0] + ii, numint, 0.5, numchan,
pow_chan_avg + ii, pow_chan_med + ii, pow_chan_std + ii);
/*
fprintf(stderr, "%12.7g %12.7g %12.7g %12.7g %12.7g %12.7g %12.7g %12.7g %12.7g \n",
avg_chan_avg[ii], avg_chan_med[ii], avg_chan_std[ii],
std_chan_avg[ii], std_chan_med[ii], std_chan_std[ii],
pow_chan_avg[ii], pow_chan_med[ii], pow_chan_std[ii]);
*/
}
/* Generate the byte mask */
/* Set the channels/intervals picked by the user */
if (numuserints)
for (ii = 0; ii < numuserints; ii++)
if (userints[ii] >= 0 && userints[ii] < numint)
for (jj = 0; jj < numchan; jj++)
bytemask[userints[ii]][jj] |= USERINTS;
if (numuserchan)
for (ii = 0; ii < numuserchan; ii++)
if (userchan[ii] >= 0 && userchan[ii] < numchan)
for (jj = 0; jj < numint; jj++)
bytemask[jj][userchan[ii]] |= USERCHAN;
/* Compare each point in an interval (or channel) with */
/* the interval's (or channel's) median and the overall */
/* standard deviation. If the channel/integration */
/* medians are more than sigma different than the global */
/* value, set them to the global. */
{
float int_med, chan_med;
for (ii = 0; ii < numint; ii++) {
for (jj = 0; jj < numchan; jj++) {
{ /* Powers */
if (datapow[ii][jj] > pow_reject)
if (!(bytemask[ii][jj] & PADDING))
bytemask[ii][jj] |= BAD_POW;
}
{ /* Averages */
if (fabs(avg_int_med[ii] - dataavg_med) > timesigma * dataavg_std)
int_med = dataavg_med;
else
int_med = avg_int_med[ii];
if (fabs(avg_chan_med[jj] - dataavg_med) > timesigma * dataavg_std)
chan_med = dataavg_med;
else
chan_med = avg_chan_med[jj];
if (fabs(dataavg[ii][jj] - int_med) > avg_reject ||
fabs(dataavg[ii][jj] - chan_med) > avg_reject)
if (!(bytemask[ii][jj] & PADDING))
bytemask[ii][jj] |= BAD_AVG;
}
{ /* Standard Deviations */
if (fabs(std_int_med[ii] - datastd_med) > timesigma * datastd_std)
int_med = datastd_med;
else
int_med = std_int_med[ii];
if (fabs(std_chan_med[jj] - datastd_med) > timesigma * datastd_std)
chan_med = datastd_med;
else
chan_med = std_chan_med[jj];
if (fabs(datastd[ii][jj] - int_med) > std_reject ||
fabs(datastd[ii][jj] - chan_med) > std_reject)
if (!(bytemask[ii][jj] & PADDING))
bytemask[ii][jj] |= BAD_STD;
}
}
}
}
/* Step over the intervals and channels and count how many are set "bad". */
/* For a given interval, if the number of bad channels is greater than */
/* chantrigfrac*numchan then reject the whole interval. */
/* For a given channel, if the number of bad intervals is greater than */
/* inttrigfrac*numint then reject the whole channel. */
{
int badnum, trignum;
/* Loop over the intervals */
trignum = (int) (numchan * chantrigfrac);
for (ii = 0; ii < numint; ii++) {
if (!(bytemask[ii][0] & USERINTS)) {
badnum = 0;
for (jj = 0; jj < numchan; jj++)
if (bytemask[ii][jj] & BADDATA)
badnum++;
if (badnum > trignum) {
userints[numuserints++] = ii;
for (jj = 0; jj < numchan; jj++)
bytemask[ii][jj] |= USERINTS;
}
}
}
/* Loop over the channels */
trignum = (int) (numint * inttrigfrac);
for (ii = 0; ii < numchan; ii++) {
if (!(bytemask[0][ii] & USERCHAN)) {
badnum = 0;
for (jj = 0; jj < numint; jj++)
if (bytemask[jj][ii] & BADDATA)
badnum++;
if (badnum > trignum) {
userchan[numuserchan++] = ii;
for (jj = 0; jj < numint; jj++)
bytemask[jj][ii] |= USERCHAN;
}
}
}
}
/* Generate the New Mask */
fill_mask(timesigma, freqsigma, idata->mjd_i + idata->mjd_f,
ptsperint * idata->dt, idata->freq, idata->chan_wid,
numchan, numint, ptsperint, numuserchan, userchan,
numuserints, userints, bytemask, newmask);
/* Place the oldmask over the newmask for plotting purposes */
if (oldmask->numchan)
set_oldmask_bits(oldmask, bytemask);
/*
* Now plot the results
*/
if (xwin)
loops = 2;
for (ct = 0; ct < loops; ct++) { /* PS/XWIN Plot Loop */
float min, max, tr[6], locut, hicut;
float left, right, top, bottom;
float xl, xh, yl, yh;
float tt, ft, th, fh; /* thin and fat thicknesses and heights */
float lm, rm, tm, bm; /* LRTB margins */
float xarr[2], yarr[2];
char outdev[100];
int ii, mincol, maxcol, numcol;
/*Set the PGPLOT device to an X-Window */
if (ct == 1)
strcpy(outdev, "/XWIN");
else
sprintf(outdev, "%s.ps/CPS", idata->name);
/* Open and prep our device */
cpgopen(outdev);
cpgpap(10.25, 8.5 / 11.0);
cpgpage();
cpgiden();
cpgsch(0.7);
cpgqcir(&mincol, &maxcol);
numcol = maxcol - mincol + 1;
for (ii = mincol; ii <= maxcol; ii++) {
float color;
color = (float) (maxcol - ii) / (float) numcol;
cpgscr(ii, color, color, color);
}
/* Set thicknesses and margins */
lm = 0.04;
rm = 0.04;
bm = 0.08;
tm = 0.05;
ft = 3.0; /* This sets fat thickness = 3 x thin thickness */
tt = 0.92 / (6.0 + 4.0 * ft);
ft *= tt;
fh = 0.55;
th = tt * 11.0 / 8.5;
{ /* Powers Histogram */
float *theo, *hist, *hpows, *tpows, maxhist = 0.0, maxtheo = 0.0;
int numhist = 40, numtheo = 200, bin, numpows;
double dtheo, dhist, spacing;
/* Calculate the predicted distribution of max powers */
numpows = numint * numchan;
find_min_max_arr(numpows, datapow[0], &min, &max);
min = (min < 5.0) ? log10(5.0 * 0.95) : log10(min * 0.95);
max = log10(max * 1.05);
dhist = (max - min) / numhist;
theo = gen_fvect(numtheo);
tpows = gen_fvect(numtheo);
hist = gen_fvect(numhist);
hpows = gen_fvect(numhist);
for (ii = 0; ii < numhist; ii++) {
hist[ii] = 0.0;
hpows[ii] = min + ii * dhist;
}
for (ii = 0; ii < numpows; ii++) {
bin = (*(datapow[0] + ii) == 0.0) ? 0 :
(log10(*(datapow[0] + ii)) - min) / dhist;
if (bin < 0)
bin = 0;
if (bin >= numhist)
bin = numhist;
hist[bin] += 1.0;
}
for (ii = 0; ii < numhist; ii++)
if (hist[ii] > maxhist)
maxhist = hist[ii];
maxhist *= 1.1;
dtheo = (max - min) / (double) (numtheo - 1);
for (ii = 0; ii < numtheo; ii++) {
tpows[ii] = min + ii * dtheo;
theo[ii] = single_power_pdf(pow(10.0, tpows[ii]),
ptsperint / 2) * numpows;
spacing = (pow(10.0, tpows[ii] + dhist) - pow(10.0, tpows[ii]));
theo[ii] *= spacing;
if (theo[ii] > maxtheo)
maxtheo = theo[ii];
}
maxtheo *= 1.1;
if (maxtheo > maxhist)
maxhist = maxtheo;
left = lm;
right = lm + ft + tt;
bottom = 0.80;
top = 0.96;
cpgsvp(left, right, bottom, top);
xl = min;
xh = max;
yl = 0.0;
yh = maxhist;
cpgswin(xl, xh, yl, yh);
cpgmtxt("L", 1.1, 0.5, 0.5, "Number");
cpgmtxt("B", 2.1, 0.5, 0.5, "Max Power");
cpgbin(numhist, hpows, hist, 0);
cpgscr(maxcol, 0.5, 0.5, 0.5);
cpgsci(maxcol); /* Grey */
cpgline(numtheo, tpows, theo);
xarr[0] = log10(power_for_sigma(freqsigma, 1, ptsperint / 2));
xarr[1] = xarr[0];
yarr[0] = yl;
yarr[1] = yh;
cpgsls(4); /* Dotted line */
cpgscr(maxcol, 1.0, 0.0, 0.0);
cpgsci(maxcol); /* Red */
cpgline(2, xarr, yarr);
cpgsls(1); /* Solid line */
cpgsci(1); /* Default color */
cpgbox("BCLNST", 0.0, 0, "BC", 0.0, 0);
vect_free(hist);
vect_free(theo);
vect_free(tpows);
vect_free(hpows);
}
/* Maximum Powers */
left = lm;
right = lm + ft;
bottom = bm;
top = bm + fh;
xl = 0.0;
xh = numchan;
yl = 0.0;
yh = T;
cpgsvp(left, right, bottom, top);
cpgswin(xl, xh, yl, yh);
cpgscr(maxcol, 1.0, 0.0, 0.0); /* Red */
locut = 0.0;
hicut = pow_reject;
tr[2] = tr[4] = 0.0;
tr[1] = (xh - xl) / numchan;
tr[0] = xl - (tr[1] / 2);
tr[5] = (yh - yl) / numint;
tr[3] = yl - (tr[5] / 2);
cpgimag(datapow[0], numchan, numint, 1, numchan, 1, numint, locut, hicut, tr);
cpgswin(xl, xh, yl, yh);
cpgbox("BNST", 0.0, 0, "BNST", 0.0, 0);
cpgmtxt("B", 2.6, 0.5, 0.5, "Channel");
cpgmtxt("L", 2.1, 0.5, 0.5, "Time (s)");
xl = lof;
xh = hif;
yl = 0.0;
yh = numint;
cpgswin(xl, xh, yl, yh);
cpgbox("CST", 0.0, 0, "CST", 0.0, 0);
/* Max Power Label */
left = lm + ft;
right = lm + ft + tt;
bottom = bm + fh;
top = bm + fh + th;
cpgsvp(left, right, bottom, top);
cpgswin(0.0, 1.0, 0.0, 1.0);
cpgscr(maxcol, 1.0, 0.0, 0.0);
cpgsci(maxcol); /* Red */
cpgptxt(0.5, 0.7, 0.0, 0.5, "Max");
cpgptxt(0.5, 0.3, 0.0, 0.5, "Power");
cpgsci(1); /* Default color */
/* Max Power versus Time */
left = lm + ft;
right = lm + ft + tt;
bottom = bm;
top = bm + fh;
cpgsvp(left, right, bottom, top);
find_min_max_arr(numint, pow_int_med, &min, &max);
xl = 0.0;
xh = 1.5 * pow_reject;
yl = 0.0;
yh = T;
cpgswin(xl, xh, yl, yh);
cpgbox("BCST", 0.0, 0, "BST", 0.0, 0);
cpgscr(maxcol, 1.0, 0.0, 0.0);
cpgsci(maxcol); /* Red */
yarr[0] = yl;
yarr[1] = yh;
xarr[0] = xarr[1] = datapow_med;
cpgline(2, xarr, yarr);
cpgsls(4); /* Dotted line */
xarr[0] = xarr[1] = pow_reject;
cpgline(2, xarr, yarr);
cpgsls(1); /* Solid line */
cpgsci(1); /* Default color */
cpgline(numint, pow_int_med, times);
yl = 0.0;
yh = numint;
cpgswin(xl, xh, yl, yh);
cpgbox("", 0.0, 0, "CMST", 0.0, 0);
/* cpgmtxt("R", 2.3, 0.5, 0.5, "Interval Number"); */
/* Max Power versus Channel */
left = lm;
right = lm + ft;
bottom = bm + fh;
top = bm + fh + th;
cpgsvp(left, right, bottom, top);
find_min_max_arr(numchan, pow_chan_med, &min, &max);
xl = 0.0;
xh = numchan;
yl = 0.0;
yh = 1.5 * pow_reject;
cpgswin(xl, xh, yl, yh);
cpgbox("BST", 0.0, 0, "BCST", 0.0, 0);
cpgscr(maxcol, 1.0, 0.0, 0.0);
cpgsci(maxcol); /* Red */
xarr[0] = xl;
xarr[1] = xh;
yarr[0] = yarr[1] = datapow_med;
cpgline(2, xarr, yarr);
cpgsls(4); /* Dotted line */
yarr[0] = yarr[1] = pow_reject;
cpgline(2, xarr, yarr);
cpgsls(1); /* Solid line */
cpgsci(1); /* Default color */
cpgline(numchan, chans, pow_chan_med);
xl = lof;
xh = hif;
cpgswin(xl, xh, yl, yh);
cpgbox("CMST", 0.0, 0, "", 0.0, 0);
cpgmtxt("T", 1.8, 0.5, 0.5, "Frequency (MHz)");
/* Standard Deviations */
left = lm + ft + 2.0 * tt;
right = lm + 2.0 * ft + 2.0 * tt;
bottom = bm;
top = bm + fh;
xl = 0.0;
xh = numchan;
yl = 0.0;
yh = T;
cpgsvp(left, right, bottom, top);
cpgswin(xl, xh, yl, yh);
cpgscr(mincol, 0.7, 1.0, 0.7); /* Light Green */
cpgscr(maxcol, 0.3, 1.0, 0.3); /* Dark Green */
locut = datastd_med - timesigma * datastd_std;
hicut = datastd_med + timesigma * datastd_std;
tr[2] = tr[4] = 0.0;
tr[1] = (xh - xl) / numchan;
tr[0] = xl - (tr[1] / 2);
tr[5] = (yh - yl) / numint;
tr[3] = yl - (tr[5] / 2);
cpgimag(datastd[0], numchan, numint, 1, numchan, 1, numint, locut, hicut, tr);
cpgswin(xl, xh, yl, yh);
cpgbox("BNST", 0.0, 0, "BNST", 0.0, 0);
cpgmtxt("B", 2.6, 0.5, 0.5, "Channel");
xl = lof;
xh = hif;
yl = 0.0;
yh = numint;
cpgswin(xl, xh, yl, yh);
cpgbox("CST", 0.0, 0, "CST", 0.0, 0);
/* Data Sigma Label */
left = lm + 2.0 * ft + 2.0 * tt;
right = lm + 2.0 * ft + 3.0 * tt;
bottom = bm + fh;
top = bm + fh + th;
cpgsvp(left, right, bottom, top);
cpgswin(0.0, 1.0, 0.0, 1.0);
cpgscr(maxcol, 0.0, 1.0, 0.0);
cpgsci(maxcol); /* Green */
cpgptxt(0.5, 0.7, 0.0, 0.5, "Data");
cpgptxt(0.5, 0.3, 0.0, 0.5, "Sigma");
cpgsci(1); /* Default color */
/* Data Sigma versus Time */
left = lm + 2.0 * ft + 2.0 * tt;
right = lm + 2.0 * ft + 3.0 * tt;
bottom = bm;
top = bm + fh;
cpgsvp(left, right, bottom, top);
xl = datastd_med - 2.0 * std_reject;
xh = datastd_med + 2.0 * std_reject;
yl = 0.0;
yh = T;
cpgswin(xl, xh, yl, yh);
cpgbox("BCST", 0.0, 0, "BST", 0.0, 0);
cpgscr(maxcol, 0.0, 1.0, 0.0);
cpgsci(maxcol); /* Green */
yarr[0] = yl;
yarr[1] = yh;
xarr[0] = xarr[1] = datastd_med;
cpgline(2, xarr, yarr);
cpgsls(4); /* Dotted line */
xarr[0] = xarr[1] = datastd_med + std_reject;
cpgline(2, xarr, yarr);
xarr[0] = xarr[1] = datastd_med - std_reject;
cpgline(2, xarr, yarr);
cpgsls(1); /* Solid line */
cpgsci(1); /* Default color */
cpgline(numint, std_int_med, times);
yl = 0.0;
yh = numint;
cpgswin(xl, xh, yl, yh);
cpgbox("", 0.0, 0, "CMST", 0.0, 0);
/* cpgmtxt("R", 2.3, 0.5, 0.5, "Interval Number"); */
/* Data Sigma versus Channel */
left = lm + ft + 2.0 * tt;
right = lm + 2.0 * ft + 2.0 * tt;
bottom = bm + fh;
top = bm + fh + th;
cpgsvp(left, right, bottom, top);
xl = 0.0;
xh = numchan;
yl = datastd_med - 2.0 * std_reject;
yh = datastd_med + 2.0 * std_reject;
cpgswin(xl, xh, yl, yh);
cpgbox("BST", 0.0, 0, "BCST", 0.0, 0);
cpgscr(maxcol, 0.0, 1.0, 0.0);
cpgsci(maxcol); /* Green */
xarr[0] = xl;
xarr[1] = xh;
yarr[0] = yarr[1] = datastd_med;
cpgline(2, xarr, yarr);
cpgsls(4); /* Dotted line */
yarr[0] = yarr[1] = datastd_med + std_reject;
cpgline(2, xarr, yarr);
yarr[0] = yarr[1] = datastd_med - std_reject;
cpgline(2, xarr, yarr);
cpgsls(1); /* Solid line */
cpgsci(1); /* Default color */
cpgline(numchan, chans, std_chan_med);
xl = lof;
xh = hif;
cpgswin(xl, xh, yl, yh);
cpgbox("CMST", 0.0, 0, "", 0.0, 0);
cpgmtxt("T", 1.8, 0.5, 0.5, "Frequency (MHz)");
/* Data Mean */
left = lm + 2.0 * ft + 4.0 * tt;
right = lm + 3.0 * ft + 4.0 * tt;
bottom = bm;
top = bm + fh;
xl = 0.0;
xh = numchan;
yl = 0.0;
yh = T;
cpgsvp(left, right, bottom, top);
cpgswin(xl, xh, yl, yh);
cpgscr(mincol, 0.7, 0.7, 1.0); /* Light Blue */
cpgscr(maxcol, 0.3, 0.3, 1.0); /* Dark Blue */
locut = dataavg_med - timesigma * dataavg_std;
hicut = dataavg_med + timesigma * dataavg_std;
tr[2] = tr[4] = 0.0;
tr[1] = (xh - xl) / numchan;
tr[0] = xl - (tr[1] / 2);
tr[5] = (yh - yl) / numint;
tr[3] = yl - (tr[5] / 2);
cpgimag(dataavg[0], numchan, numint, 1, numchan, 1, numint, locut, hicut, tr);
cpgswin(xl, xh, yl, yh);
cpgbox("BNST", 0.0, 0, "BNST", 0.0, 0);
cpgmtxt("B", 2.6, 0.5, 0.5, "Channel");
xl = lof;
xh = hif;
yl = 0.0;
yh = numint;
cpgswin(xl, xh, yl, yh);
cpgbox("CST", 0.0, 0, "CST", 0.0, 0);
/* Data Mean Label */
left = lm + 3.0 * ft + 4.0 * tt;
right = lm + 3.0 * ft + 5.0 * tt;
bottom = bm + fh;
top = bm + fh + th;
cpgsvp(left, right, bottom, top);
cpgswin(0.0, 1.0, 0.0, 1.0);
cpgscr(maxcol, 0.0, 0.0, 1.0);
cpgsci(maxcol); /* Blue */
cpgptxt(0.5, 0.7, 0.0, 0.5, "Data");
cpgptxt(0.5, 0.3, 0.0, 0.5, "Mean");
cpgsci(1); /* Default color */
/* Data Mean versus Time */
left = lm + 3.0 * ft + 4.0 * tt;
right = lm + 3.0 * ft + 5.0 * tt;
bottom = bm;
top = bm + fh;
cpgsvp(left, right, bottom, top);
xl = dataavg_med - 2.0 * avg_reject;
xh = dataavg_med + 2.0 * avg_reject;
yl = 0.0;
yh = T;
cpgswin(xl, xh, yl, yh);
cpgbox("BCST", 0.0, 0, "BST", 0.0, 0);
cpgscr(maxcol, 0.0, 0.0, 1.0);
cpgsci(maxcol); /* Blue */
yarr[0] = yl;
yarr[1] = yh;
xarr[0] = xarr[1] = dataavg_med;
cpgline(2, xarr, yarr);
cpgsls(4); /* Dotted line */
xarr[0] = xarr[1] = dataavg_med + avg_reject;
cpgline(2, xarr, yarr);
xarr[0] = xarr[1] = dataavg_med - avg_reject;
cpgline(2, xarr, yarr);
cpgsls(1); /* Solid line */
cpgsci(1); /* Default color */
cpgline(numint, avg_int_med, times);
yl = 0.0;
yh = numint;
cpgswin(xl, xh, yl, yh);
cpgbox("", 0.0, 0, "CMST", 0.0, 0);
/* Data Mean versus Channel */
left = lm + 2.0 * ft + 4.0 * tt;
right = lm + 3.0 * ft + 4.0 * tt;
bottom = bm + fh;
top = bm + fh + th;
cpgsvp(left, right, bottom, top);
xl = 0.0;
xh = numchan;
yl = dataavg_med - 2.0 * avg_reject;
yh = dataavg_med + 2.0 * avg_reject;
cpgswin(xl, xh, yl, yh);
cpgbox("BST", 0.0, 0, "BCST", 0.0, 0);
cpgscr(maxcol, 0.0, 0.0, 1.0);
cpgsci(maxcol); /* Blue */
xarr[0] = xl;
xarr[1] = xh;
yarr[0] = yarr[1] = dataavg_med;
cpgline(2, xarr, yarr);
cpgsls(4); /* Dotted line */
yarr[0] = yarr[1] = dataavg_med + avg_reject;
cpgline(2, xarr, yarr);
yarr[0] = yarr[1] = dataavg_med - avg_reject;
cpgline(2, xarr, yarr);
cpgsls(1); /* Solid line */
cpgsci(1); /* Default color */
cpgline(numchan, chans, avg_chan_med);
xl = lof;
xh = hif;
cpgswin(xl, xh, yl, yh);
cpgbox("CMST", 0.0, 0, "", 0.0, 0);
cpgmtxt("T", 1.8, 0.5, 0.5, "Frequency (MHz)");
{ /* Add the Data Info area */
char out[200], out2[100];
float dy = 0.025;
cpgsvp(0.0, 1.0, 0.0, 1.0);
cpgswin(0.0, 1.0, 0.0, 1.0);
left = lm + ft + 1.5 * tt;
top = 1.0 - tm;
cpgsch(1.0);
sprintf(out, "%-s", idata->name);
cpgptxt(0.5, 1.0 - 0.5 * tm, 0.0, 0.5, out);
cpgsch(0.8);
sprintf(out, "Object:");
cpgtext(left + 0.0, top - 0 * dy, out);
sprintf(out, "%-s", idata->object);
cpgtext(left + 0.1, top - 0 * dy, out);
sprintf(out, "Telescope:");
cpgtext(left + 0.0, top - 1 * dy, out);
sprintf(out, "%-s", idata->telescope);
cpgtext(left + 0.1, top - 1 * dy, out);
sprintf(out, "Instrument:");
cpgtext(left + 0.0, top - 2 * dy, out);
sprintf(out, "%-s", idata->instrument);
cpgtext(left + 0.1, top - 2 * dy, out);
ra_dec_to_string(out2, idata->ra_h, idata->ra_m, idata->ra_s);
sprintf(out, "RA\\dJ2000\\u");
cpgtext(left + 0.0, top - 3 * dy, out);
sprintf(out, "= %-s", out2);
cpgtext(left + 0.08, top - 3 * dy, out);
ra_dec_to_string(out2, idata->dec_d, idata->dec_m, idata->dec_s);
sprintf(out, "DEC\\dJ2000\\u");
cpgtext(left + 0.0, top - 4 * dy, out);
sprintf(out, "= %-s", out2);
cpgtext(left + 0.08, top - 4 * dy, out);
sprintf(out, "Epoch\\dtopo\\u");
cpgtext(left + 0.0, top - 5 * dy, out);
sprintf(out, "= %-.11f", idata->mjd_i + idata->mjd_f);
cpgtext(left + 0.08, top - 5 * dy, out);
sprintf(out, "T\\dsample\\u (s)");
cpgtext(left + 0.0, top - 6 * dy, out);
sprintf(out, "= %g", idata->dt);
cpgtext(left + 0.08, top - 6 * dy, out);
sprintf(out, "T\\dtotal\\u (s)");
cpgtext(left + 0.0, top - 7 * dy, out);
sprintf(out, "= %g", T);
cpgtext(left + 0.08, top - 7 * dy, out);
left = lm + ft + 7.8 * tt;
sprintf(out, "Num channels");
cpgtext(left + 0.0, top - 0 * dy, out);
sprintf(out, "= %-d", numchan);
cpgtext(left + 0.12, top - 0 * dy, out);
sprintf(out, "Pts per int");
cpgtext(left + 0.19, top - 0 * dy, out);
sprintf(out, "= %-d", ptsperint);
cpgtext(left + 0.29, top - 0 * dy, out);
sprintf(out, "Num intervals");
cpgtext(left + 0.0, top - 1 * dy, out);
sprintf(out, "= %-d", numint);
cpgtext(left + 0.12, top - 1 * dy, out);
sprintf(out, "Time per int");
cpgtext(left + 0.19, top - 1 * dy, out);
sprintf(out, "= %-g", inttim);
cpgtext(left + 0.29, top - 1 * dy, out);
sprintf(out, "Power:");
cpgtext(left + 0.0, top - 2 * dy, out);
sprintf(out, "median");
cpgtext(left + 0.06, top - 2 * dy, out);
sprintf(out, "= %-.3f", datapow_med);
cpgtext(left + 0.12, top - 2 * dy, out);
sprintf(out, "\\gs");
cpgtext(left + 0.21, top - 2 * dy, out);
sprintf(out, "= %-.3g", datapow_std);
cpgtext(left + 0.245, top - 2 * dy, out);
find_min_max_arr(numint * numchan, datapow[0], &min, &max);
sprintf(out, "min");
cpgtext(left + 0.06, top - 3 * dy, out);
sprintf(out, "= %-.3f", min);
cpgtext(left + 0.12, top - 3 * dy, out);
sprintf(out, "max");
cpgtext(left + 0.21, top - 3 * dy, out);
sprintf(out, "= %-.3f", max);
cpgtext(left + 0.245, top - 3 * dy, out);
sprintf(out, "Sigma:");
cpgtext(left + 0.0, top - 4 * dy, out);
sprintf(out, "median");
cpgtext(left + 0.06, top - 4 * dy, out);
sprintf(out, "= %-.3f", datastd_med);
cpgtext(left + 0.12, top - 4 * dy, out);
sprintf(out, "\\gs");
cpgtext(left + 0.21, top - 4 * dy, out);
sprintf(out, "= %-.3g", datastd_std);
cpgtext(left + 0.245, top - 4 * dy, out);
find_min_max_arr(numint * numchan, datastd[0], &min, &max);
sprintf(out, "min");
cpgtext(left + 0.06, top - 5 * dy, out);
sprintf(out, "= %-.3f", min);
cpgtext(left + 0.12, top - 5 * dy, out);
sprintf(out, "max");
cpgtext(left + 0.21, top - 5 * dy, out);
sprintf(out, "= %-.3f", max);
cpgtext(left + 0.245, top - 5 * dy, out);
sprintf(out, "Mean:");
cpgtext(left + 0.0, top - 6 * dy, out);
sprintf(out, "median");
cpgtext(left + 0.06, top - 6 * dy, out);
sprintf(out, "= %-.3f", dataavg_med);
cpgtext(left + 0.12, top - 6 * dy, out);
sprintf(out, "\\gs");
cpgtext(left + 0.21, top - 6 * dy, out);
sprintf(out, "= %-.3g", dataavg_std);
cpgtext(left + 0.245, top - 6 * dy, out);
find_min_max_arr(numint * numchan, dataavg[0], &min, &max);
sprintf(out, "min");
cpgtext(left + 0.06, top - 7 * dy, out);
sprintf(out, "= %-.3f", min);
cpgtext(left + 0.12, top - 7 * dy, out);
sprintf(out, "max");
cpgtext(left + 0.21, top - 7 * dy, out);
sprintf(out, "= %-.3f", max);
cpgtext(left + 0.245, top - 7 * dy, out);
}
{ /* Plot the Mask */
unsigned char byte;
char temp[200];
float **plotmask, rr, gg, bb, page;
plotmask = gen_fmatrix(numint, numchan);
for (ii = 0; ii < numint; ii++) {
for (jj = 0; jj < numchan; jj++) {
byte = bytemask[ii][jj];
plotmask[ii][jj] = 0.0;
if (byte & PADDING)
plotmask[ii][jj] = 1.0;
if (byte & OLDMASK)
plotmask[ii][jj] = 2.0;
if (byte & USERZAP)
plotmask[ii][jj] = 3.0;
if (byte & BAD_POW)
plotmask[ii][jj] = 4.0;
else if (byte & BAD_AVG)
plotmask[ii][jj] = 5.0;
else if (byte & BAD_STD)
plotmask[ii][jj] = 6.0;
}
}
/* Set the colors */
numcol = 7;
maxcol = mincol + numcol - 1;
cpgscir(mincol, maxcol);
cpgqcr(0, &rr, &gg, &bb);
cpgscr(mincol + 0, rr, gg, bb); /* GOODDATA = background */
cpgscr(mincol + 1, 0.7, 0.7, 0.7); /* PADDING = light grey */
cpgscr(mincol + 2, 0.3, 0.3, 0.3); /* OLDMASK = dark grey */
cpgqcr(1, &rr, &gg, &bb);
cpgscr(mincol + 3, rr, gg, bb); /* USERZAP = foreground */
cpgscr(mincol + 4, 1.0, 0.0, 0.0); /* BAD+POW = red */
cpgscr(mincol + 5, 0.0, 0.0, 1.0); /* BAD+AVG = blue */
cpgscr(mincol + 6, 0.0, 1.0, 0.0); /* BAD+STD = green */
/* Prep the image */
for (page = 0; page <= 1; page++) {
xl = 0.0;
xh = numchan;
yl = 0.0;
yh = T;
locut = 0.0;
hicut = 6.0;
tr[2] = tr[4] = 0.0;
tr[1] = (xh - xl) / numchan;
tr[0] = xl - (tr[1] / 2);
tr[5] = (yh - yl) / numint;
tr[3] = yl - (tr[5] / 2);
if (page == 0) {
left = lm + 3.0 * ft + 6.0 * tt;
right = lm + 4.0 * ft + 6.0 * tt;
bottom = bm;
top = bm + fh;
} else {
cpgpage();
cpgiden();
left = 0.06;
right = 0.94;
bottom = 0.06;
top = 0.88;
}
cpgsvp(left, right, bottom, top);
cpgswin(xl, xh, yl, yh);
cpgimag(plotmask[0], numchan, numint, 1,
numchan, 1, numint, locut, hicut, tr);
cpgswin(xl, xh, yl, yh);
cpgbox("BNST", 0.0, 0, "BNST", 0.0, 0);
cpgmtxt("B", 2.6, 0.5, 0.5, "Channel");
if (page)
cpgmtxt("L", 2.1, 0.5, 0.5, "Time (s)");
xl = lof;
xh = hif;
yl = 0.0;
yh = numint;
cpgswin(xl, xh, yl, yh);
cpgbox("CMST", 0.0, 0, "CMST", 0.0, 0);
cpgmtxt("T", 1.8, 0.5, 0.5, "Frequency (MHz)");
cpgmtxt("R", 2.3, 0.5, 0.5, "Interval Number");
/* Add the Labels */
cpgsvp(0.0, 1.0, 0.0, 1.0);
cpgswin(0.0, 1.0, 0.0, 1.0);
cpgsch(0.8);
if (page == 0) {
cpgsci(mincol + 1);
cpgptxt(left, top + 0.1, 0.0, 0.0, "Padding");
cpgsci(mincol + 2);
cpgptxt(left, top + 0.08, 0.0, 0.0, "Old Mask");
cpgsci(mincol + 3);
cpgptxt(left, top + 0.06, 0.0, 0.0, "User Zap");
cpgsci(mincol + 4);
cpgptxt(right, top + 0.1, 0.0, 1.0, "Power");
cpgsci(mincol + 6);
cpgptxt(right, top + 0.08, 0.0, 1.0, "Sigma");
cpgsci(mincol + 5);
cpgptxt(right, top + 0.06, 0.0, 1.0, "Mean");
cpgsci(1);
} else {
cpgsci(mincol + 1);
cpgptxt(1.0 / 12.0, 0.955, 0.0, 0.5, "Padding");
cpgsci(mincol + 2);
cpgptxt(3.0 / 12.0, 0.955, 0.0, 0.5, "Old Mask");
cpgsci(mincol + 3);
cpgptxt(5.0 / 12.0, 0.955, 0.0, 0.5, "User Zap");
cpgsci(mincol + 4);
cpgptxt(7.0 / 12.0, 0.955, 0.0, 0.5, "Max Power");
cpgsci(mincol + 6);
cpgptxt(9.0 / 12.0, 0.955, 0.0, 0.5, "Data Sigma");
cpgsci(mincol + 5);
cpgptxt(11.0 / 12.0, 0.955, 0.0, 0.5, "Data Mean");
cpgsci(1);
cpgsch(0.9);
sprintf(temp, "Recommended Mask for '%-s'", idata->name);
cpgptxt(0.5, 0.985, 0.0, 0.5, temp);
}
}
vect_free(plotmask[0]);
vect_free(plotmask);
}
if (ct == 0)
printf("There are %d RFI instances.\n\n", numrfi);
if ((ct == 0 && rfips) || (ct == 1 && rfixwin)) { /* Plot the RFI instances */
int maxcol, mincol, numperpage = 25, numtoplot;
float dy = 0.035, top = 0.95, rr, gg, bb;
char temp[200];
qsort(rfivect, numrfi, sizeof(rfi), compare_rfi_freq);
/* qsort(rfivect, numrfi, sizeof(rfi), compare_rfi_sigma); */
for (ii = 0; ii <= (numrfi - 1) / numperpage; ii++) {
cpgpage();
cpgiden();
cpgsvp(0.0, 1.0, 0.0, 1.0);
cpgswin(0.0, 1.0, 0.0, 1.0);
cpgsch(0.8);
sprintf(temp, "%-s", idata->name);
cpgtext(0.05, 0.985, temp);
cpgsch(0.6);
sprintf(temp, "Freq (Hz)");
cpgptxt(0.03, 0.96, 0.0, 0.0, temp);
sprintf(temp, "Period (ms)");
cpgptxt(0.12, 0.96, 0.0, 0.0, temp);
sprintf(temp, "Sigma");
cpgptxt(0.21, 0.96, 0.0, 0.0, temp);
sprintf(temp, "Number");
cpgptxt(0.27, 0.96, 0.0, 0.0, temp);
cpgsvp(0.33, 0.64, top - dy, top);
cpgswin(lof, hif, 0.0, 1.0);
cpgbox("CIMST", 0.0, 0, "", 0.0, 0);
cpgmtxt("T", 2.5, 0.5, 0.5, "Frequency (MHz)");
cpgsvp(0.65, 0.96, top - dy, top);
cpgswin(0.0, T, 0.0, 1.0);
cpgbox("CIMST", 0.0, 0, "", 0.0, 0);
cpgmtxt("T", 2.5, 0.5, 0.5, "Time (s)");
cpgqcir(&mincol, &maxcol);
maxcol = mincol + 1;
cpgscir(mincol, maxcol);
cpgqcr(0, &rr, &gg, &bb);
cpgscr(mincol, rr, gg, bb); /* background */
cpgqcr(1, &rr, &gg, &bb);
/* cpgscr(maxcol, rr, gg, bb); foreground */
cpgscr(maxcol, 0.5, 0.5, 0.5); /* grey */
if (ii == (numrfi - 1) / numperpage)
numtoplot = numrfi % numperpage;
else
numtoplot = numperpage;
for (jj = 0; jj < numtoplot; jj++)
plot_rfi(rfivect + ii * numperpage + jj,
top - jj * dy, numint, numchan, T, lof, hif);
cpgsvp(0.33, 0.64, top - jj * dy, top - (jj - 1) * dy);
cpgswin(0.0, numchan, 0.0, 1.0);
cpgbox("BINST", 0.0, 0, "", 0.0, 0);
cpgmtxt("B", 2.5, 0.5, 0.5, "Channel");
cpgsvp(0.65, 0.96, top - jj * dy, top - (jj - 1) * dy);
cpgswin(0.0, numint, 0.0, 1.0);
cpgbox("BINST", 0.0, 0, "", 0.0, 0);
cpgmtxt("B", 2.5, 0.5, 0.5, "Interval");
}
}
cpgclos();
} /* Plot for loop */
/* Free our arrays */
vect_free(freqs);
vect_free(chans);
vect_free(times);
vect_free(ints);
vect_free(avg_chan_avg);
vect_free(std_chan_avg);
vect_free(pow_chan_avg);
vect_free(avg_int_avg);
vect_free(std_int_avg);
vect_free(pow_int_avg);
vect_free(avg_chan_med);
vect_free(std_chan_med);
vect_free(pow_chan_med);
vect_free(avg_int_med);
vect_free(std_int_med);
vect_free(pow_int_med);
vect_free(avg_chan_std);
vect_free(std_chan_std);
vect_free(pow_chan_std);
vect_free(avg_int_std);
vect_free(std_int_std);
vect_free(pow_int_std);
}
int main(int argc, char *argv[])
{
float maxpow = 0.0, inx = 0.0, iny = 0.0;
double centerr, offsetf;
int zoomlevel, maxzoom, minzoom, xid, psid;
char *rootfilenm, inchar;
fftpart *lofp;
fftview *fv;
if (argc == 1) {
printf("\nusage: explorefft fftfilename\n\n");
exit(0);
}
printf("\n\n");
printf(" Interactive FFT Explorer\n");
printf(" by Scott M. Ransom\n");
printf(" October, 2001\n");
print_help();
{
int hassuffix = 0;
char *suffix;
hassuffix = split_root_suffix(argv[1], &rootfilenm, &suffix);
if (hassuffix) {
if (strcmp(suffix, "fft") != 0) {
printf("\nInput file ('%s') must be a FFT file ('.fft')!\n\n", argv[1]);
free(suffix);
exit(0);
}
free(suffix);
} else {
printf("\nInput file ('%s') must be a FFT file ('.fft')!\n\n", argv[1]);
exit(0);
}
}
/* Read the info file */
readinf(&idata, rootfilenm);
if (strlen(remove_whitespace(idata.object)) > 0) {
printf("Examining %s data from '%s'.\n\n",
remove_whitespace(idata.object), argv[1]);
} else {
printf("Examining data from '%s'.\n\n", argv[1]);
}
N = idata.N;
T = idata.dt * idata.N;
#ifdef USEMMAP
printf("Memory mapping the input FFT. This may take a while...\n");
mmap_file = open(argv[1], O_RDONLY);
{
int rt;
struct stat buf;
rt = fstat(mmap_file, &buf);
if (rt == -1) {
perror("\nError in fstat() in explorefft.c");
printf("\n");
exit(-1);
}
Nfft = buf.st_size / sizeof(fcomplex);
}
lofp = get_fftpart(0, Nfft);
#else
{
int numamps;
fftfile = chkfopen(argv[1], "rb");
Nfft = chkfilelen(fftfile, sizeof(fcomplex));
numamps = (Nfft > MAXBINS) ? (int) MAXBINS : (int) Nfft;
lofp = get_fftpart(0, numamps);
}
#endif
/* Plot the initial data */
{
int initnumbins = INITIALNUMBINS;
if (initnumbins > Nfft) {
initnumbins = next2_to_n(Nfft) / 2;
zoomlevel = LOGDISPLAYNUM - (int) (log(initnumbins) / log(2.0));
minzoom = zoomlevel;
} else {
zoomlevel = LOGDISPLAYNUM - LOGINITIALNUMBINS;
minzoom = LOGDISPLAYNUM - LOGMAXBINS;
}
maxzoom = LOGDISPLAYNUM - LOGMINBINS;
centerr = initnumbins / 2;
}
fv = get_fftview(centerr, zoomlevel, lofp);
/* Prep the XWIN device for PGPLOT */
xid = cpgopen("/XWIN");
if (xid <= 0) {
free(fv);
#ifdef USEMMAP
close(mmap_file);
#else
fclose(fftfile);
#endif
free_fftpart(lofp);
exit(EXIT_FAILURE);
}
cpgscr(15, 0.4, 0.4, 0.4);
cpgask(0);
cpgpage();
offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
do {
cpgcurs(&inx, &iny, &inchar);
if (DEBUGOUT)
printf("You pressed '%c'\n", inchar);
switch (inchar) {
case 'A': /* Zoom in */
case 'a':
centerr = (inx + offsetf) * T;
case 'I':
case 'i':
if (DEBUGOUT)
printf(" Zooming in (zoomlevel = %d)...\n", zoomlevel);
if (zoomlevel < maxzoom) {
zoomlevel++;
free(fv);
fv = get_fftview(centerr, zoomlevel, lofp);
cpgpage();
offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
} else
printf(" Already at maximum zoom level (%d).\n", zoomlevel);
break;
case 'X': /* Zoom out */
case 'x':
case 'O':
case 'o':
if (DEBUGOUT)
printf(" Zooming out (zoomlevel = %d)...\n", zoomlevel);
if (zoomlevel > minzoom) {
zoomlevel--;
free(fv);
fv = get_fftview(centerr, zoomlevel, lofp);
cpgpage();
offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
} else
printf(" Already at minimum zoom level (%d).\n", zoomlevel);
break;
case '<': /* Shift left 1 full screen */
centerr -= fv->numbins + fv->numbins / 8;
case ',': /* Shift left 1/8 screen */
if (DEBUGOUT)
printf(" Shifting left...\n");
centerr -= fv->numbins / 8;
{ /* Should probably get the previous chunk from the fftfile... */
double lowestr;
lowestr = 0.5 * fv->numbins;
if (centerr < lowestr)
centerr = lowestr;
}
free(fv);
fv = get_fftview(centerr, zoomlevel, lofp);
cpgpage();
offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
break;
case '>': /* Shift right 1 full screen */
centerr += fv->numbins - fv->numbins / 8;
case '.': /* Shift right 1/8 screen */
if (DEBUGOUT)
printf(" Shifting right...\n");
centerr += fv->numbins / 8;
{ /* Should probably get the next chunk from the fftfile... */
double highestr;
highestr = lofp->rlo + lofp->numamps - 0.5 * fv->numbins;
if (centerr > highestr)
centerr = highestr;
}
free(fv);
fv = get_fftview(centerr, zoomlevel, lofp);
cpgpage();
offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
break;
case '+': /* Increase height of powers */
case '=':
if (maxpow == 0.0) {
printf(" Auto-scaling is off.\n");
maxpow = 1.1 * fv->maxpow;
}
maxpow = 3.0 / 4.0 * maxpow;
cpgpage();
offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
break;
case '-': /* Decrease height of powers */
case '_':
if (maxpow == 0.0) {
printf(" Auto-scaling is off.\n");
maxpow = 1.1 * fv->maxpow;
}
maxpow = 4.0 / 3.0 * maxpow;
cpgpage();
offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
break;
case 'S': /* Auto-scale */
case 's':
if (maxpow == 0.0)
break;
else {
printf(" Auto-scaling is on.\n");
maxpow = 0.0;
cpgpage();
offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
break;
}
case 'G': /* Goto a frequency */
case 'g':
{
char freqstr[50];
double freq = -1.0;
while (freq < 0.0) {
printf(" Enter the frequency (Hz) to go to:\n");
fgets(freqstr, 50, stdin);
freqstr[strlen(freqstr) - 1] = '\0';
freq = atof(freqstr);
}
offsetf = 0.0;
centerr = freq * T;
printf(" Moving to frequency %.15g.\n", freq);
free(fv);
fv = get_fftview(centerr, zoomlevel, lofp);
cpgpage();
offsetf = plot_fftview(fv, maxpow, 1.0, centerr, 2);
}
break;
case 'H': /* Show harmonics */
case 'h':
{
double retval;
retval = harmonic_loop(xid, centerr, zoomlevel, lofp);
if (retval > 0.0) {
offsetf = 0.0;
centerr = retval;
free(fv);
fv = get_fftview(centerr, zoomlevel, lofp);
cpgpage();
offsetf = plot_fftview(fv, maxpow, 1.0, centerr, 2);
}
}
break;
case '?': /* Print help screen */
print_help();
break;
case 'D': /* Show details about a selected point */
case 'd':
{
double newr;
printf(" Searching for peak near freq = %.7g Hz...\n", (inx + offsetf));
newr = find_peak(inx + offsetf, fv, lofp);
centerr = newr;
free(fv);
fv = get_fftview(centerr, zoomlevel, lofp);
cpgpage();
offsetf = plot_fftview(fv, maxpow, 1.0, centerr, 2);
}
break;
case 'L': /* Load a zaplist */
case 'l':
{
int ii, len;
char filename[200];
double *lobins, *hibins;
printf(" Enter the filename containing the zaplist to load:\n");
fgets(filename, 199, stdin);
len = strlen(filename) - 1;
filename[len] = '\0';
numzaplist = get_birdies(filename, T, 0.0, &lobins, &hibins);
lenzaplist = numzaplist + 20; /* Allow some room to add more */
if (lenzaplist)
free(zaplist);
zaplist = (bird *) malloc(sizeof(bird) * lenzaplist);
for (ii = 0; ii < numzaplist; ii++) {
zaplist[ii].lobin = lobins[ii];
zaplist[ii].hibin = hibins[ii];
}
vect_free(lobins);
vect_free(hibins);
printf("\n");
cpgpage();
offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
}
break;
case 'Z': /* Add a birdie to a zaplist */
case 'z':
{
int badchoice = 2;
float lox, hix, loy, hiy;
double rs[2];
char choice;
if (numzaplist + 1 > lenzaplist) {
lenzaplist += 10;
zaplist = (bird *) realloc(zaplist, sizeof(bird) * lenzaplist);
}
cpgqwin(&lox, &hix, &loy, &hiy);
printf(" Click the left mouse button on the first frequency limit.\n");
while (badchoice) {
cpgcurs(&inx, &iny, &choice);
if (choice == 'A' || choice == 'a') {
rs[2 - badchoice] = ((double) inx + offsetf) * T;
cpgsave();
cpgsci(7);
cpgmove(inx, 0.0);
cpgdraw(inx, hiy);
cpgunsa();
badchoice--;
if (badchoice == 1)
printf
(" Click the left mouse button on the second frequency limit.\n");
} else {
printf(" Option not recognized.\n");
}
};
if (rs[1] > rs[0]) {
zaplist[numzaplist].lobin = rs[0];
zaplist[numzaplist].hibin = rs[1];
} else {
zaplist[numzaplist].lobin = rs[1];
zaplist[numzaplist].hibin = rs[0];
}
printf(" The new birdie has: f_avg = %.15g f_width = %.15g\n\n",
0.5 * (zaplist[numzaplist].hibin + zaplist[numzaplist].lobin) / T,
(zaplist[numzaplist].hibin - zaplist[numzaplist].lobin) / T);
numzaplist++;
qsort(zaplist, numzaplist, sizeof(bird), compare_birds);
cpgpage();
offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
}
break;
case 'P': /* Print the current plot */
case 'p':
{
int len;
char filename[200];
printf(" Enter the filename to save the plot as:\n");
fgets(filename, 196, stdin);
len = strlen(filename) - 1;
filename[len + 0] = '/';
filename[len + 1] = 'P';
filename[len + 2] = 'S';
filename[len + 3] = '\0';
psid = cpgopen(filename);
cpgslct(psid);
cpgpap(10.25, 8.5 / 11.0);
cpgiden();
cpgscr(15, 0.8, 0.8, 0.8);
offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
cpgclos();
cpgslct(xid);
cpgscr(15, 0.4, 0.4, 0.4);
filename[len] = '\0';
printf(" Wrote the plot to the file '%s'.\n", filename);
}
break;
case 'N': /* Changing power normalization */
case 'n':
{
float inx2 = 0.0, iny2 = 0.0;
char choice;
unsigned char badchoice = 1;
printf(" Specify the type of power normalization:\n"
" m,M : Median values determined locally\n"
" d,D : DC frequency amplitude\n"
" r,R : Raw powers (i.e. no normalization)\n"
" u,U : User specified interval (the average powers)\n");
while (badchoice) {
cpgcurs(&inx2, &iny2, &choice);
switch (choice) {
case 'M':
case 'm':
norm_const = 0.0;
maxpow = 0.0;
badchoice = 0;
printf
(" Using local median normalization. Autoscaling is on.\n");
break;
case 'D':
case 'd':
norm_const = 1.0 / r0;
maxpow = 0.0;
badchoice = 0;
printf
(" Using DC frequency (%f) normalization. Autoscaling is on.\n",
r0);
break;
case 'R':
case 'r':
norm_const = 1.0;
maxpow = 0.0;
badchoice = 0;
printf
(" Using raw powers (i.e. no normalization). Autoscaling is on.\n");
break;
case 'U':
case 'u':
{
char choice2;
float xx = inx, yy = iny;
int lor, hir, numr;
double avg, var;
printf
(" Use the left mouse button to select a left and right boundary\n"
" of a region to calculate the average power.\n");
do {
cpgcurs(&xx, &yy, &choice2);
} while (choice2 != 'A' && choice2 != 'a');
lor = (int) ((xx + offsetf) * T);
cpgsci(7);
cpgmove(xx, 0.0);
cpgdraw(xx, 10.0 * fv->maxpow);
do {
cpgcurs(&xx, &yy, &choice2);
} while (choice2 != 'A' && choice2 != 'a');
hir = (int) ((xx + offsetf) * T);
cpgmove(xx, 0.0);
cpgdraw(xx, 10.0 * fv->maxpow);
cpgsci(1);
if (lor > hir) {
int tempr;
tempr = hir;
hir = lor;
lor = tempr;
}
numr = hir - lor + 1;
avg_var(lofp->rawpowers + lor - lofp->rlo, numr, &avg, &var);
printf(" Selection has: average = %.5g\n"
" std dev = %.5g\n", avg, sqrt(var));
norm_const = 1.0 / avg;
maxpow = 0.0;
badchoice = 0;
printf
(" Using %.5g as the normalization constant. Autoscaling is on.\n",
avg);
break;
}
default:
printf(" Unrecognized choice '%c'.\n", choice);
break;
}
}
free(fv);
fv = get_fftview(centerr, zoomlevel, lofp);
cpgpage();
offsetf = plot_fftview(fv, maxpow, 1.0, 0.0, 0);
}
break;
case 'Q': /* Quit */
case 'q':
printf(" Quitting...\n");
free(fv);
cpgclos();
break;
default:
printf(" Unrecognized option '%c'.\n", inchar);
break;
}
} while (inchar != 'Q' && inchar != 'q');
free_fftpart(lofp);
#ifdef USEMMAP
close(mmap_file);
#else
fclose(fftfile);
#endif
if (lenzaplist)
free(zaplist);
printf("Done\n\n");
return 0;
}
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;
}
int main(int argc, char *argv[])
{
FILE *infile;
int numchan, numtodisplay = 0, numprofs = 0;
long i, j, proflen, offset;
double *profs, *sumprof, nc, pl, tt, bt, p, f, df, rotate = 0.0;
double dm = 0.0, bindelay = 0.0;
char device[200], output[200];
if (argc <= 2) {
printf("usage: showmulti_dm filename dm [rotate] [numtodisplay] [device]\n");
printf(" 'filename' (required) is the multi-profile save file.\n");
printf(" 'dm' (required) DM to base profile delays on.\n");
printf(" 'rotate' (optional) is the number of bins to rotate\n");
printf(" each profile to the left.\n");
printf(" Can be fractional. Default is 0.\n");
printf(" 'numtodisplay' (optional) is the number of profiles to\n");
printf(" display at once. Defaults to\n");
printf(" the number of channels.\n");
printf(" 'device' (optional) is the pgplot device to use ('x' or\n");
printf(" 'ps'). Defaults to 'x'\n");
exit(1);
}
infile = chkfopen(argv[1], "rb");
sprintf(output, "%s.ps", argv[1]);
chkfread(&nc, sizeof(double), 1, infile);
chkfread(&pl, sizeof(double), 1, infile);
chkfread(&p, sizeof(double), 1, infile);
chkfread(&tt, sizeof(double), 1, infile);
chkfread(&bt, sizeof(double), 1, infile);
chkfread(&f, sizeof(double), 1, infile);
chkfread(&df, sizeof(double), 1, infile);
numchan = nc;
proflen = pl;
if (argc == 3) {
dm = strtod(argv[2], NULL);
rotate = 0.0;
strcpy(device, "x");
} else if (argc == 4) {
dm = strtod(argv[2], NULL);
rotate = strtod(argv[3], NULL);
numtodisplay = numchan;
strcpy(device, "x");
} else if (argc == 5) {
dm = strtod(argv[2], NULL);
rotate = strtod(argv[3], NULL);
numtodisplay = (int) strtol(argv[4], NULL, 10);
strcpy(device, "x");
} else if (argc == 6) {
dm = strtod(argv[2], NULL);
rotate = strtod(argv[3], NULL);
numtodisplay = (int) strtol(argv[4], NULL, 10);
strcpy(device, argv[5]);
}
printf("\n Multi-Profile Display Program\n");
printf(" With DM Delay Correction\n");
printf(" Scott M. Ransom\n");
printf(" 20 July 1998\n");
printf("\nProfile properties:\n");
printf("Initial folding period (s) = %-15.13f\n", p);
printf("Topocentric time (start) = %-15.10f\n", tt);
printf("Barycentric time (start) = %-15.10f\n", bt);
printf("Profile length (bins) = %-ld\n", proflen);
printf("Number of channels = %-d\n", numchan);
printf("Channel 1 frequency (MHz) = %-10.5f\n", f);
printf("Channel freq width (MHz) = %-10.5f\n", df);
printf("Dispersion Measure (cm-3 pc) = %-10.5f\n\n", dm);
/* Read the profiles. */
profs = gen_dvect(proflen * numchan);
chkfread(profs, sizeof(double), (unsigned long) (numchan * proflen), infile);
fclose(infile);
/* Create a Summed-Profile vector */
sumprof = gen_dvect(proflen);
for (i = 0; i < proflen; i++) {
sumprof[i] = 0.0;
}
/* Rotate the vectors and sum the profiles */
for (i = 0; i < numchan; i++) {
bindelay = delay_from_dm(dm, f + i * df) * (double) proflen / p;
drotate(&profs[i * proflen], proflen, bindelay);
if (rotate)
drotate(&profs[i * proflen], proflen, rotate);
for (j = 0; j < proflen; j++) {
sumprof[j] += profs[i * proflen + j];
}
}
/* Plot the profiles */
if (0 == strcmp("x", device))
cpgstart_x("portrait");
else
cpgstart_ps(output, "portrait");
for (i = 0; i <= numchan / numtodisplay; i++) {
offset = i * numtodisplay;
numprofs = (numchan - offset) > numtodisplay ? numtodisplay : numchan - offset;
if (numprofs > 0) {
cpgpage();
multi_prof_plot(proflen, numprofs, profs + offset * proflen,
sumprof, "Pulse Phase (Periods)",
(double) (1.0 + offset), 1.0, "Channel Number",
f + offset * df, df, "Frequency (MHz)");
}
}
cpgend();
/* Cleanup */
vect_free(profs);
vect_free(sumprof);
return 0;
}
int main(int argc, char *argv[])
{
float minval = SMALLNUM, maxval = LARGENUM, inx = 0, iny = 0;
int centern, offsetn;
int zoomlevel, maxzoom = 0, minzoom, xid, psid;
char *rootfilenm, inchar;
datapart *lodp;
dataview *dv;
basicstats *statvals;
if (argc == 1) {
printf("\nusage: exploredat datafilename\n\n");
exit(0);
}
printf("\n\n");
printf(" Interactive Data Explorer\n");
printf(" by Scott M. Ransom\n");
printf(" November, 2001\n");
print_help();
{
int hassuffix = 0;
char *suffix;
hassuffix = split_root_suffix(argv[1], &rootfilenm, &suffix);
if (hassuffix) {
if (strcmp(suffix, "dat") != 0) {
printf
("\nInput file ('%s') must be a single PRESTO data file ('.dat')!\n\n",
argv[1]);
free(suffix);
exit(0);
}
free(suffix);
} else {
printf("\nInput file ('%s') must be a PRESTO data file ('.dat')!\n\n",
argv[1]);
exit(0);
}
}
/* Read the info file */
readinf(&idata, rootfilenm);
if (idata.object) {
printf("Examining %s data from '%s'.\n\n",
remove_whitespace(idata.object), argv[1]);
} else {
printf("Examining data from '%s'.\n\n", argv[1]);
}
#ifdef USEMMAP
mmap_file = open(argv[1], O_RDONLY);
{
int rt;
struct stat buf;
rt = fstat(mmap_file, &buf);
if (rt == -1) {
perror("\nError in fstat() in exploredat.c");
printf("\n");
exit(-1);
}
Ndat = buf.st_size / sizeof(float);
}
lodp = get_datapart(0, Ndat);
#else
{
int numsamp;
datfile = chkfopen(argv[1], "rb");
Ndat = chkfilelen(datfile, sizeof(float));
numsamp = (Ndat > MAXPTS) ? (int) MAXPTS : (int) Ndat;
lodp = get_datapart(0, numsamp);
}
#endif
/* Plot the initial data */
centern = 0.5 * INITIALNUMPTS;
if (centern > lodp->nn)
centern = lodp->nn / 2;
zoomlevel = LOGMAXDISPNUM - LOGINITIALNUMPTS;
minzoom = LOGMAXDISPNUM - LOGMAXPTS;
maxzoom = LOGMAXDISPNUM - LOGMINDISPNUM;
dv = get_dataview(centern, zoomlevel, lodp);
/* Prep the XWIN device for PGPLOT */
xid = cpgopen("/XWIN");
if (xid <= 0) {
free_datapart(lodp);
#ifdef USEMMAP
close(mmap_file);
#else
fclose(datfile);
#endif
free(dv);
exit(EXIT_FAILURE);
}
cpgask(0);
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
do {
cpgcurs(&inx, &iny, &inchar);
if (DEBUGOUT)
printf("You pressed '%c'\n", inchar);
switch (inchar) {
case ' ': /* Toggle stats and sample plotting on/off */
/* 0 = both, 1 = stats only, 2 = data only */
plotstats++;
plotstats = plotstats % 3;
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
break;
case 'M': /* Toggle between median and average */
case 'm':
usemedian = (usemedian) ? 0 : 1;
free(dv);
dv = get_dataview(centern, zoomlevel, lodp);
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
break;
case 'A': /* Zoom in */
case 'a':
centern = inx + offsetn;
case 'I':
case 'i':
if (DEBUGOUT)
printf(" Zooming in (zoomlevel = %d)...\n", zoomlevel);
if (zoomlevel < maxzoom) {
zoomlevel++;
free(dv);
dv = get_dataview(centern, zoomlevel, lodp);
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
} else
printf(" Already at maximum zoom level (%d).\n", zoomlevel);
break;
case 'X': /* Zoom out */
case 'x':
case 'O':
case 'o':
if (DEBUGOUT)
printf(" Zooming out (zoomlevel = %d)...\n", zoomlevel);
if (zoomlevel > minzoom) {
zoomlevel--;
free(dv);
dv = get_dataview(centern, zoomlevel, lodp);
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
} else
printf(" Already at minimum zoom level (%d).\n", zoomlevel);
break;
case '<': /* Shift left 1 full screen */
centern -= dv->numsamps + dv->numsamps / 8;
case ',': /* Shift left 1/8 screen */
if (DEBUGOUT)
printf(" Shifting left...\n");
centern -= dv->numsamps / 8;
{ /* Should probably get the previous chunk from the datfile... */
double lowestr;
lowestr = 0.5 * dv->numsamps;
if (centern < lowestr)
centern = lowestr;
}
free(dv);
dv = get_dataview(centern, zoomlevel, lodp);
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
break;
case '>': /* Shift right 1 full screen */
centern += dv->numsamps - dv->numsamps / 8;
case '.': /* Shift right 1/8 screen */
centern += dv->numsamps / 8;
if (DEBUGOUT)
printf(" Shifting right...\n");
{ /* Should probably get the next chunk from the datfile... */
double highestr;
highestr = lodp->nlo + lodp->nn - 0.5 * dv->numsamps;
if (centern > highestr)
centern = highestr;
}
free(dv);
dv = get_dataview(centern, zoomlevel, lodp);
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
break;
case '+': /* Increase height of top edge */
{
float dy;
if (maxval > 0.5 * LARGENUM) {
printf(" Auto-scaling of top edge is off.\n");
if (minval < 0.5 * SMALLNUM)
dy = dv->maxval - dv->minval;
else
dy = dv->maxval - minval;
maxval = dv->maxval + 0.1 * dy;
} else {
if (minval < 0.5 * SMALLNUM)
dy = maxval - dv->minval;
else
dy = maxval - minval;
maxval += 0.1 * dy;
}
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
break;
}
case '_': /* Decrease height of top edge */
{
float dy;
if (maxval > 0.5 * LARGENUM) {
printf(" Auto-scaling of top edge is off.\n");
if (minval < 0.5 * SMALLNUM)
dy = dv->maxval - dv->minval;
else
dy = dv->maxval - minval;
maxval = dv->maxval - 0.1 * dy;
} else {
if (minval < 0.5 * SMALLNUM)
dy = maxval - dv->minval;
else
dy = maxval - minval;
maxval -= 0.1 * dy;
}
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
break;
}
case '=': /* Increase height of bottom edge */
{
float dy;
if (minval < 0.5 * SMALLNUM) {
printf(" Auto-scaling of bottom edge is off.\n");
if (maxval > 0.5 * LARGENUM)
dy = dv->maxval - dv->minval;
else
dy = maxval - dv->minval;
minval = dv->minval + 0.1 * dy;
} else {
if (maxval > 0.5 * LARGENUM)
dy = dv->maxval - minval;
else
dy = maxval - minval;
minval += 0.1 * dy;
}
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
break;
}
case '-': /* Decrease height of bottom edge */
{
float dy;
if (minval < 0.5 * SMALLNUM) {
printf(" Auto-scaling of bottom edge is off.\n");
if (maxval > 0.5 * LARGENUM)
dy = dv->maxval - dv->minval;
else
dy = maxval - dv->minval;
minval = dv->minval - 0.1 * dy;
} else {
if (maxval > 0.5 * LARGENUM)
dy = dv->maxval - minval;
else
dy = maxval - minval;
minval -= 0.1 * dy;
}
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
break;
}
case 'S': /* Auto-scale */
case 's':
printf(" Auto-scaling is on.\n");
minval = SMALLNUM;
maxval = LARGENUM;
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
break;
case 'G': /* Goto a time */
case 'g':
{
char timestr[50];
double time = -1.0;
while (time < 0.0) {
printf
(" Enter the time (s) from the beginning of the file to go to:\n");
fgets(timestr, 50, stdin);
timestr[strlen(timestr) - 1] = '\0';
time = atof(timestr);
}
offsetn = 0.0;
centern = (int) (time / idata.dt + 0.5);
printf(" Moving to time %.15g (data point %d).\n", time, centern);
free(dv);
dv = get_dataview(centern, zoomlevel, lodp);
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
}
break;
case '?': /* Print help screen */
print_help();
break;
case 'P': /* Print the current plot */
case 'p':
{
int len;
char filename[200];
printf(" Enter the filename to save the plot as:\n");
fgets(filename, 195, stdin);
len = strlen(filename) - 1;
filename[len + 0] = '/';
filename[len + 1] = 'C';
filename[len + 2] = 'P';
filename[len + 3] = 'S';
filename[len + 4] = '\0';
psid = cpgopen(filename);
cpgslct(psid);
cpgpap(10.25, 8.5 / 11.0);
cpgiden();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
cpgclos();
cpgslct(xid);
filename[len] = '\0';
printf(" Wrote the plot to the file '%s'.\n", filename);
}
break;
case 'V': /* Show the basic statistics for the current dataview */
case 'v':
statvals = calc_stats(dv, lodp);
printf("\n Statistics:\n"
" Low sample %d\n"
" Number of samples %d\n"
" Low time (s) %.7g\n"
" Duration of samples (s) %.7g\n"
" Maximum value %.7g\n"
" Minimum value %.7g\n"
" Average value %.7g\n"
" Median value %.7g\n"
" Standard Deviation %.7g\n"
" Skewness %.7g\n"
" Kurtosis %.7g\n\n",
dv->lon, dv->numsamps, dv->lon * idata.dt, dv->numsamps * idata.dt,
statvals->max, statvals->min, statvals->average,
statvals->median, statvals->stdev,
statvals->skewness, statvals->kurtosis);
free(statvals);
break;
case 'Q': /* Quit */
case 'q':
printf(" Quitting...\n");
free(dv);
cpgclos();
break;
default:
printf(" Unrecognized option '%c'.\n", inchar);
break;
}
} while (inchar != 'Q' && inchar != 'q');
free_datapart(lodp);
#ifdef USEMMAP
close(mmap_file);
#else
fclose(datfile);
#endif
printf("Done\n\n");
return 0;
}
static void _pgpage (void)
{
cpgpage();
}
