Reply – Re: Help in Java (netbeans & eclipse)
Your Name
Subject
Message
or Cancel
In Reply To
Re: Help in Java (netbeans & eclipse)
— by tamb20 tamb20
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTabbedPane;

import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.XYPlot;
import org.jfree.data.xy.XYDataset;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;

public class DataProcessor extends JFrame {

        private Map<Integer, Integer> idMappings = new HashMap<Integer, Integer>();
        private int pointInConcern;
        private double interval = 5;
        private int intervalCount = 100;
        private List<TetraHedron> allTetrahedrons = new ArrayList<>();
        private List<TetraHedron> tetrahedrons = new ArrayList<>();
        private double youngsModulus; // Represented by E
        private double poissonRatio; // Represented by v
        private int selectedPointId = 0;
        private double volume = 0.0;
        private double[] force = new double[3];
        private double[] newPoint = new double[3];

        double[][][] newF = new double[intervalCount + 1][tetrahedrons.size() * 12][1];

        private int temppp;

        private double[][] elasticityMatrix; // Represented by D

        private double[][] AG;

        List<double[][]> allK = new ArrayList<double[][]>();

        /**
         * @param args
         */
        public static void main(String[] args) {
                DataProcessor dataProcessor = new DataProcessor();
                dataProcessor.process();

        }

        public void process() {

                selectedPointId = 0;
                double row = 1;
                double lambda = calculateLambda(youngsModulus, poissonRatio);
                double mue = calculateMue(youngsModulus, poissonRatio);
                elasticityMatrix = calculateElasticityMatrix(lambda, mue);

                double[][] Ksum = new double[tetrahedrons.size() * 12][tetrahedrons
                                .size() * 12];
                for (int i = 0; i < 3 * tetrahedrons.size(); i++) {
                        for (int j = 0; j < 3 * tetrahedrons.size(); j++) {
                                Ksum[i][j] = 0.0;
                        }
                }

                for (TetraHedron t : tetrahedrons) {
                        double[][] s = getStiffnessMatrix(t, false);
                        assemble(Ksum, s, t.getPoints()[0].getId(),
                                        t.getPoints()[1].getId(), t.getPoints()[2].getId(),
                                        t.getPoints()[3].getId());
                        allK.add(s);
                }

                double[] F = new double[tetrahedrons.size() * 12];
                for (int i = 0; i < F.length;) {
                        F[i++] = force[0];
                        F[i++] = force[1];
                        F[i++] = force[2];
                }

                double[] U = solve(Ksum, F);

                int m = 0;
                for (TetraHedron t : tetrahedrons) {
                        Point[] points = new Point[4];
                        points[0] = new Point(U[(m * 3) + 0], U[(m * 3) + 1],
                                        U[(m * 3) + 2], t.getPoints()[0].getId());
                        m++;
                        points[1] = new Point(U[(m * 3) + 0], U[(m * 3) + 1],
                                        U[(m * 3) + 2], t.getPoints()[1].getId());
                        m++;
                        points[2] = new Point(U[(m * 3) + 0], U[(m * 3) + 1],
                                        U[(m * 3) + 2], t.getPoints()[2].getId());
                        m++;
                        points[3] = new Point(U[(m * 3) + 0], U[(m * 3) + 1],
                                        U[(m * 3) + 2], t.getPoints()[3].getId());
                        m++;

                        t.setPoints(0, points);
                }

                double[][] UTransformed = new double[U.length][1];

                for (int i = 0; i < U.length; i++) {

                        UTransformed[i][0] = U[i];
                }

                double[][] Fall = new double[tetrahedrons.size()][12];
                for (int i = 0; i < tetrahedrons.size(); i++) {
                        for (int j = 0; j < 12; j++) {
                                Fall[i][j] = 0.0;
                        }
                }

                double[][] Udash = new double[tetrahedrons.size() * 12][1];
                double[][] Fdash = new double[tetrahedrons.size() * 12][1];

                for (int i = 0; i < tetrahedrons.size() * 12; i++) {
                        Udash[i][0] = U[i];
                        Fdash[i][0] = F[i];
                }

                for (int i = 0; i < tetrahedrons.size(); i++) {

                        double[][] USelected = new double[12][1];
                        USelected[0][0] = UTransformed[((tetrahedrons.get(i).getPoints()[0]
                                        .getId()) * 3) + 0][0];
                        USelected[1][0] = UTransformed[((tetrahedrons.get(i).getPoints()[0]
                                        .getId()) * 3) + 1][0];
                        USelected[2][0] = UTransformed[((tetrahedrons.get(i).getPoints()[0]
                                        .getId()) * 3) + 2][0];
                        USelected[3][0] = UTransformed[((tetrahedrons.get(i).getPoints()[1]
                                        .getId()) * 3) + 0][0];
                        USelected[4][0] = UTransformed[((tetrahedrons.get(i).getPoints()[1]
                                        .getId()) * 3) + 1][0];
                        USelected[5][0] = UTransformed[((tetrahedrons.get(i).getPoints()[1]
                                        .getId()) * 3) + 2][0];
                        USelected[6][0] = UTransformed[((tetrahedrons.get(i).getPoints()[2]
                                        .getId()) * 3) + 0][0];
                        USelected[7][0] = UTransformed[((tetrahedrons.get(i).getPoints()[2]
                                        .getId()) * 3) + 1][0];
                        USelected[9][0] = UTransformed[((tetrahedrons.get(i).getPoints()[2]
                                        .getId()) * 3) + 2][0];
                        USelected[9][0] = UTransformed[((tetrahedrons.get(i).getPoints()[3]
                                        .getId()) * 3) + 0][0];
                        USelected[10][0] = UTransformed[((tetrahedrons.get(i).getPoints()[3]
                                        .getId()) * 3) + 1][0];
                        USelected[11][0] = UTransformed[((tetrahedrons.get(i).getPoints()[3]
                                        .getId()) * 3) + 2][0];

                        double[][] temp = multiply(allK.get(i), USelected);
                        for (int j = 0; j < 12; j++) {
                                Fall[i][j] = temp[j][0];
                        }
                }

                newF[0] = Fall;

                double[][] M = new double[tetrahedrons.size() * 12][tetrahedrons.size() * 12];
                for (int i = 0; i < M.length; i++) {
                        for (int j = 0; j < M.length; j++) {
                                M[i][j] = 0.0;
                        }
                }

                M[0][0] = 2.0;

                for (int j = 1; j < M.length; j++) {
                        if (j % 3 == 0) {
                                M[0][j] = 1.0;
                        }
                }

                for (int i = 1; i < M.length; i++) {
                        for (int j = 1; j < M.length; j++) {
                                M[i][j] = M[i - 1][j - 1];
                        }
                        M[i][0] = M[i - 1][M.length - 1];
                }

                M = multiply(M, (row * volume / 20));

                double cK = 1.0;
                double cM = 1.0;

                double[][] C = sum(multiply(Ksum, cK), multiply(M, cM));

                for (TetraHedron t : tetrahedrons) {
                        t.getStrain().put(0, getStiffnessMatrix(t, true));
                        t.getStress().put(0,
                                        multiply(elasticityMatrix, t.getStrain().get(0)));
                }

                double[][] velocity = new double[tetrahedrons.size() * 12][1];
                double[][] acceleration = new double[tetrahedrons.size() * 12][1];

                for (int t = 1; t <= intervalCount; t++) {

                        temppp = t;

                        double delta = 0.05;
                        double alpha = 0.25 * (0.5 + delta) * (0.5 + delta);
                        double a0 = 1 / (alpha * ((t + 1) * interval) * ((t + 1) * interval));
                        double a1 = delta / (alpha * ((t + 1) * interval));
                        double a2 = 1 / (alpha * ((t + 1) * interval));
                        double a3 = (1 / (2 * alpha)) - 1;
                        double a4 = (delta / alpha) - 1;
                        double a5 = ((t + 1) * interval / 2) * ((delta / alpha) - 2);
                        double a6 = ((t + 1) * interval) * (1 - delta);
                        double a7 = (t + 1) * interval * delta;

                        double[][] effectiveStiffnessMatrix = sum(Ksum,
                                        sum(multiply(M, a0), multiply(C, a1)));

                        double[][] term1 = multiply(
                                        M,
                                        sum(sum(multiply(Udash, a0), multiply(velocity, a2)),
                                                        multiply(acceleration, a3)));
                        double[][] term2 = multiply(
                                        C,
                                        sum(sum(multiply(Udash, a1), multiply(velocity, a4)),
                                                        multiply(acceleration, a5)));

                        double[][] R = sum(sum(Fdash, term1), term2);

                        newF[t] = R;

                        double[] Rdash = new double[R.length];

                        for (int i = 0; i < Rdash.length; i++) {
                                Rdash[i] = R[i][0];
                        }

                        double[] newU = solve(effectiveStiffnessMatrix, Rdash);
                        double[][] newUdash = new double[tetrahedrons.size() * 12][1];
                        for (int i = 0; i < tetrahedrons.size() * 12; i++) {
                                newUdash[i][0] = newU[i];
                        }

                        m = 0;
                        for (TetraHedron eachT : tetrahedrons) {
                                Point[] points = new Point[4];
                                points[0] = new Point(newU[(m * 3) + 0], newU[(m * 3) + 1],
                                                newU[(m * 3) + 2], eachT.getPoints()[0].getId());
                                m++;
                                points[1] = new Point(newU[(m * 3) + 0], newU[(m * 3) + 1],
                                                newU[(m * 3) + 2], eachT.getPoints()[1].getId());
                                m++;
                                points[2] = new Point(newU[(m * 3) + 0], newU[(m * 3) + 1],
                                                newU[(m * 3) + 2], eachT.getPoints()[2].getId());
                                m++;
                                points[3] = new Point(newU[(m * 3) + 0], newU[(m * 3) + 1],
                                                newU[(m * 3) + 2], eachT.getPoints()[3].getId());
                                m++;

                                eachT.setPoints(t, points);
                        }

                        double[][] newAcceleration = sum(
                                        sum(multiply(sum(multiply(Udash, -1.0), newUdash), a0),
                                                        multiply(velocity, -1.0 * a2)),
                                        multiply(acceleration, -1.0 * a3));
                        double[][] newVelocity = sum(
                                        sum(velocity, multiply(acceleration, a6)),
                                        multiply(newAcceleration, a7));

                        velocity = newVelocity;
                        acceleration = newAcceleration;

                        for (TetraHedron eachT : tetrahedrons) {
                                eachT.getStrain().put(t, getStiffnessMatrix(eachT, true));
                                eachT.getStress()
                                                .put(t,
                                                                sum(eachT.getStress().get(t - 1),
                                                                                multiply(
                                                                                                elasticityMatrix,
                                                                                                sum(eachT.getStrain().get(t),
                                                                                                                multiply(eachT
                                                                                                                                .getStrain()
                                                                                                                                .get(t - 1),
                                                                                                                                -1.0)))));
                        }

                }

                System.out.println("Strain");
                for (Integer t : tetrahedrons.get(0).getStrain().keySet()) {
                        System.out.println("\t"
                                        + tetrahedrons.get(0).getStrain().get(t)[0][0] + "\t"
                                        + tetrahedrons.get(0).getStrain().get(t)[1][0] + "\t"
                                        + tetrahedrons.get(0).getStrain().get(t)[2][0] + "\t"
                                        + tetrahedrons.get(0).getStrain().get(t)[3][0] + "\t"
                                        + tetrahedrons.get(0).getStrain().get(t)[4][0] + "\t"
                                        + tetrahedrons.get(0).getStrain().get(t)[5][0]);

                }

                System.out.println("Stress");

                for (Integer t : tetrahedrons.get(0).getStress().keySet()) {
                        System.out.println("\t"
                                        + tetrahedrons.get(0).getStress().get(t)[0][0] + "\t"
                                        + tetrahedrons.get(0).getStress().get(t)[1][0] + "\t"
                                        + tetrahedrons.get(0).getStress().get(t)[2][0] + "\t"
                                        + tetrahedrons.get(0).getStress().get(t)[3][0] + "\t"
                                        + tetrahedrons.get(0).getStress().get(t)[4][0] + "\t"
                                        + tetrahedrons.get(0).getStress().get(t)[5][0]);

                }

        }

