public static void SimulateToFile(MatrixProvider capabilitiesProvider, MatrixProvider contiguityProvider, MatrixProvider majorPowersProvider,
            MatrixProvider conflictProvider, string outputFile, string expectedAllianceFile, string conflictOutputFile, string srgOutputFile, int networkID, bool randomConflict, bool randomContig, bool randomMajorPower, bool outputDyadic, bool expectedAllianceDyadic, bool srgDyadic,
            MatrixProvider srgProvider, MatrixProvider dProvider, MatrixProvider jccProvider, MatrixProvider midProvider, MatrixProvider csProvider, MatrixProvider relProvider, int maxIter, bool overwrite, double br)
        {
            Matrix tmpContig = contiguityProvider.ReadNext(overwrite);
            SymmetricBinaryMatrix contiguity = tmpContig == null ? null : new SymmetricBinaryMatrix(tmpContig);
            Matrix initialCapabilities = capabilitiesProvider.ReadNext(overwrite);
            Vector majorPowers = majorPowersProvider.ReadNext(overwrite) as Vector;
            Matrix conflict = conflictProvider.ReadNext(overwrite);
            Matrix srg = srgProvider.ReadNext(overwrite);
            Matrix D = dProvider.ReadNext(overwrite);
            Matrix JCC = jccProvider.ReadNext(overwrite);
            Matrix MID = midProvider.ReadNext(overwrite);
            Matrix CS = csProvider.ReadNext(overwrite);
            Matrix REL = relProvider.ReadNext(overwrite);

            //int tryIntVar1 = srg.NetworkId;
            Matrix P = null;

            if (randomConflict)
            {
                P = Matrix.Zero(conflict.Rows, conflict.Cols);
                for (int i = 0; i < P.Rows; ++i)
                    for (int j = i + 1; j < P.Rows; ++j)
                        if (contiguity == null ? srg[i, j] > 0.0 : contiguity.GetValue(i, j))
                            P[i, j] = P[j, i] = RNG.RandomFloat(0.01, 0.03);
                        else
                            P[i, j] = P[j, i] = RNG.RandomFloat(0.002, 0.004);

                for (int i = 0; i < conflict.Rows; ++i)
                    for (int j = i + 1; j < conflict.Cols; ++j)
                        conflict[i, j] = conflict[j, i] = RNG.RandomBinary(P[i, j]);
            }

            if (randomContig && contiguity != null)
            {
                if (CS == null)
                {
                    contiguity.Clear();
                    int[] values = { 3, 4, 5 };
                    for (int row = 0; row < contiguity.Rows; ++row)
                    {
                        int count = RNG.Choose<int>(values);

                        count = Math.Min(count, contiguity.Cols);

                        for (int i = 0; i < count; ++i)
                        {
                            int which = RNG.RandomInt(contiguity.Cols);
                            if (contiguity[row, which] == 1)
                                --i;
                            contiguity[row, which] = 1;
                        }
                    }
                }
            }

            if (randomMajorPower)
            {
                int[] values = { 4, 5, 6 };
                int count = RNG.Choose<int>(values);

                count = Math.Min(count, majorPowers.Size);
                majorPowers.Clear();

                for (int i = 0; i < count; ++i)
                {
                    int which = RNG.RandomInt(majorPowers.Size);
                    if (majorPowers[which] == 1)
                        --i;
                    majorPowers[which] = 1;
                }
            }

            Matrix capabilities = initialCapabilities;
            if (initialCapabilities is Vector)
            {
                capabilities = Matrix.Zero(initialCapabilities.Rows, initialCapabilities.Cols);
                capabilities.SetDiagonalFromVector(initialCapabilities as Vector);
            }

            Matrix expectedAlliance = null;

            if (CS != null) // 5
            {
                Matrix SRGOutput = new Matrix(srg);
                Matrix EAOutput = null;
                networkID = srg.NetworkId;
                //expectedAlliance = SimulateNAPTStageOne(capabilities, srg, contiguity, MID, D, JCC, CS, REL, ref SRGOutput, ref EAOutput, expectedAllianceFile, outputFile, overwrite, expectedAllianceDyadic, outputDyadic, networkID);
                SimulateNAPTStageOne(capabilities, srg, contiguity, MID, D, JCC, CS, REL, ref SRGOutput, ref EAOutput, expectedAllianceFile, outputFile, overwrite, expectedAllianceDyadic, outputDyadic, networkID);

                /*
                if (!outputDyadic)
                    MatrixWriter.WriteMatrixToMatrixFile(expectedAlliance, outputFile, overwrite);
                else
                    MatrixWriter.WriteMatrixToDyadicFile(expectedAlliance, outputFile, overwrite);
                */
                if (srgOutputFile != "")
                {
                    if (!srgDyadic)
                        MatrixWriter.WriteMatrixToMatrixFile(SRGOutput, srgOutputFile, overwrite);
                    else
                        MatrixWriter.WriteMatrixToDyadicFile(SRGOutput, srgOutputFile, overwrite);
                }

                return;
            }
            else if (conflict == null && D != null) // 4
                expectedAlliance = SimulateSimplifiedLiberalStageOne(capabilities, srg, MID, D, JCC, outputFile, br);
            else if (MID != null) // 3
                expectedAlliance = SimulateSimplifiedRealistStageOne(capabilities, srg, MID, outputFile, br);
            else if (D == null) // 1
                expectedAlliance = SimulateRealistStageOne(contiguity, capabilities, srg, majorPowers, br);
            else // 2
                expectedAlliance = SimulateLiberalStageOne(contiguity, capabilities, srg, majorPowers, D, JCC, br);

            //if (outputDyadic) MatrixWriter.WriteDyadicHeader(outputFile);
            int editedNetworkId = srg.NetworkId;

            expectedAlliance.NetworkId = int.Parse(editedNetworkId + "01");   // Problem encountered 2/15/11
            expectedAlliance.CopyLabelsFrom(capabilities);
            srg.NetworkId = int.Parse(editedNetworkId + "01");
            srg.CopyLabelsFrom(capabilities);

            if (!outputDyadic)
                MatrixWriter.WriteMatrixToMatrixFile(expectedAlliance, outputFile, overwrite);
            else
                MatrixWriter.WriteMatrixToDyadicFile(expectedAlliance, outputFile, overwrite);
            if (srgOutputFile != "")
            {
                if (!srgDyadic)
                    MatrixWriter.WriteMatrixToMatrixFile(srg, srgOutputFile, overwrite);
                else
                    MatrixWriter.WriteMatrixToDyadicFile(srg, srgOutputFile, overwrite);
            }
            if (conflict != null)
            {
                conflict.NetworkId = expectedAlliance.NetworkId;
                if (!string.IsNullOrEmpty(conflictOutputFile) && !conflictProvider.IsFromFile)
                {

                    MatrixWriter.WriteMatrixToMatrixFile(conflict, conflictOutputFile, overwrite);

                }
            }

            if (CS != null) ; // 5
                //  expectedAlliance = SimulateNAPTStageTwo(...)
            else if (conflict == null && D != null) // 4
                expectedAlliance = SimulateSimplifiedLiberalStageTwo(capabilities, srg, MID, D, JCC, expectedAlliance, outputFile, srgOutputFile, editedNetworkId /*networkID*/, outputDyadic, srgDyadic, maxIter, br);
            else if (MID != null) // 3
                expectedAlliance = SimulateSimplifiedRealistStageTwo(capabilities, srg, MID, expectedAlliance, outputFile, srgOutputFile, networkID, outputDyadic, srgDyadic, maxIter, br);
            else if (D == null) // 1
                expectedAlliance = SimulateRealistStageTwo(conflict, expectedAlliance, capabilities, br);
            else // 2
                expectedAlliance = SimulateLiberalStageTwo(conflict, expectedAlliance, capabilities, D, JCC, br);

            if (MID == null) //if not simplified version
            {
                expectedAlliance.NetworkId = int.Parse(editedNetworkId + "02");
                expectedAlliance.CopyLabelsFrom(capabilities);

                if (!outputDyadic)
                    MatrixWriter.WriteMatrixToMatrixFile(expectedAlliance, outputFile, overwrite);
                else
                    MatrixWriter.WriteMatrixToDyadicFile(expectedAlliance, outputFile, overwrite);
            }

            if (conflict != null) //if conflict file exists
            {
                P = new Matrix(conflict);
                for (int i = 0; i < P.Rows; ++i)
                {
                    for (int j = i + 1; j < P.Cols; ++j)
                    {
                        P[j, i] = P[i, j] = RNG.RandomFloat(0.002, 0.004);
                        if (conflict[i, j] == 1)
                            P[j, i] = P[i, j] = RNG.RandomFloat(0.08, 0.25);
                        if (expectedAlliance[i, j] == 0.5)
                            P[j, i] = P[i, j] = 1 / ((double)P.Rows * (double)(P.Rows - 1));
                        else if (expectedAlliance[i, j] == 1)
                            P[j, i] = P[i, j] = 0.5 / ((double)P.Rows * (double)(P.Rows - 1));
                    }
                }

                conflict = new Matrix(P.Rows);
                conflict.RowLabels.CopyFrom(expectedAlliance.RowLabels);
                conflict.ColLabels.CopyFrom(expectedAlliance.ColLabels);
                for (int i = 0; i < conflict.Rows; ++i)
                    for (int j = i + 1; j < conflict.Cols; ++j)
                        conflict[i, j] = conflict[j, i] = RNG.RandomBinary(P[i, j]);

                if (D == null)
                    expectedAlliance = SimulateRealistStageTwo(conflict, expectedAlliance, capabilities, br);
                else
                    expectedAlliance = SimulateLiberalStageTwo(conflict, expectedAlliance, capabilities, D, JCC, br);

                expectedAlliance.NetworkId = int.Parse(editedNetworkId + "03");
                expectedAlliance.CopyLabelsFrom(capabilities);

                if (!outputDyadic)
                    MatrixWriter.WriteMatrixToMatrixFile(expectedAlliance, outputFile, overwrite);
                else
                    MatrixWriter.WriteMatrixToDyadicFile(expectedAlliance, outputFile, overwrite);

                conflict.NetworkId = expectedAlliance.NetworkId;
                if (!string.IsNullOrEmpty(conflictOutputFile) && !conflictProvider.IsFromFile)
                {

                    if (!outputDyadic)
                        MatrixWriter.WriteMatrixToMatrixFile(expectedAlliance, outputFile, overwrite);
                    else
                        MatrixWriter.WriteMatrixToDyadicFile(expectedAlliance, outputFile, overwrite);
                }
            }//if conflict file exists
        }