int main(int argc, char *argv[])
{
FILE *f;
if(argc !=3)
{
print_usage(argv);
return(EXIT_FAILURE);
}
char *filename = argv[1];
int beam = atoi(argv[2]);
f = fopen(filename,"r");
if(NULL == f)
{
printf("ERROR: file %s not found.\n",filename);
exit(1);
}
float x[MAX_CHANNELS],y[MAX_CHANNELS];
int i;
for(i=0;i<MAX_CHANNELS;i++)
{
fscanf(f,"%f %f",&x[i],&y[i]);
if(isnan(x[i]))
{
printf("found nan\n");
x[i] = x[i-1];
}
if(isnan(y[i]))
{
printf("found nan\n");
y[i] = y[i-1];
}
}
fclose(f);
moving_average_filter(x,MAX_CHANNELS,100);
moving_average_filter(y,MAX_CHANNELS,100);
char outfile[30];
sprintf(outfile,"epsilon_phi%d.smooth",beam);
f = fopen(outfile,"w");
for(i=0;i<MAX_CHANNELS;i++)
{
fprintf(f,"%f %f\n",x[i],y[i]);
}
fclose(f);
}
//----------------------------------------------------------------------------------------------------------
//void smooth_cal(SpecRecord dataset[], int size, int lowchan, int highchan, int window)
//void simple_smooth_cal(SpecRecord dataset[], int size, int lowchan, int highchan, int twindow, int fwindow)
void simple_smooth_cal(SpecRecord dataset[], int start, int end, int records, int lowchan, int highchan, int twindow, int fwindow)
{
//fix this loop need to run for all 4096 channels
lowchan = 0; highchan = MAX_CHANNELS;
int n, chan, dchan = highchan - lowchan;
int size = end-start;
float mean[4], tmp;
static float mean_t[4] = {0};
float sigma[4] = {0};
float *XRA, *Yxx, *Yyy, *Yxy, *Yyx;
static float *Fxx, *Fyy, *Fxy, *Fyx, *w;
//Y has band avg series
Yxx = (float*) malloc(sizeof(float) * size);
Yyy = (float*) malloc(sizeof(float) * size);
Yxy = (float*) malloc(sizeof(float) * size);
Yyx = (float*) malloc(sizeof(float) * size);
float **Sxx,**Syy,**Syx,**Sxy;
//Fxx is time avg band shape
if(0 == start)
{
Fxx = (float*) malloc(sizeof(float) * dchan);
Fyy = (float*) malloc(sizeof(float) * dchan);
Fxy = (float*) malloc(sizeof(float) * dchan);
Fyx = (float*) malloc(sizeof(float) * dchan);
if(Fxx == NULL || Fyy == NULL || Fxy == NULL || Fyx == NULL)
{
printf("malloc failed !\n");
exit(0);
}
}
if(Yxx == NULL || Yyy == NULL || Yxy == NULL || Yyx == NULL)
{
printf("malloc failed !\n");
exit(0);
}
FILE * outfile2 = fopen("avgtimecal.dat","w");
if(outfile2 == NULL)
{
printf("Can't open avgtimecal.dat\n");
exit(0);
}
for(chan=lowchan; chan<highchan; chan++)
{
mean[0] = mean[1] = mean[2] = mean[3] = 0;
int count[MAX_CHANNELS] = {0};
//for(n=0; n<size; n++)
for(n=start; n<end; n++)
{
if(dataset[n].flagBAD) continue;
//if(dataset[n].flagRFI[chan] == RFI_NONE)
{
mean[0] += dataset[n].cal.xx[chan];
mean[1] += dataset[n].cal.yy[chan];
mean[2] += dataset[n].cal.xy[chan];
mean[3] += dataset[n].cal.yx[chan];
count[chan]++;
}
}
//avoid divide by zero
if(count[chan])
{
mean[0] /= count[chan];
mean[1] /= count[chan];
mean[2] /= count[chan];
mean[3] /= count[chan];
}
fprintf(outfile2,"%f %f %f %f\n",mean[0],mean[1],mean[2],mean[3]);
//for(n=0; n<size; n++)
for(n=start; n<end; n++)
{
//if(dataset[n].flagBAD || dataset[n].flagRFI[chan] != RFI_NONE)
if(dataset[n].flagBAD)
{
dataset[n].cal.xx[chan] = mean[0];
dataset[n].cal.yy[chan] = mean[1];
dataset[n].cal.xy[chan] = mean[2];
dataset[n].cal.yx[chan] = mean[3];
}
}
}
fclose(outfile2);
// mean[0] = mean[1] = mean[2] = mean[3] = 0;
int cnt = 0;
if(0 == start)
{
float sumxx,sumyy,sumxy,sumyx;
for(n=0; n<records; n++)
{
if(dataset[n].flagBAD) continue;
sumxx = 0.0,sumyy = 0.0,sumxy = 0.0;sumyx = 0.0;
for(chan=lowchan; chan<highchan; chan++)
{
sumxx += dataset[n].cal.xx[chan];
sumyy += dataset[n].cal.yy[chan];
sumxy += dataset[n].cal.xy[chan];
sumyx += dataset[n].cal.yx[chan];
}
sumxx /= dchan;
sumyy /= dchan;
sumxy /= dchan;
sumyx /= dchan;
mean_t[0] += sumxx;
mean_t[1] += sumyy;
mean_t[2] += sumxy;
mean_t[3] += sumyx;
cnt++;
}
mean_t[0] /= cnt;
mean_t[1] /= cnt;
mean_t[2] /= cnt;
mean_t[3] /= cnt;
}
cnt = 0;
for(n=start; n<end; n++)
{
if(dataset[n].flagBAD) continue;
Yxx[cnt] = Yyy[cnt] = Yxy[cnt] = Yyx[cnt] = 0.0;
for(chan=lowchan; chan<highchan; chan++)
{
Yxx[cnt] += dataset[n].cal.xx[chan];
Yyy[cnt] += dataset[n].cal.yy[chan];
Yxy[cnt] += dataset[n].cal.xy[chan];
Yyx[cnt] += dataset[n].cal.yx[chan];
}
Yxx[cnt] /= dchan;
Yyy[cnt] /= dchan;
Yxy[cnt] /= dchan;
Yyx[cnt] /= dchan;
sigma[0] += (Yxx[cnt] - mean_t[0])*(Yxx[cnt] - mean_t[0]);
sigma[1] += (Yyy[cnt] - mean_t[1])*(Yyy[cnt] - mean_t[1]);
sigma[2] += (Yxy[cnt] - mean_t[2])*(Yxy[cnt] - mean_t[2]);
sigma[3] += (Yyx[cnt] - mean_t[3])*(Yyx[cnt] - mean_t[3]);
cnt++;
}
sigma[0] = sqrt(sigma[0]/cnt);
sigma[1] = sqrt(sigma[1]/cnt);
sigma[2] = sqrt(sigma[2]/cnt);
sigma[3] = sqrt(sigma[3]/cnt);
for(n=0; n<cnt; n++)
{
if(fabs(Yxx[n] - mean_t[0]) > 3.0*sigma[0]) Yxx[n] = mean_t[0];
if(fabs(Yyy[n] - mean_t[1]) > 3.0*sigma[1]) Yyy[n] = mean_t[1];
if(fabs(Yxy[n] - mean_t[2]) > 3.0*sigma[2]) Yxy[n] = mean_t[2];
if(fabs(Yyx[n] - mean_t[3]) > 3.0*sigma[3]) Yyx[n] = mean_t[3];
}
for(n=0; n<cnt; n++)
{
Yxx[n] /= mean_t[0];
Yyy[n] /= mean_t[1];
Yxy[n] /= mean_t[2];
Yyx[n] /= mean_t[3];
}
//To avoid window parameter from overflowing
if(twindow > (cnt/2 - 1))
twindow = cnt/2 -1;
//apply the moving average filter to reduce noise
moving_average_filter(Yxx, cnt, twindow);
moving_average_filter(Yyy, cnt, twindow);
moving_average_filter(Yxy, cnt, twindow);
moving_average_filter(Yyx, cnt, twindow);
for(chan=lowchan; chan<highchan; chan++)
{
Fxx[chan - lowchan] = 0.0;
Fyy[chan - lowchan] = 0.0;
Fxy[chan - lowchan] = 0.0;
Fyx[chan - lowchan] = 0.0;
}
int cc[MAX_CHANNELS] = {0};
if(0 == start)
{
for(chan=lowchan; chan<highchan; chan++)
{
for(n=0; n<records; n++)
{
//if(!dataset[n].flagBAD && dataset[n].flagRFI[chan] == RFI_NONE)
{
Fxx[chan - lowchan] += dataset[n].cal.xx[chan];
Fyy[chan - lowchan] += dataset[n].cal.yy[chan];
Fxy[chan - lowchan] += dataset[n].cal.xy[chan];
Fyx[chan - lowchan] += dataset[n].cal.yx[chan];
cc[chan]++;
}
}
if(cc[chan])
{
Fxx[chan - lowchan] /= cc[chan];
Fyy[chan - lowchan] /= cc[chan];
Fxy[chan - lowchan] /= cc[chan];
Fyx[chan - lowchan] /= cc[chan];
}
else
{
printf("Rec %d chan %d count zero.\n",n,chan);
Fxx[chan - lowchan] = Fxx[chan-lowchan-1];
Fyy[chan - lowchan] = Fyy[chan-lowchan-1];
Fxy[chan - lowchan] = Fxy[chan-lowchan-1];
Fyx[chan - lowchan] = Fyx[chan-lowchan-1];
}
}
diffusion_filter(Fxx, dchan, fwindow);
diffusion_filter(Fyy, dchan, fwindow);
diffusion_filter(Fxy, dchan, fwindow);
diffusion_filter(Fyx, dchan, fwindow);
write_band(Fxx,Fyy, Fxy, Fyx,n,lowchan,highchan);
}
if(0 == start)
outfile2 = fopen("smoothcal.dat","w");
else
outfile2 = fopen("smoothcal.dat","a+");
if(outfile2 == NULL)
{
printf("Can't open avgbandcal.dat\n");
}
cnt = 0;
for(n=start; n<end; n++)
{
for(chan=lowchan; chan<highchan; chan++)
{
dataset[n].cal.xx[chan] = Yxx[cnt]*Fxx[chan-lowchan];
dataset[n].cal.yy[chan] = Yyy[cnt]*Fyy[chan-lowchan];
dataset[n].cal.xy[chan] = Yxy[cnt]*Fxy[chan-lowchan];
dataset[n].cal.yx[chan] = Yyx[cnt]*Fyx[chan-lowchan];
}
if(dataset[n].flagBAD)
continue;
fprintf(outfile2, "%05i %7.6f %7.6f %7.6f %7.6f\n",n,Yxx[cnt],Yyy[cnt],Yxy[cnt],Yyx[cnt]);
cnt++;
}
fclose(outfile2);
free(Yxx);
free(Yyy);
free(Yxy);
free(Yyx);
if(records == end)
{
free(Fxx);
free(Fyy);
free(Fxy);
free(Fyx);
}
return;
}
int main(int argc, char **argv)
{
int ret = 1;
const char *input_data = "/dev/random", *output_data = NULL;
int count = 0;
struct moving_average_filter_state ma_state;
unsigned int *array_in, *array_out;
int opt;
const struct option options[] = {
{"order", required_argument, NULL, 'P'},
{"count", required_argument, NULL, 'c'},
{"input-data", required_argument, NULL, 'i'},
{"output-data", required_argument, NULL, 'o'},
{0, 0, 0, 0}
};
memset(&ma_state, 0x0, sizeof(ma_state));
while ((opt = getopt_long(argc, argv, "P:c:i:o:", options, NULL)) != -1) {
switch (opt) {
case 'P':
ma_state.P = atof(optarg);
break;
case 'c':
count = atoi(optarg);
break;
case 'i':
input_data = optarg;
break;
case 'o':
output_data = optarg;
break;
case 0:
break;
default:
return usage(argv[0]);
}
}
if (generate_array(&array_in, &count, input_data) == -1)
return 1;
printf("Elements: %d\n", count);
{
int i;
for (i=0;i<count;++i)
array_in[i] %= 100;
}
if (moving_average_filter_init(&ma_state))
goto out;
printf("Moving Average parameters: P:%d\n",
ma_state.P);
{
int i;
printf("b:\n");
for (i=0;i<ma_state.P;++i)
printf("%f ", ma_state.b[i]);
printf("\n");
}
array_out = malloc(sizeof(unsigned int)*count);
if (!array_out) {
fprintf(stderr, "Unable to allocate %d bytes", count);
goto out;
}
memset(array_out, 0x0, sizeof(unsigned int)*count);
{
int i;
for (i=0;i<count;++i)
array_out[i] = moving_average_filter(&ma_state, array_in[i]);
}
if (output_data) {
int i;
int d = open(output_data, O_WRONLY|O_CREAT, 0666);
if (d == -1) {
fprintf(stderr, "Error opening %s: %s", output_data, strerror(errno));
goto out;
}
ftruncate(d, 0);
for (i=0;i<count;++i) {
char b[1024] = {0x0, };
int n;
n = snprintf(b, sizeof(b), "%d %d %d\n", i, array_in[i], array_out[i]);
if (write(d, b, n) == -1) {
fprintf(stderr, "Error writing to %s: %s", output_data, strerror(errno));
break;
}
}
close(d);
}
ret = 0;
out:
moving_average_filter_destroy(&ma_state);
if (array_in)
free(array_in);
if (array_out)
free(array_out);
return ret;
}
