Added IntegrateElements and IntegrateFaces to python post module.

Author: SteveMaas1978

MeshLib/FSMesh.cpp

@@ -2858,6 +2858,11 @@ void FSMesh::UpdateMeshPartitions()
 	}
 }
 
+FSElemSet* FSMesh::FindFEElemSet(const std::string& szname)
+{
+	return m_pFEElemSet.FindByName(szname);
+}
+
 FSSurface* FSMesh::FindFESurface(const string& name)
 {
 	return m_pFESurface.FindByName(name);

MeshLib/FSMesh.h

@@ -277,6 +277,8 @@ class FSMesh : public FSCoreMesh
 	FSGroup* FindFEGroup(int nid);
 	//! Find FE part set by name
 	FSPartSet* FindFEPartSet(const std::string& name);
+	//! Find FE element set by name
+	FSElemSet* FindFEElemSet(const std::string& szname);
 	//! Find FE surface by name
 	FSSurface* FindFESurface(const std::string& szname);
 	//! Find FE edge set by name

PostGL/GLDisplacementMap.cpp

@@ -195,21 +195,7 @@ void CGLDisplacementMap::UpdateState(int ntime, bool breset)
 	{
 		m_ntag[ntime] = nfield;
 
-		FEState& s = *pfem->GetState(ntime);
-
-		// get the reference state
-		Post::FERefState& ref = *s.m_ref;
-
-		// set the current nodal positions
-		for (int i = 0; i < pm->Nodes(); ++i)
-		{
-			FSNode& node = pm->Node(i);
-			vec3f dr = pfem->EvaluateNodeVector(i, ntime, nfield);
-
-			// the actual nodal position is stored in the state
-			// this is the field that will be used for strain calculations
-			s.m_NODE[i].m_rt = ref.m_Node[i].m_rt + dr;
-		}
+		pfem->EvaluateNodalPosition(nfield, ntime);
 	}
 }
 

PostLib/FEDataManager.cpp

@@ -91,6 +91,17 @@ int FEDataManager::FindDataField(const std::string& fieldName)
 	return -1;
 }
 
+int FEDataManager::GetFieldCode(const std::string& fieldName)
+{
+	int n = FindDataField(fieldName);
+	if (n >= 0)
+	{
+		auto p = DataField(n);
+		return (*p)->GetFieldID();
+	}
+	return -1;
+}
+
 FEDataFieldPtr FEDataManager::DataField(int i)
 {
 	if ((i < 0) || (i >= m_Data.size())) return m_Data.end();

PostLib/FEDataManager.h

@@ -58,6 +58,9 @@ class FEDataManager
 	//! find the index of a datafield
 	int FindDataField(const std::string& fieldName);
 
+	//! Get the field code of a datafield
+	int GetFieldCode(const std::string& fieldName);
+
 	//! find the data field given an index
 	FEDataFieldPtr DataField(int i);
 

PostLib/FEPostModel.h

@@ -249,6 +249,9 @@ class FEPostModel
 	//! Evaluate a field at a given time
 	bool Evaluate(int nfield, int ntime, bool breset = false);
 
+	//! Update the nodal positions based on the displacement field
+	bool EvaluateNodalPosition(int nfield, int ntime);
+
 	//! Get the nodal coordinates of an element at time (returns nr of nodes of element)
 	int GetElementCoords(int iel, int ntime, vec3f* r);
 

PostLib/evaluate.cpp

@@ -201,6 +201,30 @@ bool FEPostModel::IsValidFieldCode(int nfield, int nstate)
 	return true;
 }
 
+bool FEPostModel::EvaluateNodalPosition(int nfield, int ntime)
+{
+	FEState* s = GetState(ntime);
+	if (s == nullptr) return false;
+
+	FSMeshBase* pm = s->GetFEMesh();
+
+	// get the reference state
+	Post::FERefState& ref = *s->m_ref;
+
+	// set the current nodal positions
+	for (int i = 0; i < pm->Nodes(); ++i)
+	{
+		FSNode& node = pm->Node(i);
+		vec3f dr = EvaluateNodeVector(i, ntime, nfield);
+
+		// the actual nodal position is stored in the state
+		// this is the field that will be used for strain calculations
+		s->m_NODE[i].m_rt = ref.m_Node[i].m_rt + dr;
+	}
+
+	return true;
+}
+
 //-----------------------------------------------------------------------------
 // Evaluate a data field at a particular time
 bool FEPostModel::Evaluate(int nfield, int ntime, bool breset)
@@ -260,9 +284,11 @@ void FEPostModel::EvalNodeField(int ntime, int nfield)
 			FACEDATA& d = state.m_FACE[i];
 			d.m_val = 0.f;
 			d.m_ntag = 0;
