public static void AppendDefaulTrajectory(string onetrajectory_filename, string reduced_filename, int index_increment) { ScenarioTree onetrajectory_st = ScenarioTree.AMPL_Import(onetrajectory_filename); ScenarioTree reduced = ScenarioTree.AMPL_Import(onetrajectory_filename); AppendDefaulTrajectory(onetrajectory_st, reduced, reduced_filename, index_increment); }
public static ScenarioTree AMPL_Import(string file_name) { ScenarioTree St = new ScenarioTree(); StreamReader freader = File.OpenText(file_name); string first_line = freader.ReadLine(); do { string line = freader.ReadLine(); string[] parts = line.Split('\t'); if (parts[parts.Length - 1] == string.Empty) { parts = Reshape(parts, 0, parts.Length - 1); } if (parts.Length > 6) { TreeNode Tn = new TreeNode(); Tn.Id = int.Parse(parts[0]); Tn.Probability = double.Parse(parts[1]); Tn.Period = int.Parse(parts[2]); if (parts[3] != string.Empty) { Tn.PredecessorId = int.Parse(parts[3]); } else { Tn.PredecessorId = -1; } Tn.Value = new float[parts.Length - 4]; for (int c = 0; c < parts.Length - 4; c++) { Tn.Value[c] = float.Parse(parts[4 + c]); } St.Add(Tn); } }while (!freader.EndOfStream); St.ConvertPredecessorIdsToReferences(); // Create a deltaT vector. St.deltaT = new double[St.T]; for (int i = 0; i < St.deltaT.Length; i++) { St.deltaT[i] = 1; } freader.Close(); return(St); }
public ScenarioTree Clone() { ScenarioTree cloned = new ScenarioTree(); for (int z = 0; z < Count; z++) { cloned.Add(this[z]); if (this[z].Predecessor != null) { cloned[z].Predecessor = cloned[this.FindPredecessorIndex(z)]; } } cloned.deltaT = (double[])deltaT.Clone(); return(cloned); }
/// <summary> /// Builds a new scenario tree by merging two scenarios. /// </summary> /// <param name="St1"></param> /// <param name="St2"></param> /// <returns></returns> public static ScenarioTree Merge(ScenarioTree St1, ScenarioTree St2) { ScenarioTree St = new ScenarioTree(); St.deltaT = St1.deltaT; //get the maximum period index... int T = St1.T; for (int t = 0; t <= T; t++) { if (t == 0) { TreeNode root1 = St1.Root; TreeNode root2 = St2.Root; TreeNode root = new TreeNode(t, null, 1.0); MergeValues(root1, root2, ref root); root.ComesFrom(root1, root2); St.Add(root); } else { List <TreeNode> L1 = St1.NodesAt(t); List <TreeNode> L2 = St2.NodesAt(t); List <TreeNode> Previous = St.NodesAt(t - 1); foreach (TreeNode n1 in L1) { foreach (TreeNode n2 in L2) { TreeNode n = new TreeNode(); n.Period = t; n.Probability = n1.Probability * n2.Probability; MergeValues(n1, n2, ref n); n.Predecessor = ScenarioTree.ComeFromListSearch(Previous, n1.Predecessor, n2.Predecessor); St.Add(n); n.ComesFrom(n1, n2); } } } } return(St); }
//old generation routine static ScenarioTree GenerateOld() { int p_Periods = 11; ScenarioTree XST = new XTree(1); XST.Generate(); ScenarioTree WST = new WTree(p_Periods); WST.Generate(); ScenarioTree ST = ScenarioTree.Merge(XST, WST); return(ST); }
//index_increment when in memory indices start from 0 so must be incremented public static void AppendDefaulTrajectory(ScenarioTree onetrajectory_scenario_tree, ScenarioTree reduced, string reduced_filename, int index_increment) { // Now find the nodes belonging to the first in the second. int T = onetrajectory_scenario_tree.Count; int[] default_trajectory = new int[T]; for (int i = 0; i < T; i++) { bool found = false; TreeNode N_i = onetrajectory_scenario_tree[i]; for (int j = 0; j < reduced.Count; j++) { TreeNode N_j = reduced[j]; if (N_i.Period == N_j.Period) { if (N_j.HaveEqualValues(N_j)) { // The two nodes reference the same realization of the underlying. default_trajectory[i] = N_j.Id; found = true; break; } } } if (!found) { Console.WriteLine("Cannot match node"); return; } } // Now write in the output the information about the default trajectory. StreamWriter sw = File.AppendText(reduced_filename); sw.WriteLine("param DefaultTrj:="); for (int i = 0; i < T; i++) { int period = onetrajectory_scenario_tree[i].Period + index_increment; sw.WriteLine(period.ToString() + "\t" + default_trajectory[i].ToString()); } sw.WriteLine(";"); sw.Close(); }
public ScenarioReduction(ScenarioTree scenarioTree) { this.inputScenarioTree = scenarioTree; this.deltaT = scenarioTree.deltaT; this.trajectories = (float[][][])scenarioTree.Scenarios; this.p = (double[])scenarioTree.ScenariosProbabilities.Clone(); // Standardize the scenario variables. Standardize(VarianceStandardizationType); this.nodesTrajectories = scenarioTree.ScenariosNodes; this.distanceWithw0 = new double[this.nodesTrajectories.Length]; for (int z = 0; z < this.distanceWithw0.Length; z++) { this.distanceWithw0[z] = -1; } }
static void Main(string[] args) { System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.Lowest; DateTime t0 = DateTime.Now; string mode = "A";// only AMPL if (args.Length < 2) { Console.WriteLine("ScenarioReduction V1.2.2\n"); Console.WriteLine("Usage: ScenarioReduction infilename action [out_scenarios] [outputmode default=A] [Options]"); Console.WriteLine("action can be: rnd:reduce or N: no operation (displays in output the original scenario) "); Console.WriteLine("output mode: C complete (descriptive statistics), A only AMPL output"); Console.WriteLine("options can be:"); Console.WriteLine("[Sn] standardize n=0,1 (use time specific std),2 (use avg std)"); Console.WriteLine("[Mn] metric n=0: L2 ,n=1: fortet mourer (L2)"); Console.WriteLine("Args count=", args.Length.ToString()); return; } string infilename = args[0]; string action = args[1].ToUpper(); int out_scenenarios = -1; int optional_param_count = 0; if (action == "rnd") { out_scenenarios = int.Parse(args[2]); optional_param_count++; } if (args.Length > 2 + optional_param_count) { mode = args[2 + optional_param_count].ToUpper(); } if (2 + optional_param_count < args.Length - 1) { Console.WriteLine("Options:"); do { optional_param_count++; string op = args[2 + optional_param_count]; int val = int.Parse(op.Substring(1)); switch (op[0]) { case 'S': //standardize ScenarioReduction.VarianceStandardizationType = val; if (mode == "C") { Console.WriteLine("Standardize=" + val); } break; case 'M': // metric ScenarioReduction.DistanceType = val; if (mode == "C") { Console.WriteLine("Metric =" + val); } break; } }while (2 + optional_param_count < args.Length - 1); } ScenarioReduction SRA = null; ScenarioTree ST = ScenarioTree.FromFile(infilename); if (mode == "C") { Console.WriteLine("Original Tree Descriptive Statistics:"); ST.DescriptiveStatistics(Console.Out); } ScenarioTree reduced_tree = null; if (action == "rnd") { SRA = new BackwardReduction(ST); SRA.Reduce(out_scenenarios); reduced_tree = SRA.ReducedScenarioTree; } else { reduced_tree = ST; } if (mode == "C") { Console.WriteLine("Reduced Tree descriptive Statistics:"); reduced_tree.DescriptiveStatistics(Console.Out); Console.WriteLine("Reduced Tree:"); Console.WriteLine(reduced_tree.ToString()); } Console.Write(reduced_tree.AMPL_Export("", "N_", null)); DateTime t1 = DateTime.Now; }
/// <summary> /// Read a text file with the following structure /// /// Node: /// Id:= x1 /// p := x1 /// t := x1 /// v := x1 x2 xn /// ParentId := c1 /// </summary> /// <param name="file"></param> /// <returns></returns> public static ScenarioTree FromFile(string file) { StreamReader sr = File.OpenText(file); string line; ScenarioTree tree = new ScenarioTree(); TreeNode tn = null; do { line = sr.ReadLine(); if (line.Contains("Node:")) { // Add the previous. if (tn != null) { tree.Add(tn); } tn = new TreeNode(); } else if (line.Contains("ParentId")) { line = CutIdentifier(line); int predessor_id = int.Parse(line); if (predessor_id > 0) { tn.Predecessor = tree[predessor_id - 1]; } } else if (line.Contains("Id")) { line = CutIdentifier(line); tn.Id = int.Parse(line); } else if (line.Contains("p")) { line = CutIdentifier(line); tn.Probability = double.Parse(line); } else if (line.Contains("t")) { line = CutIdentifier(line); tn.Period = int.Parse(line); } else if (line.Contains("v")) { line = CutIdentifier(line); string[] values = line.Split('\t'); tn.Value = new float[values.Length - 1]; for (int i = 0; i < values.Length - 1; i++) { tn.Value[i] = float.Parse(values[i]); } } }while (!sr.EndOfStream); // Aadd the last one. if (tn != null) { tree.Add(tn); } int min_period = 1; // Check for the format of periods. for (int z = 0; z < tree.Count; z++) { if (tree[z].Period < min_period) { min_period = tree[z].Period; } } if (min_period == 1) { tree.OneBasedPeriods = 1; for (int z = 0; z < tree.Count; z++) { tree[z].Period--; } } else { tree.OneBasedPeriods = 0; } int Periods = tree.T + 1; tree.deltaT = new double[Periods]; for (int t = 0; t < Periods; t++) { tree.deltaT[t] = 1; } return(tree); }
/// <summary> /// Return a scenario tree formed by only the component selected... /// </summary> /// <param name="d"></param> /// <returns></returns> public ScenarioTree GetComponent(int d) { ScenarioTree ST = new ScenarioTree(); return(null); }
public void Export(ScenarioTree tree) { // Number of scenarios. int L = tree.Leafs.Count; // Number of stages. int S = 1 + tree.T; // Prints a string like: stage: [1 2 2 3 3 3 3 4 4 4 4 4 4 4 4]. Console.Write("stage: ["); for (int n = 0; n < tree.Count; n++) { Console.Write(tree[n].Period + 1 + "\t"); } Console.WriteLine("]"); // Number of stages. Console.WriteLine("numTime: " + S); // Number of scenarios. Console.WriteLine("numScenario: " + tree.Leafs.Count); Console.WriteLine("numNode: " + tree.Count); int idx = -1; for (int z = 0; z < tree.Count; z++) { // Periods starts form zero. if (tree[z].Period == S - 2) { idx = z; } } // Index of last node of the second last stage. Console.WriteLine("secondlaststagenode: " + (idx + 1)); // Checks if it's correct! if (tree[idx + 1].Period != S - 1) { throw new Exception("Failed to calculate secondlaststagenode"); } // Scenario node variable. TreeNode[][] sn = tree.ScenariosNodes; Console.Write("ScenarioNode: ["); for (int l = 0; l < L; l++) { for (int s = 0; s < S; s++) { Console.Write(sn[l][s].Id + "\t"); } if (l < L - 1) { Console.WriteLine(); } else { Console.WriteLine("]"); } } // *************************** // Generate Probability: stages by row // Probability: [1 0.5 0.5]. Console.Write("Probability: ["); for (int s = 0; s < S; s++) { List <TreeNode> nodes = tree.NodesAt(s); foreach (TreeNode n in nodes) { Console.Write(n.Probability + "\t"); } if (s < S - 1) { Console.WriteLine(); } else { Console.WriteLine("]"); } } // Descendant...Matrix // for every node (rows) it calculates the start and the end of the // descendant nodes for every subsequent period. Console.WriteLine("successor: ["); for (int n = 0; n < tree.Count; n++) { if (tree[n].Period < S - 1) { for (int s = 1; s < S; s++) { List <TreeNode> successors = tree.GetSuccessors(tree[n], s); if (successors.Count > 0) { Console.Write(successors[0].Id + "\t" + successors[successors.Count - 1].Id + "\t"); } else { Console.Write("0\t0\t"); } } Console.WriteLine(); } } Console.WriteLine("]"); // Merge component names that contain _P _B in the name. List <int[]> indices = new List <int[]>(); // Already taken. bool[] taken = new bool[tree.componentNames.Count]; // Iterate for every component. for (int d = 0; d < tree.componentNames.Count; d++) { if (!taken[d]) { List <int> sub = new List <int>(); sub.Add(d); taken[d] = true; if (tree.componentNames[d].Contains("_B")) { string name = tree.componentNames[d].Replace("_B", "_P"); for (int d1 = d + 1; d1 < tree.componentNames.Count; d1++) { if (name.Equals(tree.componentNames[d1], StringComparison.InvariantCultureIgnoreCase)) { sub.Add(d1); taken[d1] = true; break; } } } indices.Add(sub.ToArray()); } } // Value Variables. for (int z = 0; z < indices.Count; z++) { int[] sub = indices[z]; int d = sub[0]; string name = "Component" + (z + 1); if (tree.componentNames != null) { if (d < tree.componentNames.Count) { name = tree.componentNames[d]; if (sub.Length > 1) { name = name.Replace("_B", string.Empty); } } } Console.Write(name + ": ["); for (int s = 0; s < S; s++) { List <TreeNode> nodes = tree.NodesAt(s); foreach (TreeNode n in nodes) { for (int z1 = 0; z1 < sub.Length; z1++) { Console.Write(n.Value[sub[z1]] + "\t"); } } if (s < S - 1) { Console.WriteLine(); } else { Console.WriteLine("]"); } } } return; }
public int DecoratedPeriod(ScenarioTree tree) { return(this.Period + tree.OneBasedPeriods); }
public BackwardReduction(ScenarioTree p_st) : base(p_st) { LogReset(); }
public SimultaneousBackwardReduction(ScenarioTree scenarioTree) : base(scenarioTree) { }