Merge branch 'bug3641' into translation

java/com.sap.sailing.barbados.resultimport/src/com/sap/sailing/barbados/resultimport/impl/BarbadosResultSpreadsheet.java

@@ -41,9 +41,9 @@ public class BarbadosResultSpreadsheet {
             throw new IllegalArgumentException("Didn't find "+RACE_SCORE_COLUMN_NAME+" column");
         }
         final int numberOfRaces = i-COLUMN_NUMBER_OF_FIRST_RACE_RANK;
-        final int columnNumberOfNetScore = i;
+        final int columnNumberOfTotalScore = i;
-        final int columnNumberOfTotalScore = columnNumberOfNetScore+1;
+        final int columnNumberOfNetScore = columnNumberOfTotalScore+1;
-        final int columnNumberOfFirstRaceScore = columnNumberOfTotalScore+2;
+        final int columnNumberOfFirstRaceScore = columnNumberOfNetScore+2;
         int rowIndex = 1;
         Row row;
         String iocCountryCode;
@@ -53,8 +53,8 @@ public class BarbadosResultSpreadsheet {
             String helm = row.getCell(3).getStringCellValue();
             String crew = row.getCell(4).getStringCellValue();
             Iterable<String> names = Arrays.asList(new String[] { helm, crew });
-            double scoreAfterDiscarding = row.getCell(columnNumberOfTotalScore).getNumericCellValue();
+            double scoreAfterDiscarding = row.getCell(columnNumberOfNetScore).getNumericCellValue();
-            double netPointsBeforeDiscarding = row.getCell(columnNumberOfNetScore).getNumericCellValue();
+            double totalPointsBeforeDiscarding = row.getCell(columnNumberOfTotalScore).getNumericCellValue();
             List<CompetitorEntry> rankAndMaxPointsReasonAndPointsAndDiscarded = new ArrayList<>();
             for (int raceNumber=0; raceNumber<numberOfRaces; raceNumber++) {
                 final Cell rankOrMaxPointReasonCell = row.getCell(COLUMN_NUMBER_OF_FIRST_RACE_RANK+raceNumber);
@@ -78,7 +78,7 @@ public class BarbadosResultSpreadsheet {
                 }
             }
             CompetitorRow competitorRow = new CompetitorRowImpl(totalRank, sailID, names, scoreAfterDiscarding,
-                    netPointsBeforeDiscarding, rankAndMaxPointsReasonAndPointsAndDiscarded);
+                    totalPointsBeforeDiscarding, rankAndMaxPointsReasonAndPointsAndDiscarded);
             competitorRows.add(competitorRow);
             rowIndex++;
         }

java/com.sap.sailing.datamining/src/com/sap/sailing/datamining/impl/data/RaceResultOfCompetitorWithContext.java

@@ -66,7 +66,7 @@ public class RaceResultOfCompetitorWithContext implements HasRaceResultOfCompeti
         Leaderboard leaderboard = getLeaderboard();
         final TimePoint now = MillisecondsTimePoint.now();
         double competitorCount = Util.size(leaderboard.getCompetitors());
-        double points = leaderboard.getNetPoints(competitor, raceColumn, now);
+        double points = leaderboard.getTotalPoints(competitor, raceColumn, now);
         double relativeLowPoints = leaderboard.getScoringScheme().isHigherBetter() ?
                 competitorCount - points : points;
         final double result = relativeLowPoints / competitorCount;
@@ -167,7 +167,7 @@ public class RaceResultOfCompetitorWithContext implements HasRaceResultOfCompeti
     public Boolean isPodiumFinish() {
         Leaderboard leaderboard = getLeaderboard();
         final TimePoint now = MillisecondsTimePoint.now();
-        double points = leaderboard.getNetPoints(competitor, raceColumn, now);
+        double points = leaderboard.getTotalPoints(competitor, raceColumn, now);
         if (leaderboard.getScoringScheme().isHigherBetter()) {
             double competitorCount = Util.size(leaderboard.getCompetitors());
             return points >= (competitorCount - 2.05);
@@ -180,7 +180,7 @@ public class RaceResultOfCompetitorWithContext implements HasRaceResultOfCompeti
     public Boolean isWin() {
         Leaderboard leaderboard = getLeaderboard();
         final TimePoint now = MillisecondsTimePoint.now();
-        double points = leaderboard.getNetPoints(competitor, raceColumn, now);
+        double points = leaderboard.getTotalPoints(competitor, raceColumn, now);
         if (leaderboard.getScoringScheme().isHigherBetter()) {
             double competitorCount = Util.size(leaderboard.getCompetitors());
             return points >= (competitorCount - 0.05);

java/com.sap.sailing.domain.common/src/com/sap/sailing/domain/common/DetailType.java

@@ -40,7 +40,7 @@ public enum DetailType implements Serializable {
     TIME_ON_TIME_FACTOR(4, DESCENDING), TIME_ON_DISTANCE_ALLOWANCE_IN_SECONDS_PER_NAUTICAL_MILE(0, ASCENDING),
     TOTAL_DISTANCE_TRAVELED(0, ASCENDING), TOTAL_AVERAGE_SPEED_OVER_GROUND(2, DESCENDING),
     TOTAL_TIME_SAILED_IN_SECONDS(1, ASCENDING), RACE_CURRENT_SPEED_OVER_GROUND_IN_KNOTS(2, DESCENDING),
-    RACE_TOTAL_POINTS(2, ASCENDING), REGATTA_TOTAL_POINTS(2, ASCENDING), REGATTA_TOTAL_POINTS_SUM(2, ASCENDING),
+    RACE_NET_POINTS(2, ASCENDING), REGATTA_NET_POINTS(2, ASCENDING), REGATTA_NET_POINTS_SUM(2, ASCENDING),
     RACE_RATIO_BETWEEN_TIME_SINCE_LAST_POSITION_FIX_AND_AVERAGE_SAMPLING_INTERVAL(1, ASCENDING), RACE_DISTANCE_TO_START_FIVE_SECONDS_BEFORE_RACE_START(1, ASCENDING),
     RACE_SPEED_OVER_GROUND_FIVE_SECONDS_BEFORE_START(2, DESCENDING),
     RACE_CALCULATED_TIME_TRAVELED(0, ASCENDING), RACE_CALCULATED_TIME_AT_ESTIMATED_ARRIVAL_AT_COMPETITOR_FARTHEST_AHEAD(0, ASCENDING),

java/com.sap.sailing.domain.common/src/com/sap/sailing/domain/common/dto/AbstractLeaderboardDTO.java

@@ -106,23 +106,23 @@ public abstract class AbstractLeaderboardDTO implements Serializable {
     public boolean scoredInMedalRace(CompetitorDTO competitor) {
         LeaderboardRowDTO row = rows.get(competitor);
         for (RaceColumnDTO race : races) {
-            if (race.isMedalRace() && row.fieldsByRaceColumnName.get(race.getRaceColumnName()).totalPoints > 0) {
+            if (race.isMedalRace() && row.fieldsByRaceColumnName.get(race.getRaceColumnName()).netPoints > 0) {
                 return true;
             }
         }
         return false;
     }
 
-    public Double getNetPoints(CompetitorDTO competitor, String nameOfLastRaceSoFar) {
+    public Double getTotalPoints(CompetitorDTO competitor, String nameOfLastRaceSoFar) {
-        Double netPoints = null;
+        Double totalPoints = null;
-        LeaderboardRowDTO row = rows.get(competitor);
+        final LeaderboardRowDTO row = rows.get(competitor);
         if (row != null) {
             LeaderboardEntryDTO field = row.fieldsByRaceColumnName.get(nameOfLastRaceSoFar);
-            if (field != null &&  field.netPoints != null) {
+            if (field != null &&  field.totalPoints != null) {
-                netPoints = field.netPoints;
+                totalPoints = field.totalPoints;
             }
         }
-        return netPoints;
+        return totalPoints;
     }
 
     public boolean raceIsTracked(String raceColumnName) {

java/com.sap.sailing.domain.common/src/com/sap/sailing/domain/common/dto/LeaderboardEntryDTO.java

@@ -30,15 +30,15 @@ public class LeaderboardEntryDTO implements Serializable {
      */
     public MaxPointsReason reasonForMaxPoints;
     
-    public Double netPoints;
+    public Double totalPoints;
-    public Double netPointsUncorrected;
+    public Double totalPointsUncorrected;
     
     /**
-     * Tells if the net points have been overridden by a score correction. Can be used to render differently in editing environment.
+     * Tells if the total points have been overridden by a score correction. Can be used to render differently in editing environment.
      */
-    public boolean netPointsCorrected;
+    public boolean totalPointsCorrected;
     
-    public Double totalPoints;
+    public Double netPoints;
     
     public boolean discarded;
     
@@ -130,7 +130,7 @@ public class LeaderboardEntryDTO implements Serializable {
     public LeaderboardEntryDTO() { }
     
     public boolean hasScoreCorrection() {
-        return netPointsCorrected || (reasonForMaxPoints != null && reasonForMaxPoints != MaxPointsReason.NONE);
+        return totalPointsCorrected || (reasonForMaxPoints != null && reasonForMaxPoints != MaxPointsReason.NONE);
     }
 
     @Override
@@ -162,9 +162,9 @@ public class LeaderboardEntryDTO implements Serializable {
                         .hashCode());
         result = prime * result + ((fleet == null) ? 0 : fleet.hashCode());
         result = prime * result + ((legDetails == null) ? 0 : legDetails.hashCode());
-        result = prime * result + ((netPoints == null) ? 0 : netPoints.hashCode());
+        result = prime * result + ((totalPoints == null) ? 0 : totalPoints.hashCode());
-        result = prime * result + ((netPointsUncorrected == null) ? 0 : netPointsUncorrected.hashCode());
+        result = prime * result + ((totalPointsUncorrected == null) ? 0 : totalPointsUncorrected.hashCode());
-        result = prime * result + (netPointsCorrected ? 1231 : 1237);
+        result = prime * result + (totalPointsCorrected ? 1231 : 1237);
         result = prime * result + ((race == null) ? 0 : race.hashCode());
         result = prime * result + ((reasonForMaxPoints == null) ? 0 : reasonForMaxPoints.hashCode());
         result = prime
@@ -176,7 +176,7 @@ public class LeaderboardEntryDTO implements Serializable {
         result = prime * result + ((startTack == null) ? 0 : startTack.hashCode());
         result = prime * result + ((averageSamplingInterval == null) ? 0 : averageSamplingInterval.hashCode());
         result = prime * result + ((timeSinceLastPositionFixInSeconds == null) ? 0 : timeSinceLastPositionFixInSeconds.hashCode());
-        result = prime * result + ((totalPoints == null) ? 0 : totalPoints.hashCode());
+        result = prime * result + ((netPoints == null) ? 0 : netPoints.hashCode());
         result = prime
                 * result
                 + ((windwardDistanceToCompetitorFarthestAheadInMeters == null) ? 0 : windwardDistanceToCompetitorFarthestAheadInMeters
@@ -250,17 +250,17 @@ public class LeaderboardEntryDTO implements Serializable {
                 return false;
         } else if (!legDetails.equals(other.legDetails))
             return false;
-        if (netPoints == null) {
+        if (totalPoints == null) {
-            if (other.netPoints != null)
+            if (other.totalPoints != null)
                 return false;
-        } else if (!netPoints.equals(other.netPoints))
+        } else if (!totalPoints.equals(other.totalPoints))
             return false;
-        if (netPointsUncorrected == null) {
+        if (totalPointsUncorrected == null) {
-            if (other.netPointsUncorrected != null)
+            if (other.totalPointsUncorrected != null)
                 return false;
-        } else if (!netPointsUncorrected.equals(other.netPointsUncorrected))
+        } else if (!totalPointsUncorrected.equals(other.totalPointsUncorrected))
             return false;
-        if (netPointsCorrected != other.netPointsCorrected)
+        if (totalPointsCorrected != other.totalPointsCorrected)
             return false;
         if (race == null) {
             if (other.race != null)
@@ -292,10 +292,10 @@ public class LeaderboardEntryDTO implements Serializable {
                 return false;
         } else if (!timeSinceLastPositionFixInSeconds.equals(other.timeSinceLastPositionFixInSeconds))
             return false;
-        if (totalPoints == null) {
+        if (netPoints == null) {
-            if (other.totalPoints != null)
+            if (other.netPoints != null)
                 return false;
-        } else if (!totalPoints.equals(other.totalPoints))
+        } else if (!netPoints.equals(other.netPoints))
             return false;
         if (windwardDistanceToCompetitorFarthestAheadInMeters == null) {
             if (other.windwardDistanceToCompetitorFarthestAheadInMeters != null)

java/com.sap.sailing.domain.common/src/com/sap/sailing/domain/common/dto/LeaderboardRowDTO.java

@@ -15,7 +15,7 @@ public class LeaderboardRowDTO implements Serializable {
     public CompetitorDTO competitor;
     public Map<String, LeaderboardEntryDTO> fieldsByRaceColumnName;
     public Double carriedPoints;
-    public Double totalPoints;
+    public Double netPoints;
     public Double totalTimeSailedInSeconds;
     public Double totalTimeSailedDownwindInSeconds;
     public Double maximumSpeedOverGroundInKnots;
@@ -35,7 +35,7 @@ public class LeaderboardRowDTO implements Serializable {
                 + ((maximumSpeedOverGroundInKnots == null) ? 0 : maximumSpeedOverGroundInKnots.hashCode());
         result = prime * result
                 + ((totalDistanceTraveledInMeters == null) ? 0 : totalDistanceTraveledInMeters.hashCode());
-        result = prime * result + ((totalPoints == null) ? 0 : totalPoints.hashCode());
+        result = prime * result + ((netPoints == null) ? 0 : netPoints.hashCode());
         result = prime * result
                 + ((totalTimeSailedDownwindInSeconds == null) ? 0 : totalTimeSailedDownwindInSeconds.hashCode());
         result = prime * result + ((totalTimeSailedInSeconds == null) ? 0 : totalTimeSailedInSeconds.hashCode());
@@ -84,10 +84,10 @@ public class LeaderboardRowDTO implements Serializable {
                 return false;
         } else if (!totalDistanceTraveledInMeters.equals(other.totalDistanceTraveledInMeters))
             return false;
-        if (totalPoints == null) {
+        if (netPoints == null) {
-            if (other.totalPoints != null)
+            if (other.netPoints != null)
                 return false;
-        } else if (!totalPoints.equals(other.totalPoints))
+        } else if (!netPoints.equals(other.netPoints))
             return false;
         if (totalTimeSailedDownwindInSeconds == null) {
             if (other.totalTimeSailedDownwindInSeconds != null)

java/com.sap.sailing.domain.test/src/com/sap/sailing/domain/test/LeaderboardCourseChangeTest.java

@@ -120,7 +120,7 @@ public class LeaderboardCourseChangeTest {
         
         DomainFactory baseDomainFactory = new DomainFactoryImpl((srlid)->null);
         LeaderboardDTO leaderboardDTO = leaderboard.getLeaderboardDTO(timePoint, raceColumnNames, false,
-                trackedRegattaRegistry, baseDomainFactory, /* fillNetPointsUncorrected */ false);
+                trackedRegattaRegistry, baseDomainFactory, /* fillTotalPointsUncorrected */ false);
 
         assertEquals(6, leaderboardDTO.rows.values().iterator().next().fieldsByRaceColumnName.values().iterator()
                 .next().legDetails.size());
@@ -129,7 +129,7 @@ public class LeaderboardCourseChangeTest {
         course.removeWaypoint(3);
 
         leaderboardDTO = leaderboard.getLeaderboardDTO(timePoint, raceColumnNames, false, trackedRegattaRegistry,
-                baseDomainFactory, /* fillNetPointsUncorrected */ false);
+                baseDomainFactory, /* fillTotalPointsUncorrected */ false);
         assertEquals(4, leaderboardDTO.rows.values().iterator().next().fieldsByRaceColumnName.values().iterator()
                 .next().legDetails.size());
 

java/com.sap.sailing.domain.test/src/com/sap/sailing/domain/test/LeaderboardForKielWeekTest.java

@@ -48,24 +48,24 @@ public class LeaderboardForKielWeekTest extends OnlineTracTracBasedTest {
         loadRace("event_20110609_KielerWoch-505_Race_2.txt", "event_20110609_KielerWoch-505_Race_2.mtb"); // 505 Race 2
         Competitor kevin = getCompetitorByName("Kevin");
         RaceColumn column = leaderboard.addRace(getTrackedRace(), "Test Race 1", /* medalRace */false);
-        assertEquals(17, leaderboard.getTotalPoints(kevin, now), 0.000000001);
+        assertEquals(17, leaderboard.getNetPoints(kevin, now), 0.000000001);
         Util.Pair<Competitor, RaceColumn> key = new Util.Pair<Competitor, RaceColumn>(kevin, column);
-        assertEquals(17, leaderboard.getContent(now).get(key).getTotalPoints(), 0.000000001);
+        assertEquals(17, leaderboard.getContent(now).get(key).getNetPoints(), 0.000000001);
-        assertEquals(17, leaderboard.getEntry(kevin, column, now).getTotalPoints(), 0.000000001);
+        assertEquals(17, leaderboard.getEntry(kevin, column, now).getNetPoints(), 0.000000001);
         loadRace("event_20110609_KielerWoch-505_Race_3.txt", "event_20110609_KielerWoch-505_Race_3.mtb"); // 505 Race 3
         column = leaderboard.addRace(getTrackedRace(), "Test Race 2", /* medalRace */false);
         key = new Util.Pair<Competitor, RaceColumn>(kevin, column);
         // In Race 3, Hasso ranked 31st
-        assertEquals(29, leaderboard.getTotalPoints(kevin, now), 0.000000001);
+        assertEquals(29, leaderboard.getNetPoints(kevin, now), 0.000000001);
-        assertEquals(12, leaderboard.getContent(now).get(key).getTotalPoints(), 0.000000001);
+        assertEquals(12, leaderboard.getContent(now).get(key).getNetPoints(), 0.000000001);
-        assertEquals(12, leaderboard.getEntry(kevin, column, now).getTotalPoints(), 0.000000001);
+        assertEquals(12, leaderboard.getEntry(kevin, column, now).getNetPoints(), 0.000000001);
         loadRace("event_20110609_KielerWoch-505_race_4.txt", "event_20110609_KielerWoch-505_race_4.mtb"); // 505 Race 4
         column = leaderboard.addRace(getTrackedRace(), "Test Race 3", /* medalRace */false);
         key = new Util.Pair<Competitor, RaceColumn>(kevin, column);
         // now the first race is discarded because Kevin ranked worst compared to the other two; in race 4 he ranked 10th
-        assertEquals(22, leaderboard.getTotalPoints(kevin, now), 0.000000001);
+        assertEquals(22, leaderboard.getNetPoints(kevin, now), 0.000000001);
-        assertEquals(10, leaderboard.getContent(now).get(key).getTotalPoints(), 0.000000001);
+        assertEquals(10, leaderboard.getContent(now).get(key).getNetPoints(), 0.000000001);
-        assertEquals(10, leaderboard.getEntry(kevin, column, now).getTotalPoints(), 0.000000001);
+        assertEquals(10, leaderboard.getEntry(kevin, column, now).getNetPoints(), 0.000000001);
     }
 
     private void loadRace(String paramsFile, String storedDataFile) throws MalformedURLException, IOException, InterruptedException,

java/com.sap.sailing.domain.test/src/com/sap/sailing/domain/test/LeaderboardOfflineTest.java

@@ -146,17 +146,17 @@ public class LeaderboardOfflineTest extends AbstractLeaderboardTest {
                     InterruptedException {
             }
         };
-        LeaderboardDTO leaderboardDTO = leaderboard.getLeaderboardDTO(now, emptySet, /* addOverallDetails */ true, trackedRegattaRegistry, DomainFactory.INSTANCE, /* fillNetPointsUncorrected */ false);
+        LeaderboardDTO leaderboardDTO = leaderboard.getLeaderboardDTO(now, emptySet, /* addOverallDetails */ true, trackedRegattaRegistry, DomainFactory.INSTANCE, /* fillTotalPointsUncorrected */ false);
         assertNotNull(leaderboardDTO);
-        assertSame(leaderboardDTO, leaderboard.getLeaderboardDTO(now, emptySet, /* addOverallDetails */ true, trackedRegattaRegistry, DomainFactory.INSTANCE, /* fillNetPointsUncorrected */ false)); // assert it's cached
+        assertSame(leaderboardDTO, leaderboard.getLeaderboardDTO(now, emptySet, /* addOverallDetails */ true, trackedRegattaRegistry, DomainFactory.INSTANCE, /* fillTotalPointsUncorrected */ false)); // assert it's cached
         leaderboard.getRaceColumnByName(columnName).releaseTrackedRace(defaultFleet); // this should clear the cache
-        LeaderboardDTO leaderboardDTO2 = leaderboard.getLeaderboardDTO(now, emptySet, /* addOverallDetails */ true, trackedRegattaRegistry, DomainFactory.INSTANCE, /* fillNetPointsUncorrected */ false);
+        LeaderboardDTO leaderboardDTO2 = leaderboard.getLeaderboardDTO(now, emptySet, /* addOverallDetails */ true, trackedRegattaRegistry, DomainFactory.INSTANCE, /* fillTotalPointsUncorrected */ false);
         assertNotSame(leaderboardDTO, leaderboardDTO2);
-        assertSame(leaderboardDTO2, leaderboard.getLeaderboardDTO(now, emptySet, /* addOverallDetails */ true, trackedRegattaRegistry, DomainFactory.INSTANCE, /* fillNetPointsUncorrected */ false)); // and cached again
+        assertSame(leaderboardDTO2, leaderboard.getLeaderboardDTO(now, emptySet, /* addOverallDetails */ true, trackedRegattaRegistry, DomainFactory.INSTANCE, /* fillTotalPointsUncorrected */ false)); // and cached again
         leaderboard.getRaceColumnByName(columnName).setTrackedRace(defaultFleet, testRaces.iterator().next()); // clear cache again; requires listener(s) to still be attached
-        LeaderboardDTO leaderboardDTO3 = leaderboard.getLeaderboardDTO(now, emptySet, /* addOverallDetails */ true, trackedRegattaRegistry, DomainFactory.INSTANCE, /* fillNetPointsUncorrected */ false);
+        LeaderboardDTO leaderboardDTO3 = leaderboard.getLeaderboardDTO(now, emptySet, /* addOverallDetails */ true, trackedRegattaRegistry, DomainFactory.INSTANCE, /* fillTotalPointsUncorrected */ false);
         assertNotSame(leaderboardDTO2, leaderboardDTO3);
-        assertSame(leaderboardDTO3, leaderboard.getLeaderboardDTO(now, emptySet, /* addOverallDetails */ true, trackedRegattaRegistry, DomainFactory.INSTANCE, /* fillNetPointsUncorrected */ false)); // and cached again
+        assertSame(leaderboardDTO3, leaderboard.getLeaderboardDTO(now, emptySet, /* addOverallDetails */ true, trackedRegattaRegistry, DomainFactory.INSTANCE, /* fillTotalPointsUncorrected */ false)); // and cached again
     }
 
     @Test
@@ -187,11 +187,11 @@ public class LeaderboardOfflineTest extends AbstractLeaderboardTest {
             }
         }
         leaderboard.getScoreCorrection().setMaxPointsReason(competitor, bestScoringRaceColumn, MaxPointsReason.DSQ);
-        // assert that best scoring but now disqualified race gets max net points because of disqualification:
+        // assert that best scoring but now disqualified race gets max total points because of disqualification:
         assertEquals(Util.size(bestScoringRaceColumn.getTrackedRace(defaultFleet).getRace().getCompetitors())+1,
-                leaderboard.getEntry(competitor, bestScoringRaceColumn, MillisecondsTimePoint.now()).getNetPoints(), 0.000000001);
+                leaderboard.getEntry(competitor, bestScoringRaceColumn, MillisecondsTimePoint.now()).getTotalPoints(), 0.000000001);
         // now assert that it gets discarded because due to disqualification it scores worse than all others:
-        assertEquals(0, leaderboard.getEntry(competitor, bestScoringRaceColumn, MillisecondsTimePoint.now()).getTotalPoints(), 0.000000001);
+        assertEquals(0, leaderboard.getEntry(competitor, bestScoringRaceColumn, MillisecondsTimePoint.now()).getNetPoints(), 0.000000001);
     }
 
     @Test
@@ -207,15 +207,15 @@ public class LeaderboardOfflineTest extends AbstractLeaderboardTest {
         FlexibleLeaderboard leaderboard = new FlexibleLeaderboardImpl("Test Leaderboard", new ThresholdBasedResultDiscardingRuleImpl(
                 new int[] { 2 }), new LowPoint(), null);
         leaderboard.addRace(testRace, "R1", /* medalRace */false);
-        assertEquals(1., leaderboard.getTotalPoints(competitor, now), 0.00000001);
+        assertEquals(1., leaderboard.getNetPoints(competitor, now), 0.00000001);
-        assertEquals(1., leaderboard.getTotalPoints(c2, now), 0.00000001);
+        assertEquals(1., leaderboard.getNetPoints(c2, now), 0.00000001);
-        assertEquals(1., leaderboard.getTotalPoints(c3, now), 0.00000001);
+        assertEquals(1., leaderboard.getNetPoints(c3, now), 0.00000001);
         leaderboard.setCarriedPoints(competitor, 100);
         leaderboard.setCarriedPoints(c2, 50);
         leaderboard.setCarriedPoints(c3, 25);
-        assertEquals(101., leaderboard.getTotalPoints(competitor, now), 0.00000001);
+        assertEquals(101., leaderboard.getNetPoints(competitor, now), 0.00000001);
-        assertEquals(51., leaderboard.getTotalPoints(c2, now), 0.00000001);
+        assertEquals(51., leaderboard.getNetPoints(c2, now), 0.00000001);
-        assertEquals(26., leaderboard.getTotalPoints(c3, now), 0.00000001);
+        assertEquals(26., leaderboard.getNetPoints(c3, now), 0.00000001);
         List<Competitor> sortedCompetitors = leaderboard.getCompetitorsFromBestToWorst(now);
         assertSame(c3, sortedCompetitors.get(0));
         assertSame(c2, sortedCompetitors.get(1));
@@ -238,9 +238,9 @@ public class LeaderboardOfflineTest extends AbstractLeaderboardTest {
         RaceColumn r2 = leaderboard.addRaceColumn("R2", /* medalRace */false);
         leaderboard.getScoreCorrection().setMaxPointsReason(competitor, r2, MaxPointsReason.DND); // non-discardable disqualification
         // assert that max points were given before discarding...
-        assertEquals(4.0, leaderboard.getEntry(competitor, r2, MillisecondsTimePoint.now()).getNetPoints(), 0.000000001);
-        // ...and after...
         assertEquals(4.0, leaderboard.getEntry(competitor, r2, MillisecondsTimePoint.now()).getTotalPoints(), 0.000000001);
+        // ...and after...
+        assertEquals(4.0, leaderboard.getEntry(competitor, r2, MillisecondsTimePoint.now()).getNetPoints(), 0.000000001);
         // ...because it's not discarded
         assertFalse(leaderboard.getEntry(competitor, r2, MillisecondsTimePoint.now()).isDiscarded());
     }
@@ -273,12 +273,12 @@ public class LeaderboardOfflineTest extends AbstractLeaderboardTest {
             }
         }
         leaderboard.getScoreCorrection().setMaxPointsReason(competitor, bestScoringRaceColumn, MaxPointsReason.DND);
-        // assert that best scoring but now disqualified race gets max net points because of disqualification:
+        // assert that best scoring but now disqualified race gets max total points because of disqualification:
-        assertEquals(Util.size(bestScoringRaceColumn.getTrackedRace(defaultFleet).getRace().getCompetitors())+1,
-                leaderboard.getEntry(competitor, bestScoringRaceColumn, MillisecondsTimePoint.now()).getNetPoints(), 0.000000001);
-        // now assert that it does not get discarded because it's a DND
         assertEquals(Util.size(bestScoringRaceColumn.getTrackedRace(defaultFleet).getRace().getCompetitors())+1,
                 leaderboard.getEntry(competitor, bestScoringRaceColumn, MillisecondsTimePoint.now()).getTotalPoints(), 0.000000001);
+        // now assert that it does not get discarded because it's a DND
+        assertEquals(Util.size(bestScoringRaceColumn.getTrackedRace(defaultFleet).getRace().getCompetitors())+1,
+                leaderboard.getEntry(competitor, bestScoringRaceColumn, MillisecondsTimePoint.now()).getNetPoints(), 0.000000001);
     }
 
     protected void testLeaderboard(int numberOfStartedRaces, int numberOfNotStartedRaces, int firstDiscardingThreshold,
@@ -314,7 +314,7 @@ public class LeaderboardOfflineTest extends AbstractLeaderboardTest {
         }
         Collections.sort(ranksOfNonMedalStartedRaces);
         int carryInt = (carry == null ? 0 : carry);
-        int totalPoints = carryInt;
+        int netPoints = carryInt;
         int medalRacePoints = getMedalRacePoints(competitor, now, defaultFleet);
         for (TrackedRace race : testRaces) {
             RaceColumn raceColumn = raceColumnsInLeaderboard.get(race);
@@ -324,9 +324,9 @@ public class LeaderboardOfflineTest extends AbstractLeaderboardTest {
                 assertEquals(rank, leaderboard.getTrackedRank(competitor, raceColumn, now));
                 assertEquals(rank, leaderboard.getContent(now).get(key).getTrackedRank());
                 assertEquals(rank, leaderboard.getEntry(competitor, raceColumn, now).getTrackedRank());
-                assertEquals(rank, leaderboard.getNetPoints(competitor, raceColumn, now), 0.000000001);
+                assertEquals(rank, leaderboard.getTotalPoints(competitor, raceColumn, now), 0.000000001);
-                assertEquals(rank, leaderboard.getContent(now).get(key).getNetPoints(), 0.000000001);
+                assertEquals(rank, leaderboard.getContent(now).get(key).getTotalPoints(), 0.000000001);
-                assertEquals(rank, leaderboard.getEntry(competitor, raceColumn, now).getNetPoints(), 0.000000001);
+                assertEquals(rank, leaderboard.getEntry(competitor, raceColumn, now).getTotalPoints(), 0.000000001);
                 // One race is discarded because four races were started, and for [3-6) one race can be discarded.
                 // The discarded race is the worst of those started, so the one with rank 4.
                 int expectedNumberOfDiscardedRaces =
@@ -334,21 +334,21 @@ public class LeaderboardOfflineTest extends AbstractLeaderboardTest {
                             numberOfRacesToCompareToDiscardThresholds < secondDiscardingThreshold ? 1 : 2;
                 boolean discarded = ranksOfNonMedalStartedRaces.indexOf(rank) >= ranksOfNonMedalStartedRaces.size()-expectedNumberOfDiscardedRaces;
                 int expected = discarded ? 0 : rank==medalRacePoints?2*rank:rank;
-                assertEquals(expected, leaderboard.getTotalPoints(competitor, raceColumn, now), 0.000000001);
+                assertEquals(expected, leaderboard.getNetPoints(competitor, raceColumn, now), 0.000000001);
-                assertEquals(expected, leaderboard.getContent(now).get(key).getTotalPoints(), 0.000000001);
+                assertEquals(expected, leaderboard.getContent(now).get(key).getNetPoints(), 0.000000001);
-                assertEquals(expected, leaderboard.getEntry(competitor, raceColumn, now).getTotalPoints(), 0.000000001);
+                assertEquals(expected, leaderboard.getEntry(competitor, raceColumn, now).getNetPoints(), 0.000000001);
-                totalPoints += leaderboard.getContent(now).get(key).getTotalPoints();
+                netPoints += leaderboard.getContent(now).get(key).getNetPoints();
             } else {
                 assertEquals(0, leaderboard.getTrackedRank(competitor, raceColumn, now));
-                assertNull(leaderboard.getNetPoints(competitor, raceColumn, now));
+                assertNull(leaderboard.getTotalPoints(competitor, raceColumn, now));
                 assertEquals(0, leaderboard.getContent(now).get(key).getTrackedRank());
-                assertNull(leaderboard.getContent(now).get(key).getNetPoints());
+                assertNull(leaderboard.getContent(now).get(key).getTotalPoints());
                 assertEquals(0, leaderboard.getEntry(competitor, raceColumn, now).getTrackedRank());
-                assertNull(leaderboard.getEntry(competitor, raceColumn, now).getNetPoints());
+                assertNull(leaderboard.getEntry(competitor, raceColumn, now).getTotalPoints());
-                // no increment on totalPoints
+                // no increment on netPoints
             }
         }
-        assertEquals(totalPoints, leaderboard.getTotalPoints(competitor, now), 0.000000001);
+        assertEquals(netPoints, leaderboard.getNetPoints(competitor, now), 0.000000001);
     }
 
     private int getMedalRacePoints(Competitor competitor, TimePoint at, Fleet fleet) throws NoWindException {

java/com.sap.sailing.domain.test/src/com/sap/sailing/domain/test/LeaderboardScoringAndRankingTest.java

@@ -110,7 +110,7 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
     /**
      * Regarding bug 912, test adding a disqualification in the middle, with a high-point scoring scheme, and check that
      * all competitors ranked worse advance by one, including getting <em>more</em> points due to the high-point scoring
-     * scheme. Note that this does not test the total points given for those competitors.
+     * scheme. Note that this does not test the net points given for those competitors.
      */
     @Test
     public void testOneStartedRaceWithDifferentScoresAndDisqualificationUsingHighPointScoringScheme() throws NoWindException {
@@ -136,13 +136,13 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         assertEquals(competitors.subList(6, 10), rankedCompetitors.subList(5, 9));
         assertEquals(competitors.get(5), rankedCompetitors.get(9));
 
-        // Now test the total points and make sure the other competitors advanced by one, too
+        // Now test the net points and make sure the other competitors advanced by one, too
-        assertEquals(0, leaderboard.getTotalPoints(competitors.get(5), f1Column, now), 0.000000001);
+        assertEquals(0, leaderboard.getNetPoints(competitors.get(5), f1Column, now), 0.000000001);
         for (int i=0; i<5; i++) {
-            assertEquals(10-i, leaderboard.getTotalPoints(competitors.get(i), f1Column, now), 0.000000001);
+            assertEquals(10-i, leaderboard.getNetPoints(competitors.get(i), f1Column, now), 0.000000001);
         }
         for (int i=6; i<10; i++) {
-            assertEquals(10-(i-1), leaderboard.getTotalPoints(competitors.get(i), f1Column, now), 0.000000001);
+            assertEquals(10-(i-1), leaderboard.getNetPoints(competitors.get(i), f1Column, now), 0.000000001);
         }
     }
 
@@ -170,15 +170,15 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         TrackedRace q2Default = new MockedTrackedRaceWithStartTimeAndRanks(now, reverseCompetitors);
         q1Column.setTrackedRace(q1Column.getFleetByName("Default"), q1Default);
         q2Column.setTrackedRace(q2Column.getFleetByName("Default"), q2Default);
-        assertEquals(Double.valueOf(competitors.size()), leaderboard.getTotalPoints(competitors.get(0), q1Column, later));
+        assertEquals(Double.valueOf(competitors.size()), leaderboard.getNetPoints(competitors.get(0), q1Column, later));
-        assertEquals(factor * Double.valueOf(1), leaderboard.getTotalPoints(competitors.get(0), q2Column, later), 0.000000001);
+        assertEquals(factor * Double.valueOf(1), leaderboard.getNetPoints(competitors.get(0), q2Column, later), 0.000000001);
-        assertEquals(Double.valueOf(factor*1.0+competitors.size()), leaderboard.getTotalPoints(competitors.get(0), later), 0.000000001);
+        assertEquals(Double.valueOf(factor*1.0+competitors.size()), leaderboard.getNetPoints(competitors.get(0), later), 0.000000001);
     }
 
     /**
      * Regarding bug 961, test scoring in a leaderboard that has a qualification series with two unordered groups where for one
      * column only one group has raced (expressed by a mocked TrackedRace attached to the column). Ensure that the column does
-     * count for the total points sum but that the competitor ordering is controlled by the number of races.
+     * count for the net points sum but that the competitor ordering is controlled by the number of races.
      */
     @Test
     public void testUnorderedGroupsWithOneGroupNotHavingRacedInAColumn() throws NoWindException {
@@ -203,8 +203,8 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         for (int i=0; i<5; i++) {
             assertTrue(competitors.get(i) == rankedCompetitors.get(2*i) || competitors.get(i) == rankedCompetitors.get(2*i+1));
             assertTrue(competitors.get(i+5) == rankedCompetitors.get(2*i) || competitors.get(i+5) == rankedCompetitors.get(2*i+1));
-            assertEquals((double) (i+1), leaderboard.getTotalPoints(competitors.get(i), later), 0.000000001);
+            assertEquals((double) (i+1), leaderboard.getNetPoints(competitors.get(i), later), 0.000000001);
-            assertEquals((double) (i+1), leaderboard.getTotalPoints(competitors.get(i+5), later), 0.0000000001);
+            assertEquals((double) (i+1), leaderboard.getNetPoints(competitors.get(i+5), later), 0.0000000001);
         }
         // now add one race for yellow fleet and test that it counts for the score but not the ordering
         // because blue fleet is still missing its race for Q2
@@ -220,15 +220,15 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
                 competitors.get(4), competitors.get(7) }), rankedCompetitorsWithOneRaceMissingInQ2);
         double[] points = new double[] { 1, 2, 3, 5, 7, 4, 6, 8, 4, 5 };
         for (int i=0; i<9; i++) {
-            assertEquals(points[i], leaderboard.getTotalPoints(competitors.get(i), later), 0.000000001);
+            assertEquals(points[i], leaderboard.getNetPoints(competitors.get(i), later), 0.000000001);
         }
-        // now add a tracked race for the blue fleet for Q2 and assert that the Q2 scores count for the total points sum
+        // now add a tracked race for the blue fleet for Q2 and assert that the Q2 scores count for the net points sum
         TrackedRace q2Blue = new MockedTrackedRaceWithStartTimeAndRanks(now,
                 Arrays.asList(new Competitor[] { competitors.get(0), competitors.get(1), competitors.get(2),
                         competitors.get(8), competitors.get(9) }));
         q2Column.setTrackedRace(q2Column.getFleetByName("Blue"), q2Blue);
         // the new order in Q2 expected to be { (0, 3), (1, 4), (2, 5), (8, 6), (9, 7) }
-        // therefore the new total points, in ascending order, are expected to be:
+        // therefore the new net points, in ascending order, are expected to be:
         // { 0: 1+1=2; 5: 1+3=4; 1: 2+2=4; 3: 4+1=5; 2: 3+3=6; 6: 2+4=6; 4: 5+2=7; 7: 3+5=8; 8: 4+4=8; 9: 5+5=10 }
         double[] expectedTotalPoints = new double[] { 2, 4, 6, 5, 7, 4, 6, 8, 8, 10 };
         int[] expectedOrderAfterTwoFullRacesPlusMinusOne = new int[] { 0, 5, 1, 3, 2, 6, 4, 7, 8, 9 };
@@ -238,8 +238,8 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
                     competitors.get(expectedOrderAfterTwoFullRacesPlusMinusOne[2*i]) == rankedCompetitorsWithAllRacesInQ2.get(2*i+1));
             assertTrue(competitors.get(expectedOrderAfterTwoFullRacesPlusMinusOne[2*i+1]) == rankedCompetitorsWithAllRacesInQ2.get(2*i) ||
                     competitors.get(expectedOrderAfterTwoFullRacesPlusMinusOne[2*i+1]) == rankedCompetitorsWithAllRacesInQ2.get(2*i+1));
-            assertEquals(expectedTotalPoints[2*i], leaderboard.getTotalPoints(competitors.get(2*i), later), 0.000000001);
+            assertEquals(expectedTotalPoints[2*i], leaderboard.getNetPoints(competitors.get(2*i), later), 0.000000001);
-            assertEquals(expectedTotalPoints[2*i+1], leaderboard.getTotalPoints(competitors.get(2*i+1), later), 0.000000001);
+            assertEquals(expectedTotalPoints[2*i+1], leaderboard.getNetPoints(competitors.get(2*i+1), later), 0.000000001);
         }
 
     }
@@ -276,7 +276,7 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         TrackedRace q2Yellow = new MockedTrackedRaceWithStartTimeAndRanks(now, competitors.subList(3, 8));
         RaceColumn q2Column = qualificationSeries.getRaceColumnByName("Q2");
         q2Column.setTrackedRace(q2Column.getFleetByName("Yellow"), q2Yellow);
-        // now add a tracked race for the blue fleet for Q2 that hasn't started yet and assert that the Q2 scores still don't count for the total points sum
+        // now add a tracked race for the blue fleet for Q2 that hasn't started yet and assert that the Q2 scores still don't count for the net points sum
         TimePoint muchLater = later.plus(10000000000l);
         TrackedRace q2Blue = new MockedTrackedRaceWithStartTimeAndRanks(muchLater,
                 Arrays.asList(new Competitor[] { competitors.get(0), competitors.get(1), competitors.get(2),
@@ -291,22 +291,22 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
                 competitors.get(4), competitors.get(7) }), rankedCompetitorsWithOneRaceMissingInQ2);
         double[] points = new double[] { 1, 2, 3, 5, 7, 4, 6, 8, 4, 5 };
         for (int i=0; i<9; i++) {
-            assertEquals(points[i], leaderboard.getTotalPoints(competitors.get(i), later), 0.000000001);
+            assertEquals(points[i], leaderboard.getNetPoints(competitors.get(i), later), 0.000000001);
         }
         // expect all results to be valid because a fleet will have its score counted even if not all fleets have raced;
         // see discussion for bug 961, but more importantly later on bug 1023.
         for (final Competitor competitor : competitors) {
-            assertTrue(leaderboard.getScoringScheme().isValidInTotalScore(leaderboard, q2Column, competitor, later));
+            assertTrue(leaderboard.getScoringScheme().isValidInNetScore(leaderboard, q2Column, competitor, later));
         }
         // now add a score correction for Q2/Blue to make it count:
         leaderboard.getScoreCorrection().correctScore(competitors.get(9), q2Column, 42.);
         for (final Competitor competitor : competitors) {
-            assertTrue(leaderboard.getScoringScheme().isValidInTotalScore(leaderboard, q2Column, competitor, later));
+            assertTrue(leaderboard.getScoringScheme().isValidInNetScore(leaderboard, q2Column, competitor, later));
         }
         // the new order in Q2 expected to be { (9, 3), ... } (we don't know about any competitor in q2Blue but #9
-        // therefore the new total points for #9 are
+        // therefore the new net points for #9 are
         // { 9: 5+42=47 }
-        assertEquals(47.0, leaderboard.getTotalPoints(competitors.get(9), later), 0.00000001);
+        assertEquals(47.0, leaderboard.getNetPoints(competitors.get(9), later), 0.00000001);
     }
 
     /**
@@ -401,7 +401,7 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
     /**
      * Asserts that the competitors ranking worse than the disqualified competitor advance by one in the
      * {@link Leaderboard#getCompetitorsFromBestToWorst(TimePoint)} ordering. Note that this does not test
-     * the total points given for those competitors.
+     * the net points given for those competitors.
      */
     @Test
     public void testOneStartedRaceWithDifferentScoresAndDisqualification() throws NoWindException {
@@ -426,13 +426,13 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         assertEquals(competitors.subList(6, 10), rankedCompetitors.subList(5, 9));
         assertEquals(competitors.get(5), rankedCompetitors.get(9));
 
-        // Now test the total points and make sure the other competitors advanced by one, too
+        // Now test the net points and make sure the other competitors advanced by one, too
-        assertEquals(11, leaderboard.getTotalPoints(competitors.get(5), f1Column, now), 0.000000001);
+        assertEquals(11, leaderboard.getNetPoints(competitors.get(5), f1Column, now), 0.000000001);
         for (int i=0; i<5; i++) {
-            assertEquals(i+1, leaderboard.getTotalPoints(competitors.get(i), f1Column, now), 0.000000001);
+            assertEquals(i+1, leaderboard.getNetPoints(competitors.get(i), f1Column, now), 0.000000001);
         }
         for (int i=6; i<10; i++) {
-            assertEquals(i, leaderboard.getTotalPoints(competitors.get(i), f1Column, now), 0.000000001);
+            assertEquals(i, leaderboard.getNetPoints(competitors.get(i), f1Column, now), 0.000000001);
         }
     }
 
@@ -493,14 +493,14 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         for (Competitor goldCompetitor : gold) {
             assertEquals(rank, f1Column.getTrackedRace(goldCompetitor).getRank(goldCompetitor, later));
             assertEquals(rank, leaderboard.getTrackedRank(goldCompetitor, f1Column, later));
-            assertEquals(NUMBER_OF_COMPETITORS/2+1-rank, leaderboard.getNetPoints(goldCompetitor, f1Column, later), 0.00000001);
+            assertEquals(NUMBER_OF_COMPETITORS/2+1-rank, leaderboard.getTotalPoints(goldCompetitor, f1Column, later), 0.00000001);
             rank++;
         }
         rank=1;
         for (Competitor silverCompetitor : silver) {
             assertEquals(rank, f1Column.getTrackedRace(silverCompetitor).getRank(silverCompetitor, later));
             assertEquals(rank, leaderboard.getTrackedRank(silverCompetitor, f1Column, later));
-            assertEquals(NUMBER_OF_COMPETITORS/2+1-rank, leaderboard.getNetPoints(silverCompetitor, f1Column, later), 0.00000001);
+            assertEquals(NUMBER_OF_COMPETITORS/2+1-rank, leaderboard.getTotalPoints(silverCompetitor, f1Column, later), 0.00000001);
             rank++;
         }
         List<Competitor> rankedCompetitors = leaderboard.getCompetitorsFromBestToWorst(later);
@@ -592,7 +592,7 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         // assert that all competitors have equal points now
         Competitor firstCompetitor = competitors.iterator().next();
         for (Competitor competitor : competitors) {
-            assertEquals(leaderboard.getTotalPoints(firstCompetitor, later), leaderboard.getTotalPoints(competitor, later));
+            assertEquals(leaderboard.getNetPoints(firstCompetitor, later), leaderboard.getNetPoints(competitor, later));
         }
         // assert that the ordering of competitors equals that of the last race
         assertEquals(reversedCompetitors, leaderboard.getCompetitorsFromBestToWorst(later));
@@ -652,7 +652,7 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         Leaderboard leaderboard = createLeaderboard(regatta, /* discarding thresholds */ new int[0]);
         TimePoint later = createAndAttachTrackedRaces(series.get(1), "Default", /* withScores */ true, f1, f2, f3);
         List<Competitor> rankedCompetitors = leaderboard.getCompetitorsFromBestToWorst(later);
-        assertEquals(leaderboard.getTotalPoints(c[0], later), leaderboard.getTotalPoints(c[1], later), 0.000000001);
+        assertEquals(leaderboard.getNetPoints(c[0], later), leaderboard.getNetPoints(c[1], later), 0.000000001);
         assertEquals(Arrays.asList(new Competitor[] { c[0], c[1], c[2] }), rankedCompetitors);
     }
 
@@ -671,7 +671,7 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         Leaderboard leaderboard = createLeaderboard(regatta, /* discarding thresholds */ new int[0]);
         TimePoint later = createAndAttachTrackedRaces(series.get(1), "Default", /* withScores */ true, f1, f2, f3, f4, f5, f6);
         List<Competitor> rankedCompetitors = leaderboard.getCompetitorsFromBestToWorst(later);
-        assertEquals(leaderboard.getTotalPoints(c[0], later), leaderboard.getTotalPoints(c[1], later), 0.000000001);
+        assertEquals(leaderboard.getNetPoints(c[0], later), leaderboard.getNetPoints(c[1], later), 0.000000001);
         assertTrue(rankedCompetitors.indexOf(c[0]) == rankedCompetitors.indexOf(c[1])-1);
     }
 
@@ -704,8 +704,8 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         Leaderboard leaderboard = createLeaderboard(regatta, /* discarding thresholds */ new int[] { 4 });
         TimePoint later = createAndAttachTrackedRaces(series.get(1), "Default", /* withScores */ true, f1, f2, f3, f4, f5);
         List<Competitor> rankedCompetitors = leaderboard.getCompetitorsFromBestToWorst(later);
-        assertEquals(33.0, leaderboard.getTotalPoints(GER2105, later), 0.0000001);
+        assertEquals(33.0, leaderboard.getNetPoints(GER2105, later), 0.0000001);
-        assertEquals(33.0, leaderboard.getTotalPoints(GER2254, later), 0.0000001);
+        assertEquals(33.0, leaderboard.getNetPoints(GER2254, later), 0.0000001);
         assertTrue(rankedCompetitors.indexOf(GER2105) == rankedCompetitors.indexOf(GER2254)-1);
     }
 
@@ -756,26 +756,26 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         }
         List<Competitor> rankedCompetitors = leaderboard.getCompetitorsFromBestToWorst(later);
         assertSame(c[0], rankedCompetitors.get(0)); // should be the winner of the final round's Final heat and take the "crown" for the elimination
-        assertEquals(0.7, leaderboard.getTotalPoints(c[0], later), 0.000000001);
+        assertEquals(0.7, leaderboard.getNetPoints(c[0], later), 0.000000001);
         assertSame(c[1], rankedCompetitors.get(1)); // should be the winner of the final round's Final heat and take the "crown" for the elimination
-        assertEquals(2, leaderboard.getTotalPoints(c[1], later), 0.000000001);
+        assertEquals(2, leaderboard.getNetPoints(c[1], later), 0.000000001);
         // first four of second heat get promoted to quarter final but lose their heat
-        assertNull(leaderboard.getTotalPoints(c[ 8], series.get(0).getRaceColumns().iterator().next(), later));
+        assertNull(leaderboard.getNetPoints(c[ 8], series.get(0).getRaceColumns().iterator().next(), later));
-        assertNull(leaderboard.getTotalPoints(c[ 9], series.get(0).getRaceColumns().iterator().next(), later));
+        assertNull(leaderboard.getNetPoints(c[ 9], series.get(0).getRaceColumns().iterator().next(), later));
-        assertNull(leaderboard.getTotalPoints(c[10], series.get(0).getRaceColumns().iterator().next(), later));
+        assertNull(leaderboard.getNetPoints(c[10], series.get(0).getRaceColumns().iterator().next(), later));
-        assertNull(leaderboard.getTotalPoints(c[11], series.get(0).getRaceColumns().iterator().next(), later));
+        assertNull(leaderboard.getNetPoints(c[11], series.get(0).getRaceColumns().iterator().next(), later));
-        assertEquals(18.5, leaderboard.getTotalPoints(c[ 8], later), 0.000000001);
+        assertEquals(18.5, leaderboard.getNetPoints(c[ 8], later), 0.000000001);
-        assertEquals(22.5, leaderboard.getTotalPoints(c[ 9], later), 0.000000001);
+        assertEquals(22.5, leaderboard.getNetPoints(c[ 9], later), 0.000000001);
-        assertEquals(26.5, leaderboard.getTotalPoints(c[10], later), 0.000000001);
+        assertEquals(26.5, leaderboard.getNetPoints(c[10], later), 0.000000001);
-        assertEquals(30.5, leaderboard.getTotalPoints(c[11], later), 0.000000001);
+        assertEquals(30.5, leaderboard.getNetPoints(c[11], later), 0.000000001);
         // last four competitors in last heat of first round don't get promoted and have null scores in all other rounds but the first
-        assertEquals(36.5, leaderboard.getTotalPoints(c[60], later), 0.000000001);
+        assertEquals(36.5, leaderboard.getNetPoints(c[60], later), 0.000000001);
-        assertEquals(44.5, leaderboard.getTotalPoints(c[61], later), 0.000000001);
+        assertEquals(44.5, leaderboard.getNetPoints(c[61], later), 0.000000001);
-        assertEquals(52.5, leaderboard.getTotalPoints(c[62], later), 0.000000001);
+        assertEquals(52.5, leaderboard.getNetPoints(c[62], later), 0.000000001);
-        assertEquals(60.5, leaderboard.getTotalPoints(c[63], later), 0.000000001);
+        assertEquals(60.5, leaderboard.getNetPoints(c[63], later), 0.000000001);
         for (int i=1; i<=3; i++) {
             for (int j=60; j<=63; j++) {
-                assertNull(leaderboard.getTotalPoints(c[j], series.get(i).getRaceColumns().iterator().next(), later));
+                assertNull(leaderboard.getNetPoints(c[j], series.get(i).getRaceColumns().iterator().next(), later));
             }
         }
     }
@@ -830,29 +830,29 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
             }
         }
         for (int numberOfEliminationsExpectedToScore=NUMBER_OF_ELIMINATIONS; numberOfEliminationsExpectedToScore>=NUMBER_OF_ELIMINATIONS-1; numberOfEliminationsExpectedToScore--) {
-            assertEquals(numberOfEliminationsExpectedToScore*18.5, leaderboard.getTotalPoints(c[ 8], later), 0.000000001);
+            assertEquals(numberOfEliminationsExpectedToScore*18.5, leaderboard.getNetPoints(c[ 8], later), 0.000000001);
-            assertEquals(numberOfEliminationsExpectedToScore*22.5, leaderboard.getTotalPoints(c[ 9], later), 0.000000001);
+            assertEquals(numberOfEliminationsExpectedToScore*22.5, leaderboard.getNetPoints(c[ 9], later), 0.000000001);
-            assertEquals(numberOfEliminationsExpectedToScore*26.5, leaderboard.getTotalPoints(c[10], later), 0.000000001);
+            assertEquals(numberOfEliminationsExpectedToScore*26.5, leaderboard.getNetPoints(c[10], later), 0.000000001);
-            assertEquals(numberOfEliminationsExpectedToScore*30.5, leaderboard.getTotalPoints(c[11], later), 0.000000001);
+            assertEquals(numberOfEliminationsExpectedToScore*30.5, leaderboard.getNetPoints(c[11], later), 0.000000001);
             // last four competitors in last heat of first round don't get promoted and have null scores in all other rounds but the first
-            assertEquals(numberOfEliminationsExpectedToScore*36.5, leaderboard.getTotalPoints(c[60], later), 0.000000001);
+            assertEquals(numberOfEliminationsExpectedToScore*36.5, leaderboard.getNetPoints(c[60], later), 0.000000001);
-            assertEquals(numberOfEliminationsExpectedToScore*44.5, leaderboard.getTotalPoints(c[61], later), 0.000000001);
+            assertEquals(numberOfEliminationsExpectedToScore*44.5, leaderboard.getNetPoints(c[61], later), 0.000000001);
-            assertEquals(numberOfEliminationsExpectedToScore*52.5, leaderboard.getTotalPoints(c[62], later), 0.000000001);
+            assertEquals(numberOfEliminationsExpectedToScore*52.5, leaderboard.getNetPoints(c[62], later), 0.000000001);
-            assertEquals(numberOfEliminationsExpectedToScore*60.5, leaderboard.getTotalPoints(c[63], later), 0.000000001);
+            assertEquals(numberOfEliminationsExpectedToScore*60.5, leaderboard.getNetPoints(c[63], later), 0.000000001);
             List<Competitor> rankedCompetitors = leaderboard.getCompetitorsFromBestToWorst(later);
             assertSame(c[0], rankedCompetitors.get(0)); // should be the winner of the final round's Final heat and take the "crown" for the elimination
-            assertEquals(numberOfEliminationsExpectedToScore*0.7, leaderboard.getTotalPoints(c[0], later), 0.000000001);
+            assertEquals(numberOfEliminationsExpectedToScore*0.7, leaderboard.getNetPoints(c[0], later), 0.000000001);
             assertSame(c[1], rankedCompetitors.get(1)); // should be the winner of the final round's Final heat and take the "crown" for the elimination
-            assertEquals(numberOfEliminationsExpectedToScore*2, leaderboard.getTotalPoints(c[1], later), 0.000000001);
+            assertEquals(numberOfEliminationsExpectedToScore*2, leaderboard.getNetPoints(c[1], later), 0.000000001);
             for (int elimination=0; elimination<NUMBER_OF_ELIMINATIONS; elimination++) {
                 // first four of second heat get promoted to quarter final but lose their heat
-                assertNull(leaderboard.getTotalPoints(c[ 8], series.get(4*elimination+0).getRaceColumns().iterator().next(), later));
+                assertNull(leaderboard.getNetPoints(c[ 8], series.get(4*elimination+0).getRaceColumns().iterator().next(), later));
-                assertNull(leaderboard.getTotalPoints(c[ 9], series.get(4*elimination+0).getRaceColumns().iterator().next(), later));
+                assertNull(leaderboard.getNetPoints(c[ 9], series.get(4*elimination+0).getRaceColumns().iterator().next(), later));
-                assertNull(leaderboard.getTotalPoints(c[10], series.get(4*elimination+0).getRaceColumns().iterator().next(), later));
+                assertNull(leaderboard.getNetPoints(c[10], series.get(4*elimination+0).getRaceColumns().iterator().next(), later));
-                assertNull(leaderboard.getTotalPoints(c[11], series.get(4*elimination+0).getRaceColumns().iterator().next(), later));
+                assertNull(leaderboard.getNetPoints(c[11], series.get(4*elimination+0).getRaceColumns().iterator().next(), later));
                 for (int i=1; i<=3; i++) {
                     for (int j=60; j<=63; j++) {
-                        assertNull(leaderboard.getTotalPoints(c[j], series.get(4*elimination+i).getRaceColumns().iterator().next(), later));
+                        assertNull(leaderboard.getNetPoints(c[j], series.get(4*elimination+i).getRaceColumns().iterator().next(), later));
                     }
                 }
             }
@@ -908,12 +908,12 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
             later = createAndAttachTrackedRaces(series.get(3), "Heat "+(heat+15), /* withScores */ true, competitorsForHeatsInFinals[heat]);
         }
         // validate first-round points for drop-outs; competitor #64 (the 9th in heat #8) shall have 65 points
-        assertEquals(65, leaderboard.getTotalPoints(c[64], later), 0.0000001);
+        assertEquals(65, leaderboard.getNetPoints(c[64], later), 0.0000001);
         for (int heat = 0; heat < 8; heat++) {
             for (int i = 4; i < 8; i++) {
                 assertEquals((8.0*i+1.0  // best overall rank for drop-outs ranking i+1 in own fleet
                              +8.0*i+8.0) // worst overall rank for drop-outs ranking i+1 in own fleet
-                             /2.0, leaderboard.getTotalPoints(c[8*heat+i], later), 0.0000001);
+                             /2.0, leaderboard.getNetPoints(c[8*heat+i], later), 0.0000001);
             }
         }
     }
