Note: This post will be updated as I discover new use cases and tools. Check back for the latest additions.

Literature Search

I usually start my research by doing a literature search on Google Scholar, finding a few interesting papers, and then—based on those papers—searching for other related papers (e.g., papers that have cited them). This is time-consuming and often I find myself getting lost in the sea of papers. With Claude, I can quickly find relevant papers based on a specific topic or keyword using natural language. For example, if I’m interested in “machine learning in hydrology,” I can ask Claude to retrieve relevant papers published in the last 5 years using a prompt like:

Find the top 5 most cited papers on "machine learning in hydrology" published in the last 5 years.

Claude will search the web including Google Scholar and return a list of relevant papers, including their titles, authors, publication years, and even a brief summary if available. Then, I can further ask Claude to look for papers that have cited these key papers, like a citation graph, to get other relevant papers. Optionally, you can ask Claude to retrieve the PDF or fulltext of the papers if they are accessible. You can then pass those papers to Zotero for management and annotation (see next section).

You can even ask Claude to write a literature review based on the retrieved papers, though I haven’t tested that yet.

Setup

• Install the Paper Search MCP.

git clone https://github.com/openags/paper-search-mcp.git ~/paper-search-mcp

# Set up the skill for Claude Code
mkdir -p ~/.claude/skills/paper-search
cp ~/paper-search-mcp/claude-code/SKILL.md ~/.claude/skills/paper-search/SKILL.md

• Edit the SKILL.md file to replace the placeholder values <REPO_PATH>. You can also just ask Claude to edit the file for you.

Literature Management

Search for Relevant Papers in Zotero

I find this the most useful feature. I use Zotero to manage my references, and I often struggle to find relevant papers when the library contains hundreds of entries. The search function in Zotero is just not that good. With Claude, I can quickly find papers related to a specific topic or keyword using natural language. For instance, if I’m researching “machine learning in hydrology,” I can ask Claude to retrieve relevant papers from my Zotero library, using a prompt like:

Find papers in my Zotero library related to "machine learning in hydrology" in the last 5 years.

Then Claude will return a list of relevant papers, including their titles, authors, publication years, and even a brief summary if available. This saves me a lot of time and helps me stay organized with my research materials.

The main benefit of using Zotero is it prevents Claude from hallucinating papers that do not exist.

Summarize Research Papers

Another great use case is summarizing research papers. I often annotate papers as I read and have developed a color code for different annotation types. When I am done, I export the annotations as notes to my Obsidian app (see my previous post on this workflow). I also like to write a short summary highlighting the key points and knowledge gaps. All of this was done manually, and it can be time-consuming when you have many papers. With Claude, I can quickly generate summaries of papers based on my annotations and let it write the note into Zotero or Obsidian. For example, I can ask:

Summarize the key findings and knowledge gaps of Shuai et al., 2017 based on my annotations and write this as note in Zotero.

Claude may ask a few clarifying questions about the note. It will then generate a concise summary based on the annotations. When you open Zotero, the note is there. This is especially useful when I want to quickly review the key points of a paper without having to read through the entire document again. It also helps me keep my notes organized and easily accessible for future reference.

You can also ask Claude to write a “when to cite” section based on the summary and annotations.

Setup

• Install the Zotero MCP.

# install zotero mcp
uv tool install zotero-mcp-server

# set up 
zotero-mcp setup  # Auto-configure (Claude Desktop supported)
# this will configure a few options

#optional. this will enable pdf outline extraction, scite citation...
uv tool install "zotero-mcp-server[all]"    # Full install with all features

• Enable Zotero Local API: Settings-->Advanced-->Miscellaneous, toggle the box for Allow other applications on this computer to communicate with Zotero. It will say Available at http://localhost:23119/api/
• Initialize and Update database.

# Build the semantic search database (fast, metadata-only)
zotero-mcp update-db

# Build with full-text extraction (slower, more comprehensive)
zotero-mcp update-db --fulltext

Manage Email Subscription

I often subscribe to Google Scholar alerts for my research topic and have them sent to my Gmail account. I then read those emails to find new papers relevant to my research. With Claude, I can automate this process by having it access my Gmail account and retrieve the alerts and create a well formatted newsletter for me on a regular basis (e.g., weekly). Claude can intelligently group papers by themes, summarize the key findings, and even highlight the most relevant papers based on my research interests. This way, I can stay up-to-date with the latest research without having to manually check my email for alerts.

This may sound like the scariest scenario—having Claude access your personal email—but if you prefer not to use your personal account, you can set up a separate dummy Gmail account just for this purpose.

Setup

Set up is pretty straightforward. You just need to connect your Gmail account to Claude.

• Download and install the Claude Desktop app.
• Go to Customize-->Connectors-->Gmail and connect your Gmail account. You can choose the different read/write permissions based on your needs.

