public void CalculateAveragePenaltyCosts()
{
// pull data
SqlConnection connection = new SqlConnection(_connectionString);
connection.Open();
SqlTransaction transaction = connection.BeginTransaction();
var jamData = _jamTeamData
.GroupBy(jd => jd.JamID)
.ToDictionary(
g => g.Key,
g => g.ToDictionary(g2 => g2.TeamID, g2 => g2)
);
var jamPlayerMap = _jamPlayers
.GroupBy(jp => jp.JamID)
.ToDictionary(
g => g.Key,
g => g.ToDictionary(g2 => g2.PlayerID, g2 => g2)
);
Dictionary <FoulComparison, Dictionary <int, float> > sss = new SituationalScoreGateway(connection, transaction).GetAllSituationalScores();
var penaltyGroupCost = PenaltyCostCalculator.CalculatePointCosts(jamData, jamPlayerMap, _penaltyGroups, _boxTimeEstimates, sss);
var jteMap = _jamTeamEffectiveness.GroupBy(jte => jte.JamID).ToDictionary(g => g.Key, g => g.ToDictionary(g2 => g2.TeamID, g2 => g2.Percentile));
var penaltyGroupValueCost = PenaltyCostCalculator.CalculateValueCosts(jamData, jamPlayerMap, _penaltyGroups, _boxTimeEstimates, sss, jteMap);
double jammerPointCost = 0;
double blockerPointCost = 0;
double jammerValueCost = 0;
double blockerValueCost = 0;
foreach (PenaltyGroup pg in _penaltyGroups)
{
if (!penaltyGroupCost.ContainsKey(pg.GroupID) || !penaltyGroupValueCost.ContainsKey(pg.GroupID))
{
continue;
}
// determine whether this penalty group is for a jammer or blocker
var penalty = pg.Penalties[0];
if (jamPlayerMap[penalty.JamID][penalty.PlayerID].IsJammer)
{
jammerPointCost += penaltyGroupCost[pg.GroupID] * pg.Penalties.Count;
jammerValueCost += penaltyGroupValueCost[pg.GroupID] * pg.Penalties.Count;
}
else
{
blockerPointCost += penaltyGroupCost[pg.GroupID] * pg.Penalties.Count;
blockerValueCost += penaltyGroupValueCost[pg.GroupID] * pg.Penalties.Count;
}
}
new AveragePenaltyCostGateway(connection, transaction).InsertAveragePenaltyCost(new AveragePenaltyCostPerJam
{
BlockerPointCost = blockerPointCost / (8 * jamData.Keys.Count),
BlockerValueCost = blockerValueCost / (8 * jamData.Keys.Count),
JammerPointCost = jammerPointCost / (2 * jamData.Keys.Count),
JammerValueCost = jammerValueCost / (2 * jamData.Keys.Count)
});
transaction.Commit();
connection.Close();
}
public IList <Dictionary <int, PlayerPerformance> > GetAllPlayerPointPerformances(int numberOfIterations)
{
// pull data
SqlConnection connection = new SqlConnection(_connectionString);
connection.Open();
SqlTransaction transaction = connection.BeginTransaction();
var players = new PlayerGateway(connection, transaction).GetAllPlayers().GroupBy(p => p.ID).ToDictionary(g => g.Key, g => g.ToDictionary(g2 => g2.TeamID));
var jams = new JamGateway(connection, transaction).GetAllJams().OrderBy(j => j.ID);
var jamBoutMap = jams.ToDictionary(j => j.ID, j => j.BoutID);
var jpe = new JamPlayerEffectivenessGateway(connection, transaction).GetAllJamPlayerEffectiveness();
var jamData = new JamDataGateway(connection, transaction).GetJamTeamDataForYear(STATS_START_DATE.Year)
.GroupBy(jd => jd.JamID)
.ToDictionary(g => g.Key, g => g.ToDictionary(g2 => g2.TeamID));
var teams = new TeamGateway(connection, transaction).GetAllTeams().ToDictionary(t => t.ID);
var bouts = new BoutGateway(connection, transaction).GetBouts().ToDictionary(t => t.ID);
var penalties = new PenaltyGateway(connection, transaction).GetAllPenalties()
.GroupBy(p => p.JamID)
.ToDictionary(
g => g.Key,
g => g.GroupBy(g2 => g2.PlayerID).ToDictionary(g3 => g3.Key, g3 => g3.ToList()));
var pgs = new PenaltyGroupGateway(connection, transaction).GetAllPenaltyGroups();
Dictionary <int, int> boxTimeEstimates = new BoxTimeEstimateGateway(connection, transaction).GetAllBoxTimeEstimates();
Dictionary <FoulComparison, Dictionary <int, float> > sss = new SituationalScoreGateway(connection, transaction).GetAllSituationalScores();
AveragePenaltyCostPerJam avgPenCost = new AveragePenaltyCostGateway(connection, transaction).GetAveragePenaltyCost();
Dictionary <int, Dictionary <int, JamPlayer> > jamPlayerMap = new JamPlayerGateway(connection, transaction).GetJamPlayers()
.GroupBy(jp => jp.JamID)
.ToDictionary(g => g.Key, g => g.ToDictionary(g2 => g2.PlayerID));
transaction.Commit();
connection.Close();
Dictionary <FoulComparison, float> medians = CalculateMedianScores(sss);
PenaltyCostCalculator ppcCalc = new PenaltyCostCalculator(_connectionString);
Dictionary <int, double> groupPenaltyCostMap = PenaltyCostCalculator.CalculatePointCosts(jamData, jamPlayerMap, pgs, boxTimeEstimates, sss);
Dictionary <int, double> jamTotalPortionMap = new Dictionary <int, double>(300);
var previousResult = GenerateInitialPlayerPerformance(players, jams, jpe, jamData, teams, bouts, penalties, pgs, avgPenCost, medians, groupPenaltyCostMap, jamTotalPortionMap);
List <Dictionary <int, PlayerPerformance> > result = new List <Dictionary <int, PlayerPerformance> >(numberOfIterations);
result.Add(previousResult);
int i = 0;
while (i < numberOfIterations)
{
previousResult = GeneratePlayerPerformanceIteration(previousResult, jams, jamData, jamTotalPortionMap, jpe, avgPenCost);
result.Add(previousResult);
i++;
}
return(result);
}