ModelData.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.OleDb;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using GUI.Datatypes;

namespace GUI.IO_Modules
{
    class ModelData
    {
        private String Dir;
        private String[] locationNames;
        private LocationCB[] locations;
        private Dictionary<String, int> locationDictionary;
        private Dictionary<String, int> usableLocationDictionary;
        private String[] productNames;
        private Dictionary<String, int> productDictionary;
        private Dictionary<String, int> producableProductDictionary;
        private List<Toolkit> usableToolkits;

        private double[] FuellgradBehaelter;
        private double[] FuellgradTransportmittel;
        private double[][] StockOfProdAtLocation;
        private double[][] DauerBauteillogistik;
        private double[][] KostenBauteillogistik;
        private double[][] DauerWerkzeuglogistik;
        private double[][] KostenWerkzeuglogistik;
        private List<Order>[][] orders;
        private List<Order>[][] relevantOrders;
        public int maxN = 0;

        public ModelData(String dir, String[] locNames, LocationCB[] loc, Dictionary<String, int> locDic)
        {
            this.Dir = dir;
            locationNames = locNames;
            locations = loc;
            locationDictionary = locDic;
            productDictionary = new Dictionary<string, int>();
            DauerBauteillogistik = new double[locations.Length][];
            KostenBauteillogistik = new double[locations.Length][];
            DauerWerkzeuglogistik = new double[locations.Length][];
            KostenWerkzeuglogistik = new double[locations.Length][];
            orders = new List<Order>[locations.Length][];
            relevantOrders = new List<Order>[locations.Length][];

            getModelData();
        }

        private void getModelData()
        {
            OleDbConnectionStringBuilder csbuilder = new OleDbConnectionStringBuilder();
            csbuilder.Provider = "Microsoft.ACE.OLEDB.12.0";
            csbuilder.DataSource = Dir;
            csbuilder.Add("Extended Properties", "Excel 12.0 Xml");

            DataTable sheet1 = new DataTable();
            using (OleDbConnection connection = new OleDbConnection(csbuilder.ConnectionString))
            {
                connection.Open();
                string sqlQuery = @"SELECT * FROM [Werkzeuge$]";
                using (OleDbDataAdapter adapter = new OleDbDataAdapter(sqlQuery, connection))
                {
                    adapter.Fill(sheet1);
                }
                getToolkitData(sheet1);
                connection.Close();
            }

            sheet1 = new DataTable();
            using (OleDbConnection connection = new OleDbConnection(csbuilder.ConnectionString))
            {
                connection.Open();
                string sqlQuery = @"SELECT * FROM [Behälter$]";
                using (OleDbDataAdapter adapter = new OleDbDataAdapter(sqlQuery, connection))
                {
                    adapter.Fill(sheet1);
                }
                getContainerData(sheet1);
                connection.Close();
            }

            sheet1 = new DataTable();
            using (OleDbConnection connection = new OleDbConnection(csbuilder.ConnectionString))
            {
                connection.Open();
                string sqlQuery = @"SELECT * FROM [Bestand$]";
                using (OleDbDataAdapter adapter = new OleDbDataAdapter(sqlQuery, connection))
                {
                    adapter.Fill(sheet1);
                }
                getStockData(sheet1);
                connection.Close();
            }

            String[] Matrices = { "Dauer Bauteillogistik", "Kosten Bauteillogistik", "Dauer Werkzeuglogistik", "Kosten Werkzeuglogistik" };
            foreach (String s in Matrices)
            {
                sheet1 = new DataTable();
                using (OleDbConnection connection = new OleDbConnection(csbuilder.ConnectionString))
                {
                    connection.Open();
                    string sqlQuery = @"SELECT * FROM [" + s + "$]";
                    using (OleDbDataAdapter adapter = new OleDbDataAdapter(sqlQuery, connection))
                    {
                        adapter.Fill(sheet1);
                    }
                    getMatrixData(sheet1, s);
                    connection.Close();
                }
            }

            foreach (String SheetName in locationNames)
            {
                sheet1 = new DataTable();
                using (OleDbConnection connection = new OleDbConnection(csbuilder.ConnectionString))
                {
                    connection.Open();
                    // select everything from the worksheet that is named after a location
                    string sqlQuery = @"SELECT * FROM [Bedarf_" + SheetName + "$]";
                    using (OleDbDataAdapter adapter = new OleDbDataAdapter(sqlQuery, connection))
                    {
                        adapter.Fill(sheet1);
                    }
                    createOrderData(sheet1, SheetName);

                    connection.Close();
                }
            }
        }

