How do i test whether my box collider is touching the floor or not?

I have a script that makes my car drive but i really cant figure out how to test if my box collider is grounded so i can stop it from moving forwards in the "Z" axis whilst in mid air.

Here Is My Script:

 public var CarGravity : float = -20;
 private var accel : Vector3;
 public var throttle : float;
 private var deadZone : float = .001;
 private var myRight : Vector3;
 private var velo : Vector3;
 private var flatVelo : Vector3;
 private var relativeVelocity : Vector3;
 private var dir: Vector3;
 private var flatDir : Vector3;
 private var carUp : Vector3;
 private var carTransform : Transform;
 private var carRigidbody : Rigidbody;
 private var engineForce : Vector3;
  
 private var turnVec : Vector3;
 private var imp : Vector3;
 private var rev : float;
 private var actualTurn : float;
 private var carMass : float;
 private var wheelTransform : Transform[] = new Transform[4];
 public var actualGrip : float;
 public var horizontal : float;
 private var maxSpeedToTurn : float = .2;
  
 public var frontLeftWheel : Transform;
 public var frontRightWheel : Transform;
 public var rearLeftWheel : Transform;
 public var rearRightWheel : Transform;
  
 public var LFWheelTransform : Transform;
 public var RFWheelTransform : Transform;
  
 public var power : float = 300;
 public var maxSpeed : float = 50;
 public var carGrip : float = 70;
 public var turnSpeed : float = 3.0;
  
 private var slideSpeed : float;
 public var mySpeed : float;
  
 private var carRight : Vector3;
 private var carFwd : Vector3;
 private var tempVEC : Vector3;
  
 function Start()
 {
     Initialize();
     Physics.gravity.y = CarGravity;
 }
  
 function Initialize()
 {
     carTransform = transform;
     carRigidbody = rigidbody;
     carUp = carTransform.up;
     carMass = rigidbody.mass;
     carFwd = Vector3.forward;
     carRight = Vector3.down;
     setUpWheels();
     carRigidbody.centerOfMass = Vector3(0,-0.7,.35);
 }
  
 function Update()
 {
     checkInput();
     carPhysicsUpdate();
 }
  
 function LateUpdate()
 {
     rotateVisualWheels();
     engineSound();
 }
  
 function setUpWheels()
 {
     if((null == frontLeftWheel || null == frontRightWheel || null == rearLeftWheel || null == rearRightWheel ))
     {
        Debug.LogError("One or more of the wheel transformshave not been plugged in on the car");
        Debug.Break();
     }
     else
     {
        wheelTransform[0] = frontLeftWheel;
        wheelTransform[1] = rearLeftWheel;
        wheelTransform[2] = frontRightWheel;
        wheelTransform[3] = rearRightWheel;
     }
 }
  
 private var rotationAmount : Vector3;
  
 function rotateVisualWheels()
 {
     LFWheelTransform.localEulerAngles.y = horizontal * 30;
     RFWheelTransform.localEulerAngles.y = horizontal * 30;
  
     rotationAmount = carRight * (relativeVelocity.z * 1.6 * Time.deltaTime * Mathf.Rad2Deg);
  
     wheelTransform[0].Rotate(rotationAmount);
     wheelTransform[1].Rotate(rotationAmount);
     wheelTransform[2].Rotate(rotationAmount);
     wheelTransform[3].Rotate(rotationAmount);
 }
  
 private var deviceAccelerometerSensitivity : float = 2;
  
 function checkInput()
 {
     if (Application.platform == RuntimePlatform.IPhonePlayer ||(Application.platform == RuntimePlatform.Android))
     {
        accel = Input.acceleration * deviceAccelerometerSensitivity;
  
        if(accel.x > deadZone || accel.x < -deadZone)
     {
        horizontal = accel.x;
     }
     else
     {
        horizontal = 0;
     }
        throttle =0;
  
        for (var touch : Touch in Input.touches)
     {
        if(touch.position.x > Screen.width -Screen.width/3 && touch.position.y < Screen.height/3)
        {
          throttle = 1;
        }
        else if(touch.position.x < Screen.width -Screen.width/3 && touch.position.y > Screen.height/3)
        {
          throttle= -1;
        }
     }
 }
     else if (Application.platform == RuntimePlatform.WindowsEditor || RuntimePlatform.WindowsWebPlayer || RuntimePlatform.WindowsPlayer )
     {
        horizontal = Input.GetAxis("Horizontal");
        throttle = Input.GetAxis("Vertical");
     }
 }
  
 function carPhysicsUpdate()
 {
     myRight = carTransform.right;
     velo = carRigidbody.velocity;
     tempVEC = Vector3(velo.x,0,velo.z);
     flatVelo = tempVEC;
     dir = transform.TransformDirection(carFwd);
     tempVEC = Vector3(dir.x,0,dir.z);
     flatDir = Vector3.Normalize(tempVEC);
     relativeVelocity = carTransform.InverseTransformDirection(flatVelo);
     slideSpeed = Vector3.Dot(myRight,flatVelo);
     mySpeed = flatVelo.magnitude;
     rev = Mathf.Sign(Vector3.Dot(flatVelo,flatDir));
     engineForce = ( flatDir * ( power * throttle ) * carMass);
     actualTurn = horizontal;
     if(rev < 0.1f)
     {
        actualTurn =- actualTurn;
     }
     turnVec =((( carUp * turnSpeed ) * actualTurn ) * carMass )* 800;
     actualGrip = Mathf.Lerp(100, carGrip, mySpeed * 0.02);
     imp = myRight * ( -slideSpeed * carMass * actualGrip);
 }
  
 function slowVelocity()
 {
     carRigidbody.AddForce(-flatVelo * 0.8);
 }
  
 function engineSound()
 {
     audio.pitch = 0.30 + mySpeed * 0.025;
     if (mySpeed > 30)
     {
        audio.pitch = 0.25 + mySpeed * 0.015;
     }
     if (mySpeed > 40)
     {
        audio.pitch = 0.20 + mySpeed * 0.013;
     }
     if (mySpeed > 49)
     {
        audio.pitch = 0.15 + mySpeed * 0.011;
     }
     if ( audio.pitch > 2.0 )
     {
        audio.pitch = 2.0;
     }
 }
  
 function FixedUpdate()
 {
     if(mySpeed < maxSpeed)
     {
     carRigidbody.AddForce( engineForce * Time.deltaTime);
  
     if (mySpeed > maxSpeedToTurn)
     {
     carRigidbody.AddTorque ( turnVec * Time.deltaTime);
     }
     else if(mySpeed < maxSpeedToTurn)
     {
        return;
     }
     carRigidbody.AddForce( imp * Time.deltaTime );
     }
 }