        /**
         * @return
         */
        private XYDataset[] createDataset() {

                final XYSeries series1 = new XYSeries("Stress vs Strain");
                final XYSeries series2 = new XYSeries("Force vs Displacement");
                final XYSeries series3 = new XYSeries("Force vs Time");
                for (Integer t : tetrahedrons.get(0).getStrain().keySet()) {
                        series1.add(tetrahedrons.get(0).getStrain().get(t)[0][0],
                                        tetrahedrons.get(0).getStress().get(t)[0][0]);
                        series3.add(1.0 * t, newF[t][0][0]);
                        series2.add(tetrahedrons.get(0)
                                        .getHistoricalPositions().get(t)[0].getX(),newF[t][0][0]);
                }

                final XYSeriesCollection dataset1 = new XYSeriesCollection();
                final XYSeriesCollection dataset2 = new XYSeriesCollection();
                final XYSeriesCollection dataset3 = new XYSeriesCollection();
                dataset1.addSeries(series1);
                dataset2.addSeries(series2);
                dataset3.addSeries(series3);

                return new XYDataset[] { dataset1, dataset2, dataset3 };

        }

        /**
         * @param dataset
         * @return
         */
        private JFreeChart createChart(final XYDataset dataset) {

                final JFreeChart chart = ChartFactory.createXYLineChart("Title",
                                "X Axis", "Y Axis", dataset);
                final XYPlot plot = chart.getXYPlot();
                return chart;

        }

