Posts on ctsolakis.com

Automate Installation of Multiple Binary packages 2

ctsol001@odu.edu (Christos Tsolakis) — Sat, 12 Apr 2025 21:23:37 -0400

In a previous post we saw how to automate installation of different versions of ParaView and give each one its own icon and menu entry.

What if we want to add a new version without re-downloading all the previous ones ?

We need to:

Find which versions we already have
Store this information
Skip steps for the ones we have

Although, these sound obvious it took quite some time to find the proper way to do it in ansible, hence this note.

Automate Installation of Multiple Binary packages

ctsol001@odu.edu (Christos Tsolakis) — Sat, 07 Oct 2023 00:00:00 +0000

As a ParaView developer it is useful to keep multiple versions of ParaView installed so that testing for regressions becomes quick and easy. I used to just drop the binaries from https://www.paraview.org/download/ right into an ~/opt directory, and add custom launchers with menulibre. To differentiate between versions I would edit the icon with Gimp so that it includes the corresponding ParaView version.

Since I started using ansible to set up different VMs and machines it became natural to look for an opportunity to use it everywhere. In this case the goal is:

Organizing build commands in cmake with profiles

ctsol001@odu.edu (Christos Tsolakis) — Wed, 09 Nov 2022 00:00:00 +0000

When dealing with a C/C++ project that utilizes cmake one will sooner or later need to organize the available build options into profiles than enable multiple features in a convenient manners. Two of the ways to achieve that is the use of cmake cache files and cmake presets.

Let’s start with setting a common ground for this test using the vtk repository:

git clone https://gitlab.kitware.com/vtk/vtk
cd vtk/
git switch -d v9.1.0
git submodule init
git submodule update --recursive

VTK has already a number of documented build options on top of the ones that cmake provides for every project.

Generating compile commands with cmake

ctsol001@odu.edu (Christos Tsolakis) — Mon, 13 Jul 2020 00:00:00 +0000

cmake offers the option to generate a compilation database in json format using the option CMAKE_EXPORT_COMPILE_COMMANDS=YES. The database holds essentially the command, paths and compilers flags used to compile each file of a project. The generated file (usually called compile_commands.json) can be used in conjunction with various code completion tools like YouCompleteMe and Visual Studio’s IntelliSense in order to offer more complete information, completion and errors about the code.

The official cmake tutorial

ctsol001@odu.edu (Christos Tsolakis) — Mon, 29 Jun 2020 00:00:00 +0000

There are many resources, posts and articles about using cmake and writing modern cmake code. Unfortunately for a new user it is sometimes difficult to locate the proper resource that contains no deprecated options or any other non-recommended practices. One of the quickest and simplest resource I became aware recently is the official tutorial that lives in the documentation of cmake.

Using ccache to speedup compilation of C/C++

ctsol001@odu.edu (Christos Tsolakis) — Tue, 23 Jun 2020 00:00:00 +0000

ccache is a utility that caches intermediate files during compilation offering significant speedups. It is especially useful if you are switching between two branches of the same project see below.

To use it, prepend it before the compiler i.e. Use ccache gcc instead of gcc ... . If you are using cmake with a version greater that 3.4 you can use the option -DCMAKE_CXX_COMPILER_LAUNCHER=ccache for older version you can modify the compiler settings or use the variable RULE_LAUNCH_COMPILE for more see here.

Change pixels in 2D/3D images

ctsol001@odu.edu (Christos Tsolakis) — Thu, 20 Feb 2020 00:00:00 +0000

Similar to an older post. One can modify 2D/3D images in order to change specific pixels /voxels. This became useful recently while trying to remove a tissue from a segmented image. For something more complicated you may want to use Slicer, but for simple cases like this a python script enough. Appended you can also find the corresponding C++ code. Keep in mind that python handles all supported PixelTypes automatically while for the C++ one needs to update the PixelType typedef and the dimension variable.

Thousands separator in C++

ctsol001@odu.edu (Christos Tsolakis) — Tue, 08 Oct 2019 00:00:00 +0000

