ebi 0.3.14

A stochastic process mining utility and library
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

use ebi_objects::{
    BusinessProcessModelAndNotation, LabelledPetriNet, ProcessTree,
    StochasticBusinessProcessModelAndNotation, StochasticLabelledPetriNet, StochasticProcessTree,
    anyhow::anyhow,
    ebi_arithmetic::{Fraction, One},
    ebi_objects::process_tree::get_number_of_transitions,
};
use ebi_optimisation::anyhow::Result;

pub trait UniformStochasticBusinessProcessModelAndNotation {
    fn mine_uniform_stochastic_business_process_model_and_notation(
        self,
    ) -> Result<StochasticBusinessProcessModelAndNotation>;
}

pub trait UniformStochasticMinerLPN {
    fn mine_uniform_stochastic_lpn(self) -> StochasticLabelledPetriNet;
}

pub trait UniformStochasticMinerTree {
    fn mine_uniform_stochastic_tree(self) -> StochasticProcessTree;
}

impl UniformStochasticBusinessProcessModelAndNotation for BusinessProcessModelAndNotation {
    fn mine_uniform_stochastic_business_process_model_and_notation(
        mut self,
    ) -> Result<StochasticBusinessProcessModelAndNotation> {
        let global_indices = self
            .sequence_flows()
            .iter()
            .map(|sequence_flow| sequence_flow.global_index())
            .collect::<Vec<_>>();

        for global_index in global_indices {
            self.global_index_2_sequence_flow_mut(global_index)
                .ok_or_else(|| anyhow!("sequence flow not found"))?
                .weight = Some(Fraction::one());
        }
        self.try_into()
    }
}

impl UniformStochasticMinerLPN for LabelledPetriNet {
    fn mine_uniform_stochastic_lpn(self) -> StochasticLabelledPetriNet {
        let len = self.transition2input_places.len();
        (self, vec![Fraction::one(); len]).into()
    }
}

impl UniformStochasticMinerTree for ProcessTree {
    fn mine_uniform_stochastic_tree(self) -> StochasticProcessTree {
        let len = get_number_of_transitions(&self) - 1;
        (self, vec![Fraction::one(); len], Fraction::one())
            .try_into()
            .unwrap()
    }
}

#[cfg(test)]
mod tests {
    use std::fs;

    use ebi_objects::{LabelledPetriNet, ProcessTree};

    use crate::techniques::uniform_stochastic_miner::{
        UniformStochasticMinerLPN, UniformStochasticMinerTree,
    };

    #[test]
    fn lpn_uniform() {
        let fin = fs::read_to_string("testfiles/aa-ab-ba.lpn").unwrap();
        let lpn = Box::new(fin.parse::<LabelledPetriNet>().unwrap());
        let slpn = lpn.mine_uniform_stochastic_lpn();
        let fout = fs::read_to_string("testfiles/aa-ab-ba_uni.slpn").unwrap();
        assert_eq!(fout, slpn.to_string())
    }

    #[test]
    fn tree_uniform() {
        let fin = fs::read_to_string("testfiles/seq(a-xor(b-c)).ptree").unwrap();
        let lpn = Box::new(fin.parse::<ProcessTree>().unwrap());
        let slpn = lpn.mine_uniform_stochastic_tree();
        let fout = fs::read_to_string("testfiles/seq(a-xor(b-c))-uniform.sptree").unwrap();
        assert_eq!(fout, slpn.to_string())
    }
}