        /**
         * @param ad
         * @param ad1
         * @return
         */
        public double[] solve(double ad[][], double ad1[]) {
                if (ad == null || ad1 == null || ad.length != ad1.length
                                || ad[0].length != ad1.length)
                        return null;
                double ad2[][] = (double[][]) ad.clone();
                double ad3[] = (double[]) ad1.clone();
                int i = ad3.length;
                double ad4[] = new double[i];
                for (int j = 0; j < i - 1; j++)
                        if (ad2[j][j] != 0.0D) {
                                for (int l = j + 1; l < i; l++) {
                                        double d = ad2[l][j] / ad2[j][j];
                                        for (int j1 = j; j1 < i; j1++)
                                                ad2[l][j1] = ad2[l][j1] - ad2[j][j1] * d;

                                        ad3[l] = ad3[l] - ad3[j] * d;
                                }

                        }

                for (int k = i - 1; k >= 0; k--) {
                        ad4[k] = 0.0D;
                        for (int i1 = k + 1; i1 < i; i1++)
                                ad4[k] = ad4[k] - ad2[k][i1] * ad4[i1];

                        if (ad2[k][k] == 0.0D)
                                ad2[k][k] = 0.10000000000000001D;
                        ad4[k] = (ad4[k] + ad3[k]) / ad2[k][k];
                }

                return ad4;

        }

        private double[][] getStiffnessMatrix(TetraHedron t, boolean justStrain) {

                double[][] displacementDifferentiationMatrix; // Represented by B
                double[][] shapefunctionIdentityMatrix; // Represented by N
                double[][] displacementIdentityMatrix; // Represented by T
                double[][] relativeDisplacementMatrix; // Represented by G
                double[][] nonLinearDisplacementMatrix; // Represented by A
                double[][] linearDifferentialOperator; // Represented by S

                TetrahedronShapeFunction shapeFunctionCalculator = new TetrahedronShapeFunction();
                Point originalPoint = tetrahedrons.get(0).getPoints()[selectedPointId];
                double[] shapeFunctions = shapeFunctionCalculator.getShapeFunction(
                                tetrahedrons.get(0), originalPoint);

                linearDifferentialOperator = multiply(
                                new double[][] {
                                                { shapeFunctionCalculator.getBetas()[selectedPointId],
                                                                0, 0 },
                                                {
                                                                0,
                                                                shapeFunctionCalculator.getGammas()[selectedPointId],
                                                                0 },
                                                {
                                                                0,
                                                                0,
                                                                shapeFunctionCalculator.getDeltas()[selectedPointId] },
                                                {
                                                                shapeFunctionCalculator.getGammas()[selectedPointId],
                                                                shapeFunctionCalculator.getBetas()[selectedPointId],
                                                                0 },
                                                {
                                                                0,
                                                                shapeFunctionCalculator.getDeltas()[selectedPointId],
                                                                shapeFunctionCalculator.getGammas()[selectedPointId] },
                                                {
                                                                shapeFunctionCalculator.getDeltas()[selectedPointId],
                                                                0,
                                                                shapeFunctionCalculator.getBetas()[selectedPointId] } },
                                (1.0 / (6.0 * shapeFunctionCalculator.getVolume())));

// double[][] Su = multiply(linearDifferentialOperator, new double[][] {
// { t.getPoints()[selectedPointId].getX() },
// { t.getPoints()[selectedPointId].getY() },
// { t.getPoints()[selectedPointId].getZ() } });

                double[][] Su = multiply(linearDifferentialOperator, new double[][] {
                                { newPoint[0] },
                                { newPoint[1] },
                                { newPoint[2] } });

                displacementDifferentiationMatrix = multiply(
                                calculateDisplacementDifferentiationMatrix(shapeFunctionCalculator),
                                1.0 / (6 * shapeFunctionCalculator.getVolume()));
                shapefunctionIdentityMatrix = calculateShapeFunctionIdentityMatrix(shapeFunctions);

                double[][] elementDisplacement = multiply(shapefunctionIdentityMatrix,
                                new double[][] { { t.getPoints()[0].getX() },
                                                { t.getPoints()[0].getY() },
                                                { t.getPoints()[0].getZ() },
                                                { t.getPoints()[1].getX() },
                                                { t.getPoints()[1].getY() },
                                                { t.getPoints()[1].getZ() },
                                                { t.getPoints()[2].getX() },
                                                { t.getPoints()[2].getY() },
                                                { t.getPoints()[2].getZ() },
                                                { t.getPoints()[3].getX() },
                                                { t.getPoints()[3].getY() },
                                                { t.getPoints()[3].getZ() } }); // should be 3x1 ...
                                                                                                                // small u

                displacementIdentityMatrix = calculateDisplacementIdentityMatrix(shapeFunctionCalculator);
                relativeDisplacementMatrix = multiply(displacementIdentityMatrix,
                                shapefunctionIdentityMatrix);

                nonLinearDisplacementMatrix = generateNonLinearDisplacementMatrix(shapeFunctionCalculator);

                AG = multiply(nonLinearDisplacementMatrix, relativeDisplacementMatrix);

                double[][] theta = multiply(displacementIdentityMatrix,
                                multiply(elementDisplacement, (1.1 * temppp)));

                double[][] ATheta = multiply(nonLinearDisplacementMatrix, theta);

                double[][] strain = sum(multiply(Su, 1), multiply(ATheta, 0.5));
                if (justStrain) {
                        return strain;
                }

                double[][] elementStiffness1 = multiply(
                                multiply(
                                                multiply(transpose(displacementDifferentiationMatrix),
                                                                elasticityMatrix),
                                                displacementDifferentiationMatrix),
                                shapeFunctionCalculator.getVolume());
                double[][] elementStiffness2 = multiply(
                                multiply(transpose(displacementDifferentiationMatrix), AG),
                                0.5 * shapeFunctionCalculator.getVolume());
                double[][] elementStiffness = sum(elementStiffness1, elementStiffness2);

                volume = volume + shapeFunctionCalculator.getVolume();

                return elementStiffness;
        }

        /**
         * @return
         */
        private double[][] generateNonLinearDisplacementMatrix(
                        TetrahedronShapeFunction shapeFunctionCalculator) {
                double[][] returnValue = new double[6][9];
                for (int i = 0; i < 6; i++) {
                        for (int j = 0; j < 9; j++) {
                                returnValue[i][j] = 0.0;
                        }
                }

                int[] indices = new int[3];
                int j = 0;
                for (int i = 0; i < 4; i++) {
                        if (i != selectedPointId) {
                                indices[j] = i;
                                j++;
                        }
                }

                returnValue[0][0] = shapeFunctionCalculator.getBetas()[indices[0]];
                returnValue[1][4] = shapeFunctionCalculator.getGammas()[indices[1]];
                returnValue[2][8] = shapeFunctionCalculator.getDeltas()[indices[2]];
                returnValue[3][1] = shapeFunctionCalculator.getGammas()[indices[0]];
                returnValue[3][3] = shapeFunctionCalculator.getBetas()[indices[1]];
                returnValue[4][5] = shapeFunctionCalculator.getDeltas()[indices[1]];
                returnValue[4][7] = shapeFunctionCalculator.getGammas()[indices[2]];
                returnValue[5][2] = shapeFunctionCalculator.getDeltas()[indices[0]];
                returnValue[5][6] = shapeFunctionCalculator.getBetas()[indices[2]];

                return returnValue;
        }

