What is git and GitHub

• git is a version control software
• GitHub is a platform for hosting and collaborating on code and software projects.

Why do you need git?

This pictures is a great example why git is required

Keeping track of codes, working and collaborating with colleagues on different projects are the perfect use cases for git.

Common Misconceptions

• GitHub is only for the coders
• Git and GitHub are the same thing
• GitHub is meant to be used for public projects
  • Private code bases can be hosted on GitHub
• You need to learn a lot of coding to get started
  • Many things can be done from the GitHub web interface

Useful git commands

• Commands that need to run once/machine
  • git config –global user.name <your username>
  • git config –global user.email <your GitHub email>
• Usual Command cycle
  • git clone <HTTPS/SSH address>
  • git checkout –b <branch name>
  • git add <file/folders name>
  • git commit -m <useful message to identify the changes>
  • git push origin main/master
  • git checkout main/master
  • git status
  • git pull

How git works?

I found a video online that helped me understanding how git works. I am including the link to the video here.

Alongside this video, software carpentry’s lesson on version control with git is also a great resource.

Example Scenario

I have made an animation to explain the concept better to my students. The scenario is that I have a GitHub repository named MECH-892. Those of you who are not familiar with the term repository, you can think of it as a set of files and folders for a project that you are working on and that you want to keep track of those files. Anyways, the purpose for this repository is to teach the concepts of git and GitHub to my students. Now, these set of files & folders exist in GitHub or a remote repository. And I want to make some changes to the files that are stored in the remote repository(in this case GitHub). We can use GitHub's GUI interface to do the changes but I want to highlight the process where we will be modifying those files from a command line interface which offers a ton of flexibility. Before making any changes to the repository I need to create a copy of the repository. I can do that using the git clone command. When I do git clone I get a copy of the remote repository on my machine. For this example, let’s assume the MECH-892 repository only has 2 files and folders-messy_files and Readme.md. I want to create a folder named Git_lessons and when I create the folder on my local machine inside the MECH-892 folder, git knows that new files/folders have been created but it doesn’t automatically add the created files and folders to the repository. To add the newly created folder to the repository, git add command is used. But git add doesn’t add the files directly to the local repository. It adds the folder to a intermediate location which is called staging area. From the staging area if we want to add the folder to the local repository, we will use git commit command. All these three things-your working directory, staging area and local repository exists in your local machine. How about if I want to make the changes to my remote repository? Then I need to push out the changes from my local machine to the remote repository. git push command does exactly that. All of these long texts are explained better in the animation below:

Animation explaining different git commands

And once the remote repository is updated, then a collaborator can grab the updated content from the repository using git pull. In this case, I am assuming that the collaborator already had cloned the repo and was working on their own research/computational work. So, they don’t need to clone the repo again. They will just do a git pull to get the updated files in their current working directory as shown in the second animation below.

Facts about OSG User School 2023

• It was the 14th OSG User School
• My thrid OSG user school and second time as an instructor. I was the instructor for two courses- Troubleshooting and Self-Checkpointing
• 60 participants in total including 5-6 international participants from ACE (African Center for Excellence)

Things I enjoyed

• In general I enjoy teaching. This year I got to teach a new course-self checkpointing. Preparing the slides and exercises for that helped me gain insight on how it can be applied to my own research work
• It’s always a great experience to learn all the great researches. Some of them goes way over my head but every iteraction that I had with the researchers added a new chapter to my knowledge.
• Madison is great in Summer and the Best western Hotel is very nice :blush:

Interested Future Participants

Keep an eye on the OSG page. The announcement for the next school happens usually in the spring.

Turner group at ASNT

Trevor and Ramon presented their work on quantifying case carburization depth and detecting MTR (Micro-textured-regions). The work was funded by Rolls Royce and Amsted Rail Brenco. Below is the group photo. We got a chance to meet with Andrea, Chris and Yongfeng (former Turner Lab members). Below is the group photo.

Interesting Presentations at ASNT

Almost all the talks that I attended were very good. Some of the extra-ordinary work and plenary talk that I liked are

