Page MenuHomeHEPForge
Files F10881874

No OneTemporary
Actions

View Options

diff --git a/t/test_colours2.cc b/t/test_colours2.cc
index e590a4f..b7b4355 100644
--- a/t/test_colours2.cc
+++ b/t/test_colours2.cc
@@ -1,236 +1,346 @@
/**
* \authors The HEJ collaboration (see AUTHORS for details)
* \date 2020
* \copyright GPLv2 or later
*/
#include <array>
+#include <bitset>
#include <stdlib.h>
#include <string>
#include <vector>
#include "HEJ/Event.hh"
#include "HEJ/Constants.hh"
+#include "HEJ/Mixmax.hh"
#include "hej_test.hh"
namespace {
const fastjet::JetDefinition jet_def{fastjet::JetAlgorithm::antikt_algorithm, 0.4};
const double min_jet_pt{30.};
struct colour_flow {
std::array<std::string,2> incoming;
std::vector<std::string> outgoing;
std::string colour;
HEJ::Event to_event(){
using namespace HEJ;
auto event = parse_configuration(incoming, outgoing);
- if(colour.size()==0)
+ if(colour.size()==0) // no colour -> only parse
return event.cluster(jet_def,min_jet_pt);
ASSERT(colour.front()=='a' && colour.back()=='a'); // only closed loops
event.sort();
// fill colours with dummy value
for(auto & p: event.incoming)
p.colour = Colour{-1, -1};
for(auto & p: event.outgoing)
p.colour = Colour{-1, -1};
int current_colour = COLOUR_OFFSET;
int backup_colour = current_colour;
Particle* last_part = &event.incoming.front();
// loop connections
for(auto const & entry: colour){
if(entry == '_'){ // '_' -> skip connection
backup_colour = current_colour;
current_colour = 0;
continue;
}
auto & part = get_particle(event, entry);
part.colour->first = last_part->colour->second = current_colour;
current_colour = ++backup_colour;
last_part = &part;
}
for(auto & in: event.incoming)
std::swap(in.colour->first, in.colour->second);
// reset untouched colours
for(auto & out: event.outgoing)
if(out.colour->first == -1 && out.colour->second ==-1)
out.colour = {};
shuffle_particles(event);
return event.cluster(jet_def,min_jet_pt);
}
private:
HEJ::Particle & get_particle(
HEJ::Event::EventData & event, char const name
){
if(name == 'a')
return event.incoming[0];
if(name == 'b')
return event.incoming[1];
size_t idx = name-'0';
ASSERT(idx<event.outgoing.size());
return event.outgoing[idx];
}
};
const colour_flow FKL_ggg{{"g","g"},{"g","g","g"},{}};
const colour_flow FKL_qgq{{"1","2"},{"1","g","2"},{}};
const colour_flow FKL_qxgqx{{"-1","-2"},{"-1","g","-2"},{}};
const colour_flow FKL_qhgq{{"1","2"},{"1","h","g","2"},{}};
const colour_flow uno_gqgq{{"1","2"},{"g","1","g","2"},{}};
const colour_flow uno_qgqg{{"1","2"},{"1","g","2","g"},{}};
const colour_flow uno_Wgqq{{"2","2"},{"W+","g","1","2"},{}};
const colour_flow uno_gWqq{{"2","2"},{"g","W+","1","2"},{}};
const colour_flow uno_gqWq{{"2","2"},{"g","1","W+","2"},{}};
const colour_flow uno_qWqg{{"2","2"},{"1","W+","2","g"},{}};
const colour_flow uno_qqWg{{"2","2"},{"1","2","W+","g"},{}};
const colour_flow uno_qqgW{{"2","2"},{"1","2","g","W+"},{}};
const colour_flow qqx_qxqgq{{"g","2"},{"-1","1","g","2"},{}};
const colour_flow qqx_qgqqx{{"1","g"},{"1","g","2","-2"},{}};
const colour_flow qqx_qgqxq{{"1","g"},{"1","g","-2","2"},{}};
const colour_flow qqx_Wqxqq{{"g","2"},{"W+","-2","1","2"},{}};
const colour_flow qqx_qxWqq{{"g","2"},{"-2","W+","1","2"},{}};
const colour_flow qqx_qxqWq{{"g","2"},{"-2","1","W+","2"},{}};
const colour_flow qqx_qWqqx{{"2","g"},{"1","W+","2","-2"},{}};
const colour_flow qqx_qqWqx{{"2","g"},{"1","2","W+","-2"},{}};
const colour_flow qqx_qqqxW{{"2","g"},{"1","2","-2","W+"},{}};
const colour_flow qqx_gqqxq{{"g","2"},{"g","3","-3","2"},{}};
const colour_flow qqx_qqxqg{{"1","g"},{"1","-3","3","g"},{}};
const colour_flow qqx_qqxqqx{{"1","-1"},{"1","-1","1","-1"},{}};
const colour_flow qqx_qWqxqqx{{"2","-1"},{"1","W+","-1","1","-1"},{}};
const colour_flow qqx_qqxWqqx{{"2","-1"},{"1","-1","W+","1","-1"},{}};
const colour_flow qqx_qqxqWqx{{"2","-1"},{"1","-1","1","W+","-1"},{}};
+ HEJ::Mixmax rng;
void verify_colour(colour_flow configuration, std::string line,
bool const expectation = true
){
configuration.colour = std::move(line);
auto const event = configuration.to_event();
if(event.is_leading_colour() != expectation){
std::cerr << "Expected "<< (expectation?"":"non-") <<"leading colour\n"
<< event
<< "\nwith connection: " << configuration.colour << "\n";
throw std::logic_error("Colour verification failed");
}
}
+ int find_colour(HEJ::Event const & evt, int const colour){
+ if(evt.incoming()[0].colour->second==colour)
+ return -1;
+ if(evt.incoming()[1].colour->second==colour)
+ return -2;
+ for(size_t i=0;i<evt.outgoing().size();++i){
+ HEJ::Particle const & out = evt.outgoing()[i];
+ if(!out.colour)
+ continue;
+ if(out.colour->first == colour)
+ return i;
+ }
+ return -3;
+ }
+
+ int find_anticolour(HEJ::Event const & evt, int const anticolour){
+ if(evt.incoming()[0].colour->first==anticolour)
+ return -1;
+ if(evt.incoming()[1].colour->first==anticolour)
+ return -2;
+ for(size_t i=0;i<evt.outgoing().size();++i){
+ HEJ::Particle const & out = evt.outgoing()[i];
+ if(!out.colour)
+ continue;
+ if(out.colour->second == anticolour)
+ return i;
+ }
+ return -3;
+ }
+
+ bool matching_colours(HEJ::Event const & evt1, HEJ::Event const & evt2){
+ ASSERT(evt1.outgoing().size()==evt2.outgoing().size());
+ for(size_t i=0; i<2;++i){
+ HEJ::optional<HEJ::Colour> col1 = evt1.incoming()[i].colour;
+ HEJ::optional<HEJ::Colour> col2 = evt2.incoming()[i].colour;
+ ASSERT(col1);
+ ASSERT(col2);
+ int idx1 = find_colour(evt1, col1->first);
+ int idx2 = find_colour(evt2, col2->first);
+ if(idx1 == -3 || idx2 == -3)
+ return false;
+ if(idx1!=idx2){
+ return false;
+ }
+ idx1 = find_anticolour(evt1, col1->second);
+ idx2 = find_anticolour(evt2, col2->second);
+ if(idx1 == -3 || idx2 == -3)
+ return false;
+ if(idx1!=idx2)
+ return false;
+ }
+ for(size_t i=0; i<evt1.outgoing().size();++i){
+ HEJ::optional<HEJ::Colour> col1 = evt1.outgoing()[i].colour;
+ HEJ::optional<HEJ::Colour> col2 = evt2.outgoing()[i].colour;
+ if(!col1){
+ if(!col2) continue;
+ return false;
+ }
+ if(!col2)
+ return false;
+ int idx1 = find_colour(evt1, col1->second);
+ int idx2 = find_colour(evt2, col2->second);
+ if(idx1 == -3 || idx2 == -3)
+ return false;
+ if(idx1!=idx2)
+ return false;
+ idx1 = find_anticolour(evt1, col1->first);
+ idx2 = find_anticolour(evt2, col2->first);
+ if(idx1 == -3 || idx2 == -3)
+ return false;
+ if(idx1!=idx2)
+ return false;
+ }
+ return true;
+ }
+
void all_colours_possible(
colour_flow momenta, std::vector<std::string> allowed
){
std::vector<HEJ::Event> possible;
- for(auto & line: allowed){
- momenta.colour = std::move(line);
+ for(auto const & line: allowed){
+ momenta.colour = line;
possible.push_back(momenta.to_event());
if(!possible.back().is_leading_colour()){
std::cerr << "Expected leading colour\n"
<< possible.back()
<< "\nwith connection: " << momenta.colour << "\n";
throw std::logic_error("Colour verification failed");
}
}
+ momenta.colour = "";
+ ASSERT(possible.size()<16); // sooo magic
+ std::bitset<16> missing = (1<<(possible.size()))-1;
+ size_t max_tries = possible.size()*10;
+ // brute force generation of specific colour flow
+ while(missing != 0 && max_tries>0){
+ --max_tries;
+ HEJ::Event test_evt = momenta.to_event();
+ test_evt.generate_colours(rng);
+ size_t i=0;
+ for(; i<possible.size();++i){
+ if(matching_colours(test_evt, possible[i])){
+ missing[i]=0;
+ break;
+ }
+ }
+ if(i==possible.size()){
+ std::cerr << "Could not find allowed connection for\n"
+ << test_evt << std::endl;
+ throw std::logic_error("Unknown colour flow");
+ }
+
+ }
+ if(max_tries<=0){
+ std::cerr << "Not all connections found missing:" << std::endl;
+ for(size_t i=0; i<16; ++i){
+ if(missing[i])
+ std::cerr << allowed[i] << "\n" << possible[i] << std::endl;
+ }
+ throw std::logic_error("Missing colour flow");
+ }
}
}
int main() {
// FKL
all_colours_possible(FKL_ggg, {"a012ba","a01b2a","a02b1a","a0b21a",
"a12b0a","a1b20a","a2b10a","ab210a"});
all_colours_possible(FKL_qgq, {"a12_b0_a", "a2_b10_a"});
all_colours_possible(FKL_qxgqx, {"a_01b_2a", "a_0b_21a"});
all_colours_possible(FKL_qhgq, {"a23_b0_a", "a3_b20_a"});
// uno
all_colours_possible(uno_gqgq, {"a023_b1_a","a03_b21_a",
"a23_b01_a","a3_b201_a"}); // u-channel
all_colours_possible(uno_qgqg, {"a12_b30_a","a2_b310_a",
"a132_b0_a","a32_b10_a"}); // u-channel
all_colours_possible(uno_Wgqq, {"a13_b2_a","a3_b12_a"});
all_colours_possible(uno_gWqq, {"a03_b2_a","a3_b02_a"});
all_colours_possible(uno_gqWq, {"a03_b1_a","a3_b01_a"});
all_colours_possible(uno_qWqg, {"a2_b30_a","a32_b0_a"});
all_colours_possible(uno_qqWg, {"a1_b30_a","a31_b0_a"});
all_colours_possible(uno_qqgW, {"a1_b20_a","a21_b0_a"});
// extremal qqx
all_colours_possible(qqx_qgqqx, {"a12_3b0_a","a2_3b10_a",
"a1b2_30_a","ab2_310_a"}); // u-channel
all_colours_possible(qqx_qgqxq, {"a1b3_20_a", "ab3_210_a",
"a13_2b0_a","a3_2b10_a"}); // u-channel
all_colours_possible(qqx_qxqgq, {"a23_b1_0a","a3_b21_0a",
"a1_023_ba","a1_03_b2a"}); // u-channel
all_colours_possible(qqx_Wqxqq, {"a3_b2_1a","a2_13_ba"});
all_colours_possible(qqx_qxWqq, {"a3_b2_0a","a2_03_ba"});
all_colours_possible(qqx_qxqWq, {"a3_b1_0a","a1_03_ba"});
all_colours_possible(qqx_qWqqx, {"a2_3b0_a","ab2_30_a"});
all_colours_possible(qqx_qqWqx, {"a1_3b0_a","ab1_30_a"});
all_colours_possible(qqx_qqqxW, {"a1_2b0_a","ab1_20_a"});
// central qqx
all_colours_possible(qqx_gqqxq, {"a01_23_ba","a1_23_b0a",
"a03_b1_2a","a3_b1_20a"}); // u-channel
all_colours_possible(qqx_qqxqg, {"a3b2_10_a","ab32_10_a",
"a2_13b0_a","a2_1b30_a"}); // u-channel
all_colours_possible(qqx_qqxqqx, {"ab_32_10_a","a2_1b_30_a"});
all_colours_possible(qqx_qWqxqqx, {"ab_43_20_a","a3_2b_40_a"});
all_colours_possible(qqx_qqxWqqx, {"ab_43_10_a","a3_1b_40_a"});
all_colours_possible(qqx_qqxqWqx, {"ab_42_10_a","a2_1b_40_a"});
// forbidden
// crossed FKL
verify_colour(FKL_ggg, "a021ba",false);
verify_colour(FKL_ggg, "a0b12a",false);
verify_colour(FKL_ggg, "a10b2a",false);
verify_colour(FKL_ggg, "a1b02a",false);
verify_colour(FKL_ggg, "a20b1a",false);
verify_colour(FKL_ggg, "a21b0a",false);
verify_colour(FKL_ggg, "a2b01a",false);
verify_colour(FKL_ggg, "ab120a",false);
// quark with anti-colour
verify_colour(FKL_qgq, "a_01b_2a",false);
verify_colour(FKL_qgq, "a_0b_21a",false);
verify_colour(FKL_qxgqx, "a12_b0_a",false);
verify_colour(FKL_qxgqx, "a2_b10_a",false);
// higgs with colour
verify_colour(FKL_qhgq, "a123_b0_a",false);
verify_colour(FKL_qhgq, "a3_1_b20_a",false);
verify_colour(FKL_qhgq, "a3_11_b20_a",false);
// not-connected
verify_colour(FKL_ggg, "a012a",false);
verify_colour(FKL_ggg, "a012aa",false);
verify_colour(FKL_ggg, "a01ba",false);
verify_colour(FKL_ggg, "a0b2a",false);
verify_colour(FKL_ggg, "a_01b2a",false);
verify_colour(FKL_ggg, "a01_b2a",false);
verify_colour(FKL_ggg, "a0b_12a",false);
verify_colour(FKL_ggg, "a012b_a",false);
verify_colour(uno_gqgq, "a_1023_ba",false);
// uno
verify_colour(uno_gqgq, "a203_b1_a",false);
verify_colour(uno_qgqg, "a312_b0_a",false);
// extremal qqx
verify_colour(qqx_qgqqx, "a10_3b2_a",false);
verify_colour(qqx_qgqqx, "a2_31b0_a",false);
verify_colour(qqx_qgqqx, "a2_31b0_a",false);
verify_colour(qqx_qgqxq, "ab13_20_a",false);
verify_colour(qqx_qxqgq, "a3_b1_02a",false);
verify_colour(qqx_qxqgq, "a21_b3_0a",false);
// central qqx
verify_colour(qqx_gqqxq, "a1_203_ba",false);
verify_colour(qqx_gqqxq, "a3_21_b0a",false);
verify_colour(qqx_qqxqg, "ab2_130_a",false);
verify_colour(qqx_qqxqg, "a3b0_12_a",false);
verify_colour(qqx_qqxqqx, "a0_1b_32_a",false);
verify_colour(qqx_qqxqqx, "a0_3b_12_a",false);
verify_colour(qqx_qqxqqx, "a2_3b_10_a",false);
verify_colour(qqx_qqxqqx, "ab_12_30_a",false);
return EXIT_SUCCESS;
}

File Metadata

Mime Type
text/x-diff
Expires
Sat, May 3, 6:54 AM (1 d, 3 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
4962166
Default Alt Text
(12 KB)

Event Timeline