#! /bin/bash
#
# BASH script to automagically uncompress different kinds of compressed files/folders
#
# Usage: extract.sh [COMPRESSED_FILENAME]
# First written: Wed, 04 May 2011 05:14:10 -0400
# Last modified: Wed, 04 May 2011 05:14:10 -0400
#
 
E_BADARGS=65
 
if [ $# != 1 ];
then
  echo
  echo "  Usage: `basename $0` [COMPRESSED_FILENAME]"
  echo
  exit $E_BADARGS
else
  if [ -f $1 ];
  then
    case $1 in
      *.tar)       tar -xvf  $1  ;;
      *.tgz)       tar -xvzf $1  ;;
      *.tar.gz)    tar -xvzf $1  ;;
      *.tbz2)      tar -xvjf $1  ;;
      *.tar.bz2)   tar -xvjf $1  ;;
      *.gz)        gunzip    $1  ;;
      *.bz2)       bunzip2   $1  ;;
      *.zip)       unzip     $1  ;;
      *)           echo "  '$1' file type unknown" ;;
    esac
  else
    echo "  '$1' is not a regular file"
    echo
  fi
fi

# Smart extract function
extract () {
  if [ $# != 1 ];
  then
    echo
    echo "  Usage: extract [COMPRESSED_FILENAME]"
    echo
  else
    if [ -f $1 ];
    then
      case $1 in
        *.tar)       tar -xvf  $1  ;;
        *.tgz)       tar -xvzf $1  ;;
        *.tar.gz)    tar -xvzf $1  ;;
        *.tbz2)      tar -xvjf $1  ;;
        *.tar.bz2)   tar -xvjf $1  ;;
        *.gz)        gunzip    $1  ;;
        *.bz2)       bunzip2   $1  ;;
        *.zip)       unzip     $1  ;;
        *)           echo "  '$1' file type unknown" ;;
      esac
    else
      echo "  '$1' is not a regular file"
      echo
    fi
  fi
}

/* heat_equation_2d.c
 * PARALLEL [MPI] C PROGRAM TO SOLVE THE 2 DIMENSIONAL HEAT EQUATION.
 * THE INITIAL TEMPERATURE IS COMPUTED TO BE HIGH IN THE MIDDLE OF THE
 * DOMAIN UNDER CONSIDERATION AND ZERO AT THE BOUNDARIES. THE BOUNDARIES
 * ARE HELD AT ZERO TEMPERATURE THROUGH OUT THE SIMULATION.
 *
 * THE GIVEN GRID IS DECOMPOSED BY THE MASTER AND THEN DISTRIBUTED BY
 * COLUMNS TO WORKERS. A GRID POINT'S CURRENT TEMPERATURE DEPENDS UPON 
 * ITS PREVIOUS TIME STEP VALUE AS WELL AS THE VALUES OF THE NEIGHBORING
 * GRID POINTS. AS SUCH, AT EACH TIME STEP, WORKERS EXCHANGE BORDER/BOUNDARY
 * DATA WITH NEIGHBORS. ONCE ALL THE TIME STEPS ARE COMPLETED, WORKERS
 * SEND THEIR RESULTS TO MASTER.
 *
 * THE PROGRAM GENERATES A DATA FILE THAT CAN BE VISUALIZED WITH THIRD 
 * PARTY PROGRAMS [GNUPLOT, MATLAB, ETC.]
 *
 * TESTED SUCCESSFULLY WITH MPICH2 (1.3.1) COMPILED AGAINST GCC (4.1.2) 
 * IN A LINUX BOX WITH QUAD CORE INTEL XEON PROCESSOR (1.86 GHz) & 4GB OF RAM.
 *
 * ORIGINAL AUTHOR : BLAISE BARNEY; 2009/12/11
 *                   LAWRENCE LIVERMORE NATIONAL LABORATORY
 * FIRST COPIED    : GOWTHAM; Fri, 26 Nov 2010 21:30:30 -0500
 * LAST MODIFIED   : GOWTHAM; Fri, 10 Dec 2010 01:34:52 -0500
 *
 * URL:
 * http://sgowtham.net/blog/2010/12/11/mpi-c-2-dimensional-heat-equation/
 *
 * COMPILATION:
 * mpicc -g -Wall -lm heat_equation_2d.c -o heat_equation_2d.x 
 *
 * EXECUTION:
 * mpirun -np NPROC -machinefile MACHINEFILE ./heat_equation_2d.x
 *
 * NPROC       : NUMBER OF PROCESSORS ALLOCATED TO RUNNING THIS PROGRAM;
 *               NXY [GRID SIZE] MUST BE DIVISIBLE BY [NPROC - 1]
 * MACHINEFILE : FILE LISTING THE HOSTNAMES OF PROCESSORS ALLOCATED TO
 *               RUNNING THIS PROGRAM
 *
 * OUTPUT      : DATA FILE 'heat_equation_2d.dat' WITH THE FOLLOWING
 *               FORMAT
 *
 *               TSTEPS=#TSTEPS
 *               U(x, y) AT t = 0         [NXY x NXY]
 *               U(x, y) AT t = 1         [NXY x NXY]
 *               ...
 *               U(x, y) AT t = TSTEP     [NXY x NXY]
 *
 *               TOTAL NUMBER OF LINES IN 'heat_equation_2d.dat'
 *               (NXY * (TSTEPS + 1)) + 1
 *
*/
 
/* STANDARD HEADERS AND DEFINITIONS 
 * REFERENCE: http://en.wikipedia.org/wiki/C_standard_library
*/
#include <stdio.h>  /* Core input/output operations                         */
#include <stdlib.h> /* Conversions, random numbers, memory allocation, etc. */
#include <math.h>   /* Common mathematical functions                        */
#include <time.h>   /* Converting between various date/time formats         */
#include <mpi.h>    /* MPI functionality                                    */
 
#define NXY          20          /* Number of (x or y) grids in U(x,y) */
                                 /* NXY must be divisible by NPROC - 1 */
#define TSTEPS      500          /* Number of time steps               */
#define MASTER        0          /* Process ID for MASTER              */
#define BEGIN         1          /* Message tag                        */
#define DONE          2          /* Message tag                        */
#define LNEIGHBOR     3          /* Left neighbor tag                  */
#define RNEIGHBOR     4          /* Right neigbor tag                  */
#define NONE          5          /* Indicates no neighbor              */
 
