Skip to content
BranchesTags

Repository files navigation

mcpl-geant4

This package faciliates the usage of Monte Carlo Particle Lists ( MCPL, https://mctools.github.io/mcpl/ ) files with Geant4.

Usage in Geant4 (C++) code

The interface between MCPL and Geant4 consists of two classes, G4MCPLGenerator and G4MCPLWriter, which users can use to either generate primary events from the particles in an existing MCPL file (1 particle per event), or to capture the particle state of particles entering one or more specified volumes in the simulation geometry and write them to a new MCPL file.

Refer to https://mctools.github.io/mcpl/hooks_geant4/ and section 3.1 of the MCPL paper (https://doi.org/10.1016/j.cpc.2017.04.012) for how to use these two classes in a Geant4 simulation.

Usage Examples

Two complete usage examples along with the necessary CMake code is provided in the mcpl-geant4 repository at:

Installation and Configuration

To use the MCPL-Geant4 bindings, one must:

  1. Install MCPL and Geant4. Although it is possible to build both projects manually, it should be noted that both are available on conda-forge. If not using conda, note that MCPL is also available on PyPI, so assuming Geant4 has already been installed in another manner, it might be possible to simply complete the setup by a pip install mcpl.
  2. Install mcpl-geant4. This can be done by pip install mcpl-geant4, or alternatively by cloning the repository at https://github.com/mctools/ncrystal-geant4 and setting the CMake variable NCrystalGeant4_DIR to point at the src/mcpl_geant4/cmake subdir of the cloned repo.
  3. Edit your projects CMakeLists.txt to add a find_package(MCPLGeant4) statement, and adding the MCPLGeant4::MCPLGeant4 target as a dependency of the Geant4 application you are building.
  4. Edit your C++ code and include the header file(s) MCPLGeant4/G4MCPLWriter.hh and/or MCPLGeant4/G4MCPLGenerator.hh as needed. Then use the corresponding classes in your Geant4 code as needed (see above for usage instructions.

Scientific reference

A substantial effort went into developing MCPL. If you use it for your work, we would appreciate it if you would use the following reference in your work:

T. Kittelmann, et al., Monte Carlo Particle Lists: MCPL, Computer Physics Communications, Volume 218, September 2017, Pages 17-42, ISSN 0010-4655, https://doi.org/10.1016/j.cpc.2017.04.012

About

MCPL bindings for Geant4

Resources

Readme
Apache-2.0 license
Activity
Custom properties

Stars

0 stars

Watchers

1 watching

Forks

0 forks
Report repository

Releases

Packages

Used by

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - mctools/mcpl-geant4: MCPL bindings for Geant4 · GitHub
Skip to content
BranchesTags
Repository files navigation
mcpl-geant4
This package faciliates the usage of Monte Carlo Particle Lists ( MCPL,
https://mctools.github.io/mcpl/ ) files with Geant4.
Usage in Geant4 (C++) code
The interface between MCPL and Geant4 consists of two classes, G4MCPLGenerator
and G4MCPLWriter, which users can use to either generate primary events from
the particles in an existing MCPL file (1 particle per event), or to capture the
particle state of particles entering one or more specified volumes in the
simulation geometry and write them to a new MCPL file.
Refer to https://mctools.github.io/mcpl/hooks_geant4/ and section 3.1 of the
MCPL paper (https://doi.org/10.1016/j.cpc.2017.04.012) for how to use these two
classes in a Geant4 simulation.
Usage Examples
Two complete usage examples along with the necessary CMake code is provided in
the mcpl-geant4 repository at:
Installation and Configuration
To use the MCPL-Geant4 bindings, one must:
  1. Install MCPL and Geant4. Although it is possible to build both projects
manually, it should be noted that both are available on conda-forge. If not
using conda, note that MCPL is also available on PyPI, so assuming
Geant4 has already been installed in another manner, it might be possible to
simply complete the setup by a pip install mcpl.
  2. Install mcpl-geant4. This can be done by pip install mcpl-geant4,
or alternatively by cloning the repository at
https://github.com/mctools/ncrystal-geant4 and setting the CMake
variable NCrystalGeant4_DIR to point at the src/mcpl_geant4/cmake
subdir of the cloned repo.
  3. Edit your projects CMakeLists.txt to add a find_package(MCPLGeant4)
statement, and adding the MCPLGeant4::MCPLGeant4 target as a
dependency of the Geant4 application you are building.
  4. Edit your C++ code and include the header file(s)
MCPLGeant4/G4MCPLWriter.hh and/or MCPLGeant4/G4MCPLGenerator.hh as
needed. Then use the corresponding classes in your Geant4 code as needed (see
above for usage instructions.
Scientific reference
A substantial effort went into developing MCPL. If you use it for your work, we
would appreciate it if you would use the following reference in your work:
T. Kittelmann, et al., Monte Carlo Particle Lists: MCPL, Computer Physics
Communications, Volume 218, September 2017, Pages 17-42, ISSN 0010-4655,
https://doi.org/10.1016/j.cpc.2017.04.012
About
MCPL bindings for Geant4
Resources
Readme
Apache-2.0 license
Activity
Custom properties
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - mctools/mcpl-geant4: MCPL bindings for Geant4 · GitHub
Skip to content
BranchesTags
Repository files navigation
mcpl-geant4
This package faciliates the usage of Monte Carlo Particle Lists ( MCPL,
https://mctools.github.io/mcpl/ ) files with Geant4.
Usage in Geant4 (C++) code
The interface between MCPL and Geant4 consists of two classes, G4MCPLGenerator
and G4MCPLWriter, which users can use to either generate primary events from
the particles in an existing MCPL file (1 particle per event), or to capture the
particle state of particles entering one or more specified volumes in the
simulation geometry and write them to a new MCPL file.
Refer to https://mctools.github.io/mcpl/hooks_geant4/ and section 3.1 of the
MCPL paper (https://doi.org/10.1016/j.cpc.2017.04.012) for how to use these two
classes in a Geant4 simulation.
Usage Examples
Two complete usage examples along with the necessary CMake code is provided in
the mcpl-geant4 repository at:
Installation and Configuration
To use the MCPL-Geant4 bindings, one must:
  1. Install MCPL and Geant4. Although it is possible to build both projects
manually, it should be noted that both are available on conda-forge. If not
using conda, note that MCPL is also available on PyPI, so assuming
Geant4 has already been installed in another manner, it might be possible to
simply complete the setup by a pip install mcpl.
  2. Install mcpl-geant4. This can be done by pip install mcpl-geant4,
or alternatively by cloning the repository at
https://github.com/mctools/ncrystal-geant4 and setting the CMake
variable NCrystalGeant4_DIR to point at the src/mcpl_geant4/cmake
subdir of the cloned repo.
  3. Edit your projects CMakeLists.txt to add a find_package(MCPLGeant4)
statement, and adding the MCPLGeant4::MCPLGeant4 target as a
dependency of the Geant4 application you are building.
  4. Edit your C++ code and include the header file(s)
MCPLGeant4/G4MCPLWriter.hh and/or MCPLGeant4/G4MCPLGenerator.hh as
needed. Then use the corresponding classes in your Geant4 code as needed (see
above for usage instructions.
Scientific reference
A substantial effort went into developing MCPL. If you use it for your work, we
would appreciate it if you would use the following reference in your work:
T. Kittelmann, et al., Monte Carlo Particle Lists: MCPL, Computer Physics
Communications, Volume 218, September 2017, Pages 17-42, ISSN 0010-4655,
https://doi.org/10.1016/j.cpc.2017.04.012
About
MCPL bindings for Geant4
Resources
Readme
Apache-2.0 license
Activity
Custom properties
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - mctools/mcpl-geant4: MCPL bindings for Geant4 · GitHub
Skip to content
BranchesTags
Repository files navigation
mcpl-geant4
This package faciliates the usage of Monte Carlo Particle Lists ( MCPL,
https://mctools.github.io/mcpl/ ) files with Geant4.
Usage in Geant4 (C++) code
The interface between MCPL and Geant4 consists of two classes, G4MCPLGenerator
and G4MCPLWriter, which users can use to either generate primary events from
the particles in an existing MCPL file (1 particle per event), or to capture the
particle state of particles entering one or more specified volumes in the
simulation geometry and write them to a new MCPL file.
Refer to https://mctools.github.io/mcpl/hooks_geant4/ and section 3.1 of the
MCPL paper (https://doi.org/10.1016/j.cpc.2017.04.012) for how to use these two
classes in a Geant4 simulation.
Usage Examples
Two complete usage examples along with the necessary CMake code is provided in
the mcpl-geant4 repository at:
Installation and Configuration
To use the MCPL-Geant4 bindings, one must:
  1. Install MCPL and Geant4. Although it is possible to build both projects
manually, it should be noted that both are available on conda-forge. If not
using conda, note that MCPL is also available on PyPI, so assuming
Geant4 has already been installed in another manner, it might be possible to
simply complete the setup by a pip install mcpl.
  2. Install mcpl-geant4. This can be done by pip install mcpl-geant4,
or alternatively by cloning the repository at
https://github.com/mctools/ncrystal-geant4 and setting the CMake
variable NCrystalGeant4_DIR to point at the src/mcpl_geant4/cmake
subdir of the cloned repo.
  3. Edit your projects CMakeLists.txt to add a find_package(MCPLGeant4)
statement, and adding the MCPLGeant4::MCPLGeant4 target as a
dependency of the Geant4 application you are building.
  4. Edit your C++ code and include the header file(s)
MCPLGeant4/G4MCPLWriter.hh and/or MCPLGeant4/G4MCPLGenerator.hh as
needed. Then use the corresponding classes in your Geant4 code as needed (see
above for usage instructions.
Scientific reference
A substantial effort went into developing MCPL. If you use it for your work, we
would appreciate it if you would use the following reference in your work:
T. Kittelmann, et al., Monte Carlo Particle Lists: MCPL, Computer Physics
Communications, Volume 218, September 2017, Pages 17-42, ISSN 0010-4655,
https://doi.org/10.1016/j.cpc.2017.04.012
About
MCPL bindings for Geant4
Resources
Readme
Apache-2.0 license
Activity
Custom properties
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - mctools/mcpl-geant4: MCPL bindings for Geant4 · GitHub
Skip to content
BranchesTags
Repository files navigation
mcpl-geant4
This package faciliates the usage of Monte Carlo Particle Lists ( MCPL,
https://mctools.github.io/mcpl/ ) files with Geant4.
Usage in Geant4 (C++) code
The interface between MCPL and Geant4 consists of two classes, G4MCPLGenerator
and G4MCPLWriter, which users can use to either generate primary events from
the particles in an existing MCPL file (1 particle per event), or to capture the
particle state of particles entering one or more specified volumes in the
simulation geometry and write them to a new MCPL file.
Refer to https://mctools.github.io/mcpl/hooks_geant4/ and section 3.1 of the
MCPL paper (https://doi.org/10.1016/j.cpc.2017.04.012) for how to use these two
classes in a Geant4 simulation.
Usage Examples
Two complete usage examples along with the necessary CMake code is provided in
the mcpl-geant4 repository at:
Installation and Configuration
To use the MCPL-Geant4 bindings, one must:
  1. Install MCPL and Geant4. Although it is possible to build both projects
manually, it should be noted that both are available on conda-forge. If not
using conda, note that MCPL is also available on PyPI, so assuming
Geant4 has already been installed in another manner, it might be possible to
simply complete the setup by a pip install mcpl.
  2. Install mcpl-geant4. This can be done by pip install mcpl-geant4,
or alternatively by cloning the repository at
https://github.com/mctools/ncrystal-geant4 and setting the CMake
variable NCrystalGeant4_DIR to point at the src/mcpl_geant4/cmake
subdir of the cloned repo.
  3. Edit your projects CMakeLists.txt to add a find_package(MCPLGeant4)
statement, and adding the MCPLGeant4::MCPLGeant4 target as a
dependency of the Geant4 application you are building.
  4. Edit your C++ code and include the header file(s)
MCPLGeant4/G4MCPLWriter.hh and/or MCPLGeant4/G4MCPLGenerator.hh as
needed. Then use the corresponding classes in your Geant4 code as needed (see
above for usage instructions.
Scientific reference
A substantial effort went into developing MCPL. If you use it for your work, we
would appreciate it if you would use the following reference in your work:
T. Kittelmann, et al., Monte Carlo Particle Lists: MCPL, Computer Physics
Communications, Volume 218, September 2017, Pages 17-42, ISSN 0010-4655,
https://doi.org/10.1016/j.cpc.2017.04.012
About
MCPL bindings for Geant4
Resources
Readme
Apache-2.0 license
Activity
Custom properties
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - mctools/mcpl-geant4: MCPL bindings for Geant4 · GitHub
Skip to content
BranchesTags
Repository files navigation
mcpl-geant4
This package faciliates the usage of Monte Carlo Particle Lists ( MCPL,
https://mctools.github.io/mcpl/ ) files with Geant4.
Usage in Geant4 (C++) code
The interface between MCPL and Geant4 consists of two classes, G4MCPLGenerator
and G4MCPLWriter, which users can use to either generate primary events from
the particles in an existing MCPL file (1 particle per event), or to capture the
particle state of particles entering one or more specified volumes in the
simulation geometry and write them to a new MCPL file.
Refer to https://mctools.github.io/mcpl/hooks_geant4/ and section 3.1 of the
MCPL paper (https://doi.org/10.1016/j.cpc.2017.04.012) for how to use these two
classes in a Geant4 simulation.
Usage Examples
Two complete usage examples along with the necessary CMake code is provided in
the mcpl-geant4 repository at:
Installation and Configuration
To use the MCPL-Geant4 bindings, one must:
  1. Install MCPL and Geant4. Although it is possible to build both projects
manually, it should be noted that both are available on conda-forge. If not
using conda, note that MCPL is also available on PyPI, so assuming
Geant4 has already been installed in another manner, it might be possible to
simply complete the setup by a pip install mcpl.
  2. Install mcpl-geant4. This can be done by pip install mcpl-geant4,
or alternatively by cloning the repository at
https://github.com/mctools/ncrystal-geant4 and setting the CMake
variable NCrystalGeant4_DIR to point at the src/mcpl_geant4/cmake
subdir of the cloned repo.
  3. Edit your projects CMakeLists.txt to add a find_package(MCPLGeant4)
statement, and adding the MCPLGeant4::MCPLGeant4 target as a
dependency of the Geant4 application you are building.
  4. Edit your C++ code and include the header file(s)
MCPLGeant4/G4MCPLWriter.hh and/or MCPLGeant4/G4MCPLGenerator.hh as
needed. Then use the corresponding classes in your Geant4 code as needed (see
above for usage instructions.
Scientific reference
A substantial effort went into developing MCPL. If you use it for your work, we
would appreciate it if you would use the following reference in your work:
T. Kittelmann, et al., Monte Carlo Particle Lists: MCPL, Computer Physics
Communications, Volume 218, September 2017, Pages 17-42, ISSN 0010-4655,
https://doi.org/10.1016/j.cpc.2017.04.012
About
MCPL bindings for Geant4
Resources
Readme
Apache-2.0 license
Activity
Custom properties
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
})();
GitHub - mctools/mcpl-geant4: MCPL bindings for Geant4 · GitHub
Skip to content
BranchesTags
Repository files navigation
mcpl-geant4
This package faciliates the usage of Monte Carlo Particle Lists ( MCPL,
https://mctools.github.io/mcpl/ ) files with Geant4.
Usage in Geant4 (C++) code
The interface between MCPL and Geant4 consists of two classes, G4MCPLGenerator
and G4MCPLWriter, which users can use to either generate primary events from
the particles in an existing MCPL file (1 particle per event), or to capture the
particle state of particles entering one or more specified volumes in the
simulation geometry and write them to a new MCPL file.
Refer to https://mctools.github.io/mcpl/hooks_geant4/ and section 3.1 of the
MCPL paper (https://doi.org/10.1016/j.cpc.2017.04.012) for how to use these two
classes in a Geant4 simulation.
Usage Examples
Two complete usage examples along with the necessary CMake code is provided in
the mcpl-geant4 repository at:
Installation and Configuration
To use the MCPL-Geant4 bindings, one must:
  1. Install MCPL and Geant4. Although it is possible to build both projects
manually, it should be noted that both are available on conda-forge. If not
using conda, note that MCPL is also available on PyPI, so assuming
Geant4 has already been installed in another manner, it might be possible to
simply complete the setup by a pip install mcpl.
  2. Install mcpl-geant4. This can be done by pip install mcpl-geant4,
or alternatively by cloning the repository at
https://github.com/mctools/ncrystal-geant4 and setting the CMake
variable NCrystalGeant4_DIR to point at the src/mcpl_geant4/cmake
subdir of the cloned repo.
  3. Edit your projects CMakeLists.txt to add a find_package(MCPLGeant4)
statement, and adding the MCPLGeant4::MCPLGeant4 target as a
dependency of the Geant4 application you are building.
  4. Edit your C++ code and include the header file(s)
MCPLGeant4/G4MCPLWriter.hh and/or MCPLGeant4/G4MCPLGenerator.hh as
needed. Then use the corresponding classes in your Geant4 code as needed (see
above for usage instructions.
Scientific reference
A substantial effort went into developing MCPL. If you use it for your work, we
would appreciate it if you would use the following reference in your work:
T. Kittelmann, et al., Monte Carlo Particle Lists: MCPL, Computer Physics
Communications, Volume 218, September 2017, Pages 17-42, ISSN 0010-4655,
https://doi.org/10.1016/j.cpc.2017.04.012
About
MCPL bindings for Geant4
Resources
Readme
Apache-2.0 license
Activity
Custom properties
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages