itkFEMObject.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef __itkFEMObject_h
#define __itkFEMObject_h

#include "itkDataObject.h"

#include "itkFEMElementBase.h"
#include "itkFEMLinearSystemWrapper.h"
#include "itkFEMLinearSystemWrapperVNL.h"
#include "itkFEMLoadBase.h"
#include "itkFEMLoadNode.h"
#include "itkFEMLoadBC.h"
#include "itkFEMLoadBCMFC.h"
#include "itkFEMLoadEdge.h"
#include "itkFEMLoadGrav.h"
#include "itkFEMLoadLandmark.h"
#include "itkFEMMaterialBase.h"
#include "itkFEMMaterialLinearElasticity.h"
#include "itkVectorContainer.h"

namespace itk
{
namespace fem
{
template <unsigned int VDimension = 3>
class ITK_EXPORT FEMObject : public DataObject
{
public:
  typedef FEMObject                Self;
  typedef DataObject               Superclass;
  typedef SmartPointer<Self>       Pointer;
  typedef SmartPointer<const Self> ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(FEMObject, DataObject);

  itkStaticConstMacro(FEMDimension, unsigned int, VDimension);
  itkStaticConstMacro(MaxDimensions, unsigned int, 3);

  typedef unsigned long ElementIdentifier;
  typedef unsigned long NodeIdentifier;
  typedef unsigned long LoadIdentifier;
  typedef unsigned long MaterialIdentifier;

  typedef VectorContainer<LoadIdentifier, Load::Pointer>          LoadContainerType;
  typedef VectorContainer<MaterialIdentifier, Material::Pointer>  MaterialContainerType;
  typedef VectorContainer<ElementIdentifier, Element::Pointer>    ElementContainerType;
  typedef VectorContainer<NodeIdentifier, Element::Node::Pointer> NodeContainerType;

  typedef typename ElementContainerType::Pointer       ElementContainerPointer;
  typedef typename ElementContainerType::ConstPointer  ElementContainerConstPointer;
  typedef typename NodeContainerType::Pointer          NodeContainerPointer;
  typedef typename NodeContainerType::ConstPointer     NodeContainerConstPointer;
  typedef typename LoadContainerType::Pointer          LoadContainerPointer;
  typedef typename LoadContainerType::ConstPointer     LoadContainerConstPointer;
  typedef typename MaterialContainerType::Pointer      MaterialContainerPointer;
  typedef typename MaterialContainerType::ConstPointer MaterialContainerConstPointer;

  typedef typename
  ElementContainerType::ConstIterator         ElementContainerConstIterator;
  typedef typename
  ElementContainerType::Iterator              ElementContainerIterator;
  typedef typename
  NodeContainerType::ConstIterator            NodeContainerConstIterator;
  typedef typename
  NodeContainerType::Iterator                 NodeContainerIterator;
  typedef typename
  LoadContainerType::ConstIterator            LoadContainerConstIterator;
  typedef typename
  LoadContainerType::Iterator                 LoadContainerIterator;
  typedef typename
  MaterialContainerType::ConstIterator        MaterialContainerConstIterator;
  typedef typename
  MaterialContainerType::Iterator             MaterialContainerIterator;

  // Copy the contents
  void DeepCopy(FEMObject *Copy);

  // Get methods to get the entire VectorContainers for Elements, Nodes, Loads, and Materials
  itkGetObjectMacro(ElementContainer, ElementContainerType);
  itkGetObjectMacro(NodeContainer, NodeContainerType);
  itkGetObjectMacro(LoadContainer, LoadContainerType);
  itkGetObjectMacro(MaterialContainer, MaterialContainerType);

  unsigned int GetNumberOfDegreesOfFreedom(void) const
  {
    return m_NGFN;
  }

  unsigned int GetNumberOfMultiFreedomConstraints(void) const
  {
    return m_NMFC;
  }

  unsigned int GetNumberOfNodes(void) const
  {
    return m_NodeContainer->Size();
  }

