public VehicleTireReading(IVehicle CurrentVehicle)
        {
            Id = Guid.NewGuid();
            CurrentTires = CurrentVehicle.Tires;
            ReadingTimeStamp = DateTime.UtcNow;
            CurrrentDistanceTraveled = CurrentVehicle.OdometerInMiles;
            ReadingId = createReadingHashKey(ReadingTimeStamp, CurrentVehicle.Id);
            VehicleId = CurrentVehicle.Id;
            TypeOfCar = CurrentVehicle.VehicleType;
            Readings = new List<TireReading>();
            int maxSpeed = 0;
            int lastSpeed = 0;

            foreach (CarTire ct in CurrentTires)
            {
                TireReading currentReading = new TireReading(this, ct);
                lastSpeed = ct.GetCurrentSpeed();
                //Capture the last speed
                if (lastSpeed > CurrentSpeed)
                {
                    CurrentSpeed = lastSpeed;
                }
                maxSpeed = ct.MaxSpeedRating;
                Readings.Add(currentReading);
            }
        }

        public override void StopVehicle(IVehicle car)
        {
            switch (car.RadioState)
            {
                case RadioState.AM:
                case RadioState.FM:
                case RadioState.XM:
                case RadioState.CD:
                case RadioState.Off:
                    {
                        car.RadioState = RadioState.Off;
                        break;
                    }
                default:
                    {
                        car.RadioState = RadioState.Auxilary;
                        break;
                    }
            }

            car.MessageLog.Add("The car radio state was set.");

            if (car.FuelType == FuelType.JetFuel)
            {
                this.RunEngineCoolingProcess(car);
            }

            base.StopVehicle(car);
        }

 public Ticket(IVehicle vehicle, decimal payedMoney, string parkedPlace, int endTime)
 {
     this.Vehicle = vehicle;
     this.PayedMoney = payedMoney;
     this.ParkedPlace = parkedPlace;
     this.EndTime = endTime;
 }

        // XXX 4-23-03: Temporary work around (see comment above)
        //
        // Checks for intersection of the given spherical obstacle with a
        // volume of "likely future vehicle positions": a cylinder along the
        // current path, extending minTimeToCollision seconds along the
        // forward axis from current position.
        //
        // If they intersect, a collision is imminent and this function returns
        // a steering force pointing laterally away from the obstacle's center.
        //
        // Returns a zero vector if the obstacle is outside the cylinder
        //
        // xxx couldn't this be made more compact using localizePosition?
        public Vector3 SteerToAvoid(IVehicle v, float minTimeToCollision)
        {
            // minimum distance to obstacle before avoidance is required
            float minDistanceToCollision = minTimeToCollision * v.Speed;
            float minDistanceToCenter = minDistanceToCollision + Radius;

            // contact distance: sum of radii of obstacle and vehicle
            float totalRadius = Radius + v.Radius;

            // obstacle center relative to vehicle position
            Vector3 localOffset = Center - v.Position;

            // distance along vehicle's forward axis to obstacle's center
            float forwardComponent = Vector3.Dot(localOffset, v.Forward);
            Vector3 forwardOffset = v.Forward * forwardComponent;

            // offset from forward axis to obstacle's center
            Vector3 offForwardOffset = localOffset - forwardOffset;

            // test to see if sphere overlaps with obstacle-free corridor
            bool inCylinder = offForwardOffset.Length() < totalRadius;
            bool nearby = forwardComponent < minDistanceToCenter;
            bool inFront = forwardComponent > 0;

            // if all three conditions are met, steer away from sphere center
            if (inCylinder && nearby && inFront)
            {
                return offForwardOffset * -1;
            }
            else
            {
                return Vector3.Zero;
            }
        }

        public void StartParking(IVehicle vehicle)
        {
            Parking parking;
            if (_startTimes == null) //normal operation
            {
                parking = new Parking
                {
                    Vehicle = vehicle,
                    StartTime = DateTime.Now,
                    EndTime = default(DateTime)
                };
            }
            else //set startTime manually for testing
            {
                parking = new Parking
                {
                    Vehicle = vehicle,
                    StartTime = _startTimes[0],
                    EndTime = default(DateTime)
                };
                _startTimes.RemoveAt(0);
            }

            _currentParkings.Add(parking);
        }

        public void StartParking(IVehicle vehicle)
        {
            int numberOfOccupiedParkingSpots = _parkingService.GetNumberOfCurrentParkings();

            //check vehicle measurements
            if (vehicle.LengthInMeters > ParkingSpotLengthInMeters || vehicle.WidthInMeters > ParkingSpotWidthInMeters)
            {
                throw new VehicleSizeException("This vehicle is too large to fit in a parking spot");
            }

            if (numberOfOccupiedParkingSpots == NumberOfParkingSpots)
            {
                //this could happen if the last empty 10% of parking spots are taken by customers with contracts and noone stops parking at that time
                throw new ParkingException("Parking garage is full");
            }

            //check contract
            if (_parkingService.HasParkingContract(vehicle))
            {
                _parkingService.StartParking(vehicle);
            }
            else // no contract
            {
                //check that at least 10% of parking spots are reserved for customers with contracts before allowing to park

                if (numberOfOccupiedParkingSpots < NumberOfParkingSpots - RequiredFreeParkingSpots)
                {
                    _parkingService.StartParking(vehicle);
                }
                else
                {
                    throw new ParkingException("Remaining free parking spots reserved for customers with contracts");
                }
            }
        }

        private StringBuilder PrintTicket(decimal paidMoney, IVehicle vehicle, int parkingHours, int sector, int place)
        {
            var totalDueSum = (vehicle.ReservedHours * vehicle.RegularRate) +
                (parkingHours > vehicle.ReservedHours ?
                (parkingHours - vehicle.ReservedHours) *
                vehicle.OvertimeRate : 0);
            var change = paidMoney -
                         ((vehicle.ReservedHours * vehicle.RegularRate) +
                          (parkingHours > vehicle.ReservedHours
                              ? (parkingHours - vehicle.ReservedHours) * vehicle.OvertimeRate
                              : 0));
            var overtimeRtae = parkingHours > vehicle.ReservedHours
                ? (parkingHours - vehicle.ReservedHours) * vehicle.OvertimeRate
                : 0;

            var ticket = new StringBuilder();
            ticket.AppendLine(new string('*', 20))
                .AppendFormat("{0}", vehicle.ToString()).AppendLine()
                .AppendFormat("at place ({0},{1})", sector, place).AppendLine()
                .AppendFormat("Rate: ${0:F2}", vehicle.ReservedHours * vehicle.RegularRate).AppendLine()
                .AppendFormat("Overtime rate: ${0:F2}", overtimeRtae).AppendLine()
                .AppendLine(
                new string('-', 20))
                .AppendFormat("Total: ${0:F2}", totalDueSum).AppendLine()
                .AppendFormat("Paid: ${0:F2}", paidMoney).AppendLine().AppendFormat(
                "Change: ${0:F2}", change).AppendLine().Append(new string('*', 20));
            return ticket;
        }

 public SimpleTrainMovingStrategy(IVehicle vehicle)
 {
     _time = 0;
     _vehicle = vehicle;
     _timer = new Timer { Interval = _interval };
     _timer.Elapsed += (sender, args) => { _time++; };
 }

 protected string Park(IVehicle car)
 {
     if (this.Occupied) {
         throw new ApplicationException("Can't park a car in a full space");
     }
     this.ParkedCar = car;
     return this.Id;
 }

 public LuxuryCar(IVehicle vehicleControls,
             IAudioControl audioControls,
             IOperateSunRoof sunRoofControls)
 {
     _vehicleControls = vehicleControls;
     _audioControls = audioControls;
     _sunRoofControls = sunRoofControls;
 }

 public virtual IVehicle CreateSaloon()
 {
     if (saloon == null)
     {
         saloon = new Saloon(new StandardEngine(1300));
     }
     return (IVehicle)saloon.Clone();
 }

 public virtual void StopVehicle(IVehicle vehicle)
 {
     if (vehicle.EngineState == EngineState.Started)
     {
         vehicle.EngineState = EngineState.Stopped;
         vehicle.MessageLog.Add("Stopped the vehicle.");
     }
 }

        public override void StartVehicle(IVehicle car)
        {
            if (car.FuelType == FuelType.Diesel)
            {
                base.WarmGlowplugs(car);
            }

            base.StartVehicle(car);
        }

 public Household(int id, ITashaPerson[] persons, IVehicle[] vehicles, float expansion, IZone zone)
 {
     //this.auxiliaryTripChains = new List<ITripChain>(7);
     HouseholdId = id;
     Persons = persons;
     Vehicles = vehicles;
     ExpansionFactor = expansion;
     HomeZone = zone;
 }

 public void InsertVehicleInDatabase(IVehicle vehicle, int sector, DateTime startTime, string place)
 {
     this.VehiclesInParkPlaces[vehicle] = place;
     this.ParkPlaces[place] = vehicle;
     this.VehiclesByLicensePlate[vehicle.LicensePlate] = vehicle;
     this.VehiclesByStartTime[vehicle] = startTime;
     this.VehiclesByOwner[vehicle.Owner].Add(vehicle);
     this.SpacesCount[sector - 1]++;
 }

        public DateTime GetExpectedTimeForVehicle(IVehicle vehicle)
        {
            if (!this.expectedTimePerVehicle.ContainsKey(vehicle))
            {
                throw new InvalidOperationException("No such vehicle");
            }

            return this.expectedTimePerVehicle[vehicle];
        }

 public void AddVehicle(IVehicle vehicle, int sector, int placeNumber, DateTime startTime)
 {
     LocationByVehicle[vehicle] = string.Format("({0},{1})", sector, placeNumber);
     VehicleByLocation[string.Format("({0},{1})", sector, placeNumber)] = vehicle;
     VehicleByLicensePlate[vehicle.LicensePlate] = vehicle;
     VehicleByStartTime[vehicle] = startTime;
     VehcileByOwner[vehicle.Owner].Add(vehicle);
     sectors[sector - 1]++;
 }

        public string GetParkedSpot(IVehicle vehicle)
        {
            if (!this.parkedCarsInSectroAndPlace.ContainsKey(vehicle))
            {
                throw new InvalidOperationException("No such vehicle");
            }

            return this.parkedCarsInSectroAndPlace[vehicle];
        }

 public SingleVehicle(IVehicle vehicle)
 {
     _vehicle = vehicle;
     _trafficLight = new TrafficLight(StopVehicle);
     List<MenuItem> singleVehicleMenuItems = new List<MenuItem>();
     singleVehicleMenuItems.Add(new MenuItem(1, "Increase Vehicle Speed.", new CommonDel(IncreaseVehicleSpeed)));
     singleVehicleMenuItems.Add(new MenuItem(2, "Keep Vehicle Current Speed.", new CommonDel(KeepVehicleCurrentSpeed)));
     singleVehicleMenuItems.Add(new MenuItem(3, "Decrease Vehicle Speed.", new CommonDel(DecreaseVehicleSpeed)));
     singleVehicleMenu = new MenuCls("Vehicle Menu", singleVehicleMenuItems);
 }

 public void RemoveVehicleFromDatabase(IVehicle vehicle)
 {
     int sector = int.Parse(this.VehiclesInParkPlaces[vehicle].Split(new[] { "(", ",", ")" }, StringSplitOptions.RemoveEmptyEntries)[0]);
     this.ParkPlaces.Remove(this.VehiclesInParkPlaces[vehicle]);
     this.VehiclesInParkPlaces.Remove(vehicle);
     this.VehiclesByLicensePlate.Remove(vehicle.LicensePlate);
     this.VehiclesByStartTime.Remove(vehicle);
     this.VehiclesByOwner.Remove(vehicle.Owner, vehicle);
     this.SpacesCount[sector - 1]--;
 }