Hey,
not sure if i understood what exatly is your goal. 3 identic cells(grids?) on top of each other?
You use the variables "width" and "height" at the top of your sketch, before calling "size()". So they have the default value 100. So "w" and "h" will be 0.
If you calculate those values after size they will be 1, but i have no idea what thy are for, because i do not understand the function of your cells-array. What is it supposed to do? Store positions? width and height of the cells? the cells themselfs?
Then your for loop draw 27*3 identical rectangles at the same spot, because you don't use any changing variable when drawing the rectangle:

1. rect(0,0,cells,cells);

Here is an example drawing just the cells:

1. int rows = 27;
   int cols = 3;
   float w = 10;
   float h = 10;
   
   void setup() {
     size(400, 400);
     smooth();
   
     // uncomment follwing lines, if you want the grid to fir the whle sketch-window
     // w= (float)width/cols;
     // h= (float)height/rows;
   
     for (int i = 0; i < rows; i++) {
       for (int j = 0; j < cols; j++) {
         rect( j*w, i*h, w, h);
       }
     }
   }
   

here is a simple maze as a 2D Array

you can "paint" the maze in the code via typing 0 or 1 - see below.

Greetings, Chrisir   

1. // think low level
2. // the parts of this function
3. // maze component
4. // particle movement component
5. //first make maze
   
6. //global variables - what variables are needed for maze component
7. // drawing cells
8. final int rows = 30;
9. final int cols = 30;
10. //
11. int w;
12. int h;
13. //
14. final int distScreen = 0;
15. //
16. int global_J = 1;
17. //
18. int [] [] cells = new int [rows] [cols];
19. // the content of the cell can be
20. final int emptyCell =0;
21. final int wallCell  =1;
22. final int startCell =2;
23. final int goalCell  =3;
24. //
25. void setup () {
26.   size(450, 360);
27.   background(255);
28.   // define
29.   w = width/(cols+0);
30.   h = height/(rows+0);
31.   //working 2D array, nested for loop
32.   //
33.   // Pre-init: all empty
34.   //meant to correlate to rows
35.   for (int i = 0; i < rows; i++) {
36.     //loop meant to correlate to cols
37.     for (int j = 0; j < cols; j++) {
38.       cells[i][j]= emptyCell;
39.     }
40.   }
41.   //
42.   // Init walls outside
43.   for (int i = 0; i < cells[0].length; i++) {
44.     cells[0][i]= wallCell;
45.     cells[rows-1][i]= wallCell;
46.     cells[i][0]= wallCell;
47.     cells[i][rows-1]= wallCell;
48.   }
49.   //
50.   // Init walls inside // HERE YOU ENTER THE MAZE !
51.   //    The content of the cell can be:
52.   //    final int emptyCell =0;
53.   //    final int wallCell  =1;
54.   //    final int startCell =2;
55.   //    final int goalCell  =3;
56.   fill( "100000000000100000000001000001");
57.   fill( "100001111100100000000001000301");
58.   fill( "100001000000100000000001000001");
59.   fill( "100001000000100000000001000001");
60.   fill( "100001011111111111000001000001");
61.   fill( "100001000000100000000001000001");
62.   fill( "100001000000100000000001000001");
63.   fill( "100001111100100000000001000001");
64.   fill( "100001000000100000000001000001");
65.   fill( "100001000000100000000001000001");
66.   fill( "100001011111111111000001000001");
67.   fill( "100001000000100000000001000001");
68.   fill( "100001000000100000000000000001");
69.   fill( "100001111100100000000001000001");
70.   fill( "100001000000100000000001000001");
71.   fill( "100001000000100000000000000001");
72.   fill( "100001000000111111000001000001");
73.   fill( "100001000000100000000001000001");
74.   fill( "100001000000100000000001000001");
75.   fill( "100001111100100000000000000001");
76.   fill( "100001000000100000000001000001");
77.   fill( "100001000000100000000001000001");
78.   fill( "100001000000111111000000000001");
79.   fill( "100001000000000000000001000001");
80.   fill( "100001000000000000000001000001");
81.   fill( "100001111100100000000001000001");
82.   fill( "102001000000000000000000000001");
83.   fill( "100001000000000000000001000001");
84. }
85. void draw () {
86.   background(0);
87.   //
88.   noStroke();
89.   //meant to correlate to rows
90.   for (int i = 0; i < rows; i++) {
91.     //loop meant to correlate to cols
92.     for (int j = 0; j < cols; j++) {
93.       // draw depending on the cell type
94.       switch(cells[i][j]) {
95.       case emptyCell:
96.         // empty / the way through the maze
    
97.         fill(255);
98.         rect(i*w+distScreen, j*h+distScreen, w, h );
99.         break;
100.       case wallCell:
101.         fill(110);
102.         rect(i*w+distScreen, j*h+distScreen, w, h );
103.         break;
104.       case startCell:
105.         fill( 0, 1, 255);
106.         stroke(2);
107.         rect(i*w+distScreen, j*h+distScreen, w, h );
108.         noStroke();
109.         break;       
110.       case goalCell:
111.         fill(1, 212, 9);
112.         rect(i*w+distScreen, j*h+distScreen, w, h );
113.         break;       
114.       default:
115.         println("Undefined cell type. Error 63 with " + cells[i][j] + ".");
116.         break;
117.       } // switch
118.     }
119.   }
120. } // func
121. void fill ( String theContent) {
122.   for (int i = 0; i < theContent.length()-1; i++) {
123.     cells[i][global_J]=  (  theContent.charAt(i) - 48  );
124.   } // for
125.   global_J++;
126. } //