Coordinates on the sky and the chip¶

In every marx simulation, one or more sources are placed at some sky position. marx simulates photons coming from that position, traces them through the mirror and gratings and finally places them on the chip. With a known aspect solution, chip coordinates can then be transformed back to sky coordinates. In general, this will not recover the exact sky position where a photon started out. A big part of that is scatter in the mirrors, which blurs the image. However, with a large number of photons, we can fit the average position which should be close to the real sky position.

In real observations, other factors contribute, such as the finite resolution of the detectors (marx usually takes that into account, but it can be switched off through the --pixadj="EXACT" switch in marx2fits) and the uncertainty of the aspect solution.

Within a single observation, positions will be less certain for fainter sources (due to Poisson statistics) and for sources at a larger off-axis angles (due to the larger PSF).

Chandra Orion Ultradeep project¶

The Orion Nebula Cluster (ONC) is a dense star forming region with about 1600 X-ray sources observed in the COUP survey by Getman et al (2005). We simulate this field with marx and then run a source detection to check how well we recover the input coordinates. This will depend on the number of counts detected and the position in the field. To simplify the simulation input, we assume that all sources have flat lightcurves and are monoenergetic at the observed mean energy (the energy matters because the effective area is energy dependent and so is the PSF). We write a short C code that reads an input coordinate list and generates the photons in this manner.

Click to show code

Click to hide code

'''C code for a grid of sources.

(``user.h`` and ``jdmath.h`` are shipped with marx.)'''
ccode=r'''
#include <stdio.h>
#include <stdlib.h>
#include <jdmath.h>
#include "user.h"

/* This user source implements many point sources via a file that
 * specifies the source positions and energies.  The current implementation
 * assumes the format:
 *  RA  Dec weight energy
 * Here RA, Dec specify the source position, weight specifies the strength
 * of the source in relation to the others.
 */
typedef struct
{
   double cosx, cosy, cosz;
   double weight;
   double energy;
}
Point_Source_Type;

static unsigned int Num_Points;
static Point_Source_Type *Point_Sources;
static unsigned int Max_Num_Points;

static char *do_realloc (char *p, unsigned int len)
{
   if (p == NULL)
     p = malloc (len);
   else
     p = realloc (p, len);

   if (p == NULL)
     fprintf (stderr, "Not enough memory\n");

   return p;
}

static void free_sources (void)
{
   if (Point_Sources == NULL)
     return;

   free ((char *) Point_Sources);
   Point_Sources = NULL;
}

static int add_source (double ra, double dec, double weight, double energy)
{
   Point_Source_Type *p;
   double cosx, cosy, cosz;

   /* Convert to God's units from arc-min */
   ra = ra * (PI/(180.0 * 60.0));
   dec = dec * (PI/(180.0 * 60.0));

   if (Max_Num_Points == Num_Points)
     {
        Max_Num_Points += 32;
        p = (Point_Source_Type *)do_realloc ((char *)Point_Sources, Max_Num_Points * sizeof (Point_Source_Type));
        if (p == NULL)
          {
             free_sources ();
             return -1;
          }
        Point_Sources = p;
     }

   p = Point_Sources + Num_Points;
   /* Note the the minus sign is to generate a vector pointing from the
    * source to the origin
    */
   p->cosx = -cos (dec) * cos (ra);
   p->cosy = -cos (dec) * sin(ra);
   p->cosz = -sin (dec);

   p->weight = weight;
   p->energy = energy;
   Num_Points += 1;

   return 0;
}

static void normalize_sources (void)
{
   double total;
   unsigned int i;

   total = 0;
   for (i = 0; i < Num_Points; i++)
     {
	Point_Sources[i].weight += total;
	total = Point_Sources[i].weight;
     }

   for (i = 0; i < Num_Points; i++)
     Point_Sources[i].weight /= total;

   /* Make sure no round-off error affects the weight of the last point */
   Point_Sources[Num_Points - 1].weight = 1.0;
}

int user_open_source (char **argv, int argc, double area,
		      double cosx, double cosy, double cosz)
{
   FILE *fp;
   char line[1024];
   char *file;
   unsigned int linenum;

   file = argv[0];
   if (file == NULL)
     {
	fprintf (stderr, "UserSource Model requires FILE as argument\n");
	return -1;
     }

   fp = fopen (file, "r");
   if (fp == NULL)
     {
	fprintf (stderr, "Unable to open %s\n", file);
	return -1;
     }

   linenum = 0;
   while (NULL != fgets (line, sizeof (line), fp))
     {
	double ra, dec, weight, energy;

	linenum++;
	if (4 != sscanf (line, "%lf %lf %lf %lf", &ra, &dec, &weight, &energy))
	  continue;

	if (weight <= 0.0)
	  {
	     fprintf (stderr, "weight on line %d of %s must be positive\n",
		      linenum, file);
	     free_sources ();
	     return -1;
	  }

	if (-1 == add_source (ra, dec, weight, energy))
	  {
	     fclose (fp);
	     return -1;
	  }
     }

   fclose (fp);
   if (Num_Points == 0)
     {
	fprintf (stderr, "%s contains no sources\n", file);
	return -1;
     }

   normalize_sources ();
   return 0;
}

void user_close_source (void)
{
   free_sources ();
}


int user_create_ray (double *delta_t, double *energy,
		     double *cosx, double *cosy, double *cosz)
{
   double r;
   Point_Source_Type *p;

   p = Point_Sources;

   r = JDMrandom ();
   while (r > p->weight)
     p++;

   *delta_t = -1.0;
   *energy = p->energy;
   *cosx = p->cosx;
   *cosy = p->cosy;
   *cosz = p->cosz;

   return 0;
}

int main (int a, char **b)
{
   (void) a;
   (void) b;
   return 1;
}
'''