Codebase Expert

I often use open-source code in my research, but it can be difficult to understand how it works, especially when the codebase is large and complex. For example, I use ATS for hydrologic modeling and sometimes need to know how ATS calculates certain fields and what the governing equations are. With Claude, I can quickly get the answer by asking specific questions about how certain functions or modules work. For example, if I want to understand how ATS calculates longwave radiation internally, I can ask Claude:

Can you explain how the longwave radiation is calculated in ATS?

Claude will then search through the codebase and provide a detailed explanation of the relevant functions and equations used in the calculation.

Setup

This requires a customized MCP that connects to the codebase. Without an MCP, Claude will try to search the web or the GitHub repo, which may not be efficient and can lead to hallucinations. With an MCP, Claude can directly access the codebase and provide accurate, detailed explanations.

I do not have experience with this, so I just ask Claude to build the MCP for me using existing examples. I mostly followed the pywrdrb-mcp example and adopted their repo structure.

In the end, I built a custom MCP—ats-mcp—which I can use to ask questions about the ATS codebase, including source code, documentation, test cases, and demo examples across multiple repositories.

USGS Water Data Retrieval

Retrieve USGS water data using the USGS Water Data MCP. This MCP uses the USGS Water Data API to retrieve water data such as streamflow, groundwater levels, and water quality parameters based on user queries. For example, if I want to retrieve streamflow data for a specific location and time period, I can ask Claude:

Plot the streamflow for the Logan River in Utah for the last year.

Other Applications

• Git commit message: Use Claude to generate descriptive commit messages based on the changes in the code. Just say:

commit this

This requires authentication with GitHub or another version control system. I find Claude very helpful for generating clear and concise commit messages, especially since I often forget exactly what changes I made.

Tips

These are some tips that I found useful when using Claude. Many of these can also be found in the official documentation and community posts (e.g., claude-code-tips).

• Context matters. Use @ to directly reference files and /add-dir to add a directory to the context, or paste screenshots or code snippets. This will help Claude understand the task better and provide more accurate responses. However, too much context will slow down Claude and cause it to forget what was told earlier.

• Plan first before you let Claude do the work. Ask Claude to come up with a detailed plan for a task. Let Claude ask you clarifying questions to make sure it understands the task correctly. This will save you time and tokens in the long run. E.g.,I want to build a personal website. Interview me in detail to understand my needs and preferences, then come up with a detailed plan for how to build the website.

• Provide verification or success criteria for the task you want to accomplish. If possible, provide some test cases or expected outputs (e.g., a screenshot). At the minimum, put a “success criteria” section in the end of the prompt and let Claude verify if the task is accomplished successfully. This can greatly reduce the chances of getting an inaccurate or incomplete response from Claude.

• Ask Claude to correct its own mistakes. If you find that the response from Claude is not accurate or contains errors, you can ask it to correct itself and put what it has learned into the memory so it won’t make the same mistake again. It is kind of like training an AI to improve itself over time.

• Provide a concise readme file–CLAUDE.md for every project. This could include specific instructions, commands, best practices, and common gotchas for using Claude with that project.

• Use skills–SKILL.md for repetitive workflows. If you find yourself doing the same thing over and over again, consider creating a skill for it. For example, if you often ask Claude to create a newsletter from common sources in a specific format, you can create a skill (e.g., /create-newsletter) that automates this process.

• Ask Claude if you don’t know how to do something. For example, if you want to set up a MCP but don’t know how to do it, just ask Claude: How can I set up a MCP to connect to my codebase? Even better, provide an example that you found somewhere and ask Claude to understand it and learn from it: Use this example (link to the example) to learn how to set up a MCP, then use it to create a MCP for my codebase.

• Don’t be afraid to experiment and try new things with Claude. The more you use it, the more you will discover its capabilities and how it can best assist you in your academic work.

Reference

• A Beginner’s Guide for the LLM-Curious, Part 2
• Claude Code Best Practices
• claude-code-tips

Before you start, make sure you have created and published the python package on Pypi.

Create conda environment and install conda-install

In this example, we use pypackage as the environment name.

conda create --name pypackage python
conda activate pypackage
conda install conda-build
conda install grayskull

Download Pypi package locally

This assumes that you have already published your package on Pypi. If not, please refer to my previous post on how to publish a python package on Pypi.

You can download the package from Pypi using:

pip download --no-deps --no-binary :all: <package_name>

This will download a tarball file (e.g., <package_name>-0.1.0.tar.gz) to the current working directory.

Create conda recipe

The only thing that’s needed for creating the conda package is a meta.yaml file. I will use the template provided by Conda-recipe.

To fill the meta.yaml file, we can use grayskull to generate a template based on the package on Pypi.

grayskull pypi <package_name>

Open the template and change the following fields:

• package/name: the name of your package
• package/version: the version of your package
• source/url: the URL of the source code, usually the tarball link on Pypi
• source/sha256: the sha256 checksum of the source code tarball. You can get it using sha256sum <package_name-xxx.tar.gz>
• requirements/build: the build dependencies, usually python and pip
• requirements/run: the runtime dependencies, usually the packages listed in requirements.txt on Github repo
• license: the license of your package, e.g., MIT
• license_file: the license file, e.g., LICENSE.txt

The rest of the fields can be left as default.

Add recipe to staged-recipes repo

• Fork the staged-recipes repo
• Clone the forked repo to your local machine
• Create a new branch using git checkout -b add-<package_name>
• Create a new folder under recipes with the same name as your package
• Add the meta.yaml file to the new folder
• Commit the changes using git commit -m "Add <package_name> recipe"
• Push the changes to your forked repo using `git push origin add-<package_name
• Create a pull request to the original staged-recipes repo

After your PR passes the review (make sure your ping using the comment “@conda-forge/help-python, ready for review!”), it will be merged to the main branch and your package will be built and uploaded to conda-forge automatically.

Test the package

You can create a new conda environment and install your package from conda-forge to test if it works.

conda create --name testenv python
conda activate testenv
conda install -c conda-forge <package_name>

Update the package

To update the package, you need to:

1. Update the version number in the meta.yaml file.
2. Update the source/url using the new version from Pypi.
3. Download the new tarball and update the source/url and source/sha256 fields in the meta.yaml file.
4. Commit the changes and push to your forked repo.
5. Create a pull request to the original staged-recipes repo.

Reference

• Build conda package from scratch: https://docs.conda.io/projects/conda-build/en/stable/user-guide/tutorials/build-pkgs.html
• How to publish a python package on conda-forge: https://blog.gishub.org/how-to-publish-a-python-package-on-conda-forge

Motivation

I previously used Overleaf, a cloud-based LaTeX editor, during my time at PNNL. Overleaf is excellent for creating professional manuscripts and supports collaboration, especially for premium users. However, after moving to the university, I lost access to the premium subscription and had to rely on the free version, which comes with limitations such as restricted compile time and slower performance. This prompted me to search for alternatives, and I discovered Mark Wang’s post about using LaTeX in VSCode as a replacement for Overleaf. If you’re curious about how LaTeX works in VSCode, I recommend checking out his original post for a detailed overview.

Setup environment

You will need a local installation of LaTeX, VScode and LaTex-Workshop extension to make it work.

Installing LaTeX

To install LaTeX using Mac as an example, go to TeX Live quick install page. I followed the macOS approach by downloading MacTeX (~6 GB) and installing it on my Mac Studio (Apple silicon).

Installing VScode and extension

Install VSCode for Mac from the offical website. Once installed, open VSCode and install the extension named LaTeX Workshop.

Using LaTeX in VSCode

First, download or locate the LaTeX files on your computer. For me, I have downloaded my LaTeX files from Overleaf. Then use VSCode to open the folder that contains the LaTeX files. Open the LaTeX file (e.g., paper.tex) using the VSCode editor.

Now you can view and edit your LaTeX file and make any changes. After you are done, click on the green triangle located on the top right panel to compile the LaTeX file. Or simply use keyboard shortcut Cmd + Option + B (Mac) or Ctrl + Alt + B (Windows/Linux) to compile the LaTeX file.

To view the compiled PDF, you can either click on the View LaTeX PDF button on the top right panel or use the keyboard shortcut Cmd + Option + V (Mac) or Ctrl + Alt + V (Windows/Linux). This will open a new tab in VSCode showing the compiled PDF.

To jump from a specific line in the LaTeX file to the corresponding location in the PDF, you can use the SyncTeX feature. Simply place your cursor on the line you want to jump from and press Cmd + Option + J (Mac) or Ctrl + Alt + J (Windows/Linux). This will synchronize the LaTeX file with the PDF and take you to the corresponding location. To do the reverse, you can click on the PDF and press Cmd + Click (Mac) or Ctrl + Click (Windows/Linux) to jump back to the LaTeX file.

Configuring LaTeX-Workshop to make it more like Overleaf

1. To enable auto build in VSCode, go to the settings (Cmd + Shift + P) and search for “Preferences: Configure language specific settings…”. Check the box for “Files: Auto Save”. This will automatically trigger the build when you make changes, allowing for an instant preview of your latest PDF.
2. Under the same settings, go to “Editor: Word Wrap”. Set it to on to enable line wrapping in LaTeX files.

Conclusion

Using LaTeX in VSCode is a great alternative to Overleaf, especially if you prefer a local setup or you do not need collaboration features. Plus, you can also utilize the rich collection of extensions offered by VSCode. For example, you can use the CoPilot extension to get AI-assisted writing suggestions.

On the downside, this setup requires a local installation of LaTeX, which can take up significant disk space and may require some initial configuration. However, once set up, it provides a powerful and flexible environment for writing LaTeX documents.

Pre-requisites:

• Docker installed on your machine. If you don’t have Docker installed, you can download it from here.

Setup

Create a Dockerfile

A Dockerfile is a text document that contains all the commands a user could call on the command line to assemble an image. The Dockerfile named “dockerfile-jupyter-pflotran” for building PFLOTRAN is shown below.

# Base image and setup
FROM ubuntu:22.04 AS base
LABEL org.opencontainers.image.ref.name="ubuntu"
LABEL org.opencontainers.image.version="22.04"
LABEL org.opencontainers.image.authors="Pin Shuai"
LABEL org.opencontainers.image.description="Docker image for running PFLOTRAN v6.0 with JupyterLab"

ARG NB_USER=aggie
ARG NB_UID=1000
ARG NB_GID=100
ARG PETSC_VERSION=v3.21.4  # Replace with the desired PETSc version so it works with the pflotran branch
ARG pflotran_branch=v6.0  # Replace with the desired PFLOTRAN branch
ENV DEBIAN_FRONTEND=noninteractive
ENV NB_USER=$NB_USER NB_UID=$NB_UID NB_GID=$NB_GID
ENV SHELL=/bin/bash
ENV PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

ENV PETSC_DIR=/scratch/petsc \
    PETSC_ARCH=petsc-arch 

# Add fix-permissions script
COPY fix-permissions /usr/local/bin/fix-permissions
RUN chmod +x /usr/local/bin/fix-permissions

# Install prerequisites
RUN apt update -qq && \
    apt install -y --no-install-recommends \
        git make cmake gcc gfortran g++ wget nano vim python3 python3-pip lcov ca-certificates && \
    apt clean && \
    rm -rf /var/lib/apt/lists/*


# Create user and set permissions. -m creates the home directory, -s sets the shell, -N does not create a group
RUN useradd -m -s /bin/bash -N -u $NB_UID $NB_USER && \
    fix-permissions /home/$NB_USER

# Conda and Python setup
USER $NB_USER
WORKDIR /home/$NB_USER

# install jupyter and Install Python packages
RUN pip3 install -U virtualenv
RUN pip3 install -U jupyterlab h5py matplotlib hydroeval numpy scipy pandas && pip3 cache purge
ENV PATH=/home/${NB_USER}/.local/bin:$PATH

# Add JupyterLab configuration
USER root
COPY jupyter_server_config.py /etc/jupyter/
COPY jupyter_notebook_config.py /etc/jupyter/
RUN chmod +x /etc/jupyter/jupyter_server_config.py 
RUN chmod +x /etc/jupyter/jupyter_notebook_config.py
RUN mkdir /home/${NB_USER}/.jupyter
COPY jupyter_notebook_config.py /home/${NB_USER}/.jupyter
RUN chmod +x /home/${NB_USER}/.jupyter/jupyter_notebook_config.py
RUN chown -R $NB_USER /home/${NB_USER}/.jupyter
COPY start.sh start-notebook.sh start-singleuser.sh /usr/local/bin/
RUN chmod +x /usr/local/bin/start*.sh

# Set up the build environment
WORKDIR /scratch

# Expose ports and final configuration
ENV JUPYTER_ENABLE_LAB=yes
EXPOSE 8888

# Build MPICH
RUN wget https://www.mpich.org/static/downloads/4.1/mpich-4.1.tar.gz --no-check-certificate

# Copy and build PETSc
COPY ./build-petsc.sh /scratch/build-petsc.sh
RUN chmod +x /scratch/build-petsc.sh && /scratch/build-petsc.sh
ENV PATH=/scratch/mpich-4.1/install/bin:$PATH

# Verify PETSc environment
RUN echo "PETSC version = ${PETSC_VERSION}" && \
    echo "PETSC directory = ${PETSC_DIR}" && \
    echo "PETSC arch = ${PETSC_ARCH}"

# Build PFLOTRAN
RUN git clone https://bitbucket.org/pflotran/pflotran.git /scratch/pflotran && \
    cd /scratch/pflotran && \
    git checkout ${pflotran_branch} 
RUN echo "PFLOTRAN branch = ${pflotran_branch}"
WORKDIR /scratch/pflotran/src/pflotran
RUN make clean && \
    make -j4 \
        gnu_code_coverage=1 \
        gnu_runtime_checks=1 \
        catch_warnings_as_errors=1 \
        pflotran 

WORKDIR /scratch/pflotran/src/pflotran/bin
RUN cp ../pflotran .

RUN chown $NB_UID:$NB_GID --from=root:root -R  /scratch/pflotran/src 

# Set PFLOTRAN environment variables
ENV PFLOTRAN_DIR=/scratch/pflotran \
    PFLOTRAN_EXE=/scratch/pflotran/src/pflotran/pflotran

# Set work directory back to user home
USER $NB_USER
WORKDIR /home/${NB_USER}
# RUN echo "Current user is: $(whoami) in working directory: $(pwd)"
# add pflotran to PATH 
ENV PATH=/scratch/pflotran/src/pflotran/bin:$PATH

# append the PATH and additional commands to the bashrc
RUN echo $PATH && \
    echo "export PATH=${PATH}" >> ~/.bashrc

# Copy the local .bashrc file into the image
COPY ./local_bashrc /scratch/local_bashrc
# Append the local .bashrc to the user's .bashrc in the image
RUN cat /scratch/local_bashrc >> ~/.bashrc

# Copy the local .vimrc file into the image
COPY ./local_vimrc /scratch/local_vimrc
# Append the local .vimrc to the user's .vimrc in the image
RUN touch ~/.vimrc && cat /scratch/local_vimrc >> ~/.vimrc

# Copy the local gitconfig file into the image
COPY ./gitconfig /scratch/gitconfig
# Append the local gitconfig to the user's gitconfig in the image
RUN touch ~/.gitconfig && cat /scratch/gitconfig >> ~/.gitconfig

# Final stage: Add metadata and expose ports
# LABEL maintainer="Your Name <your.email@example.com>"
EXPOSE 8888

# create a work directory
WORKDIR /home/${NB_USER}/work

Build the Docker image

The script below builds the Docker image using dockerfile dockerfile-jupyter-pflotran.

• General Build. The build architecture defaults to the host machine (e.g., arm64). Note the . in the end of the command which specifies the build context. For my Mac M1 chip, the build is pretty fast (~30 minutes).

docker build --progress=plain -f ./dockerfile-jupyter-pflotran -t pshuai/jupyter-pflotran:v6.0 .

• Platform-specific Build. The build architecture is specified as linux/amd64. Because the build is done on a Mac M1 chip, it took very long time (almost 2 hrs) to complete.

docker build --platform linux/amd64 --progress=plain -f ./dockerfile-jupyter-pflotran -t pshuai/pflotran-jupyter-amd64:v6.0 .

• Multiplatform Build. The build architecture is specified as linux/amd64,linux/arm64. Must include the --push flag to push the image to Dockerhub. Docker does not save multi-platform images unless the --push flag is used. The build took about 2 hrs on my Mac M1 chip.

# First, create a new builder instance (e.g., desktop-linux) that enables building for multiple platforms.
docker buildx create --use desktop-linux

# to check the builder instance
docker buildx ls

# start build with the --platform args. 
# IMPORTANT! add --push to push to Dockerhub, otherwise the multi-platform image will not be saved! 
docker buildx build --platform linux/amd64,linux/arm64 --progress=plain -f ./dockerfile-jupyter-pflotran -t pshuai/jupyter-pflotran-multiplatform:latest -t pshuai/jupyter-pflotran-multiplatform:base_v6 --push .

After the build is complete, you can pull the image and check the architecture on your machine.

docker run --rm pshuai/jupyter-pflotran-multiplatform:latest uname -m

#If you're running on an x86-64 machine, you should see x86_64
x86_64
#If you're running on an ARM machine, you should see 
aarch64

Inspect the Docker image

You can inspect the Docker image to see the layers and the size of the image.

docker inspect pshuai/jupyter-pflotran-multiplatform:latest

You can also just check the labels of the image.

docker inspect --format='' pshuai/jupyter-pflotran-multiplatform:latest

Run the image

Run PFLOTRAN

To run PFLOTRAN, use the following command. $(PFLOTRAN_DIR) is the directory to your PFLOTRAN repository. This will mount the ufd directory to the container’s /home/aggie/work directory and run the ufd_abc.in input file. You will see the screen output from PFLOTRAN if docker runs successfully.

docker run -it --rm -v $PFLOTRAN_DIR/regression_tests/ufd:/home/aggie/work pshuai/jupyter-pflotran-arm64:v6.0 pflotran -pflotranin ./ufd_abc.in

Run JupyterLab

To run JupyterLab, use the following command. $(pwd) is the current directory in your terminal.

docker run -it --rm -p 8888:8888  -v $(pwd):/home/aggie/work pshuai/jupyter-pflotran-arm64:v6.0 jupyter lab --ip=0.0.0.0 --allow-root --NotebookApp.token=''

This will print out the following in the terminal:

    Jupyter Server 2.15.0 is running at:
    http://6392a6f60965:8888/lab
    http://127.0.0.1:8888/lab

Open a browser and copy and paste the following http://127.0.0.1:8888/lab in the address to access the active jupyterlab session.

Push to Dockerhub

# check docker images
docker images

# login to dockerhub
$ docker login -u pshuai
Password: xxxx

# tag the local image with the remote repo. you can tag the same image multiple times with different tag names.
$ docker tag pshuai/jupyter-pflotran-arm64:v6.0 pshuai/jupyter-pflotran-arm64:v6.0
$ docker tag pshuai/jupyter-pflotran-arm64:latest pshuai/jupyter-pflotran-arm64:latest
# push to dockerhub after you created a new repo on Dockerhub; -a pushes all tags
$ docker push -a pshuai/jupyter-pflotran-arm64

Update the image

To update the existing image, you don’t need to rebuild the image from scratch. You can simply update the Dockerfile and run the following command to rebuild the image.

Update the Dockerfile

Use the existing image as your BASE image and create a new Dockerfile named dockerfile-jupyter-pflotran-updated. For example, you can add new packages.

# This will use the existing multiplatform image as the base image. Choose the platform that you want to use.
FROM pshuai/jupyter-pflotran-multiplatform:base_v6 AS base

USER root
# Install packages: tree
RUN apt update -qq && \
    apt install -y --no-install-recommends \
        tree && \
    apt clean && \
    rm -rf /var/lib/apt/lists/*

ARG NB_USER=aggie

EXPOSE 8888

USER ${NB_USER}
# cd to work directory
WORKDIR /home/${NB_USER}/work

Build the updated image

• For general build, use the following command.

docker build --platform linux/arm64 --progress=plain -f ./dockerfile-jupyter-pflotran-updated -t pshuai/jupyter-pflotran-arm64:latest .

• For multiplatform build, use the following command.

docker buildx build --platform linux/amd64,linux/arm64 --progress=plain -f ./dockerfile-jupyter-pflotran-updated -t pshuai/jupyter-pflotran-multiplatform:latest --push .

Common Issues

1. The docker image size is too large.
   • This may be due to the build cache. You can clean up the cache by running the following command.

# this will only install the packages that are necessary for the build
 apt install -y --no-install-recommends

 # remove the cache
 rm -Rf petsc-arch/externalpackages

• The size may increase significantly if you chown ownership of the files. See the post here.

References

• Docker Documentation
• Docker Multi-platform builds

Steps

1. Go to this website
2. Enter your Google Scholar ID
3. Click Cloud Me
4. A word cloud is generated on the right. You can further tweak the shape and other details using the options on the left.

My word cloud

Here is the word cloud from my Google Scholar page. Hydrologic, river, exchange are keywords in my research. As a groundwater hydrologist, I am surprised to see that groundwater is not one of the big words. I think the website only grabs words from the paper titles, which may not provide the whole picture of my research.

This year I started a new note-taking app, Obsidian, which I really like. If you don’t know what Obsidian is, check out this nice article by Water Programming. Obsidian becomes my all-in-one place for my notes including meeting, research, and daily notes. Since I have been making reading notes in Zotero, I started thinking if it is possible to port my literature notes into Obsidian. I did a bit search online, and found many people have already figured out different ways to achieve this. This tutorial combines the contents from this Obsidian post and this Medium article on the Zotero-Obsidian workflow with some customization.

Pre-requisites:

• Zotero (v6.0+)
• Obsidian (v1.4+)
• Obsidian plugins: Zotero Integration, Templater, Dataview
• Zotero plugins: Better BibTeX for Zotero, Zotfile,
• (Optional) Zotero Browser Extension for Chrome/Firefox. This may be useful for downloading papers to Zotero.

Setup

Install Obsidian plugins

For this workflow to work, you will need to install Zotero Integration, Templater, Dataview plugins.

It may be difficult to find where the plugins are for the first time.

• Click the settings icon (ie. ) in the lower left corner of the app.
• Click Community plugins on the left panel and select browse. This will open window with a list of plugins.
• Search for the plugin (e.g., Zotero Integration), click install
• Once installed, click enable. This step is necessary to activate the plugin

Once you have all the plugins installed, you need to change the settings for each.

Zotero Integration Settings

Change settings in the Zotero Integration plugin.

• Go to Settings --> Community plugins --> Zotero Integration
• Set Zotero as the Database
• Set Note Import Location. This is where the notes will be stored in Obsidian. I use literature folder in my vault.
• Under Import Formats, click Add Import Format and add Output Path for notes and Image Output Path. Choose Template File as the template file for Zotero notes. I will provide a template below. Choose the Bibliography Style. I use APA style.

Install Zotero plugins

You may need the following plugins: It’s a bit inconvenient to install Zotero plugins.

• Download the .xpi file for each plugin (e.g., Go to xx)
• Open Zotero, go to Tools --> Add-ons
• Click settings icon on the upper right, select Install Add-on from File...
• Locate the downloaded .xpi file, click open, and select install

Better BibTeX for Zotero

This plugin is useful for creating citation keys (e.g., author_year) for papers.

• The citation key is used as note title in Obsidian. To change the citation keys
  • Go to Zotero --> Settings --> Advanced --> Advanced Configuration --> Config Editor, search for better-bibtex.citekeyFormat. Double click to edit the format. The default is ​auth.lower + shorttitle(3,3) + year. I used auth.capitalize+ year.postfix('\_') + journal (e.g., Tashie2022_WaterResour.Res.). More formatting options are available here

Create a template for Zotero Integration

To add a template, create a markdown file named zotero note template.md. You can also put it under a folder (e.g., templates).

I started with the template provided in this post. I like the different callouts used for citation, abstract, and etc. However, I don’t like the look of the annotations and the images are not embeded in the notes.

I came across this post in the Obsidian Forum, which color-codes the highlights and provides image embeding in the annotation. There is one little problem with the color style in the CSS snippet. The colors do not match the ones used in Zotero (see Variables in ref). I have updated the CSS snippet and provided below.

In the end, I combined those two templates and came up with a customized one(see code block below) that I really like.

Here is the color code for highlights:

I will breakdown into different sections:

• Cite: Citation of the paper
• Synthesis: Your personal opinions on this paper.
• Link: Link to the PDF file on your local PC.
• Abstract: Abstract of the article.
• Annotations: All highlights, notes, comments (including box comments), links grouped by color.
• Metadata: all metadata associated with the paper which are useful for data query using DataView.

---
cssclasses:
  - literature-note
category: literaturenote
title: {{title}}
tags:{% for t in tags %}
  - {{t.tag | replace(" ", "-")}}{% endfor %}
citekey: {{citekey}}
status: unread
dateread:
---

> [!Cite]
> {{bibliography}}

{% persist "notes" %}{% if isFirstImport %}
>[!Synthesis]
>**Contribution**:: 
>
>**Related**:: {% for relation in relations | selectattr("citekey") %} [[@{{relation.citekey}}]]{% if not loop.last %}, {% endif%} {% endfor %}
>
{% endif %}{% endpersist %}

> [!Link] 
> {%- for attachment in attachments | filterby("path", "endswith", ".pdf") %}
>  [{{attachment.title}}](file://{{attachment.path | replace(" ", "%20")}})  {%- endfor -%}.

> [!Abstract]-
> {%- if abstractNote %}
> {{abstractNote}}
> {%- endif -%}.


## Annotations

{%- macro colorValueToName(color) -%}
	{%- switch color -%}
		{%- case "#ffd400" -%}
			Relevant / important
		{%- case "#ff6666" -%}
			Disagree
		{%- case "#e56eee" -%}
			Critiques
		{%- case "#a28ae5" -%}
			Questions / confusion
		{%- case "#5fb236" -%}
			TODO / follow up
		{%- default -%}
			Note
	{%- endswitch -%}
{%- endmacro -%}

{%- macro calloutHeader(type) -%}
	{%- switch type -%}
		{%- case "highlight" -%}
			Highlight
		{%- case "strike" -%}
			Strikethrough
		{%- case "underline" -%}
			Underline
		{%- case "image" -%}
			Image
		{%- default -%}
			Note
	{%- endswitch -%}
{%- endmacro %}

{% persist "annotations" %}
{% set annots = annotations | filterby("date", "dateafter", lastImportDate) -%}
{% if annots.length > 0 %}
### Imported on {{importDate | format("YYYY-MM-DD h:mm a")}}

{% for color, annots in annots | groupby("color") -%}
#### {{colorValueToName(color)}}

{% for annot in annots -%}
> [!quote{% if annot.color %}|{{annot.color}}{% endif %}] {{calloutHeader(annot.type)}}
{%- if annot.annotatedText %}
> {{annot.annotatedText | nl2br}}
{%- endif -%}
{%- if annot.imageRelativePath %}
> ![[{{annot.imageRelativePath}}]]
{%- endif %}
{%- if annot.ocrText %}
> {{annot.ocrText}}
{%- endif %}
{%- if annot.comment %}
>
>> {{annot.comment | nl2br}}
{%- endif %}
>
> [Page {{annot.page}}](zotero://open-pdf/library/items/{{annot.attachment.itemKey}}?page={{annot.page}}) [{{annot.date | format("YYYY-MM-DD#h:mm a")}}]

{% endfor -%}
{% endfor -%}
{% endif %}
{% endpersist %}

>[!metadata]-
{% for type, creators in creators | groupby("creatorType") -%}
{%- for creator in creators -%}
> **{{"First" if loop.first}}{{type | capitalize}}**::
{%- if creator.name %} {{creator.name}}  
{%- else %} {{creator.lastName}}, {{creator.firstName}}  
{%- endif %}  
{% endfor %}~ 
{%- endfor %}    
> **Title**:: {{title}}  
> **Year**:: {{date | format("YYYY")}}   
> **Citekey**:: {{citekey}} {%- if itemType %}  
> **itemType**:: {{itemType}}{%- endif %}{%- if itemType == "journalArticle" %}  
> **Journal**:: *{{publicationTitle}}* {%- endif %}{%- if volume %}  
> **Volume**:: {{volume}} {%- endif %}{%- if issue %}  
> **Issue**:: {{issue}} {%- endif %}{%- if itemType == "bookSection" %}  
> **Book**:: {{publicationTitle}} {%- endif %}{%- if publisher %}  
> **Publisher**:: {{publisher}} {%- endif %}{%- if place %}  
> **Location**:: {{place}} {%- endif %}{%- if pages %}   
> **Pages**:: {{pages}} {%- endif %}{%- if DOI %}  
> **DOI**:: {{DOI}} {%- endif %}{%- if ISBN %}  
> **ISBN**:: {{ISBN}} {%- endif %}    

Add CSS snippet

To add the CSS snippet, go to …

# go to the root directory of your vault (i.e., where notes are stored)
cd PATH/TO/VAULT/.obsidian/snippets
# create a css file, you can also use text editor to create a file. Make sure the file has .css as extention
vi callouts.css

Inside the callouts.css file, paste the updated CSS snippet as follows:

/* Yellow */
.literature-note .callout[data-callout-metadata="#ffd400"] {
  --callout-color: 255, 204, 0;
}

/* Red */
.literature-note .callout[data-callout-metadata="#ff6666"] {
  --callout-color: 255, 59, 48;
}

/* Orange */
.literature-note .callout[data-callout-metadata="#f19837"] {
  --callout-color: 255, 149, 0;
}

/* Green */
.literature-note .callout[data-callout-metadata="#5fb236"] {
  --callout-color: 40, 205, 65;
}

/* Blue */
.literature-note .callout[data-callout-metadata="#2ea8e5"] {
  --callout-color: 0, 122, 255;
}

/* Purple */
.literature-note .callout[data-callout-metadata="#a28ae5"] {
  --callout-color: 125, 84, 222;
}

/* Magenta */
.literature-note .callout[data-callout-metadata="#e56eee"] {
  --callout-color: 255, 0, 255;
}

/* Gray */
.literature-note .callout[data-callout-metadata="#aaaaaa"] {
  --callout-color: 50, 50, 50;
}

To enable the CSS snippet

• Go to Settings --> Appearance --> CSS snippets
• Enable the newly installed snippet (i.e., callouts)

This should automatically color your callouts in the notes.

Workflow

Highlight and comment

Highlight and comment on the paper as you read. Use the color code for different highlight colors. Use box comment for images (this will save images as snapshots in Obsidian).

Import the note into Obsidian

Open command pallett and search for Zotero: Create Literature Note.Alternative, create a hotkey for that command (e.g., ctrl + opt + Z).

In the pop-up box, type in the author to search for literature. Once found, hit enter. It will automatically generate a markdown note using the zotero template.

Here is a screenshot shows the final markdown file in Obsidian.

• The nice thing about the annotations is that each annotation has a link to the page number in the paper. When clicking on the link, it will bring you back to highlighted page of the PDF in Zotero.

• All snapshots are embeded under annotations, which make it extremely useful for storing key figures.

• Add additional notes. You may add additional notes under Synthesis which may include the main contribution of the paper, the impression of the paper and other notes. Any edits added outside of persist blocks (i.e., outside of Synthesis and Annotations) will be overridden when the same note is imported again.

Create table using Dataview

Once you have a collection of notes, you can create a DataView query which lists all papers and their key information in a table. This may be helpful for writting literature review.

Advanced Tips

• If the title of the paper contains colon (:), it will mess up the header formatting in the obsidian notes. The workaround is to replace it with something like -.
• If you want to add more information in the template and are wondering which keywords to use, you can use Zotero Data Explorer to inspect all available keywords. In Obsidian, open command palallet and search for Zotero Data Explorer. Once opened, choose Prompt For Selection and the associated paper, you will see all meta information.
• The annotations do not have internal links. However, you can add internal links in comments. Simply added comments after the highlights and keywords with internal links (e.g., [[keyword]])
• Obsidian does not auto-sync the literature notes. If new annotations are made in Zotero, the user has to manually pull updated by importing the same literature note again (refer to this discussion).
• The persist tag prevents content from being overwritten. Any notes made in between the persist tag will be preserved. In the example below, the notes made in the notes section will be preserved. Thus, additional new notes can be added in the notes section without being overwritten.

{% persist "notes" %}
{% endpersist %}

References

• https://forum.obsidian.md/t/zotero-integration-import-templates/36310
• https://forum.obsidian.md/t/zotero-zotfile-mdnotes-obsidian-dataview-workflow/15536
• https://medium.com/@alexandraphelan/an-updated-academic-workflow-zotero-obsidian-cffef080addd