        /**
         * @return
         */
        private double[][] calculateDisplacementIdentityMatrix(
                        TetrahedronShapeFunction shapeFunctionCalculator) {
                double[][] returnValue = new double[9][3];
                for (int i = 0; i < 9; i++) {
                        for (int j = 0; j < 3; j++) {
                                returnValue[i][j] = 0.0;
                        }
                }

                returnValue[0][0] = shapeFunctionCalculator.getBetas()[selectedPointId];
                returnValue[1][1] = shapeFunctionCalculator.getBetas()[selectedPointId];
                returnValue[2][2] = shapeFunctionCalculator.getBetas()[selectedPointId];

                returnValue[3][0] = shapeFunctionCalculator.getGammas()[selectedPointId];
                returnValue[4][1] = shapeFunctionCalculator.getGammas()[selectedPointId];
                returnValue[5][2] = shapeFunctionCalculator.getGammas()[selectedPointId];

                returnValue[6][0] = shapeFunctionCalculator.getDeltas()[selectedPointId];
                returnValue[7][1] = shapeFunctionCalculator.getDeltas()[selectedPointId];
                returnValue[8][2] = shapeFunctionCalculator.getDeltas()[selectedPointId];

                return multiply(returnValue,
                                (1.0 / (6 * shapeFunctionCalculator.getVolume())));
        }

        /**
         * @return
         */
        private double[][] calculateShapeFunctionIdentityMatrix(
                        double[] shapeFunctions) {

                double[][] returnValue = new double[3][12];
                for (int i = 0; i < 3; i++) {
                        for (int j = 0; j < 12; j++) {
                                returnValue[i][j] = 0.0;
                        }
                }

                returnValue[0][0] = shapeFunctions[0];
                returnValue[1][1] = shapeFunctions[0];
                returnValue[2][2] = shapeFunctions[0];

                returnValue[0][3] = shapeFunctions[1];
                returnValue[1][4] = shapeFunctions[1];
                returnValue[2][5] = shapeFunctions[1];

                returnValue[0][6] = shapeFunctions[2];
                returnValue[1][7] = shapeFunctions[2];
                returnValue[2][8] = shapeFunctions[2];

                returnValue[0][9] = shapeFunctions[3];
                returnValue[1][10] = shapeFunctions[3];
                returnValue[2][11] = shapeFunctions[3];

                return returnValue;
        }

        private double[][] calculateDisplacementDifferentiationMatrix(
                        TetrahedronShapeFunction shapeFunctionCalculator) {

                double[][] returnValue = new double[6][12];
                for (int i = 0; i < 6; i++) {
                        for (int j = 0; j < 12; j++) {
                                returnValue[i][j] = 0.0;
                        }
                }

                for (int i = 0; i < 4; i++) {
                        returnValue[0][(i * 3) + 0] = shapeFunctionCalculator.getBetas()[i];
                        returnValue[1][(i * 3) + 1] = shapeFunctionCalculator.getGammas()[i];
                        returnValue[2][(i * 3) + 2] = shapeFunctionCalculator.getDeltas()[i];
                        returnValue[3][(i * 3) + 0] = shapeFunctionCalculator.getGammas()[i];
                        returnValue[3][(i * 3) + 1] = shapeFunctionCalculator.getBetas()[i];
                        returnValue[4][(i * 3) + 1] = shapeFunctionCalculator.getDeltas()[i];
                        returnValue[4][(i * 3) + 2] = shapeFunctionCalculator.getGammas()[i];
                        returnValue[5][(i * 3) + 0] = shapeFunctionCalculator.getDeltas()[i];
                        returnValue[5][(i * 3) + 2] = shapeFunctionCalculator.getBetas()[i];
                }

                return returnValue;
        }

        /**
         * @param lambda
         * @param mue
         * @return
         */
        private double[][] calculateElasticityMatrix(double lambda, double mue) {
                double[][] returnValue = new double[6][6];
                for (int i = 0; i < 6; i++) {
                        for (int j = 0; j < 6; j++) {
                                returnValue[i][j] = 0.0;
                        }
                }

                double term = lambda + (2 * mue);
                returnValue[0][0] = term;
                returnValue[1][1] = term;
                returnValue[2][2] = term;

                returnValue[0][1] = lambda;
                returnValue[0][2] = lambda;
                returnValue[1][0] = lambda;
                returnValue[1][2] = lambda;
                returnValue[2][0] = lambda;
                returnValue[2][1] = lambda;

                returnValue[3][3] = mue;
                returnValue[4][4] = mue;
                returnValue[5][5] = mue;

                return returnValue;
        }

        private double calculateLambda(double E, double v) {

                return (E * v) / ((1 + v) * (1 - (2 * v)));
        }

        private double calculateMue(double E, double v) {
                return (E) / ((2) * (1 + (2 * v)));
        }

        private Vector getAppliedForce() {
                return new Vector(1, 0, 0);
        }

        private Vector getBoundaryConditions() {
                return new Vector(1, 0, 0);
        }

        public void loadData(TetraHedronVolumeDataPopulator meshData,
                        int pointInConcern, double[] newPosition, double[] Force, double y,
                        double p) {

                this.youngsModulus = y;
                this.poissonRatio = p;
                this.force = Force;
                this.newPoint = newPosition;

                this.pointInConcern = pointInConcern;
                int s1 = meshData.getTriangleNum();
                int[][] s2 = meshData.getTriangleData();
                int s3 = meshData.getVertexNum();
                double[][] s4 = meshData.getVertex();
                int id = 0;

                List<Point> allPoints = new ArrayList<>();
                for (int i = 0; i < s3; i++) {
                        allPoints.add(new Point(s4[i][0], s4[i][1], s4[i][2], i));
                }

                for (int i = 0; i < s1; i++) {
                        TetraHedron t = new TetraHedron(allPoints.get(s2[i][0]),
                                        allPoints.get(s2[i][1]), allPoints.get(s2[i][2]),
                                        allPoints.get(s2[i][3]));
                        allTetrahedrons.add(t);

                        if (s2[i][0] == pointInConcern || s2[i][1] == pointInConcern
                                        || s2[i][2] == pointInConcern || s2[i][3] == pointInConcern) {

                                for (int j = 0; j < 4; j++) {
                                        if (!idMappings.containsKey(t.getPoints()[j].getId())) {
                                                idMappings.put(t.getPoints()[j].getId(), id++);
                                        }
                                }

                                Point point0 = new Point(t.getPoints()[0].getX(),
                                                t.getPoints()[0].getY(), t.getPoints()[0].getZ(),
                                                idMappings.get(t.getPoints()[0].getId()));
                                Point point1 = new Point(t.getPoints()[1].getX(),
                                                t.getPoints()[1].getY(), t.getPoints()[1].getZ(),
                                                idMappings.get(t.getPoints()[1].getId()));
                                Point point2 = new Point(t.getPoints()[2].getX(),
                                                t.getPoints()[2].getY(), t.getPoints()[2].getZ(),
                                                idMappings.get(t.getPoints()[2].getId()));
                                Point point3 = new Point(t.getPoints()[3].getX(),
                                                t.getPoints()[3].getY(), t.getPoints()[3].getZ(),
                                                idMappings.get(t.getPoints()[3].getId()));

                                tetrahedrons
                                                .add(new TetraHedron(point0, point1, point2, point3));
                        }
                }
        }