@@ -967,17 +967,17 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         // 1 instead of 0.7 for a final that was not sailed; clarified with Juergen Bonne in an e-mail as of 18-09-2015T09:03:00Z
         final double expectedPointsForFirstEightBoats = (1.0 + 2.0 + 3.0 + 4.0 + 5.0 + 6.0 + 7.0 + 8.0) / 8.0;
         for (int i=0; i<4; i++) {
-            assertEquals(expectedPointsForFirstEightBoats, leaderboard.getTotalPoints(c[i], later), 0.000000001);
+            assertEquals(expectedPointsForFirstEightBoats, leaderboard.getNetPoints(c[i], later), 0.000000001);
         }
         for (int i=32; i<36; i++) {
-            assertEquals(expectedPointsForFirstEightBoats, leaderboard.getTotalPoints(c[i], later), 0.000000001);
+            assertEquals(expectedPointsForFirstEightBoats, leaderboard.getNetPoints(c[i], later), 0.000000001);
         }
         final double expectedPointsForLastEightBoats = (9.0 + 10.0 + 11.0 + 12.0 + 13.0 + 14.0 + 15.0 + 16.0) / 8.0;
         for (int i=16; i<20; i++) {
-            assertEquals(expectedPointsForLastEightBoats, leaderboard.getTotalPoints(c[i], later), 0.000000001);
+            assertEquals(expectedPointsForLastEightBoats, leaderboard.getNetPoints(c[i], later), 0.000000001);
         }
         for (int i=48; i<52; i++) {
-            assertEquals(expectedPointsForLastEightBoats, leaderboard.getTotalPoints(c[i], later), 0.000000001);
+            assertEquals(expectedPointsForLastEightBoats, leaderboard.getNetPoints(c[i], later), 0.000000001);
         }
     }
 
@@ -1029,16 +1029,16 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
             }
         }
         for (int i=0; i<4; i++) {
-            assertEquals(i==0?0.7:i+1, leaderboard.getTotalPoints(c[i], later), 0.000000001);
+            assertEquals(i==0?0.7:i+1, leaderboard.getNetPoints(c[i], later), 0.000000001);
         }
         for (int i=32; i<36; i++) {
-            assertEquals(i-27, leaderboard.getTotalPoints(c[i], later), 0.000000001);
+            assertEquals(i-27, leaderboard.getNetPoints(c[i], later), 0.000000001);
         }
         for (int i=16; i<20; i++) {
-            assertEquals(i-7, leaderboard.getTotalPoints(c[i], later), 0.000000001);
+            assertEquals(i-7, leaderboard.getNetPoints(c[i], later), 0.000000001);
         }
         for (int i=48; i<52; i++) {
-            assertEquals(i-35, leaderboard.getTotalPoints(c[i], later), 0.000000001);
+            assertEquals(i-35, leaderboard.getNetPoints(c[i], later), 0.000000001);
         }
     }
 
@@ -1068,13 +1068,13 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         // score averaging uses 1.0 for the first rank.
         final double expectedPointsForFirstEightBoats = (1.0 + 2.0 + 3.0 + 4.0 + 5.0 + 6.0 + 7.0 + 8.0) / 8.0;
         for (int i=0; i<8; i++) {
-            assertEquals(expectedPointsForFirstEightBoats, leaderboard.getTotalPoints(c[8*i], later), 0.0000001);
+            assertEquals(expectedPointsForFirstEightBoats, leaderboard.getNetPoints(c[8*i], later), 0.0000001);
             assertEquals("Competitor "+rankedCompetitors.get(i)+" not in list of best eight ",
                     0, Arrays.asList(c).indexOf(rankedCompetitors.get(i))%8); // each first competitor in a heat ranks in the top 8
         }
         for (int i=1; i<=3; i++) {
             for (Competitor comp : c) {
-                assertNull(leaderboard.getTotalPoints(comp, series.get(i).getRaceColumns().iterator().next(), later));
+                assertNull(leaderboard.getNetPoints(comp, series.get(i).getRaceColumns().iterator().next(), later));
             }
         }
     }
@@ -1157,14 +1157,14 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
                     .getDiscardedRaceColumns(competitors[competitorIndex], leaderboard, raceColumnsToConsider, timePoint);
             for (int raceColumnIndex=0; raceColumnIndex<raceColumnsToConsider.size(); raceColumnIndex++) {
                 assertEquals(scoresAfterNRaces[competitorIndex][raceColumnIndex],
-                        leaderboard.getTotalPoints(competitors[competitorIndex], raceColumnsToConsider.get(raceColumnIndex),
+                        leaderboard.getNetPoints(competitors[competitorIndex], raceColumnsToConsider.get(raceColumnIndex),
                                 timePoint, discardedRaceColumns), 0.00000001);
             }
         }
     }
 
     @Test
-    public void testTieBreakByMedalRaceScoreOnlyIfEqualTotalScore() throws NoWindException {
+    public void testTieBreakByMedalRaceScoreOnlyIfEqualNetScore() throws NoWindException {
         Competitor[] c = createCompetitors(2).toArray(new Competitor[0]);
         Competitor[] f1 = new Competitor[] { c[1], c[0] };
         Competitor[] f2 = new Competitor[] { c[1], c[0] };
@@ -1177,7 +1177,7 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         createAndAttachTrackedRaces(series.get(2), "Medal", /* withScores */ true, m1);
         List<Competitor> rankedCompetitors = leaderboard.getCompetitorsFromBestToWorst(later);
         // assert that both have equal score
-        assertEquals(leaderboard.getTotalPoints(c[0], later), leaderboard.getTotalPoints(c[1], later), 0.000000001);
+        assertEquals(leaderboard.getNetPoints(c[0], later), leaderboard.getNetPoints(c[1], later), 0.000000001);
         // assert that c[0] ranks better than c[1] (reason: c[0] ranked better in medal race)
         assertEquals(rankedCompetitors.indexOf(c[0]), rankedCompetitors.indexOf(c[1])-1);
     }
@@ -1203,7 +1203,7 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         createAndAttachTrackedRaces(series.get(2), "Medal", /* withScores */ true, m1, m2, m3);
         List<Competitor> rankedCompetitors = leaderboard.getCompetitorsFromBestToWorst(later);
         // assert that both have equal score
-        assertEquals(leaderboard.getTotalPoints(c[0], later), leaderboard.getTotalPoints(c[1], later), 0.000000001);
+        assertEquals(leaderboard.getNetPoints(c[0], later), leaderboard.getNetPoints(c[1], later), 0.000000001);
         // assert that c[1] ranks better than c[0] (reason: c[1] ranked better in medal race)
         assertEquals(rankedCompetitors.indexOf(c[1]), rankedCompetitors.indexOf(c[0])-1);
     }
@@ -1224,7 +1224,7 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         Leaderboard leaderboard = createLeaderboard(regatta, /* discarding thresholds */ new int[0]);
         TimePoint later = createAndAttachTrackedRaces(series.get(1), "Default", /* withScores */ true, f1, f2, f3, f4, f5, f6);
         List<Competitor> rankedCompetitors = leaderboard.getCompetitorsFromBestToWorst(later);
