Start of semester version

marimo/app.py

@@ -21,6 +21,7 @@ marimo_server = (
     .with_app(path="/bc", root="./bomb_calorimetry.py")
     .with_app(path="/cv", root="./crystal_violet.py")
     .with_app(path="/stats", root="./statistics_lab.py")
+    .with_app(path="/eq", root="./equilibrium.py")
     .with_app(path="/surface", root="./surface_adsorption.py")
 )
 
@@ -38,21 +39,6 @@ async def download_pdf(pdf_name: str):
         )
     return {"error": f"PDF not found [../pdfs/{pdf_name}]"}, 404
 
-# Create a route to display a pdf
-@app.get("/pdf/direct/{pdf_name}")
-async def get_pdf_direct(pdf_name: str):
-    pdf_path = Path(f"./pdfs/{pdf_name}")
-
-    if not pdf_path.exists():
-        raise HTTPException(status_code=404, detail=f"PDF not found {pdf_path}")
-
-    return FileResponse(
-        path=pdf_path,
-        media_type="application/pdf",
-        filename=pdf_name + ".pdf"
-    )
-
-
 # Mount the marimo server at the root
 # This will handle all the routes defined in the marimo server
 app.mount("", marimo_server.build())

marimo/bomb_calorimetry.py

@@ -7,7 +7,7 @@ app = marimo.App(width="medium")
 @app.cell
 def _():
     import marimo as mo
-    import pycek_public as cek
+    import pycek as cek
     lab = cek.bomb_calorimetry(make_plots=True)
     return cek, lab, mo
 
@@ -95,7 +95,6 @@ def _(cek, lab, mo, reset_button, run_button, sample_selector):
 
         lab.set_parameters(sample=sample_selector.value)
         data = lab.create_data()
-        print(data)
         file_content = lab.write_data_to_string()
 
         fname = lab.filename_gen.random
@@ -111,7 +110,6 @@ def _(cek, lab, mo, reset_button, run_button, sample_selector):
         )
 
         plot = cek.plotting()
-        print(data)
         image = plot.quick_plot(scatter=data,output="marimo")
 
     mo.hstack([mo.vstack([mo.md(message),download_button]),image])

marimo/crystal_violet.py

@@ -7,7 +7,7 @@ app = marimo.App(width="medium")
 @app.cell
 def _():
     import marimo as mo
-    import pycek_public as cek
+    import pycek as cek
     lab = cek.crystal_violet(make_plots=True)
     return cek, lab, mo
 

marimo/equilibrium.py

