- integrating CGNSWriter3D for aero output

Author: SimonCald

aero/CMakeLists.txt

@@ -73,7 +73,7 @@ set(GMDS_INC
 		inc/gmds/aero/SU2Writer_3D.h
 		inc/gmds/aero/TransfiniteInterpolation_3D.h
 		inc/gmds/aero/Utils.h
-
+		inc/gmds/aero/CGNSWriter3D.h
 		)
 set(GMDS_SRC
 		src/AbstractAeroBoundaries.cpp
@@ -142,6 +142,7 @@ set(GMDS_SRC
 		src/TransfiniteInterpolation_3D.cpp
 		src/Utils.cpp
 		src/main.cpp
+		src/CGNSWriter3D.cpp
 )
 #==============================================================================
 add_library(${GMDS_LIB} ${GMDS_INC} ${GMDS_SRC})

aero/inc/gmds/aero/AeroPipeline_3D.h

@@ -28,6 +28,9 @@ class LIB_GMDS_AERO_API AeroPipeline_3D : public AbstractAeroPipeline {
 	 */
 	AbstractAeroPipeline::STATUS execute() override;
 	/*------------------------------------------------------------------------*/
+	/** \brief Get the 3D blocking structure
+	 */
+	 Blocking3D* getBlocking();
 
  private:
 	/*------------------------------------------------------------------------*/

blocking/inc/gmds/blocking/CGNSWriter3D.h renamed to aero/inc/gmds/aero/CGNSWriter3D.h

@@ -9,22 +9,23 @@
 /*----------------------------------------------------------------------------*/
 #include <cgnslib.h>
 /*----------------------------------------------------------------------------*/
-#include "LIB_GMDS_BLOCKING_export.h"
-#include "gmds/ig/Blocking2D.h"
+#include "Blocking3D.h"
+#include "LIB_GMDS_AERO_export.h"
+// #include "gmds/ig/Blocking2D.h"
 /*----------------------------------------------------------------------------*/
 namespace gmds {
 
-namespace blocking {
+namespace aero {
 
-class LIB_GMDS_BLOCKING_API CGNSWriter3D
+class LIB_GMDS_AERO_API CGNSWriter3D
 {
  public:
 	/** @brief Constructor
 		 *
 		 * @param AMeshService an implementation of an io service to write data
 		 * 						  into a mesh
 	 */
-	CGNSWriter3D(Blocking2D *ABlocking);
+	CGNSWriter3D(Blocking3D *ABlocking);
 
 	CGNSWriter3D(Mesh *AMesh);
 

aero/src/AbstractAeroPipeline.cpp

@@ -84,7 +84,7 @@ AbstractAeroPipeline::AbstractAeroPipeline(std::string &Aparams, std::string &Aw
 	p.get("section_Extrusion","y_lim_insertions", m_params.y_lim);
 	p.get("section_Extrusion","z_lim_insertions", m_params.z_lim);
 	p.get("section_Extrusion","insertions_allowed_on_first_layer", m_params.insertions_allowed_on_first_layer);
-	p.get("section_Extrusion","nbr_linear_blocks_smoothing", m_params.nbr_linear_blocks_smoothing);
+	//p.get("section_Extrusion","nbr_linear_blocks_smoothing", m_params.nbr_linear_blocks_smoothing);
 
 	p.get("section_Curved_Blocks","max_degree", m_params.max_degree);
 	p.get("section_Curved_Blocks","max_error", m_params.max_error);

aero/src/AeroPipeline_3D.cpp

@@ -3130,4 +3130,70 @@ AeroPipeline_3D::smoothingLinearBlocks(int nb_iteration)
 
 	}
 }
+/*------------------------------------------------------------------------*/
+Blocking3D*
+AeroPipeline_3D::getBlocking()
+{
+	//std::cout<<"Writing blocks for cgns"<<std::endl;
+	gmds::Variable<int>* discrI = m_Blocking3D.newVariable<int, gmds::GMDS_REGION>("discrI");
+	gmds::Variable<int>* discrJ = m_Blocking3D.newVariable<int, gmds::GMDS_REGION>("discrJ");
+	gmds::Variable<int>* discrK = m_Blocking3D.newVariable<int, gmds::GMDS_REGION>("discrK");
+	gmds::Variable<int>* farfield   = m_Blocking3D.newVariable<int, gmds::GMDS_NODE>("Farfield");
+	gmds::Variable<int>* paroi      = m_Blocking3D.newVariable<int, gmds::GMDS_NODE>("Paroi");
+	Variable<int>* var_couche_blocking = m_Blocking3D.getVariable<int, GMDS_NODE>("GMDS_Couche");
+	int max_layer = 0;
+	for(auto b : m_Blocking3D.allBlocks()){
+		gmds::Variable<int>* internalNodes = m_Blocking3D.newVariable<int, gmds::GMDS_NODE>("block"+std::to_string(b.id()));
+		//std::cout<<"Block "<<b.id()<<std::endl;
+		int b_discrI = b.getNbDiscretizationI(),b_discrJ = b.getNbDiscretizationJ(), b_discrK = b.getNbDiscretizationK();
+		discrI->set(b.id(), b_discrI);
+		discrJ->set(b.id(), b_discrJ);
+		discrK->set(b.id(), b_discrK);
+		int iNode = 0;
+		for(int k = 0; k < b_discrK; k++){
+			for(int j = 0; j < b_discrJ; j++){
+				for(int i = 0; i < b_discrI; i++){
+					internalNodes->set(b(i,j,k).id(),iNode+1);
+					iNode++;
+				}
+			}
+		}
+		for(int i_b = 0; i_b<8; i_b++){
+			int layer = var_couche_blocking->value(b.getNode(i_b).id());
+			max_layer = layer > max_layer ? layer : max_layer;
+		}
+	}
+	for(auto f : m_Blocking3D.faces()){
+		Blocking3D::BlockFace b_f = m_Blocking3D.blockFace(f);
+		bool isWall = true;
+		bool isFF = true;
+		for(int i_n = 0; i_n<4; i_n++){
+			if(var_couche_blocking->value(b_f.getNode(i_n).id()) != 0) isWall = false;
+			if(var_couche_blocking->value(b_f.getNode(i_n).id()) != max_layer) isFF = false;
+		}
+		int bf_discrI = b_f.getNbDiscretizationI(), bf_discrJ = b_f.getNbDiscretizationJ();
+		if(isFF) {
+			for (int j = 0; j < bf_discrJ; j++) {
+				for (int i = 0; i < bf_discrI; i++) {
+					farfield->set(b_f(i, j).id(), 1);
+				}
+			}
+		}else if(isWall){
+			for (int j = 0; j < bf_discrJ; j++) {
+				for (int i = 0; i < bf_discrI; i++) {
+					paroi->set(b_f(i, j).id(), 1);
+				}
+			}
+		}
+	}
+	/*gmds::IGMeshIOService ioService(&m_Blocking3D);
+	gmds::VTKWriter vtkWriter(&ioService);
+	vtkWriter.setCellOptions(gmds::N|gmds::R);
+	vtkWriter.setDataOptions(gmds::N|gmds::R);
+	std::cout<<"start writing"<<std::endl;
+	vtkWriter.write("CGNS_"+m_params.output_file);
+	std::cout<<"end writing"<<std::endl;*/
+	//return "CGNS_"+m_params.output_file;
+	return &m_Blocking3D;
+}
 /*------------------------------------------------------------------------*/

blocking/src/CGNSWriter3D.cpp renamed to aero/src/CGNSWriter3D.cpp

@@ -3,16 +3,16 @@
 // Created by calderans on 29/06/2023.
 //
 /*----------------------------------------------------------------------------*/
+#include "gmds/aero/CGNSWriter3D.h"
 #include "gmds/ig/MeshDoctor.h"
 #include "gmds/io/IGMeshIOService.h"
 #include "gmds/io/VTKReader.h"
 #include <fstream>
-#include <gmds/blocking/CGNSWriter3D.h>
 #include <iomanip>
 /*----------------------------------------------------------------------------*/
 using namespace gmds;
 /*----------------------------------------------------------------------------*/
-using namespace blocking;
+using namespace aero;
 
 #define Structured CG_Structured
 #define RealDouble CG_RealDouble
@@ -21,7 +21,7 @@ using namespace blocking;
 #define Unstructured CG_Unstructured
 #define TRI_3 CG_TRI_3
 /*----------------------------------------------------------------------------*/
-CGNSWriter3D::CGNSWriter3D(Blocking2D *ABlocking)
+CGNSWriter3D::CGNSWriter3D(Blocking3D *ABlocking)
   :m_blocks(ABlocking),m_mesh(nullptr)
 {}
 /*----------------------------------------------------------------------------*/
@@ -182,7 +182,7 @@ void CGNSWriter3D::writeZones()
 					idinter1 = 1;
 					idmax1 = 2;
 					break;
-				case 1:
+				case 2:
 					pts1[0] = 1;
 					pts1[1] = 1;
 					pts1[2] = 1;
@@ -199,7 +199,7 @@ void CGNSWriter3D::writeZones()
 					idinter1 = 1;
 					idmax1 = 5;
 					break;
-				case 2:
+				case 5:
 					pts1[0] = discrI;
 					pts1[1] = 1;
 					pts1[2] = 1;
@@ -250,7 +250,7 @@ void CGNSWriter3D::writeZones()
 					idinter1 = 3;
 					idmax1 = 7;
 					break;
-				case 5:
+				case 1:
 					pts1[0] = 1;	// X1
 					pts1[1] = 1;	// Y1
 					pts1[2] = discrK;	// Z1
@@ -509,7 +509,7 @@ void CGNSWriter3D::writeZones()
 				pts_bc[4] = discrJ;	// Y2
 				pts_bc[5] = 1;			// Z2
 				break;
-			case 1:
+			case 2:
 				pts_bc[0] = 1;
 				pts_bc[1] = 1;
 				pts_bc[2] = 1;
@@ -518,7 +518,7 @@ void CGNSWriter3D::writeZones()
 				pts_bc[4] = 1;
 				pts_bc[5] = discrK;
 				break;
-			case 2:
+			case 5:
 				pts_bc[0] = discrI;
 				pts_bc[1] = 1;
 				pts_bc[2] = 1;
@@ -545,7 +545,7 @@ void CGNSWriter3D::writeZones()
 				pts_bc[4] = discrJ;
 				pts_bc[5] = discrK;
 				break;
-			case 5:
+			case 1:
 				pts_bc[0] = 1;	// X1
 				pts_bc[1] = 1;	// Y1
 				pts_bc[2] = discrK;	// Z1
@@ -612,7 +612,7 @@ void CGNSWriter3D::writeBoundaryCondition(int &num_bc, cgsize_t* pts, int id_zon
 }
 /*----------------------------------------------------------------------------*/
 void CGNSWriter3D::write(const std::string &AInFileName, const std::string &AOutFileName, const std::string &AWorkingDir){
-
+	/*
 	std::cout<<"Start reading"<<std::endl;
 
 	gmds::IGMeshIOService ioService(m_blocks);
@@ -626,7 +626,7 @@ void CGNSWriter3D::write(const std::string &AInFileName, const std::string &AOut
 	MeshDoctor doc(m_blocks);
 	doc.buildFacesAndR2F();
 	doc.buildF2R(m_blocks->getModel());
-
+*/
 	m_block_grid = m_blocks->newVariable<std::vector<TCellID>,GMDS_REGION>("block_grid");
 
 	VarDiscrI = m_blocks->getVariable<int,GMDS_REGION>("discrI");

aero/src/main.cpp

@@ -3,6 +3,7 @@
 /*------------------------------------------------------------------------*/
 #ifdef USE_CGNS
    #include <gmds/blocking/CGNSWriter.h>
+	#include <gmds/aero/CGNSWriter3D.h>
 #endif
 #include <gmds/aero/AbstractAeroPipeline.h>
 #include <gmds/aero/AeroPipeline_2D.h>
@@ -20,30 +21,46 @@ int main(int argc, char* argv[])
 {
 	std::cout << "=== AERO ALGO ====" << std::endl;
 
-	if (argc != 4 )
-	{
+	if (argc != 5) {
 		std::cout << "Merci de préciser <repertoire/de/travail> <fichier_param.ini> <fichier_sorti.cgns>" << std::endl;
 		exit(0);
 	}
 
 	std::string dir(argv[1]);
 	std::string param_file(argv[2]);
 	std::string output_file(argv[3]);
+	std::string dimension(argv[4]);
 
-	std::string input_file=dir+param_file;
+	std::string input_file = dir +"/"+ param_file;
 
-	// Mesh Generation
-	AeroPipeline_2D algo_aero2D(input_file, dir);
-	AbstractAeroPipeline::STATUS aero2D_result = algo_aero2D.execute();
+	if (dimension == "2D") {
+		// Mesh Generation
+		// Mesh Generation
+		AeroPipeline_2D algo_aero2D(input_file, dir);
+		AbstractAeroPipeline::STATUS aero2D_result = algo_aero2D.execute();
 
-	if(aero2D_result == AbstractAeroPipeline::SUCCESS) {
+		if (aero2D_result == AbstractAeroPipeline::SUCCESS) {
 #ifdef USE_CGNS
-		blocking::CGNSWriter writer(algo_aero2D.getBlocking());
-		writer.write(output_file, dir);
+			blocking::CGNSWriter writer(algo_aero2D.getBlocking());
+			writer.write(output_file, dir);
 #else
-		std::cout<<"CGNS export is desactivated"<<std::endl;
+			std::cout << "CGNS export is desactivated" << std::endl;
 #endif
-	}else{
-		std::cout<<"Erreur dans le pipeline Aero"<<std::endl;
+		}
+	}
+	else if (dimension == "3D") {
+		// Mesh Generation
+		dir = dir + "/";
+		AeroPipeline_3D algo_aero3D(input_file, dir);
+		AbstractAeroPipeline::STATUS aero_result = algo_aero3D.execute();
+
+		if (aero_result == AbstractAeroPipeline::SUCCESS) {
+#ifdef USE_CGNS
+			gmds::aero::CGNSWriter3D writer(algo_aero3D.getBlocking());
+			writer.write("", output_file, dir);
+#else
+			std::cout << "CGNS export is desactivated" << std::endl;
+#endif
+		}
 	}
 }

blocking/CMakeLists.txt

@@ -18,7 +18,7 @@ set(GMDS_INC
 if(WITH_CGNS)
     message(TEST)
     set(GMDS_INC ${GMDS_INC} inc/gmds/blocking/CGNSWriter.h
-            inc/gmds/blocking/CGNSWriter3D.h)
+            )
 endif()
 
 set(GMDS_SRC
@@ -33,7 +33,7 @@ set(GMDS_SRC
 
 if(WITH_CGNS)
     set(GMDS_SRC ${GMDS_SRC} src/CGNSWriter.cpp
-            src/CGNSWriter3D.cpp)
+            )
 endif()
 #==============================================================================
 add_library(${GMDS_LIB} ${GMDS_INC} ${GMDS_SRC})

blocking/src/main.cpp

@@ -1,7 +1,7 @@
 //
 // Created by calderans on 30/06/23.
 //
-#include <gmds/blocking/CGNSWriter3D.h>
+
 
 using namespace gmds;
 using namespace blocking;

blocking/src/main_cgns.cpp

@@ -1,7 +1,7 @@
 //
 // Created by calderans on 30/06/23.
 //
-#include <gmds/blocking/CGNSWriter3D.h>
+#include "../../aero/inc/gmds/aero/CGNSWriter3D.h"
 
 using namespace gmds;
 using namespace blocking;
@@ -18,7 +18,7 @@ int main(int argc, char** argv)
 	std::string path(argv[2]);
 	std::string filename(argv[3]);
 
-	CGNSWriter3D writer3D;
+	gmds::aero::CGNSWriter3D writer3D;
 	writer3D.write(param_file,filename,path);
 
 }