Modifying a MCPL file for MCNP source conversion

[AmChamb]

Hi,

I am using a MCPL file to generate a MCNP source for further transport calculation. When testing the source I am facing some MCNP issues due to a weight of particles equal to 0. I had a look at the possibilities given by mcpltool to modify files. I can convert the mcpl file into a text file and then modify it but my question is then how can I convert it back? Is there a way to modify directly the mcpl file filtering the particles of interest?

Thank you in advance for the help in solving the issue.

Best regards,
Amalia

[ebknudsen]

mcpltool itself cannot do this (AFAIK). That said I can think of 3 other ways:

1. you could always write a small c-program that does exactly this using the mcpl-library. I can supply you with an example code if you want.
2. Use the mcpl-python module to read the mcpl-file into a numpy array. Fix whatever needs to be fixed and the use the np2mcpl python module (https://pypi.org/project/np2mcpl/) to write a new mcpl-file.
3. Use a combo of MCPL_input and MCPL_output comps in McStas with some logic in between that fixes whatever needs to be fixed.

There are other ways of course but these are the first ones I could think of off the cuff
cheers
Erik

[willend]

Let me initially +1 @ebknudsen's comment above. For the "McStas as converter" case there are a few examples here.

On the other hand I also seem to remember being able to "filter" (together with @EsbenKlinkby) on particle properties using mcpltool - or maybe it was another, more beefy dgcode-related tool @tkittel ? Is there maybe a built-in feature for this sort of thing today?

[tkittel]

Indeed @willend, it was my "beefy" MCPL tools in dgcode:

https://mctools.github.io/simplebuild-dgcode/mcpl.html#modify-mcpl-files

I still have an evil plan to extract these tools from dgcode and into the mcpl-extra package. One day 😄

[willend]

Would be nice indeed... 😄

( For the obscure audience with a McStas background / training there is of course the slightly weird way of "writing a c-program for the conversion" - which is using MCPL_input() and MCPL_output() and filtering "in between"... But I agree it shouldn't be advertised as "the simple" or "the obvious" solution for anyone else... 😉 )

[tkittel]

@willend I agree that McStas can be a very nice tool for the McStas-savvy to inspect distributions of neutrons in MCPL files, and even filtering and producing new MCPL files. But I think any recommendation to a wider audience that it can be used to filter MCPL files should come with a very very clear warning that not only will they loose MCPL file metadata (could be crucial for MCNP usage if they need the surface ID) and even have a lossy conversion of any retained particles due to the packing+unpacking, but people will also loose any particles in the files which are not neutrons!

Still, I am aware that the fault is with myself for not providing something more "beefy" for the casual user. Maybe 2026 will be that year? 😄

[willend]

"Other particles than neutrons - does that even exist?" 🤣

Agreed, as I tried to write above - a useful hint for some cases, clearly not a general solution. 😄

[tkittel]

Thanks for the question @AmChamb ! This is in fact pretty simple to do if you are able and willing to compile a small C programme, like @ebknudsen said. The C-code itself is basically the example at https://mctools.github.io/mcpl/usage_c/#extracting-subset-of-particles-from-file but with the filtering if-statement changed to reflect your desired requirement of having a nonzero particle weight.

So in a file called myfilter.c put the following code:

#include "mcpl.h"
#include <stdio.h>

int main(int argc,char**argv) {
  if (argc!=3) {
    printf("Please supply input and output filenames\n");
    return 1;
  }
  const char * infilename = argv[1];
  const char * outfilename = argv[2];
  mcpl_file_t fi = mcpl_open_file(infilename);
  mcpl_outfile_t fo = mcpl_create_outfile(outfilename);
  mcpl_transfer_metadata(fi, fo);
  const mcpl_particle_t* particle;
  while ( ( particle = mcpl_read(fi) ) ) {
    if ( particle->weight > 0.0 ) {  // This is the crucial line defining our filter.
      mcpl_transfer_last_read_particle(fi,fo);
    }
  }
  mcpl_close_outfile(fo);
  mcpl_close_file(fi);
}

In order to turn the code above into an actual programme that you can run, you must compile it with a C compiler. Furthermore, you must have installed the mcpl code (normally via conda or pip), and instruct your C compiler to use the MCPL header files and library. To give an example of how to do this, you could for instance first install the mcpl package into a Python environment. Here are the commands you can run in a unix terminal (e.g. Linux or Mac) to do that, including the actual creation of the virtual Python environment:

$> python3 -m venv my_venv 
$> . ./my_venv/bin/activate
$> pip install mcpl

The above is only needed the first time. If coming back later in a fresh terminal, you can simply type the second of the commands (. ./my_venv/bin/activate) to enter the virtual environment. You can also clean up everything later by simply removing the ./my_venv directory, if you wish. Btw., if you also wish to access the ssw2mcpl or mcpl2ssw commands for working with MCNP, you also need to pip install mcpl-extra, since those commands are no longer part of the basic mcpl package.

No matter how you have installed MCPL, you should now have commands like mcpltool and mcpl-config available. You can verify this by running commands:

$> mcpltool --help
$> mcpl-config --summary

If the commands above gave some sort of sensible output, and in particular if you did not get "command not found" or other errors, you are good to finally compile your filter programme. So in the folder where you have saved the myfilter.c file from above, you can simply run the command:

$> gcc myfilter.c $(mcpl-config --show buildflags) -o myfilterapp

This assumes you have the gcc command installed (on a mac you might want to use clang in place of gcc in the above command).

The result of the above command should be a binary programme called myfilterapp. You can run it on your MCPL file by for instance:

$> ./myfilterapp myoriginalfile.mcpl myfilteredfile.mcpl

Note that compared to other solutions suggested in this thread, I would personally always recommend the above since

1. It needs no software except MCPL (and arguably a C compiler)
2. It is non-lossy, meaning that you preserve all the bits of any retained particles exactly as they were on-disk in the original file. The other solutions suggested here are actually lossy, and will most certainly shuffle your on-disk bits (+ in some cases throw away meta data from the MCPL header).

Of course, once we have the often requested Py-API for writing such files, things might become even easier. But in the mean-time, I hope the above will work for you :-)

[AmChamb]

Hi @tkittel,

Thank you very much for the very detailed procedure. It was very straightforward to apply and the script provided can be used for more "filtering activities" in the future. That was all I needed :) !

Cheers,
Amalia