scipplan 0.2.1a0__py2.py3-none-any.whl → 0.2.2a0__py2.py3-none-any.whl

build/lib/scipplan/plan_model.py

@@ -0,0 +1,339 @@
+from .config import Config
+from .variables import Variable, VarType
+from .parse_model import ParseModel as PM, EvalParams
+from .helpers import list_accessible_files
+
+import math
+import os
+import re
+
+from pyscipopt.scip import Model
+from pkg_resources import parse_version
+from importlib.metadata import version
+from sympy import Eq, Function, Derivative as dd, Symbol, parse_expr
+from sympy.solvers.ode.systems import dsolve_system
+
+
+if parse_version(version("pyscipopt")) >= parse_version("4.3.0"):
+    from pyscipopt import quicksum, exp, log, sqrt, sin, cos
+    allow_trig_funcs = True
+else:
+    from pyscipopt import quicksum, exp, log, sqrt 
+    allow_trig_funcs = False
+
+class PlanModel:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+        self.var_names: set[str] = set()
+        
+        self.model = Model(f"{config.domain}_{config.instance}_{config.horizon}")
+        
+        # Translation -> line_num -> horizon -> aux
+        self.aux_vars: dict[str, list[list[list]]] = {}
+        
+        self.file_translations = self.read_translations()
+
+        self.constants = self.encode_constants()
+        self.variables = self.encode_pvariables()
+        self.translations = self.encode_constraints()
+        
+        self.rewards = self.encode_reward()
+        
+        # Encode bounds on Dt
+        for h in range(self.config.horizon):
+            dt_var = self.variables[(self.config.dt_var, h)].model_var
+            self.model.addCons(dt_var >= 0.0, f"dt_{h}_lower_bound")
+            self.model.addCons(dt_var <= self.config.bigM, f"dt_{h}_upper_bound")   
+    
+    def read_translations(self) -> dict[str, list[str]]:
+        with open(self.get_file_path("solutions" if self.config.provide_sols else "odes")) as f:
+            translations = {}
+            new_sec = True
+            for line in f:
+                line = line.strip()
+                if line == "":
+                    pass
+                elif line == "---":
+                    new_sec = True
+                elif new_sec is True:
+                    translation = line.removesuffix(":")
+                    translations[translation] = []
+                    new_sec = False
+                else:
+                    translations[translation].append(line)
+        
+        return translations
+
+
+
+    def encode_constants(self) -> dict[str, float]:
+        constants = {}
+        translation = "constants"
+        config_vals = {
+            # Since horizon can be incremented without this value being updated, it will be removed for the time being
+            # "config_horizon": self.config.horizon,
+            "config_epsilon": self.config.epsilon,
+            "config_gap": self.config.gap,
+            "config_bigM": self.config.bigM
+        }
+    
+            
+        for line in self.file_translations[translation]:
+
+            var, val = line.split("=")
+            var, val = var.strip(), val.strip()
+            
+            val = val if val not in config_vals else config_vals[val]
+            
+            try:
+                val = float(val)
+            except ValueError:
+                raise ValueError("Constants can only be floats, please reconfigure: ")
+            
+            constants[var] = val
+            self.var_names.add(var)
+                
+        constants["bigM"] = self.config.bigM
+        self.var_names.add("bigM")
+        return constants
+                
+        
+    def encode_pvariables(self) -> dict[tuple[str, int], Variable]:
+        variables: dict[tuple[str, int], Variable] = {}
+        for t in range(self.config.horizon):
+            for constant, val in self.constants.items():
+                variables[(constant, t)] = Variable.create_var(self.model, constant, "constant", t, self.constants)
+                var_type = variables[(constant, t)].var_type
+                
+        translation = "pvariables"
+        for line in self.file_translations[translation]:
+            
+            var = line.rstrip("\n").strip()
+            if var == "":
+                continue
+            vtype, name = var.split(": ")
+            vtype, name = vtype.strip(), name.strip()
+            
+            self.var_names.add(name)
+            
+            if vtype.startswith("global"):
+                var = Variable.create_var(self.model, name, vtype, "global", self.constants)
+                for t in range(self.config.horizon + 1):
+                    variables[(name, t)] = var
+            else:
+                for t in range(self.config.horizon):
+                    variables[(name, t)] = Variable.create_var(self.model, name, vtype, t, self.constants)
+                    var_type = variables[(name, t)].var_type
+                if var_type is VarType.STATE:
+                    variables[(name, self.config.horizon)] = Variable.create_var(self.model, name, vtype, self.config.horizon, self.constants)
+
+        return variables
+                
+         
+         
+    def encode_constraints(self) -> dict[str, list[str]]:
+        translation_names = [
+            "initials",
+            "instantaneous_constraints",
+            "temporal_constraints",
+            "goals",
+            "odes" if self.config.provide_sols is False else "transitions"
+        ]
+        translations: dict[str, list[str]] = {}
+        for translation in translation_names:
+            translations[translation] = []
+            
+            for line in self.file_translations[translation]:
+                expr = line.rstrip("\n").strip()
+                # If line is empty don't append
+                if expr == "":
+                    continue
+                
+                translations[translation].append(expr)
+
+        if self.config.provide_sols is False: 
+            self.ode_functions = self.solve_odes(translations["odes"])
+
+            translations["transitions"] = []
+            for func_name, func in self.ode_functions.items():
+                translations["transitions"].append((func_name + "_dash" + " == " + func))
+            
+            del translations["odes"]
+            
+
+        # Encode constraints into model
+        for cons_idx, (translation, constraints) in enumerate(translations.items()):
+            for idx, constraint in enumerate(constraints):
+                if (self.config.provide_sols is False) and (translation == "temporal_constraints"):
+                    pattern = r"|".join(f"({func_name})" for func_name, func in self.ode_functions.items())
+                    constraint = re.sub(pattern, lambda x: self.ode_functions[x.group(0)], constraint)
+                    constraints[idx] = constraint
+                    
+                if translation == "initials":
+                    exprs = PM(self.get_parser_params(horizon=0, add_aux_vars=True)).evaluate(constraint, horizon=0, expr_name=f"{translation}_{idx}_0")
+                    
+                    if self.aux_vars.get(translation) is None: self.aux_vars[translation] = [None] * len(constraints)
+                    if self.aux_vars[translation][idx] is None: self.aux_vars[translation][idx] = [None] * self.config.horizon
+                    self.aux_vars[translation][idx][0] = exprs.aux_vars
+
+                    for eqtn_idx, eqtn in enumerate(exprs):
+                        self.model.addCons(eqtn, f"{translation}_{idx}_{eqtn_idx}")
+                        
+                elif translation == "goals":
+                    # horizon - 1 is because the final action time is horizon - 1
+                    exprs = PM(self.get_parser_params(horizon=self.config.horizon - 1, is_goal=True, add_aux_vars=True)).evaluate(constraint, horizon=self.config.horizon - 1, expr_name=f"{translation}_{idx}_{self.config.horizon - 1}")
+                    
+                    if self.aux_vars.get(translation) is None: self.aux_vars[translation] = [None] * len(constraints)
+                    if self.aux_vars[translation][idx] is None: self.aux_vars[translation][idx] = [None] * self.config.horizon
+                    self.aux_vars[translation][idx][self.config.horizon - 1] = exprs.aux_vars
+                    
+                    for eqtn_idx, eqtn in enumerate(exprs):
+                        self.model.addCons(eqtn, f"{translation}_{idx}_{eqtn_idx}")
+                else:
+                    for t in range(self.config.horizon):
+                        exprs = PM(self.get_parser_params(horizon=t, add_aux_vars=True)).evaluate(constraint, horizon=t, expr_name=f"{translation}_{idx}_{t}")
+                        
+                        if self.aux_vars.get(translation) is None: self.aux_vars[translation] = [None] * len(constraints)
+                        if self.aux_vars[translation][idx] is None: self.aux_vars[translation][idx] = [None] * self.config.horizon
+                        self.aux_vars[translation][idx][t] = exprs.aux_vars
+                        
+                        for eqtn_idx, eqtn in enumerate(exprs):
+                            self.model.addCons(eqtn, f"{translation}_{idx}_{eqtn_idx}")
+                    
+        return translations
+    
+    def encode_reward(self):
+        objectives = [None] * self.config.horizon
+        translation = "reward"
+        reward = self.file_translations[translation][0]
+        for t in range(self.config.horizon):
+            objectives[t] = self.model.addVar(f"Obj_{t}", vtype="C", lb=None, ub=None)
+            # For the sake of similarity the reward is similar to constraint parsing, however, only one reward function is allowed
+            exprs = PM(self.get_parser_params(t)).evaluate(reward)
+            for expr_idx, expr in enumerate(exprs):
+                self.model.addCons(objectives[t] == expr, f"Obj_{t}_{expr_idx}")
+            
+        self.model.setObjective(quicksum(objectives), "maximize")
+            
+        return objectives
+            
+            
+
+    def get_parser_params(self, horizon: int, is_goal: bool = False, add_aux_vars: bool = False) -> EvalParams:
+        functions = {
+            "exp": exp, 
+            "log": log, 
+            "sqrt": sqrt, 
+        }
+        if allow_trig_funcs:
+            functions["sin"] = sin 
+            functions["cos"] = cos 
+            
+        variables = {}
+        operators = {}
+        if is_goal:
+            for name in self.var_names:
+                var = self.variables[(name, horizon)]
+                if var.var_type is VarType.STATE:
+                    var = self.variables[(name, horizon + 1)]
+                variables[var.name] = var.model_var
+        else:
+            for name in self.var_names:
+                var = self.variables[(name, horizon)]
+                variables[var.name] = var.model_var
+                if var.var_type is VarType.STATE:
+                    var = self.variables[(name, horizon + 1)]
+                    variables[f"{var.name}_dash"] = var.model_var
+            
+        return EvalParams.as_parser(variables, functions, operators, self.model, add_aux_vars)
+    
+
+    def get_calc_params(self, horizon, dt) -> EvalParams:
+        functions = {
+            "exp": math.exp, 
+            "log": math.log, 
+            "sqrt": math.sqrt, 
+        }
+        if allow_trig_funcs:
+            functions["sin"] = math.sin 
+            functions["cos"] = math.cos
+        
+        variables = {}
+        operators = {}
+        for name in self.var_names:
+            var = self.variables[(name, horizon)]
+            if var.var_type is VarType.CONSTANT:
+                variables[var.name] = var.model_var
+            else:
+                variables[var.name] = self.model.getVal(var.model_var)
+                
+                if var.var_type is VarType.STATE:
+                    var = self.variables[(name, horizon + 1)]
+                    variables[f"{var.name}_dash"] = self.model.getVal(var.model_var)
+        
+        variables[self.config.dt_var] = dt
+        
+        
+        return EvalParams.as_calculator(variables, functions, operators, self.model)
+    
+    
+    def get_file_path(self, translation: str) -> str:
+        path = f"{translation}_{self.config.domain}_{self.config.instance}.txt"
+        
+        usr_files_path = os.path.join("./", "translation")
+        usr_files = list_accessible_files(usr_files_path)
+        
+        pkg_files_path = os.path.join(os.path.dirname(__file__), "translation")
+        pkg_files = list_accessible_files(pkg_files_path)
+        
+        
+        if path in usr_files:
+            return os.path.join(usr_files_path, path)
+        elif path in pkg_files:
+            return os.path.join(pkg_files_path, path)
+        else:
+            raise Exception("Unkown file name, please enter a configuration for a valid domain instance in translation: ")
+        
+
+    def solve_odes(self, ode_system: list[str]) -> dict[str, str]:
+        dt_var = self.config.dt_var
+
+        dt = Symbol(dt_var)
+        # Used to represent constant variables
+        temp_var = Symbol("ODES_TEMP_VAR")
+
+        variables = {}
+        states = []
+
+        for var_name in self.var_names:
+            var = self.variables[(var_name, 0)]
+            if var.var_type is VarType.STATE:
+                states.append(var.name)
+                variables[var.name] = Function(var.name)(dt)
+            elif var.var_type is VarType.CONSTANT:
+                variables[var.name] = self.constants[var.name]
+            else: # the variable is an action or aux variable which is encoded as a function of some unused variable as workaround to not being able to use symbols for constants
+                variables[var.name] = Function(var.name)(temp_var)
+        
+        variables[dt_var] = dt
+        
+        system = []
+        for eqtn in ode_system:
+            lhs, rhs = eqtn.split("==")
+            lhs = parse_expr(lhs.strip(), local_dict=variables | {"dd": dd})
+            rhs = parse_expr(rhs.strip(), local_dict=variables | {"dd": dd})
+            system.append(Eq(lhs, rhs))
+        results = dsolve_system(system, ics={variables[state].subs(dt, 0): state for state in states})
+
+
+
+        functions: dict[str, str] = {}
+        for eqtn in results[0]:
+            new_eqtn = eqtn.doit()
+            func_name = new_eqtn.lhs.name.replace(f"({temp_var.name})", "").replace(f"({self.config.dt_var})", "_dash")
+            functions[func_name] = str(new_eqtn.rhs).replace(f"({temp_var.name})", "").replace(f"({self.config.dt_var})", "_dash")
+        
+        
+        return functions
+
+

