[evla-sw-discuss] more about interim pointing results

[Ken Sowinski]

I continue the discussion over disseminating pointing offset
measurements.  Modified versions of the structs I distributed last
week are included here.  The major difference is that the ref_result
struct is now entirely self contained for each antenna and provides
only what is needed to make referenced pointing work.  Any other
information is assumed to be present in the executor.  The array of
structs will be sent to mchost after every pointing trial and it is up
to mchost to decide what to do with them.  The intent is that each
report is complete and independent of the ones before it in the same
scan.  The alternative of sending results at the end of a scan was
rejected because where telcal sits, the end of a scan is not known
until the first record of the next scan is seen; that might be too
late for pointing results.  Sending results after each trial continues
to be robust even if the operator does random skips around the file in
the Modcomps.

I have compiled a list of things that are present in the .PNT file
given to PEEK, but not available in the archive record from which we
will be constrained to run in the future.  I claim only one item on this 
list is critical and it can be reconstructed from other information.

1.  The a priori pointing model as represented in the POINTING and
SYS?ROT files.  This is required to be able to produce new, updated,
versions of these files which can be transmitted to the Modcomps to be
installed.  While the Modcomps are still here this is not an issue.
After the Modcomps are gone we can generate SQL which can be used to
update the evla parameters database with the changes reported by PEEK.

Also found in the ANTENNAS file is the name of the pad which the
antenna rests on.  Knowledge of this is important for bookkeeping, and
for the evla will be used to decide how to rotate the antenna tilt
when it is combined with the pad tilt.  It is important to carry this
information with the pointing results and I propose to derive it from
the antenna baseline parameters in the archive record.

2.  The temperature of the white and black balls installed at the
weather station.  The intent was to give an estimate of cloud cover by
measuring how much the white ball was cooled through radiating to the
sky.  This was never used in the pointing analysis.  One of the two
sensors broke a few years ago and has never been fixed.

3.  A flag indicating which wrap the antenna is on cannot be generated 
from the archive record.  PEEK makes no use of this.  If it is deemed to
be required, the archive record could be modified to include a bit to
report this just as it does for over-the-top.

4.  The antenna anemometer data is not available in the archive record.
Again PEEK makes no use of this and uses only the wind speed reported
by the weather station.  This data will no longer be reported to PEEK.

We can entertain proposals for changes to the archive record after the
Modcomps are retired, but I strongly prefer to keep it unchanged while 
the Modcomps are still in use.




/* This record represents the results of ptgsol for the subarray given
   in subid for one pointing trial.  It is intended for use with PEEK
   and is lifted from the structure of the .PNT file that is currently 
   used to communicate results to PEEK.  There will be one record for 
   each subarray in pointing mode.
*/
struct pointing_record {
  char   version[] = "Ver 10.0    June 2005";   /* PEEK wants this  */
  int    subid;        /* Subarray ID (1-5)  */
  int    mjd;          /* mjad  */
  double iat;          /* IAT in radians  */
  double lst;          /* LSt in radians  */
  char   mod[2];       /* observing mode (will always be I?)  */
  char   pid[6];       /* observing program  */
  char   sou[12];      /* source name  */
  int    qua;          /* qualifier  */
  char   band[2];      /* band code  */
  char   cormode[4];   /* correlator mode  */
  float  wx[5];        /* weather recorded at centerof pointing cycle  */
  int    nant;         /* number of antennas in subarray  */
  float  trig[6]       /* cos and sin of az, el, eta  */
  int    nant;         /* number of antennas in subarray  */
  int    npnt;         /* number of antennas with successful pointing solutions  */
  struct offset[27];   /* pointing results for npnt antennas  */
};
/* this struct represents what PEEK needs.  The version to be sent
   to the executor is described below as ref_offset.
*/
struct offset {
  int id;                 /* antenna ID  */
  char pad[8];            /* pad   *NOT* AVAILABLE IN THE ARCHIVE RECORD  */
  /* Each of the quantities below is averaged over the two IFs of
     corresponding polarization if both IFs are available.
  */
  float razerr, razbeam;  /* arc-min, normalized RCP  */
  float lazerr, lazbeam;  /* arc-min, normalized LCP  */
  float relerr, relbeam;  /*   RCP    */
  float lelerr, lelbeam;  /*   LCP    */
  float rflux;            /* measured apparant flux at 'on' in DJy  */
  float lflux;            /* measured apparant flux at 'on' in DJy  */
  char  flags[8];         /* space for quality indicators, OTT, etc  */
};

/* This struct represents what is to be passed to the executor as
   an XML document.  I expect it to be constructed in the module which 
   prepares the packet to be sent to the executor from pointing_record.  
   An array of these will be sent to the executor after each pointing 
   trial with one element for each antenna with a successful solution.  
   I think this is all that is needed to implement referenced pointing, 
   but if I have omitted anything it can easily be added.
*/
struct ref_offset {
  int    id;              /* antenna ID  */
  float  trig[4];         /* cos, sin of az and el  */
  double time;            /* EVLA timestamp at center of pointing trial  */
  char   band[2];         /* Band at which pointing was measured  */
  float  azerr;           /* sum over all trials of az error  */
  float  elerr;           /*              ditto for el  */
  int    count;           /* count of successful trials  */
  char   flags[4];        /* might need this for various referenced
                             pointing variations  */
};