struct ThermalDiffusivity {      /* Parameters used in difference      */
  double cx;                     /* equations - refer to class         */
  double cy;                     /* notes. Physically, these refer to  */
} parameters = {0.25, 0.25};     /* thermal diffusivity                */
 
 
/* MAIN PROGRAM BEGINS */
int main (int argc, char *argv[]) {
 
  /* VARIABLE DECLARATION & INITIALIZATION */
  double U[NXY][NXY],      /* 2D array to hold current values        */
         Unew[NXY][NXY],   /* 2D array to hold new values            */
         start_time,       /* Wall clock - start time                */
         end_time;         /* Wall clock - end time                  */
 
  int    proc_id,          /* Process ID                             */
         n_procs,          /* Number of processors                   */
         n_workers,        /* Number of WORKERS [nprocs - 1]         */
         cols_per_worker,  /* Number of columns of U(x,y) per WORKER */ 
         offset,           /* Offset                                 */
         source,           /* Source for a message                   */
         destination,      /* Destination for a message              */
         lneighbor,        /* Process ID of left neighbor            */
         rneighbor,        /* Process ID of right neighbor           */
         start,            /* Starting # for columns in WORKERS      */
         end,              /* Ending # for columns in WORKERS        */
         i,                /* Dummy/Running index                    */
         j,                /* Dummy/Running index                    */
         h;                /* Dummy/Running index for TSTEPS         */
 
  FILE   *output;          /* File pointer                           */
 
  MPI_Status status;       /* MPI structure containing return codes
                              for message passing operations         */
 
  MPI_Datatype cvector;    /* A custom MPI data type defined to 
                              contain column vectors                 */
 
 
  /* INITIALIZE MPI */
  MPI_Init(&argc, &argv);
 
  /* GET THE PROCESSOR ID AND NUMBER OF PROCESSORS */
  MPI_Comm_rank(MPI_COMM_WORLD, &proc_id);
  MPI_Comm_size(MPI_COMM_WORLD, &n_procs);
 
  /* NUMBER OF WORKERS [NPROC - 1] */
  n_workers = n_procs - 1;
 
  /* MPI DATA TYPE [CUSTOM] - TO SEND BLOCKS OF U(x,y) TO WORKERS AS COLUMNS
   * THANKS TO DR. STEVEN SEIDEL [http://www.cs.mtu.edu/~steve/] 
   * FOR INFORMING/TEACHING ME THE POSSIBILITY OF DEFINING CUSTOM DATA TYPES 
   * IN MPI, DURING A PREVIOUS DISCUSSION ABOUT MATRIX MULTIPILICATION
  */
  MPI_Type_vector(NXY, 1, NXY, MPI_DOUBLE, &cvector);
  MPI_Type_commit (&cvector);
 
  /* IF MASTER, THEN DO THE FOLLOWING:
   * PRINT GENERAL INFORMATION ABOUT THE PROGRAM
   * CHECK IF NPROCS MEETS THE PROGRAM REQUIREMENTS
   * POPULATE THE U(x,y) TO SIMULATE INITIAL TEMPERATURE DISTRIBUTION
   * SEND RELEVANT INFORMATION ABOUT NEIGHBORS, OF U(x,y) TO WORKERS
   * RECEIVE RELAVANT INFORMATION FROM WORKERS, AT EVERY TIME STEP
   * DISPLAY U(x,y) AT INITIAL AND FINAL STEPS
   * PRINT U(x,y) AT EVERY TIME STEP SO THAT IT CAN BE PLOTTED/ANIMATED
  */
  if (proc_id == MASTER) {
 
    printf("\n  2D Heat Equation [MPI/C]\n\n");
    printf("    Number of x-grids        : %d\n", NXY);
    printf("    Number of y-grids        : %d\n", NXY);
    printf("    Number of processors     : %d\n", n_procs);
    printf("    Number of workers        : %d\n", n_workers);
    printf("    Number of time steps     : %d\n", TSTEPS);
    printf("    Thermal diffusivity (Cx) : %4.3lf\n", parameters.cx);
    printf("    Thermal diffusivity (Cy) : %4.3lf\n\n", parameters.cy);
 
    /* CHECK IF NXY IS DIVISIBLE BY [NPROC + 1]
     * IF NOT, PRINT AN ERROR MESSAGE AND QUIT THE PROGRAM 
    */
    if (NXY%(n_procs - 1) != 0) {
      printf("    ERROR:\n");
      printf("    NXY not divisible by (NPROC + 1)\n\n");
 
      exit(1);
    }
 
    /* OPEN THE FILE FOR WRITING [OVER-WRITE, IF EXISTS]
     * PRINT ERROR MESSAGE, IF ANY & TERMINATE THE PROGRAM
    */
    if(!(output = fopen("heat_equation_2d.dat", "w"))) {
      fprintf(stderr, "\n\n    ERROR:\n");
      fprintf(stderr, "    Unable to open the output file\n\n");
 
      exit(1);
    }
 
    /* START THE CLOCK */
    start_time = MPI_Wtime();
 
    /* INITIALIZE THE GRID */
    printf("    Temperature distribution (at time t=0)\n\n");
 
    /* HEADER LINE INDICATING TOTAL NUMBER OF TIME STEPS
     * NEEDED BY MATLAB (&/OR OTHER) FOR PLOTTING
    */ 
    fprintf(output, "TSTEPS=%d\n", TSTEPS + 1);
 
    /* POPULATE THE ARRAY, U(x,y) 
     * BORDER ELEMENTS ARE ALL ZERO & HIGH VALUE IN THE MIDDLE
     * PRINT THE ARRAY - TO THE SCREEN AND TO THE FILE
    */
    for (i = 0; i < NXY; i++) {
      for (j = 0; j < NXY; j++) {
        U[i][j] = 100 * i * (NXY - i - 1) * j * (NXY - j - 1);
        printf("    %08.0lf", U[i][j]);
        fprintf(output, "%012.4lf  ", U[i][j]);
      }
      printf("\n");
      fprintf(output, "\n");
    }
 
    /* NUMBER OF COLUMNS PER WORKER 
     * IT'S IMPORTANT TO ALLOCATE EQUAL NUMBER OF COLUMNS TO
     * EACH WORKER - ELSE, SOME MIGHT FINISH FASTER WITHOUT
     * ADDITIONAL WORK
     */
    cols_per_worker = NXY/n_workers;
 
    /* INITIALIZE offset */
    offset = 0;
 
    for (i = 1; i <= n_workers; i++) {
 
      /* INFORM EACH WORKER OF ITS NEIGHBORS */
      if (i == 1) {
        lneighbor = NONE;
      } else {
        lneighbor = i - 1;
      }
 
      if (i == n_workers) {
        rneighbor = NONE;
      } else {
        rneighbor = i + 1;
      }
 
      /* DESTINATION PROCESSOR */
      destination = i;
 
      /* SEND INFORMATION TO EACH WORKER
       * OFFSET
       * NUMBER OF COLUMNS EACH WORKER HAS TO WORK WITH 
       * LEFT & RIGHT NEIGHBORS FOR EACH WORKER
       * RELEVANT PORTION OF U(x,y) TO EACH WORKER
      */
      MPI_Send(&offset,    1, MPI_INT, destination, BEGIN, MPI_COMM_WORLD);
      MPI_Send(&cols_per_worker, 1, MPI_INT, destination, BEGIN, MPI_COMM_WORLD);
      MPI_Send(&lneighbor, 1, MPI_INT, destination, BEGIN, MPI_COMM_WORLD);
      MPI_Send(&rneighbor, 1, MPI_INT, destination, BEGIN, MPI_COMM_WORLD);
 
      for(j=0; j < cols_per_worker; j++) {
        MPI_Send(&U[0][offset+j], 1, cvector, destination, BEGIN, MPI_COMM_WORLD);
      }
 
      /* INCREMENT THE offset */
      offset = offset + cols_per_worker;
    }
 
    /* RECEIVE RELEVANT INFORMATION FROM WORKERS  FOR EVERY TIME STEP */
    for(h = 1; h <= TSTEPS; h++) {
 
      for(i = 1; i <= n_workers; i++) {
 
        /* SOURCE PROCESSOR */
        source = i;
 
        MPI_Recv(&offset, 1, MPI_INT, source, DONE, MPI_COMM_WORLD, &status); 
        MPI_Recv(&cols_per_worker, 1, MPI_INT, source, DONE, MPI_COMM_WORLD, &status); 
 
        for(j=0; j < cols_per_worker; j++) {
          MPI_Recv(&U[0][offset+j], 1, cvector, source, h*DONE, MPI_COMM_WORLD, &status);
        }
 
      }
 
      /* PRINT U(x,y), THE TEMPERATURE DISTRIBUTION AFTER EVERY TIME STEP TO THE FILE */
      for (i = 0; i < NXY; i++) {
        for (j = 0; j < NXY; j++) {
          fprintf(output, "%012.4lf  ", U[i][j]);
        }
        fprintf(output, "\n");
      }
 
    }
 
    /* CLOSE THE FILE */
    fclose(output);
 
    /* PRINT U(x,y), THE TEMPERATURE DISTRIBUTION AFTER 'TSTEPS' STEPS TO THE SCREEN */
    printf("\n\n    Temperature distribution (after %d time steps)\n\n", h-1);
    for (i = 0; i < NXY; i++) {
      for (j = 0; j < NXY; j++) {
        printf("    %08.0lf", U[i][j]);
      }
      printf("\n");
    }
 
    printf("\n\n");
 
    /* STOP THE CLOCK */
    end_time = MPI_Wtime();
 
    /* PRINT TIMING INFORMATION */
    printf("    Time elapsed (sec)   : %6.4f\n\n", end_time - start_time);
 
  } /* MASTER LOOP ENDS */
 
 
  /* IF WORKER, THEN DO THE FOLLOWING:
   * INITIALIZE U(x,y) & Unew(x,y) TO ZERO
   * RECEIVE RELEVANT INFORMATION FROM MASTER
   * CALCULATE U(x, y, t+1) BY COMMUNICATING APPROPRIATELY WITH NEIGHBORING WORKERS
   * SEND RELEVANT INFORMATION TO MASTER 
  */
  if (proc_id != MASTER) {
 
    /* INITIALIZE ALL ELEMENTS OF U(x,y) & Unew(x,y) TO ZERO */
    for(i = 0; i < NXY; i++) {
      for(j = 0; j < NXY; j++) {
        U[i][j] = 0.0;
        Unew[i][j] = 0.0;
      }
    }
 
    /* RECEIVE THE COLUMNS, NEIGHBORS AND GRID INFORMATION FROM MASTER */
    MPI_Recv(&offset,    1, MPI_INT, MASTER, BEGIN, MPI_COMM_WORLD, &status);
    MPI_Recv(&cols_per_worker, 1, MPI_INT, MASTER, BEGIN, MPI_COMM_WORLD, &status);
    MPI_Recv(&lneighbor, 1, MPI_INT, MASTER, BEGIN, MPI_COMM_WORLD, &status);
    MPI_Recv(&rneighbor, 1, MPI_INT, MASTER, BEGIN, MPI_COMM_WORLD, &status);
 
    for(j=0; j < cols_per_worker; j++) {
      MPI_Recv(&U[0][offset+j], 1, cvector, MASTER, BEGIN, MPI_COMM_WORLD, &status);
    }
 
    /* FOR DEBUGGING PURPOSES ONLY 
     * RUN WITH NPROC = 3 WITH NXY = 16
     * THERE SHOULD BE TWO BLOCKS OF COMPLEMENTARY MATRICES
 
    if (proc_id == 1) {
    printf("\n");
      for (i = 0; i < NXY; i++) {
        for (j = 0; j < cols_per_worker; j++) {
          printf(" %08.0lf", U[0][i][j]);
        }
        printf("\n");
      }
    }
 
    if (proc_id == 2) {
    printf("\n");
      for (i = 0; i < NXY; i++) {
        for (j = cols_per_worker; j < 2*cols_per_worker; j++) {
          printf(" %08.0lf", U[0][i][j]);
        }
        printf("\n");
      }
    }
    */ 
 
 
    /* DETERMINE BORDER ELEMENTS - FIRST & LAST COLUMNS NEED EXTRA CARE:
     * ROW 0 CANNOT EXCHANGE INFORMATION WITH 0-1
     * ROW N CANNOT EXCHANGE INFORMATION WITH N+1
    */
    if (offset == 0) {
      /* DO NOT INCLUDE ZEROTH COLUMN */
      start = 1;
    } else {
      start = offset;
    }
 
    if ((offset + cols_per_worker) == NXY) {
      /* DO NOT INCLUDE THE LAST COLUMN */
      end = offset + cols_per_worker - 2;
    } else {
      end = offset + cols_per_worker - 1;
    }
 
    /* PERFORM TIME STEP [TSTEPS] ITERATIONS.
     * MUST COMMUNICATE BORDER COLUMNS WITH NEIGHBORS.
     * IF IT'S THE FIRST OR THE LAST COLUMN, THEN THE COMMUNICATION TAKES 
     * PLACE ONLY WITH ONE NEIGHBOR
    */
    for(h = 1; h <= TSTEPS; h++) {
      if (lneighbor != NONE) {
        MPI_Send(&U[0][offset], 1, cvector, lneighbor, RNEIGHBOR, MPI_COMM_WORLD);
 
        MPI_Recv(&U[0][offset-1], 1, cvector, lneighbor, LNEIGHBOR, MPI_COMM_WORLD, 
                 &status);
      }
 
      if (rneighbor != NONE) {
        MPI_Send(&U[0][offset+cols_per_worker-1], 1, cvector, rneighbor,
                 LNEIGHBOR, MPI_COMM_WORLD);
 
        MPI_Recv(&U[0][offset+cols_per_worker], 1, cvector, rneighbor,
                 RNEIGHBOR, MPI_COMM_WORLD, &status);
      }
 
      /* UPDATE THE VALUE OF GRID POINTS 
       * REFER TO THE SLIDES FROM WEEK #14 [PART #02]
      */
      for(i = 1; i <= NXY-2; i++) {
        for(j = start; j <= end; j++) {
          Unew[i][j] = U[i][j] + 
                       parameters.cx * (U[i-1][j] + U[i+1][j] - 2 * (U[i][j])) +
                       parameters.cy * (U[i][j-1] + U[i][j+1] - 2 * (U[i][j]));
        }
      }
 
      /* SET U(x,y) TO Unew(x,y) */
      for(i = 1; i <= NXY-2; i++) {
        for(j = start; j <= end; j++) {
          U[i][j] = Unew[i][j];
        }
      }
 
      /* SEND RELEVANT INFORMATION TO MASTER */
      MPI_Send(&offset, 1, MPI_INT, MASTER, DONE, MPI_COMM_WORLD);
      MPI_Send(&cols_per_worker, 1, MPI_INT, MASTER, DONE, MPI_COMM_WORLD);
 
      for(j=0; j < cols_per_worker; j++) {
        MPI_Send(&U[0][offset+j], 1, cvector, MASTER, h*DONE, MPI_COMM_WORLD);
      }
    }
 
  } /* WORKER LOOP ENDS */
 
 
  /* FINALIZE MPI */
  MPI_Finalize();
 
  /* INDICATE THE TERMINATION OF THE PROGRAM */
  return 0;
 
} /* MAIN PROGRAM ENDS */

% heat_equation_2d.m
% MATLAB 'SCRIPT m' FILE TO READ THE FILE 'heat_equation_2d.dat', 
% ONE DATA SET AT A TIME AND PLOT IT REPEATEDLY TO SIMULATE AN ANIMATION.
%
% TESTED SUCCESSFULLY WITH MATLAB (v7.8.0.347 R2009a; STUDENT VERSION) IN A MACBOOK PRO 
% (OS X 10.6.5) WITH INTEL CORE 2 DUO PROCESSOR (2.4 GHz) & 4GB OF RAM.
%
% FIRST WRITTEN: GOWTHAM; Fri, 10 Dec 2010 23:12:18 -0500
% LAST MODIFIED: GOWTHAM; Sun, 12 Dec 2010 09:34:23 -0500
%
% INPUT:
% 'heat_equation_2d.dat' PRODUCED BY RUNNING 'heat_equation_2d.c'
% AND IT HAS THE FOLLOWING FORMAT:
% 
% TSTEPS=# 
% U(x,y) AT t = 0         [NXY x NXY]
% U(x,y) AT t = 1         [NXY x NXY]
% U(x,y) AT t = 2         [NXY x NXY]
% ...
% U(x,y) AT t = TSTEPS    [NXY x NXY]
%
% FOR AN EXPLANATION OF 'NXY', 'TSTEPS', ETC., PLEASE REFER TO 'heat_equation_2d.c'.
% 
% OUTPUT:
% IF 'mencoder' [AND OTHER REQUIRED UTILITIES] IS AVAILABLE, THIS SCRIP WILL PRODUCE 
% 'heat_equation_2d.avi'. IF NOT, 'New Screen Recording' OPTION MAY BE USED IN
% 'QuickTime Player' TO CREATE THE ANIMATION.
%
 
