nfilter nallocate(int np /* number of patches */,
int nd /* data size */,
int *nh /* filter size [np] */,
int *pch /* patching [nd] */)
/*< allocate >*/
{
nfilter aa;
int ip, id;
aa = (nfilter) sf_alloc(1,sizeof(*aa));
aa->np = np;
aa->hlx = (sf_filter*) sf_alloc(np,sizeof(sf_filter));
for (ip=0; ip < np; ip++) {
aa->hlx[ip] = sf_allocatehelix(nh[ip]);
}
aa->pch = sf_intalloc(nd);
for (id=0; id < nd; id++) {
aa->pch[id] = pch[id];
}
aa->mis = NULL;
return aa;
}
int main(int argc, char* argv[])
{
int n1, i1, n2, i2, na, tempna, ia, niter, center=0;
float *data;
sf_filter aa;
sf_file in, out;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
n2 = sf_leftsize(in,1);
if (!sf_getint("na",&na)) na=3;
/* PEF length */
na--;
if (!sf_getint("niter",&niter)) niter=10;
/* number of iterations */
data = sf_floatalloc(n1);
aa = sf_allocatehelix(na);
tempna = na;
for (i2=0; i2 < n2; i2++) {
sf_floatread(data,n1,in);
aa->flt[0]=-2;
aa->flt[1]=1;
for (ia=0; ia < na; ia++) {
aa->lag[ia] = ia+1;
}
bound (1, &n1, &n1, &na, aa);
pefest (na * 2, n1, data, aa);
for (i1=0; i1 < n1; i1++) {
aa->mis[i1] = false;
}
na++;
print (1, &n1, ¢er, &na, aa);
fixbad (niter, aa, n1, data);
sf_floatwrite(data,n1,out);
na = tempna;
}
exit(0);
}
sf_filter steep(int dim /* number of dimensions */,
int *n /* data size [dim] */,
int *a /* filter size [dim] */,
float *d /* axis sampling [dim] */,
float vel /* velocity */,
float tgap /* time gap */)
/*< define PEF >*/
{
int *lag, c[SF_MAX_DIM], i, h, na, j;
float x, t0;
sf_filter aa;
na = 1;
for (j=0; j < dim; j++) {
na *= a[j];
}
lag = sf_intalloc(na);
for (h=i=0; i < na; i++) {
sf_line2cart(dim, a, i, c);
for (j=0; j < dim-1; j++) {
c[j] -= (a[j]-1)/2;
}
t0 = 0.;
for (j=0; j < dim-1; j++) {
x = d[j]*c[j];
t0 += x*x;
}
t0 = sqrtf(t0)/vel;
if (t0 < tgap) t0 = tgap;
x = d[dim-1]*c[dim-1];
if(x >= t0) {
lag[h] = sf_cart2line(dim, n, c);
h++;
}
}
aa = sf_allocatehelix(h);
for (i=0; i < h; i++) {
aa->lag[i] = lag[i];
aa->flt[i] = 0.;
}
free(lag);
return aa;
}
sf_filter conv(const sf_filter aa,
const sf_filter bb,
bool one /* include leading one */)
/*< convolve aa and bb >*/
{
sf_filter ss;
int na, nb, amax, bmax, ns, ia, ib, i;
na = aa->nh;
nb = bb->nh;
amax = 0;
for (i=0; i < na; i++) {
if (aa->lag[i] > amax) amax = aa->lag[i];
}
bmax = 0;
for (i=0; i < nb; i++) {
if (bb->lag[i] > bmax) bmax = bb->lag[i];
}
ns = amax+bmax;
ss = sf_allocatehelix(ns);
for (i=0; i < ns; i++) {
ss->lag[i] = i+1;
ss->flt[i] = 0.;
}
if (one) {
for (ia=0; ia < na; ia++) {
i = aa->lag[ia];
ss->flt[i-1] = aa->flt[ia];
}
for (ib=0; ib < nb; ib++) {
i = bb->lag[ib];
ss->flt[i-1] += bb->flt[ib];
}
}
for (ia=0; ia < na; ia++) {
for (ib=0; ib < nb; ib++) {
i = aa->lag[ia] + bb->lag[ib];
ss->flt[i-1] += aa->flt[ia] * bb->flt[ib];
}
}
return compress(ss,FLT_EPSILON);
}
int main(int argc, char* argv[])
{
int n123, n1, i, ik, dim, nk, nf, sf, niter, nw;
int n[SF_MAX_DIM], w[SF_MAX_DIM], k[SF_MAX_DIM];
int sa[SF_MAX_DIM], na[SF_MAX_DIM], sc[SF_MAX_DIM], nc[SF_MAX_DIM];
int ma[SF_MAX_DIM], mc[SF_MAX_DIM];
float *data, *wind, *sign, eps, di, dabs;
char varname[6], *lagfile;
sf_filter saa, naa, sbb, nbb, scc, ncc;
sf_file dat, signal, spef, npef, slag, nlag;
sf_init (argc,argv);
dat = sf_input("in");
signal = sf_output("out");
spef = sf_input("sfilt");
npef = sf_input("nfilt");
n123 = sf_filesize(dat);
if (!sf_histint(spef,"dim",&dim)) sf_error("No dim= in sfilt");
n1 = 1;
for (i=0; i < dim; i++) {
sprintf(varname,"n%d",i+1);
if (!sf_histint(dat,varname,n+i))
sf_error("No %s= in input",varname);
n1 *= n[i];
}
if (!sf_histints(spef,"w",w,dim)) sf_error("No w= in sfilt");
if (!sf_histints(spef,"k",k,dim)) sf_error("No k= in sfilt");
if (!sf_histints(spef,"a",sa,dim)) sf_error("No a= in sfilt");
if (!sf_histints(npef,"a",na,dim)) sf_error("No a= in nfilt");
if (!sf_histints(spef,"center",sc,dim)) sf_error("No center= in sfilt");
if (!sf_histints(npef,"center",nc,dim)) sf_error("No center= in nfilt");
nk=nw=1;
for (i=0; i < dim; i++) {
nw *= w[i];
nk *= k[i];
}
if (!sf_histint(spef,"n1",&sf)) sf_error("No n1= in sfilt");
if (!sf_histint(npef,"n1",&nf)) sf_error("No n1= in nfilt");
sbb = sf_allocatehelix(sf);
nbb = sf_allocatehelix(nf);
if (NULL == (lagfile = sf_histstring(spef,"lag")) &&
NULL == (lagfile = sf_getstring("slag")))
sf_error("Need slag=");
slag = sf_input(lagfile);
if (NULL == (lagfile = sf_histstring(npef,"lag")) &&
NULL == (lagfile = sf_getstring("nlag")))
sf_error("Need nlag=");
nlag = sf_input(lagfile);
sf_intread(sbb->lag,sf,slag);
sf_intread(nbb->lag,nf,nlag);
if (!sf_getfloat("eps",&eps)) sf_error("Need eps=");
/* regularization parameter */
if (!sf_getint("niter",&niter)) niter=20;
/* number of iterations */
data = sf_floatalloc(n123);
sign = sf_floatalloc(n123);
sf_floatread(data,n123,dat);
dabs = fabsf(data[0]);
for (i=1; i < n123; i++) {
di = fabsf(data[i]);
if (di > dabs) dabs=di;
}
for (i=0; i < n123; i++) {
data[i] /= dabs;
}
saa = (sf_filter) sf_alloc(nk,sizeof(*saa));
naa = (sf_filter) sf_alloc(nk,sizeof(*naa));
for (ik=0; ik < nk; ik++) {
scc = saa+ik;
ncc = naa+ik;
scc->nh = sf;
ncc->nh = nf;
scc->flt = sf_floatalloc(sf);
ncc->flt = sf_floatalloc(nf);
scc->lag = sbb->lag;
ncc->lag = nbb->lag;
scc->mis = NULL;
ncc->mis = NULL;
}
wind = sf_floatalloc(nw);
for (i=0; i < dim; i++) {
mc[i] = SF_MIN(sc[i],nc[i]);
ma[i] = SF_MIN(sa[i],na[i]);
}
tent (dim, w, mc, ma, wind);
for (i=0; i < n123-n1+1; i += n1) {
signoi_init (naa, saa, niter, nw, eps, false);
for (ik=0; ik < nk; ik++) {
sf_floatread((naa+ik)->flt,nf,npef);
sf_floatread((saa+ik)->flt,sf,spef);
}
patching (signoi_lop, data+i, sign+i, dim, k, n, w, wind);
}
sf_floatwrite (sign,n123,signal);
exit(0);
}
int main(int argc, char* argv[])
{
bool verb;
int n[SF_MAX_DIM], n0[SF_MAX_DIM], rect[SF_MAX_DIM];
int a[SF_MAX_DIM], center[SF_MAX_DIM], gap[SF_MAX_DIM];
int ndim, dim, n123, n123s, i, ia, ns, i1, niter, na, i4, n4, *kk;
float *d, *f, *dd;
double mean;
char *lagfile, key[6];
sf_filter aa;
sf_file in, filt, lag;
sf_init(argc,argv);
in = sf_input("in");
filt = sf_output("out");
if (NULL == (lagfile = sf_getstring("lag"))) sf_error("Need lag=");
/* output file for filter lags */
lag = sf_output(lagfile);
sf_settype(lag,SF_INT);
sf_putstring(filt,"lag",lagfile);
ndim = sf_filedims(in,n);
if (!sf_getint("dim",&dim)) dim=ndim; /* number of dimensions */
n4 = sf_leftsize(in,dim);
sf_putints (lag,"n",n,dim);
if (!sf_getints("a",a,dim)) sf_error("Need a=");
if (!sf_getints("center",center,dim)) {
for (i=0; i < dim; i++) {
center[i] = (i+1 < dim && a[i+1] > 1)? a[i]/2: 0;
}
}
if (!sf_getint("na",&na)) na=0;
/* filter size */
if (0 == na) {
if (!sf_getints("gap",gap,dim)) {
for (i=0; i < dim; i++) {
gap[i] = 0;
}
}
aa = createhelix(dim, n, center, gap, a); /* allocate PEF */
for (i=0; i < dim; i++) {
n0[i] = n[i];
}
} else {
aa = sf_allocatehelix (na);
if (!sf_getints ("lags", aa->lag, na)) sf_error("Need lags=");
if (!sf_getints ("n", n0, dim)) {
for (i=0; i < dim; i++) {
n0[i] = n[i];
}
}
}
n123 = 1;
for (i=0; i < dim; i++) {
n123 *= n[i];
snprintf(key,6,"rect%d",i+1);
if (!sf_getint(key,rect+i)) rect[i]=1;
}
dd = sf_floatalloc(n123);
kk = sf_intalloc(n123);
for (i1=0; i1 < n123; i1++) {
kk[i1] = 1;
}
bound (dim, n0, n, a, aa);
find_mask(n123, kk, aa);
na = aa->nh;
snprintf(key,3,"n%d",dim+1);
sf_putint(filt,key,na);
sf_shiftdim(in, filt, dim+1);
if (!sf_getint("niter",&niter)) niter=100;
/* number of iterations */
if (!sf_getbool("verb",&verb)) verb = true;
/* verbosity flag */
n123s = n123*na;
d = sf_floatalloc(n123s);
f = sf_floatalloc(n123s);
sf_multidivn_init(na, dim, n123, n, rect, d, NULL, verb);
for (i4=0; i4 < n4; i4++) {
sf_floatread(dd,n123,in);
/* apply shifts: dd -> d */
mean = 0.;
for (i=ia=0; ia < na; ia++) {
ns = aa->lag[ia];
for (i1=0; i1 < n123; i1++,i++) {
if (i1 < ns) {
d[i] = 0.0f;
} else {
d[i] = dd[i1-ns];
mean += d[i]*d[i];
}
}
}
if (mean == 0.) {
sf_floatwrite(d,n123s,filt);
continue;
}
mean = sqrt (n123s/mean);
/* -> apply mask */
for(i=0; i < n123s; i++) {
d[i] *= mean;
}
for(i1=0; i1 < n123; i1++) {
dd[i1] *= mean;
}
sf_multidivn (dd,f,niter);
sf_floatwrite(f,n123s,filt);
}
exit(0);
}
int main(int argc, char* argv[])
{
int i, ia, na, nx, ns, dim, n[SF_MAX_DIM], m[SF_MAX_DIM];
float a0, *pp, *qq;
bool adj;
sf_filter aa;
char* lagfile;
sf_file in, out, filt, lag;
sf_init (argc,argv);
in = sf_input("in");
filt = sf_input("filt");
out = sf_output("out");
dim = sf_filedims (in,n);
if (!sf_histint(filt,"n1",&na)) sf_error("No n1= in filt");
aa = sf_allocatehelix (na);
if (!sf_histfloat(filt,"a0",&a0)) a0=1.;
sf_floatread (aa->flt,na,filt);
for( ia=0; ia < na; ia++) {
aa->flt[ia] /= a0;
}
if (NULL != (lagfile = sf_getstring("lag")) /* file with filter lags */
||
NULL != (lagfile = sf_histstring(filt,"lag"))) {
lag = sf_input(lagfile);
sf_intread(aa->lag,na,lag);
} else {
lag = NULL;
for( ia=0; ia < na; ia++) {
aa->lag[ia] = ia+1;
}
}
sf_fileclose(filt);
if (!sf_getints ("n",m,dim) && (NULL == lag ||
!sf_histints (lag,"n",m,dim))) {
for (i=0; i < dim; i++) {
m[i] = n[i];
}
}
if (NULL != lag) sf_fileclose(lag);
regrid (dim, m, n, aa);
if (!sf_getbool ("adj",&adj)) adj=false;
/* if y, do adjoint operation */
if (!sf_getint ("ns",&ns)) sf_error("Need ns=");
/* scaling */
nx = 1;
for( i=0; i < dim; i++) {
nx *= n[i];
}
pp = sf_floatalloc (nx);
qq = sf_floatalloc (nx);
if (adj) {
sf_floatread (qq,nx,in);
} else {
sf_floatread (pp,nx,in);
}
hshape_init (nx,ns,aa);
hshape_lop (adj,false,nx,nx,pp,qq);
if (adj) {
sf_floatwrite (pp,nx,out);
} else {
sf_floatwrite (qq,nx,out);
}
exit (0);
}
int main(int argc, char* argv[])
{
bool verb;
int n[SF_MAX_DIM], m[SF_MAX_DIM], rect[SF_MAX_DIM];
int ndim, mdim, nd, ns, n12, i, j, niter, na, ia, i4, n4=1;
float *d, *f, *g, mean, a0;
char key[6], *peffile, *lagfile;
sf_filter aa;
sf_file dat, flt, mat, pre, pef, lag;
sf_init(argc,argv);
dat = sf_input("in");
mat = sf_input("match");
flt = sf_output("out");
if (NULL != sf_getstring("pred")) {
pre = sf_output("pred");
} else {
pre = NULL;
}
ndim = 3;
mdim = 2;
if (!sf_histint(dat,"n1",&n[0])) sf_error("No n1= in input");
if (!sf_histint(dat,"n2",&n[1])) sf_error("No n2= in input");
if (!sf_histint(dat,"n3",&n[2])) sf_error("No n3= in input");
n[3] = sf_leftsize(dat,3);
if (!sf_histint(mat,"n1",&m[0])) sf_error("No n1= in match");
if (!sf_histint(mat,"n2",&m[1])) sf_error("No n2= in match");
m[2] = sf_leftsize(mat,2);
if (mdim > ndim)
sf_error("Wrong dimensions: %d > %d",mdim,ndim);
if (m[2] != n[3]) {
sf_error("Size mismatch [n%d] : %d != %d",3,m[2],n[3]);
} else {
n4 = n[3];
}
nd = 1;
for (j=0; j < mdim; j++) {
if (m[j] != n[j])
sf_error("Size mismatch [n%d]: %d != %d",
j+1,m[j],n[j]);
nd *= m[j];
snprintf(key,6,"rect%d",j+1);
if (!sf_getint(key,rect+j)) rect[j]=1;
}
for (ns = 1; j < ndim; j++) {
ns *= n[j];
if (pre) {
snprintf(key,6,"n%d",j+1);
sf_putint(pre,key,n4);
snprintf(key,6,"n%d",j+2);
sf_putint(pre,key,1);
}
}
n12 = nd*ns;
if (!sf_getint("niter",&niter)) niter=100;
/* number of iterations */
if (!sf_getbool("verb",&verb)) verb=true;
/* verbosity flag */
if (NULL == (peffile = sf_getstring("pef"))) {
/* signal PEF file (optional) */
aa = NULL;
} else {
pef = sf_input(peffile);
if (!sf_histint(pef,"n1",&na))
sf_error("No n1= in pef");
aa = sf_allocatehelix (na);
if (!sf_histfloat(pef,"a0",&a0)) a0=1.;
sf_floatread (aa->flt,na,pef);
for( ia=0; ia < na; ia++) {
aa->flt[ia] /= a0;
}
if (NULL != (lagfile = sf_getstring("lag"))
||
NULL != (lagfile = sf_histstring(pef,"lag"))) {
/* file with PEF lags (optional) */
lag = sf_input(lagfile);
sf_intread(aa->lag,na,lag);
sf_fileclose(lag);
} else {
for( ia=0; ia < na; ia++) {
aa->lag[ia] = ia+1;
}
}
}
d = sf_floatalloc(n12);
f = sf_floatalloc(n12);
g = sf_floatalloc(nd);
for(i4=0; i4 < n4; i4++) {
fprintf(stderr,"slice %d of %d\n",i4+1,n4);
for (i=0; i < n12; i++) {
d[i] = 0.;
}
sf_multidivn_init(ns, mdim, nd, m, rect, d, aa, verb);
sf_floatread(d,n12,dat);
sf_floatread(g,nd,mat);
mean = 0.;
for(i=0; i < n12; i++) {
mean += d[i]*d[i];
}
if (mean == 0.) {
sf_floatwrite(d,n12,flt);
continue;
}
mean = sqrtf (mean/n12);
for(i=0; i < n12; i++) {
d[i] /= mean;
}
for(i=0; i < nd; i++) {
g[i] /= mean;
}
sf_multidivn (g,f,niter);
sf_floatwrite(f,n12,flt);
if (pre) {
for(i=0; i < n12; i++) {
d[i] *= mean;
}
sf_weight2_lop(false,false,n12,nd,f,g);
sf_floatwrite(g,nd,pre);
}
}
exit(0);
}
int main(int argc, char* argv[])
{
int n[2], w[2], k[2], a[2], l[2], n12, w12, i;
float *wall, *data, *windwt;
sf_filter aa;
sf_file wind, out;
sf_init (argc, argv);
out = sf_output("out");
sf_setformat(out,"native_float");
if (!sf_getint("n1",&n[0])) n[0] = 100;
if (!sf_getint("n2",&n[1])) n[1] = 30;
sf_putint(out,"n1",n[0]);
sf_putint(out,"n2",n[1]);
if (!sf_getint("w1",&w[0])) w[0] = 17;
if (!sf_getint("w2",&w[1])) w[1] = 6;
if (!sf_getint("k1",&k[0])) k[0] = 5;
if (!sf_getint("k2",&k[1])) k[1] = 11;
if (!sf_getint("a1",&a[0])) a[0] = 1;
if (!sf_getint("a2",&a[1])) a[1] = 1;
if (!sf_getint("lag1",&l[0])) l[0] = 1;
if (!sf_getint("lag2",&l[1])) l[1] = 1;
n12 = n[0]*n[1];
w12 = w[0]*w[1];
wall = sf_floatalloc(n12);
data = sf_floatalloc(n12);
windwt = sf_floatalloc(w12);
for (i=0; i < n12; i++) {
wall[i] = 1.;
}
aa = sf_allocatehelix (1);
aa->lag[0] = 1;
tent (2, w, l, a, windwt);
if (NULL != sf_getstring("wind")) {
/* optional output file for window weight */
wind = sf_output("wind");
sf_setformat(wind,"native_float");
sf_putint(wind,"n1",w[0]);
sf_putint(wind,"n2",w[1]);
sf_floatwrite (windwt,w12,wind);
sf_fileclose(wind);
}
sf_helicon_init (aa);
patching (sf_helicon_lop, wall, data, 2, k, n, w, windwt);
for (i=0; i < n12; i+= n[0]) {
data[i] = 0.;
}
for (i=1; i < n12; i+= n[0]) {
data[i] = 0.;
}
for (i=n[0]-2; i < n12; i+= n[0]) {
data[i] = 0.;
}
for (i=n[0]-1; i < n12; i+= n[0]) {
data[i] = 0.;
}
sf_floatwrite(data,n12,out);
exit (0);
}
int main(int argc, char* argv[])
{
bool spitz, verb;
int niter, sa, na, j, dim, nx, n[SF_MAX_DIM], m[SF_MAX_DIM];
float *dd, *ss, eps, na0, sa0;
char varname[6], *lagfile;
sf_filter naa, saa;
sf_file spef, npef, dat, signoi, slag, nlag;
sf_init(argc,argv);
dat = sf_input("in");
signoi = sf_output("out");
spef = sf_input("sfilt");
npef = sf_input("nfilt");
dim = sf_filedims(dat,n);
if (!sf_histint(spef,"n1",&sa)) sf_error("No n1= in sfilt");
if (!sf_histint(npef,"n1",&na)) sf_error("No n1= in nfilt");
naa = sf_allocatehelix(na);
saa = sf_allocatehelix(sa);
if (NULL == (lagfile = sf_histstring(spef,"lag")) &&
NULL == (lagfile = sf_getstring("slag")))
sf_error("Need slag=");
slag = sf_input(lagfile);
if (!sf_histints(slag,"n",m,dim)) sf_error("No n= in %s",lagfile);
sf_intread(saa->lag,sa,slag);
regrid(dim,m,n,saa);
sf_fileclose(slag);
if (NULL == (lagfile = sf_histstring(npef,"lag")) &&
NULL == (lagfile = sf_getstring("nlag")))
sf_error("Need nlag=");
nlag = sf_input(lagfile);
if (!sf_histints(nlag,"n",m,dim)) sf_error("No n= in %s",lagfile);
sf_intread(naa->lag,na,nlag);
regrid(dim,m,n,naa);
sf_fileclose(nlag);
if (!sf_histfloat(spef,"a0",&sa0)) sa0=1.;
if (!sf_histfloat(npef,"a0",&na0)) na0=1.;
if (!sf_getfloat("epsilon",&eps)) sf_error("Need eps=");
/* regularization parameter */
if (!sf_getint("niter",&niter)) niter=20;
/* number of iterations */
sprintf(varname,"n%d",dim+1);
sf_putint(signoi,varname,2);
nx=1;
for(j=0; j < dim; j++) {
nx *= n[j];
}
dd = sf_floatalloc(nx);
ss = sf_floatalloc(nx);
sf_floatread(dd,nx,dat);
sf_floatread(saa->flt,sa,spef);
for (j=0; j < sa; j++) {
saa->flt[j] /= sa0;
}
sf_floatread(naa->flt,na,npef);
for (j=0; j < na; j++) {
naa->flt[j] /= na0;
}
if (!sf_getbool("spitz",&spitz)) spitz=false;
/* if use Spitz method */
if (!sf_getbool("verb",&verb)) verb=false;
/* verbosity flag */
signoi_init (naa, saa, niter, nx, eps, verb);
if (spitz) {
signoi2_lop (false,false,nx,nx,dd,ss);
} else {
signoi_lop (false,false,nx,nx,dd,ss);
}
sf_floatwrite(ss,nx,signoi);
for (j=0; j < nx; j++) {
dd[j] -= ss[j];
}
sf_floatwrite(dd,nx,signoi);
exit (0);
}
int main(int argc, char* argv[])
{
int i, ia, na, nx, ns, dim, niter;
int n[SF_MAX_DIM], m[SF_MAX_DIM], a[SF_MAX_DIM];
float a0, eps, *mm, *pp;
bool verb, *known;
sf_filter aa;
char* lagfile;
sf_file in, out, filt, lag, mask;
sf_init (argc,argv);
in = sf_input("in");
filt = sf_input("filt");
out = sf_output("out");
dim = sf_filedims (in,n);
if (!sf_histint(filt,"n1",&na)) sf_error("No n1= in filt");
aa = sf_allocatehelix (na);
if (!sf_histfloat(filt,"a0",&a0)) a0=1.;
if (!sf_histints(filt,"a",a,dim)) {
for (i=0; i < dim; i++) {
a[i]=1;
}
}
if (NULL != (lagfile = sf_getstring("lag")) /* file with filter lags */
||
NULL != (lagfile = sf_histstring(filt,"lag"))) {
lag = sf_input(lagfile);
sf_intread(aa->lag,na,lag);
} else {
lag = NULL;
for( ia=0; ia < na; ia++) {
aa->lag[ia] = ia+1;
}
}
if (!sf_getints ("n",m,dim) && (NULL == lag ||
!sf_histints (lag,"n",m,dim))) {
for (i=0; i < dim; i++) {
m[i] = n[i];
}
}
if (NULL != lag) sf_fileclose(lag);
bound (dim, m, n, a, aa);
sf_floatread (aa->flt,na,filt);
sf_fileclose(filt);
for( ia=0; ia < na; ia++) {
aa->flt[ia] /= a0;
}
if (!sf_getint ("ns",&ns)) sf_error("Need ns=");
/* scaling */
if (!sf_getint("niter",&niter)) niter=100;
/* Number of iterations */
if (!sf_getfloat("eps",&eps)) eps=1.;
/* regularization parameter */
if (!sf_getbool("verb",&verb)) verb=true;
/* verbosity flag */
nx = 1;
for( i=0; i < dim; i++) {
nx *= n[i];
}
mm = sf_floatalloc (nx);
pp = sf_floatalloc (nx);
known = sf_boolalloc (nx);
sf_mask_init(known);
hshape_init (nx,ns,aa);
sf_conjgrad_init(nx, nx, nx, nx, eps, 1.e-8, verb, false);
if (NULL != sf_getstring("mask")) {
/* optional input mask file for known data */
mask = sf_input("mask");
sf_floatread(mm,nx,mask);
sf_fileclose(mask);
for (i=0; i < nx; i++) {
known[i] = (bool) (mm[i] != 0.);
}
sf_floatread(mm,nx,in);
} else {
sf_floatread(mm,nx,in);
for (i=0; i < nx; i++) {
known[i] = (bool) (mm[i] != 0.);
}
}
sf_conjgrad(NULL, sf_mask_lop, hshape_lop, pp, mm, mm, niter);
sf_floatwrite (mm,nx,out);
exit (0);
}
void laplacian_init(int type1 /* operator type */,
int nz, int nx /* dimensions */,
float dz, float dx /* sampling */,
float **vt1 /* [nx][nz] (v*t)^2 */)
/*< initialize >*/
{
int i;
float s1, s2, b0;
const float tol=1.e-6;
sf_filter ss, bb;
type = type1;
n1 = nz;
n2 = nx;
n12 = n1*n2;
d1 = 1./(dz*dz);
d2 = 1./(dx*dx);
switch(type) {
case 0:
center = -2.0*(d1+d2);
break;
case 1:
corner = (d1+d2)/12.0;
s1 = (5*d1-d2)/6.0;
s2 = (5*d2-d1)/6.0;
d1 = s1;
d2 = s2;
center = -2.0*(2.0*corner+d1+d2);
break;
case 2:
tri1 = sf_tridiagonal_init(n1);
sf_tridiagonal_const_define(tri1,10.0/(12.0*d1),1.0/(12.0*d1),false);
work1 = sf_floatalloc(n1);
tri2 = sf_tridiagonal_init(n2);
sf_tridiagonal_const_define(tri2,10.0/(12.0*d2),1.0/(12.0*d2),false);
work2 = sf_floatalloc(n2);
break;
case 3:
corner = 3.0*(d1/d2+d2/d1);
ss = sf_allocatehelix(4);
ss->flt[0] = ss->flt[2] = (10.0 + corner)/144.0;
ss->flt[1] = ss->flt[3] = (2 - corner)/288.0;
ss->lag[0] = 1;
ss->lag[1] = n1-1;
ss->lag[2] = n1;
ss->lag[3] = n1+1;
bb = sf_allocatehelix(n1+1);
for (i=0; i <= n1; i++) {
bb->lag[i] = i+1;
bb->flt[i] = 0.0;
}
wilson_init(n1*10);
b0 = wilson_factor(100, (50.0 - corner)/72.0, ss, bb, true, tol);
wilson_close();
sf_deallocatehelix(ss);
bb = compress(bb,tol);
sf_warning("nb=%d",bb->nh);
work1 = sf_floatalloc(n12);
corner = (d1+d2)/(12.0*b0*b0);
s1 = (5*d1-d2)/(6.0*b0*b0);
s2 = (5*d2-d1)/(6.0*b0*b0);
d1 = s1;
d2 = s2;
center = -2.0*(2.0*corner+d1+d2);
sf_polydiv_init(n1*n2,bb);
break;
case 4:
dd1 = -d1/12.0;
dd2 = -d2/12.0;
d1 *= 4.0/3.0;
d2 *= 4.0/3.0;
center = -2.0*(d1+d2+dd1+dd2);
break;
case 5:
vt = vt1;
break;
default:
sf_error("%s: Unknown Laplacian type",__FILE__);
}
}
int main(int argc, char* argv[])
{
int n[SF_MAX_DIM], m[SF_MAX_DIM];
int ndim, dim, n123, n123s, i, ia, ns, i1, na, i4, n4;
float *f, *dd;
char *lagfile;
sf_filter aa;
sf_file in, filt, lag, out;
sf_init(argc,argv);
in = sf_input("in");
filt = sf_output("filt");
out = sf_output("out");
if (!sf_histint(filt,"n1",&na)) sf_error("No n1= in filt");
aa = sf_allocatehelix (na);
if (NULL != (lagfile = sf_getstring("lag"))
/*( lag file with filter lags )*/
||
NULL != (lagfile = sf_histstring(filt,"lag"))) {
lag = sf_input(lagfile);
sf_intread(aa->lag,na,lag);
} else {
lag = NULL;
for( ia=0; ia < na; ia++) {
aa->lag[ia] = ia+1;
}
}
ndim = sf_filedims(in,n);
if (!sf_getint("dim",&dim)) dim=ndim; /* number of dimensions */
if (!sf_getints ("n",m,dim) && (NULL == lag ||
!sf_histints (lag,"n",m,dim))) {
for (i=0; i < dim; i++) {
m[i] = n[i];
}
}
regrid (dim, m, n, aa);
n4 = sf_leftsize(in,dim);
n123 = 1;
for (i=0; i < dim; i++) {
n123 *= n[i];
}
dd = sf_floatalloc(n123);
n123s = n123*na;
f = sf_floatalloc(n123s);
for (i4=0; i4 < n4; i4++) {
sf_floatread(dd,n123,in);
sf_floatread(f,n123s,in);
/* apply shifts: dd -> d */
for (i=ia=0; ia < na; ia++) {
ns = aa->lag[ia];
for (i1=0; i1 < n123; i1++,i++) {
dd[i1] -= f[i]*dd[i1-ns];
}
}
sf_floatwrite(dd,n123,out);
}
exit(0);
}