        private void getToolkitData(DataTable sheet)
        {
            foreach (DataRow d in sheet.Rows)
            {
                int locationIndex = locationDictionary[d[5].ToString()];
                LocationCB loc = locations[locationIndex];
                Toolkit t = new Toolkit(d[0].ToString(), loc);
                foreach (String s in d[2].ToString().Split(';'))
                {
                    t.addProduct(s);
                }
                foreach (String s in d[4].ToString().Split(';'))
                {
                    if (!s.Equals(""))
                    {
                        //only if s is not empty
                        t.addInfluencedToolkits(s);
                    }
                }
                loc.addToolkit(t);
            }
        }

        private void getContainerData(DataTable sheet)
        {
            FuellgradBehaelter = new double[sheet.Rows.Count];
            FuellgradTransportmittel = new double[sheet.Rows.Count];
            productNames = new String[sheet.Rows.Count];
            int counter = 0;
            foreach (DataRow d in sheet.Rows)
            {
                productNames[counter] = d[0].ToString();
                productDictionary.Add(productNames[counter], counter);
                FuellgradBehaelter[counter] = Convert.ToDouble(d[1]);
                FuellgradTransportmittel[counter] = Convert.ToDouble(d[2]);
                counter++;
            }
        }

        private void getStockData(DataTable sheet)
        {
            StockOfProdAtLocation = new double[sheet.Rows.Count][];
            foreach (DataRow d in sheet.Rows)
            {
                StockOfProdAtLocation[productDictionary[d[0].ToString()]] = new double[sheet.Columns.Count - 1];
                for (int i = 1; i < sheet.Columns.Count; i++)
                {
                    StockOfProdAtLocation[productDictionary[d[0].ToString()]][locationDictionary[sheet.Columns[i].ToString()]] = Convert.ToDouble(d[i]);
                }
            }
        }

        private void getMatrixData(DataTable sheet, String s)
        {
            foreach (DataRow d in sheet.Rows)
            {
                if (s.Equals("Dauer Bauteillogistik"))
                {
                    DauerBauteillogistik[locationDictionary[d[0].ToString()]] = new double[locations.Length];
                    for (int i = 1; i < sheet.Columns.Count; i++)
                    {
                        DauerBauteillogistik[locationDictionary[d[0].ToString()]][locationDictionary[sheet.Columns[i].ToString()]] = Convert.ToDouble(d[i]);
                    }
                }
                if (s.Equals("Kosten Bauteillogistik"))
                {
                    KostenBauteillogistik[locationDictionary[d[0].ToString()]] = new double[locations.Length];
                    for (int i = 1; i < sheet.Columns.Count; i++)
                    {
                        KostenBauteillogistik[locationDictionary[d[0].ToString()]][locationDictionary[sheet.Columns[i].ToString()]] = Convert.ToDouble(d[i]);
                    }
                }
                if (s.Equals("Dauer Werkzeuglogistik"))
                {
                    DauerWerkzeuglogistik[locationDictionary[d[0].ToString()]] = new double[locations.Length];
                    for (int i = 1; i < sheet.Columns.Count; i++)
                    {
                        DauerWerkzeuglogistik[locationDictionary[d[0].ToString()]][locationDictionary[sheet.Columns[i].ToString()]] = Convert.ToDouble(d[i]);
                    }
                }
                if (s.Equals("Kosten Werkzeuglogistik"))
                {
                    KostenWerkzeuglogistik[locationDictionary[d[0].ToString()]] = new double[locations.Length];
                    for (int i = 1; i < sheet.Columns.Count; i++)
                    {
                        KostenWerkzeuglogistik[locationDictionary[d[0].ToString()]][locationDictionary[sheet.Columns[i].ToString()]] = Convert.ToDouble(d[i]);
                    }
                }
            }
        }

