libFAUDES

Sections

Index

hio_functions.h

Go 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