Beispiel #1
0
        void ReadParameter(OleDbConnection connect, GAMSDatabase db, string strAccessSelect, string parName, int parDim, string parExp = "")
        {
            try
            {
                OleDbCommand cmd = new OleDbCommand(strAccessSelect, connect);
                connect.Open();

                OleDbDataReader reader = cmd.ExecuteReader();

                if (reader.FieldCount != parDim + 1)
                {
                    lsLog.Add("Number of fields in select statement does not match parDim+1");
                }

                GAMSParameter a = db.AddParameter(parName, parDim, parExp);

                string[] keys = new string[parDim];
                while (reader.Read())
                {
                    for (int idx = 0; idx < parDim; idx++)
                    {
                        keys[idx] = reader.GetString(idx);
                    }
                    a.AddRecord(keys).Value = Convert.ToDouble(reader.GetValue(parDim));
                }
            }
            catch (Exception ex)
            {
                lsLog.Add("Error: Failed to retrieve the required data from the database. " + ex.Message);
            }
            finally
            {
                connect.Close();
            }
        }
Beispiel #2
0
        private void GetPreviewColumnsData(out string[,] returnTable, GAMSParameter parameter, int NumberOfRows = int.MaxValue)
        {
            int CommentAsNewColumn = 0;

            if (!string.IsNullOrEmpty(parameter.Text) && parameter.Dim == 0)
            {
                CommentAsNewColumn++;
            }

            returnTable = new string[Math.Min(parameter.NumberRecords, NumberOfRows), parameter.Dim + 2 + CommentAsNewColumn];
            int j;
            int i = 0;

            foreach (GAMSParameterRecord parameterRecord in parameter)
            {
                j = 0;
                foreach (var key in parameterRecord.Keys)
                {
                    returnTable[i, j++] = key;
                }
                returnTable[i, j++] = NumericValueToStr(parameterRecord.Value, true, false); // Value
                returnTable[i, j++] = NumericValueToStr(parameterRecord.Value, false, true); // Special value

                if (!string.IsNullOrEmpty(parameter.Text) && parameter.Dim == 0)
                {
                    returnTable[i, j++] = parameter.Text;
                }
                i++;
                if (i >= NumberOfRows)
                {
                    break;
                }
            }
        }
Beispiel #3
0
        /// <summary>
        /// Runs the specified list data.
        /// </summary>
        /// <param name="listData">The list data.</param>
        /// <returns>List&lt;System.String&gt;[].</returns>
        public List <string>[] Run(List <string>[] listData)
        {
            int sheetNumber = 4;

            string[] setsTemplate = new string[2] {
                "i", "j"
            };
            string[] setsName = new string[2] {
                "所有维修员元素点", "所有任务元素点"
            };
            string[] parametersTemplate = new string[4] {
                "PL", "TL", "Tij", "Tjj"
            };
            string[] parametersName = new string[4] {
                "PLi", "TLj", "Tij", "Tjj"
            };

            GAMSWorkspace ws;

            //if (Environment.GetCommandLineArgs().Length > 1)
            //    ws = new GAMSWorkspace(systemDirectory: Environment.GetCommandLineArgs()[1]);
            //else
            ws = new GAMSWorkspace(workspacePath, null, DebugLevel.Off);
            GAMSDatabase db = ws.AddDatabase();

            GAMSSet[]       gSet = new GAMSSet[sheetNumber];
            GAMSParameter[] gPar = new GAMSParameter[sheetNumber];

            for (int i = 0; i < 2; i++) //前两个表设置
            {
                gSet[i] = db.AddSet(setsTemplate[i], 1, setsName[i]);
                gPar[i] = db.AddParameter(parametersTemplate[i], 1, parametersName[i]);
                for (int j = 0; j < listData[2 * i].Count; j++)
                {
                    gSet[i].AddRecord(listData[2 * i][j]);
                    gPar[i].AddRecord(listData[2 * i][j]).Value = Convert.ToDouble(listData[2 * i + 1][j]);
                }
            }
            for (int i = 2; i < 4; i++)
            {
                gPar[i] = db.AddParameter(parametersTemplate[i], 2, parametersName[i]);
                for (int j = 0; j < listData[3 * i - 2].Count; j++)
                {
                    gPar[i].AddRecord(listData[3 * i - 2][j], listData[3 * i - 1][j]).Value = Convert.ToDouble(listData[3 * i][j]);
                }
            }

            GAMSJob t = ws.AddJobFromString(GetModelText());

            using (GAMSOptions opt = ws.AddOptions())
            {
                opt.Defines.Add("gdxincname", db.Name);
                opt.AllModelTypes = "xpress";
                t.Run(opt, db);
            }
            List <string>[] resultData = GetResultData(t);

            return(resultData);
        }
Beispiel #4
0
        private Arc[] GetArcs(GAMSDatabase gdxFile, Node[] nodes)
        {
            Random rand = new Random(); //for debug run

            GAMSParameter par = gdxFile.GetParameter(_str.FzMatrix);

            Arc[] arcs    = new Arc[par.NumberRecords];
            int   c       = 0;
            var   nLookup = nodes.ToDictionary(n => n.Label);

            foreach (GAMSParameterRecord rec in par)
            {
                var n1 = nLookup[rec.Keys[0]];
                var n2 = nLookup[rec.Keys[1]];
                var v  = rec.Value;
                //debug run with random dual
                Arc a = new Arc(c, n1, n2, v, v - rand.Next(0, 100), new double[] { v });
                arcs[c] = a;
                c++;
            }
            return(arcs);
        }
Beispiel #5
0
        private static void ScenSolve(GAMSWorkspace ws, GAMSCheckpoint cp, Queue <double> bmultQueue, Object queueMutex, Object ioMutex)
        {
            GAMSModelInstance mi = cp.AddModelInstance();

            GAMSParameter bmult = mi.SyncDB.AddParameter("bmult", 0, "demand multiplier");
            GAMSOptions   opt   = ws.AddOptions();

            opt.AllModelTypes = "cplexd";
            // instantiate the GAMSModelInstance and pass a model definition and GAMSModifier to declare bmult mutable
            mi.Instantiate("transport us lp min z", opt, new GAMSModifier(bmult));

            bmult.AddRecord().Value = 1.0;

            while (true)
            {
                double b;
                // dynamically get a bmult value from the queue instead of passing it to the different threads at creation time
                lock (queueMutex)
                {
                    if (0 == bmultQueue.Count)
                    {
                        return;
                    }
                    b = bmultQueue.Dequeue();
                }
                bmult.FirstRecord().Value = b;
                mi.Solve();
                // we need to make the ouput a critical section to avoid messed up report informations
                lock (ioMutex)
                {
                    Console.WriteLine("Scenario bmult=" + b + ":");
                    Console.WriteLine("  Modelstatus: " + mi.ModelStatus);
                    Console.WriteLine("  Solvestatus: " + mi.SolveStatus);
                    Console.WriteLine("  Obj: " + mi.SyncDB.GetVariable("z").FindRecord().Level);
                }
            }
        }