@@ -0,0 +1,303 @@
+import marimo
+
+__generated_with = "0.11.7"
+app = marimo.App(width="full")
+
+
+@app.cell
+def _():
+    import marimo as mo
+    import numpy as np
+    import matplotlib.pyplot as plt
+    import copy
+
+    nspecies = mo.ui.number(2,10,value=2,label="Number of species")
+    mo.vstack([
+        mo.md("#**Numerical Solution of Equilibrium Problems**").center(),
+        nspecies],gap=2)
+    return copy, mo, np, nspecies, plt
+
+
+@app.cell
+def _(nspecies):
+    species = [chr(i) for i in range(65, 65 + nspecies.value)]
+    return (species,)
+
+
+@app.cell
+def _(mo, species):
+    ss = [ mo.ui.text(value=s) for s in species]
+    compounds = mo.ui.array([ *ss ],label=f"Species Names")
+
+    nn = [ mo.ui.number(-5,5,value=1,label=f"{s}") for s in species]
+    stoichiometry = mo.ui.array([
+           *nn,
+    ],label=f"Stiochiometric coefficients")
+
+    cc = [ mo.ui.number(-5,5,0.01,value=1,label=f"{s}") for s in species]
+    concentrations = mo.ui.array([
+           *cc,
+    ],label=f"Initial concentrations")
+
+    mo.hstack([
+        compounds,stoichiometry,concentrations
+    ],align="start",justify="space-around")
+
+    return cc, compounds, concentrations, nn, ss, stoichiometry
+
+
+@app.cell
+def _(compounds, mo, stoichiometry):
+    nu = stoichiometry.value
+    _tex = ""
+    for i,xs in enumerate(compounds.value):
+        if nu[i] < 0:
+            _tex += f"\\mathrm{{{abs(nu[i])}{xs}}} + " if nu[i] < -1 else f"\\mathrm{{{xs}}} + "
+    _tex = _tex.strip().rstrip('+')
+    _tex += "\\rightleftharpoons"
+    for i,xs in enumerate(compounds.value):
+        if nu[i] > 0:
+            _tex += f"\\mathrm{{{nu[i]}{xs}}} + " if nu[i] > 1 else f"\\mathrm{{{xs}}} + "
+    _tex = _tex.strip().rstrip('+')
+
+    keq = mo.ui.text(value="12",label="$K_{eq}$")
+
+    a = mo.md(
+            f"""
+            ##**Chemical Reaction**\n
+            $$\\begin{{align*}}
+            {_tex} &
+            \\end{{align*}}$$
+            """
+        )
+    b = mo.md(
+            f"""
+            ##**Equilibrium constant**\n
+            {keq}
+            """
+        )
+
+    mo.hstack([a,b],align="start",justify="space-around")
+
+    return a, b, i, keq, nu, xs
+
+
+@app.cell
+def _(mo, np):
+    step = mo.ui.slider(steps=np.logspace(-8,0,90),label="$\delta c$",show_value=True)
+    tol = mo.ui.slider(steps=np.logspace(-8,0,90),label="Convergence Threshold",show_value=True)
+
+    mo.vstack([
+        mo.md("##**Optimisation parameters**").center(),
+        mo.hstack([
+        step, 
+        tol,]
+        ,align="start",justify="space-around")
+    ])
+    
+    return step, tol
+
+
+@app.cell
+def _(np):
+    def compute_Q(conc,stoich):
+        Q = 1
+        for i in range(len(conc)):
+            Q *= conc[i]**stoich[i]
+        return Q
+
+    def compute_force(conc,stoich,pkeq):
+        Q = compute_Q(conc,stoich)
+        return -np.log10(Q) - pkeq
+
+    def update_concentrations(conc,stoich,force,dc):
+        ctmp = np.zeros(len(conc))
+        for i in range(len(conc)):
+            ctmp[i] = conc[i] +dc*stoich[i]*force
+        return ctmp
+
+    def solve_analytic(conc,keq):
+        """
+        (b+x) / (a-2x)**2 = c
+        """
+        a = conc["A"]
+        b = conc["B"]
+        c = keq
+        x0 = (-np.sqrt(8*a*c + 16*b*c + 1) + 4*a*c + 1)/(8*c)
+        x1 = (np.sqrt(8*a*c + 16*b*c + 1) + 4*a*c + 1)/(8*c)
+        return x0,x1
+    return compute_Q, compute_force, solve_analytic, update_concentrations
+
+
+@app.cell
+def _(
+    Dict,
+    List,
+    NDArray,
+    compute_Q,
+    compute_force,
+    np,
+    plt,
+    update_concentrations,
+):
+    def solve_equilibrium(
+        species: List,
+        initial_conc: Dict[str, float],
+        stoichiometry: Dict[str, float],
+        pK_eq: float,
+        dc: float,
+        rtol: float = 1e-5,
+        max_iterations: int = 10
+    ) -> NDArray:
+        """
+        Solves chemical equilibrium equations using an iterative approach.
+
+        Args:
+            initial_conc: Dictionary of initial concentrations for each species
+            stoichiometry: Dictionary of stoichiometric coefficients
+            pK_eq: Negative log of equilibrium constant
+            dc: Concentration step size for iterations
+            rtol: Relative tolerance for convergence
+            max_iterations: Maximum number of iterations before stopping
+
+        Returns:
+            NDArray: Array with columns [iteration, conc_A, conc_B, force]
+        """
+        # Initialize arrays to store results
+        ns = len(species)
+
+        conc = np.zeros(shape=(max_iterations + 1, ns))
+        forces = np.zeros(shape=(max_iterations + 1,1))
+
+        # Set initial values
+        conc[0,:] = np.array(initial_conc)
+        forces[0] = compute_force(conc[0,:], stoichiometry, pK_eq)
+
+        # Iterate until convergence or max iterations
+        for i in range(max_iterations):
+            # Update values
+            conc[i+1,:] = update_concentrations(conc[i,:], stoichiometry, forces[i,0], dc)
+            forces[i+1] = compute_force(conc[i+1,:], stoichiometry, pK_eq)
+            if forces[i+1]*forces[i] < 0:
+                dc /=2
+            pQ = -np.log10(compute_Q(conc[i+1,:], stoichiometry))
+
+            # Check convergence
+            # if np.isclose(pQ, pK_eq, rtol=rtol):
+            if np.abs(forces[i+1]) < rtol:
+                # Trim unused array space if converged early
+                return conc[:i+2,:], forces[:i + 2]
+
+        # Return all iterations if no convergence
+        return conc[:i+2,:], forces[:i + 2]
+
+    def plot(x,data,labels=None,refs=None,log=False,axes=None):
+        colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
+        ncols = data.shape[1]
+        plt.figure(figsize=(4,4))
+        for i in range(ncols):
+            plt.plot(x,data[:,i],label=labels[i],color=colors[i])
+
+        if refs is not None:
+            for i in range(len(refs)):
+                plt.axhline(refs[i],linestyle='dashed',color=colors[i])
+
+        if axes is not None:
+            plt.xlabel(axes[0])
+            plt.ylabel(axes[1])
+        if log:
+            plt.yscale("log")
+        plt.legend()
+        return plt.gca()
+    return plot, solve_equilibrium
+
+
+@app.cell
+def _(compounds, keq, np, plot, solve_equilibrium, species, step, tol):
+    # conc = { s: float(conc_all[s].value) for s in species }
+    # stoich = { s: nu_all[s].value for s in species }
+    def execute(conc_list,stoich_list):
+        # conc_list = np.array([float(conc_all[s].value) for s in species])
+        # stoich_list = np.array([nu_all[s].value for s in species])
+
+        pkeq = -np.log10(float(keq.value))
+        dc = float(step.value)
+        rtol = float(tol.value)
+
+        final_conc_list, forces = solve_equilibrium(
+            species,
+            conc_list,
+            stoich_list,
+            pkeq,dc,rtol,max_iterations=10000)
+
+        cycles = np.linspace(0,len(forces),len(forces))
+        # roots = solve_analytic(conc,float(keq.value))
+        # analytic_solution = [ data[0,1] + stoich["A"]*roots[0] , data[0,2] + stoich["B"]*roots[0] ]
+
+        plot_c = plot(cycles,final_conc_list,labels=compounds.value,axes=["Cycles","Concentration"])
+        plot_f = plot(
+            cycles, np.abs(forces),
+            labels=["Force"],refs=[rtol],log=True,axes=["Cycles","Force"])
+
+        return final_conc_list, forces, plot_c, plot_f
+    return (execute,)
+
+
+@app.cell
+def _(concentrations, execute, mo, np, stoichiometry):
+    final_conc_list, forces, plot_c, plot_f = execute(
+        np.array(concentrations.value, dtype=float),
+        np.array(stoichiometry.value,dtype=int)
+    )
+
+    mo.vstack([
+            mo.md("##**Optimisation Results**").center(),
+            mo.hstack([plot_c,plot_f],
+    align="start", justify="space-around")])
+    return final_conc_list, forces, plot_c, plot_f
+
+
+@app.cell
+def _(
+    compounds,
+    compute_Q,
+    final_conc_list,
+    forces,
+    keq,
+    mo,
+    np,
+    stoichiometry,
+):
+    stoich_list = np.array(stoichiometry.value,dtype=int)
+    # initial = mo.md(f"""
+    #     ###**Initial conditions**
+    #     ####Force = {forces[0,0]:.4e}
+    #     ####Q  = {compute_Q(final_conc_list[0,:],stoich_list):.4e}
+    #     ####Concentrations:<br> {" ".join([f"* [{xx}] = {final_conc_list[0,i]:.4e}<br>" for i,xx in enumerate(compounds.value)])}
+    #     """)
+
+    final_0 = mo.md(f"""
+        Force = {forces[-1,0]:.4e}<br>
+        Q  = {compute_Q(final_conc_list[-1,:],stoich_list):.4e}<br>
+        Keq = {float(keq.value):.4e}
+        """)
+    final_1 = mo.md(f"""
+        Concentrations:
+        {" ".join([f"<br>[{xx}] = {final_conc_list[-1,i]:.4e}" for i,xx in enumerate(compounds.value)])}
+        """)
+
+    mo.vstack([
+        mo.md('##**Final conditions**').center(),
+        mo.hstack([final_0,final_1],align="start",justify="space-between")
+    ],justify="space-around")
+
+    return final_0, final_1, stoich_list
+
+
+@app.cell
+def _():
+    return
+
+
+if __name__ == "__main__":
+    app.run()

