Clarifying License Setup for Siemens NX 8.5 Installation (University of Maryland)

The University of Maryland was recently given a $750 million software grant for the popular Siemens Product Lifecycle Management (PLM) software. After reading the article, I decided to install the software.

My experience should primarily help UMD students (who may legally download the software after logging in to the UMD portal), though I found a version of my solution online.

My installation of Siemens NX occurred at my home on my Windows 7 64-bit OS. The installation was straightforward, but I received a licensing error when attempting to run NX 8.5.

The instructions provided by UMD, titled “Siemens NX Windows Requirements and Instructions,” tell users to provide license information given in the document. Then, users are instructed to run the licensing options tool, selected through the path: “Start -> Siemens NX 8.5-> NX Licensing Tools->Licensing Options,” except that my path ended with “License Options.” Same difference.

The next step is to “add both the listed bundles.” I could not find the bundles that were listed in the document. I did, however, find a solution at a Rensselaer Polytechnic Institute website.

Scroll down to Common Errors with NX 8.0, to error 11), which states “When I open License Options, there is no bundle listed.” They state that there are two options for why this is happening:

  • a) ” You may have lost connection to the RPI network, otherwise see step B.”
  • b) “To fix, right select on My Computer > Properties > Advanced System Settings. Select Advanced > Environment Variables. Under System Variables, click New. For Variable name type UGS_LICENSE_BUNDLE. For the Variable value type: ACD30; ACD31”

I assumed my network was working fine, and I followed the instructions for b). Using the comparable bundles listed in the “Siemens NX Windows Requirements and Instructions” (which I will not list here for legal reasons)  I was able to get NX to start successfully. I did not have to restart after adding my environment variables.

Thanks to RPI for documenting this issue. Hopefully UMD includes an update to their instructions. Otherwise, I hope that this post helps UMD students.


Improving Fortran Do Loop Performance by 25%


Here’s a way to make sure you’re optimizing the writing of your code with an example in Fortran. It’s a neat, non-obvious trick to an engineer, but may be more obvious to a computer scientist. It involves the writing of a do loop where you are updating your value for an array, and instead of copying that array into a temporary variable, you simply use the programming logic to continue to use that information (location in memory) during every other time step. I was able to get 25% better performance for this simple change (and it scales). Not clear yet? Let me show you.

I’m a mediocre Fortran programmer but I’m learning new tricks with practice, challenges, and going to professor office hours. Taking Scientific Computing and High Performance Computing Systems right now is really increasing the strength of my programming skills. I hope to be an intermediate Fortran programmer by the end of the semester. Below is a sample from a code I wrote for a recent class project. The goal of the project was not to write a sequential version, so I feel comfortable posting a piece of the serial version.


The user is stepping in time from igen to gmax, calculating the neighbor value (‘naybs’) of a cell in the array ‘pop.’ Then, it updates the value of the cell in the array ‘pop’ for the next time step based on the neighbor values. But it does this update in ‘buffer,’ unnecessarily copying the data back to the array ‘pop.’ In this way, the loop proceeds without conflict. This works, but you may be sacrificing performance without even realizing it. I wrote EXAMPLE 1 below and then my instructor said “BUT WHY NOT DO IT BETTER?” and I went back to my computer and coded EXAMPLE 2.

EXAMPLE 1: Original Code

  do igen = 1, gmax
    naybs = 0
    buffer = 0
! This loop finds neighbor values
    do j = 2, y_limit + 1
      do i = 2, x_limit +1
        naybs(i,j) = pop(i-1,j-1) + pop(i,j-1) + pop(i+1,j-1)+ &
                     pop(i-1,j  )              + pop(i+1,j  )+ &
                     pop(i-1,j+1) + pop(i,j+1) + pop(i+1,j+1)
        ! Birth
        if (pop(i,j)==0 .and. naybs(i,j)==3) then
        ! Survival
        else if (pop(i,j)==1 .and. &
            (naybs(i,j)==2 .or. naybs(i,j)==3)) then
        ! Death
        end if
        pop(i,j) = buffer(i,j)
      end do
    end do
  end do

