How do I test if car is grounded to stop it from driving in mid-air?

I have a script that makes my car drive but i really cant figure out how to test if my car 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 );
     }
 }