Scicos blocks: speedup benchmarks/sciblk4.tst by 2
[scilab.git] / scilab / modules / scicos / src / cpp / createblklist.cpp
1 /*  Scicos
2 *
3 *  Copyright (C) 2015 - Scilab Enterprises - Antoine ELIAS
4 *  Copyright (C) DIGITEO - 2009 - Allan CORNET
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 *
20 * See the file ./license.txt
21 */
22 /*--------------------------------------------------------------------------*/
23 #include "double.hxx"
24 #include "int.hxx"
25 #include "internal.hxx"
26 #include "list.hxx"
27 #include "string.hxx"
28 #include "tlist.hxx"
29
30 extern "C"
31 {
32 #include "import.h"
33 }
34
35 #include "createblklist.hxx"
36 /*--------------------------------------------------------------------------*/
37 static types::InternalType* allocsci(void* data, const int rows, const int cols, const int type)
38 {
39     switch (type)
40     {
41         case SCSREAL_N:
42         {
43             types::Double* var = new types::Double(rows, cols);
44             return var;
45         }
46         case SCSCOMPLEX_N:
47         {
48             types::Double* var = new types::Double(rows, cols, true);
49             return var;
50         }
51         case SCSINT8_N:
52         {
53             types::Int8* var = new types::Int8(rows, cols);
54             return var;
55         }
56         case SCSINT16_N:
57         {
58             types::Int16* var = new types::Int16(rows, cols);
59             return var;
60         }
61         case SCSINT32_N:
62         {
63             types::Int32* var = new types::Int32(rows, cols);
64             return var;
65         }
66         case SCSUINT8_N:
67         {
68             types::UInt8* var = new types::UInt8(rows, cols);
69             return var;
70         }
71         case SCSUINT16_N:
72         {
73             types::UInt16* var = new types::UInt16(rows, cols);
74             return var;
75         }
76         case SCSUINT32_N:
77         {
78             types::UInt32* var = new types::UInt32(rows, cols);
79             return var;
80         }
81         default: // case SCSUNKNOW_N: pass the data by pointers
82         {
83             return (types::InternalType*)data;
84         }
85     }
86 }
87 /*--------------------------------------------------------------------------*/
88 static types::InternalType* vartosci(types::InternalType* pIT, void* data, const int rows, const int cols, const int type)
89 {
90     const int size = rows * cols;
91     switch (type)
92     {
93         case SCSREAL_N:
94         {
95             if (~pIT->isDouble())
96             {
97                 return pIT;
98             }
99             types::Double* var = pIT->getAs<types::Double>();
100             for (int i = 0; i < size; ++i)
101             {
102                 var->get()[i] = ((types::Double::type*)data)[i];
103             }
104             return var;
105         }
106         case SCSCOMPLEX_N:
107         {
108             if (~pIT->isDouble())
109             {
110                 return pIT;
111             }
112             types::Double* var = pIT->getAs<types::Double>();
113             for (int i = 0; i < size; ++i)
114             {
115                 var->get()[i] = ((types::Double::type*)data)[i];
116                 var->getImg()[i] = ((types::Double::type*)data)[size + i];
117             }
118             return var;
119         }
120         case SCSINT8_N:
121         {
122             if (~pIT->isInt8())
123             {
124                 return pIT;
125             }
126             types::Int8* var = pIT->getAs<types::Int8>();
127             for (int i = 0; i < size; ++i)
128             {
129                 var->get()[i] = ((types::Int8::type*)data)[i];
130             }
131             return var;
132         }
133         case SCSINT16_N:
134         {
135             if (~pIT->isInt16())
136             {
137                 return pIT;
138             }
139             types::Int16* var = pIT->getAs<types::Int16>();
140             for (int i = 0; i < size; ++i)
141             {
142                 var->get()[i] = ((types::Int16::type*)data)[i];
143             }
144             return var;
145         }
146         case SCSINT32_N:
147         {
148             if (~pIT->isInt32())
149             {
150                 return pIT;
151             }
152             types::Int32* var = pIT->getAs<types::Int32>();
153             for (int i = 0; i < size; ++i)
154             {
155                 var->get()[i] = ((types::Int32::type*)data)[i];
156             }
157             return var;
158         }
159         case SCSUINT8_N:
160         {
161             if (~pIT->isUInt8())
162             {
163                 return pIT;
164             }
165             types::UInt8* var = pIT->getAs<types::UInt8>();
166             for (int i = 0; i < size; ++i)
167             {
168                 var->get()[i] = ((types::UInt8::type*)data)[i];
169             }
170             return var;
171         }
172         case SCSUINT16_N:
173         {
174             if (~pIT->isUInt16())
175             {
176                 return pIT;
177             }
178             types::UInt16* var = pIT->getAs<types::UInt16>();
179             for (int i = 0; i < size; ++i)
180             {
181                 var->get()[i] = ((types::UInt16::type*)data)[i];
182             }
183             return var;
184         }
185         case SCSUINT32_N:
186         {
187             if (~pIT->isUInt32())
188             {
189                 return pIT;
190             }
191             types::UInt32* var = pIT->getAs<types::UInt32>();
192             for (int i = 0; i < size; ++i)
193             {
194                 var->get()[i] = ((types::UInt32::type*)data)[i];
195             }
196             return var;
197         }
198         default: // case SCSUNKNOW_N: pass the data by pointers
199         {
200             return (types::InternalType*)data;
201         }
202     }
203 }
204 /*--------------------------------------------------------------------------*/
205 static types::InternalType* vartosci(void* data, const int rows, const int cols, const int type)
206 {
207     return vartosci(allocsci(data, rows, cols, type), data, rows, cols, type);
208 }
209 /*--------------------------------------------------------------------------*/
210 types::InternalType* createblklist(const scicos_block* const Blocks, const int flag_imp, const int /*funtyp*/)
211 {
212     const int fieldCount = 41;
213     int size = 0;
214
215     /* set string of first element of scilab Blocks tlist */
216     static const char* str_blklst[] = {"scicos_block", "nevprt", "funpt", "type",
217                                        "scsptr", "nz", "z", "noz",
218                                        "ozsz", "oztyp", "oz", "nx",
219                                        "x", "xd", "res", "nin",
220                                        "insz", "inptr", "nout", "outsz",
221                                        "outptr", "nevout", "evout", "nrpar",
222                                        "rpar", "nipar", "ipar", "nopar",
223                                        "oparsz", "opartyp", "opar", "ng",
224                                        "g", "ztyp", "jroot", "label",
225                                        "work", "nmode", "mode", "xprop",
226                                        "uid"
227                                       };
228
229     int* xptr = nullptr; /* to retrieve xptr by import and zcptr of scicos_blocks */
230     double* x = nullptr; /* ptr for x, xd and g for scicos_blocks                 */
231     double* xd = nullptr;
232     int* zcptr = nullptr;
233     double* g = nullptr;
234
235     if (flag_imp >= 0)
236     {
237         int nv, mv; /* length of data                             */
238         int nblk;   /* to store number of blocks                  */
239         //int ng;             /* to store number of zero cross              */
240         void* ptr; /* ptr for data comming from import structure */
241
242         /*retrieve nblk by import structure*/
243         char Nblk[] = "nblk";
244         getscicosvarsfromimport(Nblk, &ptr, &nv, &mv);
245         nblk = ((int*)ptr)[0];
246
247         /* retrieve ng by import structure */
248         char Ng[] = "ng";
249         getscicosvarsfromimport(Ng, &ptr, &nv, &mv);
250         //ng = ((int*)ptr)[0];
251
252         /*retrieve xptr by import structure*/
253         char Xptr[] = "xptr";
254         getscicosvarsfromimport(Xptr, &ptr, &nv, &mv);
255         xptr = (int*)ptr;
256
257         /*retrieve zcptr by import structure*/
258         char Zcptr[] = "zcptr";
259         getscicosvarsfromimport(Zcptr, &ptr, &nv, &mv);
260         zcptr = (int*)ptr;
261
262         /*retrieve x and xd by import structure*/
263         char X[] = "x";
264         getscicosvarsfromimport(X, &ptr, &nv, &mv);
265         x = (double*)ptr;
266         xd = &x[xptr[nblk] - 1];
267
268         /*retrieve g by import structure*/
269         char G[] = "g";
270         getscicosvarsfromimport(G, &ptr, &nv, &mv);
271         g = (double*)ptr;
272     }
273
274     types::TList* m = new types::TList();
275
276     /* 1 - scicos_block */
277     types::String* s = new types::String(1, fieldCount);
278     for (int i = 0; i < fieldCount; ++i)
279     {
280         s->set(i, str_blklst[i]);
281     }
282
283     m->append(s);
284
285     /* 2 - nevprt */
286     m->append(new types::Double(static_cast<double>(Blocks->nevprt)));
287
288     /* 3 - funpt */
289     //cast function ptr to double*
290     if (sizeof(voidg) >= sizeof(double))
291     {
292         // store N double values as the function pointer value
293         size = sizeof(voidg) / sizeof(double);
294     }
295     else
296     {
297         // push at least one double
298         size = 1;
299     }
300
301     types::Double* funpt = new types::Double(size, 1);
302     double* d = funpt->get();
303     for (int i = 0; i < size; ++i)
304     {
305         d[i] = (double)((long long)Blocks->funpt);
306     }
307
308     m->append(funpt);
309
310     /* 4 - type */
311     m->append(new types::Double(static_cast<double>(Blocks->type)));
312
313     /* 5 - scsptr */
314     //cast function ptr to double*
315     if (sizeof(types::InternalType*) >= sizeof(double))
316     {
317         // store N double values as the function pointer value
318         size = sizeof(types::InternalType*) / sizeof(double);
319     }
320     else
321     {
322         // push at least one double
323         size = 1;
324     }
325     types::Double* scsptr = new types::Double(size, 1);
326     d = scsptr->get();
327     for (int i = 0; i < size; ++i)
328     {
329         d[i] = (double)((long long)Blocks->scsptr);
330     }
331
332     m->append(scsptr);
333
334     /* 6 - nz */
335     m->append(new types::Double(static_cast<double>(Blocks->nz)));
336
337     /* 7 - z */
338     m->append(vartosci(Blocks->z, Blocks->nz, 1, SCSREAL_N));
339
340     /* 8 - noz */
341     m->append(new types::Double(static_cast<double>(Blocks->noz)));
342
343     /* 9 - ozsz */
344     types::Double* ozsz = new types::Double(Blocks->noz, 1);
345     d = ozsz->get();
346     for (int i = 0; i < Blocks->noz; ++i)
347     {
348         d[i] = static_cast<double>(Blocks->ozsz[i]);
349     }
350
351     m->append(ozsz);
352
353     /* 10 - oztyp */
354     types::Double* oztyp = new types::Double(Blocks->noz, 1);
355     d = oztyp->get();
356     for (int i = 0; i < Blocks->noz; ++i)
357     {
358         d[i] = static_cast<double>(Blocks->oztyp[i]);
359     }
360
361     m->append(oztyp);
362
363     /* 11 - ozptr */
364     types::List* ozptr = new types::List();
365     for (int k = 0; k < Blocks->noz; k++)
366     {
367         const int rows = Blocks->ozsz[k];               /* retrieve number of rows */
368         const int cols = Blocks->ozsz[Blocks->noz + k]; /* retrieve number of cols */
369         const int type = Blocks->oztyp[k];              /* retrieve type */
370         ozptr->append(vartosci(Blocks->ozptr[k], rows, cols, type));
371     }
372
373     m->append(ozptr);
374
375     /* 12 - nx */
376     m->append(new types::Double(static_cast<double>(Blocks->nx)));
377
378     /* 13 - x */
379     if (flag_imp >= 0)
380     {
381         m->append(vartosci(&x[xptr[flag_imp] - 1], Blocks->nx, 1, SCSREAL_N));
382     }
383     else
384     {
385         m->append(vartosci(Blocks->x, Blocks->nx, 1, SCSREAL_N));
386     }
387
388     /* 14 - xd */
389     if (flag_imp >= 0)
390     {
391         m->append(vartosci(&xd[xptr[flag_imp] - 1], Blocks->nx, 1, SCSREAL_N));
392     }
393     else
394     {
395         m->append(vartosci(Blocks->xd, Blocks->nx, 1, SCSREAL_N));
396     }
397
398     /* 15 - res */
399     m->append(vartosci(Blocks->res, Blocks->nx, 1, SCSREAL_N));
400
401     /* 16 - nin */
402     m->append(new types::Double(static_cast<double>(Blocks->nin)));
403
404     /* 17 - insz */
405     types::Double* insz = new types::Double(3 * Blocks->nin, 1);
406     d = insz->get();
407     for (int i = 0; i < 3 * Blocks->nin; ++i)
408     {
409         d[i] = static_cast<double>(Blocks->insz[i]);
410     }
411
412     m->append(insz);
413
414     /* 18 - inptr */
415     types::List* inptr = new types::List();
416     for (int k = 0; k < Blocks->nin; k++)
417     {
418         const int rows = Blocks->insz[k];                   /* retrieve number of rows */
419         const int cols = Blocks->insz[Blocks->nin + k];     /* retrieve number of cols */
420         const int type = Blocks->insz[2 * Blocks->nin + k]; /* retrieve type */
421         inptr->append(vartosci(Blocks->inptr[k], rows, cols, type));
422     }
423
424     m->append(inptr);
425
426     /* 19 - nout */
427     m->append(new types::Double(static_cast<double>(Blocks->nout)));
428
429     /* 20 - outsz */
430     types::Double* outsz = new types::Double(3 * Blocks->nout, 1);
431     d = outsz->get();
432     for (int i = 0; i < 3 * Blocks->nout; ++i)
433     {
434         d[i] = static_cast<double>(Blocks->outsz[i]);
435     }
436
437     m->append(outsz);
438     /* 21 - outptr */
439     types::List* outptr = new types::List();
440     for (int k = 0; k < Blocks->nout; k++)
441     {
442         const int rows = Blocks->outsz[k];                    /* retrieve number of rows */
443         const int cols = Blocks->outsz[Blocks->nout + k];     /* retrieve number of cols */
444         const int type = Blocks->outsz[2 * Blocks->nout + k]; /* retrieve type */
445         outptr->append(vartosci(Blocks->outptr[k], rows, cols, type));
446     }
447
448     m->append(outptr);
449
450     /* 22 - nevout */
451     m->append(new types::Double(static_cast<double>(Blocks->nevout)));
452
453     /* 23 - evout */
454     m->append(vartosci(Blocks->evout, Blocks->nevout, 1, SCSREAL_N));
455
456     /* 24 - nrpar */
457     m->append(new types::Double(static_cast<double>(Blocks->nrpar)));
458
459     /* 25 - rpar */
460     m->append(vartosci(Blocks->rpar, Blocks->nrpar, 1, SCSREAL_N));
461
462     /* 26 - nipar */
463     m->append(new types::Double(static_cast<double>(Blocks->nipar)));
464
465     /* 27 - ipar */
466     types::Double* ipar = new types::Double(Blocks->nipar, 1);
467     d = ipar->get();
468     for (int i = 0; i < Blocks->nipar; ++i)
469     {
470         d[i] = static_cast<double>(Blocks->ipar[i]);
471     }
472
473     m->append(ipar);
474
475     /* 28 - nopar */
476     m->append(new types::Double(static_cast<double>(Blocks->nopar)));
477
478     /* 29 - oparsz */
479     types::Double* oparsz = new types::Double(Blocks->nopar, 1);
480     d = oparsz->get();
481     for (int i = 0; i < Blocks->nopar; ++i)
482     {
483         d[i] = static_cast<double>(Blocks->oparsz[i]);
484     }
485
486     m->append(oparsz);
487
488     /* 30 - opartyp */
489     types::Double* opartyp = new types::Double(Blocks->nopar, 1);
490     d = opartyp->get();
491     for (int i = 0; i < Blocks->nopar; ++i)
492     {
493         d[i] = static_cast<double>(Blocks->opartyp[i]);
494     }
495
496     m->append(opartyp);
497
498     /* 31 - opar */
499     types::List* opar = new types::List();
500     for (int k = 0; k < Blocks->nopar; k++)
501     {
502         const int rows = Blocks->oparsz[k];                 /* retrieve number of rows */
503         const int cols = Blocks->oparsz[Blocks->nopar + k]; /* retrieve number of cols */
504         const int type = Blocks->opartyp[k];                /* retrieve type */
505         opar->append(vartosci(Blocks->oparptr[k], rows, cols, type));
506     }
507
508     m->append(opar);
509
510     /* 32 - ng */
511     m->append(new types::Double(static_cast<double>(Blocks->ng)));
512
513     /* 33 - g */
514     if (flag_imp >= 0)
515     {
516         m->append(vartosci(&g[zcptr[flag_imp] - 1], Blocks->ng, 1, SCSREAL_N));
517     }
518     else
519     {
520         m->append(vartosci(Blocks->g, Blocks->ng, 1, SCSREAL_N));
521     }
522
523     /* 34 - ztyp */
524     m->append(new types::Double(static_cast<double>(Blocks->ztyp)));
525
526     /* 35 - jroot */
527     types::Double* jroot = new types::Double(Blocks->ng, 1);
528     d = jroot->get();
529     for (int i = 0; i < Blocks->ng; ++i)
530     {
531         d[i] = static_cast<double>(Blocks->jroot[i]);
532     }
533
534     m->append(jroot);
535
536     /* 36 - label */
537     m->append(new types::String(Blocks->label));
538
539     /* 37 - work*/
540     //store address as double
541     m->append(new types::Double((double)((long long)Blocks->work)));
542
543     /* 38 - nmode*/
544     m->append(new types::Double(static_cast<double>(Blocks->nmode)));
545
546     /* 39 - mode */
547     types::Double* mode = new types::Double(Blocks->nmode, 1);
548     d = mode->get();
549     for (int i = 0; i < Blocks->nmode; ++i)
550     {
551         d[i] = static_cast<double>(Blocks->mode[i]);
552     }
553
554     m->append(mode);
555
556     /* 40 - xprop */
557     types::Double* xprop = new types::Double(Blocks->nx, 1);
558     d = xprop->get();
559     for (int i = 0; i < Blocks->nx; ++i)
560     {
561         d[i] = static_cast<double>(Blocks->xprop[i]);
562     }
563
564     m->append(xprop);
565
566     /* 41 - uid */
567     if (Blocks->uid)
568     {
569         m->append(new types::String(Blocks->uid));
570     }
571     else
572     {
573         m->append(new types::String(L""));
574     }
575
576     return m;
577 }
578 /*--------------------------------------------------------------------------*/
579 types::InternalType* refreshblklist(types::InternalType* pIT, const scicos_block* const Blocks, const int flag_imp, const int /*funtyp*/)
580 {
581     if (~pIT->isTList())
582     {
583         return pIT;
584     }
585     types::TList* m = pIT->getAs<types::TList>();
586
587     // ensure that `m` contains the needed elements; if not discard the sync
588     if (m->getSize() != 41)
589     {
590         return m;
591     }
592
593     int* xptr = nullptr; /* to retrieve xptr by import and zcptr of scicos_blocks */
594     double* x = nullptr; /* ptr for x, xd and g for scicos_blocks                 */
595     double* xd = nullptr;
596     int* zcptr = nullptr;
597     double* g = nullptr;
598
599     if (flag_imp >= 0)
600     {
601         int nv, mv; /* length of data                             */
602         int nblk;   /* to store number of blocks                  */
603         //int ng;             /* to store number of zero cross              */
604         void* ptr; /* ptr for data comming from import structure */
605
606         /*retrieve nblk by import structure*/
607         char Nblk[] = "nblk";
608         getscicosvarsfromimport(Nblk, &ptr, &nv, &mv);
609         nblk = ((int*)ptr)[0];
610
611         /* retrieve ng by import structure */
612         char Ng[] = "ng";
613         getscicosvarsfromimport(Ng, &ptr, &nv, &mv);
614         //ng = ((int*)ptr)[0];
615
616         /*retrieve xptr by import structure*/
617         char Xptr[] = "xptr";
618         getscicosvarsfromimport(Xptr, &ptr, &nv, &mv);
619         xptr = (int*)ptr;
620
621         /*retrieve zcptr by import structure*/
622         char Zcptr[] = "zcptr";
623         getscicosvarsfromimport(Zcptr, &ptr, &nv, &mv);
624         zcptr = (int*)ptr;
625
626         /*retrieve x and xd by import structure*/
627         char X[] = "x";
628         getscicosvarsfromimport(X, &ptr, &nv, &mv);
629         x = (double*)ptr;
630         xd = &x[xptr[nblk] - 1];
631
632         /*retrieve g by import structure*/
633         char G[] = "g";
634         getscicosvarsfromimport(G, &ptr, &nv, &mv);
635         g = (double*)ptr;
636     }
637
638     /* 7 - z */
639     m->set(7, vartosci(m->get(7), Blocks->z, Blocks->nz, 1, SCSREAL_N));
640
641     /* 11 - ozptr */
642     if (m->get(11)->isList())
643     {
644         types::List* ozptr = m->get(11)->getAs<types::List>();
645         for (int k = 0; k < Blocks->noz; k++)
646         {
647             const int rows = Blocks->ozsz[k];               /* retrieve number of rows */
648             const int cols = Blocks->ozsz[Blocks->noz + k]; /* retrieve number of cols */
649             const int type = Blocks->oztyp[k];              /* retrieve type */
650             ozptr->set(k, vartosci(ozptr->get(k), Blocks->ozptr[k], rows, cols, type));
651         }
652         m->set(11, ozptr);
653     }
654
655     /* 13 - x */
656     if (flag_imp >= 0)
657     {
658         m->set(13, vartosci(m->get(13), &x[xptr[flag_imp] - 1], Blocks->nx, 1, SCSREAL_N));
659     }
660     else
661     {
662         m->set(13, vartosci(m->get(13), Blocks->x, Blocks->nx, 1, SCSREAL_N));
663     }
664
665     /* 14 - xd */
666     if (flag_imp >= 0)
667     {
668         m->set(14, vartosci(m->get(14), &xd[xptr[flag_imp] - 1], Blocks->nx, 1, SCSREAL_N));
669     }
670     else
671     {
672         m->set(14, vartosci(m->get(14), Blocks->xd, Blocks->nx, 1, SCSREAL_N));
673     }
674
675     /* 15 - res */
676     m->set(15, vartosci(m->get(15), Blocks->res, Blocks->nx, 1, SCSREAL_N));
677
678     /* 18 - inptr */
679     if (m->get(18)->isList())
680     {
681         types::List* inptr = m->get(18)->getAs<types::List>();
682         for (int k = 0; k < Blocks->nin; k++)
683         {
684             const int rows = Blocks->insz[k];                   /* retrieve number of rows */
685             const int cols = Blocks->insz[Blocks->nin + k];     /* retrieve number of cols */
686             const int type = Blocks->insz[2 * Blocks->nin + k]; /* retrieve type */
687             inptr->set(k, vartosci(inptr->get(k), Blocks->inptr[k], rows, cols, type));
688         }
689         m->set(18, inptr);
690     }
691
692     /* 21 - outptr */
693     if (m->get(21)->isList())
694     {
695         types::List* outptr = m->get(21)->getAs<types::List>();
696         for (int k = 0; k < Blocks->nout; k++)
697         {
698             const int rows = Blocks->outsz[k];                    /* retrieve number of rows */
699             const int cols = Blocks->outsz[Blocks->nout + k];     /* retrieve number of cols */
700             const int type = Blocks->outsz[2 * Blocks->nout + k]; /* retrieve type */
701             outptr->set(k, vartosci(outptr->get(k), Blocks->outptr[k], rows, cols, type));
702         }
703         m->set(21, outptr);
704     }
705
706     /* 23 - evout */
707     m->set(23, vartosci(m->get(23), Blocks->evout, Blocks->nevout, 1, SCSREAL_N));
708
709     /* 33 - g */
710     if (flag_imp >= 0)
711     {
712         m->set(33, vartosci(m->get(33), &g[zcptr[flag_imp] - 1], Blocks->ng, 1, SCSREAL_N));
713     }
714     else
715     {
716         m->set(33, vartosci(m->get(33), Blocks->g, Blocks->ng, 1, SCSREAL_N));
717     }
718
719     /* 35 - jroot */
720     m->set(35, vartosci(m->get(35), Blocks->jroot, Blocks->ng, 1, SCSREAL_N));
721
722     /* 39 - mode */
723     m->set(39, vartosci(m->get(39), Blocks->mode, Blocks->nmode, 1, SCSREAL_N));
724
725     /* 40 - xprop */
726     m->set(40, vartosci(m->get(40), Blocks->xprop, Blocks->nx, 1, SCSREAL_N));
727
728     return m;
729 }
730 /*--------------------------------------------------------------------------*/