EXAMPLE 2: Improved Code

do igen = 1, gmax
  naybs = 0

  if (mod(igen,2)==1) then

! This loop finds neighbor values
  do j = 2, y_limit + 1
    do i = 2, x_limit +1
      naybs(i,j) = pop(i-1,j-1) + pop(i,j-1) + pop(i+1,j-1)+ &
                   pop(i-1,j  )              + pop(i+1,j  )+ &
                   pop(i-1,j+1) + pop(i,j+1) + pop(i+1,j+1)
      ! Birth
      if (pop(i,j)==0 .and. naybs(i,j)==3) then
      ! Survival
      else if (pop(i,j)==1 .and. &
          (naybs(i,j)==2 .or. naybs(i,j)==3)) then
      ! Death
      end if
    end do
  end do

  else if (mod(igen,2)==0) then

! This loop finds neighbor values
  do j = 2, y_limit + 1
    do i = 2, x_limit +1
      naybs(i,j)=buffer(i-1,j-1)+buffer(i,j-1)+buffer(i+1,j-1)+ &
                 buffer(i-1,j  )              +buffer(i+1,j  )+ &
      ! Birth
      if (buffer(i,j)==0 .and. naybs(i,j)==3) then
      ! Survival
      else if (buffer(i,j)==1 .and. &
          (naybs(i,j)==2 .or. naybs(i,j)==3)) then
      ! Death
      end if
    end do
  end do
  end if
end do

I will say that you do have to write more code, but if that’s your hang-up, then you might not be very interested in performance in the first place.

More importantly, note the logic here. What I’m doing is identifying which time step is odd or even (by computing the mod of each time step), and then based on that result, I will update the next time step with a value from another grid. As far as I know, this can be done more elegantly in C by switching pointers. I don’t even know how to yet use pointers effectively in Fortran, so that might be possible here too. That would then give you the performance you desire, and the brevity that everyone likes. This result did increase my performance by 25%, which is dramatic if you are in the scientific computing world.

I note that this may be obvious to others, and they might even think that I made it harder on myself in the first place by doing something silly (which I did), but remember that I was taught this by multiple people, multiple times. Once I started to get an understanding of how data is held in memory, I started to make more advanced strides in programming. Hope this helps!

Timing an OpenMP run using Fortran

What to expect:

  • How you can time a run in Fortran by calling cpu_time
  • How you can time a run in Fortran (or C) using OpenMP using omp_get_wtime()


I am using the Intel Fortran Compiler, ifort, called Intel Fortran Composer XE 2011 for Linux. It’s version 11.1. You can find the compiler here, as part of Intel’s Non-Commercial Software Downloads. You can check the version of your ifort by supplying the command

$ ifort -v

The ifort compiler has OpenMP capability built in. OpenMP has a built-in ability to time the run that you are executing. One way that we can time the run natively in Fortran will also be shown.

At the beginning of my code, it looks like the following:

Example Code

program goodtimes

c$     use omp_lib
       use your_modules

       implicit none

       double precision :: fstart, fend
       [Declare other variables]
       double precision :: ostart,oend

c      Fortran timing
       call cpu_time (fstart)

c      OpenMP timing
c$     ostart = omp_get_wtime()

c      Start of your meaningful code

c      Middle of your meaningful code

c      End of your meaningful code

c      End Fortran timing
       call cpu_time (fend)

c      End OpenMP timing
c$     oend = omp_get_wtime()

       write(*,*) 'Fortran CPU time elapsed', fend-fstart
c$     write(*,*) 'OpenMP Walltime elapsed', oend-ostart

end program

There are a few things to mention in the loosely-written code above. I wrote it a little Fortran 77-esque, where I started writing in the 7th column, and the OpenMP pragma is ‘c$’, ‘!$’, or ‘*$’. I used ‘c$’ above. In later versions of Fortran, use ‘!$’.

