| |
libFAUDES
Sections
Index
|
hio_functions.hGo to the documentation of this file.00001 /** @file hio_functions.h Algorithms for hierarchical discrete event systems with inputs and outputs */ 00002 00003 /* Hierarchical IO Systems Plug-In for FAU Discrete Event Systems Library (libfaudes) 00004 00005 Copyright (C) 2006 Sebastian Perk 00006 Copyright (C) 2006 Thomas Moor 00007 Copyright (C) 2006 Klaus Schmidt 00008 00009 */ 00010 00011 00012 #ifndef FAUDES_HIO_FUNCTIONS_H 00013 #define FAUDES_HIO_FUNCTIONS_H 00014 00015 #include "hio_constraint.h" 00016 #include "hio_plant.h" 00017 #include "hio_controller.h" 00018 #include "hio_environment.h" 00019 #include "corefaudes.h" 00020 #include "regular.h" 00021 #include <vector> 00022 #include <stack> 00023 #include <map> 00024 00025 namespace faudes { 00026 00027 /** 00028 * CompleteSynth: compute supremal complete and 00029 * controllable (and closed) sublanguage. 00030 * Computes the supremal complete and 00031 * controllable (and closed) sublanguage of the 00032 * language generated by rSpec wrt the language 00033 * generated by rPlant and the controllable events 00034 * rCalph. 00035 * Method: iteration of SupCon() and erasing of dead 00036 * states found by IsComplete until a fix point is 00037 * reached. 00038 * Leads to maximal solution as shown in: 00039 * Kumar, Garg, Marcus. "On Supervisory Control of 00040 * sequential behaviors" IEEE Transactions On 00041 * Automatic Control, Vol. 37, 1992, pp. 1978-1985 00042 * 00043 * More concise version SupConComplete() is under 00044 * construction, see below. 00045 * 00046 * @param rPlant 00047 * plant generator 00048 * @param rCAlph 00049 * controllable events 00050 * @param rSpec 00051 * specification generator 00052 * @param rClosedLoop 00053 * reference to result 00054 * 00055 * @return 00056 * success (true) for nonempty result 00057 * 00058 * @exception Exception 00059 * - see exceptions of SupCon() 00060 * 00061 * @ingroup hiosysplugin 00062 */ 00063 00064 bool CompleteSynth( 00065 const Generator& rPlant, 00066 const EventSet rCAlph, 00067 const Generator& rSpec, 00068 Generator& rClosedLoop); 00069 00070 /** 00071 * NormalCompleteSynth: compute normal, complete 00072 * and controllable (and closed) sublanguage. 00073 * Computes the supremal normal, complete and 00074 * controllable (and closed) sublanguage of the 00075 * language generated by rSpec wrt the language 00076 * generated by rPlant, the controllable events 00077 * rCalph and the observable events rOAlph. 00078 * Method: iteration of CompleteSynth() and SupNorm() 00079 * until a fix point is reached. 00080 * Note: Supremality (if existent at all) has not yet been 00081 * considered. The proof of existence and construction 00082 * of both 00083 * -the supremal normal and complete sublanguage and 00084 * -the supremal normal and controllable sublanguage 00085 * can be found in literature, which gives reason for 00086 * hope. 00087 * 00088 * @param rPlant 00089 * plant generator 00090 * @param rCAlph 00091 * controllable events 00092 * @param rOAlph 00093 * observable events 00094 * @param rSpec 00095 * specification generator 00096 * @param rClosedLoop 00097 * reference to result 00098 * 00099 * @return 00100 * success (true) for nonempty closed loop language 00101 * 00102 * @exception Exception 00103 * - see exceptions of SupCon() and SupNorm() 00104 * 00105 * @ingroup hiosysplugin 00106 * 00107 */ 00108 00109 bool NormalCompleteSynth( 00110 Generator& rPlant, 00111 const EventSet& rCAlph, 00112 const EventSet& rOAlph, 00113 const Generator& rSpec, 00114 Generator& rClosedLoop); 00115 00116 /** 00117 * NormalCompleteSynthNB: compute normal, complete, 00118 * controllable and nonblocking sublanguage. 00119 * Computes a normal, complete, controllable and 00120 * nonblocking (and closed) sublanguage of 00121 * of the language marked by rSpec wrt the language 00122 * marked by rPlant, the controllable events 00123 * rCalph and the observable events rOAlph. 00124 * Method: iteration of CompleteSynth(), SupNorm() 00125 * and Trim() until a fix point is reached. 00126 * Note: Supremality (if existent at all) has not yet been 00127 * considered. 00128 * 00129 * @param rPlant 00130 * plant generator 00131 * @param rCAlph 00132 * controllable events 00133 * @param rOAlph 00134 * observable events 00135 * @param rSpec 00136 * specification generator 00137 * @param rClosedLoop 00138 * reference to result 00139 * 00140 * @return 00141 * success (true) for nonempty closed loop language 00142 * 00143 * @exception Exception 00144 * - see exceptions of SupCon() and SupNorm() 00145 * 00146 * @ingroup hiosysplugin 00147 * 00148 */ 00149 bool NormalCompleteSynthNB( 00150 Generator& rPlant, 00151 const EventSet& rCAlph, 00152 const EventSet& rOAlph, 00153 const Generator& rSpec, 00154 Generator& rClosedLoop); 00155 00156 /** 00157 * IoSortCL: returns IO-sorting structure required 00158 * for closed loops. This structure is the prefix closure of 00159 * the language structure [(Yp(Up+YcUcUp))*(YeUe)*]* 00160 * 00161 * @param rYc 00162 * alphabet Yc 00163 * @param rUc 00164 * alphabet Uc 00165 * @param rYp 00166 * alphabet Yp 00167 * @param rUp 00168 * alphabet Up 00169 * @param rYe 00170 * alphabet Ye 00171 * @param rUe 00172 * alphabet Ue 00173 * 00174 * @return 00175 * IO-sorting language generator 00176 * 00177 * @exception Exception 00178 * - empty parameter(s) (id 0) 00179 * - non-disjoint parameters (id 0) 00180 * 00181 * @ingroup hiosysplugin 00182 * 00183 */ 00184 00185 Generator IoSortCL( 00186 const EventSet& rYc, 00187 const EventSet& rUc, 00188 const EventSet& rYp, 00189 const EventSet& rUp, 00190 const EventSet& rYe, 00191 const EventSet& rUe); 00192 00193 /** 00194 * FreeInput: extend generator by obviously missing 00195 * input transitions. States of the generator in which a 00196 * strict but nonempty subset of the alphabet Input is active 00197 * are extended by transitions to an error state (ErrState1, 00198 * flag Err) such that now the whole Input alphabet is active in 00199 * that state. If the alphabet Output is nonempty, an error 00200 * behaviour (Output Input)* is concatenated to the error state 00201 * using a second error state (ErrState2, flag Err). 00202 * Note that this method only helps making the input free in an 00203 * hio system but does not guarantee a free input. 00204 * Method: the transition relation of all states with at least 00205 * one active AND at least one inactive Input-event is 00206 * extended by transitions such that formerly inactive Input- 00207 * events lead to the first error state in the result. If the 00208 * parameter Output is nonempty, transitions with all 00209 * Output-events from first error state to the second error 00210 * state, and transitions with all Input-events back to the 00211 * first error state are inserted. 00212 * Note: states with NO active Input-event are ignored. 00213 * 00214 * @param rGen 00215 * generator 00216 * @param rInput 00217 * alphabet Input 00218 * @param rOutput 00219 * alphabet Output 00220 * @param rResGen 00221 * reference to extended generator (result) 00222 * @param rErrState1 00223 * symbolic name of first error state; ignored if not 00224 * rGen.StateNamesEnabled() 00225 * @param rErrState2 00226 * symbolic name of second error state; ignored if not 00227 * rGen.StateNamesEnabled() 00228 * @param rErrState1Idx 00229 * index of first error state (result) 00230 * @param rErrState2Idx 00231 * index of second error state if inserted (result) 00232 * 00233 * @exception Exception 00234 * - empty Input-alphabet or non-disjoint Input and Output (id 0) 00235 * 00236 * @ingroup hiosysplugin 00237 * 00238 */ 00239 00240 void FreeInput( 00241 const Generator& rGen, 00242 const EventSet& rInput, 00243 const EventSet& rOutput, 00244 Generator& rResGen, 00245 const std::string& rErrState1, 00246 const std::string& rErrState2, 00247 Idx& rErrState1Idx, 00248 Idx& rErrState2Idx); 00249 00250 /** 00251 * FreeInput: extend generator by obviously missing 00252 * input transitions. States of the generator in which a 00253 * strict but nonempty subset of the alphabet Input is active 00254 * are extended by transitions to an error state (ErrState1, 00255 * flag Err) such that now the whole Input alphabet is active in 00256 * that state. If the alphabet Output is nonempty, an error 00257 * behaviour (Output Input)* is concatenated to the error state 00258 * using a second error state (ErrState2, flag Err). 00259 * Note that this method only helps making the input free in an 00260 * hio system but does not guarantee a free input. 00261 * Method: the transition relation of all states with at least 00262 * one active AND at least one inactive Input-event is 00263 * extended by transitions such that formerly inactive Input- 00264 * events lead to the first error state in the result. If the 00265 * parameter Output is nonempty, transitions with all 00266 * Output-events from first error state to the second error 00267 * state, and transitions with all Input-events back to the 00268 * first error state are inserted. 00269 * Note: states with NO active Input-event are ignored. 00270 * 00271 * @param rGen 00272 * generator 00273 * @param rInput 00274 * alphabet Input 00275 * @param rOutput 00276 * alphabet Output 00277 * @param rResGen 00278 * reference to extended generator (result) 00279 * @param rErrState1 00280 * symbolic name of first error state; ignored if not 00281 * rGen.StateNamesEnabled() 00282 * @param rErrState2 00283 * symbolic name of second error state; ignored if not 00284 * rGen.StateNamesEnabled() 00285 * 00286 * @exception Exception 00287 * - empty Input-alphabet or non-disjoint Input and Output (id 0) 00288 * 00289 * @ingroup hiosysplugin 00290 * 00291 */ 00292 00293 void FreeInput( 00294 const Generator& rGen, 00295 const EventSet& rInput, 00296 const EventSet& rOutput, 00297 Generator& rResGen, 00298 const std::string& rErrState1, 00299 const std::string& rErrState2); 00300 00301 /** 00302 * FreeInput: extend generator by obviously missing 00303 * input transitions. States of the generator in which a 00304 * strict but nonempty subset of the alphabet Input is active 00305 * are extended by transitions to an error state (flag Err) 00306 * such that now the whole Input alphabet is active in 00307 * that state. If the alphabet Output is nonempty, an error 00308 * behaviour (Output Input)* is concatenated to the error state 00309 * using a second error state (flag Err). 00310 * Note that this method only helps making the input free in an 00311 * hio system but does not guarantee a free input. 00312 * Method: the transition relation of all states with at least 00313 * one active AND at least one inactive Input-event is 00314 * extended by transitions such that formerly inactive Input- 00315 * events lead to the first error state in the result. If the 00316 * parameter Output is nonempty, transitions with all 00317 * Output-events from first error state to the second error 00318 * state, and transitions with all Input-events back to the 00319 * first error state are inserted. 00320 * Note: states with NO active Input-event are ignored. 00321 * 00322 * @param rGen 00323 * generator 00324 * @param rInput 00325 * alphabet Input 00326 * @param rOutput 00327 * alphabet Output 00328 * @param rResGen 00329 * reference to extended generator (result) 00330 * 00331 * @exception Exception 00332 * - empty Input-alphabet or non-disjoint Input and Output (id 0) 00333 * 00334 * @ingroup hiosysplugin 00335 * 00336 */ 00337 void FreeInput( 00338 const Generator& rGen, 00339 const EventSet& rInput, 00340 const EventSet& rOutput, 00341 Generator& rResGen); 00342 00343 /** 00344 * FreeInput: extend HioPlant by obviously missing 00345 * input transitions. States of the HioPlant in which a 00346 * strict but nonempty subset of the Up- or Ue-alphabet is active 00347 * are extended by transitions to an error state such that 00348 * now the whole Up- or Ue-alphabet is active in that state. 00349 * Note that this method only helps making the input free in an 00350 * hio system but does not guarantee a free input. 00351 * Method: the transition relation of all states with at least 00352 * one active AND at least one inactive Up- or Ue-event is 00353 * extended by transitions such that formerly inactive Up- or Ue- 00354 * events lead to the Up- or Ue-error state in the result. 00355 * Note: states with NO active Up- or Ue-event are ignored. 00356 * 00357 * @param rPlant 00358 * HioPlant 00359 * @param rResPlant 00360 * reference to extended HioPlant (result) 00361 * 00362 * @ingroup hiosysplugin 00363 * 00364 */ 00365 void FreeInput( 00366 const HioPlant& rPlant, 00367 HioPlant& rResPlant); 00368 00369 /** 00370 * FreeInput: extend HioController by obviously missing 00371 * input transitions. States of the HioController in which a 00372 * strict but nonempty subset of the Uc- or Yp-alphabet is active 00373 * are extended by transitions to an error state such that 00374 * now the whole Uc- or Yp-alphabet is active in that state. To 00375 * avoid an additional deadlock violating completeness, an error 00376 * behaviour (Up Yp)* is concatenated to the error state 00377 * using a second error state. 00378 * Note that this method only helps making the input free in an 00379 * hio system but does not guarantee a free input. 00380 * Method: the transition relation of all states with at least 00381 * one active AND at least one inactive Uc- or Yp-event is 00382 * events lead to the Uc- or Yp-error state in the result. 00383 * For each Up-event, a transition to a second error state, and 00384 * for each Yp-event, a transition from the second to the first 00385 * error state is inserted to realise the error behaviour. 00386 * Note: states with NO active Uc- or Yp-event are ignored. 00387 * 00388 * @param rController 00389 * HioController 00390 * @param rResController 00391 * reference to extended HioController (result) 00392 * 00393 * @ingroup hiosysplugin 00394 * 00395 */ 00396 void FreeInput( 00397 const HioController& rController, 00398 HioController& rResController); 00399 00400 /** 00401 * FreeInput: extend HioEnvironment by obviously missing 00402 * input transitions. States of the HioEnvironment in which a 00403 * strict but nonempty subset of the Ul- or Ye-alphabet is active 00404 * are extended by transitions to an error state such that 00405 * now the whole Ul- or Ye-alphabet is active in that state.To 00406 * avoid an additional deadlock violating completeness, an error 00407 * behaviour (Ue Ye)* is concatenated to the error state 00408 * using a second error state. 00409 * Note that this method only helps making the input free in an 00410 * hio system but does not guarantee a free input. 00411 * Method: the transition relation of all states with at least 00412 * one active AND at least one inactive Ul- or Ye-event is 00413 * events lead to the Ul- or Ye-error state in the result. 00414 * For each Ue-event, a transition to a second error state, and 00415 * for each Ye-event, a transition from the second to the first 00416 * error state is inserted to realise the error behaviour. 00417 * Note: states with NO active Ul- or Ye-event are ignored. 00418 * 00419 * @param rEnvironment 00420 * HioEnvironment 00421 * @param rResEnvironment 00422 * reference to extended HioEnvironment (result) 00423 * 00424 * @ingroup hiosysplugin 00425 * 00426 */ 00427 void FreeInput( 00428 const HioEnvironment& rEnvironment, 00429 HioEnvironment& rResEnvironment); 00430 00431 /** 00432 * FreeInput: extend HioConstraint by obviously missing 00433 * input transitions. States of the HioConstraint in which a 00434 * strict but nonempty subset of the U-alphabet is active 00435 * are extended by transitions to an error state such that 00436 * now the whole U-alphabet is active in that state.To 00437 * avoid an additional deadlock violating completeness, an error 00438 * behaviour (U Y)* is concatenated to the error state 00439 * using a second error state. 00440 * Note that this method only helps making the input free in an 00441 * hio system but does not guarantee a free input. 00442 * Method: the transition relation of all states with at least 00443 * one active AND at least one inactive U-event is 00444 * events lead to the U-error state in the result. 00445 * For each U-event, a transition to a second error state, and 00446 * for each Y-event, a transition from the second to the first 00447 * error state is inserted to realise the error behaviour. 00448 * Note: states with NO active U-event are ignored. 00449 * 00450 * @param rConstraint 00451 * HioConstraint 00452 * @param rResConstraint 00453 * reference to extended HioConstraint (result) 00454 * 00455 * @ingroup hiosysplugin 00456 * 00457 */ 00458 void FreeInput( 00459 const HioConstraint& rConstraint, 00460 HioConstraint& rResConstraint); 00461 00462 /** 00463 * FreeInput: convenience interface to faudes::FreeInput(const HioPlant&, HioPlant) 00464 * 00465 * @param rPlant 00466 * HioPlant 00467 * @ingroup hiosysplugin 00468 * 00469 */ 00470 void FreeInput(HioPlant& rPlant); 00471 00472 /** 00473 * FreeInput: convenience interface to faudes::FreeInput(const HioController&, HioController) 00474 * 00475 * @param rController 00476 * HioController 00477 * @ingroup hiosysplugin 00478 * 00479 */ 00480 void FreeInput(HioController& rController); 00481 00482 /** 00483 * FreeInput: convenience interface to faudes::FreeInput(const HioEnvironment&, HioEnvironment) 00484 * 00485 * @param rEnvironment 00486 * HioEnvironment 00487 * @ingroup hiosysplugin 00488 * 00489 */ 00490 void FreeInput(HioEnvironment& rEnvironment); 00491 00492 /** 00493 * FreeInput: convenience interface to faudes::FreeInput(const HioConstraint&, HioConstraint) 00494 * 00495 * @param rConstraint 00496 * HioConstraint 00497 * @ingroup hiosysplugin 00498 * 00499 */ 00500 void FreeInput(HioConstraint& rConstraint); 00501 00502 00503 00504 //********************************************************** 00505 //******************** Completeness ************************ 00506 //********************************************************** 00507 00508 /** 00509 * SupConComplete: Supremal Controllable and Complete Sublanguage - 00510 * alternative for CompleteSynth() - UNDER CONSTRUCTION. 00511 * CURRENTLY SLOWER THAN COMPLETESYNTH()! 00512 * Computes the supremal sublanguage of the language generated 00513 * by rSpec that is complete controllable wrt language generated 00514 * by rPlant and wrt the set rCAlph of controllable events. The result 00515 * is stored in rClosedLoop. 00516 * Method: Using the functions IsComplete() and IsControllable(), this 00517 * function iteratively determines and erases the set of incomplete 00518 * and/or uncontrollable states. For a proof of correctness, see: 00519 * 00520 * R. Kumar, V. Garg, and S.I. Marcus. On supervisory control of 00521 * sequential behaviors. IEEE Transactions on Automatic Control, 00522 * Vol. 37: pp.1978-1985, 1992. 00523 * 00524 * Determinism: 00525 * parameters have to be deterministic. Result is deterministic. 00526 * 00527 * @param rPlant 00528 * Plant Generator 00529 * @param rCAlph 00530 * Controllable events 00531 * @param rSpec 00532 * Specification Generator 00533 * @param rResGen 00534 * Reference to resulting generator 00535 * 00536 * @exception Exception 00537 * - Thrown by ControlProblemConsistencyCheck() 00538 * 00539 * 00540 */ 00541 bool SupConComplete( 00542 const Generator& rPlant, 00543 const EventSet rCAlph, 00544 const Generator& rSpec, 00545 Generator& rResGen); 00546 00547 //********************************************************** 00548 //******************** IO-shuffle ************************ 00549 //********************************************************** 00550 00551 /** 00552 * MarkIoShuffle: marking rule for IoShuffle() in case of 00553 * marked parameters rGen1 and rGen2 - UNDER CONSTRUCTION. 00554 * 00555 * Method: 00556 * Strings ending with events from rGen1 are marked according 00557 * to rGen1, strings ending with events from rGen2 are marked 00558 * according to rGen2. 00559 * 00560 * @param rGen1 00561 * First generator 00562 * @param rGen2 00563 * Second generator 00564 * @param rReverseCompositionMap 00565 * map from rGen1 and rGen2 state indeces to respective 00566 * state indeces of result 00567 * @param rShuffle 00568 * Shuffle of rGen1 and rGen2 that shall receive marking 00569 * 00570 * @ingroup hiosysplugin 00571 * 00572 */ 00573 void MarkIoShuffle( 00574 const vGenerator& rGen1, 00575 const vGenerator& rGen2, 00576 const std::map< std::pair<Idx,Idx>, Idx >& rReverseCompositionMap, 00577 vGenerator& rShuffle); 00578 00579 /** 00580 * CheapAltAnB: returns Generator of the following 00581 * specification: "After a maximum of n (=depth) pairs of 00582 * A-transitions, a B-transition has to occur!". 00583 * 00584 * @param rAset 00585 * alphabet A 00586 * @param rBset 00587 * alphabet B 00588 * @param Depth 00589 * depth of alternation 00590 * @param rAltAnB 00591 * generator of AnB-specification 00592 * 00593 * @exception Exception 00594 * - n less than 1 (id 0) 00595 * - rAset empty (id 0) 00596 * - rBset empty (id 0) 00597 * 00598 * @ingroup hiosysplugin 00599 * 00600 */ 00601 void CheapAltAnB( 00602 const EventSet rAset, 00603 const EventSet rBset, 00604 const int Depth, 00605 Generator& rAltAnB); 00606 00607 /** 00608 * CheapAltAB: returns Generator of the following 00609 * specification: "After a maximum of n (=depth) pairs of 00610 * A-transitions, a B-transition has to occur and vice-versa!". 00611 * 00612 * @param rAset 00613 * alphabet A 00614 * @param rBset 00615 * alphabet B 00616 * @param Depth 00617 * depth of alternation 00618 * @param rAltAB 00619 * generator of AB-specification 00620 * 00621 * @exception Exception 00622 * - n less than 1 (id 0) 00623 * - rAset empty (id 0) 00624 * - rBset empty (id 0) 00625 * 00626 * @ingroup hiosysplugin 00627 * 00628 */ 00629 void CheapAltAB( 00630 const EventSet rAset, 00631 const EventSet rBset, 00632 const int Depth, 00633 Generator& rAltAB); 00634 00635 /** 00636 * MarkAlternationAB: returns Generator marking the 00637 * alternation of Aset-transitions with Bset-transitions. 00638 * More docu will be provided soon. 00639 * 00640 * @param rAset 00641 * alphabet A 00642 * @param rBset 00643 * alphabet B 00644 * @param rAltAB 00645 * recognizer of AB-alternation 00646 * 00647 * @exception Exception 00648 * - rAset empty (id 0) 00649 * - rBset empty (id 0) 00650 * 00651 * @ingroup hiosysplugin 00652 * 00653 */ 00654 void MarkAlternationAB( 00655 const EventSet rAset, 00656 const EventSet rBset, 00657 Generator& rAltAB); 00658 00659 /** 00660 * IoShuffleUnchecked: IO-shuffle of rPlantA and rPlantB 00661 * according to definition, no parameter check. Moreover: marking 00662 * of alternation according to MarkAlternationAB(). 00663 * 00664 * TODO: 'checked' version 00665 * 00666 * @param rPlantA 00667 * plant A generator 00668 * @param rPlantB 00669 * plant B generator 00670 * @param rYp 00671 * alphabet Yp 00672 * @param rUp 00673 * alphabet Up 00674 * @param rYe 00675 * alphabet Ye 00676 * @param rUe 00677 * alphabet Ue 00678 * @param rIOShuffAB 00679 * reference to I/O-shuffle generator 00680 * 00681 * @ingroup hiosysplugin 00682 * 00683 */ 00684 void IoShuffleUnchecked( 00685 const Generator& rPlantA, 00686 const Generator& rPlantB, 00687 const EventSet& rYp, 00688 const EventSet& rUp, 00689 const EventSet& rYe, 00690 const EventSet& rUe, 00691 Generator& rIOShuffAB); 00692 00693 /** 00694 * IoShuffle: IO-shuffle of rPlantA and rPlantB according 00695 * to definition. Moreover: marking of alternation 00696 * according to MarkAlternationAB(). 00697 * 00698 * 00699 * @param rPlantA 00700 * plant A generator 00701 * @param rPlantB 00702 * plant B generator 00703 * @param rYp 00704 * alphabet Yp 00705 * @param rUp 00706 * alphabet Up 00707 * @param rYe 00708 * alphabet Ye 00709 * @param rUe 00710 * alphabet Ue 00711 * @param rIOShuffAB 00712 * reference to I/O-shuffle generator 00713 * 00714 * @exception Exception 00715 * - empty or non-disjoint alphabets rYp, rUp, rYe, rUe (id 0). 00716 * - plant A or plant B not in IoPlantForm (id 0). 00717 * 00718 * @ingroup hiosysplugin 00719 * 00720 */ 00721 void IoShuffle( 00722 const Generator& rPlantA, 00723 const Generator& rPlantB, 00724 const EventSet& rYp, 00725 const EventSet& rUp, 00726 const EventSet& rYe, 00727 const EventSet& rUe, 00728 Generator& rIOShuffAB); 00729 00730 /** 00731 * IoShuffle: IO-shuffle of rPlantA and rPlantB according 00732 * to definition. Moreover: alternation of depth 00733 * Depth (see CheapAltAB()) between A- and B-events (no 00734 * alternation for Depth=1) and marking of alternation 00735 * according to MarkAlternationAB(). 00736 * 00737 * @param rPlantA 00738 * HioPlant A 00739 * @param rPlantB 00740 * HioPlant B 00741 * @param rIOShuffAB 00742 * reference to composed HioPlant 00743 * 00744 * @exception Exception 00745 * - todo... 00746 * 00747 * @ingroup hiosysplugin 00748 * 00749 */ 00750 void IoShuffle( 00751 const HioPlant& rPlantA, 00752 const HioPlant& rPlantB, 00753 HioPlant& rIOShuffAB); 00754 00755 //******************** old version: no marking, forced alternation ************************ 00756 /** 00757 * IoShuffleTU: IO-shuffle of rPlantA and rPlantB according 00758 * to definition with additional forced alternation of depth 00759 * Depth (see CheapAltAB()) between A- and B-events. 00760 * -> frozen version for transport unit example 00761 * 00762 * @param rPlantA 00763 * plant A generator 00764 * @param rPlantB 00765 * plant B generator 00766 * @param rYp 00767 * alphabet Yp 00768 * @param rUp 00769 * alphabet Up 00770 * @param rYe 00771 * alphabet Ye 00772 * @param rUe 00773 * alphabet Ue 00774 * @param Depth 00775 * depth of alternation 00776 * @param rIOShuffAB 00777 * reference to I/O-shuffle generator 00778 * 00779 * @exception Exception 00780 * - todo... 00781 * 00782 * @ingroup hiosysplugin 00783 * 00784 */ 00785 void IoShuffleTU( 00786 const Generator& rPlantA, 00787 const Generator& rPlantB, 00788 const EventSet& rYp, 00789 const EventSet& rUp, 00790 const EventSet& rYe, 00791 const EventSet& rUe, 00792 const int Depth, 00793 Generator& rIOShuffAB); 00794 00795 //********************************************************** 00796 //******************** Cycles ************************ 00797 //********************************************************** 00798 00799 /** 00800 * SearchYclessSCC: Search for strongly connected ycless 00801 * components (YC-less SCC's). This function partitions the 00802 * stateset of a generator into equivalent classes such that 00803 * states x1 and x2 are equivalent iff there is a ycless 00804 * path from x1 to x2 and a ycless path from x2 to x1. 00805 * "Trivial" SCC's consisting of one state without non-Yc- 00806 * selfloop are omitted, SCC's consisting exclusively of 00807 * unmarked states are stored in rUnMarkedSccSet; all OTHER 00808 * SCC's are collected in rSccSet. Their roots (i.e. that 00809 * state of each SCC that has been visited first during depth 00810 * first search of the generator) are collected in rRoots. 00811 * This function is built on the algorithm based on a depth 00812 * first search presented in: 00813 * "Aho, Hopcroft, Ullman: 00814 * The Design and Analysis of Computer Algorithms" 00815 * Most of the comments in this function have been literally 00816 * taken from this book! 00817 * An api with generator and Yc-events as input parameters 00818 * and the set of YC-less SCC's as output parameters is 00819 * provided right below this method. 00820 * 00821 * @param state 00822 * State, from which the current recursion is started. 00823 * @param rcount 00824 * Denotes the current depth of the recursion. 00825 * @param rGen 00826 * investigated generator 00827 * @param rYc 00828 * alphabet Yc 00829 * @param UnMarkedOnly 00830 * if set true, being unmarked is an additional condition for equivalence of states 00831 * @param rNewStates 00832 * Set of states that up to now were not found by the 00833 * depth first search. 00834 * @param rSTACK 00835 * Stack of state indeces. 00836 * @param rStackStates 00837 * Set of states whose indeces are on STACK. 00838 * @param rDFN 00839 * Map assigning to each state idx its Depth-First Number. 00840 * @param rLOWLINK 00841 * Map assigning to each state its LOWLINK Number. 00842 * @param rSccSet 00843 * Set of YC-less strongly connected components (result). 00844 * @param rRoots 00845 * Set of states that each are root of some SCC (result). 00846 * 00847 * @exception Exception 00848 * - todo... 00849 * 00850 * @ingroup hiosysplugin 00851 * 00852 */ 00853 void SearchYclessScc( 00854 const Idx state, 00855 int& rcount, // why is this a ref? 00856 const Generator& rGen, 00857 const EventSet& rYc, 00858 const bool UnMarkedOnly, 00859 StateSet& rNewStates, 00860 std::stack<Idx>& rSTACK, 00861 StateSet& rStackStates, 00862 std::map<const Idx, int>& rDFN, 00863 std::map<const Idx, int>& rLOWLINK, 00864 std::set<StateSet>& rSccSet, 00865 StateSet& rRoots); 00866 00867 /** 00868 * YclessSCC: Search for strongly connected ycless 00869 * components (YC-less SCC's) - convenience api. See 00870 * SearchYclessSCC() for docu. 00871 * 00872 * @param rGen 00873 * investigated generator 00874 * @param rYc 00875 * alphabet Yc 00876 * @param rSccSet 00877 * Set of YC-less strongly connected components (result). 00878 * @param rRoots 00879 * Set of states that each are root of some SCC (result). 00880 * 00881 * @return 00882 * true if YclessSCC's have been found, false if not. 00883 * 00884 * @exception Exception 00885 * - todo... 00886 * 00887 * @ingroup hiosysplugin 00888 * 00889 */ 00890 bool YclessScc( 00891 const Generator& rGen, 00892 const EventSet& rYc, 00893 std::set<StateSet>& rSccSet, 00894 StateSet& rRoots); 00895 00896 00897 /** 00898 * YclessUnmarkedSCC: Search for strongly connected ycless 00899 * components (YC-less SCC's) consisting of unmarked states only. 00900 * Uses SearchYclessSCC(). 00901 * 00902 * @param rGen 00903 * investigated generator 00904 * @param rYc 00905 * alphabet Yc 00906 * @param rSccSet 00907 * Set of unmarked YC-less strongly connected components (result). 00908 * @param rRoots 00909 * Set of states that each are root of some SCC (result). 00910 * 00911 * @return 00912 * true if unmarked YclessSCC's have been found, false if not. 00913 * 00914 * @exception Exception 00915 * - todo... 00916 * 00917 * @ingroup hiosysplugin 00918 * 00919 */ 00920 bool YclessUnmarkedScc( 00921 const Generator& rGen, 00922 const EventSet& rYc, 00923 std::set<StateSet>& rSccSet, 00924 StateSet& rRoots); 00925 00926 /** 00927 * YclessSCC: Search for strongly connected ycless 00928 * components (YC-less SCC's) - convenience api. See 00929 * SearchYclessSCC() for docu. 00930 * 00931 * @param rGen 00932 * investigated generator 00933 * @param rYc 00934 * alphabet Yc 00935 * @param rSccSet 00936 * Set of YC-less strongly connected components (result). 00937 * 00938 * @return 00939 * true if YclessSCC's have been found, false if not. 00940 * 00941 * @exception Exception 00942 * - todo... 00943 * 00944 * @ingroup hiosysplugin 00945 * 00946 */ 00947 bool YclessSCC( 00948 const Generator& rGen, 00949 const EventSet& rYc, 00950 std::set<StateSet>& rSccSet); 00951 00952 /** 00953 * IsYcLive: This function checks if generator is Yc-live. 00954 * Method: using YclessSCC(), the function checks if no Yc-less 00955 * SCC is found. 00956 * 00957 * @param rGen 00958 * investigated generator 00959 * @param rYc 00960 * alphabet Yc 00961 * 00962 * @return 00963 * true if Generator is YcLive. 00964 * 00965 * @exception Exception 00966 * - todo... 00967 * 00968 * @ingroup hiosysplugin 00969 * 00970 */ 00971 bool IsYcLive( 00972 const Generator& rGen, 00973 const EventSet& rYc); 00974 00975 /** 00976 * WriteStateSets: Write set of StateSet's to console (indeces). 00977 * Useful to output partitions over statesets like e.g. the 00978 * set of strongly connected components. Also serves as 00979 * template for walkthrough through each state of a set of 00980 * statesets. 00981 * 00982 * @param rStateSets 00983 * Reference to set of StateSets (result). 00984 * 00985 * @exception Exception 00986 * - todo? 00987 * 00988 * @ingroup hiosysplugin 00989 * 00990 */ 00991 void WriteStateSets( 00992 const std::set<StateSet>& rStateSets); 00993 00994 /** 00995 * WriteStateSets: Write set of StateSet's to console (symbolic 00996 * state names taken from rGen). 00997 * Useful to output partitions over statesets like e.g. the 00998 * set of strongly connected components. Also serves as 00999 * template for walkthrough through each state of a set of 01000 * statesets. 01001 * 01002 * @param rGen 01003 * Generator holding symbolic state names. 01004 * @param rStateSets 01005 * Reference to set of StateSets (result). 01006 * 01007 * @exception Exception 01008 * - todo? 01009 * 01010 * @ingroup hiosysplugin 01011 * 01012 */ 01013 void WriteStateSets( 01014 const Generator& rGen, 01015 const std::set<StateSet>& rStateSets); 01016 01017 /** 01018 * SCCEntries: figure entry states and entry transitions of 01019 * strongly connected components rSccSet of rGen. Entry 01020 * states are the set of states of the SCC that are initial 01021 * state or direct successor of some state not belonging to 01022 * this SCC (i.e. belonging to a different or no SCC). Entry 01023 * transitions are the set of respective transitions leading 01024 * to an entrystate of some SCC from a state not belonging 01025 * to this SCC. 01026 * 01027 * @param rGen 01028 * generator holding SCC's of rSccSet 01029 * @param rSccSet 01030 * generator holding SCC's of rSccSet 01031 * @param rEntryStates 01032 * reference to set of entry states of all SCC's (result) 01033 * @param rEntryTransSet 01034 * reference to set of entry transitions, sorted by X2 01035 * (result) 01036 * 01037 * @exception Exception 01038 * - todo: if FAUDES_CHECKED: check if elements of rSccSet 01039 * are all subsets of StateSet of rGen. 01040 * 01041 * @ingroup hiosysplugin 01042 * 01043 */ 01044 void SccEntries( 01045 const Generator& rGen, 01046 const std::set<StateSet>& rSccSet, 01047 StateSet& rEntryStates, 01048 TransSetX2EvX1& rEntryTransSet); 01049 01050 /** 01051 * cloneSCC: makes a copy (clone) of strongly connected 01052 * component (rSCC) of the generator and moves all 01053 * transitions leading to some entry state EntryState of 01054 * this SCC to the copy of EntryState. If this is carried 01055 * out for n-1 of all n entry states of the SCC, then, in 01056 * the generator, this one SCC is transformed into n SCC's 01057 * with one unique entry state each. 01058 * The set of SCC's is extended by the clone-SCC. The set of 01059 * entry states is extended by the (unique) entry state of 01060 * the clone-SCC. 01061 * Note: all added states are equivalent to some state in 01062 * the original generator, the behaviour is not changed. 01063 * The basic idea of this algorithm id taken from 01064 * [Jéron,Marchand,Rusu,Tschaen] "Ensuring the conformance 01065 * of reactive discrete-event systems using supervisory 01066 * control" (CDC'03) 01067 * todo: check const parameters 01068 * 01069 * @param rGen 01070 * generator holding SCC's of rSccSet 01071 * @param rScc 01072 * SCC of rGen that is to be cloned // Perk: check if idx of rSccSet is better? 01073 * @param rSccSet 01074 * set of all SCC's of rGen 01075 * @param EntryState 01076 * one of the entry states of this SCC 01077 * @param rEntryStates 01078 * set of entry states of this SCC 01079 * @param rEntryTransSet 01080 * set of respective transitions to the entry states, 01081 * sorted by X2 01082 * 01083 * @exception Exception 01084 * - todo: exceptions, e.g. for rEntryState not subset of 01085 * rEntryStates not subset of rScc not element of rSccSet, 01086 * elements of rSccSet not subset of rGen.States() etc. 01087 * 01088 * @ingroup hiosysplugin 01089 * 01090 */ 01091 01092 void CloneScc( 01093 Generator& rGen, 01094 const StateSet& rScc, 01095 std::set<StateSet>& rSccSet, 01096 const Idx EntryState, 01097 StateSet& rEntryStates, 01098 TransSetX2EvX1& rEntryTransSet); 01099 01100 /** 01101 * CloneUnMarkedSCC: makes a copy (clone) of strongly connected 01102 * unmarked component (rSCC) of rGen. 01103 * 01104 * @ingroup hiosysplugin 01105 */ 01106 01107 void CloneUnMarkedScc( 01108 Generator& rGen, 01109 const StateSet& rScc, 01110 const Idx EntryState, 01111 const StateSet& rEntryStates, 01112 TransSetX2EvX1& rEntryTransSet); 01113 01114 /** 01115 * YcAcyclic: Computes the supremal(?) Yc-acyclic 01116 * sublanguage of L(Gen). Procedure: 01117 * 1) Find Yc-less SCC's with YclessScc(...) 01118 * 2) transform SCC's with n entry states to n SCC's with 01119 * one unique entry state. 01120 * 3) erase transitions leading from a state of some SCC to 01121 * the entry state of this SCC's. 01122 * 4) repeat 1)-3) until no more Yc-less SCC is found, i.e. 01123 * rResGen generates the supremal YcAcyclic sublanguage of 01124 * the language generated by rGen. 01125 * 01126 * @param rGen 01127 * input generator 01128 * @param rYc 01129 * alphabet Yc 01130 * @param rResGen 01131 * generator of supremal YcAcyclic sublanguage 01132 * 01133 * @exception Exception 01134 * - todo: rYc must be subset of rGen.Alphabet() 01135 * 01136 * @ingroup hiosysplugin 01137 * 01138 */ 01139 void YcAcyclic( 01140 const Generator& rGen, 01141 const EventSet& rYc, 01142 Generator& rResGen); 01143 01144 //********************************************************** 01145 //******************** hio synthesis ************************ 01146 //********************************************************** 01147 01148 /** 01149 * ConstrSynth_Beta: compute operator constraint Sp for plant under 01150 * environment constraint Sl such that plant is complete & Yp-live wrt 01151 * both constraints - Beta Version. Plant can be individual or 01152 * composed, ie Plant=Lpe || Le, or Plant=Lpe1 ||io Lpe2 || Lel || Ll, 01153 * ie composition of plant and envconstr, or composition of IoShuffle 01154 * of two plants with environment and envconstr. 01155 * Parameter rLocConstr is optional and may contain environment 01156 * constraints for Lpe1 and Lpe2; rOpConstraint is computed such that 01157 * rLocConstr is met under rOpConstraint. 01158 * More and better docu will follow in future version. 01159 * 01160 * @param rPlant 01161 * model of plant under environment constraint. 01162 * @param rYp 01163 * alphabet YP 01164 * @param rUp 01165 * alphabet UP 01166 * @param rLocConstr 01167 * reference to optional local constraints 01168 * @param rOpConstraint 01169 * reference to operator constraint 01170 * 01171 * @ingroup hiosysplugin 01172 * 01173 */ 01174 void ConstrSynth_Beta( 01175 Generator& rPlant, 01176 const EventSet& rYp, 01177 const EventSet& rUp, 01178 const Generator& rLocConstr, 01179 Generator& rOpConstraint); 01180 01181 /** 01182 * HioSynthUnchecked: I/O controller synthesis procedure, no 01183 * parameter check. Main hio synthesis algorithm suitable for both 01184 * the monolithic and the hierarchical case, see also respective api's 01185 * HioSynth(with parameter check), HioSynthMonolithic and 01186 * HioSynthHierarchical. The result rController realises a solution to 01187 * the I/O controller synthesis problem (S_PE,S_C,S_P,S_E,S_SpecCE). 01188 * 01189 * @param rPlant 01190 * plant model generator: 01191 * - monolithic case: I/O plant to be controlled; 01192 * - hierarchical case: parallel composition of group 01193 * (I/O-shuffle) of n I/O plants S_PEi (or their 01194 * abstractions) with the environment model S_EL for 01195 * this group. 01196 * @param rSpec 01197 * generator of desired behaviour of the external closed 01198 * loop over alphabet SigmaCE. Must be in I/O plant form. 01199 * @param rConstr 01200 * external constraint that may be assumed: 01201 * - monolithic case: composition of constraints S_C and 01202 * S_E 01203 * - hierarchical case: composition of constraints S_C and 01204 * S_L 01205 * @param rLocConstr 01206 * internal constraint that has to be achieved by the I/O 01207 * controller for the closed loop: 01208 * - monolithic case: generator of constraint S_P 01209 * - hierarchical case: parallel composition of 01210 * constraints S_Pi and S_Ei 01211 * @param rYc 01212 * alphabet YC 01213 * @param rUc 01214 * alphabet UC 01215 * @param rYp 01216 * alphabet YP 01217 * @param rUp 01218 * alphabet UP 01219 * @param rYel 01220 * monolithic: alphabet YE, hierarchical: alphabet YL 01221 * @param rUel 01222 * monolithic: alphabet UE, hierarchical: alphabet UL 01223 * @param rController 01224 * reference to I/O controller(result) 01225 * 01226 * @ingroup hiosysplugin 01227 * 01228 */ 01229 void HioSynthUnchecked( 01230 const Generator& rPlant, 01231 const Generator& rSpec, 01232 const Generator& rConstr, 01233 const Generator& rLocConstr, 01234 const EventSet& rYc, 01235 const EventSet& rUc, 01236 const EventSet& rYp, 01237 const EventSet& rUp, 01238 const EventSet& rYel, 01239 const EventSet& rUel, 01240 Generator& rController); 01241 01242 /** 01243 * HioSynthUnchecked: I/O controller synthesis procedure. 01244 * Main hio synthesis algorithm suitable for both 01245 * the monolithic and the hierarchical case, see also respective api's 01246 * HioSynthMonolithic and HioSynthHierarchical. 01247 * The result rController realises a solution to the I/O controller 01248 * synthesis problem (S_PE,S_C,S_P,S_E,S_SpecCE). 01249 * 01250 * @param rPlant 01251 * plant model generator: 01252 * - monolithic case: I/O plant to be controlled; 01253 * - hierarchical case: parallel composition of group 01254 * (I/O-shuffle) of n I/O plants S_PEi (or their 01255 * abstractions) with the environment model S_EL for 01256 * this group. 01257 * @param rSpec 01258 * generator of desired behaviour of the external closed 01259 * loop. Must be in I/O plant form. 01260 * @param rConstr 01261 * external constraint that may be assumed: 01262 * - monolithic case: composition of constraints S_C and 01263 * S_E 01264 * - hierarchical case: composition of constraints S_C and 01265 * S_L 01266 * @param rLocConstr 01267 * internal constraint that has to be achieved by the I/O 01268 * controller for the closed loop: 01269 * - monolithic case: generator of constraint S_P 01270 * - hierarchical case: parallel composition of 01271 * constraints S_Pi and S_Ei 01272 * @param rYc 01273 * alphabet YC 01274 * @param rUc 01275 * alphabet UC 01276 * @param rYp 01277 * alphabet YP 01278 * @param rUp 01279 * alphabet UP 01280 * @param rYel 01281 * monolithic: alphabet YE, hierarchical: alphabet YL 01282 * @param rUel 01283 * monolithic: alphabet UE, hierarchical: alphabet UL 01284 * @param rController 01285 * reference to I/O controller(result) 01286 * 01287 * @exception Exception 01288 * - empty or non-disjoint alphabets rYc, rUc, rYp, rUp, rYel, rUel (id 0). 01289 * - rSpec not in IoPlantForm (id 0). 01290 * - alphabet mismatch between plant or constraints and spec (id 0). 01291 * 01292 * @ingroup hiosysplugin 01293 * 01294 */ 01295 void HioSynth( 01296 const Generator& rPlant, 01297 const Generator& rSpec, 01298 const Generator& rConstr, 01299 const Generator& rLocConstr, 01300 const EventSet& rYc, 01301 const EventSet& rUc, 01302 const EventSet& rYp, 01303 const EventSet& rUp, 01304 const EventSet& rYel, 01305 const EventSet& rUel, 01306 Generator& rController); 01307 01308 /** 01309 * HioSynthMonolithic: I/O controller synthesis procedure for 01310 * monolithic plant. The result rController realises a solution to 01311 * the I/O controller synthesis problem (S_PE,S_C,S_P,S_E,S_SpecCE). 01312 * 01313 * @param rPlant 01314 * I/O plant to be controlled; must be in I/O plant form (tested if 01315 * FAUDES_CHECKED); must be complete and Yp-live wrt. Sp and 01316 * Se (not tested). 01317 * @param rSpec 01318 * I/O plant model of desired behaviour of the external closed 01319 * loop. Must be in I/O plant form (tested if FAUDES_CHECKED); 01320 * must be complete and Yp-live wrt. Sc and Se (not tested). 01321 * @param rSc 01322 * external operator constraint that may be assumed; I/O constraint form 01323 * is recommended. 01324 * @param rSp 01325 * operator constraint for rPlant; is met by admissibility of rController; 01326 * I/O constraint form is recommended. 01327 * @param rSe 01328 * environment constraint that may be assumed; I/O constraint form 01329 * is recommended. 01330 * @param rController 01331 * I/O controller solving the I/O controller synthesis problem (result) 01332 * 01333 * @exception Exception 01334 * - plant or spec not in IoPlantForm (id 0). 01335 * - alphabet mismatch between plant or constraints and spec (id 0). 01336 * 01337 * @ingroup hiosysplugin 01338 * 01339 */ 01340 void HioSynthMonolithic( 01341 const HioPlant& rPlant, 01342 const HioPlant& rSpec, 01343 const HioConstraint& rSc, 01344 const HioConstraint& rSp, 01345 const HioConstraint& rSe, 01346 HioController& rController); 01347 01348 /** 01349 * HioSynthHierarchical: I/O controller synthesis procedure for 01350 * I/O-shuffle of i plants and their interaction via an I/O environment. 01351 * The result rController realises a solution to the I/O controller 01352 * synthesis problem (S_PE,S_C,S_P,S_E,S_SpecCE) with the external 01353 * behaviour S_PE of the I/Oshuffle-environment-composition and respects 01354 * internal constraints Sp_i and Se_i preserving liveness of the 01355 * individual plants. 01356 * 01357 * @param rIoShuffle 01358 * I/O plant or group of I/O plants composed by I/O shuffle 01359 * @param rEnvironment 01360 * environment model for rIoShuffle 01361 * @param rSpec 01362 * I/O plant model of desired behaviour of the external closed 01363 * loop. Must be in I/O plant form (tested if FAUDES_CHECKED); 01364 * must be complete and Yp-live wrt. Sc and Se (not tested). 01365 * @param rIntConstr 01366 * parallel composition of constraints Sp_i and Se_i of the 01367 * individual plants composed to rIoShuffle 01368 * @param rSc 01369 * external operator constraint that may be assumed; I/O constraint form 01370 * is recommended. 01371 * @param rSl 01372 * environment constraint that may be assumed; I/O constraint form 01373 * is recommended. 01374 * @param rController 01375 * I/O controller solving the I/O controller synthesis problem (result) 01376 * 01377 * @exception Exception 01378 * - IoShuffle or spec not in IoPlantForm (id 0). 01379 * - Environment not in IoEnvironmentForm (id 0). 01380 * - alphabet mismatch between plant, environment, spec and constraints (id 0). 01381 * 01382 * @ingroup hiosysplugin 01383 * 01384 */ 01385 void HioSynthHierarchical( 01386 const HioPlant& rIoShuffle, 01387 const HioEnvironment& rEnvironment, 01388 const HioPlant& rSpec, 01389 const Generator& rIntConstr, 01390 const HioConstraint& rSc, 01391 const HioConstraint& rSl, 01392 HioController& rController); 01393 01394 //##################################### 01395 // #### end of hio_functions - below just archive ######## 01396 //##################################### 01397 01398 //IoShuffle_Musunoi() - special version for IoModule. Will be changed to std IoShuffle. 01399 void IoShuffle_Musunoi( 01400 const HioPlant& rPlantA, 01401 const HioPlant& rPlantB, 01402 int depth, 01403 Generator& rIOShuffAB) ; 01404 01405 //HioSynth_Musunoi() - special version for IoModule. Will be changed to std HioSynth. 01406 void HioSynth_Musunoi( 01407 const Generator& rPlant, 01408 const HioPlant& rSpec, 01409 const Generator& rConstr, 01410 const Generator& rLocConstr, 01411 const EventSet& rYp, 01412 const EventSet& rUp, 01413 Generator& rController); 01414 } 01415 01416 01417 #endif |
libFAUDES 2.14g --- 2009-12-3 --- c++ source docu by doxygen 1.5.6