        private void loadTestData() {
                Point p0 = new Point(-4.286024570, 7.582150460, -2.571624280, 0);
                Point p1 = new Point(-5.561186790, 6.248299120, -3.544672010, 1);
                Point p2 = new Point(-4.923605440, 6.915225030, -3.058148150, 2);
                Point p3 = new Point(-5.596092700, 7.658648970, -1.979978200, 3);
                Point p4 = new Point(-5.578639980, 6.953474040, -2.762325050, 4);
                Point p5 = new Point(-6.699521540, 6.046098710, -3.274888280, 5);
                Point p6 = new Point(-6.147807120, 6.852373600, -2.627433300, 6);
                Point p7 = new Point(-4.471798900, 6.164323810, -3.749437090, 7);
                Point p8 = new Point(-3.678542850, 8.107747080, -1.605524780, 8);
                Point p9 = new Point(-4.637318130, 7.883197780, -1.792751550, 9);
                Point p10 = new Point(-6.516149040, 4.549613000, -4.341012950, 10);
                Point p11 = new Point(-6.038668160, 5.398956300, -3.942842480, 11);
                Point p12 = new Point(-7.392597200, 6.445587640, -2.368927480, 12);
                Point p13 = new Point(-6.494345190, 7.052118300, -2.174452780, 13);
                Point p14 = new Point(-3.316689970, 7.464766030, -2.778481250, 14);
                Point p15 = new Point(-5.556344990, 4.681081300, -4.552515980, 15);

                TetraHedron t1 = new TetraHedron(p0, p1, p2, p3);
                TetraHedron t2 = new TetraHedron(p4, p5, p6, p7);
                TetraHedron t3 = new TetraHedron(p8, p9, p10, p11);
                TetraHedron t4 = new TetraHedron(p12, p13, p14, p15);

                tetrahedrons.add(t1);
                tetrahedrons.add(t2);
                tetrahedrons.add(t3);
                tetrahedrons.add(t4);
        }

        public double[][] multiply(double[][] A, double[][] B) {
                int mA = A.length;
                int nA = A[0].length;
                int mB = B.length;
                int nB = B[0].length;
                if (nA != mB)
                        throw new RuntimeException("Illegal matrix dimensions.");
                double[][] C = new double[mA][nB];
                for (int i = 0; i < mA; i++)
                        for (int j = 0; j < nB; j++)
                                for (int k = 0; k < nA; k++)
                                        C[i][j] += (A[i][k] * B[k][j]);
                return C;
        }

        public double[][] multiply(double[][] A, double factor) {
                int mA = A.length;
                int nA = A[0].length;
                double[][] result = new double[mA][nA];
                for (int i = 0; i < mA; i++) {
                        for (int j = 0; j < nA; j++) {
                                result[i][j] = A[i][j] * factor;
                        }
                }
                return result;
        }

        public double[][] sum(double[][] A, double[][] B) {
                int mA = A.length;
                int nA = A[0].length;
                int mB = B.length;
                int nB = B[0].length;
                if (mA != mB || nA != nB) {
                        throw new RuntimeException("Matrix dimensions do not match.");
                }

                double[][] result = new double[mA][nA];
                for (int i = 0; i < mA; i++) {
                        for (int j = 0; j < nA; j++) {
                                result[i][j] = A[i][j] + B[i][j];
                        }
                }
                return result;
        }

        public double[][] transpose(double[][] A) {
                int m = A.length;
                int n = A[0].length;
                double[][] C = new double[n][m];
                for (int i = 0; i < m; i++)
                        for (int j = 0; j < n; j++)
                                C[j][i] = A[i][j];
                return C;
        }