marimo/equilibrium_basic.py

@@ -0,0 +1,238 @@
+import marimo
+
+__generated_with = "0.11.7"
+app = marimo.App(width="medium")
+
+
+@app.cell
+def _():
+    import marimo as mo
+    import numpy as np
+    import matplotlib.pyplot as plt
+
+    conc_a = mo.ui.text(value="0.2",label="$[\mathrm{A}]_0$")
+    conc_b = mo.ui.text(value="0.1",label="$[\mathrm{B}]_0$")
+    keq = mo.ui.text(value="12",label="$K_{eq}$")
+
+    step = mo.ui.slider(steps=np.logspace(-8,0,90),label="$\delta c$",show_value=True)
+    tol = mo.ui.slider(steps=np.logspace(-8,0,90),label="Convergence Threshold",show_value=True)
+
+    mo.md(
+        f"""
+        ##**Initial conditions**
+
+        {conc_a} {conc_b} {keq}\n
+
+        ##**Chemical Equilibrium Solver Parameters**
+
+        {step} {tol}
+        """
+    )
+    return conc_a, conc_b, keq, mo, np, plt, step, tol
+
+
+@app.cell
+def _(np):
+    def compute_Q(conc,stoich):
+        Q = 1
+        for c in conc:
+            Q *= conc[c]**stoich[c]
+        return Q
+
+    def compute_force(conc,stoich,pkeq):
+        Q = compute_Q(conc,stoich)
+        return -np.log10(Q) - pkeq
+
+    def update_concentrations(conc,stoich,force,dc):
+        for c in conc:
+            conc[c] += dc*stoich[c]*force
+        return conc
+
+    def solve_analytic(conc,keq):
+        """
+        (b+x) / (a-2x)**2 = c
+        """
+        a = conc["A"]
+        b = conc["B"]
+        c = keq
+        x0 = (-np.sqrt(8*a*c + 16*b*c + 1) + 4*a*c + 1)/(8*c)
+        x1 = (np.sqrt(8*a*c + 16*b*c + 1) + 4*a*c + 1)/(8*c)
+        return x0,x1
+    return compute_Q, compute_force, solve_analytic, update_concentrations
+
+
+@app.cell
+def _(
+    Dict,
+    NDArray,
+    compute_Q,
+    compute_force,
+    conc_a,
+    conc_b,
+    keq,
+    mo,
+    np,
+    plt,
+    solve_analytic,
+    step,
+    tol,
+    update_concentrations,
+):
+    conc = {
+        "A": float(conc_a.value),
+        "B": float(conc_b.value),
+    }
+
+    stoich = {
+        "A":-2,
+        "B":1,
+    }
+
+    pkeq = -np.log10(float(keq.value))
+    dc = float(step.value)
+    rtol = float(tol.value)
+
+    # print(conc,np.log10(compute_Q(conc,stoich)),pkeq)
+
+    initial = mo.md(
+        f"""
+        ##**Initial conditions**
+        $Q$ = {compute_Q(conc,stoich):.4e}     
+        Initial force = {compute_force(conc, stoich, pkeq):.4e}
+        """
+    )
+
+    def solve_equilibrium(
+        initial_conc: Dict[str, float],
+        stoichiometry: Dict[str, float],
+        pK_eq: float,
+        dc: float,
+        rtol: float = 1e-5,
+        max_iterations: int = 10
+    ) -> NDArray:
+        """
+        Solves chemical equilibrium equations using an iterative approach.
+    
+        Args:
+            initial_conc: Dictionary of initial concentrations for each species
+            stoichiometry: Dictionary of stoichiometric coefficients
+            pK_eq: Negative log of equilibrium constant
+            dc: Concentration step size for iterations
+            rtol: Relative tolerance for convergence
+            max_iterations: Maximum number of iterations before stopping
+    
+        Returns:
+            NDArray: Array with columns [iteration, conc_A, conc_B, force]
+        """
+        # Initialize arrays to store results
+        iterations = np.zeros(max_iterations + 1)
+        conc_A = np.zeros(max_iterations + 1)
+        conc_B = np.zeros(max_iterations + 1)
+        forces = np.zeros(max_iterations + 1)
+    
+        # Set initial values
+        conc = initial_conc.copy()
+        force_0 = compute_force(conc, stoichiometry, pK_eq)
+        conc_A[0] = conc['A']
+        conc_B[0] = conc['B']
+        forces[0] = force_0
+    
+        # Iterate until convergence or max iterations
+        for i in range(max_iterations):
+            # Update values
+            conc = update_concentrations(conc, stoichiometry, forces[i], dc)
+            force = compute_force(conc, stoichiometry, pK_eq)
+            # if force*forces[i] < 0:
+            #     dc /=2
+            pQ = -np.log10(compute_Q(conc, stoichiometry))
+        
+            # Store results
+            iterations[i + 1] = i + 1
+            conc_A[i + 1] = conc['A']
+            conc_B[i + 1] = conc['B']
+            forces[i + 1] = force
+        
+            # Check convergence
+            # if np.isclose(pQ, pK_eq, rtol=rtol):
+            if np.abs(force) < rtol:
+                # Trim unused array space if converged early
+                return np.column_stack([
+                    iterations[:i + 2],
+                    conc_A[:i + 2],
+                    conc_B[:i + 2],
+                    forces[:i + 2]
+                ])
+    
+        # Return all iterations if no convergence
+        return np.column_stack([iterations, conc_A, conc_B, forces])
+
+    def plot(data,labels=None,refs=None,log=False,axes=None):
+        ncols = data.shape[1]
+        colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
+        plt.figure(figsize=(4,4))
+        for i in range(0,ncols-1):
+            plt.plot(data[:,0],data[:,i+1],label=labels[i],color=colors[i])
+        
+        if refs is not None:
+            for i in range(len(refs)):
+                plt.axhline(refs[i],linestyle='dashed',label=labels[i]+"$_{exact}$",color=colors[i])
+
+        if axes is not None:
+            plt.xlabel(axes[0])
+            plt.ylabel(axes[1])
+        if log:
+            plt.yscale("log")
+        plt.legend()
+        return plt.gca()
+
+
+    data = solve_equilibrium(conc,stoich,pkeq,dc,rtol,max_iterations=1000)
+    final_conc = {"A":data[-1,1] , "B":data[-1,2]}
+
+    roots = solve_analytic(conc,float(keq.value))
+    analytic_solution = [ data[0,1] + stoich["A"]*roots[0] , data[0,2] + stoich["B"]*roots[0] ]
+
+
+    plot_c = plot(data[:,0:3],labels=["[A]","[B]"],refs=analytic_solution,axes=["Cycles","Concentration"])
+    plot_f = plot(
+        np.column_stack([data[:,0],np.abs(data[:,3])]),
+        labels=["Force"],refs=[rtol],log=True,axes=["Cycles","Force"])
+    final = mo.md(
+        f"""
+        ##**Final conditions**
+
+        $[A]_f$ = {final_conc["A"]:.4e} &nbsp; &nbsp;
+        $[B]_f$ = {final_conc["B"]:.4e} &nbsp; &nbsp;
+        $Q$ = {compute_Q(final_conc,stoich):.4e} &nbsp; &nbsp;
+        $K_{{eq}}$ = {float(keq.value):.4e} \n
+        Final force = {compute_force(final_conc,stoich,pkeq):.4e} &nbsp; &nbsp;
+        Force threshold = {float(tol.value):.4e}
+
+        """
+    )
+
+    mo.vstack([initial,final,
+        mo.hstack([plot_c,plot_f])
+        ])
+
+    return (
+        analytic_solution,
+        conc,
+        data,
+        dc,
+        final,
+        final_conc,
+        initial,
+        pkeq,
+        plot,
+        plot_c,
+        plot_f,
+        roots,
+        rtol,
+        solve_equilibrium,
+        stoich,
+    )
+
+
+if __name__ == "__main__":
+    app.run()