with open('pnts.c', 'w') as f:
    f.write(ccode)

In the observation, the brightest sources are piled-up. We don’t bother simulating this here, so for the visualization we just set the scaling limits to bring out the fainter details and ignore the bright peaks.

../_images/524f7c5ec428f9eaf2f945b5719d8ee3a868ad96bed51bd9bd0f2677eb46389a.png

Image of the observed data (left) and simulation (right). The diagonal line from the center to the top right is the read-out streak from :math:\theta^1 Ori C.

../_images/44af23667958e39886f012fd37d9ade6d4842daa1e5f128904e2a61bc634a8ac.png

Apart from a clump close to the aimpoint (where sources in the ONC are so close to each other that they can easily be confused), the distribution of coordinate errors spreads out with increasing distance, i.e. size of the PSF.

Simulations with an IMAGE source¶

The SourceType=IMAGE in marx is a strange beast that behaves in ways that users might find surprising. When using this source type, marx will read in an image file and use the pixel values as relative probabilities for generating photons across the image.

Marx will read the WCS in the image header, but only use the absolute value for the pixel size, not the orientation or position. The center of the image is always supposed to be at the nominal pointing position and the image x/y axes are always aligned with the sky coordinate system in marx.

../_images/078ae6ff640837ce9d9e8fa22777a953df68c0a802393c40a5743f9cef281b9b.png

Regular Grid (ACIS)¶

In this example we place a radial grid of sources on the sky. Each source emits an equal number of photons (exactly, no Poisson statistics) so that we can compare the accuracy of the position we recover. Note that the detected number of photons will be smaller for off-axis photons because of vignetting!

../_images/da82629be9794dc8b4b8f84c14e75964e48eadb3be426002ad9e4d496b184b91.png

Image of the simulation. The size of the PSF increases further away from the aimpoint.

../_images/079d6ffc086522dcce6da15a8ac31eccc249a73f5641a63961ed5c95564dc0f1.png

left: The error in the position (measured radially to the optical axis) increases with the distance to the optical axis. One part of this is just that the effective area and thus the number of counts decreases. There is also a systematic trend where sources at larger off-axis angle are systematically fitted too close to the center. Further investigation is necessary to check if this is a problem of marx or the CIAO tool celldetect. In any case, the typical offset is below 0.2 arcsec, which is less than half a pixel in ACIS. right: Difference in position angle between input and fit.

The input position is typically recovered to much better than one pixel for sources with a few hundred counts. There is a small systematic trend that needs to be studied further.

Regular grid (HRC)¶

Same as above, but with HRC-I as a detector.

The field-of-view for the HRC-I is larger for than for ACIS-I, but the PSF becomes very large at large off-axis angles and thus the positional uncertainty will be so large that a comparison to marx is no longer helpful to test the accuracy of the marx simulations.

../_images/3dab316a32f87231ce8ab31b99079d03b93d3dfae9ddaabe4586f85e15679945.png

Image of the simulation. The size of the PSF increases further away from the aimpoint.

../_images/9d2918f9733203a70b3f165c9b8b82a191e16aa6436361c2d93bdd0aaeec8c30.png

See previous example. The same trends are visible with a slightly larger scatter.

In the central few arcmin the input position is typically recovered to better than 0.2 pixels for sources with a few hundred counts.

Coordinates on the sky and the chip¶

Chandra Orion Ultradeep project¶

Simulations with an IMAGE source¶

Regular Grid (ACIS)¶

Regular grid (HRC)¶

Page Content

Previous topic

Next topic