private void SaveEnsembleResult(string researchName, EnsembleResult e, int id)
{
foreach (AnalyzeOption opt in e.Result.Keys)
{
AnalyzeOptionInfo info = ((AnalyzeOptionInfo[])opt.GetType().GetField(opt.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false))[0];
OptionType optionType = info.OptionType;
switch (optionType)
{
case OptionType.Global:
SaveToGlobalSheet(id, info, e.Result[opt]);
break;
case OptionType.ValueList:
SaveValueListSheet(id, info, e.Result[opt]);
break;
case OptionType.Centrality:
SaveCentralitySheet(id, info, e.Result[opt]);
break;
case OptionType.Distribution:
SaveDistributionSheet(id, info, e.Result[opt]);
break;
case OptionType.Trajectory:
SaveTrajectorySheetAndFile(researchName, id, info, e.Result[opt]);
break;
default:
break;
}
}
}
// TODO think about
private void AverageResults()
{
Debug.Assert(subResearches.Count != 0);
EnsembleResult r = new EnsembleResult(subResearches[0].Result.Size);
double rCount = subResearches.Count;
foreach (AnalyzeOption option in subResearches[0].Result.EnsembleResults[0].Result.Keys)
{
SortedDictionary <Double, Double> temp = new SortedDictionary <Double, Double>();
foreach (AbstractResearch res in subResearches)
{
SortedDictionary <Double, Double> d = res.Result.EnsembleResults[0].Result[option] as SortedDictionary <Double, Double>;
foreach (KeyValuePair <double, double> k in d)
{
if (temp.ContainsKey(k.Key))
{
temp[k.Key] += k.Value / rCount;
}
else
{
temp.Add(k.Key, k.Value / rCount);
}
}
}
foreach (var item in temp.Where(kvp => kvp.Value.ToString() == "1").ToList())
{
temp.Remove(item.Key);
}
temp.Add(temp.Count, 1);
r.Result.Add(option, temp);
}
result.EnsembleResults.Add(r);
}
public override void Run()
{
PrepareData();
for (int i = 0; i < threads.Length; ++i)
{
threads[i].Start(threadData[i]);
}
AutoResetEvent.WaitAll(waitHandles);
List <RealizationResult> results = new List <RealizationResult>();
for (int i = 0; i < networks.Length; ++i)
{
if (networks[i].SuccessfullyCompleted)
{
results.Add(networks[i].NetworkResult);
}
}
if (results.Count != 0)
{
Result = EnsembleResult.AverageResults(results);
}
}
private void LoadEnsembleResults(String folderName, ResearchResult r)
{
EnsembleResult e = new EnsembleResult(r.Size);
e.EdgesCount = r.Edges;
e.Result = new Dictionary <AnalyzeOption, Object>();
foreach (String fileName in Directory.GetFiles(folderName))
{
/*reader.Read();
* while (reader.NodeType != XmlNodeType.EndElement)
* {
* AnalyzeOption opt = (AnalyzeOption)Enum.Parse(typeof(AnalyzeOption), reader.Name);
* AnalyzeOptionInfo optInfo = (AnalyzeOptionInfo)(opt.GetType().GetField(opt.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false)[0]);
* switch (optInfo.OptionType)
* {
* case OptionType.Global:
* e.Result.Add(opt, reader.ReadElementContentAsDouble());
* break;
* case OptionType.ValueList:
* case OptionType.Centrality:
* e.Result.Add(opt, LoadValueList());
* reader.Read();
* break;
* case OptionType.Distribution:
* case OptionType.Trajectory:
* e.Result.Add(opt, LoadDistribution());
* reader.Read();
* break;
* default:
* break;
* }
* }*/
}
r.EnsembleResults.Add(e);
}
private void LoadEnsembleResults(Workbook book, ResearchResult r)
{
EnsembleResult e = new EnsembleResult(r.Size);
//e.NetworkSize = r.Size;
e.EdgesCount = r.Edges;
e.Result = new Dictionary <AnalyzeOption, Object>();
Array existingOptions = Enum.GetValues(typeof(AnalyzeOption));
foreach (AnalyzeOption opt in existingOptions)
{
AnalyzeOptionInfo optInfo = (AnalyzeOptionInfo)(opt.GetType().GetField(opt.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false)[0]);
switch (optInfo.OptionType)
{
case OptionType.Global:
Double v = FindValueInGlobals(book, optInfo.FullName);
if (v != -1)
{
e.Result.Add(opt, v);
}
break;
case OptionType.ValueList:
Object vl = LoadValueList(book, optInfo);
if (vl != null)
{
e.Result.Add(opt, vl);
}
break;
case OptionType.Distribution:
case OptionType.Trajectory:
Object vd = LoadDistribution(book, optInfo);
if (vd != null)
{
e.Result.Add(opt, vd);
}
break;
default:
break;
}
}
r.EnsembleResults.Add(e);
}
private void LoadEnsembleResults(ResearchResult r)
{
while (reader.Read())
{
if (reader.Name == "Ensemble" && !reader.IsEmptyElement)
{
EnsembleResult e = new EnsembleResult(r.Size);
//e.NetworkSize = r.Size;
e.EdgesCount = r.Edges;
e.Result = new Dictionary <AnalyzeOption, Object>();
reader.Read();
while (reader.NodeType != XmlNodeType.EndElement)
{
AnalyzeOption opt = (AnalyzeOption)Enum.Parse(typeof(AnalyzeOption), reader.Name);
AnalyzeOptionInfo optInfo = (AnalyzeOptionInfo)(opt.GetType().GetField(opt.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false)[0]);
switch (optInfo.OptionType)
{
case OptionType.Global:
e.Result.Add(opt, reader.ReadElementContentAsDouble());
break;
case OptionType.ValueList:
case OptionType.Centrality:
e.Result.Add(opt, LoadValueList());
reader.Read();
break;
case OptionType.Distribution:
case OptionType.Trajectory:
e.Result.Add(opt, LoadDistribution());
reader.Read();
break;
default:
break;
}
}
r.EnsembleResults.Add(e);
}
}
}
private void SaveEnsembleResult(string researchName, EnsembleResult e, int id)
{
writer.WriteStartElement("Ensemble");
writer.WriteAttributeString("id", id.ToString());
foreach (AnalyzeOption opt in e.Result.Keys)
{
AnalyzeOptionInfo info = ((AnalyzeOptionInfo[])opt.GetType().GetField(opt.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false))[0];
OptionType optionType = info.OptionType;
switch (optionType)
{
case OptionType.Global:
writer.WriteElementString(opt.ToString(), e.Result[opt].ToString());
break;
case OptionType.ValueList:
case OptionType.Centrality:
writer.WriteStartElement(opt.ToString());
SaveValueList(e.Result[opt]);
writer.WriteEndElement();
break;
case OptionType.Distribution:
writer.WriteStartElement(opt.ToString());
SaveDistribution(info, e.Result[opt]);
writer.WriteEndElement();
break;
case OptionType.Trajectory:
writer.WriteStartElement(opt.ToString());
SaveTrajectoryAndFile(researchName, info, e.Result[opt]);
writer.WriteEndElement();
break;
default:
break;
}
}
writer.WriteEndElement();
}
/// <summary>
/// Calculates the average value of specified global analyze option.
/// </summary>
/// <param name="opt">Analyze option.</param>
public void CalculateGlobalOption(AnalyzeOption opt)
{
if (EnsembleResultsAvg.Count != 0 && EnsembleResultsAvg[0].Result.ContainsKey(opt))
{
return;
}
ResearchResult tr = null;
AnalyzeOptionInfo[] info = (AnalyzeOptionInfo[])opt.GetType().GetField(opt.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false);
Debug.Assert(info[0].OptionType == OptionType.Global);
double avg = 0;
foreach (Guid id in researches)
{
tr = StatSessionManager.GetResearchResult(id);
Debug.Assert(tr.EnsembleResults.Count == 1);
// TODO fix it
if (!tr.EnsembleResults[0].Result.ContainsKey(opt))
{
continue;
}
Debug.Assert(tr.EnsembleResults[0].Result[opt] != null);
avg += Convert.ToDouble(tr.EnsembleResults[0].Result[opt]) * tr.RealizationCount;
}
avg /= RealizationCountSum;
EnsembleResult er = null;
if (EnsembleResultsAvg.Count == 0)
{
er = new EnsembleResult(0);
EnsembleResultsAvg.Add(er);
}
else
{
er = EnsembleResultsAvg[0];
}
er.Result.Add(opt, Math.Round(avg, 4));
}
/// <summary>
/// Calculates the average distribution of specified distributed analyze option.
/// </summary>
/// <param name="opt">Analyze option.</param>
public void CalculateDistributedOption(AnalyzeOption opt)
{
if (EnsembleResultsAvg.Count != 0 && EnsembleResultsAvg[0].Result.ContainsKey(opt))
{
return;
}
AnalyzeOptionInfo[] info = (AnalyzeOptionInfo[])opt.GetType().GetField(opt.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false);
Debug.Assert(info[0].OptionType == OptionType.Distribution);
EnsembleResult er = null;
if (EnsembleResultsAvg.Count == 0)
{
er = new EnsembleResult(0);
EnsembleResultsAvg.Add(er);
}
else
{
er = EnsembleResultsAvg[0];
}
er.Result.Add(opt, CalculateDoubleAverage(opt));
}
