syn_2_omega.cppGo to the documentation of this file.00001 /** @file syn_2_omega.cpp 00002 00003 Synthesis for omega languages. 00004 00005 @ingroup Tutorials 00006 00007 @include syn_2_omega.cpp 00008 00009 */ 00010 00011 #include "libfaudes.h" 00012 00013 00014 // we make the faudes namespace available to our program 00015 using namespace faudes; 00016 00017 00018 ///////////////// 00019 // main program 00020 ///////////////// 00021 00022 00023 int main() { 00024 00025 00026 ///////////////////////////////////////////// 00027 // Omega control (closed supervisors) 00028 // 00029 // The A-B-Machine is a machine that can run process A (event a) or process B (event b). 00030 // Per operation, the machine may succeed (event c) of fail (event d). However, it is 00031 // guaranteed to suceed eventually. We have three variations: 00032 // 00033 // 1: the std case 00034 // 2: process B exhausts the machine: it will succeed in process B once and then 00035 // fail on further processes B until process A was run. 00036 // 3: process B breaks the machine: it will succeed in process B once and 00037 // then fail in any further processes 00038 // 00039 // We synthesise controllers for 3 variant specifications 00040 // 00041 // 1. Alternate in successfully processing A and B 00042 // 2. Keep on eventually succeeding in some process 00043 // 3. Start with process A, eventually switch to B, repeat 00044 // 00045 ///////////////////////////////////////////// 00046 00047 00048 // Read A-B-Machines and specifications 00049 System machineab1("data/wmachineab1.gen"); 00050 System machineab2("data/wmachineab2.gen"); 00051 System machineab3("data/wmachineab3.gen"); 00052 Generator specab1("data/wspecab1.gen"); 00053 Generator specab2("data/wspecab2.gen"); 00054 Generator specab3("data/wspecab3.gen"); 00055 00056 // Fix lazy specifications by intersection with plant 00057 Generator specab11; OmegaProduct(specab1,machineab1,specab11); specab11.OmegaTrim(); 00058 Generator specab21; OmegaProduct(specab2,machineab1,specab21); specab21.OmegaTrim(); 00059 Generator specab31; OmegaProduct(specab3,machineab1,specab31); specab31.OmegaTrim(); 00060 Generator specab12; OmegaProduct(specab1,machineab2,specab12); specab12.OmegaTrim(); 00061 Generator specab22; OmegaProduct(specab2,machineab2,specab22); specab22.OmegaTrim(); 00062 Generator specab32; OmegaProduct(specab3,machineab2,specab32); specab32.OmegaTrim(); 00063 Generator specab13; OmegaProduct(specab1,machineab3,specab13); specab13.OmegaTrim(); 00064 Generator specab23; OmegaProduct(specab2,machineab3,specab23); specab23.OmegaTrim(); 00065 Generator specab33; OmegaProduct(specab3,machineab3,specab33); specab33.OmegaTrim(); 00066 00067 // Report result to console 00068 std::cout << "################################\n"; 00069 std::cout << "# fixed lazy specifications by omega-trim \n# intersection with plant, state count\n"; 00070 std::cout << " w.r.t a-b-machine 1 (std case): \n "; 00071 std::cout << " #" << specab11.Size() << " #" << specab21.Size() << " #" << specab31.Size() << "\n"; 00072 std::cout << " w.r.t a-b-machine 2 (b exhausts the machine): \n "; 00073 std::cout << " #" << specab12.Size() << " #" << specab22.Size() << " #" << specab32.Size() << "\n"; 00074 std::cout << " w.r.t a-b-machine 3 (b breaks the machine): \n "; 00075 std::cout << " #" << specab13.Size() << " #" << specab23.Size() << " #" << specab33.Size() << "\n"; 00076 std::cout << "################################\n"; 00077 00078 00079 00080 // Test (relative closedness) 00081 bool rcl1_1 = IsRelativelyOmegaClosed(machineab1,specab11); 00082 bool rcl2_1 = IsRelativelyOmegaClosed(machineab1,specab21); 00083 bool rcl3_1 = IsRelativelyOmegaClosed(machineab1,specab31); 00084 bool rcl1_2 = IsRelativelyOmegaClosed(machineab2,specab12); 00085 bool rcl2_2 = IsRelativelyOmegaClosed(machineab2,specab22); 00086 bool rcl3_2 = IsRelativelyOmegaClosed(machineab2,specab32); 00087 bool rcl1_3 = IsRelativelyOmegaClosed(machineab3,specab13); 00088 bool rcl2_3 = IsRelativelyOmegaClosed(machineab3,specab23); 00089 bool rcl3_3 = IsRelativelyOmegaClosed(machineab3,specab33); 00090 00091 00092 // Report result to console 00093 std::cout << "################################\n"; 00094 std::cout << "# omega relative closedness w.r.t. ab-machines\n"; 00095 std::cout << " w.r.t a-b-machine 1 (std case): \n "; 00096 if(rcl1_1) std::cout << " passed "; else std::cout << " failed "; 00097 if(rcl2_1) std::cout << " passed "; else std::cout << " failed "; 00098 if(rcl3_1) std::cout << " passed "; else std::cout << " failed "; 00099 std::cout << "\n"; 00100 std::cout << " w.r.t a-b-machine 2 (b exhausts the machine): \n "; 00101 if(rcl1_2) std::cout << " passed "; else std::cout << " failed "; 00102 if(rcl2_2) std::cout << " passed "; else std::cout << " failed "; 00103 if(rcl3_2) std::cout << " passed "; else std::cout << " failed "; 00104 std::cout << "\n"; 00105 std::cout << " w.r.t a-b-machine 3 (b breaks the machine): \n "; 00106 if(rcl1_3) std::cout << " passed "; else std::cout << " failed "; 00107 if(rcl2_3) std::cout << " passed "; else std::cout << " failed "; 00108 if(rcl3_3) std::cout << " passed "; else std::cout << " failed "; 00109 std::cout << "\n"; 00110 std::cout << "################################\n"; 00111 00112 // Record test case 00113 FAUDES_TEST_DUMP("RelClosed_1_1",rcl1_1); 00114 FAUDES_TEST_DUMP("RelClosed_2_1",rcl2_1); 00115 FAUDES_TEST_DUMP("RelClosed_3_1",rcl3_1); 00116 FAUDES_TEST_DUMP("RelClosed_1_2",rcl1_2); 00117 FAUDES_TEST_DUMP("RelClosed_2_2",rcl2_2); 00118 FAUDES_TEST_DUMP("RelClosed_3_2",rcl3_2); 00119 FAUDES_TEST_DUMP("RelClosed_1_3",rcl1_3); 00120 FAUDES_TEST_DUMP("RelClosed_2_3",rcl2_3); 00121 FAUDES_TEST_DUMP("RelClosed_3_3",rcl3_3); 00122 00123 // Close specification 00124 Generator specab11c=specab11; PrefixClosure(specab11c); 00125 Generator specab12c=specab12; PrefixClosure(specab12c); 00126 Generator specab21c=specab21; PrefixClosure(specab21c); 00127 Generator specab23c=specab23; PrefixClosure(specab23c); 00128 00129 // Synthesise supervisors 00130 Generator supab11; SupConCmplNB(machineab1,specab11c,supab11); 00131 Generator supab21; SupConCmplNB(machineab1,specab21c,supab21); 00132 Generator supab12; SupConCmplNB(machineab2,specab12c,supab12); 00133 Generator supab23; SupConCmplNB(machineab3,specab23c,supab23); 00134 00135 // Report result to console 00136 std::cout << "################################\n"; 00137 std::cout << "# omega synthesis statistics\n"; 00138 supab11.SWrite(); 00139 supab12.SWrite(); 00140 supab21.SWrite(); 00141 supab23.SWrite(); 00142 std::cout << "################################\n"; 00143 00144 // Record test case 00145 FAUDES_TEST_DUMP("Sup1_1",supab11); 00146 FAUDES_TEST_DUMP("Sup1_2",supab12); 00147 FAUDES_TEST_DUMP("Sup2_1",supab21); 00148 FAUDES_TEST_DUMP("Sup2_3",supab23); 00149 00150 00151 // Test controllability 00152 std::cout << "################################\n"; 00153 std::cout << "# omega controllability:\n"; 00154 if(IsOmegaControllable(machineab1,supab11)) 00155 std::cout << "# supervisor11: passed (expected)\n"; 00156 else 00157 std::cout << "# supervisor11: failed (test case error)\n"; 00158 if(IsOmegaControllable(machineab2,supab12)) 00159 std::cout << "# supervisor12: passed (expected)\n"; 00160 else 00161 std::cout << "# supervisor12: failed (test case error)\n"; 00162 if(IsOmegaControllable(machineab1,supab21)) 00163 std::cout << "# supervisor21: passed (expected)\n"; 00164 else 00165 std::cout << "# supervisor21: failed (test case error)\n"; 00166 if(IsOmegaControllable(machineab3,supab23)) 00167 std::cout << "# supervisor23: passed (expected)\n"; 00168 else 00169 std::cout << "# supervisor23: failed (test case error)\n"; 00170 std::cout << "################################\n"; 00171 00172 00173 // Prepare graphical output for documentation, I 00174 supab11.StateNamesEnabled(false); 00175 supab21.StateNamesEnabled(false); 00176 supab12.StateNamesEnabled(false); 00177 supab23.StateNamesEnabled(false); 00178 StateMin(supab11,supab11); 00179 StateMin(supab21,supab21); 00180 StateMin(supab12,supab12); 00181 StateMin(supab23,supab23); 00182 00183 // Prepare graphical output for documentation, II 00184 machineab1.Write("tmp_syn_2_machineab1.gen"); 00185 machineab2.Write("tmp_syn_2_machineab2.gen"); 00186 machineab3.Write("tmp_syn_2_machineab3.gen"); 00187 specab1.Write("tmp_syn_2_specab1.gen"); 00188 specab2.Write("tmp_syn_2_specab2.gen"); 00189 specab3.Write("tmp_syn_2_specab3.gen"); 00190 supab11.Write("tmp_syn_2_supab11.gen"); 00191 supab21.Write("tmp_syn_2_supab21.gen"); 00192 supab12.Write("tmp_syn_2_supab12.gen"); 00193 supab23.Write("tmp_syn_2_supab23.gen"); 00194 00195 //Generator prodab22; Product(machineab2,specab22,prodab22); 00196 //prod22.Write("tmp_syn_2_prodab22.gen"); 00197 00198 00199 00200 ///////////////////////////////////////////// 00201 // Marking supervisor omega control 00202 // 00203 // 00204 //////////////////////////////////////////// 00205 00206 // Run the above test cases 00207 Generator msupab11; OmegaSupConNB(machineab1,specab1,msupab11); 00208 Generator msupab21; OmegaSupConNB(machineab1,specab2,msupab21); 00209 Generator msupab31; OmegaSupConNB(machineab1,specab3,msupab31); 00210 Generator msupab12; OmegaSupConNB(machineab2,specab1,msupab12); 00211 Generator msupab22; OmegaSupConNB(machineab2,specab2,msupab22); 00212 Generator msupab32; OmegaSupConNB(machineab2,specab3,msupab32); 00213 Generator msupab13; OmegaSupConNB(machineab3,specab1,msupab13); 00214 Generator msupab23; OmegaSupConNB(machineab3,specab2,msupab23); 00215 Generator msupab33; OmegaSupConNB(machineab3,specab3,msupab33); 00216 00217 // Report statistics 00218 std::cout << "################################\n"; 00219 std::cout << "# omega synthesis statistics\n"; 00220 msupab11.SWrite(); 00221 msupab21.SWrite(); 00222 msupab31.SWrite(); 00223 msupab12.SWrite(); 00224 msupab22.SWrite(); 00225 msupab32.SWrite(); 00226 msupab13.SWrite(); 00227 msupab23.SWrite(); 00228 msupab33.SWrite(); 00229 std::cout << "################################\n"; 00230 00231 00232 // Record test case 00233 FAUDES_TEST_DUMP("OSup1_1",msupab11); 00234 FAUDES_TEST_DUMP("OSup2_1",msupab21); 00235 FAUDES_TEST_DUMP("OSup3_1",msupab31); 00236 FAUDES_TEST_DUMP("OSup1_2",msupab12); 00237 FAUDES_TEST_DUMP("OSup2_2",msupab22); 00238 FAUDES_TEST_DUMP("OSup3_2",msupab32); 00239 FAUDES_TEST_DUMP("OSup1_3",msupab13); 00240 FAUDES_TEST_DUMP("OSup2_3",msupab23); 00241 FAUDES_TEST_DUMP("OSup3_3",msupab33); 00242 00243 // Prepare graphical output for documentation, I 00244 msupab11.StateNamesEnabled(false); 00245 msupab21.StateNamesEnabled(false); 00246 msupab31.StateNamesEnabled(false); 00247 msupab12.StateNamesEnabled(false); 00248 msupab22.StateNamesEnabled(false); 00249 msupab32.StateNamesEnabled(false); 00250 msupab13.StateNamesEnabled(false); 00251 msupab23.StateNamesEnabled(false); 00252 msupab33.StateNamesEnabled(false); 00253 StateMin(msupab11,msupab11); 00254 StateMin(msupab21,msupab21); 00255 StateMin(msupab31,msupab31); 00256 StateMin(msupab12,msupab12); 00257 StateMin(msupab22,msupab22); 00258 StateMin(msupab32,msupab32); 00259 StateMin(msupab13,msupab13); 00260 StateMin(msupab23,msupab23); 00261 StateMin(msupab33,msupab33); 00262 00263 // Prepare graphical output II 00264 //msupab11.Write("tmp_syn_2_msupab11.gen"); 00265 //msupab21.Write("tmp_syn_2_msupab21.gen"); 00266 msupab31.Write("tmp_syn_2_msupab31.gen"); 00267 //msupab12.Write("tmp_syn_2_msupab12.gen"); 00268 //msupab22.Write("tmp_syn_2_msupab22.gen"); 00269 msupab32.Write("tmp_syn_2_msupab32.gen"); 00270 //msupab13.Write("tmp_syn_2_msupab13.gen"); 00271 //msupab23.Write("tmp_syn_2_msupab23.gen"); 00272 msupab33.Write("tmp_syn_2_msupab33.gen"); 00273 00274 00275 ///////////////////////////////////////////// 00276 // Debugging/testing examples 00277 ///////////////////////////////////////////// 00278 00279 // Read example plant and spec 00280 System ex1plant("data/wplant1.gen"); 00281 Generator ex1spec("data/wspec1.gen"); 00282 00283 // Run omega synthesis procedure 00284 Generator ex1super; 00285 OmegaSupConNB(ex1plant,ex1spec,ex1super); 00286 Generator ex1controller; 00287 OmegaConNB(ex1plant,ex1spec,ex1controller); 00288 00289 // verify 00290 bool cntr1 = IsControllable(ex1plant,ex1controller); 00291 bool closed1 = IsRelativelyOmegaClosed(ex1plant,ex1controller); 00292 00293 // Prepare graphical output for documentation 00294 ex1plant.Write("tmp_syn_2_wplant1.gen"); 00295 ex1spec.Write("tmp_syn_2_wspec1.gen"); 00296 ex1super.StateNamesEnabled(false); 00297 ex1super.Write("tmp_syn_2_wsuper1.gen"); 00298 00299 // Report result to console 00300 std::cout << "################################\n"; 00301 std::cout << "# extended omega synthesis example 1 \n"; 00302 ex1super.DWrite(); 00303 ex1controller.DWrite(); 00304 std::cout << "prefix controllability: " << cntr1 << std::endl; 00305 std::cout << "rel. top. closed: " << closed1 << std::endl; 00306 std::cout << "################################\n"; 00307 00308 00309 // Read example plant and spec 00310 System ex2plant("data/wplant2.gen"); 00311 Generator ex2spec("data/wspec2.gen"); 00312 00313 // Fix spec alphabet 00314 InvProject(ex2spec,ex2plant.Alphabet()); 00315 00316 // Run omega synthesis procedure 00317 Generator ex2super; 00318 OmegaSupConNB(ex2plant,ex2spec,ex2super); 00319 Generator ex2controller; 00320 OmegaConNB(ex2plant,ex2spec,ex2controller); 00321 00322 // verify 00323 bool cntr2 = IsControllable(ex2plant,ex2controller); 00324 bool closed2 = IsRelativelyOmegaClosed(ex2plant,ex2controller); 00325 00326 // Report result to console 00327 std::cout << "################################\n"; 00328 std::cout << "# extended omega synthesis example 2 \n"; 00329 ex2super.DWrite(); 00330 ex2controller.DWrite(); 00331 std::cout << "prefix controllability: " << cntr2 << std::endl; 00332 std::cout << "rel. top. closed: " << closed2 << std::endl; 00333 std::cout << "################################\n"; 00334 00335 // Prepare graphical aoutput for documentation 00336 ex2plant.Write("tmp_syn_2_wplant2.gen"); 00337 ex2spec.Write("tmp_syn_2_wspec2.gen"); 00338 ex2super.StateNamesEnabled(false); 00339 ex2super.Write("tmp_syn_2_wsuper2.gen"); 00340 00341 // Read example plant and spec 00342 System ex3plant("data/wplant3.gen"); 00343 Generator ex3spec("data/wspec3.gen"); 00344 00345 // Run omega synthesis procedure 00346 Generator ex3super; 00347 OmegaSupConNormNB(ex3plant,ex3spec,ex3super); 00348 StateMin(ex3super, ex3super); 00349 Generator ex3controller; 00350 OmegaConNormNB(ex3plant,ex3spec,ex3controller); 00351 StateMin(ex3controller, ex3controller); 00352 00353 // verify 00354 bool cntr3 = IsControllable(ex3plant,ex3controller); 00355 bool closed3 = IsRelativelyOmegaClosed(ex3plant,ex3controller); 00356 Generator ex3plant_loc = ex3plant; 00357 Generator ex3contr_loc = ex3controller; 00358 MarkAllStates(ex3plant_loc); 00359 MarkAllStates(ex3contr_loc); 00360 bool norm3 = IsNormal(ex3plant_loc,ex3plant.ObservableEvents(),ex3contr_loc); 00361 00362 00363 // Report result to console 00364 std::cout << "################################\n"; 00365 std::cout << "# extended omega synthesis example 3 \n"; 00366 ex3super.DWrite(); 00367 ex3controller.DWrite(); 00368 std::cout << "prefix controllability: " << cntr3 << std::endl; 00369 std::cout << "prefix normality : " << norm3 << std::endl; 00370 std::cout << "rel. top. closed: " << closed3 << std::endl; 00371 std::cout << "################################\n"; 00372 00373 // Prepare graphical aoutput for documentation 00374 ex3plant.Write("tmp_syn_2_wplant3.gen"); 00375 ex3spec.Write("tmp_syn_2_wspec3.gen"); 00376 ex3super.StateNamesEnabled(false); 00377 ex3super.Write("tmp_syn_2_wsuper3.gen"); 00378 ex3controller.StateNamesEnabled(false); 00379 ex3controller.Write("tmp_syn_2_wcontr3.gen"); 00380 00381 FAUDES_TEST_DUMP("ex1super",ex1super); 00382 FAUDES_TEST_DUMP("ex1controller",ex1controller); 00383 FAUDES_TEST_DUMP("ex2super",ex2super); 00384 FAUDES_TEST_DUMP("ex2controller",ex2controller); 00385 FAUDES_TEST_DUMP("ex3super",ex3super); 00386 FAUDES_TEST_DUMP("ex3controller",ex3controller); 00387 00388 return 0; 00389 } 00390 libFAUDES 2.23h --- 2014.04.03 --- c++ api documentaion by doxygen |