vtkboneFiniteElementModel.h

Go to the documentation of this file.

/*=========================================================================
 
  Copyright 2010-2016, Numerics88 Solutions Ltd.
  http://www.numerics88.com/
 
  Copyright (c) Eric Nodwell and Steven K. Boyd
  See Copyright.txt for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
=========================================================================*/
 
#ifndef __vtkboneFiniteElementModel_h
#define __vtkboneFiniteElementModel_h
 
#include "vtkUnstructuredGrid.h"
#include "vtkboneWin32Header.h"
#include "vtkSmartPointer.h"
 
// Forward declarations
class vtkIdTypeArray;
class vtkCharArray;
class vtkDataArrayCollection;
class vtkboneConstraint;
class vtkboneConstraintCollection;
class vtkboneMaterialTable;
 
class VTKBONE_EXPORT vtkboneFiniteElementModel : public vtkUnstructuredGrid
{
public:
  static vtkboneFiniteElementModel* New();
  vtkTypeMacro(vtkboneFiniteElementModel, vtkUnstructuredGrid);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  virtual void AddNodeSet (vtkIdTypeArray* nodeSet);
 
  virtual void AddElementSet (vtkIdTypeArray* elementSet);
 
  virtual vtkIdTypeArray* GetNodeSet (const char* nodeSetName);
 
  virtual vtkIdTypeArray* GetElementSet (const char* elementSetName);
 
  virtual int RemoveNodeSet (const char* nodeSetName);
 
  virtual int RemoveElementSet (const char* elementSetName);
 
 
  virtual int GetAssociatedElementsFromNodeSet (const char *nodeSetName,
                                             vtkIdTypeArray* ids);
  virtual vtkIdTypeArray* GetAssociatedElementsFromNodeSet (const char *nodeSetName);
 
 
  virtual int DataSetFromNodeSet (const vtkIdTypeArray *nodeSet,
                                  vtkUnstructuredGrid* data);
  virtual vtkUnstructuredGrid* DataSetFromNodeSet (const vtkIdTypeArray *nodeSet);
  virtual int DataSetFromNodeSet (const char *nodeSetName,
                                  vtkUnstructuredGrid* data);
  virtual vtkUnstructuredGrid* DataSetFromNodeSet (const char *nodeSetName);
 
 
  virtual int DataSetFromElementSet(const vtkIdTypeArray *elementSet,
                                   vtkUnstructuredGrid* data);
  virtual vtkUnstructuredGrid* DataSetFromElementSet(const vtkIdTypeArray *elementSet);
  virtual int DataSetFromElementSet(const char *elementSetName,
                                   vtkUnstructuredGrid* data);
  virtual vtkUnstructuredGrid* DataSetFromElementSet(const char *elementSetName);
 
 
  virtual void SetConstraints(vtkboneConstraintCollection *);
  vtkGetObjectMacro(Constraints, vtkboneConstraintCollection);
 
 
  virtual void SetMaterialTable(vtkboneMaterialTable *);
  vtkGetObjectMacro(MaterialTable, vtkboneMaterialTable);
 
 
  virtual void SetConvergenceSet(vtkboneConstraint *);
  vtkGetObjectMacro(ConvergenceSet, vtkboneConstraint);
 
 
  enum ElementType_t {
    N88_UNKNOWN,
    N88_TETRAHEDRON,
    N88_HEXAHEDRON,
    N88_MIXED,
    NUMBER_OF_ElementType};
 
  static const char* GetElementTypeAsString (int arg);
 
