# ---------------------------------------------------------------------------- # This software is in the public domain, furnished "as is", without technical # support, and with no warranty, express or implied, as to its usefulness for # any purpose. # # CalculateRFD.py # # Author: dtomalak # Optimized by njensen # ---------------------------------------------------------------------------- ToolType = "numeric" WeatherElementEdited = "RFD" from numpy import * import time HideTool = 0 # Set up Class import SmartScript # For available commands, see SmartScript class Tool (SmartScript.SmartScript): def __init__(self, dbss): SmartScript.SmartScript.__init__(self, dbss) def execute(self, T, RH, Wind, Sky, PoP, RFD, PERCENTGREEN, GridTimeRange): "Put your tool description here" t0 = time.time() self._determinemaxmin(T, RH, Wind, PERCENTGREEN) #find absolute max/MIN values self._popthresh = self._preciptthresh() #st = time.time() fuellag = self._create1hrtimelag(T,RH,Sky,GridTimeRange) #ed = time.time() #diff = ed- st #diff = str(diff) #print diff + " seconds to run fuel lag" #st = time.time() finemoist = self._calcfinefuelmoisture(fuellag, PERCENTGREEN, GridTimeRange) #ed = time.time() #diff = ed- st #diff = str(diff) #print diff + " seconds to run fine moist" #finefuel, temp, Sky #st = time.time() ignite = self._calcignition(finemoist, T, Sky) #ed = time.time() #diff = ed- st #diff = str(diff) #print diff + " seconds to run ignition" #st = time.time() RFD = self._calcRFDINDEX(ignite, Wind) #ed = time.time() #diff = ed- st #diff = str(diff) #print diff + " seconds to run RFD" RFDcat = self._catagoricalRFD(RFD) #CLEAN UP WHERE SIG PRECIP IS OCCURING #st = time.time() #njensen RFDcat = where(greater_equal(PoP,self._popthresh),0,RFDcat) RFDcat[greater_equal(PoP,self._popthresh)] = 0 #ed = time.time() #diff = ed- st #diff = str(diff) #print diff + " seconds to run RFDcat" #print Wind[1] #self.createGrid("EXP","finemoiost","SCALAR",finemoist,GridTimeRange) #self.createGrid("EXP","ignite","SCALAR",ignite,GridTimeRange) #self.createGrid("EXP","RFD","SCALAR",RFD,GridTimeRange) #self.createGrid("EXP","SunT","SCALAR",sun,GridTimeRange) #self.createGrid("EXP","FuelT","SCALAR",fuel,GridTimeRange) t1 = time.time() print("inside CalculateRFD_NDJ took:", (t1-t0)) return RFDcat #EACH STEP IN THE PROCESS WILL GET ITS OWN MODULE #it appears that there are 4 main steps #CALCULATIONS #SINCE THIS TOOL REQUIRES SEVERAL DIFFERENT CALCULATIONS/COMPARISONS #WILL DO EACH MODULALLY def _create1hrtimelag(self, Tgrid, RHgrid,Skygrid,timer): #Step one Make RH and T Catagory grids #there are 6 temperature catagories and 21 Rh catagories #create the temp catagories 0 - 5 #njensen Tcat = where(Tgrid,0,0) Tcat = zeros(Tgrid.shape, int32) count = 0 starter = 29 tlist = [] if self._mint <= starter: #njensen Tcat = where(less_equal(Tgrid, starter), count, Tcat) Tcat[Tgrid <= starter] = count tlist.append(count) count = 1 while starter < 109: if starter > self._maxt: break if starter+20 >= self._mint and starter <= self._maxt: #njensen Tcat = where(logical_and(greater(Tgrid, starter), less_equal(Tgrid,starter + 20)), count, Tcat) Tcat[logical_and(greater(Tgrid, starter), less_equal(Tgrid,starter + 20))] = count tlist.append(count) count = count + 1 starter = starter + 20 continue if self._maxt >= 109: #njensen Tcat = where(greater_equal(Tgrid, 109), count, Tcat) Tcat[Tgrid >= 109] = count tlist.append(count) #NOW THE RHCAT #njensen RHcat = where(RHgrid,0,0) RHcat = zeros(RHgrid.shape, int32) #njensen RHcat = where(less(RHgrid, self._minrh), 100, RHcat) RHcat[RHgrid < self._minrh] = 100 validrh = [] if self._minrh <= 4: #njensen RHcat = where(less_equal(RHgrid, 4), 0 , RHcat) RHcat[RHgrid <= 4] = 0 validrh.append(0) starter = 1 baseRh = 4 while starter <= 19: if baseRh > self._maxrh: break if self._minrh <= baseRh + 5 and baseRh <= self._maxrh: #since RH values are even 4 % increments can use this short cut #njensen RHcat = where(logical_and(greater(RHgrid, baseRh), less_equal(RHgrid, baseRh + 5)), starter, RHcat) RHcat[logical_and(greater(RHgrid, baseRh), less_equal(RHgrid, baseRh + 5))] = starter validrh.append(starter) starter = starter + 1 baseRh = baseRh + 5 continue if self._maxrh > 99: #njensen RHcat = where(greater(RHgrid, 99), 20, RHcat) RHcat[RHgrid > 99] = 20 validrh.append(20) SKYcat = where(greater_equal(Skygrid, 75), 1, 0) suntable,cloudtable = self._onehrtimelagtable() ####NOW THE DATA HAS BEEN CATAGORIZED WILL HAVE TO STEP THROUGH EACH #CATAGORY TO DETERMINE 1hr fuel lag grid x = tlist[0] y = validrh[0] xsize = tlist[-1] ysize = validrh[-1] #njensen sunnyfuel = where(Skygrid, 0 , 0) sunnyfuel = zeros(Skygrid.shape, int32) hrtimelag = SKYcat ## while x <= xsize: ## row = suntable[x] ## rowcld = cloudtable[x] ## y = 0 ## while y <= ysize: ## value = row[y] ## valuecld = rowcld[y] ## tempo = where(logical_and(equal(Tcat, x), equal(RHcat, y)), 1, 0) ## fl = value#where(equal(SKYcat, 1), valuecld,value) ## sunnyfuel = tempo * fl #all locations that have 0 for tempo will be set to zero ## #sunnyfuel = where(logical_and(equal(Tcat, x), equal(RHcat, y)), value, sunnyfuel) ## y = y + 1 ## hrtimelag = where(greater(sunnyfuel,0),sunnyfuel, hrtimelag) ## continue ## x = x + 1 ## continue while x <= xsize: row = suntable[x] y = validrh[0] while y <= ysize: value = row[y] #njensen sunnyfuel = where(logical_and(equal(Tcat, x), equal(RHcat, y)), value, sunnyfuel) sunnyfuel[logical_and(equal(Tcat, x), equal(RHcat, y))] = value y = y + 1 continue x = x + 1 continue if SKYcat.any() : #njensen cloudyfuel = where(Skygrid, 0 , 0) cloudyfuel = zeros(Skygrid.shape, int32) x = tlist[0] y = validrh[0] xsize = tlist[-1] ysize = validrh[-1] while x <= xsize: row = cloudtable[x] #row = suntable[x] y = validrh[0] while y <= ysize: value = row[y] #njensen cloudyfuel = where(logical_and(equal(Tcat, x), equal(RHcat, y)), value, cloudyfuel) cloudyfuel[logical_and(equal(Tcat, x), equal(RHcat, y))] = value y = y + 1 continue x = x + 1 continue hrtimelag = where(Skygrid,0,0) if SKYcat.any(): hrtimelag = where(equal(SKYcat, 1), cloudyfuel, sunnyfuel) else: hrtimelag = sunnyfuel #self.createGrid("EXP","cldmoist","SCALAR",cloudyfuel,timer) #self.createGrid("EXP","Sunmoist","SCALAR",hrtimelag,timer) #self.createGrid("EXP","RHCAT","SCALAR",RHcat,timer) #self.createGrid("EXP","SKYCAT","SCALAR",SKYcat,timer) return hrtimelag def _calcfinefuelmoisture(self, timelagfuel, greeness, timer): tabledat = self._finefuelmoisturetable() x = len(timelagfuel) y = len(timelagfuel[0]) sizer = x * y lagdata = reshape(timelagfuel,(sizer,)) lagdata = sort(lagdata) lagmin = lagdata[0] lagmax = lagdata[-1] #STEP ONE NEED TO CATAGORIZE THE 1hr time time lag and percent green data #SIMILAR TO TEMPS AND RH #THERE ARE 15 CATAGORIES FOR Fuel moisture and roughly 9 for precent green #njensen Fuelcat = where(greeness,0,0) Fuelcat = zeros(greeness.shape, int32) #1-6 value the same as the step stepper = 1 count = 0 laglist = [] flcatlngth = len(tabledat) if lagmin <= 6: while stepper <= 6: if stepper >= lagmin and stepper <= lagmax: #njensen Fuelcat = where(equal(timelagfuel,stepper),count,Fuelcat) Fuelcat[equal(timelagfuel,stepper)] = count laglist.append(count) stepper = stepper + 1 count = count + 1 # print stepper,count continue else: stepper = 7 count = 5 if lagmin < 19 and lagmax > 6: while stepper < 19: #print stepper if stepper+1 >= lagmin and stepper <= lagmax: #njensen Fuelcat = where(logical_and(greater_equal(timelagfuel, stepper), less_equal(timelagfuel,stepper+1)),count,Fuelcat) Fuelcat[logical_and(greater_equal(timelagfuel, stepper), less_equal(timelagfuel,stepper+1))] = count laglist.append(count) stepper = stepper + 2 count = count + 1 #print stepper, count continue else: stepper = 19 count = 11 if lagmin < 25 and lagmax >= 19: while stepper < 25: #print str(stepper) + "$$$" if stepper+2 >= lagmin and stepper <= lagmax: #Fuelcat = where(logical_and(greater_equal(timelagfuel, stepper), less_equal(timelagfuel,stepper+2)),count,Fuelcat) Fuelcat[logical_and(greater_equal(timelagfuel, stepper), less_equal(timelagfuel,stepper+2))] = count laglist.append(count) stepper = stepper + 3 print(stepper) count = count + 1 #print stepper,count continue else: stepper = 25 count = 14 if lagmax >= 25: if stepper >= 25: #njensen Fuelcat = where(greater_equal(timelagfuel, stepper),count,Fuelcat) Fuelcat[timelagfuel > stepper] = count laglist.append(count) #print stepper, count #NOW PERCENT GREEN CATAGORIES #ON THE PERCENT GREEN TABLE ONLY THE 1st and LAST are different...all other are 9 #percent increments #njensen GREENcat = where(greeness,0,0) GREENcat = zeros(greeness.shape, int32) grlist = [] if self._mingreen < 5: #njensen GREENcat = where(less(greeness, 5), 0, GREENcat) GREENcat[greeness < 5] = 0 grlist.append(0) count = 1 ender = 8 stepper = 5 while count < ender: #print count, stepper if stepper+10 > self._mingreen and stepper <= self._maxgreen: #njensen GREENcat = where(logical_and(greater_equal(greeness,stepper),less(greeness, stepper+10)),count,GREENcat) GREENcat[logical_and(greater_equal(greeness,stepper),less(greeness, stepper+10))] = count grlist.append(count) count = count + 1 stepper = stepper + 10 continue if self._maxgreen >= 75: #print count, stepper #njensen GREENcat = where(greater(greeness, 75), count, GREENcat) GREENcat[greeness > 75] = count grlist.append(count) #CALCULATE THE FINE FUEL MOISTURE x = laglist[0] y = grlist[0] xsize = laglist[-1] ysize = grlist[-1] #njensen finemoisture = where(greeness, 0 , 0) finemoisture = zeros(greeness.shape, int32) #print len(GREENcat[0]), len(Fuelcat[0]), len(finemoisture) while x <= xsize: row = tabledat[x] y = grlist[0] while y <= ysize: value = row[y] #print value #njensen finemoisture = where(logical_and(equal(Fuelcat, x), equal(GREENcat, y)), value, finemoisture) finemoisture[logical_and(equal(Fuelcat, x), equal(GREENcat, y))] = value y = y + 1 continue x = x + 1 continue ###### Commented out the following line as we were ###### getting abnormally high values when rh was around 50 percent. ###### Seems when 1-hr Time Lag Fuel Moisture is cat 8 and Percent Green ###### is between 5-14 percent, Fine Fuel moisture does not go to a 9 as tables ###### show they should. finemoisture = where(equal(finemoisture,0),timelagfuel,finemoisture) #self.createGrid("EXP","finemoist","SCALAR",finemoisture,timer) #self.createGrid("EXP","tlagfuel","SCALAR",timelagfuel,timer) #self.createGrid("EXP","FuelCat","SCALAR",Fuelcat,timer) #self.createGrid("EXP","GREENcat","SCALAR",GREENcat,timer) return finemoisture #TABLES SECTION def _calcignition(self, finefuel, temp, Sky): tabledat = self._ignitioncomptable() #njensen #Fuelcat = where(Sky,0,0) #SunnyTcat = where(Sky,0,0) #CloudyTcat = where(Sky, 0, 0) #ignitionsun = where(Sky,0,0) #ignitioncld = where(Sky,0,0) Fuelcat = zeros(Sky.shape, int32) SunnyTcat = zeros(Sky.shape, int32) CloudyTcat = zeros(Sky.shape, int32) ignitionsun = zeros(Sky.shape, int32) ignitioncld = zeros(Sky.shape, int32) Skycat = where(greater_equal(Sky,80),1,0) temp = where(logical_and(equal(Skycat,1), greater_equal(temp, 20)),temp-20,temp) #njensen temp = where(less(temp,10),10,temp) temp[temp < 10] = 10 x = len(temp) y = len(temp[0]) newsize = x*y #should be same size for all arrays tdata = reshape(temp,(newsize,)) tdata = sort(tdata) self._skymint= tdata[0] if Skycat.any() and self._skymint < self._mint: self._mint = self._skymint x = len(finefuel) y = len(finefuel[0]) sizer = x * y fueldata = reshape(finefuel,(sizer,)) fueldata = sort(fueldata) fuelmin = fueldata[0] fuelmax = fueldata[-1] #First create Fine fuel catagories #EXACT SAME METHOD AS finefuelcat #1-6 value the same as the step stepper = 1 fuellist = [] count = 0 if fuelmin <= 6: while stepper <= 6: if stepper >= fuelmin and stepper <= fuelmax: #njensen Fuelcat = where(equal(finefuel,stepper),count,Fuelcat) Fuelcat[equal(finefuel,stepper)] = count fuellist.append(count) stepper = stepper + 1 count = count + 1 # print stepper,count continue else: stepper = 7 count = 5 if fuelmin < 19 and fuelmax > 6: while stepper < 19: #print stepper if stepper+1 >= fuelmin and stepper <= fuelmax: #njensen Fuelcat = where(logical_and(greater_equal(finefuel, stepper), less_equal(finefuel,stepper+1)),count,Fuelcat) Fuelcat[logical_and(greater_equal(finefuel, stepper), less_equal(finefuel,stepper+1))] = count fuellist.append(count) stepper = stepper + 2 count = count +1 #print stepper, count continue else: stepper = 19 count = 11 if fuelmin < 25 and fuelmax >= 19: while stepper < 25: #print str(stepper) + "$$$" if stepper+2 >= fuelmin and stepper <= fuelmax: #njensen Fuelcat = where(logical_and(greater_equal(finefuel, stepper), less_equal(finefuel,stepper+2)),count,Fuelcat) Fuelcat[logical_and(greater_equal(finefuel, stepper), less_equal(finefuel,stepper+2))] = count fuellist.append(count) stepper = stepper + 3 count = count + 1 #print stepper,count continue else: stepper = 25 count = 14 if fuelmax >= 25: if stepper >= 25: #Fuelcat = where(greater_equal(finefuel, stepper),count,Fuelcat) Fuelcat[finefuel >= stepper] = count fuellist.append(count) stepper = 20 tlist = [] if self._mint < 20: #njensen SunnyTcat = where(less(temp, stepper), 0 , SunnyTcat) SunnyTcat[temp < stepper] = 0 tlist.append(0) count = 1 ender =len(tabledat) - 1 while count < ender: if stepper+10 > self._mint and stepper <= self._maxt: #njensen SunnyTcat =where(logical_and(greater_equal(temp,stepper), less(temp,stepper+10)),count, SunnyTcat) SunnyTcat[logical_and(greater_equal(temp,stepper), less(temp,stepper+10))] = count tlist.append(count) count = count+1 stepper = stepper + 10 continue if self._maxt >= stepper: #njensen SunnyTcat = where(greater_equal(temp, stepper), count, SunnyTcat) SunnyTcat[temp >= stepper] = count tlist.append(count) #IGNITION x=tlist[0] y=fuellist[0] xsize = tlist[-1] ysize = fuellist[-1] while x <= xsize: row = tabledat[x] y = fuellist[0] while y <= ysize: value = row[y] #njensen ignitionsun = where(logical_and(equal(SunnyTcat, x), equal(Fuelcat, y)), value, ignitionsun) ignitionsun[logical_and(equal(SunnyTcat, x), equal(Fuelcat, y))] = value y = y + 1 continue x = x + 1 continue return ignitionsun def _calcRFDINDEX(self, ignition, wind): #THIS TOOL WILL CALCULATE THE RANGELAND FIRE DANGER...BASED OF THE IGNITION Component #and WINDSPEED #variables x = len(ignition) y = len(ignition[0]) sizer = x * y igdata = reshape(ignition,(sizer,)) igdata = sort(igdata) igmin = igdata[0] igmax = igdata[-1] #njensen RFD = where(ignition,0,0) RFD = zeros(ignition.shape, int32) spd = wind[0] wind = spd * 1.15 #convert to mph self._minwind = self._minwind * 1.15 self._maxwind = self._maxwind * 1.15 tabledat = self._RFDtable() #SPLIT DATA INTO x,y "component" grids Ignition -x Wind speed y #First ignition count = 1 #SPECIAL CASE For 0 iglist = [] #njensen IGcat = where(ignition,0,0) IGcat = zeros(ignition.shape, int32) if igmin <= 0: #njensen IGcat = where(equal(ignition,0),0,IGcat) IGcat[equal(ignition,0)] = 0 #no need to iterate through this axis as RFD will be 0 stepper = 1 ender = len(tabledat) - 1 while count <= ender: #print str(stepper) + "-" + str(stepper+5) + ":::" + str(count) if stepper+5 > igmin and stepper <= igmax: #njensen IGcat = where(logical_and(greater_equal(ignition,stepper), less(ignition,stepper+5)), count, IGcat) IGcat[logical_and(greater_equal(ignition,stepper), less(ignition,stepper+5))] = count iglist.append(count) count = count + 1 stepper = stepper + 5 continue #WIND (y axis) #1-8 mph are every 1 mph #after 8 mph it is every 2 ender = len(tabledat[0])-2 count = 0 wlist = [] stepper = 0.0 #am using .5 decimal place to account for conversions leaving remainders #ie 0-1 = > 0 <1.5 #njensen Wndcat = where(wind,0,0) Wndcat = zeros(wind.shape, int32) test = 0 while count <=7: #print count #print ":::::" if count == 0 and self._minwind <= 1.4: #njensen Wndcat = where(logical_and(greater_equal(wind, stepper), less(wind, stepper+1.5)), count, Wndcat) Wndcat[logical_and(greater_equal(wind, stepper), less(wind, stepper+1.5))] = count #print stepper, stepper + 1.5 #print "?????????????????" wlist.append(count) stepper = stepper + 1.5 test = 1 else: if test != 1: test = 1 count = 1 stepper = 1.5 #should only happen once if stepper+1.0 > self._minwind and stepper <= self._maxwind: #njensen Wndcat = where(logical_and(greater_equal(wind, stepper), less(wind, stepper+1)), count, Wndcat) Wndcat[logical_and(greater_equal(wind, stepper), less(wind, stepper+1))] = count wlist.append(count) stepper = stepper + 1 count = count + 1 while count <= ender: #every 2 mph until 26.5 mph #print count, stepper, stepper + 2 if stepper+2.0 > self._minwind and stepper <= self._maxwind: #njensen Wndcat = where(logical_and(greater_equal(wind, stepper), less(wind, stepper+2)), count, Wndcat) Wndcat[logical_and(greater_equal(wind, stepper), less(wind, stepper+2))] = count wlist.append(count) stepper = stepper + 2 count = count + 1 continue if count > ender: #print count, stepper if stepper <= self._maxwind: #njensen Wndcat = where(greater_equal(wind, stepper), count, Wndcat) Wndcat[wind >= stepper] = count wlist.append(count) x=iglist[0] y=wlist[0] xsize = iglist[-1] ysize = wlist[-1] while x <= xsize: row = tabledat[x] y = wlist[0] while y <= ysize: value = row[y] #njensen RFD = where(logical_and(equal(IGcat, x), equal(Wndcat, y)), value, RFD) RFD[logical_and(equal(IGcat, x), equal(Wndcat, y))] = value y = y + 1 continue x = x + 1 continue ## if igmin <= 0: ## RFD = where(equal(IGcat,0),0,RFD) return RFD def _catagoricalRFD(self,RFD): self._cat = self._statecriteria() keys = list(self._cat.keys()) #njensen newRfd = where(RFD,0,0) newRfd = zeros(RFD.shape, int32) for area in keys: datalist = self._cat[str(area)] areamask = self.encodeEditArea(area) #njensen tempo = where(RFD,0,0) tempo = zeros(RFD.shape, int32) for config in datalist: cat = config[0] min = config[1] max = config[2] #njensen tempo = where(logical_and(greater_equal(RFD,min), less_equal(RFD,max)),cat,tempo) tempo[logical_and(greater_equal(RFD,min), less_equal(RFD,max))] = cat newRfd = where(greater_equal(areamask,1),tempo,newRfd) continue return newRfd def _determinemaxmin(self, T, RH,Wind, PERCENTGREEN): #in order to save time this script will try to determine the maxium #and minimum range to look for each variable #for rh #rhdata = asarray(RH) #tdata = asarray(T) #wdata = asarray(Wind[0]) x = len(RH) y = len(RH[0]) newsize = x*y #should be same size for all arrays rhdata = reshape(RH,(newsize,)) tdata = reshape(T,(newsize,)) winddata = reshape(Wind[0],(newsize,)) greendata = reshape(PERCENTGREEN, (newsize,)) rhdata = sort(rhdata) tdata = sort(tdata) winddata = sort(winddata) greendata = sort(greendata) self._minrh = rhdata[0] self._maxrh = rhdata[-1] self._mint= tdata[0] self._maxt = tdata[-1] self._minwind =winddata[0] self._maxwind =winddata[-1] self._mingreen =greendata[0] self._maxgreen =greendata[-1] return def _onehrtimelagtable(self): #returns two lists 1 for sunny 1 for cloudy #BASED ON TABLE 1 #setup id [temprange[rhrangevalues]] #docmunetation pending sunnyhrlag = [[1,2,2,3,4,5,5,6,7,8,8,8,9,9,10,11,12,12,13,13,14], [1,2,2,3,4,5,5,6,7,7,7,8,9,9,10,10,11,12,13,13,13], [1,2,2,3,4,5,5,6,6,7,7,8,8,9, 9,10,11,12,12,12,13], [1,1,2,2,3,4,5,5,6,7,7,8,8,8, 9,10,10,11,12,12,13], [1,1,2,2,3,4,4,5,6,7,7,8,8,8, 9,10,10,11,12,12,13], [1,1,2,2,3,4,4,5,6,7,7,8,8,8, 9,10,10,11,12,12,13] ] cloudylag = [[1,2,4,5,5,6,7,8,9,10,11,12,12,14,15,17,19,22,25,25,25], [1,2,3,4,5,6,7,8,9, 9,11,11,12,13,14,16,18,21,24,25,25], [1,2,3,4,5,6,6,8,8, 9,10,11,11,12,14,16,17,20,23,25,25], [1,2,3,4,4,5,6,7,8, 9,10,10,11,12,13,15,17,20,23,25,25], [1,2,3,3,4,5,6,7,8, 9, 9,10,10,11,13,14,16,19,22,25,25], [1,2,2,3,4,5,6,6,8, 8, 9, 9,10,11,12,14,16,19,21,24,25] ] return sunnyhrlag, cloudylag def _finefuelmoisturetable(self): #returns a list based of Table2 #will comapre 1 hr fuel moisture to percent green #will be a two dimensional list with x =1 hr fuel moisture catagory #and y (the internal list being the the fine fuel moisture value with the #percent green catagory represented by the y index #0 represents a NO CHANGE value use the 1 hr time lag value table = [[0,2,3,4,5,8,13,18,21], [0,3,4,5,7,10,16,19,22], [0,4,5,7,9,14,18,20,22], [0,5,6,8,12,16,19,21,23], [0,6,8,11,14,18,20,22,23], [0,7,10,13,16,19,20,22,23], [0,9,12,15,18,20,21,22,23], [0,12,15,17,19,20,22,23,24], [0,14,17,18,20,21,22,23,24], [0,16,18,19,20,21,22,23,24], [0,17,19,20,21,22,22,23,24], [0,19,20,21,21,22,23,23,24], [0,21,21,22,22,23,23,24,24], [0,24,24,24,24,24,24,24,25], [0,25,25,25,25,25,25,25,25] ] return table def _ignitioncomptable(self): #will return one table (only difference is temp ranges for cloudy vs sunny tble = [ [88,75,64,54,46,39,30,21,14,9,5,2,0,0,0], [90,77,66,56,48,41,32,22,15,9,5,2,0,0,0], [93,80,68,58,50,42,33,23,16,10,6,3,0,0,0], [95,82,71,61,52,44,35,25,17,11,7,3,1,0,0], [98,85,73,63,54,46,36,26,18,12,7,4,1,0,0], [100,87,76,65,56,48,38,28,19,13,8,5,1,0,0], [100,90,78,68,58,50,40,29,21,14,9,5,2,0,0], [100,93,81,70,61,53,42,31,22,15,10,6,2,0,0], [100,97,84,73,63,55,44,32,23,16,11,7,3,0,0], [100,100,87,76,66,57,46,34,25,18,12,8,4,0,0], [100,100,90,79,69,60,49,36,27,19,13,9,4,1,0], [100,100,92,80,70,61,50,37,28,20,14,9,5,1,0], ] return tble def _RFDtable(self): #IGNITION COMPONENT(x) vs Wind spd (y) return [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [ 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 6, 6], [ 8, 8, 8, 8, 9, 9, 9, 9, 9, 10, 11, 11, 12, 13, 14, 14, 15, 16], [ 13, 14, 14, 14, 14, 14, 14, 15, 15, 16, 17, 18, 19, 21, 22, 25, 25, 25], [ 18, 19, 19, 19, 19, 20, 20, 20, 21, 22, 24, 25, 27, 29, 30, 32, 35, 35], [ 23, 24, 24, 24, 25, 25, 26, 26, 27, 29, 30, 32, 34, 36, 39, 42, 44, 46], [ 29, 29, 29, 30, 30, 31, 31, 32, 33, 35, 37, 39, 41, 44, 47, 51, 54, 57], [ 34, 34, 34, 35, 35, 36, 37, 38, 39, 41, 43, 46, 49, 52, 56, 60, 64, 68], [ 39, 39, 40, 40, 40, 41, 42, 43, 45, 47, 50, 53, 57, 60, 64, 69, 74, 79], [ 44, 44, 45, 45, 46, 47, 48, 49, 51, 54, 57, 60, 64, 68, 73, 78, 83, 89], [ 49, 49, 50, 51, 51, 52, 53, 55, 57, 60, 63, 67, 71, 76, 81, 87, 92, 97], [ 54, 55, 55, 56, 57, 58, 59, 60, 63, 66, 70, 74, 79, 84, 90, 96,100,100], [ 59, 60, 60, 61, 62, 63, 65, 66, 68, 72, 76, 81, 86, 92, 98,100,100,100], [ 64, 65, 66, 66, 68, 69, 70, 72, 74, 78, 83, 88, 94,100,100,100,100,100], [ 69, 70, 71, 72, 73, 74, 76, 77, 80, 85, 90, 95,100,100,100,100,100,100], [ 74, 75, 76, 77, 78, 80, 81, 83, 86, 91, 96,100,100,100,100,100,100,100], [ 79, 80, 81, 82, 84, 85, 89, 89, 92, 97,100,100,100,100,100,100,100,100], [ 85, 85, 86, 87, 89, 91, 92, 95, 98,100,100,100,100,100,100,100,100,100], [ 90, 91, 92, 93, 94, 96, 98,100,100,100,100,100,100,100,100,100,100,100], [ 95, 96, 97, 98,100,100,100,100,100,100,100,100,100,100,100,100,100,100], [100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100] ] def _statecriteria(self): ####CONFIGURATION FOR EACH STATE ###DICTIONARY FORMAT ## DICT = {"STATE", [(catnumber,low,high), (catnumber,low,high)]} statedict = {"Kansas" : [(0,0,30), (1,31,50), (2,51,70), (3,71,94), (4,95,100)], "Colorado" : [(0,0,30), (1,31,50), (2,51,70), (3,71,94), (4,95,100)], "Nebraska" : [(0,0,30), (1,31,50), (2,51,70), (3,71,94), (4,95,100)], "Iowa" : [(0,0,30), (1,31,50), (2,51,70), (3,71,94), (4,95,100)], } return statedict def _preciptthresh(self): #POP WHERE RFD WILL BE SET TO LOW #SET TO 101 if you want this disabled return 65