source: Sophya/trunk/SophyaLib/HiStats/xntuple.cc@ 763

Last change on this file since 763 was 763, checked in by ansari, 26 years ago

Reorganisation - Creation du module HiStats (Histos, NTuple, ...) - Reza 2/3/2000
File size: 22.8 KB
RevLine 
[763]1// -*- C++ -*-
2//
3// xntuple.cc
4// N. Regnault - 98-99
5// Extended NTuples
6//
7#include <string.h>
8#include "ppersist.h"
9#include "perrors.h"
10#include "xntuple.h"
11
12#define LENNAME 31
13#define MAXLEN 128
14#define BADVAL -1.e19
15
16//++
17// Class XNTuple
18// Lib Outils++
19// include xntuple.h
20//
21// Classe de ntuples
22//--
23//++
24// Links Parents
25// PPersist
26// NTupleInterface
27//--
28//++
29// Links Voir aussi
30// NTuple
31//--
32
33
34char* XNTuple::glob_swp = NULL ;
35long int XNTuple::NbNT = 0 ;
36
37
38NTBlk::NTBlk(int ndvar, int nfvar, int nivar, int nsvar, int strsz, int sz)
39 : sw(0), // pas swappe
40 swoff(-1),
41 ddata(NULL), fdata(NULL),
42 idata(NULL), sdata(NULL)
43{
44 if(ndvar) ddata = new double[ndvar*sz] ;
45 if(nfvar) fdata = new float[nfvar*sz] ;
46 if(nivar) idata = new int_4[nivar*sz] ;
47 if(nsvar) sdata = new char[nsvar*(strsz+1)*sz] ;
48}
49
50NTBlk::~NTBlk()
51{
52 free() ;
53}
54
55void NTBlk::free()
56{
57 if(ddata) delete[] ddata ; ddata = NULL ;
58 if(fdata) delete[] fdata ; fdata = NULL ;
59 if(idata) delete[] idata ; idata = NULL ;
60 if(sdata) delete[] sdata ; sdata = NULL ;
61}
62
63//
64// relit bloc ds fichier swap
65// (seulement si bloc n'est plus en memoire)
66//
67void XNTuple::read_blk(NTBlk* blk) const
68{
69 // deja en memoire ?
70 if( !blk->sw ) return ;
71
72 blk->free() ;
73
74 // On va --> blk
75 fseek(swf, blk->swoff, SEEK_SET) ;
76
77 if(mD) {
78 blk->ddata = new double[mD*mBlkSz] ;
79 fread(blk->ddata, sizeof(double), mD*mBlkSz, swf) ;
80 }
81 if(mF) {
82 blk->fdata = new float[mF*mBlkSz] ;
83 fread(blk->fdata, sizeof(float), mF*mBlkSz, swf) ;
84 }
85 if(mI) {
86 blk->idata = new int_4[mI*mBlkSz] ;
87 fread(blk->idata, sizeof(int), mI*mBlkSz, swf) ;
88 }
89 if(mS) {
90 blk->sdata = new char[mS*(mStrSz+1)*mBlkSz] ;
91 fread(blk->sdata, sizeof(char), mS*mBlkSz*(mStrSz+1), swf) ;
92 }
93}
94
95//
96// swappe le bloc present en memoire
97// depuis le + longtemps
98//
99void XNTuple::swap() const
100{
101 // fichier de swap ouvert ?
102 if(!swf) {
103 swf_name = new char[swp.length()+64] ;
104 strncpy(swf_name, swp.c_str(), swp.length()+1) ;
105 strcat(swf_name, "NTupleXXXXXX") ;
106 // swf_name = strdup("NTupleXXXXXX") ;
107 mktemp(swf_name) ;
108 swf = fopen(swf_name, "w+") ;
109 if(!swf) THROW(fileErr) ;
110 }
111
112 // bloc a swapper
113 NTBlk* blk = sw.front() ;
114
115 // bloc dans fichiers de swap ?
116 // if( blk->swoff > 0 )
117 write_blk(blk) ;
118 blk->free() ;
119
120 blk->sw = 1 ; // on marque le bloc swappe
121 sw.pop_front() ; // on le vire de la liste de swap
122 mNSwBlk++ ;
123}
124
125
126//
127// unswap()
128//
129void XNTuple::get_blk(int i) const
130{
131 if(i<0 || i>=mNBlk) return ;
132 read_blk(ptr[i]) ;
133 ptr[i]->sw = 0 ;
134 sw.push_back(ptr[i]) ;
135 mNSwBlk-- ;
136}
137
138
139//
140// ecrit le bloc en bout de fichier
141// (seulement si swoff < 0 )
142//
143void XNTuple::write_blk(NTBlk* blk) const
144{
145 // deja swappe ?
146 if( blk->swoff >= 0 ) return ;
147 fseek(swf, (off_t)0, SEEK_END) ;
148 // position debut du bloc
149 blk->swoff = ftell(swf) ;
150 if(blk->ddata) fwrite(blk->ddata, sizeof(double), mD*mBlkSz, swf) ;
151 if(blk->fdata) fwrite(blk->fdata, sizeof(float), mF*mBlkSz, swf) ;
152 if(blk->idata) fwrite(blk->idata, sizeof(int), mI*mBlkSz, swf) ;
153 if(blk->sdata) fwrite(blk->sdata, sizeof(char), mS*mBlkSz*(mStrSz+1), swf) ;
154}
155
156
157void XNTuple::add_blk()
158{
159 // l'ancien bloc en ecriture peut maintenant
160 // etre swappe (s'il existe)
161 if(mBlk>=0) sw.push_back(ptr[mBlk]) ;
162
163 // si pas de place, on swappe
164 if( mNBlk+1 >= mMaxBlk ) swap() ;
165
166 // nouveau bloc
167 NTBlk* tmp = new NTBlk(mD, mF, mI, mS, mStrSz, mBlkSz) ;
168 ptr.push_back(tmp) ;
169
170 // mNBlk++ ;
171 // mOff = 0 ;
172 // mBlk++ ;
173}
174
175
176XNTuple::XNTuple()
177 : mNEnt(0), mNBlk(0), mNSwBlk(0),
178 mBlkSz(0), mBlk(-1), mOff(0),
179 mMaxBlk(0), mStrSz(0),
180 mD(0), mF(0), mI(0), mS(0),
181 mVarD(NULL), mMin(NULL), mMax(NULL),
182 mNVars(0), mNames(NULL),
183 swf(NULL), swf_name(NULL), mInfo(NULL)
184{
185 if(!glob_swp) SetSwapPath("/tmp/") ;
186 swp = glob_swp ;
187 NbNT++ ;
188}
189
190//++
191// Titre Constructeurs
192//--
193//++
194// XNTuple(int ndvar, int nfvar, int nivar, int nsvar, char** vnames, -
195// int blk=512, int maxblk=100, int strsz=30)
196// Constructeur - Création d'un XNTuple de "ndvar" variables de type "double", -
197// "nfvar" de type "float", "nivar" de type "int" et "nsvar" de type -
198// "char*".
199//| * "blk" = taille blocs de données (en nombre d'entrées)
200//| * "maxblk" = nombre max de blocs présents en mémoire (non swappés)
201//| * "strsz" = taille des données de type char*
202// XNTuple(XNTuple const& nt)
203// Constructeur de copie.
204// XNTuple(string const& flnm)
205// Constructeur - lecture à partir d'un fichier PPersist.
206//--
207
208XNTuple::XNTuple(int ndvar, int nfvar, int nivar, int nsvar,
209 char** vnames,
210 int blk, int maxblk, int strsz)
211 : mNEnt(0), mNBlk(0), mNSwBlk(0),
212 mBlkSz(blk), mBlk(-1), mOff(0),
213 mMaxBlk(maxblk), mStrSz(strsz),
214 mD(ndvar), mF(nfvar), mI(nivar), mS(nsvar),
215 mVarD(NULL), mMin(NULL), mMax(NULL),
216 mNVars(ndvar+nfvar+nivar+nsvar), mNames(NULL),
217 swf(NULL), swf_name(NULL), mInfo(NULL)
218{
219 if(!glob_swp) SetSwapPath("/tmp/") ;
220 swp = glob_swp ;
221
222 mVarD = new r_8[mNVars] ;
223 mMin = new r_8[mD+mF+mI] ;
224 int i;
225 for(i = 0 ; i < (mD+mF+mI) ; i++) mMin[i] = 9E19 ;
226 mMax = new r_8[mD+mF+mI] ;
227 for(i = 0 ; i < (mD+mF+mI) ; i++) mMax[i] = -9E19 ;
228
229 if(mNVars) mNames = new char[mNVars*(LENNAME+1)] ;
230 memset(mNames, 0, mNVars*(LENNAME+1));
231 for(i = 0 ; i < mNVars ; i++)
232 strncpy(mNames+i*(LENNAME+1), vnames[i], LENNAME);
233
234 NbNT++ ;
235}
236
237
238
239XNTuple::XNTuple(string const& flnm)
240 : mNEnt(0), mNBlk(0), mNSwBlk(0),
241 mBlkSz(0), mBlk(-1), mOff(0),
242 mMaxBlk(0), mStrSz(0),
243 mD(0), mF(0), mI(0), mS(0),
244 mVarD(NULL), mMin(NULL), mMax(NULL),
245 mNVars(0), mNames(NULL),
246 swf(NULL), swf_name(NULL), mInfo(NULL)
247{
248 if(!glob_swp) SetSwapPath("/tmp/") ;
249 swp = glob_swp ;
250
251 PInPersist s(flnm);
252 ObjFileIO<XNTuple> fiont(this);
253 fiont.Read(s);
254 NbNT++ ;
255}
256
257
258XNTuple::XNTuple(XNTuple const& nt)
259 : mNEnt(0), mNBlk(0), mNSwBlk(0),
260 mBlkSz(0), mBlk(-1), mOff(0),
261 mMaxBlk(0), mStrSz(0),
262 mD(0), mF(0), mI(0), mS(0),
263 mVarD(NULL), mMin(NULL), mMax(NULL),
264 mNVars(0), mNames(NULL),
265 swf(NULL), swf_name(NULL), mInfo(NULL)
266{
267 if(!glob_swp) SetSwapPath("/tmp/") ;
268 swp = glob_swp ;
269 Copy(nt) ;
270 NbNT++ ;
271}
272
273
274
275XNTuple::~XNTuple()
276{
277 clean() ;
278 NbNT-- ;
279 if(NbNT==0) delete[] glob_swp ;
280}
281
282
283
284void XNTuple::clean()
285{
286 // On libere tous les blocs
287 for(int i = 0 ; i < mNBlk ; i++)
288 if(!ptr[i]->sw) delete ptr[i] ;
289 ptr.erase(ptr.begin(), ptr.end()) ;
290 sw.erase(sw.begin(), sw.end()) ;
291
292 // on ferme le fichier de swap
293 if(swf) fclose(swf) ; swf = NULL ;
294 remove(swf_name) ;
295 delete swf_name ; swf_name = NULL ;
296
297 // tout le monde remis a 0
298 mNEnt = 0 ; mNBlk = 0 ;
299 mNSwBlk = 0 ; mBlkSz = 0 ;
300 mBlk = -1 ; mOff = 0 ;
301 mMaxBlk = 0 ; mStrSz = 0 ;
302 mD = 0 ; mF = 0 ;
303 mI = 0 ; mS = 0 ;
304 mNVars = 0 ;
305
306
307 if(mVarD) { delete[] mVarD ; mVarD = NULL ; }
308 if(mMin) { delete[] mMin ; mMin = NULL ; }
309 if(mMax) { delete[] mMax ; mMax = NULL ; }
310
311 if(mNames) {delete[] mNames ; mNames = NULL ; }
312 if (mInfo) delete mInfo;
313
314}
315
316
317//++
318// Titre Méthodes
319//--
320//++
321// void Fill(double* d_data, float* f_data, int* i_data, char** s_data)
322// Remplissage d'une ligne dans le NTuple
323// void Show(ostream& os) const
324// Impression de la liste des variables avec min-max sur le flot "oß
325// void Show() const
326// Identique à "Show(cout)"
327// XNTuple& operator = (XNTuple const& nt)
328// Opérateur égal (=) , copie "nt" dans le premier NTuple
329//--
330void XNTuple::Fill(double* d_data, float* f_data, int* i_data, char** s_data)
331{
332 // place disponible dans bloc courant ?
333 if( mOff==mBlkSz || mOff==0 ) {
334 add_blk() ; mOff = 0 ; mNBlk++ ; mBlk++ ;
335 }
336
337 if( mD && !ptr[mBlk]->ddata ||
338 mF && !ptr[mBlk]->fdata ||
339 mI && !ptr[mBlk]->idata ||
340 mS && !ptr[mBlk]->sdata )
341 THROW(parmErr) ;
342
343 double x ;
344 // copie variables et update mMin, mMax
345 if(mD) {
346 memcpy(ptr[mBlk]->ddata+mOff*mD, d_data, mD*sizeof(double)) ;
347 for(int i = 0 ; i < mD ; i++) {
348 x = d_data[i] ;
349 if(x<mMin[i]) mMin[i] = x ;
350 if(x>mMax[i]) mMax[i] = x ;
351 }
352 }
353
354 if(mF) {
355 memcpy(ptr[mBlk]->fdata+mOff*mF, f_data, mF*sizeof(float)) ;
356 for(int i = 0 ; i < mF ; i++) {
357 x = f_data[i] ;
358 if(x<mMin[i+mD]) mMin[i+mD] = x ;
359 if(x>mMax[i+mD]) mMax[i+mD] = x ;
360 }
361 }
362
363 if(mI) {
364 memcpy(ptr[mBlk]->idata+mOff*mI, i_data, mI*sizeof(int)) ;
365 for(int i = 0 ; i < mI ; i++) {
366 x = i_data[i] ;
367 if(x<mMin[i+mD+mF]) mMin[i+mD+mF] = x ;
368 if(x>mMax[i+mD+mF]) mMax[i+mD+mF] = x ;
369 }
370 }
371 for(int i = 0 ; i < mS ; i++)
372 memcpy(ptr[mBlk]->sdata+(mOff*mS+i)*(mStrSz+1),
373 s_data[i], (strlen(s_data[i])+1)*sizeof(char)) ;
374 mOff++ ;
375 mNEnt++ ;
376}
377
378//
379// A quel index correspond mon nom ?
380//
381int XNTuple::IndexNom(char const* nom) const
382{
383 int i ;
384 for(i = 0 ; i < (mD+mF+mI+mS) ; i++)
385 if( !strncmp( mNames+i*(LENNAME+1), nom, LENNAME+1) )
386 return i ;
387 return -1 ;
388}
389
390string XNTuple::NomIndex(int k) const
391{
392 if( k<0 || k>=mNVars ) return "" ;
393 return mNames + k*(LENNAME+1) ;
394}
395
396
397//
398//
399//
400double XNTuple::GetDVal(int i, int k) const
401{
402 if( i<0 || i>=mNEnt || k<0 || k>=mD )
403 THROW(rangeCheckErr) ;
404
405 // Bloc ?
406 int blk = (int)(i/mBlkSz) ;
407 int off = i%mBlkSz ;
408
409 // bloc swappe ?
410 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
411 return ptr[blk]->ddata[off*mD+k] ;
412}
413
414//
415//
416//
417float XNTuple::GetFVal(int i, int k) const
418{
419 if( i<0 || i>=mNEnt || k<mD || k>=(mD+mF) )
420 THROW(rangeCheckErr) ;
421 k -= mD ;
422
423 // Bloc ?
424 int blk = (int)(i/mBlkSz) ;
425 int off = i%mBlkSz ;
426
427 // bloc swappe ?
428 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
429 return ptr[blk]->fdata[off*mF+k] ;
430}
431
432//
433//
434//
435int XNTuple::GetIVal(int i, int k) const
436{
437 if( i<0 || i>=mNEnt || k<(mD+mF) || k>=(mD+mF+mI) )
438 THROW(rangeCheckErr) ;
439 k -= (mD+mF) ;
440
441 // Bloc ?
442 int blk = (int)(i/mBlkSz) ;
443 int off = i%mBlkSz ;
444
445 // bloc swappe ?
446 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
447
448 return ptr[blk]->idata[off*mI+k] ;
449}
450
451//
452//
453//
454string XNTuple::GetSVal(int i, int k) const
455{
456 if( i<0 || i>=mNEnt || k<(mD+mF+mI) || k>=(mD+mF+mI+mS) )
457 THROW(rangeCheckErr) ;
458 k -= (mD+mF+mI) ;
459
460 // Bloc ?
461 int blk = (int)(i/mBlkSz) ;
462 int off = i%mBlkSz ;
463
464 // bloc swappe ?
465 if( ptr[blk]->sw ) { get_blk(blk) ; swap() ; }
466
467 // copie de la chaine
468 // string ret = strdup(ptr[blk]->sdata + (off*mS+k)*(mStrSz+1)) ; // $CHECK$ EA fuite de memoire
469 // attention, strdup fait un malloc et on ne fait jamais de free...
470 // a quoi sert ce strdup ?????????
471 string ret = ptr[blk]->sdata + (off*mS+k)*(mStrSz+1) ;
472 // return ptr[blk]->sdata[k] ;
473 return ret ;
474}
475
476
477//
478// Copie bloc a bloc, avec meme parametres
479//
480void XNTuple::Copy(XNTuple const& nt)
481{
482 clean() ;
483 // Parametres
484 mNEnt = nt.mNEnt ;
485 mBlkSz = nt.mBlkSz ;
486 mOff = nt.mOff ;
487 mMaxBlk = nt.mMaxBlk ;
488 mStrSz = nt.mStrSz ;
489 mD = nt.mD ;
490 mF = nt.mF ;
491 mI = nt.mI ;
492 mS = nt.mS ;
493 mNVars = nt.mNVars ;
494
495 // noms
496 if(mNVars) {
497 mNames = new char[mNVars*(LENNAME+1)] ;
498 mVarD = new double[mNVars];
499 memcpy(mNames, nt.mNames, mNVars*(LENNAME+1)*sizeof(char)) ;
500 }
501 // MinMax
502 if(nt.mMin) {
503 mMin = new double[(mD+mF+mI)] ;
504 memcpy(mMin, nt.mMin, (mD+mF+mI)*sizeof(double)) ;
505 }
506 if(nt.mMax) {
507 mMax = new double[(mD+mF+mI)] ;
508 memcpy(mMax, nt.mMax, (mD+mF+mI)*sizeof(double)) ;
509 }
510
511 //dup blocs
512 mNBlk = 0 ;
513 mBlk = -1 ;
514 for(int i = 0 ; i < nt.mNBlk ; i++) {
515 add_blk() ; mBlk++ ; mNBlk++ ;
516 // si nt.ptr[i] swappe, on le relit
517 if(nt.ptr[i]->sw) nt.read_blk(nt.ptr[i]) ;
518 if(mD)
519 memcpy(ptr[i]->ddata, nt.ptr[i]->ddata, mD*mBlkSz*sizeof(double)) ;
520 if(mF)
521 memcpy(ptr[i]->fdata, nt.ptr[i]->fdata, mF*mBlkSz*sizeof(float)) ;
522 if(mI)
523 memcpy(ptr[i]->idata, nt.ptr[i]->idata, mF*mBlkSz*sizeof(int)) ;
524 if(mS)
525 memcpy(ptr[i]->sdata, nt.ptr[i]->sdata, mS*mBlkSz*sizeof(char)*(mStrSz+1)) ;
526 if(nt.ptr[i]->sw) nt.ptr[i]->free() ;
527 }
528
529 // DVList Info block
530 if(nt.mInfo!=NULL) {mInfo = new DVList; *mInfo = *(nt.mInfo);}
531
532}
533
534//++
535// DVList& Info()
536// Renvoie une référence sur l'objet DVList Associé
537//--
538
539DVList& XNTuple::Info()
540{
541 if (mInfo == NULL) mInfo = new DVList;
542 return(*mInfo);
543}
544
545void XNTuple::Print(int num, int nmax) const
546{
547 printf("XNTuple::Print() : \n") ;
548 printf(" Entrees = %d, Blocs = %d, Bloc Size = %d\n",
549 mNEnt, mNBlk, mBlkSz) ;
550 int i,j;
551 printf(" D_Vars = %d : ", mD) ;
552 for(i = 0 ; i < mD ; i++)
553 printf("%s ", NomIndex(i).c_str() ) ;
554 printf("\n") ;
555
556 printf(" F_Vars = %d : ", mF) ;
557 for(i = 0 ; i < mF ; i++)
558 printf("%s ", NomIndex(i+mD).c_str() ) ;
559 printf("\n") ;
560
561 printf(" I_Vars = %d : ", mI) ;
562 for(i = 0 ; i < mI ; i++)
563 printf("%s ", NomIndex(i+mD+mF).c_str() ) ;
564 printf("\n") ;
565
566 printf(" S_Vars = %d : ", mS) ;
567 for(i = 0 ; i < mS ; i++)
568 printf("%s ", NomIndex(i+mD+mF+mI).c_str() ) ;
569 printf("\n") ;
570
571 for(i = num ; i < num+nmax ; i++) {
572 for(j = 0 ; j < mD ; j++) printf("%f ", GetDVal(i,j)) ;
573 printf(" -- ") ;
574 for(j = 0 ; j < mF ; j++) printf("%f ", GetFVal(i,j+mD)) ;
575 printf(" -- ") ;
576 for(j = 0 ; j < mI ; j++) printf("%d ", GetIVal(i,j+mD+mF)) ;
577 printf(" -- ") ;
578 for(j = 0 ; j < mS ; j++) printf("%s ", GetSVal(i,j+mD+mF+mI).c_str()) ;
579 printf("\n") ;
580 }
581}
582
583
584void XNTuple::Show(ostream& os) const
585{
586 os << "XNTuple: NVar= " << mNVars << " NEnt= " << mNEnt
587 << " (BlkSz,NBlk= " << mBlkSz << ", " << mNBlk << ")"
588 << " (mNSwBlk= " << mNSwBlk << ")" << endl ;
589 os << "(Sw File= " ; if(swf_name) os << swf_name ; os << ")" << endl ;
590
591 char* buff = new char[80] ;
592 sprintf(buff, "Variables : Type Min Max \n") ;
593 os << buff ;
594
595 double min, max ;
596 int i;
597 for(i = 0 ; i < mD ; i++) {
598 GetMinMax(i, min, max) ;
599 sprintf(buff, " %-10s: D %12.6g %12.6g \n",
600 NomIndex(i).c_str(), min, max) ;
601 os << buff ;
602 }
603 for(i = 0 ; i < mF ; i++) {
604 GetMinMax(i+mD, min, max) ;
605 sprintf(buff, " %-10s: F %12.6g %12.6g \n",
606 NomIndex(i+mD).c_str(), min, max) ;
607 os << buff ;
608 }
609 for(i = 0 ; i < mI ; i++) {
610 GetMinMax(i+mD+mF, min, max) ;
611 sprintf(buff, " %-10s: I %12.6g %12.6g \n",
612 NomIndex(i+mD+mF).c_str(), min, max) ;
613 os << buff ;
614 }
615 for(i = 0 ; i < mS ; i++) {
616 sprintf(buff, " %-10s: S ----- ----- \n",
617 NomIndex(i+mD+mF+mI).c_str()) ;
618 os << buff ;
619 }
620 delete[] buff ;
621}
622
623int XNTuple::FillFromASCIIFile(string const& fn, double ddval, float dfval,
624 int dival, const char * dsval)
625// Remplit le ntuple a partir d'un fichier ASCII.
626// Renvoie le nombre de lignes ajoutees.
627{
628// a faire
629return(0);
630}
631
632
633void XNTuple::SetSwapPath(char* p)
634{
635 if(!glob_swp) glob_swp = new char[MAXLEN+1] ;
636 strncpy(glob_swp, p, MAXLEN) ;
637}
638
639//
640//
641// Interface NTuple
642//
643//
644uint_4 XNTuple::NbLines() const
645{
646 return(NEntry());
647}
648
649uint_4 XNTuple::NbColumns() const
650{
651 return(NVar());
652}
653
654r_8* XNTuple::GetLineD(int n) const
655{
656 // memcpy() impossible
657 // il faut faire des GetVal
658 int i;
659 for(i = 0 ; i < mD ; i++)
660 mVarD[i] = GetDVal(n, i) ;
661 for(i = 0 ; i < mF ; i++)
662 mVarD[i+mD] = (double)GetFVal(n, i+mD) ;
663 for(i = 0 ; i < mI ; i++)
664 mVarD[i+mD+mF] = (double)GetIVal(n, i+mD+mF) ;
665 for(i = 0 ; i < mS ; i++)
666 mVarD[i+mD+mF+mI] = atof(GetSVal(n, i+mD+mF+mI).c_str()) ;
667 return mVarD ;
668}
669
670
671r_8 XNTuple::GetCell(int n, int k) const
672{
673 if( k<0 || k>=(mD+mF+mI+mS) ) return BADVAL ;
674 if(k<mD) return GetDVal(n,k) ;
675 if(k<(mF+mD)) return GetFVal(n,k) ;
676 if(k<(mF+mD+mI)) return GetIVal(n,k) ;
677 if(k<(mD+mF+mI+mS)) return atof(GetSVal(n,k).c_str()) ;
678 return BADVAL ;
679}
680
681
682r_8 XNTuple::GetCell(int n, string const& nom) const
683{
684 int k = IndexNom(nom.c_str()) ;
685 if(k<0) return BADVAL ;
686 if(k<mD) return GetDVal(n,k) ;
687 if(k<(mF+mD)) return GetFVal(n,k) ;
688 if(k<(mF+mD+mI)) return GetIVal(n,k) ;
689 if(k<(mD+mF+mI+mS)) return atof(GetSVal(n,k).c_str()) ;
690 return BADVAL ;
691}
692
693string XNTuple::GetCelltoString(int n, int k) const
694{
695 char buff[32];
696 if(k<0) return ("");
697 else if(k<mD)
698 { sprintf(buff, "%g", GetDVal(n,k)); return(buff) ; }
699 else if(k<(mF+mD))
700 { sprintf(buff, "%g", (double)GetFVal(n,k)); return(buff) ; }
701 else if(k<(mF+mD+mI))
702 { sprintf(buff, "%d", GetIVal(n,k)); return(buff) ; }
703 else if(k<(mD+mF+mI+mS))
704 return(GetSVal(n,k).c_str()) ;
705 return("");
706}
707
708void XNTuple::GetMinMax(int k, double& min, double& max) const
709{
710 min = 9E19 ; max = -9E19 ;
711 // variables string non traitees
712 if( k<0 || k>=(mD+mF+mI) ) return ;
713
714 min = mMin[k] ;
715 max = mMax[k] ;
716 return ;
717}
718
719
720void XNTuple::GetMinMax(string const & nom, double& min, double& max) const
721{
722 GetMinMax(IndexNom(nom.c_str()), min, max) ;
723}
724
725
726int XNTuple::ColumnIndex(string const& nom) const
727{
728 return IndexNom(nom.c_str()) ;
729}
730
731
732string XNTuple::ColumnName(int k) const
733{
734 return NomIndex(k) ;
735}
736
737
738string XNTuple::VarList_C(const char* nomx) const
739{
740 string rets = "" ;
741 rets += "/* double type variables */ \n";
742 // variables double
743 int i;
744 for(i = 0 ; i < mD ; i++) {
745 if( i>0 && (i%5)==0 ) rets += ";" ;
746 if( (i%5)==0 ) rets+="\ndouble " ;
747 else rets += ", " ;
748 rets += NomIndex(i) ;
749 }
750 if(mD) rets += ";" ;
751
752 // variables float
753 rets += "/* float type variables */ \n";
754 for(i = 0 ; i < mF ; i++) {
755 if( i>0 && (i%5)==0 ) rets += ";" ;
756 if( (i%5)==0 ) rets+="\ndouble " ;
757 else rets += ", " ;
758 rets += NomIndex(i+mD) ;
759 }
760 if(mF) rets += ";" ;
761
762 // variables int
763 rets += "/* int type variables */ \n";
764 for(i = 0 ; i < mI ; i++) {
765 if( i>0 && (i%5)==0 ) rets += ";" ;
766 if( (i%5)==0 ) rets+="\ndouble " ;
767 else rets += ", " ;
768 rets += NomIndex(i+mD+mF) ;
769 }
770 if(mI) rets += ";" ;
771
772 // variables string
773 rets += "/* string type variables */ \n";
774 for(i = 0 ; i < mS ; i++) {
775 if( i>0 && (i%5)==0 ) rets += ";" ;
776 if( (i%5)==0 ) rets+="\ndouble " ;
777 else rets += ", " ;
778 rets += NomIndex(i+mD+mF+mI) ;
779 }
780 rets += "; \n" ;
781
782 if(nomx) {
783 char buff[256] ;
784 for(i = 0 ; i < mNVars ; i++) {
785 sprintf(buff, "%s=%s[%d]; ", NomIndex(i).c_str(), nomx, i) ;
786 rets+=buff ;
787 if( (i%3 == 0) && (i>0) ) rets += "\n" ;
788 }
789 }
790 return rets ;
791}
792
793
794string XNTuple::LineHeaderToString() const
795{
796 char buff[32];
797 string rets=" Num ";
798 for(int i=0; i<mNVars; i++) {
799 sprintf(buff, "%8s ", NomIndex(i).c_str() );
800 rets += buff;
801 }
802 rets += '\n';
803 return(rets);
804
805}
806
807
808string XNTuple::LineToString(int n) const
809{
810 char buff[32];
811 double* val;
812 val = GetLineD(n);
813 sprintf(buff,"%6d: ",n);
814 string rets=buff;
815 int i;
816 for(i=0; i<(mD+mF+mI); i++) {
817 sprintf(buff, "%8.3g ", val[i]);
818 rets += buff;
819 }
820
821 for(i = mD+mF+mI ; i < mNVars ; i++) {
822 sprintf(buff, "%8s ", GetSVal(n,i).c_str() ) ;
823 rets += buff ;
824 }
825
826 rets += '\n';
827 return(rets);
828}
829
830
831void ObjFileIO<XNTuple>::WriteSelf(POutPersist& ppout) const
832{
833 if (dobj == NULL) return;
834// On ecrit 3 uint_4 ....
835// 0: Numero de version, 1 : non nul -> has info, 2 : reserve
836 uint_4 itab[3];
837 itab[0] = 1; // Numero de version a 1
838 itab[1] = itab[2] = 0;
839 if (dobj->mInfo) itab[1] = 1;
840 ppout.Put(itab,3);
841 if (dobj->mInfo) if (dobj->mInfo) ppout << (*(dobj->mInfo));
842
843 // variables internes
844 ppout.PutI4(dobj->mNEnt) ;
845 ppout.PutI4(dobj->mNBlk) ;
846 ppout.PutI4(dobj->mBlkSz) ;
847 ppout.PutI4(dobj->mBlk) ;
848 ppout.PutI4(dobj->mOff) ;
849 ppout.PutI4(dobj->mMaxBlk) ;
850 ppout.PutI4(dobj->mStrSz) ;
851 ppout.PutI4(dobj->mD) ;
852 ppout.PutI4(dobj->mF) ;
853 ppout.PutI4(dobj->mI) ;
854 ppout.PutI4(dobj->mS) ;
855 ppout.PutI4(dobj->mNVars) ;
856
857 // Noms
858 ppout.PutBytes(dobj->mNames, dobj->mNVars*(LENNAME+1)) ;
859
860 // MinMax
861 ppout.PutR8s(dobj->mMin, (dobj->mD+dobj->mF+dobj->mI)) ;
862 ppout.PutR8s(dobj->mMax, (dobj->mD+dobj->mF+dobj->mI)) ;
863
864 // Ecriture blocs N'ecrire que si datas existent
865 for(int i = 0 ; i < dobj->mNBlk ; i++) {
866 // si bloc swappe, on le relit en douce ...
867 if( dobj->ptr[i]->sw ) dobj->read_blk(dobj->ptr[i]) ;
868 ppout.PutR8s(dobj->ptr[i]->ddata, dobj->mD*dobj->mBlkSz) ;
869 ppout.PutR4s(dobj->ptr[i]->fdata, dobj->mF*dobj->mBlkSz) ;
870 ppout.PutI4s(dobj->ptr[i]->idata, dobj->mI*dobj->mBlkSz) ;
871 ppout.PutBytes(dobj->ptr[i]->sdata, dobj->mS*dobj->mBlkSz*(dobj->mStrSz+1)) ;
872 if(dobj->ptr[i]->sw) dobj->ptr[i]->free() ;
873 }
874}
875
876
877void ObjFileIO<XNTuple>::ReadSelf(PInPersist& ppin)
878{
879 if (dobj == NULL) dobj = new XNTuple;
880 else dobj->clean() ;
881// On lit 3 uint_4 ....
882// 0: Numero de version, 1 : non nul -> has info, 2 : reserve
883 uint_4 itab[3];
884 ppin.Get(itab,3);
885 if (itab[1] != 0) { // Lecture eventuelle du DVList Info
886 if (dobj->mInfo == NULL) dobj->mInfo = new DVList;
887 ppin >> (*(dobj->mInfo));
888 }
889
890 ppin.GetI4(dobj->mNEnt) ;
891 ppin.GetI4(dobj->mNBlk) ;
892 ppin.GetI4(dobj->mBlkSz) ;
893 ppin.GetI4(dobj->mBlk) ;
894 ppin.GetI4(dobj->mOff) ;
895 ppin.GetI4(dobj->mMaxBlk) ;
896 ppin.GetI4(dobj->mStrSz) ;
897 ppin.GetI4(dobj->mD) ;
898 ppin.GetI4(dobj->mF) ;
899 ppin.GetI4(dobj->mI) ;
900 ppin.GetI4(dobj->mS) ;
901 ppin.GetI4(dobj->mNVars) ;
902
903 // Noms
904 dobj->mNames = new char[dobj->mNVars*(LENNAME+1)] ;
905 dobj->mVarD = new double[dobj->mNVars];
906 ppin.GetBytes(dobj->mNames, dobj->mNVars*(LENNAME+1)) ;
907
908 // MinMax
909 dobj->mMin = new r_8[dobj->mD+dobj->mF+dobj->mI] ;
910 ppin.GetR8s(dobj->mMin, dobj->mD+dobj->mF+dobj->mI) ;
911 dobj->mMax = new r_8[dobj->mD+dobj->mF+dobj->mI] ;
912 ppin.GetR8s(dobj->mMax, dobj->mD+dobj->mF+dobj->mI) ;
913
914 // lecture Blocs
915 int nblk = dobj->mNBlk ;
916 dobj->mBlk = -1 ; dobj->mNBlk = 0 ;
917 for(int i = 0 ; i < nblk ; i++) {
918 dobj->add_blk() ; dobj->mBlk++ ; dobj->mNBlk++ ;
919 ppin.GetR8s(dobj->ptr[i]->ddata, dobj->mD*dobj->mBlkSz) ;
920 ppin.GetR4s(dobj->ptr[i]->fdata, dobj->mF*dobj->mBlkSz) ;
921 ppin.GetI4s(dobj->ptr[i]->idata, dobj->mI*dobj->mBlkSz) ;
922 ppin.GetBytes(dobj->ptr[i]->sdata, dobj->mS*dobj->mBlkSz*(dobj->mStrSz+1)) ;
923 }
924}
925
926#ifdef __CXX_PRAGMA_TEMPLATES__
927#pragma define_template ObjFileIO<XNTuple>
928#endif
929
930#if defined(ANSI_TEMPLATES) || defined(GNU_TEMPLATES)
931template class ObjFileIO<XNTuple>;
932#endif
Note: See TracBrowser for help on using the repository browser.