cell* read_by_id(uint32_t id, int level, const char *format, ...){
format2fn;
file_t *fp=zfopen(fn,"rb");
cell *out=readdata_by_id(fp, id, level, 0);
zfclose(fp);
return out;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]){
file_t *fp;
char *fn=NULL;
int start=0, howmany=0;
switch(nrhs){
case 3:
start=(long)mxGetScalar(prhs[2]);//starting block to read. matlab index.
case 2:
howmany=(long)mxGetScalar(prhs[1]);//do not break
case 1:
fn=mx2str(prhs[0]);
break;
default:
usage();
}
if(howmany>0){
if(start>0){
start--;//convert to C index.
}
if(start<0){
start=0;
}
}
fp=zfopen(fn,"rb");
if(!fp){
perror("zfopen");
error("Unable to open file: %s\n", fn);
return;
}
free(fn);
switch(nlhs){
case 0:
case 1:
plhs[0]=readdata(fp, NULL, start, howmany); break;
case 2:
plhs[0]=readdata(fp, &plhs[1], start, howmany); break;
default:
usage();
}
if(start==0 && howmany==0){
int res=zfeof(fp);
if(res){
warning("There is unread data: res=%d\n", res);
}
}
zfclose(fp);
}
/**
Write an 1-d or 2-d array into the file. First write a magic number that
represents the data type. Then write two numbers representing the
dimension. Finally write the data itself.
*/
void writearr(const void *fpn, /**<[in] The file pointer*/
const int isfn, /**<[in] Is this a filename or already opened file*/
const size_t size, /**<[in] Size of each element*/
const uint32_t magic,/**<[in] The magic number. see bin.h*/
const char *str, /**<[in] The header as string*/
const void *p, /**<[in] The data of the array*/
const uint64_t nx, /**<[in] Number of rows. this index changes fastest*/
const uint64_t ny /**<[in] Number of columns. 1 for vector*/
) {
file_t *fp;
header_t header= {magic, nx, ny, (char*)str};
if(isfn) {
fp=zfopen((char*)fpn, "wb");
} else {
fp=(file_t*) fpn;
}
if(!fp) {
warning("fp is empty\n");
return;
}
write_header(&header, fp);
if(nx*ny>0) zfwrite(p, size, nx*ny, fp);
if(isfn) zfclose(fp);
}
/*
* Loads a CRAM .crai index into memory.
*
* Returns 0 for success
* -1 for failure
*/
int cram_index_load(cram_fd *fd, char *fn) {
char line[1024], fn2[PATH_MAX];
zfp *fp;
cram_index *idx;
cram_index **idx_stack = NULL, *ep, e;
int idx_stack_alloc = 0, idx_stack_ptr = 0;
/* Check if already loaded */
if (fd->index)
return 0;
fd->index = calloc((fd->index_sz = 1), sizeof(*fd->index));
if (!fd->index)
return -1;
idx = &fd->index[0];
idx->refid = -1;
idx->start = INT_MIN;
idx->end = INT_MAX;
idx_stack = calloc(++idx_stack_alloc, sizeof(*idx_stack));
idx_stack[idx_stack_ptr] = idx;
sprintf(fn2, "%s.crai", fn);
if (!(fp = zfopen(fn2, "r"))) {
perror(fn2);
return -1;
}
while (zfgets(line, 1024, fp)) {
int n;
/* 1.1 layout */
n = sscanf(line, "%d\t%d\t%d\t%"PRId64"\t%d\t%d",
&e.refid,
&e.start,
&e.end,
&e.offset,
&e.slice,
&e.len);
e.end += e.start-1;
//printf("%d/%d..%d\n", e.refid, e.start, e.end);
if (e.refid != idx->refid) {
if (fd->index_sz < e.refid+2) {
fd->index_sz = e.refid+2;
fd->index = realloc(fd->index,
fd->index_sz * sizeof(*fd->index));
}
idx = &fd->index[e.refid+1];
idx->refid = e.refid;
idx->start = INT_MIN;
idx->end = INT_MAX;
idx->nslice = idx->nalloc = 0;
idx->e = NULL;
idx_stack[(idx_stack_ptr = 0)] = idx;
}
while (!(e.start >= idx->start && e.end <= idx->end)) {
idx = idx_stack[--idx_stack_ptr];
}
// Now contains, so append
if (idx->nslice+1 >= idx->nalloc) {
idx->nalloc = idx->nalloc ? idx->nalloc*2 : 16;
idx->e = realloc(idx->e, idx->nalloc * sizeof(*idx->e));
}
e.nalloc = e.nslice = 0; e.e = NULL;
*(ep = &idx->e[idx->nslice++]) = e;
idx = ep;
if (++idx_stack_ptr >= idx_stack_alloc) {
idx_stack_alloc *= 2;
idx_stack = realloc(idx_stack, idx_stack_alloc*sizeof(*idx_stack));
}
idx_stack[idx_stack_ptr] = idx;
}
zfclose(fp);
free(idx_stack);
// dump_index(fd);
return 0;
}
/*
* Builds an index file.
*
* fd is a newly opened cram file that we wish to index.
* fn_base is the filename of the associated CRAM file. Internally we
* add ".crai" to this to get the index filename.
*
* Returns 0 on success
* -1 on failure
*/
int cram_index_build(cram_fd *fd, const char *fn_base) {
cram_container *c;
off_t cpos, spos, hpos;
zfp *fp;
char fn_idx[PATH_MAX];
if (strlen(fn_base) > PATH_MAX-6)
return -1;
sprintf(fn_idx, "%s.crai", fn_base);
if (!(fp = zfopen(fn_idx, "wz"))) {
perror(fn_idx);
return -1;
}
cpos = htell(fd->fp);
while ((c = cram_read_container(fd))) {
int j;
if (fd->err) {
perror("Cram container read");
return 1;
}
hpos = htell(fd->fp);
if (!(c->comp_hdr_block = cram_read_block(fd)))
return 1;
assert(c->comp_hdr_block->content_type == COMPRESSION_HEADER);
c->comp_hdr = cram_decode_compression_header(fd, c->comp_hdr_block);
if (!c->comp_hdr)
return -1;
// 2.0 format
for (j = 0; j < c->num_landmarks; j++) {
char buf[1024];
cram_slice *s;
int sz;
spos = htell(fd->fp);
assert(spos - cpos - c->offset == c->landmark[j]);
if (!(s = cram_read_slice(fd))) {
zfclose(fp);
return -1;
}
sz = (int)(htell(fd->fp) - spos);
if (s->hdr->ref_seq_id == -2) {
cram_index_build_multiref(fd, c, s, fp,
cpos, c->landmark[j], sz);
} else {
sprintf(buf, "%d\t%d\t%d\t%"PRId64"\t%d\t%d\n",
s->hdr->ref_seq_id, s->hdr->ref_seq_start,
s->hdr->ref_seq_span, (int64_t)cpos,
c->landmark[j], sz);
zfputs(buf, fp);
}
cram_free_slice(s);
}
cpos = htell(fd->fp);
assert(cpos == hpos + c->length);
cram_free_container(c);
}
if (fd->err) {
zfclose(fp);
return -1;
}
return zfclose(fp);
}
int parse_baf(GapIO *io, char *fn, tg_args *a) {
int nseqs = 0, nobj = 0, ntags = 0, ncontigs = 0;
struct stat sb;
zfp *fp;
off_t pos;
contig_t *c = NULL;
tg_pair_t *pair = NULL;
baf_block *b, *co = NULL;
int last_obj_type = 0;
int last_obj_pos = 0;
tg_rec last_obj_rec = 0;
tg_rec last_cnt_rec = 0;
int last_cnt_pos = 0;
int last_obj_orient = 0;
printf("Loading %s...\n", fn);
if (-1 == stat(fn, &sb) ||
NULL == (fp = zfopen(fn, "r"))) {
perror(fn);
return -1;
}
if (a->pair_reads) {
pair = create_pair(a->pair_queue);
}
/* Loop:
* Read 1 block of data.
* If contig, create contig
* If read, insert it, insert to index.
* Anything else - reject for now
*/
pos = 0;
while (b = baf_next_block(fp)) {
int delay_destroy = 0;
switch (b->type) {
case CO: {
char *contig = baf_block_value(b, CO);
if (co)
baf_block_destroy(co);
co = b;
delay_destroy = 1;
ncontigs++;
create_new_contig(io, &c, contig, a->merge_contigs);
/* For anno */
last_obj_type = GT_Contig;
last_obj_rec = c->rec;
last_obj_pos = c->start + 1;
last_cnt_rec = c->rec;
last_cnt_pos = c->start + 1;
last_obj_orient = 0;
break;
}
case RD: {
seq_t seq;
int flags;
char *tname;
tg_rec recno;
int is_pair = 0;
/* Construct seq struct */
if (-1 == construct_seq_from_block(a, &seq, b, &tname)) {
fprintf(stderr, "Failed to parse read block for seq %d\n",
nseqs);
break;
}
/* Create range, save sequence */
flags = GRANGE_FLAG_TYPE_SINGLE;
if (seq.flags & SEQ_END_REV)
flags |= GRANGE_FLAG_END_REV;
else
flags |= GRANGE_FLAG_END_FWD;
if (seq.len < 0)
flags |= GRANGE_FLAG_COMP1;
if (pair) is_pair = 1;
recno = save_range_sequence(io, &seq, seq.mapping_qual, pair,
is_pair, tname, c, a, flags, NULL);
/* For anno */
last_obj_type = GT_Seq;
last_obj_rec = recno;
if (seq.len >= 0) {
last_obj_pos = seq.pos;
last_obj_orient = 0;
} else {
last_obj_pos = seq.pos - seq.len - 1;
last_obj_orient = 1;
}
nseqs++;
break;
}
case AN: {
range_t r;
anno_ele_t *e;
char *typ = baf_block_value(b, AN);
char *loc = baf_block_value(b, LO);
char *len = baf_block_value(b, LL);
char *txt = baf_block_value(b, TX);
char *at = baf_block_value(b, AT);
int an_pos;
bin_index_t *bin;
int anno_obj_type;
if (!(a->data_type & DATA_ANNO))
break;
if (txt)
unescape_line(txt);
if (last_obj_type == GT_Contig || (at && *at == 'C'))
anno_obj_type = GT_Contig;
else
anno_obj_type = GT_Seq;
if (!loc) {
an_pos = last_obj_pos;
} else {
if (*loc == '@') {
an_pos = atoi(loc+1);
} else {
if (anno_obj_type == GT_Contig) {
if (last_obj_orient == 0)
an_pos = last_cnt_pos + atoi(loc)-1;
else
an_pos = last_cnt_pos - (atoi(loc)-1)
- (len ? atoi(len)-1 : 0);
} else {
if (last_obj_orient == 0)
an_pos = last_obj_pos + atoi(loc)-1;
else
an_pos = last_obj_pos - (atoi(loc)-1)
- (len ? atoi(len)-1 : 0);
}
}
}
r.start = an_pos;
r.end = an_pos + (len ? atoi(len)-1 : 0);
r.mqual = str2type(typ);
r.pair_rec = (anno_obj_type == GT_Contig)
? last_cnt_rec
: last_obj_rec;
r.flags = GRANGE_FLAG_ISANNO;
if (GT_Seq == anno_obj_type)
r.flags |= GRANGE_FLAG_TAG_SEQ;
r.rec = anno_ele_new(io, 0, anno_obj_type, r.pair_rec, 0,
str2type(typ), txt);
e = (anno_ele_t *)cache_search(io, GT_AnnoEle, r.rec);
e = cache_rw(io, e);
bin = bin_add_range(io, &c, &r, NULL, NULL, 0);
e->bin = bin->rec;
ntags++;
break;
}
case 0:
/* blank line */
break;
default:
printf("Unsupported block type '%s'\n",
linetype2str(b->type));
}
if (!delay_destroy)
baf_block_destroy(b);
if ((++nobj & 0xfff) == 0) {
int perc = 0;
pos = zftello(fp);
perc = 100.0 * pos / sb.st_size;
printf("\r%d%c", perc, (nobj & 0x3fff) ? '%' : '*');
fflush(stdout);
if ((nobj & 0x3fff) == 0)
cache_flush(io);
}
#if 1
if ((nobj & 0x3fff) == 0) {
static int perc = 0;
if (perc < 100.0 * pos / sb.st_size) {
perc = 100.0 * pos / sb.st_size;
printf("\r%d%%", perc);
//HacheTableStats(io->cache, stdout);
//HacheTableStats(((GDB **)io->dbh)[0]->gfile->idx_hash, stdout);
{
static struct timeval last, curr;
static int first = 1;
static int last_obj = 0;
static int last_contigs = 0;
long delta;
gettimeofday(&curr, NULL);
if (first) {
last = curr;
first = 0;
}
delta = (curr.tv_sec - last.tv_sec) * 1000000
+ (curr.tv_usec - last.tv_usec);
printf(" - %g sec %d obj (%d contigs)\n", delta/1000000.0,
nobj - last_obj, ncontigs - last_contigs);
last = curr;
last_obj = nobj;
last_contigs = ncontigs;
}
fflush(stdout);
}
}
#endif
}
if (pair && !a->fast_mode) {
finish_pairs(io, pair);
}
if (co)
baf_block_destroy(co);
cache_flush(io);
zfclose(fp);
printf("\nLoaded %12d contigs\n", ncontigs);
printf(" %12d sequences\n", nseqs);
printf(" %12d annotations\n", ntags);
if (pair) delete_pair(pair);
if (c)
cache_decr(io, c);
return 0;
}
/* ----------------------------------------------------------------------
* tg_index interface below.
*/
int parse_fasta_or_fastq(GapIO *io, char *fn, tg_args *a, int format) {
int nseqs = 0, ret = 0;
zfp *fp;
struct stat sb;
fastq_entry_t ent = { fn, 0, NULL, NULL, NULL, 0, 0, 0, 0, '\0', '\0' };
//fastq_entry_t *(*next_seq)(zfp *fp);
contig_t *c = NULL;
int last_perd = 1;
int res;
vmessage("Loading %s...\n", fn);
if (-1 == stat(fn, &sb) ||
NULL == (fp = zfopen(fn, "r"))) {
perror(fn);
return -1;
}
/* Fetch sequences */
while ((res = fastaq_next(fp, &ent)) == 0) {
seq_t seq;
static int dummy_qual_len = 0;
static int8_t *dummy_qual = NULL;
// printf("@%s\n%s\n+\n%s\n", ent->name, ent->seq, ent->qual);
// printf("%d\tSeq %s len %d / %d\n",
// nseqs, ent->name, (int)strlen(ent->seq), ent->seq_len);
if (ent.seq_len <= 0) {
verror(ERR_WARN, "parse_fasta_or_fastq",
"Sequence named '%.1000s' appears to be blank", ent.name);
continue;
}
/* Create 1 read contig */
create_new_contig(io, &c, ent.name, 0);
seq.rec = 0;
seq.parent_rec = 0;
seq.parent_type = 0;
seq.pos = 1;
seq.flags = 0;
seq.seq_tech = STECH_UNKNOWN;
seq.format = SEQ_FORMAT_CNF1;
seq.left = 1;
seq.right = ent.seq_len;
seq.name_len = strlen(ent.name);
seq.name = strdup(ent.name);
seq.template_name_len = seq.name_len;
seq.seq = ent.seq;
seq.len = ent.seq_len;
seq.mapping_qual = 0;
if (dummy_qual_len < ent.seq_len) {
dummy_qual_len = ent.seq_len;
dummy_qual = realloc(dummy_qual, dummy_qual_len);
if (!dummy_qual) {
res = -1;
break;
}
}
seq.conf = dummy_qual;
assert(seq.conf);
if (ent.qual) {
int i;
for (i = 0; i < ent.seq_len; i++) {
int q = ent.qual[i] - '!';
if (q < 0)
q = 0;
if (q > 100)
q = 100;
seq.conf[i] = q;
}
} else {
assert(dummy_qual);
memset(dummy_qual, 3, dummy_qual_len);
}
seq.trace_name = NULL;
seq.trace_name_len = 0;
seq.alignment = NULL;
seq.alignment_len = 0;
seq.sam_aux = NULL;
seq.aux_len = 0;
seq.anno = NULL;
save_range_sequence(io,
&seq,
0, /* mapping qual */
NULL, /* pair array */
0, /* is_pair */
NULL, /* template name */
c, /* contig */
a, /* args */
GRANGE_FLAG_TYPE_SINGLE,
NULL, /* library */
NULL /* bin return rec */
);
if ((++nseqs & 0xff) == 0) {
int perc = 0;
off_t pos = zftello(fp);
perc = 100.0 * pos / sb.st_size;
if (perc > last_perd * 10) {
vmessage("%c%d%%\n", (nseqs & 0xfff) ? '.' : '*', perc);
last_perd = perc / 10 + 1;
} else {
vmessage("%c", (nseqs & 0xfff) ? '.' : '*');
}
UpdateTextOutput();
if ((nseqs & 0xfff) == 0)
cache_flush(io);
}
}
vmessage("100%%\n");
if (NULL != ent.name) free(ent.name);
if (NULL != ent.seq) free(ent.seq);
if (NULL != ent.qual) free(ent.qual);
if (res != 1) {
ret = -1;
}
vmessage("Loaded %d sequences\n", nseqs);
zfclose(fp);
cache_flush(io);
return ret;
}
void write_by_id(const void *A, uint32_t id, const char* format,...){
format2fn;
file_t *fp=zfopen(fn,"wb");
writedata_by_id(fp, A, id);
zfclose(fp);
}
/**
Read in asterism WFS wvf.*/
long setup_star_read_wvf(STAR_S *star, int nstar, const PARMS_S *parms, int seed){
const double ngsgrid=parms->maos.ngsgrid;
const int nwvl=parms->maos.nwvl;
long nstep=0;
TIC;tic;
for(int istar=0; istar<nstar; istar++){
STAR_S *stari=&star[istar];
int npowfs=parms->maos.npowfs;
stari->wvfout=mycalloc(npowfs,ccell**);
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];
if(stari->use[ipowfs]==0){
continue;
}
char *fnwvf[2][2]={{NULL,NULL},{NULL,NULL}};
PISTAT_S *pistati=&stari->pistat[ipowfs];
/*info2("Reading PSF for (%5.1f, %5.1f), ipowfs=%d\n",thetax,thetay,ipowfs); */
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;
}
fnwvf[iy][ix]=myalloca(PATH_MAX, char);
snprintf(fnwvf[iy][ix],PATH_MAX,"%s/wvfout/wvfout_seed%d_sa%d_x%g_y%g",
dirstart,seed,msa,thx,thy);
if(!zfexist(fnwvf[iy][ix])){
//warning("%s doesnot exist\n",fnwvf[iy][ix]);
fnwvf[iy][ix]=0;
}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(fnwvf[iy][ix]){
/*info("Loading %.4f x %s\n", wtxi, fnwvf[iy][ix]); */
file_t *fp_wvf=zfopen(fnwvf[iy][ix],"rb");
header_t header={0,0,0,0};
read_header(&header, fp_wvf);
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(parms->skyc.limitnstep >0 && nstep>parms->skyc.limitnstep){
nstep=parms->skyc.limitnstep;
warning("Only read %ld steps\n",nstep);
}
if(stari->nstep==0){
stari->nstep=nstep;
}else{
if(stari->nstep!=nstep){
error("Different type has different steps\n");
}
}
if(!stari->wvfout[ipowfs]){
stari->wvfout[ipowfs]=mycalloc(nstep,ccell*);
}
ccell **pwvfout=stari->wvfout[ipowfs];
for(long istep=0; istep<nstep; istep++){
ccell *wvfi=ccellreaddata(fp_wvf, 0);
ccelladd(&(pwvfout[istep]), 1, wvfi, wtxi);
ccellfree(wvfi);
}
/*zfeof(fp_wvf); */
zfclose(fp_wvf);
}
}/*iy */
}/*ix */
/*Don't bother to scale ztiltout since it does not participate in physical optics simulations. */
if(parms->skyc.bspstrehl){
dmat* scale=pistati->scale;
ccell **pwvfout=stari->wvfout[ipowfs];
for(int iwvl=0; iwvl<nwvl; iwvl++){
for(int isa=0; isa<nsa; isa++){
/*info("Scaling WVF isa %d iwvl %d with %g\n", isa, iwvl, IND(scale,isa,iwvl)); */
for(long istep=0; istep<stari->nstep; istep++){
cscale(pwvfout[istep]->p[isa+nsa*iwvl], IND(scale,isa,iwvl));
}/*istep */
}/*isa */
}/*iwvl */
}/* */
}/*ipowfs */
}/*istar */
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;
}
