static int build_quads(hpquads_t* me, int Nhptotry, il* hptotry, int R) {
int nthispass = 0;
int lastgrass = 0;
int i;
for (i=0; i<Nhptotry; i++) {
anbool ok;
int hp;
if ((i * 80 / Nhptotry) != lastgrass) {
printf(".");
fflush(stdout);
lastgrass = i * 80 / Nhptotry;
}
if (hptotry)
hp = il_get(hptotry, i);
else
hp = i;
me->hp = hp;
me->quad_created = FALSE;
ok = find_stars(me, me->radius2, R);
if (ok)
create_quad(me, TRUE);
if (me->quad_created)
nthispass++;
else {
if (R && me->Nstars && me->retryhps)
// there were some stars, and we're counting how many times stars are used.
//il_insert_unique_ascending(me->retryhps, hp);
// we don't mind hps showing up multiple times because we want to make up for the lost
// passes during loosening...
il_append(me->retryhps, hp);
// FIXME -- could also track which hps are worth visiting in a future pass
}
}
printf("\n");
return nthispass;
}
/*--------------------------------------------------------*/
int main(int argc, char *argv[])
{
char **header,
*imffname, *parfname, *psffname, *reffname,
*instrname,
*fieldname,
*catname,
*coofname,
record[RECORD_LEN],
**diffiles,
**imfiles,
**kerfiles;
int nx0, ny0, k, nim, iim, hsize,
cx, cy, psfn, kern, irad, ofs, nobj1, nobj1_max, nobj2,
nobj2_max, i, j, flag, *index,
nvar;
float x0_off, y0_off, x_tmp, y_tmp, fwhm_limit, *fwhm,
**im, **difim, *refim, *varim1, *varim2, *corrim,
*tmpim;
double *wxy, x, y, *psfs, *psfim, *kerim, ratio;
FILE *outfcat, *outfcoo;
STAR *obj1, *obj2, *objp;
PSF_STRUCT psf;
KER_STRUCT ker;
PAR_STRUCT par;
/*** IO stuff ***/
if (argc != 9) usage();
parfname = argv[1];
instrname= argv[2];
reffname = argv[3];
psffname = argv[4];
imffname = argv[5];
fieldname = argv[6];
x0_off = atof(argv[7]);
y0_off = atof(argv[8]);
puts("sssssss");
get_params(parfname, instrname, &par);
puts("sssssss");
if (!(catname=(char *)calloc(strlen(fieldname)+5, sizeof(char))))
errmess("calloc(catname)");
strcpy(catname, fieldname); strcat(catname, ".cat");
if (!(coofname=(char *)calloc(strlen(fieldname)+5, sizeof(char))))
errmess("calloc(coofname)");
strcpy(coofname, fieldname); strcat(coofname, ".coo");
if (par.verbose > 2)
{
printf("parfname = %s\n", parfname);
printf("instrname= %s\n", instrname);
printf("reffname = %s\n", reffname);
printf("psffname = %s\n", psffname);
printf("imffname = %s\n", imffname);
printf("fieldname= %s\n", fieldname);
printf("x0_off = %g\n", x0_off);
printf("y0_off = %g\n", y0_off);
printf("--------\n");
printf("catname = %s\n", catname);
printf("coofname = %s\n", coofname);
printf("--------\n");
}
nim=read_inp_list(imffname, &diffiles, &imfiles, &kerfiles);
if (par.verbose) printf("%s: %d images\n", imffname, nim);
// printf("%s %s %s\n", diffiles[0],imfiles[0],kerfiles[0]);
// printf("%s %s %s\n", diffiles[1],imfiles[1],kerfiles[1]);
//getchar();
/**********************************************************************/
/*** read in psf fit and get a sample kernel from the first image ***/
/**********************************************************************/
read_psf(psffname, &psf, par.verbose);
printf("%f %f %f\n",psf.ax, psf.ay, psf.vec[0]);
read_kernel(kerfiles[0], &ker, 1, par.verbose);
printf("%f %d %f\n",*ker.sig, *ker.deg, *ker.vec[0]);
//getchar();
psf.normrad = par.normrad;
psf.hw += ker.hw;
psfn = 2*psf.hw + 1;
kern = 2*ker.hw + 1;
/*** get memory ***/
if (!(ker.vecs = (double **)malloc(ker.nvecs*sizeof(double *))))
errmess("malloc(ker.vecs)");
for (k=0; k<ker.nvecs; k++)
if (!(ker.vecs[k] = (double *)malloc(kern*kern*sizeof(double))))
errmess("malloc(ker.vecs[k])");
if (!(kerim=(double *)malloc(kern*kern*sizeof(double))))
errmess("malloc(kerim)");
if (!(psfim=(double *)malloc(psfn*psfn*sizeof(double))))
errmess("malloc(psfim)");
if (!(fwhm = (float *)malloc(nim*sizeof(float)))) errmess("malloc(fwhm)");
if (!(index = (int *)malloc(nim*sizeof(int)))) errmess("malloc(index)");
/***********************************************************************/
/** get things that can be done once for all: spatial coeffs and psfs **/
/***********************************************************************/
refim=read_FITS_2D1file(reffname, 's', &hsize, &header, &nx0, &ny0);
for (i=0; i<hsize; i++) free(header[i]);
free(header);
par.nx0 = nx0;
par.ny0 = ny0;
par.psfhw = psf.hw;
par.psfn = psfn;
printf("nx0: %d %d %d %d\n",nx0,ny0,psf.hw,psfn);
irad = (int)par.anrad2 + 2;
/*** get even more memory ***/
if (!(psfs=(double *)malloc(psfn*psfn*sizeof(double))))
errmess("malloc(psfs)");
if (!(wxy=(double *)malloc(ker.nwxy*sizeof(double)))) errmess("malloc(wxy)");
if (!(im =(float **)malloc(nim*sizeof(float *)))) errmess("malloc(im)");
if (!(difim=(float **)malloc(nim*sizeof(float *)))) errmess("malloc(difim)");
if (!(varim1=(float *)malloc(nx0*ny0*sizeof(float))))
errmess("malloc(varim1)");
if (!(varim2=(float *)malloc(nx0*ny0*sizeof(float))))
errmess("malloc(varim2)");
if (!(corrim=(float *)malloc(nx0*ny0*sizeof(float))))
errmess("malloc(corrim)");
for (i=0; i<nx0*ny0; i++) varim1[i] = varim2[i] = 0.0;
/*** make reference psf and spatial coeffs for kernel ***/
init_psf(&psf, (double)(nx0/2), (double)(ny0/2));
make_psf(&psf, (double)(nx0/2), (double)(ny0/2), nx0/2, ny0/2, psfs);
make_vectors(&ker);
spatial_coeffs(&ker, (double)(ker.nx/2), (double)(ker.ny/2), wxy);
/*******************************/
/*** main loop over images ***/
/*******************************/
printf("MAIN:\n");
for (iim=0; iim<nim; iim++)
{
read_kernel(kerfiles[iim], &ker, 0, par.verbose);
make_kernel(&ker, wxy, kerim, 0);
im_convolve(psfs, psfim, psfn, psfn, kerim, ker.hw);
fwhm[iim] = get_fwhm(psfim, 0.0, 0.0, 0, 0, &par, &ratio);
}
/*** reject bad seeing frames ***/
quick_sort(fwhm, index, nim);
printf("fwhm = %f\n",fwhm[0]);
printf("fwhm = %f\n",fwhm[1]);
fwhm_limit = fwhm[index[(int)(nim*par.fwhm_frac)]];
printf("fwhmlim = %f\n",fwhm_limit);
j = 0;
for (iim=0; iim<nim; iim++)
{
if (fwhm[iim] <= fwhm_limit)
{
if (j != iim)
{
strcpy(diffiles[j], diffiles[iim]);
strcpy( imfiles[j], imfiles[iim]);
strcpy(kerfiles[j], kerfiles[iim]);
}
j++;
}
}
nim = j;
if (nim == 0)
{
printf("no images left ! (exit)\n");
exit(2);
}
/*** get all variability data at once ***/
for (iim=0; iim<nim; iim++)
{
difim[iim]=read_FITS_2D1file(diffiles[iim], 's',
&hsize, &header, &nx0, &ny0);
//printf("difim = %f\n",difim[iim]);
for (i=0; i<hsize; i++) free(header[i]);
free(header);
if ((nx0 != par.nx0) || (ny0 != par.ny0))
{
printf("ERROR! getvar: image %s has wrong size\n", diffiles[iim]);
exit(3);
}
im[iim]=read_FITS_2D1file(imfiles[iim], 's', &hsize, &header, &nx0, &ny0);
for (i=0; i<hsize; i++) free(header[i]);
free(header);
if ((nx0 != par.nx0) || (ny0 != par.ny0))
{
printf("ERROR! getvar: image %s has wrong size\n", imfiles[iim]);
exit(4);
}
}
/*** prepare variability likelihood image ***/
get_repeaters(difim, im, varim1, varim2, &par, nim);
/*** save variability images ***/
if (!(tmpim=(float *)malloc(nx0*ny0*sizeof(float)))) errmess("malloc(tmpim)");
memcpy(tmpim, varim1, nx0*ny0*sizeof(float));
writevar2fits("var1.fits", nx0, ny0, tmpim);
memcpy(tmpim, varim2, nx0*ny0*sizeof(float));
writevar2fits("var2.fits", nx0, ny0, tmpim);
free(tmpim);
/*** find stellar looking things ***/
covar_sig(varim1, corrim, nx0, ny0, 0.0, par.mohw, psfs, par.psfhw);
obj1 = find_stars(corrim, nx0, ny0, &nobj1, &nobj1_max, &par);
if (par.verbose > 1) printf("find_stars -> %d variables of type 1\n", nobj1);
center_stars(obj1, nobj1, difim, im, &par, nim);
/***/
covar_sig(varim2, corrim, nx0, ny0, 0.0, par.mohw, psfs, par.psfhw);
obj2 = find_stars(corrim, nx0, ny0, &nobj2, &nobj2_max, &par);
if (par.verbose > 1) printf("find_stars -> %d variables of type 2\n", nobj2);
center_stars(obj2, nobj2, difim, im, &par, nim);
/*** some stars may be found in both: take only one type and flag ***/
cross_id(obj1, nobj1, obj2, nobj2, par.id_rad);
if (par.verbose)
printf("\nFound %d and %d candidates for variables of both types\n\n",
nobj1, nobj2);
/*********************************************************************/
/*** write results to a binary file and x,y to a temporary file ***/
/*********************************************************************/
if (!(outfcoo = fopen(coofname, "w"))) errmess(coofname);
if (!(outfcat = fopen(catname, "w"))) errmess(catname);
free(coofname);
free(catname);
fseek(outfcat, 0, SEEK_END);
ofs = sizeof(float);
/*** get sinusoidal variables out ***/
if (par.verbose) printf("var1:\n num X Y flux flag\n");
nvar=0;
for (i=0; i<nobj1; i++)
{
if (par.verbose > 1) printf("i= %d\n", i);
objp = &(obj1[i]);
x = (double)(objp->x);
y = (double)(objp->y);
if (par.verbose > 1) printf("x= %g y= %g\n", x, y);
if ((x < par.bad_margin) || (x >= par.nx0 - par.bad_margin)) continue;
if ((y < par.bad_margin) || (y >= par.ny0 - par.bad_margin)) continue;
cx = objp->cx;
cy = objp->cy;
if (par.verbose > 1) printf("cx= %d cy= %d\n", cx, cy);
/*** append to a binary file ***/
if (objp->nframes > 0)
{
fprintf(outfcoo, "%5d %11.5f %11.5f\n", nvar, x, y);
nvar++;
/*** get template photometry ***/
init_psf(&psf, x, y);
make_psf(&psf, x, y, cx, cy, psfs);
objp->bg = bkg(refim, cx, cy, &par);
get_phot(refim, refim, refim, x, y, cx, cy, psfs, objp, &par);
flag = neighbor(refim, (int)x, (int)y, &par, objp->bg);
if (par.verbose)
printf("%4d %9.3f %9.3f %9.1f %5d\n", i, x, y, objp->p_flux, flag);
x_tmp = (float)(x + x0_off);
y_tmp = (float)(y + y0_off);
if (par.verbose > 2)
{
printf("x_tmp= %g y_tmp= %g\n", x_tmp, y_tmp);
printf("ofs= %d 13*ofs= %d\n", ofs, 13*ofs);
}
memcpy(&record[ 0*ofs], &x_tmp , ofs);
memcpy(&record[ 1*ofs], &y_tmp , ofs);
memcpy(&record[ 2*ofs], &objp->p_flux , ofs);
memcpy(&record[ 3*ofs], &objp->p_err , ofs);
memcpy(&record[ 4*ofs], &objp->a_flux , ofs);
memcpy(&record[ 5*ofs], &objp->a_err , ofs);
memcpy(&record[ 6*ofs], &objp->bg , ofs);
memcpy(&record[ 7*ofs], &objp->chi2_n , ofs);
memcpy(&record[ 8*ofs], &objp->corr , ofs);
memcpy(&record[ 9*ofs], &objp->nbad , sizeof(int));
memcpy(&record[10*ofs], &objp->vtype , sizeof(int));
memcpy(&record[11*ofs], &objp->nframes, sizeof(int));
memcpy(&record[12*ofs], &flag , sizeof(int));
if (par.verbose > 2) printf("record prepared - writting...\n");
fwrite(record, 1, sizeof(record), outfcat);
}
}
/*** the same for transients ***/
if (par.verbose) printf("var2:\n num X Y flux flag\n");
for (i=0; i<nobj2; i++)
{
if (par.verbose > 1) printf("i= %d\n", i);
objp = &obj2[i];
x = (double)(objp->x);
y = (double)(objp->y);
if (par.verbose > 1) printf("x= %g y= %g\n", x, y);
if ((x < par.bad_margin) || (x >= par.nx0 - par.bad_margin)) continue;
if ((y < par.bad_margin) || (y >= par.ny0 - par.bad_margin)) continue;
cx = objp->cx;
cy = objp->cy;
if (par.verbose > 1) printf("cx= %d cy= %d\n", cx, cy);
/*** append to a binary file ***/
if (objp->nframes > 0)
{
fprintf(outfcoo, "%5d %11.5f %11.5f\n", nvar, x, y);
nvar++;
/*** get template photometry ***/
init_psf(&psf, x, y);
make_psf(&psf, x, y, cx, cy, psfs);
obj2[i].bg = bkg(refim, cx, cy, &par);
get_phot(refim, refim, refim, x, y, cx, cy, psfs, objp, &par);
flag = neighbor(refim, (int)x, (int)y, &par, objp->bg);
if (par.verbose)
printf("%4d %9.3f %9.3f %9.1f %5d\n",
i+nobj1, x, y, objp->p_flux, flag);
x_tmp = (float)(x + x0_off);
y_tmp = (float)(y + y0_off);
if (par.verbose > 2)
{
printf("x_tmp= %g y_tmp= %g\n", x_tmp, y_tmp);
printf("ofs= %d 13*ofs= %d\n", ofs, 13*ofs);
}
memcpy(&record[ 0*ofs], &x_tmp , ofs);
memcpy(&record[ 1*ofs], &y_tmp , ofs);
memcpy(&record[ 2*ofs], &objp->p_flux , ofs);
memcpy(&record[ 3*ofs], &objp->p_err , ofs);
memcpy(&record[ 4*ofs], &objp->a_flux , ofs);
memcpy(&record[ 5*ofs], &objp->a_err , ofs);
memcpy(&record[ 6*ofs], &objp->bg , ofs);
memcpy(&record[ 7*ofs], &objp->chi2_n , ofs);
memcpy(&record[ 8*ofs], &objp->corr , ofs);
memcpy(&record[ 9*ofs], &objp->nbad , sizeof(int));
memcpy(&record[10*ofs], &objp->vtype , sizeof(int));
memcpy(&record[11*ofs], &objp->nframes, sizeof(int));
memcpy(&record[12*ofs], &flag , sizeof(int));
if (par.verbose > 2) printf("record prepared - writting...\n");
fwrite(record, 1, sizeof(record), outfcat);
}
}
fclose(outfcoo);
fclose(outfcat);
if (par.verbose) printf("\nVariability seach fihished!\n");
return(0);
}
