Merge pull request #15 from aarkue/feat/oc-declare-integration

Feat/oc declare integration

Author: aarkue

Cargo.lock

@@ -10,7 +10,8 @@ serde = {version = "1.0.192" , features = ["derive", "rc"]}
 serde_json = "1.0.108"
 serde_with = "3.11.0"
 ts-rs = { version = "8.1", features = ["serde-compat","chrono-impl"] }
-process_mining = { git = "https://github.com/aarkue/rust4pm", features = ["ocel-sqlite"], branch = "feat/kuzudb" }
+# process_mining = {path = "../../../rust4pm/process_mining", features = ['ocel-sqlite']}
+process_mining = { git = "https://github.com/aarkue/rust4pm", features = ["ocel-sqlite"], branch = "feat/oc-declare" }
 rayon = "1.8.0"
 itertools = "0.11.0"
 chrono = "0.4.33"

backend/Cargo.lock

@@ -22,6 +22,9 @@ pub mod preprocessing {
 }
 pub mod cel;
 pub mod table_export;
+pub mod oc_declare {
+    pub mod statistics;
+}
 
 pub mod hpc_backend;
 #[derive(Debug, Serialize, Deserialize)]

backend/shared/Cargo.toml

@@ -0,0 +1,110 @@
+use std::collections::{HashMap, HashSet};
+
+use process_mining::{
+    object_centric::oc_declare::{
+        perf::get_evs_with_objs_perf, OCDeclareArc, OCDeclareArcType, EXIT_EVENT_PREFIX,
+        INIT_EVENT_PREFIX,
+    },
+    ocel::linked_ocel::{IndexLinkedOCEL, LinkedOCELAccess},
+};
+use serde::{Deserialize, Serialize};
+use ts_rs::TS;
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[ts(export, export_to = "../../../frontend/src/types/generated/")]
+pub struct ActivityStatistics {
+    pub num_evs_per_ot_type: HashMap<String, Vec<usize>>,
+    pub num_obs_of_ot_per_ev: HashMap<String, Vec<usize>>,
+}
+
+pub fn get_activity_statistics(locel: &IndexLinkedOCEL, activity: &str) -> ActivityStatistics {
+    if activity.starts_with(INIT_EVENT_PREFIX) || activity.starts_with(EXIT_EVENT_PREFIX) {
+        let ob_type = if activity.starts_with(INIT_EVENT_PREFIX) {
+            &activity[INIT_EVENT_PREFIX.len() + 1..activity.len()]
+        } else {
+            &activity[INIT_EVENT_PREFIX.len() + 1..activity.len()]
+        };
+        return ActivityStatistics {
+            num_evs_per_ot_type: vec![(
+                ob_type.to_string(),
+                vec![1; locel.get_obs_of_type(ob_type).count()],
+            )]
+            .into_iter()
+            .collect(),
+            num_obs_of_ot_per_ev: vec![(
+                ob_type.to_string(),
+                vec![1; locel.get_obs_of_type(ob_type).count()],
+            )]
+            .into_iter()
+            .collect(),
+        };
+    }
+    // Number of activity events per object (of a type)
+    let mut num_evs_per_type: HashMap<String, Vec<usize>> = HashMap::new();
+    let mut relevant_object_types = HashSet::new();
+    // Number of objects (of a type) per activity
+    let mut num_objects_per_type: HashMap<&String, Vec<usize>> = HashMap::new();
+
+    for ev in locel.get_evs_of_type(activity) {
+        let mut num_obs_of_type_for_ev = HashMap::new();
+        for (_q, ob) in locel.get_e2o(ev) {
+            let ot = &locel[ob].object_type;
+            *num_obs_of_type_for_ev.entry(ot).or_default() += 1
+        }
+        for (a, b) in num_obs_of_type_for_ev {
+            relevant_object_types.insert(a);
+            num_objects_per_type.entry(a).or_default().push(b);
+        }
+    }
+
+    for ot in relevant_object_types {
+        num_evs_per_type.insert(
+            ot.to_string(),
+            locel
+                .get_obs_of_type(&ot)
+                .into_iter()
+                .map(|o| {
+                    locel
+                        .get_e2o_rev(o)
+                        .filter(|(_q, e)| locel[*e].event_type == activity)
+                        .count()
+                })
+                .collect(),
+        );
+    }
+    ActivityStatistics {
+        num_obs_of_ot_per_ev: num_objects_per_type
+            .into_iter()
+            .map(|(k, v)| (k.to_string(), v))
+            .collect(),
+        num_evs_per_ot_type: num_evs_per_type,
+    }
+}
+
+pub fn get_edge_stats(locel: &IndexLinkedOCEL, arc: &OCDeclareArc) -> Vec<i64> {
+    process_mining::object_centric::oc_declare::TriggerEvent::get_all_trigger_evs(
+        locel,
+        arc.from.as_str(),
+    )
+    .iter()
+    .flat_map(|ev_index| {
+        let ev_time = ev_index.get_timestamp(locel);
+        arc.label
+            .get_bindings(ev_index, locel)
+            .flat_map(move |binding| {
+                let target_ev_iterator = get_evs_with_objs_perf(&binding, locel, arc.to.as_str())
+                    .filter(|ev2| {
+                        let ev2_time = ev2.get_timestamp(locel);
+                        match arc.arc_type {
+                            OCDeclareArcType::EF | OCDeclareArcType::DF => ev_time < ev2_time,
+                            OCDeclareArcType::EP | OCDeclareArcType::DP => ev_time > ev2_time,
+                            OCDeclareArcType::AS => true,
+                        }
+                    });
+                // First event (could also implement this for last, or all matching target events)
+                let first_ev = target_ev_iterator.min_by_key(|e| e.get_timestamp(locel));
+                first_ev.map(|ev2| (ev2.get_timestamp(locel) - ev_time).num_milliseconds())
+            })
+    })
+    .collect()
+}

