Document Scicos Block type 4 structure fields
[scilab.git] / scilab / modules / scicos_blocks / includes / scicos_block4.h
1 /*  Scicos
2 *
3 *  Copyright (C) INRIA - METALAU Project <scicos@inria.fr>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 *
19 * See the file ./license.txt
20 */
21
22 #ifndef __SCICOS_BLOCK4_H__
23 #define __SCICOS_BLOCK4_H__
24
25 #ifndef NULL
26 #define NULL 0
27 #endif
28
29 #include <math.h>
30 #include <assert.h>
31 #include <stdlib.h>
32
33 #ifdef _MSC_VER
34 typedef void (*voidg) ();
35 #else
36 typedef void (*voidg) (void);
37 #endif
38
39 /* scicos_block structure definition
40 * WARNING: take care that this sructure is
41 * not the same as the one in scicos_block.h
42 * i.e same name but inptr and outptr are void **
43 */
44 typedef struct
45 {
46   int nevprt;     // Binary coding of activation inputs, -1 for internal activation (zero crossings)
47   voidg funpt;    // Pointer to the computational function
48   int type;       // Type of the computational function, in this case type 4
49   int scsptr;     // Not used for C programming
50   int nz;         // Size of discrete-time state vector
51   double *z;      // Vector of discrete-time state
52   int noz;        // Number of object states
53   int *ozsz;      // Vector of sizes of object states
54   int *oztyp;     // Vector of data types of object states
55   void **ozptr;   // Table of pointers to object states
56   int nx;         // Size of continuous-time state vector
57   double *x;      // Vector of continuous-time state
58   double *xd;     // Vector of the derivative of the continuous-state, same size nx
59                   // (output for ODE solvers, output for DAE solvers)
60   double *res;    // Vector of residuals, only used for internally implicit blocks, same size nx
61                   // (output of equations for DAE solvers)
62   int *xprop;     // Pointer to the continuous state properties register, only used for internally 
63                   // implicit blocks (-1 for algebraic states, 1 for differential states)
64   int nin;        // Number of regular input ports
65   int *insz;      // Vector of sizes of regular input ports
66   void **inptr;   // Tables of pointer to the regular input ports
67   int nout;       // Number of regular output ports
68   int *outsz;     // Vector of sizes of regular output ports
69   void **outptr;  // Tables of pointers to the regular output ports
70   int nevout;     // Number of event output ports
71   double *evout;  // Delay time of output events
72   int nrpar;      // Size of real parameters vector
73   double *rpar;   // Vector of real parameters
74   int nipar;      // Size of integer parameters vector
75   int *ipar;      // Vector of integer parameters
76   int nopar;      // Number of object parameters
77   int *oparsz;    // Vector of sizes of object parameters
78   int *opartyp;   // Vector of data types of object parameters
79   void **oparptr; // Table of pointers to the object parameters
80   int ng;         // Size of zero-crossing surfaces vector
81   double *g;      // Vector of zero-crossing surfaces
82   int ztyp;       // Boolean, True only if the block may have zero-crossing surfaces
83   int *jroot;     // Vector of size ng indicates the presence and the direction of the crossing
84   char *label;    // Block label
85   void **work;    // Table of pointers to the block workspace (if allocation done by the block)
86   int nmode;      // Size of modes vector
87   int *mode;      // Vector of modes (used to handle discontinuities)
88   char *uid;
89 } scicos_block;
90
91 /** define scicos flag number */
92 typedef enum
93 {
94     /* Should not be used directly, set through the API. */
95     CosError = -5,
96
97     /* Valid simulation states */
98     DerivativeState = 0,
99     OutputUpdate = 1,
100     StateUpdate = 2,
101     OutputEventTiming = 3,
102     Initialization = 4,
103     Ending = 5,
104     ReInitialization = 6,
105     ContinuousPropertiesUpdate = 7,
106     ZeroCrossing = 9,
107     Jacobian = 10
108 } scicos_flag;
109
110 /* utility function for block declaration */
111 int get_block_error(void);
112 int *get_pointer_xproperty(void);
113 int get_npointer_xproperty(void);
114 double Get_Jacobian_cj(void);
115 double Get_Jacobian_ci(void);
116 double Get_Scicos_SQUR(void);
117 void Set_Jacobian_flag(int flag);
118
119 int Convert_number(char *, double *);
120 void homotopy(double *);
121 int hfjac_(double *, double *, int *);
122 int rhojac_(double *, double *, double *, double *, int *, double *, int *);
123 int rho_(double *, double *, double *, double *, double *, int *);
124 int fx_(double *, double *);
125 int read_xml_initial_states(int nvar, const char *xmlfile, char **ids, double *svars);
126 int write_xml_states(int, const char *, char **, double *);
127
128 /** Define scicos simulator data type number (_N) */
129 typedef enum
130 {
131     SCSREAL_N = 10,
132     SCSCOMPLEX_N = 11,
133     SCSINT_N = 80,
134     SCSINT8_N = 81,
135     SCSINT16_N = 82,
136     SCSINT32_N = 84,
137     SCSUINT_N = 800,
138     SCSUINT8_N = 811,
139     SCSUINT16_N = 812,
140     SCSUINT32_N = 814,
141     SCSUNKNOW_N = -1
142 } scicos_datatype_number;
143
144 /* Define scicos simulator data type C operators (_COP) */
145 #define SCSREAL_COP double
146 #define SCSCOMPLEX_COP double
147 #define SCSINT_COP int
148 #define SCSINT8_COP char
149 #define SCSINT16_COP short
150 #define SCSINT32_COP int
151 #define SCSUINT_COP unsigned int
152 #define SCSUINT8_COP unsigned char
153 #define SCSUINT16_COP unsigned short
154 #define SCSUINT32_COP unsigned int
155 #define SCSUNKNOW_COP double
156
157 /** \name Getters
158  *  These macros should be used to ease programming and debugging of new blocks.
159  */
160 ///@{
161
162 /**
163 \brief Get number of regular input port.
164 */
165 #define GetNin(blk) (blk->nin)
166
167 /**
168 \brief Get regular input port pointer of port number x.
169 */
170 #define GetInPortPtrs(blk,x) (assert((x)>0), assert((x)<=(blk->nin)), blk->inptr[(x)-1])
171
172 /**
173 \brief Get number of regular output port.
174 */
175 #define GetNout(blk) (blk->nout)
176
177 /**
178 \brief Get regular output port pointer of port number x.
179 */
180 #define GetOutPortPtrs(blk,x) (assert((x)>0), assert((x)<=(blk->nout)), blk->outptr[x-1])
181
182 /**
183 \brief Get number of rows (first dimension) of regular input port number x.
184 */
185 #define GetInPortRows(blk,x) (assert((x)>0), assert((x)<=(blk->nin)), blk->insz[x-1])
186
187 /**
188 \brief Get number of columns (second dimension) of regular input port number x.
189 */
190 #define GetInPortCols(blk,x) (assert((x)>0), assert((x)<=(blk->nin)), blk->insz[blk->nin+(x-1)])
191
192 /**
193 \brief Get regular input port size number x.
194 *   GetInPortSize(blk,x,1) : get first dimension of input port number x
195 *   GetInPortSize(blk,x,2) : get second dimension of input port number x
196 */
197 #define GetInPortSize(blk,x,y) (assert((x)>0), assert((x)<=(blk->nin)), \
198         assert((y)>0), assert((y)<=2), blk->insz[(y-1)*blk->nin+(x-1)])
199
200 /**
201 \brief Get type of regular input port number x.
202 */
203 #define GetInType(blk,x) (assert((x)>0), assert((x)<=(blk->nin)), \
204         blk->insz[2*(blk->nin)+(x-1)])
205
206 /**
207 \brief Get number of rows (first dimension) of regular output port number x.
208 */
209 #define GetOutPortRows(blk,x) (assert((x)>0), assert((x)<=(blk->nout)), blk->outsz[x-1])
210
211 /**
212 \brief Get number of columns (second dimension) of regular output port number x.
213 */
214 #define GetOutPortCols(blk,x) (assert((x)>0), assert((x)<=(blk->nout)), blk->outsz[blk->nout+(x-1)])
215
216 /**
217 \brief Get regular output port size number x.
218 *   GetOutPortSize(blk,x,1) : get first dimension of output port number x
219 *   GetOutPortSize(blk,x,2) : get second dimension of output port number x
220 */
221 #define GetOutPortSize(blk,x,y) (assert((x)>0), assert((x)<=(blk->nout)), \
222     assert((y)>0), assert((y)<=2), blk->outsz[(y-1)*blk->nout+(x-1)])
223
224 /**
225 \brief Get type of regular output port number x.
226 */
227 #define GetOutType(blk,x) (assert((x)>0), assert((x)<=(blk->nout)), \
228         blk->outsz[2*(blk->nout)+(x-1)])
229
230 /**
231 \brief Get pointer of real part of regular input port number x.
232 */
233 #define GetRealInPortPtrs(blk,x) (SCSREAL_COP *) GetInPortPtrs(blk,x)
234
235 /**
236 \brief Get pointer of imaginary part of regular input port number x.
237 */
238 #define GetImagInPortPtrs(blk,x) (assert((x)>0), assert((x)<=(blk->nin)), \
239         (SCSREAL_COP *) ((SCSREAL_COP *)blk->inptr[x-1]+ \
240         ((blk->insz[(x-1)])*(blk->insz[blk->nin+(x-1)]))))
241
242 /**
243 \brief Get pointer of real part of regular output port number x.
244 */
245 #define GetRealOutPortPtrs(blk,x) (SCSREAL_COP *) GetOutPortPtrs(blk,x)
246
247 /**
248 \brief Get pointer of imaginary part of regular output port number x.
249 */
250 #define GetImagOutPortPtrs(blk,x) (assert((x)>0), assert((x)<=(blk->nout)), \
251         (SCSREAL_COP *) ((SCSREAL_COP *)blk->outptr[x-1]+ \
252         ((blk->outsz[(x-1)])*(blk->outsz[blk->nout+(x-1)]))))
253
254 /**
255 \brief Get pointer of int8 typed regular input port number x.
256 */
257 #define Getint8InPortPtrs(blk,x) (SCSINT8_COP *) GetInPortPtrs(blk,x)
258
259 /**
260 \brief Get pointer of int16 typed regular input port number x.
261 */
262 #define Getint16InPortPtrs(blk,x) (SCSINT16_COP *) GetInPortPtrs(blk,x)
263
264 /**
265 \brief Get pointer of int32 typed regular input port number x.
266 */
267 #define Getint32InPortPtrs(blk,x) (SCSINT32_COP *) GetInPortPtrs(blk,x)
268
269 /**
270 \brief Get pointer of uint8 typed regular input port number x.
271 */
272 #define Getuint8InPortPtrs(blk,x) (SCSUINT8_COP *) GetInPortPtrs(blk,x)
273
274 /**
275 \brief Get pointer of uint16 typed regular input port number x.
276 */
277 #define Getuint16InPortPtrs(blk,x) (SCSUINT16_COP *) GetInPortPtrs(blk,x)
278
279 /**
280 \brief Get pointer of uint32 typed regular input port number x.
281 */
282 #define Getuint32InPortPtrs(blk,x) (SCSUINT32_COP *) GetInPortPtrs(blk,x)
283
284 /**
285 \brief Get pointer of int8 typed regular output port number x.
286 */
287 #define Getint8OutPortPtrs(blk,x) (SCSINT8_COP *) GetOutPortPtrs(blk,x)
288
289 /**
290 \brief Get pointer of int16 typed regular output port number x.
291 */
292 #define Getint16OutPortPtrs(blk,x) (SCSINT16_COP *) GetOutPortPtrs(blk,x)
293
294 /**
295 \brief Get pointer of int32 typed regular output port number x.
296 */
297 #define Getint32OutPortPtrs(blk,x) (SCSINT32_COP *) GetOutPortPtrs(blk,x)
298
299 /**
300 \brief Get pointer of uint8 typed regular output port number x.
301 */
302 #define Getuint8OutPortPtrs(blk,x) (SCSUINT8_COP *) GetOutPortPtrs(blk,x)
303
304 /**
305 \brief Get pointer of uint16 typed regular output port number x.
306 */
307 #define Getuint16OutPortPtrs(blk,x) (SCSUINT16_COP *) GetOutPortPtrs(blk,x)
308
309 /**
310 \brief Get pointer of uint32 typed regular output port number x.
311 */
312 #define Getuint32OutPortPtrs(blk,x) (SCSUINT32_COP *) GetOutPortPtrs(blk,x)
313
314 /**
315 \brief Get number of integer parameters.
316 */
317 #define GetNipar(blk) (blk->nipar)
318
319 /**
320 \brief Get pointer of the integer parameters register
321 */
322 #define GetIparPtrs(blk) (blk->ipar)
323
324 /**
325 \brief Get number of real parameters.
326 */
327 #define GetNrpar(blk) (blk->nrpar)
328
329 /**
330 \brief Get pointer of the real parameters register.
331 */
332 #define GetRparPtrs(blk) (blk->rpar)
333
334 /**
335 \brief Get the pointer of the Work array.
336 */
337 #define GetWorkPtrs(blk) (*(blk->work))
338
339 /**
340 \brief Get number of continuous state.
341 */
342 #define GetNstate(blk) (blk->nx)
343
344 /**
345 \brief Get pointer of the continuous state register.
346 */
347 #define GetState(blk) (blk->x)
348
349 /**
350 \brief Get pointer of the derivative continuous state register.
351 */
352 #define GetDerState(blk) (blk->xd)
353
354 /**
355 \brief Get pointer of the residual continuous state register.
356 */
357 #define GetResState(blk) (blk->res)
358
359 /**
360 \brief Get pointer of continuous state properties register.
361 */
362 #define GetXpropPtrs(blk) (blk->xprop)
363
364 /**
365 \brief Get number of discrete state.
366 */
367 #define GetNdstate(blk) (blk->nz)
368
369 /**
370 \brief Get pointer of the discrete state register.
371 */
372 #define GetDstate(blk) (blk->z)
373
374 /**
375 \brief Get the input event number.
376 */
377 #define GetNevIn(blk) (blk->nevprt)
378
379 /**
380 \brief Get number of event output port.
381 */
382 #define GetNevOut(blk) (blk->nevout)
383
384 /**
385 \brief Get pointer of event output register.
386 */
387 #define GetNevOutPtrs(blk) (blk->evout)
388
389 /**
390 \brief Get number of object parameters.
391 */
392 #define GetNopar(blk) (blk->nopar)
393
394 /**
395 \brief Get type of object parameters number x.
396 */
397 #define GetOparType(blk,x) (assert(x>0), assert(x<=blk->nopar), blk->opartyp[x-1])
398
399 /**
400 \brief Get size of object parameters number x.
401 *   GetOparSize(blk,x,1) : get first dimension of opar
402 *   GetOparSize(blk,x,2) : get second dimension of opar
403 */
404 #define GetOparSize(blk,x,y) (assert((x)>0), assert(x<=blk->nopar), \
405     assert((y)>0), assert((y)<=2), blk->oparsz[(y-1)*blk->nopar+(x-1)])
406
407 /**
408 \brief Get pointer of object parameters number x.
409 */
410 #define GetOparPtrs(blk,x) (assert((x)>0), assert((x)<=(blk)->nopar), (blk)->oparptr[(x)-1])
411
412 /**
413 \brief Get pointer of real object parameters number x.
414 */
415 #define GetRealOparPtrs(blk,x) (SCSREAL_COP *) GetOparPtrs(blk,x)
416
417 /**
418 \brief Get pointer of imaginary part of object parameters number x.
419 */
420 #define GetImagOparPtrs(blk,x) (assert((x)>0), assert((x)<=(blk->nopar)), \
421         (SCSREAL_COP *) ((SCSREAL_COP *)blk->oparptr[x-1]+ \
422         ((blk->oparsz[x-1])*(blk->oparsz[blk->nopar+(x-1)])))
423
424 /**
425 \brief Get pointer of int8 typed object parameters number x.
426 */
427 #define Getint8OparPtrs(blk,x) (SCSINT8_COP *) GetOparPtrs(blk,x)
428
429 /**
430 \brief Get pointer of int16 typed object parameters number x.
431 */
432 #define Getint16OparPtrs(blk,x) (SCSINT16_COP *) GetOparPtrs(blk,x)
433
434 /**
435 \brief Get pointer of int32 typed object parameters number x.
436 */
437 #define Getint32OparPtrs(blk,x) (SCSINT32_COP *) GetOparPtrs(blk,x)
438
439 /**
440 \brief Get pointer of uint8 typed object parameters number x.
441 */
442 #define Getuint8OparPtrs(blk,x) (SCSUINT8_COP *) GetOparPtrs(blk,x)
443
444 /**
445 \brief Get pointer of uint16 typed object parameters number x.
446 */
447 #define Getuint16OparPtrs(blk,x) (SCSUINT16_COP *) GetOparPtrs(blk,x)
448
449 /**
450 \brief Get pointer of uint32 typed object parameters number x.
451 */
452 #define Getuint32OparPtrs(blk,x) (SCSUINT32_COP *) GetOparPtrs(blk,x)
453
454 /**
455 \brief Get number of object state.
456 */
457 #define GetNoz(blk) (blk->noz)
458
459 /**
460 \brief Get type of object state number x.
461 */
462 #define GetOzType(blk,x) (assert((x)>0), assert((x)<=(blk)->noz), (blk)->oztyp[(x)-1])
463
464 /**
465 \brief Get size of object state number x.
466 *   GetOzSize(blk,x,1) : get first dimension of oz
467 *   GetOzSize(blk,x,2) : get second dimension of oz
468 */
469 #define GetOzSize(blk,x,y) (assert((x)>0), assert((x)<=(blk)->noz), \
470         assert((y)>0), assert((y)<=2), (blk)->ozsz[((y)-1)*(blk)->noz+((x)-1)])
471
472 /**
473 \brief Get pointer of object state number x.
474 */
475 #define GetOzPtrs(blk,x) (assert((x)>0), assert((x)<=(blk)->noz), (blk)->ozptr[(x)-1])
476
477 /**
478 \brief Get pointer of real object state number x.
479 */
480 #define GetRealOzPtrs(blk,x) (SCSREAL_COP *) GetOzPtrs(blk,x)
481
482 /**
483 \brief Get pointer of imaginary part of object state number x.
484 */
485 #define GetImagOzPtrs(blk,x) (assert((x)>0), assert((x)<=(blk)->noz), \
486         (SCSREAL_COP *) ((SCSREAL_COP *)blk->ozptr[x-1]+ \
487         ((blk->ozsz[x-1])*(blk->ozsz[blk->noz+(x-1)])))
488
489 /**
490 \brief Get pointer of int8 typed object state number x.
491 */
492 #define Getint8OzPtrs(blk,x) (SCSINT8_COP *) GetOzPtrs(blk,x)
493
494 /**
495 \brief Get pointer of int16 typed object state number x.
496 */
497 #define Getint16OzPtrs(blk,x) (SCSINT16_COP *) GetOzPtrs(blk,x)
498
499 /**
500 \brief Get pointer of int32 typed object state number x.
501 */
502 #define Getint32OzPtrs(blk,x) (SCSINT32_COP *) GetOzPtrs(blk,x)
503
504 /**
505 \brief Get pointer of uint8 typed object state number x.
506 */
507 #define Getuint8OzPtrs(blk,x) (SCSUINT8_COP *) GetOzPtrs(blk,x)
508
509 /**
510 \brief Get pointer of uint16 typed object state number x.
511 */
512 #define Getuint16OzPtrs(blk,x) (SCSUINT16_COP *) GetOzPtrs(blk,x)
513
514 /**
515 \brief Get pointer of uint32 typed object state number x.
516 */
517 #define Getuint32OzPtrs(blk,x) (SCSUINT32_COP *) GetOzPtrs(blk,x)
518
519 /**
520 \brief Get the sizeof of the object state number x.
521 */
522 #define GetSizeOfOz(blk,x)    ((GetOzType(blk,x)==SCSREAL_N) ? (sizeof(SCSREAL_COP)) : \
523         (GetOzType(blk,x)==SCSCOMPLEX_N) ? (2*sizeof(SCSCOMPLEX_COP)) : \
524         ((GetOzType(blk,x)==SCSINT8_N)|(GetOzType(blk,x)==SCSUINT8_N)) ? (sizeof(SCSINT8_COP)) : \
525         ((GetOzType(blk,x)==SCSINT16_N)|(GetOzType(blk,x)==SCSUINT16_N)) ? (sizeof(SCSINT16_COP)) : \
526         ((GetOzType(blk,x)==SCSINT32_N)|(GetOzType(blk,x)==SCSUINT32_N)) ? (sizeof(SCSINT32_COP)) : 0)
527
528 /**
529 \brief Get the sizeof of the object parameters number x.
530 */
531 #define GetSizeOfOpar(blk,x)  ((GetOparType(blk,x)==SCSREAL_N) ? (sizeof(SCSREAL_COP)) : \
532         (GetOparType(blk,x)==SCSCOMPLEX_N) ? (2*sizeof(SCSCOMPLEX_COP)) : \
533         ((GetOparType(blk,x)==SCSINT8_N)|(GetOparType(blk,x)==SCSUINT8_N)) ? (sizeof(SCSINT8_COP)) : \
534         ((GetOparType(blk,x)==SCSINT16_N)|(GetOparType(blk,x)==SCSUINT16_N)) ? (sizeof(SCSINT16_COP)) : \
535         ((GetOparType(blk,x)==SCSINT32_N)|(GetOparType(blk,x)==SCSUINT32_N)) ? (sizeof(SCSINT32_COP)) : 0)
536
537 /**
538 \brief Get the sizeof of the regular output port number x.
539 */
540 #define GetSizeOfOut(blk,x)  ((GetOutType(blk,x)==SCSREAL_N) ? (sizeof(SCSREAL_COP)) : \
541         (GetOutType(blk,x)==SCSCOMPLEX_N) ? (2*sizeof(SCSCOMPLEX_COP)) : \
542         ((GetOutType(blk,x)==SCSINT8_N)|(GetOutType(blk,x)==SCSUINT8_N)) ? (sizeof(SCSINT8_COP)) : \
543         ((GetOutType(blk,x)==SCSINT16_N)|(GetOutType(blk,x)==SCSUINT16_N)) ? (sizeof(SCSINT16_COP)) : \
544         ((GetOutType(blk,x)==SCSINT32_N)|(GetOutType(blk,x)==SCSUINT32_N)) ? (sizeof(SCSINT32_COP)) : 0)
545 /**
546 \brief Get the sizeof of the regular input port number x.
547 */
548 #define GetSizeOfIn(blk,x)  ((GetInType(blk,x)==SCSREAL_N) ? (sizeof(SCSREAL_COP)) : \
549         (GetInType(blk,x)==SCSCOMPLEX_N) ? (2*sizeof(SCSCOMPLEX_COP)) : \
550         ((GetInType(blk,x)==SCSINT8_N)|(GetInType(blk,x)==SCSUINT8_N)) ? (sizeof(SCSINT8_COP)) : \
551         ((GetInType(blk,x)==SCSINT16_N)|(GetInType(blk,x)==SCSUINT16_N)) ? (sizeof(SCSINT16_COP)) : \
552         ((GetInType(blk,x)==SCSINT32_N)|(GetInType(blk,x)==SCSUINT32_N)) ? (sizeof(SCSINT32_COP)) : 0)
553
554 /**
555 \brief Get number of zero crossing surface.
556 */
557 #define GetNg(blk) (blk->ng)
558
559 /**
560 \brief Get pointer of the zero crossing register.
561 */
562 #define GetGPtrs(blk) (blk->g)
563
564 /**
565 \brief Get pointer of the direction of the zero crossing register.
566 */
567 #define GetJrootPtrs(blk) (blk->jroot)
568
569 /**
570 \brief Get number of modes.
571 */
572 #define GetNmode(blk) (blk->nmode)
573
574 /**
575 \brief Get pointer of the mode register.
576 */
577 #define GetModePtrs(blk) (blk->mode)
578
579 /**
580 \brief Get pointer of the block label
581 */
582 #define GetLabelPtrs(blk) (blk->label)
583
584 ///@}
585
586 #endif /* __SCICOS_BLOCK_H__ */
587