The Kitchin Research GroupChemical Engineering at Carnegie Mellon University |
Posted October 11, 2015 at 02:17 PM | categories: news | tags:
Kenate Nemera is joining us for 9 months on a Fulbright Fellowship! Kenate is an assistant professor at Addis Ababa University in Ethiopia. Kenate will help us with our recent work in modeling metal oxide polymorphs. Welcome Kenate!
Copyright (C) 2015 by John Kitchin. See the License for information about copying.
Org-mode version = 8.2.10
Posted October 09, 2015 at 11:54 AM | categories: orgmode | tags:
There was a recent suggestion on the org-mode mailing list to make it possible to toggle individual equations in org-mode when the cursor is on them, and have them toggle back when the mouse is off. Presumably, this would let you edit the equation and see the result very easily.
The strategy to enable this is to use add a function to the post-command function hook. The function will store the last fragment/environment you were on, and compare it to where you are now. If they are different the function will put the overlay back on the previous point, and do something appropriate at the current point, e.g. nothing if you are not on a fragment, or remove the overlay of the fragment you are on. The function will get run after every command, so we make sure we are in org-mode first!
Here are some example equations.
Here is a sentence with an equation \(f^{2x}=3\) and another form \(e^x = 20\) in it.
Here is a standalone equation environment.
\begin{equation} a + b \sqrt{5o} \end{equation}And now, \[15 + 7 = 12\],
It is easiest to see this in a video here: https://www.youtube.com/watch?v=E0s3PDBqsEc
(defvar org-latex-fragment-last nil "Holds last fragment/environment you were on.") (defun org-latex-fragment-toggle () "Toggle a latex fragment image " (and (eq 'org-mode major-mode) (let* ((el (org-element-context)) (el-type (car el))) (cond ;; were on a fragment and now on a new fragment ((and ;; fragment we were on org-latex-fragment-last ;; and are on a fragment now (or (eq 'latex-fragment el-type) (eq 'latex-environment el-type)) ;; but not on the last one this is a little tricky. as you edit the ;; fragment, it is not equal to the last one. We use the begin ;; property which is less likely to change for the comparison. (not (= (org-element-property :begin el) (org-element-property :begin org-latex-fragment-last)))) ;; go back to last one and put image back (save-excursion (goto-char (org-element-property :begin org-latex-fragment-last)) (org-preview-latex-fragment)) ;; now remove current image (goto-char (org-element-property :begin el)) (let ((ov (loop for ov in org-latex-fragment-image-overlays if (and (<= (overlay-start ov) (point)) (>= (overlay-end ov) (point))) return ov))) (when ov (delete-overlay ov))) ;; and save new fragment (setq org-latex-fragment-last el)) ;; were on a fragment and now are not on a fragment ((and ;; not on a fragment now (not (or (eq 'latex-fragment el-type) (eq 'latex-environment el-type))) ;; but we were on one org-latex-fragment-last) ;; put image back on (save-excursion (goto-char (org-element-property :begin org-latex-fragment-last)) (org-preview-latex-fragment)) ;; unset last fragment (setq org-latex-fragment-last nil)) ;; were not on a fragment, and now are ((and ;; we were not one one (not org-latex-fragment-last) ;; but now we are (or (eq 'latex-fragment el-type) (eq 'latex-environment el-type))) (goto-char (org-element-property :begin el)) ;; remove image (let ((ov (loop for ov in org-latex-fragment-image-overlays if (and (<= (overlay-start ov) (point)) (>= (overlay-end ov) (point))) return ov))) (when ov (delete-overlay ov))) (setq org-latex-fragment-last el)))))) (add-hook 'post-command-hook 'org-latex-fragment-toggle)
| org-latex-fragment-toggle | matlab-start-block-highlight-timer | eldoc-schedule-timer |
I think there could be another way to do this with text properties, e.g. point-left and point-entered, but that would require those properties to be set on the fragments. I might try that approach another day.
Copyright (C) 2015 by John Kitchin. See the License for information about copying.
Org-mode version = 8.2.10
Posted October 05, 2015 at 07:15 PM | categories: orgmode, emacs | tags:
Updated December 09, 2016 at 03:10 PM
A while ago I had a need for a checklist in org-mode where only one value would be checked at a time. Like a radio button in a browser form. That isn't as far as I know a feature yet, but it was not hard to achieve thanks to the org-element api. My simple idea is to make a function that will be added to the org-checkbox-statistics-hook. The function will uncheck all the boxes, and recheck the one you just clicked with a hybrid of manipulating the cursor and inserting characters with org-element code. We will use an attribute on the checklist to indicate it is a "radio" list. This seems like a feature that might already exist, but I couldn't find it.
Here is the code we run. First, we make sure we are on a plain list that has an attr_org property of ":radio", that way this won't apply to all lists, just the radio lists. Then, we loop through each element in the structure, and if it is checked, we replace [X] with [ ]. Then, we reinsert the X and delete a space, which puts [X] where we originally clicked, or used C-c C-c. Finally, we add it to the hook, so it only gets run when a checkbox is changed via clicking with org-mouse, or C-c C-c. Of course, this doesn't work if you type X in the box.
(require 'dash) (defun check-hook-fn () (when (-contains? (org-element-property :attr_org (org-element-property :parent (org-element-context))) ":radio") (save-excursion (loop for el in (org-element-property :structure (org-element-context)) do (goto-char (car el)) (when (re-search-forward "\\[X\\]" (line-end-position) t) (replace-match "[ ]")))) (forward-char) (insert "X") (delete-char 1))) (add-hook 'org-checkbox-statistics-hook 'check-hook-fn)
| check-hook-fn |
Here is a regular checklist. You can check as many as you want.
[X] one[X] two[ ] threeNow, here is a radio checklist. Only one item at a time can be checked. Nice!
[ ] a[ ] b[X] cIt is worth noting here that if we put a name on the list, it becomes an addressable data source. First we need this convenient function to get the data associated with a named list.
(defun org-get-plain-list (name) "Get the org-element representation of a plain-list with NAME." (catch 'found (org-element-map (org-element-parse-buffer) 'plain-list (lambda (plain-list) (when (string= name (org-element-property :name plain-list)) (throw 'found plain-list))))))
org-get-plain-list
Now, let's use that to get the value of the checked item in the "test" list. We define the item as everything after the [X] and get it from a regular expression match.
(defun get-radio-list-value (list-name) "Return the value of the checked item in a radio list." (save-excursion (loop for el in (org-element-property :structure (org-get-plain-list list-name)) if (string= (nth 4 el) "[X]") return (progn (let ((item (buffer-substring (car el) (car (last el))))) (string-match "\\[X\\]\\(.*\\)$" item) (match-string 1 item)))))) (get-radio-list-value "test")
c
Perfect. This has lots of potential applications. Data collection and quizzes come to mind, with associated ability to autograde and aggregate the data!
Copyright (C) 2016 by John Kitchin. See the License for information about copying.
Org-mode version = 9.0
Posted October 03, 2015 at 08:23 PM | categories: emacs, python | tags:
Updated October 03, 2015 at 08:29 PM
Autolab is an autograding service that automatically grades code assignments. It uses a program to evaluate a program on a secure virtual system. Using this requires you to run a server, and run code from students. I have never liked that because it is hard to sandbox code well enough to prevent malicious code from doing bad things. Autolab does it well, but it is a heavy solution. Here we explore a local version, one that is used to test for correctness, and not for grading. Here, if you are malicious, you reap what you sow…
The basic idea I am working towards is that Emacs will provide content to be learned (through org-mode) with active exercises. The exercises will involve a code block, and the user will run a command on their code (or an advised C-c C-c) that checks the solution for correctness. A user will be able to see the solution, and maybe get hints.
Suppose we have a problem to solve \(e^x = 3\). This is a simple problem to solve, and here is a solution.
from scipy.optimize import fsolve import numpy as np def objective(x): return np.exp(x) - 3 def solve(): return fsolve(objective, 3) print solve()
[ 1.09861229]
We would like to test this for correctness. We code this in a function-based form because we will later use the function solve to test for correctness. Let's see how we could test it with a test function. We will use exec on a string representing our code to get it into our namespace. I don't see a security issue here. You are writing the code! Eventually, we will be passing code to the test framework this way from an org-mode source block.
import unittest TOLERANCE = 1e-5 s = '''from scipy.optimize import fsolve import numpy as np def objective(x): return np.exp(x) - 3 def solve(): return fsolve(objective, 3)[0] print solve()''' def test_solve(s): exec s in globals() if (abs(np.log(3) - solve()) <= TOLERANCE): print('Correct') else: print('incorrect') test_solve(s)
1.09861228867 Correct
Next, we need to think about how we could generate an import statement from a code block name, import in python, and run a test function. We can assume that the test code will be in a file called "test_%s.py" on your python path. Here are the contents of test_solve.py.
import numpy as np TOLERANCE = 1e-5 def solve_solution(): from scipy. optimize import fsolve import numpy as np def objective(x): return np.exp(x) - 3 return fsolve(objective, 3)[0] def test_solve(s): exec s in globals() if (abs(solve_solution() - solve()) <= TOLERANCE): print('Correct!') else: print('Incorrect')
Now, we can import that, and use the functions. Here is the Python script we need to run to test it.
import test_solve test_solve.test_solve(''' from scipy. optimize import fsolve import numpy as np def objective(x): return np.exp(x) - 3 def solve(): return fsolve(objective, 3)[0] print solve()''')
1.09861228867 Correct!
Now, an elisp block to do that. One way to do this is to just run a shell command passing the string to a python interpreter. This is a short way away from an Emacs command now.
(let* ((string "import test_solve test_solve.test_solve(''' from scipy. optimize import fsolve import numpy as np def objective(x): return np.exp(x) - 3 def solve(): return fsolve(objective, 3)[0] print solve()''')")) (shell-command-to-string (format "python -c \"%s\"" string)))
1.09861228867 Correct!
Ok, now to wrap it all up in a function we can run from Emacs in a code block to test it. With the cursor in a code block, we get the name, and build the python code, and run it. The function is more complex than I anticipated because I end up running the code block essentially twice, once to get a results block and once to get the test results. For short problems this is not an issue. I also add the test results in a way that is compatible with the current results.
(defun check () (interactive) (let* ((src-block (org-element-context)) (name (org-element-property :name src-block)) (code (org-element-property :value src-block)) (end (org-element-property :end src-block)) (results) (template (format "import test_%s test_%s.test_%s('''%s''')" name name name code)) (output (format "\n%s\n" (s-join "\n" (mapcar (lambda (s) (if (s-starts-with? ":" s) s (concat ": " s))) (s-split "\n" (shell-command-to-string (format "python -c \"%s\"" template)))))))) ;; execute block as normal (org-babel-execute-src-block) ;; and add some output to the Results block (if (org-babel-where-is-src-block-result) (progn (goto-char (org-babel-where-is-src-block-result)) (setq results (org-element-context)) ;; delete results line (kill-line) ;; delete the results (setf (buffer-substring (org-element-property :begin results) (org-element-property :post-affiliated results)) "") ;; paste results line back (yank) ;; and the output from your code (insert output)) (message "%s" output))))
check
Now, we use a named src-block so we can call M-x check in it, and check the answer.
from scipy.optimize import fsolve import numpy as np def objective(x): return np.exp(x) - 3 def solve(): return fsolve(objective, 3) print solve()
[ 1.09861229] Correct!
I would like to be able to provide a solution function that would show a user my solution they were tested against. Python provides the inspect module that can do this. Here is how we get the code in Python.
import inspect import test_solve print inspect.getsource(test_solve.solve_solution)
def solve_solution():
from scipy. optimize import fsolve
import numpy as np
def objective(x):
return np.exp(x) - 3
return fsolve(objective, 3)[0]
This makes it easy to wrap up a function in emacs that will show this from at src block. We just get the block name, and build the python code and execute it here.
(defun show-solution () (interactive) (let* ((src-block (org-element-context)) (name (org-element-property :name src-block)) (template (format "import inspect import test_%s print inspect.getsource(test_%s.%s_solution)" name name name))) (switch-to-buffer-other-window (get-buffer-create "solution")) (erase-buffer) (insert (shell-command-to-string (format "python -c \"%s\"" template))) (python-mode)))
show-solution
That summarizes the main features. It allows me to write a test module that has some name conventions to define a solution function, and a test function. Emacs can generate some boilerplate code for different problem names, and run the test to give the user some feedback. Most of the code in this post would not be directly visible to a user, it would be buried in a python module somewhere on the path, and in elisp files providing the glue. I am not sure how much obfuscation you can put in the python files, e.g. just providing byte-compiled code, so it is less easy to just read it. That is not as big a deal when it is just a study guide/feedback system.
From an authoring point of view, this seems pretty good to me. It is feasible I think to write an org-source document like this with tangling for the test modules, and an export to org that does not have the solutions in it. The only subtle point might be needing to alter Python paths to find the test modules if they aren't installed via something like pip.
I think this is pretty flexible, and could handle problems that take arguments, e.g. write a function that sorts a list. Here is a simple example of that. First we write the test_sort.py file with a solution, and some tests.
def sort_solution(LIST): return LIST.sort() def test_sort(s): exec s in globals() if sort([3, 4, 2]) == [2, 3, 4]: print('passed test 1') if sort(['z', 'b']) == ['b', 'z']: print('passed test 2')
def sort(LIST): s = sorted(LIST) return s
passed test 1 passed test 2
Maybe it would make sense to use unittests, or nose or some other testing framework if it makes writing the tests easier. Another day.
Copyright (C) 2015 by John Kitchin. See the License for information about copying.
Org-mode version = 8.2.10
Posted September 30, 2015 at 11:58 AM | categories: publication, news | tags:
We have a new publication in Phys. Chem. Chem. Phys. on the reactivity of different oxide polymorphs. In this work we examine the reactivity of some common BO2 oxide polymorphs for Ru, Rh, Pt and Ir oxides. These are all normally rutile formers, but it may be possible to synthesize them in other polymorphs as epitaxial films, or under pressure. We examined how the reactivity of the polymorphs would differ from that of the most stable phase, and the impact of those changes on the oxygen evolution reaction. We predict that the reactivity may be improved in some cases. Congratulations Zhongnan!
http://pubs.rsc.org/en/Content/ArticleLanding/2015/CP/C5CP04840K#!divAbstract
@article{xu-2015-tunin-oxide, author = "Xu, Zhongnan and Kitchin, John R", title = {Tuning Oxide Activity Through Modification of the Crystal and Electronic Structure: From Strain To Potential Polymorphs}, journal = "Phys. Chem. Chem. Phys.", year = 2015, doi = "10.1039/C5CP04840K", url = "https://doi.org/10.1039/C5CP04840K", publisher = "The Royal Society of Chemistry", abstract = "Discovering new materials with tailored chemical properties is vital for advancing key technologies in catalysis and energy conversion. One strategy is the modification of a material{'}s crystal structure{,} and new methods allow for the synthesis and stabilization of potential materials in a range of crystal polymorph structures. We assess the potential reactivity of four metastable oxide polymorphs of MO2 (M=Ru{,} Rh{,} Pt{,} Ir) transition metal oxides. In spite of the similar local geometry and coordination between atoms in the metastable polymorphic and stable rutile structure{,} we find that polymorph reactivities cannot be explained by strain alone and offer tunable reactivity and increased stability. Atom-projected density of states reveals that the unique reactivity of polymorphs are caused by a redistribution of energy levels of the t2g-states. This structure-activity relationship is induced by slight distortions to the M-O bonds in polymorphic structures and is unattainable by strain. We predict columbite IrO2 to be more active than rutile IrO2 for oxygen evolution", }
Copyright (C) 2015 by John Kitchin. See the License for information about copying.
Org-mode version = 8.2.10