% CLEAR THE PREVIOUSLY SET VARIABLES
clear
 
% CLEAR THE COMMAND WINDOW
clc
 
% PAUSE FOR 15 SECONDS
% USEFUL WHEN 'mencoder' IS NOT AVAILABLE AS THIS WILL GIVE JUST ENOUGH TIME TO HIDE 
% UNWANTED SCREENS / WINDOWS AND START RECORDING VIA QuickTime Player.
% COMMENT IT OUT IF NOT NEEDED.
pause(15);
 
% OPEN THE DATA FILE FOR READING. 
% SAME BASENAME WILL BE USED FOR THE ANIMATION FILE
filename   = 'heat_equation_2d';
filehandle = fopen(filename '.dat', 'r');
 
% COUNT THE NUMBER OF TIME STEPS - GIVEN IN THE FIRST LINE
TSTEPS = fscanf(filehandle, 'TSTEPS=%d\n', 1);
 
% VARIABLE DECLARATION AND INITIALIZATION
% THIS IS THE NUMBER OF ROWS & COLUMNS IN EACH BLOCK OF DATA
NXY = 20;
 
% x & y GRIDS FOR THE MESH [3D] PLOT
x = 1:1:NXY;
y = 1:1:NXY;
 
% GENERATE X & Y ARRAYS FOR 3D PLOT
% TRANSFORMS THE DOMAIN SPECIFIED BY VECTORS x & y INTO ARRAYS X and Y, 
% WHICH CAN BE USED TO EVALUATE FUNCTIONS OF TWO VARIABLES AND 3D
% MESH/SURFACE PLOTS. THE ROWS OF THE OUTPUT ARRAY X ARE COPIES OF THE
% VECTOR x; COLUMNS OF THE OUTPUT ARRAY Y ARE COPIES OF THE VECTOR y.
% http://www.mathworks.com/help/techdoc/ref/meshgrid.html
[X, Y] = meshgrid(x,y);
 
% LOOP THROUGH THE DATA FILE TO READ 'NXY x NXY' ELEMENTS AT ONCE
% AND IMPORT THEM INTO 'TSTEPS' NUMBER OF MATRICES OF ORDER NXY.
for i = 1:TSTEPS
 
  % INITIALIZE ALL ELEMENTS OF MATRIX [OF ORDER NXY] TO ZERO
  Temperature(i).Z = zeros(NXY, NXY);
 
  % SCAN THE DATA FILE, READ 'NXY x NXY' ELEMENTS, TREAT THEM
  % AS DOUBLE PRECISION AND STORE THEM IN THE MATRIX.
  % SYNTAX:
  % Z = fscanf(filehandle, 'FORMAT', [COLS, ROWS]);
  Temperature(i).Z = fscanf(filehandle, '%f', [NXY, NXY]);
 
  % PLOT THE DATA IN THE ABOVE MATRIX AS A FUNCTION OF X & Y
  figure1 = figure(1);
  mesh(X, Y, Temperature(i).Z)
 
  % HANDLE FOR AXIS PROPERTY SO THAT IT CAN BE MODIFIED TO
  % FIT OUR REQUIREMENS
  ap = gca;
 
  % MODIFY CERTAIN AXIS PROPERTIES APPROPRIATELY
  set(ap, 'XLimMode', 'manual', 'YLimMode', 'manual', ...
          'ZLimMode', 'manual', ...
          'Xlim', [0 20], 'Ylim', [0 20], 'Zlim', [0 1000000], ...
          'FontSize', 14)
 
  % CHANGE THE COLORMAP FROM 'default' TO 'hsv'
  % THE hsv COLORMAP IS CREATED WITH 65536 COLORS
  % http://www.mathworks.com/help/techdoc/ref/colormap.html
  colormap(hsv(65536))
 
  % DISPLAY A COLOR BAR THAT WILL SERVE AS A LEGEND
  colorbar
 
  % AXES LABELS FOR THE PLOT
  xlabel('Grid points along x-axis');
  ylabel('Grid points along y-axis');
  zlabel('U(x, y), Temperature distribution');
 
  % TITLE FOR THE PLOT
  title(['TSTEP= ' num2str(i)]);
 
  % CAPTURE MOVIE FRAME AS AN ARRAY FOR LATER USE.
  % COMMENT THIS LINE IF 'mencoder' IS NOT AVAILABLE.
  % http://www.mathworks.com/help/techdoc/ref/getframe.html
  M(i) = getframe;
 
  % TIME LAG BETWEEN SUCCESSIVE PLOTS
  pause(0.00001);
 
end 
% LOOP THROUGH DATA FILE ENDS
 
% CLOSE THE DATA FILE
fclose(datafilename);
 
 
% CREATE AN ANIMATION USING THE MOVIE FRAMES.
% COMMENT THIS SECTION IF 'mencoder' IS NOT AVAILABLE
 
% CREATE AN AVI [AUDIO/VIDEO INTERLEAVED] FILE FROM THE MOVIE FRAMES ARRAY
% 'None' IS THE ONLY COMPRESSION AVAILABLE OPTION ON UNIX (LIKE) OS.
% http://www.mathworks.com/help/techdoc/ref/movie2avi.html
movie2avi(M, [filename '.avi'], 'compression', 'None', 'fps', 25);
 
% USE 'mencoder' TO COMPRESS THE MOVIE SO THAT IT CAN BE PLAYED ON 
% QuickTime Player OR SOME OTHER SUCH APPLICATION.
% USE eval TO RUN THE MAC/LINUX COMMAND
% http://www.mplayerhq.hu/DOCS/HTML/en/menc-feat-selecting-codec.html
avicompression = ['!mencoder -oac copy -ovc xvid -xvidencopts bitrate=1000 ' filename '.avi -o ' filename '_compressed.avi'];
eval(avicompression);
 
% RENAME THE COMPRESSED AVI
% USE eval TO RUN THE MAC/LINUX COMMAND
avirename = ['!mv ' filename '_compressed.avi ' filename '.avi'];
eval(avirename);

/* pi_montecarlo.c
 * PARALLEL [MPI] C PROGRAM TO COMPUTE THE VALUE OF 'PI' USING MONTE CARLO 
 * [DARTBOARD ALGORITHM] METHOD. MASTER COLLECTS THE RESULTS FROM THE WORKERS 
 * USING MPI_Reduce AND AVERAGES THEM.
 *
 * TESTED SUCCESSFULLY WITH MPICH2 (1.3.1) COMPILED AGAINST GCC (4.1.2) 
 * IN A LINUX BOX WITH QUAD CORE INTEL XEON PROCESSOR (1.86 GHz) & 4GB OF RAM.
 *
 * FIRST WRITTEN : GOWTHAM; Fri, 19 Nov 2010 01:11:34 -0500
 * LAST MODIFIED : GOWTHAM; Fri, 19 Nov 2010 03:53:31 -0500
 *
 * URL:
 * http://sgowtham.net/blog/2010/12/02/mpi-c-monte-carlo-method-of-finding-pi/ 
 *
 * COMPILATION:
 * mpicc -g -Wall -lm pi_montecarlo.c -o pi_montecarlo.x 
 *
 * EXECUTION:
 * mpirun -np NPROC -machinefile MACHINEFILE ./pi_montecarlo.x
 *
 * NPROC       : NUMBER OF PROCESSORS ALLOCATED TO RUNNING THIS PROGRAM
 * MACHINEFILE : FILE LISTING THE HOSTNAMES OF PROCESSORS ALLOCATED TO
 *               RUNNING THIS PROGRAM
 *
*/
 
 
/* STANDARD HEADERS AND DEFINITIONS 
 * REFERENCE: http://en.wikipedia.org/wiki/C_standard_library
*/
#include <stdio.h>  /* Core input/output operations                         */
#include <stdlib.h> /* Conversions, random numbers, memory allocation, etc. */
#include <math.h>   /* Common mathematical functions                        */
#include <time.h>   /* Converting between various date/time formats         */
#include <mpi.h>    /* MPI functionality                                    */
 
#define MASTER             0   /* Process ID of MASTER                      */
#define PI      3.1415926535   /* Known vaue of PI                          */
#define NDARTS     100000000   /* Number of darts thrown                    */
 
