MBDyn-1.7.3
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups
output.cc
Go to the documentation of this file.
1 /* $Header: /var/cvs/mbdyn/mbdyn/mbdyn-1.0/mbdyn/base/output.cc,v 1.74 2017/05/29 18:10:33 masarati Exp $ */
2 /*
3  * MBDyn (C) is a multibody analysis code.
4  * http://www.mbdyn.org
5  *
6  * Copyright (C) 1996-2017
7  *
8  * Pierangelo Masarati <masarati@aero.polimi.it>
9  * Paolo Mantegazza <mantegazza@aero.polimi.it>
10  *
11  * Dipartimento di Ingegneria Aerospaziale - Politecnico di Milano
12  * via La Masa, 34 - 20156 Milano, Italy
13  * http://www.aero.polimi.it
14  *
15  * Changing this copyright notice is forbidden.
16  *
17  * This program is free software; you can redistribute it and/or modify
18  * it under the terms of the GNU General Public License as published by
19  * the Free Software Foundation (version 2 of the License).
20  *
21  *
22  * This program is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25  * GNU General Public License for more details.
26  *
27  * You should have received a copy of the GNU General Public License
28  * along with this program; if not, write to the Free Software
29  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
30  */
31 
32 /* gestore dell'output */
33 
34 #include "mbconfig.h" /* This goes first in every *.c,*.cc file */
35 
36 #include <sstream>
37 
38 #include "output.h"
39 
40 /* OutputHandler - begin */
41 
42 #ifndef OUTPUT_PRECISION
43 #define OUTPUT_PRECISION 6
44 #endif /* OUTPUT_PRECISION */
45 
48 
49 const char* psExt[] = {
50  ".out", // 0
51  ".mov",
52  ".ele",
53  ".abs",
54  ".ine",
55  ".jnt", // 5
56  ".frc",
57  ".act",
58  ".rot",
59  ".rst",
60  ".rst.X", // 10
61  ".aer",
62  ".hyd",
63  ".prs",
64  ".usr",
65  ".gen", // 15
66  ".par",
67  ".amd",
68  ".rfm",
69  ".log",
70  ".air", // 20
71  ".prm",
72  ".ext",
73  ".mod",
74  ".nc",
75  ".thn", // 25
76  ".the",
77  ".pla",
78  ".grv",
79  ".dof",
80  ".drv", // 30
81  ".trc",
82  ".m", // NOTE: ALWAYS LAST!
83  NULL // 33
84 };
85 
86 /* Costruttore senza inizializzazione */
88 : FileName(NULL),
89 #ifdef USE_NETCDF
90 m_DimTime(0),
91 m_DimV1(0),
92 m_DimV3(0),
93 m_pBinFile(0),
94 #endif /* USE_NETCDF */
95 iCurrWidth(iDefaultWidth),
96 iCurrPrecision(iDefaultPrecision),
97 nCurrRestartFile(0)
98 {
100 }
101 
102 /* Costruttore con inizializzazione */
103 OutputHandler::OutputHandler(const char* sFName, int iExtNum)
104 : FileName(sFName, iExtNum),
105 #ifdef USE_NETCDF
106 m_DimTime(0),
107 m_DimV1(0),
108 m_DimV3(0),
109 m_pBinFile(0),
110 #endif /* USE_NETCDF */
111 iCurrWidth(iDefaultWidth),
112 iCurrPrecision(iDefaultPrecision),
113 nCurrRestartFile(0)
114 {
116  Init(sFName, iExtNum);
117 }
118 
119 // Pesudo-constructor
120 void
122 {
125  OutData[OUTPUT].pof = &ofOutput;
126 
130  OutData[STRNODES].pof = &ofStrNodes;
131 
134  OutData[ELECTRIC].pof= &ofElectric;
135 
139 
143 
146  OutData[ABSTRACT].pof = &ofAbstract;
147 
151  OutData[INERTIA].pof = &ofInertia;
152 
156  OutData[JOINTS].pof = &ofJoints;
157 
161  OutData[FORCES].pof = &ofForces;
162 
166  OutData[BEAMS].pof = &ofBeams;
167 
170  OutData[ROTORS].pof = &ofRotors;
171 
174  OutData[RESTART].pof = &ofRestart;
175 
176  OutData[RESTARTXSOL].flags = 0
179 
184 
187  OutData[HYDRAULIC].pof = &ofHydraulic;
188 
191  OutData[PRESNODES].pof = &ofPresNodes;
192 
196  OutData[LOADABLE].pof = &ofLoadable;
197 
200  OutData[GENELS].pof = &ofGenels;
201 
204  OutData[PARTITION].pof = &ofPartition;
205 
209 
213 
214  OutData[LOG].flags = 0
216  OutData[LOG].pof = &ofLog;
217 
220  OutData[AIRPROPS].pof = &ofAirProps;
221 
225 
228  OutData[EXTERNALS].pof = &ofExternals;
229 
232  OutData[MODAL].pof = &ofModal;
233 
237  OutData[PLATES].pof = &ofPlates;
238 
241  OutData[GRAVITY].pof = &ofGravity;
242 
244  OutData[DOFSTATS].pof = &ofDofStats;
245 
249 
252  OutData[TRACES].pof = &ofTraces;
253 
257 
258  OutData[NETCDF].flags = 0
260  OutData[NETCDF].pof = 0;
261 
262  currentStep = 0;
263 }
264 
265 /* Inizializzazione */
266 void
267 OutputHandler::Init(const char* sFName, int iExtNum)
268 {
269  FileName::iInit(sFName, iExtNum);
270 
271  OutputOpen();
272  LogOpen();
273 }
274 
275 /* Distruttore */
277 {
278  for (int iCnt = 0; iCnt < LASTFILE; iCnt++) {
279  if (IsOpen(iCnt)) {
280 #ifdef USE_NETCDF
281  if (iCnt == NETCDF) {
282  if (m_pBinFile != 0) {
283  delete m_pBinFile;
284  }
285 
286  } else
287 #endif /* USE_NETCDF */
288  {
289  OutData[iCnt].pof->exceptions(std::ios::iostate(0));
290  OutData[iCnt].pof->close();
291  }
292  }
293  }
294 }
295 
296 /* Aggiungere qui le funzioni che aprono i singoli stream */
297 bool
299 {
300 #ifdef USE_NETCDF
301  if (out == NETCDF && !IsOpen(out)) {
302  m_pBinFile = new NcFile(_sPutExt((char*)(psExt[NETCDF])), NcFile::Replace);
303  m_pBinFile->set_fill(NcFile::Fill);
304 
305  if (!m_pBinFile->is_valid()) {
306  silent_cerr("NetCDF file is invalid" << std::endl);
307  throw ErrFile(MBDYN_EXCEPT_ARGS);
308  }
309 
310  // Let's define some dimensions which could be useful
311  m_DimTime = CreateDim("time");
312  m_DimV1 = CreateDim("vec1", 1);
313  m_DimV3 = CreateDim("vec3", 3);
314 
315  } else
316 #endif /* USE_NETCDF */
317  {
318  if (!IsOpen(out)) {
319  const char *fname = _sPutExt(psExt[out]);
320 
321  // Apre lo stream
322  OutData[out].pof->open(fname);
323 
324  if (!(*OutData[out].pof)) {
325  silent_cerr("Unable to open file "
326  "\"" << fname << "\"" << std::endl);
327  throw ErrFile(MBDYN_EXCEPT_ARGS);
328  }
329 
330  if (UseText(out)) {
331  // Setta la formattazione dei campi
332  if (UseDefaultPrecision(out)) {
333  OutData[out].pof->precision(iCurrPrecision);
334  }
335 
336  // Setta la notazione
337  if (UseScientific(out)) {
338  OutData[out].pof->setf(std::ios::scientific);
339  }
340  }
341  }
342 
343  return true;
344  }
345 
346  return false;
347 }
348 
349 bool
350 OutputHandler::Open(const int out, const std::string& postfix)
351 {
352  if (UseText(out) && !IsOpen(out)) {
353  std::string sCurrFileName = sGet();
354  std::stringstream fname_ss;
355 
356  unsigned uExtIdx = sCurrFileName.find_last_of(EXT_SEP);
357 
358  if (uExtIdx != std::string::npos) {
359  fname_ss << sCurrFileName.substr(0, uExtIdx);
360 
361  } else {
362  fname_ss << sCurrFileName;
363  }
364 
365  fname_ss << postfix << psExt[out] << std::ends;
366 
367  const std::string fname = fname_ss.str();
368 
369  // Opens the stream
370  OutData[out].pof->open(fname.c_str());
371 
372  if (!(*OutData[out].pof)) {
373  silent_cerr("Unable to open file "
374  "\"" << fname << "\"" << std::endl);
375  throw ErrFile(MBDYN_EXCEPT_ARGS);
376  }
377 
378  // Sets the field format
379  if (UseDefaultPrecision(out)) {
380  OutData[out].pof->precision(iCurrPrecision);
381  }
382 
383  // Sets the notation
384  if (UseScientific(out)) {
385  OutData[out].pof->setf(std::ios::scientific);
386  }
387 
388  return true;
389  }
390 
391  return false;
392 }
393 
394 bool
395 OutputHandler::IsOpen(int out) const
396 {
399 
400  return IsOpen(OutputHandler::OutFiles(out));
401 }
402 
403 bool
405 {
406 #ifdef USE_NETCDF
407  if (out == NETCDF) {
408  return m_pBinFile == 0 ? false : m_pBinFile->is_valid();
409  }
410 #endif /* USE_NETCDF */
411 
412  return OutData[out].pof == 0 ? false : OutData[out].pof->is_open();
413 }
414 
415 bool
417 {
420 
422 }
423 
424 bool
426 {
427  return (OutData[out].flags & OUTPUT_USE_SCIENTIFIC);
428 }
429 
430 bool
432 {
435 
437 }
438 
439 bool
441 {
443 }
444 
445 bool
447 {
450 
451  return UseText(OutputHandler::OutFiles(out));
452 }
453 
454 void
456 {
457  if (!(OutData[out].flags & OUTPUT_MAY_USE_TEXT)) {
459  }
460 
461  OutData[out].flags |= OUTPUT_USE_TEXT;
462 }
463 
464 void
466 {
467  for (int out = FIRSTFILE; out < LASTFILE; out++) {
468  if (OutData[out].flags & OUTPUT_MAY_USE_TEXT) {
469  OutData[out].flags &= ~OUTPUT_USE_TEXT;
470  }
471  }
472 }
473 
474 void
476 {
477  if (!(OutData[out].flags & OUTPUT_MAY_USE_TEXT)) {
479  }
480 
481  OutData[out].flags &= ~OUTPUT_USE_TEXT;
482 }
483 
484 bool
486 {
487  return (OutData[out].flags & OUTPUT_USE_TEXT);
488 }
489 
490 bool
492 {
495 
496  return UseNetCDF(OutputHandler::OutFiles(out));
497 }
498 
499 void
501 {
502  if (!(OutData[out].flags & OUTPUT_MAY_USE_NETCDF)) {
504  }
505 
506  OutData[out].flags |= OUTPUT_USE_NETCDF;
507 }
508 
509 void
511 {
512  for (int out = FIRSTFILE; out < LASTFILE; out++) {
513  if (OutData[out].flags & OUTPUT_MAY_USE_NETCDF) {
514  OutData[out].flags &= ~OUTPUT_USE_NETCDF;
515  }
516  }
517 }
518 
519 void
521 {
522  if (!(OutData[out].flags & OUTPUT_MAY_USE_NETCDF)) {
524  }
525 
526  OutData[out].flags &= ~OUTPUT_USE_NETCDF;
527 }
528 
529 bool
531 {
532  return (OutData[out].flags & OUTPUT_USE_NETCDF);
533 }
534 
535 bool
537 {
538  if (!IsOpen(out)) {
539  return false;
540  }
541 
542 #ifdef USE_NETCDF
543  if (out == NETCDF) {
544  m_pBinFile->close();
545 
546  } else
547 #endif /* USE_NETCDF */
548  {
549  // Chiude lo stream
550  OutData[out].pof->close();
551  }
552 
553  return true;
554 }
555 
556 bool
558 {
559  return Open(OUTPUT);
560 }
561 
562 bool
563 OutputHandler::RestartOpen(bool openResXSol)
564 {
565  if (!IsOpen(RESTART)) {
566  char *resExt = NULL;
567  int n = nCurrRestartFile > 0 ?
568  (int)log10(nCurrRestartFile) + 1 : 1;
569  int lenExt = STRLENOF(".")
570  + n
571  + STRLENOF(".rst")
572  + 1;
573 
574  SAFENEWARR(resExt, char, lenExt);
575  snprintf(resExt, lenExt, ".%.*d.rst", n, nCurrRestartFile);
576  /* Apre lo stream */
577  OutData[RESTART].pof->open(_sPutExt(resExt));
578 
579  if(!(*OutData[RESTART].pof)) {
580  std::cerr << "Unable to open file '" << _sPutExt(resExt)
581  << '\'' << std::endl;
582  throw ErrFile(MBDYN_EXCEPT_ARGS);
583  }
584  SAFEDELETEARR(resExt);
585 
586  /* Setta la formattazione dei campi */
588  OutData[RESTART].pof->precision(iCurrPrecision);
589  }
590 
591  /* Setta la notazione */
592  if(UseScientific(RESTART)) {
593  OutData[RESTART].pof->setf(std::ios::scientific);
594  }
595 
596  if (openResXSol) {
598 
599  char *resXSolExt = NULL;
600  int n = nCurrRestartFile > 0 ?
601  (int)log10(nCurrRestartFile) + 1 : 1;
602  int lenXSolExt = STRLENOF(".")
603  + n
604  + STRLENOF(".rst.X")
605  + 1;
606 
607  SAFENEWARR(resXSolExt, char, lenXSolExt);
608  snprintf(resXSolExt, lenXSolExt, ".%.*d.rst.X", n, nCurrRestartFile);
609  /* Apre lo stream */
610  OutData[RESTARTXSOL].pof->open(_sPutExt(resXSolExt));
611  if(!(*OutData[RESTARTXSOL].pof)) {
612  std::cerr << "Unable to open file '" << _sPutExt(resExt)
613  << '\'' << std::endl;
614  throw ErrFile(MBDYN_EXCEPT_ARGS);
615  }
616  SAFEDELETEARR(resXSolExt);
617  /* non occorre settare la precisione e il formato
618  perche' il file e' binario */
619  }
620 
622 
623  return false;
624  }
625 
626  return true;
627 }
628 
629 bool
631 {
633  return Open(PARTITION);
634 }
635 
636 bool
638 {
639  ASSERT(!IsOpen(LOG));
640  return Open(LOG);
641 }
642 
643 /* Setta precisione e dimensioni campo */
644 const int iWidth = 7; /* Caratteri richiesti dalla notazione esponenziale */
645 
646 void
648 {
649  ASSERT(iNewWidth > iWidth);
650  if (iNewWidth > iWidth) {
651  iCurrWidth = iNewWidth;
653  for (int iCnt = 0; iCnt < LASTFILE; iCnt++) {
654  if (UseDefaultPrecision(iCnt) && IsOpen(iCnt)) {
655  OutData[iCnt].pof->width(iCurrWidth);
656  OutData[iCnt].pof->precision(iCurrPrecision);
657  }
658  }
659  }
660 }
661 
662 void
663 OutputHandler::SetPrecision(int iNewPrecision)
664 {
665  ASSERT(iNewPrecision > 0);
666  if (iNewPrecision > 0) {
667  iCurrPrecision = iNewPrecision;
668  iCurrWidth = iNewPrecision + iWidth;
669  for (int iCnt = 0; iCnt < LASTFILE; iCnt++) {
670  if (UseDefaultPrecision(iCnt) && IsOpen(iCnt)) {
671  OutData[iCnt].pof->width(iCurrWidth);
672  OutData[iCnt].pof->precision(iCurrPrecision);
673  }
674  }
675  }
676 }
677 
678 void OutputHandler::SetExceptions(std::ios::iostate flags)
679 {
680  for (int iCnt = 0; iCnt < LASTFILE; iCnt++) {
681  if(OutData[iCnt].pof) {
682  OutData[iCnt].pof->exceptions(flags);
683  }
684  }
685 }
686 
687 #ifdef USE_NETCDF
688 const NcDim *
689 OutputHandler::CreateDim(const std::string& name, integer size)
690 {
691  ASSERT(m_pBinFile != 0);
692 
693  NcDim *dim;
694  if (size == -1) {
695  dim = m_pBinFile->add_dim(name.c_str());
696 
697  } else {
698  dim = m_pBinFile->add_dim(name.c_str(), size);
699  }
700 
701  if (dim == 0) {
702  std::ostringstream os;
703  os << "OutputHandler::CreateDim(\"" << name << "\"";
704  if (size > -1) {
705  os << ", " << size;
706  }
707  os << "): unable to add dimension";
708  silent_cerr(os.str() << std::endl);
710  }
711 
712  return dim;
713 }
714 
715 const NcDim *
716 OutputHandler::GetDim(const std::string& name) const
717 {
718  ASSERT(m_pBinFile != 0);
719 
720  return m_pBinFile->get_dim(name.c_str());
721 }
722 
723 NcVar *
724 OutputHandler::CreateVar(const std::string& name, NcType type,
725  const AttrValVec& attrs, const NcDimVec& dims)
726 {
727  NcVar *var;
728 
729  var = m_pBinFile->add_var(name.c_str(), type, dims.size(), const_cast<const NcDim **>(&dims[0]));
730  if (var == 0) {
731  silent_cerr("OutputHandler::CreateVar(\"" << name << "\") failed" << std::endl);
733  }
734 
735  for (AttrValVec::const_iterator i = attrs.begin(); i != attrs.end(); ++i) {
736  if (!var->add_att(i->attr.c_str(), i->val.c_str())) {
737  silent_cerr("OutputHandler::CreateVar(\"" << name << "\"): "
738  "add_att(\"" << i->attr << "\", \"" << i->val << "\") failed" << std::endl);
740  }
741  }
742 
743  return var;
744 }
745 
746 NcVar *
747 OutputHandler::CreateVar(const std::string& name, const std::string& type)
748 {
749  AttrValVec attrs(1);
750  attrs[0] = AttrVal("type", type);
751 
752  NcDimVec dims(1);
753  dims[0] = DimV1();
754 
755  return CreateVar(name, ncChar, attrs, dims);
756 }
757 
758 NcVar *
759 OutputHandler::CreateRotationVar(const std::string& name_prefix,
760  const std::string& name_postfix,
762  const std::string& description)
763 {
764  NcDimVec dim;
765  AttrValVec attrs;
766  std::string name(name_prefix);
767 
768  switch (od) {
769  case ORIENTATION_MATRIX:
770  dim.resize(3);
771  dim[0] = DimTime();
772  dim[1] = DimV3();
773  dim[2] = DimV3();
774 
775  attrs.resize(3);
776  attrs[0] = AttrVal("units", "-");
777  attrs[1] = AttrVal("type", "Mat3x3");
778  attrs[2] = AttrVal("description",
779  description + " orientation matrix "
780  "(R11, R21, R31, R12, R22, R32, R13, R23, R33)");
781 
782  name += "R";
783  break;
784 
785  case ORIENTATION_VECTOR:
786  dim.resize(2);
787  dim[0] = DimTime();
788  dim[1] = DimV3();
789 
790  attrs.resize(3);
791  attrs[0] = AttrVal("units", "radian");
792  attrs[1] = AttrVal("type", "Vec3");
793  attrs[2] = AttrVal("description",
794  description + " orientation vector "
795  "(Phi_X, Phi_Y, Phi_Z)");
796 
797  name += "Phi";
798  break;
799 
800  case EULER_123:
801  case EULER_313:
802  case EULER_321:
803  {
804  dim.resize(2);
805  dim[0] = DimTime();
806  dim[1] = DimV3();
807 
808  attrs.resize(3);
809  attrs[0] = AttrVal("units", "radian");
810  attrs[1] = AttrVal("type", "Vec3");
811 
812  std::string etype;
813  switch (od) {
814  case EULER_123:
815  etype = "123";
816  break;
817 
818  case EULER_313:
819  etype = "313";
820  break;
821 
822  case EULER_321:
823  etype = "321";
824  break;
825 
826  default:
828  }
829 
830  attrs[2] = AttrVal("description",
831  description + " orientation Euler angles (" + etype + ") "
832  "(E_X, E_Y, E_Z)");
833 
834  name += "E";
835  } break;
836 
837  default:
839  }
840 
841  name += name_postfix;
842  return CreateVar(name, ncDouble, attrs, dim);
843 }
844 #endif // USE_NETCDF
845 
846 /* OutputHandler - end */
847 
848 
849 /* ToBeOutput - begin */
850 
852 : fOutput(fOut)
853 {
854  NO_OP;
855 }
856 
858 {
859  NO_OP;
860 }
861 
862 void
864 {
865  NO_OP;
866 }
867 
868 /* Regular output */
869 void
871 {
872  NO_OP;
873 }
874 
875 /* Output of perturbed solution (modes ...) */
876 void
878  const VectorHandler& X, const VectorHandler& XP) const
879 {
880  NO_OP;
881 }
882 
883 flag
885 {
886  return fOutput;
887 }
888 
889 bool
891 {
892  return fOutput & flag(1);
893 }
894 
895 void
897 {
898  ASSERT(f ? f & flag(1) : 1);
899 
900  fOutput = f;
901 }
902 
904 :fTrace(fTrace)
905 {
906 
907 }
908 
910 {
911 
912 }
913 
915 {
916  return fTrace;
917 }
918 
920 {
921  ASSERT(f ? f & flag(1) : 1);
922 
923  fTrace = f;
924 }
925 
926 /* ToBeOutput - end */
void OutputHandler_int(void)
Definition: output.cc:121
std::ofstream ofRestartXSol
Definition: output.h:161
void SetWidth(int iNewWidth)
Definition: output.cc:647
ToBeOutput(flag fOut=fDefaultOut)
Definition: output.cc:851
void SetNetCDF(const OutputHandler::OutFiles out)
Definition: output.cc:500
int nCurrRestartFile
Definition: output.h:186
unsigned flags
Definition: output.h:139
std::ofstream ofPlates
Definition: output.h:177
long int flag
Definition: mbdyn.h:43
virtual bool bToBeOutput(void) const
Definition: output.cc:890
#define MBDYN_EXCEPT_ARGS
Definition: except.h:63
const int iDefaultWidth
Definition: output.cc:46
bool UseNetCDF(int out) const
Definition: output.cc:491
flag fOutput
Definition: output.h:658
std::ofstream ofGenels
Definition: output.h:166
const char *const _sPutExt(const char *n)
Definition: fn_UNIX.cc:161
virtual ~OutputHandler(void)
Definition: output.cc:276
std::ofstream ofAeroModals
Definition: output.h:168
std::ofstream ofBeams
Definition: output.h:158
std::ofstream ofInertia
Definition: output.h:155
bool Close(const OutputHandler::OutFiles out)
Definition: output.cc:536
void SetText(const OutputHandler::OutFiles out)
Definition: output.cc:455
const int iWidth
Definition: output.cc:644
#define SAFEDELETEARR(pnt)
Definition: mynewmem.h:713
long currentStep
Definition: output.h:107
std::ofstream ofAerodynamic
Definition: output.h:162
OrientationDescription
Definition: matvec3.h:1597
std::ofstream ofTraces
Definition: output.h:181
std::ofstream ofExternals
Definition: output.h:173
std::ofstream ofEigenanalysis
Definition: output.h:182
std::ofstream ofPresNodes
Definition: output.h:164
std::ofstream ofThermalElements
Definition: output.h:176
std::ofstream ofOutput
Definition: output.h:151
#define NO_OP
Definition: myassert.h:74
std::ofstream ofThermalNodes
Definition: output.h:175
std::ofstream ofAirProps
Definition: output.h:171
std::ofstream ofReferenceFrames
Definition: output.h:169
bool Open(const OutputHandler::OutFiles out)
Definition: output.cc:298
const char *const sGet(void) const
Definition: fn_UNIX.cc:200
void Init(const char *sFName, int iExtNum=-1)
Definition: output.cc:267
bool UseScientific(int out) const
Definition: output.cc:416
bool LogOpen(void)
Definition: output.cc:637
std::ofstream ofForces
Definition: output.h:157
std::ofstream ofElectric
Definition: output.h:153
std::ofstream ofRotors
Definition: output.h:159
void SetPrecision(int iNewPrecision)
Definition: output.cc:663
flag fTrace
Definition: output.h:697
OutputHandler(void)
Definition: output.cc:87
struct OutputHandler::@34 OutData[LASTFILE]
void SetExceptions(std::ios::iostate flags)
Definition: output.cc:678
const char * psExt[]
Definition: output.cc:49
std::ofstream * pof
Definition: output.h:138
std::ofstream ofParameters
Definition: output.h:172
const char EXT_SEP
Definition: filename.h:63
void ClearText(void)
Definition: output.cc:465
bool IsOpen(int out) const
Definition: output.cc:395
virtual void OutputPrepare(OutputHandler &OH)
Definition: output.cc:863
NcBool add_att(NcToken, char)
#define ASSERT(expression)
Definition: colamd.c:977
virtual ~Traceable(void)
Definition: output.cc:909
std::ofstream ofDofStats
Definition: output.h:179
std::ofstream ofDriveCallers
Definition: output.h:180
virtual flag fToBeTraced(void) const
Definition: output.cc:914
std::ofstream ofRestart
Definition: output.h:160
std::ofstream ofLog
Definition: output.h:170
int iCurrWidth
Definition: output.h:184
#define STRLENOF(s)
Definition: mbdyn.h:166
int iInit(const char *n, int i=0)
Definition: fn_UNIX.cc:63
virtual void SetTraceFlag(flag f=TRACE)
Definition: output.cc:919
virtual void Output(OutputHandler &OH) const
Definition: output.cc:870
virtual flag fToBeOutput(void) const
Definition: output.cc:884
std::ofstream ofHydraulic
Definition: output.h:163
bool UseDefaultPrecision(int out) const
Definition: output.cc:431
#define SAFENEWARR(pnt, item, sz)
Definition: mynewmem.h:701
std::ofstream ofGravity
Definition: output.h:178
void ClearNetCDF(void)
Definition: output.cc:510
virtual void SetOutputFlag(flag f=flag(1))
Definition: output.cc:896
std::ofstream ofStrNodes
Definition: output.h:152
int iCurrPrecision
Definition: output.h:185
std::ofstream ofPartition
Definition: output.h:167
long int integer
Definition: colamd.c:51
bool PartitionOpen(void)
Definition: output.cc:630
std::ofstream ofLoadable
Definition: output.h:165
const int iDefaultPrecision
Definition: output.cc:47
bool RestartOpen(bool openResXSol=false)
Definition: output.cc:563
std::ofstream ofJoints
Definition: output.h:156
bool OutputOpen(void)
Definition: output.cc:557
std::ofstream ofModal
Definition: output.h:174
bool UseText(int out) const
Definition: output.cc:446
#define OUTPUT_PRECISION
Definition: output.cc:43
std::ofstream ofAbstract
Definition: output.h:154
virtual ~ToBeOutput(void)
Definition: output.cc:857
Traceable(flag fTrace=0)
Definition: output.cc:903