AC_Maint_Sim3.0.txt

#To open this file use exec(open('AC_Maint_Sim3.0.txt').read())
"""
Created on Mon Jul 19 14:45:07 2021.
@author: LtCol Thomas Kline, Divyam Khatri, Sam Thomas 
v2.7 reads variables from inputdata.csv
v2.7 records results in sq_trial_results.csv
model:
#
    a/c created, status newAircraft
    Controller controls based on shifts and A/C status
    When offshift hours, all A/C downtime
    When onshift hours:
#
#
"""
import numpy
import simpy
import random
import csv
import pandas as pd
from dataclasses import dataclass
from enum import Enum, auto
#
class g:
    """
    A class that holds the global variables.
    ...
    Attributes
    ----------
    gVars: array
        Holds all the global variables
    output_file: str
        The string of the name of the file when the output will be reported \
            after the end of the file.
    Methods
    -------
    None
    """
#
    gVars = {}
    gVarMins= {}
    gVarMaxes= {}
    gVarStepsizes= {}
    output_file = f"sq_trial_results.csv"
#
    def readVars():
        """
        Code to ingest input variables.
        Parameters
        ----------
        None
#Line 50        Returns
        -------
        None
        """
        """code to ingest input variables"""
        with open('inputData.csv', mode='r') as infile:
            reader = csv.reader(infile)
#            with open('coors_new.csv', mode='w') as outfile:
#                writer = csv.writer(outfile)
            g.gVars = {rows[0]: rows[1] for rows in reader}
        g.gVars.pop('Variables')
#
        """string to int"""
        for key in g.gVars:
            try:
                g.gVars[key] = int(g.gVars[key])
            except ValueError:
                g.gVars[key] = float(g.gVars[key])
        print(g.gVars)
#
    def getGVars():
        """
        Return gVars.
        Returns
        -------
        returns a list
            list has all of the global variables.
        """
        return g.gVars
#
    def setGVar(key,value):
        g.gVars[key]=value
#
    def readVarRanges():
        """
        Code to ingest input variable ranges
        Parameters
        ----------
        None
        Returns
        -------
        None
        """
        """code to ingest input variables"""
        with open('inputDataRanges.csv', mode='r') as infile:
            reader = csv.reader(infile)
            for rows in reader:
                g.gVarMins[rows[0]] = rows[1]
                g.gVarMaxes[rows[0]] = rows[2]
                g.gVarStepsizes[rows[0]] = rows[3]
        g.gVarMins.pop('Variables')
        g.gVarMaxes.pop('Variables')
        g.gVarStepsizes.pop('Variables')
#
        """string to int"""
        for key in g.gVarMins:#It is probably best to keep them all the same type for each key. But apparently this leads to g.gVarMaxes and g.gVarStepsizes not parsing to int or float.
            try:
                g.gVarMins[key] = int(g.gVarMins[key])
            except ValueError:
                g.gVarMins[key] = float(g.gVarMins[key])
        for key in g.gVarMaxes:
            try:
                g.gVarMaxes[key] = int(g.gVarMaxes[key])
            except ValueError:
                g.gVarMaxes[key] = float(g.gVarMaxes[key])
        for key in g.gVarStepsizes:
            try:
                g.gVarStepsizes[key] = int(g.gVarStepsizes[key])
            except ValueError:
                g.gVarStepsizes[key] = float(g.gVarStepsizes[key])
        print(g.gVars)
#
class Workcenter(Enum):
    """Maintainers' workcenters"""
    FL = auto()
    AF = auto()
    AVI = auto()
#
@dataclass
class MAF:
    """
    Maintenance Action Form (MAF) class that represent actions required
    and actions taken on aircraft..
    ...
#
    Attributes
    ----------
    tailNum: int, relates to aircraft 
    workcenter: Workcenter enum, specifies which workcenter is appropriate.
    timetoComplete: int, uses gVars to predetermine the req completion time.
    timeWorked: int, decrements timetoComplete based on worktime.
    complete: bool, used to indicate if action is complete.
#
    Methods
    -------
#
    """
    tailNum: int
    mcn: int
    workcenter: Workcenter
    timetoComplete : int
    timeWorked: int = 0
    complete: bool = False
    priority: int = 1