Notice that you must use the ‘omp_lib’ module in order to access the built-in ‘omp_get_wtime’. Otherwise, you will get an error. I strongly recommend making your start and end variables double precision. It doesn’t matter how you specify them as double precision, and I don’t necessarily recommend the way I did it above, but I just want to make it clear that you will have a better time with a double precision specification.

Note that cpu_time yields information about the CPU time (how long the CPU was working on your problem) and omp_get_wtime yields the wall clock time, such as the time that would have elapsed if you were timing the run from beginning to end with a very precise clock. I had a few runs for my application that showed the CPU operating at about 90% efficiency (where wall time is 100% of the total time). I recommend reading this post I did about profiling your code, so you can see which regions of your code are time consuming, and you can direct your OpenMP use in those regions.

Remember to include the ‘-openmp’ flag when compiling, and specifying the environment variable ‘OMP_NUM_THREADS’. I typically modify the ~/.bashrc file with a value and then source ~/.bashrc.

The rest of the code is self-explanatory. Read up on Fortran (or C) and OpenMP tutorials and other documentation for any additional information, or feel free to ask questions below. The C techniques are very similar and straightforward.

PDF from multiple PDFs or Images! Reduce PDF size through image compression! (Mac OS X 10.7.3)

I had 3 goals at the outset:

  1. Create a PDF from an image (JPEG, TIFF, PNG, etc.)
  2. Combine PDFs into one larger PDF
  3. Reduce the image quality of the PDF to a manageable size, while preserving readability. This process is not recommended for expert resizing of pictures.
This was all completed, but more importantly, the process wasn’t what I expected. I learned how to do the above, but the way below is simpler:
  1. If you are working with only images, it is useful to highlight all images and “Open With…” then select “Preview” and then Print to PDF. It joined all my images into a single PDF.
  2. If you are working with only PDFs, you can go straight to the section I’ve written below on Multiple PDFs to PDF.
  3. Reduce the image quality of the PDF to a manageable size, while preserving readability.

But there are some advantages and disadvantages about this method in 1. because if you Print to PDF in Preview it will create a white border around all of your images in your new PDF. The alternative is to create a Service in Automator that will go through all your images and convert them to PDFs, then condense all PDFs to one PDF. I haven’t fleshed out this process yet, as I’m satisfied (i.e. unwilling to complain) with the white border.

I’ve been encumbered by the inability to create PDFs from multiple PDFs or multiple images for some time. Today I decided it would be an essential skill so I learned how to do it, and now you’re going to learn. It was another beautiful day where I felt justified in purchasing my Macbook Air. Note that the majority of this instruction was compiled from about 6-8 different websites (so you don’t have to go crazy over tiny misconceptions and errors), so I thought I would throw it all into this one!

Some helpful sites (but note that my write-up is a condensed version of all of these sites to save you some time):

Create PDFs from images
Multiple Page PDF from PDFs
Combine PDF files Service
Reduce file size through quality
Resolving Quartz Filter Issues

Multiple PDFs to PDF

  • We’re going to use the built-in tool “Automator” to get things done. You can access Automator by going to your Launchpad and then clicking on Automator.
  • “Choose a type for your document:” immediately pops up, so you’re going to want to choose “Service.”
  • “Drag actions or files here to build your workflow” is the location where you will drag commands that will execute sequentially (top to bottom). Those commands can be accessed from the left-hand side where you see the library for Actions and Variables. The easiest way to find your desired action is by searching. There is a search bar next to “Actions” “Variables” in the top left of your Automator screen.
  • There is a section above the workflow area that says “Service receives selected” and has a drop-down menu. From the drop-down, select “PDF Files.” You’ll notice that to the right, “in any application” is selected, and should be fine.
  • First, we’ll search and add Combine PDF Pages to our workflow. Make sure “Appending Pages” radio button is selected if desired. Note that there are “Options” you can look choose from. Explore all the options just so you feel comfortable with the workflow.
  • Then search and add to workflow “Copy Finder Items.” I usually send the Finder items to Desktop. I do not check “Replace existing files.”
  • Then search and add to workflow “Rename Finder Items.” You can change the “Add Date or Time” pulldown to whatever naming convention customization you’d like. You should look at options and select “Show this action when the workflow runs.”
  • Finally, search and add to workflow “Move Finder Items.” I usually default moving the items to my Desktop.

