1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
/**
* @class vtkXMLPMultiBlockDataWriter
* @brief parallel writer for
* vtkHierarchicalBoxDataSet.
*
* vtkXMLPCompositeDataWriter writes (in parallel or serially) the VTK XML
* multi-group, multi-block hierarchical and hierarchical box files. XML
* multi-group data files are meta-files that point to a list of serial VTK
* XML files.
*/
#ifndef vtkXMLPMultiBlockDataWriter_h
#define vtkXMLPMultiBlockDataWriter_h
#include "vtkIOParallelXMLModule.h" // For export macro
#include "vtkXMLMultiBlockDataWriter.h"
VTK_ABI_NAMESPACE_BEGIN
class vtkCompositeDataSet;
class vtkMultiProcessController;
class VTKIOPARALLELXML_EXPORT vtkXMLPMultiBlockDataWriter : public vtkXMLMultiBlockDataWriter
{
public:
static vtkXMLPMultiBlockDataWriter* New();
vtkTypeMacro(vtkXMLPMultiBlockDataWriter, vtkXMLMultiBlockDataWriter);
void PrintSelf(ostream& os, vtkIndent indent) override;
///@{
/**
* Get/Set the number of pieces that are being written in parallel.
*/
vtkSetMacro(NumberOfPieces, int);
vtkGetMacro(NumberOfPieces, int);
///@}
///@{
/**
* Get/Set the range of pieces assigned to this writer.
*/
vtkSetMacro(StartPiece, int);
vtkGetMacro(StartPiece, int);
///@}
///@{
/**
* Controller used to communicate data type of blocks.
* By default, the global controller is used. If you want another
* controller to be used, set it with this.
* If no controller is set, only the local blocks will be written
* to the meta-file.
*/
virtual void SetController(vtkMultiProcessController*);
vtkGetObjectMacro(Controller, vtkMultiProcessController);
///@}
/**
* Set whether this instance will write the meta-file. WriteMetaFile
* is set to flag only on process 0 and all other processes have
* WriteMetaFile set to 0 by default.
*/
void SetWriteMetaFile(int flag) override;
// See the vtkAlgorithm for a description of what these do
vtkTypeBool ProcessRequest(
vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
protected:
vtkXMLPMultiBlockDataWriter();
~vtkXMLPMultiBlockDataWriter() override;
/**
* Determine the data types for each of the leaf nodes.
* Currently each process requires this information in order to
* simplify creating the file names for both the metadata file
* as well as the actual dataset files. It takes into account
* that a piece of a dataset may be distributed in multiple pieces
* over multiple processes.
*/
void FillDataTypes(vtkCompositeDataSet*) override;
vtkMultiProcessController* Controller;
/**
* Internal method called recursively to create the xml tree for
* the children of compositeData as well as write the actual data
* set files. element will only have added nested information.
* writerIdx is the global piece index used to create unique
* filenames for each file written. This function returns 0 if
* no files were written from compositeData. Process 0 creates
* the metadata for all of the processes/files.
*/
int WriteComposite(
vtkCompositeDataSet* compositeData, vtkXMLDataElement* parent, int& currentFileIndex) override;
/**
* Internal method to write a non vtkCompositeDataSet subclass as
* well as add in the file name to the metadata file.
* Element is the containing XML metadata element that may
* have data overwritten and added to (the index XML attribute
* should not be touched though). writerIdx is the piece index
* that gets incremented for the globally numbered piece.
* If this piece exists on multiple processes than it also takes
* care of that in the metadata description. This function returns
* 0 if no file was written.
*/
int ParallelWriteNonCompositeData(
vtkDataObject* dObj, vtkXMLDataElement* parentXML, int currentFileIndex);
/**
* Return the name of the file given the currentFileIndex (also the current
* globally numbered piece index), the procId the file exists on, and
* the dataSetType.
*/
virtual vtkStdString CreatePieceFileName(int currentFileIndex, int procId, int dataSetType);
/** Make a directory.
*
* Overridden to create the directory only on rank 0.
*/
void MakeDirectory(const char* name) override;
/**
* Utility function to remove any already written files
* in case writer failed.
*/
void RemoveWrittenFiles(const char* subDirectory) override;
///@{
/**
* Piece information.
*/
int StartPiece;
int NumberOfPieces;
///@}
private:
vtkXMLPMultiBlockDataWriter(const vtkXMLPMultiBlockDataWriter&) = delete;
void operator=(const vtkXMLPMultiBlockDataWriter&) = delete;
class vtkInternal;
vtkInternal* XMLPMultiBlockDataWriterInternal;
};
VTK_ABI_NAMESPACE_END
#endif
|
