nikola/pairgoth
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge feature/local-club-pairing: nuanced local club geographic criteria

Browse Source
This commit is contained in:
Claude Brisson
2025-11-29 18:14:14 +01:00
parent 4788ef7bc9 174b3adb53
commit a256b9ad1f
3 changed files with 154 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
api-webapp/src/main/kotlin/org/jeudego/pairgoth/pairing/BasePairingHelper.kt
View File

@@ -66,12 +66,30 @@ abstract class BasePairingHelper(
}
// number of players in the biggest club and the biggest country
// this can be used to disable geocost if there is a majority of players from the same country or club
// this can be used to adjust geocost if there is a majority of players from the same country or club
private val clubCounts by lazy {
pairables.groupingBy { it.club?.take(4)?.uppercase() }.eachCount()
}
protected val biggestClubSize by lazy {
pairables.groupingBy { it.club }.eachCount().values.maxOrNull()!!
clubCounts.values.maxOrNull() ?: 0
}
protected val biggestCountrySize by lazy {
pairables.groupingBy { it.club }.eachCount().values.maxOrNull()!!
pairables.groupingBy { it.country }.eachCount().values.maxOrNull() ?: 0
}
// Local club detection: a club is "local" if it has more than the threshold proportion of players
protected val localClub: String? by lazy {
val threshold = pairing.geo.proportionMainClubThreshold
clubCounts.entries.find { (_, count) ->
count.toDouble() / pairables.size > threshold
}?.key
}
protected val hasLocalClub: Boolean get() = localClub != null
// Check if a player belongs to the local club
protected fun Pairable.isFromLocalClub(): Boolean {
val local = localClub ?: return false
return club?.take(4)?.uppercase() == local
}
// already paired players map

36
api-webapp/src/main/kotlin/org/jeudego/pairgoth/pairing/solver/Solver.kt
View File

