Crossing symmetry

.github/workflows/acceptancetest.yml

@@ -1389,3 +1389,101 @@ jobs:
             cd $GITHUB_WORKSPACE
             ./tests/test_manager.py test_density_mode_vs_standalone_LI1 -pA -t0 -l INFO
 
+
+
+  # ---------------------------------------------------------------------------
+  # Crossing symmetry (tests/acceptance_tests/test_standalone_cross_symmetry.py)
+  #
+  # Split by toolchain and cost. NOTE: test_manager.py exits 1 when a test is
+  # SKIPPED (not only when it fails), and the crossing tests self-skip when
+  # gfortran / f2py / g++ are missing -- so the toolchain steps below are not
+  # optional, they are what keeps these jobs green.
+  # ---------------------------------------------------------------------------
+  acceptancetest_crossing_static:
+    # The parts that only inspect generated code / python objects: the crossing
+    # partition of a multi-flavor process, the multi-channel config map that
+    # pairs a routed subprocess's channels with the base's diagrams, the
+    # canonical colour-flow code, and the outputs that cannot decode a crossing
+    # (they get the folded crossings expanded back instead). No compilation, so
+    # this is the fast smoke test.
+    #
+    # TestCrossingConfigMap earns its place here rather than in an integration
+    # job because what it guards is invisible downstream: a mis-paired config map
+    # leaves every matrix element and the cross section itself correct, and only
+    # degrades the multi-channel sampling, so no xsec comparison catches it
+    # reliably -- it shows up as a slow, unstable integration behind an error
+    # estimate that no longer means anything.
+    runs-on: ubuntu-24.04
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.fork == true
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/checkout_mg5
+      - uses: ./.github/actions/restore-pip-cache
+
+      - name: crossing partition / config map / colour-flow code / unsupported outputs
+        run: |
+            cd $GITHUB_WORKSPACE
+            ./tests/test_manager.py -pA TestCrossingPartition TestCrossingConfigMap TestColorFlowCode TestCrossingUnsupportedOutput -t0 -l INFO
+
+
+  acceptancetest_crossing_fortran:
+    # The fortran standalone reference suite: a crossed SMATRIX call must
+    # reproduce the process it crosses into (2->2 and 2->3, every merged flavor,
+    # split orders), the density matrix must follow the crossing, an s-channel
+    # constraint must disable the machinery, and the good-helicity sets must obey
+    # the crossing's row permutation. TestGoodHelCParityDedup rides along (same
+    # backend, ~10s): the C-parity de-duplication of the helicity sum must hold
+    # where it engages and refuse itself where the pairs do not match.
+    # Needs gfortran AND f2py (restore-pip-cache provides meson/ninja and sets
+    # f2py_compiler); the f2py-backed tests skip without it, which fails the job.
+    runs-on: ubuntu-24.04
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.fork == true
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/checkout_mg5
+      - uses: ./.github/actions/restore-pip-cache
+
+      - name: crossing symmetry + C-parity good-helicity dedup, fortran standalone
+        run: |
+            cd $GITHUB_WORKSPACE
+            ./tests/test_manager.py -pA TestStandaloneCrossSymmetry TestGoodHelCParityDedup -t0 -l INFO
+
+
+  acceptancetest_crossing_cpp:
+    # The two C++ backends (standalone_cpp and standalone_mg7/madmatrix, incl.
+    # the per-event mixed-crossing SIMD page) plus the `check crossing`
+    # subcommand end to end over all three exporters.
+    runs-on: ubuntu-24.04
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.fork == true
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/checkout_mg5
+      - uses: ./.github/actions/restore-pip-cache
+
+      - name: crossing symmetry, C++ / madmatrix backends and `check crossing`
+        run: |
+            cd $GITHUB_WORKSPACE
+            ./tests/test_manager.py -pA TestStandaloneCppCrossSymmetry TestStandaloneMg7CrossSymmetry TestCheckCrossingCommand -t0 -l INFO
+
+
+  acceptancetest_standalone_mg7_openmp:
+    # The CPU sigmaKin loop of the madmatrix backend is an
+    # 'omp parallel for default( none )', so every variable it uses must be
+    # listed in its shared() clause or the generated CPPProcess.cc does not
+    # compile at all. Three of them were missing. Nothing noticed, because no
+    # build ever turns OpenMP on: it is opt-in (USEOPENMP=1, #758) and
+    # madmatrix.mk force-disables it on Darwin. This job compiles the generated
+    # file with OpenMP explicitly, so the shared() clause stays complete.
+    # Needs only a C++ compiler (no madspace, no heptools).
+    runs-on: ubuntu-24.04
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.fork == true
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/checkout_mg5
+      - uses: ./.github/actions/restore-pip-cache
+
+      - name: test one of the test test_standalone_mg7_openmp
+        run: |
+            cd $GITHUB_WORKSPACE
+            ./tests/test_manager.py test_standalone_mg7_openmp -pA -t0 -l INFO