/* FUNCTION 'pseudo_random' BEGINS
 * GIVEN TWO NUMBERS, llimit & ulimit, THIS FUNCTION GENERATES A RANDOM
 * NUMBER BETWEEN llimit & ulimit. SEED FOR rand() COMES FROM THE
 * PARENT FUNCTION, 'pi_dartboard'.
*/
double pseudo_random(double a, double b) {
 
  /* VARIABLE DECLARATION & INITIALIZATION */
  double r;  /* Random number */
 
  /* GENERATE RANDOM NUMBER BETWEEN llimit & ulimit
   * rand() IS USUALLY AN INTEGER & SO IS RAND_MAX
   * (double) rand() and (double) RAND_MAX CONVERTS THEM TO DOUBLE PRECISION
   * USING LINEAR SCALING [REFER TO CLASS NOTES/SLIDES], RANDOM NUMBER IS
   * SCALED TO LIE BETWEEN llimit & ulimit
  */
  r = ((b - a) * ((double) rand()/(double) RAND_MAX)) + a;
 
  /* RETURN THE VALUE OF RANDOM NUMBER
   * INDICATE THE TERMINATION OF THIS MODULE/FUNCTION
  */
  return r;
} /* FUNCTION 'pseudo_random' ENDS */
 
 
/* MAIN PROGRAM BEGINS */
int main (int argc, char *argv[]) {
 
  /* VARIABLE DECLARATION & INITIALIZATION */
  int    proc_id,       /* Process ID                           */
         n_procs,       /* Number of processors                 */
         llimit,        /* Lower limit for random numbers       */
         ulimit,        /* Upper limit for random numbers       */
         n_circle,      /* Number of darts that hit the circle  */
         i;             /* Dummy/Running index                  */
 
  double pi_current,    /* PI calculated by each WORKER         */
         pi_sum,        /* Sum of PI values from each WORKER    */
         x,             /* x coordinate, betwen -1 & +1         */
         y,             /* y coordinate, betwen -1 & +1         */
         z,             /* Sum of x^2 and y^2                   */
         error,         /* Error in calculation of PI           */
         start_time,    /* Wall clock - start time              */
         end_time;      /* Wall clock - end time                */
 
  struct timeval stime;
 
  llimit   = -1;
  ulimit   = 1;
  n_circle = 0;
 
  /* INITIALIZE MPI */
  MPI_Init(&argc, &argv);
 
  /* GET THE PROCESS ID AND NUMBER OF PROCESSORS */
  MPI_Comm_rank(MPI_COMM_WORLD, &proc_id);
  MPI_Comm_size(MPI_COMM_WORLD, &n_procs);
 
  /* IF MASTER, THEN DO THE FOLLOWING:
   * ACCEPT THE VALUE OF NDARTS FROM COMMAND LINE
   * PRINT THE MESSAGE TO THE SCREEN
   * START THE WALL CLOCK
  */ 
  if (proc_id == MASTER) {
    printf("\n  Monte Carlo method of finding PI\n\n");
    printf("    Number of processors : %d\n", n_procs);
    printf("    Number of darts      : %d\n\n", NDARTS);
 
    /* START THE CLOCK */
    start_time = MPI_Wtime();
  }
 
 
  /* ALL PROCESSORS, INCLUDING MASTER, DO THE FOLLOWING:
   * SEED THE RANDOM NUMBER GENERATOR
   * THROW DARTS AT THE BOARD [FOR LOOP]
   *   COORDINATES OF THE DART [x, y] ARE GENERATED AT RANDOM
   *   CHECK IF THE DART LANDED IN THE CIRCLE
   *   IF YES, INCREMENT THE COUNT
   * CALCULATE THE VALUE OF PI
  */
 
  /* SEED FOR RANDOM NUMBER GENERATOR */
  /* RESULTS IN THE FOLLOWING WARNING - MAY BE IGNORED
   * warning: implicit declaration of function ‘gettimeofday’
  */
  gettimeofday(&stime, NULL);
  srand(stime.tv_usec * stime.tv_usec * stime.tv_usec * stime.tv_usec);
 
  /* THROW NDARTS LOOP BEGINS */
  for (i = 1; i <= NDARTS; i++) {
 
    /* GENERATE RANDOM NUMBERS x & y BETWEEN -1 & +1 */
    x = pseudo_random(llimit, ulimit);
    y = pseudo_random(llimit, ulimit);
 
    /* CALCULATE x^2 + y^2 */
    z = pow(x, 2) + pow(y, 2);
 
    /* IF THE DART IS IN THE CIRCLE, INCREMENT n_circle */
    if (z <= 1.0) {
       n_circle++;
    }
 
  } /* THROW NDARTS LOOP ENDS */
 
  /* CALCULATE THE VALUE OF PI */
  pi_current = 4.0 * (double)n_circle/(double)NDARTS;
 
 
  /* USE MPI_Reduce TO SUM VALUES OF pi_current ACROSS ALL WORKERS
   * THIS HAPPENS ONLY ON MASTER
  */ 
  MPI_Reduce(&pi_current, &pi_sum, 1, MPI_DOUBLE, MPI_SUM, MASTER, MPI_COMM_WORLD);
 
 
  /* IF MASTER, THEN DO THE FOLLOWING
   * CALCULATE THE AVERAGE VALUE OF PI 
   * CALCULATE THE ERROR ASSOCIATED WITH THE COMPUTED VALUE OF PI
   * STOP THE WALL CLOCK
   * PRINT THE RESULTS TO THE SCREEN
  */
  if (proc_id == MASTER) {
 
    /* AVERAGE VALUE OF COMPUTED PI */
    pi_sum = pi_sum / n_procs;
 
    /* % ERROR ASSOCIATED WITH COMPUTED VALUE OF PI */
    error = fabs((pi_sum - PI)/PI) * 100;
 
    /* STOP THE CLOCK */
    end_time = MPI_Wtime();
 
    /* PRINT THE RESULTS TO THE SCREEN */
    printf("    Known value of  PI   : %11.10f\n", PI);
    printf("    Average value of PI  : %11.10f\n", pi_sum);
    printf("    Percentage Error     : %10.8f\n", error);
    printf("    Time elapsed (sec)   : %10.8f\n\n", end_time - start_time);
  }
 
  /* FINALIZE MPI */
  MPI_Finalize();
 
  /* INDICATE THE TERMINATION OF THE PROGRAM */
  return 0;
 
} /* MAIN PROGRAM ENDS */

/* matrix_multiply.c
 * PARALLEL [MPI] C PROGRAM TO PERFORM MATRIX MULTIPLICATION. 
 * DISPLAY OF MATRIX ELEMENTS IS SET FOR 'INTEGER-LIKE'. IF [SOME/ALL OF] 
 * THE MATRIX ELEMENTS ARE NON-INTEGERS, MODIFY THE DISPLAY IN PRINTF 
 * STATEMENTS APPROPRIATELY.
 *
 * TESTED SUCCESSFULLY WITH MPICH2 (1.3.1) COMPILED AGAINST GCC (4.1.2) 
 * IN A LINUX BOX WITH QUAD CORE INTEL XEON PROCESSOR (1.86 GHz) & 4GB OF RAM.
 *
 * STAGE #01:
 * SQUARE MATRICES ONLY
 * MATRIX ELEMENTS GENERATED WITHIN THE PROGRAM
 *
 * STAGE #02: (PROPOSED)
 * SQUARE MATRICES ONLY
 * MATRIX ELEMENTS READ FROM EXTERNAL DATA FILES - USEFUL
 * WHEN A THIRD PARTY PROGRAM GENERATES DATA. ALSO REMOVES
 * THE NEED FOR RECOMPILING THE PROGRAM EVERY TIME ORDER OF
 * MATRICES CHANGE. WRITE THE PRODUCT MATRIX TO A FILE.
 *
 * STAGE #03: (PROPOSED)
 * NOT NECESSARILY SQUARE MATRICES, i.e.
 * A(I x J) * B (J x K) = C(I x K)
 * READ MATRICES FROM EXTERNAL DATA FILES
 * CHECK TO MAKE SURE 'COLS(A) = ROWS(B)' BEFORE
 * ATTEMPTING TO PERFORM THE ACTUAL MULTIPLICATION.
 * WRITE THE PRODUCT MATRIX TO A FILE.
 *
 * FIRST WRITTEN: GOWTHAM; Fri, 10 Sep 2010 23:33:28 -0400
 * LAST MODIFIED: GOWTHAM; Sat, 20 Nov 2010 02:19:38 -0500
 *
 * URL:
 * http://sgowtham.net/blog/2010/11/30/mpi-c-matrix-multiplication-order-n/
 *
 * COMPILATION:
 * mpicc -g -Wall -lm matrix_multiply.c -o matrix_multiply.x
 *
 * EXECUTION:
 * mpirun -machinefile MACHINEFILE -np NPROC ./matrix_multiply.x
 *
 * NPROC       : NUMBER OF PROCESSORS ALLOCATED TO RUNNING THIS PROGRAM;
 *               MUST BE LESS THAN OR EQUAL TO THE ORDER OF THE 
 *               MATRICES INVOLVED. 
 * MACHINEFILE : FILE LISTING THE HOSTNAMES OF PROCESSORS ALLOCATED TO
 *               RUNNING THIS PROGRAM
 *
*/
 
 
/* STANDARD HEADERS AND DEFINITIONS 
 * REFERENCE: http://en.wikipedia.org/wiki/C_standard_library
*/
#include <stdio.h>  /* Core input/output operations                         */
#include <stdlib.h> /* Conversions, random numbers, memory allocation, etc. */
#include <math.h>   /* Common mathematical functions                        */
#include <time.h>   /* Converting between various date/time formats         */
#include <mpi.h>    /* MPI functionality                                    */
 
#define MASTER   0  /* Process ID for MASTER                                */
#define N      128  /* Order of the matrices                                */
 
 
/* FUNCTION TO MAP THE PROCESSOR ID
 * 'dest' OPTION IN MPI_Send MUST BE AN INTEGER BETWEEN 0 AND 'n_proc - 1' 
*/
int map_processors(int i, int n_procs) {
  n_procs = n_procs - 1;
  int r = (int) ceil( (double) N / (double) n_procs);
  int processor = i / r;
 
  /* RETURN THE VALUE 'processor + 1' */
  return processor + 1;
}
 
 
/* MAIN PROGRAM BEGINS */
int main(int argc, char **argv) {
 
  /* VARIABLE DECLARATION */
  int    n_procs,        /* Number of processors                   */
         proc_id,        /* Process identifier                     */
         proc_source,    /* Mapped processor ID of the source      */
         proc_dest,      /* Mapped processor ID of the destination */
         proc_current,   /* Mapped processor ID                    */
         i, j, k;        /* Dummy / running indices                */
 
  double A[N][N],        /* Matrix A - N x N                       */
         B[N][N],        /* Matrix B - N x N                       */
         C[N][N],        /* Matrix C - N x N                       */ 
         sum,            /* Cumulated sum of matrix product        */
         Abuf[N],        /* 1D array to hold the value of relevant 
                            portion of A received from MASTER      */
         Cbuf[N];        /* 1D array to hold the value of 'sum' 
                            so that it can be sent to MASTER       */
 
  MPI_Status status;     /* MPI structure containing return codes
                            for message passing operations         */
 
  /* INITIALIZE MPI */
  MPI_Init(&argc, &argv);
 
  /* GET THE PROCESSOR ID AND NUMBER OF PROCESSORS */
  MPI_Comm_rank(MPI_COMM_WORLD, &proc_id);
  MPI_Comm_size(MPI_COMM_WORLD, &n_procs);
 
  /* IF MASTER, THEN DO THE FOLLOWING:
   * POPULATE THE MATRICES A & B
   * SEND FULL MATRIX B TO ALL WORKERS
   * SEND RELEVANT PORTIONS OF MATRIX A TO ALL WORKERS
   * RECEIVE MATRIX C FROM WORKERS
   * DISPLAY MATRIX C
  */
  if (proc_id == MASTER) {
 
    /* POPULATE MATRIX A */
    printf("\n  Matrix A:\n\n");
    for (i = 0; i < N; i++) {
      for (j = 0; j < N; j++) {
        /* EACH MATRIX ELEMENT IS THE SUM OF INDICES */
        A[i][j] = i + j;
        printf(" %4.0lf", A[i][j]);
      }
      printf("\n");
    }
 
    /* POPULATE MATRIX B */
    printf("\n  Matrix B:\n\n");
    for (i = 0; i < N; i++) {
      for (j = 0; j < N; j++) {
        /* EACH MATRIX ELEMENT IS THE PRODUCT OF INDICES */
        B[i][j] = i * j;
        printf(" %4.0lf", B[i][j]);
      }
      printf("\n");
    }
 
    /* CONVERT MATRIX B INTO 1D BUFFERS;
     * SEND ALL THOSE 1D BUFFERS TO ALL WORKERS 
    */
    for (i = 1; i < n_procs; i++) {
      for (j = 0; j < N; j++) {
        /* MPI_Send(buf, count, datatype, dest, tag, comm) */
        MPI_Send(&B[j], N, MPI_DOUBLE, i, j + 1000, MPI_COMM_WORLD);
      }
    }
 
    /* SEND RELEVANT PORTIONS OF A [SPLIT ROW-WISE] TO ALL WORKERS */
    for (i = 0; i < N; i++) {
 
      /* ID OF THE PROCESSOR THAT'S RECEIVING THE INFORMATION (dest) */
      proc_dest = map_processors(i, n_procs);
 
      /* MPI_Send(buf, count, datatype, dest, tag, comm) */
      MPI_Send(&A[i], N, MPI_DOUBLE, proc_dest, i + 10000, MPI_COMM_WORLD);
    }
 
    /* RECEIVE RESULT FROM WORKERS */
    for (i = 0; i < N; i++) {
 
      /* ID OF THE PROCESSOR THAT'S SENDING THE INFORMATION (source) */
      proc_source = map_processors(i, n_procs);
 
      /* MPI_Recv(buf, count, datatype, source, tag, comm, status) */
      MPI_Recv(&C[i], N, MPI_DOUBLE, proc_source, i, MPI_COMM_WORLD, &status);
    }
 
    /* PRINT MATRIX C */
    printf("\n  Matrix C:\n\n");
    for (i = 0; i < N; i++) {
      for (j = 0; j < N; j++) {
        printf(" %4.0lf", C[i][j]);
      }
      printf("\n");
    }
    printf("\n");
 
  } /* MASTER LOOP ENDS */
 
 
 
  /* IF WORKER, THEN DO THE FOLLOWING:
   * RECEIVE ENTIRE MATRIX B FROM MASTER
   * RECEIVE RELEVANT PORTION OF MATRIX A FROM MASTER
   * PERFORM RELEVANT PORTION OF A * B CALCULATION
   * SEND RELEVANT PORTION OF MATRIX C TO MASTER 
  */
  if (proc_id > MASTER) {
 
    /* RECEIVE THE ENTIRE MATRIX B FROM MASTER AS A SET OF 1D BUFFERS */
    /* MPI_Recv(buf, count, datatype, source, tag, comm, status) */
    for (i = 0; i < N; i++) {
      MPI_Recv(&B[i], N, MPI_DOUBLE, 0, i + 1000, MPI_COMM_WORLD, &status);
    }
 
    /* FOR LOOP - MATRIX MULTIPLICATION - BEGINS */
    for (i = 0; i < N; i++) {
 
      /* ID OF THE PROCESSOR THAT'S SENDING THE INFORMATION (source) */
      proc_current = map_processors(i, n_procs);
 
      /* IF LOOP - CHECK CURRENT PROCESSOR ID - BEGINS */
      if (proc_current == proc_id) {
 
        /* RECEIVE RELEVANT PORTIONS OF A [SPLIT ROW-WISE] FROM MASTER */
        MPI_Recv(&Abuf, N, MPI_DOUBLE, 0, i + 10000, MPI_COMM_WORLD, &status);
 
        for (j = 0; j < N; j++) {
 
          /* sum NEEDS TO BE SET TO ZERO FOR EVERY VALUE OF j */
          sum = 0;
 
          /* CALCULATE THE sum, CUMULATIVE SUM OF PRODUCT OF 
           * Abuf[i] & B[j][k]
          */
          for (k = 0; k < N; k++) {
            sum = sum + (Abuf[k] * B[k][j]);
          }
 
          /* ASSIGN THE VALUE OF 'sum' to Cbuf[j] SO THAT MPI_Send CAN 
           * SEND IT TO MASTER
          */ 
          Cbuf[j] = sum;
        }
 
        /* SEND Cbuf[j] TO MASTER */
        MPI_Send(&Cbuf, N, MPI_DOUBLE, 0, i, MPI_COMM_WORLD);
 
      } /* IF LOOP - CHECK CURRENT PROCESSOR ID - ENDS */
 
    } /* FOR LOOP - MATRIX MULTIPLICATION - ENDS */
 
  } /* WORKER LOOP ENDS */
 
  /* FINALIZE MPI */
  MPI_Finalize();
 
  /* INDICATE THE TERMINATION OF THE PROGRAM */
  return 0;
 
} /* MAIN PROGRAM ENDS */

