bbsg_a05 0.1.1

bbsg_a05
Documentation 
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

use crate::dcl::Pan;
use askama::Template;
use askama_web::WebTemplate;

pub struct WebTempRow {
    sbid: String,
    pvid: String,
    pwmx: f32,
    pwrt: f32,
    regr: Vec<f32>,
}

#[derive(Template, WebTemplate)]
#[template(path = "q02.html")]
pub struct WebTemp {
    name: String,
    rows: Vec<WebTempRow>,
}

use crate::dcl::PeaAssVar;
use crate::dcl::VarType;
use crate::dcl::SSHOW_YEAR_BEG;
use crate::dcl::SSHOW_YEAR_END;
use crate::utl::get_pea00;
use crate::utl::get_sbrw00;
use crate::utl::trf_kva_2_kw;

pub const RE_MV2HV_RATIO: f32 = 0.0986;
use crate::utl::get_scurv_re;

pub async fn q02() -> WebTemp {
    let sbrw = get_sbrw00();
    let pea = get_pea00();
    let mut aids: Vec<_> = pea.aream.keys().collect();
    aids.sort();
    for aid in aids {
        let Some(ar) = pea.aream.get(aid) else {
            continue;
        };
        let mut pids: Vec<_> = ar.provm.keys().collect();
        pids.sort();
        for pid in pids {
            let Some(prov) = ar.provm.get(pid) else {
                continue;
            };
            let mut pvas = PeaAssVar::from(0u64);
            pvas.arid = aid.to_string();
            pvas.pvid = pid.to_string();
            //println!("  pv:{pid}");
            let mut sids: Vec<_> = prov.subm.keys().collect();
            sids.sort();
            for sid in sids {
                let Some(_sb) = prov.subm.get(sid) else {
                    continue;
                };
                //println!("sb:{sid}");
            }
        }
    }
    let mut rows = Vec::<WebTempRow>::new();
    let mut evcs = vec![0f32; sbrw.len()];
    let evs: f32 = sbrw
        .iter()
        .map(|sr| sr.v[VarType::NoHmChgEvTr as usize].v)
        .sum();
    //println!("evs: {evs} {}", sbrw.len());
    for (i, sr) in sbrw.iter().enumerate() {
        //println!("  {}", evcs.len());
        evcs[i] = sr.v[VarType::NoHmChgEvTr as usize].v / evs;
    }
    for (_i, sr) in sbrw.iter().enumerate() {
        let note = format!("{}", sr.v[VarType::TakeNote as usize].v);
        if note != "1" {
            continue;
        }
        if sr.sbid == "SQB" {
            continue;
        }
        let pwmx = sr.v[VarType::SubPowCap as usize].v;
        let pwmx = trf_kva_2_kw(pwmx);
        //let pwrt = RE_MV2HV_RATIO * 0.5f32;
        let pwrt = RE_MV2HV_RATIO;

        //use fast_math;
        let mut regr = get_scurv_re();
        for re in regr.iter_mut() {
            *re *= pwrt * pwmx;
        }
        let rw = WebTempRow {
            sbid: sr.sbid.to_string(),
            pvid: sr.pvid.to_string(),
            pwmx,
            pwrt,
            regr,
        };
        rows.push(rw);
    }

    WebTemp {
        name: "Solar Energy % - q02".to_string(),
        rows,
    }
}