GridCalEngine 5.1.24__tar.gz → 5.1.25__tar.gz

{GridCalEngine-5.1.24 → GridCalEngine-5.1.25}/GridCalEngine/Compilers/circuit_to_data.py

@@ -1007,6 +1007,8 @@ def get_branch_data(
                                  logger=logger)
 
         data.conn[ii] = elm.conn
+        data.m_taps[ii] = elm.tap_changer.tap_modules_array
+        data.tau_taps[ii] = elm.tap_changer.tap_angles_array
 
         ii += 1
 
@@ -1034,6 +1036,8 @@ def get_branch_data(
                                      logger=logger)
 
             data.conn[ii] = elm.conn
+            data.m_taps[ii] = elm.tap_changer.tap_modules_array
+            data.tau_taps[ii] = elm.tap_changer.tap_angles_array
 
             ii += 1
 

{GridCalEngine-5.1.24 → GridCalEngine-5.1.25}/GridCalEngine/DataStructures/branch_data.py

@@ -19,6 +19,7 @@ import pandas as pd
 import scipy.sparse as sp
 import GridCalEngine.Topology.topology as tp
 from GridCalEngine.enumerations import WindingsConnection
+from GridCalEngine.Utils.Sparse.sparse_array import SparseObjectArray
 from GridCalEngine.basic_structures import Vec, IntVec, StrVec, ObjVec, CxVec, BoolVec
 from typing import List, Tuple, Dict
 
@@ -50,15 +51,10 @@ class BranchData:
         self.F: IntVec = np.zeros(self.nelm, dtype=int)  # indices of the "from" buses
         self.T: IntVec = np.zeros(self.nelm, dtype=int)  # indices of the "to" buses
 
-        # reliabilty
+        # reliability
         self.mttf: Vec = np.zeros(self.nelm, dtype=float)
         self.mttr: Vec = np.zeros(self.nelm, dtype=float)
 
-        # composite losses curve (c * x^2 + b * x + a)
-        # self.a: Vec = np.zeros(self.nelm, dtype=float)
-        # self.b: Vec = np.zeros(self.nelm, dtype=float)
-        # self.c: Vec = np.zeros(self.nelm, dtype=float)
-
         self.R: Vec = np.zeros(self.nelm, dtype=float)
         self.X: Vec = np.zeros(self.nelm, dtype=float)
         self.G: Vec = np.zeros(self.nelm, dtype=float)
@@ -74,7 +70,10 @@ class BranchData:
         self.G2: Vec = np.zeros(self.nelm, dtype=float)
         self.B2: Vec = np.zeros(self.nelm, dtype=float)
 
-        self.conn: ObjVec = np.array([WindingsConnection.GG] * self.nelm)
+        self.conn: ObjVec = np.full(self.nelm, fill_value=WindingsConnection.GG, dtype=object)
+
+        self.m_taps = SparseObjectArray(n=self.nelm)
+        self.tau_taps = SparseObjectArray(n=self.nelm)
 
         self.k: Vec = np.ones(nelm, dtype=float)
 
@@ -169,6 +168,8 @@ class BranchData:
         data.alpha3 = self.alpha3[elm_idx]
 
         data.conn = self.conn[elm_idx]  # winding connection
+        data.m_taps = self.m_taps.slice(elm_idx)
+        data.tau_taps = self.tau_taps.slice(elm_idx)
 
         data.tap_phase_control_mode = self.tap_phase_control_mode[elm_idx]
         data.tap_module_control_mode = self.tap_module_control_mode[elm_idx]
@@ -254,6 +255,8 @@ class BranchData:
         data.alpha3 = self.alpha3.copy()
 
         data.conn = self.conn.copy()  # winding connection
+        data.m_taps = self.m_taps.copy()
+        data.tau_taps = self.tau_taps.copy()
 
         data.tap_phase_control_mode = self.tap_phase_control_mode.copy()
         data.tap_module_control_mode = self.tap_module_control_mode.copy()