• Work from Mike Lowe’s group
• Air Force Research Laboratory’s work on finding the ground truth in X-ray CT data. It was interesting to know that based on the type of X-ray CT machine-(resolution, Contrast to Noise Ratio (CNR)) the amount of detected pores were very different. CNR was the main important factor in detecting porosity of different depths
• The statistics related presentation of Miss Jennifer Brown made me regret not taking enough statistics courses during my Ph.D.
• The presentation of Bruce Drinkwater on “Are the robots coming?”

Holland Computing Center (HCC) is located at University of Nebraska-Lincoln. It provides computing resources to the affiliates of University of Nebraska system. Currently, the most advanced cluster that HCC has is swan. HCC provides High Performance Computing to its researchers.

June Summer Workshop

Every year HCC hosts a workshop in the summer teaching about the basics of High Performance Computing (HPC). It is usually in June. This year I got the opportunity to teach at the workshop. The lesson started with an introduction to Unix Shell. The shell is a program where users can type commands. With the shell, it’s possible to invoke complicated programs. The most popular Unix shell is the Bash. Bash is a program that lets the user run different commands from a command line interface (CLI). In case of the computing world, most of the clusters are designed to interact from a CLI. Learning Bash or shell commands is very helpful for researchers as it provides users with the tools to do a lot of pre and post processing directly from the terminal environment.

Bash

Software carpentry has a great lesson for the Unix Shell. The workshop followed the software carpentry’s lesson plan. The whole lesson is built in a way that makes it easier for anyone to start from scratch. Whenever I teach Bash I like to start by providing a background and usefulness for Bash. When I started using HPC for the first time at UNL, I had zero experience of using unix shell or terminal. I started to learn some of the very basic commands. I relied heavily on WinSCP for editing job submit file, looking through output and error messages, finding empty folders or jobs that failed. When I switched to a mac that pushed me to get better in using Bash. Mac did not have a good substitute of WinSCP. Cyberduck comes close but is still very far away from the functionalities that WinSCP offer.

I shared all these experiences with the students. I hope my experience and different use cases of Bash commands in my research will motivate the students.

Useful Tips and Tricks for Bash

Below are some of the commands and tips that I have found very useful for my work.

• Ctrl + A moves the cursor to the front of the line in the terminal.
• ls -lthr lets me easily find the last edited file in a directory.
• chmod +x or chmod 755 to make a file executable
• execute the script from terminal using a ./<script_file_name>
• $@ enables a shell script to accept any number of arguments

However, apart from leading the workshop I also got a chance to participate in other workshops and talks. The panel discussion about AI and its ethics was interesting. I came to know about slidesGPT from there. It generates slides based on the provided information. The API of ChatGPT is used in such different and innovative ways. One of the panelists was a lawyer. According to him the upsurge in AI and the available API’s are presenting the startups with a great advantage. The startups now can compete with the well established companies if they can innovate. Previously the costs and overhead of maintaining a company sometimes made it very difficult for startups to compete on the open market. I wish the whole session was recorded.

I learnt the importance of building a regional CI (Cyber infrastructure) network. All the conference that I had attended before was focused on research only. GPN focused on research computing along with professional development. It presented me with the opportunity to learn numerous challenges that goes behind the scene of the computing world.

Ultrasound is used widely in various industries for detection and identification of defects in polycrystalline materials. My research interest lies in quantifying polycrystalline materials through ultrasound. Using an ultrasonic transducer ultrasonic signal can be transmitted and received. When ultrasound travels inside a polycrystalline material it scatters in all direction. From the reflected signal of the wave information about the microstructure of the material can be quantified. Some of the main properties of ultrasound is phase velocity, attenuation and backscatter. Using these properties of ultrasound the microstructural properties of a material can be predicted.

Ultrasonic wave scatters when it passes through the grains of polycrystalline materials. Grain boundaries are the main sources of ultrasonic scattering and attenuation. Ultrasonics theories like Weaver’s model is specially helpful for understanding ultrasonic responses in polycrystalline materials. Norouzian and Turner developed the modifications necessary to apply ultrasonic theories to calculate phase velocity and attenuation using the discrete synthetic microstructures for cubic polycrystalline materials.

My research work aims to further this approach of developing and testing the ultrasonic theories applicable to discrete synthetic microstructures for complex polycrystalline materials. The animation in this page is my lazy approach towards describing the ultrasonic properties. However, Iowa State University has built a great website regarding all the NDT techniques. I would highly encourage interested readers to go through different sections in their website.

