MatlabTCT Documentation

MatlabTTCT Documentation

allevents

creates one-state DES selfloop with all the events of DES

  • Input: DES1 (automaton)
  • Output: DES2 (automaton)
  • Code:
create('DES1', Q, delta, Qm);
allevents('DES2','DES1');

complement

creates of the marked language complementary to the marked language of DES

  • Input: DES1 (automaton), events (AUXILIARY-EVENTS)
  • Output: DES2 (automaton)
  • Code:
create('DES1', Q, delta, Qm);
complement('DES2','DES1',events);

condat

returns control data DAT for the supervisor DES2 of the controlles system DES1 (a .DAT file)

  • Input: DES1 (automaton), DES2 (automaton)
  • Output: DAT1
  • Code:
create('DES1', Q, delta, Qm);
create('DES2', Q2, delta2, Qm2);
condat('DAT1','DES1','DES2');

create

creates an automaton model of DES (a .DES file)

  • Input: Q (number of states), Qm (marker states), delta (state transitions)
  • Output: MYDES (automaton)
  • Code:
Q = 5; %number of states; sequentially numbered: 0 (initial state),1,...,4
Qm = [0,1]; %marker states
delta = [0,11,1; 1,10,0; 1,12,2; 2,14,3; 2,13,0; 0,15,4]; %transition triples (exit state, event, enter state)
create('MYDES', Q, delta, Qm); %create automaton MYDES.DES

displaydes

Convert a DES file to a GIF file and display it

  • Input: MYDES (automaton)
  • Output: MYDES.GIF (image)
  • Code:
create('MYDES', Q, delta, Qm);
figure(1);
displaydes('MYDES');

displaytxt

display TXT file

  • Input: MYDES
  • Output:
  • Code:
create('MYDES', Q, delta, Qm);
printdes('MYDES');
displaytxt('MYDES');

exlocalize

  • Input: SUPDES, PLANTDES, [Single event] or [Eventlist], MODE(Select the algorithm for computing, please use 1), IS_SINGLE(typt of event list. [Single event]=0 / [Event ist]=1) ;
  • Output: Local Controller LOCDES;
  • Code:
exlocalize('LOCDES', [Single event]/[Eventlist], 'PLANTDES', 'SUPDES', 1, 0/1)

force

modify a DES by the insertion of a new timeout event

  • Input: DES1 (automaton), events1 (FORCIBLE EVENTS), events2 (PREEMPTIBLE EVENTS), events3 (TIMEOUT EVENT)
  • Output: DES2 (automaton)
  • Code:
create('DES1', Q, delta, Qm);
force('DES2','DES1',events1,events2,events3);

getevent

  • Input: DES
  • Output: EVENTLIST
  • Code:
trans(EVENTLIST, 'DES');

isomorph

tests whether DES1 and DES2 are identical up to renumbering of states

  • Input: DES1 (automaton), DES2 (automaton)
  • Output: boolean (true or false)
  • Code:
create('DES1', Q, delta, Qm);
create('DES2', Q, delta, Qm);
isomorph('DES1','DES2');

localize

is the set of localizations of SUPER to the k independent components

  • Input: PLANTDES, PLANTDES1(component in PLANT),...,PLANTDESk(component in PLANT), SUPDES;
  • Output:Local Controllers LOCDES1,...,LOCDESk;
  • Code:
localize({'LOCDES1',...,'LOCDESk'}, 'PLANTDES', {'PLANTDES1',...,'PLANTDESk'}, 'SUPDES');

meet

creates a reachable cartesian product DES

  • Input: DES1 (automaton), DES2 (automaton), ... ,DESk (automaton)
  • Output: DES (automaton)
  • Code:
create('DES1', Q, delta, Qm);
create('DES2', Q, delta, Qm);
meet('DES','DES1','DES2',...,'DESk');

minstate

creates a minimal-state DES that generates the same closed and marked language as DES1

  • Input: DES1 (automaton)
  • Output: DES2 (automaton)
  • Code:
create('DES1', Q, delta, Qm);
minstate('DES2','DES1');

mutex

is formed by excluding the state pair from the product of DES1 and DES2

  • Input: DES1 (automaton), DES2 (automaton), pair_state(EXCLUDED STATE PAIRS)
  • Output: DES3 (automaton)
  • Code:
create('DES1', Q, delta, Qm);
create('DES2', Q, delta, Qm);
pair_state = [1,1;1,2]; %EXCLUDED-STATE-PAIRS
mutex('DES3','DES1','DES2',pair_state);

