Movie

class ehtim.movie.Movie(frames, times, psize, ra, dec, rf=230000000000.0, polrep='stokes', pol_prim=None, pulse=<function trianglePulse2D>, source='SgrA', mjd=51544, bounds_error=True, interp='linear')

A polarimetric movie (in units of Jy/pixel).

pulse

The function convolved with the pixel values for continuous image

Type:

function

psize

The pixel dimension in radians

Type:

float

xdim

The number of pixels along the x dimension

Type:

int

ydim

The number of pixels along the y dimension

Type:

int

mjd

The integer MJD of the image

Type:

int

source

The astrophysical source name

Type:

str

ra

The source Right Ascension in fractional hours

Type:

float

dec

The source declination in fractional degrees

Type:

float

rf

The image frequency in Hz

Type:

float

polrep

polarization representation, either ‘stokes’ or ‘circ’

Type:

str

pol_prim

The default image: I,Q,U or V for Stokes, or RR,LL,LR,RL for Circular

Type:

str

interp

Interpolation method, for scipy.interpolate.interp1d ‘kind’ keyword (e.g. ‘linear’, ‘nearest’, ‘quadratic’, ‘cubic’, ‘previous’, ‘next’…)

Type:

str

bounds_error

if False, return nearest frame when outside [start_hr, stop_hr]

Type:

bool

times

The list of frame time stamps in hours

Type:

list

_movdict

The dictionary with the lists of frames

Type:

dict

add_pol_movie(movie, pol)

Add another movie polarization.

Parameters:

• movie (list) – list of 2D frames (possibly complex) in a Jy/pixel array

• pol (str) – The image type: ‘I’,’Q’,’U’,’V’ for stokes, ‘RR’,’LL’,’RL’,’LR’ for circ

add_qu(qmovie, umovie)

Add Stokes Q and U movies. self.polrep must be ‘stokes’

Parameters:

• qmovie (list) – list of 2D Stokes Q frames in Jy/pixel array

• umovie (list) – list of 2D Stokes U frames in Jy/pixel array

Returns:

add_v(vmovie)

Add Stokes V movie. self.polrep must be ‘stokes’

Parameters:

vmovie (list) – list of 2D Stokes Q frames in Jy/pixel array

Returns:

avg_frame()

Coherently Average the movie frames into a single image.

Returns:

averaged image of all frames

Return type:

(Image)

blur_circ(fwhm_x, fwhm_t, fwhm_x_pol=0)

Apply a Gaussian filter to a list of images.

Parameters:

• fwhm_x (float) – circular beam size for spatial blurring in radians

• fwhm_t (float) – temporal blurring in frames

• fwhm_x_pol (float) – circular beam size for Stokes Q,U,V spatial blurring in radians

Returns:

output image list

Return type:

(Image)

circ_polfrac_curve()

Return the (signed) total fractional circular polarized flux over time

Args:

Returns:

image fractional circular polarized flux per frame

Return type:

(numpy.ndarray)

copy()

Return a copy of the Movie object.

Args:

Returns:

copy of the Image.

Return type:

(Movie)

export_mp4(out='movie.mp4', fps=10, dpi=120, interp='gaussian', scale='lin', dynamic_range=1000.0, cfun='afmhot', nvec=20, pcut=0.01, plotp=False, gamma=0.5, frame_pad_factor=1, label_time=False, verbose=False)

Save the Movie to an mp4 file

fovx()

Return the movie fov in x direction in radians.

Args:

Returns:

movie fov in x direction (radian)

Return type:

(float)

fovy()

Returns the movie fov in y direction in radians.

Args:

Returns:

movie fov in y direction (radian)

Return type:

(float)

get_frame(n)

Return an Image of the nth frame

Parameters:

n (int) – the frame number

Returns:

the Image object of the nth frame

Return type:

(Image)

get_image(time)

Return an Image at time

Parameters:

time (float) – the time in hours

Returns:

the Image object at the given time

Return type:

(Image)

im_list()

Return a list of the movie frames

Args:

Returns:

list of Image objects

Return type:

(list)

property lightcurve

Return the total flux over time of the image in Jy.

Args:

Returns:

image total flux (Jy) over time

Return type:

(numpy.Array)

lin_polfrac_curve()

Return the total fractional linear polarized flux over time

Args:

Returns:

image fractional linear polarized flux per frame

Return type:

(numpy.ndarray)

movie_args()

“Copy arguments for making a new Movie into a list and dictonary

observe(array, tint, tadv, tstart, tstop, bw, repeat=False, mjd=None, timetype='UTC', polrep_obs=None, elevmin=10.0, elevmax=85.0, no_elevcut_space=False, ttype='nfft', fft_pad_factor=2, fix_theta_GMST=False, sgrscat=False, add_th_noise=True, jones=False, inv_jones=False, opacitycal=True, ampcal=True, phasecal=True, frcal=True, dcal=True, rlgaincal=True, stabilize_scan_phase=False, stabilize_scan_amp=False, neggains=False, tau=0.1, taup=0.1, gain_offset=0.1, gainp=0.1, dterm_offset=0.05, rlratio_std=0.0, rlphase_std=0.0, caltable_path=None, seed=False, sigmat=None, verbose=True)

Generate baselines from an array object and observe the movie.

Parameters:

• array (Array) – an array object containing sites with which to generate baselines

• tint (float) – the scan integration time in seconds

• tadv (float) – the uniform cadence between scans in seconds

• tstart (float) – the start time of the observation in hours

• tstop (float) – the end time of the observation in hours

• bw (float) – the observing bandwidth in Hz

• repeat (bool) – if True, repeat the movie to fill up the observation interval

• mjd (int) – the mjd of the observation, if set as different from the image mjd

• timetype (str) – how to interpret tstart and tstop; either ‘GMST’ or ‘UTC’

• polrep_obs (str) – ‘stokes’ or ‘circ’ sets the data polarimetric representation

• elevmin (float) – station minimum elevation in degrees

• elevmax (float) – station maximum elevation in degrees

• no_elevcut_space (bool) – if True, do not apply elevation cut to orbiters

• ttype (str) – “fast”, “nfft” or “dtft”

• fft_pad_factor (float) – zero pad the image to fft_pad_factor * image size in the FFT

• fix_theta_GMST (bool) – if True, stops earth rotation to sample fixed u,v

• sgrscat (bool) – if True, the visibilites will be blurred by the Sgr A* kernel

• add_th_noise (bool) – if True, baseline-dependent thermal noise is added

• jones (bool) – if True, uses Jones matrix to apply mis-calibration effects otherwise uses old formalism without D-terms

• inv_jones (bool) – if True, applies estimated inverse Jones matrix (not including random terms) to calibrate data

• opacitycal (bool) – if False, time-dependent gaussian errors are added to opacities

• ampcal (bool) – if False, time-dependent gaussian errors are added to station gains

• phasecal (bool) – if False, time-dependent station-based random phases are added

• frcal (bool) – if False, feed rotation angle terms are added to Jones matrix.

• dcal (bool) – if False, time-dependent gaussian errors added to Jones matrix D-terms.

• rlgaincal (bool) – if False, time-dependent gains are not equal for R and L pol

• stabilize_scan_phase (bool) – if True, random phase errors are constant over scans

• stabilize_scan_amp (bool) – if True, random amplitude errors are constant over scans

• neggains (bool) – if True, force the applied gains to be <1

• tau (float) – the base opacity at all sites, or a dict giving one opacity per site

• taup (float) – the fractional std. dev. of the random error on the opacities

• gainp (float) – the fractional std. dev. of the random error on the gains or a dict giving one std. dev. per site

• gain_offset (float) – the base gain offset at all sites, or a dict giving one gain offset per site

• dterm_offset (float) – the base std. dev. of random additive error at all sites, or a dict giving one std. dev. per site

• rlratio_std (float) – the fractional std. dev. of the R/L gain offset or a dict giving one std. dev. per site

• rlphase_std (float) – std. dev. of R/L phase offset, or a dict giving one std. dev. per site a negative value samples from uniform

• caltable_path (string) – If not None, path and prefix for saving the applied caltable

• seed (int) – seeds the random component of the noise terms. DO NOT set to 0!