        private void assemble(double[][] K, double[][] k, int i, int j, int m, int n) {

                i++;
                j++;
                m++;
                n++;

                K[(3 * i) - 2 - 1][(3 * i) - 2 - 1] = K[(3 * i) - 2 - 1][(3 * i) - 2 - 1]
                                + k[1 - 1][1 - 1];
                K[3 * i - 2 - 1][3 * i - 1 - 1] = K[3 * i - 2 - 1][3 * i - 1 - 1]
                                + k[1 - 1][2 - 1];
                K[3 * i - 2 - 1][3 * i - 1] = K[3 * i - 2 - 1][3 * i - 1]
                                + k[1 - 1][3 - 1];
                K[3 * i - 2 - 1][3 * j - 2 - 1] = K[3 * i - 2 - 1][3 * j - 2 - 1]
                                + k[1 - 1][4 - 1];
                K[3 * i - 2 - 1][3 * j - 1 - 1] = K[3 * i - 2 - 1][3 * j - 1 - 1]
                                + k[1 - 1][5 - 1];
                K[3 * i - 2 - 1][3 * j - 1] = K[3 * i - 2 - 1][3 * j - 1]
                                + k[1 - 1][6 - 1];
                K[3 * i - 2 - 1][3 * m - 2 - 1] = K[3 * i - 2 - 1][3 * m - 2 - 1]
                                + k[1 - 1][7 - 1];
                K[3 * i - 2 - 1][3 * m - 1 - 1] = K[3 * i - 2 - 1][3 * m - 1 - 1]
                                + k[1 - 1][8 - 1];
                K[3 * i - 2 - 1][3 * m - 1] = K[3 * i - 2 - 1][3 * m - 1]
                                + k[1 - 1][9 - 1];
                K[3 * i - 2 - 1][3 * n - 2 - 1] = K[3 * i - 2 - 1][3 * n - 2 - 1]
                                + k[1 - 1][10 - 1];
                K[3 * i - 2 - 1][3 * n - 1 - 1] = K[3 * i - 2 - 1][3 * n - 1 - 1]
                                + k[1 - 1][11 - 1];
                K[3 * i - 2 - 1][3 * n - 1] = K[3 * i - 2 - 1][3 * n - 1]
                                + k[1 - 1][12 - 1];
                K[3 * i - 1 - 1][3 * i - 2 - 1] = K[3 * i - 1 - 1][3 * i - 2 - 1]
                                + k[2 - 1][1 - 1];
                K[3 * i - 1 - 1][3 * i - 1 - 1] = K[3 * i - 1 - 1][3 * i - 1 - 1]
                                + k[2 - 1][2 - 1];
                K[3 * i - 1 - 1][3 * i - 1] = K[3 * i - 1 - 1][3 * i - 1]
                                + k[2 - 1][3 - 1];
                K[3 * i - 1 - 1][3 * j - 2 - 1] = K[3 * i - 1 - 1][3 * j - 2 - 1]
                                + k[2 - 1][4 - 1];
                K[3 * i - 1 - 1][3 * j - 1 - 1] = K[3 * i - 1 - 1][3 * j - 1 - 1]
                                + k[2 - 1][5 - 1];
                K[3 * i - 1 - 1][3 * j - 1] = K[3 * i - 1 - 1][3 * j - 1]
                                + k[2 - 1][6 - 1];
                K[3 * i - 1 - 1][3 * m - 2 - 1] = K[3 * i - 1 - 1][3 * m - 2 - 1]
                                + k[2 - 1][7 - 1];
                K[3 * i - 1 - 1][3 * m - 1 - 1] = K[3 * i - 1 - 1][3 * m - 1 - 1]
                                + k[2 - 1][8 - 1];
                K[3 * i - 1 - 1][3 * m - 1] = K[3 * i - 1 - 1][3 * m - 1]
                                + k[2 - 1][9 - 1];
                K[3 * i - 1 - 1][3 * n - 2 - 1] = K[3 * i - 1 - 1][3 * n - 2 - 1]
                                + k[2 - 1][10 - 1];
                K[3 * i - 1 - 1][3 * n - 1 - 1] = K[3 * i - 1 - 1][3 * n - 1 - 1]
                                + k[2 - 1][11 - 1];
                K[3 * i - 1 - 1][3 * n - 1] = K[3 * i - 1 - 1][3 * n - 1]
                                + k[2 - 1][12 - 1];
                K[3 * i - 1][3 * i - 2 - 1] = K[3 * i - 1][3 * i - 2 - 1]
                                + k[3 - 1][1 - 1];
                K[3 * i - 1][3 * i - 1 - 1] = K[3 * i - 1][3 * i - 1 - 1]
                                + k[3 - 1][2 - 1];
                K[3 * i - 1][3 * i - 1] = K[3 * i - 1][3 * i - 1] + k[3 - 1][3 - 1];
                K[3 * i - 1][3 * j - 2 - 1] = K[3 * i - 1][3 * j - 2 - 1]
                                + k[3 - 1][4 - 1];
                K[3 * i - 1][3 * j - 1 - 1] = K[3 * i - 1][3 * j - 1 - 1]
                                + k[3 - 1][5 - 1];
                K[3 * i - 1][3 * j - 1] = K[3 * i - 1][3 * j - 1] + k[3 - 1][6 - 1];
                K[3 * i - 1][3 * m - 2 - 1] = K[3 * i - 1][3 * m - 2 - 1]
                                + k[3 - 1][7 - 1];
                K[3 * i - 1][3 * m - 1 - 1] = K[3 * i - 1][3 * m - 1 - 1]
                                + k[3 - 1][8 - 1];
                K[3 * i - 1][3 * m - 1] = K[3 * i - 1][3 * m - 1] + k[3 - 1][9 - 1];
                K[3 * i - 1][3 * n - 2 - 1] = K[3 * i - 1][3 * n - 2 - 1]
                                + k[3 - 1][10 - 1];
                K[3 * i - 1][3 * n - 1 - 1] = K[3 * i - 1][3 * n - 1 - 1]
                                + k[3 - 1][11 - 1];
                K[3 * i - 1][3 * n - 1] = K[3 * i - 1][3 * n - 1] + k[3 - 1][12 - 1];
                K[3 * j - 2 - 1][3 * i - 2 - 1] = K[3 * j - 2 - 1][3 * i - 2 - 1]
                                + k[4 - 1][1 - 1];
                K[3 * j - 2 - 1][3 * i - 1 - 1] = K[3 * j - 2 - 1][3 * i - 1 - 1]
                                + k[4 - 1][2 - 1];
                K[3 * j - 2 - 1][3 * i - 1] = K[3 * j - 2 - 1][3 * i - 1]
                                + k[4 - 1][3 - 1];
                K[3 * j - 2 - 1][3 * j - 2 - 1] = K[3 * j - 2 - 1][3 * j - 2 - 1]
                                + k[4 - 1][4 - 1];
                K[3 * j - 2 - 1][3 * j - 1 - 1] = K[3 * j - 2 - 1][3 * j - 1 - 1]
                                + k[4 - 1][5 - 1];
                K[3 * j - 2 - 1][3 * j - 1] = K[3 * j - 2 - 1][3 * j - 1]
                                + k[4 - 1][6 - 1];
                K[3 * j - 2 - 1][3 * m - 2 - 1] = K[3 * j - 2 - 1][3 * m - 2 - 1]
                                + k[4 - 1][7 - 1];
                K[3 * j - 2 - 1][3 * m - 1 - 1] = K[3 * j - 2 - 1][3 * m - 1 - 1]
                                + k[4 - 1][8 - 1];
                K[3 * j - 2 - 1][3 * m - 1] = K[3 * j - 2 - 1][3 * m - 1]
                                + k[4 - 1][9 - 1];
                K[3 * j - 2 - 1][3 * n - 2 - 1] = K[3 * j - 2 - 1][3 * n - 2 - 1]
                                + k[4 - 1][10 - 1];
                K[3 * j - 2 - 1][3 * n - 1 - 1] = K[3 * j - 2 - 1][3 * n - 1 - 1]
                                + k[4 - 1][11 - 1];
                K[3 * j - 2 - 1][3 * n - 1] = K[3 * j - 2 - 1][3 * n - 1]
                                + k[4 - 1][12 - 1];
                K[3 * j - 1 - 1][3 * i - 2 - 1] = K[3 * j - 1 - 1][3 * i - 2 - 1]
                                + k[5 - 1][1 - 1];
                K[3 * j - 1 - 1][3 * i - 1 - 1] = K[3 * j - 1 - 1][3 * i - 1 - 1]
                                + k[5 - 1][2 - 1];
                K[3 * j - 1 - 1][3 * i - 1] = K[3 * j - 1 - 1][3 * i - 1]
                                + k[5 - 1][3 - 1];
                K[3 * j - 1 - 1][3 * j - 2 - 1] = K[3 * j - 1 - 1][3 * j - 2 - 1]
                                + k[5 - 1][4 - 1];
                K[3 * j - 1 - 1][3 * j - 1 - 1] = K[3 * j - 1 - 1][3 * j - 1 - 1]
                                + k[5 - 1][5 - 1];
                K[3 * j - 1 - 1][3 * j - 1] = K[3 * j - 1 - 1][3 * j - 1]
                                + k[5 - 1][6 - 1];
                K[3 * j - 1 - 1][3 * m - 2 - 1] = K[3 * j - 1 - 1][3 * m - 2 - 1]
                                + k[5 - 1][7 - 1];
                K[3 * j - 1 - 1][3 * m - 1 - 1] = K[3 * j - 1 - 1][3 * m - 1 - 1]
                                + k[5 - 1][8 - 1];
                K[3 * j - 1 - 1][3 * m - 1] = K[3 * j - 1 - 1][3 * m - 1]
                                + k[5 - 1][9 - 1];
                K[3 * j - 1 - 1][3 * n - 2 - 1] = K[3 * j - 1 - 1][3 * n - 2 - 1]
                                + k[5 - 1][10 - 1];
                K[3 * j - 1 - 1][3 * n - 1 - 1] = K[3 * j - 1 - 1][3 * n - 1 - 1]
                                + k[5 - 1][11 - 1];
                K[3 * j - 1 - 1][3 * n - 1] = K[3 * j - 1 - 1][3 * n - 1]
                                + k[5 - 1][12 - 1];
                K[3 * j - 1][3 * i - 2 - 1] = K[3 * j - 1][3 * i - 2 - 1]
                                + k[6 - 1][1 - 1];
                K[3 * j - 1][3 * i - 1 - 1] = K[3 * j - 1][3 * i - 1 - 1]
                                + k[6 - 1][2 - 1];
                K[3 * j - 1][3 * i - 1] = K[3 * j - 1][3 * i - 1] + k[6 - 1][3 - 1];
                K[3 * j - 1][3 * j - 2 - 1] = K[3 * j - 1][3 * j - 2 - 1]
                                + k[6 - 1][4 - 1];
                K[3 * j - 1][3 * j - 1 - 1] = K[3 * j - 1][3 * j - 1 - 1]
                                + k[6 - 1][5 - 1];
                K[3 * j - 1][3 * j - 1] = K[3 * j - 1][3 * j - 1] + k[6 - 1][6 - 1];
                K[3 * j - 1][3 * m - 2 - 1] = K[3 * j - 1][3 * m - 2 - 1]
                                + k[6 - 1][7 - 1];
                K[3 * j - 1][3 * m - 1 - 1] = K[3 * j - 1][3 * m - 1 - 1]
                                + k[6 - 1][8 - 1];
                K[3 * j - 1][3 * m - 1] = K[3 * j - 1][3 * m - 1] + k[6 - 1][9 - 1];
                K[3 * j - 1][3 * n - 2 - 1] = K[3 * j - 1][3 * n - 2 - 1]
                                + k[6 - 1][10 - 1];
                K[3 * j - 1][3 * n - 1 - 1] = K[3 * j - 1][3 * n - 1 - 1]
                                + k[6 - 1][11 - 1];
                K[3 * j - 1][3 * n - 1] = K[3 * j - 1][3 * n - 1] + k[6 - 1][12 - 1];
                K[3 * m - 2 - 1][3 * i - 2 - 1] = K[3 * m - 2 - 1][3 * i - 2 - 1]
                                + k[7 - 1][1 - 1];
                K[3 * m - 2 - 1][3 * i - 1 - 1] = K[3 * m - 2 - 1][3 * i - 1 - 1]
                                + k[7 - 1][2 - 1];
                K[3 * m - 2 - 1][3 * i - 1] = K[3 * m - 2 - 1][3 * i - 1]
                                + k[7 - 1][3 - 1];
                K[3 * m - 2 - 1][3 * j - 2 - 1] = K[3 * m - 2 - 1][3 * j - 2 - 1]
                                + k[7 - 1][4 - 1];
                K[3 * m - 2 - 1][3 * j - 1 - 1] = K[3 * m - 2 - 1][3 * j - 1 - 1]
                                + k[7 - 1][5 - 1];
                K[3 * m - 2 - 1][3 * j - 1] = K[3 * m - 2 - 1][3 * j - 1]
                                + k[7 - 1][6 - 1];
                K[3 * m - 2 - 1][3 * m - 2 - 1] = K[3 * m - 2 - 1][3 * m - 2 - 1]
                                + k[7 - 1][7 - 1];
                K[3 * m - 2 - 1][3 * m - 1 - 1] = K[3 * m - 2 - 1][3 * m - 1 - 1]
                                + k[7 - 1][8 - 1];
                K[3 * m - 2 - 1][3 * m - 1] = K[3 * m - 2 - 1][3 * m - 1]
                                + k[7 - 1][9 - 1];
                K[3 * m - 2 - 1][3 * n - 2 - 1] = K[3 * m - 2 - 1][3 * n - 2 - 1]
                                + k[7 - 1][10 - 1];
                K[3 * m - 2 - 1][3 * n - 1 - 1] = K[3 * m - 2 - 1][3 * n - 1 - 1]
                                + k[7 - 1][11 - 1];
                K[3 * m - 2 - 1][3 * n - 1] = K[3 * m - 2 - 1][3 * n - 1]
                                + k[7 - 1][12 - 1];
                K[3 * m - 1 - 1][3 * i - 2 - 1] = K[3 * m - 1 - 1][3 * i - 2 - 1]
                                + k[8 - 1][1 - 1];
                K[3 * m - 1 - 1][3 * i - 1 - 1] = K[3 * m - 1 - 1][3 * i - 1 - 1]
                                + k[8 - 1][2 - 1];
                K[3 * m - 1 - 1][3 * i - 1] = K[3 * m - 1 - 1][3 * i - 1]
                                + k[8 - 1][3 - 1];
                K[3 * m - 1 - 1][3 * j - 2 - 1] = K[3 * m - 1 - 1][3 * j - 2 - 1]
                                + k[8 - 1][4 - 1];
                K[3 * m - 1 - 1][3 * j - 1 - 1] = K[3 * m - 1 - 1][3 * j - 1 - 1]
                                + k[8 - 1][5 - 1];
                K[3 * m - 1 - 1][3 * j - 1] = K[3 * m - 1 - 1][3 * j - 1]
                                + k[8 - 1][6 - 1];
                K[3 * m - 1 - 1][3 * m - 2 - 1] = K[3 * m - 1 - 1][3 * m - 2 - 1]
                                + k[8 - 1][7 - 1];
                K[3 * m - 1 - 1][3 * m - 1 - 1] = K[3 * m - 1 - 1][3 * m - 1 - 1]
                                + k[8 - 1][8 - 1];
                K[3 * m - 1 - 1][3 * m - 1] = K[3 * m - 1 - 1][3 * m - 1]
                                + k[8 - 1][9 - 1];
                K[3 * m - 1 - 1][3 * n - 2 - 1] = K[3 * m - 1 - 1][3 * n - 2 - 1]
                                + k[8 - 1][10 - 1];
                K[3 * m - 1 - 1][3 * n - 1 - 1] = K[3 * m - 1 - 1][3 * n - 1 - 1]
                                + k[8 - 1][11 - 1];
                K[3 * m - 1 - 1][3 * n - 1] = K[3 * m - 1 - 1][3 * n - 1]
                                + k[8 - 1][12 - 1];
                K[3 * m - 1][3 * i - 2 - 1] = K[3 * m - 1][3 * i - 2 - 1]
                                + k[9 - 1][1 - 1];
                K[3 * m - 1][3 * i - 1 - 1] = K[3 * m - 1][3 * i - 1 - 1]
                                + k[9 - 1][2 - 1];
                K[3 * m - 1][3 * i - 1] = K[3 * m - 1][3 * i - 1] + k[9 - 1][3 - 1];
                K[3 * m - 1][3 * j - 2 - 1] = K[3 * m - 1][3 * j - 2 - 1]
                                + k[9 - 1][4 - 1];
                K[3 * m - 1][3 * j - 1 - 1] = K[3 * m - 1][3 * j - 1 - 1]
                                + k[9 - 1][5 - 1];
                K[3 * m - 1][3 * j - 1] = K[3 * m - 1][3 * j - 1] + k[9 - 1][6 - 1];
                K[3 * m - 1][3 * m - 2 - 1] = K[3 * m - 1][3 * m - 2 - 1]
                                + k[9 - 1][7 - 1];
                K[3 * m - 1][3 * m - 1 - 1] = K[3 * m - 1][3 * m - 1 - 1]
                                + k[9 - 1][8 - 1];
                K[3 * m - 1][3 * m - 1] = K[3 * m - 1][3 * m - 1] + k[9 - 1][9 - 1];
                K[3 * m - 1][3 * n - 2 - 1] = K[3 * m - 1][3 * n - 2 - 1]
                                + k[9 - 1][10 - 1];
                K[3 * m - 1][3 * n - 1 - 1] = K[3 * m - 1][3 * n - 1 - 1]
                                + k[9 - 1][11 - 1];
                K[3 * m - 1][3 * n - 1] = K[3 * m - 1][3 * n - 1] + k[9 - 1][12 - 1];
                K[3 * n - 2 - 1][3 * i - 2 - 1] = K[3 * n - 2 - 1][3 * i - 2 - 1]
                                + k[10 - 1][1 - 1];
                K[3 * n - 2 - 1][3 * i - 1 - 1] = K[3 * n - 2 - 1][3 * i - 1 - 1]
                                + k[10 - 1][2 - 1];
                K[3 * n - 2 - 1][3 * i - 1] = K[3 * n - 2 - 1][3 * i - 1]
                                + k[10 - 1][3 - 1];
                K[3 * n - 2 - 1][3 * j - 2 - 1] = K[3 * n - 2 - 1][3 * j - 2 - 1]
                                + k[10 - 1][4 - 1];
                K[3 * n - 2 - 1][3 * j - 1 - 1] = K[3 * n - 2 - 1][3 * j - 1 - 1]
                                + k[10 - 1][5 - 1];
                K[3 * n - 2 - 1][3 * j - 1] = K[3 * n - 2 - 1][3 * j - 1]
                                + k[10 - 1][6 - 1];
                K[3 * n - 2 - 1][3 * m - 2 - 1] = K[3 * n - 2 - 1][3 * m - 2 - 1]
                                + k[10 - 1][7 - 1];
                K[3 * n - 2 - 1][3 * m - 1 - 1] = K[3 * n - 2 - 1][3 * m - 1 - 1]
                                + k[10 - 1][8 - 1];
                K[3 * n - 2 - 1][3 * m - 1] = K[3 * n - 2 - 1][3 * m - 1]
                                + k[10 - 1][9 - 1];
                K[3 * n - 2 - 1][3 * n - 2 - 1] = K[3 * n - 2 - 1][3 * n - 2 - 1]
                                + k[10 - 1][10 - 1];
                K[3 * n - 2 - 1][3 * n - 1 - 1] = K[3 * n - 2 - 1][3 * n - 1 - 1]
                                + k[10 - 1][11 - 1];
                K[3 * n - 2 - 1][3 * n - 1] = K[3 * n - 2 - 1][3 * n - 1]
                                + k[10 - 1][12 - 1];
                K[3 * n - 1 - 1][3 * i - 2 - 1] = K[3 * n - 1 - 1][3 * i - 2 - 1]
                                + k[11 - 1][1 - 1];
                K[3 * n - 1 - 1][3 * i - 1 - 1] = K[3 * n - 1 - 1][3 * i - 1 - 1]
                                + k[11 - 1][2 - 1];
                K[3 * n - 1 - 1][3 * i - 1] = K[3 * n - 1 - 1][3 * i - 1]
                                + k[11 - 1][3 - 1];
                K[3 * n - 1 - 1][3 * j - 2 - 1] = K[3 * n - 1 - 1][3 * j - 2 - 1]
                                + k[11 - 1][4 - 1];
                K[3 * n - 1 - 1][3 * j - 1 - 1] = K[3 * n - 1 - 1][3 * j - 1 - 1]
                                + k[11 - 1][5 - 1];
                K[3 * n - 1 - 1][3 * j - 1] = K[3 * n - 1 - 1][3 * j - 1]
                                + k[11 - 1][6 - 1];
                K[3 * n - 1 - 1][3 * m - 2 - 1] = K[3 * n - 1 - 1][3 * m - 2 - 1]
                                + k[11 - 1][7 - 1];
                K[3 * n - 1 - 1][3 * m - 1 - 1] = K[3 * n - 1 - 1][3 * m - 1 - 1]
                                + k[11 - 1][8 - 1];
                K[3 * n - 1 - 1][3 * m - 1] = K[3 * n - 1 - 1][3 * m - 1]
                                + k[11 - 1][9 - 1];
                K[3 * n - 1 - 1][3 * n - 2 - 1] = K[3 * n - 1 - 1][3 * n - 2 - 1]
                                + k[11 - 1][10 - 1];
                K[3 * n - 1 - 1][3 * n - 1 - 1] = K[3 * n - 1 - 1][3 * n - 1 - 1]
                                + k[11 - 1][11 - 1];
                K[3 * n - 1 - 1][3 * n - 1] = K[3 * n - 1 - 1][3 * n - 1]
                                + k[11 - 1][12 - 1];
                K[3 * n - 1][3 * i - 2 - 1] = K[3 * n - 1][3 * i - 2 - 1]
                                + k[12 - 1][1 - 1];
                K[3 * n - 1][3 * i - 1 - 1] = K[3 * n - 1][3 * i - 1 - 1]
                                + k[12 - 1][2 - 1];
                K[3 * n - 1][3 * i - 1] = K[3 * n - 1][3 * i - 1] + k[12 - 1][3 - 1];
                K[3 * n - 1][3 * j - 2 - 1] = K[3 * n - 1][3 * j - 2 - 1]
                                + k[12 - 1][4 - 1];
                K[3 * n - 1][3 * j - 1 - 1] = K[3 * n - 1][3 * j - 1 - 1]
                                + k[12 - 1][5 - 1];
                K[3 * n - 1][3 * j - 1] = K[3 * n - 1][3 * j - 1] + k[12 - 1][6 - 1];
                K[3 * n - 1][3 * m - 2 - 1] = K[3 * n - 1][3 * m - 2 - 1]
                                + k[12 - 1][7 - 1];
                K[3 * n - 1][3 * m - 1 - 1] = K[3 * n - 1][3 * m - 1 - 1]
                                + k[12 - 1][8 - 1];
                K[3 * n - 1][3 * m - 1] = K[3 * n - 1][3 * m - 1] + k[12 - 1][9 - 1];
                K[3 * n - 1][3 * n - 2 - 1] = K[3 * n - 1][3 * n - 2 - 1]
                                + k[12 - 1][10 - 1];
                K[3 * n - 1][3 * n - 1 - 1] = K[3 * n - 1][3 * n - 1 - 1]
                                + k[12 - 1][11 - 1];
                K[3 * n - 1][3 * n - 1] = K[3 * n - 1][3 * n - 1] + k[12 - 1][12 - 1];
        }

