Branch data Line data Source code
1 : : #include <stdio.h>
2 : : #include "meshkit/AssyMesher.hpp"
3 : : #include "meshkit/LocalSet.hpp"
4 : : #include "meshkit/MKCore.hpp"
5 : : #include "meshkit/ModelEnt.hpp"
6 : : #include "meshkit/OneToOneSwept.hpp"
7 : : #include "meshkit/RegisterMeshOp.hpp"
8 : : #include "meshkit/SizingFunction.hpp"
9 : :
10 : : #include "iMesh_extensions.h"
11 : : #include "MBCN.h"
12 : : #include "moab/Types.hpp"
13 : : #include "MBTagConventions.hpp"
14 : :
15 : :
16 : : namespace MeshKit
17 : : {
18 : : // static registration of this mesh scheme
19 : : moab::EntityType AssyMesher_tps[] = { moab::MBTET,
20 : : moab::MBQUAD,
21 : : moab::MBTRI,
22 : : moab::MBHEX,
23 : : moab::MBMAXTYPE};
24 : 40 : const moab::EntityType* AssyMesher::output_types()
25 : 40 : { return AssyMesher_tps; }
26 : :
27 : 1 : AssyMesher::AssyMesher(MKCore *mk, const MEntVector &me_vec)
28 : : : MeshScheme( mk, me_vec),
29 [ + - ][ + - ]: 1 : igeom(mk->igeom_instance()), imesh(mk->imesh_instance()),
30 [ + - ][ + - ]: 2 : mb (mk->moab_instance())
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
31 : : {
32 : 1 : m_nPlanar = 0; //default is 3D
33 : 1 : m_nLineNumber = 0;
34 [ + - ]: 1 : szComment = "!";
35 : 1 : MAXCHARS = 300;
36 : 1 : pi = M_PI;
37 : 1 : m_dRadialSize = -1.0;
38 : 1 : m_dAxialSize = -1.0;
39 : 1 : m_dTetMeshSize = -1.0;
40 : 1 : m_nDimensions = 0;
41 : 1 : m_nMaterialSetId = 1;
42 : 1 : m_nNeumannSetId = 1;
43 [ + - ]: 1 : m_szEngine = "acis";
44 [ + - ]: 1 : m_szMeshType = "hex";
45 : 1 : m_nDuct = 0;
46 : 1 : m_nDuctNum = 0;
47 : 1 : m_nJouFlag = 0;
48 [ + - ]: 1 : m_szSideset = "yes";
49 : 1 : m_dMergeTol = 1e-4;
50 [ + - ]: 1 : m_GeomFile = "";
51 : 1 : }
52 : :
53 : 3 : AssyMesher::~AssyMesher()
54 [ - + ]: 2 : {}
55 : :
56 : 0 : bool AssyMesher::add_modelent(ModelEnt *model_ent)
57 : : {
58 : 0 : return MeshOp::add_modelent(model_ent);
59 : : }
60 : :
61 : 1 : void AssyMesher::setup_this()
62 : : {
63 : : // populate the model entities based on the geometry
64 [ + - ][ + - ]: 1 : mk_core()->populate_model_ents();
65 : :
66 : : // create a set with the names of materials as std::string
67 [ + + ]: 4 : for (int mtrlIndx = 1; mtrlIndx <= m_nAssemblyMat; ++mtrlIndx)
68 : : {
69 [ + - ][ + - ]: 3 : allMtrlsSet.insert(m_szAssmMat(mtrlIndx));
70 : : }
71 : :
72 : : // get a vector of all surfaces
73 [ + - ]: 1 : std::vector<iGeom::EntityHandle> allSurfs;
74 [ + - ]: 1 : iGeom::EntitySetHandle rootSetHandle = igeom->getRootSet();
75 [ + - ]: 1 : igeom->getEntities(rootSetHandle, iBase_FACE, allSurfs);
76 : :
77 : : // get a vector of all surfaces that have are identified
78 : : // as top surfaces for some material
79 : : std::vector<iGeom::EntityHandle> *allTopSurfs =
80 [ + - ]: 1 : selectByMaterialsAndNameSuffix(allSurfs, allMtrlsSet, "_top");
81 : :
82 : : // get the tag on the geometry that identifies the associated model entity
83 [ + - ][ + - ]: 1 : iGeom::TagHandle meTag = mk_core()->igeom_model_tag();
84 : :
85 : : // sizing function for radial mesh size . . . MeshKit core will delete it
86 : : SizingFunction* radialMeshSizePtr;
87 [ - + ][ # # ]: 1 : if (m_dRadialSize <= 0 && m_nDimensions > 0)
88 : : {
89 : : // the radial size was not specified in the input
90 : : // but there are pins
91 [ # # ][ # # ]: 0 : if (m_szGeomType == "hexagonal")
92 : : {
93 [ # # ]: 0 : double pitch = m_dMAssmPitch(1, m_nDimensions);
94 [ # # ][ # # ]: 0 : radialMeshSizePtr = new SizingFunction(mk_core(), -1, 0.1*pitch);
[ # # ]
95 : : }
96 : : else
97 : : {
98 [ # # ]: 0 : double pitchX = m_dMAssmPitchX(1, m_nDimensions);
99 [ # # ]: 0 : double pitchY = m_dMAssmPitchY(1, m_nDimensions);
100 : 0 : radialMeshSizePtr = new SizingFunction(mk_core(), -1,
101 [ # # ][ # # ]: 0 : 0.02*0.5*(pitchX + pitchY));
[ # # ]
102 : 0 : }
103 : : }
104 [ - + ]: 1 : else if (m_dRadialSize <= 0)
105 : : {
106 : : // there are no pins and no radial mesh size
107 [ # # ][ # # ]: 0 : radialMeshSizePtr = new SizingFunction(mk_core(), -1, 1.0);
[ # # ]
108 : : }
109 : : else
110 : : {
111 [ + - ][ + - ]: 1 : radialMeshSizePtr = new SizingFunction(mk_core(), -1, m_dRadialSize);
[ + - ]
112 : : }
113 [ + - ]: 1 : int radialSizeIndex = radialMeshSizePtr->core_index();
114 : :
115 : : // sizing function for axial mesh size . . . MeshKit core will delete it
116 : : // it looks like axial mesh size can be more complicated depending
117 : : // on number of ducts but for the moment assume it is uniform
118 : : SizingFunction* axialMeshSizePtr;
119 [ - + ]: 1 : if (m_dAxialSize <= 0) // the axial size was not specified in the input
120 : : {
121 : : // in uniform size case, default is 10 intervals, i.e. 10% of height
122 [ # # ][ # # ]: 0 : axialMeshSizePtr = new SizingFunction(mk_core(), 10, -1);
[ # # ]
123 : : }
124 : : else
125 : : {
126 [ + - ][ + - ]: 1 : axialMeshSizePtr = new SizingFunction(mk_core(), -1, m_dAxialSize);
[ + - ]
127 : : }
128 [ + - ]: 1 : int axialSizeIndex = axialMeshSizePtr->core_index();
129 : :
130 : : // set the mesh sizes and operations starting from top surfaces
131 [ + + ]: 5 : for (unsigned int tsi = 0; tsi < allTopSurfs->size(); ++tsi)
132 : : {
133 : : // Remark: iterator pattern may perform better that indexed loop here
134 [ + - ]: 4 : iGeom::EntityHandle topGeoHandle = (*allTopSurfs)[tsi];
135 : : ModelEnt* meTopSurf;
136 [ + - ]: 4 : igeom->getData(topGeoHandle, meTag, &meTopSurf);
137 : : // TODO: check success
138 [ + - ]: 4 : meTopSurf->sizing_function_index(radialSizeIndex);
139 : :
140 [ + - ]: 4 : MEntVector topSurfVec;
141 [ + - ]: 4 : topSurfVec.push_back(meTopSurf);
142 [ + - ][ + - ]: 4 : MeshOp* paveOp = mk_core()->construct_meshop("CAMALPaver", topSurfVec);
[ + - ]
143 [ + - ][ + - ]: 4 : mk_core()->insert_node(paveOp, (MeshOp*) this, mk_core()->root_node());
[ + - ][ + - ]
144 : :
145 : : double topBBMinX, topBBMinY, topBBMinZ, topBBMaxX, topBBMaxY, topBBMaxZ;
146 : : igeom->getEntBoundBox(topGeoHandle,
147 [ + - ]: 4 : topBBMinX, topBBMinY, topBBMinZ, topBBMaxX, topBBMaxY, topBBMaxZ);
148 : :
149 [ + - ]: 8 : std::vector<iGeom::EntityHandle> adjRegions;
150 [ + - ]: 4 : igeom->getEntAdj(topGeoHandle, iBase_REGION, adjRegions);
151 [ + + ]: 8 : for (size_t ari = 0; ari < adjRegions.size(); ++ari)
152 : : {
153 [ + - ]: 4 : iGeom::EntityHandle adjRegionHandle = adjRegions[ari];
154 : :
155 : : // confirm that the adjacent region is really below the top surface
156 : : double arBBMinX, arBBMinY, arBBMinZ, arBBMaxX, arBBMaxY, arBBMaxZ;
157 : : igeom->getEntBoundBox(adjRegionHandle,
158 [ + - ]: 4 : arBBMinX, arBBMinY, arBBMinZ, arBBMaxX, arBBMaxY, arBBMaxZ);
159 [ - + ]: 4 : if (arBBMinZ >= topBBMinZ)
160 : : {
161 : : // this is not the correct region since it is not below the top surface
162 : 0 : continue;
163 : : }
164 : :
165 : : ModelEnt* regionME;
166 [ + - ]: 4 : igeom->getData(adjRegionHandle, meTag, ®ionME);
167 : : // TODO: check success
168 : :
169 [ + - ]: 4 : regionME->sizing_function_index(axialSizeIndex, false);
170 : :
171 : : // examine the faces of the region in order to
172 : : // (1) identify indices of the top and bottom face
173 : : // (2) set sizes on vertical faces and bottom face as needed
174 [ + - ]: 4 : std::vector<iGeom::EntityHandle> regionSurfs;
175 [ + - ]: 4 : igeom->getEntAdj(adjRegionHandle, iBase_FACE, regionSurfs);
176 : 4 : size_t topFaceIndex=0, bottomFaceIndex=0;
177 [ + + ]: 28 : for (size_t rfi = 0; rfi < regionSurfs.size(); ++rfi)
178 : : {
179 [ + - ]: 24 : iGeom::EntityHandle regionFaceHandle = regionSurfs[rfi];
180 [ + + ]: 24 : if (regionFaceHandle == topGeoHandle)
181 : : {
182 : 4 : topFaceIndex = rfi;
183 : 4 : continue;
184 : : }
185 : :
186 : : // check whether this face shares an edge with the top face
187 : 20 : bool commonEdge = false;
188 [ + - ]: 20 : std::vector<iGeom::EntityHandle> edgesOfFace;
189 [ + - ]: 20 : igeom->getEntAdj(regionFaceHandle, iBase_EDGE, edgesOfFace);
190 [ + + ]: 70 : for (size_t eofci = 0; eofci < edgesOfFace.size(); ++eofci)
191 : : {
192 [ + - ][ + - ]: 66 : igeom->isEntAdj(topGeoHandle, edgesOfFace[eofci], commonEdge);
193 [ + + ]: 66 : if (commonEdge) break;
194 : : }
195 : :
196 [ + + ]: 20 : if (commonEdge)
197 : : {
198 : : // this is a vertical face
199 : : ModelEnt* meVertSurf;
200 [ + - ]: 16 : igeom->getData(regionFaceHandle, meTag, &meVertSurf);
201 : : // TODO: check success
202 [ + - ][ + + ]: 16 : if (meVertSurf->sizing_function_index() == -1)
203 : : {
204 : : // the vertical surface has not yet been processed, since no
205 : : // sizing function index is set on it
206 [ + - ]: 10 : meVertSurf->sizing_function_index(axialSizeIndex, false);
207 : : // sizing function needs to be set on the vertical edges . . .
208 : : // it should be okay to set it on all boundary edges not yet set
209 [ + - ]: 10 : MEntVector edgeMEsVec;
210 [ + - ]: 20 : std::vector<int> senses;
211 [ + - ]: 10 : meVertSurf->boundary(1, edgeMEsVec, &senses);
212 [ + + ]: 50 : for (size_t emei = 0; emei < edgeMEsVec.size(); ++emei)
213 : : {
214 [ + - ][ + - ]: 40 : if (edgeMEsVec[emei]->sizing_function_index() == -1)
[ + + ]
215 : : {
216 [ + - ][ + - ]: 15 : edgeMEsVec[emei]->sizing_function_index(axialSizeIndex, false);
217 : : }
218 : 16 : }
219 : : }
220 : : }
221 : : else
222 : : {
223 : : // this is the bottom face
224 : 4 : bottomFaceIndex = rfi;
225 : : ModelEnt* meBottomSurf;
226 [ + - ]: 4 : igeom->getData(regionFaceHandle, meTag, &meBottomSurf);
227 : : // TODO: check success
228 [ + - ][ + - ]: 4 : if (meBottomSurf->sizing_function_index() == -1)
229 : : {
230 : : // the bottom surface does not yet have a
231 : : // sizing function set on it
232 [ + - ]: 4 : meBottomSurf->sizing_function_index(radialSizeIndex);
233 : : }
234 [ + - ]: 4 : MEntVector edgeMEsVec;
235 [ + - ]: 8 : std::vector<int> senses;
236 [ + - ]: 4 : meBottomSurf->boundary(1, edgeMEsVec, &senses);
237 [ + + ]: 20 : for (size_t emei = 0; emei < edgeMEsVec.size(); ++emei)
238 : : {
239 [ + - ][ + - ]: 16 : edgeMEsVec[emei]->constrain_even(true);
240 : 4 : }
241 : : }
242 : 20 : }
243 : :
244 [ + - ]: 8 : MEntVector regionVec;
245 [ + - ]: 4 : regionVec.push_back(regionME);
246 : : OneToOneSwept *sweepOp = (OneToOneSwept*)
247 [ + - ][ + - ]: 4 : mk_core()->construct_meshop("OneToOneSwept", regionVec);
[ + - ]
248 [ + - ]: 4 : sweepOp->SetSourceSurface(topFaceIndex);
249 [ + - ]: 4 : sweepOp->SetTargetSurface(bottomFaceIndex);
250 [ + - ][ + - ]: 4 : mk_core()->insert_node(sweepOp, (MeshOp*)this, paveOp);
251 : 4 : }
252 : 4 : }
253 : :
254 [ + - ]: 1 : delete allTopSurfs;
255 : :
256 [ + - ][ + - ]: 1 : mk_core()->print_graph();
257 : 1 : }
258 : :
259 : 1 : void AssyMesher::execute_this()
260 : : {
261 : 1 : std::cout << "Execute : start meshing the assembly" << std::endl;
262 : 1 : createMaterialNeumannSets(allMtrlsSet);
263 : : //createMaterialNeumannSets();
264 : : // Start doing the steps in .jou file: /MeshKit/rgg/io.cpp:routine:CreateCubitJournal()
265 : : // AssyMesher
266 : : // 1. Find surfaces with names <pin_material>_top and set radial mesh size, also set mesh scheme to CAMALTriMesher or GRUMMP trimesher
267 : : // 2. Sweep the volumes with top surfaces of pins, use bottom surfaces of the pins if required: bottom surfaces are name as <pin_material_bot>
268 : : // 3. Find edges in surfaces with names <material_side> set size equal to edge length
269 : : // 4. After meshing assign block names for all pins, by filtering using volumes
270 : : // 5. Now mesh the top cutout portion using CAMALTriMesher or GRUMMP trim//esher (Report if this fails, if this fails change in radial mesh size and edge interval might be needed)
271 : : // 6. Now sweep and name blocks.
272 : : // 7. Create Neumann Sets
273 : :
274 : : // step 1
275 : :
276 : :
277 : 1 : }
278 : :
279 : 1 : void AssyMesher::PrepareIO (int argc, char *argv[], std::string TestDir)
280 : : // ---------------------------------------------------------------------------
281 : : // Function: Obtains file names and opens input/output files
282 : : // Input: command line arguments
283 : : // Output: none
284 : : // ---------------------------------------------------------------------------
285 : : {
286 : : // set and open input output files
287 : 1 : bool bDone = false;
288 : : #ifdef HAVE_OCC
289 : : //switch to else to protect from having define twice
290 : : #define EXTENSION ".brep";
291 : : #else
292 : : #define EXTENSION ""
293 : : #endif
294 [ - + ]: 1 : do{
295 [ - + ]: 1 : if (2 == argc) {
296 [ # # ][ # # ]: 0 : m_InputFile = (std::string)argv[1] + ".inp";
[ # # ]
297 [ # # ][ # # ]: 0 : m_LogName = m_InputFile + ".log";
298 [ # # ][ # # ]: 0 : m_GeomFile = (std::string)argv[1] + EXTENSION;
[ # # ]
299 [ # # ]: 0 : m_szCommonFile = "common.inp";
300 : : }
301 [ + - ]: 1 : else if (1 == argc){
302 [ + - ][ + - ]: 1 : m_LogFile << "\nRunning default case:\n" << std::endl;
303 [ + - ][ + - ]: 1 : m_GeomFile = TestDir + "/" + (char *)DEFAULT_TEST_AM+ EXTENSION;
[ + - ][ + - ]
304 [ + - ][ + - ]: 1 : m_InputFile = TestDir + "/" + (char *)DEFAULT_TEST_AM + ".inp";
[ + - ][ + - ]
305 [ + - ][ + - ]: 1 : m_LogName = (std::string)DEFAULT_TEST_AM + ".log";
[ + - ]
306 [ + - ][ + - ]: 1 : m_szCommonFile = TestDir + "/" + "common.inp";
[ + - ]
307 : :
308 : : }
309 : : // open input file for reading
310 [ + - ]: 1 : m_FileInput.open (m_InputFile.c_str(), std::ios::in);
311 [ + - ][ - + ]: 1 : if (!m_FileInput){
312 [ # # ][ # # ]: 0 : m_LogFile << "Unable to open file: " << m_InputFile << std::endl;
[ # # ][ # # ]
313 [ # # ]: 0 : m_FileInput.clear ();
314 : 0 : exit(1);
315 : : }
316 : : else
317 : 1 : bDone = true; // file opened successfully
318 : :
319 : : // open common.inp file, if not found do nothing.
320 [ + - ]: 1 : m_FileCommon.open (m_szCommonFile.c_str(), std::ios::in);
321 [ + - ][ - + ]: 1 : if (!m_FileCommon){
322 : 0 : have_common = false;
323 [ # # ][ # # ]: 0 : std::cout << "common.inp file not specified." << std::endl;
324 [ # # ]: 0 : m_FileCommon.clear ();
325 : : }
326 : : else {
327 : 1 : have_common = true;
328 : : }
329 [ + - ][ + - ]: 1 : std::cout << " opened file " << m_szCommonFile << " have common is "
[ + - ]
330 [ + - ][ + - ]: 1 : << have_common << std::endl;
331 : : // } while (!bDone);
332 : :
333 : :
334 : : // open the log file for dumping debug/output statements
335 [ + - ]: 1 : m_LogFile.coss.open (m_LogName.c_str(), std::ios::out);
336 [ + - ][ - + ]: 1 : if (!m_LogFile.coss){
337 [ # # ][ # # ]: 0 : m_LogFile << "Unable to open file: " << m_LogName << std::endl;
[ # # ][ # # ]
338 [ # # ]: 0 : m_LogFile.coss.clear ();
339 : 0 : exit(1);
340 : : }
341 : : else
342 : 1 : bDone = true; // file opened successfully
343 [ + - ]: 1 : m_LogFile << '\n';
344 [ + - ][ + - ]: 1 : m_LogFile << "\t\t---------------------------------------------------------" << '\n';
345 [ + - ][ + - ]: 1 : m_LogFile << "\t\t Tool to generate assembly mesh " << '\n';
346 [ + - ][ + - ]: 1 : m_LogFile << "\t\t\t\tArgonne National Laboratory" << '\n';
347 [ + - ][ + - ]: 1 : m_LogFile << "\t\t\t\t 2015 " << '\n';
348 [ + - ][ + - ]: 1 : m_LogFile << "\t\t---------------------------------------------------------" << '\n';
349 [ + - ][ + - ]: 1 : m_LogFile << "\nsee README file for using the program and details on various cards.\n"<< std::endl;
350 : :
351 : 1 : }while (!bDone);
352 : :
353 : : /////////////////////////
354 : : /////////////////////////
355 [ + - ]: 1 : CParser Parse1;
356 : 1 : bool found = false;
357 [ + - ]: 2 : std::string card;
358 : 1 : m_nLineNumber = 0;
359 [ + - ][ + - ]: 1 : std::cout << "Reading from common.inp file." << std::endl;
360 : : for(;;){
361 [ - + ]: 8 : if (!Parse1.ReadNextLine (m_FileCommon, m_nLineNumber, szInputString,
362 [ + - ]: 8 : MAXCHARS, szComment))
363 [ # # ]: 0 : IOErrorHandler (INVALIDINPUT);
364 : :
365 [ + - ][ + - ]: 8 : if (szInputString.substr(0,10) == "geomengine"){
[ + + ]
366 : 1 : found = true;
367 [ + - ]: 1 : std::istringstream szFormatString (szInputString);
368 [ + - ][ + - ]: 1 : szFormatString >> card >> m_szEngine;
369 [ # # ][ - + ]: 2 : if( ((strcmp (m_szEngine.c_str(), "acis") != 0) &&
370 [ - + ][ + - ]: 1 : (strcmp (m_szEngine.c_str(), "occ") != 0)) || szFormatString.fail())
[ - + ]
371 [ # # ]: 1 : IOErrorHandler(EGEOMENGINE);
372 : : }
373 [ + - ][ + - ]: 8 : if (szInputString.substr(0,8) == "meshtype"){
[ + + ]
374 : 1 : found = true;
375 [ + - ]: 1 : std::istringstream szFormatString (szInputString);
376 [ + - ][ + - ]: 1 : szFormatString >> card >> m_szMeshType;
377 [ + - ][ - + ]: 3 : if( ((strcmp (m_szMeshType.c_str(), "hex") != 0) &&
378 [ + - ][ + - ]: 2 : (strcmp (m_szMeshType.c_str(), "tet") != 0)) || szFormatString.fail())
[ - + ]
379 [ # # ]: 1 : IOErrorHandler(INVALIDINPUT);
380 : : }
381 : :
382 : : // Hex or Rect geometry type
383 [ + - ][ + - ]: 8 : if (szInputString.substr(0,12) == "geometrytype"){
[ + + ]
384 : 1 : found = true;
385 [ + - ]: 1 : std::istringstream szFormatString (szInputString);
386 [ + - ][ + - ]: 1 : szFormatString >> card >> m_szGeomType;
387 [ + - ][ - + ]: 3 : if( ((strcmp (m_szGeomType.c_str(), "hexagonal") != 0) &&
388 [ + - ][ + - ]: 2 : (strcmp (m_szGeomType.c_str(), "rectangular") != 0)) || szFormatString.fail())
[ - + ]
389 [ # # ]: 0 : IOErrorHandler(EGEOMTYPE);
390 : :
391 : : // set the number of sides in the geometry
392 [ + - ][ - + ]: 1 : if(m_szGeomType == "hexagonal")
393 : 0 : m_nSides = 6;
394 [ + - ][ + - ]: 1 : else if(m_szGeomType == "rectangular")
395 : 1 : m_nSides = 4;
396 : : }
397 : : // Default if volume, set geometry type to surface for 2D assemblies
398 [ + - ][ + - ]: 8 : if (szInputString.substr(0,8) == "geometry"){
[ + + ]
399 : 1 : found = true;
400 [ + - ]: 1 : std::string outfile;
401 [ + - ]: 2 : std::istringstream szFormatString (szInputString);
402 [ + - ][ + - ]: 1 : szFormatString >> card >> outfile;
403 [ + - ][ + - ]: 1 : if(strcmp (outfile.c_str(), "surface") == 0 || szFormatString.fail())
[ - + ][ - + ]
404 : 1 : m_nPlanar=1;
405 : : }
406 : :
407 : : // breaking condition
408 [ + - ][ + - ]: 8 : if(szInputString.substr(0,3) == "end" || m_nLineNumber == 500){
[ + + ][ - + ]
[ + - ]
[ + + # # ]
409 : 1 : found = true;
410 : 1 : break;
411 : : }
412 [ - + ]: 7 : if (found == false){
413 [ # # ][ # # ]: 0 : std::cout << "Cannot specify: " << szInputString << " in common.inp files" << std::endl;
[ # # ][ # # ]
414 : : }
415 : 7 : }
416 : :
417 : : /////////////////////////////////////
418 : : /////////////////////////////////////
419 : : ///
420 : : ///
421 : :
422 : : // Read AssyGen input file
423 [ + - ]: 2 : CParser Parse;
424 : 1 : int nCyl =0, nCellMat=0, nInputLines=0;
425 [ + - ][ + - ]: 2 : std::string szVolId, szVolAlias;
426 : : // count the total number of cylinder commands in each pincell
427 : : for(;;){
428 [ - + ]: 17 : if (!Parse.ReadNextLine (m_FileInput, m_nLineNumber, szInputString,
429 [ + - ]: 17 : MAXCHARS, szComment))
430 [ # # ]: 0 : IOErrorHandler (INVALIDINPUT);
431 : :
432 [ + - ][ + - ]: 17 : if (szInputString.substr(0,10) == "geomengine"){
[ - + ]
433 [ # # ]: 0 : std::istringstream szFormatString (szInputString);
434 [ # # ][ # # ]: 0 : szFormatString >> card >> m_szEngine;
435 [ # # ][ # # ]: 0 : if( ((strcmp (m_szEngine.c_str(), "acis") != 0) &&
436 [ # # ][ # # ]: 0 : (strcmp (m_szEngine.c_str(), "occ") != 0)) || szFormatString.fail())
[ # # ]
437 [ # # ]: 0 : IOErrorHandler(EGEOMENGINE);
438 : : }
439 [ + - ][ + - ]: 17 : if (szInputString.substr(0,8) == "meshtype"){
[ + + ]
440 [ + - ]: 1 : std::istringstream szFormatString (szInputString);
441 [ + - ][ + - ]: 1 : szFormatString >> card >> m_szMeshType;
442 [ # # ][ - + ]: 2 : if( ((strcmp (m_szMeshType.c_str(), "hex") != 0) &&
443 [ - + ][ + - ]: 1 : (strcmp (m_szMeshType.c_str(), "tet") != 0)) || szFormatString.fail())
[ - + ]
444 [ # # ]: 1 : IOErrorHandler(INVALIDINPUT);
445 : : }
446 [ + - ][ + - ]: 17 : if (szInputString.substr(0,4) == "duct" || szInputString.substr(0,10) == "dimensions"){
[ + + ][ + - ]
[ + - ][ - + ]
[ + + ][ + - ]
[ + + # #
# # ]
447 : 1 : ++m_nDuct;
448 : : }
449 [ + - ][ + - ]: 17 : if (szInputString.substr(0,8) == "pincells"){
[ + + ]
450 [ + - ]: 1 : std::istringstream szFormatString (szInputString);
451 [ + - ][ + - ]: 1 : szFormatString >> card >> m_nPincells;
452 [ + - ]: 1 : if(m_nPincells>0)
453 [ + - ]: 1 : m_Pincell.SetSize(m_nPincells);
454 [ # # ]: 0 : else if(m_nPincells ==0)
455 [ # # ]: 0 : m_Pincell.SetSize(1); // assume for using dummy pincell
456 : :
457 : : // count the number of cylinder lines for each pincell
458 [ + + ]: 2 : for (int i=1; i<=m_nPincells; i++){
459 : : // read the no. of input lines first pincell
460 [ - + ]: 1 : if (!Parse.ReadNextLine (m_FileInput, m_nLineNumber, szInputString,
461 [ + - ]: 1 : MAXCHARS, szComment))
462 [ # # ]: 0 : IOErrorHandler (INVALIDINPUT);
463 [ + - ]: 1 : std::istringstream szFormatString1 (szInputString);
464 [ + - ][ + - ]: 1 : szFormatString1 >> szVolId >> szVolAlias >> nInputLines;
[ + - ]
465 [ + - ][ - + ]: 1 : if(szFormatString1.fail())
466 [ # # ]: 0 : IOErrorHandler(INVALIDINPUT);
467 : : // loop thru the input lines of each pincell
468 [ + + ]: 4 : for(int l=1; l<=nInputLines; l++){
469 [ - + ]: 3 : if (!Parse.ReadNextLine (m_FileInput, m_nLineNumber, szInputString,
470 [ + - ]: 3 : MAXCHARS, szComment))
471 [ # # ]: 0 : IOErrorHandler (INVALIDINPUT);
472 [ + - ][ + - ]: 3 : if (szInputString.substr(0,8) == "cylinder"){
[ + + ]
473 : 1 : ++nCyl;
474 : : }
475 [ + - ][ + - ]: 3 : if (szInputString.substr(0,12) == "cellmaterial"){
[ - + ]
476 : 0 : ++nCellMat;
477 : : }
478 : : }
479 : :
480 : : // set the sizes
481 [ + - ]: 1 : if (nCyl>0) {
482 [ - + ]: 1 : if (nCellMat > 0) {
483 [ # # ][ # # ]: 0 : m_Pincell(i).SetCellMatSize(nCellMat);
484 : : }
485 [ + - ][ + - ]: 1 : m_Pincell(i).SetNumCyl(nCyl);
486 : : }
487 [ # # ]: 0 : else if (nCyl ==0) {
488 : : // used to be nInputLines > 0 . . . is it an error if
489 : : // neither a cylinder nor a material line in the pin cell input?
490 [ # # ]: 0 : if (nCellMat > 0)
491 [ # # ][ # # ]: 0 : m_Pincell(i).SetCellMatSize(nCellMat);
492 : : }
493 : 1 : nCyl = 0;
494 : 1 : nCellMat = 0;
495 : 2 : }
496 : : }
497 : : // breaking condition
498 [ + - ][ + - ]: 17 : if(szInputString.substr(0,3) == "end"){
[ + + ]
499 [ + - ]: 1 : std::istringstream szFormatString (szInputString);
500 : 1 : break;
501 : : }
502 : 16 : }
503 : :
504 : : // //ACIS ENGINE
505 : : //#ifdef HAVE_ACIS
506 : : // // if(m_szEngine == "acis"){
507 : : // m_szGeomFile = m_InputFile+".sat";
508 : : // // }
509 : : //#elif defined(HAVE_OCC)
510 : : // // OCC ENGINE
511 : : // // if (m_szEngine == "occ"){
512 : : // m_szG= m_InputFile+".stp";
513 : : // // }
514 : : //#endif
515 : : // std::cout << "\no/p geometry file name: " << m_szGeomFile <<std::endl;
516 : :
517 : : //Rewind the input file
518 [ + - ]: 1 : m_FileInput.clear (std::ios_base::goodbit);
519 [ + - ]: 1 : m_FileInput.seekg (0L, std::ios::beg);
520 : 1 : m_nLineNumber = 0;
521 : : // CParser Parse;
522 : : // std::string card;
523 : :
524 : : // start reading the input file break when encounter end
525 : : for(;;){
526 [ - + ]: 17 : if (!Parse.ReadNextLine (m_FileInput, m_nLineNumber, szInputString,
527 [ + - ]: 17 : MAXCHARS, szComment))
528 [ # # ]: 0 : IOErrorHandler (INVALIDINPUT);
529 [ + - ][ + - ]: 17 : if (szInputString.substr(0,12) == "geometrytype"){
[ + + ]
530 [ + - ]: 1 : std::istringstream szFormatString (szInputString);
531 [ + - ][ + - ]: 1 : szFormatString >> card >> m_szGeomType;
532 [ + - ][ - + ]: 3 : if( ((strcmp (m_szGeomType.c_str(), "hexagonal") != 0) &&
533 [ + - ][ + - ]: 2 : (strcmp (m_szGeomType.c_str(), "rectangular") != 0)) || szFormatString.fail())
[ - + ]
534 [ # # ]: 0 : IOErrorHandler(EGEOMTYPE);
535 : :
536 : : // set the number of sides in the geometry
537 [ + - ][ - + ]: 1 : if(m_szGeomType == "hexagonal")
538 : 0 : m_nSides = 6;
539 [ + - ][ + - ]: 1 : else if(m_szGeomType == "rectangular")
540 : 1 : m_nSides = 4;
541 : : }
542 [ + - ][ + - ]: 16 : else if (szInputString.substr(0,8) == "geometry"){
[ - + ]
543 [ # # ]: 0 : std::string outfile;
544 [ # # ]: 0 : std::istringstream szFormatString (szInputString);
545 [ # # ][ # # ]: 0 : szFormatString >> card >> outfile;
546 [ # # ][ # # ]: 0 : if(strcmp (outfile.c_str(), "surface") == 0 || szFormatString.fail())
[ # # ][ # # ]
547 : 0 : m_nPlanar=1;
548 : : }
549 [ + - ][ + - ]: 17 : if ((szInputString.substr(0,9) == "materials") && (szInputString.substr(0,19) != "materialset_startid")){
[ + + ][ + - ]
[ + - ][ + - ]
[ + + ][ + - ]
[ + + # #
# # ]
550 : :
551 [ + - ]: 1 : std::istringstream szFormatString (szInputString);
552 [ + - ][ + - ]: 1 : szFormatString >> card >> m_nAssemblyMat;
553 [ + - ][ - + ]: 1 : if(szFormatString.fail())
554 [ # # ]: 0 : IOErrorHandler(INVALIDINPUT);
555 [ + - ][ + - ]: 1 : m_szAssmMat.SetSize(m_nAssemblyMat); m_szAssmMatAlias.SetSize(m_nAssemblyMat);
556 [ + + ]: 4 : for (int j=1; j<=m_nAssemblyMat; j++){
557 [ + - ][ + - ]: 3 : szFormatString >> m_szAssmMat(j) >> m_szAssmMatAlias(j);
[ + - ][ + - ]
558 [ + - ]: 6 : if( (strcmp (m_szAssmMat(j).c_str(), "") == 0) ||
[ + - - + ]
[ - + ]
559 [ + - ]: 3 : (strcmp (m_szAssmMatAlias(j).c_str(), "") == 0)){
560 [ # # ]: 0 : IOErrorHandler(EMAT);
561 : : }
562 : : // checking if & inserted at the end of the material by mistake
563 [ + + ]: 3 : if (j == m_nAssemblyMat){
564 [ + - ]: 1 : std::string dummy = "";
565 [ + - ]: 1 : szFormatString >> dummy;
566 [ - + ]: 1 : if (strcmp (dummy.c_str(), "") != 0)
567 [ # # ]: 1 : IOErrorHandler(EMAT);
568 : : }
569 : 1 : }
570 : : }
571 [ + - ][ + - ]: 51 : if( (szInputString.substr(0,10) == "dimensions") ||
[ + - ][ + + ]
[ + - ]
[ + + # # ]
572 [ + - ][ + - ]: 34 : (szInputString.substr(0,4) == "duct") ){
[ + - ][ # # ]
573 : :
574 : 1 : ++m_nDuctNum;
575 [ + - ][ + - ]: 1 : std::cout << "getting assembly dimensions " << m_nDuctNum << std::endl;
[ + - ]
576 : :
577 [ + - ][ - + ]: 1 : if(m_szGeomType =="hexagonal"){
578 [ # # ]: 0 : std::istringstream szFormatString (szInputString);
579 : :
580 [ # # ]: 0 : if(m_nDuctNum == 1){
581 [ # # ][ # # ]: 0 : m_dMXYAssm.SetSize(m_nDuct, 2); m_dMZAssm.SetSize(m_nDuct, 2);
582 : : }
583 [ # # ][ # # ]: 0 : szFormatString >> card >> m_nDimensions
584 [ # # ][ # # ]: 0 : >> m_dMXYAssm(m_nDuctNum, 1) >> m_dMXYAssm(m_nDuctNum, 2)
[ # # ][ # # ]
585 [ # # ][ # # ]: 0 : >> m_dMZAssm(m_nDuctNum, 1) >> m_dMZAssm(m_nDuctNum, 2);
[ # # ][ # # ]
586 [ # # ]: 0 : if(m_nDuctNum == 1){
587 [ # # ][ # # ]: 0 : m_dMAssmPitch.SetSize(m_nDuct, m_nDimensions); m_szMMAlias.SetSize(m_nDuct, m_nDimensions);
588 : :
589 [ # # ]: 0 : assms.resize(m_nDimensions*m_nDuct); // setup while reading the problem size
590 : : }
591 : :
592 [ # # ]: 0 : for (int i=1; i<=m_nDimensions; i++){
593 [ # # ][ # # ]: 0 : szFormatString >> m_dMAssmPitch(m_nDuctNum, i);
594 [ # # ][ # # ]: 0 : if( m_dMAssmPitch(m_nDuctNum, i) < 0 )
595 [ # # ]: 0 : IOErrorHandler(ENEGATIVE);
596 : : }
597 : :
598 [ # # ]: 0 : for (int i=1; i<=m_nDimensions; i++){
599 [ # # ][ # # ]: 0 : szFormatString >> m_szMMAlias(m_nDuctNum, i);
600 [ # # ][ # # ]: 0 : if(strcmp (m_szMMAlias(m_nDuctNum, i).c_str(), "") == 0)
601 [ # # ]: 0 : IOErrorHandler(EALIAS);
602 : 0 : }
603 : : }
604 [ + - ][ + - ]: 1 : if(m_szGeomType =="rectangular"){
605 [ + - ]: 1 : std::istringstream szFormatString (szInputString);
606 [ + - ]: 1 : if(m_nDuctNum == 1){
607 [ + - ]: 1 : m_dMXYAssm.SetSize(m_nDuct, 2);
608 [ + - ]: 1 : m_dMZAssm.SetSize(m_nDuct, 2);
609 : : }
610 [ + - ][ + - ]: 1 : szFormatString >> card >> m_nDimensions
611 [ + - ][ + - ]: 2 : >> m_dMXYAssm(m_nDuctNum, 1) >> m_dMXYAssm(m_nDuctNum, 2)
[ + - ][ + - ]
612 [ + - ][ + - ]: 2 : >> m_dMZAssm(m_nDuctNum, 1) >> m_dMZAssm(m_nDuctNum, 2);
[ + - ][ + - ]
613 [ + - ][ - + ]: 1 : if (szFormatString.fail())
614 [ # # ]: 0 : IOErrorHandler(INVALIDINPUT);
615 [ + - ]: 1 : if(m_nDuctNum == 1){
616 [ + - ]: 1 : m_dMAssmPitchX.SetSize(m_nDuct, m_nDimensions);
617 [ + - ]: 1 : m_dMAssmPitchY.SetSize(m_nDuct, m_nDimensions);
618 [ + - ]: 1 : m_szMMAlias.SetSize(m_nDuct, m_nDimensions);
619 [ + - ]: 1 : assms.resize(m_nDimensions*m_nDuct);
620 : : }
621 [ + + ]: 3 : for (int i=1; i<=m_nDimensions; i++){
622 [ + - ][ + - ]: 2 : szFormatString >> m_dMAssmPitchX(m_nDuctNum, i) >> m_dMAssmPitchY(m_nDuctNum, i);
[ + - ][ + - ]
623 [ + - ][ + - ]: 2 : if( m_dMAssmPitchX(m_nDuctNum, i) < 0 || m_dMAssmPitchY(m_nDuctNum, i) < 0 || szFormatString.fail())
[ + - ][ + - ]
[ + - ][ - + ]
[ - + ]
624 [ # # ]: 0 : IOErrorHandler(ENEGATIVE);
625 : : }
626 : :
627 [ + + ]: 3 : for (int i=1; i<=m_nDimensions; i++){
628 [ + - ][ + - ]: 2 : szFormatString >> m_szMMAlias(m_nDuctNum, i);
629 [ + - ][ + - ]: 2 : if(strcmp (m_szMMAlias(m_nDuctNum, i).c_str(), "") == 0 || szFormatString.fail())
[ + - ][ - + ]
[ - + ]
630 [ # # ]: 0 : IOErrorHandler(EALIAS);
631 : 1 : }
632 : : }
633 : : }
634 [ + - ][ + - ]: 17 : if (szInputString.substr(0,8) == "pincells"){
[ + + ]
635 [ + - ]: 1 : std::istringstream szFormatString (szInputString);
636 : :
637 [ + - ][ + - ]: 1 : szFormatString >> card >> m_nPincells >> m_dPitch;
[ + - ]
638 [ - + ]: 1 : if(m_nPincells < 0)
639 [ # # ]: 0 : IOErrorHandler(ENEGATIVE);
640 : :
641 : : // this is an option if a user wants to specify pitch here
642 : 1 : double dTotalHeight = 0.0;
643 : :
644 : : //get the number of cylinder in each pincell
645 : 1 : int nTemp = 1;
646 [ + - ]: 1 : if(m_nDimensions > 0){
647 [ + - ][ + - ]: 1 : dTotalHeight = m_dMZAssm(nTemp, 2)-m_dMZAssm(nTemp, 1);
648 : : }
649 : : else{
650 : 0 : dTotalHeight = 0; // nothing specified only pincells in the model
651 : : }
652 : :
653 : : // loop thro' the pincells and read/store pincell data
654 [ + + ]: 2 : for (int i=1; i<=m_nPincells; i++){
655 : :
656 : : // set pitch if specified in pincell card
657 [ - + ]: 1 : if(m_dPitch > 0.0)
658 [ # # ][ # # ]: 0 : m_Pincell(i).SetPitch(m_dPitch, dTotalHeight);
659 : :
660 [ + - ]: 1 : ReadPinCellData( i);
661 [ + - ][ + - ]: 1 : std::cout << "\nread pincell " << i << std::endl;
[ + - ]
662 : 1 : }
663 : : }
664 : :
665 : : // 'yes' or 'no' for creating sidesets
666 [ + - ][ + - ]: 17 : if (szInputString.substr(0,13) == "createsideset"){
[ + + ]
667 [ + - ]: 1 : std::istringstream szFormatString (szInputString);
668 [ + - ][ + - ]: 1 : szFormatString >> card >> m_szSideset;
669 [ + - ][ + - ]: 1 : std::cout <<"--------------------------------------------------"<<std::endl;
670 : : }
671 : : // specify a merge tolerance value for cubit journal file
672 [ + - ][ + - ]: 17 : if (szInputString.substr(0,14) == "mergetolerance"){
[ + + ]
673 [ + - ]: 1 : std::istringstream szFormatString (szInputString);
674 [ + - ][ + - ]: 1 : szFormatString >> card >> m_dMergeTol;
675 [ + - ][ + - ]: 1 : std::cout <<"--------------------------------------------------"<<std::endl;
676 : : } // Handle mesh size inputs
677 [ + - ][ + - ]: 17 : if (szInputString.substr(0,14) == "radialmeshsize"){
[ + + ]
678 [ + - ]: 1 : std::istringstream szFormatString (szInputString);
679 [ + - ][ + - ]: 1 : szFormatString >> card >> m_dRadialSize;
680 [ + - ][ + - ]: 1 : if(m_dRadialSize < 0 || szFormatString.fail())
[ - + ][ - + ]
681 [ # # ]: 0 : IOErrorHandler(ENEGATIVE);
682 [ + - ][ + - ]: 1 : std::cout <<"--------------------------------------------------"<<std::endl;
683 : :
684 : : }
685 : : // Handle mesh size inputs
686 [ + - ][ + - ]: 17 : if (szInputString.substr(0,11) == "tetmeshsize"){
[ - + ]
687 [ # # ]: 0 : std::istringstream szFormatString (szInputString);
688 [ # # ][ # # ]: 0 : szFormatString >> card >> m_dTetMeshSize;
689 [ # # ][ # # ]: 0 : if(m_dTetMeshSize < 0 || szFormatString.fail())
[ # # ][ # # ]
690 [ # # ]: 0 : IOErrorHandler(ENEGATIVE);
691 [ # # ][ # # ]: 0 : std::cout <<"--------------------------------------------------"<<std::endl;
692 : :
693 : : }
694 : : // Handle mesh size inputs
695 [ + - ][ + - ]: 17 : if (szInputString.substr(0,13) == "axialmeshsize"){
[ + + ]
696 [ + - ]: 1 : std::istringstream szFormatString (szInputString);
697 [ + - ][ + - ]: 1 : szFormatString >> card >> m_dAxialSize;
698 [ + - ][ + - ]: 1 : if(m_dAxialSize < 0 || szFormatString.fail())
[ - + ][ - + ]
699 [ # # ]: 0 : IOErrorHandler(ENEGATIVE);
700 [ + - ][ + - ]: 1 : std::cout <<"--------------------------------------------------"<<std::endl;
701 : :
702 : : }
703 : : // Handle mesh size inputs
704 [ + - ][ + - ]: 17 : if (szInputString.substr(0,18) == "neumannset_startid"){
[ - + ]
705 [ # # ]: 0 : std::istringstream szFormatString (szInputString);
706 [ # # ][ # # ]: 0 : szFormatString >> card >> m_nNeumannSetId;
707 [ # # ][ # # ]: 0 : if(m_nNeumannSetId < 0 || szFormatString.fail())
[ # # ][ # # ]
708 [ # # ]: 0 : IOErrorHandler(ENEGATIVE);
709 [ # # ][ # # ]: 0 : std::cout <<"--------------------------------------------------"<<std::endl;
710 : :
711 : : }
712 : : // Handle mesh size inputs
713 [ + - ][ + - ]: 17 : if (szInputString.substr(0,19) == "materialset_startid"){
[ - + ]
714 [ # # ]: 0 : std::istringstream szFormatString (szInputString);
715 [ # # ][ # # ]: 0 : szFormatString >> card >> m_nMaterialSetId;
716 [ # # ][ # # ]: 0 : if(m_nMaterialSetId < 0 || szFormatString.fail())
[ # # ][ # # ]
717 [ # # ]: 0 : IOErrorHandler(ENEGATIVE);
718 [ # # ][ # # ]: 0 : std::cout <<"--------------------------------------------------"<<std::endl;
719 : :
720 : : }
721 [ + - ][ + - ]: 17 : if (szInputString.substr(0,3) == "end"){
[ + + ]
722 : :
723 : :
724 : : // if ( m_nJouFlag == 0){
725 : : // // impring merge before saving
726 : : // // Imprint_Merge();
727 : :
728 : : // // save .sat file
729 : : // IBERRCHK(igeom->save(m_szGeomFile.c_str()), *igeom);
730 : : // std::cout << "Normal Termination.\n"<< "Geometry file: " << m_szGeomFile << " saved." << std::endl;
731 : : // }
732 : 1 : break;
733 : : }
734 : 16 : }
735 : :
736 : : // Done reading now load file
737 : :
738 [ + - ][ + - ]: 2 : IBERRCHK(igeom->load(m_GeomFile.c_str()), *igeom);
739 : :
740 : 1 : }
741 : :
742 : : ///////////////////////////////////////////////////////////////////////////////////////////
743 : :
744 : 1 : void AssyMesher::ReadPinCellData ( int i)
745 : : //---------------------------------------------------------------------------
746 : : //Function: reading pincell i from file and storing the data
747 : : //Input: none
748 : : //Output: none
749 : : //---------------------------------------------------------------------------
750 : : {
751 [ + - ]: 1 : CParser Parse;
752 [ + - ][ + - ]: 2 : std::string card, szVolId, szVolAlias, szIFlag;
[ + - ][ + - ]
753 : 1 : int nInputLines, nMaterials, nCyl = 0, nRadii=0, nCellMat=0;
754 : 1 : double dLZ=0.0, dFlatF=0.0, dPX=0.0, dPY=0.0, dPZ=0.0;
755 [ + - ][ + - ]: 2 : CVector <std::string> szVMatName, szVMatAlias, szVCylMat, szVCellMat;
[ + - ][ + - ]
756 [ + - ][ + - ]: 2 : CVector<double> dVCoor(2), dVCylRadii, dVCylZPos, dZVStart, dZVEnd;
[ + - ][ + - ]
[ + - ]
757 : :
758 : : //loop over input lines
759 [ + - ][ + - ]: 1 : if (m_szGeomType == "rectangular"){
760 : :
761 [ + - ]: 1 : std::cout << "\ngetting volume id";
762 [ - + ]: 1 : if (!Parse.ReadNextLine (m_FileInput, m_nLineNumber, szInputString,
763 [ + - ]: 1 : MAXCHARS, szComment))
764 [ # # ]: 0 : IOErrorHandler (INVALIDINPUT);
765 [ + - ]: 1 : std::istringstream szFormatString (szInputString);
766 [ + - ][ + - ]: 1 : szFormatString >> szVolId >> szVolAlias >> nInputLines >> szIFlag;
[ + - ][ + - ]
767 : :
768 : : // error checking
769 [ + - - + ]: 2 : if( (strcmp (szVolAlias.c_str(), "") == 0) ||
[ - + ]
770 : 1 : (strcmp (szVolId.c_str(), "") == 0))
771 [ # # ]: 0 : IOErrorHandler(EPIN);
772 [ - + ]: 1 : if( nInputLines < 0 )
773 [ # # ]: 0 : IOErrorHandler(ENEGATIVE);
774 : :
775 [ + - ][ + - ]: 1 : m_Pincell(i).SetLineOne (szVolId, szVolAlias, nInputLines);
[ + - ][ + - ]
776 [ + - ][ - + ]: 1 : if(szIFlag == "intersect"){
777 [ # # ][ # # ]: 0 : m_Pincell(i).SetIntersectFlag(1);
778 : : }
779 : : else{
780 [ + - ][ + - ]: 1 : m_Pincell(i).SetIntersectFlag(0);
781 : : }
782 [ + + ]: 4 : for(int l=1; l<=nInputLines; l++){
783 [ - + ]: 3 : if (!Parse.ReadNextLine (m_FileInput, m_nLineNumber, szInputString,
784 [ + - ]: 3 : MAXCHARS, szComment))
785 [ # # ]: 0 : IOErrorHandler (INVALIDINPUT);
786 [ + - ][ + - ]: 3 : if (szInputString.substr(0,5) == "pitch"){
[ + + ]
787 : :
788 [ + - ]: 1 : std::istringstream szFormatString (szInputString);
789 [ + - ]: 1 : std::cout << "\ngetting pitch data";
790 [ + - ][ + - ]: 1 : szFormatString >> card >> dPX >> dPY >> dPZ;
[ + - ][ + - ]
791 : :
792 [ + - ][ + - ]: 1 : if( dPX < 0 || dPY < 0 || dPZ < 0 || szFormatString.fail())
[ + - ][ + - ]
[ - + ][ - + ]
793 [ # # ]: 0 : IOErrorHandler(ENEGATIVE);
794 [ + - ][ + - ]: 1 : m_Pincell(i).SetPitch (dPX, dPY, dPZ);
795 : : }
796 [ + - ][ + - ]: 3 : if (szInputString.substr(0,9) == "materials"){
[ - + ]
797 : :
798 [ # # ]: 0 : std::istringstream szFormatString (szInputString);
799 [ # # ][ # # ]: 0 : szFormatString >> card >> nMaterials;
800 [ # # ][ # # ]: 0 : if(szFormatString.fail())
801 [ # # ]: 0 : IOErrorHandler(INVALIDINPUT);
802 : :
803 : : //setting local arrays
804 [ # # ]: 0 : szVMatName.SetSize(nMaterials);
805 [ # # ]: 0 : szVMatAlias.SetSize(nMaterials);
806 : :
807 : : //set class variable sizes
808 [ # # ][ # # ]: 0 : m_Pincell(i).SetMatArray(nMaterials);
809 [ # # ]: 0 : std::cout << "\ngetting material data";
810 [ # # ]: 0 : for(int j=1; j<= nMaterials; j++){
811 [ # # ][ # # ]: 0 : szFormatString >> szVMatName(j) >> szVMatAlias(j);
[ # # ][ # # ]
812 [ # # ][ # # ]: 0 : if(szFormatString.fail())
813 [ # # ]: 0 : IOErrorHandler(INVALIDINPUT);
814 : : }
815 [ # # ][ # # ]: 0 : m_Pincell(i).SetMat(szVMatName, szVMatAlias);
[ # # ][ # # ]
816 : : }
817 [ + - ][ + - ]: 3 : if (szInputString.substr(0,8) == "cylinder"){
[ + + ]
818 : :
819 : 1 : ++nCyl;
820 [ + - ]: 1 : std::cout << "\ngetting cylinder data";
821 [ + - ]: 1 : std::istringstream szFormatString (szInputString);
822 [ + - ][ + - ]: 1 : szFormatString >> card >> nRadii >> dVCoor(1) >> dVCoor(2);
[ + - ][ + - ]
[ + - ][ + - ]
823 [ + - ][ - + ]: 1 : if(szFormatString.fail())
824 [ # # ]: 0 : IOErrorHandler(INVALIDINPUT);
825 [ + - ][ + - ]: 1 : m_Pincell(i).SetCylSizes(nCyl, nRadii);
826 [ + - ][ + - ]: 1 : m_Pincell(i).SetCylPos(nCyl, dVCoor);
[ + - ]
827 : :
828 : : //set local array
829 [ + - ]: 1 : dVCylRadii.SetSize(2*nRadii);
830 [ + - ]: 1 : szVCylMat.SetSize(nRadii);
831 [ + - ]: 1 : dVCylZPos.SetSize(2);
832 [ + - ][ + - ]: 1 : m_Pincell(i).SetCylSizes(nCyl, nRadii);
833 : :
834 : : // reading ZCoords
835 [ + + ]: 3 : for(int k=1; k<=2; k++){
836 [ + - ][ + - ]: 2 : szFormatString >> dVCylZPos(k);
837 [ + - ][ - + ]: 2 : if(szFormatString.fail())
838 [ # # ]: 0 : IOErrorHandler(INVALIDINPUT);
839 : : }
840 [ + - ][ + - ]: 1 : m_Pincell(i).SetCylZPos(nCyl, dVCylZPos);
[ + - ]
841 : :
842 : : // reading Radii
843 [ + + ]: 2 : for(int l=1; l<= nRadii; l++){
844 [ + - ][ + - ]: 1 : szFormatString >> dVCylRadii(l);
845 [ + - ][ + - ]: 1 : if( dVCylRadii(l) < 0 || szFormatString.fail())
[ + - ][ - + ]
[ - + ]
846 [ # # ]: 0 : IOErrorHandler(ENEGATIVE);
847 : : }
848 [ + - ][ + - ]: 1 : m_Pincell(i).SetCylRadii(nCyl, dVCylRadii);
[ + - ]
849 : :
850 : : // reading Material alias
851 [ + + ]: 2 : for(int m=1; m<= nRadii; m++){
852 [ + - ][ + - ]: 1 : szFormatString >> szVCylMat(m);
853 [ + - ][ + - ]: 1 : if(strcmp (szVCylMat(m).c_str(), "") == 0 || szFormatString.fail())
[ + - ][ - + ]
[ - + ]
854 [ # # ]: 0 : IOErrorHandler(EALIAS);
855 : : }
856 [ + - ][ + - ]: 1 : m_Pincell(i).SetCylMat(nCyl, szVCylMat);
[ + - ]
857 : : }
858 [ + - ][ + - ]: 3 : if (szInputString.substr(0,12) == "cellmaterial"){
[ - + ]
859 : :
860 [ # # ]: 0 : std::cout << "\ngetting cell material data\n";
861 [ # # ]: 0 : std::istringstream szFormatString (szInputString);
862 [ # # ]: 0 : szFormatString >> card;
863 : :
864 : : //set local arrays
865 [ # # ][ # # ]: 0 : m_Pincell(i).GetCellMatSize(nCellMat); // since size of cell material already set equal to number of cylinders
866 [ # # ]: 0 : dZVStart.SetSize(nCellMat);
867 [ # # ]: 0 : dZVEnd.SetSize(nCellMat);
868 [ # # ]: 0 : szVCellMat.SetSize(nCellMat);
869 : :
870 [ # # ]: 0 : for(int k=1; k<=nCellMat; k++){
871 [ # # ][ # # ]: 0 : szFormatString >> dZVStart(k)>> dZVEnd(k) >> szVCellMat(k);
[ # # ][ # # ]
[ # # ][ # # ]
872 [ # # ][ # # ]: 0 : if(strcmp (szVCellMat(k).c_str(), "") == 0 || szFormatString.fail())
[ # # ][ # # ]
[ # # ]
873 [ # # ]: 0 : IOErrorHandler(EALIAS);
874 : : }
875 [ # # ][ # # ]: 0 : m_Pincell(i).SetCellMat(dZVStart, dZVEnd, szVCellMat);
[ # # ][ # # ]
[ # # ]
876 : : }
877 : 1 : }
878 : : }//if rectangular ends
879 : :
880 [ + - ][ - + ]: 1 : if (m_szGeomType == "hexagonal"){
881 : :
882 [ # # ]: 0 : std::cout << "\ngetting volume id";
883 [ # # ]: 0 : if (!Parse.ReadNextLine (m_FileInput, m_nLineNumber, szInputString,
884 [ # # ]: 0 : MAXCHARS, szComment))
885 [ # # ]: 0 : IOErrorHandler (INVALIDINPUT);
886 [ # # ]: 0 : std::istringstream szFormatString (szInputString);
887 [ # # ][ # # ]: 0 : szFormatString >> szVolId >> szVolAlias >> nInputLines >> szIFlag;
[ # # ][ # # ]
888 : :
889 : : // error checking
890 [ # # # # ]: 0 : if( (strcmp (szVolAlias.c_str(), "") == 0) ||
[ # # ]
891 : 0 : (strcmp (szVolId.c_str(), "") == 0))
892 [ # # ]: 0 : IOErrorHandler(EPIN);
893 [ # # ]: 0 : if( nInputLines < 0 )
894 [ # # ]: 0 : IOErrorHandler(ENEGATIVE);
895 : :
896 [ # # ][ # # ]: 0 : m_Pincell(i).SetLineOne (szVolId, szVolAlias, nInputLines);
[ # # ][ # # ]
897 [ # # ][ # # ]: 0 : if(szIFlag == "intersect"){
898 [ # # ][ # # ]: 0 : m_Pincell(i).SetIntersectFlag(1);
899 : : }
900 : : else{
901 [ # # ][ # # ]: 0 : m_Pincell(i).SetIntersectFlag(0);
902 : : }
903 [ # # ]: 0 : for(int l=1; l<=nInputLines; l++){
904 [ # # ]: 0 : if (!Parse.ReadNextLine (m_FileInput, m_nLineNumber, szInputString,
905 [ # # ]: 0 : MAXCHARS, szComment))
906 [ # # ]: 0 : IOErrorHandler (INVALIDINPUT);
907 [ # # ][ # # ]: 0 : if (szInputString.substr(0,5) == "pitch"){
[ # # ]
908 : :
909 [ # # ]: 0 : std::istringstream szFormatString (szInputString);
910 [ # # ]: 0 : std::cout << "\ngetting pitch data";
911 [ # # ][ # # ]: 0 : szFormatString >> card >> dFlatF >> dLZ;
[ # # ]
912 [ # # ][ # # ]: 0 : if( dFlatF < 0 || dLZ < 0 || szFormatString.fail())
[ # # ][ # # ]
[ # # ]
913 [ # # ]: 0 : IOErrorHandler(ENEGATIVE);
914 [ # # ][ # # ]: 0 : m_Pincell(i).SetPitch (dFlatF, dLZ);
915 : : }
916 [ # # ][ # # ]: 0 : if (szInputString.substr(0,9) == "materials"){
[ # # ]
917 : :
918 [ # # ]: 0 : std::istringstream szFormatString (szInputString);
919 [ # # ][ # # ]: 0 : szFormatString >> card >> nMaterials;
920 [ # # ][ # # ]: 0 : if(szFormatString.fail())
921 [ # # ]: 0 : IOErrorHandler(INVALIDINPUT);
922 : : //setting local arrays
923 [ # # ]: 0 : szVMatName.SetSize(nMaterials);
924 [ # # ]: 0 : szVMatAlias.SetSize(nMaterials);
925 : :
926 : : //set class variable sizes
927 [ # # ][ # # ]: 0 : m_Pincell(i).SetMatArray(nMaterials);
928 [ # # ]: 0 : std::cout << "\ngetting material data";
929 [ # # ]: 0 : for(int j=1; j<= nMaterials; j++){
930 [ # # ][ # # ]: 0 : szFormatString >> szVMatName(j) >> szVMatAlias(j);
[ # # ][ # # ]
931 [ # # ][ # # ]: 0 : if(szFormatString.fail())
932 [ # # ]: 0 : IOErrorHandler(INVALIDINPUT);
933 : : }
934 [ # # ][ # # ]: 0 : m_Pincell(i).SetMat(szVMatName, szVMatAlias);
[ # # ][ # # ]
935 : : }
936 [ # # ][ # # ]: 0 : if (szInputString.substr(0,8) == "cylinder"){
[ # # ]
937 : :
938 : 0 : ++nCyl;
939 [ # # ]: 0 : std::cout << "\ngetting cylinder data";
940 [ # # ]: 0 : std::istringstream szFormatString (szInputString);
941 [ # # ][ # # ]: 0 : szFormatString >> card >> nRadii >> dVCoor(1) >> dVCoor(2);
[ # # ][ # # ]
[ # # ][ # # ]
942 [ # # ][ # # ]: 0 : if(szFormatString.fail())
943 [ # # ]: 0 : IOErrorHandler(INVALIDINPUT);
944 [ # # ][ # # ]: 0 : m_Pincell(i).SetCylSizes(nCyl, nRadii);
945 [ # # ][ # # ]: 0 : m_Pincell(i).SetCylPos(nCyl, dVCoor);
[ # # ]
946 : :
947 : : //set local array
948 [ # # ]: 0 : dVCylRadii.SetSize(nRadii);
949 [ # # ]: 0 : szVCylMat.SetSize(nRadii);
950 [ # # ]: 0 : dVCylZPos.SetSize(2);
951 : : //
952 [ # # ][ # # ]: 0 : m_Pincell(i).SetCylSizes(nCyl, nRadii);
953 : :
954 : : // reading ZCoords - max and min 2 always
955 [ # # ]: 0 : for(int k=1; k<=2; k++)
956 [ # # ][ # # ]: 0 : szFormatString >> dVCylZPos(k);
957 [ # # ][ # # ]: 0 : m_Pincell(i).SetCylZPos(nCyl, dVCylZPos);
[ # # ]
958 : :
959 : : // reading Radii
960 [ # # ]: 0 : for(int l=1; l<= nRadii; l++){
961 [ # # ][ # # ]: 0 : szFormatString >> dVCylRadii(l);
962 [ # # ][ # # ]: 0 : if( dVCylRadii(l) < 0 || szFormatString.fail())
[ # # ][ # # ]
[ # # ]
963 [ # # ]: 0 : IOErrorHandler(ENEGATIVE);
964 : : }
965 [ # # ][ # # ]: 0 : m_Pincell(i).SetCylRadii(nCyl, dVCylRadii);
[ # # ]
966 : :
967 : : // reading Material alias
968 [ # # ]: 0 : for(int m=1; m<= nRadii; m++){
969 [ # # ][ # # ]: 0 : szFormatString >> szVCylMat(m);
970 [ # # ][ # # ]: 0 : if(strcmp (szVCylMat(m).c_str(), "") == 0 || szFormatString.fail())
[ # # ][ # # ]
[ # # ]
971 [ # # ]: 0 : IOErrorHandler(EALIAS);
972 : : }
973 : :
974 [ # # ][ # # ]: 0 : m_Pincell(i).SetCylMat(nCyl, szVCylMat);
[ # # ]
975 : : }
976 [ # # ][ # # ]: 0 : if (szInputString.substr(0,12) == "cellmaterial"){
[ # # ]
977 : :
978 [ # # ]: 0 : std::cout << "\ngetting cell material data";
979 [ # # ]: 0 : std::istringstream szFormatString (szInputString);
980 [ # # ]: 0 : szFormatString >> card;
981 : :
982 : : //set local arrays
983 [ # # ][ # # ]: 0 : m_Pincell(i).GetCellMatSize(nCellMat); // since size of cell material already set equal to number of cylinders
984 [ # # ]: 0 : dZVStart.SetSize(nCellMat);
985 [ # # ]: 0 : dZVEnd.SetSize(nCellMat);
986 [ # # ]: 0 : szVCellMat.SetSize(nCellMat);
987 : :
988 [ # # ]: 0 : for(int k=1; k<=nCellMat; k++){
989 [ # # ][ # # ]: 0 : szFormatString >> dZVStart(k)>> dZVEnd(k) >> szVCellMat(k);
[ # # ][ # # ]
[ # # ][ # # ]
990 [ # # ][ # # ]: 0 : if(strcmp (szVCellMat(k).c_str(), "") == 0 || szFormatString.fail())
[ # # ][ # # ]
[ # # ]
991 [ # # ]: 0 : IOErrorHandler(EALIAS);
992 : : }
993 [ # # ][ # # ]: 0 : m_Pincell(i).SetCellMat(dZVStart, dZVEnd, szVCellMat);
[ # # ][ # # ]
[ # # ]
994 : : }
995 : 0 : }
996 : 1 : }// if hexagonal end
997 : :
998 : 1 : }
999 : :
1000 : :
1001 : 0 : void AssyMesher::IOErrorHandler (ErrorStates ECode) const
1002 : : // ---------------------------------------------------------------------------
1003 : : //! Function: Displays error messages related to input data \n
1004 : : //! Input: Error code \n
1005 : : //! Output: none \n
1006 : : // ---------------------------------------------------------------------------
1007 : : {
1008 : 0 : std::cerr << '\n';
1009 : :
1010 [ # # ]: 0 : if (ECode == PINCELLS) // invalid number of pincells
1011 : 0 : std::cerr << "Number of pincells must be >= 0.";
1012 [ # # ]: 0 : else if (ECode == INVALIDINPUT) // invalid input
1013 : 0 : std::cerr << "Invalid input.";
1014 [ # # ]: 0 : else if (ECode == EMAT) // invalid input
1015 : 0 : std::cerr << "Invalid Material Data.";
1016 [ # # ]: 0 : else if (ECode == EGEOMTYPE) // invalid input
1017 : 0 : std::cerr << "Invalid GeomType Data.";
1018 [ # # ]: 0 : else if (ECode == EGEOMENGINE) // invalid input
1019 : 0 : std::cerr << "Invalid Geometry Engine.";
1020 [ # # ]: 0 : else if (ECode == EALIAS) // invalid input
1021 : 0 : std::cerr << "Error Reading Aliases.";
1022 [ # # ]: 0 : else if (ECode == ENEGATIVE) // invalid input
1023 : 0 : std::cerr << "Unexpected negative value.";
1024 [ # # ]: 0 : else if (ECode == EPIN) // invalid input
1025 : 0 : std::cerr << "Invalid pinCell specs.";
1026 : : else
1027 : 0 : std::cerr << "Unknown error ...?";
1028 : :
1029 : 0 : std::cerr << '\n' << "Error in input file line : " << m_nLineNumber;
1030 : 0 : std::cerr << std::endl;
1031 : 0 : exit (1);
1032 : : }
1033 : :
1034 : 1 : std::vector<iGeom::EntityHandle>* AssyMesher::selectByMaterialsAndNameSuffix(
1035 : : std::vector<iGeom::EntityHandle> const &geoEntVec,
1036 : : std::set<std::string> const &matFilter, const char* suffix) const
1037 : : {
1038 : : // get the name tag
1039 : : iGeom::TagHandle nameTag;
1040 : : int tagSize;
1041 [ + - ]: 1 : igeom->getTagHandle("NAME", nameTag);
1042 [ + - ]: 1 : igeom->getTagSizeBytes(nameTag, tagSize);
1043 : :
1044 : : // get the length of the suffix
1045 : 1 : int suffixLen = strlen(suffix);
1046 : :
1047 : : // allocate space to store the entity name retrieved from geometric entity
1048 [ + - ]: 1 : char* entName = new char[tagSize];
1049 : :
1050 : : // allocate the vector that will be recturned
1051 : : std::vector<iGeom::EntityHandle> *selectedEnts =
1052 [ + - ][ + - ]: 1 : new std::vector<iGeom::EntityHandle>;
1053 : :
1054 [ + + ]: 19 : for (unsigned int ei = 0; ei < geoEntVec.size(); ++ei)
1055 : : {
1056 : 18 : entName[0] = 0;
1057 [ + - ][ + - ]: 18 : igeom->getData(geoEntVec[ei], nameTag, entName);
1058 : : // TODO: error check for result == iBase_SUCCESS
1059 : : // it should always be true for current code of CGM
1060 : :
1061 : : // the suffix, if present, should end at the first @ character in the
1062 : : // name or at the end of the name if there are no @ characters
1063 : 18 : size_t enLen = strlen(entName);
1064 : 18 : char* endMatchChar = strchr(entName, '@');
1065 [ + + ]: 18 : if (endMatchChar == NULL)
1066 : : {
1067 : 15 : endMatchChar = &entName[enLen];
1068 : : }
1069 : :
1070 : : // if the suffix is present
1071 [ + - ][ + + ]: 18 : if ((endMatchChar - entName) > suffixLen &&
1072 : 18 : strncmp(endMatchChar - suffixLen, suffix, suffixLen) == 0)
1073 : : {
1074 : : // if the part of the name before the suffix is in the
1075 : : // set of acceptable materials
1076 [ + - ]: 4 : std::string matNameStr(entName, endMatchChar - suffixLen);
1077 [ + - ][ + - ]: 4 : if (matFilter.find(matNameStr) != matFilter.end())
[ + - ]
1078 : : {
1079 : : // add it to the vector
1080 [ + - ][ + - ]: 4 : selectedEnts->push_back(geoEntVec[ei]);
1081 : 4 : }
1082 : : }
1083 : : }
1084 : :
1085 : : // release the memory allocated for the entity name
1086 [ + - ]: 1 : delete[] entName;
1087 : :
1088 : 1 : return selectedEnts;
1089 : : }
1090 : :
1091 : 1 : void AssyMesher::createMaterialNeumannSets(std::set <std::string> const &matFilter){
1092 : : // Name by material names in AssyGen input file
1093 : :
1094 [ + - ]: 1 : std::set<std::string>::iterator it;
1095 : 1 : int matId = 1;
1096 : : moab::Tag geomTag, matTag, neuTag, nameTag;
1097 [ + - ]: 1 : mb->tag_get_handle( "MATERIAL_SET", matTag );
1098 : : //mb->tag_get_handle( "NAME", nameTag );
1099 : 1 : char dum_val[64] = {0};
1100 : : mb->tag_get_handle(NAME_TAG_NAME, NAME_TAG_SIZE, moab::MB_TYPE_OPAQUE,
1101 [ + - ]: 1 : nameTag, moab::MB_TAG_SPARSE | moab::MB_TAG_CREAT, dum_val);
1102 : :
1103 [ + - ][ + - ]: 4 : for(it = matFilter.begin(); it != matFilter.end(); ++it){
[ + + ]
1104 : :
1105 [ + - ][ + - ]: 3 : std::cout << *it << std::endl;
[ + - ]
1106 : : // std::string matName = *it;
1107 : :
1108 : : //create a material set with id=matId
1109 : : moab::EntityHandle jj; // material meshset
1110 [ + - ]: 3 : mb->create_meshset(moab::MESHSET_SET,jj);
1111 : :
1112 [ + - ]: 3 : mb->tag_set_data(matTag, &jj, 1, (void*)&matId);
1113 : : // mb->tag_set_data(nameTag, &jj, 1, (void*)matName.c_str());
1114 : : //TODO:
1115 : : // if(matName == volumeName){
1116 : : // // Add the set to this material set
1117 : : // }
1118 : 3 : ++matId;
1119 : : }
1120 : :
1121 : 1 : }
1122 : :
1123 : 0 : void AssyMesher::createMaterialNeumannSets()
1124 : : {
1125 : : iRel::PairHandle * pair;
1126 : : mk_core()->irel_instance()->createPair (
1127 [ # # ][ # # ]: 0 : mk_core()->igeom_instance()->instance(), iRel::ENTITY, iRel::IGEOM_IFACE, iRel::ACTIVE,
[ # # ]
1128 [ # # ][ # # ]: 0 : mk_core()->imesh_instance()->instance(), iRel::SET, iRel::IMESH_IFACE, iRel::ACTIVE, pair);
[ # # ][ # # ]
[ # # ][ # # ]
1129 : :
1130 [ # # ][ # # ]: 0 : int ixrel = mk_core()->add_irel_pair(pair);
1131 : :
1132 : :
1133 : : moab::Tag geomTag, matTag, neuTag;
1134 [ # # ]: 0 : mb->tag_get_handle( "MATERIAL_SET", matTag );
1135 [ # # ]: 0 : mb->tag_get_handle( "NEUMANN_SET", neuTag );
1136 : :
1137 [ # # ][ # # ]: 0 : geomTag = mk_core()->moab_geom_dim_tag();
1138 [ # # ][ # # ]: 0 : moab::Range geom_sets[2];
[ # # ]
1139 : : moab::EntityHandle jj; // meshset
1140 : 0 : int ss = 0;
1141 : :
1142 : 0 : bool name_all_vol_surfs = true;
1143 [ # # ]: 0 : if(name_all_vol_surfs){
1144 [ # # ]: 0 : for(unsigned dim=2; dim<4; dim++) {
1145 : 0 : void *val[] = {&dim};
1146 : : mb->get_entities_by_type_and_tag(0,
1147 [ # # ]: 0 : moab::MBENTITYSET, &geomTag, val, 1, geom_sets[ss], moab::Interface::UNION);
1148 : 0 : int n_id = 1, m_id = 1;
1149 [ # # ][ # # ]: 0 : for(moab::Range::iterator i=geom_sets[ss].begin(); i!=geom_sets[ss].end(); i++)
[ # # ][ # # ]
[ # # ]
1150 : : {
1151 [ # # ]: 0 : mb->create_meshset(moab::MESHSET_SET,jj);
1152 [ # # ][ # # ]: 0 : mb->add_entities(jj, &(*i), 1);
1153 [ # # ]: 0 : if (dim == 2){
1154 [ # # ]: 0 : mb->tag_set_data(neuTag, &jj, 1, (void*)&n_id);
1155 : 0 : n_id+=1;
1156 : : }
1157 : : else{
1158 [ # # ]: 0 : mb->tag_set_data(matTag, &jj, 1, (void*)&m_id);
1159 : 0 : m_id+=1;;
1160 : : }
1161 : : }
1162 : 0 : ss++;
1163 : : }
1164 [ # # # # ]: 0 : }
1165 : : // // get the name tag
1166 : : // iGeom::TagHandle nameTag;
1167 : : // //moab::Tag geomTag;
1168 : : // int tagSize;
1169 : : // int dim = 3;
1170 : : // void *val[] = {&dim};
1171 : : // igeom->getTagHandle("NAME", nameTag);
1172 : :
1173 : : // mb->get_entities_by_type_and_tag(0,
1174 : : // moab::MBENTITYSET, &geomTag, val, 1, geom_sets[0], moab::Interface::UNION);
1175 : : // std::cout << geom_sets[0].size() << std::endl;
1176 : : // char matname[64];
1177 : : // mb->tag_get_data(nameTag, &geom_sets[0].front(), 1, &matname);
1178 : : // std::cout << matname << std::endl;
1179 : :
1180 : :
1181 : :
1182 : : // moab::Range vol_sets, surf_sets;
1183 : : // int dim = 3;
1184 : : // void *val[] = {&dim};
1185 : : // mb->get_entities_by_type_and_tag(0,
1186 : : // moab::MBENTITYSET, &geomTag, val, 1, vol_sets, moab::Interface::UNION);
1187 : : // dim = 2;
1188 : : // void *val2[] = {&dim};
1189 : : // mb->get_entities_by_type_and_tag(0,
1190 : : // moab::MBENTITYSET, &geomTag, val2, 1, surf_sets, moab::Interface::UNION);
1191 : :
1192 : :
1193 : : //MBERRCHK(rval, mk_core()->moab_instance());
1194 : :
1195 : :
1196 : :
1197 : : // igeom->getTagSizeBytes(nameTag, tagSize);
1198 : :
1199 : :
1200 : :
1201 : :
1202 [ # # ]: 0 : }
1203 : :
1204 [ + - ][ + - ]: 156 : } // namespace MeshKit
|