• sigmat (float) – temporal std for a Gaussian Process used to generate gain noise. if sigmat=None then an iid gain noise is applied.

• verbose (bool) – print updates and warnings

Returns:

an observation object

Return type:

(Obsdata)

observe_same(obs_in, repeat=False, ttype='nfft', fft_pad_factor=2, sgrscat=False, add_th_noise=True, jones=False, inv_jones=False, opacitycal=True, ampcal=True, phasecal=True, frcal=True, dcal=True, rlgaincal=True, stabilize_scan_phase=False, stabilize_scan_amp=False, neggains=False, taup=0.1, gain_offset=0.1, gainp=0.1, dterm_offset=0.05, rlratio_std=0.0, rlphase_std=0.0, caltable_path=None, seed=False, sigmat=None, verbose=True)

Observe the image on the same baselines as an existing observation object and add noise.

Parameters:

• obs_in (Obsdata) – existing observation with baselines where the FT will be sampled

• repeat (bool) – if True, repeat the movie to fill up the observation interval

• ttype (str) – “fast” or “nfft” or “direct”

• fft_pad_factor (float) – zero pad the image to fft_pad_factor * image size in FFT

• sgrscat (bool) – if True, the visibilites will be blurred by the Sgr A* kernel

• add_th_noise (bool) – if True, baseline-dependent thermal noise is added

• jones (bool) – if True, uses Jones matrix to apply mis-calibration effects

• inv_jones (bool) – if True, applies estimated inverse Jones matrix (not including random terms) to a priori calibrate data

• opacitycal (bool) – if False, time-dependent gaussian errors are added to opacities

• ampcal (bool) – if False, time-dependent gaussian errors are added to station gains

• phasecal (bool) – if False, time-dependent station-based random phases are added

• frcal (bool) – if False, feed rotation angle terms are added to Jones matrices.

• dcal (bool) – if False, time-dependent gaussian errors added to D-terms.

• rlgaincal (bool) – if False, time-dependent gains are not equal for R and L pol

• stabilize_scan_phase (bool) – if True, random phase errors are constant over scans

• stabilize_scan_amp (bool) – if True, random amplitude errors are constant over scans

• neggains (bool) – if True, force the applied gains to be <1

• taup (float) – the fractional std. dev. of the random error on the opacities

• gainp (float) – the fractional std. dev. of the random error on the gains or a dict giving one std. dev. per site

• gain_offset (float) – the base gain offset at all sites, or a dict giving one gain offset per site

• dterm_offset (float) – the base std. dev. of random additive error at all sites, or a dict giving one std. dev. per site

• rlratio_std (float) – the fractional std. dev. of the R/L gain offset or a dict giving one std. dev. per site

• rlphase_std (float) – std. dev. of R/L phase offset, or a dict giving one std. dev. per site a negative value samples from uniform

• caltable_path (string) – If not None, path and prefix for saving the applied caltable

• seed (int) – seeds the random component of the noise terms. DO NOT set to 0!

• sigmat (float) – temporal std for a Gaussian Process used to generate gain noise. if sigmat=None then an iid gain noise is applied.

• verbose – print updates and warnings

observe_same_nonoise(obs, repeat=False, sgrscat=False, ttype='nfft', fft_pad_factor=2, zero_empty_pol=True, verbose=True)

Observe the movie on the same baselines as an existing observation without adding noise.

Parameters:

• obs (Obsdata) – existing observation with baselines where the FT will be sampled

• repeat (bool) – if True, repeat the movie to fill up the observation interval

• sgrscat (bool) – if True, the visibilites are blurred by the Sgr A* scattering kernel

• ttype (str) – if “fast”, use FFT to produce visibilities. Else “direct” for DTFT

• fft_pad_factor (float) – zero pad the image to fft_pad_factor * image size in FFT

• zero_empty_pol (bool) – if True, returns zero vec if the polarization doesn’t exist. Otherwise return None

• verbose (bool) – Boolean value controls output prints.

Returns:

an observation object

Return type:

(Obsdata)

