Source code for pipeline.hifv.tasks.finalcals.renderer

import collections
import contextlib
import itertools
import operator
import os

import pipeline.domain.measures as measures
import pipeline.infrastructure
import pipeline.infrastructure.filenamer as filenamer
import pipeline.infrastructure.logging as logging
import pipeline.infrastructure.renderer.basetemplates as basetemplates
import pipeline.infrastructure.renderer.weblog as weblog
import pipeline.infrastructure.utils as utils
from pipeline.h.tasks.common.displays import applycal as applycal
from . import display as finalcalsdisplay

LOG = logging.get_logger(__name__)

FlagTotal = collections.namedtuple('FlagSummary', 'flagged total')


[docs]class VLASubPlotRenderer(object): #template = 'testdelays_plots.html' def __init__(self, context, result, plots, json_path, template, filename_prefix, bandlist): self.context = context self.result = result self.plots = plots self.ms = os.path.basename(self.result.inputs['vis']) self.template = template self.filename_prefix = filename_prefix self.bandlist = bandlist self.summary_plots = {} self.finaldelay_subpages = {} self.phasegain_subpages = {} self.bpsolamp_subpages = {} self.bpsolphase_subpages = {} self.bpsolphaseshort_subpages = {} self.finalamptimecal_subpages = {} self.finalampfreqcal_subpages = {} self.finalphasegaincal_subpages = {} self.finaldelay_subpages[self.ms] = filenamer.sanitize('finaldelays' + '-%s.html' % self.ms) self.phasegain_subpages[self.ms] = filenamer.sanitize('phasegain' + '-%s.html' % self.ms) self.bpsolamp_subpages[self.ms] = filenamer.sanitize('bpsolamp' + '-%s.html' % self.ms) self.bpsolphase_subpages[self.ms] = filenamer.sanitize('bpsolphase' + '-%s.html' % self.ms) self.bpsolphaseshort_subpages[self.ms] = filenamer.sanitize('bpsolphaseshort' + '-%s.html' % self.ms) self.finalamptimecal_subpages[self.ms] = filenamer.sanitize('finalamptimecal' + '-%s.html' % self.ms) self.finalampfreqcal_subpages[self.ms] = filenamer.sanitize('finalampfreqcal' + '-%s.html' % self.ms) self.finalphasegaincal_subpages[self.ms] = filenamer.sanitize('finalphasegaincal' + '-%s.html' % self.ms) if os.path.exists(json_path): with open(json_path, 'r') as json_file: self.json = json_file.readlines()[0] else: self.json = '{}' def _get_display_context(self): return {'pcontext': self.context, 'result': self.result, 'plots': self.plots, 'dirname': self.dirname, 'json': self.json, 'finaldelay_subpages': self.finaldelay_subpages, 'phasegain_subpages': self.phasegain_subpages, 'bpsolamp_subpages': self.bpsolamp_subpages, 'bpsolphase_subpages': self.bpsolphase_subpages, 'bpsolphaseshort_subpages': self.bpsolphaseshort_subpages, 'finalamptimecal_subpages': self.finalamptimecal_subpages, 'finalampfreqcal_subpages': self.finalampfreqcal_subpages, 'finalphasegaincal_subpages': self.finalphasegaincal_subpages, 'bandlist': self.bandlist} @property def dirname(self): stage = 'stage%s' % self.result.stage_number return os.path.join(self.context.report_dir, stage) @property def filename(self): filename = filenamer.sanitize(self.filename_prefix + '-%s.html' % self.ms) return filename @property def path(self): return os.path.join(self.dirname, self.filename)
[docs] def get_file(self): if not os.path.exists(self.dirname): os.makedirs(self.dirname) file_obj = open(self.path, 'w') return contextlib.closing(file_obj)
[docs] def render(self): display_context = self._get_display_context() t = weblog.TEMPLATE_LOOKUP.get_template(self.template) return t.render(**display_context)
[docs]class T2_4MDetailsfinalcalsRenderer(basetemplates.T2_4MDetailsDefaultRenderer): def __init__(self, uri='finalcals.mako', description='Final Calibration Tables', always_rerender=False): super(T2_4MDetailsfinalcalsRenderer, self).__init__( uri=uri, description=description, always_rerender=always_rerender)
[docs] def get_display_context(self, context, results): super_cls = super(T2_4MDetailsfinalcalsRenderer, self) ctx = super_cls.get_display_context(context, results) weblog_dir = os.path.join(context.report_dir, 'stage%s' % results.stage_number) summary_plots = {} finaldelay_subpages = {} phasegain_subpages = {} bpsolamp_subpages = {} bpsolphase_subpages = {} bpsolphaseshort_subpages = {} finalamptimecal_subpages = {} finalampfreqcal_subpages = {} finalphasegaincal_subpages = {} band2spw = collections.defaultdict(list) for result in results: m = context.observing_run.get_ms(result.inputs['vis']) spw2band = m.get_vla_spw2band() spwobjlist = m.get_spectral_windows(science_windows_only=True) listspws = [spw.id for spw in spwobjlist] for spw, band in spw2band.items(): if spw in listspws: # Science intents only band2spw[band].append(str(spw)) bandlist = [band for band in band2spw.keys()] # LOG.info("BAND LIST: " + ','.join(bandlist)) # plotter = finalcalsdisplay.finalcalsSummaryChart(context, result) # plots = plotter.plot() ms = os.path.basename(result.inputs['vis']) summary_plots[ms] = None # generate testdelay plots and JSON file plotter = finalcalsdisplay.finalDelaysPerAntennaChart(context, result) plots = plotter.plot() json_path = plotter.json_filename # write the html for each MS to disk renderer = VLASubPlotRenderer(context, result, plots, json_path, 'finalcals_plots.mako', 'finaldelays', bandlist) with renderer.get_file() as fileobj: fileobj.write(renderer.render()) finaldelay_subpages[ms] = renderer.filename # generate phase Gain plots and JSON file plotter = finalcalsdisplay.finalphaseGainPerAntennaChart(context, result) plots = plotter.plot() json_path = plotter.json_filename # write the html for each MS to disk renderer = VLASubPlotRenderer(context, result, plots, json_path, 'finalcals_plots.mako', 'phasegain', bandlist) with renderer.get_file() as fileobj: fileobj.write(renderer.render()) phasegain_subpages[ms] = renderer.filename # generate amp bandpass solution plots and JSON file plotter = finalcalsdisplay.finalbpSolAmpPerAntennaChart(context, result) plots = plotter.plot() json_path = plotter.json_filename # write the html for each MS to disk renderer = VLASubPlotRenderer(context, result, plots, json_path, 'finalcals_plots.mako', 'bpsolamp', bandlist) with renderer.get_file() as fileobj: fileobj.write(renderer.render()) bpsolamp_subpages[ms] = renderer.filename # generate phase bandpass solution plots and JSON file plotter = finalcalsdisplay.finalbpSolPhasePerAntennaChart(context, result) plots = plotter.plot() json_path = plotter.json_filename # write the html for each MS to disk renderer = VLASubPlotRenderer(context, result, plots, json_path, 'finalcals_plots.mako', 'bpsolphase', bandlist) with renderer.get_file() as fileobj: fileobj.write(renderer.render()) bpsolphase_subpages[ms] = renderer.filename # generate phase short bandpass solution plots and JSON file plotter = finalcalsdisplay.finalbpSolPhaseShortPerAntennaChart(context, result) plots = plotter.plot() json_path = plotter.json_filename # write the html for each MS to disk renderer = VLASubPlotRenderer(context, result, plots, json_path, 'finalcals_plots.mako', 'bpsolphaseshort', bandlist) with renderer.get_file() as fileobj: fileobj.write(renderer.render()) bpsolphaseshort_subpages[ms] = renderer.filename # generate final amp time cal solution plots and JSON file plotter = finalcalsdisplay.finalAmpTimeCalPerAntennaChart(context, result) plots = plotter.plot() json_path = plotter.json_filename # write the html for each MS to disk renderer = VLASubPlotRenderer(context, result, plots, json_path, 'finalcals_plots.mako', 'finalamptimecal', bandlist) with renderer.get_file() as fileobj: fileobj.write(renderer.render()) finalamptimecal_subpages[ms] = renderer.filename # generate final amp freq cal solution plots and JSON file plotter = finalcalsdisplay.finalAmpFreqCalPerAntennaChart(context, result) plots = plotter.plot() json_path = plotter.json_filename # write the html for each MS to disk renderer = VLASubPlotRenderer(context, result, plots, json_path, 'finalcals_plots.mako', 'finalampfreqcal', bandlist) with renderer.get_file() as fileobj: fileobj.write(renderer.render()) finalampfreqcal_subpages[ms] = renderer.filename # generate final phase gain cal solution plots and JSON file plotter = finalcalsdisplay.finalPhaseGainCalPerAntennaChart(context, result) plots = plotter.plot() json_path = plotter.json_filename # write the html for each MS to disk renderer = VLASubPlotRenderer(context, result, plots, json_path, 'finalcals_plots.mako', 'finalphasegaincal', bandlist) with renderer.get_file() as fileobj: fileobj.write(renderer.render()) finalphasegaincal_subpages[ms] = renderer.filename ctx.update({'summary_plots': summary_plots, 'finaldelay_subpages': finaldelay_subpages, 'phasegain_subpages': phasegain_subpages, 'bpsolamp_subpages': bpsolamp_subpages, 'bpsolphase_subpages': bpsolphase_subpages, 'bpsolphaseshort_subpages': bpsolphaseshort_subpages, 'finalamptimecal_subpages': finalamptimecal_subpages, 'finalampfreqcal_subpages': finalampfreqcal_subpages, 'finalphasegaincal_subpages': finalphasegaincal_subpages, 'dirname': weblog_dir}) return ctx
[docs]class T2_4MDetailsVLAApplycalRenderer(basetemplates.T2_4MDetailsDefaultRenderer): def __init__(self, uri='applycal.mako', description='Apply calibrations from context', always_rerender=False): super(T2_4MDetailsVLAApplycalRenderer, self).__init__( uri=uri, description=description, always_rerender=always_rerender)
[docs] def update_mako_context(self, ctx, context, result): weblog_dir = os.path.join(context.report_dir, 'stage%s' % result.stage_number) flag_totals = {} for r in result: try: flag_totals = utils.dict_merge(flag_totals, self.flags_for_result(r, context)) except: LOG.info("No flagging summaries.") calapps = {} for r in result: calapps = utils.dict_merge(calapps, self.calapps_for_result(r)) caltypes = {} for r in result: caltypes = utils.dict_merge(caltypes, self.caltypes_for_result(r)) filesizes = {} for r in result: vis = r.inputs['vis'] ms = context.observing_run.get_ms(vis) filesizes[os.path.basename(vis)] = ms._calc_filesize() # return all agents so we get ticks and crosses against each one agents = ['before', 'applycal'] ctx.update({'flags' : flag_totals, 'calapps' : calapps, 'caltypes' : caltypes, 'agents' : agents, 'dirname' : weblog_dir, 'filesizes': filesizes})
[docs] def create_science_plots(self, context, results, correlation): """ Create plots for the science targets, returning two dictionaries of vis:[Plots]. """ amp_vs_freq_summary_plots = collections.defaultdict(dict) phase_vs_freq_summary_plots = collections.defaultdict(dict) amp_vs_uv_summary_plots = collections.defaultdict(dict) max_uvs = collections.defaultdict(dict) for result in results: # Plot for 1 science field (either 1 science target or for a mosaic 1 # pointing). The science field that should be chosen is the one with # the brightest average amplitude over all spws vis = os.path.basename(result.inputs['vis']) ms = context.observing_run.get_ms(vis) # Ideally, the uvmax of the spectrum (plots 1 and 2) # would be set by the appearance of plot 3; that is, if there is # no obvious drop in amplitude with uvdist, then use all the data. # A simpler compromise would be to use a uvrange that captures the # inner half the data. baselines = sorted(ms.antenna_array.baselines, key=operator.attrgetter('length')) # take index as midpoint + 1 so we include the midpoint in the # constraint half_baselines = baselines[0:(len(baselines)//2)+1] uv_max = half_baselines[-1].length.to_units(measures.DistanceUnits.METRE) uv_range = '<%s' % uv_max LOG.debug('Setting UV range to %s for %s', uv_range, vis) max_uvs[vis] = half_baselines[-1].length brightest_fields = T2_4MDetailsVLAApplycalRenderer.get_brightest_fields(ms) # Limit to 30 sources via CAS-8737 # MAX_PLOTS = 30 ## Nplots = (len(brightest_fields.items())/30)+1 m = context.observing_run.measurement_sets[0] alltargetfields = m.get_fields(intent='TARGET') Nplots = (len(alltargetfields)/30)+1 targetfields = [field for field in alltargetfields[0:len(alltargetfields):Nplots]] plotfields = targetfields ''' for field in plotfields: plots = self.science_plots_for_result(context, result, applycal.VLAAmpVsFrequencyBasebandSummaryChart, [field.id], uv_range, correlation=correlation) amp_vs_freq_summary_plots[vis][field.id] = plots for field in plotfields: plots = self.science_plots_for_result(context, result, applycal.PhaseVsFrequencySummaryChart, [field.id], uv_range, correlation=correlation) phase_vs_freq_summary_plots[vis][field.id] = plots plots = self.science_plots_for_result(context, result, applycal.AmpVsUVBasebandSummaryChart, [field.id], correlation=correlation) amp_vs_uv_summary_plots[vis][field.id] = plots ''' ''' for source_id, brightest_field in brightest_fields.items()[0:len(brightest_fields.items()):Nplots]: plots = self.science_plots_for_result(context, result, applycal.VLAAmpVsFrequencyBasebandSummaryChart, [brightest_field.id], uv_range, correlation=correlation) amp_vs_freq_summary_plots[vis][source_id] = plots for source_id, brightest_field in brightest_fields.items()[0:len(brightest_fields.items()):Nplots]: plots = self.science_plots_for_result(context, result, applycal.PhaseVsFrequencySummaryChart, [brightest_field.id], uv_range, correlation=correlation) phase_vs_freq_summary_plots[vis][source_id] = plots plots = self.science_plots_for_result(context, result, applycal.AmpVsUVBasebandSummaryChart, [brightest_field.id], correlation=correlation) amp_vs_uv_summary_plots[vis][source_id] = plots ''' if pipeline.infrastructure.generate_detail_plots(result): scans = ms.get_scans(scan_intent='TARGET') fields = set() for scan in scans: fields.update([field.id for field in scan.fields]) # Science target detail plots. Note that summary plots go onto the # detail pages; we don't create plots per spw or antenna self.science_plots_for_result(context, result, applycal.VLAAmpVsFrequencyBasebandSummaryChart, fields, uv_range, ApplycalAmpVsFreqSciencePlotRenderer, correlation=correlation) self.science_plots_for_result(context, result, applycal.PhaseVsFrequencySummaryChart, fields, uv_range, ApplycalPhaseVsFreqSciencePlotRenderer, correlation=correlation) self.science_plots_for_result(context, result, applycal.AmpVsUVBasebandSummaryChart, fields, renderer_cls=ApplycalAmpVsUVSciencePlotRenderer, correlation=correlation) # sort plots by baseband so that the summary plots appear in baseband order ''' for vis, source_plots in amp_vs_freq_summary_plots.items(): self.sort_plots_by_baseband(source_plots) for vis, source_plots in phase_vs_freq_summary_plots.items(): self.sort_plots_by_baseband(source_plots) for vis, source_plots in amp_vs_uv_summary_plots.items(): self.sort_plots_by_baseband(source_plots) ''' return (amp_vs_freq_summary_plots, max_uvs)
[docs] def science_plots_for_result(self, context, result, plotter_cls, fields, uvrange=None, renderer_cls=None, correlation=''): # override field when plotting amp/phase vs frequency, as otherwise # the field is resolved to a list of all field IDs overrides = {'coloraxis': 'spw', 'correlation': correlation} if uvrange is not None: overrides['uvrange'] = uvrange m = context.observing_run.measurement_sets[0] plots = [] for field in fields: # override field when plotting amp/phase vs frequency, as otherwise # the field is resolved to a list of all field IDs overrides['field'] = field plotter = plotter_cls(context, result, ['TARGET'], **overrides) plots.extend(plotter.plot()) for plot in plots: plot.parameters['intent'] = ['TARGET'] if renderer_cls is not None: renderer = renderer_cls(context, result, plots, **overrides) with renderer.get_file() as fileobj: fileobj.write(renderer.render()) return plots
[docs] @staticmethod def get_brightest_fields(ms, intent='TARGET'): """ """ # get IDs for all science spectral windows spw_ids = set() for scan in ms.get_scans(scan_intent=intent): scan_spw_ids = {dd.spw.id for dd in scan.data_descriptions} spw_ids.update(scan_spw_ids) if intent == 'TARGET': science_ids = {spw.id for spw in ms.get_spectral_windows()} spw_ids = spw_ids.intersection(science_ids) result = collections.OrderedDict() by_source_id = lambda field: field.source.id fields_by_source_id = sorted(ms.get_fields(intent=intent), key=by_source_id) for source_id, source_fields in itertools.groupby(fields_by_source_id, by_source_id): fields = list(source_fields) # give the sole science target name if there's only one science target # in this ms. if len(fields) is 1: LOG.info('Only one %s target for Source #%s. Bypassing ' 'brightest target selection.', intent, source_id) result[source_id] = fields[0] continue field = fields[0] LOG.warning('Bypassing brightest field selection due to problem ' 'with visstat. Using Field #%s (%s) for Source #%s' '', field.id, field.name, source_id) result[source_id] = field continue # FIXME: code below here in remainder of for-loop is unreachable field_ids = {(f.id, f.name) for f in fields} # holds the mapping of field name to mean flux average_flux = {} # defines the parameters for the visstat job job_params = { 'vis': ms.name, 'axis': 'amp', 'datacolumn': 'corrected', 'spw': ','.join(map(str, spw_ids)), } # solve circular import problem by importing at run-time from pipeline.infrastructure import casa_tasks LOG.info('Calculating which %s field has the highest mean flux ' 'for Source #%s', intent, source_id) # run visstat for each scan selection for the target for field_id, field_name in field_ids: job_params['field'] = str(field_id) job = casa_tasks.visstat(**job_params) LOG.debug('Calculating statistics for %r (#%s)', field_name, field_id) result = job.execute(dry_run=False) average_flux[(field_id, field_name)] = float(result['CORRECTED']['mean']) LOG.debug('Mean flux for %s targets:', intent) for field_id, field_name, v in average_flux.items(): LOG.debug('\t%r (%s): %s', field_name, field_id, v) # find the ID of the field with the highest average flux sorted_by_flux = sorted(average_flux.items(), key=operator.itemgetter(1), reverse=True) (brightest_id, brightest_name), highest_flux = sorted_by_flux[0] LOG.info('%s field %r (%s) has highest mean flux (%s)', intent, brightest_name, brightest_id, highest_flux) result[source_id] = brightest_id return result
[docs] def sort_plots_by_baseband(self, d): for vis, plots in d.items(): plots = sorted(plots, key=lambda plot: plot.parameters['baseband']) d[vis] = plots
[docs] def create_plots(self, context, results, plotter_cls, intents, renderer_cls=None, **kwargs): """ Create plots and return a dictionary of vis:[Plots]. """ d = {} for result in results: plots = self.plots_for_result(context, result, plotter_cls, intents, renderer_cls, **kwargs) d = utils.dict_merge(d, plots) return d
[docs] def plots_for_result(self, context, result, plotter_cls, intents, renderer_cls=None, **kwargs): vis = os.path.basename(result.inputs['vis']) plotter = plotter_cls(context, result, intents, **kwargs) plots = plotter.plot() for plot in plots: plot.parameters['intent'] = intents d = collections.defaultdict(dict) d[vis] = plots if renderer_cls is not None: renderer = renderer_cls(context, result, plots, **kwargs) with renderer.get_file() as fileobj: fileobj.write(renderer.render()) return d
[docs] def calapps_for_result(self, result): calapps = collections.defaultdict(list) for calapp in result.applied: vis = os.path.basename(calapp.vis) calapps[vis].append(calapp) return calapps
[docs] def caltypes_for_result(self, result): type_map = { 'bandpass': 'Bandpass', 'gaincal': 'Gain', 'tsys': 'T<sub>sys</sub>', 'wvr': 'WVR', } d = {} for calapp in result.applied: for calfrom in calapp.calfrom: caltype = type_map.get(calfrom.caltype, calfrom.caltype) if calfrom.caltype == 'gaincal': # try heuristics to detect phase-only and amp-only # solutions caltype += self.get_gain_solution_type(calfrom.gaintable) d[calfrom.gaintable] = caltype return d
[docs] def get_gain_solution_type(self, gaintable): # solve circular import problem by importing at run-time from pipeline.infrastructure import casa_tasks # get stats on amp solution of gaintable calstat_job = casa_tasks.calstat(caltable=gaintable, axis='amp', datacolumn='CPARAM', useflags=True) calstat_result = calstat_job.execute(dry_run=False) stats = calstat_result['CPARAM'] # amp solutions of unity imply phase-only was requested tol = 1e-3 no_amp_soln = all([utils.approx_equal(stats['sum'], stats['npts'], tol), utils.approx_equal(stats['min'], 1, tol), utils.approx_equal(stats['max'], 1, tol)]) # same again for phase solution calstat_job = casa_tasks.calstat(caltable=gaintable, axis='phase', datacolumn='CPARAM', useflags=True) calstat_result = calstat_job.execute(dry_run=False) stats = calstat_result['CPARAM'] # phase solutions ~ 0 implies amp-only solution tol = 1e-5 no_phase_soln = all([utils.approx_equal(stats['sum'], 0, tol), utils.approx_equal(stats['min'], 0, tol), utils.approx_equal(stats['max'], 0, tol)]) if no_phase_soln and not no_amp_soln: return ' (amplitude only)' if no_amp_soln and not no_phase_soln: return ' (phase only)' return ''
[docs] def flags_for_result(self, result, context): ms = context.observing_run.get_ms(result.inputs['vis']) summaries = result.summaries by_intent = self.flags_by_intent(ms, summaries) by_spw = self.flags_by_science_spws(ms, summaries) return {ms.basename : utils.dict_merge(by_intent, by_spw)}
[docs] def flags_by_intent(self, ms, summaries): # create a dictionary of scans per observing intent, eg. 'PHASE':[1,2,7] intent_scans = {} for intent in ('BANDPASS', 'PHASE', 'AMPLITUDE', 'TARGET'): # convert IDs to strings as they're used as summary dictionary keys intent_scans[intent] = [str(s.id) for s in ms.scans if intent in s.intents] # while we're looping, get the total flagged by looking in all scans intent_scans['TOTAL'] = [str(s.id) for s in ms.scans] total = collections.defaultdict(dict) previous_summary = None for summary in summaries: for intent, scan_ids in intent_scans.items(): flagcount = 0 totalcount = 0 for i in scan_ids: # workaround for KeyError exception when summary # dictionary doesn't contain the scan if i not in summary['scan']: continue flagcount += int(summary['scan'][i]['flagged']) totalcount += int(summary['scan'][i]['total']) if previous_summary: flagcount -= int(previous_summary['scan'][i]['flagged']) ft = FlagTotal(flagcount, totalcount) total[summary['name']][intent] = ft previous_summary = summary return total
[docs] def flags_by_science_spws(self, ms, summaries): science_spws = ms.get_spectral_windows(science_windows_only=True) total = collections.defaultdict(dict) previous_summary = None for summary in summaries: flagcount = 0 totalcount = 0 for spw in science_spws: spw_id = str(spw.id) flagcount += int(summary['spw'][spw_id]['flagged']) totalcount += int(summary['spw'][spw_id]['total']) if previous_summary: flagcount -= int(previous_summary['spw'][spw_id]['flagged']) ft = FlagTotal(flagcount, totalcount) total[summary['name']]['SCIENCE SPWS'] = ft previous_summary = summary return total
[docs]class ApplycalAmpVsFreqPlotRenderer(basetemplates.JsonPlotRenderer): def __init__(self, context, result, plots, **overrides): vis = os.path.basename(result.inputs['vis']) title = 'Calibrated amplitude vs frequency for %s' % vis outfile = filenamer.sanitize('amp_vs_freq-%s.html' % vis) super(ApplycalAmpVsFreqPlotRenderer, self).__init__( 'generic_x_vs_y_field_spw_ant_detail_plots.mako', context, result, plots, title, outfile, **overrides)
[docs]class ApplycalPhaseVsFreqPlotRenderer(basetemplates.JsonPlotRenderer): def __init__(self, context, result, plots, **overrides): vis = os.path.basename(result.inputs['vis']) title = 'Calibrated phase vs frequency for %s' % vis outfile = filenamer.sanitize('phase_vs_freq-%s.html' % vis) super(ApplycalPhaseVsFreqPlotRenderer, self).__init__( 'generic_x_vs_y_field_spw_ant_detail_plots.mako', context, result, plots, title, outfile, **overrides)
[docs]class ApplycalAmpVsFreqSciencePlotRenderer(basetemplates.JsonPlotRenderer): def __init__(self, context, result, plots, **overrides): vis = os.path.basename(result.inputs['vis']) title = 'Calibrated amplitude vs frequency for %s' % vis outfile = filenamer.sanitize('science_amp_vs_freq-%s.html' % vis) super(ApplycalAmpVsFreqSciencePlotRenderer, self).__init__( 'generic_x_vs_y_field_baseband_detail_plots.mako', context, result, plots, title, outfile, **overrides)
[docs]class ApplycalPhaseVsFreqSciencePlotRenderer(basetemplates.JsonPlotRenderer): def __init__(self, context, result, plots, **overrides): vis = os.path.basename(result.inputs['vis']) title = 'Calibrated phase vs frequency for %s' % vis outfile = filenamer.sanitize('science_phase_vs_freq-%s.mako' % vis) super(ApplycalPhaseVsFreqSciencePlotRenderer, self).__init__( 'generic_x_vs_y_field_baseband_detail_plots.html', context, result, plots, title, outfile, **overrides)
[docs]class ApplycalAmpVsUVSciencePlotRenderer(basetemplates.JsonPlotRenderer): def __init__(self, context, result, plots, **overrides): vis = os.path.basename(result.inputs['vis']) title = 'Calibrated amplitude vs UV distance for %s' % vis outfile = filenamer.sanitize('science_amp_vs_uv-%s.html' % vis) super(ApplycalAmpVsUVSciencePlotRenderer, self).__init__( 'generic_x_vs_y_field_baseband_detail_plots.mako', context, result, plots, title, outfile, **overrides)
[docs]class ApplycalAmpVsUVPlotRenderer(basetemplates.JsonPlotRenderer): def __init__(self, context, result, plots, **overrides): vis = os.path.basename(result.inputs['vis']) title = 'Calibrated amplitude vs UV distance for %s' % vis outfile = filenamer.sanitize('amp_vs_uv-%s.html' % vis) super(ApplycalAmpVsUVPlotRenderer, self).__init__( 'generic_x_vs_y_spw_ant_plots.mako', context, result, plots, title, outfile, **overrides)
[docs]class ApplycalPhaseVsUVPlotRenderer(basetemplates.JsonPlotRenderer): def __init__(self, context, result, plots, **overrides): vis = os.path.basename(result.inputs['vis']) title = 'Calibrated phase vs UV distance for %s' % vis outfile = filenamer.sanitize('phase_vs_uv-%s.html' % vis) super(ApplycalPhaseVsUVPlotRenderer, self).__init__( 'generic_x_vs_y_spw_ant_plots.mako', context, result, plots, title, outfile, **overrides)
[docs]class ApplycalAmpVsTimePlotRenderer(basetemplates.JsonPlotRenderer): def __init__(self, context, result, plots, **overrides): vis = os.path.basename(result.inputs['vis']) title = 'Calibrated amplitude vs times for %s' % vis outfile = filenamer.sanitize('amp_vs_time-%s.html' % vis) super(ApplycalAmpVsTimePlotRenderer, self).__init__( 'generic_x_vs_y_field_spw_ant_detail_plots.mako', context, result, plots, title, outfile, **overrides)
[docs]class ApplycalPhaseVsTimePlotRenderer(basetemplates.JsonPlotRenderer): def __init__(self, context, result, plots, **overrides): vis = os.path.basename(result.inputs['vis']) title = 'Calibrated phase vs times for %s' % vis outfile = filenamer.sanitize('phase_vs_time-%s.html' % vis) super(ApplycalPhaseVsTimePlotRenderer, self).__init__( 'generic_x_vs_y_field_spw_ant_detail_plots.mako', context, result, plots, title, outfile, **overrides)