File size: 7,686 Bytes
124816b
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
import math
from datetime import datetime, timezone
from typing import Optional,Literal
from pydantic import BaseModel,Field,ConfigDict,model_validator
from .store import put,get,all_records,now

class Telemetry(BaseModel):
    model_config=ConfigDict(extra='forbid',allow_inf_nan=False)
    device_id:str=Field(min_length=1,max_length=64)
    packet_id:Optional[str]=Field(default=None,min_length=1,max_length=120)
    sequence:Optional[int]=Field(default=None,ge=0)
    measured_at:datetime
    solar_voltage_v:Optional[float]=Field(default=None,ge=0,le=100)
    solar_current_a:Optional[float]=Field(default=None,ge=0,le=20)
    battery_voltage_v:Optional[float]=Field(default=None,ge=0,le=100)
    consumption_w:Optional[float]=Field(default=None,ge=0,le=1000)
    battery_soc_pct:Optional[float]=Field(default=None,ge=0,le=100)
    soc_method:Literal['unavailable','fuel-gauge','coulomb-counting','simulated']='unavailable'
    temperature_c:Optional[float]=Field(default=None,ge=-80,le=100)
    humidity_pct:Optional[float]=Field(default=None,ge=0,le=100)
    pressure_hpa:Optional[float]=Field(default=None,ge=300,le=1200)
    illuminance_lux:Optional[float]=Field(default=None,ge=0,le=200000)
    provenance:Literal['MEASURED','SIMULATED']='MEASURED'

    @model_validator(mode='after')
    def timestamps(self):
        from datetime import timedelta
        if self.measured_at.tzinfo is None:raise ValueError('Telemetry timestamp requires a timezone')
        if self.measured_at>datetime.now(timezone.utc)+timedelta(minutes=5):raise ValueError('Telemetry cannot be measured in the future')
        return self

def power(t:Telemetry):
    d=t.model_dump(mode='json');d['received_at']=now()
    d['solar_power_w']=t.solar_voltage_v*t.solar_current_a if t.solar_voltage_v is not None and t.solar_current_a is not None else None
    if t.soc_method=='unavailable': d['battery_soc_pct']=None
    d['warning']='Battery SOC requires a fuel gauge or calibrated coulomb counting; voltage alone is insufficient'
    return d

class EnergyPolicy(BaseModel):
    capacity_wh:float=Field(default=20,gt=0,le=10000)
    reserve_pct:float=Field(default=25,ge=0,le=90)
    ai_cost_wh:float=Field(default=.08,ge=0,le=10)
    transmission_cost_wh:float=Field(default=.03,ge=0,le=10)

def schedule(t,policy:EnergyPolicy):
    soc=t.get('battery_soc_pct');energy=None if soc is None else soc/100*policy.capacity_wh
    available=None if energy is None else max(0,energy-policy.capacity_wh*policy.reserve_pct/100)
    decisions=[{'task':'essential monitoring','action':'KEEP','reason':'Highest priority; use available hardware readings'},
               {'task':'storage integrity','action':'KEEP','reason':'Preserve observations while processing is deferred'}]
    for task,cost in [('capture',.005),('AI processing',policy.ai_cost_wh),('transmission',policy.transmission_cost_wh)]:
        run=available is not None and available>=cost
        decisions.append({'task':task,'action':'ALLOW' if run else 'DEFER','cost_wh':cost,'reason':'Within reserve budget' if run else 'Unknown energy or reserve threshold reached'})
        if run: available-=cost
    return {'reserve_wh':energy,'decisions':decisions,'assumptions':policy.model_dump(),'warning':'Prototype scheduling; not a validated orbital energy budget'}

def demo_energy(low=False):
    rows=[];soc=18. if low else 78.; generated=0.;used=0.
    for minute in range(0,121,5):
        voltage=5.1;current=max(0,.7*math.sin(math.pi*minute/120));load=1.4
        if minute: generated+=voltage*current*5/60;used+=load*5/60;soc=max(0,min(100,(18. if low else 78.)+(generated-used)/20*100))
        rows.append({'minute':minute,'solar_power_w':voltage*current,'consumption_w':load,'battery_soc_pct':soc,'generated_wh':generated,'used_wh':used})
    t=power(Telemetry(device_id='demo-power',measured_at=datetime.now(timezone.utc),solar_voltage_v=voltage,solar_current_a=current,
        consumption_w=load,battery_soc_pct=soc,soc_method='simulated',provenance='SIMULATED'))
    return {'provenance':'SIMULATED','series':rows,'latest':t,'policy':schedule(t,EnergyPolicy())}