observe_vex(vex, source, synchronize_start=True, t_int=0.0, polrep_obs=None, ttype='nfft', fft_pad_factor=2, fix_theta_GMST=False, sgrscat=False, add_th_noise=True, jones=False, inv_jones=False, opacitycal=True, ampcal=True, phasecal=True, frcal=True, dcal=True, rlgaincal=True, stabilize_scan_phase=False, stabilize_scan_amp=False, neggains=False, tau=0.1, taup=0.1, gain_offset=0.1, gainp=0.1, dterm_offset=0.05, caltable_path=None, seed=False, sigmat=None, verbose=True)

Generate baselines from a vex file and observe the movie.

Parameters:

• vex (Vex) – an vex object containing sites and scan information

• source (str) – the source to observe

• synchronize_start (bool) – if True, the start of the movie is defined as the start of the observations

• t_int (float) – if not zero, overrides the vex scan lengths

• polrep_obs (str) – ‘stokes’ or ‘circ’ sets the data polarimetric representation

• ttype (str) – “fast” or “nfft” or “dtft”

• fft_pad_factor (float) – zero pad the image to fft_pad_factor * image size in FFT

• fix_theta_GMST (bool) – if True, stops earth rotation to sample fixed u,v

• sgrscat (bool) – if True, the visibilites will be blurred by the Sgr A* kernel

• add_th_noise (bool) – if True, baseline-dependent thermal noise is added

• jones (bool) – if True, uses Jones matrix to apply mis-calibration effects otherwise uses old formalism without D-terms

• inv_jones (bool) – if True, applies estimated inverse Jones matrix (not including random terms) to calibrate data

• opacitycal (bool) – if False, time-dependent gaussian errors are added to opacities

• ampcal (bool) – if False, time-dependent gaussian errors are added to station gains

• phasecal (bool) – if False, time-dependent station-based random phases are added

• frcal (bool) – if False, feed rotation angle terms are added to Jones matrix.

• dcal (bool) – if False, time-dependent gaussian errors added to Jones matrix D-terms.

• rlgaincal (bool) – if False, time-dependent gains are not equal for R and L pol

• stabilize_scan_phase (bool) – if True, random phase errors are constant over scans

• stabilize_scan_amp (bool) – if True, random amplitude errors are constant over scans

• neggains (bool) – if True, force the applied gains to be <1

• tau (float) – the base opacity at all sites, or a dict giving one opacity per site

• taup (float) – the fractional std. dev. of the random error on the opacities

• gain_offset (float) – the base gain offset at all sites, or a dict giving one gain offset per site

• gainp (float) – the fractional std. dev. of the random error on the gains

• dterm_offset (float) – the base dterm offset at all sites, or a dict giving one dterm offset per site

• caltable_path (string) – If not None, path and prefix for saving the applied caltable

• seed (int) – seeds the random component of the noise terms. DO NOT set to 0!

• sigmat (float) – temporal std for a Gaussian Process used to generate gain noise. if sigmat=None then an iid gain noise is applied.

• verbose (bool) – print updates and warnings

Returns:

an observation object

Return type:

(Obsdata)

offset_time(t_offset)

Offset the movie in time by t_offset

Parameters:

t_offset (float) – offset time in hours

Returns:

orth_chi()

Rotate the EVPA 90 degrees

Args:

Returns:

movie with rotated EVPA

Return type:

(Image)

reset_interp(interp=None, bounds_error=None)

Reset the movie interpolation function to change the interp. type or change the frames

Parameters:

• interp (str) – Interpolation method, input to scipy.interpolate.interp1d kind keyword

• bounds_error (bool) – if False, return nearest frame outside [start_hr, stop_hr]

save_fits(fname)

Save the Movie data to individual fits files with filenames basename + 00001, etc.

Parameters:

fname (str) – basename of output files

Returns:

save_hdf5(fname)

Save the Movie data to a single hdf5 file.

Parameters:

fname (str) – output file name

Returns:

save_txt(fname)

Save the Movie data to individual text files with filenames basename + 00001, etc.

Parameters:

fname (str) – basename of output files

Returns:

switch_polrep(polrep_out='stokes', pol_prim_out=None)

Return a new movie with the polarization representation changed

Parameters:

• polrep_out (str) – the polrep of the output data

