## ## 'awk' PROGRAM NAME: feinp_nas2freeform_elinfo_awkprog ## ## in $FEDIR/scripts ## where FEDIR=/apps/nns_com/fea ## ## Was 'nasinp2freeform_elinfo_awkprog' to 12Sep2000. ######################################################################## ## PURPOSE: This 'awk' program is called in script ## ## [$FEDIR/scripts/feinp_nas2freeform_elinfo which is called by] ## ## $FEDIR/scripts/feinp_nas2stl_bygui to ## ## ** to READ an MSC/NASTRAN input file and ## ** EXTRACT various ELEMENT records (like CTRIAx,CTETRA,CQUADx,CHEXA, ## ** and many others) into an a 'generic, free-format' output file of ## ** element connectivity info (mainly, element-ID and node-IDs) ## ** --- ONE record (no continuation rec) for each element-ID. ## ##------------------------------- ## INFO ON 'feinp_nas2stl_bygui': ## ## 'feinp_nas2stl_bygui' is a "NASTRAN-to-STL" file creation utility meant ## to support viewing of 1D elements as well as 2D and 3D. ## ## The 'generic' ELEMENTS-info output file from this awk-prog, ## 'feinp_nas2freeform_elinfo_awkprog', is used as input in a ## genericFE-to-STL awk program, 'feinp_generic2stl_awkprog'. ## ## See the 'feinp_nas2stl_bygui' script for more info. ## It includes a description of the script/awk-prog call hierarchy. ## ######################################################################## ## BASIC PROCESSING: ## See the statements (section-starts) like ## if ($0 ~ "^CHEXA" || $0 ~ "^chexa") ## in this awk program to see the supported elements --- and ## how the NASTRAN records are read and parsed. A brief summary: ## ## The input ELEMENT records can be in MSC ## - free-form format ## - short-field format ## or - long-field format (with continuation record). ## ## For each input ELEMENT record, a single 'free-form' record is written ## which is generally of the form ## elname eid pid g1 g2 g3 ... ## where elname is an element name like CTRIA3 ## eid = element-id (an integer) ## pid = property id (an integer) ## gi's are ids of grid/node points (integers). ## ######################################################################## ## CALLED BY: $FEDIR/scripts/feinp_nas2freeform_elinfo, ## which is called by ## $FEDIR/scripts/feinp_nas2stl_bygui ## to convert a NASTRAN input file of GRID & element data ## into an STL file of triangles --- to facilitate viewing. ## ## See those scripts for further info, esp. where used and origins. ## The overall processing logic is summarized in 'feinp_nas2stl_bygui'. ######################################################################## ## INPUT: a NASTRAN input filename ## OUTPUT: stdout ######################################################################## ## TEST FILES: Test NASTRAN files with various elements are ## in directory /apps/nns_com/fea/demos_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 ELEMENT RECORD TYPES BELOW: ## (in the order of the awk-program sections) ## - CTRIAx ## - CQUADx ## - CTETRA ## - CHEXA ## - CPENTA ## Candidates that could be added: ## - CBEAM/CBAR ## - CROD/CTUBE ## - CONROD ## - RBE2 ## - CELAS2/CDAMP1 ## - CONM1/CONM2 ######################################################################## ## MAINTENANCE HISTORY: ## Written by: B.Montandon O06 16Aug2000 Based on a first, rough-parsing ## NAS2STL implementation in ## 'nasinp2stl_awkprog' ## and 'nasinp2stl_bygui' ## in $FEDIR/scripts ## Updated by: B.Montandon O06 18Aug2000 Fix parsing of CHEXA free-fmt. ## Add CPENTA parsing. ## Updated by: B.Montandon O06 12Sep2000 Chgd name of this awk-prog FROM ## 'nasinp2freeform_elinfo_awkprog' ## TO 'feinp_nas2freeform_elinfo_awkprog'. ## Updated comments-documentation. ## Updated by: B.Montandon O06 13Sep2000 Improved format of DEBUG msgs. ######################################################################## BEGIN { printf ("# ELEMENT RECS FROM NASTRAN INPUT %-65s\n",FILE_IN); printf ("# \n"); printf ("# For each input ELEMENT record,\n"); printf ("# a single *free-form* record is written, of the form\n"); printf ("# elname eid pid g1 g2 g3 ...\n"); printf ("# where elname = element name like CTRIA3\n"); printf ("# eid = element-id, integer\n"); printf ("# pid = property id, integer\n"); printf ("# gi-s are ids of grid/node points, integers.\n"); printf ("# \n"); ## i is a GRID rec counter; j is an element rec counter. i=0; j=0; DEBUG=DE_BUG } { ############################################################################## ## *SKIP* THIS REC IF IT IS A *COMMENT* REC. ############################################################################## if (substr($0,1,1)=="$") { next} ############################################################################## ## *SKIP* THIS REC IF IT IS A *GRID* REC. ############################################################################## FIELD1=substr($0,1,8) FLD1CAPS=toupper(FIELD1) if (FLD1CAPS ~ "GRID") {i++; next} ############################################################################## ## DETERMINE THE RECORD FORMAT OF THE INCOMING REC. ############################################################################## RECfmt="free" IXCOMMA=index($0,",") if (IXCOMMA==0) RECfmt="short" if (RECfmt=="short") { IXSTAR=index(FIELD1,"*") if (IXSTAR!=0) RECfmt="long" } ## *FOR TESTING* -- show the input rec and its just-determined RECfmt: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - A NASTRAN RECORD WAS READ." print "#DEBUG - THE DETERMINED FORMAT AND THE RECORD-IMAGE FOLLOWS." print "#DEBUG - Fmt-in="RECfmt" FIELD1:"FIELD1" IXCOMMA:"IXCOMMA" IXSTAR:"IXSTAR print "#DEBUG - REC-IN:" print "#DEBUG - "$0 print "#DEBUG" } ########################################################################### ## **CTRIAx** RECORD PROCESSING LOGIC: ########################################################################### ## LOOK FOR *CTRIA3* or *CTRIA6* or *CTRIAR* IN THE FIRST FIELD. ## INCREMENT THE ELEMENT-REC COUNT, j. ########################################################################### if ($0 ~ "^CTRIA3" || $0 ~ "^ctria3" || $0 ~ "^CTRIA6" || $0 ~ "^ctria6" || \ $0 ~ "^CTRIAR" || $0 ~ "^ctriar") {j++ #################################################### ## CTRIAx **FREE FORMAT** RECORD-PROCESSING SECTION #################################################### ## 1) REPLACE ADJACENT COMMAS IN ELEMENT REC ## BY TWO COMMAS SEPARATED BY A DUMMY STRING --- ## 2) REPLACE EACH COMMA IN THE *FREE-FORMAT* ## ELEMENT REC BY A BLANK. ## 3) PRINT THE CHANGED *FREE-FORMAT* ELEMENT REC. ## ASSUMPTION: ALL THE NEEDED DATA IS IN ONE REC. #################################################### if (RECfmt == "free") { gsub(/,,/,",0,") gsub(/,/," ") ## *FOR TESTING* -- introduce the generically-written *CTRIAx* data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - 'GENERIC' RECORD WRITTEN FOLLOWS." print "#DEBUG - Fmt-in="RECfmt" j="j print "#DEBUG - REC-OUT:" } print $0 next } ###################################################### ## END OF CTRIAx **FREE RECORD FORMAT** WRITE SECTION ###################################################### ########################################################### ## CTRIAx **SHORT-FIELD-FORMAT** RECORD-PROCESSING SECTION ########################################################### ## 1) GET FIELDS 1,2,3,4,5,6 OF THE NASTRAN ## *SHORT-FIELD-FORMAT* CTRIAx REC. ## [THE 4th,5th,6th FIELDS are 3 grid ids.] ## 2) PRINT THE CAPTURED FIELDS, SPACE-SEPARATED, in one rec. ########################################################### if (RECfmt == "short") { f1=substr($0,1,8) f2=substr($0,9,8) if (f2==" ") f2="0" f3=substr($0,17,8) if (f3==" ") f3="0" f4=substr($0,25,8) if (f4==" ") f4="0" f5=substr($0,33,8) if (f5==" ") f5="0" f6=substr($0,41,8) if (f6==" ") f6="0" ## *FOR TESTING* -- introduce the generically-written *CTRIAx* data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - 'GENERIC' RECORD WRITTEN FOLLOWS." print "#DEBUG - Fmt-in="RECfmt" j=element-count="j print "#DEBUG - f1=elname="f1" f2=elid="f2" f3=coordsys="f3 print "#DEBUG - f4=g1="f4" f5=g2="f5" f6=g3="f6 print "#DEBUG - REC-OUT:" } printf ("%s %s %s %s %s %s\n",f1,f2,f3,f4,f5,f6) next } ###################################################### ## END OF CTRIAx **SHORT-FIELD-FORMAT** WRITE SECTION ###################################################### ########################################################## ## CTRIAx **LONG-FIELD FORMAT** RECORD-PROCESSING SECTION ########################################################## ## 1) GET FIELDS 1,2,3,4,5,6 OF THE NASTRAN ## *LONG-FIELD-FORMAT* CTRIAx REC. ## [THE 4th,5th,6th FIELDS are 3 grid ids.] ## 2) PRINT THE CAPTURED FIELDS, SPACE-SEPARATED, in one rec. ########################################################### if (RECfmt == "long") { f1=substr($0,1,8) f2=substr($0,9,16) if (f2==" ") f2="0" f3=substr($0,25,16) if (f3==" ") f3="0" f4=substr($0,41,16) if (f4==" ") f4="0" f5=substr($0,57,16) if (f5==" ") f5="0" getline f6=substr($0,9,16) if (f6==" ") f6="0" ## *FOR TESTING* -- introduce the generically-written CTRIAx data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - 'GENERIC' RECORD WRITTEN FOLLOWS." print "#DEBUG - Fmt-in="RECfmt" j=element-count="j print "#DEBUG - f1=elname="f1" f2=elid="f2" f3=coordsys="f3 print "#DEBUG - f4=g1="f4" f5=g2="f5" f6=g3="f6 print "#DEBUG - REC-OUT:" } printf ("%s %s %s %s %s %s\n",f1,f2,f3,f4,f5,f6) next } ###################################################### ## END OF **LONG-FIELD RECORD FORMAT** WRITE SECTION ###################################################### } ######################################################################### ## END OF **CTRIAx** RECORD PROCESSING LOGIC. ######################################################################### ######################################################################### ## **CQUADx** RECORD PROCESSING LOGIC: ######################################################################### ## LOOK FOR *CQUAD4* or *CQUADR* or *CQUAD8* IN THE FIRST FIELD. ## INCREMENT THE CQUAD4-REC COUNT, j. ######################################################################### if ($0 ~ "^CQUAD4" || $0 ~ "^cquad4" || $0 ~ "^CQUADR" || $0 ~ "^cquadr" || \ $0 ~ "^CQUAD8" || $0 ~ "^cquad8" || $0 ~ "^CQUAD" || $0 ~ "^cquad") {j++ #################################################### ## CQUADx **FREE FORMAT** RECORD-PROCESSING SECTION #################################################### ## 1) REPLACE ADJACENT COMMAS IN ELEMENT REC ## BY TWO COMMAS SEPARATED BY A DUMMY STRING --- ## 2) REPLACE EACH COMMA IN THE *FREE-FORMAT* ## ELEMENT REC BY A BLANK. ## 3) PRINT THE CHANGED *FREE-FORMAT* ELEMENT REC. ## ASSUMPTION: ALL THE NEEDED DATA IS IN ONE REC. #################################################### if (RECfmt == "free") { gsub(/,,/,",0,") gsub(/,/," ") ## *FOR TESTING* -- introduce the generically-written *CQUADx* data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - 'GENERIC' RECORD WRITTEN FOLLOWS." print "#DEBUG - Fmt-in="RECfmt" j="j" rec="$0 print "#DEBUG - REC-OUT:" } print $0 next } ###################################################### ## END OF CQUADx **FREE RECORD FORMAT** WRITE SECTION ###################################################### ########################################################### ## CQUADx **SHORT-FIELD-FORMAT** RECORD-PROCESSING SECTION ########################################################### ## 1) GET FIELDS 1,2,3,4,5,6,7 OF THE NASTRAN ## *SHORT-FIELD-FORMAT* CQUADx REC. ## [THE 4th,5th,6th,7th FIELDS are 4 grid ids.] ## 2) PRINT THE CAPTURED FIELDS, SPACE-SEPARATED, in one rec. ########################################################### if (RECfmt == "short") { f1=substr($0,1,8) f2=substr($0,9,8) if (f2==" ") f2="0" f3=substr($0,17,8) if (f3==" ") f3="0" f4=substr($0,25,8) if (f4==" ") f4="0" f5=substr($0,33,8) if (f5==" ") f5="0" f6=substr($0,41,8) if (f6==" ") f6="0" f7=substr($0,49,8) if (f7==" ") f7="0" ## *FOR TESTING* -- introduce the generically-written *CQUADx* data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - 'GENERIC' RECORD WRITTEN FOLLOWS." print "#DEBUG - Fmt-in="RECfmt" j=element-count="j print "#DEBUG - f1=elname="f1" f2=elid="f2" f3=coordsys="f3 print "#DEBUG - f4=g1="f4" f5=g2="f5" f6=g3="f6" f7=g3="f7 print "#DEBUG - REC-OUT:" } printf ("%s %s %s %s %s %s %s\n",f1,f2,f3,f4,f5,f6,f7) next } ###################################################### ## END OF CQUADx **SHORT-FIELD-FORMAT** WRITE SECTION ###################################################### ########################################################## ## CQUADx **LONG-FIELD FORMAT** RECORD-PROCESSING SECTION ########################################################## ## 1) GET FIELDS 1,2,3,4,5,6,7 OF THE NASTRAN ## *LONG-FIELD-FORMAT* CQUADx REC. ## [THE 4th,5th,6th,7th FIELDS are 4 grid ids.] ## 2) PRINT THE CAPTURED FIELDS, SPACE-SEPARATED, in one rec. ########################################################### if (RECfmt == "long") { f1=substr($0,1,8) f2=substr($0,9,16) if (f2==" ") f2="0" f3=substr($0,25,16) if (f3==" ") f3="0" f4=substr($0,41,16) if (f4==" ") f4="0" f5=substr($0,57,16) if (f5==" ") f5="0" getline f6=substr($0,9,16) if (f6==" ") f6="0" f7=substr($0,25,16) if (f7==" ") f7="0" ## *FOR TESTING* -- introduce the generically-written CQUADx data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - 'GENERIC' RECORD WRITTEN FOLLOWS." print "#DEBUG - Fmt-in="RECfmt" j=element-count="j print "#DEBUG - f1=elname="f1" f2=elid="f2" f3=coordsys="f3 print "#DEBUG - f4=g1="f4" f5=g2="f5" f6=g3="f6" f7=g4="f7 print "#DEBUG - REC-OUT:" } printf ("%s %s %s %s %s %s %s\n",f1,f2,f3,f4,f5,f6,f7) next } ###################################################### ## END OF **LONG-FIELD RECORD FORMAT** WRITE SECTION ###################################################### } ######################################################################### ## END OF **CQUADx** RECORD PROCESSING LOGIC. ######################################################################### ######################################################################### ## **CTETRA** RECORD PROCESSING LOGIC: ######################################################################### ## LOOK FOR *CTETRA* IN THE FIRST FIELD. ## INCREMENT THE ELEMENT-REC COUNT, j. ######################################################################### if ($0 ~ "^CTETRA" || $0 ~ "^ctetra") {j++ #################################################### ## CTETRA **FREE FORMAT** RECORD-PROCESSING SECTION #################################################### ## 1) REPLACE ADJACENT COMMAS IN ELEMENT REC ## BY TWO COMMAS SEPARATED BY A DUMMY STRING --- ## 2) REPLACE EACH COMMA IN THE *FREE-FORMAT* ## ELEMENT REC BY A BLANK. ## 3) PRINT THE CHANGED *FREE-FORMAT* ELEMENT REC. ## ASSUMPTION: ALL THE NEEDED DATA IS IN ONE REC. #################################################### if (RECfmt == "free") { gsub(/,,/,",0,") gsub(/,/," ") ## *FOR TESTING* -- introduce the generically-written *CTETRA* data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - 'GENERIC' RECORD WRITTEN FOLLOWS." print "#DEBUG - Fmt-in="RECfmt" j="j" rec="$0 print "#DEBUG - REC-OUT:" } print $0 next } ###################################################### ## END OF CTETRA **FREE RECORD FORMAT** WRITE SECTION ###################################################### ########################################################### ## CTETRA **SHORT-FIELD-FORMAT** RECORD-PROCESSING SECTION ########################################################### ## 1) GET FIELDS 1,2,3,4,5,6,7 OF THE NASTRAN ## *SHORT-FIELD-FORMAT* CTETRA REC. ## [THE 4th,5th,6th,7th FIELDS are 4 grid ids.] ## 2) PRINT THE CAPTURED FIELDS, SPACE-SEPARATED, in one rec. ########################################################### if (RECfmt == "short") { f1=substr($0,1,8) f2=substr($0,9,8) if (f2==" ") f2="0" f3=substr($0,17,8) if (f3==" ") f3="0" f4=substr($0,25,8) if (f4==" ") f4="0" f5=substr($0,33,8) if (f5==" ") f5="0" f6=substr($0,41,8) if (f6==" ") f6="0" f7=substr($0,49,8) if (f7==" ") f7="0" ## *FOR TESTING* -- introduce the generically-written *CTETRA* data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - 'GENERIC' RECORD WRITTEN FOLLOWS." print "#DEBUG - Fmt-in="RECfmt" j=element-count="j print "#DEBUG - f1=elname="f1" f2=elid="f2" f3=coordsys="f3 print "#DEBUG - f4=g1="f4" f5=g2="f5" f6=g3="f6" f7=g3="f7 print "#DEBUG - REC-OUT:" } printf ("%s %s %s %s %s %s %s\n",f1,f2,f3,f4,f5,f6,f7) next } ###################################################### ## END OF CTETRA **SHORT-FIELD-FORMAT** WRITE SECTION ###################################################### ########################################################## ## CTETRA **LONG-FIELD FORMAT** RECORD-PROCESSING SECTION ########################################################## ## 1) GET FIELDS 1,2,3,4,5,6,7 OF THE NASTRAN ## *LONG-FIELD-FORMAT* CTETRA REC. ## [THE 4th,5th,6th,7th FIELDS are 4 grid ids.] ## 2) PRINT THE CAPTURED FIELDS, SPACE-SEPARATED, in one rec. ########################################################### if (RECfmt == "long") { f1=substr($0,1,8) f2=substr($0,9,16) if (f2==" ") f2="0" f3=substr($0,25,16) if (f3==" ") f3="0" f4=substr($0,41,16) if (f4==" ") f4="0" f5=substr($0,57,16) if (f5==" ") f5="0" getline f6=substr($0,9,16) if (f6==" ") f6="0" f7=substr($0,25,16) if (f7==" ") f7="0" ## *FOR TESTING* -- introduce the generically-written *CTETRA* data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - 'GENERIC' RECORD WRITTEN FOLLOWS." print "#DEBUG - Fmt-in="RECfmt" j=element-count="j print "#DEBUG - f1=elname="f1" f2=elid="f2" f3=coordsys="f3 print "#DEBUG - f4=g1="f4" f5=g2="f5" f6=g3="f6" f7=g3="f7 print "#DEBUG - REC-OUT:" } printf ("%s %s %s %s %s %s %s\n",f1,f2,f3,f4,f5,f6,f7) next } ###################################################### ## END OF **LONG-FIELD RECORD FORMAT** WRITE SECTION ###################################################### } ######################################################################### ## END OF **CTETRA** RECORD PROCESSING LOGIC. ######################################################################### ######################################################################### ## **CHEXA** RECORD PROCESSING LOGIC: ######################################################################### ## LOOK FOR *CHEXA* IN THE FIRST FIELD. ## INCREMENT THE CHEXA-REC COUNT, j. ######################################################################### if ($0 ~ "^CHEXA" || $0 ~ "^chexa") {j++ #################################################### ## CHEXA **FREE FORMAT** RECORD-PROCESSING SECTION #################################################### ## 1) REPLACE ADJACENT COMMAS IN ELEMENT REC ## BY TWO COMMAS SEPARATED BY A DUMMY STRING --- ## 2) REPLACE EACH COMMA IN THE *FREE-FORMAT* ## ELEMENT REC BY A BLANK. ## 3) PRINT THE CHANGED *FREE-FORMAT* ELEMENT REC. #################################################### if (RECfmt == "free") { gsub(/,,/,",0,") gsub(/,/," ") temp1=$1; temp2=$2; temp3=$3; temp4=$4; temp5=$5 temp6=$6; temp7=$7; temp8=$8; temp9=$9 getline gsub(/,,/,",0,") gsub(/,/," ") temp10=$2; temp11=$3 ## *FOR TESTING* -- introduce the generically-written *CHEXA* data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - 'GENERIC' RECORD WRITTEN FOLLOWS." print "#DEBUG - Fmt-in="RECfmt" j="j" rec="$0 print "#DEBUG - REC-OUT:" } print temp1" "temp2" "temp3" "temp4" "temp5" "temp6" "temp7" "temp8" "temp9" "temp10" "temp11 next } ###################################################### ## END OF CHEXA **FREE RECORD FORMAT** WRITE SECTION ###################################################### ########################################################### ## CHEXA **SHORT-FIELD-FORMAT** RECORD-PROCESSING SECTION ########################################################### ## 1) GET FIELDS 1,2,3,4,5,6,7,8,9 OF THE NASTRAN ## *SHORT-FIELD-FORMAT* CHEXA REC -- ## AND FIELDS 2,3 OF AN EXPECTED CONTINUATION REC. ## [THE 4th,5th,6th,7th,8th,9th FIELDS of 1st rec ## are 6 of 8 grid ids.] ## 2) PRINT THE CAPTURED FIELDS, SPACE-SEPARATED, in one rec. ########################################################### if (RECfmt == "short") { f1=substr($0,1,8) f2=substr($0,9,8) if (f2==" ") f2="0" f3=substr($0,17,8) if (f3==" ") f3="0" f4=substr($0,25,8) if (f4==" ") f4="0" f5=substr($0,33,8) if (f5==" ") f5="0" f6=substr($0,41,8) if (f6==" ") f6="0" f7=substr($0,49,8) if (f7==" ") f7="0" f8=substr($0,57,8) if (f8==" ") f8="0" f9=substr($0,65,8) if (f9==" ") f9="0" getline f10=substr($0,9,8) if (f10==" ") f10="0" f11=substr($0,17,8) if (f11==" ") f11="0" ## *FOR TESTING* -- introduce the generically-written *CHEXA* data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - 'GENERIC' RECORD WRITTEN FOLLOWS." print "#DEBUG - Fmt-in="RECfmt" j=element-count="j print "#DEBUG - f1=elname="f1" f2=elid="f2" f3=coordsys="f3 print "#DEBUG - f4=g1="f4" f5=g2="f5" f6=g3="f6" f7=g4="f7 print "#DEBUG - f8=g5="f8" f9=g6="f9" f10=g7="f10" f11=g8="f11 print "#DEBUG - REC-OUT:" } printf ("%s %s %s %s %s %s %s %s %s %s %s\n",f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11) next } ###################################################### ## END OF CHEXA **SHORT-FIELD-FORMAT** WRITE SECTION ###################################################### ########################################################## ## CHEXA **LONG-FIELD FORMAT** RECORD-PROCESSING SECTION ########################################################## ## 1) GET FIELDS 1,2,3,4,5 OF THE NASTRAN ## *LONG-FIELD-FORMAT* CHEXA REC --- ## AND FIELDS 2,3,4,5 OF AN EXPECTED CONTINUATION REC ## --- AND FIELDS 2,3 OF 2nd EXPECTED CONTINUATION REC. ## ## [THE 4th,5th FIELDS of 1st rec are 1,2 of 8 grid ids, ## AND FIELDS 2,3,4,5 OF 1st EXPECTED CONTINUATION REC ## are 3,4,5,6 of 8 grid ids, and FIELDS 2,3 OF THE ## 2nd EXPECTED CONTINUATION REC are 7,8 of 8 grid ids.] ## 2) PRINT THE CAPTURED FIELDS, SPACE-SEPARATED, in one rec. ########################################################### if (RECfmt == "long") { f1=substr($0,1,8) f2=substr($0,9,16) if (f2==" ") f2="0" f3=substr($0,25,16) if (f3==" ") f3="0" f4=substr($0,41,16) if (f4==" ") f4="0" f5=substr($0,57,16) if (f5==" ") f5="0" getline f6=substr($0,9,16) if (f6==" ") f6="0" f7=substr($0,9,16) if (f7==" ") f7="0" f8=substr($0,9,16) if (f8==" ") f8="0" f9=substr($0,9,16) if (f9==" ") f9="0" getline f10=substr($0,9,16) if (f10==" ") f10="0" f11=substr($0,9,16) if (f11==" ") f11="0" ## *FOR TESTING* -- introduce the generically-written CHEXA data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - 'GENERIC' RECORD WRITTEN FOLLOWS." print "#DEBUG - Fmt-in="RECfmt" j=element-count="j print "#DEBUG - f1=elname="f1" f2=elid="f2" f3=coordsys="f3 print "#DEBUG - f4=g1="f4" f5=g2="f5" f6=g3="f6" f7=g4="f7 print "#DEBUG - f8=g5="f8" f9=g6="f9" f10=g7="f10" f11=g8="f11 print "#DEBUG - REC-OUT:" } printf ("%s %s %s %s %s %s %s %s %s %s %s\n",f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11) next } ###################################################### ## END OF **LONG-FIELD RECORD FORMAT** WRITE SECTION ###################################################### } ######################################################################### ## END OF **CHEXA** RECORD PROCESSING LOGIC. ######################################################################### ########################################################################## ## **CPENTA** RECORD PROCESSING LOGIC: ########################################################################## ## LOOK FOR *CPENTA* IN THE FIRST FIELD. ## INCREMENT THE CPENTA-REC COUNT, j. ########################################################################## if ($0 ~ "^CPENTA" || $0 ~ "^cpenta") {j++ #################################################### ## CPENTA **FREE FORMAT** RECORD-PROCESSING SECTION #################################################### ## 1) REPLACE ADJACENT COMMAS IN ELEMENT REC ## BY TWO COMMAS SEPARATED BY A DUMMY STRING --- ## 2) REPLACE EACH COMMA IN THE *FREE-FORMAT* ## ELEMENT REC BY A BLANK. ## 3) PRINT THE CHANGED *FREE-FORMAT* ELEMENT REC. #################################################### if (RECfmt == "free") { gsub(/,,/,",0,") gsub(/,/," ") ## *FOR TESTING* -- introduce the generically-written CPENTA data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - 'GENERIC' RECORD WRITTEN FOLLOWS." print "#DEBUG - Fmt-in="RECfmt" j="j" rec="$0 print "#DEBUG - REC-OUT:" } print $0 next } ###################################################### ## END OF CPENTA **FREE RECORD FORMAT** WRITE SECTION ###################################################### ########################################################### ## CPENTA **SHORT-FIELD-FORMAT** RECORD-PROCESSING SECTION ########################################################### ## 1) GET FIELDS 1,2,3,4,5,6,7,8,9 OF THE NASTRAN ## *SHORT-FIELD-FORMAT* CPENTA REC. ## NO FIELDS NEEDED FROM A CONTINUATION REC, IF ANY. ## 2) PRINT THE CAPTURED 9 FIELDS, SPACE-SEPARATED, in one rec. ########################################################### if (RECfmt == "short") { f1=substr($0,1,8) f2=substr($0,9,8) if (f2==" ") f2="0" f3=substr($0,17,8) if (f3==" ") f3="0" f4=substr($0,25,8) if (f4==" ") f4="0" f5=substr($0,33,8) if (f5==" ") f5="0" f6=substr($0,41,8) if (f6==" ") f6="0" f7=substr($0,49,8) if (f7==" ") f7="0" f8=substr($0,57,8) if (f8==" ") f8="0" f9=substr($0,65,8) if (f9==" ") f9="0" ## *FOR TESTING* -- introduce the generically-written *CPENTA* data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - 'GENERIC' RECORD WRITTEN FOLLOWS." print "#DEBUG - Fmt-in="RECfmt" j=element-count="j print "#DEBUG - f1=elname="f1" f2=elid="f2" f3=coordsys="f3 print "#DEBUG - f4=g1="f4" f5=g2="f5" f6=g3="f6 print "#DEBUG - f7=g4="f7" f8=g5="f8" f9=g6="f9 print "#DEBUG - REC-OUT:" } printf ("%s %s %s %s %s %s %s %s %s\n",f1,f2,f3,f4,f5,f6,f7,f8,f9) next } ###################################################### ## END OF CPENTA **SHORT-FIELD-FORMAT** WRITE SECTION ###################################################### ########################################################## ## CPENTA **LONG-FIELD FORMAT** RECORD-PROCESSING SECTION ########################################################## ## 1) GET FIELDS 1,2,3,4,5 OF THE NASTRAN ## *LONG-FIELD-FORMAT* CPENTA REC --- ## AND FIELDS 2,3,4,5 OF AN EXPECTED CONTINUATION REC. ## ## [THE 4th,5th FIELDS of 1st rec are 1,2 of 6 grid ids, ## AND FIELDS 2,3,4,5 OF 1st EXPECTED CONTINUATION REC ## are 3,4,5,6 of 6 grid ids.] ## 2) PRINT THE CAPTURED FIELDS, SPACE-SEPARATED, in one rec. ########################################################### if (RECfmt == "long") { f1=substr($0,1,8) f2=substr($0,9,16) if (f2==" ") f2="0" f3=substr($0,25,16) if (f3==" ") f3="0" f4=substr($0,41,16) if (f4==" ") f4="0" f5=substr($0,57,16) if (f5==" ") f5="0" getline f6=substr($0,9,16) if (f6==" ") f6="0" f7=substr($0,9,16) if (f7==" ") f7="0" f8=substr($0,9,16) if (f8==" ") f8="0" f9=substr($0,9,16) if (f9==" ") f9="0" ## *FOR TESTING* -- introduce the generically-written CPENTA data: if (DEBUG==1) { print "#DEBUG" print "#DEBUG - 'GENERIC' RECORD WRITTEN FOLLOWS." print "#DEBUG - Fmt-in="RECfmt" j=element-count="j print "#DEBUG - f1=elname="f1" f2=elid="f2" f3=coordsys="f3 print "#DEBUG - f4=g1="f4" f5=g2="f5" f6=g3="f6 print "#DEBUG - f7=g4="f7" f8=g5="f8" f9=g6="f9 print "#DEBUG - REC-OUT:" } printf ("%s %s %s %s %s %s %s %s %s\n",f1,f2,f3,f4,f5,f6,f7,f8,f9) next } ###################################################### ## END OF **LONG-FIELD RECORD FORMAT** WRITE SECTION ###################################################### } ######################################################################### ## END OF **CPENTA** RECORD PROCESSING LOGIC. ######################################################################### } END { printf ("#\n") printf ("# Created via $FEDIR/scripts/feinp_nas2freeform_elinfo\n") printf ("# Total number of GRID recs encountered: %12d\n",i) printf ("# Total number of ELEMENT recs put in this file: %12d\n",j) }