-        assertEquals(leaderboard.getTotalPoints(c[0], later), leaderboard.getTotalPoints(c[1], later), 0.000000001);
+        assertEquals(leaderboard.getNetPoints(c[0], later), leaderboard.getNetPoints(c[1], later), 0.000000001);
         assertEquals(rankedCompetitors.indexOf(c[0]), rankedCompetitors.indexOf(c[1])-1);
     }
     
@@ -1244,7 +1244,7 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         Leaderboard leaderboard = createLeaderboard(regatta, /* discarding thresholds */ new int[0]);
         TimePoint later = createAndAttachTrackedRaces(series.get(1), "Default", /* withScores */ true, f1, f2, f3, f4, f5, f6);
         List<Competitor> rankedCompetitors = leaderboard.getCompetitorsFromBestToWorst(later);
-        assertEquals(leaderboard.getTotalPoints(c[0], later), leaderboard.getTotalPoints(c[1], later), 0.000000001);
+        assertEquals(leaderboard.getNetPoints(c[0], later), leaderboard.getNetPoints(c[1], later), 0.000000001);
         assertEquals(rankedCompetitors.indexOf(c[0]), rankedCompetitors.indexOf(c[1])-1);
     }
 
@@ -1263,28 +1263,28 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
                 new HighPointFirstGets10Or8AndLastBreaksTie(), null);
         leaderboardHighPoint10Or8AndLastBreaksTie.addRace(new MockedTrackedRaceWithStartTimeAndRanks(now, Arrays.asList(competitors), dummyRegatta), "R1", /* medalRace */ false);
         assertTrue(leaderboardHighPoint10Or8AndLastBreaksTie.getScoringScheme().getScoreComparator(/* nullScoresAreBetter */ false).compare(
-                leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[0], later), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[3], later)) < 0); // c0 better than c3
+                leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[0], later), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[3], later)) < 0); // c0 better than c3
         assertEquals(10, leaderboardHighPoint10Or8AndLastBreaksTie.getCompetitorsFromBestToWorst(later).size());
-        assertEquals(new Double(10), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[0], later));
+        assertEquals(new Double(10), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[0], later));
-        assertEquals(new Double(9), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[1], later));
+        assertEquals(new Double(9), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[1], later));
-        assertEquals(new Double(1), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[9], later));
+        assertEquals(new Double(1), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[9], later));
         leaderboardHighPoint10Or8AndLastBreaksTie.addRace(new MockedTrackedRaceWithStartTimeAndRanks(now, Arrays.asList(competitors), dummyRegatta), "R2", /* medalRace */ false);
-        assertEquals(new Double(20), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[0], later));
+        assertEquals(new Double(20), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[0], later));
-        assertEquals(new Double(18), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[1], later));
+        assertEquals(new Double(18), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[1], later));
-        assertEquals(new Double(2), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[9], later));
+        assertEquals(new Double(2), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[9], later));
         RaceLog raceLogForRace2 = leaderboardHighPoint10Or8AndLastBreaksTie.getRaceColumnByName("R2").getRaceLog(leaderboardHighPoint10Or8AndLastBreaksTie.getFleet(null));
         raceLogForRace2.add(new RaceLogAdditionalScoringInformationEventImpl(now, later, new LogEventAuthorImpl("Plopp", 1), "12345678", 0, AdditionalScoringInformationType.UNKNOWN));
-        assertEquals(new Double(20), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[0], later));
+        assertEquals(new Double(20), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[0], later));
-        assertEquals(new Double(18), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[1], later));
+        assertEquals(new Double(18), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[1], later));
-        assertEquals(new Double(2), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[9], later));
+        assertEquals(new Double(2), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[9], later));
         raceLogForRace2.add(new RaceLogAdditionalScoringInformationEventImpl(now, later.plus(Duration.ONE_MINUTE), new LogEventAuthorImpl("Plopp", 1), "123456789873773762", 0, AdditionalScoringInformationType.MAX_POINTS_DECREASE_MAX_SCORE));
-        assertEquals(new Double(18), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[0], later));
+        assertEquals(new Double(18), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[0], later));
-        assertEquals(new Double(16), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[1], later));
+        assertEquals(new Double(16), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[1], later));
-        assertEquals(new Double(2), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[9], later));
+        assertEquals(new Double(2), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[9], later));
         leaderboardHighPoint10Or8AndLastBreaksTie.addRace(new MockedTrackedRaceWithStartTimeAndRanks(now, Arrays.asList(competitors), dummyRegatta), "R3", /* medalRace */ false);
-        assertEquals(new Double(28), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[0], later));
+        assertEquals(new Double(28), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[0], later));
-        assertEquals(new Double(25), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[1], later));
+        assertEquals(new Double(25), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[1], later));
-        assertEquals(new Double(3), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[9], later));
+        assertEquals(new Double(3), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[9], later));
         AdditionalScoringInformationFinder finder = new AdditionalScoringInformationFinder(raceLogForRace2);
         RaceLogAdditionalScoringInformationEvent event = finder.analyze(/*filterBy*/AdditionalScoringInformationType.MAX_POINTS_DECREASE_MAX_SCORE);
         assert event != null;
@@ -1295,18 +1295,18 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         }
         event = finder.analyze(/*filterBy*/AdditionalScoringInformationType.MAX_POINTS_DECREASE_MAX_SCORE);
         assert event == null;
-        assertEquals(new Double(30), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[0], later));
+        assertEquals(new Double(30), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[0], later));
-        assertEquals(new Double(3), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[9], later));
+        assertEquals(new Double(3), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[9], later));
         RaceState raceStateForRace2 = RaceStateImpl.create(mock(RaceLogResolver.class), raceLogForRace2, new LogEventAuthorImpl("Simon", 1));
         assertFalse(raceStateForRace2.isAdditionalScoringInformationEnabled(AdditionalScoringInformationType.MAX_POINTS_DECREASE_MAX_SCORE));
         raceStateForRace2.setAdditionalScoringInformationEnabled(later.plus(Duration.ONE_MINUTE).plus(Duration.ONE_SECOND), /*enable*/true, AdditionalScoringInformationType.MAX_POINTS_DECREASE_MAX_SCORE);
         assertTrue(raceStateForRace2.isAdditionalScoringInformationEnabled(AdditionalScoringInformationType.MAX_POINTS_DECREASE_MAX_SCORE));
-        assertEquals(new Double(28), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[0], later));
+        assertEquals(new Double(28), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[0], later));
-        assertEquals(new Double(3), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[9], later));
+        assertEquals(new Double(3), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[9], later));
         raceStateForRace2.setAdditionalScoringInformationEnabled(later.plus(Duration.ONE_MINUTE).plus(Duration.ONE_SECOND.plus(10000)), /*enable*/false, AdditionalScoringInformationType.MAX_POINTS_DECREASE_MAX_SCORE);
         assertFalse(raceStateForRace2.isAdditionalScoringInformationEnabled(AdditionalScoringInformationType.MAX_POINTS_DECREASE_MAX_SCORE));
-        assertEquals(new Double(30), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[0], later));
+        assertEquals(new Double(30), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[0], later));
-        assertEquals(new Double(3), leaderboardHighPoint10Or8AndLastBreaksTie.getTotalPoints(competitors[9], later));
+        assertEquals(new Double(3), leaderboardHighPoint10Or8AndLastBreaksTie.getNetPoints(competitors[9], later));
         LeaderboardDTO leaderboardDTO  = null;
         try {
             leaderboardDTO = leaderboardHighPoint10Or8AndLastBreaksTie.getLeaderboardDTO(later.plus(Duration.ONE_HOUR), Collections.<String>emptyList(), false, trackedRegattaRegistry, DomainFactory.INSTANCE, false);
@@ -1316,7 +1316,7 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
             e.printStackTrace();
         }
         assert leaderboardDTO != null;
-        assertEquals(30.0, leaderboardDTO.rows.get(leaderboardDTO.competitors.get(0)).totalPoints, 0.000000000001);
+        assertEquals(30.0, leaderboardDTO.rows.get(leaderboardDTO.competitors.get(0)).netPoints, 0.000000000001);
         raceStateForRace2.setAdditionalScoringInformationEnabled(later.plus(Duration.ONE_MINUTE).plus(Duration.ONE_SECOND.plus(20000)), /*enable*/true, AdditionalScoringInformationType.MAX_POINTS_DECREASE_MAX_SCORE);
         try {
             leaderboardDTO = leaderboardHighPoint10Or8AndLastBreaksTie.getLeaderboardDTO(later.plus(Duration.ONE_HOUR), Collections.<String>emptyList(), false, trackedRegattaRegistry, DomainFactory.INSTANCE, false);
@@ -1325,8 +1325,8 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         } catch (ExecutionException e) {
             e.printStackTrace();
         }
-        assertEquals(28.0, leaderboardDTO.rows.get(leaderboardDTO.competitors.get(0)).totalPoints, 0.000000000001);
+        assertEquals(28.0, leaderboardDTO.rows.get(leaderboardDTO.competitors.get(0)).netPoints, 0.000000000001);
-        assertEquals(25.0, leaderboardDTO.rows.get(leaderboardDTO.competitors.get(1)).totalPoints, 0.000000000001);
+        assertEquals(25.0, leaderboardDTO.rows.get(leaderboardDTO.competitors.get(1)).netPoints, 0.000000000001);
     }
 
     @Test
@@ -1340,35 +1340,35 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
                 .addRace(new MockedTrackedRaceWithStartTimeAndRanks(now, Arrays.asList(competitors)), "R1", /* medalRace */
                         false);
         assertTrue(leaderboardHighPoint10LastBreaksTie.getScoringScheme().getScoreComparator(/* nullScoresAreBetter */ false).compare(
-                leaderboardHighPoint10LastBreaksTie.getTotalPoints(competitors[0], later), leaderboardHighPoint10LastBreaksTie.getTotalPoints(competitors[3], later)) < 0); // c0 better than c3
+                leaderboardHighPoint10LastBreaksTie.getNetPoints(competitors[0], later), leaderboardHighPoint10LastBreaksTie.getNetPoints(competitors[3], later)) < 0); // c0 better than c3
         assertEquals(16, leaderboardHighPoint10LastBreaksTie.getCompetitorsFromBestToWorst(later).size());
-        assertEquals(new Double(10), leaderboardHighPoint10LastBreaksTie.getTotalPoints(competitors[0], later));
+        assertEquals(new Double(10), leaderboardHighPoint10LastBreaksTie.getNetPoints(competitors[0], later));
-        assertEquals(new Double(1), leaderboardHighPoint10LastBreaksTie.getTotalPoints(competitors[15], later));
+        assertEquals(new Double(1), leaderboardHighPoint10LastBreaksTie.getNetPoints(competitors[15], later));
         // Normal HighPoint leaderboard has no max so that winner gets as many points as there are competitors
         FlexibleLeaderboard leaderboardHighPoint = new FlexibleLeaderboardImpl("Test ESS Highpoint", new ThresholdBasedResultDiscardingRuleImpl(/* discarding thresholds */ new int[0]),
                 new HighPoint(), null);
         leaderboardHighPoint.addRace(new MockedTrackedRaceWithStartTimeAndRanks(now, Arrays.asList(competitors)), "R1", /* medalRace */
                 false);
         assertEquals(16, leaderboardHighPoint.getCompetitorsFromBestToWorst(later).size());
-        assertEquals(new Double(16), leaderboardHighPoint.getTotalPoints(competitors[0], later));
+        assertEquals(new Double(16), leaderboardHighPoint.getNetPoints(competitors[0], later));
         LeaderboardGroup leaderboardGroup = new LeaderboardGroupImpl("ESS", "ESS", /* displayName */ null,
                 /* displayGroupsInReverseOrder */ false, Arrays.asList(new Leaderboard[] { leaderboardHighPoint10LastBreaksTie }));
         LeaderboardGroupMetaLeaderboard leaderboardHighPointESSOverall = new LeaderboardGroupMetaLeaderboard(
                 leaderboardGroup, new HighPointExtremeSailingSeriesOverall(),
                 new ThresholdBasedResultDiscardingRuleImpl(/* discarding thresholds */ new int[0]));
         assertEquals(16, leaderboardHighPointESSOverall.getCompetitorsFromBestToWorst(later).size());
-        assertEquals(new Double(10), leaderboardHighPointESSOverall.getTotalPoints(competitors[0], later));
+        assertEquals(new Double(10), leaderboardHighPointESSOverall.getNetPoints(competitors[0], later));
-        assertEquals(new Double(9), leaderboardHighPointESSOverall.getTotalPoints(competitors[1], later));
+        assertEquals(new Double(9), leaderboardHighPointESSOverall.getNetPoints(competitors[1], later));
-        assertEquals(new Double(8), leaderboardHighPointESSOverall.getTotalPoints(competitors[2], later));
+        assertEquals(new Double(8), leaderboardHighPointESSOverall.getNetPoints(competitors[2], later));
-        assertEquals(new Double(7), leaderboardHighPointESSOverall.getTotalPoints(competitors[3], later));
+        assertEquals(new Double(7), leaderboardHighPointESSOverall.getNetPoints(competitors[3], later));
-        assertEquals(new Double(6), leaderboardHighPointESSOverall.getTotalPoints(competitors[4], later));
+        assertEquals(new Double(6), leaderboardHighPointESSOverall.getNetPoints(competitors[4], later));
-        assertEquals(new Double(5), leaderboardHighPointESSOverall.getTotalPoints(competitors[5], later));
+        assertEquals(new Double(5), leaderboardHighPointESSOverall.getNetPoints(competitors[5], later));
-        assertEquals(new Double(4), leaderboardHighPointESSOverall.getTotalPoints(competitors[6], later));
+        assertEquals(new Double(4), leaderboardHighPointESSOverall.getNetPoints(competitors[6], later));
-        assertEquals(new Double(3), leaderboardHighPointESSOverall.getTotalPoints(competitors[7], later));
+        assertEquals(new Double(3), leaderboardHighPointESSOverall.getNetPoints(competitors[7], later));
-        assertEquals(new Double(2), leaderboardHighPointESSOverall.getTotalPoints(competitors[8], later));
+        assertEquals(new Double(2), leaderboardHighPointESSOverall.getNetPoints(competitors[8], later));
-        assertEquals(new Double(1), leaderboardHighPointESSOverall.getTotalPoints(competitors[9], later));
+        assertEquals(new Double(1), leaderboardHighPointESSOverall.getNetPoints(competitors[9], later));
-        assertEquals(new Double(1), leaderboardHighPointESSOverall.getTotalPoints(competitors[14], later));
+        assertEquals(new Double(1), leaderboardHighPointESSOverall.getNetPoints(competitors[14], later));
-        assertEquals(new Double(1), leaderboardHighPointESSOverall.getTotalPoints(competitors[15], later));
+        assertEquals(new Double(1), leaderboardHighPointESSOverall.getNetPoints(competitors[15], later));
     }
 
     @Test
@@ -1392,7 +1392,7 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         leaderboard1.addRace(new MockedTrackedRaceWithStartTimeAndRanks(now, Arrays.asList(f2)), "R2", /* medalRace */
                 false);
         assertTrue(leaderboard1.getScoringScheme().getScoreComparator(/* nullScoresAreBetter */ false).compare(
-                leaderboard1.getTotalPoints(c[0], later), leaderboard1.getTotalPoints(c[3], later)) < 0); // c0 better than c3
+                leaderboard1.getNetPoints(c[0], later), leaderboard1.getNetPoints(c[3], later)) < 0); // c0 better than c3
         FlexibleLeaderboard leaderboard2 = new FlexibleLeaderboardImpl("Leaderboard 3", new ThresholdBasedResultDiscardingRuleImpl(/* discarding thresholds */ new int[0]),
                 new HighPoint(), null);
         leaderboard2.addRace(new MockedTrackedRaceWithStartTimeAndRanks(now, Arrays.asList(f3)), "R1", /* medalRace */
@@ -1400,7 +1400,7 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         leaderboard2.addRace(new MockedTrackedRaceWithStartTimeAndRanks(now, Arrays.asList(f4)), "R2", /* medalRace */
                 false);
         assertTrue(leaderboard2.getScoringScheme().getScoreComparator(/* nullScoresAreBetter */ false).compare(
-                leaderboard2.getTotalPoints(c[3], later), leaderboard2.getTotalPoints(c[0], later)) < 0); // c3 better than c0
+                leaderboard2.getNetPoints(c[3], later), leaderboard2.getNetPoints(c[0], later)) < 0); // c3 better than c0
         FlexibleLeaderboard leaderboard3 = new FlexibleLeaderboardImpl("Leaderboard 3", new ThresholdBasedResultDiscardingRuleImpl(/* discarding thresholds */ new int[0]),
                 new HighPoint(), null);
         leaderboard3.addRace(new MockedTrackedRaceWithStartTimeAndRanks(now, Arrays.asList(f5)), "R1", /* medalRace */
@@ -1419,8 +1419,8 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         assertFalse(rankedCompetitors.contains(c[1]));
         assertFalse(rankedCompetitors.contains(c[2]));
         assertEquals(2, rankedCompetitors.size());
-        assertEquals(28 /* one win, two second */, leaderboardGroup.getOverallLeaderboard().getTotalPoints(c[0], later), 0.000000001);
+        assertEquals(28 /* one win, two second */, leaderboardGroup.getOverallLeaderboard().getNetPoints(c[0], later), 0.000000001);
-        assertEquals(29 /* two wins, one second */, leaderboardGroup.getOverallLeaderboard().getTotalPoints(c[3], later), 0.000000001);
+        assertEquals(29 /* two wins, one second */, leaderboardGroup.getOverallLeaderboard().getNetPoints(c[3], later), 0.000000001);
     }
 
     @Test
@@ -1434,9 +1434,9 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
                 new HighPointFirstGets10Or8AndLastBreaksTie(), null);
         leaderboard1.addRace(new MockedTrackedRaceWithStartTimeAndRanks(now, Arrays.asList(f1)), "R1", /* medalRace */
                 false);
-        assertTrue(leaderboard1.getTotalPoints(c[2], later) > leaderboard1.getTotalPoints(c[0], later)); // c2 better than c[0]
+        assertTrue(leaderboard1.getNetPoints(c[2], later) > leaderboard1.getNetPoints(c[0], later)); // c2 better than c[0]
-        assertEquals(10.0, leaderboard1.getTotalPoints(c[2], later), 0.1);
+        assertEquals(10.0, leaderboard1.getNetPoints(c[2], later), 0.1);
-        assertEquals(9.0, leaderboard1.getTotalPoints(c[0], later), 0.1);
+        assertEquals(9.0, leaderboard1.getNetPoints(c[0], later), 0.1);
         FlexibleLeaderboard leaderboard2 = new FlexibleLeaderboardImpl("Regatta 2", new ThresholdBasedResultDiscardingRuleImpl(/* discarding thresholds */ new int[0]),
                 new HighPointFirstGets10Or8AndLastBreaksTie(), null);
         leaderboard2.addRace(new MockedTrackedRaceWithStartTimeAndRanks(now, Arrays.asList(f2)), "R1", /* medalRace */
@@ -1447,10 +1447,10 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
                 new ThresholdBasedResultDiscardingRuleImpl(new int[0])));
         List<Competitor> rankedCompetitors = leaderboardGroup.getOverallLeaderboard().getCompetitorsFromBestToWorst(later);
         assertEquals(4, rankedCompetitors.size());
-        assertEquals(19, leaderboardGroup.getOverallLeaderboard().getTotalPoints(c[0], later), 0.000000001);
+        assertEquals(19, leaderboardGroup.getOverallLeaderboard().getNetPoints(c[0], later), 0.000000001);
-        assertEquals(19, leaderboardGroup.getOverallLeaderboard().getTotalPoints(c[2], later), 0.000000001);
+        assertEquals(19, leaderboardGroup.getOverallLeaderboard().getNetPoints(c[2], later), 0.000000001);
-        assertEquals(16, leaderboardGroup.getOverallLeaderboard().getTotalPoints(c[1], later), 0.000000001);
+        assertEquals(16, leaderboardGroup.getOverallLeaderboard().getNetPoints(c[1], later), 0.000000001);
-        assertEquals(14, leaderboardGroup.getOverallLeaderboard().getTotalPoints(c[3], later), 0.000000001);
+        assertEquals(14, leaderboardGroup.getOverallLeaderboard().getNetPoints(c[3], later), 0.000000001);
         assertEquals(c[0], rankedCompetitors.get(0));
         assertEquals(c[2], rankedCompetitors.get(1));
     }
@@ -1492,34 +1492,34 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         assertEquals(8, rankedCompetitorsFleet1.size());
         for (int i = 0; i < expectedResultsFleet1.length; i++) {
             assertTrue(rankedCompetitorsFleet1.get(i) == competitors.get(i));
-            assertEquals(expectedResultsFleet1[i], leaderboard.getTotalPoints(rankedCompetitorsFleet1.get(i), later), 0.000000001);
+            assertEquals(expectedResultsFleet1[i], leaderboard.getNetPoints(rankedCompetitorsFleet1.get(i), later), 0.000000001);
         }
 
         List<Competitor> rankedCompetitorsFleet2 = r1Fleet2.getCompetitorsFromBestToWorst(later);
         assertEquals(7, rankedCompetitorsFleet2.size());
         for (int i = 0; i < expectedResultsFleet2.length; i++) {
             assertTrue(rankedCompetitorsFleet2.get(i) == competitors.get(8+i));
-            assertEquals(expectedResultsFleet2[i], leaderboard.getTotalPoints(rankedCompetitorsFleet2.get(i), later), 0.000000001);
+            assertEquals(expectedResultsFleet2[i], leaderboard.getNetPoints(rankedCompetitorsFleet2.get(i), later), 0.000000001);
         }
         
         List<Competitor> rankedCompetitorsFleet3 = r1Fleet3.getCompetitorsFromBestToWorst(later);
         assertEquals(6, rankedCompetitorsFleet3.size());
         for (int i = 0; i < expectedResultsFleet3.length; i++) {
             assertTrue(rankedCompetitorsFleet3.get(i) == competitors.get(15+i));
-            assertEquals(expectedResultsFleet3[i], leaderboard.getTotalPoints(rankedCompetitorsFleet3.get(i), later), 0.000000001);
+            assertEquals(expectedResultsFleet3[i], leaderboard.getNetPoints(rankedCompetitorsFleet3.get(i), later), 0.000000001);
         }
         
         List<Competitor> allCompetitorsFromBestToWorst = leaderboard.getCompetitorsFromBestToWorst(later);
         assertEquals(competitorsCount, allCompetitorsFromBestToWorst.size());
         // check that the fleet winners have all 8 points
-        assertEquals(8.0, leaderboard.getTotalPoints(allCompetitorsFromBestToWorst.get(0), later), 0.000000001);
+        assertEquals(8.0, leaderboard.getNetPoints(allCompetitorsFromBestToWorst.get(0), later), 0.000000001);
-        assertEquals(8.0, leaderboard.getTotalPoints(allCompetitorsFromBestToWorst.get(1), later), 0.000000001);
+        assertEquals(8.0, leaderboard.getNetPoints(allCompetitorsFromBestToWorst.get(1), later), 0.000000001);
-        assertEquals(8.0, leaderboard.getTotalPoints(allCompetitorsFromBestToWorst.get(2), later), 0.000000001);
+        assertEquals(8.0, leaderboard.getNetPoints(allCompetitorsFromBestToWorst.get(2), later), 0.000000001);
         // check that the fleet looser have all 1 point
         
-        assertEquals(1.0, leaderboard.getTotalPoints(allCompetitorsFromBestToWorst.get(competitorsCount-1), later), 0.000000001);
+        assertEquals(1.0, leaderboard.getNetPoints(allCompetitorsFromBestToWorst.get(competitorsCount-1), later), 0.000000001);
-        assertEquals(1.0, leaderboard.getTotalPoints(allCompetitorsFromBestToWorst.get(competitorsCount-2), later), 0.000000001);
+        assertEquals(1.0, leaderboard.getNetPoints(allCompetitorsFromBestToWorst.get(competitorsCount-2), later), 0.000000001);
-        assertEquals(1.0, leaderboard.getTotalPoints(allCompetitorsFromBestToWorst.get(competitorsCount-3), later), 0.000000001);
+        assertEquals(1.0, leaderboard.getNetPoints(allCompetitorsFromBestToWorst.get(competitorsCount-3), later), 0.000000001);
     }
     
     @Test
@@ -1552,14 +1552,14 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         List<Competitor> rankedCompetitorsInLeaderboard = leaderboard2.getCompetitorsFromBestToWorst(later);
         List<Double> scoresForCompetitors = new ArrayList<Double>();
         for (Competitor competitor : rankedCompetitorsInLeaderboard) {
-            scoresForCompetitors.add(leaderboard2.getTotalPoints(competitor, later));
+            scoresForCompetitors.add(leaderboard2.getNetPoints(competitor, later));
         }
         assertEquals(12, rankedCompetitorsInLeaderboard.size());
         assertEquals(c[1], rankedCompetitorsInLeaderboard.get(0));
-        assertEquals(29, leaderboard2.getTotalPoints(c[1], later), 0.000000001);
+        assertEquals(29, leaderboard2.getNetPoints(c[1], later), 0.000000001);
-        assertEquals(7, leaderboard2.getTotalPoints(c[8], later), 0.000000001);
+        assertEquals(7, leaderboard2.getNetPoints(c[8], later), 0.000000001);
-        assertEquals(4, leaderboard2.getTotalPoints(c[9], later), 0.000000001);
+        assertEquals(4, leaderboard2.getNetPoints(c[9], later), 0.000000001);
-        assertEquals(3, leaderboard2.getTotalPoints(c[11], later), 0.000000001);
+        assertEquals(3, leaderboard2.getNetPoints(c[11], later), 0.000000001);
         
         LeaderboardGroup leaderboardGroup = new LeaderboardGroupImpl("Leaderboard Group ESS Overall", "Leaderboard Group", /* displayName */ null,
                 false, Arrays.asList(leaderboard1, leaderboard2));
@@ -1600,9 +1600,9 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         }, "R1", /* medalRace */false);
         RaceColumn r2 = leaderboard1.addRaceColumn("R2", /* medalRace */false);
         leaderboard1.getScoreCorrection().correctScore(c[0], r2, 123.);
-        assertEquals(2. + 123., leaderboard1.getTotalPoints(c[0], afterEndOfR1), 0.00000001); // correction expected to apply after end of last tracked race before the corrected column
+        assertEquals(2. + 123., leaderboard1.getNetPoints(c[0], afterEndOfR1), 0.00000001); // correction expected to apply after end of last tracked race before the corrected column
-        assertEquals(2. + 0., leaderboard1.getTotalPoints(c[0], withinR1), 0.00000001); // correction expected NOT to apply before end of last tracked race before the corrected column
+        assertEquals(2. + 0., leaderboard1.getNetPoints(c[0], withinR1), 0.00000001); // correction expected NOT to apply before end of last tracked race before the corrected column
-        assertEquals(0., leaderboard1.getTotalPoints(c[0], beforeStartOfR1), 0.00000001); // not even the R1 scores apply before the start time of R1
+        assertEquals(0., leaderboard1.getNetPoints(c[0], beforeStartOfR1), 0.00000001); // not even the R1 scores apply before the start time of R1
     }
     
     /**
@@ -1629,9 +1629,9 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         assertEquals(MaxPointsReason.NONE, leaderboard1.getMaxPointsReason(c[0], leaderboard1.getRaceColumnByName("R1"), beforeStartOfR1));
         assertEquals(MaxPointsReason.DNS, leaderboard1.getMaxPointsReason(c[0], leaderboard1.getRaceColumnByName("R1"), withinR1));
         assertEquals(MaxPointsReason.DNS, leaderboard1.getMaxPointsReason(c[0], leaderboard1.getRaceColumnByName("R1"), afterEndOfR1));
-        assertNull(leaderboard1.getNetPoints(c[0], leaderboard1.getRaceColumnByName("R1"), beforeStartOfR1));
+        assertNull(leaderboard1.getTotalPoints(c[0], leaderboard1.getRaceColumnByName("R1"), beforeStartOfR1));
-        assertEquals(123., leaderboard1.getNetPoints(c[0], leaderboard1.getRaceColumnByName("R1"), withinR1), 0.00000001);
+        assertEquals(123., leaderboard1.getTotalPoints(c[0], leaderboard1.getRaceColumnByName("R1"), withinR1), 0.00000001);
-        assertEquals(123., leaderboard1.getNetPoints(c[0], leaderboard1.getRaceColumnByName("R1"), afterEndOfR1), 0.00000001);
+        assertEquals(123., leaderboard1.getTotalPoints(c[0], leaderboard1.getRaceColumnByName("R1"), afterEndOfR1), 0.00000001);
     }
     
     /**
@@ -1658,9 +1658,9 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         assertEquals(MaxPointsReason.NONE, leaderboard1.getMaxPointsReason(c[0], leaderboard1.getRaceColumnByName("R1"), beforeStartOfR1));
         assertEquals(MaxPointsReason.NONE, leaderboard1.getMaxPointsReason(c[0], leaderboard1.getRaceColumnByName("R1"), withinR1));
         assertEquals(MaxPointsReason.DNF, leaderboard1.getMaxPointsReason(c[0], leaderboard1.getRaceColumnByName("R1"), afterEndOfR1));
-        assertNull(leaderboard1.getNetPoints(c[0], leaderboard1.getRaceColumnByName("R1"), beforeStartOfR1));
+        assertNull(leaderboard1.getTotalPoints(c[0], leaderboard1.getRaceColumnByName("R1"), beforeStartOfR1));
-        assertEquals(1.0, leaderboard1.getNetPoints(c[0], leaderboard1.getRaceColumnByName("R1"), withinR1), 0.00000001); // tracked rank is 1
+        assertEquals(1.0, leaderboard1.getTotalPoints(c[0], leaderboard1.getRaceColumnByName("R1"), withinR1), 0.00000001); // tracked rank is 1
-        assertEquals(123., leaderboard1.getNetPoints(c[0], leaderboard1.getRaceColumnByName("R1"), afterEndOfR1), 0.00000001);
+        assertEquals(123., leaderboard1.getTotalPoints(c[0], leaderboard1.getRaceColumnByName("R1"), afterEndOfR1), 0.00000001);
     }
     
 
@@ -1691,7 +1691,7 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
             }
                 }, "R2", /* medalRace */false);
         leaderboard1.getScoreCorrection().correctScore(c1[0], r2, .9);
-        assertEquals(1. + .9, leaderboard1.getTotalPoints(c1[0], afterEndOfR1), 0.00000001);
+        assertEquals(1. + .9, leaderboard1.getNetPoints(c1[0], afterEndOfR1), 0.00000001);
         assertEquals(1, leaderboard1.getTotalRankOfCompetitor(c1[0], afterEndOfR1));
         // now assert that the competitor c1[0] is best in r2 because of the score correction, although c1[0] doesn't have a fleet
         assertEquals(0, leaderboard1.getCompetitorsFromBestToWorst(r2, afterEndOfR1).indexOf(c1[0]));
@@ -1732,35 +1732,35 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         RaceColumn r1 = leaderboard1.addRace(trackedRace, "R1", /* medalRace */false);
         RaceColumn r2 = leaderboard1.addRaceColumn("R2", /* medalRace */false);
         leaderboard1.getScoreCorrection().correctScore(c[0], r2, 123.);
-        assertEquals(2. + 123., leaderboard1.getTotalPoints(c[0], afterEndOfR1), 0.00000001); // correction expected to apply after end of last tracked race before the corrected column
+        assertEquals(2. + 123., leaderboard1.getNetPoints(c[0], afterEndOfR1), 0.00000001); // correction expected to apply after end of last tracked race before the corrected column
-        assertEquals(2. + 0., leaderboard1.getTotalPoints(c[0], withinR1), 0.00000001); // correction expected NOT to apply before end of last tracked race before the corrected column
+        assertEquals(2. + 0., leaderboard1.getNetPoints(c[0], withinR1), 0.00000001); // correction expected NOT to apply before end of last tracked race before the corrected column
-        assertEquals(0., leaderboard1.getTotalPoints(c[0], beforeStartOfR1), 0.00000001); // not even the R1 scores apply before the start time of R1
+        assertEquals(0., leaderboard1.getNetPoints(c[0], beforeStartOfR1), 0.00000001); // not even the R1 scores apply before the start time of R1
 
         leaderboard1.getScoreCorrection().setMaxPointsReason(c[1], r2, MaxPointsReason.DNS);
