diff --git a/gstlal-calibration/bin/gstlal_compute_strain b/gstlal-calibration/bin/gstlal_compute_strain
index 3e415ef57a9291e5ffd6cbbda3ce7ad9e34ee634..185a8ae22244fe1a1110aa6935b2bc7b48fa719c 100644
--- a/gstlal-calibration/bin/gstlal_compute_strain
+++ b/gstlal-calibration/bin/gstlal_compute_strain
@@ -416,7 +416,7 @@ if options.factors_from_filters_file:
 	EP9_real = float(filters["EP9_real"])
 	EP9_imag = float(filters["EP9_imag"])
 
-# Load all of the kappa dewhitening and correction facrtors
+# Load all of the kappa dewhitening and correction factors
 darm_act_line_freq = float(filters["ka_pcal_line_freq"])
 pcal_corr_at_darm_act_freq_real = float(filters["ka_pcal_corr_re"])
 pcal_corr_at_darm_act_freq_imag = float(filters["ka_pcal_corr_im"])
diff --git a/gstlal-calibration/gst/lal/gstlal_smoothkappas.c b/gstlal-calibration/gst/lal/gstlal_smoothkappas.c
index 7bd654024ccefb1a6321a825b812c4090eab6672..8620bcfbb91966edfe4b4a1d7930008ad695bf80 100644
--- a/gstlal-calibration/gst/lal/gstlal_smoothkappas.c
+++ b/gstlal-calibration/gst/lal/gstlal_smoothkappas.c
@@ -141,7 +141,7 @@ G_DEFINE_TYPE_WITH_CODE(
  */
 
 
-static double get_new_median(double new_element, double *fifo_array, double *current_median, gint array_size, int *index_re, int *index_im, gboolean array_is_imaginary) {
+static void get_new_median(double new_element, double *fifo_array, double *current_median, gint array_size, int *index_re, int *index_im, gboolean array_is_imaginary) {
 	if(array_is_imaginary) {
 		fifo_array[*index_im] = new_element;
 		if(*index_im < array_size - 1)
@@ -205,29 +205,54 @@ static double get_new_median(double new_element, double *fifo_array, double *cur
 	else if((array_size % 2) && (number_less > array_size / 2))
 		*current_median = first_less;
 
-	return *current_median;
+	return;
+}
+
+
+static double get_average(double new_element, double *fifo_array, gint array_size, int *index_re, int *index_im, gboolean array_is_imaginary) {
+	if(array_is_imaginary) {
+		fifo_array[*index_im] = new_element;
+		if(*index_im < array_size - 1)
+			(*index_im)++;
+		else
+			*index_im -= (array_size - 1);
+	} else {
+		fifo_array[*index_re] = new_element;
+		if(*index_re < array_size - 1)
+			(*index_re)++;
+		else
+			*index_re -= (array_size - 1);
+	}
+	double sum = 0;
+	int i;
+	for(i = 0; i < array_size; i++) {
+		sum += fifo_array[i];
+	}
+	return sum / array_size;
 }
 
 
 #define DEFINE_SMOOTH_BUFFER(DTYPE) \
-static GstFlowReturn smooth_buffer_ ## DTYPE(const DTYPE *src, DTYPE *dst, gint buffer_size, double *fifo_array, double default_kappa, double *current_median, double maximum_offset, gint array_size, int *index_re, int *index_im, gboolean gap, gboolean default_to_median, gboolean track_bad_kappa) { \
+static GstFlowReturn smooth_buffer_ ## DTYPE(const DTYPE *src, DTYPE *dst, gint buffer_size, double *fifo_array, double *avg_array, double default_kappa, double *current_median, double maximum_offset, gint array_size, gint avg_array_size, int *index_re, int *index_im, int *avg_index_re, int *avg_index_im, gboolean gap, gboolean default_to_median, gboolean track_bad_kappa) { \
 	gint i; \
-	DTYPE new_element; \
+	double new_element; \
 	for(i = 0; i < buffer_size; i++) { \
 		if(gap || (double) *src > default_kappa + maximum_offset || (double) *src < default_kappa - maximum_offset || isnan(*src) || isinf(*src)) { \
 			if(default_to_median) \
 				new_element = *current_median; \
 			else \
 				new_element = default_kappa; \
-		} else { \
-			new_element = *src; \
+		} else \
+			new_element = (double) *src; \
+ \
+		get_new_median(new_element, fifo_array, current_median, array_size, index_re, index_im, FALSE); \
+		*dst = (DTYPE) get_average(*current_median, avg_array, avg_array_size, avg_index_re, avg_index_im, FALSE); \
+		if (track_bad_kappa) { \
+                        if (*dst == default_kappa) \
+                                *dst = 0.0; \
+                        else \
+                                *dst = 1.0; \
 		} \
-		*dst = (DTYPE) get_new_median((double) new_element, fifo_array, current_median, array_size, index_re, index_im, FALSE); \
-		if (track_bad_kappa) \
-			if (*dst == default_kappa) \
-				*dst = 0.0; \
-			else \
-				*dst = 1.0; \
 		src++; \
 		dst++; \
 	} \
@@ -236,7 +261,7 @@ static GstFlowReturn smooth_buffer_ ## DTYPE(const DTYPE *src, DTYPE *dst, gint
 
 
 #define DEFINE_SMOOTH_COMPLEX_BUFFER(DTYPE) \
-static GstFlowReturn smooth_complex_buffer_ ## DTYPE(const DTYPE complex *src, DTYPE complex *dst, gint buffer_size, double *fifo_array_re, double *fifo_array_im, double default_kappa_re, double default_kappa_im, double *current_median_re, double *current_median_im, double maximum_offset_re, double maximum_offset_im, gint array_size, int *index_re, int *index_im, gboolean gap, gboolean default_to_median, gboolean track_bad_kappa) { \
+static GstFlowReturn smooth_complex_buffer_ ## DTYPE(const DTYPE complex *src, DTYPE complex *dst, gint buffer_size, double *fifo_array_re, double *fifo_array_im, double *avg_array_re, double *avg_array_im, double default_kappa_re, double default_kappa_im, double *current_median_re, double *current_median_im, double maximum_offset_re, double maximum_offset_im, gint array_size, gint avg_array_size, int *index_re, int *index_im, int *avg_index_re, int *avg_index_im, gboolean gap, gboolean default_to_median, gboolean track_bad_kappa) { \
 	gint i; \
 	double new_element_re, new_element_im; \
 	for(i = 0; i < buffer_size; i++) { \
@@ -244,30 +269,32 @@ static GstFlowReturn smooth_complex_buffer_ ## DTYPE(const DTYPE complex *src, D
 		if(gap || creal(doublesrc) > default_kappa_re + maximum_offset_re || creal(doublesrc) < default_kappa_re - maximum_offset_re || isnan(creal(doublesrc)) || isinf(creal(doublesrc))) { \
 			if(default_to_median) \
 				new_element_re = *current_median_re; \
-			else if (track_bad_kappa) \
-				new_element_re = 0.0; \
 			else \
 				new_element_re = default_kappa_re; \
 		} else { \
-			if (track_bad_kappa) \
-				new_element_re = 1.0; \
-			else \
-				new_element_re = creal(doublesrc); \
+			new_element_re = creal(doublesrc); \
 		} \
 		if(gap || cimag(doublesrc) > default_kappa_im + maximum_offset_im || cimag(doublesrc) < default_kappa_im - maximum_offset_im || isnan(cimag(doublesrc)) || isinf(cimag(doublesrc))) { \
 			if(default_to_median) \
 				new_element_im = *current_median_im; \
-			else if (track_bad_kappa) \
-				new_element_im = 0.0; \
 			else \
 				new_element_im = default_kappa_im; \
 		} else { \
-			if (track_bad_kappa) \
-				new_element_im = 1.0; \
+			new_element_im = cimag(doublesrc); \
+		} \
+		get_new_median(new_element_re, fifo_array_re, current_median_re, array_size, index_re, index_im, FALSE); \
+		get_new_median(new_element_im, fifo_array_im, current_median_im, array_size, index_re, index_im, TRUE); \
+		*dst = (DTYPE) get_average(*current_median_re, avg_array_re, avg_array_size, avg_index_re, avg_index_im, FALSE) + I * (DTYPE) get_average(*current_median_im, avg_array_im, avg_array_size, avg_index_re, avg_index_im, TRUE); \
+		if(track_bad_kappa) { \
+			if((creal((double complex) *dst) == default_kappa_re) && (cimag((double complex) *dst) == default_kappa_im)) \
+				*dst = 0.0; \
+			else if(cimag((double complex) *dst) == default_kappa_im) \
+				*dst = 1.0; \
+			else if(creal((double complex) *dst) == default_kappa_re) \
+				*dst = I; \
 			else \
-				new_element_im = cimag(doublesrc); \
+				*dst = 1.0 + I; \
 		} \
-		*dst = (DTYPE) get_new_median(new_element_re, fifo_array_re, current_median_re, array_size, index_re, index_im, FALSE) + I * (DTYPE) get_new_median(new_element_im, fifo_array_im, current_median_im, array_size, index_re, index_im, TRUE); \
 		src++; \
 		dst++; \
 	} \
@@ -373,22 +400,25 @@ static gboolean start(GstBaseTransform *trans)
 
 	element->fifo_array_re = g_malloc(sizeof(double) * element->array_size);
 	element->fifo_array_im = g_malloc(sizeof(double) * element->array_size);
+	element->avg_array_re = g_malloc(sizeof(double) * element->avg_array_size);
+	element->avg_array_im = g_malloc(sizeof(double) * element->avg_array_size);
+
 	int i;
-	if(element->track_bad_kappa) {
-		for(i = 0; i < element->array_size; i++, (element->fifo_array_re)++, (element->fifo_array_im)++) {
-			*(element->fifo_array_re) = 0;
-			*(element->fifo_array_im) = 0;
-		}
-	} else {
-		for(i = 0; i < element->array_size; i++, (element->fifo_array_re)++, (element->fifo_array_im)++) { 
-			*(element->fifo_array_re) = element->default_kappa_re;
-			*(element->fifo_array_im) = element->default_kappa_im;
-		}
+	for(i = 0; i < element->array_size; i++, (element->fifo_array_re)++, (element->fifo_array_im)++) { 
+		*(element->fifo_array_re) = element->default_kappa_re;
+		*(element->fifo_array_im) = element->default_kappa_im;
+	}
+	for(i = 0; i < element->avg_array_size; i++, (element->avg_array_re)++, (element->avg_array_im)++) {
+		*(element->avg_array_re) = element->default_kappa_re;
+		*(element->avg_array_im) = element->default_kappa_im;
 	}
 
 	(element->fifo_array_re) -= element->array_size;
 	(element->fifo_array_im) -= element->array_size;
 
+	(element->avg_array_re) -= element->avg_array_size;
+	(element->avg_array_im) -= element->avg_array_size;
+
 	return TRUE;
 }
 
@@ -418,16 +448,16 @@ static GstFlowReturn transform(GstBaseTransform *trans, GstBuffer *inbuf, GstBuf
 
 	if(element->data_type == F32) {
 		gint buffer_size = outmap.size / element->unit_size;
-		result = smooth_buffer_float((const float *) inmap.data, (float *) outmap.data, buffer_size, element->fifo_array_re, element->default_kappa_re, &element->current_median_re, element->maximum_offset_re, element->array_size, &element->index_re, &element->index_im, gap, element->default_to_median, element->track_bad_kappa);
+		result = smooth_buffer_float((const float *) inmap.data, (float *) outmap.data, buffer_size, element->fifo_array_re, element->avg_array_re, element->default_kappa_re, &element->current_median_re, element->maximum_offset_re, element->array_size, element->avg_array_size, &element->index_re, &element->index_im, &element->avg_index_re, &element->avg_index_im, gap, element->default_to_median, element->track_bad_kappa);
 	} else if(element->data_type == F64) {
 		gint buffer_size = outmap.size / element->unit_size;
-		result = smooth_buffer_double((const double *) inmap.data, (double *) outmap.data, buffer_size, element->fifo_array_re, element->default_kappa_re, &element->current_median_re, element->maximum_offset_re, element->array_size, &element->index_re, &element->index_im, gap, element->default_to_median, element->track_bad_kappa);
+		result = smooth_buffer_double((const double *) inmap.data, (double *) outmap.data, buffer_size, element->fifo_array_re, element->avg_array_re, element->default_kappa_re, &element->current_median_re, element->maximum_offset_re, element->array_size, element->avg_array_size, &element->index_re, &element->index_im, &element->avg_index_re, &element->avg_index_im, gap, element->default_to_median, element->track_bad_kappa);
 	} else if(element->data_type == Z64) {
 		gint buffer_size = outmap.size / element->unit_size;
-		result = smooth_complex_buffer_float((const float complex *) inmap.data, (float complex *) outmap.data, buffer_size, element->fifo_array_re, element->fifo_array_im, element->default_kappa_re, element->default_kappa_im, &element->current_median_re, &element->current_median_im, element->maximum_offset_re, element->maximum_offset_im, element->array_size, &element->index_re, &element->index_im, gap, element->default_to_median, element->track_bad_kappa);
+		result = smooth_complex_buffer_float((const float complex *) inmap.data, (float complex *) outmap.data, buffer_size, element->fifo_array_re, element->fifo_array_im, element->avg_array_re, element->avg_array_im, element->default_kappa_re, element->default_kappa_im, &element->current_median_re, &element->current_median_im, element->maximum_offset_re, element->maximum_offset_im, element->array_size, element->avg_array_size, &element->index_re, &element->index_im, &element->avg_index_re, &element->avg_index_im, gap, element->default_to_median, element->track_bad_kappa);
 	} else if(element->data_type == Z128) { 
 		gint buffer_size = outmap.size / element->unit_size;
-		result = smooth_complex_buffer_double((const double complex *) inmap.data, (double complex *) outmap.data, buffer_size, element->fifo_array_re, element->fifo_array_im, element->default_kappa_re, element->default_kappa_im, &element->current_median_re, &element->current_median_im, element->maximum_offset_re, element->maximum_offset_im, element->array_size, &element->index_re, &element->index_im, gap, element->default_to_median, element->track_bad_kappa);
+		result = smooth_complex_buffer_double((const double complex *) inmap.data, (double complex *) outmap.data, buffer_size, element->fifo_array_re, element->fifo_array_im, element->avg_array_re, element->avg_array_im, element->default_kappa_re, element->default_kappa_im, &element->current_median_re, &element->current_median_im, element->maximum_offset_re, element->maximum_offset_im, element->array_size, element->avg_array_size, &element->index_re, &element->index_im, &element->avg_index_re, &element->avg_index_im, gap, element->default_to_median, element->track_bad_kappa);
 	} else {
 		g_assert_not_reached();
 	}
@@ -462,6 +492,7 @@ static GstFlowReturn transform(GstBaseTransform *trans, GstBuffer *inbuf, GstBuf
 
 enum property {
 	ARG_ARRAY_SIZE = 1,
+	ARG_AVG_ARRAY_SIZE,
 	ARG_DEFAULT_KAPPA_RE,
 	ARG_DEFAULT_KAPPA_IM,
 	ARG_MAXIMUM_OFFSET_RE,
@@ -481,6 +512,9 @@ static void set_property(GObject *object, enum property prop_id, const GValue *v
 	case ARG_ARRAY_SIZE:
 		element->array_size = g_value_get_int(value);
 		break;
+	case ARG_AVG_ARRAY_SIZE:
+		element->avg_array_size = g_value_get_int(value);
+		break;
 	case ARG_DEFAULT_KAPPA_RE:
 		element->default_kappa_re = g_value_get_double(value);
 		break;
@@ -518,6 +552,9 @@ static void get_property(GObject *object, enum property prop_id, GValue *value,
 	case ARG_ARRAY_SIZE:
 		g_value_set_int(value, element->array_size);
 		break;
+	case ARG_AVG_ARRAY_SIZE:
+		g_value_set_int(value, element->avg_array_size);
+		break;
 	case ARG_DEFAULT_KAPPA_RE:
 		g_value_set_double(value, element->default_kappa_re);
 		break;
@@ -557,6 +594,10 @@ static void finalize(GObject *object)
 	element->fifo_array_re = NULL;
 	g_free(element->fifo_array_im);
 	element->fifo_array_im = NULL;
+	g_free(element->avg_array_re);
+	element->avg_array_re = NULL;
+	g_free(element->avg_array_im);
+	element->avg_array_im = NULL;
 	G_OBJECT_CLASS(gstlal_smoothkappas_parent_class)->finalize(object);
 }
 
@@ -603,6 +644,18 @@ static void gstlal_smoothkappas_class_init(GSTLALSmoothKappasClass *klass)
 			G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT
 		)
 	);
+	g_object_class_install_property(
+		gobject_class,
+		ARG_AVG_ARRAY_SIZE,
+		g_param_spec_int(
+			"avg-array-size",
+			"Average array size",
+			"Size of the array of values from which the average is calculated\n\t\t\t"
+			"from the median values. By default, no average is taken.",
+			G_MININT, G_MAXINT, 1,
+			G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT
+		)
+	);
 	g_object_class_install_property(
 		gobject_class,
 		ARG_DEFAULT_KAPPA_RE,
@@ -694,10 +747,15 @@ static void gstlal_smoothkappas_init(GSTLALSmoothKappas *element)
 {
 	element->unit_size = 0;
 	element->array_size = 0;
+	element->avg_array_size = 0;
 	element->fifo_array_re = NULL;
 	element->fifo_array_im = NULL;
+	element->avg_array_re = NULL;
+	element->avg_array_im = NULL;
 	element->index_re = 0;
 	element->index_im = 0;
+	element->avg_index_re = 0;
+	element->avg_index_im = 0;
 	gst_base_transform_set_qos_enabled(GST_BASE_TRANSFORM(element), TRUE);
 	gst_base_transform_set_gap_aware(GST_BASE_TRANSFORM(element), TRUE);
 }
diff --git a/gstlal-calibration/gst/lal/gstlal_smoothkappas.h b/gstlal-calibration/gst/lal/gstlal_smoothkappas.h
index 63046ae5bd3a89ac5c637e05de21ea7319340612..8041daf715143bd8945e5c11d24f64e645723754 100644
--- a/gstlal-calibration/gst/lal/gstlal_smoothkappas.h
+++ b/gstlal-calibration/gst/lal/gstlal_smoothkappas.h
@@ -65,8 +65,12 @@ struct _GSTLALSmoothKappas {
 	double current_median_im;
 	double *fifo_array_re;
 	double *fifo_array_im;
+	double *avg_array_re;
+	double *avg_array_im;
 	int index_re;
 	int index_im;
+	int avg_index_re;
+	int avg_index_im;
 	enum gstlal_smoothkappas_data_type {
 		F32 = 0,
 		F64,
@@ -76,6 +80,7 @@ struct _GSTLALSmoothKappas {
 
 	/* properties */
 	int array_size;
+	int avg_array_size;
 	double default_kappa_re;
 	double default_kappa_im;
 	double maximum_offset_re;
diff --git a/gstlal-calibration/python/calibration_parts.py b/gstlal-calibration/python/calibration_parts.py
index fafa062f2ae62a9b23ae8294049396b50af580a5..efd13bd4f73356bc0a771c2ac71a0b3f1aded893 100644
--- a/gstlal-calibration/python/calibration_parts.py
+++ b/gstlal-calibration/python/calibration_parts.py
@@ -18,7 +18,6 @@
 
 from gstlal import pipeparts
 import numpy
-import random
 
 import gi
 gi.require_version('Gst', '1.0')
@@ -137,18 +136,15 @@ def list_srcs(pipeline, *args):
 def smooth_kappas_no_coherence(pipeline, head, var, expected, N, Nav):
 	# Find median of calibration factors array with size N and smooth out medians with an average over Nav samples
 	# Use the maximum_offset_re property to determine whether input kappas are good or not
-	head = pipeparts.mkgeneric(pipeline, head, "lal_smoothkappas", maximum_offset_re = var, default_kappa_re = expected, array_size = N)
-	head = pipeparts.mkfirbank(pipeline, head, fir_matrix = [numpy.ones(Nav)/Nav])
+	head = pipeparts.mkgeneric(pipeline, head, "lal_smoothkappas", maximum_offset_re = var, default_kappa_re = expected, array_size = N, avg_array_size = Nav)
 	head = mkaudiorate(pipeline, head)
 	return head
 
 def smooth_complex_kappas_no_coherence(pipeline, head, real_var, imag_var, real_expected, imag_expected, N, Nav):
 	# Find median of complex calibration factors array with size N, split into real and imaginary parts, and smooth out medians with an average over Nav samples
 	# Use the maximum_offset_re and maximum_offset_im properties to determine whether input kappas are good or not
-	head = pipeparts.mkgeneric(pipeline, head, "lal_smoothkappas", maximum_offset_re = real_var, maximum_offset_im = imag_var, default_kappa_re = real_expected, default_kappa_im = imag_expected, array_size = N)
+	head = pipeparts.mkgeneric(pipeline, head, "lal_smoothkappas", maximum_offset_re = real_var, maximum_offset_im = imag_var, default_kappa_re = real_expected, default_kappa_im = imag_expected, array_size = N, avg_array_size = Nav)
 	re, im = split_into_real(pipeline, head)
-	re = pipeparts.mkfirbank(pipeline, re, fir_matrix = [numpy.ones(Nav)/Nav])
-	im = pipeparts.mkfirbank(pipeline, im, fir_matrix = [numpy.ones(Nav)/Nav])
 	re = mkaudiorate(pipeline, re)
 	im = mkaudiorate(pipeline, im)
 	return re, im
@@ -156,8 +152,7 @@ def smooth_complex_kappas_no_coherence(pipeline, head, real_var, imag_var, real_
 def smooth_kappas(pipeline, head, expected, N, Nav):
 	# Find median of calibration factors array with size N and smooth out medians with an average over Nav samples
 	# Assume input was previously gated with coherence uncertainty to determine if input kappas are good or not
-	head = pipeparts.mkgeneric(pipeline, head, "lal_smoothkappas", default_kappa_re = expected, array_size = N)
-	head = pipeparts.mkfirbank(pipeline, head, fir_matrix = [numpy.ones(Nav)/Nav])
+	head = pipeparts.mkgeneric(pipeline, head, "lal_smoothkappas", default_kappa_re = expected, array_size = N, avg_array_size = Nav)
 	head = mkaudiorate(pipeline, head)
 	return head
 
@@ -167,11 +162,9 @@ def smooth_complex_kappas(pipeline, kappas, statevector, coherence, real_expecte
 
 	statevector = pipeparts.mktee(pipeline, statevector)
 	to_kappa_or_not_to_kappa = mkadder(pipeline, list_srcs(pipeline, statevector, coherence))
-        gapped_kappas = pipeparts.mkgate(pipeline, kappas, control = to_kappa_or_not_to_kappa, threshold = 2)
-	smooth_kappas = pipeparts.mkgeneric(pipeline, gapped_kappas, "lal_smoothkappas", default_kappa_re = real_expected, default_kappa_im = imag_expected, array_size = N)
+	gapped_kappas = pipeparts.mkgate(pipeline, kappas, control = to_kappa_or_not_to_kappa, threshold = 2)
+	smooth_kappas = pipeparts.mkgeneric(pipeline, gapped_kappas, "lal_smoothkappas", default_kappa_re = real_expected, default_kappa_im = imag_expected, array_size = N, avg_array_size = Nav)
 	re, im = split_into_real(pipeline, smooth_kappas)
-	re = pipeparts.mkfirbank(pipeline, re, fir_matrix = [numpy.ones(Nav)/Nav])
-	im = pipeparts.mkfirbank(pipeline, im, fir_matrix = [numpy.ones(Nav)/Nav])
 	re = mkaudiorate(pipeline, re)
 	im = mkaudiorate(pipeline, im)
 	re = pipeparts.mkgate(pipeline, re, control = statevector, threshold=1)
@@ -203,11 +196,11 @@ def track_bad_complex_kappas(pipeline, kappas, statevector, coherence, real_expe
 	# Produce output of 1's or 0's that correspond to median not corrupted (1) or corrupted (0) by defaulting to default kappa for majority of input samples
 	# Real and imaginary parts are done separately (outputs of lal_smoothkappas can be 1+i, 1, i, or 0)
 
-        to_kappa_or_not_to_kappa = mkadder(pipeline, list_srcs(pipeline, statevector, coherence))
-        gapped_kappas = pipeparts.mkgate(pipeline, kappas, control = to_kappa_or_not_to_kappa, threshold = 2)
-        track_kappas = pipeparts.mkgeneric(pipeline, gapped_kappas, "lal_smoothkappas", default_kappa_re = real_expected, default_kappa_im = imag_expected, array_size = N, track_bad_kappa = True)
-        re, im = split_into_real(pipeline, track_kappas)
-        return re, im
+	to_kappa_or_not_to_kappa = mkadder(pipeline, list_srcs(pipeline, statevector, coherence))
+	gapped_kappas = pipeparts.mkgate(pipeline, kappas, control = to_kappa_or_not_to_kappa, threshold = 2)
+	track_kappas = pipeparts.mkgeneric(pipeline, gapped_kappas, "lal_smoothkappas", default_kappa_re = real_expected, default_kappa_im = imag_expected, array_size = N, track_bad_kappa = True)
+	re, im = split_into_real(pipeline, track_kappas)
+	return re, im
 
 def smooth_kappas_no_coherence_test(pipeline, head, var, expected, N, Nav):
 	# Find median of calibration factors array with size N and smooth out medians with an average over Nav samples
diff --git a/gstlal-calibration/tests/lal_smoothkappas_test.py b/gstlal-calibration/tests/lal_smoothkappas_test.py
index 842b304bcc502f1fffd54704b136e18ab18d4690..bfb2b7d37e2e9924c41e447d6c3385d2d36c19fe 100755
--- a/gstlal-calibration/tests/lal_smoothkappas_test.py
+++ b/gstlal-calibration/tests/lal_smoothkappas_test.py
@@ -56,12 +56,14 @@ def lal_smoothkappas_01(pipeline, name):
 	# build pipeline
 	#
 
-	src = test_common.test_src(pipeline, channels = 2, buffer_length = buffer_length, rate = rate, width = width, test_duration = test_duration, wave = wave, freq = freq, volume = volume)
-	head = pipeparts.mktogglecomplex(pipeline, src)
+	head = test_common.test_src(pipeline, channels = 2, buffer_length = buffer_length, rate = rate, width = width, test_duration = test_duration, wave = wave, freq = freq, volume = volume)
+	head = pipeparts.mktogglecomplex(pipeline, head)
 	head = pipeparts.mktee(pipeline, head)
 	pipeparts.mknxydumpsink(pipeline, pipeparts.mkqueue(pipeline, head), "%s_in.dump" % name)
-	head = pipeparts.mkgeneric(pipeline, head, "lal_smoothkappas", array_size = 3, maximum_offset_re = 1, maximum_offset_im = 1, default_kappa_im = 0, default_kappa_re = 0, default_to_median = True)
-	pipeparts.mknxydumpsink(pipeline, pipeparts.mkqueue(pipeline, head), "%s_out.dump" % name)
+	median = pipeparts.mkgeneric(pipeline, head, "lal_smoothkappas", array_size = 3, maximum_offset_re = 0.5, maximum_offset_im = 0.5, default_kappa_im = 0.5, default_kappa_re = 0.5, track_bad_kappa = True, default_to_median = False)
+	median_avg = pipeparts.mkgeneric(pipeline, head, "lal_smoothkappas", array_size = 3, avg_array_size = 2,  maximum_offset_re = 0.5, maximum_offset_im = 0.5, default_kappa_im = 0.5, default_kappa_re = 0.5, track_bad_kappa = True, default_to_median = False)
+	pipeparts.mknxydumpsink(pipeline, pipeparts.mkqueue(pipeline, median), "%s_median.dump" % name)
+	pipeparts.mknxydumpsink(pipeline, pipeparts.mkqueue(pipeline, median_avg), "%s_median_avg.dump" % name)
 
 	#
 	# done
@@ -174,7 +176,7 @@ def lal_smoothkappas_04(pipeline, name):
 #
 
 
-#test_common.build_and_run(lal_smoothkappas_01, "lal_smoothkappas_01")
+test_common.build_and_run(lal_smoothkappas_01, "lal_smoothkappas_01")
 #test_common.build_and_run(lal_smoothkappas_02, "lal_smoothkappas_02")
-test_common.build_and_run(lal_smoothkappas_03, "lal_smoothkappas_03")
+#test_common.build_and_run(lal_smoothkappas_03, "lal_smoothkappas_03")
 #test_common.build_and_run(lal_smoothkappas_04, "lal_smoothkappas_04")