Finding locations of Vertices on a Mesh

I'm still not sure what you actually want. When you talk about the bounding box, why do you calculate the bound manually? Unity provides two different bounding boxes. The Mesh class provides a local space AABB of the mesh and the Renderer provides a world space AABB.

I've posted a script that visualizes those two bounding boxes in a comment to my answer on this question.

edit
Just to simplify your code a bit and to clear up some things ;)

• It doesn't make much sense to pass the models variable to a member function. If it should be a "standalone function" it should be static. In this case it would make sense to pass the required gameobject.

• It's a bit confusing that you use the indexer of Vector3 but you still access each component (x,y,z or 0,1,2) seperately.

• Most math operations are also possible with Vector3 structs, so there's no need to perform everything seperately for each component.

• Your bounding box is, like Aldo said, in local space. It you want it in world-space you need to convert it with TransformPoint

Here's a modified version of your script. The actual calculations is simplified and i've added some obvious error checks.

 public class cubify : MonoBehaviour
 {
     public GameObject model;
     void Start()
     {
         CreateBoundingCube();
     }
     void CreateBoundingCube()
     {
         Bounds bBox = CalculateBoundingBox(model);
         GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
         cube.transform.position = bBox.center;
         cube.transform.localScale = bBox.size;
     }
     public static Bounds CalculateBoundingBox(GameObject aObj)
     {
         if (aObj == null)
         {
             Debug.LogError("CalculateBoundingBox: object is null");
             return new Bounds(Vector3.zero, Vector3.one);
         }
         Transform myTransform = aObj.transform;
         Mesh mesh = null;
         MeshFilter mF = aObj.GetComponent<MeshFilter>();
         if (mF != null)
             mesh = mF.mesh;
         else
         {
             SkinnedMeshRenderer sMR = aObj.GetComponent<SkinnedMeshRenderer>();
             if (sMR != null)
                 mesh = sMR.sharedMesh;
         }
         if (mesh == null)
         {
             Debug.LogError("CalculateBoundingBox: no mesh found on the given object");
             return new Bounds(aObj.transform.position, Vector3.one);
         }
         Vector3[] vertices = mesh.vertices;
         if (vertices.Length <=0)
         {
             Debug.LogError("CalculateBoundingBox: mesh doesn't have vertices");
             return new Bounds(aObj.transform.position, Vector3.one);
         }
         Vector3 min, max;
         min = max = myTransform.TransformPoint(vertices[0]);
         for (int i = 1; i < vertices.Length; i++)
         {
             Vector3 V = myTransform.TransformPoint(vertices[i]);
             for (int n = 0; n < 3; n++)
             {
                 if (V[n] > max[n])
                     max[n] = V[n];
                 if (V[n] < min[n])
                     min[n] = V[n];
             }
         }
         Bounds B = new Bounds();
         B.SetMinMax(min, max);
         return B;
     }
 }

Keep in mind that this will calculate the real AABB in worldspace at the current state. When the object moves or rotates you have to recalculate the boundingbox. That's why unity stores the boundingbox in local space and just calculates the worldspace boundingbox of the local rotated bounding box. Otherwise you would have to iterate through all vertices every frame since there's no other way to calculate the true AABB of an object.