\( (*\ point, \ face, \ 
      spring\ data\ and\ access\ functions\ *) 
 (*\ 
      define\ point\ list\ *) 
 (*\ position, \ velocity, \ 
      force, \ mass\ *) 
pointList\  = \ {\ 
{{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, 
          2, "fixed"}, 
{{2, 0, 0}, {0, 0, 0}, {0, 0, 
            0}, 2, "fixed"}, 
{{4, 0, 0}, {0, 0, 
            0}, {0, 0, 0}, 
          2, "fixed"}, 
{{0, 2, 0}, {0, 0, 0}, {0, 0, 
            0}, 2, "fixed"}, 
{{2, 2, 0}, {0, 0, 
            0}, {0, 0, 0}, 2, "fixed"}, {{4, 2, 0}, {0, 0, 0}, {0, 0, 0}, 
          2, "fixed"}
}
 (*\ 
      triangulate\ a\ regular\ mesh\ of\ points\ *) \)
numRow  =  2;  
    numCol  =  3;
  
faceList  =  
      For[i = 1; fl = {}, i < numRow, 
        i = i + 1, 
For[j = 1, j < numCol, j = j + 1, 
          fl = Append[
              fl, {numCol*(i - 1) + j, numCol*(i - 1) + j + 1, 
                numCol*i + j}]; 
          fl = Append[
              fl, {numCol*i + j, numCol*(i - 1) + j + 1, 
                numCol*i + j + 1}]
]]; 
    faceList = fl;
  
  
springList   =  {
{1, 2, 2, 2, 
            1}, 
{2, 3, 2, 2, 1}, 
{4, 5, 
            2, 2, 1}, 
{5, 6, 2, 2, 
            1}, 
{2, 4, 2, 2, 1}, 
{3, 5, 
            2, 2, 1}, 
{1, 4, 2, 2, 
            1}, 
{2, 5, 2, 2, 1}, 
{3, 6, 
            2, 2, 1}
};

pointCoords[
          i_] := pointList[[i]][[1]];
  
pointVelocity[
          i_] := pointList[[i]][[2]];
  
pointForce[
          i_]  :=  pointList[[i]][[3]];
 (* get the mass of the ith point *) 
pointMass[
          i_] := pointList[[i]][[4]];
  
facePoint [i_, j_]  :=  
        pointList[[faceList[[i]][[j]]]];
 (* get the Polygon  -  
        list of vertex indices of the ith face *) 
facePoly[i_]  :=  
      Polygon[{facePoint[i, 1][[1]], facePoint[i, 
              2][[1]], facePoint[i, 
              3][[1]]}]
  vector [
          i_, j_]  :=  {
pointCoords[
                i][[1]] - pointCoords[
                j][[1]], 
pointCoords[
                i][[2]] - pointCoords[
                j][[2]], 
pointCoords[
                i][[3]] - pointCoords[
                j][[3]]
};
  vectorLength[v_]  :=  
        Sqrt[v[[1]]*v[[1]] + v[[2]]*v[[2]] + 
            v[[3]]*v[[3]]];
  
springPoint[i_, j_]  := 
        pointList[[springList[[i]][[j]]]];
 (* get the vector of the ith spring *) springVector[
          i_]  :=  
        vector[springList[[i]][[1]], springList[[i]][[2]]];
 (* 
      compute the force of the ith spring *) 
springForce[
        i_]  :=  ((vectorLength[
                  springVector[
                    i]] - springList[[i]][[4]])*springList[[i]][[3]])*
        springVector[i]/vectorLength[springVector[i]]
 (* 
      get the length of the ith spring *) 
springLength[i_]  :=  
      vectorLength[springVector[i]]
  
      printSpringLengths  := 
      For[i = 1, i ≤ Length[springList], i++, 
        Print[springLength[i] // N]]