        public void display() {
                XYDataset[] datasets = createDataset();
                JFreeChart[] charts = new JFreeChart[] { createChart(datasets[0]),
                                createChart(datasets[1]), createChart(datasets[2]) };

                System.out.println("___________________-");

                JPanel panel = new JPanel();
                JTabbedPane tab = new JTabbedPane();

                ChartPanel chartPanel1 = new ChartPanel(charts[0]);
                chartPanel1.setPreferredSize(new java.awt.Dimension(1000, 300));

                ChartPanel chartPanel2 = new ChartPanel(charts[1]);
                chartPanel2.setPreferredSize(new java.awt.Dimension(1000, 300));

                ChartPanel chartPanel3 = new ChartPanel(charts[2]);
                chartPanel3.setPreferredSize(new java.awt.Dimension(1000, 300));

                JPanel testPanel1 = new JPanel();
                testPanel1.add(chartPanel1);

                JPanel testPanel2 = new JPanel();
                testPanel2.add(chartPanel2);

                JPanel testPanel3 = new JPanel();
                testPanel3.add(chartPanel3);

                tab.add(testPanel1, "Stress vs Strain");
                tab.add(testPanel2, "Force vs Displacement");
                tab.add(testPanel3, "Force vs Time");

                panel.add(tab);

                setContentPane(panel);

                pack();
                setVisible(true);

        }

}