  unsigned int GetNumberOfElements(void) const
  {
    return m_ElementContainer->Size();
  }

  unsigned int GetNumberOfLoads(void) const
  {
    return m_LoadContainer->Size();
  }

  unsigned int GetNumberOfMaterials(void) const
  {
    return m_MaterialContainer->Size();
  }

  void AddNextElement(Element::Pointer e);

  void InsertElement(Element::Pointer e, ElementIdentifier index);

  void AddNextNode(Element::Node::Pointer e);

  void InsertNode(Element::Node::Pointer e, NodeIdentifier index);

  void AddNextMaterial(Material::Pointer mat)
  {
    this->AddNextMaterialInternal(mat.GetPointer());
  }
  void AddNextMaterial(MaterialLinearElasticity::Pointer mat)
  {
    this->AddNextMaterialInternal(mat.GetPointer());
  }

  void InsertMaterial(Material::Pointer e, MaterialIdentifier index);

  void AddNextLoad(Load::Pointer ld)
  { this->AddNextLoadInternal(ld.GetPointer()); }
  void AddNextLoad(LoadNode::Pointer ld)
  { this->AddNextLoadInternal(ld.GetPointer()); }
  void AddNextLoad(LoadBCMFC::Pointer ld)
  { this->AddNextLoadInternal(ld.GetPointer()); }
  void AddNextLoad(LoadBC::Pointer ld)
  { this->AddNextLoadInternal(ld.GetPointer()); }
  void AddNextLoad(LoadEdge::Pointer ld)
  { this->AddNextLoadInternal(ld.GetPointer()); }
  void AddNextLoad(LoadGravConst::Pointer ld)
  { this->AddNextLoadInternal(ld.GetPointer()); }
  void AddNextLoad(LoadLandmark::Pointer ld)
  { this->AddNextLoadInternal(ld.GetPointer()); }

  void InsertLoad(Load::Pointer ld, LoadIdentifier index);

  Element::ConstPointer GetElement(ElementIdentifier index) const;
  Element::Pointer GetElement(ElementIdentifier index);

  Element::ConstPointer GetElementWithGlobalNumber(int globalNumber) const;
  Element::Pointer GetElementWithGlobalNumber(int globalNumber);

  Element::Node::Pointer GetNode(NodeIdentifier index);
  Element::Node::ConstPointer GetNode(NodeIdentifier index) const;

  Element::Node::Pointer GetNodeWithGlobalNumber(int globalNumber);

  Material::ConstPointer GetMaterial(MaterialIdentifier index) const;
  Material::Pointer GetMaterial(MaterialIdentifier index);

  Material::ConstPointer GetMaterialWithGlobalNumber(int globalNumber) const;
  Material::Pointer GetMaterialWithGlobalNumber(int globalNumber);

  Load::ConstPointer GetLoad(LoadIdentifier index) const;
  Load::Pointer GetLoad(LoadIdentifier index);

  Load::Pointer GetLoadWithGlobalNumber(int globalNumber);

  void Clear();

  void RenumberNodeContainer();

  void FinalizeMesh();

protected:
  FEMObject();
  ~FEMObject();
  virtual void PrintSelf(std::ostream& os, Indent indent) const;

  void GenerateGFN(void);

  void GenerateMFC(void);

  void AddNextMaterialInternal(Material *mat);
  unsigned int m_NGFN;

  unsigned int m_NMFC;

  ElementContainerPointer  m_ElementContainer;
  NodeContainerPointer     m_NodeContainer;
  LoadContainerPointer     m_LoadContainer;
  MaterialContainerPointer m_MaterialContainer;

private:
  FEMObject(const Self &);      // purposely not implemented
  void operator=(const Self &); // purposely not implemented

  void AddNextLoadInternal(Load *l);
};  // End Class: FEMObject

}
}

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkFEMObject.hxx"
#endif

#endif // #ifndef __itkFEMObject_h