def onStart(self):
if Parameters["Mode4"] == 'Debug':
self.debug = True
Domoticz.Debugging(1)
DumpConfigToLog()
else:
Domoticz.Debugging(0)
Domoticz.Debug("onStart called")
# check polling interval parameter
try:
temp = int(Parameters["Mode3"])
except:
Domoticz.Error("Invalid polling interval parameter")
else:
if temp < 5:
temp = 5 # minimum polling interval
Domoticz.Error("Specified polling interval too short: changed to 5 minutes")
elif temp > 1440:
temp = 1440 # maximum polling interval is 1 day
Domoticz.Error("Specified polling interval too long: changed to 1440 minutes (1 day)")
self.pollinterval = temp * 60
Domoticz.Log("Using polling interval of {} seconds".format(str(self.pollinterval)))
if Parameters["Mode4"] == 'Debug':
self.debug = True
Domoticz.Debugging(1)
DumpConfigToLog()
else:
Domoticz.Debugging(0)
self.rssUrl = Parameters["Mode1"]
self.rssCode = Parameters["Mode2"]
self.mt = Meteo(self.rssUrl, rssCode=self.rssCode,
domLangSetting=Settings["Language"], detailSetting=Parameters["Mode5"],
iconSetting=Parameters["Mode6"], locationName=Parameters["Name"])
if self.debug is True:
self.mt.dumpMeteoConfig
# Check if devices need to be created
createDevices()
# init with empty data
updateDevice(1, 0, "No Data")
updateDevice(2, 0, "No Data")
from meteo import Meteo, mostrar_meteo cs = Meteo(estacion='CS1', temp=[20.2, 19.1, 27.2, 24.8], lluvia=[0, 0, 0, 0]) vr = Meteo(estacion='VR1', temp=cs.temp[:], lluvia=cs.lluvia[:]) mostrar_meteo(cs) mostrar_meteo(vr)
class BasePlugin:
def __init__(self):
self.debug = False
self.error = False
self.nextpoll = datetime.now()
self.detailNo = True
self.detailLang = "english"
self.iconNo = True
self.iconType = ''
self.langKey = 0 # 0 = english, 1 = german, 2 = ?
self.rss = None
return
def onStart(self):
if Parameters["Mode4"] == 'Debug':
self.debug = True
Domoticz.Debugging(1)
DumpConfigToLog()
else:
Domoticz.Debugging(0)
Domoticz.Debug("onStart called")
# check polling interval parameter
try:
temp = int(Parameters["Mode3"])
except:
Domoticz.Error("Invalid polling interval parameter")
else:
if temp < 5:
temp = 5 # minimum polling interval
Domoticz.Error("Specified polling interval too short: changed to 5 minutes")
elif temp > 1440:
temp = 1440 # maximum polling interval is 1 day
Domoticz.Error("Specified polling interval too long: changed to 1440 minutes (1 day)")
self.pollinterval = temp * 60
Domoticz.Log("Using polling interval of {} seconds".format(str(self.pollinterval)))
if Parameters["Mode4"] == 'Debug':
self.debug = True
Domoticz.Debugging(1)
DumpConfigToLog()
else:
Domoticz.Debugging(0)
self.rssUrl = Parameters["Mode1"]
self.mt = Meteo(self.rssUrl, Settings["Language"], Parameters["Mode5"], Parameters["Mode6"])
if self.debug is True:
self.mt.dumpMeteoConfig
# Check if devices need to be created
createDevices()
# init with empty data
updateDevice(1, 0, "No Data")
updateDevice(2, 0, "No Data")
def onStop(self):
Domoticz.Debug("onStop called")
Domoticz.Debugging(0)
def onCommand(self, Unit, Command, Level, Hue):
Domoticz.Debug(
"onCommand called for Unit " + str(Unit) + ": Parameter '" + str(Command) + "', Level: " + str(Level))
def onHeartbeat(self):
now = datetime.now()
if now >= self.nextpoll:
self.nextpoll = now + timedelta(seconds=self.pollinterval)
self.mt.readMeteoWarning()
# check if
if self.mt.needUpdate is True:
updateDevice(1, self.mt.todayLevel, self.mt.todayDetail, self.mt.getTodayTitle())
updateDevice(2, self.mt.tomorrowLevel, self.mt.tomorrowDetail, self.mt.getTomorrowTitle())
Domoticz.Debug("----------------------------------------------------")
def prepare_run(self):
self.logger.info(
'----------------------------------------------------------')
self.logger.info('\tRunning: %s' % (self.exe_dirs))
self.logger.info('\ttemplate: %s' % (self.param_tmp))
self.logger.info('\trootdir: %s' % (self.rootdir))
self.logger.info(
'----------------------------------------------------------')
self._set_environment()
#----------------------- Load horizontal grid objects ----------
self.logger.info('\tReading: %s' % (self.hfile))
self.hgrid = HorizontalGrid(self.hfile,
format='gr3',
epsg=self.epsg,
logger=self.logger)
self.hgrid.copy_to_root(self.rootdir)
#----------------------- Load vertical grid objects ----------
vgrid_reader = VerticalGrid(logger=self.logger)
if 'vfile' not in self.vgrid_config:
self.vgrid_config['vfile'] = join(self.rootdir, 'vgrid.in')
if not os.path.isfile(self.vgrid_config['vfile']):
self.logger.info('\tCreating: %s' % (self.vgrid_config['vfile']))
vgrid_reader.write(**self.vgrid_config)
self.vgrid = vgrid_reader.load(self.vgrid_config['vfile'])
lat0 = sum(self.hgrid.latitude) / len(self.hgrid.latitude)
t0 = dateutil.parser.parse(self.timing["time start"])
t1 = dateutil.parser.parse(self.timing["time end"])
# #----------------------- Download Initial and Boundary fields ----------
dwnl = download_data(t0, t1, logger=self.logger)
for file in self.input_files.keys():
dwnl.get_input_data(self.input_files[file])
self.logger.info(
'----------------------------------------------------------')
#----------------------- Write command file (param.in) ------------------
cfg = ModelConfig(hydro=self.hydro_config, t0=t0, logger=self.logger)
cfg.make_config(self.param_tmp, join(self.rootdir, 'param.nml'),
'hydro')
# #----------------------- Set Boundary Conditions (bctides.in) -----------
# # Store boundary arrays in each obc bctype object (Ex: self.obc['btype']['7']['iettype'])
bcinput = BCinputs(obc=self.obc,
nnode=self.hgrid.nnode,
lat0=lat0,
t0=t0,
logger=self.logger)
bcinput.make_bctides(join(self.rootdir, 'bctides.in'))
# # ------------------- Create Ocean boundary forcing -----------------
for key in self.forcings.keys():
if not os.path.isfile(join(self.rootdir, key)):
Obf = OpenBoundaries(obc=self.forcings[key],
hgrid=self.hgrid,
vgrid=self.vgrid,
t0=t0,
t1=t1,
logger=self.logger)
if 'tidal' in self.forcings[key]:
Obf.add_tide(self.forcings[key]['tidal'])
if 'residual' in self.forcings[key]:
Obf.add_res(self.forcings[key]['residual'])
Obf.make_boundary(join(self.rootdir, key),
self.forcings[key].get('dt', 3600))
# # ------------------- Create Oceanic initial conditions ---------------------
if self.ic:
for key in self.ic:
filename = os.path.join(self.rootdir, key)
if not os.path.isfile(filename):
ic = InitialConditions(filename,hgrid=self.hgrid,t0=t0,value=self.ic[key].get('value',None),\
ncfile=self.ic[key].get('filename',None),\
var=self.ic[key].get('var',None),\
shapefile=self.ic[key].get('shapefile',None),logger=self.logger)
# #------------------------- Check/Prepare for hotstart --------------------
# self.hot = HotStart(nest=self.nest, logger=self.logger)
# self.hot.set_hotstart()
# ------------------- Create Atmospheric forcing --------------------
if self.meteo and not os.path.isfile(
os.path.join(self.rootdir, 'sflux', 'sflux_inputs.txt')):
atm = Meteo(os.path.join(self.rootdir, 'sflux'),
t0=t0,
t1=t1,
dt=self.meteo.pop('dt'),
logger=self.logger)
for key in range(1, len(self.meteo.keys()) + 1):
filename = self.meteo[key].pop('filename')
atm.add_dataset(filename, self.meteo[key])
atm.make_meteo()
if self.meteo and not os.path.isfile(
os.path.join(self.rootdir, 'windrot_geo2proj.gr3')):
## Create the GR3 files
filename = os.path.join(self.rootdir, 'windrot_geo2proj.gr3')
ic = InitialConditions(filename,hgrid=self.hgrid,t0=t0,value=get_convergence(self.hgrid.latitude,self.hgrid.longitude,self.epsg),\
logger=self.logger)
if self.stations and not os.path.isfile(
os.path.join(self.rootdir, 'station.in')):
outputs = self.stations.pop('outputs')
st = Station(os.path.join(self.rootdir, 'station.in'),
self.hgrid,
outputs,
logger=self.logger)
for key in self.stations:
st.add_station(self.stations[key], name=key)
st.write_station()
from meteo import Meteo, mostrar_meteo cs = Meteo(estacion='CS1', temp=[20.2, 19.1, 27.2, 24.8], lluvia=[0, 0, 0, 0]) mostrar_meteo(cs)
def __init__(self, fname_in):
"""
Create and initialize the Crop object.
# Arguments
fname_in (str): path and filename of the model initialization file
"""
Meteo.__init__(self, fname_in) # initialize the parent class first
dinit = self.ini
self.treeage = dinit['treeage'] # tree age (days)
self.plantdens = dinit['plantdens'] # planting density (palms/ha)
self.thinplantdens = dinit[
'thinplantdens'] # thinning planting density (palms/ha)
self.thinage = dinit['thinage'] # thinning tree age (days)
self.femaleprob = dinit[
'femaleprob'] # probability of getting female flowers
nparts = len(Parts._fields)
self.parts = Parts(*list(Part() for _ in range(nparts)))
# load in the N and mineral tables, and for SLA:
dsla = {float(k): v for k, v in dinit['sla'].items()}
self.slatable = AFGen(dsla)
for i in range(nparts):
fieldname = Parts._fields[i]
self.parts[i].weight = dinit[fieldname + '_wgt']
if i < 4:
d1 = dinit[fieldname + '_n']
nd1 = {float(k): v for k, v in d1.items()}
d2 = dinit[fieldname + '_m']
nd2 = {float(k): v for k, v in d2.items()}
self.parts[i].content = Contents(AFGen(nd1), AFGen(nd2))
self.trunkhgt = -1.0 # -1.0 is a code: the initial trunk height will be calculated
self.trunkhgt, self.treehgt = self.tree_height(
1.0) # trunk and full tree height (m)
self.vdmwgt, self.tdmwgt = self.dm_wgts(
) # VDM and total VDM weights (kg DM/palm)
parts = self.parts
# constant partitioning for generative organs (fractions):
parts.maleflo.frac, parts.femaflo.frac, parts.bunches.frac = [
0.159, 0.159, 0.682
]
self.vdmmax = self.vdm_maximum() # maximum VDM (kg DM/palm)
self.laimax = self.lai_maximum() # maximum LAI (m2 leaf/m2 ground)
# LAI (m2 leaf/m2 ground) and SLA (m2 leaf/kg DM)
self.sla, self.lai = self.lookup_sla_lai()
self.vdmreq = 0.0 # VDM requirement (kg DM/palm/day)
self.assim4maint = 0.0 # assimilates for maintenance (kg CH2O/palm/day)
self.assim4growth = 0.0 # assimilates for growth (kg CH2O/palm/day
self.assim4gen = 0.0 # assimilates for generative growth (kg CH2O/palm/day)
# "boxcar train" for the weights (kg DM/palm)of generative organs:
self.boxmaleflo = list(0.0 for _ in range(210)) # for male flowers
self.boxfemaflo = list(
0.0 for _ in range(210)) # for female flowers (immature bunches)
self.boxbunches = list(0.0 for _ in range(150)) # for mature bunches
self.bunchyield = 0.0 # yield (kg DM/palm/year)
# flower sex at the start of bunch/mature phase (0 = male/abort, 1 = female)
self.flowersex = 0
# sex of first flower
self.newflowersex = 0
#!/usr/bin/env python3
#
# simple tests the meteo
from meteo import Meteo
# Berlijn
lat_be = 52.516667
lon_be = 13.416667
rssFreudenstadt = "https://www.meteoalarm.eu/documents/rss/de/DE404.rss"
rssErz = "https://www.meteoalarm.eu/documents/rss/de/DE092.rss"
rssBerlin = "https://www.meteoalarm.eu/documents/rss/de/DE202.rss"
rssKarjala = "https://www.meteoalarm.eu/documents/rss/fi/FI001.rss"
x = Meteo(rssFreudenstadt, "de")
x.dumpMeteoConfig()
x.readMeteoWarning()
x.dumpMeteoStatus()
# just re run
x.readMeteoWarning()
x.dumpMeteoStatus()
print("tdy: " + x.getTodayTitle())
print("tmr:" + x.getTomorrowTitle())
y = Meteo(rssKarjala, "en")
y.dumpMeteoConfig()
y.readMeteoWarning()
y.dumpMeteoStatus()
print("tdy: " + y.getTodayTitle())
print("tmr:" + y.getTomorrowTitle())