backend/shared/src/lib.rs

@@ -50,13 +50,17 @@ pub async fn load_ocel_file_req(
     State(state): State<AppState>,
     Json(payload): Json<LoadOcel>,
 ) -> (StatusCode, Json<Option<OCELInfo>>) {
-    match load_ocel_file_to_state(&payload.name, &state) {
+    match load_ocel_file_to_state(&payload.name, &state, false) {
         Some(ocel_info) => (StatusCode::OK, Json(Some(ocel_info))),
         None => (StatusCode::BAD_REQUEST, Json(None)),
     }
 }
 
-pub fn load_ocel_file_to_state(name: &str, state: &AppState) -> Option<OCELInfo> {
+pub fn load_ocel_file_to_state(
+    name: &str,
+    state: &AppState,
+    ignore_errors: bool,
+) -> Option<OCELInfo> {
     match load_ocel_file(name) {
         Ok(ocel) => {
             let locel = IndexLinkedOCEL::from_ocel(ocel);
@@ -66,7 +70,9 @@ pub fn load_ocel_file_to_state(name: &str, state: &AppState) -> Option<OCELInfo>
             Some(ocel_info)
         }
         Err(e) => {
-            eprintln!("Error importing OCEL: {e:?}");
+            if !ignore_errors {
+                eprintln!("Error importing OCEL: {e:?}");
+            }
             None
         }
     }

backend/shared/src/oc_declare/statistics.rs

@@ -32,11 +32,13 @@ use ocpq_shared::{
         get_job_status, login_on_hpc, start_port_forwarding, submit_hpc_job, Client,
         ConnectionConfig, JobStatus, OCPQJobOptions,
     },
+    oc_declare::statistics::{get_activity_statistics, get_edge_stats, ActivityStatistics},
     ocel_graph::{get_ocel_graph, OCELGraph, OCELGraphOptions},
     ocel_qualifiers::qualifiers::{
         get_qualifiers_for_event_types, QualifierAndObjectType, QualifiersForEventType,
     },
     preprocessing::preprocess::get_object_rels_per_type,
+    process_mining::object_centric::oc_declare::{self, OCDeclareArc},
     table_export::{export_bindings_to_writer, TableExportOptions},
     EventWithIndex, IndexOrID, OCELInfo, ObjectWithIndex,
 };
@@ -78,9 +80,8 @@ async fn main() {
     // .allow_headers([CONTENT_TYPE])
     // .allow_origin(tower_http::cors::Any);
 
-    load_ocel_file_to_state(DEFAULT_OCEL_FILE, &state);
+    load_ocel_file_to_state(DEFAULT_OCEL_FILE, &state, true);
 
-    // build our application with a single route
     let app = Router::new()
         .route("/ocel/load", post(load_ocel_file_req))
         .route("/ocel/info", get(get_loaded_ocel_info))
@@ -119,6 +120,22 @@ async fn main() {
             "/ocel/discover-constraints",
             post(auto_discover_constraints_handler),
         )
+        .route(
+            "/ocel/discover-oc-declare",
+            post(auto_discover_oc_declare_handler),
+        )
+        .route(
+            "/ocel/evaluate-oc-declare-arcs",
+            post(evaluate_oc_declare_arcs_handler),
+        )
+        .route(
+            "/ocel/get-activity-statistics",
+            post(get_activity_statistics_handler),
+        )
+        .route(
+            "/ocel/get-oc-declare-edge-statistics",
+            post(get_oc_declare_edge_statistics_handler),
+        )
         .route(
             "/ocel/export-bindings",
             post(export_bindings_table).layer(DefaultBodyLimit::disable()),
@@ -305,6 +322,40 @@ pub async fn auto_discover_constraints_handler<'a>(
     }))
 }
 
+pub async fn auto_discover_oc_declare_handler(
+    state: State<AppState>,
+    Json(req): Json<oc_declare::OCDeclareDiscoveryOptions>,
+) -> Json<Option<Vec<OCDeclareArc>>> {
+    Json(with_ocel_from_state(&state, |locel| {
+        oc_declare::discover_behavior_constraints(&locel, req)
+    }))
+}
+pub async fn evaluate_oc_declare_arcs_handler(
+    state: State<AppState>,
+    Json(req): Json<Vec<oc_declare::OCDeclareArc>>,
+) -> Json<Option<Vec<f64>>> {
+    Json(with_ocel_from_state(&state, |locel| {
+        req.iter()
+            .map(|arc| arc.get_for_all_evs_perf(&locel))
+            .collect()
+    }))
+}
+pub async fn get_activity_statistics_handler(
+    state: State<AppState>,
+    Json(req): Json<String>,
+) -> Json<Option<ActivityStatistics>> {
+    Json(with_ocel_from_state(&state, |ocel| {
+        get_activity_statistics(ocel, &req)
+    }))
+}
+pub async fn get_oc_declare_edge_statistics_handler(
+    state: State<AppState>,
+    Json(req): Json<OCDeclareArc>,
+) -> Json<Option<Vec<i64>>> {
+    Json(with_ocel_from_state(&state, |ocel| {
+        get_edge_stats(ocel, &req)
+    }))
+}
 pub async fn export_bindings_table(
     state: State<AppState>,
     Json((node_index, table_options)): Json<(usize, TableExportOptions)>,