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 "vtkUndirectedGraph.h"
#include "vtkSmartPointer.h" // For vtkSmartPointer

#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, vtkVector3f(0, 0, 0));
  }

  vtkAtom AppendAtom(unsigned short atomicNumber, const vtkVector3f &pos);

  vtkAtom AppendAtom(unsigned short atomicNumber, double x, double y, double z)
  {
    return this->AppendAtom(atomicNumber, vtkVector3f(x, y, z));
  }

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


  vtkVector3f GetAtomPosition(vtkIdType atomId);
  void GetAtomPosition(vtkIdType atomId, float 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);

 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