        private void createOrderData(DataTable sheet1, string sheetName)
        {
            // initialization of Matrix of lists:
            int locationIndex = locationDictionary[sheetName];
            orders[locationIndex] = new List<Order>[productNames.Length];
            foreach (int i in productDictionary.Values)
            {
                orders[locationIndex][i] = new List<Order>();
            }

            foreach (DataRow dr in sheet1.Rows)
            {
                String day = dr[0].ToString();
                if (day.Equals("")) break;
                for (int i = 1; i < sheet1.Columns.Count; i++)
                {
                    int amount = Convert.ToInt32(dr[i]);
                    if (amount != 0)
                    {
                        orders[locationIndex][productDictionary[sheet1.Columns[i].ToString()]].Add(new Order(day, amount));
                    }
                }
            }
        }

        public String toDatString(double d, DateTime start, DateTime end)
        {
            StringBuilder sb = new StringBuilder(5000);
            sb.Append(getLocations());
            sb.Append(getProducts());
            sb.Append(getToolkits());
            sb.Append(getMachines());
            sb.Append(getT(d, start, end));
            sb.Append(getTau(d));
            sb.Append(getYInit());
            sb.Append(getPsi());
            sb.Append(getDelta());
            sb.Append(getKhi());
            sb.Append(getBeta());
            sb.Append(getV(d));
            sb.Append(getKappa());
            sb.Append(getSigma());
            sb.Append(getWdep());
            sb.Append(getNAndMaxN(start, end));
            sb.Append(getEpsilon());
            sb.Append(getGamma(start, d));
            sb.Append(getNu());
            sb.Append(getRho());
            sb.Append(getEta(d));
            sb.Append(getAlpha(d));
            sb.Append(getLambda());
            sb.Append(getLocOfMachine());
            sb.Append(getMachinesOfLocation());
            sb.Append(getWProducer());


            return sb.ToString();
        }