Beispiel #6
0
        static void Main(string[] args)
        {
            GAMSWorkspace ws;

            if (Environment.GetCommandLineArgs().Length > 1)
            {
                ws = new GAMSWorkspace(systemDirectory: Environment.GetCommandLineArgs()[1]);
            }
            else
            {
                ws = new GAMSWorkspace();
            }
            GAMSJob data = ws.AddJobFromString(GetDataText());

            GAMSOptions optData = ws.AddOptions();

            optData.Defines.Add("useBig", "1");
            optData.Defines.Add("nrScen", "100");

            data.Run(optData);

            optData.Dispose();
            GAMSParameter scenarioData = data.OutDB.GetParameter("ScenarioData");

            GAMSOptions opt = ws.AddOptions();

            opt.Defines.Add("datain", data.OutDB.Name);
            int maxiter = 40;

            opt.Defines.Add("maxiter", maxiter.ToString());
            opt.AllModelTypes = "cplexd";

            GAMSCheckpoint cpMaster = ws.AddCheckpoint();
            GAMSCheckpoint cpSub    = ws.AddCheckpoint();

            ws.AddJobFromString(GetMasterText()).Run(opt, cpMaster, data.OutDB);

            GAMSModelInstance masteri  = cpMaster.AddModelInstance();
            GAMSParameter     cutconst = masteri.SyncDB.AddParameter("cutconst", 1, "Benders optimality cut constant");
            GAMSParameter     cutcoeff = masteri.SyncDB.AddParameter("cutcoeff", 2, "Benders optimality coefficients");
            GAMSVariable      theta    = masteri.SyncDB.AddVariable("theta", 0, VarType.Free, "Future profit function variable");
            GAMSParameter     thetaFix = masteri.SyncDB.AddParameter("thetaFix", 0, "");

            masteri.Instantiate("masterproblem max zmaster using lp", opt, new GAMSModifier(cutconst), new GAMSModifier(cutcoeff), new GAMSModifier(theta, UpdateAction.Fixed, thetaFix));

            ws.AddJobFromString(GetSubText()).Run(opt, cpSub, data.OutDB);

            GAMSModelInstance subi     = cpSub.AddModelInstance();
            GAMSParameter     received = subi.SyncDB.AddParameter("received", 1, "units received from master");
            GAMSParameter     demand   = subi.SyncDB.AddParameter("demand", 1, "stochastic demand");

            subi.Instantiate("subproblem max zsub using lp", opt, new GAMSModifier(received), new GAMSModifier(demand));

            opt.Dispose();

            double lowerbound = double.NegativeInfinity, upperbound = double.PositiveInfinity, objmaster = double.PositiveInfinity;
            int    iter = 1;

            do
            {
                Console.WriteLine("Iteration: " + iter);
                // Solve master
                if (1 == iter) // fix theta for first iteration
                {
                    thetaFix.AddRecord().Value = 0;
                }
                else
                {
                    thetaFix.Clear();
                }

                masteri.Solve(GAMSModelInstance.SymbolUpdateType.BaseCase);
                Console.WriteLine(" Master " + masteri.ModelStatus + " : obj=" + masteri.SyncDB.GetVariable("zmaster").FirstRecord().Level);
                if (1 < iter)
                {
                    upperbound = masteri.SyncDB.GetVariable("zmaster").FirstRecord().Level;
                }
                objmaster = masteri.SyncDB.GetVariable("zmaster").FirstRecord().Level - theta.FirstRecord().Level;

                // Set received from master
                received.Clear();
                foreach (GAMSVariableRecord r in masteri.SyncDB.GetVariable("received"))
                {
                    received.AddRecord(r.Keys).Value = r.Level;
                    cutcoeff.AddRecord(iter.ToString(), r.Keys[0]);
                }

                cutconst.AddRecord(iter.ToString());
                double objsub = 0.0;
                foreach (GAMSSetRecord s in data.OutDB.GetSet("s"))
                {
                    demand.Clear();
                    foreach (GAMSSetRecord j in data.OutDB.GetSet("j"))
                    {
                        demand.AddRecord(j.Keys).Value = scenarioData.FindRecord(s.Keys[0], j.Keys[0]).Value;
                    }

                    subi.Solve(GAMSModelInstance.SymbolUpdateType.BaseCase);
                    Console.WriteLine(" Sub " + subi.ModelStatus + " : obj=" + subi.SyncDB.GetVariable("zsub").FirstRecord().Level);


                    double probability = scenarioData.FindRecord(s.Keys[0], "prob").Value;
                    objsub += probability * subi.SyncDB.GetVariable("zsub").FirstRecord().Level;
                    foreach (GAMSSetRecord j in data.OutDB.GetSet("j"))
                    {
                        cutconst.FindRecord(iter.ToString()).Value            += probability * subi.SyncDB.GetEquation("market").FindRecord(j.Keys).Marginal *demand.FindRecord(j.Keys).Value;
                        cutcoeff.FindRecord(iter.ToString(), j.Keys[0]).Value += probability * subi.SyncDB.GetEquation("selling").FindRecord(j.Keys).Marginal;
                    }
                }
                lowerbound = Math.Max(lowerbound, objmaster + objsub);
                iter++;
                if (iter == maxiter + 1)
                {
                    throw new Exception("Benders out of iterations");
                }

                Console.WriteLine(" lowerbound: " + lowerbound + " upperbound: " + upperbound + " objmaster: " + objmaster);
            } while ((upperbound - lowerbound) >= 0.001 * (1 + Math.Abs(upperbound)));

            masteri.Dispose();
            subi.Dispose();
        }