After you’ve completed these steps, go to File and then Save! I saved mine as “Combine PDFs.”

These are the workflow steps within Automator to Combine PDFs.

Once you’ve closed Automator, test our your new Service. Highlight multiple PDF files and then Control + Click them to bring up several Finder options, and then scroll down to Services, where you should see Combine PDFs as one of the options.

Select your PDFs and ctrl+click, select Services, then select Combine PDFs and you’re done!

Let me know if it didn’t work for you in the comments and we’ll sort it out! Make sure you execute all the steps correctly before you accuse me of shenanigans!

Custom Reduction of Image Quality Using ColorSync Filters

I needed to reduce a PDF that I combined from something outrageous (like 200 MB to 600 MB) to something manageable (like 2-6 MB). How can we reduce the order of magnitude by 2 and still have recognizable quality? I had the same question. It turns out for practical purposes, if someone scanned a page of writing in very high TIFF quality (each image ~15 MB), they’ve overdone it. So let’s get it back to something more manageable.

I created a custom ColorSync filter, first. Later, this filter will be applied to my really long PDF as a postprocessing step.

  • Open ColorSync by going to your “Launchpad” –> “Utilities” –> “ColorSync Utility.”
  • When you open ColorSync, navigate to Filters on your new window.
  • You’ll notice a little “+” button at the bottom left of your new window. You’ve now added a custom filter. Give it a name.
  • Use the small drop down arrow to the right of your new Filter and select “Add Image Effects Component” and then select “Image Compression.”
  • Navigate to your new filter and expand it. Change the Mode of Image Compression to “JPEG” from the drop-down. I’ve made three filters reducing file sizes from high quality to above-average quality, middle quality, and below average quality. As far as I know, these filters are written (saved) as you make the adjustments. I have found the Reduce File Size High to Below Average (placing Quality at the 1/4 mark between Min and Max to yield the best results).
  • Close the Filters window, but stay in ColorSync Utility. Create a backup of your desired PDF just in case. Open your desired PDF using ColorSync Utility (go to File –> Open). If you do this, at the bottom you’ll notice there is a Filter option. Change the Filter to your desired new created filter, and then hit Apply!
  • File –> Save a copy of your new file! Now hopefully your file is easier to deal with.
For the compression type:

Choose your type of Filter for the PDF.

And for the Filters:

Create your Filters by using ColorSync Utility.

Good luck!

Installing gcc and gfortran for Mac OS X (10.7.3)

Things you’ll need:

  • Knowledge of how to use the terminal
  • An internet connection
  • A Mac developer account (you can get this as we go along)
  • Copy of Xcode (free)
  • About an hour of your time (30 minutes downloading, 15-30 minutes doing things)

Basic steps:

  1. Download and install Xcode
  2. Download command line tools
  3. Download and install gfortran from other source
Note that if you attempt to only download and install gfortran without gcc you might get the following error!

