bbsg_a01 0.1.2

num bbsg_a01
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

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

pub struct WebTempRow {
    sbid: String,
    pvid: String,
    note: String,
    evrt: f32,
    evgr: Vec<f32>,
}

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

use crate::dcl::PeaAssVar;
use crate::dcl::VarType;
use crate::dcl::EV_AT_2050;
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::get_scurv;

pub async fn p02() -> 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 evrt = evcs[i];

        //use fast_math;
        let mut evgr = get_scurv();
        for ev in evgr.iter_mut() {
            *ev *= evrt * EV_AT_2050;
        }
        let rw = WebTempRow {
            sbid: sr.sbid.to_string(),
            pvid: sr.pvid.to_string(),
            note,
            evrt,
            evgr,
        };
        rows.push(rw);
    }

    WebTemp {
        name: "Number of EV Car - p02".to_string(),
        rows,
    }
}