Beispiel #7
0
        static void Main(string[] args)
        {
            GAMSWorkspace ws;

            if (Environment.GetCommandLineArgs().Length > 1)
            {
                ws = new GAMSWorkspace(systemDirectory: Environment.GetCommandLineArgs()[1]);
            }
            else
            {
                ws = new GAMSWorkspace();
            }
            GAMSCheckpoint cp = ws.AddCheckpoint();

            // initialize a GAMSCheckpoint by running a GAMSJob
            GAMSJob t12 = ws.AddJobFromString(GetModelText());

            t12.Run(cp);

            // create a GAMSModelInstance and solve it multiple times with different scalar bmult
            GAMSModelInstance mi = cp.AddModelInstance();

            double[] bmultlist = new double[] { 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3 };

            GAMSDatabase db = ws.AddDatabase();

            GAMSSet       scen  = db.AddSet("scen", 1, "");
            GAMSParameter bmult = db.AddParameter("bmultlist", 1, "");
            GAMSParameter zscen = db.AddParameter("zscen", 1, "");

            int i = 0;

            foreach (double b in bmultlist)
            {
                bmult.AddRecord("s" + i).Value = b;
                scen.AddRecord("s" + i++);
            }

            GAMSSet dict = db.AddSet("dict", 3, "");

            dict.AddRecord(scen.Name, "scenario", "");
            dict.AddRecord("bmult", "param", bmult.Name);
            dict.AddRecord("z", "level", zscen.Name);


            GUSSCall(dict, mi, "transport us lp min z");

            foreach (GAMSParameterRecord rec in db.GetParameter(zscen.Name))
            {
                Console.WriteLine(rec.Keys[0] + " obj: " + rec.Value);
            }

            //*******************

            GAMSModelInstance mi2 = cp.AddModelInstance();
            GAMSDatabase      db2 = ws.AddDatabase();

            GAMSSet       scen2  = db2.AddSet("scen", 1, "");
            GAMSParameter zscen2 = db2.AddParameter("zscen", 1, "");
            GAMSParameter xup    = db2.AddParameter("xup", 3, "");

            for (int j = 0; j < 4; j++)
            {
                foreach (GAMSSetRecord irec in t12.OutDB.GetSet("i"))
                {
                    foreach (GAMSSetRecord jrec in t12.OutDB.GetSet("j"))
                    {
                        xup.AddRecord("s" + j, irec.Keys[0], jrec.Keys[0]).Value = j + 1;
                    }
                }
                scen2.AddRecord("s" + j);
            }


            GAMSSet dict2 = db2.AddSet("dict", 3, "");

            dict2.AddRecord(scen2.Name, "scenario", "");
            dict2.AddRecord("x", "lower", xup.Name);
            dict2.AddRecord("z", "level", zscen2.Name);

            GUSSCall(dict2, mi2, "transport us lp min z", output: Console.Out);

            foreach (GAMSParameterRecord rec in db2.GetParameter(zscen2.Name))
            {
                Console.WriteLine(rec.Keys[0] + " obj: " + rec.Value);
            }
        }
Beispiel #8
0
        // Needs to be called with an uninstantiated GAMSModelInstance
        static void GUSSCall(GAMSSet dict, GAMSModelInstance mi, string solveStatement, GAMSOptions opt = null, GAMSModelInstanceOpt miOpt = null, TextWriter output = null)
        {
            List <Tuple <GAMSModifier, GAMSParameter> > modifierList = new List <Tuple <GAMSModifier, GAMSParameter> >();

            if (dict.Dim != 3)
            {
                throw new GAMSException("Dict needs to be 3-dimensional");
            }

            string  scenName   = dict.FirstRecord(new string[] { " ", "scenario", " " }).Keys[0];
            GAMSSet scenSymbol = dict.GAMSDatabase.GetSet(scenName);


            foreach (GAMSSetRecord rec in dict)
            {
                if (rec.Keys[1].ToLower() == "scenario")
                {
                    continue;
                }
                if (rec.Keys[1].ToLower() == "param")
                {
                    int modifierDim = dict.GAMSDatabase.GetParameter(rec.Keys[2]).Dim - scenSymbol.Dim;
                    if (modifierDim < 0)
                    {
                        throw new GAMSException("Dimension of " + rec.Keys[2] + " too small");
                    }
                    modifierList.Add(new Tuple <GAMSModifier, GAMSParameter>
                                         (new GAMSModifier(mi.SyncDB.AddParameter(rec.Keys[0], modifierDim, "")),
                                         dict.GAMSDatabase.GetParameter(rec.Keys[2])));
                }
                else if ((rec.Keys[1].ToLower() == "lower") || (rec.Keys[1].ToLower() == "upper") || (rec.Keys[1].ToLower() == "fixed"))
                {
                    int modifierDim = dict.GAMSDatabase.GetParameter(rec.Keys[2]).Dim - scenSymbol.Dim;
                    if (modifierDim < 0)
                    {
                        throw new GAMSException("Dimension of " + rec.Keys[2] + " too small");
                    }
                    GAMSVariable modifierVar;
                    try
                    {
                        modifierVar = dict.GAMSDatabase.GetVariable(rec.Keys[0]);
                    }
                    catch (Exception)
                    {
                        modifierVar = mi.SyncDB.AddVariable(rec.Keys[0], modifierDim, VarType.Free, "");
                    }
                    if (rec.Keys[1].ToLower() == "lower")
                    {
                        modifierList.Add(new Tuple <GAMSModifier, GAMSParameter>
                                             (new GAMSModifier(modifierVar, UpdateAction.Lower, mi.SyncDB.AddParameter(rec.Keys[2], modifierDim, "")),
                                             dict.GAMSDatabase.GetParameter(rec.Keys[2])));
                    }
                    else if (rec.Keys[1].ToLower() == "upper")
                    {
                        modifierList.Add(new Tuple <GAMSModifier, GAMSParameter>
                                             (new GAMSModifier(modifierVar, UpdateAction.Upper, mi.SyncDB.AddParameter(rec.Keys[2], modifierDim, "")),
                                             dict.GAMSDatabase.GetParameter(rec.Keys[2])));
                    }
                    else  // fixed
                    {
                        modifierList.Add(new Tuple <GAMSModifier, GAMSParameter>
                                             (new GAMSModifier(modifierVar, UpdateAction.Fixed, mi.SyncDB.AddParameter(rec.Keys[2], modifierDim, "")),
                                             dict.GAMSDatabase.GetParameter(rec.Keys[2])));
                    }
                }
                else if ((rec.Keys[1].ToLower() == "level") || (rec.Keys[1].ToLower() == "marginal"))
                {
                    // Check that parameter exists in GAMSDatabase, will throw an exception if not
                    GAMSParameter x = dict.GAMSDatabase.GetParameter(rec.Keys[2]);
                }
                else
                {
                    throw new GAMSException("Cannot handle UpdateAction " + rec.Keys[1]);
                }
            }
            List <GAMSModifier> mL = new List <GAMSModifier>();

            foreach (Tuple <GAMSModifier, GAMSParameter> tup in modifierList)
            {
                mL.Add(tup.Item1);
            }
            mi.Instantiate(solveStatement, opt, mL.ToArray());

            List <Tuple <GAMSSymbol, GAMSParameter, string> > outList = new List <Tuple <GAMSSymbol, GAMSParameter, string> >();

            foreach (GAMSSetRecord s in scenSymbol)
            {
                foreach (Tuple <GAMSModifier, GAMSParameter> tup in modifierList)
                {
                    GAMSParameter p;
                    GAMSParameter pscen = tup.Item2;

                    if (tup.Item1.DataSym == null)
                    {
                        p = (GAMSParameter)tup.Item1.GamsSym;
                    }
                    else
                    {
                        p = tup.Item1.DataSym;
                    }

                    // Implemented SymbolUpdateType=BaseCase
                    p.Clear();

                    GAMSParameterRecord rec;
                    string[]            filter = new string[pscen.Dim];
                    for (int i = 0; i < scenSymbol.Dim; i++)
                    {
                        filter[i] = s.Keys[i];
                    }
                    for (int i = scenSymbol.Dim; i < pscen.Dim; i++)
                    {
                        filter[i] = " ";
                    }
                    try
                    {
                        rec = pscen.FirstRecord(filter);
                    }
                    catch (GAMSException)
                    {
                        continue;
                    }
                    do
                    {
                        string[] myKeys = new string[p.Dim];
                        for (int i = 0; i < p.Dim; i++)
                        {
                            myKeys[i] = rec.Keys[scenSymbol.Dim + i];
                        }
                        p.AddRecord(myKeys).Value = rec.Value;
                    } while (rec.MoveNext());
                }

                mi.Solve(GAMSModelInstance.SymbolUpdateType.BaseCase, output, miOpt);
                if (outList.Count == 0)
                {
                    foreach (GAMSSetRecord rec in dict)
                    {
                        if ((rec.Keys[1].ToLower() == "level") || (rec.Keys[1].ToLower() == "marginal"))
                        {
                            outList.Add(new Tuple <GAMSSymbol, GAMSParameter, string>(mi.SyncDB.GetSymbol(rec.Keys[0]), dict.GAMSDatabase.GetParameter(rec.Keys[2]), rec.Keys[1].ToLower()));
                        }
                    }
                }

                foreach (Tuple <GAMSSymbol, GAMSParameter, string> tup in outList)
                {
                    string[] myKeys = new string[scenSymbol.Dim + tup.Item1.FirstRecord().Keys.Length];
                    for (int i = 0; i < scenSymbol.Dim; i++)
                    {
                        myKeys[i] = s.Keys[i];
                    }

                    if ((tup.Item3 == "level") && (tup.Item1 is GAMSVariable))
                    {
                        foreach (GAMSVariableRecord rec in tup.Item1)
                        {
                            for (int i = 0; i < rec.Keys.Length; i++)
                            {
                                myKeys[scenSymbol.Dim + i] = s.Keys[i];
                            }
                            tup.Item2.AddRecord(myKeys).Value = rec.Level;
                        }
                    }
                    else if ((tup.Item3 == "level") && (tup.Item1 is GAMSEquation))
                    {
                        foreach (GAMSEquationRecord rec in tup.Item1)
                        {
                            for (int i = 0; i < rec.Keys.Length; i++)
                            {
                                myKeys[scenSymbol.Dim + i] = s.Keys[i];
                            }
                            tup.Item2.AddRecord(myKeys).Value = rec.Level;
                        }
                    }
                    else if ((tup.Item3 == "marginal") && (tup.Item1 is GAMSVariable))
                    {
                        foreach (GAMSVariableRecord rec in tup.Item1)
                        {
                            for (int i = 0; i < rec.Keys.Length; i++)
                            {
                                myKeys[scenSymbol.Dim + i] = s.Keys[i];
                            }
                            tup.Item2.AddRecord(myKeys).Value = rec.Marginal;
                        }
                    }
                    else if ((tup.Item3 == "marginal") && (tup.Item1 is GAMSEquation))
                    {
                        foreach (GAMSEquationRecord rec in tup.Item1)
                        {
                            for (int i = 0; i < rec.Keys.Length; i++)
                            {
                                myKeys[scenSymbol.Dim + i] = s.Keys[i];
                            }
                            tup.Item2.AddRecord(myKeys).Value = rec.Marginal;
                        }
                    }
                }
            }
        }
