diff --git a/.gitignore b/.gitignore
index d394e39..114a112 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,9 +1,16 @@
-ifcs2018.aux
-ifcs2018.bbl
-ifcs2018.blg
-ifcs2018.log
-ifcs2018.out
-ifcs2018.pdf
+ifcs2018_abstract.aux
+ifcs2018_abstract.bbl
+ifcs2018_abstract.blg
+ifcs2018_abstract.log
+ifcs2018_abstract.out
+ifcs2018_abstract.pdf
+
+ifcs2018_processing.aux
+ifcs2018_processing.bbl
+ifcs2018_processing.blg
+ifcs2018_processing.log
+ifcs2018_processing.out
+ifcs2018_processing.pdf
 
 ifcs2018_poster.aux
 ifcs2018_poster.log
diff --git a/Makefile b/Makefile
index de50397..3293835 100644
--- a/Makefile
+++ b/Makefile
@@ -4,7 +4,7 @@ TEX = pdflatex -shell-escape -interaction=nonstopmode -file-line-error
 BIB = bibtex
 TARGET = ifcs2018
 
-all: $(TARGET) $(TARGET)_poster
+all: $(TARGET)_abstract $(TARGET)_poster $(TARGET)_processing
 
 view: $(TARGET)
 	evince $(TARGET).pdf
@@ -12,16 +12,22 @@ view: $(TARGET)
 view_poster: $(TARGET)_poster
 	evince $(TARGET)_poster.pdf
 
-$(TARGET): $(TARGET).tex references.bib
-	$(TEX) $(TARGET).tex
-	$(BIB) $(TARGET)
-	$(TEX) $(TARGET).tex
-	$(TEX) $(TARGET).tex
+$(TARGET)_abstract: $(TARGET)_abstract.tex references.bib
+	$(TEX) $@.tex
+	$(BIB) $@
+	$(TEX) $@.tex
+	$(TEX) $@.tex
 
 $(TARGET)_poster:
 	$(TEX) $@.tex
 	$(TEX) $@.tex
 
+$(TARGET)_processing: $(TARGET)_processing.tex references.bib
+	$(TEX) $@.tex
+	$(BIB) $@
+	$(TEX) $@.tex
+	$(TEX) $@.tex
+
 clean:
 	rm -f $(TARGET).aux $(TARGET).log $(TARGET).out $(TARGET).bbl $(TARGET).blg
 	rm -f $(TARGET)_poster.aux $(TARGET)_poster.log $(TARGET)_poster.out