/* send_receive_advanced.c
 * PARALLEL [MPI] C PROGRAM TO DEMONSTRATE MPI_Send & MPI_Recv FUNCTIONS.
 * MASTER [proc_id = 0] SENDS SOME DATA TO A WORKER [proc_id = 1].
 * WORKER PERFORMS SOME MATHEMATICAL OPERATION AND RETURNS THE
 * 'NEW INFORMATION' TO MASTER.
 *
 * TESTED SUCCESSFULLY WITH MPICH2 (1.3.1) COMPILED AGAINST GCC (4.1.2) 
 * IN A LINUX BOX WITH QUAD CORE INTEL XEON PROCESSOR (1.86 GHz) & 4GB OF RAM.
 *
 * FIRST WRITTEN: GOWTHAM; Sat, 27 Nov 2010 17:10:10 -0500
 * LAST MODIFIED: GOWTHAM; Sat, 27 Nov 2010 18:15:23 -0500
 *
 * URL:
 * http://sgowtham.net/blog/2010/11/28/mpi-c-an-advanced-send-receive/
 *
 * COMPILATION:
 * mpicc -g -Wall -lm send_receive_advanced.c -o send_receive_advanced.x
 *
 * EXECUTION:
 * mpirun -machinefile MACHINEFILE -np NPROC ./send_receive_advanced.x
 *
 * NPROC       : NUMBER OF PROCESSORS ALLOCATED TO RUNNING THIS PROGRAM;
 *               MUST BE EQUAL TO 2
 * MACHINEFILE : FILE LISTING THE HOSTNAMES OF PROCESSORS ALLOCATED TO
 *               RUNNING THIS PROGRAM
 *
*/
 
/* STANDARD HEADERS AND DEFINITIONS 
 * REFERENCE: http://en.wikipedia.org/wiki/C_standard_library
*/
#include <stdio.h>  /* Core input/output operations                         */
#include <stdlib.h> /* Conversions, random numbers, memory allocation, etc. */
#include <math.h>   /* Common mathematical functions                        */
#include <time.h>   /* Converting between various date/time formats         */
#include <mpi.h>    /* MPI functionality                                    */
 
#define MASTER  0   /* Process ID for MASTER                                */
#define WORKER  1   /* Process ID for WORKER                                */
#define N      10   /* Array size                                           */
 
/* MAIN PROGRAM BEGINS */
int main(int argc, char **argv) {
 
  /* VARIABLE DECLARATION */
  int    proc_id,       /* Process identifier                    */
         n_procs,       /* Number of processors                  */
         i;             /* Dummy/Running index                   */
 
  double x[N],          /* 1D array of size N
                           Information sent from MASTER
                           Information received by WORKER        */
         y[N];          /* 1D array of size N
                           Information sent from WORKER
                           Information received by MASTER        */
 
  MPI_Status status;    /* MPI structure containing return codes
                           for message passing operations        */
 
  /* INITIALIZE MPI */
  MPI_Init(&argc, &argv);
 
  /* GET THE PROCESS ID AND NUMBER OF PROCESSORS */
  MPI_Comm_rank(MPI_COMM_WORLD, &proc_id);
  MPI_Comm_size(MPI_COMM_WORLD, &n_procs);
 
  /* IF MASTER, THEN DO THE FOLLOWING:
   * POPULATE x[N]
   * SEND x[N] TO WORKER 
   * RECEIVE y[N] FROM WORKER
   * DISPLAY y[N]
  */
  if (proc_id == MASTER) {
 
    /* POPULATE x[N] - EACH ARRAY ELEMENT IS JUST THE INDEX */
    for (i=0; i < N; i++) {
      x[i] = i;
    }
 
    /* SEND x[N] TO WORKER */
    /* MPI_Send(buf, count, datatype, dest, tag, comm) */
    printf("\n  Sending x[N] to WORKER [proc_id = 1] with TAG = 0\n");
    MPI_Send(x, N, MPI_DOUBLE, 1, 0, MPI_COMM_WORLD);
 
    /* RECEIVE y[N] FROM WORKER */
    /* MPI_Recv(buf, count, datatype, source, tag, comm, status) */
    printf("\n  Receiving y[N] from WORKER [proc_id = 1] with TAG = 1\n");
    MPI_Recv(y, N, MPI_DOUBLE, 1, 1, MPI_COMM_WORLD, &status);
 
    /* DISPLAY y[N] */
    for (i=0; i < N; i++) {
      printf("    y[%d] = %2.0lf\n", i, y[i]);
    }
 
  } /* MASTER LOOP ENDS */
 
 
  /* IF WORKER, THEN DO THE FOLLOWING:
   * RECEIVE x[N] FROM MASTER 
   * CREATE y[N]
   * SEND y[N] TO MASTER
  */
  if (proc_id == WORKER) {
 
    /* RECEIVE x[N] FROM MASTER */
    printf("\n  Receiving x[N] from MASTER [proc_id = 0] with TAG = 0\n");
    MPI_Recv(x, N, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &status);
 
    /* CREATE A NEW ARRAY y[N]
     * A SIMPLE MATHEMATICAL MANIPULATION 
     * TAKE THE ELEMENTS OF x[N] AND SQUARE THEM
    */
    for (i=0; i < N; i++) {
      y[i] = x[i] * x[i];
    }
 
    /* SEND y[N] TO MASTER */
    printf("\n  Sending y[N] to MASTER [proc_id = 0] with TAG = 1\n");
    MPI_Send(y, N, MPI_DOUBLE, 0, 1, MPI_COMM_WORLD);
 
  } /* WORKER LOOP ENDS */
 
  /* FINALIZE MPI */
  MPI_Finalize();
 
  /* INDICATE THE TERMINATION OF THE PROGRAM */
  return 0;
 
} /* MAIN PROGRAM ENDS */

/* send_receive_simple.c
 * PARALLEL [MPI] C PROGRAM TO DEMONSTRATE MPI_Send & MPI_Recv FUNCTIONS.
 * MASTER [proc_id = 0] SENDS SOME DATA TO A WORKER [proc_id = 1].  
 * WORKER DISPLAYS THE DATA RECEIVED. 
 *
 * TESTED SUCCESSFULLY WITH MPICH2 (1.3.1) COMPILED AGAINST GCC (4.1.2) 
 * IN A LINUX BOX WITH QUAD CORE INTEL XEON PROCESSOR (1.86 GHz) & 4GB OF RAM.
 *
 * FIRST WRITTEN: GOWTHAM; Sat, 27 Nov 2010 16:01:01 -0500
 * LAST MODIFIED: GOWTHAM; Sat, 27 Nov 2010 16:49:11 -0500
 *
 * URL:
 * http://sgowtham.net/blog/2010/11/28/mpi-c-a-simple-send-receive/
 *
 * COMPILATION:
 * mpicc -g -Wall -lm send_receive_simple.c -o send_receive_simple.x
 *
 * EXECUTION:
 * mpirun -machinefile MACHINEFILE -np NPROC ./send_receive_simple.x
 *
 * NPROC       : NUMBER OF PROCESSORS ALLOCATED TO RUNNING THIS PROGRAM;
 *               MUST BE EQUAL TO 2
 * MACHINEFILE : FILE LISTING THE HOSTNAMES OF PROCESSORS ALLOCATED TO
 *               RUNNING THIS PROGRAM
 *
*/
 
/* STANDARD HEADERS AND DEFINITIONS 
 * REFERENCE: http://en.wikipedia.org/wiki/C_standard_library
*/
#include <stdio.h>  /* Core input/output operations                         */
#include <stdlib.h> /* Conversions, random numbers, memory allocation, etc. */
#include <math.h>   /* Common mathematical functions                        */
#include <time.h>   /* Converting between various date/time formats         */
#include <mpi.h>    /* MPI functionality                                    */
 
#define MASTER  0   /* Process ID for MASTER                                */
#define WORKER  1   /* Process ID for WORKER                                */
 