build/lib/scipplan/scipplan.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+import time
+
+from .config import Config
+from .plan_model import PlanModel
+from .variables import VarType
+from .zero_crossing import ZeroCrossing
+from .parse_model import ParseModel as PM
+from .helpers import InfeasibilityError, iterate, write_to_csv
+
+from importlib.metadata import version
+from pyscipopt.scip import Model
+
+class SCIPPlan:
+    """
+    SCIPPlan is a planner which optimises mixed integer non-linear programming problems over hybrid domains
+    
+    In order to use SCIPPlan you must pass in as input a Config object which contains the configuration of the problem.
+    Then you may either use the optimize or solve methods.
+    
+    The optimize method attempts to optimise the problem for the provided horizon. 
+    If there are no feasible solutions, then the optimize method will raise InfeasibilityError.
+    
+    The solve method attempts to solve the problem starting with the provided horizon.
+    If there are no feasible solutions for the current horizon then the configs horizon will be incremented.
+    After which the solve method will attempt to optimize the problem again.
+    """
+
+    def __init__(self, config: Config) -> None:
+        self.config = config
+        self.plan = PlanModel(self.config)
+        self.scip_model = self.plan.model
+        
+        self.scip_model.setRealParam("limits/gap", self.config.gap)
+        
+        if config.show_output is False:
+            self.scip_model.hideOutput()
+        
+        self.results_table = []
+        self.new_constraints = []
+        
+        self.state_actions = []
+               
+
+    def optimize(self):
+        iteration = 0
+        
+        const_gen_aux_vars = [[None] * self.config.horizon for _ in range(len(self.plan.translations["temporal_constraints"]))]
+
+        while True:
+            self.scip_model.optimize()
+            
+            if len(self.scip_model.getSols()) == 0:
+                raise InfeasibilityError
+
+            zero_cross = self.check_violated_constraints(iteration)
+                
+            self.save_values(iteration)
+            
+            if zero_cross.is_violated is False:
+                return None
+            
+            self.new_constraints.append({
+                "interval_start": zero_cross.start,
+                "interval_end": zero_cross.end,
+                "dt_interval": zero_cross.dt_interval,
+                "zero_crossing_coefficient": zero_cross.coef,
+                "new_dt_val": zero_cross.new_dt_val,
+                "horizon": zero_cross.horizon,
+                "iteration": zero_cross.iteration,
+                "constraint_idx": zero_cross.constraint_idx
+            })
+            
+            if self.config.show_output is True:
+                print("\n\n")
+                print("New Constraints: \n")
+                for new_constraint in self.new_constraints:
+                    print(new_constraint, end="\n\n")
+                print("\n\n")
+            
+            self.scip_model.freeTransform()
+            
+            t = zero_cross.horizon
+            idx = zero_cross.constraint_idx
+            constraint = self.plan.translations["temporal_constraints"][idx]
+            aux_vars = self.plan.aux_vars["temporal_constraints"][idx][t]
+            # Only add aux vars if there are no aux vars added for the specific constraint
+            params = self.plan.get_parser_params(horizon=t, add_aux_vars=aux_vars is None)
+            params.variables[self.config.dt_var] *= zero_cross.coef
+            exprs = PM(params).evaluate(constraint, aux_vars=aux_vars)
+            if const_gen_aux_vars[idx][t] is None:
+                const_gen_aux_vars[idx][t] = exprs.aux_vars
+             
+            for eqtn_idx, eqtn in enumerate(exprs):
+                self.plan.model.addCons(eqtn, f"{constraint}_{idx}_{eqtn_idx}")
+            
+            iteration += 1
+
+    
+    def check_violated_constraints(self, iteration: int) -> ZeroCrossing:
+        is_violated = False
+        cross_interval = [-1.0 * self.config.epsilon, -1.0 * self.config.epsilon]
+        
+        for h in range(self.config.horizon):
+            dt = self.scip_model.getVal(self.plan.variables[(self.config.dt_var, h)].model_var)
+            
+            for idx, constraint in enumerate(self.plan.translations["temporal_constraints"]):
+                is_violated = False
+                
+                for time in iterate(0, dt, self.config.epsilon):
+                    pm = PM(self.plan.get_calc_params(horizon=h, dt=time))
+                    exprs = pm.evaluate(constraint)
+                    
+                    for eqtn_idx, constraint_eval in enumerate(exprs):
+                        if constraint_eval is False:
+                            if not is_violated:
+                                # Set interval start when first part of zero crossing is found
+                                is_violated = True
+                                cross_interval[0] = time
+                            
+                            # Keep updating end point until end of zero crossing or end of dt interval
+                            cross_interval[1] = time
+                        
+                if is_violated and (constraint_eval is True or time + self.config.epsilon > dt):
+                    return ZeroCrossing(
+                        is_violated=True,
+                        horizon=h,
+                        iteration=iteration,
+                        start=cross_interval[0],
+                        end=cross_interval[1],
+                        dt_interval=dt,
+                        constraint_idx = idx,
+                    )
+        
+        return ZeroCrossing(is_violated=False)
+        
+    
+     
+    @classmethod
+    def solve(cls, config: Config) -> tuple[SCIPPlan, float]:
+        # Time total solve time including incrementing horizon
+        start_time = time.time()
+        while True:
+            model = SCIPPlan(config)
+            try:
+                print(f"Encoding the problem over horizon h={config.horizon}.")
+                print("Solving the problem.")
+                model.optimize()
+                                
+                solve_time = (time.time() - start_time)
+                # print(f"Total Time: {solve_time: .3f} seconds")
+                print("Problem solved. \n")
+                return model, solve_time 
+                    
+            
+            except InfeasibilityError:    
+                if config.get_defaults().get("horizon") is False:
+                    print(f"Horizon of h={model.config.horizon} is infeasible.")
+
+                    solve_time = (time.time() - start_time)
+                    print(f"Total time: {solve_time:.3f}")
+
+                    raise InfeasibilityError
+                    
+                
+                # print("Problem is infeasible for the given horizon.")
+                print(f"Horizon of h={model.config.horizon} is infeasible, incrementing to h={model.config.horizon + 1}.")
+                config.increment_horizon()
+                if config.show_output is True:
+                    print(f"Horizon Time: {(time.time() - start_time): .3f} seconds.")
+        
+
+    def save_values(self, iteration: int):
+        for (name, h), var in self.plan.variables.items():
+            self.results_table.append(var.to_dict() | {"iteration": iteration})           
+    
+
+def main():    
+    print(f"SCIP Version: {Model().version()}")
+    print(f"PySCIPOpt Version: {version('pyscipopt')}\n")
+    config = Config.get_config()
+    print(config)
+    
+    try:
+        plan, solve_time = SCIPPlan.solve(config)  
+    except InfeasibilityError:
+        return None
+    
+    if config.save_sols is True:
+        write_to_csv("new_constraints", plan.new_constraints, config)
+        write_to_csv("results", plan.results_table, config)
+        print("Solutions saved: \n")
+        
+        
+    print("Plan: ")
+    
+    # Get action variable names
+    action_names = [
+        var_name for var_name in plan.plan.var_names 
+        if plan.plan.variables[(var_name, 0)].var_type is VarType.ACTION
+        ]
+    
+    action_names = sorted(action_names)
+    
+    for step in range(plan.config.horizon):
+        for action_name in action_names:
+            if action_name == config.dt_var:
+                continue
+            print(f"{action_name} at step {step} by value {plan.scip_model.getVal(plan.plan.variables[(action_name, step)].model_var):.3f}.")
+        
+        print(f"Dt at step {step} by value {plan.scip_model.getVal(plan.plan.variables[('Dt', step)].model_var):.3f}. \n")
+    
+    print(f"Total reward: {(plan.scip_model.getObjVal()):.3f}")
+    print(f"Total time: {solve_time:.3f}")
+
+if __name__ == "__main__":
+    main()

