Posts Tagged build

Building and Installing OpenMD on Windows

Sep 19

Posted by Cody Drisko in Examples | 1 Comment

Now that Microsoft is embracing open source software, and making the Ubuntu subsystem available, it is very easy to install OpenMD on your Windows computer.

Installing Ubuntu for Windows 10

Make sure your Windows 10 system is up-to-date. You must have a 64-bit Windows 10 Operating System version 16237.0 or higher, which you can see in Settings→System→About.
Run the following code as an administrator in PowerShell:
```
Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux
```
(Note that if you do not run the command as an administrator you will get an error trying to run this.)
Restart your computer when prompted.
Download the Ubuntu app from the Windows Store.
Open the Ubuntu app and create your new UNIX username and password. (Note that it does not have to match your Windows username and/or password.)

Update Ubuntu with the following commands:

sudo apt-get update && sudo apt-get upgrade -y && sudo apt-get dist-upgrade -y && sudo apt-get autoremove -y

From here you can proceed with installing the OpenMD prerequisites for a Linux machine. After these prerequisites are installed, you can build and install OpenMD normally.

Running Graphical Applications with X Server on Ubuntu for Windows 10

If you want to use a graphical application like jmol or xmgrace to interact with the data, you’re going to need a X Server. Without it, when you call one of these programs you will get the following error:

Can't open display
Failed initializing GUI, exiting

To run these graphical applications we need to install the X server and configure bash to use it.

The X server we recommend and have tested is VcXsrv – a fully open source and up-to-date native X server.
Download this application and proceed with the installation.
Once this is installed, open the application and proceed with the default selections for the display settings. (Note that other settings may work well too, but the default settings are the only ones we’ve tested)
The X icon will show up on the bottom of your screen in the system tray.

To configure bash run the following command:

echo "export DISPLAY=localhost:0.0" >> ~/.bashrc

Either restart the Ubuntu app or source the file with the following:
```
. ~/.bashrc
```
If you want to verify it worked download the x11 apps and run xeyes:
```
sudo apt-get install x11-apps
xeyes
```

Tags: build, configuration, Installation, prerequisites

Building and Installing OpenMD 3.0

Oct 7

Posted by Dan Gezelter in Examples | 5 Comments

OpenMD is written in C++. Compiling is the process of turning this C++ code into instructions that the computer’s processor can understand.

We’re going to assume here that you have already built and installed all of the prerequisites. If you haven’t done that, go install all of the required stuff and come back. We’ll wait.

Now that you’ve got all the stuff you need, you are ready to compile OpenMD on any unix-like operating system (including Mac OS). We’re going to assume that you know how to use a command line interface and are comfortable with basic unix commands. The commands below are written assuming you are using bash (or the Bourne-Again SHell). Setting environment variables in csh or tcsh is just a little bit different.

Basic build procedure

The most important thing to do is to download the latest release of the OpenMD code:

curl -o OpenMD-3.0.tar.gz http://openmd.org/releases/OpenMD-3.0.tar.gz

The recommended way to build OpenMD is to use a separate source and build directory; for example, OpenMD-3.0 and build. The first step is to create these directories:

tar zxf OpenMD-3.0.tar.gz
mkdir build

Now you need to run cmake to configure the build. The following will configure the build to use all of the default options:

cd build
cmake ../OpenMD-3.0

If you need to specify a particular compiler, you can do that with environment variables before the cmake line:

export CXX=/opt/local/bin/mpicxx
cmake ../OpenMD-3.0

If you need to specify an option, use the -D switch to cmake. For example, the following line sets the value of CMAKE_INSTALL_PREFIX and CMAKE_BUILD_TYPE:

cmake ../OpenMD-3.0 -DCMAKE_INSTALL_PREFIX=~/Tools -DCMAKE_BUILD_TYPE=DEBUG

We will discuss various possible options later.

At this point, it would be a good idea to compile OpenMD:

make

Have a coffee while the magic happens. If you have a multi-processor machine and would prefer an espresso, try a parallel build instead:

make -j 4

And finally, as root (or using sudo) you should install it:

umask 0022; sudo make install

Local build

With the right sort of environment variable magic (see below), you can actually use OpenMD straight from the build folder. But life is a bit easier if you install it somewhere, either system-wide or locally.

By default, OpenMD is installed in /usr/local on a Unix-like system. This requires root access (or sudo). Even if you do have root access, you may not want to overwrite an existing installation or you may want to avoid conflicts with a version of OpenMD installed by your package manager.

The solution to all of these problems is to do a local install into a directory somewhere in your home folder. An additional advantage of a local install is that if you ever want to uninstall it, all you need to do is delete the installation directory; removing the files from a global install is more work.

To configure cmake to install into ~/Tools/openmd-install, for example, you would do the following:

cmake ../OpenMD-3.0 -DCMAKE_INSTALL_PREFIX=~/Tools/openmd-install

Then you can run make and make install without needing root access:

make && make install

Troubleshooting build problems