/* MAIN PROGRAM BEGINS */
int main(int argc, char **argv) {
 
  /* VARIABLE DECLARATION */
  int    proc_id,       /* Process identifier                    */
         n_procs;       /* Number of processors                  */
 
  double x;             /* Information sent from MASTER
                           Information received by WORKER        */ 
 
  MPI_Status status;    /* MPI structure containing return codes
                           for message passing operations        */
 
  /* INITIALIZE MPI */
  MPI_Init(&argc, &argv);
 
  /* GET THE PROCESS ID AND NUMBER OF PROCESSORS */
  MPI_Comm_rank(MPI_COMM_WORLD, &proc_id);
  MPI_Comm_size(MPI_COMM_WORLD, &n_procs);
 
  /* IF MASTER, THEN DO THE FOLLOWING:
   * INITIALIZE x
   * SEND IT TO THE WORKER 
  */
  if (proc_id == MASTER) {
 
    /* INITIALIZE x */
    x = 100.001;
 
    /* SEND x TO WORKER */
    printf("\n  Sending x to WORKER [proc_id = 1] with TAG = 0\n");
 
    /* MPI_Send syntax:
     * MPI_Send(buf, count, datatype, dest, tag, comm)
     * [IN buf]      initial address of send buffer (choice)
     * [IN count]    number of elements in send buffer (nonnegative integer)
     * [IN datatype] datatype of each send buffer element (handle)
     * [IN dest]     rank of destination (integer)
     * [IN tag]      message tag (integer)
     *               must be unique for a pair of Send/Recv statements
     * [IN comm]     communicator (handle) 
    */
    MPI_Send(&x, 1, MPI_DOUBLE, 1, 0, MPI_COMM_WORLD);
 
  } /* MASTER LOOP ENDS */
 
 
  /* IF WORKER, THEN DO THE FOLLOWING:
   * RECEIVE x FROM MASTER
   * DISPLAY IT 
  */
  if (proc_id == WORKER) {
 
    /* RECEIVE x FROM MASTER */
    printf("\n  Receiving x from MASTER [proc_id = 0] with TAG = 0\n");
 
    /* MPI_Recv syntax:
     * MPI_Recv(buf, count, datatype, source, tag, comm, status)
     * [OUT buf]     initial address of receive buffer (choice)
     * [IN count]    number of elements in receive buffer (integer)
     * [IN datatype] datatype of each receive buffer element (handle)
     * [IN source]   rank of source (integer)
     * [IN tag]      message tag (integer)
     *               must be same as the tag in Send statement
     * [IN comm]     communicator (handle)
     * [OUT status]  status object (Status) 
    */
    MPI_Recv(&x, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &status);
 
    /* DISPLAY x */
    printf("\n    x = %lf\n", x);
 
  } /* WORKER LOOP ENDS */
 
  /* FINALIZE MPI */
  MPI_Finalize();
 
  /* INDICATE THE TERMINATION OF THE PROGRAM */
  return 0;
 
} /* MAIN PROGRAM ENDS */

/* hello_world_oddeven.c
 * PARALLEL [MPI] C PROGRAM TO PRINT 'HELLO, WORLD!' TO THE SCREEN AS
 * WELL AS WHETHER THE PROCESSOR ID IS EITHER ODD OR EVEN.
 *
 * TESTED SUCCESSFULLY WITH MPICH2 (1.3.1) COMPILED AGAINST GCC (4.1.2) 
 * IN A LINUX BOX WITH QUAD CORE INTEL XEON PROCESSOR (1.86 GHz) & 4GB OF RAM.
 *
 * FIRST WRITTEN: GOWTHAM; Sat, 27 Nov 2010 10:30:11 -0500
 * LAST MODIFIED: GOWTHAM; Sat, 27 Nov 2010 11:25:34 -0500
 *
 * URL:
 * http://sgowtham.net/blog/2010/11/28/mpi-c-oddly-or-evenly-saying-ello/
 *
 * COMPILATION:
 * mpicc -g -Wall hello_world_oddeven.c -o hello_world_oddeven.x
 *
 * EXECUTION:
 * mpirun -machinefile MACHINEFILE -np NPROC ./hello_world_oddeven.x
 *
 * NPROC       : NUMBER OF PROCESSORS ALLOCATED TO RUNNING THIS PROGRAM
 * MACHINEFILE : FILE LISTING THE HOSTNAMES OF PROCESSORS ALLOCATED TO
 *               RUNNING THIS PROGRAM
 *
*/
 
/* STANDARD HEADERS AND DEFINITIONS 
 * REFERENCE: http://en.wikipedia.org/wiki/C_standard_library
*/
#include <stdio.h>  /* Core input/output operations                         */
#include <stdlib.h> /* Conversions, random numbers, memory allocation, etc. */
#include <math.h>   /* Common mathematical functions                        */
#include <time.h>   /* Converting between various date/time formats         */
#include <mpi.h>    /* MPI functionality                                    */
 
/* MAIN PROGRAM BEGINS */
int main(int argc, char **argv) {
 
  /* VARIABLE DECLARATION */
  int proc_id,       /* Process identifier   */
      n_procs;       /* Number of processors */
 
  /* INITIALIZE MPI */
  MPI_Init(&argc, &argv);
 
  /* GET THE PROCESS ID AND NUMBER OF PROCESSORS */
  MPI_Comm_rank(MPI_COMM_WORLD, &proc_id);
  MPI_Comm_size(MPI_COMM_WORLD, &n_procs);
 
  /* PRINT 'HELLO, WORLD!' FROM EVERY PROCESSOR 
   * ALSO INDICATE WHETHER THE PROCESSOR ID IS ODD OR EVEN
  */
  if (proc_id % 2 == 0) {
    printf("Hello, World! From %d [e] out of %d processors\n", proc_id, n_procs);
  } else {
    printf("Hello, World! From %d [o] out of %d processors\n", proc_id, n_procs);
  }
 
  /* FINALIZE MPI */
  MPI_Finalize();
 
  /* INDICATE THE TERMINATION OF THE PROGRAM */
  return 0;
 
} /* MAIN PROGRAM ENDS */

/* hello_world.c
 * PARALLEL [MPI] C PROGRAM TO PRINT 'HELLO, WORLD!' TO THE SCREEN.
 *
 * TESTED SUCCESSFULLY WITH MPICH2 (1.3.1) COMPILED AGAINST GCC (4.1.2) 
 * IN A LINUX BOX WITH QUAD CORE INTEL XEON PROCESSOR (1.86 GHz) & 4GB OF RAM.
 *
 * FIRST WRITTEN: GOWTHAM; Sat, 27 Nov 2010 08:32:34 -0500
 * LAST MODIFIED: GOWTHAM; Sat, 27 Nov 2010 09:15:23 -0500
 *
 * URL: 
 * http://sgowtham.net/blog/2010/11/28/mpi-c-saying-ello/
 *
 * COMPILATION:
 * mpicc -g -Wall hello_world.c -o hello_world.x
 *
 * EXECUTION:
 * mpirun -machinefile MACHINEFILE -np NPROC ./hello_world.x
 *
 * NPROC       : NUMBER OF PROCESSORS ALLOCATED TO RUNNING THIS PROGRAM
 * MACHINEFILE : FILE LISTING THE HOSTNAMES OF PROCESSORS ALLOCATED TO
 *               RUNNING THIS PROGRAM
 *
*/
 
/* STANDARD HEADERS AND DEFINITIONS 
 * REFERENCE: http://en.wikipedia.org/wiki/C_standard_library
*/
#include <stdio.h>  /* Core input/output operations                         */
#include <stdlib.h> /* Conversions, random numbers, memory allocation, etc. */
#include <math.h>   /* Common mathematical functions                        */
#include <time.h>   /* Converting between various date/time formats         */
#include <mpi.h>    /* MPI functionality                                    */
 
/* MAIN PROGRAM BEGINS */
int main(int argc, char **argv) {
 
  /* VARIABLE DECLARATION */
  int proc_id,       /* Process identifier   */
      n_procs;       /* Number of processors */
 
  /* INITIALIZE MPI */
  MPI_Init(&argc, &argv);
 
  /* GET THE PROCESS ID AND NUMBER OF PROCESSORS */
  MPI_Comm_rank(MPI_COMM_WORLD, &proc_id);
  MPI_Comm_size(MPI_COMM_WORLD, &n_procs);
 
  /* PRINT 'HELLO, WORLD!' FROM EVERY PROCESSOR */
  printf("Hello, World! From %d out of %d processors\n", proc_id, n_procs);
 
  /* FINALIZE MPI */
  MPI_Finalize();
 
  /* INDICATE THE TERMINATION OF THE PROGRAM */
  return 0;
 
} /* MAIN PROGRAM ENDS */

cd /scratch/$USER/
svnadmin --fs-type fsfs create /scratch/$USER/svn_repo
svnadmin load /scratch/$USER/svn_repo < /tmp/svnrepo.dump

grep --binary-files=text -v '^* Dumped revision' /tmp/svnrepo.dump > /tmp/svnrepo_1.dump

svnadmin load /scratch/$USER/svn_repo < /tmp/svnrepo_1.dump

cd /scratch/$USER/svn_work
cd PROJECT
svn switch --relocate svn+ssh://hostname/${HOME}/svn_repo \
                      svn+ssh://hostname/scratch/$USER/svn_repo
svn up

#! /bin/bash
 
# svn_switchrepo.sh
# BASH script to inform the subversion client about the change in repository location.
# Automagically generates the list of projects
# 
# USAGE: svn_switchrepo.sh
#
# First written: Gowtham; Wed, 17 Nov 2010 12:40:04 -0500
# Last modified: Gowtham; Wed, 17 Nov 2010 12:40:04 -0500
 
# Automagical generation of the project list
export MYPROJECTS=`svn list svn+ssh://hostname/scratch/$USER/svn_repo \
                   | sort | awk -F '/' '{print $1}'`
 
echo 
for x in $MYPROJECTS
do
  clear
  cd /scratch/$USER/svn_work/
  echo "  Switching repository for project ${x}"
  cd ${x}
  # svn switch --relocate OLD_REPO_URL/PATH NEW_REPO_URL/PATH
  svn switch --relocate svn+ssh://hostname/${HOME}/svn_repo \
                        svn+ssh://hostname/scratch/$USER/svn_repo
  svn up
  echo "  Done"
done
 
echo

