HADT MGL_EXPORT mgl_datac_sum(HCDT dat, const char *dir)
{
if(!dir || *dir==0) return 0;
long nx=dat->GetNx(),ny=dat->GetNy(),nz=dat->GetNz();
long p[3]={nx,ny,nz};
dual *b = new dual[nx*ny*nz];
dual *c = new dual[nx*ny*nz];
const mglDataC *d=dynamic_cast<const mglDataC *>(dat);
if(d) memcpy(c,d->a,nx*ny*nz*sizeof(dual));
else
#pragma omp parallel for
for(long i=0;i<nx*ny*nz;i++) c[i]=dat->vthr(i);
if(strchr(dir,'z') && nz>1)
{
mglStartThreadC(mgl_sumc_z,0,nx*ny,b,c,0,p);
memcpy(c,b,nx*ny*sizeof(mreal)); p[2] = 1;
}
if(strchr(dir,'y') && ny>1)
{
mglStartThreadC(mgl_sumc_y,0,nx*p[2],b,c,0,p);
memcpy(c,b,nx*p[2]*sizeof(mreal)); p[1] = p[2]; p[2] = 1;
}
if(strchr(dir,'x') && nx>1)
{
mglStartThreadC(mgl_sumc_x,0,p[1]*p[2],b,c,0,p);
p[0] = p[1]; p[1] = p[2]; p[2] = 1;
}
mglDataC *r=new mglDataC(p[0],p[1],p[2]);
memcpy(r->a,b,p[0]*p[1]*p[2]*sizeof(dual));
delete []b; delete []c; return r;
}
void MGL_EXPORT mgl_datac_modify_vw(HADT d, const char *eq,HCDT vdat,HCDT wdat)
{
const mglDataC *v = dynamic_cast<const mglDataC *>(vdat);
const mglDataC *w = dynamic_cast<const mglDataC *>(wdat);
long nn = d->nx*d->ny*d->nz, par[3]={d->nx,d->ny,d->nz};
if(vdat && vdat->GetNN()!=nn) return;
if(wdat && wdat->GetNN()!=nn) return;
mglFormulaC f(eq);
if(v && w) mglStartThreadC(mgl_cmodify,0,nn,d->a,v->a,w->a,par,&f);
else if(vdat && wdat) mglStartThreadV(mgl_cmodify_gen,nn,d->a,vdat,wdat,par,&f);
else if(v) mglStartThreadC(mgl_cmodify,0,nn,d->a,v->a,0,par,&f);
else if(vdat) mglStartThreadV(mgl_cmodify_gen,nn,d->a,vdat,0,par,&f);
else mglStartThreadC(mgl_cmodify,0,nn,d->a,0,0,par,&f);
}
void MGL_EXPORT mgl_datac_modify(HADT d, const char *eq,long dim)
{
long nx=d->nx, ny=d->ny, nz=d->nz, par[3]={nx,ny,nz};
mglFormulaC f(eq);
if(dim<0) dim=0;
if(nz>1) // 3D array
{
par[2] -= dim; if(par[2]<0) par[2]=0;
mglStartThreadC(mgl_cmodify,0,nx*ny*par[2],d->a+nx*ny*dim,0,0,par,&f);
}
else // 2D or 1D array
{
par[1] -= dim; if(par[1]<0) par[1]=0;
mglStartThreadC(mgl_cmodify,0,nx*par[1],d->a+nx*dim,0,0,par,&f);
}
}
void MGL_EXPORT mgl_datac_fill(HADT d, dual x1,dual x2,char dir)
{
if(mgl_isnan(x2)) x2=x1;
if(dir<'x' || dir>'z') dir='x';
long par[2]={d->nx,d->ny};
dual b[2]={x1,x2-x1};
if(dir=='x') b[1] *= d->nx>1 ? 1./(d->nx-1):0;
if(dir=='y') b[1] *= d->ny>1 ? 1./(d->ny-1):0;
if(dir=='z') b[1] *= d->nz>1 ? 1./(d->nz-1):0;
mglStartThreadC(mgl_cfill_x,0,d->nx*d->ny*d->nz,d->a,b,0,par,0,0,0,&dir);
}
HADT MGL_EXPORT mgl_datac_resize_box(HCDT dat, long mx,long my,long mz, mreal x1,mreal x2, mreal y1,mreal y2, mreal z1,mreal z2)
{ // NOTE: only for mglDataC
const mglDataC *d=dynamic_cast<const mglDataC *>(dat);
if(!d) return 0;
register long nx = d->nx-1, ny = d->ny-1, nz = d->nz-1;
mx = mx<1 ? nx+1:mx; my = my<1 ? ny+1:my; mz = mz<1 ? nz+1:mz;
mglDataC *r=new mglDataC(mx,my,mz);
mreal par[6]={nx*x1,0,ny*y1,0,nz*z1,0};
long nn[6]={mx,my,mz,nx+1,ny+1,nz+1};
if(mx>1) par[1] = nx*(x2-x1)/(mx-1);
if(my>1) par[3] = ny*(y2-y1)/(my-1);
if(mz>1) par[5] = nz*(z2-z1)/(mz-1);
mglStartThreadC(mgl_cresize,0,mx*my*mz,r->a,d->a,0,nn,par);
return r;
}
