From gmoellen@aoc.nrao.edu Wed Dec  8 13:06:54 2004
Date: Wed, 8 Dec 2004 12:01:29 -0700 (MST)
From: George Moellenbrock <gmoellen@aoc.nrao.edu>
To: aips2-naug@aoc.nrao.edu
Subject: [Aips2-naug] Incremental/Cumulative Calibration Issues


Gang,

I've been working lately on getting so-called "incremental calibration"  
working in calibrater.  As most of the work involves generating
accumulated calibration, it seems more appropriate to call this
"cumulative calibration".  Essentially, it provides for SN/CL-like
capabilities.

The basics are progressing well, but there are a lot of bells and whistles
which it would be good to get some feedback on.  Below are some notes
about what I suspect people will want to see in cumulative calibration.

I'll go over this list in the NAUG meeting today, to point out a few
things and solicit comments.  Comments via email are welcome, too, of 
course.

Cheers,
George


Cumulative Calibration
----------------------

o Simultaneous Apply of and Solve for a particular type (e.g., 'G').

o A function ('setaccum') to generate template accumulated calibration 
   table of desired type with desired timescale (CL v1, INDXR equivalent)

o A function to 'accumulate' (multiply) new calibration solutions
   (SN) onto template (CL)   [CLCAL equivalent]

o Selection, distribution:
   - Field mapping:  accumulate solutions from 'these' fields onto
      template for 'those' fields (SOURCES/CALSOUR equivalent), 'SELF' 
      mode
   - Spw mapping: accumulate solutions from 'these' spws onto 
      template for 'those' spws ('SELF spw' is default)
      (should 'spwmap' only work via accumulation?)

o Interpolation:
   - Currently available modes for direct apply: nearest, linear,
      'aipslin', other?   (should direct apply be defaulted, as
       in AIPS? ...cf DOBAND options)
   - Same interpolation options automatically available for 
       accumulation
   - Bad solution handling: 
      + Clipping/smoothing
      + Value replacement (via interpolation)
      + Propogation of bad solutions in incremental table 
           --> flagged solutions in accumulated table 
           --> flagged data on application (calibrater.correct())

o Interface properties
   - setapply() persistence, i.e., avoid lots of reset() and
      trivial re-do of setapply()
   - setdata() persistence
   - setsolve() non-persistence, i.e., solve() resets setsolve
      state automatically
   - option to forego accumulated calibration (setapply() still
      works even if specified table isn't whole template); we get
      this for free---and its how most types other than G will be
      used
   - Accumulation in place?  I.e., special initializing setapply()
      at beginning that establishes the template which is persistently
      applied, then accumulation updates this in place (saving versions 
      when desired).  This enables a straightforward difmap-like
      mode of operation for imaging/selfcal iterations.
   - Indexed bookkeeping of tables?  (Probably in "task" interface.)
   - ? 

o Example:

include 'calibrater.g';
cal:=calibrater('data.ms');

cal.setaccum(type='G',          # Generate cumulative table for G
             t=60,              #  solutions on 60s timescale
             table='cG1')


cal.setapply(type='P');         # Arrange to apply 'P' indefinitely

# Solve for G on calibrator:
cal.setdata(msselect='FIELD_ID==1')   #  (src1)
cal.setsolve(type='G',          # arrange to solve for G
             table='iG1',....)
cal.solve()                     # solve for G, using P
cal.accumulate(cumulin='cG1',     # accumulate linearly-interp'd
               increin='iG1',     #  solns from src1 onto src1,src2
               cumulout='cG2',    #  write new table 'cG2'
               interp='linear',
               calfield='src1',
               field="src1 src2");


# Correct calibrator and target 
cal.setdata(msselect='FIELD_ID IN [1,2,3]')   # (src1, src2)
cal.setapply(type='G',          # arrange to apply 'cG2'
             table='cG2');
cal.correct()                   # correct src1, src2 for G *and* P

# Image target
  < make initial image of src2 usin imager >

# selfcal target
cal.setdata(msselect='FIELD_ID==2');  # (src2)  (persistent)
cal.setsolve(type='G',          # arrange to solve for G on 10s timescale
             t=10,                  (phase only)
             table='iG2',
             phaseonly=T);
cal.solve()                     # solve for (incremental) G using P, cG2
cal.accumulate(cumulin='cG2',     # accumulate linearly-interp'd
               increin='iG2',     #  solns from src2 onto src2
               cumulout='cG3',    #  write new table 'cG3'
               interp='linear',
               calfield='src1',
               field='src1');

cal.setapply(type='G',          # arrange to apply new cumulative G 
             table='cG3')           (overrides previous)
cal.correct();                  # correct for P, G

 < image again >

# second round of selfcal
cal.setsolve(type='G',          # arrange to solve for G on 10s timescale
             t=10,                  (phase only)
             table='iG3',
             phaseonly=T);
cal.solve()                     # solve for (incremental) G using P, cG3

...etc...

-- 




_______________________________________________
Aips2-naug mailing list
Aips2-naug@listmgr.cv.nrao.edu
http://listmgr.cv.nrao.edu/mailman/listinfo/aips2-naug