File size: 4,264 Bytes
5070096 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 |
standard library package StateSpaceRepresentation {
doc
/*
* This package provides a model of the foundational state-space system representation,
* commonly used in control systems.
*/
private import ISQ::DurationValue;
private import Quantities::VectorQuantityValue;
private import VectorCalculations::*;
abstract attribute def StateSpace :> VectorQuantityValue;
abstract attribute def Input :> VectorQuantityValue;
abstract attribute def Output :> VectorQuantityValue;
abstract calc def GetNextState {
in input: Input;
in stateSpace: StateSpace;
in timeStep: DurationValue;
return : StateSpace;
}
abstract calc def GetOutput {
in input: Input;
in stateSpace: StateSpace;
return : Output;
}
abstract action def StateSpaceEventDef {
doc
/*
* Events to be received.
*/
}
action def ZeroCrossingEventDef :> StateSpaceEventDef;
item def StateSpaceItem {
doc
/*
* Item for SSR connection
*/
}
abstract action def StateSpaceDynamics {
doc
/*
* StateSpaceDynamics is the simplest form of State Space Representation,
* and nextState directly computes the stateSpace of the next timestep.
*/
in attribute input: Input;
abstract calc getNextState: GetNextState;
abstract calc getOutput: GetOutput;
attribute stateSpace: StateSpace;
out attribute output: Output = getOutput(input, stateSpace);
}
abstract attribute def StateDerivative :> VectorQuantityValue {
doc
/*
* The definition of the time derivative of StateSpace, which means dx/dt, where x is StateSpace
*/
ref stateSpace: StateSpace;
constraint { stateSpace.order == order }
}
abstract calc def GetDerivative {
doc
/*
* Computes the time derivative of stateSpace, which corresponds dx/dt = f(u, x), where u is input and x is stateSpace.
*/
in input: Input;
in stateSpace: StateSpace;
return : StateDerivative;
}
abstract calc def Integrate {
doc
/*
* Integrates stateSpace to compute the next stateSpace, which corresponds to x + int dx/dt dt.
* Its actual implementation should be given by a solver.
*/
in getDerivative: GetDerivative;
in input: Input;
in initialState: StateSpace;
in timeInterval: DurationValue;
return result: StateSpace;
}
abstract action def ContinuousStateSpaceDynamics :> StateSpaceDynamics {
doc
/*
* ContinuousStateSpaceDynamics represents continuous behavior.
* derivative needs to return a time derivative of stateSpace, i.e. dx/dt.
*/
abstract calc getDerivative: GetDerivative;
calc :>> getNextState: GetNextState {
/* We compute nextState by Integrate defined above by giving derivative calc. */
calc integrate: Integrate {
in getDerivative = ContinuousStateSpaceDynamics::getDerivative;
in input = GetNextState::input;
in initialState = GetNextState::stateSpace;
in timeInterval = GetNextState::timeStep;
}
return result = integrate.result;
}
event occurrence zeroCrossingEvents[0..*] : ZeroCrossingEventDef {
/* ContinuousStateSpaceDynamics may cause zero crossings anomaly. */
}
}
abstract calc def GetDifference {
doc
/*
* Computes difference of stateSpace by one timestep, that is x(k+1) - x(k),
* where k is the timestep number.
*/
in input: Input;
in stateSpace: StateSpace;
return : StateSpace;
}
abstract action def DiscreteStateSpaceDynamics :> StateSpaceDynamics {
doc
/*
* DiscreteStateSpaceDynamics represents discrete behavior.
* differences needs to return difference of the stateSpace for each timestep.
*/
abstract calc getDifference: GetDifference;
calc :>> getNextState: GetNextState {
attribute diff: StateSpace = getDifference(input, stateSpace);
return result = stateSpace + diff;
}
}
}
|