View source for Installation/Live Images/USB-Stick for OFW11/Creation Guide

<span style="font-size:180%">'''WARNING: These instructions are currently being written and under testing!'''</span>

= Creating the development machine =

== Installation details ==
Rough outline of the installation steps, although specifies details are provided at each subsection:
# Install Lubuntu 15.10 x86_64 in a virtual machine.
# Install necessary packages inside virtual machine.
# Install Anaconda bundle of Python 2.7.
# Install OpenFOAM 3.0.x, as instructed here: [[Installation/Linux/OpenFOAM-3.0.x/Ubuntu#Ubuntu_15.10]]
# Install foam-extend 4.0, based on the instructions from here: [[Installation/Linux/foam-extend-3.2/Ubuntu#Ubuntu_15.10]]
# Install swak4Foam, PyFoam and cfMesh for OpenFOAM 3.0.x and in foam-extend 4.0 (although cfMesh is already integrated into it).


=== Install Lubuntu 15.10 x86_64 in a virtual machine ===
'''TODO'''


=== Packages that need to be installed in the development VM ===
'''TODO'''

Part of the software stack:
<bash>sudo apt-get install squashfs-tools
</bash>

All of the packages for OpenFOAM and foam-extend (see next sections), along with the requested software that is listed in section [[#First boot up of the new USB-Stick|First boot up of the new USB-Stick]].

=== Install Anaconda 4.0.0 with Python 2.7 ===
At the request of one of the instructors for OFW11, we need to install the Anaconda Python 2.7 software bundle. To do so, the following commands were used:
<ol {{NoIndentStyle}}>
<li>We'll install it on OpenFOAM's folder, to make it easier to spot it in the crowd of software that is going to be installed:
<bash>mkdir ~/OpenFOAM
cd OpenFOAM</bash>
</li>
<li>Download the Anaconda installer:
<bash>wget http://repo.continuum.io/archive/Anaconda2-4.0.0-Linux-x86_64.sh</bash>
</li>
<li>To install it, run:
<bash>bash Anaconda2-4.0.0-Linux-x86_64.sh -p $PWD/anaconda2</bash>
<ul>
<li>It will show you the license and ask you to agree to this license.</li>
<li>And it will ask you if it should prepend the installation path into {{tt|PATH}} within {{tt|.bashrc}}, to which you can reply {{tt|no}}.</li>
</ul>
</li>
<li>As a note for the OpenFOAM and foam-extend installations, here is the command that will have to be used for loading the respective environment:
<bash>export PATH=/home/lubuntu/OpenFOAM/anaconda2/bin:$PATH</bash>
</li>
<li>Since we need to install a few more packages, run the previous command line and then run the following commands:
<bash>easy_install ipdb
easy_install rst2pdf
conda install seaborn
conda install vtk=5.10.1</bash>
</li>
<li>Then we should clean up the downloaded files:
<bash>conda clean --tarballs</bash>
</li>
</ol>

=== Install Salome 7.7.1 ===
At the time of this writing, the version was 7.7.1 and the steps for installing it were as follows:
<ol>
<li>Download the Universal Binaries package from their download page: [http://www.salome-platform.org/downloads/current-version Salome Downloads page]</li>
<li>Place the downloaded package inside the folder {{tt|~/OpenFOAM}} and then run in the command line:
<bash>cd ~/OpenFOAM
chmod +x Salome-V7_7_1-LGPL-x86_64.run
./Salome-V7_7_1-LGPL-x86_64.run -t $PWD/salome
</bash>
</li>
<li>It will then ask you for the language, to which you can simply press the Enter key.</li>
<li>Once it's finished installing, we're done for now. We will use an alias for running the following command:
<bash>/home/lubuntu/OpenFOAM/salome/appli_V7_7_1/salome</bash>
</li>
</ol>


=== Dakota 6.3 ===
We will take the short-cut and install the binary package, instead of building it from source code. Installation steps:
<ol>
<li>Download Dakota 6.3 from here: [https://dakota.sandia.gov/download.html Dakota Downloads page]</li>
<li>Unpack it within the folder {{tt|~/OpenFOAM}}, e.g.:
<bash>cd ~/OpenFOAM
tar -xf /Downloads/dakota-6.3-public-Linux.x86_64.tar.gz</bash></li>
<li>Rename the unpacked folder to {{tt|dakota}}:
<bash>mv dakota-6.3.0.Linux.x86_64 dakota</bash></li>
<li>The environment script code to be used within OpenFOAM and foam-extend is as follows:
<bash>DAKOTA_INSTALL=$HOME/OpenFOAM/dakota
export PATH=$PATH:$DAKOTA_INSTALL/bin:$DAKOTA_INSTALL/test
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$DAKOTA_INSTALL/lib:$DAKOTA_INSTALL/bin</bash>
</li>
</ol>


=== Install HELYX-OS 2.4.0 ===

At the time of this writing, a beta version of 2.4.0 was provided for the USB stick, nonetheless, we'll keep the instructions ''somewhat general'' here. Installation steps:
<ol>
<li>Download HELYX-OS from the official download page: [http://engys.github.io/HELYX-OS/ HELYX-OS project page]</li>
<li>We'll use a circumvention mechanism for the installation, by unpacking directly:
<bash>cd ~/OpenFOAM
mkdir HELYX-OS

PACKAGE=~/Downloads/20160531-Engys-HELYX-OS-2.4.0-linux-x86_64-FULL.bin
ARCHIVE=`awk '/^__ARCHIVE_BELOW__/ {print NR + 1; exit 0; }' $PACKAGE`
tail -n+$ARCHIVE $PACKAGE | tar -xzv -C HELYX-OS ./20160531-Engys-HELYX-OS-2.4.0-linux-x86_64-GUI.tar.bz2 > /dev/null 
unset PACKAGE ARCHIVE

cd HELYX-OS

tar -xf 20160531-Engys-HELYX-OS-2.4.0-linux-x86_64-GUI.tar.bz2 --transform='s_Engys/HELYX-OS__'
rm 20160531-Engys-HELYX-OS-2.4.0-linux-x86_64-GUI.tar.bz2
</bash>
</li>
<li>Launch HELYX-OS, because we need to configure it accordingly to use OpenFOAM 3.0.x:
<bash>v2.4.0/HELYX-OS.sh</bash>
</li>
<li>It will complain that the "Core" is not installed. Therefore, close that dialogue box and click on the X on the upper right corner of start window. Then click on the menu {{tt|Edit --> Preferences}} and configure as follows:
<ul {{NoIndentStyle}}>
<li>For the ''Core Folder'', choose this path:
<bash>/home/lubuntu/OpenFOAM/OpenFOAM-3.0.x</bash></li>
<li>For the ''ParaView Executable'', choose this path:
<bash>/home/lubuntu/OpenFOAM/ThirdParty-3.0.x/platforms/linux64Gcc/ParaView-4.4.0/bin/paraview</bash></li>
</ul>
Then  you can press the OK button and close HELYX-OS.
</li>
<li>If all goes well, keep in mind to:
<ul {{NoIndentStyle}}>
<li>Create an alias:
<bash>alias helyxos="$HOME/OpenFOAM/HELYX-OS/v2.4.0/HELYX-OS.sh"</bash></li>
<li>Copy the file {{tt|~/.HELYX-OS/application.properties}} to the USB-stick.</li>
</ul>
</li>
</ol>


=== Install OpenFOAM 3.0.x ===
For the most part, follow the installation instructions given at [[Installation/Linux/OpenFOAM-3.0.x/Ubuntu]], namely in section [[Installation/Linux/OpenFOAM-3.0.x/Ubuntu#Ubuntu 14.04|Ubuntu 14.04]].

The changes needed are as follows:
<ol {{NoIndentStyle}}>
<li>In step #2 on those other instructions, do not install the following packages:
<bash>bison qt4-dev-tools libqt4-dev libqtwebkit-dev python python-dev</bash>
because we will be using the Anaconda Python 2.7 bundle, provided by [http://www.continuum.io Continuum Analytics], at the request of one of the instructors, which already provides most of these packages (Bison will have to be custom built). At the time of this writing, version Anaconda 4.0.0 was used.
</li>
<li>In step #6 on those other instructions, instead of running:
<bash>source $HOME/OpenFOAM/OpenFOAM-3.0.x/etc/bashrc FOAMY_HEX_MESH=yes</bash>
run:
<bash>echo export FOAMY_HEX_MESH=yes >> OpenFOAM-3.0.x/etc/prefs.sh
source $HOME/OpenFOAM/OpenFOAM-3.0.x/etc/bashrc 
</bash>
</li>
<li>Next we need to do a bit of manual file editing, where we need to edit the file {{tt|OpenFOAM-3.0.x/etc/bashrc}} and find this line:
<bash>_foamSource `$WM_PROJECT_DIR/bin/foamEtcFile config/gperftools.sh`</bash>
Then add below it the lines needed for Python and PyFoam, namely to make it look like this:
<bash>_foamSource `$WM_PROJECT_DIR/bin/foamEtcFile config/gperftools.sh`
_foamSource `$WM_PROJECT_DIR/bin/foamEtcFile config/Python.sh`
_foamSource `$WM_PROJECT_DIR/bin/foamEtcFile config/PyFoam.sh`
_foamSource `$WM_PROJECT_DIR/bin/foamEtcFile config/Dakota.sh`</bash>
</li>
<li>Then we need to create the aforementioned files, by running the following commands (keep in mind the OpenFOAM environment needs to already be active):
<bash>foam
echo 'export ANACONDA_PATH=$HOME/OpenFOAM/anaconda2' > etc/config/Python.sh
echo 'export PATH=$ANACONDA_PATH/bin:$PATH' >> etc/config/Python.sh
echo 'export PYTHONHOME=$ANACONDA_PATH' >> etc/config/Python.sh
echo 'export PYTHONPATH=$ANACONDA_PATH/lib/python2.7/site-packages' >> etc/config/Python.sh

echo 'export PYFOAM_DIR=$HOME/OpenFOAM/PyFoam' > etc/config/PyFoam.sh
echo 'export PYTHONPATH=$PYTHONPATH:$PYFOAM_DIR/lib/python2.7/site-packages/' >> etc/config/PyFoam.sh
echo 'export PATH=$PATH:$PYFOAM_DIR/bin' >> etc/config/PyFoam.sh

echo 'DAKOTA_INSTALL=$HOME/OpenFOAM/dakota' > etc/config/Dakota.sh
echo 'export PATH=$PATH:$DAKOTA_INSTALL/bin:$DAKOTA_INSTALL/test' >> etc/config/Dakota.sh
echo 'export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$DAKOTA_INSTALL/lib:$DAKOTA_INSTALL/bin' >> etc/config/Dakota.sh
echo 'unset DAKOTA_INSTALL' >> etc/config/Dakota.sh
</bash>
</li>
<li>Keep a mental note that you '''do not need''' to run this command:
<bash>export QT_SELECT=qt4</bash>
because we will be using Anaconda's Qt 4.8.7 build.
</li>
<li>In sub-step #9.2 on those other instructions, we build ParaView with the following commands (we need to make a couple of fixes):
<bash>foam3rdParty
sed -i -e 's=/usr/include=$ANACONDA_PATH/include=' etc/tools/ParaView4Functions
sed -i -e 's=PYTHON_INCLUDE_PATH=PYTHON_INCLUDE_DIR=' etc/tools/ParaView4Functions
./makeParaView4 -python -mpi -python-lib $ANACONDA_PATH/lib/libpython2.7.so.1.0 -qmake $ANACONDA_PATH/bin/qmake > log.makePV 2>&1</bash>
</li>
</ol>


==== Install additional contributions for OpenFOAM 3.0.x ====

===== Installing swak4Foam into OpenFOAM 3.0.x =====
These steps are a rough outline, given that the provided package was still a release candidate. Steps:
<ol>
<li>Unpack the provided package {{tt|swak4Foam-0.4rc.tgz}} into the folder {{tt|~/OpenFOAM/contribs}}, unpack and rename it accordingly:
<bash>cd ~/OpenFOAM/contribs/
tar -xzf swak4Foam-0.4rc.tgz
mv swak4Foam-0.4rc swak4Foam</bash>
</li>
<li>Now we go into the source code folder and use the same hack as used in foam-extend's {{tt|AllMake.stage5}} for installing on the {{tt|site}} folder:
<bash>cd swak4Foam
find Utilities Libraries -name files   | xargs -n 1 sed -i.old "s/FOAM_USER/FOAM_SITE/g"
find Utilities Libraries -name options | xargs -n 1 sed -i.old "s/FOAM_USER/FOAM_SITE/g"</bash>
</li>
<li>Now we need to configure the settings needed for using Python:
<bash>echo 'export SWAK_PYTHON_INCLUDE="-I$PYTHONHOME/include/python2.7"' > swakConfiguration
echo 'export SWAK_PYTHON_LINK="-L$PYTHONHOME/lib -lpython2.7"' >> swakConfiguration
echo 'export SWAK_COMPILE_GRAMMAR_OPTION="-O1"' >> swakConfiguration
</bash>
</li>
<li>We need to build Bison:
<bash>./maintainanceScripts/compileRequirements.sh</bash>
</li>
<li>Now we can build it:
<bash>./Allwmake > log.make 2>&1</bash>
If you want to built in parallel, run first:
<bash>export WM_NCOMPPROCS=4</bash>
</li>
<li>Clean up when completed, because we need to rebuild it for foam-extend 4.0:
<bash>./Allwclean</bash>
</li>
</ol>

===== Installing PyFoam into OpenFOAM 3.0.x =====
At this point, the environment is already defined with the {{tt|PYFOAM_DIR}} variable, which will make our life a bit easier. These steps are a rough outline, given that the provided package was still a release candidate. Steps:
<ol>
<li>Unpack the provided package {{tt|pyFoam-0.6.6.rc.tgz}} into the folder {{tt|~/OpenFOAM/contribs}}, unpack and rename it accordingly:
<bash>cd ~/OpenFOAM/contribs/
tar -xzf pyFoam-0.6.6.rc.tgz
mv pyFoam-0.6.6.rc/PyFoam PyFoam
rmdir pyFoam-0.6.6.rc</bash>
</li>
<li>If you've already installed a previous version of PyFoam:
<bash>[ -e "$PYFOAM_DIR" ] && rm -rf $PYFOAM_DIR</bash>
</li>
<li>Now we can install it:
<bash>mkdir -p $PYFOAM_DIR/lib/python2.7/site-packages/
python setup.py install --prefix=$PYFOAM_DIR</bash>
</li>
</ol>


===== Installing cfMesh into OpenFOAM 3.0.x =====
Steps, using the source code from the online git repository:
<ol>
<li>Go to the work folder and clone the repository:
<bash>cd ~/OpenFOAM/contribs/
git clone git://git.code.sf.net/p/cfmesh/code cfMesh</bash>
</li>
<li>Now we go into the source code folder and use the same hack as used in foam-extend's {{tt|AllMake.stage5}} for installing cfMesh on the {{tt|site}} folder:
<bash>cd cfMesh
find meshLibrary executables utilities -name files   | xargs -n 1 sed -i.old "s/FOAM_USER/FOAM_SITE/g"
find meshLibrary executables utilities -name options | xargs -n 1 sed -i.old "s/FOAM_USER/FOAM_SITE/g"</bash>
</li>
<li>Now we can build it:
<bash>./Allwmake > log.make 2>&1</bash>
If you want to built in parallel, run first:
<bash>export WM_NCOMPPROCS=4</bash>
</li>
</ol>

=== Install foam-extend 4.0 ===
For the most part, follow the installation instructions given at [[Installation/Linux/foam-extend-3.2/Ubuntu]], namely in section [[Installation/Linux/foam-extend-3.2/Ubuntu#Ubuntu 15.10|Ubuntu 15.10]].

The changes needed are as follows:
<ol {{NoIndentStyle}}>
<li>Do not install the following packages:
<bash>qt4-dev-tools libqt4-dev python python-dev</bash>
because we will be using the Anaconda Python 2.7 bundle, provided by [http://www.continuum.io Continuum Analytics], at the request of one of the instructors, which already provides most of these packages (Bison will have to be custom built). At the time of this writing, version Anaconda 4.0.0 was used.
</li>
<li>Use the following commands to clone the repository:
<bash>cd ~
mkdir foam
cd foam
git clone git://git.code.sf.net/p/foam-extend/foam-extend-3.2 -b nextRelease foam-extend-4.0
</bash>
</li>
<li>Next we need to do a bit of manual file editing, where we need to edit the file {{tt|foam-extend-4.0/etc/bashrc}} and find this line:
<bash># _foamSource $WM_PROJECT_DIR/etc/apps/ensight/bashrc</bash>
Then add below it the lines needed for Python and PyFoam, namely to make it look like this:
<bash># _foamSource $WM_PROJECT_DIR/etc/apps/ensight/bashrc
_foamSource $WM_PROJECT_DIR/etc/Python.sh
_foamSource $WM_PROJECT_DIR/etc/PyFoam.sh
_foamSource $WM_PROJECT_DIR/etc/Dakota.sh</bash>
</li>
<li>Then we need to create the aforementioned files, by running the following commands (keep in mind the foam-extend environment needs to already be active):
<bash>foam
echo 'export ANACONDA_PATH=$HOME/OpenFOAM/anaconda2' > etc/Python.sh
echo 'export PATH=$ANACONDA_PATH/bin:$PATH' >> etc/Python.sh
echo 'export PYTHONHOME=$ANACONDA_PATH' >> etc/Python.sh
echo 'export PYTHONPATH=$ANACONDA_PATH/lib/python2.7/site-packages' >> etc/Python.sh
echo 'export CMAKE_INCLUDE_PATH=$ANACONDA_PATH/include' >> etc/Python.sh
echo 'export CMAKE_LIBRARY_PATH=$ANACONDA_PATH/lib' >> etc/Python.sh
echo 'export QT_BIN_DIR=$ANACONDA_PATH/bin/' >> etc/Python.sh

echo 'export PYFOAM_DIR=$HOME/OpenFOAM/PyFoam' > etc/PyFoam.sh
echo 'export PYTHONPATH=$PYTHONPATH:$PYFOAM_DIR/lib/python2.7/site-packages/' >> etc/PyFoam.sh
echo 'export PATH=$PATH:$PYFOAM_DIR/bin' >> etc/PyFoam.sh

echo 'DAKOTA_INSTALL=$HOME/OpenFOAM/dakota' > etc/Dakota.sh
echo 'export PATH=$PATH:$DAKOTA_INSTALL/bin:$DAKOTA_INSTALL/test' >> etc/Dakota.sh
echo 'export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$DAKOTA_INSTALL/lib:$DAKOTA_INSTALL/bin' >> etc/Dakota.sh
echo 'unset DAKOTA_INSTALL' >> etc/Dakota.sh
</bash>
</li>
<li>Need to disable the defaults for using custom CMake and Open-MPI:
<bash>sed -i -e 's=\(export WM_THIRD_PARTY_USE_CMAKE_322\)=#\1=' etc/bashrc
sed -i -e 's=\(export WM_THIRD_PARTY_USE_OPENMPI_165\)=#\1=' etc/bashrc
</bash>
</li>
<li>The following has to the {{tt|prefs.sh}} file (you should already be inside the folder {{tt|foam-extend-4.0}} for this):
<bash>echo 'export WM_THIRD_PARTY_USE_BISON_27=1' > etc/prefs.sh
echo 'export PYFOAM_SYSTEM=1' >> etc/prefs.sh
echo 'export CMAKE_SYSTEM=1' >> etc/prefs.sh
echo 'export WM_MPLIB=SYSTEMOPENMPI' >> etc/prefs.sh

source $HOME/foam/foam-extend-4.0/etc/bashrc 
</bash>
</li>
<li>Now, to build foam-extend 4.0, we will use the following commands:
<bash># wmake is required for subsequent targets
( cd wmake/src && make )

# build ThirdParty sources
( cd $WM_THIRD_PARTY_DIR && ./AllMake.pre ) > log.ThirdParty 2>&1

# We make sure the ThirdParty packages environment variables are up-to-date
# before compiling the rest of OpenFOAM
. $WM_PROJECT_DIR/etc/bashrc

# build OpenFOAM libraries and applications
./Allwmake > log.make 2>&1
</bash>
</li>
</ol>


==== Install additional contributions for foam-extend 4.0 ====
cfMesh is already integrated into foam-extend and PyFoam is the same as the one in OpenFOAM 3.0.x.

===== Installing swak4Foam into foam-extend 4.0 =====

These steps assume you've already followed the steps at [[#Installing swak4Foam into OpenFOAM 3.0.x|Installing swak4Foam into OpenFOAM 3.0.x]]. Steps:
<ol>
<li>Now we go into the source code folder:
<bash>cd ~/OpenFOAM/contribs/swak4Foam</bash>
</li>
<li>Now we can build it:
<bash>./Allwmake > log.make 2>&1</bash>
If you want to built in parallel, run first:
<bash>export WM_NCOMPPROCS=4</bash>
</li>
<li>Clean up when completed, because we might need to rebuild it for something else:
<bash>./Allwclean</bash>
</li>
</ol>


===== Installing FSI toolkit into foam-extend 4.0 =====

The instructions for FSI toolkit will be available at [[Extend-bazaar/Toolkits/Fluid-structure_interaction]] after the time of this writing.
These steps are a rough outline, given that the provided package was still a release candidate. Steps:
<ol>
<li>Unpack the provided package {{tt|Fsi_40.tgz}} into the folder {{tt|~/foam/contribs}}, unpack and rename it accordingly:
<bash>mkdir -p ~/foam/contribs/
tar -xzf Fsi_40.tgz
</bash>
</li>
<li>Now we go into the source code folder and use the same hack as used in foam-extend's {{tt|AllMake.stage5}} for installing on the {{tt|site}} folder:
<bash>cd FluidSolidInteraction
find src -name files   | xargs -n 1 sed -i.old "s/FOAM_USER/FOAM_SITE/g"
find src -name options | xargs -n 1 sed -i.old "s/FOAM_USER/FOAM_SITE/g"
find src/{solvers,utilities} -name options | xargs -n 1 sed -i.old "s/\(\-lfluidSolidInteraction\)/-L\$(FOAM_SITE_LIBBIN) \1/"
find src/fluidSolidInteraction -type f -name "*.C" | xargs -n 1 sed -i.old 's=lduSolverPerformance::debug=blockLduMatrix::debug='
</bash>
</li>
<li>Now we can build it:
<bash>./Allwmake > log.make 2>&1</bash>
If you want to built in parallel, run first:
<bash>export WM_NCOMPPROCS=4</bash>
</li>
<li>Clean up when completed, because we might need to rebuild it in a later update (and for saving some disk space):
<bash>./Allwclean</bash>
</li>
</ol>

== Preparations before copying to final image ==
This is a cheat sheet on the commands needed for cleaning up each installation before copying to the USB-Stick:

=== Clean up OpenFOAM 3.0.x ''et al'' ===
<bash>of30x
foam3rdParty
rm -r build
rm log.*
rm *.log
</bash>

=== Clean up foam-extend 4.0 ''et al'' ===
<bash>fe40
foam
rm log.*
</bash>

=== Set-up the correct user IDs for 3rd party folders ===
This is for saving up space and time when packaging Anaconda, Salome and others:
<bash>cd ~/OpenFOAM
sudo chown -R 999:999 salome
sudo chown -R 999:999 anaconda2
sudo chown -R 999:999 dakota
sudo chown -R 999:999 HELYX-OS
sudo chown -R 999:999 PyFoam
</bash>

== Cheat sheet for copying installation to USB-Stick ==
'''Notes''':
* This is meant to be used mid-way of the instructions from sub-section [[#Transferring the local installation to the persistent partition file in the drive|Transferring the local installation to the persistent partition file in the drive]].


First of all, create our sandbox folder:
<bash>mkdir ~/sandbox</bash>

And if this isn't the first time copying, run:
<bash>sudo chown -R $USER:$USER ~/sandbox</bash>

=== Copying OpenFOAM 3.0.x ''et al'' ===
In a new terminal, run:
<bash>of30x
cd ~/OpenFOAM
TARGET=~/sandbox/OpenFOAM
mkdir $TARGET/

rsync -a site/ $TARGET/site/
rsync -a OpenFOAM-3.0.x/  $TARGET/OpenFOAM-3.0.x/
rsync -a ThirdParty-3.0.x/ $TARGET/ThirdParty-3.0.x/

cd $TARGET/OpenFOAM-3.0.x/
rm -r platforms/linux64GccDPInt32OptSYSTEMOPENMPI/
rm -r platforms/linux64GccDPInt32Opt/{src,applications}

cd $TARGET/ThirdParty-3.0.x/
rm -r CGAL-4.7/ ParaView-4.4.0/ scotch_6.0.3/
rm -r download
</bash>


=== Copying foam-extend 4.0 ''et al'' ===
In a new terminal, run:
<bash>fe40
cd ~/foam
TARGET=~/sandbox/foam
mkdir $TARGET/

rsync -a site/ $TARGET/site/
rsync -a foam-extend-4.0/ $TARGET/foam-extend-4.0/

cd $TARGET/foam-extend-4.0/
find applications/{solvers,utilities} src -name "$WM_OPTIONS" | xargs rm -r
rm -r ThirdParty/rpmBuild/{BUILD*,TGZS,RPMS,rpmDB}/* ThirdParty/rpmBuild/SOURCES/*.tar.gz
find applications src -name "*.dep" | xargs rm
rm log.*
</bash>

=== Packing the ''sandbox'' to a compressed image ===
Given that the final installation well over 3 GiB, therefore we need to save up space by relying on {{tt|squashfs}} to get the whole thing trimmed down to something more manageable (for more details, see [http://tldp.org/HOWTO/SquashFS-HOWTO/creatingandusing.html this page]).

But first, we must change the ownership of the contents:
<bash>sudo chown -R 999:999 ~/sandbox/OpenFOAM/OpenFOAM-3.0.x
sudo chown -R 999:999 ~/sandbox/OpenFOAM/ThirdParty-3.0.x
sudo chown -R 999:999 ~/sandbox/OpenFOAM/site
sudo chown -R 999:999 ~/sandbox/foam/foam-extend-4.0
sudo chown -R 999:999 ~/sandbox/foam/site
</bash>

To do so, run:
<bash>sudo mksquashfs ~/sandbox/OpenFOAM/OpenFOAM-3.0.x ~/sandbox/OpenFOAM-3.0.x.sqfs
sudo mksquashfs ~/sandbox/OpenFOAM/ThirdParty-3.0.x ~/sandbox/ThirdParty-3.0.x.sqfs
sudo mksquashfs ~/sandbox/OpenFOAM/site ~/sandbox/OpenFOAM-site-3.0.x.sqfs
sudo mksquashfs ~/OpenFOAM/anaconda2 ~/sandbox/anaconda2.sqfs
sudo mksquashfs ~/OpenFOAM/salome ~/sandbox/salome.sqfs
sudo mksquashfs ~/OpenFOAM/dakota ~/sandbox/dakota.sqfs
sudo mksquashfs ~/OpenFOAM/HELYX-OS ~/sandbox/HELYX-OS.sqfs
sudo mksquashfs ~/OpenFOAM/PyFoam ~/sandbox/PyFoam.sqfs
sudo mksquashfs ~/sandbox/foam/foam-extend-4.0 ~/sandbox/foam-extend-4.0.sqfs
sudo mksquashfs ~/sandbox/foam/site ~/sandbox/foam-extend-site-4.0.sqfs</bash>
<ul {{NoIndentStyle}}>
<li>'''Note''': If this isn't the first time you are running these commands, then run before the commands above:
<bash>sudo rm ~/sandbox/*.sqfs</bash>
</li>
</ul>

Check the final size of the files, just in case:
<bash>ls -l -h ~/sandbox/*.sqfs</bash>

=== Copying the compressed images to the USB-stick ===
It's simply this:
<bash>rsync -a -v --progress ~/sandbox/*.sqfs /media/$USER/OFW11/</bash>


=== Making sure the compressed images are properly used ===

In a new terminal, run:
<bash>cd /mnt/casper/upper/home/lubuntu/</bash>

Create the place-holder folders and symbolic links which will link into the original folders:
<bash>mkdir -p OpenFOAM/OpenFOAM-3.0.x
mkdir -p OpenFOAM/ThirdParty-3.0.x
mkdir -p OpenFOAM/site
mkdir -p OpenFOAM/anaconda2
mkdir -p OpenFOAM/salome
mkdir -p OpenFOAM/dakota
mkdir -p OpenFOAM/HELYX-OS
mkdir -p OpenFOAM/PyFoam
mkdir -p foam/foam-extend-4.0
mkdir -p foam/site
</bash>


=== Copying the folders that were not compressed ===
Simply run:
<bash>rsync -a ~/.HELYX-OS/ /mnt/casper/upper/home/lubuntu/.HELYX-OS/
</bash>

=== Making the compressed filesystems mounted at start ===

Edit the {{tt|rc.local}} file:
<bash>sudo nano /mnt/casper/upper/etc/rc.local</bash>

Place the following inside the file:
<bash>#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.

mount /cdrom/OpenFOAM-3.0.x.sqfs /home/lubuntu/OpenFOAM/OpenFOAM-3.0.x -t squashfs -o loop,ro
mount /cdrom/ThirdParty-3.0.x.sqfs /home/lubuntu/OpenFOAM/ThirdParty-3.0.x -t squashfs -o loop,ro
mount /cdrom/OpenFOAM-site-3.0.x.sqfs /home/lubuntu/OpenFOAM/site -t squashfs -o loop,ro
mount /cdrom/anaconda2.sqfs /home/lubuntu/OpenFOAM/anaconda2 -t squashfs -o loop,ro
mount /cdrom/salome.sqfs /home/lubuntu/OpenFOAM/salome -t squashfs -o loop,ro
mount /cdrom/dakota.sqfs /home/lubuntu/OpenFOAM/dakota -t squashfs -o loop,ro
mount /cdrom/HELYX-OS.sqfs /home/lubuntu/OpenFOAM/HELYX-OS -t squashfs -o loop,ro
mount /cdrom/PyFoam.sqfs /home/lubuntu/OpenFOAM/PyFoam -t squashfs -o loop,ro
mount /cdrom/foam-extend-4.0.sqfs /home/lubuntu/foam/foam-extend-4.0 -t squashfs -o loop,ro
mount /cdrom/foam-extend-site-4.0.sqfs /home/lubuntu/foam/site -t squashfs -o loop,ro

exit 0
</bash>

Save and close, by using the key combination {{tt|Ctrl+X}} and then hit the {{tt|Y}} key separately.

Finally, make the script executable:
<bash>sudo chmod +x /mnt/casper/upper/etc/rc.local</bash>


=== Update the aliases file ===
Edit the {{tt|.bash_aliases}} on the persistent mounted folder:
<bash>nano /mnt/casper/upper/home/lubuntu/.bash_aliases</bash>

And place the following code inside it:
<bash>alias of30x='source $HOME/OpenFOAM/OpenFOAM-3.0.x/etc/bashrc ; export PS1="(OF:\$WM_PROJECT_VERSION) $PS1"'
alias fe40='source $HOME/foam/foam-extend-4.0/etc/bashrc ; export PS1="(FE:\$WM_PROJECT_VERSION) $PS1"'
alias salome='/home/lubuntu/OpenFOAM/salome/appli_V7_7_1/salome'
alias helyxos='$HOME/OpenFOAM/HELYX-OS/v2.4.0/HELYX-OS.sh'

echo
echo "Whenever you start a new terminal, you can activate a specific environment, by running only one of the following commands:"
echo "  For OpenFOAM 3.0.x, run:   of30x"
echo "  For foam-extend 4.0, run:   fe40"
echo
</bash>

Save and close, by using the key combination {{tt|Ctrl+X}} and then hit the {{tt|Y}} key separately.

=== Create symbolic links for easier navigation ===
Create a few symbolic links for easier navigation:
<bash>ln -s /cdrom/Training /mnt/casper/upper/home/lubuntu/Training
ln -s /cdrom/Training /mnt/casper/upper/home/lubuntu/Desktop/Training
ln -s /cdrom /mnt/casper/upper/home/lubuntu/USB-stick-root</bash>


=== Next steps - go back to transferring from-to the USB-stick ===

Now you can continue where you left off at section [[#Transferring the local installation to the persistent partition file in the drive|Transferring the local installation to the persistent partition file in the drive]].

= Creating the USB-Stick =

Please keep in mind the description given here: [[Installation/Live Images/USB-Stick for OFW11/Reminders|Reminders]]

== Commands for formatting USB-Stick drive ==

These steps are dedicated for creating a stick drive with a partition size that should fit all 8GB USB drives, including those that ''lie'' about their total size, such as those that really only have around 7,750,000,000 bytes. The following instructions aim for a primary partition of 7,654,604,800 bytes.

'''Steps''':
<ol {{NoIndentStyle}}>
<li>Switch to root or keep in mind to do the command with {{tt|sudo}}.
</li>
<li>First of all, unmount the partition that it probably auto-mounted:
<bash>umount /dev/sdX1</bash>
</li>
<li>For creating the partition:
<bash>fdisk /dev/sdX
d  #delete
o  #create DOC partition table
c  #toggle DOS compatibility

#should show:
#  DOS Compatibility flag is set (DEPRECATED!)

n  #new partition
p  #new partition
1  #partition 1
62    #first sector
+7300M  #end sector, as size in MB

t  #change type
c  #change to W95 FAT32 (LBA)

a  #make it bootable

p  #prints current table on screen make a note of the shown values, because you're going to need the End sector number

w  #write partition table
</bash>
;Note: Make sure you have the units in sectors:
<bash>u  # use as many times as possible until it shows

#Changing display/entry units to sectors
</bash>
</li>
<li>'''Optional''' - Full clean up of partition:
<bash>dd if=/dev/zero of=/dev/sdX1 bs=512</bash>
<ol {{NoIndentStyle}}>
<li>In another terminal (also as root), tun:
<bash>while killall -USR1 dd; do sleep 30; done</bash>
</li>
<li>Then look at the previous terminal window and every 30 seconds it should update on the current write status. Given how this command works, if you have more than one {{tt|dd}} running, it will update for all running {{tt|dd}} applications.
</li>
<li>It will probably end with the message:
<bash>dd: error writing '/dev/sdX1': No space left on device</bash>
because we didn't define the total number of bytes/blocks to write.
</li>
<li>Once completed, make sure it's fully written by running:
<bash>sync</bash>
wait until it returns control back to you.
</li>
</ol>
</li>
<li>Once complete, then for formatting the partition properly:
<bash>mkfs -t vfat -n OFW11 /dev/sdX1</bash>
</li>
</ol>

== Creating the live USB ==
'''Tested with Lubuntu 15.10 x86_64.'''

Need to have {{tt|usb-creator-gtk}} installed and we will be using Lubuntu 64-bit as the basis for our stick drives. In addition, it's advisable to do these steps from a working installation of the desired Lubuntu version, even if it's within a virtual machine.

; Warning
: There is a critical bug in syslinux that is provided in Ubuntu 15.10, as [https://bugs.launchpad.net/ubuntu/+source/usb-creator/+bug/1499746 reported here]. The work around is to run the following commands:
<bash>cd
wget http://launchpadlibrarian.net/200593067/syslinux_6.03+dfsg-5ubuntu1_amd64.deb
wget http://launchpadlibrarian.net/200593072/syslinux-common_6.03+dfsg-5ubuntu1_all.deb
sudo dpkg -i syslinux-common_6.03+dfsg-5ubuntu1_all.deb syslinux_6.03+dfsg-5ubuntu1_amd64.deb
</bash>
: The Deb packages came from [https://launchpad.net/ubuntu/wily/amd64/syslinux/3:6.03+dfsg-5ubuntu1 here] and [https://launchpad.net/ubuntu/vivid/amd64/syslinux-common/3:6.03+dfsg-5ubuntu1 here].
: The following hack is optional, but advisable, if you don't want to have to do the last fix on the steps below every time you need to do another live USB: <bash>sudo sed -i -e 's=\(if len(target_mounts) > 0:\)=if False: #\1=' /usr/share/usb-creator/usb-creator-helper</bash> As this will disable the ''auto-mount-and-get-damaged-syslinux-from-casper''.


'''Steps''':
<ol {{NoIndentStyle}}>
<li>As root (or with {{tt|sudo}}), run:
<bash>usb-creator-gtk</bash>
</li>
<li>Select the ISO for the Lubuntu Live CD/DVD.</li>
<li>Select the stick drive you want as the target for the Live USB.
* '''Note''': Do not use the erase function, otherwise you will loose the correct booting mechanism that was created with {{tt|fdisk}} and {{tt|mkfs}}.
</li>
<li>Select the largest possible "Stored in reserved extra space", at least taking into account how much will be left over for the ''read-anywhere'' files, such as presentations and VM installers.
* For example:
** 690 MiB for the cloned Live CD
** 1.0 GiB for the ''read-anywhere'' data.
** 7.1 GiB - 1.0 GiB - 690 MiB = 5.42 GiB = 5556.4 MiB... which is larger than 4GiB, the file size limit for FAT32 partitions.
</li>
</li>Finally, click on the "Make Startup Disk" button and wait a while for it to run...
</li>
</li>When it's finally completed, we need to do some additional fixing:
<ol {{NoIndentStyle}}>
<li>Unmount the stick:
<bash>umount /dev/sdX1</bash>
</li>
<li>If you didn't do the hack for {{tt|/usr/share/usb-creator/usb-creator-helper}}, then you'll need to redeploy the {{tt|syslinux}} and MBR:
<bash>sudo syslinux -f /dev/sdX1
sudo dd if=/usr/lib/syslinux/mbr/mbr.bin of=/dev/sdX bs=446 count=1 conv=sync
sudo sync
</bash>
</li>
<li>Now interactively mount the USB-stick again and then you can finally unmount+eject interactively.
</li>
</ol>
</li>
</ol>


=== First boot up of the new USB-Stick ===

After booting up the USB-Stick in a real machine or virtual machine, install the necessary packages, with the following commands:
<bash>sudo apt-get update
sudo apt-get install virtualbox-guest-utils virtualbox-guest-dkms</bash>
which will install the necessary guest additions for Virtualbox to be usable in case the USB-stick doesn't boot directly in the real machine.


Then continue to install the necessary packages for OpenFOAM 3.0.x and foam-extend 4.0:
<bash>sudo apt-get install git-core gitk build-essential cmake flex zlib1g-dev gnuplot gnuplot-x11 \
libreadline-dev libncurses-dev libxt-dev libopenmpi-dev openmpi-bin libboost-system-dev libboost-thread-dev libgmp-dev \
libmpfr-dev binutils-dev libiberty-dev rpm mercurial graphviz</bash>

As well as the requested software and necessary dependencies for them:
<bash>sudo apt-get install kompare emacs24 imagemagick openscad libmotif4 liblapack3</bash>

Now proceed with cleaning up the downloaded Deb files:
<bash>sudo apt-get clean
sudo apt-get autoclean
</bash>


Then change the desktop image, by right clicking on the desktop and choosing {{tt|Desktop Preferences}}. Make sure you download the image from the Workshop website and place it in the folder {{tt|/home/lubuntu/Images}}.


[[Image:OFW11_-_Add_to_launch_bar.png|thumb|600px|right|Steps for adding LXTerminal to the short-cut bar]]

For adding a link to the LX terminal (as shown in the image to the right):
# Right click on the tool-bar at bottom and choose {{tt|Add / Remove Panel Items}}.
# Click on the first occurrence of {{tt|Application Launch Bar}}.
# Click on the button {{tt|Preferences}}.
# In the new window {{tt|Application Launch Bar}}, in the {{tt|Installed Applications}}, browse into {{tt|System Tools}} and pick {{tt|LXTerminal}}.
# Click on the {{tt|+ Add}} button.
# Finally, click on the {{tt|Close}} buttons for each one of the opened windows.


Similarly to the previous steps, we need to add the {{tt|Keyboard Layout Handler}} to the main panel:
# Right click on the tool-bar at bottom and choose {{tt|Add / Remove Panel Items}}.
# Click on the button {{tt|+ Add}}.
# In the new window, look for and select {{tt|Keyboard Layout Handler}} and click on the {{tt|+ Add}} button.
# On the previous window, click on the {{tt|Keyboard Layout Handler}} at the bottom of the list.
# Click on the {{tt|Up}} button twice, so that it is placed above of the {{tt|Digital Clock}}.
# Finally, click on the {{tt|Close}} button.


You can also add the {{tt|LXTerminal}} icon to the desktop environment, by right clicking in the {{tt|System Tools -> LXTerminal}} icon at the LXDE main menu (''start menu'').

Finally, we need to add the standard {{tt|lubuntu}} user to the group for virtual box share folders, to ensure that shared folders can work:
<bash>sudo usermod -aG vboxsf lubuntu</bash>

<br>

=== Transferring the local installation to the persistent partition file in the drive ===

'''Steps''':
<ol {{NoIndentStyle}}>
<li>Mount the stick with the interactive mount that Lubuntu has got from the file manager.</li>
<li>Copy the image file to the home folder. This file will contain the persistent installation on the USB-stick, which is why it's best to first copy to your system, so that's quicker in storing several thousands of files inside it:
<bash>rsync -a -v --progress /media/$USER/OFW11/casper-rw ~/sandbox/casper-rw</bash>
</li>
<li>As root (or with {{tt|sudo}}), run:
<bash>mkdir /mnt/casper
mount -t auto ~/sandbox/casper-rw /mnt/casper/ -o loop
</bash>
</li>
<li>The ''persistent'' home folder will now be located at {{tt|/mnt/casper/upper/home/lubuntu/}}:
<bash>cd /mnt/casper/upper/home/lubuntu/</bash>
If it doesn't exist, then create it and change ownership:
<bash>mkdir -p /mnt/casper/upper/home/lubuntu/
chown -R $USER:$USER /mnt/casper/upper/home/lubuntu/</bash>
</li>
<li>Copy the files you have on the sandbox folder into the designated folder, as explained in section [[#Cheat sheet for copying installation to USB-Stick|Cheat sheet for copying installation to USB-Stick]].</li>
<li>When you're done copying files to the image, make sure the ''persistent'' home folder has the correct owner permissions:
<bash>chown -R 999:999 /mnt/casper/upper/home/lubuntu/</bash>
</li>
<li>Then unmount it:
<bash>umount /mnt/casper</bash>
</li>
<li>Then copy the {{tt|casper-rw}} file back to the USB-stick:
<bash>rm /media/$USER/OFW11/casper-rw
rsync -a -v --progress ~/sandbox/casper-rw /media/$USER/OFW11/</bash>
</li>
<li>Finally, unmount the stick:
<bash>umount /dev/sdX1</bash>
</li>
</ol>

=== Creating the bootable ISO for the virtual machine ===

References:
* http://www.syslinux.org/wiki/index.php/ISOLINUX

<ol {{NoIndentStyle}}>
<li>Install the package {{tt|genisoimage}} in your Lubuntu development system:
<bash>sudo apt-get install genisoimage</bash>
<li>Mount the USB-stick.
</li>
<li>Create a folder where you will place all files that will go into the ISO file. For example:
<bash>mkdir ISOroot</bash>
</li>
<li>Copy the folders {{tt|syslinux}} and {{tt|install}} from the USB-stick, into the folder {{tt|ISOroot}}, so that you get this folder structure:
<bash>ISOroot
|-- install
|-- syslinux
</bash>
</li>
<li>Copy the boot files into the folder {{tt|syslinux}}, for example:
<bash>cp /media/$USER/OFW11/casper/{vmlinuz.efi,initrd.lz} ISOroot/syslinux/</bash>
</li>
<li>Edit the file {{tt|ISOroot/syslinux/txt.cfg}} and change it to this:
<bash>default live
label live
menu label ^Try Lubuntu without installing
kernel /syslinux/vmlinuz.efi
append noprompt cdrom-detect/try-usb=true persistent file=/cdrom/preseed/lubuntu.seed boot=casper initrd=/syslinux/initrd.lz quiet splash ---
label live-install
menu label ^Install Lubuntu
kernel /syslinux/vmlinuz.efi
append noprompt cdrom-detect/try-usb=true persistent file=/cdrom/preseed/lubuntu.seed boot=casper only-ubiquity initrd=/syslinux/initrd.lz quiet splash ---
label check
menu label ^Check disc for defects
kernel /syslinux/vmlinuz.efi
append noprompt boot=casper integrity-check initrd=/syslinux/initrd.lz quiet splash ---
label memtest
menu label Test ^memory
kernel /install/mt86plus
label hd
menu label ^Boot from first hard disk
localboot 0x80
</bash>
Essentially you will be changing the paths that state {{tt|/casper/}} to {{tt|/syslinux/}}.
</li>
<li>Create the ISO file by running the following command from the parent folder where {{tt|ISOroot}} is located:
<bash>mkisofs -o VMbootUSB.iso    -b syslinux/isolinux.bin -c syslinux/boot.cat    -no-emul-boot -boot-load-size 4 -boot-info-table    ISOroot</bash>
</li>
<li>The final image file {{tt|VMbootUSB.iso}} is what we will need to boot the USB-stick inside the virtual machine.</li>
</ol>


=== Creating the virtual machine in Virtualbox ===

Keep in mind that these steps are only needed for creating the virtual machine to be placed inside the USB-stick. Nonetheless, it might be useful in case the exported OVA file is incompatible.

'''References''':
* http://askubuntu.com/a/25600

'''Side notes''':
<ul {{NoIndentStyle}}>
<li>On Ubuntu, had to install the necessary packages for getting the USB2/3 drivers for Virtualbox on the host side (the real machine):
<bash>sudo apt-get install virtualbox-ext-pack</bash>
And then run the following command for adding my user to the group {{tt|vboxusers}}:
<bash>sudo usermod -aG vboxusers $USER</bash>
Then I had to log out and then log back in, otherwise it's not possible to use a real USB drive in a virtual machine within Virtualbox.
</li>
</ul>

'''Steps''':
<ol>
<li>Simply create a new Virtual Machine in Virtualbox, meant for a Ubuntu 64-bit machine and without any disks, because we will boot straight from the USB drive.
</li>
<li>After the virtual machine is created, edit its settings and:
<ol>
<li>increase the RAM to at least 2048MB;</li>
<li>change from 1 to 2 virtual cores;</li>
<li>choose for the optical drive to use the {{tt|VMbootUSB.iso}};</li>
<li>probably best to turn off audio capabilities;</li>
<li>in the USB section, choose USB 3.0 or 2.0 controller, depending on what kind of USB-stick you're using;</li>
<li>still in the USB section, click on the button that adds a new USB device and choose your USB-stick.</li>
</li>
</ol>
<li>Boot up the VM and test it.
</li>
<li>If it works fine, do a standard shutdown within the virtual machine.
</li>
<li>Then use on the main menu for the Virtualbox the item {{tt|File -> Export Appliance...}} to export the virtual machine to a settings file to be placed inside the USB-stick, preferably with the file name  {{tt|OFW11USBVM.ova}}.
</li>
<li>Best to place both the {{tt|OFW11USBVM.ova}} and {{tt|VMbootUSB.iso}} files inside the folder {{tt|VM}} in the real USB-stick partition (i.e. not inside the booted up Live Lubuntu).
</li>
</ol>


=== Adding auxiliary third-party software ===
The objective is to make the USB-stick as self-sufficient as possible, at least on Windows and Mac OS X, given that it seems redundant to install OpenFOAM inside a virtual machine within a Linux Distribution, given that OpenFOAM and foam-extend can be built without any problems on most Linux Distributions.

# First create the folder {{tt|ThirdParty}} in main real partition of the USB-disk.
# Place the following files inside the new folder:
## VirtualBox installer for Windows (downloadable from [https://www.virtualbox.org/wiki/Downloads here]).
## VirtualBox installer for Mac OS X (downloadable from [https://www.virtualbox.org/wiki/Downloads here]).
## Browse and save the VitualBox User Guide: [https://www.virtualbox.org/wiki/Documentation VirtualBox.com -> Documentation -> PDF version] - Make sure to save the PDF file as {{tt|VirtualBox-UserManual.pdf}}.
## Create the sub-folder {{tt|VirtualBoxExtensionPack}} and add the following files:
### The VirtualBox Oracle VM VirtualBox Extension Pack file, which has the file extension {{tt|.vbox-extpack}}.
### Browse and save the PUEL license page: [https://www.virtualbox.org/wiki/VirtualBox_PUEL VirtualBox Personal Use and Evaluation License (PUEL)]
### Browse and save the FAQ about licensing: [https://www.virtualbox.org/wiki/Licensing_FAQ Licensing: Frequently Asked Questions]

<br>

== Cloning the original stick to a new image ==

'''Steps''':
<ol {{NoIndentStyle}}>
<li>Make sure you don't have the stick mounted! Example to umount:
<bash>umount /dev/sdX1</bash>
</li>
<li>As root (or with {{tt|sudo}}), run:
<bash>dd if=/dev/sdX of=OFW11-2016_v5.img bs=512 count=14950463</bash>
* The value "14950463" is the End sector count 14950462 plus 1.
* 14950463 sector * 512 B/sector = 7654636544 B = 7654636544 ~= 7300 MiB

In the meantime, while it's copying:
# In another terminal (also as root), run: <bash>while killall -USR1 dd; do sleep 30; done</bash>
# Then look at the previous terminal window and every 30 seconds it should update on the current write status. Given how this command works, if you have more than one {{tt|dd}} running, it will update for all running {{tt|dd}} applications.
</li>
<li>When it's done cloning, make sure the file system is synced:
<bash>sync</bash>
wait until it returns control back to you.
</li>
<li>Now you can mount the stick again, if you want. Or simply eject it.</li>
</ol>

<br>

= Upgrading an existing USB-stick =
Thanks to how the disk set-up is organized, we can ''easily'' do relative updates to the USB stick contents by updating only the packages we need, without the need to recreating the whole disk. The following two sections address the creation and deployment of an update.

== Creating an upgrade iteration package ==
One example is the iteration done after image v4 was already deployed into the USB sticks and we had additional updates to the USB stick. The changes made were in the {{tt|Training}} folder and the squash image files for foam-extend 4.0. The steps taken:

# We have 3 folders:
#* {{tt|USB-stick-structure_v4}} - which has the folders {{tt|ThirdParty}} and {{tt|Training}} from the v4 image.
#* {{tt|USB-stick-structure_v5}} - which has the folders {{tt|ThirdParty}} and {{tt|Training}} meant for the v5 image.
#* {{tt|upgrade_USB_v4_to_v5}} - has the new squash files {{tt|foam-extend-4.0.sqfs}} and {{tt|foam-extend-site-4.0.sqfs}} for the v5 image and it will have the updated training material as well.
# To get a the updated training files into the difference file, we used the following command, executed at the base folder where all 3 sub-folders are present: <bash>rsync -crv --progress  USB-stick-structure_v5/ --compare-dest=$PWD/USB-stick-structure_v4/ upgrade_USB_v4_to_v5/</bash>
# To remove the empty folders that were created with the previous command: <bash>find upgrade_USB_v4_to_v5/ -type d -empty -delete</bash>
# Finally, create a nice package that can be sent to the team handling the deployments to the USB sticks: <bash>7z a upgrade_USB_v4_to_v5.zip upgrade_USB_v4_to_v5</bash>

== Deploying an upgrade iteration package ==
On the deployment side, the steps should be fairly simple:
# Download the upgrade package file {{tt|upgrade_USB_v4_to_v5.zip}}, from the link provided at the [[Installation/Live_Images/USB-Stick_for_OFW11/Download#Upgrade package v4 to v5|Download page, section Upgrade package v4 to v5]].
# Place it in a convenient location, such as the {{tt|Desktop}} folder or {{tt|Download}} folder.
# Unzip it, either interactively or by using the following command line: <bash>unzip upgrade_USB_v4_to_v5.zip</bash>
# Go into the unpacked folder: <bash>cd upgrade_USB_v4_to_v5</bash>
# Now, for each stick, we can either use drag and drop or we can use a few commands to copy the files to each USB stick, namely:
## The next step will use {{tt|rsync}}, which will make intermediate copies, for which the USB-stick will unlikely have enough space. Therefore, we must first delete the squash files that will be updated, e.g.: <bash>rm /media/$USER/OFW11/{foam-extend-4.0.sqfs,foam-extend-site-4.0.sqfs}</bash>
## Next, we can copy the files: <bash>rsync -av --progress ./  /media/$USER/OFW11/</bash>
## Finally, let's use {{tt|sync}} to ensure that the USB-stick is fully updated: <bash>sudo sync</bash>
## Now you can safely eject the USB-stick (interactively, no command available for this one).

== Deploying within the virtual machine ==
This is meant to be done within the virtual machine appliance, not exactly meant to be done with the virtualization of the physical USB-stick, but it can also be done like that. The idea is that the package has to either be brought in via SSH or downloaded directly from within the virtual machine, because the likelihood of this working with ''drag and drop'' is very small.

Steps:
# Download the upgrade package file {{tt|upgrade_USB_v4_to_v5.zip}}, from the link provided at the [[Installation/Live_Images/USB-Stick_for_OFW11/Download#Upgrade package v4 to v5|Download page, section Upgrade package v4 to v5]].
# Place it in a convenient location, such as the {{tt|Desktop}} folder or {{tt|Download}} folder.
# Unzip it, either interactively or by using the following command line: <bash>unzip upgrade_USB_v4_to_v5.zip</bash>
# Go into the unpacked folder: <bash>cd upgrade_USB_v4_to_v5</bash>
# Next we need to unmount the two squash images: <bash>sudo umount /home/lubuntu/foam/foam-extend-4.0 ; sudo umount /home/lubuntu/foam/site</bash>
# The next step will use {{tt|rsync}}, which will make intermediate copies, for which the USB-stick will unlikely have enough space. Therefore, we must first delete the squash files that will be updated: <bash>sudo rm /cdrom/{foam-extend-4.0.sqfs,foam-extend-site-4.0.sqfs}</bash>
# Next, we can copy the files: <bash>sudo rsync -av --progress ./  /cdrom/</bash>
# Now we can mount again the two squash images: 
#* The main image: <bash>sudo mount /cdrom/foam-extend-4.0.sqfs /home/lubuntu/foam/foam-extend-4.0 -t squashfs -o loop,ro</bash>
#* The site image: <bash>sudo mount /cdrom/foam-extend-site-4.0.sqfs /home/lubuntu/foam/site -t squashfs -o loop,ro</bash>