/**
Make basic arrays for servo analysis.
*/
static void servo_calc_init(SERVO_CALC_T *st, const dmat *psdin, double dt, long dtrat){
if(psdin->ny!=2){
error("psdin should have two columns\n");
}
double Ts=dt*dtrat;
st->fny=0.5/Ts;
dmat *nu=st->nu=dlogspace(-3,log10(0.5/dt),1000);
st->psd=dinterp1(psdin, 0, nu, 1e-40);
st->var_sig=psd_inte2(psdin);
dcomplex pi2i=COMPLEX(0, TWOPI);
if(st->Hsys || st->Hwfs || st->Hint || st->s){
error("Already initialized\n");
}
st->Hsys=cnew(nu->nx, 1);
st->Hwfs=cnew(nu->nx, 1);
st->Hint=cnew(nu->nx, 1);
st->s=cnew(nu->nx,1);
for(long i=0; i<nu->nx; i++){
dcomplex s=st->s->p[i]=pi2i*nu->p[i];
dcomplex zInv=cexp(-s*Ts);
dcomplex Hint=st->Hint->p[i]=1./(1-zInv);
dcomplex Hwfs, Hdac;
if(dtrat==1){//we have a pure delay
Hwfs=st->Hwfs->p[i]=zInv;
Hdac=1;
}else{
Hwfs=st->Hwfs->p[i]=(1-zInv)/(Ts*s);
Hdac=Hwfs;
}
dcomplex Hlag=cexp(-s*dt);/*lag due to readout/computation*/
dcomplex Hmir=1;/*DM */
st->Hsys->p[i]=Hwfs*Hlag*Hdac*Hmir*Hint;
}
}
void
reflect·unsafe_New(Type* t, byte* ret)
{
#line 577 "/home/pi/go_build/hg/go/src/pkg/runtime/iface.goc"
ret = runtime·cnew(t);
FLUSH(&ret);
}
void
reflect·unsafe_New(Type* t, byte* ret)
{
ret = 0;
FLUSH(&ret);
#line 606 "/tmp/makerelease197226928/go/src/pkg/runtime/iface.goc"
ret = runtime·cnew(t);
FLUSH(&ret);
}
void
reflect·unsafe_New(Type* t, byte* ret)
{
ret = 0;
FLUSH(&ret);
#line 591 "/home/14/ren/source/golang/go/src/pkg/runtime/iface.goc"
ret = runtime·cnew(t);
FLUSH(&ret);
}
static void test_cov(){/*not good */
rand_t rstat;
int seed=4;
double r0=0.2;
double dx=1./64;
long N=1+1024;
long nx=N;
long ny=N;
long nframe=1;
seed_rand(&rstat, seed);
map_t *atm=mapnew(nx, ny, dx,dx, NULL);
cmat *atmhat=cnew((N+1)*3,(N+1)*3);
dmat *atmhattot=dnew((N+1)*3,(N+1)*3);
//cfft2plan(atmhat,-1);
//cfft2plan(atmhat, 1);
dset((dmat*)atm,1);
cembedd(atmhat, (dmat*)atm, 0);
cfft2(atmhat, -1);
cabs22d(&atmhattot, 1, atmhat, 1);
ccpd(&atmhat, atmhattot);
cfft2i(atmhat, 1);
cfftshift(atmhat);
dmat *denom=dnew((N+1)*3,(N+1)*3);
dmat *cov=dnew((N+1)*3,(N+1)*3);
creal2d(&denom, 0, atmhat, 1);
writebin(denom, "denom.bin");
dzero(atmhattot);
for(long i=0; i<nframe; i++){
info("%ld of %ld\n", i, nframe);
for(long j=0; j<nx*ny; j++){
atm->p[j]=randn(&rstat);
}
fractal_do((dmat*)atm, dx, r0,L0,ninit);
/*mapwrite(atm, "atm_%ld.bin", i); */
cembedd(atmhat, (dmat*)atm, 0);
cfft2(atmhat, -1);
cabs22d(&atmhattot, 1, atmhat, 1);
if(i==0 || (i+1)%10==0){
dscale(atmhattot, 1./(i+1));
ccpd(&atmhat, atmhattot);
writebin(atmhattot, "atm_psf_%ld.bin",i+1);
cfft2i(atmhat, 1);
cfftshift(atmhat);
creal2d(&cov, 0, atmhat, 1);
for(long k=0; k<cov->nx*cov->ny; k++){
cov->p[k]/=denom->p[k];
}
writebin(cov, "atm_cov_%ld.bin",i+1);
}
}
}
/* -------------------------------------------------------------------------------------
// sdyALInitialize
//------------------------------------------------------------------------------------- */
void SDYAPI sdyALInitialize(SDY_SETTINGS* pSettings)
{
assert(!g_cAudLines);
g_wMaxAudLines = pSettings->wAudLines;
if(!g_cAudLines)
g_cAudLines = cnew();
sdyManInitialize(pSettings->wBufSec);
}
stack* initStack(int eleSize,void(*dealloc)(void*)){
stack *s = cnew(stack);
assert(s!=NULL);
s->length=0;
s->capacity=1;
s->dealloc=dealloc;
s->elemSize=eleSize;
s->type=-1;
s->value=malloc(eleSize);
s->print = NULL;
return s;
}
/**
Convert PSD into time series.*/
dmat* psd2time(const dmat *psdin, rand_t *rstat, double dt, int nstepin){
if(!psdin){
error("psdin cannot be null\n");
}
long nstep=nextpow2(nstepin);
double df=1./(dt*nstep);
dmat *fs=dlinspace(0, df, nstep);
dmat *psd=NULL;
if(psdin->ny==1){//[alpha, beta, fmin, fmax] discribes power law with cut on/off freq.
psd=dnew(nstep, 1);
double alpha=psdin->p[0];
double beta=psdin->p[1];
long i0=1, imax=nstep;
if(psdin->nx>2){
i0=(long)round(psdin->p[2]/df);
if(i0<1) i0=1;
}
if(psdin->nx>3){
imax=(long)round(psdin->p[3]/df);
}
info("fmin=%g, fmax=%g, df=%g, i0=%ld, imax=%ld\n",
psdin->p[2], psdin->p[3], df, i0, imax);
for(long i=i0; i<imax; i++){
psd->p[i]=beta*pow(i*df, alpha);
}
}else if(psdin->ny==2){
if(psdin->nx<2){
error("Invalid PSD\n");
}
psd=dinterp1(psdin, 0, fs, 1e-40);
psd->p[0]=0;/*disable pistion. */
}else{
error("psdin is invalid format.\n");
}
cmat *wshat=cnew(nstep, 1);
//cfft2plan(wshat, -1);
for(long i=0; i<nstep; i++){
wshat->p[i]=sqrt(psd->p[i]*df)*COMPLEX(randn(rstat), randn(rstat));
}
cfft2(wshat, -1);
dmat *out=NULL;
creal2d(&out, 0, wshat, 1);
cfree(wshat);
dfree(psd);
dfree(fs);
dresize(out, nstepin, 1);
return out;
}
static void
copyin ( Type *t , void *src , void **dst )
{
uintptr size;
void *p;
Alg *alg;
#line 158 "/tmp/makerelease197226928/go/src/pkg/runtime/iface.goc"
size = t->size;
alg = t->alg;
#line 161 "/tmp/makerelease197226928/go/src/pkg/runtime/iface.goc"
if ( size <= sizeof ( *dst ) )
alg->copy ( size , dst , src ) ;
else {
p = runtime·cnew ( t ) ;
alg->copy ( size , p , src ) ;
*dst = p;
}
}
int main(int argc, char *argv[]) {
if(argc<7) {
info("Usage: %s loc.bin amp.bin cov.bin ncomp pttr wvl1 wvl2 ...\n", argv[0]);
exit(0);
}
enum {
P_EXE,
P_LOC,
P_AMP,
P_COV,
P_NCOMP,
P_PTTR,
P_WVL
};
loc_t *loc=locread("%s",argv[P_LOC]);
dmat *amp=NULL;
if(strcmp(argv[P_AMP],"NULL")) {
amp=dread("%s",argv[P_AMP]);
} else {
amp=dnew(loc->nloc,1);
dset(amp,1);
}
dmat *cov=dread("%s",argv[P_COV]);
long ncomp=strtol(argv[P_NCOMP], NULL, 10);
long pttr=strtol(argv[P_PTTR], NULL, 10);
cmat *otf=otf=cnew(ncomp, ncomp);
dmat *psf=NULL;
for(int iwvl=0; iwvl<argc-P_WVL; iwvl++) {
double wvl=strtod(argv[iwvl+P_WVL], NULL);
double dtheta=wvl/(ncomp*loc->dx);
genotf(&otf, loc, amp, NULL, NULL, 0, wvl, dtheta, cov, 0, 0, ncomp, ncomp, 1, pttr);
writebin(otf, "%s_otf_%g.bin", argv[P_COV], wvl);
cfftshift(otf);
cfft2i(otf, 1);
cfftshift(otf);
creal2d(&psf, 0, otf, 1);
writebin(psf, "%s_psf_%g.bin", argv[P_COV], wvl);
}
cfree(otf);
dfree(psf);
dfree(cov);
dfree(amp);
locfree(loc);
}
/*
static int test_fft_speed_small(){
int nis=128;
int *is=mycalloc(nis,int);
dmat *tim=dnew(nis,1);
for(int ii=0; ii<nis; ii++){
is[ii]=ii+1;
}
ccell *ac=cellnew(nis,1);
rand_t stat;
seed_rand(&stat,1);
for(int ii=0; ii<nis; ii++){
ac->p[ii]=cnew(is[ii],is[ii]);
//cfft2plan(ac->p[ii],-1);
crandn(ac->p[ii],20,&stat);
}
TIC;
for(int ii=0; ii<nis; ii++){
info2("size %4d: ",is[ii]);
tic;
for(int i=0; i<1000; i++){
cfft2(ac->p[ii],-1);
}
toc2("fft");
tim->p[ii]=toc3;
}
writebin(tim,"fft_timing");
}
static void test_fft_speed(){
int nis=2048;
int *is=mycalloc(nis,int);
dmat *tim=dnew(nis,1);
for(int ii=0; ii<nis; ii++){
is[ii]=(ii+1)*2;
}
ccell *ac=cellnew(nis,1);
rand_t stat;
seed_rand(&stat,1);
TIC;
for(int ii=0; ii<nis; ii++){
info2("size %4d: ",is[ii]);
tic;
ac->p[ii]=cnew(is[ii],is[ii]);
//cfft2plan(ac->p[ii],-1);
crandn(ac->p[ii],20,&stat);
toc("plan");
}
toc("plan");
for(int ii=0; ii<nis; ii++){
info2("size %4d: ",is[ii]);
tic;
int nrepeat;
if(is[ii]<300)
nrepeat=100;
else if(is[ii]<1000)
nrepeat=10;
else
nrepeat=1;
for(int i=0; i<nrepeat; i++){
cfft2(ac->p[ii],-1);
}
toc2("fft");
tim->p[ii]=toc3/nrepeat;
}
writebin(tim,"fft_timing");
}*/
static void test_fft_special(){
int nis=2;
int *is=mycalloc(nis,int);
dmat *tim=dnew(nis,1);
is[0]=3824;
is[1]=4096;
ccell *ac=ccellnew(nis,1);
rand_t rstat;
seed_rand(&rstat,1);
TIC;
for(int ii=0; ii<nis; ii++){
info2("size %4d: ",is[ii]);
tic;
ac->p[ii]=cnew(is[ii],is[ii]);
//cfft2plan(ac->p[ii],-1);
//cfft2partialplan(ac->p[ii],512,-1);
crandn(ac->p[ii],20,&rstat);
toc("plan");
}
for(int ii=0; ii<nis; ii++){
info2("size %4d: ",is[ii]);
tic;
int nrepeat;
if(is[ii]<300)
nrepeat=100;
else if(is[ii]<1000)
nrepeat=10;
else
nrepeat=4;
for(int i=0; i<nrepeat; i++){
cfft2(ac->p[ii],-1);
}
toc2("fft");
for(int i=0; i<nrepeat; i++){
cfft2partial(ac->p[ii],512,-1);
}
toc2("fft2partial");
tim->p[ii]=toc3/nrepeat;
}
writebin(tim,"fft_timing");
}
dmat *psd1d(const dmat *v, /**<[in] The data sequence*/
long nseg /**<[in] Number of overlapping segments*/
){
long nx;
long ncol;
if(v->nx==1){
nx=v->ny;
ncol=1;
}else{
nx=v->nx;
ncol=v->ny;
}
if(nseg<=1) nseg=1;
const int lseg2=nx/(nseg+1);
const int lseg=lseg2*2;
dmat *psd=dnew(lseg2+1, ncol);
cmat *hat=cnew(lseg, 1);
//cfft2plan(hat, -1);
for(long icol=0; icol<ncol; icol++){
double *ppsd=psd->p+icol*(lseg2+1);
for(int iseg=0; iseg<nseg; iseg++){
double* p=v->p+icol*nx+iseg*lseg2;
for(int ix=0; ix<lseg; ix++){
hat->p[ix]=p[ix]*W_J(ix, lseg2);
}
cfft2(hat, -1);
ppsd[0]+=cabs2(hat->p[0]);
for(int ix=1; ix<lseg2; ix++){
ppsd[ix]+=cabs2(hat->p[ix])+cabs2(hat->p[lseg-ix]);
}
ppsd[lseg2]+=cabs2(hat->p[lseg2]);
}
}
double sumwt=0;
for(int ix=0; ix<lseg; ix++){
sumwt+=pow(W_J(ix, lseg2), 2);
}
sumwt*=lseg*nseg;
dscale(psd, 1./sumwt);
cfree(hat);
return psd;
}
void resize(size_t size) {
size_t i;
clear(emd);
m_size = size;
m_imfs = cnew(T*, m_nF);
for(i = 0; i < m_nF; i++)
m_imfs[i] = cnew(T, size);
m_residue = cnew(T, size);
m_minP = cnew(size_t, size / 2);
m_maxP = cnew(size_t, size / 2);
m_min = cnew(T, size);
m_max = cnew(T, size);
}
runtime·newm(void)
{
M *mp;
static Type *mtype; // The Go type M
if(mtype == nil) {
Eface e;
runtime·gc_m_ptr(&e);
mtype = ((PtrType*)e.type)->elem;
}
mp = runtime·cnew(mtype);
mcommoninit(mp);
if(runtime·iscgo) {
CgoThreadStart ts;
if(libcgo_thread_start == nil)
runtime·throw("libcgo_thread_start missing");
// pthread_create will make us a stack.
mp->g0 = runtime·malg(-1);
ts.m = mp;
ts.g = mp->g0;
ts.fn = runtime·mstart;
runtime·asmcgocall(libcgo_thread_start, &ts);
} else {
if(Windows)
// windows will layout sched stack on os stack
mp->g0 = runtime·malg(-1);
else
mp->g0 = runtime·malg(8192);
runtime·newosproc(mp, mp->g0, (byte*)mp->g0->stackbase, runtime·mstart);
}
return mp;
}
/**
Calculate total error. If g0 is 0, use st->g, otherwith use g0 to figure out g, a T.
*/
static double servo_calc_do(SERVO_CALC_T *st, double g0){
dmat *nu=st->nu;
if(!st->Hol){
st->Hol=cnew(nu->nx,1);
}
/*Compute Hol with the first integrator and gain.*/
if(g0>EPS){
st->g=g0;
}
cadd(&st->Hol, 0, st->Hsys, st->g);
double g2=1;/*additional g to multiply. !=1 if g0 is nonzero and type is 2.*/
if(st->type==2){//type II controller
ccwm(st->Hol, st->Hint);/*multiply the second integrator*/
if(fabs(g0)>EPS){/*figure out a, T from new g0*/
double margin, fcross;
margin=phase_at_gain(&fcross, nu, st->Hol, 1);/*see how much phase lead is needed*/
double phineed=st->pmargin-margin;
double a,T;
if(phineed*2.2>M_PI){/*lead filter is not suitable*/
a=1;
T=0;
}else{
a=(1-sin(phineed))/(1+sin(phineed));
double f0=fcross*sqrt(a);
T=1./(2.*M_PI*f0);
}
/* Hlead is multiplied by sqrt(a) so it has unit gain at cross over frequency*/
g2=sqrt(a);
st->g=g0*g2;
st->a=a;
st->T=T;
//info("g0=%g, g2=%g, phineed=%.1f\n", g0, g2, phineed*180/M_PI);
}
double a=st->a;
double T=st->T;
for(int i=0; i<nu->nx; i++){
dcomplex Hlead=(1+T*st->s->p[i])/(1+a*T*st->s->p[i])*g2;
st->Hol->p[i]*=Hlead;
}
}
double res_sig=0;
double sum_n=0, sum_1=0;
dmat *psd=st->psd;
for(int i=0; i<nu->nx; i++){
dcomplex Hol=st->Hol->p[i];
dcomplex Hrej=1./(1.+Hol);
//The gain never reach below -50dB
res_sig+=psd->p[i]*creal(Hrej*conj(Hrej)+1e-5)*nu->p[i];
if(st->nu->p[i]<st->fny){
//compute noise prop only within nyqust frequency
dcomplex Hcl=Hol*Hrej;
dcomplex Hwfs=st->Hwfs->p[i];
dcomplex Hn=Hcl/Hwfs;
sum_n+=creal(Hn*conj(Hn))*nu->p[i];
sum_1+=nu->p[i];
}
}
double dlognu=(log(nu->p[nu->nx-1])-log(nu->p[0]))/(nu->nx-1);
res_sig*=dlognu;
st->res_sig=res_sig;
st->gain_n=sum_n/sum_1;
if(!servo_isstable(nu, st->Hol)){
st->gain_n=100;
/*put a high penalty to drive down the gain*/
st->res_n=10*(1+g0)*(st->var_sig+st->sigma2n);
/*warning2("Unstable: g0=%g, g2=%g, res_sig=%g, res_n=%g, tot=%g, gain_n=%g sigma2n=%g\n",
g0, g2, res_sig, st->res_n, st->res_n+res_sig, st->gain_n, st->sigma2n);*/
}else{
if(st->gain_n>1){
st->gain_n=pow(st->gain_n,3);/*a fudge factor to increase the penalty*/
}
st->res_n=st->sigma2n*st->gain_n;
/*info2(" Stable: g0=%g, g2=%g, res_sig=%g, res_n=%g, tot=%g, gain_n=%g sigma2n=%g\n",
g0, g2, res_sig, st->res_n, st->res_n+res_sig, st->gain_n, st->sigma2n);*/
}
return res_sig+st->res_n;
}
static void
evacuate ( MapType *t , Hmap *h , uintptr oldbucket )
{
Bucket *b;
Bucket *x , *y;
Bucket *newx , *newy;
uintptr xi , yi;
uintptr newbit;
uintptr hash;
uintptr i;
byte *k , *v;
byte *xk , *yk , *xv , *yv;
uint8 top;
bool eq;
#line 182 "C:\Users\gopher\AppData\Local\Temp\1\makerelease745458658\go\src\pkg\runtime\hashmap.goc"
b = ( Bucket* ) ( h->oldbuckets + oldbucket * h->bucketsize ) ;
newbit = ( uintptr ) 1 << ( h->B - 1 ) ;
#line 185 "C:\Users\gopher\AppData\Local\Temp\1\makerelease745458658\go\src\pkg\runtime\hashmap.goc"
if ( !evacuated ( b ) ) {
#line 189 "C:\Users\gopher\AppData\Local\Temp\1\makerelease745458658\go\src\pkg\runtime\hashmap.goc"
x = ( Bucket* ) ( h->buckets + oldbucket * h->bucketsize ) ;
y = ( Bucket* ) ( h->buckets + ( oldbucket + newbit ) * h->bucketsize ) ;
xi = 0;
yi = 0;
xk = ( byte* ) x->data;
yk = ( byte* ) y->data;
xv = xk + h->keysize * BUCKETSIZE;
yv = yk + h->keysize * BUCKETSIZE;
for ( ; b != nil; b = b->overflow ) {
for ( i = 0 , k = ( byte* ) b->data , v = k + h->keysize * BUCKETSIZE; i < BUCKETSIZE; i++ , k += h->keysize , v += h->valuesize ) {
top = b->tophash[i];
if ( top == Empty ) {
b->tophash[i] = EvacuatedEmpty;
continue;
}
if ( top < MinTopHash )
runtime·throw ( "bad state" ) ;
#line 209 "C:\Users\gopher\AppData\Local\Temp\1\makerelease745458658\go\src\pkg\runtime\hashmap.goc"
hash = h->hash0;
t->key->alg->hash ( &hash , t->key->size , IK ( h , k ) ) ;
if ( ( h->flags & Iterator ) != 0 ) {
t->key->alg->equal ( &eq , t->key->size , IK ( h , k ) , IK ( h , k ) ) ;
if ( !eq ) {
#line 225 "C:\Users\gopher\AppData\Local\Temp\1\makerelease745458658\go\src\pkg\runtime\hashmap.goc"
if ( ( top & 1 ) != 0 )
hash |= newbit;
else
hash &= ~newbit;
top = hash >> ( 8*sizeof ( uintptr ) -8 ) ;
if ( top < MinTopHash )
top += MinTopHash;
}
}
#line 235 "C:\Users\gopher\AppData\Local\Temp\1\makerelease745458658\go\src\pkg\runtime\hashmap.goc"
if ( ( hash & newbit ) == 0 ) {
b->tophash[i] = EvacuatedX;
if ( xi == BUCKETSIZE ) {
if ( checkgc ) mstats.next_gc = mstats.heap_alloc;
newx = runtime·cnew ( t->bucket ) ;
x->overflow = newx;
x = newx;
xi = 0;
xk = ( byte* ) x->data;
xv = xk + h->keysize * BUCKETSIZE;
}
x->tophash[xi] = top;
if ( ( h->flags & IndirectKey ) != 0 ) {
* ( byte** ) xk = * ( byte** ) k;
} else {
t->key->alg->copy ( t->key->size , xk , k ) ;
}
if ( ( h->flags & IndirectValue ) != 0 ) {
* ( byte** ) xv = * ( byte** ) v;
} else {
t->elem->alg->copy ( t->elem->size , xv , v ) ;
}
xi++;
xk += h->keysize;
xv += h->valuesize;
} else {
b->tophash[i] = EvacuatedY;
if ( yi == BUCKETSIZE ) {
if ( checkgc ) mstats.next_gc = mstats.heap_alloc;
newy = runtime·cnew ( t->bucket ) ;
y->overflow = newy;
y = newy;
yi = 0;
yk = ( byte* ) y->data;
yv = yk + h->keysize * BUCKETSIZE;
}
y->tophash[yi] = top;
if ( ( h->flags & IndirectKey ) != 0 ) {
* ( byte** ) yk = * ( byte** ) k;
} else {
t->key->alg->copy ( t->key->size , yk , k ) ;
}
if ( ( h->flags & IndirectValue ) != 0 ) {
* ( byte** ) yv = * ( byte** ) v;
} else {
t->elem->alg->copy ( t->elem->size , yv , v ) ;
}
yi++;
yk += h->keysize;
yv += h->valuesize;
}
}
}
/*
Compute cxx on atm to compare against L2, invpsd, fractal.
*/
static void test_cxx(){
rand_t rstat;
int seed=4;
double r0=0.2;
double dx=1./4;
long N=16;
long nx=N;
long ny=N;
long nframe=40960;
seed_rand(&rstat, seed);
{
dmat *cxx=dnew(N*N,N*N);
map_t *atm=mapnew(nx+1, ny+1, dx, dx,NULL);
for(long i=0; i<nframe; i++){
info("%ld of %ld\n", i, nframe);
for(long j=0; j<(nx+1)*(ny+1); j++){
atm->p[j]=randn(&rstat);
}
fractal_do((dmat*)atm, dx, r0, L0, ninit);
dmat *sec=dsub((dmat*)atm, 0, nx, 0, ny);
dmat *atmvec=dref_reshape(sec, nx*ny, 1);
dmm(&cxx,1, atmvec,atmvec,"nt",1);
dfree(atmvec);
dfree(sec);
}
dscale(cxx, 1./nframe);
writebin(cxx, "cxx_fractal");
dfree(cxx);
mapfree(atm);
}
{
dmat *cxx=dnew(N*N,N*N);
dmat *spect=turbpsd(nx, ny, dx, r0, 100, 0, 0.5);
spect->p[0]=spect->p[1];
cmat *atm=cnew(nx, ny);
//cfft2plan(atm, -1);
dmat *atmr=dnew(nx*ny,1);
dmat *atmi=dnew(nx*ny,1);
for(long ii=0; ii<nframe; ii+=2){
info("%ld of %ld\n", ii, nframe);
for(long i=0; i<atm->nx*atm->ny; i++){
atm->p[i]=COMPLEX(randn(&rstat), randn(&rstat))*spect->p[i];
}
cfft2(atm, -1);
for(long i=0; i<atm->nx*atm->ny; i++){
atmr->p[i]=creal(atm->p[i]);
atmi->p[i]=cimag(atm->p[i]);
}
dmm(&cxx,1, atmr,atmr,"nt",1);
dmm(&cxx,1, atmi,atmi,"nt",1);
}
dscale(cxx, 1./nframe);
writebin(cxx, "cxx_fft");
dfree(cxx);
dfree(atmr);
dfree(atmi);
cfree(atm);
}
loc_t *loc=mksqloc_auto(16,16,1./4,1./4);
locwrite(loc,"loc");
dmat *B=stfun_kolmogorov(loc, r0);
writebin(B, "B_theory");
}
static void test_psd(){
rand_t rstat;
int seed=4;
double r0=0.2;
double dx=1./64;
long N=1024;
long nx=N;
long ny=N;
long ratio=1;
long xskip=nx*(ratio-1)/2;
long yskip=ny*(ratio-1)/2;
long nframe=512;
seed_rand(&rstat, seed);
if(1){
map_t *atm=mapnew(nx+1, ny+1, dx,dx, NULL);
cmat *hat=cnew(nx*ratio, ny*ratio);
//cfft2plan(hat, -1);
dmat *hattot=dnew(nx*ratio, ny*ratio);
for(long i=0; i<nframe; i++){
info2("%ld of %ld\n", i, nframe);
for(long j=0; j<(nx+1)*(ny+1); j++){
atm->p[j]=randn(&rstat);
}
fractal_do((dmat*)atm, dx, r0,L0,ninit);
czero(hat);
for(long iy=0; iy<ny; iy++){
for(long ix=0; ix<nx; ix++){
IND(hat,ix+xskip,iy+yskip)=IND(atm,ix,iy);
}
}
cfftshift(hat);
cfft2i(hat, -1);
cabs22d(&hattot, 1, hat, 1);
}
dscale(hattot, 1./nframe);
dfftshift(hattot);
writebin(hattot, "PSD_fractal");
}
{
dmat *spect=turbpsd(nx, ny, dx, r0, 100, 0, 0.5);
writebin(spect, "spect");
cmat *hat=cnew(nx*ratio, ny*ratio);
//cfft2plan(hat, -1);
dmat *hattot=dnew(nx*ratio, ny*ratio);
cmat *atm=cnew(nx, ny);
//cfft2plan(atm, -1);
dmat *atmr=dnew(atm->nx, atm->ny);
dmat *atmi=dnew(atm->nx, atm->ny);
cmat* phat=hat;
dmat* patmr=atmr;
dmat* patmi=atmi;
for(long ii=0; ii<nframe; ii+=2){
info2("%ld of %ld\n", ii, nframe);
for(long i=0; i<atm->nx*atm->ny; i++){
atm->p[i]=COMPLEX(randn(&rstat), randn(&rstat))*spect->p[i];
}
cfft2(atm, -1);
for(long i=0; i<atm->nx*atm->ny; i++){
atmr->p[i]=creal(atm->p[i]);
atmi->p[i]=cimag(atm->p[i]);
}
czero(hat);
for(long iy=0; iy<ny; iy++){
for(long ix=0; ix<nx; ix++){
IND(phat,ix+xskip,iy+yskip)=IND(patmr,ix,iy);
}
}
cfftshift(hat);
cfft2i(hat, -1);
cabs22d(&hattot, 1, hat, 1);
czero(hat);
for(long iy=0; iy<ny; iy++){
for(long ix=0; ix<nx; ix++){
IND(phat,ix+xskip,iy+yskip)=IND(patmi,ix,iy);
}
}
cfftshift(hat);
cfft2i(hat, -1);
cabs22d(&hattot, 1, hat, 1);
}
dscale(hattot, 1./nframe);
dfftshift(hattot);
writebin(hattot, "PSD_fft");
}
}
static void test_stfun(){
rand_t rstat;
int seed=4;
double r0=0.2;
double dx=1./16;
long N=32;
long nx=N;
long ny=N;
long nframe=500;
seed_rand(&rstat, seed);
if(L0<9000){
dmat *rr=dlinspace(0, N*dx, N);
dmat *covvk=turbcov(rr, sqrt(2)*N*dx, r0, L0);
writebin(covvk, "cov_vk");
dfree(rr);
dfree(covvk);
}
/* return; */
{
map_t *atm=mapnew(nx+1, ny+1, dx, dx,NULL);
stfun_t *data=stfun_init(nx, ny, NULL);
zfarr *save=zfarr_init(nframe, 1, "fractal_atm.bin");
for(long i=0; i<nframe; i++){
for(long j=0; j<(nx+1)*(ny+1); j++){
atm->p[j]=randn(&rstat);
}
fractal_do((dmat*)atm, dx, r0,L0,ninit);
stfun_push(data, (dmat*)atm);
zfarr_dmat(save, i, (dmat*)atm);
if(i%100==0)
info("%ld of %ld\n", i, nframe);
}
zfarr_close(save);
dmat *st=stfun_finalize(data);
writebin(st, "stfun_fractal.bin");
ddraw("fractal", st, NULL,NULL, "Atmosphere","x","y","stfun");
}
/*exit(0); */
{
stfun_t *data=stfun_init(nx, ny, NULL);
dmat *spect=turbpsd(nx, ny, dx, r0, 100, 0, 0.5);
cmat *atm=cnew(nx, ny);
//cfft2plan(atm, -1);
dmat *atmr=dnew(atm->nx, atm->ny);
dmat *atmi=dnew(atm->nx, atm->ny);
spect->p[0]=0;
for(long ii=0; ii<nframe; ii+=2){
for(long i=0; i<atm->nx*atm->ny; i++){
atm->p[i]=COMPLEX(randn(&rstat), randn(&rstat))*spect->p[i];
}
cfft2(atm, -1);
for(long i=0; i<atm->nx*atm->ny; i++){
atmr->p[i]=creal(atm->p[i]);
atmi->p[i]=cimag(atm->p[i]);
}
stfun_push(data, atmr);
stfun_push(data, atmi);
if(ii%100==0)
info("%ld of %ld\n", ii, nframe);
}
dmat *st=stfun_finalize(data);
writebin(st, "stfun_fft.bin");
ddraw("fft", st, NULL,NULL, "Atmosphere","x","y","stfun");
}
}
/**
Setup the detector transfer functions. See maos/setup_powfs.c
*/
static void setup_powfs_dtf(POWFS_S *powfs, const PARMS_S* parms){
const int npowfs=parms->maos.npowfs;
for(int ipowfs=0; ipowfs<npowfs; ipowfs++){
const int ncomp=parms->maos.ncomp[ipowfs];
const int ncomp2=ncomp>>1;
const int embfac=parms->maos.embfac[ipowfs];
const int pixpsa=parms->skyc.pixpsa[ipowfs];
const double pixtheta=parms->skyc.pixtheta[ipowfs];
const double blur=parms->skyc.pixblur[ipowfs]*pixtheta;
const double e0=exp(-2*M_PI*M_PI*blur*blur);
const double dxsa=parms->maos.dxsa[ipowfs];
const double pixoffx=parms->skyc.pixoffx[ipowfs];
const double pixoffy=parms->skyc.pixoffy[ipowfs];
const double pxo=-(pixpsa/2-0.5+pixoffx)*pixtheta;
const double pyo=-(pixpsa/2-0.5+pixoffy)*pixtheta;
loc_t *loc_ccd=mksqloc(pixpsa, pixpsa, pixtheta, pixtheta, pxo, pyo);
powfs[ipowfs].dtf=mycalloc(parms->maos.nwvl,DTF_S);
for(int iwvl=0; iwvl<parms->maos.nwvl; iwvl++){
const double wvl=parms->maos.wvl[iwvl];
const double dtheta=wvl/(dxsa*embfac);
const double pdtheta=pixtheta*pixtheta/(dtheta*dtheta);
const double du=1./(dtheta*ncomp);
const double du2=du*du;
const double dupth=du*pixtheta;
cmat *nominal=cnew(ncomp,ncomp);
//cfft2plan(nominal,-1);
//cfft2plan(nominal,1);
cmat* pn=nominal;
const double theta=0;
const double ct=cos(theta);
const double st=sin(theta);
for(int iy=0; iy<ncomp; iy++){
int jy=iy-ncomp2;
for(int ix=0; ix<ncomp; ix++){
int jx=ix-ncomp2;
double ir=ct*jx+st*jy;
double ia=-st*jx+ct*jy;
IND(pn,ix,iy)=sinc(ir*dupth)*sinc(ia*dupth)
*pow(e0,ir*ir*du2)*pow(e0,ia*ia*du2)
*pdtheta;
}
}
if(parms->skyc.fnpsf1[ipowfs]){
warning("powfs %d has additional otf to be multiplied\n", ipowfs);
dcell *psf1c=dcellread("%s", parms->skyc.fnpsf1[ipowfs]);
dmat *psf1=NULL;
if(psf1c->nx == 1){
psf1=dref(psf1c->p[0]);
}else if(psf1c->nx==parms->maos.nwvl){
psf1=dref(psf1c->p[iwvl]);
}else{
error("skyc.fnpsf1 has wrong dimension\n");
}
dcellfree(psf1c);
if(psf1->ny!=2){
error("skyc.fnpsf1 has wrong dimension\n");
}
dmat *psf1x=dnew_ref(psf1->nx, 1, psf1->p);
dmat *psf1y=dnew_ref(psf1->nx, 1, psf1->p+psf1->nx);
dmat *psf2x=dnew(ncomp*ncomp, 1);
for(int iy=0; iy<ncomp; iy++){
int jy=iy-ncomp2;
for(int ix=0; ix<ncomp; ix++){
int jx=ix-ncomp2;
psf2x->p[ix+iy*ncomp]=sqrt(jx*jx+jy*jy)*dtheta;
}
}
info("powfs %d, iwvl=%d, dtheta=%g\n", ipowfs, iwvl, dtheta*206265000);
writebin(psf2x, "powfs%d_psf2x_%d", ipowfs,iwvl);
dmat *psf2=dinterp1(psf1x, psf1y, psf2x, 0);
normalize_sum(psf2->p, psf2->nx*psf2->ny, 1);
psf2->nx=ncomp; psf2->ny=ncomp;
writebin(psf2, "powfs%d_psf2_%d", ipowfs,iwvl);
cmat *otf2=cnew(ncomp, ncomp);
//cfft2plan(otf2, -1);
ccpd(&otf2, psf2);//peak in center
cfftshift(otf2);//peak in corner
cfft2(otf2, -1);
cfftshift(otf2);//peak in center
writebin(otf2, "powfs%d_otf2_%d", ipowfs, iwvl);
writebin(nominal, "powfs%d_dtf%d_nominal_0",ipowfs,iwvl);
for(int i=0; i<ncomp*ncomp; i++){
nominal->p[i]*=otf2->p[i];
}
writebin(nominal, "powfs%d_dtf%d_nominal_1",ipowfs,iwvl);
dfree(psf1x);
dfree(psf1y);
dfree(psf2x);
dfree(psf1);
cfree(otf2);
dfree(psf2);
}
cfftshift(nominal);//peak in corner
cfft2(nominal,-1);
cfftshift(nominal);//peak in center
cfft2i(nominal,1);
warning_once("double check nominal for off centered skyc.fnpsf1\n");
/*This nominal will multiply to OTF with peak in corner. But after
inverse fft, peak will be in center*/
ccp(&powfs[ipowfs].dtf[iwvl].nominal, nominal);
cfree(nominal);
loc_t *loc_psf=mksqloc(ncomp, ncomp, dtheta, dtheta, -ncomp2*dtheta, -ncomp2*dtheta);
powfs[ipowfs].dtf[iwvl].si=mkh(loc_psf,loc_ccd,0,0,1);
locfree(loc_psf);
if(parms->skyc.dbg){
writebin(powfs[ipowfs].dtf[iwvl].nominal,
"%s/powfs%d_dtf%d_nominal",dirsetup,ipowfs,iwvl);
writebin(powfs[ipowfs].dtf[iwvl].si,
"%s/powfs%d_dtf%d_si",dirsetup,ipowfs,iwvl);
}
powfs[ipowfs].dtf[iwvl].U=cnew(ncomp,1);
dcomplex *U=powfs[ipowfs].dtf[iwvl].U->p;
for(int ix=0; ix<ncomp; ix++){
int jx=ix<ncomp2?ix:(ix-ncomp);
U[ix]=COMPLEX(0, -2.*M_PI*jx*du);
}
}/*iwvl */
locfree(loc_ccd);
}/*ipowfs */
}
/**
Time domain physical simulation.
noisy:
- 0: no noise at all;
- 1: poisson and read out noise.
- 2: only poisson noise.
*/
dmat *skysim_sim(dmat **mresout, const dmat *mideal, const dmat *mideal_oa, double ngsol,
ASTER_S *aster, const POWFS_S *powfs,
const PARMS_S *parms, int idtratc, int noisy, int phystart){
int dtratc=0;
if(!parms->skyc.multirate){
dtratc=parms->skyc.dtrats->p[idtratc];
}
int hasphy;
if(phystart>-1 && phystart<aster->nstep){
hasphy=1;
}else{
hasphy=0;
}
const int nmod=mideal->nx;
dmat *res=dnew(6,1);/*Results. 1-2: NGS and TT modes.,
3-4:On axis NGS and TT modes,
4-6: On axis NGS and TT wihtout considering un-orthogonality.*/
dmat *mreal=NULL;/*modal correction at this step. */
dmat *merr=dnew(nmod,1);/*modal error */
dcell *merrm=dcellnew(1,1);dcell *pmerrm=NULL;
const int nstep=aster->nstep?aster->nstep:parms->maos.nstep;
dmat *mres=dnew(nmod,nstep);
dmat* rnefs=parms->skyc.rnefs;
dcell *zgradc=dcellnew3(aster->nwfs, 1, aster->ngs, 0);
dcell *gradout=dcellnew3(aster->nwfs, 1, aster->ngs, 0);
dmat *gradsave=0;
if(parms->skyc.dbg){
gradsave=dnew(aster->tsa*2,nstep);
}
SERVO_T *st2t=0;
kalman_t *kalman=0;
dcell *mpsol=0;
dmat *pgm=0;
dmat *dtrats=0;
int multirate=parms->skyc.multirate;
if(multirate){
kalman=aster->kalman[0];
dtrats=aster->dtrats;
}else{
if(parms->skyc.servo>0){
const double dtngs=parms->maos.dt*dtratc;
st2t=servo_new(merrm, NULL, 0, dtngs, aster->gain->p[idtratc]);
pgm=aster->pgm->p[idtratc];
}else{
kalman=aster->kalman[idtratc];
}
}
if(kalman){
kalman_init(kalman);
mpsol=dcellnew(aster->nwfs, 1); //for psol grad.
}
const long nwvl=parms->maos.nwvl;
dcell **psf=0, **mtche=0, **ints=0;
ccell *wvf=0,*wvfc=0, *otf=0;
if(hasphy){
psf=mycalloc(aster->nwfs,dcell*);
wvf=ccellnew(aster->nwfs,1);
wvfc=ccellnew(aster->nwfs,1);
mtche=mycalloc(aster->nwfs,dcell*);
ints=mycalloc(aster->nwfs,dcell*);
otf=ccellnew(aster->nwfs,1);
for(long iwfs=0; iwfs<aster->nwfs; iwfs++){
const int ipowfs=aster->wfs[iwfs].ipowfs;
const long ncomp=parms->maos.ncomp[ipowfs];
const long nsa=parms->maos.nsa[ipowfs];
wvf->p[iwfs]=cnew(ncomp,ncomp);
wvfc->p[iwfs]=NULL;
psf[iwfs]=dcellnew(nsa,nwvl);
//cfft2plan(wvf->p[iwfs], -1);
if(parms->skyc.multirate){
mtche[iwfs]=aster->wfs[iwfs].pistat->mtche[(int)aster->idtrats->p[iwfs]];
}else{
mtche[iwfs]=aster->wfs[iwfs].pistat->mtche[idtratc];
}
otf->p[iwfs]=cnew(ncomp,ncomp);
//cfft2plan(otf->p[iwfs],-1);
//cfft2plan(otf->p[iwfs],1);
ints[iwfs]=dcellnew(nsa,1);
int pixpsa=parms->skyc.pixpsa[ipowfs];
for(long isa=0; isa<nsa; isa++){
ints[iwfs]->p[isa]=dnew(pixpsa,pixpsa);
}
}
}
for(int irep=0; irep<parms->skyc.navg; irep++){
if(kalman){
kalman_init(kalman);
}else{
servo_reset(st2t);
}
dcellzero(zgradc);
dcellzero(gradout);
if(ints){
for(int iwfs=0; iwfs<aster->nwfs; iwfs++){
dcellzero(ints[iwfs]);
}
}
for(int istep=0; istep<nstep; istep++){
memcpy(merr->p, PCOL(mideal,istep), nmod*sizeof(double));
dadd(&merr, 1, mreal, -1);/*form NGS mode error; */
memcpy(PCOL(mres,istep),merr->p,sizeof(double)*nmod);
if(mpsol){//collect averaged modes for PSOL.
for(long iwfs=0; iwfs<aster->nwfs; iwfs++){
dadd(&mpsol->p[iwfs], 1, mreal, 1);
}
}
pmerrm=0;
if(istep>=parms->skyc.evlstart){/*performance evaluation*/
double res_ngs=dwdot(merr->p,parms->maos.mcc,merr->p);
if(res_ngs>ngsol*100){
dfree(res); res=NULL;
break;
}
{
res->p[0]+=res_ngs;
res->p[1]+=dwdot2(merr->p,parms->maos.mcc_tt,merr->p);
double dot_oa=dwdot(merr->p, parms->maos.mcc_oa, merr->p);
double dot_res_ideal=dwdot(merr->p, parms->maos.mcc_oa, PCOL(mideal,istep));
double dot_res_oa=0;
for(int imod=0; imod<nmod; imod++){
dot_res_oa+=merr->p[imod]*IND(mideal_oa,imod,istep);
}
res->p[2]+=dot_oa-2*dot_res_ideal+2*dot_res_oa;
res->p[4]+=dot_oa;
}
{
double dot_oa_tt=dwdot2(merr->p, parms->maos.mcc_oa_tt, merr->p);
/*Notice that mcc_oa_tt2 is 2x5 marix. */
double dot_res_ideal_tt=dwdot(merr->p, parms->maos.mcc_oa_tt2, PCOL(mideal,istep));
double dot_res_oa_tt=0;
for(int imod=0; imod<2; imod++){
dot_res_oa_tt+=merr->p[imod]*IND(mideal_oa,imod,istep);
}
res->p[3]+=dot_oa_tt-2*dot_res_ideal_tt+2*dot_res_oa_tt;
res->p[5]+=dot_oa_tt;
}
}//if evl
if(istep<phystart || phystart<0){
/*Ztilt, noise free simulation for acquisition. */
dmm(&zgradc->m, 1, aster->gm, merr, "nn", 1);/*grad due to residual NGS mode. */
for(int iwfs=0; iwfs<aster->nwfs; iwfs++){
const int ipowfs=aster->wfs[iwfs].ipowfs;
const long ng=parms->maos.nsa[ipowfs]*2;
for(long ig=0; ig<ng; ig++){
zgradc->p[iwfs]->p[ig]+=aster->wfs[iwfs].ztiltout->p[istep*ng+ig];
}
}
for(int iwfs=0; iwfs<aster->nwfs; iwfs++){
int dtrati=(multirate?(int)dtrats->p[iwfs]:dtratc);
if((istep+1) % dtrati==0){
dadd(&gradout->p[iwfs], 0, zgradc->p[iwfs], 1./dtrati);
dzero(zgradc->p[iwfs]);
if(noisy){
int idtrati=(multirate?(int)aster->idtrats->p[iwfs]:idtratc);
dmat *nea=aster->wfs[iwfs].pistat->sanea->p[idtrati];
for(int i=0; i<nea->nx; i++){
gradout->p[iwfs]->p[i]+=nea->p[i]*randn(&aster->rand);
}
}
pmerrm=merrm;//record output.
}
}
}else{
/*Accumulate PSF intensities*/
for(long iwfs=0; iwfs<aster->nwfs; iwfs++){
const double thetax=aster->wfs[iwfs].thetax;
const double thetay=aster->wfs[iwfs].thetay;
const int ipowfs=aster->wfs[iwfs].ipowfs;
const long nsa=parms->maos.nsa[ipowfs];
ccell* wvfout=aster->wfs[iwfs].wvfout[istep];
for(long iwvl=0; iwvl<nwvl; iwvl++){
double wvl=parms->maos.wvl[iwvl];
for(long isa=0; isa<nsa; isa++){
ccp(&wvfc->p[iwfs], IND(wvfout,isa,iwvl));
/*Apply NGS mode error to PSF. */
ngsmod2wvf(wvfc->p[iwfs], wvl, merr, powfs+ipowfs, isa,
thetax, thetay, parms);
cembedc(wvf->p[iwfs],wvfc->p[iwfs],0,C_FULL);
cfft2(wvf->p[iwfs],-1);
/*peak in corner. */
cabs22d(&psf[iwfs]->p[isa+nsa*iwvl], 1., wvf->p[iwfs], 1.);
}/*isa */
}/*iwvl */
}/*iwfs */
/*Form detector image from accumulated PSFs*/
double igrad[2];
for(long iwfs=0; iwfs<aster->nwfs; iwfs++){
int dtrati=dtratc, idtrat=idtratc;
if(multirate){//multirate
idtrat=aster->idtrats->p[iwfs];
dtrati=dtrats->p[iwfs];
}
if((istep+1) % dtrati == 0){/*has output */
dcellzero(ints[iwfs]);
const int ipowfs=aster->wfs[iwfs].ipowfs;
const long nsa=parms->maos.nsa[ipowfs];
for(long isa=0; isa<nsa; isa++){
for(long iwvl=0; iwvl<nwvl; iwvl++){
double siglev=aster->wfs[iwfs].siglev->p[iwvl];
ccpd(&otf->p[iwfs],psf[iwfs]->p[isa+nsa*iwvl]);
cfft2i(otf->p[iwfs], 1); /*turn to OTF, peak in corner */
ccwm(otf->p[iwfs], powfs[ipowfs].dtf[iwvl].nominal);
cfft2(otf->p[iwfs], -1);
dspmulcreal(ints[iwfs]->p[isa]->p, powfs[ipowfs].dtf[iwvl].si,
otf->p[iwfs]->p, siglev);
}
/*Add noise and apply matched filter. */
#if _OPENMP >= 200805
#pragma omp critical
#endif
switch(noisy){
case 0:/*no noise at all. */
break;
case 1:/*both poisson and read out noise. */
{
double bkgrnd=aster->wfs[iwfs].bkgrnd*dtrati;
addnoise(ints[iwfs]->p[isa], &aster->rand, bkgrnd, bkgrnd, 0,0,IND(rnefs,idtrat,ipowfs));
}
break;
case 2:/*there is still poisson noise. */
addnoise(ints[iwfs]->p[isa], &aster->rand, 0, 0, 0,0,0);
break;
default:
error("Invalid noisy\n");
}
igrad[0]=0;
igrad[1]=0;
double pixtheta=parms->skyc.pixtheta[ipowfs];
if(parms->skyc.mtch){
dmulvec(igrad, mtche[iwfs]->p[isa], ints[iwfs]->p[isa]->p, 1);
}
if(!parms->skyc.mtch || fabs(igrad[0])>pixtheta || fabs(igrad[1])>pixtheta){
if(!parms->skyc.mtch){
warning2("fall back to cog\n");
}else{
warning_once("mtch is out of range\n");
}
dcog(igrad, ints[iwfs]->p[isa], 0, 0, 0, 3*IND(rnefs,idtrat,ipowfs), 0);
igrad[0]*=pixtheta;
igrad[1]*=pixtheta;
}
gradout->p[iwfs]->p[isa]=igrad[0];
gradout->p[iwfs]->p[isa+nsa]=igrad[1];
}/*isa */
pmerrm=merrm;
dcellzero(psf[iwfs]);/*reset accumulation.*/
}/*if iwfs has output*/
}/*for wfs*/
}/*if phystart */
//output to mreal after using it to ensure two cycle delay.
if(st2t){//Type I or II control.
if(st2t->mint->p[0]){//has output.
dcp(&mreal, st2t->mint->p[0]->p[0]);
}
}else{//LQG control
kalman_output(kalman, &mreal, 0, 1);
}
if(kalman){//LQG control
int indk=0;
//Form PSOL grads and obtain index to LQG M
for(int iwfs=0; iwfs<aster->nwfs; iwfs++){
int dtrati=(multirate?(int)dtrats->p[iwfs]:dtratc);
if((istep+1) % dtrati==0){
indk|=1<<iwfs;
dmm(&gradout->p[iwfs], 1, aster->g->p[iwfs], mpsol->p[iwfs], "nn", 1./dtrati);
dzero(mpsol->p[iwfs]);
}
}
if(indk){
kalman_update(kalman, gradout->m, indk-1);
}
}else if(st2t){
if(pmerrm){
dmm(&merrm->p[0], 0, pgm, gradout->m, "nn", 1);
}
servo_filter(st2t, pmerrm);//do even if merrm is zero. to simulate additional latency
}
if(parms->skyc.dbg){
memcpy(PCOL(gradsave, istep), gradout->m->p, sizeof(double)*gradsave->nx);
}
}/*istep; */
}
if(parms->skyc.dbg){
int dtrati=(multirate?(int)dtrats->p[0]:dtratc);
writebin(gradsave,"%s/skysim_grads_aster%d_dtrat%d",dirsetup, aster->iaster,dtrati);
writebin(mres,"%s/skysim_sim_mres_aster%d_dtrat%d",dirsetup,aster->iaster,dtrati);
}
dfree(mreal);
dcellfree(mpsol);
dfree(merr);
dcellfree(merrm);
dcellfree(zgradc);
dcellfree(gradout);
dfree(gradsave);
if(hasphy){
dcellfreearr(psf, aster->nwfs);
dcellfreearr(ints, aster->nwfs);
ccellfree(wvf);
ccellfree(wvfc);
ccellfree(otf);
free(mtche);
}
servo_free(st2t);
/*dfree(mres); */
if(mresout) {
*mresout=mres;
}else{
dfree(mres);
}
dscale(res, 1./((nstep-parms->skyc.evlstart)*parms->skyc.navg));
return res;
}
void
reflect·unsafe_New(Type *t, void *ret)
{
ret = runtime·cnew(t);
FLUSH(&ret);
}