diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..4ddc47c
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+*.pyc
+.ipynb_checkpoints
+example_trace_dat*
+/dist/
+/build/
+/bart_py.egg-info/
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..792b7bf
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,26 @@
+language: python
+python:
+  - "2.7"
+before_install:
+  - sudo apt-get update -qq
+  - sudo apt-get install -qq libfreetype6-dev
+  - sudo apt-get install -qq libpng12-dev
+  - wget http://ftp.us.debian.org/debian/pool/main/t/trace-cmd/trace-cmd_2.4.0-1_amd64.deb
+  - sudo dpkg -i trace-cmd_2.4.0-1_amd64.deb
+install:
+  - pip install matplotlib
+  - pip install Cython --install-option="--no-cython-compile"
+  - pip install pandas
+  - pip install ipython[all]
+  - pip install --upgrade trappy
+script: nosetests
+virtualenv:
+  system_site_packages: true
+notifications:
+  email:
+    recipients:
+      - javi.merino@arm.com
+    on_success: never
+    on_failure: always
+cache:
+  - pip
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..51e7c77
--- /dev/null
+++ b/README.md
@@ -0,0 +1,119 @@
+BART [![Build Status](https://travis-ci.org/ARM-software/bart.svg?branch=master)](https://travis-ci.org/ARM-software/bart) [![Version](https://img.shields.io/pypi/v/bart-py.svg)](https://pypi.python.org/pypi/bart-py)
+====
+
+The Behavioural Analysis and Regression Toolkit is based on
+[TRAPpy](https://github.com/ARM-software/trappy). The primary goal is to assert
+behaviours using the FTrace output from the kernel.
+
+## Target Audience
+
+The framework is designed to cater to a wide range of audience. Aiding
+developers as well as automating the testing of "difficult to test" behaviours.
+
+#### Kernel Developers
+
+Making sure that the code that you are writing is doing the right thing.
+
+#### Performance Engineers
+
+Plotting/Asserting performance behaviours between different revisions of the
+kernel.
+
+#### Quality Assurance/Release Engineers
+
+Verifying behaviours when different components/patches are integrated.
+
+# Installation
+
+The following instructions are for Ubuntu 14.04 LTS but they should
+also work with Debian jessie.  Older versions of Ubuntu or Debian
+(e.g. Ubuntu 12.04 or Debian wheezy) will likely require to install
+more packages from pip as the ones present in Ubuntu 12.04 or Debian
+wheezy will probably be too old.
+
+## Required dependencies
+
+#### Install additional tools required for some tests and functionalities
+
+    $ sudo apt install trace-cmd kernelshark
+
+#### Install the Python package manager
+
+    $ sudo apt install python-pip python-dev
+
+#### Install required python packages
+
+    $ sudo apt install libfreetype6-dev libpng12-dev python-nose
+    $ sudo pip install numpy matplotlib pandas ipython[all]
+    $ sudo pip install --upgrade trappy
+
+`ipython[all]` will install [IPython
+Notebook](http://ipython.org/notebook.html), a web based interactive
+python programming interface.  It is required if you plan to use interactive
+plotting in BART.
+
+#### Install BART
+
+    $ sudo pip install --upgrade bart-py
+
+# For developers
+
+Instead of installing TRAPpy and BART using `pip` you should clone the repositories:
+
+    $ git clone git@github.com:ARM-software/bart.git
+    $ git clone git@github.com:ARM-software/trappy.git
+
+Add the directories to your PYTHONPATH
+
+    $ export PYTHONPATH=$BASE_DIR/bart:$BASE_DIR/trappy:$PYTHONPATH
+
+
+# Trace Analysis Language
+
+BART also provides a generic Trace Analysis Language, which allows the user to
+construct complex relation statements on trace data and assert their expected
+behaviours. The usage of the Analyzer module can be seen for the thermal
+behaviours
+[here](https://github.com/ARM-software/bart/blob/master/docs/notebooks/thermal/Thermal.ipynb)
+
+# Scheduler Assertions
+
+Enables assertion and the calculation of the following parameters:
+
+#### Runtime
+
+The total time that the task spent on a CPU executing.
+
+#### Switch
+
+Assert that a task switched between CPUs/Clusters in a given window of time.
+
+#### Duty Cycle
+
+The ratio of the execution time to the total time.
+
+#### Period
+
+The average difference between two switch-in or two switch-out events of a
+task.
+
+#### First CPU
+
+The first CPU that a task ran on.
+
+#### Residency
+
+Calculate and assert the total residency of a task on a CPU or cluster.
+
+#### Examples
+
+The Scheduler assertions also use TRAPpy's EventPlot to provide a `kernelshark`
+like timeline for the tasks under consideration. (in IPython notebooks).
+
+A notebook explaining the usage of the framework for asserting the deadline
+scheduler behaviours can be seen
+[here](https://rawgit.com/sinkap/0abbcc4918eb228b8887/raw/a1b4d6e0079f4ea0368d595d335bc340616501ff/SchedDeadline.html).
+
+# API reference
+
+The API reference can be found in https://pythonhosted.org/bart-py
diff --git a/bart/__init__.py b/bart/__init__.py
new file mode 100644
index 0000000..886dbc8
--- /dev/null
+++ b/bart/__init__.py
@@ -0,0 +1,21 @@
+#    Copyright 2015-2016 ARM Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""Initialization for bart"""
+
+import bart.sched
+import bart.common
+import bart.thermal
+from bart.version import __version__
diff --git a/bart/common/Analyzer.py b/bart/common/Analyzer.py
new file mode 100644
index 0000000..7bb55c9
--- /dev/null
+++ b/bart/common/Analyzer.py
@@ -0,0 +1,82 @@
+#    Copyright 2015-2016 ARM Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""Allow the user to assert various conditions
+based on the grammar defined in trappy.stats.grammar. The class is
+also intended to have aggregator based functionality. This is not
+implemented yet.
+"""
+
+from trappy.stats.grammar import Parser
+import warnings
+import numpy as np
+import pandas as pd
+
+# pylint: disable=invalid-name
+
+
+class Analyzer(object):
+
+    """
+    :param data: TRAPpy FTrace Object
+    :type data: :mod:`trappy.ftrace.FTrace`
+
+    :param config: A dictionary of variables, classes
+        and functions that can be used in the statements
+    :type config: dict
+    """
+
+    def __init__(self, data, config, **kwargs):
+        self._parser = Parser(data, config, **kwargs)
+
+    def assertStatement(self, statement, select=None):
+        """Solve the statement for a boolean result
+
+        :param statement: A string representing a valid
+            :mod:`trappy.stats.grammar` statement
+        :type statement: str
+
+        :param select: If the result represents a boolean
+            mask and the data was derived from a TRAPpy event
+            with a pivot value. The :code:`select` can be
+            used to select a particular pivot value
+        :type select: :mod:`pandas.DataFrame` column
+        """
+
+        result = self.getStatement(statement, select=select)
+
+        if isinstance(result, pd.DataFrame):
+            result = result.all().all()
+        elif not(isinstance(result, bool) or isinstance(result, np.bool_)): # pylint: disable=no-member
+            warnings.warn("solution of {} is not boolean".format(statement))
+
+        return result
+
+    def getStatement(self, statement, reference=False, select=None):
+        """Evaluate the statement"""
+
+        result = self._parser.solve(statement)
+
+        # pylint: disable=no-member
+        if np.isscalar(result):
+            return result
+        # pylint: enable=no-member
+
+        if select is not None and len(result):
+            result = result[select]
+            if reference:
+                result = self._parser.ref(result)
+
+        return result
diff --git a/bart/common/Utils.py b/bart/common/Utils.py
new file mode 100644
index 0000000..034cf74
--- /dev/null
+++ b/bart/common/Utils.py
@@ -0,0 +1,287 @@
+#    Copyright 2015-2016 ARM Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""Utility functions for sheye"""
+
+import trappy
+import numpy as np
+
+# pylint fails to recognize numpy members.
+# pylint: disable=no-member
+
+def listify(to_select):
+    """Utitlity function to handle both single and
+    list inputs
+    """
+
+    if not isinstance(to_select, list):
+        to_select = [to_select]
+
+    return to_select
+
+def init_ftrace(trace):
+    """Initialize the FTrace Object
+
+    :param trace: Path for the trace file
+        or a trace object
+    :type trace: str, :mod:`trappy.ftrace.FTrace`
+    """
+
+    if isinstance(trace, basestring):
+        return trappy.FTrace(trace)
+
+    elif isinstance(trace, trappy.BareTrace):
+        return trace
+
+    raise ValueError("Invalid trace Object")
+
+def select_window(series, window):
+    """Helper Function to select a portion of
+    pandas time series
+
+    :param series: Input Time Series data
+    :type series: :mod:`pandas.Series`
+
+    :param window: A tuple indicating a time window
+    :type window: tuple
+    """
+
+    if not window:
+        return series
+
+    start, stop = window
+    ix = series.index
+    selector = ((ix >= start) & (ix <= stop))
+    window_series = series[selector]
+    return window_series
+
+def area_under_curve(series, sign=None, method="trapz", step="post"):
+    """Return the area under the time series curve (Integral)
+
+    :param series: The time series to be integrated
+    :type series: :mod:`pandas.Series`
+
+    :param sign: Clip the data for the area in positive
+        or negative regions. Can have two values
+
+        - `"+"`
+        - `"="`
+    :type sign: str
+
+    :param method: The method for area calculation. This can
+        be any of the integration methods supported in `numpy`
+        or `rect`
+    :type param: str
+
+    :param step: The step behaviour for `rect` method
+    :type step: str
+
+    *Rectangular Method*
+
+        - Step: Post
+
+            Consider the following time series data
+
+            .. code::
+
+                2            *----*----*----+
+                             |              |
+                1            |              *----*----+
+                             |
+                0  *----*----+
+                   0    1    2    3    4    5    6    7
+
+            .. code::
+
+                import pandas as pd
+                a = [0, 0, 2, 2, 2, 1, 1]
+                s = pd.Series(a)
+
+            The area under the curve is:
+
+            .. math::
+
+                \sum_{k=0}^{N-1} (x_{k+1} - {x_k}) \\times f(x_k) \\\\
+                (2 \\times 3) + (1 \\times 2) = 8
+
+        - Step: Pre
+
+            .. code::
+
+                2       +----*----*----*
+                        |              |
+                1       |              +----*----*----+
+                        |
+                0  *----*
+                   0    1    2    3    4    5    6    7
+
+            .. code::
+
+                import pandas as pd
+                a = [0, 0, 2, 2, 2, 1, 1]
+                s = pd.Series(a)
+
+            The area under the curve is:
+
+            .. math::
+
+                \sum_{k=1}^{N} (x_k - x_{k-1}) \\times f(x_k) \\\\
+                (2 \\times 3) + (1 \\times 3) = 9
+    """
+
+    if sign == "+":
+        series = series.clip_lower(0)
+    elif sign == "=":
+        series = series.clip_upper(0)
+
+    series = series.dropna()
+
+    if method == "rect":
+
+        if step == "post":
+            values = series.values[:-1]
+        elif step == "pre":
+            values = series.values[1:]
+        else:
+            raise ValueError("Invalid Value for step: {}".format(step))
+
+        return float((values * np.diff(series.index)).sum())
+
+    if hasattr(np, method):
+        np_integ_method = getattr(np, method)
+        return np_integ_method(series.values, series.index)
+    else:
+        raise ValueError("Invalid method: {}".format(method))
+
+def interval_sum(series, value=None, step="post"):
+    """A function that returns the sum of the
+    intervals where the value of series is equal to
+    the expected value. Consider the following time
+    series data:
+
+    ====== =======
+     Time   Value
+    ====== =======
+      0      0
+      1      0
+      2      1
+      3      1
+      4      1
+      5      1
+      8      0
+      9      1
+     10      0
+     11      1
+     12      1
+    ====== =======
+
+    .. note::
+
+        The time/index values, in general, may not be
+        uniform. This causes difference in the
+        the values of :func:`interval_sum` for **step-pre**
+        and **step-post** behaviours
+
+    .. code::
+
+        import pandas
+
+        values = [0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1]
+        index = [0, 1, 2, 3, 4, 5, 8, 9, 10, 11, 12]
+        series = pandas.Series(values, index=index)
+
+    The :func:`interval_sum` for the value 1 is calculated differently
+    for **step-post** and **step-pre** behaviours as follows:
+
+        - **Step-Post**
+
+
+          .. code::
+
+            1            *----*----*----*-------------+    *----+    *----*
+                         |                            |    |    |    |
+            0  *----*----+                            *----+    *----+
+               0    1    2    3    4    5    6    7   8    9    10   11   12
+
+          .. math::
+
+            (8-2) + (10-9) + (12-11) = 6 + 1 + 1 = 8
+
+        - **Step-Pre**
+
+          .. code::
+
+            1       +----*----*----*----*              +----*    +----*----*
+                    |                   |              |    |    |
+            0  *----*                   +--------------*    +----*
+               0    1    2    3    4    5    6    7    8    9    10   11   12
+
+          .. math::
+
+                (5-1) + (9-8) + (12-10) = 4 + 1 + 2 = 7
+
+        .. note::
+
+            The asterisks (*) on the plots above represent the values of the time
+            series data and these do not vary between the two step styles
+
+    :param series: The time series data
+    :type series: :mod:`pandas.Series`
+
+    :param value: The value to checked for in the series. If the
+        value is None, the truth value of the elements in the
+        series will be used
+    :type value: element
+
+    :param step: The step behaviour as described above
+        ::
+
+            step="post"
+            step="pre
+    :type step: str
+    """
+
+    index = series.index
+    array = series.values
+
+    time_splits = np.append(np.where(np.diff(array) != 0), len(array) - 1)
+
+    prev = 0
+    time = 0
+    step_post = True
+
+    if step == "pre":
+        step_post = False
+    elif step != "post":
+        raise ValueError("Invalid value for step: {}".format(step))
+
+    for split in time_splits:
+
+        first_val = series.iloc[split]
+        check = (first_val == value) if value else first_val
+        if check:
+            start = prev
+            end = split
+
+            if step_post:
+                end = split + 1 if split < len(series) - 1 else split
+            else:
+                start = prev - 1 if prev > 1 else prev
+
+            time += index[end] - index[start]
+
+        prev = split + 1
+
+    return float(time)
diff --git a/bart/common/__init__.py b/bart/common/__init__.py
new file mode 100644
index 0000000..f42522b
--- /dev/null
+++ b/bart/common/__init__.py
@@ -0,0 +1,20 @@
+#    Copyright 2015-2016 ARM Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""Initialization for bart.common"""
+
+
+from bart.common import Utils
+from bart.common import Analyzer
diff --git a/bart/common/signal.py b/bart/common/signal.py
new file mode 100644
index 0000000..acf7091
--- /dev/null
+++ b/bart/common/signal.py
@@ -0,0 +1,300 @@
+#    Copyright 2015-2016 ARM Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""
+**Signals**
+
+    - Definition
+
+        A signal is a string representation of a TRAPpy event and the
+        column in the same event. The signal can be of two types:
+
+            - *Pivoted Signal*
+
+                A pivoted signal has a pivot specified in its event class.
+                This means that the signal in the event is a concatenation of different
+                signals which belong to different **pivot** nodes. The analysis for pivoted
+                signals must be done by decomposing them into pivoted signals for each node.
+
+                For example, an even that represents the load of the CPU can be pivoted on
+                :code:`"cpu"` which should be a column in the event's `DataFrame`
+
+            - *Non-Pivoted Signal*
+
+                A non pivoted signal has an event that has no pivot value associated with it.
+                This probably means that signal has one component and can be analysed without
+                decomposing it into smaller signals.
+
+    - Representation
+
+        The following are valid representations of a signal
+
+        - :code:`"event_name:event_column"`
+        - :code:`"trappy.event.class:event_column"`
+
+"""
+
+from trappy.stats.grammar import Parser
+from trappy.stats import StatConf
+from bart.common.Utils import area_under_curve, interval_sum
+
+# pylint: disable=invalid-name
+# pylint: disable=anomalous-backslash-in-string
+
+class SignalCompare(object):
+
+    """
+    :param data: TRAPpy FTrace Object
+    :type data: :mod:`trappy.ftrace.FTrace`
+
+    :param sig_a: The first signal
+    :type sig_a: str
+
+    :param sig_b: The first signal
+    :type sig_b: str
+
+    :param config: A dictionary of variables, classes
+        and functions that can be used in the statements
+    :type config: dict
+
+    :param method: The method to be used for reindexing data
+        This can be one of the standard :mod:`pandas.DataFrame`
+        methods (eg. pad, bfill, nearest). The default is pad
+        or use the last valid observation.
+    :type method: str
+
+    :param limit: The number of indices a value will be propagated
+        when reindexing. The default is None
+    :type limit: int
+
+    :param fill: Whether to fill the NaNs in the data.
+        The default value is True.
+    :type fill: bool
+
+    .. note::
+
+        Both the signals must have the same pivots. For example:
+
+            - Signal A has a pivot as :code:`"cpu"` which means that
+              the trappy event (:mod:`trappy.base.Base`) has a pivot
+              parameter which is equal to :code:`"cpu"`. Then the signal B
+              should also have :code:`"cpu"` as it's pivot.
+
+            - Signal A and B can both have undefined or None
+              as their pivots
+    """
+
+    def __init__(self, data, sig_a, sig_b, **kwargs):
+
+        self._parser = Parser(
+            data,
+            config=kwargs.pop(
+                "config",
+                None),
+            **kwargs)
+        self._a = sig_a
+        self._b = sig_b
+        self._pivot_vals, self._pivot = self._get_signal_pivots()
+
+        # Concatenate the indices by doing any operation (say add)
+        self._a_data = self._parser.solve(sig_a)
+        self._b_data = self._parser.solve(sig_b)
+
+    def _get_signal_pivots(self):
+        """Internal function to check pivot conditions and
+        return an intersection of pivot on the signals"""
+
+        sig_a_info = self._parser.inspect(self._a)
+        sig_b_info = self._parser.inspect(self._b)
+
+        if sig_a_info["pivot"] != sig_b_info["pivot"]:
+            raise RuntimeError("The pivot column for both signals" +
+                               "should be same (%s,%s)"
+                               % (sig_a_info["pivot"], sig_b_info["pivot"]))
+
+        if sig_a_info["pivot"]:
+            pivot_vals = set(
+                sig_a_info["pivot_values"]).intersection(sig_b_info["pivot_values"])
+            pivoted = sig_a_info["pivot"]
+        else:
+            pivot_vals = [StatConf.GRAMMAR_DEFAULT_PIVOT]
+            pivoted = False
+
+        return pivot_vals, pivoted
+
+    def conditional_compare(self, condition, **kwargs):
+        """Conditionally compare two signals
+
+        The conditional comparison of signals has two components:
+
+        - **Value Coefficient** :math:`\\alpha_{v}` which measures the difference in values of
+          of the two signals when the condition is true:
+
+          .. math::
+
+                \\alpha_{v} = \\frac{area\_under\_curve(S_A\ |\ C(t)\ is\ true)}
+                {area\_under\_curve(S_B\ |\ C(t)\ is\ true)} \\\\
+
+                \\alpha_{v} = \\frac{\int S_A(\{t\ |\ C(t)\})dt}{\int S_B(\{t\ |\ C(t)\})dt}
+
+        - **Time Coefficient** :math:`\\alpha_{t}` which measures the time during which the
+          condition holds true.
+
+          .. math::
+
+                \\alpha_{t} = \\frac{T_{valid}}{T_{total}}
+
+        :param condition: A condition that returns a truth value and obeys the grammar syntax
+            ::
+
+                "event_x:sig_a > event_x:sig_b"
+
+        :type condition: str
+
+        :param method: The method for area calculation. This can
+            be any of the integration methods supported in `numpy`
+            or `rect`
+        :type param: str
+
+        :param step: The step behaviour for area and time
+            summation calculation
+        :type step: str
+
+        Consider the two signals A and B as follows:
+
+            .. code::
+
+                A = [0, 0, 0, 3, 3, 0, 0, 0]
+                B = [0, 0, 2, 2, 2, 2, 1, 1]
+
+
+            .. code::
+
+
+                                                     A = xxxx
+                3                 *xxxx*xxxx+        B = ----
+                                  |         |
+                2            *----*----*----+
+                             |    |         |
+                1            |    |         *----*----+
+                             |    |         |
+                0  *x-x-*x-x-+xxxx+         +xxxx*xxxx+
+                   0    1    2    3    4    5    6    7
+
+        The condition:
+
+        .. math::
+
+            A > B
+
+        is valid between T=3 and T=5. Therefore,
+
+        .. math::
+
+            \\alpha_v=1.5 \\\\
+            \\alpha_t=\\frac{2}{7}
+
+        :returns: There are two cases:
+
+            - **Pivoted Signals**
+              ::
+
+                    {
+                        "pivot_name" : {
+                                "pval_1" : (v1,t1),
+                                "pval_2" : (v2, t2)
+                        }
+                    }
+            - **Non Pivoted Signals**
+
+              The tuple of :math:`(\\alpha_v, \\alpha_t)`
+        """
+
+        if self._pivot:
+            result = {self._pivot: {}}
+
+        mask = self._parser.solve(condition)
+        step = kwargs.get("step", "post")
+
+        for pivot_val in self._pivot_vals:
+
+            a_piv = self._a_data[pivot_val]
+            b_piv = self._b_data[pivot_val]
+
+            area = area_under_curve(a_piv[mask[pivot_val]], **kwargs)
+            try:
+                area /= area_under_curve(b_piv[mask[pivot_val]], **kwargs)
+            except ZeroDivisionError:
+                area = float("nan")
+
+            duration = min(a_piv.last_valid_index(), b_piv.last_valid_index())
+            duration -= max(a_piv.first_valid_index(),
+                            b_piv.first_valid_index())
+            duration = interval_sum(mask[pivot_val], step=step) / duration
+
+            if self._pivot:
+                result[self._pivot][pivot_val] = area, duration
+            else:
+                result = area, duration
+
+        return result
+
+    def get_overshoot(self, **kwargs):
+        """Special case for :func:`conditional_compare`
+        where the condition is:
+        ::
+
+            "sig_a > sig_b"
+
+        :param method: The method for area calculation. This can
+            be any of the integration methods supported in `numpy`
+            or `rect`
+        :type param: str
+
+        :param step: The step behaviour for calculation of area
+            and time summation
+        :type step: str
+
+        .. seealso::
+
+            :func:`conditional_compare`
+        """
+
+        condition = " ".join([self._a, ">", self._b])
+        return self.conditional_compare(condition, **kwargs)
+
+    def get_undershoot(self, **kwargs):
+        """Special case for :func:`conditional_compare`
+        where the condition is:
+        ::
+
+            "sig_a < sig_b"
+
+        :param method: The method for area calculation. This can
+            be any of the integration methods supported in `numpy`
+            or `rect`
+        :type param: str
+
+        :param step: The step behaviour for calculation of area
+            and time summation
+        :type step: str
+
+        .. seealso::
+
+            :func:`conditional_compare`
+        """
+
+        condition = " ".join([self._a, "<", self._b])
+        return self.conditional_compare(condition, **kwargs)
diff --git a/bart/sched/SchedAssert.py b/bart/sched/SchedAssert.py
new file mode 100755
index 0000000..5ecfec9
--- /dev/null
+++ b/bart/sched/SchedAssert.py
@@ -0,0 +1,666 @@
+#    Copyright 2015-2016 ARM Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""
+:mod:`bart.sched.SchedAssert` provides ability to assert scheduler behaviour.
+The analysis is based on TRAPpy's statistics framework and is potent enough
+to aggregate statistics over processor hierarchies.
+"""
+
+import trappy
+import itertools
+import math
+from trappy.stats.Aggregator import MultiTriggerAggregator
+from bart.sched import functions as sched_funcs
+from bart.common import Utils
+import numpy as np
+
+# pylint: disable=invalid-name
+# pylint: disable=too-many-arguments
+class SchedAssert(object):
+
+    """The primary focus of this class is to assert and verify
+    predefined scheduler scenarios. This does not compare parameters
+    across runs
+
+    :param ftrace: A single trappy.FTrace object
+        or a path that can be passed to trappy.FTrace
+    :type ftrace: :mod:`trappy.ftrace.FTrace`
+
+    :param topology: A topology that describes the arrangement of
+        CPU's on a system. This is useful for multi-cluster systems
+        where data needs to be aggregated at different topological
+        levels
+    :type topology: :mod:`trappy.stats.Topology.Topology`
+
+    :param execname: The execname of the task to be analysed
+
+        .. note::
+
+                There should be only one PID that maps to the specified
+                execname. If there are multiple PIDs :mod:`bart.sched.SchedMultiAssert`
+                should be used
+
+    :type execname: str
+
+    :param pid: The process ID of the task to be analysed
+    :type pid: int
+
+    .. note:
+
+        One of pid or execname is mandatory. If only execname
+        is specified, The current implementation will fail if
+        there are more than one processes with the same execname
+    """
+
+    def __init__(self, ftrace, topology, execname=None, pid=None):
+
+        ftrace = Utils.init_ftrace(ftrace)
+
+        if not execname and not pid:
+            raise ValueError("Need to specify at least one of pid or execname")
+
+        self.execname = execname
+        self._ftrace = ftrace
+        self._pid = self._validate_pid(pid)
+        self._aggs = {}
+        self._topology = topology
+        self._triggers = sched_funcs.sched_triggers(self._ftrace, self._pid,
+                                              trappy.sched.SchedSwitch)
+        self.name = "{}-{}".format(self.execname, self._pid)
+
+    def _validate_pid(self, pid):
+        """Validate the passed pid argument"""
+
+        if not pid:
+            pids = sched_funcs.get_pids_for_process(self._ftrace,
+                                              self.execname)
+
+            if len(pids) != 1:
+                raise RuntimeError(
+                    "There should be exactly one PID {0} for {1}".format(
+                        pids,
+                        self.execname))
+
+            return pids[0]
+
+        elif self.execname:
+
+            pids = sched_funcs.get_pids_for_process(self._ftrace,
+                                              self.execname)
+            if pid not in pids:
+                raise RuntimeError(
+                    "PID {0} not mapped to {1}".format(
+                        pid,
+                        self.execname))
+        else:
+            self.execname = sched_funcs.get_task_name(self._ftrace, pid)
+
+        return pid
+
+    def _aggregator(self, aggfunc):
+        """
+        Return an aggregator corresponding to the
+        aggfunc, the aggregators are memoized for performance
+
+        :param aggfunc: Function parameter that
+            accepts a :mod:`pandas.Series` object and
+            returns a vector/scalar
+
+        :type: function(:mod:`pandas.Series`)
+        """
+
+        if aggfunc not in self._aggs.keys():
+            self._aggs[aggfunc] = MultiTriggerAggregator(self._triggers,
+                                                         self._topology,
+                                                         aggfunc)
+        return self._aggs[aggfunc]
+
+    def getResidency(self, level, node, window=None, percent=False):
+        """
+        Residency of the task is the amount of time it spends executing
+        a particular group of a topological level. For example:
+        ::
+
+            from trappy.stats.Topology import Topology
+
+            big = [1, 2]
+            little = [0, 3, 4, 5]
+
+            topology = Topology(clusters=[little, big])
+
+            s = SchedAssert(trace, topology, pid=123)
+            s.getResidency("cluster", big)
+
+        This will return the residency of the task on the big cluster. If
+        percent is specified it will be normalized to the total runtime
+        of the task
+
+        :param level: The topological level to which the group belongs
+        :type level: str
+
+        :param node: The group of CPUs for which residency
+            needs to calculated
+        :type node: list
+
+        :param window: A (start, end) tuple to limit the scope of the
+            residency calculation.
+        :type window: tuple
+
+        :param percent: If true the result is normalized to the total runtime
+            of the task and returned as a percentage
+        :type percent: bool
+
+        .. math::
+
+            R = \\frac{T_{group} \\times 100}{T_{total}}
+
+        .. seealso:: :mod:`bart.sched.SchedAssert.SchedAssert.assertResidency`
+        """
+
+        # Get the index of the node in the level
+        node_index = self._topology.get_index(level, node)
+
+        agg = self._aggregator(sched_funcs.residency_sum)
+        level_result = agg.aggregate(level=level, window=window)
+
+        node_value = level_result[node_index]
+
+        if percent:
+            total = agg.aggregate(level="all", window=window)[0]
+            node_value = node_value * 100
+            node_value = node_value / total
+
+        return node_value
+
+    def assertResidency(
+            self,
+            level,
+            node,
+            expected_value,
+            operator,
+            window=None,
+            percent=False):
+        """
+        :param level: The topological level to which the group belongs
+        :type level: str
+
+        :param node: The group of CPUs for which residency
+            needs to calculated
+        :type node: list
+
+        :param expected_value: The expected value of the residency
+        :type expected_value: double
+
+        :param operator: A binary operator function that returns
+            a boolean. For example:
+            ::
+
+                import operator
+                op = operator.ge
+                assertResidency(level, node, expected_value, op)
+
+            Will do the following check:
+            ::
+
+                getResidency(level, node) >= expected_value
+
+            A custom function can also be passed:
+            ::
+
+                THRESHOLD=5
+                def between_threshold(a, expected):
+                    return abs(a - expected) <= THRESHOLD
+
+        :type operator: function
+
+        :param window: A (start, end) tuple to limit the scope of the
+            residency calculation.
+        :type window: tuple
+
+        :param percent: If true the result is normalized to the total runtime
+            of the task and returned as a percentage
+        :type percent: bool
+
+        .. seealso:: :mod:`bart.sched.SchedAssert.SchedAssert.getResidency`
+        """
+        node_value = self.getResidency(level, node, window, percent)
+        return operator(node_value, expected_value)
+
+    def getStartTime(self):
+        """
+        :return: The first time the task ran across all the CPUs
+        """
+
+        agg = self._aggregator(sched_funcs.first_time)
+        result = agg.aggregate(level="all", value=sched_funcs.TASK_RUNNING)
+        return min(result[0])
+
+    def getEndTime(self):
+        """
+        :return: The first last time the task ran across
+            all the CPUs
+        """
+
+        agg = self._aggregator(sched_funcs.first_time)
+        agg = self._aggregator(sched_funcs.last_time)
+        result = agg.aggregate(level="all", value=sched_funcs.TASK_RUNNING)
+        return max(result[0])
+
+    def _relax_switch_window(self, series, direction, window):
+        """
+            direction == "left"
+                return the last time the task was running
+                if no such time exists in the window,
+                extend the window's left extent to
+                getStartTime
+
+            direction == "right"
+                return the first time the task was running
+                in the window. If no such time exists in the
+                window, extend the window's right extent to
+                getEndTime()
+
+            The function returns a None if
+            len(series[series == TASK_RUNNING]) == 0
+            even in the extended window
+        """
+
+        series = series[series == sched_funcs.TASK_RUNNING]
+        w_series = sched_funcs.select_window(series, window)
+        start, stop = window
+
+        if direction == "left":
+            if len(w_series):
+                return w_series.index.values[-1]
+            else:
+                start_time = self.getStartTime()
+                w_series = sched_funcs.select_window(
+                    series,
+                    window=(
+                        start_time,
+                        start))
+
+                if not len(w_series):
+                    return None
+                else:
+                    return w_series.index.values[-1]
+
+        elif direction == "right":
+            if len(w_series):
+                return w_series.index.values[0]
+            else:
+                end_time = self.getEndTime()
+                w_series = sched_funcs.select_window(series, window=(stop, end_time))
+
+                if not len(w_series):
+                    return None
+                else:
+                    return w_series.index.values[0]
+        else:
+            raise ValueError("direction should be either left or right")
+
+    def assertSwitch(
+            self,
+            level,
+            from_node,
+            to_node,
+            window,
+            ignore_multiple=True):
+        """
+        This function asserts that there is context switch from the
+           :code:`from_node` to the :code:`to_node`:
+
+        :param level: The topological level to which the group belongs
+        :type level: str
+
+        :param from_node: The node from which the task switches out
+        :type from_node: list
+
+        :param to_node: The node to which the task switches
+        :type to_node: list
+
+        :param window: A (start, end) tuple to limit the scope of the
+            residency calculation.
+        :type window: tuple
+
+        :param ignore_multiple: If true, the function will ignore multiple
+           switches in the window, If false the assert will be true if and
+           only if there is a single switch within the specified window
+        :type ignore_multiple: bool
+        """
+
+        from_node_index = self._topology.get_index(level, from_node)
+        to_node_index = self._topology.get_index(level, to_node)
+
+        agg = self._aggregator(sched_funcs.csum)
+        level_result = agg.aggregate(level=level)
+
+        from_node_result = level_result[from_node_index]
+        to_node_result = level_result[to_node_index]
+
+        from_time = self._relax_switch_window(from_node_result, "left", window)
+        if ignore_multiple:
+            to_time = self._relax_switch_window(to_node_result, "left", window)
+        else:
+            to_time = self._relax_switch_window(
+                to_node_result,
+                "right", window)
+
+        if from_time and to_time:
+            if from_time < to_time:
+                return True
+
+        return False
+
+    def getRuntime(self, window=None, percent=False):
+        """Return the Total Runtime of a task
+
+        :param window: A (start, end) tuple to limit the scope of the
+            residency calculation.
+        :type window: tuple
+
+        :param percent: If True, the result is returned
+            as a percentage of the total execution time
+            of the run.
+        :type percent: bool
+
+        .. seealso:: :mod:`bart.sched.SchedAssert.SchedAssert.assertRuntime`
+        """
+
+        agg = self._aggregator(sched_funcs.residency_sum)
+        run_time = agg.aggregate(level="all", window=window)[0]
+
+        if percent:
+
+            if window:
+                begin, end = window
+                total_time = end - begin
+            else:
+                total_time = self._ftrace.get_duration()
+
+            run_time = run_time * 100
+            run_time = run_time / total_time
+
+        return run_time
+
+    def assertRuntime(
+            self,
+            expected_value,
+            operator,
+            window=None,
+            percent=False):
+        """Assert on the total runtime of the task
+
+        :param expected_value: The expected value of the runtime
+        :type expected_value: double
+
+        :param operator: A binary operator function that returns
+            a boolean. For example:
+            ::
+
+                import operator
+                op = operator.ge
+                assertRuntime(expected_value, op)
+
+            Will do the following check:
+            ::
+
+                getRuntime() >= expected_value
+
+            A custom function can also be passed:
+            ::
+
+                THRESHOLD=5
+                def between_threshold(a, expected):
+                    return abs(a - expected) <= THRESHOLD
+
+        :type operator: function
+
+        :param window: A (start, end) tuple to limit the scope of the
+            residency calculation.
+        :type window: tuple
+
+        :param percent: If True, the result is returned
+            as a percentage of the total execution time
+            of the run.
+        :type percent: bool
+
+        .. seealso:: :mod:`bart.sched.SchedAssert.SchedAssert.getRuntime`
+        """
+
+        run_time = self.getRuntime(window, percent)
+        return operator(run_time, expected_value)
+
+    def getPeriod(self, window=None, align="start"):
+        """Return the period of the task in (ms)
+
+        Let's say a task started execution at the following times:
+
+            .. math::
+
+                T_1, T_2, ...T_n
+
+        The period is defined as:
+
+            .. math::
+
+                Median((T_2 - T_1), (T_4 - T_3), ....(T_n - T_{n-1}))
+
+        :param window: A (start, end) tuple to limit the scope of the
+            residency calculation.
+        :type window: tuple
+
+        :param align:
+            :code:`"start"` aligns period calculation to switch-in events
+            :code:`"end"` aligns the calculation to switch-out events
+        :type param: str
+
+        .. seealso:: :mod:`bart.sched.SchedAssert.SchedAssert.assertPeriod`
+        """
+
+        agg = self._aggregator(sched_funcs.period)
+        deltas = agg.aggregate(level="all", window=window)[0]
+
+        if not len(deltas):
+            return float("NaN")
+        else:
+            return np.median(deltas) * 1000
+
+    def assertPeriod(
+            self,
+            expected_value,
+            operator,
+            window=None,
+            align="start"):
+        """Assert on the period of the task
+
+        :param expected_value: The expected value of the runtime
+        :type expected_value: double
+
+        :param operator: A binary operator function that returns
+            a boolean. For example:
+            ::
+
+                import operator
+                op = operator.ge
+                assertPeriod(expected_value, op)
+
+            Will do the following check:
+            ::
+
+                getPeriod() >= expected_value
+
+            A custom function can also be passed:
+            ::
+
+                THRESHOLD=5
+                def between_threshold(a, expected):
+                    return abs(a - expected) <= THRESHOLD
+
+        :param window: A (start, end) tuple to limit the scope of the
+            calculation.
+        :type window: tuple
+
+        :param align:
+            :code:`"start"` aligns period calculation to switch-in events
+            :code:`"end"` aligns the calculation to switch-out events
+        :type param: str
+
+        .. seealso:: :mod:`bart.sched.SchedAssert.SchedAssert.getPeriod`
+        """
+
+        period = self.getPeriod(window, align)
+        return operator(period, expected_value)
+
+    def getDutyCycle(self, window):
+        """Return the duty cycle of the task
+
+        :param window: A (start, end) tuple to limit the scope of the
+            calculation.
+        :type window: tuple
+
+        Duty Cycle:
+            The percentage of time the task spends executing
+            in the given window of time
+
+            .. math::
+
+                \delta_{cycle} = \\frac{T_{exec} \\times 100}{T_{window}}
+
+        .. seealso:: :mod:`bart.sched.SchedAssert.SchedAssert.assertDutyCycle`
+        """
+
+        return self.getRuntime(window, percent=True)
+
+    def assertDutyCycle(self, expected_value, operator, window):
+        """
+        :param operator: A binary operator function that returns
+            a boolean. For example:
+            ::
+
+                import operator
+                op = operator.ge
+                assertPeriod(expected_value, op)
+
+            Will do the following check:
+            ::
+
+                getPeriod() >= expected_value
+
+            A custom function can also be passed:
+            ::
+
+                THRESHOLD=5
+                def between_threshold(a, expected):
+                    return abs(a - expected) <= THRESHOLD
+
+        :param window: A (start, end) tuple to limit the scope of the
+            calculation.
+        :type window: tuple
+
+        .. seealso:: :mod:`bart.sched.SchedAssert.SchedAssert.getDutyCycle`
+
+        """
+        return self.assertRuntime(
+            expected_value,
+            operator,
+            window,
+            percent=True)
+
+    def getFirstCpu(self, window=None):
+        """
+        :return: The first CPU the task ran on
+
+        .. seealso:: :mod:`bart.sched.SchedAssert.SchedAssert.assertFirstCPU`
+        """
+
+        agg = self._aggregator(sched_funcs.first_cpu)
+        result = agg.aggregate(level="cpu", window=window)
+        result = list(itertools.chain.from_iterable(result))
+
+        min_time = min(result)
+        if math.isinf(min_time):
+            return -1
+        index = result.index(min_time)
+        return self._topology.get_node("cpu", index)[0]
+
+    def assertFirstCpu(self, cpus, window=None):
+        """
+        Check if the Task started (first ran on in the duration
+        of the trace) on a particular CPU(s)
+
+        :param cpus: A list of acceptable CPUs
+        :type cpus: int, list
+
+        .. seealso:: :mod:`bart.sched.SchedAssert.SchedAssert.getFirstCPU`
+        """
+
+        first_cpu = self.getFirstCpu(window=window)
+        cpus = Utils.listify(cpus)
+        return first_cpu in cpus
+
+    def getLastCpu(self, window=None):
+        """Return the last CPU the task ran on"""
+
+        agg = self._aggregator(sched_funcs.last_cpu)
+        result = agg.aggregate(level="cpu", window=window)
+        result = list(itertools.chain.from_iterable(result))
+
+        end_time = max(result)
+        if not end_time:
+            return -1
+
+        return result.index(end_time)
+
+    def generate_events(self, level, start_id=0, window=None):
+        """Generate events for the trace plot
+
+        .. note::
+            This is an internal function accessed by the
+            :mod:`bart.sched.SchedMultiAssert` class for plotting data
+        """
+
+        agg = self._aggregator(sched_funcs.trace_event)
+        result = agg.aggregate(level=level, window=window)
+        events = []
+
+        for idx, level_events in enumerate(result):
+            if not len(level_events):
+                continue
+            events += np.column_stack((level_events, np.full(len(level_events), idx))).tolist()
+
+        return sorted(events, key = lambda x : x[0])
+
+    def plot(self, level="cpu", window=None, xlim=None):
+        """
+        :return: :mod:`trappy.plotter.AbstractDataPlotter` instance
+            Call :func:`view` to draw the graph
+        """
+
+        if not xlim:
+            if not window:
+                xlim = [0, self._ftrace.get_duration()]
+            else:
+                xlim = list(window)
+
+        events = {}
+        events[self.name] = self.generate_events(level, window)
+        names = [self.name]
+        num_lanes = self._topology.level_span(level)
+        lane_prefix = level.upper() + ": "
+        return trappy.EventPlot(events, names, xlim,
+                                lane_prefix=lane_prefix,
+                                num_lanes=num_lanes)
diff --git a/bart/sched/SchedMatrix.py b/bart/sched/SchedMatrix.py
new file mode 100755
index 0000000..4595469
--- /dev/null
+++ b/bart/sched/SchedMatrix.py
@@ -0,0 +1,292 @@
+#    Copyright 2015-2016 ARM Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""
+The SchedMatrix provides an ability to compare two executions
+of benchmarks with multiple processes.
+
+For example, consider a benchmark that spawns 4 identical threads
+and any two threads should exhibit a certain behaviours and the
+remaining another identical but different behaviour.
+
+SchedMatrix creates a Matrix of Scheduler Waveform Correlations
+
+A = Reference Execution
+B = Execution to be Evaluated
+
+.. code::
+
+               +---+  +---+
+               |   |  |   |
+    A1, B3 +---+   +--+   +--------------+
+                          +---+  +---+
+                          |   |  |   |
+    A2, B4 +--------------+   +--+   +---+
+               +---+  +---+
+               |   |  |   |
+    A3, B1 +---+   +--+   +--------------+
+                          +---+  +---+
+                          |   |  |   |
+    A4, B2 +--------------+   +--+   +---+
+
+
+**Correlation Matrix**
+
+    === ==== ==== ==== ====
+         B1   B2   B3   B4
+    === ==== ==== ==== ====
+    A1   1    0    1    0
+    A2   0    1    0    1
+    A3   1    0    1    0
+    A4   0    1    0    1
+    === ==== ==== ==== ====
+
+
+Thus a success criteria can be defined as A1 having two similar threads in the
+evaluated execution
+::
+
+    assertSiblings(A1, 2, operator.eq)
+    assertSiblings(A2, 2, operator.eq)
+    assertSiblings(A3, 2, operator.eq)
+    assertSiblings(A4, 2, operator.eq)
+"""
+
+
+import sys
+import trappy
+import numpy as np
+from trappy.stats.Aggregator import MultiTriggerAggregator
+from trappy.stats.Correlator import Correlator
+from bart.sched import functions as sched_funcs
+from bart.common import Utils
+
+POSITIVE_TOLERANCE = 0.80
+
+# pylint: disable=invalid-name
+# pylint: disable=too-many-arguments
+
+
+class SchedMatrix(object):
+
+    """
+    :param reference_trace: The trace file path/ftrace object
+        to be used as a reference
+    :type reference_trace: str, :mod:`trappy.ftrace.FTrace`
+
+    :param trace: The trace file path/ftrace object
+        to be verified
+    :type trace: str, :mod:`trappy.ftrace.FTrace`
+
+    :param topology: A topology that describes the arrangement of
+        CPU's on a system. This is useful for multi-cluster systems
+        where data needs to be aggregated at different topological
+        levels
+    :type topology: :mod:`trappy.stats.Topology.Topology`
+
+    :param execnames: The execnames of the task to be analysed
+
+        A single execname or a list of execnames can be passed.
+        There can be multiple processes associated with a single
+        execname parameter. The execnames are searched using a prefix
+        match.
+    :type execname: list, str
+
+    Consider the following processes which need to be analysed:
+
+    * **Reference Trace**
+
+            ===== ==============
+             PID    execname
+            ===== ==============
+             11     task_1
+             22     task_2
+             33     task_3
+            ===== ==============
+
+    * **Trace to be verified**
+
+            ===== ==============
+             PID    execname
+            ===== ==============
+             77     task_1
+             88     task_2
+             99     task_3
+            ===== ==============
+
+
+    A :mod:`bart.sched.SchedMatrix.SchedMatrix` instance be created
+    following different ways:
+
+        - Using execname prefix match
+          ::
+
+            SchedMatrix(r_trace, trace, topology,
+                        execnames="task_")
+
+        - Individual Task names
+          ::
+
+            SchedMatrix(r_trace, trace, topology,
+                        execnames=["task_1", "task_2", "task_3"])
+
+    """
+
+    def __init__(
+            self,
+            reference_trace,
+            trace,
+            topology,
+            execnames,
+            aggfunc=sched_funcs.csum):
+
+        run = Utils.init_ftrace(trace)
+        reference_run = Utils.init_ftrace(reference_trace)
+
+        self._execnames = Utils.listify(execnames)
+        self._reference_pids = self._populate_pids(reference_run)
+        self._pids = self._populate_pids(run)
+        self._dimension = len(self._pids)
+        self._topology = topology
+        self._matrix = self._generate_matrix(run, reference_run, aggfunc)
+
+        if len(self._pids) != len(self._reference_pids):
+            raise RuntimeError(
+                "The runs do not have the same number of PIDs for {0}".format(
+                    str(execnames)))
+
+    def _populate_pids(self, run):
+        """Populate the qualifying PIDs from the run"""
+
+        if len(self._execnames) == 1:
+            return sched_funcs.get_pids_for_process(run, self._execnames[0])
+
+        pids = []
+
+        for proc in self._execnames:
+            pids += sched_funcs.get_pids_for_process(run, proc)
+
+        return list(set(pids))
+
+    def _generate_matrix(self, run, reference_run, aggfunc):
+        """Generate the Correlation Matrix"""
+
+        reference_aggs = []
+        aggs = []
+
+        for idx in range(self._dimension):
+
+            reference_aggs.append(
+                MultiTriggerAggregator(
+                    sched_funcs.sched_triggers(
+                        reference_run,
+                        self._reference_pids[idx],
+                        trappy.sched.SchedSwitch
+                        ),
+                    self._topology,
+                    aggfunc))
+
+            aggs.append(
+                MultiTriggerAggregator(
+                    sched_funcs.sched_triggers(
+                        run,
+                        self._pids[idx],
+                        trappy.sched.SchedSwitch
+                        ),
+                    self._topology,
+                    aggfunc))
+
+        agg_pair_gen = ((r_agg, agg)
+                        for r_agg in reference_aggs for agg in aggs)
+
+        # pylint fails to recognize numpy members.
+        # pylint: disable=no-member
+        matrix = np.zeros((self._dimension, self._dimension))
+        # pylint: enable=no-member
+
+        for (ref_result, test_result) in agg_pair_gen:
+            i = reference_aggs.index(ref_result)
+            j = aggs.index(test_result)
+            corr = Correlator(
+                ref_result,
+                test_result,
+                corrfunc=sched_funcs.binary_correlate,
+                filter_gaps=True)
+            _, total = corr.correlate(level="cluster")
+
+            matrix[i][j] = total
+
+        return matrix
+
+    def print_matrix(self):
+        """Print the correlation matrix"""
+
+        # pylint fails to recognize numpy members.
+        # pylint: disable=no-member
+        np.set_printoptions(precision=5)
+        np.set_printoptions(suppress=False)
+        np.savetxt(sys.stdout, self._matrix, "%5.5f")
+        # pylint: enable=no-member
+
+    def getSiblings(self, pid, tolerance=POSITIVE_TOLERANCE):
+        """Return the number of processes in the
+        reference trace that have a correlation
+        greater than tolerance
+
+        :param pid: The PID of the process in the reference
+            trace
+        :type pid: int
+
+        :param tolerance: A correlation value > tolerance
+            will classify the resultant process as a sibling
+        :type tolerance: float
+
+        .. seealso:: :mod:`bart.sched.SchedMatrix.SchedMatrix.assertSiblings`
+        """
+
+        ref_pid_idx = self._reference_pids.index(pid)
+        pid_result = self._matrix[ref_pid_idx]
+        return len(pid_result[pid_result > tolerance])
+
+    def assertSiblings(self, pid, expected_value, operator,
+                       tolerance=POSITIVE_TOLERANCE):
+        """Assert that the number of siblings in the reference
+        trace match the expected value and the operator
+
+        :param pid: The PID of the process in the reference
+            trace
+        :type pid: int
+
+        :param operator: A binary operator function that returns
+            a boolean. For example:
+            ::
+
+                import operator
+                op = operator.eq
+                getSiblings(pid, expected_value, op)
+
+            Will do the following check:
+            ::
+
+                getSiblings(pid) == expected_value
+
+        :param tolerance: A correlation value > tolerance
+            will classify the resultant process as a sibling
+        :type tolerance: float
+
+        .. seealso:: :mod:`bart.sched.SchedMatrix.SchedMatrix.getSiblings`
+        """
+        num_siblings = self.getSiblings(pid, tolerance)
+        return operator(num_siblings, expected_value)
diff --git a/bart/sched/SchedMultiAssert.py b/bart/sched/SchedMultiAssert.py
new file mode 100755
index 0000000..32ea17d
--- /dev/null
+++ b/bart/sched/SchedMultiAssert.py
@@ -0,0 +1,299 @@
+#    Copyright 2015-2016 ARM Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""A library for asserting scheduler scenarios based on the
+statistics aggregation framework"""
+
+import re
+import inspect
+import trappy
+from bart.sched import functions as sched_funcs
+from bart.sched.SchedAssert import SchedAssert
+from bart.common import Utils
+
+class SchedMultiAssert(object):
+    """This is vector assertion class built on top of
+    :mod:`bart.sched.SchedAssert.SchedAssert`
+
+    :param ftrace: A single trappy.FTrace object
+        or a path that can be passed to trappy.FTrace
+    :type ftrace: :mod:`trappy.ftrace.FTrace`
+
+    :param topology: A topology that describes the arrangement of
+        CPU's on a system. This is useful for multi-cluster systems
+        where data needs to be aggregated at different topological
+        levels
+    :type topology: :mod:`trappy.stats.Topology.Topology`
+
+    :param execnames: The execnames of the task to be analysed
+
+        A single execname or a list of execnames can be passed.
+        There can be multiple processes associated with a single
+        execname parameter. The execnames are searched using a prefix
+        match.
+    :type execname: list, str
+
+    :param pids: The process IDs of the tasks to be analysed
+    :type pids: list, int
+
+    Consider the following processes which need to be analysed
+
+        ===== ==============
+         PID    execname
+        ===== ==============
+         11     task_1
+         22     task_2
+         33     task_3
+        ===== ==============
+
+    A :mod:`bart.sched.SchedMultiAssert.SchedMultiAssert` instance be created
+    following different ways:
+
+        - Using execname prefix match
+          ::
+
+            SchedMultiAssert(ftrace, topology, execnames="task_")
+
+        - Individual Task names
+          ::
+
+            SchedMultiAssert(ftrace, topology, execnames=["task_1", "task_2", "task_3"])
+
+        - Using Process IDs
+          ::
+
+            SchedMultiAssert(ftrace, topology, pids=[11, 22, 33])
+
+
+    All the functionality provided in :mod:`bart.sched.SchedAssert.SchedAssert` is available
+    in this class with the addition of handling vector assertions.
+
+    For example consider the use of :func:`getDutyCycle`
+    ::
+
+        >>> s = SchedMultiAssert(ftrace, topology, execnames="task_")
+        >>> s.getDutyCycle(window=(start, end))
+        {
+            "11": {
+                "task_name": "task_1",
+                "dutycycle": 10.0
+            },
+            "22": {
+                "task_name": "task_2",
+                "dutycycle": 20.0
+            },
+            "33": {
+                "task_name": "task_3",
+                "dutycycle": 30.0
+            },
+        }
+
+    The assertions can be used in a similar way
+    ::
+
+        >>> import operator as op
+        >>> s = SchedMultiAssert(ftrace, topology, execnames="task_")
+        >>> s.assertDutyCycle(15, op.ge, window=(start, end))
+        {
+            "11": {
+                "task_name": "task_1",
+                "dutycycle": False
+            },
+            "22": {
+                "task_name": "task_2",
+                "dutycycle": True
+            },
+            "33": {
+                "task_name": "task_3",
+                "dutycycle": True
+            },
+        }
+
+    The above result can be coalesced using a :code:`rank` parameter
+    As we know that only 2 processes have duty cycles greater than 15%
+    we can do the following:
+    ::
+
+        >>> import operator as op
+        >>> s = SchedMultiAssert(ftrace, topology, execnames="task_")
+        >>> s.assertDutyCycle(15, op.ge, window=(start, end), rank=2)
+        True
+
+    See :mod:`bart.sched.SchedAssert.SchedAssert` for the available
+    functionality
+    """
+
+    def __init__(self, ftrace, topology, execnames=None, pids=None):
+
+        self._ftrace = Utils.init_ftrace(ftrace)
+        self._topology = topology
+
+        if execnames and pids:
+            raise ValueError('Either pids or execnames must be specified')
+        if execnames:
+            self._execnames = Utils.listify(execnames)
+            self._pids = self._populate_pids()
+        elif pids:
+            self._pids = pids
+        else:
+            raise ValueError('One of PIDs or execnames must be specified')
+
+        self._asserts = self._populate_asserts()
+        self._populate_methods()
+
+    def _populate_asserts(self):
+        """Populate SchedAsserts for the PIDs"""
+
+        asserts = {}
+
+        for pid in self._pids:
+            asserts[pid] = SchedAssert(self._ftrace, self._topology, pid=pid)
+
+        return asserts
+
+    def _populate_pids(self):
+        """Map the input execnames to PIDs"""
+
+        if len(self._execnames) == 1:
+            return sched_funcs.get_pids_for_process(self._ftrace, self._execnames[0])
+
+        pids = []
+
+        for proc in self._execnames:
+            pids += sched_funcs.get_pids_for_process(self._ftrace, proc)
+
+        return list(set(pids))
+
+    def _create_method(self, attr_name):
+        """A wrapper function to create a dispatch function"""
+
+        return lambda *args, **kwargs: self._dispatch(attr_name, *args, **kwargs)
+
+    def _populate_methods(self):
+        """Populate Methods from SchedAssert"""
+
+        for attr_name in dir(SchedAssert):
+            attr = getattr(SchedAssert, attr_name)
+
+            valid_method = attr_name.startswith("get") or \
+                           attr_name.startswith("assert")
+            if inspect.ismethod(attr) and valid_method:
+                func = self._create_method(attr_name)
+                setattr(self, attr_name, func)
+
+    def get_task_name(self, pid):
+        """Get task name for the PID"""
+        return self._asserts[pid].execname
+
+
+    def _dispatch(self, func_name, *args, **kwargs):
+        """The dispatch function to call into the SchedAssert
+           Method
+        """
+
+        assert_func = func_name.startswith("assert")
+        num_true = 0
+
+        rank = kwargs.pop("rank", None)
+        result = kwargs.pop("result", {})
+        param = kwargs.pop("param", re.sub(r"assert|get", "", func_name, count=1).lower())
+
+        for pid in self._pids:
+
+            if pid not in result:
+                result[pid] = {}
+                result[pid]["task_name"] = self.get_task_name(pid)
+
+            attr = getattr(self._asserts[pid], func_name)
+            result[pid][param] = attr(*args, **kwargs)
+
+            if assert_func and result[pid][param]:
+                num_true += 1
+
+        if assert_func and rank:
+            return num_true == rank
+        else:
+            return result
+
+    def getCPUBusyTime(self, level, node, window=None, percent=False):
+        """Get the amount of time the cpus in the system were busy executing the
+        tasks
+
+        :param level: The topological level to which the group belongs
+        :type level: string
+
+        :param node: The group of CPUs for which to calculate busy time
+        :type node: list
+
+        :param window: A (start, end) tuple to limit the scope of the
+        calculation.
+        :type window: tuple
+
+        :param percent: If True the result is normalized to the total
+        time of the period, either the window or the full lenght of
+        the trace.
+        :type percent: bool
+
+        .. math::
+
+            R = \\frac{T_{busy} \\times 100}{T_{total}}
+
+        """
+        residencies = self.getResidency(level, node, window=window)
+
+        busy_time = sum(v["residency"] for v in residencies.itervalues())
+
+        if percent:
+            if window:
+                total_time = window[1] - window[0]
+            else:
+                total_time = self._ftrace.get_duration()
+            num_cpus = len(node)
+            return busy_time / (total_time * num_cpus) * 100
+        else:
+            return busy_time
+
+    def generate_events(self, level, window=None):
+        """Generate Events for the trace plot
+
+        .. note::
+            This is an internal function for plotting data
+        """
+
+        events = {}
+        for s_assert in self._asserts.values():
+            events[s_assert.name] = s_assert.generate_events(level, window=window)
+
+        return events
+
+    def plot(self, level="cpu", window=None, xlim=None):
+        """
+        :return: :mod:`trappy.plotter.AbstractDataPlotter` instance
+            Call :func:`view` to draw the graph
+        """
+
+        if not xlim:
+            if not window:
+                xlim = [0, self._ftrace.get_duration()]
+            else:
+                xlim = list(window)
+
+        events = self.generate_events(level, window)
+        names = [s.name for s in self._asserts.values()]
+        num_lanes = self._topology.level_span(level)
+        lane_prefix = level.upper() + ": "
+        return trappy.EventPlot(events, names, xlim,
+                                lane_prefix=lane_prefix,
+                                num_lanes=num_lanes)
diff --git a/bart/sched/__init__.py b/bart/sched/__init__.py
new file mode 100644
index 0000000..68133da
--- /dev/null
+++ b/bart/sched/__init__.py
@@ -0,0 +1,21 @@
+#    Copyright 2015-2016 ARM Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""Initialization for bart.sched"""
+
+
+from bart.sched import SchedAssert
+from bart.sched import SchedMultiAssert
+from bart.sched import SchedMatrix
diff --git a/bart/sched/functions.py b/bart/sched/functions.py
new file mode 100644
index 0000000..d1b17d4
--- /dev/null
+++ b/bart/sched/functions.py
@@ -0,0 +1,621 @@
+#    Copyright 2015-2016 ARM Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""Scheduler specific Functionality for the
+stats framework
+
+The Scheduler stats aggregation is based on a signal
+which is generated by the combination of two triggers
+from the events with the following parameters
+
+========================= ============ =============
+EVENT                       VALUE          FILTERS
+========================= ============ =============
+:func:`sched_switch`        1           next_pid
+:func:`sched_switch`      -1           prev_pid
+========================= ============ =============
+
+Both these Triggers are provided by the event
+:mod:`trappy.sched.SchedSwitch` which correspond to
+the :code:`sched_switch` unique word in the trace
+
+.. seealso:: :mod:`trappy.stats.Trigger.Trigger`
+
+Using the above information the following signals are
+generated.
+
+**EVENT SERIES**
+
+This is a combination of the two triggers as specified
+above and has alternating +/- 1 values and is merely
+a representation of the position in time when the process
+started or stopped running on a CPU
+
+**RESIDENCY SERIES**
+
+This series is a cumulative sum of the event series and
+is a representation of the continuous residency of the
+process on a CPU
+
+The pivot for the aggregators is the CPU on which the
+event occurred on. If N is the number of CPUs in the
+system, N signal for each CPU are generated. These signals
+can then be aggregated by specifying a Topology
+
+.. seealso:: :mod:`trappy.stats.Topology.Topology`
+"""
+
+import numpy as np
+from trappy.stats.Trigger import Trigger
+
+WINDOW_SIZE = 0.0001
+"""A control config for filter events. Some analyses
+may require ignoring of small interruptions"""
+
+# Trigger Values
+SCHED_SWITCH_IN = 1
+"""Value of the event when a task is **switch in**
+or scheduled on a CPU"""
+SCHED_SWITCH_OUT = -1
+"""Value of the event when a task is **switched out**
+or relinquishes a CPU"""
+NO_EVENT = 0
+"""Signifies no event on an event trace"""
+
+# Field Names
+CPU_FIELD = "__cpu"
+"""The column in the sched_switch event that
+indicates the CPU on which the event occurred
+"""
+NEXT_PID_FIELD = "next_pid"
+"""The column in the sched_switch event that
+indicates the PID of the next process to be scheduled
+"""
+PREV_PID_FIELD = "prev_pid"
+"""The column in the sched_switch event that
+indicates the PID of the process that was scheduled
+in
+"""
+TASK_RUNNING = 1
+"""The column in the sched_switch event that
+indicates the CPU on which the event occurred
+"""
+TASK_NOT_RUNNING = 0
+"""In a residency series, a zero indicates
+that the task is not running
+"""
+TIME_INVAL = -1
+"""Standard Value to indicate invalid time data"""
+SERIES_SANTIZED = "_sched_sanitized"
+"""A memoized flag which is set when an event series
+is checked for boundary conditions
+"""
+
+
+def sanitize_asymmetry(series, window=None):
+    """Sanitize the cases when a :code:`SWITCH_OUT`
+    happens before a :code:`SWITCH_IN`. (The case when
+    a process is already running before the trace started)
+
+    :param series: Input Time Series data
+    :type series: :mod:`pandas.Series`
+
+    :param window: A tuple indicating a time window
+    :type window: tuple
+    """
+
+    if not hasattr(series, SERIES_SANTIZED):
+
+        events = series[series != 0]
+        if len(series) >= 2 and len(events):
+            if series.values[0] == SCHED_SWITCH_OUT:
+                series.values[0] = TASK_NOT_RUNNING
+
+            elif events.values[0] == SCHED_SWITCH_OUT:
+                series.values[0] = SCHED_SWITCH_IN
+                if window:
+                    series.index.values[0] = window[0]
+
+            if series.values[-1] == SCHED_SWITCH_IN:
+                series.values[-1] = TASK_NOT_RUNNING
+
+            elif events.values[-1] == SCHED_SWITCH_IN:
+                series.values[-1] = SCHED_SWITCH_OUT
+                if window:
+                    series.index.values[-1] = window[1]
+
+        # No point if the series just has one value and
+        # one event. We do not have sufficient data points
+        # for any calculation. We should Ideally never reach
+        # here.
+        elif len(series) == 1:
+            series.values[0] = 0
+
+        setattr(series, SERIES_SANTIZED, True)
+
+    return series
+
+
+def csum(series, window=None, filter_gaps=False):
+    """:func:`aggfunc` for the cumulative sum of the
+    input series data
+
+    :param series: Input Time Series data
+    :type series: :mod:`pandas.Series`
+
+    :param window: A tuple indicating a time window
+    :type window: tuple
+
+    :param filter_gaps: If set, a process being switched out
+        for :mod:`bart.sched.functions.WINDOW_SIZE` is
+        ignored. This is helpful when small interruptions need
+        to be ignored to compare overall correlation
+    :type filter_gaps: bool
+    """
+
+    if filter_gaps:
+        series = filter_small_gaps(series)
+
+    series = series.cumsum()
+    return select_window(series, window)
+
+def filter_small_gaps(series):
+    """A helper function that does filtering of gaps
+    in residency series < :mod:`bart.sched.functions.WINDOW_SIZE`
+
+    :param series: Input Time Series data
+    :type series: :mod:`pandas.Series`
+    """
+
+    start = None
+    for index, value in series.iteritems():
+
+        if value == SCHED_SWITCH_IN:
+            if start == None:
+                continue
+
+            if index - start < WINDOW_SIZE:
+                series[start] = NO_EVENT
+                series[index] = NO_EVENT
+            start = None
+
+        if value == SCHED_SWITCH_OUT:
+            start = index
+
+    return series
+
+def first_cpu(series, window=None):
+    """:func:`aggfunc` to calculate the time of
+    the first switch in event in the series
+    This is returned as a vector of unit length
+    so that it can be aggregated and reduced across
+    nodes to find the first cpu of a task
+
+    :param series: Input Time Series data
+    :type series: :mod:`pandas.Series`
+
+    :param window: A tuple indicating a time window
+    :type window: tuple
+    """
+    series = select_window(series, window)
+    series = series[series == SCHED_SWITCH_IN]
+    if len(series):
+        return [series.index.values[0]]
+    else:
+        return [float("inf")]
+
+def last_cpu(series, window=None):
+    """:func:`aggfunc` to calculate the time of
+    the last switch out event in the series
+    This is returned as a vector of unit length
+    so that it can be aggregated and reduced across
+    nodes to find the last cpu of a task
+
+    :param series: Input Time Series data
+    :type series: :mod:`pandas.Series`
+
+    :param window: A tuple indicating a time window
+    :type window: tuple
+    """
+    series = select_window(series, window)
+    series = series[series == SCHED_SWITCH_OUT]
+
+    if len(series):
+        return [series.index.values[-1]]
+    else:
+        return [0]
+
+def select_window(series, window):
+    """Helper Function to select a portion of
+    pandas time series
+
+    :param series: Input Time Series data
+    :type series: :mod:`pandas.Series`
+
+    :param window: A tuple indicating a time window
+    :type window: tuple
+    """
+
+    if not window:
+        return series
+
+    start, stop = window
+    ix = series.index
+    selector = ((ix >= start) & (ix <= stop))
+    window_series = series[selector]
+    return window_series
+
+def residency_sum(series, window=None):
+    """:func:`aggfunc` to calculate the total
+    residency
+
+
+    The input series is processed for
+    intervals between a :mod:`bart.sched.functions.SCHED_SWITCH_OUT`
+    and :mod:`bart.sched.functions.SCHED_SWITCH_IN` to track
+    additive residency of a task
+
+    .. math::
+
+        S_{in} = i_{1}, i_{2}...i_{N} \\\\
+        S_{out} = o_{1}, o_{2}...o_{N} \\\\
+        R_{total} = \sum_{k}^{N}\Delta_k = \sum_{k}^{N}(o_{k} - i_{k})
+
+    :param series: Input Time Series data
+    :type series: :mod:`pandas.Series`
+
+    :param window: A tuple indicating a time window
+    :type window: tuple
+
+    :return: A scalar float value
+    """
+
+    if not len(series):
+        return 0.0
+
+    org_series = series
+    series = select_window(series, window)
+    series = sanitize_asymmetry(series, window)
+
+    s_in = series[series == SCHED_SWITCH_IN]
+    s_out = series[series == SCHED_SWITCH_OUT]
+
+    if not (len(s_in) and len(s_out)):
+        try:
+            org_series = sanitize_asymmetry(org_series)
+            running = select_window(org_series.cumsum(), window)
+            if running.values[0] == TASK_RUNNING and running.values[-1] == TASK_RUNNING:
+                return window[1] - window[0]
+        except Exception,e:
+            pass
+
+    if len(s_in) != len(s_out):
+        raise RuntimeError(
+            "Unexpected Lengths: s_in={}, s_out={}".format(
+                len(s_in),
+                len(s_out)))
+    else:
+        return np.sum(s_out.index.values - s_in.index.values)
+
+
+def first_time(series, value, window=None):
+    """:func:`aggfunc` to:
+
+    - Return the first index where the
+      series == value
+
+    - If no such index is found
+      +inf is returned
+
+    :param series: Input Time Series data
+    :type series: :mod:`pandas.Series`
+
+    :param window: A tuple indicating a time window
+    :type window: tuple
+
+    :return: A vector of Unit Length
+    """
+
+    series = select_window(series, window)
+    series = series[series == value]
+
+    if not len(series):
+        return [float("inf")]
+
+    return [series.index.values[0]]
+
+
+def period(series, align="start", window=None):
+    """This :func:`aggfunc` returns a tuple
+    of the average duration between two triggers:
+
+        - When :code:`align=start` the :code:`SCHED_IN`
+          trigger is used
+
+        - When :code:`align=end` the :code:`SCHED_OUT`
+          trigger is used
+
+
+    .. math::
+
+        E = e_{1}, e_{2}...e_{N} \\\\
+        T_p = \\frac{\sum_{j}^{\lfloor N/2 \\rfloor}(e_{2j + 1} - e_{2j})}{N}
+
+    :param series: Input Time Series data
+    :type series: :mod:`pandas.Series`
+
+    :param window: A tuple indicating a time window
+    :type window: tuple
+
+    :return:
+        A list of deltas of successive starts/stops
+        of a task
+
+    """
+
+    series = select_window(series, window)
+    series = sanitize_asymmetry(series, window)
+
+    if align == "start":
+        series = series[series == SCHED_SWITCH_IN]
+    elif align == "end":
+        series = series[series == SCHED_SWITCH_OUT]
+
+    if len(series) % 2 == 0:
+        series = series[:1]
+
+    if not len(series):
+        return []
+
+    return list(np.diff(series.index.values))
+
+def last_time(series, value, window=None):
+    """:func:`aggfunc` to:
+
+    - The first index where the
+      series == value
+
+    - If no such index is found
+      :mod:`bart.sched.functions.TIME_INVAL`
+      is returned
+
+    :param series: Input Time Series data
+    :type series: :mod:`pandas.Series`
+
+    :param window: A tuple indicating a time window
+    :type window: tuple
+
+    :return: A vector of Unit Length
+    """
+
+    series = select_window(series, window)
+    series = series[series == value]
+    if not len(series):
+        return [TIME_INVAL]
+
+    return [series.index.values[-1]]
+
+
+def binary_correlate(series_x, series_y):
+    """Helper function to Correlate binary Data
+
+    Both the series should have same indices
+
+    For binary time series data:
+
+    .. math::
+
+        \\alpha_{corr} = \\frac{N_{agree} - N_{disagree}}{N}
+
+    :param series_x: First time Series data
+    :type series_x: :mod:`pandas.Series`
+
+    :param series_y: Second time Series data
+    :type series_y: :mod:`pandas.Series`
+    """
+
+    if len(series_x) != len(series_y):
+        raise ValueError("Cannot compute binary correlation for \
+                          unequal vectors")
+
+    agree = len(series_x[series_x == series_y])
+    disagree = len(series_x[series_x != series_y])
+
+    return (agree - disagree) / float(len(series_x))
+
+def get_pids_for_process(ftrace, execname, cls=None):
+    """Get the PIDs for a given process
+
+    :param ftrace: A ftrace object with a sched_switch
+        event
+    :type ftrace: :mod:`trappy.ftrace.FTrace`
+
+    :param execname: The name of the process
+    :type execname: str
+
+    :param cls: The SchedSwitch event class (required if
+        a different event is to be used)
+    :type cls: :mod:`trappy.base.Base`
+
+    :return: The set of PIDs for the execname
+    """
+
+    if not cls:
+        try:
+            df = ftrace.sched_switch.data_frame
+        except AttributeError:
+            raise ValueError("SchedSwitch event not found in ftrace")
+
+        if len(df) == 0:
+            raise ValueError("SchedSwitch event not found in ftrace")
+    else:
+        event = getattr(ftrace, cls.name)
+        df = event.data_frame
+
+    mask = df["next_comm"].apply(lambda x : True if x == execname else False)
+    return list(np.unique(df[mask]["next_pid"].values))
+
+def get_task_name(ftrace, pid, cls=None):
+    """Returns the execname for pid
+
+    :param ftrace: A ftrace object with a sched_switch
+        event
+    :type ftrace: :mod:`trappy.ftrace.FTrace`
+
+    :param pid: The PID of the process
+    :type pid: int
+
+    :param cls: The SchedSwitch event class (required if
+        a different event is to be used)
+    :type cls: :mod:`trappy.base.Base`
+
+    :return: The execname for the PID
+    """
+
+    if not cls:
+        try:
+            df = ftrace.sched_switch.data_frame
+        except AttributeError:
+           raise ValueError("SchedSwitch event not found in ftrace")
+    else:
+        event = getattr(ftrace, cls.name)
+        df = event.data_frame
+
+    df = df[df["next_pid"] == pid]
+    if not len(df):
+        return ""
+    else:
+        return df["next_comm"].values[0]
+
+def sched_triggers(ftrace, pid, sched_switch_class):
+    """Returns the list of sched_switch triggers
+
+    :param ftrace: A ftrace object with a sched_switch
+        event
+    :type ftrace: :mod:`trappy.ftrace.FTrace`
+
+    :param pid: The PID of the associated process
+    :type pid: int
+
+    :param sched_switch_class: The SchedSwitch event class
+    :type sched_switch_class: :mod:`trappy.base.Base`
+
+    :return: List of triggers, such that
+        ::
+
+            triggers[0] = switch_in_trigger
+            triggers[1] = switch_out_trigger
+    """
+
+    if not hasattr(ftrace, "sched_switch"):
+        raise ValueError("SchedSwitch event not found in ftrace")
+
+    triggers = []
+    triggers.append(sched_switch_in_trigger(ftrace, pid, sched_switch_class))
+    triggers.append(sched_switch_out_trigger(ftrace, pid, sched_switch_class))
+    return triggers
+
+def sched_switch_in_trigger(ftrace, pid, sched_switch_class):
+    """
+    :param ftrace: A ftrace object with a sched_switch
+        event
+    :type ftrace: :mod:`trappy.ftrace.FTrace`
+
+    :param pid: The PID of the associated process
+    :type pid: int
+
+    :param sched_switch_class: The SchedSwitch event class
+    :type sched_switch_class: :mod:`trappy.base.Base`
+
+    :return: :mod:`trappy.stats.Trigger.Trigger` on
+        the SchedSwitch: IN for the given PID
+    """
+
+    task_in = {}
+    task_in[NEXT_PID_FIELD] = pid
+
+    return Trigger(ftrace,
+                   sched_switch_class,              # trappy Event Class
+                   task_in,                         # Filter Dictionary
+                   SCHED_SWITCH_IN,                 # Trigger Value
+                   CPU_FIELD)                       # Primary Pivot
+
+def sched_switch_out_trigger(ftrace, pid, sched_switch_class):
+    """
+    :param ftrace: A ftrace object with a sched_switch
+        event
+    :type ftrace: :mod:`trappy.ftrace.FTrace`
+
+    :param pid: The PID of the associated process
+    :type pid: int
+
+    :param sched_switch_class: The SchedSwitch event class
+    :type sched_switch_class: :mod:`trappy.base.Base`
+
+    :return: :mod:`trappy.stats.Trigger.Trigger` on
+        the SchedSwitch: OUT for the given PID
+    """
+
+    task_out = {}
+    task_out[PREV_PID_FIELD] = pid
+
+    return Trigger(ftrace,
+                   sched_switch_class,              # trappy Event Class
+                   task_out,                        # Filter Dictionary
+                   SCHED_SWITCH_OUT,                # Trigger Value
+                   CPU_FIELD)                       # Primary Pivot
+
+
+def trace_event(series, window=None):
+    """
+    :func:`aggfunc` to be used for plotting
+    the process residency data using
+    :mod:`trappy.plotter.EventPlot`
+
+    :param series: Input Time Series data
+    :type series: :mod:`pandas.Series`
+
+    :param window: A tuple indicating a time window
+    :type window: tuple
+
+    :return: A list of events
+        of the type:
+        ::
+
+            [
+                [start_time_1, stop_time_1],
+                [start_time_2, stop_time_2],
+                #
+                #
+                [start_time_N, stop_time_N],
+            ]
+    """
+    rects = []
+    series = select_window(series, window)
+    series = sanitize_asymmetry(series, window)
+
+    s_in = series[series == SCHED_SWITCH_IN]
+    s_out = series[series == SCHED_SWITCH_OUT]
+
+    if not len(s_in):
+        return rects
+
+    if len(s_in) != len(s_out):
+        raise RuntimeError(
+            "Unexpected Lengths: s_in={}, s_out={}".format(
+                len(s_in),
+                len(s_out)))
+
+    return np.column_stack((s_in.index.values, s_out.index.values))
diff --git a/bart/thermal/ThermalAssert.py b/bart/thermal/ThermalAssert.py
new file mode 100644
index 0000000..d0ffa78
--- /dev/null
+++ b/bart/thermal/ThermalAssert.py
@@ -0,0 +1,135 @@
+#    Copyright 2015-2016 ARM Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""A thermal specific library to assert certain thermal
+behaviours
+"""
+
+from bart.common import Utils
+from bart.common.Analyzer import Analyzer
+import numpy as np
+
+
+# pylint: disable=invalid-name
+# pylint: disable=too-many-arguments
+class ThermalAssert(object):
+
+    """A class that accepts a TRAPpy FTrace object and
+    provides assertions for thermal behaviours
+
+    :param ftrace: A path to the trace file or a TRAPpy FTrace object
+    :type ftrace: str, :mod:`trappy.ftrace.FTrace`
+    """
+
+    def __init__(self, ftrace, config=None):
+
+        self._ftrace = Utils.init_ftrace(ftrace)
+        self._analyzer = Analyzer(self._ftrace, config)
+
+    def getThermalResidency(self, temp_range, window, percent=False):
+        """Return the total time spent in a given temperature range
+
+        :param temp_range: A tuple of (low_temp, high_temp)
+            which specifies the range of temperature that
+            one intends to calculate the residency for.
+        :type temp_range: tuple
+
+        :param window: A (start, end) tuple to limit the scope of the
+            residency calculation.
+        :type window: tuple
+
+        :param percent: Returns the residency as a percentage of the total
+            duration of the trace
+        :type percent: bool
+
+        .. seealso:
+
+            :mod:`bart.thermal.ThermalAssert.ThermalAssert.assertThermalResidency`
+        """
+
+        # Get a pivoted thermal temperature data using the grammar
+        data = self._analyzer.getStatement("trappy.thermal.Thermal:temp")
+
+        result = {}
+        for pivot, data_frame in data.groupby(axis=1, level=0):
+
+            series = data_frame[pivot]
+            series = Utils.select_window(series, window)
+            mask = (series >= temp_range[0]) & (series <= temp_range[1])
+            index = series.index.values
+            # pylint fails to recognize numpy members.
+            # pylint: disable=no-member
+            shift_index = np.roll(index, 1)
+            # pylint: enable=no-member
+            shift_index[0] = 0
+
+            result[pivot] = sum((index - shift_index)[mask.values])
+
+            if percent:
+                result[pivot] = (
+                    result[pivot] * 100.0) / self._ftrace.get_duration()
+
+        return result
+
+    def assertThermalResidency(
+            self,
+            expected_value,
+            operator,
+            temp_range,
+            window,
+            percent=False):
+        """
+        :param expected_value: The expected value of the residency
+        :type expected_value: double
+
+        :param operator: A binary operator function that returns
+            a boolean. For example:
+            ::
+
+                import operator
+                op = operator.ge
+                assertThermalResidency(temp_range, expected_value, op)
+
+            Will do the following check:
+            ::
+
+                getThermalResidency(temp_range) >= expected_value
+
+            A custom function can also be passed:
+            ::
+
+                THRESHOLD=5
+                def between_threshold(a, expected):
+                    return abs(a - expected) <= THRESHOLD
+
+        :param temp_range: A tuple of (low_temp, high_temp)
+            which specifies the range of temperature that
+            one intends to calculate the residency for.
+        :type temp_range: tuple
+
+        :param window: A (start, end) tuple to limit the scope of the
+            residency calculation.
+        :type window: tuple
+
+        :param percent: Returns the residency as a percentage of the total
+            duration of the trace
+        :type percent: bool
+
+        .. seealso:
+
+            :mod:`bart.thermal.ThermalAssert.ThermalAssert.assertThermalResidency`
+        """
+
+        residency = self.getThermalResidency(temp_range, window, percent)
+        return operator(residency, expected_value)
diff --git a/bart/thermal/__init__.py b/bart/thermal/__init__.py
new file mode 100644
index 0000000..6eefbc2
--- /dev/null
+++ b/bart/thermal/__init__.py
@@ -0,0 +1,19 @@
+#    Copyright 2015-2016 ARM Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""Initialization for bart.thermal"""
+
+
+import bart.thermal.ThermalAssert
diff --git a/bart/version.py b/bart/version.py
new file mode 100644
index 0000000..c071e8d
--- /dev/null
+++ b/bart/version.py
@@ -0,0 +1,16 @@
+#    Copyright 2016-2016 ARM Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+__version__ = "1.8.0"
diff --git a/docs/api_reference/.gitignore b/docs/api_reference/.gitignore
new file mode 100644
index 0000000..588039e
--- /dev/null
+++ b/docs/api_reference/.gitignore
@@ -0,0 +1,3 @@
+_build
+*.rst
+!index.rst
diff --git a/docs/api_reference/Makefile b/docs/api_reference/Makefile
new file mode 100644
index 0000000..f7c61a3
--- /dev/null
+++ b/docs/api_reference/Makefile
@@ -0,0 +1,196 @@
+# Makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+PAPER         =
+BUILDDIR      = _build
+
+# User-friendly check for sphinx-build
+ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1)
+$(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/)
+endif
+
+# Internal variables.
+PAPEROPT_a4     = -D latex_paper_size=a4
+PAPEROPT_letter = -D latex_paper_size=letter
+ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+# the i18n builder cannot share the environment and doctrees with the others
+I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+
+.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest coverage gettext
+
+help:
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo "  html       to make standalone HTML files"
+	@echo "  dirhtml    to make HTML files named index.html in directories"
+	@echo "  singlehtml to make a single large HTML file"
+	@echo "  pickle     to make pickle files"
+	@echo "  json       to make JSON files"
+	@echo "  htmlhelp   to make HTML files and a HTML help project"
+	@echo "  qthelp     to make HTML files and a qthelp project"
+	@echo "  applehelp  to make an Apple Help Book"
+	@echo "  devhelp    to make HTML files and a Devhelp project"
+	@echo "  epub       to make an epub"
+	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
+	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
+	@echo "  latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
+	@echo "  text       to make text files"
+	@echo "  man        to make manual pages"
+	@echo "  texinfo    to make Texinfo files"
+	@echo "  info       to make Texinfo files and run them through makeinfo"
+	@echo "  gettext    to make PO message catalogs"
+	@echo "  changes    to make an overview of all changed/added/deprecated items"
+	@echo "  xml        to make Docutils-native XML files"
+	@echo "  pseudoxml  to make pseudoxml-XML files for display purposes"
+	@echo "  linkcheck  to check all external links for integrity"
+	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
+	@echo "  coverage   to run coverage check of the documentation (if enabled)"
+
+clean:
+	rm -rf $(BUILDDIR)/*
+	ls *.rst | grep -v index.rst | xargs rm -f
+
+reference:
+	sphinx-apidoc -f -e -o . ../../bart
+
+html: reference
+	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
+
+dirhtml: reference
+	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
+
+singlehtml: reference
+	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
+	@echo
+	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
+
+pickle: reference
+	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
+	@echo
+	@echo "Build finished; now you can process the pickle files."
+
+json: reference
+	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
+	@echo
+	@echo "Build finished; now you can process the JSON files."
+
+htmlhelp: reference
+	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
+	@echo
+	@echo "Build finished; now you can run HTML Help Workshop with the" \
+	      ".hhp project file in $(BUILDDIR)/htmlhelp."
+
+qthelp: reference
+	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
+	@echo
+	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
+	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
+	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/BART.qhcp"
+	@echo "To view the help file:"
+	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/BART.qhc"
+
+applehelp: reference
+	$(SPHINXBUILD) -b applehelp $(ALLSPHINXOPTS) $(BUILDDIR)/applehelp
+	@echo
+	@echo "Build finished. The help book is in $(BUILDDIR)/applehelp."
+	@echo "N.B. You won't be able to view it unless you put it in" \
+	      "~/Library/Documentation/Help or install it in your application" \
+	      "bundle."
+
+devhelp: reference
+	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
+	@echo
+	@echo "Build finished."
+	@echo "To view the help file:"
+	@echo "# mkdir -p $$HOME/.local/share/devhelp/BART"
+	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/BART"
+	@echo "# devhelp"
+
+epub: reference
+	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
+	@echo
+	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
+
+latex: reference
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo
+	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
+	@echo "Run \`make' in that directory to run these through (pdf)latex" \
+	      "(use \`make latexpdf' here to do that automatically)."
+
+latexpdf: reference
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through pdflatex..."
+	$(MAKE) -C $(BUILDDIR)/latex all-pdf
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+latexpdfja: reference
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through platex and dvipdfmx..."
+	$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+text: reference
+	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
+	@echo
+	@echo "Build finished. The text files are in $(BUILDDIR)/text."
+
+man: reference
+	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
+	@echo
+	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
+
+texinfo: reference
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo
+	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
+	@echo "Run \`make' in that directory to run these through makeinfo" \
+	      "(use \`make info' here to do that automatically)."
+
+info: reference
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo "Running Texinfo files through makeinfo..."
+	make -C $(BUILDDIR)/texinfo info
+	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
+
+gettext: reference
+	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
+	@echo
+	@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
+
+changes: reference
+	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
+	@echo
+	@echo "The overview file is in $(BUILDDIR)/changes."
+
+linkcheck: reference
+	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
+	@echo
+	@echo "Link check complete; look for any errors in the above output " \
+	      "or in $(BUILDDIR)/linkcheck/output.txt."
+
+doctest: reference
+	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
+	@echo "Testing of doctests in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/doctest/output.txt."
+
+coverage: reference
+	$(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage
+	@echo "Testing of coverage in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/coverage/python.txt."
+
+xml: reference
+	$(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
+	@echo
+	@echo "Build finished. The XML files are in $(BUILDDIR)/xml."
+
+pseudoxml: reference
+	$(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
+	@echo
+	@echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."
diff --git a/docs/api_reference/conf.py b/docs/api_reference/conf.py
new file mode 100644
index 0000000..32d6653
--- /dev/null
+++ b/docs/api_reference/conf.py
@@ -0,0 +1,381 @@
+# -*- coding: utf-8 -*-
+#    Copyright 2015-2016 ARM Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# BART documentation build configuration file, created by
+# sphinx-quickstart on Fri Sep  4 11:30:35 2015.
+#
+# This file is execfile()d with the current directory set to its
+# containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+import sys
+import os
+import shlex
+
+this_dir = os.path.dirname(__file__)
+sys.path.insert(0, os.path.join(this_dir, '../..'))
+import bart
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#sys.path.insert(0, os.path.abspath('.'))
+
+# -- General configuration ------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx.ext.todo',
+    'sphinx.ext.coverage',
+    'sphinx.ext.mathjax',
+    'sphinx.ext.ifconfig',
+    'sphinx.ext.viewcode']
+
+# Update MathJax path to use the cdnjs using HTTPS
+mathjax_path = "https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+# source_suffix = ['.rst', '.md']
+source_suffix = '.rst'
+
+# The encoding of source files.
+#source_encoding = 'utf-8-sig'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+project = u'BART'
+copyright = u'2016, ARM Ltd.'
+author = u'Kapileshwar Singh(KP), Javi Merino'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version. Drop everything after the last "."
+version = bart.__version__[:bart.__version__.rindex(".")]
+# The full version, including alpha/beta/rc tags.
+release = bart.__version__
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these cases.
+language = 'en'
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+#today = ''
+# Else, today_fmt is used as the format for a strftime call.
+#today_fmt = '%B %d, %Y'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+exclude_patterns = ['_build']
+
+# The reST default role (used for this markup: `text`) to use for all
+# documents.
+#default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+#add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+#add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+#show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# A list of ignored prefixes for module index sorting.
+#modindex_common_prefix = []
+
+# If true, keep warnings as "system message" paragraphs in the built documents.
+#keep_warnings = False
+
+# If true, `todo` and `todoList` produce output, else they produce nothing.
+todo_include_todos = True
+
+
+# -- Options for HTML output ----------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+html_theme = 'classic'
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#html_theme_options = {}
+
+# Add any paths that contain custom themes here, relative to this directory.
+#html_theme_path = []
+
+# The name for this set of Sphinx documents.  If None, it defaults to
+# "<project> v<release> documentation".
+#html_title = None
+
+# A shorter title for the navigation bar.  Default is the same as html_title.
+#html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+#html_logo = None
+
+# The name of an image file (within the static path) to use as favicon of the
+# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+#html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+
+# Add any extra paths that contain custom files (such as robots.txt or
+# .htaccess) here, relative to this directory. These files are copied
+# directly to the root of the documentation.
+#html_extra_path = []
+
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+# using the given strftime format.
+#html_last_updated_fmt = '%b %d, %Y'
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+#html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+#html_sidebars = {}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+#html_additional_pages = {}
+
+# If false, no module index is generated.
+#html_domain_indices = True
+
+# If false, no index is generated.
+#html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+#html_split_index = False
+
+# If true, links to the reST sources are added to the pages.
+#html_show_sourcelink = True
+
+# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
+#html_show_sphinx = True
+
+# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
+#html_show_copyright = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+#html_use_opensearch = ''
+
+# This is the file name suffix for HTML files (e.g. ".xhtml").
+#html_file_suffix = None
+
+# Language to be used for generating the HTML full-text search index.
+# Sphinx supports the following languages:
+#   'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
+#   'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr'
+#html_search_language = 'en'
+
+# A dictionary with options for the search language support, empty by default.
+# Now only 'ja' uses this config value
+#html_search_options = {'type': 'default'}
+
+# The name of a javascript file (relative to the configuration directory) that
+# implements a search results scorer. If empty, the default will be used.
+#html_search_scorer = 'scorer.js'
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'BARTdoc'
+
+# -- Options for LaTeX output ---------------------------------------------
+
+latex_elements = {
+# The paper size ('letterpaper' or 'a4paper').
+#'papersize': 'letterpaper',
+
+# The font size ('10pt', '11pt' or '12pt').
+#'pointsize': '10pt',
+
+# Additional stuff for the LaTeX preamble.
+#'preamble': '',
+
+# Latex figure (float) alignment
+#'figure_align': 'htbp',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+#  author, documentclass [howto, manual, or own class]).
+latex_documents = [
+  (master_doc, 'BART.tex', u'BART Documentation',
+   u'Kapileshwar Singh(KP), Javi Merino', 'manual'),
+]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page.
+#latex_logo = None
+
+# For "manual" documents, if this is true, then toplevel headings are parts,
+# not chapters.
+#latex_use_parts = False
+
+# If true, show page references after internal links.
+#latex_show_pagerefs = False
+
+# If true, show URL addresses after external links.
+#latex_show_urls = False
+
+# Documents to append as an appendix to all manuals.
+#latex_appendices = []
+
+# If false, no module index is generated.
+#latex_domain_indices = True
+
+
+# -- Options for manual page output ---------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+    (master_doc, 'bart', u'BART Documentation',
+     [author], 1)
+]
+
+# If true, show URL addresses after external links.
+#man_show_urls = False
+
+
+# -- Options for Texinfo output -------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+  (master_doc, 'BART', u'BART Documentation',
+   author, 'BART', 'One line description of project.',
+   'Miscellaneous'),
+]
+
+# Documents to append as an appendix to all manuals.
+#texinfo_appendices = []
+
+# If false, no module index is generated.
+#texinfo_domain_indices = True
+
+# How to display URL addresses: 'footnote', 'no', or 'inline'.
+#texinfo_show_urls = 'footnote'
+
+# If true, do not generate a @detailmenu in the "Top" node's menu.
+#texinfo_no_detailmenu = False
+
+
+# -- Options for Epub output ----------------------------------------------
+
+# Bibliographic Dublin Core info.
+epub_title = project
+epub_author = author
+epub_publisher = author
+epub_copyright = copyright
+
+# The basename for the epub file. It defaults to the project name.
+#epub_basename = project
+
+# The HTML theme for the epub output. Since the default themes are not optimized
+# for small screen space, using the same theme for HTML and epub output is
+# usually not wise. This defaults to 'epub', a theme designed to save visual
+# space.
+#epub_theme = 'epub'
+
+# The language of the text. It defaults to the language option
+# or 'en' if the language is not set.
+#epub_language = ''
+
+# The scheme of the identifier. Typical schemes are ISBN or URL.
+#epub_scheme = ''
+
+# The unique identifier of the text. This can be a ISBN number
+# or the project homepage.
+#epub_identifier = ''
+
+# A unique identification for the text.
+#epub_uid = ''
+
+# A tuple containing the cover image and cover page html template filenames.
+#epub_cover = ()
+
+# A sequence of (type, uri, title) tuples for the guide element of content.opf.
+#epub_guide = ()
+
+# HTML files that should be inserted before the pages created by sphinx.
+# The format is a list of tuples containing the path and title.
+#epub_pre_files = []
+
+# HTML files shat should be inserted after the pages created by sphinx.
+# The format is a list of tuples containing the path and title.
+#epub_post_files = []
+
+# A list of files that should not be packed into the epub file.
+epub_exclude_files = ['search.html']
+
+# The depth of the table of contents in toc.ncx.
+#epub_tocdepth = 3
+
+# Allow duplicate toc entries.
+#epub_tocdup = True
+
+# Choose between 'default' and 'includehidden'.
+#epub_tocscope = 'default'
+
+# Fix unsupported image types using the Pillow.
+#epub_fix_images = False
+
+# Scale large images.
+#epub_max_image_width = 0
+
+# How to display URL addresses: 'footnote', 'no', or 'inline'.
+#epub_show_urls = 'inline'
+
+# If false, no index is generated.
+#epub_use_index = True
diff --git a/docs/api_reference/index.rst b/docs/api_reference/index.rst
new file mode 100644
index 0000000..f21d055
--- /dev/null
+++ b/docs/api_reference/index.rst
@@ -0,0 +1,22 @@
+.. BART documentation master file, created by
+   sphinx-quickstart on Fri Sep  4 12:40:17 2015.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+Welcome to BART's documentation!
+==================================
+
+Contents:
+
+.. toctree::
+   :maxdepth: 4
+
+   bart
+
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`
diff --git a/docs/examples/thermal.py b/docs/examples/thermal.py
new file mode 100644
index 0000000..8fe3e95
--- /dev/null
+++ b/docs/examples/thermal.py
@@ -0,0 +1,87 @@
+#    Copyright 2015-2016 ARM Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""
+An example file for usage of Analyzer for thermal assertions
+"""
+from bart.common.Analyzer import Analyzer
+from trappy.stats.Topology import Topology
+import unittest
+import trappy
+
+
+class TestThermal(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        # We can run a workload invocation script here
+        # Which then copies the required traces for analysis to
+        # the host.
+        trace_file = "update_a_trace_path_here"
+        ftrace = trappy.FTrace(trace_file, "test_run")
+
+        # Define the parameters that you intend to use in the grammar
+        config = {}
+        config["THERMAL"] = trappy.thermal.Thermal
+        config["OUT"] = trappy.cpu_power.CpuOutPower
+        config["IN"] = trappy.cpu_power.CpuInPower
+        config["PID"] = trappy.pid_controller.PIDController
+        config["GOVERNOR"] = trappy.thermal.ThermalGovernor
+        config["CONTROL_TEMP"] = 77000
+        config["SUSTAINABLE_POWER"] = 2500
+        config["EXPECTED_TEMP_QRT"] = 95
+        config["EXPECTED_STD_PCT"] = 5
+
+        # Define a Topology
+        cls.BIG = '000000f0'
+        cls.LITTLE = '0000000f'
+        cls.tz = 0
+        cls.analyzer = Analyzer(ftrace, config)
+
+    def test_temperature_quartile(self):
+        """Assert Temperature quartile"""
+
+        self.assertTrue(self.analyzer.assertStatement(
+            "numpy.percentile(THERMAL:temp, EXPECTED_TEMP_QRT) < (CONTROL_TEMP + 5000)"))
+
+    def test_average_temperature(self):
+        """Assert Average temperature"""
+
+        self.assertTrue(self.analyzer.assertStatement(
+            "numpy.mean(THERMAL:temp) < CONTROL_TEMP", select=self.tz))
+
+    def test_temp_stdev(self):
+        """Assert StdDev(temp) as % of mean"""
+
+        self.assertTrue(self.analyzer.assertStatement(
+            "(numpy.std(THERMAL:temp) * 100.0) / numpy.mean(THERMAL:temp)\
+             < EXPECTED_STD_PCT", select=self.tz))
+
+    def test_zero_load_input_power(self):
+        """Test power demand when load is zero"""
+
+        zero_load_power_big = self.analyzer.getStatement("((IN:load0 + IN:load1 + IN:load2 + IN:load3) == 0) \
+                                                     & (IN:dynamic_power > 0)", reference=True, select=self.BIG)
+        self.assertEquals(len(zero_load_power_big), 0)
+
+        zero_load_power_little = self.analyzer.getStatement("((IN:load0 + IN:load1 + IN:load2 + IN:load3) == 0) \
+                                                     & (IN:dynamic_power > 0)", reference=True, select=self.LITTLE)
+        self.assertEquals(len(zero_load_power_little), 0)
+
+    def test_sustainable_power(self):
+        """temp > control_temp, allocated_power < sustainable_power"""
+
+        self.analyzer.getStatement("(GOVERNOR:current_temperature > CONTROL_TEMP) &\
+            (PID:output > SUSTAINABLE_POWER)", reference=True, select=0)
diff --git a/docs/notebooks/sched/SchedDeadline.ipynb b/docs/notebooks/sched/SchedDeadline.ipynb
new file mode 100644
index 0000000..95cd0e2
--- /dev/null
+++ b/docs/notebooks/sched/SchedDeadline.ipynb
@@ -0,0 +1,648 @@
+{
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 2",
+   "language": "python",
+   "name": "python2"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.9"
+  },
+  "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Setup"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "from trappy.stats.Topology import Topology\n",
+      "from bart.sched.SchedMultiAssert import SchedMultiAssert\n",
+      "from bart.sched.SchedAssert import SchedAssert\n",
+      "import trappy\n",
+      "import os\n",
+      "import operator\n",
+      "import json\n",
+      "\n",
+      "#Define a CPU Topology (for multi-cluster systems)\n",
+      "BIG = [1, 2]\n",
+      "LITTLE = [0, 3, 4, 5]\n",
+      "CLUSTERS = [BIG, LITTLE]\n",
+      "topology = Topology(clusters=CLUSTERS)\n",
+      "\n",
+      "BASE_PATH = \"/Users/kapileshwarsingh/AnalysisRawData/LPC/sched_deadline/\"\n",
+      "\n",
+      "THRESHOLD = 10.0\n",
+      "def between_threshold(a, b):\n",
+      "    return abs(((a - b) * 100.0) / b) < THRESHOLD"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [],
+     "prompt_number": 3
+    },
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Periodic Yield"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "The thread periodic_yeild is woken up at 30ms intervals where it calls sched_yield and relinquishes its time-slice.\n",
+      "The expectation is that the task will have a duty cycle < 1% and a period of 30ms.\n",
+      "\n",
+      "There are two threads, and the rank=1 conveys that the condition is true for one of the threads with the name \"periodic_yeild\"\n"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "TRACE_FILE = os.path.join(BASE_PATH, \"yield\")\n",
+      "ftrace = trappy.FTrace(TRACE_FILE, \"cpuhog\")\n",
+      "\n",
+      "# Assert Period\n",
+      "s = SchedMultiAssert(ftrace, topology, execnames=\"periodic_yield\")\n",
+      "if s.assertPeriod(30, between_threshold, rank=1):\n",
+      "    print \"PASS: Period\"\n",
+      "    print json.dumps(s.getPeriod(), indent=3)\n",
+      "\n",
+      "print \"\"\n",
+      "    \n",
+      "# Assert DutyCycle    \n",
+      "if s.assertDutyCycle(1, operator.lt, window=(0,4), rank=2):\n",
+      "    print \"PASS: DutyCycle\"\n",
+      "    print json.dumps(s.getDutyCycle(window=(0,4)), indent=3)"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "PASS: Period\n",
+        "{\n",
+        "   \"1844\": {\n",
+        "      \"period\": 1.0085000000401578, \n",
+        "      \"task_name\": \"periodic_yield\"\n",
+        "   }, \n",
+        "   \"1845\": {\n",
+        "      \"period\": 29.822017857142669, \n",
+        "      \"task_name\": \"periodic_yield\"\n",
+        "   }\n",
+        "}\n",
+        "\n",
+        "PASS: DutyCycle\n",
+        "{\n",
+        "   \"1844\": {\n",
+        "      \"task_name\": \"periodic_yield\", \n",
+        "      \"dutycycle\": 0.074749999998857675\n",
+        "   }, \n",
+        "   \"1845\": {\n",
+        "      \"task_name\": \"periodic_yield\", \n",
+        "      \"dutycycle\": 0.03862499999343072\n",
+        "   }\n",
+        "}\n"
+       ]
+      }
+     ],
+     "prompt_number": 10
+    },
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "CPU Hog"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "The reservation of a CPU hogging task is set to 10ms for every 100ms. The assertion ensures a duty cycle of 10%"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "TRACE_FILE = os.path.join(BASE_PATH, \"cpuhog\")\n",
+      "ftrace = trappy.FTrace(TRACE_FILE, \"cpuhog\")\n",
+      "s = SchedMultiAssert(ftrace, topology, execnames=\"cpuhog\")\n",
+      "s.plot().view()\n",
+      "\n",
+      "# Assert DutyCycle\n",
+      "if s.assertDutyCycle(10, between_threshold, window=(0, 5), rank=1):\n",
+      "    print \"PASS: DutyCycle\"\n",
+      "    print json.dumps(s.getDutyCycle(window=(0, 5)), indent=3)"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "html": [
+        "<style>\n",
+        "/*\n",
+        "\n",
+        " *    Copyright 2015-2015 ARM Limited\n",
+        "\n",
+        " *\n",
+        "\n",
+        " * Licensed under the Apache License, Version 2.0 (the \"License\");\n",
+        "\n",
+        " * you may not use this file except in compliance with the License.\n",
+        "\n",
+        " * You may obtain a copy of the License at\n",
+        "\n",
+        " *\n",
+        "\n",
+        " *     http://www.apache.org/licenses/LICENSE-2.0\n",
+        "\n",
+        " *\n",
+        "\n",
+        " * Unless required by applicable law or agreed to in writing, software\n",
+        "\n",
+        " * distributed under the License is distributed on an \"AS IS\" BASIS,\n",
+        "\n",
+        " * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
+        "\n",
+        " * See the License for the specific language governing permissions and\n",
+        "\n",
+        " * limitations under the License.\n",
+        "\n",
+        " */\n",
+        "\n",
+        "\n",
+        "\n",
+        ".d3-tip {\n",
+        "\n",
+        "  line-height: 1;\n",
+        "\n",
+        "  padding: 12px;\n",
+        "\n",
+        "  background: rgba(0, 0, 0, 0.6);\n",
+        "\n",
+        "  color: #fff;\n",
+        "\n",
+        "  border-radius: 2px;\n",
+        "\n",
+        "  position: absolute !important;\n",
+        "\n",
+        "  z-index: 99999;\n",
+        "\n",
+        "}\n",
+        "\n",
+        "\n",
+        "\n",
+        ".d3-tip:after {\n",
+        "\n",
+        "  box-sizing: border-box;\n",
+        "\n",
+        "  pointer-events: none;\n",
+        "\n",
+        "  display: inline;\n",
+        "\n",
+        "  font-size: 10px;\n",
+        "\n",
+        "  width: 100%;\n",
+        "\n",
+        "  line-height: 1;\n",
+        "\n",
+        "  color: rgba(0, 0, 0, 0.6);\n",
+        "\n",
+        "  content: \"\\25BC\";\n",
+        "\n",
+        "  position: absolute !important;\n",
+        "\n",
+        "  z-index: 99999;\n",
+        "\n",
+        "  text-align: center;\n",
+        "\n",
+        "}\n",
+        "\n",
+        "\n",
+        "\n",
+        ".d3-tip.n:after {\n",
+        "\n",
+        "  margin: -1px 0 0 0;\n",
+        "\n",
+        "  top: 100%;\n",
+        "\n",
+        "  left: 0;\n",
+        "\n",
+        "}\n",
+        "\n",
+        "\n",
+        "\n",
+        ".chart {\n",
+        "\n",
+        "  shape-rendering: crispEdges;\n",
+        "\n",
+        "}\n",
+        "\n",
+        "\n",
+        "\n",
+        ".mini text {\n",
+        "\n",
+        "  font: 9px sans-serif;\n",
+        "\n",
+        "}\n",
+        "\n",
+        "\n",
+        "\n",
+        ".main text {\n",
+        "\n",
+        "  font: 12px sans-serif;\n",
+        "\n",
+        "}\n",
+        "\n",
+        "\n",
+        "\n",
+        ".axis line, .axis path {\n",
+        "\n",
+        "  stroke: black;\n",
+        "\n",
+        "}\n",
+        "\n",
+        "\n",
+        "\n",
+        ".miniItem {\n",
+        "\n",
+        "  stroke-width: 8;\n",
+        "\n",
+        "}\n",
+        "\n",
+        "\n",
+        "\n",
+        ".brush .extent {\n",
+        "\n",
+        "\n",
+        "\n",
+        "  stroke: #000;\n",
+        "\n",
+        "  fill-opacity: .125;\n",
+        "\n",
+        "  shape-rendering: crispEdges;\n",
+        "\n",
+        "}\n",
+        "\n",
+        "</style>\n",
+        "<div id=\"fig_41c7653cedde4765ae1f166e75c4fb08\" class=\"eventplot\">\n",
+        "        <script>\n",
+        "            var req = require.config( {\n",
+        "\n",
+        "                paths: {\n",
+        "\n",
+        "                    \"EventPlot\": \"https://rawgit.com/sinkap/7f89de3e558856b81f10/raw/46144f8f8c5da670c54f826f0c634762107afc66/EventPlot\",\n",
+        "                    \"d3-tip\": \"http://labratrevenge.com/d3-tip/javascripts/d3.tip.v0.6.3\",\n",
+        "                    \"d3\": \"http://d3js.org/d3.v3.min\"\n",
+        "                },\n",
+        "                shim: {\n",
+        "                    \"d3-tip\": [\"d3\"],\n",
+        "                    \"EventPlot\": {\n",
+        "\n",
+        "                        \"deps\": [\"d3-tip\", \"d3\" ],\n",
+        "                        \"exports\":  \"EventPlot\"\n",
+        "                    }\n",
+        "                }\n",
+        "            });\n",
+        "            req([\"require\", \"EventPlot\"], function() {\n",
+        "               EventPlot.generate('fig_41c7653cedde4765ae1f166e75c4fb08', 'https://rawgit.com/sinkap/e9bc2394cf322f4dad0d/raw/014fae226c847a467fba541fbc390e18acea127b/fig_41c7653cedde4765ae1f166e75c4fb08.json');\n",
+        "            });\n",
+        "        </script>\n",
+        "        </div>"
+       ],
+       "metadata": {},
+       "output_type": "display_data",
+       "text": [
+        "<IPython.core.display.HTML object>"
+       ]
+      },
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "PASS: DutyCycle\n",
+        "{\n",
+        "   \"1852\": {\n",
+        "      \"task_name\": \"cpuhog\", \n",
+        "      \"dutycycle\": 10.050119999991693\n",
+        "   }\n",
+        "}\n"
+       ]
+      }
+     ],
+     "prompt_number": 11
+    },
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Changing Reservations"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "A CPU hogging task has reservations set in the increasing order starting from 10%  followed by a 2s period of normal execution"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "TRACE_FILE = os.path.join(BASE_PATH, \"cancel_dl_timer\")\n",
+      "ftrace = trappy.FTrace(TRACE_FILE, \"cpuhog\")\n",
+      "s = SchedAssert(ftrace, topology, execname=\"cpuhog\")\n",
+      "s.plot().view()\n",
+      "\n",
+      "NUM_PHASES = 10\n",
+      "PHASE_DURATION = 2\n",
+      "start = s.getStartTime()\n",
+      "DUTY_CYCLE_FACTOR = 10\n",
+      "\n",
+      "\n",
+      "for phase in range(NUM_PHASES + 1):\n",
+      "    window = (start + (phase * PHASE_DURATION),\n",
+      "              start + ((phase + 1) * PHASE_DURATION))\n",
+      "    \n",
+      "    if phase % 2 == 0:\n",
+      "        DUTY_CYCLE = (phase + 2) * DUTY_CYCLE_FACTOR / 2\n",
+      "    else:\n",
+      "        DUTY_CYCLE = 100\n",
+      "\n",
+      "\n",
+      "    print \"WINDOW -> [{:.2f}, {:.2f}]\".format(window[0],\n",
+      "                                            window[1])\n",
+      "    \n",
+      "    \n",
+      "    \n",
+      "    if s.assertDutyCycle(DUTY_CYCLE, between_threshold, window=window):\n",
+      "        print \"PASS: Expected={} Actual={:.2f} THRESHOLD={}\".format(DUTY_CYCLE,\n",
+      "                                                                s.getDutyCycle(window=window),\n",
+      "                                                                THRESHOLD)\n",
+      "    else:\n",
+      "        print \"FAIL: Expected={} Actual={:.2f} THRESHOLD={}\".format(DUTY_CYCLE,\n",
+      "                                                                s.getDutyCycle(window=window),\n",
+      "                                                                THRESHOLD)\n",
+      "    \n",
+      "    print \"\""
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "html": [
+        "<style>\n",
+        "/*\n",
+        "\n",
+        " *    Copyright 2015-2015 ARM Limited\n",
+        "\n",
+        " *\n",
+        "\n",
+        " * Licensed under the Apache License, Version 2.0 (the \"License\");\n",
+        "\n",
+        " * you may not use this file except in compliance with the License.\n",
+        "\n",
+        " * You may obtain a copy of the License at\n",
+        "\n",
+        " *\n",
+        "\n",
+        " *     http://www.apache.org/licenses/LICENSE-2.0\n",
+        "\n",
+        " *\n",
+        "\n",
+        " * Unless required by applicable law or agreed to in writing, software\n",
+        "\n",
+        " * distributed under the License is distributed on an \"AS IS\" BASIS,\n",
+        "\n",
+        " * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
+        "\n",
+        " * See the License for the specific language governing permissions and\n",
+        "\n",
+        " * limitations under the License.\n",
+        "\n",
+        " */\n",
+        "\n",
+        "\n",
+        "\n",
+        ".d3-tip {\n",
+        "\n",
+        "  line-height: 1;\n",
+        "\n",
+        "  padding: 12px;\n",
+        "\n",
+        "  background: rgba(0, 0, 0, 0.6);\n",
+        "\n",
+        "  color: #fff;\n",
+        "\n",
+        "  border-radius: 2px;\n",
+        "\n",
+        "  position: absolute !important;\n",
+        "\n",
+        "  z-index: 99999;\n",
+        "\n",
+        "}\n",
+        "\n",
+        "\n",
+        "\n",
+        ".d3-tip:after {\n",
+        "\n",
+        "  box-sizing: border-box;\n",
+        "\n",
+        "  pointer-events: none;\n",
+        "\n",
+        "  display: inline;\n",
+        "\n",
+        "  font-size: 10px;\n",
+        "\n",
+        "  width: 100%;\n",
+        "\n",
+        "  line-height: 1;\n",
+        "\n",
+        "  color: rgba(0, 0, 0, 0.6);\n",
+        "\n",
+        "  content: \"\\25BC\";\n",
+        "\n",
+        "  position: absolute !important;\n",
+        "\n",
+        "  z-index: 99999;\n",
+        "\n",
+        "  text-align: center;\n",
+        "\n",
+        "}\n",
+        "\n",
+        "\n",
+        "\n",
+        ".d3-tip.n:after {\n",
+        "\n",
+        "  margin: -1px 0 0 0;\n",
+        "\n",
+        "  top: 100%;\n",
+        "\n",
+        "  left: 0;\n",
+        "\n",
+        "}\n",
+        "\n",
+        "\n",
+        "\n",
+        ".chart {\n",
+        "\n",
+        "  shape-rendering: crispEdges;\n",
+        "\n",
+        "}\n",
+        "\n",
+        "\n",
+        "\n",
+        ".mini text {\n",
+        "\n",
+        "  font: 9px sans-serif;\n",
+        "\n",
+        "}\n",
+        "\n",
+        "\n",
+        "\n",
+        ".main text {\n",
+        "\n",
+        "  font: 12px sans-serif;\n",
+        "\n",
+        "}\n",
+        "\n",
+        "\n",
+        "\n",
+        ".axis line, .axis path {\n",
+        "\n",
+        "  stroke: black;\n",
+        "\n",
+        "}\n",
+        "\n",
+        "\n",
+        "\n",
+        ".miniItem {\n",
+        "\n",
+        "  stroke-width: 8;\n",
+        "\n",
+        "}\n",
+        "\n",
+        "\n",
+        "\n",
+        ".brush .extent {\n",
+        "\n",
+        "\n",
+        "\n",
+        "  stroke: #000;\n",
+        "\n",
+        "  fill-opacity: .125;\n",
+        "\n",
+        "  shape-rendering: crispEdges;\n",
+        "\n",
+        "}\n",
+        "\n",
+        "</style>\n",
+        "<div id=\"fig_421afa8cc8234df49030c900b680220b\" class=\"eventplot\">\n",
+        "        <script>\n",
+        "            var req = require.config( {\n",
+        "\n",
+        "                paths: {\n",
+        "\n",
+        "                    \"EventPlot\": \"https://rawgit.com/sinkap/7f89de3e558856b81f10/raw/46144f8f8c5da670c54f826f0c634762107afc66/EventPlot\",\n",
+        "                    \"d3-tip\": \"http://labratrevenge.com/d3-tip/javascripts/d3.tip.v0.6.3\",\n",
+        "                    \"d3\": \"http://d3js.org/d3.v3.min\"\n",
+        "                },\n",
+        "                shim: {\n",
+        "                    \"d3-tip\": [\"d3\"],\n",
+        "                    \"EventPlot\": {\n",
+        "\n",
+        "                        \"deps\": [\"d3-tip\", \"d3\" ],\n",
+        "                        \"exports\":  \"EventPlot\"\n",
+        "                    }\n",
+        "                }\n",
+        "            });\n",
+        "            req([\"require\", \"EventPlot\"], function() {\n",
+        "               EventPlot.generate('fig_421afa8cc8234df49030c900b680220b', 'https://rawgit.com/sinkap/a207675f6483aa0b9342/raw/825717935112f36fe996b77093c0c71d3871fee4/fig_421afa8cc8234df49030c900b680220b.json');\n",
+        "            });\n",
+        "        </script>\n",
+        "        </div>"
+       ],
+       "metadata": {},
+       "output_type": "display_data",
+       "text": [
+        "<IPython.core.display.HTML object>"
+       ]
+      },
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "WINDOW -> [0.00, 2.00]\n",
+        "PASS: Expected=10 Actual=10.38 THRESHOLD=10.0\n",
+        "\n",
+        "WINDOW -> [2.00, 4.00]\n",
+        "PASS: Expected=100 Actual=99.60 THRESHOLD=10.0\n",
+        "\n",
+        "WINDOW -> [4.00, 6.00]\n",
+        "PASS: Expected=20 Actual=21.06 THRESHOLD=10.0\n",
+        "\n",
+        "WINDOW -> [6.00, 8.00]\n",
+        "PASS: Expected=100 Actual=95.69 THRESHOLD=10.0\n",
+        "\n",
+        "WINDOW -> [8.00, 10.00]\n",
+        "PASS: Expected=30 Actual=31.78 THRESHOLD=10.0\n",
+        "\n",
+        "WINDOW -> [10.00, 12.00]\n",
+        "PASS: Expected=100 Actual=98.23 THRESHOLD=10.0\n",
+        "\n",
+        "WINDOW -> [12.00, 14.00]\n",
+        "PASS: Expected=40 Actual=40.74 THRESHOLD=10.0\n",
+        "\n",
+        "WINDOW -> [14.00, 16.00]\n",
+        "PASS: Expected=100 Actual=97.58 THRESHOLD=10.0\n",
+        "\n",
+        "WINDOW -> [16.00, 18.00]\n",
+        "PASS: Expected=50 Actual=52.51 THRESHOLD=10.0\n",
+        "\n",
+        "WINDOW -> [18.00, 20.00]\n",
+        "PASS: Expected=100 Actual=96.38 THRESHOLD=10.0\n",
+        "\n",
+        "WINDOW -> [20.00, 22.00]\n",
+        "PASS: Expected=60 Actual=60.71 THRESHOLD=10.0\n",
+        "\n"
+       ]
+      }
+     ],
+     "prompt_number": 4
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
\ No newline at end of file
diff --git a/docs/notebooks/thermal/Thermal.ipynb b/docs/notebooks/thermal/Thermal.ipynb
new file mode 100644
index 0000000..bf51929
--- /dev/null
+++ b/docs/notebooks/thermal/Thermal.ipynb
@@ -0,0 +1,393 @@
+{
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 2",
+   "language": "python",
+   "name": "python2"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  },
+  "name": "",
+  "signature": "sha256:59ef0b9fe2847e77f9df55deeb6df1f94f4fe2a3a0f99e13cba99854e8bf66ed"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Configuration"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import trappy\n",
+      "import numpy\n",
+      "\n",
+      "config = {}\n",
+      "\n",
+      "# TRAPpy Events\n",
+      "config[\"THERMAL\"] = trappy.thermal.Thermal\n",
+      "config[\"OUT\"] = trappy.cpu_power.CpuOutPower\n",
+      "config[\"IN\"] = trappy.cpu_power.CpuInPower\n",
+      "config[\"PID\"] = trappy.pid_controller.PIDController\n",
+      "config[\"GOVERNOR\"] = trappy.thermal.ThermalGovernor\n",
+      "\n",
+      "# Control Temperature\n",
+      "config[\"CONTROL_TEMP\"] = 77000\n",
+      "\n",
+      "# A temperature margin of 2.5 degrees Celsius\n",
+      "config[\"TEMP_MARGIN\"] = 2500\n",
+      "\n",
+      "# The Sustainable power at the control Temperature\n",
+      "config[\"SUSTAINABLE_POWER\"] = 2500\n",
+      "\n",
+      "# Expected percentile of CONTROL_TEMP + TEMP_MARGIN\n",
+      "config[\"EXPECTED_TEMP_QRT\"] = 95\n",
+      "\n",
+      "# Maximum expected Standard Deviation as a percentage\n",
+      "# of mean temperature\n",
+      "config[\"EXPECTED_STD_PCT\"] = 5\n"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [],
+     "prompt_number": 1
+    },
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Get the Trace"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import urllib\n",
+      "import os\n",
+      "\n",
+      "TRACE_DIR = \"example_trace_dat_thermal\"\n",
+      "TRACE_FILE = os.path.join(TRACE_DIR, 'bart_thermal_trace.dat')\n",
+      "TRACE_URL = 'http://cdn.rawgit.com/sinkap/4e0a69cbff732b57e36f/raw/7dd0ed74bfc17a34a3bd5ea6b9eb3a75a42ddbae/bart_thermal_trace.dat'\n",
+      "\n",
+      "if not os.path.isdir(TRACE_DIR):\n",
+      "    os.mkdir(TRACE_DIR)\n",
+      "\n",
+      "if not os.path.isfile(TRACE_FILE):\n",
+      "    print \"Fetching trace file..\"\n",
+      "    urllib.urlretrieve(TRACE_URL, filename=TRACE_FILE)"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [],
+     "prompt_number": 2
+    },
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "FTrace Object"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "# Create a Trace object\n",
+      "\n",
+      "ftrace = trappy.FTrace(TRACE_FILE, \"SomeBenchMark\")"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [],
+     "prompt_number": 3
+    },
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Assertions"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "# Create an Assertion Object\n",
+      "\n",
+      "from bart.common.Analyzer import Analyzer\n",
+      "t = Analyzer(ftrace, config)\n",
+      "\n",
+      "BIG = '000000f0'\n",
+      "LITTLE = '0000000f'"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [],
+     "prompt_number": 4
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Assertion: Load and Dynamic Power"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "<html>\n",
+      "This assertion makes sure that the dynamic power for the each cluster is zero when the sum of the \"loads\" of each CPU is 0\n",
+      "\n",
+      "    $$\\forall\\ t\\ |\\ Load(t) = \\sum\\limits_{i=0}^{cpus} Load_i(t) = 0 \\implies dynamic\\ power(t)=0 $$\n",
+      "    \n",
+      "</html>"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "result = t.getStatement(\"((IN:load0 + IN:load1 + IN:load2 + IN:load3) == 0) \\\n",
+      "                & (IN:dynamic_power > 0)\",reference=True, select=BIG)\n",
+      "if len(result):\n",
+      "    print \"FAIL: Dynamic Power is NOT Zero when load is Zero for the BIG cluster\"\n",
+      "else:\n",
+      "    print \"PASS: Dynamic Power is Zero when load is Zero for the BIG cluster\"\n",
+      "\n",
+      "    \n",
+      "result = t.getStatement(\"((IN:load0 + IN:load1 + IN:load2 + IN:load3) == 0) \\\n",
+      "                & (IN:dynamic_power > 0)\",reference=True, select=LITTLE)\n",
+      "if len(result):\n",
+      "    print \"FAIL: Dynamic Power is NOT Zero when load is Zero for the LITTLE cluster\"\n",
+      "else:\n",
+      "    print \"PASS: Dynamic Power is Zero when load is Zero for the LITTLE cluster\""
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "PASS: Dynamic Power is Zero when load is Zero for the BIG cluster\n",
+        "PASS: Dynamic Power is Zero when load is Zero for the LITTLE cluster\n"
+       ]
+      }
+     ],
+     "prompt_number": 5
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Assertion: Control Temperature and Sustainable Power"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "<html>\n",
+      "\n",
+      "When the temperature is greater than the control temperature, the total power granted to all cooling devices should be less than sustainable_power\n",
+      "\n",
+      "$$\\forall\\ t\\ |\\ Temperature(t) > control\\_temp \\implies Total\\ Granted\\ Power(t) < sustainable\\_power$$\n",
+      "\n",
+      "<html/>"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "result = t.getStatement(\"(GOVERNOR:current_temperature > CONTROL_TEMP) &\\\n",
+      "            (PID:output > SUSTAINABLE_POWER)\", reference=True, select=0)\n",
+      "\n",
+      "if len(result):\n",
+      "    print \"FAIL: The Governor is allocating power > sustainable when T > CONTROL_TEMP\"\n",
+      "else:\n",
+      "    print \"PASS: The Governor is allocating power <= sustainable when T > CONTROL_TEMP\"    "
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "PASS: The Governor is allocating power <= sustainable when T > CONTROL_TEMP\n"
+       ]
+      }
+     ],
+     "prompt_number": 6
+    },
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Statistics"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "Check if 95% of the temperature readings are below CONTROL_TEMP + MARGIN"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "t.assertStatement(\"numpy.percentile(THERMAL:temp, 95) < (CONTROL_TEMP + TEMP_MARGIN)\")"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "metadata": {},
+       "output_type": "pyout",
+       "prompt_number": 7,
+       "text": [
+        "True"
+       ]
+      }
+     ],
+     "prompt_number": 7
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "Check if the mean temperauture is less than CONTROL_TEMP"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "t.assertStatement(\"numpy.mean(THERMAL:temp) <= CONTROL_TEMP\",  select=0)"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "metadata": {},
+       "output_type": "pyout",
+       "prompt_number": 8,
+       "text": [
+        "True"
+       ]
+      }
+     ],
+     "prompt_number": 8
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "We can also use getStatement to get the absolute values. Here we are getting the standard deviation expressed as a percentage of the mean"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "t.getStatement(\"(numpy.std(THERMAL:temp) * 100.0) / numpy.mean(THERMAL:temp)\", select=0)"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "metadata": {},
+       "output_type": "pyout",
+       "prompt_number": 9,
+       "text": [
+        "2.2390646863105119"
+       ]
+      }
+     ],
+     "prompt_number": 9
+    },
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Thermal Residency"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "from bart.thermal.ThermalAssert import ThermalAssert\n",
+      "\n",
+      "t_assert = ThermalAssert(ftrace)\n",
+      "end = ftrace.get_duration()\n",
+      "\n",
+      "LOW = 0\n",
+      "HIGH = 78000\n",
+      "\n",
+      "# The thermal residency gives the percentage (or absolute time) spent in the\n",
+      "# specified temperature range. \n",
+      "\n",
+      "result = t_assert.getThermalResidency(temp_range=(0, 78000),\n",
+      "                                              window=(0, end),\n",
+      "                                              percent=True)\n",
+      "\n",
+      "for tz_id in result:\n",
+      "    print \"Thermal Zone: {} spends {:.2f}% time in the temperature range [{}, {}]\".format(tz_id, \n",
+      "                                                                                          result[tz_id],\n",
+      "                                                                                          LOW/1000,\n",
+      "                                                                                          HIGH/1000)\n",
+      "    pct_temp = numpy.percentile(t.getStatement(\"THERMAL:temp\")[tz_id], result[tz_id])\n",
+      "    \n",
+      "    print \"The {:.2f}th percentile temperature is {:.2f}\".format(result[tz_id], pct_temp / 1000.0)\n",
+      "    "
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Thermal Zone: 0 spends 86.58% time in the temperature range [0, 78]\n",
+        "The 86.58th percentile temperature is 78.28\n"
+       ]
+      }
+     ],
+     "prompt_number": 10
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
\ No newline at end of file
diff --git a/setup.cfg b/setup.cfg
new file mode 100644
index 0000000..c4b13e3
--- /dev/null
+++ b/setup.cfg
@@ -0,0 +1,2 @@
+[upload_sphinx]
+upload-dir = docs/api_reference/_build/html
diff --git a/setup.py b/setup.py
new file mode 100644
index 0000000..c73c225
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,58 @@
+#!/usr/bin/env python
+#    Copyright 2015-2016 ARM Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+from setuptools import setup, find_packages
+
+
+execfile("bart/version.py")
+
+LONG_DESCRIPTION = """Behavioural Analysis involves the expressing the general
+expectation of the state of the system while targeting a single or set of heuristics.
+This is particularly helpful when there are large number of factors that can change
+the behaviour of the system and testing all permutations of these input parameters
+is impossible. In such a scenario an assertion of the final expectation can be
+useful in managing performance and regression.
+
+The Behavioural Analysis and Regression Toolkit is based on TRAPpy. The primary goal is
+to assert behaviours using the FTrace output from the kernel
+"""
+
+REQUIRES = [
+    "TRAPpy>=3.0",
+]
+
+setup(name='bart-py',
+      version=__version__,
+      license="Apache v2",
+      author="ARM-BART",
+      author_email="bart@arm.com",
+      description="Behavioural Analysis and Regression Toolkit",
+      long_description=LONG_DESCRIPTION,
+      url="http://arm-software.github.io/bart",
+      packages=find_packages(),
+      include_package_data=True,
+      classifiers=[
+          "Development Status :: 5 - Production/Stable",
+          "Environment :: Web Environment",
+          "Environment :: Console",
+          "License :: OSI Approved :: Apache Software License",
+          "Operating System :: POSIX :: Linux",
+          "Programming Language :: Python :: 2.7",
+          # As we depend on trace data from the Linux Kernel/FTrace
+          "Topic :: System :: Operating System Kernels :: Linux",
+          "Topic :: Scientific/Engineering :: Visualization"
+      ],
+      install_requires=REQUIRES
+      )
diff --git a/tests/raw_trace.dat b/tests/raw_trace.dat
new file mode 100644
index 0000000..adfb449
--- /dev/null
+++ b/tests/raw_trace.dat
Binary files differ
diff --git a/tests/test_common_utils.py b/tests/test_common_utils.py
new file mode 100644
index 0000000..09b31e3
--- /dev/null
+++ b/tests/test_common_utils.py
@@ -0,0 +1,130 @@
+#    Copyright 2015-2016 ARM Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+from bart.common import Utils
+from bart.common.Analyzer import Analyzer
+import unittest
+import pandas as pd
+import trappy
+
+
+class TestCommonUtils(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super(TestCommonUtils, self).__init__(*args, **kwargs)
+
+    def test_interval_sum(self):
+        """Test Utils Function: interval_sum"""
+
+        # A series with a non uniform index
+        # Refer to the example illustrations in the
+        # the interval sum docs-strings which explains
+        # the difference between step-post and ste-pre
+        # calculations
+        values = [0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1]
+        index = [0, 1, 2, 3, 4, 5, 8, 9, 10, 11, 12]
+        series = pd.Series(values, index=index)
+
+        self.assertEqual(Utils.interval_sum(series, 1, step="post"), 8)
+        self.assertEqual(Utils.interval_sum(series, 1, step="pre"), 7)
+
+        # check left boundary
+        array = [1, 1, 0, 0]
+        series = pd.Series(array)
+
+        self.assertEqual(Utils.interval_sum(series, 1, step="post"), 2)
+        self.assertEqual(Utils.interval_sum(series, 1, step="pre"), 1)
+
+        # check right boundary
+        array = [0, 0, 1, 1]
+        series = pd.Series(array)
+
+        self.assertEqual(Utils.interval_sum(series, 1, step="post"), 1)
+        self.assertEqual(Utils.interval_sum(series, 1, step="pre"), 2)
+
+        array = [False, False, True, True, True, True, False, False]
+        series = pd.Series(array)
+        self.assertEqual(Utils.interval_sum(series), 4)
+
+    def test_area_under_curve(self):
+        """Test Utils function: area_under_curve"""
+
+        array = [0, 0, 2, 2, 2, 1, 1, 1]
+        series = pd.Series(array)
+
+        # Area under curve post stepping
+        self.assertEqual(
+            Utils.area_under_curve(
+                series,
+                method="rect",
+                step="post"),
+            8)
+
+        # Area under curve pre stepping
+        self.assertEqual(
+            Utils.area_under_curve(
+                series,
+                method="rect",
+                step="pre"),
+            9)
+
+        array = [1]
+        series = pd.Series(array)
+
+        # Area under curve post stepping, edge case
+        self.assertEqual(
+            Utils.area_under_curve(
+                series,
+                method="rect",
+                step="post"),
+            0)
+
+        # Area under curve pre stepping, edge case
+        self.assertEqual(
+            Utils.area_under_curve(
+                series,
+                method="rect",
+                step="pre"),
+            0)
+
+
+class TestAnalyzer(unittest.TestCase):
+
+    def test_assert_statement_bool(self):
+        """Check that asssertStatement() works with a simple boolean case"""
+
+        rolls_dfr = pd.DataFrame({"results": [1, 3, 2, 6, 2, 4]})
+        trace = trappy.BareTrace()
+        trace.add_parsed_event("dice_rolls", rolls_dfr)
+        config = {"MAX_DICE_NUMBER": 6}
+
+        t = Analyzer(trace, config)
+        statement = "numpy.max(dice_rolls:results) <= MAX_DICE_NUMBER"
+        self.assertTrue(t.assertStatement(statement, select=0))
+
+    def test_assert_statement_dataframe(self):
+        """assertStatement() works if the generated statement creates a pandas.DataFrame of bools"""
+
+        rolls_dfr = pd.DataFrame({"results": [1, 3, 2, 6, 2, 4]})
+        trace = trappy.BareTrace()
+        trace.add_parsed_event("dice_rolls", rolls_dfr)
+        config = {"MIN_DICE_NUMBER": 1, "MAX_DICE_NUMBER": 6}
+        t = Analyzer(trace, config)
+
+        statement = "(dice_rolls:results <= MAX_DICE_NUMBER) & (dice_rolls:results >= MIN_DICE_NUMBER)"
+        self.assertTrue(t.assertStatement(statement))
+
+        statement = "dice_rolls:results == 3"
+        self.assertFalse(t.assertStatement(statement))
diff --git a/tests/test_sched_assert.py b/tests/test_sched_assert.py
new file mode 100644
index 0000000..4f8c28b
--- /dev/null
+++ b/tests/test_sched_assert.py
@@ -0,0 +1,116 @@
+#    Copyright 2015-2016 ARM Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+
+from bart.sched.SchedAssert import SchedAssert
+from bart.sched.SchedMultiAssert import SchedMultiAssert
+import trappy
+from trappy.stats.Topology import Topology
+import unittest
+
+import utils_tests
+
+
+@unittest.skipUnless(utils_tests.trace_cmd_installed(),
+                     "trace-cmd not installed")
+class TestSchedAssert(utils_tests.SetupDirectory):
+
+    def __init__(self, *args, **kwargs):
+
+        self.BIG = [1,2]
+        self.LITTLE = [0, 3, 4, 5]
+        self.clusters = [self.BIG, self.LITTLE]
+        self.topology = Topology(clusters=self.clusters)
+        super(TestSchedAssert, self).__init__(
+             [("raw_trace.dat", "trace.dat")],
+             *args,
+             **kwargs)
+
+    def test_get_runtime(self):
+
+        r = trappy.FTrace()
+        # The ls process is process we are
+        # testing against with pre calculated
+        # values
+        process = "ls"
+
+        # Complete duration
+        expected_time = 0.0034740000264719129
+        s = SchedAssert(r, self.topology, execname=process)
+        self.assertAlmostEqual(s.getRuntime(), expected_time, places=9)
+        self.assertAlmostEqual(s.getRuntime(), expected_time, places=9)
+
+        # Non Interrupted Window
+        window = (0.0034, 0.003525)
+        expected_time = 0.000125
+        self.assertAlmostEqual(s.getRuntime(window=window), expected_time,
+                               places=9)
+
+        # Interrupted Window
+        window = (0.0030, 0.0032)
+        expected_time = 0.000166
+        self.assertAlmostEqual(s.getRuntime(window=window), expected_time,
+                               places=9)
+
+        # A window with multiple interruptions
+        window = (0.0027, 0.0036)
+        expected_time = 0.000817
+        self.assertAlmostEqual(s.getRuntime(window=window), expected_time,
+                               places=9)
+
+    def test_get_last_cpu(self):
+        """SchedAssert.getLastCpu() gives you the last cpu in which a task ran"""
+        expected_last_cpu = 5
+
+        sa = SchedAssert("trace.dat", self.topology, execname="ls")
+        self.assertEqual(sa.getLastCpu(), expected_last_cpu)
+
+class TestSchedMultiAssert(utils_tests.SetupDirectory):
+    def __init__(self, *args, **kwargs):
+        self.big = [1,2]
+        self.little = [0, 3, 4, 5]
+        self.clusters = [self.big, self.little]
+        self.all_cpus = sorted(self.big + self.little)
+        self.topology = Topology(clusters=self.clusters)
+        super(TestSchedMultiAssert, self).__init__(
+             [("raw_trace.dat", "trace.dat")],
+             *args,
+             **kwargs)
+
+    def test_cpu_busy_time(self):
+        """SchedMultiAssert.getCPUBusyTime() work"""
+
+        # precalculated values against these processes in the trace
+        pids = [4729, 4734]
+        first_time = .000214
+        last_time = .003171
+
+        tr = trappy.FTrace()
+        sma = SchedMultiAssert(tr, self.topology, pids=pids)
+
+        expected_busy_time = 0.0041839999754810708
+        busy_time = sma.getCPUBusyTime("all", self.all_cpus, window=(first_time, last_time))
+        self.assertAlmostEqual(busy_time, expected_busy_time)
+
+        # percent calculation
+        expected_busy_pct = 23.582459561949445
+        busy_pct= sma.getCPUBusyTime("all", self.all_cpus, percent=True,
+                                     window=(first_time, last_time))
+        self.assertAlmostEqual(busy_pct, expected_busy_pct)
+
+        # percent without a window
+        expected_busy_pct = 23.018818156540004
+        busy_pct= sma.getCPUBusyTime("cluster", self.little, percent=True)
+        self.assertAlmostEqual(busy_pct, expected_busy_pct)
diff --git a/tests/test_sched_functions.py b/tests/test_sched_functions.py
new file mode 100644
index 0000000..1a8d4ac
--- /dev/null
+++ b/tests/test_sched_functions.py
@@ -0,0 +1,69 @@
+#    Copyright 2016-2016 ARM Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+import trappy
+
+import utils_tests
+
+class TestSchedFunctions(utils_tests.SetupDirectory):
+    def __init__(self, *args, **kwargs):
+        super(TestSchedFunctions, self).__init__([], *args, **kwargs)
+
+    def test_get_pids_for_processes_no_sched_switch(self):
+        """get_pids_for_processes() raises an exception if the trace doesn't have a sched_switch event"""
+        from bart.sched.functions import get_pids_for_process
+
+        trace_file = "trace.txt"
+        raw_trace_file = "trace.raw.txt"
+
+        with open(trace_file, "w") as fout:
+            fout.write("")
+
+        with open(raw_trace_file, "w") as fout:
+            fout.write("")
+
+        trace = trappy.FTrace(trace_file)
+        with self.assertRaises(ValueError):
+            get_pids_for_process(trace, "foo")
+
+    def test_get_pids_for_process_funny_process_names(self):
+        """get_pids_for_process() works when a process name is a substring of another"""
+        from bart.sched.functions import get_pids_for_process
+
+        trace_file = "trace.txt"
+        raw_trace_file = "trace.raw.txt"
+        in_data = """          <idle>-0     [001] 10826.894644: sched_switch:          prev_comm=swapper/1 prev_pid=0 prev_prio=120 prev_state=0 next_comm=rt-app next_pid=3268 next_prio=120
+            wmig-3268  [001] 10826.894778: sched_switch:          prev_comm=wmig prev_pid=3268 prev_prio=120 prev_state=1 next_comm=rt-app next_pid=3269 next_prio=120
+           wmig1-3269  [001] 10826.905152: sched_switch:          prev_comm=wmig1 prev_pid=3269 prev_prio=120 prev_state=1 next_comm=wmig next_pid=3268 next_prio=120
+            wmig-3268  [001] 10826.915384: sched_switch:          prev_comm=wmig prev_pid=3268 prev_prio=120 prev_state=1 next_comm=swapper/1 next_pid=0 next_prio=120
+          <idle>-0     [005] 10826.995169: sched_switch:          prev_comm=swapper/5 prev_pid=0 prev_prio=120 prev_state=0 next_comm=wmig1 next_pid=3269 next_prio=120
+           wmig1-3269  [005] 10827.007064: sched_switch:          prev_comm=wmig1 prev_pid=3269 prev_prio=120 prev_state=0 next_comm=wmig next_pid=3268 next_prio=120
+            wmig-3268  [005] 10827.019061: sched_switch:          prev_comm=wmig prev_pid=3268 prev_prio=120 prev_state=0 next_comm=wmig1 next_pid=3269 next_prio=120
+           wmig1-3269  [005] 10827.031061: sched_switch:          prev_comm=wmig1 prev_pid=3269 prev_prio=120 prev_state=0 next_comm=wmig next_pid=3268 next_prio=120
+            wmig-3268  [005] 10827.050645: sched_switch:          prev_comm=wmig prev_pid=3268 prev_prio=120 prev_state=1 next_comm=swapper/5 next_pid=0 next_prio=120
+"""
+
+        # We create an empty trace.txt to please trappy ...
+        with open(trace_file, "w") as fout:
+            fout.write("")
+
+        # ... but we only put the sched_switch events in the raw trace
+        # file because that's where trappy is going to look for
+        with open(raw_trace_file, "w") as fout:
+            fout.write(in_data)
+
+        trace = trappy.FTrace(trace_file)
+
+        self.assertEquals(get_pids_for_process(trace, "wmig"), [3268])
diff --git a/tests/test_signal.py b/tests/test_signal.py
new file mode 100644
index 0000000..48692a9
--- /dev/null
+++ b/tests/test_signal.py
@@ -0,0 +1,104 @@
+#    Copyright 2015-2016 ARM Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+import pandas as pd
+import trappy
+from utils_tests import TestBART
+from bart.common.signal import SignalCompare
+import numpy as np
+
+
+class TestSignalCompare(TestBART):
+
+    def __init__(self, *args, **kwargs):
+        super(TestSignalCompare, self).__init__(*args, **kwargs)
+
+    def test_conditional_compare(self):
+        """Test conditional_compare"""
+
+        # Refer to the example in
+        # bart.common.signal.SignalCompare.conditional_compare
+        # doc-strings which explains the calculation for the
+        # data set below
+        A = [0, 0, 0, 3, 3, 0, 0, 0]
+        B = [0, 0, 2, 2, 2, 2, 1, 1]
+
+        trace = trappy.BareTrace()
+        df = pd.DataFrame({"A": A, "B": B})
+        trace.add_parsed_event("event", df)
+
+        s = SignalCompare(trace, "event:A", "event:B")
+        expected = (1.5, 2.0 / 7)
+        self.assertEqual(
+            s.conditional_compare(
+                "event:A > event:B",
+                method="rect"),
+            expected)
+
+    def test_get_overshoot(self):
+        """Test get_overshoot"""
+
+        A = [0, 0, 0, 3, 3, 0, 0, 0]
+        B = [0, 0, 2, 2, 2, 2, 1, 1]
+
+        trace = trappy.BareTrace()
+        df = pd.DataFrame({"A": A, "B": B})
+        trace.add_parsed_event("event", df)
+
+        s = SignalCompare(trace, "event:A", "event:B")
+        expected = (1.5, 2.0 / 7)
+        self.assertEqual(
+            s.get_overshoot(method="rect"),
+            expected)
+
+        A = [0, 0, 0, 1, 1, 0, 0, 0]
+        B = [0, 0, 2, 2, 2, 2, 1, 1]
+
+        df = pd.DataFrame({"A": A, "B": B})
+        trace.event.data_frame = df
+        s = SignalCompare(trace, "event:A", "event:B")
+
+        expected = (float("nan"), 0.0)
+        result = s.get_overshoot(method="rect")
+        self.assertTrue(np.isnan(result[0]))
+        self.assertEqual(result[1], expected[1])
+
+    def test_get_undershoot(self):
+        """Test get_undershoot"""
+
+        A = [0, 0, 0, 1, 1, 1, 1, 1]
+        B = [2, 2, 2, 2, 2, 2, 2, 2]
+
+        trace = trappy.BareTrace()
+        df = pd.DataFrame({"A": A, "B": B})
+        trace.add_parsed_event("event", df)
+
+        s = SignalCompare(trace, "event:A", "event:B")
+        expected = (4.0 / 14.0, 1.0)
+        self.assertEqual(
+            s.get_undershoot(method="rect"),
+            expected)
+
+        A = [3, 3, 3, 3, 3, 3, 3, 3]
+        B = [2, 2, 2, 2, 2, 2, 1, 1]
+
+        df = pd.DataFrame({"A": A, "B": B})
+        trace.event.data_frame = df
+        s = SignalCompare(trace, "event:A", "event:B")
+
+        expected = (float("nan"), 0.0)
+        result = s.get_undershoot(method="rect")
+        self.assertTrue(np.isnan(result[0]))
+        self.assertEqual(result[1], expected[1])
diff --git a/tests/trace.raw.txt b/tests/trace.raw.txt
new file mode 100644
index 0000000..f66d55b
--- /dev/null
+++ b/tests/trace.raw.txt
@@ -0,0 +1,7 @@
+version = 6
+CPU 3 is empty
+CPU 4 is empty
+cpus=6
+              ls-4734  [002] 106439.675591: sched_switch:          prev_comm=trace-cmd prev_pid=4734 prev_prio=120 prev_state=1024 next_comm=migration/2 next_pid=18 next_prio=0
+     migration/2-18    [002] 106439.675613: sched_switch:          prev_comm=migration/2 prev_pid=18 prev_prio=0 prev_state=1 next_comm=trace-cmd next_pid=4732 next_prio=120
+       trace-cmd-4730  [001] 106439.675718: sched_switch:          prev_comm=trace-cmd prev_pid=4730 prev_prio=120 prev_state=1 next_comm=trace-cmd next_pid=4729 next_prio=120
diff --git a/tests/trace.txt b/tests/trace.txt
new file mode 100644
index 0000000..4fbf4c9
--- /dev/null
+++ b/tests/trace.txt
@@ -0,0 +1,7 @@
+version = 6
+CPU 3 is empty
+CPU 4 is empty
+cpus=6
+              ls-4734  [002] 106439.675591: sched_switch:         trace-cmd:4734 [120] R ==> migration/2:18 [0]
+     migration/2-18    [002] 106439.675613: sched_switch:         migration/2:18 [0] S ==> trace-cmd:4732 [120]
+       trace-cmd-4731  [001] 106439.675698: sched_switch:         trace-cmd:4731 [120] S ==> trace-cmd:4730 [120]
diff --git a/tests/utils_tests.py b/tests/utils_tests.py
new file mode 100644
index 0000000..6dadca1
--- /dev/null
+++ b/tests/utils_tests.py
@@ -0,0 +1,66 @@
+#    Copyright 2015-2016 ARM Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+
+import unittest
+import os
+import shutil
+import subprocess
+import tempfile
+
+TESTS_DIRECTORY = os.path.dirname(os.path.realpath(__file__))
+
+
+def trace_cmd_installed():
+    """Return true if trace-cmd is installed, false otherwise"""
+    with open(os.devnull) as devnull:
+        try:
+            subprocess.check_call(["trace-cmd", "options"], stdout=devnull)
+        except OSError:
+            return False
+
+    return True
+
+class SetupDirectory(unittest.TestCase):
+
+    def __init__(self, files_to_copy, *args, **kwargs):
+        self.files_to_copy = files_to_copy
+        super(SetupDirectory, self).__init__(*args, **kwargs)
+
+    def setUp(self):
+        self.previous_dir = os.getcwd()
+
+        self.out_dir = tempfile.mkdtemp()
+        os.chdir(self.out_dir)
+
+        for src_fname, dst_fname in self.files_to_copy:
+            src_fname = os.path.join(TESTS_DIRECTORY, src_fname)
+            shutil.copy(src_fname, os.path.join(self.out_dir, dst_fname))
+
+    def tearDown(self):
+        os.chdir(self.previous_dir)
+        shutil.rmtree(self.out_dir)
+
+
+class TestBART(SetupDirectory):
+
+    def __init__(self, *args, **kwargs):
+        super(TestBART, self).__init__(
+            [
+                ("./trace.txt", "trace.txt"),
+                ("./trace.raw.txt", "trace.raw.txt")
+            ],
+            *args,
+            **kwargs)