As you print more and more numbers in the screen it may become cumbersome to count digits just to see is if you are in the range of millions or 100’s of millions. Visually grouping digits can simmplify things. There is a pleathora of ways to do this in C++ but the one I find the best is the one provided by the standand C++ library through the std::numpunct object. Here is a small example that uses groups digits using commas.

#ifdef in Latex documents

ctsol001@odu.edu (Christos Tsolakis) — Tue, 11 Jun 2019 00:00:00 +0000

Consider the case where you want to generate slightly different versions of a document out of single latex file. This could be needed when using different document templates or if you want to switch on/off commentary in your document. You may want different introduction or order of chapters based on each particular case. A way to do it is using conditionals that exists available in plain TeX. For example

\documentclass{article}
\newif\ifanswers
%\answerstrue 
\begin{document}

question : what is the expected complexity of quicksort for an array of integers ?
\vspace{1cm}

\ifanswers
answer $o(n\log n)$ where $n$ is the numer of integers.
\fi
\vspace{1cm}

question : give the definition of an abelian group .
\vspace{1cm}

\ifanswers
answer : an abelian group is a set, $a$, together with an operation $\cdot$ that ...
\vspace{1cm}
\fi
\end{document}

Enabling conditionals can be achieved by commenting/uncommenting the 3rd line either by hand or using a makefile:

Keep running until crash with gdb

ctsol001@odu.edu (Christos Tsolakis) — Thu, 21 Mar 2019 00:00:00 +0000

Many times when trying to catch a bug , or to validate that your parallel code runs correctly you wish to run your code again and again and again until break on an assertion or even better until you persuade yourself that your code is good enough. Once more, stakoverflow has the answer for us:

set $n = 100
while $n-- > 0
 printf "starting program\n"
 run
 if $_siginfo
 printf "Received signal %d, stopping\n", $_siginfo.si_signo
 loop_break
 else
 printf "program exited\n"
 end
end

If you use it often save it in a file and launch it using

How about stopping sending your public keys ?

ctsol001@odu.edu (Christos Tsolakis) — Tue, 19 Mar 2019 00:00:00 +0000

Did you know that when connecting to a server wish ssh it will first send all your public ssh keys and then it will promt you for a password ? Sure it is just public keys, but still. See here for more https://github.com/FiloSottile/whosthere

Adding support for new mesh formats in ParaView

ctsol001@odu.edu (Christos Tsolakis) — Sun, 25 Nov 2018 00:00:00 +0000

The architecture of ParaView allows extending its functionality by creating plugins which can be loaded as dynamic libraries without recompiling ParaView.

The main mesh filetypes we are handling in our lab are .ugrid generated by AFLR3 and used widely within FUN3D, .meshb from INRIA Gamma Team and .su2 from the SU2 solver. Unfortunately there is no support for these from Paraview. Fortunately there is documentation for creating readers (plugin guides).

Here is the boilerplate for writting a reader for an unstructred grid based on the Paraview wiki.

Podcast series on history of AI

ctsol001@odu.edu (Christos Tsolakis) — Sun, 30 Sep 2018 00:00:00 +0000

In this series created by the wondery network the host will transport you to the days or early AI, from the lonely ELIZA, to Apple’s Siri, and from Deep Blue to AlphaGo.

Episode 1 : Thinking Machines : Artificial Intelligence

Episode 2 : Thinking Machines : How Do You Make a Computer Blink

Episode 3 : Thinking Machines : Siri-ous Business

Episode 4 : Thinking Machines : I learn Therefore I am

Episode 5 : Thinking Machines : Passing For Human

Extract Cell types from mesh in Paraview

ctsol001@odu.edu (Christos Tsolakis) — Tue, 17 Apr 2018 00:00:00 +0000

It is often usefull to select cells by their type for visualization in Paraview. Visualizing boundary layer meshes for example or extracting the surface elements of a mesh can be done by using the following script in the Programmable filter of Paraview.

input = self.GetUnstructuredGridInput()
output = self.GetUnstructuredGridOutput();

