void plotr0vstheta(){
TFile *f;
int isSum=0;
if(isSum==0){
f = TFile::Open("mergedV_Prod.root");
}
else{
f = TFile::Open("mergedV_Sum.root");
}
int xbin=0;
// TVectorD* vecVmean = (TVectorD*)f->Get(Form("D_%d/Vmean",xbin));
TVectorD* vecV = (TVectorD*)f->Get(Form("D_%d/D_0/r01",xbin));
double *V = vecV->GetMatrixArray();
double Vmean = getmean(V,ntheta);
double theta[ntheta];
for(int itheta=0;itheta<ntheta;itheta++){
theta[itheta]=itheta*TMath::Pi()/ntheta/nn;
}
int maxper10 = findmaxper(V,ntheta,Vmean);
double maxper = (double)(maxper10+2)/10;
TGraph *gV2theta = new TGraph(ntheta,theta,V);
gV2theta->SetTitle("");
gV2theta->GetXaxis()->SetTitle("#theta");
gV2theta->GetYaxis()->SetTitle("r_{0}");
gV2theta->GetYaxis()->SetTitleOffset(1.1);
gV2theta->GetXaxis()->SetTitleSize(0.04);
gV2theta->GetYaxis()->SetTitleSize(0.04);
gV2theta->SetMarkerStyle(20);
gV2theta->SetMarkerSize(1.3);
gV2theta->SetMarkerColor(1);
gV2theta->SetLineColor(1);
gV2theta->SetMinimum(Vmean*(1-maxper*1.5));
gV2theta->SetMaximum(Vmean*(1+maxper*1.5));
gV2theta->Draw("AP");
TLine *lup = new TLine(gV2theta->GetXaxis()->GetXmin(),Vmean*(1+maxper), gV2theta->GetXaxis()->GetXmax(),Vmean*(1+maxper));
TLine *ldown = new TLine(gV2theta->GetXaxis()->GetXmin(),Vmean*(1-maxper), gV2theta->GetXaxis()->GetXmax(),Vmean*(1-maxper));
TLine *l = new TLine(gV2theta->GetXaxis()->GetXmin(),Vmean, gV2theta->GetXaxis()->GetXmax(),Vmean);
l->SetLineStyle(2);
lup->SetLineStyle(2);
ldown->SetLineStyle(2);
l->SetLineWidth(1.2);
lup->SetLineWidth(1.2);
ldown->SetLineWidth(1.2);
TLatex *tl = new TLatex();
// tl->SetNDC();
tl->SetTextFont(42);
tl->SetTextSize(0.04);
// tl->SetBorderStyle(0);
tl->DrawLatex(0,Vmean*(1+maxper),Form("mean up %.f%%",maxper*100));
tl->DrawLatex(0,Vmean*(1-maxper),Form("mean down %.f%%",maxper*100));
tl->DrawLatex(1,0.2,Form("Multiplicity %d to %d",120,150));
l->Draw("same");
lup->Draw("same");
ldown->Draw("same");
if(isSum==0)c1->SaveAs("hr0theta_Prod.png");
else c1->SaveAs("hr0theta_Sum.png");
}
image_t*synth_simple(image_t*alpha, image_t*img)
{
matrix_t*dst = image_extractchannel(img, IMAGE_YUV_Y);
statistics_t*st = statistics_new_frommatrix(dst);
complex_matrix_t*c = matrix_fft(dst);
matrix_t*m = matrix_new_gaussrandom(dst->width, dst->height, 0, 1);
int it;
for(it=0;it<10;it++) {
complex_matrix_t*s = matrix_fft(m);
int t;
for(t=0;t<s->width*s->height;t++) {
double r = sqrt(c->data[t].real*c->data[t].real + c->data[t].imag*c->data[t].imag);
double r2 = sqrt(s->data[t].real*s->data[t].real + s->data[t].imag*s->data[t].imag);
if(r2) {
s->data[t].real *= r / r2 / (s->width*s->height);
s->data[t].imag *= r / r2 / (s->width*s->height);
}
//s->data[t].imag = 0;
}
matrix_delete(m);
m = complex_matrix_ifft_real(s);
matrix_adjust_statistics(m, st);
matrix_adjust_minmax(m, st);
complex_matrix_delete(s);
}
//image_t*result = image_from_matrix(m,IMAGE_CLAMP);
matrix_t*dst_u = image_extractchannel(img, IMAGE_YUV_U);
matrix_t*dst_v = image_extractchannel(img, IMAGE_YUV_V);
int u = getmean(img, dst_u);
int v = getmean(img, dst_v);
image_t*result = image_new(img->width, img->height);
int t;
for(t=0;t<img->width*img->height;t++) {
int yy = m->data[t];
//result->data[t].r = clamp00ff(yy);
//result->data[t].g = clamp00ff(yy);
//result->data[t].b = clamp00ff(yy);
//u = 128;
//v = 128;
result->data[t].r = clamp00ff(yy + ((360*(v-128))>>8));
result->data[t].g = clamp00ff(yy - ((88*(u-128)+183*(v-128))>>8));
result->data[t].b = clamp00ff(yy + ((455 * (u-128))>>8));
result->data[t].a = 255;
}
matrix_delete(m);
matrix_delete(dst);
matrix_delete(dst_u);
matrix_delete(dst_v);
complex_matrix_delete(c);
statistics_delete(st);
return result;
}
void plotr0vstheta(){
TFile *f;
int isSum=0;
const int ntotbin=5;
const int trkpointmin[ntotbin] = {120,150,185,220,260};
const int trkpointmax[ntotbin] = {150,185,220,260,300};
int xbin=0;
c1 = new TCanvas("c1"," ",1200,700);
makeMultiPanelCanvas(c1,3,2,0,0,0.25,0.2,0.03);
gStyle->SetOptFit(1);
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
gStyle->SetErrorX(0);
TH1D *hFrame = new TH1D("","",100,0,2);
hFrame->SetTitle("");
hFrame->GetXaxis()->SetTitle("#theta");
hFrame->GetYaxis()->SetTitle("r_{0}");
hFrame->GetYaxis()->SetTitleOffset(1.1);
hFrame->GetXaxis()->SetTitleSize(0.04);
hFrame->GetYaxis()->SetTitleSize(0.04);
hFrame->GetXaxis()->SetRangeUser(0,1.5);
hFrame->SetMinimum(0.04);
hFrame->SetMaximum(0.25);
for(int trkbin=0;trkbin<ntotbin; trkbin++){
if(isSum==0){
f = TFile::Open(Form("M%d%d/mergedV_Prod.root",trkpointmax[trkbin],trkpointmin[trkbin]));
}
else{
f = TFile::Open(Form("M%d%d/mergedV_Sum.root",trkpointmax[trkbin],trkpointmin[trkbin]));
}
TVectorD* vecr0 = (TVectorD*)f->Get(Form("D_%d/D_0/r0",xbin));
double *r0 = vecr0->GetMatrixArray();
double r0mean = getmean(r0,ntheta);
double theta[ntheta];
for(int itheta=0;itheta<ntheta;itheta++){
theta[itheta]=itheta*TMath::Pi()/ntheta/nn;
}
int maxper10 = findmaxper(r0,ntheta,r0mean);
double maxper = (double)(maxper10+1)/10;
c1->cd(trkbin+1);
hFrame->Draw();
TGraph *gr0theta = new TGraph(ntheta,theta,r0);
gr0theta->SetMarkerStyle(20);
gr0theta->SetMarkerSize(1.3);
gr0theta->SetMarkerColor(1);
gr0theta->SetLineColor(1);
gr0theta->Draw("Psame");
TLine *lup = new TLine(gr0theta->GetXaxis()->GetXmin(),r0mean*(1+maxper), gr0theta->GetXaxis()->GetXmax(),r0mean*(1+maxper));
TLine *ldown = new TLine(gr0theta->GetXaxis()->GetXmin(),r0mean*(1-maxper), gr0theta->GetXaxis()->GetXmax(),r0mean*(1-maxper));
TLine *l = new TLine(hFrame->GetXaxis()->GetXmin(),r0mean, hFrame->GetXaxis()->GetXmax(),r0mean);
l->SetLineStyle(2);
lup->SetLineStyle(2);
ldown->SetLineStyle(2);
l->SetLineWidth(1.2);
lup->SetLineWidth(1.2);
ldown->SetLineWidth(1.2);
TLatex *tl = new TLatex();
// tl->SetNDC();
tl->SetTextFont(42);
tl->SetTextSize(0.04);
// tl->SetBorderStyle(0);
tl->DrawLatex(0,r0mean*(1+maxper),Form("mean up %.f%%",maxper*100));
tl->DrawLatex(0,r0mean*(1-maxper),Form("mean down %.f%%",maxper*100));
tl->SetNDC();
tl->DrawLatex(0.7,0.85,Form("Multiplicity %d to %d",trkpointmin[trkbin],trkpointmax[trkbin]));
l->Draw("same");
lup->Draw("same");
ldown->Draw("same");
}
c1->cd(ntotbin+1);
TLatex *tlx0 = new TLatex(0.12,0.3,Form("PF candidate"));
TLatex *tlx1 = new TLatex(0.12,0.25,Form("%.1f<p_{T}<%.1f (GeV/c)",0.3,6.0));
tlx0->SetNDC();
tlx1->SetNDC();
tlx0->SetTextSize(0.045);
tlx1->SetTextSize(0.045);
hFrame->Draw();
tlx0->Draw("same");
tlx1->Draw("same");
if(isSum==0)c1->SaveAs("hr0theta_Prod.png");
else c1->SaveAs("hr0theta_Sum.png");
}
void standardize(double* x, int d) {
int i;
double mean = getmean(x, d);
for (i = 0; i < d; i++)
x[i] -= mean;
}
int main (int argc, char *argv[]) {
FILE *imgfp, *datfp;
char imgroot[MAXL], imgfile[MAXL], gfcfile[MAXL], ifhfile[MAXL];
char outroot[MAXL], outfile[MAXL], datfile[MAXL], volfile[MAXL], recfile[MAXL];
char program[MAXL], string[MAXL], command[MAXL], *ptr;
int isbig;
char control = '\0';
IFH ifh;
UCHAR ix, iy, iz;
XYZN xyzn;
int iv, iv0, jv, imgdim[3];
int ir, jr, nn;
int c, i, j, k, m, n;
double dela, delg, u1;
float vmin, vmax, fwhm = 0., alpha = ALPHA, *img_orig=NULL;
float maxfac = 0.0;
/**************/
/* gain field */
/**************/
int norder = NORDER, nterm = NTERM;
int niter = 0, limiter = LIMITER;
int eight = 8; /* field length for call to powstring_ () */
float a[NTERM], /* polynomial coefficients */
a0[NTERM];
float drms, diffcrit = DIFFCRIT;
float u1gfc[MAXR];
double sum0, sum, q, t;
/*********/
/* flags */
/*********/
int test = 0;
int status = 0;
int debug = 0;
int gfreeze = 0;
int verbose = 0;
int negdef = 0;
if (!(ptr = strrchr (argv[0], '/'))) ptr = argv[0]; else ptr++;
strcpy (program, ptr);
/************************/
/* process command line */
/************************/
for (k = 0, i = 1; i < argc; i++) if (*argv[i] == '-') {
strcpy (string, argv[i]); ptr = string;
while (c = *ptr++) switch (c) {
case 'v': verbose++; break;
case 'n': negdef++; break;
case 'g': gfreeze++; break;
case '@': control = *ptr++; *ptr = '\0'; break;
case 'b': g_bandwidth = atof (ptr); *ptr = '\0'; break;
case 'p': fwhm = atof (ptr); *ptr = '\0'; break;
case 'e': diffcrit = atof (ptr); *ptr = '\0'; break;
case 'i': g_sigma = atof (ptr); *ptr = '\0'; break;
case 'l': limiter = atoi (ptr); *ptr = '\0'; break;
case 'm': g_mr = atoi (ptr); *ptr = '\0'; break;
case 's': g_sconst = atof (ptr); *ptr = '\0'; break;
case 'z': g_zthresh = atof (ptr); *ptr = '\0'; break;
case 'M': maxfac = atof (ptr); *ptr = '\0'; break;
case 'r': getrange (ptr, &g_gfc_thresh, &g_gfc_ceil); *ptr = '\0'; break;
}
} else switch (k) {
case 0: getroot (argv[i], imgroot); k++; break;
}
if (k < 1) {
fprintf (stderr, "Usage:\t%s <imgroot>\n", program);
fprintf (stderr, " e.g.,\t%s vc1440_mpr_n4_111_t88.4dfp\n", program); /*??*/
fprintf (stderr, "\toption\n");
fprintf (stderr, "\t-g freeze initial gain field\n");
fprintf (stderr, "\t-n force negative definite quadratic gain field\n");
fprintf (stderr, "\t-v verbose mode\n");
fprintf (stderr, "\t-p<flt> pre-blur by specified FWHM in mm\n");
fprintf (stderr, "\t-b<flt>\tspecify bandwidth in intensity units (default=%.1f)\n", BANDWIDTH);
fprintf (stderr, "\t-e<flt>\tspecify drms convergence criterion (default=%f)\n", DIFFCRIT);
fprintf (stderr, "\t-i<flt>\tspecify sigma (default=%f)\n", SIGMA);
fprintf (stderr, "\t-l<int>\tspecify iteration limit (default=%d)\n", LIMITER);
fprintf (stderr, "\t-m<flt>\tspecify gfc computation region count (default=%d)\n", MR);
fprintf (stderr, "\t-s<flt>\tspecify space constant in mm (default=%f)\n", SCONST);
fprintf (stderr, "\t-z<flt>\tspecify background threshold (default=%.1f)\n", ZTHRESH);
fprintf (stderr, "\t-M<flt>\tspecify maximum correction factor\n");
fprintf (stderr, "\t-r<flt>[to<flt>]\tspecify gfc range (default=%.1fto%.1f)\n", GFC_THRESH, GFC_CEIL);
exit (1);
}
/*******************************************/
/* read/initialize gain field coefficients */
/*******************************************/
sprintf (gfcfile, "%s.4dfp.gfc", imgroot);
if (imgfp = fopen (gfcfile, "r")) {
printf ("Reading: %s\n", gfcfile);
for (k = 0; k < nterm; k++) fscanf (imgfp, "%f", a + k);
fclose (imgfp);
} else {
a[0] = 1.0;
for (k = 1; k < nterm; k++) a[k] = 0.0;
}
for (k = 0; k < nterm; k++) fprintf (stdout, "%8.4f", a[k]); fprintf (stdout, "\n");
/******************************/
/* get input image dimensions */
/******************************/
if (Getifh (imgroot, &ifh) != 0) errr (program, imgroot);
isbig = strcmp (ifh.imagedata_byte_order, "littleendian");
if (!control) control = (isbig) ? 'b' : 'l';
for (k = 0; k < 3; k++) g_voxdim[k] = ifh.scaling_factor[k];
if (debug) printf ("%10.6f%10.6f%10.6f\n", g_voxdim[0], g_voxdim[1], g_voxdim[2]);
g_dimension = ((g_xdim = ifh.matrix_size[0])
*(g_ydim = ifh.matrix_size[1])
*(g_zdim = ifh.matrix_size[2]));
/************************************************/
/* check image index limits against XYZN typedef */
/*************************************************/
if (g_xdim > MAXD || g_ydim > MAXD || g_zdim > MAXD) {
fprintf (stderr, "%s: %s dimension exceeds %d\n", program, imgroot, MAXD);
exit (-1);
}
if (ifh.number_of_bytes_per_pixel != 4) {
printf ("%s: cannot process %d bytes per pixel", program, ifh.number_of_bytes_per_pixel);
exit (-1);
}
/************/
/* allocate */
/************/
if (!(g_img1 = (float *) malloc (g_dimension * sizeof (float)))
|| !(g_img0 = (float *) malloc (g_dimension * sizeof (float)))
|| !(g_imgg = (float *) malloc (g_dimension * sizeof (float)))
|| !(g_imgo = (short *) calloc (g_dimension, sizeof (short)))
|| !(g_imgb = (UCHAR *) calloc (g_dimension, sizeof (UCHAR)))) errm (program);
sprintf (imgfile, "%s.4dfp.img", imgroot);
printf ("Reading: %s\n", imgfile);
if (!(imgfp = fopen (imgfile, "rb")) || eread (g_img0, g_dimension, isbig, imgfp)
|| fclose (imgfp)) errr (program, imgfile);
/******************/
/* pre-blur image */
/******************/
if (!gfreeze && fwhm > 0) {
if (!(img_orig = (float *) malloc (g_dimension * sizeof (float)))) errm (program);
/*************************************/
/* img_orig will hold original image */
/*************************************/
memcpy (img_orig, g_img0, g_dimension*sizeof(float));
memcpy (g_img1, g_img0, g_dimension*sizeof(float));
printf ("blur FWHM = %.2f mm\n", fwhm);
imgdim[0] = g_xdim; imgdim[1] = g_ydim; imgdim[2] = g_zdim;
imgblur3d_ (&fwhm, &alpha, g_voxdim, g_img1, imgdim, g_img0); /* g_img1 returned unusable */
/************************************************************************/
/* g_img0 now points to blurred image to be used in further computation */
/************************************************************************/
}
/*******************/
/* compute outroot */
/*******************/
if (ptr = strrchr (imgroot, '/')) ptr++; else ptr = imgroot;
getroot (ptr, outroot);
/*********************/
/* apply initial gfc */
/*********************/
evalgain3d_ (g_imgg, &g_xdim, &g_ydim, &g_zdim, &norder, a);
for (sum = sum0 = i = 0; i < g_dimension; i++) {
sum0 += g_img0[i];
sum += (g_img1[i] = g_img0[i]/g_imgg[i]);
}
for (i = 0; i < g_dimension; i++) g_img1[i] *= (sum0/sum);
if (gfreeze) goto WRITE;
/****************/
/* open datfile */
/****************/
sprintf (datfile, "%s_gfc.dat", outroot);
if (!(datfp = fopen (datfile, "a"))) errw (program, datfile);
powstring_ (&norder, &eight, string);
fprintf (datfp, "#\t%s\n", string);
fprintf (datfp, "%d\t", niter);
for (k = 0; k < nterm; k++) fprintf (datfp, "%8.4f", a[k]);
fprintf (datfp, "%8.4f\n", 0.0); fflush (datfp);
/***********************/
/* clear region buffer */
/***********************/
memset (&g_region, '\0', MAXR * sizeof (REGION));
iv0 = ir = 0;
/***************************/
/* find contiguous regions */
/***************************/
CONTIG: while (ir < MAXR) {
for (iv = iv0; iv < g_dimension; iv++) if (!g_imgo[iv]) break;
if (iv == g_dimension) break;
iv0 = iv;
g_imgo[iv] = ir + 1;
g_region[ir].u1 = (floor (g_img1[iv] / g_bandwidth) + 0.5) * g_bandwidth;
k = iv;
j = g_dimension;
j /= g_zdim; iz = k / j; k -= iz * j;
j /= g_ydim; iy = k / j; k -= iy * j;
j /= g_xdim; ix = k / j; k -= ix * j;
xyzn.ix = ix; xyzn.iy = iy; xyzn.iz = iz; xyzn.nn = 0;
assign (ir, xyzn);
do {
m = g_region[ir].ne++;
iv = g_region[ir].xyzn[m].ix + g_xdim*(g_region[ir].xyzn[m].iy + g_ydim*g_region[ir].xyzn[m].iz);
for (j = 0; j < 6; j++) {
xyzn = g_region[ir].xyzn[m];
switch (j) {
case 0: k = -1; if (xyzn.ix < 1) continue; xyzn.ix--; break;
case 1: k *= -1; if (xyzn.ix > g_xdim - 2) continue; xyzn.ix++; break;
case 2: k *= -g_xdim; if (xyzn.iy < 1) continue; xyzn.iy--; break;
case 3: k *= -1; if (xyzn.iy > g_ydim - 2) continue; xyzn.iy++; break;
case 4: k *= -g_ydim; if (xyzn.iz < 1) continue; xyzn.iz--; break;
case 5: k *= -1; if (xyzn.iz > g_zdim - 2) continue; xyzn.iz++; break;
}
jv = iv + k;
if (g_imgo[jv] || g_img0[jv] < g_zthresh) continue;
dela = g_img1[jv] - g_region[ir].u1;
if (fabs (dela) < 0.5 * g_bandwidth) {
g_imgo[jv] = ir + 1;
assign (ir, xyzn);
}
}
if (verbose && !(g_region[ir].count % 1000)) {
xyzn = g_region[ir].xyzn[m];
printf ("checkr0: region=%4d unexa=%8d coords=%4d%4d%4d u1=%8.2f\n",
ir, g_region[ir].count - m, xyzn.ix, xyzn.iy, xyzn.iz, g_region[ir].u1);
}
} while (g_region[ir].count > g_region[ir].ne);
if (g_region[ir].count == 1) {
iv = g_region[ir].xyzn[0].ix + g_xdim*(g_region[ir].xyzn[0].iy + g_ydim*g_region[ir].xyzn[0].iz);
g_imgo[iv] = -1;
g_region[ir].count = g_region[ir].ne = 0;
} else {
ir++;
}
}
/************************/
/* sort regions by size */
/************************/
qsort ((void *) g_region, ir, sizeof (REGION), rcompare);
if (ir == MAXR) {
if (verbose) printf ("ir %d -> %d iv0=%10d ivmax=%d\n", ir, MAXR/2, iv0, g_dimension);
while (--ir > MAXR/2) {
for (m = 0; m < g_region[ir].count; m++) {
xyzn = g_region[ir].xyzn[m]; iv = xyzn.ix + g_xdim*(xyzn.iy + g_ydim*xyzn.iz);
g_imgo[iv] = 0;
}
g_region[ir].count = g_region[ir].ne = 0;
}
goto CONTIG;
}
g_nr = ir;
for (ir = g_nr; ir < MAXR; ir++) if (g_region[ir].xyzn) free (g_region[ir].xyzn);
test = 1;
ITER: getmean (); /* analyze g_img1 */
getxyzn0 (); /* analyze g_img1 */
/********************/
/* reassign regions */
/********************/
for (i = 0; i < g_dimension; i++) g_imgo[i] = 0;
printf ("total number of regions %d\n", g_nr);
for (ir = 0; ir < g_nr; ir++) {
g_region[ir].ne = g_region[ir].count = 0;
if (g_region[ir].u1 < g_gfc_thresh || g_region[ir].u1 > g_gfc_ceil) continue;
assign (ir, g_region[ir].xyzn0);
do {
m = g_region[ir].ne++;
xyzn = g_region[ir].xyzn[m];
iv = xyzn.ix + g_xdim*(xyzn.iy + g_ydim*xyzn.iz);
for (j = 0; j < 6; j++) {
xyzn = g_region[ir].xyzn[m];
switch (j) {
case 0: k = -1; if (xyzn.ix < 1) continue; xyzn.ix--; break;
case 1: k *= -1; if (xyzn.ix > g_xdim - 2) continue; xyzn.ix++; break;
case 2: k *= -g_xdim; if (xyzn.iy < 1) continue; xyzn.iy--; break;
case 3: k *= -1; if (xyzn.iy > g_ydim - 2) continue; xyzn.iy++; break;
case 4: k *= -g_ydim; if (xyzn.iz < 1) continue; xyzn.iz--; break;
case 5: k *= -1; if (xyzn.iz > g_zdim - 2) continue; xyzn.iz++; break;
}
jv = iv + k;
if (g_imgo[jv] || g_img0[jv] < g_zthresh) continue;
dela = g_img1[jv] - g_region[ir].u1;
delg = g_sconst * (g_img1[jv] - g_img1[iv]) / g_voxdim[j/2];
if (sqrt (dela*dela + delg*delg) < g_sigma*g_bandwidth) {
g_imgo[jv] = ir + 1;
assign (ir, xyzn);
}
}
if (verbose && !(g_region[ir].count % 1000)) {
xyzn = g_region[ir].xyzn[m];
printf ("checkr1: region=%4d unexa=%8d coords=%4d%4d%4d u1=%8.2f\n",
ir, g_region[ir].count - m, xyzn.ix, xyzn.iy, xyzn.iz, g_region[ir].u1);
}
} while (g_region[ir].count > g_region[ir].ne);
}
getmean (); getxyzn0 (); /* analyze g_img1 */
listreg (stdout);
if (g_region[0].u1 < g_bandwidth) {
fprintf (stderr, "%s: algorithmic failure\n", program);
exit (-1);
}
if (++niter > limiter || !test) goto COUNT;
fprintf (stdout, "%s: iteration %d\n", program, niter);
/***************/
/* compute gfc */
/***************/
for (ir = 0; ir < g_nr; ir++) u1gfc[ir] = g_region[ir].u1;
for (k = 0; k < nterm; k++) a0[k] = a[k];
fitgain3dd_ (g_img0, &g_xdim, &g_ydim, &g_zdim, g_imgo, u1gfc, &g_mr, &norder, a, &drms);
if (negdef) fnegdef_ (a);
printf ("niter=%d drms=%.6f diffcrit=%.6f\n", niter, drms, diffcrit);
fprintf (datfp, "%d\t", niter);
for (k = 0; k < nterm; k++) fprintf (datfp, "%8.4f", a[k]);
fprintf (datfp, "%8.4f\n", 100*drms); fflush (datfp);
evalgain3d_ (g_imgg, &g_xdim, &g_ydim, &g_zdim, &norder, a);
for (sum = i = 0; i < g_dimension; i++) sum += (g_img1[i] = g_img0[i]/g_imgg[i]);
for ( i = 0; i < g_dimension; i++) g_img1[i] *= (sum0/sum);
/********************/
/* convergence test */
/********************/
test = (drms > diffcrit);
goto ITER;
COUNT: fclose (datfp);
/*******************/
/* count neighbors */
/*******************/
for (ir = 0; ir < g_nr; ir++) {
for (g_nl = m = 0; m < g_region[ir].count; m++) {
ix = g_region[ir].xyzn[m].ix;
iy = g_region[ir].xyzn[m].iy;
iz = g_region[ir].xyzn[m].iz;
iv = ix + g_xdim*(iy + g_ydim*iz);
nn = 0;
k = -1; if (ix > 0) {if ((j = g_imgo[iv + k]) == ir + 1) nn++; else enter (j);}
k *= -1; if (ix < g_xdim - 1) {if ((j = g_imgo[iv + k]) == ir + 1) nn++; else enter (j);}
k *= -g_xdim; if (iy > 0) {if ((j = g_imgo[iv + k]) == ir + 1) nn++; else enter (j);}
k *= -1; if (iy < g_ydim - 1) {if ((j = g_imgo[iv + k]) == ir + 1) nn++; else enter (j);}
k *= -g_ydim; if (iz > 0) {if ((j = g_imgo[iv + k]) == ir + 1) nn++; else enter (j);}
k *= -1; if (iz < g_zdim - 1) {if ((j = g_imgo[iv + k]) == ir + 1) nn++; else enter (j);}
if (nn > g_region[ir].nnmax) g_region[ir].nnmax = nn;
g_imgb[iv] = g_region[ir].xyzn[m].nn = nn;
}
if (verbose) {
printf ("%5d%10d%10d%5d%2d |", ir, g_region[ir].count, k, j, g_region[ir].nnmax);
for (i = 0; i < g_nl; i++) printf (" %d", g_list[i]); printf ("\n");
}
}
/*********************************/
/* write gain field coefficients */
/*********************************/
if (!(imgfp = fopen (gfcfile, "w"))) errw (program, gfcfile);
printf ("Writing: %s\n", gfcfile);
for (k = 0; k < nterm; k++) fprintf (imgfp, "%8.4f", a[k]); fprintf (imgfp, "\n");
fclose (imgfp);
/*************************/
/* write corrected image */
/*************************/
WRITE: for (sum0 = sum = i = 0; i < g_dimension; i++) {
if (!gfreeze && fwhm > 0) g_img0[i] = img_orig[i];
sum0 += g_img0[i];
q = 1./g_imgg[i];
t = (maxfac > 0.0) ? 2.*maxfac*tanh(.5*q/maxfac) : q;
if (0) printf ("%10.6f %10.6f\n", q, t);
sum += (g_img1[i] = g_img0[i]*t);
}
for (i = 0; i < g_dimension; i++) g_img1[i] *= (sum0/sum);
vmin = FLT_MAX; vmax = -vmin;
for (i = 0; i < g_dimension; i++) {
if (g_img1[i] < vmin) vmin = g_img1[i];
if (g_img1[i] > vmax) vmax = g_img1[i];
}
sprintf (outfile, "%s_gfc.4dfp.img", outroot);
fprintf (stdout, "Writing: %s\n", outfile);
if (!(imgfp = fopen (outfile, "wb")) || ewrite (g_img1, g_dimension, control, imgfp)
|| fclose (imgfp)) errw (program, outfile);
/***************/
/* ifh and hdr */
/***************/
sprintf (ifhfile, "%s_gfc.4dfp.ifh", outroot);
if (Writeifh (program, ifhfile, &ifh, control)) errw (program, ifhfile);
sprintf (command, "ifh2hdr %s -r%.0f", ifhfile, vmax);
system (command);
/*******/
/* rec */
/*******/
startrece (outfile, argc, argv, g_rcsid, control);
sprintf (string, "%s gain field coefficients\n", imgroot); printrec (string);
powstring_ (&norder, &eight, string); printrec (string);
for (k = 0; k < nterm; k++) {sprintf (string, "%8.4f", a[k]); printrec (string);} printrec ("\n");
if (!gfreeze) {
sprintf (recfile, "%s_gfc.4dfp.img.rec", outroot);
if (!(imgfp = fopen (recfile, "a"))) errw (program, recfile); listreg (imgfp); fclose (imgfp);
}
catrec (imgfile);
endrec ();
if (gfreeze) goto FREE;
/*************************/
/* compute regions image */
/*************************/
for (i = 0; i < g_dimension; i++) g_img1[i] = 0;
for (ir = 0; ir < g_mr; ir++) {
for (m = 0; m < g_region[ir].count; m++) {
xyzn = g_region[ir].xyzn[m];
iv = xyzn.ix + g_xdim*(xyzn.iy + g_ydim*xyzn.iz);
g_img1[iv] = g_region[ir].u1;
}
}
/******************************/
/* write processing QA images */
/******************************/
sprintf (volfile, "%s_gfc_vols.4dfp.img", outroot);
printf ("Writing: %s\n", volfile);
if (!(imgfp = fopen (volfile, "w"))) errw (program, volfile);
/*****************/
/* regions image */
/*****************/
if (ewrite (g_img1, g_dimension, control, imgfp)) errw (program, volfile);
/****************/
/* border image */
/****************/
for (i = 0; i < g_dimension; i++) g_img1[i] = g_imgb[i];
if (ewrite (g_img1, g_dimension, control, imgfp)) errw (program, volfile);
/**************/
/* gain field */
/**************/
for (i = 0; i < g_dimension; i++) g_img1[i] = g_imgg[i];
if (ewrite (g_img1, g_dimension, control, imgfp)) errw (program, volfile);
fclose (imgfp);
/***************/
/* ifh and hdr */
/***************/
sprintf (ifhfile, "%s_gfc_vols.4dfp.ifh", outroot);
ifh.matrix_size[3] = 3;
if (Writeifh (program, ifhfile, &ifh, control)) errw (program, ifhfile);
sprintf (string, "ifh2hdr %s -r%.0f", ifhfile, vmax);
system (string);
/*******/
/* rec */
/*******/
startrece (volfile, argc, argv, g_rcsid, control);
sprintf (string, "%s_gfc QA (3 volumes)\n", imgroot); printrec (string);
catrec (outfile);
printrec ("Volume 1: regions\nVolume 2: border\nVolume 3: gain field\n");
endrec ();
/************/
/* clean up */
/************/
FREE: free (g_img1); free (g_img0); free (g_imgg);
free (g_imgo); free (g_imgb);
if (img_orig) free (img_orig);
for (ir = 0; ir < g_nr; ir++) free (g_region[ir].xyzn);
exit (status);
}
main(int argc, char**argv)
{
int NPTS =0;
int NCHN =0;
int NTRLS =0;
int WIN=0;
int MODORDER=0;
if (argc==9)
{
NCHN=atoi(argv[4]);
NTRLS=atoi(argv[5]);
NPTS=atoi(argv[6]);
WIN=atoi(argv[7]);
MODORDER=atoi(argv[8]);
}
else if ( argc!=4 && argc!=9)
{
fprintf(stderr,"opsswhite datfile A Ve Nchannels Ntrails Npoints WIN MODORDER\n");
exit(1);
}
else {
double chan[1],trai[1],poin[1],wind[1],order[1];
FILE *chanfp,*traifp,*poinfp,*windfp,*orderfp;
if((chanfp=fopen("channel","r"))==NULL)
printf("The file'channel' was not opened\n");
else
fscanf(chanfp,"%lf",&chan[0]);
NCHN=(int)chan[0];
fclose(chanfp);
if((traifp=fopen("trail","r"))==NULL)
printf("The file'trail' was not opened\n");
else
fscanf(traifp,"%lf",&trai[0]);
NTRLS=(int)trai[0];
fclose(traifp);
if((poinfp=fopen("points","r"))==NULL)
printf("The file'points' was not opened\n");
else
fscanf(poinfp,"%lf",&poin[0]);
NPTS=(int)poin[0];
fclose(poinfp);
if((windfp=fopen("window","r"))==NULL)
printf("The file'window' was not opened\n");
else
fscanf(windfp,"%lf",&wind[0]);
WIN=(int)wind[0];
fclose(windfp);
if((orderfp=fopen("order","r"))==NULL)
printf("The file'order' was not opened\n");
else
fscanf(orderfp,"%lf",&order[0]);
MODORDER=(int)order[0];
fclose(orderfp);}
FILE *inpt, *shfp, *stimp, *fp;
FILE *fr;
int *shift, *stim;
int shfmin=0, shfmax=0, stimmin, stimmax;
double *A[MAXORDER],*Ve,*tildA;
float **dat;
double **x; /* rout is residual output */
int *n; /* n[j] is the number of data in j-th segment, 120 */
int i, j, k, rec, idx, t;
double **rout; /* rout is residual output */
double *xtemp[NCHN];
double *rtemp[NCHN];
double mean[NCHN], ss[NCHN], corfun[50], sigthresh, prob;
int nlags = 5;
int nresids = WIN-MODORDER;
int l, lag, nsig=0, ntot=0;
sigthresh = 2.000 / sqrt((double)nresids);
if( argc<4)
{
fprintf(stderr,"Usage: opss datfile A Ve\n");
exit(1);
}
for(i=0;i<MAXORDER;i++){
if((A[i]=malloc(NCHN*NCHN*sizeof(double)))==NULL)
EEGerror("main---memory allocation error\n");
}
if((tildA=malloc(MAXORDER*(MAXORDER+1)*NCHN*NCHN*sizeof(double)/2))==NULL)
EEGerror("main---memory allocation error\n");
if((Ve=malloc(NCHN*NCHN*sizeof(double)))==NULL)
EEGerror("main---memory allocation error\n");
/* allocation of memory for dat */
dat = malloc(NCHN*sizeof(float*));
for( i = 0; i < NCHN; i++)
dat[i] = malloc(WIN*NTRLS*sizeof(float));
x = malloc(NCHN*sizeof(double*));
for( i = 0; i < NCHN; i++)
x[i] = malloc(WIN*NTRLS*sizeof(double));
/*** For residual calculation ****/
rout = malloc(NCHN*sizeof(double*));
for( i = 0; i < NCHN; i++)
rout[i] = malloc((WIN-MODORDER)*NTRLS*sizeof(double));
/*
rtemp = malloc(NCHN*sizeof(double*));
for( i = 0; i < NCHN; i++)
rtemp[i] = malloc((WIN-MODORDER)*sizeof(double));
*/
n=malloc(NTRLS*sizeof(int));
shift = malloc(NTRLS*sizeof(int));
stim = malloc(NTRLS*sizeof(int));
if((inpt = fopen(argv[1],"rb")) == NULL) {
printf("\007Error opening input file!\n"); return;
}
/* if((shfp = fopen(argv[2],"rt")) == NULL) {
printf("\007Error opening shift file!\n"); return;
}
if((stimp = fopen(argv[3],"rt")) == NULL) {
printf("\007Error opening stim file!\n"); return;
}
*/
/* Initialization, required by MARfit */
for( i = 0; i < NTRLS; i++) n[i] = WIN;
/* for( i=0; i<NTRLS; i++ ) fscanf(shfp,"%d",&shift[i]); */
/* for( i=0; i<NTRLS; i++ ) fscanf(shfp,"%d", &shift[i]);
fclose(shfp);
minmax(NTRLS, shift, &shfmin, &shfmax);*/
/* printf("min, max = %d %d\n", shfmin, shfmax); */
/* for( i=0; i<NTRLS; i++ ) fscanf(stimp,"%d", &stim[i]);
fclose(stimp);
minmax(NTRLS, stim, &stimmin, &stimmax);*/
stimmin=0; /* convert to points */
/* printf("min, max = %d %d\n", stimmin, stimmax); */
/* printf("Trl, CHN, T, WIN = %d %d %d %d\n",NTRLS,NCHN, NPTS, WIN); */
/********* read monkey dat *********/
t = -(stimmin - WIN/2)*5 - 5; /* - (20-8)*5 +5 = -60 - 5 msec */
/* for (rec=3; rec < 104; rec++) { */
for ( rec=abs(shfmin); rec < (NPTS-WIN-shfmax+1); rec++) {
t+=5;
/*printf("index, t = %d %d msec\n", (rec-abs(shfmin)+1), t);*/
for( j = 0; j < NCHN; j++){
idx=0;
for( i = 0; i < NTRLS; i++){
if(fseek(inpt, sizeof(float)*(shift[i] + rec + i*NCHN*NPTS + j*NPTS), 0) != 0){
printf("Error in fseek\n"); exit(-1);
}
if( fread(&dat[j][idx],sizeof(float),WIN,inpt) !=WIN) {
if(feof(inpt))
{printf("premature end of file in read data");exit(-1);}
else {printf("file read error");exit(-1);}
}
idx+=WIN;
}
}
/*
for( i = 0; i < 3; i++){
for( j = 0; j < WIN*NTRLS; j++) {
printf("%f\n", dat[i][j]);
}
printf("OOOOOOOO\n");
}
*/
/* convert data format from float to double */
for (i=0; i < NCHN; i++)
for(j=0; j < WIN*NTRLS; j++)
x[i][j] = dat[i][j];
MARfit(x,NCHN,n,NTRLS,MODORDER,tildA);
EEGrealA(tildA,A,Ve,NCHN,MODORDER);
/*
MARfit(x,NCHN,n,NTRLS,6,tildA);
EEGrealA(tildA,A,Ve,NCHN,5);
*/
/****** calculate residual of MVAR for whiteness test *******/
/* First loop over trials, and then loop over channels & allocate memory for
xtemp & rtemp at proper locations in x & rout */
if((fr = fopen("resid.out","a")) == NULL) {
printf("\007Error opening MAR coeff file!\n"); return;
}
for(j=0;j<NTRLS;j++){
for(k=0;k<NCHN;k++){
xtemp[k]=x[k]+j*WIN;
rtemp[k]=rout[k] + j*(WIN-MODORDER);
}
MAR_residual(xtemp,rtemp,A,NCHN,MODORDER,WIN);
/* compute mean and sum of squares for residuals of each channel */
for(k=0;k<NCHN;k++){
mean[k] = getmean(rtemp[k],nresids);
ss[k] = getss(rtemp[k],mean[k],nresids);
/* fprintf(stderr,"%d %lf %lf\n", k, mean[k], ss[k]);*/
}
/* loop over channel pairs to get correlations */
for(k=0;k<NCHN;k++){
for(l=0;l<NCHN;l++){
if(l >= k){
cor(rtemp[k],mean[k],ss[k],rtemp[l],mean[l],ss[l],nresids,nlags,corfun);
for(lag=0;lag<nlags*2;lag++){
ntot++;
if(fabs(corfun[lag]) > sigthresh){
nsig++;
}
}
}
}
}
} /* end of trial */
prob = (double)nsig / (double)ntot;
fprintf(fr,"%lf\n", prob);
fclose(fr);
/*** write MAR coefficients(including noise) to output files ***/
/*** Each line of the output file corresponds to ONE MAR model at each
given time instant ***/
if((fp = fopen(argv[2],"a")) == NULL) {
printf("\007Error opening MAR coeff file!\n"); return;
}
/* for ( i=0; i < 6; i++) *//* 5 order, 1st is identity; if 7, then new =0 */
for ( i=0; i < MODORDER+1; i++) /* 5 order, 1st is identity; if 7, then new =0 */
for ( j=0; j < NCHN*NCHN; j++)
fprintf(fp,"%.3g ",A[i][j]);
fprintf(fp,"\n");
fclose(fp);
if((fp = fopen(argv[3],"a")) == NULL) {
printf("\007Error opening MAR noise file!\n"); return;
}
for ( i=0; i < NCHN*NCHN; i++)
fprintf(fp,"%.3g ",Ve[i]);
fprintf(fp,"\n");
fclose(fp);
/* if((fp = fopen(argv[6],"a")) == NULL) {
printf("\007Error opening time file!\n"); return;
}
fprintf(fp,"%d\n", t);
fclose(fp);
*/
} /* end of rec */
free(tildA);
free(Ve);
for(i=0;i<MAXORDER;i++)free(A[i]);
free(n);
for (i = 0; i < NCHN; i++)
free(dat[i]);
free(dat);
for (i = 0; i < NCHN; i++)
free(x[i]);
free(x);
for (j = 0; j < NCHN; j++){
free(rout[j]);
}
free(rout);
exit(0);
}
void RunStatsCommand(ProgramData *p, int lcindex, int threadindex, _Stats *s)
{
int i, j, k, Npct;
double *tmpdata = NULL, *tmpweight = NULL;
if(p->NJD[threadindex] <= 0) {
for(i=0, k=0; i < s->Nvar; i++) {
for(j=0; j < s->Nstats; j++, k++) {
s->statsout[threadindex][k] = 0.0;
}
}
return;
}
if((tmpdata = (double *) malloc(p->NJD[threadindex]*sizeof(double))) == NULL) {
error(ERR_MEMALLOC);
}
for(i = 0, k=0; i < s->Nvar; i++) {
if(s->vars[i]->vectortype != VARTOOLS_VECTORTYPE_LC) {
error(ERR_BADVARIABLETYPE_STATSCOMMAND);
}
for(j=0; j < p->NJD[threadindex]; j++) {
tmpdata[j] = EvaluateVariable_Double(lcindex, threadindex, j, s->vars[i]);
}
Npct = 0;
for(j = 0; j < s->Nstats; j++, k++) {
switch(s->statstocalc[j]) {
case VARTOOLS_STATSTYPE_MEAN:
s->statsout[threadindex][k] = getmean(p->NJD[threadindex], tmpdata);
break;
case VARTOOLS_STATSTYPE_WEIGHTEDMEAN:
s->statsout[threadindex][k] = getweightedmean(p->NJD[threadindex], tmpdata, p->sig[threadindex]);
break;
case VARTOOLS_STATSTYPE_MEDIAN:
s->statsout[threadindex][k] = median(p->NJD[threadindex], tmpdata);
break;
case VARTOOLS_STATSTYPE_MEDIAN_WEIGHT:
s->statsout[threadindex][k] = median_weight(p->NJD[threadindex], tmpdata, p->sig[threadindex]);
break;
case VARTOOLS_STATSTYPE_STDDEV:
s->statsout[threadindex][k] = stddev(p->NJD[threadindex], tmpdata);
break;
case VARTOOLS_STATSTYPE_MEDDEV:
s->statsout[threadindex][k] = meddev(p->NJD[threadindex], tmpdata);
break;
case VARTOOLS_STATSTYPE_MEDMEDDEV:
s->statsout[threadindex][k] = medmeddev(p->NJD[threadindex], tmpdata);
break;
case VARTOOLS_STATSTYPE_MAD:
s->statsout[threadindex][k] = MAD(p->NJD[threadindex], tmpdata);
break;
case VARTOOLS_STATSTYPE_KURTOSIS:
s->statsout[threadindex][k] = kurtosis(p->NJD[threadindex], tmpdata);
break;
case VARTOOLS_STATSTYPE_SKEWNESS:
s->statsout[threadindex][k] = skewness(p->NJD[threadindex], tmpdata);
break;
case VARTOOLS_STATSTYPE_PERCENTILE:
s->statsout[threadindex][k] = percentile(p->NJD[threadindex],
tmpdata,
s->pctval[Npct]);
Npct++;
break;
case VARTOOLS_STATSTYPE_PERCENTILE_WEIGHT:
s->statsout[threadindex][k] = percentile_weight(p->NJD[threadindex],
tmpdata,
p->sig[threadindex],
s->pctval[Npct]);
Npct++;
break;
case VARTOOLS_STATSTYPE_MAXIMUM:
s->statsout[threadindex][k] = getmaximum(p->NJD[threadindex],tmpdata);
break;
case VARTOOLS_STATSTYPE_MINIMUM:
s->statsout[threadindex][k] = getminimum(p->NJD[threadindex],tmpdata);
break;
case VARTOOLS_STATSTYPE_SUM:
s->statsout[threadindex][k] = getsum(p->NJD[threadindex],tmpdata);
break;
default:
error(ERR_CODEERROR);
}
}
}
if(tmpdata != NULL)
free(tmpdata);
}
