void cpgstart_ps(const char *filenm, const char *orientation)
{
char tmp[100];
if (0 == strcmp(orientation, "portrait")) {
sprintf(tmp, "%s/VCPS", filenm);
if (cpgopen(tmp) <= 0)
exit(EXIT_FAILURE);
} else {
sprintf(tmp, "%s/CPS", filenm);
if (cpgopen(tmp) <= 0)
exit(EXIT_FAILURE);
}
}
void display_particles(NBody *data, double max, int n)
/*assume a top-down view (i.e. ignore the z-component*/
{
#ifdef PGPLOT
int npix=256;
float tr[6];
static int firsttime=1;
if (firsttime)
{
assert(NDIM>=2);
cpgopen("?");
cpgenv(1,npix,1,npix,0,1);
firsttime=0;
}
tr[0]=0;tr[1]=1;tr[2]=0;tr[3]=0;tr[4]=0;tr[5]=1;
float **mat=fmatrix(npix,npix);
for (int i=0;i<npix;i++)
for (int j=0;j<npix;j++)
mat[i][j]=0;
for (int i=0;i<n;i++)
{
int ii= npix*((data[i].x[0]+max)/(2*max));
int jj= npix*((data[i].x[1]+max)/(2*max));
if ((ii>=0)&&(ii<npix)&&(jj>=0)&&(jj<npix))
mat[ii][jj]++;
}
cpgimag(mat[0],npix,npix,1,npix,1,npix,0,5.0,tr);
#endif
}
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;
}
int main(int argc, char** argv)
{
if(argc!=2)
{
perror("Invalid arguements : SMROStats <file.lba>\n");
exit(1);
}
// Get the filename from the command line
char* filename = argv[1];
// Get stats for input file
struct stat file_stats;
if(stat(filename,&file_stats))
{
perror("Couldn't retrieve file information.\n");
exit(1);
}
// Check length of input file
int max=1024; // No. of blocks to read. When max=1024;64MB of input used
if(file_stats.st_size<(BLK_SIZE*max))
max=file_stats.st_size/BLK_SIZE;
// Data loader
dsp::SMROFile* loader = new dsp::SMROFile;
loader->open( filename );
loader->set_output( new dsp::BitSeries );
loader->set_block_size( BLK_SIZE );
// Convert to a dsp::TimeSeries
dsp::SMROTwoBitCorrection* unpacker = new dsp::SMROTwoBitCorrection;
unpacker->set_input( loader->get_output() );
unpacker->set_output( new dsp::TimeSeries );
// Go to work
int count;
for(count=0;count<max;count++) // Load and unpack (BLK_SIZE*max) bytes
{
loader->operate();
unpacker->operate();
}
loader->close();
// Plot Histogram
cpgopen("?");
cpglab("","","SMRO Sampler Statistics");
cpgsvp(0.1,0.9,0.1,0.9);
dsp::TwoBitStatsPlotter* plot = new dsp::TwoBitStatsPlotter;
plot->set_data(unpacker);
plot->plot();
cpgclos();
// Free memory
delete loader,unpacker;
}
void cpgstart_x(const char *orientation)
{
if (cpgopen("/XWIN") <= 0)
exit(EXIT_FAILURE);
if (0 == strcmp(orientation, "portrait")) {
cpgpap(8.5, 11.0 / 8.5);
} else {
cpgpap(11.0, 8.5 / 11.0);
}
cpgask(1);
}
static int _pgopen (char *dev)
{
int id;
if (*dev == 0)
dev = DEFAULT_DEVICE;
id = cpgopen (dev);
return id; /* <= 0 is error */
}
int main(void)
{
if ((ipass=fopen(scans,"r"))==NULL)
{
printf("Cannot open file. \n");
exit(1);
}
fscanf(ipass,"%i", &Ptotal);
for (Pindex=1; Pindex<=Ptotal; Pindex++)
{
fscanf(ipass,"%s", powerfile);
// printf("%s\n",powerfile);
if ((fp=fopen(powerfile,"r"))==NULL)
{
printf("Cannot open file. \n");
exit(1);
}
strcpy(passfile,"");
strcat(passfile,prefix);
p=strpbrk(powerfile,"2");
strcat(passfile,p);
// printf("%s\n",passfile);
if ((fpass=fopen(passfile,"r"))==NULL)
{
printf("Cannot open file. \n");
exit(1);
}
printf("\nReading data file %s \n",powerfile);
for (acqcount=1; acqcount < (numofacqs+1); acqcount++) read_data();
read_pass_file();
// test_data();
fclose(fpass);
fclose(fp);
}
group_data();
pg_id = cpgopen("/XSERVE");
while (sat_choice <100)
{
printf("\nPlot Satellite: ");
scanf("%i", &sat_choice);
if (sat_choice<40) plot_map();
}
write_map();
fclose(ipass);
printf("End of Program\n");
return 0;
}
/*
* Class: pulsarhunter_PgplotInterface
* Method: pgopen
* Signature: (Ljava/lang/String;)V
*/
JNIEXPORT void JNICALL Java_pulsarhunter_PgplotInterface_pgopen
(JNIEnv *env, jclass cl, jstring device){
int one=1,zero=0;
jint strlen = (*env)->GetStringUTFLength(env,device);
char *deviceStr = (char*) (*env)->GetStringUTFChars(env,device,NULL);
// pgbeg__(&zero,deviceStr,&one,&one,strlen);
cpgopen(deviceStr);
(*env)->ReleaseStringUTFChars(env,device,deviceStr);
}
/**
* This method opens a graphic panel for plotting. All the subsequent plotting will be put in this panel.
*
* @return The PGPLOT graphic Id just in case.
*/
int opengr()
{
char aux[8];
int i = 5;
int GRid;
cpgqinf("STATE", aux, &i);
if (strncmp(aux, "OPEN", i) != 0) {
GRid = cpgopen("/xwindow");
cpgask(0);
resizemax(0.85);
return (GRid);
} else {
fprintf(stderr, "Device alredy open !!");
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 main(void)
{
int j, jj;
int sleep_sec=2;
char bufD[128];
int ind, Mcount;
int M=50;
int plan;
pg_id = cpgopen("/XSERVE");
cpgpap(6.00, 0.8);
timedata = fftw_malloc(sizeof(double) * (N+1));
freqdata = fftw_malloc(sizeof(fftw_complex) * (N+1));
read_count=N*M;
mem_size=read_count * 2;
ai_buf = (I16*)malloc(mem_size);
if ((fp=fopen("SatPosData","w"))==NULL)
{
printf("Cannot open file. \n");
exit(1);
}
for (j=1; j<=max_scans; j++)
{
printf("\nPause %d seconds ...",sleep_sec);
sleep(sleep_sec);
printf("\n\nAcquisition %d\n",j);
fprintf(fp,"\nAcquisition: %d\n",j);
strcpy(bufD, send_command0("Apollo","GET_TIME$"));
printf("Universal Time: %s",bufD);
fprintf(fp, "UT: %s",bufD);
printf("Satellites above local horizon:\n");
getSatInfo0();
getSatInfo1();
acquire_data();
transfer_and_scale((U16*)ai_buf, channel+1);
for (k=0; k<(N/2)+1; k++) accumFreqData[k]=0;
printf("Integrating ... %i %i-blocks",M,N);
for (Mcount=1; Mcount<=M; Mcount++)
{
for (ind=0; ind<N; ind++)
{
timedata[ind]=voltarray[ind+(N*(Mcount-1))];
}
// printf("%i ",Mcount);
plan=(j==1)&(Mcount==1);
if (plan)
{
p=fftw_plan_dft_r2c_1d(N, timedata, freqdata, FFTW_FORWARD);
}
fftw_execute(p);
for (k=0; k<(N/2)+1; k++)
{
accumFreqData[k]+=(sqrt(freqdata[k][0]*freqdata[k][0]+freqdata[k][1]*freqdata[k][1])/(M*256));
}
}
fprintf(fp, "Bin Voltages \n");
for (jj=0; jj<=240; jj+=10)
{
for (k=jj; k<(jj+10); k++) fprintf(fp, "%f ", accumFreqData[k]);
fprintf(fp, "\n");
}
// plot_channel_data();
plot_freq_data();
}
int fclose(FILE *fp);
postfft();
free( ai_buf );
printf("\n\nEnd of program. ");
//getch();
putchar('\n');
return 0;
}
int main(int argc, char **argv) {
float lm, hm;
int ID;
float x1, y1, x2, y2;
char ch;
char filename[1024];
int enhanceid = -1;
int sectionmode = LON;
int histmode = DEP;
float binw = 10.0;
reset(&mainset);
load(&mainset);
rangeadjust(&control, &mainset, NULL, NULL, NULL, NULL);
ID = cpgopen("/xwindow");
resizemax(0.85);
cpgask(0);
/*
* This a bug-fix for the gmt command that outputs the borders wrapped.
*/
int i;
for(i=0; i < nborders; i++)
if (borders[i][0] != -999 && borders[i][0] > 180)
borders[i][0] = borders[i][0] - 360.0;
lm = hm = -1.0;
while (ch != 'Q') {
if (control.printout) {
lerchar("Entre com o nome do arquivo", filename, 1000);
if (strlen(filename) == 0) {
strcpy(message, "Nome invalido.");
alert(ERROR);
control.printout = 0;
} else {
if (strlen(filename) < 3 || strncasecmp( &filename[strlen(filename)-3], ".ps", 3) != 0) {
sprintf(filename,"%s.ps/cps",filename);
} else {
sprintf(filename,"%s/cps",filename);
}
cpgopen(filename);
cpgask(0);
}
}
plot(&control, &mainset);
if (control.printout == 0 && enhanceid != -1) {
enhanceid = enhance(&control, &mainset, enhanceid);
}
if (mainset.region) {
plotsection(&mainset, &control, sectionmode);
plothistogram(&mainset, binw, histmode, lm, hm);
}
if (control.printout) {
cpgclos();
cpgslct(ID);
control.printout = 0;
filename[strlen(filename) - 4] = '\0';
sprintf(message, "Print Out saved to file %s", filename);
alert(INFO);
continue;
}
// Restore default map position
cpgsvp(0.07, 0.93, 0.35, 0.9);
cpgswin(control.xmin, control.xmax, control.ymin, control.ymax);
ch = getonechar(&x1, &y1, 0);
switch(ch) {
case('='): {
control.printout = 1;
break;
}
case('R'): {
reset(&mainset);
load(&mainset);
break;
}
case('B'): {
binw = lerfloat("Entre com o valor da largura do bin?");
break;
}
case('A'): {
enhanceid = findpt(&mainset, x1, y1);
break;
}
case('2'): {
control.hasplates = (control.hasplates == 1) ? 0 : 1;
break;
}
case('1'): {
control.hascontinents++;
if (control.hascontinents > 2) control.hascontinents = 0;
break;
}
case ('W'): {
control.xmax = 180;
control.xmin = -180;
control.ymax = 90;
control.ymin = -90;
break;
}
case('0'): {
mainset.lon1 = -180;
mainset.lon2 = 180;
mainset.lat1 = -90;
mainset.lat2 = 90;
load(&mainset);
mainset.region = 0;
break;
}
case ('L'): {
sectionmode = (sectionmode == LAT) ? LON : LAT;
break;
}
case ('H'): {
histmode = (histmode == MAG) ? DEP : MAG;
binw = (histmode == MAG) ? 0.1 : 10.0;
break;
}
case ('S'): {
x2 = x1;
y2 = y1;
getonechar(&x2, &y2, 1);
order(&x1,&x2);
order(&y1,&y2);
mainset.lon1 = x1;
mainset.lon2 = x2;
mainset.lat1 = y1;
mainset.lat2 = y2;
load(&mainset);
mainset.region = 1;
break;
}
case('X'): { // ZOOM
x2 = x1;
y2 = y1;
getonechar(&x2, &y2, 1);
order(&x1,&x2);
order(&y1,&y2);
rangeadjust(&control, &mainset, &x1, &x2, &y1, &y2);
break;
}
case('C'): { // Color mode
control.colormode ++;
if (control.colormode>COLORMAG) control.colormode = COLORNONE;
break;
}
case('N'): { /* Ano */
int y1, y2;
y1 = lerint("Entre com ano inicial?");
y2 = lerint("Entre com ano final?");
orderint(&y1,&y2);
mainset.y1 = y1;
mainset.y2 = y2;
load(&mainset);
break;
}
case('M'): { /* Magnitude */
float m1, m2;
m1 = lerfloat("Entre com a Magnitude Inicial?");
m2 = lerfloat("Entre com a Magnitude Final?");
order(&m1,&m2);
mainset.m1 = m1;
mainset.m2 = m2;
load(&mainset);
break;
}
case('J'): { /* Ajuste */
lm = lerfloat("Entre com o menor valor de mag. para ajuste.");
hm = lerfloat("Entre com o maior valor de mag. para ajuste.");
if (lm == hm) {
lm = hm = -1;
}
break;
}
case('P'): { /* Profundidade */
float d1, d2;
d1 = lerfloat("Entre com a Profundidade Minima?");
d2 = lerfloat("Entre com a Profundidade Maxima?");
order(&d1,&d2);
mainset.d1 = d1;
mainset.d2 = d2;
load(&mainset);
break;
}
}
}
cpgclos();
}
void Plotter2::open() {
cpgopen((filename + "/" + device).c_str());
hasDevice = true;
}
int main()
{
//
printf("\n====================================================================\n");
printf("This program is able to simulate a variety of ecological\n");
printf("situations in a 2D lattice\n");
printf("====================================================================\n");
//==========================================================================
//--------------------------SYSTEM INITIALIZATIONS--------------------------
//==========================================================================
// initialize random seed
srand(time(NULL));
// force print all outputs (remove stdout buffer)
setbuf(stdout, NULL);
// initialize pgplot window
if (!cpgopen("/XWINDOW"))
errorCase(ERR_PGPLOT);
cpgpap(20.0, 0.33); // set window size
cpgsubp(3,1); // subdivide window into panels
// color indexes (R, G, B)
cpgscr(0, 0.0, 0.0, 0.0); // empty space, black
cpgscr(1, 1.0, 1.0, 1.0);
cpgscr(10, 0.0, 0.0, 0.0); // empty space, black
cpgscr(11, 0.5, 0.5, 0.5); // Trophic 1, gray
cpgscr(12, 0.5, 1.0, 1.0); // Trophic 2, cyan
cpgscr(13, 1.0, 0.5, 0.0); // Trophic 3, orange
cpgscr(14, 1.0, 0.0, 0.0);
cpgscir(10,NUMB_TROPHIC+10);
//==========================================================================
//--------------------------VARIABLE INITIALIZATIONS------------------------
//==========================================================================
// generic variables
int i, j, k; // counters
// simulation environment
int** simEnv = allocateArray2DInt(ENV_SIZE_X, ENV_SIZE_Y);
int** simEnvAge = allocateArray2DInt(ENV_SIZE_X, ENV_SIZE_Y);
int* simLocal = allocateArray1DInt(5);
// inputs
char input;
// current location and time
int x,y;
int tGlobal,t;
int flagUpdate;
// rates
float predationRates[NUMB_TROPHIC-1] = RATE_PRED;
float deathRates[NUMB_TROPHIC] = RATE_DEATH;
//float aBirth = 0; // A+0 -> A+A
// float abPred = 0; // B+A -> B+B
// float bDeath = 0; // B -> 0
// int aFlag; int abFlag; int bFlag;
// population counts;
int popCount[NUMB_TROPHIC];
float popDens[NUMB_TROPHIC];
float popDensOld[NUMB_TROPHIC];
for (i=0; i<NUMB_TROPHIC; i++){
popCount[i] = 0;
popDens[i] = 0.0;
popDensOld[i] = 1.0/(float)INIT_DENSITY;
}
float* ageStructure = allocateArray1D(ENV_SIZE_TOTAL);
// pgplot variables
float* plotImg = allocateArray1D(ENV_SIZE_TOTAL);
//float TR[6] = {0, 1, 0, 0, 0, 1};
float TR[6] = {0, 0, 1, ENV_SIZE_Y, -1, 0};
float plotMinBound = 0.0;
float plotMaxBound = (float)NUMB_TROPHIC;
//==========================================================================
//--------------------------ACTUAL CODE-------------------------------------
//==========================================================================
// environment initialization
randomizeArray2DInt(simEnv, ENV_SIZE_X, ENV_SIZE_Y, NUMB_TROPHIC);
// load initial display
for (i=0; i<ENV_SIZE_X; i++)
for (j=0; j<ENV_SIZE_Y; j++)
plotImg[i*ENV_SIZE_Y+j] = (float)(simEnv[i][j]);
cpgpanl(1,1);
cpgswin(0, ENV_SIZE_X-1, 0, ENV_SIZE_Y-1);
cpgsvp(0.01, 0.99, 0.01, 0.99);
cpgimag(plotImg, ENV_SIZE_Y, ENV_SIZE_X, 1, ENV_SIZE_Y, 1, ENV_SIZE_X, plotMinBound, plotMaxBound, TR);
// Load graph labels
// Population Density vs Time Plot
cpgpanl(2,1);
cpgsvp(0.08, 0.92, 0.08, 0.92);
cpgswin(0, ENV_SIZE_X, 0, 1);
cpgbox("ABCINTS", 0.0, 0, "ABCINTS", 0.0, 0);
cpglab("Time", "Population Density", "");
// Phase Portrait Plot
cpgpanl(3,1);
cpgsvp(0.08, 0.92, 0.08, 0.92);
cpgswin(0, 1, 0, 1);
cpgbox("ABCINTS", 0.0, 0, "ABCINTS", 0.0, 0);
cpglab("", "", "Phase Portrait");
cpgsci(11);
cpglab("Population Density SpA", "", "");
cpgsci(12);
cpglab("", "Population Density SpB", "");
// initial delay to visualize starting matrix
for (t=0; t<500000000; t++){}
tGlobal = 1;
while(1){
//aFlag = 0; abFlag = 0; bFlag = 0;
// run simulation for a full Monte Carlo timestep (ENV_SIZE_X*ENV_SIZE_Y)
for (t=0; t<ENV_SIZE_TOTAL; t++){
ecoRun(simEnv, simEnvAge, simLocal, predationRates, deathRates);
}
incrementAge(simEnvAge);
// plot stuffs
if ((tGlobal%1) == 0){
// calculate population densities
updatePopDens(simEnv, popCount, popDens);
// PLOT population densities
cpgpanl(2,1);
cpgsvp(0.08, 0.92, 0.08, 0.92);
cpgswin(0, ENV_SIZE_X, 0, 1);
for (i=0; i<NUMB_TROPHIC; i++){
cpgsls(1); cpgsci(i+11); // line style and color
cpgmove((tGlobal-1), popDensOld[i]);
cpgdraw(tGlobal, popDens[i]);
}
//printArray2DInt(simEnvAge, ENV_SIZE_X, ENV_SIZE_Y);
// PLOT age structure
/*updateAgeStructure(simEnv, simEnvAge, ageStructure, 1);
cpgpanl(3,1);
cpgsvp(0.08, 0.92, 0.08, 0.92);
cpgswin(0, 10, 0, (ENV_SIZE_TOTAL/10));
cpgsls(1); cpgsci(1); // line style and color
cpgeras();
cpgbox("ABCINTS", 0.0, 0, "ABCINTS", 0.0, 0);
cpglab("Age", "Number of Individuals", "Age Structure");
cpghist(popCount[1], ageStructure, 0, 10, 10, 1);*/
// PLOT phase portrait
cpgpanl(3,1);
cpgsvp(0.08, 0.92, 0.08, 0.92);
cpgswin(0, 1, 0, 1);
cpgsls(1); cpgsci(1); // line style and color
cpgmove(popDensOld[0], popDensOld[1]);
cpgdraw(popDens[0], popDens[1]);
for (i=0; i<NUMB_TROPHIC; i++)
popDensOld[i] = popDens[i];
}
// load array and display on pgplot
if ((tGlobal%1) == 0){
cpgpanl(1,1);
cpgswin(0, ENV_SIZE_X, 0, ENV_SIZE_Y);
cpgsvp(0.01, 0.99, 0.01, 0.99);
for (i=0; i<ENV_SIZE_X; i++)
for (j=0; j<ENV_SIZE_Y; j++)
plotImg[i*ENV_SIZE_Y+j] = (float)(simEnv[i][j]);
cpgimag(plotImg, ENV_SIZE_Y, ENV_SIZE_X, 1, ENV_SIZE_Y, 1, ENV_SIZE_X, plotMinBound, plotMaxBound, TR);
}
tGlobal++;
//for (t=0; t<10000000; t++){}
}
}
int main(int argc, char** argv){
float tr[6];
const float ZAP=32;
const uint64_t TSIZE=18;
const uint64_t zapE=64;
fftwf_init_threads();
fftwf_plan_with_nthreads(omp_get_max_threads());
logmsg("Open file '%s'",argv[1]);
FILE* f = fopen(argv[1],"r");
int hdr_bytes = read_header(f);
const uint64_t nskip = hdr_bytes;
const uint64_t nchan = nchans;
logmsg("Nchan=%"PRIu64", tsamp=%f",nchan,tsamp);
mjk_rand_t *random = mjk_rand_init(12345);
rewind(f);
FILE* of = fopen("clean.fil","w");
uint8_t hdr[nskip];
fread(hdr,1,nskip,f);
fwrite(hdr,1,nskip,of);
const uint64_t nsamp_per_block=round(pow(2,TSIZE));
logmsg("Tblock = %f",nsamp_per_block*tsamp);
mjk_clock_t *t_all = init_clock();
start_clock(t_all);
mjk_clock_t *t_read = init_clock();
mjk_clock_t *t_trns= init_clock();
mjk_clock_t *t_rms = init_clock();
mjk_clock_t *t_fft = init_clock();
mjk_clock_t *t_spec = init_clock();
const uint64_t bytes_per_block = nchan*nsamp_per_block;
uint8_t *buffer = calloc(bytes_per_block,1);
float **data = malloc_2df(nchan,nsamp_per_block);
float **clean = malloc_2df(nchan,nsamp_per_block);
float *bpass = calloc(nchan,sizeof(float));
float *ch_var=NULL;
float *ch_mean=NULL;
float *ch_fft_n=NULL;
float *ch_fft_p=NULL;
logmsg("Planning FFT - this will take a long time the first time it is run!");
start_clock(t_fft);
FILE * wisfile;
if(wisfile=fopen("wisdom.txt","r")){
fftwf_import_wisdom_from_file(wisfile);
fclose(wisfile);
}
const int fftX=nsamp_per_block;
const int fftY=nchan;
const int fftXo=nsamp_per_block/2+1;
float *X = fftwf_malloc(sizeof(float)*fftX);
for (uint64_t i = 0; i < nsamp_per_block ; i++){
X[i]=i;
}
float *tseries = fftwf_malloc(sizeof(float)*fftX);
float complex *fseries = fftwf_malloc(sizeof(float complex)*fftXo);
float *pseries = fftwf_malloc(sizeof(float)*fftXo);
uint8_t *mask = malloc(sizeof(uint8_t)*fftXo);
fftwf_plan fft_1d = fftwf_plan_dft_r2c_1d(fftX,tseries,fseries,FFTW_MEASURE|FFTW_DESTROY_INPUT);
complex float * fftd = fftwf_malloc(sizeof(complex float)*(fftXo*fftY));
fftwf_plan fft_plan = fftwf_plan_many_dft_r2c(
1,&fftX,fftY,
data[0] ,&fftX,1,fftX,
fftd ,&fftXo,1,fftXo,
FFTW_MEASURE|FFTW_PRESERVE_INPUT);
logmsg("Planning iFFT - this will take a long time the first time it is run!");
fftwf_plan ifft_plan = fftwf_plan_many_dft_c2r(
1,&fftX,fftY,
fftd ,&fftXo,1,fftXo,
clean[0] ,&fftX,1,fftX,
FFTW_MEASURE|FFTW_PRESERVE_INPUT);
if(!fft_plan){
logmsg("Error - could not do FFT plan");
exit(2);
}
wisfile=fopen("wisdom.txt","w");
fftwf_export_wisdom_to_file(wisfile);
fclose(wisfile);
stop_clock(t_fft);
logmsg("T(planFFT)= %.2lfs",read_clock(t_fft));
reset_clock(t_fft);
float min_var=1e9;
float max_var=0;
float min_fft_n=1e9;
float max_fft_n=0;
float min_fft_p=1e9;
float max_fft_p=0;
float min_mean=1e9;
float max_mean=0;
uint64_t nblocks=0;
uint64_t totread=0;
while(!feof(f)){
nblocks++;
ch_var = realloc(ch_var,nchan*nblocks*sizeof(float));
ch_mean = realloc(ch_mean,nchan*nblocks*sizeof(float));
ch_fft_n = realloc(ch_fft_n,nchan*nblocks*sizeof(float));
ch_fft_p = realloc(ch_fft_p,nchan*nblocks*sizeof(float));
start_clock(t_read);
uint64_t read = fread(buffer,1,bytes_per_block,f);
stop_clock(t_read);
if (read!=bytes_per_block){
nblocks--;
break;
}
totread+=read;
logmsg("read=%"PRIu64" bytes. T=%fs",read,totread*tsamp/(float)nchan);
uint64_t offset = (nblocks-1)*nchan;
start_clock(t_trns);
// transpose with small blocks in order to increase cache efficiency.
#define BLK 8
#pragma omp parallel for schedule(static,2) shared(buffer,data)
for (uint64_t j = 0; j < nchan ; j+=BLK){
for (uint64_t i = 0; i < nsamp_per_block ; i++){
for (uint64_t k = 0; k < BLK ; k++){
data[j+k][i] = buffer[i*nchan+j+k];
}
}
}
#pragma omp parallel for shared(data)
for (uint64_t j = 0; j < nchan ; j++){
if(j<zapE || (nchan-j) < zapE){
for (uint64_t i = 0; i < nsamp_per_block ; i++){
data[j][i]=ZAP;
}
}
}
if(nblocks==1){
#pragma omp parallel for shared(data,bpass)
for (uint64_t j = 0; j < nchan ; j++){
for (uint64_t i = 0; i < nsamp_per_block ; i++){
bpass[j]+=data[j][i];
}
bpass[j]/=(float)nsamp_per_block;
bpass[j]-=ZAP;
}
}
#pragma omp parallel for shared(data,bpass)
for (uint64_t j = 0; j < nchan ; j++){
for (uint64_t i = 0; i < nsamp_per_block ; i++){
data[j][i]-=bpass[j];
}
}
stop_clock(t_trns);
start_clock(t_rms);
#pragma omp parallel for shared(data,ch_mean,ch_var)
for (uint64_t j = 0; j < nchan ; j++){
float mean=0;
for (uint64_t i = 0; i < nsamp_per_block ; i++){
mean+=data[j][i];
}
mean/=(float)nsamp_per_block;
if(mean > ZAP+5 || mean < ZAP-5){
logmsg("ZAP ch=%"PRIu64,j);
for (uint64_t i = 0; i < nsamp_per_block ; i++){
data[j][i]=ZAP;
}
}
float ss=0;
float x=0;
for (uint64_t i = 0; i < nsamp_per_block ; i++){
x = data[j][i]-mean;
ss+=x*x;
}
float var=ss/(float)nsamp_per_block;
if (var > 0){
for (uint64_t i = 0; i < nsamp_per_block ; i++){
float v = (data[j][i]-mean)/sqrt(var);
if(v > 3 || v < -3){
data[j][i]=mjk_rand_gauss(random)*sqrt(var)+mean;
}
}
}
ch_var[offset+j] = var;
ch_mean[offset+j] = mean;
}
stop_clock(t_rms);
for (uint64_t i = 0; i < nsamp_per_block ; i++){
tseries[i]=0;
}
float tmean=0;
float tvar=0;
float max=0;
float min=1e99;
//#pragma omp parallel for shared(data,tseries)
// NOT THREAD SAFE
for (uint64_t j = 0; j < nchan ; j++){
tmean+=ch_mean[offset+j];
tvar+=ch_var[offset+j];
for (uint64_t i = 0; i < nsamp_per_block ; i++){
tseries[i]+=data[j][i];
if(data[j][i]>max)max=data[j][i];
if(data[j][i]<min)min=data[j][i];
}
}
float ss=0;
float mm=0;
for (uint64_t i = 0; i < nsamp_per_block ; i++){
float x=tseries[i]-tmean;
mm+=tseries[i];
ss+=x*x;
}
float rvar=ss/(float)nsamp_per_block;
logmsg("var=%g tvar=%g",ss/(float)nsamp_per_block,tvar);
logmsg("mean=%g tmean=%g",mm/(float)nsamp_per_block,tmean);
cpgopen("3/xs");
cpgsvp(0.1,0.9,0.1,0.9);
cpgswin(0,fftX,tmean-sqrt(tvar)*30,tmean+sqrt(tvar)*30);
cpgbox("ABN",0,0,"ABN",0,0);
cpgline(fftX,X,tseries);
cpgsci(2);
cpgclos();
tr[0] = 0.0 ;
tr[1] = 1;
tr[2] = 0;
tr[3] = 0.5;
tr[4] = 0;
tr[5] = 1;
logmsg("max=%g min=%g",max,min);
cpgopen("4/xs");
cpgsvp(0.1,0.9,0.1,0.9);
cpgswin(0,nsamp_per_block,0,nchan);
cpgbox("ABN",0,0,"ABN",0,0);
cpggray(*data,nsamp_per_block,nchan,1,nsamp_per_block,1,nchan,tmean/(float)nchan+sqrt(rvar/(float)nchan),tmean/(float)nchan-sqrt(rvar/(float)nchan),tr);
cpgclos();
start_clock(t_fft);
fftwf_execute(fft_1d);
fftwf_execute(fft_plan);
stop_clock(t_fft);
{
float T = sqrt(fftXo*tvar)*12;
logmsg("Zap T=%.2e",T);
float fx[fftXo];
float fT[fftXo];
#pragma omp parallel for shared(fseries,pseries,mask)
for (uint64_t i = 0; i < fftXo ; i++){
mask[i]=1;
}
#pragma omp parallel for shared(fseries,pseries,mask)
for (uint64_t i = 0; i < fftXo ; i++){
pseries[i]=camp(fseries[i]);
fx[i]=i;
float TT = T;
if (i>512)TT=T/2.0;
if(i>32){
fT[i]=TT;
if (pseries[i] > TT) {
mask[i]=0;
}
} else fT[i]=0;
}
uint64_t nmask=0;
for (uint64_t i = 0; i < fftXo ; i++){
if (mask[i]==0){
nmask++;
}
}
logmsg("masked=%d (%.2f%%)",nmask,100*nmask/(float)fftXo);
cpgopen("1/xs");
cpgsvp(0.1,0.9,0.1,0.9);
cpgswin(0,fftXo,0,T*10);
cpgbox("ABN",0,0,"ABN",0,0);
cpgline(fftXo,fx,pseries);
cpgsci(2);
cpgline(fftXo,fx,fT);
cpgclos();
}
// exit(1);
start_clock(t_spec);
//FILE* ff=fopen("plot","w");
#pragma omp parallel for shared(fftd,ch_mean,ch_fft_n,ch_fft_p)
for (uint64_t j = 0; j < nchan ; j++){
float var = ch_var[offset+j];
float m=sqrt(var*fftXo/2.0);
float T = sqrt(var*fftXo)*3;
uint64_t n=0;
float p=0;
float complex *fftch = fftd + fftXo*j;
for(uint64_t i = 1; i < fftXo; i++){
if (camp(fftch[i]) > T) {
n++;
p+=camp(fftch[i]);
}
// if(j==512)fprintf(ff,"%f ",camp(fftch[i]));
if(mask[i]==0){
fftch[i]=m*(mjk_rand_gauss(random) + I*mjk_rand_gauss(random));
}
// if(j==512)fprintf(ff,"%f\n",camp(fftch[i]));
}
ch_fft_n[offset+j]=n;
ch_fft_p[offset+j]=p;
}
// fclose(ff);
logmsg("iFFT");
fftwf_execute(ifft_plan);
#pragma omp parallel for schedule(static,2) shared(buffer,clean)
for (uint64_t j = 0; j < nchan ; j+=BLK){
for (uint64_t i = 0; i < nsamp_per_block ; i++){
for (uint64_t k = 0; k < BLK ; k++){
clean[j+k][i]/=(float)fftX;
buffer[i*nchan+j+k] = round(clean[j+k][i]);
}
}
if(j==512){
cpgopen("2/xs");
cpgsvp(0.1,0.9,0.1,0.9);
cpgswin(0,fftX,ch_mean[j]-sqrt(ch_var[j])*10,ch_mean[j]+sqrt(ch_var[j])*10);
cpgbox("ABN",0,0,"ABN",0,0);
cpgline(fftX,X,data[j]);
cpgsci(2);
cpgline(fftX,X,clean[j]);
cpgclos();
}
}
fwrite(buffer,1,bytes_per_block,of);
for (uint64_t i = 0; i < nsamp_per_block ; i++){
tseries[i]=0;
}
tmean=0;
tvar=0;
max=0;
min=1e99;
//#pragma omp parallel for shared(clean,tseries)
// NOT THREAD SAFE
for (uint64_t j = 0; j < nchan ; j++){
tmean+=ch_mean[offset+j];
tvar+=ch_var[offset+j];
for (uint64_t i = 0; i < nsamp_per_block ; i++){
tseries[i]+=clean[j][i];
if(clean[j][i]>max)max=clean[j][i];
if(clean[j][i]<min)min=clean[j][i];
}
}
ss=0;
mm=0;
for (uint64_t i = 0; i < nsamp_per_block ; i++){
float x=tseries[i]-tmean;
mm+=tseries[i];
ss+=x*x;
}
rvar=ss/(float)nsamp_per_block;
logmsg("var=%g tvar=%g",ss/(float)nsamp_per_block,tvar);
logmsg("mean=%g tmean=%g",mm/(float)nsamp_per_block,tmean);
cpgopen("5/xs");
cpgsvp(0.1,0.9,0.1,0.9);
cpgswin(0,fftX,tmean-sqrt(tvar)*30,tmean+sqrt(tvar)*30);
cpgbox("ABN",0,0,"ABN",0,0);
cpgline(fftX,X,tseries);
cpgsci(2);
cpgclos();
tr[0] = 0.0 ;
tr[1] = 1;
tr[2] = 0;
tr[3] = 0.5;
tr[4] = 0;
tr[5] = 1;
logmsg("max=%g min=%g",max,min);
cpgopen("6/xs");
cpgsvp(0.1,0.9,0.1,0.9);
cpgswin(0,nsamp_per_block,0,nchan);
cpgbox("ABN",0,0,"ABN",0,0);
cpggray(*clean,nsamp_per_block,nchan,1,nsamp_per_block,1,nchan,tmean/(float)nchan+sqrt(rvar/(float)nchan),tmean/(float)nchan-sqrt(rvar/(float)nchan),tr);
cpgclos();
stop_clock(t_spec);
for (uint64_t j = 0; j < nchan ; j++){
float mean=ch_mean[offset+j];
if (mean > max_mean)max_mean=mean;
if (mean < min_mean)min_mean=mean;
float var=ch_var[offset+j];
if (var > max_var)max_var=var;
if (var < min_var)min_var=var;
float fft_n=ch_fft_n[offset+j];
if (fft_n > max_fft_n)max_fft_n=fft_n;
if (fft_n < min_fft_n)min_fft_n=fft_n;
float fft_p=ch_fft_p[offset+j];
if (fft_p > max_fft_p)max_fft_p=fft_p;
if (fft_p < min_fft_p)min_fft_p=fft_p;
}
}
stop_clock(t_all);
fclose(of);
logmsg("T(all) = %.2lfs",read_clock(t_all));
logmsg("T(read) = %.2lfs",read_clock(t_read));
logmsg("T(trans)= %.2lfs",read_clock(t_trns));
logmsg("T(fft) = %.2lfs",read_clock(t_fft));
logmsg("T(fan) = %.2lfs",read_clock(t_spec));
logmsg("T(rms) = %.2lfs",read_clock(t_rms));
logmsg("T(rest) = %.2lfs",read_clock(t_all)-read_clock(t_read)-read_clock(t_trns)-read_clock(t_rms)-read_clock(t_fft)-read_clock(t_spec));
tr[0] = -tsamp*nsamp_per_block*0.5;
tr[2] = tsamp*nsamp_per_block;
tr[1] = 0;
tr[3] = 0.5;
tr[5] = 0;
tr[4] = 1;
cpgopen("1/xs");
cpgsvp(0.1,0.9,0.1,0.9);
cpgswin(0,nblocks*tsamp*nsamp_per_block,0,nchan);
cpgbox("ABN",600,10,"ABN",100,1);
cpggray(ch_mean,nchan,nblocks,1,nchan,1,nblocks,max_mean,min_mean,tr);
cpgclos();
cpgopen("2/xs");
cpgsvp(0.1,0.9,0.1,0.9);
cpgswin(0,nblocks*tsamp*nsamp_per_block,0,nchan);
cpgbox("ABN",600,10,"ABN",100,1);
cpggray(ch_var,nchan,nblocks,1,nchan,1,nblocks,max_var,min_var,tr);
cpgclos();
cpgopen("3/xs");
cpgsvp(0.1,0.9,0.1,0.9);
cpgswin(0,nblocks*tsamp*nsamp_per_block,0,nchan);
cpgbox("ABN",600,10,"ABN",100,1);
cpggray(ch_fft_n,nchan,nblocks,1,nchan,1,nblocks,max_fft_n,min_fft_n,tr);
cpgclos();
cpgopen("4/xs");
cpgsvp(0.1,0.9,0.1,0.9);
cpgswin(0,nblocks*tsamp*nsamp_per_block,0,nchan);
cpgbox("ABN",600,10,"ABN",100,1);
cpggray(ch_fft_p,nchan,nblocks,1,nchan,1,nblocks,max_fft_p,min_fft_p,tr);
cpgclos();
cpgopen("mean.ps/vcps");
cpgsvp(0.1,0.9,0.1,0.9);
cpgswin(0,nblocks*tsamp*nsamp_per_block,0,nchan);
cpgbox("ABN",600,10,"ABN",100,1);
cpggray(ch_mean,nchan,nblocks,1,nchan,1,nblocks,max_mean,min_mean,tr);
cpgclos();
cpgopen("var.ps/vcps");
cpgsvp(0.1,0.9,0.1,0.9);
cpgswin(0,nblocks*tsamp*nsamp_per_block,0,nchan);
cpgbox("ABN",600,10,"ABN",100,1);
cpggray(ch_var,nchan,nblocks,1,nchan,1,nblocks,max_var,min_var,tr);
cpgclos();
cpgopen("fft_n.ps/vcps");
cpgsvp(0.1,0.9,0.1,0.9);
cpgswin(0,nblocks*tsamp*nsamp_per_block,0,nchan);
cpgbox("ABN",600,10,"ABN",100,1);
cpggray(ch_fft_n,nchan,nblocks,1,nchan,1,nblocks,max_fft_n,min_fft_n,tr);
cpgclos();
cpgopen("fft_p.ps/vcps");
cpgsvp(0.1,0.9,0.1,0.9);
cpgswin(0,nblocks*tsamp*nsamp_per_block,0,nchan);
cpgbox("ABN",600,10,"ABN",100,1);
cpggray(ch_fft_p,nchan,nblocks,1,nchan,1,nblocks,max_fft_p,min_fft_p,tr);
cpgclos();
fclose(f);
free(buffer);
free_2df(data);
return 0;
}
int main(int argc, char *argv[]) {
float *x=NULL,*y=NULL,minx,maxx,miny,maxy,cx, *oparams=NULL,*nparams=NULL;
float *rx=NULL,*ry=NULL,*w=NULL,*wparams=NULL,*wx=NULL,*wy=NULL,*ww=NULL;
float *y_sault_fit=NULL, *x_fit=NULL, *y_new_fit=NULL, *y_reynolds_fit=NULL;
float *y_stevens_fit=NULL,*y_whole_fit=NULL,*y_old_fit=NULL;
int i,j,n=0,n_fit=100,new_fit_order=2,whole_fit_order=5,nr=0,nw=0;
/* float extra_x[NEXTRA]={ 93, 95 }, extra_y[NEXTRA] = { 0.1223, 0.1168 }; */
float extra_x[NEXTRA]= { 93, 95 }, extra_y[NEXTRA] = { 0.1116, 0.1056 };
float extra_u[NEXTRA]= { 0.01356, 0.01399 };
float fitp_sault[NFIT_SAULT]= { -202.6259, 149.7321, -36.4943, 2.9372 };
float fitp_reynolds[NFIT_REYNOLDS]= { -30.7667, 26.4908, -7.0977, 0.605334 };
float fitp_stevens[NFIT_STEVENS]= { -1.237160, 2.005317, -0.400622 };
float fitp_old[NFIT_OLD]= { -23.839, 19.569, -4.8168, 0.35836 };
float *ratio_reynolds_fit=NULL,*ratio_stevens_fit=NULL,*ratio_sault_fit=NULL;
float *ratio_new_fit=NULL;
float vpx1, vpx2, vpy1, vpy2, vpy3, lx, ly, dly;
char fitlabel[BUFSIZE];
/* Generate the cm fit points. */
for (cx=1.0; cx<10.0; cx+=0.1) {
nr++;
rx = realloc(rx, nr * sizeof(float));
ry = realloc(ry, nr * sizeof(float));
rx[nr-1] = log10f(cx * 1000);
ry[nr-1] = 0.0;
for (i=0; i<NFIT_REYNOLDS; i++) {
ry[nr-1] += fitp_reynolds[i] * powf(rx[n-1], (float)i);
}
}
/* Generate the 15mm fit points. */
for (cx=10.0; cx<=24.0; cx+=0.128) {
n++;
x = realloc(x, n * sizeof(float));
y = realloc(y, n * sizeof(float));
w = realloc(w, n * sizeof(float));
x[n-1] = log10f(cx * 1000);
y[n-1] = 0.0;
for (i=0; i<NFIT_REYNOLDS; i++) {
y[n-1] += fitp_sault[i] * powf(x[n-1], (float)i);
}
w[n-1] = 1.0/0.1;
}
/* Do the fit. */
linfit_order(NFIT_SAULT, n, x, y, w, &oparams);
for (i=0; i<NFIT_SAULT; i++) {
printf("i = %d c[i] = %.4f\n", i, oparams[i]);
}
/* Add the 3mm flux points. */
for (i=0; i<NEXTRA; i++) {
n++;
x = realloc(x, n * sizeof(float));
y = realloc(y, n * sizeof(float));
w = realloc(w, n * sizeof(float));
x[n-1] = log10f(extra_x[i] * 1000);
y[n-1] = log10f(extra_y[i]);
w[n-1] = 1/extra_u[i];
}
/* Do another fit. */
linfit_order(new_fit_order, n, x, y, w, &nparams);
for (i=0; i<new_fit_order; i++) {
printf("i = %d nc[i] = %.4f\n", i, nparams[i]);
}
/* Generate the whole range fit points. */
minx=log10f(900);
maxx=log10f(100000);
miny=-2;
maxy=log10f(20);
x_fit = malloc(n_fit * sizeof(float));
for (i=0; i<n_fit; i++) {
x_fit[i] = minx + i * ((maxx - minx)/(float)n_fit);
nw++;
wx = realloc(wx, nw * sizeof(float));
wy = realloc(wy, nw * sizeof(float));
ww = realloc(ww, nw * sizeof(float));
wx[nw-1] = x_fit[i];
wy[nw-1] = 0.0;
ww[nw-1] = 1;
if (x_fit[i] < log10f(11143)) {
/* Use the Reynolds fit. */
for (j=0; j<NFIT_REYNOLDS; j++) {
wy[nw-1] += fitp_reynolds[j] * powf(x_fit[i], (float)j);
}
} else {
/* Use the new fit. */
for (j=0; j<new_fit_order; j++) {
wy[nw-1] += nparams[j] * powf(x_fit[i], (float)j);
}
}
}
/* Do a whole-range fit. */
linfit_order(whole_fit_order, nw, wx, wy, ww, &wparams);
for (i=0; i<whole_fit_order; i++) {
printf("i = %d wc[i] = %.4f\n", i, wparams[i]);
}
// minmax(n, x, &minx, &maxx);
// minmax(n, y, &miny, &maxy);
y_sault_fit = malloc(n_fit * sizeof(float));
y_reynolds_fit = malloc(n_fit * sizeof(float));
y_stevens_fit = malloc(n_fit * sizeof(float));
y_new_fit = malloc(n_fit * sizeof(float));
y_whole_fit = malloc(n_fit * sizeof(float));
y_old_fit = malloc(n_fit * sizeof(float));
ratio_reynolds_fit = malloc(n_fit * sizeof(float));
ratio_stevens_fit = malloc(n_fit * sizeof(float));
ratio_sault_fit = malloc(n_fit * sizeof(float));
ratio_new_fit = malloc(n_fit * sizeof(float));
/* minx=log10f(50); */
minx=log10f(1000);
/* maxx=log10f(500000); */
maxx=log10f(110000);
for (i=0; i<n_fit; i++) {
x_fit[i] = minx + i * ((maxx - minx)/(float)n_fit);
y_sault_fit[i] = 0.0;
y_reynolds_fit[i] = 0.0;
y_new_fit[i] = 0.0;
y_stevens_fit[i] = 0.0;
y_whole_fit[i] = 0.0;
y_old_fit[i] = 0.0;
for (j=0; j<NFIT_SAULT; j++) {
y_sault_fit[i] += fitp_sault[j] * powf(x_fit[i], (float)j);
}
for (j=0; j<NFIT_REYNOLDS; j++) {
y_reynolds_fit[i] += fitp_reynolds[j] * powf(x_fit[i], (float)j);
}
for (j=0; j<NFIT_STEVENS; j++) {
y_stevens_fit[i] += fitp_stevens[j] * powf(x_fit[i], (float)j);
}
for (j=0; j<new_fit_order; j++) {
y_new_fit[i] += nparams[j] * powf(x_fit[i], (float)j);
}
for (j=0; j<whole_fit_order; j++) {
y_whole_fit[i] += wparams[j] * powf(x_fit[i], (float)j);
}
for (j=0; j<NFIT_OLD; j++) {
y_old_fit[i] += fitp_old[j] * powf(x_fit[i], (float)j);
}
ratio_reynolds_fit[i] = powf(10, (y_reynolds_fit[i] - y_whole_fit[i]));
ratio_stevens_fit[i] = powf(10, (y_stevens_fit[i] - y_whole_fit[i]));
ratio_sault_fit[i] = powf(10, (y_sault_fit[i] - y_whole_fit[i]));
ratio_new_fit[i] = powf(10, (y_new_fit[i] - y_whole_fit[i]));
}
/* cpgopen("11/xs"); */
cpgopen("1934-638_models.ps/cps");
/* cpgopen("1934-638_models.png/png"); */
cpgqvp(0, &vpx1, &vpx2, &vpy1, &vpy2);
vpy3 = vpy1 + (vpy2 - vpy1) / 5.0;
/* cpgsvp(vpx1, vpx2, vpy3, vpy2); */
cpgswin(minx, maxx, miny, maxy);
lx = minx + (maxx - minx) / 9.0;
ly = miny + (maxy - miny) / 3.0;
dly = (maxy - miny) / 20.0;
cpgsch(1.0);
cpgbox("BCLNTS",0,0,"BCLNTS",0,0);
cpglab("Frequency (MHz)", "Flux Density (Jy)", "1934-638 Model Comparison");
cpgsch(0.8);
cpgpt(n, x, y, 4);
/* cpgpt(nw, wx, wy, 4); */
cpgsci(2);
/* cpgpt(nr, rx, ry, 4); */
cpgline(n_fit, x_fit, y_sault_fit);
strcpy(fitlabel, "Sault: ");
fitstring(fitp_sault, NFIT_SAULT, fitlabel);
cpgtext(lx, ly, fitlabel);
cpgsci(3);
cpgline(n_fit, x_fit, y_new_fit);
strcpy(fitlabel, "Stevens (linear): ");
fitstring(nparams, new_fit_order, fitlabel);
ly -= dly;
cpgtext(lx, ly, fitlabel);
cpgsci(4);
cpgline(n_fit, x_fit, y_reynolds_fit);
strcpy(fitlabel, "Reynolds: ");
fitstring(fitp_reynolds, NFIT_REYNOLDS, fitlabel);
ly -= dly;
cpgtext(lx, ly, fitlabel);
cpgsci(5);
cpgline(n_fit, x_fit, y_stevens_fit);
strcpy(fitlabel, "Stevens (Miriad): ");
fitstring(fitp_stevens, NFIT_STEVENS, fitlabel);
ly -= dly;
cpgtext(lx, ly, fitlabel);
cpgsci(6);
cpgline(n_fit, x_fit, y_old_fit);
strcpy(fitlabel, "Pre-1994: ");
fitstring(fitp_old, NFIT_OLD, fitlabel);
ly -= dly;
cpgtext(lx, ly, fitlabel);
/* cpgsci(6); */
/* cpgline(n_fit, x_fit, y_whole_fit); */
/* strcpy(fitlabel, "Stevens (New): "); */
/* fitstring(wparams, whole_fit_order, fitlabel); */
/* ly -= dly; */
/* cpgtext(lx, ly, fitlabel); */
/* cpgsvp(vpx1, vpx2, vpy1, vpy3); */
/* cpgsci(1); */
/* cpgswin(minx, maxx, 0.9, 1.1); */
/* cpgsch(1.0); */
/* cpgbox("BCLNTS",0,0,"BCMTS",0,0); */
/* cpglab("Frequency (MHz)", "Model Ratio", ""); */
/* cpgsci(2); */
/* cpgline(n_fit, x_fit, ratio_sault_fit); */
/* cpgsci(3); */
/* cpgline(n_fit, x_fit, ratio_new_fit); */
/* cpgsci(4); */
/* cpgline(n_fit, x_fit, ratio_reynolds_fit); */
/* cpgsci(5); */
/* cpgline(n_fit, x_fit, ratio_stevens_fit); */
cpgclos();
exit(0);
}
int main(){
printf("\n====================================================================\n");
printf("This program is able to simulate the diffusion of heat\n");
printf("across a metal plate of size %i x %i\n", ENV_SIZE_X, ENV_SIZE_Y);
printf("====================================================================\n");
//==========================================================================
//--------------------------SYSTEM INITIALIZATIONS--------------------------
//==========================================================================
// initialize random seed
srand(time(NULL));
// force print all outputs (remove stdout buffer)
setbuf(stdout, NULL);
// initialize pgplot window
if (!cpgopen("/XWINDOW"))
errorCase(ERR_PGPLOT);
cpgpap(0.0, 0.6); // set window size
cpgsubp(1,3); // subdivide window into panels
// heatmap
cpgpanl(1,1);
cpgsvp(0.0, 1.0, 0.0, 1.0);
cpgswin(0, ENV_SIZE_X, 0, ENV_SIZE_Y);
// flux plot
cpgpanl(1,2);
cpgsvp(0.08, 0.92, 0.08, 0.92);
cpgswin(LINE_PLOT_X1, LINE_PLOT_X2, FLUX_PLOT_Y1, FLUX_PLOT_Y2);
cpgbox("ABCINTS", 0.0, 0, "ABCINTS", 0.0, 0);
cpglab("Time", "Flux", "");
// heat plot
cpgpanl(1,3);
cpgsvp(0.08, 0.92, 0.08, 0.92);
cpgswin(LINE_PLOT_X1, LINE_PLOT_X2, LINE_PLOT_Y1, LINE_PLOT_Y2);
cpgbox("ABCINTS", 0.0, 0, "ABCINTS", 0.0, 0);
cpglab("Time", "Total Heat", "");
// initialize color table for pgplot display
float rl[9] = {-0.5, 0.0, 0.17, 0.33, 0.50, 0.67, 0.83, 1.0, 1.7};
float rr[9] = { 0.0, 0.0, 0.0, 0.0, 0.6, 1.0, 1.0, 1.0, 1.0};
float rg[9] = { 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.6, 0.0, 1.0};
float rb[9] = { 0.0, 0.3, 0.8, 1.0, 0.3, 0.0, 0.0, 0.0, 1.0};
cpgctab(rl, rr, rg, rb, 512, 1.0, 0.5);
cpgscr(10, 0.0, 0.0, 1.0);
cpgscr(11, 1.0, 0.0, 0.0);
cpgsfs(3);
//==========================================================================
//--------------------------VARIABLE INITIALIZATIONS------------------------
//==========================================================================
// generic variables
int i, j, k; // counters
// simulation environment
float** simEnvEven = allocateArray2D(ENV_SIZE_X, ENV_SIZE_Y);
float** simEnvOdd = allocateArray2D(ENV_SIZE_X, ENV_SIZE_Y);
float* simLocal = allocateArray1D(5);
// mnist handwritten numbers
float** mnistDatabase = readCSV("mnist_train_100.csv", 100, 785);
for (i=0; i<100; i++)
for (j=0; j<785; j++)
mnistDatabase[i][j] = mnistDatabase[i][j]/255.0;
// current location and time
int x,y,z;
int t, tGlobal;
// student number
int studentNumbRaw;
int studentNumbWorking;
int studentNumb[7];
// rates
float rateDiff = 0.2;
float delta;
// flux variables
float flux;
float fluxTotal;
float fluxAverage;
float fluxHeat;
float totalHeat;
int x1, x2, y1, y2;
// background heat
float bgHeat;
// tracking variables
float totalHeatOld;
float totalHeatPre;
float tGlobalOld;
float fluxOld;
// pgplot variables
float* plotImg = allocateArray1D(ENV_SIZE_TOTAL);
float TR[6] = {0, 0, 1, ENV_SIZE_Y, -1, 0};
float plotMinBound = 0;
float plotMaxBound = 1;
//==========================================================================
//--------------------------------SETUP-------------------------------------
//==========================================================================
// ask for student number
printf("Please enter your student number:\n");
if (scanf("%i", &studentNumbRaw) == 0)
errorCase(ERR_INVALID_INPUT);
studentNumbWorking = studentNumbRaw;
for (i=0; i<SN_LENGTH; i++){
studentNumb[6-i] = studentNumbWorking%10;
studentNumbWorking /= 10;
}
printf("\nYour student number is:\n");
for (i=0; i<SN_LENGTH; i++)
printf("%i", studentNumb[i]);
printf("\n\n");
// set and print diffusion rate based on last digit of student number
rateDiff = ((((float)(studentNumb[6]))/10.0)*0.19)+0.01;
printf("Your Diffusion Rate is: \n%f\n\n", rateDiff);
// set and print background heat added based on last 4 digits of student number
studentNumbRaw -= 1410000;
bgHeat = ((float)((studentNumbRaw%97)%10));
bgHeat += ((float)((studentNumbRaw%101)%8))*10;
bgHeat /= 100;
printf("Your Background Heat is: \n%f\n\n", bgHeat*100);
// set and print domain for calculating flux
// x1, y1 based on last four digits of student number
x1 = studentNumbRaw % ENV_SIZE_X;
y1 = studentNumbRaw % ENV_SIZE_Y;
// x2, y2 based on last four digits of student number
x2 = x1 + (studentNumbRaw % (97));
if (x2 >= ENV_SIZE_X)
x2 = ENV_SIZE_X - 1;
y2 = y1 + (studentNumbRaw % (29));
if (y2 >= ENV_SIZE_Y)
y2 = ENV_SIZE_Y - 1;
printf("Your Domain is: \n(%i, %i) X (%i, %i)\n\n", x1, y1, x2, y2);
// environment initialization:
// select digits and place into environment
for (i=0; i<SN_LENGTH; i++){
if (studentNumb[i] == 0)
z = 0;
else if (studentNumb[i] == 1)
z = 13;
else if (studentNumb[i] == 2)
z = 27;
else if (studentNumb[i] == 3)
z = 33;
else if (studentNumb[i] == 4)
z = 44;
else if (studentNumb[i] == 5)
z = 55;
else if (studentNumb[i] == 6)
z = 60;
else if (studentNumb[i] == 7)
z = 71;
else if (studentNumb[i] == 8)
z = 81;
else
z = 89;
for (x=0; x<28; x++)
for (y=0; y<28; y++) {
simEnvEven[x+(i*28)+1][y+1] = mnistDatabase[z][y*28+x] + bgHeat;
if (simEnvEven[x+(i*28)+1][y+1] > 1.0)
simEnvEven[x+(i*28)+1][y+1] = 1.0;
}
}
//==========================================================================
//--------------------------ACTUAL CODE-------------------------------------
//==========================================================================
// initialize display
fixBoundaryConditions(simEnvEven);
copyArray2D(simEnvEven, simEnvOdd, ENV_SIZE_X, ENV_SIZE_Y);
loadImage(simEnvEven, plotImg);
cpgpanl(1,1);
cpgsvp(0.0, 1.0, 0.0, 1.0);
cpgswin(0, ENV_SIZE_X, 0, ENV_SIZE_Y);
cpgimag(plotImg, ENV_SIZE_Y, ENV_SIZE_X, 1, ENV_SIZE_Y, 1, ENV_SIZE_X, plotMinBound, plotMaxBound, TR);
cpgrect(x1, x2, y1, y2);
// initialize trackers
tGlobalOld = 0;
fluxOld = 0;
totalHeatOld = 0;
for (x=x1; x<=x2; x++)
for (y=y1; y<=y2; y++)
totalHeatOld += simEnvEven[x][y];
// initial delay to visualize starting matrix
for (t=0; t<500000000; t++){}
t = 0;
tGlobal = 0;
flux = 0;
fluxAverage = 0;
fluxTotal = 0;
while(1){
flux = 0;
cpgpanl(1,1);
cpgsvp(0.0, 1.0, 0.0, 1.0);
cpgswin(0, ENV_SIZE_X, 0, ENV_SIZE_Y);
// calculate heat changes using numeric methods
fixBoundaryConditions(simEnvEven);
//simEnvEven[50][15] = 100;
//simEnvEven[60][15] = -10;
copyArray2D(simEnvEven, simEnvOdd, ENV_SIZE_X, ENV_SIZE_Y);
for (x=1; x<(ENV_SIZE_X-1); x++)
for (y=1; y<(ENV_SIZE_Y-1); y++)
if ((x+y)%2 == 0) {
delta = rateDiff*(simEnvEven[x][y+1] - 2*simEnvEven[x][y] + simEnvEven[x][y-1]);
simEnvOdd[x][y] += delta;
if (INSIDE_BOX)
flux += delta;
delta = rateDiff*(simEnvEven[x+1][y] - 2*simEnvEven[x][y] + simEnvEven[x-1][y]);
simEnvOdd[x][y] += delta;
if (INSIDE_BOX)
flux += delta;
}
for (x=1; x<(ENV_SIZE_X-1); x++)
for (y=1; y<(ENV_SIZE_Y-1); y++)
if ((x+y)%2 == 1) {
delta = rateDiff*(simEnvOdd[x][y+1] - 2*simEnvOdd[x][y] + simEnvOdd[x][y-1]);
simEnvOdd[x][y] += delta;
if (INSIDE_BOX)
flux += delta;
delta = rateDiff*(simEnvOdd[x+1][y] - 2*simEnvOdd[x][y] + simEnvOdd[x-1][y]);
simEnvOdd[x][y] += delta;
if (INSIDE_BOX)
flux += delta;
}
loadImage(simEnvOdd, plotImg);
cpgimag(plotImg, ENV_SIZE_Y, ENV_SIZE_X, 1, ENV_SIZE_Y, 1, ENV_SIZE_X, plotMinBound, plotMaxBound, TR);
cpgrect(x1, x2, y1, y2);
fluxTotal += flux;
tGlobal++;
flux = 0;
//simEnvOdd[50][15] = 100;
//simEnvOdd[60][15] = -10;
fixBoundaryConditions(simEnvOdd);
for (x=1; x<(ENV_SIZE_X-1); x++)
for (y=1; y<(ENV_SIZE_Y-1); y++)
if ((x+y)%2 == 1) {
delta = rateDiff*(simEnvOdd[x][y+1] - 2*simEnvOdd[x][y] + simEnvOdd[x][y-1]);
simEnvEven[x][y] += delta;
if (INSIDE_BOX)
flux += delta;
delta = rateDiff*(simEnvOdd[x+1][y] - 2*simEnvOdd[x][y] + simEnvOdd[x-1][y]);
simEnvEven[x][y] += delta;
if (INSIDE_BOX)
flux += delta;
}
for (x=1; x<(ENV_SIZE_X-1); x++)
for (y=1; y<(ENV_SIZE_Y-1); y++)
if ((x+y)%2 == 0) {
delta = rateDiff*(simEnvEven[x][y+1] - 2*simEnvEven[x][y] + simEnvEven[x][y-1]);
simEnvEven[x][y] += delta;
if (INSIDE_BOX)
flux += delta;
delta = rateDiff*(simEnvEven[x+1][y] - 2*simEnvEven[x][y] + simEnvEven[x-1][y]);
simEnvEven[x][y] += delta;
if (INSIDE_BOX)
flux += delta;
}
loadImage(simEnvEven, plotImg);
cpgimag(plotImg, ENV_SIZE_Y, ENV_SIZE_X, 1, ENV_SIZE_Y, 1, ENV_SIZE_X, plotMinBound, plotMaxBound, TR);
cpgrect(x1, x2, y1, y2);
fluxTotal += flux;
tGlobal++;
// flux line plot
cpgpanl(1,2);
cpgsvp(0.08, 0.92, 0.08, 0.92);
cpgswin(LINE_PLOT_X1, LINE_PLOT_X2, FLUX_PLOT_Y1, FLUX_PLOT_Y2);
cpgmove(tGlobalOld, fluxOld);
cpgdraw(tGlobal, flux);
// heat line plot
totalHeat = 0;
for (x=x1; x<=x2; x++)
for (y=y1; y<=y2; y++)
totalHeat += simEnvEven[x][y];
cpgpanl(1,3);
cpgsvp(0.08, 0.92, 0.08, 0.92);
cpgswin(LINE_PLOT_X1, LINE_PLOT_X2, LINE_PLOT_Y1, LINE_PLOT_Y2);
cpgmove(tGlobalOld, totalHeatOld);
cpgdraw(tGlobal, totalHeat);
// set trackers
tGlobalOld = tGlobal;
totalHeatOld = totalHeat;
fluxOld = flux;
if (tGlobal%100 == 0) {
totalHeat = 0;
for (x=x1; x<=x2; x++)
for (y=y1; y<=y2; y++)
totalHeat += simEnvEven[x][y];
fluxAverage = fluxTotal/tGlobal;
fluxHeat = totalHeat - totalHeatPre;
printf("Total Heat: %f \n Current Divergence: %f \n Current Flux: %f\n\n", totalHeat, flux, fluxHeat);
}
totalHeatPre = 0;
for (x=x1; x<=x2; x++)
for (y=y1; y<=y2; y++)
totalHeatPre += simEnvEven[x][y];
}
}
int main (int argc,char **argv)
{
int argPos, argNum = argc;
char charBuffer [RGPBufferSIZE], panelTitle [RGPBufferSIZE], *outFile = (char *) "rgisplot";
int panelRow, panelCol, panelRowNum,panelColNum, defaultLW;
DBInt dataNum, entryNum = 0;
DBInt ret, mode = 0, device = 0, format = 0, layout = 0;
float x0, y0, x1, y1, pWidth = -1.0, pHeight = -1.0;
DBObjData *dbData;
for (argPos = 1;argPos < argNum; )
{
if (CMargTest (argv [argPos],"-m","--mode"))
{
const char *modes [] = { "interactive", "batch", (char *) NULL };
if ((argNum = CMargShiftLeft (argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing mode!"); return (CMfailed); }
if ((mode = CMoptLookup (modes,argv [argPos],true)) == DBFault)
{ CMmsgPrint (CMmsgUsrError,"Invalid mode %s",argv [argPos]); goto Usage; }
if ((argNum = CMargShiftLeft (argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest (argv [argPos],"-d","--device"))
{
const char *devices [] = { "screen", "file", (char *) NULL };
if ((argNum = CMargShiftLeft (argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing device!"); return (CMfailed); }
if ((device = CMoptLookup (devices,argv [argPos],true)) == DBFault)
{ CMmsgPrint (CMmsgUsrError,"Invalid device %s",argv [argPos]); goto Usage; }
if ((argNum = CMargShiftLeft (argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest (argv [argPos],"-p","--psize"))
{
if ((argNum = CMargShiftLeft (argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing psize!"); return (CMfailed); }
if ((argv [argPos] == (char *) NULL) || (sscanf (argv [argPos],"%f,%f",&pWidth,&pHeight) != 2))
{ CMmsgPrint (CMmsgUsrError,"Invalid page size %s",argv [argPos]); goto Usage; }
if ((argNum = CMargShiftLeft (argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest (argv [argPos],"-f","--format"))
{
const char *formats [] = { "eps", "gif", "ppm", (char *) NULL };
if ((argNum = CMargShiftLeft (argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing format!"); return (CMfailed); }
if ((format = CMoptLookup (formats,argv [argPos],true)) == DBFault)
{ CMmsgPrint (CMmsgUsrError,"Invalid format %s",argv [argPos]); goto Usage; }
if ((argNum = CMargShiftLeft (argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest (argv [argPos],"-l","--layout"))
{
const char *layouts [] = { "portrait","landscape", (char *) NULL };
if ((argNum = CMargShiftLeft (argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing layout!"); return (CMfailed); }
if ((layout = CMoptLookup (layouts,argv [argPos],true)) == DBFault)
{ CMmsgPrint (CMmsgUsrError,"Invalid layout %s",argv [argPos]); goto Usage; }
if ((argNum = CMargShiftLeft (argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest (argv [argPos],"-o","--output"))
{
if ((argNum = CMargShiftLeft (argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing output!"); return (CMfailed); }
if (argv [argPos] == (char *) NULL)
{ CMmsgPrint (CMmsgUsrError,"Invalid output file"); goto Usage; }
outFile = argv [argPos];
if ((argNum = CMargShiftLeft (argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest (argv [argPos],"-h","--help"))
{
Usage:
CMmsgPrint (CMmsgUsrError,"Usage: rgisPlot [-m <>] [-d <>] [-f <>] [-l <>] [-o <>] -h");
CMmsgPrint (CMmsgUsrError," -m, --mode <interactive | batch>");
CMmsgPrint (CMmsgUsrError," -d, --device <screen | file>");
CMmsgPrint (CMmsgUsrError," -p, --psize width,height");
CMmsgPrint (CMmsgUsrError," -f, --format <eps | gif>");
CMmsgPrint (CMmsgUsrError," -l, --layout <landscape | portrait>");
CMmsgPrint (CMmsgUsrError," -o, --output <filename>");
argNum = CMargShiftLeft (argPos,argv,argNum);
return (DBSuccess);
}
if ((argv [argPos][0] == '-') && (strlen (argv [argPos]) > 1))
{ CMmsgPrint (CMmsgUsrError,"Unknown option: %s!",argv [argPos]); return (CMfailed); }
argPos++;
}
switch (device)
{
case 0: cpgopen ("/XWINDOW"); break;
case 1:
{
char *formatStrings [] = { (char *) "CPS", (char *) "GIF", (char *) "PPM" };
sprintf (charBuffer,layout == 0 ? "%s/V%s" : "%s/%s", outFile, formatStrings [format]);
cpgopen (charBuffer);
} break;
default: return (CMfailed);
}
cpgscrn (0,"WHITE",&ret);
if ((pWidth > 0.0) && (pHeight > 0.0)) cpgpap (pWidth, pHeight / pWidth);
do {
RGPPrintMessage (mode,&entryNum,"Panel Layout [horizontal,vertical]:");
while (fgets (charBuffer,sizeof (charBuffer) - 1,stdin) == (char *) NULL);
if (sscanf (charBuffer,"%d,%d",&panelColNum,&panelRowNum) == 2) break;
else
if (RGPPrintError (mode,entryNum,"Panel layout input error")) goto Stop;
} while (true);
RGPInitPenColors ();
cpgsubp (panelColNum,panelRowNum);
cpgqlw (&defaultLW);
ret = DBSuccess;
for (panelRow = 0;panelRow < panelRowNum;++panelRow)
for (panelCol = 0;panelCol < panelColNum; ++panelCol)
{
cpgpanl (panelCol + 1,panelRow + 1);
cpgsch (1.8);
cpgvstd ();
do {
sprintf (charBuffer,"Panel Title [%d,%d]:",panelRow,panelCol);
RGPPrintMessage (mode,&entryNum,charBuffer);
if (fgets (panelTitle,sizeof (panelTitle) - 1,stdin) != (char *) NULL)
{
if (panelTitle [strlen (panelTitle) - 1] == '\n')
panelTitle [strlen (panelTitle) - 1] = '\0';
if (strlen (panelTitle) > 0) break;
}
RGPPrintError (mode,entryNum,"Panel Title input error"); goto Stop;
} while (true);
dataNum = 0;
do {
RGPPrintMessage (mode,&entryNum,"Mapextent [X0,Y0,X1,Y1]:");
if (fgets (charBuffer,sizeof (charBuffer) - 1,stdin) == (char *) NULL) continue;
if (sscanf (charBuffer,"%f,%f,%f,%f",&x0,&y0,&x1,&y1) == 4) break;
else if (RGPPrintError (mode,entryNum,"Mapextent input error")) goto Stop;
} while (true);
cpgwnad (x0,x1,y0,y1);
do {
sprintf (charBuffer,"RiverGIS data file [%d]:",++dataNum);
RGPPrintMessage (mode,&entryNum, charBuffer);
if ((fgets (charBuffer,sizeof (charBuffer) - 1,stdin) != (char *) NULL) &&
(strlen (charBuffer) > 0) && charBuffer [0] != '\n')
{
if (charBuffer [strlen (charBuffer) - 1] == '\n') charBuffer [strlen (charBuffer) - 1] = '\0';
dbData = new DBObjData ();
if (dbData->Read (charBuffer) != DBSuccess) { dataNum--; continue; }
switch (dbData->Type ())
{
case DBTypeVectorPoint:
if ((ret = RGPDrawVecPoint (mode, &entryNum, dbData)) == DBFault) goto Stop;
break;
case DBTypeVectorLine:
if ((ret = RGPDrawVecLine (mode, &entryNum, dbData)) == DBFault) goto Stop;
break;
case DBTypeVectorPolygon:
break;
case DBTypeGridContinuous:
if ((ret = RGPDrawGridContinuous (mode,&entryNum,dbData)) == DBFault) goto Stop;
break;
case DBTypeGridDiscrete:
break;
case DBTypeNetwork:
if ((ret = RGPDrawNetwork (mode, &entryNum, dbData)) == DBFault) goto Stop;
break;
default: CMmsgPrint (CMmsgUsrError,"Invalid data type"); dataNum--; break;
}
delete dbData;
}
else break;
} while (true);
cpgbox ("BCMTS",0.0,0,"BCNMTS",0.0,0);
cpgslw (2);
cpgsch (2.5);
cpgmtxt ("T",1.5,0.5,0.5,panelTitle);
cpgslw (defaultLW);
}
Stop:
cpgend ();
return (ret);
}
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);
}
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[])
{
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;
}
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;
}