CMake caches some variables from run-to-run. How can I wipe the cache to start from scratch?
Delete CMakeCache.txt in the build directory. This is also a very useful file to look into if you have any problems.
What environment variables affect how OpenMD finds force field and data files?
FORCE_PARAM_PATH – This environment variable is used by OpenMD to find the location of the data files used for force fields and atom sizes, etc. If you get errors about not being able to find some .txt files, then you should set this to the name of the folder containing files such as Amber.frc and element.txt. These are typically installed to /usr/local/openmd/forceFields
CMake honors user umask settings for creating directories. To get predictable results please set umask explicitly before running the make install command.

Advanced build options

How do I do a debug build?
-DCMAKE_BUILD_TYPE=Debug does a debug build (gcc -g).
To revert to a regular build use -DCMAKE_BUILD_TYPE=Release.
How do I see what commands cmake is using to build?
Run Make as follows:

VERBOSE=1 make
How do I build the Doxygen documentation?If CMake found the “doxygen” program in your PATH, an optional build target called “doc” is created. If the Doxygen executable was not on the PATH, you will need to specify its location with -DDOXYGEN_EXECUTABLE=wherever. To build the documentation, type:
make doc

Tags: build, compiling, configuration, Installation

Installing OpenMD prerequisites

Jan 13

Posted by Dan Gezelter in Examples | 7 Comments

To get OpenMD up and running, there are some required (and optional) software packages you should have to create a functioning build environment:

On a Mac (macOS Mojave or later)

Install Xcode
Install homebrew
Open a Terminal window, and update your homebrew packages to the latest updates:
```
brew update
brew upgrade
```
(Note that the brew command is usually located in /usr/local/bin)
Install the relevant prerequisite packages:
```
brew install cmake open-babel qhull zlib fftw open-mpi numpy scipy
```
You can go have lunch or coffee while these are being built and installed.
Install some optional software if you want to use and interact with the data produced by OpenMD:
```
brew install grace brewsci/bio/jmol 
```
Install some optional software if you want to develop or add to OpenMD:
```
brew install antlr@2 gengetopt doxygen
```

On Linux

Use yum, apt-get, or the package manager in your favorite distribution to install the following packages and all of their prerequisites. Package names depend on the Linux variant, so in Fedora (and Red Hat) the package names are:
```
fftw
fftw-devel
cmake
openbabel
openbabel-devel
openmpi3
openmpi3-devel
python3-numpy
python3-scipy
qhull
qhull-devel
zlib
zlib-devel
```
In Ubuntu (and probably other Debian-based versions), the packages are:
```
libfftw3-3
libfftw3-dev
cmake
openbabel
libopenbabel-dev
openmpi-bin
libopenmpi-dev
python3-numpy
python3-scipy
qhull-bin
libqhull-dev
minizip
zlib1g-dev
```
Install some optional packages if you want to use and interact with the data produced by OpenMD:
```
jmol
grace
```
Install some optional software if you want to develop or add to OpenMD:
```
antlr
gengetopt
doxygen
```

On Windows

Building and installing OpenMD on Windows is now quite straightforward. All it takes is the installation of an Ubuntu subsystem on your Windows Machine. Once you have this, all the commands for the Linux build are exactly the same. Alternatively, CMake will generate a (mostly) working build of OpenMD 2.6 in Windows with the Visual Studio 2019 C++ compiler, but we don’t routinely test the code in this configuration.

Follow the steps to building and installing OpenMD on Windows. (Note that if you’re planning on using visualization software that relies on an X Server, you’ll need to follow the Windows-specific instructions for that as well.)
Refer to the list of packages for linux above to get the correct packages installed.

Building from source

If you are building all of the prerequisites from source, you’ll need (in addition to a C++ compiler):

CMake – This cross-platform build system is required for building OpenMD. You need to install CMake 2.8.11 or newer. This is available as a binary package from the KitWare website; alternatively, it may be available through your package manager (on Linux). If necessary, you can also compile it yourself from the source code.
python – An interpreted scripting language that some of the OpenMD utilities use to parse and process data files.
You probably already have this.
Open MPI – A very good implementation of the MPI-2 specification for parallel computing.
qhull – A computational geometry toolbox for computing convex hulls and Delaunay triangulations. qhull is required for the LangevinHull integrator and for any of the tools that compute the Hull atoms or hull volumes of nanoparticles and clusters.
openbabel – a chemical toolbox for converting between different data formats. This is required for building the atom2omd program which helps prepare initial “metadata” or omd files for simulations.
fftw – a library for computing discrete Fourier transforms. This is required for surface undulation spectra (Hxy in staticProps). Get version 3.
zlib – required to support reading compressed trajectory files.

You’ll also likely want to download and compile the following useful tools for interacting with the data:

If you are going to be extending or developing OpenMD, you’ll need the following tool:

antlr – our tool for parsing meta-data files. You’ll want version 2.7, not 3.
gengetopt – a tool to generate C code to parse the command line arguments argc and argv that are part of every C or C++ program