JIVE Wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
===== function: process_phase_reference_data =====

<code python>
################################################################################
# Process Phase Referencing Data
def process_phase_reference_data(aips_uvdata, PhaseReferencingInfoDict):
    """Runs through the list of phase referencing observations to make images
    """
    # make sure the argument is a list
    if(type(PhaseReferencingInfoDict) != type([0])):
        PhaseReferencingInfoDict = [PhaseReferencingInfoDict]
    # declare some local variables in case they need to be cleaned up in a
    # try block
    junk = AIPSImage('JUNKJUNKJUNKJUNK', 'JUNKCL', 1,1)
    split_uvdata = [junk]
    image_noself = junk
    imgdata = junk
    cal_data = junk
    del junk
    # Ok, what are the numbers of the gain tables which are important
    CL_base = Gainuse_Before_Fring
    CL_first_fring = aips_uvdata.table_highver('AIPS CL') +1
    CL_second_fring = CL_first_fring +1
    # remove any old CL tables if there was a problem
    if(check_table_version_valid(aips_uvdata, 'AIPS CL', CL_first_fring)):
        aips_uvdata.zap_table('AIPS CL', CL_first_fring)
    if(check_table_version_valid(aips_uvdata, 'AIPS CL', CL_second_fring)):
        aips_uvdata.zap_table('AIPS CL', CL_second_fring)
    # Clear any old SN tables
    if(aips_uvdata.table_highver('AIPS SN') > 0):
        aips_uvdata.zap_table('AIPS SN', -1)
    # Set up some FRING information
    fring_snver = 1
    fring_aparm = [None, 0,0,0,0,0,0,0,0,0]
    fring_dparm = [None, 0,0,0,0,0,0,0,0,0]
    fring_aparm[1] = 3  # need at least 3 antennas for a solution
    fring_aparm[6] = 0  # turn most printing off
    fring_aparm[7] = 0  # default SNR level
    fring_aparm[9] = 1  # use search_list
    fring_dparm[1] = 2  # use small number as we only have a point-source model
    fring_dparm[4] = t_int
    fring_dparm[8] = 0  # do not zero rates or delays
    # define the split class
    splitclass = 'SPLIT'
    # Now loop over all pairings.
    for prid in PhaseReferencingInfoDict:
        # now, for each calibrator-target pair, run through and make
        # the sequence of images and statistical data
        try:
            ####################################################################
            # Step 1:  Run Fring on the calibrator in point-source mode
            search_list = range(0,len(prid['Calibrator_Search_List']))
            for antenna in xrange(len(search_list)):
                search_list[antenna] = \
                    antenna_dict[prid['Calibrator_Search_List'][antenna]]
            this_refant = search_list[0]
            search_list[0] = None
            run_fring(aips_uvdata,
                      this_refant,
                      search_list,
                      prid['Calibrator_Solint_Fring'],
                      0,   # solsub
                      prid['Calibrator_Name'],
                      CL_base,
                      prid['Calibrator_Timerange'],
                      final_flagver,
                      Bandpass_Global,
                      None,      # image
                      None,      # ncomp
                      None,      # flux
                      None,      # smodel
                      fring_aparm,
                      fring_dparm,
                      fring_snver)
            print 'fring done'
            run_clcal(aips_uvdata,
                      CL_base,
                      CL_first_fring,
                      this_refant,
                      [prid['Calibrator_Name'],prid['Target_Name']],
                      prid['Calibrator_Name'],
                      None,   # do all timerange for these objects
                      'CALI',
                      'AMBG',
                      snver_first=fring_snver,
                      snver_last = fring_snver)
            # show the phases
            if(pause_after_plots):
                snplot('CL',CL_first_fring,'PHAS',opcode='ALSI',
                       snuvdata=aips_uvdata,sources_use=[prid['Calibrator_Name'],
                                                         prid['Target_Name']],
                       nplots=len(aips_uvdata.antennas))
                possm_2([prid['Calibrator_Name'],prid['Target_Name']], 'LL',
                        CL_first_fring, -1, this_refant, final_flagver,
                        bpver=Bandpass_Global)
            ####################################################################
            # Step 2: process target source to make images
            # split this sucker out
            split_uvdata = \
                split_data(aips_uvdata, splitclass, 1, prid['Target_Name'],
                           CL_first_fring, Bandpass_Global, final_flagver)
            # Run with robust = 8 for natural weighting
            robust = 8
            # Now process the data to make an image and self-cal and make an
            # image.  I need a string to uniquely describe the process
            result_name = prid['Target_Name'] + '.' + prid['Calibrator_Name'] + \
                          '.' + processing_option.__str__() + ".%.0f"%robust
            (statistics_noself, statistics, image_noself, imgdata, cal_data) = \
                                process_single_source_file_to_images(
                split_uvdata[0],
                prid['Target_Name'],
                result_name,
                robust,
                prid['Target_Timerange'],
                this_refant,
                prid['Target_Solint'],       # seconds
                prid['Target_Solint_Amp'],   # seconds
                imsize,       # pixels
                cellsize,     # arcsec
                prid['Target_Source_Size'],
                1,            # starting sequence number
                prid['Target_SelfCal_Iterations'],
                use_initial_point_source_calibration=1,
                save_image_plots=1,
                save_output_data=0
                )
            prid['Target_Statistics_PNSCR8'] = statistics_noself
            prid['Target_Statistics_PWSCR8'] = statistics
            # Run with robust = 0 for smaller beam size
            robust = 0
            # Now process the data to make an image and self-cal and make an
            # image.  I need a string to uniquely describe the process
            result_name = prid['Target_Name'] + '.' + prid['Calibrator_Name'] + \
                          '.' + processing_option.__str__() + ".%.0f"%robust
            (statistics_noself, statistics, image_noself, imgdata, cal_data) = \
                                process_single_source_file_to_images(
                split_uvdata[0],
                prid['Target_Name'],
                result_name,
                robust,
                prid['Target_Timerange'],
                this_refant,
                prid['Target_Solint'],       # seconds
                prid['Target_Solint_Amp'],   # seconds
                imsize,       # pixels
                cellsize,     # arcsec
                prid['Target_Source_Size'],
                3,            # starting sequence number
                prid['Target_SelfCal_Iterations'],
                use_initial_point_source_calibration=1,
                save_image_plots=1,
                save_output_data=0
                )
            prid['Target_Statistics_PNSCR0'] = statistics_noself
            prid['Target_Statistics_PWSCR0'] = statistics
            # Now zap the split data
            split_uvdata[0].zap()
            ####################################################################
            # Step 3: split out the calibrator to make an image to FRING with.
            #         Then reFRING
            split_uvdata = \
                split_data(aips_uvdata, splitclass, 1, prid['Calibrator_Name'],
                           CL_first_fring, Bandpass_Global, final_flagver)
            # Run with robust = 8 for natural weighting
            robust = 8
            # Now process the data to make an image and self-cal and make an
            # image.  I need a string to uniquely describe the process
            result_name = 'tmp'
            (statistics_noself, statistics, image_noself, imgdata, cal_data) = \
                                process_single_source_file_to_images(
                split_uvdata[0],
                prid['Calibrator_Name'],
                result_name,
                robust,
                prid['Calibrator_Timerange'],
                this_refant,
                prid['Calibrator_Calib_Solint'],       # seconds
                prid['Calibrator_Calib_Solint_Amp'],   # seconds
                imsize,       # pixels
                cellsize,     # arcsec
                prid['Calibrator_Source_Size'],
                1,            # starting sequence number
                prid['Calibrator_SelfCal_Iterations'],
                use_initial_point_source_calibration=1,
                save_image_plots=0,
                save_output_data=1  # save just the self-caled image
                )
            # zap the split data before I forget
            split_uvdata[0].zap()
            # Now fring using the new image
            aips_uvdata.zap_table('AIPS SN', -1)
            run_fring(aips_uvdata,
                      this_refant,
                      search_list,
                      prid['Calibrator_Solint_Fring'],
                      0,   # solsub
                      prid['Calibrator_Name'],
                      CL_base,
                      prid['Calibrator_Timerange'],
                      final_flagver,
                      Bandpass_Global,
                      imgdata,      # image
                      prid['Calibrator_Ncomp'],
                      prid['Calibrator_Flux_Fraction']*statistics['Pixel_Max'],
                      None,      # smodel
                      fring_aparm,
                      fring_dparm,
                      fring_snver)
            run_clcal(aips_uvdata,
                      CL_base,
                      CL_second_fring,
                      this_refant,
                      [prid['Calibrator_Name'],prid['Target_Name']],
                      prid['Calibrator_Name'],
                      None,   # do all timerange for these objects
                      'CALI',
                      'AMBG',
                      snver_first=fring_snver,
                      snver_last = fring_snver)
            
            ####################################################################
            # Step 4: process target source to make images
            # split this sucker out
            split_uvdata = \
                split_data(aips_uvdata, splitclass, 1, prid['Target_Name'],
                           CL_second_fring, Bandpass_Global, final_flagver)
            # Run with robust = 8 for natural weighting
            robust = 8
            # Now process the data to make an image and self-cal and make an
            # image.  I need a string to uniquely describe the process
            result_name = prid['Target_Name'] + '.' + prid['Calibrator_Name'] + \
                          '.' + processing_option.__str__() + ".%.0f"%robust
            (statistics_noself, statistics, image_noself, imgdata, cal_data) = \
                                process_single_source_file_to_images(
                split_uvdata[0],
                prid['Target_Name'],
                result_name,
                robust,
                prid['Target_Timerange'],
                this_refant,
                prid['Target_Solint'],       # seconds
                prid['Target_Solint_Amp'],   # seconds
                imsize,       # pixels
                cellsize,     # arcsec
                prid['Target_Source_Size'],
                5,            # starting sequence number
                prid['Target_SelfCal_Iterations'],
                use_initial_point_source_calibration=1,
                save_image_plots=1,
                save_output_data=0
                )
            prid['Target_Statistics_INSCR8'] = statistics_noself
            prid['Target_Statistics_IWSCR8'] = statistics
            # Run with robust = 0 for smaller beam size
            robust = 0
            # Now process the data to make an image and self-cal and make an
            # image.  I need a string to uniquely describe the process
            result_name = prid['Target_Name'] + '.' + prid['Calibrator_Name'] + \
                          '.' + processing_option.__str__() + ".%.0f"%robust
            (statistics_noself, statistics, image_noself, imgdata, cal_data) = \
                                process_single_source_file_to_images(
                split_uvdata[0],
                prid['Target_Name'],
                result_name,
                robust,
                prid['Target_Timerange'],
                this_refant,
                prid['Target_Solint'],       # seconds
                prid['Target_Solint_Amp'],   # seconds
                imsize,       # pixels
                cellsize,     # arcsec
                prid['Target_Source_Size'],
                7,            # starting sequence number
                prid['Target_SelfCal_Iterations'],
                use_initial_point_source_calibration=1,
                save_image_plots=1,
                save_output_data=0
                )
            prid['Target_Statistics_INSCR0'] = statistics_noself
            prid['Target_Statistics_IWSCR0'] = statistics
            # Now zap the split data
            split_uvdata[0].zap()
            # Remove the new CL tables
            aips_uvdata.zap_table('AIPS CL', CL_first_fring)
            aips_uvdata.zap_table('AIPS CL', CL_second_fring)
        finally:
            if(split_uvdata[0].exists()): split_uvdata[0].zap()
            if(image_noself.exists()): image_noself.zap()
            if(imgdata.exists()): imgdata.zap()
            if(cal_data.exists()): cal_data.zap()
</code>