Below you find my personal collection links, scripts, guides and graphics you might find neat, or useful.

• Link'O'Rama
• Personal credo
• Gnuplot extrapolations with errorbars
• arXiv logo
• How to fix your citation index
• RSS-feed of PRL's newly accepted and cond-mat with authors
• MathJax
• Guide to migrate from Linux to MacOSX
• Condensed matter job sites
• Word count of TeX manuscript for Phys. Rev. Lett.
• Shell script to create histograms
• Shell script to manage ssh keys
• Honeycomb lattice graphics
• YouTube science
• Shell script grepskip
• Setup your Raspberry Pi as an AirPrint server
• Calling C/C++ routines from Fortran

Histograms in the shell & gnuplot

This is a nice shell script (author unknown) which uses awk to produce a histogram from a data set. This can be especially useful in combination with gnuplot, e.g., for the original data set data.dat use the line

gnuplot> p "< histogram data.dat 100" u 1:2 w boxes

in gnuplot to plot the histogram of data.dat with 100 subdivisions (bins) of the whole data range. Unfortunately, the script's origin is lost - I apologize for not being able to crediting the original author. You can download the script here: histogram (make sure to put it in a directory in your $PATH and make it executable).

                  #!/bin/bash

                  FILE=$1 # input file
                  BINS=$2 # number of bins

                  if [ "$#" != "2" ] || [ ! -f $FILE ]; then
                     echo 'usage: histogram <file> <#bins>'
                     exit 1
                  fi

                  # determine border values
                  MIN=$(awk 'NR == 1 || $1 < min {line = $0; min = $1} END {print line}' $FILE)
                  MAX=$(awk 'NR == 1 || $1 > max {line = $0; max = $1} END {print line}' $FILE)

                  # use awk to bin data
                  awk -v m=$MIN -v M=$MAX -v b=$BINS 'BEGIN { 

                    w = (M-m)/b      # width of each bin

                    # set up arrays
                    for (i = 1 ; i <= b; ++i) {
                      n[i] = m+(i*w)        # upper bound of bin
                      c[i] = n[i] - (w/2)   # centre of bin
                      f[i] = 0              # frequency count
                    }
                  }

                  { 
                    # bin the data
                    for (i = 1; i <= b; ++i)
                      if ($1 <= n[i]) {
                           ++f[i]
                           break       
                      } 
                  }

                  END {
                    # print results to a file for plotting

                    for (i = 1; i <= b; ++i) {
                      if (f[i] > 0) {
                        print c[i],"\t", f[i]
                      }
                      else {
                        print c[i], 0
                      }
                    }
                  }' $FILE
               

Note, that gnuplot of course can create histograms intrinsically using the commands

gnuplot> binwidth=5
gnuplot> bin(x,width)=width*floor(x/width)
gnuplot> p 'data.dat' u (bin($1,binwidth)):(1.0) smooth freq with boxes

Honeycomb & twisted graphene lattice graphics

Since I have been repeatedly asked for graphics I used in talks and papers I here provide high resolution versions of a few popular images for use under . Click on the preview images to obtain the high-res version.

Shellscript grepskip

Ever so often I need to grep a certain line from a file. The problem is, I do not need the line of the regular expression I can provide, but the n-th line after. For this purpose I wrote the little script grepskip.

#!/usr/bin/perl

if (@ARGV < 3)
{  die "usage: grepskip <expr> [expr] ... <nskip> <file>\n\n";
} 

@expressions = ();
for ($i=0;$i<@ARGV-2;$i++)
{  push(@expressions,@ARGV[$i]);
}

$file = $ARGV[@ARGV-1];
$nskip = $ARGV[@ARGV-2];

open(FID,"<$file") || die "unable to open $file";
@line = <FID>;
close(FID);

for ($i=0;$i<@line;$i++)
{  foreach $exp (@expressions)
   {  if ($line[$i] =~ m/.*$exp.*/) 
      {  print $line[$i+$nskip];
      }
   }
}
               

Here is an example, how it works. Let the file data.dat contain the lines:

                  0.0   0.0
                     0.283084   0.040688
                     0.364561   0.155806
                  1.0   0.0
                     0.998068   0.215512
                     0.812932   0.552596
                  0.0   1.0
                     0.884292   0.177753
                     0.764657   0.142434
               

To extract the second line after the pattern '   0.0$', without knowing which lines match the pattern we can use

$ grepskip '   0.0$' 2 data.dat
   0.364561   0.155806
   0.812932   0.552596

Calling C/C++ routines from Fortran

Here are two examples of frequently used system functions implemented in C and called from Fortran. While these might be available as intrinsic functions in you compiler of choice, their implementation would be specific to your compiler and not part of the Fortran standard and hence not portable, unless implemented in C. Note that the functions are listed twice, once with and once without the trailing underscore - this is to stay compatible with different Fortran compilers which implement different naming conventions.

The first example is a function to obtain the process ID (PID) of the program you are running (fgetpid.c).

#include <unistd.h>

void fgetpid_(int *id)
{
   *id = (int)getpid();
}

void fgetpid(int *id)
{
   *id = (int)getpid();
}

You can call the function from Fortran via:

INTEGER :: pid
CALL fgetpid(pid)
WRITE(*,*) pid               

At the linking stage don't forget to also link to fgetpid.o! The second example is execution of system commands using C's system command (exec.c).

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

void exec_(char *cmd, int *cmdLen, int *stat)
{
   char *cmdcpy;

   if(!(cmdcpy=(char*)malloc(*cmdLen+1)))
   {  fprintf(stderr,"exec: malloc failed\n");
      exit(1);
   }
   strncpy(cmdcpy,cmd,*cmdLen);
   cmdcpy[*cmdLen]='\0';
   *stat = system(cmdcpy);

   free(cmdcpy);
   return;
}


void exec(char *cmd, int *cmdLen, int *stat)
{
   char *cmdcpy;

   if(!(cmdcpy=(char*)malloc(*cmdLen+1)))
   {  fprintf(stderr,"exec: malloc failed\n");
      exit(1);
   }
   strncpy(cmdcpy,cmd,*cmdLen);
   cmdcpy[*cmdLen]='\0';
   *stat = system(cmdcpy);

   free(cmdcpy);
   return;
}

Execute system commands in Fortran via:

CHARACTER(len=128) :: cmd
INTEGER :: ierr
cmd = 'touch test.dat'
CALL exec(trim(cmd),len_trim(cmd),ierr)