cell *readdata_by_id(file_t *fp, uint32_t id, int level, header_t *header){
header_t header2={0};
if(!header){
header=&header2;
read_header(header, fp);
}
void *out=0;
if(level<0 && !iscell(&header->magic)){
level=0;
}
if(zfisfits(fp) || level==0){
switch(level){
case 0:/*read a mat*/
if(!id) id=header->magic;
switch(id){
case M_DBL:
case M_FLT:
out=dreaddata(fp, header);break;
case M_CMP:
case M_ZMP:
out=creaddata(fp, header);break;
case M_LONG: out=lreaddata(fp, header);break;
case M_LOC64: out=locreaddata(fp, header); break;
case M_MAP64: out=mapreaddata(fp, header); break;
case M_DSP32: case M_DSP64: /**Possible to read mismatched integer*/
out=dspreaddata(fp, header);break;
case M_SSP32: case M_SSP64:
out=sspreaddata(fp, header);break;
case M_CSP32: case M_CSP64:
out=cspreaddata(fp, header);break;
case M_ZSP64: case M_ZSP32:
out=zspreaddata(fp, header);break;
default:error("data type id=%u not supported\n", id);
}
break;
case 1:{/*read a cell from fits*/
int maxlen=10;
void **tmp=malloc(maxlen*sizeof(void*));
int nx=0;
do{
if(nx>=maxlen){
maxlen*=2;
tmp=realloc(tmp, sizeof(void*)*maxlen);
}
tmp[nx++]=readdata_by_id(fp, id, 0, header);
free(header->str);header->str=0;
}while(!read_header2(header, fp));
cell *dcout=cellnew(nx, 1);
memcpy(dcout->p, tmp, sizeof(void*)*nx);
free(tmp);
out=dcout;
}
break;
default:
error("Only support zero or one level of cell when reading fits file\n");
}
}else{
if(!iscell(&header->magic)){
//wrap array into cell
info2("Read cell from non cell data\n");
cell *dcout=cellnew(1,1);
dcout->p[0]=readdata_by_id(fp, id, level-1, header);
out=dcout;
}else{
long nx=header->nx;
long ny=header->ny;
cell *dcout=cellnew(nx, ny);
dcout->header=header->str; header->str=0;
for(long i=0; i<nx*ny; i++){
dcout->p[i]=readdata_by_id(fp, id, level-1, 0);
}
out=dcout;
}
}
free(header->str);header->str=0;
return out;
}
long setup_star_read_ztilt(STAR_S *star, int nstar, const PARMS_S *parms, int seed){
const double ngsgrid=parms->maos.ngsgrid;
long nstep=0;
TIC;tic;
for(int istar=0; istar<nstar; istar++){
STAR_S *stari=&star[istar];
int npowfs=parms->maos.npowfs;
stari->ztiltout=dcellnew(npowfs, 1);
const double thetax=stari->thetax*206265;/*in as */
const double thetay=stari->thetay*206265;
double thxnorm=thetax/ngsgrid;
double thynorm=thetay/ngsgrid;
long thxl=(long)floor(thxnorm);/*Used to be double, but -0 appears. */
long thyl=(long)floor(thynorm);
double wtx=thxnorm-thxl;
double wty=thynorm-thyl;
for(int ipowfs=0; ipowfs<npowfs; ipowfs++){
const int msa=parms->maos.msa[ipowfs];
const int nsa=parms->maos.nsa[ipowfs];
const int ng=nsa*2;
char *fnztilt[2][2]={{NULL,NULL},{NULL,NULL}};
char *fngoff[2][2]={{NULL, NULL}, {NULL, NULL}};
double wtsum=0;
for(int ix=0; ix<2; ix++){
double thx=(thxl+ix)*ngsgrid;
for(int iy=0; iy<2; iy++){
double thy=(thyl+iy)*ngsgrid;
double wtxi=fabs(((1-ix)-wtx)*((1-iy)-wty));
if(wtxi<0.01){
/*info("skipping ix=%d,iy=%d because wt=%g\n",ix,iy,wtxi); */
continue;
}
fnztilt[iy][ix]=myalloca(PATH_MAX, char);
if(parms->skyc.usephygrad){
warning_once("Using phygrad\n");
snprintf(fnztilt[iy][ix],PATH_MAX,"%s/phygrad/phygrad_seed%d_sa%d_x%g_y%g",
dirstart,seed,msa,thx,thy);
}else{
snprintf(fnztilt[iy][ix],PATH_MAX,"%s/ztiltout/ztiltout_seed%d_sa%d_x%g_y%g",
dirstart,seed,msa,thx,thy);
}
fngoff[iy][ix]=myalloca(PATH_MAX, char);
snprintf(fngoff[iy][ix],PATH_MAX,"%s/gradoff/gradoff_sa%d_x%g_y%g",
dirstart,msa,thx,thy);
if(!zfexist(fnztilt[iy][ix])){
//warning("%s doesnot exist\n",fnwvf[iy][ix]);
fnztilt[iy][ix]=fngoff[iy][ix]=NULL;
}else{
wtsum+=wtxi;
}
}
}
if(wtsum<0.01){
error("PSF is not available for (%g,%g). wtsum=%g\n",thetax,thetay, wtsum);
}
/*Now do the actual reading */
for(int ix=0; ix<2; ix++){
for(int iy=0; iy<2; iy++){
double wtxi=fabs(((1-ix)-wtx)*((1-iy)-wty))/wtsum;
if(fnztilt[iy][ix]){
file_t *fp_ztilt=zfopen(fnztilt[iy][ix],"rb");
header_t header={0,0,0,0};
read_header(&header, fp_ztilt);
if(iscell(&header.magic)){
// error("expected data type: %u, got %u\n",(uint32_t)MCC_ANY, header.magic);
nstep=header.nx;
free(header.str);
if(stari->nstep==0){
stari->nstep=nstep;
}else{
if(stari->nstep!=nstep){
error("Different type has different steps\n");
}
}
if(!stari->ztiltout->p[ipowfs]){
stari->ztiltout->p[ipowfs]=dnew(ng, nstep);
}
dmat *ztiltout=stari->ztiltout->p[ipowfs];
for(long istep=0; istep<nstep; istep++){
dmat *ztilti=dreaddata(fp_ztilt, 0);
for(int ig=0; ig<ng; ig++){
ztiltout->p[ig+istep*ng]+=ztilti->p[ig]*wtxi;
}
dfree(ztilti);
}
}else{
dmat *tmp=dreaddata(fp_ztilt, &header);
dadd(&stari->ztiltout->p[ipowfs], 1, tmp, wtxi );
dfree(tmp);
}
zfclose(fp_ztilt);
}/* if(fnwvf) */
if(fngoff[iy][ix] && zfexist(fngoff[iy][ix])){
if(!stari->goff){
stari->goff=dcellnew(npowfs, 1);
}
dmat *tmp=dread("%s", fngoff[iy][ix]);
dadd(&stari->goff->p[ipowfs], 1, tmp, wtxi);
dfree(tmp);
}
}/*iy */
}/*ix */
}/*ipowfs */
}/*istar */
if(parms->skyc.verbose){
toc2("Reading PSF");
}
//close(fd);
return nstep;
}
