C# Procedural Tilemap Generation - Each instance of tilemap rendering the same

I am working with script from a tutorial I followed to randomly generate terrain on a tilemap. The trouble I am having is when I add individual instances of the tilemap each one is a copy of the other. I thought it would be as simple as making the 2d array static so each instance of the tilemap would generate off a seperate array however this was not the case. Can I get some pointers here?

TileData.cs using UnityEngine; using System.Collections;

 public class TileData : MonoBehaviour{
     public static int[,] tile;
     int x, y;
 
     // Use this for initialization
     void Awake ()
     {
         int mapHeight = TileMap.SIZE_Z;
         int mapWidth = TileMap.SIZE_X;;
         float tileSize = TileMap.TILESIZE;
 
         tile = new int[mapWidth, mapHeight];
 
         for (int x = 0; x < mapWidth; x++) 
         {
             for (int y = 0; y < mapHeight; y++)
             {
                 tile[x, y] = Random.Range (0, 4);
             }
         }
     }
 
     public int GetTileAt(int x, int y) {
         return tile[x,y];
     }
 }

TileMap.cs

 using UnityEngine;
 using System.Collections;
 [RequireComponent(typeof(MeshRenderer))]
 [RequireComponent(typeof(MeshCollider))]
 public class TileMap : MonoBehaviour {
     
     public int size_x;
     public int size_z;
     public float tileSize;
 
     public static int SIZE_X;
     public static int SIZE_Z;
     public static float TILESIZE;
     
         
     public Texture2D terrainTiles;
     public int tileResolution;
         
     // Use this for initialization
     void Start () 
     {
         SIZE_X = size_x;
         SIZE_Z = size_z;
         TILESIZE = tileSize;
         BuildMesh();
     }
         
     Color[][] ChopUpTiles() 
     {
         int numTilesPerRow = terrainTiles.width / tileResolution;
         int numRows = terrainTiles.height / tileResolution;
 
         Color[][] tiles = new Color[numTilesPerRow*numRows][];
 
         for(int y=0; y<numRows; y++) 
         {
             for(int x=0; x<numTilesPerRow; x++) 
             {
                 tiles[y*numTilesPerRow + x] = terrainTiles.GetPixels( x*tileResolution , y*tileResolution, tileResolution, tileResolution );
             }
         }
 
         return tiles;
     }
         
     void BuildTexture() 
     {
         //TileData map = new TileData();
         TileData map = gameObject.AddComponent<TileData>() as TileData;
 
         int texWidth = size_x * tileResolution;
         int texHeight = size_z * tileResolution;
         Texture2D texture = new Texture2D(texWidth, texHeight);
             
         Color[][] tiles = ChopUpTiles();
 
         for(int y=0; y < size_z; y++) 
         {
             for(int x=0; x < size_x; x++) 
             {
                 Color[] p = tiles[map.GetTileAt(x,y)];
                 texture.SetPixels(x*tileResolution, y*tileResolution, tileResolution, tileResolution, p);
             }
         }
             
         texture.filterMode = FilterMode.Point;
         texture.wrapMode = TextureWrapMode.Clamp;
         texture.Apply();
             
         MeshRenderer mesh_renderer = GetComponent<MeshRenderer>();
         mesh_renderer.sharedMaterials[0].mainTexture = texture;
             
     }
         
     public void BuildMesh() 
     {
         int numTiles = size_x * size_z;
         int numTris = numTiles * 2;
             
         int vsize_x = size_x + 1;
         int vsize_z = size_z + 1;
         int numVerts = vsize_x * vsize_z;
             
         // Generate the mesh data
         Vector3[] vertices = new Vector3[ numVerts ];
         Vector3[] normals = new Vector3[numVerts];
         Vector2[] uv = new Vector2[numVerts];
             
         int[] triangles = new int[ numTris * 3 ];
             
         int x, z;
         for(z=0; z < vsize_z; z++) 
         {
             for(x=0; x < vsize_x; x++) 
             {
                 vertices[ z * vsize_x + x ] = new Vector3( x*tileSize, 0, -z*tileSize );
                 normals[ z * vsize_x + x ] = Vector3.up;
                 uv[ z * vsize_x + x ] = new Vector2( (float)x / size_x, 1f - (float)z / size_z );
             }
         }
             
         for(z=0; z < size_z; z++) 
         {
             for(x=0; x < size_x; x++) 
             {
                 int squareIndex = z * size_x + x;
                 int triOffset = squareIndex * 6;
                 triangles[triOffset + 0] = z * vsize_x + x +            0;
                 triangles[triOffset + 2] = z * vsize_x + x + vsize_x + 0;
                 triangles[triOffset + 1] = z * vsize_x + x + vsize_x + 1;
             
                 triangles[triOffset + 3] = z * vsize_x + x +            0;
                 triangles[triOffset + 5] = z * vsize_x + x + vsize_x + 1;
                 triangles[triOffset + 4] = z * vsize_x + x +            1;
             }
         }
             
             
         // Create a new Mesh and populate with the data
         Mesh mesh = new Mesh();
         mesh.vertices = vertices;
         mesh.triangles = triangles;
         mesh.normals = normals;
         mesh.uv = uv;
             
         // Assign our mesh to our filter/renderer/collider
         MeshFilter mesh_filter = GetComponent<MeshFilter>();
         MeshCollider mesh_collider = GetComponent<MeshCollider>();
 
         mesh_filter.mesh = mesh;
         mesh_collider.sharedMesh = mesh;
         Debug.Log ("Done Mesh!");
             
         BuildTexture();
     }
 }