def __init__(self, dae, N=None, ts=None, yxNames=None, yuNames=None):
Ocp.__init__(self, dae, N=N, ts=ts)
self.hashPrefix = 'mhe'
if yxNames is None:
yxNames = dae.xNames()
if yuNames is None:
yuNames = dae.uNames()
if not isinstance(yxNames, list):
raise Exception("If you decide to provide measurements, "+\
"you have to provide them as a list of strings")
if not isinstance(yuNames, list):
raise Exception("If you decide to provide end measurements, "+\
"you have to provide them as a list of strings")
self._yxNames = yxNames
self._yuNames = yuNames
self._yx = C.veccat([self[n] for n in self.yxNames])
self._yu = C.veccat([self[n] for n in self.yuNames])
assert not C.dependsOn(
self.yx, self.dae.uVec()), "error: x measurement depends on u"
assert not C.dependsOn(
self.yu, self.dae.xVec()), "error: u measurement depends on x"
Ocp.minimizeLsq(self, C.veccat([self.yx, self.yu]))
Ocp.minimizeLsqEndTerm(self, self.yx)
def __init__(self, dae, N=None, ts=None, yxNames=None, yuNames=None):
Ocp.__init__(self, dae, N=N, ts=ts)
self.hashPrefix = "mhe"
if yxNames is None:
yxNames = dae.xNames()
if yuNames is None:
yuNames = dae.uNames()
if not isinstance(yxNames, list):
raise Exception("If you decide to provide measurements, " + "you have to provide them as a list of strings")
if not isinstance(yuNames, list):
raise Exception(
"If you decide to provide end measurements, " + "you have to provide them as a list of strings"
)
self._yxNames = yxNames
self._yuNames = yuNames
self._yx = C.veccat([self[n] for n in self.yxNames])
self._yu = C.veccat([self[n] for n in self.yuNames])
assert not C.dependsOn(self.yx, self.dae.uVec()), "error: x measurement depends on u"
assert not C.dependsOn(self.yu, self.dae.xVec()), "error: u measurement depends on x"
Ocp.minimizeLsq(self, C.veccat([self.yx, self.yu]))
Ocp.minimizeLsqEndTerm(self, self.yx)
def __init__(self, dae):
self._program = dae.program
self.residuals = dae.program.getDaeResidual()
self.f = [eq for eq in casadi.vertsplit(self.residuals)
if casadi.dependsOn(eq, dae.dx_dt)]
self.gx = [eq for eq in casadi.vertsplit(self.residuals)
if (not casadi.dependsOn(eq, dae.y)
and not casadi.dependsOn(eq, dae.dx_dt))]
self.gy = [eq for eq in casadi.vertsplit(self.residuals)
if casadi.dependsOn(eq, dae.y)]
def blt(self):
f = casadi.vertsplit(self.residuals)
diff_and_algebraic = [x.getVar()
for x in self._program.getVariables(self._program.DIFFERENTIATED)]
diff_and_algebraic += [x.getVar()
for x in self._program.getVariables(self._program.REAL_ALGEBRAIC)]
blt = np.zeros((len(f), len(diff_and_algebraic)), dtype=np.int8)
for i, fi in enumerate(f):
for j, xj in enumerate(diff_and_algebraic):
if casadi.dependsOn(fi, [xj]):
blt[i, j] = 1
keep = np.nonzero(blt.sum(0))[0]
diff_and_algebraic = [diff_and_algebraic[i]
for i in keep]
blt = blt[:, keep]
# sorted = np.argsort(blt.sum(0))
# diff_and_algebraic = [diff_and_algebraic[i]
# for i in sorted]
# blt = blt[:, sorted]
return blt, diff_and_algebraic
def __init__(self, \
t = ca.MX.sym("t", 1),
u = ca.MX.sym("u", 0), \
x = None, \
p = None, \
eps_e = ca.MX.sym("eps_e", 0), \
eps_u = ca.MX.sym("eps_u", 0), \
phi = None, \
f = None):
intro.pecas_intro()
print('\n' + 26 * '-' + \
' PECas system definition ' + 27 * '-')
print('\nStarting definition of ExplODE system ...')
if not all(isinstance(arg, ca.casadi.MX) for \
arg in [t, u, x, p, eps_e, eps_u, phi, f]):
raise TypeError('''
Missing input argument for system definition or wrong variable type for an
input argument. Input arguments must be CasADi symbolic types.''')
if ca.dependsOn(f, t):
raise NotImplementedError('''
Explicit time dependecies of the ODE right hand side are not yet supported in
PECas, but probably will be in future versions.''')
self.t = t
self.u = u
self.x = x
self.eps_e = eps_e
self.eps_u = eps_u
self.p = p
self.phi = phi
self.f = f
print('Definition of ExplODE system sucessful.')
def __init__(self, \
t = ca.MX.sym("t", 1),
u = ca.MX.sym("u", 0), \
x = None, \
p = None, \
eps_e = ca.MX.sym("eps_e", 0), \
eps_u = ca.MX.sym("eps_u", 0), \
phi = None, \
f = None):
intro.pecas_intro()
print('\n' + 26 * '-' + \
' PECas system definition ' + 27 * '-')
print('\nStarting definition of ExplODE system ...')
if not all(isinstance(arg, ca.casadi.MX) for \
arg in [t, u, x, p, eps_e, eps_u, phi, f]):
raise TypeError('''
Missing input argument for system definition or wrong variable type for an
input argument. Input arguments must be CasADi symbolic types.''')
if ca.dependsOn(f, t):
raise NotImplementedError('''
Explicit time dependecies of the ODE right hand side are not yet supported in
PECas, but probably will be in future versions.''')
self.t = t
self.u = u
self.x = x
self.eps_e = eps_e
self.eps_u = eps_u
self.p = p
self.phi = phi
self.f = f
print('Definition of ExplODE system sucessful.')
def depends_on(b, a):
return ca.dependsOn(b, a)
def __init__(self, dae, N = None, ts = None, yxNames = None, yuNames = None, useLinearObjTerms = False, hashPrefix = 'ocp'):
dae.assertNoFreeParams()
self.hashPrefix = hashPrefix
self._dae = dae
if N is None or ts is None:
raise Exception('please initialize Ocp with Ocp(dae, N=.., ts=..)')
assert type(N) is int, "N must be an int, got type: "+str(type(N))
assert type(ts) in [int,float], "ts must be an int or float, got type: "+str(type(ts))
self._N = N
self._ts = float(ts)
self._ebndmap = {}
self._ebndmapStart = {}
self._ebndmapEnd = {}
self._lbndmap = {}
self._lbndmapStart = {}
self._lbndmapEnd = {}
self._ubndmap = {}
self._ubndmapStart = {}
self._ubndmapEnd = {}
self._constraints = []
self._constraintsStart = []
self._constraintsEnd = []
self._dbgMessages = []
if yxNames is None:
yxNames = dae.xNames()
else:
assert isinstance(yxNames, list), "yxNames must be a list of strings"
self._yxNames = yxNames
if yuNames is None:
yuNames = dae.uNames()
else:
assert isinstance(yuNames, list), "yuNames must be a list of strings"
self._yuNames = yuNames
self._yx = C.veccat([self[n] for n in self._yxNames])
self._yu = C.veccat([self[n] for n in self._yuNames])
assert not C.dependsOn(self._yx, self.dae.uVec()), "error: x measurement depends on u"
assert not C.dependsOn(self._yu, self.dae.xVec()), "error: u measurement depends on x"
self.__minimizeLsq( C.veccat([self._yx, self._yu]) )
self.__minimizeLsqEndTerm( self._yx )
# Calculate offsets of measurements
self._yOffsets = {}
_offset = 0
for name in self._yxNames:
self._yOffsets.update({name: _offset})
_offset += self.dae[ name ].shape[ 0 ]
for name in self._yuNames:
self._yOffsets.update({name: _offset})
_offset += self.dae[ name ].shape[ 0 ]
# Usage of linear terms
self._useLinearObjTerms = useLinearObjTerms