build/lib/scipplan/variables.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Union
+
+from pyscipopt.scip import Model, Variable as SCIPVariable
+
+@dataclass
+class Variable:
+    name: str
+    var_type: VarType
+    val_type: ValType
+    time: int
+    model: Model
+    model_var: Union[SCIPVariable | float]
+    
+    @classmethod
+    def create_var(cls, model: Model, name: str, vtype: str, time: int, const_vals: dict[str, float]) -> Variable:
+        
+        if "action" in vtype:
+            var_type = VarType.ACTION
+        elif "state" in vtype:
+            var_type = VarType.STATE
+        elif "auxiliary" in vtype:
+            var_type = VarType.AUX
+        elif "constant" in vtype:
+            var_type = VarType.CONSTANT
+        else: # var type isn't recognised
+            raise Exception("Unknown variable type: ")
+        
+        if "continuous" in vtype:
+            val_type = ValType.CONTINUOUS
+        elif "integer" in vtype:
+            val_type = ValType.INTEGER
+        elif "boolean" in vtype:
+            val_type = ValType.BOOLEAN
+        elif var_type is VarType.CONSTANT:
+            # Special case for constants as the value type doesn't matter for the model as it is numeric
+            val_type = None
+        else: # val type isn't recognised
+            raise Exception("Unkown value type: ")
+        
+        if var_type is VarType.CONSTANT:
+            model_var = const_vals[name]
+        else:
+            model_var = model.addVar(name=f"{name}_{time}", vtype=val_type.value, lb=None, ub=None)
+        
+        var = Variable(
+            name=name,
+            var_type=var_type,
+            val_type=val_type,
+            time=time,
+            model=model,
+            model_var=model_var
+        )
+        
+        return var
+    
+    def to_dict(self):
+        if self.var_type is VarType.CONSTANT:
+            var_val = self.model_var
+            val_type = None
+        else:
+            val_type = self.val_type.name
+            try:
+                var_val = self.model.getVal(self.model_var)
+            except Warning:
+                var_val = None
+        
+             
+        return {
+            "name": self.name,
+            "variable_type": self.var_type.name,
+            "value_type": val_type,
+            "horizon": self.time,
+            "variable_value": var_val
+        }
+
+
+
+class VarType(Enum):
+    ACTION = "action"
+    STATE = "state"
+    AUX = "auxiliary"
+    CONSTANT = "constant"
+
+class ValType(Enum):
+    CONTINUOUS = "C"
+    INTEGER = "I"
+    BOOLEAN = "B"