+			f.Deactivate();
 			if (f.IsEnabled())
 			{
 				d.m_ntag = 1;
+				f.Activate();
 				for (int j = 0; j < f.Nodes(); ++j) { float val = state.m_NODE[f.n[j]].m_val; faceData.value(i, j) = val; d.m_val += val; }
 				d.m_val /= (float)f.Nodes();
 			}

PyLib/PyFBSMesh.cpp

@@ -87,6 +87,8 @@ void init_FSMesh(py::module_& m)
 
 		.def("Surfaces", &FSMesh::FESurfaces, DOC(FSMesh, FESurfaces))
 		.def("Surface", &FSMesh::GetFESurface, py::return_value_policy::reference, DOC(FSMesh, GetFESurface))
+		.def("FindSurface", &FSMesh::FindFESurface, py::return_value_policy::reference)
+
 		.def("NodeIndexFromID", &FSMesh::NodeIndexFromID, DOC(FSMesh, NodeIndexFromID))
 
 		.def("MeshDataFields", &FSMesh::MeshDataFields, DOC(FSMesh, MeshDataFields))
@@ -97,6 +99,7 @@ void init_FSMesh(py::module_& m)
 
         .def("ElemSets", &FSMesh::FEElemSets, DOC(FSMesh, FEElemSets))
         .def("ElemSet", &FSMesh::GetFEElemSet, py::return_value_policy::reference, DOC(FSMesh, GetFEElemSet))
+		.def("FindElemSet", &FSMesh::FindFEElemSet, py::return_value_policy::reference)
 
         .def("NodeSets", &FSMesh::FENodeSets, DOC(FSMesh, FENodeSets))
         .def("NodeSet", &FSMesh::GetFENodeSet, py::return_value_policy::reference, DOC(FSMesh, GetFENodeSet))

PyLib/PyFBSPost.cpp

@@ -78,6 +78,74 @@ FEPostModel* GetActivePostModel()
 }
 #endif
 
+double PostIntegrateElements(FEPostModel& model, FSElemSet& set, ModelDataField& field, int component, int state)
+{
+	FEState* ps = model.GetState(state);
+	if (ps == nullptr)
+	{
+		throw pyGenericExcept("Invalid state index.");
+	}
+
+	FSMesh* mesh = set.GetMesh();
+	if (mesh == nullptr) return 0.0;
+	std::vector<int> elemList = set.CopyItems();
+
+	// update the model's state
+	Post::FEDataManager* DM = model.GetDataManager();
+	if (DM)
+	{
+		int dispField = DM->GetFieldCode("displacement");
+		if (dispField >= 0)
+		{
+			if (!model.EvaluateNodalPosition(dispField, state))
+			{
+				return 0.0;
+			}
+		}
+	}
+
+	if (!model.Evaluate(field.GetFieldID() | component, state))
+	{
+		return 0.0;
+	}
+
+	return Post::IntegrateElems(*mesh, elemList, ps);
+}
+
+double PostIntegrateFaces(FEPostModel& model, FSSurface& surf, ModelDataField& field, int component, int state)
+{
+	FEState* ps = model.GetState(state);
+	if (ps == nullptr)
+	{
+		throw pyGenericExcept("Invalid state index.");
+	}
+
+	FSMesh* mesh = surf.GetMesh();
+	if (mesh == nullptr) return 0.0;
+	std::vector<int> elemList = surf.CopyItems();
+
+	// update the model's state
+	Post::FEDataManager* DM = model.GetDataManager();
+	if (DM)
+	{
+		int dispField = DM->GetFieldCode("displacement");
+		if (dispField >= 0)
+		{
+			if (!model.EvaluateNodalPosition(dispField, state))
+			{
+				return 0.0;
+			}
+		}
+	}
+
+	if (!model.Evaluate(field.GetFieldID() | component, state, true))
+	{
+		return 0.0;
+	}
+
+	return Post::IntegrateFaces(*mesh, elemList, ps);
+}
+
 void init_FBSPost(py::module& m)
 {
 	py::module post = m.def_submodule("post", "Module used to interact with plot files");
@@ -87,6 +155,9 @@ void init_FBSPost(py::module& m)
 	post.def("GetActiveModel", &GetActivePostModel, "Returns the active FEPostModel instance.", py::return_value_policy::reference);
 #endif
 
+	post.def("IntegrateElements", &PostIntegrateElements, "Integrates a data field over an element set.");
+	post.def("IntegrateFaces"   , &PostIntegrateFaces   , "Integrates a data field over a surface.");
+
     InitStandardDataFields();
     post.def("AddStandardDataField", pybind11::overload_cast<FEPostModel&, const std::string&>(&AddStandardDataField), 
         "Adds a standard data field to the model.", py::arg("model"), py::arg("dataField"));