dune-fem  2.4.1-rc
dataoutput.hh
Go to the documentation of this file.
1 #ifndef DUNE_FEM_DATAOUTPUT_HH
2 #define DUNE_FEM_DATAOUTPUT_HH
3 
4 #ifndef USE_VTKWRITER
5 #define USE_VTKWRITER 1
6 #endif
7 
8 //#define USE_GRAPE 0
9 
10 //- Dune includes
13 #include <dune/fem/io/parameter.hh>
21 
22 #ifndef ENABLE_VTXPROJECTION
23 #define ENABLE_VTXPROJECTION 1
24 #endif
25 
26 #if USE_VTKWRITER
28 #if ENABLE_VTXPROJECTION
31 #endif // #if ENABLE_VTXPROJECTION
32 #endif // #if USE_VTKWRITER
33 
34 #ifndef USE_GRAPE
35 // define whether to use grape of not
36 #define USE_GRAPE HAVE_GRAPE
37 #endif
38 
39 #if USE_GRAPE
40 #include <dune/grid/io/visual/grapedatadisplay.hh>
41 #endif
42 
43 namespace Dune
44 {
45 
46  namespace Fem
47  {
48 
58 #ifndef DOXYGEN
59  : public LocalParameter< DataOutputParameters, DataOutputParameters >
60 #endif
61  {
62  protected:
63  const std::string keyPrefix_;
65 
66  public:
67  explicit DataOutputParameters ( std::string keyPrefix, const ParameterReader &parameter = Parameter::container() )
68  : keyPrefix_( std::move( keyPrefix ) ), parameter_( parameter )
69  {}
70 
72  : keyPrefix_( "fem.io." ), parameter_( parameter )
73  {}
74 
76  virtual std::string path() const
77  {
78  return parameter().getValue< std::string >( keyPrefix_ + "path", "./" );
79  }
80 
81  virtual std::string absolutePath () const
82  {
83  std::string absPath = parameter().getValue< std::string >( "fem.prefix", "." ) + "/";
84  const std::string relPath = path();
85  if( relPath != "./" )
86  absPath += relPath;
87  return absPath;
88  }
89 
91  virtual std::string prefix () const
92  {
93  return parameter().getValue< std::string >( keyPrefix_ + "datafileprefix", "" );
94  }
95 
97  virtual int outputformat () const
98  {
99  static const std::string formatTable[]
100  = { "vtk-cell", "vtk-vertex", "sub-vtk-cell", "binary" , "gnuplot" , "none" };
101  int format = parameter().getEnum( keyPrefix_ + "outputformat", formatTable, 1 );
102  return format;
103  }
104 
105  virtual bool conformingoutput () const
106  {
107  return parameter().getValue< bool >( keyPrefix_ + "conforming", false );
108  }
109 
111  virtual bool grapedisplay () const
112  {
113 #if USE_GRAPE
114  return (parameter().getValue( keyPrefix_ + "grapedisplay", 0 ) == 1);
115 #else
116  return false;
117 #endif
118  }
119 
121  virtual double savestep () const
122  {
123  return parameter().getValue< double >( keyPrefix_ + "savestep", 0 );
124  }
125 
127  virtual int savecount () const
128  {
129  return parameter().getValue< int >( keyPrefix_ + "savecount", 0 );
130  }
131 
133  virtual int subsamplingLevel() const
134  {
135  return parameter().getValue< int >( keyPrefix_ + "subsamplinglevel", 1 );
136  }
137 
139  virtual int startcounter () const
140  {
141  return 0;
142  }
143 
145  virtual int startcall () const
146  {
147  return 0;
148  }
149 
151  virtual double startsavetime () const
152  {
153  return 0.0;
154  }
155 
158  virtual bool willWrite ( bool write ) const
159  {
160  return write;
161  }
162 
165  virtual bool writeMode() const
166  {
167  return true ;
168  }
169 
170  const ParameterReader &parameter () const noexcept { return parameter_; }
171  };
172 
173 
174 
182  template< class GridImp, class DataImp >
184  : public IOInterface
185  {
187 
188  protected:
189  template< class Grid, class OutputTuple, int N = std::tuple_size< OutputTuple >::value >
191 
192  template< class Grid, class OutputTuple, int N >
193  struct GridPartGetter
194  {
195  typedef typename TypeTraits< typename std::tuple_element< 0, OutputTuple >::type >::PointeeType DFType;
196  typedef typename DFType :: DiscreteFunctionSpaceType :: GridPartType GridPartType;
197 
198  GridPartGetter ( const Grid &, const OutputTuple &data )
199  : gridPart_( getGridPart( data ) )
200  {}
201 
202  const GridPartType &gridPart () const
203  {
204  return gridPart_;
205  }
206 
207  protected:
208  static const GridPartType &getGridPart( const OutputTuple& data )
209  {
210  const DFType *df = std::get< 0 >( data );
211  assert( df );
212  return df->space().gridPart();
213  }
214 
215  const GridPartType &gridPart_;
216  };
217 
218 
219  template< class Grid, class OutputTuple >
220  struct GridPartGetter< Grid, OutputTuple, 0 >
221  {
223 
224  GridPartGetter ( const Grid &grid, const OutputTuple & )
225  : gridPart_( const_cast< Grid & >( grid ) )
226  {}
227 
228  const GridPartType &gridPart () const
229  {
230  return gridPart_;
231  }
232 
233  protected:
234  const GridPartType gridPart_;
235  };
236 
237 
238 #if USE_VTKWRITER
239  template< class VTKIOType >
241  {
242  virtual ~VTKListEntry ()
243  {}
244  virtual void add ( VTKIOType & ) const = 0;
245 
246  protected:
248  {}
249  };
250 
251 #if ENABLE_VTXPROJECTION
252  template< class VTKIOType, class DFType >
253  class VTKFunc;
254 
255  template< class VTKOut >
257 #endif // #if ENABLE_VTXPROJECTION
258 
259  template< class VTKOut >
261 #endif // #if USE_VTKWRITER
262 
263  template< class GridPartType >
265 
266  protected:
267  enum OutputFormat { vtk = 0, vtkvtx = 1, subvtk = 2 , binary = 3, gnuplot = 4, none = 5 };
268 
270  typedef GridImp GridType;
272  typedef DataImp OutPutDataType;
273 
274  public:
281  DataOutput ( const GridType &grid, OutPutDataType &data, const DataOutputParameters &parameter );
282 
283  DataOutput ( const GridType &grid, OutPutDataType &data, const ParameterReader &parameter = Parameter::container() )
284  : DataOutput( grid, data, DataOutputParameters( parameter ) )
285  {}
286 
294  DataOutput ( const GridType &grid, OutPutDataType &data, const TimeProviderBase &tp, const DataOutputParameters &parameter );
295 
296  DataOutput ( const GridType &grid, OutPutDataType &data, const TimeProviderBase &tp, const ParameterReader &parameter = Parameter::container() )
297  : DataOutput( grid, data, tp, DataOutputParameters( parameter ) )
298  {}
299 
300  void consistentSaveStep ( const TimeProviderBase &tp ) const;
301 
303  virtual ~DataOutput()
304  {
305  delete param_;
306 
307  if( pvd_ )
308  {
309  pvd_ << " </Collection>" << std::endl;
310  pvd_ << "</VTKFile>" << std::endl;
311 
312  pvd_.close();
313  }
314  }
315 
316  protected:
318  void init ( const DataOutputParameters &parameter );
319 
320  public:
322  virtual bool willWrite ( const TimeProviderBase &tp ) const
323  {
324  // make save step consistent
325  consistentSaveStep( tp );
326 
327  const double saveTimeEps = 2*std::numeric_limits< double >::epsilon()*saveTime_;
328  const bool writeStep = (saveStep_ > 0) && (tp.time() - saveTime_ >= -saveTimeEps);
329  const bool writeCount = (saveCount_ > 0) && (writeCalls_ % saveCount_ == 0);
330  return param_->willWrite( writeStep || writeCount );
331  }
332 
334  virtual bool willWrite () const
335  {
336  return param_->willWrite( (saveCount_ > 0) && (writeCalls_ % saveCount_ == 0) );
337  }
338 
342  void write( const std::string& outstring ) const
343  {
344  if( willWrite() )
345  writeData( writeCalls_, outstring );
346  ++writeCalls_;
347  }
348 
350  void write() const
351  {
352  if( willWrite() )
353  writeData( writeCalls_, "" );
354  ++writeCalls_;
355  }
356 
361  void write(const TimeProviderBase& tp, const std::string& outstring ) const
362  {
363  if( willWrite(tp) )
364  writeData( tp.time(), outstring );
365  ++writeCalls_;
366  }
367 
371  void write( const TimeProviderBase& tp ) const
372  {
373  write( tp, "" );
374  }
375 
380  void writeData ( double sequenceStamp, const std::string &outstring ) const;
381 
385  void writeData ( double sequenceStamp ) const
386  {
387  writeData( sequenceStamp, "" );
388  }
389 
391  virtual const char* myClassName () const
392  {
393  return "DataOutput";
394  }
395 
397  const std::string &path () const
398  {
399  return path_;
400  }
401 
403  int writeStep() const
404  {
405  return writeStep_;
406  }
407 
409  int writeCalls() const
410  {
411  return writeCalls_;
412  }
413 
415  double saveTime() const
416  {
417  return saveTime_;
418  }
419 
420  protected:
421 #if USE_VTKWRITER
422  std::string writeVTKOutput () const;
423 #endif
424 
425  std::string writeGnuPlotOutput () const;
426 
428  virtual void writeBinaryData ( const double ) const
429  {
430  DUNE_THROW(NotImplemented, "Format 'binary' not supported by DataOutput, use DataWriter instead." );
431  }
432 
434  virtual void display () const
435  {
436  if( grapeDisplay_ )
437  grapeDisplay( data_ );
438  }
439 
440  protected:
442  template< class OutputTupleType >
443  void grapeDisplay ( OutputTupleType &data ) const;
444 
446  const GridType& grid_;
447  OutPutDataType &data_;
448 
449  // name for data output
450  std::string path_;
451  std::string datapref_;
452  // use grape display
454 
455  // counter for sequence of files
456  mutable int writeStep_;
457  // counter for call to write
458  mutable int writeCalls_;
459  // next point in time to save data
460  mutable double saveTime_;
461  // time interval to save files
462  double saveStep_;
463  // number of write call between writting files
465  // grape, vtk or ...
468  mutable std::ofstream sequence_;
469  mutable std::ofstream pvd_;
471  }; // end class DataOutput
472 
473 
474 
475  // DataOutput::GridPartGetter
476  // --------------------------
477 
478 
479  // DataOutput::VTKFunc
480  // -------------------
481 
482 #if USE_VTKWRITER
483 #if ENABLE_VTXPROJECTION
484  template< class GridImp, class DataImp >
485  template< class VTKIOType, class DFType >
486  class DataOutput< GridImp, DataImp >::VTKFunc
487  : public VTKListEntry< VTKIOType >
488  {
489  typedef typename VTKIOType::GridPartType GridPartType;
490  typedef typename DFType::DiscreteFunctionSpaceType::FunctionSpaceType FunctionSpaceType;
491 
493  typedef AdaptiveDiscreteFunction< LagrangeSpaceType > NewFunctionType;
494 
495  public:
496  VTKFunc ( const GridPartType &gridPart, const DFType &df )
497  : df_( df ),
498  space_( const_cast< GridPartType & >( gridPart ) ),
499  func_( 0 )
500  {
501  // space_.setDescription(df.space().getDescription());
502  }
503 
505  {
506  delete func_;
507  }
508 
509  virtual void add ( VTKIOType &vtkio ) const
510  {
511  func_ = new NewFunctionType( df_.name()+"vtx-prj" , space_ );
512  if( df_.space().continuous() )
513  {
514  // vtkio.addVertexData( df_ );
516  }
517  else
518  {
520  VtxProjectionImpl::project( df_, *func_, weight );
521  }
522  vtkio.addVertexData( *func_ );
523  }
524 
525  private:
526  VTKFunc ( const VTKFunc & );
527 
528  const DFType& df_;
529  LagrangeSpaceType space_;
530  mutable NewFunctionType *func_;
531  };
532 #endif // #if ENABLE_VTXPROJECTION
533 #endif // #if USE_VTKWRITER
534 
535 
536 
537  // DataOutput::VTKOutputerDG
538  // -------------------------
539 
540 #if USE_VTKWRITER
541  template< class GridImp, class DataImp >
542  template< class VTKOut >
543  struct DataOutput< GridImp, DataImp >::VTKOutputerDG
544  {
546  explicit VTKOutputerDG ( VTKOut &vtkOut, bool conforming = false )
547  : vtkOut_( vtkOut ),
548  conforming_( conforming )
549  {}
550 
552  template< class DFType >
553  void visit ( DFType *df )
554  {
555  if( df )
556  {
557  if( conforming_ || (df->space().order() == 0) )
558  vtkOut_.addCellData( *df );
559  else
560  vtkOut_.addVertexData( *df );
561  }
562  }
563 
564  template< class OutputTuple >
565  void forEach ( OutputTuple &data )
566  {
567  ForEachValue< OutputTuple > forEach( data );
568  forEach.apply( *this );
569  }
570 
571  private:
572  VTKOut &vtkOut_;
573  bool conforming_;
574  };
575 #endif // #if USE_VTKWRITER
576 
577 
578 
579  // DataOutput::VTKOutputerLagrange
580  // -------------------------------
581 
582 #if USE_VTKWRITER
583 #if ENABLE_VTXPROJECTION
584  template< class GridImp, class DataImp >
585  template< class VTKOut >
586  struct DataOutput< GridImp, DataImp >::VTKOutputerLagrange
587  {
589  explicit VTKOutputerLagrange ( VTKOut &vtkOut )
590  : vtkOut_( vtkOut ),
591  vec_()
592  {}
593 
596  {
597  for( auto& entry : vec_ )
598  {
599  delete entry;
600  entry = nullptr;
601  }
602  }
603 
605  template< class DFType >
606  void visit ( DFType *df )
607  {
608  if( df )
609  {
610  auto entry = new VTKFunc< VTKOut, DFType >( vtkOut_.gridPart(), *df );
611  entry->add( vtkOut_ );
612  vec_.push_back( entry );
613  }
614  }
615 
616  template< class OutputTuple >
617  void forEach ( OutputTuple &data )
618  {
619  ForEachValue< OutputTuple > forEach( data );
620  forEach.apply( *this );
621  }
622 
623  private:
624  VTKOut &vtkOut_;
626  std::vector< VTKListEntryType * > vec_;
627  };
628 #endif // #if ENABLE_VTXPROJECTION
629 #endif // #if USE_VTKWRITER
630 
631 
632 
633  // DataOutput::GnuplotOutputer
634  // ---------------------------
635 
636  template< class GridImp, class DataImp >
637  template< class GridPartType >
638  class DataOutput< GridImp, DataImp >::GnuplotOutputer
639  {
640  typedef typename GridPartType::template Codim< 0 >::IteratorType::Entity Entity;
641  std::ostream& out_;
643  int i_;
644  const Entity& en_;
645 
646  public:
648  GnuplotOutputer ( std::ostream& out,
650  int i,
651  const Entity &en )
652  : out_(out), quad_(quad), i_(i), en_(en)
653  {}
654 
656  template <class DFType>
657  void visit(DFType* df)
658  {
659  if( df )
660  {
661  auto lf = df->localFunction(en_);
662  typename DFType::DiscreteFunctionSpaceType::RangeType u;
663  lf.evaluate( quad_[ i_ ], u );
664 
665  DUNE_CONSTEXPR int dimRange = DFType::DiscreteFunctionSpaceType::dimRange;
666  for( auto k = 0; k < dimRange; ++k )
667  out_ << " " << u[ k ];
668  }
669  }
670 
671  template< class OutputTuple >
672  void forEach ( OutputTuple &data )
673  {
674  ForEachValue< OutputTuple > forEach( data );
675  forEach.apply( *this );
676  }
677  };
678 
679 
680 
681  // Implementation of DataOutput
682  // ----------------------------
683 
684  template< class GridImp, class DataImp >
686  ::DataOutput ( const GridType &grid, OutPutDataType &data,
687  const DataOutputParameters& parameter )
688  : grid_( grid ),
689  data_( data ),
690  writeStep_(0),
691  writeCalls_(0),
692  saveTime_(0),
693  saveStep_(-1),
694  saveCount_(-1),
695  outputFormat_(vtkvtx),
696  conformingOutput_( false ),
697  param_(parameter.clone())
698  {
699  // initialize class
700  init( parameter );
701  }
702 
703 
704  template< class GridImp, class DataImp >
706  ::DataOutput ( const GridType &grid, OutPutDataType &data,
707  const TimeProviderBase &tp,
708  const DataOutputParameters &parameter )
709  : grid_(grid),
710  data_(data),
711  writeStep_(0),
712  writeCalls_(0),
713  saveTime_(0),
714  saveStep_(-1),
715  saveCount_(-1),
716  outputFormat_(vtkvtx),
717  conformingOutput_( false ),
718  param_(parameter.clone())
719  {
720  // initialize class
721  init( parameter );
722 
723  // make save step consistent
724  consistentSaveStep( tp );
725  }
726 
727  template< class GridImp, class DataImp >
730  {
731  // set old values according to new time
732  if( saveStep_ > 0 )
733  {
734  const auto oldTime = tp.time() - saveStep_;
735  while( saveTime_ <= oldTime )
736  {
737  ++writeStep_;
738  saveTime_ += saveStep_;
739  }
740  }
741  }
742 
743 
744  template< class GridImp, class DataImp >
746  init ( const DataOutputParameters &parameter )
747  {
748  const bool writeMode = parameter.writeMode();
749  path_ = parameter.absolutePath();
750 
751  // create path if not already exists
752  if( writeMode )
753  IOInterface :: createGlobalPath ( grid_.comm(), path_ );
754 
755  // add prefix for data file
756  datapref_ += parameter.prefix();
757 
758  auto outputFormat = parameter.outputformat();
759  switch( outputFormat )
760  {
761  case 0: outputFormat_ = vtk; break;
762  case 1: outputFormat_ = vtkvtx; break;
763  case 2: outputFormat_ = subvtk; break;
764  case 3: outputFormat_ = binary; break;
765  case 4: outputFormat_ = gnuplot; break;
766  case 5: outputFormat_ = none; break;
767  default:
768  DUNE_THROW(NotImplemented,"DataOutput::init: wrong output format");
769  }
770 
771  conformingOutput_ = parameter.conformingoutput();
772 
773  grapeDisplay_ = parameter.grapedisplay();
774 
775  // get parameters for data writing
776  saveStep_ = parameter.savestep();
777  saveCount_ = parameter.savecount();
778 
779  // set initial quantities
780  writeStep_ = parameter.startcounter();
781  writeCalls_ = parameter.startcall();
782  saveTime_ = parameter.startsavetime();
783 
784  if( writeMode )
785  {
786  // only write series file for VTK output
787  if ( Parameter :: verbose() && outputFormat_ < binary )
788  {
789  {
790  std::string name = path_ + "/" + datapref_;
791  name += ".series";
792  std::cout << "opening file: " << name << std::endl;
793  sequence_.open(name.c_str());
794  if ( ! sequence_ )
795  std::cout << "could not write sequence file" << std::endl;
796  }
797 
798  {
799  std::string name = path_ + "/" + datapref_;
800  name += ".pvd";
801  std::cout << "opening file: " << name << std::endl;
802  pvd_.open(name.c_str());
803  if ( ! pvd_ )
804  std::cout << "could not write sequence file" << std::endl;
805  else
806  {
807  pvd_ << "<?xml version=\"1.0\"?>" << std::endl;
808  pvd_ << "<VTKFile type=\"Collection\" version=\"0.1\" byte_order=\"LittleEndian\">" << std::endl;
809  pvd_ << " <Collection>" << std::endl;
810  }
811  }
812  }
813 
814  // write parameter file
815  Parameter::write("parameter.log");
816  }
817  }
818 
819 
820  template< class GridImp, class DataImp >
822  ::writeData ( double sequenceStamp, const std::string &outstring ) const
823  {
824  std::string filename;
825  // check online display
826  display();
827  switch( outputFormat_ )
828  {
829  // if no output was chosen just return
830  case none: break ;
831  case binary: writeBinaryData( sequenceStamp ); break;
832  case vtk :
833  case vtkvtx :
834  case subvtk :
835 #if USE_VTKWRITER
836  // write data in vtk output format
837  filename = writeVTKOutput();
838  break;
839 #else
840  DUNE_THROW(NotImplemented,"DataOutput::write: VTKWriter was disabled by USE_VTKWRITER 0");
841 #endif // #if USE_VTKWRITER
842  case gnuplot : filename = writeGnuPlotOutput(); break;
843  default:
844  DUNE_THROW(NotImplemented,"DataOutput::write: wrong output format = " << outputFormat_);
845  }
846 
847  if( outputFormat_ != none )
848  {
849  if( sequence_ )
850  sequence_ << writeStep_ << " "
851  << filename << " "
852  << sequenceStamp
853  << outstring
854  << std::endl;
855 
856  if( pvd_ )
857  {
858  // cH: only use the basename of filename, Paraview will
859  // prepend the leading path correctly, if the pvd-file
860  // resides in the same directory as the data files.
861  std::string basefilename;
862  auto pos = filename.find_last_of( '/' );
863  if (pos == filename.npos)
864  pos = -1;
865  basefilename = filename.substr( pos+1, filename.npos );
866  pvd_ << " <DataSet timestep=\"" << sequenceStamp << "\" "
867  << "group=\"\" part=\"0\" "
868  << "file=\""<<basefilename<<"\"/>" << std::endl;
869  }
870 
871  if( Parameter::verbose() )
872  {
873  // only write info for proc 0, otherwise on large number of procs
874  // this is to much output
875  std::cout << myClassName() << "[" << grid_.comm().rank() << "]::write data"
876  << " writestep=" << writeStep_
877  << " sequenceStamp=" << sequenceStamp
878  << outstring
879  << std::endl;
880  }
881  }
882 
883  saveTime_ += saveStep_;
884  ++writeStep_;
885  }
886 
887 
888 #if USE_VTKWRITER
889  template< class GridImp, class DataImp >
891  {
892  std::string filename;
893  // check whether to use vertex data of discontinuous data
894  const bool vertexData = (outputFormat_ == vtkvtx);
895 
896  // check whether we have parallel run
897  const bool parallel = (grid_.comm().size() > 1);
898 
899  // generate filename, with path only for serial run
900  auto name = generateFilename( (parallel ? datapref_ : path_ + "/" + datapref_ ), writeStep_ );
901 
902  if( vertexData )
903  {
904 #if ENABLE_VTXPROJECTION
905  // get gridpart from first discrete function in tuple
906  typedef GridPartGetter< GridType, OutPutDataType > GridPartGetterType;
907  GridPartGetterType gp( grid_, data_ );
908  const auto &gridPart = gp.gridPart();
909 
910  // create vtk output handler
912  VTKIOType vtkio ( gridPart, VTK::conforming, param_->parameter() );
913 
914  // add all functions
916  io.forEach( data_ );
917 
918  if( parallel )
919  {
920  // write all data for parallel runs
921  filename = vtkio.pwrite( name, path_, "." );
922  }
923  else
924  {
925  // write all data serial
926  filename = vtkio.write( name );
927  }
928 #endif
929  }
930  else if ( outputFormat_ == vtk )
931  {
932  typedef GridPartGetter< GridType, OutPutDataType> GridPartGetterType;
933  GridPartGetterType gp( grid_, data_ );
934 
935  // create vtk output handler
937  VTKIOType vtkio( gp.gridPart(), conformingOutput_ ? VTK::conforming : VTK::nonconforming, param_->parameter() );
938 
939  // add all functions
940  VTKOutputerDG< VTKIOType > io( vtkio, conformingOutput_ );
941  io.forEach( data_ );
942 
943  // write all data
944  if( parallel )
945  {
946  // write all data for parallel runs
947  filename = vtkio.pwrite( name, path_, "." );
948  }
949  else
950  {
951  // write all data serial
952  filename = vtkio.write( name );
953  }
954  }
955  else if ( outputFormat_ == subvtk )
956  {
957  typedef GridPartGetter< GridType, OutPutDataType> GridPartGetterType;
958  GridPartGetterType gp( grid_, data_ );
959 
960  // create vtk output handler
962  VTKIOType vtkio ( gp.gridPart(), static_cast< unsigned int >( param_->subsamplingLevel() ), param_->parameter() );
963 
964  // add all functions
965  VTKOutputerDG< VTKIOType > io( vtkio, conformingOutput_ );
966  io.forEach( data_ );
967 
968  // write all data
969  if( parallel )
970  {
971  // write all data for parallel runs
972  filename = vtkio.pwrite( name, path_, "." );
973  }
974  else
975  {
976  // write all data serial
977  filename = vtkio.write( name );
978  }
979  }
980  return filename;
981  }
982 #endif // #if USE_VTKWRITER
983 
984 
985  template< class GridImp, class DataImp >
987  {
988  // generate filename
989  auto name = generateFilename( path_ + "/" + datapref_, writeStep_ );
990  name += ".gnu";
991  std::ofstream gnuout(name.c_str());
992  gnuout << std::scientific << std::setprecision( 16 );
993 
994  typedef GridPartGetter< GridType, OutPutDataType > GridPartGetterType;
995  GridPartGetterType gp( grid_, data_ );
996  const auto &gridPart = gp.gridPart();
997 
998  // start iteration
999  typedef typename GridPartGetterType::GridPartType GridPartType;
1000  typedef typename GridPartType::GridViewType GridViewType;
1001  for( const auto entity : elements( static_cast<GridViewType>( gridPart ) ) )
1002  {
1003  CachingQuadrature< GridPartType, 0 > quad( entity, 1 );
1004  for( unsigned int i = 0; i < quad.nop(); ++i )
1005  {
1006  const auto x = entity.geometry().global( quad.point( i ) );
1007  for( auto k = 0; k < x.dimension; ++k )
1008  gnuout << (k > 0 ? " " : "") << x[ k ];
1009  GnuplotOutputer< GridPartType > io( gnuout, quad, i, entity );
1010  io.forEach( data_ );
1011  gnuout << std::endl;
1012  }
1013  }
1014  return name;
1015  }
1016 
1017 
1018 #if USE_GRAPE
1019  template< class GridImp, class DataImp >
1020  template< class OutputTupleType >
1021  inline void DataOutput< GridImp, DataImp >::grapeDisplay ( OutputTupleType &data ) const
1022  {
1023  GrapeDataDisplay<GridType> grape(grid_);
1025  grape.display();
1026  }
1027 #else // #if USE_GRAPE
1028  template< class GridImp, class DataImp >
1029  template< class OutputTupleType >
1030  inline void DataOutput< GridImp, DataImp >::grapeDisplay ( OutputTupleType &data ) const
1031  {
1032  std::cerr << "WARNING: HAVE_GRAPE == 0, but grapeDisplay == true, recompile with grape support for online display!" << std::endl;
1033  }
1034 #endif // #else // #if USE_GRAPE
1035 
1036  } // end namespace Fem
1037 
1038 } // namespace Dune
1039 
1040 #endif // #ifndef DUNE_FEM_DATAOUTPUT_HH
DataOutput(const GridType &grid, OutPutDataType &data, const ParameterReader &parameter=Parameter::container())
Definition: dataoutput.hh:283
static void project(const Function &f, DiscreteFunction &u, Weight &weight)
Definition: vtxprojection.hh:32
std::string writeGnuPlotOutput() const
Definition: dataoutput.hh:986
void visit(DFType *df)
Applies the setting on every DiscreteFunction/LocalFunction pair.
Definition: dataoutput.hh:606
virtual int subsamplingLevel() const
save data every subsamplingLevel (fem.io.subsamplinglevel)
Definition: dataoutput.hh:133
std::string path_
Definition: dataoutput.hh:450
DataImp OutPutDataType
type of data tuple
Definition: dataoutput.hh:272
void visit(DFType *df)
Applies the setting on every DiscreteFunction/LocalFunction pair.
Definition: dataoutput.hh:553
VTKOutputerDG(VTKOut &vtkOut, bool conforming=false)
Constructor.
Definition: dataoutput.hh:546
virtual bool willWrite(const TimeProviderBase &tp) const
returns true if data will be written on next write call
Definition: dataoutput.hh:322
OutputFormat outputFormat_
Definition: dataoutput.hh:466
DFType::DiscreteFunctionSpaceType::GridPartType GridPartType
Definition: dataoutput.hh:196
GnuplotOutputer(std::ostream &out, CachingQuadrature< GridPartType, 0 > &quad, int i, const Entity &en)
Constructor.
Definition: dataoutput.hh:648
std::string writeVTKOutput() const
Definition: dataoutput.hh:890
int writeCalls() const
return write calls
Definition: dataoutput.hh:409
std::string datapref_
Definition: dataoutput.hh:451
const ParameterReader & parameter() const noexcept
Definition: dataoutput.hh:170
virtual ~VTKListEntry()
Definition: dataoutput.hh:242
double saveStep_
Definition: dataoutput.hh:462
void forEach(OutputTuple &data)
Definition: dataoutput.hh:672
virtual double startsavetime() const
value of first save time (no parameter available)
Definition: dataoutput.hh:151
int writeStep_
Definition: dataoutput.hh:456
virtual void writeBinaryData(const double) const
write binary data
Definition: dataoutput.hh:428
int getEnum(const std::string &key, const std::string(&values)[n]) const
Definition: reader.hh:215
int writeStep() const
return write step
Definition: dataoutput.hh:403
void write(const TimeProviderBase &tp) const
write given data to disc, evaluates parameter savecount and savestep
Definition: dataoutput.hh:371
Implementation of the Dune::Fem::IOInterface. This class manages data output. Available output format...
Definition: dataoutput.hh:183
~VTKOutputerLagrange()
destructor, delete entries of list
Definition: dataoutput.hh:595
virtual bool willWrite(bool write) const
Definition: dataoutput.hh:158
Definition: adaptivefunction/adaptivefunction.hh:34
virtual std::string absolutePath() const
Definition: dataoutput.hh:81
DataOutputParameters(std::string keyPrefix, const ParameterReader &parameter=Parameter::container())
Definition: dataoutput.hh:67
DataOutput(const GridType &grid, OutPutDataType &data, const TimeProviderBase &tp, const ParameterReader &parameter=Parameter::container())
Definition: dataoutput.hh:296
Definition: vtkio.hh:528
virtual int startcall() const
number of first call (no parameter available)
Definition: dataoutput.hh:145
void write(const TimeProviderBase &tp, const std::string &outstring) const
write given data to disc, evaluates parameter savecount and savestep
Definition: dataoutput.hh:361
void visit(DFType *df)
Applies the setting on every DiscreteFunction/LocalFunction pair.
Definition: dataoutput.hh:657
const GridType & grid_
type of this class
Definition: dataoutput.hh:446
Definition: dataoutput.hh:260
virtual std::string prefix() const
base of file name for data file (fem.io.datafileprefix)
Definition: dataoutput.hh:91
void write(const std::string &outstring) const
write given data to disc, evaluates parameter savecount
Definition: dataoutput.hh:342
const DataOutputParameters * param_
Definition: dataoutput.hh:470
bool conformingOutput_
Definition: dataoutput.hh:467
OutputFormat
Definition: dataoutput.hh:267
virtual bool conformingoutput() const
Definition: dataoutput.hh:105
const GridPartType & gridPart() const
Definition: dataoutput.hh:202
Definition: vtxprojection.hh:17
Parameter class for Dune::Fem::DataOutput.
Definition: dataoutput.hh:57
virtual int startcounter() const
number for first data file (no parameter available)
Definition: dataoutput.hh:139
~VTKFunc()
Definition: dataoutput.hh:504
Definition: dataoutput.hh:253
general base for time providers
Definition: timeprovider.hh:35
Definition: dataoutput.hh:190
std::string generateFilename(const std::string &fn, int ntime, int precision=6)
Definition: iointerface.hh:47
Definition: dataoutput.hh:264
VTKListEntry()
Definition: dataoutput.hh:247
virtual void display() const
display data with grape
Definition: dataoutput.hh:434
virtual bool grapedisplay() const
use online grape display (fem.io.grapedisplay)
Definition: dataoutput.hh:111
Definition: io/parameter.hh:549
Definition: coordinate.hh:4
DataOutputParameters(const ParameterReader &parameter=Parameter::container())
Definition: dataoutput.hh:71
int writeCalls_
Definition: dataoutput.hh:458
Definition: dataoutput.hh:256
const GridPartType & gridPart_
Definition: dataoutput.hh:215
GridImp GridType
type of grid used
Definition: dataoutput.hh:270
Definition: dataoutput.hh:240
virtual ~DataOutput()
destructor
Definition: dataoutput.hh:303
void init(const DataOutputParameters &parameter)
initialize data writer
Definition: dataoutput.hh:746
static ParameterContainer & container()
Definition: io/parameter.hh:190
AdaptiveLeafGridPart< Grid > GridPartType
Definition: dataoutput.hh:222
static void write(const std::string &filename, const std::string &fileextension="", bool writeAll=true)
write the parameter database to a file
Definition: io/parameter.hh:515
int saveCount_
Definition: dataoutput.hh:464
virtual bool willWrite() const
returns true if data will be written on next write call
Definition: dataoutput.hh:334
virtual void add(VTKIOType &vtkio) const
Definition: dataoutput.hh:509
STL namespace.
void consistentSaveStep(const TimeProviderBase &tp) const
Definition: dataoutput.hh:729
OutPutDataType & data_
Definition: dataoutput.hh:447
GridPartGetter(const Grid &, const OutputTuple &data)
Definition: dataoutput.hh:198
void writeData(double sequenceStamp) const
write data with a given sequence stamp
Definition: dataoutput.hh:385
static void createGlobalPath(const CommunicatorType &comm, const std::string &path)
create global path for data output
Definition: iointerface.hh:267
static const GridPartType & getGridPart(const OutputTuple &data)
Definition: dataoutput.hh:208
static bool verbose()
obtain the cached value for fem.verbose
Definition: io/parameter.hh:444
IOInterface to write data to hard disk.
Definition: iointerface.hh:161
void move(ArrayInterface< T > &array, const unsigned int oldOffset, const unsigned int newOffset, const unsigned int length)
Definition: array_inline.hh:38
void forEach(OutputTuple &data)
Definition: dataoutput.hh:565
void write() const
write given data to disc, evaluates parameter savecount
Definition: dataoutput.hh:350
virtual std::string path() const
path where the data is stored (always relative to fem.prefix)
Definition: dataoutput.hh:76
ParameterReader parameter_
Definition: dataoutput.hh:64
const std::string & path() const
return output path name
Definition: dataoutput.hh:397
Definition: adaptiveleafgridpart.hh:248
T getValue(const std::string &key) const
get mandatory parameter
Definition: reader.hh:149
const std::string keyPrefix_
Definition: dataoutput.hh:63
static void addToDisplay(Disp &disp, const DINFO *dinf, double time, Tuple &tuple)
Definition: iotuple.hh:270
static void interpolateFunction(const Function &function, DiscreteFunctionType &discreteFunction)
Definition: lagrangeinterpolation.hh:82
const GridPartType gridPart_
Definition: dataoutput.hh:234
std::ofstream pvd_
Definition: dataoutput.hh:469
TypeTraits< typename std::tuple_element< 0, OutputTuple >::type >::PointeeType DFType
Definition: dataoutput.hh:195
void forEach(OutputTuple &data)
Definition: dataoutput.hh:617
double time() const
obtain the current time
Definition: timeprovider.hh:94
Definition: vtkio.hh:27
std::ofstream sequence_
Definition: dataoutput.hh:468
GridPartGetter(const Grid &grid, const OutputTuple &)
Definition: dataoutput.hh:224
VTKOutputerLagrange(VTKOut &vtkOut)
Constructor.
Definition: dataoutput.hh:589
VTKFunc(const GridPartType &gridPart, const DFType &df)
Definition: dataoutput.hh:496
double saveTime() const
return save time
Definition: dataoutput.hh:415
virtual int outputformat() const
format of output (fem.io.outputformat)
Definition: dataoutput.hh:97
bool grapeDisplay_
Definition: dataoutput.hh:453
DataOutput(const GridType &grid, OutPutDataType &data, const DataOutputParameters &parameter)
Constructor creating data output class.
Definition: dataoutput.hh:686
double saveTime_
Definition: dataoutput.hh:460
const GridPartType & gridPart() const
Definition: dataoutput.hh:228
void writeData(double sequenceStamp, const std::string &outstring) const
write data with a given sequence stamp and outstring
Definition: dataoutput.hh:822
void grapeDisplay(OutputTupleType &data) const
display data with grape
Definition: dataoutput.hh:1030
virtual const char * myClassName() const
print class name
Definition: dataoutput.hh:391
virtual double savestep() const
save data every savestep interval (fem.io.savestep)
Definition: dataoutput.hh:121
virtual bool writeMode() const
Definition: dataoutput.hh:165
virtual int savecount() const
save data every savecount calls to write method (fem.io.savecount)
Definition: dataoutput.hh:127