#! /bin/bash
#
# BASH script to generate SVN repository log
# Refer to http://svnbook.red-bean.com/en/1.1/ch05s03.html for details
#
# Usage: svn_log.sh [REPO_PATH]
# First written: Thu, 28 Jan 2010 12:19:37 -0500
# Last modified: Thu, 28 Jan 2010 12:19:37 -0500
 
 
if [ $# != 1 ];
then
  echo
  echo "  ERROR : REPOSITORY PATH missing"
  echo "  Usage : svn_log.sh [REPO_PATH]"
  echo
  exit
else
  export REPO=$1
 
  # Determine the youngest/newest/latest revision number
  export REVISION=`svnlook youngest $REPO`
 
  echo "----------------------------------------------------------------------------------------------------------------"
  echo " Rev #  Date/Time                                    Message"
  echo "----------------------------------------------------------------------------------------------------------------"
 
  while [ $REVISION -ge 1 ];
  do
    # Extract all information about the given revision
    svnlook info $REPO -r $REVISION > /tmp/sg_svnlook.tmp
 
    # Pick out relevant information from the above
    export DATETIME=`cat /tmp/sg_svnlook.tmp | head -2 | tail -1`
    export MESSAGE=`cat /tmp/sg_svnlook.tmp | tail -1`
 
    # Print them to the screen
    printf "%6s %45s %s\n"  "$REVISION" "$DATETIME" "$MESSAGE"
 
    # Decrement the revision number by 1
    export REVISION=`expr $REVISION - 1`
  done
 
  echo "----------------------------------------------------------------------------------------------------------------"
fi

#! /bin/bash
 
# BASH script to display the IP Address - one that the machine has, 
# as well as router's public IP Address, if any.
# Tested on Apple Mac Snow Leopard 10.6.2
 
# First written : Gowtham, Thu Dec 31 12:05:35 EST 2005
# Last modified : Gowtham, Thu Dec 31 12:05:35 EST 2005
 
# en1 is the wireless interface. 
# Change appropriately, if different
export WIFI_INTERFACE="en1"
 
# Details about the ${WIFI_INTERFACE}
ifconfig ${WIFI_INTERFACE} > public_ip.txt
export STATUS=`cat public_ip.txt | grep "status" | awk '{print $4}'`
 
# Analyze the details and display appropriate information
if [ "$STATUS" = "active" ];
then
  export IPADDRESS=`cat public_ip.txt | grep broadcast | awk '{print $2}'`
  export SSID=`system_profiler SPAirPortDataType | \
               grep -A1 "Current Network Information:" | \
               tail -1 | awk -F ':' '{print $1}' | \
               sed 's/^[ \t]*//;s/[ \t]*$//'`
else
  echo
  echo " `date`"
  echo " You are not connected to the internet"
  echo
  exit 0
fi
 
# Get the public IP address, $NSIP
export NSIP=`curl -s http://checkip.dyndns.org | awk '{print $6}' | \
             awk -F '<' '{print $1}'`
 
# Compare $IPADDRESS & $NSIP
# Display appropriate information along with SSID
if [ "$IPADDRESS" = "$NSIP" ];
then
  echo
  echo "  `date`"
  echo "  SSID       : $SSID"
  echo "  IP Address : $IPADDRESS"
  echo
else
  echo
  echo "  `date`"
  echo "  SSID                        : $SSID"
  echo "  Machine's static IP Address : $IPADDRESS"
  echo "  Router's  public IP Address : $NSIP"
  echo
fi
 
# Delete the scratch file
rm -f public_ip.txt

#! /bin/bash
 
# Script to extract the atomic positions (xyz) from 
# POSCAR & OUTCAR files of VASP and write them to a 
# file, to be used with Jmol, MolDen and such other
# third party programs
 
# First written: Gowtham, Tue, 22 Dec 2009 11:11:12 -0500
# Last modified: Gowtham, Tue, 22 Dec 2009 16:29:36 -0500
 
# Essential VASP Files
# If missing, quit the program
export POSCAR="POSCAR"
export OUTCAR="OUTCAR"
 
if [[ -e $POSCAR || -e $OUTCAR ]];
then
  echo
  echo "  $POSCAR & $OUTCAR found"
else
  echo
  echo "  ERROR : POSCAR &/or OUTCAR missing"
  echo
  exit
fi
 
# Output Filename 
# If missing, quit the program
export OUTPUT=$1
 
if [ $# != 1 ];
then
  echo
  echo "  ERROR : OUTPUT_FILENAME Missing"
  echo "  Usage : vasp2xyz.sh OUTPUT_FILENAME"
  echo
  exit
fi
 
# Delete scratch files
rm -f Final.tmp.*
rm -f $OUTPUT.xyz
 
# Atoms related information
# Extracted from POSCAR & OUTCAR
 
# Total number of atom types
# Pat Krogel: Tue, 22 Dec 2009 13:13:48 -050
declare -a ATOM_TYPE=(`sed -n '6 p' $POSCAR`)
export ATOM_TYPE_TOTAL=${#ATOM_TYPE[@]}
 
# Total number of atoms
export ATOMS_TOTAL=0
export i=0
while [[ "$i" -lt "$ATOM_TYPE_TOTAL" ]];
do
  export iATOM_TYPE=${ATOM_TYPE[$i]}
  export ATOMS_TOTAL=`expr $ATOMS_TOTAL + $iATOM_TYPE`
  export i=`expr $i + 1`
done
 
# Atom labels
declare -a ATOM_LABEL=(`grep "POTCAR:" $OUTCAR | head -$ATOM_TYPE_TOTAL | awk '{print $3}' | sed -e 's/_.*//g'`)
export ATOM_LABEL_TOTAL=${#ATOM_LABEL[@]}
 
# Print2Screen
if [[ "$ATOM_TYPE_TOTAL" != "$ATOM_LABEL_TOTAL" ]];
then
  echo
  echo "  ERROR : Atom Type Total ($ATOM_TYPE_TOTAL) does NOT"
  echo "          match Atom Label Count ($ATOM_LABEL_COUNT)"
  echo "  Please make sure OUTCAR & POSCAR are from the same"
  echo "  system and calculation"
  echo 
  exit
else
  echo
  echo "  Number of Atom Types   :" $ATOM_TYPE_TOTAL
  echo "  Atom Type              :" ${ATOM_LABEL[@]}
  echo "  Atom Type Count        :" ${ATOM_TYPE[@]}
  echo "  Total Number of Atoms  :" $ATOMS_TOTAL
 
  # ATOM_LABEL_2 is an array of atom labels
  # with each atom label appearing an appropriate
  # number of times, to a total of $ATOMS_TOTAL
  declare -a ATOM_LABEL_2
  export REPEAT=0
  export j=0
 
  while [[ "$j" -lt "$ATOM_TYPE_TOTAL" ]]; 
  do
    export k=1
 
    while [[ "$k" -le "${ATOM_TYPE[$j]}" ]]; 
    do
      export REPEAT=`expr $REPEAT + 1`
      export k=`expr $k + 1`
      ATOM_LABEL_2[$REPEAT]=${ATOM_LABEL[$j]}
    done
 
    export j=`expr $j + 1`
  done
# echo ${ATOM_LABEL_2[@]}
# echo ${#ATOM_LABEL_2[@]}
 
  # Record the line numbers where coordinates are written
  # in OUTCAR. Actual coordinates begin 2 lines below
  # the recorded numbers
  grep -n "POSITION" $OUTCAR | sed -e 's/:/ /g' | sed -e 's/POSITION.*//g' > LINE_NUMBERS.tmp
 
  export FRAME_NUMBER=1
  while read START
  do
    export START_HERE=`expr $START + 2`
    export END_HERE=`expr $START_HERE + $ATOMS_TOTAL - 1`
 
    echo "$ATOMS_TOTAL" >> $OUTPUT.xyz
    echo "# Frame Number: $FRAME_NUMBER" >> $OUTPUT.xyz
    sed -n "$START_HERE,$END_HERE p" $OUTCAR | awk '{printf "%12.8f %12.8f %12.8f\n", $1, $2, $3}' > Final.tmp.$FRAME_NUMBER
 
    export l=1
    while read X Y Z
    do
      echo ${ATOM_LABEL_2[$l]} $X $Y $Z > Final.tmp.$FRAME_NUMBER.$l
      awk '{ printf "%-3s %12.8f %12.8f %12.8f\n", $1, $2, $3, $4 }' Final.tmp.$FRAME_NUMBER.$l >> $OUTPUT.xyz
      export l=`expr $l + 1`
    done<Final.tmp.$FRAME_NUMBER
 
    export FRAME_NUMBER=`expr $FRAME_NUMBER + 1`
  done<LINE_NUMBERS.tmp
 
  export FRAMES_TOTAL=`expr $FRAME_NUMBER - 1`
  echo "  Total Number of Frames :" $FRAMES_TOTAL
  echo
fi
 
# Delete scratch files
rm -f LINE_NUMBERS.tmp 
rm -f Final.tmp.*

#! /bin/bash
 
# A wrapper for 'qstat' command to show 
# the total number processors used/in use.
# ROCKS 5.2.2
 
# Thu, 10 Dec 2009 12:27:59 -0500
 
export PROC_TOTAL="142"
 
export USERS_LIST="
  user0
  user1
  user2
  user3
  user4"
 
export PROC_INUSE=`/opt/gridengine/bin/lx26-amd64/qstat -u $USERS_LIST | \
                  awk '{print} (NR>2) {used_procs+=\$9} END {print used_procs}' | \
                  tail -1 | awk '{print $NF}'`
 
export PROC_AVAIL=`expr $PROC_TOTAL - $PROC_INUSE`
 
echo '-----------------------------------------------------------------------------------------------------------------' 
/opt/gridengine/bin/lx26-amd64/qstat -u $USERS_LIST
echo '-----------------------------------------------------------------------------------------------------------------' 
echo "   $PROC_TOTAL total processors :: $PROC_INUSE is/are in use :: $PROC_AVAIL is/are available"
echo '-----------------------------------------------------------------------------------------------------------------'
echo

#! /bin/bash
 
# A wrapper for 'qstat' command to show only the jobs
# submitted by a given user but show the total number
# processors used/in use.
# ROCKS 5.2.2
#
# Usage:
# qu [USERNAME]
# In the absence of any jobs submitted by USERNAME, or if
# USERNAME is not specified at all, it just displays the jobs, 
# if any, by the currently logged in user.
#
# Thu, 10 Dec 2009 12:27:59 -0500
 
export EXPECTED_ARGS="1"
export PROC_TOTAL="142"
 
export USERS_LIST="
  user0
  user1
  user2
  user3
  user4"
 
if [ $# -ne $EXPECTED_ARGS ];
then 
  export MYUSER="$USER"
else
  export MYUSER="$1"
fi
 
export PROC_USER=`/opt/gridengine/bin/lx26-amd64/qstat -u $MYUSER | \
                 awk '{print} (NR>2) {used_procs+=\$9} END {print used_procs}' | \
                 tail -1 | awk '{print $NF}'`
 
export PROC_INUSE=`/opt/gridengine/bin/lx26-amd64/qstat -u $USERS_LIST | \
                  awk '{print} (NR>2) {used_procs+=\$9} END {print used_procs}' | \
                  tail -1 | awk '{print $NF}'`
 
export PROC_AVAIL=`expr $PROC_TOTAL - $PROC_INUSE`
 
if [[ $PROC_USER -gt 0 ]] ;
then
  echo '-----------------------------------------------------------------------------------------------------------------' 
  /opt/gridengine/bin/lx26-amd64/qstat -u $MYUSER
  echo '-----------------------------------------------------------------------------------------------------------------' 
  echo " $PROC_TOTAL total processors :: $PROC_INUSE is/are in use :: $PROC_USER is/are use by $MYUSER :: $PROC_AVAIL is/are available "
  echo '-----------------------------------------------------------------------------------------------------------------'
  echo
else
  echo
  echo "  `hostname` @ `date -R`"
  echo
  echo "  $PROC_TOTAL total processors"
  echo "  $PROC_INUSE is/are in use "
  echo "  0 is/are use by $MYUSER"
  echo "  $PROC_AVAIL is/are available "
  echo
fi

CREATE TABLE IF NOT EXISTS `MyDatabase`.`TRK` (
  `id`          int( 11 ) NOT NULL AUTO_INCREMENT PRIMARY KEY ,
  `latitude`    float NULL ,
  `longitude`   float NULL ,
  `altitude`    float NULL ,
  `date`        date NULL ,
  `time`        time NULL
) ENGINE = MYISAM DEFAULT CHARSET latin1 AUTO_INCREMENT=1 ;
 
CREATE UNIQUE INDEX lldt ON `MyDatabase`.`TRK` (`latitude`,`longitude`,`date`,`time`);

<?php
 
# Database connection
$host     = 'localhost';
$dbuser   = 'DB_USERNAME';
$dbpasswd = 'DB_PASSWORD';
$database = 'DB_NAME';
 
$connect  = mysql_connect($host, $dbuser, $dbpasswd) or
            die('<b>MySQL Connection Error:</b> ' .
            mysql_errno() . ': ' .
            mysql_error());
 
mysql_select_db($database, $connect) or
            die('<b>Database Connection Error:</b> ' .
            mysql_errno() . ': ' .
            mysql_error());
 
# Radius of Earth (in miles)
# Use appropriate conversion factors if
# the distance is desired in other units.
$earth_radius  = 3960.00;
$distance_unit = "miles";
 
# Date / Time in UTC 
$start_datetime = "2009-11-25 03:00:00";
$end_datetime   = "2009-11-29 13:00:00";
 
# Running indices
$i         = 1;
$total_dis = 0.00;
 
# SQL Query #1
# Get all GPS/Date Time points between start_datetime and
# end_datetime
$sql1  = "SELECT latitude, longitude, date, time, ";
$sql1 .= "CONCAT(date, ' ', time) AS datetime ";
$sql1 .= "FROM TRK WHERE CONCAT(date, ' ', time) BETWEEN ";
$sql1 .= "'$start_datetime' AND '$end_datetime' ";
$sql1 .= "ORDER BY UNIX_TIMESTAMP(datetime) ASC ";
$res1  = mysql_query($sql1) or
          die('Invalid Query : ' .
          mysql_errno() . ' : ' .
          mysql_error());
 
while ($myrow1 = mysql_fetch_array($res1)) {
  $lat1 = $myrow1['latitude'];
  $lon1 = $myrow1['longitude'];
  $dat1 = $myrow1['date'];
  $tim1 = $myrow1['time'];
  $dt_1 = "$dat1" . " " . "$tim1";
 
  # SQL Query #2
  # Get the GPS/Date Time point next to the one in question
  $sql2   = "SELECT latitude, longitude, date, time, ";
  $sql2  .= "CONCAT(date, ' ', time) AS trk_dt_0, ";
  $sql2  .= "'$dat1 $tim1' AS trk_dt_1 FROM TRK WHERE ";
  $sql2  .= "UNIX_TIMESTAMP(CONCAT(date, ' ', time)) > ";
  $sql2  .= "UNIX_TIMESTAMP('$dat1 $tim1') ORDER BY ";
  $sql2  .= "UNIX_TIMESTAMP(trk_dt_0) ASC LIMIT 1 ";
  $res2   = mysql_query($sql2) or
             die('Invalid Query : ' .
             mysql_errno() . ' : ' .
             mysql_error());
  $nres2  = mysql_num_rows($res2);
 
  if($nres2 == 1) {
    while ($myrow2 = mysql_fetch_array($res2)) {
      $lat2 = $myrow2['latitude'];
      $lon2 = $myrow2['longitude'];
      $dat2 = $myrow2['date'];
      $tim2 = $myrow2['time'];
      $dt_2 = "$dat2" . " " . "$tim2";
 
      # Compute distance between two points in question using
      # Haversine formula/function.
      # Add the haversine distance to the total/cumulative distance
      $haver_dis = distance_haversine($lat1, $lon1, $lat2, $lon2);
      $total_dis = $total_dis + $haver_dis ;
      $i         = str_pad($i, 6, "0", STR_PAD_LEFT);
 
      # Present results at each step
      # Can be piped out to a flat text file, if need be.
      # Useful to check the speed of movement, etc.
      # echo "    $i :: $dt_1 : $lat1 : $lon1 : $dt_2 : $lat2 : $lon2 : $haver_dis : $total_dis\n";

      # Increment the running index
      $i++;
    }
  }
}
 
# Function to accept latitue and longitude of 
# two locations and compute the distance between them.
function distance_haversine($lat1, $lon1, $lat2, $lon2) {
  global $earth_radius;
  $delta_lat = $lat2 - $lat1 ;
  $delta_lon = $lon2 - $lon1 ;
  $alpha     = $delta_lat/2 ;
  $beta      = $delta_lon/2 ;
 
  $a        = sin(deg2rad($alpha)) * sin(deg2rad($alpha)) + cos(deg2rad($lat1)) * cos(deg2rad($lat2)) * sin(deg2rad($beta)) * sin(deg2rad($beta)) ;
  $c        = asin(min(1, sqrt($a)));
  $distance = 2*$earth_radius * $c;
  $distance = round($distance, 4);
 
  return $distance;
}
 
# Print the summary
echo "\n";
echo "  Start Date Time : $start_datetime\n";
echo "  End Date Time   : $end_datetime\n";
echo "  Total Distance  : $total_dis $distance_unit\n";
echo "\n";
 
# Close the database connection
mysql_close($connect);
?>

CREATE TABLE IF NOT EXISTS `MyDatabase`.`TRK` (
  `id`          int( 11 ) NOT NULL AUTO_INCREMENT PRIMARY KEY ,
  `latitude`    float NOT NULL DEFAULT '0' ,
  `longitude`   float NOT NULL DEFAULT '0' ,
  `altitude`    float NOT NULL DEFAULT '0' ,
  `date_time`   float NOT NULL DEFAULT '0000-00-00 00:00:00' 
) ENGINE = MYISAM DEFAULT CHARSET latin1 AUTO_INCREMENT=1 ;
 
CREATE UNIQUE INDEX dt ON `MyDatabase`.`TRK` (`date_time`);
CREATE UNIQUE INDEX lldt ON `MyDatabase`.`TRK` (`latitude`,`longitude`,`date_time`);

<?php
# Database connection
$host     = 'localhost';
$dbuser   = 'DB_USERNAME';
$dbpasswd = 'DB_PASSWORD';
$database = 'DB_NAME';
 
$connect  = mysql_connect($host, $dbuser, $dbpasswd) or
            die('<b>MySQL Connection Error:</b> ' .
            mysql_errno() . ': ' .
            mysql_error());
 
mysql_select_db($database, $connect) or
            die('<b>Database Connection Error:</b> ' .
            mysql_errno() . ': ' .
            mysql_error());
 
# Radius of Earth (in miles)
# Use appropriate conversion factors if
# the distance is desired in other units.
$earth_radius  = 3960.00;
$distance_unit = "miles";
 
# Date / Time in UTC 
$start_datetime = "2009-11-25 03:00:00";
$end_datetime   = "2009-11-29 13:00:00";
 
# Running indices
$i         = 1;
$total_dis = 0.00;
 
# SQL Query #1
# Get all GPS/Date Time points between start_datetime and
# end_datetime
$sql1  = "SELECT trk_latitude, trk_longitude, trk_datetime ";
$sql1 .= "FROM tracks WHERE trk_datetime BETWEEN ";
$sql1 .= "'$start_datetime' AND '$end_datetime' ";
$sql1 .= "ORDER BY trk_datetime ASC ";
$res1  = mysql_query($sql1) or
          die('Invalid Query : ' .
          mysql_errno() . ' : ' .
          mysql_error());
 
while ($myrow1 = mysql_fetch_array($res1)) {
  $lat1 = $myrow1['trk_latitude'];
  $lon1 = $myrow1['trk_longitude'];
  $dt1  = $myrow1['trk_datetime'];
 
  # SQL Query #2
  # Get the GPS/Date Time point next to the one in question
  $sql2   = "SELECT trk_latitude, trk_longitude, trk_datetime ";
  $sql2  .= "FROM tracks WHERE trk_datetime > '$dt1' ORDER BY ";
  $sql2  .= "trk_datetime ASC LIMIT 1 ";
  $res2   = mysql_query($sql2) or
             die('Invalid Query : ' .
             mysql_errno() . ' : ' .
             mysql_error());
  $nres2  = mysql_num_rows($res2);
 
  if($nres2 == 1) {
    while ($myrow2 = mysql_fetch_array($res2)) {
      $lat2 = $myrow2['trk_latitude'];
      $lon2 = $myrow2['trk_longitude'];
      $dt2  = $myrow2['trk_datetime'];
 
      # Compute distance between two points in question using
      # Haversine formula/function.
      # Add the haversine distance to the total/cumulative distance
      $haver_dis = distance_haversine($lat1, $lon1, $lat2, $lon2);
      $total_dis = $total_dis + $haver_dis ;
      $i         = str_pad($i, 6, "0", STR_PAD_LEFT);
 
      # Present results at each step
      # Can be piped out to a flat text file, if need be.
      # Useful to check the speed of movement, etc.
      # $time_now = date('r');  
      # echo " $i : $time_now : $dt1 : $lat1 : $lon1 : $dt2 : $lat2 : $lon2 : $haver_dis : $total_dis\n";

      # Increment the running index
      $i++;
    }
  }
}
 
# Function to accept latitue and longitude of 
# two locations and compute the distance between them.
function distance_haversine($lat1, $lon1, $lat2, $lon2) {
  global $earth_radius;
  $delta_lat = $lat2 - $lat1 ;
  $delta_lon = $lon2 - $lon1 ;
  $alpha     = $delta_lat/2 ;
  $beta      = $delta_lon/2 ;
 
  $a        = sin(deg2rad($alpha)) * sin(deg2rad($alpha)) + cos(deg2rad($lat1)) * cos(deg2rad($lat2)) * sin(deg2rad($beta)) * sin(deg2rad($beta)) ;
  $c        = asin(min(1, sqrt($a)));
  $distance = 2*$earth_radius * $c;
  $distance = round($distance, 4);
 
  return $distance;
}
 
# Print the summary
echo "\n";
echo "  Start Date Time : $start_datetime\n";
echo "  End Date Time   : $end_datetime\n";
echo "  Total Distance  : $total_dis $distance_unit\n";
echo "\n";
 
# Close the database connection
mysql_close($connect);
?>

#showcase_holder {
  background: #000000 url('images/loading.gif') 50% 50% no-repeat;
  position: relative;
}
 
#showcase_image_border {
  position: relative;
  margin: 0;
}
 
#showcase_navigation {
  position: absolute;
  margin: 0px;
  margin-right: -10px;
  padding: 0px;
  top: 0px;
  left: 0px;
  z-index: 1000;
}
 
#showcase_navigation a {
  outline: none;
}
 
#showcase_navigation_prev, 
#showcase_navigation_next {
  width: 49.9%;
  height: 100%;
  /* Trick IE into showing hover */
  background: transparent url('images/blank.gif') no-repeat;
  display: block;
}
 
