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); }