vtkMolecule.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkMolecule.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm 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 vtkMolecule_h
#define vtkMolecule_h
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkSmartPointer.h"          // For vtkSmartPointer
#include "vtkUndirectedGraph.h"
 
#include "vtkAtom.h" // Simple proxy class dependent on vtkMolecule
#include "vtkBond.h" // Simple proxy class dependent on vtkMolecule
 
#include "vtkVector.h" // Small templated vector convenience class
 
class vtkAbstractElectronicData;
class vtkDataArray;
class vtkInformation;
class vtkInformationVector;
class vtkMatrix3x3;
class vtkPlane;
class vtkPoints;
class vtkUnsignedCharArray;
class vtkUnsignedShortArray;
 
class VTKCOMMONDATAMODEL_EXPORT vtkMolecule : public vtkUndirectedGraph
{
public:
  static vtkMolecule* New();
  vtkTypeMacro(vtkMolecule, vtkUndirectedGraph);
  void PrintSelf(ostream& os, vtkIndent indent) override;
  void Initialize() override;
 
  int GetDataObjectType() override { return VTK_MOLECULE; }
 
  vtkAtom AppendAtom() { return this->AppendAtom(0, 0., 0., 0.); }
 
 
  vtkAtom AppendAtom(unsigned short atomicNumber, double x, double y, double z);
  vtkAtom AppendAtom(unsigned short atomicNumber, const vtkVector3f& pos)
  {
    return this->AppendAtom(atomicNumber, pos[0], pos[1], pos[2]);
  }
 
  vtkAtom AppendAtom(unsigned short atomicNumber, double pos[3])
  {
    return this->AppendAtom(atomicNumber, pos[0], pos[1], pos[2]);
  }
 
  vtkAtom GetAtom(vtkIdType atomId);
 
  vtkIdType GetNumberOfAtoms();
 
 
  vtkBond AppendBond(vtkIdType atom1, vtkIdType atom2, unsigned short order = 1);
  vtkBond AppendBond(const vtkAtom& atom1, const vtkAtom& atom2, unsigned short order = 1)
  {
    return this->AppendBond(atom1.Id, atom2.Id, order);
  }
 
  vtkBond GetBond(vtkIdType bondId);
 
  vtkIdType GetNumberOfBonds();
 
  unsigned short GetAtomAtomicNumber(vtkIdType atomId);
 
  void SetAtomAtomicNumber(vtkIdType atomId, unsigned short atomicNum);
 
 
  void SetAtomPosition(vtkIdType atomId, const vtkVector3f& pos);
  void SetAtomPosition(vtkIdType atomId, double x, double y, double z);
  void SetAtomPosition(vtkIdType atomId, double pos[3])
  {
    this->SetAtomPosition(atomId, pos[0], pos[1], pos[2]);
  }
 
 
  vtkVector3f GetAtomPosition(vtkIdType atomId);
  void GetAtomPosition(vtkIdType atomId, float pos[3]);
  void GetAtomPosition(vtkIdType atomId, double pos[3]);
 
 
  void SetBondOrder(vtkIdType bondId, unsigned short order);
  unsigned short GetBondOrder(vtkIdType bondId);
 
  double GetBondLength(vtkIdType bondId);
 
 
  vtkPoints* GetAtomicPositionArray();
  vtkUnsignedShortArray* GetAtomicNumberArray();
  vtkUnsignedShortArray* GetBondOrdersArray();
 
 
  vtkGetObjectMacro(ElectronicData, vtkAbstractElectronicData);
  virtual void SetElectronicData(vtkAbstractElectronicData*);
 
  bool CheckedShallowCopy(vtkGraph* g) override;
 
  bool CheckedDeepCopy(vtkGraph* g) override;
 
  void ShallowCopy(vtkDataObject* obj) override;
 
  void DeepCopy(vtkDataObject* obj) override;
 
  virtual void ShallowCopyStructure(vtkMolecule* m);
 
  virtual void DeepCopyStructure(vtkMolecule* m);
 
  virtual void ShallowCopyAttributes(vtkMolecule* m);
 
  virtual void DeepCopyAttributes(vtkMolecule* m);
 
 
  static bool GetPlaneFromBond(const vtkBond& bond, const vtkVector3f& normal, vtkPlane* plane);
  static bool GetPlaneFromBond(
    const vtkAtom& atom1, const vtkAtom& atom2, const vtkVector3f& normal, vtkPlane* plane);
 
  bool HasLattice();
 
  void ClearLattice();
 
 
  void SetLattice(vtkMatrix3x3* matrix);
  void SetLattice(const vtkVector3d& a, const vtkVector3d& b, const vtkVector3d& c);
 
  vtkMatrix3x3* GetLattice();
 
 
  void GetLattice(vtkVector3d& a, vtkVector3d& b, vtkVector3d& c);
  void GetLattice(vtkVector3d& a, vtkVector3d& b, vtkVector3d& c, vtkVector3d& origin);
 
 
  vtkGetMacro(LatticeOrigin, vtkVector3d);
  vtkSetMacro(LatticeOrigin, vtkVector3d);
 
  vtkUnsignedCharArray* GetAtomGhostArray();
 
  void AllocateAtomGhostArray();
 
  vtkUnsignedCharArray* GetBondGhostArray();
 
  void AllocateBondGhostArray();
 
  int Initialize(
    vtkPoints* atomPositions, vtkDataArray* atomicNumberArray, vtkDataSetAttributes* atomData);
 
  int Initialize(vtkPoints* atomPositions, vtkDataSetAttributes* atomData)
  {
    return this->Initialize(atomPositions, nullptr, atomData);
  }
 
  int Initialize(vtkMolecule* molecule);
 
 
  static vtkMolecule* GetData(vtkInformation* info);
  static vtkMolecule* GetData(vtkInformationVector* v, int i = 0);
 
  vtkDataSetAttributes* GetAtomData() { return this->GetVertexData(); }
 
  vtkDataSetAttributes* GetBondData() { return this->GetEdgeData(); }
 
  vtkIdType GetBondId(vtkIdType a, vtkIdType b) { return this->GetEdgeId(a, b); }
 
 
  vtkSetStringMacro(AtomicNumberArrayName);
  vtkGetStringMacro(AtomicNumberArrayName);
 
 
  vtkSetStringMacro(BondOrdersArrayName);
  vtkGetStringMacro(BondOrdersArrayName);
 
  unsigned long GetActualMemorySize() override;
 
protected:
  vtkMolecule();
  ~vtkMolecule() override;
 
  virtual void CopyStructureInternal(vtkMolecule* m, bool deep);
 
  virtual void CopyAttributesInternal(vtkMolecule* m, bool deep);
 
 
  bool BondListIsDirty;
  void SetBondListDirty() { this->BondListIsDirty = true; }
  void UpdateBondList();
  vtkIdTypeArray* GetBondList();
 
  friend class vtkAtom;
  friend class vtkBond;
 
  vtkAbstractElectronicData* ElectronicData;
  vtkSmartPointer<vtkMatrix3x3> Lattice;
  vtkVector3d LatticeOrigin;
 
  vtkUnsignedCharArray* AtomGhostArray;
  vtkUnsignedCharArray* BondGhostArray;
 
  char* AtomicNumberArrayName;
  char* BondOrdersArrayName;
 
private:
  vtkMolecule(const vtkMolecule&) = delete;
  void operator=(const vtkMolecule&) = delete;
};
 
#endif