#showcase_navigation_prev {
  top: 0px;
  left: 0px;
  float: left;
}
 
#showcase_navigation_next {
  top: 0px;
  right: 0px;
  float: right;
}
 
#showcase_navigation_prev:hover, 
#showcase_navigation_prev:visited:hover {
  background: url('images/left_arrow.png') no-repeat 50% 50%;
  cursor: pointer;
}
 
#showcase_navigation_next:hover, 
#showcase_navigation_next:visited:hover {
  background: url('images/right_arrow.png') no-repeat 50% 50%;
  cursor: pointer;
}

<!--
Terms in UPPER CASE indicate variables that need to be somehow/automagically 
supplied for proper functioning. If your image details are stored in a MySQL 
database and you are serving the page using PHP, you may use the getimagesize() 
function as follows:
 
list($width, $height, $type, $attribs) = getimagesize("filename.jpg");
-->
 
<div id="showcase_holder" style="width:IMAGE_WIDTHpx;height:IMAGE_HEIGHTpx;">
  <div id="showcase_image_border" style="width:IMAGE_WIDTHpx;height:IMAGE_HEIGHTpx;">
    <img src="CURRENT_IMAGE_URL" title="Image Title"
      alt="Image Title" id="photo" name="photo" style="background:black;">
 
    <div id="showcase_navigation" style="width:IMAGE_WIDTHpx;height:IMAGE_HEIGHTpx;">
      <a href="PREV_IMAGE_URL" id="showcase_navigation_prev"></a>
      <a href="NEXT_IMAGE_URL" id="showcase_navigation_next"></a>
    </div>
  </div>
</div>