# copy all curent data
output.GetPointData().PassData(input.GetPointData())
output.GetCellData().PassData(input.GetCellData())

# create an array holding the VTK cell type id of each element
cellTypes = vtk.vtkUnsignedCharArray()
cellTypes.DeepCopy(input.GetCellTypesArray())
cellTypes.SetName("Cell Types")
output.GetCellData().AddArray(cellTypes)

Even simpler you can import this file (export_cell_types.cpd) from the menu Tools>Manage Custom Filters… > Import.

Simple macros in ParaView

ctsol001@odu.edu (Christos Tsolakis) — Wed, 06 Sep 2017 00:00:00 +0000

If you use ParaView often you may want to automate some of your workflows. One way to do this is writing a macro using the Python interpreter that ships with ParaView. Here, is an example of extracting all elements from a tetrahedral mesh that have a minimum dihedral angle less that 5 degrees.

from paraview.simple import *
#### disable automatic camera reset on 'Show'
paraview.simple._DisableFirstRenderCameraReset()
# get selection
G = GetActiveSource()
# create quality Data
# set min dihedraql angle as criterion
M = MeshQuality(Input=G, TetQualityMeasure="Minimum Dihedral Angle")
# select it
SetActiveSource(M)
# Create selector
S = SelectionQuerySource(QueryString = "Quality <=5")
# Create Extractor
E = ExtractSelection(Input = M,Selection = S)
Show()
Render()

#### uncomment the following to render all views
# RenderAllViews()
# alternatively, if you want to write images, you can use SaveScreenshot(...).

Another advantage of this approach is that you can run it in a headless environment using the pvpython interpreter that ships with ParaView.

Experience at ATPESC

ctsol001@odu.edu (Christos Tsolakis) — Tue, 05 Sep 2017 00:00:00 +0000

During the first half of August we took part in the Argonne Training Program on Extreme Scale Computing (ATPESC) and worked for a few days in the Argonne Leading Computing Facilities center (ALCF) just outside of Chicago, Illinois. The training consisted of lectures and presentations on software and hardware advances as well as hands-on exercises using the supercomputers of Argonne. We had the chance to meet people working on some of the most influential high-performance computing projects like core members of the MPI Forum or the OpenMP committee.

Type selector using template specialization

ctsol001@odu.edu (Christos Tsolakis) — Sat, 20 May 2017 00:00:00 +0000

In an effort to contribute back to the great matplotlib-cpp library I came across the need of having to create a mechanism that can select between different types in C++. This was needed in order to allow passing data from C++ to python without any copies using the numpy library. The only caveat in this case in that numpy requires to know the type you are passing. Since the matplotlib-cpp library is template-based there is a nice compile-time way to do it using template specialization. In simple terms it boils down to creating a base case for all the types you do not support and specialize for the types you care. Using a simple struct to hold the type completes the whole construct. The final result is :

Usefull GCC compilation flags

ctsol001@odu.edu (Christos Tsolakis) — Tue, 25 Apr 2017 00:00:00 +0000

Having the -Wall flag enabled by default can potentially save lots of time and headaches when programming in C/C++. Same other usefull flags are :

-Wduplicated-cond : Warn about duplicated condition in if-else-if chains.
-Wduplicated-branches : Warn when an if-else has identical branches.
-Wlogical-op : Warn about use of logical operations where a bitwise operation probably was intended.
-Wnull-dereference: Warn when the compiler detects paths that dereferences a null pointer.
-Wjump-misses-init: Warn if a goto statement or a switch statement jumps forward across the initialization of a variable, or jumps backward to a label after the variable has been initialized.

source

Embracing ssh-agent

ctsol001@odu.edu (Christos Tsolakis) — Thu, 10 Nov 2016 00:00:00 +0000

ssh-agent helps with managing ssh keys, it can keep track of unlocked identity ssh keys making possible to enter the passphrase only once and use the unlocked key for all upcoming ssh connections. You can make it even more flexible by Sharing the same ssh-agent among multiple login sessions. Below is the best answer in my opinion, that I have used successfully may times.

