00001
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032 #include "op_observercomputation.h"
00033
00034 namespace faudes{
00035
00036
00037 void calcAbstAlphObs(cGenerator& rGenObs, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx,set<Idx > > & rMapRelabeledEvents) {
00038 OP_DF("calcAbstAlphObs(" << rGenObs.Name() << "," << "rHighAlph, rNewHighAlph, rMapRelabeledEvents)");
00039
00040
00041 EventSet cntrevs = rGenObs.ControllableEvents();
00042 calcAbstAlphObs(rGenObs, cntrevs , rHighAlph, rNewHighAlph, rMapRelabeledEvents);
00043
00044 rGenObs.SetControllable(cntrevs);
00045 }
00046
00047
00048 void calcAbstAlphObs(vGenerator& rGenObs, EventSet& rControllableEvents, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx,set<Idx > > & rMapRelabeledEvents) {
00049 OP_DF("calcAbstAlphObs(" << rGenObs.Name() << "," << "rControllableEvents, rHighAlph, rNewHighAlph, rMapRelabeledEvents)");
00050
00051 map<Transition,Idx> changedtrans;
00052 calcAbstAlphObs(rGenObs, rControllableEvents, rHighAlph, rNewHighAlph, changedtrans);
00053
00054
00055 map<Transition,Idx>::iterator rtEndIt = changedtrans.end();
00056 map<Transition,Idx>::iterator rtIt = changedtrans.begin();
00057 for(; rtIt != rtEndIt; rtIt++){
00058 if(rMapRelabeledEvents.find(rtIt->first.Ev) == rMapRelabeledEvents.end() ){
00059 rMapRelabeledEvents[rtIt->first.Ev] = set<Idx>();
00060 if(rGenObs.Alphabet().Exists(rtIt->second) )
00061 rMapRelabeledEvents[rtIt->first.Ev].insert(rtIt->second);
00062 }
00063 else {
00064 if(rGenObs.Alphabet().Exists(rtIt->second) )
00065 rMapRelabeledEvents[rtIt->first.Ev].insert(rtIt->second);
00066 }
00067 }
00068 }
00069
00070
00071 void calcAbstAlphObs(vGenerator& rGenObs, EventSet& rControllableEvents, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Transition,Idx>& rMapChangedTrans)
00072 {
00073 OP_DF("calcAbstAlphObs(" << rGenObs.Name() << ", rControllableEvents, rHighAlph, rNewHighAlph, rMapChangedTRans)");
00074
00075 rNewHighAlph = rHighAlph;
00076 rMapChangedTrans.clear();
00077 Generator genDyn(rGenObs);
00078 map<Transition,Transition> mapChangedTransReverse;
00079 vector<Idx> newPartitions;
00080 map<Idx,Idx> mapStateToPartition;
00081 map<Idx, EventSet> mapRelabeledEvents;
00082 bool done=false;
00083 #ifdef DF_PLOT
00084 Idx iterationCount=1;
00085 string name;
00086 #endif
00087
00088
00089
00090 while(done==false)
00091 {
00092
00093 calculateDynamicSystemObs(rGenObs, rNewHighAlph, genDyn);
00094 #ifdef DF_PLOT
00095 name = ("./Automata/Plots/" + rGenObs.Name() + "DynamicSystem_" + ToString(iterationCount));
00096 genDyn.DotWrite(name);
00097 #endif
00098
00099 Generator genPart;
00100 mapStateToPartition.clear();
00101 newPartitions.clear();
00102
00103
00104 calcBisimulation(genDyn, mapStateToPartition, genPart, newPartitions);
00105 #ifdef DF_PLOT
00106 name = ("./Automata/Plots/" + rGenObs.Name() + "Bisimulation_" + ToString(iterationCount));
00107 genPart.DotWrite(name);
00108 ++iterationCount;
00109 #endif
00110
00111
00112
00113 done=relabel(rGenObs, rControllableEvents, rNewHighAlph, newPartitions, mapStateToPartition, mapChangedTransReverse, rMapChangedTrans, mapRelabeledEvents);
00114 }
00115 }
00116
00117
00118 void calculateDynamicSystemObs(const vGenerator& rGen, EventSet& rHighAlph, vGenerator& rGenDyn)
00119 {
00120 OP_DF("calculateDynamicSystemObs(" << rGen.Name() << "," << rHighAlph.Name() << "," << rGenDyn.Name() << ")");
00121
00122 TransSetX2EvX1 tset_X2EvX1;
00123 rGen.TransRel(tset_X2EvX1);
00124
00125
00126 rGenDyn.ClearTransRel();
00127 rGenDyn.InjectAlphabet(rHighAlph);
00128
00129
00130 EventSet::Iterator eIt = rGenDyn.AlphabetBegin();
00131 EventSet::Iterator eItEnd = rGenDyn.AlphabetEnd();
00132
00133 TransSetX2EvX1::Iterator tItByX2Ev;
00134 TransSetX2EvX1::Iterator tItByX2EvEnd;
00135 StateSet reach;
00136 StateSet::Iterator sIt;
00137 StateSet::Iterator sItEnd;
00138 TransSet::Iterator tIt;
00139 TransSet::Iterator tItEnd;
00140 map<Idx,StateSet> entryStateToLocalReach;
00141 set<Idx>::iterator esIt, esItEnd;
00142
00143 map<Idx,vector<pair<Idx,Idx> > > stateToEntryState;
00144 map<Idx,vector<pair<Idx,Idx> > >::iterator stesIt;
00145 map<Idx,vector<pair<Idx,Idx> > >::iterator stesItEnd;
00146
00147 std::string eventname = ( rGenDyn.EventSymbolTablep())->UniqueSymbol("mLabel_1");
00148 Idx mLabel = (rGenDyn.EventSymbolTablep())->InsEntry(eventname);
00149
00150
00151
00152
00153 StateSet::Iterator stateSetIt = rGen.StatesBegin();
00154 StateSet::Iterator stateSetItEnd = rGen.StatesEnd();
00155 for( ; stateSetIt != stateSetItEnd; ++stateSetIt) {
00156 OP_DF("calculateDynamicSystemObs: loop over all states; current state: " << rGen.StateName(*stateSetIt)
00157 << " [" << *stateSetIt << "]");
00158
00159
00160 reach.Clear();
00161 LocalAccessibleReach(rGen, rHighAlph, *stateSetIt, reach);
00162 OP_DF("calculateDynamicSystemObs: states in local reach: \n " << reach.ToString() );
00163
00164
00165
00166
00167 tItByX2Ev=tset_X2EvX1.BeginByX2(*stateSetIt);
00168 tItByX2EvEnd=tset_X2EvX1.EndByX2(*stateSetIt);
00169 for(; tItByX2Ev != tItByX2EvEnd; ++tItByX2Ev)
00170 {
00171 OP_DF("calculateDynamicSystemObs: checking transition : " << rGen.TStr(*tItByX2Ev));
00172 if(rHighAlph.Exists(tItByX2Ev->Ev)){
00173 OP_DF("calculateDynamicSystemObs: current state is an entry-state");
00174
00175 entryStateToLocalReach[*stateSetIt]=reach;
00176 break;
00177 }
00178 }
00179 vector<pair<Idx,Idx> > emptyVector;
00180 stateToEntryState[*stateSetIt]=emptyVector;
00181
00182
00183 sIt=reach.Begin();
00184 sItEnd=reach.End();
00185 for( ; sIt != sItEnd; ++sIt)
00186 {
00187
00188 if(rGen.ExistsMarkedState(*sIt))
00189 {
00190 OP_DF("calculateDynamicSystemObs: marked state " << rGen.SStr(*sIt)
00191 << " is locally reachable from current state");
00192 rGenDyn.InsEvent(mLabel);
00193 rGenDyn.InsState(*stateSetIt);
00194 rGenDyn.InsState(*sIt);
00195 rGenDyn.SetTransition(*stateSetIt, mLabel, *sIt);
00196 }
00197
00198 tIt = rGen.TransRelBegin(*sIt);
00199 tItEnd = rGen.TransRelEnd(*sIt);
00200 for(; tIt != tItEnd; ++tIt)
00201 {
00202 OP_DF("calculateDynamicSystemObs: Loop over all states in reach; checking transition: "
00203 << rGen.TStr(*tIt));
00204 if(rHighAlph.Exists(tIt->Ev))
00205 {
00206 OP_DF("calculateDynamicSystemObs: state " << rGen.SStr(tIt->X2) <<
00207 " is an entry state and can be reached from current state" << rGen.SStr(*stateSetIt) << " by event " << rGen.EventName(tIt->Ev));
00208 pair<Idx,Idx> newPair;
00209 newPair.first=tIt->X2;
00210 newPair.second=tIt->Ev;
00211
00212 stateToEntryState[*stateSetIt].push_back(newPair);
00213 }
00214 }
00215 }
00216 }
00217
00218
00219 stesIt = stateToEntryState.begin();
00220 stesItEnd = stateToEntryState.end();
00221 vector<pair <Idx,Idx> >* pPairs;
00222 vector<pair <Idx,Idx> >::iterator vIt;
00223 vector<pair <Idx,Idx> >::iterator vItEnd;
00224
00225
00226
00227
00228 for(; stesIt != stesItEnd; ++stesIt)
00229 {
00230 pPairs=&(stesIt->second);
00231 vIt = (*pPairs).begin();
00232 vItEnd = (*pPairs).end();
00233
00234 for( ; vIt != vItEnd; ++vIt)
00235 {
00236
00237 if(!((rGenDyn.TransRel()).Exists(stesIt->first,vIt->second,vIt->first)))
00238 {
00239
00240 StateSet* pLocalReach = &((entryStateToLocalReach.find(vIt->first))->second);
00241
00242
00243 StateSet::Iterator lrsIt = pLocalReach->Begin();
00244 StateSet::Iterator lrsItEnd = pLocalReach->End();
00245 for(; lrsIt != lrsItEnd; ++lrsIt)
00246 {
00247 rGenDyn.InsEvent(vIt->second);
00248 rGenDyn.InsState(stesIt->first);
00249 rGenDyn.InsState(*lrsIt);
00250 rGenDyn.SetTransition(stesIt->first,vIt->second,*lrsIt);
00251 OP_DF("calculateDynamicSystemObs: Transition added to resulting generator: " <<
00252 rGenDyn.TStr(Transition(stesIt->first,vIt->second,*lrsIt)));
00253 }
00254 }
00255 }
00256 }
00257 OP_DF("calculateDynamicSystemObs: leaving function");
00258 }
00259
00260
00261 void calcAbstAlphObsOCC(cGenerator& rGenObs, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx,set<Idx > > & rMapRelabeledEvents){
00262 OP_DF("calcAbstAlphObsOCC(" << rGenObs.Name() << "," << "rHighAlph, rNewHighAlph, rMapRelabeledEvents)");
00263
00264
00265 map<Transition,Idx> changedtrans;
00266 EventSet rControllableEvents = rGenObs.ControllableEvents();
00267
00268 calcAbstAlphObsOCC(rGenObs, rControllableEvents, rHighAlph, rNewHighAlph, changedtrans);
00269
00270
00271 map<Transition,Idx>::iterator rtEndIt = changedtrans.end();
00272 map<Transition,Idx>::iterator rtIt = changedtrans.begin();
00273 for(; rtIt != rtEndIt; rtIt++){
00274 if(rMapRelabeledEvents.find(rtIt->first.Ev) == rMapRelabeledEvents.end() ){
00275 rMapRelabeledEvents[rtIt->first.Ev] = set<Idx>();
00276 if(rGenObs.Alphabet().Exists(rtIt->second) )
00277 rMapRelabeledEvents[rtIt->first.Ev].insert(rtIt->second);
00278 } else {
00279 if(rGenObs.Alphabet().Exists(rtIt->second) )
00280 rMapRelabeledEvents[rtIt->first.Ev].insert(rtIt->second);
00281 }
00282 }
00283
00284 rGenObs.SetControllable(rControllableEvents);
00285 }
00286
00287
00288 void calcAbstAlphObsOCC(vGenerator& rGenObs, EventSet& rControllableEvents, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Transition,Idx>& rMapChangedTrans)
00289 {
00290 OP_DF("calcAbstAlphObsOCC(" << rGenObs.Name() << ", rControllableEvents, rHighAlph, rNewHighAlph, rMapChangedTRans)");
00291
00292 rNewHighAlph = rHighAlph;
00293 rMapChangedTrans.clear();
00294 Generator genDyn(rGenObs);
00295 map<Transition,Transition> mapChangedTransReverse;
00296 vector<Idx> newPartitions;
00297 map<Idx,Idx> mapStateToPartition;
00298 map<Idx, EventSet> mapRelabeledEvents;
00299 bool done=false;
00300 #ifdef DF_PLOT
00301 Idx iterationCount=1;
00302 string name;
00303 #endif
00304
00305
00306
00307
00308 while(done==false)
00309 {
00310
00311 calculateDynamicSystemObsOCC(rGenObs, rControllableEvents, rNewHighAlph, genDyn);
00312 #ifdef DF_PLOT
00313 name = ("./Automata/Plots/" + rGenObs.Name() + "DynamicSystem_" + ToString(iterationCount));
00314 genDyn.DotWrite(name);
00315 #endif
00316
00317 Generator genPart;
00318 mapStateToPartition.clear();
00319 newPartitions.clear();
00320
00321 calcBisimulation(genDyn, mapStateToPartition, genPart, newPartitions);
00322 #ifdef DF_PLOT
00323 name = ("./Automata/Plots/" + rGenObs.Name() + "Bisimulation_" + ToString(iterationCount));
00324 genPart.DotWrite(name);
00325 ++iterationCount;
00326 #endif
00327
00328
00329
00330 done=relabel(rGenObs, rControllableEvents, rNewHighAlph, newPartitions, mapStateToPartition, mapChangedTransReverse, rMapChangedTrans, mapRelabeledEvents);
00331 }
00332 }
00333
00334
00335 void calculateDynamicSystemObsOCC(const vGenerator& rGen, EventSet& rControllableEvents, EventSet& rHighAlph, vGenerator& rGenDyn){
00336 OP_DF("calculateDynamicSystemObsOCC(" << rGen.Name() << "," << rControllableEvents.Name() << "," << rHighAlph.Name() << "," << rGenDyn.Name() << ")");
00337
00338 TransSetX2EvX1 tset_X2EvX1;
00339 rGen.TransRel(tset_X2EvX1);
00340
00341
00342 rGenDyn.ClearTransRel();
00343 rGenDyn.InjectAlphabet(rHighAlph);
00344
00345 std::string eventname = ( rGenDyn.EventSymbolTablep())->UniqueSymbol("cLabel_1");
00346 Idx cLabel = (rGenDyn.EventSymbolTablep())->InsEntry(eventname);
00347 eventname = ( rGenDyn.EventSymbolTablep())->UniqueSymbol("mLabel_1");
00348 Idx mLabel = (rGenDyn.EventSymbolTablep())->InsEntry(eventname);
00349 rGenDyn.InsEvent(cLabel);
00350 rGenDyn.InsEvent(mLabel);
00351 rGenDyn.InjectInitStates(rGen.InitStates() );
00352 rGenDyn.InjectStates(rGen.States() );
00353 rGenDyn.InjectMarkedStates(rGen.MarkedStates() );
00354
00355
00356 map<Idx, map<Idx, bool> > exitLocalStatesMap;
00357 map<Idx, StateSet> entryLocalStatesMap;
00358 StateSet::Iterator stIt, stEndIt;
00359 stIt = rGen.StatesBegin();
00360 stEndIt = rGen.StatesEnd();
00361 TransSet::Iterator tsIt, tsEndIt;
00362 bool isExitState;
00363
00364 for(; stIt != stEndIt; stIt++){
00365 OP_DF("calculateDynamicSystemObsOCC: loop over all states; current state: " << rGen.StateName(*stIt)
00366 << " [" << *stIt << "]");
00367
00368
00369 forwardReachabilityObs(rGen, rHighAlph, *stIt, mLabel, rGenDyn);
00370
00371
00372
00373
00374 tsIt = rGen.TransRelBegin(*stIt);
00375 tsEndIt = rGen.TransRelEnd(*stIt);
00376 isExitState = false;
00377 for( ; tsIt != tsEndIt; tsIt++){
00378 if(rHighAlph.Exists(tsIt->Ev) ){
00379 OP_DF("calculateDynamicSystemObsOCC: current state is an exit-state");
00380 isExitState = true;
00381
00382
00383 if( entryLocalStatesMap.find(tsIt->X2) == entryLocalStatesMap.end() ){
00384 entryLocalStatesMap[tsIt->X2] = StateSet();
00385 LocalAccessibleReach(rGen,rHighAlph, tsIt->X2, entryLocalStatesMap[tsIt->X2]);
00386 }
00387 }
00388 }
00389
00390
00391 if(isExitState == true){
00392 StateSet doneStates;
00393 exitLocalStatesMap[*stIt][*stIt] = false;
00394 doneStates.Insert(*stIt);
00395 backwardReachabilityObsOCC(tset_X2EvX1, rControllableEvents, rHighAlph, *stIt, *stIt, false, exitLocalStatesMap, doneStates);
00396
00397 }
00398
00399 }
00400
00401 map<Idx, map<Idx, bool> >::const_iterator elIt, elEndIt;
00402 elIt = exitLocalStatesMap.begin();
00403 elEndIt = exitLocalStatesMap.end();
00404 map<Idx,bool>::const_iterator lcIt, lcEndIt;
00405 StateSet::Iterator exIt, exEndIt;
00406 map<Idx,StateSet>::const_iterator enIt;
00407
00408 for( ; elIt != elEndIt; elIt++){
00409 lcEndIt = elIt->second.end();
00410
00411 tsIt = rGen.TransRel().Begin(elIt->first);
00412 tsEndIt = rGen.TransRel().End(elIt->first);
00413 for( ; tsIt != tsEndIt; tsIt++){
00414 OP_DF("calculateDynamicSystemObsOCC: insert transitions for the high-level event" << rGen.EventName(tsIt->Ev) << "[" << tsIt->Ev << "]");
00415 if(rHighAlph.Exists(tsIt->Ev) ){
00416 bool controllable = rControllableEvents.Exists(tsIt->Ev);
00417 enIt = entryLocalStatesMap.find(tsIt->X2);
00418 stEndIt = enIt->second.End();
00419
00420 for(lcIt = elIt->second.begin(); lcIt != lcEndIt; lcIt ++){
00421
00422 for( stIt = enIt->second.Begin(); stIt != stEndIt; stIt++){
00423 OP_DF("calculateDynamicSystemObsOCC: Transition added to resulting generator: " <<
00424 rGenDyn.TStr(Transition(lcIt->first,tsIt->Ev,*stIt)));
00425
00426 rGenDyn.SetTransition(lcIt->first,tsIt->Ev,*stIt);
00427 if( controllable || lcIt->second ){
00428 OP_DF("calculateDynamicSystemObsOCC: cLabel-Transition added to resulting generator: " <<
00429 rGenDyn.TStr(Transition(lcIt->first,cLabel,*stIt)));
00430
00431 rGenDyn.SetTransition(lcIt->first,cLabel,*stIt);
00432 }
00433 }
00434 }
00435 }
00436 }
00437 }
00438 }
00439
00440
00441 void forwardReachabilityObs(const vGenerator& rGen, const EventSet& rHighAlph, Idx lowState, Idx mLabel, vGenerator& rGenDyn) {
00442 OP_DF("forwardReachabilityObs(" << rGen.Name() << "," << rHighAlph.Name() << "," << lowState << "," << rGenDyn.EventName(mLabel) << "," << rGenDyn.Name() << ")");
00443
00444
00445 TransSet::Iterator tIt;
00446 TransSet::Iterator tEndIt;
00447
00448 std::stack<Idx> todo;
00449
00450
00451
00452 todo.push(lowState);
00453 StateSet doneStates;
00454
00455 if(rGen.MarkedStates().Exists(lowState) ){
00456 OP_DF("forwardReachabilityObs: Transition with mLabel added to resulting generator: " <<
00457 rGenDyn.TStr(Transition(lowState,mLabel,lowState)));
00458 rGenDyn.SetTransition(lowState, mLabel, lowState);
00459 }
00460
00461 doneStates.Insert(lowState);
00462
00463 while (! todo.empty()) {
00464 const Idx current = todo.top();
00465 todo.pop();
00466 tIt = rGen.TransRelBegin(current);
00467 tEndIt = rGen.TransRelEnd(current);
00468 for (; tIt != tEndIt; ++tIt) {
00469
00470 if (rHighAlph.Exists(tIt->Ev)) {
00471 continue;
00472 }
00473
00474 else if (! doneStates.Exists(tIt->X2)) {
00475 todo.push(tIt->X2);
00476 if(rGen.MarkedStates().Exists(tIt->X2) ){
00477 OP_DF("forwardReachabilityObs: Transition with mLabel added to resulting generator: " <<
00478 rGenDyn.TStr(Transition(lowState,mLabel,tIt->X2)));
00479 rGenDyn.SetTransition(lowState, mLabel, tIt->X2);
00480 }
00481 doneStates.Insert(tIt->X2);
00482 }
00483 }
00484 }
00485 }
00486
00487
00488 void backwardReachabilityObsOCC(const TransSetX2EvX1& rTransSetX2EvX1, const EventSet& rControllableEvents, const EventSet& rHighAlph, Idx exitState, Idx currentState, bool controllablePath, map<Idx, map<Idx, bool> >& rExitLocalStatesMap, StateSet& rDoneStates){
00489 OP_DF("backwardReachabilityObsOCC(rTransSetX2EvX1," << rControllableEvents.Name() << "," << rHighAlph.Name() << "," << exitState << "," << currentState << "," << controllablePath << ",rExitLocalStatesMap, rDoneStates)");
00490
00491
00492
00493
00494 TransSetX2EvX1::Iterator tsIt, tsEndIt;
00495 tsIt = rTransSetX2EvX1.BeginByX2(currentState);
00496 tsEndIt = rTransSetX2EvX1.EndByX2(currentState);
00497 bool currentControllablePath;
00498
00499 for( ;tsIt != tsEndIt; tsIt++){
00500
00501 if( !rHighAlph.Exists(tsIt->Ev) && tsIt->X1 != exitState){
00502
00503 if( !rDoneStates.Exists(tsIt->X1) ){
00504 rDoneStates.Insert(tsIt->X1);
00505
00506 currentControllablePath = rControllableEvents.Exists(tsIt->Ev) || controllablePath;
00507 rExitLocalStatesMap[exitState][tsIt->X1] = currentControllablePath;
00508
00509 backwardReachabilityObsOCC(rTransSetX2EvX1, rControllableEvents, rHighAlph, exitState, tsIt->X1, currentControllablePath, rExitLocalStatesMap, rDoneStates);
00510 }
00511 else{
00512
00513
00514
00515 currentControllablePath = rControllableEvents.Exists(tsIt->Ev) || controllablePath;
00516 if(rExitLocalStatesMap[exitState][tsIt->X1] != currentControllablePath && currentControllablePath == true){
00517 rExitLocalStatesMap[exitState][tsIt->X1] = true;
00518
00519 backwardReachabilityObsOCC(rTransSetX2EvX1, rControllableEvents, rHighAlph, exitState, tsIt->X1, true, rExitLocalStatesMap, rDoneStates);
00520 }
00521 }
00522 }
00523 }
00524 }
00525
00526
00527 void calcAbstAlphObsLCC(cGenerator& rGenObs, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Idx,set<Idx > > & rMapRelabeledEvents){
00528 OP_DF("calcAbstAlphObsLCC(" << rGenObs.Name() << "," << "rHighAlph, rNewHighAlph, rMapRelabeledEvents)");
00529
00530
00531 map<Transition,Idx> changedtrans;
00532 EventSet rControllableEvents = rGenObs.ControllableEvents();
00533
00534 calcAbstAlphObsLCC(rGenObs, rControllableEvents, rHighAlph, rNewHighAlph, changedtrans);
00535
00536
00537 map<Transition,Idx>::iterator rtEndIt = changedtrans.end();
00538 map<Transition,Idx>::iterator rtIt = changedtrans.begin();
00539 for(; rtIt != rtEndIt; rtIt++){
00540 if(rMapRelabeledEvents.find(rtIt->first.Ev) == rMapRelabeledEvents.end() ){
00541 rMapRelabeledEvents[rtIt->first.Ev] = set<Idx>();
00542 if(rGenObs.Alphabet().Exists(rtIt->second) )
00543 rMapRelabeledEvents[rtIt->first.Ev].insert(rtIt->second);
00544 } else {
00545 if(rGenObs.Alphabet().Exists(rtIt->second) )
00546 rMapRelabeledEvents[rtIt->first.Ev].insert(rtIt->second);
00547 }
00548 }
00549
00550 rGenObs.SetControllable(rControllableEvents);
00551 }
00552
00553
00554 void calcAbstAlphObsLCC(vGenerator& rGenObs, EventSet& rControllableEvents, EventSet& rHighAlph, EventSet& rNewHighAlph, map<Transition,Idx>& rMapChangedTrans)
00555 {
00556 OP_DF("calcAbstAlphObsLCC(" << rGenObs.Name() << ", rControllableEvents, rHighAlph, rNewHighAlph, rMapChangedTRans)");
00557
00558 rNewHighAlph = rHighAlph;
00559 rMapChangedTrans.clear();
00560 Generator genDyn(rGenObs);
00561 map<Transition,Transition> mapChangedTransReverse;
00562 vector<Idx> newPartitions;
00563 map<Idx,Idx> mapStateToPartition;
00564 map<Idx, EventSet> mapRelabeledEvents;
00565 bool done=false;
00566 #ifdef DF_PLOT
00567 Idx iterationCount=1;
00568 string name;
00569 #endif
00570
00571
00572
00573
00574 while(done==false)
00575 {
00576
00577 calculateDynamicSystemObsLCC(rGenObs, rControllableEvents, rNewHighAlph, genDyn);
00578 #ifdef DF_PLOT
00579 name = ("./Automata/Plots/" + rGenObs.Name() + "DynamicSystem_" + ToString(iterationCount));
00580 genDyn.DotWrite(name);
00581 #endif
00582
00583 Generator genPart;
00584 mapStateToPartition.clear();
00585 newPartitions.clear();
00586
00587 calcBisimulation(genDyn, mapStateToPartition, genPart, newPartitions);
00588 #ifdef DF_PLOT
00589 name = ("./Automata/Plots/" + rGenObs.Name() + "Bisimulation_" + ToString(iterationCount));
00590 genPart.DotWrite(name);
00591 ++iterationCount;
00592 #endif
00593
00594
00595
00596 done=relabel(rGenObs, rControllableEvents, rNewHighAlph, newPartitions, mapStateToPartition, mapChangedTransReverse, rMapChangedTrans, mapRelabeledEvents);
00597 }
00598 }
00599
00600
00601 void calculateDynamicSystemObsLCC(const vGenerator& rGen, EventSet& rControllableEvents, EventSet& rHighAlph, vGenerator& rGenDyn){
00602 OP_DF("calculateDynamicSystemObsLCC(" << rGen.Name() << "," << rControllableEvents.Name() << "," << rHighAlph.Name() << "," << rGenDyn.Name() << ")");
00603
00604 TransSetX2EvX1 tset_X2EvX1;
00605 rGen.TransRel(tset_X2EvX1);
00606
00607
00608 rGenDyn.ClearTransRel();
00609 rGenDyn.InjectAlphabet(rHighAlph);
00610 std::string eventname = ( rGenDyn.EventSymbolTablep())->UniqueSymbol("ucLabel_1");
00611 Idx ucLabel = (rGenDyn.EventSymbolTablep())->InsEntry(eventname);
00612 eventname = ( rGenDyn.EventSymbolTablep())->UniqueSymbol("mLabel_1");
00613 Idx mLabel = (rGenDyn.EventSymbolTablep())->InsEntry(eventname);
00614 rGenDyn.InsEvent(ucLabel);
00615 rGenDyn.InsEvent(mLabel);
00616 rGenDyn.InjectInitStates(rGen.InitStates() );
00617 rGenDyn.InjectStates(rGen.States() );
00618 rGenDyn.InjectMarkedStates(rGen.MarkedStates() );
00619
00620
00621 map<Idx, map<Idx, bool> > exitLocalStatesMap;
00622 map<Idx, StateSet> entryLocalStatesMap;
00623 StateSet::Iterator stIt, stEndIt;
00624 stIt = rGen.StatesBegin();
00625 stEndIt = rGen.StatesEnd();
00626 TransSet::Iterator tsIt, tsEndIt;
00627 bool isExitState;
00628
00629 for(; stIt != stEndIt; stIt++){
00630 OP_DF("calculateDynamicSystemObsLCC: loop over all states; current state: " << rGen.StateName(*stIt)
00631 << " [" << *stIt << "]");
00632
00633
00634 forwardReachabilityObs(rGen, rHighAlph, *stIt, mLabel, rGenDyn);
00635
00636
00637
00638
00639 tsIt = rGen.TransRelBegin(*stIt);
00640 tsEndIt = rGen.TransRelEnd(*stIt);
00641 isExitState = false;
00642 for( ; tsIt != tsEndIt; tsIt++){
00643 if(rHighAlph.Exists(tsIt->Ev) ){
00644 OP_DF("calculateDynamicSystemObsLCC: current state is an exit-state");
00645 isExitState = true;
00646
00647
00648 if( entryLocalStatesMap.find(tsIt->X2) == entryLocalStatesMap.end() ){
00649 entryLocalStatesMap[tsIt->X2] = StateSet();
00650 LocalAccessibleReach(rGen,rHighAlph, tsIt->X2, entryLocalStatesMap[tsIt->X2]);
00651 }
00652 }
00653 }
00654
00655
00656 if(isExitState == true){
00657 StateSet doneStates;
00658 exitLocalStatesMap[*stIt][*stIt] = false;
00659 doneStates.Insert(*stIt);
00660 backwardReachabilityObsLCC(tset_X2EvX1, rControllableEvents, rHighAlph, *stIt, *stIt, false, exitLocalStatesMap, doneStates);
00661
00662 }
00663
00664 }
00665
00666 map<Idx, map<Idx, bool> >::const_iterator elIt, elEndIt;
00667 elIt = exitLocalStatesMap.begin();
00668 elEndIt = exitLocalStatesMap.end();
00669 map<Idx,bool>::const_iterator lcIt, lcEndIt;
00670 StateSet::Iterator exIt, exEndIt;
00671 map<Idx,StateSet>::const_iterator enIt;
00672
00673 for( ; elIt != elEndIt; elIt++){
00674 lcEndIt = elIt->second.end();
00675
00676 tsIt = rGen.TransRel().Begin(elIt->first);
00677 tsEndIt = rGen.TransRel().End(elIt->first);
00678 for( ; tsIt != tsEndIt; tsIt++){
00679 OP_DF("calculateDynamicSystemObsLCC: insert transitions for the high-level event" << rGen.EventName(tsIt->Ev) << "[" << tsIt->Ev << "]");
00680 if(rHighAlph.Exists(tsIt->Ev) ){
00681 bool controllable = rControllableEvents.Exists(tsIt->Ev);
00682 enIt = entryLocalStatesMap.find(tsIt->X2);
00683 stEndIt = enIt->second.End();
00684
00685 for(lcIt = elIt->second.begin(); lcIt != lcEndIt; lcIt ++){
00686
00687 for( stIt = enIt->second.Begin(); stIt != stEndIt; stIt++){
00688 OP_DF("calculateDynamicSystemObsLCC: Transition added to resulting generator: " <<
00689 rGenDyn.TStr(Transition(lcIt->first,tsIt->Ev,*stIt)));
00690
00691 rGenDyn.SetTransition(lcIt->first,tsIt->Ev,*stIt);
00692 if( !(controllable || lcIt->second) ){
00693 OP_DF("calculateDynamicSystemObsLCC: cLabel-Transition added to resulting generator: " <<
00694 rGenDyn.TStr(Transition(lcIt->first,ucLabel,*stIt)));
00695
00696 rGenDyn.SetTransition(lcIt->first,ucLabel,*stIt);
00697 }
00698 }
00699 }
00700 }
00701 }
00702 }
00703 }
00704
00705
00706 void backwardReachabilityObsLCC(const TransSetX2EvX1& rTransSetX2EvX1, const EventSet& rControllableEvents, const EventSet& rHighAlph, Idx exitState, Idx currentState, bool controllablePath, map<Idx, map<Idx, bool> >& rExitLocalStatesMap, StateSet& rDoneStates){
00707 OP_DF("backwardReachabilityObsOCC(rTransSetX2EvX1," << rControllableEvents.Name() << "," << rHighAlph.Name() << "," << exitState << "," << currentState << "," << controllablePath << ",rExitLocalStatesMap, rDoneStates)");
00708
00709
00710
00711
00712 TransSetX2EvX1::Iterator tsIt, tsEndIt;
00713 tsIt = rTransSetX2EvX1.BeginByX2(currentState);
00714 tsEndIt = rTransSetX2EvX1.EndByX2(currentState);
00715 bool currentControllablePath;
00716
00717 for( ;tsIt != tsEndIt; tsIt++){
00718
00719 if( !rHighAlph.Exists(tsIt->Ev) && tsIt->X1 != exitState){
00720
00721 if( !rDoneStates.Exists(tsIt->X1) ){
00722 rDoneStates.Insert(tsIt->X1);
00723
00724 currentControllablePath = rControllableEvents.Exists(tsIt->Ev) || controllablePath;
00725 rExitLocalStatesMap[exitState][tsIt->X1] = currentControllablePath;
00726
00727 backwardReachabilityObsLCC(rTransSetX2EvX1, rControllableEvents, rHighAlph, exitState, tsIt->X1, currentControllablePath, rExitLocalStatesMap, rDoneStates);
00728 }
00729 else{
00730
00731
00732
00733 currentControllablePath = rControllableEvents.Exists(tsIt->Ev) || controllablePath;
00734 if(rExitLocalStatesMap[exitState][tsIt->X1] != currentControllablePath && currentControllablePath == false){
00735 rExitLocalStatesMap[exitState][tsIt->X1] = currentControllablePath;
00736
00737 backwardReachabilityObsLCC(rTransSetX2EvX1, rControllableEvents, rHighAlph, exitState, tsIt->X1, false, rExitLocalStatesMap, rDoneStates);
00738 }
00739 }
00740 }
00741 }
00742 }
00743
00744
00745 bool relabel(vGenerator& rGenRelabel, EventSet& rControllableEvents, EventSet& rHighAlph, vector<Idx>& rNewPartitions, map<Idx,Idx>& rMapStateToPartition, map<Transition,Transition>& rMapChangedTransReverse, map<Transition,Idx>& rMapChangedTrans, map<Idx, EventSet>& rMapRelabeledEvents)
00746 {
00747
00748 OP_DF("relabel(" << rGenRelabel.Name() << "," << rControllableEvents.Name() << "," << rHighAlph.Name() << ", rNewPartition, rMapStateToPartition, rMapChangedTransReverse, rMapChangedTrans, rMapRelabeledEvents)");
00749
00750
00751
00752
00753
00754
00755 map<Idx, map<Idx, map<Idx, Idx> > > mapRelabel;
00756
00757
00758 set<Idx> notRelabeledLowEvents;
00759
00760 const TransSet& transSet = rGenRelabel.TransRel();
00761 TransSet::Iterator tIt = transSet.Begin();
00762 TransSet::Iterator tItEnd = transSet.End();
00763
00764 vector<pair<TransSet::Iterator,Transition> > editTransSet;
00765
00766 vector<Idx>::iterator newPartIt = rNewPartitions.begin();
00767 vector<Idx>::iterator newPartItEnd = rNewPartitions.end();
00768 for(; newPartIt != newPartItEnd; ++newPartIt)
00769 mapRelabel[*newPartIt]=map<Idx, map <Idx, Idx> >();
00770
00771
00772
00773
00774
00775
00776
00777
00778 for(; tIt != tItEnd; ++tIt)
00779 {
00780 OP_DF("relabel: current transition: " << rGenRelabel.TStr(*tIt) );
00781 Idx indexX1Partition=rMapStateToPartition[tIt->X1];
00782 OP_DF("relabel: X1 belongs to coset with index " << indexX1Partition);
00783 Idx indexX2Partition=rMapStateToPartition[tIt->X2];
00784 OP_DF("relabel: X2 belongs to coset with index " << indexX2Partition);
00785
00786
00787 if(rHighAlph.Exists(tIt->Ev))
00788 {
00789 OP_DF("relabel: Event is high-level event");
00790
00791
00792
00793 if(mapRelabel[indexX1Partition].find(tIt->Ev) == mapRelabel[indexX1Partition].end())
00794 {
00795 mapRelabel[indexX1Partition][tIt->Ev][indexX2Partition]=tIt->Ev;
00796 OP_DF("relabel: First occurence of the current event leaving the current X1-coset");
00797 }
00798
00799
00800 else
00801 {
00802
00803
00804 if(mapRelabel[indexX1Partition][tIt->Ev].find(indexX2Partition) != mapRelabel[indexX1Partition][tIt->Ev].end())
00805 {
00806 if(mapRelabel[indexX1Partition][tIt->Ev][indexX2Partition] != tIt->Ev)
00807 {
00808 OP_DF("relabel: the same event leading to the same X2-coset has already been relabeld before. The current transition is relabeld correspondingly");
00809 pair<TransSet::Iterator,Transition> newPair;
00810 newPair.first=tIt;
00811 newPair.second = Transition(tIt->X1,mapRelabel[indexX1Partition][tIt->Ev][indexX2Partition],tIt->X2);
00812 editTransSet.push_back(newPair);
00813 }
00814 else
00815 OP_DF("relabel: There already exists a high-level transition from the current X1-coset to the same X2-coset and the current transition ist labeled with the same event. No relabeling necessary");
00816 }
00817
00818
00819
00820 else
00821 {
00822 bool createNewLabel = false;
00823
00824 if(rMapRelabeledEvents.find(tIt->Ev) != rMapRelabeledEvents.end())
00825 {
00826 EventSet::Iterator lsIt = rMapRelabeledEvents[tIt->Ev].Begin();
00827 EventSet::Iterator lsItEnd = rMapRelabeledEvents[tIt->Ev].End();
00828 for(; lsIt != lsItEnd; ++lsIt)
00829 {
00830 createNewLabel = false;
00831 map<Idx,Idx>::iterator mapIt = mapRelabel[indexX1Partition][tIt->Ev].begin();
00832 map<Idx,Idx>::iterator mapItEnd = mapRelabel[indexX1Partition][tIt->Ev].end();
00833 for(; mapIt != mapItEnd; ++mapIt)
00834 {
00835
00836
00837 if(mapIt->second == *lsIt)
00838 {
00839 createNewLabel = true;
00840 break;
00841 }
00842 }
00843
00844 if(createNewLabel == false)
00845 {
00846 pair<TransSet::Iterator,Transition> newPair;
00847 newPair.first=tIt;
00848 newPair.second = Transition(tIt->X1,*lsIt,tIt->X2);
00849 editTransSet.push_back(newPair);
00850 OP_DF("relabel: An event was found that can be reused: " << rGenRelabel.EventName(*lsIt));
00851 break;
00852 }
00853 }
00854 }
00855
00856 else
00857 {
00858 createNewLabel = true;
00859 }
00860
00861 if(createNewLabel == true)
00862 {
00863
00864 std::string eventName = ( rGenRelabel.EventSymbolTablep())->UniqueSymbol(rGenRelabel.EventSymbolTablep()->Symbol(tIt->Ev) + "newHLevent_1");
00865 Idx newLabel = (rGenRelabel.EventSymbolTablep())->InsEntry(eventName);
00866
00867 rGenRelabel.InsEvent(eventName);
00868
00869 if(rControllableEvents.Exists(tIt->Ev)){
00870 rControllableEvents.Insert(newLabel);
00871 }
00872 OP_DF("relabel: No event that can be reused could be found. The new event " << rGenRelabel.EventName(newLabel) << " was created");
00873 rHighAlph.Insert(newLabel);
00874
00875 pair<TransSet::Iterator,Transition> newPair;
00876 newPair.first=tIt;
00877 newPair.second = Transition(tIt->X1,newLabel,tIt->X2);
00878 editTransSet.push_back(newPair);
00879 rMapRelabeledEvents[tIt->Ev].Insert(newLabel);
00880 }
00881 }
00882 }
00883 }
00884
00885 else
00886 {
00887 OP_DF("relabel: Event is low-level event");
00888
00889 if(indexX1Partition != indexX2Partition)
00890 {
00891
00892
00893 if(rMapRelabeledEvents.find(tIt->Ev) == rMapRelabeledEvents.end())
00894 {
00895 std::string eventName = ( rGenRelabel.EventSymbolTablep())->UniqueSymbol(rGenRelabel.EventSymbolTablep()->Symbol(tIt->Ev) + "newHLevent_1");
00896 Idx newLabel = (rGenRelabel.EventSymbolTablep())->InsEntry(eventName);
00897 rGenRelabel.InsEvent(eventName);
00898
00899 rHighAlph.Insert(newLabel);
00900 if(rControllableEvents.Exists(tIt->Ev)){
00901 rControllableEvents.Insert(newLabel);
00902 }
00903 OP_DF("relabel: First occurence of current low-level event " << rGenRelabel.EventName(tIt->Ev)
00904 << " between cosets. The new event " << rGenRelabel.EventName(newLabel) << " was created");
00905 mapRelabel[indexX1Partition][tIt->Ev][indexX2Partition]=newLabel;
00906 rMapRelabeledEvents[tIt->Ev].Insert(newLabel);
00907 pair<TransSet::Iterator,Transition> newPair;
00908 newPair.first=tIt;
00909 newPair.second = Transition(tIt->X1,newLabel,tIt->X2);
00910 editTransSet.push_back(newPair);
00911 }
00912
00913
00914
00915 else
00916 {
00917 EventSet::Iterator lsIt = rMapRelabeledEvents[tIt->Ev].Begin();
00918 EventSet::Iterator lsItEnd = rMapRelabeledEvents[tIt->Ev].End();
00919 bool createNewLabel = true;
00920 for(; lsIt != lsItEnd; ++lsIt)
00921 {
00922 bool labelFound = false;
00923
00924 if(mapRelabel.find(indexX1Partition) == mapRelabel.end())
00925 {
00926
00927
00928 labelFound = true;
00929 }
00930 else
00931 {
00932
00933 if(mapRelabel[indexX1Partition].find(tIt->Ev) == mapRelabel[indexX1Partition].end())
00934 {
00935 labelFound = true;
00936 }
00937 else
00938 {
00939
00940
00941
00942 if(mapRelabel[indexX1Partition][tIt->Ev].find(indexX2Partition) == mapRelabel[indexX1Partition][tIt->Ev].end())
00943 {
00944 map<Idx,Idx>::iterator mapIt=mapRelabel[indexX1Partition][tIt->Ev].begin();
00945 map<Idx,Idx>::iterator mapItEnd=mapRelabel[indexX1Partition][tIt->Ev].end();
00946 labelFound = true;
00947 for(; mapIt != mapItEnd; ++ mapIt)
00948 {
00949 if(mapIt->second== *lsIt)
00950 {
00951 labelFound = false;
00952 break;
00953 }
00954 }
00955 }
00956
00957
00958 else
00959 {
00960 pair<TransSet::Iterator,Transition> newPair;
00961 newPair.first=tIt;
00962 newPair.second = Transition(tIt->X1,mapRelabel[indexX1Partition][tIt->Ev][indexX2Partition],tIt->X2);
00963 editTransSet.push_back(newPair);
00964 OP_DF("relabel: A transition to same X2-coset has already been found and relabeled before; the current transition is also labeled with " << rGenRelabel.EventName(mapRelabel[indexX1Partition][tIt->Ev][indexX2Partition]));
00965 createNewLabel = false;
00966 break;
00967 }
00968 }
00969 }
00970
00971 if(labelFound == true)
00972 {
00973 pair<TransSet::Iterator,Transition> newPair;
00974 newPair.first=tIt;
00975 newPair.second = Transition(tIt->X1,*lsIt,tIt->X2);
00976 editTransSet.push_back(newPair);
00977 OP_DF("relabele: Low level event " << rGenRelabel.EventName(tIt->Ev) << " is relabeled with " << rGenRelabel.EventName(*lsIt) << " which can be reused");
00978 mapRelabel[indexX1Partition][tIt->Ev][indexX2Partition]=*lsIt;
00979 createNewLabel = false;
00980 break;
00981 }
00982 }
00983
00984 if(createNewLabel == true)
00985 {
00986 std::string eventName = ( rGenRelabel.EventSymbolTablep())->UniqueSymbol(rGenRelabel.EventSymbolTablep()->Symbol(tIt->Ev) + "newHLevent_1");
00987 Idx newLabel = (rGenRelabel.EventSymbolTablep())->InsEntry(eventName);
00988 rGenRelabel.InsEvent(eventName);
00989
00990 rHighAlph.Insert(newLabel);
00991 if(rControllableEvents.Exists(tIt->Ev) ){
00992 rControllableEvents.Insert(newLabel);
00993 }
00994 OP_DF("relabel: No label could be reused, and the new event " << rGenRelabel.EventName(newLabel) << " was created");
00995 mapRelabel[indexX1Partition][tIt->Ev][indexX2Partition]=newLabel;
00996 pair<TransSet::Iterator,Transition> newPair;
00997 newPair.first=tIt;
00998 newPair.second = Transition(tIt->X1,newLabel,tIt->X2);
00999 editTransSet.push_back(newPair);
01000 rMapRelabeledEvents[tIt->Ev].Insert(newLabel);
01001 }
01002 }
01003 }
01004
01005 else
01006 {
01007 notRelabeledLowEvents.insert(tIt->Ev);
01008 }
01009 }
01010 }
01011
01012
01013
01014
01015
01016
01017 vector<pair<TransSet::Iterator,Transition> >::iterator etSetIt = editTransSet.begin();
01018 vector<pair<TransSet::Iterator,Transition> >::iterator etSetItEnd = editTransSet.end();
01019 set<Idx> insertHighEvents;
01020 set<Idx> deleteHighEvents;
01021 bool quotAuotTrue=true;
01022
01023 OP_DF("relabel: Trying to avoid unnecessariy new labels");
01024
01025 for(etSetIt = editTransSet.begin(); etSetIt != editTransSet.end(); ++etSetIt)
01026 {
01027 Idx oldEvent = etSetIt->first->Ev;
01028 Idx newEvent = etSetIt->second.Ev;
01029 OP_DF("relabel: Checking transition X1=" << rGenRelabel.StateName(etSetIt->first->X1)<< " ["<<etSetIt->first->X1
01030 << "] Ev=" << rGenRelabel.EventName(oldEvent) << " X2=" << rGenRelabel.StateName(etSetIt->first->X2)
01031 << " [" << etSetIt->first->X2 << "] which shall be relabeled with event " << rGenRelabel.EventName(newEvent));
01032
01033 if(notRelabeledLowEvents.find(oldEvent) == notRelabeledLowEvents.end() && !rHighAlph.Exists(oldEvent))
01034 {
01035 OP_DF("relabel: There is no low-level event " << rGenRelabel.EventName(oldEvent) << " left");
01036 insertHighEvents.insert(oldEvent);
01037
01038 quotAuotTrue=false;
01039
01040 if(rMapRelabeledEvents[oldEvent].Find(newEvent) == rMapRelabeledEvents[oldEvent].Begin())
01041 {
01042 OP_DF("relabel: Transition will not be relabeled");
01043
01044 if(rMapRelabeledEvents[oldEvent].Find(newEvent)==(--(rMapRelabeledEvents[oldEvent].End())))
01045 {
01046 OP_DF("relabel: newEvent is the first and last event in rMapRelabeledEvents[oldEvent]");
01047 deleteHighEvents.insert(newEvent);
01048 }
01049
01050 vector<pair<TransSet::Iterator,Transition> >::iterator helpIt = etSetIt;
01051 helpIt--;
01052 editTransSet.erase(etSetIt);
01053 etSetIt = helpIt;
01054 }
01055 else
01056 {
01057
01058 Idx newLabel = *(--(rMapRelabeledEvents[oldEvent].Find(newEvent)));
01059 etSetIt->second.Ev = newLabel;
01060
01061 if(rMapRelabeledEvents[oldEvent].Find(newEvent)==(--(rMapRelabeledEvents[oldEvent].End())))
01062 {
01063 deleteHighEvents.insert(newEvent);
01064 }
01065 }
01066 }
01067 }
01068
01069
01070
01071
01072
01073 set<Idx>::iterator setIt = insertHighEvents.begin();
01074 set<Idx>::iterator setItEnd = insertHighEvents.end();
01075 for(; setIt!= setItEnd; ++ setIt)
01076 {
01077 rHighAlph.Insert(*setIt);
01078 }
01079 setIt = deleteHighEvents.begin();
01080 setItEnd = deleteHighEvents.end();
01081 for(; setIt != setItEnd; ++setIt)
01082 {
01083 rGenRelabel.DelEvent(*setIt);
01084 rHighAlph.Erase(*setIt);
01085 rControllableEvents.Erase(*setIt);
01086 }
01087
01088 rControllableEvents = rControllableEvents * rGenRelabel.Alphabet();
01089
01090 if(editTransSet.empty()&& quotAuotTrue== true)
01091 {
01092 OP_DF("relabel: Leaving function relabel with true");
01093 return true;
01094 }
01095
01096
01097 etSetIt = editTransSet.begin();
01098 etSetItEnd = editTransSet.end();
01099 for(; etSetIt != etSetItEnd; ++etSetIt)
01100 {
01101 map<Transition,Transition>::iterator mrIt;
01102 mrIt=rMapChangedTransReverse.find(*(etSetIt->first));
01103
01104 if(mrIt!=rMapChangedTransReverse.end())
01105 {
01106 Transition originalTrans = mrIt->second;
01107 (rMapChangedTrans.find(originalTrans))->second = (etSetIt->second).Ev;
01108 rMapChangedTransReverse.erase(mrIt);
01109 rMapChangedTransReverse[etSetIt->second]=originalTrans;
01110 OP_DF("relabel: The transition X1= " << rGenRelabel.SStr((etSetIt->first)->X1) << " Ev=" << rGenRelabel.EStr((etSetIt->first)->Ev) << " X2= " << rGenRelabel.SStr((etSetIt->first)->X2) << " has already been relabeled in a former iteration step. The original transition was " << rGenRelabel.SStr(originalTrans.X1) << " Ev=" << rGenRelabel.EStr(originalTrans.Ev) << " X2= " << rGenRelabel.SStr(originalTrans.X2) << "; the new label is " << rGenRelabel.EStr((etSetIt->second).Ev));
01111 }
01112
01113 else
01114 {
01115 rMapChangedTransReverse[etSetIt->second]=*(etSetIt->first);
01116 rMapChangedTrans[*(etSetIt->first)]=(etSetIt->second).Ev;
01117 OP_DF("relabel: First relabeling of transition X1=" << rGenRelabel.SStr((etSetIt->first)->X1)
01118 << " Ev=" << rGenRelabel.EStr((etSetIt->first)->Ev) << " X2= " << rGenRelabel.SStr((etSetIt->first)->X2) << " new label is " << rGenRelabel.EStr((etSetIt->second).Ev));
01119 }
01120
01121 rGenRelabel.ClrTransition(etSetIt->first);
01122 rGenRelabel.SetTransition(etSetIt->second);
01123 }
01124
01125 OP_DF("relabel: leaving function with false");
01126 return false;
01127 }
01128
01129
01130 void insertRelabeledEvents(cGenerator& rGenPlant, const map<Idx,set<Idx> >& rMapRelabeledEvents, cEventSet& rNewEvents) {
01131 map<Idx,set<Idx> >::const_iterator reEndIt = rMapRelabeledEvents.end();
01132 TransSet::Iterator tsEndIt = rGenPlant.TransRelEnd();
01133 TransSet::Iterator tsIt = rGenPlant.TransRelBegin();
01134
01135 for(; tsIt != tsEndIt; tsIt++){
01136 map<Idx,set<Idx> >::const_iterator reIt = rMapRelabeledEvents.find(tsIt->Ev);
01137 if(reIt == reEndIt) continue;
01138 const AttributeCFlags& attr = rGenPlant.EventAttribute(tsIt->Ev);
01139 set<Idx>::const_iterator rsEndIt = reIt->second.end();
01140 set<Idx>::const_iterator rsIt = reIt->second.begin();
01141
01142
01143 for(; rsIt != rsEndIt; rsIt++){
01144 rGenPlant.InsEvent(*rsIt,attr);
01145 rNewEvents.Insert(*rsIt,attr);
01146 rGenPlant.SetTransition(tsIt->X1,*rsIt,tsIt->X2);
01147 }
01148 }
01149 }
01150
01151
01152 void insertRelabeledEvents(cGenerator& rGenPlant, const map<Idx,set<Idx> >& rMapRelabeledEvents) {
01153 map<Idx,set<Idx> >::const_iterator reEndIt = rMapRelabeledEvents.end();
01154 TransSet::Iterator tsEndIt = rGenPlant.TransRelEnd();
01155 TransSet::Iterator tsIt = rGenPlant.TransRelBegin();
01156
01157 for(; tsIt != tsEndIt; tsIt++){
01158 map<Idx,set<Idx> >::const_iterator reIt = rMapRelabeledEvents.find(tsIt->Ev);
01159 if(reIt == reEndIt) continue;
01160 const AttributeCFlags& attr = rGenPlant.EventAttribute(tsIt->Ev);
01161 set<Idx>::const_iterator rsEndIt = reIt->second.end();
01162 set<Idx>::const_iterator rsIt = reIt->second.begin();
01163
01164
01165 for(; rsIt != rsEndIt; rsIt++){
01166 rGenPlant.InsEvent(*rsIt,attr);
01167 rGenPlant.SetTransition(tsIt->X1,*rsIt,tsIt->X2);
01168 }
01169 }
01170 }
01171
01172 }