Beispiel #9
0
        static void Main(string[] args)
        {
            // Reading input data from workbook
            var excelApp = new Excel.Application();

            Excel.Workbook wb = excelApp.Workbooks.Open(Directory.GetCurrentDirectory() + @"\..\..\..\..\Data\transport.xls");

            Excel.Range range;

            Excel.Worksheet capacity = (Excel.Worksheet)wb.Worksheets.get_Item("capacity");
            range = capacity.UsedRange;
            Array capacityData = (Array)range.Cells.Value;
            int   iCount       = capacity.UsedRange.Columns.Count;

            Excel.Worksheet demand = (Excel.Worksheet)wb.Worksheets.get_Item("demand");
            range = demand.UsedRange;
            Array demandData = (Array)range.Cells.Value;
            int   jCount     = range.Columns.Count;

            Excel.Worksheet distance = (Excel.Worksheet)wb.Worksheets.get_Item("distance");
            range = distance.UsedRange;
            Array distanceData = (Array)range.Cells.Value;

            // number of markets/plants have to be the same in all spreadsheets
            Debug.Assert((range.Columns.Count - 1) == jCount && (range.Rows.Count - 1) == iCount,
                         "Size of the spreadsheets doesn't match");
            wb.Close();

            // Creating the GAMSDatabase and fill with the workbook data
            GAMSWorkspace ws;

            if (Environment.GetCommandLineArgs().Length > 1)
            {
                ws = new GAMSWorkspace(systemDirectory: Environment.GetCommandLineArgs()[1]);
            }
            else
            {
                ws = new GAMSWorkspace();
            }
            GAMSDatabase db = ws.AddDatabase();

            GAMSSet       i             = db.AddSet("i", 1, "Plants");
            GAMSSet       j             = db.AddSet("j", 1, "Markets");
            GAMSParameter capacityParam = db.AddParameter("a", 1, "Capacity");
            GAMSParameter demandParam   = db.AddParameter("b", 1, "Demand");
            GAMSParameter distanceParam = db.AddParameter("d", 2, "Distance");

            for (int ic = 1; ic <= iCount; ic++)
            {
                i.AddRecord((string)capacityData.GetValue(1, ic));
                capacityParam.AddRecord((string)capacityData.GetValue(1, ic)).Value = (double)capacityData.GetValue(2, ic);
            }
            for (int jc = 1; jc <= jCount; jc++)
            {
                j.AddRecord((string)demandData.GetValue(1, jc));
                demandParam.AddRecord((string)demandData.GetValue(1, jc)).Value = (double)demandData.GetValue(2, jc);
                for (int ic = 1; ic <= iCount; ic++)
                {
                    distanceParam.AddRecord((string)distanceData.GetValue(ic + 1, 1), (string)distanceData.GetValue(1, jc + 1)).Value = (double)distanceData.GetValue(ic + 1, jc + 1);
                }
            }

            // Create and run the GAMSJob
            using (GAMSOptions opt = ws.AddOptions())
            {
                GAMSJob t10 = ws.AddJobFromString(GetModelText());
                opt.Defines.Add("gdxincname", db.Name);
                opt.AllModelTypes = "xpress";
                t10.Run(opt, db);
                foreach (GAMSVariableRecord rec in t10.OutDB.GetVariable("x"))
                {
                    Console.WriteLine("x(" + rec.Keys[0] + "," + rec.Keys[1] + "): level=" + rec.Level + " marginal=" + rec.Marginal);
                }
            }
        }
