## ## 'awk' PROGRAM NAME: feinp_generic2stl_awkprog ## in $FEDIR/scripts ## where FEDIR=/apps/nns_com/fea ## ## Was 'nasinp_generic2stl_awkprog' to 12Sep2000. ######################################################################## ## PURPOSE: ## ## ** This awk program is called by ## ** $FEDIR/scripts/feinp_nas2stl_bygui ## ** to translate a NASTRAN input file containing GRID & element records ## ** ## ** (like 2D-elements: CTRIA3, CTRIA6, CTRIAR, CQUAD4, CQUAD8, CQUADR, ## ** 3D-elements: CTETRA, CPENTA, CHEXA ## ** and perhaps someday some 1D-elements) ## ** into an STL file. ## ## --------------- ## OTHER-USES NOTE (non-NASTRAN): ## ## This awk-prog could be called by an ## - 'feinp_abq2stl_bygui' utility to create an STL file from ## ABAQUS input, ## or by an ## - 'feinp_idesim2stl_bygui' utility to create an STL file from ## an I-DEAS Simulation Universal file, ## etc. ## ## ----------------------- ## NASTRAN PROCESSING NOTE: ## ## The NASTRAN input file is not read directly by this script. ## A 'generic, free-format' file of FE-geometry is expected by ## this awk-prog --- with one record per element --- along with a set ## of corresponding 'generic, free-format' grid (a.k.a. node) records, ## sorted by grid/node-ID. ## ## The main scripts & awk-progs within 'feinp_nas2stl_bygui' are: ## ## feinp_nas2stl_bygui ## feinp_nas2freeform_nodeinfo ## feinp_nas2freeform_elinfo ## feinp_nas2freeform_elinfo_awkprog ## feinp_generic2stl_awkprog ## ## all in $FEDIR/scripts. ## ## ------- ## ## The main calling script 'feinp_nas2stl_bygui' ## uses '$FEDIR/scripts/feinp_nas2freeform_nodeinfo' to ## extract the MSC/NASTRAN node=grid data into a 'generic, free-format' file ## format, which is later sorted by grid-id, ## and ## the calling script uses '$FEDIR/scripts/feinp_nas2freeform_elinfo' to ## extract the MSC/NASTRAN element data into a 'generic, free-format' ## file format. ## ## Pertinent FE-geometry data on continuation NASTRAN records is put into ## a single record of the 'generic, free-format' files. ## ## This awk program then reads the data from the concatenation of those ## two 'generic' files. ## ## ------- ## ## Note that other FE input files, like ABAQUS, could be supported by ## creating 'feinp_abq2freeform_nodeinfo' & 'feinp_abq2freeform_elinfo' ## utility scripts --- and awk-prog 'feinp_abq2freeform_elinfo_awkprog' ## --- which are called by a script with a name like ## 'feinp_abq2stl_bygui', which would be similar in contents to ## 'feinp_nas2stl_bygui'. ## ## ------- ## ## See the statements like if ($1=="CHEXA" || $1=="chexa") ## in this awk program to see the supported elements --- and ## how the NASTRAN records are read and parsed. ## ######################################################################## ## HISTORICAL ORIGINS NOTE: ## The idea of an awk-based NASTRAN-to-STL utility, and, in particular, ## the mathematics in this awk program (for computing 'normals' to ## triangles in the STL file) is based on a NASTRAN(CTRIA3)- ## to-STL 'awk' script found in a 1998 ICCON mail from ## "Bronislav Plemenitas" of SLOVENIA ## to Harland Mayes of (?). ## Ref: ICCON STL-related e-mails in file ## /apps/simtec_2000/doc/STL_and_FEM_HELP_ICCON ## ## The 'bronch' script was for CTRIA3 recs -- not CQUADs, CTETRAs, CPENTAs, ## CHEXAs, [CBEAMs, CBARs, RBEs,] etc. This utility has been extended to ## create STL triangle data for those elements. ## ## Also, this utility uses a MUCH MORE EFFICIENT GRID-XYZ-INFO ARRAY-LOOKUP ## ROUTINE ('binary search') than the simple linear-scan routine used ## in the 'bronch' example. This makes it feasible to use on very ## large NASTRAN input files. ## ##---------------- ## The 'SlaToIv' and 'ivview' programs on SGI's enable using the ## NASTRAN-to-STL utility as a 1st step in a NASTRAN model-viewer utility. ## This existence of 'SlaToIv' and 'ivview' on SGI's was also pointed ## out in ICCON e-mails. ######################################################################## ## THIS 'awk' PROGRAM IS ## CALLED BY: $FEDIR/scripts/feinp_nas2stl_bygui ## ## which is called by the ## 'nasview_tools' toolchest in $FEDIR/scripts, ## actually 'nasview_tools.chestdef' in $FEDIR/scripts. ## ## And 'nasview_tools' may be an option in the ## 'nasmain' script in $FEDIR/scripts ## i.e. may be in the NASTRAN menu in nnsFEAmenu system. ## ## OR could be called manually by an alias in $HOME/.profile file ## OR could be called by a drawer in user's $HOME/.auxchestrc file ## OR could be called by a desktop icon created by 'Find, File QuickFind'. ######################################################################## ## TEST FILES: Test NASTRAN files with various elements are ## in directory /apps/nns_com/fea/demos_nas2stl. ## and/or in /apps/simtec_2000/test_files_nas2stl ## Some of these NASTRAN input files are from ## /apps/msc/msc70/msc70/nast/demo ## and /apps/msc/msc70/msc70/nast/tpl. ## Others may be from NNS NASTRAN users. ######################################################################## ## SUPPORTED RECORD TYPES BELOW: ## - CTRIAx ## - CQUADx ## - CTETRA ## - CPENTA ## - CHEXA ## Candidates that could be added: ## - CBEAM/CBAR ## - CROD/CTUBE ## - CONROD ## - RBE2 ## - CELAS2/CDAMP1 ## - CONM1/CONM2 (represent as small blocks?) ######################################################################## ## MAINTENANCE HISTORY: ## Written by: B.Montandon O06 15Aug2000 Based on 'simtec_nastria2stl_bygui' ## and 'simtec_nastetra2stl_bygui' ## in $FEDIR/scripts ## AND on other test awk code ## in /usr/people/bmo01/Dscrtest/test_nasinp2stl_* files ## like /usr/people/bmo01/Dscrtest/test_nasinp2stl_chexa ## and /usr/people/bmo01/Dscrtest/test_nasinp2stl_cquadxs ## Updated by: B.Montandon O06 21Aug2000 Add 'binary search' and ## better code, from ## 'simtec_nas_tria_quad2stl_bygui' ## and 'simtec_nas_tetra_penta_hexa2stl_bygui' ## in $FEDIR/scripts ## Updated by: B.Montandon O06 12Sep2000 Chgd name of this awk-prog FROM ## 'nasinp_generic2stl_awkprog' ## TO 'feinp_generic2stl_awkprog'. ## Also chgd names of 'nasinp2*' ## scripts in comments to ## 'feinp_nas2*'. ######################################################################## ######################################################################## ## NOTE1: THIS LOGIC ASSUMES *ALL* THE *GRID* RECORDS ARE SORTED BY GRID ## ID# and ARE BEFORE THE *element-connectivity* RECORDS, in the ## generic input file. ## ---- ## SEE SIMILAR NOTEs in the calling script ## $FEDIR/scripts/simtec_nas_tria_quad2stl_bygui ######################################################################### ######################################################################## ## NOTE2: AS A RULE OF THUMB, WE USE *next* AS SOON AS POSSIBLE IN THE ## main awk logic --- to skip unnecessary processing. ######################################################################## BEGIN { printf ("SOLID - FROM NASTRAN INPUT %-65s\n",FILE_IN); DEBUG=DE_BUG; i=0; jtria=0; jquad=0; jtet=0; jpent=0; jhex=0; ## i is a GRID rec counter; j's are element rec counters. } { ############################################################################## ## *GRID*-RECORD PROCESSING SECTION: ############################################################################## ## LOOK FOR *GRID* IN THE FIRST FIELD. INCREMENT THE GRID-REC COUNT, i. ############################################################################## FLD1CAPS=toupper($1) if ( FLD1CAPS=="GRID" ) {i++ ## EXIT, WITH MSG TO OUTFILE, IF A GRID REC HAS LESS THAN 6 FIELDS. if (NF<6) { print "*ERROR" print "*ERROR: There must be at least 6 fields in GRID recs:" print "*ERROR: String GRID, two integers, and 3 x,y,z coordinates." exit } #################################################### ## STORE THE GRID-ID in the g[.] array. (pre-sorted) #################################################### g[i]=$2 ################################################################ ## STORE THE 4th,5th,6th FIELDS IN THE gx[.],gy[.],gz[.] arrays. ################################################################ gx[i]=$4; gy[i]=$5; gz[i]=$6 ## *FOR TESTING* -- show the just-captured GRID data & input rec: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - GRID READ: i=grid-count="i" g[i]=grid-id="g[i] print "#DEBUG - gx[i]="gx[i]" gy[i]="gy[i]" gz[i]="gz[i] print "#DEBUG - REC-IN:" print "#DEBUG - "$0 } next } ####################################################################### ## END OF the *GRID*-RECORD PROCESSING SECTION ####################################################################### ########################################################################## ## *CTRIAx*-RECORD PROCESSING SECTION: ########################################################################## ## LOOK FOR *CTRIA3* or *CTRIA6* or *CTRIAR* IN THE FIRST FIELD. ## INCREMENT THE ELEMENT-REC COUNT, jtria. ########################################################################## # FLD1CAPS=toupper($1) ## DONE ABOVE. if ( FLD1CAPS=="CTRIA3" || FLD1CAPS=="CTRIA6" || FLD1CAPS=="CTRIAR" ) {jtria++ ################################################################ ## STORE THE *CTRIAx* ELEMENT-ID IN THE *e* VAR. ## STORE THE 4th, 5th, 6th FIELDS (3 grid ids) ## IN THE *g1*, *g2*, *g3* VARS. ################################################################ e=$2; g1=$4; g2=$5; g3=$6 ## *FOR TESTING* -- show the just-captured *CTRIAx* data & input rec: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - ELEMENT READ: jtria=CTRIAx-count="jtria" e=element-id="e print "#DEBUG - g1="g1" g2="g2" g3="g3 print "#DEBUG - REC-IN:" print "#DEBUG - "$0 } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g1. ## FOR A MATCH, SET x1,y1,z1 to gx[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g1) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID-id "g1" of CTRIAx-id "e"." next } else { x1=gx[k] ; y1=gy[k] ; z1=gz[k] ## *FOR TESTING* -- show the looked-up *CTRIAx* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g1=GRID-id="g1" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x1="x1" y1="y1" z1="z1 } } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g2. ## FOR A MATCH, SET x2,y2,z2 to gx[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g2) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID-id "g2" of CTRIAx-id "e"." next } else { x2=gx[k] ; y2=gy[k] ; z2=gz[k] ## *FOR TESTING* -- show the looked-up *CTRIAx* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g2=GRID-id="g2" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x2="x2" y2="y2" z2="z2 } } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g3. ## FOR A MATCH, SET x3,y3,z3 to gx[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g3) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID-id "g3" of CTRIAx-id "e"." next } else { x3=gx[k] ; y3=gy[k] ; z3=gz[k] ## *FOR TESTING* -- show the looked-up *CTRIAx* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g3=GRID-id="g3" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x3="x3" y3="y3" z3="z3 } } ################################################################ ## CALCULATE THE FACET NORMAL of THE CURRENT *CTRIAx* ELEMENT. ################################################################ ax=x2-x1; ay=y2-y1; az=z2-z1 bx=x3-x1; by=y3-y1; bz=z3-z1 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CTRIAx-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO ## THE CURRENT *CTRIAx* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x1" "y1" "z1 print " vertex "x2" "y2" "z2 print " vertex "x3" "y3" "z3 print " endloop" print "endfacet" next } ####################################################################### ## END OF if ( FLD1CAPS=="CTRIA3" || ... ) ## i.e. END OF the *CTRIAx*-RECORD PROCESSING SECTION ####################################################################### ####################################################################### ## *CQUADx*-RECORD PROCESSING SECTION: ####################################################################### ## LOOK FOR *CQUAD4* or *CQUAD8* or *CQUADR* IN THE FIRST FIELD. ## INCREMENT THE ELEMENT-REC COUNT, jquad. ####################################################################### # FLD1CAPS=toupper($1) ## DONE ABOVE. if ( FLD1CAPS=="CQUAD4" || FLD1CAPS=="CQUAD8" || FLD1CAPS=="CQUADR" ) {jquad++ ################################################################ ## STORE THE *CQUAD4* ELEMENT-ID IN THE *e* VAR. ## STORE THE 4th, 5th, 6th, 7th FIELDS (4 grid ids) ## IN THE g1, g2, g3, g4 VARS. ################################################################ e=$2; g1=$4; g2=$5; g3=$6; g4=$7 ## *FOR TESTING* -- show the just-captured *CQUADx* data & input rec: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - ELEMENT READ: jquad=CQUADx-count="jquad" e=element-id="e print "#DEBUG - g1="g1" g2="g2" g3="g3" g4="g4 print "#DEBUG - REC-IN:" print "#DEBUG - "$0 } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g1. ## FOR A MATCH, SET x1,y1,z1 to gz[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g1) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID-id "g1" of CQUADx-id "e"." next } else { x1=gx[k] ; y1=gy[k] ; z1=gz[k] ## *FOR TESTING* -- show the looked-up *CQUADx* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g1="g1" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x1="x1" y1="y1" z1="z1 } } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g2. ## FOR A MATCH, SET x2,y2,z2 to gx[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g2) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID-id "g2" of CQUADx-id "e"." next } else { x2=gx[k] ; y2=gy[k] ; z2=gz[k] ## *FOR TESTING* -- show the looked-up *CQUADx* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g2="g2" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x2="x2" y2="y2" z2="z2 } } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g3. ## FOR A MATCH, SET x3,y3,z3 to gx[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g3) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID-id "g3" of CQUADx-id "e"." next } else { x3=gx[k] ; y3=gy[k] ; z3=gz[k] ## *FOR TESTING* -- show the looked-up *CQUADx* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g3="g3" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x3="x3" y3="y3" z3="z3 } } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g4. ## FOR A MATCH, SET x3,y3,z3 to gx[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g4) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID-id "g4" of CQUADx-id "e"." next } else { x4=gx[k] ; y4=gy[k] ; z4=gz[k] ## *FOR TESTING* -- show the looked-up *CQUADx* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g4="g4" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x4="x4" y4="y4" z4="z4 } } ################################################################ ## CALCULATE THE FACET NORMAL OF TRIANGLE#1 (using pts 1,2,3) ## of THE CURRENT *CQUADx* ELEMENT. ################################################################ ax=x2-x1; ay=y2-y1; az=z2-z1 bx=x3-x1; by=y3-y1; bz=z3-z1 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CQUADx-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO TRIANGLE#1 ## of THE CURRENT *CQUADx* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x1" "y1" "z1 print " vertex "x2" "y2" "z2 print " vertex "x3" "y3" "z3 print " endloop" print "endfacet" ################################################################ ## CALCULATE THE FACET NORMAL OF TRIANGLE#2 (using pts 1,3,4) ## of THE CURRENT *CQUADx* ELEMENT. ################################################################ ax=x3-x1; ay=y3-y1; az=z3-z1 bx=x4-x1; by=y4-y1; bz=z4-z1 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CQUADx-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO TRIANGLE#2 ## of THE CURRENT *CQUADx* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x1" "y1" "z1 print " vertex "x3" "y3" "z3 print " vertex "x4" "y4" "z4 print " endloop" print "endfacet" next } ####################################################################### ## END OF if ($FLD1CAPS=="CQUAD4" || ... ) ## i.e. END OF the *CQUADx*-RECORD PROCESSING SECTION. ####################################################################### ########################################################################## ## *CTETRA*-RECORD PROCESSING SECTION: ########################################################################## ## LOOK FOR *CTETRA* IN THE FIRST FIELD. ## INCREMENT THE ELEMENT-REC COUNT, jtet. ########################################################################## # FLD1CAPS=toupper($1) ## DONE ABOVE. if ( FLD1CAPS=="CTETRA" ) {jtet++ ####################################################################### ## STORE THE *CETRA* ELEMENT-ID IN THE *e* VAR. ## STORE THE 4th, 5th, 6th 7th FIELDS (4 grid ids) ## IN THE g1, g2, g3, g4 VARS. ####################################################################### e=$2; g1=$4; g2=$5; g3=$6; g4=$7 ## *FOR TESTING* -- show the just-captured *CTETRA* data & input rec: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - ELEMENT READ: jtet=CTETRA-count="jtet" e=element-id="e print "#DEBUG - g1="g1" g2="g2" g3="g3" g4="g4 print "#DEBUG - REC-IN:" print "#DEBUG - "$0 } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g1. ## FOR A MATCH, SET x1,y1,z1 to gx[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g1) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID "g1" of CTETRA "e"." next } else { x1=gx[k] ; y1=gy[k] ; z1=gz[k] ## *FOR TESTING* -- show the looked-up *CTETRA* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g1="g1" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x1="x1" y1="y1" z1="z1 } } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g2. ## FOR A MATCH, SET x2,y2,z2 to gx[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g2) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID-id "g2" of CTETRA-id "e"." next } else { x2=gx[k] ; y2=gy[k] ; z2=gz[k] ## *FOR TESTING* -- show the looked-up *CTETRA* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g2="g2" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x2="x2" y2="y2" z2="z2 } } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g3. ## FOR A MATCH, SET x3,y3,z3 to gx[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g3) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID-id "g3" of CTETRA-id "e"." next } else { x3=gx[k] ; y3=gy[k] ; z3=gz[k] ## *FOR TESTING* -- show the looked-up *CTETRA* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g3="g3" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x3="x3" y3="y3" z3="z3 } } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g4. ## FOR A MATCH, SET x4,y4,z4 to gx[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g4) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID-id "g4" of CTETRA-id "e"." next } else { x4=gx[k] ; y4=gy[k] ; z4=gz[k] ## *FOR TESTING* -- show the looked-up *CTETRA* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g4="g4" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x4="x4" y4="y4" z4="z4 } } ############################################################## ## CALCULATE THE FACET NORMAL of *FACE1* OF THE CURRENT ## *CTETRA* ELEMENT --- using xyz1,xyz3,xyz2. ############################################################## ax=x3-x1; ay=y3-y1; az=z3-z1 bx=x2-x1; by=y2-y1; bz=z2-z1 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CTETRA-id "e" is all zeros." print "*ERROR: Probably a recfmt problem with one of its GRID records." print "*ERROR: See grid&element extracted data in "FILE_IN next } ############################################################## ## OUTPUT THE SET OF STL RECS CORRESPONDING TO *FACE1* OF ## THE CURRENT *CTETRA* ELEMENT. ############################################################## print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x1" "y1" "z1 print " vertex "x3" "y3" "z3 print " vertex "x2" "y2" "z2 print " endloop" print "endfacet" ############################################################## ## CALCULATE THE FACET NORMAL of *FACE2* OF THE CURRENT ## *CTETRA* ELEMENT --- using xyz1,xyz2,xyz4. ############################################################## ax=x2-x1; ay=y2-y1; az=z2-z1 bx=x4-x1; by=y4-y1; bz=z4-z1 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CTETRA-id "e" is all zeros." print "*ERROR: Probably a recfmt problem with one of its GRID records." print "*ERROR: See grid&element extracted data in "FILE_IN next } ############################################################## ## OUTPUT THE SET OF STL RECS CORRESPONDING TO *FACE2* OF ## THE CURRENT *CTETRA* ELEMENT. ############################################################## print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x1" "y1" "z1 print " vertex "x2" "y2" "z2 print " vertex "x4" "y4" "z4 print " endloop" print "endfacet" ############################################################## ## CALCULATE THE FACET NORMAL of *FACE3* OF THE CURRENT ## *CTETRA* ELEMENT --- using xyz1,xyz4,xyz3. ############################################################## ax=x4-x1; ay=y4-y1; az=z4-z1 bx=x3-x1; by=y3-y1; bz=z3-z1 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CTETRA-id "e" is all zeros." print "*ERROR: Probably a recfmt problem with one of its GRID records." print "*ERROR: See grid&element extracted data in "FILE_IN next } ############################################################## ## OUTPUT THE SET OF STL RECS CORRESPONDING TO *FACE3* OF ## THE CURRENT *CTETRA* ELEMENT. ############################################################## print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x1" "y1" "z1 print " vertex "x4" "y4" "z4 print " vertex "x3" "y3" "z3 print " endloop" print "endfacet" ############################################################## ## CALCULATE THE FACET NORMAL of *FACE4* OF THE CURRENT ## *CTETRA* ELEMENT --- using xyz2,xyz3,xyz4. ############################################################## ax=x3-x2; ay=y3-y2; az=z3-z2 bx=x4-x2; by=y4-y2; bz=z4-z2 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CTETRA-id "e" is all zeros." print "*ERROR: Probably a recfmt problem with one of its GRID records." print "*ERROR: See grid&element extracted data in "FILE_IN next } ############################################################## ## OUTPUT THE SET OF STL RECS CORRESPONDING TO *FACE4* OF ## THE CURRENT *CTETRA* ELEMENT. ############################################################## print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x2" "y2" "z2 print " vertex "x3" "y3" "z3 print " vertex "x4" "y4" "z4 print " endloop" print "endfacet" next } ####################################################################### ## END OF if ( FLD1CAPS=="CTETRA" ) ## i.e. END OF the *CTETRA*-RECORD PROCESSING SECTION ####################################################################### ####################################################################### ## *CPENTA*-RECORD PROCESSING SECTION: ####################################################################### ## LOOK FOR *CPENTA* IN THE FIRST FIELD. ## INCREMENT THE CPENTA-REC COUNT, jpent. ####################################################################### # FLD1CAPS=toupper($1) ## DONE ABOVE. if ( FLD1CAPS=="CPENTA" ) {jpent++ ################################################################ ## STORE THE *CPENTA* ELEMENT-ID IN THE *e* VAR. ## STORE THE 4th, 5th, 6th, 7th, 8th, 9th FIELDS ## (6 corner grid ids of the 'prism' element) ## IN THE g1, g2, g3, g4, g5, g6 VARS. ################################################################ e=$2; g1=$4; g2=$5; g3=$6; g4=$7; g5=$8; g6=$9 ## *FOR TESTING* -- show the just-captured *CPENTA* data & input rec: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - ELEMENT READ: jpent=CPENTA-count="jpent" e=element-id="e print "#DEBUG - g1="g1" g2="g2" g3="g3 print "#DEBUG - g4="g4" g5="g5" g6="g6 print "#DEBUG - REC-IN:" print "#DEBUG - "$0 } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g1. ## FOR A MATCH, SET x1,y1,z1 to gz[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g1) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID "g1" of CPENTA "e"." next } else { x1=gx[k] ; y1=gy[k] ; z1=gz[k] ## *FOR TESTING* -- show the looked-up *CPENTA* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g1="g1" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x1="x1" y1="y1" z1="z1 } } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g2. ## FOR A MATCH, SET x2,y2,z2 to gz[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g2) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID "g2" of CPENTA "e"." next } else { x2=gx[k] ; y2=gy[k] ; z2=gz[k] ## *FOR TESTING* -- show the looked-up *CPENTA* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - FOUND g2="g2" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x2="x2" y2="y2" z2="z2 } } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g3. ## FOR A MATCH, SET x3,y3,z3 to gz[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g3) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID "g3" of CPENTA "e"." next } else { x3=gx[k] ; y3=gy[k] ; z3=gz[k] ## *FOR TESTING* -- show the looked-up *CPENTA* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g3="g3": at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x3="x3" y3="y3" z3="z3 } } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g4. ## FOR A MATCH, SET x4,y4,z4 to gz[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g4) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID "g4" of CPENTA "e"." next } else { x4=gx[k] ; y4=gy[k] ; z4=gz[k] ## *FOR TESTING* -- show the looked-up *CPENTA* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g4="g4" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x4="x4" y4="y4" z4="z4 } } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g5. ## FOR A MATCH, SET x5,y5,z5 to gz[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g5) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID "g5" of CPENTA "e"." next } else { x5=gx[k] ; y5=gy[k] ; z5=gz[k] ## *FOR TESTING* -- show the looked-up *CPENTA* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g5="g5" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x5="x5" y5="y5" z5="z5 } } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g6. ## FOR A MATCH, SET x6,y6,z6 to gz[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g6) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID "g6" of CPENTA "e"." next } else { x6=gx[k] ; y6=gy[k] ; z6=gz[k] ## *FOR TESTING* -- show the just-captured *CPENTA* data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g6="g6" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x6="x6" y6="y6" z6="z6 } } ####################################################################### ####################################################################### ## WE NOW MAKE THE PENTA-PRISM (2 end-triangles, then 3 rectangles) ## OUT OF 2 TRIANGLES, THEN 2*3=6 TRIANGLES. ####################################################################### ####################################################################### ################################################################ ## CALCULATE THE FACET NORMAL OF END-TRIANGLE#1 (using pts 1,3,2) ## of THE CURRENT *CPENTA* ELEMENT. ################################################################ ax=x3-x1; ay=y3-y1; az=z3-z1 bx=x2-x1; by=y2-y1; bz=z2-z1 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CPENTA-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO END-TRIANGLE#1 ## of THE CURRENT *CPENTA* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x1" "y1" "z1 print " vertex "x3" "y3" "z3 print " vertex "x2" "y2" "z2 print " endloop" print "endfacet" ################################################################ ## CALCULATE THE FACET NORMAL OF END-TRIANGLE#2 (using pts 4,5,6) ## of THE CURRENT *CPENTA* ELEMENT. ################################################################ ax=x5-x4; ay=y5-y4; az=z5-z4 bx=x6-x4; by=y6-y4; bz=z6-z4 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CPENTA-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO END-TRIANGLE#2 ## of THE CURRENT *CPENTA* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x4" "y4" "z4 print " vertex "x5" "y5" "z5 print " vertex "x6" "y6" "z6 print " endloop" print "endfacet" ################################################################ ## CALCULATE THE FACET NORMAL OF RECTANGLE1-TRIANGLE1 ## (using pts 2,3,5) of THE CURRENT *CPENTA* ELEMENT. ################################################################ ax=x3-x2; ay=y3-y2; az=z3-z2 bx=x5-x2; by=y5-y2; bz=z5-z2 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CPENTA-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO RECTANGLE1-TRIANGLE1 ## of THE CURRENT *CPENTA* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x2" "y2" "z2 print " vertex "x3" "y3" "z3 print " vertex "x5" "y5" "z5 print " endloop" print "endfacet" ################################################################ ## CALCULATE THE FACET NORMAL OF RECTANGLE1-TRIANGLE2 ## (using pts 3,6,5) of THE CURRENT *CPENTA* ELEMENT. ################################################################ ax=x6-x3; ay=y6-y3; az=z6-z3 bx=x5-x3; by=y5-y3; bz=z5-z3 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CPENTA-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO RECTANGLE1-TRIANGLE2 ## of THE CURRENT *CPENTA* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x3" "y3" "z3 print " vertex "x6" "y6" "z6 print " vertex "x5" "y5" "z5 print " endloop" print "endfacet" ################################################################ ## CALCULATE THE FACET NORMAL OF RECTANGLE2-TRIANGLE1 ## (using pts 1,4,3) of THE CURRENT *CPENTA* ELEMENT. ################################################################ ax=x4-x1; ay=y4-y1; az=z4-z1 bx=x3-x1; by=y3-y1; bz=z3-z1 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CPENTA-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO RECTANGLE2-TRIANGLE1 ## of THE CURRENT *CPENTA* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x1" "y1" "z1 print " vertex "x4" "y4" "z4 print " vertex "x3" "y3" "z3 print " endloop" print "endfacet" ################################################################ ## CALCULATE THE FACET NORMAL OF RECTANGLE2-TRIANGLE2 ## (using pts 3,4,6) of THE CURRENT *CPENTA* ELEMENT. ################################################################ ax=x4-x3; ay=y4-y3; az=z4-z3 bx=x6-x3; by=y6-y3; bz=z6-z3 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CPENTA-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO RECTANGLE2-TRIANGLE2 ## of THE CURRENT *CPENTA* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x3" "y3" "z3 print " vertex "x4" "y4" "z4 print " vertex "x6" "y6" "z6 print " endloop" print "endfacet" ################################################################ ## CALCULATE THE FACET NORMAL OF RECTANGLE3-TRIANGLE1 ## (using pts 1,2,5) of THE CURRENT *CPENTA* ELEMENT. ################################################################ ax=x2-x1; ay=y2-y1; az=z2-z1 bx=x5-x1; by=y5-y1; bz=z5-z1 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CPENTA-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO RECTANGLE3-TRIANGLE1 ## of THE CURRENT *CPENTA* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x1" "y1" "z1 print " vertex "x2" "y2" "z2 print " vertex "x5" "y5" "z5 print " endloop" print "endfacet" ################################################################ ## CALCULATE THE FACET NORMAL OF RECTANGLE3-TRIANGLE2 ## (using pts 1,5,4) of THE CURRENT *CPENTA* ELEMENT. ################################################################ ax=x5-x1; ay=y5-y1; az=z5-z1 bx=x4-x1; by=y4-y1; bz=z4-z1 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CPENTA-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO RECTANGLE3-TRIANGLE2 ## of THE CURRENT *CPENTA* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x1" "y1" "z1 print " vertex "x5" "y5" "z5 print " vertex "x4" "y4" "z4 print " endloop" print "endfacet" next } ####################################################################### ## END OF if ( FLD1CAPS=="CPENTA" ) ## i.e. END OF the *CPENTA*-RECORD PROCESSING SECTION. ####################################################################### ####################################################################### ## *CHEXA*-RECORD PROCESSING SECTION: ####################################################################### ## LOOK FOR *CHEXA* IN THE FIRST FIELD. ## INCREMENT THE CHEXA-REC COUNT, jhex. ####################################################################### # FLD1CAPS=toupper($1) ## DONE ABOVE. if ( FLD1CAPS=="CHEXA" ) {jhex++ ################################################################ ## STORE THE *CHEXA* ELEMENT-ID IN THE *e* VAR. ## STORE THE 4th, 5th, 6th, 7th, 8th, 9th, 10th, 11th FIELDS ## (8 corner grid ids of the 'brick' element) ## IN THE g1, g2, g3, g4, g5, g6, g7, g8 VARS. ################################################################ e=$2; g1=$4; g2=$5; g3=$6; g4=$7; g5=$8; g6=$9; g7=$10; g8=$11 ## *FOR TESTING* -- show the just-captured *CHEXA* data & input rec: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - ELEMENT READ: jhex=CHEXA-count="jhex" e=element-id="e print "#DEBUG - g1="g1" g2="g2" g3="g3" g4="g4 print "#DEBUG - g5="g5" g6="g6" g7="g7" g8="g8 print "#DEBUG - REC-IN:" print "#DEBUG - "$0 } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g1. ## FOR A MATCH, SET x1,y1,z1 to gz[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g1) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID "g1" of CHEXA "e"." next } else { x1=gx[k] ; y1=gy[k] ; z1=gz[k] ## *FOR TESTING* -- show the looked-up *CHEXA* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g1="g1" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x1="x1" y1="y1" z1="z1 } } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g2. ## FOR A MATCH, SET x2,y2,z2 to gz[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g2) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID "g2" of CHEXA "e"." next } else { x2=gx[k] ; y2=gy[k] ; z2=gz[k] ## *FOR TESTING* -- show the looked-up *CHEXA* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g2="g2" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x2="x2" y2="y2" z2="z2 } } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g3. ## FOR A MATCH, SET x3,y3,z3 to gz[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g3) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID "g3" of CHEXA "e"." next } else { x3=gx[k] ; y3=gy[k] ; z3=gz[k] ## *FOR TESTING* -- show the looked-up *CHEXA* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g3="g3" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x3="x3" y3="y3" z3="z3 } } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g4. ## FOR A MATCH, SET x4,y4,z4 to gz[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g4) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID "g4" of CHEXA "e"." next } else { x4=gx[k] ; y4=gy[k] ; z4=gz[k] ## *FOR TESTING* -- show the looked-up *CHEXA* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g4="g4" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x4="x4" y4="y4" z4="z4 } } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g5. ## FOR A MATCH, SET x5,y5,z5 to gz[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g5) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID "g5" of CHEXA "e"." next } else { x5=gx[k] ; y5=gy[k] ; z5=gz[k] ## *FOR TESTING* -- show the looked-up *CHEXA* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g5="g5" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x5="x5" y5="y5" z5="z5 } } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g6. ## FOR A MATCH, SET x6,y6,z6 to gz[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g6) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID "g6" of CHEXA "e"." next } else { x6=gx[k] ; y6=gy[k] ; z6=gz[k] ## *FOR TESTING* -- show the looked-up *CHEXA* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g6="g6" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x6="x6" y6="y6" z6="z6 } } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g7. ## FOR A MATCH, SET x7,y7,z7 to gz[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g7) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID "g7" of CHEXA "e"." next } else { x7=gx[k] ; y7=gy[k] ; z7=gz[k] ## *FOR TESTING* -- show the looked-up *CHEXA* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g7="g7" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x7="x7" y7="y7" z7="z7 } } ################################################################### ## binary-SEARCH THE g[.] GRID-ID array FOR A MATCH, g[k], WITH g8. ## FOR A MATCH, SET x8,y8,z8 to gz[k],gy[k],gz[k]. ################################################################### k=binarySearch(g, i, g8) if ( k==-1 ) { print "*ERROR" print "*ERROR: NO GRID COORDS FOUND for GRID "g8" of CHEXA "e"." next } else { x8=gx[k] ; y8=gy[k] ; z8=gz[k] ## *FOR TESTING* -- show the looked-up *CHEXA* grid-data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - BINARY SEARCH of grid array g[k] FOUND:" print "#DEBUG - g8="g8" at k="k" g[k]="g[k] print "#DEBUG - with xyz coordinates" print "#DEBUG - x8="x8" y8="y8" z8="z8 } } ####################################################################### ####################################################################### ## WE NOW MAKE THE HEX-BOX (six sides) OUT OF 12 TRIANGLES. ####################################################################### ####################################################################### ################################################################ ## CALCULATE THE FACET NORMAL OF TRIANGLE#1 (using pts 1,3,2) ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ ax=x3-x1; ay=y3-y1; az=z3-z1 bx=x2-x1; by=y2-y1; bz=z2-z1 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CHEXA-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO TRIANGLE#1 ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x1" "y1" "z1 print " vertex "x3" "y3" "z3 print " vertex "x2" "y2" "z2 print " endloop" print "endfacet" ################################################################ ## CALCULATE THE FACET NORMAL OF TRIANGLE#2 (using pts 1,4,3) ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ ax=x4-x1; ay=y4-y1; az=z4-z1 bx=x3-x1; by=y3-y1; bz=z3-z1 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CHEXA-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO TRIANGLE#2 ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x1" "y1" "z1 print " vertex "x4" "y4" "z4 print " vertex "x3" "y3" "z3 print " endloop" print "endfacet" ################################################################ ## CALCULATE THE FACET NORMAL OF TRIANGLE#3 (using pts 5,6,7) ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ ax=x6-x5; ay=y6-y5; az=z6-z5 bx=x7-x5; by=y7-y5; bz=z7-z5 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CHEXA-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO TRIANGLE#3 ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x5" "y5" "z5 print " vertex "x6" "y6" "z6 print " vertex "x7" "y7" "z7 print " endloop" print "endfacet" ################################################################ ## CALCULATE THE FACET NORMAL OF TRIANGLE#4 (using pts 5,7,8) ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ ax=x7-x5; ay=y7-y5; az=z7-z5 bx=x8-x5; by=y8-y5; bz=z8-z5 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CHEXA-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO TRIANGLE#4 ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x5" "y5" "z5 print " vertex "x7" "y7" "z7 print " vertex "x8" "y8" "z8 print " endloop" print "endfacet" ################################################################ ## CALCULATE THE FACET NORMAL OF TRIANGLE#5 (using pts 1,2,6) ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ ax=x2-x1; ay=y2-y1; az=z2-z1 bx=x6-x1; by=y6-y1; bz=z6-z1 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CHEXA-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO TRIANGLE#5 ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x1" "y1" "z1 print " vertex "x2" "y2" "z2 print " vertex "x6" "y6" "z6 print " endloop" print "endfacet" ################################################################ ## CALCULATE THE FACET NORMAL OF TRIANGLE#6 (using pts 1,6,5) ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ ax=x6-x1; ay=y6-y1; az=z6-z1 bx=x5-x1; by=y5-y1; bz=z5-z1 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CHEXA-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO TRIANGLE#6 ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x1" "y1" "z1 print " vertex "x6" "y6" "z6 print " vertex "x5" "y5" "z5 print " endloop" print "endfacet" ################################################################ ## CALCULATE THE FACET NORMAL OF TRIANGLE#7 (using pts 3,4,8) ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ ax=x4-x3; ay=y4-y3; az=z4-z3 bx=x8-x3; by=y8-y3; bz=z8-z3 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CHEXA-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO TRIANGLE#7 ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x3" "y3" "z3 print " vertex "x4" "y4" "z4 print " vertex "x8" "y8" "z8 print " endloop" print "endfacet" ################################################################ ## CALCULATE THE FACET NORMAL OF TRIANGLE#8 (using pts 3,8,7) ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ ax=x8-x3; ay=y8-y3; az=z8-z3 bx=x7-x3; by=y7-y3; bz=z7-z3 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CHEXA-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO TRIANGLE#8 ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x3" "y3" "z3 print " vertex "x8" "y8" "z8 print " vertex "x7" "y7" "z7 print " endloop" print "endfacet" ################################################################ ## CALCULATE THE FACET NORMAL OF TRIANGLE#9 (using pts 1,5,8) ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ ax=x5-x1; ay=y5-y1; az=z5-z1 bx=x8-x1; by=y8-y1; bz=z8-z1 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CHEXA-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO TRIANGLE#9 ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x1" "y1" "z1 print " vertex "x5" "y5" "z5 print " vertex "x8" "y8" "z8 print " endloop" print "endfacet" ################################################################ ## CALCULATE THE FACET NORMAL OF TRIANGLE#10 (using pts 1,8,4) ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ ax=x8-x1; ay=y8-y1; az=z8-z1 bx=x4-x1; by=y4-y1; bz=z4-z1 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CHEXA-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO TRIANGLE#10 ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x1" "y1" "z1 print " vertex "x8" "y8" "z8 print " vertex "x4" "y4" "z4 print " endloop" print "endfacet" ################################################################ ## CALCULATE THE FACET NORMAL OF TRIANGLE#11 (using pts 2,3,7) ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ ax=x3-x2; ay=y3-y2; az=z3-z2 bx=x7-x2; by=y7-y2; bz=z7-z2 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CHEXA-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO TRIANGLE#11 ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x2" "y2" "z2 print " vertex "x3" "y3" "z3 print " vertex "x7" "y7" "z7 print " endloop" print "endfacet" ################################################################ ## CALCULATE THE FACET NORMAL OF TRIANGLE#12 (using pts 2,7,6) ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ ax=x7-x2; ay=y7-y2; az=z7-z2 bx=x6-x2; by=y6-y2; bz=z6-z2 cx=ay*bz-az*by cy=az*bx-ax*bz cz=ax*by-ay*bx if ( cx==0 && cy==0 && cz==0 ) { print "*ERROR" print "*ERROR: A normal of a face of CHEXA-id "e" is all zeros." print "*ERROR: Probably a RecFmt problem with one of its GRID records." print "*ERROR: See grid & element extracted data in "FILE_IN next } ################################################################ ## OUTPUT THE SET OF STL RECS CORRESPONDING TO TRIANGLE#12 ## of THE CURRENT *CHEXA* ELEMENT. ################################################################ print "facet normal "cx" "cy" "cz print " outer loop" print " vertex "x2" "y2" "z2 print " vertex "x7" "y7" "z7 print " vertex "x6" "y6" "z6 print " endloop" print "endfacet" next } ####################################################################### ## END OF if ( FLD1CAPS=="CHEXA" ) ## i.e. END OF the *CHEXA*-RECORD PROCESSING SECTION. ####################################################################### } END { j=jtria+jquad+jtet+jpent+jhex if ( j==0 ) { print "*ERROR" print "*ERROR: No ELEMENTS were found in the input file." } printf ("ENDSOLID - %12d triangles generated from %12d CTRIAx elements.\n",jtria,jtria) printf ("ENDSOLID - 2 x %12d triangles generated from %12d CQUADx elements.\n",jquad,jquad) printf ("ENDSOLID - 4 x %12d triangles generated from %12d CTETRA elements.\n",jtet,jtet) printf ("ENDSOLID - 8 x %12d triangles generated from %12d CPENTA elements.\n",jpent,jpent) printf ("ENDSOLID - 12 x %12d triangles generated from %12d CHEXA elements.\n",jhex,jhex) } ## START OF function *binarySearch* ######################################################################## ## NOTE: *function* statement is not recognized within ## awk BEGIN, *body=main*, and END sections. ######################################################################## ## ## DESCRIPTION OF A BINARY SEARCH ALGORITHM ## ## from http://www.ics.hawaii.edu/~yongsi/ics665/principle.html ## ## We have a sorted array A and a key K. Our task is to determine whether ## the key K is present in this array A. If we do find A[i] = K, ## return the array index i. Otherwise, return i = -1. ## ## The search Binary search works in the following way: ## ## 1. Compare K with the middle value (M) in remaiding part of array A. ## 2. If K = M, we are done. ## 3. If K < M, we continue our search to the lower end of array A and ## entirely ignore the other end. ## 4. If K > M, we continue, but confine ourselves to the higher end. ## ######################################################################## ## EXAMPLE: A = {1 3 4 6 8 9 11}. K = 4. ## ## M = 6 ## Compare K with 6. It is smaller. Continue search with A = 1 3 4. ## M = 3 ## Compare K with 3. It is bigger. Continue search with A = 3 4. (4 only?) ## M = 4 ## Compare K with 4. It is equal. We are done, we found K in A. ######################################################################## ## ## The algorithm (C-like) for Binary Search is listed below: ######################################################################## function binarySearch(ARRAY,ARRAY_SIZE,KEY, low,high,middle) { low=1 high=ARRAY_SIZE while ( low <= high ) { middle = int( (low+high)/2 ) ## FOR TESTING: # print "low= "low" high="high" middle="middle if ( KEY == ARRAY[ middle ] ) { return middle } else if ( KEY < ARRAY[ middle ] ) { high = middle - 1 } else { low = middle + 1 } } return -1 } ## END OF awk program