A process simulation contains a number of processes that describe the active elements in a model. A process contains a sequence of actions. These actions are timeless. Time consumption is realised with special time-operations. In this example several of this time-operations are presented together with an example process.
//---------------------------------------------------------------------------- // Copyright (C) 2002, 2003 Humboldt-Universitaet zu Berlin // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // //---------------------------------------------------------------------------- #include <odemx/base/Process.h> #include <iostream> using namespace std; using namespace odemx; // // The first Process is a simple SimTime timer. // It does write a '.' every full (1.0) tic in SimTime. // class TimerA : public Process { public: // // We label all instances of this class 'TimerA'. // ODEMx changes the label on its own to prevent // confusion. It will add a number to the label // if more than one Timer is created in the // simulation. This procedure guarantees that // every label is unique in a simulation. // // When we create a Timer object we will have to // provide a pointer to the Simulation we want it // to participate with. // TimerA(Simulation* sim) : Process(sim, "TimerA") {} // // The behaviour of a user process must be defined // by an implementation of the pure virtual function // 'int main()'. The return value of this function // is stored and can be accessed with 'getReturnValue()'. // As long as 'main()' hasn't finished, the return // value is not valid. You can use 'hasReturned()' // to check this condition. // virtual int main() { while (true) { // // We use 'holdFor()' to let the SimTime pass. // 'holdFor()' requires a time period. We could // also use 'activateIn()'. // The difference between these two is seen if // there is more than one process scheduled at // the same time. 'holdFor' would than schedule // the current process as the last while 'activateIn' // would schedule the current process as the first one. // holdFor(1.0); cout << '.'; } return 0; } }; int main(int argc, char* argv[]) { // // For this example we can use the DefaultSimulation. // In more complex applications it is recommended to // provide a custom-made simulation class. // TimerA* myTimer=new TimerA(getDefaultSimulation()); // // The new process is just created by now. // It won't be executed because it is not activated. // A process can be activated by any of these methods: // // 'hold()' // 'holdFor()' // 'holdUntil()' // 'activate()' // 'activateIn()' // 'acitvateAt()' // // 'hold()' and 'activate()' are equal to 'holdFor(0.0)' // and 'activateIn(0.0)'. 'holdUntil(t)' and 'activateAt(t)' // are equal to 'holdFor(t-now)' and 'activateIn(t-now)'. // myTimer->activate(); // // There are three ways to compute a simulation. // Firstly, you can 'run()' the simulation until it is // finished. A simulation is finished if there is no active // process left or it is stopped with 'exitSimulation()'. // Secondly, you can compute a simulation 'step()' by step. // Thirdly, you can run a simulation until a given SimTime is // reached or passed with 'runUntil()'. // // Because TimerA is running for ever we shouldn't use // 'run()'. Instead we try both 'step()' and 'runUntil()'. // cout << "Basic Simulation Example" << endl; cout << "========================" << endl; for (int i=1; i<5; ++i) { getDefaultSimulation()->step(); cout << endl << i << ". step time=" << getDefaultSimulation()->getTime() << endl; } cout << endl; cout << "continue until SimTime 13.0 is reached or passed:"; getDefaultSimulation()->runUntil(13.0); cout << endl << "time=" << getDefaultSimulation()->getTime() << endl; cout << "========================" << endl; return 0; }