Beispiel #10
0
        static void Main(string[] args)
        {
            GAMSWorkspace ws;

            if (Environment.GetCommandLineArgs().Length > 1)
            {
                ws = new GAMSWorkspace(systemDirectory: Environment.GetCommandLineArgs()[1]);
            }
            else
            {
                ws = new GAMSWorkspace();
            }
            GAMSJob data = ws.AddJobFromString(GetDataText());

            GAMSOptions optData = ws.AddOptions();

            optData.Defines.Add("useBig", "1");
            optData.Defines.Add("nrScen", "100");

            data.Run(optData);

            optData.Dispose();
            GAMSParameter scenarioData = data.OutDB.GetParameter("ScenarioData");

            GAMSOptions opt = ws.AddOptions();

            opt.Defines.Add("datain", data.OutDB.Name);
            int maxiter = 40;

            opt.Defines.Add("maxiter", maxiter.ToString());
            opt.AllModelTypes = "cplexd";

            GAMSCheckpoint cpMaster = ws.AddCheckpoint();
            GAMSCheckpoint cpSub    = ws.AddCheckpoint();

            ws.AddJobFromString(GetMasterText()).Run(opt, cpMaster, data.OutDB);

            GAMSModelInstance masteri  = cpMaster.AddModelInstance();
            GAMSParameter     cutconst = masteri.SyncDB.AddParameter("cutconst", 1, "Benders optimality cut constant");
            GAMSParameter     cutcoeff = masteri.SyncDB.AddParameter("cutcoeff", 2, "Benders optimality coefficients");
            GAMSVariable      theta    = masteri.SyncDB.AddVariable("theta", 0, VarType.Free, "Future profit function variable");
            GAMSParameter     thetaFix = masteri.SyncDB.AddParameter("thetaFix", 0, "");

            masteri.Instantiate("masterproblem max zmaster using lp", opt, new GAMSModifier(cutconst), new GAMSModifier(cutcoeff), new GAMSModifier(theta, UpdateAction.Fixed, thetaFix));

            ws.AddJobFromString(GetSubText()).Run(opt, cpSub, data.OutDB);

            int numThreads = 2;

            GAMSModelInstance[] subi = new GAMSModelInstance[numThreads];
            Queue <Tuple <string, double, Dictionary <string, double> > > demQueue = new Queue <Tuple <string, double, Dictionary <string, double> > >();

            for (int i = 0; i < numThreads; i++)
            {
                subi[i] = cpSub.AddModelInstance();
                GAMSParameter received = subi[i].SyncDB.AddParameter("received", 1, "units received from first stage solution");
                GAMSParameter demand   = subi[i].SyncDB.AddParameter("demand", 1, "stochastic demand");

                subi[i].Instantiate("subproblem max zsub using lp", opt, new GAMSModifier(received), new GAMSModifier(demand));
            }
            opt.Dispose();

            double lowerbound = double.NegativeInfinity, upperbound = double.PositiveInfinity, objmaster = double.PositiveInfinity;
            int    iter = 1;

            do
            {
                Console.WriteLine("Iteration: " + iter);
                // Solve master
                if (1 == iter) // fix theta for first iteration
                {
                    thetaFix.AddRecord().Value = 0;
                }
                else
                {
                    thetaFix.Clear();
                }

                masteri.Solve(GAMSModelInstance.SymbolUpdateType.BaseCase);
                Console.WriteLine(" Master " + masteri.ModelStatus + " : obj=" + masteri.SyncDB.GetVariable("zmaster").FirstRecord().Level);
                if (1 < iter)
                {
                    upperbound = masteri.SyncDB.GetVariable("zmaster").FirstRecord().Level;
                }
                objmaster = masteri.SyncDB.GetVariable("zmaster").FirstRecord().Level - theta.FirstRecord().Level;

                foreach (GAMSSetRecord s in data.OutDB.GetSet("s"))
                {
                    Dictionary <string, double> demDict = new Dictionary <string, double>();
                    foreach (GAMSSetRecord j in data.OutDB.GetSet("j"))
                    {
                        demDict[j.Keys[0]] = scenarioData.FindRecord(s.Keys[0], j.Keys[0]).Value;
                    }
                    demQueue.Enqueue(new Tuple <string, double, Dictionary <string, double> >(s.Keys[0], scenarioData.FindRecord(s.Keys[0], "prob").Value, demDict));
                }

                for (int i = 0; i < numThreads; i++)
                {
                    subi[i].SyncDB.GetParameter("received").Clear();
                }
                foreach (GAMSVariableRecord r in masteri.SyncDB.GetVariable("received"))
                {
                    cutcoeff.AddRecord(iter.ToString(), r.Keys[0]);
                    for (int i = 0; i < numThreads; i++)
                    {
                        subi[i].SyncDB.GetParameter("received").AddRecord(r.Keys).Value = r.Level;
                    }
                }

                cutconst.AddRecord(iter.ToString());
                double objsubsum = 0.0;

                // solve multiple model instances in parallel
                Object   queueMutex = new Object();
                Object   ioMutex    = new Object();
                double[] objsub     = new double[numThreads];
                Dictionary <string, double>[] coef = new Dictionary <string, double> [numThreads];
                double[] cons = new double[numThreads];

                for (int i = 0; i < numThreads; i++)
                {
                    coef[i] = new Dictionary <string, double>();
                    foreach (GAMSSetRecord j in data.OutDB.GetSet("j"))
                    {
                        coef[i].Add(j.Keys[0], 0.0);
                    }
                }

                Parallel.For(0, numThreads, delegate(int i) { ScenSolve(subi[i], ref cons[i], ref coef[i], demQueue, ref objsub[i], queueMutex, ioMutex); });

                for (int i = 0; i < numThreads; i++)
                {
                    objsubsum += objsub[i];
                    cutconst.FindRecord(iter.ToString()).Value += cons[i];
                    foreach (GAMSSetRecord j in data.OutDB.GetSet("j"))
                    {
                        cutcoeff.FindRecord(iter.ToString(), j.Keys[0]).Value += coef[i][j.Keys[0]];
                    }
                }
                lowerbound = Math.Max(lowerbound, objmaster + objsubsum);

                iter++;
                if (iter == maxiter + 1)
                {
                    throw new Exception("Benders out of iterations");
                }

                Console.WriteLine(" lowerbound: " + lowerbound + " upperbound: " + upperbound + " objmaster: " + objmaster);
            } while ((upperbound - lowerbound) >= 0.001 * (1 + Math.Abs(upperbound)));

            masteri.Dispose();
            foreach (GAMSModelInstance inst in subi)
            {
                inst.Dispose();
            }
        }
