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);

  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 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);
  virtual void DeepCopy(vtkDataObject *src);

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