.github/workflows/acceptancetest_madevent.yml

@@ -996,3 +996,94 @@ jobs:
         run: |
             cd $GITHUB_WORKSPACE
             ./tests/test_manager.py test_madevent_mssm_gogo -pA -t0 -l INFO
+
+
+  # ---------------------------------------------------------------------------
+  # Crossing symmetry, madevent end-to-end. Each of these runs one or more full
+  # (small) madevent generations, hence one job apiece.
+  # ---------------------------------------------------------------------------
+  acceptancetest_crossing_madevent_labels:
+    # The event LABELS a crossed subprocess writes to the LHE: the W+ helicity of
+    # p p > w+ j (the crossed leg is a massive vector, so a bad relabel scrambles
+    # it), the colour flow of u u~ > u u~ (98/2 asymmetric, so a swapped flow
+    # label is detectable), and the colour flow a within-group router CHOOSES
+    # (which mask it selects with, not just which label it writes).
+    runs-on: ubuntu-24.04
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.fork == true
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/checkout_mg5
+      - uses: ./.github/actions/restore-pip-cache
+
+      - name: crossed helicity and colour-flow labels written to the LHE
+        run: |
+            cd $GITHUB_WORKSPACE
+            ./tests/test_manager.py -pA TestMadeventCrossingHelicity TestMadeventColorFlowRatio -t0 -l INFO
+
+      # Separate step (and ~4 minutes of its own): a within-group router must
+      # RESELECT the colour flow with its own colour-config mask rather than
+      # relabel the one its base picked. Only an event-level comparison sees
+      # this -- the cross section agreed to 0.02% while ~10% of the affected
+      # flavour class carried a flow the --use_crossing=False build never picks
+      # -- so this integrates the process twice and compares the colour-topology
+      # distribution class by class.
+      - name: within-group router colour selection
+        run: |
+            cd $GITHUB_WORKSPACE
+            ./tests/test_manager.py -pA TestMadeventRouterColorSelection -t0 -l INFO
+
+
+  acceptancetest_crossing_madevent_xsec:
+    # The cross-section-level guards on the crossing router: each process is
+    # integrated twice (crossing-routed vs --use_crossing=False, same seed) and
+    # the two results must agree.
+    #   p p > w+ j, w+ > j j   decay chain riding on a crossed production
+    #   p p > t t~ j j         inclusive, and the only test that integrates the
+    #                          cross-GROUP (Track B) router
+    runs-on: ubuntu-24.04
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.fork == true
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/checkout_mg5
+      - uses: ./.github/actions/restore-pip-cache
+
+      - name: crossing cross-section regressions (decay chain + inclusive)
+        run: |
+            cd $GITHUB_WORKSPACE
+            ./tests/test_manager.py -pA TestMadeventDecayChainCrossing TestMadeventInclusiveCrossingXsec -t0 -l INFO
+
+
+  acceptancetest_crossing_reweight:
+    # The folded-subprocess layout of the default (crossing on) standalone output,
+    # and the reweighting of a sample whose events sit in a grouped subprocess
+    # where every merged leg is an anti-particle (the -81 label regression).
+    runs-on: ubuntu-24.04
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.fork == true
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/checkout_mg5
+      - uses: ./.github/actions/restore-pip-cache
+
+      - name: folded subprocesses + merged anti-particle labels in reweight
+        run: |
+            cd $GITHUB_WORKSPACE
+            ./tests/test_manager.py test_standalone_crossing_folds_qqx_subprocess test_reweight_merged_antiparticle_labels -pA -t0 -l INFO
+
+
+  acceptancetest_density_multicore:
+    # do_reweight splits the event file across jobs in multicore mode; each job
+    # writes the average density matrix of its own chunk and the mother interface
+    # has to recombine them into the canonical Average_density_matrix_*.txt.
+    # Generates 3000 events (> nevt_job) so the file is really split, then
+    # reweights twice (1 core vs 2) -- the slowest of the new jobs.
+    runs-on: ubuntu-24.04
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.fork == true
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/checkout_mg5
+      - uses: ./.github/actions/restore-pip-cache
+
+      - name: test one of the test test_density_mode_multicore
+        run: |
+            cd $GITHUB_WORKSPACE
+            ./tests/test_manager.py test_density_mode_multicore -pA -t0 -l INFO