Beispiel #11
0
        static void Main(string[] args)
        {
            // Create a save/restart file usually supplied by an application provider
            // We create it for demonstration purpose
            string wDir = Path.Combine(".", "tmp");

            CreateSaveRestart(Path.Combine(wDir, "tbase"));

            // define some data by using C# data structures
            List <string> plants = new List <string>()
            {
                "Seattle", "San-Diego"
            };
            List <string> markets = new List <string>()
            {
                "New-York", "Chicago", "Topeka"
            };
            Dictionary <string, double> capacity = new Dictionary <string, double>()
            {
                { "Seattle", 350.0 }, { "San-Diego", 600.0 }
            };
            Dictionary <string, double> demand = new Dictionary <string, double>()
            {
                { "New-York", 325.0 }, { "Chicago", 300.0 }, { "Topeka", 275.0 }
            };
            Dictionary <Tuple <string, string>, double> distance = new Dictionary <Tuple <string, string>, double>()
            {
                { new Tuple <string, string> ("Seattle", "New-York"), 2.5 },
                { new Tuple <string, string> ("Seattle", "Chicago"), 1.7 },
                { new Tuple <string, string> ("Seattle", "Topeka"), 1.8 },
                { new Tuple <string, string> ("San-Diego", "New-York"), 2.5 },
                { new Tuple <string, string> ("San-Diego", "Chicago"), 1.8 },
                { new Tuple <string, string> ("San-Diego", "Topeka"), 1.4 }
            };

            GAMSWorkspace ws;

            if (Environment.GetCommandLineArgs().Length > 1)
            {
                ws = new GAMSWorkspace(workingDirectory: wDir, systemDirectory: Environment.GetCommandLineArgs()[1]);
            }
            else
            {
                ws = new GAMSWorkspace(workingDirectory: wDir);
            }
            // prepare a GAMSDatabase with data from the C# data structures
            GAMSDatabase db = ws.AddDatabase();

            GAMSSet i = db.AddSet("i", 1, "canning plants");

            foreach (string p in plants)
            {
                i.AddRecord(p);
            }

            GAMSSet j = db.AddSet("j", 1, "markets");

            foreach (string m in markets)
            {
                j.AddRecord(m);
            }

            GAMSParameter a = db.AddParameter("a", 1, "capacity of plant i in cases");

            foreach (string p in plants)
            {
                a.AddRecord(p).Value = capacity[p];
            }

            GAMSParameter b = db.AddParameter("b", 1, "demand at market j in cases");

            foreach (string m in markets)
            {
                b.AddRecord(m).Value = demand[m];
            }

            GAMSParameter d = db.AddParameter("d", 2, "distance in thousands of miles");

            foreach (Tuple <string, string> t in distance.Keys)
            {
                d.AddRecord(t.Item1, t.Item2).Value = distance[t];
            }

            GAMSParameter f = db.AddParameter("f", 0, "freight in dollars per case per thousand miles");

            f.AddRecord().Value = 90;

            // run a job using data from the created GAMSDatabase
            GAMSCheckpoint cpBase = ws.AddCheckpoint("tbase");

            using (GAMSOptions opt = ws.AddOptions())
            {
                GAMSJob t4 = ws.AddJobFromString(GetModelText(), cpBase);
                opt.Defines.Add("gdxincname", db.Name);
                opt.AllModelTypes = "xpress";
                t4.Run(opt, db);
                foreach (GAMSVariableRecord rec in t4.OutDB.GetVariable("x"))
                {
                    Console.WriteLine("x(" + rec.Keys[0] + "," + rec.Keys[1] + "): level=" + rec.Level + " marginal=" + rec.Marginal);
                }
            }
        }
Beispiel #12
0
        static void Main(string[] args)
        {
            GAMSWorkspace ws;

            if (Environment.GetCommandLineArgs().Length > 1)
            {
                ws = new GAMSWorkspace(systemDirectory: Environment.GetCommandLineArgs()[1]);
            }
            else
            {
                ws = new GAMSWorkspace();
            }
            GAMSCheckpoint cp = ws.AddCheckpoint();

            // initialize a GAMSCheckpoint by running a GAMSJob
            GAMSJob t7 = ws.AddJobFromString(GetModelText());

            t7.Run(cp);

            // create a GAMSModelInstance and solve it multiple times with different scalar bmult
            GAMSModelInstance mi = cp.AddModelInstance();

            GAMSParameter bmult = mi.SyncDB.AddParameter("bmult", 0, "demand multiplier");
            GAMSOptions   opt   = ws.AddOptions();

            opt.AllModelTypes = "gurobi";

            // instantiate the GAMSModelInstance and pass a model definition and GAMSModifier to declare bmult mutable
            mi.Instantiate("transport us lp min z", opt, new GAMSModifier(bmult));

            bmult.AddRecord().Value = 1.0;
            double[] bmultlist      = new double[] { 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3 };

            foreach (double b in bmultlist)
            {
                bmult.FirstRecord().Value = b;
                mi.Solve();
                Console.WriteLine("Scenario bmult=" + b + ":");
                Console.WriteLine("  Modelstatus: " + mi.ModelStatus);
                Console.WriteLine("  Solvestatus: " + mi.SolveStatus);
                Console.WriteLine("  Obj: " + mi.SyncDB.GetVariable("z").FindRecord().Level);
            }

            // create a GAMSModelInstance and solve it with single links in the network blocked
            mi = cp.AddModelInstance();

            GAMSVariable  x   = mi.SyncDB.AddVariable("x", 2, VarType.Positive, "");
            GAMSParameter xup = mi.SyncDB.AddParameter("xup", 2, "upper bound on x");

            // instantiate the GAMSModelInstance and pass a model definition and GAMSModifier to declare upper bound of X mutable
            mi.Instantiate("transport us lp min z", modifiers: new GAMSModifier(x, UpdateAction.Upper, xup));

            foreach (GAMSSetRecord i in t7.OutDB.GetSet("i"))
            {
                foreach (GAMSSetRecord j in t7.OutDB.GetSet("j"))
                {
                    xup.Clear();
                    xup.AddRecord(i.Keys[0], j.Keys[0]).Value = 0;
                    mi.Solve();
                    Console.WriteLine("Scenario link blocked: " + i.Keys[0] + " - " + j.Keys[0]);
                    Console.WriteLine("  Modelstatus: " + mi.ModelStatus);
                    Console.WriteLine("  Solvestatus: " + mi.SolveStatus);
                    Console.WriteLine("  Obj: " + mi.SyncDB.GetVariable("z").FindRecord().Level);
                }
            }
        }