-        assertEquals(3. + 5., leaderboard1.getTotalPoints(c[1], afterEndOfR1), 0.00000001); // DNS is applied at race start (not known), so at least after the end of R1
+        assertEquals(3. + 5., leaderboard1.getNetPoints(c[1], afterEndOfR1), 0.00000001); // DNS is applied at race start (not known), so at least after the end of R1
-        assertEquals(3. + 0., leaderboard1.getTotalPoints(c[1], withinR1), 0.00000001); // correction expected NOT to apply before end of last tracked race before the corrected column
+        assertEquals(3. + 0., leaderboard1.getNetPoints(c[1], withinR1), 0.00000001); // correction expected NOT to apply before end of last tracked race before the corrected column
-        assertEquals(0., leaderboard1.getTotalPoints(c[1], beforeStartOfR1), 0.00000001); // not even the R1 scores apply before the start time of R1
+        assertEquals(0., leaderboard1.getNetPoints(c[1], beforeStartOfR1), 0.00000001); // not even the R1 scores apply before the start time of R1
 
         leaderboard1.getScoreCorrection().setMaxPointsReason(c[2], r2, MaxPointsReason.DNF);
-        assertEquals(1. + 5., leaderboard1.getTotalPoints(c[2], afterEndOfR1), 0.00000001); // DNF is applied after R2 finish (not known), so at least after the end of R1
+        assertEquals(1. + 5., leaderboard1.getNetPoints(c[2], afterEndOfR1), 0.00000001); // DNF is applied after R2 finish (not known), so at least after the end of R1
-        assertEquals(1. + 0., leaderboard1.getTotalPoints(c[2], withinR1), 0.00000001); // correction expected NOT to apply before end of last tracked race before the corrected column
+        assertEquals(1. + 0., leaderboard1.getNetPoints(c[2], withinR1), 0.00000001); // correction expected NOT to apply before end of last tracked race before the corrected column
-        assertEquals(0., leaderboard1.getTotalPoints(c[2], beforeStartOfR1), 0.00000001); // not even the R1 scores apply before the start time of R1
+        assertEquals(0., leaderboard1.getNetPoints(c[2], beforeStartOfR1), 0.00000001); // not even the R1 scores apply before the start time of R1
 
         leaderboard1.getScoreCorrection().setMaxPointsReason(c[3], r1, MaxPointsReason.DNF);
-        assertEquals(0., leaderboard1.getTotalPoints(c[3], beforeStartOfR1), 0.00000001); // DNF does not apply before the start
+        assertEquals(0., leaderboard1.getNetPoints(c[3], beforeStartOfR1), 0.00000001); // DNF does not apply before the start
-        assertEquals(4., leaderboard1.getTotalPoints(c[3], withinR1), 0.00000001); // correction expected NOT to apply before end of race
+        assertEquals(4., leaderboard1.getNetPoints(c[3], withinR1), 0.00000001); // correction expected NOT to apply before end of race
-        assertEquals(5., leaderboard1.getTotalPoints(c[3], afterEndOfR1), 0.00000001); // after race is finished, DNF applies
+        assertEquals(5., leaderboard1.getNetPoints(c[3], afterEndOfR1), 0.00000001); // after race is finished, DNF applies
 
         leaderboard1.getScoreCorrection().setMaxPointsReason(c[3], r1, MaxPointsReason.DNS);
-        assertEquals(0., leaderboard1.getTotalPoints(c[3], beforeStartOfR1), 0.00000001); // DNS does not apply before the start
+        assertEquals(0., leaderboard1.getNetPoints(c[3], beforeStartOfR1), 0.00000001); // DNS does not apply before the start
-        assertEquals(5., leaderboard1.getTotalPoints(c[3], withinR1), 0.00000001); // correction expected to apply after the start
+        assertEquals(5., leaderboard1.getNetPoints(c[3], withinR1), 0.00000001); // correction expected to apply after the start
-        assertEquals(5., leaderboard1.getTotalPoints(c[3], afterEndOfR1), 0.00000001); // not even the R1 scores apply before the start time of R1
+        assertEquals(5., leaderboard1.getNetPoints(c[3], afterEndOfR1), 0.00000001); // not even the R1 scores apply before the start time of R1
 
         leaderboard1.getScoreCorrection().setMaxPointsReason(c[3], r1, null);
         leaderboard1.getScoreCorrection().correctScore(c[3], r1, 123.);
-        assertEquals(4., leaderboard1.getTotalPoints(c[3], withinR1), 0.00000001); // correction expected NOT to apply before end of last tracked race before the corrected column
+        assertEquals(4., leaderboard1.getNetPoints(c[3], withinR1), 0.00000001); // correction expected NOT to apply before end of last tracked race before the corrected column
-        assertEquals(123., leaderboard1.getTotalPoints(c[3], afterEndOfR1), 0.00000001); // correction is applied after R1 finish
+        assertEquals(123., leaderboard1.getNetPoints(c[3], afterEndOfR1), 0.00000001); // correction is applied after R1 finish
-        assertEquals(0., leaderboard1.getTotalPoints(c[3], beforeStartOfR1), 0.00000001); // not even the R1 scores apply before the start time of R1
+        assertEquals(0., leaderboard1.getNetPoints(c[3], beforeStartOfR1), 0.00000001); // not even the R1 scores apply before the start time of R1
     }
 
     private TimePoint createAndAttachTrackedRaces(Series theSeries, String fleetName, boolean withScores, Competitor[]... competitorLists) {
@@ -2013,21 +2013,21 @@ public class LeaderboardScoringAndRankingTest extends AbstractLeaderboardTest {
         r2Column.setTrackedRace(r2Column.getFleetByName("Default"), r2Default);
 
         List<Competitor> rankedCompetitors = leaderboard.getCompetitorsFromBestToWorst(later);
-        Map<Competitor, Double> totalPoints = new LinkedHashMap<>();
+        Map<Competitor, Double> netPoints = new LinkedHashMap<>();
         for (Competitor rankedCompetitor : rankedCompetitors) {
-            totalPoints.put(rankedCompetitor, leaderboard.getTotalPoints(rankedCompetitor, later));
+            netPoints.put(rankedCompetitor, leaderboard.getNetPoints(rankedCompetitor, later));
         }
         // assert that the final column competitors are ranked from top to bottom:
         double scoreInFinalRace = 10.0;
         for (Competitor rankedCompetitor : leaderboard.getCompetitorsFromBestToWorst(f1Column, later)) {
-            assertEquals(scoreInFinalRace, leaderboard.getTotalPoints(rankedCompetitor, f1Column, later), 0.000001);
+            assertEquals(scoreInFinalRace, leaderboard.getNetPoints(rankedCompetitor, f1Column, later), 0.000001);
             scoreInFinalRace = Math.max(scoreInFinalRace-1, 1);
         }
         double lastScore = Double.MAX_VALUE;
         // assert that only the points matter for ranking; not the fleet assignment
         for (Competitor rankedCompetitor : rankedCompetitors) {
             // with a high-point scoring scheme, assert that as competitors get worse, scores get less
-            double rankedCompetitorScore = totalPoints.get(rankedCompetitor);
+            double rankedCompetitorScore = netPoints.get(rankedCompetitor);
             assertTrue("Expected " + rankedCompetitor + " with rank "
                     + (rankedCompetitors.indexOf(rankedCompetitor) + 1)
                     + " to have worse (lesser) score than its immediate better competitor who scored " + lastScore

java/com.sap.sailing.domain.test/src/com/sap/sailing/domain/test/RegattaLogEventNotificationForwardingTest.java

@@ -163,16 +163,16 @@ public class RegattaLogEventNotificationForwardingTest extends AbstractSerializa
         final TimePoint now = MillisecondsTimePoint.now();
         leaderboard.getScoreCorrection().setTimePointOfLastCorrectionsValidity(now);
         LeaderboardDTO dto = leaderboard.getLeaderboardDTO(now.plus(10), Collections.emptySet(), /* addOverallDetails */ false,
-                /* trackedRegattaRegistry */ null, DomainFactory.INSTANCE, /* fillNetPointsUncorrected */ false);
+                /* trackedRegattaRegistry */ null, DomainFactory.INSTANCE, /* fillTotalPointsUncorrected */ false);
         assertTrue(dto.competitors.isEmpty());
         final RegattaLogRegisterCompetitorEvent event = createRegattaLogEvent();
         regatta.getRegattaLog().add(event);
         LeaderboardDTO dto2 = leaderboard.computeDTO(now.plus(20), Collections.emptySet(), /* addOverallDetails */ false,
-                /* waitForLatestAnalyses */ false, /* trackedRegattaRegistry */ null, DomainFactory.INSTANCE, /* fillNetPointsUncorrected */ false);
+                /* waitForLatestAnalyses */ false, /* trackedRegattaRegistry */ null, DomainFactory.INSTANCE, /* fillTotalPointsUncorrected */ false);
         assertFalse(dto2.competitors.isEmpty());
         assertEquals(event.getCompetitor().getName(), dto2.competitors.get(0).getName());
         LeaderboardDTO dto3 = leaderboard.getLeaderboardDTO(now.plus(20), Collections.emptySet(), /* addOverallDetails */ false,
-                /* trackedRegattaRegistry */ null, DomainFactory.INSTANCE, /* fillNetPointsUncorrected */ false);
+                /* trackedRegattaRegistry */ null, DomainFactory.INSTANCE, /* fillTotalPointsUncorrected */ false);
         assertFalse(dto3.competitors.isEmpty());
         assertEquals(event.getCompetitor().getName(), dto3.competitors.get(0).getName());
     }
@@ -195,16 +195,16 @@ public class RegattaLogEventNotificationForwardingTest extends AbstractSerializa
         leaderboard.getScoreCorrection().setTimePointOfLastCorrectionsValidity(now);
         RegattaLeaderboard deserializedLeaderboard = cloneBySerialization(leaderboard, DomainFactory.INSTANCE);
         LeaderboardDTO dto = deserializedLeaderboard.getLeaderboardDTO(now.plus(10), Collections.emptySet(), /* addOverallDetails */ false,
-                /* trackedRegattaRegistry */ null, DomainFactory.INSTANCE, /* fillNetPointsUncorrected */ false);
+                /* trackedRegattaRegistry */ null, DomainFactory.INSTANCE, /* fillTotalPointsUncorrected */ false);
         assertTrue(dto.competitors.isEmpty());
         final RegattaLogRegisterCompetitorEvent event = createRegattaLogEvent();
         deserializedLeaderboard.getRegatta().getRegattaLog().add(event);
         LeaderboardDTO dto2 = deserializedLeaderboard.computeDTO(now.plus(20), Collections.emptySet(), /* addOverallDetails */ false,
-                /* waitForLatestAnalyses */ false, /* trackedRegattaRegistry */ null, DomainFactory.INSTANCE, /* fillNetPointsUncorrected */ false);
+                /* waitForLatestAnalyses */ false, /* trackedRegattaRegistry */ null, DomainFactory.INSTANCE, /* fillTotalPointsUncorrected */ false);
         assertFalse(dto2.competitors.isEmpty());
         assertEquals(event.getCompetitor().getName(), dto2.competitors.get(0).getName());
         LeaderboardDTO dto3 = deserializedLeaderboard.getLeaderboardDTO(now.plus(20), Collections.emptySet(), /* addOverallDetails */ false,
-                /* trackedRegattaRegistry */ null, DomainFactory.INSTANCE, /* fillNetPointsUncorrected */ false);
+                /* trackedRegattaRegistry */ null, DomainFactory.INSTANCE, /* fillTotalPointsUncorrected */ false);
         assertFalse(dto3.competitors.isEmpty());
         assertEquals(event.getCompetitor().getName(), dto3.competitors.get(0).getName());
     }

java/com.sap.sailing.domain.test/src/com/sap/sailing/domain/test/mock/MockedTrackedRace.java

@@ -534,7 +534,7 @@ public class MockedTrackedRace implements DynamicTrackedRace {
             }
 
             @Override