marimo/index.html

@@ -103,32 +103,26 @@
             <p style="text-align: center">Version 1 - 20/02/2025</p>
         </a>
         <a href="/stats" class="lab-card">
-            <h3 style="text-align: center">Statistics Lab</h3>
+            <h3 style="text-align: center">Statistics</h3>
             <p style="text-align: center">Basic statistical concepts and Python introduction<br>(Week 2)</p>
         </a>
         <a href="/bc" class="lab-card">
-            <h3 style="text-align: center">Bomb Calorimetry Lab</h3>
+            <h3 style="text-align: center">Bomb Calorimetry</h3>
             <p style="text-align: center">Thermodynamics and heat measurements<br>(Week 4)</p>
         </a>
         <a href="/cv" class="lab-card">
-            <h3 style="text-align: center">Crystal Violet Lab</h3>
+            <h3 style="text-align: center">Crystal Violet</h3>
             <p style="text-align: center">Chemical kinetics and reaction rates<br>(Week 8)</p>
         </a>
+        <a href="/eq" class="lab-card">
+            <h3 style="text-align: center">Chemical Equilibrium</h3>
+            <p style="text-align: center">Numerical solution of equilibrium problems<br>(Week 10)</p>
+        </a>
         <a href="/surface" class="lab-card">
-            <h3 style="text-align: center">Surface Adsorption Lab</h3>
-            <p style="text-align: center">Equilibrium and surface chemistry<br>(Week 10)</p>
+            <h3 style="text-align: center">Surface Adsorption</h3>
+            <p style="text-align: center">Equilibrium and surface chemistry<br>(Week 12)</p>
         </a>
     </div>