error trying to exec `as': execvp: No such file or directory

Also note that I performed this installation on a Macbook Air.


Download and install Xcode by clicking this link, or by searching for it in the Apple App Store, where it can be downloaded for free (see image).

Xcode contains gcc

After you’ve downloaded Xcode, you’ll want to open it and agree to their terms of service. Then, you’ll want to navigate to the menu Xcode –> Preferences –> Downloads. Here you’ll see an option to download Command Line Tools (see image). Note that you’ll need a developer account at this stage, and I was redirected to their developer page where I had to fill out a form and create my account (using my existing Apple ID, where a lot of the form was already auto-filled).

CL Tools

Download Command Line Tools from Preferences --> Downloads

After you have successfully installed the command line tools, open your terminal and type something like:

$ which gcc

which should return the path of your gcc in /usr/local/bin. All of this should have been taken care of automatically.

I mentioned at the beginning that I got an error when attempting to use gfortran on my machine before I’d even installed gcc. I found that gcc must be installed in order to use gfortran. But my gfortran installation went smooth because it’s very straightforward.

Download gfortran from this link.

After considering my hardware, I chose the option:

Mac OS Lion (10.7) on Intel 64-bit processors (gfortran 4.6.2): download (released on 2011-10-20)

The installation has a walkthrough that comes with the package, like many Mac installations. Straightforward and it should also work automatically. Then, open your terminal and type

$ which gfortran

and it should reveal that it was successfully installed in /usr/local/bin.

Happy programming!

Profiling a simple Fortran code with gprof

I finished working through Chapman’s Introducton to Fortran 90/95, and it was a very interesting (helpful) read. My next step is to work through Chapman’s (no relation?) Using OpenMP, but there are some performance considerations I must first address.

Therefore, I looked into gprof, which is the GNU profiling tool. It will give me an understanding of how quickly my code runs, and which tasks in the workflow are taking up the most resources. Here is what the ifort man pages say about the gprof compiler flag (note that I have a 32-bit processor for this test!):

Compiles and links for function profiling with gprof(1).
Architectures: IA-32, Intel® 64 architectures
Arguments: None
Default: OFF
Files are compiled and linked without profiling.
Description: This option compiles and links for function profiling with gprof(1).
Alternate Options:
Linux and Mac OS X: -pg (only available on systems using IA-32 architecture or Intel® 64 architecture), -qp (this is a deprecated option)

That’s interesting, sure! So with that bit of knowledge, I want to apply it to a large code that might make debugging a pain. I’m going to focus on a much simpler test case (that I’m taking from Chapman’s Fortran 90/95 book, Example 6-10, pg. 340).

gprof Example with Fortran Code

The example I consider has a function called “ave_value” which calculates the average value of a function between two points first_value and last_value. “ave_value” is called by “my_function,” which is declared as external in the test driver program “test_ave_value.” It’s a very simple program with three .f90 files.

I wrote these functions based on the example given in Chapman, and then  I compiled them with the following command:

$ ifort -p ave_value.f90 my_function.f90 test_ave_value.f90 -o test_ave_value

As a reminder, the -p flag allows me to specify our gprof option, and the -o flag allows me to rename the executable.

Now that you have your executable, you can simply run it, as I did:

$ ./test_ave_value

And you’ll notice that it has generated a “gmon.out” file that can be interpreted by gprof to show you your statistics! Writing gmon.out will overwrite any previous versions that you had in the folder, so use caution. Now, run gprof to interpret the gmon.out file.

$ gprof test_ave_value > tav.output

The tav.output was my re-naming of the gprof output. Now we can view the results of gprof in tav.output, in any competent text editor.

Looking at the Numbers

There is sufficient documentation for understanding gprof numbers on their website, but I’ll hit some critical points. The outputs are separated into the Flat Profile and the Call Graph. The Flat Profile conveys how much time your program has spent executing each function. The Call Graph conveys how much time was spent in the function and its children. You can read more here.

Visualization of gprof results

A quick way to put a visualization together (per the documentation of gprof2dot):

gprof path/to/your/executable | | dot -Tpng -o output.png

Here, gprof executes your program (which you’ve already compiled and linked with the appropriate flag!). That output is piped to a program called gprof2dot, which then pipes its output to create an output file that you can view in any competent image display tool!

Note that if you download gprof2dot, you’ll need to change the permissions to ensure that it’s an executable. I tried to run the non-executable version with

$ ./

but it would not execute because the file permissions were not set to executable.

Now that I learned this, I’m going to try it on a bigger code. Happy profiling!

Installing Python 2.7.2 in Ubuntu 11.10 – UNRESOLVED?

The bottom line: I have a working python installation because I installed it LOCALLY, but when I attempt a global (or system-wide) installation (using sudo), I run into an error I can’t seem to crack.


My goal is to install Python 2.7.2 so I can integrate it with my parallel workflow. It’s not a very ambitious goal. I installed the Intel C compiler (no sweat), MPICH2, and now I’m at this necessary step before I install mpi4py, a wonderful tool developed here.


During my installation process, I covered two versions of Ubuntu (because I updated midstream). The two versions were the notoriously friendly 10.04, and now 11.10. These are home editions, not server editions. I’ve done a lot of experimental stuff regarding the graphics on my 10.04, so now a lot of stuff is broken, and I thought upgrading to 11.10 would fix a lot of the harm I caused (it did!). I’m using a 64 bit Intel architecture, Corei7.


I downloaded the Python-2.7.2.tgz package. I unpacked it somewhere friendly. Then I built somewhere else. I usually do this and it has worked out pretty well so far.


Here is a list of the commands that I issue. They should work and install Python, in theory.

Command 1
./configure –prefix=$INSTALL_DESTINATION CC=$INTEL_C_COMPILER 2>&1 | tee c.txt

Note that my $INSTALL_DESTINATION was only root accessible, meaning I needed to specify sudo when making any changes to that directory. I do the fancy tee because it is absolutely necessary to keep me from going mad. Printing a history of what I just did and when I did it is great bookkeeping. Keep in mind that I fiddled with my Intel compiler. I tried to use the 32 bit compilers but it wouldn’t configure. I wasn’t sure if that would help, and now I know it doesn’t.

Command 2
make 2>&1 | tee m.txt

Again, this is a simple command that will send its output to a text file. At this stage, I got some warnings. I did not format the warning for your reading enjoyment.

compilation aborted for /home/benjamin/Documents/installs/Python-2.7.2/Modules/_ctypes/libffi/src/x86/ffi64.c (code 2)

Python build finished, but the necessary bits to build these modules were not found:
_bsddb _sqlite3 _tkinter
bsddb185 bz2 dbm
dl gdbm imageop
readline sunaudiodev
To find the necessary bits, look in in detect_modules() for the module’s name.
Failed to build these modules:
_bisect _codecs_cn _codecs_hk
_codecs_iso2022 _codecs_jp _codecs_kr
_codecs_tw _collections _csv
_ctypes _ctypes_test _curses
_curses_panel _elementtree _functools
_hashlib _heapq _hotshot
_io _json _locale
_lsprof _multibytecodec _multiprocessing
_random _socket _ssl
_struct _testcapi array
audioop binascii cmath
cPickle crypt cStringIO
datetime fcntl future_builtins
grp itertools linuxaudiodev
math mmap nis
operator ossaudiodev parser
pyexpat resource select
spwd strop syslog
termios time unicodedata

At the very least, we presume that our make install may not go as expected. Considering that I was about to install in a root directory, I issued the command

Command 3
$ sudo make install 2>&1 | tee mi.txt

which gave me the error

Traceback (most recent call last):
  File "/opt/Python-2.7/lib/python2.7/", line 17, in <module>
    import struct
  File "/opt/Python-2.7/lib/python2.7/", line 1, in <module>
    from _struct import *
ImportError: No module named _struct
make: *** [libinstall] Error 1

From here, it’s been all suffering and confusion.


I came across a forum post that detailed the error very similar to mine (if not exactly similar, but probably not, because it wasn’t their solution that solved my problem). They recommended an upgrade of the make utility. Before their recent upgrade in 2010, make was last upgraded in 2006. Four years of waiting reduced my “Failure to build these modules” from above, to this:

Failed to build these modules:


My recommendation here is to update your installation of make. Yet, with all of these wonderful improvements, my installation still failed with the same error. To check your existing version of make, go into your terminal window and type

$make -v

To automatically download the 3.8.2 edition of make, click here.

So with make upgraded, I was still running into issues with _struct. I did attempt the solution found in the link I provided to the forum posting. It did not work. But I think it’s a good start. I did not find the system-wide python installation absolutely necessary, so installing it locally was a breeze. I may come back to this later to resolve, but I’ll take any comments below to try them out.

Note: If you keep attempting the installation from source, make sure you run

$ make clean

after every time your

$ make install

fails, before you run make again.