@@ -294,6 +297,13 @@ class BranchData:
 
         return data
 
+    def get_series_admittance(self) -> CxVec:
+        """
+        Get the series admittance of the branches
+        :return: complex vector
+        """
+        return 1.0 / (self.R + 1j * self.X)
+
     def get_island(self, bus_idx: Vec) -> IntVec:
         """
         Get the array of branch indices that belong to the islands given by the bus indices

{GridCalEngine-5.1.24 → GridCalEngine-5.1.25}/GridCalEngine/DataStructures/shunt_data.py

@@ -17,6 +17,7 @@
 import numpy as np
 import scipy.sparse as sp
 import GridCalEngine.Topology.topology as tp
+from GridCalEngine.Utils.Sparse.sparse_array import SparseObjectArray
 from GridCalEngine.basic_structures import Vec, CxVec, IntVec, StrVec, BoolVec
 
 
@@ -48,7 +49,9 @@ class ShuntData:
 
         self.cost: Vec = np.zeros(nelm, dtype=float)
 
-        # reliabilty
+        self.taps = SparseObjectArray(n=self.nelm)
+
+        # reliability
         self.mttf: Vec = np.zeros(nelm, dtype=float)
         self.mttr: Vec = np.zeros(nelm, dtype=float)
 
@@ -88,6 +91,8 @@ class ShuntData:
 
         data.cost = self.cost[elm_idx]
 
+        data.taps = self.taps.slice(elm_idx)
+
         data.mttf = self.mttf[elm_idx]
         data.mttr = self.mttr[elm_idx]
 
@@ -117,6 +122,8 @@ class ShuntData:
 
         data.cost = self.cost.copy()
 
+        data.taps = self.taps.copy()
+
         data.mttf = self.mttf.copy()
         data.mttr = self.mttr.copy()
 

{GridCalEngine-5.1.24 → GridCalEngine-5.1.25}/GridCalEngine/Devices/Branches/tap_changer.py

@@ -87,6 +87,14 @@ class TapChanger:
         """
         self._tap_position = val
 
+    @property
+    def tap_modules_array(self):
+        return self._m_array
+
+    @property
+    def tap_angles_array(self):
+        return self._tau_array
+
     def resize(self) -> None:
         """
         Resize and recalc the tap positions array
@@ -252,7 +260,8 @@ class TapChanger:
         :param tap_module: float value of the tap module
         """
         if self.tc_type != TapChangerTypes.NoRegulation:
-            return find_closest_number(arr=self._tau_array, target=tap_module)
+            _, val = find_closest_number(arr=self._tau_array, target=tap_module)
+            return val
 
     def get_tap_module_min(self) -> float:
         """

{GridCalEngine-5.1.24 → GridCalEngine-5.1.25}/GridCalEngine/Devices/Parents/editable_device.py

@@ -225,7 +225,8 @@ class EditableDevice:
         # list of properties that cannot be edited
         self.non_editable_properties: List[str] = list()
 
-        self.properties_with_profile: Dict[str, Optional[Any]] = dict()
+        # dictionary with property name -> profile name
+        self.properties_with_profile: Dict[str, str] = dict()
 
         self.register(key='idtag', units='', tpe=str, definition='Unique ID', editable=False)
         self.register(key='name', units='', tpe=str, definition='Name of the device.')
@@ -342,6 +343,7 @@ class EditableDevice:
         """
         assert (hasattr(self, key))  # the property must exist, this avoids bugs when registering
 