-
-    <!--
-    <embed
-        src="/pdf/direct/calendar.pdf"
-        type="application/pdf"
-        width="100%"
-        height="600px"
-    />
-    -->
-
     
     <h2 style="text-align: center"><strong>Check the unit outline for when the reports are due</strong></h2>
     

marimo/pdfs/LabManualCHEM2000-1.pdf

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7d4837ecf82f7380646b50441cd3ddfade7adc0627e1dcac8e091d00e53338e7
-size 3218438
+oid sha256:1edb8d09bfc9d1d3102d3c30f0530ad10a26f189f0dd9077fa86a6946018e6b9
+size 4779263

marimo/statistics_lab.py

@@ -7,7 +7,7 @@ app = marimo.App(width="medium")
 @app.cell
 def _():
     import marimo as mo
-    import pycek_public as cek
+    import pycek as cek
     lab = cek.stats_lab(make_plots=True)
     return cek, lab, mo
 

marimo/surface_adsorption.py

@@ -7,7 +7,7 @@ app = marimo.App(width="medium")
 @app.cell
 def _():
     import marimo as mo
-    import pycek_public as cek
+    import pycek as cek
     lab = cek.cek.surface_adsorption(make_plots=True)
     return cek, lab, mo
 

src/pycek_public/cek_labs.py

@@ -73,6 +73,9 @@ class cek_labs(ABC):
         self.update_metadata_from_attr()
         self.logger.critical(f"Initial seed = {np.random.get_state()[1][0]}")
 
+    def reset(self):
+        np.random.seed(self.student_ID)
+
     def set_token(self, token):
         self.token = token
         #print(f"Check: {self._check_token()}")