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

Last change on this file since 1006 was 1006, checked in by ansari, 25 years ago

change int to long dans Fill()

Sans doute malsain que ce ne soit pas des int_4 et al.

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