-            public int getNetPoints(Competitor competitor, TimePoint timePoint) throws NoWindException {
+            public int getTotalPoints(Competitor competitor, TimePoint timePoint) throws NoWindException {
                 return 0;
             }
 

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/Leaderboard.java

@@ -54,15 +54,15 @@ public interface Leaderboard extends LeaderboardBase, HasRaceColumns {
      */
     public interface Entry {
         int getTrackedRank();
-        Double getNetPoints();
-        Double getNetPointsUncorrected();
         Double getTotalPoints();
+        Double getTotalPointsUncorrected();
+        Double getNetPoints();
         MaxPointsReason getMaxPointsReason();
         boolean isDiscarded();
         /**
-         * Tells if the net points have been corrected by a {@link ScoreCorrection}
+         * Tells if the total points have been corrected by a {@link ScoreCorrection}
          */
-        boolean isNetPointsCorrected();
+        boolean isTotalPointsCorrected();
         
         /**
          * @return <code>null</code>, if the competitor's fleet in the race column cannot be determined, the
@@ -74,7 +74,7 @@ public interface Leaderboard extends LeaderboardBase, HasRaceColumns {
     LeaderboardDTO computeDTO(final TimePoint timePoint,
             final Collection<String> namesOfRaceColumnsForWhichToLoadLegDetails, boolean addOverallDetails,
             final boolean waitForLatestAnalyses, TrackedRegattaRegistry trackedRegattaRegistry,
-            DomainFactory baseDomainFactory, boolean fillNetPointsUncorrected) throws NoWindException;
+            DomainFactory baseDomainFactory, boolean fillTotalPointsUncorrected) throws NoWindException;
 
     /**
      * Obtains the unique set of {@link Competitor} objects from all {@link TrackedRace}s currently linked to this
@@ -164,7 +164,7 @@ public interface Leaderboard extends LeaderboardBase, HasRaceColumns {
     Map<RaceColumn, List<Competitor>> getRankedCompetitorsFromBestToWorstAfterEachRaceColumn(TimePoint timePoint) throws NoWindException;
     
     /**
-     * Computes the competitor's total points sum as they were or would have been after each race column (from left to right)
+     * Computes the competitor's net points sum as they were or would have been after each race column (from left to right)
      * was completed.<p>
      * 
      * A leaderboard fills up over time, usually "from left to right" with one race after another finishing.
@@ -173,14 +173,14 @@ public interface Leaderboard extends LeaderboardBase, HasRaceColumns {
      * exactly <i>n</i> races. Still, this method pretends such a time point would have existed, actually ignoring
      * the <i>times</i> at which a race took place but only looking at the resulting scores and discards.<p>
      * 
-     * When computing the total points sum after all columns up to and including the race column that is the key of the resulting
+     * When computing the net points sum after all columns up to and including the race column that is the key of the resulting
      * map, the method applies the discarding and tie breaking rules as they would have had to be applied had the races
      * in the respective column just completed.
      * 
      * @return The resulting map is guaranteed to have the same iteration order regarding the race columns
      * as {@link #getRaceColumns()}.
      */
-    Map<RaceColumn, Map<Competitor, Double>> getTotalPointsSumAfterRaceColumn(TimePoint timePoint) throws NoWindException;
+    Map<RaceColumn, Map<Competitor, Double>> getNetPointsSumAfterRaceColumn(TimePoint timePoint) throws NoWindException;
     
     /**
      * Tells the number of points carried over from previous races not tracked by this leaderboard for
@@ -225,7 +225,7 @@ public interface Leaderboard extends LeaderboardBase, HasRaceColumns {
      * @return <code>null</code> if the competitor didn't participate in the race or the race hasn't started yet at
      *         <code>timePoint</code>
      */
-    Double getNetPoints(Competitor competitor, RaceColumn raceColumn, TimePoint timePoint);
+    Double getTotalPoints(Competitor competitor, RaceColumn raceColumn, TimePoint timePoint);
 
     /**
      * Tells if and why a competitor received "penalty" points for a race (however the scoring rules define the
@@ -235,7 +235,7 @@ public interface Leaderboard extends LeaderboardBase, HasRaceColumns {
 
     /**
      * A possibly corrected number of points for the race specified. Defaults to the result of calling
-     * {@link #getNetPoints(Competitor, TrackedRace, TimePoint)} but may be corrected by the regatta rules for
+     * {@link #getTotalPoints(Competitor, TrackedRace, TimePoint)} but may be corrected by the regatta rules for
      * discarding results. If {@link #isDiscarded(Competitor, RaceColumn, TimePoint) discarded}, the points returned
      * will be 0.
      * 
@@ -249,7 +249,7 @@ public interface Leaderboard extends LeaderboardBase, HasRaceColumns {
      *         competitor doesn't appear in any of the race column's attached tracked races. A 0.0 score is returned
      *         if the competitor's result for <code>race</code> is discarded.
      */
-    Double getTotalPoints(Competitor competitor, RaceColumn race, TimePoint timePoint) throws NoWindException;
+    Double getNetPoints(Competitor competitor, RaceColumn race, TimePoint timePoint) throws NoWindException;
 
     /**
      * Tells whether the contribution of <code>raceColumn</code> is discarded in the current leaderboard's standings for
@@ -260,17 +260,17 @@ public interface Leaderboard extends LeaderboardBase, HasRaceColumns {
     boolean isDiscarded(Competitor competitor, RaceColumn raceColumn, TimePoint timePoint);
 
     /**
-     * Sums up the {@link #getTotalPoints(Competitor, TrackedRace, TimePoint) total points} of <code>competitor</code>
+     * Sums up the {@link #getNetPoints(Competitor, TrackedRace, TimePoint) net points} of <code>competitor</code>
      * across all races tracked by this leaderboard, respecting the {@link RaceColumn#isStartsWithZeroScore()} property.
      */
-    Double getTotalPoints(Competitor competitor, TimePoint timePoint);
+    Double getNetPoints(Competitor competitor, TimePoint timePoint);
     
     /**
-     * Sums up the {@link #getTotalPoints(Competitor, RaceColumn, TimePoint) total points} of <code>competitor</code>
+     * Sums up the {@link #getNetPoints(Competitor, RaceColumn, TimePoint) net points} of <code>competitor</code>
      * across all race columns listed in <code>raceColumnsToconsider</code>, respecting the
      * {@link RaceColumn#isStartsWithZeroScore()} property.
      */
-    Double getTotalPoints(Competitor competitor, Iterable<RaceColumn> raceColumnsToConsider, TimePoint timePoint)
+    Double getNetPoints(Competitor competitor, Iterable<RaceColumn> raceColumnsToConsider, TimePoint timePoint)
             throws NoWindException;
 
     /**
@@ -283,8 +283,8 @@ public interface Leaderboard extends LeaderboardBase, HasRaceColumns {
      * {@link Fleet#compareTo(Fleet) ordered fleets} and {@link RaceColumn#isMedalRace() medal races}. The ordering
      * does not consider result discarding because when sorting for a race column it is of interest how the competitor
      * performed in that race and not how the score affected the overall regatta score. Therefore, it is based on
-     * {@link #getNetPoints(Competitor, RaceColumn, TimePoint)} and not on
+     * {@link #getTotalPoints(Competitor, RaceColumn, TimePoint)} and not on
-     * {@link #getTotalPoints(Competitor, RaceColumn, TimePoint)}.
+     * {@link #getNetPoints(Competitor, RaceColumn, TimePoint)}.
      */
     List<Competitor> getCompetitorsFromBestToWorst(RaceColumn raceColumn, TimePoint timePoint) throws NoWindException;
     
@@ -306,7 +306,7 @@ public interface Leaderboard extends LeaderboardBase, HasRaceColumns {
      * computational effort compared to fetching all entries separately, particularly because all
      * {@link #isDiscarded(Competitor, RaceColumn, TimePoint) discarded races} of a competitor are computed in one
      * sweep using {@link ResultDiscardingRule#getDiscardedRaceColumns(Competitor, Leaderboard, Iterable, TimePoint)} only once.
-     * Note that in order to get the {@link #getTotalPoints(Competitor, TimePoint) total points} for a competitor
+     * Note that in order to get the {@link #getNetPoints(Competitor, TimePoint) total points} for a competitor
      * for the entire leaderboard, the {@link #getCarriedPoints(Competitor) carried-over points} need to be added.
      */
     Map<Util.Pair<Competitor, RaceColumn>, Entry> getContent(TimePoint timePoint) throws NoWindException;
@@ -326,7 +326,7 @@ public interface Leaderboard extends LeaderboardBase, HasRaceColumns {
     /**
      * A leaderboard can carry over points from races that are not tracked by this leaderboard in detail,
      * so for which no {@link RaceColumn} column is present in this leaderboard. These scores are
-     * simply added to the scores tracked by this leaderboard in the {@link #getTotalPoints(Competitor, TimePoint)}
+     * simply added to the scores tracked by this leaderboard in the {@link #getNetPoints(Competitor, TimePoint)}
      * method.
      */
     void setCarriedPoints(Competitor competitor, double carriedPoints);
@@ -370,7 +370,7 @@ public interface Leaderboard extends LeaderboardBase, HasRaceColumns {
      * that column shall be considered for discarding and counts for determining the number of races so far. Also, if a
      * tracked race is connected to the column and has started already, the column is to be considered for discarding
      * unless the column has several unordered fleets and not all fleets have started their race yet (see
-     * {@link ScoringScheme#isValidInTotalScore(Leaderboard, RaceColumn, Competitor, TimePoint)}).
+     * {@link ScoringScheme#isValidInNetScore(Leaderboard, RaceColumn, Competitor, TimePoint)}).
      */
     boolean countRaceForComparisonWithDiscardingThresholds(Competitor competitor, RaceColumn raceColumn, TimePoint timePoint);
     
@@ -458,14 +458,14 @@ public interface Leaderboard extends LeaderboardBase, HasRaceColumns {
     Distance getTotalDistanceTraveled(Competitor competitor, TimePoint timePoint);
     
     /**
-     * Same as {@link #getTotalPoints(Competitor, RaceColumn, TimePoint)}, only that for determining the discarded
+     * Same as {@link #getNetPoints(Competitor, RaceColumn, TimePoint)}, only that for determining the discarded
      * results only <code>raceColumnsToConsider</code> are considered.
      */
-    Double getTotalPoints(Competitor competitor, RaceColumn raceColumn, Iterable<RaceColumn> raceColumnsToConsider,
+    Double getNetPoints(Competitor competitor, RaceColumn raceColumn, Iterable<RaceColumn> raceColumnsToConsider,
             TimePoint timePoint) throws NoWindException;
 
     /**
-     * Same as {@link #getTotalPoints(Competitor, RaceColumn, Iterable, TimePoint)}, only that the set of discarded race columns can
+     * Same as {@link #getNetPoints(Competitor, RaceColumn, Iterable, TimePoint)}, only that the set of discarded race columns can
      * be specified which is useful when total points are to be computed for more than one column for the same
      * competitor because then the calculation of discards (which requires looking at all columns) only needs to be done
      * once and not again for each column (which would lead to quadratic effort).
@@ -475,7 +475,7 @@ public interface Leaderboard extends LeaderboardBase, HasRaceColumns {
      *            {@link ResultDiscardingRule#getDiscardedRaceColumns(Competitor, Leaderboard, Iterable, TimePoint)
      *            getDiscardedRaceColumns(competitor, this, raceColumnsToConsider, timePoint)}.
      */
-    Double getTotalPoints(Competitor competitor, RaceColumn raceColumn, TimePoint timePoint,
+    Double getNetPoints(Competitor competitor, RaceColumn raceColumn, TimePoint timePoint,
             Set<RaceColumn> discardedRaceColumns);
 
     TimePoint getNowMinusDelay();
@@ -522,7 +522,7 @@ public interface Leaderboard extends LeaderboardBase, HasRaceColumns {
      */
     LeaderboardDTO getLeaderboardDTO(TimePoint timePoint,
             Collection<String> namesOfRaceColumnsForWhichToLoadLegDetails,
-            boolean addOverallDetails, TrackedRegattaRegistry trackedRegattaRegistry, DomainFactory baseDomainFactory, boolean fillNetPointsUncorrected) throws NoWindException,
+            boolean addOverallDetails, TrackedRegattaRegistry trackedRegattaRegistry, DomainFactory baseDomainFactory, boolean fillTotalPointsUncorrected) throws NoWindException,
             InterruptedException, ExecutionException;
 
     NumberOfCompetitorsInLeaderboardFetcher getNumberOfCompetitorsInLeaderboardFetcher();

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/ScoringScheme.java

@@ -96,13 +96,13 @@ public interface ScoringScheme extends Serializable {
 
     /**
      * Under certain circumstances, a scoring scheme may decide that the scores of a column are not (yet) to be used
-     * for the leaderboard's total scores. This may, e.g., be the case if a column is split into more than one fleet and
+     * for the leaderboard's net scores. This may, e.g., be the case if a column is split into more than one fleet and
      * those fleets are unordered. In that case, scores need to be available for all fleets before the column counts
-     * for the total scores. Another example is a scoring scheme that defines elimination rounds and awards no points
+     * for the net scores. Another example is a scoring scheme that defines elimination rounds and awards no points
      * to a competitor in a round from which the competitor got promoted to the next round. Such promotion columns
      * then have no scores and don't count in the number of races starting from where discards are applied.<p>
      */
-    boolean isValidInTotalScore(Leaderboard leaderboard, RaceColumn raceColumn, Competitor competitor, TimePoint at);
+    boolean isValidInNetScore(Leaderboard leaderboard, RaceColumn raceColumn, Competitor competitor, TimePoint at);
 
     /**
      * Some scoring schemes are applied to {@link LeaderboardGroupMetaLeaderboard} instances. These instances of a

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/caching/LeaderboardDTOCache.java

@@ -166,7 +166,7 @@ public class LeaderboardDTOCache implements LeaderboardCache {
                     try {
                         LeaderboardDTO result = leaderboard.computeDTO(adjustedTimePoint,
                                 namesOfRaceColumnsForWhichToLoadLegDetails, addOverallDetails,
-                                waitForLatestAnalyses, trackedRegattaRegistry, baseDomainFactory, /* fillNetPointsUncorrected */ false);
+                                waitForLatestAnalyses, trackedRegattaRegistry, baseDomainFactory, /* fillTotalPointsUncorrected */ false);
                         return result;
                     } finally {
                         LockUtil.unpropagateLockSetFrom(callerThread);

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/caching/LiveLeaderboardUpdater.java

@@ -297,7 +297,7 @@ public class LiveLeaderboardUpdater implements Runnable {
                     final boolean addOverallDetails = getOverallDetails(timePoint);
                     LeaderboardDTO newCacheValue = leaderboard.computeDTO(timePoint,
                             namesOfRaceColumnsForWhichToLoadLegDetails, addOverallDetails,
-                            /* waitForLatestAnalyses */false, trackedRegattaRegistry, baseDomainFactory, /* fillNetPointsUncorrected */ false);
+                            /* waitForLatestAnalyses */false, trackedRegattaRegistry, baseDomainFactory, /* fillTotalPointsUncorrected */ false);
                     updateCacheContents(namesOfRaceColumnsForWhichToLoadLegDetails, addOverallDetails, newCacheValue);
                 } catch (NoWindException e) {
                     logger.log(Level.SEVERE, "Exception during re-calculating the live leaderboard "+leaderboard.getName(), e);

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/impl/AbstractHighPointExtremeSailingSeriesOverall.java

@@ -122,15 +122,15 @@ public abstract class AbstractHighPointExtremeSailingSeriesOverall extends HighP
             List<Leaderboard> randomAccessLeaderboardList = new ArrayList<Leaderboard>(Util.size(overallLeaderboard.getLeaderboards()));
             Util.addAll(overallLeaderboard.getLeaderboards(), randomAccessLeaderboardList);
             for (Leaderboard leaderboardInOverall : overallLeaderboard.getLeaderboards()) {
-                o1PointsInLeaderboardsOfTheGroup.add(leaderboardInOverall.getTotalPoints(o1, timePoint));
+                o1PointsInLeaderboardsOfTheGroup.add(leaderboardInOverall.getNetPoints(o1, timePoint));
-                o2PointsInLeaderboardsOfTheGroup.add(leaderboardInOverall.getTotalPoints(o2, timePoint));
+                o2PointsInLeaderboardsOfTheGroup.add(leaderboardInOverall.getNetPoints(o2, timePoint));
             }
             int localResult = 0;
             for (ListIterator<Leaderboard> reverseLeaderbaordIterator=randomAccessLeaderboardList.listIterator(randomAccessLeaderboardList.size());
                     reverseLeaderbaordIterator.hasPrevious(); ) {
                 Leaderboard leaderboardInOverall = reverseLeaderbaordIterator.previous();
-                final Double o1PointsForLeaderboard = leaderboardInOverall.getTotalPoints(o1, timePoint);
+                final Double o1PointsForLeaderboard = leaderboardInOverall.getNetPoints(o1, timePoint);
-                final Double o2PointsForLeaderboard = leaderboardInOverall.getTotalPoints(o2, timePoint);
+                final Double o2PointsForLeaderboard = leaderboardInOverall.getNetPoints(o2, timePoint);
                 if (o1PointsForLeaderboard != null && o2PointsForLeaderboard != null) {
                     // we're in a scheme where points never get 0 so we can safely assume
                     // that the last total points that are no 0 are the ones that we want to

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/impl/AbstractScoringSchemeImpl.java

@@ -78,7 +78,7 @@ public abstract class AbstractScoringSchemeImpl implements ScoringScheme {
      * more races.
      */
     @Override
-    public boolean isValidInTotalScore(Leaderboard leaderboard, RaceColumn raceColumn, Competitor competitor, TimePoint at) {
+    public boolean isValidInNetScore(Leaderboard leaderboard, RaceColumn raceColumn, Competitor competitor, TimePoint at) {
         boolean result;
         Iterable<? extends Fleet> fleets = raceColumn.getFleets();
         if (Util.size(fleets) <= 1 || allFleetsOrdered(fleets)) {
@@ -101,7 +101,7 @@ public abstract class AbstractScoringSchemeImpl implements ScoringScheme {
         for (Competitor competitor : leaderboard.getCompetitors()) {
             Fleet fleet = raceColumn.getFleetOfCompetitor(competitor);
             if (fleetsForWhichNoScoreWasFound.contains(fleet)) {
-                if (leaderboard.getNetPoints(competitor, raceColumn, at) != null) {
+                if (leaderboard.getTotalPoints(competitor, raceColumn, at) != null) {
                     fleetsForWhichNoScoreWasFound.remove(fleet);
                 }
             }

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/impl/AbstractSimpleLeaderboardImpl.java

@@ -130,7 +130,7 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
     /**
      * Backs the {@link #getCarriedPoints(Competitor)} API with data. Can be used to prime this leaderboard
      * with aggregated results of races not tracked / displayed by this leaderboard in detail. The points
-     * provided by this map are considered by {@link #getTotalPoints(Competitor, TimePoint)}.
+     * provided by this map are considered by {@link #getNetPoints(Competitor, TimePoint)}.
      */
     private final Map<Competitor, Double> carriedPoints;
 
@@ -172,23 +172,23 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
      */
     class EntryImpl implements Entry {
         private final Callable<Integer> trackedRankProvider;
-        private final Double netPoints;
-        private final Callable<Double> netPointsUncorrectedProvider;
-        private final boolean isNetPointsCorrected;
         private final Double totalPoints;
+        private final Callable<Double> totalPointsUncorrectedProvider;
+        private final boolean isTotalPointsCorrected;
+        private final Double netPoints;
         private final MaxPointsReason maxPointsReason;
         private final boolean discarded;
         private final Fleet fleet;
 
-        private EntryImpl(Callable<Integer> trackedRankProvider, Double netPoints,
+        private EntryImpl(Callable<Integer> trackedRankProvider, Double totalPoints,
-                Callable<Double> netPointsUncorrectedProvider, boolean isNetPointsCorrected,
+                Callable<Double> totalPointsUncorrectedProvider, boolean isTotalPointsCorrected,
-                Double totalPoints, MaxPointsReason maxPointsReason, boolean discarded, Fleet fleet) {
+                Double netPoints, MaxPointsReason maxPointsReason, boolean discarded, Fleet fleet) {
             super();
             this.trackedRankProvider = trackedRankProvider;
-            this.netPoints = netPoints;
-            this.netPointsUncorrectedProvider = netPointsUncorrectedProvider;
-            this.isNetPointsCorrected = isNetPointsCorrected;
             this.totalPoints = totalPoints;
+            this.totalPointsUncorrectedProvider = totalPointsUncorrectedProvider;
+            this.isTotalPointsCorrected = isTotalPointsCorrected;
+            this.netPoints = netPoints;
             this.maxPointsReason = maxPointsReason;
             this.discarded = discarded;
             this.fleet = fleet;
@@ -202,18 +202,18 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
             }
         }
         @Override
-        public Double getNetPoints() {
-            return netPoints;
-        }
-        @Override
-        public boolean isNetPointsCorrected() {
-            return isNetPointsCorrected;
-        }
-        @Override
         public Double getTotalPoints() {
             return totalPoints;
         }
         @Override
+        public boolean isTotalPointsCorrected() {
+            return isTotalPointsCorrected;
+        }
+        @Override
+        public Double getNetPoints() {
+            return netPoints;
+        }
+        @Override
         public MaxPointsReason getMaxPointsReason() {
             return maxPointsReason;
         }
@@ -226,9 +226,9 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
             return fleet;
         }
         @Override
-        public Double getNetPointsUncorrected() {
+        public Double getTotalPointsUncorrected() {
             try {
-                return netPointsUncorrectedProvider.call();
+                return totalPointsUncorrectedProvider.call();
             } catch (Exception e) {
                 throw new RuntimeException(e);
             }
@@ -437,7 +437,7 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
     }
 
     @Override
-    public Double getNetPoints(final Competitor competitor, final RaceColumn raceColumn, final TimePoint timePoint) {
+    public Double getTotalPoints(final Competitor competitor, final RaceColumn raceColumn, final TimePoint timePoint) {
         return getScoreCorrection().getCorrectedScore(
                 ()->getTrackedRank(competitor, raceColumn, timePoint), competitor,
                 raceColumn, timePoint, new NumberOfCompetitorsFetcherImpl(), getScoringScheme()).getCorrectedScore();
@@ -462,7 +462,7 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
 
     /**
      * Same as {@link #isDiscarded(Competitor, RaceColumn, TimePoint)}, only that the set of discarded race columns can
-     * be specified which is useful when total points are to be computed for more than one column for the same
+     * be specified which is useful when net points are to be computed for more than one column for the same
      * competitor because then the calculation of discards (which requires looking at all columns) only needs to be done
      * once and not again for each column (which would lead to quadratic effort).
      * 
@@ -479,21 +479,21 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
     }
 
     @Override
-    public Double getTotalPoints(Competitor competitor, RaceColumn raceColumn, TimePoint timePoint) throws NoWindException {
+    public Double getNetPoints(Competitor competitor, RaceColumn raceColumn, TimePoint timePoint) throws NoWindException {
-        return getTotalPoints(competitor, raceColumn, getRaceColumns(), timePoint);
+        return getNetPoints(competitor, raceColumn, getRaceColumns(), timePoint);
     }
 
     @Override
-    public Double getTotalPoints(Competitor competitor, RaceColumn raceColumn,
+    public Double getNetPoints(Competitor competitor, RaceColumn raceColumn,
             Iterable<RaceColumn> raceColumnsToConsider, TimePoint timePoint) throws NoWindException {
         final Set<RaceColumn> discardedRaceColumns = getResultDiscardingRule()
                 .getDiscardedRaceColumns(competitor, this, raceColumnsToConsider, timePoint);
-        return getTotalPoints(competitor, raceColumn, timePoint, discardedRaceColumns);
+        return getNetPoints(competitor, raceColumn, timePoint, discardedRaceColumns);
     }
 
     /**
-     * Same as {@link #getTotalPoints(Competitor, RaceColumn, Iterable, TimePoint)}, only that the set of discarded race columns can
+     * Same as {@link #getNetPoints(Competitor, RaceColumn, Iterable, TimePoint)}, only that the set of discarded race columns can
-     * be specified which is useful when total points are to be computed for more than one column for the same
+     * be specified which is useful when net points are to be computed for more than one column for the same
      * competitor because then the calculation of discards (which requires looking at all columns) only needs to be done
      * once and not again for each column (which would lead to quadratic effort).
      * 
@@ -503,28 +503,28 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
      *            getDiscardedRaceColumns(competitor, this, raceColumnsToConsider, timePoint)}.
      */
     @Override
-    public Double getTotalPoints(Competitor competitor, RaceColumn raceColumn, TimePoint timePoint, Set<RaceColumn> discardedRaceColumns) {
+    public Double getNetPoints(Competitor competitor, RaceColumn raceColumn, TimePoint timePoint, Set<RaceColumn> discardedRaceColumns) {
         Double result;
         if (isDiscarded(competitor, raceColumn, timePoint, discardedRaceColumns)) {
             result = 0.0;
         } else {
-            final Double netPoints = getNetPoints(competitor, raceColumn, timePoint);
+            final Double totalPoints = getTotalPoints(competitor, raceColumn, timePoint);
-            if (netPoints == null) {
+            if (totalPoints == null) {
                 result = null;
             } else {
-                result = raceColumn.getFactor() * netPoints;
+                result = raceColumn.getFactor() * totalPoints;
             }
         }
         return result;
     }
 
     @Override
-    public Double getTotalPoints(Competitor competitor, TimePoint timePoint) {
+    public Double getNetPoints(Competitor competitor, TimePoint timePoint) {
-        return getTotalPoints(competitor, getRaceColumns(), timePoint);
+        return getNetPoints(competitor, getRaceColumns(), timePoint);
     }
 
     @Override
-    public Double getTotalPoints(Competitor competitor, final Iterable<RaceColumn> raceColumnsToConsider,
+    public Double getNetPoints(Competitor competitor, final Iterable<RaceColumn> raceColumnsToConsider,
             TimePoint timePoint) {
         // when a column with isStartsWithZeroScore() is found, only reset score if the competitor scored in any race from there on
         boolean needToResetScoreUponNextNonEmptyEntry = false;
@@ -535,14 +535,14 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
             if (raceColumn.isStartsWithZeroScore()) {
                 needToResetScoreUponNextNonEmptyEntry = true;
             }
-            if (getScoringScheme().isValidInTotalScore(this, raceColumn, competitor, timePoint)) {
+            if (getScoringScheme().isValidInNetScore(this, raceColumn, competitor, timePoint)) {
-                final Double totalPoints = getTotalPoints(competitor, raceColumn, timePoint, discardedRaceColumns);
+                final Double netPoints = getNetPoints(competitor, raceColumn, timePoint, discardedRaceColumns);
-                if (totalPoints != null) {
+                if (netPoints != null) {
                     if (needToResetScoreUponNextNonEmptyEntry) {
                         result = 0;
                         needToResetScoreUponNextNonEmptyEntry = false;
                     }
-                    result += totalPoints;
+                    result += netPoints;
                 }
             }
         }
@@ -550,19 +550,19 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
     }
 
     /**
-     * All competitors with non-<code>null</code> net points are added to the result which is then sorted by net points in ascending
+     * All competitors with non-<code>null</code> total points are added to the result which is then sorted by total points in ascending
-     * order. The fleet, if ordered, is the primary ordering criterion, followed by the net points.
+     * order. The fleet, if ordered, is the primary ordering criterion, followed by the total points.
      */
     @Override
     public List<Competitor> getCompetitorsFromBestToWorst(final RaceColumn raceColumn, TimePoint timePoint) throws NoWindException {
-        final Map<Competitor, com.sap.sse.common.Util.Pair<Double, Fleet>> netPointsAndFleet = new HashMap<Competitor, com.sap.sse.common.Util.Pair<Double, Fleet>>();
+        final Map<Competitor, com.sap.sse.common.Util.Pair<Double, Fleet>> totalPointsAndFleet = new HashMap<Competitor, com.sap.sse.common.Util.Pair<Double, Fleet>>();
         for (Competitor competitor : getCompetitors()) {
-            Double netPoints = getNetPoints(competitor, raceColumn, timePoint);
+            Double totalPoints = getTotalPoints(competitor, raceColumn, timePoint);
-            if (netPoints != null) {
+            if (totalPoints != null) {
-                netPointsAndFleet.put(competitor, new com.sap.sse.common.Util.Pair<Double, Fleet>(netPoints, raceColumn.getFleetOfCompetitor(competitor)));
+                totalPointsAndFleet.put(competitor, new com.sap.sse.common.Util.Pair<Double, Fleet>(totalPoints, raceColumn.getFleetOfCompetitor(competitor)));
             }
         }
-        List<Competitor> result = new ArrayList<Competitor>(netPointsAndFleet.keySet());
+        List<Competitor> result = new ArrayList<Competitor>(totalPointsAndFleet.keySet());
         Collections.sort(result, new Comparator<Competitor>() {
             @Override
             public int compare(Competitor o1, Competitor o2) {
@@ -573,8 +573,8 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
                     if (raceColumn.hasSplitFleets() && !raceColumn.hasSplitFleetContiguousScoring()) {
                         // only check fleets if there are more than one and the column is not to be contiguously scored even in case
                         // of split fleets
-                        final Fleet o1Fleet = netPointsAndFleet.get(o1).getB();
+                        final Fleet o1Fleet = totalPointsAndFleet.get(o1).getB();
-                        final Fleet o2Fleet = netPointsAndFleet.get(o2).getB();
+                        final Fleet o2Fleet = totalPointsAndFleet.get(o2).getB();
                         if (o1Fleet == null) {
                             if (o2Fleet == null) {
                                 comparisonResult = 0;
@@ -596,7 +596,7 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
                     }
                     if (comparisonResult == 0) {
                         comparisonResult = getScoringScheme().getScoreComparator(/* nullScoresAreBetter */ false).compare(
-                                netPointsAndFleet.get(o1).getA(), netPointsAndFleet.get(o2).getA());
+                                totalPointsAndFleet.get(o1).getA(), totalPointsAndFleet.get(o2).getA());
                     }
                 }
                 return comparisonResult;
@@ -654,7 +654,7 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
     @Override
     public boolean countRaceForComparisonWithDiscardingThresholds(Competitor competitor, RaceColumn raceColumn, TimePoint timePoint) {
         TrackedRace trackedRaceForCompetitorInColumn;
-        return getScoringScheme().isValidInTotalScore(this, raceColumn, competitor, timePoint) && 
+        return getScoringScheme().isValidInNetScore(this, raceColumn, competitor, timePoint) && 
                (getScoreCorrection().isScoreCorrected(competitor, raceColumn, timePoint) ||
                        ((trackedRaceForCompetitorInColumn=raceColumn.getTrackedRace(competitor)) != null &&
                         trackedRaceForCompetitorInColumn.hasStarted(timePoint) &&
@@ -703,7 +703,7 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
     }
 
     @Override
-    public Map<RaceColumn, Map<Competitor, Double>> getTotalPointsSumAfterRaceColumn(final TimePoint timePoint)
+    public Map<RaceColumn, Map<Competitor, Double>> getNetPointsSumAfterRaceColumn(final TimePoint timePoint)
             throws NoWindException {
         final Map<RaceColumn, Map<Competitor, Double>> result = new LinkedHashMap<>();
         List<RaceColumn> raceColumnsToConsider = new ArrayList<>();
@@ -714,12 +714,12 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
             futures.put(raceColumn, executor.submit(new Callable<Map<Competitor, Double>>() {
                 @Override
                 public Map<Competitor, Double> call() {
-                    Map<Competitor, Double> totalPointsSumPerCompetitorInColumn = new HashMap<>();
+                    Map<Competitor, Double> netPointsSumPerCompetitorInColumn = new HashMap<>();
                     for (Competitor competitor : getCompetitors()) {
-                        totalPointsSumPerCompetitorInColumn.put(competitor, getTotalPoints(competitor, finalRaceColumnsToConsider, timePoint));
+                        netPointsSumPerCompetitorInColumn.put(competitor, getNetPoints(competitor, finalRaceColumnsToConsider, timePoint));
                     }
                     synchronized (result) {
-                        return totalPointsSumPerCompetitorInColumn;
+                        return netPointsSumPerCompetitorInColumn;
                     }
                 }
             }));
@@ -1205,7 +1205,7 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
     public LeaderboardDTO computeDTO(final TimePoint timePoint,
             final Collection<String> namesOfRaceColumnsForWhichToLoadLegDetails, boolean addOverallDetails,
             final boolean waitForLatestAnalyses, TrackedRegattaRegistry trackedRegattaRegistry, final DomainFactory baseDomainFactory,
-            final boolean fillNetPointsUncorrected)
+            final boolean fillTotalPointsUncorrected)
             throws NoWindException {
         long startOfRequestHandling = System.currentTimeMillis();
         final LeaderboardDTOCalculationReuseCache cache = new LeaderboardDTOCalculationReuseCache(timePoint);
@@ -1313,7 +1313,7 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
             row.competitor = competitorDTO;
             row.fieldsByRaceColumnName = new HashMap<String, LeaderboardEntryDTO>();
             row.carriedPoints = this.hasCarriedPoints(competitor) ? this.getCarriedPoints(competitor) : null;
-            row.totalPoints = this.getTotalPoints(competitor, timePoint);
+            row.netPoints = this.getNetPoints(competitor, timePoint);
             if (addOverallDetails) {
                 addOverallDetailsToRow(timePoint, competitor, row);
             }
@@ -1327,7 +1327,7 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
                                 namesOfRaceColumnsForWhichToLoadLegDetails != null
                                         && namesOfRaceColumnsForWhichToLoadLegDetails.contains(raceColumn
                                                 .getName()), waitForLatestAnalyses, legRanksCache, baseDomainFactory,
-                                                fillNetPointsUncorrected, cache);
+                                                fillTotalPointsUncorrected, cache);
                     });
                 executor.execute(future);
                 futuresForColumnName.put(raceColumn.getName(), future);
@@ -1403,8 +1403,8 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
      *            if <code>false</code>, this method is allowed to read the maneuver analysis results from a cache that
      *            may not reflect all data already received; otherwise, the method will always block for the latest
      *            cache updates to have happened before returning.
-     * @param fillNetPointsUncorrected
+     * @param fillTotalPointsUncorrected
-     *            tells if {@link LeaderboardEntryDTO#netPointsUncorrected} shall be filled; filling it is rather
+     *            tells if {@link LeaderboardEntryDTO#totalPointsUncorrected} shall be filled; filling it is rather
      *            expensive, especially when compared to simply retrieving a score correction, and particularly if in a
      *            larger fleet a number of competitors haven't properly finished the race. This should only be used for
      *            leaderboard editing where a user needs to see what the uncorrected score was that would be used when
@@ -1413,16 +1413,16 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
     private LeaderboardEntryDTO getLeaderboardEntryDTO(Entry entry, RaceColumn raceColumn, Competitor competitor,
             TimePoint timePoint, boolean addLegDetails, boolean waitForLatestAnalyses,
             Map<Leg, LinkedHashMap<Competitor, Integer>> legRanksCache, DomainFactory baseDomainFactory,
-            boolean fillNetPointsUncorrected, WindLegTypeAndLegBearingCache cache) {
+            boolean fillTotalPointsUncorrected, WindLegTypeAndLegBearingCache cache) {
         LeaderboardEntryDTO entryDTO = new LeaderboardEntryDTO();
         TrackedRace trackedRace = raceColumn.getTrackedRace(competitor);
         entryDTO.race = trackedRace == null ? null : trackedRace.getRaceIdentifier();
-        entryDTO.netPoints = entry.getNetPoints();
-        if (fillNetPointsUncorrected) {
-            entryDTO.netPointsUncorrected = entry.getNetPointsUncorrected();
-        }
-        entryDTO.netPointsCorrected = entry.isNetPointsCorrected();
         entryDTO.totalPoints = entry.getTotalPoints();
+        if (fillTotalPointsUncorrected) {
+            entryDTO.totalPointsUncorrected = entry.getTotalPointsUncorrected();
+        }
+        entryDTO.totalPointsCorrected = entry.isTotalPointsCorrected();
+        entryDTO.netPoints = entry.getNetPoints();
         entryDTO.reasonForMaxPoints = entry.getMaxPointsReason();
         entryDTO.discarded = entry.isDiscarded();
         final GPSFixTrack<Competitor, GPSFixMoving> track = trackedRace == null ? null : trackedRace.getTrack(competitor);
@@ -1880,7 +1880,7 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
     @Override
     public LeaderboardDTO getLeaderboardDTO(TimePoint timePoint,
             Collection<String> namesOfRaceColumnsForWhichToLoadLegDetails, boolean addOverallDetails,
-            TrackedRegattaRegistry trackedRegattaRegistry, DomainFactory baseDomainFactory, boolean fillNetPointsUncorrected) throws NoWindException,
+            TrackedRegattaRegistry trackedRegattaRegistry, DomainFactory baseDomainFactory, boolean fillTotalPointsUncorrected) throws NoWindException,
             InterruptedException, ExecutionException {
         LeaderboardDTO result = null;
         if (timePoint == null) {
@@ -1890,7 +1890,7 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
             // when the tracked race associations or score corrections or tracked race contents changes:
             final TimePoint nowMinusDelay = this.getNowMinusDelay();
             final TimePoint timePointOfLatestModification = this.getTimePointOfLatestModification();
-            if (fillNetPointsUncorrected || (timePointOfLatestModification != null && !nowMinusDelay.before(timePointOfLatestModification))) {
+            if (fillTotalPointsUncorrected || (timePointOfLatestModification != null && !nowMinusDelay.before(timePointOfLatestModification))) {
                 // if there hasn't been any modification to the leaderboard since nowMinusDelay, use non-live mode
                 // and pull the result from the regular leaderboard cache:
                 timePoint = timePointOfLatestModification;
@@ -1901,10 +1901,10 @@ public abstract class AbstractSimpleLeaderboardImpl implements Leaderboard, Race
             }
         }
         if (timePoint != null) {
-            if (fillNetPointsUncorrected) {
+            if (fillTotalPointsUncorrected) {
-                // explicitly filling the uncorrected net points requires uncached recalculation
+                // explicitly filling the uncorrected total points requires uncached recalculation
                 result = computeDTO(timePoint, namesOfRaceColumnsForWhichToLoadLegDetails, addOverallDetails, /* waitForLatestAnalyses */ true,
-                        trackedRegattaRegistry, baseDomainFactory, fillNetPointsUncorrected);
+                        trackedRegattaRegistry, baseDomainFactory, fillTotalPointsUncorrected);
             } else {
                 // in replay we'd like up-to-date results; they are still cached
                 // which is OK because the cache is invalidated whenever any of the tracked races attached to the

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/impl/HighPoint.java

@@ -74,7 +74,7 @@ public class HighPoint extends AbstractScoringSchemeImpl {
     }
 
     @Override
-    public boolean isValidInTotalScore(Leaderboard leaderboard, RaceColumn raceColumn, Competitor competitor, TimePoint at) {
+    public boolean isValidInNetScore(Leaderboard leaderboard, RaceColumn raceColumn, Competitor competitor, TimePoint at) {
         return true;
     }
     

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/impl/LeaderboardTotalRankComparator.java

@@ -51,8 +51,8 @@ import com.sap.sse.common.Util.Pair;
 public class LeaderboardTotalRankComparator implements Comparator<Competitor> {
     private final Leaderboard leaderboard;
     private final ScoringScheme scoringScheme;
-    private final Map<Util.Pair<Competitor, RaceColumn>, Double> totalPointsCache;
     private final Map<Util.Pair<Competitor, RaceColumn>, Double> netPointsCache;
+    private final Map<Util.Pair<Competitor, RaceColumn>, Double> totalPointsCache;
     private final boolean nullScoresAreBetter;
     private final TimePoint timePoint;
     
@@ -82,15 +82,15 @@ public class LeaderboardTotalRankComparator implements Comparator<Competitor> {
         this.timePoint = timePoint;
         this.scoringScheme = scoringScheme;
         this.nullScoresAreBetter = nullScoresAreBetter;
-        totalPointsCache = new HashMap<Util.Pair<Competitor, RaceColumn>, Double>();
         netPointsCache = new HashMap<Util.Pair<Competitor, RaceColumn>, Double>();
+        totalPointsCache = new HashMap<Util.Pair<Competitor, RaceColumn>, Double>();
         for (Competitor competitor : leaderboard.getCompetitors()) {
             Set<RaceColumn> discardedRaceColumns = leaderboard.getResultDiscardingRule().getDiscardedRaceColumns(
                     competitor, leaderboard, raceColumnsToConsider, timePoint);
             for (RaceColumn raceColumn : raceColumnsToConsider) {
                 Pair<Competitor, RaceColumn> key = new Util.Pair<Competitor, RaceColumn>(competitor, raceColumn);
-                totalPointsCache.put(key, leaderboard.getTotalPoints(competitor, raceColumn, timePoint, discardedRaceColumns));
+                netPointsCache.put(key, leaderboard.getNetPoints(competitor, raceColumn, timePoint, discardedRaceColumns));
-                netPointsCache.put(key, leaderboard.getNetPoints(competitor, raceColumn, timePoint));
+                totalPointsCache.put(key, leaderboard.getTotalPoints(competitor, raceColumn, timePoint));
             }
         }
     }
@@ -103,8 +103,8 @@ public class LeaderboardTotalRankComparator implements Comparator<Competitor> {
     public int compare(Competitor o1, Competitor o2) {
         List<Util.Pair<RaceColumn, Double>> o1Scores = new ArrayList<>();
         List<Util.Pair<RaceColumn, Double>> o2Scores = new ArrayList<>();
-        List<Util.Pair<RaceColumn, Double>> o1NetPoints = new ArrayList<>();
+        List<Util.Pair<RaceColumn, Double>> o1TotalPoints = new ArrayList<>();
-        List<Util.Pair<RaceColumn, Double>> o2NetPoints = new ArrayList<>();
+        List<Util.Pair<RaceColumn, Double>> o2TotalPoints = new ArrayList<>();
         double o1ScoreSum = getLeaderboard().getCarriedPoints(o1);
         double o2ScoreSum = getLeaderboard().getCarriedPoints(o2);
         Double o1MedalRaceScore = 0.0;
@@ -116,12 +116,12 @@ public class LeaderboardTotalRankComparator implements Comparator<Competitor> {
         for (RaceColumn raceColumn : getLeaderboard().getRaceColumns()) {
             needToResetO1ScoreUponNextValidResult = raceColumn.isStartsWithZeroScore();
             needToResetO2ScoreUponNextValidResult = raceColumn.isStartsWithZeroScore();
-            final boolean o1ValidInTotalScore = getLeaderboard().getScoringScheme().isValidInTotalScore(getLeaderboard(), raceColumn, o1, timePoint);
+            final boolean o1ValidInNetScore = getLeaderboard().getScoringScheme().isValidInNetScore(getLeaderboard(), raceColumn, o1, timePoint);
-            final boolean o2ValidInTotalScore = getLeaderboard().getScoringScheme().isValidInTotalScore(getLeaderboard(), raceColumn, o2, timePoint);
+            final boolean o2ValidInNetScore = getLeaderboard().getScoringScheme().isValidInNetScore(getLeaderboard(), raceColumn, o2, timePoint);
             final Double o1Score;
-            if (o1ValidInTotalScore) {
+            if (o1ValidInNetScore) {
                 Pair<Competitor, RaceColumn> key = new Util.Pair<>(o1, raceColumn);
-                o1Score = totalPointsCache.get(key);
+                o1Score = netPointsCache.get(key);
                 if (o1Score != null) {
                     o1Scores.add(new Util.Pair<>(raceColumn, o1Score));
                     if (needToResetO1ScoreUponNextValidResult) {
@@ -130,17 +130,17 @@ public class LeaderboardTotalRankComparator implements Comparator<Competitor> {
                     }
                     o1ScoreSum += o1Score;
                 }
-                final Double o1Net = netPointsCache.get(key);
+                final Double o1Total = totalPointsCache.get(key);
-                if (o1Net != null) {
+                if (o1Total != null) {
-                    o1NetPoints.add(new Util.Pair<>(raceColumn, o1Net));
+                    o1TotalPoints.add(new Util.Pair<>(raceColumn, o1Total));
                 }
             } else {
                 o1Score = null;
             }
             final Double o2Score;
-            if (o2ValidInTotalScore) {
+            if (o2ValidInNetScore) {
                 Pair<Competitor, RaceColumn> key = new Util.Pair<Competitor, RaceColumn>(o2, raceColumn);
-                o2Score = totalPointsCache.get(key);
+                o2Score = netPointsCache.get(key);
                 if (o2Score != null) {
                     o2Scores.add(new Util.Pair<RaceColumn, Double>(raceColumn, o2Score));
                     if (needToResetO2ScoreUponNextValidResult) {
@@ -149,14 +149,14 @@ public class LeaderboardTotalRankComparator implements Comparator<Competitor> {
                     }
                     o2ScoreSum += o2Score;
                 }
-                final Double o2Net = netPointsCache.get(key);
+                final Double o2Total = totalPointsCache.get(key);
-                if (o2Net != null) {
+                if (o2Total != null) {
-                    o2NetPoints.add(new Util.Pair<>(raceColumn, o2Net));
+                    o2TotalPoints.add(new Util.Pair<>(raceColumn, o2Total));
                 }
             } else {
                 o2Score = null;
             }
-            if (o1ValidInTotalScore && o2ValidInTotalScore) {
+            if (o1ValidInNetScore && o2ValidInNetScore) {
                 int preemptiveColumnResult = 0;
                 if (raceColumn.isMedalRace()) {
                     // only count the score for the medal race score if it wasn't a carry-forward column
@@ -192,7 +192,7 @@ public class LeaderboardTotalRankComparator implements Comparator<Competitor> {
                     result = compareByBetterScore(o1, Collections.unmodifiableList(o1Scores), o2, Collections.unmodifiableList(o2Scores), timePoint);
                     if (result == 0) {
                         // compare by last race:
-                        result = scoringScheme.compareByLastRace(o1NetPoints, o2NetPoints, nullScoresAreBetter);
+                        result = scoringScheme.compareByLastRace(o1TotalPoints, o2TotalPoints, nullScoresAreBetter);
                         if (result == 0) {
                             try {
                                 result = scoringScheme.compareByLatestRegattaInMetaLeaderboard(getLeaderboard(), o1, o2, timePoint);
@@ -209,7 +209,7 @@ public class LeaderboardTotalRankComparator implements Comparator<Competitor> {
 
     /**
      * Precondition: either both scored in medal race or both didn't. If both scored, the better score wins.
-     * This is to be applied only if the total score of both competitors are equal to each other.
+     * This is to be applied only if the net score of both competitors are equal to each other.
      */
     private int compareByMedalRaceScore(Double o1MedalRaceScore, Double o2MedalRaceScore) {
         assert o1MedalRaceScore != null || o2MedalRaceScore == null;
@@ -290,7 +290,7 @@ public class LeaderboardTotalRankComparator implements Comparator<Competitor> {
     }
 
     /**
-     * Assuming both competitors scored in the same number of races, and assuming they scored the same total score,
+     * Assuming both competitors scored in the same number of races, and assuming they scored the same net score,
      * break the tie according to the {@link #scoringScheme scoring scheme} set for this comparator.
      * @see ScoringScheme#compareByBetterScore(Competitor, List, Competitor, List, boolean, TimePoint)
      */

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/impl/LowPoint.java

@@ -73,7 +73,7 @@ public class LowPoint extends AbstractScoringSchemeImpl {
     }
 
     @Override
-    public boolean isValidInTotalScore(Leaderboard leaderboard, RaceColumn raceColumn, Competitor competitor, TimePoint at) {
+    public boolean isValidInNetScore(Leaderboard leaderboard, RaceColumn raceColumn, Competitor competitor, TimePoint at) {
         return true;
     }
 

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/impl/LowPointForLeagueOverallLeaderboard.java

@@ -46,12 +46,12 @@ public class LowPointForLeagueOverallLeaderboard extends LowPoint {
         assert Math.abs(o1ScoreSum - o2ScoreSum) < 0.00001;
         assert o1Scores.stream().allMatch(rcAndScore->rcAndScore.getA() instanceof MetaLeaderboardColumn);
         assert o2Scores.stream().allMatch(rcAndScore->rcAndScore.getA() instanceof MetaLeaderboardColumn);
-        double totalPointsSumO1 = getTotalPoints(o1, o1Scores.stream().map(rcAndScore->rcAndScore.getA()), timePoint);
+        double netPointsSumO1 = getNetPoints(o1, o1Scores.stream().map(rcAndScore->rcAndScore.getA()), timePoint);
-        double totalPointsSumO2 = getTotalPoints(o2, o1Scores.stream().map(rcAndScore->rcAndScore.getA()), timePoint);
+        double netPointsSumO2 = getNetPoints(o2, o1Scores.stream().map(rcAndScore->rcAndScore.getA()), timePoint);
-        return getScoreComparator(nullScoresAreBetter).compare(totalPointsSumO1, totalPointsSumO2);
+        return getScoreComparator(nullScoresAreBetter).compare(netPointsSumO1, netPointsSumO2);
     }
 
-    private double getTotalPoints(Competitor competitor, Stream<RaceColumn> raceColumns, TimePoint timePoint) {
+    private double getNetPoints(Competitor competitor, Stream<RaceColumn> raceColumns, TimePoint timePoint) {
-        return raceColumns.collect(Collectors.summingDouble(rc->((MetaLeaderboardColumn) rc).getLeaderboard().getTotalPoints(competitor, timePoint)));
+        return raceColumns.collect(Collectors.summingDouble(rc->((MetaLeaderboardColumn) rc).getLeaderboard().getNetPoints(competitor, timePoint)));
     }
 }

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/impl/LowPointWithEliminationsAndRoundsWinnerGets07.java

@@ -187,7 +187,7 @@ public class LowPointWithEliminationsAndRoundsWinnerGets07 extends LowPoint {
     }
 
     @Override
-    public boolean isValidInTotalScore(Leaderboard leaderboard, RaceColumn raceColumn, Competitor competitor, TimePoint at) {
+    public boolean isValidInNetScore(Leaderboard leaderboard, RaceColumn raceColumn, Competitor competitor, TimePoint at) {
         final RaceColumnInSeries raceColumnInSeries = (RaceColumnInSeries) raceColumn;
         final Iterator<? extends Series> seriesInRegattaIter = raceColumnInSeries.getSeries().getRegatta().getSeries().iterator();
         while (seriesInRegattaIter.hasNext() && seriesInRegattaIter.next() != raceColumnInSeries.getSeries())

java/com.sap.sailing.domain/src/com/sap/sailing/domain/leaderboard/impl/ThresholdBasedResultDiscardingRuleImpl.java

@@ -79,12 +79,12 @@ public class ThresholdBasedResultDiscardingRuleImpl implements ThresholdBasedRes
         int resultsToDiscard = getNumberOfResultsToDiscard(competitor, raceColumnsToConsider, leaderboard, timePoint);
         Set<RaceColumn> result;
         if (resultsToDiscard > 0) {
-            final Map<RaceColumn, Double> netPointsForCompetitorPerColumn = new HashMap<>();
+            final Map<RaceColumn, Double> totalPointsForCompetitorPerColumn = new HashMap<>();
             List<RaceColumn> sortedRaces = new ArrayList<RaceColumn>();
             for (RaceColumn raceColumn : raceColumnsToConsider) {
                 if (raceColumn.isDiscardable()) {
                     sortedRaces.add(raceColumn);
-                    netPointsForCompetitorPerColumn.put(raceColumn, leaderboard.getNetPoints(competitor, raceColumn, timePoint));
+                    totalPointsForCompetitorPerColumn.put(raceColumn, leaderboard.getTotalPoints(competitor, raceColumn, timePoint));
                 }
             }
             result = new HashSet<RaceColumn>();
@@ -96,8 +96,8 @@ public class ThresholdBasedResultDiscardingRuleImpl implements ThresholdBasedRes
                     return -leaderboard
                             .getScoringScheme()
                             .getScoreComparator(/* nullScoresAreBetter */true)
-                            .compare(netPointsForCompetitorPerColumn.get(raceColumn1),
+                            .compare(totalPointsForCompetitorPerColumn.get(raceColumn1),
-                                    netPointsForCompetitorPerColumn.get(raceColumn2));
+                                    totalPointsForCompetitorPerColumn.get(raceColumn2));
                 }
             };
             Collections.sort(sortedRaces, comparator);

java/com.sap.sailing.domain/src/com/sap/sailing/domain/tracking/TrackedRegatta.java

@@ -92,7 +92,7 @@ public interface TrackedRegatta extends Serializable {
     
     void removeRaceListener(RaceListener listener);
 
-    int getNetPoints(Competitor competitor, TimePoint timePoint) throws NoWindException;
+    int getTotalPoints(Competitor competitor, TimePoint timePoint) throws NoWindException;
 
     void removeTrackedRace(RaceDefinition raceDefinition);
 

java/com.sap.sailing.domain/src/com/sap/sailing/domain/tracking/impl/TrackedRegattaImpl.java

@@ -229,7 +229,7 @@ public class TrackedRegattaImpl implements TrackedRegatta {
     }
 
     @Override
-    public int getNetPoints(Competitor competitor, TimePoint timePoint) throws NoWindException {
+    public int getTotalPoints(Competitor competitor, TimePoint timePoint) throws NoWindException {
         int result = 0;
         lockTrackedRacesForRead();
         try {

java/com.sap.sailing.freg.resultimport.test/src/com/sap/sailing/freg/resultimport/test/SimpleHtmlParsingTest.java

@@ -43,7 +43,7 @@ public class SimpleHtmlParsingTest {
             if (Util.contains(row.getNames(), "MARTIN Aline")) {
                 assertEquals("FRA 8716", row.getSailID());
                 assertEquals(111, row.getScoreAfterDiscarding(), 0.000000001);
-                assertEquals(230.00, row.getNetPointsBeforeDiscarding(), 0.000000001);
+                assertEquals(230.00, row.getTotalPointsBeforeDiscarding(), 0.000000001);
             }
         }
     }
@@ -59,7 +59,7 @@ public class SimpleHtmlParsingTest {
             if (Util.contains(row.getNames(), "NIEMINEN Jukka")) {
                 assertEquals("FIN 8768", row.getSailID());
                 assertEquals(118, row.getScoreAfterDiscarding(), 0.000000001);
-                assertEquals(118.00, row.getNetPointsBeforeDiscarding(), 0.000000001);
+                assertEquals(118.00, row.getTotalPointsBeforeDiscarding(), 0.000000001);
                 assertNull(Util.get(row.getRankAndMaxPointsReasonAndPointsAndDiscarded(), 0).getRank());
                 assertNull(Util.get(row.getRankAndMaxPointsReasonAndPointsAndDiscarded(), 0).getScore());
                 assertEquals(false, Util.get(row.getRankAndMaxPointsReasonAndPointsAndDiscarded(), 0).isDiscarded());
@@ -69,7 +69,7 @@ public class SimpleHtmlParsingTest {
             } else if (Util.contains(row.getNames(), "HAGAN Douglas")) {
                 assertEquals("AUS 8817", row.getSailID());
                 assertEquals(235.00, row.getScoreAfterDiscarding(), 0.000000001);
-                assertEquals(235.00, row.getNetPointsBeforeDiscarding(), 0.000000001);
+                assertEquals(235.00, row.getTotalPointsBeforeDiscarding(), 0.000000001);
                 assertNull(Util.get(row.getRankAndMaxPointsReasonAndPointsAndDiscarded(), 0).getRank());
                 assertEquals("DNF", Util.get(row.getRankAndMaxPointsReasonAndPointsAndDiscarded(), 0).getMaxPointsReason());
                 assertEquals((double) 117.00, (double) Util.get(row.getRankAndMaxPointsReasonAndPointsAndDiscarded(), 0).getScore(), 0.000000001);
@@ -118,14 +118,14 @@ public class SimpleHtmlParsingTest {
             if (Util.contains(row.getNames(), "HOLZAPFEL Alexander")) {
                 assertEquals("GER 8975", row.getSailID());
                 assertEquals(60.00, row.getScoreAfterDiscarding(), 0.000000001);
-                assertEquals(74.00, row.getNetPointsBeforeDiscarding(), 0.000000001);
+                assertEquals(74.00, row.getTotalPointsBeforeDiscarding(), 0.000000001);
                 assertEquals((int) 11, (int) Util.get(row.getRankAndMaxPointsReasonAndPointsAndDiscarded(), 0).getRank());
                 assertEquals((double) 11, (double) Util.get(row.getRankAndMaxPointsReasonAndPointsAndDiscarded(), 0).getScore(), 0.000000001);
                 assertEquals(false, Util.get(row.getRankAndMaxPointsReasonAndPointsAndDiscarded(), 0).isDiscarded());
             } else if (Util.contains(row.getNames(), "BART Cedric")) {
                 assertEquals("SUI 8543", row.getSailID());
                 assertEquals(55.00, row.getScoreAfterDiscarding(), 0.000000001);
-                assertEquals(74.00, row.getNetPointsBeforeDiscarding(), 0.000000001);
+                assertEquals(74.00, row.getTotalPointsBeforeDiscarding(), 0.000000001);
                 assertEquals((int) 2, (int) Util.get(row.getRankAndMaxPointsReasonAndPointsAndDiscarded(), 2).getRank());
                 assertEquals((double) 2, (double) Util.get(row.getRankAndMaxPointsReasonAndPointsAndDiscarded(), 2).getScore(), 0.000000001);
                 assertEquals(false, Util.get(row.getRankAndMaxPointsReasonAndPointsAndDiscarded(), 2).isDiscarded());
@@ -135,7 +135,7 @@ public class SimpleHtmlParsingTest {
             } else if (Util.contains(row.getNames(), "LEWNS Chris")) {
                 assertEquals("GBR 9057", row.getSailID());
                 assertEquals(64.00, row.getScoreAfterDiscarding(), 0.000000001);
-                assertEquals(140.00, row.getNetPointsBeforeDiscarding(), 0.000000001);
+                assertEquals(140.00, row.getTotalPointsBeforeDiscarding(), 0.000000001);
                 assertNull(Util.get(row.getRankAndMaxPointsReasonAndPointsAndDiscarded(), 7).getRank());
                 assertEquals("DNF", Util.get(row.getRankAndMaxPointsReasonAndPointsAndDiscarded(), 7).getMaxPointsReason());
                 assertEquals((double) 76, (double) Util.get(row.getRankAndMaxPointsReasonAndPointsAndDiscarded(), 7).getScore(), 0.000000001);
@@ -155,7 +155,7 @@ public class SimpleHtmlParsingTest {
             if (Util.contains(row.getNames(), "HOLSTE Kim (M1993)")) {
                 assertEquals("GER 1864", row.getSailID());
                 assertEquals(58.00, row.getScoreAfterDiscarding(), 0.000000001);
-                assertEquals(169.00, row.getNetPointsBeforeDiscarding(), 0.000000001);
+                assertEquals(169.00, row.getTotalPointsBeforeDiscarding(), 0.000000001);
                 assertEquals((int) 25, (int) Util.get(row.getRankAndMaxPointsReasonAndPointsAndDiscarded(), 0).getRank());
                 assertEquals((double) 25, (double) Util.get(row.getRankAndMaxPointsReasonAndPointsAndDiscarded(), 0).getScore(), 0.000000001);
                 assertEquals(false, Util.get(row.getRankAndMaxPointsReasonAndPointsAndDiscarded(), 0).isDiscarded());

java/com.sap.sailing.gwt.ui.test/src/com/sap/sailing/gwt/ui/test/GwtTestCaseColumnToggling.java

@@ -179,7 +179,7 @@ public class GwtTestCaseColumnToggling extends GWTTestCase {
         ArrayList<String> al = new ArrayList<String>();
         al.add(COLUMN1_NAME);
         service.getLeaderboardByName(LEADERBOARD_NAME, new Date(), al, /* addOverallDetails */ false, /* previousLeaderboardId */ null,
-                /* fillUncorrectedNetPoints */ false, new AsyncCallback<IncrementalOrFullLeaderboardDTO>() {
+                /* fillUncorrectedTotalPoints */ false, new AsyncCallback<IncrementalOrFullLeaderboardDTO>() {
             @Override
             public void onFailure(Throwable caught) {
                 fail("Failed to get leaderboard.");

java/com.sap.sailing.gwt.ui.test/src/com/sap/sailing/gwt/ui/test/MockedTrackedRace.java

@@ -293,7 +293,7 @@ public class MockedTrackedRace implements DynamicTrackedRace {
             }
 
             @Override
-            public int getNetPoints(Competitor competitor, TimePoint timePoint) throws NoWindException {
+            public int getTotalPoints(Competitor competitor, TimePoint timePoint) throws NoWindException {
                 return 0;
             }
 

java/com.sap.sailing.gwt.ui.test/src/com/sap/sailing/gwt/ui/test/TestColumnSwapping.java

@@ -99,7 +99,7 @@ public class TestColumnSwapping {
             sailingService.updateIsMedalRace(TEST_LEADERBOARD_NAME, races[0], true);
             sailingService.updateIsMedalRace(TEST_LEADERBOARD_NAME, races[2], false);
             lb = sailingService.getLeaderboardByName(TEST_LEADERBOARD_NAME, new Date(), /* races to load */ null, /* addOverallDetails */ true, /* previous leaderboard ID */ null,
-                    /* fillNetPointsUncorrected */ false).getLeaderboardDTO(/* previousVersion */ null);
+                    /* fillTotalPointsUncorrected */ false).getLeaderboardDTO(/* previousVersion */ null);
         } catch (Exception e) {
             // e.printStackTrace();
             fail(e.getLocalizedMessage());
@@ -141,7 +141,7 @@ public class TestColumnSwapping {
         service.moveLeaderboardColumnUp(LEADERBOARDNAME, "Race3");
         try {
             leaderboardDTO = service.getLeaderboardByName(LEADERBOARDNAME, leaderboardCreationDate, leglist, /* addOverallDetails */
-                    true, /* previous leaderboard ID */null, /* fillNetPointsUncorrected */false).getLeaderboardDTO(/* previousVersion */null);
+                    true, /* previous leaderboard ID */null, /* fillTotalPointsUncorrected */false).getLeaderboardDTO(/* previousVersion */null);
         } catch (Exception e) {
             // TODO Auto-generated catch block
             e.printStackTrace();

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/home/communication/event/minileaderboard/MiniLeaderboardItemDTO.java

@@ -6,18 +6,18 @@ import com.sap.sse.gwt.dispatch.shared.commands.DTO;
 public class MiniLeaderboardItemDTO implements DTO {
     private SimpleCompetitorDTO competitor;
     private int rank;
-    private Double points;
+    private Double netPoints;
     private int raceCount;
     
     @SuppressWarnings("unused")
     private MiniLeaderboardItemDTO() {
     }
     
-    public MiniLeaderboardItemDTO(SimpleCompetitorDTO competitor, int rank, Double points, int raceCount) {
+    public MiniLeaderboardItemDTO(SimpleCompetitorDTO competitor, int rank, Double netPoints, int raceCount) {
         super();
         this.competitor = competitor;
         this.rank = rank;
-        this.points = points;
+        this.netPoints = netPoints;
         this.raceCount = raceCount;
     }
     
@@ -25,8 +25,8 @@ public class MiniLeaderboardItemDTO implements DTO {
         return competitor;
     }
     
-    public Double getPoints() {
+    public Double getNetPoints() {
-        return points;
+        return netPoints;
     }
     
     public int getRank() {

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/home/desktop/partials/standings/StandingsListCompetitor.java

@@ -35,7 +35,7 @@ public class StandingsListCompetitor extends UIObject {
         rankUi.setInnerText(Integer.toString(item.getRank()));
         teamIdUi.setInnerText(competitor.getSailID());
         teamNameUi.setInnerText(competitor.getName());
-        String pointsString = i18n.pointsValue(item.getPoints());
+        String pointsString = i18n.pointsValue(item.getNetPoints());
         if(showRaceCounts) {
             pointsString += " (" + i18n.racesCount(item.getRaceCount()) + ")";
         }

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/home/desktop/places/event/regatta/analyticstab/RegattaCompetitorAnalyticsTabView.java

@@ -91,7 +91,7 @@ public class RegattaCompetitorAnalyticsTabView extends SharedLeaderboardRegattaT
     private List<DetailType> getAvailableDetailsTypes() {
         List<DetailType> availableDetailsTypes = new ArrayList<DetailType>();
         availableDetailsTypes.add(DetailType.REGATTA_RANK);
-        availableDetailsTypes.add(DetailType.REGATTA_TOTAL_POINTS_SUM);
+        availableDetailsTypes.add(DetailType.REGATTA_NET_POINTS_SUM);
         return availableDetailsTypes;
     }
 

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/home/desktop/places/fakeseries/analyticstab/EventSeriesCompetitorAnalyticsTabView.java

@@ -80,7 +80,7 @@ public class EventSeriesCompetitorAnalyticsTabView extends SharedLeaderboardEven
     private List<DetailType> getAvailableDetailsTypes() {
         List<DetailType> availableDetailsTypes = new ArrayList<DetailType>();
         availableDetailsTypes.add(DetailType.OVERALL_RANK);
-        availableDetailsTypes.add(DetailType.REGATTA_TOTAL_POINTS_SUM);
+        availableDetailsTypes.add(DetailType.REGATTA_NET_POINTS_SUM);
         return availableDetailsTypes;
     }
 

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/home/mobile/partials/minileaderboard/MinileaderboardBoxItem.java

@@ -30,7 +30,7 @@ public class MinileaderboardBoxItem extends Widget {
         competitorNameUi.setInnerText(entry.getCompetitor().getName());
         competitorCountryNameUi.setInnerText(String.valueOf(entry.getCompetitor().getSailID()));
         competitorRankUi.setInnerText(String.valueOf(entry.getRank()) + ".");
-        competitorPointsUi.setInnerText(StringMessages.INSTANCE.pointsValue(entry.getPoints()));
+        competitorPointsUi.setInnerText(StringMessages.INSTANCE.pointsValue(entry.getNetPoints()));
         if (showRaceCount) {
             competitorRacesUi.setInnerText("(" + entry.getRaceCount() + ")");
         }

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/home/server/LeaderboardContext.java

@@ -93,12 +93,12 @@ public class LeaderboardContext {
                 int raceCount = 0;
                 if(row.fieldsByRaceColumnName != null) {
                     for(LeaderboardEntryDTO lbEntry : row.fieldsByRaceColumnName.values()) {
-                        if(lbEntry.totalPoints != null) {
+                        if(lbEntry.netPoints != null) {
                             raceCount++;
                         }
                     }
                 }
-                result.addItem(new MiniLeaderboardItemDTO(new SimpleCompetitorDTO(competitor), rank, row.totalPoints, raceCount));
+                result.addItem(new MiniLeaderboardItemDTO(new SimpleCompetitorDTO(competitor), rank, row.netPoints, raceCount));
                 if (limit > 0 && rank >= limit) break;
             }
             result.setTotalCompetitorCount(leaderboardDTO.competitors.size());

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/actions/GetLeaderboardByNameAction.java

@@ -37,11 +37,11 @@ public class GetLeaderboardByNameAction implements AsyncAction<LeaderboardDTO> {
     private final StringMessages stringMessages;
     private final ErrorReporter errorReporter;
     private final Timer timerToAdjustOffetIn;
-    private final boolean fillNetPointsUncorrected;
+    private final boolean fillTotalPointsUncorrected;
     
     public GetLeaderboardByNameAction(SailingServiceAsync sailingService, String leaderboardName, Date date,
             final Collection<String> namesOfRacesForWhichToLoadLegDetails, boolean addOverallDetails,
-            LeaderboardDTO previousLeaderboard, boolean fillNetPointsUncorrected, Timer timerToAdjustOffsetIn,
+            LeaderboardDTO previousLeaderboard, boolean fillTotalPointsUncorrected, Timer timerToAdjustOffsetIn,
             ErrorReporter errorReporter, StringMessages stringMessages) {
         this.sailingService = sailingService;
         this.errorReporter = errorReporter;
@@ -52,14 +52,14 @@ public class GetLeaderboardByNameAction implements AsyncAction<LeaderboardDTO> {
         this.addOverallDetails = addOverallDetails;
         this.previousLeaderboard = previousLeaderboard;
         this.timerToAdjustOffetIn = timerToAdjustOffsetIn;
-        this.fillNetPointsUncorrected = fillNetPointsUncorrected;
+        this.fillTotalPointsUncorrected = fillTotalPointsUncorrected;
     }
     
     @Override
     public void execute(final AsyncCallback<LeaderboardDTO> callback) {
         final long clientTimeWhenRequestWasSent = System.currentTimeMillis();
         sailingService.getLeaderboardByName(leaderboardName, date, namesOfRacesForWhichToLoadLegDetails, addOverallDetails,
-                previousLeaderboard==null?null:previousLeaderboard.getId(), fillNetPointsUncorrected,
+                previousLeaderboard==null?null:previousLeaderboard.getId(), fillTotalPointsUncorrected,
                         new AsyncCallback<IncrementalOrFullLeaderboardDTO>() {
                     @Override
                     public void onFailure(Throwable caught) {

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/DetailTypeFormatter.java

@@ -26,12 +26,12 @@ public class DetailTypeFormatter {
             return stringMessages.regattaRank();
         case OVERALL_RANK:
             return stringMessages.overallRank();
-        case RACE_TOTAL_POINTS:
+        case RACE_NET_POINTS:
-            return stringMessages.totalPoints();
+            return stringMessages.netPoints();
-        case REGATTA_TOTAL_POINTS:
+        case REGATTA_NET_POINTS:
-            return stringMessages.totalPoints();            
+            return stringMessages.netPoints();            
-        case REGATTA_TOTAL_POINTS_SUM:
+        case REGATTA_NET_POINTS_SUM:
-            return stringMessages.totalPoints();            
+            return stringMessages.netPoints();            
         case NUMBER_OF_MANEUVERS:
             return stringMessages.numberOfManeuvers();
         case CURRENT_SPEED_OVER_GROUND_IN_KNOTS:
@@ -225,9 +225,9 @@ public class DetailTypeFormatter {
         case RACE_RANK:
         case REGATTA_RANK:
         case OVERALL_RANK:
-        case RACE_TOTAL_POINTS:
+        case RACE_NET_POINTS:
-        case REGATTA_TOTAL_POINTS:
+        case REGATTA_NET_POINTS:
-        case REGATTA_TOTAL_POINTS_SUM:
+        case REGATTA_NET_POINTS_SUM:
         case CURRENT_LEG:
         case TACK:
         case START_TACK:
@@ -336,12 +336,12 @@ public class DetailTypeFormatter {
             return stringMessages.regattaRankTooltip();
         case OVERALL_RANK:
             return stringMessages.overallRankTooltip();
-        case RACE_TOTAL_POINTS:
+        case RACE_NET_POINTS:
-            return stringMessages.raceTotalPointsTooltip();
+            return stringMessages.raceNetPointsTooltip();
-        case REGATTA_TOTAL_POINTS:
+        case REGATTA_NET_POINTS:
-            return stringMessages.regattaTotalPointsTooltip();            
+            return stringMessages.regattaNetPointsTooltip();            
-        case REGATTA_TOTAL_POINTS_SUM:
+        case REGATTA_NET_POINTS_SUM:
-            return stringMessages.regattaTotalPointsTooltip();            
+            return stringMessages.regattaNetPointsTooltip();            
         case RANK_GAIN:
             return stringMessages.rankGainTooltip();
         case TACK:

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/SailingService.java

@@ -182,7 +182,7 @@ public interface SailingService extends RemoteService, FileStorageManagementGwtS
     
     IncrementalOrFullLeaderboardDTO getLeaderboardByName(String leaderboardName, Date date,
             Collection<String> namesOfRaceColumnsForWhichToLoadLegDetails, boolean addOverallDetails,
-            String previousLeaderboardId, boolean fillNetPointsUncorrected) throws Exception;
+            String previousLeaderboardId, boolean fillTotalPointsUncorrected) throws Exception;
 
     List<StrippedLeaderboardDTO> getLeaderboards();
     

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/SailingServiceAsync.java

@@ -221,7 +221,7 @@ public interface SailingServiceAsync extends ServerInfoRetriever, FileStorageMan
 
     void getLeaderboardByName(String leaderboardName, Date date,
             Collection<String> namesOfRaceColumnsForWhichToLoadLegDetails, boolean addOverallDetails,
-            String previousLeaderboardId, boolean fillNetPointsUncorrected,
+            String previousLeaderboardId, boolean fillTotalPointsUncorrected,
             AsyncCallback<IncrementalOrFullLeaderboardDTO> callback);
 
     void getLeaderboardNames(AsyncCallback<List<String>> callback);
@@ -520,7 +520,7 @@ public interface SailingServiceAsync extends ServerInfoRetriever, FileStorageMan
 
     /**
      * @param detailType
-     *            supports {@link DetailType#REGATTA_RANK}, {@link DetailType#REGATTA_TOTAL_POINTS_SUM} and
+     *            supports {@link DetailType#REGATTA_RANK}, {@link DetailType#REGATTA_NET_POINTS_SUM} and
      *            {@link DetailType#OVERALL_RANK}.
      * 
      * @return the first triple element is the race column name; then follows the list of competitors, and finally the

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages.java

@@ -499,9 +499,9 @@ public interface StringMessages extends com.sap.sse.gwt.client.StringMessages,
     String competitorRegattaDataAfterRaceN(String detailType, String raceColumnName);
     String showRankChart();
     String rankChart();
-    String totalPoints();
+    String netPoints();
-    String raceTotalPointsTooltip();
+    String raceNetPointsTooltip();
-    String regattaTotalPointsTooltip();
+    String regattaNetPointsTooltip();
     String overallLeaderboardSelection();
     String errorTryingToObtainOverallLeaderboards(String message);
     String finished();
@@ -587,7 +587,7 @@ public interface StringMessages extends com.sap.sse.gwt.client.StringMessages,
     String sailIdColumnTooltip();
     String rankColumnTooltip();
     String carryColumnTooltip();
-    String totalsColumnTooltip();
+    String totalNetPointsColumnTooltip();
     String windData();
     String gpsData();
     String status();
@@ -621,7 +621,7 @@ public interface StringMessages extends com.sap.sse.gwt.client.StringMessages,
     String correctScore();
     String correctScoreFor(String competitorName, String raceColumnName);
     String penaltyOrRedress();
-    String netScore();
+    String totalScore();
     String timePointMustBeAfterStartOfTracking();
     String timePointMustBeBeforeEndOfTracking();
     String regattaUsedForTheTrackedRace();
@@ -1139,7 +1139,7 @@ public interface StringMessages extends com.sap.sse.gwt.client.StringMessages,
     String racesScored();
     String racesScoredTooltip();
     String averageNumberOfOperationsPerMessage();
-    String showUncorrectedNetPoints();
+    String showUncorrectedTotalPoints();
     String setStartTimeReceived();
     String setStartTimeReceivedDescription();
     String lastScoreCorrectionsTime();

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages.properties

@@ -523,9 +523,9 @@ errorFetchingChartData=Error fetching chart data: {0}
 loadingCompetitorData=Loading competitor data...
 competitorRegattaDataAfterRaceN={0} after race {1}
 rankChart=Ranking
-totalPoints=Total points
+netPoints=Net points
-raceTotalPointsTooltip=Competitor''s total points in the race
+raceNetPointsTooltip=Competitor''s net points in the race
-regattaTotalPointsTooltip=Competitor''s total points in the regatta
+regattaNetPointsTooltip=Competitor''s net points in the regatta
 showRankChart=Show rank chart
 overallLeaderboardSelection=Overall Leaderboard
 errorTryingToObtainOverallLeaderboards=Error trying to obtain overall leaderboards: {0}
@@ -580,7 +580,7 @@ competitorColumnTooltip=Names of the members of this competitor.
 sailIdColumnTooltip=Shows the flag of the country and the sail number of the competitor.
 rankColumnTooltip=The overall rank of this competitor in the regatta.
 carryColumnTooltip=Points carried over from previous races.
-totalsColumnTooltip=The total of all points of a competitor in the regatta.\nSorting based on rank, not points.
+totalNetPointsColumnTooltip=The total net points of a competitor in the regatta.\nSorting based on rank, not points.
 windData=Wind data
 gpsData=GPS data
 status=Status
@@ -604,7 +604,7 @@ cannotAddRacesToRegattaLeaderboardButOnlyToRegatta=This is a regatta leaderboard
 correctScore=Correct Score
 correctScoreFor=Correct score for competitor {0} in race {1}
 penaltyOrRedress=Penalty/Redress
-netScore=Net points
+totalScore=Total points
 timePointMustBeAfterStartOfTracking=Time point must be after start of tracking.
 timePointMustBeBeforeEndOfTracking=Time point must be before end of tracking.
 regattaUsedForTheTrackedRace=Regatta used for the tracked race
@@ -1111,7 +1111,7 @@ simulationLegendTooltip=Time Comparison:\nRace is the leg duration measured from
 racesScored=Races scored
 racesScoredTooltip=Number of races the competitor has completed or gotten a score for in this leaderboard.
 averageNumberOfOperationsPerMessage=Average number of operations per message
-showUncorrectedNetPoints=Show uncorrected net points
+showUncorrectedTotalPoints=Show uncorrected total points
 setStartTimeReceived=Set start time received
 setStartTimeReceivedDescription=This sets the startTimeReceived of the selected TrackedRace that isn''t persistent. This means that the new value will be forgotten after the server has been restarted.
 lastScoreCorrectionsTime=Last score correction time
@@ -1561,4 +1561,4 @@ oneTurnerLeft=1-Turner Left
 oneTurnerRight=1-Turner Right
 current=Current
 simulationLegendAlgorithmTimedOutText = out-of-bounds
-simulationLegendMixedLegText = ambiguous wind
+simulationLegendMixedLegText = ambiguous wind

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages_de.properties

@@ -517,9 +517,9 @@ errorFetchingChartData=Fehler beim Laden der Chartdaten: {0}
 loadingCompetitorData=Lade Teilnehmer-Daten
 competitorRegattaDataAfterRaceN={0} nach Rennen {1}
 rankChart=Ranking
-totalPoints=Gesamtpunktzahl
+netPoints=Gesamtpunktzahl
-raceTotalPointsTooltip=Punktzahl des Teilnehmers in dem Rennen
+raceNetPointsTooltip=Punktzahl des Teilnehmers in dem Rennen
-regattaTotalPointsTooltip=Punktzahl des Teilnehmers in der Regatta
+regattaNetPointsTooltip=Punktzahl des Teilnehmers in der Regatta
 showRankChart=Rang-Diagramm anzeigen
 overallLeaderboardSelection=Gesamtergebnisse
 errorTryingToObtainOverallLeaderboards=Fehler beim Laden der Gesamtergebnisse: {0}
@@ -576,7 +576,7 @@ competitorColumnTooltip=Namen der Segler dieses Teilnehmers
 sailIdColumnTooltip=Zeigt die Länderflagge und die Segelnummer des Teilnehmers
 rankColumnTooltip=Der Gesamtplatz des Teilnehmers in der Regatta
 carryColumnTooltip=Übertrag vergangener Rennen
-totalsColumnTooltip=Summe aller Punkte eines Teilnehmers in der Regatta.\nSortierung nach Rang, nicht Punkten.
+totalNetPointsColumnTooltip=Summe aller Punkte eines Teilnehmers in der Regatta abzüglich gestrichene Wertungen.\nSortierung nach Rang, nicht Punkten.
 windData=Winddaten
 gpsData=GPS-Daten
 status=Status
@@ -598,7 +598,7 @@ cannotAddRacesToRegattaLeaderboardButOnlyToRegatta=Dies ist eine Regatta-Ergebni
 correctScore=Ergebnis bearbeiten
 correctScoreFor=Ergebnis für Teilnehmer {0} in Rennen {1} bearbeiten
 penaltyOrRedress=Strafe/Gutschrift
-netScore=Nettoergebnis
+totalScore=Punkte vor Streichern
 timePointMustBeAfterStartOfTracking=Der Zeitpunkt muß nach dem Trackingbeginn sein.
 timePointMustBeBeforeEndOfTracking=Der Zeitpunkt muß vor dem Trackingende sein.
 regattaUsedForTheTrackedRace=Regatta, zu der das Rennen gehört
@@ -1101,7 +1101,7 @@ showNumberOfRacesScored=Anzahl bepunkteter Rennen
 racesScored=Bepunktete Rennen
 racesScoredTooltip=Anzahl von Rennen, die der Segler vollendet oder für die er Punkte bekommen hat
 averageNumberOfOperationsPerMessage=Durchschnittliche Anzahl Operationen pro Nachricht
-showUncorrectedNetPoints=Unkorrigierte Netto-Punkte anzeigen
+showUncorrectedTotalPoints=Unkorrigierte Punkte anzeigen
 setStartTimeReceived=Setze die erhaltene Startzeit
 setStartTimeReceivedDescription=This sets the startTimeReceived of the selected TrackedRace, that isn''t persistent. This means, that the new value will be forgotten after the server has been restarted.
 setStartTimeReceivedDescription=Dies setzt die startTimeReceived des selektierten TrackedRaces, welches nicht persistent ist. Das beudeutet, dass der neue Wert vergessen wird, sobald der Server neu gestartet wurde.
@@ -1546,4 +1546,4 @@ oneTurnerLeft=1-Wenden-Kurs links
 oneTurnerRight=1-Wenden-Kurs rechts
 current=Strömung
 simulationLegendAlgorithmTimedOutText=außerhalb des zul. Bereichs
-simulationLegendMixedLegText=mehrdeutiger Wind
+simulationLegendMixedLegText=mehrdeutiger Wind

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages_ja.properties

@@ -520,9 +520,9 @@ errorFetchingChartData=チャートデータの取込でエラー発生: {0}
 loadingCompetitorData=競技者データをロードしています...
 competitorRegattaDataAfterRaceN=レース {1} 後の {0}
 rankChart=ランキング
-totalPoints=総得点
+netPoints=総得点
-raceTotalPointsTooltip=当該レースの競技者総得点
+raceNetPointsTooltip=当該レースの競技者総得点
-regattaTotalPointsTooltip=当該レガッタの競技者総得点
+regattaNetPointsTooltip=当該レガッタの競技者総得点
 showRankChart=ランクチャート表示
 overallLeaderboardSelection=全体リーダーボード
 errorTryingToObtainOverallLeaderboards=全体リーダーボードを取得しようとしてエラーが発生: {0}
@@ -577,7 +577,7 @@ competitorColumnTooltip=この競技者の乗員の名前です。
 sailIdColumnTooltip=競技者の国の国旗と競技者のセールナンバーを表示します。
 rankColumnTooltip=レガッタにおけるこの競技者の全体ランクです。
 carryColumnTooltip=以前のレースから持ち越された得点です。
-totalsColumnTooltip=レガッタにおける競技者のすべての得点の合計です。\nソートは得点ではなくランクに基づきます。
+totalNetPointsColumnTooltip=レガッタにおける競技者のすべての得点の合計です。\nソートは得点ではなくランクに基づきます。
 windData=風データ
 gpsData=GPS データ
 status=ステータス
@@ -601,7 +601,7 @@ cannotAddRacesToRegattaLeaderboardButOnlyToRegatta=これはレガッタのリ
 correctScore=スコア修正
 correctScoreFor=レース {1} での競技者 {0} のスコアを修正
 penaltyOrRedress=ペナルティー/救済
-netScore=正味得点
+totalScore=正味得点
 timePointMustBeAfterStartOfTracking=時点は追跡の開始後でなければなりません。
 timePointMustBeBeforeEndOfTracking=時点は追跡の終了前でなければなりません。
 regattaUsedForTheTrackedRace=追跡レースに使用されるレガッタ
@@ -1108,7 +1108,7 @@ simulationLegendTooltip=時間比較:\nレースは GPS から計測されたレ
 racesScored=スコアが記録されたレース
 racesScoredTooltip=このリーダーボードにおいて競技者が完了したか、得点を獲得したレースの数
 averageNumberOfOperationsPerMessage=メッセージごとの操作の平均数
-showUncorrectedNetPoints=未修正正味得点表示
+showUncorrectedTotalPoints=未修正正味得点表示
 setStartTimeReceived=設定済スタート時刻を受信
 setStartTimeReceivedDescription=これにより、永続的でない選択した TrackedRace の startTimeReceived が設定されます。したがって、サーバが再起動された後は新規の値は忘れられます。
 lastScoreCorrectionsTime=最終得点修正時刻

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages_ru.properties

@@ -522,8 +522,8 @@ loadingCompetitorData=Загрузка данных участника...
 competitorRegattaDataAfterRaceN={0} после гонки {1}
 rankChart=Ранг
 totalPoints=Общий балл
-raceTotalPointsTooltip=Общий балл участника в данной гонке
+raceNetPointsTooltip=Общий балл участника в данной гонке
-regattaTotalPointsTooltip=Общий балл участника в данной регате
+regattaNetPointsTooltip=Общий балл участника в данной регате
 showRankChart=Показать диаграмму ранга
 overallLeaderboardSelection=Итоговая таблица лидеров
 errorTryingToObtainOverallLeaderboards=Ошибка при попытке получить итоговые таблицы лидеров: {0}
@@ -578,7 +578,7 @@ competitorColumnTooltip=Имена членов данного участник
 sailIdColumnTooltip=Показывает флаг страны и хвостовой номер участника.
 rankColumnTooltip=Общий ранг данного участника в регате.
 carryColumnTooltip=Баллы, перенесенные из других гонок.
-totalsColumnTooltip=Общая сумма всех баллов участника в регате.\nСортировка по рангу, не по баллам.
+totalNetPointsColumnTooltip=Общая сумма всех баллов участника в регате.\nСортировка по рангу, не по баллам.
 windData=Данные о ветре
 gpsData=Данные GPS
 status=Статус
@@ -602,7 +602,7 @@ cannotAddRacesToRegattaLeaderboardButOnlyToRegatta=Это таблица лид
 correctScore=Правильная оценка
 correctScoreFor=Правильная оценка для участника {0} в гонке {1}
 penaltyOrRedress=Взыскание/компенсация
-netScore=Точки сети
+totalScore=Точки сети
 timePointMustBeAfterStartOfTracking=Отметка времени должна быть после начала отслеживания.
 timePointMustBeBeforeEndOfTracking=Отметка времени должна быть раньше окончания отслеживания.
 regattaUsedForTheTrackedRace=Регата, используемая для отслеживаемой гонки
@@ -1109,7 +1109,7 @@ simulationLegendTooltip=Сравнение времени:\nгонка — эт
 racesScored=Оцененные гонки
 racesScoredTooltip=Число гонок, которые участник завершил или за которые имеет оценки в данной таблице лидеров.
 averageNumberOfOperationsPerMessage=Среднее число операций на сообщение
-showUncorrectedNetPoints=Показать неисправленные точки сети
+showUncorrectedTotalPoints=Показать неисправленные точки сети
 setStartTimeReceived=Установить полученное время старта
 setStartTimeReceivedDescription=Устанавливает полученное время старта для выбранной отслеживаемой гонки, которое не хранится постоянно. Это значит, что после перезагрузки сервера новое значение будет забыто.
 lastScoreCorrectionsTime=Время последнего исправления оценки

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages_zh.properties

@@ -522,8 +522,8 @@ loadingCompetitorData=正在加载参赛队数据...
 competitorRegattaDataAfterRaceN={0} 比赛轮次后 {1}
 rankChart=排名
 totalPoints=总分
-raceTotalPointsTooltip=参赛队在本轮次比赛中的总分
+raceNetPointsTooltip=参赛队在本轮次比赛中的总分
-regattaTotalPointsTooltip=参赛队在比赛中的总分
+regattaNetPointsTooltip=参赛队在比赛中的总分
 showRankChart=显示排名记录
 overallLeaderboardSelection=总积分榜
 errorTryingToObtainOverallLeaderboards=尝试获取总积分榜出错： {0}
@@ -578,7 +578,7 @@ competitorColumnTooltip=此参赛队的成员姓名。
 sailIdColumnTooltip=显示参赛队所代表的国家国旗和帆号。
 rankColumnTooltip=参赛队在比赛中的总名次。
 carryColumnTooltip=前几个轮次的比赛中的得分。
-totalsColumnTooltip=参赛队在比赛中的总得分。\n按名次（而不是得分）排序。
+totalNetPointsColumnTooltip=参赛队在比赛中的总得分。\n按名次（而不是得分）排序。
 windData=风力数据
 gpsData=GPS 数据
 status=状态
@@ -1109,7 +1109,7 @@ simulationLegendTooltip=时间比较：\n比赛轮次指根据 GPS 计算的航
 racesScored=记分的比赛轮次
 racesScoredTooltip=参赛队完成并记录在此积分榜上的比赛轮次数。
 averageNumberOfOperationsPerMessage=各消息操作的平均数
-showUncorrectedNetPoints=显示未更正的净分
+showUncorrectedTotalPoints=显示未更正的净分
 setStartTimeReceived=设置接收的开始时间
 setStartTimeReceivedDescription=设置非持久的所选 TrackedRace 的 startTimeReceived。 这意味着，重启服务器后，将忘记新值。
 lastScoreCorrectionsTime=上次得分更正时间

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/StringMessages_zh_CN.properties

@@ -522,8 +522,8 @@ loadingCompetitorData=正在加载参赛队数据...
 competitorRegattaDataAfterRaceN={0} 比赛轮次后 {1}
 rankChart=排名
 totalPoints=总分
-raceTotalPointsTooltip=参赛队在本轮次比赛中的总分
+raceNetPointsTooltip=参赛队在本轮次比赛中的总分
-regattaTotalPointsTooltip=参赛队在比赛中的总分
+regattaNetPointsTooltip=参赛队在比赛中的总分
 showRankChart=显示排名记录
 overallLeaderboardSelection=总积分榜
 errorTryingToObtainOverallLeaderboards=尝试获取总积分榜出错： {0}
@@ -578,7 +578,7 @@ competitorColumnTooltip=此参赛队的成员姓名。
 sailIdColumnTooltip=显示参赛队所代表的国家国旗和帆号。
 rankColumnTooltip=参赛队在比赛中的总名次。
 carryColumnTooltip=前几个轮次的比赛中的得分。
-totalsColumnTooltip=参赛队在比赛中的总得分。\n按名次（而不是得分）排序。
+totalNetPointsColumnTooltip=参赛队在比赛中的总得分。\n按名次（而不是得分）排序。
 windData=风力数据
 gpsData=GPS 数据
 status=状态
@@ -602,7 +602,7 @@ cannotAddRacesToRegattaLeaderboardButOnlyToRegatta=有比赛积分榜。您只
 correctScore=更正得分
 correctScoreFor=更正参赛队{0}在比赛轮次{1}中的得分
 penaltyOrRedress=惩罚/补偿
-netScore=净分
+totalScore=净分
 timePointMustBeAfterStartOfTracking=时间点必须在跟踪开始之后。
 timePointMustBeBeforeEndOfTracking=时间点必须在跟踪结束之前。
 regattaUsedForTheTrackedRace=用于跟踪的比赛轮次的比赛
@@ -1109,7 +1109,7 @@ simulationLegendTooltip=时间比较：\n比赛轮次指根据 GPS 计算的航
 racesScored=记分的比赛轮次
 racesScoredTooltip=参赛队完成并记录在此积分榜上的比赛轮次数。
 averageNumberOfOperationsPerMessage=各消息操作的平均数
-showUncorrectedNetPoints=显示未更正的净分
+showUncorrectedTotalPoints=显示未更正的净分
 setStartTimeReceived=设置接收的开始时间
 setStartTimeReceivedDescription=设置非持久的所选 TrackedRace 的 startTimeReceived。 这意味着，重启服务器后，将忘记新值。
 lastScoreCorrectionsTime=上次得分更正时间

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/shared/charts/AbstractCompetitorLeaderboardChart.java

@@ -154,7 +154,7 @@ public abstract class AbstractCompetitorLeaderboardChart<SettingsType extends Ab
                 chart.getYAxis().setReversed(true);
                 chart.getYAxis().setTickInterval(1.0);
                 break;
-            case REGATTA_TOTAL_POINTS_SUM:
+            case REGATTA_NET_POINTS_SUM:
                 chart.getYAxis().setTickInterval(5.0);
                 chart.getYAxis().setReversed(false);
                 break;
@@ -240,7 +240,7 @@ public abstract class AbstractCompetitorLeaderboardChart<SettingsType extends Ab
                         case REGATTA_RANK:
                             fillTotalRanksSeries(result, chartSeries);
                             break;
-                        case REGATTA_TOTAL_POINTS_SUM:
+                        case REGATTA_NET_POINTS_SUM:
                             fillTotalPointsSeries(result, chartSeries);
                             break;
                         default:

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/shared/charts/MultiCompetitorLeaderboardChartSettingsDialogComponent.java

@@ -27,7 +27,7 @@ public class MultiCompetitorLeaderboardChartSettingsDialogComponent implements S
 
         availableDetailsTypes = new ArrayList<DetailType>();
         availableDetailsTypes.add(DetailType.REGATTA_RANK);
-        availableDetailsTypes.add(DetailType.REGATTA_TOTAL_POINTS_SUM);
+        availableDetailsTypes.add(DetailType.REGATTA_NET_POINTS_SUM);
     }
 
     @Override

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/shared/filter/CompetitorRaceRankFilterUIFactory.java

@@ -15,8 +15,8 @@ public class CompetitorRaceRankFilterUIFactory extends AbstractCompetitorNumberF
         this(new CompetitorRaceRankFilter());
     }
 
-    public CompetitorRaceRankFilterUIFactory(CompetitorRaceRankFilter competitorRaceNetPointsFilter) {
+    public CompetitorRaceRankFilterUIFactory(CompetitorRaceRankFilter competitorRaceTotalPointsFilter) {
-        super(competitorRaceNetPointsFilter, BinaryOperator.Operators.LessThanEquals);
+        super(competitorRaceTotalPointsFilter, BinaryOperator.Operators.LessThanEquals);
         
         supportedOperators.add(BinaryOperator.Operators.LessThanEquals);
         supportedOperators.add(BinaryOperator.Operators.GreaterThanEquals);

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboard/LeaderboardEntryPoint.java

@@ -160,7 +160,7 @@ public class LeaderboardEntryPoint extends AbstractSailingEntryPoint {
         String chartDetailParam = GwtHttpRequestUtils.getStringParameter(LeaderboardUrlSettings.PARAM_CHART_DETAIL, null);
         final DetailType chartDetailType;
         if (chartDetailParam != null && (DetailType.REGATTA_RANK.name().equals(chartDetailParam) || DetailType.OVERALL_RANK.name().equals(chartDetailParam) || 
-                DetailType.REGATTA_TOTAL_POINTS_SUM.name().equals(chartDetailParam))) {
+                DetailType.REGATTA_NET_POINTS_SUM.name().equals(chartDetailParam))) {
             chartDetailType = DetailType.valueOf(chartDetailParam);
         } else {
             chartDetailType = leaderboardType.isMetaLeaderboard() ?  DetailType.OVERALL_RANK : DetailType.REGATTA_RANK;

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboard/LeaderboardPanel.java

@@ -526,7 +526,7 @@ public class LeaderboardPanel extends SimplePanel implements TimeListener, PlayS
         getSailingService().getLeaderboardByName(getLeaderboardName(),
                 timer.getPlayMode() == PlayModes.Live ? null : getLeaderboardDisplayDate(),
                 /* namesOfRacesForWhichToLoadLegDetails */getNamesOfExpandedRaces(),
-                shallAddOverallDetails(), previousLeaderboard.getId(), /* fillNetPointsUncorrected */ false,
+                shallAddOverallDetails(), previousLeaderboard.getId(), /* fillTotalPointsUncorrected */ false,
                 new MarkedAsyncCallback<IncrementalOrFullLeaderboardDTO>(
                         new AsyncCallback<IncrementalOrFullLeaderboardDTO>() {
                             @Override
@@ -768,8 +768,8 @@ public class LeaderboardPanel extends SimplePanel implements TimeListener, PlayS
             double addedScores = 0;
             for (RaceColumnDTO raceColumn : getLeaderboard().getRaceList()) {
                 LeaderboardEntryDTO entryBefore = object.fieldsByRaceColumnName.get(raceColumn.getName());
-                if (entryBefore.totalPoints != null) {
+                if (entryBefore.netPoints != null) {
-                    addedScores += entryBefore.totalPoints;
+                    addedScores += entryBefore.netPoints;
                 }
                 // else "add 0"
                 if (raceColumn.getName().equals(getRaceColumnName())) {
@@ -780,11 +780,11 @@ public class LeaderboardPanel extends SimplePanel implements TimeListener, PlayS
         }
 
         /**
-         * Displays a combination of total points and maxPointsReason in bold, transparent, strike-through, depending on
+         * Displays a combination of net points and maxPointsReason in bold, transparent, strike-through, depending on
          * various criteria. Here's how:
          * 
          * <pre>
-         *                                  total points                |    maxPointsReason
+         *                                  net points                |    maxPointsReason
          * -------------------------------+-----------------------------+-----------------------
          *  not discarded, no maxPoints   | bold                        | none
          *  not discarded, maxPoints      | bold                        | transparent
@@ -799,10 +799,10 @@ public class LeaderboardPanel extends SimplePanel implements TimeListener, PlayS
             	boolean isLive = isLive(entry.fleet);
                 final String textColor = isLive ? IS_LIVE_TEXT_COLOR : DEFAULT_TEXT_COLOR;
                 final String addedScores = isShowAddedScores() ? scoreFormat.format(computeAddedScores(object)) : "";
-                String totalOrAddedPointsAsText = isShowAddedScores() ? addedScores
-                        : entry.totalPoints == null ? "" : scoreFormat.format(entry.totalPoints);
                 String netOrAddedPointsAsText = isShowAddedScores() ? addedScores
                         : entry.netPoints == null ? "" : scoreFormat.format(entry.netPoints);
+                String totalOrAddedPointsAsText = isShowAddedScores() ? addedScores
+                        : entry.totalPoints == null ? "" : scoreFormat.format(entry.totalPoints);
                 if (entry.fleet != null && entry.fleet.getColor() != null) {
                     html.append(raceColumnTemplate.cellFrameWithTextColorAndFleetBorder(textColor, entry.fleet.getColor().getAsHtml()));
                 } else {
@@ -812,15 +812,15 @@ public class LeaderboardPanel extends SimplePanel implements TimeListener, PlayS
                 if (entry.reasonForMaxPoints == null || entry.reasonForMaxPoints == MaxPointsReason.NONE) {
                     if (!entry.discarded) {
                         html.appendHtmlConstant("<span style=\"font-weight: bold;\">");
-                        html.appendHtmlConstant(totalOrAddedPointsAsText);
+                        html.appendHtmlConstant(netOrAddedPointsAsText);
                         html.appendHtmlConstant("</span>");
                     } else {
                         html.appendHtmlConstant(" <span style=\"opacity: 0.5;\"><del>");
-                        html.appendHtmlConstant(netOrAddedPointsAsText);
+                        html.appendHtmlConstant(totalOrAddedPointsAsText);
                         html.appendHtmlConstant("</del></span>");
                     }
                 } else {
-                    html.appendHtmlConstant(" <span title=\"" + netOrAddedPointsAsText + "/" + totalOrAddedPointsAsText
+                    html.appendHtmlConstant(" <span title=\"" + totalOrAddedPointsAsText + "/" + netOrAddedPointsAsText
                             + "\" style=\"opacity: 0.5;\">");
                     if (entry.discarded) {
                         html.appendHtmlConstant("<del>");
@@ -923,8 +923,8 @@ public class LeaderboardPanel extends SimplePanel implements TimeListener, PlayS
         public String getValue(LeaderboardRowDTO object) {
             // The following code exists only for robustness. This method should never be called because
             // RaceColumn implements its own render(...) method which doesn't make use of getValue(...)
-            final Double totalPoints = object.fieldsByRaceColumnName.get(getRaceColumnName()).totalPoints;
+            final Double netPoints = object.fieldsByRaceColumnName.get(getRaceColumnName()).netPoints;
-            return "" + (totalPoints == null ? "" : scoreFormat.format(totalPoints));
+            return "" + (netPoints == null ? "" : scoreFormat.format(netPoints));
         }
 
         @Override
@@ -1460,7 +1460,7 @@ public class LeaderboardPanel extends SimplePanel implements TimeListener, PlayS
             int racesSailedInRow = 0;
             for (RaceColumnDTO raceColumn : getLeaderboard().getRaceList()) {
                 LeaderboardEntryDTO entryBefore = object.fieldsByRaceColumnName.get(raceColumn.getName());
-                if (entryBefore.totalPoints != null) {
+                if (entryBefore.netPoints != null) {
                     if (entryBefore.reasonForMaxPoints.equals(MaxPointsReason.NONE) ||
                             !Util.contains(Arrays.asList(MAX_POINTS_REASONS_THAT_IDENTIFY_NON_FINISHED_RACES), entryBefore.reasonForMaxPoints)) {
                         racesSailedInRow++;
@@ -1509,15 +1509,15 @@ public class LeaderboardPanel extends SimplePanel implements TimeListener, PlayS
     }
 
     /**
-     * Displays the totals for a competitor for the entire leaderboard.
+     * Displays the net points totals for a competitor for the entire leaderboard.
      * 
      * @author Axel Uhl (D043530)
      * 
      */
-    private class TotalsColumn extends LeaderboardSortableColumnWithMinMax<LeaderboardRowDTO, String> {
+    private class TotalNetPointssColumn extends LeaderboardSortableColumnWithMinMax<LeaderboardRowDTO, String> {
         private final String columnStyle;
 
-        protected TotalsColumn(String columnStyle) {
+        protected TotalNetPointssColumn(String columnStyle) {
             super(new TextCell(), SortingOrder.ASCENDING, LeaderboardPanel.this);
             this.columnStyle = columnStyle;
             setHorizontalAlignment(ALIGN_CENTER);
@@ -1525,8 +1525,8 @@ public class LeaderboardPanel extends SimplePanel implements TimeListener, PlayS
 
         @Override
         public String getValue(LeaderboardRowDTO object) {
-            Double totalPoints = object.totalPoints;
+            Double netPoints = object.netPoints;
-            return "" + (totalPoints == null ? "" : scoreFormat.format(totalPoints));
+            return "" + (netPoints == null ? "" : scoreFormat.format(netPoints));
         }
 
         @Override
@@ -1556,7 +1556,7 @@ public class LeaderboardPanel extends SimplePanel implements TimeListener, PlayS
 
         @Override
         public SafeHtmlHeader getHeader() {
-            return new SafeHtmlHeaderWithTooltip(SafeHtmlUtils.fromString(stringMessages.total()), stringMessages.totalsColumnTooltip());
+            return new SafeHtmlHeaderWithTooltip(SafeHtmlUtils.fromString(stringMessages.total()), stringMessages.totalNetPointsColumnTooltip());
         }
     }
 
@@ -2243,7 +2243,7 @@ public class LeaderboardPanel extends SimplePanel implements TimeListener, PlayS
             GetLeaderboardByNameAction getLeaderboardByNameAction = new GetLeaderboardByNameAction(sailingService,
                     getLeaderboardName(), useNullAsTimePoint() ? null : date,
                     /* namesOfRacesForWhichToLoadLegDetails */getNamesOfExpandedRaces(), shallAddOverallDetails(), /* previousLeaderboard */
-                    getLeaderboard(), isFillNetPointsUncorrected(), timer, errorReporter, stringMessages);
+                    getLeaderboard(), isFillTotalPointsUncorrected(), timer, errorReporter, stringMessages);
             this.asyncActionsExecutor.execute(getLeaderboardByNameAction, LOAD_LEADERBOARD_DATA_CATEGORY,
                     new AsyncCallback<LeaderboardDTO>() {
                         @Override
@@ -2265,7 +2265,7 @@ public class LeaderboardPanel extends SimplePanel implements TimeListener, PlayS
         }
     }
 
-    protected boolean isFillNetPointsUncorrected() {
+    protected boolean isFillTotalPointsUncorrected() {
         return false;
     }
 
@@ -2826,7 +2826,7 @@ public class LeaderboardPanel extends SimplePanel implements TimeListener, PlayS
      * If the last column is the totals column, remove it. Add the race column as the last column.
      */
     private void addRaceColumn(RaceColumn<?> raceColumn) {
-        if (getLeaderboardTable().getColumn(getLeaderboardTable().getColumnCount() - 1) instanceof TotalsColumn) {
+        if (getLeaderboardTable().getColumn(getLeaderboardTable().getColumnCount() - 1) instanceof TotalNetPointssColumn) {
             removeColumn(getLeaderboardTable().getColumnCount() - 1);
         }
         addColumn(raceColumn);
@@ -2943,8 +2943,8 @@ public class LeaderboardPanel extends SimplePanel implements TimeListener, PlayS
     private void ensureTotalsColumn() {
         // add a totals column on the right
         if (getLeaderboardTable().getColumnCount() == 0
-                || !(getLeaderboardTable().getColumn(getLeaderboardTable().getColumnCount() - 1) instanceof TotalsColumn)) {
+                || !(getLeaderboardTable().getColumn(getLeaderboardTable().getColumnCount() - 1) instanceof TotalNetPointssColumn)) {
-            addColumn(new TotalsColumn(TOTAL_COLUMN_STYLE));
+            addColumn(new TotalNetPointssColumn(TOTAL_COLUMN_STYLE));
         }
     }
     

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboard/LeaderboardUrlConfigurationDialog.java

@@ -178,10 +178,10 @@ public class LeaderboardUrlConfigurationDialog extends SettingsDialog<Leaderboar
             urlSettingsContent.add(chartDetailListBox);
             if (leaderboardType.isMetaLeaderboard()) {
                 chartDetailListBox.addItem(DetailType.OVERALL_RANK.name());
-                chartDetailListBox.addItem(DetailType.REGATTA_TOTAL_POINTS_SUM.name());
+                chartDetailListBox.addItem(DetailType.REGATTA_NET_POINTS_SUM.name());
             } else {
                 chartDetailListBox.addItem(DetailType.REGATTA_RANK.name());
-                chartDetailListBox.addItem(DetailType.REGATTA_TOTAL_POINTS_SUM.name());
+                chartDetailListBox.addItem(DetailType.REGATTA_NET_POINTS_SUM.name());
             }
             chartDetailListBox.setSelectedIndex(0);
             

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboardedit/EditScoreDialog.java

@@ -15,11 +15,11 @@ import com.sap.sse.gwt.client.dialog.DataEntryDialog;
 
 public class EditScoreDialog extends DataEntryDialog<Util.Pair<MaxPointsReason, Double>> {
     private final ListBox maxPointsBox;
-    private final DoubleBox netPointsBox;
+    private final DoubleBox totalPointsBox;
     private final StringMessages stringMessages;
     
     public EditScoreDialog(StringMessages stringMessages, String competitorName, String raceColumnName,
-            MaxPointsReason oldMaxPointsReason, Double oldNetPoints, DialogCallback<Util.Pair<MaxPointsReason, Double>> callback) {
+            MaxPointsReason oldMaxPointsReason, Double oldTotalPoints, DialogCallback<Util.Pair<MaxPointsReason, Double>> callback) {
         super(stringMessages.correctScore(), stringMessages.correctScoreFor(competitorName, raceColumnName),
                 stringMessages.ok(), stringMessages.cancel(), /* validator */ null, /* animationEnabled */ true,
                 callback);
@@ -34,9 +34,9 @@ public class EditScoreDialog extends DataEntryDialog<Util.Pair<MaxPointsReason,
         } else {
             maxPointsBox.setSelectedIndex(1+Arrays.asList(MaxPointsReason.values()).indexOf(oldMaxPointsReason));
         }
-        netPointsBox = createDoubleBox(/* visibleLength */ 5);
+        totalPointsBox = createDoubleBox(/* visibleLength */ 5);
-        if (oldNetPoints != null) {
+        if (oldTotalPoints != null) {
-            netPointsBox.setValue(oldNetPoints);
+            totalPointsBox.setValue(oldTotalPoints);
         }
     }
 
@@ -48,8 +48,8 @@ public class EditScoreDialog extends DataEntryDialog<Util.Pair<MaxPointsReason,
         } else {
             maxPointsReason = MaxPointsReason.valueOf(maxPointsBox.getItemText(maxPointsBox.getSelectedIndex()));
         }
-        final Double netScore = netPointsBox.getValue();
+        final Double totalScore = totalPointsBox.getValue();
-        return new Util.Pair<MaxPointsReason, Double>(maxPointsReason, netScore);
+        return new Util.Pair<MaxPointsReason, Double>(maxPointsReason, totalScore);
     }
 
     @Override
@@ -57,19 +57,19 @@ public class EditScoreDialog extends DataEntryDialog<Util.Pair<MaxPointsReason,
         Grid grid = new Grid(2, 2);
         grid.setWidget(0, 0, new Label(stringMessages.penaltyOrRedress()));
         grid.setWidget(0, 1, maxPointsBox);
-        grid.setWidget(1, 0, new Label(stringMessages.netScore()));
+        grid.setWidget(1, 0, new Label(stringMessages.totalScore()));
-        grid.setWidget(1, 1, netPointsBox);
+        grid.setWidget(1, 1, totalPointsBox);
         return grid;
     }
 
     @Override
     protected FocusWidget getInitialFocusWidget() {
-        return netPointsBox;
+        return totalPointsBox;
     }
     
     @Override
     public void show() {
         super.show();
-        netPointsBox.selectAll();
+        totalPointsBox.selectAll();
     }
 }

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboardedit/EditableLeaderboardPanel.java

@@ -88,7 +88,7 @@ public class EditableLeaderboardPanel extends LeaderboardPanel {
     final private CellTable<CompetitorDTO> suppressedCompetitorsTable;
     final private ListDataProvider<CompetitorDTO> suppressedCompetitorsShown;
 
-    private CheckBox showUncorrectedNetPointsCheckbox;
+    private CheckBox showUncorrectedTotalPointsCheckbox;
     
     private class SettingsClickHandler implements ClickHandler {
         private final StringMessages stringMessages;
@@ -334,13 +334,13 @@ public class EditableLeaderboardPanel extends LeaderboardPanel {
                         }
 
                         @Override
-                        public void onSuccess(Util.Triple<Double, Double, Boolean> newNetAndTotalPointsAndIsCorrected) {
+                        public void onSuccess(Util.Triple<Double, Double, Boolean> newTotalAndNetPointsAndIsCorrected) {
                             setBusyState(false);
                             row.fieldsByRaceColumnName.get(raceColumnName).reasonForMaxPoints = value == null
                                     || value.length() == 0 ? null : MaxPointsReason.valueOf(value.trim());
-                            row.fieldsByRaceColumnName.get(raceColumnName).netPoints = newNetAndTotalPointsAndIsCorrected.getA();
+                            row.fieldsByRaceColumnName.get(raceColumnName).totalPoints = newTotalAndNetPointsAndIsCorrected.getA();
-                            row.fieldsByRaceColumnName.get(raceColumnName).totalPoints = newNetAndTotalPointsAndIsCorrected.getB();
+                            row.fieldsByRaceColumnName.get(raceColumnName).netPoints = newTotalAndNetPointsAndIsCorrected.getB();
-                            row.fieldsByRaceColumnName.get(raceColumnName).netPointsCorrected = newNetAndTotalPointsAndIsCorrected.getC();
+                            row.fieldsByRaceColumnName.get(raceColumnName).totalPointsCorrected = newTotalAndNetPointsAndIsCorrected.getC();
                             getCell().setViewData(row, null); // ensure that getValue() is called again
                             whiteboard.setObjectWithWhichToUpdateRow(row);
                         }
@@ -360,10 +360,10 @@ public class EditableLeaderboardPanel extends LeaderboardPanel {
         }
     }
     
-    private class UncorrectedNetPointsViewProvider extends AbstractRowUpdateWhiteboardProducerThatHasCell<LeaderboardRowDTO, String> {
+    private class UncorrectedTotalPointsViewProvider extends AbstractRowUpdateWhiteboardProducerThatHasCell<LeaderboardRowDTO, String> {
         private final String raceColumnName;
         
-        protected UncorrectedNetPointsViewProvider(String raceColumnName) {
+        protected UncorrectedTotalPointsViewProvider(String raceColumnName) {
             this.raceColumnName = raceColumnName;
         }
 
@@ -382,59 +382,59 @@ public class EditableLeaderboardPanel extends LeaderboardPanel {
         public String getValue(LeaderboardRowDTO object) {
             LeaderboardEntryDTO leaderboardEntryDTO = object.fieldsByRaceColumnName.get(raceColumnName);
             String result = "";
-            if (leaderboardEntryDTO != null && leaderboardEntryDTO.netPointsUncorrected != null) {
+            if (leaderboardEntryDTO != null && leaderboardEntryDTO.totalPointsUncorrected != null) {
-                result="("+scoreFormat.format(leaderboardEntryDTO.netPointsUncorrected)+")";
+                result="("+scoreFormat.format(leaderboardEntryDTO.totalPointsUncorrected)+")";
             }
             return result;
         }
     }
 
-    private class NetPointsEditCellProvider extends AbstractRowUpdateWhiteboardProducerThatHasCell<LeaderboardRowDTO, String> {
+    private class TotalPointsEditCellProvider extends AbstractRowUpdateWhiteboardProducerThatHasCell<LeaderboardRowDTO, String> {
-        private final EditTextCell netPointsEditCell;
+        private final EditTextCell totalPointsEditCell;
         private final String raceColumnName;
 
-        protected NetPointsEditCellProvider(String raceColumnName) {
+        protected TotalPointsEditCellProvider(String raceColumnName) {
             this.raceColumnName = raceColumnName;
-            netPointsEditCell = new EditTextCell(new SafeHtmlRenderer<String>() {
+            totalPointsEditCell = new EditTextCell(new SafeHtmlRenderer<String>() {
                 @Override
-                public void render(String netPointsAsString, SafeHtmlBuilder html) {
+                public void render(String totalPointsAsString, SafeHtmlBuilder html) {
-                    if (netPointsAsString != null) {
+                    if (totalPointsAsString != null) {
-                        final boolean netPointsCorrected = isNetPointsCorrected();
+                        final boolean totalPointsCorrected = isTotalPointsCorrected();
-                        if (netPointsCorrected) {
+                        if (totalPointsCorrected) {
                             html.appendHtmlConstant("<b>");
                         }
-                        html.appendEscaped(netPointsAsString);
+                        html.appendEscaped(totalPointsAsString);
-                        if (netPointsCorrected) {
+                        if (totalPointsCorrected) {
                             html.appendHtmlConstant("</b>");
                         }
                     }
                 }
 
                 @Override
-                public SafeHtml render(String netPointsAsString) {
+                public SafeHtml render(String totalPointsAsString) {
-                    final boolean netPointsCorrected = isNetPointsCorrected();
+                    final boolean totalPointsCorrected = isTotalPointsCorrected();
                     String prefix;
                     String suffix;
-                    if (netPointsCorrected) {
+                    if (totalPointsCorrected) {
                         prefix = "<b class='bold'>";
                         suffix = "</b>";
                     } else {
                         prefix = "";
                         suffix = "";
                     }
-                    return SafeHtmlUtils.fromSafeConstant(prefix+SafeHtmlUtils.fromString(netPointsAsString).asString()+suffix);
+                    return SafeHtmlUtils.fromSafeConstant(prefix+SafeHtmlUtils.fromString(totalPointsAsString).asString()+suffix);
                 }
             });
         }
 
-        private boolean isNetPointsCorrected() {
+        private boolean isTotalPointsCorrected() {
             LeaderboardEntryDTO leaderboardEntryDTO = getCurrentlyRendering().fieldsByRaceColumnName.get(raceColumnName);
-            return leaderboardEntryDTO != null && leaderboardEntryDTO.netPointsCorrected;
+            return leaderboardEntryDTO != null && leaderboardEntryDTO.totalPointsCorrected;
         }
 
         @Override
         public EditTextCell getCell() {
-            return netPointsEditCell;
+            return totalPointsEditCell;
         }
 
         @Override
@@ -460,13 +460,13 @@ public class EditableLeaderboardPanel extends LeaderboardPanel {
                         }
 
                         @Override
-                        public void onSuccess(Util.Triple<Double, Double, Boolean> newNetAndTotalPointsAndIsCorrected) {
+                        public void onSuccess(Util.Triple<Double, Double, Boolean> newTotalAndTotalPointsAndIsCorrected) {
                             setBusyState(false);
                             final LeaderboardEntryDTO leaderboardEntryDTO = row.fieldsByRaceColumnName.get(raceColumnName);
-                            leaderboardEntryDTO.netPoints = value == null || value.length() == 0 ? newNetAndTotalPointsAndIsCorrected
+                            leaderboardEntryDTO.totalPoints = value == null || value.length() == 0 ? newTotalAndTotalPointsAndIsCorrected
                                     .getA() : Double.valueOf(value.trim());
-                            leaderboardEntryDTO.totalPoints = newNetAndTotalPointsAndIsCorrected.getB();
+                            leaderboardEntryDTO.netPoints = newTotalAndTotalPointsAndIsCorrected.getB();
-                            leaderboardEntryDTO.netPointsCorrected = newNetAndTotalPointsAndIsCorrected.getC();
+                            leaderboardEntryDTO.totalPointsCorrected = newTotalAndTotalPointsAndIsCorrected.getC();
                             getCell().setViewData(row, null); // ensure that getValue() is called again
                             whiteboard.setObjectWithWhichToUpdateRow(row);
                         }
@@ -479,31 +479,31 @@ public class EditableLeaderboardPanel extends LeaderboardPanel {
         public String getValue(LeaderboardRowDTO object) {
             LeaderboardEntryDTO leaderboardEntryDTO = object.fieldsByRaceColumnName.get(raceColumnName);
             String result = "n/a";
-            if (leaderboardEntryDTO != null && leaderboardEntryDTO.netPoints != null) {
+            if (leaderboardEntryDTO != null && leaderboardEntryDTO.totalPoints != null) {
-                result = scoreFormat.format(leaderboardEntryDTO.netPoints);
+                result = scoreFormat.format(leaderboardEntryDTO.totalPoints);
             }
             return result;
         }
     }
     
-    private class MaxPointsReasonAndNetPointsEditButtonCell extends AbstractRowUpdateWhiteboardProducerThatHasCell<LeaderboardRowDTO, String> {
+    private class MaxPointsReasonAndTotalPointsEditButtonCell extends AbstractRowUpdateWhiteboardProducerThatHasCell<LeaderboardRowDTO, String> {
         private final ButtonCell cell = new ButtonCell();
         private final String raceColumnName;
         private final StringMessages stringMessages;
         private final MaxPointsDropDownCellProvider maxPointsDropDownCellProvider;
-        private final NetPointsEditCellProvider netPointsEditCellProvider;
+        private final TotalPointsEditCellProvider totalPointsEditCellProvider;
         
         /**
          * @param maxPointsDropDownCellProvider will have its cell's view data reset after a successful update to force call to getValue
-         * @param netPointsEditCellProvider will have its cell's view data reset after a successful update to force call to getValue
+         * @param totalPointsEditCellProvider will have its cell's view data reset after a successful update to force call to getValue
          */
-        public MaxPointsReasonAndNetPointsEditButtonCell(StringMessages stringMessages, String raceColumnName,
+        public MaxPointsReasonAndTotalPointsEditButtonCell(StringMessages stringMessages, String raceColumnName,
                 MaxPointsDropDownCellProvider maxPointsDropDownCellProvider,
-                NetPointsEditCellProvider netPointsEditCellProvider) {
+                TotalPointsEditCellProvider totalPointsEditCellProvider) {
             this.stringMessages = stringMessages;
             this.raceColumnName = raceColumnName;
             this.maxPointsDropDownCellProvider = maxPointsDropDownCellProvider;
-            this.netPointsEditCellProvider = netPointsEditCellProvider;
+            this.totalPointsEditCellProvider = totalPointsEditCellProvider;
         }
 
         @Override
@@ -521,7 +521,7 @@ public class EditableLeaderboardPanel extends LeaderboardPanel {
                     getWhiteboardOwner().whiteboardProduced(whiteboard);
                     new EditScoreDialog(stringMessages, row.competitor.getName(), raceColumnName,
                             row.fieldsByRaceColumnName.get(raceColumnName).reasonForMaxPoints,
-                            row.fieldsByRaceColumnName.get(raceColumnName).netPoints, new DialogCallback<Util.Pair<MaxPointsReason, Double>>() {
+                            row.fieldsByRaceColumnName.get(raceColumnName).totalPoints, new DialogCallback<Util.Pair<MaxPointsReason, Double>>() {
                         @Override
                         public void ok(final Util.Pair<MaxPointsReason, Double> editedObject) {
                             setBusyState(true);
@@ -538,7 +538,7 @@ public class EditableLeaderboardPanel extends LeaderboardPanel {
                                 }
 
                                 @Override
-                                public void onSuccess(Util.Triple<Double, Double, Boolean> newNetAndTotalPointsAndIsCorrected) {
+                                public void onSuccess(Util.Triple<Double, Double, Boolean> newTotalAndTotalPointsAndIsCorrected) {
                                     getSailingService().updateLeaderboardMaxPointsReason(getLeaderboardName(), row.competitor.getIdAsString(), raceColumnName,
                                             editedObject.getA(), getLeaderboardDisplayDate(),
                                                     new AsyncCallback<Util.Triple<Double, Double, Boolean>>() {
@@ -552,15 +552,15 @@ public class EditableLeaderboardPanel extends LeaderboardPanel {
                                         }
 
                                         @Override
-                                        public void onSuccess(Util.Triple<Double, Double, Boolean> newNetAndTotalPointsAndIsCorrected) {
+                                        public void onSuccess(Util.Triple<Double, Double, Boolean> newTotalAndNetPointsAndIsCorrected) {
                                             setBusyState(false);
                                             final LeaderboardEntryDTO leaderboardEntryDTO = row.fieldsByRaceColumnName.get(raceColumnName);
                                             leaderboardEntryDTO.reasonForMaxPoints = editedObject.getA();
-                                            leaderboardEntryDTO.netPoints = newNetAndTotalPointsAndIsCorrected.getA();
+                                            leaderboardEntryDTO.totalPoints = newTotalAndNetPointsAndIsCorrected.getA();
-                                            leaderboardEntryDTO.totalPoints = newNetAndTotalPointsAndIsCorrected.getB();
+                                            leaderboardEntryDTO.netPoints = newTotalAndNetPointsAndIsCorrected.getB();
-                                            leaderboardEntryDTO.netPointsCorrected = newNetAndTotalPointsAndIsCorrected.getC();
+                                            leaderboardEntryDTO.totalPointsCorrected = newTotalAndNetPointsAndIsCorrected.getC();
                                             maxPointsDropDownCellProvider.getCell().setViewData(row, null);
-                                            netPointsEditCellProvider.getCell().setViewData(row, null);
+                                            totalPointsEditCellProvider.getCell().setViewData(row, null);
                                             whiteboard.setObjectWithWhichToUpdateRow(row);
                                         }
                                     });
@@ -652,14 +652,14 @@ public class EditableLeaderboardPanel extends LeaderboardPanel {
         final Button setScoreCorrectionDefaultTimeBtn = new Button(stringMessages.setTimeToNow());
         setScoreCorrectionDefaultTimeBtn.addStyleName("inlineButton");
         scoreCorrectionInfoGrid.setWidget(0, 2, setScoreCorrectionDefaultTimeBtn);
-        showUncorrectedNetPointsCheckbox = new CheckBox(stringMessages.showUncorrectedNetPoints());
+        showUncorrectedTotalPointsCheckbox = new CheckBox(stringMessages.showUncorrectedTotalPoints());
-        showUncorrectedNetPointsCheckbox.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
+        showUncorrectedTotalPointsCheckbox.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
             @Override
             public void onValueChange(ValueChangeEvent<Boolean> event) {
                 timeChanged(getTimer().getTime(), getTimer().getTime());
             }
         });
-        scoreCorrectionInfoGrid.setWidget(0, 3, showUncorrectedNetPointsCheckbox);
+        scoreCorrectionInfoGrid.setWidget(0, 3, showUncorrectedTotalPointsCheckbox);
 
         setScoreCorrectionDefaultTimeBtn.addClickHandler(new ClickHandler() {
             @Override
@@ -994,12 +994,12 @@ public class EditableLeaderboardPanel extends LeaderboardPanel {
                 new ArrayList<RowUpdateWhiteboardProducerThatAlsoHasCell<LeaderboardRowDTO, ?>>();
         final MaxPointsDropDownCellProvider maxPointsDropDownCellProvider = new MaxPointsDropDownCellProvider(race.getRaceColumnName());
         list.add(maxPointsDropDownCellProvider);
-        final NetPointsEditCellProvider netPointsEditCellProvider = new NetPointsEditCellProvider(race.getRaceColumnName());
+        final TotalPointsEditCellProvider totalPointsEditCellProvider = new TotalPointsEditCellProvider(race.getRaceColumnName());
-        list.add(netPointsEditCellProvider);
+        list.add(totalPointsEditCellProvider);
-        final UncorrectedNetPointsViewProvider uncorrectedViewProvider = new UncorrectedNetPointsViewProvider(race.getRaceColumnName());
+        final UncorrectedTotalPointsViewProvider uncorrectedViewProvider = new UncorrectedTotalPointsViewProvider(race.getRaceColumnName());
         list.add(uncorrectedViewProvider);
-        list.add(new MaxPointsReasonAndNetPointsEditButtonCell(getStringMessages(), race.getRaceColumnName(),
+        list.add(new MaxPointsReasonAndTotalPointsEditButtonCell(getStringMessages(), race.getRaceColumnName(),
-                maxPointsDropDownCellProvider, netPointsEditCellProvider));
+                maxPointsDropDownCellProvider, totalPointsEditCellProvider));
         return list;
     }
     
@@ -1007,8 +1007,8 @@ public class EditableLeaderboardPanel extends LeaderboardPanel {
      * Computing the uncorrected scores can be expensive for large leaderboards; disable by default but allow user to enable
      */
     @Override
-    protected boolean isFillNetPointsUncorrected() {
+    protected boolean isFillTotalPointsUncorrected() {
-        return showUncorrectedNetPointsCheckbox==null?false:showUncorrectedNetPointsCheckbox.getValue();
+        return showUncorrectedTotalPointsCheckbox==null?false:showUncorrectedTotalPointsCheckbox.getValue();
     }
 
     @Override

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/leaderboardedit/MatchAndApplyScoreCorrectionsDialog.java

@@ -259,9 +259,9 @@ public class MatchAndApplyScoreCorrectionsDialog extends DataEntryDialog<BulkSco
                             result.addMaxPointsReasonUpdate(competitor, raceColumn,
                                     officialCorrectionEntry.getMaxPointsReason());
                             if (officialCorrectionEntry.getScore() != null) {
-                                double officialTotalPoints = officialCorrectionEntry.getScore().doubleValue();
+                                double officialTotalPointsWithFactorApplied = officialCorrectionEntry.getScore().doubleValue();
-                                double officialNetPoints = officialTotalPoints / raceColumn.getEffectiveFactor();
+                                double officialTotalPoints = officialTotalPointsWithFactorApplied / raceColumn.getEffectiveFactor();
-                                result.addScoreUpdate(competitor, raceColumn, officialNetPoints);
+                                result.addScoreUpdate(competitor, raceColumn, officialTotalPoints);
                             }
                         }
                     }
@@ -308,15 +308,15 @@ public class MatchAndApplyScoreCorrectionsDialog extends DataEntryDialog<BulkSco
                 LeaderboardEntryDTO entry = leaderboardRow.fieldsByRaceColumnName.get(raceColumn.getName());
                 String raceNameOrNumber = getSelectedString(raceNameOrNumberChoosers, raceColumn);
                 VerticalPanel cell = new VerticalPanel();
-                cell.add(new Label(entry.netPoints+"/"+entry.totalPoints+"/"+entry.reasonForMaxPoints+
+                cell.add(new Label(entry.totalPoints+"/"+entry.netPoints+"/"+entry.reasonForMaxPoints+
                         (entry.discarded?"/discarded":"")));
                 if (officialSailID != null && raceNameOrNumber != null) {
                     ScoreCorrectionEntryDTO officialCorrectionEntry =
                         regattaScoreCorrection.getScoreCorrectionsByRaceNameOrNumber()
                         .get(raceNameOrNumber).get(officialSailID);
-                    final Double officialTotalPoints = officialCorrectionEntry == null ? null :
+                    final Double officialTotalPointsWithFactorApplied = officialCorrectionEntry == null ? null :
                         officialCorrectionEntry.isDiscarded() ? new Double(0) : officialCorrectionEntry.getScore();
-                    final Double officialNetPoints = officialCorrectionEntry == null ? null :
+                    final Double officialTotalPoints = officialCorrectionEntry == null ? null :
                         officialCorrectionEntry.getScore() == null ? null :
                         officialCorrectionEntry.getScore() / raceColumn.getEffectiveFactor();
                     final MaxPointsReason officialMaxPointsReason = officialCorrectionEntry == null ? null :
@@ -325,25 +325,25 @@ public class MatchAndApplyScoreCorrectionsDialog extends DataEntryDialog<BulkSco
                     // entries not considered "different' in case we haven't got an entry for the competitor/race at all;
                     // those non-existing "entries" will be ignored by getResults anyhow
                     boolean entriesDiffer = officialCorrectionEntry != null &&
-                           (((officialNetPoints == null && entry.netPoints != null) || (officialNetPoints != null && (entry.netPoints == null || !new Double(entry.netPoints).equals(officialNetPoints)))) ||
+                           (((officialTotalPoints == null && entry.totalPoints != null) || (officialTotalPoints != null && (entry.totalPoints == null || !new Double(entry.totalPoints).equals(officialTotalPoints)))) ||
-                            ((officialTotalPoints == null && entry.totalPoints != null) || (officialTotalPoints != null && (entry.totalPoints == null || !new Double(entry.totalPoints).equals(officialTotalPoints)))) ||
+                            ((officialTotalPointsWithFactorApplied == null && entry.netPoints != null) || (officialTotalPointsWithFactorApplied != null && (entry.netPoints == null || !new Double(entry.netPoints).equals(officialTotalPointsWithFactorApplied)))) ||
                             ((officialMaxPointsReason == null && entry.reasonForMaxPoints != MaxPointsReason.NONE) ||
                                     officialMaxPointsReason != null && officialMaxPointsReason != entry.reasonForMaxPoints));
                     if (entriesDiffer) {
                         sb.appendHtmlConstant("<span style=\"color: #0000FF;\"><b>");
                     }
-                    if (officialNetPoints == null) {
-                        sb.appendEscaped("null");
-                    } else {
-                        sb.append(officialNetPoints);
-                    }
-                    sb.appendEscaped("/");
                     if (officialTotalPoints == null) {
                         sb.appendEscaped("null");
                     } else {
                         sb.append(officialTotalPoints);
                     }
                     sb.appendEscaped("/");
+                    if (officialTotalPointsWithFactorApplied == null) {
+                        sb.appendEscaped("null");
+                    } else {
+                        sb.append(officialTotalPointsWithFactorApplied);
+                    }
+                    sb.appendEscaped("/");
                     if (officialMaxPointsReason != null) {
                         sb.appendEscaped(officialMaxPointsReason.name());
                     } else {

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/server/SailingServiceImpl.java

@@ -698,7 +698,7 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
     @Override
     public IncrementalOrFullLeaderboardDTO getLeaderboardByName(final String leaderboardName, final Date date,
             final Collection<String> namesOfRaceColumnsForWhichToLoadLegDetails, boolean addOverallDetails,
-            String previousLeaderboardId, boolean fillNetPointsUncorrected) throws NoWindException, InterruptedException, ExecutionException,
+            String previousLeaderboardId, boolean fillTotalPointsUncorrected) throws NoWindException, InterruptedException, ExecutionException,
             IllegalArgumentException {
         try {
             long startOfRequestHandling = System.currentTimeMillis();
@@ -712,7 +712,7 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
                     timePoint = new MillisecondsTimePoint(date);
                 }
                 LeaderboardDTO leaderboardDTO = leaderboard.getLeaderboardDTO(timePoint,
-                        namesOfRaceColumnsForWhichToLoadLegDetails, addOverallDetails, getService(), baseDomainFactory, fillNetPointsUncorrected);
+                        namesOfRaceColumnsForWhichToLoadLegDetails, addOverallDetails, getService(), baseDomainFactory, fillTotalPointsUncorrected);
                 LeaderboardDTO previousLeaderboardDTO = null;
                 synchronized (leaderboardByNameResultsCacheById) {
                     leaderboardByNameResultsCacheById.put(leaderboardDTO.getId(), leaderboardDTO);
@@ -3041,8 +3041,8 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
             TimePoint effectiveTimePoint = timePoint == null ? leaderboard.getNowMinusDelay() : timePoint;
             if (detailType != null) {
                 switch (detailType) {
-                case REGATTA_TOTAL_POINTS_SUM:
+                case REGATTA_NET_POINTS_SUM:
-                    for (Entry<RaceColumn, Map<Competitor, Double>> e : leaderboard.getTotalPointsSumAfterRaceColumn(effectiveTimePoint).entrySet()) {
+                    for (Entry<RaceColumn, Map<Competitor, Double>> e : leaderboard.getNetPointsSumAfterRaceColumn(effectiveTimePoint).entrySet()) {
                         List<CompetitorDTO> competitorDTOs = new ArrayList<>();
                         List<Double> pointSums = new ArrayList<>();
                         for (Entry<Competitor, Double> e2 : e.getValue().entrySet()) {

java/com.sap.sailing.mongodb.test/src/com/sap/sailing/mongodb/test/TestStoringAndRetrievingLeaderboardGroups.java

@@ -161,10 +161,10 @@ public class TestStoringAndRetrievingLeaderboardGroups extends AbstractMongoDBTe
         Leaderboard loadedOverallLeaderboard = loadedLeaderboardGroup.getOverallLeaderboard();
         final RaceColumn leaderboard3Column = loadedOverallLeaderboard.getRaceColumnByName("Leaderboard 3");
         assertTrue(loadedOverallLeaderboard.getScoreCorrection().hasCorrectionFor(leaderboard3Column));
-        final Double totalPoints = loadedOverallLeaderboard.getTotalPoints(wolfgang, leaderboard3Column,
+        final Double netPoints = loadedOverallLeaderboard.getNetPoints(wolfgang, leaderboard3Column,
                 MillisecondsTimePoint.now());
-        assertNotNull(totalPoints);
+        assertNotNull(netPoints);
-        assertEquals(99.9, totalPoints, 0.00000000001);
+        assertEquals(99.9, netPoints, 0.00000000001);
     }
 
     @Test

java/com.sap.sailing.resultimport/src/com/sap/sailing/resultimport/CompetitorRow.java

@@ -4,7 +4,7 @@ package com.sap.sailing.resultimport;
 public interface CompetitorRow {
     Iterable<CompetitorEntry> getRankAndMaxPointsReasonAndPointsAndDiscarded();
 
-    Double getNetPointsBeforeDiscarding();
+    Double getTotalPointsBeforeDiscarding();
 
     Double getScoreAfterDiscarding();
 

java/com.sap.sailing.resultimport/src/com/sap/sailing/resultimport/impl/CompetitorRowImpl.java

@@ -8,17 +8,17 @@ public class CompetitorRowImpl implements CompetitorRow {
     private final String sailID;
     private final Iterable<String> names;
     private final Double scoreAfterDiscarding;
-    private final Double netPointsBeforeDiscarding;
+    private final Double totalPointsBeforeDiscarding;
     private final Iterable<CompetitorEntry> rankAndMaxPointsReasonAndPointsAndDiscarded;
     
     public CompetitorRowImpl(Integer totalRank, String sailID, Iterable<String> names, Double scoreAfterDiscarding,
-            Double netPointsBeforeDiscarding, Iterable<CompetitorEntry> rankAndMaxPointsReasonAndPointsAndDiscarded) {
+            Double totalPointsBeforeDiscarding, Iterable<CompetitorEntry> rankAndMaxPointsReasonAndPointsAndDiscarded) {
         super();
         this.totalRank = totalRank;
         this.sailID = sailID;
         this.names = names;
         this.scoreAfterDiscarding = scoreAfterDiscarding;
-        this.netPointsBeforeDiscarding = netPointsBeforeDiscarding;
+        this.totalPointsBeforeDiscarding = totalPointsBeforeDiscarding;
         this.rankAndMaxPointsReasonAndPointsAndDiscarded = rankAndMaxPointsReasonAndPointsAndDiscarded;
     }
 
@@ -43,8 +43,8 @@ public class CompetitorRowImpl implements CompetitorRow {
     }
 
     @Override
-    public Double getNetPointsBeforeDiscarding() {
+    public Double getTotalPointsBeforeDiscarding() {
-        return netPointsBeforeDiscarding;
+        return totalPointsBeforeDiscarding;
     }
 
     @Override

java/com.sap.sailing.sailwave.resultimport.test/.settings/org.eclipse.core.resources.prefs

@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding//src/com/sap/sailing/sailwave/resultimport/test/ParserTest.java=UTF-8

java/com.sap.sailing.server.gateway/src/com/sap/sailing/server/gateway/jaxrs/api/LeaderboardsResource.java

@@ -154,7 +154,7 @@ public class LeaderboardsResource extends AbstractSailingServerResource {
         LeaderboardDTO leaderboardDTO = leaderboard.getLeaderboardDTO(
                 timePointAndResultStateAndMaxCompetitorsCount.getA(), Collections.<String> emptyList(), /* addOverallDetails */
                 false, getService(), getService().getBaseDomainFactory(),
-                /* fillNetPointsUncorrected */false);
+                /* fillTotalPointsUncorrected */false);
 
         TimePoint resultTimePoint = timePointAndResultStateAndMaxCompetitorsCount.getA();
         ResultStates resultState = timePointAndResultStateAndMaxCompetitorsCount.getB();
@@ -183,7 +183,7 @@ public class LeaderboardsResource extends AbstractSailingServerResource {
 
             jsonCompetitor.put("rank", counter);
             jsonCompetitor.put("carriedPoints", leaderboardRowDTO.carriedPoints);
-            jsonCompetitor.put("totalPoints", leaderboardRowDTO.totalPoints);
+            jsonCompetitor.put("netPoints", leaderboardRowDTO.netPoints);
             jsonCompetitorEntries.add(jsonCompetitor);
             JSONObject jsonRaceColumns = new JSONObject();
             jsonCompetitor.put("raceScores", jsonRaceColumns);
@@ -197,9 +197,9 @@ public class LeaderboardsResource extends AbstractSailingServerResource {
 
                 final FleetDTO fleetOfCompetitor = leaderboardEntry.fleet;
                 jsonEntry.put("fleet", fleetOfCompetitor == null ? "" : fleetOfCompetitor.getName());
-                jsonEntry.put("netPoints", leaderboardEntry.netPointsCorrected);
+                jsonEntry.put("totalPoints", leaderboardEntry.totalPointsCorrected);
-                jsonEntry.put("uncorrectedNetPoints", leaderboardEntry.netPoints);
+                jsonEntry.put("uncorrectedTotalPoints", leaderboardEntry.totalPoints);
-                jsonEntry.put("totalPoints", leaderboardEntry.totalPoints);
+                jsonEntry.put("netPoints", leaderboardEntry.netPoints);
                 MaxPointsReason maxPointsReason = leaderboardEntry.reasonForMaxPoints;
                 jsonEntry.put("maxPointsReason", maxPointsReason != null ? maxPointsReason.toString() : null);
                 jsonEntry.put("rank", regattaRankedCompetitorsForColumn.indexOf(competitor) + 1);
@@ -236,7 +236,7 @@ public class LeaderboardsResource extends AbstractSailingServerResource {
 
             jsonCompetitor.put("rank", 0);
             jsonCompetitor.put("carriedPoints", null);
-            jsonCompetitor.put("totalPoints", null);
+            jsonCompetitor.put("netPoints", null);
             jsonCompetitorEntries.add(jsonCompetitor);
             JSONObject jsonRaceColumns = new JSONObject();
             jsonCompetitor.put("raceScores", jsonRaceColumns);
@@ -245,8 +245,8 @@ public class LeaderboardsResource extends AbstractSailingServerResource {
                 jsonRaceColumns.put(raceColumn.getName(), jsonEntry);
                 final Fleet fleetOfCompetitor = raceColumn.getFleetOfCompetitor(competitor);
                 jsonEntry.put("fleet", fleetOfCompetitor == null ? "" : fleetOfCompetitor.getName());
-                jsonEntry.put("netPoints", null);
                 jsonEntry.put("totalPoints", null);
+                jsonEntry.put("netPoints", null);
                 jsonEntry.put("maxPointsReason", "");
                 jsonEntry.put("rank", 0);
                 jsonEntry.put("isDiscarded", false);

java/com.sap.sailing.server.test/src/com/sap/sailing/server/test/LeaderboardDiscardingRulesTest.java

@@ -86,10 +86,10 @@ public class LeaderboardDiscardingRulesTest {
         TimePoint now = MillisecondsTimePoint.now();
         // Hunger scores better than Plattner in this case because Hunger's two discards are 123/124, keeping 122/122
         // whereas Plattner is to discard two of the four 123 results, keeping 123/123, being two points worse than Hunger:
-        double totalPointsHasso = leaderboard.getTotalPoints(hasso, now);
+        double netPointsHasso = leaderboard.getNetPoints(hasso, now);
-        double totalPointsWolfgang = leaderboard.getTotalPoints(wolfgang, now);
+        double netPointsWolfgang = leaderboard.getNetPoints(wolfgang, now);
-        assertEquals(122.+122., totalPointsWolfgang, 0.0000000001);
+        assertEquals(122.+122., netPointsWolfgang, 0.0000000001);
-        assertEquals(123.+123., totalPointsHasso,  0.000000001);
+        assertEquals(123.+123., netPointsHasso,  0.000000001);
     }
 
     /**
@@ -129,11 +129,11 @@ public class LeaderboardDiscardingRulesTest {
         TimePoint now = MillisecondsTimePoint.now();
         // Jes scores better than Rasmus in this case because Jes's two discards are 1.0/2.0, keeping 3.0/3.0
         // whereas Rasmus is to discard two of the four 2.0 results, keeping 2.0/2.0, being two points worse than Hunger:
-        double totalPointsRasmus = leaderboard.getTotalPoints(rasmus, now);
+        double netPointsRasmus = leaderboard.getNetPoints(rasmus, now);
-        double totalPointsJes = leaderboard.getTotalPoints(jes, now);
+        double netPointsJes = leaderboard.getNetPoints(jes, now);
         assertEquals(3, Util.size(leaderboard.getCompetitors()));
-        assertEquals(3.+3., totalPointsJes, 0.0000000001);
+        assertEquals(3.+3., netPointsJes, 0.0000000001);
-        assertEquals(2.+2., totalPointsRasmus,  0.000000001);
+        assertEquals(2.+2., netPointsRasmus,  0.000000001);
     }
 
     /**
@@ -171,9 +171,9 @@ public class LeaderboardDiscardingRulesTest {
         TimePoint now = MillisecondsTimePoint.now();
         // Hunger scores better than Plattner in this case because Hunger's two discards are 123/124, keeping 122/122
         // whereas Plattner is to discard two of the four 123 results, keeping 123/123, being two points worse than Hunger:
-        double totalPointsHasso = leaderboard.getTotalPoints(hasso, now);
+        double netPointsHasso = leaderboard.getNetPoints(hasso, now);
-        double totalPointsWolfgang = leaderboard.getTotalPoints(wolfgang, now);
+        double netPointsWolfgang = leaderboard.getNetPoints(wolfgang, now);
-        assertEquals(122.+122., totalPointsWolfgang, 0.0000000001);
+        assertEquals(122.+122., netPointsWolfgang, 0.0000000001);
-        assertEquals(123.+123., totalPointsHasso,  0.000000001);
+        assertEquals(123.+123., netPointsHasso,  0.000000001);
     }
 }

java/com.sap.sailing.server/src/com/sap/sailing/server/operationaltransformation/UpdateLeaderboardMaxPointsReason.java

@@ -51,7 +51,7 @@ public class UpdateLeaderboardMaxPointsReason extends AbstractLeaderboardColumnO
                 updateStoredLeaderboard(toState, leaderboard);
                 Entry updatedEntry = leaderboard.getEntry(competitor, raceColumn, timePoint);
                 boolean isScoreCorrected = leaderboard.getScoreCorrection().isScoreCorrected(competitor, raceColumn, timePoint);
-                return new Util.Triple<Double, Double, Boolean>(updatedEntry.getNetPoints(), updatedEntry.getTotalPoints(), isScoreCorrected);
+                return new Util.Triple<Double, Double, Boolean>(updatedEntry.getTotalPoints(), updatedEntry.getNetPoints(), isScoreCorrected);
             } else {
                 throw new IllegalArgumentException("Didn't find competitor with ID "+competitorIdAsString+" in leaderboard "+getLeaderboardName());
             }

java/com.sap.sailing.server/src/com/sap/sailing/server/operationaltransformation/UpdateLeaderboardScoreCorrection.java

@@ -41,8 +41,8 @@ public class UpdateLeaderboardScoreCorrection extends AbstractLeaderboardColumnO
     @Override
     public Util.Triple<Double, Double, Boolean> internalApplyTo(RacingEventService toState) throws NoWindException {
         Leaderboard leaderboard = toState.getLeaderboardByName(getLeaderboardName());
-        Double newNetPoints;
         Double newTotalPoints;
+        Double newNetPoints;
         boolean isScoreCorrected;
         if (leaderboard != null) {
             Competitor competitor = leaderboard.getCompetitorByIdAsString(competitorIdAsString);
@@ -50,12 +50,12 @@ public class UpdateLeaderboardScoreCorrection extends AbstractLeaderboardColumnO
                 RaceColumn raceColumn = leaderboard.getRaceColumnByName(getColumnName());
                 if (correctedScore == null) {
                     leaderboard.getScoreCorrection().uncorrectScore(competitor, raceColumn);
-                    newNetPoints = leaderboard.getNetPoints(competitor, raceColumn, timePoint);
+                    newTotalPoints = leaderboard.getTotalPoints(competitor, raceColumn, timePoint);
                 } else {
                     leaderboard.getScoreCorrection().correctScore(competitor, raceColumn, correctedScore);
-                    newNetPoints = correctedScore;
+                    newTotalPoints = correctedScore;
                 }
-                newTotalPoints = leaderboard.getEntry(competitor, raceColumn, timePoint).getTotalPoints();
+                newNetPoints = leaderboard.getEntry(competitor, raceColumn, timePoint).getNetPoints();
                 isScoreCorrected = leaderboard.getScoreCorrection().isScoreCorrected(competitor, raceColumn, timePoint);
             } else {
                 throw new IllegalArgumentException("Didn't find competitor with ID "+competitorIdAsString+" in leaderboard "+getLeaderboardName());
@@ -64,7 +64,7 @@ public class UpdateLeaderboardScoreCorrection extends AbstractLeaderboardColumnO
             throw new IllegalArgumentException("Didn't find leaderboard "+getLeaderboardName());
         }
         updateStoredLeaderboard(toState, leaderboard);
-        return new Util.Triple<Double, Double, Boolean>(newNetPoints, newTotalPoints, isScoreCorrected);
+        return new Util.Triple<Double, Double, Boolean>(newTotalPoints, newNetPoints, isScoreCorrected);
     }
 
 }

java/com.sap.sailing.velum.resultimport.test/.settings/org.eclipse.core.resources.prefs

@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding//src/com/sap/sailing/velum/resultimport/test/ParserTest.java=UTF-8

java/com.sap.sailing.xmlexport/src/com/sap/sailing/xmlexport/LeaderboardData.java

@@ -243,7 +243,7 @@ public class LeaderboardData extends ExportAction {
                     addNamedElementWithValue(competitorRaceDataElement, "max_points_reason", maxPointsReason.toString()); 
                     boolean isDiscardedForCompetitor = leaderboard.isDiscarded(competitorInLeaderboard, column, timepointToBeUsed);
                     addNamedElementWithValue(competitorRaceDataElement, "is_discarded", isDiscardedForCompetitor == true ? "true" : "false");
-                    Double finalRaceScore = leaderboard.getTotalPoints(competitorInLeaderboard, column, timepointToBeUsed);
+                    Double finalRaceScore = leaderboard.getNetPoints(competitorInLeaderboard, column, timepointToBeUsed);
                     addNamedElementWithValue(competitorRaceDataElement, "final_race_score", finalRaceScore);
                     competitorElement.addContent(competitorRaceDataElement);
                     raceElement.addContent(competitorElement);
@@ -404,7 +404,7 @@ public class LeaderboardData extends ExportAction {
                         addNamedElementWithValue(competitorRaceDataElement, "max_points_reason", maxPointsReason.toString()); 
                         boolean isDiscardedForCompetitor = leaderboard.isDiscarded(competitorInLeaderboard, column, race.getEndOfRace());
                         addNamedElementWithValue(competitorRaceDataElement, "is_discarded", isDiscardedForCompetitor == true ? "true" : "false");
-                        Double finalRaceScore = leaderboard.getTotalPoints(competitorInLeaderboard, column, race.getEndOfRace());
+                        Double finalRaceScore = leaderboard.getNetPoints(competitorInLeaderboard, column, race.getEndOfRace());
                         addNamedElementWithValue(competitorRaceDataElement, "final_race_score", finalRaceScore);
                         competitorElement.addContent(competitorRaceDataElement);
                         raceElement.addContent(competitorElement);
@@ -428,7 +428,7 @@ public class LeaderboardData extends ExportAction {
             addNamedElementWithValue(competitorRaceDataElement, "max_points_reason", maxPointsReason.toString()); 
             boolean isDiscardedForCompetitor = leaderboard.isDiscarded(competitor, column, race.getEndOfRace());
             addNamedElementWithValue(competitorRaceDataElement, "is_discarded", isDiscardedForCompetitor == true ? "true" : "false");
-            Double finalRaceScore = leaderboard.getTotalPoints(competitor, column, race.getEndOfRace());
+            Double finalRaceScore = leaderboard.getNetPoints(competitor, column, race.getEndOfRace());
             addNamedElementWithValue(competitorRaceDataElement, "final_race_score", finalRaceScore);
             if (maxPointsReason.equals(MaxPointsReason.DNS) || race.getMarkPassings(competitor).isEmpty()) {
                 // we do not want to include competitors that did not start the race
@@ -701,7 +701,7 @@ public class LeaderboardData extends ExportAction {
         Speed averageSpeedOverGroundIncludingNonCompletedRaces = getAverageSpeedOverGround(leaderboard, competitor, timePointOfLatestModification, true);
         addNamedElementWithValue(competitorElement, "average_speed_over_ground_including_non_finished_races_in_knots", averageSpeedOverGroundIncludingNonCompletedRaces == null ? 0 : averageSpeedOverGroundIncludingNonCompletedRaces.getKnots());
         addNamedElementWithValue(competitorElement, "overall_rank", leaderboard.getTotalRankOfCompetitor(competitor, timePointOfLatestModification));
-        addNamedElementWithValue(competitorElement, "overall_score", leaderboard.getTotalPoints(competitor, timePointOfLatestModification));
+        addNamedElementWithValue(competitorElement, "overall_score", leaderboard.getNetPoints(competitor, timePointOfLatestModification));
         competitorElement.addContent(createDataConfidenceXML(competitorConfidenceAndErrorMessages));
         TimePoint elapsedTime = MillisecondsTimePoint.now().minus(timeSpent.asMillis());
         addNamedElementWithValue(competitorElement, "generation_time_in_milliseconds", elapsedTime.asMillis());