natobs

returns a natural projection DES2 of DES1, with (allevents) image representation DES3

  • Input: DES1, EVENTLIST
  • Output: DES2, DES3
  • Code:
natobs('DES2','DES3', 'DES1', EVENTLIST);

nonconflict

tests whether DES1, DES2 are nonconflicting

  • Input: DES1 (automaton), DES2 (automaton)
  • Output: boolean (true or false)
  • Code:
nonconflict((true or false), 'DES1','DES2');

observable

  • Input: DES1, DES2, MODE(Test for observability[1] or strong observability[2]), EVENTLIST(list of event labels erased)
  • Output: boolean (true or false)
  • Code:
observable((true or false), 'DES1', 'DES2', MODE, EVENTLIST);

printdat

Convert a DAT file to a TXT file

  • Input: MYDAT
  • Output: MYDAT.TXT
  • Code:
printdat('MYDAT');

printdes

Convert a DES file to a TXT file

  • Input: MYDES
  • Output: MYDES.TXT
  • Code:
printdes('MYDES');

project

generates projected, closed and marked languages of DES

  • Input: DES1, EVENTLIST(list of event labels erased)
  • Output: DES2
  • Code:
project('DES2', 'DES1', EVENTLIST)

recode

  • Input: DES1
  • Output: DES2
  • Code:
recode('DES2', 'DES1')

relabel

generates the relabeled closed mand marked behaviors of DES

  • Input: DES1, EVENTLIST [OLD-NEW EVENT LABEL PAIRS]
  • Output: DES2
  • Code:
Relabel('DES2', 'DES1', EVENLIST)

selfloop

add specific loop transitions to automaton

  • Input: G, EVENTLIST
  • Output: SG
  • Code:
selfloop('SG', 'G', EVENTLIST)

supcon

generate trims for the supremal controllable sublanguage of the marked legal language generated by DES2 for plant DES1

  • Input: SPEC(automaton; the marked legal language), PLANT(automaton; the synthesis of all components.)
  • Output: SUPDES(automaton; the supervisor)
  • Code:
create('PLANT', Q, delta, Qm); % create PLANT automaton
create('E', Q, delta, Qm); % create SPECIFICATION automaton
allevents('ALL', 'PLANT');
sync('SPEC', 'E', 'ALL');
supcon('SUPDES', 'PLANT', 'SPEC');

supconrobs

Generate trims for the supremal controllable and relatively observable sublanguage of the marked legal language generated by DES2 for plant DES1

  • Input: G, K, IMAGE
  • Output: SUPCRO
  • Code:
supconrobs('SUPCRO', 'G', 'K', IMAGE)

supnorm

is a trim DES which represents the supremal sublanguage of the legal language represented by DES2, that is normal with respect to the marked behavior of the plant generator DES1

  • Input:G, K, IMAGE
  • Output: SUPN
  • Code:
supnorm('SUPN', 'G', 'K', IMAGE)

supqc

  • Input: G, IMAGE
  • Output: SUPQC
  • Code:
supqc('SUPQC', 'G', IMAGE)

supreduce

is a reduced supervisor for plant DES1 which is control-equivalent to DES2

  • Input: G, SUP, CONDAT
  • Output: SIM
  • Code:
supreduce('SIM', 'G', 'SUP', CONDAT)

suprobs

is a trim DES which represents the supremal relatively observable sublanguage of the language represented by DES2, with respect to the plant DES1

  • Input: G, K, IMAGE
  • Output: SUPRO
  • Code:
suprobs('SUPRO', 'G', 'K', IMAGE)

supscop

is a trim DES which represents the supremal normal solution to the Supervisory Control and Observation Problem (SCOP), corresponding to the plant DES1, legal language DES2, and specified natural projection

  • Input: G, K, IMAGE
  • Output: SUPCN
  • Code:
supscop('supcn', 'G', 'K', IMAGE)

sync

is the (reachable) synchronous product of DES1,DES2,...,DESk. DES need not be coreachable

  • Input: DES1 (automaton), DES2 (automaton), ... ,DESk (automaton)
  • Output: DES (automaton)
  • Code:
create('DES1', Q, delta, Qm);
create('DES2', Q, delta, Qm);
sync('DES','DES1','DES2',...,'DESk');

trim

is the trim (reachable and coreachable) substructure of DES1

  • Input: G
  • Output: TG
  • Code:
trim('TG', 'G')

Tallevents

