chandra/lkl_srcdet
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

energy interpolation added, convergence condition updated

Browse Source
This commit is contained in:
Андрей Семена
2025-06-16 16:21:19 +03:00
parent ea741219ce
commit 54febb8bbf
3 changed files with 402 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

279
chan_psf.c
View File

@@ -15,6 +15,120 @@ double * psfvalfromptr(double * psfdata, npy_intp * dims, int k, int xi, int yi)
return psfdata + (k*dims[1] + xi)*dims[2] + yi;
};
double * eepsfvalfromptr(double * psfdata, npy_intp * dims, int k, int ei, int xi, int yi)
{
//printf("check didx %d %.2e\n", ((dims[1]*eidx + k)*dims[2] + xi)*dims[3] + yi, *( psfdata + ((dims[1]*eidx + k)*dims[2] + xi)*dims[3] + yi));
return psfdata + ((k*dims[1] + ei)*dims[2] + xi)*dims[3] + yi;
};
static PyObject * put_psf_on(PyObject *self, PyObject *args)
{
PyArrayObject *psfi, *x, *y, *roll, *xc, *yc, *smat, *emap;
if (!PyArg_ParseTuple(args, "OOOOOOOO", &psfi, &x, &y, &roll, &xc, &yc, &smat, &emap)) return NULL;
int loc, ctr, msum=0;
double x1, y1, dx, dy;
npy_intp snew = {emap->dimensions[0]};
PyArrayObject * cmap = PyArray_SimpleNew(1, &snew, NPY_DOUBLE);
double * cmapd = (double*) cmap->data;
double * smatd = (double*) smat->data;
double *ca = (double*)malloc(sizeof(double)*x->dimensions[0]);
double *sa = (double*)malloc(sizeof(double)*x->dimensions[0]);
double* nparrptr = (double*) roll->data;
for (ctr=0; ctr < x->dimensions[0]; ctr++)
{
ca[ctr] = cos(nparrptr[ctr]);
sa[ctr] = sin(nparrptr[ctr]);
};
Py_BEGIN_ALLOW_THREADS;
double inpixdx, inpixdy;
long * k = (long*)psfi->data;
double* xptr = (double*) x->data;
double* yptr = (double*) y->data;
double *xcptr = (double*) xc->data;
double *ycptr = (double*) yc->data;
double pval, eloc, p2, p3;
int idx1d, idx2d;
printf("check smap %d %d %d\n", smat->dimensions[0], smat->dimensions[1], smat->dimensions[2]);
printf("%f %f %f %f %f\n", nparrptr[0], xptr[0], yptr[0], xcptr[0], ycptr[0]);
for (loc=0; loc < xc->dimensions[0]; loc++) // loop over sky locations
{
//printf("loc %d %d %d \n", loc);
msum = 0;
for (ctr=0; ctr < psfi->dimensions[0]; ctr++) // for each sky location loop over all provided events
{
x1 = (xcptr[loc] - xptr[ctr]);
y1 = (ycptr[loc] - yptr[ctr]);
//rotate by the event roll angle, dx dy centered at the psf center (central pixel of 101x101 map)
dx = x1*ca[ctr] - y1*sa[ctr]; //+ 50;
dy = y1*ca[ctr] + x1*sa[ctr]; // + 50.;
// temporary hardcode psf shape is 101x101
//current psf shape is 101:
if ((dx > -50) && (dx < 50))
{
if ((dy > -50) && (dy < 50))
{
idx1d = (int)((dx + 50.5)); // float dx from -0.5 to 0.5 should fell in the 50-th pixel
idx2d = (int)((dy + 50.5));
pval = * psfvalfromptr(smatd, smat->dimensions, *(k + ctr), idx1d, idx2d);
//naive interpolation block
//-------------------------------------------------------------------------------------------------------
inpixdx = dx - (idx1d - 50);
inpixdy = dy - (idx2d - 50);
if (inpixdx > 0.)
{
p2 = * psfvalfromptr(smatd, smat->dimensions, *(k + ctr), idx1d + 1, idx2d);
if (inpixdy > 0.)
{
p3 = * psfvalfromptr(smatd, smat->dimensions, * (k + ctr), idx1d, idx2d + 1);
}else{
inpixdy = -inpixdy;
p3 = * psfvalfromptr(smatd, smat->dimensions, * (k + ctr), idx1d, idx2d - 1);
}
}else{
p2 = * psfvalfromptr(smatd, smat->dimensions, * (k + ctr), idx1d - 1, idx2d);
inpixdx = -inpixdx;
if (inpixdy > 0.)
{
p3 = * psfvalfromptr(smatd, smat->dimensions, * (k + ctr), idx1d, idx2d + 1);
}else{
inpixdy = -inpixdy;
p3 = * psfvalfromptr(smatd, smat->dimensions, * (k + ctr), idx1d, idx2d - 1);
}
}
printf("pval %f %f %f %f %f idx12&k %d %d %d x1:%f y1:%f dxdy: %f %f\n", pval, p2, p3, inpixdx, inpixdy, idx1d, idx2d, k[ctr], x1, y1, dx, dy);
pval = (pval + inpixdx*(p2 - pval) + inpixdy*(p3 - pval));
msum = 1;
};
};
};
if (msum > 0)
{
*(cmapd + loc) = pval;
};
};
Py_END_ALLOW_THREADS;
PyObject *res = Py_BuildValue("O", cmap);
Py_DECREF(cmap);
return res;
}
static PyObject * solve_for_locations(PyObject *self, PyObject *args)
{
@@ -184,10 +298,175 @@ static PyObject * solve_for_locations(PyObject *self, PyObject *args)
return res;
}
static PyObject * solve_for_locations_eintp(PyObject *self, PyObject *args)
{
//xc, yc --- wcs locations, events has coordinates in the same locations, and psf have the same grid as well
// the only additional parameter to events are pk scale (rate scale in respect to psf) and rotation angle
PyArrayObject *psfi, *eidx, *x, *y, *roll, *pk, *xc, *yc, *smat, *emap;
int loc, ctr;
double x1, y1, dx, dy;
if (!PyArg_ParseTuple(args, "OOOOOOOOOO", &psfi, &eidx, &x, &y, &roll, &pk, &xc, &yc, &emap, &smat)) return NULL;
// -------------------------- ===============
// those are events properties those for sky smat it array for psf matrices
npy_intp snew = {xc->dimensions[0]};
PyArrayObject * cmap = PyArray_SimpleNew(1, &snew, NPY_DOUBLE);
PyArrayObject * pmap = PyArray_SimpleNew(1, &snew, NPY_DOUBLE);
double * cmapd = (double*) cmap->data;
double * pmapd = (double*) pmap->data;
double * smatd = (double*) smat->data;
double *ca = (double*)malloc(sizeof(double)*x->dimensions[0]);
double *sa = (double*)malloc(sizeof(double)*x->dimensions[0]);
double* nparrptr = (double*) roll->data;
for (ctr=0; ctr < x->dimensions[0]; ctr++)
{
ca[ctr] = cos(nparrptr[ctr]);
sa[ctr] = sin(nparrptr[ctr]);
};
double * bw = (double*)malloc(sizeof(double)*psfi->dimensions[0]); //not more then thet will be used for each location
Py_BEGIN_ALLOW_THREADS;
double inpixdx, inpixdy;
double * pkd = (double*) pk->data;
long * k = (long*)psfi->data;
double * ek = (double*)eidx->data;
int ei;
double* xptr = (double*) x->data;
double* yptr = (double*) y->data;
double *xcptr = (double*) xc->data;
double *ycptr = (double*) yc->data;
long ctr, msum=0;
double lkl, erf;
double pval, eloc, p2, p3, ptmp;
int idx1d, idx2d;
//return psfdata + ((k*dims[1] + ei)*dims[2] + xi)*dims[3] + yi;
//printf("psf dim %d %d %d %d\n", smat->dimensions[0], smat->dimensions[1], smat->dimensions[2], smat->dimensions[3]);
//printf("psf %f %f\n", smatd[((0*smat->dimensions[1] + 1*smat->dimensions[2]) + 30)*smat->dimensions[3] + 30], smatd[((0*smat->dimensions[1] + 1*smat->dimensions[2]) + 30)*smat->dimensions[3] + 30]);
for (loc=0; loc < xc->dimensions[0]; loc++) // loop over sky locations
{
msum = 0;
//printf("loc %d\n", loc);
for (ctr=0; ctr < psfi->dimensions[0]; ctr++) // for each sky location loop over all provided events
{
x1 = (xcptr[loc] - xptr[ctr]);
y1 = (ycptr[loc] - yptr[ctr]);
//rotate by the event roll angle, dx dy centered at the psf center (central pixel of 101x101 map)
dx = x1*ca[ctr] - y1*sa[ctr]; //+ 50;
dy = y1*ca[ctr] + x1*sa[ctr]; // + 50.;
// temporary hardcode psf shape is 101x101
ei = (int)(ek[ctr]);
erf = ek[ctr] - (double)(ei);
//printf("evt %d ei %d erf %f ek %f\n", ctr, ei, erf, ek[ctr]);
//current psf shape is 101:
if ((dx > -50) && (dx < 50))
{
if ((dy > -50) && (dy < 50))
{
idx1d = (int)((dx + 50.5)); // float dx from -0.5 to 0.5 should fell in the 50-th pixel
idx2d = (int)((dy + 50.5));
pval = (* eepsfvalfromptr(smatd, smat->dimensions, *(k + ctr), ei, idx1d, idx2d))*(1. - erf) + (* eepsfvalfromptr(smatd, smat->dimensions, *(k + ctr), ei + 1, idx1d, idx2d))*erf;
//naive interpolation block
//-------------------------------------------------------------------------------------------------------
inpixdx = dx - (idx1d - 50);
inpixdy = dy - (idx2d - 50);
if (inpixdx > 0.)
{
p2 = (* eepsfvalfromptr(smatd, smat->dimensions, *(k + ctr), ei, idx1d + 1, idx2d))*(1. - erf) + (* eepsfvalfromptr(smatd, smat->dimensions, *(k + ctr), ei + 1, idx1d + 1, idx2d))*erf;
if (inpixdy > 0.)
{
p3 = (* eepsfvalfromptr(smatd, smat->dimensions, *(k + ctr), ei, idx1d, idx2d + 1))*(1. - erf) + (* eepsfvalfromptr(smatd, smat->dimensions, *(k + ctr), ei + 1, idx1d, idx2d + 1))*erf;
}else{
inpixdy = -inpixdy;
p3 = (* eepsfvalfromptr(smatd, smat->dimensions, *(k + ctr), ei, idx1d, idx2d - 1))*(1. - erf) + (* eepsfvalfromptr(smatd, smat->dimensions, *(k + ctr), ei + 1, idx1d, idx2d - 1))*erf;
}
}else{
p2 = (* eepsfvalfromptr(smatd, smat->dimensions, *(k + ctr), ei, idx1d - 1, idx2d))*(1. - erf) + (* eepsfvalfromptr(smatd, smat->dimensions, *(k + ctr), ei + 1, idx1d - 1, idx2d))*erf;
inpixdx = -inpixdx;
if (inpixdy > 0.)
{
p3 = (* eepsfvalfromptr(smatd, smat->dimensions, *(k + ctr), ei, idx1d, idx2d + 1))*(1. - erf) + (* eepsfvalfromptr(smatd, smat->dimensions, *(k + ctr), ei + 1, idx1d, idx2d + 1))*erf;
}else{
inpixdy = -inpixdy;
p3 = (* eepsfvalfromptr(smatd, smat->dimensions, *(k + ctr), ei, idx1d, idx2d - 1))*(1. - erf) + (* eepsfvalfromptr(smatd, smat->dimensions, *(k + ctr), ei + 1, idx1d, idx2d - 1))*erf;
}
}
//printf("pval %f %f %f %f %f %d %d %d\n", pval, p2, p3, inpixdx, inpixdy, idx1d, idx2d, k[ctr]);
pval = (pval + inpixdx*(p2 - pval) + inpixdy*(p3 - pval))* (*(pkd + ctr));
// interpolation up to here
//-------------------------------------------------------------------------------------------------------
if (pval > 1e-10)
{
bw[msum] = pval;
//printf("%d %d %d %f %f %f %f %f\n", k[ctr], idx1d, idx2d, inpixdx, inpixdy, dx, dy, pval);
//printf("%d %d %d %f %f %f %f %f\n", k[ctr], idx1d, idx2d, xptr[ctr], yptr[ctr], xcptr[loc], ycptr[loc], pval);
msum += 1;
};
};
};
};
if (msum > 0)
{
eloc = (double) *((double*) emap->data + loc);
pval = get_phc_solution_pkr((double) msum, eloc, bw, msum);
*(cmapd + loc) = pval*eloc;
lkl = 0.;
for (ctr=0; ctr < msum; ctr ++)
{
lkl = lkl + log(pval*bw[ctr] + 1.);
}
//printf("loc %d %d %f %f %f %f\n", loc, msum, bw[0], eloc, pval, lkl);
*(pmapd + loc) = lkl; //log(lkl); //get_lkl_pkr(pval, bw, msum);
/*
lkl = 0;
for (ctr=0; ctr < msum; ctr ++)
{
lkl = lkl + bw[ctr];
}
*(pmapd + loc) = lkl;
printf("%d %d %f\n", msum, loc, pmapd[loc]);
*/
}else{
*(cmapd + loc) = 0.;
*(pmapd + loc) = 0.;
};
};
//printf("loop done\n");
Py_END_ALLOW_THREADS;
free(bw);
PyObject *res = Py_BuildValue("OO", cmap, pmap);
Py_DECREF(cmap);
Py_DECREF(pmap);
return res;
}
static PyMethodDef PSFMethods[] = {
{"solve_for_locations", solve_for_locations, METH_VARARGS, "get coordinates within pixel based on its coordinates"},
{"solve_for_locations_eintp", solve_for_locations_eintp, METH_VARARGS, "compute likelihood using psf energy interpolation"},
{"put_psf_on_img", put_psf_on, METH_VARARGS, "put psf as is on img for all cooreindates "},
{NULL, NULL, 0, NULL}
};