fix: remove remains of normal distribution score calculation

Author: FreekBes

prisma/schema.prisma

@@ -97,7 +97,7 @@ model CodamCoalitionScore {
 model CodamCoalitionSeasonResult {
 	id               Int      @id @default(autoincrement())
 	coalition_id     Int
-	score            Int      // NOT the same as the sum of all scores, but the score after applying the normal distribution
+	score            Int      // NOT the same as the sum of all scores, but the average score of all active contributors at the end of the season
 	bloc_deadline_id Int
 
 	created_at       DateTime @default(now())

src/routes/charts.ts

@@ -151,35 +151,6 @@ export const generateChartCoalitionScoreHistory = async function(prisma: PrismaC
 					// @ts-ignore
 					tension: 0.25,
 				},
-				/*
-				{
-					label: 'Average points',
-					data: Object.values(dataPoints).map((score) => score.avgPoints),
-					// borderColor: coalition.color ? coalition.color : '#808080',
-					// backgroundColor: coalition.color ? coalition.color : '#808080',
-					fill: false,
-					// @ts-ignore
-					tension: 0.25,
-				},
-				{
-					label: 'Standard deviation',
-					data: Object.values(dataPoints).map((score) => score.stdDevPoints),
-					// borderColor: coalition.color ? coalition.color : '#808080',
-					// backgroundColor: coalition.color ? coalition.color : '#808080',
-					fill: false,
-					// @ts-ignore
-					tension: 0.25,
-				},
-				{
-					label: 'Min active points',
-					data: Object.values(dataPoints).map((score) => score.minActivePoints),
-					// borderColor: coalition.color ? coalition.color : '#808080',
-					// backgroundColor: coalition.color ? coalition.color : '#808080',
-					fill: false,
-					// @ts-ignore
-					tension: 0.25,
-				},
-				*/
 			],
 		},
 		options: {

src/sync/results.ts

@@ -1,6 +1,6 @@
 import Fast42 from '@codam/fast42';
 import { NODE_ENV } from '../env';
-import { getRanking, getScoresNormalDistribution, getUsersScores, RANKING_MAX } from '../utils';
+import { getRanking, getScoreStatistics, getUsersScores, RANKING_MAX } from '../utils';
 import { prisma } from './base';
 
 export const calculateResults = async function(api: Fast42): Promise<void> {
@@ -56,7 +56,7 @@ export const calculateResults = async function(api: Fast42): Promise<void> {
 			}
 
 			// Entire coalition score
-			const score = await getScoresNormalDistribution(prisma, coalition.id, season.end_at);
+			const score = await getScoreStatistics(prisma, coalition.id, season.end_at);
 			console.log(`   - Final score for coalition ${coalition.name} in season ${seasonName}: ${score.mean}`);
 			const result = await prisma.codamCoalitionSeasonResult.create({
 				data: {

src/utils.ts

@@ -338,11 +338,11 @@ export const getUserSeasonRanking = async function(prisma: PrismaClient, userId:
 	return userRanking + 1;
 };
 
-export interface NormalDistribution {
+export interface ScoreStatistics {
 	dataPoints: number[];
+	sum: number;
 	mean: number;
 	median: number;
-	stdDev: number;
 	min: number;
 	max: number;
 };
@@ -424,21 +424,21 @@ export const getUserScores = async function(prisma: PrismaClient, userId: number
 	return { userScores, totalScore };
 };
 
-const getEmptyNormalDistribution = function(): NormalDistribution {
+const getEmptyScoreStatistics = function(): ScoreStatistics {
 	return {
 		dataPoints: [],
+		sum: 0,
 		mean: 0,
 		median: 0,
-		stdDev: 0,
 		min: 0,
 		max: 0,
 	};
 };
 
-export const getScoresNormalDistribution = async function(prisma: PrismaClient, coalitionId: number, untilDate: Date = new Date()): Promise<NormalDistribution> {
+export const getScoreStatistics = async function(prisma: PrismaClient, coalitionId: number, untilDate: Date = new Date()): Promise<ScoreStatistics> {
 	const bloc = await getBlocAtDate(prisma, untilDate);
 	if (!bloc) { // No season currently ongoing
-		return getEmptyNormalDistribution();
+		return getEmptyScoreStatistics();
 	}
 	const scores = await prisma.codamCoalitionScore.groupBy({
 		by: ['user_id'],
@@ -459,22 +459,20 @@ export const getScoresNormalDistribution = async function(prisma: PrismaClient,
 		},
 	});
 	if (scores.length === 0) { // No scores for this coalition
-		return getEmptyNormalDistribution();
+		return getEmptyScoreStatistics();
 	}
 	// console.log(scores);
 	const scoresArray = scores.map(s => s._sum.amount ? s._sum.amount : 0);
 	const scoresSum = scoresArray.reduce((a, b) => a + b, 0);
 	const scoresMean = scoresSum / scoresArray.length;
 	const scoresMedian = scoresArray[Math.floor(scoresArray.length / 2)];
-	const scoresVariance = scoresArray.reduce((a, b) => a + Math.pow(b - scoresMean, 2), 0) / scoresArray.length;
-	const scoresStdDev = Math.sqrt(scoresVariance);
 	const scoresMin = Math.min(...scoresArray);
 	const scoresMax = Math.max(...scoresArray);
 	return {
 		dataPoints: scoresArray,
+		sum: scoresSum,
 		mean: scoresMean,
 		median: scoresMedian,
-		stdDev: scoresStdDev,
 		min: scoresMin,
 		max: scoresMax,
 	};
@@ -486,19 +484,14 @@ export interface CoalitionScore {
 	totalPoints: number;
 	avgPoints: number;
 	medianPoints: number;
-	stdDevPoints: number;
-	minActivePoints: number; // Minimum score for a user to be considered active
+	totalMembers: number;
 	totalContributors: number;
-	activeContributors: number;
 };
 
 export const getCoalitionScore = async function(prisma: PrismaClient, coalitionId: number, atDateTime: Date = new Date()): Promise<CoalitionScore> {
-	const normalDist = await getScoresNormalDistribution(prisma, coalitionId, atDateTime);
-	const minScore = Math.floor(normalDist.mean - normalDist.stdDev);
-	const activeScores = normalDist.dataPoints.filter(s => s >= minScore);
-	const fairScore = Math.floor(activeScores.reduce((a, b) => a + b, 0) / activeScores.length);
+	const scoreStatistics = await getScoreStatistics(prisma, coalitionId, atDateTime);
 
-	const totalActiveMembers = await prisma.intraCoalitionUser.count({
+	const totalMembers = await prisma.intraCoalitionUser.count({
 		where: {
 			coalition_id: coalitionId,
 			user: {
@@ -513,16 +506,16 @@ export const getCoalitionScore = async function(prisma: PrismaClient, coalitionI
 		},
 	});
 
+	const totalContributors = Math.min(scoreStatistics.dataPoints.length, totalMembers);
+
 	return {
 		coalition_id: coalitionId,
-		totalPoints: normalDist.dataPoints.reduce((a, b) => a + b, 0),
-		avgPoints: normalDist.mean,
-		medianPoints: normalDist.median,
-		stdDevPoints: normalDist.stdDev,
-		minActivePoints: minScore,
-		score: Math.floor(normalDist.mean), // fairScore can jump down too easily when there are a couple of really well scoring students on top of the leaderboard (scores dataset is not a normal distribution)
-		totalContributors: Math.min(normalDist.dataPoints.length, totalActiveMembers),
-		activeContributors: Math.min(activeScores.length, totalActiveMembers),
+		totalPoints: scoreStatistics.sum,
+		avgPoints: scoreStatistics.mean,
+		medianPoints: scoreStatistics.median,
+		score: Math.floor(scoreStatistics.sum / totalContributors),
+		totalMembers: totalMembers,
+		totalContributors: totalContributors,
 	};
 };
 

templates/admin/dashboard.njk

@@ -45,9 +45,9 @@
 							<li>Score: {{ coalitionScores[coalition.id].score | thousands }}</li>
 							<li>Total points: {{ coalitionScores[coalition.id].totalPoints | thousands }}</li>
 							<li>Total contributor count: {{ coalitionScores[coalition.id].totalContributors | thousands }}</li>
+							<li>Total member count: {{ coalitionScores[coalition.id].totalMembers | thousands }}</li>
 							<li>Average points: {{ coalitionScores[coalition.id].avgPoints | toFixed(2) | thousands }}</li>
 							<li>Median points: {{ coalitionScores[coalition.id].medianPoints | toFixed(2) | thousands }}</li>
-							<li>Standard deviation points: {{ coalitionScores[coalition.id].stdDevPoints | toFixed(2) | thousands }}</li>
 						</ul>
 						<ul>
 							{% for fixedType, score in coalitionScoresPerFixedType[coalition.id] %}

templates/coalition.njk

@@ -203,8 +203,9 @@
 				<div class="card-body p-2">
 					<ul>
 						<li>Total points: {{ coalitionScore.totalPoints | thousands }}</li>
-						<li>Active contributors: {{ coalitionScore.activeContributors | thousands }} <small class="text-muted">(any member who has contributed at least 1 point this season)</small></li>
-						<li>Average points: {{ coalitionScore.score | thousands }} <small class="text-muted">(this becomes the coalition score)</small></li>
+						<li>Total contributors: {{ coalitionScore.totalContributors | thousands }} <small class="text-muted">(any member who has contributed at least 1 point this season)</small></li>
+						<li>Average points: {{ coalitionScore.score | thousands }} <small class="text-muted">(this becomes the coalition score: total points / total contributors)</small></li>
+						<li>Total members: {{ coalitionScore.totalMembers | thousands }}</li>
 					</ul>
 				</div>
 			</div>