  virtual int GetElementType();
 
 
  virtual void GetAllCellPoints (vtkIdTypeArray* allCellPoints);
  virtual vtkIdTypeArray* GetAllCellPoints ();
 
 
  virtual int ApplyBoundaryCondition(
      vtkIdTypeArray* nodeIds,
      vtkDataArray* senses,
      vtkDataArray* displacements,
      const char* arg_constraintName);
  virtual int ApplyBoundaryCondition(
      vtkIdTypeArray* nodeIds,
      int sense,
      double displacement,
      const char* arg_constraintName);
  virtual int ApplyBoundaryCondition(
      vtkIdType nodeId,
      int sense,
      double displacement,
      const char* arg_constraintName);
  virtual int ApplyBoundaryCondition(
      const char* nodeSetName,
      int sense,
      double displacement,
      const char* arg_constraintName);
 
 
  virtual int FixNodes(vtkIdTypeArray* ids, const char* arg_constraintName);
  virtual int FixNodes(vtkIdType id, const char* arg_constraintName);
  virtual int FixNodes(const char* selectionName, const char* arg_constraintName);
 
 
  virtual int ApplyLoad(
      vtkIdTypeArray* elementIds,
      vtkDataArray* distributions,
      vtkDataArray* senses,
      vtkDataArray* forces,
      const char* arg_constraintName);
  virtual int ApplyLoad(
      vtkIdTypeArray* elementIds,
      int distribution,
      vtkDataArray* senses,
      vtkDataArray* forces,
      const char* arg_constraintName);
  virtual int ApplyLoad(
      vtkIdTypeArray* elementIds,
      int distribution,
      int sense,
      double total_force,
      const char* arg_constraintName);
  virtual int ApplyLoad(
      vtkIdType elementId,
      int distribution,
      int sense,
      double force,
      const char* arg_constraintName);
  virtual int ApplyLoad(
      const char* elementSetName,
      int distribution,
      int sense,
      double total_force,
      const char* arg_constraintName);
 
 
  virtual int ConvergenceSetFromConstraint(vtkboneConstraint* constraint);
  virtual int ConvergenceSetFromConstraint(const char* constraintName);
 
 
  virtual int DataSetFromConstraint(vtkboneConstraint* arg_constraint,
                                   vtkUnstructuredGrid* data);
  virtual vtkUnstructuredGrid* DataSetFromConstraint(vtkboneConstraint* arg_constraint);
  virtual int DataSetFromConstraint(const char *arg_constraintName,
                                   vtkUnstructuredGrid* data);
  virtual vtkUnstructuredGrid* DataSetFromConstraint(const char *arg_constraintName);
 
 
  vtkSetStringMacro(Name);
  vtkGetStringMacro(Name);
 
 
  virtual void SetNodeSets (vtkDataArrayCollection*);
  vtkGetObjectMacro(NodeSets, vtkDataArrayCollection);
 
 
  virtual void SetElementSets (vtkDataArrayCollection*);
  vtkGetObjectMacro(ElementSets, vtkDataArrayCollection);
 
 
  virtual void SetGaussPointData(vtkDataArrayCollection *);
  vtkGetObjectMacro(GaussPointData, vtkDataArrayCollection);
 
 
  vtkSetStringMacro(History);
  vtkGetStringMacro(History);
 
  void AppendHistory(const char* s);
 
 
  vtkSetStringMacro(Log);
  vtkGetStringMacro(Log);
 
  void AppendLog(const char* s);
 
 
  virtual void ShallowCopy(vtkDataObject *src) override;
  virtual void DeepCopy(vtkDataObject *src) override;
 
protected:
  vtkboneFiniteElementModel();
  ~vtkboneFiniteElementModel();
 
  vtkDataArrayCollection* NodeSets;
  vtkDataArrayCollection* ElementSets;
  vtkDataArrayCollection* GaussPointData;
 
  vtkboneConstraintCollection *Constraints;
  vtkboneMaterialTable *MaterialTable;
  vtkboneConstraint* ConvergenceSet;
 
  char* Name;
  char* History;
  char* Log;
 
private:
  vtkboneFiniteElementModel(const vtkboneFiniteElementModel&);  // Not implemented.
  void operator=(const vtkboneFiniteElementModel&);  // Not implemented.
};
 
#endif