@@ -443,14 +443,14 @@ sealed class Solver(
val geoMaxCost = pairing.geo.avoidSameGeo
val countryFactor: Int = if (legacyMode || biggestCountrySize.toDouble() / pairables.size <= proportionMainClubThreshold)
preferMMSDiffRatherThanSameCountry
else
0
val clubFactor: Int = if (legacyMode || biggestClubSize.toDouble() / pairables.size <= proportionMainClubThreshold)
preferMMSDiffRatherThanSameClub
else
0
// Country factor: in legacy mode or when no dominant country, use normal factor
val countryFactor: Int = if (legacyMode || biggestCountrySize.toDouble() / pairables.size <= proportionMainClubThreshold)
preferMMSDiffRatherThanSameCountry
else
0
// Club factor: always use the configured value
val clubFactor: Int = preferMMSDiffRatherThanSameClub
//val groupFactor: Int = preferMMSDiffRatherThanSameClubsGroup
// Same country
@@ -463,24 +463,38 @@ sealed class Solver(
// Same club and club group (TODO club group)
var clubRatio = 0.0
// To match OpenGotha, only do a case insensitive comparison of the first four characters.
// But obviously, there is a margin of improvement here towards some way of normalizing clubs.
val commonClub = p1.club?.take(4)?.uppercase() == p2.club?.take(4)?.uppercase()
val commonGroup = false // TODO
if (commonGroup && !commonClub) {
// Local club adjustment: when local club exists (non-legacy mode), treat local club
// members pairing together as if they were from different clubs (give them the bonus).
// Strangers from the same visiting club still get no bonus (normal same-club behavior).
val effectiveCommonClub: Boolean = if (!legacyMode && hasLocalClub && commonClub) {
val p1Local = p1.isFromLocalClub()
val p2Local = p2.isFromLocalClub()
// Both from local club: treat as different clubs (effectiveCommonClub = false)
// Both strangers from same club: normal same-club (effectiveCommonClub = true)
// Mixed (one local, one stranger): treat as different (effectiveCommonClub = false)
!p1Local && !p2Local
} else {
commonClub
}
if (commonGroup && !effectiveCommonClub) {
clubRatio = if (clubFactor == 0) {
0.0
} else {
clubFactor.toDouble() / 2.0 / placementScoreRange.toDouble()
}
} else if (!commonGroup && !commonClub) {
} else if (!commonGroup && !effectiveCommonClub) {
clubRatio = if (clubFactor == 0) {
0.0
} else {
clubFactor.toDouble() * 1.2 / placementScoreRange.toDouble()
}
}
// else: effectiveCommonClub = true → clubRatio stays 0 (no bonus for same club)
clubRatio = min(clubRatio, 1.0)
// TODO Same family

108
api-webapp/src/test/kotlin/LocalClubTest.kt Normal file
View File

@@ -0,0 +1,108 @@
package org.jeudego.pairgoth.test
import com.republicate.kson.Json
import org.jeudego.pairgoth.model.ID
import org.junit.jupiter.api.Test
import kotlin.test.assertEquals
import kotlin.test.assertTrue
/**
* Test for local club behavior in geographical pairing criteria.
*
* When a club has more than 40% of players (proportionMainClubThreshold),
* it's considered the "local club" and geographical penalties are adjusted:
* - Two players from the local club: no club penalty
* - Two "strangers" (not from local club) with same club: half penalty
* - Players from different clubs: no bonus (like when threshold exceeded)
*/
class LocalClubTest : TestBase() {
companion object {
// Tournament with MacMahon pairing to test geographical criteria
val localClubTournament = Json.Object(
"type" to "INDIVIDUAL",
"name" to "Local Club Test",
"shortName" to "local-club-test",
"startDate" to "2024-01-01",
"endDate" to "2024-01-01",
"country" to "FR",
"location" to "Test Location",
"online" to false,
"timeSystem" to Json.Object(
"type" to "SUDDEN_DEATH",
"mainTime" to 3600
),
"rounds" to 1,
"pairing" to Json.Object(
"type" to "MAC_MAHON",
"mmFloor" to -20,
"mmBar" to 0
)
)
// Helper to create a player
fun player(name: String, firstname: String, rating: Int, rank: Int, club: String, country: String = "FR") = Json.Object(
"name" to name,
"firstname" to firstname,
"rating" to rating,
"rank" to rank,
"country" to country,
"club" to club,
"final" to true
)
}
@Test
fun `local club detection with more than 40 percent`() {
// Create tournament
var resp = TestAPI.post("/api/tour", localClubTournament).asObject()
val tourId = resp.getInt("id") ?: throw Error("tournament creation failed")
// Add 10 players: 5 from "LocalClub" (50% > 40% threshold),
// 2 strangers from "VisitorA", 2 strangers from "VisitorB", 1 from "Solo"
val playerIds = mutableListOf<ID>()
// 5 local club players (50%) - all same rank to be in same group
for (i in 1..5) {
resp = TestAPI.post("/api/tour/$tourId/part", player("Local$i", "Player", 100, -10, "LocalClub")).asObject()
assertTrue(resp.getBoolean("success")!!)
playerIds.add(resp.getInt("id")!!)
}
// 2 visitors from VisitorA club
for (i in 1..2) {
resp = TestAPI.post("/api/tour/$tourId/part", player("VisitorA$i", "Player", 100, -10, "VisitorA")).asObject()
assertTrue(resp.getBoolean("success")!!)
playerIds.add(resp.getInt("id")!!)
}
// 2 visitors from VisitorB club
for (i in 1..2) {
resp = TestAPI.post("/api/tour/$tourId/part", player("VisitorB$i", "Player", 100, -10, "VisitorB")).asObject()
assertTrue(resp.getBoolean("success")!!)
playerIds.add(resp.getInt("id")!!)
}
// 1 solo player
resp = TestAPI.post("/api/tour/$tourId/part", player("Solo", "Player", 100, -10, "SoloClub")).asObject()
assertTrue(resp.getBoolean("success")!!)
playerIds.add(resp.getInt("id")!!)
assertEquals(10, playerIds.size, "Should have 10 players")
// Generate pairing with weights output
val outputFile = getOutputFile("local-club-weights.txt")
val games = TestAPI.post("/api/tour/$tourId/pair/1?weights_output=$outputFile", Json.Array("all")).asArray()
// Verify we got 5 games (10 players / 2)
assertEquals(5, games.size, "Should have 5 games")
// Read and verify the weights file exists
assertTrue(outputFile.exists(), "Weights file should exist")
// The key verification is that the test completes without errors
// and that local club players can be paired together
// (The BOSP2024 test verifies the detailed behavior matches expected DUDD outcomes)
logger.info("Local club test completed successfully with ${games.size} games")
}
}