desdeo 1.1.3__py3-none-any.whl → 2.0.0__py3-none-any.whl

desdeo/utopia_stuff/utopia_problem_old.py

@@ -0,0 +1,415 @@
+import math
+import numpy as np
+from pathlib import Path
+import polars as pl
+
+from desdeo.problem.schema import (
+    Constant,
+    Constraint,
+    ConstraintTypeEnum,
+    DiscreteRepresentation,
+    ExtraFunction,
+    Objective,
+    ObjectiveTypeEnum,
+    Problem,
+    TensorConstant,
+    TensorVariable,
+    Variable,
+    VariableTypeEnum,
+)
+from desdeo.tools.utils import available_solvers, payoff_table_method
+
+
+def utopia_problem_old(problem_name: str = "Forest problem", holding: int = 1) -> tuple[Problem, dict]:
+    r"""Defines a test forest problem that has TensorConstants and TensorVariables.
+
+    The problem has TensorConstants V, W and P as vectors taking values from a data file and
+    TensorVariables X_n, where n is the number of units in the data, as vectors matching the constants in shape.
+    The variables are binary and each variable vector X_i has one variable with the value 1 while others have value 0.
+    The variable with the value 1 for each vector X_i represents the optimal plan for the corresponding unit i.
+    The three objective functions f_1, f_2, f_3 represent the net present value, wood volume at the end of
+    the planning period, and the profit from harvesting.
+    All of the objective functions are to be maximized.
+    The problem is defined as follows:
+
+    \begin{align}
+        \mbox{maximize~} & \sum_{j=1}^N\sum_{i \in I_j} v_{ij} x_{ij} & \\
+        \mbox{maximize~} & \sum_{j=1}^N\sum_{i \in I_j} w_{ij} x_{ij} & \\
+        \mbox{maximize~} & \sum_{j=1}^N\sum_{i \in I_j} p_{ij} x_{ij} & \\
+        \nonumber\\
+        \mbox{subject to~} &  \sum\limits_{i \in I_j} x_{ij} = 1, & \forall j = 1 \ldots N \\
+        & x_{ij}\in \{0,1\}& \forall j = 1 \ldots N, ~\forall i\in I_j,
+    \end{align}
+
+    where $x_{ij}$ are decision variables representing the choice of implementing management plan $i$ in stand $j$,
+    and $I_j$ is the set of available management plans for stand $j$. For each plan $i$ in stand $j$
+    the net present value, wood volume at the end of the planning period, and the profit from harvesting
+    are represented by $v_{ij}$, $w_{ij}$, and $p_{ij}$ respectively.
+
+    Args:
+        holding (int, optional): The number of the holding to be optimized. Defaults to 1.
+        comparing (bool, optional): Determines if solutions are to be compared to those from the rahti app.
+            Defaults to None.
+
+    Returns:
+        Problem: An instance of the test forest problem.
+    """
+    # TODO: remove this at some point
+    comparing = False
+
+    schedule_dict = {}
+
+    discounting_factor = 3  # This can be 1, 2, 3, 4 or 5. It represents %
+    discounting = [
+        (1 - 0.01 * discounting_factor) ** 3,
+        (1 - 0.01 * discounting_factor) ** 8,
+        (1 - 0.01 * discounting_factor) ** 13,
+    ]
+
+    df = pl.read_csv(Path("tests/data/alternatives_290124.csv"), dtypes={"unit": pl.Float64})
+    df_key = pl.read_csv(Path("tests/data/alternatives_key_290124.csv"), dtypes={"unit": pl.Float64})
+
+    selected_df_v = df.filter(pl.col("holding") == holding).select(
+        ["unit", "schedule", f"npv_{discounting_factor}_percent"]
+    )
+    unique_units = selected_df_v.unique(["unit"], maintain_order=True).get_column("unit")
+    selected_df_v.group_by(["unit", "schedule"])
+    rows_by_key = selected_df_v.rows_by_key(key=["unit", "schedule"])
+    v_array = np.zeros((selected_df_v["unit"].n_unique(), selected_df_v["schedule"].n_unique()))
+    for i in range(np.shape(v_array)[0]):
+        for j in range(np.shape(v_array)[1]):
+            if (unique_units[i], j) in rows_by_key:
+                v_array[i][j] = rows_by_key[(unique_units[i], j)][0][0]
+
+    # determine whether the results are to be compared to those from the rahti app (for testing purposes)
+    # if compared, the stock values are calculated by substacting the value after 2025 period from
+    # the value after the 2035 period (in other words, last value - first value)
+    if comparing:
+        selected_df_w = df.filter(pl.col("holding") == holding).select(["unit", "schedule", "stock_2025", "stock_2035"])
+        selected_df_w.group_by(["unit", "schedule"])
+        rows_by_key = selected_df_w.rows_by_key(key=["unit", "schedule"])
+        selected_df_key_w = df_key.select(["unit", "schedule", "treatment"])
+        selected_df_key_w.group_by(["unit", "schedule"])
+        rows_by_key_df_key = selected_df_key_w.rows_by_key(key=["unit", "schedule"])
+        w_array = np.zeros((selected_df_w["unit"].n_unique(), selected_df_w["schedule"].n_unique()))
+        for i in range(np.shape(w_array)[0]):
+            for j in range(np.shape(w_array)[1]):
+                if len(rows_by_key_df_key[(unique_units[i], j)]) == 0:
+                    continue
+                if (unique_units[i], j) in rows_by_key:
+                    w_array[i][j] = rows_by_key[(unique_units[i], j)][0][1] - rows_by_key[(unique_units[i], j)][0][0]
+    else:
+        selected_df_w = df.filter(pl.col("holding") == holding).select(["unit", "schedule", "stock_2035"])
+        selected_df_w.group_by(["unit", "schedule"])
+        rows_by_key = selected_df_w.rows_by_key(key=["unit", "schedule"])
+        selected_df_key_w = df_key.select(["unit", "schedule", "treatment"])
+        selected_df_key_w.group_by(["unit", "schedule"])
+        rows_by_key_df_key = selected_df_key_w.rows_by_key(key=["unit", "schedule"])
+        w_array = np.zeros((selected_df_w["unit"].n_unique(), selected_df_w["schedule"].n_unique()))
+        for i in range(np.shape(w_array)[0]):
+            for j in range(np.shape(w_array)[1]):
+                if len(rows_by_key_df_key[(unique_units[i], j)]) == 0:
+                    continue
+                if (unique_units[i], j) in rows_by_key:
+                    w_array[i][j] = rows_by_key[(unique_units[i], j)][0][0]
+
+    """
+    selected_df_p = df.filter(pl.col("holding") == holding).select(
+        ["unit", "schedule", "harvest_value_period_2025", "harvest_value_period_2030", "harvest_value_period_2035"]
+    )
+    selected_df_p.group_by(["unit", "schedule"])
+    rows_by_key = selected_df_p.rows_by_key(key=["unit", "schedule"])
+    p_array = np.zeros((selected_df_p["unit"].n_unique(), selected_df_p["schedule"].n_unique()))
+    discounting = [0.95**5, 0.95**10, 0.95**15]
+    for i in range(np.shape(p_array)[0]):
+        for j in range(np.shape(p_array)[1]):
+            if (unique_units[i], j) in rows_by_key:
+                p_array[i][j] = (
+                    sum(x * y for x, y in zip(rows_by_key[(unique_units[i], j)][0], discounting, strict=True)) + 1e-6
+                )  # the 1E-6 is to deal with an annoying corner case, don't worry about it
+                v_array[i][j] += p_array[i][j]
+    """
+
+    selected_df_p1 = df.filter(pl.col("holding") == holding).select(["unit", "schedule", "harvest_value_period_2025"])
+    selected_df_p1.group_by(["unit", "schedule"])
+    rows_by_key = selected_df_p1.rows_by_key(key=["unit", "schedule"])
+    p1_array = np.zeros((selected_df_p1["unit"].n_unique(), selected_df_p1["schedule"].n_unique()))
+    for i in range(np.shape(p1_array)[0]):
+        for j in range(np.shape(p1_array)[1]):
+            if (unique_units[i], j) in rows_by_key:
+                p1_array[i][j] = rows_by_key[(unique_units[i], j)][0][0] + 1e-6
+
+    selected_df_p2 = df.filter(pl.col("holding") == holding).select(["unit", "schedule", "harvest_value_period_2030"])
+    selected_df_p2.group_by(["unit", "schedule"])
+    rows_by_key = selected_df_p2.rows_by_key(key=["unit", "schedule"])
+    p2_array = np.zeros((selected_df_p2["unit"].n_unique(), selected_df_p2["schedule"].n_unique()))
+    for i in range(np.shape(p2_array)[0]):
+        for j in range(np.shape(p2_array)[1]):
+            if (unique_units[i], j) in rows_by_key:
+                p2_array[i][j] = rows_by_key[(unique_units[i], j)][0][0] + 1e-6
+
+    selected_df_p3 = df.filter(pl.col("holding") == holding).select(["unit", "schedule", "harvest_value_period_2035"])
+    selected_df_p3.group_by(["unit", "schedule"])
+    rows_by_key = selected_df_p3.rows_by_key(key=["unit", "schedule"])
+    p3_array = np.zeros((selected_df_p3["unit"].n_unique(), selected_df_p3["schedule"].n_unique()))
+    for i in range(np.shape(p3_array)[0]):
+        for j in range(np.shape(p3_array)[1]):
+            if (unique_units[i], j) in rows_by_key:
+                p3_array[i][j] = rows_by_key[(unique_units[i], j)][0][0] + 1e-6
+
+    constants = []
+    variables = []
+    constraints = []
+    f_1_func = []
+    f_2_func = []
+    p1_func = []
+    p2_func = []
+    p3_func = []
+    # define the constants V, W and P, decision variable X, constraints, and objective function expressions in one loop
+    for i in range(np.shape(v_array)[0]):
+        # Constants V, W and P
+        v = TensorConstant(
+            name=f"V_{i+1}",
+            symbol=f"V_{i+1}",
+            shape=[np.shape(v_array)[1]],  # NOTE: vectors have to be of form [2] instead of [2,1] or [1,2]
+            values=v_array[i].tolist(),
+        )
+        constants.append(v)
+        w = TensorConstant(
+            name=f"W_{i+1}",
+            symbol=f"W_{i+1}",
+            shape=[np.shape(w_array)[1]],  # NOTE: vectors have to be of form [2] instead of [2,1] or [1,2]
+            values=w_array[i].tolist(),
+        )
+        constants.append(w)
+        p1 = TensorConstant(
+            name=f"P1_{i+1}",
+            symbol=f"P1_{i+1}",
+            shape=[np.shape(p1_array)[1]],  # NOTE: vectors have to be of form [2] instead of [2,1] or [1,2]
+            values=p1_array[i].tolist(),
+        )
+        constants.append(p1)
+
+        p2 = TensorConstant(
+            name=f"P2_{i+1}",
+            symbol=f"P2_{i+1}",
+            shape=[np.shape(p2_array)[1]],  # NOTE: vectors have to be of form [2] instead of [2,1] or [1,2]
+            values=p2_array[i].tolist(),
+        )
+        constants.append(p2)
+
+        p3 = TensorConstant(
+            name=f"P3_{i+1}",
+            symbol=f"P3_{i+1}",
+            shape=[np.shape(p3_array)[1]],  # NOTE: vectors have to be of form [2] instead of [2,1] or [1,2]
+            values=p3_array[i].tolist(),
+        )
+        constants.append(p3)
+
+        # Decision variable X
+        x = TensorVariable(
+            name=f"X_{i+1}",
+            symbol=f"X_{i+1}",
+            variable_type=VariableTypeEnum.binary,
+            shape=[np.shape(v_array)[1]],  # NOTE: vectors have to be of form [2] instead of [2,1] or [1,2]
+            lowerbounds=np.shape(v_array)[1] * [0],
+            upperbounds=np.shape(v_array)[1] * [1],
+            initial_values=np.shape(v_array)[1] * [0],
+        )
+        variables.append(x)
+
+        # Fill out the dict with information about treatments associated with X_{i+1}
+        treatment_list = (
+            df_key.filter((pl.col("holding") == holding) & (pl.col("unit") == unique_units[i]))
+            .get_column("treatment")
+            .to_list()
+        )
+        schedule_dict[f"X_{i+1}"] = dict(zip(range(len(treatment_list)), treatment_list, strict=True))
+        schedule_dict[f"X_{i+1}"]["unit"] = unique_units[i]
+
+        # Constraints
+        con = Constraint(
+            name=f"x_con_{i+1}",
+            symbol=f"x_con_{i+1}",
+            cons_type=ConstraintTypeEnum.EQ,
+            func=f"Sum(X_{i+1}) - 1",
+            is_twice_differentiable=True,
+        )
+        constraints.append(con)
+
+        # Objective function expressions
+        exprs = f"V_{i+1}@X_{i+1}"
+        f_1_func.append(exprs)
+
+        exprs = f"W_{i+1}@X_{i+1}"
+        f_2_func.append(exprs)
+
+        exprs = f"P1_{i+1}@X_{i+1}"
+        p1_func.append(exprs)
+
+        exprs = f"P2_{i+1}@X_{i+1}"
+        p2_func.append(exprs)
+
+        exprs = f"P3_{i+1}@X_{i+1}"
+        p3_func.append(exprs)
+
+    for i in range(1, 4):
+        pvar = Variable(name=f"P_{i}", symbol=f"P_{i}", variable_type=VariableTypeEnum.real, lowerbound=0)
+        variables.append(pvar)
+
+    vvar = Variable(name="V_end", symbol="V_end", variable_type=VariableTypeEnum.real, lowerbound=0)
+    variables.append(vvar)
+
+    # get the remainder value of the forest into decision variable V_end
+    v_func = "V_end - " + " - ".join(f_1_func)
+    con = Constraint(
+        name="v_con",
+        symbol="v_con",
+        cons_type=ConstraintTypeEnum.EQ,
+        func=v_func,
+        is_twice_differentiable=True,
+    )
+    constraints.append(con)
+
+    # These are here, so that we can get the harvesting incomes into decision variables P_i
+    p1_func = "P_1 - " + " - ".join(p1_func)
+    con = Constraint(
+        name="p1_con",
+        symbol="p1_con",
+        cons_type=ConstraintTypeEnum.EQ,
+        func=p1_func,
+        is_twice_differentiable=True,
+    )
+    constraints.append(con)
+
+    p2_func = "P_2 - " + " - ".join(p2_func)
+    con = Constraint(
+        name="p2_con",
+        symbol="p2_con",
+        cons_type=ConstraintTypeEnum.EQ,
+        func=p2_func,
+        is_twice_differentiable=True,
+    )
+    constraints.append(con)
+
+    p3_func = "P_3 - " + " - ".join(p3_func)
+    con = Constraint(
+        name="p3_con",
+        symbol="p3_con",
+        cons_type=ConstraintTypeEnum.EQ,
+        func=p3_func,
+        is_twice_differentiable=True,
+    )
+    constraints.append(con)
+
+    # print(v_func)
+    # print(p1_func)
+    # print(p2_func)
+    # print(p3_func)
+
+    # form the objective function sums
+    f_2_func = " + ".join(f_2_func)
+    f_3_func = f"{discounting[0]} * P_1 + {discounting[1]} * P_2 + {discounting[2]} * P_3"
+    f_1_func = "V_end + " + f_3_func
+
+    # print(f_1_func)
+    # print(f_2_func)
+    # print(f_3_func)
+
+    f_1 = Objective(
+        name="Net present value",
+        symbol="f_1",
+        func=f_1_func,
+        maximize=True,
+        objective_type=ObjectiveTypeEnum.analytical,
+        is_linear=True,
+        is_convex=False,  # not checked
+        is_twice_differentiable=True,
+    )
+
+    f_2 = Objective(
+        name="Wood stock volume",
+        symbol="f_2",
+        func=f_2_func,
+        maximize=True,
+        objective_type=ObjectiveTypeEnum.analytical,
+        is_linear=True,
+        is_convex=False,  # not checked
+        is_twice_differentiable=True,
+    )
+
+    f_3 = Objective(
+        name="Harvest value",
+        symbol="f_3",
+        func=f_3_func,
+        maximize=True,
+        objective_type=ObjectiveTypeEnum.analytical,
+        is_linear=True,
+        is_convex=False,  # not checked
+        is_twice_differentiable=True,
+    )
+
+    # This is so bad, but we currently don't have a better way
+    ideals, nadirs = payoff_table_method(
+        problem=Problem(
+            name=problem_name,
+            description="A test forest problem.",
+            constants=constants,
+            variables=variables,
+            objectives=[f_1, f_2, f_3],
+            constraints=constraints,
+        ),
+        solver=available_solvers["gurobipy"],
+    )
+
+    print(ideals)
+    print(nadirs)
+
+    f_1 = Objective(
+        name="Nettonykyarvo / €",
+        symbol="f_1",
+        func=f_1_func,
+        maximize=True,
+        ideal=math.ceil(ideals["f_1"]),
+        nadir=math.floor(nadirs["f_1"]),
+        objective_type=ObjectiveTypeEnum.analytical,
+        is_linear=True,
+        is_convex=False,  # not checked
+        is_twice_differentiable=True,
+    )
+
+    f_2 = Objective(
+        name="Puuston tilavuus / m^3",
+        symbol="f_2",
+        func=f_2_func,
+        maximize=True,
+        ideal=math.ceil(ideals["f_2"]),
+        nadir=math.floor(nadirs["f_2"]),
+        objective_type=ObjectiveTypeEnum.analytical,
+        is_linear=True,
+        is_convex=False,  # not checked
+        is_twice_differentiable=True,
+    )
+
+    f_3 = Objective(
+        name="Hakkuiden tuotto / €",
+        symbol="f_3",
+        func=f_3_func,
+        maximize=True,
+        ideal=math.ceil(ideals["f_3"]),
+        nadir=math.floor(nadirs["f_3"]),
+        objective_type=ObjectiveTypeEnum.analytical,
+        is_linear=True,
+        is_convex=False,  # not checked
+        is_twice_differentiable=True,
+    )
+
+    return Problem(
+        name=problem_name,
+        description="A test forest problem.",
+        constants=constants,
+        variables=variables,
+        objectives=[f_1, f_2, f_3],
+        constraints=constraints,
+        is_twice_differentiable=True,
+    ), schedule_dict

