{"id":362,"date":"2020-10-01T11:07:46","date_gmt":"2020-10-01T10:07:46","guid":{"rendered":"http:\/\/ri.itservices.manchester.ac.uk\/csf4\/?page_id=362"},"modified":"2025-10-10T16:59:00","modified_gmt":"2025-10-10T15:59:00","slug":"starccm","status":"publish","type":"page","link":"https:\/\/ri.itservices.manchester.ac.uk\/csf4\/software\/applications\/starccm\/","title":{"rendered":"StarCCM"},"content":{"rendered":"<h2>Overview<\/h2>\n<p><a href=\"https:\/\/www.plm.automation.siemens.com\/global\/en\/products\/simcenter\/STAR-CCM.html\">StarCCM+<\/a> is a computation continuum mechanics application which can handle problems relating to fluid flow, heat transfer and stress. See below for the available versions on CSF.<\/p>\n<p><em><strong>Please note that the CSF Team do not supply copies of STARCM+ for laptops\/desktops, you will need to request that via the<\/strong><\/em> <a href=\"https:\/\/research-it.manchester.ac.uk\/services\/application-support\/\">Research Applications Team<\/a>.<\/p>\n<h2>Restrictions on Use<\/h2>\n<table class=\"hint\">\n<tbody>\n<tr>\n<td>Only users who have been added to the StarCCM group can run the application (run <code>groups<\/code> to see your group memberships). Owing to licence restrictions, only users from the School of MACE can be added to this group. Requests to be added to the StarCCM group should be requested via our<a href=\"https:\/\/ri.itservices.manchester.ac.uk\/hpc-help\"> help form<\/a>.<br \/>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>When the job runs there may not be enough licenses for the number of cores you have requested. There is currently a high demand for licenses and they may run out. To check whether there are at least enough licenses for you job your can add the following line to your <strong>jobscript<\/strong>:<\/p>\n<pre>. $STARCCM_HOME\/liccheck.sh\r\n<\/pre>\n<p>(that&#8217;s a full-stop followed by a space at the start of the line &#8211; please copy it carefully.)<\/p>\n<p>If there are <em>not<\/em> enough licenses for your job the job will automatically re-queue in the CSF batch system. If there are enough licenses the job will run StarCCM. If you omit this check your job will simply fail if there are not enough licenses.<\/p>\n<h2>Set Up Procedure<\/h2>\n<p>Once you have been added to the StarCCM+ group, you will be able to access the modulefiles. We now recommend loading modulefiles within your jobscript so that you have a full record of how the job was run. See the example jobscript below for how to do this. Alternatively, you may load modulefiles on the login node and let the job inherit these settings.<\/p>\n<p>Load <em>one<\/em> of the following modulefiles:<\/p>\n<pre># Choose required precision (double is more accurate but slower)\r\nmodule load  starccm\/20.04.008-mixed\r\nmodule load  starccm\/20.04.008-double\r\n\r\nmodule load  starccm\/19.04.009-mixed           # Also called v2024.6\r\nmodule load  starccm\/19.04.009-double\r\n\r\nmodule load starccm\/18.02.010-mixed            # Also called v2023.2\r\nmodule load starccm\/18.02.010-double\r\n\r\nmodule load starccm\/17.04.008-mixed            # Also called v2022.6\r\nmodule load starccm\/17.04.008-double\r\n\r\n\r\nmodule load starccm\/17.02.007-mixed            # Also called v2022.1\r\nmodule load starccm\/17.02.007-double\r\n\r\nmodule load starccm\/15.04.010-mixed            # Also called v2020.2.1 \r\nmodule load starccm\/15.04.010-double\r\n\r\nmodule load starccm\/15.02.009-mixed            # Also called v2020.1\r\nmodule load starccm\/15.02.009-double\r\n<\/pre>\n<h2>Running the Application<\/h2>\n<p>Currently, use of StarCCM+ in batch mode only is supported; no attempt should be made to use the StarCCM+ GUI directly on the CSF (however, see below for the <a href=\"#clientserver\">client-server<\/a> method). Once you have loaded the modulefile for the version you wish to run please write a jobscript based on one of those below and then submit it to the batch system with this command:<\/p>\n<pre>sbatch <em>myjobscript<\/em>\r\n<\/pre>\n<p>replacing <code><em>myjobscript<\/em><\/code> with the name of your file.<\/p>\n<h2>Small Parallel Jobs<\/h2>\n<p>These are jobs that use a single compute node &#8211; between 2 and 40 cores.<\/p>\n<h3>Jobs of up to 40 cores<\/h3>\n<p>This example describes how to submit an SMP job (uses cores in a single compute node)<\/p>\n<pre>#!\/bin\/bash --login\r\n#SBATCH -p multicore   # Single compute-node parallel job\r\n#SBATCH -n 4           # (--ntasks=4) Use 4 cores on a single node (max 40)\r\n\r\n# We now recommend loading the modulefile in the jobscript. Use your required version\r\nmodule load starccm\/19.04.009-mixed\r\n\r\n# Check for licenses, requeue if not enough available.\r\n. $STARCCM_HOME\/liccheck.sh\r\n\r\n### <strong>For version 19.04 and onwards, the SLURM integration allows a simpler command<\/strong>:\r\nstarccm+ -batch -pio -mpi openmpi -bs slurm <em>myinput.sim<\/em>\r\n\r\n### <strong>For older versions, please use the following more manual method<\/strong>:\r\n# Create a file listing the nodes to use\r\nNODEFILE=nodes.$SLURM_JOB_ID.txt\r\nscontrol show hostnames $SLURM_JOB_NODELIST &gt; $NODEFILE\r\n\r\n# NB: -pio enables parallel IO to speed up file access (CSF4 only)\r\nstarccm+ -batch -pio -mpi openmpi -machinefile $NODEFILE -np $SLURM_NTASKS <em>myinput.sim<\/em>\r\n                                                                              #\r\n                                                                              #\r\n                                                                              # Replace <em>myinput.sim<\/em>\r\n                                                                              # your sim file name.\r\n<\/pre>\n<p>Submit the job to the batch system using<\/p>\n<pre>sbatch <em>jobscript<\/em>\r\n<\/pre>\n<p>where <em>jobscript<\/em> is the name of your jobscript file.<\/p>\n<h2>Large Parallel Jobs<\/h2>\n<h3>Please check how your job scales before running large parallel jobs!<\/h3>\n<p>Do not assume that using twice as many cores will run you job in half the time! Jobs do not always scale linearly. Users are encouraged to test how their problem scales when considering a new problem or mesh size. This can be achieved easily, using an inbuilt script provided by CD-Adapco, which can be invoked using the <code>-benchmark<\/code> flag. For example:<\/p>\n<pre>#!\/bin\/bash --login\r\n#SBATCH -p multinode   # Multiple compute-node parallel job\r\n#SBATCH -N 2           # Two compute nodes\r\n#SBATCH -n 80          # (--ntasks=80) Two compute nodes, each using 40 cores\r\n\r\n# We now recommend loading the modulefile in the jobscript. Use your required version\r\nmodule load starccm\/19.04.009-mixed\r\n\r\n# Check for licenses, requeue if not enough available.\r\n. $STARCCM_HOME\/liccheck.sh\r\n\r\n### <strong>For version 19.04 and onwards, the SLURM integration allows a simpler command<\/strong>:\r\nstarccm+ -batch -pio -mpi openmpi -bs slurm <em>myinput.sim<\/em>\r\n\r\n### <strong>For older versions, please use the following more manual method<\/strong>:\r\n# Create a file listing the nodes to use\r\nNODEFILE=nodes.$SLURM_JOB_ID.txt\r\nscontrol show hostnames $SLURM_JOB_NODELIST &gt; $NODEFILE\r\n\r\n# NB: -pio enables parallel IO to speed up file access (CSF4 only)\r\nstarccm+ <strong>-benchmark<\/strong> \"-nps 1,2,4,8,16,32,40,80 -nits 20\" -pio -mpi openmpi \\\r\n                    -machinefile $NODEFILE -np $SLURM_NTASKS <em>myinput.sim<\/em>\r\n            #                                                \r\n            # Run the automatic benchmarks                   \r\n            # on your input model                            \r\n                                                              \r\n<\/pre>\n<p>Submit the job to the batch system using<\/p>\n<pre>sbatch <em>jobscript<\/em>\r\n<\/pre>\n<p>where <em>jobscript<\/em> is the name of your jobscript file. Any text printed out by the job will be in the <code>slurm-<em>nnnnn<\/em>.out<\/code> text file, where <code><em>nnnnn<\/em><\/code> is the unique job id number for your job.<\/p>\n<p>This will run 20 iterations on 1, 2, 4, 8, 16, 32, 40 and finally 80 cores, timing the runs. You may wish to run a smaller number of tests, for example, with 1,20,40,80 cores. Ensure you request enough cores using <code>#SBATCH -n <em>numcores<\/em><\/code> to match your largest benchmark. Note that the <code>\"<\/code> (quote) characters are required around the <code>\"-nps 1,2...\"<\/code> flag.<\/p>\n<p>The output is a <code>.html<\/code> file which can be opened using a web browser. This file will show how your problem scales, which can be used to decide how many cores to use. The parallel efficiency can be computed as speedup \/ number of workers from the resulting table. The point at which efficiency drops below ~85% users should consider using fewer cores, which may actually increase the speed of your computations.<\/p>\n<h3>Multi-node jobs of 80 cores or more<\/h3>\n<p>This is a multi-node example using two 40-core nodes (hence 80 cores in total). You can specify more nodes by using multiples of 40 for the number of cores (e.g., 120 for three nodes).<\/p>\n<pre>#!\/bin\/bash --login\r\n#SBATCH -p multinode   # Multiple compute-node parallel job\r\n#SBATCH -N 2           # Two compute nodes\r\n#SBATCH -n 80          # (--ntasks=80) Two compute nodes, each using 40 cores\r\n\r\n# We now recommend loading the modulefile in the jobscript. Use your required version\r\nmodule load starccm\/19.04.009-mixed\r\n\r\n# Check for licenses, requeue if not enough available.\r\n. $STARCCM_HOME\/liccheck.sh\r\n\r\n### <strong>For version 19.04 and onwards, the SLURM integration allows a simpler command<\/strong>:\r\nstarccm+ -batch -pio -mpi openmpi -bs slurm <em>myinput.sim<\/em>\r\n\r\n### <strong>For older versions, please use the following more manual method<\/strong>:\r\n# Create a file listing the nodes to use\r\nNODEFILE=nodes.$SLURM_JOB_ID.txt\r\nscontrol show hostnames $SLURM_JOB_NODELIST &gt; $NODEFILE\r\n\r\n# NB: -pio enables parallel IO to speed up file access (CSF4 only)\r\nstarccm+ -batch -pio -mpi openmpi -machinefile $NODEFILE -np $SLURM_NTASKS <em>myinput.sim<\/em>\r\n                                                                                #\r\n                                                                                #\r\n                                                     # Replace <em>myinput.sim<\/em> with #\r\n                                                     # your input file name.    #\r\n<\/pre>\n<p>Submit the job to the batch system using<\/p>\n<pre>sbatch <em>jobscript<\/em>\r\n<\/pre>\n<p>where <em>jobscript<\/em> is the name of your jobscript file. Any text printed out by the job will be in the <code>slurm-<em>nnnnn<\/em>.out<\/code> text file, where <code><em>nnnnn<\/em><\/code> is the unique job id number for your job.<\/p>\n<h2>Force a Checkpoint and optionally Abort<\/h2>\n<p>Checkpointing saves the current state of your simulation to file so that you can run the job again from the current state rather than from the beginning of the simulation. This is needed if your simulation is going to run for longer than the maximum runtime permitted (7 days).<\/p>\n<p>When asked to checkpoint, StarCCM+ will write out a new <code>.sim<\/code> file with <code>@<em>iteration<\/em><\/code> in the name to indicate the iteration number at which the checkpoint file was made. For example <code>&#109;&#x79;&#x69;n&#112;&#x75;t&#64;&#x32;&#x35;&#55;&#x30;&#x33;&#46;&#115;&#x69;m<\/code>. You can then use this as the input <code>.sim<\/code> file for another job on the CSF.<\/p>\n<h3>Manually<\/h3>\n<p>To force a checkpoint manually, leaving your batch job to carry on running the simulation after the checkpoint file has been written, run the following command on the login node in the directory from where you submitted the job:<\/p>\n<pre>touch CHECKPOINT\r\n<\/pre>\n<p>StarCCM+ checks after every iteration for this file. Once it sees the file it will save the current state of the simulation then rename the <code>CHECKPOINT<\/code> file to be <code>CHECKPOINT~<\/code> (so that it doesn&#8217;t keep checkpointing) then carry on with the simulation. You can run <code>touch CHECKPOINT<\/code> again at some time in the future to generate a new checkpoint file.<\/p>\n<p>If you wish to checkpoint and then terminate your simulation (which will end your CSF job), run the following on the login node in the directory where your simulation is running:<\/p>\n<pre>touch ABORT\r\n<\/pre>\n<p>You batch job will then terminate after it has written the checkpoint file.<\/p>\n<h3>Automatically in your jobscript<\/h3>\n<p>It is possible to automatically checkpoint your job near the end of the job&#8217;s runtime and have it re-queue itself on the CSF using the jobscript as shown below.<\/p>\n<p>In this example we run a simulation file named <code>myinput.sim<\/code>. When the job re-queues after a checkpoint, it will run <code>myinput@<em>nnnnn<\/em>.sim<\/code> where <code><em>nnnnn<\/em><\/code> is the iteration number at which the checkpoint was written. The script will automatically use the most recent checkpoint file. Eventually, the simulation will converge and StarCCM will exit normally. When this happens no further checkpoints are made and the job will not re-queue.<\/p>\n<p>Note that the script below does not delete any checkpoint files. If your simulation runs for a long time it may checkpoint a number of times and leave you with many large checkpoint files. You can periodically delete all but the most recent of these files.<\/p>\n<pre>#!\/bin\/bash --login\r\n#SBATCH -p multinode              # Job will run on the multi-node compute nodes\r\n#SBATCH -N 2                      # Two compute nodes\r\n#SBATCH -n 80                     # This example uses two 40-core nodes\r\n#SBATCH --signal=B:USR1@<strong>300<\/strong>       # Send a signal <strong>300<\/strong> seconds before end of job to write a checkpoint \r\n                                  # file. Is this enough time to write the checkpoint file?\r\n\r\n# -------------- Edit settings (carefully) ----------------\r\n\r\n# Name of simulation file - DO NOT add .sim to end of name.\r\n# Will be used to find <em>SIMFILE<\/em>.sim on first run or the\r\n# most recent <em>SIMFILE<\/em>@<em>nnnnn<\/em>.sim checkpoint file if available.\r\n\r\nSIMFILE=<em>myinput<\/em>\r\n\r\n# Version of StarCCM to use\r\nmodule load starccm\/19.04.009-mixed\r\n\r\n# -------------- End of settings --------------------------\r\n\r\n# Check for licenses, requeue if not enough available.\r\n. $STARCCM_HOME\/liccheck.sh\r\n\r\nfunction checkpoint_abort {\r\n    # Ask starccm to checkpoint then exit\r\n    touch ABORT\r\n\r\n    # Wait for StarCCM to write the checkpoint file\r\n    wait $CCMPID\r\n\r\n    # If checkpoint file written, job will requeue itself automatically \r\n    CHKFILE=`ls -t ${SIMFILE}@*.sim | head -1`\r\n    if [ -f \"$CHKFILE\" ]; then \r\n      echo \"Job checkpointed at `date` - wrote $CHKFILE - job will be requeued automatically\"\r\n      STATUS=99\r\n    else\r\n      echo \"No checkpoint file found (this is probably an error!) Job will not be requeued.\"\r\n    fi\r\n}\r\ntrap checkpoint_abort USR1 \r\n\r\n# Find newest checkpoint file \r\nSIM=`ls -t ${SIMFILE}*.sim | head -1`\r\nif [ -z \"$SIM\" ]; then\r\n  echo \"Failed to find any ${SIMFILE}[@nnnn].sim files. Job will exit!\"\r\n  exit 1\r\nfi\r\n\r\n# Create a file listing the nodes to use\r\nNODEFILE=nodes.$SLURM_JOB_ID.txt\r\nscontrol show hostnames $SLURM_JOB_NODELIST &gt; $NODEFILE\r\n\r\n# Start starccm+ (with parallel IO - CSF4 only) and save its process id (the &amp; at the end is important!)\r\nstarccm+ -batch -pio -mpi openmpi -machinefile $NODEFILE -np $SLURM_NTASKS $SIM <strong>&amp;<\/strong>\r\nCCMPID=$!\r\n\r\n# Wait for starccm to finish\r\nwait\r\n\r\n# Job will be requeued to carry on from last checkpoint if necessary\r\nexit $STATUS\r\n<\/pre>\n<p>Submit the job to the batch system using<\/p>\n<pre>sbatch <em>jobscript<\/em>\r\n<\/pre>\n<p>where <em>jobscript<\/em> is the name of your jobscript file. Any text printed out by the job will be in the <code>slurm-<em>nnnnn<\/em>.out<\/code> text file, where <code><em>nnnnn<\/em><\/code> is the unique job id number for your job.<br \/>\n<a name=\"clientserver\"><\/a><\/p>\n<h2>Client \/ Server Usage<\/h2>\n<p>The StarCCM+ GUI running on a campus desktop PC can be connected to a batch simulation running on the CSF. This allows the GUI to display the current state of the simulation (for example you can see graphs showing how particular variables are converging).<\/p>\n<p>Note that the method below will mean that the CSF job, once it is running, does NOT automatically start the simulation. Instead StarCCM+ will wait for you to connect the GUI to the job. But the CSF job is running and will be consuming its available runtime (max 7 days on the CSF).<\/p>\n<p>Please follow the instructions below:<\/p>\n<ol class=\"gaplist\">\n<li>Open two terminal windows on your PC. For example, two MobaXterm windows (use the + button above the black command window to open a second command window in a new <em>tab<\/em>) or run MobaXterm twice. On Mac or Linux, open two <em>Terminal<\/em> applications.<\/li>\n<li>In the first command-window, log in to the CSF as normal. Then write your StarCCM+ batch job. This should be familiar. However, there is a small change to one of the flags on the <code>starccm+<\/code> command-line as show in this example:\n<pre>#!\/bin\/bash --login\r\n#SBATCH -p multicore     # Single compute-node parallel job\r\n#SBATCH -n 40            # 40 core job to run a StarCCM simulation\r\n\r\n# We now recommend loading the modulefile in the jobscript. Use your required version\r\nmodule load starccm\/15.02.009-mixed\r\n\r\n# Check for licenses, requeue if not enough available.\r\n. $STARCCM_HOME\/liccheck.sh\r\n\r\n# Create a file listing the nodes to use\r\nNODEFILE=nodes.$SLURM_JOB_ID.txt\r\nscontrol show hostnames $SLURM_JOB_NODELIST &gt; $NODEFILE\r\n\r\n# Run starccm, but in <em>server<\/em> mode instead of <em>batch<\/em> mode\r\nstarccm+ <strong>-server<\/strong> -load <em>myinput.sim<\/em> -pio -mpi openmpi -machinefile $NODEFILE -np $SLURM_NTASKS\r\n           #               #\r\n           #               # Replace <em>myinput.sim<\/em> with your own input file.\r\n           #\r\n           # Now we use -server instead of -batch (as used previously)\r\n<\/pre>\n<p>Submit the job using <code>sbatch <em>myjobscript<\/em><\/code> as usual.<\/li>\n<li>Wait for the above job to run. When it does you will see a file named <code>slurm-<em>12345<\/em>.out<\/code> where <code><em>12345<\/em><\/code> will be unique to your job. Have a look in this file:\n<pre>cat slurm-<em>12345<\/em>.out\r\n<\/pre>\n<p>At the end of the file will be a message informing you where the job is running and on which <em>port<\/em> the server is listening:<\/p>\n<pre>Server::start -host <strong><em>node070<\/em><\/strong>.csf4.local:<strong><em>47827<\/em><\/strong>\r\n                        #              #\r\n                        #              # The port number <em>may<\/em> be different\r\n                        #              # but it is often 47827 (the default).\r\n                        #\r\n                        # The node name will likely be different.\r\n                        # Make a note of <em>your<\/em> node name.\r\n<\/pre>\n<\/li>\n<li>Now, in the second terminal window on <em>your PC<\/em> (<strong>NOT<\/strong> the CSF) log in to the CSF again with the following command:\n<pre>ssh -L <strong><em>47827<\/em><\/strong>:<strong><em>node070<\/em><\/strong>:<strong><em>47827<\/em><\/strong> <strong><em>mxyzabc1<\/em><\/strong>@csf4.itservices.manchester.ac.uk\r\n         #       #     #       #\r\n         #       #     #       # Use your own username here\r\n         #       #     #\r\n         #       #     # Use the port number reported earlier\r\n         #       #\r\n         #       # Use the node name reported earlier\r\n         #\r\n         # Use the port number earlier\r\n<\/pre>\n<p>Enter your CSF password when asked. You must leave this window logged in all time while using the StarCCM+ GUI on your PC. The GUI will be communicating with the CSF through this log-in (<em>tunnel<\/em>). You do not need to type any commands in to this login window.<\/li>\n<li>Now start the StarCCM+ GUI on your desktop PC. For example, on Windows, do this via the <em>Start Menu<\/em>. This will display the main user interface. In the GUI:\n<ol>\n<li>Select <em>File menu<\/em> then <em>Connect to server&#8230;<\/em><\/li>\n<li>In the window that pops up set:\n<pre>Host: localhost\r\nPort: 47827 (or whatever number you got from above).\r\n<\/pre>\n<p>Then hit OK. The GUI will connect to the job on the CSF.<\/li>\n<li>If running the StarCCM+ GUI on a linux desktop, you can connect to the server using:\n<pre>starccm+ -host localhost:<strong>47827<\/strong> # Change the port number to match given above\r\n<\/pre>\n<\/li>\n<li>You can now run (start) the simulation by going to the <em>Solution<\/em> menu then <em>Run<\/em> (or simply press <code>CTRL+R<\/code> in the main window).<\/li>\n<li>If you just want to look at the mesh, Open the <em>Scenes<\/em> node in the tree on the left. Then right-click on a <em>geometry<\/em> node and select <em>Open<\/em>. This will display the 3D geometry in the main viewer window.<\/li>\n<\/ol>\n<\/li>\n<li>You can disconnect the GUI from the CSF job using the <em>File<\/em> menu then <em>Disconnect from server<\/em>. This will leave the simulation running on the CSF but it won&#8217;t update in the GUI. You can close the StarCCM GUI at this point.<\/li>\n<\/ol>\n<h2>Co-Simulation with Abaqus<\/h2>\n<p>It is possible to have STAR-CCM+ perform some calculations with Abaqus, exchanging data between the two applications. For example, in mechanical co-simulation STAR-CCM+ passes traction loads to Abaqus (pressure + wall shear stress), and Abaqus passes displacements to STAR-CCM+. In Abaqus, the traction loads are applied to the surface of the solid structure. In STAR-CCM+, the displacements are used as an input to the mesh morpher. Data is exchanged via the Co-Simulation module of STAR-CCM+.<\/p>\n<p>You will need to set up the co-simulation in your STAR-CCM+ input file and also have available an Abaqus input file. You should also ensure the input files, when run in their respective applications, converge to solutions otherwise the co-simulation will not converge.<\/p>\n<p>More information is available in the STAR-CCM+ user guide, available on the login node by running the following command after you&#8217;ve loaded the starccm modulefile:<\/p>\n<pre>evince $STARCCM_UG\r\n<\/pre>\n<h3>Example 40-core co-simulation job<\/h3>\n<p>In this example we will run a single-node 40-core job with 32 cores used by StarCCM and 8 cores used by Abaqus.<\/p>\n<p>Create a directory structure for your co-simulation:<\/p>\n<pre>cd ~\/scratch\r\nmkdir co-sim # Change the name as requried\r\ncd co-sim\r\nmkdir abaqus starccm # Two directories to hold the input and output files from each app\r\n<\/pre>\n<p>Now copy your input files to the respective directories. For example:<\/p>\n<pre>cp ~\/abq_cosim.inp ~\/scratch\/co-sim\/abaqus\r\ncp ~\/ccm_cosim.sim ~\/scratch\/co-sim\/starccm\r\n<\/pre>\n<p>Now make some changes to the STAR-CCM+ input file to enable co-simulation. You can do this on your local workstation if you prefer but it is useful to be able to do this on the CSF when you want to change the settings before submitting a job &#8211; you will avoid transferring the input file back and forth between your workstation:<\/p>\n<pre># Load the required version of starccm, for example:\r\nmodule load starccm\/15.02.009-mixed\r\n\r\n# Start an interactive job to run the starccm GUI:\r\ncd ~\/scratch\/co-sim\/starccm\r\nsrun --pty starccm+ ccm_cosim.sim\r\n<\/pre>\n<p>When the GUI starts, open the <code>Co-Simulations<\/code> node in the tree viewer, expand <code>Link1<\/code> then look for the following attributes and set their values as follows:<\/p>\n<pre>Co-Simulation Type = Abaqus Co-Simulation # Choose from the drop-down menu\r\n...\r\n### Note there are several simulation settings (e.g., ramping parameters) that control\r\n### the simulation. You will need to set these but they are beyond the scope of this\r\n### web-page. Please refer to the starccm user guide.\r\n...\r\nAbaqus Execution\r\n    Current Job Name = <em>my-abq-cosim<\/em>       # Any name, used to name abaqus output files\r\n    Input file = ..\/abaqus\/abq_cosim.inp  # See directory structure created above\r\n    Executable name = abq2020             # The Abaqus command used on the CSF (choose version)\r\n    Number of CPUs = 8                    # This MUST match the jobscript (see below)\r\n    Remote shell = ssh                    # The default - leave set to this\r\n<\/pre>\n<p>Save the input file and exit the STAR-CCM+ GUI.<\/p>\n<p>Now create a jobscript to load the starccm and abaqus modulefiles, and run starccm with the correct number of cores:<\/p>\n<pre>cd ~\/scratch\/co-sim\/starccm\r\ngedit cosim.sh\r\n<\/pre>\n<p>The jobscript should contain the following:<\/p>\n<pre>#!\/bin\/bash --login\r\n#SBATCH -p multicore        # Single-node parallel job\r\n#SBATCH -n 40               # 40-cores in total for StarCCM and Abaqus to use\r\n\r\n## Load the modulefiles in the jobscript so we always know which version we used\r\nmodule load starccm\/15.02.009-mixed\r\nmodule load abaqus\/2020\r\n\r\n## We will use 32 (out of 40) cores for starccm and 8 (out of 40) cores for abaqus.\r\n## Manually set the special SLURM_NTASKS variable to these numbers so the license check\r\n## scripts test for the correct number of licenses. If there are not enough licenses\r\n## then the job will requeue.\r\nexport SLURM_NTASKS=8\r\n. $ABAQUS_HOME\/liccheck.sh\r\n\r\n## NOTE: We will leave SLURM_NTASKS set to the number needed for starccm after this license check\r\nexport SLURM_NTASKS=32\r\n. $STARCCM_HOME\/liccheck.sh\r\n\r\n# Create a file listing the nodes to use\r\nNODEFILE=nodes.$SLURM_JOB_ID.txt\r\nscontrol show hostnames $SLURM_JOB_NODELIST &gt; $NODEFILE\r\n\r\n## Now run starccm with 32 cores. It runs the 'abq2020' command with 8 cores (set in input file)\r\nstarccm+ -batch ccm_cosim.sim -mpi openmpi -machinefile $NODEFILE -np $SLURM_NTASKS\r\n<\/pre>\n<p>Submit the job using<\/p>\n<pre>sbatch cosim.sh<\/pre>\n<p>When the job runs you will see output files written to the <code>~\/scratch\/co-sim\/abaqus<\/code> and <code>~\/scratch\/co-sim\/starccm<\/code> directories. For example, to see what is happening in each simulation:<\/p>\n<pre>cd ~\/scratch\/co-sim\/abaqus\r\ntail -f <em>my-abq-cosim<\/em>.msg # The abaqus output file name was set in the starccm input file above\r\n  #\r\n  # Press CTRL+C to exit out of the 'tail' command\r\n\r\ncd ~\/scratch\/co-sim\/starccm\r\ntail -f slurm-<em>123456<\/em>.out # Replace <em>123456<\/em> with the job id number of your starccm job\r\n  #\r\n  # Press CTRL+C to exit out of the 'tail' command\r\n<\/pre>\n<p>The simulation should run until it is converged.<\/p>\n<h2>Further Information<\/h2>\n<p>Further information on StarCCM+ and other CFD applications may be found by <a href=\"http:\/\/cfd.mace.manchester.ac.uk\/twiki\/bin\/view\/Forum\/ForumCFD \">visiting the MACE CFD Forum<\/a>.<\/p>\n<p>The STAR-CCM+ user guide is available on the CSF using the following command <em>after<\/em> you have loaded the starccm modulefile:<\/p>\n<pre>evince $STARCCM_UG\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"<p>Overview StarCCM+ is a computation continuum mechanics application which can handle problems relating to fluid flow, heat transfer and stress. See below for the available versions on CSF. Please note that the CSF Team do not supply copies of STARCM+ for laptops\/desktops, you will need to request that via the Research Applications Team. Restrictions on Use Only users who have been added to the StarCCM group can run the application (run groups to see your.. <a href=\"https:\/\/ri.itservices.manchester.ac.uk\/csf4\/software\/applications\/starccm\/\">Read more &raquo;<\/a><\/p>\n","protected":false},"author":4,"featured_media":0,"parent":49,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-362","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/ri.itservices.manchester.ac.uk\/csf4\/wp-json\/wp\/v2\/pages\/362","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ri.itservices.manchester.ac.uk\/csf4\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/ri.itservices.manchester.ac.uk\/csf4\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/ri.itservices.manchester.ac.uk\/csf4\/wp-json\/wp\/v2\/users\/4"}],"replies":[{"embeddable":true,"href":"https:\/\/ri.itservices.manchester.ac.uk\/csf4\/wp-json\/wp\/v2\/comments?post=362"}],"version-history":[{"count":20,"href":"https:\/\/ri.itservices.manchester.ac.uk\/csf4\/wp-json\/wp\/v2\/pages\/362\/revisions"}],"predecessor-version":[{"id":1457,"href":"https:\/\/ri.itservices.manchester.ac.uk\/csf4\/wp-json\/wp\/v2\/pages\/362\/revisions\/1457"}],"up":[{"embeddable":true,"href":"https:\/\/ri.itservices.manchester.ac.uk\/csf4\/wp-json\/wp\/v2\/pages\/49"}],"wp:attachment":[{"href":"https:\/\/ri.itservices.manchester.ac.uk\/csf4\/wp-json\/wp\/v2\/media?parent=362"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}