petal-qc 0.0.0__py3-none-any.whl

petal_qc/utils/Progress.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""An object usefull to show the progress of a process."""
+import sys
+import time
+
+
+class GTimer(object):
+    """A timer."""
+
+    def __init__(self, do_start=False):
+        """Initialization.
+
+        Args:
+        ----
+            do_start: If True, start the timer. Defaults to False.
+
+        """
+        self._start = time.time()
+        self._running = True
+        self._end = self._start
+        self._mark = self._start
+        if do_start:
+            self.start()
+
+    def mark(self):
+        """Time since last mark."""
+        return time.time() - self._mark
+
+    def set_mark(self):
+        """Sets a time mark."""
+        self._mark = time.time()
+
+    def start(self):
+        """Start the timer."""
+        self._running = True
+        self._start = time.time()
+
+    def stop(self):
+        """Stop the timer."""
+        self._end = time.time()
+        self._running = False
+        return self._end - self._start
+
+    def reset(self):
+        """Reset the timer."""
+        self._start = time.time()
+
+    def __call__(self):
+        """Get elapsed time since start."""
+        if self._running:
+            return time.time() - self._start
+        else:
+            return self._end - self._start
+
+
+def rate_units(r):
+    """Return the rate as a string with proper unitns."""
+    units = "Hz"
+    if r > 1.0e6:
+        r /= 1.0e6
+        units = "MHz"
+
+    elif r > 1.0e3:
+        r /= 1.0e3
+        units = "kHz"
+
+    elif r > 1.0:
+        pass
+
+    elif r > 1e-3:
+        r /= 1.0e-3
+        units = "mHz"
+
+    else:
+        r /= 1.0e-6
+        units = "uHz"
+
+    return r, units
+
+
+def time_units(t):
+    """Return time as string with proper units."""
+    units = "s"
+    if t > 86400.0:
+        t /= 86400.0
+        units = "d "
+
+    elif t > 3600.0:
+        t /= 3600.0
+        units = "h "
+
+    elif t > 60.0:
+        t /= 60.0
+        units = "m "
+
+    elif t > 1.0:
+        units = "s "
+
+    elif t > 1.0e-3:
+        t /= 1.0e-3
+        units = "ms"
+
+    elif t > 1.0e-6:
+        t /= 1.0e-6
+        units = "us"
+
+    else:
+        t /= 1.0e-9
+        units = "ns"
+
+    return t, units
+
+
+class ShowProgress(object):
+    """Shows the program status based on a counter."""
+
+    def __init__(self, max_val, width=40):
+        """Initialization.
+
+        Args:
+        ----
+            max_val: Max value
+            width (optional): The width of the message string.
+
+        """
+        self.width = width-2
+        self.timer = GTimer()
+        self.counter = 0.0
+        self.max_val = float(max_val)
+        self.prg = 0.0
+
+    def start(self):
+        """Start the process monitor."""
+        self.counter = 0
+        self.timer.start()
+
+    def stop(self):
+        """Stop th eprocess monitor."""
+        self.timer.stop()
+
+    def increase(self, val=1.0, show=False, interval=0.1):
+        """Increase the counter and show message if requested.
+
+        Args:
+        ----
+            val: Value of increment.
+            show: True to show the message. Defaults to False.
+            interval: Inerval to update message.
+
+        """
+        self.counter += val
+        self.prg = self.counter/self.max_val
+        if show:
+            if self.timer.mark() > interval:
+                self.timer.set_mark()
+                self.show()
+
+    def show(self):
+        """Shows message."""
+        self.show_stat(self.prg)
+
+    def show_stat(self, x):
+        """Show status of input value."""
+        n21 = int(x*self.width)
+        n22 = int(self.width-n21-1)
+
+        c21 = n21*'='
+        c22 = n22*' '
+        if self.prg > 0.0:
+            tt = self.timer()*(1.0/self.prg-1.0)
+        else:
+            tt = 0.0
+
+        rate = self.counter/self.timer()
+        rv, ru = rate_units(rate)
+        te, teu = time_units(self.timer())
+        tr, tru = time_units(tt)
+
+#        ss = '\r[%s>%s] %5.1f%% %8d' % (c21 , c22, 100.*x, self.counter)
+        ss = '\rElapsed %4.1f %s %5.1f %s [%s>%s] %5.1f%% ERT %5.1f %s' % (te, teu, rv, ru, c21, c22, 100.*x, tr, tru)
+        print(ss, end='')
+        sys.stdout.flush()

petal_qc/utils/all_files.py

@@ -0,0 +1,35 @@
+"""method to get all files in a folder matching the given name."""
+import os
+import fnmatch
+from pathlib import Path
+
+
+def all_files(root, patterns='*', single_level=False, yield_folders=False):
+    """A generator that reruns all files in the given folder.
+
+    Args:
+    ----
+        root (file path): The folder
+        patterns (str, optional): The pattern of the files. Defaults to '*'.
+        single_level (bool, optional): If true, do not go into sub folders. Defaults to False.
+        yield_folders (bool, optional): If True, return folders as well. Defaults to False.
+
+    Yields
+    ------
+        str: file path name
+
+    """
+    patterns = patterns.split(';')
+    for path, subdirs, files in os.walk(root):
+        if yield_folders:
+            files.extend(subdirs)
+
+        files.sort()
+        for name in files:
+            for pattern in patterns:
+                if fnmatch.fnmatch(name, pattern):
+                    yield Path(os.path.join(path, name))
+                    break
+
+        if single_level:
+            break

petal_qc/utils/docx_utils.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+"""Set of utilities to use wit hpython-docx."""
+import os
+import tempfile
+
+import docx
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
+from docx.oxml import ns
+from docx.oxml import OxmlElement
+from docx.oxml import parse_xml
+from docx.shared import Cm
+
+
+def create_element(name):
+    """Create a new XML element."""
+    return OxmlElement(name)
+
+
+def create_attribute(element, name, value):
+    """Create an attribute."""
+    element.set(ns.qn(name), value)
+
+
+def add_page_number(paragraph):
+    """Add page number."""
+    paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+
+    page_run = paragraph.add_run()
+    t1 = create_element('w:t')
+    create_attribute(t1, 'xml:space', 'preserve')
+    t1.text = 'Page '
+    page_run._r.append(t1)
+
+    page_num_run = paragraph.add_run()
+
+    fldChar1 = create_element('w:fldChar')
+    create_attribute(fldChar1, 'w:fldCharType', 'begin')
+
+    instrText = create_element('w:instrText')
+    create_attribute(instrText, 'xml:space', 'preserve')
+    instrText.text = "PAGE"
+
+    fldChar2 = create_element('w:fldChar')
+    create_attribute(fldChar2, 'w:fldCharType', 'end')
+
+    page_num_run._r.append(fldChar1)
+    page_num_run._r.append(instrText)
+    page_num_run._r.append(fldChar2)
+
+    of_run = paragraph.add_run()
+    t2 = create_element('w:t')
+    create_attribute(t2, 'xml:space', 'preserve')
+    t2.text = ' of '
+    of_run._r.append(t2)
+
+    fldChar3 = create_element('w:fldChar')
+    create_attribute(fldChar3, 'w:fldCharType', 'begin')
+
+    instrText2 = create_element('w:instrText')
+    create_attribute(instrText2, 'xml:space', 'preserve')
+    instrText2.text = "NUMPAGES"
+
+    fldChar4 = create_element('w:fldChar')
+    create_attribute(fldChar4, 'w:fldCharType', 'end')
+
+    num_pages_run = paragraph.add_run()
+    num_pages_run._r.append(fldChar3)
+    num_pages_run._r.append(instrText2)
+    num_pages_run._r.append(fldChar4)
+
+
+def paragraph_align_center():
+    """Align center."""
+    return WD_ALIGN_PARAGRAPH.CENTER
+
+
+class Document(object):
+    """Create a document."""
+
+    def __init__(self):
+        """Initialize."""
+        self.doc = docx.Document()
+        self.doc_fign = 1
+        self.doc_tbln = 1
+
+    def __getattr__(self, __name):
+        """Call docx.document.Document stuff."""
+        try:
+            return getattr(self.doc, __name)
+
+        except Exception:
+            return object.__getattribute__(self, __name)
+
+    def add_page_numbers(self):
+        """Add page numbers."""
+        add_page_number(self.doc.sections[0].footer.paragraphs[0])
+
+    def add_picture(self, fig, center=True, size=10, caption=None):
+        """Add a picture in the document.
+
+        Args:
+        ----
+            doc: the document
+            fig : The matplotlib figure
+            center (bool, optional): If picture will be centerd. Defaults to True.
+            size (int, optional): Size of picture in cm. Defaults to 10.
+            caption (str, optional): The text of the caption. Defaults to None.
+
+        Returns
+        -------
+            Index of Figure if caption is True, otherwise -1.
+
+        """
+        png_file = tempfile.NamedTemporaryFile(suffix=".png", delete=False)
+        fig.savefig(png_file, dpi=300)
+        png_file.close()
+        P = self.add_paragraph()
+        if center:
+            P.alignment = WD_ALIGN_PARAGRAPH.CENTER
+
+        P.add_run().add_picture(png_file.name, width=Cm(size))
+        rc = -1
+        if caption:
+            P = self.add_paragraph()
+            R = P.add_run("Figure ")
+
+            p = R.element  # this is the actual lxml element for a paragraph
+            fld_xml = r"""<w:fldSimple %s w:instr="SEQ Figure \* ARABIC ">
+                            <w:r><w:rPr>
+                            <w:noProof/>
+                            </w:rPr>
+                            <w:t>%d</w:t>
+                        </w:r></w:fldSimple>""" % (ns.nsdecls('w'), self.doc_fign)
+            rc = self.doc_fign
+            self.doc_fign += 1
+
+            # fld_xml = '<w:fldSimple %s w:instr=" SEQ Figure \* ARABIC "/>' % nsdecls('w')
+            fldSimple = parse_xml(fld_xml)
+            p.addnext(fldSimple)
+            P.add_run(". {}".format(caption))
+            P.style = self.styles['Caption']
+            if center:
+                P.alignment = paragraph_align_center()
+
+        os.remove(png_file.name)
+        return rc
+
+    def insert_table(self, rows=1, cols=1, caption=None, center=False):
+        """Adds a table to the document.
+
+        Args:
+        ----
+            nrow: The number of rows in the table
+            ncol: The number of columns in the table
+            caption: The caption if not NOne. Defaults to None.
+            center: wheter to center the table and caption or not.
+
+        Returns
+        -------
+            The table object.
+
+        """
+        if caption:
+            P = self.add_paragraph()
+            R = P.add_run("Table ")
+
+            p = R.element  # this is the actual lxml element for a paragraph
+            fld_xml = r"""<w:fldSimple %s w:instr="SEQ Table \* ARABIC ">
+                            <w:r><w:rPr>
+                            <w:noProof/>
+                            </w:rPr>
+                            <w:t>%d</w:t>
+                        </w:r></w:fldSimple>""" % (ns.nsdecls('w'), self.doc_tbln)
+            self.doc_tbln += 1
+
+            # fld_xml = '<w:fldSimple %s w:instr=" SEQ Figure \* ARABIC "/>' % nsdecls('w')
+            fldSimple = parse_xml(fld_xml)
+            p.addnext(fldSimple)
+            P.add_run(". {}".format(caption))
+            P.style = self.styles['Caption']
+            if center:
+                P.alignment = paragraph_align_center()
+
+        table = self.add_table(rows=rows, cols=cols)
+        return table

petal_qc/utils/fit_utils.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+"""A number of utils to make fits with numpy."""
+import matplotlib.pyplot as plt
+import numpy as np
+from lmfit.models import GaussianModel
+from scipy.signal import find_peaks
+# from scipy.stats import moyal as landau
+
+log2 = np.log(2)
+s2pi = np.sqrt(2*np.pi)
+spi = np.sqrt(np.pi)
+s2 = np.sqrt(2.0)
+tiny = np.finfo(np.float64).eps
+
+
+def fit_gaussian(n, X, center, width=5.0, amplitude=1):
+    """Fit a gaussion.
+
+    Args:
+    ----
+        n: The bins
+        X: the bin edges
+        center: The center (or mean) of the gaussian.
+        width: the sigma estimate of the gaussion. Defaults to 5.0.
+        amplitude: the estimae of the amplitude. Defaults to 1.
+
+    Returns
+    -------
+        the fit result and a legend
+
+    """
+    model = GaussianModel()
+    params = model.make_params(amplitude=amplitude, center=center, sigma=width)
+    result = model.fit(n, params, x=X)
+    legend = r'$\mu$=%.3f $\sigma$=%.3f' % (result.best_values['center'], result.best_values['sigma'])
+    return result, legend
+
+
+def create_multi_peak(peaks):
+    """Create a multi gaussan model.
+
+    input is an array of (amplitude, center, width) tuples
+    """
+    def create_single_peak(ipeak, center, width=5.0, amplitude=1):
+        """Create a single gaussian with initial values as given.
+
+        Parameter:
+            ipeak   - label for hte peak (a decimal number)
+            center    - center of hte peak
+            width     - width of the peak
+            amplitude - amplitude of the peak
+
+        """
+        pref = "f{0}_".format(ipeak)
+        model = GaussianModel(prefix=pref)
+        model.set_param_hint(pref+'amplitude', value=amplitude)
+        model.set_param_hint(pref+'center', value=center)
+        model.set_param_hint(pref+'sigma', value=width)
+        return model
+
+    ipeak = 0
+    mod = None
+    for ampl, center, sigma in peaks:
+        this_mod = create_single_peak(ipeak, center, sigma, ampl)
+        if mod is None:
+            mod = this_mod
+        else:
+            mod = mod + this_mod
+
+        ipeak += 1
+
+    return mod
+
+
+def fit_multi_gaus(hints, n, bins):
+    """Fit a a number of gaussians as defined by the hints.
+
+    Parameter:
+        hints: an array of (ampl, mean, sigma)
+        n: histogram bin  contents
+        bins: bin limits
+
+    Returns
+    -------
+        result: The fit result object
+        out: an array of (mean, std) tuples, one per peak
+        legend: a lengend.
+
+    """
+    width = (bins[1] - bins[0])
+    X = bins[:-1] + (0.5*width)
+
+    model = create_multi_peak(hints)
+    if model is None:
+        return None, None, None
+
+    # do the fit
+    result = model.fit(n, x=X)
+    legend = r""
+    out = []
+    for i in range(len(hints)):
+        pref = "f{0}_".format(i)
+        if i:
+            legend += '\n'
+        legend += r"$\mu$={:.3f} $\sigma$={:.3f}".format(result.best_values[pref + 'center'],
+                                                         result.best_values[pref + 'sigma'])
+
+        out.append((result.best_values[pref + 'center'], result.best_values[pref + 'sigma']))
+
+    return result, out, legend
+
+
+def fit_peak_model(n, bins, distance=None, height=None, debug=None):
+    """Fit a multigaussian model from the number of peaks found.
+
+    TODO: need to compute the distance from the noise and step
+
+    Parameter:
+    ---------
+        n: histogram bin  contents
+        bins: bin limits
+        distance: distance parameter find_peak
+        height: the cut on the peak height
+        debug: set to true to see extra information
+
+    Returns
+    -------
+        result: The fit result object
+        out: an array of (mean, std) tuples, one per peak
+        legend: a lengend
+
+    """
+    width = (bins[1] - bins[0])
+    ntot = np.sum(n)
+    thrs = 0.01*ntot
+    if height is not None:
+        thrs = height
+
+    if debug:
+        print("ntot:", ntot)
+        print("thrs:", thrs)
+        print("width:", width)
+
+    peaks, prop = find_peaks(n, thrs, distance=distance)
+    if debug:
+        print("== Peaks")
+        for peak, ampl in zip(peaks, prop['peak_heights']):
+            print("\t height {:.3f} peak {:.3f} width {:.3f}".format(ampl, bins[peak], width))
+
+    hints = []
+    for peak, ampl in zip(peaks, prop['peak_heights']):
+        hints.append((ampl, bins[peak], width))
+
+    return fit_multi_gaus(hints, n, bins)
+
+
+def draw_best_fit_orig(ax, result, bins, legend=None):
+    """Draw the best fit."""
+    step = 0.5 * (bins[1] - bins[0])
+    X = bins[:-1] + step
+    ax.plot(X, result.best_fit)
+    if legend is not None:
+        ax.legend([legend], loc=1)
+
+
+def draw_best_fit(ax, result, bins, npts=100, legend=None, color="#fa6e1e"):
+    """Draw the best fit."""
+    X = np.linspace(bins[0], bins[:-1], num=npts)
+    Y = result.eval(param=result.params, x=X)
+    ax.plot(X, Y, color=color)
+    if legend is not None:
+        ax.legend([legend], loc=1)
+
+
+if __name__ == "__main__":
+    nevts = 10000
+    fig, ax = plt.subplots(nrows=1, ncols=2)
+
+    # Double peak gauss
+    peak1 = np.random.default_rng().normal(10.0, 0.5, nevts)
+    values = np.append(peak1, np.random.default_rng().normal(7.5, 0.75, int(0.75*nevts)))
+
+    count, bins, ignored = ax[0].hist(values, 50)
+    result, out, legend = fit_peak_model(count, bins, debug=True)
+    ax[0].legend([legend], loc=1)
+    draw_best_fit(ax[0], result, bins)
+
+    plt.show()