Microstructure refers to the internal organization of a material. Due to the nature of my research I am focused on investigating polycrystalline materials. Polycrystalline materials refer to those materials that have many crystals e.g. Copper, Iron, Aluminum etc. If we put these materials under a microscope we can see that they consist of many small elements or building blocks like a jigsaw puzzle which we refer to as grains. DREAM.3D and Neper are two of the most prominent software for creation of two and three dimensional synthetic microstructures.

DREAM.3D

DREAM.3D fills up a given space with grains of random shapes and sizes, and allows them to grow in all directions untill no empty voxels(3D pixels) are remaining.

Slurm script for DREAM.3D

More information about the inner workings of DREAM.3D can be found in Mike Groeber’s paper. Creation of a relatively realistic synthetic microstructures requires a lot of computing. I usually create the DREAM.3D synthetics in Holland Computing Center (HCC) Slurm based cluster. The script to generate many realizations follows:

#!/bin/sh
#SBATCH --array=1-40
#SBATCH --nodes=1
#SBATCH --time=127:00:00
#SBATCH --mem=64G
#SBATCH -o two_phase_30-%A_%a.out --array=1-40

module load singularity
mkdir /<path>/<to>/<json file>/$SLURM_ARRAY_TASK_ID
singularity exec -B /<path>/<to>/<json file>/$SLURM_ARRAY_TASK_ID:/mnt docker://unlhcc/dream3d PipelineRunner -p /<path>/<to>/<json file>/*.json

The GUI of DREAM.3D creates a .json file and it can be run from the command line using the PipelineRunner -p command.

Neper

Neper is based on Voronoi tessellation. Neper fills a given space with random seed points. Neper has the capability to generate microstructures of different grain size distributions. The image below shows a 3D Voronoi polycrystal.

Slurm script for Voronoi tessellation

As our codebase is for voxelized format of synthetic microstructure, the generated polycrystals are converted to a raster or voxelized format. An example code for generating voronoi polycrystal in a slurm cluster is shown below. Please note that the time of my investigation the current version of Neper was 3.5.

#!/bin/sh
#SBATCH --nodes=1
#SBATCH --array=1-10
#SBATCH --ntasks=10
#SBATCH --time=120:59:00       
#SBATCH --mem=15G      
#SBATCH --job-name=vor_9sd_500_cube_array
#SBATCH -o slurm-%A_%a.out --array=1-10

module load neper/3.5
mkdir $SLURM_ARRAY_TASK_ID
cd $SLURM_ARRAY_TASK_ID
domain_val=500
mean_val=30
sd_val=9;

neper -T -n from_morpho -id $SLURM_ARRAY_TASK_ID -domain "cube($domain_val,$domain_val,$domain_val)" -morpho "voronoi,diameq:lognormal($mean_val,$sd_val)" -format tesr,ori -tesrsize $domain_val -tesrformat binary16 -oricrysym cubic -ori random -statcell size,diameq,w -o voronoi_sd"$sd_val"_"$domain_val"

Slurm script for Laguerre tessellation

Laguerre tessellation is based on Voronoi tessellation. The main difference for Laguerre is that the generated seed are not equidistant from the grain boundary. Laguerre tessellation is used for simulating foams and is better in making a wider grain-size distributions.

#!/bin/sh
#SBATCH --nodes=1
#SBATCH --array=1-10
#SBATCH --ntasks=10
#SBATCH --time=69:59:00       
#SBATCH --mem=20G      
#SBATCH --job-name=laguerre_sd9_200_cube_array
#SBATCH -o slurm-%A_%a.out --array=1-10

module load neper/3.5
mkdir $SLURM_ARRAY_TASK_ID
cd $SLURM_ARRAY_TASK_ID
domain_val=500
mean_val=30
sd_val=9;

neper -T -n from_morpho -id $SLURM_ARRAY_TASK_ID -domain "cube($domain_val,$domain_val,$domain_val)" -morpho "diameq:lognormal($mean_val,$sd_val)" -morphooptiini "coo:packing,weight:0.5*diameq" -format tesr,ori -tesrsize $domain_val -tesrformat binary16 -oricrysym cubic -ori random -statcell size,diameq,w -o laguerre_sd"$sd_val"_"$domain_val"