tops 0.2.0__tar.gz

tops-0.2.0/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2022-present Hallvar Haugdal <hallvar.haugdal@sintef.no>
+
+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.

tops-0.2.0/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.1
+Name: tops
+Version: 0.2.0
+Summary: Tiny open power system simulator
+Author-email: Hallvar Haugdal <hallvar.haugdal@sintef.no>
+License: MIT License
+        
+        Copyright (c) 2022-present Hallvar Haugdal <hallvar.haugdal@sintef.no>
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/hallvar-h/TOPS
+Project-URL: Bug Tracker, https://github.com/hallvar-h/TOPS/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: pandas
+
+# TOPS (Tiny open power system simulator)
+This is a package for performing dynamic power system simulations in Python. The aim is to provide a simple and lightweight tool which is easy to install, run and modify, to be used by researchers and in education. Performance is not the main priority. The only dependencies are numpy, scipy, pandas and matplotlib (the core functionality only uses numpy and scipy).
+
+The package is being developed as part of ongoing research, and thus contains experimental features. Use at your own risk!
+
+Some features:
+- Newton-Rhapson power flow
+- Dynamic time domain simulation (RMS/phasor approximation)
+- Linearization, eigenvalue analysis/modal analysis
+
+# Installation
+The package can be installed using pip, as follows:
+
+`pip install git+https://github.com/hallvar-h/tops`
+
+# Citing
+If you use this code for your research, please cite [this paper](https://arxiv.org/abs/2101.02937).
+
+# Example notebooks
+[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/hallvar-h/TOPS/HEAD?filepath=examples%2Fnotebooks)
+
+# Contact
+[Hallvar Haugdal](mailto:hallvhau@gmail.com)

tops-0.2.0/README.md

@@ -0,0 +1,23 @@
+# TOPS (Tiny open power system simulator)
+This is a package for performing dynamic power system simulations in Python. The aim is to provide a simple and lightweight tool which is easy to install, run and modify, to be used by researchers and in education. Performance is not the main priority. The only dependencies are numpy, scipy, pandas and matplotlib (the core functionality only uses numpy and scipy).
+
+The package is being developed as part of ongoing research, and thus contains experimental features. Use at your own risk!
+
+Some features:
+- Newton-Rhapson power flow
+- Dynamic time domain simulation (RMS/phasor approximation)
+- Linearization, eigenvalue analysis/modal analysis
+
+# Installation
+The package can be installed using pip, as follows:
+
+`pip install git+https://github.com/hallvar-h/tops`
+
+# Citing
+If you use this code for your research, please cite [this paper](https://arxiv.org/abs/2101.02937).
+
+# Example notebooks
+[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/hallvar-h/TOPS/HEAD?filepath=examples%2Fnotebooks)
+
+# Contact
+[Hallvar Haugdal](mailto:hallvhau@gmail.com)

tops-0.2.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tops"
+description = 'Tiny open power system simulator'
+readme = "README.md"
+requires-python = ">=3.7"
+license = {file="LICENSE"}
+version = "0.2.0"
+keywords = []
+authors = [
+  { name = "Hallvar Haugdal", email = "hallvar.haugdal@sintef.no" },
+]
+classifiers = [
+	"Programming Language :: Python :: 3",
+	"Operating System :: OS Independent",
+]
+dependencies = [
+	"numpy",
+	"scipy",
+	"matplotlib",
+    "pandas"
+	]
+
+[project.urls]
+"Homepage" = "https://github.com/hallvar-h/TOPS"
+"Bug Tracker" = "https://github.com/hallvar-h/TOPS/issues"

tops-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tops-0.2.0/src/tops/dyn_models/__init__.py

@@ -0,0 +1,11 @@
+from . import gen
+from . import loads
+from . import lines
+from . import trafos
+from . import shunts
+from . import avr
+from . import pss
+from . import gov
+from . import utils
+from . import pll
+from . import vsc

tops-0.2.0/src/tops/dyn_models/avr.py

@@ -0,0 +1,174 @@
+from tops.dyn_models.blocks import *
+from tops.dyn_models.utils import auto_init
+
+
+class AVR:
+    def connections(self):
+        return [
+            {
+                'input': 'v_t',
+                'source': {
+                    'container': 'gen',
+                    'mdl': '*',
+                    'id': self.par['gen'],
+                },
+                'output': 'v_t_abs',
+            },
+            {
+                'input': 'v_setp',
+                'source': {
+                    'container': 'gen',
+                    'mdl': '*',
+                    'id': self.par['gen'],
+                },
+                'output': 'v_setp',
+            },
+            {
+                'input': 'v_pss',
+                'source': {
+                    'container': 'gen',
+                    'mdl': '*',
+                    'id': self.par['gen'],
+                },
+                'output': 'v_pss',
+            },
+            {
+                'output': 'output',
+                'destination': {
+                    'container': 'gen',
+                    'mdl': '*',
+                    'id': self.par['gen'],
+                },
+                'input': 'E_f',
+            }
+        ]
+
+
+class SEXS(DAEModel, AVR):
+    def input_list(self):
+        return ['v_setp', 'v_t', 'v_pss']
+
+    def add_blocks(self):
+        p = self.par
+        self.tg_red = LeadLag(T_1=p['T_a'], T_2=p['T_b'])
+        self.gain = Gain(K=p['K'])
+        self.time_constant_lim = TimeConstantLims(T=p['T_e'], V_min=p['E_min'], V_max=p['E_max'])
+        self.tg_red.input = lambda x, v: self.v_setp(x, v) - self.v_t(x, v) + self.v_pss(x, v) + self.int_par['bias']
+        self.gain.input = lambda x, v: self.tg_red.output(x, v)
+        self.time_constant_lim.input = lambda x, v: self.gain.output(x, v)
+        self.output = lambda x, v: self.time_constant_lim.output(x, v)
+
+    def int_par_list(self):
+        return ['bias']
+
+    def init_from_connections(self, x0, v0, output_0):
+        # auto_init(self, x0, v0, output_0['output'])
+        self.int_par['bias'] = \
+            self.tg_red.initialize(
+                x0, v0, self.gain.initialize(
+                    x0, v0, self.time_constant_lim.initialize(
+                        x0, v0, output_0['output'])
+            )
+        )
+
+
+
+class SEXS_PI(DAEModel, AVR):
+    def input_list(self):
+        return ['v_setp', 'v_t', 'v_pss']
+
+    def add_blocks(self):
+        p = self.par
+        self.pi_regulator = PIRegulator(K_p=p['K_p'], K_i=p['K_i'])
+        self.tg_red = LeadLag(T_1=p['T_a'], T_2=p['T_b'])
+        self.gain = Gain(K=p['K'])
+        self.time_constant_lim = TimeConstantLims(T=p['T_e'], V_min=p['E_min'], V_max=p['E_max'])
+
+        self.v_setp_lag = TimeConstant(T=p['T_ext'])
+        self.v_setp_lag.input = lambda x, v: self.v_setp(x, v)
+        
+        self.pi_regulator.input = lambda x, v: self.v_setp_lag.output(x, v) - self.v_t(x, v) + self.v_pss(x, v)  # + self.int_par['bias']
+        self.tg_red.input = lambda x, v: self.pi_regulator.output(x, v)
+        self.gain.input = lambda x, v: self.tg_red.output(x, v)
+        self.time_constant_lim.input = lambda x, v: self.gain.output(x, v)
+        self.output = lambda x, v: self.time_constant_lim.output(x, v)
+
+    # def int_par_list(self):
+    #     return ['bias']
+
+    def init_from_connections(self, x0, v0, output_0):
+        # v_0 = np.ones(self.n_units)
+        v_0 = self.v_setp(x0, v0)
+        self.v_setp_lag.initialize(x0, v0, v_0)
+        self.pi_regulator.initialize(
+            x0, v0, self.tg_red.initialize(
+                x0, v0, self.gain.initialize(
+                    x0, v0, self.time_constant_lim.initialize(
+                        x0, v0, output_0['output']
+                    )
+                )
+            )
+        )
+
+
+class IEEET1(DAEModel, AVR):
+    '''
+    Saturation not yet included!
+    '''
+    def input_list(self):
+        return ['v_setp', 'v_t', 'v_pss']
+
+    def add_blocks(self):
+        p = self.par
+        self.time_constant_Tr = TimeConstant(T=p['T_r'])
+        self.time_constant_gain_Ka_Ta = TimeConstantGainLims(K=p['K_a'], T=p['T_a'], V_min=p['V_rmin'], V_max=p['V_rmax'])
+        self.time_constant_gain_Ke_Te = TimeConstantVar(K=p['K_e'], T=p['T_e'])
+        # self.saturation = Saturation(E_1=p['E_1'], S_e1=p['S_e1'], E_2=p['E_2'], S_e2=p['S_e2'])
+        self.diff_Kf_Tf = WashoutGain(K=p['K_f'], T_w=p['T_f'])
+        
+        self.time_constant_Tr.input = lambda x, v: self.v_t(x, v)
+        self.v_error = lambda x, v: self.v_setp(x, v) - self.time_constant_Tr.output(x, v) + self.v_pss(x, v) + self.int_par['bias']
+        self.time_constant_gain_Ka_Ta.input = lambda x, v: self.v_error(x, v) - self.diff_Kf_Tf.output(x, v)
+        self.time_constant_gain_Ke_Te.input = lambda x, v: self.time_constant_gain_Ka_Ta.output(x, v) # + self.saturation.output(x, v)
+        self.diff_Kf_Tf.input = self.time_constant_gain_Ke_Te.output
+        # self.saturation.input = lambda x, v: self.time_constant_gain_Ke_Te.output(x, v)*0
+        
+        self.output = self.time_constant_gain_Ke_Te.output
+
+    def int_par_list(self):
+        return ['bias']
+
+    def init_from_connections(self, x0, v0, output_0):
+        auto_init(self, x0, v0, output_0['output'])
+
+
+class SCRX(DAEModel, AVR):
+    '''
+    Missing negative current logic!
+    '''
+    def input_list(self):
+        return ['v_setp', 'v_t', 'v_pss']
+
+    def add_blocks(self):
+        p = self.par
+        
+        self.lead_lag_Tb_Ta = LeadLag(T_1=p['T_a'], T_2=p['T_b'])
+        self.time_constant_gain_K_Te = TimeConstantGainLims(K=p['K'], T=p['T_e'], V_min=p['E_min'], V_max=p['E_max'])
+        
+        self.v_error = lambda x, v: self.v_setp(x, v) - self.v_t(x, v) + self.v_pss(x, v) + self.int_par['bias']
+        self.lead_lag_Tb_Ta.input = self.v_error
+        self.time_constant_gain_K_Te.input = self.lead_lag_Tb_Ta.output
+
+        def current_logic_block(x, v):
+            bus_fed_idx = p['C_switch'] == 0
+            out_signal = self.time_constant_gain_K_Te.output(x, v)
+            out_signal[bus_fed_idx] *= self.v_t(x, v)[bus_fed_idx]
+            return out_signal            
+        
+        self.output = current_logic_block
+
+    def int_par_list(self):
+        return ['bias']
+
+    def init_from_connections(self, x0, v0, output_0):
+        auto_init(self, x0, v0, output_0['output'])

tops-0.2.0/src/tops/dyn_models/blocks.py

@@ -0,0 +1,368 @@
+from tops.dyn_models.utils import DAEModel, output
+import numpy as np
+
+
+class PIRegulator(DAEModel):
+
+    def add_blocks(self):
+        self.integrator = Integrator(n_units=self.n_units)
+        self.integrator.input = lambda x, v: self.input(x, v)
+
+    @output
+    def output(self, x, v):
+        # X = self.local_view(x)
+        return self.par['K_p']*self.input(x, v) + self.par['K_i']*self.integrator.output(x, v)
+
+    def initialize(self, x0, v0, output_value):
+        input_value = self.integrator.initialize(x0, v0, output_value/self.par['K_i'])
+        return input_value
+
+
+class Integrator(DAEModel):
+    def state_list(self):
+        return ['x_i']
+
+    @output
+    def output(self, x, v):
+        X = self.local_view(x)
+        return X['x_i']
+
+    def state_derivatives(self, dx, x, v):
+        dX = self.local_view(dx)
+        X = self.local_view(x)
+
+        dX['x_i'][:] = self.input(x, v)
+
+    def initialize(self, x0, v0, output_value):
+        X0 = self.local_view(x0)
+        X0['x_i'][:] = output_value
+        input_value = output_value
+        return input_value*0
+
+    
+class Integrator2(Integrator):
+    """
+    Same as Integrator, but with time constant.
+    """
+    @output
+    def output(self, x, v):
+        X = self.local_view(x)
+        return X['x_i']/self.par['T']
+
+    def initialize(self, x0, v0, output_value):
+        X0 = self.local_view(x0)
+        X0['x_i'][:] = output_value*self.par['T']
+        input_value = output_value*self.par['T']
+        return input_value*0
+
+
+class Gain(DAEModel):
+    @output
+    def output(self, x, v):
+        # X = self.local_view(x)
+        return self.par['K']*self.input(x, v)
+
+    def initialize(self, x0, v0,output_value):
+        return output_value/self.par['K']
+
+
+class Limiter(DAEModel):
+    @output
+    def output(self, x, v):
+        # X = self.local_view(x)
+        return np.minimum(np.maximum(self.input(x, v), self.par['Min']), self.par['Max'])
+
+
+class Washout(DAEModel):
+    def state_list(self):
+        return ['x']
+
+    @output
+    def output(self, x, v):
+        X = self.local_view(x)
+        return (self.input(x, v) - X['x'])/self.par['T_w']
+
+    def state_derivatives(self, dx, x, v):
+        dX = self.local_view(dx)
+        X = self.local_view(x)
+
+        dX['x'][:] = self.output(x, v)
+
+
+class TimeConstant(DAEModel):
+    '''
+            ______________	
+           |               |
+           |       1       |
+    u ---->|  -----------  |----> y
+           |    1 + s*T    |
+           |_______________|
+
+
+    '''
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.zero_idx = self.par['T']==0
+    
+    def state_list(self):
+        return ['x']
+
+    @output
+    def output(self, x, v):
+        X = self.local_view(x)
+        out = X['x']
+        if np.any(self.zero_idx):
+            out[self.zero_idx] = self.input(x, v)[self.zero_idx]
+        return out
+
+    def initialize(self, x0, v0, output_value):
+        X0 = self.local_view(x0)
+        X0['x'][:] = output_value
+        return output_value
+
+    def state_derivatives(self, dx, x, v):
+        dX = self.local_view(dx)
+        X = self.local_view(x)
+        
+        coeff = ~self.zero_idx/(self.par['T']+self.zero_idx)  # 1/T if T is not zero, 0 otherw
+        dX['x'][:] = coeff*(self.input(x, v) - X['x'])
+
+
+class TimeConstantVar(TimeConstant):
+    '''
+            ______________	
+           |               |
+           |       1       |
+    u ---->|  -----------  |----> y
+           |    K + s*T    |
+           |_______________|
+
+
+    '''
+    def initialize(self, x0, v0, output_value):
+        X0 = self.local_view(x0)
+        X0['x'][:] = output_value
+        return self.par['K']*output_value
+
+    def state_derivatives(self, dx, x, v):
+        dX = self.local_view(dx)
+        X = self.local_view(x)
+        # Check if T=0?
+        dX['x'][:] = 1/self.par['T']*(self.input(x, v) - self.par['K']*X['x'])
+
+
+class TimeConstantGain(TimeConstant):
+    def output(self, x, v):
+        return self.par['K']*super().output(x, v)
+    
+    def initialize(self, x0, v0, output_value):
+        return super().initialize(x0, v0, output_value/self.par['K'])
+
+
+class TimeConstantLims(DAEModel):
+    '''
+	                 ___ V_max
+            ________/_____	
+           |               |
+           |       1       |
+    u ---->|  -----------  |----> y
+           |   1 + s*T_2   |
+           |_______________|
+               ___/
+          V_min
+
+    '''
+    def state_list(self):
+        return ['x']
+
+    @output
+    def output(self, x, v):
+        X = self.local_view(x)
+        return np.minimum(np.maximum(X['x'], self.par['V_min']), self.par['V_max'])
+
+    def initialize(self, x0, v0,output_value):
+        X0 = self.local_view(x0)
+        X0['x'][:] = np.minimum(np.maximum(output_value, self.par['V_min']), self.par['V_max'])
+        return output_value
+
+    def state_derivatives(self, dx, x, v):
+        dX = self.local_view(dx)
+        X = self.local_view(x)
+
+        dX['x'][:] = 1/self.par['T']*(self.input(x, v) - X['x'])
+
+        # Lims on state variable (clamping)
+        lower_lim_idx = (X['x'] <= self.par['V_min']) & (dX['x'] < 0)
+        dX['x'][lower_lim_idx] *= 0
+
+        upper_lim_idx = (X['x'] >= self.par['V_max']) & (dX['x'] > 0)
+        dX['x'][upper_lim_idx] *= 0
+
+class TimeConstantGainLims(TimeConstantLims):
+    '''
+	                 ___ V_max
+            ________/_____	
+           |               |
+           |       K       |
+    u ---->|  -----------  |----> y
+           |   1 + s*T_2   |
+           |_______________|
+               ___/
+          V_min
+
+    '''
+    def state_derivatives(self, dx, x, v):
+        dX = self.local_view(dx)
+        X = self.local_view(x)
+
+        dX['x'][:] = 1/self.par['T']*(self.par['K']*self.input(x, v) - X['x'])
+
+        # Lims on state variable (clamping)
+        lower_lim_idx = (X['x'] <= self.par['V_min']) & (dX['x'] < 0)
+        dX['x'][lower_lim_idx] *= 0
+
+        upper_lim_idx = (X['x'] >= self.par['V_max']) & (dX['x'] > 0)
+        dX['x'][upper_lim_idx] *= 0
+    
+    def initialize(self, x0, v0, output_value):
+        return super().initialize(x0, v0, output_value/self.par['K'])
+
+class LeadLag(DAEModel):
+    '''
+            _______________
+           |               |
+           |   1 + s*T_1   |
+    u ---->|  -----------  |----> y
+           |   1 + s*T_2   |
+           |_______________|
+     
+    '''
+    def state_list(self):
+        return ['x']
+
+    @output
+    def output(self, x, v):
+        X = self.local_view(x)
+        return 1/self.par['T_2']*(self.par['T_1']*self.input(x, v) - X['x'])
+
+    def initialize(self, x0, v0,output_value):
+        X0 = self.local_view(x0)
+        p = self.par
+
+        X0['x'][:] = p['T_1']*output_value - p['T_2']*output_value
+        return output_value
+
+    def state_derivatives(self, dx, x, v):
+        dX = self.local_view(dx)
+        X = self.local_view(x)
+
+        dX['x'][:] = (self.par['T_1']/self.par['T_2'] - 1)*self.input(x, v) - 1/self.par['T_2']*X['x']
+
+
+class PIRegulator2(DAEModel):
+    def state_list(self):
+        return ['x']
+
+    @output
+    def output(self, x, v):
+        X = self.local_view(x)
+        return 1/self.par['T_2']*(self.par['T_1']*self.input(x, v) + X['x'])
+
+    def state_derivatives(self, dx, x, v):
+        dX = self.local_view(dx)
+        X = self.local_view(x)
+        dX['x'][:] = self.input(x, v)
+
+    def initialize(self, x0, v0, output_value):
+        X = self.local_view(x0)
+        X['x'] = self.par['T_2']/self.par['T_1']*output_value
+        return np.zeros(self.n_units)
+    
+
+class WashoutGain(DAEModel):
+    '''
+            _______________
+           |               |
+           |      s*K      |
+    u ---->|  -----------  |----> y
+           |    1 + s*T    |
+           |_______________|
+     
+    sK/(1+sT) = y/u
+    u*sK = y + sTy
+    s(Ku - Ty) = y
+    x = Ku - Ty
+    sx = y
+    y = 1/T(Ku - x)
+    '''
+    def state_list(self):
+        return ['x']
+
+    @output
+    def output(self, x, v):
+        X = self.local_view(x)
+        return 1/self.par['T_w']*(self.par['K']*self.input(x, v) - X['x'])
+
+    def state_derivatives(self, dx, x, v):
+        dX = self.local_view(dx)
+        dX['x'][:] = self.output(x, v)
+
+    # def initialize(self, x0, v0, output_value):
+        # dx = 0 => x = Ku
+        # pass
+
+
+class Saturation(DAEModel):
+    '''
+    Not verified!!
+    '''
+    @output
+    def output(self, x, v):
+        U = self.input(x, v)
+        
+        E1 = self.par['E_1']
+        SE1 = self.par['S_e1']
+        E2 = self.par['E_2']
+        SE2 = self.par['S_e2']
+
+        sqrt = np.sqrt
+        K = SE1/SE2
+        A = sqrt(E1*E2)*(sqrt(E1) - sqrt(E2*K))/(sqrt(E2) - sqrt(E1*K))
+        B = SE2*(sqrt(E2) - sqrt(E1*K))**2/(E1 - E2)**2
+
+        
+        with np.errstate(divide='ignore'):
+            SE = B*(U - A)**2/U
+        SE[U <= 0] = 0
+        
+        return SE
+    
+
+class Backlash(DAEModel):
+    """Based on PowerFactory implementation"""
+    def state_list(self):
+        return ['x']
+    
+    def state_derivatives(self, dx, x, v):
+        dX = self.local_view(dx)
+        X = self.local_view(x)
+        db = self.par['db']
+        if db <= 0:
+            return db*0
+
+        y = self.input(x, v)
+        x = X['x']
+
+        if (y - x) >= db:
+            d = (y - x) - db
+        elif (y - x) <= -db:
+            d = (y - x) + db
+        else:
+            d = 0
+
+        dX['x'][:] = d/0.01
+
+    @output
+    def output(self, x, v):
+        X = self.local_view(x)
+        return X['x']