class QueueItem(BaseModel):
    name:str=Field(max_length=120)
    kind:Literal['mask','risk','metadata','crop','image']='metadata'
    size_bytes:int=Field(gt=0,le=100_000_000)
    priority:int=Field(default=50,ge=0,le=100)
    asset_id:Optional[str]=None

def enqueue(item):
    occupied=sum(j['size_bytes'] for j in all_records('queue') if j['state']!='sent')
    if occupied+item.size_bytes>100_000_000: raise ValueError('Simulated storage capacity exceeded (100 MB)')
    return put('queue',{**item.model_dump(),'created_at':now(),'sent_bytes':0,'state':'queued','retries':0,'provenance':'SIMULATED LINK'})

def transmit(seconds,rate_kbps,link_open,energy_allowed):
    budget=int(seconds*rate_kbps*1000/8) if link_open and energy_allowed else 0
    moved=0
    for j in sorted(all_records('queue'),key=lambda j:(-j['priority'],j['created_at'])):
        if j['state'] not in ('queued','transmitting'): continue
        amount=min(budget,j['size_bytes']-j['sent_bytes']);j['sent_bytes']+=amount;budget-=amount;moved+=amount
        if amount: j['state']='sent' if j['sent_bytes']>=j['size_bytes'] else 'transmitting';put('queue',j,j['id'])
    return {'transmitted_bytes':moved,'link_open':link_open,'energy_allowed':energy_allowed,'provenance':'SIMULATED LINK','items':all_records('queue')}

def cloud_assessment(weather=None,baseline=None,enhanced=None):
    factors=[];missing=['cloud microphysics','vertical cloud structure','in-cloud temperature and liquid water','updraft observations']
    if weather:
        times=weather.get('hourly',{}).get('time',[])
        # Use provider time nearest current UTC rather than first midnight record.
        current=datetime.now(timezone.utc).replace(tzinfo=None)
        idx=min(range(len(times)),key=lambda i:abs((datetime.fromisoformat(times[i]).replace(tzinfo=None)-current).total_seconds())) if times else None
        for key in ('temperature_2m','relative_humidity_2m','cloud_cover','wind_speed_10m','precipitation'):
            values=weather.get('hourly',{}).get(key,[])
            val=values[idx] if idx is not None and idx<len(values) else None
            factors.append({'factor':key,'value':val,'unit':weather.get('units',{}).get(key),'source':weather.get('source'),
                'time':times[idx] if idx is not None else None,'status':weather.get('provenance') if val is not None else 'UNAVAILABLE',
                'interpretation':'Surface/grid context only; does not establish seedability'})
    difference=None
    if baseline and enhanced:
        b,e=baseline['frames'][-1],enhanced['frames'][-1]
        difference={'area_km2':e['area_km2']-b['area_km2'],'exposed_features':e['exposed_count']-b['exposed_count'],
            'baseline_id':baseline['id'],'enhanced_id':enhanced['id'],'assumed_rain_increase_pct':(enhanced['config']['rainfall_mm_h']/baseline['config']['rainfall_mm_h']-1)*100 if baseline['config']['rainfall_mm_h'] else None}
    for factor in factors:
        if factor.get('time'):
            stamp=datetime.fromisoformat(factor['time'].replace('Z','+00:00'))
            factor['time']=(stamp.replace(tzinfo=timezone.utc) if stamp.tzinfo is None else stamp.astimezone(timezone.utc)).isoformat()
    return {'status':'INSUFFICIENT DATA','created_at':now(),'factors':factors,'missing':missing,'comparison':difference,
        'warnings':['Additional rainfall may worsen runoff and flooding','Rainfall enhancement is a user assumption, not a prediction of cloud-seeding effectiveness','No operational recommendation or actuation; qualified atmospheric assessment required']}