build/lib/scipplan/zero_crossing.py

@@ -0,0 +1,29 @@
+from dataclasses import field, dataclass
+from textwrap import dedent
+
+@dataclass
+class ZeroCrossing:
+    is_violated: bool = field(repr=False)
+    iteration: int = None
+    horizon: int = None
+    start: float = None
+    end: float = None
+    dt_interval: float = None
+    coef: float = field(init=False, default=None)
+    new_dt_val: float = field(init=False, default=None)
+    constraint_idx: int = None
+    
+    def __post_init__(self):
+        if self.is_violated is True:
+            if self.start is None or self.end is None or self.dt_interval is None:
+                raise ValueError(
+                    dedent(f"""
+                    Incorrect input values, start, end and dt_interval have to be specified when zero crossing exists
+                    
+                    {self.start = }
+                    {self.end = }
+                    {self.dt_interval = }
+                    """))
+            avg_interval = (self.start + self.end) / 2.0
+            self.coef = avg_interval / self.dt_interval
+            self.new_dt_val = self.coef * self.dt_interval

scipplan/__init__.py

@@ -1,5 +1,5 @@
-__version__ = "0.2.1alpha0"
+__version__ = "0.2.2alpha0"
 print(f"SCIPPlan Version: {__version__}")
-__release__ = "v0.2.1a0"
+__release__ = "v0.2.2a0"
 __author__ = "Ari Gestetner, Buser Say"
-__email__ = "ari.gestetner@monash.edu, buser.say@monash.edu"
+__email__ = "ari.gestetner@monash.edu, buser.say@monash.edu"