• pol_prim_out (str) – The default movie: I,Q,U or V for Stokes, RR,LL,LR,RL for Circular

Returns:

new movie object with potentially different polrep

Return type:

(Movie)

ehtim.movie.export_multipanel_mp4(input_list, out='movie.mp4', start_hr=None, stop_hr=None, nframes=100, fov=None, npix=None, nrows=1, fps=10, dpi=120, verbose=False, titles=None, panel_size=4.0, common_scale=False, scale='linear', label_type='scale', has_cbar=False, **kwargs)

Export a movie comparing multiple movies in a grid.

Parameters:

• input_list (list) – The list of input Movies or Images

• out (string) – The output filename

• start_hr (float) – The start time in hours. If None, defaults to first start time

• end_hr (float) – The end time in hours. If None, defaults to last start time

• nframes (int) – The number of frames in the output movie

• fov (float) – If specified, use this field of view for all panels

• npix (int) – If specified, use this linear pixel dimension for all panels

• nrows (int) – Number of rows in movie

• fps (int) – Frames per second

• titles (list) – List of panel titles for input_list

• panel_size (float) – Size of individual panels (inches)

ehtim.movie.load_fits(basename, nframes, framedur=-1, pulse=<function trianglePulse2D>, polrep='stokes', pol_prim=None, zero_pol=True, interp='linear', bounds_error=True)

Read in a movie from fits files and create a Movie object.

Parameters:

• basename (str) – The base name of individual movie frames. Files should have names basename + 00001, etc.

• nframes (int) – The total number of frames

• framedur (float) – The frame duration in seconds. if famedur==-1, frame duration taken from file headers

• pulse (function) – The function convolved with the pixel values for continuous image

• polrep (str) – polarization representation, either ‘stokes’ or ‘circ’

• pol_prim (str) – The default image: I,Q,U or V for Stokes, RR,LL,LR,RL for Circular

• zero_pol (bool) – If True, loads any missing polarizations as zeros

• interp (str) – Interpolation method, input to scipy.interpolate.interp1d kind keyword

• bounds_error (bool) – if False, return nearest frame outside interval [start_hr, stop_hr]

Returns:

a Movie object

Return type:

Movie

ehtim.movie.load_hdf5(file_name, pulse=<function trianglePulse2D>, interp='linear', bounds_error=True)

Read in a movie from an hdf5 file and create a Movie object.

Parameters:

• file_name (str) – The name of the hdf5 file.

• pulse (function) – The function convolved with the pixel values for continuous image

• interp (str) – Interpolation method, input to scipy.interpolate.interp1d kind keyword

• bounds_error (bool) – if False, return nearest frame outside interval [start_hr, stop_hr]

Returns:

a Movie object

Return type:

Movie

ehtim.movie.load_txt(basename, nframes, framedur=-1, pulse=<function trianglePulse2D>, polrep='stokes', pol_prim=None, zero_pol=True, interp='linear', bounds_error=True)

Read in a movie from text files and create a Movie object.

Parameters:

• basename (str) – The base name of individual movie frames. Files should have names basename + 00001, etc.

• nframes (int) – The total number of frames

• framedur (float) – The frame duration in seconds if famedur==-1, frame duration taken from file headers

• pulse (function) – The function convolved with the pixel values for continuous image

• polrep (str) – polarization representation, either ‘stokes’ or ‘circ’

• pol_prim (str) – The default image: I,Q,U or V for Stokes, RR,LL,LR,RL for Circular

• zero_pol (bool) – If True, loads any missing polarizations as zeros

• interp (str) – Interpolation method, input to scipy.interpolate.interp1d kind keyword

• bounds_error (bool) – if False, return nearest frame outside interval [start_hr, stop_hr]

Returns:

a Movie object

Return type:

Movie

ehtim.movie.merge_im_list(imlist, framedur=- 1, interp='linear', bounds_error=True)

Merge a list of image objects into a movie object.

Parameters:

• imlist (list) – list of Image objects

• framedur (float) – duration of a movie frame in seconds use to override times in the individual movies

• interp (str) – Interpolation method, input to scipy.interpolate.interp1d kind keyword

• bounds_error – if False, return nearest frame outside interval [start_hr, stop_hr]