#
class Time:
    """
    A class that controls the time for the simulation.
    ...
    Attributes
    ----------
    None
    Methods
    -------
    getTime(env):
        Return environment time.
    getDay(env):
        Returns day in simulation.
    getHour(env):
        Returns hour in simulation.
    getMinute(env):
        Return minute in current hour and day of simulation.
    getMinIntoCurrDay(env):
        Return minutes into current day.
    getMinLeftInShift(env):
        Return minutes left in daily shift.
    """
    def getTime(env):
        """
        Return environment time in days, hours, minutes.
        Parameters
        ----------
        env : int, simpy environment, a running total of minutes at which events 
            are scheduled.
        Returns
        -------
        returns time in a D:H:M format as a string.
        """
        return str(Time.getDay(env)) + ":" + \
            str(Time.getHour(env)) + ":" + str(Time.getMinute(env))
#
    def getDay(env):
        """
        Return day in simulation.
        Parameters
        ----------
        env : int, simpy environment, a running total of minutes at which events 
            are scheduled. 
        Returns
        -------
        day : int. the current day number in the simulation
        """
        time = env.now  # recorded in total minutes
        day = round(time // (24*60))  # // drops the
        return day
#
    def getHour(env):
        """
        Return hour of the current day in simulation.
        Parameters
        ----------
        env : int, simpy environment, a running total of minutes at which events 
            are scheduled. 
        Returns
        -------
        hour : int. the current hour in the current day in the simulation
        """
        time = env.now  # recorded in total minutes
        time = time % (24*60)  #discard day, % only keeps remainder (in minutes)
        hour = round(time // 60) #//discards remainder
        return hour
#
    def getMinute(env):
        """
        Return minute in current hour and day of simulation.
        Parameters
        ----------
        env : int, simpy environment, a running total of minutes at which events 
            are scheduled. 
        Returns
        -------
        minute : int.
        """
        time = env.now  # recorded in total minutes
        time = time % (24*60)  #discard day, % only keeps remainder (in minutes)
        time %= 60 #discard hours, only keep remainder
        minute = round(time // 1)
        return minute
#
    def getMinIntoCurrDay(env):
        """
        Return minute in current day of simulation.
        Parameters
        ----------
        env : int
            Simpy's "clock", a running total of minutes at which events 
            are scheduled.
        Returns
        -------
        minutesIntoCurrentDay : TYPE
            DESCRIPTION.
        """
        time = env.now #recorded in total minutes
        time = time % (24*60) # % only keeps remainder (in minutes)
        minutesIntoCurrentDay = time #assignes remainder to variable
        return minutesIntoCurrentDay
#
    def getMinLeftInShift(env):
        """
        Return minutes left in shift.
        Parameters
        ----------
        env : int
            Simpy's "clock", a running total of minutes at which events 
            are scheduled.
        Returns
        -------
        minutesLeftInShift : int
        """
        time = env.now 
        time = time % (24*60)
        if (g.gVars['offShiftHr']*60) - time > 0:
           minutesLeftInShift = (g.gVars['offShiftHr']*60) - time
        else: 
           minutesLeftInShift = 0
        return minutesLeftInShift
#
class Squadron_Model:
    """
    The class that contains the events in the simulation.
    ...
#
    Attributes
    ----------
    self.env(env):
    self.controller(self): int
        Simpy Resource, input variable number of maintenance controllers
    self.flightlineMech(self): int
        Simpy Resource, input variable number of flightline mechanics
    self.airframesMech(self): int
        Simpy Resource, input variable number of airframes mechanics
    self.aviTech(self): int
        Simpy Resource, input variable number of avionics technicians
    self.pilot(self): int
        Simpy Resource, input variable number of pilots
    self.DayInMinutes: 1440
        total minutes in 24 hours
    self.offShiftHr: int
        input variable, hour when shift ends
    self.onShiftHr: int
        input variable, hour when shift starts
    self.prob_fl: int
        input variable, probability that A/C needs flightline workcenter repair
    self.prob_avi: int
        input variable, probability that A/C needs avionics workcenter repair
    self.prob_af: int
        input variable, probability that A/C needs airframes workcenter repair
    self.prob_awp: int
        input variable, probability that repair requires parts
    self.trial_number = trial_number
        number of runs through simulation
#
    self.results_df: pandas dataframe
    self.results_df["tailNum"]: list
        aircraft tail numbers
    self.results_df["Q_Time_Controller"]: list
        total time waiting for maintenance controller
    self.results_df["Q_Time_FlightLineMech"]: list
        total time waiting for flightline mechanics
    self.results_df["Q_Time_AirFrameMech"]: list
        qtotoal time waiting for airframes mechanics
    self.results_df["Q_Time_aviTech"]: list
        total time waiting for avionics technicians
    self.results_df["Total_Flight_Time"]: list
        total time spent flying
    self.results_df["Total_Flights"]: list
        total number of flights
    self.results_df["Total_AF_Repair_Time"]: list
        total time in repair or troubleshooting by airframes workcenter
    self.results_df["Total_Avi_Repair_Time"]: list
        total time in repair or troubleshooting by avionics workcenter
    self.results_df["Total_FL_Repair_Time"]: list
        total time in repair or troubleshooting by flightline workcenter
    self.results_df["Total_MC_Time"]: list
        total time aircraft is capable of flying: "mission capable"
    self.results_df["Total_NMC_Time"]: list
        total time aircraft is not capable of flying: "non-mission capable"
    self.results_df["Total_AWP_Time"]: list
        total time aircraft is waiting for parts from supply
    self.results_df.set_index("tailNum", inplace=True)
        command to set aircraft tail number as index
#
#
    Methods
    -------
    def generate_ac(self):
        creates a number of Aircraft objects and names them by counter
    def Controller(self, aircraft)
        onsiders material condition, flight schedule, and decides
    def inspect(self, aircraft):
        randomly break something on the aircraft
    def fly(self, aircraft):
        simulates aircraft flying
    def troubleshoot(self, aircraft, ld):
        simulates troubleshooting process; determines if parts required
    def repair(self, aircraft, ld):
        simulates the repair process
    def awp_supply(self, aircraft):
        simulates waiting parts from supply
    def downtime(self, aircraft):
        simulates time that personnel are not working on aircraft
    def run(self):
        run simulation until end
    """
#
    def __init__(self, trial_number):
        """
        Initialize local variables for Squadron Model.
        Returns
        -------
        None.
        """
        self.env = simpy.Environment()
        self.controller = simpy.Resource(self.env,
                                         capacity=g.gVars['numControllers'])
        self.flightlineMech = \
            simpy.Resource(self.env, capacity=g.gVars['numFlightlineMechs'])
        self.airframeMech = \
            simpy.Resource(self.env, capacity=g.gVars['numAirframeMechs'])
        self.aviTech = simpy.Resource(self.env, capacity=g.gVars[
            'numAviTechs'])
        self.pilot = simpy.Resource(self.env, capacity=g.gVars['numPilots'])
        self.DayInMinutes = 1440
        self.offShiftHr = g.gVars['offShiftHr']
        self.onShiftHr = g.gVars['onShiftHr']
        self.prob_fl = g.gVars['prob_fl']
        self.prob_avi = g.gVars['prob_avi']
        self.prob_af = g.gVars['prob_af']
        self.prob_awp = g.gVars['prob_awp']
        self.trial_number = trial_number
        self.results_df = pd.DataFrame()
        self.results_df["tailNum"] = []
        self.results_df["Q_Time_Controller"] = []
        self.results_df["Q_Time_FlightLineMech"] = []
        self.results_df["Q_Time_AirFrameMech"] = []
        self.results_df["Q_Time_aviTech"] = []
        self.results_df["Total_Flight_Time"] = []
        self.results_df["Total_Flights"] = []
        self.results_df["Total_AF_Repair_Time"] = []
        self.results_df["Total_Avi_Repair_Time"] = []
        self.results_df["Total_FL_Repair_Time"] = []
        self.results_df["Total_MC_Time"] = []
        self.results_df["Total_NMC_Time"] = []
        self.results_df["Total_AWP_Time"] = []
        self.results_df.set_index("tailNum", inplace=True)
#
    def generate_ac(self):
        """
        Generate all instances of the aircraft and sends them to controller.
        Yields
        ------
        yields to start controller for each specific aircraft.
        """
        for i in range(g.gVars['numAircraft']):
            tailNum = Aircraft(i+1) #increment tailNum
            self.env.process(self.control(tailNum)) #send to Mx Control
            yield self.env.timeout(0) #now until end of range
#
#
    def control(self, aircraft):
        """
        simulates maintenance control workcener, which directs
        actions are appropriate for the aircraft.
        Parameters
        ----------
        aircraft:aircraft class object that each aircraft's attributes
        Yields
        ------
        yields to each process the aircraft goes through in its life
#
        """
        timeLeft = Time.getMinLeftInShift(self.env)
        if timeLeft > 5:
            with self.controller.request() as req:
                yield req
                self.env.timeout(5)   
#
                if aircraft.getStatus() == "newAircraft":
                    aircraft.startMC = self.env.now
                    self.env.process(self.inspect(aircraft))
#
                elif aircraft.getStatus() == "needsInspection":
                   self.env.process(self.inspect(aircraft))
#
                elif aircraft.getStatus() == "passedInspection":
                    self.env.process(self.fly(aircraft))
#
                elif aircraft.getStatus() == "needsTroubleshooting":    
                    ld = aircraft.get_incompleteMAF() 
                    self.env.process(self.troubleshoot(aircraft, ld))
#
#
                elif aircraft.getStatus() == "needsRepair":
#
                    if any(maf.complete == False for maf in aircraft.mafs):
#
                        ld = aircraft.get_incompleteMAF() 
                        self.env.process(self.repair(aircraft, ld))
#
                    else: 
                        aircraft.setStatus("doneRepair")
                        aircraft.startMC = self.env.now
                        nmc_time = aircraft.startMC - aircraft.startNMC
                        aircraft.totalNMCTime = aircraft.totalNMCTime + nmc_time
                        self.env.process(self.inspect(aircraft))
#
                elif aircraft.getStatus() == "doneRepair":
                    self.env.process(self.inspect(aircraft))
#
                elif aircraft.getStatus() == "needPreflight":
                    self.env.process(self.fly(aircraft))
#
                elif aircraft.getStatus() == "doneFlight":
                    aircraft.setStatus("needsInspection")
                    self.env.process(self.inspect(aircraft))  
#
                else:
                    raise Exception("aircraft status not known")
        else:
            self.env.process(self.downtime(aircraft))
#
    def inspect(self, aircraft):
        """
        Simulate the inspection process, where there is a probability
        that a discrepancy is discovered, and if discovered a MAF is created.
        If any maf is created, troubleshooting is required to determine
        how to repair and if parts are needed.
        Parameters
        ----------
        aircraft : Class object for the aircraft that is being inspected.
        Yields
        ------
        yields a timeout of inspection time
        """
#
        print(Time.getTime(self.env), "- A/C", aircraft.tailNum,
              "- in inspection")
        yield self.env.timeout(5) #length of inspection in time
#
        if random.random() <= self.prob_fl:
            aircraft.add_maf(aircraft.maf_counter, workcenter=Workcenter.FL)
#
        if random.random() <= self.prob_avi:
            aircraft.add_maf(aircraft.maf_counter, workcenter=Workcenter.AVI)
#
        if random.random() <= self.prob_af:
            aircraft.add_maf(aircraft.maf_counter, workcenter=Workcenter.AF)
#
        if any(maf.complete == False for maf in aircraft.mafs):
            aircraft.changeStatus("needsTroubleshooting")
            aircraft.startNMC = self.env.now
            mc_time = aircraft.startNMC - aircraft.startMC
            aircraft.totalMCTime = aircraft.totalMCTime + mc_time
#
        else:
            aircraft.changeStatus("passedInspection")
        print(Time.getTime(self.env), "- A/C", aircraft.tailNum,
              "-", aircraft.status)
        self.env.process(self.control(aircraft))
#
    def fly(self, aircraft):
        """
        Simulate flying the aircraft.
        Aircraft arrives at this process if status "passedInspection"
        Parameters
        ----------
        aircraft : Class object for the aircraft that is being inspected.
        Yields
        ------
        yields the timeout for flight time
        """
        if any(maf.complete == False for maf in aircraft.mafs):
            raise Exception('Cant fly, {aircraft.tailNum} broken')    
#
        else:
#            print(Time.getTime(self.env), "- A/C", aircraft.tailNum,
#                  "- getting Pilot")
#
            with self.pilot.request() as req:
                yield req
                takeoffTime = self.env.now
                aircraft.totalFlights += 1
                # increment aircraft's number of flights
#
                flytimeDur = random.normalvariate(g.gVars['mean_flytime'],
                                                  g.gVars['flytime_sig'])
                print(Time.getTime(self.env), "- A/C", aircraft.tailNum,
                      "- departed on flight", aircraft.totalFlights)
                yield self.env.timeout(flytimeDur)
                print(Time.getTime(self.env), "- A/C", aircraft.tailNum,
                      "- completed flight", aircraft.totalFlights)
                landTime = self.env.now
                flightTime = landTime - takeoffTime
                aircraft.totalFlightTime = aircraft.totalFlightTime + flightTime
 #               aircraft.onSchedule = False
                aircraft.changeStatus("doneFlight")
                self.env.process(self.control(aircraft))
#
    def troubleshoot(self, aircraft, ld):
        """
        Represent the troubleshooting process: when inspection reveals that something
        is wrong, troubleshooting process identifies the actions and parts 
        required to correct the discrepancy.
        Parameters
        ----------
        Aircraft
        Returns
        -------
        None
        """
        start_q_mechanic = self.env.now
        if ld.workcenter == Workcenter.AVI:
            mech = self.aviTech.request()
        elif ld.workcenter == Workcenter.FL:
            mech = self.flightlineMech.request()
        elif ld.workcenter == Workcenter.AF:
            mech = self.airframeMech.request()
        else:
            raise Exception('Workcenter unknown {ld.workcenter}')
        troubleshoot_duration = random.normalvariate(g.gVars['mean_troubleshoot'], \
                                                    g.gVars['troubleshoot_sig'])
        with mech as req: #req the resource
            yield req #give the resource once available
#
            print(f"{Time.getTime(self.env)} - A/C {aircraft.tailNum} - {ld.workcenter} troubleshooting mcn {ld.mcn}")
#
            end_q_mechanic = self.env.now
            q_time = end_q_mechanic - start_q_mechanic
            aircraft.q_time_mechanic = aircraft.q_time_mechanic + q_time
            yield self.env.timeout(troubleshoot_duration)
            parts_req = random.random() < self.prob_awp
            if parts_req:
                self.env.process(self.awp_supply(aircraft, ld))
                print(f"{Time.getTime(self.env)} - A/C {aircraft.tailNum} - mcn {ld.mcn} requires parts")
#
            else: 
                aircraft.changeStatus("needsRepair")
                self.env.process(self.control(aircraft))
                print(f"{Time.getTime(self.env)} - A/C {aircraft.tailNum} - {ld.workcenter} troubleshooting mcn {ld.mcn} complete")
#
    def repair(self, aircraft, ld):
        """
        Simulate the repair process.
        Capture queue time by workcenter.
        Determine if repair can be completed during shift.
        Capture time worked by workcenter.
        Parameters
        ----------
        Aircraft & a MAF object to record attributes
        Returns
        -------
        None
        """
        start_q_time = self.env.now
        if ld.workcenter == Workcenter.AVI:
            mech = self.aviTech.request()
        elif ld.workcenter == Workcenter.FL:
            mech = self.flightlineMech.request()
        elif ld.workcenter == Workcenter.AF:
            mech = self.airframeMech.request()
        else:
            raise Exception('Workcenter unknown {ld.workcenter}')
        with mech as req: #req the resource
            yield req #give the resource once available
#
            print(f"{Time.getTime(self.env)} - A/C {aircraft.tailNum} - {ld.workcenter} working mcn {ld.mcn}")
#
            end_q_time = self.env.now
            q_time = end_q_time - start_q_time
            if ld.workcenter == Workcenter.AVI:
                aircraft.q_time_aviTech = aircraft.q_time_aviTech + q_time
            elif ld.workcenter == Workcenter.FL:
                aircraft.q_time_flightlineMech = aircraft.q_time_flightlineMech + q_time
            elif ld.workcenter == Workcenter.AF:
                aircraft.q_time_airframesMech = aircraft.q_time_airframesMech + q_time
            else:
                raise Exception('Workcenter unknown {ld.workcenter}')
#
            timeleft = Time.getMinLeftInShift(self.env)
#
            if 0 <= timeleft <=5:
                self.env.process(self.downtime(aircraft))
#
            else:
                if ld.timetoComplete < timeleft:
                    worktime = ld.timetoComplete
                else:
                    worktime = timeleft
#
                yield self.env.timeout(worktime)
#
                setattr(ld, "timeWorked", ld.timeWorked + worktime)
                setattr(ld, "timetoComplete", ld.timetoComplete - worktime)
#
                if ld.workcenter == Workcenter.AVI:
                    aircraft.totalAviRepairTime = aircraft.totalAviRepairTime + worktime
                elif ld.workcenter == Workcenter.FL:
                    aircraft.totalFLRepairTime = aircraft.totalFLRepairTime + worktime
                elif ld.workcenter == Workcenter.AF:
                    aircraft.totalAFRepairTime = aircraft.totalAFRepairTime + worktime
                else:
                    raise Exception('Workcenter unknown {ld.workcenter}')
#
                if ld.timetoComplete == 0:
                    print(f"{Time.getTime(self.env)} - A/C {aircraft.tailNum} - {ld.workcenter} completed mcn {ld.mcn}") 
                    setattr(ld, "complete", True)
#
                else:
                    print(f"{Time.getTime(self.env)} - A/C {aircraft.tailNum} - {ld.workcenter} worked mcn {ld.mcn}, end of shift")
#
                self.env.process(self.control(aircraft))
#
#
    def awp_supply(self, aircraft, ld):
        """
        Represent the troubleshooting process.
        Parameters
        ----------
        Aircraft & a MAF object to record attributes
        Returns
        -------
        None
        """
        awp_time = random.expovariate(1.0/g.gVars['mean_awp'])
        print(f"{Time.getTime(self.env)} - A/C {aircraft.tailNum} - awaiting parts for mcn {ld.mcn}")        
        yield self.env.timeout(awp_time)
        aircraft.totalAWPTime = aircraft.totalAWPTime + awp_time
        print(f"{Time.getTime(self.env)} - A/C {aircraft.tailNum} - mcn {ld.mcn} parts received")
        aircraft.changeStatus("needsRepair")
        self.env.process(self.control(aircraft))
#
#
    def downtime(self, aircraft):
        """
        Accounts for the hours where squadron personnel not working.
        Parameters
        ----------
        aircraft
        Returns
        ------
        None
        """
        downtimeDur = (self.DayInMinutes-Time.getMinIntoCurrDay(self.env)) + (self.onShiftHr*60)
        yield self.env.timeout(downtimeDur)
        if self.env.now > g.gVars['warm_up_period']:
            df_to_add = pd.DataFrame({"tailNum":[aircraft.tailNum],
                                     "Q_Time_Controller":[aircraft.q_time_controller],
                                     "Q_Time_FlightLineMech":[aircraft.q_time_flightlineMech],
                                     "Q_Time_AirFrameMech":[aircraft.q_time_airframesMech],
                                     "Q_Time_aviTech":[aircraft.q_time_aviTech],
                                     "Total_Flight_Time":[aircraft.totalFlightTime],
                                     "Total_Flights":[aircraft.totalFlights],
                                     "Total_AF_Repair_Time":[aircraft.totalAFRepairTime],
                                     "Total_FL_Repair_Time":[aircraft.totalFLRepairTime],
                                     "Total_Avi_Repair_Time":[aircraft.totalAviRepairTime],
                                     "Total_MC_Time":[aircraft.totalMCTime],
                                     "Total_NMC_Time":[aircraft.totalNMCTime],
                                     "Total_AWP_Time":[aircraft.totalAWPTime]})
            df_to_add.set_index("tailNum", inplace=True)
            self.results_df = self.results_df.append(df_to_add)
        self.env.process(self.control(aircraft))
#
    def calculate_means(self):
        """
        Takes dataframe output to calculate means.
        Parameters
        ----------
        None
        Returns
        ------
        None
        """
        self.mean_q_time_controller = self.results_df["Q_Time_Controller"].mean()
        self.mean_q_time_flightlineMech = self.results_df["Q_Time_FlightLineMech"].mean()
        self.mean_q_time_airframeMech = self.results_df["Q_Time_AirFrameMech"].mean()
        self.mean_q_time_aviTech = self.results_df["Q_Time_aviTech"].mean()
        self.mean_total_flightTime = self.results_df["Total_Flight_Time"].mean()
        self.mean_total_flights = self.results_df["Total_Flights"].mean()
        self.mean_total_afRepairTime = self.results_df["Total_AF_Repair_Time"].mean()
        self.mean_total_flRepairTime = self.results_df["Total_FL_Repair_Time"].mean()
        self.mean_total_aviRepairTime = self.results_df["Total_Avi_Repair_Time"].mean()
        self.mean_total_MCTime = self.results_df["Total_MC_Time"].max()
        self.mean_total_NMCTime = self.results_df["Total_NMC_Time"].mean()
        self.mean_total_AWPTime = self.results_df["Total_AWP_Time"].mean()
#
    #write trial run results as new line in g.output_file
    def write_run_results(self):
        """
        Writes results of run to csv file.
        Parameters
        ----------
        aircraft
        Returns
        ------
        None
        """
        with open(g.output_file, "a", newline="") as f:
            writer = csv.writer(f, delimiter=",")
            results_to_write = [self.trial_number,
                                g.gVars["numAircraft"],
                                g.gVars["warm_up_period"],
                                g.gVars["sim_duration"],
                                g.gVars["onShiftHr"],
                                g.gVars["offShiftHr"],
                                g.gVars["numControllers"],
                                self.mean_q_time_controller,
                                g.gVars["prob_fl"],
                                g.gVars["mean_fl_fix"],
                                g.gVars["numFlightlineMechs"],
                                self.mean_q_time_flightlineMech,
                                self.mean_total_flRepairTime,
                                g.gVars["prob_af"],
                                g.gVars["mean_af_fix"],
                                g.gVars["numAirframeMechs"],
                                self.mean_q_time_airframeMech,
                                self.mean_total_afRepairTime,
                                g.gVars["prob_avi"],
                                g.gVars["mean_avi_fix"],
                                g.gVars["numAviTechs"],
                                self.mean_q_time_aviTech,
                                self.mean_total_aviRepairTime,
                                g.gVars["mean_troubleshoot"],
                                g.gVars["troubleshoot_sig"],
                                g.gVars["mean_flytime"],
                                 g.gVars["flytime_sig"],
                                self.mean_total_flightTime,
                                self.mean_total_flights,
                                self.mean_total_MCTime,
                                self.mean_total_NMCTime,
                                g.gVars["prob_awp"],
                                g.gVars["mean_awp"],
                                self.mean_total_AWPTime,
                                g.gVars["numPilots"]]
            writer.writerow(results_to_write) 
#
    def run(self):
        """
        Start the simulation.
        Calls generate ac and runs the simulation for sim duration
#
        Returns
        -------
        None.
        """
        self.env.process(self.generate_ac())
        self.env.run(until=(g.gVars['warm_up_period'] + g.gVars['sim_duration']))
        print(g.gVars['warm_up_period'] + g.gVars['sim_duration'])
        self.calculate_means()
        self.write_run_results()
#
class Aircraft:
    """
    A class to represent an aircraft.
    ...
    Attributes
    ----------
    self.tailNum:int
        aircraft tail number
    self.status:str
        aircraft status
    self.lastStatus:str
        last status if aircraft
    self.maf_counter: int
        used in adding a readable mcn integer
    self.mafs: MAF list
        list of MAF objects used in recording maintenance
    self.startMC: int
        used in calculating total MC and NMC time during sim
    self.startNMC: int
        used in calculating total MC and NMC time during sim
    self.q_time_controller: int
        queue time for controller
    self.q_time_mechanic: int
        queue time for mechanic of any type
    self.q_time_flightlineMech : int
        queue time for flightline mechanic
    self.q_time_airframesMech : int
        queue time for airframes mechanic
    self.q_time_aviTech : int
        queue time for avionics technician
    self.q_time_pilot: int
        queue time for pilot
#
    self.totalFlightTime: int
        total flight time in minutes
    self.totalFlights: int
        total number of flight
    self.totalAviRepairTime: int
        total time spent in avionics repairs
    self.totalFLRepairTime: int
        total time spent in flightline repairs
    self.totalAFRepairTime: int
        total time spent in airframes repairs
    self.totalAWPTime: int
        total time waiting for parts (in minutes)
    self.totalMCTime: int
        total time aircraft is mission capable (in minutes)
    self.totalNMCTime: int
        total time aircraft is non-mission capable (in minutes)
    self.totalAWPTime: int
        total time aircraft is awaiting parts from supply (in minutes)
#
    self.onSchedule:bool
        whether aircraft is on schedule or not
#
    Methods
    -------
    def getTailNum(self):
        Gets the tail number.
    def getStatus(self):
        Gets the status.
    def setStatus(self, status):
        Sets the status.
    def changeStatus(self,newStatus):
        Changes the status.
    def calculate_timetoComplete(self, workcenter):
        Choose a time to complete MAF referencing workcenter.
    def add_MAF(self, MAF, workcenter):
        Create a MAF and add it to aircraft's list of MAFs.
    def get_incompleteMAF(self):
        Iterate through aircraft's list of MAFs, return first incomplete.
    det get_lastMAF(self):
        Iterate through aircraft's list of MAFs, return last incomplete.
    """
#
    def __init__(self, tailNum): #default values on initialization
        self.tailNum = tailNum
        self.status = "newAircraft"
        self.lastStatus = ""
        self.maf_counter = 0
        self.mafs: [MAF] = []
        self.startMC = 0
        self.startNMC = 0
#
        self.q_time_controller = 0
        self.q_time_mechanic = 0
        self.q_time_flightlineMech = 0
        self.q_time_airframesMech = 0
        self.q_time_aviTech = 0
        self.q_time_pilot = 0
#
        self.totalFlightTime = 0
        self.totalFlights = 0
        self.totalAviRepairTime = 0
        self.totalFLRepairTime = 0
        self.totalAFRepairTime = 0
        self.totalAWPTime = 0
        self.totalMCTime = 0
        self.totalNMCTime = 0
        self.totalAWPTime = 0
#
        self.onSchedule = True
#
    def getTailNum(self):
        """
        Get the tail number.
        Returns
        -------
        tailNum (int)
        """
        return self.tailNum
#
    def getStatus(self):
        """
        Get the status.
        Returns
        -------
        status (str)
        """
        return self.status
#
    def setStatus(self, status):
        """
        Set the status.
        Parameters
        ----------
        status : int
            aircraft status.
        Returns
        -------
        None.
#
        """
        self.status = status
#
    def changeStatus(self, newStatus):
        """
        Change the status.
        Parameters
        ----------
        newStatus : str
            status to change to.
        Returns
        -------
        None.
        """
        if newStatus != self.status:
            self.lastStatus = self.status
            self.status = newStatus
        else:
            self.status = newStatus
#
    def calculate_timetoComplete(self, workcenter) -> None:
        """
        Assign timetoComplete for MAF.
        Parameters
        ----------
        workcenter : enum
            uses workcenter to apply random value.
        Returns
        -------
        timetoComplete: int
        """
        if workcenter == Workcenter.FL:
            timetoComplete = random.expovariate(1.0/g.gVars['mean_fl_fix'])
        elif workcenter == Workcenter.AF:
            timetoComplete = random.expovariate(1.0/g.gVars['mean_af_fix'])
        elif workcenter == Workcenter.AVI:
            timetoComplete = random.expovariate(1.0/g.gVars['mean_avi_fix']) 
        return timetoComplete
#
    def add_maf(self, maf: MAF, workcenter) -> None:
        """
        add a maf to the list of mafs.
        Parameters
        ----------
        maf: MAF class
        workcenter: enum
        Returns
        -------
        appends maf into aircraft.mafs list
        """
        self.maf_counter += 1
        timetoComplete = self.calculate_timetoComplete(workcenter)
        self.mafs.append(MAF(tailNum=self.tailNum, mcn=self.maf_counter, workcenter=workcenter, timetoComplete=timetoComplete))
#
    def get_incompleteMAF(self):
        """
        evaluates maf.complete == False then returns first object.
        Parameters
        ----------
        None
        Returns
        -------
        ld[0]: list
        """
        ld = []
        for maf in self.mafs:
            if maf.complete == False:
                ld.append(maf)
        return ld[0]
#
    def get_LastMAF(self):
        """
        evaluates maf.complete == False then returns last object.
        Parameters
        ----------
        None
        Returns
        -------
        ld[-1]: list
        """
        ld = []
        for maf in self.mafs:
            if maf.complete == False:
                ld.append(maf)
        return ld[-1]
#
#This sets up the output file.
with open(g.output_file, "w", newline="") as f:
   writer = csv.writer(f, delimiter=",")
   column_headers = ["Run","Number of Aicraft", "Warm Up Period","Sim Duration",
                     "On Shift Hour","Off Shift Hour",
                     "Controllers","Queue Time - Maintenance Control",
                     "FL_Probability","FL_Fix_Mean","Flightline Mechanics", 
                     "Queue Time - Flightline","Avg A/C Time - Flighline Repair", 
                     "AF_Probability","AF_Fix_Mean","Airframes Mechanics",
                     "Queue Time Airframes","Avg A/C Time - Airframes Repair",
                     "AVI_Probability","AVI_Fix_Mean","Avionics Mechanics",
                     "Queue Time - Avionics","Avg A/C Time - Avionics Repair",
                     "Troubshoot_Mean", "Troubleshoot_Sigma", 
                     "Flight_Time_Mean", "Flight_Time_Sigma",
                     "Avg A/C Flight Time","Avg A/C Flights","Avg A/C MC Time", 
                     "Avg A/C NMC Time","AWP_Probability","Mean_AWP",
                     "Avg A/C AWP Time","Pilots"]
   writer.writerow(column_headers)
#
g.readVarRanges()
for key in g.gVarMins:
    g.gVars[key]=g.gVarMins[key]#Could I simply set g.gVars=g.gVarMins to avoid the for loop?
rangeValues={key : numpy.arange(g.gVarMins[key],g.gVarMaxes[key]+g.gVarStepsizes[key],g.gVarStepsizes[key]) for key in g.gVarMins}#Ideally, split into int/float.
keys=g.gVars.keys()
import itertools
for vals in itertools.product(*rangeValues.values()):#numTrials should probably not be here. Will it cause a problem?
    for iter_count,key in enumerate(keys):#This might not be the most efficient assignment method. Especially since likely only one value is updated at a time. But the simulation itself seems to take much more time. Can this be improved?
        g.gVars[key]=vals[iter_count]
    for trial_num in range(1,g.gVars['numTrials']+1):
        print("Trial ", trial_num, " of ", g.gVars['numTrials'], sep="")
        my_sq_model = Squadron_Model(trial_num)
        my_sq_model.run()
        print()
    print("Finished all trials for the set of input values ",values, sep="")
    print()
#
print("End Sim")