PyPI - xcoll - Versions diffs - 0.6.1__py3-none-any.whl → 0.6.2__py3-none-any.whl - Mend - Supply Chain Defender

xcoll 0.6.1py3-none-any.whl → 0.6.2py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of xcoll might be problematic. Click here for more details.

Files changed (84) hide show

xcoll/scattering_routines/fluka/flukaio/doc/FlukaIO.html DELETED Viewed

@@ -1,1607 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-<meta name="generator" content="AsciiDoc 8.6.8">
-<title>FlukaIO: A library for particle exchange</title>
-<style type="text/css">
-/*
- * AsciiDoc 'volnitsky' theme for xhtml11 and html5 backends.
- * Based on css from http://volnitsky.com, which was in turn based on default
- * theme from AsciiDoc
- *
- * FIXME: The styling is still a bit rough in places.
- *
- */
-/* Default font. */
-body {
-  font-family: Georgia,"Times New Roman",Times,serif;
-}
-/* Title font. */
-h1, h2, h3, h4, h5, h6,
-div.title, caption.title,
-thead, p.table.header,
-#toctitle,
-#author, #revnumber, #revdate, #revremark,
-#footer {
-  font-family: Candara,Arial,sans-serif;
-}
-#toc a {
-    border-bottom: 1px dotted #999999;
-    color: #3A3A4D !important;
-    text-decoration: none !important;
-}
-#toc a:hover {
-    border-bottom: 1px solid #6D4100;
-    color: #6D4100 !important;
-    text-decoration: none !important;
-}
-a { color: #666688; text-decoration: none; border-bottom: 1px dotted #666688; }
-a:visited { color: #615FA0; border-bottom: 1px dotted #615FA0; }
-a:hover { color: #6D4100; border-bottom: 1px solid #6D4100; }
-em {
-  font-style: italic;
-  color: #444466;
-}
-strong {
-  font-weight: bold;
-  color: #444466;
-}
-h1, h2, h3, h4, h5, h6 {
-  color: #666688;
-  margin-bottom: 0.5em;
-  line-height: 1.3;
-  letter-spacing:+0.15em;
-}
-h1, h2, h3 { border-bottom: 2px solid #ccd; }
-h2 { padding-top: 0.5em; }
-h3 { float: left; }
-h3 + * { clear: left; }
-div.sectionbody {
-  margin-left: 0;
-}
-hr {
-  border: 1px solid #444466;
-}
-p {
-  margin-top: 0.5em;
-  margin-bottom: 0.5em;
-}
-ul, ol, li > p {
-  margin-top: 0;
-}
-pre {
-  padding: 0;
-  margin: 0;
-}
-#author {
-  color: #444466;
-  font-weight: bold;
-  font-size: 1.1em;
-}
-#footer {
-  font-size: small;
-  border-top: 2px solid silver;
-  padding-top: 0.5em;
-  margin-top: 4.0em;
-}
-#footer-text {
-  float: left;
-  padding-bottom: 0.5em;
-}
-#footer-badges {
-  float: right;
-  padding-bottom: 0.5em;
-}
-#preamble {
-  margin-top: 1.5em;
-  margin-bottom: 1.5em;
-}
-div.tableblock, div.imageblock, div.exampleblock, div.verseblock,
-div.quoteblock, div.literalblock, div.listingblock, div.sidebarblock,
-div.admonitionblock {
-  margin-top: 1.5em;
-  margin-bottom: 1.5em;
-}
-div.admonitionblock {
-  margin-top: 2.5em;
-  margin-bottom: 2.5em;
-}
-div.content { /* Block element content. */
-  padding: 0;
-}
-/* Block element titles. */
-div.title, caption.title {
-  color: #444466;
-  font-weight: bold;
-  text-align: left;
-  margin-top: 1.0em;
-  margin-bottom: 0.5em;
-}
-div.title + * {
-  margin-top: 0;
-}
-td div.title:first-child {
-  margin-top: 0.0em;
-}
-div.content div.title:first-child {
-  margin-top: 0.0em;
-}
-div.content + div.title {
-  margin-top: 0.0em;
-}
-div.sidebarblock > div.content {
-  background: #ffffee;
-  border: 1px solid silver;
-  padding: 0.5em;
-}
-div.listingblock > div.content {
-  border: 1px solid silver;
-  background: #f4f4f4;
-  padding: 0.5em;
-}
-div.quoteblock {
-  padding-left: 2.0em;
-  margin-right: 10%;
-}
-div.quoteblock > div.attribution {
-  padding-top: 0.5em;
-  text-align: right;
-}
-div.verseblock {
-  padding-left: 2.0em;
-  margin-right: 10%;
-}
-div.verseblock > pre.content {
-  font-family: inherit;
-}
-div.verseblock > div.attribution {
-  padding-top: 0.75em;
-  text-align: left;
-}
-/* DEPRECATED: Pre version 8.2.7 verse style literal block. */
-div.verseblock + div.attribution {
-  text-align: left;
-}
-div.admonitionblock .icon {
-  vertical-align: top;
-  font-size: 1.1em;
-  font-weight: bold;
-  text-decoration: underline;
-  color: #444466;
-  padding-right: 0.5em;
-}
-div.admonitionblock td.content {
-  padding-left: 0.5em;
-  border-left: 2px solid silver;
-}
-div.exampleblock > div.content {
-  border-left: 2px solid silver;
-  padding: 0.5em;
-}
-div.imageblock div.content { padding-left: 0; }
-span.image img { border-style: none; }
-a.image:visited { color: white; }
-dl {
-  margin-top: 0.8em;
-  margin-bottom: 0.8em;
-}
-dt {
-  margin-top: 0.5em;
-  margin-bottom: 0;
-  font-style: normal;
-  color: #444466;
-}
-dd > *:first-child {
-  margin-top: 0.1em;
-}
-ul, ol {
-    list-style-position: outside;
-}
-ol.arabic {
-  list-style-type: decimal;
-}
-ol.loweralpha {
-  list-style-type: lower-alpha;
-}
-ol.upperalpha {
-  list-style-type: upper-alpha;
-}
-ol.lowerroman {
-  list-style-type: lower-roman;
-}
-ol.upperroman {
-  list-style-type: upper-roman;
-}
-div.compact ul, div.compact ol,
-div.compact p, div.compact p,
-div.compact div, div.compact div {
-  margin-top: 0.1em;
-  margin-bottom: 0.1em;
-}
-div.tableblock > table {
-  border: 3px solid #444466;
-}
-thead {
-  font-weight: bold;
-  color: #444466;
-}
-tfoot {
-  font-weight: bold;
-}
-td > div.verse {
-  white-space: pre;
-}
-p.table {
-  margin-top: 0;
-}
-/* Because the table frame attribute is overriden by CSS in most browsers. */
-div.tableblock > table[frame="void"] {
-  border-style: none;
-}
-div.tableblock > table[frame="hsides"] {
-  border-left-style: none;
-  border-right-style: none;
-}
-div.tableblock > table[frame="vsides"] {
-  border-top-style: none;
-  border-bottom-style: none;
-}
-div.hdlist {
-  margin-top: 0.8em;
-  margin-bottom: 0.8em;
-}
-div.hdlist tr {
-  padding-bottom: 15px;
-}
-dt.hdlist1.strong, td.hdlist1.strong {
-  font-weight: bold;
-}
-td.hdlist1 {
-  vertical-align: top;
-  font-style: normal;
-  padding-right: 0.8em;
-  color: #444466;
-}
-td.hdlist2 {
-  vertical-align: top;
-}
-div.hdlist.compact tr {
-  margin: 0;
-  padding-bottom: 0;
-}
-.comment {
-  background: yellow;
-}
-@media print {
-  #footer-badges { display: none; }
-}
-#toctitle {
-  color: #666688;
-  font-size: 1.2em;
-  font-weight: bold;
-  margin-top: 1.0em;
-  margin-bottom: 0.1em;
-}
-div.toclevel1, div.toclevel2, div.toclevel3, div.toclevel4 { margin-top: 0; margin-bottom: 0; }
-div.toclevel1 { margin-top: 0.3em; margin-left: 0; font-size: 1.0em; }
-div.toclevel2 { margin-top: 0.25em; margin-left: 2em; font-size: 0.9em; }
-div.toclevel3 { margin-left: 4em; font-size: 0.8em; }
-div.toclevel4 { margin-left: 6em; font-size: 0.8em; }
-body {
-  margin: 1em 5%;
-  max-width:  55em;
-  padding-left: 0;
-}
-.monospaced, tt, div.listingblock > div.content {
-  font-family:  Consolas, "Andale Mono", "Courier New", monospace;
-  color: #004400;
-  background: #f4f4f4;
-  max-width: 80em;
-  line-height: 1.2em;
-}
-.paragraph p  {
-  line-height: 1.5em;
-  margin-top: 1em;
-}
-.paragraph p, li, dd, .content { max-width: 45em; }
-.admonitionblock               { max-width: 35em; }
-div.sectionbody div.ulist > ul > li {
-  list-style-type: square;
-  color: #aaa;
-}
-  div.sectionbody div.ulist >  ul > li > * {
-    color: black;
-    /*font-size: 50%;*/
-  }
-div.sectionbody div.ulist > ul > li div.ulist > ul > li {
-  color: #ccd ;
-}
-  div.sectionbody div.ulist > ul > li div.ulist > ul > li > * {
-    color: black ;
-  }
-em {
-  font-style: normal ! important;
-  font-weight: bold ! important;
-  color: #662222   ! important;
-  letter-spacing:+0.08em ! important;
-}
-/*
- * html5 specific
- *
- * */
-table.tableblock {
-  margin-top: 1.0em;
-  margin-bottom: 1.5em;
-}
-thead, p.tableblock.header {
-  font-weight: bold;
-  color: #666688;
-}
-p.tableblock {
-  margin-top: 0;
-}
-table.tableblock {
-  border-width: 3px;
-  border-spacing: 0px;
-  border-style: solid;
-  border-color: #444466;
-  border-collapse: collapse;
-}
-th.tableblock, td.tableblock {
-  border-width: 1px;
-  padding: 4px;
-  border-style: solid;
-  border-color: #444466;
-}
-table.tableblock.frame-topbot {
-  border-left-style: hidden;
-  border-right-style: hidden;
-}
-table.tableblock.frame-sides {
-  border-top-style: hidden;
-  border-bottom-style: hidden;
-}
-table.tableblock.frame-none {
-  border-style: hidden;
-}
-th.tableblock.halign-left, td.tableblock.halign-left {
-  text-align: left;
-}
-th.tableblock.halign-center, td.tableblock.halign-center {
-  text-align: center;
-}
-th.tableblock.halign-right, td.tableblock.halign-right {
-  text-align: right;
-}
-th.tableblock.valign-top, td.tableblock.valign-top {
-  vertical-align: top;
-}
-th.tableblock.valign-middle, td.tableblock.valign-middle {
-  vertical-align: middle;
-}
-th.tableblock.valign-bottom, td.tableblock.valign-bottom {
-  vertical-align: bottom;
-}
-/*
-  pygmentize filter
-*/
-.highlight .hll { background-color: #ffffcc }
-.highlight  { background: #f4f4f4; }
-.highlight .c { color: #008800; font-style: italic } /* Comment */
-.highlight .err { border: 1px solid #FF0000 } /* Error */
-.highlight .k { color: #AA22FF; font-weight: bold } /* Keyword */
-.highlight .o { color: #666666 } /* Operator */
-.highlight .cm { color: #008800; font-style: italic } /* Comment.Multiline */
-.highlight .cp { color: #008800 } /* Comment.Preproc */
-.highlight .c1 { color: #008800; font-style: italic } /* Comment.Single */
-.highlight .cs { color: #008800; font-weight: bold } /* Comment.Special */
-.highlight .gd { color: #A00000 } /* Generic.Deleted */
-.highlight .ge { font-style: italic } /* Generic.Emph */
-.highlight .gr { color: #FF0000 } /* Generic.Error */
-.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
-.highlight .gi { color: #00A000 } /* Generic.Inserted */
-.highlight .go { color: #808080 } /* Generic.Output */
-.highlight .gp { color: #000080; font-weight: bold } /* Generic.Prompt */
-.highlight .gs { font-weight: bold } /* Generic.Strong */
-.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
-.highlight .gt { color: #0040D0 } /* Generic.Traceback */
-.highlight .kc { color: #AA22FF; font-weight: bold } /* Keyword.Constant */
-.highlight .kd { color: #AA22FF; font-weight: bold } /* Keyword.Declaration */
-.highlight .kn { color: #AA22FF; font-weight: bold } /* Keyword.Namespace */
-.highlight .kp { color: #AA22FF } /* Keyword.Pseudo */
-.highlight .kr { color: #AA22FF; font-weight: bold } /* Keyword.Reserved */
-.highlight .kt { color: #00BB00; font-weight: bold } /* Keyword.Type */
-.highlight .m { color: #666666 } /* Literal.Number */
-.highlight .s { color: #BB4444 } /* Literal.String */
-.highlight .na { color: #BB4444 } /* Name.Attribute */
-.highlight .nb { color: #AA22FF } /* Name.Builtin */
-.highlight .nc { color: #0000FF } /* Name.Class */
-.highlight .no { color: #880000 } /* Name.Constant */
-.highlight .nd { color: #AA22FF } /* Name.Decorator */
-.highlight .ni { color: #999999; font-weight: bold } /* Name.Entity */
-.highlight .ne { color: #D2413A; font-weight: bold } /* Name.Exception */
-.highlight .nf { color: #00A000 } /* Name.Function */
-.highlight .nl { color: #A0A000 } /* Name.Label */
-.highlight .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */
-.highlight .nt { color: #008000; font-weight: bold } /* Name.Tag */
-.highlight .nv { color: #B8860B } /* Name.Variable */
-.highlight .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */
-.highlight .w { color: #bbbbbb } /* Text.Whitespace */
-.highlight .mf { color: #666666 } /* Literal.Number.Float */
-.highlight .mh { color: #666666 } /* Literal.Number.Hex */
-.highlight .mi { color: #666666 } /* Literal.Number.Integer */
-.highlight .mo { color: #666666 } /* Literal.Number.Oct */
-.highlight .sb { color: #BB4444 } /* Literal.String.Backtick */
-.highlight .sc { color: #BB4444 } /* Literal.String.Char */
-.highlight .sd { color: #BB4444; font-style: italic } /* Literal.String.Doc */
-.highlight .s2 { color: #BB4444 } /* Literal.String.Double */
-.highlight .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */
-.highlight .sh { color: #BB4444 } /* Literal.String.Heredoc */
-.highlight .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */
-.highlight .sx { color: #008000 } /* Literal.String.Other */
-.highlight .sr { color: #BB6688 } /* Literal.String.Regex */
-.highlight .s1 { color: #BB4444 } /* Literal.String.Single */
-.highlight .ss { color: #B8860B } /* Literal.String.Symbol */
-.highlight .bp { color: #AA22FF } /* Name.Builtin.Pseudo */
-.highlight .vc { color: #B8860B } /* Name.Variable.Class */
-.highlight .vg { color: #B8860B } /* Name.Variable.Global */
-.highlight .vi { color: #B8860B } /* Name.Variable.Instance */
-.highlight .il { color: #666666 } /* Literal.Number.Integer.Long */
-@media screen {
-  body {
-    max-width: 50em; /* approximately 80 characters wide */
-    margin-left: 16em;
-  }
-  #toc {
-    position: fixed;
-    top: 0;
-    left: 0;
-    bottom: 0;
-    width: 13em;
-    padding: 0.5em;
-    padding-bottom: 1.5em;
-    margin: 0;
-    overflow: auto;
-    border-right: 3px solid #f8f8f8;
-    background-color: white;
-  }
-  #toc .toclevel1 {
-    margin-top: 0.5em;
-  }
-  #toc .toclevel2 {
-    margin-top: 0.25em;
-    display: list-item;
-    color: #aaaaaa;
-  }
-  #toctitle {
-    margin-top: 0.5em;
-  }
-}
-</style>
-<script type="text/javascript">
-/*<![CDATA[*/
-var asciidoc = {  // Namespace.
-/////////////////////////////////////////////////////////////////////
-// Table Of Contents generator
-/////////////////////////////////////////////////////////////////////
-/* Author: Mihai Bazon, September 2002
- * http://students.infoiasi.ro/~mishoo
- *
- * Table Of Content generator
- * Version: 0.4
- *
- * Feel free to use this script under the terms of the GNU General Public
- * License, as long as you do not remove or alter this notice.
- */
- /* modified by Troy D. Hanson, September 2006. License: GPL */
- /* modified by Stuart Rackham, 2006, 2009. License: GPL */
-// toclevels = 1..4.
-toc: function (toclevels) {
-  function getText(el) {
-    var text = "";
-    for (var i = el.firstChild; i != null; i = i.nextSibling) {
-      if (i.nodeType == 3 /* Node.TEXT_NODE */) // IE doesn't speak constants.
-        text += i.data;
-      else if (i.firstChild != null)
-        text += getText(i);
-    }
-    return text;
-  }
-  function TocEntry(el, text, toclevel) {
-    this.element = el;
-    this.text = text;
-    this.toclevel = toclevel;
-  }
-  function tocEntries(el, toclevels) {
-    var result = new Array;
-    var re = new RegExp('[hH]([1-'+(toclevels+1)+'])');
-    // Function that scans the DOM tree for header elements (the DOM2
-    // nodeIterator API would be a better technique but not supported by all
-    // browsers).
-    var iterate = function (el) {
-      for (var i = el.firstChild; i != null; i = i.nextSibling) {
-        if (i.nodeType == 1 /* Node.ELEMENT_NODE */) {
-          var mo = re.exec(i.tagName);
-          if (mo && (i.getAttribute("class") || i.getAttribute("className")) != "float") {
-            result[result.length] = new TocEntry(i, getText(i), mo[1]-1);
-          }
-          iterate(i);
-        }
-      }
-    }
-    iterate(el);
-    return result;
-  }
-  var toc = document.getElementById("toc");
-  if (!toc) {
-    return;
-  }
-  // Delete existing TOC entries in case we're reloading the TOC.
-  var tocEntriesToRemove = [];
-  var i;
-  for (i = 0; i < toc.childNodes.length; i++) {
-    var entry = toc.childNodes[i];
-    if (entry.nodeName.toLowerCase() == 'div'
-     && entry.getAttribute("class")
-     && entry.getAttribute("class").match(/^toclevel/))
-      tocEntriesToRemove.push(entry);
-  }
-  for (i = 0; i < tocEntriesToRemove.length; i++) {
-    toc.removeChild(tocEntriesToRemove[i]);
-  }
-  // Rebuild TOC entries.
-  var entries = tocEntries(document.getElementById("content"), toclevels);
-  for (var i = 0; i < entries.length; ++i) {
-    var entry = entries[i];
-    if (entry.element.id == "")
-      entry.element.id = "_toc_" + i;
-    var a = document.createElement("a");
-    a.href = "#" + entry.element.id;
-    a.appendChild(document.createTextNode(entry.text));
-    var div = document.createElement("div");
-    div.appendChild(a);
-    div.className = "toclevel" + entry.toclevel;
-    toc.appendChild(div);
-  }
-  if (entries.length == 0)
-    toc.parentNode.removeChild(toc);
-},
-/////////////////////////////////////////////////////////////////////
-// Footnotes generator
-/////////////////////////////////////////////////////////////////////
-/* Based on footnote generation code from:
- * http://www.brandspankingnew.net/archive/2005/07/format_footnote.html
- */
-footnotes: function () {
-  // Delete existing footnote entries in case we're reloading the footnodes.
-  var i;
-  var noteholder = document.getElementById("footnotes");
-  if (!noteholder) {
-    return;
-  }
-  var entriesToRemove = [];
-  for (i = 0; i < noteholder.childNodes.length; i++) {
-    var entry = noteholder.childNodes[i];
-    if (entry.nodeName.toLowerCase() == 'div' && entry.getAttribute("class") == "footnote")
-      entriesToRemove.push(entry);
-  }
-  for (i = 0; i < entriesToRemove.length; i++) {
-    noteholder.removeChild(entriesToRemove[i]);
-  }
-  // Rebuild footnote entries.
-  var cont = document.getElementById("content");
-  var spans = cont.getElementsByTagName("span");
-  var refs = {};
-  var n = 0;
-  for (i=0; i<spans.length; i++) {
-    if (spans[i].className == "footnote") {
-      n++;
-      var note = spans[i].getAttribute("data-note");
-      if (!note) {
-        // Use [\s\S] in place of . so multi-line matches work.
-        // Because JavaScript has no s (dotall) regex flag.
-        note = spans[i].innerHTML.match(/\s*\[([\s\S]*)]\s*/)[1];
-        spans[i].innerHTML =
-          "[<a id='_footnoteref_" + n + "' href='#_footnote_" + n +
-          "' title='View footnote' class='footnote'>" + n + "</a>]";
-        spans[i].setAttribute("data-note", note);
-      }
-      noteholder.innerHTML +=
-        "<div class='footnote' id='_footnote_" + n + "'>" +
-        "<a href='#_footnoteref_" + n + "' title='Return to text'>" +
-        n + "</a>. " + note + "</div>";
-      var id =spans[i].getAttribute("id");
-      if (id != null) refs["#"+id] = n;
-    }
-  }
-  if (n == 0)
-    noteholder.parentNode.removeChild(noteholder);
-  else {
-    // Process footnoterefs.
-    for (i=0; i<spans.length; i++) {
-      if (spans[i].className == "footnoteref") {
-        var href = spans[i].getElementsByTagName("a")[0].getAttribute("href");
-        href = href.match(/#.*/)[0];  // Because IE return full URL.
-        n = refs[href];
-        spans[i].innerHTML =
-          "[<a href='#_footnote_" + n +
-          "' title='View footnote' class='footnote'>" + n + "</a>]";
-      }
-    }
-  }
-},
-install: function(toclevels) {
-  var timerId;
-  function reinstall() {
-    asciidoc.footnotes();
-    if (toclevels) {
-      asciidoc.toc(toclevels);
-    }
-  }
-  function reinstallAndRemoveTimer() {
-    clearInterval(timerId);
-    reinstall();
-  }
-  timerId = setInterval(reinstall, 500);
-  if (document.addEventListener)
-    document.addEventListener("DOMContentLoaded", reinstallAndRemoveTimer, false);
-  else
-    window.onload = reinstallAndRemoveTimer;
-}
-}
-asciidoc.install(2);
-/*]]>*/
-</script>
-</head>
-<body class="article">
-<div id="header">
-<h1>FlukaIO: A library for particle exchange</h1>
-<span id="author">David Siñuela Pastor</span><br>
-<span id="email" class="monospaced">&lt;<a href="mailto:david.sinuela.pastor@cern.ch">david.sinuela.pastor@cern.ch</a>&gt;</span><br>
-<span id="revnumber">version 3.0RC2</span>
-<div id="toc">
-  <div id="toctitle">Table of Contents</div>
-  <noscript><p><b>JavaScript must be enabled in your browser to display the table of contents.</b></p></noscript>
-</div>
-</div>
-<div id="content">
-<div id="preamble">
-<div class="sectionbody">
-<div class="quoteblock">
-<div class="title">Abstract</div>
-<div class="content">
-<div class="paragraph"><p>This document describes the FlukaIO protocol and discusses the implementation of
-the FlukaIO library. FlukaIO is a message passing protocol on top of TCP/IP, it
-was developed to enable the on-line communication of the Fluka Monte Carlo
-particle tracker and single particle trackers as SixTrack or Icosim.</p></div>
-</div>
-<div class="attribution">
-</div></div>
-</div>
-</div>
-<div class="sect1">
-<h2 id="_introduction">1. Introduction</h2>
-<div class="sectionbody">
-<div class="paragraph"><p>Two families of highly specialized simulators can be used to study the effects
-of a beam in an accelerator. One family is used to study the effects of the
-interaction of the beam with static matter, simulating individual particles and
-their interactions as they go though the matter. This kind of simulations are
-based on the Monte Carlo technique, after thousands of particles simulated the
-averaged results are very similar to those observed in reality. The second
-family, the single particle trackers, simulate the particles as they orbit
-throughout the accelerator ring. These kind of trackers simulate individual
-particles flying in the ring by applying them the optical functions of the ring
-elements.</p></div>
-<div class="paragraph"><p>For certain studies it is interesting to evaluate the long-term effects of the
-beam-matter interactions on the beam dynamics and vice versa. Therefore each
-kind of simulator plays an important role in these studies.</p></div>
-<div class="paragraph"><p>The current coupling infrastructure was designed to support a simulation where
-the beam circulates along the beam during thousands of turns. The trackig of the
-particles is performed by a single particle tracker as SixTrack or Icosim, and
-the Monte Carlo tracker Fluka is used to simulate one or more areas of the ring
-where the beam-matter interaction effects are important.</p></div>
-<div class="paragraph"><p>The test case simulation comprised a section of the accelerator with a moving
-scraper, a scraper is a piece of matter that moves into the beam pipe producing
-a reduction of the beam halo. With the infrastructure here described we were
-able to simulate the long term effects of the scraper on the beam stability. Two
-kind of outputs were obtained by these simulations: the pattern of lost
-particles along the ring and the energy deposition on the scraper geometry.</p></div>
-<div class="paragraph"><p>FlukaIO is the protocol and the library that provides the API for managing the
-communication between the trackers. The library implements a message passing
-protocol on top of TCP/IP and can be easily linked to other codes.</p></div>
-<div class="paragraph"><p>Both trackers must run at the same time and they will transport the particles in
-the portion of the accelerator that they are in charge to simulate. One of the
-two processes acts as the server and the other acts as the client. The
-disctinction only means that one process starts listening on one network port
-and the other starts the connection to that process. After the connection is
-established there is no disctinction in the way the server or the client work.</p></div>
-<div class="paragraph"><p>In the current implementation Fluka is set up to be the server and the single
-particle tracker acts as the client. By doing so we can easily change the single
-particle tracker keeping the server code (which is slightly more complicated)
-intact.</p></div>
-<div class="sect2">
-<h3 id="_getting_the_library">1.1. Getting the library</h3>
-<div class="paragraph"><p>The library is distributed via the main CERN&#8217;s subversion repository
-<a href="#flukaiosvn">[flukaiosvn]</a> as a source code package that must be compiled by the user.
-There exist several tags on the repository marking stable releases, please try
-to always use one of these. Compatible versions (API and protocol) are kept
-under the same major version number. That is, applications using release version
-2.0 can safely migrate to 2.1 and are encouraged to do so.</p></div>
-</div>
-<div class="sect2">
-<h3 id="_compiling_and_linking">1.2. Compiling and Linking</h3>
-<div class="paragraph"><p>The detailed instructions on how to compile FlukaIO can be found in the README
-file. The resulting library can be linked to a variety of languages, please
-refer to the documentation of your language to learn how to interoperate with C
-libraries.  We have successfully linked the library to software written in
-Fortran 77, Fortran 90, C, C++ and Matlab.</p></div>
-<div class="paragraph"><p>For C/C++ code the header files <span class="monospaced">FlukaIO.h</span> and <span class="monospaced">FlukaIOServer.h</span> must be
-included. In the case of Fortran the interface is defined in <span class="monospaced">FortranFlukaIO.h</span>
-and <span class="monospaced">FortranFlukaIOServer.h</span>.</p></div>
-<div class="paragraph"><p>Four sample programs are provided in the <span class="monospaced">samples</span> folder, one
-<a href="../samples/ClientTest.c">client</a> and <a href="../samples/ServerTest.c">server</a> in
-C and one <a href="../samples/fclient.f">client</a> and
-<a href="../samples/fserver.f">server</a> in Fortran. These can be used as a starting
-point for developing new servers or clients.</p></div>
-</div>
-</div>
-</div>
-<div class="sect1">
-<h2 id="_user_guide">2. User Guide</h2>
-<div class="sectionbody">
-<div class="sect2">
-<h3 id="_execution_flow">2.1. Execution flow</h3>
-<div class="paragraph"><p>In our setup both processes start executing aproximately at the same time.
-Fluka takes the role of the server and starts listening on a network port and
-the single particle tracker connects to the Fluka server.</p></div>
-<div class="paragraph"><p>A handshake takes place when the communication is started and both processes
-tell the other the version of the protocol they implement. If the major version
-of the protocol differs they end the connection and an error is reported.</p></div>
-<div class="paragraph"><p>Once the two processes have succesfully established the connection the
-simulation starts on the single particle tracker.</p></div>
-<div class="paragraph"><p>The particles are inserted and tracked along the lattice. The simulation
-continues as normal until it reaches an element in the lattice labelled as a
-Fluka element. At this point the simulation has to continue in Fluka, therefore
-all the particles have to be sent to the Fluka process.</p></div>
-<div class="paragraph"><p>Before sending the particles the single particle tracker must tell Fluka where
-in space and time the particles have to be inserted. For that purpose the SPT
-sends an Insertion PoinT message (IPT) which the lattice element number and
-current turn. There must be a convention for Fluka to know which element number
-corresponds to which position in the Fluka space and the turn number can be used
-to compute the time shift in cases where it is important for the simulation.</p></div>
-<div class="paragraph"><p>The particles are then sent to the Fluka process in individual messages followed
-an End Of Bunch message (EOB). The SPT then remains waiting for incoming network
-messages. Fluka tracks the particles one by one and sends them back to the SPT
-if they reach the exit region of the geometry. Once all the particles received
-by Fluka are sent or lost Fluka sends the end of bunch message to the SPT. Once
-the SPT receives the EOB message knows all the remaining particles have been
-received. The simulation continues in the single particle tracker from the next
-element.</p></div>
-<div class="paragraph"><p>The simulation will finish when the number of turns requested is exhausted or
-because all the particles were lost. The SPT will send an End of Communication
-message (EOC) and Fluka will reply with and EOC message to notify that the
-message was received and the process is going to finish.</p></div>
-<div class="paragraph"><p>The following diagram shows the data flow between the two processes:</p></div>
-<div class="imageblock aafigure">
-<div class="content">
-<img src="FlukaIO__1.png" alt="FlukaIO__1.png">
-</div>
-</div>
-<div class="paragraph"><p>Notice that the number of particles is always variable, not only particles can
-be lost in the accelerator tracker or in the Fluka section but also new
-particles can be generated in Fluka. Moreover, this processes can alter the
-order of the particles sent back to the original process.</p></div>
-</div>
-<div class="sect2">
-<h3 id="_types_of_messages">2.2. Types of Messages</h3>
-<div class="paragraph"><p><strong>Particle Message</strong></p></div>
-<div class="paragraph"><p>A message containing the data of a particle:</p></div>
-<div class="ulist"><ul>
-<li>
-<p>
-id: particle id
-</p>
-</li>
-<li>
-<p>
-gen: particle generation
-</p>
-</li>
-<li>
-<p>
-weigth: statistical weigth
-</p>
-</li>
-<li>
-<p>
-x: position in cm
-</p>
-</li>
-<li>
-<p>
-y: position in cm
-</p>
-</li>
-<li>
-<p>
-z: position in cm
-</p>
-</li>
-<li>
-<p>
-tx: director cosine along the x axis
-</p>
-</li>
-<li>
-<p>
-ty: director cosine along the y axis
-</p>
-</li>
-<li>
-<p>
-tz: director cosine along the z axis
-</p>
-</li>
-<li>
-<p>
-aa: mass number
-</p>
-</li>
-<li>
-<p>
-zz: ion charge
-</p>
-</li>
-<li>
-<p>
-m: rest mass in GeV/c^2
-</p>
-</li>
-<li>
-<p>
-p: momentum in GeV/c
-</p>
-</li>
-<li>
-<p>
-t: time shift with respect to reference particle
-</p>
-</li>
-</ul></div>
-<div class="paragraph"><p><strong>End of batch</strong></p></div>
-<div class="paragraph"><p>A message specifying that all the particles of the current turn/batch have been
-processed and sent.</p></div>
-<div class="paragraph"><p><strong>End of computation</strong></p></div>
-<div class="paragraph"><p>Tells the other side that is ready to finish the simulation, the other end
-should then reply with an end of computation message and finish the process.</p></div>
-<div class="paragraph"><p><strong>Insertion point</strong></p></div>
-<div class="paragraph"><p>Usually sent from the tracker to the Fluka process, it contains the turn number
-and the elemenet number, instructing Fluka where the upcoming batch of particles
-has to be inserted.</p></div>
-<div class="paragraph"><p>As explained before, certain convention must exist among Fluka and the SPT,
-Fluka must be able to know which position in the space corresponds to each of
-the element identifiers.</p></div>
-</div>
-<div class="sect2">
-<h3 id="_api">2.3. API</h3>
-<div class="paragraph"><p>The API is splitted in two major sections: the client API and the server API.
-The client API is used by both the client and the server, while the server API
-contains only those functions needed to start the server. Two equivalent APIs
-are provided, one in C and the other in Fortran.  Since Fluka is implemented in
-Fortran the Fortran interface is needed to use FlukaIO.</p></div>
-<div class="paragraph"><div class="title">Note</div><p>All the API functions return -1 in case of error, the return value of every call
-should always be checked.</p></div>
-<div class="sect3">
-<h4 id="_client_api">2.3.1. Client API</h4>
-<div class="sect4">
-<h5 id="_create_the_connection_object">Create the connection object</h5>
-<div class="listingblock">
-<div class="title">C</div>
-<div class="content"><div class="highlight"><pre><span class="n">flukaio_connection_t</span> <span class="o">*</span><span class="n">flukaio_connect</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">host</span><span class="p">,</span> <span class="kt">int</span> <span class="n">port</span><span class="p">);</span>
-</pre></div></div></div>
-<div class="listingblock">
-<div class="title">Fortran</div>
-<div class="content"><div class="highlight"><pre><span class="kt">integer </span><span class="k">function </span><span class="nv">ntconnect</span><span class="p">(</span><span class="nv">host</span><span class="p">,</span> <span class="nv">port</span><span class="p">)</span>
-<span class="kt">character</span><span class="p">(</span><span class="nb">len</span><span class="o">=*</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">host</span>
-<span class="kt">integer</span> <span class="kd">::</span> <span class="nv">port</span>
-</pre></div></div></div>
-</div>
-<div class="sect4">
-<h5 id="_connect_to_a_flukaio_server_through_host_and_port">Connect to a FlukaIO server through host and port</h5>
-<div class="paragraph"><p>This call connects the current process to a FlukaIO server and returns the
-connection information. The connection should be opened at the initialization
-phase of the program and closed before finishing the process.</p></div>
-<div class="listingblock">
-<div class="title">C</div>
-<div class="content"><div class="highlight"><pre><span class="n">flukaio_connection_t</span> <span class="o">*</span><span class="n">flukaio_connect</span><span class="p">(</span><span class="n">flukaio_connection_t</span> <span class="o">*</span><span class="n">conn</span><span class="p">,</span> <span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">host</span><span class="p">,</span> <span class="kt">int</span> <span class="n">port</span><span class="p">);</span>
-</pre></div></div></div>
-<div class="paragraph"><p>It returns a pointer to a new flukaio_connection_t structure that must be passed
-to all subsequent calls to the functions of the API.</p></div>
-<div class="paragraph"><p>As it is usually the first call to flukaio in the client code it is recommended
-to use it like follows:</p></div>
-<div class="listingblock">
-<div class="title">C</div>
-<div class="content"><div class="highlight"><pre><span class="n">flukaio_connection_t</span> <span class="o">*</span><span class="n">conn</span> <span class="o">=</span> <span class="n">flukaio_connect</span><span class="p">(</span><span class="n">flukaio_conn</span><span class="p">(),</span> <span class="s">&quot;host&quot;</span><span class="p">,</span> <span class="mi">1234</span><span class="p">);</span>
-</pre></div></div></div>
-<div class="listingblock">
-<div class="title">Fortran</div>
-<div class="content"><div class="highlight"><pre><span class="kt">integer </span><span class="k">function </span><span class="nv">ntconnect</span><span class="p">(</span><span class="nv">host</span><span class="p">,</span> <span class="nv">port</span><span class="p">)</span>
-<span class="kt">character</span><span class="p">(</span><span class="nb">len</span><span class="o">=*</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">host</span>
-<span class="kt">integer</span> <span class="kd">::</span> <span class="nv">port</span>
-</pre></div></div></div>
-<div class="paragraph"><p>In the case of Fortran the function returns an integer with the connection
-identifier that should be passed to all the following calls to the API. If the
-identifier is smaller than 0 an error occurred.</p></div>
-</div>
-<div class="sect4">
-<h5 id="_disconnect">Disconnect</h5>
-<div class="paragraph"><p>Closes the connection to the server and releases its resources. The connection
-memory is freed inside the call.</p></div>
-<div class="listingblock">
-<div class="title">C</div>
-<div class="content"><div class="highlight"><pre><span class="kt">void</span> <span class="n">flukaio_disconnect</span><span class="p">(</span><span class="n">flukaio_connection_t</span> <span class="o">*</span><span class="n">conn</span><span class="p">);</span>
-</pre></div></div></div>
-<div class="listingblock">
-<div class="title">Fortran</div>
-<div class="content"><div class="highlight"><pre><span class="kt">integer </span><span class="k">function </span><span class="nv">ntend</span><span class="p">(</span><span class="nv">cid</span><span class="p">)</span>
-        <span class="kt">integer</span> <span class="kd">::</span> <span class="nv">cid</span>
-</pre></div></div></div>
-</div>
-<div class="sect4">
-<h5 id="_configure_connection_read_timeout">Configure connection read timeout</h5>
-<div class="paragraph"><p>Two functions are provided to read incoming particles: read_message and
-wait_message, the latter blocks the process until a message is received or an
-error occurred. It can happen that the other end of the communication never
-sends any message and therefore the process would keep waiting forever. This
-timeout specifies the maximum amount of time a wait_message call should wait.</p></div>
-<div class="listingblock">
-<div class="title">C</div>
-<div class="content"><div class="highlight"><pre><span class="kt">int</span> <span class="n">connection_set_read_timeout</span><span class="p">(</span><span class="n">flukaio_connection_t</span> <span class="o">*</span><span class="n">conn</span><span class="p">,</span> <span class="kt">long</span> <span class="n">timeout</span><span class="p">);</span>
-</pre></div></div></div>
-<div class="listingblock">
-<div class="title">Fortran</div>
-<div class="content"><div class="highlight"><pre><span class="kt">integer </span><span class="k">function </span><span class="nv">ntrtimeout</span><span class="p">(</span><span class="nv">cid</span><span class="p">,</span> <span class="nv">seconds</span><span class="p">)</span>
-        <span class="kt">integer</span> <span class="kd">::</span> <span class="nv">cid</span>
-        <span class="kt">integer</span> <span class="kd">::</span> <span class="nv">seconds</span>
-</pre></div></div></div>
-</div>
-<div class="sect4">
-<h5 id="_configure_connection_write_timeout">Configure connection write timeout</h5>
-<div class="listingblock">
-<div class="title">C</div>
-<div class="content"><div class="highlight"><pre><span class="kt">int</span> <span class="n">connection_set_write_timeout</span><span class="p">(</span><span class="n">flukaio_connection_t</span> <span class="o">*</span><span class="n">conn</span><span class="p">,</span> <span class="kt">long</span> <span class="n">timeout</span><span class="p">);</span>
-</pre></div></div></div>
-<div class="listingblock">
-<div class="title">Fortran</div>
-<div class="content"><div class="highlight"><pre><span class="kt">integer </span><span class="k">function </span><span class="nv">ntwtimeout</span><span class="p">(</span><span class="nv">cid</span><span class="p">,</span> <span class="nv">seconds</span><span class="p">)</span>
-        <span class="kt">integer</span> <span class="kd">::</span> <span class="nv">cid</span>
-        <span class="kt">integer</span> <span class="kd">::</span> <span class="nv">seconds</span>
-</pre></div></div></div>
-</div>
-<div class="sect4">
-<h5 id="_send_a_particle">Send a particle</h5>
-<div class="paragraph"><p>This call creates a particle message with the particle information provided and
-saves it in the outgoing buffer. The particle information can be safely modified
-immediately after calling this function.</p></div>
-<div class="paragraph"><p>In the case of C a particle_info_t pointer with the particle data must be passed
-and in the case of Fortran all the particle properties must be passed as
-arguments.</p></div>
-<div class="listingblock">
-<div class="title">C</div>
-<div class="content"><div class="highlight"><pre><span class="kt">ssize_t</span>
-<span class="n">flukaio_send_particle</span><span class="p">(</span><span class="n">flukaio_connection_t</span> <span class="o">*</span><span class="n">conn</span><span class="p">,</span> <span class="k">const</span> <span class="n">particle_info_t</span> <span class="o">*</span><span class="n">part</span><span class="p">);</span>
-</pre></div></div></div>
-<div class="listingblock">
-<div class="title">Fortran</div>
-<div class="content"><div class="highlight"><pre><span class="kt">integer </span><span class="k">function </span><span class="nv">ntsendp</span><span class="p">(</span><span class="nv">cid</span><span class="p">,</span> <span class="nv">id</span><span class="p">,</span> <span class="nv">gen</span><span class="p">,</span> <span class="nv">wgt</span><span class="p">,</span> <span class="nv">x</span><span class="p">,</span> <span class="nv">y</span><span class="p">,</span> <span class="nv">z</span><span class="p">,</span> <span class="nv">tx</span><span class="p">,</span> <span class="nv">ty</span><span class="p">,</span> <span class="nv">tz</span><span class="p">,</span> <span class="nv">aa</span><span class="p">,</span> <span class="nv">zz</span><span class="p">,</span> <span class="nv">m</span><span class="p">,</span> <span class="nv">p</span><span class="p">,</span> <span class="nv">t</span><span class="p">)</span>
-        <span class="kt">integer</span> <span class="kd">::</span> <span class="nv">cid</span>
-        <span class="kt">integer</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">4</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">id</span>
-        <span class="kt">integer</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">4</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">gen</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">wgt</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">x</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">y</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">z</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">tx</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">ty</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">tz</span>
-        <span class="kt">integer</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">aa</span>
-        <span class="kt">integer</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">zz</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">m</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">p</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">t</span>
-</pre></div></div></div>
-</div>
-<div class="sect4">
-<h5 id="_send_end_of_batch_message">Send End Of Batch message</h5>
-<div class="paragraph"><p>End of turn message tells the other end that all the particles in the current
-batch were sent.</p></div>
-<div class="listingblock">
-<div class="title">C</div>
-<div class="content"><div class="highlight"><pre><span class="kt">ssize_t</span> <span class="n">flukaio_send_eob</span><span class="p">(</span><span class="n">flukaio_connection_t</span> <span class="o">*</span><span class="n">conn</span><span class="p">);</span>
-</pre></div></div></div>
-<div class="listingblock">
-<div class="title">Fortran</div>
-<div class="content"><div class="highlight"><pre><span class="kt">integer </span><span class="k">function </span><span class="nv">ntsendeob</span><span class="p">(</span><span class="nv">cid</span><span class="p">)</span>
-        <span class="kt">integer</span> <span class="kd">::</span> <span class="nv">cid</span>
-</pre></div></div></div>
-</div>
-<div class="sect4">
-<h5 id="_send_insertion_point">Send Insertion Point</h5>
-<div class="paragraph"><p>Tells the other end where the following particles should be inserted. It sends
-an integer with the insertion point identifier and an integer with the turn
-number.</p></div>
-<div class="listingblock">
-<div class="title">C</div>
-<div class="content"><div class="highlight"><pre><span class="kt">ssize_t</span> <span class="n">flukaio_send_ipt</span><span class="p">(</span><span class="n">flukaio_connection_t</span> <span class="o">*</span><span class="n">conn</span><span class="p">,</span> <span class="kt">uint32_t</span> <span class="n">turn</span><span class="p">,</span> <span class="kt">uint32_t</span> <span class="n">ipt</span><span class="p">);</span>
-</pre></div></div></div>
-<div class="listingblock">
-<div class="title">Fortran</div>
-<div class="content"><div class="highlight"><pre><span class="kt">integer </span><span class="k">function </span><span class="nv">ntsendipt</span><span class="p">(</span><span class="nv">cid</span><span class="p">,</span> <span class="nv">ipt</span><span class="p">,</span> <span class="nv">turn</span><span class="p">)</span>
-        <span class="kt">integer</span> <span class="kd">::</span> <span class="nv">cid</span>
-        <span class="kt">integer</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">4</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">ipt</span>
-        <span class="kt">integer</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">4</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">turn</span>
-</pre></div></div></div>
-</div>
-<div class="sect4">
-<h5 id="_send_end_of_computation_message">Send End Of Computation message</h5>
-<div class="paragraph"><p>Informs the other end that the simulation has finished.</p></div>
-<div class="listingblock">
-<div class="title">C</div>
-<div class="content"><div class="highlight"><pre><span class="kt">ssize_t</span> <span class="n">flukaio_send_eoc</span><span class="p">(</span><span class="n">flukaio_connection_t</span> <span class="o">*</span><span class="n">conn</span><span class="p">);</span>
-</pre></div></div></div>
-<div class="listingblock">
-<div class="title">Fortran</div>
-<div class="content"><div class="highlight"><pre><span class="kt">integer </span><span class="k">function </span><span class="nv">ntsendeoc</span><span class="p">(</span><span class="nv">cid</span><span class="p">)</span>
-        <span class="kt">integer</span> <span class="kd">::</span> <span class="nv">cid</span>
-</pre></div></div></div>
-</div>
-<div class="sect4">
-<h5 id="_read_a_message_non_blocking">Read a message (non-blocking)</h5>
-<div class="paragraph"><p>Reads messages from the incoming buffer, if nothing was read from the network
-returns -1, otherwise it returns the size of the read message.</p></div>
-<div class="listingblock">
-<div class="title">C</div>
-<div class="content"><div class="highlight"><pre><span class="kt">ssize_t</span>
-<span class="n">flukaio_receive_message</span><span class="p">(</span><span class="n">flukaio_connection_t</span> <span class="o">*</span><span class="n">conn</span><span class="p">,</span> <span class="n">flukaio_message_t</span> <span class="o">*</span><span class="n">msg</span><span class="p">);</span>
-</pre></div></div></div>
-<div class="paragraph"><p>Stores the incoming message in msg. The type of the message can be inspected by
-looking at the msg.type field.</p></div>
-<div class="listingblock">
-<div class="title">Fortran</div>
-<div class="content"><div class="highlight"><pre><span class="kt">integer </span><span class="k">function </span><span class="nv">ntrecv</span><span class="p">(</span><span class="nv">cid</span><span class="p">,</span> <span class="nv">mtype</span><span class="p">,</span> <span class="nv">id</span><span class="p">,</span> <span class="nv">gen</span><span class="p">,</span> <span class="nv">wgt</span><span class="p">,</span> <span class="nv">x</span><span class="p">,</span> <span class="nv">y</span><span class="p">,</span> <span class="nv">z</span><span class="p">,</span> <span class="nv">tx</span><span class="p">,</span> <span class="nv">ty</span><span class="p">,</span> <span class="nv">tz</span><span class="p">,</span> <span class="nv">aa</span><span class="p">,</span> <span class="nv">zz</span><span class="p">,</span> <span class="nv">m</span><span class="p">,</span> <span class="nv">p</span><span class="p">,</span> <span class="nv">t</span><span class="p">)</span>
-        <span class="kt">integer</span> <span class="kd">::</span> <span class="nv">cid</span>
-        <span class="kt">integer</span> <span class="kd">::</span> <span class="nv">mtype</span>
-        <span class="kt">integer</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">4</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">id</span>
-        <span class="kt">integer</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">4</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">gen</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">wgt</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">x</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">y</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">z</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">tx</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">ty</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">tz</span>
-        <span class="kt">integer</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">aa</span>
-        <span class="kt">integer</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">zz</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">m</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">p</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">t</span>
-</pre></div></div></div>
-<div class="paragraph"><p>Stores the incoming message in the arguments, the type of the message is stored
-in mtype.</p></div>
-</div>
-<div class="sect4">
-<h5 id="_read_a_message_blocking">Read a message (blocking)</h5>
-<div class="paragraph"><p>If no message was received it blocks the application until a message arrives.
-Returns -1 if an error occurred (the other end disconnected or the read
-operation timed out).</p></div>
-<div class="listingblock">
-<div class="title">C</div>
-<div class="content"><div class="highlight"><pre><span class="kt">ssize_t</span>
-<span class="n">flukaio_wait_message</span><span class="p">(</span><span class="n">flukaio_connection_t</span> <span class="o">*</span><span class="n">conn</span><span class="p">,</span> <span class="n">flukaio_message_t</span> <span class="o">*</span><span class="n">msg</span><span class="p">);</span>
-</pre></div></div></div>
-<div class="paragraph"><p>Stores the incoming message in msg. The type of the message can be inspected by
-looking at the msg.type field.</p></div>
-<div class="listingblock">
-<div class="title">Fortran</div>
-<div class="content"><div class="highlight"><pre><span class="kt">integer </span><span class="k">function </span><span class="nv">ntwait</span><span class="p">(</span><span class="nv">cid</span><span class="p">,</span> <span class="nv">mtype</span><span class="p">,</span> <span class="nv">id</span><span class="p">,</span> <span class="nv">gen</span><span class="p">,</span> <span class="nv">wgt</span><span class="p">,</span> <span class="nv">x</span><span class="p">,</span> <span class="nv">y</span><span class="p">,</span> <span class="nv">z</span><span class="p">,</span> <span class="nv">tx</span><span class="p">,</span> <span class="nv">ty</span><span class="p">,</span> <span class="nv">tz</span><span class="p">,</span> <span class="nv">aa</span><span class="p">,</span> <span class="nv">zz</span><span class="p">,</span> <span class="nv">m</span><span class="p">,</span> <span class="nv">p</span><span class="p">,</span> <span class="nv">t</span><span class="p">)</span>
-        <span class="kt">integer</span> <span class="kd">::</span> <span class="nv">cid</span>
-        <span class="kt">integer</span> <span class="kd">::</span> <span class="nv">mtype</span>
-        <span class="kt">integer</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">4</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">id</span>
-        <span class="kt">integer</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">4</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">gen</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">wgt</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">x</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">y</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">z</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">tx</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">ty</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">tz</span>
-        <span class="kt">integer</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">aa</span>
-        <span class="kt">integer</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">zz</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">m</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">p</span>
-        <span class="kt">real</span><span class="p">(</span><span class="nb">kind</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span> <span class="kd">::</span> <span class="nv">t</span>
-</pre></div></div></div>
-<div class="paragraph"><p>Stores the incoming message in the arguments, the type of the message is stored
-in mtype.</p></div>
-</div>
-</div>
-<div class="sect3">
-<h4 id="_server_api">2.3.2. Server API</h4>
-<div class="sect4">
-<h5 id="_create_server_object">Create server object.</h5>
-<div class="listingblock">
-<div class="title">C</div>
-<div class="content"><div class="highlight"><pre><span class="n">flukaio_server_t</span><span class="o">*</span> <span class="n">flukaio_server_create</span><span class="p">();</span>
-</pre></div></div></div>
-<div class="paragraph"><p>This creates a structure holding all server attributes. This structure has to be
-used to call all other server operations.</p></div>
-<div class="listingblock">
-<div class="title">Fortran</div>
-<div class="content"><div class="highlight"><pre><span class="kt">integer </span><span class="k">function </span><span class="nv">ntserver</span><span class="p">()</span>
-</pre></div></div></div>
-<div class="paragraph"><p>Returns the server identified to be used to all subsequetn calls.</p></div>
-</div>
-<div class="sect4">
-<h5 id="_setup_a_server_listening_on_port">Setup a server listening on port</h5>
-<div class="paragraph"><p>Returns the assigned port or -1 if error.  The desired port can be specified in
-the port argument, if 0 is provided the port will be randomly assigned by the
-operating system.</p></div>
-<div class="listingblock">
-<div class="title">C</div>
-<div class="content"><div class="highlight"><pre><span class="kt">int</span> <span class="n">flukaio_server_start</span><span class="p">(</span><span class="n">flukaio_server_t</span><span class="o">*</span> <span class="n">server</span><span class="p">,</span> <span class="kt">unsigned</span> <span class="kt">int</span> <span class="n">port</span><span class="p">);</span>
-</pre></div></div></div>
-<div class="listingblock">
-<div class="title">Fortran</div>
-<div class="content"><div class="highlight"><pre><span class="kt">integer </span><span class="k">function </span><span class="nv">ntstart</span><span class="p">(</span><span class="nv">sid</span><span class="p">,</span> <span class="nv">port</span><span class="p">)</span>
-        <span class="kt">integer</span> <span class="kd">::</span> <span class="nv">sid</span>
-        <span class="kt">integer</span> <span class="kd">::</span> <span class="nv">port</span>
-</pre></div></div></div>
-<div class="paragraph"><p>The first variable is the serverid obtained with ntserver().</p></div>
-</div>
-<div class="sect4">
-<h5 id="_accept_connection">Accept connection</h5>
-<div class="paragraph"><p>Waits for a client connection and returns a structure with the connection
-information.</p></div>
-<div class="listingblock">
-<div class="title">C</div>
-<div class="content"><div class="highlight"><pre><span class="n">flukaio_connection_t</span> <span class="o">*</span><span class="n">flukaio_server_accept</span><span class="p">(</span><span class="n">flukaio_server_t</span><span class="o">*</span> <span class="n">server</span><span class="p">);</span>
-</pre></div></div></div>
-<div class="paragraph"><p>This returns the incoming connection object that can be used with the client
-API.</p></div>
-<div class="listingblock">
-<div class="title">Fortran</div>
-<div class="content"><div class="highlight"><pre><span class="kt">integer </span><span class="k">function </span><span class="nv">ntaccept</span><span class="p">(</span><span class="nv">sid</span><span class="p">)</span>
-        <span class="kt">integer</span> <span class="kd">::</span> <span class="nv">sid</span>
-</pre></div></div></div>
-<div class="paragraph"><p>Returns a connection identifier if there was a connection, otherwise -1.</p></div>
-</div>
-<div class="sect4">
-<h5 id="_shutdown_server">Shutdown server</h5>
-<div class="paragraph"><p>Frees all server resources, stops listening for connections.</p></div>
-<div class="listingblock">
-<div class="title">C</div>
-<div class="content"><div class="highlight"><pre><span class="kt">int</span> <span class="n">flukaio_server_shutdown</span><span class="p">(</span><span class="n">flukaio_server_t</span><span class="o">*</span> <span class="n">server</span><span class="p">);</span>
-</pre></div></div></div>
-<div class="listingblock">
-<div class="title">Fortran</div>
-<div class="content"><div class="highlight"><pre><span class="kt">integer </span><span class="k">function </span><span class="nv">ntshwnd</span><span class="p">()</span>
-        <span class="kt">integer</span> <span class="kd">::</span> <span class="nv">sid</span>
-</pre></div></div></div>
-</div>
-<div class="sect4">
-<h5 id="_get_server_port">Get server port</h5>
-<div class="paragraph"><p>Returns the port number on which the server is listening.</p></div>
-<div class="listingblock">
-<div class="title">C</div>
-<div class="content"><div class="highlight"><pre><span class="kt">int</span> <span class="n">flukaio_server_get_port</span><span class="p">(</span><span class="n">flukaio_server_t</span><span class="o">*</span> <span class="n">server</span><span class="p">);</span>
-</pre></div></div></div>
-<div class="listingblock">
-<div class="title">Fortran</div>
-<div class="content"><div class="highlight"><pre><span class="kt">integer </span><span class="k">function </span><span class="nv">ntgetport</span><span class="p">(</span><span class="nv">sid</span><span class="p">)</span>
-        <span class="kt">integer</span> <span class="kd">::</span> <span class="nv">sid</span>
-</pre></div></div></div>
-</div>
-</div>
-</div>
-<div class="sect2">
-<h3 id="_troubleshooting">2.4. Troubleshooting</h3>
-<div class="paragraph"><p>The source code is distributed with a complete test suite under the folder
-“tests”. In order to run the tests the CppUTest [1] test harness must be
-correctly installed. If CppUTest is installed the test suite is executed and a
-report is generated each time the code is compiled using make.</p></div>
-<div class="paragraph"><p>If something is failing please run the test suite and check that everything is
-working as expected. If that is the case try to sniff the network connection
-with <span class="monospaced">tcpdump</span>.</p></div>
-</div>
-</div>
-</div>
-<div class="sect1">
-<h2 id="_technical_documentation">3. Technical documentation</h2>
-<div class="sectionbody">
-<div class="sect2">
-<h3 id="_main_flukaio_features">3.1. Main FlukaIO features</h3>
-<div class="paragraph"><p>Although FlukaIO is meant to link Fluka to single particle tracking codes it has
-been designed to be extensible, a small list of features follows:</p></div>
-<div class="ulist"><ul>
-<li>
-<p>
-Two equivalent APIs, the native C API and a compatibility layer for Fortran
-   codes.
-</p>
-</li>
-<li>
-<p>
-TCP/IP communication: enabling client/server architectures
-</p>
-</li>
-<li>
-<p>
-Variable size messages to use minimum bandwidth
-</p>
-</li>
-<li>
-<p>
-Extensible list of message types, implemented now: particle, end of turn, end
-   of computation and insertion point
-</p>
-</li>
-<li>
-<p>
-Buffered input and output to improve performance
-</p>
-</li>
-<li>
-<p>
-Modular Object-Oriented architecture
-</p>
-</li>
-<li>
-<p>
-Complete test-suite
-</p>
-</li>
-</ul></div>
-</div>
-<div class="sect2">
-<h3 id="_protocol_description">3.2. Protocol Description</h3>
-<div class="sect3">
-<h4 id="_message_format">3.2.1. Message format</h4>
-<div class="paragraph"><p>The messages have this common header format:</p></div>
-<div class="imageblock aafigure">
-<div class="content">
-<img src="FlukaIO__2.png" alt="FlukaIO__2.png">
-</div>
-</div>
-<div class="paragraph"><p>The header of the message contains the total size of the message in bytes
-(unsigned integer: 2 bytes) and the type of message (unsigned integer: 1 byte),
-3 bytes in total.</p></div>
-</div>
-<div class="sect3">
-<h4 id="_types_of_messages_2">3.2.2. Types of Messages</h4>
-<div class="paragraph"><p>The type field in a message can have one of these values:</p></div>
-<div class="ulist"><ul>
-<li>
-<p>
-<strong>0 = ERR</strong>: Error (used internally)
-</p>
-</li>
-<li>
-<p>
-<strong>1 = PART</strong>: A message containing a particle
-</p>
-</li>
-<li>
-<p>
-<strong>2 = TURN</strong>: End of turn message
-</p>
-</li>
-<li>
-<p>
-<strong>3 = END</strong>: End of computation
-</p>
-</li>
-<li>
-<p>
-<strong>4 = CONF</strong>: Configuration, reserved
-</p>
-</li>
-<li>
-<p>
-<strong>5 = IPT</strong>: Insertion point
-</p>
-</li>
-</ul></div>
-<div class="paragraph"><p>The message types and their meanings are not strictly defined, interpretation
-depends on the application. Following definitions are just a guideline.</p></div>
-<div class="sect4">
-<h5 id="_error_message">Error message</h5>
-<div class="paragraph"><p>When the reads a message of type ERR means that the incoming message was not
-recognised. It is used internally, but it is also the type of message that the
-functions read_message and wait_message return when there is an error (in
-addition to returning -1).</p></div>
-</div>
-<div class="sect4">
-<h5 id="_particle_message">Particle message</h5>
-<div class="paragraph"><p>Contains a particle in the data section, for more details read the header file
-<span class="monospaced">include/ParticleInfo.h</span>:</p></div>
-<div class="imageblock aafigure">
-<div class="content">
-<img src="FlukaIO__3.png" alt="FlukaIO__3.png">
-</div>
-</div>
-</div>
-<div class="sect4">
-<h5 id="_end_of_batch_message">End Of Batch message</h5>
-<div class="paragraph"><p>Empty message communicating that all the particles were sent.</p></div>
-</div>
-<div class="sect4">
-<h5 id="_end_of_computation_message">End Of Computation message</h5>
-<div class="paragraph"><p>Informs the other end that computation was finished and must disconnect. Doesn’t
-contain any data.</p></div>
-</div>
-<div class="sect4">
-<h5 id="_insertion_point">Insertion point</h5>
-<div class="paragraph"><p>Contains a 4 bytes unsigned integer with the insertion point number, and a 4
-bytes unsigned integer with the turn number.</p></div>
-<div class="imageblock aafigure">
-<div class="content">
-<img src="FlukaIO__4.png" alt="FlukaIO__4.png">
-</div>
-</div>
-</div>
-</div>
-</div>
-<div class="sect2">
-<h3 id="_logical_structure">3.3. Logical Structure</h3>
-<div class="imageblock aafigure">
-<div class="content">
-<img src="FlukaIO__5.png" alt="FlukaIO__5.png">
-</div>
-</div>
-<div class="paragraph"><p>The library offers two APIs: FlukaIO and FlukaIOServer, a client application
-would normally use only FlukaIO while a server application would use both.</p></div>
-<div class="paragraph"><p>When a connection is established the FlukaIO library returns a Connection object
-(or connection id in the Fortran interface) which holds all the data needed
-during a communication session.</p></div>
-<div class="paragraph"><p>All the incoming and outgoing messages are sent through a Connection object,
-which stores them in the appropriate buffer if needed.  When enough data is
-stored in the output buffer or a flush operation is requested the connection
-object sends all the contents of the output buffer and erases them from memory.</p></div>
-<div class="paragraph"><p>All network operations are defined as function pointers in the Connection
-struct. This is used to replace all operating system calls during tests avoiding
-hitting the network and providing reliable and replicable test results.</p></div>
-</div>
-<div class="sect2">
-<h3 id="_data_flow_diagrams">3.4. Data flow diagrams</h3>
-<div class="paragraph"><p>In this section of the document an overview of the data flow is provided showing
-the collaboration between the different components of the library.</p></div>
-<div class="sect3">
-<h4 id="_starting_and_ending_communication">3.4.1. Starting and ending communication</h4>
-<div class="imageblock aafigure">
-<div class="content">
-<img src="FlukaIO__6.png" alt="FlukaIO__6.png">
-</div>
-</div>
-</div>
-<div class="sect3">
-<h4 id="_sending_messages">3.4.2. Sending messages</h4>
-<div class="imageblock aafigure">
-<div class="content">
-<img src="FlukaIO__7.png" alt="FlukaIO__7.png">
-</div>
-</div>
-<div class="paragraph"><p>End Of Computation messages are not shown in the diagram because they follow the
-same execution flow as the End Of Batch in the sense that they are synchronous
-as well.</p></div>
-</div>
-</div>
-<div class="sect2">
-<h3 id="_how_to">3.5. How to</h3>
-<div class="sect3">
-<h4 id="_add_new_fields_to_particles">3.5.1. Add new fields to particles</h4>
-<div class="paragraph"><p>If the partile structure is to be modified this approach is recommended:</p></div>
-<div class="olist arabic"><ol class="arabic">
-<li>
-<p>
-Add the field to particle_info_t (<span class="monospaced">include/ParticleInfo.h</span>)
-</p>
-</li>
-<li>
-<p>
-Update <span class="monospaced">PARTICLES_EQUAL</span> helpers in tests (<span class="monospaced">tests/FlukaIOTest.cpp</span> and
-<span class="monospaced">tests/FortranFlukaIO.cpp</span>)
-</p>
-</li>
-<li>
-<p>
-Run the tests and correct the code if they fail.
-</p>
-</li>
-</ol></div>
-<div class="paragraph"><p>The Fortran interface will need more work than the C interface because it
-exposes each individual field in the function signatures. Because of this the
-Fortran samples have to be updated to reflect the new interface. The C samples
-should still be working after the change.</p></div>
-</div>
-<div class="sect3">
-<h4 id="_add_new_message_types">3.5.2. Add new message types</h4>
-<div class="paragraph"><p>New message types can be introduced by adding the message id to the enum
-<span class="monospaced">message_type_t</span> found in <span class="monospaced">include/message.h</span> and modifying the FlukaIO logic.
-In case more variable size messages have to be implemented the data union field
-in flukaio_message_t structure can be modified to store the new data.</p></div>
-</div>
-</div>
-</div>
-</div>
-<div class="sect1">
-<h2 id="_credits">4. Credits</h2>
-<div class="sectionbody">
-<div class="ulist"><ul>
-<li>
-<p>
-David Siñuela Pastor &lt;<a href="mailto:david.sinuela.pastor@cern.ch">david.sinuela.pastor@cern.ch</a>&gt;
-</p>
-</li>
-<li>
-<p>
-Alessio Mereghetti &lt;<a href="mailto:Alessio.Mereghetti@cern.ch">Alessio.Mereghetti@cern.ch</a>&gt;
-</p>
-</li>
-<li>
-<p>
-Vasilis Vlachoudis &lt;<a href="mailto:Vasilis.Vlachoudis@cern.ch">Vasilis.Vlachoudis@cern.ch</a>&gt;
-</p>
-</li>
-<li>
-<p>
-Francesco Cerutti &lt;<a href="mailto:Francesco.Cerutti@cern.ch">Francesco.Cerutti@cern.ch</a>&gt;
-</p>
-</li>
-<li>
-<p>
-Joel Francois Clivaz &lt;<a href="mailto:joel.francois.clivaz@cern.ch">joel.francois.clivaz@cern.ch</a>&gt;
-</p>
-</li>
-</ul></div>
-</div>
-</div>
-<div class="sect1">
-<h2 id="_references">5. References</h2>
-<div class="sectionbody">
-<div class="ulist bibliography"><ul>
-<li>
-<p>
-<a id="flukaiosvn"></a>[flukaiosvn] . <em>FlukaIO subversion repository</em> .
-<a href="http://svnweb.cern.ch/world/wsvn/FlukaIO">http://svnweb.cern.ch/world/wsvn/FlukaIO</a>
-</p>
-</li>
-<li>
-<p>
-<a id="cpputest"></a>[cpputest] . <em>CppUTest</em>.  <a href="http://sourceforge.net/projects/cpputest/">http://sourceforge.net/projects/cpputest/</a>
-</p>
-</li>
-<li>
-<p>
-<a id="flukadesc"></a>[flukadesc] . G.  Battistoni, S.  Muraro, P.R. Sala, F. Cerutti, A.
-  Ferrari, S. Roesler, A.  Fasso`, J.  Ranft . <em>The FLUKA code: Description and
-benchmarking</em> . Proceedings of the Hadronic Shower Simulation Workshop 2006,
-Fermilab 6&#8212;8 September 2006, M. Albrow, R. Raja eds., AIP Conference Proceeding
-896, 31-49, (2007)
-</p>
-</li>
-<li>
-<p>
-<a id="flukacode"></a>[flukacode] . A. Fasso`, A.  Ferrari, J. Ranft, and P.R. Sala . <em>FLUKA: a
-  multi-particle transport code</em> . CERN-2005-10 (2005), INFN/TC_05/11, SLAC-R-773
-</p>
-</li>
-<li>
-<p>
-<a id="sixtrack"></a>[sixtrack] . F. Schmidt . <em>SixTrack, User’s Reference Manual</em> .  CERN
-  SL/94-56 (AP), 1994.
-</p>
-</li>
-<li>
-<p>
-<a id="icosim"></a>[icosim] . Holden, N . <em>Development of the ICOSIM Program and Application
-  to Magnetised Collimators in the LHC</em> . CERN-AB-Note-2008-054, 2008
-</p>
-</li>
-</ul></div>
-</div>
-</div>
-</div>
-<div id="footnotes"><hr></div>
-<div id="footer">
-<div id="footer-text">
-Version 3.0RC2<br>
-Last updated 2012-10-05 15:47:42 CEST
-</div>
-</div>
-</body>
-</html>