private SortedDictionary <Double, Double> CalculateDoubleAverage(AnalyzeOption opt)
{
SortedDictionary <Double, Double> temp = new SortedDictionary <Double, Double>();
ResearchResult tr = null;
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);
Debug.Assert(tr.EnsembleResults[0].Result[opt] is SortedDictionary <Double, Double>);
SortedDictionary <Double, Double> d = tr.EnsembleResults[0].Result[opt] as SortedDictionary <Double, Double>;
foreach (KeyValuePair <Double, Double> k in d)
{
double value = Math.Round(k.Value * tr.RealizationCount / RealizationCountSum, 4);
if (temp.ContainsKey(k.Key))
{
temp[k.Key] += value;
}
else
{
temp.Add(k.Key, value);
}
}
}
return(temp);
}
private void FillOptionsPanel(Panel p, OptionType ot)
{
p.Controls.Clear();
AnalyzeOption availableOptions = StatSessionManager.GetAvailableAnalyzeOptions(GetCurrentResearchType(),
GetCurrentModelType());
Array existingOptions = Enum.GetValues(typeof(AnalyzeOption));
int location = 0;
foreach (AnalyzeOption opt in existingOptions)
{
if ((availableOptions & opt) == opt && opt != AnalyzeOption.None)
{
if (!StatSessionManager.HasOptionType(opt, ot))
{
continue;
}
CheckBox cb = new CheckBox();
cb.Name = opt.ToString();
cb.Text = opt.ToString();
cb.AutoSize = true;
cb.Location = new Point(10, (location++) * 20 + 5);
cb.Checked = false;
p.Controls.Add(cb);
}
}
}
public static AbstractNetwork CreateNetworkByType(ModelType mt, String rName,
ResearchType rType, GenerationType gType,
Dictionary <ResearchParameter, object> rParams,
Dictionary <GenerationParameter, object> genParams,
AnalyzeOption AnalyzeOptions,
ContainerMode mode)
{
ModelTypeInfo[] info = (ModelTypeInfo[])mt.GetType().GetField(mt.ToString()).GetCustomAttributes(typeof(ModelTypeInfo), false);
Type t = Type.GetType(info[0].Implementation);
Type[] constructTypes = new Type[] {
typeof(String),
typeof(ResearchType),
typeof(GenerationType),
typeof(Dictionary <ResearchParameter, object>),
typeof(Dictionary <GenerationParameter, object>),
typeof(AnalyzeOption),
typeof(ContainerMode)
};
object[] invokeParams = new object[] {
rName,
rType,
gType,
rParams,
genParams,
AnalyzeOptions,
mode
};
return((AbstractNetwork)t.GetConstructor(constructTypes).Invoke(invokeParams));
}
// TODO check //
private void FillEigenDistanceDistributionResults(AnalyzeOption option, RealizationResult result)
{
Debug.Assert(option == AnalyzeOption.EigenDistanceDistribution);
Debug.Assert(result.Result[option] is SortedDictionary <Double, Double>);
SortedDictionary <Double, Double> d = result.Result[option] as SortedDictionary <Double, Double>;
if (!Result.ContainsKey(option))
{
Result.Add(option, new SortedDictionary <Double, Double>());
}
Debug.Assert(Result[option] is SortedDictionary <Double, Double>);
SortedDictionary <Double, Double> temp = Result[option] as SortedDictionary <Double, Double>;
foreach (KeyValuePair <double, double> k in d)
{
if (temp.ContainsKey(k.Key))
{
temp[k.Key] = CalculateNextAverageValue(temp[k.Key], k.Value);
}
else
{
temp.Add(k.Key, k.Value);
}
}
}
/// <summary>
/// Sets analyze options for specified research.
/// </summary>
/// <param name="id">ID of research.</param>
/// <param name="o">Analyze options to set (flag).</param>
/// <node>param o must be subset from available analyze options.</node>
public static void SetAnalyzeOptions(Guid id, AnalyzeOption o)
{
try
{
if (existingResearches[id].StatusInfo.Status == ResearchStatus.NotStarted)
{
AnalyzeOption opt = GetAvailableAnalyzeOptions(id);
if ((opt | o) != opt)
{
throw new CoreException("Specified option is not available for current research and model type.");
}
else
{
existingResearches[id].AnalyzeOption = o;
}
}
else
{
throw new CoreException("Unable to modify research after start.");
}
}
catch (KeyNotFoundException)
{
throw new CoreException("Specified research does not exists.");
}
}
private void InitializeAnalyzeOptionsGroup()
{
optionsPanel.Controls.Clear();
AnalyzeOption availableOptions = SessionManager.GetAvailableAnalyzeOptions(rType, GetCurrentModelType());
AnalyzeOption checkedOptions = AnalyzeOption.None;
if (dType != DialogType.Create)
{
checkedOptions = SessionManager.GetAnalyzeOptions(researchId);
}
Array existingOptions = Enum.GetValues(typeof(AnalyzeOption));
int location = 0;
foreach (AnalyzeOption opt in existingOptions)
{
if ((availableOptions & opt) == opt && opt != AnalyzeOption.None)
{
CheckBox cb = new CheckBox();
cb.Name = opt.ToString();
cb.Text = opt.ToString();
cb.AutoSize = true;
cb.Location = new Point(10, (location++) * 20 + 5);
cb.Checked = false;
optionsPanel.Controls.Add(cb);
if (dType != DialogType.Create && (checkedOptions & opt) == opt)
{
cb.Checked = true;
}
}
}
}
private bool SetAnalyzeOptionsValues()
{
AnalyzeOption opts = AnalyzeOption.None;
int numOfSelectedItems = 0;
foreach (Control c in AnalyzeOptionsStackPanel.Children)
{
Debug.Assert(c is CheckBox);
CheckBox cc = c as CheckBox;
// TODO maybe better content and text
AnalyzeOption current = (AnalyzeOption)Enum.Parse(typeof(AnalyzeOption), cc.Content.ToString());
if (cc.IsChecked.GetValueOrDefault())
{
opts |= current;
numOfSelectedItems++;
}
}
if ((researchType == ResearchType.Activation || researchType == ResearchType.Evolution) &&
numOfSelectedItems != 1)
{
MessageBox.Show("Exactly one item form Analyze Options must be selected.");
return(false);
}
LabSessionManager.SetAnalyzeOptions(opts);
return(true);
}
private bool Check(AnalyzeOption o, RealizationResult rn, ResearchResult rr)
{
Debug.Assert(rn.Result.ContainsKey(o));
Debug.Assert(rn.Result[o] != null);
Debug.Assert(rr.EnsembleResults.Count() > 0);
if (!rr.EnsembleResults[0].Result.ContainsKey(o))
return true;
Debug.Assert(rr.EnsembleResults[0].Result[o] != null);
AnalyzeOptionInfo[] info = (AnalyzeOptionInfo[])o.GetType().GetField(o.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false);
OptionType ot = info[0].OptionType;
switch (ot)
{
case OptionType.Global:
Double v1 = Convert.ToDouble(rn.Result[o]);
Double v2 = Convert.ToDouble(rr.EnsembleResults[0].Result[o]);
return Math.Round(v1, 4) == v2;
case OptionType.Distribution:
case OptionType.Trajectory:
Debug.Assert(rn.Result[o] is SortedDictionary<Double, Double>);
Debug.Assert(rr.EnsembleResults[0].Result[o] is SortedDictionary<Double, Double>);
SortedDictionary<Double, Double> d1 = rn.Result[o] as SortedDictionary<Double, Double>;
SortedDictionary<Double, Double> d2 = rr.EnsembleResults[0].Result[o] as SortedDictionary<Double, Double>;
return CheckDictionary(d1, d2);
default:
Debug.Assert(false);
break;
}
return true;
}
public GraphicsTab(AnalyzeOption o, SortedDictionary <Double, Double> v)
{
option = o;
values = v;
drawingOptions = new DrawingOption(Color.Black, false);
statisticsOptions = new StatisticsOption(ApproximationType.None, ThickeningType.None, 0);
InitializeComponent();
}
public BANetwork(String rName,
Dictionary<ResearchParameter, object> rParams,
Dictionary<GenerationParameter, object> genParams,
AnalyzeOption analyzeOpts)
: base(rName, rParams, genParams, analyzeOpts)
{
networkGenerator = new BANetworkGenerator();
networkAnalyzer = new NonHierarchicAnalyzer(this);
}
public GraphicsTab(AnalyzeOption o, SortedDictionary<Double, Double> v)
{
option = o;
values = v;
drawingOptions = new DrawingOption(Color.Black, false);
statisticsOptions = new StatisticsOption(ApproximationType.None, ThickeningType.None, 0);
InitializeComponent();
}
// TODO check //
private void FillDoubleResults(AnalyzeOption option, RealizationResult result)
{
if (!Result.ContainsKey(option))
{
Result.Add(option, 0.0);
}
Result[option] = CalculateNextAverageValue((Double)Result[option],
(Double)result.Result[option]);
}
private static void FillDoubleResults(AnalyzeOption option, List <RealizationResult> results, EnsembleResult r)
{
double temp = 0;
foreach (RealizationResult res in results)
{
temp += (double)(res.Result[option]) / results.Count;
}
r.Result.Add(option, double.IsNaN(temp) ? 0 : Math.Round(temp, 4));
}
public RegularHierarchicNetwork(String rName,
GenerationType gType,
Dictionary<ResearchParameter, object> rParams,
Dictionary<GenerationParameter, object> genParams,
AnalyzeOption analyzeOpts)
: base(rName, gType, rParams, genParams, analyzeOpts)
{
networkGenerator = new RegularHierarchicNetworkGenerator();
networkAnalyzer = new RegularHierarchicNetworkAnalyzer(this);
}
public NonRegularHierarchicNetwork(String rName,
ResearchType rType,
GenerationType gType,
Dictionary <ResearchParameter, object> rParams,
Dictionary <GenerationParameter, object> genParams,
AnalyzeOption analyzeOpts, ContainerMode mode) : base(rName, rType, gType, rParams, genParams, analyzeOpts, mode)
{
networkGenerator = new NonRegularHierarchicNetworkGenerator(mode);
networkAnalyzer = new NonRegularHierarchicNetworkAnalyzer(this);
}
public GraphicsTab(String rName, AnalyzeOption o, SortedDictionary <Double, Double> v)
{
researchName = rName;
option = o;
values = v;
drawingOptions = new DrawingOption(Color.Black, true);
statisticsOptions = new StatisticsOption(ApproximationType.None, ThickeningType.None, 0);
InitializeComponent();
InitializeChart();
}
public WSNetwork(String rName,
ResearchType rType,
GenerationType gType,
TracingType tType,
Dictionary <ResearchParameter, Object> rParams,
Dictionary <GenerationParameter, Object> genParams,
AnalyzeOption analyzeOpts) : base(rName, rType, gType, tType, rParams, genParams, analyzeOpts)
{
networkGenerator = new WSNetworkGenerator();
networkAnalyzer = new NonHierarchicAnalyzer(this);
}
public AbstractNetwork(String rName,
Dictionary<ResearchParameter, object> rParams,
Dictionary<GenerationParameter, object> genParams,
AnalyzeOption AnalyzeOptions)
{
ResearchName = rName;
ResearchParameterValues = rParams;
GenerationParameterValues = genParams;
this.AnalyzeOptions = AnalyzeOptions;
NetworkResult = new RealizationResult();
}
protected int GetAnalyzeOptionsCount()
{
int counter = 0;
Array existingOptions = Enum.GetValues(typeof(AnalyzeOption));
foreach (AnalyzeOption opt in existingOptions)
{
if (AnalyzeOption.HasFlag(opt) && opt != AnalyzeOption.None)
{
++counter;
}
}
return(counter);
}
private static void FillEigenValuesResults(AnalyzeOption option, List <RealizationResult> results, EnsembleResult r)
{
Debug.Assert(option == AnalyzeOption.EigenValues);
List <Double> temp = new List <Double>();
foreach (RealizationResult res in results)
{
Debug.Assert(res.Result[option] is List <Double>);
List <Double> e = res.Result[option] as List <Double>;
foreach (Double k in e)
{
temp.Add(k);
}
}
r.Result.Add(option, temp);
}
public AbstractNetwork(String rName, ResearchType rType,
GenerationType gType, TracingType tType,
Dictionary <ResearchParameter, Object> rParams,
Dictionary <GenerationParameter, Object> genParams,
AnalyzeOption AnalyzeOptions)
{
ResearchName = rName;
ResearchType = rType;
GenerationType = gType;
TracingType = tType;
ResearchParameterValues = rParams;
GenerationParameterValues = genParams;
this.AnalyzeOptions = AnalyzeOptions;
NetworkResult = new RealizationResult();
}
protected AbstractNetwork(String rName, ResearchType rType,
GenerationType gType,
Dictionary <ResearchParameter, object> rParams,
Dictionary <GenerationParameter, object> genParams,
AnalyzeOption AnalyzeOptions, ContainerMode mode)
{
this.containerMode = mode;
ResearchName = rName;
ResearchType = rType;
GenerationType = gType;
ResearchParameterValues = rParams;
GenerationParameterValues = genParams;
this.AnalyzeOptions = AnalyzeOptions;
NetworkResult = new RealizationResult();
}
public Object CalculateOption(AnalyzeOption option)
{
switch (option)
{
case AnalyzeOption.AvgClusteringCoefficient:
return CalculateAverageClusteringCoefficient();
case AnalyzeOption.AvgDegree:
return CalculateAverageDegree();
case AnalyzeOption.AvgPathLength:
return CalculateAveragePath();
case AnalyzeOption.ClusteringCoefficientDistribution:
return CalculateClusteringCoefficientDistribution();
case AnalyzeOption.ClusteringCoefficientPerVertex:
return CalculateClusteringCoefficientPerVertex();
case AnalyzeOption.CompleteComponentDistribution:
return CalculateCompleteComponentDistribution();
case AnalyzeOption.ConnectedComponentDistribution:
return CalculateConnectedComponentDistribution();
case AnalyzeOption.CycleDistribution:
// TODO
return CalculateCycleDistribution(1, 1);
case AnalyzeOption.Cycles3:
return CalculateCycles3();
case AnalyzeOption.Cycles3Eigen:
return CalculateCycles3Eigen();
case AnalyzeOption.Cycles3Trajectory:
return CalculateCycles3Trajectory();
case AnalyzeOption.Cycles4:
return CalculateCycles4();
case AnalyzeOption.Cycles4Eigen:
return CalculateCycles4Eigen();
case AnalyzeOption.DegreeDistribution:
return CalculateDegreeDistribution();
case AnalyzeOption.Diameter:
return CalculateDiameter();
case AnalyzeOption.DistanceDistribution:
return CalculateDistanceDistribution();
case AnalyzeOption.EigenDistanceDistribution:
return CalculateEigenDistanceDistribution();
case AnalyzeOption.EigenValues:
return CalculateEigenValues();
case AnalyzeOption.TriangleByVertexDistribution:
return CalculateTriangleByVertexDistribution();
default:
return null;
}
}
private List <AnalyzeOption> GetCheckedOptions(Panel p)
{
List <AnalyzeOption> o = new List <AnalyzeOption>();
foreach (Control c in p.Controls)
{
Debug.Assert(c is CheckBox);
CheckBox cc = c as CheckBox;
AnalyzeOption current = (AnalyzeOption)Enum.Parse(typeof(AnalyzeOption), cc.Name);
if (cc.Checked)
{
o.Add(current);
}
}
return(o);
}
// TODO check //
private void FillEigenValuesResults(AnalyzeOption option, RealizationResult result)
{
Debug.Assert(option == AnalyzeOption.EigenValues);
Debug.Assert(result.Result[option] is List <Double>);
List <Double> e = result.Result[option] as List <Double>;
if (!Result.ContainsKey(option))
{
Result.Add(option, new List <Double>());
}
Debug.Assert(result.Result[option] is List <Double>);
List <Double> temp = result.Result[option] as List <Double>;
foreach (Double k in e)
{
temp.Add(k);
}
}
private void InitializeAnalyzeOptionsGroup()
{
AnalyzeOptionsStackPanel.Children.Clear();
AnalyzeOption options = LabSessionManager.GetAvailableAnalyzeOptions(researchType, GetCurrentModelType());
for (int i = 0; i < Enum.GetNames(typeof(AnalyzeOption)).Length; ++i)
{
int k = (int)options & (1 << i);
if (k != 0)
{
CheckBox option = new CheckBox()
{
Content = ((AnalyzeOption)k).ToString()
};
AnalyzeOptionsStackPanel.Children.Add(option);
}
}
}
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 SetAnalyzeOptionsValues()
{
AnalyzeOption opts = SessionManager.GetAnalyzeOptions(ResultResearchId);
foreach (Control c in optionsPanel.Controls)
{
Debug.Assert(c is CheckBox);
CheckBox cc = c as CheckBox;
AnalyzeOption current = (AnalyzeOption)Enum.Parse(typeof(AnalyzeOption), cc.Name);
if (cc.Checked)
{
opts |= current;
}
else
{
opts &= ~current;
}
}
SessionManager.SetAnalyzeOptions(ResultResearchId, opts);
}
/// <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));
}
private void AddAnalizeOptionsList()
{
if (!LabSessionManager.IsResearchCreated())
{
return;
}
AnalyzeOptionsMenuItem.Items.Clear();
AnalyzeOption options = LabSessionManager.GetAvailableAnalyzeOptions(LabSessionManager.GetResearchType(), LabSessionManager.GetResearchModelType());
for (int i = 0; i < Enum.GetNames(typeof(AnalyzeOption)).Length; ++i)
{
int k = (int)options & (1 << i);
if (k != 0)
{
CheckBox option = new CheckBox()
{
Content = ((AnalyzeOption)k).ToString()
};
AnalyzeOptionsMenuItem.Items.Add(option);
}
}
}
private static void FillListResults(AnalyzeOption option, List <RealizationResult> results, EnsembleResult r)
{
List <Double> temp = new List <double>();
foreach (RealizationResult res in results)
{
Debug.Assert(res.Result[option] is List <Double>);
List <Double> l = res.Result[option] as List <Double>;
for (int j = 0; j < l.Count; ++j)
{
if (j < temp.Count())
{
temp[j] += l[j] / results.Count;
}
else
{
temp.Add(l[j] / results.Count);
}
}
}
r.Result.Add(option, temp);
}
private static void FillTrajectoryResults(AnalyzeOption option, List <RealizationResult> results, EnsembleResult r)
{
SortedDictionary <Double, Double> temp = new SortedDictionary <Double, Double>();
foreach (RealizationResult res in results)
{
Debug.Assert(res.Result[option] is SortedDictionary <Double, Double>);
SortedDictionary <Double, Double> d = res.Result[option] as SortedDictionary <Double, Double>;
foreach (KeyValuePair <double, double> k in d)
{
if (temp.ContainsKey(k.Key))
{
temp[k.Key] += k.Value / results.Count;
}
else
{
temp.Add(k.Key, k.Value / results.Count);
}
}
}
r.Result.Add(option, temp);
}
private void FillAnalyzeOptionsTable(Guid researchId)
{
analyzeOptionsTable.Rows.Clear();
AnalyzeOption availableOptions = SessionManager.GetAvailableAnalyzeOptions(researchId);
AnalyzeOption checkedOptions = SessionManager.GetAnalyzeOptions(researchId);
Array existingOptions = Enum.GetValues(typeof(AnalyzeOption));
foreach (AnalyzeOption opt in existingOptions)
{
if ((availableOptions & opt) == opt && opt != AnalyzeOption.None)
{
if ((checkedOptions & opt) == opt)
{
analyzeOptionsTable.Rows.Add(opt.ToString(), true);
}
else
{
analyzeOptionsTable.Rows.Add(opt.ToString(), false);
}
}
}
}
private bool Check(AnalyzeOption o, RealizationResult rn, ResearchResult rr)
{
Debug.Assert(rn.Result.ContainsKey(o));
Debug.Assert(rn.Result[o] != null);
Debug.Assert(rr.EnsembleResults.Count() > 0);
if (!rr.EnsembleResults[0].Result.ContainsKey(o))
{
return(true);
}
Debug.Assert(rr.EnsembleResults[0].Result[o] != null);
AnalyzeOptionInfo[] info = (AnalyzeOptionInfo[])o.GetType().GetField(o.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false);
OptionType ot = info[0].OptionType;
switch (ot)
{
case OptionType.Global:
Double v1 = Convert.ToDouble(rn.Result[o]);
Double v2 = Convert.ToDouble(rr.EnsembleResults[0].Result[o]);
return(Math.Round(v1, 4) == v2);
case OptionType.Distribution:
case OptionType.Trajectory:
Debug.Assert(rn.Result[o] is SortedDictionary <Double, Double>);
Debug.Assert(rr.EnsembleResults[0].Result[o] is SortedDictionary <Double, Double>);
SortedDictionary <Double, Double> d1 = rn.Result[o] as SortedDictionary <Double, Double>;
SortedDictionary <Double, Double> d2 = rr.EnsembleResults[0].Result[o] as SortedDictionary <Double, Double>;
return(CheckDictionary(d1, d2));
default:
Debug.Assert(false);
break;
}
return(true);
}
// TODO check //
private void FillListResults(AnalyzeOption option, RealizationResult result)
{
if (!Result.ContainsKey(option))
{
Result.Add(option, new List <Double>());
}
Debug.Assert(Result[option] is List <Double>);
List <Double> temp = Result[option] as List <Double>;
Debug.Assert(result.Result[option] is List <Double>);
List <Double> l = result.Result[option] as List <Double>;
for (int j = 0; j < l.Count; ++j)
{
if (j < temp.Count())
{
temp[j] = CalculateNextAverageValue(temp[j], l[j]);
}
else
{
temp.Add(l[j]);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="eIndex"></param>
/// <param name="opt"></param>
/// <param name="sopt"></param>
/// <returns></returns>
public object ApplyStatisticsOtion(int eIndex, AnalyzeOption opt, StatisticsOption sopt)
{
return null;
}
private static void FillListResults(AnalyzeOption option, List<RealizationResult> results, EnsembleResult r)
{
List<Double> temp = new List<double>();
foreach (RealizationResult res in results)
{
Debug.Assert(res.Result[option] is List<Double>);
List<Double> l = res.Result[option] as List<Double>;
for (int j = 0; j < l.Count; ++j)
{
if (j < temp.Count())
temp[j] += l[j] / results.Count;
else
temp.Add(l[j] / results.Count);
}
}
r.Result.Add(option, temp);
}
private static void FillEigenValuesResults(AnalyzeOption option, List<RealizationResult> results, EnsembleResult r)
{
Debug.Assert(option == AnalyzeOption.EigenValues);
List<Double> temp = new List<Double>();
foreach (RealizationResult res in results)
{
Debug.Assert(res.Result[option] is List<Double>);
List<Double> e = res.Result[option] as List<Double>;
foreach (Double k in e)
temp.Add(k);
}
r.Result.Add(option, temp);
}
private static void FillEigenDistanceDistributionResults(AnalyzeOption option, List<RealizationResult> results, EnsembleResult r)
{
Debug.Assert(option == AnalyzeOption.EigenDistanceDistribution);
SortedDictionary<Double, Double> temp = new SortedDictionary<Double, Double>();
foreach (RealizationResult res in results)
{
Debug.Assert(res.Result[option] is SortedDictionary<Double, Double>);
SortedDictionary<Double, Double> d = res.Result[option] as SortedDictionary<Double, Double>;
foreach (double k in d.Keys)
{
if (temp.ContainsKey(k))
temp[k] += d[k];
else
temp.Add(k, d[k]);
}
}
r.Result.Add(option, temp);
}
private static void FillDictionaryResults(AnalyzeOption option, List<RealizationResult> results, EnsembleResult r)
{
SortedDictionary<Double, Double> temp = new SortedDictionary<Double, Double>();
foreach (RealizationResult res in results)
{
Debug.Assert(res.Result[option] is SortedDictionary<Double, Double>);
SortedDictionary<Double, Double> d = res.Result[option] as SortedDictionary<Double, Double>;
foreach (double k in d.Keys)
{
if (temp.ContainsKey(k))
temp[k] += Math.Round(d[k] / results.Count, 4);
else
temp.Add(k, Math.Round(d[k] / results.Count, 4));
}
}
r.Result.Add(option, temp);
}
/// <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);
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();
EnsembleResultsAvg.Add(er);
}
else
er = EnsembleResultsAvg[0];
er.Result.Add(opt, Math.Round(avg, 4));
}
public AvailableAnalyzeOption(AnalyzeOption options)
{
Options = options;
}
/// <summary>
/// Checks if specified option has specified option type/
/// </summary>
/// <param name="opt">Analyze option.</param>
/// <param name="ot">Analyze option type.</param>
/// <returns></returns>
public static bool HasOptionType(AnalyzeOption opt, OptionType ot)
{
AnalyzeOptionInfo[] info = (AnalyzeOptionInfo[])opt.GetType().GetField(opt.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false);
return (info[0].OptionType == ot);
}
private SortedDictionary<Double, Double> CalculateDoubleAverage(AnalyzeOption opt)
{
SortedDictionary<Double, Double> temp = new SortedDictionary<Double, Double>();
ResearchResult tr = null;
foreach (Guid id in researches)
{
tr = StatSessionManager.GetResearchResult(id);
Debug.Assert(tr.EnsembleResults.Count == 1);
Debug.Assert(tr.EnsembleResults[0].Result[opt] != null);
Debug.Assert(tr.EnsembleResults[0].Result[opt] is SortedDictionary<Double, Double>);
SortedDictionary<Double, Double> d = tr.EnsembleResults[0].Result[opt] as SortedDictionary<Double, Double>;
foreach (Double k in d.Keys)
{
double value = Math.Round(d[k] * tr.RealizationCount / RealizationCountSum, 4);
if (temp.ContainsKey(k))
temp[k] += value;
else
temp.Add(k, value);
}
}
return temp;
}
public static AbstractNetwork CreateNetworkByType(ModelType mt, String rName,
GenerationType gType,
Dictionary<ResearchParameter, object> rParams,
Dictionary<GenerationParameter, object> genParams,
AnalyzeOption AnalyzeOptions)
{
ModelTypeInfo[] info = (ModelTypeInfo[])mt.GetType().GetField(mt.ToString()).GetCustomAttributes(typeof(ModelTypeInfo), false);
Type t = Type.GetType(info[0].Implementation);
Type[] constructTypes = new Type[] {
typeof(String),
typeof(GenerationType),
typeof(Dictionary<ResearchParameter, object>),
typeof(Dictionary<GenerationParameter, object>),
typeof(AnalyzeOption) };
object[] invokeParams = new object[] {
rName,
gType,
rParams,
genParams,
AnalyzeOptions };
return (AbstractNetwork)t.GetConstructor(constructTypes).Invoke(invokeParams);
}
private static void FillDoubleResults(AnalyzeOption option, List<RealizationResult> results, EnsembleResult r)
{
double temp = 0;
foreach (RealizationResult res in results)
{
temp += (double)(res.Result[option]) / results.Count;
}
r.Result.Add(option, double.IsNaN(temp) ? 0 : Math.Round(temp, 4));
}
/// <summary>
/// Sets analyze options for specified research.
/// </summary>
/// <param name="id">ID of research.</param>
/// <param name="o">Analyze options to set (flag).</param>
/// <node>param o must be subset from available analyze options.</node>
public static void SetAnalyzeOptions(Guid id, AnalyzeOption o)
{
try
{
if (existingResearches[id].Status == ResearchStatus.NotStarted)
{
AnalyzeOption opt = GetAvailableAnalyzeOptions(id);
if ((opt | o) != opt)
throw new CoreException("Specified option is not available for current research and model type.");
else
existingResearches[id].AnalyzeOption = o;
}
else
throw new CoreException("Unable to modify research after start.");
}
catch (KeyNotFoundException)
{
throw new CoreException("Specified research does not exists.");
}
}
/// <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();
EnsembleResultsAvg.Add(er);
}
else
er = EnsembleResultsAvg[0];
er.Result.Add(opt, CalculateDoubleAverage(opt));
}
