* trailing element of DataComponentInterpretation::component_is_scalar . The
* array is then given as an extra argument to DataOut::add_data_vector to
* explain how the data in the given solution vector is to be interpreted.
- * Visualization programs like Visit and Paraview will then offer to show
+ * Visualization programs like VisIt and Paraview will then offer to show
* these <code>dim</code> components as vector fields, rather than as
* individual scalar fields.
*
<code>gnuplot</code> and a postscript viewer (for <code>eps</code>) should be available almost everywhere. In the last few years, most new visualization programs have moved to support
<code>vtk</code>/<code>vtu</code> format. There are a number of excellent programs that can read <code>vtk</code> and
<code>vtu</code>, such as
- <a href="http://www.llnl.gov/visit/" target="_top">Visit</a>,
+ <a href="http://www.llnl.gov/visit/" target="_top">VisIt</a>,
<a href="http://www.paraview.org/" target="_top">ParaView</a>, as well as others. Povray is freely available for almost all platforms. AVS is a commercial program available for most Unix flavors. Tecplot is a commercial program available
for Windows and most Unix platforms.
</p>
0). These files contain the locally owned cells for the timestep and
processor. The files <code>solution-TTTT.visit</code> is the visit record
for timestep <code>TTTT</code>, while <code>solution-TTTT.pvtu</code> is
-the same for ParaView. (More recent versions of Visit can actually read
+the same for ParaView. (More recent versions of VisIt can actually read
<code>.pvtu</code> files as well, but it doesn't hurt to output both
kinds of record files.) Finally, the file
<code>solution.pvd</code> is a special record only supported by ParaView that references
Apart from the output shown above, the program generated the file
<code>solution.vtk</code>, which is in the VTK format that is widely
used by many visualization programs today -- including the two
-heavy-weights <a href="https://www.llnl.gov/visit">Visit</a> and
+heavy-weights <a href="https://www.llnl.gov/visit">VisIt</a> and
<a href="https://www.paraview.org">Paraview</a> that are the most
commonly used programs for this purpose today.
-Using Visit, it is not very difficult to generate a picture of the
+Using VisIt, it is not very difficult to generate a picture of the
solution like this:
<table width="60%" align="center">
<tr>
force density will therefore intuitively lead to a membrane that
simply bulges upward -- like the one shown above.
-Visit and Paraview both allow playing with various kinds of visualizations
+VisIt and Paraview both allow playing with various kinds of visualizations
of the solution. Several video lectures show how to use these programs.
@dealiiVideoLectureSeeAlso{11,32}
The program produces two files: <code>solution-2d.vtk</code> and
<code>solution-3d.vtk</code>, which can be viewed using the programs
-Visit or Paraview (in case you do not have these programs, you can easily
+VisIt or Paraview (in case you do not have these programs, you can easily
change the
output format in the program to something which you can view more
easily). Visualizing solutions is a bit of an art, but it can also be fun, so
which is not the same as displaying information. In particular, it is easy to
overload a picture with information, but while it shows more information it
makes it also more difficult to glean insight. As an example, the program I
-used to generate these pictures, Visit, by default puts tick marks on every
+used to generate these pictures, VisIt, by default puts tick marks on every
axis, puts a big fat label "X Axis" on the $x$ axis and similar for the other
axes, shows the file name from which the data was taken in the top left and
the name of the user doing so and the time and date on the bottom right. None
// set of output files can be read at once. These <code>.pvtu</code>
// are used by Paraview to describe an entire parallel computation's
// output files. We then do the same again for the competitor of
- // Paraview, the Visit visualization program, by creating a matching
+ // Paraview, the VisIt visualization program, by creating a matching
// <code>.visit</code> file.
const std::string master_name = data_out.write_vtu_with_pvtu_record(
output_dir, "solution", current_refinement_cycle, mpi_communicator, 2);
// @sect4{Solid::output_results}
// Here we present how the results are written to file to be viewed
- // using ParaView or Visit. The method is similar to that shown in previous
+ // using ParaView or VisIt. The method is similar to that shown in previous
// tutorials so will not be discussed in detail.
template <int dim>
void Solid<dim>::output_results() const
In practice, it might be interesting to visualize such quality measures.
The function GridTools::compute_aspect_ratio_of_cells() provides one
way to get this kind of information. Even better, visualization tools
-such as Visit often allow you to visualize this sort of information
+such as VisIt often allow you to visualize this sort of information
for a variety of measures from within the visualization software
-itself; in the case of Visit, just add a "pseudo-color" plot and select
+itself; in the case of VisIt, just add a "pseudo-color" plot and select
one of the mesh quality measures instead of the solution field.
<h3>Mode profile</h3>
-We can inspect the mode profile with Paraview or Visit.
+We can inspect the mode profile with Paraview or VisIt.
As we have discussed, at resonance all the mechanical
energy is transmitted and the amplitude of motion is amplified inside the cavity.
It can be observed that the PMLs are quite effective to truncate the solution.
There is not much to be said about the results of this program, other than
-that they look nice. All images were made using Visit from the
+that they look nice. All images were made using VisIt from the
output files that the program wrote to disk. The first two pictures show
the $x$- and $y$-displacements as scalar components:
quantities) but that the two components actually are the parts of a
vector-valued quantity, namely the displacement. Absent this knowledge, the
DataOut class assumes that all individual variables we print are separate
-scalars, and Visit and Paraview then faithfully assume that this is indeed what it is. In
+scalars, and VisIt and Paraview then faithfully assume that this is indeed what it is. In
other words, once we have written the data as scalars, there is nothing in
these programs that allows us to paste these two scalar fields back together as a
vector field. Where we would have to attack this problem is at the root,
instead refer the reader to the step-22 program where we show how to do this
for a more general situation. That said, we couldn't help generating the data
anyway that would show how this would look if implemented as discussed in
-step-22. The vector field then looks like this (Visit and Paraview
+step-22. The vector field then looks like this (VisIt and Paraview
randomly select a few
hundred vertices from which to draw the vectors; drawing them from each
individual vertex would make the picture unreadable):
* polynomials rather than simply linear or bilinear is a feature that was
* only introduced in VTK sometime in 2017 or 2018. You will need at least
* Paraview version 5.5 (released in the spring of 2018) or a similarly
- * recent version of Visit for this feature to work (for example,
- * Visit 2.13.2, released in May 2018, does not yet support this feature).
+ * recent version of VisIt for this feature to work (for example,
+ * VisIt 2.13.2, released in May 2018, does not yet support this feature).
* Older versions of these programs are likely going to result in errors
* when trying to read files generated with this flag set to @p true.
* Experience with these programs shows that these error messages are likely
/**
* Write triangulation in VTU format for each processor, and add a .pvtu file
- * for visualization in Visit or Paraview that describes the collection of VTU
+ * for visualization in VisIt or Paraview that describes the collection of VTU
* files as all part of the same simulation. The output is in the form
* <tt>filename_without_extension.proc000*.vtu</tt> where * is
* 0,1,...,n_proc-1 and <tt>filename_without_extension.pvtu</tt>. The input
* are then supposed to be interpreted as a tensor, one has to (i) use a
* visualization program that can visualize tensors, and (ii) teach it
* how to re-combine the scalar fields into tensors. In the case of
- * Visit -- see https://wci.llnl.gov/simulation/computer-codes/visit/ --
+ * VisIt -- see https://wci.llnl.gov/simulation/computer-codes/visit/ --
* this is done by creating a new "Expression": in essence, one creates
* a variable, say "grad_u", that is tensor-valued and whose value is
* given by the expression <code>{{grad_u_xx,grad_u_xy},
* {grad_u_yx, grad_u_yy}}</code>, where the referenced variables are
* the names of scalar fields that, here, are produced by the example
- * below. Visit is then able to visualize this "new" variable as a
+ * below. VisIt is then able to visualize this "new" variable as a
* tensor.)
*
* All derived classes have to do is implement a constructor and overload
*
* These pictures show an ellipse representing the gradient tensor at, on
* average, every tenth mesh point. You may want to read through the
- * documentation of the Visit visualization program (see
+ * documentation of the VisIt visualization program (see
* https://wci.llnl.gov/simulation/computer-codes/visit/) for an interpretation
* of how exactly tensors are visualizated.
*
projects / dealii.git / commitdiff