diff --git a/ifcs2018.tex b/ifcs2018_abstract.tex
similarity index 100%
rename from ifcs2018.tex
rename to ifcs2018_abstract.tex
diff --git a/ifcs2018_processing.tex b/ifcs2018_processing.tex
new file mode 100644
index 0000000..535bfea
--- /dev/null
+++ b/ifcs2018_processing.tex
@@ -0,0 +1,209 @@
+\documentclass[a4paper,conference]{IEEEtran/IEEEtran}
+\usepackage{graphicx,color,hyperref}
+\usepackage{amsfonts}
+\usepackage{url}
+\usepackage[normalem]{ulem}
+\graphicspath{{/home/jmfriedt/gpr/170324_avalanche/}{/home/jmfriedt/gpr/1705_homemade/}}
+% correct bad hyphenation here
+\hyphenation{op-tical net-works semi-conduc-tor}
+\textheight=26cm
+\setlength{\footskip}{30pt}
+\pagenumbering{gobble}
+\begin{document}
+\title{Filter optimization for real time digital processing of radiofrequency signals: application
+to oscillator metrology}
+
+\author{\IEEEauthorblockN{A. Hugeat\IEEEauthorrefmark{1}\IEEEauthorrefmark{2}, J. Bernard\IEEEauthorrefmark{2},
+G. Goavec-M\'erou\IEEEauthorrefmark{1},
+P.-Y. Bourgeois\IEEEauthorrefmark{1}, J.-M Friedt\IEEEauthorrefmark{1}}
+\IEEEauthorblockA{\IEEEauthorrefmark{1}FEMTO-ST, Time \& Frequency department, Besan\c con, France }
+\IEEEauthorblockA{\IEEEauthorrefmark{2}FEMTO-ST, Computer Science department DISC, Besan\c con, France \\
+Email: \{pyb2,jmfriedt\}@femto-st.fr}
+}
+\maketitle
+\thispagestyle{plain}
+\pagestyle{plain}
+
+\begin{abstract}
+Software Defined Radio (SDR) provides stability, flexibility and reconfigurability to
+radiofrequency signal processing. Applied to oscillator characterization in the context
+of ultrastable clocks, stringent filtering requirements are defined by spurious signal or
+noise rejection needs. Since real time radiofrequency processing must be performed in a
+Field Programmable Array to meet timing constraints, we investigate optimization strategies
+to design filters meeting rejection characteristics while limiting the hardware resources
+required and keeping timing constraints within the targeted measurement bandwidths.
+\end{abstract}
+
+\begin{IEEEkeywords}
+Software Defined Radio, Mixed-Integer Linear Programming, Finite Impulse Response filter
+\end{IEEEkeywords}
+
+\section{Digital signal processing of ultrastable clock signals}
+
+Analog oscillator phase noise characteristics are classically performed by downconverting
+the radiofrequency signal using a saturated mixer to bring the radiofrequency signal to baseband,
+followed by a Fourier analysis of the beat signal to analyze phase fluctuations close to carrier. In
+a fully digital approach, the radiofrequency signal is digitized and numerically downconverted by
+multiplying the samples with a local numerically controlled oscillator (Fig. \ref{schema}) \cite{rsi}.
+
+\begin{figure}[h!tb]
+\begin{center}
+\includegraphics[width=.8\linewidth]{images/schema}
+\end{center}
+\caption{Fully digital oscillator phase noise characterization: the Device Under Test
+(DUT) signal is sampled by the radiofrequency grade Analog to Digital Converter (ADC) and
+downconverted by mixing with a Numerically Controlled Oscillator (NCO). Unwanted signals
+and noise aliases are rejected by a Low Pass Filter (LPF) implemented as a cascade of Finite
+Impulse Response (FIR) filters. The signal is then decimated before a Fourier analysis displays
+the spectral characteristics of the phase fluctuations.}
+\label{schema}
+\end{figure}
+
+As with the analog mixer,
+the non-linear behavior of the downconverter introduces noise or spurious signal aliasing as
+well as the generation of the frequency sum signal in addition to the frequency difference.
+These unwanted spectral characteristics must be rejected before decimating the data stream
+for the phase noise spectral characterization. The characteristics introduced between the downconverter
+and the decimation processing blocks are core characteristics of an oscillator characterization
+system, and must reject out-of-band signals below the targeted phase noise -- typically in the
+sub -170~dBc/Hz for ultrastable oscillator we aim at characterizing. The filter blocks will
+use most resources of the Field Programmable Gate Array (FPGA) used to process the radiofrequency
+datastream: optimizing the performance of the filter while reducing the needed resources is
+hence tackled in a systematic approach using optimization techniques. Most significantly, we
+tackle the issue by attempting to cascade multiple Finite Impulse Response (FIR) filters with
+tunable number of coefficients and tunable number of bits representing the coefficients and the
+data being processed.
+
+\section{Finite impulse response filter}
+
+We select FIR filter for their unconditional stability and ease of design. A FIR filter is defined
+by a set of weights $b_k$ applied to the inputs $x_k$ through a convolution to generate the outputs $y_k$
+$$y_n=\sum_{k=0}^N b_k x_{n-k}$$
+
+As opposed to an implementation on a general purpose processor in which word size is defined by the 
+processor architecture, implementing such a filter on an FPGA offer more degrees of freedom since
+not only the coefficient values and number of taps must be defined, but also the number of bits defining
+the coefficients and the sample size.
+
+\section{Filter optimization}
+
+A basic approach for implementing the FIR filter is to compute the transfer function of
+a monolithic filter: this single filter defines all coefficients with the same resolution
+(number of bits) and processes data represented with their own resolution. Meeting the
+filter shape requires a large number of coefficients, limited by resources of the FPGA since
+this filter must process data stream at the radiofrequency sampling rate after the mixer.
+
+An optimization problem \cite{leung2004handbook} aims at improving one or many
+performance criteria within a constrained resource environment. Amongst the tools
+developed to meet this aim, Mixed-Integer Linear Programming (MILP) provides the framework to
+provide a formal definition of the stated problem and search for an optimal use of available
+resources \cite{yu2007design, kodek1980design}.
+
+The degrees of freedom when addressing the problem of replacing the single monolithic
+FIR with a cascade of optimized filters are the number of coefficients $N_i$ of each filter $i$,
+the number of bits $c_i$ representing the coefficients and the number of bits $d_i$ representing
+the data fed to the filter. Because each FIR in the chain is fed the output of the previous stage,
+the optimization of the complete processing chain within a constrained resource environment is not
+trivial. The resource occupation of a FIR filter is considered as $c_i+d_i+\log_2(N_i)$ which is
+the number of bits needed in a worst case condition to represent the output of the FIR.
+
+
+\begin{figure}[h!tb]
+\includegraphics[width=\linewidth]{images/noise-rejection.pdf}
+\caption{Rejection as a function of number of coefficients and number of bits}
+\label{noise-rejection}
+\end{figure}
+
+The objective function maximizes the noise rejection while keeping resource occupation below
+a user-defined threshold. The MILP solver is allowed to choose the number of successive
+filters, within an upper bound. The last problem is to model the noise rejection. Since filter
+noise rejection capability is not modeled with linear equation, a look-up-table is generated
+for multiple filter configurations in which the $c_i$, $d_i$ and $N_i$ parameters are varied: for each
+one of these conditions, the low-pass filter rejection defined as the mean power between
+half the Nyquist frequency and the Nyquist frequency is stored as computed by the frequency response
+of the digital filter (Fig. \ref{noise-rejection}).
+
+Linear program formalism for solving the problem is well documented: an objective function is
+defined which is linearly dependent on the parameters to be optimized. Constraints are expressed
+as linear equation and solved using one of the available solvers, in our case GLPK\cite{glpk}.
+
+The MILP solver provides a solution to the problem by selecting a series of small FIR with
+increasing number of bits representing data and coefficients as well as an increasing number
+of coefficients, instead of a single monolithic filter. Fig. \ref{compare-fir} exhibits the
+performance comparison between one solution and a monolithic FIR when selecting a cutoff
+frequency of half the Nyquist frequency: a series of 5 FIR and a series of 10 FIR with the
+same space usage are provided as selected by the MILP solver. The FIR cascade provides improved
+rejection than the monolithic FIR at the expense of a lower cutoff frequency which remains to
+be tuned or compensated for.
+
+\begin{figure}[h!tb]
+% \includegraphics[width=\linewidth]{images/compare-fir.pdf}
+\includegraphics[width=\linewidth]{images/fir-mono-vs-fir-series-200dB.pdf}
+\caption{Comparison of the rejection capability between a series of FIR and a monolithic FIR
+with a cutoff frequency set at half the Nyquist frequency.}
+\label{compare-fir}
+\end{figure}
+
+The resource occupation when synthesizing such FIR on a Xilinx FPGA is summarized as Tab. \ref{t1}.
+
+\begin{table}[h!tb]
+\caption{Resource occupation on a Xilinx Zynq-7000 series FPGA when synthesizing the FIR cascade
+identified as optimal by the MILP solver within a finite resource criterion. The last line refers
+to available resources on a Zynq-7010 as found on the Redpitaya board. The rejection is the mean
+value from 0.6 to 1 Nyquist frequency.}
+\begin{center}
+\begin{tabular}{|c|cccc|}\hline
+FIR & BlockRAM & LookUpTables & DSP & rejection (dB)\\\hline\hline
+1 (monolithic) & 1 & 4064 & 40 & -72 \\
+5 & 5 & 12332 & 0 & -217 \\
+10 & 10 & 12717 & 0 & -251 \\\hline\hline
+Zynq 7010 & 60 & 17600 & 80 &  \\\hline
+\end{tabular}
+\end{center}
+%\vspace{-0.7cm}
+\label{t1}
+\end{table}
+
+\section{Filter coefficient selection}
+
+The coefficients of a single monolithic filter are computed as the impulse response
+of the filter transfer function, and practically approximated by a multitude of methods
+including least square optimization (Matlab's {\tt firls} function), Hamming or Kaiser windowing
+(Matlab's {\tt fir1} function). Cascading filters opens a new optimization opportunity by
+selecting various coefficient sets depending on the number of coefficients. Fig. \ref{2}
+illustrates that for a number of coefficients ranging from 8 to 47, {\tt fir1} provides a better
+rejection than {\tt firls}: since the linear solver increases the number of coefficients along
+the processing chain, the type of selected filter also changes depending on the number of coefficients
+and evolves along the processing chain.
+
+\begin{figure}[h!tb]
+\includegraphics[width=\linewidth]{images/fir1-vs-firls}
+\caption{Evolution of the rejection capability of least-square optimized filters and Hamming
+FIR filters as a function of the number of coefficients, for floating point numbers and 8-bit
+encoded integers.}
+\label{2}
+\end{figure}
+
+\section{Conclusion}
+
+We address the optimization problem of designing a low-pass filter chain in a Field Programmable Gate
+Array for improved noise rejection within constrained resource occupation, as needed for
+real time processing of radiofrequency signal when characterizing spectral phase noise
+characteristics of stable oscillators. The flexibility of the digital approach makes the result
+best suited for closing the loop and using the measurement output in a feedback loop for
+controlling clocks, e.g. in a quartz-stabilized high performance clock whose long term behavior
+is controlled by non-piezoelectric resonator (sapphire resonator, microwave or optical
+atomic transition).
+
+\section*{Acknowledgement}
+
+This work is supported by the ANR Programme d'Investissement d'Avenir in
+progress at the Time and Frequency Departments of the FEMTO-ST Institute
+(Oscillator IMP, First-TF and Refimeve+), and by R\'egion de Franche-Comt\'e.
+The authors would like to thank E. Rubiola, F. Vernotte, G. Cabodevila for support and
+fruitful discussions.
+
+\bibliographystyle{IEEEtran}
+\bibliography{references}
+\end{document}
+