Beispiel #13
0
        static void Main(string[] args)
        {
            GAMSWorkspace ws;

            if (Environment.GetCommandLineArgs().Length > 1)
            {
                ws = new GAMSWorkspace(systemDirectory: Environment.GetCommandLineArgs()[1]);
            }
            else
            {
                ws = new GAMSWorkspace();
            }
            // instantiate GAMSOptions and define parameters
            GAMSOptions  opt          = ws.AddOptions();
            GAMSDatabase cutstockData = ws.AddDatabase("csdata");

            opt.AllModelTypes = "Cplex";
            opt.OptCR         = 0.0; // Solve to optimality
            int maxpattern = 35;

            opt.Defines.Add("pmax", maxpattern.ToString());
            opt.Defines.Add("solveMasterAs", "RMIP");

            // define input data
            Dictionary <string, double> d = new Dictionary <string, double>()
            {
                { "i1", 97 }, { "i2", 610 }, { "i3", 395 }, { "i4", 211 }
            };
            Dictionary <string, double> w = new Dictionary <string, double>()
            {
                { "i1", 47 }, { "i2", 36 }, { "i3", 31 }, { "i4", 14 }
            };
            int r = 100; // raw width

            // cutstockData.AddSet("i", 1, "widths").AddRecords(d.Keys);
            // cutstockData.AddParameter("d", 1, "demand").AddRecords(d);
            // cutstockData.AddParameter("w", 1, "width").AddRecords(w);
            // cutstockData.AddParameter("r", 0, "raw width").AddRecord().Value = r;

            GAMSSet       widths   = cutstockData.AddSet("i", 1, "widths");
            GAMSParameter rawWidth = cutstockData.AddParameter("r", 0, "raw width");
            GAMSParameter demand   = cutstockData.AddParameter("d", 1, "demand");
            GAMSParameter width    = cutstockData.AddParameter("w", 1, "width");

            rawWidth.AddRecord().Value = r;
            foreach (string i in d.Keys)
            {
                widths.AddRecord(i);
            }
            foreach (KeyValuePair <string, double> t in d)
            {
                demand.AddRecord(t.Key).Value = t.Value;
            }
            foreach (KeyValuePair <string, double> t in w)
            {
                width.AddRecord(t.Key).Value = t.Value;
            }

            // create initial checkpoint
            GAMSCheckpoint masterCP      = ws.AddCheckpoint();
            GAMSJob        masterInitJob = ws.AddJobFromString(GetMasterModel());

            masterInitJob.Run(opt, masterCP, cutstockData);

            GAMSJob masterJob = ws.AddJobFromString("execute_load 'csdata', aip, pp; solve master min z using %solveMasterAs%;", masterCP);

            GAMSSet       pattern     = cutstockData.AddSet("pp", 1, "pattern index");
            GAMSParameter patternData = cutstockData.AddParameter("aip", 2, "pattern data");

            // Initial pattern: pattern i hold width i
            int patternCount = 0;

            foreach (KeyValuePair <string, double> t in w)
            {
                patternData.AddRecord(t.Key, pattern.AddRecord((++patternCount).ToString()).Keys[0]).Value = (int)(r / t.Value);
            }

            // create model instance for sub job
            GAMSCheckpoint subCP = ws.AddCheckpoint();

            ws.AddJobFromString(GetSubModel()).Run(opt, subCP, cutstockData);
            GAMSModelInstance subMI = subCP.AddModelInstance();

            // define modifier demdual
            GAMSParameter demandDual = subMI.SyncDB.AddParameter("demdual", 1, "dual of demand from master");

            subMI.Instantiate("pricing min z using mip", opt, new GAMSModifier(demandDual));

            // find new pattern
            bool patternAdded = true;

            do
            {
                masterJob.Run(opt, masterCP, cutstockData);
                // Copy duals into gmssubMI.SyncDB DB
                demandDual.Clear();
                foreach (GAMSEquationRecord dem in masterJob.OutDB.GetEquation("demand"))
                {
                    demandDual.AddRecord(dem.Keys[0]).Value = dem.Marginal;
                }

                subMI.Solve();
                if (subMI.SyncDB.GetVariable("z").FindRecord().Level < -0.00001)
                {
                    if (patternCount == maxpattern)
                    {
                        Console.Out.WriteLine("Out of pattern. Increase maxpattern (currently {0}).", maxpattern);
                        patternAdded = false;
                    }
                    else
                    {
                        Console.WriteLine("New patter! Value: " + subMI.SyncDB.GetVariable("z").FindRecord().Level);
                        GAMSSetRecord s = pattern.AddRecord((++patternCount).ToString());
                        foreach (GAMSVariableRecord y in subMI.SyncDB.GetVariable("y"))
                        {
                            if (y.Level > 0.5)
                            {
                                patternData.AddRecord(y.Keys[0], s.Keys[0]).Value = Math.Round(y.Level);
                            }
                        }
                    }
                }
                else
                {
                    patternAdded = false;
                }
            } while (patternAdded);

            // solve final MIP
            opt.Defines["solveMasterAs"] = "MIP";
            masterJob.Run(opt, cutstockData);
            Console.WriteLine("Optimal Solution: {0}", masterJob.OutDB.GetVariable("z").FindRecord().Level);
            foreach (GAMSVariableRecord xp in masterJob.OutDB.GetVariable("xp"))
            {
                if (xp.Level > 0.5)
                {
                    Console.Out.Write("  pattern {0} {1} times: ", xp.Keys[0], xp.Level);
                    GAMSParameterRecord aip = masterJob.OutDB.GetParameter("aip").FirstRecord(" ", xp.Keys[0]);
                    do
                    {
                        Console.Out.Write(" {0}: {1}", aip.Keys[0], aip.Value);
                    } while (aip.MoveNext());
                    Console.Out.WriteLine();
                }
            }
            // clean up of unmanaged ressources
            cutstockData.Dispose();
            subMI.Dispose();
            opt.Dispose();
        }
        public void ProcessTask(TaskManager.TaskDetails oTask, out List <string> lsLogs, out string sOutput, out string sStatus)
        {
            // cast input values
            CutStockInput oInput = new CutStockInput();

            oInput = (CutStockInput)oDF.XmlStringToObject(oTask.InputValues, oInput);

            CutStockOutput oOutput = new CutStockOutput();

            // call processing algorithm

            GAMSWorkspace ws = new GAMSWorkspace();

            lsLog.Add("working directory : " + ws.WorkingDirectory);
            // instantiate GAMSOptions and define parameters
            GAMSOptions  opt          = ws.AddOptions();
            GAMSDatabase cutstockData = ws.AddDatabase("csdata");

            opt.AllModelTypes = "Cplex";
            opt.OptCR         = 0.0; // Solve to optimality
            opt.Defines.Add("pmax", oInput.MaxPattern.ToString());
            opt.Defines.Add("solveMasterAs", "RMIP");

            GAMSSet       widths   = cutstockData.AddSet("i", 1, "widths");
            GAMSParameter rawWidth = cutstockData.AddParameter("r", 0, "raw width");
            GAMSParameter demand   = cutstockData.AddParameter("d", 1, "demand");
            GAMSParameter width    = cutstockData.AddParameter("w", 1, "width");

            rawWidth.AddRecord().Value = oInput.RawWidth;

            foreach (CutItem oI in oInput.Items)
            {
                widths.AddRecord(oI.Name);
                demand.AddRecord(oI.Name).Value = oI.Demand;
                width.AddRecord(oI.Name).Value  = oI.Width;
            }

            // create initial checkpoint
            GAMSCheckpoint masterCP      = ws.AddCheckpoint();
            GAMSJob        masterInitJob = ws.AddJobFromString(GetMasterModel());

            masterInitJob.Run(opt, masterCP, cutstockData);

            GAMSJob masterJob = ws.AddJobFromString("execute_load 'csdata', aip, pp; solve master min z using %solveMasterAs%;", masterCP);

            GAMSSet       pattern     = cutstockData.AddSet("pp", 1, "pattern index");
            GAMSParameter patternData = cutstockData.AddParameter("aip", 2, "pattern data");

            // Initial pattern: pattern i hold width i
            int patternCount = 0;

            foreach (GAMSParameterRecord rec in width)
            {
                patternData.AddRecord(rec.Keys[0], pattern.AddRecord((++patternCount).ToString()).Keys[0]).Value = (int)(oInput.RawWidth / rec.Value);
            }

            // create model instance for sub job
            GAMSCheckpoint subCP = ws.AddCheckpoint();

            ws.AddJobFromString(GetSubModel()).Run(opt, subCP, cutstockData);
            GAMSModelInstance subMI = subCP.AddModelInstance();

            // define modifier demdual
            GAMSParameter demandDual = subMI.SyncDB.AddParameter("demdual", 1, "dual of demand from master");

            subMI.Instantiate("pricing min z using mip", opt, new GAMSModifier(demandDual));

            // find new pattern
            bool patternAdded = true;

            do
            {
                masterJob.Run(opt, masterCP, cutstockData);
                // Copy duals into gmssubMI.SyncDB DB
                demandDual.Clear();
                foreach (GAMSEquationRecord dem in masterJob.OutDB.GetEquation("demand"))
                {
                    demandDual.AddRecord(dem.Keys[0]).Value = dem.Marginal;
                }

                subMI.Solve();
                if (subMI.SyncDB.GetVariable("z").FindRecord().Level < -0.00001)
                {
                    if (patternCount == oInput.MaxPattern)
                    {
                        lsLog.Add("Out of pattern. Increase maxpattern (currently " + oInput.MaxPattern + ")." + Environment.NewLine);
                        patternAdded = false;
                    }
                    else
                    {
                        lsLog.Add("New pattern! Value: " + subMI.SyncDB.GetVariable("z").FindRecord().Level + Environment.NewLine);
                        GAMSSetRecord s = pattern.AddRecord((++patternCount).ToString());
                        foreach (GAMSVariableRecord y in subMI.SyncDB.GetVariable("y"))
                        {
                            if (y.Level > 0.5)
                            {
                                patternData.AddRecord(y.Keys[0], s.Keys[0]).Value = Math.Round(y.Level);
                            }
                        }
                    }
                }
                else
                {
                    patternAdded = false;
                }
            } while (patternAdded);

            // solve final MIP
            opt.Defines["solveMasterAs"] = "MIP";
            masterJob.Run(opt, cutstockData);
            var dlevel = masterJob.OutDB.GetVariable("z").FindRecord().Level;

            oOutput.OptimalSolution = (int)dlevel;
            lsLog.Add("Optimal Solution: " + dlevel + Environment.NewLine);
            List <Pattern> lP = new List <Pattern>();

            foreach (GAMSVariableRecord xp in masterJob.OutDB.GetVariable("xp"))
            {
                string sPatternLog = "";
                if (xp.Level > 0.5)
                {
                    sPatternLog = string.Format("  pattern {0,2} {1,4} times: ", xp.Keys[0], Math.Round(xp.Level));
                    GAMSParameterRecord aip = masterJob.OutDB.GetParameter("aip").FirstRecord(" ", xp.Keys[0]);

                    Pattern oP = new Pattern()
                    {
                        Name = "pattern " + xp.Keys[0].ToString(), Count = (int)Math.Round(xp.Level)
                    };
                    List <PatternPiece> lPP = new List <PatternPiece>();
                    int    x     = 0;
                    double scale = 100 / masterJob.OutDB.GetParameter("r").FirstRecord().Value;
                    do
                    {
                        sPatternLog += " " + aip.Keys[0] + ": " + aip.Value.ToString();
                        // draw cuts
                        for (int i = 0; i < aip.Value; i++)
                        {
                            PatternPiece oPP = new PatternPiece()
                            {
                                Name  = aip.Keys[0],
                                Width = (int)(width.FindRecord(aip.Keys[0]).Value *scale),
                                Left  = x,
                                Color = oInput.Items.Where(xi => xi.Name == aip.Keys[0]).FirstOrDefault().Color
                            };
                            lPP.Add(oPP);
                            // x += oPP.Width - 1;
                            x += oPP.Width;
                        }
                    } while (aip.MoveNext());

                    if (x < 100)
                    {
                        PatternPiece oPExcess = new PatternPiece()
                        {
                            Name  = "E",
                            Width = (int)(rawWidth.FirstRecord().Value *scale - x),
                            Left  = x,
                            Color = "CCCCCC"
                        };
                        lPP.Add(oPExcess);
                    }
                    lsLog.Add(sPatternLog);
                    oP.Pieces = lPP.ToArray();
                    lP.Add(oP);
                }
            }

            oOutput.Patterns = lP.ToArray();
            // clean up of unmanaged resources
            cutstockData.Dispose();
            subMI.Dispose();
            opt.Dispose();


            sOutput = oDF.ObjectToXmlString(oOutput);
            sStatus = "completed";
            lsLogs  = lsLog;
        }