creates one-state TDS selfloop with all the events of TDS

  • Input: TDS1 (automaton)
  • Output: TDS2 (automaton)
  • Code:
Tallevents('TDS2','TDS1');

Tcomp

  • Input: MYADS1; MYADS2
  • Output: ADS3 (ATG)
  • Code:
Tcreate_ATG('MYADS1', Q, delta, Qm, TimeBound, Forcible);
Tcreate_ATG('MYADS2', Q, delta, Qm, TimeBound, Forcible);
Tcomp('ADS3', 'MYADS1', 'MYADS2')

Tcondat

returns control data DAT for the supervisor TDS2 of the controlles system TDS1 (a .DAT file)

  • Input:TDS1 (automaton), TDS2 (automaton)
  • Output: DAT1
  • Code:
Tcondat('DAT1','TDS1','TDS2');

Tcreate_ATG

creates an automaton model of ATG (a .ADS file)

  • Input: Q (number of states), Qm (marker states), delta (state transitions), TimeBound (time bound for each event), Forcible (forcible event list).
  • Output: MYADS (ATG)
  • Code:
Q = 5; %number of states; sequentially numbered: 0 (initial state),1,...,4
Qm = [0,1]; %marker states
delta = [0,11,1; 1,10,0; 1,12,2; 2,14,3; 2,13,0; 0,15,4]; %transition triples (exit state, event, enter state)
TimeBound = [10,0,1; 11,0,1000; 12,0,1; 13,0,1000; 14,0,1; 15,0,1]; %time bound for each event [event label, lower bonud, upper bound].
Forcible = [11,13]%forcible event list.
Tcreate_ATG('MYADS', Q, delta, Qm, TimeBound, Forcible); %create automaton MYADS.ADS

Tcreate_TTG

creates an automaton model of TTG (a .TDS file)

  • Input: Q (number of states), Qm (marker states), delta (state transitions), Forcible (forcible event list).
  • Output: MYTDS (TTG)
  • Code:
Q = 5; %number of states; sequentially numbered: 0 (initial state),1,...,4
Qm = [0,1]; %marker states
delta = [0,11,1; 1,10,0; 1,12,2; 2,14,3; 2,13,0; 0,15,4]; %transition triples (exit state, event, enter state)
Forcible = [11,13]%forcible event list.
Tcreate_TTG('MYTDS', Q, delta, Qm, Forcible); %create automaton MYTDS.TDS

Tisomorph

tests whether TDS1 and TDS2 are identical up to renumbering of states

  • Input: TDS1 (automaton), TDS2 (automaton)
  • Output: boolean (true or false)
  • Code:
Tisomorph('TDS1','TDS2');

Tmeet

creates a reachable cartesian product TDS

  • Input: TDS1 (automaton), TDS2 (automaton), ... ,TDSk (automaton)
  • Output: TDS (automaton)
  • Code:
Tmeet('TDS','TDS1','TDS2',...,'TDSk');

Tminstate

creates a minimal-state TDS that generates the same closed and marked language as TDS1

  • Input: TDS1 (automaton)
  • Output: TDS2 (automaton)
  • Code:
Tminstate('TDS2','TDS1');

Tnatobs

returns a natural projection TDS2 of TDS1, with (allevents) image representation TDS3

  • Input: TDS1, EVENTLIST
  • Output: TDS2, TDS3
  • Code:
Tnatobs('TDS2','TDS3', 'TDS1', EVENTLIST);

Tnonconflict

tests whether TDS1, TDS2 are nonconflicting

  • Input: TDS1 (automaton), TDS2 (automaton)
  • Output: boolean (true or false)
  • Code:
Tnonconflict((true or false), 'TDS1','TDS2');

Tproject

generates projected, closed and marked languages of TDS

  • Input: TDS1, EVENTLIST(list of event labels erased)
  • Output: TDS2
  • Code:
Tproject('TDS2', 'TDS1', EVENTLIST)

Tsupcon

generate trims for the supremal controllable sublanguage of the marked legal language generated by TDS2 for plant TDS1

  • Input: SPEC(automaton; the marked legal language), PLANT(automaton; the synthesis of all components.)
  • Output: SUPTDS(automaton; the supervisor)
  • Code:
Tsupcon('SUPTDS', 'PLANT', 'SPEC');

Tsupreduce

is a reduced supervisor for plant TDS1 which is control-equivalent to TDS2

  • Input: G, SUP, CONDAT
  • Output: SIMSUP
  • Code:
Tsupreduce('SIMSUP', 'G', 'SUP', CONDAT)