desdeo/utopia_stuff/utopia_reference_solutions.py

@@ -0,0 +1,79 @@
+"""This is a docstring."""
+
+import json
+
+from desdeo.api.db import SessionLocal
+from desdeo.api.db_models import Method, SolutionArchive, User, Utopia
+from desdeo.api.db_models import Problem as ProblemInDB
+from desdeo.api.schema import Methods
+from desdeo.utopia_stuff.utopia_problem import utopia_problem
+
+
+def get_chosen_solution(username: str):
+    """Recreates the forest problem for the specified user.
+
+    Args:
+        username (str): username of the forest owner
+    """
+    db = SessionLocal()
+    user = db.query(User).filter(User.username == username).first()
+    if user is None:
+        raise Exception("User not found")  # noqa: TRY002
+    problem_in_db = (
+        db.query(ProblemInDB).filter(ProblemInDB.owner == user.id, ProblemInDB.name == "Metsänhoitosuunnitelma").first()
+    )
+    # map_info = db.query(Utopia).filter(Utopia.problem == problem_in_db.id, Utopia.user == user.id)
+
+    nimbus_method = db.query(Method).filter(Method.kind == Methods.NIMBUS).first()
+
+    solution = (
+        db.query(SolutionArchive)
+        .filter(
+            SolutionArchive.user == user.id,
+            SolutionArchive.problem == problem_in_db.id,
+            SolutionArchive.method == nimbus_method.id,
+        )
+        .first()
+    )
+
+    if not solution:
+        return (None, None)
+
+    return (solution.objectives, solution.decision_variables)
+
+
+"""    with open("C:/MyTemp/data/forest_owners.json") as file:  # noqa: PTH123
+        fo_dict = json.load(file)
+
+    print(fo_dict[username])
+
+    problem, schedule_dict = utopia_problem(
+        simulation_results=fo_dict[username]["simulation_results"],
+        treatment_key=fo_dict[username]["treatment_key"],
+        problem_name="Metsänhoitosuunnitelma",
+    )
+
+    problem_in_db.value = problem.model_dump(mode="json")
+    map_info.schedule_dict = schedule_dict
+
+    db.commit()"""
+
+
+if __name__ == "__main__":
+    # print(get_chosen_solution("Iisakkila"))
+    with open("C:/MyTemp/data/forest_owners.json") as file:  # noqa: PTH123
+        fo_dict = json.load(file)
+
+    reference_dict = {}
+    for fo in fo_dict:
+        objectives, decision_vars = get_chosen_solution(fo)
+        if objectives is None:
+            continue
+        reference_dict[fo] = {
+            "objectives": objectives,
+            "decisions_vars": decision_vars,
+            "simulation_results": fo_dict[fo]["simulation_results"],
+        }
+
+    with open("reference_solutions.json", "w") as file:
+        json.dump(reference_dict, file, indent=4)  # indent=4 makes it nicely formatted