function sshagent_findsockets {
 find /tmp -uid $(id -u) -type s -name agent.\* 2>/dev/null
}

function sshagent_testsocket {
 if [ ! -x "$(which ssh-add)" ] ; then
 echo "ssh-add is not available; agent testing aborted"
 return 1
 fi

 if [ X"$1" != X ] ; then
 export SSH_AUTH_SOCK=$1
 fi

 if [ X"$SSH_AUTH_SOCK" = X ] ; then
 return 2
 fi

 if [ -S $SSH_AUTH_SOCK ] ; then
 ssh-add -l > /dev/null
 if [ $? = 2 ] ; then
 echo "Socket $SSH_AUTH_SOCK is dead! Deleting!"
 rm -f $SSH_AUTH_SOCK
 return 4
 else
 echo "Found ssh-agent $SSH_AUTH_SOCK"
 return 0
 fi
 else
 echo "$SSH_AUTH_SOCK is not a socket!"
 return 3
 fi
}

function sshagent_init {
 # ssh agent sockets can be attached to a ssh daemon process or an
 # ssh-agent process.

 AGENTFOUND=0

 # Attempt to find and use the ssh-agent in the current environment
 if sshagent_testsocket ; then AGENTFOUND=1 ; fi

 # If there is no agent in the environment, search /tmp for
 # possible agents to reuse before starting a fresh ssh-agent
 # process.
 if [ $AGENTFOUND = 0 ] ; then
 for agentsocket in $(sshagent_findsockets) ; do
 if [ $AGENTFOUND != 0 ] ; then break ; fi
 if sshagent_testsocket $agentsocket ; then AGENTFOUND=1 ; fi
 done
 fi

 # If at this point we still haven't located an agent, it's time to
 # start a new one
 if [ $AGENTFOUND = 0 ] ; then
 eval `ssh-agent`
 fi

 # Clean up
 unset AGENTFOUND
 unset agentsocket

 # Finally, show what keys are currently in the agent
 ssh-add -l
}

source

Linediff : Comparing files snippet by snippet

ctsol001@odu.edu (Christos Tsolakis) — Sun, 09 Oct 2016 00:00:00 +0000

When performing big code changes like refactoring, comparing files can become tedious and time consuming. One way to reduce the load is to compare the file function by function or even snippet by snippet since, most of the time this is what you actually need. A plugin for vim that works very closely to the default diff tool of git vimdiff is linediff.vim.

Cheetsheet

^V and use movement commands to select text
:Linediff to put selected text into buffer
repeat for second snippet
Use diffget and diffput and rest of vimdiff commands as usual
Save both buffers once done

Evaluating mesh volume from surface

ctsol001@odu.edu (Christos Tsolakis) — Fri, 30 Oct 2015 00:00:00 +0000

One of the first tests one needs to implement when generating meshes is a volume test. The main idea like in many other tests is to evaluate the same quantity in two different ways and then compare the results. If everything is correct the results should be close up to some rounding precision error.

When dealing with surface vs volume calculation a familiar method from multi-variable calculus is the Divergence theorem [1] :

Removing white pixels from figures

ctsol001@odu.edu (Christos Tsolakis) — Wed, 18 Mar 2015 00:00:00 +0000

Quite often, especially when you are working with presentations, you may realize that you need to remove the white background from your figures. One way is to use any photo editing software like Gimp for example and remove the background. But if you have a lot of files and you don’t need smoothing or any other effect you can also use a simple script like this:

#!/usr/bin/env python 
#source : http://stackoverflow.com/a/765829
from PIL import Image
import sys
white = (255, 255, 255, 255)
transparent = (255, 255, 255, 0)
for infile in sys.argv[1:]:
 img = Image.open(infile)
 img = img.convert("RGBA")

 pixdata = img.load()

 for y in xrange(img.size[1]):
 for x in xrange(img.size[0]):
 if pixdata[x, y] == white:
 pixdata[x, y] = transparent

 img.save(infile + "_modified", "PNG")

source