ParaView
vtkMaterialInterfaceFilter.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: $RCSfile: vtkMaterialInterfaceFilter.h,v $
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
31 #ifndef vtkMaterialInterfaceFilter_h
32 #define vtkMaterialInterfaceFilter_h
33 
34 #include "vtkMultiBlockDataSetAlgorithm.h"
35 #include "vtkPVVTKExtensionsDefaultModule.h" //needed for exports
36 #include <string> // needed for string
37 #include <vector> // needed for vector
38 
39 #include "vtkSmartPointer.h" // needed for smart pointer
40 #include "vtkTimerLog.h" // needed for vtkTimerLog.
41 
42 class vtkDataSet;
43 class vtkImageData;
44 class vtkPolyData;
45 class vtkNonOverlappingAMR;
46 class vtkPoints;
47 class vtkDoubleArray;
48 class vtkCellArray;
49 class vtkCellData;
50 class vtkIntArray;
51 class vtkMultiProcessController;
52 class vtkDataArraySelection;
53 class vtkCallbackCommand;
54 class vtkImplicitFunction;
55 
56 // specific to us
57 class vtkMaterialInterfaceLevel;
58 class vtkMaterialInterfaceFilterBlock;
59 class vtkMaterialInterfaceFilterIterator;
60 class vtkMaterialInterfaceEquivalenceSet;
61 class vtkMaterialInterfaceFilterRingBuffer;
64 
65 class VTKPVVTKEXTENSIONSDEFAULT_EXPORT vtkMaterialInterfaceFilter
66  : public vtkMultiBlockDataSetAlgorithm
67 {
68 public:
69  static vtkMaterialInterfaceFilter* New();
70  vtkTypeMacro(vtkMaterialInterfaceFilter, vtkMultiBlockDataSetAlgorithm);
71  void PrintSelf(ostream& os, vtkIndent indent);
72 
73  // PARAVIEW interface stuff
74 
76 
79  void SelectMaterialArray(const char* name);
83  void UnselectMaterialArray(const char* name);
87  void UnselectAllMaterialArrays();
91  void SetMaterialArrayStatus(const char* name, int status);
93 
96  int GetMaterialArrayStatus(const char* name);
97  int GetMaterialArrayStatus(int index);
99 
102  int GetNumberOfMaterialArrays();
106  const char* GetMaterialArrayName(int index);
107 
109 
112  void SelectMassArray(const char* name);
116  void UnselectMassArray(const char* name);
120  void UnselectAllMassArrays();
124  void SetMassArrayStatus(const char* name, int status);
126 
129  int GetMassArrayStatus(const char* name);
130  int GetMassArrayStatus(int index);
132 
135  int GetNumberOfMassArrays();
139  const char* GetMassArrayName(int index);
140 
142 
145  void SelectVolumeWtdAvgArray(const char* name);
149  void UnselectVolumeWtdAvgArray(const char* name);
153  void UnselectAllVolumeWtdAvgArrays();
154 
158  void SetVolumeWtdAvgArrayStatus(const char* name, int status);
160 
163  int GetVolumeWtdAvgArrayStatus(const char* name);
164  int GetVolumeWtdAvgArrayStatus(int index);
166 
169  int GetNumberOfVolumeWtdAvgArrays();
173  const char* GetVolumeWtdAvgArrayName(int index);
174 
176 
179  void SelectMassWtdAvgArray(const char* name);
183  void UnselectMassWtdAvgArray(const char* name);
187  void UnselectAllMassWtdAvgArrays();
188 
192  void SetMassWtdAvgArrayStatus(const char* name, int status);
194 
197  int GetMassWtdAvgArrayStatus(const char* name);
198  int GetMassWtdAvgArrayStatus(int index);
200 
203  int GetNumberOfMassWtdAvgArrays();
207  const char* GetMassWtdAvgArrayName(int index);
208 
210 
213  void SelectSummationArray(const char* name);
217  void UnselectSummationArray(const char* name);
221  void UnselectAllSummationArrays();
225  void SetSummationArrayStatus(const char* name, int status);
227 
230  int GetSummationArrayStatus(const char* name);
231  int GetSummationArrayStatus(int index);
233 
236  int GetNumberOfSummationArrays();
240  const char* GetSummationArrayName(int index);
241 
243 
244 
247  void SetMaterialFractionThreshold(double fraction);
248  vtkGetMacro(MaterialFractionThreshold, double);
250 
252 
253 
256  vtkSetMacro(ComputeOBB, bool);
257  vtkGetMacro(ComputeOBB, bool);
259 
261 
262 
272  void SetUpperLoadingBound(int nPolys);
273  vtkGetMacro(UpperLoadingBound, int);
275 
277 
278 
281  vtkSetStringMacro(OutputBaseName);
282  vtkGetStringMacro(OutputBaseName);
284 
285 
288  vtkSetMacro(WriteGeometryOutput, bool);
289  vtkGetMacro(WriteGeometryOutput, bool);
290  vtkSetMacro(WriteStatisticsOutput, bool);
291  vtkGetMacro(WriteStatisticsOutput, bool);
293 
295 
300  vtkSetMacro(BlockGhostLevel, unsigned char);
301  vtkGetMacro(BlockGhostLevel, unsigned char);
303 
307  static void SelectionModifiedCallback(vtkObject*, unsigned long, void* clientdata, void*);
308 
310 
313  void SetClipFunction(vtkImplicitFunction* clipFunction);
314  vtkGetObjectMacro(ClipFunction, vtkImplicitFunction);
316 
318 
322  vtkSetMacro(InvertVolumeFraction, int);
323  vtkGetMacro(InvertVolumeFraction, int);
325 
329  vtkMTimeType GetMTime();
330 
331 protected:
334 
335  virtual int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*);
336  virtual int FillInputPortInformation(int port, vtkInformation* info);
337  virtual int FillOutputPortInformation(int port, vtkInformation* info);
338 
339  // Set up the result arrays for the calculations we are about to
340  // make.
341  void PrepareForPass(vtkNonOverlappingAMR* hbdsInput,
342  std::vector<std::string>& volumeWtdAvgArrayNames,
343  std::vector<std::string>& massWtdAvgArrayNames, std::vector<std::string>& summedArrayNames,
344  std::vector<std::string>& integratedArrayNames);
345  // Craete a new fragment/piece.
346  vtkPolyData* NewFragmentMesh();
347  // Process each cell, looking for fragments.
348  int ProcessBlock(int blockId);
349  // Cell has been identified as inside the fragment. Integrate, and
350  // generate fragement surface etc...
351  void ConnectFragment(vtkMaterialInterfaceFilterRingBuffer* iterator);
352  void GetNeighborIterator(vtkMaterialInterfaceFilterIterator* next,
353  vtkMaterialInterfaceFilterIterator* iterator, int axis0, int maxFlag0, int axis1, int maxFlag1,
354  int axis2, int maxFlag2);
355  void GetNeighborIteratorPad(vtkMaterialInterfaceFilterIterator* next,
356  vtkMaterialInterfaceFilterIterator* iterator, int axis0, int maxFlag0, int axis1, int maxFlag1,
357  int axis2, int maxFlag2);
358  void CreateFace(vtkMaterialInterfaceFilterIterator* in, vtkMaterialInterfaceFilterIterator* out,
359  int axis, int outMaxFlag);
360  int ComputeDisplacementFactors(vtkMaterialInterfaceFilterIterator* pointNeighborIterators[8],
361  double displacmentFactors[3], int rootNeighborIdx, int faceAxis);
362  int SubVoxelPositionCorner(double* point,
363  vtkMaterialInterfaceFilterIterator* pointNeighborIterators[8], int rootNeighborIdx,
364  int faceAxis);
365  void FindPointNeighbors(vtkMaterialInterfaceFilterIterator* iteratorMin0,
366  vtkMaterialInterfaceFilterIterator* iteratorMax0, int axis0, int maxFlag1, int maxFlag2,
367  vtkMaterialInterfaceFilterIterator pointNeighborIterators[8], double pt[3]);
368  // Finds a global origin for the data set, and level 0 dx
369  int ComputeOriginAndRootSpacingOld(vtkNonOverlappingAMR* input);
370  void ComputeOriginAndRootSpacing(vtkNonOverlappingAMR* input);
371  // Returns the total number of local(wrt this proc) blocks.
372  int GetNumberOfLocalBlocks(vtkNonOverlappingAMR* input);
373  // Complex ghost layer Handling.
374  std::vector<vtkMaterialInterfaceFilterBlock*> GhostBlocks;
375  void ShareGhostBlocks();
376  void HandleGhostBlockRequests();
377  int ComputeRequiredGhostExtent(int level, int inExt[6], int outExt[6]);
378 
379  void ComputeAndDistributeGhostBlocks(
380  int* numBlocksInProc, int* blockMetaData, int myProc, int numProcs);
381 
382  vtkMultiProcessController* Controller;
383 
384  vtkMaterialInterfaceEquivalenceSet* EquivalenceSet;
385  void AddEquivalence(
386  vtkMaterialInterfaceFilterIterator* neighbor1, vtkMaterialInterfaceFilterIterator* neighbor2);
387  //
388  void PrepareForResolveEquivalences();
389  //
390  void ResolveEquivalences();
391  void GatherEquivalenceSets(vtkMaterialInterfaceEquivalenceSet* set);
392  void ShareGhostEquivalences(vtkMaterialInterfaceEquivalenceSet* globalSet, int* procOffsets);
393  void ReceiveGhostFragmentIds(vtkMaterialInterfaceEquivalenceSet* globalSet, int* procOffset);
394  void MergeGhostEquivalenceSets(vtkMaterialInterfaceEquivalenceSet* globalSet);
395 
396  // Sum/finalize attribute's contribution for those
397  // which are split over multiple processes.
398  int ResolveIntegratedAttributes(const int controllingProcId);
399  // Initialize our attribute arrays to ho9ld resolved attributes
400  int PrepareToResolveIntegratedAttributes();
401 
402  // Send my integrated attributes to another process.
403  int SendIntegratedAttributes(const int recipientProcId);
404  // Receive integrated attributes from another process.
405  int ReceiveIntegratedAttributes(const int sourceProcId);
406  // Size buffers etc...
407  int PrepareToCollectIntegratedAttributes(std::vector<vtkMaterialInterfaceCommBuffer>& buffers,
408  std::vector<vtkDoubleArray*>& volumes, std::vector<vtkDoubleArray*>& clipDepthMaxs,
409  std::vector<vtkDoubleArray*>& clipDepthMins, std::vector<vtkDoubleArray*>& moments,
410  std::vector<std::vector<vtkDoubleArray*> >& volumeWtdAvgs,
411  std::vector<std::vector<vtkDoubleArray*> >& massWtdAvgs,
412  std::vector<std::vector<vtkDoubleArray*> >& sums);
413  // Free resources.
414  int CleanUpAfterCollectIntegratedAttributes(std::vector<vtkMaterialInterfaceCommBuffer>& buffers,
415  std::vector<vtkDoubleArray*>& volumes, std::vector<vtkDoubleArray*>& clipDepthMaxs,
416  std::vector<vtkDoubleArray*>& clipDepthMins, std::vector<vtkDoubleArray*>& moments,
417  std::vector<std::vector<vtkDoubleArray*> >& volumeWtdAvgs,
418  std::vector<std::vector<vtkDoubleArray*> >& massWtdAvgs,
419  std::vector<std::vector<vtkDoubleArray*> >& sums);
420  // Receive all integrated attribute arrays from all other
421  // processes.
422  int CollectIntegratedAttributes(std::vector<vtkMaterialInterfaceCommBuffer>& buffers,
423  std::vector<vtkDoubleArray*>& volumes, std::vector<vtkDoubleArray*>& clipDepthMaxs,
424  std::vector<vtkDoubleArray*>& clipDepthMins, std::vector<vtkDoubleArray*>& moments,
425  std::vector<std::vector<vtkDoubleArray*> >& volumeWtdAvgs,
426  std::vector<std::vector<vtkDoubleArray*> >& massWtdAvgs,
427  std::vector<std::vector<vtkDoubleArray*> >& sums);
428  // Send my integrated attributes to all other processes.
429  int BroadcastIntegratedAttributes(const int sourceProcessId);
430  // Send my geometric attribuites to a controler.
431  int SendGeometricAttributes(const int controllingProcId);
432  // size buffers & new containers
433  int PrepareToCollectGeometricAttributes(std::vector<vtkMaterialInterfaceCommBuffer>& buffers,
434  std::vector<vtkDoubleArray*>& coaabb, std::vector<vtkDoubleArray*>& obb,
435  std::vector<int*>& ids);
436  // Free resources.
437  int CleanUpAfterCollectGeometricAttributes(std::vector<vtkMaterialInterfaceCommBuffer>& buffers,
438  std::vector<vtkDoubleArray*>& coaabb, std::vector<vtkDoubleArray*>& obb,
439  std::vector<int*>& ids);
440  // Recieve all geometric attributes from all other
441  // processes.
442  int CollectGeometricAttributes(std::vector<vtkMaterialInterfaceCommBuffer>& buffers,
443  std::vector<vtkDoubleArray*>& coaabb, std::vector<vtkDoubleArray*>& obb,
444  std::vector<int*>& ids);
445  // size local copy to hold all.
446  int PrepareToMergeGeometricAttributes();
447  // Gather geometric attributes on a single process.
448  int GatherGeometricAttributes(const int recipientProcId);
449  // Merge fragment's geometry that are split on this process
450  void ResolveLocalFragmentGeometry();
451  // Merge fragment's geometry that are split across processes
452  void ResolveRemoteFragmentGeometry();
453  // Clean duplicate points from fragment geometry.
454  void CleanLocalFragmentGeometry();
455  //
456  void BuildLoadingArray(std::vector<vtkIdType>& loadingArray);
457  int PackLoadingArray(vtkIdType*& buffer);
458  int UnPackLoadingArray(vtkIdType* buffer, int bufSize, std::vector<vtkIdType>& loadingArray);
459 
460  // copy any integrated attributes (volume, id, weighted averages, sums, etc)
461  // into the fragment polys in the output data sets.
462  void CopyAttributesToOutput0();
463  void CopyAttributesToOutput1();
464  void CopyAttributesToOutput2();
465  // Write a text file containing local fragment attributes.
466  int WriteGeometryOutputToTextFile();
467  int WriteStatisticsOutputToTextFile();
468  // Build the output data
469  int BuildOutputs(vtkMultiBlockDataSet* mbdsOutput0, vtkMultiBlockDataSet* mbdsOutput1,
470  vtkMultiBlockDataSet* mbdsOutput2, int materialId);
471 
472  // integration helper, returns 0 if the source array
473  // type is unsupported.
474  int Accumulate(double* dest, // scalar/vector result
475  vtkDataArray* src, // array to accumulate from
476  int nComps, //
477  int srcCellIndex, // which cell
478  double weight); // weight of contribution
479  int AccumulateMoments(double* moments, // =(Myz, Mxz, Mxy, m)
480  vtkDataArray* massArray, //
481  int srcCellIndex, // from which cell in mass
482  double* X);
483  // Compute the geomteric attributes that have been requested.
484  void ComputeGeometricAttributes();
485  int ComputeLocalFragmentOBB();
486  int ComputeLocalFragmentAABBCenters();
487  // int ComputeFragmentMVBB();
488 
489  // Format input block into an easy to access array with
490  // extra metadata (information) extracted.
492  vtkMaterialInterfaceFilterBlock** InputBlocks;
493  void DeleteAllBlocks();
494  int InitializeBlocks(vtkNonOverlappingAMR* input, std::string& materialFractionArrayName,
495  std::string& massArrayName, std::vector<std::string>& volumeWtdAvgArrayNames,
496  std::vector<std::string>& massWtdAvgArrayNames, std::vector<std::string>& summedArrayNames,
497  std::vector<std::string>& integratedArrayNames);
498  void AddBlock(vtkMaterialInterfaceFilterBlock* block, unsigned char levelOfGhostLayer);
499 
500  // New methods for connecting neighbors.
501  void CheckLevelsForNeighbors(vtkMaterialInterfaceFilterBlock* block);
502  // Returns 1 if there we neighbors found, 0 if not.
503  int FindFaceNeighbors(unsigned int blockLevel, int blockIndex[3], int faceAxis, int faceMaxFlag,
504  std::vector<vtkMaterialInterfaceFilterBlock*>* result);
505 
506  // We need ghost cells for edges and corners as well as faces.
507  // neighborDirection is used to specify a face, edge or corner.
508  // Using a 2x2x2 cube center at origin: (-1,-1,-1), (-1,-1,1) ... are corners.
509  // (1,1,0) is an edge, and (-1,0,0) is a face.
510  // Returns 1 if the neighbor exists.
511  int HasNeighbor(unsigned int blockLevel, int blockIndex[3], int neighborDirection[3]);
512 
513  // Threshold value used to select a cell
514  // as being iniside some fragment, PV uses
515  // a double between 0 and 1, this is stored here
517  // The extraction filter uses a scaled threshold
518  // in the range of 0 to 255
520  //
522  vtkSetStringMacro(MaterialFractionArrayName);
523 
524  // while processing a material array this holds
525  // a pointer to the output poly data
526  // data set
527  vtkPolyData* CurrentFragmentMesh;
528  // As peices/fragments are found they are stored here
529  // until resolution.
530  std::vector<vtkPolyData*> FragmentMeshes;
531 
532  // TODO? this could be cleaned up (somewhat) by
533  // addding an integration class which encapsulates
534  // all of the supported operations.
537  // Local id of current fragment
539  // Accumulator for the volume of the current fragment.
541  // Fragment volumes indexed by the fragment id. It's a local
542  // per-process indexing until fragments have been resolved
543  vtkDoubleArray* FragmentVolumes;
544 
545  // Min and max depth of crater.
546  // These are only computed when the clip plane is on.
547  double ClipDepthMin;
548  double ClipDepthMax;
549  vtkDoubleArray* ClipDepthMinimums;
550  vtkDoubleArray* ClipDepthMaximums;
551 
552  // Accumulator for moments of the current fragment
553  std::vector<double> FragmentMoment; // =(Myz, Mxz, Mxy, m)
554  // Moments indexed by fragment id
555  vtkDoubleArray* FragmentMoments;
556  // Centers of fragment AABBs, only computed if moments are not
557  vtkDoubleArray* FragmentAABBCenters;
558  // let us know if the user has specified a mass array
560 
561  // Weighted average, where weights correspond to fragment volume.
562  // Accumulators one for each array to average, scalar or vector
563  std::vector<std::vector<double> > FragmentVolumeWtdAvg;
564  // weighted averages indexed by fragment id.
565  std::vector<vtkDoubleArray*> FragmentVolumeWtdAvgs;
566  // number of arrays for which to compute the weighted average
568  // Names of the arrays to average.
569  std::vector<std::string> VolumeWtdAvgArrayNames;
570 
571  // Weighted average, where weights correspond to fragment mass.
572  // Accumulators one for each array to average, scalar or vector
573  std::vector<std::vector<double> > FragmentMassWtdAvg;
574  // weighted averages indexed by fragment id.
575  std::vector<vtkDoubleArray*> FragmentMassWtdAvgs;
576  // number of arrays for which to compute the weighted average
578  // Names of the arrays to average.
579  std::vector<std::string> MassWtdAvgArrayNames;
580 
581  // Unique list of all integrated array names
582  // it's used construct list of arrays that
583  // will be coppied into output.
584  std::vector<std::string> IntegratedArrayNames;
585  std::vector<int> IntegratedArrayNComp;
586  // number of integrated arrays
588 
589  // Sum of data over the fragment.
590  // Accumulators, one for each array to sum
591  std::vector<std::vector<double> > FragmentSum;
592  // sums indexed by fragment id.
593  std::vector<vtkDoubleArray*> FragmentSums;
594  // number of arrays for which to compute the weighted average
595  int NToSum;
597 
598  // OBB indexed by fragment id
599  vtkDoubleArray* FragmentOBBs;
600  // turn on/off OBB calculation
602 
603  // Upper bound used to exclude heavily loaded procs
604  // from work sharing. Reducing may aliviate oom issues.
606 
607  // This is getting a bit ugly but ...
608  // When we resolve (merge equivalent) fragments we need a mapping
609  // from local ids to global ids.
610  // This array give an offset into the global array for each process.
611  // The array is computed when we resolve ids, and is used
612  // when resoving other attributes like volume
613  int* NumberOfRawFragmentsInProcess; // in each process by proc id for a single material
614  int* LocalToGlobalOffsets; // indexes into a gathered array of local ids by proc id
615  int TotalNumberOfRawFragments; // over all processes for a single material
616  int NumberOfResolvedFragments; // over all processes for a single material
617  // Total number of fragments over all materials, used to
618  // generate a unique id for each fragment.
620  // Material id, each pass involves a different material use this to
621  // tag fragments by material.
623 
624  // For each material an array of resolved fragments. Blocks are multi piece
625  // of poly data. The multipiece is much like a std vector of poly data *.
626  // multi block is indexed by material.
627  vtkMultiBlockDataSet* ResolvedFragments;
628  // for each material a list of global ids of pieces we own.
629  std::vector<std::vector<int> > ResolvedFragmentIds;
630  // List of split fragments
631  std::vector<std::vector<int> > FragmentSplitMarker;
632  vtkIntArray* FragmentSplitGeometry;
633 
634  // A polydata with points at fragment centers, same structure
635  // as the resolved fragments.
636  vtkMultiBlockDataSet* ResolvedFragmentCenters;
637  //
638  std::vector<vtkPoints*> ResolvedFragmentPoints;
639 
640  // A polydata representing OBB, same structure as the resolved
641  // fragments.
642  vtkMultiBlockDataSet* ResolvedFragmentOBBs;
643 
644  double GlobalOrigin[3];
645  double RootSpacing[3];
646  int StandardBlockDimensions[3];
647 
648  void SaveBlockSurfaces(const char* fileName);
649  void SaveGhostSurfaces(const char* fileName);
650 
651  // Use for the moment to find neighbors.
652  // It could be changed into the primary storage of blocks.
653  std::vector<vtkMaterialInterfaceLevel*> Levels;
654 
655  // Ivars for computing the point on corners and edges of a face.
656  vtkMaterialInterfaceFilterIterator* FaceNeighbors;
657  // Permutation of the neighbors. Axis0 normal to face.
661  double FaceCornerPoints[12];
662  double FaceEdgePoints[12];
663  int FaceEdgeFlags[4];
664  // outMaxFlag implies out is positive direction of axis.
665  void ComputeFacePoints(vtkMaterialInterfaceFilterIterator* in,
666  vtkMaterialInterfaceFilterIterator* out, int axis, int outMaxFlag);
667  void ComputeFaceNeighbors(vtkMaterialInterfaceFilterIterator* in,
668  vtkMaterialInterfaceFilterIterator* out, int axis, int outMaxFlag);
669 
670  long ComputeProximity(const int faceIdx[3], int faceLevel, const int ext[6], int refLevel);
671 
672  void FindNeighbor(int faceIndex[3], int faceLevel, vtkMaterialInterfaceFilterIterator* neighbor,
673  vtkMaterialInterfaceFilterIterator* reference);
674 
675  // PARAVIEW interface data
676  vtkDataArraySelection* MaterialArraySelection;
677  vtkDataArraySelection* MassArraySelection;
678  vtkDataArraySelection* VolumeWtdAvgArraySelection;
679  vtkDataArraySelection* MassWtdAvgArraySelection;
680  vtkDataArraySelection* SummationArraySelection;
681  vtkCallbackCommand* SelectionObserver;
685  int DrawOBB;
686  double Progress;
690 // Debug
691 #ifdef vtkMaterialInterfaceFilterDEBUG
692  int MyPid;
693 #endif
694 
695  vtkImplicitFunction* ClipFunction;
696 
697  // Variables that setup clipping with a sphere and a plane.
698  double ClipCenter[3];
700  double ClipRadius;
702  double ClipPlaneVector[3];
703  double ClipPlaneNormal[3];
704 
705  // Variable that will invert a material.
707 
708  // Specify the number of Ghost level available in each block.
709  // By default set to 1
710  unsigned char BlockGhostLevel;
711 
712 #ifdef vtkMaterialInterfaceFilterPROFILE
713  // Lets profile to see what takes the most time for large number of processes.
714  vtkSmartPointer<vtkTimerLog> InitializeBlocksTimer;
715  vtkSmartPointer<vtkTimerLog> ShareGhostBlocksTimer;
716  long NumberOfBlocks;
717  long NumberOfGhostBlocks;
718  vtkSmartPointer<vtkTimerLog> ProcessBlocksTimer;
719  vtkSmartPointer<vtkTimerLog> ResolveEquivalencesTimer;
720 #endif
721 
722 private:
723  vtkMaterialInterfaceFilter(const vtkMaterialInterfaceFilter&) VTK_DELETE_FUNCTION;
724  void operator=(const vtkMaterialInterfaceFilter&) VTK_DELETE_FUNCTION;
725 };
726 
727 #endif
vtkMaterialInterfaceEquivalenceSet * EquivalenceSet
int FragmentId
class vtkMaterialInterfaceFilterIntegrator {
Extract particles and analyse them.
Data structure that describes a fragment&#39;s loading.
vtkDataArraySelection * SummationArraySelection
vtkMultiProcessController * Controller
std::vector< vtkPolyData * > FragmentMeshes
std::vector< std::vector< int > > ResolvedFragmentIds
vtkMaterialInterfaceFilterIterator * FaceNeighbors
vtkDataArraySelection * MaterialArraySelection
vtkMultiBlockDataSet * ResolvedFragments
std::vector< vtkDoubleArray * > FragmentSums
vtkMultiBlockDataSet * ResolvedFragmentOBBs
vtkMultiBlockDataSet * ResolvedFragmentCenters
std::vector< std::vector< double > > FragmentVolumeWtdAvg
vtkMaterialInterfaceFilterBlock ** InputBlocks
std::vector< std::string > VolumeWtdAvgArrayNames
std::vector< std::vector< double > > FragmentSum
std::vector< std::string > MassWtdAvgArrayNames
std::vector< std::vector< int > > FragmentSplitMarker
std::vector< vtkPoints * > ResolvedFragmentPoints
std::vector< vtkDoubleArray * > FragmentMassWtdAvgs
vtkDataArraySelection * MassWtdAvgArraySelection
std::vector< vtkDoubleArray * > FragmentVolumeWtdAvgs
std::vector< std::vector< double > > FragmentMassWtdAvg
std::vector< std::string > IntegratedArrayNames
vtkDataArraySelection * VolumeWtdAvgArraySelection
std::vector< vtkMaterialInterfaceFilterBlock * > GhostBlocks
vtkDataArraySelection * MassArraySelection
std::vector< vtkMaterialInterfaceLevel * > Levels