.github/workflows/unittest.yml

@@ -733,3 +733,25 @@ jobs:
         run: |
             cd $GITHUB_WORKSPACE
             ./tests/test_manager.py test_generate_ewsud_ttbar test_generate_ewsud_ww test_generate_ewsud_zz -t0
+
+
+  unittest_34:
+    # Unit tests added with the crossing-symmetry feature:
+    #   tests/unit_tests/interface/test_reweight_density.py
+    #     (TestAverageDensityMatrix: the average-density-matrix helpers shared by
+    #      DensityInterface and CommonRunCmd.do_reweight's multicore recombination)
+    #   tests/unit_tests/various/test_reweight_interface.py
+    #     (TestPdgForMeCall: merged-particle labels, both signs, resolved to the
+    #      event's concrete PDGs before the fortran call)
+    # Pure python, no toolchain: the whole job is a couple of seconds.
+    runs-on: ubuntu-24.04
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.fork == true
+
+    steps:
+      - uses: actions/checkout@v5
+      - uses: ./.github/actions/restore-pip-cache
+
+      - name: reweight density / merged-label unit tests
+        run: |
+            cd $GITHUB_WORKSPACE
+            ./tests/test_manager.py TestAverageDensityMatrix TestPdgForMeCall -t0

.gitignore

@@ -79,3 +79,6 @@ nsqso_born.inc
 docs/build/
 tests/input_files/IOTestsComparison_BackUp/
 tests/input_files/IOTestsComparison/**/*.BackUp
+
+# output of ./tests/test_manager.py
+UNITTEST_proc/

MadSpin/decay.py

@@ -66,6 +66,30 @@
 logger = logging.getLogger('decay.stdout') # -> stdout
 logger_stderr = logging.getLogger('decay.stderr') # ->stderr
 
+import contextlib
+
+@contextlib.contextmanager
+def _no_merge_crossing():
+    """Temporarily disable crossing-symmetry folding (merge_crossing='record')
+    for the enclosed MG5 generation.
+
+    MadSpin's legacy full_decay_chain (madspin_v1) and onshell_v1 paths evaluate
+    the production matrix element through a PDG-dispatch interface (the
+    standalone_msP fortran driver / smatrixhel) that cannot reach a crossing-
+    folded subprocess, so their generation must keep every subprocess on its own
+    (as before the crossing feature).  The density path is crossing-aware and
+    keeps crossing on.  MG_MERGE_CROSSING=off is the documented escape hatch
+    (see madgraph_interface.do_add)."""
+    saved = os.environ.get('MG_MERGE_CROSSING')
+    os.environ['MG_MERGE_CROSSING'] = 'off'
+    try:
+        yield
+    finally:
+        if saved is None:
+            os.environ.pop('MG_MERGE_CROSSING', None)
+        else:
+            os.environ['MG_MERGE_CROSSING'] = saved
+
 import random 
 import math
 from madgraph import MG5DIR, MadGraph5Error
@@ -3097,11 +3121,12 @@ def generate_all_matrix_element(self):
 
         commandline = commandline.replace('add process', 'generate',1)
         logger.info(commandline)
-
-        mgcmd.exec_cmd(commandline, precmd=True)
+
+        with _no_merge_crossing():
+            mgcmd.exec_cmd(commandline, precmd=True)
         commandline = 'output standalone_msP %s %s' % \
-        (pjoin(path_me,'production_me'), ' '.join(list(self.list_branches.keys())))        
-        mgcmd.exec_cmd(commandline, precmd=True)        
+        (pjoin(path_me,'production_me'), ' '.join(list(self.list_branches.keys())))
+        mgcmd.exec_cmd(commandline, precmd=True)
         logger.info('Done %.4g' % (time.time()-start))
 
         # 3. Create all_ME + topology objects ----------------------------------
@@ -3181,7 +3206,8 @@ def generate_all_matrix_element(self):
                         commandline += self.get_proc_with_decay(proc, one_decay, mgcmd._curr_model, self.options)
                 commandline = commandline.replace('add process', 'generate',1)
             logger.info(commandline)
