chaste.mesh package

Module contents

Mesh Module

class chaste.mesh.ChastePoint3

GetWithDefault((ChastePoint3)arg1, (int)i[, (float)def=0.0]) → float :

C++ signature :

double GetWithDefault(ChastePoint<3u> {lvalue},unsigned int [,double=0.0])

IsSamePoint((ChastePoint3)arg1, (ChastePoint3)rPoint) → bool :

C++ signature :

bool IsSamePoint(ChastePoint<3u> {lvalue},ChastePoint<3u>)

SetCoordinate((ChastePoint3)arg1, (int)i, (float)value) → None :

C++ signature :

void SetCoordinate(ChastePoint<3u> {lvalue},unsigned int,double)

rGetLocation((ChastePoint3)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> rGetLocation(ChastePoint<3u> {lvalue})

class chaste.mesh.Node3

AddAppliedForceContribution((Node3)arg1, (object)forceContribution) → None :

C++ signature :

void AddAppliedForceContribution(Node<3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul> {lvalue})

AddBoundaryElement((Node3)arg1, (int)index) → None :

C++ signature :

void AddBoundaryElement(Node<3u> {lvalue},unsigned int)

AddElement((Node3)arg1, (int)index) → None :

C++ signature :

void AddElement(Node<3u> {lvalue},unsigned int)

AddNeighbour((Node3)arg1, (int)index) → None :

C++ signature :

void AddNeighbour(Node<3u> {lvalue},unsigned int)

AddNodeAttribute((Node3)arg1, (float)attribute) → None :

C++ signature :

void AddNodeAttribute(Node<3u> {lvalue},double)

ClearAppliedForce((Node3)arg1) → None :

C++ signature :

void ClearAppliedForce(Node<3u> {lvalue})

ClearNeighbours((Node3)arg1) → None :

C++ signature :

void ClearNeighbours(Node<3u> {lvalue})

ContainingBoundaryElementsBegin((Node3)arg1) → object :

C++ signature :

Node<3u>::ContainingBoundaryElementIterator ContainingBoundaryElementsBegin(Node<3u> {lvalue})

ContainingBoundaryElementsEnd((Node3)arg1) → object :

C++ signature :

Node<3u>::ContainingBoundaryElementIterator ContainingBoundaryElementsEnd(Node<3u> {lvalue})

ContainingElementsBegin((Node3)arg1) → object :

C++ signature :

Node<3u>::ContainingElementIterator ContainingElementsBegin(Node<3u> {lvalue})

ContainingElementsEnd((Node3)arg1) → object :

C++ signature :

Node<3u>::ContainingElementIterator ContainingElementsEnd(Node<3u> {lvalue})

GetIndex((Node3)arg1) → int :

C++ signature :

unsigned int GetIndex(Node<3u> {lvalue})

GetNeighboursSetUp((Node3)arg1) → bool :

C++ signature :

bool GetNeighboursSetUp(Node<3u> {lvalue})

GetNumBoundaryElements((Node3)arg1) → int :

C++ signature :

unsigned int GetNumBoundaryElements(Node<3u> {lvalue})

GetNumContainingElements((Node3)arg1) → int :

C++ signature :

unsigned int GetNumContainingElements(Node<3u> {lvalue})

GetNumNodeAttributes((Node3)arg1) → int :

C++ signature :

unsigned int GetNumNodeAttributes(Node<3u> {lvalue})

GetPoint((Node3)arg1) → ChastePoint3 :

C++ signature :

ChastePoint<3u> GetPoint(Node<3u> {lvalue})

GetRadius((Node3)arg1) → float :

C++ signature :

double GetRadius(Node<3u> {lvalue})

GetRegion((Node3)arg1) → int :

C++ signature :

unsigned int GetRegion(Node<3u> {lvalue})

HasNodeAttributes((Node3)arg1) → bool :

C++ signature :

bool HasNodeAttributes(Node<3u> {lvalue})

IsBoundaryNode((Node3)arg1) → bool :

C++ signature :

bool IsBoundaryNode(Node<3u> {lvalue})

IsDeleted((Node3)arg1) → bool :

C++ signature :

bool IsDeleted(Node<3u> {lvalue})

IsInternal((Node3)arg1) → bool :

C++ signature :

bool IsInternal(Node<3u> {lvalue})

IsParticle((Node3)arg1) → bool :

C++ signature :

bool IsParticle(Node<3u> {lvalue})

MarkAsDeleted((Node3)arg1) → None :

C++ signature :

void MarkAsDeleted(Node<3u> {lvalue})

MarkAsInternal((Node3)arg1) → None :

C++ signature :

void MarkAsInternal(Node<3u> {lvalue})

NeighboursIsEmpty((Node3)arg1) → bool :

C++ signature :

bool NeighboursIsEmpty(Node<3u> {lvalue})

RemoveBoundaryElement((Node3)arg1, (int)index) → None :

C++ signature :

void RemoveBoundaryElement(Node<3u> {lvalue},unsigned int)

RemoveDuplicateNeighbours((Node3)arg1) → None :

C++ signature :

void RemoveDuplicateNeighbours(Node<3u> {lvalue})

RemoveElement((Node3)arg1, (int)index) → None :

C++ signature :

void RemoveElement(Node<3u> {lvalue},unsigned int)

SetAsBoundaryNode((Node3)arg1[, (bool)value=True]) → None :

C++ signature :

void SetAsBoundaryNode(Node<3u> {lvalue} [,bool=True])

SetIndex((Node3)arg1, (int)index) → None :

C++ signature :

void SetIndex(Node<3u> {lvalue},unsigned int)

SetIsParticle((Node3)arg1, (bool)isParticle) → None :

C++ signature :

void SetIsParticle(Node<3u> {lvalue},bool)

SetNeighboursSetUp((Node3)arg1, (bool)flag) → None :

C++ signature :

void SetNeighboursSetUp(Node<3u> {lvalue},bool)

SetPoint((Node3)arg1, (ChastePoint3)point) → None :

C++ signature :

void SetPoint(Node<3u> {lvalue},ChastePoint<3u>)

SetRadius((Node3)arg1, (float)radius) → None :

C++ signature :

void SetRadius(Node<3u> {lvalue},double)

SetRegion((Node3)arg1, (int)region) → None :

C++ signature :

void SetRegion(Node<3u> {lvalue},unsigned int)

rGetAppliedForce((Node3)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> {lvalue} rGetAppliedForce(Node<3u> {lvalue})

rGetLocation((Node3)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> rGetLocation(Node<3u> {lvalue})

class chaste.mesh.NodeAttributes3

AddAppliedForceContribution((NodeAttributes3)arg1, (object)appliedForceContribution) → None :

C++ signature :

void AddAppliedForceContribution(NodeAttributes<3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul> {lvalue})

AddAttribute((NodeAttributes3)arg1, (float)attribute) → None :

C++ signature :

void AddAttribute(NodeAttributes<3u> {lvalue},double)

AddNeighbour((NodeAttributes3)arg1, (int)index) → None :

C++ signature :

void AddNeighbour(NodeAttributes<3u> {lvalue},unsigned int)

ClearAppliedForce((NodeAttributes3)arg1) → None :

C++ signature :

void ClearAppliedForce(NodeAttributes<3u> {lvalue})

ClearNeighbours((NodeAttributes3)arg1) → None :

C++ signature :

void ClearNeighbours(NodeAttributes<3u> {lvalue})

GetNeighboursSetUp((NodeAttributes3)arg1) → bool :

C++ signature :

bool GetNeighboursSetUp(NodeAttributes<3u> {lvalue})

GetRadius((NodeAttributes3)arg1) → float :

C++ signature :

double GetRadius(NodeAttributes<3u> {lvalue})

GetRegion((NodeAttributes3)arg1) → int :

C++ signature :

unsigned int GetRegion(NodeAttributes<3u> {lvalue})

IsParticle((NodeAttributes3)arg1) → bool :

C++ signature :

bool IsParticle(NodeAttributes<3u> {lvalue})

NeighboursIsEmpty((NodeAttributes3)arg1) → bool :

C++ signature :

bool NeighboursIsEmpty(NodeAttributes<3u> {lvalue})

RemoveDuplicateNeighbours((NodeAttributes3)arg1) → None :

C++ signature :

void RemoveDuplicateNeighbours(NodeAttributes<3u> {lvalue})

SetIsParticle((NodeAttributes3)arg1, (bool)isParticle) → None :

C++ signature :

void SetIsParticle(NodeAttributes<3u> {lvalue},bool)

SetNeighboursSetUp((NodeAttributes3)arg1, (bool)flag) → None :

C++ signature :

void SetNeighboursSetUp(NodeAttributes<3u> {lvalue},bool)

SetRadius((NodeAttributes3)arg1, (float)radius) → None :

C++ signature :

void SetRadius(NodeAttributes<3u> {lvalue},double)

SetRegion((NodeAttributes3)arg1, (int)region) → None :

C++ signature :

void SetRegion(NodeAttributes<3u> {lvalue},unsigned int)

rGetAppliedForce((NodeAttributes3)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> {lvalue} rGetAppliedForce(NodeAttributes<3u> {lvalue})

class chaste.mesh.PottsMesh3

AddElement((PottsMesh3)arg1, (object)pNewElement) → int :

C++ signature :

unsigned int AddElement(PottsMesh<3u> {lvalue},PottsElement<3u>*)

CalculateBoundingBox((PottsMesh3)arg1, (VecNodePtr3)rNodes) → object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(PottsMesh_less__3__greater__wrapper {lvalue},std::vector<Node<3u>*, std::allocator<Node<3u>*> >)

CalculateBoundingBox( (PottsMesh3)arg1) -> object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(PottsMesh<3u> {lvalue})

CalculateBoundingBox( (PottsMesh3)arg1) -> object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(PottsMesh_less__3__greater__wrapper {lvalue})

Clear((PottsMesh3)arg1) → None :

C++ signature :

void Clear(PottsMesh<3u> {lvalue})

Clear( (PottsMesh3)arg1) -> None :

C++ signature :

void Clear(PottsMesh_less__3__greater__wrapper {lvalue})

ConstructFromMeshReader((PottsMesh3)arg1, (object)rMeshReader) → None :

C++ signature :

void ConstructFromMeshReader(PottsMesh<3u> {lvalue},AbstractMeshReader<3u, 3u> {lvalue})

DeleteElement((PottsMesh3)arg1, (int)index) → None :

C++ signature :

void DeleteElement(PottsMesh<3u> {lvalue},unsigned int)

DeleteNode((PottsMesh3)arg1, (int)index) → None :

C++ signature :

void DeleteNode(PottsMesh<3u> {lvalue},unsigned int)

DivideElement((PottsMesh3)arg1, (object)pElement[, (bool)placeOriginalElementBelow=False]) → int :

C++ signature :

unsigned int DivideElement(PottsMesh<3u> {lvalue},PottsElement<3u>* [,bool=False])

GetCentroidOfElement((PottsMesh3)arg1, (int)index) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetCentroidOfElement(PottsMesh<3u> {lvalue},unsigned int)

GetCentroidOfElement( (PottsMesh3)arg1, (int)index) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetCentroidOfElement(PottsMesh_less__3__greater__wrapper {lvalue},unsigned int)

GetElement((PottsMesh3)arg1, (int)index) → object :

C++ signature :

PottsElement<3u>* GetElement(PottsMesh<3u> {lvalue},unsigned int)

GetElementIteratorBegin((PottsMesh3)arg1[, (bool)skipDeletedElements=True]) → object :

C++ signature :

PottsMesh<3u>::PottsElementIterator GetElementIteratorBegin(PottsMesh<3u> {lvalue} [,bool=True])

GetElementIteratorEnd((PottsMesh3)arg1) → object :

C++ signature :

PottsMesh<3u>::PottsElementIterator GetElementIteratorEnd(PottsMesh<3u> {lvalue})

GetMooreNeighbouringNodeIndices((PottsMesh3)arg1, (int)nodeIndex) → SetUnsigned :

C++ signature :

std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> > GetMooreNeighbouringNodeIndices(PottsMesh<3u> {lvalue},unsigned int)

GetNearestNodeIndex((PottsMesh3)arg1, (ChastePoint3)rTestPoint) → int :

C++ signature :

unsigned int GetNearestNodeIndex(PottsMesh<3u> {lvalue},ChastePoint<3u>)

GetNearestNodeIndex( (PottsMesh3)arg1, (ChastePoint3)rTestPoint) -> int :

C++ signature :

unsigned int GetNearestNodeIndex(PottsMesh_less__3__greater__wrapper {lvalue},ChastePoint<3u>)

GetNeighbouringElementIndices((PottsMesh3)arg1, (int)elementIndex) → SetUnsigned :

C++ signature :

std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> > GetNeighbouringElementIndices(PottsMesh<3u> {lvalue},unsigned int)

GetNumAllElements((PottsMesh3)arg1) → int :

C++ signature :

unsigned int GetNumAllElements(PottsMesh<3u> {lvalue})

GetNumAllNodes((PottsMesh3)arg1) → int :

C++ signature :

unsigned int GetNumAllNodes(PottsMesh<3u> {lvalue})

GetNumAllNodes( (PottsMesh3)arg1) -> int :

C++ signature :

unsigned int GetNumAllNodes(PottsMesh_less__3__greater__wrapper {lvalue})

GetNumElements((PottsMesh3)arg1) → int :

C++ signature :

unsigned int GetNumElements(PottsMesh<3u> {lvalue})

GetNumElements( (PottsMesh3)arg1) -> int :

C++ signature :

unsigned int GetNumElements(PottsMesh_less__3__greater__wrapper {lvalue})

GetNumNodes((PottsMesh3)arg1) → int :

C++ signature :

unsigned int GetNumNodes(PottsMesh<3u> {lvalue})

GetNumNodes( (PottsMesh3)arg1) -> int :

C++ signature :

unsigned int GetNumNodes(PottsMesh_less__3__greater__wrapper {lvalue})

GetSurfaceAreaOfElement((PottsMesh3)arg1, (int)index) → float :

C++ signature :

double GetSurfaceAreaOfElement(PottsMesh<3u> {lvalue},unsigned int)

GetSurfaceAreaOfElement( (PottsMesh3)arg1, (int)index) -> float :

C++ signature :

double GetSurfaceAreaOfElement(PottsMesh_less__3__greater__wrapper {lvalue},unsigned int)

GetVectorFromAtoB((PottsMesh3)arg1, (object)rLocationA, (object)rLocationB) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetVectorFromAtoB(PottsMesh<3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,boost::numeric::ublas::c_vector<double, 3ul>)

GetVectorFromAtoB( (PottsMesh3)arg1, (object)rLocationA, (object)rLocationB) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetVectorFromAtoB(PottsMesh_less__3__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,boost::numeric::ublas::c_vector<double, 3ul>)

GetVolumeOfElement((PottsMesh3)arg1, (int)index) → float :

C++ signature :

double GetVolumeOfElement(PottsMesh<3u> {lvalue},unsigned int)

GetVolumeOfElement( (PottsMesh3)arg1, (int)index) -> float :

C++ signature :

double GetVolumeOfElement(PottsMesh_less__3__greater__wrapper {lvalue},unsigned int)

GetVonNeumannNeighbouringNodeIndices((PottsMesh3)arg1, (int)nodeIndex) → SetUnsigned :

C++ signature :

std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> > GetVonNeumannNeighbouringNodeIndices(PottsMesh<3u> {lvalue},unsigned int)

GetWidth((PottsMesh3)arg1, (int)rDimension) → float :

C++ signature :

double GetWidth(PottsMesh<3u> {lvalue},unsigned int)

GetWidth( (PottsMesh3)arg1, (int)rDimension) -> float :

C++ signature :

double GetWidth(PottsMesh_less__3__greater__wrapper {lvalue},unsigned int)

PermuteNodes((PottsMesh3)arg1) → None :

C++ signature :

void PermuteNodes(PottsMesh<3u> {lvalue})

PermuteNodes( (PottsMesh3)arg1) -> None :

C++ signature :

void PermuteNodes(PottsMesh_less__3__greater__wrapper {lvalue})

ReadNodesPerProcessorFile((PottsMesh3)arg1, (str)rNodesPerProcessorFile) → None :

C++ signature :

void ReadNodesPerProcessorFile(PottsMesh<3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

ReadNodesPerProcessorFile( (PottsMesh3)arg1, (str)rNodesPerProcessorFile) -> None :

C++ signature :

void ReadNodesPerProcessorFile(PottsMesh_less__3__greater__wrapper {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

RefreshMesh((PottsMesh3)arg1) → None :

C++ signature :

void RefreshMesh(PottsMesh<3u> {lvalue})

RefreshMesh( (PottsMesh3)arg1) -> None :

C++ signature :

void RefreshMesh(PottsMesh_less__3__greater__wrapper {lvalue})

RemoveDeletedElements((PottsMesh3)arg1) → None :

C++ signature :

void RemoveDeletedElements(PottsMesh<3u> {lvalue})

Rotate((PottsMesh3)arg1, (object)rotationMatrix) → None :

C++ signature :

void Rotate(PottsMesh<3u> {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul>)

Rotate( (PottsMesh3)arg1, (object)rotationMatrix) -> None :

C++ signature :

void Rotate(PottsMesh_less__3__greater__wrapper {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul>)

Rotate( (PottsMesh3)arg1, (object)axis, (float)angle) -> None :

C++ signature :

void Rotate(PottsMesh<3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,double)

Rotate( (PottsMesh3)arg1, (float)theta) -> None :

C++ signature :

void Rotate(PottsMesh<3u> {lvalue},double)

Scale((PottsMesh3)arg1[, (float)xFactor=1.0[, (float)yFactor=1.0[, (float)zFactor=1.0]]]) → None :

C++ signature :

void Scale(PottsMesh<3u> {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

Scale( (PottsMesh3)arg1 [, (float)xFactor=1.0 [, (float)yFactor=1.0 [, (float)zFactor=1.0]]]) -> None :

C++ signature :

void Scale(PottsMesh_less__3__greater__wrapper {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

SetDistributedVectorFactory((PottsMesh3)arg1, (object)pFactory) → None :

C++ signature :

void SetDistributedVectorFactory(PottsMesh<3u> {lvalue},DistributedVectorFactory*)

SetDistributedVectorFactory( (PottsMesh3)arg1, (object)pFactory) -> None :

C++ signature :

void SetDistributedVectorFactory(PottsMesh_less__3__greater__wrapper {lvalue},DistributedVectorFactory*)

SetElementOwnerships((PottsMesh3)arg1) → None :

C++ signature :

void SetElementOwnerships(PottsMesh_less__3__greater__wrapper {lvalue})

SolveBoundaryElementMapping((PottsMesh3)arg1, (int)index) → int :

C++ signature :

unsigned int SolveBoundaryElementMapping(PottsMesh_less__3__greater__wrapper {lvalue},unsigned int)

SolveElementMapping((PottsMesh3)arg1, (int)index) → int :

C++ signature :

unsigned int SolveElementMapping(PottsMesh_less__3__greater__wrapper {lvalue},unsigned int)

SolveNodeMapping((PottsMesh3)arg1, (int)index) → int :

C++ signature :

unsigned int SolveNodeMapping(PottsMesh_less__3__greater__wrapper {lvalue},unsigned int)

Translate((PottsMesh3)arg1, (object)rDisplacement) → None :

C++ signature :

void Translate(PottsMesh<3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>)

Translate( (PottsMesh3)arg1, (object)rDisplacement) -> None :

C++ signature :

void Translate(PottsMesh_less__3__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 3ul>)

Translate( (PottsMesh3)arg1 [, (float)xMovement=0.0 [, (float)yMovement=0.0 [, (float)zMovement=0.0]]]) -> None :

C++ signature :

void Translate(PottsMesh<3u> {lvalue} [,double=0.0 [,double=0.0 [,double=0.0]]])

class chaste.mesh.ChastePoint2

GetWithDefault((ChastePoint2)arg1, (int)i[, (float)def=0.0]) → float :

C++ signature :

double GetWithDefault(ChastePoint<2u> {lvalue},unsigned int [,double=0.0])

IsSamePoint((ChastePoint2)arg1, (ChastePoint2)rPoint) → bool :

C++ signature :

bool IsSamePoint(ChastePoint<2u> {lvalue},ChastePoint<2u>)

SetCoordinate((ChastePoint2)arg1, (int)i, (float)value) → None :

C++ signature :

void SetCoordinate(ChastePoint<2u> {lvalue},unsigned int,double)

rGetLocation((ChastePoint2)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> rGetLocation(ChastePoint<2u> {lvalue})

class chaste.mesh.Node2

AddAppliedForceContribution((Node2)arg1, (object)forceContribution) → None :

C++ signature :

void AddAppliedForceContribution(Node<2u> {lvalue},boost::numeric::ublas::c_vector<double, 2ul> {lvalue})

AddBoundaryElement((Node2)arg1, (int)index) → None :

C++ signature :

void AddBoundaryElement(Node<2u> {lvalue},unsigned int)

AddElement((Node2)arg1, (int)index) → None :

C++ signature :

void AddElement(Node<2u> {lvalue},unsigned int)

AddNeighbour((Node2)arg1, (int)index) → None :

C++ signature :

void AddNeighbour(Node<2u> {lvalue},unsigned int)

AddNodeAttribute((Node2)arg1, (float)attribute) → None :

C++ signature :

void AddNodeAttribute(Node<2u> {lvalue},double)

ClearAppliedForce((Node2)arg1) → None :

C++ signature :

void ClearAppliedForce(Node<2u> {lvalue})

ClearNeighbours((Node2)arg1) → None :

C++ signature :

void ClearNeighbours(Node<2u> {lvalue})

ContainingBoundaryElementsBegin((Node2)arg1) → object :

C++ signature :

Node<2u>::ContainingBoundaryElementIterator ContainingBoundaryElementsBegin(Node<2u> {lvalue})

ContainingBoundaryElementsEnd((Node2)arg1) → object :

C++ signature :

Node<2u>::ContainingBoundaryElementIterator ContainingBoundaryElementsEnd(Node<2u> {lvalue})

ContainingElementsBegin((Node2)arg1) → object :

C++ signature :

Node<2u>::ContainingElementIterator ContainingElementsBegin(Node<2u> {lvalue})

ContainingElementsEnd((Node2)arg1) → object :

C++ signature :

Node<2u>::ContainingElementIterator ContainingElementsEnd(Node<2u> {lvalue})

GetIndex((Node2)arg1) → int :

C++ signature :

unsigned int GetIndex(Node<2u> {lvalue})

GetNeighboursSetUp((Node2)arg1) → bool :

C++ signature :

bool GetNeighboursSetUp(Node<2u> {lvalue})

GetNumBoundaryElements((Node2)arg1) → int :

C++ signature :

unsigned int GetNumBoundaryElements(Node<2u> {lvalue})

GetNumContainingElements((Node2)arg1) → int :

C++ signature :

unsigned int GetNumContainingElements(Node<2u> {lvalue})

GetNumNodeAttributes((Node2)arg1) → int :

C++ signature :

unsigned int GetNumNodeAttributes(Node<2u> {lvalue})

GetPoint((Node2)arg1) → ChastePoint2 :

C++ signature :

ChastePoint<2u> GetPoint(Node<2u> {lvalue})

GetRadius((Node2)arg1) → float :

C++ signature :

double GetRadius(Node<2u> {lvalue})

GetRegion((Node2)arg1) → int :

C++ signature :

unsigned int GetRegion(Node<2u> {lvalue})

HasNodeAttributes((Node2)arg1) → bool :

C++ signature :

bool HasNodeAttributes(Node<2u> {lvalue})

IsBoundaryNode((Node2)arg1) → bool :

C++ signature :

bool IsBoundaryNode(Node<2u> {lvalue})

IsDeleted((Node2)arg1) → bool :

C++ signature :

bool IsDeleted(Node<2u> {lvalue})

IsInternal((Node2)arg1) → bool :

C++ signature :

bool IsInternal(Node<2u> {lvalue})

IsParticle((Node2)arg1) → bool :

C++ signature :

bool IsParticle(Node<2u> {lvalue})

MarkAsDeleted((Node2)arg1) → None :

C++ signature :

void MarkAsDeleted(Node<2u> {lvalue})

MarkAsInternal((Node2)arg1) → None :

C++ signature :

void MarkAsInternal(Node<2u> {lvalue})

NeighboursIsEmpty((Node2)arg1) → bool :

C++ signature :

bool NeighboursIsEmpty(Node<2u> {lvalue})

RemoveBoundaryElement((Node2)arg1, (int)index) → None :

C++ signature :

void RemoveBoundaryElement(Node<2u> {lvalue},unsigned int)

RemoveDuplicateNeighbours((Node2)arg1) → None :

C++ signature :

void RemoveDuplicateNeighbours(Node<2u> {lvalue})

RemoveElement((Node2)arg1, (int)index) → None :

C++ signature :

void RemoveElement(Node<2u> {lvalue},unsigned int)

SetAsBoundaryNode((Node2)arg1[, (bool)value=True]) → None :

C++ signature :

void SetAsBoundaryNode(Node<2u> {lvalue} [,bool=True])

SetIndex((Node2)arg1, (int)index) → None :

C++ signature :

void SetIndex(Node<2u> {lvalue},unsigned int)

SetIsParticle((Node2)arg1, (bool)isParticle) → None :

C++ signature :

void SetIsParticle(Node<2u> {lvalue},bool)

SetNeighboursSetUp((Node2)arg1, (bool)flag) → None :

C++ signature :

void SetNeighboursSetUp(Node<2u> {lvalue},bool)

SetPoint((Node2)arg1, (ChastePoint2)point) → None :

C++ signature :

void SetPoint(Node<2u> {lvalue},ChastePoint<2u>)

SetRadius((Node2)arg1, (float)radius) → None :

C++ signature :

void SetRadius(Node<2u> {lvalue},double)

SetRegion((Node2)arg1, (int)region) → None :

C++ signature :

void SetRegion(Node<2u> {lvalue},unsigned int)

rGetAppliedForce((Node2)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> {lvalue} rGetAppliedForce(Node<2u> {lvalue})

rGetLocation((Node2)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> rGetLocation(Node<2u> {lvalue})

class chaste.mesh.NodeAttributes2

AddAppliedForceContribution((NodeAttributes2)arg1, (object)appliedForceContribution) → None :

C++ signature :

void AddAppliedForceContribution(NodeAttributes<2u> {lvalue},boost::numeric::ublas::c_vector<double, 2ul> {lvalue})

AddAttribute((NodeAttributes2)arg1, (float)attribute) → None :

C++ signature :

void AddAttribute(NodeAttributes<2u> {lvalue},double)

AddNeighbour((NodeAttributes2)arg1, (int)index) → None :

C++ signature :

void AddNeighbour(NodeAttributes<2u> {lvalue},unsigned int)

ClearAppliedForce((NodeAttributes2)arg1) → None :

C++ signature :

void ClearAppliedForce(NodeAttributes<2u> {lvalue})

ClearNeighbours((NodeAttributes2)arg1) → None :

C++ signature :

void ClearNeighbours(NodeAttributes<2u> {lvalue})

GetNeighboursSetUp((NodeAttributes2)arg1) → bool :

C++ signature :

bool GetNeighboursSetUp(NodeAttributes<2u> {lvalue})

GetRadius((NodeAttributes2)arg1) → float :

C++ signature :

double GetRadius(NodeAttributes<2u> {lvalue})

GetRegion((NodeAttributes2)arg1) → int :

C++ signature :

unsigned int GetRegion(NodeAttributes<2u> {lvalue})

IsParticle((NodeAttributes2)arg1) → bool :

C++ signature :

bool IsParticle(NodeAttributes<2u> {lvalue})

NeighboursIsEmpty((NodeAttributes2)arg1) → bool :

C++ signature :

bool NeighboursIsEmpty(NodeAttributes<2u> {lvalue})

RemoveDuplicateNeighbours((NodeAttributes2)arg1) → None :

C++ signature :

void RemoveDuplicateNeighbours(NodeAttributes<2u> {lvalue})

SetIsParticle((NodeAttributes2)arg1, (bool)isParticle) → None :

C++ signature :

void SetIsParticle(NodeAttributes<2u> {lvalue},bool)

SetNeighboursSetUp((NodeAttributes2)arg1, (bool)flag) → None :

C++ signature :

void SetNeighboursSetUp(NodeAttributes<2u> {lvalue},bool)

SetRadius((NodeAttributes2)arg1, (float)radius) → None :

C++ signature :

void SetRadius(NodeAttributes<2u> {lvalue},double)

SetRegion((NodeAttributes2)arg1, (int)region) → None :

C++ signature :

void SetRegion(NodeAttributes<2u> {lvalue},unsigned int)

rGetAppliedForce((NodeAttributes2)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> {lvalue} rGetAppliedForce(NodeAttributes<2u> {lvalue})

class chaste.mesh.PottsMesh2

AddElement((PottsMesh2)arg1, (object)pNewElement) → int :

C++ signature :

unsigned int AddElement(PottsMesh<2u> {lvalue},PottsElement<2u>*)

CalculateBoundingBox((PottsMesh2)arg1, (VecNodePtr2)rNodes) → object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(PottsMesh_less__2__greater__wrapper {lvalue},std::vector<Node<2u>*, std::allocator<Node<2u>*> >)

CalculateBoundingBox( (PottsMesh2)arg1) -> object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(PottsMesh<2u> {lvalue})

CalculateBoundingBox( (PottsMesh2)arg1) -> object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(PottsMesh_less__2__greater__wrapper {lvalue})

Clear((PottsMesh2)arg1) → None :

C++ signature :

void Clear(PottsMesh<2u> {lvalue})

Clear( (PottsMesh2)arg1) -> None :

C++ signature :

void Clear(PottsMesh_less__2__greater__wrapper {lvalue})

ConstructFromMeshReader((PottsMesh2)arg1, (object)rMeshReader) → None :

C++ signature :

void ConstructFromMeshReader(PottsMesh<2u> {lvalue},AbstractMeshReader<2u, 2u> {lvalue})

DeleteElement((PottsMesh2)arg1, (int)index) → None :

C++ signature :

void DeleteElement(PottsMesh<2u> {lvalue},unsigned int)

DeleteNode((PottsMesh2)arg1, (int)index) → None :

C++ signature :

void DeleteNode(PottsMesh<2u> {lvalue},unsigned int)

DivideElement((PottsMesh2)arg1, (object)pElement[, (bool)placeOriginalElementBelow=False]) → int :

C++ signature :

unsigned int DivideElement(PottsMesh<2u> {lvalue},PottsElement<2u>* [,bool=False])

GetCentroidOfElement((PottsMesh2)arg1, (int)index) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetCentroidOfElement(PottsMesh<2u> {lvalue},unsigned int)

GetCentroidOfElement( (PottsMesh2)arg1, (int)index) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetCentroidOfElement(PottsMesh_less__2__greater__wrapper {lvalue},unsigned int)

GetElement((PottsMesh2)arg1, (int)index) → object :

C++ signature :

PottsElement<2u>* GetElement(PottsMesh<2u> {lvalue},unsigned int)

GetElementIteratorBegin((PottsMesh2)arg1[, (bool)skipDeletedElements=True]) → object :

C++ signature :

PottsMesh<2u>::PottsElementIterator GetElementIteratorBegin(PottsMesh<2u> {lvalue} [,bool=True])

GetElementIteratorEnd((PottsMesh2)arg1) → object :

C++ signature :

PottsMesh<2u>::PottsElementIterator GetElementIteratorEnd(PottsMesh<2u> {lvalue})

GetMooreNeighbouringNodeIndices((PottsMesh2)arg1, (int)nodeIndex) → SetUnsigned :

C++ signature :

std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> > GetMooreNeighbouringNodeIndices(PottsMesh<2u> {lvalue},unsigned int)

GetNearestNodeIndex((PottsMesh2)arg1, (ChastePoint2)rTestPoint) → int :

C++ signature :

unsigned int GetNearestNodeIndex(PottsMesh<2u> {lvalue},ChastePoint<2u>)

GetNearestNodeIndex( (PottsMesh2)arg1, (ChastePoint2)rTestPoint) -> int :

C++ signature :

unsigned int GetNearestNodeIndex(PottsMesh_less__2__greater__wrapper {lvalue},ChastePoint<2u>)

GetNeighbouringElementIndices((PottsMesh2)arg1, (int)elementIndex) → SetUnsigned :

C++ signature :

std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> > GetNeighbouringElementIndices(PottsMesh<2u> {lvalue},unsigned int)

GetNumAllElements((PottsMesh2)arg1) → int :

C++ signature :

unsigned int GetNumAllElements(PottsMesh<2u> {lvalue})

GetNumAllNodes((PottsMesh2)arg1) → int :

C++ signature :

unsigned int GetNumAllNodes(PottsMesh<2u> {lvalue})

GetNumAllNodes( (PottsMesh2)arg1) -> int :

C++ signature :

unsigned int GetNumAllNodes(PottsMesh_less__2__greater__wrapper {lvalue})

GetNumElements((PottsMesh2)arg1) → int :

C++ signature :

unsigned int GetNumElements(PottsMesh<2u> {lvalue})

GetNumElements( (PottsMesh2)arg1) -> int :

C++ signature :

unsigned int GetNumElements(PottsMesh_less__2__greater__wrapper {lvalue})

GetNumNodes((PottsMesh2)arg1) → int :

C++ signature :

unsigned int GetNumNodes(PottsMesh<2u> {lvalue})

GetNumNodes( (PottsMesh2)arg1) -> int :

C++ signature :

unsigned int GetNumNodes(PottsMesh_less__2__greater__wrapper {lvalue})

GetSurfaceAreaOfElement((PottsMesh2)arg1, (int)index) → float :

C++ signature :

double GetSurfaceAreaOfElement(PottsMesh<2u> {lvalue},unsigned int)

GetSurfaceAreaOfElement( (PottsMesh2)arg1, (int)index) -> float :

C++ signature :

double GetSurfaceAreaOfElement(PottsMesh_less__2__greater__wrapper {lvalue},unsigned int)

GetVectorFromAtoB((PottsMesh2)arg1, (object)rLocationA, (object)rLocationB) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetVectorFromAtoB(PottsMesh<2u> {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,boost::numeric::ublas::c_vector<double, 2ul>)

GetVectorFromAtoB( (PottsMesh2)arg1, (object)rLocationA, (object)rLocationB) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetVectorFromAtoB(PottsMesh_less__2__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,boost::numeric::ublas::c_vector<double, 2ul>)

GetVolumeOfElement((PottsMesh2)arg1, (int)index) → float :

C++ signature :

double GetVolumeOfElement(PottsMesh<2u> {lvalue},unsigned int)

GetVolumeOfElement( (PottsMesh2)arg1, (int)index) -> float :

C++ signature :

double GetVolumeOfElement(PottsMesh_less__2__greater__wrapper {lvalue},unsigned int)

GetVonNeumannNeighbouringNodeIndices((PottsMesh2)arg1, (int)nodeIndex) → SetUnsigned :

C++ signature :

std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> > GetVonNeumannNeighbouringNodeIndices(PottsMesh<2u> {lvalue},unsigned int)

GetWidth((PottsMesh2)arg1, (int)rDimension) → float :

C++ signature :

double GetWidth(PottsMesh<2u> {lvalue},unsigned int)

GetWidth( (PottsMesh2)arg1, (int)rDimension) -> float :

C++ signature :

double GetWidth(PottsMesh_less__2__greater__wrapper {lvalue},unsigned int)

PermuteNodes((PottsMesh2)arg1) → None :

C++ signature :

void PermuteNodes(PottsMesh<2u> {lvalue})

PermuteNodes( (PottsMesh2)arg1) -> None :

C++ signature :

void PermuteNodes(PottsMesh_less__2__greater__wrapper {lvalue})

ReadNodesPerProcessorFile((PottsMesh2)arg1, (str)rNodesPerProcessorFile) → None :

C++ signature :

void ReadNodesPerProcessorFile(PottsMesh<2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

ReadNodesPerProcessorFile( (PottsMesh2)arg1, (str)rNodesPerProcessorFile) -> None :

C++ signature :

void ReadNodesPerProcessorFile(PottsMesh_less__2__greater__wrapper {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

RefreshMesh((PottsMesh2)arg1) → None :

C++ signature :

void RefreshMesh(PottsMesh<2u> {lvalue})

RefreshMesh( (PottsMesh2)arg1) -> None :

C++ signature :

void RefreshMesh(PottsMesh_less__2__greater__wrapper {lvalue})

RemoveDeletedElements((PottsMesh2)arg1) → None :

C++ signature :

void RemoveDeletedElements(PottsMesh<2u> {lvalue})

Rotate((PottsMesh2)arg1, (object)rotationMatrix) → None :

C++ signature :

void Rotate(PottsMesh<2u> {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul>)

Rotate( (PottsMesh2)arg1, (object)rotationMatrix) -> None :

C++ signature :

void Rotate(PottsMesh_less__2__greater__wrapper {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul>)

Rotate( (PottsMesh2)arg1, (object)axis, (float)angle) -> None :

C++ signature :

void Rotate(PottsMesh<2u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,double)

Rotate( (PottsMesh2)arg1, (float)theta) -> None :

C++ signature :

void Rotate(PottsMesh<2u> {lvalue},double)

Scale((PottsMesh2)arg1[, (float)xFactor=1.0[, (float)yFactor=1.0[, (float)zFactor=1.0]]]) → None :

C++ signature :

void Scale(PottsMesh<2u> {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

Scale( (PottsMesh2)arg1 [, (float)xFactor=1.0 [, (float)yFactor=1.0 [, (float)zFactor=1.0]]]) -> None :

C++ signature :

void Scale(PottsMesh_less__2__greater__wrapper {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

SetDistributedVectorFactory((PottsMesh2)arg1, (object)pFactory) → None :

C++ signature :

void SetDistributedVectorFactory(PottsMesh<2u> {lvalue},DistributedVectorFactory*)

SetDistributedVectorFactory( (PottsMesh2)arg1, (object)pFactory) -> None :

C++ signature :

void SetDistributedVectorFactory(PottsMesh_less__2__greater__wrapper {lvalue},DistributedVectorFactory*)

SetElementOwnerships((PottsMesh2)arg1) → None :

C++ signature :

void SetElementOwnerships(PottsMesh_less__2__greater__wrapper {lvalue})

SolveBoundaryElementMapping((PottsMesh2)arg1, (int)index) → int :

C++ signature :

unsigned int SolveBoundaryElementMapping(PottsMesh_less__2__greater__wrapper {lvalue},unsigned int)

SolveElementMapping((PottsMesh2)arg1, (int)index) → int :

C++ signature :

unsigned int SolveElementMapping(PottsMesh_less__2__greater__wrapper {lvalue},unsigned int)

SolveNodeMapping((PottsMesh2)arg1, (int)index) → int :

C++ signature :

unsigned int SolveNodeMapping(PottsMesh_less__2__greater__wrapper {lvalue},unsigned int)

Translate((PottsMesh2)arg1, (object)rDisplacement) → None :

C++ signature :

void Translate(PottsMesh<2u> {lvalue},boost::numeric::ublas::c_vector<double, 2ul>)

Translate( (PottsMesh2)arg1, (object)rDisplacement) -> None :

C++ signature :

void Translate(PottsMesh_less__2__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>)

Translate( (PottsMesh2)arg1 [, (float)xMovement=0.0 [, (float)yMovement=0.0 [, (float)zMovement=0.0]]]) -> None :

C++ signature :

void Translate(PottsMesh<2u> {lvalue} [,double=0.0 [,double=0.0 [,double=0.0]]])

class chaste.mesh.NodesOnlyMesh2

AddHaloNode((NodesOnlyMesh2)arg1, (Node2)pNewNode) → None :

C++ signature :

void AddHaloNode(NodesOnlyMesh<2u> {lvalue},boost::shared_ptr<Node<2u> >)

AddHaloNodesToBoxes((NodesOnlyMesh2)arg1) → None :

C++ signature :

void AddHaloNodesToBoxes(NodesOnlyMesh<2u> {lvalue})

AddMovedNode((NodesOnlyMesh2)arg1, (Node2)pMovedNode) → None :

C++ signature :

void AddMovedNode(NodesOnlyMesh<2u> {lvalue},boost::shared_ptr<Node<2u> >)

AddNode((NodesOnlyMesh2)arg1, (Node2)pNewNode) → int :

C++ signature :

unsigned int AddNode(NodesOnlyMesh<2u> {lvalue},Node<2u>*)

AddNode( (NodesOnlyMesh2)arg1, (Node2)pNewNode) -> int :

C++ signature :

unsigned int AddNode(NodesOnlyMesh_less__2__greater__wrapper {lvalue},Node<2u>*)

AddNodesToBoxes((NodesOnlyMesh2)arg1) → None :

C++ signature :

void AddNodesToBoxes(NodesOnlyMesh<2u> {lvalue})

CalculateBoundaryNodePairs((NodesOnlyMesh2)arg1, (vector_less__std_scope_pair_less_Node_less_2_greater___ptr__comma__Node_less_2_greater___ptr__greater___greater_)rNodePairs) → None :

C++ signature :

void CalculateBoundaryNodePairs(NodesOnlyMesh<2u> {lvalue},std::vector<std::pair<Node<2u>*, Node<2u>*>, std::allocator<std::pair<Node<2u>*, Node<2u>*> > > {lvalue})

CalculateBoundingBox((NodesOnlyMesh2)arg1, (VecNodePtr2)rNodes) → object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(NodesOnlyMesh_less__2__greater__wrapper {lvalue},std::vector<Node<2u>*, std::allocator<Node<2u>*> >)

CalculateBoundingBox( (NodesOnlyMesh2)arg1) -> object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(NodesOnlyMesh<2u> {lvalue})

CalculateBoundingBox( (NodesOnlyMesh2)arg1) -> object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(NodesOnlyMesh_less__2__greater__wrapper {lvalue})

CalculateDesignatedOwnershipOfBoundaryElement((NodesOnlyMesh2)arg1, (int)faceIndex) → bool :

C++ signature :

bool CalculateDesignatedOwnershipOfBoundaryElement(NodesOnlyMesh<2u> {lvalue},unsigned int)

CalculateDesignatedOwnershipOfBoundaryElement( (NodesOnlyMesh2)arg1, (int)faceIndex) -> bool :

C++ signature :

bool CalculateDesignatedOwnershipOfBoundaryElement(NodesOnlyMesh_less__2__greater__wrapper {lvalue},unsigned int)

CalculateDesignatedOwnershipOfElement((NodesOnlyMesh2)arg1, (int)elementIndex) → bool :

C++ signature :

bool CalculateDesignatedOwnershipOfElement(NodesOnlyMesh<2u> {lvalue},unsigned int)

CalculateDesignatedOwnershipOfElement( (NodesOnlyMesh2)arg1, (int)elementIndex) -> bool :

C++ signature :

bool CalculateDesignatedOwnershipOfElement(NodesOnlyMesh_less__2__greater__wrapper {lvalue},unsigned int)

CalculateInteriorNodePairs((NodesOnlyMesh2)arg1, (vector_less__std_scope_pair_less_Node_less_2_greater___ptr__comma__Node_less_2_greater___ptr__greater___greater_)rNodePairs) → None :

C++ signature :

void CalculateInteriorNodePairs(NodesOnlyMesh<2u> {lvalue},std::vector<std::pair<Node<2u>*, Node<2u>*>, std::allocator<std::pair<Node<2u>*, Node<2u>*> > > {lvalue})

CalculateMinMaxEdgeLengths((NodesOnlyMesh2)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> CalculateMinMaxEdgeLengths(NodesOnlyMesh<2u> {lvalue})

CalculateMinMaxEdgeLengths( (NodesOnlyMesh2)arg1) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> CalculateMinMaxEdgeLengths(NodesOnlyMesh_less__2__greater__wrapper {lvalue})

CalculateNodesOutsideLocalDomain((NodesOnlyMesh2)arg1) → None :

C++ signature :

void CalculateNodesOutsideLocalDomain(NodesOnlyMesh<2u> {lvalue})

Clear((NodesOnlyMesh2)arg1) → None :

C++ signature :

void Clear(NodesOnlyMesh<2u> {lvalue})

Clear( (NodesOnlyMesh2)arg1) -> None :

C++ signature :

void Clear(NodesOnlyMesh_less__2__greater__wrapper {lvalue})

ClearBoxCollection((NodesOnlyMesh2)arg1) → None :

C++ signature :

void ClearBoxCollection(NodesOnlyMesh_less__2__greater__wrapper {lvalue})

ClearHaloNodes((NodesOnlyMesh2)arg1) → None :

C++ signature :

void ClearHaloNodes(NodesOnlyMesh<2u> {lvalue})

ConstructCuboid((NodesOnlyMesh2)arg1, (int)width, (int)height, (int)depth) → None :

C++ signature :

void ConstructCuboid(NodesOnlyMesh<2u> {lvalue},unsigned int,unsigned int,unsigned int)

ConstructCuboid( (NodesOnlyMesh2)arg1, (int)width, (int)height, (int)depth) -> None :

C++ signature :

void ConstructCuboid(NodesOnlyMesh_less__2__greater__wrapper {lvalue},unsigned int,unsigned int,unsigned int)

ConstructFromMeshReader((NodesOnlyMesh2)arg1, (object)rMeshReader) → None :

C++ signature :

void ConstructFromMeshReader(NodesOnlyMesh<2u> {lvalue},AbstractMeshReader<2u, 2u> {lvalue})

ConstructFromMeshReader( (NodesOnlyMesh2)arg1, (object)rMeshReader) -> None :

C++ signature :

void ConstructFromMeshReader(NodesOnlyMesh_less__2__greater__wrapper {lvalue},AbstractMeshReader<2u, 2u> {lvalue})

ConstructLinearMesh((NodesOnlyMesh2)arg1, (int)width) → None :

C++ signature :

void ConstructLinearMesh(NodesOnlyMesh<2u> {lvalue},unsigned int)

ConstructLinearMesh( (NodesOnlyMesh2)arg1, (int)width) -> None :

C++ signature :

void ConstructLinearMesh(NodesOnlyMesh_less__2__greater__wrapper {lvalue},unsigned int)

ConstructNodesWithoutMesh((NodesOnlyMesh2)arg1, (VecNodePtr2)rNodes, (float)maxInteractionDistance) → None :

C++ signature :

void ConstructNodesWithoutMesh(NodesOnlyMesh<2u> {lvalue},std::vector<Node<2u>*, std::allocator<Node<2u>*> >,double)

ConstructNodesWithoutMesh( (NodesOnlyMesh2)arg1, (VecNodeSharedPtr2)rNodes, (float)maxInteractionDistance) -> None :

C++ signature :

void ConstructNodesWithoutMesh(NodesOnlyMesh<2u> {lvalue},std::vector<boost::shared_ptr<Node<2u> >, std::allocator<boost::shared_ptr<Node<2u> > > >,double)

ConstructNodesWithoutMesh( (NodesOnlyMesh2)arg1, (AbstractMesh2_2)rGeneratingMesh, (float)maxInteractionDistance) -> None :

C++ signature :

void ConstructNodesWithoutMesh(NodesOnlyMesh<2u> {lvalue},AbstractMesh<2u, 2u>,double)

ConstructRectangularMesh((NodesOnlyMesh2)arg1, (int)width, (int)height[, (bool)stagger=True]) → None :

C++ signature :

void ConstructRectangularMesh(NodesOnlyMesh<2u> {lvalue},unsigned int,unsigned int [,bool=True])

ConstructRectangularMesh( (NodesOnlyMesh2)arg1, (int)width, (int)height [, (bool)stagger=True]) -> None :

C++ signature :

void ConstructRectangularMesh(NodesOnlyMesh_less__2__greater__wrapper {lvalue},unsigned int,unsigned int [,bool=True])

DeleteElement((NodesOnlyMesh2)arg1, (int)index) → None :

C++ signature :

void DeleteElement(NodesOnlyMesh<2u> {lvalue},unsigned int)

DeleteElement( (NodesOnlyMesh2)arg1, (int)index) -> None :

C++ signature :

void DeleteElement(NodesOnlyMesh_less__2__greater__wrapper {lvalue},unsigned int)

DeleteMovedNode((NodesOnlyMesh2)arg1, (int)index) → None :

C++ signature :

void DeleteMovedNode(NodesOnlyMesh<2u> {lvalue},unsigned int)

DeleteNode((NodesOnlyMesh2)arg1, (int)index) → None :

C++ signature :

void DeleteNode(NodesOnlyMesh<2u> {lvalue},unsigned int)

DeleteNode( (NodesOnlyMesh2)arg1, (int)index) -> None :

C++ signature :

void DeleteNode(NodesOnlyMesh_less__2__greater__wrapper {lvalue},unsigned int)

GetHaloNodeIndices((NodesOnlyMesh2)arg1, (VecUnsigned)rHaloIndices) → None :

C++ signature :

void GetHaloNodeIndices(NodesOnlyMesh<2u> {lvalue},std::vector<unsigned int, std::allocator<unsigned int> > {lvalue})

GetHaloNodeIndices( (NodesOnlyMesh2)arg1, (VecUnsigned)rHaloIndices) -> None :

C++ signature :

void GetHaloNodeIndices(NodesOnlyMesh_less__2__greater__wrapper {lvalue},std::vector<unsigned int, std::allocator<unsigned int> > {lvalue})

GetInverseJacobianForElement((NodesOnlyMesh2)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant, (object)rInverseJacobian) → None :

C++ signature :

void GetInverseJacobianForElement(NodesOnlyMesh<2u> {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue},double {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue})

GetInverseJacobianForElement( (NodesOnlyMesh2)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant, (object)rInverseJacobian) -> None :

C++ signature :

void GetInverseJacobianForElement(NodesOnlyMesh_less__2__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue},double {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue})

GetJacobianForElement((NodesOnlyMesh2)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant) → None :

C++ signature :

void GetJacobianForElement(NodesOnlyMesh<2u> {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue},double {lvalue})

GetJacobianForElement( (NodesOnlyMesh2)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant) -> None :

C++ signature :

void GetJacobianForElement(NodesOnlyMesh_less__2__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue},double {lvalue})

GetMaximumInteractionDistance((NodesOnlyMesh2)arg1) → float :

C++ signature :

double GetMaximumInteractionDistance(NodesOnlyMesh<2u> {lvalue})

GetMaximumNodeIndex((NodesOnlyMesh2)arg1) → int :

C++ signature :

unsigned int GetMaximumNodeIndex(NodesOnlyMesh<2u> {lvalue})

GetMaximumNodeIndex( (NodesOnlyMesh2)arg1) -> int :

C++ signature :

unsigned int GetMaximumNodeIndex(NodesOnlyMesh_less__2__greater__wrapper {lvalue})

GetNearestNodeIndex((NodesOnlyMesh2)arg1, (ChastePoint2)rTestPoint) → int :

C++ signature :

unsigned int GetNearestNodeIndex(NodesOnlyMesh<2u> {lvalue},ChastePoint<2u>)

GetNearestNodeIndex( (NodesOnlyMesh2)arg1, (ChastePoint2)rTestPoint) -> int :

C++ signature :

unsigned int GetNearestNodeIndex(NodesOnlyMesh_less__2__greater__wrapper {lvalue},ChastePoint<2u>)

GetNumAllNodes((NodesOnlyMesh2)arg1) → int :

C++ signature :

unsigned int GetNumAllNodes(NodesOnlyMesh<2u> {lvalue})

GetNumAllNodes( (NodesOnlyMesh2)arg1) -> int :

C++ signature :

unsigned int GetNumAllNodes(NodesOnlyMesh_less__2__greater__wrapper {lvalue})

GetNumBoundaryElements((NodesOnlyMesh2)arg1) → int :

C++ signature :

unsigned int GetNumBoundaryElements(NodesOnlyMesh<2u> {lvalue})

GetNumBoundaryElements( (NodesOnlyMesh2)arg1) -> int :

C++ signature :

unsigned int GetNumBoundaryElements(NodesOnlyMesh_less__2__greater__wrapper {lvalue})

GetNumCableElements((NodesOnlyMesh2)arg1) → int :

C++ signature :

unsigned int GetNumCableElements(NodesOnlyMesh<2u> {lvalue})

GetNumCableElements( (NodesOnlyMesh2)arg1) -> int :

C++ signature :

unsigned int GetNumCableElements(NodesOnlyMesh_less__2__greater__wrapper {lvalue})

GetNumElements((NodesOnlyMesh2)arg1) → int :

C++ signature :

unsigned int GetNumElements(NodesOnlyMesh<2u> {lvalue})

GetNumElements( (NodesOnlyMesh2)arg1) -> int :

C++ signature :

unsigned int GetNumElements(NodesOnlyMesh_less__2__greater__wrapper {lvalue})

GetNumLocalBoundaryElements((NodesOnlyMesh2)arg1) → int :

C++ signature :

unsigned int GetNumLocalBoundaryElements(NodesOnlyMesh<2u> {lvalue})

GetNumLocalBoundaryElements( (NodesOnlyMesh2)arg1) -> int :

C++ signature :

unsigned int GetNumLocalBoundaryElements(NodesOnlyMesh_less__2__greater__wrapper {lvalue})

GetNumLocalElements((NodesOnlyMesh2)arg1) → int :

C++ signature :

unsigned int GetNumLocalElements(NodesOnlyMesh<2u> {lvalue})

GetNumLocalElements( (NodesOnlyMesh2)arg1) -> int :

C++ signature :

unsigned int GetNumLocalElements(NodesOnlyMesh_less__2__greater__wrapper {lvalue})

GetNumNodes((NodesOnlyMesh2)arg1) → int :

C++ signature :

unsigned int GetNumNodes(NodesOnlyMesh<2u> {lvalue})

GetNumNodes( (NodesOnlyMesh2)arg1) -> int :

C++ signature :

unsigned int GetNumNodes(NodesOnlyMesh_less__2__greater__wrapper {lvalue})

GetNumVertices((NodesOnlyMesh2)arg1) → int :

C++ signature :

unsigned int GetNumVertices(NodesOnlyMesh<2u> {lvalue})

GetNumVertices( (NodesOnlyMesh2)arg1) -> int :

C++ signature :

unsigned int GetNumVertices(NodesOnlyMesh_less__2__greater__wrapper {lvalue})

GetVectorFromAtoB((NodesOnlyMesh2)arg1, (object)rLocationA, (object)rLocationB) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetVectorFromAtoB(NodesOnlyMesh<2u> {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,boost::numeric::ublas::c_vector<double, 2ul>)

GetVectorFromAtoB( (NodesOnlyMesh2)arg1, (object)rLocationA, (object)rLocationB) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetVectorFromAtoB(NodesOnlyMesh_less__2__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,boost::numeric::ublas::c_vector<double, 2ul>)

GetWeightedDirectionForBoundaryElement((NodesOnlyMesh2)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) → None :

C++ signature :

void GetWeightedDirectionForBoundaryElement(NodesOnlyMesh<2u> {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 2ul> {lvalue},double {lvalue})

GetWeightedDirectionForBoundaryElement( (NodesOnlyMesh2)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) -> None :

C++ signature :

void GetWeightedDirectionForBoundaryElement(NodesOnlyMesh_less__2__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 2ul> {lvalue},double {lvalue})

GetWeightedDirectionForElement((NodesOnlyMesh2)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) → None :

C++ signature :

void GetWeightedDirectionForElement(NodesOnlyMesh<2u> {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 2ul> {lvalue},double {lvalue})

GetWeightedDirectionForElement( (NodesOnlyMesh2)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) -> None :

C++ signature :

void GetWeightedDirectionForElement(NodesOnlyMesh_less__2__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 2ul> {lvalue},double {lvalue})

GetWidth((NodesOnlyMesh2)arg1, (int)rDimension) → float :

C++ signature :

double GetWidth(NodesOnlyMesh<2u> {lvalue},unsigned int)

GetWidth( (NodesOnlyMesh2)arg1, (int)rDimension) -> float :

C++ signature :

double GetWidth(NodesOnlyMesh_less__2__greater__wrapper {lvalue},unsigned int)

IsOwned((NodesOnlyMesh2)arg1, (object)location) → bool :

C++ signature :

bool IsOwned(NodesOnlyMesh<2u> {lvalue},boost::numeric::ublas::c_vector<double, 2ul> {lvalue})

LoadBalanceMesh((NodesOnlyMesh2)arg1) → None :

C++ signature :

void LoadBalanceMesh(NodesOnlyMesh<2u> {lvalue})

PermuteNodes((NodesOnlyMesh2)arg1) → None :

C++ signature :

void PermuteNodes(NodesOnlyMesh<2u> {lvalue})

PermuteNodes( (NodesOnlyMesh2)arg1) -> None :

C++ signature :

void PermuteNodes(NodesOnlyMesh_less__2__greater__wrapper {lvalue})

PermuteNodes( (NodesOnlyMesh2)arg1, (VecUnsigned)perm) -> None :

C++ signature :

void PermuteNodes(NodesOnlyMesh<2u> {lvalue},std::vector<unsigned int, std::allocator<unsigned int> >)

ReMesh((NodesOnlyMesh2)arg1, (object)rMap) → None :

C++ signature :

void ReMesh(NodesOnlyMesh<2u> {lvalue},NodeMap {lvalue})

ReMesh( (NodesOnlyMesh2)arg1, (object)rMap) -> None :

C++ signature :

void ReMesh(NodesOnlyMesh_less__2__greater__wrapper {lvalue},NodeMap {lvalue})

ReadNodesPerProcessorFile((NodesOnlyMesh2)arg1, (str)rNodesPerProcessorFile) → None :

C++ signature :

void ReadNodesPerProcessorFile(NodesOnlyMesh<2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

ReadNodesPerProcessorFile( (NodesOnlyMesh2)arg1, (str)rNodesPerProcessorFile) -> None :

C++ signature :

void ReadNodesPerProcessorFile(NodesOnlyMesh_less__2__greater__wrapper {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

RefreshJacobianCachedData((NodesOnlyMesh2)arg1) → None :

C++ signature :

void RefreshJacobianCachedData(NodesOnlyMesh<2u> {lvalue})

RefreshJacobianCachedData( (NodesOnlyMesh2)arg1) -> None :

C++ signature :

void RefreshJacobianCachedData(NodesOnlyMesh_less__2__greater__wrapper {lvalue})

RefreshMesh((NodesOnlyMesh2)arg1) → None :

C++ signature :

void RefreshMesh(NodesOnlyMesh<2u> {lvalue})

RefreshMesh( (NodesOnlyMesh2)arg1) -> None :

C++ signature :

void RefreshMesh(NodesOnlyMesh_less__2__greater__wrapper {lvalue})

ResizeBoxCollection((NodesOnlyMesh2)arg1) → None :

C++ signature :

void ResizeBoxCollection(NodesOnlyMesh<2u> {lvalue})

Rotate((NodesOnlyMesh2)arg1, (object)rotationMatrix) → None :

C++ signature :

void Rotate(NodesOnlyMesh<2u> {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul>)

Rotate( (NodesOnlyMesh2)arg1, (object)rotationMatrix) -> None :

C++ signature :

void Rotate(NodesOnlyMesh_less__2__greater__wrapper {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul>)

Rotate( (NodesOnlyMesh2)arg1, (object)axis, (float)angle) -> None :

C++ signature :

void Rotate(NodesOnlyMesh<2u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,double)

Rotate( (NodesOnlyMesh2)arg1, (float)theta) -> None :

C++ signature :

void Rotate(NodesOnlyMesh<2u> {lvalue},double)

Scale((NodesOnlyMesh2)arg1[, (float)xFactor=1.0[, (float)yFactor=1.0[, (float)zFactor=1.0]]]) → None :

C++ signature :

void Scale(NodesOnlyMesh<2u> {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

Scale( (NodesOnlyMesh2)arg1 [, (float)xFactor=1.0 [, (float)yFactor=1.0 [, (float)zFactor=1.0]]]) -> None :

C++ signature :

void Scale(NodesOnlyMesh_less__2__greater__wrapper {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

SetCalculateNodeNeighbours((NodesOnlyMesh2)arg1, (bool)calculateNodeNeighbours) → None :

C++ signature :

void SetCalculateNodeNeighbours(NodesOnlyMesh<2u> {lvalue},bool)

SetDistributedVectorFactory((NodesOnlyMesh2)arg1, (object)pFactory) → None :

C++ signature :

void SetDistributedVectorFactory(NodesOnlyMesh<2u> {lvalue},DistributedVectorFactory*)

SetDistributedVectorFactory( (NodesOnlyMesh2)arg1, (object)pFactory) -> None :

C++ signature :

void SetDistributedVectorFactory(NodesOnlyMesh_less__2__greater__wrapper {lvalue},DistributedVectorFactory*)

SetElementOwnerships((NodesOnlyMesh2)arg1) → None :

C++ signature :

void SetElementOwnerships(NodesOnlyMesh_less__2__greater__wrapper {lvalue})

SetInitialBoxCollection((NodesOnlyMesh2)arg1, (object)domainSize, (float)maxInteractionDistance) → None :

C++ signature :

void SetInitialBoxCollection(NodesOnlyMesh<2u> {lvalue},boost::numeric::ublas::c_vector<double, 4ul>,double)

SetMaximumInteractionDistance((NodesOnlyMesh2)arg1, (float)maxDistance) → None :

C++ signature :

void SetMaximumInteractionDistance(NodesOnlyMesh<2u> {lvalue},double)

SetMinimumNodeDomainBoundarySeparation((NodesOnlyMesh2)arg1, (float)separation) → None :

C++ signature :

void SetMinimumNodeDomainBoundarySeparation(NodesOnlyMesh<2u> {lvalue},double)

SetNode((NodesOnlyMesh2)arg1, (int)nodeIndex, (ChastePoint2)point[, (bool)concreteMove=False]) → None :

C++ signature :

void SetNode(NodesOnlyMesh<2u> {lvalue},unsigned int,ChastePoint<2u> [,bool=False])

SetNode( (NodesOnlyMesh2)arg1, (int)nodeIndex, (ChastePoint2)point [, (bool)concreteMove=False]) -> None :

C++ signature :

void SetNode(NodesOnlyMesh_less__2__greater__wrapper {lvalue},unsigned int,ChastePoint<2u> [,bool=False])

SetUpBoxCollection((NodesOnlyMesh2)arg1, (float)cutOffLength, (object)domainSize[, (int)numLocalRows=-1[, (bool)isPeriodic=False]]) → None :

C++ signature :

void SetUpBoxCollection(NodesOnlyMesh_less__2__greater__wrapper {lvalue},double,boost::numeric::ublas::c_vector<double, 4ul> [,int=-1 [,bool=False]])

SolveBoundaryElementMapping((NodesOnlyMesh2)arg1, (int)index) → int :

C++ signature :

unsigned int SolveBoundaryElementMapping(NodesOnlyMesh_less__2__greater__wrapper {lvalue},unsigned int)

SolveElementMapping((NodesOnlyMesh2)arg1, (int)index) → int :

C++ signature :

unsigned int SolveElementMapping(NodesOnlyMesh_less__2__greater__wrapper {lvalue},unsigned int)

SolveNodeMapping((NodesOnlyMesh2)arg1, (int)index) → int :

C++ signature :

unsigned int SolveNodeMapping(NodesOnlyMesh<2u> {lvalue},unsigned int)

SolveNodeMapping( (NodesOnlyMesh2)arg1, (int)index) -> int :

C++ signature :

unsigned int SolveNodeMapping(NodesOnlyMesh_less__2__greater__wrapper {lvalue},unsigned int)

Translate((NodesOnlyMesh2)arg1, (object)rDisplacement) → None :

C++ signature :

void Translate(NodesOnlyMesh<2u> {lvalue},boost::numeric::ublas::c_vector<double, 2ul>)

Translate( (NodesOnlyMesh2)arg1, (object)rDisplacement) -> None :

C++ signature :

void Translate(NodesOnlyMesh_less__2__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>)

Translate( (NodesOnlyMesh2)arg1 [, (float)xMovement=0.0 [, (float)yMovement=0.0 [, (float)zMovement=0.0]]]) -> None :

C++ signature :

void Translate(NodesOnlyMesh<2u> {lvalue} [,double=0.0 [,double=0.0 [,double=0.0]]])

UpdateBoxCollection((NodesOnlyMesh2)arg1) → None :

C++ signature :

void UpdateBoxCollection(NodesOnlyMesh<2u> {lvalue})

class chaste.mesh.NodesOnlyMesh3

AddHaloNode((NodesOnlyMesh3)arg1, (Node3)pNewNode) → None :

C++ signature :

void AddHaloNode(NodesOnlyMesh<3u> {lvalue},boost::shared_ptr<Node<3u> >)

AddHaloNodesToBoxes((NodesOnlyMesh3)arg1) → None :

C++ signature :

void AddHaloNodesToBoxes(NodesOnlyMesh<3u> {lvalue})

AddMovedNode((NodesOnlyMesh3)arg1, (Node3)pMovedNode) → None :

C++ signature :

void AddMovedNode(NodesOnlyMesh<3u> {lvalue},boost::shared_ptr<Node<3u> >)

AddNode((NodesOnlyMesh3)arg1, (Node3)pNewNode) → int :

C++ signature :

unsigned int AddNode(NodesOnlyMesh<3u> {lvalue},Node<3u>*)

AddNode( (NodesOnlyMesh3)arg1, (Node3)pNewNode) -> int :

C++ signature :

unsigned int AddNode(NodesOnlyMesh_less__3__greater__wrapper {lvalue},Node<3u>*)

AddNodesToBoxes((NodesOnlyMesh3)arg1) → None :

C++ signature :

void AddNodesToBoxes(NodesOnlyMesh<3u> {lvalue})

CalculateBoundaryNodePairs((NodesOnlyMesh3)arg1, (vector_less__std_scope_pair_less_Node_less_3_greater___ptr__comma__Node_less_3_greater___ptr__greater___greater_)rNodePairs) → None :

C++ signature :

void CalculateBoundaryNodePairs(NodesOnlyMesh<3u> {lvalue},std::vector<std::pair<Node<3u>*, Node<3u>*>, std::allocator<std::pair<Node<3u>*, Node<3u>*> > > {lvalue})

CalculateBoundingBox((NodesOnlyMesh3)arg1, (VecNodePtr3)rNodes) → object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(NodesOnlyMesh_less__3__greater__wrapper {lvalue},std::vector<Node<3u>*, std::allocator<Node<3u>*> >)

CalculateBoundingBox( (NodesOnlyMesh3)arg1) -> object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(NodesOnlyMesh<3u> {lvalue})

CalculateBoundingBox( (NodesOnlyMesh3)arg1) -> object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(NodesOnlyMesh_less__3__greater__wrapper {lvalue})

CalculateDesignatedOwnershipOfBoundaryElement((NodesOnlyMesh3)arg1, (int)faceIndex) → bool :

C++ signature :

bool CalculateDesignatedOwnershipOfBoundaryElement(NodesOnlyMesh<3u> {lvalue},unsigned int)

CalculateDesignatedOwnershipOfBoundaryElement( (NodesOnlyMesh3)arg1, (int)faceIndex) -> bool :

C++ signature :

bool CalculateDesignatedOwnershipOfBoundaryElement(NodesOnlyMesh_less__3__greater__wrapper {lvalue},unsigned int)

CalculateDesignatedOwnershipOfElement((NodesOnlyMesh3)arg1, (int)elementIndex) → bool :

C++ signature :

bool CalculateDesignatedOwnershipOfElement(NodesOnlyMesh<3u> {lvalue},unsigned int)

CalculateDesignatedOwnershipOfElement( (NodesOnlyMesh3)arg1, (int)elementIndex) -> bool :

C++ signature :

bool CalculateDesignatedOwnershipOfElement(NodesOnlyMesh_less__3__greater__wrapper {lvalue},unsigned int)

CalculateInteriorNodePairs((NodesOnlyMesh3)arg1, (vector_less__std_scope_pair_less_Node_less_3_greater___ptr__comma__Node_less_3_greater___ptr__greater___greater_)rNodePairs) → None :

C++ signature :

void CalculateInteriorNodePairs(NodesOnlyMesh<3u> {lvalue},std::vector<std::pair<Node<3u>*, Node<3u>*>, std::allocator<std::pair<Node<3u>*, Node<3u>*> > > {lvalue})

CalculateMinMaxEdgeLengths((NodesOnlyMesh3)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> CalculateMinMaxEdgeLengths(NodesOnlyMesh<3u> {lvalue})

CalculateMinMaxEdgeLengths( (NodesOnlyMesh3)arg1) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> CalculateMinMaxEdgeLengths(NodesOnlyMesh_less__3__greater__wrapper {lvalue})

CalculateNodesOutsideLocalDomain((NodesOnlyMesh3)arg1) → None :

C++ signature :

void CalculateNodesOutsideLocalDomain(NodesOnlyMesh<3u> {lvalue})

Clear((NodesOnlyMesh3)arg1) → None :

C++ signature :

void Clear(NodesOnlyMesh<3u> {lvalue})

Clear( (NodesOnlyMesh3)arg1) -> None :

C++ signature :

void Clear(NodesOnlyMesh_less__3__greater__wrapper {lvalue})

ClearBoxCollection((NodesOnlyMesh3)arg1) → None :

C++ signature :

void ClearBoxCollection(NodesOnlyMesh_less__3__greater__wrapper {lvalue})

ClearHaloNodes((NodesOnlyMesh3)arg1) → None :

C++ signature :

void ClearHaloNodes(NodesOnlyMesh<3u> {lvalue})

ConstructCuboid((NodesOnlyMesh3)arg1, (int)width, (int)height, (int)depth) → None :

C++ signature :

void ConstructCuboid(NodesOnlyMesh<3u> {lvalue},unsigned int,unsigned int,unsigned int)

ConstructCuboid( (NodesOnlyMesh3)arg1, (int)width, (int)height, (int)depth) -> None :

C++ signature :

void ConstructCuboid(NodesOnlyMesh_less__3__greater__wrapper {lvalue},unsigned int,unsigned int,unsigned int)

ConstructFromMeshReader((NodesOnlyMesh3)arg1, (object)rMeshReader) → None :

C++ signature :

void ConstructFromMeshReader(NodesOnlyMesh<3u> {lvalue},AbstractMeshReader<3u, 3u> {lvalue})

ConstructFromMeshReader( (NodesOnlyMesh3)arg1, (object)rMeshReader) -> None :

C++ signature :

void ConstructFromMeshReader(NodesOnlyMesh_less__3__greater__wrapper {lvalue},AbstractMeshReader<3u, 3u> {lvalue})

ConstructLinearMesh((NodesOnlyMesh3)arg1, (int)width) → None :

C++ signature :

void ConstructLinearMesh(NodesOnlyMesh<3u> {lvalue},unsigned int)

ConstructLinearMesh( (NodesOnlyMesh3)arg1, (int)width) -> None :

C++ signature :

void ConstructLinearMesh(NodesOnlyMesh_less__3__greater__wrapper {lvalue},unsigned int)

ConstructNodesWithoutMesh((NodesOnlyMesh3)arg1, (VecNodePtr3)rNodes, (float)maxInteractionDistance) → None :

C++ signature :

void ConstructNodesWithoutMesh(NodesOnlyMesh<3u> {lvalue},std::vector<Node<3u>*, std::allocator<Node<3u>*> >,double)

ConstructNodesWithoutMesh( (NodesOnlyMesh3)arg1, (VecNodeSharedPtr3)rNodes, (float)maxInteractionDistance) -> None :

C++ signature :

void ConstructNodesWithoutMesh(NodesOnlyMesh<3u> {lvalue},std::vector<boost::shared_ptr<Node<3u> >, std::allocator<boost::shared_ptr<Node<3u> > > >,double)

ConstructNodesWithoutMesh( (NodesOnlyMesh3)arg1, (AbstractMesh3_3)rGeneratingMesh, (float)maxInteractionDistance) -> None :

C++ signature :

void ConstructNodesWithoutMesh(NodesOnlyMesh<3u> {lvalue},AbstractMesh<3u, 3u>,double)

ConstructRectangularMesh((NodesOnlyMesh3)arg1, (int)width, (int)height[, (bool)stagger=True]) → None :

C++ signature :

void ConstructRectangularMesh(NodesOnlyMesh<3u> {lvalue},unsigned int,unsigned int [,bool=True])

ConstructRectangularMesh( (NodesOnlyMesh3)arg1, (int)width, (int)height [, (bool)stagger=True]) -> None :

C++ signature :

void ConstructRectangularMesh(NodesOnlyMesh_less__3__greater__wrapper {lvalue},unsigned int,unsigned int [,bool=True])

DeleteElement((NodesOnlyMesh3)arg1, (int)index) → None :

C++ signature :

void DeleteElement(NodesOnlyMesh<3u> {lvalue},unsigned int)

DeleteElement( (NodesOnlyMesh3)arg1, (int)index) -> None :

C++ signature :

void DeleteElement(NodesOnlyMesh_less__3__greater__wrapper {lvalue},unsigned int)

DeleteMovedNode((NodesOnlyMesh3)arg1, (int)index) → None :

C++ signature :

void DeleteMovedNode(NodesOnlyMesh<3u> {lvalue},unsigned int)

DeleteNode((NodesOnlyMesh3)arg1, (int)index) → None :

C++ signature :

void DeleteNode(NodesOnlyMesh<3u> {lvalue},unsigned int)

DeleteNode( (NodesOnlyMesh3)arg1, (int)index) -> None :

C++ signature :

void DeleteNode(NodesOnlyMesh_less__3__greater__wrapper {lvalue},unsigned int)

GetHaloNodeIndices((NodesOnlyMesh3)arg1, (VecUnsigned)rHaloIndices) → None :

C++ signature :

void GetHaloNodeIndices(NodesOnlyMesh<3u> {lvalue},std::vector<unsigned int, std::allocator<unsigned int> > {lvalue})

GetHaloNodeIndices( (NodesOnlyMesh3)arg1, (VecUnsigned)rHaloIndices) -> None :

C++ signature :

void GetHaloNodeIndices(NodesOnlyMesh_less__3__greater__wrapper {lvalue},std::vector<unsigned int, std::allocator<unsigned int> > {lvalue})

GetInverseJacobianForElement((NodesOnlyMesh3)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant, (object)rInverseJacobian) → None :

C++ signature :

void GetInverseJacobianForElement(NodesOnlyMesh<3u> {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue},double {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue})

GetInverseJacobianForElement( (NodesOnlyMesh3)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant, (object)rInverseJacobian) -> None :

C++ signature :

void GetInverseJacobianForElement(NodesOnlyMesh_less__3__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue},double {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue})

GetJacobianForElement((NodesOnlyMesh3)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant) → None :

C++ signature :

void GetJacobianForElement(NodesOnlyMesh<3u> {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue},double {lvalue})

GetJacobianForElement( (NodesOnlyMesh3)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant) -> None :

C++ signature :

void GetJacobianForElement(NodesOnlyMesh_less__3__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue},double {lvalue})

GetMaximumInteractionDistance((NodesOnlyMesh3)arg1) → float :

C++ signature :

double GetMaximumInteractionDistance(NodesOnlyMesh<3u> {lvalue})

GetMaximumNodeIndex((NodesOnlyMesh3)arg1) → int :

C++ signature :

unsigned int GetMaximumNodeIndex(NodesOnlyMesh<3u> {lvalue})

GetMaximumNodeIndex( (NodesOnlyMesh3)arg1) -> int :

C++ signature :

unsigned int GetMaximumNodeIndex(NodesOnlyMesh_less__3__greater__wrapper {lvalue})

GetNearestNodeIndex((NodesOnlyMesh3)arg1, (ChastePoint3)rTestPoint) → int :

C++ signature :

unsigned int GetNearestNodeIndex(NodesOnlyMesh<3u> {lvalue},ChastePoint<3u>)

GetNearestNodeIndex( (NodesOnlyMesh3)arg1, (ChastePoint3)rTestPoint) -> int :

C++ signature :

unsigned int GetNearestNodeIndex(NodesOnlyMesh_less__3__greater__wrapper {lvalue},ChastePoint<3u>)

GetNumAllNodes((NodesOnlyMesh3)arg1) → int :

C++ signature :

unsigned int GetNumAllNodes(NodesOnlyMesh<3u> {lvalue})

GetNumAllNodes( (NodesOnlyMesh3)arg1) -> int :

C++ signature :

unsigned int GetNumAllNodes(NodesOnlyMesh_less__3__greater__wrapper {lvalue})

GetNumBoundaryElements((NodesOnlyMesh3)arg1) → int :

C++ signature :

unsigned int GetNumBoundaryElements(NodesOnlyMesh<3u> {lvalue})

GetNumBoundaryElements( (NodesOnlyMesh3)arg1) -> int :

C++ signature :

unsigned int GetNumBoundaryElements(NodesOnlyMesh_less__3__greater__wrapper {lvalue})

GetNumCableElements((NodesOnlyMesh3)arg1) → int :

C++ signature :

unsigned int GetNumCableElements(NodesOnlyMesh<3u> {lvalue})

GetNumCableElements( (NodesOnlyMesh3)arg1) -> int :

C++ signature :

unsigned int GetNumCableElements(NodesOnlyMesh_less__3__greater__wrapper {lvalue})

GetNumElements((NodesOnlyMesh3)arg1) → int :

C++ signature :

unsigned int GetNumElements(NodesOnlyMesh<3u> {lvalue})

GetNumElements( (NodesOnlyMesh3)arg1) -> int :

C++ signature :

unsigned int GetNumElements(NodesOnlyMesh_less__3__greater__wrapper {lvalue})

GetNumLocalBoundaryElements((NodesOnlyMesh3)arg1) → int :

C++ signature :

unsigned int GetNumLocalBoundaryElements(NodesOnlyMesh<3u> {lvalue})

GetNumLocalBoundaryElements( (NodesOnlyMesh3)arg1) -> int :

C++ signature :

unsigned int GetNumLocalBoundaryElements(NodesOnlyMesh_less__3__greater__wrapper {lvalue})

GetNumLocalElements((NodesOnlyMesh3)arg1) → int :

C++ signature :

unsigned int GetNumLocalElements(NodesOnlyMesh<3u> {lvalue})

GetNumLocalElements( (NodesOnlyMesh3)arg1) -> int :

C++ signature :

unsigned int GetNumLocalElements(NodesOnlyMesh_less__3__greater__wrapper {lvalue})

GetNumNodes((NodesOnlyMesh3)arg1) → int :

C++ signature :

unsigned int GetNumNodes(NodesOnlyMesh<3u> {lvalue})

GetNumNodes( (NodesOnlyMesh3)arg1) -> int :

C++ signature :

unsigned int GetNumNodes(NodesOnlyMesh_less__3__greater__wrapper {lvalue})

GetNumVertices((NodesOnlyMesh3)arg1) → int :

C++ signature :

unsigned int GetNumVertices(NodesOnlyMesh<3u> {lvalue})

GetNumVertices( (NodesOnlyMesh3)arg1) -> int :

C++ signature :

unsigned int GetNumVertices(NodesOnlyMesh_less__3__greater__wrapper {lvalue})

GetVectorFromAtoB((NodesOnlyMesh3)arg1, (object)rLocationA, (object)rLocationB) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetVectorFromAtoB(NodesOnlyMesh<3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,boost::numeric::ublas::c_vector<double, 3ul>)

GetVectorFromAtoB( (NodesOnlyMesh3)arg1, (object)rLocationA, (object)rLocationB) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetVectorFromAtoB(NodesOnlyMesh_less__3__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,boost::numeric::ublas::c_vector<double, 3ul>)

GetWeightedDirectionForBoundaryElement((NodesOnlyMesh3)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) → None :

C++ signature :

void GetWeightedDirectionForBoundaryElement(NodesOnlyMesh<3u> {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 3ul> {lvalue},double {lvalue})

GetWeightedDirectionForBoundaryElement( (NodesOnlyMesh3)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) -> None :

C++ signature :

void GetWeightedDirectionForBoundaryElement(NodesOnlyMesh_less__3__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 3ul> {lvalue},double {lvalue})

GetWeightedDirectionForElement((NodesOnlyMesh3)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) → None :

C++ signature :

void GetWeightedDirectionForElement(NodesOnlyMesh<3u> {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 3ul> {lvalue},double {lvalue})

GetWeightedDirectionForElement( (NodesOnlyMesh3)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) -> None :

C++ signature :

void GetWeightedDirectionForElement(NodesOnlyMesh_less__3__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 3ul> {lvalue},double {lvalue})

GetWidth((NodesOnlyMesh3)arg1, (int)rDimension) → float :

C++ signature :

double GetWidth(NodesOnlyMesh<3u> {lvalue},unsigned int)

GetWidth( (NodesOnlyMesh3)arg1, (int)rDimension) -> float :

C++ signature :

double GetWidth(NodesOnlyMesh_less__3__greater__wrapper {lvalue},unsigned int)

IsOwned((NodesOnlyMesh3)arg1, (object)location) → bool :

C++ signature :

bool IsOwned(NodesOnlyMesh<3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul> {lvalue})

LoadBalanceMesh((NodesOnlyMesh3)arg1) → None :

C++ signature :

void LoadBalanceMesh(NodesOnlyMesh<3u> {lvalue})

PermuteNodes((NodesOnlyMesh3)arg1) → None :

C++ signature :

void PermuteNodes(NodesOnlyMesh<3u> {lvalue})

PermuteNodes( (NodesOnlyMesh3)arg1) -> None :

C++ signature :

void PermuteNodes(NodesOnlyMesh_less__3__greater__wrapper {lvalue})

PermuteNodes( (NodesOnlyMesh3)arg1, (VecUnsigned)perm) -> None :

C++ signature :

void PermuteNodes(NodesOnlyMesh<3u> {lvalue},std::vector<unsigned int, std::allocator<unsigned int> >)

ReMesh((NodesOnlyMesh3)arg1, (object)rMap) → None :

C++ signature :

void ReMesh(NodesOnlyMesh<3u> {lvalue},NodeMap {lvalue})

ReMesh( (NodesOnlyMesh3)arg1, (object)rMap) -> None :

C++ signature :

void ReMesh(NodesOnlyMesh_less__3__greater__wrapper {lvalue},NodeMap {lvalue})

ReadNodesPerProcessorFile((NodesOnlyMesh3)arg1, (str)rNodesPerProcessorFile) → None :

C++ signature :

void ReadNodesPerProcessorFile(NodesOnlyMesh<3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

ReadNodesPerProcessorFile( (NodesOnlyMesh3)arg1, (str)rNodesPerProcessorFile) -> None :

C++ signature :

void ReadNodesPerProcessorFile(NodesOnlyMesh_less__3__greater__wrapper {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

RefreshJacobianCachedData((NodesOnlyMesh3)arg1) → None :

C++ signature :

void RefreshJacobianCachedData(NodesOnlyMesh<3u> {lvalue})

RefreshJacobianCachedData( (NodesOnlyMesh3)arg1) -> None :

C++ signature :

void RefreshJacobianCachedData(NodesOnlyMesh_less__3__greater__wrapper {lvalue})

RefreshMesh((NodesOnlyMesh3)arg1) → None :

C++ signature :

void RefreshMesh(NodesOnlyMesh<3u> {lvalue})

RefreshMesh( (NodesOnlyMesh3)arg1) -> None :

C++ signature :

void RefreshMesh(NodesOnlyMesh_less__3__greater__wrapper {lvalue})

ResizeBoxCollection((NodesOnlyMesh3)arg1) → None :

C++ signature :

void ResizeBoxCollection(NodesOnlyMesh<3u> {lvalue})

Rotate((NodesOnlyMesh3)arg1, (object)rotationMatrix) → None :

C++ signature :

void Rotate(NodesOnlyMesh<3u> {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul>)

Rotate( (NodesOnlyMesh3)arg1, (object)rotationMatrix) -> None :

C++ signature :

void Rotate(NodesOnlyMesh_less__3__greater__wrapper {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul>)

Rotate( (NodesOnlyMesh3)arg1, (object)axis, (float)angle) -> None :

C++ signature :

void Rotate(NodesOnlyMesh<3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,double)

Rotate( (NodesOnlyMesh3)arg1, (float)theta) -> None :

C++ signature :

void Rotate(NodesOnlyMesh<3u> {lvalue},double)

Scale((NodesOnlyMesh3)arg1[, (float)xFactor=1.0[, (float)yFactor=1.0[, (float)zFactor=1.0]]]) → None :

C++ signature :

void Scale(NodesOnlyMesh<3u> {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

Scale( (NodesOnlyMesh3)arg1 [, (float)xFactor=1.0 [, (float)yFactor=1.0 [, (float)zFactor=1.0]]]) -> None :

C++ signature :

void Scale(NodesOnlyMesh_less__3__greater__wrapper {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

SetCalculateNodeNeighbours((NodesOnlyMesh3)arg1, (bool)calculateNodeNeighbours) → None :

C++ signature :

void SetCalculateNodeNeighbours(NodesOnlyMesh<3u> {lvalue},bool)

SetDistributedVectorFactory((NodesOnlyMesh3)arg1, (object)pFactory) → None :

C++ signature :

void SetDistributedVectorFactory(NodesOnlyMesh<3u> {lvalue},DistributedVectorFactory*)

SetDistributedVectorFactory( (NodesOnlyMesh3)arg1, (object)pFactory) -> None :

C++ signature :

void SetDistributedVectorFactory(NodesOnlyMesh_less__3__greater__wrapper {lvalue},DistributedVectorFactory*)

SetElementOwnerships((NodesOnlyMesh3)arg1) → None :

C++ signature :

void SetElementOwnerships(NodesOnlyMesh_less__3__greater__wrapper {lvalue})

SetInitialBoxCollection((NodesOnlyMesh3)arg1, (object)domainSize, (float)maxInteractionDistance) → None :

C++ signature :

void SetInitialBoxCollection(NodesOnlyMesh<3u> {lvalue},boost::numeric::ublas::c_vector<double, 6ul>,double)

SetMaximumInteractionDistance((NodesOnlyMesh3)arg1, (float)maxDistance) → None :

C++ signature :

void SetMaximumInteractionDistance(NodesOnlyMesh<3u> {lvalue},double)

SetMinimumNodeDomainBoundarySeparation((NodesOnlyMesh3)arg1, (float)separation) → None :

C++ signature :

void SetMinimumNodeDomainBoundarySeparation(NodesOnlyMesh<3u> {lvalue},double)

SetNode((NodesOnlyMesh3)arg1, (int)nodeIndex, (ChastePoint3)point[, (bool)concreteMove=False]) → None :

C++ signature :

void SetNode(NodesOnlyMesh<3u> {lvalue},unsigned int,ChastePoint<3u> [,bool=False])

SetNode( (NodesOnlyMesh3)arg1, (int)nodeIndex, (ChastePoint3)point [, (bool)concreteMove=False]) -> None :

C++ signature :

void SetNode(NodesOnlyMesh_less__3__greater__wrapper {lvalue},unsigned int,ChastePoint<3u> [,bool=False])

SetUpBoxCollection((NodesOnlyMesh3)arg1, (float)cutOffLength, (object)domainSize[, (int)numLocalRows=-1[, (bool)isPeriodic=False]]) → None :

C++ signature :

void SetUpBoxCollection(NodesOnlyMesh_less__3__greater__wrapper {lvalue},double,boost::numeric::ublas::c_vector<double, 6ul> [,int=-1 [,bool=False]])

SolveBoundaryElementMapping((NodesOnlyMesh3)arg1, (int)index) → int :

C++ signature :

unsigned int SolveBoundaryElementMapping(NodesOnlyMesh_less__3__greater__wrapper {lvalue},unsigned int)

SolveElementMapping((NodesOnlyMesh3)arg1, (int)index) → int :

C++ signature :

unsigned int SolveElementMapping(NodesOnlyMesh_less__3__greater__wrapper {lvalue},unsigned int)

SolveNodeMapping((NodesOnlyMesh3)arg1, (int)index) → int :

C++ signature :

unsigned int SolveNodeMapping(NodesOnlyMesh<3u> {lvalue},unsigned int)

SolveNodeMapping( (NodesOnlyMesh3)arg1, (int)index) -> int :

C++ signature :

unsigned int SolveNodeMapping(NodesOnlyMesh_less__3__greater__wrapper {lvalue},unsigned int)

Translate((NodesOnlyMesh3)arg1, (object)rDisplacement) → None :

C++ signature :

void Translate(NodesOnlyMesh<3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>)

Translate( (NodesOnlyMesh3)arg1, (object)rDisplacement) -> None :

C++ signature :

void Translate(NodesOnlyMesh_less__3__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 3ul>)

Translate( (NodesOnlyMesh3)arg1 [, (float)xMovement=0.0 [, (float)yMovement=0.0 [, (float)zMovement=0.0]]]) -> None :

C++ signature :

void Translate(NodesOnlyMesh<3u> {lvalue} [,double=0.0 [,double=0.0 [,double=0.0]]])

UpdateBoxCollection((NodesOnlyMesh3)arg1) → None :

C++ signature :

void UpdateBoxCollection(NodesOnlyMesh<3u> {lvalue})

class chaste.mesh.MutableMesh2_2

AddElement((MutableMesh2_2)arg1, (object)pNewElement) → int :

C++ signature :

unsigned int AddElement(MutableMesh<2u, 2u> {lvalue},Element<2u, 2u>*)

AddNode((MutableMesh2_2)arg1, (Node2)pNewNode) → int :

C++ signature :

unsigned int AddNode(MutableMesh<2u, 2u> {lvalue},Node<2u>*)

AddNode( (MutableMesh2_2)arg1, (Node2)pNewNode) -> int :

C++ signature :

unsigned int AddNode(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},Node<2u>*)

CalculateBoundingBox((MutableMesh2_2)arg1, (VecNodePtr2)rNodes) → object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},std::vector<Node<2u>*, std::allocator<Node<2u>*> >)

CalculateBoundingBox( (MutableMesh2_2)arg1) -> object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(MutableMesh<2u, 2u> {lvalue})

CalculateBoundingBox( (MutableMesh2_2)arg1) -> object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(MutableMesh_less__2_comma__2__greater__wrapper {lvalue})

CalculateDesignatedOwnershipOfBoundaryElement((MutableMesh2_2)arg1, (int)faceIndex) → bool :

C++ signature :

bool CalculateDesignatedOwnershipOfBoundaryElement(MutableMesh<2u, 2u> {lvalue},unsigned int)

CalculateDesignatedOwnershipOfBoundaryElement( (MutableMesh2_2)arg1, (int)faceIndex) -> bool :

C++ signature :

bool CalculateDesignatedOwnershipOfBoundaryElement(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

CalculateDesignatedOwnershipOfElement((MutableMesh2_2)arg1, (int)elementIndex) → bool :

C++ signature :

bool CalculateDesignatedOwnershipOfElement(MutableMesh<2u, 2u> {lvalue},unsigned int)

CalculateDesignatedOwnershipOfElement( (MutableMesh2_2)arg1, (int)elementIndex) -> bool :

C++ signature :

bool CalculateDesignatedOwnershipOfElement(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

CalculateMinMaxEdgeLengths((MutableMesh2_2)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> CalculateMinMaxEdgeLengths(MutableMesh<2u, 2u> {lvalue})

CalculateMinMaxEdgeLengths( (MutableMesh2_2)arg1) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> CalculateMinMaxEdgeLengths(MutableMesh_less__2_comma__2__greater__wrapper {lvalue})

CheckIsVoronoi((MutableMesh2_2)arg1[, (float)maxPenetration=0.0]) → bool :

C++ signature :

bool CheckIsVoronoi(MutableMesh<2u, 2u> {lvalue} [,double=0.0])

Clear((MutableMesh2_2)arg1) → None :

C++ signature :

void Clear(MutableMesh<2u, 2u> {lvalue})

Clear( (MutableMesh2_2)arg1) -> None :

C++ signature :

void Clear(MutableMesh_less__2_comma__2__greater__wrapper {lvalue})

ConstructCuboid((MutableMesh2_2)arg1, (int)width, (int)height, (int)depth) → None :

C++ signature :

void ConstructCuboid(MutableMesh<2u, 2u> {lvalue},unsigned int,unsigned int,unsigned int)

ConstructCuboid( (MutableMesh2_2)arg1, (int)width, (int)height, (int)depth) -> None :

C++ signature :

void ConstructCuboid(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int,unsigned int,unsigned int)

ConstructFromMeshReader((MutableMesh2_2)arg1, (object)rMeshReader) → None :

C++ signature :

void ConstructFromMeshReader(MutableMesh<2u, 2u> {lvalue},AbstractMeshReader<2u, 2u> {lvalue})

ConstructFromMeshReader( (MutableMesh2_2)arg1, (object)rMeshReader) -> None :

C++ signature :

void ConstructFromMeshReader(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},AbstractMeshReader<2u, 2u> {lvalue})

ConstructLinearMesh((MutableMesh2_2)arg1, (int)width) → None :

C++ signature :

void ConstructLinearMesh(MutableMesh<2u, 2u> {lvalue},unsigned int)

ConstructLinearMesh( (MutableMesh2_2)arg1, (int)width) -> None :

C++ signature :

void ConstructLinearMesh(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

ConstructRectangularMesh((MutableMesh2_2)arg1, (int)width, (int)height[, (bool)stagger=True]) → None :

C++ signature :

void ConstructRectangularMesh(MutableMesh<2u, 2u> {lvalue},unsigned int,unsigned int [,bool=True])

ConstructRectangularMesh( (MutableMesh2_2)arg1, (int)width, (int)height [, (bool)stagger=True]) -> None :

C++ signature :

void ConstructRectangularMesh(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int,unsigned int [,bool=True])

DeleteBoundaryNodeAt((MutableMesh2_2)arg1, (int)index) → None :

C++ signature :

void DeleteBoundaryNodeAt(MutableMesh<2u, 2u> {lvalue},unsigned int)

DeleteElement((MutableMesh2_2)arg1, (int)index) → None :

C++ signature :

void DeleteElement(MutableMesh<2u, 2u> {lvalue},unsigned int)

DeleteElement( (MutableMesh2_2)arg1, (int)index) -> None :

C++ signature :

void DeleteElement(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

DeleteNode((MutableMesh2_2)arg1, (int)index) → None :

C++ signature :

void DeleteNode(MutableMesh<2u, 2u> {lvalue},unsigned int)

DeleteNode( (MutableMesh2_2)arg1, (int)index) -> None :

C++ signature :

void DeleteNode(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

DeleteNodePriorToReMesh((MutableMesh2_2)arg1, (int)index) → None :

C++ signature :

void DeleteNodePriorToReMesh(MutableMesh<2u, 2u> {lvalue},unsigned int)

GetHaloNodeIndices((MutableMesh2_2)arg1, (VecUnsigned)rHaloIndices) → None :

C++ signature :

void GetHaloNodeIndices(MutableMesh<2u, 2u> {lvalue},std::vector<unsigned int, std::allocator<unsigned int> > {lvalue})

GetHaloNodeIndices( (MutableMesh2_2)arg1, (VecUnsigned)rHaloIndices) -> None :

C++ signature :

void GetHaloNodeIndices(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},std::vector<unsigned int, std::allocator<unsigned int> > {lvalue})

GetInverseJacobianForElement((MutableMesh2_2)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant, (object)rInverseJacobian) → None :

C++ signature :

void GetInverseJacobianForElement(MutableMesh<2u, 2u> {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue},double {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue})

GetInverseJacobianForElement( (MutableMesh2_2)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant, (object)rInverseJacobian) -> None :

C++ signature :

void GetInverseJacobianForElement(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue},double {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue})

GetJacobianForElement((MutableMesh2_2)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant) → None :

C++ signature :

void GetJacobianForElement(MutableMesh<2u, 2u> {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue},double {lvalue})

GetJacobianForElement( (MutableMesh2_2)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant) -> None :

C++ signature :

void GetJacobianForElement(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue},double {lvalue})

GetMaximumNodeIndex((MutableMesh2_2)arg1) → int :

C++ signature :

unsigned int GetMaximumNodeIndex(MutableMesh<2u, 2u> {lvalue})

GetMaximumNodeIndex( (MutableMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetMaximumNodeIndex(MutableMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNearestNodeIndex((MutableMesh2_2)arg1, (ChastePoint2)rTestPoint) → int :

C++ signature :

unsigned int GetNearestNodeIndex(MutableMesh<2u, 2u> {lvalue},ChastePoint<2u>)

GetNearestNodeIndex( (MutableMesh2_2)arg1, (ChastePoint2)rTestPoint) -> int :

C++ signature :

unsigned int GetNearestNodeIndex(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},ChastePoint<2u>)

GetNumAllNodes((MutableMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumAllNodes(MutableMesh<2u, 2u> {lvalue})

GetNumAllNodes( (MutableMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumAllNodes(MutableMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumBoundaryElements((MutableMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumBoundaryElements(MutableMesh<2u, 2u> {lvalue})

GetNumBoundaryElements( (MutableMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumBoundaryElements(MutableMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumCableElements((MutableMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumCableElements(MutableMesh<2u, 2u> {lvalue})

GetNumCableElements( (MutableMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumCableElements(MutableMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumElements((MutableMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumElements(MutableMesh<2u, 2u> {lvalue})

GetNumElements( (MutableMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumElements(MutableMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumLocalBoundaryElements((MutableMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumLocalBoundaryElements(MutableMesh<2u, 2u> {lvalue})

GetNumLocalBoundaryElements( (MutableMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumLocalBoundaryElements(MutableMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumLocalElements((MutableMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumLocalElements(MutableMesh<2u, 2u> {lvalue})

GetNumLocalElements( (MutableMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumLocalElements(MutableMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumNodes((MutableMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumNodes(MutableMesh<2u, 2u> {lvalue})

GetNumNodes( (MutableMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumNodes(MutableMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumVertices((MutableMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumVertices(MutableMesh<2u, 2u> {lvalue})

GetNumVertices( (MutableMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumVertices(MutableMesh_less__2_comma__2__greater__wrapper {lvalue})

GetVectorFromAtoB((MutableMesh2_2)arg1, (object)rLocationA, (object)rLocationB) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetVectorFromAtoB(MutableMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,boost::numeric::ublas::c_vector<double, 2ul>)

GetVectorFromAtoB( (MutableMesh2_2)arg1, (object)rLocationA, (object)rLocationB) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetVectorFromAtoB(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,boost::numeric::ublas::c_vector<double, 2ul>)

GetWeightedDirectionForBoundaryElement((MutableMesh2_2)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) → None :

C++ signature :

void GetWeightedDirectionForBoundaryElement(MutableMesh<2u, 2u> {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 2ul> {lvalue},double {lvalue})

GetWeightedDirectionForBoundaryElement( (MutableMesh2_2)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) -> None :

C++ signature :

void GetWeightedDirectionForBoundaryElement(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 2ul> {lvalue},double {lvalue})

GetWeightedDirectionForElement((MutableMesh2_2)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) → None :

C++ signature :

void GetWeightedDirectionForElement(MutableMesh<2u, 2u> {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 2ul> {lvalue},double {lvalue})

GetWeightedDirectionForElement( (MutableMesh2_2)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) -> None :

C++ signature :

void GetWeightedDirectionForElement(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 2ul> {lvalue},double {lvalue})

GetWidth((MutableMesh2_2)arg1, (int)rDimension) → float :

C++ signature :

double GetWidth(MutableMesh<2u, 2u> {lvalue},unsigned int)

GetWidth( (MutableMesh2_2)arg1, (int)rDimension) -> float :

C++ signature :

double GetWidth(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

MoveMergeNode((MutableMesh2_2)arg1, (int)index, (int)targetIndex[, (bool)concreteMove=True]) → None :

C++ signature :

void MoveMergeNode(MutableMesh<2u, 2u> {lvalue},unsigned int,unsigned int [,bool=True])

PermuteNodes((MutableMesh2_2)arg1) → None :

C++ signature :

void PermuteNodes(MutableMesh<2u, 2u> {lvalue})

PermuteNodes( (MutableMesh2_2)arg1) -> None :

C++ signature :

void PermuteNodes(MutableMesh_less__2_comma__2__greater__wrapper {lvalue})

PermuteNodes( (MutableMesh2_2)arg1, (VecUnsigned)perm) -> None :

C++ signature :

void PermuteNodes(MutableMesh<2u, 2u> {lvalue},std::vector<unsigned int, std::allocator<unsigned int> >)

ReIndex((MutableMesh2_2)arg1, (object)map) → None :

C++ signature :

void ReIndex(MutableMesh<2u, 2u> {lvalue},NodeMap {lvalue})

ReMesh((MutableMesh2_2)arg1, (object)map) → None :

C++ signature :

void ReMesh(MutableMesh<2u, 2u> {lvalue},NodeMap {lvalue})

ReMesh( (MutableMesh2_2)arg1, (object)map) -> None :

C++ signature :

void ReMesh(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},NodeMap {lvalue})

ReMesh( (MutableMesh2_2)arg1) -> None :

C++ signature :

void ReMesh(MutableMesh<2u, 2u> {lvalue})

ReadNodesPerProcessorFile((MutableMesh2_2)arg1, (str)rNodesPerProcessorFile) → None :

C++ signature :

void ReadNodesPerProcessorFile(MutableMesh<2u, 2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

ReadNodesPerProcessorFile( (MutableMesh2_2)arg1, (str)rNodesPerProcessorFile) -> None :

C++ signature :

void ReadNodesPerProcessorFile(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

RefineElement((MutableMesh2_2)arg1, (object)pElement, (ChastePoint2)point) → int :

C++ signature :

unsigned int RefineElement(MutableMesh<2u, 2u> {lvalue},Element<2u, 2u>*,ChastePoint<2u>)

RefreshJacobianCachedData((MutableMesh2_2)arg1) → None :

C++ signature :

void RefreshJacobianCachedData(MutableMesh<2u, 2u> {lvalue})

RefreshJacobianCachedData( (MutableMesh2_2)arg1) -> None :

C++ signature :

void RefreshJacobianCachedData(MutableMesh_less__2_comma__2__greater__wrapper {lvalue})

RefreshMesh((MutableMesh2_2)arg1) → None :

C++ signature :

void RefreshMesh(MutableMesh<2u, 2u> {lvalue})

RefreshMesh( (MutableMesh2_2)arg1) -> None :

C++ signature :

void RefreshMesh(MutableMesh_less__2_comma__2__greater__wrapper {lvalue})

Rotate((MutableMesh2_2)arg1, (object)rotationMatrix) → None :

C++ signature :

void Rotate(MutableMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul>)

Rotate( (MutableMesh2_2)arg1, (object)rotationMatrix) -> None :

C++ signature :

void Rotate(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul>)

Rotate( (MutableMesh2_2)arg1, (object)axis, (float)angle) -> None :

C++ signature :

void Rotate(MutableMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,double)

Rotate( (MutableMesh2_2)arg1, (float)theta) -> None :

C++ signature :

void Rotate(MutableMesh<2u, 2u> {lvalue},double)

Scale((MutableMesh2_2)arg1[, (float)xFactor=1.0[, (float)yFactor=1.0[, (float)zFactor=1.0]]]) → None :

C++ signature :

void Scale(MutableMesh<2u, 2u> {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

Scale( (MutableMesh2_2)arg1 [, (float)xFactor=1.0 [, (float)yFactor=1.0 [, (float)zFactor=1.0]]]) -> None :

C++ signature :

void Scale(MutableMesh_less__2_comma__2__greater__wrapper {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

SetDistributedVectorFactory((MutableMesh2_2)arg1, (object)pFactory) → None :

C++ signature :

void SetDistributedVectorFactory(MutableMesh<2u, 2u> {lvalue},DistributedVectorFactory*)

SetDistributedVectorFactory( (MutableMesh2_2)arg1, (object)pFactory) -> None :

C++ signature :

void SetDistributedVectorFactory(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},DistributedVectorFactory*)

SetElementOwnerships((MutableMesh2_2)arg1) → None :

C++ signature :

void SetElementOwnerships(MutableMesh_less__2_comma__2__greater__wrapper {lvalue})

SetNode((MutableMesh2_2)arg1, (int)index, (ChastePoint2)point[, (bool)concreteMove=True]) → None :

C++ signature :

void SetNode(MutableMesh<2u, 2u> {lvalue},unsigned int,ChastePoint<2u> [,bool=True])

SetNode( (MutableMesh2_2)arg1, (int)index, (ChastePoint2)point [, (bool)concreteMove=True]) -> None :

C++ signature :

void SetNode(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int,ChastePoint<2u> [,bool=True])

SolveBoundaryElementMapping((MutableMesh2_2)arg1, (int)index) → int :

C++ signature :

unsigned int SolveBoundaryElementMapping(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

SolveElementMapping((MutableMesh2_2)arg1, (int)index) → int :

C++ signature :

unsigned int SolveElementMapping(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

SolveNodeMapping((MutableMesh2_2)arg1, (int)index) → int :

C++ signature :

unsigned int SolveNodeMapping(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

SplitEdge((MutableMesh2_2)arg1, (Node2)pNodeA, (Node2)pNodeB) → object :

C++ signature :

boost::numeric::ublas::c_vector<unsigned int, 3ul> SplitEdge(MutableMesh<2u, 2u> {lvalue},Node<2u>*,Node<2u>*)

Translate((MutableMesh2_2)arg1, (object)rDisplacement) → None :

C++ signature :

void Translate(MutableMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_vector<double, 2ul>)

Translate( (MutableMesh2_2)arg1, (object)rDisplacement) -> None :

C++ signature :

void Translate(MutableMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>)

Translate( (MutableMesh2_2)arg1 [, (float)xMovement=0.0 [, (float)yMovement=0.0 [, (float)zMovement=0.0]]]) -> None :

C++ signature :

void Translate(MutableMesh<2u, 2u> {lvalue} [,double=0.0 [,double=0.0 [,double=0.0]]])

class chaste.mesh.MutableMesh3_3

AddElement((MutableMesh3_3)arg1, (object)pNewElement) → int :

C++ signature :

unsigned int AddElement(MutableMesh<3u, 3u> {lvalue},Element<3u, 3u>*)

AddNode((MutableMesh3_3)arg1, (Node3)pNewNode) → int :

C++ signature :

unsigned int AddNode(MutableMesh<3u, 3u> {lvalue},Node<3u>*)

AddNode( (MutableMesh3_3)arg1, (Node3)pNewNode) -> int :

C++ signature :

unsigned int AddNode(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},Node<3u>*)

CalculateBoundingBox((MutableMesh3_3)arg1, (VecNodePtr3)rNodes) → object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},std::vector<Node<3u>*, std::allocator<Node<3u>*> >)

CalculateBoundingBox( (MutableMesh3_3)arg1) -> object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(MutableMesh<3u, 3u> {lvalue})

CalculateBoundingBox( (MutableMesh3_3)arg1) -> object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(MutableMesh_less__3_comma__3__greater__wrapper {lvalue})

CalculateDesignatedOwnershipOfBoundaryElement((MutableMesh3_3)arg1, (int)faceIndex) → bool :

C++ signature :

bool CalculateDesignatedOwnershipOfBoundaryElement(MutableMesh<3u, 3u> {lvalue},unsigned int)

CalculateDesignatedOwnershipOfBoundaryElement( (MutableMesh3_3)arg1, (int)faceIndex) -> bool :

C++ signature :

bool CalculateDesignatedOwnershipOfBoundaryElement(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

CalculateDesignatedOwnershipOfElement((MutableMesh3_3)arg1, (int)elementIndex) → bool :

C++ signature :

bool CalculateDesignatedOwnershipOfElement(MutableMesh<3u, 3u> {lvalue},unsigned int)

CalculateDesignatedOwnershipOfElement( (MutableMesh3_3)arg1, (int)elementIndex) -> bool :

C++ signature :

bool CalculateDesignatedOwnershipOfElement(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

CalculateMinMaxEdgeLengths((MutableMesh3_3)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> CalculateMinMaxEdgeLengths(MutableMesh<3u, 3u> {lvalue})

CalculateMinMaxEdgeLengths( (MutableMesh3_3)arg1) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> CalculateMinMaxEdgeLengths(MutableMesh_less__3_comma__3__greater__wrapper {lvalue})

CheckIsVoronoi((MutableMesh3_3)arg1[, (float)maxPenetration=0.0]) → bool :

C++ signature :

bool CheckIsVoronoi(MutableMesh<3u, 3u> {lvalue} [,double=0.0])

Clear((MutableMesh3_3)arg1) → None :

C++ signature :

void Clear(MutableMesh<3u, 3u> {lvalue})

Clear( (MutableMesh3_3)arg1) -> None :

C++ signature :

void Clear(MutableMesh_less__3_comma__3__greater__wrapper {lvalue})

ConstructCuboid((MutableMesh3_3)arg1, (int)width, (int)height, (int)depth) → None :

C++ signature :

void ConstructCuboid(MutableMesh<3u, 3u> {lvalue},unsigned int,unsigned int,unsigned int)

ConstructCuboid( (MutableMesh3_3)arg1, (int)width, (int)height, (int)depth) -> None :

C++ signature :

void ConstructCuboid(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int,unsigned int,unsigned int)

ConstructFromMeshReader((MutableMesh3_3)arg1, (object)rMeshReader) → None :

C++ signature :

void ConstructFromMeshReader(MutableMesh<3u, 3u> {lvalue},AbstractMeshReader<3u, 3u> {lvalue})

ConstructFromMeshReader( (MutableMesh3_3)arg1, (object)rMeshReader) -> None :

C++ signature :

void ConstructFromMeshReader(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},AbstractMeshReader<3u, 3u> {lvalue})

ConstructLinearMesh((MutableMesh3_3)arg1, (int)width) → None :

C++ signature :

void ConstructLinearMesh(MutableMesh<3u, 3u> {lvalue},unsigned int)

ConstructLinearMesh( (MutableMesh3_3)arg1, (int)width) -> None :

C++ signature :

void ConstructLinearMesh(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

ConstructRectangularMesh((MutableMesh3_3)arg1, (int)width, (int)height[, (bool)stagger=True]) → None :

C++ signature :

void ConstructRectangularMesh(MutableMesh<3u, 3u> {lvalue},unsigned int,unsigned int [,bool=True])

ConstructRectangularMesh( (MutableMesh3_3)arg1, (int)width, (int)height [, (bool)stagger=True]) -> None :

C++ signature :

void ConstructRectangularMesh(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int,unsigned int [,bool=True])

DeleteBoundaryNodeAt((MutableMesh3_3)arg1, (int)index) → None :

C++ signature :

void DeleteBoundaryNodeAt(MutableMesh<3u, 3u> {lvalue},unsigned int)

DeleteElement((MutableMesh3_3)arg1, (int)index) → None :

C++ signature :

void DeleteElement(MutableMesh<3u, 3u> {lvalue},unsigned int)

DeleteElement( (MutableMesh3_3)arg1, (int)index) -> None :

C++ signature :

void DeleteElement(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

DeleteNode((MutableMesh3_3)arg1, (int)index) → None :

C++ signature :

void DeleteNode(MutableMesh<3u, 3u> {lvalue},unsigned int)

DeleteNode( (MutableMesh3_3)arg1, (int)index) -> None :

C++ signature :

void DeleteNode(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

DeleteNodePriorToReMesh((MutableMesh3_3)arg1, (int)index) → None :

C++ signature :

void DeleteNodePriorToReMesh(MutableMesh<3u, 3u> {lvalue},unsigned int)

GetHaloNodeIndices((MutableMesh3_3)arg1, (VecUnsigned)rHaloIndices) → None :

C++ signature :

void GetHaloNodeIndices(MutableMesh<3u, 3u> {lvalue},std::vector<unsigned int, std::allocator<unsigned int> > {lvalue})

GetHaloNodeIndices( (MutableMesh3_3)arg1, (VecUnsigned)rHaloIndices) -> None :

C++ signature :

void GetHaloNodeIndices(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},std::vector<unsigned int, std::allocator<unsigned int> > {lvalue})

GetInverseJacobianForElement((MutableMesh3_3)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant, (object)rInverseJacobian) → None :

C++ signature :

void GetInverseJacobianForElement(MutableMesh<3u, 3u> {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue},double {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue})

GetInverseJacobianForElement( (MutableMesh3_3)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant, (object)rInverseJacobian) -> None :

C++ signature :

void GetInverseJacobianForElement(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue},double {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue})

GetJacobianForElement((MutableMesh3_3)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant) → None :

C++ signature :

void GetJacobianForElement(MutableMesh<3u, 3u> {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue},double {lvalue})

GetJacobianForElement( (MutableMesh3_3)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant) -> None :

C++ signature :

void GetJacobianForElement(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue},double {lvalue})

GetMaximumNodeIndex((MutableMesh3_3)arg1) → int :

C++ signature :

unsigned int GetMaximumNodeIndex(MutableMesh<3u, 3u> {lvalue})

GetMaximumNodeIndex( (MutableMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetMaximumNodeIndex(MutableMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNearestNodeIndex((MutableMesh3_3)arg1, (ChastePoint3)rTestPoint) → int :

C++ signature :

unsigned int GetNearestNodeIndex(MutableMesh<3u, 3u> {lvalue},ChastePoint<3u>)

GetNearestNodeIndex( (MutableMesh3_3)arg1, (ChastePoint3)rTestPoint) -> int :

C++ signature :

unsigned int GetNearestNodeIndex(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},ChastePoint<3u>)

GetNumAllNodes((MutableMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumAllNodes(MutableMesh<3u, 3u> {lvalue})

GetNumAllNodes( (MutableMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumAllNodes(MutableMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumBoundaryElements((MutableMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumBoundaryElements(MutableMesh<3u, 3u> {lvalue})

GetNumBoundaryElements( (MutableMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumBoundaryElements(MutableMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumCableElements((MutableMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumCableElements(MutableMesh<3u, 3u> {lvalue})

GetNumCableElements( (MutableMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumCableElements(MutableMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumElements((MutableMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumElements(MutableMesh<3u, 3u> {lvalue})

GetNumElements( (MutableMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumElements(MutableMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumLocalBoundaryElements((MutableMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumLocalBoundaryElements(MutableMesh<3u, 3u> {lvalue})

GetNumLocalBoundaryElements( (MutableMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumLocalBoundaryElements(MutableMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumLocalElements((MutableMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumLocalElements(MutableMesh<3u, 3u> {lvalue})

GetNumLocalElements( (MutableMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumLocalElements(MutableMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumNodes((MutableMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumNodes(MutableMesh<3u, 3u> {lvalue})

GetNumNodes( (MutableMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumNodes(MutableMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumVertices((MutableMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumVertices(MutableMesh<3u, 3u> {lvalue})

GetNumVertices( (MutableMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumVertices(MutableMesh_less__3_comma__3__greater__wrapper {lvalue})

GetVectorFromAtoB((MutableMesh3_3)arg1, (object)rLocationA, (object)rLocationB) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetVectorFromAtoB(MutableMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,boost::numeric::ublas::c_vector<double, 3ul>)

GetVectorFromAtoB( (MutableMesh3_3)arg1, (object)rLocationA, (object)rLocationB) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetVectorFromAtoB(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,boost::numeric::ublas::c_vector<double, 3ul>)

GetWeightedDirectionForBoundaryElement((MutableMesh3_3)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) → None :

C++ signature :

void GetWeightedDirectionForBoundaryElement(MutableMesh<3u, 3u> {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 3ul> {lvalue},double {lvalue})

GetWeightedDirectionForBoundaryElement( (MutableMesh3_3)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) -> None :

C++ signature :

void GetWeightedDirectionForBoundaryElement(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 3ul> {lvalue},double {lvalue})

GetWeightedDirectionForElement((MutableMesh3_3)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) → None :

C++ signature :

void GetWeightedDirectionForElement(MutableMesh<3u, 3u> {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 3ul> {lvalue},double {lvalue})

GetWeightedDirectionForElement( (MutableMesh3_3)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) -> None :

C++ signature :

void GetWeightedDirectionForElement(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 3ul> {lvalue},double {lvalue})

GetWidth((MutableMesh3_3)arg1, (int)rDimension) → float :

C++ signature :

double GetWidth(MutableMesh<3u, 3u> {lvalue},unsigned int)

GetWidth( (MutableMesh3_3)arg1, (int)rDimension) -> float :

C++ signature :

double GetWidth(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

MoveMergeNode((MutableMesh3_3)arg1, (int)index, (int)targetIndex[, (bool)concreteMove=True]) → None :

C++ signature :

void MoveMergeNode(MutableMesh<3u, 3u> {lvalue},unsigned int,unsigned int [,bool=True])

PermuteNodes((MutableMesh3_3)arg1) → None :

C++ signature :

void PermuteNodes(MutableMesh<3u, 3u> {lvalue})

PermuteNodes( (MutableMesh3_3)arg1) -> None :

C++ signature :

void PermuteNodes(MutableMesh_less__3_comma__3__greater__wrapper {lvalue})

PermuteNodes( (MutableMesh3_3)arg1, (VecUnsigned)perm) -> None :

C++ signature :

void PermuteNodes(MutableMesh<3u, 3u> {lvalue},std::vector<unsigned int, std::allocator<unsigned int> >)

ReIndex((MutableMesh3_3)arg1, (object)map) → None :

C++ signature :

void ReIndex(MutableMesh<3u, 3u> {lvalue},NodeMap {lvalue})

ReMesh((MutableMesh3_3)arg1, (object)map) → None :

C++ signature :

void ReMesh(MutableMesh<3u, 3u> {lvalue},NodeMap {lvalue})

ReMesh( (MutableMesh3_3)arg1, (object)map) -> None :

C++ signature :

void ReMesh(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},NodeMap {lvalue})

ReMesh( (MutableMesh3_3)arg1) -> None :

C++ signature :

void ReMesh(MutableMesh<3u, 3u> {lvalue})

ReadNodesPerProcessorFile((MutableMesh3_3)arg1, (str)rNodesPerProcessorFile) → None :

C++ signature :

void ReadNodesPerProcessorFile(MutableMesh<3u, 3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

ReadNodesPerProcessorFile( (MutableMesh3_3)arg1, (str)rNodesPerProcessorFile) -> None :

C++ signature :

void ReadNodesPerProcessorFile(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

RefineElement((MutableMesh3_3)arg1, (object)pElement, (ChastePoint3)point) → int :

C++ signature :

unsigned int RefineElement(MutableMesh<3u, 3u> {lvalue},Element<3u, 3u>*,ChastePoint<3u>)

RefreshJacobianCachedData((MutableMesh3_3)arg1) → None :

C++ signature :

void RefreshJacobianCachedData(MutableMesh<3u, 3u> {lvalue})

RefreshJacobianCachedData( (MutableMesh3_3)arg1) -> None :

C++ signature :

void RefreshJacobianCachedData(MutableMesh_less__3_comma__3__greater__wrapper {lvalue})

RefreshMesh((MutableMesh3_3)arg1) → None :

C++ signature :

void RefreshMesh(MutableMesh<3u, 3u> {lvalue})

RefreshMesh( (MutableMesh3_3)arg1) -> None :

C++ signature :

void RefreshMesh(MutableMesh_less__3_comma__3__greater__wrapper {lvalue})

Rotate((MutableMesh3_3)arg1, (object)rotationMatrix) → None :

C++ signature :

void Rotate(MutableMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul>)

Rotate( (MutableMesh3_3)arg1, (object)rotationMatrix) -> None :

C++ signature :

void Rotate(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul>)

Rotate( (MutableMesh3_3)arg1, (object)axis, (float)angle) -> None :

C++ signature :

void Rotate(MutableMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,double)

Rotate( (MutableMesh3_3)arg1, (float)theta) -> None :

C++ signature :

void Rotate(MutableMesh<3u, 3u> {lvalue},double)

Scale((MutableMesh3_3)arg1[, (float)xFactor=1.0[, (float)yFactor=1.0[, (float)zFactor=1.0]]]) → None :

C++ signature :

void Scale(MutableMesh<3u, 3u> {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

Scale( (MutableMesh3_3)arg1 [, (float)xFactor=1.0 [, (float)yFactor=1.0 [, (float)zFactor=1.0]]]) -> None :

C++ signature :

void Scale(MutableMesh_less__3_comma__3__greater__wrapper {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

SetDistributedVectorFactory((MutableMesh3_3)arg1, (object)pFactory) → None :

C++ signature :

void SetDistributedVectorFactory(MutableMesh<3u, 3u> {lvalue},DistributedVectorFactory*)

SetDistributedVectorFactory( (MutableMesh3_3)arg1, (object)pFactory) -> None :

C++ signature :

void SetDistributedVectorFactory(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},DistributedVectorFactory*)

SetElementOwnerships((MutableMesh3_3)arg1) → None :

C++ signature :

void SetElementOwnerships(MutableMesh_less__3_comma__3__greater__wrapper {lvalue})

SetNode((MutableMesh3_3)arg1, (int)index, (ChastePoint3)point[, (bool)concreteMove=True]) → None :

C++ signature :

void SetNode(MutableMesh<3u, 3u> {lvalue},unsigned int,ChastePoint<3u> [,bool=True])

SetNode( (MutableMesh3_3)arg1, (int)index, (ChastePoint3)point [, (bool)concreteMove=True]) -> None :

C++ signature :

void SetNode(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int,ChastePoint<3u> [,bool=True])

SolveBoundaryElementMapping((MutableMesh3_3)arg1, (int)index) → int :

C++ signature :

unsigned int SolveBoundaryElementMapping(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

SolveElementMapping((MutableMesh3_3)arg1, (int)index) → int :

C++ signature :

unsigned int SolveElementMapping(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

SolveNodeMapping((MutableMesh3_3)arg1, (int)index) → int :

C++ signature :

unsigned int SolveNodeMapping(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

SplitEdge((MutableMesh3_3)arg1, (Node3)pNodeA, (Node3)pNodeB) → object :

C++ signature :

boost::numeric::ublas::c_vector<unsigned int, 3ul> SplitEdge(MutableMesh<3u, 3u> {lvalue},Node<3u>*,Node<3u>*)

Translate((MutableMesh3_3)arg1, (object)rDisplacement) → None :

C++ signature :

void Translate(MutableMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>)

Translate( (MutableMesh3_3)arg1, (object)rDisplacement) -> None :

C++ signature :

void Translate(MutableMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 3ul>)

Translate( (MutableMesh3_3)arg1 [, (float)xMovement=0.0 [, (float)yMovement=0.0 [, (float)zMovement=0.0]]]) -> None :

C++ signature :

void Translate(MutableMesh<3u, 3u> {lvalue} [,double=0.0 [,double=0.0 [,double=0.0]]])

class chaste.mesh.TetrahedralMesh2_2

CalculateBoundingBox((TetrahedralMesh2_2)arg1, (VecNodePtr2)rNodes) → object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},std::vector<Node<2u>*, std::allocator<Node<2u>*> >)

CalculateBoundingBox( (TetrahedralMesh2_2)arg1) -> object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(TetrahedralMesh<2u, 2u> {lvalue})

CalculateBoundingBox( (TetrahedralMesh2_2)arg1) -> object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

CalculateDesignatedOwnershipOfBoundaryElement((TetrahedralMesh2_2)arg1, (int)faceIndex) → bool :

C++ signature :

bool CalculateDesignatedOwnershipOfBoundaryElement(TetrahedralMesh<2u, 2u> {lvalue},unsigned int)

CalculateDesignatedOwnershipOfBoundaryElement( (TetrahedralMesh2_2)arg1, (int)faceIndex) -> bool :

C++ signature :

bool CalculateDesignatedOwnershipOfBoundaryElement(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

CalculateDesignatedOwnershipOfElement((TetrahedralMesh2_2)arg1, (int)elementIndex) → bool :

C++ signature :

bool CalculateDesignatedOwnershipOfElement(TetrahedralMesh<2u, 2u> {lvalue},unsigned int)

CalculateDesignatedOwnershipOfElement( (TetrahedralMesh2_2)arg1, (int)elementIndex) -> bool :

C++ signature :

bool CalculateDesignatedOwnershipOfElement(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

CalculateMinMaxEdgeLengths((TetrahedralMesh2_2)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> CalculateMinMaxEdgeLengths(TetrahedralMesh<2u, 2u> {lvalue})

CalculateMinMaxEdgeLengths( (TetrahedralMesh2_2)arg1) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> CalculateMinMaxEdgeLengths(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

CheckIsConforming((TetrahedralMesh2_2)arg1) → bool :

C++ signature :

bool CheckIsConforming(TetrahedralMesh<2u, 2u> {lvalue})

Clear((TetrahedralMesh2_2)arg1) → None :

C++ signature :

void Clear(TetrahedralMesh<2u, 2u> {lvalue})

Clear( (TetrahedralMesh2_2)arg1) -> None :

C++ signature :

void Clear(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

ConstructCuboid((TetrahedralMesh2_2)arg1, (int)width, (int)height, (int)depth) → None :

C++ signature :

void ConstructCuboid(TetrahedralMesh<2u, 2u> {lvalue},unsigned int,unsigned int,unsigned int)

ConstructCuboid( (TetrahedralMesh2_2)arg1, (int)width, (int)height, (int)depth) -> None :

C++ signature :

void ConstructCuboid(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int,unsigned int,unsigned int)

ConstructFromMeshReader((TetrahedralMesh2_2)arg1, (object)rMeshReader) → None :

C++ signature :

void ConstructFromMeshReader(TetrahedralMesh<2u, 2u> {lvalue},AbstractMeshReader<2u, 2u> {lvalue})

ConstructFromMeshReader( (TetrahedralMesh2_2)arg1, (object)rMeshReader) -> None :

C++ signature :

void ConstructFromMeshReader(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},AbstractMeshReader<2u, 2u> {lvalue})

ConstructLinearMesh((TetrahedralMesh2_2)arg1, (int)width) → None :

C++ signature :

void ConstructLinearMesh(TetrahedralMesh<2u, 2u> {lvalue},unsigned int)

ConstructLinearMesh( (TetrahedralMesh2_2)arg1, (int)width) -> None :

C++ signature :

void ConstructLinearMesh(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

ConstructRectangularMesh((TetrahedralMesh2_2)arg1, (int)width, (int)height[, (bool)stagger=True]) → None :

C++ signature :

void ConstructRectangularMesh(TetrahedralMesh<2u, 2u> {lvalue},unsigned int,unsigned int [,bool=True])

ConstructRectangularMesh( (TetrahedralMesh2_2)arg1, (int)width, (int)height [, (bool)stagger=True]) -> None :

C++ signature :

void ConstructRectangularMesh(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int,unsigned int [,bool=True])

EdgesBegin((TetrahedralMesh2_2)arg1) → object :

C++ signature :

TetrahedralMesh<2u, 2u>::EdgeIterator EdgesBegin(TetrahedralMesh<2u, 2u> {lvalue})

EdgesEnd((TetrahedralMesh2_2)arg1) → object :

C++ signature :

TetrahedralMesh<2u, 2u>::EdgeIterator EdgesEnd(TetrahedralMesh<2u, 2u> {lvalue})

GetAngleBetweenNodes((TetrahedralMesh2_2)arg1, (int)indexA, (int)indexB) → float :

C++ signature :

double GetAngleBetweenNodes(TetrahedralMesh<2u, 2u> {lvalue},unsigned int,unsigned int)

GetContainingElementIndexWithInitialGuess((TetrahedralMesh2_2)arg1, (ChastePoint2)rTestPoint, (int)startingElementGuess[, (bool)strict=False]) → int :

C++ signature :

unsigned int GetContainingElementIndexWithInitialGuess(TetrahedralMesh<2u, 2u> {lvalue},ChastePoint<2u>,unsigned int [,bool=False])

GetContainingElementIndices((TetrahedralMesh2_2)arg1, (ChastePoint2)rTestPoint) → VecUnsigned :

C++ signature :

std::vector<unsigned int, std::allocator<unsigned int> > GetContainingElementIndices(TetrahedralMesh<2u, 2u> {lvalue},ChastePoint<2u>)

GetHaloNodeIndices((TetrahedralMesh2_2)arg1, (VecUnsigned)rHaloIndices) → None :

C++ signature :

void GetHaloNodeIndices(TetrahedralMesh<2u, 2u> {lvalue},std::vector<unsigned int, std::allocator<unsigned int> > {lvalue})

GetHaloNodeIndices( (TetrahedralMesh2_2)arg1, (VecUnsigned)rHaloIndices) -> None :

C++ signature :

void GetHaloNodeIndices(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},std::vector<unsigned int, std::allocator<unsigned int> > {lvalue})

GetInverseJacobianForElement((TetrahedralMesh2_2)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant, (object)rInverseJacobian) → None :

C++ signature :

void GetInverseJacobianForElement(TetrahedralMesh<2u, 2u> {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue},double {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue})

GetInverseJacobianForElement( (TetrahedralMesh2_2)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant, (object)rInverseJacobian) -> None :

C++ signature :

void GetInverseJacobianForElement(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue},double {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue})

GetJacobianForElement((TetrahedralMesh2_2)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant) → None :

C++ signature :

void GetJacobianForElement(TetrahedralMesh<2u, 2u> {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue},double {lvalue})

GetJacobianForElement( (TetrahedralMesh2_2)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant) -> None :

C++ signature :

void GetJacobianForElement(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue},double {lvalue})

GetMaximumNodeIndex((TetrahedralMesh2_2)arg1) → int :

C++ signature :

unsigned int GetMaximumNodeIndex(TetrahedralMesh<2u, 2u> {lvalue})

GetMaximumNodeIndex( (TetrahedralMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetMaximumNodeIndex(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNearestElementIndex((TetrahedralMesh2_2)arg1, (ChastePoint2)rTestPoint) → int :

C++ signature :

unsigned int GetNearestElementIndex(TetrahedralMesh<2u, 2u> {lvalue},ChastePoint<2u>)

GetNearestNodeIndex((TetrahedralMesh2_2)arg1, (ChastePoint2)rTestPoint) → int :

C++ signature :

unsigned int GetNearestNodeIndex(TetrahedralMesh<2u, 2u> {lvalue},ChastePoint<2u>)

GetNearestNodeIndex( (TetrahedralMesh2_2)arg1, (ChastePoint2)rTestPoint) -> int :

C++ signature :

unsigned int GetNearestNodeIndex(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},ChastePoint<2u>)

GetNumAllNodes((TetrahedralMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumAllNodes(TetrahedralMesh<2u, 2u> {lvalue})

GetNumAllNodes( (TetrahedralMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumAllNodes(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumBoundaryElements((TetrahedralMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumBoundaryElements(TetrahedralMesh<2u, 2u> {lvalue})

GetNumBoundaryElements( (TetrahedralMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumBoundaryElements(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumCableElements((TetrahedralMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumCableElements(TetrahedralMesh<2u, 2u> {lvalue})

GetNumCableElements( (TetrahedralMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumCableElements(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumElements((TetrahedralMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumElements(TetrahedralMesh<2u, 2u> {lvalue})

GetNumElements( (TetrahedralMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumElements(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumLocalBoundaryElements((TetrahedralMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumLocalBoundaryElements(TetrahedralMesh<2u, 2u> {lvalue})

GetNumLocalBoundaryElements( (TetrahedralMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumLocalBoundaryElements(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumLocalElements((TetrahedralMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumLocalElements(TetrahedralMesh<2u, 2u> {lvalue})

GetNumLocalElements( (TetrahedralMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumLocalElements(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumNodes((TetrahedralMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumNodes(TetrahedralMesh<2u, 2u> {lvalue})

GetNumNodes( (TetrahedralMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumNodes(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumVertices((TetrahedralMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumVertices(TetrahedralMesh<2u, 2u> {lvalue})

GetNumVertices( (TetrahedralMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumVertices(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

GetSurfaceArea((TetrahedralMesh2_2)arg1) → float :

C++ signature :

double GetSurfaceArea(TetrahedralMesh<2u, 2u> {lvalue})

GetVectorFromAtoB((TetrahedralMesh2_2)arg1, (object)rLocationA, (object)rLocationB) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetVectorFromAtoB(TetrahedralMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,boost::numeric::ublas::c_vector<double, 2ul>)

GetVectorFromAtoB( (TetrahedralMesh2_2)arg1, (object)rLocationA, (object)rLocationB) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetVectorFromAtoB(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,boost::numeric::ublas::c_vector<double, 2ul>)

GetVolume((TetrahedralMesh2_2)arg1) → float :

C++ signature :

double GetVolume(TetrahedralMesh<2u, 2u> {lvalue})

GetWeightedDirectionForBoundaryElement((TetrahedralMesh2_2)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) → None :

C++ signature :

void GetWeightedDirectionForBoundaryElement(TetrahedralMesh<2u, 2u> {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 2ul> {lvalue},double {lvalue})

GetWeightedDirectionForBoundaryElement( (TetrahedralMesh2_2)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) -> None :

C++ signature :

void GetWeightedDirectionForBoundaryElement(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 2ul> {lvalue},double {lvalue})

GetWeightedDirectionForElement((TetrahedralMesh2_2)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) → None :

C++ signature :

void GetWeightedDirectionForElement(TetrahedralMesh<2u, 2u> {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 2ul> {lvalue},double {lvalue})

GetWeightedDirectionForElement( (TetrahedralMesh2_2)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) -> None :

C++ signature :

void GetWeightedDirectionForElement(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 2ul> {lvalue},double {lvalue})

GetWidth((TetrahedralMesh2_2)arg1, (int)rDimension) → float :

C++ signature :

double GetWidth(TetrahedralMesh<2u, 2u> {lvalue},unsigned int)

GetWidth( (TetrahedralMesh2_2)arg1, (int)rDimension) -> float :

C++ signature :

double GetWidth(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

PermuteNodes((TetrahedralMesh2_2)arg1) → None :

C++ signature :

void PermuteNodes(TetrahedralMesh<2u, 2u> {lvalue})

PermuteNodes( (TetrahedralMesh2_2)arg1) -> None :

C++ signature :

void PermuteNodes(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

PermuteNodes( (TetrahedralMesh2_2)arg1, (VecUnsigned)perm) -> None :

C++ signature :

void PermuteNodes(TetrahedralMesh<2u, 2u> {lvalue},std::vector<unsigned int, std::allocator<unsigned int> >)

ReadNodesPerProcessorFile((TetrahedralMesh2_2)arg1, (str)rNodesPerProcessorFile) → None :

C++ signature :

void ReadNodesPerProcessorFile(TetrahedralMesh<2u, 2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

ReadNodesPerProcessorFile( (TetrahedralMesh2_2)arg1, (str)rNodesPerProcessorFile) -> None :

C++ signature :

void ReadNodesPerProcessorFile(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

RefreshJacobianCachedData((TetrahedralMesh2_2)arg1) → None :

C++ signature :

void RefreshJacobianCachedData(TetrahedralMesh<2u, 2u> {lvalue})

RefreshJacobianCachedData( (TetrahedralMesh2_2)arg1) -> None :

C++ signature :

void RefreshJacobianCachedData(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

RefreshMesh((TetrahedralMesh2_2)arg1) → None :

C++ signature :

void RefreshMesh(TetrahedralMesh<2u, 2u> {lvalue})

RefreshMesh( (TetrahedralMesh2_2)arg1) -> None :

C++ signature :

void RefreshMesh(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

Rotate((TetrahedralMesh2_2)arg1, (object)rotationMatrix) → None :

C++ signature :

void Rotate(TetrahedralMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul>)

Rotate( (TetrahedralMesh2_2)arg1, (object)rotationMatrix) -> None :

C++ signature :

void Rotate(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul>)

Rotate( (TetrahedralMesh2_2)arg1, (object)axis, (float)angle) -> None :

C++ signature :

void Rotate(TetrahedralMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,double)

Rotate( (TetrahedralMesh2_2)arg1, (float)theta) -> None :

C++ signature :

void Rotate(TetrahedralMesh<2u, 2u> {lvalue},double)

Scale((TetrahedralMesh2_2)arg1[, (float)xFactor=1.0[, (float)yFactor=1.0[, (float)zFactor=1.0]]]) → None :

C++ signature :

void Scale(TetrahedralMesh<2u, 2u> {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

Scale( (TetrahedralMesh2_2)arg1 [, (float)xFactor=1.0 [, (float)yFactor=1.0 [, (float)zFactor=1.0]]]) -> None :

C++ signature :

void Scale(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

SetDistributedVectorFactory((TetrahedralMesh2_2)arg1, (object)pFactory) → None :

C++ signature :

void SetDistributedVectorFactory(TetrahedralMesh<2u, 2u> {lvalue},DistributedVectorFactory*)

SetDistributedVectorFactory( (TetrahedralMesh2_2)arg1, (object)pFactory) -> None :

C++ signature :

void SetDistributedVectorFactory(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},DistributedVectorFactory*)

SetElementOwnerships((TetrahedralMesh2_2)arg1) → None :

C++ signature :

void SetElementOwnerships(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

SolveBoundaryElementMapping((TetrahedralMesh2_2)arg1, (int)index) → int :

C++ signature :

unsigned int SolveBoundaryElementMapping(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

SolveElementMapping((TetrahedralMesh2_2)arg1, (int)index) → int :

C++ signature :

unsigned int SolveElementMapping(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

SolveNodeMapping((TetrahedralMesh2_2)arg1, (int)index) → int :

C++ signature :

unsigned int SolveNodeMapping(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

Translate((TetrahedralMesh2_2)arg1, (object)rDisplacement) → None :

C++ signature :

void Translate(TetrahedralMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_vector<double, 2ul>)

Translate( (TetrahedralMesh2_2)arg1, (object)rDisplacement) -> None :

C++ signature :

void Translate(TetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>)

Translate( (TetrahedralMesh2_2)arg1 [, (float)xMovement=0.0 [, (float)yMovement=0.0 [, (float)zMovement=0.0]]]) -> None :

C++ signature :

void Translate(TetrahedralMesh<2u, 2u> {lvalue} [,double=0.0 [,double=0.0 [,double=0.0]]])

class chaste.mesh.TetrahedralMesh3_3

CalculateBoundingBox((TetrahedralMesh3_3)arg1, (VecNodePtr3)rNodes) → object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},std::vector<Node<3u>*, std::allocator<Node<3u>*> >)

CalculateBoundingBox( (TetrahedralMesh3_3)arg1) -> object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(TetrahedralMesh<3u, 3u> {lvalue})

CalculateBoundingBox( (TetrahedralMesh3_3)arg1) -> object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

CalculateDesignatedOwnershipOfBoundaryElement((TetrahedralMesh3_3)arg1, (int)faceIndex) → bool :

C++ signature :

bool CalculateDesignatedOwnershipOfBoundaryElement(TetrahedralMesh<3u, 3u> {lvalue},unsigned int)

CalculateDesignatedOwnershipOfBoundaryElement( (TetrahedralMesh3_3)arg1, (int)faceIndex) -> bool :

C++ signature :

bool CalculateDesignatedOwnershipOfBoundaryElement(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

CalculateDesignatedOwnershipOfElement((TetrahedralMesh3_3)arg1, (int)elementIndex) → bool :

C++ signature :

bool CalculateDesignatedOwnershipOfElement(TetrahedralMesh<3u, 3u> {lvalue},unsigned int)

CalculateDesignatedOwnershipOfElement( (TetrahedralMesh3_3)arg1, (int)elementIndex) -> bool :

C++ signature :

bool CalculateDesignatedOwnershipOfElement(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

CalculateMinMaxEdgeLengths((TetrahedralMesh3_3)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> CalculateMinMaxEdgeLengths(TetrahedralMesh<3u, 3u> {lvalue})

CalculateMinMaxEdgeLengths( (TetrahedralMesh3_3)arg1) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> CalculateMinMaxEdgeLengths(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

CheckIsConforming((TetrahedralMesh3_3)arg1) → bool :

C++ signature :

bool CheckIsConforming(TetrahedralMesh<3u, 3u> {lvalue})

Clear((TetrahedralMesh3_3)arg1) → None :

C++ signature :

void Clear(TetrahedralMesh<3u, 3u> {lvalue})

Clear( (TetrahedralMesh3_3)arg1) -> None :

C++ signature :

void Clear(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

ConstructCuboid((TetrahedralMesh3_3)arg1, (int)width, (int)height, (int)depth) → None :

C++ signature :

void ConstructCuboid(TetrahedralMesh<3u, 3u> {lvalue},unsigned int,unsigned int,unsigned int)

ConstructCuboid( (TetrahedralMesh3_3)arg1, (int)width, (int)height, (int)depth) -> None :

C++ signature :

void ConstructCuboid(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int,unsigned int,unsigned int)

ConstructFromMeshReader((TetrahedralMesh3_3)arg1, (object)rMeshReader) → None :

C++ signature :

void ConstructFromMeshReader(TetrahedralMesh<3u, 3u> {lvalue},AbstractMeshReader<3u, 3u> {lvalue})

ConstructFromMeshReader( (TetrahedralMesh3_3)arg1, (object)rMeshReader) -> None :

C++ signature :

void ConstructFromMeshReader(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},AbstractMeshReader<3u, 3u> {lvalue})

ConstructLinearMesh((TetrahedralMesh3_3)arg1, (int)width) → None :

C++ signature :

void ConstructLinearMesh(TetrahedralMesh<3u, 3u> {lvalue},unsigned int)

ConstructLinearMesh( (TetrahedralMesh3_3)arg1, (int)width) -> None :

C++ signature :

void ConstructLinearMesh(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

ConstructRectangularMesh((TetrahedralMesh3_3)arg1, (int)width, (int)height[, (bool)stagger=True]) → None :

C++ signature :

void ConstructRectangularMesh(TetrahedralMesh<3u, 3u> {lvalue},unsigned int,unsigned int [,bool=True])

ConstructRectangularMesh( (TetrahedralMesh3_3)arg1, (int)width, (int)height [, (bool)stagger=True]) -> None :

C++ signature :

void ConstructRectangularMesh(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int,unsigned int [,bool=True])

EdgesBegin((TetrahedralMesh3_3)arg1) → object :

C++ signature :

TetrahedralMesh<3u, 3u>::EdgeIterator EdgesBegin(TetrahedralMesh<3u, 3u> {lvalue})

EdgesEnd((TetrahedralMesh3_3)arg1) → object :

C++ signature :

TetrahedralMesh<3u, 3u>::EdgeIterator EdgesEnd(TetrahedralMesh<3u, 3u> {lvalue})

GetAngleBetweenNodes((TetrahedralMesh3_3)arg1, (int)indexA, (int)indexB) → float :

C++ signature :

double GetAngleBetweenNodes(TetrahedralMesh<3u, 3u> {lvalue},unsigned int,unsigned int)

GetContainingElementIndexWithInitialGuess((TetrahedralMesh3_3)arg1, (ChastePoint3)rTestPoint, (int)startingElementGuess[, (bool)strict=False]) → int :

C++ signature :

unsigned int GetContainingElementIndexWithInitialGuess(TetrahedralMesh<3u, 3u> {lvalue},ChastePoint<3u>,unsigned int [,bool=False])

GetContainingElementIndices((TetrahedralMesh3_3)arg1, (ChastePoint3)rTestPoint) → VecUnsigned :

C++ signature :

std::vector<unsigned int, std::allocator<unsigned int> > GetContainingElementIndices(TetrahedralMesh<3u, 3u> {lvalue},ChastePoint<3u>)

GetHaloNodeIndices((TetrahedralMesh3_3)arg1, (VecUnsigned)rHaloIndices) → None :

C++ signature :

void GetHaloNodeIndices(TetrahedralMesh<3u, 3u> {lvalue},std::vector<unsigned int, std::allocator<unsigned int> > {lvalue})

GetHaloNodeIndices( (TetrahedralMesh3_3)arg1, (VecUnsigned)rHaloIndices) -> None :

C++ signature :

void GetHaloNodeIndices(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},std::vector<unsigned int, std::allocator<unsigned int> > {lvalue})

GetInverseJacobianForElement((TetrahedralMesh3_3)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant, (object)rInverseJacobian) → None :

C++ signature :

void GetInverseJacobianForElement(TetrahedralMesh<3u, 3u> {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue},double {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue})

GetInverseJacobianForElement( (TetrahedralMesh3_3)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant, (object)rInverseJacobian) -> None :

C++ signature :

void GetInverseJacobianForElement(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue},double {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue})

GetJacobianForElement((TetrahedralMesh3_3)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant) → None :

C++ signature :

void GetJacobianForElement(TetrahedralMesh<3u, 3u> {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue},double {lvalue})

GetJacobianForElement( (TetrahedralMesh3_3)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant) -> None :

C++ signature :

void GetJacobianForElement(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue},double {lvalue})

GetMaximumNodeIndex((TetrahedralMesh3_3)arg1) → int :

C++ signature :

unsigned int GetMaximumNodeIndex(TetrahedralMesh<3u, 3u> {lvalue})

GetMaximumNodeIndex( (TetrahedralMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetMaximumNodeIndex(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNearestElementIndex((TetrahedralMesh3_3)arg1, (ChastePoint3)rTestPoint) → int :

C++ signature :

unsigned int GetNearestElementIndex(TetrahedralMesh<3u, 3u> {lvalue},ChastePoint<3u>)

GetNearestNodeIndex((TetrahedralMesh3_3)arg1, (ChastePoint3)rTestPoint) → int :

C++ signature :

unsigned int GetNearestNodeIndex(TetrahedralMesh<3u, 3u> {lvalue},ChastePoint<3u>)

GetNearestNodeIndex( (TetrahedralMesh3_3)arg1, (ChastePoint3)rTestPoint) -> int :

C++ signature :

unsigned int GetNearestNodeIndex(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},ChastePoint<3u>)

GetNumAllNodes((TetrahedralMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumAllNodes(TetrahedralMesh<3u, 3u> {lvalue})

GetNumAllNodes( (TetrahedralMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumAllNodes(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumBoundaryElements((TetrahedralMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumBoundaryElements(TetrahedralMesh<3u, 3u> {lvalue})

GetNumBoundaryElements( (TetrahedralMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumBoundaryElements(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumCableElements((TetrahedralMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumCableElements(TetrahedralMesh<3u, 3u> {lvalue})

GetNumCableElements( (TetrahedralMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumCableElements(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumElements((TetrahedralMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumElements(TetrahedralMesh<3u, 3u> {lvalue})

GetNumElements( (TetrahedralMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumElements(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumLocalBoundaryElements((TetrahedralMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumLocalBoundaryElements(TetrahedralMesh<3u, 3u> {lvalue})

GetNumLocalBoundaryElements( (TetrahedralMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumLocalBoundaryElements(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumLocalElements((TetrahedralMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumLocalElements(TetrahedralMesh<3u, 3u> {lvalue})

GetNumLocalElements( (TetrahedralMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumLocalElements(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumNodes((TetrahedralMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumNodes(TetrahedralMesh<3u, 3u> {lvalue})

GetNumNodes( (TetrahedralMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumNodes(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumVertices((TetrahedralMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumVertices(TetrahedralMesh<3u, 3u> {lvalue})

GetNumVertices( (TetrahedralMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumVertices(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

GetSurfaceArea((TetrahedralMesh3_3)arg1) → float :

C++ signature :

double GetSurfaceArea(TetrahedralMesh<3u, 3u> {lvalue})

GetVectorFromAtoB((TetrahedralMesh3_3)arg1, (object)rLocationA, (object)rLocationB) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetVectorFromAtoB(TetrahedralMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,boost::numeric::ublas::c_vector<double, 3ul>)

GetVectorFromAtoB( (TetrahedralMesh3_3)arg1, (object)rLocationA, (object)rLocationB) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetVectorFromAtoB(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,boost::numeric::ublas::c_vector<double, 3ul>)

GetVolume((TetrahedralMesh3_3)arg1) → float :

C++ signature :

double GetVolume(TetrahedralMesh<3u, 3u> {lvalue})

GetWeightedDirectionForBoundaryElement((TetrahedralMesh3_3)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) → None :

C++ signature :

void GetWeightedDirectionForBoundaryElement(TetrahedralMesh<3u, 3u> {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 3ul> {lvalue},double {lvalue})

GetWeightedDirectionForBoundaryElement( (TetrahedralMesh3_3)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) -> None :

C++ signature :

void GetWeightedDirectionForBoundaryElement(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 3ul> {lvalue},double {lvalue})

GetWeightedDirectionForElement((TetrahedralMesh3_3)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) → None :

C++ signature :

void GetWeightedDirectionForElement(TetrahedralMesh<3u, 3u> {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 3ul> {lvalue},double {lvalue})

GetWeightedDirectionForElement( (TetrahedralMesh3_3)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) -> None :

C++ signature :

void GetWeightedDirectionForElement(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 3ul> {lvalue},double {lvalue})

GetWidth((TetrahedralMesh3_3)arg1, (int)rDimension) → float :

C++ signature :

double GetWidth(TetrahedralMesh<3u, 3u> {lvalue},unsigned int)

GetWidth( (TetrahedralMesh3_3)arg1, (int)rDimension) -> float :

C++ signature :

double GetWidth(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

PermuteNodes((TetrahedralMesh3_3)arg1) → None :

C++ signature :

void PermuteNodes(TetrahedralMesh<3u, 3u> {lvalue})

PermuteNodes( (TetrahedralMesh3_3)arg1) -> None :

C++ signature :

void PermuteNodes(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

PermuteNodes( (TetrahedralMesh3_3)arg1, (VecUnsigned)perm) -> None :

C++ signature :

void PermuteNodes(TetrahedralMesh<3u, 3u> {lvalue},std::vector<unsigned int, std::allocator<unsigned int> >)

ReadNodesPerProcessorFile((TetrahedralMesh3_3)arg1, (str)rNodesPerProcessorFile) → None :

C++ signature :

void ReadNodesPerProcessorFile(TetrahedralMesh<3u, 3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

ReadNodesPerProcessorFile( (TetrahedralMesh3_3)arg1, (str)rNodesPerProcessorFile) -> None :

C++ signature :

void ReadNodesPerProcessorFile(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

RefreshJacobianCachedData((TetrahedralMesh3_3)arg1) → None :

C++ signature :

void RefreshJacobianCachedData(TetrahedralMesh<3u, 3u> {lvalue})

RefreshJacobianCachedData( (TetrahedralMesh3_3)arg1) -> None :

C++ signature :

void RefreshJacobianCachedData(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

RefreshMesh((TetrahedralMesh3_3)arg1) → None :

C++ signature :

void RefreshMesh(TetrahedralMesh<3u, 3u> {lvalue})

RefreshMesh( (TetrahedralMesh3_3)arg1) -> None :

C++ signature :

void RefreshMesh(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

Rotate((TetrahedralMesh3_3)arg1, (object)rotationMatrix) → None :

C++ signature :

void Rotate(TetrahedralMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul>)

Rotate( (TetrahedralMesh3_3)arg1, (object)rotationMatrix) -> None :

C++ signature :

void Rotate(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul>)

Rotate( (TetrahedralMesh3_3)arg1, (object)axis, (float)angle) -> None :

C++ signature :

void Rotate(TetrahedralMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,double)

Rotate( (TetrahedralMesh3_3)arg1, (float)theta) -> None :

C++ signature :

void Rotate(TetrahedralMesh<3u, 3u> {lvalue},double)

Scale((TetrahedralMesh3_3)arg1[, (float)xFactor=1.0[, (float)yFactor=1.0[, (float)zFactor=1.0]]]) → None :

C++ signature :

void Scale(TetrahedralMesh<3u, 3u> {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

Scale( (TetrahedralMesh3_3)arg1 [, (float)xFactor=1.0 [, (float)yFactor=1.0 [, (float)zFactor=1.0]]]) -> None :

C++ signature :

void Scale(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

SetDistributedVectorFactory((TetrahedralMesh3_3)arg1, (object)pFactory) → None :

C++ signature :

void SetDistributedVectorFactory(TetrahedralMesh<3u, 3u> {lvalue},DistributedVectorFactory*)

SetDistributedVectorFactory( (TetrahedralMesh3_3)arg1, (object)pFactory) -> None :

C++ signature :

void SetDistributedVectorFactory(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},DistributedVectorFactory*)

SetElementOwnerships((TetrahedralMesh3_3)arg1) → None :

C++ signature :

void SetElementOwnerships(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

SolveBoundaryElementMapping((TetrahedralMesh3_3)arg1, (int)index) → int :

C++ signature :

unsigned int SolveBoundaryElementMapping(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

SolveElementMapping((TetrahedralMesh3_3)arg1, (int)index) → int :

C++ signature :

unsigned int SolveElementMapping(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

SolveNodeMapping((TetrahedralMesh3_3)arg1, (int)index) → int :

C++ signature :

unsigned int SolveNodeMapping(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

Translate((TetrahedralMesh3_3)arg1, (object)rDisplacement) → None :

C++ signature :

void Translate(TetrahedralMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>)

Translate( (TetrahedralMesh3_3)arg1, (object)rDisplacement) -> None :

C++ signature :

void Translate(TetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 3ul>)

Translate( (TetrahedralMesh3_3)arg1 [, (float)xMovement=0.0 [, (float)yMovement=0.0 [, (float)zMovement=0.0]]]) -> None :

C++ signature :

void Translate(TetrahedralMesh<3u, 3u> {lvalue} [,double=0.0 [,double=0.0 [,double=0.0]]])

class chaste.mesh.AbstractTetrahedralMesh2_2

CalculateBoundingBox((AbstractTetrahedralMesh2_2)arg1, (VecNodePtr2)rNodes) → object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},std::vector<Node<2u>*, std::allocator<Node<2u>*> >)

CalculateBoundingBox( (AbstractTetrahedralMesh2_2)arg1) -> object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(AbstractTetrahedralMesh<2u, 2u> {lvalue})

CalculateBoundingBox( (AbstractTetrahedralMesh2_2)arg1) -> object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

CalculateDesignatedOwnershipOfBoundaryElement((AbstractTetrahedralMesh2_2)arg1, (int)faceIndex) → bool :

C++ signature :

bool CalculateDesignatedOwnershipOfBoundaryElement(AbstractTetrahedralMesh<2u, 2u> {lvalue},unsigned int)

CalculateDesignatedOwnershipOfBoundaryElement( (AbstractTetrahedralMesh2_2)arg1, (int)faceIndex) -> bool :

C++ signature :

bool CalculateDesignatedOwnershipOfBoundaryElement(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

CalculateDesignatedOwnershipOfElement((AbstractTetrahedralMesh2_2)arg1, (int)elementIndex) → bool :

C++ signature :

bool CalculateDesignatedOwnershipOfElement(AbstractTetrahedralMesh<2u, 2u> {lvalue},unsigned int)

CalculateDesignatedOwnershipOfElement( (AbstractTetrahedralMesh2_2)arg1, (int)elementIndex) -> bool :

C++ signature :

bool CalculateDesignatedOwnershipOfElement(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

CalculateMaximumNodeConnectivityPerProcess((AbstractTetrahedralMesh2_2)arg1) → int :

C++ signature :

unsigned int CalculateMaximumNodeConnectivityPerProcess(AbstractTetrahedralMesh<2u, 2u> {lvalue})

CalculateMinMaxEdgeLengths((AbstractTetrahedralMesh2_2)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> CalculateMinMaxEdgeLengths(AbstractTetrahedralMesh<2u, 2u> {lvalue})

CalculateMinMaxEdgeLengths( (AbstractTetrahedralMesh2_2)arg1) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> CalculateMinMaxEdgeLengths(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

CalculateNodeExchange((AbstractTetrahedralMesh2_2)arg1, (VecVecInt)rNodesToSendPerProcess, (VecVecInt)rNodesToReceivePerProcess) → None :

C++ signature :

void CalculateNodeExchange(AbstractTetrahedralMesh<2u, 2u> {lvalue},std::vector<std::vector<unsigned int, std::allocator<unsigned int> >, std::allocator<std::vector<unsigned int, std::allocator<unsigned int> > > > {lvalue},std::vector<std::vector<unsigned int, std::allocator<unsigned int> >, std::allocator<std::vector<unsigned int, std::allocator<unsigned int> > > > {lvalue})

CheckOutwardNormals((AbstractTetrahedralMesh2_2)arg1) → None :

C++ signature :

void CheckOutwardNormals(AbstractTetrahedralMesh<2u, 2u> {lvalue})

ConstructCuboid((AbstractTetrahedralMesh2_2)arg1, (int)width, (int)height, (int)depth) → None :

C++ signature :

void ConstructCuboid(AbstractTetrahedralMesh<2u, 2u> {lvalue},unsigned int,unsigned int,unsigned int)

ConstructCuboid( (AbstractTetrahedralMesh2_2)arg1, (int)width, (int)height, (int)depth) -> None :

C++ signature :

void ConstructCuboid(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int,unsigned int,unsigned int)

ConstructFromMesh((AbstractTetrahedralMesh2_2)arg1, (AbstractTetrahedralMesh2_2)rOtherMesh) → None :

C++ signature :

void ConstructFromMesh(AbstractTetrahedralMesh<2u, 2u> {lvalue},AbstractTetrahedralMesh<2u, 2u> {lvalue})

ConstructFromMeshReader((AbstractTetrahedralMesh2_2)arg1, (object)rMeshReader) → None :

C++ signature :

void ConstructFromMeshReader(AbstractTetrahedralMesh<2u, 2u> {lvalue},AbstractMeshReader<2u, 2u> {lvalue})

ConstructFromMeshReader( (AbstractTetrahedralMesh2_2)arg1, (object)arg2) -> None :

C++ signature :

void ConstructFromMeshReader(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},AbstractMeshReader<2u, 2u> {lvalue})

ConstructLinearMesh((AbstractTetrahedralMesh2_2)arg1, (int)width) → None :

C++ signature :

void ConstructLinearMesh(AbstractTetrahedralMesh<2u, 2u> {lvalue},unsigned int)

ConstructLinearMesh( (AbstractTetrahedralMesh2_2)arg1, (int)width) -> None :

C++ signature :

void ConstructLinearMesh(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

ConstructRectangularMesh((AbstractTetrahedralMesh2_2)arg1, (int)width, (int)height[, (bool)stagger=True]) → None :

C++ signature :

void ConstructRectangularMesh(AbstractTetrahedralMesh<2u, 2u> {lvalue},unsigned int,unsigned int [,bool=True])

ConstructRectangularMesh( (AbstractTetrahedralMesh2_2)arg1, (int)width, (int)height [, (bool)stagger=True]) -> None :

C++ signature :

void ConstructRectangularMesh(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int,unsigned int [,bool=True])

ConstructRegularSlabMesh((AbstractTetrahedralMesh2_2)arg1, (float)spaceStep, (float)width[, (float)height=0[, (float)depth=0]]) → None :

C++ signature :

void ConstructRegularSlabMesh(AbstractTetrahedralMesh<2u, 2u> {lvalue},double,double [,double=0 [,double=0]])

ConstructRegularSlabMeshWithDimensionSplit((AbstractTetrahedralMesh2_2)arg1, (int)dimension, (float)spaceStep, (float)width[, (float)height=0[, (float)depth=0]]) → None :

C++ signature :

void ConstructRegularSlabMeshWithDimensionSplit(AbstractTetrahedralMesh<2u, 2u> {lvalue},unsigned int,double,double [,double=0 [,double=0]])

GetBoundaryElementIteratorBegin((AbstractTetrahedralMesh2_2)arg1) → object :

C++ signature :

__gnu_cxx::__normal_iterator<BoundaryElement<1u, 2u>* const*, std::vector<BoundaryElement<1u, 2u>*, std::allocator<BoundaryElement<1u, 2u>*> > > GetBoundaryElementIteratorBegin(AbstractTetrahedralMesh<2u, 2u> {lvalue})

GetBoundaryElementIteratorEnd((AbstractTetrahedralMesh2_2)arg1) → object :

C++ signature :

__gnu_cxx::__normal_iterator<BoundaryElement<1u, 2u>* const*, std::vector<BoundaryElement<1u, 2u>*, std::allocator<BoundaryElement<1u, 2u>*> > > GetBoundaryElementIteratorEnd(AbstractTetrahedralMesh<2u, 2u> {lvalue})

GetContainingElementIndex((AbstractTetrahedralMesh2_2)arg1, (ChastePoint2)rTestPoint[, (bool)strict=False[, (SetUnsigned)testElements=<chaste.mesh._chaste_project_PyChaste_mesh.SetUnsigned object at 0x7f0a6c6de050>[, (bool)onlyTryWithTestElements=False]]]) → int :

C++ signature :

unsigned int GetContainingElementIndex(AbstractTetrahedralMesh<2u, 2u> {lvalue},ChastePoint<2u> [,bool=False [,std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> >=<chaste.mesh._chaste_project_PyChaste_mesh.SetUnsigned object at 0x7f0a6c6de050> [,bool=False]]])

GetElement((AbstractTetrahedralMesh2_2)arg1, (int)index) → object :

C++ signature :

Element<2u, 2u>* GetElement(AbstractTetrahedralMesh<2u, 2u> {lvalue},unsigned int)

GetElementIteratorBegin((AbstractTetrahedralMesh2_2)arg1[, (bool)skipDeletedElements=True]) → object :

C++ signature :

AbstractTetrahedralMesh<2u, 2u>::ElementIterator GetElementIteratorBegin(AbstractTetrahedralMesh<2u, 2u> {lvalue} [,bool=True])

GetElementIteratorEnd((AbstractTetrahedralMesh2_2)arg1) → object :

C++ signature :

AbstractTetrahedralMesh<2u, 2u>::ElementIterator GetElementIteratorEnd(AbstractTetrahedralMesh<2u, 2u> {lvalue})

GetHaloNodeIndices((AbstractTetrahedralMesh2_2)arg1, (VecUnsigned)rHaloIndices) → None :

C++ signature :

void GetHaloNodeIndices(AbstractTetrahedralMesh<2u, 2u> {lvalue},std::vector<unsigned int, std::allocator<unsigned int> > {lvalue})

GetHaloNodeIndices( (AbstractTetrahedralMesh2_2)arg1, (VecUnsigned)rHaloIndices) -> None :

C++ signature :

void GetHaloNodeIndices(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},std::vector<unsigned int, std::allocator<unsigned int> > {lvalue})

GetInverseJacobianForElement((AbstractTetrahedralMesh2_2)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant, (object)rInverseJacobian) → None :

C++ signature :

void GetInverseJacobianForElement(AbstractTetrahedralMesh<2u, 2u> {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue},double {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue})

GetInverseJacobianForElement( (AbstractTetrahedralMesh2_2)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant, (object)rInverseJacobian) -> None :

C++ signature :

void GetInverseJacobianForElement(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue},double {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul> {lvalue})

GetMaximumNodeIndex((AbstractTetrahedralMesh2_2)arg1) → int :

C++ signature :

unsigned int GetMaximumNodeIndex(AbstractTetrahedralMesh<2u, 2u> {lvalue})

GetMaximumNodeIndex( (AbstractTetrahedralMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetMaximumNodeIndex(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNearestElementIndexFromTestElements((AbstractTetrahedralMesh2_2)arg1, (ChastePoint2)rTestPoint, (SetUnsigned)testElements) → int :

C++ signature :

unsigned int GetNearestElementIndexFromTestElements(AbstractTetrahedralMesh<2u, 2u> {lvalue},ChastePoint<2u>,std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> >)

GetNearestNodeIndex((AbstractTetrahedralMesh2_2)arg1, (ChastePoint2)rTestPoint) → int :

C++ signature :

unsigned int GetNearestNodeIndex(AbstractTetrahedralMesh<2u, 2u> {lvalue},ChastePoint<2u>)

GetNearestNodeIndex( (AbstractTetrahedralMesh2_2)arg1, (ChastePoint2)rTestPoint) -> int :

C++ signature :

unsigned int GetNearestNodeIndex(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},ChastePoint<2u>)

GetNumAllBoundaryElements((AbstractTetrahedralMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumAllBoundaryElements(AbstractTetrahedralMesh<2u, 2u> {lvalue})

GetNumAllElements((AbstractTetrahedralMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumAllElements(AbstractTetrahedralMesh<2u, 2u> {lvalue})

GetNumAllNodes((AbstractTetrahedralMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumAllNodes(AbstractTetrahedralMesh<2u, 2u> {lvalue})

GetNumAllNodes( (AbstractTetrahedralMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumAllNodes(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumBoundaryElements((AbstractTetrahedralMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumBoundaryElements(AbstractTetrahedralMesh<2u, 2u> {lvalue})

GetNumBoundaryElements( (AbstractTetrahedralMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumBoundaryElements(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumCableElements((AbstractTetrahedralMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumCableElements(AbstractTetrahedralMesh<2u, 2u> {lvalue})

GetNumCableElements( (AbstractTetrahedralMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumCableElements(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumElements((AbstractTetrahedralMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumElements(AbstractTetrahedralMesh<2u, 2u> {lvalue})

GetNumElements( (AbstractTetrahedralMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumElements(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumLocalBoundaryElements((AbstractTetrahedralMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumLocalBoundaryElements(AbstractTetrahedralMesh<2u, 2u> {lvalue})

GetNumLocalBoundaryElements( (AbstractTetrahedralMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumLocalBoundaryElements(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumLocalElements((AbstractTetrahedralMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumLocalElements(AbstractTetrahedralMesh<2u, 2u> {lvalue})

GetNumLocalElements( (AbstractTetrahedralMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumLocalElements(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumNodes((AbstractTetrahedralMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumNodes(AbstractTetrahedralMesh<2u, 2u> {lvalue})

GetNumNodes( (AbstractTetrahedralMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumNodes(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumVertices((AbstractTetrahedralMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumVertices(AbstractTetrahedralMesh<2u, 2u> {lvalue})

GetNumVertices( (AbstractTetrahedralMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumVertices(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

GetVectorFromAtoB((AbstractTetrahedralMesh2_2)arg1, (object)rLocationA, (object)rLocationB) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetVectorFromAtoB(AbstractTetrahedralMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,boost::numeric::ublas::c_vector<double, 2ul>)

GetVectorFromAtoB( (AbstractTetrahedralMesh2_2)arg1, (object)rLocationA, (object)rLocationB) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetVectorFromAtoB(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,boost::numeric::ublas::c_vector<double, 2ul>)

GetWeightedDirectionForBoundaryElement((AbstractTetrahedralMesh2_2)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) → None :

C++ signature :

void GetWeightedDirectionForBoundaryElement(AbstractTetrahedralMesh<2u, 2u> {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 2ul> {lvalue},double {lvalue})

GetWeightedDirectionForBoundaryElement( (AbstractTetrahedralMesh2_2)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) -> None :

C++ signature :

void GetWeightedDirectionForBoundaryElement(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 2ul> {lvalue},double {lvalue})

GetWidth((AbstractTetrahedralMesh2_2)arg1, (int)rDimension) → float :

C++ signature :

double GetWidth(AbstractTetrahedralMesh<2u, 2u> {lvalue},unsigned int)

GetWidth( (AbstractTetrahedralMesh2_2)arg1, (int)rDimension) -> float :

C++ signature :

double GetWidth(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

PermuteNodes((AbstractTetrahedralMesh2_2)arg1) → None :

C++ signature :

void PermuteNodes(AbstractTetrahedralMesh<2u, 2u> {lvalue})

PermuteNodes( (AbstractTetrahedralMesh2_2)arg1) -> None :

C++ signature :

void PermuteNodes(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

ReadNodesPerProcessorFile((AbstractTetrahedralMesh2_2)arg1, (str)rNodesPerProcessorFile) → None :

C++ signature :

void ReadNodesPerProcessorFile(AbstractTetrahedralMesh<2u, 2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

ReadNodesPerProcessorFile( (AbstractTetrahedralMesh2_2)arg1, (str)rNodesPerProcessorFile) -> None :

C++ signature :

void ReadNodesPerProcessorFile(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

RefreshMesh((AbstractTetrahedralMesh2_2)arg1) → None :

C++ signature :

void RefreshMesh(AbstractTetrahedralMesh<2u, 2u> {lvalue})

RefreshMesh( (AbstractTetrahedralMesh2_2)arg1) -> None :

C++ signature :

void RefreshMesh(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

Rotate((AbstractTetrahedralMesh2_2)arg1, (object)rotationMatrix) → None :

C++ signature :

void Rotate(AbstractTetrahedralMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul>)

Rotate( (AbstractTetrahedralMesh2_2)arg1, (object)rotationMatrix) -> None :

C++ signature :

void Rotate(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul>)

Rotate( (AbstractTetrahedralMesh2_2)arg1, (object)axis, (float)angle) -> None :

C++ signature :

void Rotate(AbstractTetrahedralMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,double)

Rotate( (AbstractTetrahedralMesh2_2)arg1, (float)theta) -> None :

C++ signature :

void Rotate(AbstractTetrahedralMesh<2u, 2u> {lvalue},double)

Scale((AbstractTetrahedralMesh2_2)arg1[, (float)xFactor=1.0[, (float)yFactor=1.0[, (float)zFactor=1.0]]]) → None :

C++ signature :

void Scale(AbstractTetrahedralMesh<2u, 2u> {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

Scale( (AbstractTetrahedralMesh2_2)arg1 [, (float)xFactor=1.0 [, (float)yFactor=1.0 [, (float)zFactor=1.0]]]) -> None :

C++ signature :

void Scale(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

SetDistributedVectorFactory((AbstractTetrahedralMesh2_2)arg1, (object)pFactory) → None :

C++ signature :

void SetDistributedVectorFactory(AbstractTetrahedralMesh<2u, 2u> {lvalue},DistributedVectorFactory*)

SetDistributedVectorFactory( (AbstractTetrahedralMesh2_2)arg1, (object)pFactory) -> None :

C++ signature :

void SetDistributedVectorFactory(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},DistributedVectorFactory*)

SetElementOwnerships((AbstractTetrahedralMesh2_2)arg1) → None :

C++ signature :

void SetElementOwnerships(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue})

Translate((AbstractTetrahedralMesh2_2)arg1, (object)rDisplacement) → None :

C++ signature :

void Translate(AbstractTetrahedralMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_vector<double, 2ul>)

Translate( (AbstractTetrahedralMesh2_2)arg1, (object)rDisplacement) -> None :

C++ signature :

void Translate(AbstractTetrahedralMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>)

Translate( (AbstractTetrahedralMesh2_2)arg1 [, (float)xMovement=0.0 [, (float)yMovement=0.0 [, (float)zMovement=0.0]]]) -> None :

C++ signature :

void Translate(AbstractTetrahedralMesh<2u, 2u> {lvalue} [,double=0.0 [,double=0.0 [,double=0.0]]])

class chaste.mesh.AbstractTetrahedralMesh3_3

CalculateBoundingBox((AbstractTetrahedralMesh3_3)arg1, (VecNodePtr3)rNodes) → object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},std::vector<Node<3u>*, std::allocator<Node<3u>*> >)

CalculateBoundingBox( (AbstractTetrahedralMesh3_3)arg1) -> object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(AbstractTetrahedralMesh<3u, 3u> {lvalue})

CalculateBoundingBox( (AbstractTetrahedralMesh3_3)arg1) -> object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

CalculateDesignatedOwnershipOfBoundaryElement((AbstractTetrahedralMesh3_3)arg1, (int)faceIndex) → bool :

C++ signature :

bool CalculateDesignatedOwnershipOfBoundaryElement(AbstractTetrahedralMesh<3u, 3u> {lvalue},unsigned int)

CalculateDesignatedOwnershipOfBoundaryElement( (AbstractTetrahedralMesh3_3)arg1, (int)faceIndex) -> bool :

C++ signature :

bool CalculateDesignatedOwnershipOfBoundaryElement(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

CalculateDesignatedOwnershipOfElement((AbstractTetrahedralMesh3_3)arg1, (int)elementIndex) → bool :

C++ signature :

bool CalculateDesignatedOwnershipOfElement(AbstractTetrahedralMesh<3u, 3u> {lvalue},unsigned int)

CalculateDesignatedOwnershipOfElement( (AbstractTetrahedralMesh3_3)arg1, (int)elementIndex) -> bool :

C++ signature :

bool CalculateDesignatedOwnershipOfElement(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

CalculateMaximumNodeConnectivityPerProcess((AbstractTetrahedralMesh3_3)arg1) → int :

C++ signature :

unsigned int CalculateMaximumNodeConnectivityPerProcess(AbstractTetrahedralMesh<3u, 3u> {lvalue})

CalculateMinMaxEdgeLengths((AbstractTetrahedralMesh3_3)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> CalculateMinMaxEdgeLengths(AbstractTetrahedralMesh<3u, 3u> {lvalue})

CalculateMinMaxEdgeLengths( (AbstractTetrahedralMesh3_3)arg1) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> CalculateMinMaxEdgeLengths(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

CalculateNodeExchange((AbstractTetrahedralMesh3_3)arg1, (VecVecInt)rNodesToSendPerProcess, (VecVecInt)rNodesToReceivePerProcess) → None :

C++ signature :

void CalculateNodeExchange(AbstractTetrahedralMesh<3u, 3u> {lvalue},std::vector<std::vector<unsigned int, std::allocator<unsigned int> >, std::allocator<std::vector<unsigned int, std::allocator<unsigned int> > > > {lvalue},std::vector<std::vector<unsigned int, std::allocator<unsigned int> >, std::allocator<std::vector<unsigned int, std::allocator<unsigned int> > > > {lvalue})

CheckOutwardNormals((AbstractTetrahedralMesh3_3)arg1) → None :

C++ signature :

void CheckOutwardNormals(AbstractTetrahedralMesh<3u, 3u> {lvalue})

ConstructCuboid((AbstractTetrahedralMesh3_3)arg1, (int)width, (int)height, (int)depth) → None :

C++ signature :

void ConstructCuboid(AbstractTetrahedralMesh<3u, 3u> {lvalue},unsigned int,unsigned int,unsigned int)

ConstructCuboid( (AbstractTetrahedralMesh3_3)arg1, (int)width, (int)height, (int)depth) -> None :

C++ signature :

void ConstructCuboid(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int,unsigned int,unsigned int)

ConstructFromMesh((AbstractTetrahedralMesh3_3)arg1, (AbstractTetrahedralMesh3_3)rOtherMesh) → None :

C++ signature :

void ConstructFromMesh(AbstractTetrahedralMesh<3u, 3u> {lvalue},AbstractTetrahedralMesh<3u, 3u> {lvalue})

ConstructFromMeshReader((AbstractTetrahedralMesh3_3)arg1, (object)rMeshReader) → None :

C++ signature :

void ConstructFromMeshReader(AbstractTetrahedralMesh<3u, 3u> {lvalue},AbstractMeshReader<3u, 3u> {lvalue})

ConstructFromMeshReader( (AbstractTetrahedralMesh3_3)arg1, (object)arg2) -> None :

C++ signature :

void ConstructFromMeshReader(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},AbstractMeshReader<3u, 3u> {lvalue})

ConstructLinearMesh((AbstractTetrahedralMesh3_3)arg1, (int)width) → None :

C++ signature :

void ConstructLinearMesh(AbstractTetrahedralMesh<3u, 3u> {lvalue},unsigned int)

ConstructLinearMesh( (AbstractTetrahedralMesh3_3)arg1, (int)width) -> None :

C++ signature :

void ConstructLinearMesh(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

ConstructRectangularMesh((AbstractTetrahedralMesh3_3)arg1, (int)width, (int)height[, (bool)stagger=True]) → None :

C++ signature :

void ConstructRectangularMesh(AbstractTetrahedralMesh<3u, 3u> {lvalue},unsigned int,unsigned int [,bool=True])

ConstructRectangularMesh( (AbstractTetrahedralMesh3_3)arg1, (int)width, (int)height [, (bool)stagger=True]) -> None :

C++ signature :

void ConstructRectangularMesh(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int,unsigned int [,bool=True])

ConstructRegularSlabMesh((AbstractTetrahedralMesh3_3)arg1, (float)spaceStep, (float)width[, (float)height=0[, (float)depth=0]]) → None :

C++ signature :

void ConstructRegularSlabMesh(AbstractTetrahedralMesh<3u, 3u> {lvalue},double,double [,double=0 [,double=0]])

ConstructRegularSlabMeshWithDimensionSplit((AbstractTetrahedralMesh3_3)arg1, (int)dimension, (float)spaceStep, (float)width[, (float)height=0[, (float)depth=0]]) → None :

C++ signature :

void ConstructRegularSlabMeshWithDimensionSplit(AbstractTetrahedralMesh<3u, 3u> {lvalue},unsigned int,double,double [,double=0 [,double=0]])

GetBoundaryElementIteratorBegin((AbstractTetrahedralMesh3_3)arg1) → object :

C++ signature :

__gnu_cxx::__normal_iterator<BoundaryElement<2u, 3u>* const*, std::vector<BoundaryElement<2u, 3u>*, std::allocator<BoundaryElement<2u, 3u>*> > > GetBoundaryElementIteratorBegin(AbstractTetrahedralMesh<3u, 3u> {lvalue})

GetBoundaryElementIteratorEnd((AbstractTetrahedralMesh3_3)arg1) → object :

C++ signature :

__gnu_cxx::__normal_iterator<BoundaryElement<2u, 3u>* const*, std::vector<BoundaryElement<2u, 3u>*, std::allocator<BoundaryElement<2u, 3u>*> > > GetBoundaryElementIteratorEnd(AbstractTetrahedralMesh<3u, 3u> {lvalue})

GetContainingElementIndex((AbstractTetrahedralMesh3_3)arg1, (ChastePoint3)rTestPoint[, (bool)strict=False[, (SetUnsigned)testElements=<chaste.mesh._chaste_project_PyChaste_mesh.SetUnsigned object at 0x7f0a6c6de0e8>[, (bool)onlyTryWithTestElements=False]]]) → int :

C++ signature :

unsigned int GetContainingElementIndex(AbstractTetrahedralMesh<3u, 3u> {lvalue},ChastePoint<3u> [,bool=False [,std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> >=<chaste.mesh._chaste_project_PyChaste_mesh.SetUnsigned object at 0x7f0a6c6de0e8> [,bool=False]]])

GetElement((AbstractTetrahedralMesh3_3)arg1, (int)index) → object :

C++ signature :

Element<3u, 3u>* GetElement(AbstractTetrahedralMesh<3u, 3u> {lvalue},unsigned int)

GetElementIteratorBegin((AbstractTetrahedralMesh3_3)arg1[, (bool)skipDeletedElements=True]) → object :

C++ signature :

AbstractTetrahedralMesh<3u, 3u>::ElementIterator GetElementIteratorBegin(AbstractTetrahedralMesh<3u, 3u> {lvalue} [,bool=True])

GetElementIteratorEnd((AbstractTetrahedralMesh3_3)arg1) → object :

C++ signature :

AbstractTetrahedralMesh<3u, 3u>::ElementIterator GetElementIteratorEnd(AbstractTetrahedralMesh<3u, 3u> {lvalue})

GetHaloNodeIndices((AbstractTetrahedralMesh3_3)arg1, (VecUnsigned)rHaloIndices) → None :

C++ signature :

void GetHaloNodeIndices(AbstractTetrahedralMesh<3u, 3u> {lvalue},std::vector<unsigned int, std::allocator<unsigned int> > {lvalue})

GetHaloNodeIndices( (AbstractTetrahedralMesh3_3)arg1, (VecUnsigned)rHaloIndices) -> None :

C++ signature :

void GetHaloNodeIndices(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},std::vector<unsigned int, std::allocator<unsigned int> > {lvalue})

GetInverseJacobianForElement((AbstractTetrahedralMesh3_3)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant, (object)rInverseJacobian) → None :

C++ signature :

void GetInverseJacobianForElement(AbstractTetrahedralMesh<3u, 3u> {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue},double {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue})

GetInverseJacobianForElement( (AbstractTetrahedralMesh3_3)arg1, (int)elementIndex, (object)rJacobian, (float)rJacobianDeterminant, (object)rInverseJacobian) -> None :

C++ signature :

void GetInverseJacobianForElement(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue},double {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul> {lvalue})

GetMaximumNodeIndex((AbstractTetrahedralMesh3_3)arg1) → int :

C++ signature :

unsigned int GetMaximumNodeIndex(AbstractTetrahedralMesh<3u, 3u> {lvalue})

GetMaximumNodeIndex( (AbstractTetrahedralMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetMaximumNodeIndex(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNearestElementIndexFromTestElements((AbstractTetrahedralMesh3_3)arg1, (ChastePoint3)rTestPoint, (SetUnsigned)testElements) → int :

C++ signature :

unsigned int GetNearestElementIndexFromTestElements(AbstractTetrahedralMesh<3u, 3u> {lvalue},ChastePoint<3u>,std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> >)

GetNearestNodeIndex((AbstractTetrahedralMesh3_3)arg1, (ChastePoint3)rTestPoint) → int :

C++ signature :

unsigned int GetNearestNodeIndex(AbstractTetrahedralMesh<3u, 3u> {lvalue},ChastePoint<3u>)

GetNearestNodeIndex( (AbstractTetrahedralMesh3_3)arg1, (ChastePoint3)rTestPoint) -> int :

C++ signature :

unsigned int GetNearestNodeIndex(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},ChastePoint<3u>)

GetNumAllBoundaryElements((AbstractTetrahedralMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumAllBoundaryElements(AbstractTetrahedralMesh<3u, 3u> {lvalue})

GetNumAllElements((AbstractTetrahedralMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumAllElements(AbstractTetrahedralMesh<3u, 3u> {lvalue})

GetNumAllNodes((AbstractTetrahedralMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumAllNodes(AbstractTetrahedralMesh<3u, 3u> {lvalue})

GetNumAllNodes( (AbstractTetrahedralMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumAllNodes(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumBoundaryElements((AbstractTetrahedralMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumBoundaryElements(AbstractTetrahedralMesh<3u, 3u> {lvalue})

GetNumBoundaryElements( (AbstractTetrahedralMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumBoundaryElements(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumCableElements((AbstractTetrahedralMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumCableElements(AbstractTetrahedralMesh<3u, 3u> {lvalue})

GetNumCableElements( (AbstractTetrahedralMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumCableElements(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumElements((AbstractTetrahedralMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumElements(AbstractTetrahedralMesh<3u, 3u> {lvalue})

GetNumElements( (AbstractTetrahedralMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumElements(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumLocalBoundaryElements((AbstractTetrahedralMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumLocalBoundaryElements(AbstractTetrahedralMesh<3u, 3u> {lvalue})

GetNumLocalBoundaryElements( (AbstractTetrahedralMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumLocalBoundaryElements(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumLocalElements((AbstractTetrahedralMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumLocalElements(AbstractTetrahedralMesh<3u, 3u> {lvalue})

GetNumLocalElements( (AbstractTetrahedralMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumLocalElements(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumNodes((AbstractTetrahedralMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumNodes(AbstractTetrahedralMesh<3u, 3u> {lvalue})

GetNumNodes( (AbstractTetrahedralMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumNodes(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumVertices((AbstractTetrahedralMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumVertices(AbstractTetrahedralMesh<3u, 3u> {lvalue})

GetNumVertices( (AbstractTetrahedralMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumVertices(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

GetVectorFromAtoB((AbstractTetrahedralMesh3_3)arg1, (object)rLocationA, (object)rLocationB) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetVectorFromAtoB(AbstractTetrahedralMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,boost::numeric::ublas::c_vector<double, 3ul>)

GetVectorFromAtoB( (AbstractTetrahedralMesh3_3)arg1, (object)rLocationA, (object)rLocationB) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetVectorFromAtoB(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,boost::numeric::ublas::c_vector<double, 3ul>)

GetWeightedDirectionForBoundaryElement((AbstractTetrahedralMesh3_3)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) → None :

C++ signature :

void GetWeightedDirectionForBoundaryElement(AbstractTetrahedralMesh<3u, 3u> {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 3ul> {lvalue},double {lvalue})

GetWeightedDirectionForBoundaryElement( (AbstractTetrahedralMesh3_3)arg1, (int)elementIndex, (object)rWeightedDirection, (float)rJacobianDeterminant) -> None :

C++ signature :

void GetWeightedDirectionForBoundaryElement(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int,boost::numeric::ublas::c_vector<double, 3ul> {lvalue},double {lvalue})

GetWidth((AbstractTetrahedralMesh3_3)arg1, (int)rDimension) → float :

C++ signature :

double GetWidth(AbstractTetrahedralMesh<3u, 3u> {lvalue},unsigned int)

GetWidth( (AbstractTetrahedralMesh3_3)arg1, (int)rDimension) -> float :

C++ signature :

double GetWidth(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

PermuteNodes((AbstractTetrahedralMesh3_3)arg1) → None :

C++ signature :

void PermuteNodes(AbstractTetrahedralMesh<3u, 3u> {lvalue})

PermuteNodes( (AbstractTetrahedralMesh3_3)arg1) -> None :

C++ signature :

void PermuteNodes(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

ReadNodesPerProcessorFile((AbstractTetrahedralMesh3_3)arg1, (str)rNodesPerProcessorFile) → None :

C++ signature :

void ReadNodesPerProcessorFile(AbstractTetrahedralMesh<3u, 3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

ReadNodesPerProcessorFile( (AbstractTetrahedralMesh3_3)arg1, (str)rNodesPerProcessorFile) -> None :

C++ signature :

void ReadNodesPerProcessorFile(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

RefreshMesh((AbstractTetrahedralMesh3_3)arg1) → None :

C++ signature :

void RefreshMesh(AbstractTetrahedralMesh<3u, 3u> {lvalue})

RefreshMesh( (AbstractTetrahedralMesh3_3)arg1) -> None :

C++ signature :

void RefreshMesh(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

Rotate((AbstractTetrahedralMesh3_3)arg1, (object)rotationMatrix) → None :

C++ signature :

void Rotate(AbstractTetrahedralMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul>)

Rotate( (AbstractTetrahedralMesh3_3)arg1, (object)rotationMatrix) -> None :

C++ signature :

void Rotate(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul>)

Rotate( (AbstractTetrahedralMesh3_3)arg1, (object)axis, (float)angle) -> None :

C++ signature :

void Rotate(AbstractTetrahedralMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,double)

Rotate( (AbstractTetrahedralMesh3_3)arg1, (float)theta) -> None :

C++ signature :

void Rotate(AbstractTetrahedralMesh<3u, 3u> {lvalue},double)

Scale((AbstractTetrahedralMesh3_3)arg1[, (float)xFactor=1.0[, (float)yFactor=1.0[, (float)zFactor=1.0]]]) → None :

C++ signature :

void Scale(AbstractTetrahedralMesh<3u, 3u> {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

Scale( (AbstractTetrahedralMesh3_3)arg1 [, (float)xFactor=1.0 [, (float)yFactor=1.0 [, (float)zFactor=1.0]]]) -> None :

C++ signature :

void Scale(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

SetDistributedVectorFactory((AbstractTetrahedralMesh3_3)arg1, (object)pFactory) → None :

C++ signature :

void SetDistributedVectorFactory(AbstractTetrahedralMesh<3u, 3u> {lvalue},DistributedVectorFactory*)

SetDistributedVectorFactory( (AbstractTetrahedralMesh3_3)arg1, (object)pFactory) -> None :

C++ signature :

void SetDistributedVectorFactory(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},DistributedVectorFactory*)

SetElementOwnerships((AbstractTetrahedralMesh3_3)arg1) → None :

C++ signature :

void SetElementOwnerships(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue})

Translate((AbstractTetrahedralMesh3_3)arg1, (object)rDisplacement) → None :

C++ signature :

void Translate(AbstractTetrahedralMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>)

Translate( (AbstractTetrahedralMesh3_3)arg1, (object)rDisplacement) -> None :

C++ signature :

void Translate(AbstractTetrahedralMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 3ul>)

Translate( (AbstractTetrahedralMesh3_3)arg1 [, (float)xMovement=0.0 [, (float)yMovement=0.0 [, (float)zMovement=0.0]]]) -> None :

C++ signature :

void Translate(AbstractTetrahedralMesh<3u, 3u> {lvalue} [,double=0.0 [,double=0.0 [,double=0.0]]])

class chaste.mesh.AbstractMesh2_2

CalculateBoundingBox((AbstractMesh2_2)arg1) → object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(AbstractMesh<2u, 2u> {lvalue})

CalculateBoundingBox( (AbstractMesh2_2)arg1) -> object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(AbstractMesh_less__2_comma__2__greater__wrapper {lvalue})

CalculateBoundingBox( (AbstractMesh2_2)arg1, (VecNodePtr2)rNodes) -> object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(AbstractMesh_less__2_comma__2__greater__wrapper {lvalue},std::vector<Node<2u>*, std::allocator<Node<2u>*> >)

CalculateMaximumContainingElementsPerProcess((AbstractMesh2_2)arg1) → int :

C++ signature :

unsigned int CalculateMaximumContainingElementsPerProcess(AbstractMesh<2u, 2u> {lvalue})

GetBoundaryNodeIteratorBegin((AbstractMesh2_2)arg1) → object :

C++ signature :

__gnu_cxx::__normal_iterator<Node<2u>* const*, std::vector<Node<2u>*, std::allocator<Node<2u>*> > > GetBoundaryNodeIteratorBegin(AbstractMesh<2u, 2u> {lvalue})

GetBoundaryNodeIteratorEnd((AbstractMesh2_2)arg1) → object :

C++ signature :

__gnu_cxx::__normal_iterator<Node<2u>* const*, std::vector<Node<2u>*, std::allocator<Node<2u>*> > > GetBoundaryNodeIteratorEnd(AbstractMesh<2u, 2u> {lvalue})

GetDistanceBetweenNodes((AbstractMesh2_2)arg1, (int)indexA, (int)indexB) → float :

C++ signature :

double GetDistanceBetweenNodes(AbstractMesh<2u, 2u> {lvalue},unsigned int,unsigned int)

GetMeshFileBaseName((AbstractMesh2_2)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetMeshFileBaseName(AbstractMesh<2u, 2u> {lvalue})

GetNearestNodeIndex((AbstractMesh2_2)arg1, (ChastePoint2)rTestPoint) → int :

C++ signature :

unsigned int GetNearestNodeIndex(AbstractMesh<2u, 2u> {lvalue},ChastePoint<2u>)

GetNearestNodeIndex( (AbstractMesh2_2)arg1, (ChastePoint2)rTestPoint) -> int :

C++ signature :

unsigned int GetNearestNodeIndex(AbstractMesh_less__2_comma__2__greater__wrapper {lvalue},ChastePoint<2u>)

GetNode((AbstractMesh2_2)arg1, (int)index) → Node2 :

C++ signature :

Node<2u>* GetNode(AbstractMesh<2u, 2u> {lvalue},unsigned int)

GetNodeIteratorBegin((AbstractMesh2_2)arg1[, (bool)skipDeletedNodes=True]) → object :

C++ signature :

AbstractMesh<2u, 2u>::NodeIterator GetNodeIteratorBegin(AbstractMesh<2u, 2u> {lvalue} [,bool=True])

GetNodeIteratorEnd((AbstractMesh2_2)arg1) → object :

C++ signature :

AbstractMesh<2u, 2u>::NodeIterator GetNodeIteratorEnd(AbstractMesh<2u, 2u> {lvalue})

GetNumAllNodes((AbstractMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumAllNodes(AbstractMesh<2u, 2u> {lvalue})

GetNumAllNodes( (AbstractMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumAllNodes(AbstractMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumBoundaryNodes((AbstractMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumBoundaryNodes(AbstractMesh<2u, 2u> {lvalue})

GetNumNodeAttributes((AbstractMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumNodeAttributes(AbstractMesh<2u, 2u> {lvalue})

GetNumNodes((AbstractMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumNodes(AbstractMesh<2u, 2u> {lvalue})

GetNumNodes( (AbstractMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumNodes(AbstractMesh_less__2_comma__2__greater__wrapper {lvalue})

GetVectorFromAtoB((AbstractMesh2_2)arg1, (object)rLocationA, (object)rLocationB) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetVectorFromAtoB(AbstractMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,boost::numeric::ublas::c_vector<double, 2ul>)

GetVectorFromAtoB( (AbstractMesh2_2)arg1, (object)rLocationA, (object)rLocationB) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetVectorFromAtoB(AbstractMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,boost::numeric::ublas::c_vector<double, 2ul>)

GetWidth((AbstractMesh2_2)arg1, (int)rDimension) → float :

C++ signature :

double GetWidth(AbstractMesh<2u, 2u> {lvalue},unsigned int)

GetWidth( (AbstractMesh2_2)arg1, (int)rDimension) -> float :

C++ signature :

double GetWidth(AbstractMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

IsMeshChanging((AbstractMesh2_2)arg1) → bool :

C++ signature :

bool IsMeshChanging(AbstractMesh<2u, 2u> {lvalue})

IsMeshOnDisk((AbstractMesh2_2)arg1) → bool :

C++ signature :

bool IsMeshOnDisk(AbstractMesh<2u, 2u> {lvalue})

PermuteNodes((AbstractMesh2_2)arg1) → None :

C++ signature :

void PermuteNodes(AbstractMesh<2u, 2u> {lvalue})

PermuteNodes( (AbstractMesh2_2)arg1) -> None :

C++ signature :

void PermuteNodes(AbstractMesh_less__2_comma__2__greater__wrapper {lvalue})

ReadNodesPerProcessorFile((AbstractMesh2_2)arg1, (str)rNodesPerProcessorFile) → None :

C++ signature :

void ReadNodesPerProcessorFile(AbstractMesh<2u, 2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

ReadNodesPerProcessorFile( (AbstractMesh2_2)arg1, (str)rNodesPerProcessorFile) -> None :

C++ signature :

void ReadNodesPerProcessorFile(AbstractMesh_less__2_comma__2__greater__wrapper {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

RefreshMesh((AbstractMesh2_2)arg1) → None :

C++ signature :

void RefreshMesh(AbstractMesh<2u, 2u> {lvalue})

RefreshMesh( (AbstractMesh2_2)arg1) -> None :

C++ signature :

void RefreshMesh(AbstractMesh_less__2_comma__2__greater__wrapper {lvalue})

Rotate((AbstractMesh2_2)arg1, (object)rotationMatrix) → None :

C++ signature :

void Rotate(AbstractMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul>)

Rotate( (AbstractMesh2_2)arg1, (object)rotationMatrix) -> None :

C++ signature :

void Rotate(AbstractMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul>)

Rotate( (AbstractMesh2_2)arg1, (object)axis, (float)angle) -> None :

C++ signature :

void Rotate(AbstractMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,double)

Rotate( (AbstractMesh2_2)arg1, (float)theta) -> None :

C++ signature :

void Rotate(AbstractMesh<2u, 2u> {lvalue},double)

RotateX((AbstractMesh2_2)arg1, (float)theta) → None :

C++ signature :

void RotateX(AbstractMesh<2u, 2u> {lvalue},double)

RotateY((AbstractMesh2_2)arg1, (float)theta) → None :

C++ signature :

void RotateY(AbstractMesh<2u, 2u> {lvalue},double)

RotateZ((AbstractMesh2_2)arg1, (float)theta) → None :

C++ signature :

void RotateZ(AbstractMesh<2u, 2u> {lvalue},double)

Scale((AbstractMesh2_2)arg1[, (float)xFactor=1.0[, (float)yFactor=1.0[, (float)zFactor=1.0]]]) → None :

C++ signature :

void Scale(AbstractMesh<2u, 2u> {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

Scale( (AbstractMesh2_2)arg1 [, (float)xFactor=1.0 [, (float)yFactor=1.0 [, (float)zFactor=1.0]]]) -> None :

C++ signature :

void Scale(AbstractMesh_less__2_comma__2__greater__wrapper {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

SetDistributedVectorFactory((AbstractMesh2_2)arg1, (object)pFactory) → None :

C++ signature :

void SetDistributedVectorFactory(AbstractMesh<2u, 2u> {lvalue},DistributedVectorFactory*)

SetDistributedVectorFactory( (AbstractMesh2_2)arg1, (object)pFactory) -> None :

C++ signature :

void SetDistributedVectorFactory(AbstractMesh_less__2_comma__2__greater__wrapper {lvalue},DistributedVectorFactory*)

SetElementOwnerships((AbstractMesh2_2)arg1) → None :

C++ signature :

void SetElementOwnerships(AbstractMesh_less__2_comma__2__greater__wrapper {lvalue})

SetMeshHasChangedSinceLoading((AbstractMesh2_2)arg1) → None :

C++ signature :

void SetMeshHasChangedSinceLoading(AbstractMesh<2u, 2u> {lvalue})

Translate((AbstractMesh2_2)arg1, (object)rDisplacement) → None :

C++ signature :

void Translate(AbstractMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_vector<double, 2ul>)

Translate( (AbstractMesh2_2)arg1, (object)rDisplacement) -> None :

C++ signature :

void Translate(AbstractMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>)

Translate( (AbstractMesh2_2)arg1 [, (float)xMovement=0.0 [, (float)yMovement=0.0 [, (float)zMovement=0.0]]]) -> None :

C++ signature :

void Translate(AbstractMesh<2u, 2u> {lvalue} [,double=0.0 [,double=0.0 [,double=0.0]]])

class chaste.mesh.AbstractMesh3_3

CalculateBoundingBox((AbstractMesh3_3)arg1) → object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(AbstractMesh<3u, 3u> {lvalue})

CalculateBoundingBox( (AbstractMesh3_3)arg1) -> object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(AbstractMesh_less__3_comma__3__greater__wrapper {lvalue})

CalculateBoundingBox( (AbstractMesh3_3)arg1, (VecNodePtr3)rNodes) -> object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(AbstractMesh_less__3_comma__3__greater__wrapper {lvalue},std::vector<Node<3u>*, std::allocator<Node<3u>*> >)

CalculateMaximumContainingElementsPerProcess((AbstractMesh3_3)arg1) → int :

C++ signature :

unsigned int CalculateMaximumContainingElementsPerProcess(AbstractMesh<3u, 3u> {lvalue})

GetBoundaryNodeIteratorBegin((AbstractMesh3_3)arg1) → object :

C++ signature :

__gnu_cxx::__normal_iterator<Node<3u>* const*, std::vector<Node<3u>*, std::allocator<Node<3u>*> > > GetBoundaryNodeIteratorBegin(AbstractMesh<3u, 3u> {lvalue})

GetBoundaryNodeIteratorEnd((AbstractMesh3_3)arg1) → object :

C++ signature :

__gnu_cxx::__normal_iterator<Node<3u>* const*, std::vector<Node<3u>*, std::allocator<Node<3u>*> > > GetBoundaryNodeIteratorEnd(AbstractMesh<3u, 3u> {lvalue})

GetDistanceBetweenNodes((AbstractMesh3_3)arg1, (int)indexA, (int)indexB) → float :

C++ signature :

double GetDistanceBetweenNodes(AbstractMesh<3u, 3u> {lvalue},unsigned int,unsigned int)

GetMeshFileBaseName((AbstractMesh3_3)arg1) → str :

C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > GetMeshFileBaseName(AbstractMesh<3u, 3u> {lvalue})

GetNearestNodeIndex((AbstractMesh3_3)arg1, (ChastePoint3)rTestPoint) → int :

C++ signature :

unsigned int GetNearestNodeIndex(AbstractMesh<3u, 3u> {lvalue},ChastePoint<3u>)

GetNearestNodeIndex( (AbstractMesh3_3)arg1, (ChastePoint3)rTestPoint) -> int :

C++ signature :

unsigned int GetNearestNodeIndex(AbstractMesh_less__3_comma__3__greater__wrapper {lvalue},ChastePoint<3u>)

GetNode((AbstractMesh3_3)arg1, (int)index) → Node3 :

C++ signature :

Node<3u>* GetNode(AbstractMesh<3u, 3u> {lvalue},unsigned int)

GetNodeIteratorBegin((AbstractMesh3_3)arg1[, (bool)skipDeletedNodes=True]) → object :

C++ signature :

AbstractMesh<3u, 3u>::NodeIterator GetNodeIteratorBegin(AbstractMesh<3u, 3u> {lvalue} [,bool=True])

GetNodeIteratorEnd((AbstractMesh3_3)arg1) → object :

C++ signature :

AbstractMesh<3u, 3u>::NodeIterator GetNodeIteratorEnd(AbstractMesh<3u, 3u> {lvalue})

GetNumAllNodes((AbstractMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumAllNodes(AbstractMesh<3u, 3u> {lvalue})

GetNumAllNodes( (AbstractMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumAllNodes(AbstractMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumBoundaryNodes((AbstractMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumBoundaryNodes(AbstractMesh<3u, 3u> {lvalue})

GetNumNodeAttributes((AbstractMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumNodeAttributes(AbstractMesh<3u, 3u> {lvalue})

GetNumNodes((AbstractMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumNodes(AbstractMesh<3u, 3u> {lvalue})

GetNumNodes( (AbstractMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumNodes(AbstractMesh_less__3_comma__3__greater__wrapper {lvalue})

GetVectorFromAtoB((AbstractMesh3_3)arg1, (object)rLocationA, (object)rLocationB) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetVectorFromAtoB(AbstractMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,boost::numeric::ublas::c_vector<double, 3ul>)

GetVectorFromAtoB( (AbstractMesh3_3)arg1, (object)rLocationA, (object)rLocationB) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetVectorFromAtoB(AbstractMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,boost::numeric::ublas::c_vector<double, 3ul>)

GetWidth((AbstractMesh3_3)arg1, (int)rDimension) → float :

C++ signature :

double GetWidth(AbstractMesh<3u, 3u> {lvalue},unsigned int)

GetWidth( (AbstractMesh3_3)arg1, (int)rDimension) -> float :

C++ signature :

double GetWidth(AbstractMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

IsMeshChanging((AbstractMesh3_3)arg1) → bool :

C++ signature :

bool IsMeshChanging(AbstractMesh<3u, 3u> {lvalue})

IsMeshOnDisk((AbstractMesh3_3)arg1) → bool :

C++ signature :

bool IsMeshOnDisk(AbstractMesh<3u, 3u> {lvalue})

PermuteNodes((AbstractMesh3_3)arg1) → None :

C++ signature :

void PermuteNodes(AbstractMesh<3u, 3u> {lvalue})

PermuteNodes( (AbstractMesh3_3)arg1) -> None :

C++ signature :

void PermuteNodes(AbstractMesh_less__3_comma__3__greater__wrapper {lvalue})

ReadNodesPerProcessorFile((AbstractMesh3_3)arg1, (str)rNodesPerProcessorFile) → None :

C++ signature :

void ReadNodesPerProcessorFile(AbstractMesh<3u, 3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

ReadNodesPerProcessorFile( (AbstractMesh3_3)arg1, (str)rNodesPerProcessorFile) -> None :

C++ signature :

void ReadNodesPerProcessorFile(AbstractMesh_less__3_comma__3__greater__wrapper {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

RefreshMesh((AbstractMesh3_3)arg1) → None :

C++ signature :

void RefreshMesh(AbstractMesh<3u, 3u> {lvalue})

RefreshMesh( (AbstractMesh3_3)arg1) -> None :

C++ signature :

void RefreshMesh(AbstractMesh_less__3_comma__3__greater__wrapper {lvalue})

Rotate((AbstractMesh3_3)arg1, (object)rotationMatrix) → None :

C++ signature :

void Rotate(AbstractMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul>)

Rotate( (AbstractMesh3_3)arg1, (object)rotationMatrix) -> None :

C++ signature :

void Rotate(AbstractMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul>)

Rotate( (AbstractMesh3_3)arg1, (object)axis, (float)angle) -> None :

C++ signature :

void Rotate(AbstractMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,double)

Rotate( (AbstractMesh3_3)arg1, (float)theta) -> None :

C++ signature :

void Rotate(AbstractMesh<3u, 3u> {lvalue},double)

RotateX((AbstractMesh3_3)arg1, (float)theta) → None :

C++ signature :

void RotateX(AbstractMesh<3u, 3u> {lvalue},double)

RotateY((AbstractMesh3_3)arg1, (float)theta) → None :

C++ signature :

void RotateY(AbstractMesh<3u, 3u> {lvalue},double)

RotateZ((AbstractMesh3_3)arg1, (float)theta) → None :

C++ signature :

void RotateZ(AbstractMesh<3u, 3u> {lvalue},double)

Scale((AbstractMesh3_3)arg1[, (float)xFactor=1.0[, (float)yFactor=1.0[, (float)zFactor=1.0]]]) → None :

C++ signature :

void Scale(AbstractMesh<3u, 3u> {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

Scale( (AbstractMesh3_3)arg1 [, (float)xFactor=1.0 [, (float)yFactor=1.0 [, (float)zFactor=1.0]]]) -> None :

C++ signature :

void Scale(AbstractMesh_less__3_comma__3__greater__wrapper {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

SetDistributedVectorFactory((AbstractMesh3_3)arg1, (object)pFactory) → None :

C++ signature :

void SetDistributedVectorFactory(AbstractMesh<3u, 3u> {lvalue},DistributedVectorFactory*)

SetDistributedVectorFactory( (AbstractMesh3_3)arg1, (object)pFactory) -> None :

C++ signature :

void SetDistributedVectorFactory(AbstractMesh_less__3_comma__3__greater__wrapper {lvalue},DistributedVectorFactory*)

SetElementOwnerships((AbstractMesh3_3)arg1) → None :

C++ signature :

void SetElementOwnerships(AbstractMesh_less__3_comma__3__greater__wrapper {lvalue})

SetMeshHasChangedSinceLoading((AbstractMesh3_3)arg1) → None :

C++ signature :

void SetMeshHasChangedSinceLoading(AbstractMesh<3u, 3u> {lvalue})

Translate((AbstractMesh3_3)arg1, (object)rDisplacement) → None :

C++ signature :

void Translate(AbstractMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>)

Translate( (AbstractMesh3_3)arg1, (object)rDisplacement) -> None :

C++ signature :

void Translate(AbstractMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 3ul>)

Translate( (AbstractMesh3_3)arg1 [, (float)xMovement=0.0 [, (float)yMovement=0.0 [, (float)zMovement=0.0]]]) -> None :

C++ signature :

void Translate(AbstractMesh<3u, 3u> {lvalue} [,double=0.0 [,double=0.0 [,double=0.0]]])

class chaste.mesh.VertexMesh2_2

CalculateAreaOfFace((VertexMesh2_2)arg1, (object)pFace) → float :

C++ signature :

double CalculateAreaOfFace(VertexMesh<2u, 2u> {lvalue},VertexElement<1u, 2u>*)

CalculateAreaOfFace( (VertexMesh2_2)arg1, (object)pFace) -> float :

C++ signature :

double CalculateAreaOfFace(VertexMesh_less__2_comma__2__greater__wrapper {lvalue},VertexElement<1u, 2u>*)

CalculateBoundingBox((VertexMesh2_2)arg1, (VecNodePtr2)rNodes) → object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(VertexMesh_less__2_comma__2__greater__wrapper {lvalue},std::vector<Node<2u>*, std::allocator<Node<2u>*> >)

CalculateBoundingBox( (VertexMesh2_2)arg1) -> object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(VertexMesh<2u, 2u> {lvalue})

CalculateBoundingBox( (VertexMesh2_2)arg1) -> object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(VertexMesh_less__2_comma__2__greater__wrapper {lvalue})

CalculateMomentsOfElement((VertexMesh2_2)arg1, (int)index) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> CalculateMomentsOfElement(VertexMesh<2u, 2u> {lvalue},unsigned int)

CalculateMomentsOfElement( (VertexMesh2_2)arg1, (int)index) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> CalculateMomentsOfElement(VertexMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

CalculateUnitNormalToFaceWithArea((VertexMesh2_2)arg1, (object)pFace, (object)rNormal) → float :

C++ signature :

double CalculateUnitNormalToFaceWithArea(VertexMesh<2u, 2u> {lvalue},VertexElement<1u, 2u>*,boost::numeric::ublas::c_vector<double, 2ul> {lvalue})

Clear((VertexMesh2_2)arg1) → None :

C++ signature :

void Clear(VertexMesh<2u, 2u> {lvalue})

Clear( (VertexMesh2_2)arg1) -> None :

C++ signature :

void Clear(VertexMesh_less__2_comma__2__greater__wrapper {lvalue})

ConstructFromMeshReader((VertexMesh2_2)arg1, (object)rMeshReader) → None :

C++ signature :

void ConstructFromMeshReader(VertexMesh<2u, 2u> {lvalue},AbstractMeshReader<2u, 2u> {lvalue})

ElementIncludesPoint((VertexMesh2_2)arg1, (object)rTestPoint, (int)elementIndex) → bool :

C++ signature :

bool ElementIncludesPoint(VertexMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,unsigned int)

GenerateVerticesFromElementCircumcentres((VertexMesh2_2)arg1, (TetrahedralMesh2_2)rMesh) → None :

C++ signature :

void GenerateVerticesFromElementCircumcentres(VertexMesh_less__2_comma__2__greater__wrapper {lvalue},TetrahedralMesh<2u, 2u> {lvalue})

GetAreaGradientOfElementAtNode((VertexMesh2_2)arg1, (object)pElement, (int)localIndex) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetAreaGradientOfElementAtNode(VertexMesh<2u, 2u> {lvalue},VertexElement<2u, 2u>*,unsigned int)

GetCentroidOfElement((VertexMesh2_2)arg1, (int)index) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetCentroidOfElement(VertexMesh<2u, 2u> {lvalue},unsigned int)

GetCentroidOfElement( (VertexMesh2_2)arg1, (int)index) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetCentroidOfElement(VertexMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

GetDelaunayNodeIndexCorrespondingToVoronoiElementIndex((VertexMesh2_2)arg1, (int)elementIndex) → int :

C++ signature :

unsigned int GetDelaunayNodeIndexCorrespondingToVoronoiElementIndex(VertexMesh<2u, 2u> {lvalue},unsigned int)

GetEdgeLength((VertexMesh2_2)arg1, (int)elementIndex1, (int)elementIndex2) → float :

C++ signature :

double GetEdgeLength(VertexMesh<2u, 2u> {lvalue},unsigned int,unsigned int)

GetElement((VertexMesh2_2)arg1, (int)index) → object :

C++ signature :

VertexElement<2u, 2u>* GetElement(VertexMesh<2u, 2u> {lvalue},unsigned int)

GetElementIteratorBegin((VertexMesh2_2)arg1[, (bool)skipDeletedElements=True]) → object :

C++ signature :

VertexMesh<2u, 2u>::VertexElementIterator GetElementIteratorBegin(VertexMesh<2u, 2u> {lvalue} [,bool=True])

GetElementIteratorEnd((VertexMesh2_2)arg1) → object :

C++ signature :

VertexMesh<2u, 2u>::VertexElementIterator GetElementIteratorEnd(VertexMesh<2u, 2u> {lvalue})

GetElongationShapeFactorOfElement((VertexMesh2_2)arg1, (int)elementIndex) → float :

C++ signature :

double GetElongationShapeFactorOfElement(VertexMesh<2u, 2u> {lvalue},unsigned int)

GetLocalIndexForElementEdgeClosestToPoint((VertexMesh2_2)arg1, (object)rTestPoint, (int)elementIndex) → int :

C++ signature :

unsigned int GetLocalIndexForElementEdgeClosestToPoint(VertexMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,unsigned int)

GetNearestNodeIndex((VertexMesh2_2)arg1, (ChastePoint2)rTestPoint) → int :

C++ signature :

unsigned int GetNearestNodeIndex(VertexMesh<2u, 2u> {lvalue},ChastePoint<2u>)

GetNearestNodeIndex( (VertexMesh2_2)arg1, (ChastePoint2)rTestPoint) -> int :

C++ signature :

unsigned int GetNearestNodeIndex(VertexMesh_less__2_comma__2__greater__wrapper {lvalue},ChastePoint<2u>)

GetNeighbouringElementIndices((VertexMesh2_2)arg1, (int)elementIndex) → SetUnsigned :

C++ signature :

std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> > GetNeighbouringElementIndices(VertexMesh<2u, 2u> {lvalue},unsigned int)

GetNeighbouringNodeIndices((VertexMesh2_2)arg1, (int)nodeIndex) → SetUnsigned :

C++ signature :

std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> > GetNeighbouringNodeIndices(VertexMesh<2u, 2u> {lvalue},unsigned int)

GetNeighbouringNodeNotAlsoInElement((VertexMesh2_2)arg1, (int)nodeIndex, (int)elemIndex) → SetUnsigned :

C++ signature :

std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> > GetNeighbouringNodeNotAlsoInElement(VertexMesh<2u, 2u> {lvalue},unsigned int,unsigned int)

GetNextEdgeGradientOfElementAtNode((VertexMesh2_2)arg1, (object)pElement, (int)localIndex) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetNextEdgeGradientOfElementAtNode(VertexMesh<2u, 2u> {lvalue},VertexElement<2u, 2u>*,unsigned int)

GetNumAllElements((VertexMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumAllElements(VertexMesh<2u, 2u> {lvalue})

GetNumAllNodes((VertexMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumAllNodes(VertexMesh<2u, 2u> {lvalue})

GetNumAllNodes( (VertexMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumAllNodes(VertexMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumElements((VertexMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumElements(VertexMesh<2u, 2u> {lvalue})

GetNumElements( (VertexMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumElements(VertexMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumFaces((VertexMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumFaces(VertexMesh<2u, 2u> {lvalue})

GetNumFaces( (VertexMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumFaces(VertexMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumNodes((VertexMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumNodes(VertexMesh<2u, 2u> {lvalue})

GetNumNodes( (VertexMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumNodes(VertexMesh_less__2_comma__2__greater__wrapper {lvalue})

GetPerimeterGradientOfElementAtNode((VertexMesh2_2)arg1, (object)pElement, (int)localIndex) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetPerimeterGradientOfElementAtNode(VertexMesh<2u, 2u> {lvalue},VertexElement<2u, 2u>*,unsigned int)

GetPreviousEdgeGradientOfElementAtNode((VertexMesh2_2)arg1, (object)pElement, (int)localIndex) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetPreviousEdgeGradientOfElementAtNode(VertexMesh<2u, 2u> {lvalue},VertexElement<2u, 2u>*,unsigned int)

GetRosetteRankOfElement((VertexMesh2_2)arg1, (int)index) → int :

C++ signature :

unsigned int GetRosetteRankOfElement(VertexMesh<2u, 2u> {lvalue},unsigned int)

GetShortAxisOfElement((VertexMesh2_2)arg1, (int)index) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetShortAxisOfElement(VertexMesh<2u, 2u> {lvalue},unsigned int)

GetSurfaceAreaOfElement((VertexMesh2_2)arg1, (int)index) → float :

C++ signature :

double GetSurfaceAreaOfElement(VertexMesh<2u, 2u> {lvalue},unsigned int)

GetSurfaceAreaOfElement( (VertexMesh2_2)arg1, (int)index) -> float :

C++ signature :

double GetSurfaceAreaOfElement(VertexMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

GetVectorFromAtoB((VertexMesh2_2)arg1, (object)rLocationA, (object)rLocationB) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetVectorFromAtoB(VertexMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,boost::numeric::ublas::c_vector<double, 2ul>)

GetVectorFromAtoB( (VertexMesh2_2)arg1, (object)rLocationA, (object)rLocationB) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetVectorFromAtoB(VertexMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,boost::numeric::ublas::c_vector<double, 2ul>)

GetVolumeOfElement((VertexMesh2_2)arg1, (int)index) → float :

C++ signature :

double GetVolumeOfElement(VertexMesh<2u, 2u> {lvalue},unsigned int)

GetVolumeOfElement( (VertexMesh2_2)arg1, (int)index) -> float :

C++ signature :

double GetVolumeOfElement(VertexMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

GetVoronoiElementIndexCorrespondingToDelaunayNodeIndex((VertexMesh2_2)arg1, (int)nodeIndex) → int :

C++ signature :

unsigned int GetVoronoiElementIndexCorrespondingToDelaunayNodeIndex(VertexMesh<2u, 2u> {lvalue},unsigned int)

GetWidth((VertexMesh2_2)arg1, (int)rDimension) → float :

C++ signature :

double GetWidth(VertexMesh<2u, 2u> {lvalue},unsigned int)

GetWidth( (VertexMesh2_2)arg1, (int)rDimension) -> float :

C++ signature :

double GetWidth(VertexMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

PermuteNodes((VertexMesh2_2)arg1) → None :

C++ signature :

void PermuteNodes(VertexMesh<2u, 2u> {lvalue})

PermuteNodes( (VertexMesh2_2)arg1) -> None :

C++ signature :

void PermuteNodes(VertexMesh_less__2_comma__2__greater__wrapper {lvalue})

ReadNodesPerProcessorFile((VertexMesh2_2)arg1, (str)rNodesPerProcessorFile) → None :

C++ signature :

void ReadNodesPerProcessorFile(VertexMesh<2u, 2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

ReadNodesPerProcessorFile( (VertexMesh2_2)arg1, (str)rNodesPerProcessorFile) -> None :

C++ signature :

void ReadNodesPerProcessorFile(VertexMesh_less__2_comma__2__greater__wrapper {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

RefreshMesh((VertexMesh2_2)arg1) → None :

C++ signature :

void RefreshMesh(VertexMesh<2u, 2u> {lvalue})

RefreshMesh( (VertexMesh2_2)arg1) -> None :

C++ signature :

void RefreshMesh(VertexMesh_less__2_comma__2__greater__wrapper {lvalue})

Rotate((VertexMesh2_2)arg1, (object)rotationMatrix) → None :

C++ signature :

void Rotate(VertexMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul>)

Rotate( (VertexMesh2_2)arg1, (object)rotationMatrix) -> None :

C++ signature :

void Rotate(VertexMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul>)

Rotate( (VertexMesh2_2)arg1, (object)axis, (float)angle) -> None :

C++ signature :

void Rotate(VertexMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,double)

Rotate( (VertexMesh2_2)arg1, (float)theta) -> None :

C++ signature :

void Rotate(VertexMesh<2u, 2u> {lvalue},double)

Scale((VertexMesh2_2)arg1[, (float)xFactor=1.0[, (float)yFactor=1.0[, (float)zFactor=1.0]]]) → None :

C++ signature :

void Scale(VertexMesh<2u, 2u> {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

Scale( (VertexMesh2_2)arg1 [, (float)xFactor=1.0 [, (float)yFactor=1.0 [, (float)zFactor=1.0]]]) -> None :

C++ signature :

void Scale(VertexMesh_less__2_comma__2__greater__wrapper {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

SetDistributedVectorFactory((VertexMesh2_2)arg1, (object)pFactory) → None :

C++ signature :

void SetDistributedVectorFactory(VertexMesh<2u, 2u> {lvalue},DistributedVectorFactory*)

SetDistributedVectorFactory( (VertexMesh2_2)arg1, (object)pFactory) -> None :

C++ signature :

void SetDistributedVectorFactory(VertexMesh_less__2_comma__2__greater__wrapper {lvalue},DistributedVectorFactory*)

SetElementOwnerships((VertexMesh2_2)arg1) → None :

C++ signature :

void SetElementOwnerships(VertexMesh_less__2_comma__2__greater__wrapper {lvalue})

SolveBoundaryElementMapping((VertexMesh2_2)arg1, (int)index) → int :

C++ signature :

unsigned int SolveBoundaryElementMapping(VertexMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

SolveElementMapping((VertexMesh2_2)arg1, (int)index) → int :

C++ signature :

unsigned int SolveElementMapping(VertexMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

SolveNodeMapping((VertexMesh2_2)arg1, (int)index) → int :

C++ signature :

unsigned int SolveNodeMapping(VertexMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

Translate((VertexMesh2_2)arg1, (object)rDisplacement) → None :

C++ signature :

void Translate(VertexMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_vector<double, 2ul>)

Translate( (VertexMesh2_2)arg1, (object)rDisplacement) -> None :

C++ signature :

void Translate(VertexMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>)

Translate( (VertexMesh2_2)arg1 [, (float)xMovement=0.0 [, (float)yMovement=0.0 [, (float)zMovement=0.0]]]) -> None :

C++ signature :

void Translate(VertexMesh<2u, 2u> {lvalue} [,double=0.0 [,double=0.0 [,double=0.0]]])

class chaste.mesh.VertexMesh3_3

CalculateAreaOfFace((VertexMesh3_3)arg1, (object)pFace) → float :

C++ signature :

double CalculateAreaOfFace(VertexMesh<3u, 3u> {lvalue},VertexElement<2u, 3u>*)

CalculateAreaOfFace( (VertexMesh3_3)arg1, (object)pFace) -> float :

C++ signature :

double CalculateAreaOfFace(VertexMesh_less__3_comma__3__greater__wrapper {lvalue},VertexElement<2u, 3u>*)

CalculateBoundingBox((VertexMesh3_3)arg1, (VecNodePtr3)rNodes) → object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(VertexMesh_less__3_comma__3__greater__wrapper {lvalue},std::vector<Node<3u>*, std::allocator<Node<3u>*> >)

CalculateBoundingBox( (VertexMesh3_3)arg1) -> object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(VertexMesh<3u, 3u> {lvalue})

CalculateBoundingBox( (VertexMesh3_3)arg1) -> object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(VertexMesh_less__3_comma__3__greater__wrapper {lvalue})

CalculateMomentsOfElement((VertexMesh3_3)arg1, (int)index) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> CalculateMomentsOfElement(VertexMesh<3u, 3u> {lvalue},unsigned int)

CalculateMomentsOfElement( (VertexMesh3_3)arg1, (int)index) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> CalculateMomentsOfElement(VertexMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

CalculateUnitNormalToFaceWithArea((VertexMesh3_3)arg1, (object)pFace, (object)rNormal) → float :

C++ signature :

double CalculateUnitNormalToFaceWithArea(VertexMesh<3u, 3u> {lvalue},VertexElement<2u, 3u>*,boost::numeric::ublas::c_vector<double, 3ul> {lvalue})

Clear((VertexMesh3_3)arg1) → None :

C++ signature :

void Clear(VertexMesh<3u, 3u> {lvalue})

Clear( (VertexMesh3_3)arg1) -> None :

C++ signature :

void Clear(VertexMesh_less__3_comma__3__greater__wrapper {lvalue})

ConstructFromMeshReader((VertexMesh3_3)arg1, (object)rMeshReader) → None :

C++ signature :

void ConstructFromMeshReader(VertexMesh<3u, 3u> {lvalue},AbstractMeshReader<3u, 3u> {lvalue})

ElementIncludesPoint((VertexMesh3_3)arg1, (object)rTestPoint, (int)elementIndex) → bool :

C++ signature :

bool ElementIncludesPoint(VertexMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,unsigned int)

GenerateVerticesFromElementCircumcentres((VertexMesh3_3)arg1, (TetrahedralMesh3_3)rMesh) → None :

C++ signature :

void GenerateVerticesFromElementCircumcentres(VertexMesh_less__3_comma__3__greater__wrapper {lvalue},TetrahedralMesh<3u, 3u> {lvalue})

GetAreaGradientOfElementAtNode((VertexMesh3_3)arg1, (object)pElement, (int)localIndex) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetAreaGradientOfElementAtNode(VertexMesh<3u, 3u> {lvalue},VertexElement<3u, 3u>*,unsigned int)

GetCentroidOfElement((VertexMesh3_3)arg1, (int)index) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetCentroidOfElement(VertexMesh<3u, 3u> {lvalue},unsigned int)

GetCentroidOfElement( (VertexMesh3_3)arg1, (int)index) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetCentroidOfElement(VertexMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

GetDelaunayNodeIndexCorrespondingToVoronoiElementIndex((VertexMesh3_3)arg1, (int)elementIndex) → int :

C++ signature :

unsigned int GetDelaunayNodeIndexCorrespondingToVoronoiElementIndex(VertexMesh<3u, 3u> {lvalue},unsigned int)

GetEdgeLength((VertexMesh3_3)arg1, (int)elementIndex1, (int)elementIndex2) → float :

C++ signature :

double GetEdgeLength(VertexMesh<3u, 3u> {lvalue},unsigned int,unsigned int)

GetElement((VertexMesh3_3)arg1, (int)index) → object :

C++ signature :

VertexElement<3u, 3u>* GetElement(VertexMesh<3u, 3u> {lvalue},unsigned int)

GetElementIteratorBegin((VertexMesh3_3)arg1[, (bool)skipDeletedElements=True]) → object :

C++ signature :

VertexMesh<3u, 3u>::VertexElementIterator GetElementIteratorBegin(VertexMesh<3u, 3u> {lvalue} [,bool=True])

GetElementIteratorEnd((VertexMesh3_3)arg1) → object :

C++ signature :

VertexMesh<3u, 3u>::VertexElementIterator GetElementIteratorEnd(VertexMesh<3u, 3u> {lvalue})

GetElongationShapeFactorOfElement((VertexMesh3_3)arg1, (int)elementIndex) → float :

C++ signature :

double GetElongationShapeFactorOfElement(VertexMesh<3u, 3u> {lvalue},unsigned int)

GetLocalIndexForElementEdgeClosestToPoint((VertexMesh3_3)arg1, (object)rTestPoint, (int)elementIndex) → int :

C++ signature :

unsigned int GetLocalIndexForElementEdgeClosestToPoint(VertexMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,unsigned int)

GetNearestNodeIndex((VertexMesh3_3)arg1, (ChastePoint3)rTestPoint) → int :

C++ signature :

unsigned int GetNearestNodeIndex(VertexMesh<3u, 3u> {lvalue},ChastePoint<3u>)

GetNearestNodeIndex( (VertexMesh3_3)arg1, (ChastePoint3)rTestPoint) -> int :

C++ signature :

unsigned int GetNearestNodeIndex(VertexMesh_less__3_comma__3__greater__wrapper {lvalue},ChastePoint<3u>)

GetNeighbouringElementIndices((VertexMesh3_3)arg1, (int)elementIndex) → SetUnsigned :

C++ signature :

std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> > GetNeighbouringElementIndices(VertexMesh<3u, 3u> {lvalue},unsigned int)

GetNeighbouringNodeIndices((VertexMesh3_3)arg1, (int)nodeIndex) → SetUnsigned :

C++ signature :

std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> > GetNeighbouringNodeIndices(VertexMesh<3u, 3u> {lvalue},unsigned int)

GetNeighbouringNodeNotAlsoInElement((VertexMesh3_3)arg1, (int)nodeIndex, (int)elemIndex) → SetUnsigned :

C++ signature :

std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> > GetNeighbouringNodeNotAlsoInElement(VertexMesh<3u, 3u> {lvalue},unsigned int,unsigned int)

GetNextEdgeGradientOfElementAtNode((VertexMesh3_3)arg1, (object)pElement, (int)localIndex) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetNextEdgeGradientOfElementAtNode(VertexMesh<3u, 3u> {lvalue},VertexElement<3u, 3u>*,unsigned int)

GetNumAllElements((VertexMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumAllElements(VertexMesh<3u, 3u> {lvalue})

GetNumAllNodes((VertexMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumAllNodes(VertexMesh<3u, 3u> {lvalue})

GetNumAllNodes( (VertexMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumAllNodes(VertexMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumElements((VertexMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumElements(VertexMesh<3u, 3u> {lvalue})

GetNumElements( (VertexMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumElements(VertexMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumFaces((VertexMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumFaces(VertexMesh<3u, 3u> {lvalue})

GetNumFaces( (VertexMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumFaces(VertexMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumNodes((VertexMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumNodes(VertexMesh<3u, 3u> {lvalue})

GetNumNodes( (VertexMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumNodes(VertexMesh_less__3_comma__3__greater__wrapper {lvalue})

GetPerimeterGradientOfElementAtNode((VertexMesh3_3)arg1, (object)pElement, (int)localIndex) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetPerimeterGradientOfElementAtNode(VertexMesh<3u, 3u> {lvalue},VertexElement<3u, 3u>*,unsigned int)

GetPreviousEdgeGradientOfElementAtNode((VertexMesh3_3)arg1, (object)pElement, (int)localIndex) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetPreviousEdgeGradientOfElementAtNode(VertexMesh<3u, 3u> {lvalue},VertexElement<3u, 3u>*,unsigned int)

GetRosetteRankOfElement((VertexMesh3_3)arg1, (int)index) → int :

C++ signature :

unsigned int GetRosetteRankOfElement(VertexMesh<3u, 3u> {lvalue},unsigned int)

GetShortAxisOfElement((VertexMesh3_3)arg1, (int)index) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetShortAxisOfElement(VertexMesh<3u, 3u> {lvalue},unsigned int)

GetSurfaceAreaOfElement((VertexMesh3_3)arg1, (int)index) → float :

C++ signature :

double GetSurfaceAreaOfElement(VertexMesh<3u, 3u> {lvalue},unsigned int)

GetSurfaceAreaOfElement( (VertexMesh3_3)arg1, (int)index) -> float :

C++ signature :

double GetSurfaceAreaOfElement(VertexMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

GetVectorFromAtoB((VertexMesh3_3)arg1, (object)rLocationA, (object)rLocationB) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetVectorFromAtoB(VertexMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,boost::numeric::ublas::c_vector<double, 3ul>)

GetVectorFromAtoB( (VertexMesh3_3)arg1, (object)rLocationA, (object)rLocationB) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetVectorFromAtoB(VertexMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,boost::numeric::ublas::c_vector<double, 3ul>)

GetVolumeOfElement((VertexMesh3_3)arg1, (int)index) → float :

C++ signature :

double GetVolumeOfElement(VertexMesh<3u, 3u> {lvalue},unsigned int)

GetVolumeOfElement( (VertexMesh3_3)arg1, (int)index) -> float :

C++ signature :

double GetVolumeOfElement(VertexMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

GetVoronoiElementIndexCorrespondingToDelaunayNodeIndex((VertexMesh3_3)arg1, (int)nodeIndex) → int :

C++ signature :

unsigned int GetVoronoiElementIndexCorrespondingToDelaunayNodeIndex(VertexMesh<3u, 3u> {lvalue},unsigned int)

GetWidth((VertexMesh3_3)arg1, (int)rDimension) → float :

C++ signature :

double GetWidth(VertexMesh<3u, 3u> {lvalue},unsigned int)

GetWidth( (VertexMesh3_3)arg1, (int)rDimension) -> float :

C++ signature :

double GetWidth(VertexMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

PermuteNodes((VertexMesh3_3)arg1) → None :

C++ signature :

void PermuteNodes(VertexMesh<3u, 3u> {lvalue})

PermuteNodes( (VertexMesh3_3)arg1) -> None :

C++ signature :

void PermuteNodes(VertexMesh_less__3_comma__3__greater__wrapper {lvalue})

ReadNodesPerProcessorFile((VertexMesh3_3)arg1, (str)rNodesPerProcessorFile) → None :

C++ signature :

void ReadNodesPerProcessorFile(VertexMesh<3u, 3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

ReadNodesPerProcessorFile( (VertexMesh3_3)arg1, (str)rNodesPerProcessorFile) -> None :

C++ signature :

void ReadNodesPerProcessorFile(VertexMesh_less__3_comma__3__greater__wrapper {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

RefreshMesh((VertexMesh3_3)arg1) → None :

C++ signature :

void RefreshMesh(VertexMesh<3u, 3u> {lvalue})

RefreshMesh( (VertexMesh3_3)arg1) -> None :

C++ signature :

void RefreshMesh(VertexMesh_less__3_comma__3__greater__wrapper {lvalue})

Rotate((VertexMesh3_3)arg1, (object)rotationMatrix) → None :

C++ signature :

void Rotate(VertexMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul>)

Rotate( (VertexMesh3_3)arg1, (object)rotationMatrix) -> None :

C++ signature :

void Rotate(VertexMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul>)

Rotate( (VertexMesh3_3)arg1, (object)axis, (float)angle) -> None :

C++ signature :

void Rotate(VertexMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,double)

Rotate( (VertexMesh3_3)arg1, (float)theta) -> None :

C++ signature :

void Rotate(VertexMesh<3u, 3u> {lvalue},double)

Scale((VertexMesh3_3)arg1[, (float)xFactor=1.0[, (float)yFactor=1.0[, (float)zFactor=1.0]]]) → None :

C++ signature :

void Scale(VertexMesh<3u, 3u> {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

Scale( (VertexMesh3_3)arg1 [, (float)xFactor=1.0 [, (float)yFactor=1.0 [, (float)zFactor=1.0]]]) -> None :

C++ signature :

void Scale(VertexMesh_less__3_comma__3__greater__wrapper {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

SetDistributedVectorFactory((VertexMesh3_3)arg1, (object)pFactory) → None :

C++ signature :

void SetDistributedVectorFactory(VertexMesh<3u, 3u> {lvalue},DistributedVectorFactory*)

SetDistributedVectorFactory( (VertexMesh3_3)arg1, (object)pFactory) -> None :

C++ signature :

void SetDistributedVectorFactory(VertexMesh_less__3_comma__3__greater__wrapper {lvalue},DistributedVectorFactory*)

SetElementOwnerships((VertexMesh3_3)arg1) → None :

C++ signature :

void SetElementOwnerships(VertexMesh_less__3_comma__3__greater__wrapper {lvalue})

SolveBoundaryElementMapping((VertexMesh3_3)arg1, (int)index) → int :

C++ signature :

unsigned int SolveBoundaryElementMapping(VertexMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

SolveElementMapping((VertexMesh3_3)arg1, (int)index) → int :

C++ signature :

unsigned int SolveElementMapping(VertexMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

SolveNodeMapping((VertexMesh3_3)arg1, (int)index) → int :

C++ signature :

unsigned int SolveNodeMapping(VertexMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

Translate((VertexMesh3_3)arg1, (object)rDisplacement) → None :

C++ signature :

void Translate(VertexMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>)

Translate( (VertexMesh3_3)arg1, (object)rDisplacement) -> None :

C++ signature :

void Translate(VertexMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 3ul>)

Translate( (VertexMesh3_3)arg1 [, (float)xMovement=0.0 [, (float)yMovement=0.0 [, (float)zMovement=0.0]]]) -> None :

C++ signature :

void Translate(VertexMesh<3u, 3u> {lvalue} [,double=0.0 [,double=0.0 [,double=0.0]]])

class chaste.mesh.MutableVertexMesh2_2

AddElement((MutableVertexMesh2_2)arg1, (object)pNewElement) → int :

C++ signature :

unsigned int AddElement(MutableVertexMesh<2u, 2u> {lvalue},VertexElement<2u, 2u>*)

AddNode((MutableVertexMesh2_2)arg1, (Node2)pNewNode) → int :

C++ signature :

unsigned int AddNode(MutableVertexMesh<2u, 2u> {lvalue},Node<2u>*)

CalculateAreaOfFace((MutableVertexMesh2_2)arg1, (object)pFace) → float :

C++ signature :

double CalculateAreaOfFace(MutableVertexMesh<2u, 2u> {lvalue},VertexElement<1u, 2u>*)

CalculateAreaOfFace( (MutableVertexMesh2_2)arg1, (object)pFace) -> float :

C++ signature :

double CalculateAreaOfFace(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},VertexElement<1u, 2u>*)

CalculateBoundingBox((MutableVertexMesh2_2)arg1, (VecNodePtr2)rNodes) → object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},std::vector<Node<2u>*, std::allocator<Node<2u>*> >)

CalculateBoundingBox( (MutableVertexMesh2_2)arg1) -> object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(MutableVertexMesh<2u, 2u> {lvalue})

CalculateBoundingBox( (MutableVertexMesh2_2)arg1) -> object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue})

CalculateMomentsOfElement((MutableVertexMesh2_2)arg1, (int)index) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> CalculateMomentsOfElement(MutableVertexMesh<2u, 2u> {lvalue},unsigned int)

CalculateMomentsOfElement( (MutableVertexMesh2_2)arg1, (int)index) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> CalculateMomentsOfElement(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

CheckForIntersections((MutableVertexMesh2_2)arg1) → bool :

C++ signature :

bool CheckForIntersections(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue})

CheckForRosettes((MutableVertexMesh2_2)arg1) → None :

C++ signature :

void CheckForRosettes(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue})

CheckForSwapsFromShortEdges((MutableVertexMesh2_2)arg1) → bool :

C++ signature :

bool CheckForSwapsFromShortEdges(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue})

CheckForT2Swaps((MutableVertexMesh2_2)arg1, (object)rElementMap) → bool :

C++ signature :

bool CheckForT2Swaps(MutableVertexMesh<2u, 2u> {lvalue},VertexElementMap {lvalue})

Clear((MutableVertexMesh2_2)arg1) → None :

C++ signature :

void Clear(MutableVertexMesh<2u, 2u> {lvalue})

Clear( (MutableVertexMesh2_2)arg1) -> None :

C++ signature :

void Clear(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue})

ClearLocationsOfT1Swaps((MutableVertexMesh2_2)arg1) → None :

C++ signature :

void ClearLocationsOfT1Swaps(MutableVertexMesh<2u, 2u> {lvalue})

ClearLocationsOfT3Swaps((MutableVertexMesh2_2)arg1) → None :

C++ signature :

void ClearLocationsOfT3Swaps(MutableVertexMesh<2u, 2u> {lvalue})

DeleteElementPriorToReMesh((MutableVertexMesh2_2)arg1, (int)index) → None :

C++ signature :

void DeleteElementPriorToReMesh(MutableVertexMesh<2u, 2u> {lvalue},unsigned int)

DeleteNodePriorToReMesh((MutableVertexMesh2_2)arg1, (int)index) → None :

C++ signature :

void DeleteNodePriorToReMesh(MutableVertexMesh<2u, 2u> {lvalue},unsigned int)

DivideEdge((MutableVertexMesh2_2)arg1, (Node2)pNodeA, (Node2)pNodeB) → None :

C++ signature :

void DivideEdge(MutableVertexMesh<2u, 2u> {lvalue},Node<2u>*,Node<2u>*)

DivideElement((MutableVertexMesh2_2)arg1, (object)pElement, (int)nodeAIndex, (int)nodeBIndex[, (bool)placeOriginalElementBelow=False]) → int :

C++ signature :

unsigned int DivideElement(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},VertexElement<2u, 2u>*,unsigned int,unsigned int [,bool=False])

DivideElementAlongGivenAxis((MutableVertexMesh2_2)arg1, (object)pElement, (object)axisOfDivision[, (bool)placeOriginalElementBelow=False]) → int :

C++ signature :

unsigned int DivideElementAlongGivenAxis(MutableVertexMesh<2u, 2u> {lvalue},VertexElement<2u, 2u>*,boost::numeric::ublas::c_vector<double, 2ul> [,bool=False])

DivideElementAlongShortAxis((MutableVertexMesh2_2)arg1, (object)pElement[, (bool)placeOriginalElementBelow=False]) → int :

C++ signature :

unsigned int DivideElementAlongShortAxis(MutableVertexMesh<2u, 2u> {lvalue},VertexElement<2u, 2u>* [,bool=False])

ElementIncludesPoint((MutableVertexMesh2_2)arg1, (object)rTestPoint, (int)elementIndex) → bool :

C++ signature :

bool ElementIncludesPoint(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,unsigned int)

GenerateVerticesFromElementCircumcentres((MutableVertexMesh2_2)arg1, (TetrahedralMesh2_2)rMesh) → None :

C++ signature :

void GenerateVerticesFromElementCircumcentres(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},TetrahedralMesh<2u, 2u> {lvalue})

GetCellRearrangementRatio((MutableVertexMesh2_2)arg1) → float :

C++ signature :

double GetCellRearrangementRatio(MutableVertexMesh<2u, 2u> {lvalue})

GetCellRearrangementThreshold((MutableVertexMesh2_2)arg1) → float :

C++ signature :

double GetCellRearrangementThreshold(MutableVertexMesh<2u, 2u> {lvalue})

GetCentroidOfElement((MutableVertexMesh2_2)arg1, (int)index) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetCentroidOfElement(MutableVertexMesh<2u, 2u> {lvalue},unsigned int)

GetCentroidOfElement( (MutableVertexMesh2_2)arg1, (int)index) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetCentroidOfElement(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

GetCheckForInternalIntersections((MutableVertexMesh2_2)arg1) → bool :

C++ signature :

bool GetCheckForInternalIntersections(MutableVertexMesh<2u, 2u> {lvalue})

GetLastT2SwapLocation((MutableVertexMesh2_2)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetLastT2SwapLocation(MutableVertexMesh<2u, 2u> {lvalue})

GetLocalIndexForElementEdgeClosestToPoint((MutableVertexMesh2_2)arg1, (object)rTestPoint, (int)elementIndex) → int :

C++ signature :

unsigned int GetLocalIndexForElementEdgeClosestToPoint(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,unsigned int)

GetLocationsOfT1Swaps((MutableVertexMesh2_2)arg1) → VecCVectorDouble_2 :

C++ signature :

std::vector<boost::numeric::ublas::c_vector<double, 2ul>, std::allocator<boost::numeric::ublas::c_vector<double, 2ul> > > GetLocationsOfT1Swaps(MutableVertexMesh<2u, 2u> {lvalue})

GetLocationsOfT3Swaps((MutableVertexMesh2_2)arg1) → VecCVectorDouble_2 :

C++ signature :

std::vector<boost::numeric::ublas::c_vector<double, 2ul>, std::allocator<boost::numeric::ublas::c_vector<double, 2ul> > > GetLocationsOfT3Swaps(MutableVertexMesh<2u, 2u> {lvalue})

GetNearestNodeIndex((MutableVertexMesh2_2)arg1, (ChastePoint2)rTestPoint) → int :

C++ signature :

unsigned int GetNearestNodeIndex(MutableVertexMesh<2u, 2u> {lvalue},ChastePoint<2u>)

GetNearestNodeIndex( (MutableVertexMesh2_2)arg1, (ChastePoint2)rTestPoint) -> int :

C++ signature :

unsigned int GetNearestNodeIndex(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},ChastePoint<2u>)

GetNumAllNodes((MutableVertexMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumAllNodes(MutableVertexMesh<2u, 2u> {lvalue})

GetNumAllNodes( (MutableVertexMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumAllNodes(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumElements((MutableVertexMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumElements(MutableVertexMesh<2u, 2u> {lvalue})

GetNumElements( (MutableVertexMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumElements(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumFaces((MutableVertexMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumFaces(MutableVertexMesh<2u, 2u> {lvalue})

GetNumFaces( (MutableVertexMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumFaces(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue})

GetNumNodes((MutableVertexMesh2_2)arg1) → int :

C++ signature :

unsigned int GetNumNodes(MutableVertexMesh<2u, 2u> {lvalue})

GetNumNodes( (MutableVertexMesh2_2)arg1) -> int :

C++ signature :

unsigned int GetNumNodes(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue})

GetProtorosetteFormationProbability((MutableVertexMesh2_2)arg1) → float :

C++ signature :

double GetProtorosetteFormationProbability(MutableVertexMesh<2u, 2u> {lvalue})

GetProtorosetteResolutionProbabilityPerTimestep((MutableVertexMesh2_2)arg1) → float :

C++ signature :

double GetProtorosetteResolutionProbabilityPerTimestep(MutableVertexMesh<2u, 2u> {lvalue})

GetRosetteResolutionProbabilityPerTimestep((MutableVertexMesh2_2)arg1) → float :

C++ signature :

double GetRosetteResolutionProbabilityPerTimestep(MutableVertexMesh<2u, 2u> {lvalue})

GetSurfaceAreaOfElement((MutableVertexMesh2_2)arg1, (int)index) → float :

C++ signature :

double GetSurfaceAreaOfElement(MutableVertexMesh<2u, 2u> {lvalue},unsigned int)

GetSurfaceAreaOfElement( (MutableVertexMesh2_2)arg1, (int)index) -> float :

C++ signature :

double GetSurfaceAreaOfElement(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

GetT2Threshold((MutableVertexMesh2_2)arg1) → float :

C++ signature :

double GetT2Threshold(MutableVertexMesh<2u, 2u> {lvalue})

GetVectorFromAtoB((MutableVertexMesh2_2)arg1, (object)rLocationA, (object)rLocationB) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetVectorFromAtoB(MutableVertexMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,boost::numeric::ublas::c_vector<double, 2ul>)

GetVectorFromAtoB( (MutableVertexMesh2_2)arg1, (object)rLocationA, (object)rLocationB) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetVectorFromAtoB(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,boost::numeric::ublas::c_vector<double, 2ul>)

GetVolumeOfElement((MutableVertexMesh2_2)arg1, (int)index) → float :

C++ signature :

double GetVolumeOfElement(MutableVertexMesh<2u, 2u> {lvalue},unsigned int)

GetVolumeOfElement( (MutableVertexMesh2_2)arg1, (int)index) -> float :

C++ signature :

double GetVolumeOfElement(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

GetWidth((MutableVertexMesh2_2)arg1, (int)rDimension) → float :

C++ signature :

double GetWidth(MutableVertexMesh<2u, 2u> {lvalue},unsigned int)

GetWidth( (MutableVertexMesh2_2)arg1, (int)rDimension) -> float :

C++ signature :

double GetWidth(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

HandleHighOrderJunctions((MutableVertexMesh2_2)arg1, (Node2)pNodeA, (Node2)pNodeB) → None :

C++ signature :

void HandleHighOrderJunctions(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},Node<2u>*,Node<2u>*)

IdentifySwapType((MutableVertexMesh2_2)arg1, (Node2)pNodeA, (Node2)pNodeB) → None :

C++ signature :

void IdentifySwapType(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},Node<2u>*,Node<2u>*)

PerformIntersectionSwap((MutableVertexMesh2_2)arg1, (Node2)pNode, (int)elementIndex) → None :

C++ signature :

void PerformIntersectionSwap(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},Node<2u>*,unsigned int)

PerformNodeMerge((MutableVertexMesh2_2)arg1, (Node2)pNodeA, (Node2)pNodeB) → None :

C++ signature :

void PerformNodeMerge(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},Node<2u>*,Node<2u>*)

PerformProtorosetteResolution((MutableVertexMesh2_2)arg1, (Node2)pProtorosetteNode) → None :

C++ signature :

void PerformProtorosetteResolution(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},Node<2u>*)

PerformRosetteRankDecrease((MutableVertexMesh2_2)arg1, (Node2)pRosetteNode) → None :

C++ signature :

void PerformRosetteRankDecrease(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},Node<2u>*)

PerformRosetteRankIncrease((MutableVertexMesh2_2)arg1, (Node2)pNodeA, (Node2)pNodeB) → None :

C++ signature :

void PerformRosetteRankIncrease(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},Node<2u>*,Node<2u>*)

PerformT1Swap((MutableVertexMesh2_2)arg1, (Node2)pNodeA, (Node2)pNodeB, (SetUnsigned)rElementsContainingNodes) → None :

C++ signature :

void PerformT1Swap(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},Node<2u>*,Node<2u>*,std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> > {lvalue})

PerformT2Swap((MutableVertexMesh2_2)arg1, (object)rElement) → None :

C++ signature :

void PerformT2Swap(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},VertexElement<2u, 2u> {lvalue})

PerformT3Swap((MutableVertexMesh2_2)arg1, (Node2)pNode, (int)elementIndex) → None :

C++ signature :

void PerformT3Swap(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},Node<2u>*,unsigned int)

PerformVoidRemoval((MutableVertexMesh2_2)arg1, (Node2)pNodeA, (Node2)pNodeB, (Node2)pNodeC) → None :

C++ signature :

void PerformVoidRemoval(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},Node<2u>*,Node<2u>*,Node<2u>*)

PermuteNodes((MutableVertexMesh2_2)arg1) → None :

C++ signature :

void PermuteNodes(MutableVertexMesh<2u, 2u> {lvalue})

PermuteNodes( (MutableVertexMesh2_2)arg1) -> None :

C++ signature :

void PermuteNodes(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue})

ReMesh((MutableVertexMesh2_2)arg1, (object)rElementMap) → None :

C++ signature :

void ReMesh(MutableVertexMesh<2u, 2u> {lvalue},VertexElementMap {lvalue})

ReMesh( (MutableVertexMesh2_2)arg1, (object)rElementMap) -> None :

C++ signature :

void ReMesh(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},VertexElementMap {lvalue})

ReMesh( (MutableVertexMesh2_2)arg1) -> None :

C++ signature :

void ReMesh(MutableVertexMesh<2u, 2u> {lvalue})

ReadNodesPerProcessorFile((MutableVertexMesh2_2)arg1, (str)rNodesPerProcessorFile) → None :

C++ signature :

void ReadNodesPerProcessorFile(MutableVertexMesh<2u, 2u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

ReadNodesPerProcessorFile( (MutableVertexMesh2_2)arg1, (str)rNodesPerProcessorFile) -> None :

C++ signature :

void ReadNodesPerProcessorFile(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

RefreshMesh((MutableVertexMesh2_2)arg1) → None :

C++ signature :

void RefreshMesh(MutableVertexMesh<2u, 2u> {lvalue})

RefreshMesh( (MutableVertexMesh2_2)arg1) -> None :

C++ signature :

void RefreshMesh(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue})

RemoveDeletedNodes((MutableVertexMesh2_2)arg1) → None :

C++ signature :

void RemoveDeletedNodes(MutableVertexMesh<2u, 2u> {lvalue})

RemoveDeletedNodesAndElements((MutableVertexMesh2_2)arg1, (object)rElementMap) → None :

C++ signature :

void RemoveDeletedNodesAndElements(MutableVertexMesh<2u, 2u> {lvalue},VertexElementMap {lvalue})

Rotate((MutableVertexMesh2_2)arg1, (object)rotationMatrix) → None :

C++ signature :

void Rotate(MutableVertexMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul>)

Rotate( (MutableVertexMesh2_2)arg1, (object)rotationMatrix) -> None :

C++ signature :

void Rotate(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul>)

Rotate( (MutableVertexMesh2_2)arg1, (object)axis, (float)angle) -> None :

C++ signature :

void Rotate(MutableVertexMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,double)

Rotate( (MutableVertexMesh2_2)arg1, (float)theta) -> None :

C++ signature :

void Rotate(MutableVertexMesh<2u, 2u> {lvalue},double)

Scale((MutableVertexMesh2_2)arg1[, (float)xFactor=1.0[, (float)yFactor=1.0[, (float)zFactor=1.0]]]) → None :

C++ signature :

void Scale(MutableVertexMesh<2u, 2u> {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

Scale( (MutableVertexMesh2_2)arg1 [, (float)xFactor=1.0 [, (float)yFactor=1.0 [, (float)zFactor=1.0]]]) -> None :

C++ signature :

void Scale(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

SetCellRearrangementRatio((MutableVertexMesh2_2)arg1, (float)cellRearrangementRatio) → None :

C++ signature :

void SetCellRearrangementRatio(MutableVertexMesh<2u, 2u> {lvalue},double)

SetCellRearrangementThreshold((MutableVertexMesh2_2)arg1, (float)cellRearrangementThreshold) → None :

C++ signature :

void SetCellRearrangementThreshold(MutableVertexMesh<2u, 2u> {lvalue},double)

SetCheckForInternalIntersections((MutableVertexMesh2_2)arg1, (bool)checkForInternalIntersections) → None :

C++ signature :

void SetCheckForInternalIntersections(MutableVertexMesh<2u, 2u> {lvalue},bool)

SetDistributedVectorFactory((MutableVertexMesh2_2)arg1, (object)pFactory) → None :

C++ signature :

void SetDistributedVectorFactory(MutableVertexMesh<2u, 2u> {lvalue},DistributedVectorFactory*)

SetDistributedVectorFactory( (MutableVertexMesh2_2)arg1, (object)pFactory) -> None :

C++ signature :

void SetDistributedVectorFactory(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},DistributedVectorFactory*)

SetElementOwnerships((MutableVertexMesh2_2)arg1) → None :

C++ signature :

void SetElementOwnerships(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue})

SetNode((MutableVertexMesh2_2)arg1, (int)nodeIndex, (ChastePoint2)point) → None :

C++ signature :

void SetNode(MutableVertexMesh<2u, 2u> {lvalue},unsigned int,ChastePoint<2u>)

SetNode( (MutableVertexMesh2_2)arg1, (int)nodeIndex, (ChastePoint2)point) -> None :

C++ signature :

void SetNode(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int,ChastePoint<2u>)

SetProtorosetteFormationProbability((MutableVertexMesh2_2)arg1, (float)protorosetteFormationProbability) → None :

C++ signature :

void SetProtorosetteFormationProbability(MutableVertexMesh<2u, 2u> {lvalue},double)

SetProtorosetteResolutionProbabilityPerTimestep((MutableVertexMesh2_2)arg1, (float)protorosetteResolutionProbabilityPerTimestep) → None :

C++ signature :

void SetProtorosetteResolutionProbabilityPerTimestep(MutableVertexMesh<2u, 2u> {lvalue},double)

SetRosetteResolutionProbabilityPerTimestep((MutableVertexMesh2_2)arg1, (float)rosetteResolutionProbabilityPerTimestep) → None :

C++ signature :

void SetRosetteResolutionProbabilityPerTimestep(MutableVertexMesh<2u, 2u> {lvalue},double)

SetT2Threshold((MutableVertexMesh2_2)arg1, (float)t2Threshold) → None :

C++ signature :

void SetT2Threshold(MutableVertexMesh<2u, 2u> {lvalue},double)

SolveBoundaryElementMapping((MutableVertexMesh2_2)arg1, (int)index) → int :

C++ signature :

unsigned int SolveBoundaryElementMapping(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

SolveElementMapping((MutableVertexMesh2_2)arg1, (int)index) → int :

C++ signature :

unsigned int SolveElementMapping(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

SolveNodeMapping((MutableVertexMesh2_2)arg1, (int)index) → int :

C++ signature :

unsigned int SolveNodeMapping(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int)

Translate((MutableVertexMesh2_2)arg1, (object)rDisplacement) → None :

C++ signature :

void Translate(MutableVertexMesh<2u, 2u> {lvalue},boost::numeric::ublas::c_vector<double, 2ul>)

Translate( (MutableVertexMesh2_2)arg1, (object)rDisplacement) -> None :

C++ signature :

void Translate(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>)

Translate( (MutableVertexMesh2_2)arg1 [, (float)xMovement=0.0 [, (float)yMovement=0.0 [, (float)zMovement=0.0]]]) -> None :

C++ signature :

void Translate(MutableVertexMesh<2u, 2u> {lvalue} [,double=0.0 [,double=0.0 [,double=0.0]]])

WidenEdgeOrCorrectIntersectionLocationIfNecessary((MutableVertexMesh2_2)arg1, (int)indexA, (int)indexB, (object)intersection) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> WidenEdgeOrCorrectIntersectionLocationIfNecessary(MutableVertexMesh_less__2_comma__2__greater__wrapper {lvalue},unsigned int,unsigned int,boost::numeric::ublas::c_vector<double, 2ul>)

class chaste.mesh.MutableVertexMesh3_3

AddElement((MutableVertexMesh3_3)arg1, (object)pNewElement) → int :

C++ signature :

unsigned int AddElement(MutableVertexMesh<3u, 3u> {lvalue},VertexElement<3u, 3u>*)

AddNode((MutableVertexMesh3_3)arg1, (Node3)pNewNode) → int :

C++ signature :

unsigned int AddNode(MutableVertexMesh<3u, 3u> {lvalue},Node<3u>*)

CalculateAreaOfFace((MutableVertexMesh3_3)arg1, (object)pFace) → float :

C++ signature :

double CalculateAreaOfFace(MutableVertexMesh<3u, 3u> {lvalue},VertexElement<2u, 3u>*)

CalculateAreaOfFace( (MutableVertexMesh3_3)arg1, (object)pFace) -> float :

C++ signature :

double CalculateAreaOfFace(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},VertexElement<2u, 3u>*)

CalculateBoundingBox((MutableVertexMesh3_3)arg1, (VecNodePtr3)rNodes) → object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},std::vector<Node<3u>*, std::allocator<Node<3u>*> >)

CalculateBoundingBox( (MutableVertexMesh3_3)arg1) -> object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(MutableVertexMesh<3u, 3u> {lvalue})

CalculateBoundingBox( (MutableVertexMesh3_3)arg1) -> object :

C++ signature :

ChasteCuboid<3u> CalculateBoundingBox(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue})

CalculateMomentsOfElement((MutableVertexMesh3_3)arg1, (int)index) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> CalculateMomentsOfElement(MutableVertexMesh<3u, 3u> {lvalue},unsigned int)

CalculateMomentsOfElement( (MutableVertexMesh3_3)arg1, (int)index) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> CalculateMomentsOfElement(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

CheckForIntersections((MutableVertexMesh3_3)arg1) → bool :

C++ signature :

bool CheckForIntersections(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue})

CheckForRosettes((MutableVertexMesh3_3)arg1) → None :

C++ signature :

void CheckForRosettes(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue})

CheckForSwapsFromShortEdges((MutableVertexMesh3_3)arg1) → bool :

C++ signature :

bool CheckForSwapsFromShortEdges(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue})

CheckForT2Swaps((MutableVertexMesh3_3)arg1, (object)rElementMap) → bool :

C++ signature :

bool CheckForT2Swaps(MutableVertexMesh<3u, 3u> {lvalue},VertexElementMap {lvalue})

Clear((MutableVertexMesh3_3)arg1) → None :

C++ signature :

void Clear(MutableVertexMesh<3u, 3u> {lvalue})

Clear( (MutableVertexMesh3_3)arg1) -> None :

C++ signature :

void Clear(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue})

ClearLocationsOfT1Swaps((MutableVertexMesh3_3)arg1) → None :

C++ signature :

void ClearLocationsOfT1Swaps(MutableVertexMesh<3u, 3u> {lvalue})

ClearLocationsOfT3Swaps((MutableVertexMesh3_3)arg1) → None :

C++ signature :

void ClearLocationsOfT3Swaps(MutableVertexMesh<3u, 3u> {lvalue})

DeleteElementPriorToReMesh((MutableVertexMesh3_3)arg1, (int)index) → None :

C++ signature :

void DeleteElementPriorToReMesh(MutableVertexMesh<3u, 3u> {lvalue},unsigned int)

DeleteNodePriorToReMesh((MutableVertexMesh3_3)arg1, (int)index) → None :

C++ signature :

void DeleteNodePriorToReMesh(MutableVertexMesh<3u, 3u> {lvalue},unsigned int)

DivideEdge((MutableVertexMesh3_3)arg1, (Node3)pNodeA, (Node3)pNodeB) → None :

C++ signature :

void DivideEdge(MutableVertexMesh<3u, 3u> {lvalue},Node<3u>*,Node<3u>*)

DivideElement((MutableVertexMesh3_3)arg1, (object)pElement, (int)nodeAIndex, (int)nodeBIndex[, (bool)placeOriginalElementBelow=False]) → int :

C++ signature :

unsigned int DivideElement(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},VertexElement<3u, 3u>*,unsigned int,unsigned int [,bool=False])

DivideElementAlongGivenAxis((MutableVertexMesh3_3)arg1, (object)pElement, (object)axisOfDivision[, (bool)placeOriginalElementBelow=False]) → int :

C++ signature :

unsigned int DivideElementAlongGivenAxis(MutableVertexMesh<3u, 3u> {lvalue},VertexElement<3u, 3u>*,boost::numeric::ublas::c_vector<double, 3ul> [,bool=False])

DivideElementAlongShortAxis((MutableVertexMesh3_3)arg1, (object)pElement[, (bool)placeOriginalElementBelow=False]) → int :

C++ signature :

unsigned int DivideElementAlongShortAxis(MutableVertexMesh<3u, 3u> {lvalue},VertexElement<3u, 3u>* [,bool=False])

ElementIncludesPoint((MutableVertexMesh3_3)arg1, (object)rTestPoint, (int)elementIndex) → bool :

C++ signature :

bool ElementIncludesPoint(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,unsigned int)

GenerateVerticesFromElementCircumcentres((MutableVertexMesh3_3)arg1, (TetrahedralMesh3_3)rMesh) → None :

C++ signature :

void GenerateVerticesFromElementCircumcentres(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},TetrahedralMesh<3u, 3u> {lvalue})

GetCellRearrangementRatio((MutableVertexMesh3_3)arg1) → float :

C++ signature :

double GetCellRearrangementRatio(MutableVertexMesh<3u, 3u> {lvalue})

GetCellRearrangementThreshold((MutableVertexMesh3_3)arg1) → float :

C++ signature :

double GetCellRearrangementThreshold(MutableVertexMesh<3u, 3u> {lvalue})

GetCentroidOfElement((MutableVertexMesh3_3)arg1, (int)index) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetCentroidOfElement(MutableVertexMesh<3u, 3u> {lvalue},unsigned int)

GetCentroidOfElement( (MutableVertexMesh3_3)arg1, (int)index) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetCentroidOfElement(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

GetCheckForInternalIntersections((MutableVertexMesh3_3)arg1) → bool :

C++ signature :

bool GetCheckForInternalIntersections(MutableVertexMesh<3u, 3u> {lvalue})

GetLastT2SwapLocation((MutableVertexMesh3_3)arg1) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetLastT2SwapLocation(MutableVertexMesh<3u, 3u> {lvalue})

GetLocalIndexForElementEdgeClosestToPoint((MutableVertexMesh3_3)arg1, (object)rTestPoint, (int)elementIndex) → int :

C++ signature :

unsigned int GetLocalIndexForElementEdgeClosestToPoint(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,unsigned int)

GetLocationsOfT1Swaps((MutableVertexMesh3_3)arg1) → VecCVectorDouble_3 :

C++ signature :

std::vector<boost::numeric::ublas::c_vector<double, 3ul>, std::allocator<boost::numeric::ublas::c_vector<double, 3ul> > > GetLocationsOfT1Swaps(MutableVertexMesh<3u, 3u> {lvalue})

GetLocationsOfT3Swaps((MutableVertexMesh3_3)arg1) → VecCVectorDouble_3 :

C++ signature :

std::vector<boost::numeric::ublas::c_vector<double, 3ul>, std::allocator<boost::numeric::ublas::c_vector<double, 3ul> > > GetLocationsOfT3Swaps(MutableVertexMesh<3u, 3u> {lvalue})

GetNearestNodeIndex((MutableVertexMesh3_3)arg1, (ChastePoint3)rTestPoint) → int :

C++ signature :

unsigned int GetNearestNodeIndex(MutableVertexMesh<3u, 3u> {lvalue},ChastePoint<3u>)

GetNearestNodeIndex( (MutableVertexMesh3_3)arg1, (ChastePoint3)rTestPoint) -> int :

C++ signature :

unsigned int GetNearestNodeIndex(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},ChastePoint<3u>)

GetNumAllNodes((MutableVertexMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumAllNodes(MutableVertexMesh<3u, 3u> {lvalue})

GetNumAllNodes( (MutableVertexMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumAllNodes(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumElements((MutableVertexMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumElements(MutableVertexMesh<3u, 3u> {lvalue})

GetNumElements( (MutableVertexMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumElements(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumFaces((MutableVertexMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumFaces(MutableVertexMesh<3u, 3u> {lvalue})

GetNumFaces( (MutableVertexMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumFaces(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue})

GetNumNodes((MutableVertexMesh3_3)arg1) → int :

C++ signature :

unsigned int GetNumNodes(MutableVertexMesh<3u, 3u> {lvalue})

GetNumNodes( (MutableVertexMesh3_3)arg1) -> int :

C++ signature :

unsigned int GetNumNodes(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue})

GetProtorosetteFormationProbability((MutableVertexMesh3_3)arg1) → float :

C++ signature :

double GetProtorosetteFormationProbability(MutableVertexMesh<3u, 3u> {lvalue})

GetProtorosetteResolutionProbabilityPerTimestep((MutableVertexMesh3_3)arg1) → float :

C++ signature :

double GetProtorosetteResolutionProbabilityPerTimestep(MutableVertexMesh<3u, 3u> {lvalue})

GetRosetteResolutionProbabilityPerTimestep((MutableVertexMesh3_3)arg1) → float :

C++ signature :

double GetRosetteResolutionProbabilityPerTimestep(MutableVertexMesh<3u, 3u> {lvalue})

GetSurfaceAreaOfElement((MutableVertexMesh3_3)arg1, (int)index) → float :

C++ signature :

double GetSurfaceAreaOfElement(MutableVertexMesh<3u, 3u> {lvalue},unsigned int)

GetSurfaceAreaOfElement( (MutableVertexMesh3_3)arg1, (int)index) -> float :

C++ signature :

double GetSurfaceAreaOfElement(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

GetT2Threshold((MutableVertexMesh3_3)arg1) → float :

C++ signature :

double GetT2Threshold(MutableVertexMesh<3u, 3u> {lvalue})

GetVectorFromAtoB((MutableVertexMesh3_3)arg1, (object)rLocationA, (object)rLocationB) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetVectorFromAtoB(MutableVertexMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,boost::numeric::ublas::c_vector<double, 3ul>)

GetVectorFromAtoB( (MutableVertexMesh3_3)arg1, (object)rLocationA, (object)rLocationB) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> GetVectorFromAtoB(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,boost::numeric::ublas::c_vector<double, 3ul>)

GetVolumeOfElement((MutableVertexMesh3_3)arg1, (int)index) → float :

C++ signature :

double GetVolumeOfElement(MutableVertexMesh<3u, 3u> {lvalue},unsigned int)

GetVolumeOfElement( (MutableVertexMesh3_3)arg1, (int)index) -> float :

C++ signature :

double GetVolumeOfElement(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

GetWidth((MutableVertexMesh3_3)arg1, (int)rDimension) → float :

C++ signature :

double GetWidth(MutableVertexMesh<3u, 3u> {lvalue},unsigned int)

GetWidth( (MutableVertexMesh3_3)arg1, (int)rDimension) -> float :

C++ signature :

double GetWidth(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

HandleHighOrderJunctions((MutableVertexMesh3_3)arg1, (Node3)pNodeA, (Node3)pNodeB) → None :

C++ signature :

void HandleHighOrderJunctions(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},Node<3u>*,Node<3u>*)

IdentifySwapType((MutableVertexMesh3_3)arg1, (Node3)pNodeA, (Node3)pNodeB) → None :

C++ signature :

void IdentifySwapType(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},Node<3u>*,Node<3u>*)

PerformIntersectionSwap((MutableVertexMesh3_3)arg1, (Node3)pNode, (int)elementIndex) → None :

C++ signature :

void PerformIntersectionSwap(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},Node<3u>*,unsigned int)

PerformNodeMerge((MutableVertexMesh3_3)arg1, (Node3)pNodeA, (Node3)pNodeB) → None :

C++ signature :

void PerformNodeMerge(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},Node<3u>*,Node<3u>*)

PerformProtorosetteResolution((MutableVertexMesh3_3)arg1, (Node3)pProtorosetteNode) → None :

C++ signature :

void PerformProtorosetteResolution(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},Node<3u>*)

PerformRosetteRankDecrease((MutableVertexMesh3_3)arg1, (Node3)pRosetteNode) → None :

C++ signature :

void PerformRosetteRankDecrease(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},Node<3u>*)

PerformRosetteRankIncrease((MutableVertexMesh3_3)arg1, (Node3)pNodeA, (Node3)pNodeB) → None :

C++ signature :

void PerformRosetteRankIncrease(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},Node<3u>*,Node<3u>*)

PerformT1Swap((MutableVertexMesh3_3)arg1, (Node3)pNodeA, (Node3)pNodeB, (SetUnsigned)rElementsContainingNodes) → None :

C++ signature :

void PerformT1Swap(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},Node<3u>*,Node<3u>*,std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> > {lvalue})

PerformT2Swap((MutableVertexMesh3_3)arg1, (object)rElement) → None :

C++ signature :

void PerformT2Swap(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},VertexElement<3u, 3u> {lvalue})

PerformT3Swap((MutableVertexMesh3_3)arg1, (Node3)pNode, (int)elementIndex) → None :

C++ signature :

void PerformT3Swap(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},Node<3u>*,unsigned int)

PerformVoidRemoval((MutableVertexMesh3_3)arg1, (Node3)pNodeA, (Node3)pNodeB, (Node3)pNodeC) → None :

C++ signature :

void PerformVoidRemoval(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},Node<3u>*,Node<3u>*,Node<3u>*)

PermuteNodes((MutableVertexMesh3_3)arg1) → None :

C++ signature :

void PermuteNodes(MutableVertexMesh<3u, 3u> {lvalue})

PermuteNodes( (MutableVertexMesh3_3)arg1) -> None :

C++ signature :

void PermuteNodes(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue})

ReMesh((MutableVertexMesh3_3)arg1, (object)rElementMap) → None :

C++ signature :

void ReMesh(MutableVertexMesh<3u, 3u> {lvalue},VertexElementMap {lvalue})

ReMesh( (MutableVertexMesh3_3)arg1, (object)rElementMap) -> None :

C++ signature :

void ReMesh(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},VertexElementMap {lvalue})

ReMesh( (MutableVertexMesh3_3)arg1) -> None :

C++ signature :

void ReMesh(MutableVertexMesh<3u, 3u> {lvalue})

ReadNodesPerProcessorFile((MutableVertexMesh3_3)arg1, (str)rNodesPerProcessorFile) → None :

C++ signature :

void ReadNodesPerProcessorFile(MutableVertexMesh<3u, 3u> {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

ReadNodesPerProcessorFile( (MutableVertexMesh3_3)arg1, (str)rNodesPerProcessorFile) -> None :

C++ signature :

void ReadNodesPerProcessorFile(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

RefreshMesh((MutableVertexMesh3_3)arg1) → None :

C++ signature :

void RefreshMesh(MutableVertexMesh<3u, 3u> {lvalue})

RefreshMesh( (MutableVertexMesh3_3)arg1) -> None :

C++ signature :

void RefreshMesh(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue})

RemoveDeletedNodes((MutableVertexMesh3_3)arg1) → None :

C++ signature :

void RemoveDeletedNodes(MutableVertexMesh<3u, 3u> {lvalue})

RemoveDeletedNodesAndElements((MutableVertexMesh3_3)arg1, (object)rElementMap) → None :

C++ signature :

void RemoveDeletedNodesAndElements(MutableVertexMesh<3u, 3u> {lvalue},VertexElementMap {lvalue})

Rotate((MutableVertexMesh3_3)arg1, (object)rotationMatrix) → None :

C++ signature :

void Rotate(MutableVertexMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul>)

Rotate( (MutableVertexMesh3_3)arg1, (object)rotationMatrix) -> None :

C++ signature :

void Rotate(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_matrix<double, 3ul, 3ul>)

Rotate( (MutableVertexMesh3_3)arg1, (object)axis, (float)angle) -> None :

C++ signature :

void Rotate(MutableVertexMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,double)

Rotate( (MutableVertexMesh3_3)arg1, (float)theta) -> None :

C++ signature :

void Rotate(MutableVertexMesh<3u, 3u> {lvalue},double)

Scale((MutableVertexMesh3_3)arg1[, (float)xFactor=1.0[, (float)yFactor=1.0[, (float)zFactor=1.0]]]) → None :

C++ signature :

void Scale(MutableVertexMesh<3u, 3u> {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

Scale( (MutableVertexMesh3_3)arg1 [, (float)xFactor=1.0 [, (float)yFactor=1.0 [, (float)zFactor=1.0]]]) -> None :

C++ signature :

void Scale(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

SetCellRearrangementRatio((MutableVertexMesh3_3)arg1, (float)cellRearrangementRatio) → None :

C++ signature :

void SetCellRearrangementRatio(MutableVertexMesh<3u, 3u> {lvalue},double)

SetCellRearrangementThreshold((MutableVertexMesh3_3)arg1, (float)cellRearrangementThreshold) → None :

C++ signature :

void SetCellRearrangementThreshold(MutableVertexMesh<3u, 3u> {lvalue},double)

SetCheckForInternalIntersections((MutableVertexMesh3_3)arg1, (bool)checkForInternalIntersections) → None :

C++ signature :

void SetCheckForInternalIntersections(MutableVertexMesh<3u, 3u> {lvalue},bool)

SetDistributedVectorFactory((MutableVertexMesh3_3)arg1, (object)pFactory) → None :

C++ signature :

void SetDistributedVectorFactory(MutableVertexMesh<3u, 3u> {lvalue},DistributedVectorFactory*)

SetDistributedVectorFactory( (MutableVertexMesh3_3)arg1, (object)pFactory) -> None :

C++ signature :

void SetDistributedVectorFactory(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},DistributedVectorFactory*)

SetElementOwnerships((MutableVertexMesh3_3)arg1) → None :

C++ signature :

void SetElementOwnerships(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue})

SetNode((MutableVertexMesh3_3)arg1, (int)nodeIndex, (ChastePoint3)point) → None :

C++ signature :

void SetNode(MutableVertexMesh<3u, 3u> {lvalue},unsigned int,ChastePoint<3u>)

SetNode( (MutableVertexMesh3_3)arg1, (int)nodeIndex, (ChastePoint3)point) -> None :

C++ signature :

void SetNode(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int,ChastePoint<3u>)

SetProtorosetteFormationProbability((MutableVertexMesh3_3)arg1, (float)protorosetteFormationProbability) → None :

C++ signature :

void SetProtorosetteFormationProbability(MutableVertexMesh<3u, 3u> {lvalue},double)

SetProtorosetteResolutionProbabilityPerTimestep((MutableVertexMesh3_3)arg1, (float)protorosetteResolutionProbabilityPerTimestep) → None :

C++ signature :

void SetProtorosetteResolutionProbabilityPerTimestep(MutableVertexMesh<3u, 3u> {lvalue},double)

SetRosetteResolutionProbabilityPerTimestep((MutableVertexMesh3_3)arg1, (float)rosetteResolutionProbabilityPerTimestep) → None :

C++ signature :

void SetRosetteResolutionProbabilityPerTimestep(MutableVertexMesh<3u, 3u> {lvalue},double)

SetT2Threshold((MutableVertexMesh3_3)arg1, (float)t2Threshold) → None :

C++ signature :

void SetT2Threshold(MutableVertexMesh<3u, 3u> {lvalue},double)

SolveBoundaryElementMapping((MutableVertexMesh3_3)arg1, (int)index) → int :

C++ signature :

unsigned int SolveBoundaryElementMapping(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

SolveElementMapping((MutableVertexMesh3_3)arg1, (int)index) → int :

C++ signature :

unsigned int SolveElementMapping(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

SolveNodeMapping((MutableVertexMesh3_3)arg1, (int)index) → int :

C++ signature :

unsigned int SolveNodeMapping(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int)

Translate((MutableVertexMesh3_3)arg1, (object)rDisplacement) → None :

C++ signature :

void Translate(MutableVertexMesh<3u, 3u> {lvalue},boost::numeric::ublas::c_vector<double, 3ul>)

Translate( (MutableVertexMesh3_3)arg1, (object)rDisplacement) -> None :

C++ signature :

void Translate(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},boost::numeric::ublas::c_vector<double, 3ul>)

Translate( (MutableVertexMesh3_3)arg1 [, (float)xMovement=0.0 [, (float)yMovement=0.0 [, (float)zMovement=0.0]]]) -> None :

C++ signature :

void Translate(MutableVertexMesh<3u, 3u> {lvalue} [,double=0.0 [,double=0.0 [,double=0.0]]])

WidenEdgeOrCorrectIntersectionLocationIfNecessary((MutableVertexMesh3_3)arg1, (int)indexA, (int)indexB, (object)intersection) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> WidenEdgeOrCorrectIntersectionLocationIfNecessary(MutableVertexMesh_less__3_comma__3__greater__wrapper {lvalue},unsigned int,unsigned int,boost::numeric::ublas::c_vector<double, 2ul>)

class chaste.mesh.Cylindrical2dVertexMesh

AddNode((Cylindrical2dVertexMesh)arg1, (Node2)pNewNode) → int :

C++ signature :

unsigned int AddNode(Cylindrical2dVertexMesh {lvalue},Node<2u>*)

CalculateAreaOfFace((Cylindrical2dVertexMesh)arg1, (object)pFace) → float :

C++ signature :

double CalculateAreaOfFace(Cylindrical2dVertexMesh {lvalue},VertexElement<1u, 2u>*)

CalculateAreaOfFace( (Cylindrical2dVertexMesh)arg1, (object)pFace) -> float :

C++ signature :

double CalculateAreaOfFace(Cylindrical2dVertexMesh_wrapper {lvalue},VertexElement<1u, 2u>*)

CalculateBoundingBox((Cylindrical2dVertexMesh)arg1, (VecNodePtr2)rNodes) → object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(Cylindrical2dVertexMesh_wrapper {lvalue},std::vector<Node<2u>*, std::allocator<Node<2u>*> >)

CalculateBoundingBox( (Cylindrical2dVertexMesh)arg1) -> object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(Cylindrical2dVertexMesh {lvalue})

CalculateBoundingBox( (Cylindrical2dVertexMesh)arg1) -> object :

C++ signature :

ChasteCuboid<2u> CalculateBoundingBox(Cylindrical2dVertexMesh_wrapper {lvalue})

CalculateMomentsOfElement((Cylindrical2dVertexMesh)arg1, (int)index) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> CalculateMomentsOfElement(Cylindrical2dVertexMesh {lvalue},unsigned int)

CalculateMomentsOfElement( (Cylindrical2dVertexMesh)arg1, (int)index) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 3ul> CalculateMomentsOfElement(Cylindrical2dVertexMesh_wrapper {lvalue},unsigned int)

CheckForIntersections((Cylindrical2dVertexMesh)arg1) → bool :

C++ signature :

bool CheckForIntersections(Cylindrical2dVertexMesh_wrapper {lvalue})

CheckForRosettes((Cylindrical2dVertexMesh)arg1) → None :

C++ signature :

void CheckForRosettes(Cylindrical2dVertexMesh_wrapper {lvalue})

CheckForSwapsFromShortEdges((Cylindrical2dVertexMesh)arg1) → bool :

C++ signature :

bool CheckForSwapsFromShortEdges(Cylindrical2dVertexMesh_wrapper {lvalue})

Clear((Cylindrical2dVertexMesh)arg1) → None :

C++ signature :

void Clear(Cylindrical2dVertexMesh {lvalue})

Clear( (Cylindrical2dVertexMesh)arg1) -> None :

C++ signature :

void Clear(Cylindrical2dVertexMesh_wrapper {lvalue})

DivideElement((Cylindrical2dVertexMesh)arg1, (object)pElement, (int)nodeAIndex, (int)nodeBIndex[, (bool)placeOriginalElementBelow=False]) → int :

C++ signature :

unsigned int DivideElement(Cylindrical2dVertexMesh_wrapper {lvalue},VertexElement<2u, 2u>*,unsigned int,unsigned int [,bool=False])

ElementIncludesPoint((Cylindrical2dVertexMesh)arg1, (object)rTestPoint, (int)elementIndex) → bool :

C++ signature :

bool ElementIncludesPoint(Cylindrical2dVertexMesh_wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,unsigned int)

GenerateVerticesFromElementCircumcentres((Cylindrical2dVertexMesh)arg1, (TetrahedralMesh2_2)rMesh) → None :

C++ signature :

void GenerateVerticesFromElementCircumcentres(Cylindrical2dVertexMesh_wrapper {lvalue},TetrahedralMesh<2u, 2u> {lvalue})

GetCentroidOfElement((Cylindrical2dVertexMesh)arg1, (int)index) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetCentroidOfElement(Cylindrical2dVertexMesh {lvalue},unsigned int)

GetCentroidOfElement( (Cylindrical2dVertexMesh)arg1, (int)index) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetCentroidOfElement(Cylindrical2dVertexMesh_wrapper {lvalue},unsigned int)

GetLocalIndexForElementEdgeClosestToPoint((Cylindrical2dVertexMesh)arg1, (object)rTestPoint, (int)elementIndex) → int :

C++ signature :

unsigned int GetLocalIndexForElementEdgeClosestToPoint(Cylindrical2dVertexMesh_wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,unsigned int)

GetNearestNodeIndex((Cylindrical2dVertexMesh)arg1, (ChastePoint2)rTestPoint) → int :

C++ signature :

unsigned int GetNearestNodeIndex(Cylindrical2dVertexMesh {lvalue},ChastePoint<2u>)

GetNearestNodeIndex( (Cylindrical2dVertexMesh)arg1, (ChastePoint2)rTestPoint) -> int :

C++ signature :

unsigned int GetNearestNodeIndex(Cylindrical2dVertexMesh_wrapper {lvalue},ChastePoint<2u>)

GetNumAllNodes((Cylindrical2dVertexMesh)arg1) → int :

C++ signature :

unsigned int GetNumAllNodes(Cylindrical2dVertexMesh {lvalue})

GetNumAllNodes( (Cylindrical2dVertexMesh)arg1) -> int :

C++ signature :

unsigned int GetNumAllNodes(Cylindrical2dVertexMesh_wrapper {lvalue})

GetNumElements((Cylindrical2dVertexMesh)arg1) → int :

C++ signature :

unsigned int GetNumElements(Cylindrical2dVertexMesh {lvalue})

GetNumElements( (Cylindrical2dVertexMesh)arg1) -> int :

C++ signature :

unsigned int GetNumElements(Cylindrical2dVertexMesh_wrapper {lvalue})

GetNumFaces((Cylindrical2dVertexMesh)arg1) → int :

C++ signature :

unsigned int GetNumFaces(Cylindrical2dVertexMesh {lvalue})

GetNumFaces( (Cylindrical2dVertexMesh)arg1) -> int :

C++ signature :

unsigned int GetNumFaces(Cylindrical2dVertexMesh_wrapper {lvalue})

GetNumNodes((Cylindrical2dVertexMesh)arg1) → int :

C++ signature :

unsigned int GetNumNodes(Cylindrical2dVertexMesh {lvalue})

GetNumNodes( (Cylindrical2dVertexMesh)arg1) -> int :

C++ signature :

unsigned int GetNumNodes(Cylindrical2dVertexMesh_wrapper {lvalue})

GetSurfaceAreaOfElement((Cylindrical2dVertexMesh)arg1, (int)index) → float :

C++ signature :

double GetSurfaceAreaOfElement(Cylindrical2dVertexMesh {lvalue},unsigned int)

GetSurfaceAreaOfElement( (Cylindrical2dVertexMesh)arg1, (int)index) -> float :

C++ signature :

double GetSurfaceAreaOfElement(Cylindrical2dVertexMesh_wrapper {lvalue},unsigned int)

GetVectorFromAtoB((Cylindrical2dVertexMesh)arg1, (object)rLocation1, (object)rLocation2) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetVectorFromAtoB(Cylindrical2dVertexMesh {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,boost::numeric::ublas::c_vector<double, 2ul>)

GetVectorFromAtoB( (Cylindrical2dVertexMesh)arg1, (object)rLocation1, (object)rLocation2) -> object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> GetVectorFromAtoB(Cylindrical2dVertexMesh_wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>,boost::numeric::ublas::c_vector<double, 2ul>)

GetVolumeOfElement((Cylindrical2dVertexMesh)arg1, (int)index) → float :

C++ signature :

double GetVolumeOfElement(Cylindrical2dVertexMesh {lvalue},unsigned int)

GetVolumeOfElement( (Cylindrical2dVertexMesh)arg1, (int)index) -> float :

C++ signature :

double GetVolumeOfElement(Cylindrical2dVertexMesh_wrapper {lvalue},unsigned int)

GetWidth((Cylindrical2dVertexMesh)arg1, (int)rDimension) → float :

C++ signature :

double GetWidth(Cylindrical2dVertexMesh {lvalue},unsigned int)

GetWidth( (Cylindrical2dVertexMesh)arg1, (int)rDimension) -> float :

C++ signature :

double GetWidth(Cylindrical2dVertexMesh_wrapper {lvalue},unsigned int)

HandleHighOrderJunctions((Cylindrical2dVertexMesh)arg1, (Node2)pNodeA, (Node2)pNodeB) → None :

C++ signature :

void HandleHighOrderJunctions(Cylindrical2dVertexMesh_wrapper {lvalue},Node<2u>*,Node<2u>*)

IdentifySwapType((Cylindrical2dVertexMesh)arg1, (Node2)pNodeA, (Node2)pNodeB) → None :

C++ signature :

void IdentifySwapType(Cylindrical2dVertexMesh_wrapper {lvalue},Node<2u>*,Node<2u>*)

PerformIntersectionSwap((Cylindrical2dVertexMesh)arg1, (Node2)pNode, (int)elementIndex) → None :

C++ signature :

void PerformIntersectionSwap(Cylindrical2dVertexMesh_wrapper {lvalue},Node<2u>*,unsigned int)

PerformNodeMerge((Cylindrical2dVertexMesh)arg1, (Node2)pNodeA, (Node2)pNodeB) → None :

C++ signature :

void PerformNodeMerge(Cylindrical2dVertexMesh_wrapper {lvalue},Node<2u>*,Node<2u>*)

PerformProtorosetteResolution((Cylindrical2dVertexMesh)arg1, (Node2)pProtorosetteNode) → None :

C++ signature :

void PerformProtorosetteResolution(Cylindrical2dVertexMesh_wrapper {lvalue},Node<2u>*)

PerformRosetteRankDecrease((Cylindrical2dVertexMesh)arg1, (Node2)pRosetteNode) → None :

C++ signature :

void PerformRosetteRankDecrease(Cylindrical2dVertexMesh_wrapper {lvalue},Node<2u>*)

PerformRosetteRankIncrease((Cylindrical2dVertexMesh)arg1, (Node2)pNodeA, (Node2)pNodeB) → None :

C++ signature :

void PerformRosetteRankIncrease(Cylindrical2dVertexMesh_wrapper {lvalue},Node<2u>*,Node<2u>*)

PerformT1Swap((Cylindrical2dVertexMesh)arg1, (Node2)pNodeA, (Node2)pNodeB, (SetUnsigned)rElementsContainingNodes) → None :

C++ signature :

void PerformT1Swap(Cylindrical2dVertexMesh_wrapper {lvalue},Node<2u>*,Node<2u>*,std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> > {lvalue})

PerformT2Swap((Cylindrical2dVertexMesh)arg1, (object)rElement) → None :

C++ signature :

void PerformT2Swap(Cylindrical2dVertexMesh_wrapper {lvalue},VertexElement<2u, 2u> {lvalue})

PerformT3Swap((Cylindrical2dVertexMesh)arg1, (Node2)pNode, (int)elementIndex) → None :

C++ signature :

void PerformT3Swap(Cylindrical2dVertexMesh_wrapper {lvalue},Node<2u>*,unsigned int)

PerformVoidRemoval((Cylindrical2dVertexMesh)arg1, (Node2)pNodeA, (Node2)pNodeB, (Node2)pNodeC) → None :

C++ signature :

void PerformVoidRemoval(Cylindrical2dVertexMesh_wrapper {lvalue},Node<2u>*,Node<2u>*,Node<2u>*)

PermuteNodes((Cylindrical2dVertexMesh)arg1) → None :

C++ signature :

void PermuteNodes(Cylindrical2dVertexMesh {lvalue})

PermuteNodes( (Cylindrical2dVertexMesh)arg1) -> None :

C++ signature :

void PermuteNodes(Cylindrical2dVertexMesh_wrapper {lvalue})

ReMesh((Cylindrical2dVertexMesh)arg1, (object)rElementMap) → None :

C++ signature :

void ReMesh(Cylindrical2dVertexMesh {lvalue},VertexElementMap {lvalue})

ReMesh( (Cylindrical2dVertexMesh)arg1, (object)rElementMap) -> None :

C++ signature :

void ReMesh(Cylindrical2dVertexMesh_wrapper {lvalue},VertexElementMap {lvalue})

ReMesh( (Cylindrical2dVertexMesh)arg1) -> None :

C++ signature :

void ReMesh(Cylindrical2dVertexMesh {lvalue})

ReadNodesPerProcessorFile((Cylindrical2dVertexMesh)arg1, (str)rNodesPerProcessorFile) → None :

C++ signature :

void ReadNodesPerProcessorFile(Cylindrical2dVertexMesh {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

ReadNodesPerProcessorFile( (Cylindrical2dVertexMesh)arg1, (str)rNodesPerProcessorFile) -> None :

C++ signature :

void ReadNodesPerProcessorFile(Cylindrical2dVertexMesh_wrapper {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

RefreshMesh((Cylindrical2dVertexMesh)arg1) → None :

C++ signature :

void RefreshMesh(Cylindrical2dVertexMesh {lvalue})

RefreshMesh( (Cylindrical2dVertexMesh)arg1) -> None :

C++ signature :

void RefreshMesh(Cylindrical2dVertexMesh_wrapper {lvalue})

Rotate((Cylindrical2dVertexMesh)arg1, (object)rotationMatrix) → None :

C++ signature :

void Rotate(Cylindrical2dVertexMesh {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul>)

Rotate( (Cylindrical2dVertexMesh)arg1, (object)rotationMatrix) -> None :

C++ signature :

void Rotate(Cylindrical2dVertexMesh_wrapper {lvalue},boost::numeric::ublas::c_matrix<double, 2ul, 2ul>)

Rotate( (Cylindrical2dVertexMesh)arg1, (object)axis, (float)angle) -> None :

C++ signature :

void Rotate(Cylindrical2dVertexMesh {lvalue},boost::numeric::ublas::c_vector<double, 3ul>,double)

Rotate( (Cylindrical2dVertexMesh)arg1, (float)theta) -> None :

C++ signature :

void Rotate(Cylindrical2dVertexMesh {lvalue},double)

Scale((Cylindrical2dVertexMesh)arg1[, (float)xScale=1.0[, (float)yScale=1.0[, (float)zScale=1.0]]]) → None :

C++ signature :

void Scale(Cylindrical2dVertexMesh {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

Scale( (Cylindrical2dVertexMesh)arg1 [, (float)xScale=1.0 [, (float)yScale=1.0 [, (float)zScale=1.0]]]) -> None :

C++ signature :

void Scale(Cylindrical2dVertexMesh_wrapper {lvalue} [,double=1.0 [,double=1.0 [,double=1.0]]])

SetDistributedVectorFactory((Cylindrical2dVertexMesh)arg1, (object)pFactory) → None :

C++ signature :

void SetDistributedVectorFactory(Cylindrical2dVertexMesh {lvalue},DistributedVectorFactory*)

SetDistributedVectorFactory( (Cylindrical2dVertexMesh)arg1, (object)pFactory) -> None :

C++ signature :

void SetDistributedVectorFactory(Cylindrical2dVertexMesh_wrapper {lvalue},DistributedVectorFactory*)

SetElementOwnerships((Cylindrical2dVertexMesh)arg1) → None :

C++ signature :

void SetElementOwnerships(Cylindrical2dVertexMesh_wrapper {lvalue})

SetNode((Cylindrical2dVertexMesh)arg1, (int)nodeIndex, (ChastePoint2)point) → None :

C++ signature :

void SetNode(Cylindrical2dVertexMesh {lvalue},unsigned int,ChastePoint<2u>)

SetNode( (Cylindrical2dVertexMesh)arg1, (int)nodeIndex, (ChastePoint2)point) -> None :

C++ signature :

void SetNode(Cylindrical2dVertexMesh_wrapper {lvalue},unsigned int,ChastePoint<2u>)

SolveBoundaryElementMapping((Cylindrical2dVertexMesh)arg1, (int)index) → int :

C++ signature :

unsigned int SolveBoundaryElementMapping(Cylindrical2dVertexMesh_wrapper {lvalue},unsigned int)

SolveElementMapping((Cylindrical2dVertexMesh)arg1, (int)index) → int :

C++ signature :

unsigned int SolveElementMapping(Cylindrical2dVertexMesh_wrapper {lvalue},unsigned int)

SolveNodeMapping((Cylindrical2dVertexMesh)arg1, (int)index) → int :

C++ signature :

unsigned int SolveNodeMapping(Cylindrical2dVertexMesh_wrapper {lvalue},unsigned int)

Translate((Cylindrical2dVertexMesh)arg1, (object)rDisplacement) → None :

C++ signature :

void Translate(Cylindrical2dVertexMesh {lvalue},boost::numeric::ublas::c_vector<double, 2ul>)

Translate( (Cylindrical2dVertexMesh)arg1, (object)rDisplacement) -> None :

C++ signature :

void Translate(Cylindrical2dVertexMesh_wrapper {lvalue},boost::numeric::ublas::c_vector<double, 2ul>)

Translate( (Cylindrical2dVertexMesh)arg1 [, (float)xMovement=0.0 [, (float)yMovement=0.0 [, (float)zMovement=0.0]]]) -> None :

C++ signature :

void Translate(Cylindrical2dVertexMesh {lvalue} [,double=0.0 [,double=0.0 [,double=0.0]]])

WidenEdgeOrCorrectIntersectionLocationIfNecessary((Cylindrical2dVertexMesh)arg1, (int)indexA, (int)indexB, (object)intersection) → object :

C++ signature :

boost::numeric::ublas::c_vector<double, 2ul> WidenEdgeOrCorrectIntersectionLocationIfNecessary(Cylindrical2dVertexMesh_wrapper {lvalue},unsigned int,unsigned int,boost::numeric::ublas::c_vector<double, 2ul>)