void ImplicitList::extractFullMatrix(T *_pT)
{
typename T::type tStart = static_cast<typename T::type>(convert_input(m_poStart));
typename T::type tStep = static_cast<typename T::type>(convert_input(m_poStep));
typename T::type* p = _pT->get();
for (int i = 0 ; i < m_iSize ; i++)
{
p[i] = tStart + i * tStep;
}
}
void rnalib_init(toptions *opts, tsequence *seq)
{
/* initialize input and pairing tables */
z = seq->seq - 1;
n = seq->length;
convert_input(1, z, n);
init_canPair();
init_canStackPair();
/* initialize energies */
init_stack_dg();
init_hl_ent_ar();
init_tstackh_dg();
init_hl_tetra();
init_bl_ent_ar();
init_il_ent_ar();
init_tstacki_dg();
init_dr_dangle_dg();
init_dl_dangle_dg();
init_termaupenalty_ar();
init_intloop11();
init_intloop21();
init_intloop22();
init_scale_ar();
}
/* used in window-mode to shift the input sequence */
void shift_input(toptions *opts, tsequence *seq, char output){
int i;
/* printf("window_pos: %d\n", opts->window_pos); */
/* printf("window_size: %d\n", opts->window_size); */
/* printf("seq->seq: %s\n", seq->seq); */
/* printf("seq->original_seq: %s\n", seq->original_seq); */
for (i=opts->window_pos; i<=opts->window_pos + opts->window_size; i++)
seq->seq[i-opts->window_pos] = seq->original_seq[i];
if (number_of_graphics) {
for (i=opts->window_pos; i<=opts->window_pos + opts->window_size; i++)
graphics_sequence[i-opts->window_pos] = seq->original_seq[i];
graphics_sequence[strlen(seq->seq)] = 0;
}
convert_input(0, seq->seq, opts->window_size);
if (output) print_sequence(opts, seq, opts->window_pos, opts->window_size);
}
int
main(int argc, char **argv)
{
int c;
int i;
struct pshell *psh;
struct pbar *pbp;
struct wmember head;
struct wmember all_head;
char *nastran_file = "Converted from NASTRAN file (stdin)";
bu_setprogname(argv[0]);
fpin = stdin;
units = INCHES;
/* FIXME: These need to be improved */
tol.magic = BN_TOL_MAGIC;
tol.dist = 0.0005;
tol.dist_sq = tol.dist * tol.dist;
tol.perp = 1e-6;
tol.para = 1 - tol.perp;
while ((c=bu_getopt(argc, argv, "x:X:t:ni:o:mh?")) != -1) {
switch (c) {
case 'x':
sscanf(bu_optarg, "%x", (unsigned int *)&RTG.debug);
bu_printb("librt RT_G_DEBUG", RT_G_DEBUG, DEBUG_FORMAT);
bu_log("\n");
break;
case 'X':
sscanf(bu_optarg, "%x", (unsigned int *)&RTG.NMG_debug);
bu_printb("librt RTG.NMG_debug", RTG.NMG_debug, NMG_DEBUG_FORMAT);
bu_log("\n");
break;
case 't': /* calculational tolerance */
tol.dist = atof(bu_optarg);
tol.dist_sq = tol.dist * tol.dist;
break;
case 'n':
polysolids = 0;
break;
case 'm':
units = MM;
break;
case 'i':
fpin = fopen(bu_optarg, "rb");
if (fpin == (FILE *)NULL) {
bu_log("Cannot open NASTRAN file (%s) for reading!\n", bu_optarg);
bu_exit(1, Usage, argv[0]);
}
nastran_file = bu_optarg;
break;
case 'o':
output_file = bu_optarg;
break;
default:
bu_exit(1, Usage, argv[0]);
}
}
fpout = wdb_fopen(output_file);
if (fpout == NULL) {
bu_log("Cannot open BRL-CAD file (%s) for writing!\n", output_file);
bu_exit(1, Usage, argv[0]);
}
if (!fpin || !fpout) {
bu_exit(1, Usage, argv[0]);
}
line = (char *)bu_malloc(MAX_LINE_SIZE, "line");
next_line = (char *)bu_malloc(MAX_LINE_SIZE, "next_line");
prev_line = (char *)bu_malloc(MAX_LINE_SIZE, "prev_line");
curr_rec = (char **)bu_calloc(NO_OF_FIELDS, sizeof(char *), "curr_rec");
for (i=0; i<NO_OF_FIELDS; i++)
curr_rec[i] = (char *)bu_malloc(sizeof(char)*FIELD_LENGTH, "curr_rec[i]");
prev_rec = (char **)bu_calloc(NO_OF_FIELDS, sizeof(char *), "prev_rec");
for (i=0; i<NO_OF_FIELDS; i++)
prev_rec[i] = (char *)bu_malloc(sizeof(char)*FIELD_LENGTH, "prev_rec[i]");
/* first pass, find start of NASTRAN "bulk data" */
start_off = (-1);
bulk_data_start_line = 0;
while (bu_fgets(line, MAX_LINE_SIZE, fpin)) {
bulk_data_start_line++;
if (bu_strncmp(line, "BEGIN BULK", 10))
continue;
start_off = bu_ftell(fpin);
break;
}
if (start_off < 0) {
bu_log("Cannot find start of bulk data in NASTRAN file!\n");
bu_exit(1, Usage, argv[0]);
}
/* convert BULK data deck into something reasonable */
fptmp = bu_temp_file(NULL, 0);
if (fptmp == NULL) {
perror(argv[0]);
bu_exit(1, "Cannot open temporary file\n");
}
convert_input();
/* initialize some lists */
BU_LIST_INIT(&coord_head.l);
BU_LIST_INIT(&pbar_head.l);
BU_LIST_INIT(&pshell_head.l);
BU_LIST_INIT(&all_head.l);
nmg_model = (struct model *)NULL;
/* count grid points */
bu_fseek(fptmp, 0, SEEK_SET);
while (bu_fgets(line, MAX_LINE_SIZE, fptmp)) {
if (!bu_strncmp(line, "GRID", 4))
grid_count++;
}
if (!grid_count) {
bu_exit(1, "No geometry in this NASTRAN file!\n");
}
/* get default values and properties */
bu_fseek(fptmp, 0, SEEK_SET);
while (get_next_record(fptmp, 1, 0)) {
if (!bu_strncmp(curr_rec[0], "BAROR", 5)) {
/* get BAR defaults */
bar_def_pid = atoi(curr_rec[2]);
} else if (!bu_strncmp(curr_rec[0], "PBAR", 4)) {
struct pbar *pb;
BU_ALLOC(pb, struct pbar);
pb->pid = atoi(curr_rec[1]);
pb->mid = atoi(curr_rec[2]);
pb->area = atof(curr_rec[3]);
BU_LIST_INIT(&pb->head.l);
BU_LIST_INSERT(&pbar_head.l, &pb->l);
} else if (!bu_strncmp(curr_rec[0], "PSHELL", 6)) {
BU_ALLOC(psh, struct pshell);
psh->s = (struct shell *)NULL;
psh->pid = atoi(curr_rec[1]);
psh->mid = atoi(curr_rec[2]);
psh->thick = atof(curr_rec[3]);
BU_LIST_INSERT(&pshell_head.l, &psh->l);
pshell_count++;
}
}
/* allocate storage for grid points */
g_pts = (struct grid_point *)bu_calloc(grid_count, sizeof(struct grid_point), "grid points");
/* get all grid points */
bu_fseek(fptmp, 0, SEEK_SET);
while (get_next_record(fptmp, 1, 0)) {
int gid;
int cid;
double tmp[3];
if (bu_strncmp(curr_rec[0], "GRID", 4))
continue;
gid = atoi(curr_rec[1]);
cid = atoi(curr_rec[2]);
for (i=0; i<3; i++) {
tmp[i] = atof(curr_rec[i+3]);
}
g_pts[grid_used].gid = gid;
g_pts[grid_used].cid = cid;
g_pts[grid_used].v = (struct vertex **)bu_calloc(pshell_count + 1, sizeof(struct vertex *), "g_pts vertex array");
VMOVE(g_pts[grid_used].pt, tmp);
grid_used++;
}
/* find coordinate systems */
bu_fseek(fptmp, 0, SEEK_SET);
while (get_next_record(fptmp, 1, 0)) {
if (bu_strncmp(curr_rec[0], "CORD", 4))
continue;
get_coord_sys();
}
/* convert everything to BRL-CAD coordinate system */
i = 0;
while (convert_all_cs() || convert_all_pts()) {
i++;
if (i > 10) {
bu_exit(1, "Cannot convert to default coordinate system, check for circular definition\n");
}
}
mk_id(fpout, nastran_file);
/* get elements */
bu_fseek(fptmp, 0, SEEK_SET);
while (get_next_record(fptmp, 1, 0)) {
if (!bu_strncmp(curr_rec[0], "CBAR", 4))
get_cbar();
else if (!bu_strncmp(curr_rec[0], "CROD", 4))
get_cbar();
else if (!bu_strncmp(curr_rec[0], "CTRIA3", 6))
get_ctria3();
else if (!bu_strncmp(curr_rec[0], "CQUAD4", 6))
get_cquad4();
}
if (nmg_model) {
nmg_rebound(nmg_model, &tol);
if (polysolids)
mk_bot_from_nmg(fpout, "pshell.0", nmg_shell);
else
mk_nmg(fpout, "pshell.0", nmg_model);
}
BU_LIST_INIT(&head.l);
for (BU_LIST_FOR(psh, pshell, &pshell_head.l)) {
struct model *m;
char name[NAMESIZE+1];
if (!psh->s)
continue;
m = nmg_find_model(&psh->s->l.magic);
nmg_rebound(m, &tol);
nmg_fix_normals(psh->s, &tol);
if (psh->thick > tol.dist) {
nmg_model_face_fuse(m, &tol);
nmg_hollow_shell(psh->s, psh->thick*conv[units], 1, &tol);
}
sprintf(name, "pshell.%d", psh->pid);
if (polysolids)
mk_bot_from_nmg(fpout, name, psh->s);
else
mk_nmg(fpout, name, m);
mk_addmember(name, &head.l, NULL, WMOP_UNION);
}
if (BU_LIST_NON_EMPTY(&head.l)) {
mk_lfcomb(fpout, "shells", &head, 0);
mk_addmember("shells", &all_head.l, NULL, WMOP_UNION);
}
BU_LIST_INIT(&head.l);
for (BU_LIST_FOR(pbp, pbar, &pbar_head.l)) {
char name[NAMESIZE+1];
if (BU_LIST_IS_EMPTY(&pbp->head.l))
continue;
sprintf(name, "pbar_group.%d", pbp->pid);
mk_lfcomb(fpout, name, &pbp->head, 0);
mk_addmember(name, &head.l, NULL, WMOP_UNION);
}
if (BU_LIST_NON_EMPTY(&head.l)) {
mk_lfcomb(fpout, "pbars", &head, 0);
mk_addmember("pbars", &all_head.l, NULL, WMOP_UNION);
}
if (BU_LIST_NON_EMPTY(&all_head.l)) {
mk_lfcomb(fpout, "all", &all_head, 0);
}
wdb_close(fpout);
return 0;
}
void ImplicitList::extractValueAsInteger(int _iOccur, T* val)
{
val->get()[0] = static_cast<typename T::type>(convert_input(m_poStart)) +
_iOccur * static_cast<typename T::type>(convert_input(m_poStep));
}
bool ImplicitList::compute()
{
if (m_bComputed == true)
{
return true;
}
m_iSize = -1;
if (isComputable() == true)
{
m_iSize = 0;
if (m_eOutType == ScilabDouble)
{
m_pDblStart = m_poStart->getAs<Double>();
double dblStart = m_pDblStart->get(0);
m_pDblStep = m_poStep->getAs<Double>();
double dblStep = m_pDblStep->get(0);
m_pDblEnd = m_poEnd->getAs<Double>();
double dblEnd = m_pDblEnd->get(0);
// othe way to compute
// nan value
if (ISNAN(dblStart) || ISNAN(dblStep) || ISNAN(dblEnd))
{
m_iSize = -1;
m_bComputed = true;
return true;
}
// no finite values
if ( finite(dblStart) == 0 || finite(dblStep) == 0 || finite(dblEnd) == 0)
{
if ((dblStep > 0 && dblStart < dblEnd) ||
(dblStep < 0 && dblStart > dblEnd))
{
// return nan
m_iSize = -1;
}
// else return []
m_bComputed = true;
return true;
}
// step null
if (dblStep == 0) // return []
{
m_bComputed = true;
return true;
}
double dblVal = dblStart; // temp value
double dblEps = NumericConstants::eps;
double dblPrec = 2 * std::max(fabs(dblStart), fabs(dblEnd)) * dblEps;
while (dblStep * (dblVal - dblEnd) <= 0)
{
m_iSize++;
dblVal = dblStart + m_iSize * dblStep;
}
if (fabs(dblVal - dblEnd) < dblPrec)
{
m_iSize++;
}
}
else //m_eOutType == ScilabInt
{
if (m_eOutType == ScilabInt8 ||
m_eOutType == ScilabInt16 ||
m_eOutType == ScilabInt32 ||
m_eOutType == ScilabInt64)
{
//signed
long long llStart = convert_input(m_poStart);
long long llStep = convert_input(m_poStep);
long long llEnd = convert_input(m_poEnd);
#ifdef _MSC_VER
m_iSize = static_cast<int>(floor( static_cast<double>(_abs64(llEnd - llStart) / _abs64(llStep)) )) + 1;
#else
m_iSize = static_cast<int>(floor( static_cast<double>(llabs(llEnd - llStart) / llabs(llStep)) )) + 1;
#endif
}
else
{
//unsigned
unsigned long long ullStart = convert_unsigned_input(m_poStart);
unsigned long long ullStep = convert_unsigned_input(m_poStep);
unsigned long long ullEnd = convert_unsigned_input(m_poEnd);
#ifdef _MSC_VER
m_iSize = static_cast<int>(floor(static_cast<double>(_abs64(ullEnd - ullStart) / _abs64(ullStep)) )) + 1;
#else
m_iSize = static_cast<int>(floor(static_cast<double>(llabs(ullEnd - ullStart) / llabs(ullStep)) )) + 1;
#endif
}
}
m_bComputed = true;
return true;
}
else
{
return false;
}
}