        private String getLocations()
        {
            StringBuilder sb = new StringBuilder(200);
            sb.Append("S:[");
            usableLocationDictionary = new Dictionary<string, int>();
            foreach (LocationCB l in locations)
            {
                if (l.CheckState != CheckState.Unchecked)
                {
                    sb.Append("\"" + l.Name + "\", ");
                    usableLocationDictionary.Add(l.Name, locationDictionary[l.Name]);
                }
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getProducts()
        {
            StringBuilder sb = new StringBuilder(300);
            sb.Append("P:[");
            List<String> ProducedProducts = new List<String>();

            foreach (LocationCB l in locations)
            {
                if (l.CheckState != CheckState.Unchecked)
                {
                    l.extendProducableProducts(ProducedProducts);
                }
            }

            producableProductDictionary = new Dictionary<string, int>();
            foreach (String p in ProducedProducts)
            {
                producableProductDictionary.Add(p, productDictionary[p]);
            }

            foreach (String p in productNames)
            {
                sb.Append("\"" + p + "\", ");
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getToolkits()
        {
            StringBuilder sb = new StringBuilder(200);
            sb.Append("W:[");

            usableToolkits = new List<Toolkit>();
            foreach (LocationCB l in locations)
            {
                if (l.CheckState != CheckState.Unchecked)
                {
                    foreach (Toolkit t in l.getToolkits())
                    {
                        usableToolkits.Add(t);
                        sb.Append("\"" + t.Name + "\", ");
                    }
                }
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getMachines()
        {
            StringBuilder sb = new StringBuilder(200);
            sb.Append("M:[");
            foreach (LocationCB l in locations)
            {
                if (l.CheckState != CheckState.Unchecked)
                {
                    foreach (MachineCB m in l.getMachines())
                    {
                        if (m.CheckState != CheckState.Unchecked)
                        {

                            sb.Append("\"" + m.Name + "\", ");
                        }
                    }
                }
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getT(double d, DateTime start, DateTime end)
        {
            StringBuilder sb = new StringBuilder(200);
            sb.Append("T:[");

            double hours = end.Subtract(start).TotalHours;
            int timeslotNumber = (int)(hours / d);
            for (int i = 1; i <= timeslotNumber; i++)
            {
                sb.Append(i + ", ");
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getTau(double d)
        {
            return "tau: " + 60 * d + "\n";
        }

        private String getYInit()
        {
            StringBuilder sb = new StringBuilder(300);
            sb.Append("yInit:[");
            foreach (LocationCB l in locations)
            {
                if (l.CheckState != CheckState.Unchecked)
                {
                    foreach (Toolkit t in l.getToolkits())
                    {
                        sb.Append("(\"" + l.Name + "\" \"" + t.Name + "\") " + 1 + " ");
                    }
                }
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getPsi()
        {
            StringBuilder sb = new StringBuilder(300);
            sb.Append("psi:[");
            foreach (LocationCB l in locations)
            {
                if (l.CheckState != CheckState.Unchecked)
                {
                    foreach (String p in productNames)
                    {
                        sb.Append("(\"" + l.Name + "\" \"" + p + "\") " + l.Penalty + " ");
                    }
                }
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getDelta()
        {
            StringBuilder sb = new StringBuilder(2000);
            sb.Append("delta:[");
            foreach (KeyValuePair<String, int> S1 in usableLocationDictionary)
            {
                foreach (KeyValuePair<String, int> S2 in usableLocationDictionary)
                {
                    foreach (Toolkit t in usableToolkits)
                    {
                        sb.Append("(\"" + S1.Key + "\" \"" + S2.Key + "\" \"" + t.Name + "\") " + KostenWerkzeuglogistik[S1.Value][S2.Value] + " ");
                    }
                }
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getKhi()
        {
            StringBuilder sb = new StringBuilder(300);
            sb.Append("khi:[");
            foreach (KeyValuePair<String, int> S1 in usableLocationDictionary)
            {
                foreach (KeyValuePair<String, int> S2 in usableLocationDictionary)
                {
                    sb.Append("(\"" + S1.Key + "\" \"" + S2.Key + "\") " + KostenBauteillogistik[S1.Value][S2.Value] + " ");
                }
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getBeta()
        {
            StringBuilder sb = new StringBuilder(300);
            sb.Append("beta:[");
            foreach (KeyValuePair<String, int> S in usableLocationDictionary)
            {
                foreach (KeyValuePair<String, int> P in productDictionary)
                {
                    sb.Append("(\"" + S.Key + "\" \"" + P.Key + "\") " + StockOfProdAtLocation[P.Value][S.Value] + " ");
                }
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getV(double d)
        {
            StringBuilder sb = new StringBuilder(300);
            sb.Append("v:[");
            foreach (KeyValuePair<String, int> S in usableLocationDictionary)
            {
                foreach (MachineCB m in locations[S.Value].getMachines())
                {
                    if (m.CheckState != CheckState.Unchecked)
                    {
                        foreach (Toolkit t in usableToolkits)
                        {
                            sb.Append("(\"" + m.Name + "\" \"" + t.Name + "\") " + Math.Ceiling(m.Bauteilwechselphase / (60 * d)) + " ");
                        }
                    }
                }
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getKappa()
        {
            StringBuilder sb = new StringBuilder(300);
            sb.Append("kappa:[");
            foreach (KeyValuePair<String, int> P in productDictionary)
            {
                sb.Append("(\"" + P.Key + "\") " + FuellgradBehaelter[P.Value] + " ");
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getSigma()
        {
            StringBuilder sb = new StringBuilder(300);
            sb.Append("sigma:[");
            foreach (KeyValuePair<String, int> P in productDictionary)
            {
                sb.Append("(\"" + P.Key + "\") " + FuellgradTransportmittel[P.Value] + " ");
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getWdep()
        {
            StringBuilder sb = new StringBuilder(300);
            sb.Append("Wdep:[");
            foreach (KeyValuePair<String, int> L in usableLocationDictionary)
            {
                foreach (Toolkit t in locations[L.Value].getToolkits())
                {
                    // Mosel cannot have empty lists in the initializations block, therefore don't write them down
                    if (t.getInfluencedToolkits().Count != 0)
                    {
                        sb.Append("(\"" + t.Name + "\") [");
                        foreach (String ww in t.getInfluencedToolkits())
                        {
                            sb.Append("\"" + ww + "\" ");
                        }
                        sb.Append("] ");
                    }
                }
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getNAndMaxN(DateTime start, DateTime end)
        {
            StringBuilder sb = new StringBuilder(300);
            sb.Append("N:[");
            foreach (KeyValuePair<String, int> S in usableLocationDictionary)
            {
                relevantOrders[S.Value] = new List<Order>[productNames.Length];
                foreach (KeyValuePair<String, int> P in productDictionary)
                {
                    relevantOrders[S.Value][P.Value] = new List<Order>();
                    foreach (Order o in orders[S.Value][P.Value])
                    {
                        // list all the orders one should take into account
                        if (o.IsDueBetween(start, end))
                        {
                            relevantOrders[S.Value][P.Value].Add(o);
                        }
                    }
                    sb.Append("(\"" + S.Key + "\" \"" + P.Key + "\") " + relevantOrders[S.Value][P.Value].Count + " ");
                    if (maxN < relevantOrders[S.Value][P.Value].Count) maxN = relevantOrders[S.Value][P.Value].Count;
                }
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n" + "maxN: " + maxN + "\n";
        }

        private String getEpsilon()
        {
            StringBuilder sb = new StringBuilder(300);
            sb.Append("epsilon:[");
            foreach (KeyValuePair<String, int> S in usableLocationDictionary)
            {
                foreach (KeyValuePair<String, int> P in productDictionary)
                {
                    int count = 1;
                    foreach (Order o in relevantOrders[S.Value][P.Value])
                    {
                        sb.Append("(\"" + S.Key + "\" \"" + P.Key + "\" " + count++ + ") " + o.Amount + " ");
                    }
                }
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getGamma(DateTime start, double d)
        {
            StringBuilder sb = new StringBuilder(300);
            sb.Append("gamma:[");
            foreach (KeyValuePair<String, int> S in usableLocationDictionary)
            {
                foreach (KeyValuePair<String, int> P in productDictionary)
                {
                    int count = 1;
                    foreach (Order o in relevantOrders[S.Value][P.Value])
                    {
                        sb.Append("(\"" + S.Key + "\" \"" + P.Key + "\" " + count++ + ") " + o.getDueTimeslot(start, d) + " ");
                    }
                }
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getNu()
        {
            StringBuilder sb = new StringBuilder(300);
            sb.Append("nu:[");
            foreach (KeyValuePair<String, int> S in usableLocationDictionary)
            {
                foreach (KeyValuePair<String, int> P in productDictionary)
                {
                    int count = 1;
                    foreach (Order o in relevantOrders[S.Value][P.Value])
                    {
                        // at this time we have no data, so it is set to 0.
                        sb.Append("(\"" + S.Key + "\" \"" + P.Key + "\" " + count++ + ") " + 0 + " ");
                    }
                }
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getRho()
        {
            StringBuilder sb = new StringBuilder(300);
            sb.Append("rho:[");
            foreach (KeyValuePair<String, int> S in usableLocationDictionary)
            {
                foreach (MachineCB m in locations[S.Value].getMachines())
                {
                    if (m.CheckState != CheckState.Unchecked)
                    {
                        foreach (Toolkit t in usableToolkits)
                        {
                            // number of products produced per minute = Huebe ohne Stoerung * Qualitaetsrate
                            double rho = m.getProducts().First<ProductCB>().hoS * m.getProducts().First<ProductCB>().qualitaetsrate;
                            sb.Append("(\"" + m.Name + "\" \"" + t.Name + "\") " + rho.ToString().Replace(',','.') + " ");
                        }
                    }
                }
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getEta(double d)
        {
            StringBuilder sb = new StringBuilder(2000);
            sb.Append("eta:[");
            foreach (KeyValuePair<String, int> S1 in usableLocationDictionary)
            {
                foreach (KeyValuePair<String, int> S2 in usableLocationDictionary)
                {
                    foreach (Toolkit t in usableToolkits)
                    {
                        sb.Append("(\"" + S1.Key + "\" \"" + S2.Key + "\" \"" + t.Name + "\") " + Math.Ceiling(DauerWerkzeuglogistik[S1.Value][S2.Value] / (60 * d)) + " ");
                    }
                }
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getAlpha(double d)
        {
            StringBuilder sb = new StringBuilder(300);
            sb.Append("alpha:[");
            foreach (KeyValuePair<String, int> S1 in usableLocationDictionary)
            {
                foreach (KeyValuePair<String, int> S2 in usableLocationDictionary)
                {
                    sb.Append("(\"" + S1.Key + "\" \"" + S2.Key + "\") " + Math.Ceiling(DauerBauteillogistik[S1.Value][S2.Value] / (60 * d)) + " ");
                }
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getLambda()
        {
            // until we get any other data, lambda is set to 0
            return "lambda:" + 0 + "\n";
        }

        private String getLocOfMachine()
        {
            StringBuilder sb = new StringBuilder(300);
            sb.Append("LocOfMachine:[");
            foreach (KeyValuePair<String, int> S in usableLocationDictionary)
            {
                foreach (MachineCB m in locations[S.Value].getMachines())
                {
                    if (m.CheckState != CheckState.Unchecked)
                    {
                        sb.Append("(\"" + m.Name + "\") \"" + S.Key + "\"" + " ");
                    }
                }
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getMachinesOfLocation()
        {
            StringBuilder sb = new StringBuilder(300);
            sb.Append("MachinesOfLocation:[");
            foreach (KeyValuePair<String, int> S in usableLocationDictionary)
            {
                if (locations[S.Value].getMachines().Count > 0)
                {
                    sb.Append("(\"" + S.Key + "\") [");
                    foreach (MachineCB m in locations[S.Value].getMachines())
                    {
                        if (m.CheckState != CheckState.Unchecked)
                        {
                            sb.Append("\"" + m.Name + "\" ");
                        }
                    }
                    sb.Append("] ");
                }
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }

        private String getWProducer()
        {
            StringBuilder sb = new StringBuilder(300);
            sb.Append("WProducer:[");
            foreach (String p in productNames)
            {
                //first list all the elements of one list. To check if it is empty.
                //Mosel cannot read in empty lists.
                List<String> temp = new List<string>();
                foreach (Toolkit t in usableToolkits)
                {
                    if (t.isAbleToProduce(p)) temp.Add(t.Name);
                }
                if (temp.Count > 0)
                {
                    sb.Append("(\"" + p + "\") [");
                    foreach (String t in temp)
                    {
                        sb.Append("\"" + t + "\" ");
                    }
                    sb.Append("] ");
                }
            }
            String s = sb.ToString();
            s = s.TrimEnd(new char[] { ',', ' ' });
            return s + "]\n";
        }
    }
}