Combining MARX and the MIT CCD Simulator

                                  Mike W. Wise
                                  May 23, 2002



Current ACIS CCD Simulators and MARX Integration Issues
-------------------------------------------------------

The simulation of ACIS observations in MARX currently utilizes
various tabulated calibration products (QE files, FEF files,
etc.) in order to generate the CCD properties for a given 
detected event. The actual interaction of a photon with the
CCD is *not* simulated. Codes developed by the MIT and PSU 
ACIS IPI groups do exist to model such interactions.
Integrating one, both, or some amalgamation of these codes
into MARX has been suggested on several occasions. Here, 
I will try to describe some of the issues such an integration 
would involve. I will concentrate on the MIT IPI simulator
since it is this code which is currently used in the generation
of CIAO calibration products for ACIS.


MIT CCD Simulator (written by Gregory Y. Prigozhin)
---------------------------------------------------

1) "Licensing"

   This code was developed and is maintained by the MIT ACIS
   IPI team for internal calibration and testing efforts.
   As well as representing the research activities of individuals.
   Although the IPI team has been very positive about supporting
   efforts to incorporate the simulator into MARX for internal
   calibration activities, a version for general release
   would require their official consent. Such a general release
   raises issues of support and responsibility which need to 
   be addressed before the code could be publically released.


2) BI model

   The current code simulates a BI CCD to a reasonable level
   of accuracy. This model is currently used by the calibration
   group to generate calibration products for the ACIS S3 aimpoint
   CCD. ACIS S1 is not simulated directly by the model, but is
   approximated by modifying the products created for S3.

   An as yet to be determined way to make the model "tunable"
   for individual CCDs would be required. Currently the model
   is tuned for S3 and these parameters are hard-coded.


3) FI model

   A separate version of the simulator code exists to simulate
   preflight FI CCDs. Needless to say, such a model is a far
   cry from the current FI performance. The degradations involved
   in CTI is added subsequently using specialized IDL code
   I believe. For integration into MARX, these two pieces of
   code would need to be integrated. The tuning to individual
   FI CCDs would also be required.


4) On-orbit fidelity

   The CCDs performace evolves. Currently, the calibration group
   begins with a simulation using the MIT code and then "tweaks"
   the resulting fits to agree with on-orbit calibration data and
   other input from sources such as grating spectra. Somehow the
   rewrite of the simulator code would have to be designed to
   allow such "tweaking".


5) Implementation

   The current code consists of a single monolithic C program.
   This code would essentially need to be completely rewritten
   for incorporation into MARX as well as redesigned to allow
   tuning. And there would need to be two models internally
   for the two types of CCDs, both tunable.


6) Addtional code required

   Adding code to MARX to allow the photon/CCD interaction to be
   simulated is only the tip of the development iceberg. First, 
   the current code does not simulate a full ACIS frame but
   rather the charge cloud produced by a single photon. Additional
   code would have to be created to produce full frames, perform
   the onboard detection algorithm, and treat more complicated
   effects such as pileup.

   This point also raises the issue of the many ACIS readout
   modes and their subsequent effects of the event CCD properties
   read out. MARX does not currently simulate different ACIS
   readout modes. 



Summary
--------

Implementing a full CCD simulation at the back end of MARX
has many attractive aspects. However, it also a highly
non-trivial undertaking and not simply a matter of plugging
exsiting code into the MARX architecture.