-            mgcmd.exec_cmd(commandline, precmd=True)
+            with _no_merge_crossing():
+                mgcmd.exec_cmd(commandline, precmd=True)
             # remove decay with 0 branching ratio.
             mgcmd.remove_pointless_decay(self.banner.param_card)
             commandline = 'output standalone_msF %s %s' % (pjoin(path_me,'full_me'),
@@ -5123,7 +5149,17 @@ def generate_all_matrix_element(self):
 
         commandline = commandline.replace('add process', 'generate',1)
         mgcmd = self.mgcmd
-        mgcmd.exec_cmd(commandline, precmd=True)
+        # The legacy onshell_v1 path (mode=='onshell') evaluates the production
+        # ME through smatrixhel, which dispatches on concrete PDGs and returns 0
+        # for a crossing-folded subprocess (-> production_me==0 -> ZeroDivision).
+        # Keep every subprocess on its own for it, exactly like full_decay_chain.
+        # The density path (mode=='density') is crossing-aware (GET_DENSITY_IDX
+        # via _resolve_crossed) and keeps crossing on.
+        if self.mode == 'onshell':
+            with _no_merge_crossing():
+                mgcmd.exec_cmd(commandline, precmd=True)
+        else:
+            mgcmd.exec_cmd(commandline, precmd=True)
         # remove decay with 0 branching ratio.
         #mgcmd.remove_pointless_decay(self.banner.param_card)
         #
@@ -5135,16 +5171,52 @@ def generate_all_matrix_element(self):
         # store information about matrix element
         for matrix_element in mgcmd._curr_matrix_elements.get_matrix_elements():
             me_string = matrix_element.get('processes')[0].shell_string()
-            for me in matrix_element.get('processes'):
-                dirpath = pjoin(path_me, ms_me_subdir, 'SubProcesses', "P%s" % me_string)
-                # get the orignal order:
-                initial = []
-                final = [l.get('id') for l in me.get_legs_with_decays()\
-                          if l.get('state') or initial.append(l.get('id'))]
+
+            def register(leg_ids, _pdir="P%s" % me_string):
+                # ``leg_ids`` is the ordered list of external PDG ids (initial
+                # then final, in leg order).  Build the (sorted) lookup tag and
+                # keep the natural leg order for momentum extraction.  A base
+                # process always wins over a crossed one, so never overwrite.
+                initial = [i for i, l in zip(leg_ids, order_state) if not l]
+                final = [i for i, l in zip(leg_ids, order_state) if l]
                 order = (tuple(initial), tuple(final))
-                initial.sort(), final.sort()
-                tag = (tuple(initial), tuple(final))
-                self.all_me[tag] = {'pdir': "P%s" % me_string, 'order': order}
+                tag = (tuple(sorted(initial)), tuple(sorted(final)))
+                self.all_me.setdefault(tag, {'pdir': _pdir, 'order': order})
+
+            for me in matrix_element.get('processes'):
+                legs = me.get_legs_with_decays()
+                order_state = [l.get('state') for l in legs]
+                register([l.get('id') for l in legs])
+
+            # Crossed subprocesses folded into this matrix element with crossing
+            # symmetry on (merge_crossing='record') were NOT generated as their
+            # own directory: only the representative partner is on disk.  Its
+            # crossing-aware SMATRIX (smatrixhel dispatches on the signed PDGs,
+            # see interface_madspin.calculate_matrix_element) can still compute
+            # them, so register each crossed process against the SAME pdir.
+            # Without this the onshell/density lookup misses e.g. the recorded
+            # q q~ > t t~ g (partner of the kept q g > t t~ q) and raises
+            # KeyError.  The decays never cross (they ride on their production
+            # leg), so re-attach the base decay chains before expanding, exactly
+            # as the exporter does for the check_sa crossing demo.
+            try:
+                crossed_processes = matrix_element.get('crossed_processes')
+            except Exception:
+                crossed_processes = []
+            base_decays = matrix_element.get('processes')[0].get('decay_chains')
+            for cross_entry in crossed_processes:
+                proc = cross_entry[0]
+                if base_decays:
+                    proc = copy.copy(proc)
+                    proc.set('decay_chains', base_decays)
+                    # empty LegList (same class as proc's legs) forces
+                    # get_legs_with_decays to recompute with the re-attached decays
+                    proc.set('legs_with_decays', proc.get('legs').__class__())
+                    legs = proc.get_legs_with_decays()
+                else:
+                    legs = proc.get('legs')
+                order_state = [l.get('state') for l in legs]
+                register([l.get('id') for l in legs])
 
         return self.all_me