00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #ifndef _adevs_dess_h_
00021 #define _adevs_dess_h_
00022 #include "adevs_models.h"
00023
00024 namespace adevs
00025 {
00026
00038 template <class X> class DESS: public Atomic<X>
00039 {
00040 public:
00042 DESS();
00048 virtual void evolve_func(double h) = 0;
00056 virtual double next_event_func(bool& is_event) = 0;
00061 virtual void discrete_action_func(const Bag<X>& xb) = 0;
00067 virtual void discrete_output_func(Bag<X>& yb) = 0;
00077 virtual void state_changed() = 0;
00079 void delta_int();
00081 void delta_ext(double e, const Bag<X>& xb);
00083 void delta_conf(const Bag<X>& xb);
00085 void output_func(Bag<X>& yb);
00087 double ta();
00089 virtual ~DESS(){}
00090
00091 private:
00092
00093 double sigma;
00094
00095 enum { DESS_STEP, DESS_EVENT, DESS_OUTPUT } phase;
00096
00097 Bag<X> empty_bag;
00098
00099 Bag<X> ytmp;
00100 };
00101
00102 template <class X>
00103 DESS<X>::DESS()
00104 {
00105 sigma = 0.0;
00106 phase = DESS_STEP;
00107 }
00108
00109 template <class X>
00110 void DESS<X>::delta_int()
00111 {
00112 if (phase == DESS_OUTPUT)
00113 {
00114 ytmp.clear();
00115 bool event = false;
00116 sigma = next_event_func(event);
00117 if (event) phase = DESS_EVENT;
00118 else phase = DESS_STEP;
00119 }
00120 else
00121 {
00122
00123 evolve_func(sigma);
00124
00125 state_changed();
00126
00127 if (phase == DESS_EVENT)
00128 {
00129
00130 discrete_output_func(ytmp);
00131
00132 discrete_action_func(empty_bag);
00133
00134 state_changed();
00135 phase = DESS_OUTPUT;
00136 sigma = 0.0;
00137 }
00138
00139
00140 else
00141 {
00142 bool event = false;
00143 sigma = next_event_func(event);
00144 if (event) phase = DESS_EVENT;
00145 else phase = DESS_STEP;
00146 }
00147 }
00148 }
00149
00150 template <class X>
00151 void DESS<X>::delta_ext(double e, const Bag<X>& xb)
00152 {
00153
00154 evolve_func(e);
00155
00156 state_changed();
00157
00158 discrete_action_func(xb);
00159
00160 state_changed();
00161
00162 bool event = false;
00163 sigma = next_event_func(event);
00164 if (event) phase = DESS_EVENT;
00165 else phase = DESS_STEP;
00166 }
00167
00168 template <class X>
00169 void DESS<X>::delta_conf(const Bag<X>& xb)
00170 {
00171
00172
00173 if (phase == DESS_OUTPUT || phase == DESS_STEP)
00174 {
00175 ytmp.clear();
00176 delta_ext(sigma,xb);
00177 }
00178
00179
00180 else if (phase == DESS_EVENT)
00181 {
00182
00183 evolve_func(sigma);
00184
00185 state_changed();
00186
00187 discrete_output_func(ytmp);
00188
00189 discrete_action_func(xb);
00190
00191 state_changed();
00192
00193 phase = DESS_OUTPUT;
00194 sigma = 0.0;
00195 }
00196 }
00197
00198 template <class X>
00199 void DESS<X>::output_func(Bag<X>& yb)
00200 {
00201 typename Bag<X>::iterator iter = ytmp.begin();
00202 for (; iter != ytmp.end(); iter++)
00203 {
00204 yb.insert(*iter);
00205 }
00206 }
00207
00208 template <class X>
00209 double DESS<X>::ta()
00210 {
00211 return sigma;
00212 }
00213
00214 }
00215
00216 #endif