desdeo-2.0.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 The Multiobjective Optimization Group (http://www.mit.jyu.fi/optgroup/).
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

desdeo-2.0.0.dist-info/METADATA

@@ -0,0 +1,168 @@
+Metadata-Version: 2.3
+Name: desdeo
+Version: 2.0.0
+Summary: DESDEO is a modular and open source framework for interactive multiobjective optimization.
+License: MIT
+Author: Giovanni Misitano
+Author-email: giovanni.a.misitano@jyu.fi
+Requires-Python: >=3.12,<3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: bayesian-optimization (>=1.0,<2.0)
+Requires-Dist: cvxpy[scip] (>=1.6.4,<2.0.0)
+Requires-Dist: greenlet (>=3.1.1,<4.0.0)
+Requires-Dist: gurobipy (>=12.0.0,<13.0.0)
+Requires-Dist: nevergrad (>=1.0.12,<2.0.0)
+Requires-Dist: numba (>=0.61.0,<0.62.0)
+Requires-Dist: numpy (>=2.2.0,<3.0.0)
+Requires-Dist: polars (>=1.17,<2.0)
+Requires-Dist: pyarrow (>=20.0.0,<21.0.0)
+Requires-Dist: pydantic (>=2.9,<3.0)
+Requires-Dist: pymoo (>=0.6.1.2,<0.7.0.0)
+Requires-Dist: pyomo (>=6.8,<7.0)
+Requires-Dist: pyparsing (>=3.0,<4.0)
+Requires-Dist: scipy (>=1.11.4,<2.0.0)
+Requires-Dist: shap (>=0.47.0,<0.48.0)
+Requires-Dist: sympy (>=1.0,<2.0)
+Requires-Dist: tsp-solver (>=0.1,<0.2)
+Description-Content-Type: text/markdown
+
+# DESDEO: the open-source software framework for interactive multiobjective optimization
+
+[![Documentation Status](https://img.shields.io/readthedocs/desdeo.svg?version=desdeo2&label=Documentation)](https://desdeo.readthedocs.io/en/latest/) ![Tests](https://img.shields.io/github/actions/workflow/status/industrial-optimization-group/DESDEO/unit_tests.yaml?branch=desdeo2&label=Tests)
+
+[![Discord server](https://dcbadge.vercel.app/api/server/TgSnUmzv5M)](https://discord.gg/TgSnUmzv5M)
+
+## Introduction
+
+DESDEO is an open-source framework for interactive multiobjective optimization
+methods. The framework contains implementations of both scalarization- and
+population-based interactive methods. There are currently no other open-source
+software frameworks that focus solely on the implementation of interactive
+multiobjective optimization methods.
+
+The mission of DESDEO is to increase awareness of the benefits of interactive
+multiobjective optimization methods, make interactive methods openly available,
+and to function as _the_ central hub for implementations of various interactive
+methods. Apart from existing methods, DESDEO offers various tools to facilitate
+the development of new methods and their application as well.  Another important
+goal of DESDEO is to answer the needs of decision makers and practitioners when
+it comes to modeling and solving real-life multiobjective optimization problems.
+
+In the bigger picture, DESDEO will be composed of three major components:
+
+1. The __core-logic__, which contains the algorithmic implementation of
+interactive methods, various tools related to multiobjective optimization, and
+means to model a variety of multiobjective optimization problems. The core-logic
+can be considered stable enough for use in research and applications.
+2. The __web-API__ (WIP), which implements a web-based application programming
+interface (API) to allow the use of the various functionalities found in
+DESDEO's core-logic through a web connection. The web-API implements also a
+database, which is a vital component for managing and enabling
+decision-support using the framework. __The
+web-API is currently under heavy development, and is subject to changes.__
+3. The __web-GUI__ (WIP), which implements a web-based interface for utilizing
+the interactive methods and tools for modeling and solving multiobjective
+optimization problems. __The web-GUI relies heavily on the web-API, and is also being actively developed currently, and therefore subject to sudden changes.__
+
+For developing and experimenting with interactive multiobjective optimization
+methods on a "grass root" level, the __core-logic__ provides the necessary
+tools.  For deploying interactive methods, the __web-API__ and the __web_GUI__
+play a central role.
+
+DESDEO is an open-source project and everybody is welcome to contribute!
+
+## Core-logic: key features
+
+DESDEO's core-logic offers various features that can facilitate the application and
+development of new interactive multiobjective optimization methods. Some
+of the key features include, but are not limited to,
+
+-   A powerful, pydantic-based, schema for modeling multiobjective optimization
+problem of various kinds. Including, analytically defined problems, data-based
+problems, surrogate-based problems, and simulation-based problems.
+Both continuous and (mixed-)integer problems are supported as well.
+-   Support to interface to many popular and powerful optimization software for
+solving multiobjective optimization problems. Including Gurobi, various solvers
+from the COIN-OR project, and nevergrad, for instance. 
+-   A wide assortment of modular software components for implementing existing
+and new interactive multiobjective optimization methods. For example, many
+scalarization functions and evolutionary operators for multiobjective
+optimization are available.
+-   An extensive documentation suitable for both newcomers to DESDEO and
+interactive multiobjective optimization in general, and seasoned veterans.
+
+## Web-API: key features
+
+DESDEO's web-API is currently under active development. Once it stabilized, its
+key features will be listed here. In the meantime, the interested user can
+follow (and contribute!) the development progress of the web-API in [this
+issue](https://github.com/industrial-optimization-group/DESDEO/issues/245).
+
+## Web-GUI: key features
+
+DESDEO's web-GUI is currently in a planning stage. Once its active development
+starts, an issue will be created for documenting its development, as is
+currently the case with the web-API.
+
+## Installation instructions
+
+For installing DESDEO, please see the documentation (TODO) for instructions.
+
+## Documentation
+
+Care has been taken to make sure DESDEO is well documented, making it accessible
+to both newcomers and seasoned users alike.  [The documentation of DESDEO is
+available online.](https://desdeo.readthedocs.io/en/desdeo2/)
+
+## Contributing
+
+As DESDEO is an open source-project, anybody is welcome to contribute.
+An extensive tutorial to get started contributing to DESDEO
+[is available in the documentation](https://desdeo.readthedocs.io/en/desdeo2/tutorials/contributing/).
+Be sure to check it out!
+
+For additional support for contributing to DESDEO,
+be sure to check out the DESDEO channels
+in the MCDM Community's Discord server. You may join the server
+[through this invite](https://discord.gg/TgSnUmzv5M).
+
+## License
+
+DESDEO is licensed under the MIT license. For more information,
+check the `LICENSE` file.
+
+## Citing DESDEO
+
+To cite DESDEO, please include the following reference:
+
+[Misitano, G., Saini, B. S., Afsar, B., Shavazipour, B., & Miettinen, K. (2021). DESDEO: The modular and open source framework for interactive multiobjective optimization. IEEE Access, 9, 148277-148295.](https://doi.org/10.1109/ACCESS.2021.3123825)
+
+```
+@article{misitano2021desdeo,
+  title={DESDEO: The modular and open source framework for interactive multiobjective optimization},
+  author={Misitano, Giovanni and Saini, Bhupinder Singh and Afsar, Bekir and Shavazipour, Babooshka and Miettinen, Kaisa},
+  journal={IEEE Access},
+  volume={9},
+  pages={148277--148295},
+  year={2021},
+  publisher={IEEE}
+}
+```
+
+__Note__: A new article describing the latest iteration of the framework,
+also known as _DESDEO 2.0_ is currently being prepared. The content of
+this repository's master branch is considered to be _DESDEO 2.0_.
+
+## Funding
+
+Currently, DESDEO's development is partly funded by two projects granted by the
+[Research Council of Finland](https://www.aka.fi/en/). The most recent ones
+include:
+
+- DESIDES (project 355346)
+- UTOPIA (project 352784)
+- DAEMON (project 322221)
+
+