+        # create GCProp object
         prop = GCProp(prop_name=key,
                       units=units,
                       tpe=tpe,
@@ -360,7 +362,7 @@ class EditableDevice:
 
         if profile_name != '':
             assert (hasattr(self, profile_name))  # the profile property must exist, this avoids bugs in registering
-            assert (isinstance(getattr(self, profile_name), Profile))
+            assert (isinstance(getattr(self, profile_name), Profile))  # the profile must be of type "Profile"
             self.properties_with_profile[key] = profile_name
 
         if not editable:
@@ -708,9 +710,9 @@ class EditableDevice:
         Set the profile values at t
         :param t: time index (integer)
         """
-        for magnitude in self.properties_with_profile.keys():
-            profile: Profile = getattr(self, self.properties_with_profile[magnitude])
-            setattr(self, magnitude, profile[t])
+        for property_name, profile_name in self.properties_with_profile.items():
+            profile: Profile = getattr(self, profile_name)
+            setattr(self, property_name, profile[t])
 
     def get_profile(self, magnitude: str) -> Union[Profile, None]:
         """

{GridCalEngine-5.1.24 → GridCalEngine-5.1.25}/GridCalEngine/Devices/assets.py

@@ -207,7 +207,7 @@ class Assets:
         self._diagrams: List[Union[dev.MapDiagram, dev.SchematicDiagram]] = list()
 
         # objects with profiles
-        self.objects_with_profiles = {
+        self.template_objects_dict = {
             "Regions": [
                 dev.Country(),
                 dev.Community(),
@@ -286,7 +286,7 @@ class Assets:
 
         self.properties_with_profile = ['Y']
         '''
-        for key, elm_list in self.objects_with_profiles.items():
+        for key, elm_list in self.template_objects_dict.items():
             for elm in elm_list:
                 if elm.properties_with_profile is not None:
                     key = str(elm.device_type.value)
@@ -308,11 +308,12 @@ class Assets:
         for key, tpe in self.device_type_name_dict.items():
             yield tpe
 
-    def items_declared(self) -> Generator[ALL_DEV_TYPES, None, None]:
+    def template_items(self) -> Generator[ALL_DEV_TYPES, None, None]:
         """
-        Iterator of the declared objects in the MultiCircuit
+        Iterator of the declared objects in the MultiCircuit.
+        These are the object types that you see in the App DataBase tree
         """
-        for key, elm_type_list in self.objects_with_profiles.items():
+        for key, elm_type_list in self.template_objects_dict.items():
             for elm in elm_type_list:
                 yield elm
 
@@ -508,7 +509,7 @@ class Assets:
         #     for elm in elements:
         #         elm.ensure_profiles_exist(self.time_profile)
 
-        for elm in self.items_declared():
+        for elm in self.items():
             elm.ensure_profiles_exist(self.time_profile)
 
     def delete_profiles(self):
@@ -5322,6 +5323,6 @@ class Assets:
         Clear the multi-circuit (remove the bus and branch objects)
         """
 
-        for key, elm_list in self.objects_with_profiles.items():
+        for key, elm_list in self.template_objects_dict.items():
             for elm in elm_list:
                 self.get_elements_by_type(device_type=elm.device_type).clear()

{GridCalEngine-5.1.24 → GridCalEngine-5.1.25}/GridCalEngine/Devices/multi_circuit.py

@@ -206,24 +206,24 @@ class MultiCircuit(Assets):
         """
         return (self.get_bus_number() + self.get_connectivity_nodes_number()) > 0
 
-    def get_objects_with_profiles_list(self) -> List[ALL_DEV_TYPES]:
+    def get_template_objects_list(self) -> List[ALL_DEV_TYPES]:
         """
         get objects_with_profiles in the form of list
         :return: List[dev.EditableDevice]
         """
         lst = list()
-        for key, elm_list in self.objects_with_profiles.items():
+        for key, elm_list in self.template_objects_dict.items():
             for elm in elm_list:
                 lst.append(elm)
         return lst
 
-    def get_objects_with_profiles_str_dict(self) -> Dict[str, List[str]]:
+    def get_template_objects_str_dict(self) -> Dict[str, List[str]]:
         """
         get objects_with_profiles as a strings dictionary
         :return:
         """
         d = dict()
-        for key, elm_list in self.objects_with_profiles.items():
+        for key, elm_list in self.template_objects_dict.items():
             d[key] = [o.device_type.value for o in elm_list]
         return d
 
@@ -761,7 +761,7 @@ class MultiCircuit(Assets):
         """
         self.ensure_profiles_exist()
 
-        for device in self.items_declared():
+        for device in self.items():
             device.set_profile_values(t)
 
         self.snapshot_time = self.time_profile[t]
@@ -1706,89 +1706,89 @@ class MultiCircuit(Assets):
                              expected_value=self.get_snapshot_time_unix())
 
         # for each category
-        for key, template_elms_list in self.objects_with_profiles.items():
+        # for key, template_elms_list in self.categorized_template_objects_dict.items():
 
             # for each object type
-            for template_elm in template_elms_list:
+        for template_elm in self.template_items():
 
-                # get all objects of the type
-                elms1 = self.get_elements_by_type(device_type=template_elm.device_type)
-                elms2 = grid2.get_elements_by_type(device_type=template_elm.device_type)
+            # get all objects of the type
+            elms1 = self.get_elements_by_type(device_type=template_elm.device_type)
+            elms2 = grid2.get_elements_by_type(device_type=template_elm.device_type)
 
-                if len(elms1) != len(elms2):
-                    logger.add_error(msg="Different number of elements",
-                                     device_class=template_elm.device_type.value,
-                                     value=len(elms2),
-                                     expected_value=len(elms1))
+            if len(elms1) != len(elms2):
+                logger.add_error(msg="Different number of elements",
+                                 device_class=template_elm.device_type.value,
+                                 value=len(elms2),
+                                 expected_value=len(elms1))
 
-                # for every property
-                for prop_name, prop in template_elm.registered_properties.items():
+            # for every property
+            for prop_name, prop in template_elm.registered_properties.items():
 
-                    if skip_internals:
-                        analyze = prop.display
-                    else:
-                        analyze = True
+                if skip_internals:
+                    analyze = prop.display
+                else:
+                    analyze = True
+
+                if analyze:
+                    # for every pair of elements:
+                    for elm1, elm2 in zip(elms1, elms2):
 
-                    if analyze:
-                        # for every pair of elements:
-                        for elm1, elm2 in zip(elms1, elms2):
+                        # compare the snapshot values
+                        v1 = elm1.get_property_value(prop=prop, t_idx=None)
+                        v2 = elm2.get_property_value(prop=prop, t_idx=None)
 
-                            # compare the snapshot values
-                            v1 = elm1.get_property_value(prop=prop, t_idx=None)
-                            v2 = elm2.get_property_value(prop=prop, t_idx=None)
+                        if v1 != v2:
+                            logger.add_error(msg="Different snapshot values",
+                                             device_class=template_elm.device_type.value,
+                                             device_property=prop.name,
+                                             value=v2,
+                                             expected_value=v1)
 
-                            if v1 != v2:
-                                logger.add_error(msg="Different snapshot values",
+                        if prop.has_profile():
+                            p1 = elm1.get_profile_by_prop(prop=prop)
+                            p2 = elm1.get_profile_by_prop(prop=prop)
+
+                            if p1 != p2:
+                                logger.add_error(msg="Different profile values",
                                                  device_class=template_elm.device_type.value,
                                                  device_property=prop.name,
-                                                 value=v2,
-                                                 expected_value=v1)
-
-                            if prop.has_profile():
-                                p1 = elm1.get_profile_by_prop(prop=prop)
-                                p2 = elm1.get_profile_by_prop(prop=prop)
-
-                                if p1 != p2:
-                                    logger.add_error(msg="Different profile values",
-                                                     device_class=template_elm.device_type.value,
-                                                     device_property=prop.name,
-                                                     object_value=p2,
-                                                     expected_object_value=p1)
-
-                                if detailed_profile_comparison:
-                                    for t_idx in range(nt):
-
-                                        v1 = p1[t_idx]
-                                        v2 = p2[t_idx]
-
-                                        if v1 != v2:
-                                            logger.add_error(msg="Different time series values",
-                                                             device_class=template_elm.device_type.value,
-                                                             device_property=prop.name,
-                                                             device=str(elm1),
-                                                             value=v2,
-                                                             expected_value=v1)
-
-                                        v1b = elm1.get_property_value(prop=prop, t_idx=t_idx)
-                                        v2b = elm2.get_property_value(prop=prop, t_idx=t_idx)
-
-                                        if v1 != v1b:
-                                            logger.add_error(
-                                                msg="Profile getting values differ with different getter methods!",
-                                                device_class=template_elm.device_type.value,
-                                                device_property=prop.name,
-                                                device=str(elm1),
-                                                value=v1b,
-                                                expected_value=v1)
-
-                                        if v2 != v2b:
-                                            logger.add_error(
-                                                msg="Profile getting values differ with different getter methods!",
-                                                device_class=template_elm.device_type.value,
-                                                device_property=prop.name,
-                                                device=str(elm1),
-                                                value=v1b,
-                                                expected_value=v1)
+                                                 object_value=p2,
+                                                 expected_object_value=p1)
+
+                            if detailed_profile_comparison:
+                                for t_idx in range(nt):
+
+                                    v1 = p1[t_idx]
+                                    v2 = p2[t_idx]
+
+                                    if v1 != v2:
+                                        logger.add_error(msg="Different time series values",
+                                                         device_class=template_elm.device_type.value,
+                                                         device_property=prop.name,
+                                                         device=str(elm1),
+                                                         value=v2,
+                                                         expected_value=v1)
+
+                                    v1b = elm1.get_property_value(prop=prop, t_idx=t_idx)
+                                    v2b = elm2.get_property_value(prop=prop, t_idx=t_idx)
+
+                                    if v1 != v1b:
+                                        logger.add_error(
+                                            msg="Profile getting values differ with different getter methods!",
+                                            device_class=template_elm.device_type.value,
+                                            device_property=prop.name,
+                                            device=str(elm1),
+                                            value=v1b,
+                                            expected_value=v1)
+
+                                    if v2 != v2b:
+                                        logger.add_error(
+                                            msg="Profile getting values differ with different getter methods!",
+                                            device_class=template_elm.device_type.value,
+                                            device_property=prop.name,
+                                            device=str(elm1),
+                                            value=v1b,
+                                            expected_value=v1)
 
         # if any error in the logger, bad
         return logger.error_count() == 0, logger

{GridCalEngine-5.1.24 → GridCalEngine-5.1.25}/GridCalEngine/Devices/profile.py

@@ -21,7 +21,7 @@ import numpy as np
 import numba as nb
 from GridCalEngine.basic_structures import Numeric, NumericVec, IntVec
 from GridCalEngine.enumerations import DeviceType
-from GridCalEngine.Devices.sparse_array import SparseArray, PROFILE_TYPES, check_type
+from GridCalEngine.Utils.Sparse.sparse_array import SparseArray, PROFILE_TYPES, check_type
 
 
 @nb.njit()

{GridCalEngine-5.1.24 → GridCalEngine-5.1.25}/GridCalEngine/IO/cim/cgmes/cgmes_to_gridcal.py

@@ -402,7 +402,7 @@ def get_gcdev_loads(cgmes_model: CgmesCircuit,
                 if cgmes_elm.LoadResponse is not None:
 
                     if cgmes_elm.LoadResponse.exponentModel:
-                        print(f'Exponent model True at {cgmes_elm.name}')
+                        # print(f'Exponent model True at {cgmes_elm.name}')
                         pass  # TODO convert exponent to ZIP
                     else:  # ZIP model
                         # TODO check all attributes

{GridCalEngine-5.1.24 → GridCalEngine-5.1.25}/GridCalEngine/Simulations/Derivatives/csc_derivatives.py

@@ -58,7 +58,8 @@ def dSbus_dV_numba_sparse_csc(Yx: CxVec, Yp: IntVec, Yi: IntVec, V: CxVec, Vm: C
     for j in range(n):  # for each column ...
 
         # compute the unitary vector of the voltage
-        E[j] /= Vm[j]
+        if Vm[j] > 0.0:
+            E[j] /= Vm[j]
 
         for k in range(Yp[j], Yp[j + 1]):  # for each row ...
             # row index

{GridCalEngine-5.1.24 → GridCalEngine-5.1.25}/GridCalEngine/Simulations/PowerFlow/NumericalMethods/pf_advanced_formulation.py

@@ -26,6 +26,7 @@ from GridCalEngine.DataStructures.numerical_circuit import NumericalCircuit
 import GridCalEngine.Simulations.Derivatives.csc_derivatives as deriv
 from GridCalEngine.Topology.simulation_indices import compile_types
 from GridCalEngine.Utils.Sparse.csc2 import CSC, CxCSC, sp_slice, csc_stack_2d_ff, scipy_to_mat
+from GridCalEngine.Utils.NumericalMethods.common import find_closest_number
 from GridCalEngine.Simulations.PowerFlow.NumericalMethods.common_functions import expand
 from GridCalEngine.Simulations.PowerFlow.NumericalMethods.common_functions import compute_fx_error
 from GridCalEngine.Simulations.PowerFlow.NumericalMethods.discrete_controls import (control_q_inside_method,
@@ -243,7 +244,7 @@ class PfAdvancedFormulation(PfFormulationTemplate):
         self.idx_dQt = np.array(0, dtype=int)
 
         k_v_m = self.analyze_branch_controls()  # this fills the indices above
-        vd, pq, pv, pqv, p, self.no_slack = compile_types(
+        self.vd, pq, pv, pqv, p, self.no_slack = compile_types(
             Pbus=self.nc.Sbus.real,
             types=self.bus_types
         )
@@ -255,7 +256,7 @@ class PfAdvancedFormulation(PfFormulationTemplate):
 
         self.Gsw = self.nc.branch_data.G0sw[self.idx_conv]
 
-        self.Ys = 1.0 / (self.nc.branch_data.R + 1j * self.nc.branch_data.X)
+        self.Ys: CxVec = self.nc.branch_data.get_series_admittance()
 
         self.adm = compute_admittances(
             R=self.nc.branch_data.R,
@@ -547,8 +548,7 @@ class PfAdvancedFormulation(PfFormulationTemplate):
                 changed, pv, pq, pqv, p = control_q_inside_method(self.Scalc, self.S0,
                                                                   self.pv, self.pq,
                                                                   self.pqv, self.p,
-                                                                  self.Qmin,
-                                                                  self.Qmax)
+                                                                  self.Qmin, self.Qmax)
 
                 if len(changed) > 0:
                     any_change = True
@@ -572,6 +572,12 @@ class PfAdvancedFormulation(PfFormulationTemplate):
             # update the tap module control
             if self.options.control_taps_modules:
                 for i, k in enumerate(self.idx_dm):
+
+                    m_taps = self.nc.branch_data.m_taps[i]
+
+                    if self.options.orthogonalize_controls and m_taps is not None:
+                        _, self.m[i] = find_closest_number(arr=m_taps, target=self.m[i])
+
                     if self.m[i] < self.nc.branch_data.tap_module_min[k]:
                         self.m[i] = self.nc.branch_data.tap_module_min[k]
                         self.tap_module_control_mode[k] = TapModuleControl.fixed
@@ -590,7 +596,14 @@ class PfAdvancedFormulation(PfFormulationTemplate):
 
             # update the tap phase control
             if self.options.control_taps_phase:
+
                 for i, k in enumerate(self.idx_dtau):
+
+                    tau_taps = self.nc.branch_data.tau_taps[i]
+
+                    if self.options.orthogonalize_controls and tau_taps is not None:
+                        _, self.tau[i] = find_closest_number(arr=tau_taps, target=self.tau[i])
+
                     if self.tau[i] < self.nc.branch_data.tap_angle_min[k]:
                         self.tau[i] = self.nc.branch_data.tap_angle_min[k]
                         self.tap_phase_control_mode[k] = TapPhaseControl.fixed

{GridCalEngine-5.1.24 → GridCalEngine-5.1.25}/GridCalEngine/Simulations/PowerFlow/power_flow_options.py

@@ -36,6 +36,7 @@ class PowerFlowOptions(OptionsTemplate):
                  control_taps_modules: bool = True,
                  control_taps_phase: bool = True,
                  control_remote_voltage: bool = True,
+                 orthogonalize_controls: bool = True,
                  apply_temperature_correction: bool = True,
                  branch_impedance_tolerance_mode=BranchImpedanceMode.Specified,
                  distributed_slack: bool = False,
@@ -86,6 +87,8 @@ class PowerFlowOptions(OptionsTemplate):
 
         self.control_remote_voltage = control_remote_voltage
 
+        self.orthogonalize_controls = orthogonalize_controls
+
         self.apply_temperature_correction = apply_temperature_correction
 
         self.branch_impedance_tolerance_mode = branch_impedance_tolerance_mode
@@ -113,6 +116,7 @@ class PowerFlowOptions(OptionsTemplate):
         self.register(key="control_taps_modules", tpe=bool)
         self.register(key="control_taps_phase", tpe=bool)
         self.register(key="control_remote_voltage", tpe=bool)
+        self.register(key="orthogonalize_controls", tpe=bool)
         self.register(key="apply_temperature_correction", tpe=bool)
         self.register(key="branch_impedance_tolerance_mode", tpe=BranchImpedanceMode)
         self.register(key="distributed_slack", tpe=bool)

{GridCalEngine-5.1.24 → GridCalEngine-5.1.25}/GridCalEngine/Utils/NumericalMethods/common.py

@@ -128,21 +128,69 @@ class ConvexMethodResult:
         print("Elapsed:\t", self.elapsed, 's')
 
 
-def find_closest_number(arr: Vec, target: float) -> float:
+# def find_closest_number(arr: Vec, target: float) -> Tuple[int, float]:
+#     """
+#     Find the closest number that exists in array
+#     :param arr: Array to be searched
+#     :param target: Value to search for
+#     :return: index in the array, Closes adjusted or truncated value
+#     """
+#     idx: int = np.searchsorted(a=arr, v=target, side='left')
+#     if idx == 0:
+#         return idx, arr[0]
+#     if idx == len(arr):
+#         return idx, arr[-1]
+#     before = arr[idx - 1]
+#     after = arr[idx]
+#     if after - target < target - before:
+#         return idx, after
+#     else:
+#         return idx - 1, before
+
+
+@nb.njit(cache=True)
+def find_closest_number(arr: Vec, target: float) -> Tuple[int, float]:
     """
     Find the closest number that exists in array
-    :param arr: Array to be searched
+    :param arr: Array to be searched (must be sorted from min to max)
     :param target: Value to search for
-    :return: Closes adjusted or truncated value
+    :return: index in the array, Closes adjusted or truncated value
     """
-    idx = np.searchsorted(arr, target)
-    if idx == 0:
-        return arr[0]
-    if idx == len(arr):
-        return arr[-1]
-    before = arr[idx - 1]
-    after = arr[idx]
-    if after - target < target - before:
-        return after
-    else:
-        return before
+    if len(arr) == 0:
+        # nothing to do
+        return -1, target
+
+    prev: float = arr[0]
+
+    if target <= prev:
+        return 0, prev
+
+    last: float = arr[-1]
+    if target >= last:
+        return len(arr) - 1, last
+
+    for i in range(1, len(arr)):
+        val: float = arr[i]
+
+        if val <= prev:
+            # test that the values strictly increase
+            raise Exception("The array must be monotonically increasing")
+
+        if prev < target <= val:
+            # the value is within the interval
+
+            d_prev = target - prev
+            d_post = val - target
+
+            if abs(d_prev - d_post) < 1e-10:
+                return i, val
+            else:
+                if d_prev < d_post:
+                    return i - 1, prev
+                else:
+                    return i, val
+
+        prev = val
+
+    # if we reached here, something went wrong...
+    return 0, arr[0]