con_supcc.cpp

Go to the documentation of this file.
00001 /** @file con_controllability.cpp Conditionalcontrollability */
00002 
00003 /*
00004  * Implementation of the conditionally controllable algorithm
00005  *
00006  * Copyright (C) 2012  Tomas Masopust
00007  *
00008  */
00009 
00010 
00011 #include "con_supcc.h"
00012 #include "con_include.h"
00013 #include "op_include.h"
00014 #include <vector>
00015 
00016 namespace faudes {
00017 
00018 bool SupConditionalControllable(
00019   const Generator& gen, 
00020   const GeneratorVector& genVector, 
00021   const EventSet& ACntrl,
00022   const EventSet& InitEk,
00023   GeneratorVector& supVector,
00024   Generator& Coord) {
00025 
00026   /* Steps of the algorithm
00027    * 1. compute Ek so that it contains all shared events
00028    * 2. extend Ek so that K = L(gen) is CD
00029    * 3. extend Ek so that Pk is Li-observer, i=1,2,...,n
00030    * 4. compute the coordinator Gk and supCk, supCi+k
00031    * 5. if supCk subseteq Pk(supCi+k), return supCi+k and the supervised coordinator (supCk)
00032    * 6. extend Ek so that P^{i+k}_k is (P^{i+k}_k)^{-1}(Li)-observer and OCC for that language
00033    * 7. recompute supCi+k a return them and the supervised coordinator
00034    */
00035   
00036   Idx i;
00037 
00038   // the generators must be deterministic and prefix-closed
00039   if (gen.IsDeterministic() == false || IsPrefixClosed(gen) == false) {
00040     std::stringstream errstr;
00041     errstr << "Generators must be deterministic and prefix-closed";
00042     throw Exception("ConditionalControllability", errstr.str(), 201);
00043   } 
00044   for (i = 0; i < genVector.Size(); i++) {
00045     if (genVector.At(i).IsDeterministic() == false || IsPrefixClosed(genVector.At(i)) == false) {
00046       std::stringstream errstr;
00047       errstr << "Generators of genVector must be deterministic and prefix-closed";
00048       throw Exception("ConditionalControllability", errstr.str(), 201);
00049     }
00050   }
00051 
00052 /* 1. compute Ek so that it contains all shared events */
00053   EventSet unionset;      // contains union of Ei
00054   EventSet shared;      // contains union of intersections
00055 
00056   // Compute unionset
00057   for (i = 0; i < genVector.Size(); i++) {
00058     SetUnion(unionset,genVector.At(i).Alphabet(),unionset);
00059   }
00060 
00061   // Compute the set of shared events
00062   for (i = 0; i < genVector.Size(); i++) {
00063     for (Idx j = 0; j < genVector.Size(); j++) {
00064       if (j != i) {
00065     EventSet eHelpInt;
00066     SetIntersection(genVector.At(i).Alphabet(),genVector.At(j).Alphabet(),eHelpInt);
00067     SetUnion(shared,eHelpInt,shared);
00068       }
00069     }
00070   }
00071 
00072   EventSet ek = shared + InitEk;
00073   std::cerr << "Initial Ek = { ";
00074   EventSet::Iterator eit;
00075   for (eit=ek.Begin(); eit != ek.End(); ++eit) {
00076     std::cerr << ek.SymbolicName(*eit) << " ";
00077   } 
00078   std::cerr << "}" << std::endl;
00079 
00080     // Alphabet of the generator must be under union Ei 
00081   bool ok = SetInclusion(gen.Alphabet(),unionset);
00082     if (ok == false) {
00083     std::stringstream errstr;
00084     errstr << "Generator alphabet is not included in union of the alphabets";
00085     throw Exception("ConditionalDecomposability", errstr.str(), 100);
00086     }
00087 
00088     // Alphabet of the generator must contain Ek
00089   ok = SetInclusion(ek,gen.Alphabet());
00090     if (ok == false) {
00091     std::stringstream errstr;
00092     errstr << "Generator alphabet does not include the alphabet ek";
00093     throw Exception("ConditionalDecomposability", errstr.str(), 100);
00094     }
00095 
00096 /* 2. extend Ek so that K = L(gen) is CD */
00097   std::cerr << "Extension of Ek for Conditional Decomposability..." << std::endl;
00098   EventSetVector ee;
00099   for (i = 0; i < genVector.Size(); i++) {
00100     ee.Append(genVector.At(i).Alphabet());
00101   } 
00102   ConDecExtension(gen,ee,ek);
00103 
00104 /* 3. extend Ek so that Pk is Li-observer, i=1,2,...,n */
00105   bool repeat = true;
00106   std::cerr << "Extension of Ek for Li-observers..." << std::endl;
00107   while (repeat) {
00108     repeat = false;
00109     for (i = 0; i < genVector.Size(); i++) {
00110       if (IsObs(genVector.At(i),ek*genVector.At(i).Alphabet()) == false ) {
00111         repeat = true;
00112         EventSet ekHelp = ek * genVector.At(i).Alphabet();
00113         calcNaturalObserver(genVector.At(i),ekHelp);
00114         SetUnion(ek,ekHelp,ek);
00115       }
00116     } 
00117   }
00118   std::cerr << "Extended Ek = { ";
00119   for (eit=ek.Begin(); eit != ek.End(); ++eit) {
00120     std::cerr << ek.SymbolicName(*eit) << " ";
00121   } 
00122   std::cerr << "}" << std::endl;
00123 
00124 /* 4. compute the coordinator Gk and supCk, supCi+k */
00125   // coordinator Gk = || P_k(G_i)
00126   Generator gk;
00127   FullLanguage(ek,gk);
00128   for (i = 0; i < genVector.Size(); i++) {
00129     Generator pomGen;
00130     Project(genVector.At(i),ek,pomGen);
00131     Parallel(gk,pomGen,gk);
00132   }
00133 
00134   // compute P_k(K) and the vector of P_{i+k}(K)
00135   Generator pk;
00136   Project(gen,ek,pk);
00137   GeneratorVector specVect;
00138   for (i = 0; i < genVector.Size(); i++) {
00139     Generator pomGen;
00140     Project(gen,ek+genVector.At(i).Alphabet(),pomGen);
00141     specVect.Append(pomGen);
00142   }
00143 
00144   // the set of controllable events E_{k,c} 
00145   EventSet ekc;
00146   SetIntersection(ek,ACntrl,ekc);
00147   // supCk supervisor
00148   Generator supCk;
00149   // vector of supC_{i+k} supervisors
00150   GeneratorVector supCkVector;
00151 
00152   // compute supremal controllable sublanguage of P_k(K) wrt L(G_k) and E_{k,c}
00153   // if (IsControllable(gk,ekc,pk)) --  DO NOT USE, if K not subset of L, then the results are wrong!!!
00154   SupConClosed(gk,ekc,pk,supCk);
00155 
00156   // compute supremal controllable sublanguage of P_{i+k}(K) wrt L(G_i)||supCk and E_{1+k,c}
00157   for (i = 0; i < genVector.Size(); i++) {
00158     Generator helpPlant;
00159     Parallel(genVector.At(i),supCk,helpPlant);
00160     Generator supCik;
00161     SupConClosed(helpPlant,helpPlant.Alphabet()*ACntrl,specVect.At(i),supCik);
00162     supCkVector.Append(supCik); // supC_{i+k} = supCik
00163   }
00164 
00165 /* 5. if supCk subseteq Pk(supCi+k), return supCi+k and the supervised coordinator*/
00166   bool incl = true;
00167   // TODO -- implement this test nodeterministically!!!
00168   for (i = 0; i < supCkVector.Size(); i++) {
00169     Generator PkHelp;
00170     Project(supCkVector.At(i),ek,PkHelp);
00171     incl = incl && LanguageInclusion(supCk,PkHelp);
00172   }
00173   // incl = true ==> ok
00174   if (incl) {
00175     Coord = supCk;
00176     supVector = supCkVector;
00177     std::cout << "Finished: supCk is a subset of all Pk(supCi+k)." << std::endl;
00178     return true;
00179   }
00180 
00181 /* 6. extend Ek so that P^{i+k}_k is (P^{i+k}_i)^{-1}(Li)-observer and OCC for that language */
00182 // Here LCC is used instead of OCC
00183   // compute a vector of (P^{i+k}_k)^{-1}(Li)
00184   GeneratorVector invLiVect;
00185   for (i = 0; i < genVector.Size(); i++) {
00186     Generator invLi;
00187     aInvProject(genVector.At(i),ek+genVector.At(i).Alphabet(),invLi);
00188     invLiVect.Append(invLi);
00189   }
00190   repeat = true;
00191   while (repeat) {
00192     repeat = false;
00193     for (i = 0; i < invLiVect.Size(); i++) {
00194       if (IsObs(invLiVect.At(i),ek) && IsLCC(invLiVect.At(i),ek) == false ) {
00195         repeat = true;
00196         calcNaturalObserverLCC(genVector.At(i),ekc,ek);
00197       }
00198     } 
00199   }
00200 
00201 /* 7. recompute supCi+k a return them and the supervised coordinator*/
00202   // recompute the set of controllable events E_{k,c} 
00203   ekc = ek * ACntrl;
00204   supCk.Clear();
00205   supCkVector.Clear();
00206 
00207   // coordinator Gk = || P_k(G_i)
00208   gk.Clear();
00209   FullLanguage(ek,gk);
00210   for (i = 0; i < genVector.Size(); i++) {
00211     Generator pomGen;
00212     Project(genVector.At(i),ek,pomGen);
00213     Parallel(gk,pomGen,gk);
00214   }
00215 
00216   // compute P_k(K) and the vector of P_{i+k}(K)
00217   pk.Clear();
00218   Project(gen,ek,pk);
00219   specVect.Clear();
00220   for (i = 0; i < genVector.Size(); i++) {
00221     Generator pomGen;
00222     Project(gen,ek+genVector.At(i).Alphabet(),pomGen);
00223     specVect.Append(pomGen);
00224   }
00225 
00226   // compute supremal controllable sublanguage of P_k(K) wrt L(G_k) and E_{k,c}
00227   SupConClosed(gk,ekc,pk,supCk);
00228 
00229   // compute supremal controllable sublanguages of P_{i+k}(K) wrt L(G_i)||supCk and E_{1+k,c}
00230   for (i = 0; i < genVector.Size(); i++) {
00231     Generator helpPlant;
00232     Parallel(genVector.At(i),supCk,helpPlant);
00233     Generator supCik;
00234     SupConClosed(helpPlant,helpPlant.Alphabet()*ACntrl,specVect.At(i),supCik);
00235     supCkVector.Append(supCik); // supC_{i+k} = supCik
00236   }
00237   
00238   // the resulting supervisors
00239   supVector = supCkVector;
00240   Coord = supCk;
00241   std::cout << "Finished: supCk was NOT a subset of all Pk(supCi+k)." << std::endl;
00242   return true;
00243 
00244 }
00245 
00246 
00247 } // name space 
00248 
00249 
00250 

libFAUDES 2.23h --- 2014.04.03 --- c++ api documentaion by doxygen